def refresh(self, *p, **kw):
def display_popup(widget, event, element):
if event.button == 3:
menu = advene.gui.popup.Menu(element,
controller=self.controller)
menu.popup()
return True
return False
g = self.controller.gui
for (w, elements) in ((self.created, g.last_created), (self.edited,
g.last_edited)):
w.foreach(w.remove)
for e in reversed(elements):
if isinstance(e, Annotation):
b = AnnotationRepresentation(e, self.controller)
elif isinstance(e, Relation):
b = RelationRepresentation(e, self.controller)
else:
b = Gtk.Button("\n".join(
(helper.get_type(e), self.controller.get_title(e))),
use_underline=False)
b.connect('clicked',
(lambda i, el: self.controller.gui.edit_element(el)),
e)
content = getattr(e, 'content', None)
if content:
b.set_tooltip_text(content.data)
enable_drag_source(b, e, self.controller)
b.connect('button-press-event', display_popup, e)
w.pack_start(b, False, True, 0)
self.widget.show_all()
return True
def build_widget(self):
vbox = gtk.VBox()
self.label = {}
self.label['title'] = gtk.Label()
vbox.pack_start(self.label['title'], expand=False)
b = self.label['edit'] = gtk.Button(_("Edit query"))
# Enable DND
def get_element():
return self.element
enable_drag_source(b, get_element, self.controller)
b.connect('clicked',
lambda w: self.controller.gui.edit_element(self.element))
vbox.pack_start(b, expand=False)
f = gtk.Frame(_("Try to apply the query on..."))
v = gtk.VBox()
f.add(v)
def try_query(b, expr):
try:
res, q = self.controller.evaluate_query(self.element,
expr=expr)
self.controller.gui.open_adhoc_view('interactiveresult',
query=self.element,
result=res,
destination='east')
except Exception, e:
#print "********** Oops"
#import traceback
#traceback.print_exc()
b.set_sensitive(False)
return True
def build_widget(self):
vbox=gtk.VBox()
self.label={}
self.label['title']=gtk.Label()
vbox.pack_start(self.label['title'], expand=False)
b=self.label['edit']=gtk.Button(_("Edit query"))
# Enable DND
def get_element():
return self.element
enable_drag_source(b, get_element, self.controller)
b.connect('clicked', lambda w: self.controller.gui.edit_element(self.element))
vbox.pack_start(b, expand=False)
f=gtk.Frame(_("Try to apply the query on..."))
v=gtk.VBox()
f.add(v)
def try_query(b, expr):
try:
res, q = self.controller.evaluate_query(self.element, expr=expr)
self.controller.gui.open_adhoc_view('interactiveresult',
query=self.element,
result=res,
destination='east')
except Exception, e:
#print "********** Oops"
#import traceback
#traceback.print_exc()
b.set_sensitive(False)
return True
def refresh(self, *p, **kw):
def display_popup(widget, event, element):
if event.button == 3:
menu = advene.gui.popup.Menu(element, controller=self.controller)
menu.popup()
return True
return False
g=self.controller.gui
for (w, elements) in ( (self.created, g.last_created),
(self.edited, g.last_edited) ):
w.foreach(w.remove)
for e in reversed(elements):
b=gtk.Button("\n".join((helper.get_type(e), self.controller.get_title(e))), use_underline=False)
b.set_alignment(0, 0)
colorname=self.controller.get_element_color(e)
if colorname:
if config.data.os == 'win32':
text=b.get_label()
b.foreach(b.remove)
l=gtk.Label()
l.set_markup('<span background="%s">%s</span>' % (colorname, text))
l.show()
b.add(l)
else:
style = b.modify_bg(gtk.STATE_NORMAL, name2color(colorname))
b.connect('clicked', (lambda i, el: self.controller.gui.edit_element(el)),
e)
content=getattr(e, 'content', None)
if content:
b.set_tooltip_text(content.data)
enable_drag_source(b, e, self.controller)
b.connect('button-press-event', display_popup, e)
w.pack_start(b, expand=False)
self.widget.show_all()
return True
def refresh(self, *p, **kw):
def display_popup(widget, event, element):
if event.button == 3:
menu = advene.gui.popup.Menu(element, controller=self.controller)
menu.popup()
return True
return False
g=self.controller.gui
for (w, elements) in ( (self.created, g.last_created),
(self.edited, g.last_edited) ):
w.foreach(w.remove)
for e in reversed(elements):
if isinstance(e, Annotation):
b = AnnotationRepresentation(e, self.controller)
elif isinstance(e, Relation):
b = RelationRepresentation(e, self.controller)
else:
b = Gtk.Button("\n".join((helper.get_type(e), self.controller.get_title(e))), use_underline=False)
b.connect('clicked', (lambda i, el: self.controller.gui.edit_element(el)),
e)
content=getattr(e, 'content', None)
if content:
b.set_tooltip_text(content.data)
enable_drag_source(b, e, self.controller)
b.connect('button-press-event', display_popup, e)
w.pack_start(b, False, True, 0)
self.widget.show_all()
return True
def __init__(self, annotation=None, container=None):
self.annotation=annotation
self.active=False
self._fraction_marker=None
GenericColorButtonWidget.__init__(self, element=annotation, container=container)
self.connect('key-press-event', self.keypress, self.annotation)
self.connect('enter-notify-event', lambda b, e: b.grab_focus() and True)
# The widget can generate drags
enable_drag_source(self, annotation, container.controller)
self.no_image_pixbuf=None
def __init__(self, annotation=None, container=None):
self.annotation=annotation
self.active=False
self._fraction_marker=None
GenericColorButtonWidget.__init__(self, element=annotation, container=container)
self.connect('key-press-event', self.keypress, self.annotation)
self.connect('enter-notify-event', lambda b, e: b.grab_focus() and True)
# The widget can generate drags
enable_drag_source(self, annotation, container.controller)
self.no_image_pixbuf=None
def __init__(self, relation, controller, direction='to'):
self.relation=relation
self.controller=controller
self.direction=direction
super(RelationRepresentation, self).__init__()
l=gtk.Label()
self.add(l)
l.show()
self.refresh()
self.connect('button-press-event', self.button_press_handler, relation)
enable_drag_source(self, self.relation, self.controller)
def __init__(self, annotation, controller):
super(AnnotationRepresentation, self).__init__()
self.annotation=annotation
self.controller=controller
self.add(self.controller.gui.get_illustrated_text(text=self.controller.get_title(annotation),
position=annotation.fragment.begin,
vertical=False,
height=20,
color=controller.get_element_color(annotation)))
self.connect('button-press-event', self.button_press_handler, annotation)
enable_drag_source(self, self.annotation, self.controller)
def __init__(self, relation, controller, direction='to'):
self.relation=relation
self.controller=controller
self.direction=direction
super(RelationRepresentation, self).__init__()
l=gtk.Label()
self.add(l)
l.show()
self.refresh()
self.connect('button-press-event', self.button_press_handler, relation)
enable_drag_source(self, self.relation, self.controller)
def __init__(self, annotation, controller):
super(AnnotationRepresentation, self).__init__()
self.annotation=annotation
self.controller=controller
self.add(self.controller.gui.get_illustrated_text(text=self.controller.get_title(annotation),
position=annotation.begin,
vertical=False,
height=20,
color=controller.get_element_color(annotation)))
self.connect('button-press-event', self.button_press_handler, annotation)
enable_drag_source(self, self.annotation, self.controller)
def build_widget(self):
vbox = Gtk.VBox()
self.label = {}
self.label['title'] = Gtk.Label()
vbox.pack_start(self.label['title'], False, True, 0)
self.label['info'] = Gtk.Label()
vbox.pack_start(self.label['info'], False, True, 0)
b = self.label['edit'] = Gtk.Button(_("Edit view"))
b.connect('clicked',
lambda w: self.controller.gui.edit_element(self.element))
# Enable DND
def get_element():
return self.element
enable_drag_source(b, get_element, self.controller)
vbox.pack_start(b, False, True, 0)
b = self.label['activate'] = Gtk.Button(_("Open view"))
b.connect('clicked', self.activate)
# Drag and drop for adhoc views
def drag_data_get_cb(button, context, selection, targetType,
timestamp):
if targetType == config.data.target_type['adhoc-view']:
if not isinstance(self.element, View):
return False
if helper.get_view_type(self.element) != 'adhoc':
return False
selection.set(
selection.get_target(), 8,
urllib.parse.urlencode({
'id': self.element.id,
}).encode('utf8'))
return True
else:
logger.warning("Unknown target type for drag: %d", targetType)
return True
b.drag_source_set(
Gdk.ModifierType.BUTTON1_MASK,
config.data.get_target_types('adhoc-view'),
Gdk.DragAction.LINK | Gdk.DragAction.COPY | Gdk.DragAction.MOVE)
b.connect('drag-data-get', drag_data_get_cb)
vbox.pack_start(b, False, True, 0)
vbox.show_all()
return vbox
def build_widget(self):
vbox = gtk.VBox()
self.label = {}
self.label['title'] = gtk.Label()
vbox.pack_start(self.label['title'], expand=False)
self.label['info'] = gtk.Label()
vbox.pack_start(self.label['info'], expand=False)
b = self.label['edit'] = gtk.Button(_("Edit view"))
b.connect('clicked',
lambda w: self.controller.gui.edit_element(self.element))
# Enable DND
def get_element():
return self.element
enable_drag_source(b, get_element, self.controller)
vbox.pack_start(b, expand=False)
b = self.label['activate'] = gtk.Button(_("Open view"))
b.connect('clicked', self.activate)
# Drag and drop for adhoc views
def drag_data_get_cb(button, context, selection, targetType,
timestamp):
if targetType == config.data.target_type['adhoc-view']:
if not isinstance(self.element, View):
return False
if helper.get_view_type(self.element) != 'adhoc':
return False
selection.set(
selection.target, 8,
urllib.urlencode({
'id': self.element.id,
}).encode('utf8'))
return True
else:
print "Unknown target type for drag: %d" % targetType
return True
b.drag_source_set(
gtk.gdk.BUTTON1_MASK, config.data.drag_type['adhoc-view'],
gtk.gdk.ACTION_LINK | gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE)
b.connect('drag-data-get', drag_data_get_cb)
vbox.pack_start(b, expand=False)
vbox.show_all()
return vbox
def build_widget(self):
vbox = Gtk.VBox()
self.label = {}
self.label['title'] = Gtk.Label()
vbox.pack_start(self.label['title'], False, True, 0)
b = self.label['edit'] = Gtk.Button(_("Edit query"))
# Enable DND
def get_element():
return self.element
enable_drag_source(b, get_element, self.controller)
b.connect('clicked',
lambda w: self.controller.gui.edit_element(self.element))
vbox.pack_start(b, False, True, 0)
f = Gtk.Frame.new(_("Try to apply the query on..."))
v = Gtk.VBox()
f.add(v)
def try_query(b, expr):
try:
res, q = self.controller.evaluate_query(self.element,
expr=expr)
self.controller.gui.open_adhoc_view('interactiveresult',
query=self.element,
result=res,
destination='east')
except Exception:
logger.debug("Exception in query evaluation", exc_info=True)
b.set_sensitive(False)
return True
self.apply_buttons = []
for (expr, label) in (
('package', _("the package")),
('package/annotations', _("all annotations of the package")),
('package/annotations/first',
_("the first annotation of the package")),
):
b = Gtk.Button(label, use_underline=False)
b.connect('clicked', try_query, expr)
v.pack_start(b, False, True, 0)
self.apply_buttons.append(b)
vbox.add(f)
vbox.show_all()
return vbox
def build_widget(self):
vbox=gtk.VBox()
self.label={}
self.label['title']=gtk.Label()
vbox.pack_start(self.label['title'], expand=False)
b=self.label['edit']=gtk.Button(_("Edit resource"))
# Enable DND
def get_element():
return self.element
enable_drag_source(b, get_element, self.controller)
b.connect('clicked', lambda w: self.controller.gui.edit_element(self.element))
vbox.pack_start(b, expand=False)
self.preview=gtk.VBox()
vbox.add(self.preview)
vbox.show_all()
return vbox
def build_widget(self):
vbox=Gtk.VBox()
self.label={}
self.label['title']=Gtk.Label()
vbox.pack_start(self.label['title'], False, True, 0)
b=self.label['edit']=Gtk.Button(_("Edit query"))
# Enable DND
def get_element():
return self.element
enable_drag_source(b, get_element, self.controller)
b.connect('clicked', lambda w: self.controller.gui.edit_element(self.element))
vbox.pack_start(b, False, True, 0)
f=Gtk.Frame.new(_("Try to apply the query on..."))
v=Gtk.VBox()
f.add(v)
def try_query(b, expr):
try:
res, q = self.controller.evaluate_query(self.element, expr=expr)
self.controller.gui.open_adhoc_view('interactiveresult',
query=self.element,
result=res,
destination='east')
except Exception:
logger.debug("Exception in query evaluation", exc_info=True)
b.set_sensitive(False)
return True
self.apply_buttons=[]
for (expr, label) in (
('package', _("the package")),
('package/annotations', _("all annotations of the package")),
('package/annotations/first', _("the first annotation of the package")),
):
b=Gtk.Button(label, use_underline=False)
b.connect('clicked', try_query, expr)
v.pack_start(b, False, True, 0)
self.apply_buttons.append(b)
vbox.add(f)
vbox.show_all()
return vbox
def build_widget(self):
vbox=gtk.VBox()
self.label={}
self.label['title']=gtk.Label()
vbox.pack_start(self.label['title'], expand=False)
self.label['info']=gtk.Label()
vbox.pack_start(self.label['info'], expand=False)
b=self.label['edit']=gtk.Button(_("Edit view"))
b.connect('clicked', lambda w: self.controller.gui.edit_element(self.element))
# Enable DND
def get_element():
return self.element
enable_drag_source(b, get_element, self.controller)
vbox.pack_start(b, expand=False)
b=self.label['activate']=gtk.Button(_("Open view"))
b.connect('clicked', self.activate)
# Drag and drop for adhoc views
def drag_data_get_cb(button, context, selection, targetType, timestamp):
if targetType == config.data.target_type['adhoc-view']:
if not isinstance(self.element, View):
return False
if helper.get_view_type(self.element) != 'adhoc':
return False
selection.set(selection.target, 8,
urllib.urlencode( {
'id': self.element.id,
} ).encode('utf8'))
return True
else:
print "Unknown target type for drag: %d" % targetType
return True
b.drag_source_set(gtk.gdk.BUTTON1_MASK,
config.data.drag_type['adhoc-view'],
gtk.gdk.ACTION_LINK | gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE)
b.connect('drag-data-get', drag_data_get_cb)
vbox.pack_start(b, expand=False)
vbox.show_all()
return vbox
def build_widget(self):
vbox=Gtk.VBox()
self.label={}
self.label['title']=Gtk.Label()
vbox.pack_start(self.label['title'], False, True, 0)
self.label['info']=Gtk.Label()
vbox.pack_start(self.label['info'], False, True, 0)
b=self.label['edit']=Gtk.Button(_("Edit view"))
b.connect('clicked', lambda w: self.controller.gui.edit_element(self.element))
# Enable DND
def get_element():
return self.element
enable_drag_source(b, get_element, self.controller)
vbox.pack_start(b, False, True, 0)
b=self.label['activate']=Gtk.Button(_("Open view"))
b.connect('clicked', self.activate)
# Drag and drop for adhoc views
def drag_data_get_cb(button, context, selection, targetType, timestamp):
if targetType == config.data.target_type['adhoc-view']:
if not isinstance(self.element, View):
return False
if helper.get_view_type(self.element) != 'adhoc':
return False
selection.set(selection.get_target(), 8,
urllib.parse.urlencode( {
'id': self.element.id,
} ).encode('utf8'))
return True
else:
logger.warn("Unknown target type for drag: %d" % targetType)
return True
b.drag_source_set(Gdk.ModifierType.BUTTON1_MASK,
config.data.get_target_types('adhoc-view'),
Gdk.DragAction.LINK | Gdk.DragAction.COPY | Gdk.DragAction.MOVE)
b.connect('drag-data-get', drag_data_get_cb)
vbox.pack_start(b, False, True, 0)
vbox.show_all()
return vbox
def __init__(self, annotation=None, container=None):
self.annotation = annotation
self.active = False
self._fraction_marker = None
self.resize_time = None
self.resize_cursor = Gdk.Cursor.new_from_name(
container.widget.get_display(), "ew-resize")
GenericColorButtonWidget.__init__(self,
element=annotation,
container=container)
self.connect('key-press-event', self.keypress, self.annotation)
self.connect('enter-notify-event',
lambda b, e: b.grab_focus() and True)
self.connect('leave-notify-event',
lambda b, e: self.set_cursor(None) and False)
self.connect('motion-notify-event', self.motion_notify_cb)
# The widget can generate drags
enable_drag_source(self, annotation, container.controller)
self.no_image_pixbuf = None
def build_widget(self):
vbox = Gtk.VBox()
self.label = {}
self.label['title'] = Gtk.Label()
vbox.pack_start(self.label['title'], False, True, 0)
b = self.label['edit'] = Gtk.Button(_("Edit resource"))
# Enable DND
def get_element():
return self.element
enable_drag_source(b, get_element, self.controller)
b.connect('clicked',
lambda w: self.controller.gui.edit_element(self.element))
vbox.pack_start(b, False, True, 0)
self.preview = Gtk.VBox()
vbox.add(self.preview)
vbox.show_all()
return vbox
def build_widget(self):
vbox=gtk.VBox()
self.player = self.controller.playerfactory.get_player()
self.player.sound_mute()
self.drawable=gtk.Socket()
def handle_remove(socket):
# Do not kill the widget if the application exits
return True
self.drawable.connect('plug-removed', handle_remove)
black=gtk.gdk.Color(0, 0, 0)
for state in (gtk.STATE_ACTIVE, gtk.STATE_NORMAL,
gtk.STATE_SELECTED, gtk.STATE_INSENSITIVE,
gtk.STATE_PRELIGHT):
self.drawable.modify_bg (state, black)
self.drawable.set_size_request(320, 200)
self.toolbar=gtk.Toolbar()
self.toolbar.set_style(gtk.TOOLBAR_ICONS)
# Append the volume control to the toolbar
def volume_change(scale, value):
if self.player.sound_get_volume() != int(value * 100):
self.player.sound_set_volume(int(value * 100))
return True
self.audio_volume = gtk.VolumeButton()
self.audio_volume.set_value(self.player.sound_get_volume() / 100.0)
ti = gtk.ToolItem()
ti.add(self.audio_volume)
self.audio_volume.connect('value-changed', volume_change)
self.toolbar.insert(ti, -1)
sync_button=gtk.ToolButton(gtk.STOCK_CONNECT)
sync_button.set_tooltip_text(_("Synchronize"))
sync_button.connect('clicked', self.synchronize)
self.toolbar.insert(sync_button, -1)
def offset_changed(spin):
self.offset = long(spin.get_value())
return True
ti = gtk.ToolItem()
self.offset_spin = gtk.SpinButton(gtk.Adjustment(value = self.offset,
lower = - 24 * 60 * 60 * 1000,
upper = 24 * 60 * 60 * 1000,
step_incr = 1000 / config.data.preferences['default-fps'],
page_incr = 1000))
self.offset_spin.get_adjustment().connect('value-changed', offset_changed)
ti.add(self.offset_spin)
self.offset_spin.set_tooltip_text(_("Offset in ms"))
self.toolbar.insert(ti, -1)
self.label = gtk.Label()
self.label.set_alignment(0, 0)
self.label.modify_font(pango.FontDescription("sans 10"))
timestamp_button = get_pixmap_button('set-to-now.png')
timestamp_button.set_tooltip_text(_("Drag and drop to get player time"))
enable_drag_source(timestamp_button, lambda: long(self.player.get_stream_information().position), self.controller)
# Cannot use a gtk.ToolButton since it cannot be drag_source
ti = gtk.ToolItem()
ti.add(timestamp_button)
self.toolbar.insert(ti, -1)
black=gtk.gdk.color_parse('black')
white=gtk.gdk.color_parse('white')
eb=gtk.EventBox()
eb.add(self.label)
for state in (gtk.STATE_ACTIVE, gtk.STATE_NORMAL,
gtk.STATE_SELECTED, gtk.STATE_INSENSITIVE,
gtk.STATE_PRELIGHT):
self.label.modify_bg(state, black)
eb.modify_bg(state, black)
self.label.modify_fg(state, white)
vbox.add(self.drawable)
vbox.pack_start(eb, expand=False)
vbox.pack_start(self.toolbar, expand=False)
self.drawable.connect_after('realize', self.register_drawable)
# Accept annotation/timestamp drop, to adjust time offset
vbox.connect('drag-data-received', self.drag_received_cb)
vbox.drag_dest_set(gtk.DEST_DEFAULT_MOTION |
gtk.DEST_DEFAULT_HIGHLIGHT |
gtk.DEST_DEFAULT_ALL,
config.data.drag_type['annotation'] +
config.data.drag_type['timestamp'],
gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_LINK | gtk.gdk.ACTION_MOVE)
vbox.show_all()
return vbox
def build_widget(self):
vbox = gtk.VBox()
self.player = self.controller.playerfactory.get_player()
self.player.sound_mute()
self.drawable = gtk.Socket()
def handle_remove(socket):
# Do not kill the widget if the application exits
return True
self.drawable.connect('plug-removed', handle_remove)
black = gtk.gdk.Color(0, 0, 0)
for state in (gtk.STATE_ACTIVE, gtk.STATE_NORMAL, gtk.STATE_SELECTED,
gtk.STATE_INSENSITIVE, gtk.STATE_PRELIGHT):
self.drawable.modify_bg(state, black)
self.drawable.set_size_request(320, 200)
self.toolbar = gtk.Toolbar()
self.toolbar.set_style(gtk.TOOLBAR_ICONS)
# Append the volume control to the toolbar
def volume_change(scale, value):
if self.player.sound_get_volume() != int(value * 100):
self.player.sound_set_volume(int(value * 100))
return True
self.audio_volume = gtk.VolumeButton()
self.audio_volume.set_value(self.player.sound_get_volume() / 100.0)
ti = gtk.ToolItem()
ti.add(self.audio_volume)
self.audio_volume.connect('value-changed', volume_change)
self.toolbar.insert(ti, -1)
sync_button = gtk.ToolButton(gtk.STOCK_CONNECT)
sync_button.set_tooltip_text(_("Synchronize"))
sync_button.connect('clicked', self.synchronize)
self.toolbar.insert(sync_button, -1)
def offset_changed(spin):
self.offset = long(spin.get_value())
return True
ti = gtk.ToolItem()
self.offset_spin = gtk.SpinButton(
gtk.Adjustment(value=self.offset,
lower=-24 * 60 * 60 * 1000,
upper=24 * 60 * 60 * 1000,
step_incr=1000 /
config.data.preferences['default-fps'],
page_incr=1000))
self.offset_spin.get_adjustment().connect('value-changed',
offset_changed)
ti.add(self.offset_spin)
self.offset_spin.set_tooltip_text(_("Offset in ms"))
self.toolbar.insert(ti, -1)
self.label = gtk.Label()
self.label.set_alignment(0, 0)
self.label.modify_font(pango.FontDescription("sans 10"))
timestamp_button = get_pixmap_button('set-to-now.png')
timestamp_button.set_tooltip_text(
_("Drag and drop to get player time"))
enable_drag_source(
timestamp_button,
lambda: long(self.player.get_stream_information().position),
self.controller)
# Cannot use a gtk.ToolButton since it cannot be drag_source
ti = gtk.ToolItem()
ti.add(timestamp_button)
self.toolbar.insert(ti, -1)
black = gtk.gdk.color_parse('black')
white = gtk.gdk.color_parse('white')
eb = gtk.EventBox()
eb.add(self.label)
for state in (gtk.STATE_ACTIVE, gtk.STATE_NORMAL, gtk.STATE_SELECTED,
gtk.STATE_INSENSITIVE, gtk.STATE_PRELIGHT):
self.label.modify_bg(state, black)
eb.modify_bg(state, black)
self.label.modify_fg(state, white)
vbox.add(self.drawable)
vbox.pack_start(eb, expand=False)
vbox.pack_start(self.toolbar, expand=False)
self.drawable.connect_after('realize', self.register_drawable)
# Accept annotation/timestamp drop, to adjust time offset
vbox.connect('drag-data-received', self.drag_received_cb)
vbox.drag_dest_set(
gtk.DEST_DEFAULT_MOTION | gtk.DEST_DEFAULT_HIGHLIGHT
| gtk.DEST_DEFAULT_ALL, config.data.drag_type['annotation'] +
config.data.drag_type['timestamp'],
gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_LINK | gtk.gdk.ACTION_MOVE)
vbox.show_all()
return vbox
def __init__(self, value, controller, width=None, epsilon=None, comment_getter=None, visible_label=True, bgcolor=None, callback=None):
"""Instanciate a new TimestampRepresentation.
@param value: the timestamp value
@type value: int
@param controller: the controller
@type controller: advene.core.Controller
@param width: the snapshot width
@type width: int
@param epsilon: the precision (for snapshot display)
@type epsilon: int (ms)
@param comment_getter: method returning the associated comment
@type comment_getter: method
@param visible_label: should the timestamp label be displayed?
@type visible_label: boolean
@param bgcolor: background color
@type bgcolor: string
@value callback: a callback that will be called before value modification
@type callback: method. If it returns False, then the modification will be cancelled
"""
super(TimestampRepresentation, self).__init__()
self._value=value
self.controller=controller
self._width=width or config.data.preferences['bookmark-snapshot-width']
if epsilon is None:
epsilon=config.data.preferences['bookmark-snapshot-precision']
self.epsilon=epsilon
self.visible_label=visible_label
# comment_getter is a method which returns the comment
# associated to this timestamp
self.comment_getter=comment_getter
# extend_popup_menu is a method which takes the menu and the
# element as parameter, and adds appropriate menu items.
self.extend_popup_menu=None
self.highlight=False
self._bgcolor = None
# Displayed text.
self._text = '<span size="xx-small">%(timestamp)s</span>'
self.callback = callback
box=gtk.VBox()
self.image=gtk.Image()
self.label=gtk.Label()
box.pack_start(self.image, expand=False)
box.pack_start(self.label, expand=False)
if not self.visible_label:
self.label.set_no_show_all(True)
self.label.hide()
self.add(box)
self.box=box
self._bgcolor = bgcolor
self.refresh()
self.connect('button-press-event', self._button_press_handler)
enable_drag_source(self, self.get_value, self.controller)
def enter_bookmark(widget, event):
self.controller.notify('BookmarkHighlight', timestamp=self.value, immediate=True)
self.highlight=True
return False
def leave_bookmark(widget, event):
self.controller.notify('BookmarkUnhighlight', timestamp=self.value, immediate=True)
self.highlight=False
return False
self.connect('enter-notify-event', enter_bookmark)
self.connect('leave-notify-event', leave_bookmark)
self._rules=[]
# React to UpdateSnapshot events
self._rules.append(self.controller.event_handler.internal_rule (event='SnapshotUpdate',
method=self.snapshot_update_cb))
self.connect('destroy', self.remove_rules)
def build_widget(self):
vbox = Gtk.VBox()
self.player = self.controller.playerfactory.get_player()
self.player.sound_mute()
self.drawable = get_drawable()
black = Gdk.Color(0, 0, 0)
for state in (Gtk.StateType.ACTIVE, Gtk.StateType.NORMAL,
Gtk.StateType.SELECTED, Gtk.StateType.INSENSITIVE,
Gtk.StateType.PRELIGHT):
self.drawable.modify_bg(state, black)
self.drawable.set_size_request(320, 200)
self.toolbar = Gtk.Toolbar()
self.toolbar.set_style(Gtk.ToolbarStyle.ICONS)
# Append the volume control to the toolbar
def volume_change(scale, value):
if self.player.sound_get_volume() != int(value * 100):
self.player.sound_set_volume(int(value * 100))
return True
self.audio_volume = Gtk.VolumeButton()
self.audio_volume.set_value(self.player.sound_get_volume() / 100.0)
ti = Gtk.ToolItem()
ti.add(self.audio_volume)
self.audio_volume.connect('value-changed', volume_change)
self.toolbar.insert(ti, -1)
sync_button = Gtk.ToolButton(Gtk.STOCK_CONNECT)
sync_button.set_tooltip_text(_("Synchronize"))
sync_button.connect('clicked', self.synchronize)
self.toolbar.insert(sync_button, -1)
def offset_changed(spin):
self.offset = int(spin.get_value())
return True
ti = Gtk.ToolItem()
self.offset_spin = Gtk.SpinButton.new(
Gtk.Adjustment.new(self.offset, -24 * 60 * 60 * 1000,
24 * 60 * 60 * 1000,
self.controller.frame2time(1), 1000, 500), 1000,
0)
self.offset_spin.get_adjustment().connect('value-changed',
offset_changed)
ti.add(self.offset_spin)
self.offset_spin.set_tooltip_text(_("Offset in ms"))
self.toolbar.insert(ti, -1)
self.label = Gtk.Label()
self.label.set_alignment(0, 0)
self.label.modify_font(Pango.FontDescription("sans 10"))
timestamp_button = get_pixmap_button('set-to-now.png')
timestamp_button.set_tooltip_text(
_("Drag and drop to get player time"))
enable_drag_source(
timestamp_button,
lambda: int(self.player.get_stream_information().position),
self.controller)
# Cannot use a Gtk.ToolButton since it cannot be drag_source
ti = Gtk.ToolItem()
ti.add(timestamp_button)
self.toolbar.insert(ti, -1)
black = Gdk.color_parse('black')
white = Gdk.color_parse('white')
eb = Gtk.EventBox()
eb.add(self.label)
for state in (Gtk.StateType.ACTIVE, Gtk.StateType.NORMAL,
Gtk.StateType.SELECTED, Gtk.StateType.INSENSITIVE,
Gtk.StateType.PRELIGHT):
self.label.modify_bg(state, black)
eb.modify_bg(state, black)
self.label.modify_fg(state, white)
vbox.add(self.drawable)
vbox.pack_start(eb, False, True, 0)
vbox.pack_start(self.toolbar, False, True, 0)
self.drawable.connect_after('realize', self.register_drawable)
# Accept annotation/timestamp drop, to adjust time offset
vbox.connect('drag-data-received', self.drag_received_cb)
vbox.drag_dest_set(
Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT
| Gtk.DestDefaults.ALL,
config.data.get_target_types('annotation', 'timestamp'),
Gdk.DragAction.COPY | Gdk.DragAction.LINK | Gdk.DragAction.MOVE)
vbox.show_all()
return vbox
def __init__(self, value, controller, width=None, epsilon=None, comment_getter=None, visible_label=True, bgcolor=None, callback=None):
"""Instanciate a new TimestampRepresentation.
@param value: the timestamp value
@type value: int
@param controller: the controller
@type controller: advene.core.Controller
@param width: the snapshot width
@type width: int
@param epsilon: the precision (for snapshot display)
@type epsilon: int (ms)
@param comment_getter: method returning the associated comment
@type comment_getter: method
@param visible_label: should the timestamp label be displayed?
@type visible_label: boolean
@param bgcolor: background color
@type bgcolor: string
@value callback: a callback that will be called before value modification
@type callback: method. If it returns False, then the modification will be cancelled
"""
super(TimestampRepresentation, self).__init__()
self._value=value
self.controller=controller
self._width=width or config.data.preferences['bookmark-snapshot-width']
if epsilon is None:
epsilon=config.data.preferences['bookmark-snapshot-precision']
self.epsilon=epsilon
self.visible_label=visible_label
# comment_getter is a method which returns the comment
# associated to this timestamp
self.comment_getter=comment_getter
# extend_popup_menu is a method which takes the menu and the
# element as parameter, and adds appropriate menu items.
self.extend_popup_menu=None
self.highlight=False
self._bgcolor = None
# Displayed text.
self._text = '<span size="xx-small">%(timestamp)s</span>'
self.callback = callback
box=gtk.VBox()
self.image=gtk.Image()
self.label=gtk.Label()
box.pack_start(self.image, expand=False)
box.pack_start(self.label, expand=False)
if not self.visible_label:
self.label.set_no_show_all(True)
self.label.hide()
self.add(box)
self.box=box
self._bgcolor = bgcolor
self.refresh()
self.connect('button-press-event', self._button_press_handler)
enable_drag_source(self, self.get_value, self.controller)
def enter_bookmark(widget, event):
self.controller.notify('BookmarkHighlight', timestamp=self.value, immediate=True)
self.highlight=True
return False
def leave_bookmark(widget, event):
self.controller.notify('BookmarkUnhighlight', timestamp=self.value, immediate=True)
self.highlight=False
return False
self.connect('enter-notify-event', enter_bookmark)
self.connect('leave-notify-event', leave_bookmark)
self._rules=[]
# React to UpdateSnapshot events
self._rules.append(self.controller.event_handler.internal_rule (event='SnapshotUpdate',
method=self.snapshot_update_cb))
self.connect('destroy', self.remove_rules)
