def __init__(self, buff, appwin, readonly = False):
# Save params
self.appwin = appwin;
self.readonly = readonly
# Gather globals
self.keyh = pedconfig.conf.keyh
# Init vars
self.xpos = 0; self.ypos = 0
self.changed = False;
self.needscan = True;
self.record = False;
self.recarr = [] # Macros
self.undoarr = [] # Undo
self.redoarr = [] # Redo
self.colsel = False
self.oldsearch = ""
self.oldrep = ""
self.xsel = -1; self.ysel = -1
self.xsel2 = -1; self.ysel2 = -1
self.mx = -1; self.my = -1
self.caret = []; self.caret.append(0); self.caret.append(0)
self.focus = False
self.insert = True
self.startxxx = -1; self.startyyy = -1
self.hex = False
self.accum = [];
self.bigcaret = False
# Init configurables
self.scgap = SCROLLGAP
self.pgup = PAGEUP
self.tabstop = TABSTOP
# Process buffer into list
self.text = buff
self.maxlinelen = 0
# Parent widget
gtk.DrawingArea.__init__(self)
self.set_flags(gtk.CAN_FOCUS | gtk.SENSITIVE)
self.pangolayout = self.create_pango_layout("a")
if self.readonly:
self.set_tooltip_text("Read only buffer")
# Our font
fd = pango.FontDescription()
fd.set_size(14*1024); fd.set_family("mono")
self.pangolayout.set_font_description(fd)
# Get Pango steps
self.cxx, self.cyy = self.pangolayout.get_pixel_size()
ts = self.pangolayout.get_tabs()
if ts == None: self.tabstop = TABSTOP
else: al, self.tabstop = ts.get_tab(0)
#print "tabstop", self.tabstop
sm = len(self.text) + self.get_height() / self.cyy + 10
self.hadj = gtk.Adjustment(0, 0, self.maxlinelen, 1, 15, 25);
self.vadj = gtk.Adjustment(0, 0, sm, 1, 15, 25)
self.vscroll = gtk.VScrollbar(self.vadj)
self.hscroll = gtk.HScrollbar(self.hadj)
# We connect scrollers after construction
self.hadj.connect("value-changed", self.hscroll_cb)
self.vadj.connect("value-changed", self.vscroll_cb)
self.set_events( gtk.gdk.POINTER_MOTION_MASK |
gtk.gdk.POINTER_MOTION_HINT_MASK |
gtk.gdk.BUTTON_PRESS_MASK |
gtk.gdk.BUTTON_RELEASE_MASK |
gtk.gdk.KEY_PRESS_MASK |
gtk.gdk.KEY_RELEASE_MASK )
self.set_events( gtk.gdk.ALL_EVENTS_MASK )
self.colormap = gtk.widget_get_default_colormap()
# Set default background color
if self.readonly:
color = self.colormap.alloc_color("#d8d8d8")
self.modify_bg(gtk.STATE_NORMAL, color)
# Customize your colors here
self.fgcolor = self.colormap.alloc_color(FGCOLOR)
self.rbgcolor = self.colormap.alloc_color(RBGCOLOR)
self.cbgcolor = self.colormap.alloc_color(CBGCOLOR)
self.kwcolor = self.colormap.alloc_color(KWCOLOR)
self.clcolor = self.colormap.alloc_color(CLCOLOR)
self.cocolor = self.colormap.alloc_color(COCOLOR)
self.stcolor = self.colormap.alloc_color(STCOLOR)
self.connect("expose-event", self.area_expose_cb)
self.connect("motion-notify-event", self.area_motion)
self.connect("button-press-event", self.area_button)
self.connect("button-release-event", self.area_button)
self.connect("key-press-event", self.area_key)
self.connect("key-release-event", self.area_key)
self.connect("focus", self.area_focus)
self.connect("configure_event", self.configure_event)
self.connect("size-request", self.size_request)
self.connect("size-allocate", self.size_alloc)
self.connect("scroll-event", self.scroll_event)
#self.connect("enter-notify-event", self.area_enter)
#self.connect("leave-notify-event", self.area_leave)
self.connect("focus-in-event", self.focus_in_cb)
self.connect("focus-out-event", self.focus_out_cb)
self.aaa = 0
def __init__(self, project, mainview, small=False):
"""
Creates a new instance of RecordingView.
Parameters:
project -- the currently active Project.
mainview -- the main Jokosher window (MainApp).
small -- set to True if we want small edit views (i.e. for the mixing view).
"""
gtk.Frame.__init__(self)
self.project = project
self.mainview = mainview
self.small = small
self.timelinebar = TimeLineBar.TimeLineBar(self.project, mainview)
self.errorMessageArea = None
self.restoreMessageArea = None
self.unsetNameMessageArea = None
## create darker workspace box
self.eventBox = gtk.EventBox()
self.eventBox.connect("button-press-event",
self.OnEmptySpaceDoubleClicked)
self.vbox = gtk.VBox()
self.add(self.vbox)
self.vbox.pack_start(self.timelinebar, False, False)
self.instrumentWindow = gtk.ScrolledWindow()
self.instrumentBox = gtk.VBox()
## pack the instrument box inside the eventbox as you cant modify the color of a gtk.Box
self.eventBox.add(self.instrumentBox)
self.instrumentWindow.add_with_viewport(self.eventBox)
self.instrumentWindow.set_policy(gtk.POLICY_NEVER,
gtk.POLICY_AUTOMATIC)
self.vbox.pack_start(self.instrumentWindow, True, True)
self.instrumentWindow.child.set_shadow_type(gtk.SHADOW_NONE)
self.views = []
self.header_size_group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
self.header_size_group.add_widget(self.timelinebar.GetHeaderWidget())
self.hb = gtk.HBox()
self.hb.set_spacing(6)
self.hb.set_border_width(6)
self.vbox.pack_end(self.hb, False, False)
self.vbox.pack_end(gtk.HSeparator(), False, False)
self.zoom_hb = gtk.HBox()
self.zoom_hb.set_spacing(6)
self.zoom_hb.set_border_width(0)
self.header_size_group.add_widget(self.zoom_hb)
self.scrollRange = gtk.Adjustment()
self.scrollBar = gtk.HScrollbar(self.scrollRange)
self.hb.pack_start(self.zoom_hb, False, False)
self.hb.pack_start(self.scrollBar, True, True)
self.lastzoom = 0
self.zoomSlider = gtk.HScale()
self.zoomSlider.set_size_request(70, -1)
self.zoomSlider.set_range(self.ZOOM_MIN_SCALE, self.ZOOM_MAX_SCALE)
self.zoomSlider.set_increments(0.2, 0.2)
self.zoomSlider.set_draw_value(False)
self.zoomSlider.set_value(self.project.viewScale)
self.zoomSlider.set_tooltip_text(
_("Zoom the timeline - Right-Click to reset to the default level"))
self.zoomSlider.connect("value-changed", self.OnZoom)
self.zoomSlider.connect("button-press-event", self.OnZoomReset)
self.inbutton = gtk.Button()
inimg = gtk.image_new_from_stock(gtk.STOCK_ZOOM_IN,
gtk.ICON_SIZE_BUTTON)
self.inbutton.set_image(inimg)
self.inbutton.set_relief(gtk.RELIEF_NONE)
self.inbutton.set_tooltip_text(_("Zoom in timeline"))
self.inbutton.connect("clicked", self.OnZoomIn)
self.outbutton = gtk.Button()
outimg = gtk.image_new_from_stock(gtk.STOCK_ZOOM_OUT,
gtk.ICON_SIZE_BUTTON)
self.outbutton.set_image(outimg)
self.outbutton.set_relief(gtk.RELIEF_NONE)
self.outbutton.set_tooltip_text(_("Zoom out timeline"))
self.outbutton.connect("clicked", self.OnZoomOut)
self.zoom_hb.pack_start(self.outbutton, False, False)
self.zoom_hb.pack_start(self.zoomSlider, False, False)
self.zoom_hb.pack_start(self.inbutton, False, False)
self.centreViewOnPosition = False
self.scrollRange.lower = 0
self.scrollRange.upper = 100
self.scrollRange.value = 0
self.scrollRange.step_increment = 1
self.scrollBar.connect("value-changed", self.OnScroll)
self.connect("expose-event", self.OnExpose)
self.connect("button_release_event", self.OnExpose)
self.connect("button_press_event", self.OnMouseDown)
#connect to the project signals
self.project.connect("gst-bus-error", self.OnProjectGstError)
self.project.connect("incremental-save", self.OnProjectIncSave)
self.project.connect("instrument::added", self.OnInstrumentAdded)
self.project.connect("instrument::reordered",
self.OnInstrumentReordered)
self.project.connect("instrument::removed", self.OnInstrumentRemoved)
self.project.connect("view-start", self.OnViewStartChanged)
self.vbox.drag_dest_set(gtk.DEST_DEFAULT_DROP, self.DRAG_TARGETS,
gtk.gdk.ACTION_COPY)
self.vbox.connect("drag_data_received", self.OnDragDataReceived)
self.vbox.connect("drag_motion", self.OnDragMotion)
#add the instruments that were loaded from the project file already
for instr in self.project.instruments:
self.OnInstrumentAdded(project, instr)
self.show_all()
self.show_all()
if self.small:
self.inbutton.hide()
self.outbutton.hide()
self.zoomSlider.hide()
if self.project.CanDoIncrementalRestore():
message = _("Would you like to restore the current project?")
details = _(
"A crash was detected and changes to your project were not saved.\nIf you would like, you can attempt to recover these lost changes."
)
msg_area = MessageArea.MessageArea()
msg_area.add_button(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)
msg_area.add_stock_button_with_text(_("_Restore Project"),
gtk.STOCK_APPLY,
gtk.RESPONSE_OK)
msg_area.set_text_and_icon(gtk.STOCK_DIALOG_QUESTION, message,
details)
msg_area.connect("response", self.OnRestoreMessageAreaResponse,
msg_area)
msg_area.connect("close", self.OnRestoreMessageAreaClose, msg_area)
self.vbox.pack_end(msg_area, False, False)
msg_area.show()
self.restoreMessageArea = msg_area
elif self.project.name_is_unset:
self.ShowUnsetProjectNameMessage()
def __init__(self,
modelCollection,
programSettings,
width=250,
console=None,
customFunctions=None):
# Call super class init function.
gtk.VBox.__init__(self)
# Internalise parameters.
self.modelCollection = modelCollection
self.console = console
self.customFunctions = customFunctions
# Reference to image.
# self.image = self.modelCollection.sliceImage
# Get parent width and set height according to projector aspect ratio.
aspect = float(programSettings['projectorSizeY'].value) / float(
programSettings['projectorSizeX'].value)
self.width = width #250
self.height = int(self.width * aspect)
# Create image view.
self.imageView = gtk.Image()
# Create black dummy image.
self.imageBlack = numpy.zeros((self.height, self.width, 3),
numpy.uint8)
# Create pixbuf from numpy.
self.pixbuf = gtk.gdk.pixbuf_new_from_array(self.imageBlack,
gtk.gdk.COLORSPACE_RGB, 8)
# Set image to viewer.
self.imageView.set_from_pixbuf(self.pixbuf)
self.pack_start(self.imageView, expand=True, fill=True)
self.imageView.show()
# Create slider.
self.slider = gtk.HScrollbar()
self.pack_start(self.slider, expand=True, fill=True)
self.slider.set_range(1, 100)
self.slider.set_value(1)
self.slider.set_round_digits(0)
self.slider.show()
# Connect event handler. We only want to update if the button was released.
self.slider.connect("value-changed", self.callbackScroll)
# self.slider.connect("button-release-event", self.callbackScroll)
# Create current slice label.
self.labelBox = gtk.HBox()
self.pack_start(self.labelBox, expand=True, fill=True)
self.labelBox.show()
# Create labels.
self.minLabel = gtk.Label('1')
self.labelBox.pack_start(self.minLabel, expand=False)
self.minLabel.show()
self.currentLabel = gtk.Label('1')
self.labelBox.pack_start(self.currentLabel, expand=True, fill=True)
self.currentLabel.show()
self.maxLabel = gtk.Label('1')
self.labelBox.pack_start(self.maxLabel, expand=False)
self.maxLabel.show()
def build_prop_dialog(self):
dlg = gtk.Dialog('Properties')
#dlg.set_size_request(400,200)
vbox = dlg.vbox
frame = gtk.Frame('Opacity')
frame.show()
frame.set_border_width(5)
vbox.pack_start(frame, False, False)
table = gtk.Table(2, 2)
table.set_homogeneous(False)
table.show()
table.set_col_spacings(3)
table.set_row_spacings(3)
table.set_border_width(3)
frame.add(table)
#EitanP - start
frame_size = gtk.Frame('Markers Size')
frame_size.show()
frame_size.set_border_width(5)
vbox.pack_start(frame_size, False, False)
table_size = gtk.Table(2, 2)
table_size.set_homogeneous(False)
table_size.show()
table_size.set_col_spacings(3)
table_size.set_row_spacings(3)
table_size.set_border_width(3)
frame_size.add(table_size)
#EitanP - end
label = gtk.Label('Plane')
label.show()
def set_plane_opacity(bar):
pwx, pwy, pwz = self.get_plane_widgets()
val = bar.get_value()
pwx.GetTexturePlaneProperty().SetOpacity(val)
pwx.GetPlaneProperty().SetOpacity(val)
pwy.GetTexturePlaneProperty().SetOpacity(val)
pwy.GetPlaneProperty().SetOpacity(val)
pwz.GetTexturePlaneProperty().SetOpacity(val)
pwz.GetPlaneProperty().SetOpacity(val)
self.owner.pwxyz.Render()
scrollbar = gtk.HScrollbar()
scrollbar.show()
scrollbar.set_range(0, 1)
scrollbar.set_value(1)
scrollbar.connect('value_changed', set_plane_opacity)
scrollbar.set_size_request(300, 20)
table.attach(label, 0, 1, 0, 1)
table.attach(scrollbar, 1, 2, 0, 1)
label = gtk.Label('Markers')
label.show()
def set_marker_opacity(bar):
val = bar.get_value()
for marker in EventHandler().get_markers_as_seq():
marker.GetProperty().SetOpacity(val)
self.owner.pwxyz.Render()
scrollbar = gtk.HScrollbar()
scrollbar.show()
scrollbar.set_range(0, 1)
scrollbar.set_value(1)
scrollbar.connect('value_changed', set_marker_opacity)
scrollbar.set_size_request(300, 20)
table.attach(label, 0, 1, 1, 2)
table.attach(scrollbar, 1, 2, 1, 2)
#EitanP - start
label = gtk.Label('Markers')
label.show()
def set_marker_size(bar):
val = bar.get_value()
for marker in EventHandler().get_markers_as_seq():
marker.set_size(val)
self.owner.pwxyz.Render()
self.owner.pwxyz.Render()
scrollbar_size = gtk.HScrollbar()
scrollbar_size.show()
scrollbar_size.set_range(0, 20)
scrollbar_size.set_value(1)
scrollbar_size.connect('value_changed', set_marker_size)
scrollbar_size.set_size_request(300, 20)
table_size.attach(scrollbar_size, 0, 1, 1, 2)
#EitanP - end
button = gtk.Button('Hide')
button.show()
button.set_use_stock(True)
button.set_label(gtk.STOCK_CANCEL)
def hide(button):
self.propDialog.hide()
return True
button.connect('clicked', hide)
vbox.pack_start(button, False, False)
dlg.hide()
self.propDialog = dlg
def __init__(self, tareas):
"""
days es el número de días totales que se pueden representar. Los que
actualmente se muestren depende del zoom aplicado.
tareas es el conjunto de datos *inicial* a ser mostrado. El valor en
cada momento (self.tareas) puede ser diferente en función de las
operaciones con el backend.
"""
self.ventana = gtk.Window()
self.ventana.set_size_request(800, 400)
self.ventana.connect("delete_event", lambda *a, **kw: gtk.main_quit())
self.ventana.connect("destroy", lambda *a, **kw: gtk.main_quit())
self.container = gtk.VBox()
self.grafica = gtk.HBox()
self.container.pack_start(self.grafica)
self.container.set_property("border-width", 5)
self.controls = gtk.VBox()
self.lower_controls = gtk.HBox()
self.lower_controls.set_property("homogeneous", True)
self.lower_controls.set_property("spacing", 10)
self.b_salir = gtk.Button(stock = gtk.STOCK_QUIT)
self.b_salir.connect("clicked", self.__salir)
self.lower_controls.add(self.b_salir)
# El valor más alto que se puede obtener es upper - page_size
self.zoom = gtk.Adjustment(62.0, 1.0, 365.0 + 31.0, 1.0, 31.0, 31.0)
self.zoom_level = 62
self.slider = gtk.HScale(self.zoom)
self.slider.set_digits(0)
self.slider.get_layout().set_font_description(
pango.FontDescription("monospace 8"))
for i in range(31, 365, 31):
try:
self.slider.add_mark(i, gtk.POS_TOP, None)
except AttributeError:
pass # Versión de pygtk sin add_mark
self.lower_controls.add(self.slider)
self.slider.connect("value-changed", self._update_zoom)
if not tareas:
days = 0
else:
days = (max(tareas, key = lambda t: t.fin).fin
- min(tareas, key = lambda t: t.ini).ini).days
self.scrollbar = gtk.HScrollbar()
self.adj_scroll = gtk.Adjustment(0, 0, days + 10, 1, 10, 10)
self.scrollbar.set_adjustment(self.adj_scroll)
self.controls.pack_start(self.scrollbar, expand = False)
self.first_day = 0
self.adj_scroll.connect("value-changed", self._update_first_day)
self.b_vista = gtk.ToggleButton("Ver por línea")
self.b_vista.connect("toggled", self._cambiar_vista)
self.lower_controls.pack_end(self.b_vista, expand = False)
self.controls.pack_start(self.lower_controls, expand = False)
self.container.pack_start(self.controls, expand = False)
self.ventana.add(self.container)
self.ventana.set_title("Vista por empleado")
self.vista_por_empleado = True
#tareas.sort(key = lambda t: t.fecha)
self.tareas = tareas
self.load_escena()
self.grafica.add(self.escena)
self.ventana.show_all()
win.connect("destroy", gtk.main_quit)
table = gtk.Table()
win.add(table)
row, col = 0, 0
drawing_area = gtk.DrawingArea()
# drawing_area.set_size_request(100, 100)
pack(drawing_area, row, col)
row += 1
vscroll = gtk.VScrollbar()
pack(vscroll, 0, 1)
hscroll = gtk.HScrollbar()
pack(hscroll, row, col)
row += 1
notebook = gtk.Notebook()
label = gtk.Label("Label")
notebook.append_page(label)
label = gtk.Label("Label")
notebook.append_page(label)
pack(notebook, row, col)
row += 1
button = gtk.Button("Button")
pack(button, row, col)
row += 1
if conf.fftw is None:
wait_for_info.wait()
wait_for_info.release()
da_width = conf.borderleft + conf.fftw + conf.histow + conf.histooffs
da_height = conf.drawingheight
# Put it into layout into table with horizontal scrolling.
layout = gtk.Layout(None, None)
layout.set_size_request(1024, da_height)
layout.set_size(da_width, da_height)
table = gtk.Table(2, 1, False)
table.attach(layout, 0, 1, 0, 1, gtk.FILL | gtk.EXPAND, gtk.FILL | gtk.EXPAND,
0, 0)
hScrollbar = gtk.HScrollbar(None)
table.attach(hScrollbar, 0, 1, 1, 2, gtk.FILL | gtk.SHRINK,
gtk.FILL | gtk.SHRINK, 0, 0)
hAdjust = layout.get_hadjustment()
hScrollbar.set_adjustment(hAdjust)
drawing_area = gtk.DrawingArea()
drawing_area.set_size_request(da_width, da_height)
drawing_area.connect("realize", steal_sdl_window)
drawing_area.connect("expose-event", da_expose_event)
drawing_area.show()
drawing_area.connect("button_press_event", da_press)
drawing_area.connect("button_release_event", da_press)
drawing_area.connect("scroll-event", da_scroll)
def update_segments_frame(self):
'Update the segment props with the latest segments'
vbox = self.vboxSegPropsFrame
widgets = vbox.get_children()
for w in widgets:
vbox.remove(w)
names = self.paramd.keys()
if not len(names):
label = gtk.Label('No segments')
label.show()
vbox.pack_start(label)
return
names.sort()
numrows = len(names) + 1
numcols = 2
table = gtk.Table(numrows, numcols)
table.set_col_spacings(3)
table.show()
vbox.pack_start(table, True, True)
delete = gtk.Label('Hide')
delete.show()
opacity = gtk.Label('Opacity')
opacity.show()
table.attach(delete, 0, 1, 0, 1, xoptions=gtk.FILL, yoptions=0)
table.attach(opacity,
1,
2,
0,
1,
xoptions=gtk.EXPAND | gtk.FILL,
yoptions=0)
deleteButtons = {}
opacityBars = {}
class OpacityCallback:
def __init__(self, sr, name, paramd):
"""
sr is the surf renderer instance
name is the name of the surface
paramd is the dict mapping names to objects
You don't want to pass the object itself because it is
bound at init time but you to be able to dynamically
update
"""
self.name = name
self.sr = sr
self.paramd = paramd
def __call__(self, bar):
val = bar.get_value()
self.paramd[self.name].isoActor.GetProperty().SetOpacity(val)
class HideCallback:
def __init__(self, sr, name, paramd):
"""
sr is the surf renderer instance
name is the name of the surface
paramd is the dict mapping names to objects
You don't want to pass the object itself because it is
bound at init time but you to be able to dynamically
update
"""
self.sr = sr
self.name = name
self.paramd = paramd
self.removed = False
def __call__(self, button):
if button.get_active():
self.paramd[self.name].isoActor.VisibilityOff()
else:
self.paramd[self.name].isoActor.VisibilityOn()
self.sr.Render()
rownum = 1
for name in names:
hideCallback = HideCallback(self.sr, name, self.paramd)
opacityCallback = OpacityCallback(self.sr, name, self.paramd)
b = gtk.CheckButton(name)
b.show()
b.set_active(False)
b.connect('toggled', hideCallback)
table.attach(b,
0,
1,
rownum,
rownum + 1,
xoptions=False,
yoptions=False)
deleteButtons[name] = b
scrollbar = gtk.HScrollbar()
scrollbar.show()
scrollbar.set_size_request(*self.SCROLLBARSIZE)
table.attach(scrollbar,
1,
2,
rownum,
rownum + 1,
xoptions=True,
yoptions=False)
scrollbar.set_range(0, 1)
scrollbar.set_increments(.05, .2)
scrollbar.set_value(1.0)
scrollbar.connect('value_changed', opacityCallback)
rownum += 1
def __init__(self, fullscreen=False, show_library=False, open_path=None,
open_page=1):
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
# ----------------------------------------------------------------
# Attributes
# ----------------------------------------------------------------
self.is_fullscreen = False
self.is_double_page = False
self.is_manga_mode = False
self.is_virtual_double_page = False # I.e. a wide image is displayed
self.zoom_mode = preferences.ZOOM_MODE_BEST
self.width = None
self.height = None
self._manual_zoom = 100 # In percent of original image size
self._waiting_for_redraw = False
self.file_handler = filehandler.FileHandler(self)
self.thumbnailsidebar = thumbbar.ThumbnailSidebar(self)
self.statusbar = status.Statusbar()
self.slideshow = slideshow.Slideshow(self)
self.cursor_handler = cursor.CursorHandler(self)
self.enhancer = enhance.ImageEnhancer(self)
self.glass = lens.MagnifyingGlass(self)
self.ui_manager = ui.MainUI(self)
self.menubar = self.ui_manager.get_widget('/Menu')
self.toolbar = self.ui_manager.get_widget('/Tool')
self.popup = self.ui_manager.get_widget('/Popup')
self.actiongroup = self.ui_manager.get_action_groups()[0]
self.left_image = gtk.Image()
self.right_image = gtk.Image()
self._image_box = gtk.HBox(False, 2)
self._main_layout = gtk.Layout()
self._event_handler = event.EventHandler(self)
self._vadjust = self._main_layout.get_vadjustment()
self._hadjust = self._main_layout.get_hadjustment()
self._vscroll = gtk.VScrollbar(self._vadjust)
self._hscroll = gtk.HScrollbar(self._hadjust)
# ----------------------------------------------------------------
# Setup
# ----------------------------------------------------------------
self.set_title('Comix')
self.set_size_request(300, 300) # Avoid making the window *too* small
self.resize(prefs['window width'], prefs['window height'])
# This is a hack to get the focus away from the toolbar so that
# we don't activate it with space or some other key (alternative?)
self.toolbar.set_focus_child(
self.ui_manager.get_widget('/Tool/expander'))
self.toolbar.set_style(gtk.TOOLBAR_ICONS)
self._image_box.add(self.left_image)
self._image_box.add(self.right_image)
self._image_box.show_all()
self._main_layout.put(self._image_box, 0, 0)
self.set_bg_colour(prefs['bg colour'])
self._vadjust.step_increment = 15
self._vadjust.page_increment = 1
self._hadjust.step_increment = 15
self._hadjust.page_increment = 1
table = gtk.Table(2, 2, False)
table.attach(self.thumbnailsidebar, 0, 1, 2, 5, gtk.FILL,
gtk.FILL|gtk.EXPAND, 0, 0)
table.attach(self._main_layout, 1, 2, 2, 3, gtk.FILL|gtk.EXPAND,
gtk.FILL|gtk.EXPAND, 0, 0)
table.attach(self._vscroll, 2, 3, 2, 3, gtk.FILL|gtk.SHRINK,
gtk.FILL|gtk.SHRINK, 0, 0)
table.attach(self._hscroll, 1, 2, 4, 5, gtk.FILL|gtk.SHRINK,
gtk.FILL, 0, 0)
table.attach(self.menubar, 0, 3, 0, 1, gtk.FILL|gtk.SHRINK,
gtk.FILL, 0, 0)
table.attach(self.toolbar, 0, 3, 1, 2, gtk.FILL|gtk.SHRINK,
gtk.FILL, 0, 0)
table.attach(self.statusbar, 0, 3, 5, 6, gtk.FILL|gtk.SHRINK,
gtk.FILL, 0, 0)
if prefs['default double page']:
self.actiongroup.get_action('double_page').activate()
if prefs['default fullscreen'] or fullscreen:
self.actiongroup.get_action('fullscreen').activate()
if prefs['default manga mode']:
self.actiongroup.get_action('manga_mode').activate()
if prefs['default zoom mode'] == preferences.ZOOM_MODE_BEST:
self.actiongroup.get_action('best_fit_mode').activate()
elif prefs['default zoom mode'] == preferences.ZOOM_MODE_WIDTH:
self.actiongroup.get_action('fit_width_mode').activate()
elif prefs['default zoom mode'] == preferences.ZOOM_MODE_HEIGHT:
self.actiongroup.get_action('fit_height_mode').activate()
elif prefs['default zoom mode'] == preferences.ZOOM_MODE_MANUAL:
# This little ugly hack is to get the activate call on
# 'fit_manual_mode' to actually create an event (and callback).
# Since manual mode is the default selected radio button action
# it won't send an event if we activate it when it is already
# the selected one.
self.actiongroup.get_action('best_fit_mode').activate()
self.actiongroup.get_action('fit_manual_mode').activate()
if prefs['show toolbar']:
prefs['show toolbar'] = False
self.actiongroup.get_action('toolbar').activate()
if prefs['show menubar']:
prefs['show menubar'] = False
self.actiongroup.get_action('menubar').activate()
if prefs['show statusbar']:
prefs['show statusbar'] = False
self.actiongroup.get_action('statusbar').activate()
if prefs['show scrollbar']:
prefs['show scrollbar'] = False
self.actiongroup.get_action('scrollbar').activate()
if prefs['show thumbnails']:
prefs['show thumbnails'] = False
self.actiongroup.get_action('thumbnails').activate()
if prefs['hide all']:
prefs['hide all'] = False
self.actiongroup.get_action('hide all').activate()
if prefs['keep transformation']:
prefs['keep transformation'] = False
self.actiongroup.get_action('keep_transformation').activate()
else:
prefs['rotation'] = 0
prefs['vertical flip'] = False
prefs['horizontal flip'] = False
self.add(table)
table.show()
self._main_layout.show()
self._display_active_widgets()
self._main_layout.set_events(gtk.gdk.BUTTON1_MOTION_MASK |
gtk.gdk.BUTTON2_MOTION_MASK |
gtk.gdk.BUTTON_PRESS_MASK |
gtk.gdk.BUTTON_RELEASE_MASK |
gtk.gdk.POINTER_MOTION_MASK)
self._main_layout.drag_dest_set(gtk.DEST_DEFAULT_ALL,
[('text/uri-list', 0, 0)],
gtk.gdk.ACTION_COPY |
gtk.gdk.ACTION_MOVE)
self.connect('delete_event', self.terminate_program)
self.connect('key_press_event', self._event_handler.key_press_event)
self.connect('configure_event', self._event_handler.resize_event)
self._main_layout.connect('button_release_event',
self._event_handler.mouse_release_event)
self._main_layout.connect('scroll_event',
self._event_handler.scroll_wheel_event)
self._main_layout.connect('button_press_event',
self._event_handler.mouse_press_event)
self._main_layout.connect('motion_notify_event',
self._event_handler.mouse_move_event)
self._main_layout.connect('drag_data_received',
self._event_handler.drag_n_drop_event)
self.ui_manager.set_sensitivities()
self.show()
if open_path is not None:
self.file_handler.open_file(open_path, open_page)
if show_library:
self.actiongroup.get_action('library').activate()
def __init__(self,
fullscreen=False,
is_slideshow=slideshow,
show_library=False,
manga_mode=False,
double_page=False,
zoom_mode=None,
open_path=None,
open_page=1):
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
# ----------------------------------------------------------------
# Attributes
# ----------------------------------------------------------------
self.is_in_focus = True
self.is_fullscreen = False
self.is_double_page = False
self.is_manga_mode = False
self.is_virtual_double_page = False # I.e. a wide image is displayed
self.width = None
self.height = None
self.was_out_of_focus = False
#: Used to remember if changing to fullscreen enabled 'Hide all'
self.hide_all_forced = False
self._manual_zoom = 100 # In percent of original image size
self._waiting_for_redraw = False
self._image_box = gtk.HBox(False, 2)
self._main_layout = gtk.Layout()
self._event_handler = event.EventHandler(self)
self._vadjust = self._main_layout.get_vadjustment()
self._hadjust = self._main_layout.get_hadjustment()
self._vscroll = gtk.VScrollbar(self._vadjust)
self._hscroll = gtk.HScrollbar(self._hadjust)
self.filehandler = file_handler.FileHandler(self)
self.imagehandler = image_handler.ImageHandler(self)
self.imagehandler.page_available += self._page_available
self.thumbnailsidebar = thumbbar.ThumbnailSidebar(self)
self.statusbar = status.Statusbar()
self.clipboard = clipboard.Clipboard(self)
self.slideshow = slideshow.Slideshow(self)
self.cursor_handler = cursor_handler.CursorHandler(self)
self.enhancer = enhance_backend.ImageEnhancer(self)
self.lens = lens.MagnifyingLens(self)
self.osd = osd.OnScreenDisplay(self)
self.uimanager = ui.MainUI(self)
self.menubar = self.uimanager.get_widget('/Menu')
self.toolbar = self.uimanager.get_widget('/Tool')
self.popup = self.uimanager.get_widget('/Popup')
self.actiongroup = self.uimanager.get_action_groups()[0]
self.left_image = gtk.Image()
self.right_image = gtk.Image()
# ----------------------------------------------------------------
# Setup
# ----------------------------------------------------------------
self.set_title(constants.APPNAME)
self.set_size_request(300, 300) # Avoid making the window *too* small
self.resize(prefs['window width'], prefs['window height'])
# Hook up any additional key events not handled by UI accelerators
self._event_handler.register_key_events()
# This is a hack to get the focus away from the toolbar so that
# we don't activate it with space or some other key (alternative?)
self.toolbar.set_focus_child(
self.uimanager.get_widget('/Tool/expander'))
self.toolbar.set_style(gtk.TOOLBAR_ICONS)
self.toolbar.set_icon_size(gtk.ICON_SIZE_LARGE_TOOLBAR)
self._image_box.add(self.left_image)
self._image_box.add(self.right_image)
self._image_box.show_all()
self._main_layout.put(self._image_box, 0, 0)
self.set_bg_colour(prefs['bg colour'])
self._vadjust.step_increment = 15
self._vadjust.page_increment = 1
self._hadjust.step_increment = 15
self._hadjust.page_increment = 1
table = gtk.Table(2, 2, False)
table.attach(self.thumbnailsidebar, 0, 1, 2, 5, gtk.FILL,
gtk.FILL | gtk.EXPAND, 0, 0)
table.attach(self._main_layout, 1, 2, 2, 3, gtk.FILL | gtk.EXPAND,
gtk.FILL | gtk.EXPAND, 0, 0)
table.attach(self._vscroll, 2, 3, 2, 3, gtk.FILL | gtk.SHRINK,
gtk.FILL | gtk.SHRINK, 0, 0)
table.attach(self._hscroll, 1, 2, 4, 5, gtk.FILL | gtk.SHRINK,
gtk.FILL, 0, 0)
table.attach(self.menubar, 0, 3, 0, 1, gtk.FILL | gtk.SHRINK, gtk.FILL,
0, 0)
table.attach(self.toolbar, 0, 3, 1, 2, gtk.FILL | gtk.SHRINK, gtk.FILL,
0, 0)
table.attach(self.statusbar, 0, 3, 5, 6, gtk.FILL | gtk.SHRINK,
gtk.FILL, 0, 0)
if prefs['default double page'] or double_page:
self.actiongroup.get_action('double_page').activate()
if prefs['default manga mode'] or manga_mode:
self.actiongroup.get_action('manga_mode').activate()
# Determine zoom mode. If zoom_mode is passed, it overrides
# the zoom mode preference.
zoom_actions = {
constants.ZOOM_MODE_BEST: 'best_fit_mode',
constants.ZOOM_MODE_WIDTH: 'fit_width_mode',
constants.ZOOM_MODE_HEIGHT: 'fit_height_mode',
constants.ZOOM_MODE_MANUAL: 'fit_manual_mode'
}
if zoom_mode is not None:
zoom_action = zoom_actions[zoom_mode]
else:
zoom_action = zoom_actions[prefs['zoom mode']]
if zoom_action == 'fit_manual_mode':
# This little ugly hack is to get the activate call on
# 'fit_manual_mode' to actually create an event (and callback).
# Since manual mode is the default selected radio button action
# it won't send an event if we activate it when it is already
# the selected one.
self.actiongroup.get_action('best_fit_mode').activate()
self.actiongroup.get_action(zoom_action).activate()
if prefs['stretch']:
self.actiongroup.get_action('stretch').activate()
if prefs['invert smart scroll']:
self.actiongroup.get_action('invert_scroll').activate()
if prefs['show toolbar']:
prefs['show toolbar'] = False
self.actiongroup.get_action('toolbar').activate()
if prefs['show menubar']:
prefs['show menubar'] = False
self.actiongroup.get_action('menubar').activate()
if prefs['show statusbar']:
prefs['show statusbar'] = False
self.actiongroup.get_action('statusbar').activate()
if prefs['show scrollbar']:
prefs['show scrollbar'] = False
self.actiongroup.get_action('scrollbar').activate()
if prefs['show thumbnails']:
prefs['show thumbnails'] = False
self.actiongroup.get_action('thumbnails').activate()
if prefs['hide all']:
prefs['hide all'] = False
self.actiongroup.get_action('hide all').activate()
if prefs['keep transformation']:
prefs['keep transformation'] = False
self.actiongroup.get_action('keep_transformation').activate()
else:
prefs['rotation'] = 0
prefs['vertical flip'] = False
prefs['horizontal flip'] = False
self.add(table)
table.show()
self._main_layout.show()
self._display_active_widgets()
self._main_layout.set_events(gtk.gdk.BUTTON1_MOTION_MASK
| gtk.gdk.BUTTON2_MOTION_MASK
| gtk.gdk.BUTTON_PRESS_MASK
| gtk.gdk.BUTTON_RELEASE_MASK
| gtk.gdk.POINTER_MOTION_MASK)
self._main_layout.drag_dest_set(
gtk.DEST_DEFAULT_ALL, [('text/uri-list', 0, 0)],
gtk.gdk.ACTION_COPY | gtk.gdk.ACTION_MOVE)
self.connect('focus-in-event', self.gained_focus)
self.connect('focus-out-event', self.lost_focus)
self.connect('delete_event', self.close_program)
self.connect('key_press_event', self._event_handler.key_press_event)
self.connect('key_release_event',
self._event_handler.key_release_event)
self.connect('configure_event', self._event_handler.resize_event)
self._main_layout.connect('button_release_event',
self._event_handler.mouse_release_event)
self._main_layout.connect('scroll_event',
self._event_handler.scroll_wheel_event)
self._main_layout.connect('button_press_event',
self._event_handler.mouse_press_event)
self._main_layout.connect('motion_notify_event',
self._event_handler.mouse_move_event)
self._main_layout.connect('drag_data_received',
self._event_handler.drag_n_drop_event)
self.uimanager.set_sensitivities()
self.show()
# If MComix is set to start in fullscreen mode, it
# cannot switch to windowed mode on Win32 unless this
# condition is set to trigger after normal show().
if prefs['default fullscreen'] or fullscreen:
self.actiongroup.get_action('fullscreen').activate()
if prefs['previous quit was quit and save']:
fileinfo = self.filehandler.read_fileinfo_file()
if fileinfo != None:
open_path = fileinfo[0]
open_page = fileinfo[1] + 1
prefs['previous quit was quit and save'] = False
if open_path is not None:
self.filehandler.open_file(open_path, open_page)
if is_slideshow:
self.actiongroup.get_action('slideshow').activate()
if show_library:
self.actiongroup.get_action('library').activate()
def __init__(self, buff, appwin):
# Save params
global gl_appwin
gl_appwin = appwin
self.appwin = appwin;
# Gather globals
self.keyh = pedconfig.pedconfig.keyh
# Init vars
self.xpos = 0; self.ypos = 0
self.changed = False; self.colsel = False
self.xsel = -1; self.ysel = -1
self.xsel2 = -1; self.ysel2 = -1
self.caret = []; self.caret.append(0); self.caret.append(0)
self.maxlinelen = 0
self.focus = False
# Init configurables
self.scgap = SCROLLGAP
self.pgup = PAGEUP
self.tabstop = TABSTOP
# Process buffer into list
self.text = buff
for aa in self.text:
xlen = len(aa)
if self.maxlinelen < xlen:
self.maxlinelen = xlen
# Parent widget
gtk.DrawingArea.__init__(self)
self.set_flags(gtk.CAN_FOCUS | gtk.SENSITIVE)
self.pangolayout = self.create_pango_layout("a")
# Set default background color
'''colormap = gtk.widget_get_default_colormap()
color = colormap.alloc_color("#d0d0d0")
self.modify_bg(gtk.STATE_NORMAL, color)'''
# Our font
fd = pango.FontDescription()
fd.set_size(14*1024); fd.set_family("mono")
self.pangolayout.set_font_description(fd)
# Get Pango steps
self.cxx, self.cyy = self.pangolayout.get_pixel_size()
ts = self.pangolayout.get_tabs()
if ts == None: self.tabstop = TABSTOP
else: al, self.tabstop = ts.get_tab(0)
#print "tabstop", self.tabstop
# Set up scroll bars
sm = len(self.text) + self.get_height() / self.cyy + 10
self.hadj = gtk.Adjustment(0, 0, 100, 1, 15, 25);
self.vadj = gtk.Adjustment(0, 0, sm, 1, 15, 25);
self.vscroll = gtk.VScrollbar(self.vadj)
self.hscroll = gtk.HScrollbar(self.hadj)
# We connect scrollers after construction
self.hadj.connect("value-changed", self.hscroll_cb)
self.vadj.connect("value-changed", self.vscroll_cb)
#self.www = gtk.gdk.screen_width();
#self.hhh = gtk.gdk.screen_height();
# Start up with initial size
#self.set_size_request(3*self.www/4, self.hhh/5)
self.set_events( gtk.gdk.POINTER_MOTION_MASK |
gtk.gdk.POINTER_MOTION_HINT_MASK |
gtk.gdk.BUTTON_PRESS_MASK |
gtk.gdk.BUTTON_RELEASE_MASK |
gtk.gdk.KEY_PRESS_MASK |
gtk.gdk.KEY_RELEASE_MASK )
self.set_events( gtk.gdk.ALL_EVENTS_MASK )
colormap = gtk.widget_get_default_colormap()
self.fgcolor = colormap.alloc_color("#000000")
self.bgcolor = colormap.alloc_color("#4488ff")
self.kwcolor = colormap.alloc_color("#44aaff")
self.clcolor = colormap.alloc_color("#44aa44")
self.cocolor = colormap.alloc_color("#4444ff")
self.stcolor = colormap.alloc_color("#ff44ff")
self.connect("expose-event", self.area_expose_cb)
self.connect("motion-notify-event", self.area_motion)
self.connect("button-press-event", self.area_button)
self.connect("button-release-event", self.area_button)
self.connect("key-press-event", self.area_key)
self.connect("key-release-event", self.area_key)
self.connect("focus", self.area_focus)
self.connect("configure_event", self.configure_event)
self.connect("size-request", self.size_request)
self.connect("size-allocate", self.size_alloc)
self.connect("scroll-event", self.scroll_event)
#self.connect("enter-notify-event", self.area_enter)
#self.connect("leave-notify-event", self.area_leave)
self.connect("focus-in-event", self.focus_in_cb)
self.connect("focus-out-event", self.focus_out_cb)
def __init__(self):
self.directoriodeiconos = activity.get_bundle_path() + "/Iconos/"
self.gris = gtk.gdk.Color(50000, 50000, 50000, 1)
self.rosado = gtk.gdk.Color(65000, 13000, 25000, 1)
gtk.HBox.__init__(self, False, 5)
self.ajuste = gtk.Adjustment(0, 0, 100, 1, 1)
self.barradeprogreso = gtk.HScrollbar(self.ajuste)
self.barradeprogreso.modify_bg(gtk.STATE_NORMAL, self.rosado)
#self.barradeprogreso.connect("value-changed", self.srollmove)
self.etiqueta_progreso = gtk.Label("¡¡¡ CeibalRadio !!!")
caja_progreso = gtk.VBox()
caja_progreso.pack_start(self.barradeprogreso, True, True, 5)
caja_progreso.pack_start(self.etiqueta_progreso, True, True, 0)
self.pack_start(caja_progreso, True, True, 5)
caja_de_botones = gtk.HBox(False, 0)
# ****** BOTON_ATRAS
self.imagenatras = gtk.Image()
self.imagenatras.set_from_file(self.directoriodeiconos + "atras.png")
self.botonatras = gtk.Button()
self.botonatras.modify_bg(gtk.STATE_NORMAL, self.gris)
self.botonatras.add(self.imagenatras)
#self.botonatras.connect("clicked",self.clickenatras)
caja_de_botones.pack_start(self.botonatras, False, False, 5)
# ****** BOTON PLAY
self.imagenplay = gtk.Image()
self.imagenplay.set_from_file(self.directoriodeiconos + "play.png")
self.botonplay = gtk.Button()
self.botonplay.modify_bg(gtk.STATE_NORMAL, self.gris)
self.botonplay.add(self.imagenplay)
#self.botonplay.connect("clicked",self.clickenplay_pausa)
caja_de_botones.pack_start(self.botonplay, False, False, 5)
# ****** BOTON SIGUIENTE
self.imagensiguiente = gtk.Image()
self.imagensiguiente.set_from_file(self.directoriodeiconos +
"siguiente.png")
self.botonsiguiente = gtk.Button()
self.botonsiguiente.modify_bg(gtk.STATE_NORMAL, self.gris)
self.botonsiguiente.add(self.imagensiguiente)
#self.botonsiguiente.connect("clicked",self.clickensiguiente)
caja_de_botones.pack_start(self.botonsiguiente, False, False, 5)
# ****** BOTON STOP
self.imagenstop = gtk.Image()
self.imagenstop.set_from_file(self.directoriodeiconos + "stop.png")
self.botonstop = gtk.Button()
self.botonstop.modify_bg(gtk.STATE_NORMAL, self.gris)
self.botonstop.add(self.imagenstop)
#self.botonstop.connect("clicked",self.clickenstop)
caja_de_botones.pack_start(self.botonstop, False, False, 5)
# ****** BOTON ABRIR DIRECTORIO
self.imagenabrir = gtk.Image()
self.imagenabrir.set_from_file(self.directoriodeiconos + "abrir.png")
self.botonabrir = gtk.Button()
self.botonabrir.modify_bg(gtk.STATE_NORMAL, self.gris)
self.botonabrir.add(self.imagenabrir)
#self.botonabrir.connect("clicked",self.clickenabrir)
caja_de_botones.pack_start(self.botonabrir, False, False, 5)
self.etiqueta_hora = gtk.Label("Hora")
caja_de_botones_y_hora = gtk.VBox()
caja_de_botones_y_hora.pack_start(caja_de_botones, False, False, 5)
caja_de_botones_y_hora.pack_start(self.etiqueta_hora, False, False, 5)
self.pack_start(caja_de_botones_y_hora, False, False, 5)
self.show_all()
def _createUI(self):
self.leftSizeGroup = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
self.props.row_spacing = 2
self.props.column_spacing = 2
self.hadj = gtk.Adjustment()
self.vadj = gtk.Adjustment()
# zooming slider's "zoom fit" button
zoom_controls_hbox = gtk.HBox()
zoom_best_fit_button = gtk.Button(_("Zoom"))
zoom_best_fit_button.set_relief(gtk.RELIEF_NONE)
zoom_best_fit_button.set_tooltip_text(ZOOM_FIT)
zoom_best_fit_button.set_image(
gtk.image_new_from_stock(gtk.STOCK_ZOOM_FIT, gtk.ICON_SIZE_BUTTON))
zoom_best_fit_button.connect("clicked", self._zoomFitCb)
zoom_controls_hbox.pack_start(zoom_best_fit_button)
# zooming slider
self._zoomAdjustment = gtk.Adjustment()
self._zoomAdjustment.set_value(Zoomable.getCurrentZoomLevel())
self._zoomAdjustment.connect("value-changed",
self._zoomAdjustmentChangedCb)
self._zoomAdjustment.props.lower = 0
self._zoomAdjustment.props.upper = Zoomable.zoom_steps
zoomslider = gtk.HScale(self._zoomAdjustment)
zoomslider.props.draw_value = False
zoomslider.set_tooltip_text(_("Zoom Timeline"))
zoomslider.connect("scroll-event", self._zoomSliderScrollCb)
zoomslider.set_size_request(100,
0) # At least 100px wide for precision
zoom_controls_hbox.pack_start(zoomslider)
self.attach(zoom_controls_hbox,
0,
1,
0,
1,
yoptions=0,
xoptions=gtk.FILL)
# controls for tracks and layers
self._controls = TimelineControls()
controlwindow = gtk.Viewport(None, self.vadj)
controlwindow.add(self._controls)
controlwindow.set_size_request(-1, 1)
controlwindow.set_shadow_type(gtk.SHADOW_OUT)
self.attach(controlwindow, 0, 1, 1, 2, xoptions=gtk.FILL)
# timeline ruler
self.ruler = ruler.ScaleRuler(self.app, self.hadj)
self.ruler.set_size_request(0, 25)
#self.ruler.set_border_width(2)
self.ruler.connect("key-press-event", self._keyPressEventCb)
self.ruler.connect("size-allocate", self._rulerSizeAllocateCb)
rulerframe = gtk.Frame()
rulerframe.set_shadow_type(gtk.SHADOW_OUT)
rulerframe.add(self.ruler)
self.attach(rulerframe, 1, 2, 0, 1, yoptions=0)
# proportional timeline
self._canvas = TimelineCanvas(self.app)
self._root_item = self._canvas.get_root_item()
self.attach(self._canvas, 1, 2, 1, 2)
self.vadj.connect("changed", self._unsureVadjHeightCb)
# scrollbar
self._hscrollbar = gtk.HScrollbar(self.hadj)
self._vscrollbar = gtk.VScrollbar(self.vadj)
self.attach(self._hscrollbar, 1, 2, 2, 3, yoptions=0)
self.attach(self._vscrollbar, 2, 3, 1, 2, xoptions=0)
self.hadj.connect("value-changed", self._updateScrollPosition)
self.vadj.connect("value-changed", self._updateScrollPosition)
# error infostub
self.infostub = InfoStub()
self.attach(self.infostub, 1, 2, 4, 5, yoptions=0)
self.show_all()
self.infostub.hide()
# toolbar actions
actions = (
("ZoomIn", gtk.STOCK_ZOOM_IN, None, "<Control>plus", ZOOM_IN,
self._zoomInCb),
("ZoomOut", gtk.STOCK_ZOOM_OUT, None, "<Control>minus", ZOOM_OUT,
self._zoomOutCb),
("ZoomFit", gtk.STOCK_ZOOM_FIT, None, None, ZOOM_FIT,
self._zoomFitCb),
# actions for adding additional accelerators
("ControlEqualAccel", gtk.STOCK_ZOOM_IN, None, "<Control>equal",
ZOOM_IN, self._zoomInCb),
("ControlKPAddAccel", gtk.STOCK_ZOOM_IN, None, "<Control>KP_Add",
ZOOM_IN, self._zoomInCb),
("ControlKPSubtractAccel", gtk.STOCK_ZOOM_OUT, None,
"<Control>KP_Subtract", ZOOM_OUT, self._zoomOutCb),
)
selection_actions = (
("DeleteObj", gtk.STOCK_DELETE, None, "Delete", DELETE,
self.deleteSelected),
("UnlinkObj", "pitivi-unlink", None, "<Shift><Control>L", UNLINK,
self.unlinkSelected),
("LinkObj", "pitivi-link", None, "<Control>L", LINK,
self.linkSelected),
("UngroupObj", "pitivi-ungroup", None, "<Shift><Control>G",
UNGROUP, self.ungroupSelected),
("GroupObj", "pitivi-group", None, "<Control>G", GROUP,
self.groupSelected),
)
self.playhead_actions = (
("Split", "pitivi-split", _("Split"), "S", SPLIT, self.split),
("Keyframe", "pitivi-keyframe", _("Add a Keyframe"), "K", KEYFRAME,
self.keyframe),
("Prevframe", "pitivi-prevframe", _("_Previous Keyframe"), "E",
PREVFRAME, self.prevframe),
("Nextframe", "pitivi-nextframe", _("_Next Keyframe"), "R",
NEXTFRAME, self.nextframe),
)
actiongroup = gtk.ActionGroup("timelinepermanent")
actiongroup.add_actions(actions)
self.ui_manager.insert_action_group(actiongroup, 0)
actiongroup = gtk.ActionGroup("timelineselection")
actiongroup.add_actions(selection_actions)
actiongroup.add_actions(self.playhead_actions)
self.link_action = actiongroup.get_action("LinkObj")
self.unlink_action = actiongroup.get_action("UnlinkObj")
self.group_action = actiongroup.get_action("GroupObj")
self.ungroup_action = actiongroup.get_action("UngroupObj")
self.delete_action = actiongroup.get_action("DeleteObj")
self.split_action = actiongroup.get_action("Split")
self.keyframe_action = actiongroup.get_action("Keyframe")
self.prevframe_action = actiongroup.get_action("Prevframe")
self.nextframe_action = actiongroup.get_action("Nextframe")
self.ui_manager.insert_action_group(actiongroup, -1)
self.ui_manager.add_ui_from_string(ui)
# drag and drop
self.drag_dest_set(gtk.DEST_DEFAULT_MOTION,
[dnd.FILESOURCE_TUPLE, dnd.EFFECT_TUPLE],
gtk.gdk.ACTION_COPY)
self.connect("drag-data-received", self._dragDataReceivedCb)
self.connect("drag-leave", self._dragLeaveCb)
self.connect("drag-drop", self._dragDropCb)
self.connect("drag-motion", self._dragMotionCb)
self._canvas.connect("key-press-event", self._keyPressEventCb)
self._canvas.connect("scroll-event", self._scrollEventCb)
