blob: 48f69f7c5839d6fe14793394819b0c8d80fbf21a [file] [log] [blame]
// Copyright 2015 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef COBALT_CSSOM_CSS_TRANSITION_SET_H_
#define COBALT_CSSOM_CSS_TRANSITION_SET_H_
#include <map>
#include "base/basictypes.h"
#include "base/optional.h"
#include "base/time/time.h"
#include "cobalt/cssom/css_transition.h"
#include "cobalt/cssom/property_definitions.h"
namespace cobalt {
namespace cssom {
class CSSComputedStyleData;
class PropertyValue;
// Maintains a mapping from the set of all unique CSS style properties to
// active transitions. Not all style properties may have active transitions.
// This class is used to maintain persistance of active transitions and is
// expected to be modified over time as events such as CSS style modifications
// occur.
class TransitionSet {
public:
// An EventHandler object can be supplied to the TransitionSet upon
// construction to have TransitionSet update a caller as it internally updates
// its set of active transitions on each call to UpdateTransitions(). This
// is useful as it can provide an external observer (e.g. such as an adapter
// from CSS Transitions to the Web Animations API) the opportunity to take
// action based on transition start/end events.
class EventHandler {
public:
virtual ~EventHandler() {}
// Called when a transition is starting, either freshly introduced or
// replacing an existing transition.
virtual void OnTransitionStarted(const Transition& transition,
TransitionSet* transition_set) = 0;
// Called when a transition is removed, either because it has finished, or
// because it was replaced (in which case OnTransitionStarted() will be
// called with the replacement immediately after this).
virtual void OnTransitionRemoved(const Transition& transition,
Transition::IsCanceled is_canceled) = 0;
};
explicit TransitionSet(EventHandler* event_handler = NULL);
// Helper function to get a const reference to a global empty transition set.
static const TransitionSet* EmptyTransitionSet();
// Given a source and destination CSS Style Declarations (presumably applied
// to an HTML element), updates all current transitions to reflect the new
// state. This may mean removing transitions that were canceled or
// completed, updating existing transitions with new values, or creating new
// transitions. The implementation of this method is defined here:
// https://www.w3.org/TR/2013/WD-css3-transitions-20131119/#starting
void UpdateTransitions(const base::TimeDelta& current_time,
const CSSComputedStyleData& source,
const CSSComputedStyleData& destination);
// Given the name of a property, returns the active transition corresponding
// to it. If no transition currently exists for this property, this method
// returns NULL.
const Transition* GetTransitionForProperty(PropertyKey property) const;
// Returns true if there are no animations in this animation set.
bool empty() const { return transitions_.IsEmpty(); }
// Clears out all currently running transitions.
void Clear();
private:
void UpdateTransitionForProperty(
PropertyKey property, const base::TimeDelta& current_time,
const scoped_refptr<PropertyValue>& source_value,
const scoped_refptr<PropertyValue>& destination_value,
const CSSComputedStyleData& transition_style);
// We define a TransitionMap (from CSS property to Transition object) here to
// host our set of active transitions, and additionally manage the firing
// of transition begin/end events.
class TransitionMap {
public:
explicit TransitionMap(EventHandler* event_handler);
~TransitionMap();
const Transition* GetTransitionForProperty(PropertyKey property) const;
bool IsEmpty() const { return transitions_.empty(); }
// Adds or replaces an existing transition in the map.
void UpdateTransitionForProperty(PropertyKey property,
const Transition& transition,
cssom::TransitionSet* transition_set);
// Removes an existing transition from the map if it exists.
void RemoveTransitionForPropertyIfExists(
PropertyKey property, Transition::IsCanceled is_canceled);
// Clears all entries from the map, as if RemoveTransitionForProperty()
// had been called on each property.
void Clear();
typedef std::map<PropertyKey, Transition> InternalTransitionMap;
const InternalTransitionMap& GetInternalMap() const { return transitions_; }
private:
EventHandler* event_handler_;
InternalTransitionMap transitions_;
};
TransitionMap transitions_;
DISALLOW_COPY_AND_ASSIGN(TransitionSet);
};
} // namespace cssom
} // namespace cobalt
#endif // COBALT_CSSOM_CSS_TRANSITION_SET_H_