def _toolbar(self): toolbar = gtk.Toolbar() button = gtk.RadioToolButton(None) button.set_tooltip_text("Start transition") button.set_stock_id(gtk.STOCK_GO_FORWARD) toolbar.add(button) self.button_run_phase1 = button button = gtk.RadioToolButton(self.button_run_phase1, None) button.set_tooltip_text("Start & finish transition") button.set_stock_id(gtk.STOCK_GOTO_LAST) toolbar.add(button) self.button_run_phase12 = button toolbar.add(gtk.SeparatorToolItem()) button = gtk.ToolButton(None) button.set_tooltip_text("Receive all packets") button.set_stock_id(gtk.STOCK_GOTO_BOTTOM) button.connect("clicked", lambda w: self.simulation.receive_all( self.netview.get_perspective().get_process_ids())) toolbar.add(button) button = gtk.ToggleToolButton(None) button.set_tooltip_text( "Automatically call 'Receive all packets' after any transition action") button.set_stock_id(gtk.STOCK_EXECUTE) toolbar.add(button) self.button_auto_receive = button return toolbar
def __create_widgets(self): """ """ self.__tbox = BWTable(1, 4) self.__tbox.bw_set_spacing(0) self.__vbox = BWVBox() self.__jump_to = gtk.RadioToolButton(None, gtk.STOCK_JUMP_TO) try_set_tooltip_text(self.__jump_to, 'Change focus') self.__jump_to.connect('toggled', self.__change_pointer, RadialNet.POINTER_JUMP_TO) try: # gtk.STOCK_INFO is available only in PyGTK 2.8 and later. info_icon = gtk.STOCK_INFO except AttributeError: self.__info = gtk.RadioToolButton(self.__jump_to, None) self.__info.set_label(_("Info")) else: self.__info = gtk.RadioToolButton(self.__jump_to, info_icon) try_set_tooltip_text(self.__info, 'Show information') self.__info.connect('toggled', self.__change_pointer, RadialNet.POINTER_INFO) self.__group = gtk.RadioToolButton(self.__jump_to, gtk.STOCK_ADD) try_set_tooltip_text(self.__group, 'Group children') self.__group.connect('toggled', self.__change_pointer, RadialNet.POINTER_GROUP) self.__region = gtk.RadioToolButton(self.__jump_to, gtk.STOCK_SELECT_COLOR) try_set_tooltip_text(self.__region, 'Fill region') self.__region.connect('toggled', self.__change_pointer, RadialNet.POINTER_FILL) self.__region_color = gtk.combo_box_new_text() self.__region_color.append_text(_('Red')) self.__region_color.append_text(_('Yellow')) self.__region_color.append_text(_('Green')) self.__region_color.connect('changed', self.__change_region) self.__region_color.set_active(self.radialnet.get_region_color()) self.__tbox.bw_attach_next(self.__jump_to) self.__tbox.bw_attach_next(self.__info) self.__tbox.bw_attach_next(self.__group) self.__tbox.bw_attach_next(self.__region) self.__vbox.bw_pack_start_noexpand_nofill(self.__tbox) self.__vbox.bw_pack_start_noexpand_nofill(self.__region_color) self.bw_add(self.__vbox) self.__jump_to.set_active(True) self.__region_color.set_no_show_all(True) self.__region_color.hide()
def __create_widgets(self): """ """ self.__tbox = HIGTableRNet(1, 4) self.__tbox._set_spacing(0) self.__vbox = HIGVBox() self.__jump_to = gtk.RadioToolButton(None, gtk.STOCK_JUMP_TO) self.__jump_to.set_tooltip_text('Change focus') self.__jump_to.connect('toggled', self.__change_pointer, POINTER_JUMP_TO) self.__info = gtk.RadioToolButton(self.__jump_to, gtk.STOCK_INFO) self.__info.set_tooltip_text('Show information') self.__info.connect('toggled', self.__change_pointer, POINTER_INFO) self.__group = gtk.RadioToolButton(self.__jump_to, gtk.STOCK_ADD) self.__group.set_tooltip_text('Group children') self.__group.connect('toggled', self.__change_pointer, POINTER_GROUP) self.__region = gtk.RadioToolButton(self.__jump_to, gtk.STOCK_SELECT_COLOR) self.__region.set_tooltip_text('Fill region') self.__region.connect('toggled', self.__change_pointer, POINTER_FILL) self.__region_color = gtk.combo_box_new_text() self.__region_color.append_text('Red') self.__region_color.append_text('Yellow') self.__region_color.append_text('Green') self.__region_color.connect('changed', self.__change_region) self.__region_color.set_active(self.radialnet.get_region_color()) self.__tbox._attach_next(self.__jump_to) self.__tbox._attach_next(self.__info) self.__tbox._attach_next(self.__group) self.__tbox._attach_next(self.__region) self.__vbox._pack_noexpand_nofill(self.__tbox) self.__vbox._pack_noexpand_nofill(self.__region_color) self._add(self.__vbox) self.__jump_to.set_active(True) self.__region_color.set_no_show_all(True) self.__region_color.hide()
def __InsertButton(self, Type, TypeDesc, Group): newIconWidget = gtk.Image() newIconWidget.set_from_pixbuf(Type.GetIcon()) newIconWidget.show() newButton = gtk.RadioToolButton(Group, None) newButton.set_icon_widget(newIconWidget) newButton.set_tooltip(self.tooltips, Type.GetId()) newButton.connect("toggled", self.on_tbButton_toggled, Type.GetId(), TypeDesc) newButton.show() self.tbToolBox.insert(newButton, -1)
def __init__(self): super(PyApp, self).__init__() self.set_title("Toolbar Demo") self.set_default_size(250, 200) self.set_position(gtk.WIN_POS_CENTER) toolbar = gtk.Toolbar() toolbar.set_style(gtk.TOOLBAR_ICONS) toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL) newbtn = gtk.ToolButton(gtk.STOCK_NEW) newbtn.set_tooltip_text("New") openbtn = gtk.ToolButton(gtk.STOCK_OPEN) savebtn = gtk.ToolButton(gtk.STOCK_SAVE) sep = gtk.SeparatorToolItem() rb1 = gtk.RadioToolButton(None, gtk.STOCK_JUSTIFY_LEFT) 53 rb2 = gtk.RadioToolButton(rb1, gtk.STOCK_JUSTIFY_RIGHT) prv = gtk.ToggleToolButton(gtk.STOCK_PRINT_PREVIEW) quitbtn = gtk.ToolButton(gtk.STOCK_QUIT) toolbar.insert(newbtn, 0) toolbar.insert(openbtn, 1) toolbar.insert(savebtn, 2) toolbar.insert(sep, 3) toolbar.insert(rb1, 4) toolbar.insert(rb2, 5) toolbar.insert(prv, 6) toolbar.insert(quitbtn, 7) quitbtn.connect("clicked", gtk.main_quit) vbox = gtk.VBox(False, 2) vbox.pack_start(toolbar, False, False, 0) self.add(vbox) self.connect("destroy", gtk.main_quit) self.show_all()
def __create_widgets(self): """ """ self.__tooltips = gtk.Tooltips() self.__nmap = gtk.RadioToolButton(None, gtk.STOCK_FIND) self.__nmap.set_label('Nmap') self.__nmap.set_is_important(True) self.__nmap.connect('toggled', self.__backend_callback, BACKEND_NMAP) self.__nmap.set_tooltip(self.__tooltips, _("Nmap as backend")) self.__nmap.set_active(True) self.__backend_callback(self.__nmap, BACKEND_NMAP) self.insert(self.__nmap, 0)
def _create_lessons_toolbar(self): toolbar = gtk.Toolbar() for lesson in lessons.THEMES: button = gtk.RadioToolButton() button.set_label(lesson.name) if toolbar.get_n_items(): button.props.group = toolbar.get_nth_item(0) button.connect('clicked', self.__lesson_clicked_cb, lesson) toolbar.insert(button, -1) toolbar.get_nth_item(0).set_active(True) toolbar.show_all() return toolbar
def sig_reload(self, widget=None): self.tree_sc.update() ids = rpc.session.rpc_exec_auth('/object', 'execute', self.model, 'search', self.domain2) if self.tree_res.toolbar: icon_name = 'icon' wid = self.glade.get_widget('tree_toolbar') for w in wid.get_children(): wid.remove(w) c = {} c.update(rpc.session.context) res_ids = rpc.session.rpc_exec_auth_try('/object', 'execute', self.view['model'], 'read', ids, ['name', icon_name], c) rb = None for r in res_ids: rb = gtk.RadioToolButton(group=rb) l = gtk.Label(r['name']) rb.set_label_widget(l) icon = gtk.Image() if icon_name in r: if hasattr(r[icon_name], 'startswith' ) and r[icon_name].startswith('STOCK_'): icon.set_from_stock(getattr(gtk, r[icon_name]), gtk.ICON_SIZE_BUTTON) else: try: icon.set_from_stock(r[icon_name], gtk.ICON_SIZE_BUTTON) except: pass hb = gtk.HBox(spacing=6) hb.pack_start(icon) hb.pack_start(gtk.Label(r['name'])) rb.set_icon_widget(hb) rb.show_all() rb.set_data('id', r['id']) rb.connect('clicked', self.menu_main_clicked) self.menu_main_clicked(rb) wid.insert(rb, -1) else: self.tree_res.ids = ids self.tree_res.reload() wid = self.glade.get_widget('widget_vbox') wid.hide()
def append_page(self, contentview): #label = widgets.hyperlink('', icon=contentview.icon) label = contentview.icon group = None if len(self.__buttons): group = self.__buttons.values()[0] button = gtk.RadioToolButton(group) #button.set_icon_widget(label) #button.set_mode(False) button.set_active(True) button.set_icon_widget(label) button.connect('toggled', self.cb_button_clicked, contentview.unique_id) self.__views[contentview.unique_id] = label self.__buttons[contentview.unique_id] = button self.pack_start(button, expand=False)
def __init__(self): dialog = gtk.Dialog() dialog.connect("delete-event", gtk.main_quit) dialog.set_size_request(450, -1) dialog.set_resizable(True) # to make it nice we'll put the toolbar into the handle box, # so that it can be detached from the main window handlebox = gtk.HandleBox() dialog.vbox.pack_start(handlebox, False, False, 5) # toolbar will be horizontal, with both icons and text, and # with 5pxl spaces between items and finally, # we'll also put it into our handlebox toolbar = gtk.Toolbar() toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL) toolbar.set_style(gtk.TOOLBAR_BOTH) toolbar.set_border_width(5) handlebox.add(toolbar) self.buttons = [] for a in range(0, 5): if a == 0: #first button with none group widget = None else: #additional buttons with belong to the group of the first button widget = but but = gtk.RadioToolButton(group=widget, stock_id=gtk.STOCK_APPLY) but.set_label("button %d" % a) but.connect("clicked", self.radio_event, a) toolbar.insert(but, a) self.buttons.append(but) dialog.show_all()
def __init__(self, client=None): super(MainWindow, self).__init__() if client is None: client = Client() def channel_compare_cb(model, a, b): a, = model.get(a, 0) b, = model.get(b, 0) return (cmp(a.title, b.title) or cmp(a.tags, b.tags) or cmp(a.station.title, b.station.title)) channels = gtk.ListStore(object) channels.set_sort_func(0, channel_compare_cb) channels.set_sort_column_id(0, gtk.SORT_ASCENDING) tag_completion = TagsCompletion(client.get_tags()) self.__current_title = None def read_wishlist(): filename = get_config_filename('wishlist') wishlist = [] try: text = file(filename).read().strip() wishlist = text and text.split('\n') or [] except IOError: pass return dict(zip(wishlist, range(len(wishlist)))) self.__wishlist = read_wishlist() def channel_added_cb(client, channel): tree_iter = channels.insert(-1, (channel, )) tag_completion.add(channel.tags) if (channel == client.current_channel or (channel.uri == self.__config.channel_uri and client.current_channel is None)): model = tree_view.get_model() tree_iter = model.convert_child_iter_to_iter(tree_iter) tree_view.get_selection().select_iter(tree_iter) def state_changed_cb(client): if client.is_playing: self.__config.channel_uri = client.current_channel.uri self.__play_button.set_active(True) stream_tags_changed_cb(client) else: self.__pause_button.set_active(True) self.__stream_info.hide() tree_view.queue_draw() def stream_tags_changed_cb(client): self.__current_title = client.stream_tags.get( 'title').strip() or None org = client.stream_tags.get('organization').strip() or None markup = [] if self.__current_title: markup.append('<b>%s</b>' % glib.markup_escape_text(self.__current_title)) if org: markup.append('<small>%s</small>' % glib.markup_escape_text(org)) if markup: self.__stream_info.set_markup(' - '.join(markup)) self.__stream_info.set_tooltip_markup('\n'.join(markup)) self.__stream_info.show() else: self.__stream_info.set_markup('') self.__stream_info.hide() self.__favorite_button.set_sensitive(bool(self.__current_title)) self.__favorite_button.set_active( self.__current_title in self.__wishlist) self.__client = client self.__client.connect('channel-added', channel_added_cb) self.__client.connect('state-changed', state_changed_cb) self.__client.connect('stream-tags-changed', stream_tags_changed_cb) self.__client.wait(Client.STATE_STATIONS_LOADED) self.__filter_timeout = 0 self.__current_tags = [] self.__config = Configuration() def channel_visible_cb(model, iter): channel, = model.get(iter, 0) return channel.matches(self.__current_tags) matching_channels = gtk.TreeModel.filter_new(channels) matching_channels.set_visible_func(channel_visible_cb) self.set_title('WebRadio') self.set_default_size(500, 400) self.set_icon_name('rhythmbox') self.connect('destroy', gtk.main_quit) vbox = gtk.VBox() self.add(vbox) toolbar = gtk.Toolbar() toolbar.set_show_arrow(False) vbox.pack_start(toolbar, expand=False) def play_button_clicked_cb(button): if not button.get_active(): self.__client.pause() return model, tree_iter = tree_view.get_selection().get_selected() channel = None if model and tree_iter: channel, = model.get(tree_iter, 0) if channel is not None: if channel == self.__client.current_channel: self.__client.resume() else: self.__client.play(channel) def favorite_button_clicked_cb(button): if not self.__current_title: return if button.get_active(): self.__wishlist[self.__current_title] = True else: self.__wishlist.pop(self.__current_title, False) wishlist_text = '\n'.join(self.__wishlist.keys()) + '\n' filename = get_config_filename('wishlist') file(filename, 'w').write(wishlist_text) self.__play_button = gtk.RadioToolButton(None, gtk.STOCK_MEDIA_PLAY) self.__play_button.connect('clicked', play_button_clicked_cb) self.__play_button.set_is_important(True) toolbar.insert(self.__play_button, -1) self.__pause_button = gtk.RadioToolButton(self.__play_button, gtk.STOCK_MEDIA_PAUSE) toolbar.insert(self.__pause_button, -1) self.__favorite_button = gtk.ToggleToolButton(gtk.STOCK_ABOUT) self.__favorite_button.connect('clicked', favorite_button_clicked_cb) toolbar.insert(self.__favorite_button, -1) item = gtk.SeparatorToolItem() item.set_expand(True) item.set_draw(False) toolbar.insert(item, -1) item = gtk.ToolItem() toolbar.insert(item, -1) def filter_timeout_cb(entry): self.__current_tags = filter(None, entry.get_text().split(' ')) matching_channels.refilter() self.__filter_timeout = 0 return False def filter_entry_changed_cb(entry, *args): if self.__filter_timeout: glib.source_remove(self.__filter_timeout) self.__filter_timeout = glib.timeout_add(200, filter_timeout_cb, entry) self.__filter_entry = gtk.Entry() self.__filter_entry.set_width_chars(40) self.__filter_entry.set_completion(tag_completion) self.__filter_entry.connect('changed', filter_entry_changed_cb) item.add(self.__filter_entry) scrolled = gtk.ScrolledWindow() scrolled.set_shadow_type(gtk.SHADOW_IN) scrolled.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) vbox.pack_start(scrolled, expand=True) def row_activated_cb(view, path, column): model = view.get_model() channel, = model.get(model.get_iter(path), 0) self.__client.play(channel) tree_view = gtk.TreeView(matching_channels) tree_view.set_headers_visible(False) tree_view.connect('row-activated', row_activated_cb) scrolled.add(tree_view) def adjustment_cb(adjustment): model, tree_iter = tree_view.get_selection().get_selected() if model and tree_iter: path = model.get_path(tree_iter) tree_view.scroll_to_cell(path, None, True, 0.5, 0.5) tree_view.get_vadjustment().connect('changed', adjustment_cb) def icon_cell_data_cb(column, cell, model, iter): channel, = model.get(iter, 0) if channel != self.__client.current_channel: cell.set_property('stock-id', None) elif self.__client.is_playing: cell.set_property('stock-id', gtk.STOCK_MEDIA_PLAY) else: cell.set_property('stock-id', gtk.STOCK_MEDIA_PAUSE) def text_cell_data_cb(column, cell, model, iter): channel, = model.get(iter, 0) title, tags = channel.title, channel.tags tags = [channel.station.id] + list(tags) details = title, ' '.join(tags), channel.station.title details = tuple(map(glib.markup_escape_text, details)) markup = '<b>%s</b>\n<small>%s - %s</small>' % details cell.set_property('markup', markup) cell = gtk.CellRendererPixbuf() cell.set_properties(stock_size=gtk.ICON_SIZE_MENU) column = gtk.TreeViewColumn('Icon', cell) column.set_cell_data_func(cell, icon_cell_data_cb) column.set_expand(False) tree_view.insert_column(column, -1) cell = gtk.CellRendererText() cell.set_properties(ellipsize=pango.ELLIPSIZE_END) column = gtk.TreeViewColumn(None, cell) column.set_cell_data_func(cell, text_cell_data_cb) tree_view.insert_column(column, -1) self.__stream_info = MarqueLabel() self.__stream_info.set_no_show_all(True) vbox.pack_start(self.__stream_info, expand=False) stream_tags_changed_cb(self.__client) state_changed_cb(self.__client) tags = (self.__config.tags or '').strip() self.__filter_entry.grab_focus() self.__filter_entry.set_text(tags + ' ') self.__filter_entry.set_position(-1) for station in self.__client.get_stations(): for channel in station.channels: channel_added_cb(self.__client, channel) self.get_child().show_all()
def __init__(self, goocalendar): super(Toolbar, self).__init__() self.goocalendar = goocalendar self.accel_group = Main.get_main().accel_group today_button = gtk.ToolButton() today_button.set_label(_('Today')) today_button.set_homogeneous(False) today_button.connect("clicked", self.on_today_button_clicked) today_button.add_accelerator("clicked", self.accel_group, gtk.keysyms.t, gtk.gdk.MODIFIER_MASK, gtk.ACCEL_VISIBLE) self.insert(today_button, -1) arrow_left = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE) go_back = gtk.ToolButton() go_back.set_icon_widget(arrow_left) go_back.set_label(_("go back")) go_back.set_expand(False) go_back.set_homogeneous(False) go_back.connect("clicked", self.on_go_back_clicked) self.insert(go_back, -1) self.current_page_label = gtk.Label("") self.current_page = gtk.ToggleToolButton() self.current_page.set_label_widget(self.current_page_label) self.current_page.connect("clicked", self.on_current_page_clicked) self.insert(self.current_page, -1) self.__cal_popup = gtk.Window(gtk.WINDOW_POPUP) self.__cal_popup.set_events(self.__cal_popup.get_events() | gtk.gdk.KEY_PRESS_MASK) self.__cal_popup.set_resizable(False) self.__cal_popup.connect('delete-event', self.on_cal_popup_closed) self.__cal_popup.connect('key-press-event', self.on_cal_popup_key_pressed) self.__cal_popup.connect('button-press-event', self.on_cal_popup_button_pressed) gtkcal = gtk.Calendar() gtkcal.connect('day-selected', self.on_gtkcal_day_selected) gtkcal.connect('day-selected-double-click', self.on_gtkcal_day_selected_double_click) gtkcal.set_display_options(gtk.CALENDAR_SHOW_HEADING | gtk.CALENDAR_SHOW_WEEK_NUMBERS | gtk.CALENDAR_SHOW_DAY_NAMES) gtkcal.set_no_show_all(True) self.__cal_popup.add(gtkcal) gtkcal.show() self.gtkcal = gtkcal self.goocalendar.connect('day-selected', self.on_goocalendar_day_selected) arrow_right = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_NONE) go_forward = gtk.ToolButton() go_forward.set_icon_widget(arrow_right) go_forward.set_label(_("go forward")) go_forward.set_expand(False) go_forward.set_homogeneous(False) go_forward.connect("clicked", self.on_go_forward_clicked) self.insert(go_forward, -1) arrow_left = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE) previous_year = gtk.ToolButton() previous_year.set_icon_widget(arrow_left) previous_year.set_label(_("previous year")) previous_year.set_expand(False) previous_year.set_homogeneous(False) previous_year.connect("clicked", self.on_previous_year_clicked) self.insert(previous_year, -1) self.current_year_label = gtk.Label("") current_year = gtk.ToolItem() current_year.add(self.current_year_label) self.insert(current_year, -1) arrow_right = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_NONE) next_year = gtk.ToolButton() next_year.set_icon_widget(arrow_right) next_year.set_label(_("next year")) next_year.set_expand(False) next_year.set_homogeneous(False) next_year.connect("clicked", self.on_next_year_clicked) self.insert(next_year, -1) blank_widget = gtk.ToolItem() blank_widget.set_expand(True) self.insert(blank_widget, -1) week_button = gtk.RadioToolButton() week_button.set_label(_('Week View')) week_button.connect("clicked", self.on_week_button_clicked) week_button.add_accelerator("clicked", self.accel_group, gtk.keysyms.w, gtk.gdk.MODIFIER_MASK, gtk.ACCEL_VISIBLE) self.insert(week_button, -1) if hasattr(gtk.RadioToolButton, 'new_from_widget'): month_button = gtk.RadioToolButton.new_from_widget(week_button) else: month_button = gtk.RadioToolButton(week_button) month_button.set_label_widget(gtk.Label(_('Month View'))) month_button.connect("clicked", self.on_month_button_clicked) month_button.add_accelerator("clicked", self.accel_group, gtk.keysyms.m, gtk.gdk.MODIFIER_MASK, gtk.ACCEL_VISIBLE) self.insert(month_button, -1) buttons = {'month': month_button, 'week': week_button} buttons[self.goocalendar.view].set_active(True) self.update_displayed_date() self.set_style(gtk.TOOLBAR_ICONS)
def get_toolbar(self): toolbar = gtk.Toolbar() toolbar.set_style({ 'default': False, 'both': gtk.TOOLBAR_BOTH, 'text': gtk.TOOLBAR_TEXT, 'icons': gtk.TOOLBAR_ICONS}[CONFIG['client.toolbar']]) self.widget.pack_start(toolbar, expand=False, fill=True) for icon in ['bold', 'italic', 'underline']: button = gtk.ToggleToolButton('gtk-%s' % icon) button.connect('toggled', self.toggle_props, icon) toolbar.insert(button, -1) self.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) tool = gtk.ToolItem() tool.add(combobox) toolbar.insert(tool, -1) self.tag_widgets[name] = combobox toolbar.insert(gtk.SeparatorToolItem(), -1) button = None for icon in ['left', 'center', 'right', 'fill']: name = icon if icon == 'fill': name = 'justify' stock_id = 'gtk-justify-%s' % icon if hasattr(gtk.RadioToolButton, 'new_with_stock_from_widget'): button = gtk.RadioToolButton.new_with_stock_from_widget( button, stock_id) else: button = gtk.RadioToolButton(button, stock_id) button.set_active(icon == 'left') button.connect('toggled', self.toggle_justification, name) toolbar.insert(button, -1) self.tag_widgets[name] = button toolbar.insert(gtk.SeparatorToolItem(), -1) for icon, label in [ ('foreground', _('Foreground')), # TODO ('background', _('Background')), ]: button = gtk.ToolButton('tryton-text-%s' % icon) button.set_label(label) button.connect('clicked', self.toggle_color, icon) toolbar.insert(button, -1) self.tag_widgets[icon] = button return toolbar
def __init__(self, goocalendar): super(Toolbar, self).__init__() self.goocalendar = goocalendar self.accel_group = Main.get_main().accel_group today_label = gtk.Label(_('Today')) today_button = gtk.ToolButton(today_label) today_button.set_homogeneous(False) today_button.connect("clicked", self.on_today_button_clicked) today_button.add_accelerator("clicked", self.accel_group, gtk.keysyms.t, gtk.gdk.MODIFIER_MASK, gtk.ACCEL_VISIBLE) self.insert(today_button, -1) arrow_left = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE) go_back = gtk.ToolButton(arrow_left, "go left") go_back.set_expand(False) go_back.set_homogeneous(False) go_back.connect("clicked", self.on_go_back_clicked) self.insert(go_back, -1) self.current_page_label = gtk.Label("") self.current_page = gtk.ToggleToolButton() self.current_page.set_icon_widget(self.current_page_label) self.current_page.connect("clicked", self.on_current_page_clicked) self.insert(self.current_page, -1) gtkcal = gtk.Calendar() gtkcal.connect('day-selected', self.on_gtkcal_day_selected) gtkcal.set_display_options( gtk.CALENDAR_SHOW_HEADING | gtk.CALENDAR_SHOW_WEEK_NUMBERS | gtk.CALENDAR_SHOW_DAY_NAMES) gtkcal.set_no_show_all(True) gtkcal_item = goocanvas.Widget(widget=gtkcal) gtkcal_item.set_property('visibility', goocanvas.ITEM_INVISIBLE) goocalendar.get_root_item().add_child(gtkcal_item) self.gtkcal = gtkcal self.gtkcal_item = gtkcal_item self.goocalendar.connect('day-selected', self.on_goocalendar_day_selected) arrow_right = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_NONE) go_forward = gtk.ToolButton(arrow_right, "go right") go_forward.set_expand(False) go_forward.set_homogeneous(False) go_forward.connect("clicked", self.on_go_forward_clicked) self.insert(go_forward, -1) arrow_left = gtk.Arrow(gtk.ARROW_LEFT, gtk.SHADOW_NONE) previous_year = gtk.ToolButton(arrow_left, "next year") previous_year.set_expand(False) previous_year.set_homogeneous(False) previous_year.connect("clicked", self.on_previous_year_clicked) self.insert(previous_year, -1) self.current_year_label = gtk.Label("") current_year = gtk.ToolItem() current_year.add(self.current_year_label) self.insert(current_year, -1) arrow_right = gtk.Arrow(gtk.ARROW_RIGHT, gtk.SHADOW_NONE) next_year = gtk.ToolButton(arrow_right, "next year") next_year.set_expand(False) next_year.set_homogeneous(False) next_year.connect("clicked", self.on_next_year_clicked) self.insert(next_year, -1) blank_widget = gtk.ToolItem() blank_widget.set_expand(True) self.insert(blank_widget, -1) week_button = gtk.RadioToolButton() week_button.set_label(_('Week View')) week_button.connect("clicked", self.on_week_button_clicked) week_button.add_accelerator("clicked", self.accel_group, gtk.keysyms.w, gtk.gdk.MODIFIER_MASK, gtk.ACCEL_VISIBLE) self.insert(week_button, -1) month_button = gtk.RadioToolButton(week_button) month_button.set_label(_('Month View')) month_button.connect("clicked", self.on_month_button_clicked) month_button.add_accelerator("clicked", self.accel_group, gtk.keysyms.m, gtk.gdk.MODIFIER_MASK, gtk.ACCEL_VISIBLE) month_button.set_active(True) self.insert(month_button, -1) self.update_displayed_date() self.set_style(gtk.TOOLBAR_ICONS)
def __init__(self, theme, ink_canvas): gtk.Toolbar.__init__(self) self._inkcanvas = ink_canvas ### paint button paint_image = gtk.Image() paint_image.set_from_pixbuf(theme.load_icon('paintbrush', 48, 0)) paint_button = gtk.RadioToolButton() paint_button.set_icon_widget(paint_image) paint_button.set_label('Paintbrush') paint_button.connect('clicked', self.__set_paint) ### eraser button erase_image = gtk.Image() erase_image.set_from_pixbuf(theme.load_icon('eraser', 48, 0)) erase_button = gtk.RadioToolButton(paint_button) erase_button.set_icon_widget(erase_image) erase_button.set_label('Eraser') erase_button.connect('clicked', self.__set_eraser) ### Color select self._color_label = ColorLabel(self._inkcanvas.get_stroke_color()) hbox = gtk.HBox() hbox.pack_start(self._color_label) hbox.pack_start(gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_IN)) color_button = gtk.ToolItem() color_button_t = ColorButton(hbox) color_button_t.connect('color-set', self.__color_set, paint_button) color_button.add(color_button_t) ### clear button imgclear = gtk.Image() imgclear.set_from_stock(gtk.STOCK_CLEAR, gtk.ICON_SIZE_LARGE_TOOLBAR ) clear = gtk.ToolButton(imgclear) clear.set_label('Clear') clear.connect( 'clicked', self.__clear_canvas ) main_img = gtk.Image() main_img.set_from_pixbuf(theme.load_icon('medium_grid', 48, 0)) blank_img = gtk.Image() blank_img.set_from_pixbuf(theme.load_icon('no_grid', 48, 0) ) small_img = gtk.Image() small_img.set_from_pixbuf(theme.load_icon('small_grid', 48, 0)) medium_img = gtk.Image() medium_img.set_from_pixbuf(theme.load_icon('medium_grid', 48, 0)) large_img = gtk.Image() large_img.set_from_pixbuf(theme.load_icon('large_grid', 48, 0)) ### grid button grid_button_t = GridButton( main_img, blank_img, small_img, medium_img, large_img, self._inkcanvas.get_grid_type()) grid_button_t.connect( 'grid-type-set', self.__set_grid_type) grid_button = gtk.ToolItem() grid_button.add(grid_button_t) ### undo Button undo_button = gtk.ToolButton() undo_button.set_stock_id(gtk.STOCK_UNDO) undo_button.connect("clicked", self.__undo) ### redo Button redo_button = gtk.ToolButton() redo_button.set_stock_id(gtk.STOCK_REDO) redo_button.connect("clicked", self.__redo) ### size Slider brushsmall_t = gtk.Image() brushsmall_t.set_from_pixbuf(theme.load_icon('brush-small', 48, 0)) brushsmall = gtk.ToolItem() brushsmall.add(brushsmall_t) brushlarge_t = gtk.Image() brushlarge_t.set_from_pixbuf(theme.load_icon('brush-large', 48, 0)) brushlarge = gtk.ToolItem() brushlarge.add(brushlarge_t) brush_slider_t = gtk.HScale(gtk.Adjustment(value=8, lower=1, upper=20, step_incr=0.5, page_incr=1, page_size=0)) brush_slider_t.set_size_request(130, -1) brush_slider_t.set_value_pos(gtk.POS_RIGHT) brush_slider_t.set_digits(0) brush_slider_t.set_update_policy(gtk.UPDATE_DISCONTINUOUS) brush_slider_t.connect("value-changed", self.__set_size) brush_slider = gtk.ToolItem() brush_slider.add(brush_slider_t) ### toolbar self.set_show_arrow(True) self.insert(color_button, -1) self.insert(gtk.SeparatorToolItem(), -1) self.insert(paint_button, -1) self.insert(erase_button, -1) self.insert(gtk.SeparatorToolItem(), -1) self.insert(undo_button, -1) self.insert(redo_button, -1) self.insert(gtk.SeparatorToolItem(), -1) self.insert(clear, -1) self.insert(gtk.SeparatorToolItem(), -1) self.insert(grid_button, -1) self.insert(gtk.SeparatorToolItem(), -1) self.insert(brushsmall, -1) self.insert(brush_slider, -1) self.insert(brushlarge, -1)
class Gui(gtk.Window): def __init__(self, API_KEY): super(Gui, self).__init__() self.connect("destroy", self.on_destroy) self.set_border_width(5) self.set_size_request(780, 400) try: self.set_icon_from_file( os.path.join(sys.path[0], "images", "youtube.png")) self.EMPTY_POSTER = gtk.gdk.pixbuf_new_from_file( os.path.join(sys.path[0], "images", "blank_default.png")) self.YOUTUBE_PIXBUF = gtk.gdk.pixbuf_new_from_file( os.path.join(sys.path[0], "images", "youtube_16.png")) except Exception, e: print e.message self.set_title(PROG_NAME) self.results_title = "" # Toolbar and it's items toolbar = gtk.Toolbar() toolbar.set_style(gtk.TOOLBAR_ICONS) #TODO: change categories image btn_categories = gtk.ToggleToolButton(gtk.STOCK_DIRECTORY) btn_categories.set_tooltip_text("Show/hide categories") btn_categories.connect("clicked", self.btn_categories_clicked) toolbar.insert(btn_categories, -1) toolbar.insert(gtk.SeparatorToolItem(), -1) btn_home = gtk.ToolButton(gtk.STOCK_HOME) btn_home.set_tooltip_text("Get most popular videos for your country") btn_home.connect("clicked", self.btn_home_clicked) toolbar.insert(btn_home, -1) toolbar.insert(gtk.SeparatorToolItem(), -1) bookmark_icon = gtk.Image() bookmark_icon.set_from_file( os.path.join(sys.path[0], "images", "bookmark_24.png")) self.btn_saved_items = gtk.ToggleToolButton() self.btn_saved_items.set_icon_widget(bookmark_icon) self.btn_saved_items.set_tooltip_text("Show/hide bookmarks") self.btn_saved_items.set_sensitive(False) self.btn_saved_items.connect("clicked", self.btn_saved_items_clicked) toolbar.insert(self.btn_saved_items, -1) toolbar.insert(gtk.SeparatorToolItem(), -1) self.btn_refresh = gtk.ToolButton(gtk.STOCK_REFRESH) self.btn_refresh.set_tooltip_text("Update results") self.btn_refresh.connect("clicked", self.btn_refresh_clicked) self.btn_refresh.set_sensitive(False) toolbar.insert(self.btn_refresh, -1) toolbar.insert(gtk.SeparatorToolItem(), -1) self.btn_prev = gtk.ToolButton(gtk.STOCK_GO_BACK) self.btn_prev.connect("clicked", self.btn_prev_clicked) self.btn_prev.set_sensitive(False) toolbar.insert(self.btn_prev, -1) self.btn_next = gtk.ToolButton(gtk.STOCK_GO_FORWARD) self.btn_next.connect("clicked", self.btn_next_clicked) self.btn_next.set_sensitive(False) toolbar.insert(self.btn_next, -1) toolbar.insert(gtk.SeparatorToolItem(), -1) entry_item = gtk.ToolItem() entry = gtk.Entry() entry.set_tooltip_text("Search youtube") entry.connect("activate", self.entry_activated) entry_item.add(entry) toolbar.insert(entry_item, -1) # May use gtk_image_new_from_file date_icon = gtk.Image() date_icon.set_from_file( os.path.join(sys.path[0], "images", "calendar-24.png")) views_icon = gtk.Image() views_icon.set_from_file( os.path.join(sys.path[0], "images", "eye-24.png")) self.rtb_date = gtk.RadioToolButton() self.rtb_date.set_icon_widget(date_icon) self.rtb_date.set_tooltip_text("Sort by date") self.rtb_views = gtk.RadioToolButton(self.rtb_date) self.rtb_views.set_icon_widget(views_icon) self.rtb_views.set_tooltip_text("Sort by views") toolbar.insert(self.rtb_date, -1) toolbar.insert(self.rtb_views, -1) toolbar.insert(gtk.SeparatorToolItem(), -1) self.btn_info = gtk.ToggleToolButton(gtk.STOCK_INFO) self.btn_info.set_tooltip_text("Show/hide info") self.btn_info.connect("clicked", self.btn_info_clicked) self.btn_info.set_sensitive(False) toolbar.insert(self.btn_info, -1) # Loading indicator self.sp_results = gtk.Spinner() self.sp_results.set_size_request(SPINNER_SIZE, SPINNER_SIZE) # Data self.iv_results = gtk.IconView() self.iv_results.set_pixbuf_column(COL_PIXBUF) self.iv_results.set_text_column(COL_TEXT) self.iv_results.set_item_width(ICON_VIEW_ITEM_WIDTH) self.sw_results = self.create_scrolled_window() self.sw_results.add(self.iv_results) self.sw_results.show_all() vadj = self.sw_results.get_vadjustment() vadj.connect("value-changed", self.on_results_scroll_to_bottom) self.iv_results.connect("expose-event", self.on_results_draw) self.iv_results.connect("selection-changed", self.on_result_selection_changed) self.iv_results.connect("item-activated", self.on_result_item_activated) # Error btn_results_error = gtk.Button("Repeat") btn_results_error.connect("clicked", self.btn_results_error_clicked) btn_results_error.show() self.hb_results_error = gtk.HBox(False, 1) self.hb_results_error.pack_start(btn_results_error, True, False, 10) # No api key label lb_api_key = gtk.Label( "No youtube api key found. It should be in the file 'key.txt' in the application directory." ) lb_api_key.set_line_wrap(True) self.vb_results = gtk.VBox(False, 1) self.vb_results.pack_start(self.sw_results, True, True, 1) self.vb_results.pack_start(self.sp_results, True, False, 1) self.vb_results.pack_start(self.hb_results_error, True, False, 1) self.vb_results.pack_start(lb_api_key, True, False, 1) # Title self.lb_title = gtk.Label("") self.lb_title.set_size_request(SIDE_WIDTH, -1) self.lb_title.set_line_wrap(True) fr_title = gtk.Frame("Title") fr_title.add(self.lb_title) fr_title.show_all() # Resolutions self.sp_resolutions = gtk.Spinner() self.sp_resolutions.set_size_request(SPINNER_SIZE, SPINNER_SIZE) #TODO: group icons in one place self.channel_error_icon = gtk.image_new_from_file( os.path.join(sys.path[0], "images", "box-important-24.png")) self.btn_resolutions_error = gtk.Button() self.btn_resolutions_error.set_image(self.channel_error_icon) self.btn_resolutions_error.connect("clicked", self.btn_resolutions_error_clicked) self.tv_resolutions = self.create_tree_view() self.resolutions_store = gtk.ListStore(gtk.gdk.Pixbuf, str, str) self.tv_resolutions.set_model(self.resolutions_store) self.tv_resolutions.connect("row-activated", self.on_resolution_activated) self.sw_resolutions = self.create_scrolled_window() self.sw_resolutions.add(self.tv_resolutions) self.sw_resolutions.show_all() vb_resolutions = gtk.VBox(False, 1) vb_resolutions.pack_start(self.sw_resolutions, True, True, 1) vb_resolutions.pack_start(self.sp_resolutions, True, False, 1) vb_resolutions.pack_start(self.btn_resolutions_error, True, False, 1) vb_resolutions.show() fr_resolutions = gtk.Frame("Resolutions") fr_resolutions.add(vb_resolutions) fr_resolutions.show() # Save/delete buttons star_icon = gtk.image_new_from_file( os.path.join(sys.path[0], "images", "star-24.png")) star_filled_icon = gtk.image_new_from_file( os.path.join(sys.path[0], "images", "star-filled-24.png")) self.btn_save = gtk.Button() self.btn_save.set_image(star_icon) self.btn_delete = gtk.Button() self.btn_delete.set_image(star_filled_icon) self.btn_save.connect("clicked", self.btn_save_clicked) self.btn_delete.connect("clicked", self.btn_delete_clicked) # List related to video id list_icon = gtk.image_new_from_file( os.path.join(sys.path[0], "images", "menu-24.png")) self.btn_list_video_id = gtk.Button() self.btn_list_video_id.set_image(list_icon) self.btn_list_video_id.set_tooltip_text("List related to video") self.btn_list_video_id.connect("clicked", self.btn_list_video_id_clicked) self.btn_list_video_id.show() # List channel videos self.channel_icon = gtk.image_new_from_file( os.path.join(sys.path[0], "images", "video-playlist-24.png")) self.btn_list_channel = gtk.Button() self.btn_list_channel.set_image(self.channel_icon) self.btn_list_channel.set_tooltip_text("List channel videos") self.btn_list_channel.connect("clicked", self.btn_channel_clicked) self.btn_list_channel.show() self.sp_channel = gtk.Spinner() self.sp_channel.set_size_request(SPINNER_SIZE, SPINNER_SIZE) image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PLAY, gtk.ICON_SIZE_BUTTON) self.btn_get_links = gtk.Button() self.btn_get_links.set_image(image) self.btn_get_links.set_tooltip_text("Get links") self.btn_get_links.connect("clicked", self.btn_get_links_clicked) self.btn_get_links.show() self.hb_actions = gtk.HBox(False, 1) self.hb_actions.pack_start(self.btn_list_video_id, True, True, 1) self.hb_actions.pack_start(self.btn_save, True, True, 1) self.hb_actions.pack_start(self.btn_delete, True, True, 1) self.hb_actions.pack_start(self.sp_channel, True, False, 1) self.hb_actions.pack_start(self.btn_list_channel, True, True, 1) self.hb_actions.pack_start(self.btn_get_links, True, True, 1) self.vb_results.pack_end(self.hb_actions, False, False, 1) # Client frame self.rb_ytdl = gtk.RadioButton(None, "youtube-dl") self.rb_ytdl.connect('toggled', self.rb_ytdl_toggled) self.rb_streamlink = gtk.RadioButton(self.rb_ytdl, "streamlink") vb_client = gtk.VBox(False, 1) vb_client.pack_start(self.rb_ytdl, False, False, 1) vb_client.pack_start(self.rb_streamlink, False, False, 1) self.fr_client = gtk.Frame("Client") self.fr_client.add(vb_client) self.fr_client.show_all() # Player frame self.player_init_text = "" self.lb_player = gtk.Label("") self.lb_player.set_size_request(SIDE_WIDTH, -1) self.lb_player.set_line_wrap(True) self.btn_close_player = gtk.Button() image = gtk.image_new_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_BUTTON) self.btn_close_player.set_image(image) self.btn_close_player.set_tooltip_text("Close player") self.btn_close_player.connect("clicked", self.btn_close_player_clicked) hb_player = gtk.HBox(False, 1) hb_player.pack_start(self.lb_player, True, True, 1) hb_player.pack_end(self.btn_close_player, False, False, 1) fr_player = gtk.Frame("Player") fr_player.add(hb_player) fr_player.show_all() self.btn_close_player.hide() self.vb_right = gtk.VBox(False, 1) self.vb_right.set_size_request(SIDE_WIDTH, -1) self.vb_right.pack_start(fr_title, False, False, 1) self.vb_right.pack_start(fr_resolutions, True, True, 1) self.vb_right.pack_start(self.fr_client, False, False, 1) self.vb_right.pack_start(fr_player, False, False, 1) # Categories self.sp_categories = gtk.Spinner() self.sp_categories.set_size_request(SPINNER_SIZE, SPINNER_SIZE) self.btn_categories_error = gtk.Button("Repeat") self.btn_categories_error.connect("clicked", self.btn_categories_error_clicked) tv_categories = self.create_tree_view() self.categories_store = gtk.ListStore(gtk.gdk.Pixbuf, str, str) tv_categories.set_model(self.categories_store) tv_categories.connect("row-activated", self.on_categories_activated) self.sw_categories = self.create_scrolled_window() self.sw_categories.add(tv_categories) self.sw_categories.show_all() self.vb_categories = gtk.VBox(False, 1) self.vb_categories.set_size_request(SIDE_WIDTH, -1) self.vb_categories.pack_start(self.sp_categories, True, False, 1) self.vb_categories.pack_start(self.sw_categories, True, True, 1) self.vb_categories.pack_start(self.btn_categories_error, True, False, 1) hbox = gtk.HBox(False, 1) hbox.pack_start(self.vb_categories, False, False, 1) hbox.pack_start(self.vb_results, True, True, 1) hbox.pack_start(self.vb_right, False, False, 1) hbox.show() vbox = gtk.VBox(False, 1) vbox.pack_start(toolbar, False, False, 1) vbox.pack_start(hbox, True, True, 1) toolbar.show_all() self.vb_results.show() self.add(vbox) vbox.show() self.show() self.is_task_started = False loc = locale.getlocale() self.search_net = SearchNet(API_KEY, self, loc) self.categories_net = CategoriesNet(API_KEY, self, loc) self.images_indices = set() self.images_cache = {} self.video_id_processor = VideoIdProcessor(self) # Setup client radiobuttons if clients detected is_ytdl = self.video_id_processor.youtube_dl != "" is_streamlink = self.video_id_processor.player.streamlink != "" if is_ytdl: self.rb_ytdl.set_active(True) elif is_streamlink: self.rb_streamlink.set_active(True) else: self.fr_client.hide() vb_client.set_sensitive(is_ytdl and is_streamlink) self.results_store = None self.results_history = ResultsHistory(self) self.saved_items = SavedItemsDb(self) self.channel_net = ChannelNet(API_KEY, self) self.is_empty = True if API_KEY == "": lb_api_key.show() self.sw_results.hide() btn_categories.set_sensitive(False)
def __init__(self, field_name, model_name, attrs=None): super(RichTextBox, self).__init__(field_name, model_name, attrs=attrs) self.table_tag = gtk.TextTagTable() self.text_buffer = gtk.TextBuffer(self.table_tag) self.textview.set_buffer(self.text_buffer) self.textview.connect_after('move-cursor', self.detect_style) self.textview.connect('button-release-event', self.detect_style) self.focus_out = True tags = ('bold', 'italic', 'underline', 'font_family', 'size', 'left', 'center', 'right', 'fill', 'foreground', 'background', 'markup') # Build all buttons self.tools = {} for tag in tags[:3]: self.tools[tag] = gtk.ToggleToolButton('gtk-%s' % tag) self.sizes = map(str, range(6, 33)) fonts = self.textview.get_pango_context().list_families() self.families = sorted([font.get_name() for font in fonts]) for tag, values in zip(tags[3:5], (self.families, self.sizes)): self.tools[tag] = gtk.ToolItem() box = gtk.combo_box_new_text() for value in values: box.append_text(value) box.set_focus_on_click(False) self.tools[tag].add(box) group = None for tag in tags[5:9]: self.tools[tag] = gtk.RadioToolButton(group, 'gtk-justify-%s' % tag) if not group: group = self.tools[tag] for tag in tags[9:11]: self.tools[tag] = gtk.ToolButton('tryton-text-%s' % tag) self.tools['markup'] = gtk.ToggleToolButton('tryton-text-markup') # Set properties to each button tag_values = ( ('bold', 'weight', pango.WEIGHT_BOLD), ('italic', 'style', pango.STYLE_ITALIC), ('underline', 'underline', pango.UNDERLINE_SINGLE), ('left', 'justification', gtk.JUSTIFY_LEFT), ('center', 'justification', gtk.JUSTIFY_CENTER), ('right', 'justification', gtk.JUSTIFY_RIGHT), ('fill', 'justification', gtk.JUSTIFY_FILL), ) self.text_tags = {} for tag, name, prop in tag_values: self.text_tags[tag] = gtk.TextTag(tag) self.text_tags[tag].set_property(name, prop) self.table_tag.add(self.text_tags[tag]) self.font_props = { 'font_family': {}, 'size': {}, 'foreground': {}, 'background': {}, } font_desc = self.textview.get_pango_context().get_font_description() self.current_font_prop = { 'foreground': gtk.gdk.Color('#000'), 'background': gtk.gdk.Color('#fff'), 'font_family': font_desc.get_family(), 'size': str(font_desc.get_size() / pango.SCALE), 'justify': 'left', } self.tools['size'].child.set_active( self.sizes.index(self.current_font_prop['size'])) font_family = self.current_font_prop['font_family'] if font_family in self.families: self.tools['font_family'].child.set_active( self.families.index(font_family)) self.start_tags = {} self.end_tags = {} # Connect events self.tool_ids = {} for tag in tags[:3]: self.tool_ids[tag] = self.tools[tag].connect( 'toggled', self.action_style_font, self.text_tags[tag], tag) for tag in tags[3:5]: self.tool_ids[tag] = self.tools[tag].child.connect( 'changed', self.action_prop_font, tag) for tag in tags[5:9]: self.tool_ids[tag] = self.tools[tag].connect( 'toggled', self.action_justification, tag) for tag in tags[9:11]: self.tool_ids[tag] = self.tools[tag].connect( 'clicked', self.action_prop_font, tag) self.tool_ids['markup'] = self.tools['markup'].connect( 'toggled', self.edit_text_markup) self.insert_text_id = self.text_buffer.connect_after( 'insert-text', self.persist_style) # Tooltip text self.tools['bold'].set_tooltip_text(_('Change text to bold')) self.tools['italic'].set_tooltip_text(_('Change text to italic')) self.tools['underline'].set_tooltip_text(_('Change text to underline')) self.tools['font_family'].set_tooltip_text(_('Choose font-family')) self.tools['size'].set_tooltip_text(_('Choose font-size')) self.tools['left'].set_tooltip_text(_('Justify of line to the left')) self.tools['center'].set_tooltip_text( _('Justify of line to the center')) self.tools['right'].set_tooltip_text(_('Justify of line to the right')) self.tools['fill'].set_tooltip_text( _('Justify of line to fill window')) self.tools['foreground'].set_tooltip_text( _('Change the foreground text')) self.tools['background'].set_tooltip_text( _('Change the background text')) self.tools['markup'].set_tooltip_text(_('Change the markup text view')) # Packing widgets self.tool_bar = gtk.Toolbar() self.tool_bar.set_style(gtk.TOOLBAR_ICONS) for tag in tags: self.tool_bar.insert(self.tools[tag], -1) separator = gtk.SeparatorToolItem for local in (3, 6, 11, 14): self.tool_bar.insert(separator(), local) self.widget.pack_start(self.tool_bar, False)
def __init__(self, view, attrs): super(RichTextBox, self).__init__(view, attrs) self.text_buffer = gtk.TextBuffer() setup_tags(self.text_buffer) self.text_buffer.register_serialize_format(MIME, serialize, None) self.text_buffer.register_deserialize_format(MIME, deserialize, None) self.text_buffer.connect_after('insert-text', self.insert_text_style) self.textview.set_buffer(self.text_buffer) self.textview.connect_after('move-cursor', self.detect_style) self.textview.connect('button-release-event', self.detect_style) self.toolbar = gtk.Toolbar() self.toolbar.set_style({ 'default': False, 'both': gtk.TOOLBAR_BOTH, 'text': gtk.TOOLBAR_TEXT, 'icons': gtk.TOOLBAR_ICONS }[CONFIG['client.toolbar']]) self.widget.pack_start(self.toolbar, expand=False, fill=True) self.tag_widgets = {} self.tags = {} for icon in ['bold', 'italic', 'underline']: button = gtk.ToggleToolButton('gtk-%s' % icon) button.connect('toggled', self.toggle_props, icon) self.toolbar.insert(button, -1) self.tag_widgets[icon] = button self.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) tool = gtk.ToolItem() tool.add(combobox) self.toolbar.insert(tool, -1) self.tag_widgets[name] = combobox self.toolbar.insert(gtk.SeparatorToolItem(), -1) button = None for icon in ['left', 'center', 'right', 'fill']: name = icon if icon == 'fill': name = 'justify' button = gtk.RadioToolButton(button, 'gtk-justify-%s' % icon) button.set_active(icon == 'left') button.connect('toggled', self.toggle_justification, name) self.toolbar.insert(button, -1) self.tag_widgets[name] = button self.toolbar.insert(gtk.SeparatorToolItem(), -1) self.colors = {} for icon, label in [ ('foreground', _('Foreground')), # TODO ('background', _('Background')), ]: button = gtk.ToolButton('tryton-text-%s' % icon) button.set_label(label) button.connect('clicked', self.toggle_color, icon) self.toolbar.insert(button, -1) self.tag_widgets[icon] = button
def __init__(self, uicore, buffer): super(InteractiveButtons, self).__init__(False, 1) self.buffer = buffer self.output_type = 'hexadecimal' # By default shows hexadecimal so no syntax highlight self.buffer.set_highlight_syntax(False) self.uicore = uicore self.toolbox = self self.int_tb = gtk.Toolbar() self.int_tb.set_style(gtk.TOOLBAR_ICONS) # Previous buffer button self.prev_ti = gtk.ToolItem() self.prev_align = gtk.Alignment(yalign=0.5) self.prev_ti.add(self.prev_align) self.prev = gtk.ToolButton(gtk.STOCK_GO_UP) self.prev.set_tooltip_text('Previous buffer') self.prev.connect("clicked", self.move, 'b') self.prev.label = 'Previous' self.prev_align.add(self.prev) self.int_tb.insert(self.prev_ti, 0) # Next buffer button self.next_ti = gtk.ToolItem() self.next_align = gtk.Alignment(yalign=0.5) self.next_ti.add(self.next_align) self.next = gtk.ToolButton(gtk.STOCK_GO_DOWN) self.next.set_tooltip_text('Next buffer') self.next.connect("clicked", self.move, 'f') self.next.label = 'Next' self.next_align.add(self.next) self.int_tb.insert(self.next_ti, 1) # Separator self.sep = gtk.SeparatorToolItem() self.int_tb.insert(self.sep, 2) # Seek to... self.seek_tb = gtk.ToolItem() self.seek_label = gtk.Label(' Seek: ') self.seek_tb.add(self.seek_label) self.int_tb.insert(self.seek_tb, 3) self.seek_entry_tb = gtk.ToolItem() self.seek_entry = gtk.Entry(100) self.seek_entry.set_icon_from_stock(1, gtk.STOCK_GO_FORWARD) self.seek_entry.set_icon_tooltip_text(1, 'Seek to') self.seek_entry.connect("activate", self.seek) self.seek_entry.connect("icon-press", self.seek) self.seek_entry_tb.add(self.seek_entry) self.int_tb.insert(self.seek_entry_tb, 4) # Separator self.sep = gtk.SeparatorToolItem() self.int_tb.insert(self.sep, 5) # Buffer size self.buffer_tb = gtk.ToolItem() self.buffer_label = gtk.Label(' Buffer size: ') self.buffer_tb.add(self.buffer_label) self.int_tb.insert(self.buffer_tb, 6) self.buffer_entry_tb = gtk.ToolItem() self.buffer_entry = gtk.Entry(100) self.buffer_entry.set_icon_from_stock(1, gtk.STOCK_APPLY) self.buffer_entry.set_icon_tooltip_text(1, 'Apply') self.buffer_entry.connect("activate", self.set_buffer_size) self.buffer_entry.connect("icon-press", self.set_buffer_size) self.buffer_entry_tb.add(self.buffer_entry) self.int_tb.insert(self.buffer_entry_tb, 7) # Separator self.sep = gtk.SeparatorToolItem() self.int_tb.insert(self.sep, 8) # Radio buttons (output format) self.hex_ti = gtk.ToolItem() self.hex_align = gtk.Alignment(yalign=0.5) self.hex_ti.add(self.hex_align) self.hex_button = gtk.RadioToolButton(None, None) self.hex_button.set_label("HEX") self.hex_button.connect("toggled", self.callback, "Hexadecimal") self.hex_button.set_active(True) self.hex_align.add(self.hex_button) self.int_tb.insert(self.hex_ti, 9) self.dasm_ti = gtk.ToolItem() self.dasm_align = gtk.Alignment(yalign=0.5) self.dasm_ti.add(self.dasm_align) self.dasm_button = gtk.RadioToolButton(self.hex_button, None) self.dasm_button.set_label("ASM") self.dasm_button.connect("toggled", self.callback, "Disassembly") self.dasm_align.add(self.dasm_button) self.int_tb.insert(self.dasm_ti, 10) if 'radare' in self.uicore.backend: # Separator self.sep = gtk.SeparatorToolItem() self.int_tb.insert(self.sep, 11) self.exec_entry_tb = gtk.ToolItem() self.exec_entry = gtk.Entry(100) self.exec_entry.set_icon_from_stock(1, gtk.STOCK_EXECUTE) self.exec_entry.set_icon_tooltip_text(1, 'Execute') self.exec_entry.connect("activate", self.r2_exec) self.exec_entry.connect("icon-press", self.r2_exec) self.exec_entry_tb.add(self.exec_entry) self.int_tb.insert(self.exec_entry_tb, 12) self.pack_start(self.int_tb, True, True) self.uicore.core.bsize = 512
def _controls(self): icon_arrow = gtk.image_new_from_file( os.path.join(paths.ICONS_DIR, "arrow.svg")) icon_transition = gtk.image_new_from_file( os.path.join(paths.ICONS_DIR, "transition.svg")) icon_place = gtk.image_new_from_file( os.path.join(paths.ICONS_DIR, "place.svg")) icon_arc = gtk.image_new_from_file( os.path.join(paths.ICONS_DIR, "arc.svg")) icon_area = gtk.image_new_from_file( os.path.join(paths.ICONS_DIR, "area.svg")) icon_trace = gtk.image_new_from_file( os.path.join(paths.ICONS_DIR, "trace.svg")) icon_simrun = gtk.image_new_from_file( os.path.join(paths.ICONS_DIR, "simrun.svg")) icon_verif = gtk.image_new_from_file( os.path.join(paths.ICONS_DIR, "verif.svg")) toolbar = gtk.Toolbar() button1 = gtk.RadioToolButton(None) button1.connect("toggled", lambda w: self.set_mode("edit")) button1.set_stock_id(gtk.STOCK_EDIT) toolbar.add(button1) button2 = gtk.RadioToolButton(button1, None) button2.connect("toggled", lambda w: self.set_mode("tracing")) button2.set_icon_widget(icon_trace) toolbar.add(button2) button2 = gtk.RadioToolButton(button1, None) button2.connect("toggled", lambda w: self.set_mode("simrun")) button2.set_icon_widget(icon_simrun) toolbar.add(button2) button2 = gtk.RadioToolButton(button1, None) button2.connect("toggled", lambda w: self.set_mode("verif")) button2.set_icon_widget(icon_verif) toolbar.add(button2) toolbar.add(gtk.SeparatorToolItem()) self.button_undo = gtk.ToolButton() self.button_undo.connect("clicked", lambda w: self.undo()) self.button_undo.set_stock_id(gtk.STOCK_UNDO) self.button_redo = gtk.ToolButton() self.button_redo.connect("clicked", lambda w: self.redo()) self.button_redo.set_stock_id(gtk.STOCK_REDO) toolbar.add(self.button_undo) toolbar.add(self.button_redo) toolbar.add(gtk.SeparatorToolItem()) button1 = gtk.RadioToolButton(None,None) button1.connect("toggled", lambda w: self.set_tool("selection")) button1.set_icon_widget(icon_arrow) self.button_selection = button1 button2 = gtk.RadioToolButton(button1,None) button2.connect("toggled", lambda w: self.set_tool("transition")) button2.set_icon_widget(icon_transition) button3 = gtk.RadioToolButton(button1,None) button3.connect("toggled", lambda w: self.set_tool("place")) button3.set_icon_widget(icon_place) button4 = gtk.RadioToolButton(button1,None) button4.connect("toggled", lambda w: self.set_tool("edge")) button4.set_icon_widget(icon_arc) button5 = gtk.RadioToolButton(button1,None) button5.connect("toggled", lambda w: self.set_tool("area")) button5.set_icon_widget(icon_area) toolbar.add(button1) toolbar.add(button2) toolbar.add(button3) toolbar.add(button4) toolbar.add(button5) toolbar.add(gtk.SeparatorToolItem()) button1 = gtk.ToolButton() button1.connect("clicked", lambda w: self.canvas.zoom_in()) button1.set_stock_id(gtk.STOCK_ZOOM_IN) button2 = gtk.ToolButton() button2.connect("clicked", lambda w: self.canvas.zoom_out()) button2.set_stock_id(gtk.STOCK_ZOOM_OUT) toolbar.add(button1) toolbar.add(button2) vbox = gtk.VBox() vbox.pack_start(toolbar) vbox.show_all() return vbox
def _controls(self): def add_radio_shortcut(accel_group, widget, key, ctrl=False): mask = 0 if ctrl: mask |= gtk.gdk.CONTROL_MASK accel_group.connect_group( gtk.gdk.keyval_from_name(key), mask, gtk.ACCEL_VISIBLE, lambda a, b, c, d: activate_radio(widget)) def activate_radio(widget): widget.set_active(True) icon_arrow = gtk.image_new_from_file( os.path.join(paths.ICONS_DIR, "arrow.svg")) icon_transition = gtk.image_new_from_file( os.path.join(paths.ICONS_DIR, "transition.svg")) icon_place = gtk.image_new_from_file( os.path.join(paths.ICONS_DIR, "place.svg")) icon_arc = gtk.image_new_from_file( os.path.join(paths.ICONS_DIR, "arc.svg")) icon_area = gtk.image_new_from_file( os.path.join(paths.ICONS_DIR, "area.svg")) icon_trace = gtk.image_new_from_file( os.path.join(paths.ICONS_DIR, "trace.svg")) icon_simrun = gtk.image_new_from_file( os.path.join(paths.ICONS_DIR, "simrun.svg")) icon_verif = gtk.image_new_from_file( os.path.join(paths.ICONS_DIR, "verif.svg")) toolbar = gtk.Toolbar() button1 = gtk.RadioToolButton(None) button1.connect("toggled", lambda w: self.set_mode("edit")) button1.set_stock_id(gtk.STOCK_EDIT) button1.set_tooltip_text("Edit") toolbar.add(button1) button2 = gtk.RadioToolButton(button1, None) button2.connect("toggled", lambda w: self.set_mode("tracing")) button2.set_tooltip_text("Tracing") button2.set_icon_widget(icon_trace) toolbar.add(button2) button2 = gtk.RadioToolButton(button1, None) button2.connect("toggled", lambda w: self.set_mode("simrun")) button2.set_tooltip_text("Simulation") button2.set_icon_widget(icon_simrun) toolbar.add(button2) button2 = gtk.RadioToolButton(button1, None) button2.connect("toggled", lambda w: self.set_mode("verif")) button2.set_tooltip_text("Verification") button2.set_icon_widget(icon_verif) toolbar.add(button2) toolbar.add(gtk.SeparatorToolItem()) self.button_undo = gtk.ToolButton() self.button_undo.connect("clicked", lambda w: self.undo()) self.button_undo.set_tooltip_text("Undo") self.button_undo.set_stock_id(gtk.STOCK_UNDO) self.button_redo = gtk.ToolButton() self.button_redo.connect("clicked", lambda w: self.redo()) self.button_redo.set_tooltip_text("Redo") self.button_redo.set_stock_id(gtk.STOCK_REDO) toolbar.add(self.button_undo) toolbar.add(self.button_redo) toolbar.add(gtk.SeparatorToolItem()) ag = gtk.AccelGroup() self.app.window.add_accel_group(ag) button1 = gtk.RadioToolButton(None, None) button1.connect("toggled", lambda w: self.set_tool("selection")) button1.set_tooltip_text("Selection (Ctrl+S)") button1.set_icon_widget(icon_arrow) self.button_selection = button1 add_radio_shortcut(ag, button1, "s", ctrl=True) button2 = gtk.RadioToolButton(button1, None) button2.connect("toggled", lambda w: self.set_tool("transition")) button2.set_tooltip_text("Transition (Ctrl+R)") button2.set_icon_widget(icon_transition) add_radio_shortcut(ag, button2, "r", ctrl=True) button3 = gtk.RadioToolButton(button1, None) button3.connect("toggled", lambda w: self.set_tool("place")) button3.set_tooltip_text("Place (Ctrl+E)") button3.set_icon_widget(icon_place) add_radio_shortcut(ag, button3, "e", ctrl=True) button4 = gtk.RadioToolButton(button1, None) button4.connect("toggled", lambda w: self.set_tool("edge")) button4.set_tooltip_text("Edge (Ctrl+A)") button4.set_icon_widget(icon_arc) add_radio_shortcut(ag, button4, "a", ctrl=True) button5 = gtk.RadioToolButton(button1, None) button5.connect("toggled", lambda w: self.set_tool("area")) button5.set_tooltip_text("Area (Ctrl+B)") button5.set_icon_widget(icon_area) add_radio_shortcut(ag, button5, "b", ctrl=True) toolbar.add(button1) toolbar.add(button2) toolbar.add(button3) toolbar.add(button4) toolbar.add(button5) toolbar.add(gtk.SeparatorToolItem()) button1 = gtk.ToolButton() button1.connect("clicked", lambda w: self.canvas.zoom_in()) button1.set_tooltip_text("Zoom in") button1.set_stock_id(gtk.STOCK_ZOOM_IN) button2 = gtk.ToolButton() button2.connect("clicked", lambda w: self.canvas.zoom_out()) button2.set_tooltip_text("Zoom out") button2.set_stock_id(gtk.STOCK_ZOOM_OUT) toolbar.add(button1) toolbar.add(button2) vbox = gtk.VBox() vbox.pack_start(toolbar) vbox.show_all() return vbox
def __init__(self,num,icon,tooltip,size): self.num=num self.icon=icon self.tooltip=tooltip self.Item=gtk.RadioToolButton() self.Item.set_size_request(size,size)