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.need_update = True 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
def setPipeline(self, pipeline, position=None): """ Set the Viewer to the given Pipeline. Properly switches the currently set action to that new Pipeline. @param pipeline: The Pipeline to switch to. @type pipeline: L{Pipeline}. @param position: Optional position to seek to initially. """ self.debug("self.pipeline:%r", self.pipeline) self.seeker = Seeker() self._disconnectFromPipeline() if self.pipeline: self.pipeline.set_state(Gst.State.NULL) self.pipeline = pipeline if self.pipeline: self.pipeline.pause() self.seeker.seek(position) self.pipeline.connect("state-change", self._pipelineStateChangedCb) self.pipeline.connect("position", self._positionCb) self.pipeline.connect("duration-changed", self._durationChangedCb) self.sink = pipeline.video_overlay self._switch_output_window() self._setUiActive()
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, 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 for state in range(gtk.STATE_INSENSITIVE + 1): self.modify_bg(state, self.style.black)
class ScaleRuler(Gtk.DrawingArea, Zoomable, Loggable): __gsignals__ = { "button-press-event": "override", "button-release-event": "override", "motion-notify-event": "override", "scroll-event": "override", "seek": (GObject.SignalFlags.RUN_LAST, None, [GObject.TYPE_UINT64]) } border = 0 min_tick_spacing = 3 scale = [0, 0, 0, 0.5, 1, 2, 5, 10, 15, 30, 60, 120, 300, 600, 3600] subdivide = ((1, 1.0), (2, 0.5), (10, .25)) 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.need_update = True 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 def _hadjValueChangedCb(self, hadj): self.pixbuf_offset = self.hadj.get_value() self.queue_draw() ## Zoomable interface override def _maybeUpdate(self): self.need_update = True self.queue_draw() self.callback_id = None return False def zoomChanged(self): if self.callback_id is not None: GObject.source_remove(self.callback_id) self.callback_id = GObject.timeout_add(100, self._maybeUpdate) ## timeline position changed method def timelinePositionChanged(self, value, unused_frame=None): self.position = value self.queue_draw() ## Gtk.Widget overrides def configureEventCb(self, widget, event, data=None): self.debug("Configuring, height %d, width %d", widget.get_allocated_width(), widget.get_allocated_height()) # Destroy previous buffer if self.pixbuf is not None: self.pixbuf.finish() self.pixbuf = None # Create a new buffer self.pixbuf = cairo.ImageSurface(cairo.FORMAT_ARGB32, widget.get_allocated_width(), widget.get_allocated_height()) return False def drawCb(self, widget, cr): if self.pixbuf is not None: db = self.pixbuf # Create cairo context with double buffer as is DESTINATION cc = cairo.Context(db) #draw everything self.drawBackground(cc) self.drawRuler(cc) self.drawPosition(cc) db.flush() cr.set_source_surface(self.pixbuf, 0.0, 0.0) cr.paint() else: self.info('No buffer to paint buffer') return False def do_button_press_event(self, event): self.debug("button pressed at x:%d", event.x) self.pressed = True position = self.pixelToNs(event.x + self.pixbuf_offset) self._seeker.seek(position) return True def do_button_release_event(self, event): self.debug("button released at x:%d", event.x) self.pressed = False # The distinction between the ruler and timeline canvas is theoretical. # If the user interacts with the ruler, have the timeline steal focus # from other widgets. This reactivates keyboard shortcuts for playback. #timeline = self.app.gui.timeline_ui #timeline._canvas.grab_focus(timeline._root_item) return False def do_motion_notify_event(self, event): position = self.pixelToNs(event.x + self.pixbuf_offset) if self.pressed: self.debug("motion at event.x %d", event.x) self._seeker.seek(position) else: human_time = beautify_length(position) cur_frame = int(position / self.ns_per_frame) + 1 self.set_tooltip_text(human_time + "\n" + _("Frame #%d" % cur_frame)) return False def do_scroll_event(self, event): if event.scroll.state & Gdk.ModifierType.CONTROL_MASK: # Control + scroll = zoom if event.scroll.direction == Gdk.ScrollDirection.UP: Zoomable.zoomIn() self.app.gui.timeline_ui.zoomed_fitted = False elif event.scroll.direction == Gdk.ScrollDirection.DOWN: Zoomable.zoomOut() self.app.gui.timeline_ui.zoomed_fitted = False else: # No modifier key held down, just scroll if (event.scroll.direction == Gdk.ScrollDirection.UP or event.scroll.direction == Gdk.ScrollDirection.LEFT): self.app.gui.timeline_ui.scroll_left() elif (event.scroll.direction == Gdk.ScrollDirection.DOWN or event.scroll.direction == Gdk.ScrollDirection.RIGHT): self.app.gui.timeline_ui.scroll_right() def setProjectFrameRate(self, rate): """ Set the lowest scale based on project framerate """ self.frame_rate = rate self.ns_per_frame = float(1 / self.frame_rate) * Gst.SECOND self.scale[0] = float(2 / rate) self.scale[1] = float(5 / rate) self.scale[2] = float(10 / rate) ## Drawing methods def drawBackground(self, cr): style = self.get_style_context() setCairoColor(cr, style.get_background_color(Gtk.StateFlags.NORMAL)) cr.rectangle(0, 0, cr.get_target().get_width(), cr.get_target().get_height()) cr.fill() offset = int(self.nsToPixel(Gst.CLOCK_TIME_NONE)) - self.pixbuf_offset if offset > 0: setCairoColor(cr, style.get_background_color(Gtk.StateFlags.ACTIVE)) cr.rectangle(0, 0, int(offset), cr.get_target().get_height()) cr.fill() def drawRuler(self, cr): # FIXME use system defaults cr.set_font_face(cairo.ToyFontFace("Cantarell")) cr.set_font_size(13) textwidth = cr.text_extents(time_to_string(0))[2] for scale in self.scale: spacing = Zoomable.zoomratio * scale if spacing >= textwidth * 1.5: break offset = self.pixbuf_offset % spacing self.drawFrameBoundaries(cr) self.drawTicks(cr, offset, spacing, scale) self.drawTimes(cr, offset, spacing, scale) def drawTick(self, cr, paintpos, height): # We need to use 0.5 pixel offsets to get a sharp 1 px line in cairo paintpos = int(paintpos - 0.5) + 0.5 height = int(cr.get_target().get_height() * (1 - height)) style = self.get_style_context() setCairoColor(cr, style.get_color(Gtk.StateType.NORMAL)) cr.set_line_width(1) cr.move_to(paintpos, height) cr.line_to(paintpos, cr.get_target().get_height()) cr.close_path() cr.stroke() def drawTicks(self, cr, offset, spacing, scale): for subdivide, height in self.subdivide: spc = spacing / float(subdivide) if spc < self.min_tick_spacing: break paintpos = -spacing + 0.5 paintpos += spacing - offset while paintpos < cr.get_target().get_width(): self.drawTick(cr, paintpos, height) paintpos += spc def drawTimes(self, cr, offset, spacing, scale): # figure out what the optimal offset is interval = long(Gst.SECOND * scale) seconds = self.pixelToNs(self.pixbuf_offset) paintpos = float(self.border) + 2 if offset > 0: seconds = seconds - (seconds % interval) + interval paintpos += spacing - offset while paintpos < cr.get_target().get_width(): if paintpos < self.nsToPixel(Gst.CLOCK_TIME_NONE): state = Gtk.StateType.ACTIVE else: state = Gtk.StateType.NORMAL timevalue = time_to_string(long(seconds)) style = self.get_style_context() setCairoColor(cr, style.get_color(state)) x_bearing, y_bearing = cr.text_extents("0")[:2] cr.move_to(int(paintpos), 1 - y_bearing) cr.show_text(timevalue) paintpos += spacing seconds += interval def drawFrameBoundaries(self, cr): """ Draw the alternating rectangles that represent the project frames at high zoom levels. These are based on the framerate set in the project settings, not the actual frames on a video codec level. """ frame_width = self.nsToPixel(self.ns_per_frame) if not frame_width >= self.min_frame_spacing: return offset = self.pixbuf_offset % frame_width height = cr.get_target().get_height() y = int(height - self.frame_height) # INSENSITIVE is a dark shade of gray, but lacks contrast # SELECTED will be bright blue and more visible to represent frames style = self.get_style_context() states = [style.get_background_color(Gtk.StateFlags.ACTIVE), style.get_background_color(Gtk.StateFlags.SELECTED)] frame_num = int(self.pixelToNs(self.pixbuf_offset) * float(self.frame_rate) / Gst.SECOND) paintpos = self.pixbuf_offset - offset max_pos = cr.get_target().get_width() + self.pixbuf_offset while paintpos < max_pos: paintpos = self.nsToPixel(1 / float(self.frame_rate) * Gst.SECOND * frame_num) setCairoColor(cr, states[(frame_num + 1) % 2]) cr.rectangle(0.5 + paintpos - self.pixbuf_offset, y, frame_width, height) cr.fill() frame_num += 1 def drawPosition(self, context): # a simple RED line will do for now xpos = self.nsToPixel(self.position) + self.border - self.pixbuf_offset context.save() context.set_line_width(1.5) context.set_source_rgb(1.0, 0, 0) context.move_to(xpos, 0) context.line_to(xpos, context.get_target().get_height()) context.stroke() context.restore()
class ViewerWidget(Gtk.DrawingArea, Loggable): """ Widget for displaying properly GStreamer video sink @ivar settings: The settings of the application. @type settings: L{GlobalSettings} """ __gsignals__ = {} 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 # FIXME PyGi Styling with Gtk3 #for state in range(Gtk.StateType.INSENSITIVE + 1): #self.modify_bg(state, self.style.black) def init_transformation_events(self): self.set_events(Gdk.EventMask.BUTTON_PRESS_MASK | Gdk.EventMask.BUTTON_RELEASE_MASK | Gdk.EventMask.POINTER_MOTION_MASK | Gdk.EventMask.POINTER_MOTION_HINT_MASK) def show_box(self): if not self.box: self.box = TransformationBox(self.settings) self.box.init_size(self.area) self._update_gradient() self.connect("button-press-event", self.button_press_event) self.connect("button-release-event", self.button_release_event) self.connect("motion-notify-event", self.motion_notify_event) self.connect("size-allocate", self._sizeCb) self.box.set_transformation_properties(self.transformation_properties) self.renderbox() def _sizeCb(self, widget, area): # The transformation box is cleared when using regular rendering # so we need to flush the pipeline self.seeker.flush() def hide_box(self): if self.box: self.box = None self.disconnect_by_func(self.button_press_event) self.disconnect_by_func(self.button_release_event) self.disconnect_by_func(self.motion_notify_event) self.seeker.flush() self.zoom = 1.0 if self.sink: self.sink.set_render_rectangle(*self.area) def set_transformation_properties(self, transformation_properties): self.transformation_properties = transformation_properties def _store_pixbuf(self): """ When not playing, store a pixbuf of the current viewer image. This will allow it to be restored for the transformation box. """ if self.box and self.zoom != 1.0: # The transformation box is active and dezoomed # crop away 1 pixel border to avoid artefacts on the pixbuf self.pixbuf = Gdk.pixbuf_get_from_window(self.get_window(), self.box.area.x + 1, self.box.area.y + 1, self.box.area.width - 2, self.box.area.height - 2) else: self.pixbuf = Gdk.pixbuf_get_from_window(self.get_window(), 0, 0, self.get_window().get_width(), self.get_window().get_height()) self.stored = True def do_realize(self): """ Redefine gtk DrawingArea's do_realize method to handle multiple OSes. This is called when creating the widget to get the window ID. """ Gtk.DrawingArea.do_realize(self) if platform.system() == 'Windows': self.window_xid = self.props.window.handle else: self.window_xid = self.get_property('window').get_xid() def button_release_event(self, widget, event): if event.button == 1: self.box.update_effect_properties() self.box.release_point() self.seeker.flush() self.stored = False return True def button_press_event(self, widget, event): if event.button == 1: self.box.select_point(event) return True def _currentStateCb(self, pipeline, state): self.pipeline = pipeline if state == Gst.State.PAUSED: self._store_pixbuf() self.renderbox() def motion_notify_event(self, widget, event): if event.get_state() & Gdk.ModifierType.BUTTON1_MASK: if self.box.transform(event): if self.stored: self.renderbox() return True def do_expose_event(self, event): self.area = event.area if self.box: self._update_gradient() if self.zoom != 1.0: width = int(float(self.area.width) * self.zoom) height = int(float(self.area.height) * self.zoom) area = ((self.area.width - width) / 2, (self.area.height - height) / 2, width, height) self.sink.set_render_rectangle(*area) else: area = self.area self.box.update_size(area) self.renderbox() def _update_gradient(self): self.gradient_background = cairo.LinearGradient(0, 0, 0, self.area.height) self.gradient_background.add_color_stop_rgb(0.00, .1, .1, .1) self.gradient_background.add_color_stop_rgb(0.50, .2, .2, .2) self.gradient_background.add_color_stop_rgb(1.00, .5, .5, .5) def renderbox(self): if self.box: cr = self.window.cairo_create() cr.push_group() if self.zoom != 1.0: # draw some nice background for zoom out cr.set_source(self.gradient_background) cr.rectangle(0, 0, self.area.width, self.area.height) cr.fill() # translate the drawing of the zoomed out box cr.translate(self.box.area.x, self.box.area.y) # clear the drawingarea with the last known clean video frame # translate when zoomed out if self.pixbuf: if self.box.area.width != self.pixbuf.get_width(): scale = float(self.box.area.width) / float(self.pixbuf.get_width()) cr.save() cr.scale(scale, scale) cr.set_source_pixbuf(self.pixbuf, 0, 0) cr.paint() if self.box.area.width != self.pixbuf.get_width(): cr.restore() if self.pipeline and self.pipeline.get_state()[1] == Gst.State.PAUSED: self.box.draw(cr) cr.pop_group_to_source() cr.paint()
class PitiviViewer(Gtk.VBox, Loggable): """ A Widget to control and visualize a Pipeline @ivar pipeline: The current pipeline @type pipeline: L{Pipeline} @ivar action: The action controlled by this Pipeline @type action: L{ViewAction} """ __gtype_name__ = 'PitiviViewer' __gsignals__ = { "activate-playback-controls": (GObject.SignalFlags.RUN_LAST, None, (GObject.TYPE_BOOLEAN,)), } INHIBIT_REASON = _("Currently playing") def __init__(self, app, undock_action=None): Gtk.VBox.__init__(self) self.set_border_width(SPACING) self.app = app 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) def setPipeline(self, pipeline, position=None): """ Set the Viewer to the given Pipeline. Properly switches the currently set action to that new Pipeline. @param pipeline: The Pipeline to switch to. @type pipeline: L{Pipeline}. @param position: Optional position to seek to initially. """ self.debug("self.pipeline:%r", self.pipeline) self.seeker = Seeker() self._disconnectFromPipeline() if self.pipeline: self.pipeline.set_state(Gst.State.NULL) self.pipeline = pipeline if self.pipeline: self.pipeline.pause() self.seeker.seek(position) self.pipeline.connect("state-change", self._pipelineStateChangedCb) self.pipeline.connect("position", self._positionCb) self.pipeline.connect("duration-changed", self._durationChangedCb) self.sink = pipeline.video_overlay self._switch_output_window() self._setUiActive() def _disconnectFromPipeline(self): self.debug("pipeline:%r", self.pipeline) if self.pipeline is None: # silently return, there's nothing to disconnect from return self.pipeline.disconnect_by_func(self._pipelineStateChangedCb) self.pipeline.disconnect_by_func(self._positionCb) self.pipeline.disconnect_by_func(self._durationChangedCb) self.pipeline = None def _setUiActive(self, active=True): self.debug("active %r", active) self.set_sensitive(active) if self._haveUI: for item in [self.goToStart_button, self.back_button, self.playpause_button, self.forward_button, self.goToEnd_button, self.timecode_entry]: item.set_sensitive(active) if active: self.emit("activate-playback-controls", True) def _externalWindowDeleteCb(self, window, event): self.dock() return True def _externalWindowConfigureCb(self, window, event): self.settings.viewerWidth = event.width self.settings.viewerHeight = event.height self.settings.viewerX = event.x self.settings.viewerY = event.y def _createUi(self): """ Creates the Viewer GUI """ # Drawing area # The aspect ratio gets overridden on startup by setDisplayAspectRatio self.aframe = Gtk.AspectFrame(xalign=0.5, yalign=1.0, ratio=4.0 / 3.0, obey_child=False) self.internal = ViewerWidget() self.internal.init_transformation_events() self.internal.show() self.aframe.add(self.internal) self.pack_start(self.aframe, True, True, 0) self.external_window = Gtk.Window() vbox = Gtk.VBox() vbox.set_spacing(SPACING) self.external_window.add(vbox) self.external = ViewerWidget() vbox.pack_start(self.external, True, True, 0) self.external_window.connect("delete-event", self._externalWindowDeleteCb) self.external_window.connect("configure-event", self._externalWindowConfigureCb) self.external_vbox = vbox self.external_vbox.show_all() # Buttons/Controls bbox = Gtk.HBox() boxalign = Gtk.Alignment(xalign=0.5, yalign=0.5, xscale=0.0, yscale=0.0) boxalign.add(bbox) self.pack_start(boxalign, False, True, 0) self.goToStart_button = Gtk.ToolButton(Gtk.STOCK_MEDIA_PREVIOUS) self.goToStart_button.connect("clicked", self._goToStartCb) self.goToStart_button.set_tooltip_text(_("Not implemented")) self.goToStart_button.set_sensitive(False) bbox.pack_start(self.goToStart_button, False, True, 0) self.back_button = Gtk.ToolButton(Gtk.STOCK_MEDIA_REWIND) self.back_button.connect("clicked", self._backCb) self.back_button.set_tooltip_text(_("Not implemented")) self.back_button.set_sensitive(False) bbox.pack_start(self.back_button, False, True, 0) self.playpause_button = PlayPauseButton() self.playpause_button.connect("play", self._playButtonCb) bbox.pack_start(self.playpause_button, False, True, 0) self.playpause_button.set_sensitive(False) self.forward_button = Gtk.ToolButton(Gtk.STOCK_MEDIA_FORWARD) self.forward_button.connect("clicked", self._forwardCb) self.forward_button.set_tooltip_text(_("Not implemented")) self.forward_button.set_sensitive(False) bbox.pack_start(self.forward_button, False, True, 0) self.goToEnd_button = Gtk.ToolButton(Gtk.STOCK_REFRESH) self.goToEnd_button.connect("clicked", self._goToEndCb) self.goToEnd_button.set_tooltip_text(_("Go back to live")) self.goToEnd_button.set_sensitive(False) bbox.pack_start(self.goToEnd_button, False, True, 0) # current time self.timecode_entry = TimeWidget() self.timecode_entry.setWidgetValue(0) self.timecode_entry.set_tooltip_text(_('Enter a timecode or frame number\nand press "Enter" to go to that position')) self.timecode_entry.connectActivateEvent(self._entryActivateCb) bbox.pack_start(self.timecode_entry, False, 10, 0) self._haveUI = True # Identify widgets for AT-SPI, making our test suite easier to develop # These will show up in sniff, accerciser, etc. self.goToStart_button.get_accessible().set_name("goToStart_button") self.back_button.get_accessible().set_name("back_button") self.playpause_button.get_accessible().set_name("playpause_button") self.forward_button.get_accessible().set_name("forward_button") self.goToEnd_button.get_accessible().set_name("goToEnd_button") self.timecode_entry.get_accessible().set_name("timecode_entry") screen = Gdk.Screen.get_default() height = screen.get_height() if height >= 800: # show the controls and force the aspect frame to have at least the same # width (+110, which is a magic number to minimize dead padding). bbox.show_all() req = bbox.size_request() width = req.width height = req.height width += 110 height = int(width / self.aframe.props.ratio) self.aframe.set_size_request(width, height) self.show_all() self.buttons = bbox self.buttons_container = boxalign def setDisplayAspectRatio(self, ratio): """ Sets the DAR of the Viewer to the given ratio. @arg ratio: The aspect ratio to set on the viewer @type ratio: L{float} """ self.debug("Setting ratio of %f [%r]", float(ratio), ratio) try: self.aframe.set_property("ratio", float(ratio)) except: self.warning("could not set ratio !") def _entryActivateCb(self, entry): self._seekFromTimecodeWidget() def _seekFromTimecodeWidget(self): nanoseconds = self.timecode_entry.getWidgetValue() self.seeker.seek(nanoseconds) ## active Timeline calllbacks def _durationChangedCb(self, unused_pipeline, duration): if duration == 0: self._setUiActive(False) else: self._setUiActive(True) ## Control Gtk.Button callbacks def setZoom(self, zoom): """ Zoom in or out of the transformation box canvas. This is called by clipproperties. """ if self.target.box: maxSize = self.target.area width = int(float(maxSize.width) * zoom) height = int(float(maxSize.height) * zoom) area = ((maxSize.width - width) / 2, (maxSize.height - height) / 2, width, height) self.sink.set_render_rectangle(*area) self.target.box.update_size(area) self.target.zoom = zoom self.target.sink = self.sink self.target.renderbox() def _playButtonCb(self, unused_button, playing): self.app.togglePlayback() def _goToStartCb(self, unused_button): raise NotImplementedError def _backCb(self, unused_button): # Seek backwards one second raise NotImplementedError def _forwardCb(self, unused_button): # Seek forward one second raise NotImplementedError def _goToEndCb(self, unused_button): self.app.goToEnd() ## public methods for controlling playback def undock(self): if not self.undock_action: self.error("Cannot undock because undock_action is missing.") return if not self.docked: return self.docked = False self.settings.viewerDocked = False self.undock_action.set_label(_("Dock Viewer")) self.target = self.external self.remove(self.buttons_container) self.external_vbox.pack_end(self.buttons_container, False, False, 0) self.external_window.set_type_hint(Gdk.WindowTypeHint.UTILITY) self.external_window.show() self.fullscreen_button = Gtk.ToggleToolButton(Gtk.STOCK_FULLSCREEN) self.fullscreen_button.set_tooltip_text(_("Show this window in fullscreen")) self.buttons.pack_end(self.fullscreen_button, expand=False, fill=False, padding=6) self.fullscreen_button.show() self.fullscreen_button.connect("toggled", self._toggleFullscreen) # if we are playing, switch output immediately if self.sink: self._switch_output_window() self.hide() self.external_window.move(self.settings.viewerX, self.settings.viewerY) self.external_window.resize(self.settings.viewerWidth, self.settings.viewerHeight) def dock(self): if not self.undock_action: self.error("Cannot dock because undock_action is missing.") return if self.docked: return self.docked = True self.settings.viewerDocked = True self.undock_action.set_label(_("Undock Viewer")) self.target = self.internal self.fullscreen_button.destroy() self.external_vbox.remove(self.buttons_container) self.pack_end(self.buttons_container, False, False, 0) self.show() # if we are playing, switch output immediately if self.sink: self._switch_output_window() self.external_window.hide() def _toggleDocked(self, action): if self.docked: self.undock() else: self.dock() def _toggleFullscreen(self, widget): if widget.get_active(): self.external_window.hide() # GTK doesn't let us fullscreen utility windows self.external_window.set_type_hint(Gdk.WindowTypeHint.NORMAL) self.external_window.show() self.external_window.fullscreen() widget.set_tooltip_text(_("Exit fullscreen mode")) else: self.external_window.unfullscreen() widget.set_tooltip_text(_("Show this window in fullscreen")) self.external_window.hide() self.external_window.set_type_hint(Gdk.WindowTypeHint.UTILITY) self.external_window.show() def _positionCb(self, unused_pipeline, position): """ If the timeline position changed, update the viewer UI widgets. This is meant to be called either by the gobject timer when playing, or by mainwindow's _timelineSeekCb when the timer is disabled. """ self.timecode_entry.setWidgetValue(position, False) def clipTrimPreview(self, tl_obj, position): """ While a clip is being trimmed, show a live preview of it. """ 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 clip_uri = tl_obj.props.uri cur_time = time() if not self._tmp_pipeline: self.debug("Creating temporary pipeline for clip %s, position %s", clip_uri, print_ns(position)) self._oldTimelinePos = self.pipeline.getPosition() self._tmp_pipeline = Gst.ElementFactory.make("playbin", None) self._tmp_pipeline.set_property("uri", clip_uri) self.setPipeline(SimplePipeline(self._tmp_pipeline, self._tmp_pipeline)) self._lastClipTrimTime = cur_time if (cur_time - self._lastClipTrimTime) > 0.2: # Do not seek more than once every 200 ms (for performance) self._tmp_pipeline.seek_simple(Gst.Format.TIME, Gst.SeekFlags.FLUSH, position) self._lastClipTrimTime = cur_time def clipTrimPreviewFinished(self): """ After trimming a clip, reset the project pipeline into the viewer. """ if self._tmp_pipeline is not None: self._tmp_pipeline.set_state(Gst.State.NULL) self._tmp_pipeline = None # Free the memory self.setPipeline(self.app.current.pipeline, self._oldTimelinePos) self.debug("Back to old pipeline") def _pipelineStateChangedCb(self, pipeline, state): """ When playback starts/stops, update the viewer widget, play/pause button and (un)inhibit the screensaver. This is meant to be called by mainwindow. """ self.info("current state changed : %s", state) if int(state) == int(Gst.State.PLAYING): self.playpause_button.setPause() elif int(state) == int(Gst.State.PAUSED): self.playpause_button.setPlay() else: self.sink = None self.internal._currentStateCb(self.pipeline, state) def _switch_output_window(self): Gdk.threads_enter() # Prevent cases where target has no "window_xid" (yes, it happens!): self.target.show() self.sink.set_window_handle(self.target.window_xid) self.sink.expose() Gdk.threads_leave()
class PitiviViewer(gtk.VBox, Loggable): """ A Widget to control and visualize a Pipeline @ivar pipeline: The current pipeline @type pipeline: L{Pipeline} @ivar action: The action controlled by this Pipeline @type action: L{ViewAction} """ __gtype_name__ = "PitiviViewer" __gsignals__ = {"activate-playback-controls": (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (gobject.TYPE_BOOLEAN,))} INHIBIT_REASON = _("Currently playing") 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 setPipeline(self, pipeline, position=None): """ Set the Viewer to the given Pipeline. Properly switches the currently set action to that new Pipeline. @param pipeline: The Pipeline to switch to. @type pipeline: L{Pipeline}. @param position: Optional position to seek to initially. """ self.debug("self.pipeline:%r", self.pipeline) self.seeker = Seeker() self._disconnectFromPipeline() if self.pipeline: self.pipeline.set_state(gst.STATE_NULL) self.pipeline = pipeline if self.pipeline: self.pipeline.pause() self.seeker.seek(position) self.pipeline.connect("state-changed", self._pipelineStateChangedCb) self.pipeline.connect("position", self._positionCb) self.pipeline.connect("xid-message", self.xidMessageCb) self.pipeline.connect("duration-changed", self._durationChangedCb) self._setUiActive() def _disconnectFromPipeline(self): self.debug("pipeline:%r", self.pipeline) if self.pipeline is None: # silently return, there's nothing to disconnect from return self.pipeline.disconnect_by_func(self._pipelineStateChangedCb) self.pipeline.disconnect_by_func(self.xidMessageCb) self.pipeline.disconnect_by_func(self._positionCb) self.pipeline.disconnect_by_func(self._durationChangedCb) self.pipeline = None def _setUiActive(self, active=True): self.debug("active %r", active) self.set_sensitive(active) if self._haveUI: for item in [ self.goToStart_button, self.back_button, self.playpause_button, self.forward_button, self.goToEnd_button, self.timecode_entry, ]: item.set_sensitive(active) if active: self.emit("activate-playback-controls", True) def _externalWindowDeleteCb(self, window, event): self.dock() return True def _externalWindowConfigureCb(self, window, event): self.settings.viewerWidth = event.width self.settings.viewerHeight = event.height self.settings.viewerX = event.x self.settings.viewerY = event.y def _createUi(self): """ Creates the Viewer GUI """ # Drawing area # The aspect ratio gets overridden on startup by setDisplayAspectRatio self.aframe = gtk.AspectFrame(xalign=0.5, yalign=1.0, ratio=4.0 / 3.0, obey_child=False) self.internal = ViewerWidget(self.app.settings) self.internal.init_transformation_events() self.internal.show() self.aframe.add(self.internal) self.pack_start(self.aframe, expand=True) self.external_window = gtk.Window() vbox = gtk.VBox() vbox.set_spacing(SPACING) self.external_window.add(vbox) self.external = ViewerWidget(self.app.settings) vbox.pack_start(self.external) self.external_window.connect("delete-event", self._externalWindowDeleteCb) self.external_window.connect("configure-event", self._externalWindowConfigureCb) self.external_vbox = vbox self.external_vbox.show_all() # Buttons/Controls bbox = gtk.HBox() boxalign = gtk.Alignment(xalign=0.5, yalign=0.5) boxalign.add(bbox) self.pack_start(boxalign, expand=False) self.goToStart_button = gtk.ToolButton(gtk.STOCK_MEDIA_PREVIOUS) self.goToStart_button.connect("clicked", self._goToStartCb) self.goToStart_button.set_tooltip_text(_("Go to the beginning of the timeline")) self.goToStart_button.set_sensitive(False) bbox.pack_start(self.goToStart_button, expand=False) self.back_button = gtk.ToolButton(gtk.STOCK_MEDIA_REWIND) self.back_button.connect("clicked", self._backCb) self.back_button.set_tooltip_text(_("Go back one second")) self.back_button.set_sensitive(False) bbox.pack_start(self.back_button, expand=False) self.playpause_button = PlayPauseButton() self.playpause_button.connect("play", self._playButtonCb) bbox.pack_start(self.playpause_button, expand=False) self.playpause_button.set_sensitive(False) self.forward_button = gtk.ToolButton(gtk.STOCK_MEDIA_FORWARD) self.forward_button.connect("clicked", self._forwardCb) self.forward_button.set_tooltip_text(_("Go forward one second")) self.forward_button.set_sensitive(False) bbox.pack_start(self.forward_button, expand=False) self.goToEnd_button = gtk.ToolButton(gtk.STOCK_MEDIA_NEXT) self.goToEnd_button.connect("clicked", self._goToEndCb) self.goToEnd_button.set_tooltip_text(_("Go to the end of the timeline")) self.goToEnd_button.set_sensitive(False) bbox.pack_start(self.goToEnd_button, expand=False) # current time self.timecode_entry = TimeWidget() self.timecode_entry.setWidgetValue(0) self.timecode_entry.connect("value-changed", self._jumpToTimecodeCb) self.timecode_entry.connectFocusEvents(self._entryFocusInCb, self._entryFocusOutCb) bbox.pack_start(self.timecode_entry, expand=False, padding=10) self._haveUI = True screen = gtk.gdk.screen_get_default() height = screen.get_height() if height >= 800: # show the controls and force the aspect frame to have at least the same # width (+110, which is a magic number to minimize dead padding). bbox.show_all() width, height = bbox.size_request() width += 110 height = int(width / self.aframe.props.ratio) self.aframe.set_size_request(width, height) self.show_all() self.buttons = boxalign def setDisplayAspectRatio(self, ratio): """ Sets the DAR of the Viewer to the given ratio. @arg ratio: The aspect ratio to set on the viewer @type ratio: L{float} """ self.debug("Setting ratio of %f [%r]", float(ratio), ratio) try: self.aframe.set_property("ratio", float(ratio)) except: self.warning("could not set ratio !") def _entryFocusInCb(self, entry, event): self.app.gui.setActionsSensitive(False) def _entryFocusOutCb(self, entry, event): self.app.gui.setActionsSensitive(True) ## active Timeline calllbacks def _durationChangedCb(self, unused_pipeline, duration): if duration == 0: self._setUiActive(False) else: self._setUiActive(True) ## Control gtk.Button callbacks def setZoom(self, zoom): """ Zoom in or out of the transformation box canvas. This is called by clipproperties. """ if self.target.box: maxSize = self.target.area width = int(float(maxSize.width) * zoom) height = int(float(maxSize.height) * zoom) area = gtk.gdk.Rectangle((maxSize.width - width) / 2, (maxSize.height - height) / 2, width, height) self.sink.set_render_rectangle(*area) self.target.box.update_size(area) self.target.zoom = zoom self.target.sink = self.sink self.target.renderbox() def _playButtonCb(self, unused_button, playing): self.app.current.pipeline.togglePlayback() def _goToStartCb(self, unused_button): self.seeker.seek(0) def _backCb(self, unused_button): # Seek backwards one second self.seeker.seekRelative(0 - gst.SECOND) def _forwardCb(self, unused_button): # Seek forward one second self.seeker.seekRelative(gst.SECOND) def _goToEndCb(self, unused_button): try: end = self.app.current.pipeline.getDuration() except: self.warning("Couldn't get timeline duration") try: self.seeker.seek(end) except: self.warning("Couldn't seek to the end of the timeline") ## Callback for jumping to a specific timecode def _jumpToTimecodeCb(self, widget): nanoseconds = widget.getWidgetValue() self.seeker.seek(nanoseconds) ## public methods for controlling playback def undock(self): if not self.undock_action: self.error("Cannot undock because undock_action is missing.") return if not self.docked: return self.docked = False self.settings.viewerDocked = False self.undock_action.set_label(_("Dock Viewer")) self.remove(self.buttons) self.external_vbox.pack_end(self.buttons, False, False) self.external_window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_UTILITY) self.external_window.show() self.target = self.external # if we are playing, switch output immediately if self.sink: self._switch_output_window() self.hide() self.external_window.move(self.settings.viewerX, self.settings.viewerY) self.external_window.resize(self.settings.viewerWidth, self.settings.viewerHeight) def dock(self): if not self.undock_action: self.error("Cannot dock because undock_action is missing.") return if self.docked: return self.docked = True self.settings.viewerDocked = True self.undock_action.set_label(_("Undock Viewer")) self.target = self.internal self.external_vbox.remove(self.buttons) self.pack_end(self.buttons, False, False) self.show() # if we are playing, switch output immediately if self.sink: self._switch_output_window() self.external_window.hide() def _toggleDocked(self, action): if self.docked: self.undock() else: self.dock() def _positionCb(self, unused_pipeline, position): """ If the timeline position changed, update the viewer UI widgets. This is meant to be called either by the gobject timer when playing, or by mainwindow's _timelineSeekCb when the timer is disabled. """ self.timecode_entry.setWidgetValue(position, False) def clipTrimPreview(self, tl_obj, position): """ While a clip is being trimmed, show a live preview of it. """ if 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 clip_uri = tl_obj.props.uri cur_time = time() if not self._tmp_pipeline: self.debug("Creating temporary pipeline for clip %s, position %s", clip_uri, gst.TIME_ARGS(position)) self._oldTimelinePos = self.pipeline.getPosition() self._tmp_pipeline = gst.element_factory_make("playbin2") self._tmp_pipeline.set_property("uri", clip_uri) self.setPipeline(SimplePipeline(self._tmp_pipeline)) self._lastClipTrimTime = cur_time if (cur_time - self._lastClipTrimTime) > 0.2: # Do not seek more than once every 200 ms (for performance) self._tmp_pipeline.seek_simple(gst.FORMAT_TIME, gst.SEEK_FLAG_FLUSH, position) self._lastClipTrimTime = cur_time def clipTrimPreviewFinished(self): """ After trimming a clip, reset the project pipeline into the viewer. """ if self._tmp_pipeline is not None: self._tmp_pipeline.set_state(gst.STATE_NULL) self._tmp_pipeline = None # Free the memory self.setPipeline(self.app.current.pipeline, self._oldTimelinePos) self.debug("Back to old pipeline") def _pipelineStateChangedCb(self, pipeline, state): """ When playback starts/stops, update the viewer widget, play/pause button and (un)inhibit the screensaver. This is meant to be called by mainwindow. """ self.info("current state changed : %s", state) if int(state) == int(gst.STATE_PLAYING): self.playpause_button.setPause() self.system.inhibitScreensaver(self.INHIBIT_REASON) elif int(state) == int(gst.STATE_PAUSED): self.playpause_button.setPlay() self.system.uninhibitScreensaver(self.INHIBIT_REASON) else: self.sink = None self.system.uninhibitScreensaver(self.INHIBIT_REASON) self.internal._currentStateCb(self.pipeline, state) def xidMessageCb(self, unused_pipeline, message): """ When the pipeline sends us a message to prepare-xwindow-id, tell the viewer to switch its output window. """ self.sink = message.src self._switch_output_window() def _switch_output_window(self): gtk.gdk.threads_enter() self.sink.set_xwindow_id(self.target.window_xid) self.sink.expose() gtk.gdk.threads_leave()