def __init__(self, plugin, window): WindowExtension.__init__(self, plugin, window) self.preferences = plugin.preferences self._monitor = None # Init statusbar button self.statusbar_frame = gtk.Frame() self.statusbar_frame.set_shadow_type(gtk.SHADOW_IN) self.window.statusbar.pack_end(self.statusbar_frame, False) self.statusbar_button = gtk.ToggleButton( '<attachments>') # translated below button_set_statusbar_style(self.statusbar_button) self.statusbar_button.set_use_underline(True) self.__class__.toggle_fileview.connect_actionable( self, self.statusbar_button) self.statusbar_frame.add(self.statusbar_button) self.statusbar_frame.show_all() # Init browser widget opener = self.window.get_resource_opener() self.widget = AttachmentBrowserPluginWidget(self, opener, self.preferences) # FIXME FIXME FIXME - get rid of ui object here self.on_preferences_changed(plugin.preferences) self.connectto(plugin.preferences, 'changed', self.on_preferences_changed) # XXX if self.window.ui.page: self.on_open_page(self.window.ui, self.window.ui.page, self.window.ui.page) self.connectto(self.window.ui, 'open-page') self.connectto(self.window, 'pane-state-changed')
def create_gui_panel(self): self.logview = gtk.TextView() self.logview.set_editable(False) # Use a monospace font. This is safe - by testing - setting an # illegal font description has no effect. self.logview.modify_font(pango.FontDescription("monospace")) searchbox = gtk.HBox() entry = gtk.Entry() entry.connect("activate", self.enter_clicked, self.logview) searchbox.pack_start(entry, True) b = gtk.Button("Find Next") b.connect_object('clicked', self.on_find_clicked, self.logview, entry) searchbox.pack_start(b, False) self.hbox = gtk.HBox() self.freeze_button = gtk.ToggleButton("Dis_connect") self.freeze_button.set_active(False) self.freeze_button.connect("toggled", self.freeze_log) searchbox.pack_end(self.freeze_button, False) sw = gtk.ScrolledWindow() sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) sw.add(self.logview) self.logview.set_border_width(5) self.logview.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#fff")) self.vbox = gtk.VBox() self.log_label = gtk.Label("PATH") self.log_label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#00a")) self.vbox.pack_start(self.log_label, False) self.vbox.pack_start(sw, True) self.vbox.pack_start(searchbox, False) self.vbox.pack_start(self.hbox, False)
def get_entry(self, value_item): """Create a widget for this array element.""" bad_img = gtk.image_new_from_stock(gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_MENU) button = gtk.ToggleButton() button.options = [ rose.TYPE_LOGICAL_VALUE_FALSE, rose.TYPE_LOGICAL_VALUE_TRUE ] button.labels = [ rose.TYPE_LOGICAL_FALSE_TITLE, rose.TYPE_LOGICAL_TRUE_TITLE ] button.set_tooltip_text(value_item) if value_item in self.allowed_values: index = self.allowed_values.index(value_item) button.set_active(index) button.set_image(self.make_log_image(index)) button.set_label(button.labels[index]) else: button.set_inconsistent(True) button.set_image(bad_img) button.connect('toggled', self._switch_state_and_set) button.show() return button
def create_buttons(self): # create whiteboard button actions_hbox = self.chat_control.xml.get_object('actions_hbox') self.button = gtk.ToggleButton(label=None, use_underline=True) self.button.set_property('relief', gtk.RELIEF_NONE) self.button.set_property('can-focus', False) img = gtk.Image() img_path = self.plugin.local_file_path('tictactoe.png') pixbuf = gtk.gdk.pixbuf_new_from_file(img_path) iconset = gtk.IconSet(pixbuf=pixbuf) factory = gtk.IconFactory() factory.add('tictactoe', iconset) factory.add_default() img.set_from_stock('tictactoe', gtk.ICON_SIZE_MENU) self.button.set_image(img) send_button = self.chat_control.xml.get_object('send_button') send_button_pos = actions_hbox.child_get_property(send_button, 'position') actions_hbox.add_with_properties(self.button, 'position', send_button_pos - 1, 'expand', False) id_ = self.button.connect('toggled', self.on_tictactoe_button_toggled) self.chat_control.handlers[id_] = self.button self.button.show()
def __init__(self, host='localhost', port='2947', device=None, debug=0): self.host = host self.port = port self.device = device self.debug = debug self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.set_size_request(WIN_X, WIN_Y) if not self.window.get_display(): raise Exception("Can't open display") self.window.set_title('Navigator') self.widget = Navigation() self.window.connect('delete_event', self.delete_event) self.window.connect('destroy', self.destroy) self.widget.show() vbox = gtk.VBox(False, 0) self.window.add(vbox) self.window.present() buttonbox = gtk.HButtonBox() buttonbox.set_layout(gtk.BUTTONBOX_END) button_toggle_placemark = gtk.ToggleButton('Placemark') button_toggle_placemark.connect('toggled', self.toggle_placemark) buttonbox.pack_start(button_toggle_placemark, expand=True, fill=True) button_dist = gtk.Button('ruler') button_dist.connect('clicked', self.distance_dialog) buttonbox.pack_start(button_dist, expand=True, fill=True) button_reset_rotate = gtk.Button('Reset Rotate') button_reset_rotate.connect('clicked', self.reset_rotate) buttonbox.pack_start(button_reset_rotate, expand=True, fill=True) vbox.pack_start(buttonbox, False, False, 0) vbox.add(self.widget) self.window.show_all() self.ruler_start = False self.dialog = False
def exc_error(cls, message, response_cb=None, title=_("Error!")): '''show an error dialog displaying the message and the traceback; this dialog should have only the option to close and the response callback is optional since in few cases one want to know when the error dialog was closed, but it can happen, so return stock.CLOSE to the callback if its set''' #cls.message_window('%s\n\n%s' % (message, traceback.format_exc()), # gtk.STOCK_DIALOG_ERROR, response_cb, title).show() window = gtk.Window() vbox = gtk.VBox() text = gtk.Label(message) vbox.pack_start(text) hide_button = gtk.ToggleButton('Show details') trace = gtk.Label(traceback.format_exc()) def on_hide(*args): if hide_button.get_active(): #show hide_button.set_label('Hide details') trace.show() else: hide_button.set_label('Show details') trace.hide() hide_button.connect('toggled', on_hide) close_button = gtk.Button(stock=gtk.STOCK_OK) def on_ok(*args): window.destroy() close_button.connect('clicked', on_ok) vbox.pack_start(hide_button, False, False) vbox.pack_start(trace) vbox.pack_start(close_button, False, False) window.add(vbox) window.show_all() on_hide()
def __init__(self): gtk.HBox.__init__(self) self._popping_down = False self._old_date = None self._block_changed = False # bootstrap problems, kiwi.ui.widgets.entry imports dateentry # we need to use a proxy entry because we want the mask from kiwi.ui.widgets.entry import ProxyEntry self.entry = ProxyEntry() # Set datatype before connecting to change event, to not get when the # mask is set self.entry.set_property('data-type', datetime.date) self.entry.connect('changed', self._on_entry__changed) self.entry.connect('activate', self._on_entry__activate) mask = self.entry.get_mask() if mask: self.entry.set_width_chars(len(mask)) self.pack_start(self.entry, False, False) self.entry.show() self._button = gtk.ToggleButton() self._button.connect('scroll-event', self._on_entry__scroll_event) self._button.connect('toggled', self._on_button__toggled) self._button.set_focus_on_click(False) self.pack_start(self._button, False, False) self._button.show() arrow = gtk.Arrow(gtk.ARROW_DOWN, gtk.SHADOW_NONE) self._button.add(arrow) arrow.show() self._popup = _DateEntryPopup(self) self._popup.connect('date-selected', self._on_popup__date_selected) self._popup.connect('hide', self._on_popup__hide) self._popup.set_size_request(-1, 24)
def fillCardsFrame(self, vbox): hbox1 = gtk.HBox(True, 0) hbox1.show() vbox.pack_start(hbox1, True, True, 0) cards = [ "A", "K", "Q", "J", "T", "9", "8", "7", "6", "5", "4", "3", "2" ] for j in range(0, len(cards)): hbox1 = gtk.HBox(True, 0) hbox1.show() vbox.pack_start(hbox1, True, True, 0) for i in range(0, len(cards)): if i < (j + 1): suit = "o" else: suit = "s" button = gtk.ToggleButton("%s%s%s" % (cards[i], cards[j], suit)) button.connect("toggled", self.cardCallback, "%s%s%s" % (cards[i], cards[j], suit)) hbox1.pack_start(button, True, True, 0) button.show()
def __init__(self, title='Array Cycler', default_width=DEFAULT_WIN_WIDTH, default_height=DEFAULT_WIN_HEIGHT, cadence=0.6): self.cadence = cadence self.viewport = Viewport() self.win = gtk.Window(gtk.WINDOW_TOPLEVEL) self.win.set_title(title) self.win.set_default_size(default_width, default_height) self.win.connect('key-press-event', self._on_key_press) self.win.connect('realize', self._on_realize) self.win.connect('unrealize', self._on_unrealize) vb = gtk.VBox() vb.pack_start(self.viewport, True, True, 2) hb = gtk.HBox() vb.pack_start(hb, False, True, 2) self.status_label = gtk.Label() self.status_label.set_alignment(0, 0.5) hb.pack_start(self.status_label, True, True, 2) self.plane_label = gtk.Label() self.plane_label.set_alignment(0, 0.5) hb.pack_start(self.plane_label, True, True, 2) self.desc_label = gtk.Label() hb.pack_start(self.desc_label, True, True, 2) self.cycle_tbutton = gtk.ToggleButton('Cycle') hb.pack_start(self.cycle_tbutton, False, True, 2) self.win.add(vb) self.viewport.setShapeGetter(self._get_shape) self.viewport.setSurfaceGetter(self._get_surface) self.viewport.setTuningSetter(self._set_tuning) self.cycle_tbutton.set_active(True)
def create_ui(self): mainvbox = gtk.VBox() hbox = gtk.HBox() self.adapterlist = gtk.combo_box_new_text() self.adapterlist.connect("changed", self.adapter_changed) self.initialtuning = gtk.combo_box_new_text() self.find_adapters_and_fill_list() hbox.add(self.adapterlist) hbox.add(self.initialtuning) scanbutton = gtk.Button("Scan") scanbutton.connect("clicked", self.scan_button_clicked) hbox.add(scanbutton) mainvbox.pack_start(hbox, fill=False, expand=False) scanvbox = gtk.VBox() self.label = gtk.Label("") self.progressbar = gtk.ProgressBar() scanvbox.pack_start(self.label, True, True, 3) scanvbox.pack_start(self.progressbar, True, True, 3) mainvbox.pack_start(scanvbox, fill=False, expand=False) self.channelstore = gtk.ListStore(str, int, int, int) self.channelstore.set_sort_column_id(2, gtk.SORT_ASCENDING) self.channelview = gtk.TreeView(self.channelstore) self.channelview.set_headers_visible(True) self.channelview.set_sensitive(True) namecol = gtk.TreeViewColumn("Channel", gtk.CellRendererText(), text=0) self.channelview.append_column(namecol) self.channelview.connect("row-activated", self.play_channel) channelscroll = gtk.ScrolledWindow() channelscroll.add(self.channelview) label = gtk.Label("Current Program:") eitscroll = gtk.ScrolledWindow() textview = gtk.TextView() textview.set_wrap_mode(gtk.WRAP_WORD) self.eittextbuffer = textview.get_buffer() eitscroll.add(textview) eitscroll.show() textview.show() channelvbox = gtk.VBox() channelvbox.pack_start(channelscroll) channelvbox.pack_start(label, False, False, 3) channelvbox.pack_start(eitscroll) playervbox = gtk.VBox() self.videowidget = VideoWidget() playervbox.pack_start(self.videowidget) hbox = gtk.HBox() playervbox.pack_start(hbox, fill=False, expand=False) self.pause_image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PAUSE, gtk.ICON_SIZE_BUTTON) self.pause_image.show() self.play_image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PLAY, gtk.ICON_SIZE_BUTTON) self.play_image.show() self.playbutton = button = gtk.Button() button.add(self.play_image) button.set_property('can-default', True) button.set_focus_on_click(False) button.set_size_request(40, 40) button.show() hbox.pack_start(button, False, False, 3) button.set_property('has-default', False) button.connect('clicked', lambda *args: self.play_toggled()) image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_NEXT, gtk.ICON_SIZE_BUTTON) image.show() button = gtk.Button() button.add(image) button.set_property('can-default', True) button.set_focus_on_click(False) button.set_size_request(40, 40) button.show() hbox.pack_start(button, False, False, 3) button.set_property('has-default', False) button.connect('clicked', lambda *args: self.seek_end_toggled()) self.adjustment = gtk.Adjustment(0.0, 0.00, 100.0, 0.1, 1.0, 1.0) hscale = gtk.HScale(self.adjustment) hscale.set_digits(2) hscale.set_update_policy(gtk.UPDATE_CONTINUOUS) hscale.connect('button-press-event', self.scale_button_press_cb) hscale.connect('button-release-event', self.scale_button_release_cb) hscale.connect('format-value', self.scale_format_value_cb) hbox.pack_start(hscale, True, True, 3) self.hscale = hscale image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_RECORD, gtk.ICON_SIZE_BUTTON) image.show() self.recordbutton = button = gtk.ToggleButton() button.add(image) button.set_focus_on_click(False) button.set_size_request(40, 40) button.show() hbox.pack_start(button, False, False, 3) button.connect('clicked', lambda *args: self.recording_toggled()) self.spinner = spinner = gtk.Spinner() spinner.show() spinner.size(32, 32) hbox.pack_start(spinner, False, True, 3) hbox = gtk.HBox() hbox.add(channelvbox) hbox.add(playervbox) mainvbox.add(hbox) # add widgets to window self.add(mainvbox)
def __init__(self): '''Konstruktor klasy MainWindow''' self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.set_title("elSter - console") self.window.connect("destroy", self.on_window1_destroy) self.window.set_border_width(0) self.container = gtk.HBox(gtk.FALSE, ConfigWindow.zmienna+1) self.container.set_border_width(10) self.vcontainer = gtk.VBox(gtk.FALSE,2) self.window.set_default_size((self.size_of_window * ConfigWindow.zmienna) + 10 * ConfigWindow.zmienna * ConfigWindow.iloscbt, (self.size_of_window * ConfigWindow.iloscbt) + 10 * ConfigWindow.zmienna * ConfigWindow.iloscbt) #self.window.set_default_size(640,320) self.scrolled_window = gtk.ScrolledWindow() self.scrolled_window.set_policy(gtk.POLICY_ALWAYS,gtk.POLICY_ALWAYS) self.scrolled_window.show() # self.window.add(self.vcontainer) self.window.add(self.vcontainer) # self.scrolled_window.add(self.menuTool()) # self.scrolled_window.add(self.container) #self.scrolled_window.add(self.container) #self.scrolled_window.set_size_request(640,320) # self.vcontainer.add(self.scrolled_window) self.vcontainer.pack_start(self.menuTool(),False,False,0) self.vcontainer.pack_start(self.container, False, False, 0) # # self.vcontainer.pack_start(self.scrolled_window,True,True,0) # self.cb_list = gtk.ListStore(str) # self.cb_keyboard = gtk.ComboBox(self.cb_list) # self.cb_cell = gtk.CellRendererText() # self.cb_keyboard.pack_start(self.cb_cell,True) # self.cb_keyboard.add_attribute(self.cb_cell,'text',0) # print alphabet # for i in range(47,91): # self.cb_list.append(alphabet[i-47]) # self.cb_keyboard.set_model(self.cb_list) # self.cb_keyboard.show() # global bt_table_id, bt_table '''Początek tworzenia tablic odpowiedzialnych za przechowywanie obiektów graficznych''' self.vBox = {} self.btBox = {} self.btBlackout = {} self.sb_address = {} self.sb_adjustment = {} self.bt_id = {} self.frame = {} self.hbox_for_frame = {} self.bt_address = {} self.bt_table_id = [[1 for x in range(ConfigWindow.iloscbt + 1)] for y in range(ConfigWindow.zmienna + 1)] self.bt_table = [[1 for bt_x in range(ConfigWindow.iloscbt + 1)] for bt_y in range(ConfigWindow.zmienna + 1)] '''Uzupełnianie głównego kontenera''' for num in range(1, ConfigWindow.zmienna + 1): self.vBox[num] = gtk.VBox(gtk.FALSE, ConfigWindow.zmienna) #self.vBox[num].set_size_request(1000,300) self.container.add(self.vBox[num]) self.vBox[num].show() '''Uzupełnianie kontenera o pionowe elementy''' for i in range(1, ConfigWindow.zmienna2 + 1): self.sb_adjustment[i] = gtk.Adjustment(i, 1, 100, 1, 5, 0) self.sb_address[i] = gtk.SpinButton(self.sb_adjustment[i], 0, 0) self.setBT(self.sb_address) self.sb_address[i].show() self.btBlackout[i] = gtk.ToggleButton("Blackout") self.btBlackout[i].connect("clicked", self.blackoutclock, i, self.bt_id) self.btBlackout[i].show() self.vBox[i].add(self.btBlackout[i]) print self.bt_table print self.bt_table_id for bt in range(1, ConfigWindow.iloscbt + 1): self.btBox[bt] = gtk.ToggleButton("LED" + str(bt)) # self.btBox[bt].connect('clicked',self.click,i,bt) self.btBox[bt].show() self.bt_id[bt] = self.btBox[bt].connect('clicked', self.click, i, bt) self.bt_id[0] = 0 try: self.bt_table[i][bt] = self.btBox[bt] except IndexError: print 'IndexError' self.bt_table_id[i][bt] = self.bt_id[bt] print self.btBox[bt] print self.bt_table # self.bt_table[i-1][bt-1] = self.btBox[bt] # for self.vBox in range(1,zmienna2+1): self.vBox[i].add(self.btBox[bt]) print self.btBox self.frame[i] = gtk.Frame("Change address") # self.bt_address[i] = gtk.Button("Change") self.lel = gtk.Frame() self.lel.set_border_width(5) self.bt_address[i] = gtk.Button("Change") self.bt_address[i].connect("clicked", self.click_change_address, i,self.sb_address[i]) self.frame[i].set_border_width(5) self.bt_address[i].set_border_width(10) self.frame[i].add(self.bt_address[i]) self.frame[i].show() self.bt_address[i].show() self.vBox[i].add(self.frame[i]) self.sb_adjustment[i].connect('value_changed', self.addressValueChange, i, self.bt_id, self.bt_table) print self.bt_id print self.bt_table_id self.vBox[i].add(self.sb_address[i]) self.printfuckingBT() '''Uruchomienie kilku ważnych wewnętrznych metod''' self.printfuckingBT() self.container.show() self.vcontainer.show() self.window.show()
def __init__(self, settings, config, sql, parent): self.importtimer = 0 self.settings = settings self.config = config self.sql = sql self.parent = parent imp = self.config.get_import_parameters() # print "Import parameters" # print imp self.input_settings = {} self.pipe_to_hud = None self.importer = fpdb_import.Importer(self, self.settings, self.config, self.sql) self.importer.setCallHud(True) self.importer.setMinPrint(settings['minPrint']) self.importer.setQuiet(False) self.importer.setFailOnError(False) self.importer.setHandCount(0) # self.importer.setWatchTime() self.server = settings['db-host'] self.user = settings['db-user'] self.password = settings['db-password'] self.database = settings['db-databaseName'] self.mainVBox = gtk.VBox(False,1) hbox = gtk.HBox(True, 0) # contains 2 equal vboxes self.mainVBox.pack_start(hbox, False, False, 0) vbox1 = gtk.VBox(True, 0) hbox.pack_start(vbox1, True, True, 0) vbox2 = gtk.VBox(True, 0) hbox.pack_start(vbox2, True, True, 0) self.intervalLabel = gtk.Label(_("Time between imports in seconds:")) self.intervalLabel.set_alignment(xalign=1.0, yalign=0.5) vbox1.pack_start(self.intervalLabel, False, True, 0) hbox = gtk.HBox(False, 0) vbox2.pack_start(hbox, False, True, 0) self.intervalEntry = gtk.Entry() self.intervalEntry.set_text(str(self.config.get_import_parameters().get("interval"))) hbox.pack_start(self.intervalEntry, False, False, 0) lbl1 = gtk.Label() hbox.pack_start(lbl1, expand=False, fill=True) lbl = gtk.Label('') vbox1.pack_start(lbl, expand=False, fill=True) lbl = gtk.Label('') vbox2.pack_start(lbl, expand=False, fill=True) self.addSites(vbox1, vbox2) self.textbuffer = gtk.TextBuffer() self.textview = gtk.TextView(self.textbuffer) hbox = gtk.HBox(False, 0) self.mainVBox.pack_start(hbox, expand=True, padding=3) hbox = gtk.HBox(False, 0) self.mainVBox.pack_start(hbox, expand=False, padding=3) lbl1 = gtk.Label() hbox.pack_start(lbl1, expand=True, fill=False) self.doAutoImportBool = False self.startButton = gtk.ToggleButton(_(" Start _Auto Import ")) self.startButton.connect("clicked", self.startClicked, "start clicked") hbox.pack_start(self.startButton, expand=False, fill=False) lbl2 = gtk.Label() hbox.pack_start(lbl2, expand=True, fill=False) hbox = gtk.HBox(False, 0) hbox.show() self.mainVBox.pack_start(hbox, expand=True, padding=3) scrolledwindow = gtk.ScrolledWindow() scrolledwindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.mainVBox.pack_end(scrolledwindow, expand=True) scrolledwindow.add(self.textview) self.mainVBox.show_all() self.addText(_("Auto Import Ready."))
def __init__(self, parent): super(JigsawPuzzleUI, self).__init__(border_color=COLOR_FRAME_OUTER) self._shuffling = False self._parent = parent # We want the translatables to be detected but not yet translated global _ _ = lambda x: x self.labels_to_translate = [] self._state = GAME_IDLE self._readonly = False self._join_time = 0 inner_table = gtk.Table(2, 2, False) self.add(inner_table) self.game = JigsawPuzzleWidget() self.game.connect('picked', self.piece_pick_cb, False) self.game.connect('dropped', self.piece_drop_cb) self.game.connect('solved', self.do_solve) self.game.connect('cutter-changed', self.cutter_change_cb) self.game.show() # panel is a holder for everything on the left side down to (not inclusive) the language dropdown panel = gtk.VBox() # Logo image img_logo = gtk.Image() img_logo.set_from_file("icons/logo.png") img_logo.show() panel.pack_start(img_logo, expand=False, fill=False) # Control panel has the image controls control_panel = BorderFrame(border=BORDER_ALL_BUT_BOTTOM, border_color=COLOR_FRAME_CONTROLS, bg_color=COLOR_BG_CONTROLS) control_panel_box = gtk.VBox() scrolled = gtk.ScrolledWindow() scrolled.props.hscrollbar_policy = gtk.POLICY_NEVER scrolled.props.vscrollbar_policy = gtk.POLICY_AUTOMATIC scrolled.show() scrolled.add_with_viewport(control_panel_box) scrolled.child.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(COLOR_BG_CONTROLS)) control_panel.add(scrolled) spacer = gtk.Label() spacer.set_size_request(-1, 5) control_panel_box.pack_start(spacer, expand=False, fill=False) btn_box = gtk.Table(2, 5, False) btn_box.set_col_spacings(5) btn_box.set_row_spacings(5) btn_box.attach(gtk.Label(), 0, 1, 0, 2) # Cut type buttons self.btn_basic_cut = gtk.ToggleButton() i = gtk.Image() i.set_from_pixbuf( utils.load_image(os.path.join('icons', 'cut_basic.svg'))) self.btn_basic_cut.set_image(i) btn_box.attach(prepare_btn(self.btn_basic_cut), 1, 2, 0, 1, 0, 0) self.btn_simple_cut = gtk.ToggleButton() i = gtk.Image() i.set_from_pixbuf( utils.load_image(os.path.join('icons', 'cut_simple.svg'))) self.btn_simple_cut.set_image(i) btn_box.attach(prepare_btn(self.btn_simple_cut), 2, 3, 0, 1, 0, 0) self.btn_classic_cut = gtk.ToggleButton() i = gtk.Image() i.set_from_pixbuf( utils.load_image(os.path.join('icons', 'cut_classic.svg'))) self.btn_classic_cut.set_image(i) # Link cutter buttons with cutter styles self.btn_cut_mapping = { 'basic': self.btn_basic_cut, 'simple': self.btn_simple_cut, 'classic': self.btn_classic_cut, } for k, v in self.btn_cut_mapping.items(): v.connect("released", self.set_piece_cut, k) btn_box.attach(prepare_btn(self.btn_classic_cut), 3, 4, 0, 1, 0, 0) # Difficulty level buttons self.btn_easy_level = gtk.ToggleButton() i = gtk.Image() i.set_from_pixbuf( utils.load_image(os.path.join('icons', 'level_easy.svg'))) self.btn_easy_level.set_active(True) self.btn_easy_level.set_image(i) btn_box.attach(prepare_btn(self.btn_easy_level), 1, 2, 1, 2, 0, 0) self.btn_normal_level = gtk.ToggleButton() i = gtk.Image() i.set_from_pixbuf( utils.load_image(os.path.join('icons', 'level_normal.svg'))) self.btn_normal_level.set_image(i) btn_box.attach(prepare_btn(self.btn_normal_level), 2, 3, 1, 2, 0, 0) self.btn_hard_level = gtk.ToggleButton() i = gtk.Image() i.set_from_pixbuf( utils.load_image(os.path.join('icons', 'level_hard.svg'))) self.btn_hard_level.set_image(i) # Link level buttons with levels self.btn_level_mapping = { 3: self.btn_easy_level, 5: self.btn_normal_level, 8: self.btn_hard_level, } for k, v in self.btn_level_mapping.items(): v.connect("released", self.set_level, k) btn_box.attach(prepare_btn(self.btn_hard_level), 3, 4, 1, 2, 0, 0) btn_box.attach(gtk.Label(), 4, 5, 0, 2) control_panel_box.pack_start(btn_box, expand=False) self.thumb = ImageSelectorWidget(frame_color=COLOR_FRAME_THUMB, prepare_btn_cb=prepare_btn, method=utils.RESIZE_PAD, image_dir="images", parent=self._parent) self.thumb.connect("category_press", self.do_select_category) self.thumb.connect("image_press", self.do_shuffle) control_panel_box.pack_start(self.thumb, expand=False) spacer = gtk.Label() spacer.set_size_request(-1, 5) control_panel_box.pack_start(spacer, expand=False, fill=False) # The game control buttons btn_box = gtk.Table(3, 4, False) btn_box.set_row_spacings(2) btn_box.attach(gtk.Label(), 0, 1, 0, 4) btn_box.attach(gtk.Label(), 2, 3, 0, 4) self.btn_solve = prepare_btn(gtk.Button(" "), 200) self.labels_to_translate.append([self.btn_solve, _("Solve")]) self.btn_solve.connect("clicked", self.do_solve) btn_box.attach(self.btn_solve, 1, 2, 0, 1, 0, 0) self.btn_shuffle = prepare_btn(gtk.Button(" "), 200) self.labels_to_translate.append([self.btn_shuffle, _("Shuffle")]) self.btn_shuffle.connect("clicked", self.do_shuffle) btn_box.attach(self.btn_shuffle, 1, 2, 1, 2, 0, 0) self.btn_add = prepare_btn(gtk.Button(" "), 200) self.labels_to_translate.append([self.btn_add, _("My Picture")]) self.btn_add.connect("clicked", self.do_add_image) btn_box.attach(self.btn_add, 1, 2, 2, 3, 0, 0) self.btn_hint = prepare_btn(gtk.ToggleButton(" "), 200) self.labels_to_translate.append([self.btn_hint, _("Board Hint")]) self.btn_hint.connect("clicked", self.do_show_hint) btn_box.attach(self.btn_hint, 1, 2, 3, 4, 0, 0) control_panel_box.pack_start(btn_box, False) self.control_panel_box = control_panel_box # Control panel end panel.pack_start(control_panel, expand=True, fill=True) inner_table.attach(panel, 0, 1, 0, 1, 0) self.game_box = BorderFrame(border_color=COLOR_FRAME_GAME) self.game_box.add(self.game) self.notebook = gtk.Notebook() self.notebook.show() self.notebook.props.show_border = False self.notebook.props.show_tabs = False self.notebook.append_page(self.game_box) inner_table.attach(self.notebook, 1, 2, 0, 1) lang_combo = prepare_btn( LanguageComboBox('org.worldwideworkshop.olpc.JigsawPuzzle')) lang_combo.connect('changed', self.do_select_language) # Push the gettext translator into the global namespace del _ lang_combo.install() lang_box = BorderFrame(bg_color=COLOR_BG_CONTROLS, border_color=COLOR_FRAME_CONTROLS) hbox = gtk.HBox(False) vbox = gtk.VBox(False) vbox.pack_start(lang_combo, padding=8) hbox.pack_start(vbox, padding=8) lang_box.add(hbox) inner_table.attach(lang_box, 0, 1, 1, 2, gtk.FILL, gtk.FILL) timer_box = BorderFrame(border=BORDER_ALL_BUT_LEFT, bg_color=COLOR_BG_CONTROLS, border_color=COLOR_FRAME_CONTROLS) timer_hbox = gtk.HBox(False) self.timer = TimerWidget(bg_color=COLOR_BG_BUTTONS[0][1], fg_color=COLOR_FG_BUTTONS[0][1], lbl_color=COLOR_BG_BUTTONS[1][1]) self.timer.set_sensitive(False) self.timer.set_border_width(3) self.labels_to_translate.append((self.timer, _("Time: "))) timer_hbox.pack_start(self.timer, False, padding=8) self.timer.connect('timer_toggle', self.timer_toggle_cb) self.msg_label = gtk.Label() self.msg_label.show() timer_hbox.pack_start(self.msg_label, True) self.do_select_language(lang_combo) self.buddy_panel = BuddyPanel(BUDDYMODE_COLLABORATION) self.buddy_panel.show() if not parent._shared_activity: self.do_select_category(self) self.set_contest_mode(False) # Assert consistent state self.cutter_change_cb(None, self.game.get_cutter(), self.game.get_target_pieces_per_line())
def new(self): self.channel = None # Styling for the label that appears when the list is empty hildon.hildon_helper_set_logical_font(self.empty_label, \ 'LargeSystemFont') hildon.hildon_helper_set_logical_color(self.empty_label, \ gtk.RC_FG, gtk.STATE_NORMAL, 'SecondaryTextColor') self.episode_actions = gPodderEpisodeActions(self.main_window, \ episode_list_status_changed=self.episode_list_status_changed, \ episode_is_downloading=self.episode_is_downloading, \ show_episode_shownotes=self.show_episode_shownotes, \ playback_episodes=self.playback_episodes, \ download_episode_list=self.download_episode_list, \ show_episode_in_download_manager=self.show_episode_in_download_manager, \ add_download_task_monitor=self.add_download_task_monitor, \ remove_download_task_monitor=self.remove_download_task_monitor, \ for_each_episode_set_task_status=self.for_each_episode_set_task_status, \ delete_episode_list=self.delete_episode_list) # Tap-and-hold (aka "long press") context menu self.touched_episode = None self.context_menu = gtk.Menu() # "Emulate" hildon_gtk_menu_new self.context_menu.set_name('hildon-context-sensitive-menu') self.context_menu.append(self.action_shownotes.create_menu_item()) self.context_menu.append(self.action_download.create_menu_item()) self.context_menu.append(self.action_delete.create_menu_item()) self.context_menu.append(gtk.SeparatorMenuItem()) self.context_menu.append(self.action_keep.create_menu_item()) self.context_menu.append(self.action_mark_as_old.create_menu_item()) self.context_menu.show_all() self.treeview.tap_and_hold_setup(self.context_menu) # Workaround for Maemo bug XXX self.button_search_episodes_clear.set_name('HildonButton-thumb') appmenu = hildon.AppMenu() for action in (self.action_update, \ self.action_rename, \ self.action_login, \ self.action_website, \ self.action_unsubscribe, \ self.action_check_for_new_episodes, \ self.action_delete_episodes): button = gtk.Button() action.connect_proxy(button) appmenu.append(button) self.pause_sub_button = hildon.CheckButton( gtk.HILDON_SIZE_FINGER_HEIGHT) self.pause_sub_button.set_label(_('Pause subscription')) self.pause_sub_button.connect( 'toggled', self.on_pause_subscription_button_toggled) appmenu.append(self.pause_sub_button) self.keep_episodes_button = hildon.CheckButton( gtk.HILDON_SIZE_FINGER_HEIGHT) self.keep_episodes_button.set_label(_('Keep episodes')) self.keep_episodes_button.connect('toggled', self.on_keep_episodes_button_toggled) appmenu.append(self.keep_episodes_button) for filter in (self.item_view_episodes_all, \ self.item_view_episodes_undeleted, \ self.item_view_episodes_downloaded): button = gtk.ToggleButton() filter.connect_proxy(button) appmenu.add_filter(button) appmenu.show_all() self.main_window.set_app_menu(appmenu)
def __init__(self, tab_domain): self.viewport = gtk.Viewport() self.viewport.set_shadow_type(gtk.SHADOW_NONE) self.vbox = gtk.VBox(spacing=3) self.alternate_viewport = gtk.Viewport() self.alternate_viewport.set_shadow_type(gtk.SHADOW_NONE) self.alternate_view = False self.search_window = None self.search_table = None self.last_search_text = '' self.tab_domain = tab_domain or [] self.tab_counter = [] tooltips = common.Tooltips() self.filter_vbox = gtk.VBox(spacing=0) self.filter_vbox.set_border_width(0) hbox = gtk.HBox(homogeneous=False, spacing=0) self.search_entry = PlaceholderEntry() self.search_entry.set_placeholder_text(_('Search')) self.search_entry.set_alignment(0.0) self.search_entry.set_icon_from_stock(gtk.ENTRY_ICON_PRIMARY, 'tryton-find') self.search_entry.set_icon_tooltip_text(gtk.ENTRY_ICON_PRIMARY, _('Open filters')) self.completion = gtk.EntryCompletion() self.completion.set_model(gtk.ListStore(str)) self.completion.set_text_column(0) self.completion.props.inline_selection = True self.completion.props.popup_set_width = False self.completion.set_match_func(lambda *a: True) self.completion.connect('match-selected', self.match_selected) self.search_entry.connect('activate', self.activate) self.search_entry.set_completion(self.completion) self.search_entry.connect('key-press-event', self.key_press) self.search_entry.connect('focus-in-event', self.focus_in) self.search_entry.connect('icon-press', self.icon_press) hbox.pack_start(self.search_entry, expand=True, fill=True) def popup(widget): menu = widget._menu for child in menu.get_children(): menu.remove(child) if not widget.props.active: menu.popdown() return def menu_position(menu, data=None): widget_allocation = widget.get_allocation() if hasattr(widget.window, 'get_root_coords'): x, y = widget.window.get_root_coords( widget_allocation.x, widget_allocation.y) else: x, y = widget.window.get_origin() x += widget_allocation.x y += widget_allocation.y return (x, y + widget_allocation.height, False) for id_, name, domain in self.bookmarks(): menuitem = gtk.MenuItem(name) menuitem.connect('activate', self.bookmark_activate, domain) menu.add(menuitem) menu.show_all() menu.popup(None, None, menu_position, 0, 0) def deactivate(menuitem, togglebutton): togglebutton.props.active = False but_bookmark = gtk.ToggleButton() self.but_bookmark = but_bookmark tooltips.set_tip(but_bookmark, _('Show bookmarks of filters')) img_bookmark = gtk.Image() img_bookmark.set_from_stock('tryton-bookmark', gtk.ICON_SIZE_SMALL_TOOLBAR) img_bookmark.set_alignment(0.5, 0.5) but_bookmark.add(img_bookmark) but_bookmark.set_relief(gtk.RELIEF_NONE) menu = gtk.Menu() menu.set_property('reserve-toggle-size', False) menu.connect('deactivate', deactivate, but_bookmark) but_bookmark._menu = menu but_bookmark.connect('toggled', popup) hbox.pack_start(but_bookmark, expand=False, fill=False) but_prev = gtk.Button() self.but_prev = but_prev tooltips.set_tip(but_prev, _('Previous')) but_prev.connect('clicked', self.search_prev) img_prev = gtk.Image() img_prev.set_from_stock('tryton-go-previous', gtk.ICON_SIZE_SMALL_TOOLBAR) img_prev.set_alignment(0.5, 0.5) but_prev.add(img_prev) but_prev.set_relief(gtk.RELIEF_NONE) hbox.pack_start(but_prev, expand=False, fill=False) but_next = gtk.Button() self.but_next = but_next tooltips.set_tip(but_next, _('Next')) but_next.connect('clicked', self.search_next) img_next = gtk.Image() img_next.set_from_stock('tryton-go-next', gtk.ICON_SIZE_SMALL_TOOLBAR) img_next.set_alignment(0.5, 0.5) but_next.add(img_next) but_next.set_relief(gtk.RELIEF_NONE) hbox.pack_start(but_next, expand=False, fill=False) hbox.show_all() hbox.set_focus_chain([self.search_entry]) self.filter_vbox.pack_start(hbox, expand=False, fill=False) hseparator = gtk.HSeparator() hseparator.show() self.filter_vbox.pack_start(hseparator, expand=False, fill=False) if self.tab_domain: self.notebook = gtk.Notebook() try: self.notebook.props.homogeneous = True except AttributeError: # No more supported by GTK+3 pass self.notebook.set_scrollable(True) for name, domain, count in self.tab_domain: hbox = gtk.HBox(spacing=3) label = gtk.Label('_' + name) label.set_use_underline(True) hbox.pack_start(label, expand=True, fill=True) counter = gtk.Label() hbox.pack_start(counter, expand=False, fill=True) hbox.show_all() self.notebook.append_page(gtk.VBox(), hbox) self.tab_counter.append(counter) self.filter_vbox.pack_start(self.notebook, expand=True, fill=True) self.notebook.show_all() # Set the current page before connecting to switch-page to not # trigger the search a second times. self.notebook.set_current_page(0) self.notebook.get_nth_page(0).pack_end(self.viewport) self.notebook.connect('switch-page', self.switch_page) self.notebook.connect_after('switch-page', self.switch_page_after) filter_expand = True else: self.notebook = None self.vbox.pack_end(self.viewport) filter_expand = False self.vbox.pack_start(self.filter_vbox, expand=filter_expand, fill=True) self.but_next.set_sensitive(False) self.but_prev.set_sensitive(False) tooltips.enable()
def __init__(self): gtk.EventBox.__init__(self) self.modify_bg(gtk.STATE_NORMAL, COLORES["contenido"]) self.set_border_width(4) self.game = False self.pump = False self.firstrun = True self.pygamecanvas = sugargame2.canvas.PygameCanvas(self) grupo1 = gtk.Alignment(0.5, 1, 0, 0) separador = gtk.HSeparator() grupo1.add(separador) grupo2 = gtk.Alignment(1, 0.5, 0, 0) grupo2.add(self.pygamecanvas) grupo3 = gtk.Alignment(1, 1, 0, 0) vbox = gtk.VBox() butt = gtk.Button() img = gtk.Image() img.set_from_file("Imagenes/go_back_disabled.png") butt.set_relief(gtk.RELIEF_NONE) butt.set_image(img) butt.set_label("") butt.modify_bg(gtk.STATE_NORMAL, COLORES["toolbar"]) butt.connect("clicked", self.__reset_menu) butt.connect("enter-notify-event", self.__color) butt.connect("leave-notify-event", self.__decolor) img.show() butt.show() vbox.add(butt) self.score_label = gtk.Label("SCORE\n0") self.score_label.set_property("justify", gtk.JUSTIFY_RIGHT) self.score_label.modify_font( pango.FontDescription("DejaVu Sans Mono 22")) self.score_label.modify_fg(gtk.STATE_NORMAL, COLORES["window"]) self.score_label.set_padding(xpad=30, ypad=30) self.score_label.show() vbox.add(self.score_label) butt = gtk.ToggleButton() butt.set_active(False) butt.set_relief(gtk.RELIEF_NONE) butt.modify_bg(gtk.STATE_NORMAL, COLORES["toolbar"]) img = gtk.Image() img.set_from_file("Iconos/stock_volume-max.svg") butt.set_image(img) butt.set_label("") img.show() butt.show() butt.connect("toggled", self.update_volume) self.volbtn = butt vbox.add(butt) grupo3.add(vbox) hb = gtk.HBox() hb.pack_start(grupo1) hb.add(grupo2) hb.pack_end(grupo3) self.add(hb) self.connect("size-allocate", self.__reescalar) self.show_all()
def __init__(self, url, title): gtk.FileChooserDialog.__init__(self, title, None, gtk.FILE_CHOOSER_ACTION_SAVE, backend="gnomevfs") self.set_local_only(False) self.URI = url self.uri = self.URI.get_url() self.select_uri(self.uri) ## self.set_current_folder (self.uri) ## self.set_current_name (self.uri) accelerator = gtk.AccelGroup() self.add_accel_group(accelerator) b = self.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT) b.add_accelerator('clicked', accelerator, gtk.keysyms.Escape, 0, 0) b = self.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK) b.add_accelerator('clicked', accelerator, gtk.keysyms.Return, 0, 0) b = self.add_button(gtk.STOCK_COPY, RESPONSE_COPY) b.add_accelerator('clicked', accelerator, gtk.keysyms.c, gtk.gdk.CONTROL_MASK, 0) b = self.add_button(gtk.STOCK_FIND, RESPONSE_VIEW) b.add_accelerator('clicked', accelerator, gtk.keysyms.v, gtk.gdk.CONTROL_MASK, 0) # added widgets vbox = gtk.VBox() hbox = gtk.HBox() vbox.pack_start(hbox) hbox.set_spacing(6) hbox.set_border_width(6) self.invalid_w = gtk.ToggleButton(_('Invalid')) hbox.pack_start(self.invalid_w, expand=False) tips.set_tip( self.invalid_w, "Set this to indicate an invalid URL", "An invalid url may not usually be used, " "but be kept for historical purposes.") self.invalid_w.set_active(self.URI.invalid or False) self.inexact_w = gtk.ToggleButton(_('Inexact')) hbox.pack_start(self.inexact_w, expand=False) tips.set_tip(self.inexact_w, "Indicates an URL that is not the resource proper", "An inexact URL usually requires manual intervention.") self.inexact_w.set_active(self.URI.inexact or False) hbox.pack_start(gtk.Label(_(' Date accessed:')), False) self.date_w = gtk.Entry() hbox.pack_start(self.date_w) tips.set_tip( self.date_w, "The date (and time) the resource has been accessed.", "This information is often required" " by bibliographical standards.") self.date_w.set_text(self.URI.date or '') hbox = gtk.HBox() vbox.pack_start(hbox) hbox.set_spacing(6) hbox.set_border_width(6) hbox.pack_start(gtk.Label(_('Note:')), False) self.note_w = gtk.Entry() hbox.pack_start(self.note_w) tips.set_tip(self.note_w, "A note e.g. about the resource or its accessability.", "Information that might help the user") self.note_w.set_text(self.URI.note or '') self.set_extra_widget(vbox) self.show_all()
def __init__(self, session): '''constructor''' gtk.VBox.__init__(self) self.session = session self.config_dir = session.config_dir self._enabled = True Avatar = extension.get_default('avatar') self.avatar = Avatar(cell_dimension=48) self.avatarBox = gtk.EventBox() self.avatarBox.set_events(gtk.gdk.BUTTON_PRESS_MASK) self.avatarBox.connect('button-press-event', self.on_avatar_click) self.avatarBox.add(self.avatar) self.avatarBox.set_tooltip_text(_('Click here to set your avatar')) self.avatarBox.set_border_width(4) self.avatar_path = self.config_dir.get_path("last_avatar") if not self.session.config_dir.file_readable(self.avatar_path): path = gui.theme.image_theme.user else: path = self.avatar_path self.avatar.set_from_file(path) self.nick = TextField.TextField(session.contacts.me.display_name, session.contacts.me.account, False) self.nick.set_tooltip_text(_('Click here to set your nick name')) self.status = StatusButton.StatusButton(session) self.status.set_tooltip_text(_('Click here to change your status')) self.status.set_status(session.contacts.me.status) self.search = gtk.ToggleButton() self.search.set_tooltip_text(_('Search (Ctrl+F)')) self.mail = gtk.Button(label="(0)") self.mail.set_tooltip_text(_('Click here to access your mail')) self.mail.get_settings().set_property("gtk-button-images", True) self.mail.set_image( gtk.image_new_from_file(gui.theme.image_theme.mailbox)) self.mail.set_relief(gtk.RELIEF_NONE) self.search.set_image( gtk.image_new_from_stock(gtk.STOCK_FIND, gtk.ICON_SIZE_MENU)) self.search.set_relief(gtk.RELIEF_NONE) self.empty_message_text = _("Click here to set your message") self.message = TextField.TextField( session.contacts.me.message, '[I]' + self.empty_message_text + '[/I]', True) self.message.set_tooltip_text(self.empty_message_text) self.toolbar = gtk.HBox() hbox = gtk.HBox() hbox.set_border_width(1) hbox.pack_start(self.avatarBox, False) vbox = gtk.VBox() nick_hbox = gtk.HBox() nick_hbox.pack_start(self.nick, True, True) nick_hbox.pack_start(self.mail, False) nick_hbox.pack_start(self.search, False) # enable this code and you'll get a nice button which fires a signal #def do_something_weird(item): # from e3.base.Event import Event # session.add_event(Event.EVENT_DISCONNECTED, 'Tested disconnection', 0) #test_btn=gtk.Button(label="(!)") #test_btn.connect('clicked', do_something_weird) #test_btn.show() #nick_hbox.pack_start(test_btn, False) vbox.pack_start(nick_hbox, False) message_hbox = gtk.HBox() message_hbox.pack_start(self.message, True, True) message_hbox.pack_start(self.status, False) vbox.pack_start(message_hbox, False) hbox.pack_start(vbox, True, True) self.pack_start(hbox, True, True) self.pack_start(self.toolbar, False) hbox.show() nick_hbox.show() message_hbox.show() vbox.show() self._add_subscriptions()
def __init__(self, gfxwindow): self.gfxwindow = gfxwindow buttonrow = gtk.HBox() # TODO 3D: make better icons for each of these, this is # complicated, we have to find a way to not use absolute # paths, and to include the icons in the build.... ## select_image = gtk.Image() ## select_image.set_from_file("/users/vrc/i686_4.0/stow/oof2-dist3d-2.4/lib/python2.4/site-packages/oof3d/ooflib/common/IO/GUI/icons/select.png") ## rotate_image = gtk.Image() ## rotate_image.set_from_file("/users/vrc/i686_4.0/stow/oof2-dist3d-2.4/lib/python2.4/site-packages/oof3d/ooflib/common/IO/GUI/icons/rotate.png") ## dolly_image = gtk.Image() ## dolly_image.set_from_file("/users/vrc/i686_4.0/stow/oof2-dist3d-2.4/lib/python2.4/site-packages/oof3d/ooflib/common/IO/GUI/icons/dolly.png") # Use the "pressed" and "released" signals because the "clicked" signal is # emitted when the state is changed by setactive self.selectbutton = gtk.ToggleButton("Select") #self.selectbutton.set_image(select_image) buttonrow.pack_start(self.selectbutton) tooltips.set_tooltip_text( self.selectbutton, "Select objects according to toolbox behavior") gtklogger.connect(self.selectbutton, "pressed", self.selectCB) gtklogger.connect(self.selectbutton, "released", self.selectReleaseCB) self.tumblebutton = gtk.ToggleButton("Tumble") #self.tumblebutton.set_image(rotate_image) buttonrow.pack_start(self.tumblebutton) tooltips.set_tooltip_text(self.tumblebutton, "Tumble the view using the mouse") gtklogger.connect(self.tumblebutton, "pressed", self.tumbleCB) gtklogger.connect(self.tumblebutton, "released", self.tumbleReleaseCB) self.dollybutton = gtk.ToggleButton("Dolly") #self.dollybutton.set_image(dolly_image) buttonrow.pack_start(self.dollybutton) tooltips.set_tooltip_text(self.dollybutton, "Dolly in and out using the mouse") gtklogger.connect(self.dollybutton, "pressed", self.dollyCB) gtklogger.connect(self.dollybutton, "released", self.dollyReleaseCB) self.trackbutton = gtk.ToggleButton("Track") buttonrow.pack_start(self.trackbutton) tooltips.set_tooltip_text( self.trackbutton, "Move camera and visible objects parallel to focal plane") gtklogger.connect(self.trackbutton, "pressed", self.trackCB) gtklogger.connect(self.trackbutton, "released", self.trackReleaseCB) # TODO 3D: separator between stateful and non-stateful buttons? self.fillbutton = gtk.Button("Fill") buttonrow.pack_start(self.fillbutton) tooltips.set_tooltip_text( self.fillbutton, "Dolly in or out such that visible objects approximately fill viewport" ) gtklogger.connect(self.fillbutton, "clicked", self.fillCB) clippingscale = gtk.HScale(toolboxGUI.clippingadj) clippingscale.set_update_policy(gtk.UPDATE_DELAYED) clippingscale.set_value_pos(gtk.POS_RIGHT) buttonrow.pack_start(clippingscale) tooltips.set_tooltip_text( clippingscale, "Adjust the near clipping plane to view cross section") # TODO 3D: more useful things in the toolbar? self.gtk = buttonrow # self.selectHandler = SelectMouseHandler(gfxwindow) self.tumbleHandler = TumbleMouseHandler(gfxwindow) self.dollyHandler = DollyMouseHandler(gfxwindow) self.trackHandler = TrackMouseHandler(gfxwindow) self.selectbutton.set_active(True)
def __init__(self, *args, **kwargs): super(BrowserTab, self).__init__(*args, **kwargs) h = History() row = h.get_bookmark_list() for r in row: bookmarks_list.append(r[0]) self.zeronet_button = gtk.ToggleButton() self.zeronet_button.set_size_request(50, 50) self.zeronet_button.connect("clicked", self.start_zeronet) self.bottom_hpan = gtk.HPaned() self.webview = webkit.WebView() scrolled_window = gtk.ScrolledWindow() self.webview.connect("load-finished", self.on_finish_loading) self.webview.connect("download-requested", self.initiate_download) scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scrolled_window.add(self.webview) self.history_window = gtk.ScrolledWindow() self.history_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.history_window.set_size_request(200, 10) self.history_box = gtk.VBox() header_hbox = gtk.HBox() header = gtk.Label("History") close_button = gtk.Button() image = gtk.Image() image.set_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_MENU) close_button.connect("clicked", self.hide_history) close_button.set_image(image) close_button.set_relief(gtk.RELIEF_NONE) header_hbox.pack_start(header, True, True, 0) header_hbox.pack_end(close_button, False, False, 0) self.history_box.pack_start(header_hbox, False, False, 0) self.history_list_store = gtk.ListStore(str) self.history_tree_view = gtk.TreeView(self.history_list_store) self.history_box.pack_start(self.history_window, True, True, 0) self.history_window.add_with_viewport(self.history_tree_view) self.bookmarks_window = gtk.ScrolledWindow() self.bookmarks_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.bookmarks_box = gtk.VBox() self.bookmarks_window.set_size_request(200, 10) header_hbox = gtk.HBox() header = gtk.Label("Bookmarks") close_button = gtk.Button() image = gtk.Image() image.set_from_stock(gtk.STOCK_CLOSE, gtk.ICON_SIZE_MENU) close_button.connect("clicked", self.hide_bookmarks) close_button.set_image(image) close_button.set_relief(gtk.RELIEF_NONE) header_hbox.pack_start(header, True, True, 0) header_hbox.pack_end(close_button, False, False, 0) self.bookmarks_box.pack_start(header_hbox, False, False, 0) self.bookmarks_list_store = gtk.ListStore(str) self.bookmarks_tree_view = gtk.TreeView(self.bookmarks_list_store) self.bookmarks_box.pack_start(self.bookmarks_window, True, True, 0) self.bookmarks_window.add_with_viewport(self.bookmarks_tree_view) self.find_entry = gtk.Entry() self.find_entry.connect( "activate", lambda x: self.webview.search_text( self.find_entry.get_text(), False, True, True)) find_box = gtk.HBox() close_button = gtk.Button("Close") close_button.connect("clicked", lambda x: find_box.hide()) prev_button = gtk.Button("Previous") next_button = gtk.Button("Next") prev_button.connect( "clicked", lambda x: self.webview.search_text( self.find_entry.get_text(), False, False, True)) next_button.connect( "clicked", lambda x: self.webview.search_text( self.find_entry.get_text(), False, True, True)) find_box.pack_start(close_button, False, False, 0) find_box.pack_start(self.find_entry, False, False, 0) find_box.pack_start(prev_button, False, False, 0) find_box.pack_start(next_button, False, False, 0) self.find_box = find_box self.pack_end(find_box, False, False, 0) main_hbox = gtk.HBox(False, 0) menu_url_vbox = gtk.VBox(False, 0) menu_hbox = gtk.HBox(False, 0) url_hbox = gtk.HBox(False, 0) image = gtk.Image() self.new_tab_button = gtk.Button() image.set_from_stock(gtk.STOCK_NEW, gtk.ICON_SIZE_MENU) self.new_tab_button.set_image(image) self.new_tab_button.set_relief(gtk.RELIEF_NONE) self.menu1 = gtk.Button("Create") self.menu1.connect("clicked", self.create_site) self.menu2 = gtk.Button("Update") self.menu2.connect("clicked", self.signSite) self.menu3 = gtk.Button("Publish") self.menu3.connect("clicked", self.publish_site) self.settings = gtk.Button() image = gtk.Image() image.set_from_stock(gtk.STOCK_EXECUTE, gtk.ICON_SIZE_MENU) self.settings.set_image(image) self.settings.set_size_request(78, 30) self.settings.set_relief(gtk.RELIEF_NONE) self.menu = gtk.Menu() self.menu_items = ["New Tab", "History", "Bookmarks", "About", "Quit"] for i in self.menu_items: menu_item = gtk.MenuItem(i) self.menu.append(menu_item) menu_item.connect("activate", self.menuitem_response, i) menu_item.show() self.settings.connect("event", self.menu_show) self.url_textbox = gtk.Entry() self.go_back = gtk.Button() image = gtk.Image() image.set_from_stock(gtk.STOCK_GO_BACK, gtk.ICON_SIZE_MENU) self.go_back.set_image(image) self.go_back.connect("clicked", lambda x: self.webview.go_back()) self.go_back.set_relief(gtk.RELIEF_NONE) self.url_textbox.connect("activate", self.load_url) image = gtk.Image() self.go_forward = gtk.Button() image.set_from_stock(gtk.STOCK_GO_FORWARD, gtk.ICON_SIZE_MENU) self.go_forward.set_image(image) self.go_forward.connect("clicked", lambda x: self.webview.go_forward()) self.go_forward.set_relief(gtk.RELIEF_NONE) image = gtk.Image() image.set_from_file("not_bookmarked.ico") self.bookmark_image = gtk.ToggleButton() self.bookmark_image.set_image(image) self.bookmark_image.set_active(False) vertical_line = gtk.VSeparator() image = gtk.Image() self.bookmark_button = gtk.Button() image.set_from_stock(gtk.STOCK_INDEX, gtk.ICON_SIZE_MENU) self.bookmark_button.set_image(image) self.bookmark_button.connect("clicked", self.add_bookmark) self.bookmark_button.set_relief(gtk.RELIEF_NONE) image = gtk.Image() self.refresh = gtk.Button() image.set_from_stock(gtk.STOCK_REFRESH, gtk.ICON_SIZE_MENU) self.refresh.set_image(image) self.refresh.connect("clicked", lambda x: self.webview.reload()) self.refresh.set_relief(gtk.RELIEF_NONE) self.secure_icon = gtk.Image() self.secure_button = gtk.Button() self.secure_icon.set_from_stock(gtk.STOCK_INFO, gtk.ICON_SIZE_MENU) self.secure_button.set_image(self.secure_icon) self.dialog = gtk.Dialog(title="ZeroNet") self.pbar = gtk.ProgressBar() self.pbar.set_text("Starting Zeronet") self.dialog.vbox.pack_start(self.pbar, True, True, 0) self.pbar.show() self.pack_start(main_hbox, False, False, 0) main_hbox.pack_start(menu_url_vbox, True, True, 0) menu_url_vbox.pack_start(menu_hbox, True, True, 0) menu_hbox.pack_start(self.new_tab_button, False, True, 0) menu_hbox.pack_start(self.menu1, True, True, 0) menu_hbox.pack_start(self.menu2, True, True, 0) menu_hbox.pack_start(self.menu3, True, True, 0) menu_hbox.pack_end(self.settings, False, False, 0) menu_url_vbox.pack_start(url_hbox, True, True, 0) url_hbox.pack_start(self.go_back, False, False, 0) url_hbox.pack_start(self.secure_button, False, False, 0) url_hbox.pack_start(self.url_textbox, True, True, 0) url_hbox.pack_start(self.refresh, False, False, 0) url_hbox.pack_start(self.go_forward, False, False, 0) url_hbox.pack_start(self.bookmark_image, False, False, 0) url_hbox.pack_start(vertical_line, False, False, 2) url_hbox.pack_start(self.bookmark_button, False, False, 0) main_hbox.pack_start(self.zeronet_button, False, False, 0) self.bottom_hpan.add2(scrolled_window) self.pack_start(self.bottom_hpan, True, True, 0) scrolled_window.show_all() main_hbox.show_all() self.bottom_hpan.show() image = gtk.Image() if not pid: image.set_from_file("2.png") self.zeronet_button.set_image(image) self.zeronet_button.set_active(False) else: image.set_from_file("1.png") self.zeronet_button.set_image(image) self.zeronet_button.set_active(True) self.show()
def __init__(self): # Create a TOPLEVEL WINDOW self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) # Set the postion of WINDOW to center self.window.set_position(gtk.WIN_POS_CENTER) # Set window title self.window.set_title("Sample GTK window") # Set tool tip self.window.set_tooltip_text("This a sample GTK window") # Set window size self.window.set_size_request(600, 100) # BUTTON1 # Simple sample button with text as EXIT self.button1 = gtk.Button("EXIT") # On button EXIT clicked destory the window self.button1.connect("clicked", self.destroy) # Set tool tips self.button1.set_tooltip_text("This button will close this window") # BUTTON2 # Simple sample button with text as EXIT self.button2 = gtk.Button("Hide") # On button EXIT clicked destory the window self.button2.connect("clicked", self.hideit) # Set tool tips self.button2.set_tooltip_text("This button will hide the exit button") # BUTTON3 # Simple sample button with text as EXIT self.button3 = gtk.ToggleButton("Show") # On button EXIT clicked destory the window self.button3.connect("clicked", self.showit) # Set tool tips self.button3.set_tooltip_text("This button will show the exit button") # BUTTON4 self.button4 = gtk.Button("Relable") self.button4.connect("clicked", self.relable) # Create a simple label self.label1 = gtk.Label("This is a label") #TEXTBOX, connect textchange method, for the signal changed self.textbox = gtk.Entry() self.textbox.set_text("As you type see the window title") self.textbox.connect("changed", self.textchange) """ # A simple container fixed = gtk.Fixed() # Put buttons to the container fixed.put(self.button1,20,30) fixed.put(self.button2,100,30) fixed.put(self.button3,150,30) fixed.put(self.label1,200,100) """ """ Comment this to section and uncomment fxied container, to see how Fixed works. One can change VBox to HBox to see th difference """ # Combo box self.combo = gtk.combo_box_entry_new_text() self.combo.connect("changed", self.combo_text) self.combo.append_text("This is some text") self.combo.append_text("Some more text") # HBox self.box1 = gtk.HBox() self.box1.pack_start(self.button1) self.box1.pack_start(self.button2) self.box1.pack_start(self.button3) self.box1.pack_start(self.button4) # self.box1.pack_start(self.textbox) # self.box1.pack_start(self.label1) # Above was added to VBox to make it better # VBox self.box2 = gtk.VBox() # Pack HBox in VBox self.box2.pack_start(self.box1) self.box2.pack_start(self.label1) self.box2.pack_start(self.textbox) self.box2.pack_start(self.combo) # Add fixed container to the main window # self.window.add(fixed) # If box enabled, uncomment the above and comment below line self.window.add(self.box2) # Show the created window, button...all self.window.show_all() # Connect destroy singal of the window to destory method [X] self.window.connect("destroy", self.destroy)
class ImagesDemo(hildon.Window): pixbuf_loader = None load_timeout = None image_stream = None def __init__(self, parent=None): hildon.Window.__init__(self) try: self.set_screen(parent.get_screen()) except AttributeError: self.connect('destroy', lambda *w: gtk.main_quit()) self.connect("destroy", self.cleanup_callback) self.set_title(self.__class__.__name__) self.set_border_width(8) scroll = gtk.ScrolledWindow() scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.add(scroll) vbox = gtk.VBox(False, 8) vbox.set_border_width(8) scroll.add_with_viewport(vbox) label = gtk.Label(); label.set_markup("<u>Image loaded from a file</u>") vbox.pack_start(label, False, False, 0) frame = gtk.Frame() frame.set_shadow_type(gtk.SHADOW_IN) # The alignment keeps the frame from growing when users resize # the window align = gtk.Alignment(0.5, 0.5, 0, 0) align.add(frame) vbox.pack_start(align, False, False, 0) image = gtk.Image() # use the current directory for the file try: pixbuf = gtk.gdk.pixbuf_new_from_file(GTKLOGO_IMAGE) image.set_from_pixbuf(pixbuf) except gobject.GError, error: # This code shows off error handling. You can just use # gtk_image_new_from_file() instead if you don't want to report # errors to the user. If the file doesn't load when using # gtk_image_new_from_file(), a "missing image" icon will # be displayed instead. dialog = gtk.MessageDialog(self, gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, "Unable to open image file 'gtk-logo-rgb.gif': \n%s" % error) dialog.connect("response", lambda dlg, resp: dlg.destroy()) dialog.show() frame.add(image) # Animation label = gtk.Label() label.set_markup("<u>Animation loaded from a file</u>") vbox.pack_start(label, False, False, 0) frame = gtk.Frame() frame.set_shadow_type(gtk.SHADOW_IN) # The alignment keeps the frame from growing when users resize # the window align = gtk.Alignment(0.5, 0.5, 0, 0) align.add(frame) vbox.pack_start(align, False, False, 0) image = gtk.Image() image.set_from_file(BUDDY_IMAGE); frame.add(image) # Progressive label = gtk.Label() label.set_markup("<u>Progressive image loading</u>") vbox.pack_start(label, False, False, 0) frame = gtk.Frame() frame.set_shadow_type(gtk.SHADOW_IN) # The alignment keeps the frame from growing when users resize # the window align = gtk.Alignment(0.5, 0.5, 0, 0) align.add(frame) vbox.pack_start(align, False, False, 0) # Create an empty image for now; the progressive loader # will create the pixbuf and fill it in. image = gtk.Image() image.set_from_pixbuf(None) frame.add(image) self.start_progressive_loading(image) # Sensitivity control button = gtk.ToggleButton("_Insensitive"); vbox.pack_start(button, False, False, 0) button.connect("toggled", self.on_sensitivity_toggled, vbox) self.show_all()
def initWidget(self, opt, value): """ Initialize the option widget. The widget type is selected automatically based in the option type and the set/range of valid values. """ type = opt.type if not self.isValid: type = "invalid" if type == "bool": self.widget = gtk.ToggleButton() self.widget.set_use_stock(True) # Make sure the button doesn't change size when toggled self.widget.set_label("gtk-yes") wYes = self.widget.size_request()[0] self.widget.set_label("gtk-no") wNo = self.widget.size_request()[0] self.widget.set_size_request(max(wYes, wNo), -1) if value: self.widget.set_label("gtk-yes") else: self.widget.set_label("gtk-no") self.widget.set_active(value) self.widget.connect("toggled", self.activateSignal) elif type == "int" and opt.valid and len(opt.valid) == 1: self.widget = SlideSpinner(self.activateSignal, opt.valid[0].start, opt.valid[0].end, True) self.widget.setValue(value) elif type == "float" and opt.valid and len(opt.valid) == 1: self.widget = SlideSpinner(self.activateSignal, opt.valid[0].start, opt.valid[0].end, False) self.widget.setValue(value) elif type == "enum" or \ (type != "invalid" and opt.valid and reduce (lambda x,y: x and y, map(dri.Range.empty, opt.valid))): desc = opt.getDesc([lang]) optValList = [] for r in opt.valid: if type == "enum": for v in range(r.start, r.end + 1): vString = dri.ValueToStr(v, type) if type == "enum" and desc and desc.enums.has_key(v): string = desc.enums[v] else: string = vString optValList.append((string, vString)) else: vString = dri.ValueToStr(r.start, type) optValList.append((vString, vString)) self.widget = WrappingOptionMenu(optValList, self.activateSignal, width=180) self.widget.setValue(str(value)) else: self.widget = gtk.Entry() if type == "invalid": self.widget.set_text(value) else: self.widget.set_text(dri.ValueToStr(value, type)) self.widget.connect("changed", self.activateSignal) self.highlightInvalid() self.widget.show()
def realize(self): self.channel = self.mixer.add_channel(self.channel_name, self.stereo) if self.channel == None: raise Exception, "Cannot create a channel" Channel.realize(self) if self.future_volume_midi_cc != None: self.channel.volume_midi_cc = self.future_volume_midi_cc if self.future_balance_midi_cc != None: self.channel.balance_midi_cc = self.future_balance_midi_cc if self.future_mute_midi_cc != None: self.channel.mute_midi_cc = self.future_mute_midi_cc if self.future_solo_midi_cc != None: self.channel.solo_midi_cc = self.future_solo_midi_cc if self.app._init_solo_channels and self.channel_name in self.app._init_solo_channels: self.channel.solo = True self.channel.midi_scale = self.slider_scale.scale self.on_volume_changed(self.slider_adjustment) self.on_balance_changed(self.balance_adjustment) # vbox child at upper part self.vbox = gtk.VBox() self.pack_start(self.vbox, False) self.label_name = gtk.Label() self.label_name.set_text(self.channel_name) self.label_name.set_size_request(0, -1) self.label_name_event_box = gtk.EventBox() self.label_name_event_box.connect("button-press-event", self.on_label_mouse) self.label_name_event_box.add(self.label_name) self.vbox.pack_start(self.label_name_event_box, True) # self.label_stereo = gtk.Label() # if self.stereo: # self.label_stereo.set_text("stereo") # else: # self.label_stereo.set_text("mono") # self.label_stereo.set_size_request(0, -1) # self.vbox.pack_start(self.label_stereo, True) self.hbox_mutesolo = gtk.HBox() self.mute = gtk.ToggleButton() self.mute.set_label("M") self.mute.set_active(self.channel.out_mute) self.mute.connect("toggled", self.on_mute_toggled) self.hbox_mutesolo.pack_start(self.mute, True) self.solo = gtk.ToggleButton() self.solo.set_label("S") self.solo.set_active(self.channel.solo) self.solo.connect("toggled", self.on_solo_toggled) self.hbox_mutesolo.pack_start(self.solo, True) self.vbox.pack_start(self.hbox_mutesolo, False) frame = gtk.Frame() frame.set_shadow_type(gtk.SHADOW_IN) frame.add(self.abspeak) self.pack_start(frame, False) # hbox child at lower part self.hbox = gtk.HBox() self.hbox.pack_start(self.slider, True) frame = gtk.Frame() frame.set_shadow_type(gtk.SHADOW_IN) frame.add(self.meter) self.hbox.pack_start(frame, True) frame = gtk.Frame() frame.set_shadow_type(gtk.SHADOW_IN) frame.add(self.hbox) self.pack_start(frame, True) self.volume_digits.set_size_request(0, -1) self.pack_start(self.volume_digits, False) self.create_balance_widget() self.monitor_button = gtk.ToggleButton('MON') self.monitor_button.connect('toggled', self.on_monitor_button_toggled) self.pack_start(self.monitor_button, False, False)
def __init__(self, command, stdoutfile, width=400, height=400, standalone=False, ignore_command=False, title=None): self.standalone = standalone self.command = command self.ignore_command = ignore_command self.stdout = stdoutfile self.stdout_updater = None self.proc = None self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.set_border_width(5) if title is None: self.window.set_title('Command Output') else: self.window.set_title(title) self.window.connect("delete_event", self.quit) self.window.set_default_size(width, height) self.window.set_icon(get_icon()) self.quit_already = False self.find_current = None self.find_current_iter = None self.search_warning_done = False sw = gtk.ScrolledWindow() sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) sw.show() self.textview = gtk.TextView() self.textview.set_editable(False) self.textview.set_wrap_mode(gtk.WRAP_WORD) # Use a monospace font. This is safe - by testing - setting an # illegal font description has no effect. self.textview.modify_font(pango.FontDescription("monospace")) tb = self.textview.get_buffer() self.textview.show() self.ftag = tb.create_tag(None, background="#70FFA9") vbox = gtk.VBox() vbox.show() if not self.ignore_command: self.progress_bar = gtk.ProgressBar() self.progress_bar.set_text(command) self.progress_bar.set_pulse_step(0.04) self.progress_bar.show() vbox.pack_start(self.progress_bar, expand=False) self.command_label = gtk.Label(self.command) if self.ignore_command: self.command_label.show() vbox.pack_start(self.command_label, expand=False) sw.add(self.textview) frame = gtk.Frame() frame.add(sw) frame.show() vbox.add(frame) save_button = gtk.Button("Save As") save_button.connect("clicked", self.save, self.textview) save_button.show() hbox = gtk.HBox() hbox.pack_start(save_button, False) hbox.show() output_label = gtk.Label('output : ' + stdoutfile.name) output_label.show() hbox.pack_start(output_label, expand=True) self.freeze_button = gtk.ToggleButton("_Disconnect") self.freeze_button.set_active(False) self.freeze_button.connect("toggled", self.freeze) self.freeze_button.show() searchbox = gtk.HBox() searchbox.show() entry = gtk.Entry() entry.show() entry.connect("activate", self.enter_clicked) searchbox.pack_start(entry, True) b = gtk.Button("Find Next") b.connect_object('clicked', self.on_find_clicked, entry) b.show() searchbox.pack_start(b, False) searchbox.pack_start(self.freeze_button, False) close_button = gtk.Button("_Close") close_button.connect("clicked", self.quit, None, None) close_button.show() hbox.pack_end(close_button, False) vbox.pack_start(searchbox, False) vbox.pack_start(hbox, False) self.window.add(vbox) close_button.grab_focus() self.window.show()
def realize(self): self.channel = self.mixer.add_output_channel(self.channel_name, self.stereo) if self.channel == None: raise Exception, "Cannot create a channel" Channel.realize(self) if self.future_volume_midi_cc != None: self.channel.volume_midi_cc = self.future_volume_midi_cc if self.future_balance_midi_cc != None: self.channel.balance_midi_cc = self.future_balance_midi_cc if self.future_mute_midi_cc != None: self.channel.mute_midi_cc = self.future_mute_midi_cc self.channel.midi_scale = self.slider_scale.scale self.on_volume_changed(self.slider_adjustment) self.on_balance_changed(self.balance_adjustment) # vbox child at upper part self.vbox = gtk.VBox() self.pack_start(self.vbox, False) self.label_name = gtk.Label() self.label_name.set_text(self.channel_name) self.label_name.set_size_request(0, -1) self.label_name_event_box = gtk.EventBox() self.label_name_event_box.connect('button-press-event', self.on_label_mouse) self.label_name_event_box.add(self.label_name) if not self.colours: OutputChannel.colours = available_colours[:] for color in self.colours: self.color_tuple = [ gtk.gdk.color_parse(color[x]) for x in range(3) ] self.colours.remove(color) break self.label_name_event_box.modify_bg(gtk.STATE_NORMAL, self.color_tuple[1]) self.vbox.pack_start(self.label_name_event_box, True) self.mute = gtk.ToggleButton() self.mute.set_label("M") self.mute.set_active(self.channel.out_mute) self.mute.connect("toggled", self.on_mute_toggled) self.vbox.pack_start(self.mute, False) frame = gtk.Frame() frame.set_shadow_type(gtk.SHADOW_IN) frame.add(self.abspeak) self.vbox.pack_start(frame, False) # hbox child at lower part self.hbox = gtk.HBox() self.hbox.pack_start(self.slider, True) frame = gtk.Frame() frame.set_shadow_type(gtk.SHADOW_IN) frame.add(self.meter) self.hbox.pack_start(frame, True) frame = gtk.Frame() frame.set_shadow_type(gtk.SHADOW_IN) frame.add(self.hbox) self.pack_start(frame, True) self.volume_digits.set_size_request(0, -1) self.pack_start(self.volume_digits, False) self.create_balance_widget() self.monitor_button = gtk.ToggleButton('MON') self.monitor_button.connect('toggled', self.on_monitor_button_toggled) self.pack_start(self.monitor_button, False, False) # add control groups to the input channels, and initialize them # appropriately for input_channel in self.app.channels: ctlgroup = input_channel.add_control_group(self) if self._init_muted_channels and input_channel.channel.name in self._init_muted_channels: ctlgroup.mute.set_active(True) if self._init_solo_channels and input_channel.channel.name in self._init_solo_channels: ctlgroup.solo.set_active(True) self._init_muted_channels = None self._init_solo_channels = None
def __init__(self, policy, widgets, download_only, select_only=False): self.policy = policy self.select_only = select_only def update_ok_state(): self.window.set_response_sensitive(gtk.RESPONSE_OK, policy.solver.ready) if policy.solver.ready and self.window.get_focus() is None: run_button.grab_focus() policy.watchers.append(update_ok_state) self.window = widgets.get_widget('main') self.window.set_default_size(gtk.gdk.screen_width() * 2 / 5, 300) self.progress = widgets.get_widget('progress') self.progress_area = widgets.get_widget('progress_area') self.comment = widgets.get_widget('comment') widgets.get_widget('stop').connect( 'clicked', lambda b: policy.handler.abort_all_downloads()) self.refresh_button = widgets.get_widget('refresh') # Tree view self.browser = InterfaceBrowser(policy, widgets) prefs = widgets.get_widget('preferences') self.window.action_area.set_child_secondary(prefs, True) # Glade won't let me add this to the template! if select_only: run_button = dialog.MixedButton(_("_Select"), gtk.STOCK_EXECUTE, button=gtk.ToggleButton()) elif download_only: run_button = dialog.MixedButton(_("_Download"), gtk.STOCK_EXECUTE, button=gtk.ToggleButton()) else: run_button = dialog.MixedButton(_("_Run"), gtk.STOCK_EXECUTE, button=gtk.ToggleButton()) self.window.add_action_widget(run_button, gtk.RESPONSE_OK) run_button.show_all() run_button.set_flags(gtk.CAN_DEFAULT) self.run_button = run_button run_button.grab_focus() def response(dialog, resp): if resp in (gtk.RESPONSE_CANCEL, gtk.RESPONSE_DELETE_EVENT): self.window.destroy() sys.exit(1) elif resp == gtk.RESPONSE_OK: if self.cancel_download_and_run: self.cancel_download_and_run.trigger() if run_button.get_active(): self.cancel_download_and_run = tasks.Blocker( "cancel downloads") self.download_and_run(run_button, self.cancel_download_and_run) elif resp == gtk.RESPONSE_HELP: gui_help.display() elif resp == SHOW_PREFERENCES: import preferences preferences.show_preferences( policy.config, notify_cb=lambda: policy.solve_with_downloads()) self.window.connect('response', response) self.window.realize() # Make busy pointer work, even with --systray
def __init__(self): gtk.ToolItem.__init__(self) preview = ColorPreview() self.dropdown_button = dropdownpanel.DropdownPanelButton(preview) self.preview_size = ToolbarManager.icon_size self.connect("toolbar-reconfigured", self._toolbar_reconf_cb) self.connect("create-menu-proxy", lambda *a: True) self.set_tooltip_text(_("Color History and other tools")) self.add(self.dropdown_button) from application import get_app app = get_app() app.brush.observers.append(self._brush_settings_changed_cb) preview.color = app.brush_color_manager.get_color() self._app = app self._main_preview = preview panel_frame = gtk.Frame() panel_frame.set_shadow_type(gtk.SHADOW_OUT) self.dropdown_button.set_property("panel-widget", panel_frame) panel_vbox = gtk.VBox() panel_vbox.set_spacing(widgets.SPACING_TIGHT) panel_vbox.set_border_width(widgets.SPACING) panel_frame.add(panel_vbox) def hide_panel_cb(*a): self.dropdown_button.panel_hide() def hide_panel_idle_cb(*a): gobject.idle_add(self.dropdown_button.panel_hide) # Colour changing section_frame = widgets.section_frame(_("Change Color")) panel_vbox.pack_start(section_frame, True, True) section_table = gtk.Table() section_table.set_col_spacings(widgets.SPACING) section_table.set_border_width(widgets.SPACING) section_frame.add(section_table) hsv_widget = HSVTriangle() hsv_widget.set_size_request(175, 175) hsv_widget.set_color_manager(app.brush_color_manager) section_table.attach(hsv_widget, 0, 1, 0, 1) preview_hbox = gtk.HBox() color_picker = ColorPickerButton() preview_adj = PreviousCurrentColorAdjuster() preview_adj.set_color_manager(app.brush_color_manager) color_picker.set_color_manager(app.brush_color_manager) preview_hbox.pack_start(color_picker, False, False) preview_hbox.pack_start(preview_adj, True, True) side_vbox = gtk.VBox() side_vbox.set_spacing(widgets.SPACING_TIGHT) section_table.attach(side_vbox, 1, 2, 0, 1) def init_proxy(widget, action_name): action = app.find_action(action_name) assert action is not None, \ "Must be able to find action %s" % (action_name,) widget.set_related_action(action) widget.connect("clicked", hide_panel_cb) return widget button = init_proxy(gtk.Button(), "ColorDetailsDialog") side_vbox.pack_end(button, False, False) side_vbox.pack_end(preview_hbox, False, False) side_vbox.pack_end(gtk.Alignment(), True, True) button = init_proxy(gtk.ToggleButton(), "HCYWheelTool") button.set_label(_("HCY Wheel")) side_vbox.pack_end(button, False, False) button = init_proxy(gtk.ToggleButton(), "PaletteTool") button.set_label(_("Color Palette")) side_vbox.pack_end(button, False, False) # History section_frame = widgets.section_frame(_("Recently Used")) panel_vbox.pack_start(section_frame, True, True) history = ColorHistoryView(app) history.button_clicked += self._history_button_clicked section_frame.add(history)
def __init__(self): self.built = False oofGUI.MainPage.__init__(self, name="Active %s"%Spacestring, ordering=71.1, tip="Modify active %s."%spacestring) mainbox = gtk.VBox(spacing=2) self.gtk.add(mainbox) # Microstructure widget, centered at the top of the page. align = gtk.Alignment(xalign=0.5) mainbox.pack_start(align, expand=0, fill=0) centerbox = gtk.HBox(spacing=3) align.add(centerbox) label = gtk.Label('Microstructure=') label.set_alignment(1.0, 0.5) centerbox.pack_start(label, expand=0, fill=0) self.mswidget = whowidget.WhoWidget(microstructure.microStructures, scope=self) centerbox.pack_start(self.mswidget.gtk[0], expand=0, fill=0) mainpane = gtk.HPaned() gtklogger.setWidgetName(mainpane, 'Pane') mainbox.pack_start(mainpane, expand=1, fill=1) gtklogger.connect_passive(mainpane, 'notify::position') # Active area status in the left half of the main pane. vbox = gtk.VBox() mainpane.pack1(vbox, resize=1, shrink=0) aasframe = gtk.Frame("Active %s Status"%Spacestring) aasframe.set_shadow_type(gtk.SHADOW_IN) vbox.pack_start(aasframe, expand=0, fill=0, padding=2) self.aainfo = gtk.Label() gtklogger.setWidgetName(self.aainfo, "Status") ## self.aainfo.set_alignment(0.0, 0.5) aasframe.add(self.aainfo) naaframe = gtk.Frame("Named Active %ss"%Spacestring) naaframe.set_shadow_type(gtk.SHADOW_IN) vbox.pack_start(naaframe, expand=1, fill=1) naabox = gtk.VBox() naaframe.add(naabox) self.aalist = chooser.ScrolledChooserListWidget( callback=self.aalistCB, dbcallback=self.aalistCB2, name="NamedAreas") naabox.pack_start(self.aalist.gtk, expand=1, fill=1, padding=2) bbox = gtk.HBox() naabox.pack_start(bbox, expand=0, fill=0, padding=2) self.storebutton = gtk.Button("Store...") bbox.pack_start(self.storebutton, expand=1, fill=0) gtklogger.setWidgetName(self.storebutton, "Store") gtklogger.connect(self.storebutton, 'clicked', self.storeCB) tooltips.set_tooltip_text( self.storebutton, "Save the current active %s for future use."%spacestring) self.renamebutton = gtk.Button("Rename...") bbox.pack_start(self.renamebutton, expand=1, fill=0) gtklogger.setWidgetName(self.renamebutton, "Rename") gtklogger.connect(self.renamebutton, 'clicked', self.renameCB) tooltips.set_tooltip_text(self.renamebutton, "Rename the selected saved active %s."%spacestring) self.deletebutton = gtk.Button("Delete") bbox.pack_start(self.deletebutton, expand=1, fill=0) gtklogger.setWidgetName(self.deletebutton, "Delete") gtklogger.connect(self.deletebutton, 'clicked', self.deleteCB) tooltips.set_tooltip_text(self.deletebutton, "Delete the selected saved active %s."%spacestring) self.restorebutton = gtk.Button("Restore") bbox.pack_start(self.restorebutton, expand=1, fill=0) gtklogger.setWidgetName(self.restorebutton, "Restore") gtklogger.connect(self.restorebutton, 'clicked', self.restoreCB) tooltips.set_tooltip_text(self.restorebutton, "Use the selected saved active %s."%spacestring) # Active area modification methods in the right half of the main pane modframe = gtk.Frame("Active %s Modification"%Spacestring) gtklogger.setWidgetName(modframe, "Modify") modframe.set_shadow_type(gtk.SHADOW_IN) mainpane.pack2(modframe, resize=0, shrink=0) modbox = gtk.VBox() modframe.add(modbox) ## scroll = gtk.ScrolledWindow() ## scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) ## modbox.pack_start(scroll, expand=1, fill=1) self.activeareaModFactory = regclassfactory.RegisteredClassFactory( activeareamod.ActiveAreaModifier.registry, title="Method:", scope=self, name="Method") ## scroll.add_with_viewport(self.activeareaModFactory.gtk) modbox.pack_start(self.activeareaModFactory.gtk, expand=1, fill=1) self.historian = historian.Historian(self.activeareaModFactory.set, self.sensitizeHistory, setCBkwargs={'interactive':1}) self.activeareaModFactory.set_callback(self.historian.stateChangeCB) # Prev, OK, and Next buttons hbox = gtk.HBox() modbox.pack_start(hbox, expand=0, fill=0, padding=2) self.prevbutton = gtkutils.prevButton() hbox.pack_start(self.prevbutton, expand=0, fill=0, padding=2) gtklogger.connect(self.prevbutton, 'clicked', self.historian.prevCB) tooltips.set_tooltip_text( self.prevbutton, 'Recall the previous active %s modification operation.'%spacestring) self.okbutton = gtk.Button(stock=gtk.STOCK_OK) hbox.pack_start(self.okbutton, expand=1, fill=1, padding=2) gtklogger.setWidgetName(self.okbutton, "OK") gtklogger.connect(self.okbutton, 'clicked', self.okbuttonCB) tooltips.set_tooltip_text( self.okbutton, 'Perform the active %s modification operation defined above.' %spacestring) self.nextbutton = gtkutils.nextButton() hbox.pack_start(self.nextbutton, expand=0, fill=0, padding=2) gtklogger.connect(self.nextbutton, 'clicked', self.historian.nextCB) tooltips.set_tooltip_text( self.nextbutton, "Recall the next active %s modification operation."%spacestring) # Undo, Redo, Override hbox = gtk.HBox() modbox.pack_start(hbox, expand=0, fill=0, padding=2) self.undobutton = gtk.Button(stock=gtk.STOCK_UNDO) hbox.pack_start(self.undobutton, expand=1, fill=0) gtklogger.setWidgetName(self.undobutton, "Undo") gtklogger.connect(self.undobutton, 'clicked', self.undoCB) tooltips.set_tooltip_text(self.undobutton, "Undo the previous operation.") self.redobutton = gtk.Button(stock=gtk.STOCK_REDO) hbox.pack_start(self.redobutton, expand=1, fill=0) gtklogger.setWidgetName(self.redobutton, "Redo") gtklogger.connect(self.redobutton, 'clicked', self.redoCB) tooltips.set_tooltip_text(self.redobutton, "Redo an undone operation.") self.overridebutton = gtk.ToggleButton('Override') hbox.pack_start(self.overridebutton, expand=1, fill=0) gtklogger.setWidgetName(self.overridebutton, "Override") self.overridesignal = gtklogger.connect(self.overridebutton, 'clicked', self.overrideCB) tooltips.set_tooltip_text(self.overridebutton, "Temporarily activate the entire microstructure.") # Switchboard signals self.sbcallbacks = [ switchboard.requestCallback(self.mswidget, self.mswidgetCB), switchboard.requestCallback("active area modified", self.aamodified), switchboard.requestCallbackMain("stored active areas changed", self.storedAAChanged), switchboard.requestCallbackMain(('validity', self.activeareaModFactory), self.validityChangeCB) ] self.built = True
def __init__(self): gtk.ToolItem.__init__(self) self.set_homogeneous(False) self.button_image = gtk.Image() self.button_image.set_from_stock(self.inactive_stock_id, ToolbarManager.icon_size) self.button_shows_modified = False self.button = dropdownpanel.DropdownPanelButton(self.button_image) self.vbox = gtk.VBox() frame = gtk.Frame() frame.add(self.vbox) frame.set_shadow_type(gtk.SHADOW_OUT) self.button.set_property("panel-widget", frame) self.add(self.button) self.connect("create-menu-proxy", lambda *a: True) from application import get_app app = get_app() self.app = app # A limited subset of the available brush settings. frame = widgets.section_frame(_("Quick Brush Settings")) table = gtk.Table() table.set_homogeneous(False) table.set_row_spacings(widgets.SPACING_TIGHT) table.set_col_spacings(widgets.SPACING) table.set_border_width(widgets.SPACING) frame.add(table) self.vbox.pack_start(frame, True, True) sg_row_height = gtk.SizeGroup(gtk.SIZE_GROUP_VERTICAL) sg_slider_width = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL) row = 0 for setting_cname in self.setting_cnames: scale = gtk.HScale() scale.set_size_request(128, -1) scale.set_draw_value(False) scale.set_can_focus(False) scale.set_can_default(False) s = brushsettings.settings_dict[setting_cname] adj = app.brush_adjustment[setting_cname] scale.set_adjustment(adj) scale.set_tooltip_text(s.tooltip) #scale.set_update_policy(gtk.UPDATE_DISCONTINUOUS) sg_row_height.add_widget(scale) sg_slider_width.add_widget(scale) label = gtk.Label(_("%s:") % s.name) label.set_alignment(0.0, 0.5) label.set_tooltip_text(s.tooltip) sg_row_height.add_widget(label) reset_button = widgets.borderless_button( stock_id=gtk.STOCK_CLEAR, tooltip=_("Restore '%s' to this brush's saved value") % s.name) reset_button.connect("clicked", self.reset_button_clicked_cb, adj, setting_cname) sg_row_height.add_widget(reset_button) adj.connect("value-changed", self.adjustment_changed_cb, reset_button, setting_cname) adj.value_changed() table.attach(label, 0, 1, row, row + 1, gtk.FILL) table.attach(scale, 1, 2, row, row + 1, gtk.FILL | gtk.EXPAND) table.attach(reset_button, 2, 3, row, row + 1, gtk.FILL) row += 1 table.set_col_spacing(1, widgets.SPACING_TIGHT) # Access to the brush settings window, and a big reset-all button # aligned with the settings above. frame = widgets.section_frame(_("Detailed Brush Settings")) hbox = gtk.HBox() hbox.set_spacing(widgets.SPACING) hbox.set_border_width(widgets.SPACING) frame.add(hbox) self.vbox.pack_start(frame, True, True) widget = gtk.ToggleButton() action = self.app.find_action("BrushEditorWindow") widget.set_related_action(action) #widget.set_label(_("Edit All Settings")) hbox.pack_start(widget, True, True) widget.connect("toggled", lambda a: self.button.panel_hide()) sg_slider_width.add_widget(widget) widget = gtk.ToggleButton() action = self.app.find_action("BrushIconEditorWindow") widget.set_related_action(action) #widget.set_label(_("Edit Icon")) hbox.pack_start(widget, True, True) widget.connect("toggled", lambda a: self.button.panel_hide()) sg_slider_width.add_widget(widget) widget = gtk.Button(_("Restore Saved Settings")) widget.connect("clicked", self.reset_all_clicked_cb) widget.set_tooltip_text( _("Reset all brush settings to the current brush's saved values")) hbox.pack_start(widget, True, True) sg_slider_width.add_widget(widget) self.reset_all_button = widget # Brush blend modes vbox = gtk.VBox() vbox.set_border_width(widgets.SPACING) vbox.set_spacing(widgets.SPACING_TIGHT) frame = widgets.section_frame(_("Brush Blend Mode")) frame.add(vbox) self.vbox.pack_start(frame, True, True) table = gtk.Table(2, 2, homogeneous=True) topts = gtk.EXPAND | gtk.FILL tpad = 0 table.set_row_spacings(widgets.SPACING_TIGHT) table.set_col_spacings(widgets.SPACING) for la, ra, ta, ba, action_name in self.blend_modes_table: action = self.app.find_action(action_name) button = gtk.ToggleButton() button.set_related_action(action) button.set_can_focus(False) button.set_can_default(False) button.set_image_position(gtk.POS_LEFT) button.set_alignment(0.0, 0.5) button.set_relief(gtk.RELIEF_HALF) image = action.create_icon(gtk.ICON_SIZE_BUTTON) image.set_padding(widgets.SPACING_TIGHT, widgets.SPACING_TIGHT) button.set_image(image) table.attach(button, la, ra, ta, ba, topts, topts, tpad, tpad) button.connect("clicked", self.blendmode_button_clicked_cb) vbox.pack_start(table, False, False) self.vbox.set_border_width(widgets.SPACING) self.vbox.set_spacing(widgets.SPACING) self.app.brush.observers.append(self.brush_settings_changed_cb)