def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.y1 = y1
self.y2 = y2
self.y3 = y3
self.x_max = x_max
self.x_min = x_min
self.x_scale = x_scale
self.y_max = y_max
self.y_min = y_min
self.y_scale = y_scale
if have_toolbox:
self.toolbar_box = ToolbarBox()
self.activity_button = ActivityToolbarButton(self)
self.activity_button.page.share.hide()
self.toolbar_box.toolbar.insert(self.activity_button, 0)
self.activity_button.show()
self.graph_item = ToolbarButton()
self.graph_item.props.icon_name = 'graph'
else:
self.toolbox = activity.ActivityToolbox(self)
activity_toolbar = self.toolbox.get_activity_toolbar()
activity_toolbar.share.props.visible = False
self.graph_toolbar = gtk.Toolbar()
if have_toolbox:
self.graph_item.props.page = self.graph_toolbar
else:
self.toolbox.add_toolbar(_('Graph'), self.graph_toolbar)
self.plot_item = ToolButton('gtk-refresh')
self.plot_item.props.tooltip = _("Plot")
self.plot_item.connect("clicked", self.plot)
self.plot_item.show()
self.graph_toolbar.insert(self.plot_item, 0)
self.evaluate_item = ToolButton('evaluate')
self.evaluate_item.props.tooltip = _('Evaluate')
self.evaluate_item.connect("clicked", self.evaluate)
self.evaluate_item.show()
self.graph_toolbar.insert(self.evaluate_item, -1)
separator = gtk.SeparatorToolItem()
separator.show()
self.graph_toolbar.insert(separator, -1)
self.zoom_in_item = ToolButton('zoom-in')
self.zoom_in_item.props.tooltip = _('Zoom In')
self.zoom_in_item.connect("clicked", self.zoom_in)
self.zoom_in_item.show()
self.graph_toolbar.insert(self.zoom_in_item, -1)
self.zoom_out_item = ToolButton('zoom-out')
self.zoom_out_item.props.tooltip = _('Zoom Out')
self.zoom_out_item.connect("clicked", self.zoom_out)
self.zoom_out_item.show()
self.graph_toolbar.insert(self.zoom_out_item, -1)
self.zoom_reset_item = ToolButton('zoom-original')
self.zoom_reset_item.props.tooltip = _('Zoom Reset')
self.zoom_reset_item.connect("clicked", self.zoom_reset)
self.zoom_reset_item.show()
self.graph_toolbar.insert(self.zoom_reset_item, -1)
separator = gtk.SeparatorToolItem()
separator.show()
self.graph_toolbar.insert(separator, -1)
self.connect_points_item = ToggleToolButton('connect-points')
self.connect_points_item.set_tooltip(_("Connect Points"))
self.connect_points_item.set_active(True)
self.connect_points_item.connect("toggled", self.toggle_connect)
self.connect_points_item.show()
self.graph_toolbar.insert(self.connect_points_item, -1)
separator = gtk.SeparatorToolItem()
separator.show()
self.graph_toolbar.insert(separator, -1)
self.decimal_item = RadioToolButton()
self.decimal_item.set_named_icon('decimal')
self.decimal_item.set_tooltip(_("Decimal Scale Style"))
self.decimal_item.connect("toggled", self.scale_dec)
self.decimal_item.show()
self.graph_toolbar.insert(self.decimal_item, -1)
self.radians_item = RadioToolButton()
self.radians_item.set_named_icon('radian')
self.radians_item.set_tooltip(_("Radians Scale Style"))
self.radians_item.set_group(self.decimal_item)
self.radians_item.connect("toggled", self.scale_rad)
self.radians_item.show()
self.graph_toolbar.insert(self.radians_item, -1)
self.custom_item = RadioToolButton()
self.custom_item.set_named_icon('custom')
self.custom_item.set_tooltip(_("Custom Scale Style"))
self.custom_item.set_group(self.radians_item)
self.custom_item.connect("toggled", self.scale_cust)
self.custom_item.show()
self.graph_toolbar.insert(self.custom_item, -1)
self.graph_toolbar.show()
if have_toolbox:
self.graph_item.show()
self.toolbar_box.toolbar.insert(self.graph_item, -1)
separator = gtk.SeparatorToolItem()
separator.set_draw(False)
separator.set_expand(True)
separator.show()
self.toolbar_box.toolbar.insert(separator, -1)
self.stop = StopButton(self)
self.stop.show()
self.toolbar_box.toolbar.insert(self.stop, -1)
self.set_toolbar_box(self.toolbar_box)
self.toolbar_box.show()
else:
self.toolbox.show()
self.set_toolbox(self.toolbox)
self.v_box = gtk.VBox()
self.set_canvas(self.v_box)
self.parameter_entries = gtk.Table(6, 3)
self.y1_entry = gtk.Entry()
self.y2_entry = gtk.Entry()
self.y3_entry = gtk.Entry()
self.x_min_entry = gtk.Entry()
self.x_min_entry.set_size_request(90, 24)
self.x_min_entry.set_alignment(1)
self.x_max_entry = gtk.Entry()
self.x_max_entry.set_size_request(90, 24)
self.x_max_entry.set_alignment(1)
self.x_scale_entry = gtk.Entry()
self.x_scale_entry.set_size_request(90, 24)
self.x_scale_entry.set_alignment(1)
self.y_min_entry = gtk.Entry()
self.y_min_entry.set_size_request(90, 24)
self.y_min_entry.set_alignment(1)
self.y_max_entry = gtk.Entry()
self.y_max_entry.set_size_request(90, 24)
self.y_max_entry.set_alignment(1)
self.y_scale_entry = gtk.Entry()
self.y_scale_entry.set_size_request(90, 24)
self.y_scale_entry.set_alignment(1)
self.y1_entry.set_text(self.y1)
self.y2_entry.set_text(self.y2)
self.y3_entry.set_text(self.y3)
self.x_min_entry.set_text(self.x_min)
self.x_max_entry.set_text(self.x_max)
self.x_scale_entry.set_text(self.x_scale)
self.y_min_entry.set_text(self.y_min)
self.y_max_entry.set_text(self.y_max)
self.y_scale_entry.set_text(self.y_scale)
self.scale_box = gtk.HBox()
label = gtk.Label("y1 = ")
label.set_alignment(0, .5)
label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("blue"))
self.parameter_entries.attach(label, 0, 1, 0, 1, xpadding=5, ypadding=5, xoptions=gtk.FILL)
self.parameter_entries.attach(self.y1_entry, 1, 2, 0, 1)
label = gtk.Label(_("X min"))
label.set_alignment(1, .5)
self.parameter_entries.attach(label, 2, 3, 0, 1, xpadding=5, ypadding=7, xoptions=gtk.FILL)
self.parameter_entries.attach(self.x_min_entry, 3, 4, 0, 1, xoptions=gtk.FILL)
label = gtk.Label(_("Y min"))
label.set_alignment(1, .5)
self.parameter_entries.attach(label, 4, 5, 0, 1, xpadding=5, ypadding=5, xoptions=gtk.FILL)
self.parameter_entries.attach(self.y_min_entry, 5, 6, 0, 1, xpadding=5, xoptions=gtk.FILL)
label = gtk.Label("y2 = ")
label.set_alignment(0, .5)
label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("red"))
self.parameter_entries.attach(label, 0, 1, 1, 2, xpadding=5, ypadding=5, xoptions=gtk.FILL)
self.parameter_entries.attach(self.y2_entry, 1, 2, 1, 2)
label = gtk.Label(_("X max"))
label.set_alignment(1, .5)
self.parameter_entries.attach(label, 2, 3, 1, 2, xpadding=5, ypadding=7, xoptions=gtk.FILL)
self.parameter_entries.attach(self.x_max_entry, 3, 4, 1, 2, xoptions=gtk.FILL)
label = gtk.Label(_("Y max"))
label.set_alignment(1, .5)
self.parameter_entries.attach(label, 4, 5, 1, 2, xpadding=5, ypadding=5, xoptions=gtk.FILL)
self.parameter_entries.attach(self.y_max_entry, 5, 6, 1, 2, xpadding=5, xoptions=gtk.FILL)
label = gtk.Label("y3 = ")
label.set_alignment(0, .5)
label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("DarkGreen"))
self.parameter_entries.attach(label, 0, 1, 2, 3, xpadding=5, ypadding=5, xoptions=gtk.FILL)
self.parameter_entries.attach(self.y3_entry, 1, 2, 2, 3)
label = gtk.Label(_("X scale"))
label.set_alignment(0, .5)
self.scale_box.add(label)
self.scale_box.add(self.x_scale_entry)
label = gtk.Label(_("Y scale"))
label.set_alignment(0, .5)
self.scale_box.add(label)
self.scale_box.add(self.y_scale_entry)
self.parameter_entries.attach(self.scale_box, 2, 6, 2, 3, xpadding=5, xoptions=gtk.FILL)
self.v_box.pack_start(self.parameter_entries, False, True, 4)
self.parameter_entries.show_all()
self.graph = GraphClass(self)
self.v_box.pack_start(self.graph.drawing_area, True, True, 0)
self.status_bar = gtk.Statusbar()
self.status_bar.ContextId = self.status_bar.get_context_id("Dummy")
self.status_bar.show()
self.v_box.pack_end(self.status_bar, False, True, 0)
self.v_box.show_all()
def add_space(self):
try:
self.__toolbar.insert(gtk.SeparatorToolItem(), -1)
except:
self.__toolbar.append_space()
def __init__(self, handle):
"""Set up the XoScope activity."""
activity.Activity.__init__(self, handle)
self._instance_directory = os.path.join(self.get_activity_root(),\
'instance')
# we do not have collaboration features
# make the share option insensitive
self.max_participants = 1
self._capturing = False
self._mode = 'live'
# 0, 2 or 5 second delay before capturing the image
self._delay = 0
# Zoom 1x, 2x, 4x
self._zoom = 1
# Exposure bracketing
self._bracketing = '0'
# Preview mode stuff
self._num_pics = 0
# Index of pic to be displayed in preview mode
self._pic_index = 0
# This holds the image titles and name information. Saved
# across activity instances
self._images = []
# Flag to store whether image preview element needs to resize
# the pixbuf
self._needs_resize = False
if OLD_TOOLBAR:
self.toolbox = ActivityToolbox(self)
self.set_toolbox(self.toolbox)
self.toolbox.show()
activity_toolbar = self.toolbox.get_activity_toolbar()
activity_toolbar = gtk.Toolbar()
self.toolbox.add_toolbar(_('Control'), activity_toolbar)
self.toolbox.set_current_toolbar(1)
self._controls_toolbar = activity_toolbar
advanced_toolbar = self.toolbox.get_activity_toolbar()
advanced_toolbar = gtk.Toolbar()
#self.toolbox.add_toolbar(_('Advanced controls'), advanced_toolbar)
else:
toolbar_box = ToolbarBox()
self.activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(self.activity_button, 0)
self.activity_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
activity_toolbar = self.activity_button.page
self._controls_toolbar = self.get_toolbar_box().toolbar
self._controls_toolbar.show()
advanced_toolbar = gtk.Toolbar()
#advanced_toolbar.show_all()
advanced_button = ToolbarButton()
advanced_button.props.page = advanced_toolbar
advanced_button.props.label = _('Advanced controls')
advanced_button.props.icon_name = 'advanced'
#advanced_button.show()
#toolbar_box.toolbar.insert(advanced_button, -1)
self._live_toolitem = gtk.ToolItem()
self._live_toolbar_container = gtk.HBox()
self._preview_toolitem = gtk.ToolItem()
self._preview_toolbar_container = gtk.HBox()
separator = gtk.SeparatorToolItem()
if not OLD_TOOLBAR:
separator.props.draw = True
else:
separator.props.draw = False
separator.set_expand(False)
self._controls_toolbar.insert(separator, -1)
separator.show()
self._photo_button = ToolButton('photo')
self._photo_button.props.label = _('Capture photo')
self._photo_button.connect('clicked',
self.__capture_image_cb)
self._live_toolbar_container.add(self._photo_button)
self._photo_button.show()
self._delay_button = ToolButton('delay_%d' % self._delay)
self._delay_button.props.label = _('Capture delay')
self._delay_button.connect('clicked',
self.__change_capture_delay_cb)
self._live_toolbar_container.add(self._delay_button)
self._delay_button.show()
self._zoom_button = ToolButton('zoom_%d' % self._zoom)
self._zoom_button.props.label = _('Image Zoom')
self._zoom_button.connect('clicked',
self.__change_image_zoom_cb)
self._live_toolbar_container.add(self._zoom_button)
self._zoom_button.show()
#if self._check_available_control(v4l2.V4L2_CID_EXPOSURE):
# self._bracketing_button = ToolButton('bracketing_%s' % self._bracketing)
# self._bracketing_button.props.label = _('bracketing mode')
# self._bracketing_button.connect('clicked',
# self.__change_capture_bracketing_cb)
# self._live_toolbar_container.add(self._bracketing_button)
# self._bracketing_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = True
separator.set_expand(False)
self._live_toolbar_container.add(separator)
separator.show()
# Camera control settings follow
if self._check_available_control(v4l2.V4L2_CID_EXPOSURE):
self._exposure_button = ToolButton('exposure')
self._exposure_button.set_palette(ScalePalette('Exposure',\
v4l2.V4L2_CID_EXPOSURE))
self._exposure_button.connect('clicked',
self.__button_clicked_cb)
self._live_toolbar_container.add(self._exposure_button)
self._exposure_button.show()
if self._check_available_control(v4l2.V4L2_CID_GAIN):
self._gain_button = ToolButton('gain')
self._gain_button.set_palette(ScalePalette('Gain',\
v4l2.V4L2_CID_GAIN,
self._check_available_control(v4l2.V4L2_CID_AUTOGAIN)))
self._gain_button.connect('clicked',
self.__button_clicked_cb)
advanced_toolbar.insert(self._gain_button, -1)
self._gain_button.show()
if self._check_available_control(v4l2.V4L2_CID_BRIGHTNESS):
self._brightness_button = ToolButton('brightness')
self._brightness_button.set_palette(ScalePalette('Brightness',\
v4l2.V4L2_CID_BRIGHTNESS,
self._check_available_control(
v4l2.V4L2_CID_AUTOBRIGHTNESS)))
self._brightness_button.connect('clicked',
self.__button_clicked_cb)
self._live_toolbar_container.add(self._brightness_button)
self._brightness_button.show()
if self._check_available_control(v4l2.V4L2_CID_CONTRAST):
self._contrast_button = ToolButton('contrast')
self._contrast_button.set_palette(ScalePalette('Contrast',\
v4l2.V4L2_CID_CONTRAST))
self._contrast_button.connect('clicked',
self.__button_clicked_cb)
self._live_toolbar_container.add(self._contrast_button)
self._contrast_button.show()
if self._check_available_control(v4l2.V4L2_CID_SATURATION):
self._saturation_button = ToolButton('saturation')
self._saturation_button.set_palette(ScalePalette('Saturation',\
v4l2.V4L2_CID_SATURATION))
self._saturation_button.connect('clicked',
self.__button_clicked_cb)
advanced_toolbar.insert(self._saturation_button, -1)
self._saturation_button.show()
if self._check_available_control(
v4l2.V4L2_CID_WHITE_BALANCE_TEMPERATURE):
self._white_balance_button = ToolButton('white_balance')
self._white_balance_button.set_palette(ScalePalette('White'
' balance', v4l2.V4L2_CID_WHITE_BALANCE_TEMPERATURE,
self._check_available_control(
v4l2.V4L2_CID_AUTO_WHITE_BALANCE)))
self._white_balance_button.connect('clicked',
self.__button_clicked_cb)
advanced_toolbar.insert(self._white_balance_button, -1)
self._white_balance_button.show()
if self._check_available_control(v4l2.V4L2_CID_HUE):
self._color_tone_button = ToolButton('color_tone')
self._color_tone_button.set_palette(ScalePalette('Color'
' tone', v4l2.V4L2_CID_HUE,
self._check_available_control(
v4l2.V4L2_CID_HUE_AUTO)))
self._color_tone_button.connect('clicked',
self.__button_clicked_cb)
advanced_toolbar.insert(self._color_tone_button, -1)
self._color_tone_button.show()
#if self._check_available_control(v4l2.V4L2_CID_NIGHT_MODE):
# self._night_mode_button = ToolButton('night_mode')
# self._night_mode_button.set_palette(ScalePalette('Night mode',\
# v4l2.V4L2_CID_NIGHT_MODE))
# self._night_mode_button.connect('clicked',
# self.__button_clicked_cb)
# self._live_toolbar_container.add(self._night_mode_button)
# self._night_mode_button.show()
self._previous_image = ToolButton('go-previous-paired')
self._previous_image.label = _('Previous image')
self._previous_image.connect('clicked',
self.__previous_image_clicked_cb)
self._preview_toolbar_container.add(self._previous_image)
self._previous_image.show()
self._next_image = ToolButton('go-next-paired')
self._next_image.label = _('Next image')
self._next_image.connect('clicked',
self.__next_image_clicked_cb)
self._preview_toolbar_container.add(self._next_image)
self._next_image.show()
self._image_name_entry = gtk.Entry()
self._image_name_entry.set_text('')
self._image_name_entry.set_size_request(400, -1)
self._image_name_entry.connect('activate',
self.__image_name_entry_activated_cb)
self._preview_toolbar_container.add(self._image_name_entry)
self._image_name_entry.show()
self._save_to_journal = ToolButton('save_to_journal')
self._save_to_journal.label = _('Save to journal')
self._save_to_journal.connect('clicked',
self.__save_to_journal_clicked_cb)
self._preview_toolbar_container.add(self._save_to_journal)
self._save_to_journal.show()
self._trash = ToolButton('trash')
self._trash.label = _('Delete')
self._trash.connect('clicked',
self.__trash_clicked_cb)
self._preview_toolbar_container.add(self._trash)
self._trash.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self._controls_toolbar.insert(separator, -1)
separator.show()
self._mode_button = ToolButton('%s_mode' % self._mode)
self._mode_button.props.label = _('Mode')
self._mode_button.connect('clicked',
self.__switch_modes_cb)
self._controls_toolbar.insert(self._mode_button, -1)
self._mode_button.show()
if not OLD_TOOLBAR:
separator = gtk.SeparatorToolItem()
separator.props.draw = True
separator.set_expand(False)
self._controls_toolbar.insert(separator, -1)
separator.show()
activity_stop = StopButton(self)
toolbar_box.toolbar.insert(activity_stop, -1)
activity_stop.show()
self._preview_toolitem.add(self._preview_toolbar_container)
self._live_toolitem.add(self._live_toolbar_container)
self._preview_toolbar_container.show()
self._live_toolbar_container.show()
if self._mode == 'preview':
self._controls_toolbar.insert(self._preview_toolitem, 1)
self._preview_toolitem.show()
else:
self._controls_toolbar.insert(self._live_toolitem, 1)
self._live_toolitem.show()
self._mode = 'live'
self._controls_toolbar.show()
activity_toolbar.show()
self._main_view = gtk.HBox()
self._movie_window = gtk.DrawingArea()
self._movie_window.connect('realize',
self.__movie_window_realize_cb)
self._movie_window.unset_flags(gtk.DOUBLE_BUFFERED)
self._movie_window.set_flags(gtk.APP_PAINTABLE)
self._main_view.add(self._movie_window)
self._preview_frame = gtk.AspectFrame(None, 0.5, 0.5, 1, True)
self._preview_window = gtk.Image()
self._preview_frame.add(self._preview_window)
self._preview_window.connect('size_allocate',
self.__preview_window_size_allocate_cb)
self.xoscope = gst.Pipeline('xoscope_pipe')
camsrc = gst.element_factory_make('v4l2src', 'camsrc')
caps = gst.Caps('video/x-raw-yuv')
filt = gst.element_factory_make('capsfilter', 'filter')
filt.set_property('caps', caps)
ffmpegcolorspace = gst.element_factory_make('ffmpegcolorspace',
'ffmpegcolorspace')
self._disp_sink = gst.element_factory_make('xvimagesink', 'disp_sink')
# http://thread.gmane.org/gmane.comp.video.gstreamer.devel/29644
self._disp_sink.set_property('sync', False)
self.image_sink = gst.element_factory_make('fakesink',
'image_sink')
self.image_sink.set_property('silent', True)
tee = gst.element_factory_make('tee', 'tee')
queue = gst.element_factory_make('queue', 'dispqueue')
queue.set_property('leaky', True)
queue.set_property('max-size-buffers', 20)
queue2 = gst.element_factory_make('queue', 'imagequeue')
queue2.set_property('leaky', True)
queue2.set_property('max-size-buffers', 20)
self._zoom_element = gst.element_factory_make('videobox', 'zoombox')
jpeg = gst.element_factory_make('jpegenc', 'pbjpeg')
jpeg.set_property('quality', 100)
self.xoscope.add(camsrc, filt, ffmpegcolorspace,\
self._zoom_element, self._disp_sink, tee, queue, queue2,\
self.image_sink, jpeg)
gst.element_link_many(camsrc, filt, self._zoom_element,\
ffmpegcolorspace, tee, queue, self._disp_sink)
gst.element_link_many(tee, queue2, jpeg, self.image_sink)
bus = self.xoscope.get_bus()
bus.add_signal_watch()
bus.enable_sync_message_emission()
bus.connect('message', self.__on_message_cb)
bus.connect('sync-message::element', self.__on_sync_message_cb)
self._main_view.show()
self._movie_window.show()
self.set_canvas(self._main_view)
# If we start playing without a delay, the live view window
# doesn't get attached to the main canvas properly (This is
# a problem on slow computers like xo1).
gobject.timeout_add(2000, self.__start_live_view)
def __init__(self, th, port, server):
self.th = th
self.port = port
self.server = server # we need this to quit the server when closing main window
gtk.window_set_default_icon_name('thawab')
gtk.Window.__init__(self)
self.set_title(_('Thawab'))
self.set_default_size(600, 480)
self.import_w = None
self.fixes_w = None
self.ix_w = ThIndexerWindow(self)
vb = gtk.VBox(False, 0)
self.add(vb)
tools = gtk.Toolbar()
vb.pack_start(tools, False, False, 2)
self._content = ContentPane("http://127.0.0.1:%d/" % port, _("Thawab"))
vb.pack_start(self._content, True, True, 2)
b = gtk.ToolButton(gtk.STOCK_NEW)
b.connect('clicked', lambda bb: self._content.new_tab())
b.set_tooltip_text(_("Open a new tab"))
tools.insert(b, -1)
# TODO: add navigation buttons (back, forward ..etc.) and zoom buttons
tools.insert(gtk.SeparatorToolItem(), -1)
img = gtk.Image()
img.set_from_stock(gtk.STOCK_CONVERT, gtk.ICON_SIZE_BUTTON)
b = gtk.ToolButton(icon_widget=img, label=_("Import"))
b.set_tooltip_text(_("Import .bok files"))
b.connect('clicked', self.import_cb)
tools.insert(b, -1)
img = gtk.Image()
img.set_from_stock(gtk.STOCK_FIND_AND_REPLACE, gtk.ICON_SIZE_BUTTON)
b = gtk.ToolButton(icon_widget=img, label=_("Index"))
b.set_is_important(True)
b.set_tooltip_text(_("Create search index"))
b.connect('clicked', lambda *a: self.ix_w.show_all())
tools.insert(b, -1)
tools.insert(gtk.SeparatorToolItem(), -1)
img = gtk.Image()
img.set_from_stock(gtk.STOCK_ZOOM_IN, gtk.ICON_SIZE_BUTTON)
b = gtk.ToolButton(icon_widget=img, label=_("Zoom in"))
b.set_is_important(True)
b.set_tooltip_text(_("Makes things appear bigger"))
b.connect('clicked', lambda a: self._do_in_current_view("zoom_in"))
tools.insert(b, -1)
img = gtk.Image()
img.set_from_stock(gtk.STOCK_ZOOM_OUT, gtk.ICON_SIZE_BUTTON)
b = gtk.ToolButton(icon_widget=img, label=_("Zoom out"))
b.set_tooltip_text(_("Makes things appear smaller"))
b.connect('clicked', lambda a: self._do_in_current_view("zoom_out"))
tools.insert(b, -1)
img = gtk.Image()
img.set_from_stock(gtk.STOCK_ZOOM_100, gtk.ICON_SIZE_BUTTON)
b = gtk.ToolButton(icon_widget=img, label=_("1:1 Zoom"))
b.set_tooltip_text(_("restore original zoom factor"))
b.connect('clicked',
lambda a: self._do_in_current_view("set_zoom_level", 1.0))
tools.insert(b, -1)
tools.insert(gtk.SeparatorToolItem(), -1)
img = gtk.Image()
img.set_from_stock(gtk.STOCK_PREFERENCES, gtk.ICON_SIZE_BUTTON)
b = gtk.ToolButton(icon_widget=img, label=_("Fixes"))
b.set_is_important(True)
b.set_tooltip_text(_("Misc Fixes"))
b.connect('clicked', self.fixes_cb)
tools.insert(b, -1)
tools.insert(gtk.SeparatorToolItem(), -1)
img = gtk.Image()
img.set_from_stock(gtk.STOCK_HELP, gtk.ICON_SIZE_BUTTON)
b = gtk.ToolButton(icon_widget=img, label=_("Help"))
b.set_tooltip_text(_("Show user manual"))
b.connect(
'clicked', lambda a: self._content.new_tab(
"http://127.0.0.1:%d/_theme/manual/manual.html" % port))
tools.insert(b, -1)
self._content.new_tab()
self.connect("delete_event", self.quit)
self.drag_dest_set(gtk.DEST_DEFAULT_ALL, targets_l, (1 << 5) - 1)
self.connect('drag-data-received', self.drop_data_cb)
self.show_all()
def get_separador(draw=False, ancho=0, expand=False):
separador = gtk.SeparatorToolItem()
separador.props.draw = draw
separador.set_size_request(ancho, -1)
separador.set_expand(expand)
return separador
def __init__(self, activity):
gtk.Toolbar.__init__(self)
self._activity = activity
self._updating_share = False
"""
activity.connect('shared', self.__activity_shared_cb)
activity.connect('joined', self.__activity_shared_cb)
activity.connect('notify::max_participants',
self.__max_participants_changed_cb)
"""
#if activity.metadata:
if True:
self.label = gtk.Label(display.menu_journal_label)
self.label.show()
self._add_widget(self.label)
self.title = gtk.Entry()
self.title.set_size_request(int(gtk.gdk.screen_width() / 6), -1)
if activity.metadata:
self.title.set_text(activity.metadata['title'])
#activity.metadata.connect('updated', self.__jobject_updated_cb)
self.title.connect('changed', self.__title_changed_cb)
self.title.connect('activate', self.__update_title_cb)
self._add_widget(self.title)
fn = os.path.join(os.getcwd(), 'assets', 'stack_new.png')
button = ImageButton()
tooltip = _("Add Album Stack")
button.set_image(fn, tip=tooltip)
self.add_album = button
self.add_album.show()
self.add_album.connect('clicked', self.__add_album_clicked_cb)
self.insert(self.add_album, -1)
fn = os.path.join(os.getcwd(), 'assets', 'stack_del.png')
button = ImageButton()
tooltip = _("Delete Album Stack")
button.set_image(fn, tip=tooltip)
button.connect('clicked', self.__delete_album_clicked_cb)
self.insert(button, -1)
fn = os.path.join(os.getcwd(), 'assets', 'trash_del.png')
button = ImageButton()
tooltip = _("Remove Trash Images from XO")
button.set_image(fn, tip=tooltip)
self.empty_journal_button = button
self.empty_journal_button.hide()
self.empty_journal_button.connect('clicked',
self.__empty_trash_clicked_cb)
self.insert(self.empty_journal_button, -1)
"""
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
self.share = ToolComboBox(label_text=_('Traceback:'))
self.share.combo.connect('changed', self.__traceback_changed_cb)
self.share.combo.append_item("traceback_plain", _('Plain'))
self.share.combo.append_item('traceback_context', _('Context'))
self.share.combo.append_item('traceback_verbose', _('Verbose'))
self.insert(self.share, -1)
self.share.show()
self._update_share()
"""
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self.insert(separator, -1)
separator.show()
self.keep = ToolButton()
self.keep.set_tooltip(_('Save and Start New'))
#client = gconf.client_get_default()
#color = XoColor(client.get_string('/desktop/sugar/user/color'))
#keep_icon = Icon(icon_name='document-save', xo_color=color)
keep_icon = Icon(icon_name='document-save')
keep_icon.show()
self.keep.set_icon_widget(keep_icon)
#self.keep.props.accelerator = '<Ctrl>S'
self.keep.connect('clicked', self.__keep_clicked_cb)
self.insert(self.keep, -1)
self.keep.show()
self.stop = ToolButton('activity-stop')
self.stop.set_tooltip(_('Stop'))
#self.stop.props.accelerator = '<Ctrl>Q'
self.stop.connect('clicked', self.__stop_clicked_cb)
self.insert(self.stop, -1)
self.stop.show()
self._update_title_sid = None
def __init__(self, policy, exceptions, embed=None, execution_path="/usr/share/tomoyo-mdv"):
"""Initializes main window and GUI"""
if embed:
self.window = gtk.Plug(embed)
else:
self.window = gtk.Window()
self.window.set_title(_("Tomoyo GUI"))
self.window.set_default_size(640, 440)
self.window.connect('delete-event', lambda *w: gtk.main_quit())
self.policy = policy
self.exceptions = exceptions
self.execution_path = execution_path
# main vbox
self.main_vbox = gtk.VBox()
self.window.add(self.main_vbox)
# toolbar
toolbar = gtk.Toolbar()
toolbar.set_style(gtk.TOOLBAR_ICONS)
toolbar_item = gtk.ToolButton("Refresh")
toolbar_item.set_stock_id(gtk.STOCK_REFRESH)
toolbar_item.connect("clicked", lambda *w: self.refresh_domains(self.all_domains, self.active_domains, reload=True))
toolbar_item.set_tooltip_text(_("Refresh policy"))
toolbar.insert(toolbar_item, -1)
toolbar_item = gtk.ToolButton("Save")
toolbar_item.set_stock_id(gtk.STOCK_SAVE)
toolbar_item.connect("clicked", lambda *w: self.save_domains())
toolbar_item.set_tooltip_text(_("Save policy"))
toolbar.insert(toolbar_item, -1)
toolbar_item = gtk.ToolButton(label="Save and apply")
toolbar_item.set_stock_id(gtk.STOCK_APPLY)
toolbar_item.connect("clicked", lambda *w: self.save_domains(reload=True))
toolbar_item.set_tooltip_text(_("Save and apply policy"))
toolbar.insert(toolbar_item, -1)
toolbar.insert(gtk.SeparatorToolItem(), -1)
# policy exporting
self.export_domains = gtk.ToolButton("Export")
self.export_domains.set_stock_id(gtk.STOCK_SAVE_AS)
self.export_domains.connect("clicked", self.export_policy)
self.export_domains.set_tooltip_text(_("Export selected policy"))
self.export_domains.set_sensitive(False)
self.selected_domains = None
toolbar.insert(self.export_domains, -1)
# policy importing
self.import_domains = gtk.ToolButton("Import")
self.import_domains.set_stock_id(gtk.STOCK_OPEN)
self.import_domains.connect("clicked", self.import_policy)
self.import_domains.set_tooltip_text(_("Import selected policy"))
self.import_domains.set_sensitive(True)
self.selected_domains = None
toolbar.insert(self.import_domains, -1)
toolbar.insert(gtk.SeparatorToolItem(), -1)
# policy initializing
self.initialize_domains = gtk.ToolButton("Initialize")
self.initialize_domains.set_stock_id(gtk.STOCK_REVERT_TO_SAVED)
self.initialize_domains.connect("clicked", self.install_policy)
self.initialize_domains.set_tooltip_text(_("Initialize policy"))
self.selected_domains = None
toolbar.insert(self.initialize_domains, -1)
toolbar.insert(gtk.SeparatorToolItem(), -1)
toolbar_item = gtk.ToolButton("Quit")
toolbar_item.set_stock_id(gtk.STOCK_QUIT)
toolbar_item.connect("clicked", lambda *w: gtk.main_quit())
toolbar_item.set_tooltip_text(_("Quit without saving"))
toolbar.insert(toolbar_item, -1)
self.main_vbox.pack_start(toolbar, False, False)
# tabs
self.notebook = gtk.Notebook()
self.main_vbox.pack_start(self.notebook)
self.notebook.connect('switch-page', self.show_help_for_page)
# domains
sw_all, self.all_domains = self.build_list_of_domains()
sw_active, self.active_domains = self.build_list_of_domains()
# help text for switching pages
self.num_pages = 0
self.page_help = {}
self.notebook.append_page(sw_all, gtk.Label(_("All domains")))
self.add_page_help("All domains")
self.notebook.append_page(sw_active, gtk.Label(_("Active domains")))
self.add_page_help("Active domains")
# contents
sw2 = gtk.ScrolledWindow()
sw2.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw2.set_shadow_type(gtk.SHADOW_ETCHED_IN)
frame = gtk.Frame(_("Details"))
self.domain_details = gtk.VBox(False, 5)
frame.add(self.domain_details)
sw2.add_with_viewport(frame)
self.main_vbox.pack_start(sw2)
# size group
self.size_group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL)
# show initial help
self.show_help(0)
self.window.show_all()
self.refresh_domains(self.all_domains, self.active_domains)
# now building exceptions
sw_exceptions, self.ls_exceptions = self.build_list_of_exceptions()
self.update_exceptions()
self.notebook.append_page(sw_exceptions, gtk.Label(_("Exceptions")))
self.add_page_help("Exceptions")
# help
self.notebook.append_page(self.build_help(), gtk.Label(_("Help")))
self.add_page_help("Help")
def __init__(self, activity, channels):
#Se utiliza para contralar que no se ejecute dos veces
self._butia_context_id = None
gtk.Toolbar.__init__(self)
self.activity = activity
self._channels = channels
self.mode = 'butia'
# Set up Sensores Button
self.time = RadioToolButton(group=None)
# Mantiene la lista de botones (de sensores)
# agregados a la ButiaToolbar
self.lista_sensores_button = []
self.we_are_logging = False
self._log_this_sample = False
self._logging_timer = None
self._logging_counter = 0
self._image_counter = 0
self._logging_interval = 0
self._channels_logged = []
self._busy = False
self._take_screenshot = True
# BUTIA Se detectan sensores
log.debug('se agrega el boton refrescar')
self.refrescar_button = RadioToolButton(group=None)
self.refrescar_button.set_named_icon('recargar')
self.refrescar_button.connect('clicked', self.update_buttons)
self.insert(self.refrescar_button, -1)
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self.detect_sensors()
self.load_buttons()
separator = gtk.SeparatorToolItem()
separator.props.draw = True
self.insert(separator, -1)
self._log_interval_combo = ComboBox()
self.interval = [
_('1/10 second'),
_('1 second'),
_('30 seconds'),
_('5 minutes'),
_('30 minutes')
]
if hasattr(self._log_interval_combo, 'set_tooltip_text'):
self._log_interval_combo.set_tooltip_text(_('Sampling interval'))
self._interval_changed_id = self._log_interval_combo.connect(
'changed', self.log_interval_cb)
for i, s in enumerate(self.interval):
self._log_interval_combo.append_item(i, s, None)
if s == _('1 second'):
self._log_interval_combo.set_active(i)
self._log_interval_tool = ToolComboBox(self._log_interval_combo)
self.insert(self._log_interval_tool, -1)
self.logging_interval_status = '1 second'
# Set up Logging/Stop Logging Button
self._record = ToolButton('media-record')
self.insert(self._record, -1)
self._record.set_tooltip(_('Start Recording'))
self._record.connect('clicked', self.record_control_cb)
self.show_all()
def __init__(self):
#La ventana
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_position(gtk.WIN_POS_CENTER)
self.window.set_title("Generador de CED")
self.window.maximize()
self.window.set_resizable(False)
self.window.set_icon_from_file(ruta + 'iconos/iconoApp.png')
color = gtk.gdk.color_parse('#ffffff')
self.window.modify_bg(gtk.STATE_NORMAL, color)
self.window.connect("delete_event", self.salir)
self.window.connect("destroy", self.destroy)
#contenedor
tabla = gtk.Table(100, 100, False)
#El Menu
menu = gtk.MenuBar()
menuArchivo = gtk.Menu()
menuEditar = gtk.Menu()
menuProyecto = gtk.Menu()
menuA = gtk.MenuItem("Archivo")
menuE = gtk.MenuItem("Editar")
menuP = gtk.MenuItem("Proyecto")
menuH = gtk.MenuItem("Herramientas")
menuL = gtk.MenuItem("Aplicacion")
menuY = gtk.MenuItem("Ayuda")
#El menu archivo
menuA.set_submenu(menuArchivo)
self.nue = gtk.MenuItem("Nuevo Proyecto")
self.abr = gtk.MenuItem("Abrir Proyecto")
self.gua = gtk.MenuItem("Guardar Proyecto")
self.gua.set_sensitive(False)
self.guc = gtk.MenuItem("Guardar Proyecto Como...")
self.guc.set_sensitive(False)
self.cer = gtk.MenuItem("Cerrar Proyecto")
self.cer.set_sensitive(False)
self.sep = gtk.SeparatorMenuItem()
self.sal = gtk.MenuItem("Salir")
menuArchivo.append(self.nue)
menuArchivo.append(self.abr)
menuArchivo.append(self.gua)
menuArchivo.append(self.guc)
menuArchivo.append(self.cer)
menuArchivo.append(self.sep)
menuArchivo.append(self.sal)
#el menu edicion
menuE.set_submenu(menuEditar)
self.inHoja = gtk.MenuItem("Insertar Hoja")
self.inImagen = gtk.MenuItem("Insertar Imagen")
self.inSonido = gtk.MenuItem("Insertar Sonido")
self.inVideo = gtk.MenuItem("Insertar Video")
self.inArchivo = gtk.MenuItem("Insertar Archivo")
self.sepEd1 = gtk.SeparatorMenuItem()
self.cop = gtk.MenuItem("Copiar Objeto")
self.peg = gtk.MenuItem("Pegar Objeto")
self.elm = gtk.MenuItem("Eliminar Objeto")
menuEditar.append(self.inHoja)
menuEditar.append(self.inImagen)
menuEditar.append(self.inSonido)
menuEditar.append(self.inVideo)
menuEditar.append(self.inArchivo)
menuEditar.append(self.sepEd1)
menuEditar.append(self.cop)
menuEditar.append(self.peg)
menuEditar.append(self.elm)
#el Menu proyecto
menuP.set_submenu(menuProyecto)
self.eje = gtk.MenuItem("Ejecutar")
self.verHtml = gtk.MenuItem("Ver Codigo Fuente")
menuProyecto.append(self.eje)
menuProyecto.append(self.verHtml)
menu.append(menuA)
menu.append(menuE)
menu.append(menuP)
menu.append(menuH)
menu.append(menuL)
menu.append(menuY)
#La barra de herramientas
self.barra = gtk.Toolbar()
self.barra.set_orientation(gtk.ORIENTATION_HORIZONTAL)
self.barra.set_style(gtk.TOOLBAR_ICONS)
self.barra.set_border_width(5)
self.barra.set_tooltips(True)
tooltips = gtk.Tooltips()
#Botones estandar
#icono=gtk.image_new_from_pixbuf(gtk.gdk.pixbuf_new_from_file_at_size('iconos/proyecto.png', 25, 25))
icoNue = gtk.Image()
icoNue.set_from_file(ruta + 'iconos/proyecto.png')
self.barraNue = gtk.ToolButton(icoNue)
self.barraNue.set_tooltip(tooltips, "Nuevo Proyecto")
icoAbr = gtk.Image()
icoAbr.set_from_file(ruta + 'iconos/abrir.png')
self.barraAbr = gtk.ToolButton(icoAbr)
self.barraAbr.set_tooltip(tooltips, "Abrir Proyecto")
icoGua = gtk.Image()
icoGua.set_from_file(ruta + 'iconos/guardar.png')
self.barraGua = gtk.ToolButton(icoGua)
self.barraGua.set_tooltip(tooltips, "Guardar Proyecto")
self.barraGua.set_sensitive(False)
icoGuc = gtk.Image()
icoGuc.set_from_file(ruta + 'iconos/guardarc.png')
self.barraGuc = gtk.ToolButton(icoGuc)
self.barraGuc.set_tooltip(tooltips, "Guardar Proyecto Como")
self.barraGuc.set_sensitive(False)
self.sep = gtk.SeparatorToolItem()
icoSal = gtk.Image()
icoSal.set_from_file(ruta + 'iconos/salir.png')
self.quittb = gtk.ToolButton(icoSal)
#botones de recursos
self.sep2 = gtk.SeparatorToolItem()
icoHoj = gtk.Image()
icoHoj.set_from_file(ruta + 'iconos/hoja.png')
self.barraHojaNueva = gtk.ToolButton(icoHoj)
self.barraHojaNueva.set_tooltip(tooltips, "Insertar Nueva Hoja")
self.barraHojaNueva.set_sensitive(False)
icoImg = gtk.Image()
icoImg.set_from_file(ruta + 'iconos/imagen.png')
self.barraImagenNuevo = gtk.ToolButton(icoImg)
self.barraImagenNuevo.set_tooltip(tooltips, "Insertar Nueva Imagen")
self.barraImagenNuevo.set_sensitive(False)
icoSon = gtk.Image()
icoSon.set_from_file(ruta + 'iconos/sonido.png')
self.barraSonidoNuevo = gtk.ToolButton(icoSon)
self.barraSonidoNuevo.set_tooltip(tooltips, "Insertar Nuevo Sonido")
self.barraSonidoNuevo.set_sensitive(False)
icoVid = gtk.Image()
icoVid.set_from_file(ruta + 'iconos/video.png')
self.barraVideoNuevo = gtk.ToolButton(icoVid)
self.barraVideoNuevo.set_tooltip(tooltips, "Insertar Nuevo Video")
self.barraVideoNuevo.set_sensitive(False)
icoArc = gtk.Image()
icoArc.set_from_file(ruta + 'iconos/archivo.png')
self.barraArchivoNuevo = gtk.ToolButton(icoArc)
self.barraArchivoNuevo.set_tooltip(tooltips, "Insertar Nuevo Archivo")
self.barraArchivoNuevo.set_sensitive(False)
#botones de objetos
self.sep3 = gtk.SeparatorToolItem()
icoRec = gtk.Image()
icoRec.set_from_file(ruta + 'iconos/cuadrado.png')
self.barraRectangulo = gtk.ToolButton(icoRec)
self.barraRectangulo.set_tooltip(tooltips, "Insertar rectangulo")
self.barraRectangulo.set_sensitive(False)
icoCir = gtk.Image()
icoCir.set_from_file(ruta + 'iconos/circulo.png')
self.barraCirculo = gtk.ToolButton(icoCir)
self.barraCirculo.set_tooltip(tooltips, "Insertar circulo")
self.barraCirculo.set_sensitive(False)
icoTri = gtk.Image()
icoTri.set_from_file(ruta + 'iconos/triangulo.png')
self.barraTriangulo = gtk.ToolButton(icoTri)
self.barraTriangulo.set_tooltip(tooltips, "Insertar triangulo")
self.barraTriangulo.set_sensitive(False)
icoLin = gtk.Image()
icoLin.set_from_file(ruta + 'iconos/linea.png')
self.barraLinea = gtk.ToolButton(icoLin)
self.barraLinea.set_tooltip(tooltips, "Insertar Linea")
self.barraLinea.set_sensitive(False)
icoimg = gtk.Image()
icoimg.set_from_file(ruta + 'iconos/imagen.png')
self.barraImagen = gtk.ToolButton(icoimg)
self.barraImagen.set_tooltip(tooltips, "Insertar Imagen a la Hoja")
self.barraImagen.set_sensitive(False)
icotex = gtk.Image()
icotex.set_from_file(ruta + 'iconos/texto.png')
self.barraTexto = gtk.ToolButton(icotex)
self.barraTexto.set_tooltip(tooltips, "Insertar texto")
self.barraTexto.set_sensitive(False)
#botones de formularios
self.sep4 = gtk.SeparatorToolItem()
icoBot = gtk.Image()
icoBot.set_from_file(ruta + 'iconos/boton.png')
self.barraBoton = gtk.ToolButton(icoBot)
self.barraBoton.set_tooltip(tooltips, "Insertar Boton")
self.barraBoton.set_sensitive(False)
icoTex = gtk.Image()
icoTex.set_from_file(ruta + 'iconos/cajaTexto.png')
self.barraCajaTexto = gtk.ToolButton(icoTex)
self.barraCajaTexto.set_tooltip(tooltips, "Insertar caja de texto")
self.barraCajaTexto.set_sensitive(False)
icoLis = gtk.Image()
icoLis.set_from_file(ruta + 'iconos/lista.png')
self.barraLista = gtk.ToolButton(icoLis)
self.barraLista.set_tooltip(tooltips, "Insertar Lista Desplegable")
self.barraLista.set_sensitive(False)
icoChk = gtk.Image()
icoChk.set_from_file(ruta + 'iconos/check.png')
self.barraCheck = gtk.ToolButton(icoChk)
self.barraCheck.set_tooltip(tooltips, "Insertar CheckBox")
self.barraCheck.set_sensitive(False)
icoArea = gtk.Image()
icoArea.set_from_file(ruta + 'iconos/editor.png')
self.barraArea = gtk.ToolButton(icoArea)
self.barraArea.set_tooltip(tooltips, "Insertar Editor de Texto")
self.barraArea.set_sensitive(False)
icoSnd = gtk.Image()
icoSnd.set_from_file(ruta + 'iconos/corneta.png')
self.barraSon = gtk.ToolButton(icoSnd)
self.barraSon.set_tooltip(tooltips, "Insertar Sonido a la Hoja")
self.barraSon.set_sensitive(False)
icoCla = gtk.Image()
icoCla.set_from_file(ruta + 'iconos/clap.png')
self.barraCla = gtk.ToolButton(icoCla)
self.barraCla.set_tooltip(tooltips, "Insertar Video a la Hoja")
self.barraCla.set_sensitive(False)
icoScr = gtk.Image()
icoScr.set_from_file(ruta + 'iconos/escritos.png')
self.barraScr = gtk.ToolButton(icoScr)
self.barraScr.set_tooltip(tooltips,
"Insertar Codigo Escrito a la Hoja")
self.barraScr.set_sensitive(False)
#Insertamos los botones estandar a la barra
self.barra.insert(self.barraNue, 0)
self.barra.insert(self.barraAbr, 1)
self.barra.insert(self.barraGua, 2)
self.barra.insert(self.barraGuc, 3)
self.barra.insert(self.sep, 4)
self.barra.insert(self.quittb, 5)
#Insertamos los botones recuros a la barra
self.barra.insert(self.sep2, 6)
self.barra.insert(self.barraHojaNueva, 7)
self.barra.insert(self.barraImagenNuevo, 8)
self.barra.insert(self.barraSonidoNuevo, 9)
self.barra.insert(self.barraVideoNuevo, 10)
self.barra.insert(self.barraArchivoNuevo, 11)
#Insertamos los botones objetos a la barra
self.barra.insert(self.sep3, 12)
self.barra.insert(self.barraRectangulo, 13)
self.barra.insert(self.barraCirculo, 14)
self.barra.insert(self.barraTriangulo, 15)
self.barra.insert(self.barraLinea, 16)
self.barra.insert(self.barraImagen, 17)
self.barra.insert(self.barraTexto, 18)
#insertamos los botones de Controles de Formularios
self.barra.insert(self.sep4, 19)
self.barra.insert(self.barraBoton, 20)
self.barra.insert(self.barraCajaTexto, 21)
self.barra.insert(self.barraLista, 22)
self.barra.insert(self.barraCheck, 23)
self.barra.insert(self.barraArea, 24)
self.barra.insert(self.barraSon, 25)
self.barra.insert(self.barraCla, 26)
self.barra.insert(self.barraScr, 27)
#La zona de Trabajo
#NAvegador de Proyecto
self.treeview = gtk.TreeView()
# Crear la columna para la lista
self.columna = gtk.TreeViewColumn('Proyecto')
self.celdaIcono = gtk.CellRendererPixbuf()
self.cell = gtk.CellRendererText()
self.columna.pack_start(self.celdaIcono, False)
self.columna.pack_start(self.cell, False)
self.columna.set_attributes(self.celdaIcono, stock_id=1)
self.columna.set_attributes(self.cell, text=0)
self.treeview.append_column(self.columna)
self.treeview.set_enable_tree_lines(True)
self.selFila = self.treeview.get_selection()
#Vista de las propiedades de los objetos
self.panelPropiedades = gtk.TreeView()
rendererText = gtk.CellRendererText()
column = gtk.TreeViewColumn("Propiedad", rendererText, text=0)
column.set_sort_column_id(0)
self.panelPropiedades.append_column(column)
self.cajaEditable = gtk.CellRendererCombo()
self.cajaEditable.set_fixed_size(5, -1)
self.cajaEditable.set_property("editable", True)
self.cajaEditable.set_property("text-column", 0)
self.cajaEditable.set_property("has-entry", True)
column = gtk.TreeViewColumn("Valor", self.cajaEditable, text=1)
column.add_attribute(self.cajaEditable, "model", 2)
self.panelPropiedades.append_column(column)
self.panelPropiedades.set_grid_lines(True)
#Zona de Previsualizacion
self.lienzo = webkit.WebView()
self.lienzo.set_view_source_mode(False)
propLienzo = webkit.WebSettings()
propLienzo.set_property("enable-plugins", False)
self.lienzo.set_settings(propLienzo)
#propLienzo.set_property("title","Titulo 1")
#self.lienzo.set_settings(propLienzo)
# Barras de desplazamiento para el contenedor
scroll = gtk.ScrolledWindow()
scroll2 = gtk.ScrolledWindow()
scroll3 = gtk.ScrolledWindow()
#self.scroll3.set_policy(gtk.POLICY_NEVER,gtk.POLICY_AUTOMATIC)
#barra estado
self.statusbar = gtk.Statusbar()
#Agregamos al Contenedor
scroll.add(self.treeview)
scroll2.add(self.lienzo)
scroll3.add(self.panelPropiedades)
tabla.attach(menu, 0, 100, 0, 1, gtk.FILL | gtk.EXPAND,
gtk.FILL | gtk.SHRINK, 0, 0)
tabla.attach(self.barra, 0, 100, 1, 2, gtk.FILL | gtk.EXPAND,
gtk.FILL | gtk.SHRINK, 0, 0)
tabla.attach(scroll, 0, 20, 2, 50, gtk.FILL, gtk.FILL | gtk.EXPAND, 0,
0)
tabla.attach(scroll3, 0, 20, 50, 98, gtk.FILL | gtk.EXPAND,
gtk.FILL | gtk.EXPAND, 0, 0)
tabla.attach(scroll2, 20, 100, 2, 98, gtk.FILL | gtk.EXPAND,
gtk.FILL | gtk.EXPAND, 0, 0)
tabla.attach(self.statusbar, 0, 100, 98, 100, gtk.FILL | gtk.EXPAND,
gtk.FILL, 0, 0)
#ACtrivamos las funciones de los menu
self.sal.connect("activate", self.salir, 2)
#activamos las funciones de los botones de la barra
self.quittb.connect("clicked", self.salir, 2)
#mostramos la ventana
self.window.add(tabla)
self.window.show_all()
def __init__(self, handle):
"""Set up the Elephant activity."""
activity.Activity.__init__(self, handle)
# we do not have collaboration features
# make the share option insensitive
self.max_participants = 1
# toolbar with the new toolbar redesign
toolbar_box = ToolbarBox()
activity_button = ActivityButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
title_entry = TitleEntry(self)
toolbar_box.toolbar.insert(title_entry, -1)
title_entry.show()
share_button = ShareButton(self)
toolbar_box.toolbar.insert(share_button, -1)
share_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
# Instances to Elephants classes
words = elephant.word_list()
# Get a word form word list and path
self.get_random_word(words)
# Vertical box conteinter definition
vbox_main = gtk.VBox()
# Horizontal boxes conteiners definition
hbox_01 = gtk.HBox()
hbox_02 = gtk.HBox()
hbox_03 = gtk.HBox()
# Buttons definitions
self.button_repeat = gtk.Button()
self.button_repeat.set_label('Repetir')
self.button_option1 = gtk.Button()
self.button_option2 = gtk.Button()
self.button_option3 = gtk.Button()
# Image and label word
self.label_word = gtk.Label()
self.image_word = gtk.Image()
#self.image_word = self.show_image(path)
#self.label_word = self.show_label(word)
# Create layout
self.set_canvas(vbox_main)
vbox_main.add(hbox_01)
vbox_main.add(hbox_02)
vbox_main.add(hbox_03)
# Put label and label on layout
hbox_02.add(self.image_word)
hbox_02.add(self.label_word)
# conectors
self.connect('realize', self.__window_realize)
self.button_repeat.connect('clicked', self.__button_clicked_rep)
self.button_option1.connect('clicked', self.__button_clicked_op)
self.button_option2.connect('clicked', self.__button_clicked_op)
self.button_option3.connect('clicked', self.__button_clicked_op)
# Put buttons on layout
hbox_01.add(self.button_repeat)
hbox_03.add(self.button_option1)
hbox_03.add(self.button_option2)
hbox_03.add(self.button_option3)
# ShowMeTheMoney!!!
vbox_main.show_all()
#label_word.show()
self.elephant_is_saying()
def _create_toolitems_2_4(self):
# use the GTK+ 2.4 GtkToolbar API
iconSize = gtk.ICON_SIZE_SMALL_TOOLBAR
if not _new_tooltip_api:
self.tooltips = gtk.Tooltips()
for text, tooltip_text, image_num, callback, callback_arg, scroll \
in self.toolitems:
if text is None:
self.insert( gtk.SeparatorToolItem(), -1 )
continue
image = gtk.Image()
image.set_from_stock(image_num, iconSize)
tbutton = gtk.ToolButton(image, text)
self.insert(tbutton, -1)
if callback_arg:
tbutton.connect('clicked', getattr(self, callback),
callback_arg)
else:
tbutton.connect('clicked', getattr(self, callback))
if scroll:
tbutton.connect('scroll_event', getattr(self, callback))
if _new_tooltip_api:
tbutton.set_tooltip_text(tooltip_text)
else:
tbutton.set_tooltip(self.tooltips, tooltip_text, 'Private')
# Axes toolitem, is empty at start, update() adds a menu if >=2 axes
self.axes_toolitem = gtk.ToolItem()
self.insert(self.axes_toolitem, 0)
if _new_tooltip_api:
self.axes_toolitem.set_tooltip_text(
'Select axes that controls affect')
else:
self.axes_toolitem.set_tooltip (
self.tooltips,
tip_text='Select axes that controls affect',
tip_private = 'Private')
align = gtk.Alignment (xalign=0.5, yalign=0.5, xscale=0.0, yscale=0.0)
self.axes_toolitem.add(align)
self.menubutton = gtk.Button ("Axes")
align.add (self.menubutton)
def position_menu (menu):
"""Function for positioning a popup menu.
Place menu below the menu button, but ensure it does not go off
the bottom of the screen.
The default is to popup menu at current mouse position
"""
x0, y0 = self.window.get_origin()
x1, y1, m = self.window.get_pointer()
x2, y2 = self.menubutton.get_pointer()
sc_h = self.get_screen().get_height() # requires GTK+ 2.2 +
w, h = menu.size_request()
x = x0 + x1 - x2
y = y0 + y1 - y2 + self.menubutton.allocation.height
y = min(y, sc_h - h)
return x, y, True
def button_clicked (button, data=None):
self.axismenu.popup (None, None, position_menu, 0,
gtk.get_current_event_time())
self.menubutton.connect ("clicked", button_clicked)
def append_separator(self):
separator = gtk.SeparatorToolItem()
self.insert(separator, self.position)
self.position += 1
def ui_init(self):
self._fullscreen = False
self._showing_info = False
# FIXME: if _thumb_tray becomes some kind of button group, we wouldn't
# have to track which recd is active
self._active_recd = None
self.connect_after('key-press-event', self._key_pressed)
self._active_toolbar_idx = 0
self._toolbar_box = ToolbarBox()
activity_button = ActivityToolbarButton(self)
self._toolbar_box.toolbar.insert(activity_button, 0)
self.set_toolbar_box(self._toolbar_box)
self._toolbar = self.get_toolbar_box().toolbar
tool_group = None
if self.model.get_has_camera():
self._photo_button = RadioToolButton()
self._photo_button.props.group = tool_group
tool_group = self._photo_button
self._photo_button.props.icon_name = 'camera-external'
self._photo_button.props.label = _('Photo')
self._photo_button.mode = constants.MODE_PHOTO
self._photo_button.connect('clicked', self._mode_button_clicked)
self._toolbar.insert(self._photo_button, -1)
self._video_button = RadioToolButton()
self._video_button.props.group = tool_group
self._video_button.props.icon_name = 'media-video'
self._video_button.props.label = _('Video')
self._video_button.mode = constants.MODE_VIDEO
self._video_button.connect('clicked', self._mode_button_clicked)
self._toolbar.insert(self._video_button, -1)
else:
self._photo_button = None
self._video_button = None
self._audio_button = RadioToolButton()
self._audio_button.props.group = tool_group
self._audio_button.props.icon_name = 'media-audio'
self._audio_button.props.label = _('Audio')
self._audio_button.mode = constants.MODE_AUDIO
self._audio_button.connect('clicked', self._mode_button_clicked)
self._toolbar.insert(self._audio_button, -1)
self._toolbar.insert(gtk.SeparatorToolItem(), -1)
self._toolbar_controls = RecordControl(self._toolbar)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
self._toolbar.insert(separator, -1)
self._toolbar.insert(StopButton(self), -1)
self.get_toolbar_box().show_all()
main_box = gtk.VBox()
self.set_canvas(main_box)
main_box.get_parent().modify_bg(gtk.STATE_NORMAL, COLOR_BLACK)
main_box.show()
self._media_view = MediaView()
self._media_view.connect('media-clicked',
self._media_view_media_clicked)
self._media_view.connect('pip-clicked', self._media_view_pip_clicked)
self._media_view.connect('info-clicked', self._media_view_info_clicked)
self._media_view.connect('full-clicked', self._media_view_full_clicked)
self._media_view.connect('tags-changed', self._media_view_tags_changed)
self._media_view.show()
self._controls_hbox = gtk.HBox()
self._controls_hbox.show()
self._shutter_button = ShutterButton()
self._shutter_button.connect("clicked", self._shutter_clicked)
self._controls_hbox.pack_start(self._shutter_button,
expand=True,
fill=False)
self._countdown_image = CountdownImage()
self._controls_hbox.pack_start(self._countdown_image,
expand=True,
fill=False)
self._play_button = PlayButton()
self._play_button.connect('clicked', self._play_pause_clicked)
self._controls_hbox.pack_start(self._play_button, expand=False)
self._playback_scale = PlaybackScale(self.model)
self._controls_hbox.pack_start(self._playback_scale,
expand=True,
fill=True)
self._progress = ProgressInfo()
self._controls_hbox.pack_start(self._progress, expand=True, fill=True)
self._title_label = gtk.Label()
self._title_label.set_markup("<b><span foreground='white'>" +
_('Title:') + '</span></b>')
self._controls_hbox.pack_start(self._title_label, expand=False)
self._title_entry = gtk.Entry()
self._title_entry.modify_bg(gtk.STATE_INSENSITIVE, COLOR_BLACK)
self._title_entry.connect('changed', self._title_changed)
self._controls_hbox.pack_start(self._title_entry,
expand=True,
fill=True,
padding=10)
self._record_container = RecordContainer(self._media_view,
self._controls_hbox)
main_box.pack_start(self._record_container,
expand=True,
fill=True,
padding=6)
self._record_container.show()
self._thumb_tray = HTray()
self._thumb_tray.set_size_request(-1, 150)
main_box.pack_end(self._thumb_tray, expand=False)
self._thumb_tray.show_all()
def __init__(self, handle):
"""Set up the Chutar activity."""
activity.Activity.__init__(self, handle)
# we do not have collaboration features
# make the share option insensitive
self.max_participants = 1
# toolbar with the new toolbar redesign
toolbar_box = ToolbarBox()
activity_button = ActivityButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
title_entry = TitleEntry(self)
toolbar_box.toolbar.insert(title_entry, -1)
title_entry.show()
share_button = ShareButton(self)
toolbar_box.toolbar.insert(share_button, -1)
share_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
hbox = gtk.HBox()
vbox = gtk.VBox()
#se usaran para el marcador
self.label = gtk.Label()
self.label.modify_font(pango.FontDescription("Purisa 14"))
frame = gtk.Frame("Marcador")
#asignacion de variables a widgest de gtk
self.vadjustment = gtk.Adjustment()
self.hadjustment = gtk.Adjustment()
#asignacion de valores por defecto del adjustment
self.vadjustment.set_upper(100)
self.vadjustment.set_value(0)
self.hadjustment.set_upper(100)
self.hadjustment.set_value(0)
#asignacion de propiedades de widgets
self.vslide = gtk.VScale(self.vadjustment)
self.hslide = gtk.HScale(self.hadjustment)
#propiedad para que no se muestre valor del slide
self.vslide.set_draw_value(False)
self.hslide.set_draw_value(False)
#variables globales que se utilizan en los slides
self.increment_x = self.increment_y = 1
self.indicator_x = self.indicator_y = -1
self.goles = 0
#asignacion de variables de widgets
self.drawing_area = gtk.DrawingArea()
self.drawing_area.set_size_request(WIDTH, HEIGHT)
#asignando cancha y arquero
self.cancha = gtk.gdk.pixbuf_new_from_file('images/arcosugar.jpg')
self.portero = gtk.gdk.pixbuf_new_from_file(
'images/goalkeeper_downcenter.png')
#window.connect("destroy", lambda w: gtk.main_quit())
#callbacks al invocar el area de dibujo
self.drawing_area.connect('configure_event', self.__configure_cb)
self.drawing_area.connect('expose-event', self.__expose_cb)
#evento que invoca funcion al presionar cualquier tecla
self.connect('key-press-event', self.__key_press_event_cb)
#anhadiendo widgets dentro del contenedor principal
self.set_canvas(hbox)
hbox.add(vbox)
frame.add(self.label)
vbox.add(frame)
vbox.add(self.drawing_area)
vbox.add(self.hslide)
hbox.add(self.vslide)
#mostrando los widgets
self.show_all()
#invocacion de la funcion que realiza loop del slider horizontal
gobject.timeout_add(DELAY, self.__hslider_move_cb)
def get_toolbar(self, textview):
toolbar = gtk.Toolbar()
toolbar.set_style({
'default': False,
'both': gtk.TOOLBAR_BOTH,
'text': gtk.TOOLBAR_TEXT,
'icons': gtk.TOOLBAR_ICONS
}[CONFIG['client.toolbar']])
tag_widgets = self.tag_widgets[textview] = {}
for icon in ['bold', 'italic', 'underline']:
button = gtk.ToggleToolButton()
button.set_icon_widget(
IconFactory.get_image('tryton-format-%s' % icon,
gtk.ICON_SIZE_SMALL_TOOLBAR))
button.connect('toggled', self.toggle_props, icon, textview)
toolbar.insert(button, -1)
tag_widgets[icon] = button
toolbar.insert(gtk.SeparatorToolItem(), -1)
for name, options, active in [
('family', FAMILIES, FAMILIES.index('normal')),
('size', SIZES, SIZES.index('4')),
]:
try:
combobox = gtk.ComboBoxText()
except AttributeError:
combobox = gtk.combo_box_new_text()
for option in options:
combobox.append_text(option)
combobox.set_active(active)
combobox.set_focus_on_click(False)
combobox.connect('changed', self.change_props, name, textview)
tool = gtk.ToolItem()
tool.add(combobox)
toolbar.insert(tool, -1)
tag_widgets[name] = combobox
toolbar.insert(gtk.SeparatorToolItem(), -1)
button = None
for name in ['left', 'center', 'right', 'justify']:
icon = 'tryton-format-align-%s' % name
button = gtk.RadioToolButton.new_from_widget(button)
button.set_icon_widget(
IconFactory.get_image(icon, gtk.ICON_SIZE_SMALL_TOOLBAR))
button.set_active(icon == 'left')
button.connect('toggled', self.toggle_justification, name,
textview)
toolbar.insert(button, -1)
tag_widgets[name] = button
toolbar.insert(gtk.SeparatorToolItem(), -1)
for icon, label in [
('foreground', _('Foreground')),
# TODO ('background', _('Background')),
]:
button = gtk.ToolButton()
if icon == 'foreground':
button.set_icon_widget(
IconFactory.get_image('tryton-format-color-text',
gtk.ICON_SIZE_SMALL_TOOLBAR))
button.set_label(label)
button.connect('clicked', self.toggle_color, icon, textview)
toolbar.insert(button, -1)
tag_widgets[icon] = button
return toolbar
buttons['MachDown'] = gtk.ToolButton(gtk.STOCK_GO_BACK)
buttons['MachDisp'] = gtk.Button("")
buttons['MachUp'] = gtk.ToolButton(gtk.STOCK_GO_FORWARD)
buttons['ReDown'] = gtk.ToolButton(gtk.STOCK_GO_BACK)
buttons['ReDisp'] = gtk.Button("")
buttons['ReUp'] = gtk.ToolButton(gtk.STOCK_GO_FORWARD)
buttons['NEDown'] = gtk.ToolButton(gtk.STOCK_GO_BACK)
buttons['NEDisp'] = gtk.Button("")
buttons['NEUp'] = gtk.ToolButton(gtk.STOCK_GO_FORWARD)
fig = Figure()
canvas = FigureCanvas(fig) # a gtk.DrawingArea
nav = NavigationToolbar(canvas, win)
nav.set_size_request(250, 35)
sep = [gtk.SeparatorToolItem() for i in range(10)]
toolbar = gtk.HBox(False, 2)
toolbar.pack_start(buttons['New'], False, False, 0)
toolbar.pack_start(buttons['Open'], False, False, 0)
toolbar.pack_start(buttons['Save'], False, False, 0)
toolbar.pack_start(sep[0], False, False, 0)
toolbar.pack_start(nav, False, False, 0)
toolbar.pack_start(sep[1], False, False, 0)
toolbar.pack_start(combobox, False, False, 0)
toolbar.pack_start(sep[2], False, False, 0)
toolbar.pack_start(buttons['ReMesh'], False, False, 0)
toolbar.pack_start(sep[3], False, False, 0)
toolbar.pack_start(buttons['MachDown'], False, False, 0)
toolbar.pack_start(buttons['MachDisp'], False, False, 0)
toolbar.pack_start(buttons['MachUp'], False, False, 0)
def __init__(self):
super(AgendaWindow, self).__init__()
self.set_title("Agenda")
self.set_size_request(500, 400)
self.set_position(gtk.WIN_POS_CENTER)
self.connect("destroy", gtk.main_quit)
# Database parameters
self.page_limit = setup_options.getLimit()
self.current_page = 1
self.items_quantity = 0
self.db = BasicDb()
#Contact id
self.contact_id = 0
# Menu bar
mb = gtk.MenuBar()
filemenu = gtk.Menu()
filem = gtk.MenuItem("_File")
filem.set_submenu(filemenu)
agr = gtk.AccelGroup()
self.add_accel_group(agr)
newi = gtk.ImageMenuItem(gtk.STOCK_NEW, agr)
key, mod = gtk.accelerator_parse("<Control>N")
newi.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
filemenu.append(newi)
sep = gtk.SeparatorMenuItem()
filemenu.append(sep)
exit = gtk.ImageMenuItem(gtk.STOCK_QUIT, agr)
key, mod = gtk.accelerator_parse("<Control>Q")
exit.add_accelerator("activate", agr, key, mod, gtk.ACCEL_VISIBLE)
exit.connect("activate", gtk.main_quit)
newi.connect("activate", self.add_contact)
filemenu.append(exit)
mb.append(filem)
sw = gtk.ScrolledWindow()
sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
toolbar = gtk.Toolbar()
toolbar.set_style(gtk.TOOLBAR_ICONS)
newtb = gtk.ToolButton(gtk.STOCK_NEW)
self.back = gtk.ToolButton(gtk.STOCK_GO_BACK)
self.back.set_sensitive(False)
self.next = gtk.ToolButton(gtk.STOCK_GO_FORWARD)
self.next.set_sensitive(False)
sep = gtk.SeparatorToolItem()
quittb = gtk.ToolButton(gtk.STOCK_QUIT)
toolbar.insert(newtb, 0)
toolbar.insert(self.back, 1)
toolbar.insert(self.next, 2)
toolbar.insert(sep, 3)
toolbar.insert(quittb, 4)
newtb.connect("clicked", self.add_contact)
quittb.connect("clicked", gtk.main_quit)
self.back.connect("clicked", self.previous_page)
self.next.connect("clicked", self.next_page)
vbox = gtk.VBox(False, 3)
vbox.pack_start(mb, False, False, 0)
vbox.pack_start(toolbar, False, False, 0)
vbox.pack_start(sw, True, True, 0)
self.store = self.create_model()
self.treeView = gtk.TreeView(self.store)
self.treeView.connect("row-activated", self.on_activated)
self.treeView.set_rules_hint(True)
self.populate_model()
self.selected = self.treeView.get_selection()
self.selected.connect("changed", self.on_changed)
sw.add(self.treeView)
self.create_columns(self.treeView)
self.enable_next_previous()
hbox = gtk.HBox(True, 3)
self.edit = gtk.Button("Edit")
self.edit.set_size_request(70, 30)
self.edit.set_sensitive(False)
self.edit.connect("clicked", self.edit_contact)
self.label = gtk.Label(" - ")
self.delete = gtk.Button("Delete")
self.delete.set_size_request(70, 30)
self.delete.set_sensitive(False)
self.delete.connect("clicked", self.delete_contact)
hbox.add(self.label)
hbox.add(self.edit)
hbox.add(self.delete)
halign = gtk.Alignment(1, 0, 0, 0)
halign.add(hbox)
vbox.pack_start(halign, False, False, 3)
self.add(vbox)
self.show_all()
def __init__(self, controller, conversation, MainClass, addButton=True):
'''Save the identifier of this conversation and begin to log message'''
self.controller = controller
self.mainClass = MainClass
self.stopped = False
#This identifier enable the check of members change!
self.members = conversation.getMembers()
self.idMyLog = self.members[0]
for mem in self.members[1:len(self.members)]:
self.idMyLog = self.idMyLog + '-' + mem
self.lastUserName = ''
#The identifier of this conversation is the id of conversation
self.idConv = id(conversation)
self.conversation = conversation
#We would save logs in :
self.logDir = os.path.join(self.mainClass.logsDir, \
time.strftime('%B_%Y', time.localtime(time.time()))) #This is created at the first run
#If the log dir not exist create it
if not os.path.exists(self.logDir):
try:
os.mkdir(self.logDir)
except: #in case we can't create the dir with the date
self.logDir = self.mainClass.logsDir
#Create the log FileName
self.logFileName = os.path.join(self.logDir, \
self.idMyLog + '.html')
#Exist already?
if os.path.exists(self.logFileName):
self.logFile = open(self.logFileName, 'r+')
#Ok we have to delete the last string if it is a </body></html>
self.logFile.seek(-15, 2)
lastLine = self.logFile.readline()
if lastLine.find('</html>') != -1:
#Ok, last time we closed the file in the right way
#let seek at the beginning of the line to overwrite
#(15 chars with the new line).
self.logFile.seek(-15, 2)
else:
#Last time we have not closed the file in the right way
#We put a br..
self.logFile.seek(0, 2)
self.logFile.write('\n<span><br/></span>\n')
else:
self.logFile = open(self.logFileName, 'w')
#Head of the document
self.logFile.write('<html>\n')
self.logFile.write(
'<head>\n<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" />\n'
)
convwith = _('Conversation with %s') % self.idMyLog
self.logFile.write('<title>' + convwith +
'</title>\n</head>\n<body>\n')
self.modified = False
#For file send and receive logging
self.p2p = controller.msn.p2p[conversation.switchboard.firstUser]
#Connect the sending and receiving logger
self.sendmessageId = self.controller.conversationManager.connect( \
'send-message', self.logSendMessage)
self.receivemessageId = self.controller.conversationManager.connect( \
'receive-message', self.logReceivedMessage)
self.fileTransferId = self.p2p.connect('file-transfer-accepted',\
self.logFileTransfer)
#Every time the conversationManager send a close-conversation-ui
#execute stop
self.closeUIId = self.controller.conversationManager.connect(\
'close-conversation-ui', self.stop)
if addButton:
#Add a button to the toolbar of this conversation:
self.logButton = gtk.ToolButton(label=_('Logs'))
self.logButton.set_stock_id(gtk.STOCK_DND)
if self.controller.theme.getImage('log'):
imagelog = gtk.Image()
imagelog.set_from_pixbuf(self.controller.theme.getImage('log'))
imagelog.show()
self.logButton.set_icon_widget(imagelog)
self.logButton.connect('clicked', self.mainClass.viewLog,
self.logFileName)
self.logButton.set_tooltip_text(
_('View the logs of this conversation'))
conversation.ui.input.toolbar.insert(gtk.SeparatorToolItem(), -1)
conversation.ui.input.toolbar.insert(self.logButton, -1)
conversation.ui.input.toolbar.show_all()
def __init__(self, handle):
"""Set up the CalculArte activity."""
activity.Activity.__init__(self, handle)
# we do not have collaboration features
# make the share option insensitive
self.max_participants = 1
# toolbar with the new toolbar redesign
toolbar_box = ToolbarBox()
activity_button = ActivityButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
title_entry = TitleEntry(self)
toolbar_box.toolbar.insert(title_entry, -1)
title_entry.show()
share_button = ShareButton(self)
toolbar_box.toolbar.insert(share_button, -1)
share_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
vbox = gtk.VBox()
hbox = gtk.HBox(True)
self.label_historial = gtk.Label()
self.label_historial.set_line_wrap(True)
self.entry_visor = gtk.Entry()
self.table = gtk.Table(5, 5, True)
boton = gtk.Button('boton falso')
self.label_historial.set_text('Ultimo resultado:')
self.set_canvas(hbox)
hbox.add(vbox)
hbox.add(self.label_historial)
vbox.add(self.entry_visor)
vbox.add(self.table)
vbox.add(boton)
OPTIONS.reverse()
for j in range(4):
for i in range(OPT_LENGHT):
button = gtk.Button()
option = OPTIONS.pop()
button.set_label(option)
button.connect('activate', self.__button_cb, self.entry_visor,
boton, self.label_historial)
self.connect('key-press-event', self.__barrido_columnas_cb)
#canvas = self.get_canvas()
#canvas.connect('key-press-event', self.__barrido_columnas_cb)
if option == 'Aceptar':
self.table.attach(button, i, i + 3, j, j + 1)
break
else:
self.table.attach(button, i, i + 1, j, j + 1)
hbox.show_all()
boton.hide()
OPTIONS.reverse()
self._filas_index = 0
self._columnas_index = 0
self._flag_fila_columna = 0
gobject.timeout_add(DELAY, self.__timeout_cb, self.table)
def __init__(self, handle):
activity.Activity.__init__(self, handle, True)
toolbarbox = ToolbarBox()
self._main_view = gtk.VBox()
EventBox.add(self._main_view)
## CONNECTS ##
Toolbars.restart_button.connect("clicked", self._restart_button_cb)
Toolbars.reading_button.connect("clicked", self._read_button_cb)
Toolbars.load_button.connect("clicked", self._load_button_cb)
#Toolbars.credits.connect("clicked", self.Credits)
Toolbars.new_button.connect("clicked", self._new_button_cb)
Toolbars.book_button.connect("clicked", self._edit_book_button_cb,
Toolbars.ColorLetra.get_color())
Toolbars.page_button.connect("clicked", self._edit_page_button_cb,
EventBox)
Toolbars.check_button.connect("clicked", self._check_button_cb,
Toolbars.ColorLetra.get_color())
Toolbars.ColorLetra.set_title(
_('Select color for font and go to home page'))
Toolbars.ColorLetra.connect('notify::color', self.Home)
Toolbars.ColorFondo.set_title(
_('Select color for page and go to home page'))
Toolbars.ColorFondo.connect('notify::color', self.Home)
Toolbars.Fonts.connect('change_selection', self.Home)
Toolbars.Title_Tam.connect('change_selection', self.Home)
Toolbars.ColorTitle.set_title(
_('Select color for title and go to home page'))
Toolbars.ColorTitle.connect('notify::color', self.Home)
Toolbars.tutorial.connect("clicked", self.Tutorial)
# FIN DE CONNECTS #
# The Activity Button:
activity_button = ActivityToolbarButton(self)
# Insert the Activity Toolbar Button in the toolbarbox
toolbarbox.toolbar.insert(activity_button, 0)
toolbarbox.toolbar.insert(gtk.SeparatorToolItem(), -1)
Read_Toolbar(toolbarbox)
Write_Toolbar(toolbarbox)
Text_Toolbar(toolbarbox)
Color_Toolbar(toolbarbox)
Separador = gtk.SeparatorToolItem()
Separador.props.draw = False
Separador.set_expand(True)
toolbarbox.toolbar.insert(Separador, -1)
Ayuda(toolbarbox)
# Stop button
stopbtn = StopButton(self)
toolbarbox.toolbar.insert(stopbtn, -1)
# Set toolbar box
self.set_toolbar_box(toolbarbox)
# Define main view as a vbox container
EventBox.modify_bg(gtk.STATE_NORMAL, Toolbars.ColorFondo.get_color())
self.set_canvas(EventBox)
# Empty Book
self._book = empty_book()
self._start_book(Toolbars.ColorLetra.get_color())
def draw(self):
'''draw the toolbar'''
toolbar_small = self.handler.session.config.get_or_set(
'b_toolbar_small', False)
if toolbar_small:
size = gtk.ICON_SIZE_MENU
else:
size = gtk.ICON_SIZE_LARGE_TOOLBAR
self.settings = self.get_settings()
self.settings.set_long_property('gtk-toolbar-icon-size', size,
'ConversationToolbar.py:37')
# check if we have theme-specific toolbar-icons
image_theme = gui.theme.image_theme
if image_theme.has_custom_toolbar_icons():
theme_tool_font = utils.gtk_ico_image_load(image_theme.tool_font,
size)
theme_tool_font_color = utils.gtk_ico_image_load(
image_theme.tool_font_color, size)
theme_tool_emotes = utils.gtk_ico_image_load(
image_theme.tool_emotes, size)
theme_tool_nudge = utils.gtk_ico_image_load(
image_theme.tool_nudge, size)
theme_tool_invite = utils.gtk_ico_image_load(
image_theme.tool_invite, size)
theme_tool_clean = utils.gtk_ico_image_load(
image_theme.tool_clean, size)
theme_tool_file_transfer = utils.gtk_ico_image_load(
image_theme.tool_file_transfer, size)
self.theme_tool_block = utils.gtk_ico_image_load(
image_theme.tool_block, size)
self.theme_tool_unblock = utils.gtk_ico_image_load(
image_theme.tool_unblock, size)
else:
theme_tool_font = gtk.STOCK_SELECT_FONT
theme_tool_font_color = gtk.STOCK_SELECT_COLOR
emote_theme = gui.theme.emote_theme
theme_tool_emotes = utils.gtk_ico_image_load(
emote_theme.emote_to_path(':D', True), size)
theme_tool_nudge = utils.gtk_ico_image_load(
emote_theme.emote_to_path(':S', True), size)
theme_tool_invite = gtk.STOCK_ADD
theme_tool_clean = gtk.STOCK_CLEAR
theme_tool_file_transfer = gtk.STOCK_GO_UP
self.theme_tool_block = gtk.STOCK_STOP
self.theme_tool_unblock = gtk.STOCK_YES
if self.session.config.b_avatar_on_left:
self.theme_tool_hide_avatar = gtk.STOCK_GO_BACK
self.theme_tool_show_avatar = gtk.STOCK_GO_FORWARD
else:
self.theme_tool_hide_avatar = gtk.STOCK_GO_FORWARD
self.theme_tool_show_avatar = gtk.STOCK_GO_BACK
theme_tool_call = utils.gtk_ico_image_load(image_theme.call, size)
theme_tool_video = utils.gtk_ico_image_load(image_theme.video, size)
theme_tool_av = utils.gtk_ico_image_load(image_theme.av, size)
self.font = gtk.ToolButton(theme_tool_font)
self.font.set_label(_('Select font'))
self.font.set_tooltip_text(_('Select font'))
self.font.connect('clicked',
lambda *args: self.handler.on_font_selected())
self.color = gtk.ToolButton(theme_tool_font_color)
self.color.set_label(_('Select font color'))
self.color.set_tooltip_text(_('Select font color'))
self.color.connect('clicked',
lambda *args: self.handler.on_color_selected())
self.emotes = gtk.ToolButton()
self.emotes.set_icon_widget(theme_tool_emotes)
self.emotes.set_label(_('Send an emoticon'))
self.emotes.set_tooltip_text(_('Send an emoticon'))
self.emotes.connect('clicked',
lambda *args: self.handler.on_emotes_selected())
self.nudge = gtk.ToolButton()
self.nudge.set_icon_widget(theme_tool_nudge)
self.nudge.set_label(_('Request attention'))
self.nudge.set_tooltip_text(_('Request attention'))
self.nudge.connect(
'clicked',
lambda *args: self.handler.on_notify_attention_selected())
self.invite = gtk.ToolButton(theme_tool_invite)
self.invite.set_label(_('Invite a buddy'))
self.invite.set_tooltip_text(_('Invite a buddy'))
self.invite.connect('clicked',
lambda *args: self.handler.on_invite_selected())
self.clean = gtk.ToolButton(theme_tool_clean)
self.clean.set_label(_('Clean the conversation'))
self.clean.set_tooltip_text(_('Clean the conversation'))
self.clean.connect('clicked',
lambda *args: self.handler.on_clean_selected())
self.invite_file_transfer = gtk.ToolButton(theme_tool_file_transfer)
self.invite_file_transfer.set_label(_('Send a file'))
self.invite_file_transfer.set_tooltip_text(_('Send a file'))
self.invite_file_transfer.connect(
'clicked',
lambda *args: self.handler.on_invite_file_transfer_selected())
self.ublock = gtk.ToolButton(self.theme_tool_block)
self.ublock.set_label(_('Block/Unblock contact'))
self.ublock.set_tooltip_text(_('Block/Unblock contact'))
self.ublock.connect('clicked',
lambda *args: self.handler.on_ublock_selected())
self.toggle_avatar = gtk.ToolButton(self.theme_tool_show_avatar)
self.toggle_avatar.set_label(_('Hide/Show avatar'))
self.update_toggle_avatar_icon(self.session.config.b_show_info)
self.toggle_avatar.connect(
'clicked', lambda *args: self.handler.on_toggle_avatar_selected())
self.invite_video_call = gtk.ToolButton(theme_tool_video)
self.invite_video_call.set_label(_('Video Call'))
self.invite_video_call.set_tooltip_text(_('Video Call'))
self.invite_video_call.connect(
'clicked',
lambda *args: self.handler.on_invite_video_call_selected())
self.invite_audio_call = gtk.ToolButton(theme_tool_call)
self.invite_audio_call.set_label(_('Voice Call'))
self.invite_audio_call.set_tooltip_text(_('Voice Call'))
self.invite_audio_call.connect(
'clicked',
lambda *args: self.handler.on_invite_voice_call_selected())
self.invite_av_call = gtk.ToolButton(theme_tool_av)
self.invite_av_call.set_label(_('Audio/Video Call'))
self.invite_av_call.set_tooltip_text(_('Audio/Video Call'))
self.invite_av_call.connect(
'clicked', lambda *args: self.handler.on_invite_av_call_selected())
self.add(self.font)
self.add(self.color)
self.add(gtk.SeparatorToolItem())
self.add(self.emotes)
self.add(self.nudge)
if self.handler.session_service_supported(
e3.Session.SERVICE_CONTACT_INVITE):
self.add(gtk.SeparatorToolItem())
self.add(self.invite)
if self.handler.session_service_supported(
e3.Session.SERVICE_FILETRANSFER):
self.add(self.invite_file_transfer)
self.add(gtk.SeparatorToolItem())
if self.handler.session_service_supported(e3.Session.SERVICE_CALLS):
self.add(self.invite_video_call)
self.add(self.invite_audio_call)
self.add(self.invite_av_call)
self.add(gtk.SeparatorToolItem())
self.add(self.clean)
if self.handler.session_service_supported(
e3.Session.SERVICE_CONTACT_BLOCK):
self.add(self.ublock)
self.add(gtk.SeparatorToolItem())
self.add(self.toggle_avatar)
def __init__(self, browser):
gtk.Toolbar.__init__(self)
self._browser = browser
# navigational buttons
self._back = gtk.ToolButton(gtk.STOCK_GO_BACK)
self._back.set_tooltip(gtk.Tooltips(), _('Back'))
self._back.props.sensitive = False
self._back.connect('clicked', self._go_back_cb)
self.insert(self._back, -1)
self._forward = gtk.ToolButton(gtk.STOCK_GO_FORWARD)
self._forward.set_tooltip(gtk.Tooltips(), _('Forward'))
self._forward.props.sensitive = False
self._forward.connect('clicked', self._go_forward_cb)
self.insert(self._forward, -1)
self._forward.show()
self._stop_and_reload = gtk.ToolButton(gtk.STOCK_REFRESH)
self._stop_and_reload.set_tooltip(gtk.Tooltips(),
_('Stop and reload current page'))
self._stop_and_reload.connect('clicked', self._stop_and_reload_cb)
self.insert(self._stop_and_reload, -1)
self._stop_and_reload.show()
self._loading = False
self.insert(gtk.SeparatorToolItem(), -1)
# zoom buttons
self._zoom_in = gtk.ToolButton(gtk.STOCK_ZOOM_IN)
self._zoom_in.set_tooltip(gtk.Tooltips(), _('Zoom in'))
self._zoom_in.connect('clicked', self._zoom_in_cb)
self.insert(self._zoom_in, -1)
self._zoom_in.show()
self._zoom_out = gtk.ToolButton(gtk.STOCK_ZOOM_OUT)
self._zoom_out.set_tooltip(gtk.Tooltips(), _('Zoom out'))
self._zoom_out.connect('clicked', self._zoom_out_cb)
self.insert(self._zoom_out, -1)
self._zoom_out.show()
self._zoom_hundred = gtk.ToolButton(gtk.STOCK_ZOOM_100)
self._zoom_hundred.set_tooltip(gtk.Tooltips(), _('100% zoom'))
self._zoom_hundred.connect('clicked', self._zoom_hundred_cb)
self.insert(self._zoom_hundred, -1)
self._zoom_hundred.show()
self.insert(gtk.SeparatorToolItem(), -1)
# location entry
self._entry = gtk.Entry()
self._entry.connect('activate', self._entry_activate_cb)
self._current_uri = None
entry_item = gtk.ToolItem()
entry_item.set_expand(True)
entry_item.add(self._entry)
self._entry.show()
self.insert(entry_item, -1)
entry_item.show()
# scale other content besides from text as well
self._browser.set_full_content_zoom(True)
self._browser.connect("title-changed", self._title_changed_cb)
def __init__(self, mod_consseq_builder, is_mainwindow=False, id_num=-1):
gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL)
self.is_mainwindow = is_mainwindow
self.id_num = id_num
self.cons = mod_consseq_builder
self.infowin = None
# initialize the observable events for this class
self.defineObservableEvents(['consensus_saved'])
# initialize the window GUI elements and event handlers
self.connect('destroy', self.destroyWindow)
self.vbox = gtk.VBox(False, 0)
self.add(self.vbox)
# create the menus and toolbar
menuxml = '''<menubar name="menubar">
<menu action="File">
<menuitem action="Save_Consens" />
<separator />
<menuitem action="Export_Alignment" />
<menuitem action="Export_Consensus" />
<menuitem action="Export_Raw" />
<separator />
<menuitem action="File_Info" />
<separator />
<menuitem action="Close" />
</menu>
<menu action="Edit">
<menuitem action="Undo" />
<menuitem action="Redo" />
<separator />
<menuitem action="Copy" />
<menuitem action="Delete" />
<menuitem action="Modify" />
<separator />
<menuitem action="Recalc_Consens" />
</menu>
<menu action="View">
<menuitem action="Scroll_Lock" />
</menu>
</menubar>
<popup name="editpopup">
<menuitem action="Copy" />
<menuitem action="Delete" />
<menuitem action="Modify" />
<separator />
<menuitem action="Recalc_Consens" />
</popup>
<toolbar name="toolbar">
<toolitem action="File_Info" />
<separator />
<toolitem action="Save_Consens" />
<separator />
<toolitem action="Undo" />
<toolitem action="Redo" />
<separator />
<toolitem action="Copy" />
<toolitem action="Delete" />
<toolitem action="Modify" />
</toolbar>'''
# These actions are (usually) always enabled.
self.main_ag = gtk.ActionGroup('main_actions')
self.main_ag.add_actions([
('File', None, '_File'),
('Save_Consens', gtk.STOCK_SAVE,
'_Save working sequence to project', None,
'Save the working sequence to the project', self.saveConsensus),
('Export_Consensus', None, 'Export w_orking sequence...', None,
'Export the working sequence to a file', self.exportConsensus),
('Export_Raw', None, 'Export _raw sequence(s)...', None,
'Export the un-edited sequence(s) to a file',
self.exportRawSequence),
('File_Info', gtk.STOCK_INFO, '_Information...', None,
'View detailed information about the file(s)', self.fileInfo),
('Close', gtk.STOCK_CLOSE, '_Close', None, 'Close this window',
self.closeWindow), ('Edit', None, '_Edit'),
('Recalc_Consens', None, '_Recalculate working seq.', None,
'Recalculate the working sequence', self.recalcConsensus),
('View', None, '_View')
])
# These actions are enabled only when there are two sequencing traces in the window.
self.twotrace_ag = gtk.ActionGroup('twotrace_actions')
self.twotrace_ag.add_actions([
('Export_Alignment', None, 'Export _alignment...', None,
'Export the aligned forward and reverse sequences',
self.exportAlignment)
])
self.twotrace_ag.add_toggle_actions([
('Scroll_Lock', None, '_Synchronize trace scrolling', None,
'Synchronizes the scrolling of the forward and reverse traces',
self.lockScrolling, True)
])
# these actions are for common edit commands
self.edit_ag = gtk.ActionGroup('edite_actions')
self.edit_ag.add_actions([
('Undo', gtk.STOCK_UNDO, '_Undo', '<ctl>z',
'Undo the last change to the working sequence',
self.undoConsChange),
('Redo', gtk.STOCK_REDO, '_Redo', '<ctl>y',
'Redo the last change to the working sequence',
self.redoConsChange)
])
# these actions are only enabled when there is an active selection
self.sel_edit_ag = gtk.ActionGroup('selected_edit_actions')
self.sel_edit_ag.add_actions([
('Copy', gtk.STOCK_COPY, '_Copy selected base(s) to clipboard',
'<ctl>c', 'Copy the selected base(s) to the system clipboard',
self.copyConsBases),
('Delete', gtk.STOCK_DELETE, '_Delete selected base(s)', None,
'Delete the selected base(s) from the working sequence',
self.deleteConsBases),
('Modify', gtk.STOCK_EDIT, '_Modify selected base(s)...', None,
'Edit the selected base(s)', self.editConsBases)
])
self.uim = gtk.UIManager()
self.add_accel_group(self.uim.get_accel_group())
self.uim.insert_action_group(self.main_ag, 0)
self.uim.insert_action_group(self.twotrace_ag, 0)
self.uim.insert_action_group(self.edit_ag, 0)
self.uim.insert_action_group(self.sel_edit_ag, 0)
self.uim.add_ui_from_string(menuxml)
self.vbox.pack_start(self.uim.get_widget('/menubar'),
expand=False,
fill=False)
toolbar_hbox = gtk.HBox()
self.uim.get_widget('/toolbar').set_show_arrow(False)
self.uim.get_widget('/toolbar').set_icon_size(
gtk.ICON_SIZE_LARGE_TOOLBAR)
self.uim.get_widget('/toolbar').set_style(gtk.TOOLBAR_ICONS)
toolbar_hbox.pack_start(self.uim.get_widget('/toolbar'),
expand=False,
fill=False)
self.vbox.pack_start(toolbar_hbox, expand=False, fill=False)
# disable some menus/toolbar buttons by default
self.edit_ag.get_action('Undo').set_sensitive(False)
self.edit_ag.get_action('Redo').set_sensitive(False)
self.sel_edit_ag.set_sensitive(False)
self.loadSequenceTraces()
# If there is only one trace file, disable the actions that require two traces.
if self.numseqs < 2:
self.twotrace_ag.set_sensitive(False)
# get the trace file(s) toolbar
trace_tb = self.stlayout.getTraceToolBar()
for cnt in range(0, 2):
blank = gtk.SeparatorToolItem()
blank.set_draw(False)
#self.uim.get_widget('/toolbar').insert(blank, 0)
trace_tb.insert(blank, 0)
toolbar_hbox.pack_start(trace_tb, True, True)
# add a consensus sequence status bar at the bottom of the window
sbar = ConsensSeqStatusBar(self.cons)
self.vbox.pack_start(sbar, False)
self.vbox.show_all()
self.vbox.show()
# by default, do not show the "Save_Consens" action UI elements
self.main_ag.get_action('Save_Consens').set_visible(False)
self.setDefaultGeometry()
self.show()
self.set_focus(None)
def createTraceToolBar(self):
toolbar = gtk.Toolbar()
#toolbar.set_orientation(gtk.ORIENTATION_VERTICAL)
#toolbar.set_icon_size(gtk.ICON_SIZE_MENU)
toolbar.set_icon_size(gtk.ICON_SIZE_LARGE_TOOLBAR)
toolbar.set_style(gtk.TOOLBAR_ICONS)
toolbar.set_show_arrow(False)
# build the zoom controls
self.zoomin_button = gtk.ToolButton(gtk.STOCK_ZOOM_IN)
self.zoomin_button.set_homogeneous(False)
self.zoomin_button.set_tooltip_text('Zoom in')
self.zoomin_button.connect('clicked', self.zoomButtons, 1)
toolbar.insert(self.zoomin_button, -1)
self.zoomout_button = gtk.ToolButton(gtk.STOCK_ZOOM_OUT)
self.zoomout_button.set_homogeneous(False)
self.zoomout_button.set_tooltip_text('Zoom out')
self.zoomout_button.connect('clicked', self.zoomButtons, -1)
toolbar.insert(self.zoomout_button, -1)
self.zoom_combo = gtk.combo_box_new_text()
for zoom in self.zoom_levels:
self.zoom_combo.append_text(str(zoom) + '%')
self.zoom_combo.set_active(self.curr_zoom)
self.zoom_combo.connect('changed', self.zoomComboBox)
# place the combo box in a VButtonBox to prevent it from expanding vertically
vbox = gtk.VButtonBox()
vbox.pack_start(self.zoom_combo, False)
t_item = gtk.ToolItem()
t_item.add(vbox)
t_item.set_tooltip_text('Adjust the zoom level')
t_item.set_expand(False)
toolbar.insert(t_item, -1)
toolbar.insert(gtk.SeparatorToolItem(), -1)
# build the y scale adjustment slider
t_item = gtk.ToolItem()
t_item.add(gtk.Label('Y:'))
toolbar.insert(t_item, -1)
self.vscale_adj = gtk.Adjustment(0, 0, 0)
hslider = gtk.HScale(self.vscale_adj)
hslider.set_draw_value(False)
self.initYScaleSlider(self.selected_seqtv)
sizereq = hslider.size_request()
#hslider.set_size_request(sizereq[0], 100)
hslider.set_size_request(60, sizereq[1])
self.y_slider = gtk.ToolItem()
self.y_slider.add(hslider)
self.y_slider.set_tooltip_text('Adjust the Y scale of the trace view')
toolbar.insert(self.y_slider, -1)
self.vscale_adj.connect('value_changed', self.yScaleChanged)
toolbar.insert(gtk.SeparatorToolItem(), -1)
# build the toggle button for phred scores
toggle = gtk.CheckButton()
toggle.set_label('conf. scores')
toggle.set_active(True)
toggle.connect('toggled', self.showConfToggled)
# place the toggle button in a VButtonBox to prevent it from expanding vertically
vbox = gtk.VButtonBox()
vbox.pack_start(toggle, False)
t_item = gtk.ToolItem()
t_item.add(vbox)
t_item.set_tooltip_text('Turn the display of phred scores on or off')
t_item.set_expand(False)
toolbar.insert(t_item, -1)
# if we got two sequences, build a combo box to choose between them
if len(self.seqt_viewers) == 2:
trace_combo = gtk.combo_box_new_text()
# see if the forward trace is first or second
if self.seqt_viewers[0].getSequenceTrace().isReverseComplemented():
trace_combo.append_text('Reverse:')
trace_combo.append_text('Forward:')
else:
trace_combo.append_text('Forward:')
trace_combo.append_text('Reverse:')
trace_combo.append_text('Both:')
trace_combo.set_active(0)
trace_combo.connect('changed', self.traceComboBox)
# place the combo box in a VButtonBox to prevent it from expanding vertically
vbox = gtk.VButtonBox()
vbox.pack_start(trace_combo, False)
t_item = gtk.ToolItem()
t_item.add(vbox)
#t_item.set_tooltip_text('Adjust the zoom level')
toolbar.insert(t_item, 0)
trace_combo.set_active(2)
return toolbar
def __init__(self, handle):
super(Chat, self).__init__(handle)
smilies.init()
self.entry = None
self.chatbox = None
root = self.make_root()
self.set_canvas(root)
root.show_all()
self.entry.grab_focus()
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
toolbar_box.toolbar.insert(ActivityButton(self), -1)
toolbar_box.toolbar.insert(TitleEntry(self), -1)
share_button = ShareButton(self)
toolbar_box.toolbar.insert(share_button, -1)
separator = gtk.SeparatorToolItem()
toolbar_box.toolbar.insert(separator, -1)
self._smiley = RadioMenuButton(icon_name='smilies')
self._smiley.palette = Palette(_('Insert smiley'))
self._smiley.props.sensitive = False
toolbar_box.toolbar.insert(self._smiley, -1)
table = self._create_pallete_smiley_table()
table.show_all()
self._smiley.palette.set_content(table)
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
toolbar_box.toolbar.insert(StopButton(self), -1)
toolbar_box.show_all()
pservice = presenceservice.get_instance()
self.owner = pservice.get_owner()
# Chat is room or one to one:
self._chat_is_room = False
self.text_channel = None
if self.shared_activity:
# we are joining the activity
self.connect('joined', self._joined_cb)
if self.get_shared():
# we have already joined
self._joined_cb(self)
elif handle.uri:
# XMPP non-Sugar incoming chat, not sharable
share_button.props.visible = False
self._one_to_one_connection(handle.uri)
else:
# we are creating the activity
if not self.metadata or self.metadata.get(
'share-scope',
activity.SCOPE_PRIVATE) == activity.SCOPE_PRIVATE:
# if we are in private session
self._alert(_('Off-line'), _('Share, or invite someone.'))
self.connect('shared', self._shared_cb)
def make_toolbar(self, toolbar, tips, use_stock_icons):
# bold tool
self.bold = self._make_toggle_button(
toolbar, tips, "Bold", "bold.png", gtk.STOCK_BOLD,
lambda: self._editor.get_textview().toggle_font_mod("bold"),
use_stock_icons)
# italic tool
self.italic = self._make_toggle_button(
toolbar, tips, "Italic", "italic.png", gtk.STOCK_ITALIC,
lambda: self._editor.get_textview().toggle_font_mod("italic"),
use_stock_icons)
# underline tool
self.underline = self._make_toggle_button(
toolbar, tips, "Underline", "underline.png", gtk.STOCK_UNDERLINE,
lambda: self._editor.get_textview().toggle_font_mod("underline"),
use_stock_icons)
# strikethrough
self.strike = self._make_toggle_button(
toolbar, tips, "Strike", "strike.png", gtk.STOCK_STRIKETHROUGH,
lambda: self._editor.get_textview().toggle_font_mod("strike"),
use_stock_icons)
# fixed-width tool
self.fixed_width = self._make_toggle_button(
toolbar, tips, "Monospace", "fixed-width.png", None,
lambda: self._editor.get_textview().toggle_font_mod("tt"),
use_stock_icons)
# link
self.link = self._make_toggle_button(toolbar, tips, "Make Link",
"link.png", None,
self.on_toggle_link,
use_stock_icons)
# no wrap tool
self.no_wrap = self._make_toggle_button(
toolbar, tips, "No Wrapping", "no-wrap.png", None,
lambda: self._editor.get_textview().toggle_font_mod("nowrap"),
use_stock_icons)
# family combo
self.font_family_combo = FontSelector()
self.font_family_combo.set_size_request(150, 25)
item = gtk.ToolItem()
item.add(self.font_family_combo)
tips.set_tip(item, "Font Family")
toolbar.insert(item, -1)
self.font_family_id = self.font_family_combo.connect(
"changed", lambda w: self.on_family_set())
self._font_ui_signals.append(
FontUI(self.font_family_combo, self.font_family_id))
# font size
DEFAULT_FONT_SIZE = 10
self.font_size_button = gtk.SpinButton(
gtk.Adjustment(value=DEFAULT_FONT_SIZE,
lower=2,
upper=500,
step_incr=1))
self.font_size_button.set_size_request(-1, 25)
#self.font_size_button.set_range(2, 100)
self.font_size_button.set_value(DEFAULT_FONT_SIZE)
self.font_size_button.set_editable(False)
item = gtk.ToolItem()
item.add(self.font_size_button)
tips.set_tip(item, "Font Size")
toolbar.insert(item, -1)
self.font_size_id = self.font_size_button.connect(
"value-changed",
lambda w: self.on_font_size_change(self.font_size_button.get_value(
)))
self._font_ui_signals.append(
FontUI(self.font_size_button, self.font_size_id))
# font fg color
# TODO: code in proper default color
self.fg_color_button = FgColorTool(14, 15, (0, 0, 0))
self.fg_color_button.connect(
"set-color", lambda w, color: self.on_color_set("fg", color))
tips.set_tip(self.fg_color_button, "Set Text Color")
toolbar.insert(self.fg_color_button, -1)
# font bg color
self.bg_color_button = BgColorTool(14, 15, (65535, 65535, 65535))
self.bg_color_button.connect(
"set-color", lambda w, color: self.on_color_set("bg", color))
tips.set_tip(self.bg_color_button, "Set Background Color")
toolbar.insert(self.bg_color_button, -1)
# separator
toolbar.insert(gtk.SeparatorToolItem(), -1)
# left tool
self.left_align = self._make_toggle_button(
toolbar, tips, "Left Align", "alignleft.png",
gtk.STOCK_JUSTIFY_LEFT, lambda: self.on_justify("left"),
use_stock_icons)
# center tool
self.center_align = self._make_toggle_button(
toolbar, tips, "Center Align", "aligncenter.png",
gtk.STOCK_JUSTIFY_CENTER, lambda: self.on_justify("center"),
use_stock_icons)
# right tool
self.right_align = self._make_toggle_button(
toolbar, tips, "Right Align", "alignright.png",
gtk.STOCK_JUSTIFY_RIGHT, lambda: self.on_justify("right"),
use_stock_icons)
# justify tool
self.fill_align = self._make_toggle_button(
toolbar, tips, "Justify Align", "alignjustify.png",
gtk.STOCK_JUSTIFY_FILL, lambda: self.on_justify("fill"),
use_stock_icons)
# bullet list tool
self.bullet = self._make_toggle_button(toolbar, tips, "Bullet List",
"bullet.png", None,
lambda: self.on_bullet_list(),
use_stock_icons)
def __init__(self, p_mwindow):
"""
p_mwindow: un 'MainWindow'.
Retorna: un 'ContextToolbar'.
Crea un nuevo 'ContextToolbar'.
"""
gtk.Toolbar.__init__(self)
self._mwindow = p_mwindow
self.set_style(gtk.TOOLBAR_ICONS)
self.connect("button-press-event", self.on_button_press_event)
root = os.path.abspath(os.path.join(__file__, os.pardir, os.pardir))
# Boton para mostrar el editor.
img = gtk.Image()
img.set_from_file(os.path.join(root, "images", "file.png"))
self._file = gtk.ToolButton(img, "New")
self._file.set_tooltip_text("New M-File")
self._file.connect("clicked", self.on_file_clicked)
self.insert(self._file, -1)
# Separador.
self.insert(gtk.SeparatorToolItem(), -1)
# Boton cortar.
img = gtk.Image()
img.set_from_file(os.path.join(root, "images", "cut.png"))
self._cut = gtk.ToolButton(img, "Cut")
self._cut.set_tooltip_text("Cut")
self._cut.connect("clicked", self.on_cut_clicked)
self.insert(self._cut, -1)
# Boton copiar.
img = gtk.Image()
img.set_from_file(os.path.join(root, "images", "copy.png"))
self._copy = gtk.ToolButton(img, "Copy")
self._copy.set_tooltip_text("Copy")
self._copy.connect("clicked", self.on_copy_clicked)
self.insert(self._copy, -1)
# Boton pegar.
img = gtk.Image()
img.set_from_file(os.path.join(root, "images", "paste.png"))
self._paste = gtk.ToolButton(img, "Paste")
self._paste.set_tooltip_text("Paste")
self._paste.connect("clicked", self.on_paste_clicked)
self.insert(self._paste, -1)
# Separador.
self.insert(gtk.SeparatorToolItem(), -1)
# Boton para mostrar la ayuda.
img = gtk.Image()
img.set_from_file(os.path.join(root, "images", "help.png"))
help = gtk.ToolButton(img, "Help")
help.set_tooltip_text("Help")
help.connect("clicked", self.on_help_clicked)
self.insert(help, -1)
# Separador.
self.insert(gtk.SeparatorToolItem(), -1)
# Label 'Current Directory:'
item = gtk.ToolItem()
label = gtk.Label("Current Director_y: ")
label.set_use_underline(True)
label.set_mnemonic_widget(p_mwindow.get_combo())
item.add(label)
self.insert(item, -1)
# Boton para seleccionar un directorio.
browse = gtk.ToolItem()
browse.add(gtk.Button("..."))
browse.set_tooltip_text("Browse for folder")
browse.child.connect("clicked", self.on_browse_clicked)
self.insert(browse, -1)
def __init__(self, handle):
print "running activity init", handle
Activity.__init__(self, handle)
print "activity running"
self._logger = logging.getLogger('scribble-activity')
toolbox = ActivityToolbox(self)
self.set_toolbox(toolbox)
toolbox.show()
pencilbtn = sugar.graphics.radiotoolbutton.RadioToolButton()
pencilbtn.set_named_icon('tool-pencil')
pencilbtn.set_tooltip(_("Pencil"))
pencilbtn.connect('toggled', self._pencil_cb)
circlebtn = sugar.graphics.radiotoolbutton.RadioToolButton()
circlebtn.set_named_icon('tool-shape-ellipse')
circlebtn.set_tooltip(_("Ellipse"))
circlebtn.connect('toggled', self._circle_cb)
circlebtn.set_group(pencilbtn)
rectbtn = sugar.graphics.radiotoolbutton.RadioToolButton()
rectbtn.set_named_icon('tool-shape-rectangle')
rectbtn.set_tooltip(_("Rectangle"))
rectbtn.connect('toggled', self._rect_cb)
rectbtn.set_group(circlebtn)
polybtn = sugar.graphics.radiotoolbutton.RadioToolButton()
polybtn.set_named_icon('tool-shape-freeform')
polybtn.set_tooltip(_("Shape"))
polybtn.connect('toggled', self._poly_cb)
polybtn.set_group(rectbtn)
sep = gtk.SeparatorToolItem()
sep.set_expand(False)
sep.set_draw(True)
erasebtn = sugar.graphics.radiotoolbutton.RadioToolButton()
erasebtn.set_named_icon('tool-eraser')
erasebtn.set_tooltip(_("Erase"))
erasebtn.connect('toggled', self._erase_cb)
erasebtn.set_group(polybtn)
toolbar = gtk.Toolbar()
toolbar.insert(pencilbtn, -1)
toolbar.insert(circlebtn, -1)
toolbar.insert(rectbtn, -1)
toolbar.insert(polybtn, -1)
toolbar.insert(sep, -1)
toolbar.insert(erasebtn, -1)
sep = gtk.SeparatorToolItem()
sep.set_expand(True)
sep.set_draw(False)
toolbar.insert(sep, -1)
exportbtn = ExportButton(self)
toolbar.insert(exportbtn, -1)
exportbtn.show()
toolbox.add_toolbar(_('Toolbox'), toolbar)
toolbar.show_all()
self._scribblewidget = scribblewidget.ScribbleWidget()
self._scribblewidget.connect('item-added', \
self.scribblewidget_item_added_cb)
colors = profile.get_color()
self._scribblewidget.set_fill_color(colors.get_fill_color())
self._scribblewidget.set_stroke_color(colors.get_stroke_color())
self._scribblewidget.set_tool('pencil')
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.add(self._scribblewidget)
self.set_canvas(sw)
sw.show_all()
self.cmdtube = None # Shared session
self.initiating = False
# get the Presence Service
self.pservice = presenceservice.get_instance()
# Buddy object for you
owner = self.pservice.get_owner()
self.owner = owner
self.connect('shared', self._shared_cb)
self.connect('joined', self._joined_cb)
def __init__(self, handle):
sugar.activity.activity.Activity.__init__(self, handle)
self.data_file = None
self.set_title(_('Terminal Activity'))
# Non-working attempt to hide the Escape key from Sugar.
#self.connect('key-press-event', self._key_press_cb)
toolbox = sugar.activity.activity.ActivityToolbox(self)
editbar = sugar.activity.activity.EditToolbar()
toolbox.add_toolbar(_('Edit'), editbar)
editbar.show()
editbar.undo.props.visible = False
editbar.redo.props.visible = False
editbar.separator.props.visible = False
editbar.copy.connect('clicked', self._copy_cb)
editbar.copy.props.accelerator = '<Ctrl><Shift>C'
editbar.paste.connect('clicked', self._paste_cb)
editbar.paste.props.accelerator = '<Ctrl><Shift>V'
newtabbtn = sugar.graphics.toolbutton.ToolButton('list-add')
newtabbtn.set_tooltip(_("Open New Tab"))
newtabbtn.props.accelerator = '<Ctrl><Shift>T'
newtabbtn.connect('clicked', self._open_tab_cb)
deltabbtn = sugar.graphics.toolbutton.ToolButton('list-remove')
deltabbtn.set_tooltip(_("Close Tab"))
deltabbtn.props.accelerator = '<Ctrl><Shift>X'
deltabbtn.connect('clicked', self._close_tab_cb)
tabsep = gtk.SeparatorToolItem()
tabsep.set_expand(True)
tabsep.set_draw(False)
# Add a button that will be used to become root easily.
rootbtn = sugar.graphics.toolbutton.ToolButton('activity-become-root')
rootbtn.set_tooltip(_('Become root'))
rootbtn.connect('clicked', self._become_root_cb)
prevtabbtn = sugar.graphics.toolbutton.ToolButton('go-previous')
prevtabbtn.set_tooltip(_("Previous Tab"))
prevtabbtn.props.accelerator = '<Ctrl><Shift>Left'
prevtabbtn.connect('clicked', self._prev_tab_cb)
nexttabbtn = sugar.graphics.toolbutton.ToolButton('go-next')
nexttabbtn.set_tooltip(_("Next Tab"))
nexttabbtn.props.accelerator = '<Ctrl><Shift>Right'
nexttabbtn.connect('clicked', self._next_tab_cb)
tabbar = gtk.Toolbar()
tabbar.insert(newtabbtn, -1)
tabbar.insert(deltabbtn, -1)
tabbar.insert(tabsep, -1)
tabbar.insert(rootbtn, -1)
tabbar.insert(prevtabbtn, -1)
tabbar.insert(nexttabbtn, -1)
tabbar.show_all()
toolbox.add_toolbar(_('Tab'), tabbar)
activity_toolbar = toolbox.get_activity_toolbar()
activity_toolbar.share.props.visible = False
activity_toolbar.keep.props.visible = False
fullscreenbtn = sugar.graphics.toolbutton.ToolButton('view-fullscreen')
fullscreenbtn.set_tooltip(_("Fullscreen"))
fullscreenbtn.props.accelerator = '<Alt>Enter'
fullscreenbtn.connect('clicked', self._fullscreen_cb)
activity_toolbar.insert(fullscreenbtn, 2)
fullscreenbtn.show()
self.set_toolbox(toolbox)
toolbox.show()
self.notebook = gtk.Notebook()
self.notebook.set_property("tab-pos", gtk.POS_BOTTOM)
self.notebook.set_scrollable(True)
self.notebook.show()
self.set_canvas(self.notebook)
self._create_tab(None)
def __init__(self, handle):
if os.path.exists('/tmp/1'):
os.remove('/tmp/1')
"""Set up the HelloWorld activity."""
activity.Activity.__init__(self, handle)
if os.path.exists('/tmp/2'):
os.remove('/tmp/2')
# we do not have collaboration features
# make the share option insensitive
self.max_participants = 1
# toolbar with the new toolbar redesign
toolbar_box = ToolbarBox()
activity_button = ActivityButton(self)
toolbar_box.toolbar.insert(activity_button, 0)
activity_button.show()
title_entry = TitleEntry(self)
#toolbar_box.toolbar.insert(title_entry, -1)
toolbar_box.toolbar.insert(title_entry, -1)
title_entry.show()
share_button = ShareButton(self)
toolbar_box.toolbar.insert(share_button, -1)
share_button.show()
keep_button = KeepButton(self)
toolbar_box.toolbar.insert(keep_button, -1)
keep_button.show()
separator = gtk.SeparatorToolItem()
separator.props.draw = False
separator.set_expand(True)
toolbar_box.toolbar.insert(separator, -1)
separator.show()
stop_button = StopButton(self)
toolbar_box.toolbar.insert(stop_button, -1)
stop_button.show()
self.set_toolbar_box(toolbar_box)
toolbar_box.show()
self.container = gtk.VBox()
self.container.show()
self.set_canvas(self.container)
if os.path.exists('/tmp/3'):
os.remove('/tmp/3')
self.label = gtk.Label(_("Hello World!"))
self.container.add(self.label)
self.label.set_angle(self.angle)
self.label.show()
if os.path.exists('/tmp/4'):
os.remove('/tmp/4')
self.button = gtk.Button("Rotate")
self.container.add(self.button)
self.button.connect('clicked', self.hello, None)
self.button.show()
