def test_move_clip(self):
self._wait_until_project_loaded()
clip1 = GES.TitleClip()
clip1.set_start(0 * Gst.SECOND)
clip1.set_duration(10 * Gst.SECOND)
clip2 = GES.TitleClip()
clip2.set_start(5 * Gst.SECOND)
clip2.set_duration(10 * Gst.SECOND)
self.layer.add_clip(clip1)
self.assertEqual(len(self.layer.get_clips()), 1)
self.layer.add_clip(clip2)
self.assertEqual(len(self.layer.get_clips()), 3)
with self.action_log.started("move clip"):
clip2.set_start(20 * Gst.SECOND)
self.assertEqual(clip2.get_start(), 20 * Gst.SECOND)
self.assertEqual(len(self.layer.get_clips()), 2)
self.action_log.undo()
self.assertEqual(clip2.get_start(), 5 * Gst.SECOND)
self.assertEqual(len(self.layer.get_clips()), 3)
self.action_log.redo()
self.assertEqual(clip2.get_start(), 20 * Gst.SECOND)
self.assertEqual(len(self.layer.get_clips()), 2)
def create_project(with_group=False, saved=False):
"""Creates a project with two clips in a group."""
timeline = GES.Timeline.new_audio_video()
layer = timeline.append_layer()
if with_group:
clip1 = GES.TitleClip()
clip1.set_start(0)
clip1.set_duration(10 * Gst.SECOND)
layer.add_clip(clip1)
clip2 = GES.TitleClip()
clip2.set_start(100 * Gst.SECOND)
clip2.set_duration(10 * Gst.SECOND)
layer.add_clip(clip2)
group = GES.Container.group([clip1, clip2])
if saved:
if isinstance(saved, str):
suffix = "-%s.xges" % saved
else:
suffix = ".xges"
uri = "file://%s" % tempfile.NamedTemporaryFile(suffix=suffix).name
timeline.get_asset().save(timeline, uri, None, overwrite=True)
return timeline
def test_rollback_of_nested_operation_does_not_add_actions_to_parent(self):
clip1 = GES.TitleClip()
clip1.set_start(0 * Gst.SECOND)
clip1.set_duration(1 * Gst.SECOND)
clip2 = GES.TitleClip()
clip2.set_start(1 * Gst.SECOND)
clip2.set_duration(1 * Gst.SECOND)
# begin parent operation
self.action_log.begin("parent")
# push one parent action
self.layer.add_clip(clip1)
stack_snapshot = self.action_log._get_last_stack().done_actions[::]
# begin nested operation
self.action_log.begin("nested")
# push one nested action
self.layer.add_clip(clip2)
self.action_log.rollback()
self.assertListEqual(self.action_log._get_last_stack().done_actions,
stack_snapshot)
def clip_dragged_to_create_layer(self, below):
"""Simulates dragging a clip on a separator, without dropping it."""
self.setup_timeline_container()
timeline_ui = self.timeline_container.timeline
layers = self.timeline.get_layers()
self.assertEqual(len(layers), 1)
clip = GES.TitleClip()
self.layer.add_clip(clip)
# Drag a clip on a separator to create a layer.
with mock.patch.object(Gtk, "get_event_widget") as get_event_widget:
get_event_widget.return_value = clip.ui
event = mock.Mock()
event.x = 0
event.get_button.return_value = True, 1
timeline_ui._button_press_event_cb(None, event)
def translate_coordinates(widget, x, y):
return x, y
clip.ui.translate_coordinates = translate_coordinates
event = mock.Mock()
event.get_state.return_value = Gdk.ModifierType.BUTTON1_MASK
event.x = 1
if below:
event.y = LAYER_HEIGHT * 2
else:
event.y = -1
event.get_button.return_value = True, 1
timeline_ui._motion_notify_event_cb(None, event)
return clip, event, timeline_ui
def test_layer_added(self):
self.setup_timeline_container()
layers = self.timeline.get_layers()
self.assertEqual(len(layers), 1)
clip = GES.TitleClip()
self.layer.add_clip(clip)
self.timeline_container.add_layer_action.emit("activate", None)
layers = self.timeline.get_layers()
self.assertEqual(len(layers), 2)
self.assertEqual(layers[0], self.layer)
self.check_layers(layers)
self.assertEqual(layers[0].get_clips(), [clip])
self.assertEqual(layers[1].get_clips(), [])
self.action_log.undo()
layers = self.timeline.get_layers()
self.assertEqual(len(layers), 1)
self.assertEqual(layers[0], self.layer)
self.check_layers(layers)
self.assertEqual(layers[0].get_clips(), [clip])
self.action_log.redo()
layers = self.timeline.get_layers()
self.assertEqual(len(layers), 2)
self.assertEqual(layers[0], self.layer)
self.check_layers(layers)
self.assertEqual(layers[0].get_clips(), [clip])
self.assertEqual(layers[1].get_clips(), [])
def testConnectionAndDisconnection(self):
timeline = GES.Timeline.new_audio_video()
layer = GES.Layer()
timeline.add_layer(layer)
self.observer.startObserving(timeline)
self.assertTrue(timeline.connected)
clip1 = GES.TitleClip()
layer.add_clip(clip1)
track_element1 = clip1.get_children(False)[0]
self.assertTrue(timeline.connected)
self.assertTrue(clip1.connected)
self.assertTrue(track_element1.connected)
layer.remove_clip(clip1)
self.assertTrue(timeline.connected)
self.assertFalse(clip1.connected)
self.assertFalse(track_element1.connected)
layer.add_clip(clip1)
track_element2 = clip1.get_children(False)[0]
self.assertTrue(timeline.connected)
self.assertTrue(clip1.connected)
self.assertFalse(track_element1.connected)
self.assertTrue(track_element2.connected)
self.observer.stopObserving(timeline)
self.assertFalse(timeline.connected)
self.assertFalse(clip1.connected)
self.assertFalse(track_element1.connected)
self.assertFalse(track_element2.connected)
def test_effects_index(self):
stacks = []
self.action_log.connect("commit", BaseTestUndoTimeline.commit_cb,
stacks)
clip1 = GES.TitleClip()
self.layer.add_clip(clip1)
effect1 = GES.Effect.new("agingtv")
effect2 = GES.Effect.new("edgetv")
clip1.add(effect1)
clip1.add(effect2)
self.assert_effects(clip1, effect1, effect2)
with self.action_log.started("move effect"):
assert clip1.set_top_effect_index(effect2, 0)
self.assertEqual(len(stacks), 1)
self.assert_effects(clip1, effect2, effect1)
self.action_log.undo()
self.assert_effects(clip1, effect1, effect2)
self.action_log.redo()
self.assert_effects(clip1, effect2, effect1)
def testClipPropertyChange(self):
stacks = []
self.action_log.connect("commit", TestTimelineUndo.commitCb, stacks)
clip1 = GES.TitleClip()
self.layer.add_clip(clip1)
clip1.set_start(5 * Gst.SECOND)
clip1.set_duration(20 * Gst.SECOND)
self.layer.add_clip(clip1)
self.action_log.begin("modify clip")
clip1.set_start(10 * Gst.SECOND)
self.action_log.commit()
self.assertEqual(1, len(stacks))
stack = stacks[0]
self.assertEqual(1, len(stack.done_actions))
action = stack.done_actions[0]
self.assertTrue(isinstance(action, ClipPropertyChanged))
self.assertEqual(10 * Gst.SECOND, clip1.get_start())
self.action_log.undo()
self.assertEqual(5 * Gst.SECOND, clip1.get_start())
self.action_log.redo()
self.assertEqual(10 * Gst.SECOND, clip1.get_start())
clip1.set_priority(10)
self.action_log.begin("priority change")
clip1.set_priority(20)
self.action_log.commit()
self.assertEqual(20, clip1.get_priority())
self.action_log.undo()
self.assertEqual(10, clip1.get_priority())
self.action_log.redo()
self.assertEqual(20, clip1.get_priority())
def testRemoveEffectFromClip(self):
stacks = []
self.action_log.connect("commit", BaseTestUndoTimeline.commit_cb, stacks)
clip1 = GES.TitleClip()
self.layer.add_clip(clip1)
effect1 = GES.Effect.new("agingtv")
with self.action_log.started("add effect"):
clip1.add(effect1)
self.assertEqual(1, len(stacks))
stack = stacks[0]
self.assertEqual(1, len(stack.done_actions), stack.done_actions)
action = stack.done_actions[0]
self.assertTrue(isinstance(action, TrackElementAdded))
self.assertTrue(effect1 in clip1.get_children(True))
self.assertEqual(1, len([effect for effect in
clip1.get_children(True)
if isinstance(effect, GES.Effect)]))
with self.action_log.started("remove effect"):
clip1.remove(effect1)
self.assert_effect_count(clip1, 0)
self.action_log.undo()
self.assert_effect_count(clip1, 1)
self.action_log.redo()
self.assert_effect_count(clip1, 0)
def testClipPropertyChange(self):
stacks = []
self.action_log.connect("commit", BaseTestUndoTimeline.commit_cb, stacks)
# We are not dropping clips here...
self.app.gui.timeline_ui.timeline.dropping_clips = False
clip1 = GES.TitleClip()
clip1.set_start(5 * Gst.SECOND)
clip1.set_duration(20 * Gst.SECOND)
self.layer.add_clip(clip1)
with self.action_log.started("modify clip"):
clip1.set_start(10 * Gst.SECOND)
self.assertEqual(1, len(stacks))
stack = stacks[0]
self.assertEqual(1, len(stack.done_actions))
action = stack.done_actions[0]
self.assertTrue(isinstance(action, PropertyChangedAction))
self.assertEqual(10 * Gst.SECOND, clip1.get_start())
self.action_log.undo()
self.assertEqual(5 * Gst.SECOND, clip1.get_start())
self.action_log.redo()
self.assertEqual(10 * Gst.SECOND, clip1.get_start())
clip1.set_priority(10)
with self.action_log.started("priority change"):
clip1.set_priority(20)
self.assertEqual(20, clip1.get_priority())
self.action_log.undo()
self.assertEqual(10, clip1.get_priority())
self.action_log.redo()
self.assertEqual(20, clip1.get_priority())
def testAddEffectToClip(self):
stacks = []
self.action_log.connect("commit", TestTimelineUndo.commitCb, stacks)
clip1 = GES.TitleClip()
self.layer.add_clip(clip1)
effect1 = GES.Effect.new("agingtv")
self.action_log.begin("add effect")
clip1.add(effect1)
self.action_log.commit()
self.assertEqual(1, len(stacks))
stack = stacks[0]
self.assertEqual(1, len(stack.done_actions), stack.done_actions)
action = stack.done_actions[0]
self.assertTrue(isinstance(action, EffectAdded))
self.assertTrue(effect1 in clip1.get_children(True))
self.assertEqual(1, len([effect for effect in
clip1.get_children(True)
if isinstance(effect, GES.Effect)]))
self.action_log.undo()
self.assertFalse(effect1 in clip1.get_children(True))
self.action_log.redo()
self.assertEqual(1, len([effect for effect in
clip1.get_children(True)
if isinstance(effect, GES.Effect)]))
def test_add_effect_to_clip(self):
stacks = []
self.action_log.connect("commit", common.TestCase.commit_cb, stacks)
clip1 = GES.TitleClip()
self.layer.add_clip(clip1)
effect1 = GES.Effect.new("agingtv")
with self.action_log.started("add effect"):
clip1.add(effect1)
self.assertEqual(1, len(stacks))
stack = stacks[0]
self.assertEqual(1, len(stack.done_actions), stack.done_actions)
action = stack.done_actions[0]
self.assertTrue(isinstance(action, TrackElementAdded))
self.assertTrue(effect1 in clip1.get_children(True))
self.assertEqual(
1,
len([
effect for effect in clip1.get_children(True)
if isinstance(effect, GES.Effect)
]))
self.action_log.undo()
self.assertFalse(effect1 in clip1.get_children(True))
self.action_log.redo()
self.assertEqual(
1,
len([
effect for effect in clip1.get_children(True)
if isinstance(effect, GES.Effect)
]))
def create_title_clip_cb(self, unused_button):
title_clip = GES.TitleClip()
duration = self.app.settings.titleClipLength * Gst.MSECOND
title_clip.set_duration(duration)
with self.app.action_log.started(
"add title clip",
finalizing_action=CommitTimelineFinalizingAction(
self._project.pipeline),
toplevel=True):
self.app.gui.editor.timeline_ui.insert_clips_on_first_layer(
[title_clip])
# Now that the clip is inserted in the timeline, it has a source which
# can be used to set its properties.
source = title_clip.get_children(False)[0]
properties = {
"text": DEFAULT_TEXT,
"foreground-color": BACKGROUND_DEFAULT_COLOR,
"color": FOREGROUND_DEFAULT_COLOR,
"font-desc": DEFAULT_FONT_DESCRIPTION,
"valignment": DEFAULT_VALIGNMENT,
"halignment": DEFAULT_HALIGNMENT
}
for prop, value in properties.items():
res = source.set_child_property(prop, value)
assert res, prop
self._selection.set_selection([title_clip], SELECT)
def add_clips_separately(self):
for i in range(3):
clip = GES.TitleClip()
clip.set_start(i * Gst.SECOND)
clip.set_duration(1 * Gst.SECOND)
with self.action_log.started("add clip {}".format(i)):
self.layer.add_clip(clip)
def test_effects_index_with_removal(self):
stacks = []
self.action_log.connect("commit", BaseTestUndoTimeline.commit_cb,
stacks)
clip1 = GES.TitleClip()
self.layer.add_clip(clip1)
effect1 = GES.Effect.new("agingtv")
effect2 = GES.Effect.new("dicetv")
effect3 = GES.Effect.new("edgetv")
with self.action_log.started("Add effect1"):
clip1.add(effect1)
with self.action_log.started("Add effect2"):
clip1.add(effect2)
with self.action_log.started("Add effect3"):
clip1.add(effect3)
self.assert_effects(clip1, effect1, effect2, effect3)
self.action_log.undo()
self.assert_effects(clip1, effect1, effect2)
self.action_log.redo()
self.assert_effects(clip1, effect1, effect2, effect3)
with self.action_log.started("Remove effect"):
assert clip1.remove(effect2)
self.assertEqual(len(stacks), 4)
self.assert_effects(clip1, effect1, effect3)
self.action_log.undo()
self.assert_effects(clip1, effect1, effect2, effect3)
self.action_log.redo()
self.assert_effects(clip1, effect1, effect3)
self.action_log.undo()
self.assert_effects(clip1, effect1, effect2, effect3)
self.action_log.undo()
self.assert_effects(clip1, effect1, effect2)
self.action_log.undo()
self.assert_effects(clip1, effect1)
self.action_log.undo()
self.assert_effects(clip1)
self.action_log.redo()
self.assert_effects(clip1, effect1)
self.action_log.redo()
self.assert_effects(clip1, effect1, effect2)
self.action_log.redo()
self.assert_effects(clip1, effect1, effect2, effect3)
self.action_log.redo()
self.assert_effects(clip1, effect1, effect3)
self.action_log.undo()
self.assert_effects(clip1, effect1, effect2, effect3)
self.action_log.redo()
self.assert_effects(clip1, effect1, effect3)
def test_add_effect_change_property(self):
stacks = []
self.action_log.connect("commit", BaseTestUndoTimeline.commit_cb,
stacks)
clip1 = GES.TitleClip()
self.layer.add_clip(clip1)
effect1 = GES.Effect.new("agingtv")
with self.action_log.started("add effect"):
clip1.add(effect1)
self.assertEqual(1, len(stacks))
stack = stacks[0]
self.assertEqual(1, len(stack.done_actions), stack.done_actions)
action = stack.done_actions[0]
self.assertTrue(isinstance(action, TrackElementAdded))
self.assertTrue(effect1 in clip1.get_children(True))
self.assertEqual(
1,
len([
effect for effect in clip1.get_children(True)
if isinstance(effect, GES.Effect)
]))
with self.action_log.started("change child property"):
effect1.set_child_property("scratch-lines", 0)
self.assertEqual(effect1.get_child_property("scratch-lines")[1], 0)
# Undo effect property change.
self.action_log.undo()
self.assertEqual(effect1.get_child_property("scratch-lines")[1], 7)
# Redo effect property change.
self.action_log.redo()
self.assertEqual(effect1.get_child_property("scratch-lines")[1], 0)
# Undo effect property change.
self.action_log.undo()
self.assertTrue(effect1 in clip1.get_children(True))
# Undo effect add.
self.action_log.undo()
self.assertFalse(effect1 in clip1.get_children(True))
# Redo effect add.
self.action_log.redo()
self.assertTrue(effect1 in clip1.get_children(True))
self.assertEqual(effect1.get_child_property("scratch-lines")[1], 7)
# Redo effect property change.
self.action_log.redo()
self.assertEqual(effect1.get_child_property("scratch-lines")[1], 0)
def test_clip_dragged_to_create_layer_below(self):
self.setup_timeline_container()
timeline_ui = self.timeline_container.timeline
layers = self.timeline.get_layers()
self.assertEqual(len(layers), 1)
clip = GES.TitleClip()
self.layer.add_clip(clip)
# Drag a clip on a separator to create a layer.
with mock.patch.object(Gtk, 'get_event_widget') as get_event_widget:
get_event_widget.return_value = clip.ui
event = mock.Mock()
event.x = 0
event.get_button.return_value = True, 1
timeline_ui._button_press_event_cb(None, event)
def translate_coordinates(widget, x, y):
return x, y
clip.ui.translate_coordinates = translate_coordinates
event = mock.Mock()
event.get_state.return_value = Gdk.ModifierType.BUTTON1_MASK
event.x = 1
event.y = LAYER_HEIGHT * 2
event.get_button.return_value = True, 1
timeline_ui._motion_notify_event_cb(None, event)
timeline_ui._button_release_event_cb(None, event)
layers = self.timeline.get_layers()
self.assertEqual(len(layers), 2)
self.assertEqual(layers[0], self.layer)
self.check_layers(layers)
self.assertEqual(layers[0].get_clips(), [])
self.assertEqual(layers[1].get_clips(), [clip])
self.action_log.undo()
layers = self.timeline.get_layers()
self.assertEqual(len(layers), 1)
self.assertEqual(layers[0], self.layer)
self.check_layers(layers)
self.assertEqual(layers[0].get_clips(), [clip])
self.action_log.redo()
layers = self.timeline.get_layers()
self.assertEqual(len(layers), 2)
self.assertEqual(layers[0], self.layer)
self.check_layers(layers)
self.assertEqual(layers[0].get_clips(), [])
self.assertEqual(layers[1].get_clips(), [clip])
def _createCb(self, unused_button):
"""
The user clicked the "Create and insert" button, initialize the UI
"""
clip = GES.TitleClip()
clip.set_text("")
clip.set_duration(int(Gst.SECOND * 5))
clip.set_color(FOREGROUND_DEFAULT_COLOR)
clip.set_background(BACKGROUND_DEFAULT_COLOR)
# TODO: insert on the current layer at the playhead position.
# If no space is available, create a new layer to insert to on top.
self.app.gui.timeline_ui.insertEnd([clip])
self.app.gui.timeline_ui.timeline.selection.setToObj(clip, SELECT)
def testTrackElementPropertyChanged(self):
clip1 = GES.TitleClip()
self.layer.add_clip(clip1)
with self.action_log.started("Title text change"):
source = clip1.get_children(False)[0]
source.set_child_property("text", "pigs fly!")
self.assertEqual(source.get_child_property("text")[1], "pigs fly!")
self.action_log.undo()
self.assertEqual(source.get_child_property("text")[1], "")
self.action_log.redo()
self.assertEqual(source.get_child_property("text")[1], "pigs fly!")
def create_project(with_group=False, saved=False):
"""Creates a project with two clips in a group."""
project = GES.Project()
timeline = project.extract()
layer = timeline.append_layer()
if with_group:
clip1 = GES.TitleClip()
clip1.set_start(0)
clip1.set_duration(10)
layer.add_clip(clip1)
clip2 = GES.TitleClip()
clip2.set_start(100)
clip2.set_duration(10)
layer.add_clip(clip2)
group = GES.Container.group([clip1, clip2])
if saved:
uri = "file://%s" % tempfile.NamedTemporaryFile(suffix=".xges").name
project.save(timeline, uri, None, overwrite=True)
return timeline
def test_update_clips_asset(self):
timeline_container = common.create_timeline_container()
mainloop = common.create_main_loop()
mainloop.run(until_empty=True)
ges_timeline = timeline_container.ges_timeline
layer, = ges_timeline.get_layers()
title_clip = GES.TitleClip()
title_clip.props.duration = 100
layer.add_clip(title_clip)
self.assertListEqual(list(timeline_container.timeline.clips()),
[title_clip])
# Check the title clips are ignored.
timeline_container.update_clips_asset(mock.Mock())
def test_add_clip(self):
clip1 = GES.TitleClip()
with self.action_log.started("add clip"):
self.layer.add_clip(clip1)
stack, = self.action_log.undo_stacks
self.assertEqual(len(stack.done_actions), 2, stack.done_actions)
self.assertTrue(isinstance(stack.done_actions[0], ClipAdded))
self.assertTrue(clip1 in self.getTimelineClips())
self.action_log.undo()
self.assertFalse(clip1 in self.getTimelineClips())
self.action_log.redo()
self.assertTrue(clip1 in self.getTimelineClips())
def test_switch_context_tab(self):
"""Checks tab switches."""
app = common.create_pitivi_mock()
editorperspective = EditorPerspective(app)
editorperspective.setup_ui()
for expected_tab, b_element in [(2, GES.TitleClip()),
(0, GES.SourceClip()),
(1, GES.TransitionClip())]:
editorperspective.switchContextTab(b_element)
self.assertEqual(editorperspective.context_tabs.get_current_page(),
expected_tab, b_element)
# Make sure the tab does not change when using an invalid argument.
editorperspective.switchContextTab("invalid")
self.assertEqual(editorperspective.context_tabs.get_current_page(),
expected_tab)
def _createCb(self, unused_button):
"""
The user clicked the "Create and insert" button, initialize the UI
"""
source = GES.TitleClip()
source.set_text("")
source.set_duration(long(Gst.SECOND * 5))
self.set_source(source, True)
# TODO: insert on the current layer at the playhead position.
# If no space is available, create a new layer to insert to on top.
self.app.gui.timeline_ui.insertEnd([self.source])
self.app.gui.timeline_ui.timeline.selection.setToObj(
self.source, SELECT)
#After insertion consider as not created
self.created = False
def _createCb(self, unused_button):
clip = GES.TitleClip()
clip.set_duration(int(Gst.SECOND * 5))
self.app.gui.timeline_ui.insertClips([clip])
# Now that the clip is inserted in the timeline, it has a source which
# can be used to set its properties.
source = clip.get_children(False)[0]
assert source.set_child_property("text", "")
assert source.set_child_property("foreground-color",
BACKGROUND_DEFAULT_COLOR)
assert source.set_child_property("color", FOREGROUND_DEFAULT_COLOR)
assert source.set_child_property("font-desc", DEFAULT_FONT_DESCRIPTION)
assert source.set_child_property("valignment", DEFAULT_VALIGNMENT)
assert source.set_child_property("halignment", DEFAULT_HALIGNMENT)
# Select it so the Title editor becomes active.
self._selection.setSelection([clip], SELECT)
def test_switch_context_tab(self):
"""Checks tab switches."""
app = common.create_pitivi_mock()
mainwindow = MainWindow(app)
for expected_tab, b_element in [(2, GES.TitleClip()),
(0, GES.SourceClip()),
(1, GES.TransitionClip())]:
mainwindow.switchContextTab(b_element)
self.assertEqual(mainwindow.context_tabs.get_current_page(),
expected_tab, b_element)
# Make sure the tab does not change when using an invalid argument.
mainwindow.switchContextTab("invalid")
self.assertEqual(mainwindow.context_tabs.get_current_page(),
expected_tab)
mainwindow.destroy()
def test_effect_toggling(self):
clip1 = GES.TitleClip()
self.layer.add_clip(clip1)
effect1 = GES.Effect.new("agingtv")
with self.action_log.started("add effect"):
clip1.add(effect1)
self.assertTrue(effect1.props.active)
self.assert_effect_count(clip1, 1)
with self.action_log.started("toggle effect"):
effect1.props.active = False
self.assertFalse(effect1.props.active)
with self.action_log.started("remove effect"):
clip1.remove(effect1)
self.assert_effect_count(clip1, 0)
# Undo effect removing.
self.action_log.undo()
self.assert_effect_count(clip1, 1)
# Undo effect toggling.
self.action_log.undo()
self.assertTrue(effect1.props.active)
# Redo effect toggling.
self.action_log.redo()
self.assertFalse(effect1.props.active)
# Undo effect toggling.
self.action_log.undo()
self.assertTrue(effect1.props.active)
# Undo effect add.
self.action_log.undo()
self.assertFalse(effect1 in clip1.get_children(True))
# Redo effect add.
self.action_log.redo()
self.assertTrue(effect1 in clip1.get_children(True))
self.assertTrue(effect1.props.active)
# Redo effect toggling.
self.action_log.redo()
self.assertFalse(effect1.props.active)
def _createCb(self, unused_button):
title_clip = GES.TitleClip()
duration = self.app.settings.titleClipLength * Gst.MSECOND
title_clip.set_duration(duration)
self.app.gui.editor.timeline_ui.insert_clips_on_first_layer([title_clip])
# Now that the clip is inserted in the timeline, it has a source which
# can be used to set its properties.
source = title_clip.get_children(False)[0]
assert source.set_child_property("text", "")
assert source.set_child_property("foreground-color", BACKGROUND_DEFAULT_COLOR)
assert source.set_child_property("color", FOREGROUND_DEFAULT_COLOR)
assert source.set_child_property("font-desc", DEFAULT_FONT_DESCRIPTION)
assert source.set_child_property("valignment", DEFAULT_VALIGNMENT)
assert source.set_child_property("halignment", DEFAULT_HALIGNMENT)
# Select it so the Title editor becomes active.
self._selection.setSelection([title_clip], SELECT)
self.app.gui.editor.timeline_ui.timeline.resetSelectionGroup()
self.app.gui.editor.timeline_ui.timeline.current_group.add(title_clip)
def testGetSingleClip(self):
selection = Selection()
clip1 = GES.UriClip()
clip2 = GES.TitleClip()
# Selection empty.
self.assertFalse(selection.getSingleClip(GES.TitleClip))
# Selection contains only a non-requested-type clip.
selection.setSelection([clip1], SELECT)
self.assertFalse(selection.getSingleClip(GES.TitleClip))
# Selection contains only requested-type clip.
selection.setSelection([clip2], SELECT)
self.assertEqual(clip2, selection.getSingleClip(GES.TitleClip))
# Selection contains more than one clip.
selection.setSelection([clip1, clip2], SELECT)
self.assertFalse(selection.getSingleClip(GES.UriClip))
def test_property_change(self):
action_log = UndoableActionLog()
action_log.begin("complex stuff")
stack, = action_log.stacks
clip = GES.TitleClip()
unused_observer = GObjectObserver(clip, ["start"], action_log)
self.assertEqual(len(stack.done_actions), 0)
clip.props.start = 2
self.assertEqual(len(stack.done_actions), 1)
clip.props.start = 2
self.assertEqual(len(stack.done_actions), 1)
clip.props.start = 4
self.assertEqual(len(stack.done_actions), 2)
action = stack.done_actions[-1]
self.assertEqual(action.old_value, 2)
self.assertEqual(action.new_value, 4)
