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()