[pitivi] Port to the new GES API
- From: Thibault Saunier <tsaunier src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [pitivi] Port to the new GES API
- Date: Fri, 15 Feb 2013 19:43:26 +0000 (UTC)
commit a0c4c55a1c6febade7ecf24fe12435db8306d7ce
Author: Thibault Saunier <thibault saunier collabora com>
Date: Fri Feb 1 17:45:50 2013 -0300
Port to the new GES API
pitivi/application.py | 2 +-
pitivi/autoaligner.py | 77 ++++++++--------
pitivi/clipproperties.py | 100 ++++++++++----------
pitivi/mainwindow.py | 2 +-
pitivi/medialibrary.py | 16 ++--
pitivi/project.py | 8 +-
pitivi/timeline/thumbnailer.py | 10 +-
pitivi/timeline/timeline.py | 70 +++++++-------
pitivi/timeline/track.py | 112 +++++++++++-----------
pitivi/titleeditor.py | 12 +-
pitivi/transitions.py | 6 +-
pitivi/undo/effect.py | 90 +++++++++---------
pitivi/undo/timeline.py | 204 ++++++++++++++++++++--------------------
pitivi/utils/timeline.py | 68 +++++++-------
pitivi/utils/widgets.py | 2 +-
pitivi/viewer.py | 2 +-
tests/test_timeline_undo.py | 200 ++++++++++++++++++++--------------------
17 files changed, 491 insertions(+), 490 deletions(-)
---
diff --git a/pitivi/application.py b/pitivi/application.py
index 23d284e..311e068 100644
--- a/pitivi/application.py
+++ b/pitivi/application.py
@@ -348,7 +348,7 @@ class ProjectCreatorGuiPitivi(GuiPitivi):
if self._maybePopStartupUri(startup_uris, info.get_uri()) \
and add_to_timeline:
self.action_log.begin("add clip")
- src = GES.TimelineFileSource(uri=info.get_uri())
+ src = GES.UriClip(uri=info.get_uri())
src.set_property("priority", 1)
self.current.timeline.get_layers()[0].add_object(src)
self.action_log.commit()
diff --git a/pitivi/autoaligner.py b/pitivi/autoaligner.py
index 9e31612..b385c1d 100644
--- a/pitivi/autoaligner.py
+++ b/pitivi/autoaligner.py
@@ -21,7 +21,7 @@
# TODO reimplement after GES port
"""
-Classes for automatic alignment of L{TimelineObject}s
+Classes for automatic alignment of L{Clip}s
"""
from gi.repository import GObject
@@ -298,18 +298,18 @@ def affinealign(reference, targets, max_drift=0.02):
return offsets, drifts
-def getAudioTrack(timeline_object):
- """Helper function for getting an audio track from a TimelineObject
+def getAudioTrack(clip):
+ """Helper function for getting an audio track from a Clip
- @param timeline_object: The TimelineObject from which to locate an
+ @param clip: The Clip from which to locate an
audio track
- @type timeline_object: L{TimelineObject}
- @returns: An audio track from timeline_object, or None if
- timeline_object has no audio track
- @rtype: audio L{TrackObject} or L{NoneType}
+ @type clip: L{Clip}
+ @returns: An audio track from clip, or None if
+ clip has no audio track
+ @rtype: audio L{TrackElement} or L{NoneType}
"""
- for track in timeline_object.track_objects:
+ for track in clip.track_elements:
if track.stream_type == AudioStream:
return track
return None
@@ -474,7 +474,7 @@ class EnvelopeExtractee(Extractee, Loggable):
class AutoAligner(Loggable):
"""
- Class for aligning a set of L{TimelineObject}s automatically.
+ Class for aligning a set of L{Clip}s automatically.
The alignment is based on their contents, so that the shifted tracks
are synchronized. The current implementation only analyzes audio
@@ -499,21 +499,21 @@ class AutoAligner(Loggable):
"""
- def __init__(self, timeline_objects, callback):
+ def __init__(self, clips, callback):
"""
- @param timeline_objects: an iterable of L{TimelineObject}s.
- In this implementation, only L{TimelineObject}s with at least one
+ @param clips: an iterable of L{Clip}s.
+ In this implementation, only L{Clip}s with at least one
audio track will be aligned.
- @type timeline_objects: iter(L{TimelineObject})
+ @type clips: iter(L{Clip})
@param callback: A function to call when alignment is complete. No
arguments will be provided.
@type callback: function
"""
Loggable.__init__(self)
- # self._timeline_objects maps each object to its envelope. The values
+ # self._clips maps each object to its envelope. The values
# are initially None prior to envelope extraction.
- self._timeline_objects = dict.fromkeys(timeline_objects)
+ self._clips = dict.fromkeys(clips)
self._callback = callback
# stack of (Track, Extractee) pairs waiting to be processed
# When start() is called, the stack will be populated, and then
@@ -522,15 +522,15 @@ class AutoAligner(Loggable):
self._extraction_stack = []
@staticmethod
- def canAlign(timeline_objects):
+ def canAlign(clips):
"""
Can an AutoAligner align these objects?
Determine whether a group of timeline objects can all
be aligned together by an AutoAligner.
- @param timeline_objects: a group of timeline objects
- @type timeline_objects: iterable(L{TimelineObject})
+ @param clips: a group of timeline objects
+ @type clips: iterable(L{Clip})
@returns: True iff the objects can aligned.
@rtype: L{bool}
@@ -538,7 +538,7 @@ class AutoAligner(Loggable):
# numpy is a "soft dependency". If you're running without numpy,
# this False return value is your only warning not to
# use the AutoAligner, which will crash immediately.
- return all(getAudioTrack(t) is not None for t in timeline_objects)
+ return all(getAudioTrack(t) is not None for t in clips)
def _extractNextEnvelope(self):
audiotrack, extractee = self._extraction_stack.pop()
@@ -548,9 +548,9 @@ class AutoAligner(Loggable):
audiotrack.out_point - audiotrack.in_point)
return False
- def _envelopeCb(self, array, timeline_object):
- self.debug("Receiving envelope for %s", timeline_object)
- self._timeline_objects[timeline_object] = array
+ def _envelopeCb(self, array, clip):
+ self.debug("Receiving envelope for %s", clip)
+ self._clips[clip] = array
if self._extraction_stack:
self._extractNextEnvelope()
else: # This was the last envelope
@@ -567,19 +567,18 @@ class AutoAligner(Loggable):
"""
progress_aggregator = ProgressAggregator()
- pairs = [] # (TimelineObject, {audio}TrackObject) pairs
- for timeline_object in self._timeline_objects.keys():
- audiotrack = getAudioTrack(timeline_object)
+ pairs = [] # (Clip, {audio}TrackElement) pairs
+ for clip in self._clips.keys():
+ audiotrack = getAudioTrack(clip)
if audiotrack is not None:
- pairs.append((timeline_object, audiotrack))
- else: # forget any TimelineObject without an audio track
- self._timeline_objects.pop(timeline_object)
+ pairs.append((clip, audiotrack))
+ else: # forget any Clip without an audio track
+ self._clips.pop(clip)
if len(pairs) >= 2:
- for timeline_object, audiotrack in pairs:
+ for clip, audiotrack in pairs:
# blocksize is the number of samples per block
blocksize = audiotrack.stream.rate // self.BLOCKRATE
- extractee = EnvelopeExtractee(blocksize, self._envelopeCb,
- timeline_object)
+ extractee = EnvelopeExtractee(blocksize, self._envelopeCb, clip)
# numsamples is the total number of samples in the track,
# which is used by progress_aggregator to determine
# the percent completion.
@@ -612,23 +611,23 @@ class AutoAligner(Loggable):
determine which object moves and which stays put.
@returns: the timeline object with lowest priority.
- @rtype: L{TimelineObject}
+ @rtype: L{Clip}
"""
- def priority(timeline_object):
- return timeline_object.priority
- return min(self._timeline_objects.iterkeys(), key=priority)
+ def priority(clip):
+ return clip.priority
+ return min(self._clips.iterkeys(), key=priority)
def _performShifts(self):
self.debug("performing shifts")
reference = self._chooseReference()
# By using pop(), this line also removes the reference
- # TimelineObject and its envelope from further consideration,
+ # Clip and its envelope from further consideration,
# saving some CPU time in rigidalign.
- reference_envelope = self._timeline_objects.pop(reference)
+ reference_envelope = self._clips.pop(reference)
# We call list() because we need a reliable ordering of the pairs
# (In python 3, dict.items() returns an unordered dictview)
- pairs = list(self._timeline_objects.items())
+ pairs = list(self._clips.items())
envelopes = [p[1] for p in pairs]
offsets = rigidalign(reference_envelope, envelopes)
for (movable, envelope), offset in zip(pairs, offsets):
diff --git a/pitivi/clipproperties.py b/pitivi/clipproperties.py
index 75a46f1..40bdd25 100644
--- a/pitivi/clipproperties.py
+++ b/pitivi/clipproperties.py
@@ -142,7 +142,7 @@ class EffectProperties(Gtk.Expander):
Gtk.Expander.__init__(self)
self.selected_effects = []
- self.timeline_objects = []
+ self.clips = []
self._factory = None
self.app = instance
self.settings = instance.settings
@@ -246,7 +246,7 @@ class EffectProperties(Gtk.Expander):
def _newProjectLoadedCb(self, app, project):
self.clip_properties.project = project
- self.selected_effects = self.timeline.selection.getSelectedTrackEffects()
+ self.selected_effects = self.timeline.selection.getSelectedEffects()
self.updateAll()
def _vcontentNotifyCb(self, paned, gparamspec):
@@ -272,32 +272,32 @@ class EffectProperties(Gtk.Expander):
timeline = property(_getTimeline, _setTimeline)
def _selectionChangedCb(self, selection,):
- for timeline_object in self.timeline_objects:
- timeline_object.disconnect_by_func(self._trackObjectAddedCb)
- timeline_object.disconnect_by_func(self._trackRemovedRemovedCb)
+ for clip in self.clips:
+ clip.disconnect_by_func(self._TrackElementAddedCb)
+ clip.disconnect_by_func(self._trackElementRemovedCb)
- self.selected_effects = selection.getSelectedTrackEffects()
+ self.selected_effects = selection.getSelectedEffects()
if selection.selected:
- self.timeline_objects = list(selection.selected)
- for timeline_object in self.timeline_objects:
- timeline_object.connect("track-object-added", self._trackObjectAddedCb)
- timeline_object.connect("track-object-removed", self._trackRemovedRemovedCb)
+ self.clips = list(selection.selected)
+ for clip in self.clips:
+ clip.connect("track-object-added", self._TrackElementAddedCb)
+ clip.connect("track-object-removed", self._trackElementRemovedCb)
self.show()
else:
- self.timeline_objects = []
+ self.clips = []
self.hide()
self.updateAll()
- def _trackObjectAddedCb(self, unused_timeline_object, track_object):
- if isinstance(track_object, GES.TrackEffect):
- selec = self.timeline.selection.getSelectedTrackEffects()
+ def _TrackElementAddedCb(self, unused_clip, track_element):
+ if isinstance(track_element, GES.BaseEffect):
+ selec = self.timeline.selection.getSelectedEffects()
self.selected_effects = selec
self.updateAll()
- def _trackRemovedRemovedCb(self, unused_timeline_object, track_object):
- if isinstance(track_object, GES.TrackEffect):
- selec = self.timeline.selection.getSelectedTrackEffects()
+ def _trackElementRemovedCb(self, unused_clip, track_element):
+ if isinstance(track_element, GES.BaseEffect):
+ selec = self.timeline.selection.getSelectedEffects()
self.selected_effects = selec
self.updateAll()
@@ -316,7 +316,7 @@ class EffectProperties(Gtk.Expander):
self.app.action_log.begin("remove effect")
self._cleanCache(effect)
effect.get_track().remove_object(effect)
- effect.get_timeline_object().release_track_object(effect)
+ effect.get_clip().release_track_element(effect)
self._updateTreeview()
self.app.action_log.commit()
@@ -324,24 +324,24 @@ class EffectProperties(Gtk.Expander):
config_ui = self.effect_props_handling.cleanCache(effect)
def addEffectToCurrentSelection(self, bin_desc):
- if self.timeline_objects:
+ if self.clips:
media_type = self.app.effects.getFactoryFromName(bin_desc).media_type
# Trying to apply effect only on the first object of the selection
- tlobj = self.timeline_objects[0]
+ clip = self.clips[0]
# Checking that this effect can be applied on this track object
# Which means, it has the corresponding media_type
- for tckobj in tlobj.get_track_objects():
- track = tckobj.get_track()
+ for track_element in clip.get_track_elements():
+ track = track_element.get_track()
if track.get_property("track_type") == GES.TrackType.AUDIO and \
media_type == AUDIO_EFFECT or \
track.get_property("track_type") == GES.TrackType.VIDEO and \
media_type == VIDEO_EFFECT:
#Actually add the effect
self.app.action_log.begin("add effect")
- effect = GES.TrackParseLaunchEffect(bin_description=bin_desc)
- tlobj.add_track_object(effect)
+ effect = GES.Effect(bin_description=bin_desc)
+ clip.add_track_element(effect)
track.add_object(effect)
self.updateAll()
self.app.action_log.commit()
@@ -385,7 +385,7 @@ class EffectProperties(Gtk.Expander):
def updateAll(self):
if self.get_expanded():
self._removeEffectBt.set_sensitive(False)
- if len(self.timeline_objects) == 1:
+ if len(self.clips) == 1:
self._setEffectDragable()
self._updateTreeview()
self._updateEffectConfigUi()
@@ -400,21 +400,21 @@ class EffectProperties(Gtk.Expander):
def _updateTreeview(self):
self.storemodel.clear()
- obj = self.timeline_objects[0]
- for track_effect in obj.get_top_effects():
- if not track_effect.props.bin_description in HIDDEN_EFFECTS:
+ obj = self.clips[0]
+ for effect in obj.get_top_effects():
+ if not effect.props.bin_description in HIDDEN_EFFECTS:
asset = self.app.effects.getFactoryFromName(
- track_effect.props.bin_description)
- to_append = [track_effect.props.active]
- track = track_effect.get_track()
+ effect.props.bin_description)
+ to_append = [effect.props.active]
+ track = effect.get_track()
if track.get_property("track_type") == GES.TrackType.AUDIO:
to_append.append("Audio")
elif track.get_property("track_type") == GES.TrackType.VIDEO:
to_append.append("Video")
- to_append.append(track_effect.props.bin_description)
+ to_append.append(effect.props.bin_description)
to_append.append(asset.description)
- to_append.append(track_effect)
+ to_append.append(effect)
self.storemodel.append(to_append)
@@ -429,7 +429,7 @@ class EffectProperties(Gtk.Expander):
self._info_bar.hide()
def _treeviewSelectionChangedCb(self, treeview):
- if self.selection.count_selected_rows() == 0 and self.timeline_objects:
+ if self.selection.count_selected_rows() == 0 and self.clips:
self.app.gui.setActionsSensitive(True)
self._removeEffectBt.set_sensitive(False)
else:
@@ -445,14 +445,14 @@ class EffectProperties(Gtk.Expander):
self._config_ui_h_pos = self.app.gui.settings.mainWindowHeight // 3
if self.selection.get_selected()[1]:
- track_effect = self.storemodel.get_value(self.selection.get_selected()[1],
+ effect = self.storemodel.get_value(self.selection.get_selected()[1],
COL_TRACK_EFFECT)
for widget in self._vcontent.get_children():
if type(widget) in [Gtk.ScrolledWindow, GstElementSettingsWidget]:
self._vcontent.remove(widget)
- element = track_effect
+ element = effect
ui = self.effect_props_handling.getEffectConfigurationUI(element)
self._effect_config_ui = ui
@@ -460,7 +460,7 @@ class EffectProperties(Gtk.Expander):
self._vcontent.pack2(self._effect_config_ui, resize=False, shrink=False)
self._vcontent.set_position(int(self._config_ui_h_pos))
self._effect_config_ui.show_all()
- self.selected_on_treeview = track_effect
+ self.selected_on_treeview = effect
else:
self._hideEffectConfig()
@@ -537,7 +537,8 @@ class TransformationProperties(Gtk.Expander):
for name, spinbtn in self.spin_buttons.items():
spinbtn.set_value(self.default_values[name])
self.connectSpinButtonsToFlush()
- self.track_effect.gnl_object.props.active = False
+ # FIXME Why are we looking at the gnl object directly?
+ self.effect.gnl_object.props.active = False
def disconnectSpinButtonsFromFlush(self):
for spinbtn in self.spin_buttons.values():
@@ -566,8 +567,9 @@ class TransformationProperties(Gtk.Expander):
def _onValueChangedCb(self, spinbtn, prop):
value = spinbtn.get_value()
- if value != self.default_values[prop] and not self.track_effect.get_gnlobject().props.active:
- self.track_effect.get_gnlobject().props.active = True
+ # FIXME Why are we looking at the gnl object directly?
+ if value != self.default_values[prop] and not self.effect.get_gnlobject().props.active:
+ self.effect.get_gnlobject().props.active = True
if value != self.effect.get_property(prop):
self.action_log.begin("Transformation property change")
@@ -590,26 +592,26 @@ class TransformationProperties(Gtk.Expander):
self.app.current.pipeline.flushSeek()
def _findEffect(self, name):
- for track_effect in self._current_tl_obj.get_track_objects():
- if isinstance(track_effect, GES.TrackParseLaunchEffect):
- if name in track_effect.get_property("bin-description"):
- self.track_effect = track_effect
- return track_effect.get_element()
+ for effect in self._current_tl_obj.get_track_elements():
+ if isinstance(effect, GES.BaseEffect):
+ if name in effect.get_property("bin-description"):
+ self.effect = effect
+ return effect.get_element()
def _findOrCreateEffect(self, name):
effect = self._findEffect(name)
if not effect:
- effect = GES.TrackParseLaunchEffect(bin_description=name)
- self._current_tl_obj.add_track_object(effect)
+ effect = GES.Effect(bin_description=name)
+ self._current_tl_obj.add_track_element(effect)
tracks = self.app.projectManager.current.timeline.get_tracks()
for track in tracks:
if track.get_caps().to_string() == "video/x-raw":
track.add_object(effect)
effect = self._findEffect(name)
# disable the effect on default
- a = self.track_effect.get_gnlobject()
+ a = self.effect.get_gnlobject()
self.effect = list(list(a.elements())[0].elements())[1]
- self.track_effect.get_gnlobject().props.active = False
+ self.effect.get_gnlobject().props.active = False
self.app.gui.viewer.internal.set_transformation_properties(self)
effect.freeze_notify()
return self.effect
diff --git a/pitivi/mainwindow.py b/pitivi/mainwindow.py
index 2445bf9..5b827cb 100644
--- a/pitivi/mainwindow.py
+++ b/pitivi/mainwindow.py
@@ -1284,7 +1284,7 @@ class PitiviMainWindow(Gtk.Window, Loggable):
preview_window.hide() # Hack to allow setting the window position
previewer.previewUri(uri)
previewer.setMinimal()
- info = self.app.current.get_asset(uri, GES.TimelineFileSource).get_info()
+ info = self.app.current.get_asset(uri, GES.UriClip).get_info()
try:
# For videos and images, automatically resize the window
# Try to keep it 1:1 if it can fit within 85% of the parent window
diff --git a/pitivi/medialibrary.py b/pitivi/medialibrary.py
index 4339666..4e6adaa 100644
--- a/pitivi/medialibrary.py
+++ b/pitivi/medialibrary.py
@@ -341,7 +341,7 @@ class MediaLibraryWidget(Gtk.VBox, Loggable):
"""
self.app.gui.setActionsSensitive(True)
- def _trackObjectAddedCb(self, source, trackobj):
+ def _trackElementAddedCb(self, source, trackobj):
""" After an object has been added to the first track, position it
correctly and request the next source to be processed. """
timeline = self.app.current.timeline
@@ -353,9 +353,9 @@ class MediaLibraryWidget(Gtk.VBox, Loggable):
else:
source.props.start = timeline.props.duration
- # We only need one TrackObject to estimate the new duration.
+ # We only need one TrackElement to estimate the new duration.
# Process the next source.
- source.disconnect_by_func(self._trackObjectAddedCb)
+ source.disconnect_by_func(self._trackElementAddedCb)
self._insertNextSource()
def _searchEntryChangedCb(self, entry):
@@ -587,7 +587,7 @@ class MediaLibraryWidget(Gtk.VBox, Loggable):
def _assetAddedCb(self, unused_project, asset,
current_clip_iter=None, total_clips=None):
""" a file was added to the medialibrary """
- if isinstance(asset, GES.AssetFileSource):
+ if isinstance(asset, GES.UriClipAsset):
self._updateProgressbar()
self._addAsset(asset)
@@ -606,7 +606,7 @@ class MediaLibraryWidget(Gtk.VBox, Loggable):
def _errorCreatingAssetCb(self, unsued_project, error, id, type):
""" The given uri isn't a media file """
- if GObject.type_is_a(type, GES.TimelineFileSource):
+ if GObject.type_is_a(type, GES.UriClip):
error = (id, str(error.domain), error)
self._errors.append(error)
self._updateProgressbar()
@@ -687,8 +687,8 @@ class MediaLibraryWidget(Gtk.VBox, Loggable):
"""Check if a given URI is present in the timeline"""
layers = self.app.current.timeline.get_layers()
for layer in layers:
- for tlobj in layer.get_objects():
- if tlobj.get_asset() == asset:
+ for clip in layer.get_objects():
+ if clip.get_asset() == asset:
return True
return False
@@ -696,7 +696,7 @@ class MediaLibraryWidget(Gtk.VBox, Loggable):
"""
Select, in the media library, unused sources in the project.
"""
- assets = self.app.current.list_assets(GES.TimelineFileSource)
+ assets = self.app.current.list_assets(GES.UriClip)
unused_sources_uris = []
model = self.treeview.get_model()
diff --git a/pitivi/project.py b/pitivi/project.py
index 79a1138..926e04b 100644
--- a/pitivi/project.py
+++ b/pitivi/project.py
@@ -762,7 +762,7 @@ class Project(Loggable, GES.Project):
def _handle_asset_loaded(self, id):
self.nb_imported_files += 1
self.nb_remaining_file_to_import = len([asset for asset in self.get_loading_assets() if
- GObject.type_is_a(asset.get_extractable_type(), GES.TimelineFileSource)])
+ GObject.type_is_a(asset.get_extractable_type(), GES.UriClip)])
if self.nb_remaining_file_to_import == 0:
self.nb_imported_files = 0
self._emitChange("done-importing")
@@ -838,11 +838,11 @@ class Project(Loggable, GES.Project):
"""
# Do not try to reload URIS that we already have loaded
for uri in uris:
- self.create_asset(quote_uri(uri), GES.TimelineFileSource)
+ self.create_asset(quote_uri(uri), GES.UriClip)
self._calculateNbLoadingAssets()
def listSources(self):
- return self.list_assets(GES.TimelineFileSource)
+ return self.list_assets(GES.UriClip)
def release(self):
if self.pipeline:
@@ -1001,7 +1001,7 @@ class Project(Loggable, GES.Project):
def _calculateNbLoadingAssets(self):
nb_remaining_file_to_import = len([asset for asset in self.get_loading_assets() if
- GObject.type_is_a(asset.get_extractable_type(), GES.TimelineFileSource)])
+ GObject.type_is_a(asset.get_extractable_type(), GES.UriClip)])
if self.nb_remaining_file_to_import == 0 and nb_remaining_file_to_import:
self.nb_remaining_file_to_import = nb_remaining_file_to_import
self._emitChange("start-importing")
diff --git a/pitivi/timeline/thumbnailer.py b/pitivi/timeline/thumbnailer.py
index 22764dd..d380f05 100644
--- a/pitivi/timeline/thumbnailer.py
+++ b/pitivi/timeline/thumbnailer.py
@@ -204,9 +204,9 @@ class ThumbnailCache(object):
previewers = {}
-def get_preview_for_object(instance, trackobject):
- uri = trackobject.props.uri
- track_type = trackobject.get_track().props.track_type
+def get_preview_for_object(instance, trackelement):
+ uri = trackelement.props.uri
+ track_type = trackelement.props.track_type
key = uri, track_type
if not key in previewers:
# TODO: handle non-random access factories
@@ -218,7 +218,7 @@ def get_preview_for_object(instance, trackobject):
# previewers[key] = RandomAccessAudioPreviewer(instance, uri)
previewers[key] = DefaultPreviewer(instance, uri)
elif track_type == GES.TrackType.VIDEO:
- if trackobject.get_timeline_object().is_image():
+ if trackelement.get_clip().is_image():
previewers[key] = StillImagePreviewer(instance, uri)
else:
previewers[key] = RandomAccessVideoPreviewer(instance, uri)
@@ -271,7 +271,7 @@ class DefaultPreviewer(Previewer):
class RandomAccessPreviewer(Previewer):
""" Handles loading, caching, and drawing preview data for segments of
random-access streams. There is one Previewer per track_type per
- TrackObject. Preview data is read from a uri, and when requested, drawn
+ TrackElement. Preview data is read from a uri, and when requested, drawn
into a given cairo context. If the requested data is not cached, an
appropriate filler will be substituted, and an asyncrhonous request
for the data will be issued. When the data becomes available, the update
diff --git a/pitivi/timeline/timeline.py b/pitivi/timeline/timeline.py
index 2b371ff..f809d29 100644
--- a/pitivi/timeline/timeline.py
+++ b/pitivi/timeline/timeline.py
@@ -46,7 +46,7 @@ from pitivi.utils.misc import quote_uri, print_ns
from pitivi.utils.pipeline import PipelineError
from pitivi.settings import GlobalSettings
-from track import Track, TrackObject
+from track import Track, TrackElement
from layer import VideoLayerControl, AudioLayerControl
from pitivi.utils.timeline import EditingContext, SELECT, Zoomable
@@ -228,10 +228,10 @@ class TimelineCanvas(GooCanvas.Canvas, Zoomable, Loggable):
x += self.app.gui.timeline_ui.hadj.get_value()
return Point(*self.convert_from_pixels(x, y))
- def setExpanded(self, track_object, expanded):
+ def setExpanded(self, track_element, expanded):
track_ui = None
for track in self._tracks:
- if track.track == track_object:
+ if track.track == track_element:
track_ui = track
break
@@ -269,8 +269,8 @@ class TimelineCanvas(GooCanvas.Canvas, Zoomable, Loggable):
def getItemsInArea(self, x1, y1, x2, y2):
'''
- Permits to get the Non UI L{Track}/L{TrackObject} in a list of set
- corresponding to the L{Track}/L{TrackObject} which are in the are
+ Permits to get the Non UI L{Track}/L{TrackElement} in a list of set
+ corresponding to the L{Track}/L{TrackElement} which are in the are
@param x1: The horizontal coordinate of the up left corner of the area
@type x1: An C{int}
@@ -281,7 +281,7 @@ class TimelineCanvas(GooCanvas.Canvas, Zoomable, Loggable):
@param x2: The vertical coordinate of the down right corner of the area
@type x2: An C{int}
- @returns: A list of L{Track}, L{TrackObject} tuples
+ @returns: A list of L{Track}, L{TrackElement} tuples
'''
bounds = GooCanvas.CanvasBounds()
bounds.x1 = x1
@@ -293,15 +293,15 @@ class TimelineCanvas(GooCanvas.Canvas, Zoomable, Loggable):
return [], []
tracks = set()
- track_objects = set()
+ track_elements = set()
for item in items:
if isinstance(item, Track):
tracks.add(item.track)
- elif isinstance(item, TrackObject):
- track_objects.add(item.element)
+ elif isinstance(item, TrackElement):
+ track_elements.add(item.element)
- return tracks, track_objects
+ return tracks, track_elements
def _normalize(self, p1, p2):
w, h = p1 - p2
@@ -357,7 +357,7 @@ class TimelineCanvas(GooCanvas.Canvas, Zoomable, Loggable):
items = self.get_items_in_area(self._marquee.get_bounds(), True, True, True)
if items:
return set((item.element for item in items if isinstance(item,
- TrackObject) and item.bg in items))
+ TrackElement) and item.bg in items))
return set()
## playhead implementation
@@ -475,9 +475,9 @@ class TimelineCanvas(GooCanvas.Canvas, Zoomable, Loggable):
self._request_size()
def updateTracks(self):
- self.debug("Updating all TrackObjects")
+ self.debug("Updating all TrackElements")
for track in self._tracks:
- track.updateTrackObjects()
+ track.updateTrackElements()
class TimelineControls(Gtk.VBox, Loggable):
@@ -1173,7 +1173,7 @@ class Timeline(Gtk.Table, Loggable, Zoomable):
if not self._temp_objects:
self._create_temp_source(x, y)
- # Let some time for TrackObject-s to be created
+ # Let some time for TrackElement-s to be created
if self._temp_objects:
focus = self._temp_objects[0]
if self._move_context is None:
@@ -1240,7 +1240,7 @@ class Timeline(Gtk.Table, Loggable, Zoomable):
else:
if self.app.current.timeline.props.duration == 0:
return False
- timeline_objs = self._getTimelineObjectUnderMouse(x, y)
+ timeline_objs = self._getClipUnderMouse(x, y)
if timeline_objs:
# FIXME make a util function to add effects
# instead of copy/pasting it from cliproperties
@@ -1248,20 +1248,20 @@ class Timeline(Gtk.Table, Loggable, Zoomable):
media_type = self.app.effects.getFactoryFromName(bin_desc).media_type
# Trying to apply effect only on the first object of the selection
- tlobj = timeline_objs[0]
+ clip = timeline_objs[0]
# Checking that this effect can be applied on this track object
# Which means, it has the corresponding media_type
- for tckobj in tlobj.get_track_objects():
- track = tckobj.get_track()
+ for track_element in clip.get_track_elements():
+ track = track_element.get_track()
if track.get_property("track_type") == GES.TrackType.AUDIO and \
media_type == AUDIO_EFFECT or \
track.get_property("track_type") == GES.TrackType.VIDEO and \
media_type == VIDEO_EFFECT:
#Actually add the effect
self.app.action_log.begin("add effect")
- effect = GES.TrackParseLaunchEffect(bin_description=bin_desc)
- tlobj.add_track_object(effect)
+ effect = GES.Effect(bin_description=bin_desc)
+ clip.add_track_element(effect)
track.add_object(effect)
self.app.gui.clipconfig.effect_expander.updateAll()
self.app.action_log.commit()
@@ -1273,13 +1273,13 @@ class Timeline(Gtk.Table, Loggable, Zoomable):
Gtk.drag_finish(context, True, False, timestamp)
return True
- def _getTimelineObjectUnderMouse(self, x, y):
+ def _getClipUnderMouse(self, x, y):
timeline_objs = []
items_in_area = self._canvas.getItemsInArea(x, y, x + 1, y + 1)
- track_objects = [obj for obj in items_in_area[1]]
- for track_object in track_objects:
- timeline_objs.append(track_object.get_timeline_object())
+ track_elements = [obj for obj in items_in_area[1]]
+ for track_element in track_elements:
+ timeline_objs.append(track_element.get_clip())
return timeline_objs
@@ -1339,14 +1339,14 @@ class Timeline(Gtk.Table, Loggable, Zoomable):
quoted_uri = quote_uri(uri)
layers = self.timeline.get_layers()
for layer in layers:
- for tlobj in layer.get_objects():
- if hasattr(tlobj, "get_uri"):
- if quote_uri(tlobj.get_uri()) == quoted_uri:
- layer.remove_object(tlobj)
+ for clip in layer.get_objects():
+ if hasattr(clip, "get_uri"):
+ if quote_uri(clip.get_uri()) == quoted_uri:
+ layer.remove_object(clip)
else:
# TimelineStandardTransition and the like don't have URIs
# GES will remove those transitions automatically.
- self.debug("Not removing %s from timeline as it has no URI" % tlobj)
+ self.debug("Not removing %s from timeline as it has no URI" % clip)
def _create_temp_source(self, x, y):
"""
@@ -1729,7 +1729,7 @@ class Timeline(Gtk.Table, Loggable, Zoomable):
def deleteSelected(self, unused_action):
if self.timeline:
self.app.action_log.begin("delete clip")
- #FIXME GES port: Handle unlocked TrackObject-s
+ #FIXME GES port: Handle unlocked TrackElement-s
for obj in self.timeline.selection:
layer = obj.get_layer()
layer.remove_object(obj)
@@ -1740,8 +1740,8 @@ class Timeline(Gtk.Table, Loggable, Zoomable):
self.debug("Ungouping selected clips %s" % self.timeline.selection)
self.timeline.enable_update(False)
self.app.action_log.begin("ungroup")
- for tlobj in self.timeline.selection:
- tlobj.objects_set_locked(False)
+ for clip in self.timeline.selection:
+ clip.objects_set_locked(False)
self.timeline.enable_update(True)
self.app.action_log.commit()
@@ -1750,8 +1750,8 @@ class Timeline(Gtk.Table, Loggable, Zoomable):
self.debug("Gouping selected clips %s" % self.timeline.selection)
self.timeline.enable_update(False)
self.app.action_log.begin("group")
- for tlobj in self.timeline.selection:
- tlobj.objects_set_locked(True)
+ for clip in self.timeline.selection:
+ clip.objects_set_locked(True)
self.app.action_log.commit()
self.timeline.enable_update(True)
@@ -1784,7 +1784,7 @@ class Timeline(Gtk.Table, Loggable, Zoomable):
start = tck_obj.get_start()
end = start + tck_obj.get_duration()
if start < position and end > position:
- obj = tck_obj.get_timeline_object()
+ obj = tck_obj.get_clip()
obj.split(position)
self.timeline.enable_update(True)
diff --git a/pitivi/timeline/track.py b/pitivi/timeline/track.py
index cd2f609..6d61d46 100644
--- a/pitivi/timeline/track.py
+++ b/pitivi/timeline/track.py
@@ -163,7 +163,7 @@ class Selected(Signallable):
selected = property(getSelected, setSelected)
-class TrackObjectController(Controller):
+class TrackElementController(Controller):
_cursor = ARROW
_context = None
@@ -245,7 +245,7 @@ class TrackObjectController(Controller):
class TrimHandle(View, GooCanvas.CanvasImage, Loggable, Zoomable):
- """A component of a TrackObject which manage's the source's edit
+ """A component of a TrackElement which manage's the source's edit
points"""
def __init__(self, instance, element, timeline, **kwargs):
@@ -294,16 +294,16 @@ class StartHandle(TrimHandle):
"""Subclass of TrimHandle wich sets the object's start time"""
- class Controller(TrackObjectController):
+ class Controller(TrackElementController):
_cursor = LEFT_SIDE
def drag_start(self, item, target, event):
self.debug("Trim start %s" % target)
- TrackObjectController.drag_start(self, item, target, event)
+ TrackElementController.drag_start(self, item, target, event)
if self._view.element.is_locked():
- elem = self._view.element.get_timeline_object()
+ elem = self._view.element.get_clip()
else:
elem = self._view.element
@@ -328,16 +328,16 @@ class EndHandle(TrimHandle):
"""Subclass of TrimHandle which sets the objects's end time"""
- class Controller(TrackObjectController):
+ class Controller(TrackElementController):
_cursor = RIGHT_SIDE
def drag_start(self, item, target, event):
self.debug("Trim end %s" % target)
- TrackObjectController.drag_start(self, item, target, event)
+ TrackElementController.drag_start(self, item, target, event)
if self._view.element.is_locked():
- elem = self._view.element.get_timeline_object()
+ elem = self._view.element.get_clip()
else:
elem = self._view.element
self._context = EditingContext(elem, self._view.timeline,
@@ -377,9 +377,9 @@ def raise_new(self, above):
setattr(GooCanvas.CanvasItem, "raise_", raise_new)
-class TrackObject(View, GooCanvas.CanvasGroup, Zoomable, Loggable):
+class TrackElement(View, GooCanvas.CanvasGroup, Zoomable, Loggable):
- class Controller(TrackObjectController):
+ class Controller(TrackElementController):
_handle_enter_leave = True
@@ -387,7 +387,7 @@ class TrackObject(View, GooCanvas.CanvasGroup, Zoomable, Loggable):
if not self._view.movable:
return
- TrackObjectController.drag_start(self, item, target, event)
+ TrackElementController.drag_start(self, item, target, event)
self._context = EditingContext(self._view.element,
self._view.timeline, GES.EditMode.EDIT_NORMAL, GES.Edge.EDGE_NONE,
@@ -602,37 +602,37 @@ class TrackObject(View, GooCanvas.CanvasGroup, Zoomable, Loggable):
element = property(getElement, setElement, delElement)
- def _updateCb(self, track_object, start):
+ def _updateCb(self, track_element, start):
self._update()
def selectedChangedCb(self, element, unused_selection):
# Do not confuse this method with _selectionChangedCb in Timeline
# unused_selection is True only when no clip was selected before
# Note that element is a track.Selected object,
- # whereas self.element is a GES object (ex: TrackVideoTransition)
+ # whereas self.element is a GES object (ex: VideoTransition)
if element.selected:
- if isinstance(self.element, GES.TrackTransition):
- if isinstance(self.element, GES.TrackVideoTransition):
+ if isinstance(self.element, GES.Transition):
+ if isinstance(self.element, GES.VideoTransition):
self.app.gui.trans_list.activate(self.element)
- elif isinstance(self.element, GES.TrackTitleSource):
+ elif isinstance(self.element, GES.TitleSource):
self.app.gui.switchContextTab("title editor")
- self.app.gui.title_editor.set_source(self.element.get_timeline_object())
+ self.app.gui.title_editor.set_source(self.element.get_clip())
else:
if self.element.get_track().get_property("track_type") == GES.TrackType.VIDEO:
has_text_overlay = False
- tlobj = self.element.get_timeline_object()
- trackobjs = tlobj.get_track_objects()
+ clip = self.element.get_clip()
+ trackobjs = clip.get_track_elements()
for trackobj in trackobjs:
- if isinstance(trackobj, GES.TrackTextOverlay):
+ if isinstance(trackobj, GES.TextOverlay):
has_text_overlay = True
title = trackobj
if not has_text_overlay:
- title = GES.TrackTextOverlay()
+ title = GES.TextOverlay()
title.set_text("")
- title.set_start(self.element.get_start())
- title.set_duration(self.element.get_duration())
+ title.set_start(self.element.start)
+ title.set_duration(self.element.duration)
# FIXME: Creating a text overlay everytime we select a video track object is madness
- self.element.get_timeline_object().add_track_object(title)
+ self.element.get_clip().add_track_element(title)
self.element.get_track().add_object(title)
self.app.gui.title_editor.set_source(title)
self.app.gui.trans_list.deactivate()
@@ -645,12 +645,12 @@ class TrackObject(View, GooCanvas.CanvasGroup, Zoomable, Loggable):
def _update(self):
# Calculating the new position
try:
- x = self.nsToPixel(self.element.get_start())
+ x = self.nsToPixel(self.element.start)
except Exception, e:
raise Exception(e)
# get layer and track_type
- layer = self.element.get_timeline_object().get_layer()
+ layer = self.element.get_clip().get_layer()
track_type = self.element.get_track().get_property("track-type")
# update height, compare with current height to not run into recursion
@@ -693,20 +693,20 @@ class TrackObject(View, GooCanvas.CanvasGroup, Zoomable, Loggable):
self.app.gui.timeline_ui.unsureVadjHeight()
-class TrackTransition(TrackObject):
+class Transition(TrackElement):
"""
- Subclass of TrackObject to account for the differences of transition objects
+ Subclass of TrackElement to account for the differences of transition objects
"""
def __init__(self, instance, element, track, timeline, utrack):
- TrackObject.__init__(self, instance, element, track, timeline, utrack)
+ TrackElement.__init__(self, instance, element, track, timeline, utrack)
for thing in (self.bg, self._selec_indic, self.namebg, self.name):
self.add_child(thing, -1)
- if isinstance(element, GES.TrackVideoTransition):
+ if isinstance(element, GES.VideoTransition):
element.connect("notify::transition-type", self._changeVideoTransitionCb)
self.movable = False
def _setElement(self, element):
- if isinstance(element, GES.TrackVideoTransition):
+ if isinstance(element, GES.VideoTransition):
self.name.props.text = element.props.transition_type.value_nick
def _getColor(self):
@@ -717,12 +717,12 @@ class TrackTransition(TrackObject):
self.name.props.text = transition.props.transition_type.value_nick
-class TrackTitleSource(TrackObject):
+class TitleSource(TrackElement):
"""
- Subclass of TrackObject for titles
+ Subclass of TrackElement for titles
"""
def __init__(self, instance, element, track, timeline, utrack):
- TrackObject.__init__(self, instance, element, track, timeline, utrack)
+ TrackElement.__init__(self, instance, element, track, timeline, utrack)
#self.preview = Preview(self.app, element)
object_thingies = (self.bg, self._selec_indic,
self.start_handle, self.end_handle,
@@ -745,12 +745,12 @@ class TrackTitleSource(TrackObject):
self._update()
-class TrackFileSource(TrackObject):
+class UriSource(TrackElement):
"""
- Subclass of TrackObject to allow thumbnailing of objects with URIs
+ Subclass of TrackElement to allow thumbnailing of objects with URIs
"""
def __init__(self, instance, element, track, timeline, utrack):
- TrackObject.__init__(self, instance, element, track, timeline, utrack)
+ TrackElement.__init__(self, instance, element, track, timeline, utrack)
self.preview = Preview(self.app, element, self.height)
object_thingies = (self.bg, self.preview, self._selec_indic,
self.start_handle, self.end_handle,
@@ -763,7 +763,7 @@ class TrackFileSource(TrackObject):
Set the human-readable file name as the clip's text label
"""
if self.element:
- info = element.get_timeline_object().get_asset().get_info()
+ info = element.get_clip().get_asset().get_info()
self.name.props.text = info_name(info)
twidth, theight = text_size(self.name)
self.namewidth = twidth
@@ -779,7 +779,7 @@ class TrackFileSource(TrackObject):
class Track(GooCanvas.CanvasGroup, Zoomable, Loggable):
"""
- Groups all TrackObjects of one Track
+ Groups all TrackElements of one Track
"""
__gtype_name__ = 'Track'
@@ -834,32 +834,32 @@ class Track(GooCanvas.CanvasGroup, Zoomable, Loggable):
track = property(getTrack, setTrack, None, "The timeline property")
- def _objectAddedCb(self, unused_timeline, track_object):
- if isinstance(track_object, GES.TrackTransition):
- self._transitionAdded(track_object)
- elif isinstance(track_object, GES.TrackTitleSource):
- w = TrackTitleSource(self.app, track_object, self.track, self.timeline, self)
- self.widgets[track_object] = w
+ def _objectAddedCb(self, unused_timeline, track_element):
+ if isinstance(track_element, GES.Transition):
+ self._transitionAdded(track_element)
+ elif isinstance(track_element, GES.TitleSource):
+ w = TitleSource(self.app, track_element, self.track, self.timeline, self)
+ self.widgets[track_element] = w
self.add_child(w, -1)
- elif isinstance(track_object, GES.TrackFileSource):
- w = TrackFileSource(self.app, track_object, self.track, self.timeline, self)
- self.widgets[track_object] = w
+ elif isinstance(track_element, GES.UriSource):
+ w = UriSource(self.app, track_element, self.track, self.timeline, self)
+ self.widgets[track_element] = w
self.add_child(w, -1)
- def _objectRemovedCb(self, unused_timeline, track_object):
- if not isinstance(track_object, GES.TrackEffect) and track_object in self.widgets:
- w = self.widgets[track_object]
- del self.widgets[track_object]
+ def _objectRemovedCb(self, unused_timeline, track_element):
+ if not isinstance(track_element, GES.BaseEffect) and track_element in self.widgets:
+ w = self.widgets[track_element]
+ del self.widgets[track_element]
self.remove_child(self.find_child(w))
Zoomable.removeInstance(w)
def _transitionAdded(self, transition):
- w = TrackTransition(self.app, transition, self.track, self.timeline, self)
+ w = Transition(self.app, transition, self.track, self.timeline, self)
self.widgets[transition] = w
self.add_child(w, -1)
self.transitions.append(w)
w.raise_(None)
- def updateTrackObjects(self):
- for track_object in self.widgets.itervalues():
- track_object._update()
+ def updateTrackElements(self):
+ for track_element in self.widgets.itervalues():
+ track_element._update()
diff --git a/pitivi/titleeditor.py b/pitivi/titleeditor.py
index c6e8738..73e1eec 100644
--- a/pitivi/titleeditor.py
+++ b/pitivi/titleeditor.py
@@ -711,7 +711,7 @@ class TitleEditor(Loggable):
source_text = self.source.get_text()
self.log("Title text set to %s", source_text)
if source_text is None:
- # FIXME: sometimes we get a TrackTextOverlay/TrackTitleSource
+ # FIXME: sometimes we get a TextOverlay/TitleSource
# without a valid text property. This should not happen.
source_text = ""
self.warning('Source did not have a text property, setting it to "" to avoid pango choking
up on None')
@@ -777,7 +777,7 @@ class TitleEditor(Loggable):
def set_source(self, source, created=False): # FIXME: this "created" boolean param is a hack
"""
- Set the GESTimelineTitleSource to be used with the title editor.
+ Set the GESTitleClip to be used with the title editor.
This can be called either from the title editor in _createCb, or by
track.py to set the source to None.
"""
@@ -790,9 +790,9 @@ class TitleEditor(Loggable):
if source is None:
self._deactivate()
else:
- assert isinstance(source, GES.TrackTextOverlay) or \
- isinstance(source, GES.TrackTitleSource) or \
- isinstance(source, GES.TimelineTitleSource)
+ assert isinstance(source, GES.TextOverlay) or \
+ isinstance(source, GES.TitleSource) or \
+ isinstance(source, GES.TitleClip)
self._updateFromSource()
self._activate()
@@ -800,7 +800,7 @@ class TitleEditor(Loggable):
"""
The user clicked the "Create and insert" button, initialize the UI
"""
- source = GES.TimelineTitleSource()
+ source = GES.TitleClip()
source.set_text("")
source.set_duration(long(Gst.SECOND * 5))
self.set_source(source, True)
diff --git a/pitivi/transitions.py b/pitivi/transitions.py
index f8f58bc..e558b81 100644
--- a/pitivi/transitions.py
+++ b/pitivi/transitions.py
@@ -165,7 +165,7 @@ class TransitionsListWidget(Signallable, Gtk.VBox, Loggable):
position = self.app.current.pipeline.getPosition()
self.app.current.pipeline.simple_seek(0)
- self.element.get_timeline_object().set_asset(transition_asset)
+ self.element.get_clip().set_asset(transition_asset)
# Seek back into the previous position, refreshing the preview
self.app.current.pipeline.simple_seek(position)
@@ -258,7 +258,7 @@ class TransitionsListWidget(Signallable, Gtk.VBox, Loggable):
"""
Get the list of transitions from GES and load the associated thumbnails.
"""
- for trans_asset in GES.list_assets(GES.TimelineTransition):
+ for trans_asset in GES.list_assets(GES.BaseTransitionClip):
trans_asset.icon = self._getIcon(trans_asset.get_id())
self.storemodel.append([trans_asset,
str(trans_asset.get_id()),
@@ -278,7 +278,7 @@ class TransitionsListWidget(Signallable, Gtk.VBox, Loggable):
self.element.connect("notify::border", self._borderChangedCb)
self.element.connect("notify::invert", self._invertChangedCb)
self.element.connect("notify::type", self._transitionTypeChangedCb)
- transition_asset = element.get_timeline_object().get_asset()
+ transition_asset = element.get_clip().get_asset()
if transition_asset.get_id() == "crossfade":
self.props_widgets.set_sensitive(False)
else:
diff --git a/pitivi/undo/effect.py b/pitivi/undo/effect.py
index da6a28c..3382782 100644
--- a/pitivi/undo/effect.py
+++ b/pitivi/undo/effect.py
@@ -70,19 +70,19 @@ class EffectGstElementPropertyChangeTracker:
properties[prop.name] = gst_element.get_property(prop.name)
self._tracked_effects[gst_element] = properties
- def getPropChangedFromTrackObj(self, track_effect):
+ def getPropChangedFromTrackObj(self, effect):
prop_changed = []
for undo_stack in self.action_log.undo_stacks:
for done_prop_change in undo_stack.done_actions:
if isinstance(done_prop_change, EffectPropertyChanged):
- if done_prop_change.gst_element is track_effect.getElement():
+ if done_prop_change.gst_element is effect.getElement():
prop_changed.append(done_prop_change)
for redo_stack in self.action_log.redo_stacks:
for done_prop_change in redo_stack.done_actions:
if isinstance(done_prop_change, EffectPropertyChanged):
- if done_prop_change.gst_element is track_effect.getElement():
+ if done_prop_change.gst_element is effect.getElement():
prop_changed.append(done_prop_change)
return prop_changed
@@ -95,109 +95,109 @@ class EffectGstElementPropertyChangeTracker:
self.action_log.push(action)
-class TrackEffectAdded(UndoableAction):
- # Note: We have a bug if we just remove the TrackEffect from the timeline
+class EffectAdded(UndoableAction):
+ # Note: We have a bug if we just remove the Effect from the timeline
# and keep it saved here and then readd it to corresponding timeline (it
- # freezes everything). So what we are doing is to free the TrackEffect,
+ # freezes everything). So what we are doing is to free the Effect,
# keep its settings here when undoing, and instanciate a new one when
# doing again. We have to keep all EffectPropertyChanged object that refers
- # to the TrackEffect when undoing so we reset theirs gst_element when
- # doing it again. The way of doing it is the same with TrackEffectRemoved
- def __init__(self, timeline_object, track_object, properties_watcher):
- self.timeline_object = timeline_object
- self.track_object = track_object
- self.factory = track_object.factory
+ # to the Effect when undoing so we reset theirs gst_element when
+ # doing it again. The way of doing it is the same with EffectRemoved
+ def __init__(self, clip, track_element, properties_watcher):
+ self.clip = clip
+ self.track_element = track_element
+ self.factory = track_element.factory
self.effect_props = []
self.gnl_obj_props = []
self._properties_watcher = properties_watcher
self._props_changed = []
def do(self):
- timeline = self.timeline_object.timeline
+ timeline = self.clip.timeline
tl_obj_track_obj = timeline.addEffectFactoryOnObject(self.factory,
- timeline_objects=[self.timeline_object])
+ clips=[self.clip])
- self.track_object = tl_obj_track_obj[0][1]
- element = self.track_object.getElement()
+ self.track_element = tl_obj_track_obj[0][1]
+ element = self.track_element.getElement()
for prop_name, prop_value in self.effect_props:
element.set_property(prop_name, prop_value)
for prop_name, prop_value in self.gnl_obj_props:
- self.track_object.gnl_object.set_property(prop_name, prop_value)
+ self.track_element.gnl_object.set_property(prop_name, prop_value)
for prop_changed in self._props_changed:
- prop_changed.gst_element = self.track_object.getElement()
+ prop_changed.gst_element = self.track_element.getElement()
self._props_changed = []
self._done()
def undo(self):
- element = self.track_object.getElement()
+ element = self.track_element.getElement()
props = GObject.list_properties(element)
self.effect_props = [(prop.name, element.get_property(prop.name))
for prop in props
if prop.flags & GObject.PARAM_WRITABLE
and prop.name not in PROPS_TO_IGNORE]
- gnl_props = GObject.list_properties(self.track_object.gnl_object)
- gnl_obj = self.track_object.gnl_object
+ gnl_props = GObject.list_properties(self.track_element.gnl_object)
+ gnl_obj = self.track_element.gnl_object
self.gnl_obj_props = [(prop.name, gnl_obj.get_property(prop.name))
for prop in gnl_props
if prop.flags & GObject.PARAM_WRITABLE]
- self.timeline_object.removeTrackObject(self.track_object)
- self.track_object.track.removeTrackObject(self.track_object)
+ self.clip.removeTrackElement(self.track_element)
+ self.track_element.track.removeTrackElement(self.track_element)
self._props_changed =\
- self._properties_watcher.getPropChangedFromTrackObj(self.track_object)
- del self.track_object
- self.track_object = None
+ self._properties_watcher.getPropChangedFromTrackObj(self.track_element)
+ del self.track_element
+ self.track_element = None
self._undone()
-class TrackEffectRemoved(UndoableAction):
- def __init__(self, timeline_object, track_object, properties_watcher):
- self.track_object = track_object
- self.timeline_object = timeline_object
- self.factory = track_object.factory
+class EffectRemoved(UndoableAction):
+ def __init__(self, clip, track_element, properties_watcher):
+ self.track_element = track_element
+ self.clip = clip
+ self.factory = track_element.factory
self.effect_props = []
self.gnl_obj_props = []
self._properties_watcher = properties_watcher
self._props_changed = []
def do(self):
- element = self.track_object.getElement()
+ element = self.track_element.getElement()
props = GObject.list_properties(element)
self.effect_props = [(prop.name, element.get_property(prop.name))
for prop in props
if prop.flags & GObject.PARAM_WRITABLE
and prop.name not in PROPS_TO_IGNORE]
- gnl_props = GObject.list_properties(self.track_object.gnl_object)
- gnl_obj = self.track_object.gnl_object
+ gnl_props = GObject.list_properties(self.track_element.gnl_object)
+ gnl_obj = self.track_element.gnl_object
self.gnl_obj_props = [(prop.name, gnl_obj.get_property(prop.name))
for prop in gnl_props
if prop.flags & GObject.PARAM_WRITABLE]
- self.timeline_object.removeTrackObject(self.track_object)
- self.track_object.track.removeTrackObject(self.track_object)
+ self.clip.removeTrackElement(self.track_element)
+ self.track_element.track.removeTrackElement(self.track_element)
self._props_changed =\
- self._properties_watcher.getPropChangedFromTrackObj(self.track_object)
- del self.track_object
- self.track_object = None
+ self._properties_watcher.getPropChangedFromTrackObj(self.track_element)
+ del self.track_element
+ self.track_element = None
self._done()
def undo(self):
- timeline = self.timeline_object.timeline
+ timeline = self.clip.timeline
tl_obj_track_obj = timeline.addEffectFactoryOnObject(self.factory,
- timeline_objects=[self.timeline_object])
+ clips=[self.clip])
- self.track_object = tl_obj_track_obj[0][1]
- element = self.track_object.getElement()
+ self.track_element = tl_obj_track_obj[0][1]
+ element = self.track_element.getElement()
for prop_name, prop_value in self.effect_props:
element.set_property(prop_name, prop_value)
for prop_name, prop_value in self.gnl_obj_props:
- self.track_object.gnl_object.set_property(prop_name, prop_value)
+ self.track_element.gnl_object.set_property(prop_name, prop_value)
for prop_changed in self._props_changed:
- prop_changed.gst_element = self.track_object.getElement()
+ prop_changed.gst_element = self.track_element.getElement()
self._props_changed = []
self._undone()
diff --git a/pitivi/undo/timeline.py b/pitivi/undo/timeline.py
index d47540a..87e116d 100644
--- a/pitivi/undo/timeline.py
+++ b/pitivi/undo/timeline.py
@@ -21,12 +21,12 @@
from pitivi.utils.signal import Signallable
from pitivi.undo.undo import PropertyChangeTracker, UndoableAction
-from pitivi.undo.effect import TrackEffectAdded, TrackEffectRemoved
+from pitivi.undo.effect import EffectAdded, EffectRemoved
from pitivi.undo.effects import EffectGstElementPropertyChangeTracker
-class TimelineObjectPropertyChangeTracker(PropertyChangeTracker):
+class ClipPropertyChangeTracker(PropertyChangeTracker):
# no out-point
property_names = ["start", "duration", "in-point",
"media-duration", "priority", "selected"]
@@ -54,10 +54,10 @@ class TimelineObjectPropertyChangeTracker(PropertyChangeTracker):
else:
self._disabled = disabled
- def _propertyChangedCb(self, timeline_object, value, property_name):
+ def _propertyChangedCb(self, clip, value, property_name):
if not self._disabled:
PropertyChangeTracker._propertyChangedCb(self,
- timeline_object, value, property_name)
+ clip, value, property_name)
class KeyframeChangeTracker(Signallable):
@@ -105,95 +105,95 @@ class KeyframeChangeTracker(Signallable):
return (keyframe.mode, keyframe.time, keyframe.value)
-class TimelineObjectPropertyChanged(UndoableAction):
- def __init__(self, timeline_object, property_name, old_value, new_value):
- self.timeline_object = timeline_object
+class ClipPropertyChanged(UndoableAction):
+ def __init__(self, clip, property_name, old_value, new_value):
+ self.clip = clip
self.property_name = property_name
self.old_value = old_value
self.new_value = new_value
def do(self):
- setattr(self.timeline_object,
+ setattr(self.clip,
self.property_name.replace("-", "_"), self.new_value)
self._done()
def undo(self):
- setattr(self.timeline_object,
+ setattr(self.clip,
self.property_name.replace("-", "_"), self.old_value)
self._undone()
-class TimelineObjectAdded(UndoableAction):
- def __init__(self, timeline, timeline_object):
+class ClipAdded(UndoableAction):
+ def __init__(self, timeline, clip):
self.timeline = timeline
- self.timeline_object = timeline_object
- self.tracks = dict((track_object, track_object.get_track())
- for track_object in timeline_object.get_track_objects())
+ self.clip = clip
+ self.tracks = dict((track_element, track_element.get_track())
+ for track_element in clip.get_track_elements())
def do(self):
- for track_object, track in self.tracks.iteritems():
- track.addTrackObject(track_object)
+ for track_element, track in self.tracks.iteritems():
+ track.addTrackElement(track_element)
- self.timeline.addTimelineObject(self.timeline_object)
+ self.timeline.addClip(self.clip)
self._done()
def undo(self):
- self.timeline.removeTimelineObject(self.timeline_object, deep=True)
+ self.timeline.removeClip(self.clip, deep=True)
self._undone()
-class TimelineObjectRemoved(UndoableAction):
- def __init__(self, timeline, timeline_object):
+class ClipRemoved(UndoableAction):
+ def __init__(self, timeline, clip):
self.timeline = timeline
- self.timeline_object = timeline_object
- self.tracks = dict((track_object, track_object.get_track())
- for track_object in timeline_object.get_track_objects())
+ self.clip = clip
+ self.tracks = dict((track_element, track_element.get_track())
+ for track_element in clip.get_track_elements())
def do(self):
- self.timeline.removeTimelineObject(self.timeline_object, deep=True)
+ self.timeline.removeClip(self.clip, deep=True)
self._done()
def undo(self):
- for track_object, track in self.tracks.iteritems():
- track.addTrackObject(track_object)
+ for track_element, track in self.tracks.iteritems():
+ track.addTrackElement(track_element)
- self.timeline.addTimelineObject(self.timeline_object)
+ self.timeline.addClip(self.clip)
self._undone()
class InterpolatorKeyframeAdded(UndoableAction):
- def __init__(self, track_object, keyframe):
- self.track_object = track_object
+ def __init__(self, track_element, keyframe):
+ self.track_element = track_element
self.keyframe = keyframe
def do(self):
- self.track_object.newKeyframe(self.keyframe)
+ self.track_element.newKeyframe(self.keyframe)
self._done()
def undo(self):
- self.track_object.removeKeyframe(self.keyframe)
+ self.track_element.removeKeyframe(self.keyframe)
self._undone()
class InterpolatorKeyframeRemoved(UndoableAction):
- def __init__(self, track_object, keyframe):
- self.track_object = track_object
+ def __init__(self, track_element, keyframe):
+ self.track_element = track_element
self.keyframe = keyframe
def do(self):
- self.track_object.removeKeyframe(self.keyframe)
+ self.track_element.removeKeyframe(self.keyframe)
self._undone()
def undo(self):
- self.track_object.newKeyframe(self.keyframe.time,
+ self.track_element.newKeyframe(self.keyframe.time,
self.keyframe.value, self.keyframe.mode)
self._done()
class InterpolatorKeyframeChanged(UndoableAction):
- def __init__(self, track_object, keyframe, old_snapshot, new_snapshot):
- self.track_object = track_object
+ def __init__(self, track_element, keyframe, old_snapshot, new_snapshot):
+ self.track_element = track_element
self.keyframe = keyframe
self.old_snapshot = old_snapshot
self.new_snapshot = new_snapshot
@@ -219,22 +219,22 @@ class ActivePropertyChanged(UndoableAction):
self.active = not active
def do(self):
- self.effect_action.track_object.active = self.active
+ self.effect_action.track_element.active = self.active
self.active = not self.active
self._done()
def undo(self):
- self.effect_action.track_object.active = self.active
+ self.effect_action.track_element.active = self.active
self.active = not self.active
self._undone()
class TimelineLogObserver(object):
- timelinePropertyChangedAction = TimelineObjectPropertyChanged
- timelineObjectAddedAction = TimelineObjectAdded
- timelineObjectRemovedAction = TimelineObjectRemoved
- trackEffectAddAction = TrackEffectAdded
- trackEffectRemovedAction = TrackEffectRemoved
+ timelinePropertyChangedAction = ClipPropertyChanged
+ timelineObjectAddedAction = ClipAdded
+ timelineObjectRemovedAction = ClipRemoved
+ effectAddAction = EffectAdded
+ effectRemovedAction = EffectRemoved
interpolatorKeyframeAddedAction = InterpolatorKeyframeAdded
interpolatorKeyframeRemovedAction = InterpolatorKeyframeRemoved
interpolatorKeyframeChangedAction = InterpolatorKeyframeChanged
@@ -242,7 +242,7 @@ class TimelineLogObserver(object):
def __init__(self, log):
self.log = log
- self.timeline_object_property_trackers = {}
+ self.clip_property_trackers = {}
self.interpolator_keyframe_trackers = {}
self.effect_properties_tracker = EffectGstElementPropertyChangeTracker(log)
self._pipeline = None
@@ -259,17 +259,17 @@ class TimelineLogObserver(object):
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)
+ for clip in layer.get_objects():
+ self._connectToClip(clip)
+ for track_element in clip.track_elements:
+ self._connectToTrackElement(track_element)
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)
+ 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():
@@ -280,32 +280,32 @@ class TimelineLogObserver(object):
timeline.disconnect_by_func(self._timelineObjectAddedCb)
timeline.disconnect_by_func(self._timelineObjectRemovedCb)
- def _connectToTimelineObject(self, timeline_object):
- tracker = TimelineObjectPropertyChangeTracker()
- tracker.connectToObject(timeline_object)
+ def _connectToClip(self, clip):
+ tracker = ClipPropertyChangeTracker()
+ tracker.connectToObject(clip)
for property_name in tracker.property_names:
tracker.connect("notify::" + property_name,
self._timelineObjectPropertyChangedCb, property_name)
- self.timeline_object_property_trackers[timeline_object] = tracker
+ self.clip_property_trackers[clip] = 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)
+ clip.connect("track-object-added", self._timelineObjectTrackElementAddedCb)
+ #clip.connect("track-object-removed", self._timelineObjectTrackElementRemovedCb)
+ for obj in clip.get_track_elements():
+ self._connectToTrackElement(obj)
- def _disconnectFromTimelineObject(self, timeline_object):
- tracker = self.timeline_object_property_trackers.pop(timeline_object)
- tracker.disconnectFromObject(timeline_object)
+ def _disconnectFromClip(self, clip):
+ tracker = self.clip_property_trackers.pop(clip)
+ tracker.disconnectFromObject(clip)
tracker.disconnect_by_func(self._timelineObjectPropertyChangedCb)
- def _connectToTrackObject(self, track_object):
- #for prop, interpolator in track_object.getInterpolators().itervalues():
+ def _connectToTrackElement(self, track_element):
+ #for prop, interpolator in track_element.getInterpolators().itervalues():
#self._connectToInterpolator(interpolator)
- if isinstance(track_object, TrackEffect):
- self.effect_properties_tracker.addEffectElement(track_object.getElement())
+ if isinstance(track_element, GES.BaseEffect):
+ self.effect_properties_tracker.addEffectElement(track_element.getElement())
- def _disconnectFromTrackObject(self, track_object):
- for prop, interpolator in track_object.getInterpolators().itervalues():
+ def _disconnectFromTrackElement(self, track_element):
+ for prop, interpolator in track_element.getInterpolators().itervalues():
self._disconnectFromInterpolator(interpolator)
def _connectToInterpolator(self, interpolator):
@@ -323,62 +323,62 @@ class TimelineLogObserver(object):
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)
+ def _timelineObjectAddedCb(self, timeline, clip):
+ self._connectToClip(clip)
+ action = self.timelineObjectAddedAction(timeline, clip)
self.log.push(action)
- def _timelineObjectRemovedCb(self, timeline, timeline_object):
- self._disconnectFromTimelineObject(timeline_object)
- action = self.timelineObjectRemovedAction(timeline, timeline_object)
+ def _timelineObjectRemovedCb(self, timeline, clip):
+ self._disconnectFromClip(clip)
+ action = self.timelineObjectRemovedAction(timeline, clip)
self.log.push(action)
- def _timelineObjectPropertyChangedCb(self, tracker, timeline_object,
+ def _timelineObjectPropertyChangedCb(self, tracker, clip,
old_value, new_value, property_name):
- action = self.timelinePropertyChangedAction(timeline_object,
+ action = self.timelinePropertyChangedAction(clip,
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)
+ def _timelineObjectTrackElementAddedCb(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 object
- #because the track_object changes when redoing
- track_object.connect("active-changed",
- self._trackObjectActiveChangedCb, action)
+ #because the track_element changes when redoing
+ track_element.connect("active-changed",
+ self._trackElementActiveChangedCb, action)
self.log.push(action)
- element = track_object.getElement()
+ element = track_element.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._connectToTrackElement(track_element)
+
+ def _timelineObjectTrackElementRemovedCb(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._disconnectFromTrackObject(track_object)
+ self._disconnectFromTrackElement(track_element)
- def _interpolatorKeyframeAddedCb(self, track_object, keyframe):
- action = self.interpolatorKeyframeAddedAction(track_object, keyframe)
+ def _interpolatorKeyframeAddedCb(self, track_element, keyframe):
+ action = self.interpolatorKeyframeAddedAction(track_element, keyframe)
self.log.push(action)
- def _interpolatorKeyframeRemovedCb(self, track_object, keyframe,
+ def _interpolatorKeyframeRemovedCb(self, track_element, keyframe,
old_value=None):
- action = self.interpolatorKeyframeRemovedAction(track_object, keyframe)
+ action = self.interpolatorKeyframeRemovedAction(track_element, keyframe)
self.log.push(action)
- def _trackObjectActiveChangedCb(self, track_object, active, add_effect_action):
+ def _trackElementActiveChangedCb(self, track_element, active, add_effect_action):
action = self.activePropertyChangedAction(add_effect_action, active)
self.log.push(action)
- def _interpolatorKeyframeMovedCb(self, tracker, track_object,
+ def _interpolatorKeyframeMovedCb(self, tracker, track_element,
keyframe, old_snapshot, new_snapshot):
- action = self.interpolatorKeyframeChangedAction(track_object,
+ action = self.interpolatorKeyframeChangedAction(track_element,
keyframe, old_snapshot, new_snapshot)
self.log.push(action)
diff --git a/pitivi/utils/timeline.py b/pitivi/utils/timeline.py
index c2ed12f..2f07df9 100644
--- a/pitivi/utils/timeline.py
+++ b/pitivi/utils/timeline.py
@@ -45,18 +45,18 @@ SELECT_BETWEEN = 3
#------------------------------------------------------------------------------#
# Timeline Object management helper #
class TimelineError(Exception):
- """Base Exception for errors happening in L{Timeline}s or L{TimelineObject}s"""
+ """Base Exception for errors happening in L{Timeline}s or L{Clip}s"""
pass
class Selection(Signallable):
"""
- A collection of L{GES.TimelineObject}.
+ A collection of L{GES.Clip}.
Signals:
- C{selection-changed} : The contents of the L{GES.Selection} changed.
- @ivar selected: Set of selected L{GES.TrackObject}
+ @ivar selected: Set of selected L{GES.TrackElement}
@type selected: C{list}
"""
@@ -69,23 +69,23 @@ class Selection(Signallable):
def setToObj(self, obj, mode):
"""
- Convenience method for calling L{setSelection} with a single L{GES.TimelineObject}
+ Convenience method for calling L{setSelection} with a single L{GES.Clip}
@see: L{setSelection}
"""
self.setSelection(set([obj]), mode)
- def addTimelineObject(self, timeline_object):
+ def addClip(self, clip):
"""
- Add the given timeline_object to the selection.
+ Add the given clip to the selection.
- @param timeline_object: The object to add
- @type timeline_object: L{GES.TimelineObject}
+ @param clip: The object to add
+ @type clip: L{GES.Clip}
@raises TimelineError: If the object is already controlled by this
Selection.
"""
- if timeline_object in self.timeline_objects:
- raise TimelineError("TrackObject already in this selection")
+ if clip in self.clips:
+ raise TimelineError("TrackElement already in this selection")
def setSelection(self, objs, mode):
"""
@@ -105,8 +105,8 @@ class Selection(Signallable):
selection = set()
for obj in objs:
# FIXME GES break, handle the fact that we have unlinked objects in GES
- if isinstance(obj, GES.TrackObject):
- selection.add(obj.get_timeline_object())
+ if isinstance(obj, GES.TrackElement):
+ selection.add(obj.get_clip())
else:
selection.add(obj)
@@ -125,38 +125,38 @@ class Selection(Signallable):
self.last_single_obj = iter(selection).next()
for obj in old_selection - self.selected:
- for tckobj in obj.get_track_objects():
- if not isinstance(tckobj, GES.TrackEffect) and not isinstance(tckobj, GES.TrackTextOverlay):
- tckobj.selected.selected = False
+ for track_element in obj.get_track_elements():
+ if not isinstance(track_element, GES.BaseEffect) and not isinstance(track_element,
GES.TextOverlay):
+ track_element.selected.selected = False
for obj in self.selected - old_selection:
- for tckobj in obj.get_track_objects():
- if not isinstance(tckobj, GES.TrackEffect) and not isinstance(tckobj, GES.TrackTextOverlay):
- tckobj.selected.selected = True
+ for track_element in obj.get_track_elements():
+ if not isinstance(track_element, GES.BaseEffect) and not isinstance(track_element,
GES.TextOverlay):
+ track_element.selected.selected = True
self.emit("selection-changed")
def getSelectedTrackObjs(self):
"""
- Returns the list of L{TrackObject} contained in this selection.
+ Returns the list of L{TrackElement} contained in this selection.
"""
objects = []
- for timeline_object in self.selected:
- objects.extend(timeline_object.get_track_objects())
+ for clip in self.selected:
+ objects.extend(clip.get_track_elements())
return set(objects)
- def getSelectedTrackEffects(self):
+ def getSelectedEffects(self):
"""
- Returns the list of L{TrackEffect} contained in this selection.
+ Returns the list of L{GES.BaseEffect} contained in this selection.
"""
- track_effects = []
- for timeline_object in self.selected:
- for track in timeline_object.get_track_objects():
- if isinstance(track, GES.TrackEffect):
- track_effects.append(track)
+ effects = []
+ for clip in self.selected:
+ for track in clip.get_track_elements():
+ if isinstance(track, GES.BaseEffect):
+ effects.append(track)
- return track_effects
+ return effects
def __len__(self):
return len(self.selected)
@@ -181,10 +181,10 @@ class EditingContext(Signallable):
def __init__(self, focus, timeline, mode, edge, other, settings):
"""
- @param focus: the TimelineObject or TrackObject which is to be the
+ @param focus: the Clip or TrackElement which is to be the
main target of interactive editing, such as the object directly under the
mouse pointer
- @type focus: L{GES.TimelineObject} or L{GES.TrackObject}
+ @type focus: L{GES.Clip} or L{GES.TrackElement}
@param timeline: the timeline to edit
@type timeline: instance of L{GES.Timeline}
@@ -199,7 +199,7 @@ class EditingContext(Signallable):
@param other: a set of objects which are the secondary targets of
interactive editing, such as objects in the current selection.
- @type other: a set() of L{TimelineObject}s or L{TrackObject}s
+ @type other: a set() of L{Clip}s or L{TrackElement}s
@param setting: The PiTiVi settings, used to get the snap_distance
parametter
@@ -212,8 +212,8 @@ class EditingContext(Signallable):
other.difference_update(set((focus,)))
self.other = other
- if isinstance(focus, GES.TrackObject):
- self.focus = focus.get_timeline_object()
+ if isinstance(focus, GES.TrackElement):
+ self.focus = focus.get_clip()
else:
self.focus = focus
self.timeline = timeline
diff --git a/pitivi/utils/widgets.py b/pitivi/utils/widgets.py
index 889052b..21b9f46 100644
--- a/pitivi/utils/widgets.py
+++ b/pitivi/utils/widgets.py
@@ -806,7 +806,7 @@ class GstElementSettingsWidget(Gtk.VBox, Loggable):
"No properties."
"""
is_effect = False
- if isinstance(self.element, GES.TrackParseLaunchEffect):
+ if isinstance(self.element, GES.Effect):
is_effect = True
props = [prop for prop in self.element.list_children_properties() if not prop.name in
self.ignore]
else:
diff --git a/pitivi/viewer.py b/pitivi/viewer.py
index 40586ea..7d4b978 100644
--- a/pitivi/viewer.py
+++ b/pitivi/viewer.py
@@ -433,7 +433,7 @@ class PitiviViewer(Gtk.VBox, Loggable):
"""
While a clip is being trimmed, show a live preview of it.
"""
- if isinstance(tl_obj, GES.TimelineTitleSource) or tl_obj.props.is_image or not hasattr(tl_obj,
"get_uri"):
+ if isinstance(tl_obj, GES.TitleClip) or tl_obj.props.is_image or not hasattr(tl_obj, "get_uri"):
self.log("%s is an image or has no URI, so not previewing trim" % tl_obj)
return False
diff --git a/tests/test_timeline_undo.py b/tests/test_timeline_undo.py
index 42499ea..7f22635 100644
--- a/tests/test_timeline_undo.py
+++ b/tests/test_timeline_undo.py
@@ -31,13 +31,13 @@
#from gi.repository import Gst
#from pitivi.pipeline import Pipeline
-#from pitivi.utils.timeline import Timeline, TimelineObject, SELECT_ADD
-#from pitivi.utils.track import Track, SourceTrackObject, TrackEffect
+#from pitivi.utils.timeline import Timeline, Clip, SELECT_ADD
+#from pitivi.utils.track import Track, SourceTrackElement, BaseEffect
#from pitivi.factories.test import VideoTestSourceFactory, TestEffectFactory
#from pitivi.stream import VideoStream
#from pitivi.undo.timeline import TimelineLogObserver, \
- #TimelineObjectAdded, TimelineObjectRemoved, \
- #TimelineObjectPropertyChanged, TrackEffectAdded
+ #ClipAdded, ClipRemoved, \
+ #ClipPropertyChanged, EffectAdded
#from pitivi.undo.undo import UndoableActionLog
#class TestTimelineLogObserver(TimelineLogObserver):
@@ -49,13 +49,13 @@
#TimelineLogObserver._disconnectFromTimeline(self, timeline)
#timeline.connected = False
- #def _connectToTimelineObject(self, timeline_object):
- #TimelineLogObserver._connectToTimelineObject(self, timeline_object)
- #timeline_object.connected = True
+ #def _connectToClip(self, clip):
+ #TimelineLogObserver._connectToClip(self, clip)
+ #clip.connected = True
- #def _disconnectFromTimelineObject(self, timeline_object):
- #TimelineLogObserver._disconnectFromTimelineObject(self, timeline_object)
- #timeline_object.connected = False
+ #def _disconnectFromClip(self, clip):
+ #TimelineLogObserver._disconnectFromClip(self, clip)
+ #clip.connected = False
#def new_stream():
@@ -76,26 +76,26 @@
#stream = new_stream()
#factory = new_source_factory()
#track = Track(stream)
- #track_object1 = SourceTrackObject(factory, stream)
- #track.addTrackObject(track_object1)
+ #track_element1 = SourceTrackElement(factory, stream)
+ #track.addTrackElement(track_element1)
#timeline.addTrack(track)
- #timeline_object1 = TimelineObject(factory)
- #timeline_object1.addTrackObject(track_object1)
- #timeline.addTimelineObject(timeline_object1)
+ #clip1 = Clip(factory)
+ #clip1.addTrackElement(track_element1)
+ #timeline.addClip(clip1)
#self.observer.startObserving(timeline)
#self.failUnless(timeline.connected)
- #self.failUnless(timeline_object1.connected)
+ #self.failUnless(clip1.connected)
- #timeline.removeTimelineObject(timeline_object1)
- #self.failIf(timeline_object1.connected)
+ #timeline.removeClip(clip1)
+ #self.failIf(clip1.connected)
- #timeline.addTimelineObject(timeline_object1)
- #self.failUnless(timeline_object1)
+ #timeline.addClip(clip1)
+ #self.failUnless(clip1)
#self.observer.stopObserving(timeline)
#self.failIf(timeline.connected)
- #self.failIf(timeline_object1.connected)
+ #self.failIf(clip1.connected)
#class TestTimelineUndo(TestCase):
@@ -108,20 +108,20 @@
#self.timeline = Timeline()
#self.timeline.addTrack(self.track1)
#self.timeline.addTrack(self.track2)
- #self.track_object1 = SourceTrackObject(self.factory, self.stream)
- #self.track_object2 = SourceTrackObject(self.factory, self.stream)
- #self.track_effect1 = TrackEffect(self.effect_factory, self.stream)
- #self.track_effect2 = TrackEffect(self.effect_factory, self.stream)
- #self.track1.addTrackObject(self.track_object1)
- #self.track2.addTrackObject(self.track_object2)
- #self.timeline_object1 = TimelineObject(self.factory)
- #self.timeline_object1.addTrackObject(self.track_object1)
- #self.timeline_object1.addTrackObject(self.track_object2)
+ #self.track_element1 = SourceTrackElement(self.factory, self.stream)
+ #self.track_element2 = SourceTrackElement(self.factory, self.stream)
+ #self.base_effect1 = BaseEffect(self.effect_factory, self.stream)
+ #self.base_effect2 = BaseEffect(self.effect_factory, self.stream)
+ #self.track1.addTrackElement(self.track_element1)
+ #self.track2.addTrackElement(self.track_element2)
+ #self.clip1 = Clip(self.factory)
+ #self.clip1.addTrackElement(self.track_element1)
+ #self.clip1.addTrackElement(self.track_element2)
#self.action_log = UndoableActionLog()
#self.observer = TestTimelineLogObserver(self.action_log)
#self.observer.startObserving(self.timeline)
- #def testAddTimelineObject(self):
+ #def testAddClip(self):
#stacks = []
#def commitCb(action_log, stack, nested):
@@ -129,54 +129,54 @@
#self.action_log.connect("commit", commitCb)
#self.action_log.begin("add clip")
- #self.timeline.addTimelineObject(self.timeline_object1)
+ #self.timeline.addClip(self.clip1)
#self.action_log.commit()
#self.failUnlessEqual(len(stacks), 1)
#stack = stacks[0]
#self.failUnlessEqual(len(stack.done_actions), 1)
#action = stack.done_actions[0]
- #self.failUnless(isinstance(action, TimelineObjectAdded))
+ #self.failUnless(isinstance(action, ClipAdded))
- #self.failUnless(self.timeline_object1 \
- #in self.timeline.timeline_objects)
+ #self.failUnless(self.clip1 \
+ #in self.timeline.clips)
#self.action_log.undo()
- #self.failIf(self.timeline_object1 \
- #in self.timeline.timeline_objects)
+ #self.failIf(self.clip1 \
+ #in self.timeline.clips)
#self.action_log.redo()
- #self.failUnless(self.timeline_object1 \
- #in self.timeline.timeline_objects)
+ #self.failUnless(self.clip1 \
+ #in self.timeline.clips)
- #def testRemoveTimelineObject(self):
+ #def testRemoveClip(self):
#stacks = []
#def commitCb(action_log, stack, nested):
#stacks.append(stack)
#self.action_log.connect("commit", commitCb)
- #self.timeline.addTimelineObject(self.timeline_object1)
+ #self.timeline.addClip(self.clip1)
#self.action_log.begin("remove clip")
- #self.timeline.removeTimelineObject(self.timeline_object1, deep=True)
+ #self.timeline.removeClip(self.clip1, deep=True)
#self.action_log.commit()
#self.failUnlessEqual(len(stacks), 1)
#stack = stacks[0]
#self.failUnlessEqual(len(stack.done_actions), 1)
#action = stack.done_actions[0]
- #self.failUnless(isinstance(action, TimelineObjectRemoved))
+ #self.failUnless(isinstance(action, ClipRemoved))
- #self.failIf(self.timeline_object1 \
- #in self.timeline.timeline_objects)
+ #self.failIf(self.clip1 \
+ #in self.timeline.clips)
#self.action_log.undo()
- #self.failUnless(self.timeline_object1 \
- #in self.timeline.timeline_objects)
+ #self.failUnless(self.clip1 \
+ #in self.timeline.clips)
#self.action_log.redo()
- #self.failIf(self.timeline_object1 \
- #in self.timeline.timeline_objects)
+ #self.failIf(self.clip1 \
+ #in self.timeline.clips)
- #def testAddEffectToTimelineObject(self):
+ #def testAddEffectToClip(self):
#stacks = []
#pipeline = Pipeline()
@@ -187,112 +187,112 @@
##FIXME Should I commit it and check there are 2 elements
##in the stacks
- #self.timeline.addTimelineObject(self.timeline_object1)
- #self.track1.addTrackObject(self.track_effect1)
+ #self.timeline.addClip(self.clip1)
+ #self.track1.addTrackElement(self.base_effect1)
#self.action_log.begin("add effect")
- #self.timeline_object1.addTrackObject(self.track_effect1)
+ #self.clip1.addTrackElement(self.base_effect1)
#self.action_log.commit()
#self.failUnlessEqual(len(stacks), 1)
#stack = stacks[0]
#self.failUnlessEqual(len(stack.done_actions), 1)
#action = stack.done_actions[0]
- #self.failUnless(isinstance(action, TrackEffectAdded))
+ #self.failUnless(isinstance(action, EffectAdded))
- #self.failUnless(self.track_effect1 \
- #in self.timeline_object1.track_objects)
- #self.failUnless(self.track_effect1 \
- #in self.track1.track_objects)
+ #self.failUnless(self.base_effect1 \
+ #in self.clip1.track_elements)
+ #self.failUnless(self.base_effect1 \
+ #in self.track1.track_elements)
#self.failUnless(len([effect for effect in \
- #self.timeline_object1.track_objects
- #if isinstance(effect, TrackEffect)]) == 1)
- #self.failUnless(len([effect for effect in self.track1.track_objects
- #if isinstance(effect, TrackEffect)]) == 1)
+ #self.clip1.track_elements
+ #if isinstance(effect, BaseEffect)]) == 1)
+ #self.failUnless(len([effect for effect in self.track1.track_elements
+ #if isinstance(effect, BaseEffect)]) == 1)
#self.action_log.undo()
- #self.failIf(self.track_effect1 \
- #in self.timeline_object1.track_objects)
- #self.failIf(self.track_effect1 \
- #in self.track1.track_objects)
+ #self.failIf(self.base_effect1 \
+ #in self.clip1.track_elements)
+ #self.failIf(self.base_effect1 \
+ #in self.track1.track_elements)
#self.action_log.redo()
#self.failUnless(len([effect for effect in
- #self.timeline_object1.track_objects
- #if isinstance(effect, TrackEffect)]) == 1)
- #self.failUnless(len([effect for effect in self.track1.track_objects
- #if isinstance(effect, TrackEffect)]) == 1)
+ #self.clip1.track_elements
+ #if isinstance(effect, BaseEffect)]) == 1)
+ #self.failUnless(len([effect for effect in self.track1.track_elements
+ #if isinstance(effect, BaseEffect)]) == 1)
- #self.timeline.removeTimelineObject(self.timeline_object1, deep=True)
+ #self.timeline.removeClip(self.clip1, deep=True)
- #def testTimelineObjectPropertyChange(self):
+ #def testClipPropertyChange(self):
#stacks = []
#def commitCb(action_log, stack, nested):
#stacks.append(stack)
#self.action_log.connect("commit", commitCb)
- #self.timeline_object1.start = 5 * Gst.SECOND
- #self.timeline_object1.duration = 20 * Gst.SECOND
- #self.timeline.addTimelineObject(self.timeline_object1)
+ #self.clip1.start = 5 * Gst.SECOND
+ #self.clip1.duration = 20 * Gst.SECOND
+ #self.timeline.addClip(self.clip1)
#self.action_log.begin("modify clip")
- #self.timeline_object1.start = 10 * Gst.SECOND
+ #self.clip1.start = 10 * Gst.SECOND
#self.action_log.commit()
#self.failUnlessEqual(len(stacks), 1)
#stack = stacks[0]
#self.failUnlessEqual(len(stack.done_actions), 1)
#action = stack.done_actions[0]
- #self.failUnless(isinstance(action, TimelineObjectPropertyChanged))
+ #self.failUnless(isinstance(action, ClipPropertyChanged))
- #self.failUnlessEqual(self.timeline_object1.start, 10 * Gst.SECOND)
+ #self.failUnlessEqual(self.clip1.start, 10 * Gst.SECOND)
#self.action_log.undo()
- #self.failUnlessEqual(self.timeline_object1.start, 5 * Gst.SECOND)
+ #self.failUnlessEqual(self.clip1.start, 5 * Gst.SECOND)
#self.action_log.redo()
- #self.failUnlessEqual(self.timeline_object1.start, 10 * Gst.SECOND)
+ #self.failUnlessEqual(self.clip1.start, 10 * Gst.SECOND)
- #self.timeline_object1.priority = 10
+ #self.clip1.priority = 10
#self.action_log.begin("priority change")
- #self.timeline_object1.priority = 20
+ #self.clip1.priority = 20
#self.action_log.commit()
- #self.failUnlessEqual(self.timeline_object1.priority, 20)
+ #self.failUnlessEqual(self.clip1.priority, 20)
#self.action_log.undo()
- #self.failUnlessEqual(self.timeline_object1.priority, 10)
+ #self.failUnlessEqual(self.clip1.priority, 10)
#self.action_log.redo()
- #self.failUnlessEqual(self.timeline_object1.priority, 20)
+ #self.failUnlessEqual(self.clip1.priority, 20)
#def testUngroup(self):
- #self.timeline_object1.start = 5 * Gst.SECOND
- #self.timeline_object1.duration = 20 * Gst.SECOND
+ #self.clip1.start = 5 * Gst.SECOND
+ #self.clip1.duration = 20 * Gst.SECOND
- #self.timeline.addTimelineObject(self.timeline_object1)
- #self.timeline.setSelectionToObj(self.track_object1, SELECT_ADD)
+ #self.timeline.addClip(self.clip1)
+ #self.timeline.setSelectionToObj(self.track_element1, SELECT_ADD)
- #self.failUnlessEqual(len(self.timeline.timeline_objects), 1)
- #self.failUnlessEqual(self.timeline.timeline_objects[0].start,
+ #self.failUnlessEqual(len(self.timeline.clips), 1)
+ #self.failUnlessEqual(self.timeline.clips[0].start,
#5 * Gst.SECOND)
- #self.failUnlessEqual(self.timeline.timeline_objects[0].duration,
+ #self.failUnlessEqual(self.timeline.clips[0].duration,
#20 * Gst.SECOND)
#self.action_log.begin("ungroup")
#self.timeline.ungroupSelection()
#self.action_log.commit()
- #self.failUnlessEqual(len(self.timeline.timeline_objects), 2)
- #self.failUnlessEqual(self.timeline.timeline_objects[0].start,
+ #self.failUnlessEqual(len(self.timeline.clips), 2)
+ #self.failUnlessEqual(self.timeline.clips[0].start,
#5 * Gst.SECOND)
- #self.failUnlessEqual(self.timeline.timeline_objects[0].duration,
+ #self.failUnlessEqual(self.timeline.clips[0].duration,
#20 * Gst.SECOND)
- #self.failUnlessEqual(self.timeline.timeline_objects[1].start,
+ #self.failUnlessEqual(self.timeline.clips[1].start,
#5 * Gst.SECOND)
- #self.failUnlessEqual(self.timeline.timeline_objects[1].duration,
+ #self.failUnlessEqual(self.timeline.clips[1].duration,
#20 * Gst.SECOND)
#self.action_log.undo()
- #self.failUnlessEqual(len(self.timeline.timeline_objects), 1)
- #self.failUnlessEqual(self.timeline.timeline_objects[0].start,
+ #self.failUnlessEqual(len(self.timeline.clips), 1)
+ #self.failUnlessEqual(self.timeline.clips[0].start,
#5 * Gst.SECOND)
- #self.failUnlessEqual(self.timeline.timeline_objects[0].duration,
+ #self.failUnlessEqual(self.timeline.clips[0].duration,
#20 * Gst.SECOND)
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
