def setup_timeline_container(self):
project = self.app.project_manager.current_project
self.timeline_container = TimelineContainer(self.app)
self.timeline_container.setProject(project)
timeline = self.timeline_container.timeline
timeline.app.project_manager.current_project = project
timeline.get_parent = mock.MagicMock(
return_value=self.timeline_container)
def create_timeline_container(**settings):
app = create_pitivi_mock(leftClickAlsoSeeks=False, **settings)
app.project_manager = ProjectManager(app)
project = app.project_manager.new_blank_project()
timeline_container = TimelineContainer(app, app.gui.editor.editor_state)
timeline_container.set_project(project)
timeline = timeline_container.timeline
timeline.get_parent = mock.MagicMock(return_value=timeline_container)
app.gui.editor.timeline_ui = timeline_container
return timeline_container
def test_alignment_editor(self):
"""Exercise aligning a clip using the alignment editor."""
# Wait until the project creates a layer in the timeline.
common.create_main_loop().run(until_empty=True)
from pitivi.timeline.timeline import TimelineContainer
timeline_container = TimelineContainer(
self.app, editor_state=self.app.gui.editor.editor_state)
timeline_container.set_project(self.project)
self.app.gui.editor.timeline_ui = timeline_container
clipproperties = ClipProperties(self.app)
clipproperties.new_project_loaded_cb(None, self.project)
self.project.pipeline.get_position = mock.Mock(return_value=0)
transformation_box = clipproperties.transformation_expander
transformation_box._new_project_loaded_cb(self.app, self.project)
timeline = timeline_container.timeline
clip = self.add_clips_simple(timeline, 1)[0]
timeline.selection.select([clip])
source = transformation_box.source
self.assertIsNotNone(source)
height = source.get_child_property("height").value
width = source.get_child_property("width").value
self.assertEqual(source.get_child_property("posx").value, 0)
self.assertEqual(source.get_child_property("posy").value, 0)
alignment_editor = transformation_box.alignment_editor
event = mock.MagicMock()
event.x = 0
event.y = 0
alignment_editor._motion_notify_event_cb(None, event)
alignment_editor._button_release_event_cb(None, None)
self.assertEqual(source.get_child_property("posx").value, -width)
self.assertEqual(source.get_child_property("posy").value, -height)
self.action_log.undo()
self.assertEqual(source.get_child_property("posx").value, 0)
self.assertEqual(source.get_child_property("posy").value, 0)
self.action_log.redo()
self.assertEqual(source.get_child_property("posx").value, -width)
self.assertEqual(source.get_child_property("posy").value, -height)
def test_preset_persistent(self):
"""Checks the render preset is remembered when loading a project."""
project = self.create_simple_project()
self.assertEqual(project.muxer, "webmmux")
self.assertEqual(project.vencoder, "vp8enc")
self.assertDictEqual(project.vcodecsettings, {})
dialog = self.create_rendering_dialog(project)
self.check_quality_widget(dialog,
vencoder="x264enc",
vcodecsettings={
"quantizer": 21,
"pass": 5
},
preset="youtube",
sensitive=True,
value=Quality.MEDIUM)
project_manager = project.app.project_manager
with tempfile.NamedTemporaryFile() as temp_file:
uri = Gst.filename_to_uri(temp_file.name)
project_manager.save_project(uri=uri, backup=False)
app2 = common.create_pitivi()
project2 = app2.project_manager.load_project(uri)
timeline_container = TimelineContainer(
app2, editor_state=app2.gui.editor.editor_state)
timeline_container.set_project(project2)
common.create_main_loop().run(until_empty=True)
self.assertEqual(project2.muxer, "qtmux")
self.assertEqual(project2.vencoder, "x264enc")
self.assertTrue(
set({
"quantizer": 21,
"pass": 5
}.items()).issubset(set(project2.vcodecsettings.items())))
dialog2 = self.create_rendering_dialog(project2)
self.assertTrue(
set({
"quantizer": 21,
"pass": 5
}.items()).issubset(set(project2.vcodecsettings.items())))
self.check_quality_widget(dialog2,
vencoder="x264enc",
vcodecsettings=None,
preset="youtube",
sensitive=True,
value=Quality.MEDIUM)
def create_timeline_container():
app = create_pitivi_mock(leftClickAlsoSeeks=False)
project_manager = ProjectManager(app)
project_manager.newBlankProject()
project = project_manager.current_project
timeline_container = TimelineContainer(app)
timeline_container.setProject(project)
timeline = timeline_container.timeline
timeline.app.project_manager.current_project = project
timeline.get_parent = mock.MagicMock(return_value=timeline_container)
app.gui.timeline_ui = timeline_container
return timeline_container
def createTimeline(self):
app = common.create_pitivi_mock()
project_manager = ProjectManager(app)
project_manager.newBlankProject()
project = project_manager.current_project
timeline_container = TimelineContainer(app)
timeline_container.setProject(project)
timeline = timeline_container.timeline
timeline.app.project_manager.current_project = project
timeline.get_parent = mock.MagicMock(return_value=timeline_container)
timeline.app.settings.leftClickAlsoSeeks = False
return timeline
def test_rendering_with_unsupported_asset_scaled_proxies(self):
"""Tests rendering with scaled proxies."""
sample_name = "30fps_numeroted_frames_red.mkv"
with common.cloned_sample(sample_name):
self.check_import([sample_name],
proxying_strategy=ProxyingStrategy.AUTOMATIC)
project = self.app.project_manager.current_project
proxy_manager = self.app.proxy_manager
timeline_container = TimelineContainer(
self.app, editor_state=self.app.gui.editor.editor_state)
timeline_container.set_project(project)
rendering_asset = None
asset, = project.list_assets(GES.UriClip)
with mock.patch.object(proxy_manager,
"is_asset_format_well_supported",
return_value=False):
proxy = self.check_add_proxy(asset, scaled=True)
# Check that HQ proxy was created
hq_uri = self.app.proxy_manager.get_proxy_uri(asset)
self.assertTrue(os.path.exists(Gst.uri_get_location(hq_uri)),
hq_uri)
layer, = project.ges_timeline.get_layers()
clip = proxy.extract()
layer.add_clip(clip)
def _use_proxy_assets():
nonlocal layer, asset, rendering_asset
clip, = layer.get_clips()
rendering_asset = clip.get_asset()
old_use_proxy_assets()
dialog = self.create_rendering_dialog(project)
old_use_proxy_assets = dialog._use_proxy_assets
dialog._use_proxy_assets = _use_proxy_assets
self.render(dialog)
self.mainloop.run(until_empty=True)
# Check rendering used HQ proxy
self.assertTrue(proxy_manager.is_hq_proxy(rendering_asset))
# Check asset was replaced with scaled proxy after rendering
self.assertTrue(proxy_manager.is_scaled_proxy(
clip.get_asset()))
def test_rendering_with_scaled_proxies(self):
"""Tests rendering with scaled proxies."""
sample_name = "30fps_numeroted_frames_red.mkv"
with common.cloned_sample(sample_name):
self.check_import([sample_name],
proxying_strategy=ProxyingStrategy.NOTHING)
project = self.app.project_manager.current_project
proxy_manager = self.app.proxy_manager
timeline_container = TimelineContainer(
self.app, editor_state=self.app.gui.editor.editor_state)
timeline_container.set_project(project)
rendering_asset = None
asset, = project.list_assets(GES.UriClip)
proxy = self.check_add_proxy(asset, scaled=True)
layer, = project.ges_timeline.get_layers()
clip = proxy.extract()
layer.add_clip(clip)
# Patch the function that reverts assets to proxies after rendering.
from pitivi.render import RenderDialog
old_use_proxy_assets = RenderDialog._use_proxy_assets
def check_use_proxy_assets(self):
nonlocal layer, asset, rendering_asset
clip, = layer.get_clips()
rendering_asset = clip.get_asset()
old_use_proxy_assets(self)
RenderDialog._use_proxy_assets = check_use_proxy_assets
try:
dialog = self.create_rendering_dialog(project)
self.render(dialog)
self.mainloop.run(until_empty=True)
finally:
RenderDialog._use_proxy_assets = old_use_proxy_assets
# Check rendering did not use scaled proxy
self.assertFalse(proxy_manager.is_scaled_proxy(rendering_asset))
# Check asset was replaced with scaled proxy after rendering
self.assertTrue(proxy_manager.is_scaled_proxy(clip.get_asset()))
def test_color_change(self):
"""Exercise the changing of colors for color clip."""
# Wait until the project creates a layer in the timeline.
common.create_main_loop().run(until_empty=True)
from pitivi.timeline.timeline import TimelineContainer
timeline_container = TimelineContainer(
self.app, editor_state=self.app.gui.editor.editor_state)
timeline_container.set_project(self.project)
self.app.gui.editor.timeline_ui = timeline_container
clipproperties = ClipProperties(self.app)
clipproperties.new_project_loaded_cb(None, self.project)
self.project.pipeline.get_position = mock.Mock(return_value=0)
clipproperties.create_color_clip_cb(None)
color_expander = clipproperties.color_expander
color_picker_mock = mock.Mock()
color_picker_mock.calculate_argb.return_value = 1 << 24 | 2 << 16 | 3 << 8 | 4
color_expander._color_picker_value_changed_cb(color_picker_mock)
color = color_expander.source.get_child_property("foreground-color")[1]
self.assertEqual(color, 0x1020304)
def _create_ui(self):
"""Creates the graphical interface.
The rough hierarchy is:
vpaned:
- mainhpaned(secondhpaned(main_tabs, context_tabs), viewer)
- timeline_ui
The full hierarchy can be admired by starting the GTK+ Inspector
with Ctrl+Shift+I.
"""
# pylint: disable=attribute-defined-outside-init
# Main "toolbar" (using client-side window decorations with HeaderBar)
self.headerbar = self.__create_headerbar()
# Set up our main containers, in the order documented above
# Separates the tabs+viewer from the timeline
self.toplevel_widget = Gtk.Paned(orientation=Gtk.Orientation.VERTICAL)
# Separates the tabs from the viewer
self.mainhpaned = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL)
# Separates the two sets of tabs
self.secondhpaned = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL)
self.toplevel_widget.pack1(self.mainhpaned, resize=False, shrink=False)
self.mainhpaned.pack1(self.secondhpaned, resize=True, shrink=False)
self.toplevel_widget.show()
self.secondhpaned.show()
self.mainhpaned.show()
# First set of tabs
self.main_tabs = BaseTabs(self.app)
self.medialibrary = MediaLibraryWidget(self.app)
self.effectlist = EffectListWidget(self.app)
self.main_tabs.append_page("Media Library", self.medialibrary,
Gtk.Label(label=_("Media Library")))
self.main_tabs.append_page("Effect Library", self.effectlist,
Gtk.Label(label=_("Effect Library")))
self.medialibrary.connect('play', self._media_library_play_cb)
self.medialibrary.show()
self.effectlist.show()
# Second set of tabs
self.context_tabs = BaseTabs(self.app)
self.clipconfig = ClipProperties(self.app)
self.trans_list = TransitionsListWidget(self.app)
self.context_tabs.append_page("Clip", self.clipconfig,
Gtk.Label(label=_("Clip")))
self.context_tabs.append_page("Transition", self.trans_list,
Gtk.Label(label=_("Transition")))
# Show by default the Title tab, as the Clip and Transition tabs
# are useful only when a clip or transition is selected, but
# the Title tab allows adding titles.
self.context_tabs.set_current_page(2)
self.secondhpaned.pack1(self.main_tabs, resize=False, shrink=False)
self.secondhpaned.pack2(self.context_tabs, resize=False, shrink=False)
self.main_tabs.show()
self.context_tabs.show()
# Viewer
self.viewer = ViewerContainer(self.app)
self.mainhpaned.pack2(self.viewer, resize=True, shrink=False)
# Now, the lower part: the timeline
self.timeline_ui = TimelineContainer(self.app, self.editor_state)
self.toplevel_widget.pack2(self.timeline_ui, resize=True, shrink=False)
self.intro = InteractiveIntro(self.app)
self.headerbar.pack_end(self.intro.intro_button)
# Setup shortcuts for HeaderBar buttons and menu items.
self._create_actions()
# Identify widgets for AT-SPI, making our test suite easier to develop
# These will show up in sniff, accerciser, etc.
self.headerbar.get_accessible().set_name("editor_headerbar")
self.menu_button.get_accessible().set_name("main menu button")
self.toplevel_widget.get_accessible().set_name("contents")
self.mainhpaned.get_accessible().set_name("upper half")
self.secondhpaned.get_accessible().set_name("tabs")
self.main_tabs.get_accessible().set_name("primary tabs")
self.context_tabs.get_accessible().set_name("secondary tabs")
self.viewer.get_accessible().set_name("viewer")
self.timeline_ui.get_accessible().set_name("timeline area")
# Restore settings for position and visibility.
if self.settings.mainWindowHPanePosition is None:
self._set_default_positions()
self.secondhpaned.set_position(self.settings.mainWindowHPanePosition)
self.mainhpaned.set_position(self.settings.mainWindowMainHPanePosition)
self.toplevel_widget.set_position(
self.settings.mainWindowVPanePosition)
