def init_combo(self): self.combobox = gtk.combo_box_new_text() cb = gtk.combo_box_new_text() self.layout.put(self.combobox, 5, 295) for item in self.notreverseble_encryptions + self.reverseble_encryptions: self.combobox.append_text(item) self.combobox.show()
def _createCalendarPanel(self, sources): """ Creates one side in the notebook - the one for setting up calendar synchronization """ box = gtk.VBox(False, 5) label = gtk.Label("Source A") label.set_alignment(0, 0) box.pack_start(label, False, False, 0) label.show() self.calendar_combobox1 = gtk.combo_box_new_text() for sourceDesc in sources: self.calendar_combobox1.append_text(sourceDesc) self.calendar_combobox1.set_active(0) box.pack_start(self.calendar_combobox1, False, False, 0) self.calendar_combobox1.show() label = gtk.Label("Source B") label.set_alignment(0, 0) box.pack_start(label, False, False, 0) label.show() self.calendar_combobox2 = gtk.combo_box_new_text() for sourceDesc in sources: self.calendar_combobox2.append_text(sourceDesc) self.calendar_combobox2.set_active(1) box.pack_start(self.calendar_combobox2, False, False, 0) self.calendar_combobox2.show() box.show() return box
def __init__(self, current): PreferencesTab.__init__(self, u'Selecciona los servicios que deseas \ usar para cortar URLs y subir imágenes a Twitter', current) i = 0 default = -1 url_lbl = gtk.Label('Cortar URL') self.shorten = gtk.combo_box_new_text() for key,v in URL_SERVICES.iteritems(): self.shorten.append_text(key) if key == self.current['shorten-url']: default = i i += 1 self.shorten.set_active(default) url_box = gtk.HBox(False) url_box.pack_start(url_lbl, False, False, 3) url_box.pack_start(self.shorten, False, False, 3) pic_lbl = gtk.Label(u'Subir imágenes') self.upload = gtk.combo_box_new_text() i = 0 for key in PHOTO_SERVICES: self.upload.append_text(key) if key == self.current['upload-pic']: default = i i += 1 self.upload.set_active(default) pic_box = gtk.HBox(False) pic_box.pack_start(pic_lbl, False, False, 3) pic_box.pack_start(self.upload, False, False, 3) self.pack_start(url_box, False, False, 2) self.pack_start(pic_box, False, False, 2) self.show_all()
def initComponents(self, wTree): self.banksWindow = wTree.get_object('banksWindow') if (self.banksWindow): self.banksWindow.connect('destroy', self.closeWindow) # Set favicon and logo pixbuf = gtk.gdk.pixbuf_new_from_file('assets/logo.svg') pixbuf = pixbuf.scale_simple(16, 16, gtk.gdk.INTERP_BILINEAR) self.banksWindow.set_icon(pixbuf) self.saveButton = wTree.get_object('buttonSaveDefault') if (self.saveButton): self.saveButton.connect('clicked', self.saveDefault) self.startButton = wTree.get_object('buttonStart') if (self.startButton): self.startButton.connect('clicked', self.startServer) vbox2 = wTree.get_object('vbox2') self.comboBox1 = gtk.combo_box_new_text() self.comboBox2 = gtk.combo_box_new_text() comboBoxes = [self.comboBox1, self.comboBox2] vbox2.get_children()[0].add(self.comboBox1) vbox2.get_children()[1].add(self.comboBox2) # Fill the boxes accordingly to the existing presets. for box in comboBoxes: box.append_text("0 - None") for p in self.presetsList[1:]: box.append_text(str(self.presetsList.index(p)) + " - " + p.get_small_str()) box.set_active(0) # Sets a defaultly selected bank. if self.banksList != []: bank.set_all(self.banksList) listlen = len(self.presetsList) index = 1 for preset in self.presetsList[1:]: if self.banksList[0].get_preset(0) != None \ and preset.name == self.banksList[0].get_preset(0).name: break index += 1 if index >= listlen: index = 0 self.comboBox1.set_active(index) index = 1 for preset in self.presetsList[1:]: if self.banksList[0].get_preset(1) != None \ and preset.name == self.banksList[0].get_preset(1).name: break index += 1 if index >= listlen: print "Not able to find preset in bank. None set as default." index = 0 self.comboBox2.set_active(index) self.comboBox1.connect('changed', self.storePreset1) self.comboBox2.connect('changed', self.storePreset2)
def __init__(self, geditwindow, path, active): gtk.VBox.__init__(self) if active: targets=["html","html-single","pdf","test", "all"] langs = ["en-US","as-IN", "bn-IN", "de-DE", "es-ES", "fr-FR", "gu-IN", "hi-IN", "it-IT", "ja-JP", "kn-IN", "ko-KR", "ml-IN", "mr-IN", "or-IN", "pa-IN", "pt-BR", "ru-RU", "si-LK", "ta-IN", "te-IN", "zh-CN", "zh-TW"] #self.output_text = gtk.TextBuffer() #self.output_area = gtk.TextView(self.output_text) #self.output_area.set_editable(False) #self.output_area.modify_font(pango.FontDescription("Monospace 10")) self.terminal = vte.Terminal() self.terminal.fork_command(directory=path) #terminal.connect("show", show_callback) scrolled_window = gtk.ScrolledWindow() #scrolled_window.add(self.output_area) scrolled_window.add(self.terminal) self.pack_start(scrolled_window) buttonbox = gtk.HButtonBox() buttonbox.set_layout(gtk.BUTTONBOX_END) targets_combo = gtk.combo_box_new_text() for t in targets: targets_combo.append_text(t) targets_combo.set_active(0) buttonbox.pack_start(targets_combo, False, False, 1) lang_combo = gtk.combo_box_new_text() for l in langs: lang_combo.append_text(l) lang_combo.set_active(0) buttonbox.pack_start(lang_combo, False, False, 1) okbutton = gtk.Button("Build", None, False) buttonbox.pack_start(okbutton, False, False, 3) self.pack_start(buttonbox, False, False, 3) self.show_all() okbutton.connect("clicked", self.build, path, targets_combo, lang_combo)
def add_query_widget(container, field_names, sel_qf='title', sel_comm='contains', text=''): hbox = gtk.HBox() cb = gtk.combo_box_new_text() select = 0 for i, field in enumerate(QUERY_FIELDS): if sel_qf == field: select = i cb.append_text(field_names[field]) cb.set_active(select) action_cb = gtk.combo_box_new_text() select = 0 for i, command in enumerate(QUERY_COMMANDS): if sel_comm == command: select = i action_cb.append_text(QUERY_COMMAND_NAMES[command]) action_cb.set_active(select) entry = gtk.Entry() entry.set_text(text) button = gtk.Button(stock=gtk.STOCK_DELETE) button.connect("clicked", lambda w: hbox.destroy()) hbox.pack_start(cb, expand=False) hbox.pack_start(action_cb, expand=False) hbox.pack_start(entry, expand=True, padding=8) hbox.pack_start(button, expand=False, fill=False) hbox.show_all() container.pack_start(hbox)
def _create_dialog(self, config): enabled, curhz = config.get_sound() self.enabled = gtk.CheckButton("Sound enabled") self.enabled.set_active(enabled) hz = gtk.combo_box_new_text() for text in config.get_sound_values(): hz.append_text(text) hz.set_active(curhz) self.hz = hz ymmixer = gtk.combo_box_new_text() for text in config.get_ymmixer_types(): ymmixer.append_text(text) ymmixer.set_active(config.get_ymmixer()) self.ymmixer = ymmixer self.mic = gtk.CheckButton("Enable (Falcon) microphone") self.mic.set_active(config.get_mic()) dialog = gtk.Dialog("Sound settings", self.parent, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, (gtk.STOCK_APPLY, gtk.RESPONSE_APPLY, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)) dialog.vbox.add(self.enabled) dialog.vbox.add(gtk.Label("Sound frequency::")) dialog.vbox.add(hz) dialog.vbox.add(gtk.Label("YM voices mixing method:")) dialog.vbox.add(ymmixer) dialog.vbox.add(self.mic) dialog.vbox.show_all() self.dialog = dialog
def construct_window(self): self.window = gtk.Window() self.window.set_title("Feed Reader") self.window.resize(1000, 700) self.edit_add_feader = gtk.Entry() self.button_add = gtk.Button("Add") self.button_refresh = gtk.Button(stock = gtk.STOCK_REFRESH) self.combo_feaders = gtk.combo_box_new_text() self.combo_feeds = gtk.combo_box_new_text() self.webview = webkit.WebView() hbox = gtk.HBox() hbox.pack_start(self.edit_add_feader) hbox.pack_start(self.button_add) hbox.pack_start(self.button_refresh) scrollframe = gtk.ScrolledWindow() scrollframe.add(self.webview) # solution for now: # textview = gtk.TextView() # self.buffer = textview.get_buffer() # scrollframe.add(textview) # ----------------- vbox = gtk.VBox() vbox.pack_start(hbox, False) vbox.pack_start(self.combo_feaders, False) vbox.pack_start(self.combo_feeds, False) vbox.pack_start(scrollframe) self.window.add(vbox)
def populate_settings_widgets(self): self.theme_selector = gtk.combo_box_new_text() for theme in sorted(resources.get_themes()): self.theme_selector.append_text(theme) self.ui.get_object("theme_container").pack_start(self.theme_selector, True, True) self.theme_selector.set_active_iter( dict([(x[0].strip(), x.iter) for x in self.theme_selector.get_model()]).get( self.settings["theme"], self.theme_selector.get_model().get_iter_root() ) ) self.theme_selector.show_all() self.urlshorter_selector = gtk.combo_box_new_text() for urlshorter in urlshorters.keys(): self.urlshorter_selector.append_text(urlshorter) self.ui.get_object("urlshorter_container").pack_start(self.urlshorter_selector, True, True) self.urlshorter_selector.set_active_iter( dict([(x[0].strip(), x.iter) for x in self.urlshorter_selector.get_model()]).get( self.settings["urlshorter"], self.urlshorter_selector.get_model().get_iter_root() ) ) self.urlshorter_selector.show_all() self.retweet_style_selector = gtk.combo_box_new_text() for format in RETWEET_FORMATS: self.retweet_style_selector.append_text(format) self.ui.get_object("retweet_style_container").pack_start(self.retweet_style_selector, True, True) self.retweet_style_selector.set_active_iter( dict([(x[0].strip(), x.iter) for x in self.retweet_style_selector.get_model()]).get( self.settings["retweet_style"], self.retweet_style_selector.get_model().get_iter_root() ) ) self.retweet_style_selector.show_all()
def __init__(self, master): gtk.Frame.__init__(self) self.master = master self.set_border_width(20) vb = gtk.VBox(spacing = 10) hb = gtk.HBox(spacing=5) hb.set_border_width(5) vb.pack_start(hb, False) self.drive = gtk.combo_box_new_text() hb.pack_end(self.drive, False) hb.pack_end(gtk.Label(_("Boot Device: ")), False) for d in install.listDevices(): self.drive.append_text(d[0]) self.drive.set_active(0) mlcombobox = gtk.HBox(spacing=5) mlcombobox.set_border_width(5) l = gtk.Label(_("Select menu.lst to import: ")) mlcombobox.pack_start(l, False) self.mlcombo = gtk.combo_box_new_text() self.mlcombo.connect("changed", mainWindow.sigprocess, self.newimport) self.mlcombo.append_text(_("None")) for d, p in install.menulst: self.mlcombo.append_text("%s:%s" % (d, p)) mlcombobox.pack_start(self.mlcombo, False) eb = gtk.Button(_("Edit menu.lst")) eb.connect("clicked", self.editmbr) mlcombobox.pack_end(eb, False) vb.pack_start(mlcombobox, False) self.add(vb) self.show_all()
def __init__(self, current): PreferencesTab.__init__(self, _('Select your preferred services for \ shorten URLs and upload images'), current) i = 0 default = -1 url_lbl = gtk.Label(_('Shorten URL')) self.shorten = gtk.combo_box_new_text() for key, v in URL_SERVICES.iteritems(): self.shorten.append_text(key) if key == self.current['shorten-url']: default = i i += 1 self.shorten.set_active(default) url_box = gtk.HBox(False) url_box.pack_start(url_lbl, False, False, 3) url_box.pack_start(self.shorten, False, False, 3) pic_lbl = gtk.Label(_('Upload images')) self.upload = gtk.combo_box_new_text() i = 0 for key in PHOTO_SERVICES: self.upload.append_text(key) if key == self.current['upload-pic']: default = i i += 1 self.upload.set_active(default) pic_box = gtk.HBox(False) pic_box.pack_start(pic_lbl, False, False, 3) pic_box.pack_start(self.upload, False, False, 3) self.pack_start(url_box, False, False, 2) self.pack_start(pic_box, False, False, 2) self.show_all()
def init_text_view(self): #self.notebook = gtk.Notebook() view = gtk.TextView() sw = gtk.ScrolledWindow() sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.text_view = view self.text_view.set_left_margin(8) self.text_view.set_right_margin(8) self.text_view.set_wrap_mode(gtk.WRAP_WORD_CHAR) sw.add(view) #self.font_label = gtk.Label(_("Preview")) self.style_combo = gtk.combo_box_new_text() self.size_combo = gtk.combo_box_new_text() vb = gtk.VBox() hb = gtk.HBox() vb.pack_start(hb, False) vb.pack_start(sw) #hb.pack_start(self.font_label, False) hb.pack_end(self.style_combo, False) hb.pack_end(self.size_combo, False) self.set_scalable_sizes() self.style_combo.connect("changed", self.style_changed) self.size_combo.connect("changed", self.size_changed) return vb
def __init__(self, selection, _log): self.clipboard = gtk.Clipboard(selection=selection) self.selection = selection self._log = _log self.owned_label = label() self.get_targets = gtk.combo_box_new_text() self.get_targets.set_sensitive(False) self.get_targets.connect("changed", self.get_target_changed) self.set_targets = gtk.combo_box_new_text() self.set_targets.append_text("STRING") self.set_targets.append_text("UTF8_STRING") self.set_targets.set_active(0) self.set_targets.connect("changed", self.set_target_changed) self.value_label = label() self.value_entry = gtk.Entry(max=100) self.value_entry.set_width_chars(32) self.clear_label_btn = gtk.Button("X") self.clear_label_btn.connect("clicked", self.clear_label) self.clear_entry_btn = gtk.Button("X") self.clear_entry_btn.connect("clicked", self.clear_entry) self.get_get_targets_btn = gtk.Button("Get Targets") self.get_get_targets_btn.connect("clicked", self.do_get_targets) self.get_target_btn = gtk.Button("Get Target") self.get_target_btn.connect("clicked", self.do_get_target) self.get_target_btn.set_sensitive(False) self.set_target_btn = gtk.Button("Set Target") self.set_target_btn.connect("clicked", self.do_set_target) self.get_string_btn = gtk.Button("Get String") self.get_string_btn.connect("clicked", self.do_get_string) self.set_string_btn = gtk.Button("Set String") self.set_string_btn.connect("clicked", self.do_set_string) self.clipboard.connect("owner-change", self.owner_changed) self.log("ready")
def createInfo(self, line): # Turns a line into a gtk hbox of parameters hbox = gtk.HBox() entry = gtk.Entry() entry.set_text(line.get_label()) hbox.pack_start(entry, expand=False, fill=False, padding=5) label = gtk.Label("marker:") hbox.pack_start(label, expand=False, fill=False) combo = gtk.combo_box_new_text() for i in PlotStyles.nmar: combo.append_text(i) combo.set_active(self.getMarkerIndex(line)) hbox.pack_start(combo, expand=False, fill=False, padding=5) label = gtk.Label("linestyle:") hbox.pack_start(label, expand=False, fill=False) combo = gtk.combo_box_new_text() for i in PlotStyles.nsty: combo.append_text(i) combo.set_active(self.getStyleIndex(line)) hbox.pack_start(combo, expand=False, fill=False, padding=5) label = gtk.Label("colour:") hbox.pack_start(label, expand=False, fill=False) combo = gtk.combo_box_new_text() for i in PlotStyles.colours: combo.append_text(i) combo.set_active(self.getColourIndex(line)) hbox.pack_start(combo, expand=False, fill=False, padding=5) return hbox
def __init__(self): self.box = gtk.HBox() self.funz = gtk.Entry() self.funz.set_tooltip_text("The function") self.ab = gtk.combo_box_new_text() self.ab.set_tooltip_text("Where the funtion should be") self.preset = gtk.combo_box_new_text() self.preset.set_tooltip_text("Arrow type") self.inarc = gtk.SpinButton(digits = 0) self.inarc.set_tooltip_text("Arrow curve, in degrees") self.canc = gtk.Button("Delete") self.canc.set_tooltip_text("Delete the arrow") self.add = gtk.Button("Add arrow") self.canc.set_tooltip_text("Add another arrow") self.inarc.set_increments(5, 30) self.inarc.set_range(-180, 180) for x in SCRITTA: self.ab.append_text(x) for x in PRESET: self.preset.append_text(x) self.ab.set_active(0) self.preset.set_active(0) self.box.pack_start(self.funz, False, False) self.box.pack_start(self.ab, False, False) self.box.pack_start(self.preset, False, False) self.box.pack_start(self.inarc, False, False) self.box.pack_start(self.canc, False, False) self.box.pack_start(self.add, False, False) self.set()
def __init__(self): gtk.Window.__init__(self) self.set_border_width(10) self.set_title("atop-plot") self.grid = gtk.Table() self.grid.set_col_spacings(5) self.grid.set_row_spacings(5) self.add(self.grid) self.file_label = gtk.Label("File") self.grid.attach(self.file_label, 0, 1, 0, 1, gtk.FILL, gtk.FILL) self.load_button = gtk.FileChooserButton("Select A File", None) self.load_button.connect("file-set", self.file_selected) self.grid.attach(self.load_button, 1, 2, 0, 1, gtk.FILL, gtk.FILL) self.label_label = gtk.Label("Label") self.grid.attach(self.label_label, 2, 3, 0, 1, gtk.FILL, gtk.FILL) self.label_combo = gtk.combo_box_new_text() self.label_combo.set_sensitive(False) self.label_combo.connect("changed", self.on_label_combo_changed) self.grid.attach(self.label_combo, 3, 4, 0, 1, gtk.FILL, gtk.FILL) self.pid_label = gtk.Label("PID") self.grid.attach(self.pid_label, 4, 5, 0, 1, gtk.FILL, gtk.FILL) self.pid_combo = gtk.combo_box_new_text() self.pid_combo.set_sensitive(False) self.pid_combo.connect("changed", self.on_pid_combo_changed) self.grid.attach(self.pid_combo, 5, 6, 0, 1, gtk.FILL, gtk.FILL)
def _create_dialog(self, config): table, self.dialog = create_table_dialog(self.parent, "Hard disks", 4, 4, "Set and reboot") factory = FselAndEjectFactory() row = 0 label = "ASCI HD image:" path = config.get_acsi_image() fsel, box = factory.get(label, None, path, gtk.FILE_CHOOSER_ACTION_OPEN) table_add_widget_row(table, row, label, box, True) self.acsi = fsel row += 1 label = "IDE HD master image:" path = config.get_idemaster_image() fsel, box = factory.get(label, None, path, gtk.FILE_CHOOSER_ACTION_OPEN) table_add_widget_row(table, row, label, box, True) self.idemaster = fsel row += 1 label = "IDE HD slave image:" path = config.get_ideslave_image() fsel, box = factory.get(label, None, path, gtk.FILE_CHOOSER_ACTION_OPEN) table_add_widget_row(table, row, label, box, True) self.ideslave = fsel row += 1 table_add_widget_row(table, row, " ", gtk.HSeparator(), True) row += 1 label = "GEMDOS drive directory:" path = config.get_hd_dir() fsel, box = factory.get(label, None, path, gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER) table_add_widget_row(table, row, label, box, True) self.hddir = fsel row += 1 hddrive = gtk.combo_box_new_text() for text in config.get_hd_drives(): hddrive.append_text(text) hddrive.set_tooltip_text("Whether GEMDOS HD emulation uses fixed drive letter, or first free drive letter after ASCI & IDE drives (detection unreliable)") table_add_widget_row(table, row, "GEMDOS HD drive:", hddrive) self.hddrive = hddrive row += 1 protect = gtk.combo_box_new_text() for text in config.get_protection_types(): protect.append_text(text) protect.set_tooltip_text("Whether/how to write protect (GEMDOS HD) emulation files, 'auto' means using host files' own properties") table_add_widget_row(table, row, "Write protection:", protect) self.protect = protect row += 1 lower = gtk.combo_box_new_text() for text in config.get_hd_cases(): lower.append_text(text) lower.set_tooltip_text("What to do with names of files created by Atari programs through GEMDOS HD emulation") table_add_widget_row(table, row, "File names:", lower) self.lower = lower table.show_all()
def render(self): label = gtk.Label(self.name) label.show() self.widget['label']=label day = gtk.combo_box_new_text() day.show() day.append_text('') for idx in range(1,32): day.append_text(str(idx)) month_list = ['Januari','Februari','Maret','April','Mei','Juni','Juli','Agustus','September','Oktober','November','Desember'] month = gtk.combo_box_new_text() month.show() month.append_text('') for item in month_list: month.append_text(item) year = gtk.combo_box_new_text() year.show() year.append_text('') for idx in range(1900,2015): year.append_text(str(idx)) self.widget['content'] = [day,month,year] return self.widget
def _create_types_tab(self, tab): tab.set_border_width(6) tab.set_spacing(6) text = _('Create model from widget') self.create_from_widget_btn = gtk.RadioButton(None, text) self.create_from_widget_btn.connect('toggled', self._on_creation_type_toggled) hbox = gtk.HBox() hbox.set_spacing(6) hbox.pack_start(self.create_from_widget_btn, False, False) self.widget_combo = gtk.combo_box_new_text() hbox.pack_start(self.widget_combo) tab.pack_start(hbox, False, False) self.custom_model_btn = gtk.RadioButton(self.create_from_widget_btn, _('Custom model')) self.custom_model_btn.connect('toggled', self._on_creation_type_toggled) tab.pack_start(self.custom_model_btn, False, False) self.custom_model_align = gtk.Alignment(0, 0, 1, 1) self.custom_model_align.set_padding(0, 0, 48, 0) hbox = gtk.HBox() hbox.set_spacing(6) self.custom_model_store = gtk.ListStore(object, int, str) self.custom_model_view = gtk.TreeView(self.custom_model_store) renderer1 = gtk.CellRendererText() renderer1.set_property('xalign', 1) # right alignment col1 = gtk.TreeViewColumn(_('Index'), renderer1, text=CUSTOM_MODEL_INDEX) self.custom_model_view.append_column(col1) renderer2 = gtk.CellRendererText() col2 = gtk.TreeViewColumn(_('Type'), renderer2, text=CUSTOM_MODEL_TYPE_NAME) self.custom_model_view.append_column(col2) scrolled_window = create_scrolled_window(self.custom_model_view, hpolicy=gtk.POLICY_NEVER) hbox.pack_start(scrolled_window, True, True) table = gtk.Table(2, 2) self.types_combo = gtk.combo_box_new_text() for t in renderer_expert.get_type_names(): self.types_combo.append_text(t) self.types_combo.set_active(0) self.add_type_btn = create_image_only_button(gtk.STOCK_ADD) self.del_type_btn = create_image_only_button(gtk.STOCK_REMOVE) table.attach(self.types_combo, 0, 1, 0, 1, yoptions=0) table.attach(self.add_type_btn, 1, 2, 0, 1, yoptions=0) table.attach(self.del_type_btn, 1, 2, 1, 2, yoptions=0) hbox.pack_start(table, False, False) self.custom_model_align.add(hbox) self.custom_model_align.set_sensitive(False) tab.pack_start(self.custom_model_align, True, True)
def __init__(self): self.mainwindow = gtk.Window(gtk.WINDOW_TOPLEVEL) self.mainwindow.set_title("Tesseract Trainer") self.mainwindow.connect("destroy", lambda w: gtk.main_quit()) self.mainwindow.set_icon_from_file("/usr/share/tesseract-gui/tesseract-gui-logo.png") self.mainwindow.set_size_request(700, 200) self.vboxtw = gtk.VBox(False, 1) self.mainwindow.add(self.vboxtw) self.vboxtw.show() ################ self.hboxlang = gtk.HBox(False, 3) self.vboxtw.pack_start(self.hboxlang, True, True, 1) self.hboxlang.show() self.langlabel = gtk.Label("Language") self.hboxlang.pack_start(self.langlabel, True, True, 1) self.langlabel.show() self.combolang = gtk.combo_box_new_text() self.hboxlang.pack_start(self.combolang, True, True, 1) langfile = open("lang_list.txt", "r") flines = langfile.readlines() langfile.close() for line in flines: lang = line.rsplit(":", 2)[0] # print lang self.combolang.append_text(lang) self.combolang.show() self.combolang.connect("changed", self.changed_combo_lang) #################### self.hboxfont = gtk.HBox(False, 3) self.vboxtw.pack_start(self.hboxfont, True, True, 1) self.hboxfont.show() self.fontlabel = gtk.Label("Font") self.hboxfont.pack_start(self.fontlabel, True, True, 1) self.fontlabel.show() self.combofont = gtk.combo_box_new_text() self.hboxfont.pack_start(self.combofont, True, True, 1) self.combofont.show() ##################### self.hboxstyle = gtk.HBox(False, 3) self.vboxtw.pack_start(self.hboxstyle, True, True, 1) self.hboxstyle.show() self.stylelabel = gtk.Label("Style") self.hboxstyle.pack_start(self.stylelabel, True, True, 1) self.stylelabel.show() self.combostyle = gtk.combo_box_new_text() self.hboxstyle.pack_start(self.combostyle, True, True, 1) self.combostyle.show() self.mainwindow.show()
def _add_manual_combos(self): # It is hell trying to work with Glade's combo boxes # so I just added GTK ones manually. Sue me. self.convertBox = gtk.combo_box_new_text() self.processingTable.attach(self.convertBox, 5,9,1,2) self.convertBox.connect("changed", self.cBox_cb) self.qualityBox = gtk.combo_box_new_text() self.processingTable.attach(self.qualityBox, 5,9,2,3)
def define_elements(self, form_data=None): """Declare all required elements - Config, Argument, Check elements.""" # Define data self.data_types = ['i8', 'i16', 'i32', 'i64', 'u8', 'u16', 'u32', 'u64', 'f32', 'f64'] self.compare_types = ['I', 'G', 'E'] self.other_data_types = ['Futhur', 'Check'] # Define Argument elements self.arg_elements = ( ('a1', gtk.Label('Val name *'), gtk.Entry()), ('a2', gtk.Label('Abs address *'), gtk.Entry()), ('a3', gtk.Label('Data type *'), gtk.combo_box_new_text()), ('a4', gtk.Label('Check'), gtk.CheckButton()), ('a5', gtk.Label('Watch'), gtk.CheckButton()), ) self.check_elements = ( ('c1', gtk.Label('Check'), gtk.CheckButton()), ('c2', gtk.Label('Abs address *'), gtk.Entry()), ('c3', gtk.Label('Data type *'), gtk.combo_box_new_text()), ('c4', gtk.Label('*'), gtk.combo_box_new_text()), ('c5', gtk.Label('Check value'), gtk.CheckButton()), ('c6', gtk.Label('*'), gtk.combo_box_new_text()), ) for i in self.data_types: self.arg_elements[2][2].append_text(i) self.check_elements[2][2].append_text(i) for i in self.compare_types: self.check_elements[3][2].append_text(i) for i in self.other_data_types: self.check_elements[5][2].append_text(i) if form_data: self.arg_elements[0][2].set_text(form_data[0]) self.arg_elements[1][2].set_text(form_data[1]) if form_data[2] != None: self.arg_elements[2][2].set_active(self.data_types.index(form_data[2])) if form_data[3] == 'True': self.arg_elements[3][2].set_active(1) if form_data[4] == 'True': self.arg_elements[4][2].set_active(1) if form_data[5] == 'True': self.check_elements[0][2].set_active(1); self.check_elements[1][2].set_text(form_data[6]) if form_data[7] != None: self.check_elements[2][2].set_active(self.data_types.index(form_data[7])) if form_data[8] != None: self.check_elements[3][2].set_active(self.compare_types.index(form_data[8])) if form_data[9] == 'True': self.check_elements[4][2].set_active(1) if form_data[10] != None: self.check_elements[5][2].set_active(self.other_data_types.index(form_data[10]))
def test_update_node_combo(self): nodeList=["N1","N2","N3"] combobox = gtk.combo_box_new_text() self.ed._update_node_combo(combobox, nodeList, "N3") assert combobox.get_active() == 2 self.ed.nodeList=[] combobox = gtk.combo_box_new_text() self.ed._update_node_combo(combobox, nodeList, "XXX") assert combobox.get_active() == -1
def __init__(self, image): vbox = gtk.VBox() # want 5 small labels, 1 larger label and a sub-frame dimlabel = gtk.Label("Dimensions: "+self.getdims(image)) dtypelabel = gtk.Label("Datatype: "+image[:].dtype.name) scalelabel = gtk.Label("Intensity: %1.8f X"%image.scaling) voxlabel = gtk.Label("Vox size: "+self.getvox(image)) originlabel = gtk.Label("Origin: "+self.getorigin(image)) # make 4 lines worth of space for this label xform = image.orientation_xform.tomatrix() xformlabel = gtk.Label("Dir Cos: \n" + \ str(xform)) xformlabel.set_size_request(300,80) buttons = gtk.Frame() buttons.set_size_request(300,70) buttons.set_shadow_type(gtk.SHADOW_ETCHED_IN) frametable = gtk.Table(2,2) frametable.set_row_spacings(5) frametable.set_col_spacings(10) self.imgframe = gtk.combo_box_new_text() for size in ["Full Volume", "160x160x160mm", "80x80x80mm", "40x40x40mm", "20x20x20mm", "10x10x10mm"]: self.imgframe.append_text(size) self.imgframe.set_active(0) self.imspace = gtk.combo_box_new_text() for space in ["World Space", "Voxel Space"]: self.imspace.append_text(space) self.imspace.set_active(0) self.imginterp = gtk.combo_box_new_text() for interp in interp_types: self.imginterp.append_text(interp) self.imginterp.set_active(1) self.hidecrosshairs = gtk.ToggleButton(label="Hide Crosshairs") frametable.attach(self.imgframe, 0, 1, 0, 1) frametable.attach(self.imspace, 0, 1, 1, 2) frametable.attach(self.imginterp, 1, 2, 0, 1) frametable.attach(self.hidecrosshairs, 1, 2, 1, 2) buttons.add(frametable) vbox.pack_start(dimlabel) vbox.pack_start(dtypelabel) vbox.pack_start(scalelabel) vbox.pack_start(voxlabel) vbox.pack_start(originlabel) vbox.pack_start(xformlabel) vbox.pack_start(buttons) gtk.Frame.__init__(self) self.set_border_width(5) self.add(vbox)
def construct(self): vbox = gtk.VBox() entry = gtk.Entry() #entry.set_text(UML.format(self.subject, visibility=True, is_derived=Truemultiplicity=True) or '') # monitor subject attribute (all, cause it contains many children) changed_id = entry.connect('changed', self._on_end_name_change) def handler(event): if not entry.props.has_focus: entry.handler_block(changed_id) entry.set_text(UML.format(self.subject, visibility=True, is_derived=True, multiplicity=True) or '') #entry.set_text(UML.format(self.subject, multiplicity=True) or '') entry.handler_unblock(changed_id) handler(None) self.watcher.watch('name', handler) \ .watch('aggregation', handler)\ .watch('visibility', handler)\ .watch('lowerValue<LiteralSpecification>.value', handler)\ .watch('upperValue<LiteralSpecification>.value', handler)\ .register_handlers() entry.connect("destroy", self.watcher.unregister_handlers) vbox.pack_start(entry) entry.set_tooltip_text("""\ Enter attribute name and multiplicity, for example - name + name [1] - name [1..2] ~ 1..2 - [1..2]\ """) combo = gtk.combo_box_new_text() for t in ('Unknown navigation', 'Not navigable', 'Navigable'): combo.append_text(t) nav = self.subject.navigability combo.set_active(self.NAVIGABILITY.index(nav)) combo.connect('changed', self._on_navigability_change) vbox.pack_start(combo, expand=False) combo = gtk.combo_box_new_text() for t in ('No aggregation', 'Shared', 'Composite'): combo.append_text(t) combo.set_active(['none', 'shared', 'composite'].index(self.subject.aggregation)) combo.connect('changed', self._on_aggregation_change) vbox.pack_start(combo, expand=False) return vbox
def init_settings(self): #ustawienia startowe oraz defincjie niektórych widgetów self.dev_dvd = self.obj['dev_dvd'] #layer_break adj = gtk.Adjustment(lower=0, upper=99999999, step_incr=1, page_incr=10, page_size=10) self.layer_break = gtk.SpinButton() self.obj['table1'].attach(self.layer_break, left_attach=1, right_attach=2, top_attach=1, bottom_attach=2) self.layer_break.set_adjustment(adj) self.layer_break.show() #layer_break XGD3 bez LT-MAX adj = gtk.Adjustment(lower=0, upper=99999999, step_incr=1, page_incr=10, page_size=10) self.xgd3_layer_break = gtk.SpinButton() self.obj['table1'].attach(self.xgd3_layer_break, left_attach=1, right_attach=2, top_attach=2, bottom_attach=3) self.xgd3_layer_break.set_adjustment(adj) self.xgd3_layer_break.show() #layer_break XGD3 z LT-MAX adj = gtk.Adjustment(lower=0, upper=99999999, step_incr=1, page_incr=10, page_size=10) self.xgd3_layer_break_lt_max = gtk.SpinButton() self.obj['table1'].attach(self.xgd3_layer_break_lt_max, left_attach=1, right_attach=2, top_attach=3, bottom_attach=4) self.xgd3_layer_break_lt_max.set_adjustment(adj) self.xgd3_layer_break_lt_max.show() #rozmiar dla truncate dla XGD3 bez LT-MAX - przycięcie obrazu przed nagrywaniem adj = gtk.Adjustment(lower=0, upper=9999999999, step_incr=1, page_incr=10, page_size=10) self.truncate_size = gtk.SpinButton() self.obj['table1'].attach(self.truncate_size, left_attach=1, right_attach=2, top_attach=4, bottom_attach=5) self.truncate_size.set_adjustment(adj) self.truncate_size.show() #prędkość nagrywania self.burn_speeds = ['x1', 'x2', 'x4', 'x8'] self._burn_speeds = ['1', '2', '4', '8'] self.burn_speed = gtk.combo_box_new_text() self.burn_speed.show() self.obj['table1'].attach(self.burn_speed, left_attach=1, right_attach=2, top_attach=5, bottom_attach=6) for ele in self.burn_speeds: self.burn_speed.append_text(ele) #bufor dla growisofs adj = gtk.Adjustment(lower=0, upper=9999, step_incr=1, page_incr=10, page_size=10) self.buffer = gtk.SpinButton() self.obj['table1'].attach(self.buffer, left_attach=1, right_attach=2, top_attach=6, bottom_attach=7) self.buffer.set_adjustment(adj) self.buffer.show() #terminal self.terminals = ['xterm', 'gnome-terminal', 'terminator'] self.terminal = gtk.combo_box_new_text() self.terminal.show() self.obj['table1'].attach(self.terminal, left_attach=1, right_attach=2, top_attach=7, bottom_attach=8) for ele in self.terminals: self.terminal.append_text(ele)
def __init__(self): super(MainWindow, self).__init__() self.checked = False self.connect("destroy", self.do_exit) self.set_size_request(400, 150) self.set_position(gtk.WIN_POS_CENTER) self.set_title('MangaFox Grabber') try: self.set_icon_from_file('logo.png') except: pass halign = {} vbox = gtk.VBox(False, 2) hbox = {} self.progress = gtk.ProgressBar() self.progress.set_text("Press Check, when ready.") self.button = gtk.Button('Check') self.button.connect('clicked', self.on_continue) self.help = gtk.Button('How to use this application?') self.help.connect('clicked', self.on_help) self.entry = gtk.Entry() self.entrylabel = gtk.Label('Manga') self.threads = gtk.combo_box_new_text() for sel in ['5 threads(slowest, most stable)', '10 threads(recommended)', '20 threads', '50 threads (fastest, least stable)']: self.threads.append_text(sel) self.threads.set_active(1) self.selection = gtk.combo_box_new_text() for sel in ['A5 page size', 'A4 page size', 'A3 page size']: self.selection.append_text(sel) self.selection.set_active(0) widgs = [[self.progress], [self.threads], [self.selection], [self.entrylabel, self.entry], [self.button, self.help], ] for key, widgets in enumerate(widgs): halign[key] = gtk.Alignment(1, 0, 1, 0) hbox[key] = gtk.HBox(False, 2) for widget in widgets: hbox[key].add(widget) halign[key].add(hbox[key]) vbox.pack_start(halign[key], False, False, 1) self.add(vbox) self.show_all()
def __init__(self): gtk.Frame.__init__(self) self.set_border_width(4) self.modify_bg(0, COLORES["window"]) self.set_label(" Datos de Usuario ") self.get_property("label-widget").modify_bg(0, COLORES["window"]) self.set_label_align(0.5, 1.0) tabla = gtk.Table(rows=5, columns=2, homogeneous=True) tabla.set_property("column-spacing", 5) tabla.set_property("row-spacing", 5) label = gtk.Label("Nombre:") tabla.attach(label, 0, 1, 0, 1) self.nombre = gtk.Entry() self.nombre.connect("changed", self.__update_data) tabla.attach(self.nombre, 1, 2, 0, 1) label = gtk.Label("Apellido:") tabla.attach(label, 0, 1, 1, 2) self.apellido = gtk.Entry() self.apellido.connect("changed", self.__update_data) tabla.attach(self.apellido, 1, 2, 1, 2) label = gtk.Label("Escuela:") tabla.attach(label, 0, 1, 2, 3) self.escuela = gtk.Entry() self.escuela.connect("changed", self.__update_data) tabla.attach(self.escuela, 1, 2, 2, 3) label = gtk.Label("Grado:") tabla.attach(label, 0, 1, 3, 4) self.grado = gtk.combo_box_new_text() self.grado.connect("changed", self.__update_data) for g in GRADOS: self.grado.append_text(g) tabla.attach(self.grado, 1, 2, 3, 4) label = gtk.Label("Edad:") tabla.attach(label, 0, 1, 4, 5) self.edad = gtk.combo_box_new_text() self.edad.connect("changed", self.__update_data) for e in EDADES: self.edad.append_text(str(e)) tabla.attach(self.edad, 1, 2, 4, 5) event = gtk.EventBox() event.modify_bg(0, COLORES["window"]) event.set_border_width(4) event.add(tabla) self.add(event) self.show_all()
def __init__(self, query_builder, remove_callback, row_number=None): self.mapper = weakref.proxy(query_builder.mapper) self.table = weakref.proxy(query_builder.expressions_table) self.dialog = weakref.proxy(query_builder) self.menu_item_selected = False if row_number is None: # assume we want the row appended to the end of the table row_number = self.table.props.n_rows self.and_or_combo = None if row_number != 1: self.and_or_combo = gtk.combo_box_new_text() self.and_or_combo.append_text("and") self.and_or_combo.append_text("or") self.and_or_combo.set_active(0) self.table.attach(self.and_or_combo, 0, 1, row_number, row_number + 1) self.prop_button = gtk.Button(_('Choose a property...')) self.prop_button.props.use_underline = False def on_prop_button_clicked(button, event, menu): menu.popup(None, None, None, event.button, event.time) self.schema_menu = SchemaMenu(self.mapper, self.on_schema_menu_activated, self.relation_filter) self.prop_button.connect('button-press-event', on_prop_button_clicked, self.schema_menu) self.table.attach(self.prop_button, 1, 2, row_number, row_number+1) self.cond_combo = gtk.combo_box_new_text() conditions = ['=', '!=', '<', '<=', '>', '>=', 'is', 'is not', 'like', 'ilike'] map(self.cond_combo.append_text, conditions) self.cond_combo.set_active(0) self.table.attach(self.cond_combo, 2, 3, row_number, row_number+1) # by default we start with an entry but value_widget can # change depending on the type of the property chosen in the # schema menu, see self.on_schema_menu_activated self.value_widget = gtk.Entry() self.value_widget.connect('changed', self.on_value_changed) self.table.attach(self.value_widget, 3, 4, row_number, row_number+1) if row_number != 1: image = gtk.image_new_from_stock(gtk.STOCK_REMOVE, gtk.ICON_SIZE_BUTTON) self.remove_button = gtk.Button() self.remove_button.props.image = image self.remove_button.connect('clicked', lambda b: remove_callback(self)) self.table.attach(self.remove_button, 4, 5, row_number, row_number + 1)
def __init__(self, ch_num): self.chan_val = np.zeros((24), dtype=int) self.channel_box = gtk.HBox(homogeneous=False,spacing=0) if ch_num < 9: self.glabel = gtk.Label( " " + str(ch_num + 1) ) else: self.glabel = gtk.Label( str(ch_num + 1) ) self.button_SP = gtk.ToggleButton( label="n" ) self.button_SC = gtk.CheckButton() self.button_SL = gtk.CheckButton() self.button_ST = gtk.CheckButton() self.button_SM = gtk.CheckButton() self.combo_SD = gtk.combo_box_new_text() self.button_SMX = gtk.CheckButton() self.combo_SZ10b = gtk.combo_box_new_text() self.combo_SZ8b = gtk.combo_box_new_text() self.combo_SZ6b = gtk.combo_box_new_text() for i in range(16): self.combo_SD.append_text(str(i) + " mv") self.combo_SD.set_active(0) for i in range(32): self.combo_SZ10b.append_text(str(i) + " ns") self.combo_SZ10b.set_active(0) for i in range(16): self.combo_SZ8b.append_text(str(i) + " ns") self.combo_SZ8b.set_active(0) for i in range(8): self.combo_SZ6b.append_text(str(i) + " ns") self.combo_SZ6b.set_active(0) self.button_SP.connect("toggled",self.SP_callback,ch_num) self.button_SC.connect("toggled",self.SC_callback,ch_num) self.button_SL.connect("toggled",self.SL_callback,ch_num) self.button_ST.connect("toggled",self.ST_callback,ch_num) self.button_SM.connect("toggled",self.SM_callback,ch_num) if ch_num < 64: self.button_SM.set_active(True) self.combo_SD.connect("changed",self.get_SD_value,ch_num) self.button_SMX.connect("toggled",self.SMX_callback,ch_num) self.combo_SZ10b.connect("changed",self.get_SZ10b_value,ch_num) self.combo_SZ8b.connect("changed",self.get_SZ8b_value,ch_num) self.combo_SZ6b.connect("changed",self.get_SZ6b_value,ch_num) self.channel_box.pack_start(self.glabel,expand=False) self.channel_box.pack_start(self.button_SP,expand=False) self.channel_box.pack_start(self.button_SC,expand=False) self.channel_box.pack_start(self.button_SL,expand=False) self.channel_box.pack_start(self.button_ST,expand=False) self.channel_box.pack_start(self.button_SM,expand=False) self.channel_box.pack_start(self.combo_SD,expand=False) self.channel_box.pack_start(self.button_SMX,expand=False) self.channel_box.pack_start(self.combo_SZ10b,expand=False) self.channel_box.pack_start(self.combo_SZ8b,expand=False) self.channel_box.pack_start(self.combo_SZ6b,expand=False)
def __init__(self): self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.connect("destroy", self.destroy) self.window.set_default_size(400, 300) self.window.set_border_width(20) # Title vbox = gtk.VBox(False, 0) vbox.set_spacing(15) label = gtk.Label("Connect to xpra server") label.modify_font(pango.FontDescription("sans 13")) vbox.pack_start(label) # Mode: hbox = gtk.HBox(False, 20) hbox.set_spacing(20) hbox.pack_start(gtk.Label("Mode: ")) self.mode_combo = gtk.combo_box_new_text() self.mode_combo.get_model().clear() for option in ["tcp", "ssh"]: self.mode_combo.append_text(option) self.mode_combo.set_active(0) hbox.pack_start(self.mode_combo) vbox.pack_start(hbox) # JPEG: hbox = gtk.HBox(False, 20) hbox.set_spacing(20) hbox.pack_start(gtk.Label("JPEG Compression: ")) self.jpeg_combo = gtk.combo_box_new_text() self.jpeg_combo.get_model().clear() for option in XPRA_COMPRESSION_OPTIONS: self.jpeg_combo.append_text(option) self.jpeg_combo.set_active(0) hbox.pack_start(self.jpeg_combo) vbox.pack_start(hbox) # Host:Port hbox = gtk.HBox(False, 0) hbox.set_spacing(5) self.host_entry = gtk.Entry(max=128) self.host_entry.set_width_chars(40) if len(sys.argv) > 1: self.host_entry.set_text(sys.argv[1]) else: self.host_entry.set_text("127.0.0.1") self.port_entry = gtk.Entry(max=5) self.port_entry.set_width_chars(5) if len(sys.argv) > 2: self.port_entry.set_text(sys.argv[2]) else: self.port_entry.set_text("16010") hbox.pack_start(self.host_entry) hbox.pack_start(gtk.Label(":")) hbox.pack_start(self.port_entry) vbox.pack_start(hbox) # Info Label self.info = gtk.Label() self.info.set_line_wrap(True) self.info.set_size_request(360, -1) vbox.pack_start(self.info) # Connect button: self.button = gtk.Button("Connect") self.button.connect("clicked", self.connect_clicked, None) vbox.pack_start(self.button) self.window.add(vbox) self.window.show_all()
def __init__(self): global IMG_PATH IMG_PATH = respaths.IMAGE_PATH # Read cursors global INSERTMOVE_CURSOR, OVERWRITE_CURSOR, TWOROLL_CURSOR, ONEROLL_CURSOR, \ ONEROLL_NO_EDIT_CURSOR, TWOROLL_NO_EDIT_CURSOR, SLIDE_CURSOR, SLIDE_NO_EDIT_CURSOR, \ MULTIMOVE_CURSOR, MULTIMOVE_NO_EDIT_CURSOR INSERTMOVE_CURSOR = gtk.gdk.pixbuf_new_from_file( respaths.IMAGE_PATH + "insertmove_cursor.png") OVERWRITE_CURSOR = gtk.gdk.pixbuf_new_from_file(respaths.IMAGE_PATH + "overwrite_cursor.png") TWOROLL_CURSOR = gtk.gdk.pixbuf_new_from_file(respaths.IMAGE_PATH + "tworoll_cursor.png") ONEROLL_CURSOR = gtk.gdk.pixbuf_new_from_file(respaths.IMAGE_PATH + "oneroll_cursor.png") SLIDE_CURSOR = gtk.gdk.pixbuf_new_from_file(respaths.IMAGE_PATH + "slide_cursor.png") ONEROLL_NO_EDIT_CURSOR = gtk.gdk.pixbuf_new_from_file( respaths.IMAGE_PATH + "oneroll_noedit_cursor.png") TWOROLL_NO_EDIT_CURSOR = gtk.gdk.pixbuf_new_from_file( respaths.IMAGE_PATH + "tworoll_noedit_cursor.png") SLIDE_NO_EDIT_CURSOR = gtk.gdk.pixbuf_new_from_file( respaths.IMAGE_PATH + "slide_noedit_cursor.png") MULTIMOVE_CURSOR = gtk.gdk.pixbuf_new_from_file(respaths.IMAGE_PATH + "multimove_cursor.png") MULTIMOVE_NO_EDIT_CURSOR = gtk.gdk.pixbuf_new_from_file( respaths.IMAGE_PATH + "multimove_cursor.png") # Window self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.set_icon_from_file(respaths.IMAGE_PATH + "flowbladeappicon.png") self.window.set_border_width(5) # To ask confirmation for shutdown self.window.connect("delete-event", lambda w, e: app.shutdown()) # Player consumer has to be stopped and started when window resized self.window.connect("window-state-event", lambda w, e: updater.refresh_player()) # Build menubar # Menubar build resources menu_actions = [ ('FileMenu', None, _('_File')), ('New', None, _('_New...'), '<control>N', None, lambda a: projectaction.new_project()), ('Open', None, _('_Open...'), '<control>O', None, lambda a: projectaction.load_project()), ('OpenRecent', None, _('Open Recent')), ('Save', None, _('_Save'), '<control>S', None, lambda a: projectaction.save_project()), ('Save As', None, _('_Save As...'), None, None, lambda a: projectaction.save_project_as()), ('SaveSnapshot', None, _('Save Backup Snapshot...'), None, None, lambda a: projectaction.save_backup_snapshot()), ('ExportMenu', None, _('Export')), ('ExportMeltXML', None, _('MLT XML'), None, None, lambda a: exporting.MELT_XML_export()), ('ExportEDL', None, _('EDL CMX 3600'), None, None, lambda a: exporting.EDL_export()), ('ExportScreenshot', None, _('Current Frame'), None, None, lambda a: exporting.screenshot_export()), ('Close', None, _('_Close'), None, None, lambda a: projectaction.close_project()), ('Quit', None, _('_Quit'), '<control>Q', None, lambda a: app.shutdown()), ('EditMenu', None, _('_Edit')), ('Undo', None, _('_Undo'), '<control>Z', None, undo.do_undo_and_repaint), ('Redo', None, _('_Redo'), '<control>Y', None, undo.do_redo_and_repaint), ('AddFromMonitor', None, _('Add Monitor Clip')), ('AppendClip', None, _('Append'), None, None, lambda a: tlineaction.append_button_pressed()), ('InsertClip', None, _('Insert'), None, None, lambda a: tlineaction.insert_button_pressed()), ('ThreepointOverWriteClip', None, _('Three Point Overwrite'), None, None, lambda a: tlineaction.three_point_overwrite_pressed()), ('RangeOverWriteClip', None, _('Range Overwrite'), None, None, lambda a: tlineaction.range_overwrite_pressed()), ('CutClip', None, _('Cut Clip'), None, None, lambda a: tlineaction.cut_pressed()), ('DeleteClip', None, _('Lift'), None, None, lambda a: tlineaction.lift_button_pressed()), ('SpliceOutClip', None, _('Splice Out'), None, None, lambda a: tlineaction.splice_out_button_pressed()), ('ResyncSelected', None, _('Resync'), None, None, lambda a: tlineaction.resync_button_pressed()), ('SetSyncParent', None, _('Set Sync Parent'), None, None, lambda a: _this_is_not_used()), ('AddTransition', None, _('Add Single Track Transition'), None, None, lambda a: tlineaction.add_transition_menu_item_selected()), ('AddFade', None, _('Add Single Track Fade'), None, None, lambda a: tlineaction.add_fade_menu_item_selected()), ('ClearFilters', None, _('Clear Filters'), None, None, lambda a: clipmenuaction.clear_filters()), ('ChangeSequenceTracks', None, _('Change Sequence Tracks Count...'), None, None, lambda a: projectaction.change_sequence_track_count()), ('Watermark', None, _('Watermark...'), None, None, lambda a: menuactions.edit_watermark()), ('ProfilesManager', None, _('Profiles Manager'), None, None, lambda a: menuactions.profiles_manager()), ('Preferences', None, _('Preferences'), None, None, lambda a: preferenceswindow.preferences_dialog()), ('ViewMenu', None, _('View')), ('ProjectMenu', None, _('Project')), ('AddMediaClip', None, _('Add Media Clip...'), None, None, lambda a: projectaction.add_media_files()), ('AddImageSequence', None, _('Add Image Sequence...'), None, None, lambda a: projectaction.add_image_sequence()), ('CreateColorClip', None, _('Create Color Clip...'), None, None, lambda a: patternproducer.create_color_clip()), ('PatternProducersMenu', None, _('Create Pattern Producer')), ('CreateNoiseClip', None, _('Noise'), None, None, lambda a: patternproducer.create_noise_clip()), ('CreateBarsClip', None, _('EBU Bars'), None, None, lambda a: patternproducer.create_bars_clip()), ('CreateIsingClip', None, _('Ising'), None, None, lambda a: patternproducer.create_icing_clip()), ('CreateColorPulseClip', None, _('Color Pulse'), None, None, lambda a: patternproducer.create_color_pulse_clip()), ('LogClipRange', None, _('Log Marked Clip Range'), '<control>L', None, lambda a: medialog.log_range_clicked()), ('RecreateMediaIcons', None, _('Recreate Media Icons...'), None, None, lambda a: menuactions.recreate_media_file_icons()), ('RemoveUnusedMedia', None, _('Remove Unused Media...'), None, None, lambda a: projectaction.remove_unused_media()), ('JackAudio', None, _("JACK Audio..."), None, None, lambda a: menuactions.jack_output_managing()), ('ProxyManager', None, _('Proxy Manager'), None, None, lambda a: proxyediting.show_proxy_manager_dialog()), ('ProjectType', None, _("Change Project Type..."), None, None, lambda a: projectaction.change_project_type()), ('ProjectInfo', None, _('Project Info'), None, None, lambda a: menuactions.show_project_info()), ('RenderMenu', None, _('Render')), ('AddToQueue', None, _('Add To Batch Render Queue...'), None, None, lambda a: projectaction.add_to_render_queue()), ('BatchRender', None, _('Batch Render Queue'), None, None, lambda a: batchrendering.launch_batch_rendering()), ('Render', None, _('Render Timeline'), None, None, lambda a: projectaction.do_rendering()), ('ToolsMenu', None, _('Tools')), ('Titler', None, _('Titler'), None, None, lambda a: titler.show_titler()), ('AudioMix', None, _('Audio Mixer'), None, None, lambda a: audiomonitoring.show_audio_monitor()), ('MediaLink', None, _('Media Relinker'), None, None, lambda a: medialinker.display_linker()), ('HelpMenu', None, _('_Help')), ('QuickReference', None, _('Contents'), None, None, lambda a: menuactions.quick_reference()), ('Environment', None, _('Runtime Environment'), None, None, lambda a: menuactions.environment()), ('KeyboardShortcuts', None, _('Keyboard Shortcuts'), None, None, lambda a: dialogs.keyboard_shortcuts_dialog(self.window)), ('About', None, _('About'), None, None, lambda a: menuactions.about()), ('InsertMode', None, None, '1', None, lambda a: _this_is_not_used()), ('OverMode', None, None, '2', None, lambda a: _this_is_not_used()), ('OneRollMode', None, None, '3', None, lambda a: _this_is_not_used()), ('TwoRollMode', None, None, '4', None, lambda a: _this_is_not_used()), ('SlideMode', None, None, '5', None, lambda a: _this_is_not_used()), ('MultiMode', None, None, '6', None, lambda a: _this_is_not_used()) ] menu_string = """<ui> <menubar name='MenuBar'> <menu action='FileMenu'> <menuitem action='New'/> <menuitem action='Open'/> <menu action='OpenRecent'/> <menuitem action='Save'/> <menuitem action='Save As'/> <menuitem action='SaveSnapshot'/> <separator/> <menu action='ExportMenu'> <menuitem action='ExportMeltXML'/> <menuitem action='ExportEDL'/> <menuitem action='ExportScreenshot'/> </menu> <separator/> <menuitem action='Close'/> <menuitem action='Quit'/> </menu> <menu action='EditMenu'> <menuitem action='Undo'/> <menuitem action='Redo'/> <separator/> <menu action='AddFromMonitor'> <menuitem action='AppendClip'/> <menuitem action='InsertClip'/> <menuitem action='ThreepointOverWriteClip'/> <menuitem action='RangeOverWriteClip'/> </menu> <separator/> <menuitem action='CutClip'/> <separator/> <menuitem action='SpliceOutClip'/> <menuitem action='DeleteClip'/> <menuitem action='ResyncSelected'/> <menuitem action='ClearFilters'/> <separator/> <menuitem action='AddTransition'/> <menuitem action='AddFade'/> <separator/> <menuitem action='ChangeSequenceTracks'/> <menuitem action='Watermark'/> <separator/> <menuitem action='ProfilesManager'/> <menuitem action='Preferences'/> </menu> <menu action='ViewMenu'> </menu> <menu action='ProjectMenu'> <menuitem action='AddMediaClip'/> <menuitem action='AddImageSequence'/> <separator/> <menuitem action='CreateColorClip'/> <menu action='PatternProducersMenu'> <menuitem action='CreateNoiseClip'/> <menuitem action='CreateColorPulseClip'/> <menuitem action='CreateIsingClip'/> <menuitem action='CreateBarsClip'/> </menu> <separator/> <menuitem action='LogClipRange'/> <separator/> <menuitem action='RecreateMediaIcons'/> <menuitem action='RemoveUnusedMedia'/> <separator/> <menuitem action='ProxyManager'/> </menu> <menu action='RenderMenu'> <menuitem action='AddToQueue'/> <menuitem action='BatchRender'/> <separator/> <menuitem action='Render'/> </menu> <menu action='ToolsMenu'> <menuitem action='Titler'/> <menuitem action='AudioMix'/> <separator/> <menuitem action='MediaLink'/> </menu> <menu action='HelpMenu'> <menuitem action='QuickReference'/> <menuitem action='KeyboardShortcuts'/> <menuitem action='Environment'/> <separator/> <menuitem action='About'/> </menu> </menubar> </ui>""" # Create global action group action_group = gtk.ActionGroup('WindowActions') action_group.add_actions(menu_actions, user_data=None) # Create UIManager and add accelators to window ui = gtk.UIManager() ui.insert_action_group(action_group, 0) ui.add_ui_from_string(menu_string) accel_group = ui.get_accel_group() self.window.add_accel_group(accel_group) # Get menu bar self.menubar = ui.get_widget('/MenuBar') # Set reference to UI manager and acclegroup self.uimanager = ui self.accel_group = accel_group # Add recent projects to menu editorpersistance.fill_recents_menu_widget( ui.get_widget('/MenuBar/FileMenu/OpenRecent'), projectaction.open_recent_project) # Disable audio mixer if not available if editorstate.audio_monitoring_available == False: ui.get_widget('/MenuBar/ToolsMenu/AudioMix').set_sensitive(False) # Menu box menu_vbox = gtk.VBox(False, 0) menu_vbox.pack_start(self.menubar, False, True, 0) # Media manager self.bin_list_view = guicomponents.BinListView( projectaction.bin_selection_changed, projectaction.bin_name_edited) dnd.connect_bin_tree_view(self.bin_list_view.treeview, projectaction.move_files_to_bin) self.bin_list_view.set_property("can-focus", True) bins_panel = panels.get_bins_panel( self.bin_list_view, lambda w, e: projectaction.add_new_bin(), lambda w, e: projectaction.delete_selected_bin()) bins_panel.set_size_request(MEDIA_MANAGER_WIDTH, BINS_HEIGHT) self.media_list_view = guicomponents.MediaPanel( projectaction.media_file_menu_item_selected, updater.set_and_display_monitor_media_file) self.media_scroll_window = gtk.ScrolledWindow() self.media_scroll_window.add_with_viewport(self.media_list_view.widget) self.media_scroll_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.media_scroll_window.set_size_request( guicomponents.MEDIA_OBJECT_WIDGET_WIDTH * 2 + 70, guicomponents.MEDIA_OBJECT_WIDGET_HEIGHT) self.media_scroll_window.show_all() media_panel = panels.get_media_files_panel( self.media_scroll_window, lambda w, e: projectaction.add_media_files(), lambda w, e: projectaction.delete_media_files(), lambda a: self.media_list_view.columns_changed(a), lambda w, e: proxyediting.create_proxy_files_pressed(), projectaction.media_filtering_select_pressed) self.mm_paned = gtk.HPaned() self.mm_paned.pack1(bins_panel, resize=True, shrink=True) self.mm_paned.pack2(media_panel, resize=True, shrink=False) mm_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0) mm_panel.set_padding(2, 2, 6, 2) mm_panel.add(self.mm_paned) # Effects self.effect_select_list_view = guicomponents.FilterListView() self.effect_select_combo_box = gtk.combo_box_new_text() self.effect_select_list_view.treeview.connect( "row-activated", clipeffectseditor.effect_select_row_double_clicked) dnd.connect_effects_select_tree_view( self.effect_select_list_view.treeview) clip_editor_panel = clipeffectseditor.get_clip_effects_editor_panel( self.effect_select_combo_box, self.effect_select_list_view) clipeffectseditor.widgets.effect_stack_view.treeview.connect( "button-press-event", clipeffectseditor.filter_stack_button_press) effects_editor_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0) effects_editor_panel.set_padding(0, 0, 4, 0) effects_editor_panel.add(clipeffectseditor.widgets.value_edit_frame) effects_hbox = gtk.HBox() effects_hbox.set_border_width(5) effects_hbox.pack_start(clip_editor_panel, False, False, 0) effects_hbox.pack_start(effects_editor_panel, True, True, 0) self.effects_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0) self.effects_panel.set_padding(2, 2, 2, 2) self.effects_panel.add(effects_hbox) # Compositors compositor_clip_panel = compositeeditor.get_compositor_clip_panel() compositor_editor_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0) compositor_editor_panel.set_padding(0, 0, 4, 0) compositor_editor_panel.add(compositeeditor.widgets.value_edit_frame) compositors_hbox = gtk.HBox() compositors_hbox.set_border_width(5) compositors_hbox.pack_start(compositor_clip_panel, False, False, 0) compositors_hbox.pack_start(compositor_editor_panel, True, True, 0) self.compositors_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0) self.compositors_panel.set_padding(0, 0, 0, 0) self.compositors_panel.add(compositors_hbox) # Render normal_height = True if appconsts.TOP_ROW_HEIGHT < 500: # small screens have no space to display this normal_height = False add_audio_desc = True if editorstate.SCREEN_HEIGHT < 863: add_audio_desc = False try: render.create_widgets(normal_height) render_panel_left = rendergui.get_render_panel_left( render.widgets, add_audio_desc, normal_height) except IndexError: print "No rendering options found" render_panel_left = None # 'None' here means that no possible rendering options were available # and creating panel failed. Inform user of this and hide render GUI if render_panel_left == None: render_hbox = gtk.VBox(False, 5) render_hbox.pack_start(gtk.Label("Rendering disabled."), False, False, 0) render_hbox.pack_start( gtk.Label("No available rendering options found."), False, False, 0) render_hbox.pack_start( gtk.Label( "See Help->Environment->Render Options for details."), False, False, 0) render_hbox.pack_start( gtk.Label("Install codecs to make rendering available."), False, False, 0) render_hbox.pack_start(gtk.Label(" "), True, True, 0) else: # all is good render_panel_right = rendergui.get_render_panel_right( render.widgets, lambda w, e: projectaction.do_rendering(), lambda w, e: projectaction.add_to_render_queue()) render_hbox = gtk.HBox(True, 5) render_hbox.pack_start(render_panel_left, True, True, 0) render_hbox.pack_start(render_panel_right, True, True, 0) render_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0) render_panel.set_padding(2, 6, 8, 6) render_panel.add(render_hbox) # Media log events List media_log_events_list_view = medialog.get_media_log_list_view() events_panel = medialog.get_media_log_events_panel( media_log_events_list_view) media_log_vbox = gtk.HBox() media_log_vbox.pack_start(events_panel, True, True, 0) media_log_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0) media_log_panel.set_padding(6, 6, 6, 6) media_log_panel.add(media_log_vbox) self.media_log_events_list_view = media_log_events_list_view # Sequence list self.sequence_list_view = guicomponents.SequenceListView( projectaction.sequence_name_edited) seq_panel = panels.get_sequences_panel( self.sequence_list_view, lambda w, e: projectaction.change_edit_sequence(), lambda w, e: projectaction.add_new_sequence(), lambda w, e: projectaction.delete_selected_sequence()) # Project info project_info_panel = projectinfogui.get_project_info_panel() # Project vbox and panel project_vbox = gtk.HBox() project_vbox.pack_start(project_info_panel, False, True, 0) project_vbox.pack_start(seq_panel, True, True, 0) project_panel = gtk.Alignment(0.5, 0.5, 1.0, 1.0) project_panel.set_padding(0, 2, 6, 2) project_panel.add(project_vbox) # Notebook self.notebook = gtk.Notebook() self.notebook.set_size_request(appconsts.NOTEBOOK_WIDTH, appconsts.TOP_ROW_HEIGHT) self.notebook.append_page(mm_panel, gtk.Label(_("Media"))) self.notebook.append_page(media_log_panel, gtk.Label(_("Range Log"))) self.notebook.append_page(self.effects_panel, gtk.Label(_("Filters"))) self.notebook.append_page(self.compositors_panel, gtk.Label(_("Compositors"))) self.notebook.append_page(project_panel, gtk.Label(_("Project"))) self.notebook.append_page(render_panel, gtk.Label(_("Render"))) self.notebook.set_tab_pos(gtk.POS_BOTTOM) # Right notebook, used for Widescreen and Two row layouts self.right_notebook = gtk.Notebook() self.right_notebook.set_tab_pos(gtk.POS_BOTTOM) # Position bar and decorative frame for it self.pos_bar = PositionBar() pos_bar_frame = gtk.Frame() pos_bar_frame.add(self.pos_bar.widget) pos_bar_frame.set_shadow_type(gtk.SHADOW_ETCHED_IN) # Positionbar vbox pos_bar_vbox = gtk.VBox(False, 1) pos_bar_vbox.pack_start(guiutils.get_pad_label(5, 2), False, True, 0) pos_bar_vbox.pack_start(pos_bar_frame, False, True, 0) # Play buttons row self._create_monitor_row_widgets() self.player_buttons = glassbuttons.PlayerButtons() self.player_buttons.widget.set_tooltip_text( _("Prev Frame - Arrow Left\nNext Frame - Arrow Right\nPlay - Space\nStop - Space\nMark In - I\nMark Out - O\nClear Marks\nTo Mark In\nTo Mark Out" )) self.monitor_source.modify_font(pango.FontDescription("sans bold 8")) player_buttons_row = gtk.HBox(False, 0) player_buttons_row.pack_start(self.player_buttons.widget, False, True, 0) player_buttons_row.pack_start(self.monitor_source, True, True, 0) # Creates monitor switch buttons self._create_monitor_buttons() # Switch button box switch_hbox = gtk.HBox(True, 1) switch_hbox.pack_start(self.sequence_editor_b, False, False, 0) switch_hbox.pack_start(self.clip_editor_b, False, False, 0) # Switch button box V, for centered buttons switch_vbox = gtk.VBox(False, 1) switch_vbox.pack_start(guiutils.get_pad_label(5, 2), False, True, 0) switch_vbox.pack_start(switch_hbox, False, True, 0) # Switch / pos bar row self.view_mode_select = guicomponents.get_monitor_view_select_combo( lambda w, e: tlineaction.view_mode_menu_lauched(w, e)) sw_pos_hbox = gtk.HBox(False, 1) sw_pos_hbox.pack_start(switch_vbox, False, True, 0) sw_pos_hbox.pack_start(pos_bar_vbox, True, True, 0) sw_pos_hbox.pack_start(self.view_mode_select.widget, False, False, 0) # Video display black_box = gtk.EventBox() black_box.add(gtk.Label()) bg_color = gtk.gdk.Color(red=0.0, green=0.0, blue=0.0) black_box.modify_bg(gtk.STATE_NORMAL, bg_color) self.tline_display = black_box # This can be any GTK+ widget (that is not "windowless"), only its XWindow draw rect # is used to position and scale SDL overlay that actually displays video. dnd.connect_video_monitor(self.tline_display) # Monitor monitor_vbox = gtk.VBox(False, 1) monitor_vbox.pack_start(self.tline_display, True, True, 0) monitor_vbox.pack_start(sw_pos_hbox, False, True, 0) monitor_vbox.pack_start(player_buttons_row, False, True, 0) monitor_align = gtk.Alignment(xalign=0.0, yalign=0.0, xscale=1.0, yscale=1.0) monitor_align.add(monitor_vbox) monitor_align.set_padding(3, 0, 3, 3) monitor_frame = gtk.Frame() monitor_frame.add(monitor_align) monitor_frame.set_shadow_type(gtk.SHADOW_ETCHED_OUT) monitor_frame.set_size_request(MONITOR_AREA_WIDTH, appconsts.TOP_ROW_HEIGHT) # Notebook panel notebook_vbox = gtk.VBox(False, 1) notebook_vbox.pack_start(self.notebook, True, True) # Top row paned self.top_paned = gtk.HPaned() self.top_paned.pack1(notebook_vbox, resize=False, shrink=False) self.top_paned.pack2(monitor_frame, resize=True, shrink=False) # Top row self.top_row_hbox = gtk.HBox(False, 0) self.top_row_hbox.pack_start(self.top_paned, True, True, 0) self._update_top_row() # Edit buttons rows self.edit_buttons_row = self._get_edit_buttons_row() self.edit_buttons_frame = gtk.Frame() self.edit_buttons_frame.add(self.edit_buttons_row) self.edit_buttons_frame.set_shadow_type(gtk.SHADOW_ETCHED_IN) # Timeline scale self.tline_scale = tlinewidgets.TimeLineFrameScale( editevent.insert_move_mode_pressed, updater.mouse_scroll_zoom) # Timecode display self.tline_info = gtk.HBox() info_contents = gtk.Label() self.tline_info.add(info_contents) self.tline_info.info_contents = info_contents # this switched and sacved as member of its container info_h = gtk.HBox() info_h.pack_start(self.tline_info, False, False, 0) info_h.pack_start(gtk.Label(), True, True, 0) info_h.set_size_request( tlinewidgets.COLUMN_WIDTH - 22 - 22, # - 22, # room for 2 menu launch buttons tlinewidgets.SCALE_HEIGHT) marker_pixbuf = gtk.gdk.pixbuf_new_from_file(respaths.IMAGE_PATH + "marker.png") markers_launcher = guicomponents.get_markers_menu_launcher( tlineaction.marker_menu_lauch_pressed, marker_pixbuf) tracks_launcher_pixbuf = gtk.gdk.pixbuf_new_from_file( respaths.IMAGE_PATH + "track_menu_launch.png") tracks_launcher = guicomponents.PressLaunch( trackaction.all_tracks_menu_launch_pressed, tracks_launcher_pixbuf) # Timeline top row tline_hbox_1 = gtk.HBox() tline_hbox_1.pack_start(info_h, False, False, 0) tline_hbox_1.pack_start(tracks_launcher.widget, False, False, 0) tline_hbox_1.pack_start(markers_launcher.widget, False, False, 0) tline_hbox_1.pack_start(self.tline_scale.widget, True, True, 0) # Timeline column self.tline_column = tlinewidgets.TimeLineColumn( trackaction.track_active_switch_pressed, trackaction.track_center_pressed) # Timeline editpanel self.tline_canvas = tlinewidgets.TimeLineCanvas( editevent.tline_canvas_mouse_pressed, editevent.tline_canvas_mouse_moved, editevent.tline_canvas_mouse_released, editevent.tline_canvas_double_click, updater.mouse_scroll_zoom, self.tline_cursor_leave, self.tline_cursor_enter) dnd.connect_tline(self.tline_canvas.widget, editevent.tline_effect_drop, editevent.tline_media_drop) # Timeline middle row tline_hbox_2 = gtk.HBox() tline_hbox_2.pack_start(self.tline_column.widget, False, False, 0) tline_hbox_2.pack_start(self.tline_canvas.widget, True, True, 0) # Bottom row filler self.left_corner = guicomponents.TimeLineLeftBottom() self.left_corner.widget.set_size_request(tlinewidgets.COLUMN_WIDTH, 20) # Timeline scroller self.tline_scroller = tlinewidgets.TimeLineScroller( updater.tline_scrolled) # Timeline bottom row tline_hbox_3 = gtk.HBox() tline_hbox_3.pack_start(self.left_corner.widget, False, False, 0) tline_hbox_3.pack_start(self.tline_scroller, True, True, 0) # Timeline hbox tline_vbox = gtk.VBox() tline_vbox.pack_start(tline_hbox_1, False, False, 0) tline_vbox.pack_start(tline_hbox_2, True, True, 0) tline_vbox.pack_start(tline_hbox_3, False, False, 0) # Timeline box self.tline_box = gtk.HBox() self.tline_box.pack_start(tline_vbox, True, True, 0) # Timeline pane tline_pane = gtk.VBox(False, 1) tline_pane.pack_start(self.edit_buttons_frame, False, True, 0) tline_pane.pack_start(self.tline_box, True, True, 0) # VPaned top row / timeline self.app_v_paned = gtk.VPaned() self.app_v_paned.pack1(self.top_row_hbox, resize=False, shrink=False) self.app_v_paned.pack2(tline_pane, resize=True, shrink=False) # Pane pane = gtk.VBox(False, 1) pane.pack_start(menu_vbox, False, True, 0) pane.pack_start(self.app_v_paned, True, True, 0) # Tooltips self._add_tool_tips() # GUI preferences self._init_gui_to_prefs() # Viewmenu initial state self._init_view_menu(ui.get_widget('/MenuBar/ViewMenu')) # Set pane and show window self.window.add(pane) self.window.set_title("Flowblade") # Maximize if it seems that we exited maximized, else set size w, h = editorpersistance.prefs.exit_allocation if w != 0: # non-existing prefs file causes w and h to be 0 if (float(w) / editorstate.SCREEN_WIDTH > 0.95) and (float(h) / editorstate.SCREEN_HEIGHT > 0.95): self.window.maximize() print "maximize" else: self.window.resize(w, h) self.window.set_position(gtk.WIN_POS_CENTER) else: self.window.set_position(gtk.WIN_POS_CENTER) # Show window and all of its components self.window.show_all() # Set paned positions self.mm_paned.set_position(editorpersistance.prefs.mm_paned_position) self.top_paned.set_position(editorpersistance.prefs.top_paned_position) self.app_v_paned.set_position( editorpersistance.prefs.app_v_paned_position)
def create_list_box(self, str1, str2, int1, int2): '''Returns a ComboBox object''' return gtk.combo_box_new_text()
def __init__(self): self.dmxoff = False self.colours = [ ("Red", (255,0,0)), ("Green", (0,255,0)), ("Blue", (0,0,255)), ("Cyan", (0,255,255)), ("Magenta", (255,0,255)), ("Lime", (255,255,0)), ("Orange", (255,55,0)), ("Yellow", (255,72,0)), ("Natural", (255,77,18)), ("White", (255,152,58)), ("Full", (255,255,255)) ] self.window = gtk.Window (gtk.WINDOW_TOPLEVEL) self.window.connect("destroy", lambda w: gtk.main_quit()) self.window.set_title("range controls") self.window.set_position(gtk.WIN_POS_CENTER) self.tooltips = gtk.Tooltips() box1 = gtk.VBox(False, 0) self.window.add(box1) labels = { 1: "R", 2: "G", 3: "B", 4: "white", 5: "strobe & speed", 6: "mode" } self.adjustments = {} boxh = gtk.HBox(False, 20) boxh.set_border_width(20) blackout = gtk.CheckButton("Blackout") self.blackout = blackout blackout.connect("toggled", self.cb_master) boxh.pack_start(blackout, True, True, 0) dmxoff = gtk.CheckButton("DMX Off") self.dmxoff = dmxoff dmxoff.connect("toggled", self.cb_dmxoff) boxh.pack_start(dmxoff, True, True, 2) reset = gtk.Button("Refresh") reset.connect("clicked", self.cb_reset) boxh.pack_start(reset, False, False, 0) fadeout = gtk.Button("Fadeout") fadeout.connect("clicked", self.cb_fadeout) boxh.pack_start(fadeout, False, False, 0) fadein = gtk.Button("Fadein") fadein.connect("clicked", self.cb_fadein) boxh.pack_start(fadein, False, False, 0) box1.pack_start(boxh, True, True, 0) box2 = gtk.HBox(False, 5) box2.set_border_width(5) for colour in self.colours: button = gtk.Button(colour[0]) button.connect("clicked", self.cb_colours, colour[1]) self.tooltips.set_tip(button, str(colour[1])) box2.pack_start(button, True, True, 0) box1.pack_start(box2, False, False, 0) box2 = gtk.HBox(False, 20) box2.set_border_width(20) label = gtk.Label("Master") box2.pack_start(label, False, False, 0) box2 = gtk.HBox(False, 20) box2.set_border_width(20) label = gtk.Label("Master") box2.pack_start(label, False, False, 0) adjm = gtk.Adjustment(1.0, 0.0, 1.0, 1/255.0, 1/255.0, 0.0) self.adjm = adjm adjm.connect("value_changed", self.cb_master) scale = gtk.HScale(adjm) scale.set_digits(3) box2.pack_start(scale, True, True, 0) box1.pack_start(box2, True, True, 0) for i in xrange(1,7): box2 = gtk.HBox(False, 10) box2.set_border_width(10) label = gtk.Label(labels[i]) box2.pack_start(label, False, False, 0) adj3 = gtk.Adjustment(0.0, 0.0, 255.0, 1.0, 25.0, 0.0) self.adjustments[i] = adj3 adj3.connect("value_changed", self.cb_dmx, i) scale = gtk.HScale(adj3) scale.set_digits(0) box2.pack_start(scale, True, True, 0) box1.pack_start(box2, True, True, 0) if i==6: # 0 - 31: normal & strobe # 31 - 63: fade in # 64 - 95: fade out # 96 -127: fade in & out # 128-159: colour change (smooth) # 160-223: colour change (immediate, 3 colors) # 224-255: audio sensitive self.moderange = adj3 combobox = gtk.combo_box_new_text() combobox.append_text("Normal") combobox.append_text("Strobe (& Normal)") combobox.append_text("Fade In") combobox.append_text("Fade Out") combobox.append_text("Fade In & Out") combobox.append_text("Colour Change (smooth)") combobox.append_text("Colour Change (rough, 3 colours)") combobox.append_text("Colour Change (rough, 7 colours)") combobox.append_text("Audio") combobox.connect('changed', self.cb_mode) box2.pack_start(combobox, False, False, 0) combobox.set_active(0) else: reset = gtk.Button("Refresh") reset.connect("clicked", self.cb_reset) zero = gtk.Button(" 0 ") zero.connect("clicked", self.cb_zero, i) box2.pack_start(zero, False, False, 0) if i != 4: full = gtk.Button(" F ") full.connect("clicked", self.cb_full, i) box2.pack_start(full, False, False, 0) separator = gtk.HSeparator() box1.pack_start(separator, False, True, 0) box2 = gtk.VBox(False, 10) box2.set_border_width(10) box2.set_size_request(400, -1) box1.pack_start(box2, False, True, 0) button = gtk.Button("Quit") button.connect("clicked", lambda w: gtk.main_quit()) box2.pack_start(button, True, True, 0) button.set_flags(gtk.CAN_DEFAULT) button.grab_default() self.window.show_all()
def _build_interface(self): self.vbox = gtk.VBox() self.vbox.set_spacing(6) self.vbox_top = gtk.VBox() self.vbox_top.set_spacing(0) self.list = common.list_view_new_icon_and_text( headers=['', _('Drive'), _('Mapping')], number_of_text_columns=2, select_multiple=False) self.vbox_top.pack_start(self.list, True, True) self.hbox_buttons = gtk.HBox() self.hbox_buttons.set_spacing(6) self.button_add = gtk.Button(stock=gtk.STOCK_ADD) self.button_add.set_sensitive(True) self.hbox_buttons.pack_start(self.button_add, False, False) self.button_remove = gtk.Button(stock=gtk.STOCK_REMOVE) self.button_remove.set_sensitive(False) self.hbox_buttons.pack_start(self.button_remove, False, False) self.button_auto = common.button_new_with_image('gtk-refresh', label=_("Autodetect"), use_underline=False) self.hbox_buttons.pack_end(self.button_auto, False, False) self.vbox_top.pack_start(self.hbox_buttons, False, False) self.vbox.pack_start(self.vbox_top, True, True) self.vbox_bottom = gtk.VBox() self.vbox_bottom.set_spacing(6) self.path_entry = gtk.Entry() self.path_button = gtk.Button(_('Browse...')) self.path_box = common.new_label_with_widget( '%s: ' % _('Path'), [self.path_entry, self.path_button]) self.vbox_bottom.pack_start(self.path_box, False, True) #self.expander = gtk.Expander(_('Advanced')) #self.vbox_bottom.pack_start(self.expander, False, True) self.vbox_expander = gtk.VBox() self.vbox_expander.set_spacing(6) #self.expander.add(self.vbox_expander) self.vbox_bottom.pack_start(self.vbox_expander, False, True) self.device_entry = gtk.Entry() self.device_button = gtk.Button(_('Browse...')) self.device_box = common.new_label_with_widget( '%s: ' % _('Device'), [self.device_entry, self.device_button]) self.vbox_expander.pack_start(self.device_box, False, True) self.hbox_toggle = gtk.HBox() self.device_toggle = gtk.CheckButton(_('Use device file for path')) self.hbox_toggle.pack_end(self.device_toggle, False, True) self.vbox_expander.pack_start(self.hbox_toggle, False, True) self.type = gtk.combo_box_new_text() for d_type, d_name in self.DRIVE_TYPES: self.type.append_text(d_name) self.type_box = common.new_label_with_widget('%s: ' % _('Type'), self.type) self.vbox_bottom.pack_start(self.type_box, False, True) self.vbox.pack_start(self.vbox_bottom, False, True) self.list.connect('changed', self.list_changed) self.button_add.connect('clicked', self.button_add_clicked) self.button_remove.connect('clicked', self.button_remove_clicked) self.button_auto.connect('clicked', self.button_auto_clicked) self.path_entry.connect('changed', self.path_changed) self.path_button.connect('clicked', self.button_path_clicked) self.type.connect('changed', self.type_changed) self.device_entry.connect('changed', self.device_changed) self.device_button.connect('clicked', self.button_device_clicked) self.device_toggle.connect_after('toggled', self.device_toggled) self.list.renderers[1].connect('edited', self.drive_letter_edit) self.list.renderers[1].set_property('editable', True) self.list.renderers[2].connect('edited', self.drive_mapping_edit) self.list.renderers[2].set_property('editable', True) self.frame = common.frame_wrap(self.vbox, self.title) self.pack_start(self.frame, True, True) self.sizable = [self.path_box.widget, self.type] self.show_all() self.hbox_toggle.hide() self.filechooserdialog_path = common.filechooserdialog_new_with_filters( title=_('Select which folder the drive should be mapped to'), parent=common.widget_get_top_parent(self), action=gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER, on_response_func=self.path_dialog_response) self.filechooserdialog_device = common.filechooserdialog_new_with_filters( title=_('Select which device file the drive use'), parent=common.widget_get_top_parent(self), action=gtk.FILE_CHOOSER_ACTION_OPEN, on_response_func=self.device_dialog_response)
def __init__(self, *args, **kwargs): super(WinCSV, self).__init__(*args, **kwargs) self.dialog = gtk.Dialog(parent=self.parent, flags=gtk.DIALOG_DESTROY_WITH_PARENT) Main().add_window(self.dialog) self.dialog.set_position(gtk.WIN_POS_CENTER_ON_PARENT) self.dialog.set_icon(TRYTON_ICON) self.dialog.connect('response', self.response) dialog_vbox = gtk.VBox() hbox_mapping = gtk.HBox(True) dialog_vbox.pack_start(hbox_mapping, True, True, 0) frame_fields = gtk.Frame() frame_fields.set_shadow_type(gtk.SHADOW_NONE) viewport_fields = gtk.Viewport() scrolledwindow_fields = gtk.ScrolledWindow() scrolledwindow_fields.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) viewport_fields.add(scrolledwindow_fields) frame_fields.add(viewport_fields) label_all_fields = gtk.Label(_('<b>All fields</b>')) label_all_fields.set_use_markup(True) frame_fields.set_label_widget(label_all_fields) hbox_mapping.pack_start(frame_fields, True, True, 0) vbox_buttons = gtk.VBox(False, 10) vbox_buttons.set_border_width(5) hbox_mapping.pack_start(vbox_buttons, False, True, 0) button_add = gtk.Button(_('_Add'), stock=None, use_underline=True) button_add.set_image( IconFactory.get_image('tryton-add', gtk.ICON_SIZE_BUTTON)) button_add.set_always_show_image(True) button_add.connect_after('clicked', self.sig_sel) vbox_buttons.pack_start(button_add, False, False, 0) button_remove = gtk.Button(_('_Remove'), stock=None, use_underline=True) button_remove.set_image( IconFactory.get_image('tryton-remove', gtk.ICON_SIZE_BUTTON)) button_remove.set_always_show_image(True) button_remove.connect_after('clicked', self.sig_unsel) vbox_buttons.pack_start(button_remove, False, False, 0) button_remove_all = gtk.Button(_('_Clear'), stock=None, use_underline=True) button_remove_all.set_image( IconFactory.get_image('tryton-clear', gtk.ICON_SIZE_BUTTON)) button_remove_all.set_always_show_image(True) button_remove_all.connect_after('clicked', self.sig_unsel_all) vbox_buttons.pack_start(button_remove_all, False, False, 0) hseparator_buttons = gtk.HSeparator() vbox_buttons.pack_start(hseparator_buttons, False, False, 3) self.add_buttons(vbox_buttons) frame_fields_selected = gtk.Frame() frame_fields_selected.set_shadow_type(gtk.SHADOW_NONE) viewport_fields_selected = gtk.Viewport() scrolledwindow_fields_selected = gtk.ScrolledWindow() scrolledwindow_fields_selected.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) viewport_fields_selected.add(scrolledwindow_fields_selected) frame_fields_selected.add(viewport_fields_selected) label_fields_selected = gtk.Label(_('<b>Fields selected</b>')) label_fields_selected.set_use_markup(True) frame_fields_selected.set_label_widget(label_fields_selected) hbox_mapping.pack_start(frame_fields_selected, True, True, 0) frame_csv_param = gtk.Frame() frame_csv_param.set_shadow_type(gtk.SHADOW_ETCHED_OUT) dialog_vbox.pack_start(frame_csv_param, False, True, 0) alignment_csv_param = gtk.Alignment(0.5, 0.5, 1, 1) alignment_csv_param.set_padding(7, 7, 7, 7) frame_csv_param.add(alignment_csv_param) vbox_csv_param = gtk.VBox() alignment_csv_param.add(vbox_csv_param) self.add_chooser(vbox_csv_param) expander_csv = gtk.Expander() vbox_csv_param.pack_start(expander_csv, False, True, 0) label_csv_param = gtk.Label(_('CSV Parameters')) expander_csv.set_label_widget(label_csv_param) table = gtk.Table(2, 4, False) table.set_border_width(8) table.set_row_spacings(9) table.set_col_spacings(8) expander_csv.add(table) label_csv_delimiter = gtk.Label(_('Delimiter:')) label_csv_delimiter.set_alignment(1, 0.5) table.attach(label_csv_delimiter, 0, 1, 0, 1) self.csv_delimiter = gtk.Entry() self.csv_delimiter.set_max_length(1) if os.name == 'nt' and ',' == locale.localeconv()['decimal_point']: delimiter = ';' else: delimiter = ',' self.csv_delimiter.set_text(delimiter) self.csv_delimiter.set_width_chars(1) label_csv_delimiter.set_mnemonic_widget(self.csv_delimiter) table.attach(self.csv_delimiter, 1, 2, 0, 1) label_csv_quotechar = gtk.Label(_("Quote char:")) label_csv_quotechar.set_alignment(1, 0.5) table.attach(label_csv_quotechar, 2, 3, 0, 1) self.csv_quotechar = gtk.Entry() self.csv_quotechar.set_text("\"") self.csv_quotechar.set_width_chars(1) label_csv_quotechar.set_mnemonic_widget(self.csv_quotechar) table.attach(self.csv_quotechar, 3, 4, 0, 1) label_csv_enc = gtk.Label(_("Encoding:")) label_csv_enc.set_alignment(1, 0.5) table.attach(label_csv_enc, 0, 1, 1, 2) if hasattr(gtk, 'ComboBoxText'): self.csv_enc = gtk.ComboBoxText() else: self.csv_enc = gtk.combo_box_new_text() for i, encoding in enumerate(encodings): self.csv_enc.append_text(encoding) if ((os.name == 'nt' and encoding == 'cp1252') or (os.name != 'nt' and encoding == 'utf_8')): self.csv_enc.set_active(i) label_csv_enc.set_mnemonic_widget(self.csv_enc) table.attach(self.csv_enc, 1, 2, 1, 2) self.add_csv_header_param(table) button_cancel = self.dialog.add_button(set_underline(_("Cancel")), gtk.RESPONSE_CANCEL) button_cancel.set_image( IconFactory.get_image('tryton-cancel', gtk.ICON_SIZE_BUTTON)) button_ok = self.dialog.add_button(set_underline(_("OK")), gtk.RESPONSE_OK) button_ok.set_image( IconFactory.get_image('tryton-ok', gtk.ICON_SIZE_BUTTON)) self.dialog.vbox.pack_start(dialog_vbox) self.view1 = gtk.TreeView() self.view1.get_selection().set_mode(gtk.SELECTION_MULTIPLE) self.view1.connect('row-expanded', self.on_row_expanded) scrolledwindow_fields.add(self.view1) self.view2 = gtk.TreeView() self.view2.get_selection().set_mode(gtk.SELECTION_MULTIPLE) scrolledwindow_fields_selected.add(self.view2) self.view1.set_headers_visible(False) self.view2.set_headers_visible(False) cell = gtk.CellRendererText() column = gtk.TreeViewColumn(_('Field name'), cell, text=0) self.view1.append_column(column) cell = gtk.CellRendererText() column = gtk.TreeViewColumn(_('Field name'), cell, text=0) self.view2.append_column(column) self.model1 = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_STRING) self.model2 = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING) self.model_populate(self._get_fields(self.model)) self.view1.set_model(self.model1) self.view1.connect('row-activated', self.sig_sel) self.view2.set_model(self.model2) self.view2.connect('row-activated', self.sig_unsel) self.dialog.show_all() self.show() self.register() if sys.platform != 'darwin': self.view2.drag_source_set( gtk.gdk.BUTTON1_MASK | gtk.gdk.BUTTON3_MASK, [ gtk.TargetEntry.new('EXPORT_TREE', gtk.TARGET_SAME_WIDGET, 0) ], gtk.gdk.ACTION_MOVE) self.view2.drag_dest_set(gtk.DEST_DEFAULT_ALL, [ gtk.TargetEntry.new('EXPORT_TREE', gtk.TARGET_SAME_WIDGET, 0) ], gtk.gdk.ACTION_MOVE) self.view2.connect('drag-begin', self.drag_begin) self.view2.connect('drag-motion', self.drag_motion) self.view2.connect('drag-drop', self.drag_drop) self.view2.connect("drag-data-get", self.drag_data_get) self.view2.connect('drag-data-received', self.drag_data_received) self.view2.connect('drag-data-delete', self.drag_data_delete)
def __init__(self, gmtPlotterWidget, gmtWrapper, width=200): self.tooltips = gtk.Tooltips() self.width = width self.gmtPlotterWidget = gmtPlotterWidget self.eb = gtk.EventBox() self.eb.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("gray")) self.eb.set_size_request(self.width, 200) self.vBox = gtk.VBox(homogeneous=True, spacing=1) self.row1 = gtk.HBox(homogeneous=False, spacing=1) # Colormap Type self.colormapCombo = gtk.combo_box_new_text() self.colormapCombo.append_text("haxby") self.colormapCombo.append_text("gray") self.colormapCombo.append_text("wysiwyg") self.colormapCombo.append_text("polar") self.colormapCombo.append_text("seis") self.colormapCombo.append_text("spectral") self.colormapCombo.append_text("other...") self.colormapCombo.set_active(0) self.colormapCombo.connect("changed", self.checkColormap) self.tooltips.set_tip( self.colormapCombo, 'select some of the GMT colormaps, or type your preferred colormap in the text field', tip_private=None) self.colormapEntry = gtk.Entry() self.colormapEntry.set_width_chars(5) self.colormapEntry.set_sensitive(False) self.colormapLabel = gtk.Label("Colormap Type:") self.colormapBox = gtk.HBox(homogeneous=False, spacing=5) self.colormapBox.pack_start(self.colormapLabel) self.invertCheck = gtk.CheckButton(label="Invert") self.tooltips.set_tip( self.invertCheck, 'flip the colormap around, e.g. from red->blue to blue->red', tip_private=None) self.invertCheckBox = gtk.HBox(homogeneous=False, spacing=0) self.invertCheckBox.pack_start(self.invertCheck) self.adjustCheck = gtk.CheckButton(label="Auto scale") self.tooltips.set_tip( self.adjustCheck, 'adjust the colormap automatically to range of scalars plotted in background, else will used fixed range', tip_private=None) self.adjustCheck.set_active(True) self.adjustCheckBox = gtk.HBox(homogeneous=False, spacing=0) self.adjustCheckBox.pack_start(self.adjustCheck) self.labelCheck = gtk.CheckButton(label="Labels") self.labelCheck.set_active(True) self.tooltips.set_tip(self.labelCheck, 'Add a colorbar and labels to the maps.', tip_private=None) self.labelCheckBox = gtk.HBox(homogeneous=False, spacing=0) self.labelCheckBox.pack_start(self.labelCheck) self.plateBoundaryCheck = gtk.CheckButton(label="Pbound") self.tooltips.set_tip(self.plateBoundaryCheck, 'plot NUVEL1 major tectonic plate boundaries', tip_private=None) self.plateBoundaryCheckBox = gtk.HBox(homogeneous=False, spacing=0) self.plateBoundaryCheckBox.pack_start(self.plateBoundaryCheck) self.coastCheck = gtk.CheckButton(label="Coastlines") self.tooltips.set_tip(self.coastCheck, 'Plot coastlines', tip_private=None) self.coastCheckBox = gtk.HBox(homogeneous=False, spacing=0) self.coastCheckBox.pack_start(self.coastCheck) self.coastMaskCombo = gtk.combo_box_new_text() self.coastMaskCombo.append_text("No Mask") self.coastMaskCombo.append_text("Mask Sea") self.coastMaskCombo.append_text("Mask Land") self.coastMaskCombo.set_active(0) self.plotGridLines = gtk.CheckButton(label="Grid lines") self.tooltips.set_tip(self.plotGridLines, 'plot grid lines on top of map', tip_private=None) self.plotGridLinesBox = gtk.HBox(homogeneous=False, spacing=0) self.plotGridLinesBox.pack_start(self.plotGridLines) self.colorSymLabel = gtk.Label("Colors:") self.coastColorButton = gtk.Button("Coast") self.coastColorButton.connect("clicked", self.setCoastColor) self.tooltips.set_tip(self.coastColorButton, 'change color for coast lines', tip_private=None) self.coastMaskColorButton = gtk.Button("Mask") self.coastMaskColorButton.connect("clicked", self.setCoastMaskColor) self.tooltips.set_tip(self.coastMaskColorButton, 'change color for coast mask', tip_private=None) self.pbcolButton = gtk.Button("Pbound") self.pbcolButton.connect("clicked", self.setPbcol) self.tooltips.set_tip(self.pbcolButton, 'change color for plate boundaries', tip_private=None) self.vecColButton = gtk.Button("Vectors") self.vecColButton.connect("clicked", self.setVectColor) self.tooltips.set_tip(self.vecColButton, 'change color for vectors', tip_private=None) # grid resolution self.gridres = gtk.Entry() self.gridres.set_width_chars(4) self.gridres.set_max_length(4) self.gridres.set_text("1.0") self.gridresLabel = gtk.Label("resolution") self.tooltips.set_tip( self.gridres, 'set the resolution (in degrees) of the background grid (if applicable). 0.25...2 are useful for global plots', tip_private=None) #Range Settings # self.rangeLabel = gtk.Label("Lat/Lon Range:") # self.range1Box = gtk.HBox(homogeneous = False, spacing = 0) # self.range1Box.pack_start(self.rangeLabel) self.rangeButton = gtk.Button("Update Lat/Lon Range") self.tooltips.set_tip( self.rangeButton, 'change the geographic region to be mapped (not that useful for global plots)', tip_private=None) self.rangeButton.connect("clicked", self.openRangeWindow) self.row1.pack_start(self.colormapBox, expand=False) self.row1.pack_start(self.colormapCombo, expand=False) self.row1.pack_start(self.colormapEntry, expand=False) self.row1.pack_start(self.invertCheckBox, expand=False) self.row1.pack_start(self.adjustCheckBox, expand=False) self.row1.pack_start(self.labelCheckBox, expand=False) self.row1.pack_start(self.rangeButton, expand=False) self.row2 = gtk.HBox(homogeneous=False, spacing=5) self.applyChangesButton = gtk.Button("Apply Changes") self.applyChangesButton.connect("clicked", self.applyChanges) # self.row2.pack_start(self.range1Box, expand = False) self.row2.pack_start(self.plotGridLinesBox, expand=False) self.row2.pack_start(self.coastCheckBox, expand=False) self.row2.pack_start(self.coastMaskCombo, expand=False) self.row2.pack_start(self.plateBoundaryCheckBox, expand=False) self.row2.pack_start(self.colorSymLabel, expand=False) self.row2.pack_start(self.pbcolButton, expand=False) self.row2.pack_start(self.coastColorButton, expand=False) # self.row2.pack_start(self.coastMaskColorButton,expand=False) self.row2.pack_start(self.vecColButton, expand=False) self.row2.pack_start(self.gridres, expand=False) self.row2.pack_start(self.gridresLabel, expand=False) self.row3 = gtk.HBox(homogeneous=True, spacing=5) # Projection self.projectionLabel = gtk.Label("Projection:") self.projectionEntry = guiUtils.RangeSelectionBox(initial=170, min=0, max=359, digits=0, buttons=True) # width of projection self.projectionEntryEnd = gtk.Entry() self.projectionEntryEnd.set_width_chars(2) self.projectionEntryEnd.set_max_length(2) self.projectionEntryEnd.set_text("7") self.projectionLabel2 = gtk.Label("PS width (inches)") self.projectionBox = gtk.HBox(homogeneous=False, spacing=50) # projection type self.projectCombo = gtk.combo_box_new_text() self.projections = [ 'W Mollweide', 'H Hammer', 'N Robinson' ,\ 'Q Equi-Cyl' , 'J Miller', 'M Mercator', 'Kf Eckert-IV', 'X Linear' ] for pt in self.projections: self.projectCombo.append_text(pt) self.projectCombo.set_active(0) self.projectionBox.pack_start(self.projectionLabel, expand=False) self.projectionBox.pack_start(self.projectCombo, expand=False) self.projectionBox.pack_start(self.projectionEntry, expand=True) self.projectionBox.pack_start(self.projectionEntryEnd, expand=False) self.projectionBox.pack_start(self.projectionLabel2, expand=False) self.row3.pack_start(self.projectionBox, expand=False) self.row4 = gtk.HBox(homogeneous=False, spacing=5) self.applyChangesButton = gtk.Button("Apply Changes") self.applyChangesButton.connect("clicked", self.applyChanges) self.defaultsButton = gtk.Button("Reset") self.defaultsButton.connect("clicked", self.resetToDefault) self.row4.pack_start(self.applyChangesButton, expand=False) self.row4.pack_start(self.defaultsButton, expand=False) self.vBox.pack_start(self.row1, expand=False, fill=False) self.vBox.pack_start(self.row2, expand=False, fill=False) self.vBox.pack_start(self.row3, expand=True, fill=False) self.vBox.pack_start(self.row4, expand=False, fill=False) self.eb.add(self.vBox) # # init with none, gets set in gmt plotter widget self.gmtPlotter = gmtWrapper self.loadDefaults()
def create_combo_box(self, strings): combobox = gtk.combo_box_new_text() for label in strings: combobox.append_text(label) combobox.set_active(0) return combobox
gtk.gdk.threads_init() gtk.gdk.threads_enter() window = gtk.Window() window.set_position(gtk.WIN_POS_CENTER) window.set_title("ZBar GUI") window.set_icon_from_file( "/home/initbrain/Bureau/fktb_0.2.3/images/logo_zbar.png") window.set_border_width(8) window.connect("destroy", gtk.main_quit) zbar = zbarpygtk.Gtk() zbar.connect("decoded-text", decoded) # video device list combo box video_list = gtk.combo_box_new_text() video_list.connect("changed", video_changed) # enable/disable status button status_button = gtk.ToggleButton("closed") status_image = gtk.image_new_from_stock(gtk.STOCK_NO, gtk.ICON_SIZE_BUTTON) status_button.set_image(status_image) status_button.set_sensitive(False) # bind status button state and video state status_button.connect("toggled", status_button_toggled) zbar.connect("notify::video-enabled", video_enabled) zbar.connect("notify::video-opened", video_opened) # open image file button open_button = gtk.Button(stock=gtk.STOCK_OPEN)
def __init__(self, folder): ''' Конструктор :param folder: Папка, в которой будет осуществляться поиск :type folder: string ''' gtk.gdk.threads_init() if os.path.exists(folder): self.folder = folder gtk.Window.__init__(self) self.set_title(_('File search')) self.set_position(gtk.WIN_POS_CENTER) self.set_default_size(800,500) vbox = gtk.VBox(False, 10) #main params mainParamsVBox = gtk.VBox(False,10) hbox1 = gtk.HBox(False,0) self.label1 = gtk.Label(_('File name')) self.label1.set_alignment(0,0.5) self.fileNameEntry = gtk.Entry() self.exactCB = gtk.CheckButton(_('Exact')) self.caseCB = gtk.CheckButton(_('Case sensitive')) self.regexCB = gtk.CheckButton(_('Regex')) self.fileTypeCombo = gtk.combo_box_new_text() self.fileTypeCombo.append_text(_('Files and folders')) self.fileTypeCombo.append_text(_('Files only')) self.fileTypeCombo.append_text(_('Folders only')) self.fileTypeCombo.set_active(0) hbox1.pack_start(self.label1, False, False, 10) hbox1.pack_start(self.fileNameEntry, True, True) hbox1.pack_start(self.fileTypeCombo, False, False,10) hbox1.pack_start(self.exactCB, False, False,10) hbox1.pack_start(self.caseCB, False, False,10) hbox1.pack_start(self.regexCB, False, False,10) self.regexCB.connect('clicked',self.regexCBClick) hbox2 = gtk.HBox(False,0) self.label2 = gtk.Label(_('Search in folder')) self.label2.set_alignment(0,0.5) self.fileChooser = gtk.FileChooserButton(_('Select folder')) self.fileChooser.set_action(gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER) if self.folder: self.fileChooser.set_current_folder(self.folder) self.folderRecursiveCB = gtk.CheckButton(_('Recursive')) self.folderRecursiveCB.set_active(True) hbox2.pack_start(self.label2, False, False, 10) hbox2.pack_start(self.fileChooser, True, True) hbox2.pack_start(self.folderRecursiveCB, False, False, 10) hbox3 = gtk.HBox(False,0) self.label3 = gtk.Label(_('Search for text')) self.label3.set_alignment(0,0.5) self.textEntry = gtk.Entry() self.textCaseCB = gtk.CheckButton(_('Case sensitive')) self.textRegexCB = gtk.CheckButton(_('Regex')) hbox3.pack_start(self.label3, False, False, 10) hbox3.pack_start(self.textEntry, True, True) hbox3.pack_start(self.textCaseCB, False, False, 10) hbox3.pack_start(self.textRegexCB, False, False, 10) mainParamsVBox.pack_start(hbox1) mainParamsVBox.pack_start(hbox2) mainParamsVBox.pack_start(hbox3) #additional params addParamsExpander = gtk.Expander(_('Additional parameters')) addParamsHBox = gtk.HBox() addParamsVBox1 = gtk.VBox() self.useLocateCB = gtk.CheckButton(_('Use UNIX \'locate\' command')) self.useLocateCB.set_active(True) self.useLocateCB.set_tooltip_text('Possibly slow for text search') self.hiddenCB = gtk.CheckButton(_('Process hidden files and folders')) self.linksCB = gtk.CheckButton(_('Follow simlinks')) self.linksCB.set_tooltip_text('Attention! Dead locks possible! ') self.linksCB.set_active(True) addParamsVBox1.pack_start(self.useLocateCB, False, False) addParamsVBox1.pack_start(self.hiddenCB, False, False) addParamsVBox1.pack_start(self.linksCB, False, False) addParamsHBox.pack_start(addParamsVBox1,False, False, 10) addParamsExpander.add(addParamsHBox) #treeview self.treeview = gtk.TreeView() r = gtk.CellRendererText() self.treeview.insert_column_with_attributes(-1, "File name", r, text=0) #status box self.statusBox = gtk.HBox(False,10) self.spinner = gtk.Spinner() #self.spinner.set_sensitive(0) self.statusLabel = gtk.Label('') # statusLabel.set_justify(gtk.JUSTIFY_LEFT) self.statusLabel.set_alignment(0,0) self.statusLabel.set_width_chars(120) self.statusBox.pack_start(self.spinner,False,False,10) self.statusBox.pack_start(self.statusLabel, False, False,10) #button box buttonBox = gtk.HButtonBox() buttonBox.set_layout(gtk.BUTTONBOX_END) buttonBox.set_spacing(10) buttonBox.set_border_width(10) self.buttonStart = gtk.Button(_('Start search'),gtk.STOCK_FIND) self.buttonStop = gtk.Button(_('Stop search'), gtk.STOCK_STOP) self.imagePause = gtk.Image() self.imagePause.set_from_stock(gtk.STOCK_MEDIA_PAUSE, gtk.ICON_SIZE_BUTTON) self.imageContinue = gtk.Image() self.imageContinue.set_from_stock(gtk.STOCK_MEDIA_PLAY, gtk.ICON_SIZE_BUTTON) self.buttonPause = gtk.ToggleButton(_('Pause search')) self.buttonPause.set_image(self.imagePause) self.buttonPause.set_mode(True) self.buttonClose = gtk.Button(_('Close'), gtk.STOCK_CLOSE) buttonBox.add(self.buttonStart) buttonBox.add(self.buttonStop) buttonBox.add(self.buttonPause) buttonBox.add(self.buttonClose) self.buttonClose.connect('clicked', self.closeSearch) self.buttonStart.connect('clicked', self.startSearch) self.buttonStop.connect('clicked', self.stopSearch) self.buttonPause.connect('clicked',self.pauseSearch) self.buttonStop.set_sensitive(0) self.buttonPause.set_sensitive(0) vbox.pack_start(mainParamsVBox, False, True, 10) vbox.pack_start(addParamsExpander, False, True, 0) scrolled = gtk.ScrolledWindow() scrolled.add(self.treeview) vbox.pack_start(scrolled, True, True, 0) vbox.pack_start(self.statusBox, False, True, 0) vbox.pack_start(buttonBox, False, True, 0) self.add(vbox) #self.connect('destroy', self.closeSearch) self.connect('delete-event', self.closeSearch)
def _build_widget(self): ####################################################################### # Type if self._vbox_type == None: self._vbox_type = gtk.VBox(homogeneous=False, spacing=0) label = gtk.Label("Type") label.justify = gtk.JUSTIFY_LEFT label.xalign = 0.5 label.yalign = 0.5 label.xpad = 0 label.ypad = 0 self._vbox_type.add(label) button = gtk.combo_box_new_text() button.connect("changed", self._type_callback) for i in range(OscType.END): button.insert_text(i, OscType.STRINGS[i]) button.set_active(self._type) self._vbox_type.add(button) self._buttons["type"] = button self._hbox.pack_start(self._vbox_type, expand=False, fill=False) ####################################################################### # Mute if self._vbox_mute == None: self._vbox_mute = gtk.VBox(homogeneous=False, spacing=0) label = gtk.Label("Mute") label.justify = gtk.JUSTIFY_LEFT label.xalign = 0.5 label.yalign = 0.5 label.xpad = 0 label.ypad = 0 label.set_width_chars(6) self._vbox_mute.add(label) if self._mute_is_on: button = gtk.ToggleButton("ON") button.set_active(True) else: button = gtk.ToggleButton("OFF") button.set_active(False) button.connect("toggled", self._mute_callback) self._vbox_mute.add(button) self._buttons["mute"] = button self._hbox.pack_start(self._vbox_mute, expand=False, fill=False) ####################################################################### # Volume if self._vbox_volume == None: self._vbox_volume = gtk.VBox(homogeneous=False, spacing=0) label = gtk.Label("Volume") label.justify = gtk.JUSTIFY_LEFT label.xalign = 0.5 label.yalign = 0.5 label.xpad = 0 label.ypad = 0 self._vbox_volume.add(label) button = gtk.SpinButton(gtk.Adjustment(value=self._volume, lower=0.0, upper=1.0, step_incr=0.01, page_incr=0.10, page_size=0.0), climb_rate=0.0, digits=2) button.set_width_chars(6) button.connect("value-changed", self._volume_callback) self._vbox_volume.add(button) self._buttons["volume"] = button self._hbox.pack_start(self._vbox_volume, expand=False, fill=False) ####################################################################### # Pitch if self._vbox_pitch == None: self._vbox_pitch = gtk.VBox(homogeneous=False, spacing=0) label = gtk.Label("Pitch (Hz)") label.justify = gtk.JUSTIFY_LEFT label.xalign = 0.5 label.yalign = 0.5 label.xpad = 0 label.ypad = 0 self._vbox_pitch.add(label) button = gtk.SpinButton(gtk.Adjustment(value=self._pitch, lower=0.001, upper=20000.0, step_incr=5.0, page_incr=10.0, page_size=0.0), climb_rate=0.0, digits=4) button.set_width_chars(10) button.connect("value-changed", self._pitch_callback, None) self._vbox_pitch.add(button) self._buttons["pitch"] = button if self._type != OscType.NOISE: self._hbox.pack_start(self._vbox_pitch, expand=False, fill=False) ####################################################################### # Sync if self._vbox_sync == None: self._vbox_sync = gtk.VBox(homogeneous=False, spacing=0) label = gtk.Label("Sync") label.justify = gtk.JUSTIFY_LEFT label.xalign = 0.5 label.yalign = 0.5 label.xpad = 0 label.ypad = 0 label.set_width_chars(6) self._vbox_sync.add(label) button = gtk.ToggleButton("OFF") button.connect("toggled", self._sync_callback) self._vbox_sync.add(button) self._buttons["sync"] = button if self._can_sync and self._type != OscType.NOISE: self._hbox.pack_start(self._vbox_sync, expand=False, fill=False) ####################################################################### # Harmonics if self._vbox_harmonics == None: self._vbox_harmonics = gtk.VBox(homogeneous=False, spacing=0) label = gtk.Label("Harmonics") label.justify = gtk.JUSTIFY_LEFT label.xalign = 0.5 label.yalign = 0.5 label.xpad = 10 label.ypad = 0 label.set_max_width_chars(10) self._vbox_harmonics.add(label) button = gtk.SpinButton(gtk.Adjustment(value=3, lower=2, upper=256, step_incr=1, page_incr=5, page_size=0), climb_rate=0, digits=0) button.connect("value-changed", self._harmonics_callback) self._vbox_harmonics.add(button) self._buttons["harmonics"] = button if self._type in [OscType.SAWTOOTH, OscType.SQUARE]: self._hbox.pack_start(self._vbox_harmonics, expand=False, fill=False) ####################################################################### # Pulse Width if self._vbox_pulse_width == None: self._vbox_pulse_width = gtk.VBox(homogeneous=False, spacing=0) label = gtk.Label("Pulse Width") label.justify = gtk.JUSTIFY_LEFT label.xalign = 0.5 label.yalign = 0.5 label.xpad = 10 label.ypad = 0 label.set_max_width_chars(13) self._vbox_pulse_width.add(label) button = gtk.SpinButton(gtk.Adjustment(value=self._pulse_width, lower=0.000001, upper=200000.0, step_incr=0.0005, page_incr=0.0010, page_size=0), climb_rate=0, digits=8) button.connect("value-changed", self._pulse_width_callback) self._vbox_pulse_width.add(button) self._buttons["pulse_width"] = button if self._type == OscType.PULSE: self._hbox.pack_start(self._vbox_pulse_width, expand=False, fill=False) ####################################################################### # Pulse Units if self._vbox_pulse_units == None: self._vbox_pulse_units = gtk.VBox(homogeneous=False, spacing=0) label = gtk.Label("Pulse Units") label.justify = gtk.JUSTIFY_LEFT label.xalign = 0.5 label.yalign = 0.5 label.xpad = 10 label.ypad = 0 label.set_max_width_chars(10) self._vbox_pulse_units.add(label) button = gtk.combo_box_new_text() button.insert_text(0, "msec") button.insert_text(0, "% lambda") button.set_active(0) button.connect("changed", self._pulse_units_callback) self._vbox_pulse_units.add(button) self._buttons["pulse_units"] = button if self._type == OscType.PULSE: self._hbox.pack_start(self._vbox_pulse_units, expand=False, fill=False) self._hbox.show_all()
def SJLiveSetting(self, widget): okno = gtk.Window() okno.move(100,100) okno.resize(350,500) okno.set_title("Setting") adjV = gtk.Adjustment(1, 1, 120, 1, 1, 5) adjH = gtk.Adjustment(1, 1, 120, 1, 1, 5) scrollSet = gtk.ScrolledWindow(adjH, adjV) okno.add(scrollSet) kostra = gtk.VBox() self.HboxSetting = gtk.HBox(False,2) frKamera = gtk.Frame("Nastavení kamery") # Vytvoreni a vyplneni tabulky tabGeneral = gtk.Table(5, 2, True) # 2 radky, 2 sloupce a stejna velikost policek tabGeneral.set_row_spacings(2) tabGeneral.set_col_spacings(5) # Nastaveni - Zdroj kamery #hbkamera = gtk.HBox(False, 2) labelKamera = gtk.Label("Kamera:") self.cbKamera = gtk.combo_box_new_text() self.cbKamera.append_text(str(0)) for x in xrange(0,10): if cv2.VideoCapture(x).isOpened(): self.cbKamera.append_text(str(x)) self.cbKamera.set_active( int(self.cfg.get("CAMERA","cam")) ) self.cbKamera.connect("changed", self.KameraSettingChanged) tabGeneral.attach(labelKamera,0,1,0,1) tabGeneral.attach(self.cbKamera,1,2,0,1) # Nastaveni - Zaverka #hbShutter = gtk.HBox(False, 2) labelShutter = gtk.Label("Zaverka: 1/") adjShutter = gtk.Adjustment(100, 1, 1000, 1, 1, 0) self.sbShutter = gtk.SpinButton(adjShutter,1,0) self.sbShutter.set_value( float(self.cfg.get("CAMERA","shutter")) ) self.sbShutter.connect("changed", self.KameraSettingChanged) tabGeneral.attach(labelShutter,0,1,1,2) tabGeneral.attach(self.sbShutter,1,2,1,2) # Nastaveni - FrameRate #hbFPS = gtk.HBox(False, 2) labelFPS = gtk.Label("Snimkovaci rychlost FPS: ") adjFPS = gtk.Adjustment(1, 0.01, 120, 0.01, 0.01, 0) self.sbFPS = gtk.SpinButton(adjFPS,0.01,2) self.sbFPS.set_value( float(self.cfg.get("CAMERA","fps")) ) self.sbFPS.connect("changed", self.KameraSettingChanged) tabGeneral.attach(labelFPS,0,1,2,3) tabGeneral.attach(self.sbFPS,1,2,2,3) frKamera.add(tabGeneral) kostra.pack_start(frKamera, False, False, 10) frMaska = gtk.Frame("Nastavení Masky") # Vytvoreni a vyplneni tabulky tabMaska = gtk.Table(5, 2, True) # 2 radky, 2 sloupce a stejna velikost policek tabMaska.set_row_spacings(2) tabMaska.set_col_spacings(5) labelZobrazMasku = gtk.Label("Zobrazit masku:") self.cbZobrazMasku = gtk.combo_box_new_text() self.cbZobrazMasku.append_text("Vypnuto") self.cbZobrazMasku.append_text("Obrys - silný") self.cbZobrazMasku.append_text("Obrys - slabý") self.cbZobrazMasku.append_text("Obsah") self.cbZobrazMasku.append_text("Přesah") self.cbZobrazMasku.append_text("Maska") self.cbZobrazMasku.set_active( int(self.cfg.get("MASK","type")) ) self.cbZobrazMasku.connect("changed", self.KameraSettingChanged) tabMaska.attach(labelZobrazMasku,0,1,0,1) tabMaska.attach(self.cbZobrazMasku,1,2,0,1) HboxMask = gtk.HBox() HboxX = gtk.HBox() HboxY = gtk.HBox() HboxR = gtk.HBox() labelX = gtk.Label("X") labelY = gtk.Label("Y") labelR = gtk.Label("R") adjX = gtk.Adjustment(1, 1, self.cam.get(3), 1, 1, 0) adjY = gtk.Adjustment(1, 1, self.cam.get(4), 1, 1, 0) adjR = gtk.Adjustment(1, 1, 120, 1, 1, 0) self.sbMaskX = gtk.SpinButton(adjX,1,0) self.sbMaskY = gtk.SpinButton(adjY,1,0) self.sbMaskR = gtk.SpinButton(adjR,1,0) HboxX.pack_start(labelX) HboxX.pack_start(self.sbMaskX) HboxY.pack_start(labelY) HboxY.pack_start(self.sbMaskY) HboxR.pack_start(labelR) HboxR.pack_start(self.sbMaskR) self.sbMaskX.set_value( float(self.cfg.get("MASK","maskX")) ) self.sbMaskY.set_value( float(self.cfg.get("MASK","maskY")) ) self.sbMaskR.set_value( float(self.cfg.get("MASK","maskR")) ) self.sbMaskX.connect("changed", self.KameraSettingChanged) self.sbMaskY.connect("changed", self.KameraSettingChanged) self.sbMaskR.connect("changed", self.KameraSettingChanged) HboxMask.pack_start(HboxX) HboxMask.pack_start(HboxY) HboxMask.pack_start(HboxR) tabMaska.attach(HboxMask,0,2,1,2) frMaska.add(tabMaska) kostra.pack_start(frMaska, False, False, 10) labelHist = gtk.Label("Zobrazit Histogram:") self.cbHist = gtk.combo_box_new_text() self.cbHist.append_text("Vypnuto") self.cbHist.append_text("In SJ - I") self.cbHist.append_text("In SJ - II") self.cbHist.append_text("In SJ - III") self.cbHist.append_text("In SJ - IV") self.cbHist.append_text("Vlastní okno") self.cbHist.set_active( int(self.cfg.get("MASK","hist")) ) self.cbHist.connect("changed", self.KameraSettingChanged) tabMaska.attach(labelHist,0,1,2,3) tabMaska.attach(self.cbHist,1,2,2,3) labelPlotFlare = gtk.Label("Vykreslení erupcí:") self.cbPlotFlare = gtk.combo_box_new_text() self.cbPlotFlare.append_text("Vypnuto") self.cbPlotFlare.append_text("Red") self.cbPlotFlare.append_text("Blue") self.cbPlotFlare.append_text("In JS - III") self.cbPlotFlare.append_text("In JS - IV") self.cbPlotFlare.append_text("Vlastní okno") self.cbPlotFlare.set_active( int(self.cfg.get("MASK","type")) ) self.cbHist.connect("changed", self.KameraSettingChanged) tabMaska.attach(labelPlotFlare,0,1,4,5) tabMaska.attach(self.cbPlotFlare,1,2,4,5) scrollSet.add_with_viewport(kostra) okno.show_all()
def __init__(self): # paparazzi process self.pp = None self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.set_title("Paparazzi Configuration Chooser") self.my_vbox = gtk.VBox() # if PAPARAZZI_HOME not set, then assume the tree containing this # file is a reasonable substitute self.paparazzi_home = os.getenv( "PAPARAZZI_HOME", os.path.dirname(os.path.abspath(__file__))) self.conf_dir = os.path.join(self.paparazzi_home, "conf") self.conf_xml = os.path.join(self.conf_dir, "conf.xml") self.conf_personal_name = "conf_personal.xml" self.conf_personal = os.path.join(self.conf_dir, self.conf_personal_name) self.controlpanel_xml = os.path.join(self.conf_dir, "control_panel.xml") self.controlpanel_personal_name = "control_panel_personal.xml" self.controlpanel_personal = os.path.join( self.conf_dir, self.controlpanel_personal_name) self.exclude_backups = True self.verbose = False # MenuBar mb = gtk.MenuBar() # File filemenu = gtk.Menu() # File Title filem = gtk.MenuItem("File") filem.set_submenu(filemenu) exitm = gtk.MenuItem("Exit") exitm.connect("activate", gtk.main_quit) filemenu.append(exitm) mb.append(filem) # Help helpmenu = gtk.Menu() # Help Title helpm = gtk.MenuItem("Help") helpm.set_submenu(helpmenu) aboutm = gtk.MenuItem("About") aboutm.connect("activate", self.about) helpmenu.append(aboutm) mb.append(helpm) self.my_vbox.pack_start(mb, False) # Combo Bar self.conf_label = gtk.Label("Conf:") self.conf_label.set_size_request(100, 30) self.conf_file_combo = gtk.combo_box_new_text() self.find_conf_files() # self.firmwares_combo.connect("changed", self.parse_list_of_airframes) self.conf_file_combo.set_size_request(550, 30) self.btnDeleteConf = gtk.Button(None, gtk.STOCK_DELETE) self.btnDeleteConf.connect("clicked", self.delete_conf) self.btnDeleteConf.set_tooltip_text("Permanently Delete Conf") self.btnPersonalConf = gtk.Button(None, gtk.STOCK_COPY) self.btnPersonalConf.connect("clicked", self.personal_conf) self.btnPersonalConf.set_tooltip_text( "Create Personal Conf Based on Selected and Activate") self.confbar = gtk.HBox() self.confbar.pack_start(self.conf_label) self.confbar.pack_start(self.conf_file_combo) self.confbar.pack_start(self.btnDeleteConf) self.confbar.pack_start(self.btnPersonalConf) self.my_vbox.pack_start(self.confbar, False) # Explain current conf config self.conf_explain = gtk.Label("") self.update_conf_label() self.conf_explain.set_size_request(0, 45) self.cfexbar = gtk.HBox() self.cfexbar.pack_start(self.conf_explain) self.my_vbox.pack_start(self.cfexbar, False) # Controlpanel self.controlpanel_label = gtk.Label("Controlpanel:") self.controlpanel_label.set_size_request(100, 30) self.controlpanel_file_combo = gtk.combo_box_new_text() self.find_controlpanel_files() self.controlpanel_file_combo.set_size_request(550, 30) # window self.btnDeleteControl = gtk.Button(None, gtk.STOCK_DELETE) self.btnDeleteControl.connect("clicked", self.delete_controlpanel) self.btnDeleteControl.set_tooltip_text("Permanently Delete") self.btnPersonalControl = gtk.Button(None, gtk.STOCK_COPY) self.btnPersonalControl.connect("clicked", self.personal_controlpanel) self.btnPersonalControl.set_tooltip_text( "Create Personal Controlpanel Based on Selected and Activate") self.controlpanelbar = gtk.HBox(False) self.controlpanelbar.pack_start(self.controlpanel_label) self.controlpanelbar.pack_start(self.controlpanel_file_combo) self.controlpanelbar.pack_start(self.btnDeleteControl) self.controlpanelbar.pack_start(self.btnPersonalControl) self.my_vbox.pack_start(self.controlpanelbar, False) # Explain current controlpanel config self.controlpanel_explain = gtk.Label("") self.update_controlpanel_label() self.controlpanel_explain.set_size_request(0, 45) self.ctexbar = gtk.HBox() self.ctexbar.pack_start(self.controlpanel_explain) self.my_vbox.pack_start(self.ctexbar, False) # show backups button self.btnBackups = gtk.CheckButton("show backups") self.btnBackups.connect("toggled", self.set_backups) self.my_vbox.pack_start(self.btnBackups, False) # show gui button self.btnPythonGUI = gtk.CheckButton("new python center (beta)") self.my_vbox.pack_start(self.btnPythonGUI, False) # Buttons self.btnAccept = gtk.Button("Set Active") self.btnAccept.connect("clicked", self.accept) self.btnAccept.set_tooltip_text( "Set selected Conf/Control_Panel as Active") self.btnLaunch = gtk.Button( "Launch Paparazzi with selected configuration") self.btnLaunch.connect("clicked", self.launch) self.btnLaunch.set_tooltip_text( "Launch Paparazzi with current conf.xml and control_panel.xml") self.btnExit = gtk.Button("Exit") self.btnExit.connect("clicked", gtk.main_quit) self.btnExit.set_tooltip_text("Close application") self.toolbar = gtk.HBox() self.toolbar.set_size_request(0, 60) self.toolbar.pack_start(self.btnLaunch) self.toolbar.pack_start(self.btnAccept) self.toolbar.pack_start(self.btnExit) self.my_vbox.pack_start(self.toolbar, False) # status bar self.statusbar = gtk.Statusbar() self.context_id = self.statusbar.get_context_id("info") #self.statusbar.push(self.context_id, "Waiting for you to do something...") self.my_vbox.pack_end(self.statusbar, False) # Bottom self.window.add(self.my_vbox) self.window.show_all() self.window.set_position(gtk.WIN_POS_CENTER_ALWAYS) self.window.connect("destroy", gtk.main_quit)
def build_handset(self): self.arrow_stepval = 1.0 widgets = {} # Place arrow buttons off_xv = 220 off_yh = 150 btns = widgets.setdefault('buttons', {}) for x, y, name, axis, mult in ( (off_xv, off_yh - 140, 'up3', 0, 10), (off_xv, off_yh - 100, 'up2', 0, 3), (off_xv, off_yh - 60, 'up1', 0, 1), (off_xv - 170, off_yh, 'left3', 1, 10), (off_xv - 130, off_yh, 'left2', 1, 3), (off_xv - 90, off_yh, 'left1', 1, 1), (off_xv + 80, off_yh, 'right1', 1, -1), (off_xv + 120, off_yh, 'right2', 1, -3), (off_xv + 160, off_yh, 'right3', 1, -10), (off_xv, off_yh + 60, 'down1', 0, -1), (off_xv, off_yh + 100, 'down2', 0, -3), (off_xv, off_yh + 140, 'down3', 0, -10), ): btn = self._make_button(name) btn.connect("clicked", self.arrowMove, axis, mult) btns[name] = btn self.lw.put(btn, x, y) # Place entries ents = widgets.setdefault('entries', {}) for x, y, width, name in ((off_xv - 35, off_yh + 5, 10, 'mainstep'), ): ent = gtk.Entry() ent.set_alignment(1.0) ent.set_text("0") ent.set_width_chars(width) ent.show() ents[name] = ent self.lw.put(ent, x, y) # Place spin buttons for x, y, name in ((20, 250, 'lspin'), (120, 250, 'rspin')): ent = gtk.SpinButton() ent.show() ent.set_alignment(1.0) ent.set_update_policy(gtk.UPDATE_ALWAYS) # this seems to force size ent.set_range(-1000, 1000) ents[name] = ent self.lw.put(ent, x, y) # Place labels lbls = widgets.setdefault('labels', {}) for x, y, txt, name in ((off_xv + 45, 210 + 5, 'x1', 'x1'), (off_xv + 45, 250 + 5, 'x3', 'x3'), (off_xv + 45, 290 + 5, 'x10', 'x10'), (off_xv, off_yh - 18, 'Step', 'mainstep'), (off_xv - 5, off_yh + 35, 'arcsec', 'mainunit'), (20, 30, 'Mode', 'mode'), (20, 232, '+N/-S', 'lstep'), (120, 232, '+E/-W', 'rstep'), (20, 275, 'arcsec', 'lstepunit'), (120, 275, 'arcsec', 'rstepunit')): lbl = gtk.Label(txt) lbl.show() lbls[name] = lbl self.lw.put(lbl, x, y) # Compass lbl = self._make_compass('N', 'S', 'E', 'W') lbls['compass'] = lbl self.lw.put(lbl, off_xv + 80, off_yh - 120) # Place buttons btns = widgets['buttons'] btn = gtk.Button('Move') #btn.set_size(10, -1) btn.connect("clicked", self.execute) btn.show() btns['move'] = btn self.lw.put(btn, 20, 300) # Mode drop-down cbox = gtk.combo_box_new_text() cbox.show() cbox.connect("changed", self.changeMode) btns['mode'] = cbox self.lw.put(cbox, 20, 50) self.widgets = widgets
def on_treeEffects_button_release_event(self, widget, *args): print "on_treeEffects_button_release_event" # get correct gettext method _ = self._ # get selected effect (if any) selected_effect, unique_id = self.get_selected_effect() real_effect = self.OSTreeEffects.get_real_effect( service=selected_effect) clip_effect = self.get_clip_effect(unique_id) if real_effect: # show the settings panel self.vbox_effect_settings.set_property('visible', True) # Clear Effect Edit Controls self.clear_effect_controls() # Loop through Params param_index = 1 for param in real_effect.params: # get hbox hbox = self.vbox_effect_settings.get_children()[param_index] label = hbox.get_children()[0] self.sizegroup1.add_widget(label) # Get actual value for param user_param_value = self.get_clip_parameter( clip_effect, param.name) # update label with title label.set_text(_(param.title)) label.set_tooltip_text(_(param.title)) if param.type == "spinner": # create spinner adj = gtk.Adjustment(float(user_param_value), float(param.min), float(param.max), float(param.step), float(param.step), 0.0) spinner = gtk.SpinButton(adj, float(param.step), int(param.digits)) # connect signal spinner.connect("value-changed", self.effect_spinner_changed, real_effect, param, unique_id) # add to hbox hbox.pack_start(spinner, expand=True, fill=True) elif param.type == "hscale": # create hscale adj = gtk.Adjustment(float(user_param_value), float(param.min), float(param.max), float(param.step), float(param.step), 0.0) hscale = gtk.HScale(adj) hscale.set_digits(int(param.digits)) # connect signal hscale.connect("value-changed", self.effect_hscale_changed, real_effect, param, unique_id) # add to hbox hbox.pack_start(hscale, expand=True, fill=True) elif param.type == "dropdown": cboBox = gtk.combo_box_new_text() # add values box_index = 0 for k, v in param.values.items(): # add dropdown item cboBox.append_text(k) # select dropdown (if default) if v == user_param_value: cboBox.set_active(box_index) box_index = box_index + 1 # connect signal cboBox.connect("changed", self.effect_dropdown_changed, real_effect, param, unique_id) # add to hbox hbox.pack_start(cboBox, expand=True, fill=True) elif param.type == "color": colorButton = gtk.ColorButton() # set color default_color = gtk.gdk.color_parse(user_param_value) colorButton.set_color(default_color) # connect signal colorButton.connect("color-set", self.effect_color_changed, real_effect, param, unique_id) # add to hbox hbox.pack_start(colorButton, expand=True, fill=True) # show all new controls hbox.show_all() # increment param index param_index = param_index + 1
def __init__(self, logger): self.logger = logger self.drawcolors = ['white', 'black', 'red', 'yellow', 'blue', 'green'] self.select = FileSelection.FileSelection() root = gtk.Window(gtk.WINDOW_TOPLEVEL) root.set_title("FitsImageCanvas Example") root.set_border_width(2) root.connect("delete_event", lambda w, e: quit(w)) self.root = root vbox = gtk.VBox(spacing=2) fi = FitsImageCanvas(logger) fi.enable_autocuts('on') fi.enable_zoom('on') fi.enable_cuts(True) fi.enable_flip(True) fi.enable_rotate(True) fi.enable_draw(True) fi.set_drawtype('ruler') fi.set_drawcolor('blue') fi.set_callback('drag-drop', self.drop_file) fi.set_callback('motion', self.motion) fi.set_bg(0.2, 0.2, 0.2) fi.ui_setActive(True) self.fitsimage = fi w = fi.get_widget() w.set_size_request(512, 512) vbox.pack_start(w, fill=True, expand=True) self.readout = gtk.Label("") vbox.pack_start(self.readout, fill=True, expand=False) hbox = gtk.HBox(spacing=5) wdrawtype = gtk.combo_box_new_text() self.drawtypes = fi.get_drawtypes() index = 0 for name in self.drawtypes: wdrawtype.insert_text(index, name) index += 1 index = self.drawtypes.index('ruler') wdrawtype.set_active(index) wdrawtype.connect('changed', self.set_drawparams) self.wdrawtype = wdrawtype wdrawcolor = gtk.combo_box_new_text() index = 0 for name in self.drawcolors: wdrawcolor.insert_text(index, name) index += 1 index = self.drawcolors.index('blue') wdrawcolor.set_active(index) wdrawcolor.connect('changed', self.set_drawparams) self.wdrawcolor = wdrawcolor wclear = gtk.Button("Clear Canvas") wclear.connect('clicked', self.clear_canvas) wopen = gtk.Button("Open File") wopen.connect('clicked', self.open_file) wquit = gtk.Button("Quit") wquit.connect('clicked', quit) for w in (wquit, wclear, wdrawcolor, wdrawtype, wopen): hbox.pack_end(w, fill=False, expand=False) vbox.pack_start(hbox, fill=False, expand=False) root.add(vbox)
def init_main(self): """""" vbox = gtk.VBox() frame = gtk.Frame() frame.set_label_widget(gtk.image_new_from_file(media.ICON_LANGUAGE)) frame.set_border_width(5) vbox.pack_start(frame, False, False) hbox = gtk.HBox() vbox1 = gtk.VBox() frame.add(vbox1) hbox = gtk.HBox() vbox1.pack_start(hbox, False, False, 5) label = gtk.Label(_("Choose language: ")) hbox.pack_start(label, False, False, 10) aspect = gtk.AspectFrame() aspect.set_shadow_type(gtk.SHADOW_NONE) hbox.pack_start(aspect) self.language = gtk.combo_box_new_text() for lang in [lang[0] for lang in LANGUAGES]: self.language.append_text(lang) self.language.set_active([lang[1] for lang in LANGUAGES ].index(self.config.get_languaje())) hbox.pack_start(self.language, False, False, 10) frame = gtk.Frame() frame.set_label_widget(gtk.image_new_from_file(media.ICON_NETWORK)) frame.set_border_width(5) vbox.pack_start(frame, False, False) vbox1 = gtk.VBox() frame.add(vbox1) hbox = gtk.HBox() label = gtk.Label(_("Max simultaneous downloads: ")) hbox.pack_start(label, False, False, 10) aspect = gtk.AspectFrame() aspect.set_shadow_type(gtk.SHADOW_NONE) hbox.pack_start(aspect) self.max_downloads = gtk.SpinButton(None, 1, 0) self.max_downloads.set_range(1, 20) self.max_downloads.set_increments(1, 0) self.max_downloads.set_numeric(True) self.max_downloads.set_value(self.config.get_max_downloads()) hbox.pack_start(self.max_downloads, False, False, 10) vbox1.pack_start(hbox, False, False, 2) hbox = gtk.HBox() label = gtk.Label(_("Max download speed: ")) hbox.pack_start(label, False, False, 10) aspect = gtk.AspectFrame() aspect.set_shadow_type(gtk.SHADOW_NONE) hbox.pack_start(aspect) self.max_download_speed = gtk.SpinButton(None, 4, 0) self.max_download_speed.set_range(0, 5000) self.max_download_speed.set_increments(4, 0) self.max_download_speed.set_numeric(True) self.max_download_speed.set_value(self.config.get_max_download_speed()) hbox.pack_start(self.max_download_speed, False, False, 10) vbox1.pack_start(hbox, False, False, 2) #hbox = gtk.HBox() #label = gtk.Label(_("Max simultaneous uploads: ")) #hbox.pack_start(label, False, False, 10) #aspect = gtk.AspectFrame() #aspect.set_shadow_type(gtk.SHADOW_NONE) #hbox.pack_start(aspect) #self.max_uploads = gtk.SpinButton(None, 1, 0) #self.max_uploads.set_range(1,10) #self.max_uploads.set_increments(1,0) #self.max_uploads.set_numeric(True) #self.max_uploads.set_value(self.config.get_max_uploads()) #hbox.pack_start(self.max_uploads, False, False, 10) #vbox1.pack_start(hbox, False, False, 2) frame = gtk.Frame() frame.set_label_widget(gtk.image_new_from_file(media.ICON_FOLDER)) frame.set_border_width(5) vbox.pack_start(frame, False, False) vbox1 = gtk.VBox() frame.add(vbox1) hbox = gtk.HBox() vbox1.pack_start(hbox, False, False, 5) label = gtk.Label(_("Downloads Folder: ")) hbox.pack_start(label, False, False, 10) path = self.config.get_downloads_folder() self.downloads_folder = gtk.Label(path) self.downloads_folder.set_width_chars(30) self.downloads_folder.set_alignment(0, 0.5) self.downloads_folder.set_ellipsize(pango.ELLIPSIZE_START) hbox.pack_start(self.downloads_folder, False, False, 10) bbox = gtk.HButtonBox() bbox.set_layout(gtk.BUTTONBOX_END) hbox.pack_start(bbox, True, True, 10) button = gtk.Button(None, gtk.STOCK_OPEN) button.connect("clicked", self.choose_path) bbox.pack_start(button) vbox.show_all() return vbox
def create_visual_elements(self): self.set_size_request(600, 400) label = gtk.Label() label.set_alignment(0.0, 0.5) markup = "<span font_desc='12'>The image to be written into usb drive:</span>" label.set_markup(markup) self.vbox.pack_start(label, expand=False, fill=False, padding=2) table = gtk.Table(2, 10, False) table.set_col_spacings(5) table.set_row_spacings(5) self.vbox.pack_start(table, expand=True, fill=True) scroll = gtk.ScrolledWindow() scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) scroll.set_shadow_type(gtk.SHADOW_IN) tv = gtk.TextView() tv.set_editable(False) tv.set_wrap_mode(gtk.WRAP_WORD) tv.set_cursor_visible(False) self.buf = gtk.TextBuffer() self.buf.set_text(self.image_path) tv.set_buffer(self.buf) scroll.add(tv) table.attach(scroll, 0, 10, 0, 1) # There are 2 ways to use DeployImageDialog # One way is that called by HOB when the 'Deploy Image' button is clicked # The other way is that called by a standalone script. # Following block of codes handles the latter way. It adds a 'Select Image' button and # emit a signal when the button is clicked. if self.standalone: gobject.signal_new("select_image_clicked", self, gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE, ()) icon = gtk.Image() pix_buffer = gtk.gdk.pixbuf_new_from_file(hic.ICON_IMAGES_DISPLAY_FILE) icon.set_from_pixbuf(pix_buffer) button = gtk.Button("Select Image") button.set_image(icon) #button.set_size_request(140, 50) table.attach(button, 9, 10, 1, 2, gtk.FILL, 0, 0, 0) button.connect("clicked", self.select_image_button_clicked_cb) separator = gtk.HSeparator() self.vbox.pack_start(separator, expand=False, fill=False, padding=10) self.usb_desc = gtk.Label() self.usb_desc.set_alignment(0.0, 0.5) markup = "<span font_desc='12'>You haven't chosen any USB drive.</span>" self.usb_desc.set_markup(markup) self.usb_combo = gtk.combo_box_new_text() self.usb_combo.connect("changed", self.usb_combo_changed_cb) model = self.usb_combo.get_model() model.clear() self.usb_combo.append_text(self.__dummy_usb__) for usb in self.find_all_usb_devices(): self.usb_combo.append_text("/dev/" + usb) self.usb_combo.set_active(0) self.vbox.pack_start(self.usb_combo, expand=False, fill=False) self.vbox.pack_start(self.usb_desc, expand=False, fill=False, padding=2) self.progress_bar = HobProgressBar() self.vbox.pack_start(self.progress_bar, expand=False, fill=False) separator = gtk.HSeparator() self.vbox.pack_start(separator, expand=False, fill=True, padding=10) self.vbox.show_all() self.progress_bar.hide()
def __init__(self): # Create a new window self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) # Set the window title self.window.set_title("CurrencyConverter") # Set a handler for delete_event that immediately # exits GTK. self.window.connect("delete_event", self.delete_event) slist = ["HR Kuna", "Euro", "US Dollar", "Swiss Franc"] # Create a 2x2 table table = gtk.Table(5, 3, True) # Put the table in the main window self.window.add(table) # Create first button button1 = gtk.Button("Convert") #choose a currency from 2 combo box combo1 = gtk.combo_box_new_text() combo1.append_text(slist[0]) combo1.append_text(slist[1]) combo1.append_text(slist[2]) combo1.append_text(slist[3]) #combo1.set_active(0) combo1.connect("changed", self.combo_selected1) combo2 = gtk.combo_box_new_text() combo2.append_text(slist[0]) combo2.append_text(slist[1]) combo2.append_text(slist[2]) combo2.append_text(slist[3]) #combo2.set_active(0) combo2.connect("changed", self.combo_selected2) label1 = gtk.Label("Currency I Have") label2 = gtk.Label("Currency I Want") label3 = gtk.Label("Amount") label4 = gtk.Label("Converted") datelabel = gtk.Label(x.date) datelabel.modify_font(pango.FontDescription("sans 16")) menu_bar = gtk.MenuBar() file_menu = gtk.Menu() help_menu = gtk.Menu() help_item = gtk.MenuItem("Help") about_item = gtk.MenuItem("About") quit_item = gtk.MenuItem("Quit") file_menu.append(quit_item) help_menu.append(about_item) file_item = gtk.MenuItem("File") help_item = gtk.MenuItem("Help") file_item.set_submenu(file_menu) menu_bar.append(file_item) help_item.set_submenu(help_menu) menu_bar.append(help_item) entry1 = gtk.Entry(max=10) entry2 = gtk.Entry(max=10) combo1.connect("changed", self.combo_entry, entry1) button1.connect("clicked", self.callback, entry2) table.attach(button1, 1, 2, 3, 4, gtk.FILL | gtk.SHRINK, gtk.FILL | gtk.SHRINK, 10, 5) table.attach(combo1, 0, 1, 2, 3, gtk.FILL | gtk.SHRINK, gtk.FILL | gtk.SHRINK, 10, 5) table.attach(combo2, 2, 3, 2, 3, gtk.FILL | gtk.SHRINK, gtk.FILL | gtk.SHRINK, 10, 5) table.attach(label1, 0, 1, 1, 2, gtk.FILL | gtk.SHRINK, gtk.FILL | gtk.SHRINK, 10, 5) table.attach(label2, 2, 3, 1, 2, gtk.FILL | gtk.SHRINK, gtk.FILL | gtk.SHRINK, 10, 5) table.attach(label3, 0, 1, 3, 4, gtk.FILL | gtk.SHRINK, gtk.FILL | gtk.SHRINK, 10, 5) table.attach(label4, 2, 3, 3, 4, gtk.FILL | gtk.SHRINK, gtk.FILL | gtk.SHRINK, 10, 5) table.attach(datelabel, 1, 2, 1, 2, gtk.FILL | gtk.SHRINK, gtk.FILL | gtk.SHRINK, 10, 5) table.attach(entry1, 0, 1, 4, 5, gtk.FILL | gtk.SHRINK, gtk.FILL | gtk.SHRINK, 10, 5) table.attach(entry2, 2, 3, 4, 5, gtk.FILL | gtk.SHRINK, gtk.FILL | gtk.SHRINK, 10, 5) table.attach(menu_bar, 0, 3, 0, 1, gtk.FILL | gtk.SHRINK, gtk.FILL | gtk.SHRINK, 0, 0) table.set_row_spacings(15) table.set_col_spacings(10) quit_item.connect("activate", gtk.main_quit) about_item.connect("activate", self.response, None) entry1.connect("key-release-event", self.entry_data) button1.show() combo1.show() combo2.show() quit_item.show() help_item.show() file_item.show() about_item.show() menu_bar.show() label1.show() label2.show() label3.show() label4.show() datelabel.show() entry1.show() entry2.show() table.show() self.window.show()
def __init__(self): # color systems self.__colorSystems = ["YIQ", "RGB", "HSV"] self.__activeColorSystem = self.__colorSystems[0] ## main window spacing = 5 self.window = gtk.Window() self.window.set_position(gtk.WIN_POS_CENTER_ON_PARENT) self.window.set_default_size(*windowSize) self.window.set_title("colorname") self.window.connect("delete_event", self.delete_event) self.window.connect("destroy", self.destroy) self.window.set_border_width(1) pixbuf = self.window.render_icon(gtk.STOCK_SELECT_COLOR, gtk.ICON_SIZE_DIALOG) self.window.set_icon(pixbuf) ## main boxes mainBox = gtk.VBox(spacing=spacing) self.window.add(mainBox) ## misc self.colorSelect = gtk.ColorSelection() mainBox.pack_start(self.colorSelect, expand=False) listsBox = gtk.VPaned() listsBox.set_position(150) mainBox.pack_start(listsBox, expand=True) ## colors colorFrame = gtk.Frame(label="Colors") listsBox.pack1(colorFrame, shrink=False) colorBox = gtk.VBox(spacing=spacing) colorFrame.add(colorBox) self.colorModel = gtk.ListStore(gobject.TYPE_BOOLEAN, gobject.TYPE_STRING, gobject.TYPE_PYOBJECT) colorView = gtk.TreeView(self.colorModel) # columns toggleRend = gtk.CellRendererToggle() toggleRend.set_property('activatable', True) toggleRend.connect("toggled", self.__colorlistCheckboxHandler, self.colorModel) toggleCol = gtk.TreeViewColumn("", toggleRend) toggleCol.add_attribute(toggleRend, "active", 0) colorView.append_column(toggleCol) colorView.append_column( gtk.TreeViewColumn("Colorlist", gtk.CellRendererText(), text=1)) # create scrollbars around the view. colorScrolledListView = gtk.ScrolledWindow() colorScrolledListView.set_property("hscrollbar_policy", gtk.POLICY_NEVER) colorScrolledListView.add(colorView) colorBox.pack_start(colorScrolledListView) ## results resultFrame = gtk.Frame(label="Results") listsBox.pack2(resultFrame, shrink=0) self.resultModel = gtk.ListStore(gobject.TYPE_FLOAT, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_UINT) self.__resultView = gtk.TreeView(self.resultModel) self.__resultView.set_search_column(1) resultRend = gtk.CellRendererText() # color colNr = 1 colorCell = gtk.CellRendererPixbuf() colorNameCol = gtk.TreeViewColumn("Color") colorNameCol.pack_start(colorCell, False) colorNameCol.pack_start(resultRend, True) colorNameCol.set_sort_column_id(colNr) colorNameCol.set_cell_data_func(colorCell, self.__renderColorPixbuf) colorNameCol.set_attributes(resultRend, text=colNr) self.__resultView.append_column(colorNameCol) # source colNr = 2 sourceCol = gtk.TreeViewColumn("Source", resultRend, text=colNr) sourceCol.set_sort_column_id(colNr) sourceCol.set_min_width(-1) self.__resultView.append_column(sourceCol) # distance colNr = 0 distCol = gtk.TreeViewColumn("Distance", resultRend, text=colNr) distCol.set_sort_column_id(colNr) distCol.set_sort_order(gtk.SORT_ASCENDING) self.__resultView.append_column(distCol) self.__resultView.connect("button_press_event", self.__resultsPopup) # create scrollbars around the view. resultScrolledListView = gtk.ScrolledWindow() resultScrolledListView.set_property("hscrollbar_policy", gtk.POLICY_NEVER) resultScrolledListView.add(self.__resultView) resultFrame.add(resultScrolledListView) ## button box buttonBox = gtk.HBox(spacing=spacing) execButton = gtk.Button(stock=gtk.STOCK_EXECUTE) execButton.connect("clicked", self.execute) buttonBox.pack_start(execButton, fill=False, expand=False) selCombobox = gtk.combo_box_new_text() map(selCombobox.append_text, self.__colorSystems) selCombobox.set_active(0) buttonBox.pack_start(selCombobox, fill=False, expand=False) selCombobox.connect("changed", self.__comboboxChangedHandler) closeButton = gtk.Button(stock=gtk.STOCK_CLOSE) closeButton.connect_object("clicked", gtk.Widget.destroy, self.window) buttonBox.pack_end(closeButton, fill=False, expand=False) aboutButton = gtk.Button("A_bout") aboutButton.connect("clicked", self.__showAbout) buttonBox.pack_end(aboutButton, fill=False, expand=False) mainBox.pack_start(buttonBox, fill=False, expand=False) ## self.window.show_all()
def tab_page(self): vvbox1 = gtk.VBox(False, 10) vvbox1.set_border_width(3) vvbox2 = gtk.VBox(False) vvbox3 = gtk.VBox(False, 5) ####### vvbox2.set_border_width(3) hhbox1 = gtk.HBox(False) hhbox2 = gtk.HBox(False) ############# hhbox1.set_border_width(3) tb1 = gtk.Table(2, 2, True) ###########Rc_Cell_Cell################### button1 = gtk.Button(stock='gtk-go-up') button2 = gtk.Button(stock='gtk-go-down') label1 = gtk.Label(_('Columns')) label1.modify_font(pango.FontDescription('bold')) label1.set_justify(gtk.JUSTIFY_LEFT) cel_sort = self.listen_cel() cel_sort.renderer.connect('toggled', self.fixed_toggled, cel_sort.model) button1.connect('clicked', self.downup, cel_sort, True) button2.connect('clicked', self.downup, cel_sort, False) #############Rc_Cell_Appearance########## label2 = gtk.Label(_('Appearance')) label2.modify_font(pango.FontDescription('bold')) #chkb1 = gtk.CheckButton() #tb1.attach() ######################################### vvbox2.pack_start(button1, True) vvbox2.pack_start(button2, True) vvbox1.pack_start(label1, False) hhbox1.pack_start(cel_sort, True) hhbox1.pack_start(vvbox2, False) vvbox1.pack_start(hhbox1, False) vvbox1.pack_start(label2, False) tb1.attach(gtk.Label(_('Expand')), 0, 1, 0, 1) tb1.attach(gtk.Label(_('Min size')), 1, 2, 0, 1) tb1.attach(gtk.Label(_('Horizontal')), 2, 3, 0, 1) tb1.attach(gtk.Label(_('Vertical')), 3, 4, 0, 1) for i in xrange(len(edna_function.mc)): cheak = gtk.CheckButton(None) cheak.cl = '%s_expand' % edna_function.mc[i] cheak.set_active(int(edna_function.rc_dict['style'][cheak.cl])) cheak.connect('toggled', self.toggled) sp2 = gtk.SpinButton(gtk.Adjustment(0, 0, 100, 1, -1)) sp2.cl = '%s_size' % edna_function.mc[i] sp2.set_value(int(edna_function.rc_dict['style'][sp2.cl])) sp2.connect('value_changed', self.spin) chkH1 = gtk.combo_box_new_text() for j in gfH: chkH1.append_text(j) chkH1.nm = '%s_alignment_h' % edna_function.mc[i] chkH1.set_active( gf.index(float(edna_function.rc_dict['style'][chkH1.nm]))) chkH1.connect('changed', self.chk_c) chkV1 = gtk.combo_box_new_text() for j in gfV: chkV1.append_text(j) chkV1.nm = '%s_alignment_v' % edna_function.mc[i] chkV1.set_active( gf.index(float(edna_function.rc_dict['style'][chkV1.nm]))) chkV1.connect('changed', self.chk_c) tb1.attach(cheak, 0, 1, i + 1, i + 2) tb1.attach(sp2, 1, 2, i + 1, i + 2) tb1.attach(chkH1, 2, 3, i + 1, i + 2) tb1.attach(chkV1, 3, 4, i + 1, i + 2) lb = gtk.Label(_('Columns')) vvbox3.pack_start(lb, True) for i in xrange(len(edna_function.mc)): lb = gtk.Label(edna_gui.Name_Colum[edna_function.mc[i]]) lb.set_alignment(0.0, 0.5) vvbox3.pack_start(lb, True) hhbox2.pack_start(vvbox3, True) hhbox2.pack_start(tb1, False) vvbox1.pack_start(hhbox2, False) hbox2 = gtk.HBox(False, 10) label1 = gtk.Label(_('Format of creation')) label1.set_alignment(0.0, 0.5) entry1 = gtk.Entry() entry1.set_text(edna_function.rc_dict['style']['cell_datec_format']) entry1.connect('changed', self.on_changed, 'cell_datec_format') hbox2.pack_start(label1, True) hbox2.pack_start(entry1, False) hbox3 = gtk.HBox(False, 10) label2 = gtk.Label(_('Format of change')) label2.set_alignment(0.0, 0.5) entry2 = gtk.Entry() entry2.set_text(edna_function.rc_dict['style']['cell_datem_format']) entry2.connect('changed', self.on_changed, 'cell_datem_format') hbox3.pack_start(label2, True) hbox3.pack_start(entry2, False) hbox4 = gtk.HBox(False, 3) chk1 = gtk.combo_box_new_text() chk1.append_text(_('in the bytes')) chk1.append_text(_('with a floating point Kb, Mb')) chk1.append_text(_('with a floating point Kb, Mb, Gb')) chk1.set_active(int( edna_function.rc_dict['style']['cell_size_format'])) chk1.connect('changed', self.chk1_c) label3 = gtk.Label(_('Size format')) label3.set_alignment(0.0, 0.5) hbox5 = gtk.HBox(False, 3) chk2 = gtk.combo_box_new_text() chk2.append_text(_('numerical')) chk2.append_text(_('string')) chk2.set_active(int(edna_function.rc_dict['style']['cell_atr_format'])) chk2.connect('changed', self.chk2_c) label4 = gtk.Label(_('Attribute format')) label4.set_alignment(0.0, 0.5) hbox4.pack_start(label3, True) hbox4.pack_start(chk1, False) hbox5.pack_start(label4, True) hbox5.pack_start(chk2, False) vvbox1.pack_start(hbox2, False) vvbox1.pack_start(hbox3, False) vvbox1.pack_start(hbox4, False) vvbox1.pack_start(hbox5, False) self.note.append_page(vvbox1, gtk.Label(_('Table')))
def __init__(self, pkgs=[]): self.window = gtk.Window() self.window.set_default_size(500, 300) self.window.show() hbox = gtk.VPaned() hbox.show() self.graph = chart.LineChart() self.graph.set_size_request(500, 200) self.graph.connect('select', self.select) hbox.pack1(self.graph, True) self.graph.show() vbox = gtk.VBox() vbox.show() # add distro stuff h = gtk.HBox() self.distro = gtk.combo_box_new_text() self.distro.connect("changed", self.distro_changed) h.add(self.distro) self.branch = gtk.combo_box_new_text() self.branch.connect("changed", self.branch_changed) h.add(self.branch) self.arch = gtk.combo_box_new_text() h.add(self.arch) self.color = gtk.ColorButton() h.add(self.color) self.add = gtk.Button(stock=gtk.STOCK_ADD) self.add.connect("clicked", self.add_distro) h.add(self.add) h.show_all() vbox.pack_start(h, False, False) # package stuff vbox2 = gtk.VBox() vbox2.show() self.pkg_store = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING) self.packages = [] p_tv = gtk.TreeView(self.pkg_store) #p_tv.set_fixed_height_mode(True) p_tv.set_rules_hint(True) p_tv.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH) #p_tv.set_headers_visible(False) renderer = gtk.CellRendererText() p_tv.append_column(gtk.TreeViewColumn("Packages", renderer, markup=0)) p_tv.append_column(gtk.TreeViewColumn("Version", renderer, text=1)) p_tv.show() sp = gtk.ScrolledWindow() sp.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS) sp.show() sp.add(p_tv) vbox2.pack_start(sp) hbox2 = gtk.HBox() hbox2.show() hbox2.pack_start(vbox2, False, False) self.distro_store = gtk.ListStore(str) s = gtk.ScrolledWindow() s.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS) s.show() s.set_vadjustment(sp.props.vadjustment) self.distro_view = gtk.TreeView(self.distro_store) #self.distro_view.set_fixed_height_mode(True) self.distro_view.set_rules_hint(True) self.distro.set_size_request(-1, -1) self.distro_view.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH) #l.set_headers_visible(False) self.distro_view.show() s.add(self.distro_view) hbox2.pack_start(s) vbox.pack_start(hbox2) # add package stuff h = gtk.HBox() self.pkg = gtk.Entry() self.pkg.connect("activate", self.add_pkg_cb) h.pack_start(self.pkg, False, False) self.add = gtk.Button(stock=gtk.STOCK_ADD) self.add.connect("clicked", self.add_pkg_cb) h.pack_start(self.add, False, False) h.show_all() vbox.pack_start(h, False, False) hbox.add(vbox) self.window.add(hbox) self.window.connect("destroy", lambda x: gtk.main_quit()) HOST, USER, PASSWORD, DB = helper.mysql_settings() con = db.connect(host=HOST, user=USER, password=PASSWORD, database=DB) self.distros = {} cur = con.cursor() cur.execute( "SELECT DISTINCT distros.name, branches.branch, repos.architecture FROM distros, repos, branches WHERE distros.id = repos.distro_id AND repos.id = branches.repo_id;" ) for name, branch, arch in cur: if name not in self.distros: self.distros[name] = {} if branch not in self.distros[name]: self.distros[name][branch] = [] if arch not in self.distros[name][branch]: self.distros[name][branch].append(arch) con.close() for d in self.distros.keys(): self.distro.append_text(d) self.current = datetime.now() self._histories = [] for p in pkgs: self.add_pkg(p)
def __init__(self, img, parent=None): global config, exten self.image = img.name self.recycle = False #print("Begin autosave_a with launching image: "+str(image)) # Create the window win = gtk.Window.__init__(self) #self.connect('destroy', lambda *w: gtk.main_quit()) self.connect('destroy', self.on_destroy) self.set_title(_("Autosave_a Panel")) # next block is for the window icon -------------------------------- icon_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), \ 'autosave_a') try: self.set_icon_from_file(icon_dir + os.sep + 'autosave-icon.png') except: print("Autosave warning: did not find the icon file!") # ------------------------------------------------------------------ self.set_focus_on_map(True) self.set_border_width(8) sup_vbox = gtk.VBox(False, 8) self.add(sup_vbox) label = gtk.Label(_(" Choose your parameters below and press 'Start';")\ +_("\nonly button active after 'Start' is 'Stop'. Then")\ +_("\nminimize (close=stop) the window until needed.")) # pack_start(child, expand=True, fill=True, padding=0) sup_vbox.pack_start(label, False, False, 0) ############################## ## Directory -> dir_frame = gtk.Frame(_("Directory")) sup_vbox.pack_start(dir_frame, padding=5) hbox = gtk.HBox(False, 4) dir_frame.add(hbox) # button to choose dir (to launch gtk.FileSelection) button = gtk.Button(_("Change the")) button.connect('clicked', self.on_choose_dir_clicked) hbox.pack_start(button, False, False, 0) # put the actual dir beside it label = gtk.Label(_("backup dir.: ")) hbox.pack_start(label, False, False, 0) self.label = gtk.Label('') self.label.set_has_tooltip(True) self.label.set_tooltip_text(_("The actual folder where the backup")\ +_("\nwill be")) hbox.pack_start(self.label, False, False, 0) ############################## ## Files -> file_frame = gtk.Frame(_("Files")) sup_vbox.pack_start(file_frame, padding=5) table = gtk.Table(2, 3) table.set_row_spacings(4) table.set_col_spacings(4) file_frame.add(table) # column headers label = gtk.Label(_("image")) label.set_has_tooltip(True) label.set_tooltip_text(_("The source(s) of the backup file from:")\ +_("\nthe one to all")) table.attach(label, 0, 1, 0, 1) label = gtk.Label(_("extension")) label.set_tooltip_text(_("To control the compression of 'xcf' file from:")\ +_("\nmore to less")) table.attach(label, 1, 2, 0, 1) label = gtk.Label(_("nr kept")) label.set_has_tooltip(True) label.set_tooltip_text(_("Number of backup kept for the same ")\ +_("\nsession and image ID")) table.attach(label, 2, 3, 0, 1) # autosave image source + extension: xcfbz2 or xcfgz self.source = [_("Launching one"), _("All changed"), \ _("All open")] self.combo1 = gtk.combo_box_new_text() [self.combo1.append_text(x) for x in self.source] self.combo1.connect("changed", self.on_all_changed) table.attach(self.combo1, 0, 1, 1, 2) exten = [".xcf.bz2", ".xcf.gz", ".xcf", ".png", ".jpg"] self.combo = gtk.combo_box_new_text() [self.combo.append_text(x) for x in exten] self.combo.connect("changed", self.on_file_ext_change) table.attach(self.combo, 1, 2, 1, 2) # number of backup to keep of current image: 1 -> 9 self.interv = gtk.SpinButton(adjustment=None, climb_rate=1.0, digits=0) self.interv.set_range(1, 9) self.interv.set_increments(1, 1) self.interv.set_numeric(True) self.interv.connect('value-changed', self.on_nr_kept_change) table.attach(self.interv, 2, 3, 1, 2) ############################## ## Time -> time_frame = gtk.Frame(_("Time")) sup_vbox.pack_start(time_frame, padding=5) hbox = gtk.HBox(False, 4) time_frame.add(hbox) self.rbtn = gtk.CheckButton(_("At start? ")) self.rbtn.connect("toggled", self.on_toggled_check, None) self.rbtn.set_has_tooltip(True) self.rbtn.set_tooltip_text(_("If check: begins at the interval start,")\ +_("\nif not at the end.")) hbox.pack_start(self.rbtn, False, False, 0) # put the header for time interval beside it label = gtk.Label(_("Backup interval (min):")) hbox.pack_start(label, False, False, 0) # gtk.SpinButton(adjustment=None, climb_rate=0.0, digits=0) self.interv1 = gtk.SpinButton(adjustment=None, climb_rate=0.0, digits=1) self.interv1.set_range(1, 999) self.interv1.set_increments(0.1, 5) self.interv1.set_numeric(True) self.interv1.connect('value-changed', self.on_time_interval_change) hbox.pack_start(self.interv1, False, False, 0) ############################## ## Controls -> hbox = gtk.HBox(False, 8) sup_vbox.pack_start(hbox, False, False, 0) # button to save current parameters now self.choices = shelf.list_dict() self.nr = 0 # number of save_config for i in range(len(self.choices)): if self.choices[i][:5] == 'recal': self.nr += 1 if self.nr == 5: self.recycle = True self.button = gtk.Button(_("Save config ") + str(self.nr % 5)) self.button.set_has_tooltip(True) self.button.set_tooltip_text(_("Will save all the above parameters on disk")\ +_("\nfor later usage with button 'Recall config'")) self.button.connect('clicked', self.on_save_now_clicked) hbox.pack_start(self.button, False, False, 0) # place a remenber param. combobox hbox2 = gtk.HBox() #hbox2.set_border_width(10) hbox.pack_start(hbox2) self.combo_box = gtk.combo_box_new_text() self.combo_box.set_wrap_width(1) # new 'choices' list to unable lang. translation self.choices_combo = [_("Default config")] conf_act = 0 for i in range(len(self.choices)): if i > 0: if self.choices[i][:5] == 'lasts': self.choices_combo.append(_("LastStop config")) conf_act = i else: self.choices_combo.append(_("Recall config ")+\ self.choices[i][-1:]) self.combo_box.append_text(self.choices_combo[i]) self.combo_box.set_active(conf_act) self.combo_box.set_has_tooltip(True) self.combo_box.set_tooltip_text( _("Choose from existing config presets")) hbox2.pack_start(self.combo_box) self.combo_box.connect("changed", self.choice_i_cb) # icon to indicate state self.stock_ic = gtk.Image() self.stock_ic.set_from_stock(gtk.STOCK_EXECUTE, gtk.ICON_SIZE_BUTTON) self.stock_ic.set_has_tooltip(True) self.stock_ic.set_tooltip_text(_("Indicates if the widgets to the left")\ +_("\nand above are frozen or not")) hbox.pack_start(self.stock_ic, False, False, 0) hbox.pack_start(gtk.VSeparator(), expand=False) # place a start-stop button self.button1 = gtk.Button(_("Start")) self.button1.connect('pressed', self.on_activate_clicked) hbox.pack_start(self.button1, True, True, 3) ############################## ## Info during -> info_frame = gtk.Frame(_("Info")) sup_vbox.pack_start(info_frame, padding=5) vbox = gtk.VBox(False, 0) info_frame.add(vbox) if self.recycle: msgi = msgr else: msgi = msga self.label1 = gtk.Label(msgi) self.label1.set_alignment(0.1, 0.2) vbox.pack_start(self.label1, False, False, 0) self.show_all() self.set_config() timeout_add_seconds(1, self.timer_action)
def __init__(self, ip): TITLE = "Nmap Scan Module" nmap = getattr(config, 'NMAP_PATH') self.profiles = getattr(config, 'NMAP_PROFILES') self.ip = ip # Dialog self.dialog = gtk.Dialog( title=TITLE, parent=None, buttons=(gtk.STOCK_HELP, gtk.RESPONSE_HELP, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK)) self.dialog.resize(250, 75) # Label self.tglab = gtk.Label('Target:') self.tglab.set_alignment(0.0, 0.5) # A target text entry self.tgentry = gtk.Entry(max=50) self.tgentry.set_text(self.ip) # Label self.prolab = gtk.Label('Profile:') self.prolab.set_alignment(0.0, 0.5) # A ComboBox self.combobox = gtk.combo_box_new_text() for profile in self.profiles.keys(): self.combobox.append_text(profile) self.combobox.connect('changed', self.changed_cb) # Label self.comlab = gtk.Label('Command:') self.comlab.set_alignment(0.0, 0.5) # A command text entry self.comentry = gtk.Entry(max=200) self.comentry.set_text('nmap -v -A ' + self.ip) # Separator self.sep = gtk.HSeparator() # ProgressBar self.progressbar = gtk.ProgressBar(adjustment=None) ######################################################### # Table table = gtk.Table(rows=5, columns=4, homogeneous=False) table.set_row_spacings(2) table.set_col_spacings(2) # Add lements to Table table.attach(self.tglab, 0, 1, 0, 1) table.attach(self.tgentry, 1, 2, 0, 1) table.attach(self.prolab, 2, 3, 0, 1) table.attach(self.combobox, 3, 4, 0, 1) table.attach(self.comlab, 0, 1, 1, 2) table.attach(self.comentry, 1, 4, 1, 2) table.attach(self.sep, 1, 3, 2, 3) table.attach(self.progressbar, 0, 5, 3, 4) # Add HBox to VBox self.dialog.vbox.pack_start(table, False, False, 2) ######################################################### # the help button self.butt_help = self.dialog.action_area.get_children()[2] self.butt_help.connect("clicked", lambda x: self.show_help()) # the cancel button self.butt_cancel = self.dialog.action_area.get_children()[1] self.butt_cancel.connect("clicked", lambda x: self.dialog.destroy()) # the save button self.butt_save = self.dialog.action_area.get_children()[0] self.butt_save.connect("clicked", self.validateData) # Check nmap availability if not os.path.exists(config.NMAP_PATH): self.progressbar.set_text('Nmap not found on: ' + config.NMAP_PATH) self.progressbar.set_fraction(1) self.butt_save.set_sensitive(False) # Finish self.dialog.show_all() self.dialog.show()
def __init__(self): gtk.Window.__init__(self) self.connect('destroy', self.destroy_cb) self.config_window = None self.live_hide_timeout = 0 self.light_hop_timeout = 0 self.busy = False self.leds = ledmap.Ledmap( os.path.join(source_dir, 'data', 'led-maps.txt')) logging.debug('loaded %d maps', len(self.leds.get_names())) for name in self.leds.get_names(): bytes = self.leds.get_bytes(name) logging.debug('%s: %d lights', name, len(bytes)) # where project directories get written, see RTI cap above self.outdir = options.outdir self.lights = lights.Lights() # try to reset the lights ... if this fails, disable dome controls try: self.dome_controls = True name = self.leds.get_names()[0] self.lights.set_triple(self.leds.get_bytes(name)[0]) except lights.Error as e: logging.debug('no lights found, disabling dome controls') self.dome_controls = False self.vbox = gtk.VBox(False, 0) self.add(self.vbox) self.vbox.show() fixed = gtk.Fixed() self.vbox.pack_start(fixed, False) fixed.show() self.camera = camera.Camera() self.preview = preview.Preview(self.camera) fixed.put(self.preview, 0, 0) self.preview.show() self.preview.connect('motion_notify_event', self.preview_motion_cb) if options.verbose: try: config = camera.Config(self.camera) config.prettyprint(sys.stdout, config.get_root_widget()) except: logging.debug("No Camera detected: unable to print config") eb = gtk.EventBox() fixed.put(eb, 0, 0) eb.show() self.progress = progress.Progress() self.progress.set_size_request(preview_width, -1) eb.add(self.progress) eb = gtk.EventBox() fixed.put(eb, 0, 0) eb.show() self.info = info.Info() self.info.set_size_request(preview_width, -1) eb.add(self.info) eb = gtk.EventBox() fixed.put(eb, 20, 380) eb.show() self.play_image = gtk.image_new_from_stock(gtk.STOCK_MEDIA_PLAY, gtk.ICON_SIZE_SMALL_TOOLBAR) self.pause_image = gtk.image_new_from_stock( gtk.STOCK_MEDIA_PAUSE, gtk.ICON_SIZE_SMALL_TOOLBAR) self.live = gtk.Button() self.live.set_image(self.play_image) self.live.set_tooltip_text("Start/stop live preview") self.live.connect('clicked', self.live_cb, None) eb.add(self.live) self.live.show() self.toolbar = gtk.HBox(False, 5) self.toolbar.set_border_width(3) self.vbox.pack_end(self.toolbar) self.toolbar.show() button = gtk.Button() quit_image = gtk.image_new_from_stock(gtk.STOCK_QUIT, gtk.ICON_SIZE_SMALL_TOOLBAR) quit_image.show() button.set_tooltip_text("Quit RTIAcquire") button.connect('clicked', self.destroy_cb, None) button.add(quit_image) self.toolbar.pack_end(button, False, False) button.show() if self.dome_controls: self.dome_picker = gtk.combo_box_new_text() for name in self.leds.get_names(): self.dome_picker.append_text(name) self.dome_picker.set_active(0) self.dome_picker.set_tooltip_text("Select lighting system") self.dome_picker.connect('changed', self.dome_picker_cb, None) self.toolbar.pack_start(self.dome_picker, False, False) self.dome_picker.show() self.light_picker = gtk.SpinButton(climb_rate=1) self.light_picker.set_numeric(True) self.light_picker.set_wrap(True) self.light_picker.set_increments(1, 1) self.light_picker.set_tooltip_text("Pick light") self.light_picker_refresh() self.light_picker.connect('value_changed', self.light_picker_cb, None) self.toolbar.pack_start(self.light_picker, False, False) self.light_picker.show() button = gtk.Button() menu_image = gtk.image_new_from_stock(gtk.STOCK_PREFERENCES, gtk.ICON_SIZE_SMALL_TOOLBAR) menu_image.show() button.set_tooltip_text("Camera settings") button.connect('clicked', self.config_cb, None) button.add(menu_image) self.toolbar.pack_start(button, False, False) button.show() button = gtk.Button('Focus') button.set_tooltip_text("Focus camera automatically") button.connect('clicked', self.focus_cb, None) self.toolbar.pack_start(button, False, False) button.show() photo_image = gtk.image_new_from_file( os.path.join(source_dir, 'data', 'camera_24.png')) photo = gtk.Button() photo.set_image(photo_image) photo.set_tooltip_text("Take single photo") photo.connect('clicked', self.photo_cb, None) self.toolbar.pack_start(photo, False, False) photo.show() if self.dome_controls: photo = gtk.Button('RTI Preview') photo.set_tooltip_text("Take preview RTI image") photo.connect('clicked', self.rti_preview_cb, None) self.toolbar.pack_start(photo, False, False) photo.show() photo = gtk.Button('RTI Capture ...') photo.set_tooltip_text("Start full RTI acquisition") photo.connect('clicked', self.rti_capture_cb, None) self.toolbar.pack_start(photo, False, False) photo.show() self.info.msg('Welcome to RTI Acquire', 'v1.3, March 2014') self.show()
def createColorWidget(self): self.size_group = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL) frame = gtk.Frame('Color') frame.set_border_width(0) frame.set_size_request(200, 400) frame.show() vbox = gtk.VBox(False, 0) #----Line 1 Opacity --------------- hbox = gtk.HBox(False, 0) hbox.show() label = gtk.Label("Opacity:") label.show() hbox.pack_start(label, False, True, 0) adj_hscale = gtk.Adjustment(0, 0, 100, 1.0, 5.0, 0.0) hscale = gtk.HScale(adj_hscale) hscale.set_size_request(30, -1) hscale.set_value_pos(gtk.POS_RIGHT) hscale.set_draw_value(False) hscale.set_digits(1) hbox.pack_start(hscale, True, True, 0) hscale.show() #keep hscale to global value global_var.dialogWidget['colorOpacity_hscale'] = hscale adj_spin = gtk.Adjustment(0, 0, 100, 1.0, 5.0, 0.0) spinner = gtk.SpinButton(adj_spin, 0, 0) spinner.set_wrap(True) spinner.set_size_request(15, -1) spinner.show() global_var.dialogWidget[ 'colorOpacity_spinner'] = spinner #keep spinner to global value hbox.pack_start(spinner, True, True, 0) global cval # temp value of spinner and hscale item = None color = None adj_spin.connect("value_changed", self.change_alpha_level, spinner, hscale, item, "spinner", color) adj_hscale.connect("value_changed", self.change_alpha_level, spinner, hscale, item, "hscale", color) vbox.pack_start(hbox, False, True, 0) #-----Line 2 Item Color Button ----------- label_color = gtk.Label("Color : ") label_color.show() hbox = gtk.HBox(False, 0) hbox.pack_start(label_color, False, True, 0) hbox.show() #...Create color button colorbutton = gtk.ColorButton( gtk.gdk.color_parse('#CC3300')) # Display current fill color colorbutton.connect('color-set', self.color_set_cb) colorbutton.show() global_var.dialogWidget[ 'colorColor_button'] = colorbutton # keep color button to global value colorbutton.set_size_request(45, 45) hbox.pack_start(colorbutton, False, True, 0) vbox.pack_start(hbox, False, True, 0) #-----Line 3 Item Color Fill Option----------- label_Fill = gtk.Label("Fill : ") label_Fill.show() hbox = gtk.HBox(False, 0) hbox.pack_start(label_Fill, False, True, 0) hbox.show() options = ["None", "Solid", "RGBA", "Gradiant", "Pattern"] option_color = gtk.combo_box_new_text() for opt in options: option_color.append_text(opt) option_color.set_active(0) option_color.set_size_request(85, -1) option_color.show() option_color.connect('changed', self.combo_fill_mode) global_var.dialogWidget[ 'colorFill_option'] = option_color # keep fill color option to global value hbox.pack_start(option_color, False, True, 0) vbox.pack_start(hbox, False, True, 0) #vbox.pack_start(colorbutton,False,True,0) #label.show() frame.add(vbox) vbox.show() #------Line 4 gradiant option area----------- ''' expander = gtk.Expander("Gradiant :") # The Label for the expander label = gtk.Label("Details can be shown or hidden.") expander.add(label) #label_Gradiant = gtk.Label("Gradiant : ") expander.show() hbox = gtk.HBox(False,0) hbox.pack_start(expander,False,True,0) hbox.show() #expander.add(hbox) vbox.pack_start(hbox,False,True,0)''' hbox = gtk.HBox(False, 0) vbox_s = gtk.VBox(False, 0) #scrolled_win = gtk.ScrolledWindow () #scrolled_win.set_policy(gtk.POLICY_AUTOMATIC,gtk.POLICY_AUTOMATIC) #gtk.POLICY_NEVER #vbox_s.pack_start (scrolled_win, False, True, 0) vbox_s.show() #vbox.pack_start(vbox, False, True, 0) label_Gradiant = gtk.Label("Gradiant Show") label_Gradiant.show() label_Pattern = gtk.Label("Pattern Show ") label_Pattern.show() expander_g = gtk.Expander("Gradiant") expander_g.show() c_pre = self.preview_canvas() expander_g.add(c_pre) expander_p = gtk.Expander("Pattern") expander_p.show() expander_p.add(label_Pattern) #scrolled_win.add(expander_g) #scrolled_win.add(expander_p) #scrolled_win.show() #scrolled_win.add(expander_p) vbox_s.pack_start(expander_g, False, True, 0) vbox_s.pack_start(expander_p, False, True, 0) #vbox_s.set_border_width(0) hbox.pack_start(vbox_s, False, True, 0) hbox.show() vbox.pack_start(hbox, False, True, 0) self.size_group.add_widget(label) self.size_group.add_widget(label_color) self.size_group.add_widget(label_Fill) #self.size_group.add_widget(label_Gradiant) return frame
def init(self): # The user_id to work on self.current_user_id = 0 self.user_list = [] # --------------- # Log Management # --------------- # create tree model self.log_model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_INT, gobject.TYPE_INT, gobject.TYPE_INT, gobject.TYPE_STRING) # Main box is vertical top_box = gtk.VBox(False, 8) top_box.show() self.frame.add(top_box) # First line label and combo label_box = gtk.HBox(False, 8) label_box.show() top_box.pack_start(label_box, False, False, 0) # Let the user select the class to work on # # Grab the class list and put it in a combo class_box = gtk.HBox(False, 8) class_box.show() label_box.pack_start(class_box, False, False, 0) user_label = gtk.Label(_('Select a user:'******'SELECT DISTINCT user_id FROM logs') user_list = self.cur.fetchall() self.combo_user = gtk.combo_box_new_text() self.combo_user.show() # Insert the ALL option (HACK, use the user_id -2 to indicate ALL) self.combo_user.append_text(_("All users")) self.user_list.append(-2) for auser in user_list: if (auser[0] == -1 or not auser[0]): # This is the name of the Default user profile self.combo_user.append_text(_("Default")) self.user_list.append(-1) continue self.cur.execute( 'SELECT login, firstname, lastname FROM users WHERE user_id=?', (auser[0], )) oneuser = self.cur.fetchall() self.combo_user.append_text( (oneuser[0][0] + ' ' + oneuser[0][1] + ' ' + oneuser[0][2])) # Save in a list the combo index => the user_id self.user_list.append(auser[0]) self.combo_user.set_active(self.current_user_id) label_box.pack_end(self.combo_user, True, True, 0) # update the combobox self.combo_user.connect('changed', self.user_changed_cb) # Second line logs and button log_hbox = gtk.HBox(False, 8) log_hbox.show() top_box.add(log_hbox) loglist_box = gtk.VBox(False, 8) loglist_box.show() log_hbox.add(loglist_box) vbox_button = gtk.VBox(False, 8) vbox_button.show() log_hbox.add(vbox_button) # Create the table sw = gtk.ScrolledWindow() sw.show() sw.set_shadow_type(gtk.SHADOW_ETCHED_IN) sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) # create tree view treeview_log = gtk.TreeView(self.log_model) treeview_log.show() treeview_log.set_rules_hint(True) treeview_log.set_search_column(COLUMN_DATE) sw.add(treeview_log) loglist_box.pack_start(sw, True, True, 0) # add columns to the tree view self.__add_columns_log(treeview_log) # Reset buttons self.button_remove = gtk.Button(_('Reset')) self.button_remove.connect("clicked", self.on_remove_log_clicked, treeview_log) vbox_button.pack_start(self.button_remove, False, False, 0) self.button_remove.show() self.button_remove.set_sensitive(True) # Refresh buttons self.button_refresh = gtk.Button(stock='gtk-refresh') self.button_refresh.connect("clicked", self.on_refresh_log_clicked) vbox_button.pack_start(self.button_refresh, False, False, 0) self.button_refresh.show() self.button_refresh.set_sensitive(True) # Load lists self.user_changed_cb(self.combo_user) self.reload_log()
def __init__(self, parent_diag, lista, part_act): ''' Constructor ''' gtk.Table.__init__(self, 6, 6) self.lista = lista self.part_act = part_act self.parent_diag = parent_diag #Tipo de partición self.lbl1 = gtk.Label(_("Partition type:")) self.lbl1.set_alignment(0, 0.5) self.attach(self.lbl1, 0, 1, 0, 1) self.lbl1.show() self.cmb_tipo = gtk.combo_box_new_text() if is_logic(self.part_act): self.cmb_tipo.append_text(msj.particion.logica) self.cmb_tipo.set_sensitive(False) else: self.cmb_tipo.append_text(msj.particion.primaria) # Solo se permite una particion extendida en el disco if not has_extended(self.lista): self.cmb_tipo.append_text(msj.particion.extendida) self.cmb_tipo.set_active(0) self.attach(self.cmb_tipo, 1, 2, 0, 1) self.cmb_tipo.connect("changed", self.cmb_tipo_on_changed) self.cmb_tipo.show() #Sistema de Archivos self.lbl2 = gtk.Label(_("File system:")) self.lbl2.set_alignment(0, 0.5) self.attach(self.lbl2, 0, 1, 1, 2) self.lbl2.show() self.cmb_fs = gtk.combo_box_new_text() self.cmb_fs_fill() self.cmb_fs.connect("changed", self.cmb_fs_on_changed) self.attach(self.cmb_fs, 1, 2, 1, 2) self.cmb_fs.show() # Punto de Montaje self.lbl3 = gtk.Label(_("Mount point:")) self.lbl3.set_alignment(0, 0.5) self.lbl3.set_size_request(200, 30) self.attach(self.lbl3, 0, 1, 2, 3) self.lbl3.show() self.cmb_montaje = gtk.combo_box_new_text() self.cmb_montaje_fill() self.attach(self.cmb_montaje, 1, 2, 2, 3) self.cmb_montaje.connect("changed", self.cmb_montaje_on_changed) self.cmb_montaje.show() self.entrada = gtk.Entry() self.entrada.set_text('/') self.attach(self.entrada, 1, 2, 2, 3) self.entrada.connect("changed", self.validate_m_point) self.formatear = gtk.CheckButton(_("Format this partition")) self.attach(self.formatear, 1, 2, 3, 4) self.formatear.set_visible(is_usable(self.part_act)) self.formatear.connect("toggled", self.cmb_fs_on_changed) self.formatear.show() self.show()
def _launch_config_section_chooser_dialog(self, name_section_dict, prefs, dialog_title, config_title, section_title, null_section_choice=False): chooser_dialog = gtk.Dialog(title=dialog_title, parent=self.window, buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT)) config_label = gtk.Label(config_title) config_label.show() section_label = gtk.Label(section_title) section_label.show() config_name_box = gtk.combo_box_new_text() name_keys = name_section_dict.keys() name_keys.sort() for k, name in enumerate(name_keys): config_name_box.append_text(name) if name in prefs: config_name_box.set_active(k) if config_name_box.get_active() == -1: config_name_box.set_active(0) config_name_box.show() section_box = gtk.VBox() section_box.show() null_section_checkbutton = gtk.CheckButton( rose.config_editor.DIALOG_LABEL_NULL_SECTION) null_section_checkbutton.connect( "toggled", lambda b: section_box.set_sensitive(not b.get_active())) if null_section_choice: null_section_checkbutton.show() null_section_checkbutton.set_active(True) index = config_name_box.get_active() self._reload_section_choices(section_box, name_section_dict[name_keys[index]], prefs.get(name_keys[index], [])) config_name_box.connect( 'changed', lambda c: self._reload_section_choices( section_box, name_section_dict[name_keys[c.get_active()]], prefs.get(name_keys[c.get_active()], []))) vbox = gtk.VBox(spacing=rose.config_editor.SPACING_PAGE) vbox.pack_start(config_label, expand=False, fill=False) vbox.pack_start(config_name_box, expand=False, fill=False) vbox.pack_start(section_label, expand=False, fill=False) vbox.pack_start(null_section_checkbutton, expand=False, fill=False) vbox.pack_start(section_box, expand=False, fill=False) vbox.show() hbox = gtk.HBox() hbox.pack_start(vbox, expand=True, fill=True, padding=rose.config_editor.SPACING_PAGE) hbox.show() chooser_dialog.vbox.pack_start(hbox, padding=rose.config_editor.SPACING_PAGE) section_box.grab_focus() response = chooser_dialog.run() if response in [ gtk.RESPONSE_OK, gtk.RESPONSE_YES, gtk.RESPONSE_ACCEPT ]: config_name_entered = name_keys[config_name_box.get_active()] if null_section_checkbutton.get_active(): chooser_dialog.destroy() return config_name_entered, None for widget in section_box.get_children(): if hasattr(widget, 'get_active'): index = widget.get_active() sections = name_section_dict[config_name_entered] section_name = sections[index] chooser_dialog.destroy() return config_name_entered, section_name chooser_dialog.destroy() return None, None
def __init__( self, username=None, password=None, authlevel=None, levels_mapping=None, parent=None, ): if username: super(AccountDialog, self).__init__( _('Edit Account'), _('Edit existing account'), gtk.STOCK_DIALOG_INFO, ( gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_APPLY, gtk.RESPONSE_OK, ), parent, ) else: super(AccountDialog, self).__init__( _('New Account'), _('Create a new account'), gtk.STOCK_DIALOG_INFO, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_ADD, gtk.RESPONSE_OK), parent, ) self.levels_mapping = levels_mapping table = gtk.Table(2, 3, False) self.username_label = gtk.Label() self.username_label.set_markup('<b>' + _('Username:'******'</b>') self.username_label.set_alignment(1.0, 0.5) self.username_label.set_padding(5, 5) self.username_entry = gtk.Entry() table.attach(self.username_label, 0, 1, 0, 1) table.attach(self.username_entry, 1, 2, 0, 1) self.authlevel_label = gtk.Label() self.authlevel_label.set_markup('<b>' + _('Authentication Level:') + '</b>') self.authlevel_label.set_alignment(1.0, 0.5) self.authlevel_label.set_padding(5, 5) # combo_box_new_text is deprecated but no other pygtk alternative. self.authlevel_combo = gtk.combo_box_new_text() active_idx = None for idx, level in enumerate(levels_mapping): self.authlevel_combo.append_text(level) if authlevel and authlevel == level: active_idx = idx elif not authlevel and level == 'DEFAULT': active_idx = idx if active_idx is not None: self.authlevel_combo.set_active(active_idx) table.attach(self.authlevel_label, 0, 1, 1, 2) table.attach(self.authlevel_combo, 1, 2, 1, 2) self.password_label = gtk.Label() self.password_label.set_markup('<b>' + _('Password:'******'</b>') self.password_label.set_alignment(1.0, 0.5) self.password_label.set_padding(5, 5) self.password_entry = gtk.Entry() self.password_entry.set_visibility(False) table.attach(self.password_label, 0, 1, 2, 3) table.attach(self.password_entry, 1, 2, 2, 3) self.vbox.pack_start(table, False, False, padding=5) if username: self.username_entry.set_text(username) self.username_entry.set_editable(False) else: self.set_focus(self.username_entry) if password: self.password_entry.set_text(username) self.show_all()