def __init__(self, log):
self.log = log
self.clip_property_trackers = {}
self.control_source_keyframe_trackers = {}
self.children_props_tracker = TrackElementChildPropertyTracker(log)
self._pipeline = None
Loggable.__init__(self)
def __init__(self, instance, uimap):
Loggable.__init__(self)
Signallable.__init__(self)
self.app = instance
self.bt = {}
self.settings = {}
self.source = None
self.created = False
self.seeker = Seeker()
#Drag attributes
self._drag_events = []
self._signals_connected = False
self._createUI()
self.textbuffer = Gtk.TextBuffer()
self.pangobuffer = InteractivePangoBuffer()
self.textarea.set_buffer(self.pangobuffer)
self.textbuffer.connect("changed", self._updateSourceText)
self.pangobuffer.connect("changed", self._updateSourceText)
#Connect buttons
self.pangobuffer.setup_widget_from_pango(self.bt["bold"], "<b>bold</b>")
self.pangobuffer.setup_widget_from_pango(self.bt["italic"], "<i>italic</i>")
def __init__(self, timeline):
Gtk.DrawingArea.__init__(self)
Zoomable.__init__(self)
Loggable.__init__(self)
self.log("Creating new ScaleRuler")
self.timeline = timeline
self._pipeline = None
hadj = timeline.timeline.hadj
hadj.connect("value-changed", self._hadj_value_changed_cb)
self.add_events(Gdk.EventMask.POINTER_MOTION_MASK |
Gdk.EventMask.BUTTON_PRESS_MASK | Gdk.EventMask.BUTTON_RELEASE_MASK |
Gdk.EventMask.SCROLL_MASK)
self.pixbuf = None
# all values are in pixels
self.pixbuf_offset = 0
self.pixbuf_offset_painted = 0
self.position = 0 # In nanoseconds
self.frame_rate = Gst.Fraction(1 / 1)
self.ns_per_frame = float(1 / self.frame_rate) * Gst.SECOND
self.scales = SCALES
def __init__(self):
gtk.VBox.__init__(self)
Loggable.__init__(self)
self.element = None
self.ignore = None
self.properties = None
self.buttons = {}
def __init__(self, app, undock_action=None):
Gtk.VBox.__init__(self)
self.set_border_width(SPACING)
self.app = app
self.settings = app.settings
self.system = app.system
Loggable.__init__(self)
self.log("New ViewerContainer")
self.pipeline = None
self.docked = True
self.seeker = Seeker()
# Only used for restoring the pipeline position after a live clip trim preview:
self._oldTimelinePos = None
self._haveUI = False
self._createUi()
self.undock_action = undock_action
if undock_action:
self.undock_action.connect("activate", self._toggleDocked)
if not self.settings.viewerDocked:
self.undock()
def __init__(self, instance, hadj):
gtk.DrawingArea.__init__(self)
Zoomable.__init__(self)
Loggable.__init__(self)
self.log("Creating new ScaleRuler")
self.app = instance
self._seeker = Seeker()
self.hadj = hadj
hadj.connect("value-changed", self._hadjValueChangedCb)
self.add_events(gtk.gdk.POINTER_MOTION_MASK |
gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK)
self.pixbuf = None
# all values are in pixels
self.pixbuf_offset = 0
self.pixbuf_offset_painted = 0
# This is the number of width we allocate for the pixbuf
self.pixbuf_multiples = 4
self.position = 0 # In nanoseconds
self.pressed = False
self.need_update = True
self.min_frame_spacing = 5.0
self.frame_height = 5.0
self.frame_rate = gst.Fraction(1 / 1)
def __init__(self, settings=None, realizedCb=None):
# Prevent black frames and flickering while resizing or changing focus:
# The aspect ratio gets overridden by setDisplayAspectRatio.
Gtk.AspectFrame.__init__(self, xalign=0.5, yalign=1.0,
ratio=4.0 / 3.0, obey_child=False)
Loggable.__init__(self)
self.drawing_area = GtkClutter.Embed()
self.drawing_area.set_double_buffered(False)
# We keep the ViewerWidget hidden initially, or the desktop wallpaper
# would show through the non-double-buffered widget!
if realizedCb:
self.drawing_area.connect("realize", realizedCb, self)
self.add(self.drawing_area)
layout_manager = Clutter.BinLayout(x_align=Clutter.BinAlignment.FILL, y_align=Clutter.BinAlignment.FILL)
self.drawing_area.get_stage().set_layout_manager(layout_manager)
self.texture = Clutter.Texture()
# This is a trick to make the viewer appear darker at the start.
self.texture.set_from_rgb_data(data=[0] * 3, has_alpha=False,
width=1, height=1, rowstride=3, bpp=3,
flags=Clutter.TextureFlags.NONE)
self.drawing_area.get_stage().add_child(self.texture)
self.drawing_area.show()
self.seeker = Seeker()
self.settings = settings
self.box = None
self.stored = False
self.area = None
self.zoom = 1.0
self.sink = None
self.pixbuf = None
self.pipeline = None
self.transformation_properties = None
def __init__(self, app):
Gtk.Box.__init__(self)
Loggable.__init__(self)
self.app = app
self.settings = app.settings
self._project = None
self.set_orientation(Gtk.Orientation.VERTICAL)
self.infobar_box = Gtk.Box()
self.infobar_box.set_orientation(Gtk.Orientation.VERTICAL)
self.infobar_box.show()
self.pack_start(self.infobar_box, False, False, 0)
# Transformation boxed DISABLED
# self.transformation_expander = TransformationProperties(instance, instance.action_log)
# self.transformation_expander.set_vexpand(False)
# vbox.pack_start(self.transformation_expander, False, False, 0)
effects_properties_manager = EffectsPropertiesManager(app)
self.effect_expander = EffectProperties(
app, effects_properties_manager, self)
self.effect_expander.set_vexpand(False)
viewport = Gtk.ScrolledWindow()
viewport.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
viewport.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
viewport.set_visible(True)
viewport.add(self.effect_expander)
self.pack_start(viewport, True, True, 0)
def __init__(self, app):
Gtk.Expander.__init__(self)
Loggable.__init__(self)
self.app = app
self._project = None
self._selection = None
self.source = None
self._selected_clip = None
self.spin_buttons = {}
self.spin_buttons_handler_ids = {}
self.set_label(_("Transformation"))
self.builder = Gtk.Builder()
self.builder.add_from_file(os.path.join(get_ui_dir(),
"cliptransformation.ui"))
self.__control_bindings = {}
# Used to make sure self.__control_bindings_changed doesn't get called
# when bindings are changed from this class
self.__own_bindings_change = False
self.add(self.builder.get_object("transform_box"))
self._initButtons()
self.show_all()
self.hide()
self.app.project_manager.connect_after(
"new-project-loaded", self._newProjectLoadedCb)
self.app.project_manager.connect_after(
"project-closed", self.__project_closed_cb)
def __init__(self, bElement, timeline):
Clutter.Actor.__init__(self)
Zoomable.__init__(self)
Loggable.__init__(self)
PreviewGenerator.__init__(self, GES.TrackType.AUDIO)
self.pipeline = None
self.discovered = False
self.bElement = bElement
self._uri = quote_uri(bElement.props.uri) # Guard against malformed URIs
self.timeline = timeline
self.actors = []
self.set_content_scaling_filters(Clutter.ScalingFilter.NEAREST, Clutter.ScalingFilter.NEAREST)
self.canvas = Clutter.Canvas()
self.set_content(self.canvas)
self.width = 0
self._num_failures = 0
self.lastUpdate = datetime.now()
self.interval = timedelta(microseconds=INTERVAL)
self.current_geometry = (-1, -1)
self.adapter = None
self.surface = None
self.timeline.connect("scrolled", self._scrolledCb)
self.canvas.connect("draw", self._drawContentCb)
self.canvas.invalidate()
self._callback_id = 0
def __init__(self, ges_layer, timeline):
Gtk.EventBox.__init__(self)
Zoomable.__init__(self)
Loggable.__init__(self)
self.ges_layer = ges_layer
self.ges_layer.ui = self
self.timeline = timeline
self.app = timeline.app
self.ges_layer.connect("clip-added", self._clipAddedCb)
self.ges_layer.connect("clip-removed", self._clipRemovedCb)
# FIXME Make the layer height user setable with 'Paned'
self.props.height_request = ui.LAYER_HEIGHT / 2
self.props.valign = Gtk.Align.START
self._layout = LayerLayout(self.timeline)
self._layout.connect("remove", self.__childWidgetRemovedCb)
self.add(self._layout)
self.media_types = GES.TrackType(0)
for clip in ges_layer.get_clips():
self._addClip(clip)
self.before_sep = SpacedSeparator(Gtk.PositionType.TOP)
self.after_sep = SpacedSeparator(Gtk.PositionType.BOTTOM)
def __init__(self, ges_elem, max_cpu_usage):
Previewer.__init__(self, GES.TrackType.AUDIO, max_cpu_usage)
Zoomable.__init__(self)
Loggable.__init__(self)
self.pipeline = None
self._wavebin = None
self.discovered = False
self.ges_elem = ges_elem
self.timeline = ges_elem.get_parent().get_timeline().ui
asset = self.ges_elem.get_parent().get_asset()
self.n_samples = asset.get_duration() / SAMPLE_DURATION
self.samples = None
self.peaks = None
self._start = 0
self._end = 0
self._surface_x = 0
# Guard against malformed URIs
self.wavefile = None
self._uri = quote_uri(get_proxy_target(ges_elem).props.id)
self._num_failures = 0
self.adapter = None
self.surface = None
self._force_redraw = True
self.ges_elem.connect("notify::in-point", self._inpoint_changed_cb)
self.connect("notify::height-request", self._height_changed_cb)
self.becomeControlled()
def __init__(self, app):
Gtk.ScrolledWindow.__init__(self)
Loggable.__init__(self)
self.app = app
self.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
viewport = Gtk.Viewport()
viewport.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
viewport.show()
self.add(viewport)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
vbox.show()
viewport.add(vbox)
self.infobar_box = Gtk.Box()
self.infobar_box.set_orientation(Gtk.Orientation.VERTICAL)
self.infobar_box.show()
vbox.pack_start(self.infobar_box, False, False, 0)
transformation_expander = TransformationProperties(app)
transformation_expander.set_vexpand(False)
vbox.pack_start(transformation_expander, False, False, 0)
self.effect_expander = EffectProperties(app, self)
self.effect_expander.set_vexpand(False)
vbox.pack_start(self.effect_expander, False, False, 0)
def __init__(self):
Loggable.__init__(self)
# Init logging as early as possible so we can log startup code
enable_color = not os.environ.get('PITIVI_DEBUG_NO_COLOR', '0') in ('', '1')
# Let's show a human-readable pitivi debug output by default, and only
# show a crazy unreadable mess when surrounded by gst debug statements.
enable_crack_output = "GST_DEBUG" in os.environ
log.init('PITIVI_DEBUG', enable_color, enable_crack_output)
self.info('starting up')
self.settings = GlobalSettings()
self.threads = ThreadMaster()
self.effects = EffectsHandler()
self.system = getSystem()
self.current_project = None
self.projectManager = ProjectManager(self)
self._connectToProjectManager(self.projectManager)
self.action_log = UndoableActionLog()
self.debug_action_log_observer = DebugActionLogObserver()
self.debug_action_log_observer.startObserving(self.action_log)
# TODO reimplement the observing after GES port
#self.timelineLogObserver = TimelineLogObserver(self.action_log)
self.projectLogObserver = ProjectLogObserver(self.action_log)
self._version_information = {}
self._checkVersion()
def __init__(self, timeline, hadj):
Gtk.DrawingArea.__init__(self)
Zoomable.__init__(self)
Loggable.__init__(self)
self.log("Creating new ScaleRuler")
self.timeline = timeline
self._pipeline = None
self.hadj = hadj
hadj.connect("value-changed", self._hadjValueChangedCb)
self.add_events(Gdk.EventMask.POINTER_MOTION_MASK |
Gdk.EventMask.BUTTON_PRESS_MASK | Gdk.EventMask.BUTTON_RELEASE_MASK |
Gdk.EventMask.SCROLL_MASK)
self.pixbuf = None
# all values are in pixels
self.pixbuf_offset = 0
self.pixbuf_offset_painted = 0
self.position = 0 # In nanoseconds
self.frame_rate = Gst.Fraction(1 / 1)
self.ns_per_frame = float(1 / self.frame_rate) * Gst.SECOND
self.playhead_pixbuf = GdkPixbuf.Pixbuf.new_from_file(
os.path.join(configure.get_pixmap_dir(), "pitivi-playhead.svg"))
self.scales = SCALES
def __init__(self, app):
Loggable.__init__(self)
self.app = app
self.app.shortcuts.connect("accel-changed", self.__accel_changed_cb)
self.settings = app.settings
self.widgets = {}
self.resets = {}
self.original_values = {}
self.action_ids = {}
# Identify the widgets we'll need
builder = Gtk.Builder()
builder.add_from_file(os.path.join(get_ui_dir(), "preferences.ui"))
builder.connect_signals(self)
self.dialog = builder.get_object("dialog1")
self.sidebar = builder.get_object("sidebar")
self.stack = builder.get_object("stack")
self.revert_button = builder.get_object("revertButton")
self.factory_settings = builder.get_object("resetButton")
self.restart_warning = builder.get_object("restartWarning")
for section_id in self.settings_sections:
self.add_settings_page(section_id)
self.factory_settings.set_sensitive(self._canReset())
self.__add_shortcuts_section()
self.__add_plugin_manager_section()
self.dialog.set_transient_for(app.gui)
def __init__(self, app):
GObject.Object.__init__(self)
Loggable.__init__(self)
self.app = app
self._total_time_to_transcode = 0
self._total_transcoded_time = 0
self._start_proxying_time = 0
self._estimated_time = 0
self.__running_transcoders = []
self.__pending_transcoders = []
self.__encoding_target_file = None
self.proxyingUnsupported = False
for encoding_format in [ENCODING_FORMAT_JPEG, ENCODING_FORMAT_PRORES]:
self.__encoding_profile = self.__getEncodingProfile(encoding_format)
if self.__encoding_profile:
self.__encoding_target_file = encoding_format
self.info("Using %s as proxying format", encoding_format)
break
if not self.__encoding_profile:
self.proxyingUnsupported = True
self.error("Not supporting any proxy formats!")
return
def __init__(self):
Gtk.Application.__init__(self,
application_id="org.pitivi",
flags=Gio.ApplicationFlags.HANDLES_OPEN)
Loggable.__init__(self)
self.settings = None
self.threads = None
self.effects = None
self.system = None
self.project_manager = ProjectManager(self)
self.action_log = UndoableActionLog(self)
self.timeline_log_observer = None
self.project_log_observer = None
self._last_action_time = Gst.util_get_timestamp()
self.gui = None
self.welcome_wizard = None
self._version_information = {}
self._scenario_file = None
self._first_action = True
Zoomable.app = self
self.connect("startup", self._startupCb)
self.connect("activate", self._activateCb)
self.connect("open", self.openCb)
def __init__(self, pipeline):
Loggable.__init__(self)
Signallable.__init__(self)
self._pipeline = pipeline
self._bus = self._pipeline.get_bus()
self._bus.add_signal_watch()
self._bus.connect("message", self._busMessageCb)
self._listening = False # for the position handler
self._listeningInterval = 300 # default 300ms
self._listeningSigId = 0
self._duration = Gst.CLOCK_TIME_NONE
self.lastPosition = int(0 * Gst.SECOND)
self.pendingRecovery = False
self._attempted_recoveries = 0
self._waiting_for_async_done = True
self._next_seek = None
self._timeout_async_id = 0
# Create a cluttersink element used for display. Subclasses must connect
# it to self._pipeline themselves
self._clutter_sink = Gst.ElementFactory.make("cluttersink", None)
if isinstance(pipeline, GES.Pipeline):
self._pipeline.preview_set_video_sink(self._clutter_sink)
else:
self._pipeline.set_property("video_sink", self._clutter_sink)
def __init__(self, app, undock_action=None):
Gtk.VBox.__init__(self)
self.set_border_width(SPACING)
self.app = app
self.settings = app.settings
self.system = app.system
Loggable.__init__(self)
self.log("New PitiviViewer")
self.pipeline = None
self._tmp_pipeline = None # Used for displaying a preview when trimming
self.sink = None
self.docked = True
# Only used for restoring the pipeline position after a live clip trim preview:
self._oldTimelinePos = None
self._haveUI = False
self._createUi()
self.target = self.internal
self.undock_action = undock_action
if undock_action:
self.undock_action.connect("activate", self._toggleDocked)
if not self.settings.viewerDocked:
self.undock()
def __init__(self):
Gtk.Application.__init__(self,
application_id="org.pitivi",
flags=Gio.ApplicationFlags.HANDLES_OPEN)
Loggable.__init__(self)
self.settings = None
self.threads = None
self.effects = None
self.system = None
self.project_manager = ProjectManager(self)
self.action_log = None
self.project_observer = None
self._last_action_time = Gst.util_get_timestamp()
self.gui = None
self.__welcome_wizard = None
self._version_information = {}
self._scenario_file = None
self._first_action = True
Zoomable.app = self
self.shortcuts = ShortcutsManager(self)
def __init__(self):
Gtk.Button.__init__(self)
Loggable.__init__(self)
self.image = Gtk.Image()
self.add(self.image)
self.playing = False
self.setPlay()
def __init__(self, app):
Gtk.Box.__init__(self)
self.set_border_width(SPACING)
self.app = app
self.settings = app.settings
Loggable.__init__(self)
self.log("New ViewerContainer")
self.pipeline = None
self.docked = True
self.target = None
self._compactMode = False
# Only used for restoring the pipeline position after a live clip trim
# preview:
self._oldTimelinePos = None
self._haveUI = False
self._createUi()
self.__owning_pipeline = False
if not self.settings.viewerDocked:
self.undock()
def __init__(self, app):
gtksettings = Gtk.Settings.get_default()
gtksettings.set_property("gtk-application-prefer-dark-theme", True)
theme = gtksettings.get_property("gtk-theme-name")
os.environ["GTK_THEME"] = theme + ":dark"
# Pulseaudio "role"
# (http://0pointer.de/blog/projects/tagging-audio.htm)
os.environ["PULSE_PROP_media.role"] = "production"
os.environ["PULSE_PROP_application.icon_name"] = "pitivi"
Gtk.IconTheme.get_default().append_search_path(get_pixmap_dir())
Gtk.ApplicationWindow.__init__(self)
Loggable.__init__(self)
self.log("Creating main window")
self.app = app
self.greeter = GreeterPerspective(app)
self.editor = EditorPerspective(app)
self.__perspective = None
self.help_action = None
self.about_action = None
self.main_menu_action = None
app.project_manager.connect("new-project-loading",
self.__new_project_loading_cb)
app.project_manager.connect("new-project-failed",
self.__new_project_failed_cb)
app.project_manager.connect("project-closed", self.__project_closed_cb)
def __init__(self, widget):
# Prevent black frames and flickering while resizing or changing focus:
# The aspect ratio gets overridden by setDisplayAspectRatio.
Gtk.AspectFrame.__init__(self, xalign=0.5, yalign=0.5, ratio=4.0 / 3.0, obey_child=False)
Loggable.__init__(self)
self.add(widget)
def __init__(self, default_path=None, user_path=None, system=None):
GObject.Object.__init__(self)
Loggable.__init__(self)
self.default_path = default_path
self.user_path = user_path
self.presets = {}
self.widget_map = {}
self.ordered = Gtk.ListStore(str, object)
def sortme(store, i1, i2, unused_udata):
name1 = store[i1][0]
name2 = store[i2][0]
if name1 > name2:
return 1
return -1
self.ordered.set_sort_func(0, sortme)
self.ordered.set_sort_column_id(0, Gtk.SortType.ASCENDING)
self.cur_preset = None
# Whether to ignore the updateValue calls.
self.ignore_update_requests = False
self.system = system
def __init__(self, instance, hadj):
Gtk.DrawingArea.__init__(self)
Zoomable.__init__(self)
Loggable.__init__(self)
self.log("Creating new ScaleRuler")
self.app = instance
self._seeker = Seeker()
self.hadj = hadj
hadj.connect("value-changed", self._hadjValueChangedCb)
self.add_events(Gdk.EventMask.POINTER_MOTION_MASK |
Gdk.EventMask.BUTTON_PRESS_MASK | Gdk.EventMask.BUTTON_RELEASE_MASK |
Gdk.EventMask.SCROLL_MASK)
self.pixbuf = None
# all values are in pixels
self.pixbuf_offset = 0
self.pixbuf_offset_painted = 0
# This is the number of width we allocate for the pixbuf
self.pixbuf_multiples = 4
self.position = 0 # In nanoseconds
self.pressed = False
self.min_frame_spacing = 5.0
self.frame_height = 5.0
self.frame_rate = Gst.Fraction(1 / 1)
self.ns_per_frame = float(1 / self.frame_rate) * Gst.SECOND
self.connect('draw', self.drawCb)
self.connect('configure-event', self.configureEventCb)
self.callback_id = None
self.callback_id_scroll = None
def __init__(self, name="", uri=None, **kwargs):
"""
@param name: the name of the project
@param uri: the uri of the project
"""
Loggable.__init__(self)
self.log("name:%s, uri:%s", name, uri)
self.name = name
self.author = ""
self.year = ""
self.settings = None
self.description = ""
self.uri = uri
self.urichanged = False
self.format = None
self.medialibrary = MediaLibrary()
self._dirty = False
self.timeline = ges.timeline_new_audio_video()
# We add a Selection to the timeline as there is currently
# no such feature in GES
self.timeline.selection = Selection()
self.pipeline = Pipeline()
self.pipeline.add_timeline(self.timeline)
self.seeker = Seeker()
self.settings = MultimediaSettings()
def __init__(self, app):
Loggable.__init__(self)
self.settings = app.settings
self.widgets = {}
self.resets = {}
self._current = None
# Identify the widgets we'll need
builder = Gtk.Builder()
builder.add_from_file(os.path.join(get_ui_dir(), "preferences.ui"))
builder.connect_signals(self)
self.dialog = builder.get_object("dialog1")
self.model = builder.get_object("liststore1")
self.treeview = builder.get_object("treeview1")
self.contents = builder.get_object("box1")
self.revert_button = builder.get_object("revertButton")
self.factory_settings = builder.get_object("resetButton")
self.restart_warning = builder.get_object("restartWarning")
self.sections = {}
self.__fillContents()
req = self.contents.get_preferred_size()[0]
min_width = req.width
min_height = req.height
width = max(min_width, self.settings.prefsDialogWidth)
height = max(min_height, self.settings.prefsDialogHeight)
self.dialog.set_transient_for(app.gui)
self.dialog.set_default_size(width, height)
def __init__(self, instance, uiman):
Gtk.ScrolledWindow.__init__(self)
Loggable.__init__(self)
self.app = instance
self.settings = instance.settings
self._project = None
self.infobar_box = Gtk.VBox()
effect_properties_handling = EffectsPropertiesManager(instance)
self.effect_expander = EffectProperties(instance, effect_properties_handling, self)
self.effect_expander.set_vexpand(False)
# Transformation boxed DISABLED
#self.transformation_expander = TransformationProperties(instance, instance.action_log)
#self.transformation_expander.set_vexpand(False)
vbox = Gtk.VBox()
vbox.set_spacing(SPACING)
vbox.pack_start(self.infobar_box, False, True, 0)
# Transformation boxed DISABLED
#vbox.pack_start(self.transformation_expander, False, True, 0)
vbox.pack_start(self.effect_expander, True, True, 0)
viewport = Gtk.Viewport()
viewport.add(vbox)
self.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
self.add(viewport)
viewport.show()
vbox.show()
self.infobar_box.show()
def __init__(self, bin_desc):
Gst.Bin.__init__(self)
Loggable.__init__(self)
self.internal_bin = Gst.parse_bin_from_description(bin_desc, True)
self.add(self.internal_bin)
sinkpad, = [pad for pad in self.internal_bin.iterate_sink_pads()]
self.add_pad(Gst.GhostPad.new(None, sinkpad))
srcpad, = [pad for pad in self.internal_bin.iterate_src_pads()]
self.add_pad(Gst.GhostPad.new(None, srcpad))
def __new__(cls, *args, **kwargs):
"""Returns the singleton instance."""
if not cls._instance:
cls._instance = super(Encoders, cls).__new__(cls)
# We have to initialize the instance here, otherwise
# __init__ is called every time we use Encoders().
Loggable.__init__(cls._instance)
cls._instance._load_encoders()
cls._instance._load_combinations()
return cls._instance
def __init__(self, timeline):
Gtk.Layout.__init__(self)
Loggable.__init__(self)
self._children = []
self._changed = False
self.timeline = timeline
self.props.hexpand = True
self.get_style_context().add_class("LayerLayout")
def __init__(self, uri):
Loggable.__init__(self)
self._filehash = hash_file(Gst.uri_get_location(uri))
thumbs_cache_dir = get_dir(os.path.join(xdg_cache_home(), "thumbs"))
self._dbfile = os.path.join(thumbs_cache_dir, self._filehash)
self._db = sqlite3.connect(self._dbfile)
self._cur = self._db.cursor() # Use this for normal db operations
self._cur.execute("CREATE TABLE IF NOT EXISTS Thumbs\
(Time INTEGER NOT NULL PRIMARY KEY,\
Jpeg BLOB NOT NULL)")
def __init__(self, ges_layer, app):
Gtk.EventBox.__init__(self)
Loggable.__init__(self)
self.ges_layer = ges_layer
self.ges_timeline = self.ges_layer.get_timeline()
self.app = app
self.__icon = None
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
self.add(hbox)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
hbox.pack_start(vbox, True, True, 0)
rightside_separator = Gtk.Separator.new(Gtk.Orientation.VERTICAL)
hbox.pack_start(rightside_separator, False, False, 0)
name_row = Gtk.Box()
name_row.set_orientation(Gtk.Orientation.HORIZONTAL)
name_row.props.spacing = PADDING
name_row.props.margin_top = PADDING
name_row.props.margin_left = PADDING
name_row.props.margin_right = PADDING
vbox.pack_start(name_row, False, False, 0)
self.name_entry = Gtk.Entry()
self.name_entry.get_style_context().add_class("LayerControlEntry")
self.name_entry.props.valign = Gtk.Align.CENTER
self.name_entry.connect("focus-out-event", self.__name_focus_out_cb)
self.ges_layer.connect("notify-meta", self.__layer_rename_cb)
self.__updateName()
name_row.pack_start(self.name_entry, True, True, 0)
self.menubutton = Gtk.MenuButton.new()
self.menubutton.props.valign = Gtk.Align.CENTER
self.menubutton.props.relief = Gtk.ReliefStyle.NONE
model, action_group = self.__createMenuModel()
popover = Gtk.Popover.new_from_model(self.menubutton, model)
popover.insert_action_group("layer", action_group)
popover.props.position = Gtk.PositionType.LEFT
self.menubutton.set_popover(popover)
name_row.pack_start(self.menubutton, False, False, 0)
space = Gtk.Label()
space.props.vexpand = True
vbox.pack_start(space, False, False, 0)
self.ges_layer.connect("notify::priority", self.__layerPriorityChangedCb)
self.ges_timeline.connect("layer-added", self.__timelineLayerAddedCb)
self.ges_timeline.connect("layer-removed", self.__timelineLayerRemovedCb)
self.__updateActions()
# When the window property is set, specify the mouse cursor.
self.connect("notify::window", self.__windowSetCb)
def __init__(self, pipeline):
Loggable.__init__(self)
self.pipeline = pipeline
self.bus = self.pipeline.get_bus()
self.cpu_usage_tracker = CPUUsageTracker()
self.rate = 1.0
self.done = False
self.ready = False
self.lastPos = 0
self._bus_cb_id = None
def __init__(self, app):
Gtk.ScrolledWindow.__init__(self)
Loggable.__init__(self)
self.app = app
self.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
viewport = Gtk.Viewport()
viewport.set_shadow_type(Gtk.ShadowType.ETCHED_IN)
viewport.show()
self.add(viewport)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
vbox.show()
viewport.add(vbox)
self.clips_box = Gtk.Box()
self.clips_box.set_orientation(Gtk.Orientation.VERTICAL)
self.clips_box.show()
vbox.pack_start(self.clips_box, False, False, 0)
self.transformation_expander = TransformationProperties(app)
self.transformation_expander.set_vexpand(False)
vbox.pack_start(self.transformation_expander, False, False, 0)
self.speed_expander = TimeProperties(app)
self.speed_expander.set_vexpand(False)
vbox.pack_start(self.speed_expander, False, False, 0)
self.title_expander = TitleProperties(app)
self.title_expander.set_vexpand(False)
vbox.pack_start(self.title_expander, False, False, 0)
self.color_expander = ColorProperties(app)
self.color_expander.set_vexpand(False)
vbox.pack_start(self.color_expander, False, False, 0)
self.effect_expander = EffectProperties(app)
self.effect_expander.set_vexpand(False)
vbox.pack_start(self.effect_expander, False, False, 0)
self.helper_box = self.create_helper_box()
self.clips_box.pack_start(self.helper_box, False, False, 0)
disable_scroll(vbox)
self.transformation_expander.set_source(None)
self.speed_expander.set_clip(None)
self.title_expander.set_source(None)
self.color_expander.set_source(None)
self.effect_expander.set_clip(None)
self._project = None
self._selection = None
def __init__(self):
GObject.Object.__init__(self)
Loggable.__init__(self)
self.log("new object %s", self)
self._x11 = False
try:
from gi.repository import GdkX11
self._x11 = True
except ImportError:
pass
def __init__(self, instance):
Gtk.Box.__init__(self)
Loggable.__init__(self)
self.app = instance
self._drag_icon = GdkPixbuf.Pixbuf.new_from_file_at_size(
os.path.join(get_pixmap_dir(), "effects", "defaultthumbnail.svg"),
ICON_WIDTH, ICON_HEIGHT)
self._star_icon_regular = GdkPixbuf.Pixbuf.new_from_file_at_size(
os.path.join(get_pixmap_dir(), "star-regular.svg"), 15, 15)
self._star_icon_solid = GdkPixbuf.Pixbuf.new_from_file_at_size(
os.path.join(get_pixmap_dir(), "star-solid.svg"), 15, 15)
self.set_orientation(Gtk.Orientation.VERTICAL)
builder = Gtk.Builder()
builder.add_from_file(os.path.join(get_ui_dir(), "effectslibrary.ui"))
builder.connect_signals(self)
toolbar = builder.get_object("effectslibrary_toolbar")
toolbar.get_style_context().add_class(Gtk.STYLE_CLASS_INLINE_TOOLBAR)
self.search_entry = builder.get_object("search_entry")
self.fav_view_toggle = builder.get_object("favourites_toggle")
self.fav_view_toggle.set_image(Gtk.Image.new_from_pixbuf(self._star_icon_solid))
self.main_view = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.category_view = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
# Used for showing search results and favourites
self.search_view = Gtk.ListBox(activate_on_single_click=False)
self.search_view.connect("row-activated", self.effects_listbox_row_activated_cb)
placeholder_text = Gtk.Label(_("No effects"))
placeholder_text.props.visible = True
self.search_view.set_placeholder(placeholder_text)
self.main_view.pack_start(self.category_view, True, True, 0)
self.main_view.pack_start(self.search_view, True, True, 0)
scrollwin = Gtk.ScrolledWindow()
scrollwin.props.hscrollbar_policy = Gtk.PolicyType.NEVER
scrollwin.props.vscrollbar_policy = Gtk.PolicyType.AUTOMATIC
scrollwin.add(self.main_view)
self.pack_start(toolbar, False, False, 0)
self.pack_start(scrollwin, True, True, 0)
# Delay the loading of the available effects so the application
# starts faster.
GLib.idle_add(self._load_available_effects_cb)
scrollwin.show_all()
toolbar.show_all()
self.search_view.hide()
def __init__(self, factory, stream_):
"""
Create a new Extractor.
@param factory: the factory with which to decode the stream
@type factory: L{ObjectFactory}
@param stream_: the stream to decode
@type stream_: L{Stream}
"""
Loggable.__init__(self)
self.debug("Initialized with %s %s", factory, stream_)
def __init__(self, stack, source):
Gtk.DrawingArea.__init__(self)
Loggable.__init__(self)
self._source = source
self.click_source_position = None
self.stack = stack
project = stack.app.project_manager.current_project
project.connect("video-size-changed", self._canvas_size_changed_cb)
self.project_size = numpy.array(
[project.videowidth, project.videoheight])
def __init__(self, app):
Loggable.__init__(self)
Gtk.Expander.__init__(self)
self.set_label(_("Title"))
self.set_expanded(True)
self.app = app
self.source = None
self._setting_props = False
self._children_props_handler = None
self._create_ui()
def __init__(self, widget):
# Prevent black frames and flickering while resizing or changing focus:
# The aspect ratio gets overridden by setDisplayAspectRatio.
Gtk.AspectFrame.__init__(self,
xalign=0.5,
yalign=0.5,
ratio=4.0 / 3.0,
obey_child=False)
Loggable.__init__(self)
self.add(widget)
def __init__(self):
Loggable.__init__(self)
# The current Previewer per GES.TrackType.
self._current_previewers = {}
# The queue of Previewers.
self._previewers = {
GES.TrackType.AUDIO: [],
GES.TrackType.VIDEO: []
}
self._running = True
def __init__(self, pipeline, video_overlay):
Loggable.__init__(self)
Signallable.__init__(self)
self._pipeline = pipeline
self._bus = self._pipeline.get_bus()
self._bus.add_signal_watch()
self._bus.connect("message", self._busMessageCb)
self._listening = False # for the position handler
self._listeningInterval = 300 # default 300ms
self._listeningSigId = 0
self._duration = Gst.CLOCK_TIME_NONE
self.video_overlay = video_overlay
def __init__(self, app):
Loggable.__init__(self)
self.app = app
self.settings = {}
self.source = None
self.seeker = Seeker()
# Drag attributes
self._drag_events = []
self._signals_connected = False
self._createUI()
def __init__(self, timeout=80):
"""
@param timeout (optional): the amount of miliseconds for a seek attempt
"""
Signallable.__init__(self)
Loggable.__init__(self)
self.timeout = timeout
self.pending_seek_id = None
self.position = None
self.format = None
self._time = None
def __init__(self, app):
Gtk.Expander.__init__(self)
Loggable.__init__(self)
self.app = app
self.source = None
self._children_props_handler = None
self.set_label(_("Color"))
self.set_expanded(True)
self._create_ui()
def __init__(self, app=None):
GObject.Object.__init__(self)
Loggable.__init__(self)
if app is not None:
self.app = weakref.proxy(app)
else:
self.app = None
self.undo_stacks = []
self.redo_stacks = []
self.stacks = []
self.running = False
self._checkpoint = self._takeSnapshot()
def __init__(self, settings=None):
Gtk.DrawingArea.__init__(self)
Loggable.__init__(self)
self.seeker = Seeker()
self.settings = settings
self.box = None
self.stored = False
self.area = None
self.zoom = 1.0
self.sink = None
self.pixbuf = None
self.pipeline = None
self.transformation_properties = None
def __init__(self, project_manager):
Loggable.__init__(self)
self.project_manager = project_manager
self.conf_folder_path = xdg_config_home("editor_state")
self.project = None
self.conf_file_path = None
self._editor_state = {}
self.__state_saving_handle = 0
self.project_manager.connect("new-project-loaded",
self._new_project_loaded_cb)
def __init__(self, title, headline):
Loggable.__init__(self)
self.builder = Gtk.Builder()
self.builder.add_from_file(os.path.join(get_ui_dir(),
"filelisterrordialog.ui"))
self.builder.connect_signals(self)
self.window = self.builder.get_object("filelisterrordialog")
self.window.set_modal(False)
self.window.set_title(title)
self.builder.get_object("headline").set_text(headline)
self.errorvbox = self.builder.get_object("errorvbox")
def __init__(self, timeline, hadj):
Gtk.DrawingArea.__init__(self)
Zoomable.__init__(self)
Loggable.__init__(self)
self.log("Creating new ScaleRuler")
# Allows stealing focus from other GTK widgets, prevent accidents:
self.props.can_focus = True
self.connect("focus-in-event", self._focusInCb)
self.connect("focus-out-event", self._focusOutCb)
self.timeline = timeline
self._background_color = timeline.get_style_context().lookup_color(
'theme_bg_color')[1]
self._seeker = Seeker()
self.hadj = hadj
hadj.connect("value-changed", self._hadjValueChangedCb)
self.add_events(Gdk.EventMask.POINTER_MOTION_MASK
| Gdk.EventMask.BUTTON_PRESS_MASK
| Gdk.EventMask.BUTTON_RELEASE_MASK
| Gdk.EventMask.SCROLL_MASK)
self.pixbuf = None
# all values are in pixels
self.pixbuf_offset = 0
self.pixbuf_offset_painted = 0
# This is the number of width we allocate for the pixbuf
self.pixbuf_multiples = 4
self.position = 0 # In nanoseconds
self.pressed = False
self.frame_rate = Gst.Fraction(1 / 1)
self.ns_per_frame = float(1 / self.frame_rate) * Gst.SECOND
self.connect('draw', self.drawCb)
self.connect('configure-event', self.configureEventCb)
self.callback_id = None
self.callback_id_scroll = None
self.set_size_request(0, HEIGHT)
style = self.get_style_context()
color_normal = style.get_color(Gtk.StateFlags.NORMAL)
color_insensitive = style.get_color(Gtk.StateFlags.INSENSITIVE)
self._color_normal = color_normal
self._color_dimmed = Gdk.RGBA(
*[(x * 3 + y * 2) / 5
for x, y in ((color_normal.red, color_insensitive.red),
(color_normal.green, color_insensitive.green),
(color_normal.blue, color_insensitive.blue))])
self.scales = SCALES
def __init__(self, ges_marker_list, action_log):
Loggable.__init__(self)
self.action_log = action_log
self.marker_observers = {}
ges_marker_list.connect("marker-added", self._marker_added_cb)
ges_marker_list.connect("marker-removed", self._marker_removed_cb)
ges_marker_list.connect("marker-moved", self._marker_moved_cb)
ges_markers = ges_marker_list.get_markers()
for ges_marker in ges_markers:
self._connect(ges_marker)
def __init__(self, default_path, user_path, system):
GObject.Object.__init__(self)
Loggable.__init__(self)
self.default_path = default_path
self.user_path = user_path
self.presets = {}
self.widget_map = {}
self.ordered = Gtk.ListStore(str, object)
self.cur_preset = None
# Whether to ignore the updateValue calls.
self.ignore_update_requests = False
self.system = system
def __init__(self, app):
Gtk.Expander.__init__(self)
self.set_expanded(True)
self.set_label(_("Effects"))
Loggable.__init__(self)
self.app = app
self.clip = None
self.effects_properties_manager = EffectsPropertiesManager(app)
setup_custom_effect_widgets(self.effects_properties_manager)
self.drag_lines_pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(
os.path.join(get_pixmap_dir(), "grip-lines-solid.svg"), 15, 15)
self.expander_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.effects_listbox = Gtk.ListBox()
placeholder_label = Gtk.Label(
_("To apply an effect to the clip, drag it from the Effect Library "
"or use the button below."))
placeholder_label.set_line_wrap(True)
placeholder_label.show()
self.effects_listbox.set_placeholder(placeholder_label)
# Add effect popover button
self.effect_popover = EffectsPopover(app)
self.add_effect_button = Gtk.MenuButton(_("Add Effect"))
self.add_effect_button.set_popover(self.effect_popover)
self.add_effect_button.props.halign = Gtk.Align.CENTER
self.drag_dest_set(Gtk.DestDefaults.DROP, [EFFECT_TARGET_ENTRY],
Gdk.DragAction.COPY)
self.expander_box.pack_start(self.effects_listbox, False, False, 0)
self.expander_box.pack_start(self.add_effect_button, False, False,
PADDING)
self.add(self.expander_box)
# Connect all the widget signals
self.connect("drag-motion", self._drag_motion_cb)
self.connect("drag-leave", self._drag_leave_cb)
self.connect("drag-data-received", self._drag_data_received_cb)
self.add_effect_button.connect("toggled", self._add_effect_button_cb)
self.show_all()
def __init__(self, ges_marker):
Gtk.EventBox.__init__(self)
Loggable.__init__(self)
self.add_events(Gdk.EventMask.ENTER_NOTIFY_MASK |
Gdk.EventMask.LEAVE_NOTIFY_MASK)
self.ges_marker = ges_marker
self.ges_marker.ui = self
self.position_ns = self.ges_marker.props.position
self.get_style_context().add_class("Marker")
self.ges_marker.connect("notify-meta", self._notify_meta_cb)
self._selected = False
def __init__(self, uri):
Loggable.__init__(self)
# TODO: replace with utils.misc.hash_file
self._filehash = hash_file(Gst.uri_get_location(uri))
self._filename = os.path.basename(path_from_uri(uri))
# TODO: replace with pitivi.settings.xdg_cache_home()
cache_dir = get_dir(os.path.join(xdg_dirs.xdg_cache_home, "pitivi"),
autocreate)
dbfile = os.path.join(get_dir(os.path.join(cache_dir, "thumbs")),
self._filehash)
self._db = sqlite3.connect(dbfile)
self._cur = self._db.cursor() # Use this for normal db operations
self._cur.execute("CREATE TABLE IF NOT EXISTS Thumbs\
(Time INTEGER NOT NULL PRIMARY KEY,\
Jpeg BLOB NOT NULL)")
def __init__(self, app):
Loggable.__init__(self)
self.app = app
self.engine = Peas.Engine.get_default()
# Many plugins need access to the main window. However, by the time a
# plugin is loaded from settings (as soon Pitivi application starts),
# the main window doesn't exist yet. So we load plugins from settings
# after the main window is added.
self.app.connect("window-added", self.__window_added_cb)
for loader in self.DEFAULT_LOADERS:
self.engine.enable_loader(loader)
self._setup_plugins_dir()
self._setup_extension_set()
def __init__(self, ges_timeline_element, action_log):
Loggable.__init__(self)
self.ges_timeline_element = ges_timeline_element
self.action_log = action_log
self._properties = {}
for prop in ges_timeline_element.list_children_properties():
if prop.name in PROPS_TO_IGNORE:
continue
prop_name = child_property_name(prop)
res, value = ges_timeline_element.get_child_property(prop_name)
assert res, prop_name
self._properties[prop_name] = value
ges_timeline_element.connect('deep-notify', self._property_changed_cb)
