def __init__(self, log):
self.log = log
self.clip_property_trackers = {}
self.interpolator_keyframe_trackers = {}
self.effect_properties_tracker = EffectGstElementPropertyChangeTracker(log)
self._pipeline = None
class TimelineLogObserver(object):
timelinePropertyChangedAction = ClipPropertyChanged
ClipAddedAction = ClipAdded
ClipRemovedAction = ClipRemoved
effectAddAction = EffectAdded
effectRemovedAction = EffectRemoved
interpolatorKeyframeAddedAction = InterpolatorKeyframeAdded
interpolatorKeyframeRemovedAction = InterpolatorKeyframeRemoved
interpolatorKeyframeChangedAction = InterpolatorKeyframeChanged
activePropertyChangedAction = ActivePropertyChanged
def __init__(self, log):
self.log = log
self.clip_property_trackers = {}
self.interpolator_keyframe_trackers = {}
self.effect_properties_tracker = EffectGstElementPropertyChangeTracker(log)
self._pipeline = None
def setPipeline(self, pipeline):
self._pipeline = pipeline
self.effect_properties_tracker.pipeline = pipeline
def getPipeline(self):
return self._pipeline
pipeline = property(getPipeline, setPipeline)
def startObserving(self, timeline):
self._connectToTimeline(timeline)
for layer in timeline.get_layers():
for clip in layer.get_clips():
self._connectToClip(clip)
for track_element in clip.track_elements:
self._connectToTrackElement(track_element)
def stopObserving(self, timeline):
self._disconnectFromTimeline(timeline)
for clip in timeline.clips:
self._disconnectFromClip(clip)
for track_element in clip.track_elements:
self._disconnectFromTrackElement(track_element)
def _connectToTimeline(self, timeline):
for layer in timeline.get_layers():
layer.connect("clip-added", self._clipAddedCb)
layer.connect("clip-removed", self._clipRemovedCb)
def _disconnectFromTimeline(self, timeline):
timeline.disconnect_by_func(self._clipAddedCb)
timeline.disconnect_by_func(self._clipRemovedCb)
def _connectToClip(self, clip):
tracker = ClipPropertyChangeTracker()
tracker.connectToObject(clip)
for property_name in tracker.property_names:
tracker.connect("notify::" + property_name, self._clipPropertyChangedCb, property_name)
self.clip_property_trackers[clip] = tracker
clip.connect("track-element-added", self._clipTrackElementAddedCb)
clip.connect("track-element-removed", self._clipTrackElementRemovedCb)
for element in clip.get_track_elements():
self._connectToTrackElement(element)
def _disconnectFromClip(self, clip):
tracker = self.clip_property_trackers.pop(clip)
tracker.disconnectFromObject(clip)
tracker.disconnect_by_func(self._clipPropertyChangedCb)
def _connectToTrackElement(self, track_element):
# FIXME: keyframes are disabled:
# for prop, interpolator in track_element.getInterpolators().itervalues():
# self._connectToInterpolator(interpolator)
if isinstance(track_element, GES.BaseEffect):
self.effect_properties_tracker.addEffectElement(track_element.getElement())
def _disconnectFromTrackElement(self, track_element):
for prop, interpolator in track_element.getInterpolators().itervalues():
self._disconnectFromInterpolator(interpolator)
def _connectToInterpolator(self, interpolator):
interpolator.connect("keyframe-added", self._interpolatorKeyframeAddedCb)
interpolator.connect("keyframe-removed", self._interpolatorKeyframeRemovedCb)
tracker = KeyframeChangeTracker()
tracker.connectToObject(interpolator)
tracker.connect("keyframe-moved", self._interpolatorKeyframeMovedCb)
self.interpolator_keyframe_trackers[interpolator] = tracker
def _disconnectFromInterpolator(self, interpolator):
tracker = self.interpolator_keyframe_trackers.pop(interpolator)
tracker.disconnectFromObject(interpolator)
tracker.disconnect_by_func(self._interpolatorKeyframeMovedCb)
def _clipAddedCb(self, timeline, clip):
self._connectToClip(clip)
action = self.ClipAddedAction(timeline, clip)
self.log.push(action)
def _clipRemovedCb(self, timeline, clip):
self._disconnectFromClip(clip)
action = self.ClipRemovedAction(timeline, clip)
self.log.push(action)
def _clipPropertyChangedCb(self, tracker, clip, old_value, new_value, property_name):
action = self.timelinePropertyChangedAction(clip, property_name, old_value, new_value)
self.log.push(action)
def _clipTrackElementAddedCb(self, clip, track_element):
if isinstance(track_element, GES.BaseEffect):
action = self.effectAddAction(clip, track_element, self.effect_properties_tracker)
# We use the action instead of the track element
# because the track_element changes when redoing
track_element.connect("active-changed", self._trackElementActiveChangedCb, action)
self.log.push(action)
element = track_element.getElement()
if element:
self.effect_properties_tracker.addEffectElement(element)
else:
self._connectToTrackElement(track_element)
def _clipTrackElementRemovedCb(self, clip, track_element):
if isinstance(track_element, GES.BaseEffect):
action = self.effectRemovedAction(clip, track_element, self.effect_properties_tracker)
self.log.push(action)
else:
self._disconnectFromTrackElement(track_element)
def _interpolatorKeyframeAddedCb(self, track_element, keyframe):
action = self.interpolatorKeyframeAddedAction(track_element, keyframe)
self.log.push(action)
def _interpolatorKeyframeRemovedCb(self, track_element, keyframe, old_value=None):
action = self.interpolatorKeyframeRemovedAction(track_element, keyframe)
self.log.push(action)
def _trackElementActiveChangedCb(self, track_element, active, add_effect_action):
"""
This happens when an effect is (de)activated on a clip in the timeline.
"""
action = self.activePropertyChangedAction(add_effect_action, active)
self.log.push(action)
def _interpolatorKeyframeMovedCb(self, tracker, track_element, keyframe, old_snapshot, new_snapshot):
action = self.interpolatorKeyframeChangedAction(track_element, keyframe, old_snapshot, new_snapshot)
self.log.push(action)
class TimelineLogObserver(object):
timelinePropertyChangedAction = ClipPropertyChanged
ClipAddedAction = ClipAdded
ClipRemovedAction = ClipRemoved
effectAddAction = EffectAdded
effectRemovedAction = EffectRemoved
interpolatorKeyframeAddedAction = InterpolatorKeyframeAdded
interpolatorKeyframeRemovedAction = InterpolatorKeyframeRemoved
interpolatorKeyframeChangedAction = InterpolatorKeyframeChanged
activePropertyChangedAction = ActivePropertyChanged
def __init__(self, log):
self.log = log
self.clip_property_trackers = {}
self.interpolator_keyframe_trackers = {}
self.effect_properties_tracker = EffectGstElementPropertyChangeTracker(log)
self._pipeline = None
def setPipeline(self, pipeline):
self._pipeline = pipeline
self.effect_properties_tracker.pipeline = pipeline
def getPipeline(self):
return self._pipeline
pipeline = property(getPipeline, setPipeline)
def startObserving(self, timeline):
self._connectToTimeline(timeline)
for layer in timeline.get_layers():
for clip in layer.get_clips():
self._connectToClip(clip)
for track_element in clip.track_elements:
self._connectToTrackElement(track_element)
def stopObserving(self, timeline):
self._disconnectFromTimeline(timeline)
for clip in timeline.clips:
self._disconnectFromClip(clip)
for track_element in clip.track_elements:
self._disconnectFromTrackElement(track_element)
def _connectToTimeline(self, timeline):
for layer in timeline.get_layers():
layer.connect("clip-added", self._clipAddedCb)
layer.connect("clip-removed", self._clipRemovedCb)
def _disconnectFromTimeline(self, timeline):
timeline.disconnect_by_func(self._clipAddedCb)
timeline.disconnect_by_func(self._clipRemovedCb)
def _connectToClip(self, clip):
tracker = ClipPropertyChangeTracker()
tracker.connectToObject(clip)
for property_name in tracker.property_names:
tracker.connect("notify::" + property_name,
self._clipPropertyChangedCb, property_name)
self.clip_property_trackers[clip] = tracker
clip.connect("child-added", self._clipTrackElementAddedCb)
clip.connect("child-removed", self._clipTrackElementRemovedCb)
for element in clip.get_children():
self._connectToTrackElement(element)
def _disconnectFromClip(self, clip):
tracker = self.clip_property_trackers.pop(clip)
tracker.disconnectFromObject(clip)
tracker.disconnect_by_func(self._clipPropertyChangedCb)
def _connectToTrackElement(self, track_element):
# FIXME: keyframes are disabled:
#for prop, interpolator in track_element.getInterpolators().itervalues():
#self._connectToInterpolator(interpolator)
if isinstance(track_element, GES.BaseEffect):
self.effect_properties_tracker.addEffectElement(track_element.getElement())
def _disconnectFromTrackElement(self, track_element):
for prop, interpolator in track_element.getInterpolators().itervalues():
self._disconnectFromInterpolator(interpolator)
def _connectToInterpolator(self, interpolator):
interpolator.connect("keyframe-added", self._interpolatorKeyframeAddedCb)
interpolator.connect("keyframe-removed", self._interpolatorKeyframeRemovedCb)
tracker = KeyframeChangeTracker()
tracker.connectToObject(interpolator)
tracker.connect("keyframe-moved", self._interpolatorKeyframeMovedCb)
self.interpolator_keyframe_trackers[interpolator] = tracker
def _disconnectFromInterpolator(self, interpolator):
tracker = self.interpolator_keyframe_trackers.pop(interpolator)
tracker.disconnectFromObject(interpolator)
tracker.disconnect_by_func(self._interpolatorKeyframeMovedCb)
def _clipAddedCb(self, timeline, clip):
self._connectToClip(clip)
action = self.ClipAddedAction(timeline, clip)
self.log.push(action)
def _clipRemovedCb(self, timeline, clip):
self._disconnectFromClip(clip)
action = self.ClipRemovedAction(timeline, clip)
self.log.push(action)
def _clipPropertyChangedCb(self, tracker, clip,
old_value, new_value, property_name):
action = self.timelinePropertyChangedAction(clip,
property_name, old_value, new_value)
self.log.push(action)
def _clipTrackElementAddedCb(self, clip, track_element):
if isinstance(track_element, GES.BaseEffect):
action = self.effectAddAction(clip, track_element,
self.effect_properties_tracker)
# We use the action instead of the track element
# because the track_element changes when redoing
track_element.connect("active-changed",
self._trackElementActiveChangedCb, action)
self.log.push(action)
element = track_element.getElement()
if element:
self.effect_properties_tracker.addEffectElement(element)
else:
self._connectToTrackElement(track_element)
def _clipTrackElementRemovedCb(self, clip, track_element):
if isinstance(track_element, GES.BaseEffect):
action = self.effectRemovedAction(clip,
track_element,
self.effect_properties_tracker)
self.log.push(action)
else:
self._disconnectFromTrackElement(track_element)
def _interpolatorKeyframeAddedCb(self, track_element, keyframe):
action = self.interpolatorKeyframeAddedAction(track_element, keyframe)
self.log.push(action)
def _interpolatorKeyframeRemovedCb(self, track_element, keyframe, old_value=None):
action = self.interpolatorKeyframeRemovedAction(track_element, keyframe)
self.log.push(action)
def _trackElementActiveChangedCb(self, track_element, active, add_effect_action):
"""
This happens when an effect is (de)activated on a clip in the timeline.
"""
action = self.activePropertyChangedAction(add_effect_action, active)
self.log.push(action)
def _interpolatorKeyframeMovedCb(self, tracker, track_element,
keyframe, old_snapshot, new_snapshot):
action = self.interpolatorKeyframeChangedAction(track_element,
keyframe, old_snapshot, new_snapshot)
self.log.push(action)
def __init__(self, log):
self.log = log
self.clip_property_trackers = {}
self.interpolator_keyframe_trackers = {}
self.effect_properties_tracker = EffectGstElementPropertyChangeTracker(log)
self._pipeline = None
class TimelineLogObserver(object):
timelinePropertyChangedAction = TimelineObjectPropertyChanged
timelineObjectAddedAction = TimelineObjectAdded
timelineObjectRemovedAction = TimelineObjectRemoved
trackEffectAddAction = TrackEffectAdded
trackEffectRemovedAction = TrackEffectRemoved
interpolatorKeyframeAddedAction = InterpolatorKeyframeAdded
interpolatorKeyframeRemovedAction = InterpolatorKeyframeRemoved
interpolatorKeyframeChangedAction = InterpolatorKeyframeChanged
activePropertyChangedAction = ActivePropertyChanged
def __init__(self, log):
self.log = log
self.timeline_object_property_trackers = {}
self.interpolator_keyframe_trackers = {}
self.effect_properties_tracker = EffectGstElementPropertyChangeTracker(log)
self._pipeline = None
def setPipeline(self, pipeline):
self._pipeline = pipeline
self.effect_properties_tracker.pipeline = pipeline
def getPipeline(self):
return self._pipeline
pipeline = property(getPipeline, setPipeline)
def startObserving(self, timeline):
self._connectToTimeline(timeline)
for layer in timeline.get_layers():
for timeline_object in layer.get_objects():
self._connectToTimelineObject(timeline_object)
for track_object in timeline_object.track_objects:
self._connectToTrackObject(track_object)
def stopObserving(self, timeline):
self._disconnectFromTimeline(timeline)
for timeline_object in timeline.timeline_objects:
self._disconnectFromTimelineObject(timeline_object)
for track_object in timeline_object.track_objects:
self._disconnectFromTrackObject(track_object)
def _connectToTimeline(self, timeline):
for layer in timeline.get_layers():
layer.connect("object-added", self._timelineObjectAddedCb)
layer.connect("object-removed", self._timelineObjectRemovedCb)
def _disconnectFromTimeline(self, timeline):
timeline.disconnect_by_func(self._timelineObjectAddedCb)
timeline.disconnect_by_func(self._timelineObjectRemovedCb)
def _connectToTimelineObject(self, timeline_object):
tracker = TimelineObjectPropertyChangeTracker()
tracker.connectToObject(timeline_object)
for property_name in tracker.property_names:
tracker.connect("notify::" + property_name,
self._timelineObjectPropertyChangedCb, property_name)
self.timeline_object_property_trackers[timeline_object] = tracker
timeline_object.connect("track-object-added", self._timelineObjectTrackObjectAddedCb)
#timeline_object.connect("track-object-removed", self._timelineObjectTrackObjectRemovedCb)
for obj in timeline_object.get_track_objects():
self._connectToTrackObject(obj)
def _disconnectFromTimelineObject(self, timeline_object):
tracker = self.timeline_object_property_trackers.pop(timeline_object)
tracker.disconnectFromObject(timeline_object)
tracker.disconnect_by_func(self._timelineObjectPropertyChangedCb)
def _connectToTrackObject(self, track_object):
#for prop, interpolator in track_object.getInterpolators().itervalues():
#self._connectToInterpolator(interpolator)
if isinstance(track_object, TrackEffect):
self.effect_properties_tracker.addEffectElement(track_object.getElement())
def _disconnectFromTrackObject(self, track_object):
for prop, interpolator in track_object.getInterpolators().itervalues():
self._disconnectFromInterpolator(interpolator)
def _connectToInterpolator(self, interpolator):
interpolator.connect("keyframe-added", self._interpolatorKeyframeAddedCb)
interpolator.connect("keyframe-removed",
self._interpolatorKeyframeRemovedCb)
tracker = KeyframeChangeTracker()
tracker.connectToObject(interpolator)
tracker.connect("keyframe-moved", self._interpolatorKeyframeMovedCb)
self.interpolator_keyframe_trackers[interpolator] = tracker
def _disconnectFromInterpolator(self, interpolator):
tracker = self.interpolator_keyframe_trackers.pop(interpolator)
tracker.disconnectFromObject(interpolator)
tracker.disconnect_by_func(self._interpolatorKeyframeMovedCb)
def _timelineObjectAddedCb(self, timeline, timeline_object):
self._connectToTimelineObject(timeline_object)
action = self.timelineObjectAddedAction(timeline, timeline_object)
self.log.push(action)
def _timelineObjectRemovedCb(self, timeline, timeline_object):
self._disconnectFromTimelineObject(timeline_object)
action = self.timelineObjectRemovedAction(timeline, timeline_object)
self.log.push(action)
def _timelineObjectPropertyChangedCb(self, tracker, timeline_object,
old_value, new_value, property_name):
action = self.timelinePropertyChangedAction(timeline_object,
property_name, old_value, new_value)
self.log.push(action)
def _timelineObjectTrackObjectAddedCb(self, timeline_object, track_object):
if isinstance(track_object, TrackEffect):
action = self.trackEffectAddAction(timeline_object, track_object,
self.effect_properties_tracker)
#We use the action instead of the track object
#because the track_object changes when redoing
track_object.connect("active-changed",
self._trackObjectActiveChangedCb, action)
self.log.push(action)
element = track_object.getElement()
if element:
self.effect_properties_tracker.addEffectElement(element)
else:
self._connectToTrackObject(track_object)
def _timelineObjectTrackObjectRemovedCb(self, timeline_object,
track_object):
if isinstance(track_object, TrackEffect):
action = self.trackEffectRemovedAction(timeline_object,
track_object,
self.effect_properties_tracker)
self.log.push(action)
else:
self._disconnectFromTrackObject(track_object)
def _interpolatorKeyframeAddedCb(self, track_object, keyframe):
action = self.interpolatorKeyframeAddedAction(track_object, keyframe)
self.log.push(action)
def _interpolatorKeyframeRemovedCb(self, track_object, keyframe,
old_value=None):
action = self.interpolatorKeyframeRemovedAction(track_object, keyframe)
self.log.push(action)
def _trackObjectActiveChangedCb(self, track_object, active, add_effect_action):
action = self.activePropertyChangedAction(add_effect_action, active)
self.log.push(action)
def _interpolatorKeyframeMovedCb(self, tracker, track_object,
keyframe, old_snapshot, new_snapshot):
action = self.interpolatorKeyframeChangedAction(track_object,
keyframe, old_snapshot, new_snapshot)
self.log.push(action)
