def make_preferences_dialog(self): # TODO: switch to something declarative or at least clean-up the following mess self.prefs = prefs = gtk.Dialog(APP_NAME, None, gtk.DIALOG_DESTROY_WITH_PARENT, (gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)) prefs.connect("response", self.on_preferences_changed) prefs.connect("delete-event", self.on_preferences_changed) def on_sb_time_changed(widget, data=None): self.options.timeout = widget.get_value() self.logger.debug("Timeout value changed: %f." % self.options.timeout) def on_cbox_sizes_changed(widget, data=None): index = widget.get_active() self.options.font_size = FONT_SIZES.keys()[index] self.update_geometry() self.logger.debug("Window size changed: %s." % self.options.font_size) def on_cbox_modes_changed(widget, data=None): index = widget.get_active() self.options.key_mode = KEY_MODES.keys()[index] self.on_change_mode() self.logger.debug("Key mode changed: %s." % self.options.key_mode) def on_cbox_bak_changed(widget, data=None): index = widget.get_active() self.options.bak_mode = BAK_MODES.keys()[index] self.on_change_mode() self.logger.debug("Bak mode changed: %s." % self.options.bak_mode) def on_cbox_mods_changed(widget, data=None): index = widget.get_active() self.options.mods_mode = MODS_MODES.keys()[index] self.on_change_mode() self.logger.debug("Mods mode changed: %s." % self.options.mods_mode) def on_cbox_modsonly_changed(widget, data=None): self.options.mods_only = widget.get_active() self.on_change_mode() self.logger.debug("Modifiers only changed: %s." % self.options.mods_only) def on_cbox_visshift_changed(widget, data=None): self.options.vis_shift = widget.get_active() self.on_change_mode() self.logger.debug("Visible Shift changed: %s." % self.options.vis_shift) def on_cbox_visspace_changed(widget, data=None): self.options.vis_space = widget.get_active() self.on_change_mode() self.logger.debug("Show Whitespace changed: %s." % self.options.vis_space) def on_cbox_position_changed(widget, data=None): index = widget.get_active() new_position = POSITIONS.keys()[index] if new_position == 'fixed': new_geom = on_btn_sel_geom(widget) if not new_geom: self.cbox_positions.set_active(POSITIONS.keys().index( self.options.position)) return elif self.options.position == 'fixed': # automatically clear geometry self.options.geometry = None self.options.position = new_position self.update_geometry() self.logger.debug("Window position changed: %s." % self.options.position) def on_cbox_screen_changed(widget, data=None): self.options.screen = widget.get_active() self.set_active_monitor(self.options.screen) self.logger.debug("Screen changed: %d." % self.options.screen) def on_cbox_persist_changed(widget, data=None): self.options.persist = widget.get_active() if not self.get_property('visible'): self.show() else: self.on_label_change(self.label.get_text()) self.logger.debug("Persistent changed: %s." % self.options.persist) def on_sb_compr_changed(widget, data=None): self.options.compr_cnt = widget.get_value_as_int() self.on_change_mode() self.logger.debug("Compress repeats value changed: %d." % self.options.compr_cnt) def on_cbox_compr_changed(widget, data=None): compr_enabled = widget.get_active() self.sb_compr.set_sensitive(compr_enabled) self.options.compr_cnt = self.sb_compr.get_value_as_int( ) if compr_enabled else 0 self.on_change_mode() self.logger.debug("Compress repeats value changed: %d." % self.options.compr_cnt) def on_btn_sel_geom(widget, data=None): try: ret = subprocess.check_output(['slop', '-f', '%x %y %w %h']) except subprocess.CalledProcessError: return False except OSError: msg = gtk.MessageDialog( parent=self, type=gtk.MESSAGE_ERROR, buttons=gtk.BUTTONS_OK, message_format="Error running \"slop\"") msg.format_secondary_markup( "\"slop\" is required for interactive selection. " "See <a href=\"https://github.com/naelstrof/slop\">" "https://github.com/naelstrof/slop</a>") msg.run() msg.destroy() return False self.options.geometry = map(int, ret.split(' ')) self.update_geometry() self.btn_reset_geom.set_sensitive(True) return True def on_btn_reset_geom(widget, data=None): self.options.geometry = None if self.options.position == 'fixed': self.options.position = 'bottom' self.cbox_positions.set_active(POSITIONS.keys().index( self.options.position)) self.update_geometry() widget.set_sensitive(False) def on_adj_opacity_changed(widget, data=None): self.options.opacity = widget.get_value() self.update_colors() def on_font_color_changed(widget, data=None): self.options.font_color = widget.get_color().to_string() self.update_colors() def on_bg_color_changed(widget, data=None): self.options.bg_color = widget.get_color().to_string() self.update_colors() def on_btn_font(widget, data=None): self.options.font_desc = widget.get_font_name() self.font = pango.FontDescription(self.options.font_desc) self.update_label() frm_main = gtk.Frame(_("Preferences")) frm_main.set_border_width(6) frm_time = gtk.Frame("<b>%s</b>" % _("Time")) frm_time.set_border_width(4) frm_time.get_label_widget().set_use_markup(True) frm_time.set_shadow_type(gtk.SHADOW_NONE) vbox_time = gtk.VBox(spacing=6) hbox_time = gtk.HBox() lbl_time1 = gtk.Label(_("Display for")) lbl_time2 = gtk.Label(_("seconds")) sb_time = gtk.SpinButton(digits=1) sb_time.set_increments(0.5, 1.0) sb_time.set_range(0.5, 10.0) sb_time.set_numeric(True) sb_time.set_update_policy(gtk.UPDATE_IF_VALID) sb_time.set_value(self.options.timeout) sb_time.connect("value-changed", on_sb_time_changed) hbox_time.pack_start(lbl_time1, expand=False, fill=False, padding=6) hbox_time.pack_start(sb_time, expand=False, fill=False, padding=4) hbox_time.pack_start(lbl_time2, expand=False, fill=False, padding=4) vbox_time.pack_start(hbox_time) chk_persist = gtk.CheckButton(_("Persistent window")) chk_persist.connect("toggled", on_cbox_persist_changed) chk_persist.set_active(self.options.persist) vbox_time.pack_start(chk_persist) frm_time.add(vbox_time) frm_time.show_all() frm_position = gtk.Frame("<b>%s</b>" % _("Position")) frm_position.set_border_width(4) frm_position.get_label_widget().set_use_markup(True) frm_position.set_shadow_type(gtk.SHADOW_NONE) vbox_position = gtk.VBox(spacing=6) lbl_screen = gtk.Label(_("Screen")) cbox_screen = gtk.combo_box_new_text() scr = self.get_screen() for n in range(scr.get_n_monitors()): cbox_screen.insert_text( n, '%d: %s' % (n, scr.get_monitor_plug_name(n))) cbox_screen.set_active(self.monitor) cbox_screen.connect("changed", on_cbox_screen_changed) hbox0_position = gtk.HBox() hbox0_position.pack_start(lbl_screen, expand=False, fill=False, padding=6) hbox0_position.pack_start(cbox_screen, expand=False, fill=False, padding=4) vbox_position.pack_start(hbox0_position) lbl_positions = gtk.Label(_("Position")) self.cbox_positions = cbox_positions = gtk.combo_box_new_text() cbox_positions.set_name('position') for key, value in enumerate(POSITIONS): cbox_positions.insert_text(key, value) cbox_positions.set_active(POSITIONS.keys().index( self.options.position)) cbox_positions.connect("changed", on_cbox_position_changed) self.btn_reset_geom = btn_reset_geom = gtk.Button(_("Reset")) btn_reset_geom.connect("clicked", on_btn_reset_geom) btn_reset_geom.set_sensitive(self.options.geometry is not None) hbox1_position = gtk.HBox() hbox1_position.pack_start(lbl_positions, expand=False, fill=False, padding=6) hbox1_position.pack_start(cbox_positions, expand=False, fill=False, padding=4) hbox1_position.pack_start(btn_reset_geom, expand=False, fill=False, padding=4) vbox_position.pack_start(hbox1_position) btn_sel_geom = gtk.Button(_("Select window/region")) btn_sel_geom.connect("clicked", on_btn_sel_geom) vbox_position.pack_start(btn_sel_geom) frm_aspect = gtk.Frame("<b>%s</b>" % _("Aspect")) frm_aspect.set_border_width(4) frm_aspect.get_label_widget().set_use_markup(True) frm_aspect.set_shadow_type(gtk.SHADOW_NONE) vbox_aspect = gtk.VBox(spacing=6) frm_position.add(vbox_position) hbox0_font = gtk.HBox() lbl_font = gtk.Label(_("Font")) btn_font = gtk.FontButton(self.options.font_desc) btn_font.set_use_size(False) btn_font.set_show_size(False) btn_font.connect("font-set", on_btn_font) hbox0_font.pack_start(lbl_font, expand=False, fill=False, padding=6) hbox0_font.pack_start(btn_font, expand=False, fill=False, padding=4) hbox2_aspect = gtk.HBox() lbl_sizes = gtk.Label(_("Size")) cbox_sizes = gtk.combo_box_new_text() cbox_sizes.set_name('size') for key, value in enumerate(FONT_SIZES): cbox_sizes.insert_text(key, value) cbox_sizes.set_active(FONT_SIZES.keys().index(self.options.font_size)) cbox_sizes.connect("changed", on_cbox_sizes_changed) hbox2_aspect.pack_start(lbl_sizes, expand=False, fill=False, padding=6) hbox2_aspect.pack_start(cbox_sizes, expand=False, fill=False, padding=4) hbox3_font_color = gtk.HBox() lbl_font_color = gtk.Label(_("Font color")) btn_font_color = gtk.ColorButton( color=gtk.gdk.color_parse(self.options.font_color)) btn_font_color.connect("color-set", on_font_color_changed) btn_bg_color = gtk.ColorButton( color=gtk.gdk.color_parse(self.options.bg_color)) btn_bg_color.connect("color-set", on_bg_color_changed) hbox3_font_color.pack_start(lbl_font_color, expand=False, fill=False, padding=6) hbox3_font_color.pack_start(btn_font_color, expand=False, fill=False, padding=4) hbox3_font_color.pack_start(btn_bg_color, expand=False, fill=False, padding=4) hbox4_aspect = gtk.HBox() lbl_opacity = gtk.Label(_("Opacity")) adj_opacity = gtk.Adjustment(self.options.opacity, 0.1, 1.0, 0.1, 0, 0) adj_opacity.connect("value-changed", on_adj_opacity_changed) adj_scale = gtk.HScale(adj_opacity) hbox4_aspect.pack_start(lbl_opacity, expand=False, fill=False, padding=6) hbox4_aspect.pack_start(adj_scale, expand=True, fill=True, padding=4) vbox_aspect.pack_start(hbox0_font) vbox_aspect.pack_start(hbox2_aspect) vbox_aspect.pack_start(hbox3_font_color) vbox_aspect.pack_start(hbox4_aspect) frm_aspect.add(vbox_aspect) frm_kbd = gtk.Frame("<b>%s</b>" % _("Keys")) frm_kbd.set_border_width(4) frm_kbd.get_label_widget().set_use_markup(True) frm_kbd.set_shadow_type(gtk.SHADOW_NONE) vbox_kbd = gtk.VBox(spacing=6) hbox_kbd = gtk.HBox() lbl_kbd = gtk.Label(_("Keyboard mode")) cbox_modes = gtk.combo_box_new_text() cbox_modes.set_name('mode') for key, value in enumerate(KEY_MODES): cbox_modes.insert_text(key, value) cbox_modes.set_active(KEY_MODES.keys().index(self.options.key_mode)) cbox_modes.connect("changed", on_cbox_modes_changed) hbox_kbd.pack_start(lbl_kbd, expand=False, fill=False, padding=6) hbox_kbd.pack_start(cbox_modes, expand=False, fill=False, padding=4) vbox_kbd.pack_start(hbox_kbd) hbox_kbd = gtk.HBox() lbl_kbd = gtk.Label(_("Backspace mode")) cbox_modes = gtk.combo_box_new_text() for key, value in enumerate(BAK_MODES): cbox_modes.insert_text(key, value) cbox_modes.set_active(BAK_MODES.keys().index(self.options.bak_mode)) cbox_modes.connect("changed", on_cbox_bak_changed) hbox_kbd.pack_start(lbl_kbd, expand=False, fill=False, padding=6) hbox_kbd.pack_start(cbox_modes, expand=False, fill=False, padding=4) vbox_kbd.pack_start(hbox_kbd) hbox_kbd = gtk.HBox() lbl_kbd = gtk.Label(_("Modifiers mode")) cbox_modes = gtk.combo_box_new_text() for key, value in enumerate(MODS_MODES): cbox_modes.insert_text(key, value) cbox_modes.set_active(MODS_MODES.keys().index(self.options.mods_mode)) cbox_modes.connect("changed", on_cbox_mods_changed) hbox_kbd.pack_start(lbl_kbd, expand=False, fill=False, padding=6) hbox_kbd.pack_start(cbox_modes, expand=False, fill=False, padding=4) vbox_kbd.pack_start(hbox_kbd) chk_kbd = gtk.CheckButton(_("Show Modifier sequences only")) chk_kbd.connect("toggled", on_cbox_modsonly_changed) chk_kbd.set_active(self.options.mods_only) vbox_kbd.pack_start(chk_kbd) chk_kbd = gtk.CheckButton(_("Always show Shift")) chk_kbd.connect("toggled", on_cbox_visshift_changed) chk_kbd.set_active(self.options.vis_shift) vbox_kbd.pack_start(chk_kbd) chk_vspace = gtk.CheckButton(_("Show Whitespace characters")) chk_vspace.connect("toggled", on_cbox_visspace_changed) chk_vspace.set_active(self.options.vis_space) vbox_kbd.pack_start(chk_vspace) hbox_compr = gtk.HBox() chk_compr = gtk.CheckButton(_("Compress repeats after")) chk_compr.set_active(self.options.compr_cnt > 0) chk_compr.connect("toggled", on_cbox_compr_changed) self.sb_compr = sb_compr = gtk.SpinButton(digits=0) sb_compr.set_increments(1, 1) sb_compr.set_range(1, 100) sb_compr.set_numeric(True) sb_compr.set_update_policy(gtk.UPDATE_IF_VALID) sb_compr.set_value(self.options.compr_cnt or 3) sb_compr.connect("value-changed", on_sb_compr_changed) hbox_compr.pack_start(chk_compr, expand=False, fill=False) hbox_compr.pack_start(sb_compr, expand=False, fill=False, padding=4) vbox_kbd.pack_start(hbox_compr) frm_kbd.add(vbox_kbd) hbox_main = gtk.HBox() vbox_main = gtk.VBox() vbox_main.pack_start(frm_time, False, False, 6) vbox_main.pack_start(frm_position, False, False, 6) vbox_main.pack_start(frm_aspect, False, False, 6) hbox_main.pack_start(vbox_main) vbox_main = gtk.VBox() vbox_main.pack_start(frm_kbd, False, False, 6) hbox_main.pack_start(vbox_main) frm_main.add(hbox_main) prefs.vbox.pack_start(frm_main) prefs.set_destroy_with_parent(True) prefs.set_resizable(False) prefs.set_has_separator(False) prefs.set_default_response(gtk.RESPONSE_CLOSE) prefs.vbox.show_all()
def __init__(self, window): self._window = window gtk.Dialog.__init__(self, _('Preferences'), window, 0, (gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)) self.connect('response', self._response) self.set_has_separator(False) self.set_resizable(True) self.set_default_response(gtk.RESPONSE_CLOSE) notebook = gtk.Notebook() self.vbox.pack_start(notebook) self.set_border_width(4) notebook.set_border_width(6) # ---------------------------------------------------------------- # The "Appearance" tab. # ---------------------------------------------------------------- page = _PreferencePage(80) page.new_section(_('Background')) fixed_bg_button = gtk.RadioButton(None, '%s:' % _('Use this colour as background')) fixed_bg_button.set_tooltip_text( _('Always use this selected colour as the background colour.')) color_button = gtk.ColorButton(gtk.gdk.Color(*prefs['bg colour'])) color_button.connect('color_set', self._color_button_cb) page.add_row(fixed_bg_button, color_button) dynamic_bg_button = gtk.RadioButton(fixed_bg_button, _('Use dynamic background colour.')) dynamic_bg_button.set_active(prefs['smart bg']) dynamic_bg_button.connect('toggled', self._check_button_cb, 'smart bg') dynamic_bg_button.set_tooltip_text( _('Automatically pick a background colour that fits the viewed image.')) page.add_row(dynamic_bg_button) page.new_section(_('Thumbnails')) label = gtk.Label('%s:' % _('Thumbnail size (in pixels)')) adjustment = gtk.Adjustment(prefs['thumbnail size'], 20, 128, 1, 10) thumb_size_spinner = gtk.SpinButton(adjustment) thumb_size_spinner.connect('value_changed', self._spinner_cb, 'thumbnail size') page.add_row(label, thumb_size_spinner) thumb_number_button = gtk.CheckButton( _('Show page numbers on thumbnails.')) thumb_number_button.set_active( prefs['show page numbers on thumbnails']) thumb_number_button.connect('toggled', self._check_button_cb, 'show page numbers on thumbnails') page.add_row(thumb_number_button) page.new_section(_('Magnifying Glass')) label = gtk.Label('%s:' % _('Magnifying glass size (in pixels)')) adjustment = gtk.Adjustment(prefs['lens size'], 50, 400, 1, 10) glass_size_spinner = gtk.SpinButton(adjustment) glass_size_spinner.connect('value_changed', self._spinner_cb, 'lens size') glass_size_spinner.set_tooltip_text( _('Set the size of the magnifying glass. It is a square with a side of this many pixels.')) page.add_row(label, glass_size_spinner) label = gtk.Label('%s:' % _('Magnification factor')) adjustment = gtk.Adjustment(prefs['lens magnification'], 1.1, 10.0, 0.1, 1.0) glass_magnification_spinner = gtk.SpinButton(adjustment, digits=1) glass_magnification_spinner.connect('value_changed', self._spinner_cb, 'lens magnification') glass_magnification_spinner.set_tooltip_text( _('Set the magnification factor of the magnifying glass.')) page.add_row(label, glass_magnification_spinner) page.new_section(_('Image scaling')) stretch_button = gtk.CheckButton(_('Stretch small images.')) stretch_button.set_active(prefs['stretch']) stretch_button.connect('toggled', self._check_button_cb, 'stretch') stretch_button.set_tooltip_text( _('Stretch images to a size that is larger than their original size if the current zoom mode requests it. If this preference is unset, images are never scaled to be larger than their original size.')) page.add_row(stretch_button) page.new_section(_('Transparency')) checkered_bg_button = gtk.CheckButton( _('Use checkered background for transparent images.')) checkered_bg_button.set_active( prefs['checkered bg for transparent images']) checkered_bg_button.connect('toggled', self._check_button_cb, 'checkered bg for transparent images') checkered_bg_button.set_tooltip_text( _('Use a grey checkered background for transparent images. If this preference is unset, the background is plain white instead.')) page.add_row(checkered_bg_button) notebook.append_page(page, gtk.Label(_('Appearance'))) # ---------------------------------------------------------------- # The "Behaviour" tab. # ---------------------------------------------------------------- page = _PreferencePage(150) page.new_section(_('Scroll')) smart_space_button = gtk.CheckButton( _('Use smart space key scrolling.')) smart_space_button.set_active(prefs['smart space scroll']) smart_space_button.connect('toggled', self._check_button_cb, 'smart space scroll') smart_space_button.set_tooltip_text( _('Use smart scrolling with the space key. Normally the space key scrolls only right down (or up when shift is pressed), but with this preference set it also scrolls sideways and so tries to follow the natural reading order of the comic book.')) page.add_row(smart_space_button) flip_with_wheel_button = gtk.CheckButton( _('Flip pages when scrolling off the edges of the page.')) flip_with_wheel_button.set_active(prefs['flip with wheel']) flip_with_wheel_button.connect('toggled', self._check_button_cb, 'flip with wheel') flip_with_wheel_button.set_tooltip_text( _('Flip pages when scrolling "off the page" with the scroll wheel or with the arrow keys. It takes three consecutive "steps" with the scroll wheel or the arrow keys for the pages to be flipped.')) page.add_row(flip_with_wheel_button) page.new_section(_('Double page mode')) step_length_button = gtk.CheckButton( _('Flip two pages in double page mode.')) step_length_button.set_active(prefs['double step in double page mode']) step_length_button.connect('toggled', self._check_button_cb, 'double step in double page mode') step_length_button.set_tooltip_text( _('Flip two pages, instead of one, each time we flip pages in double page mode.')) page.add_row(step_length_button) virtual_double_button = gtk.CheckButton( _('Show only one wide image in double page mode.')) virtual_double_button.set_active( prefs['no double page for wide images']) virtual_double_button.connect('toggled', self._check_button_cb, 'no double page for wide images') virtual_double_button.set_tooltip_text( _("Display only one image in double page mode, if the image's width exceeds its height. The result of this is that scans that span two pages are displayed properly (i.e. alone) also in double page mode.")) page.add_row(virtual_double_button) page.new_section(_('Files')) auto_open_next_button = gtk.CheckButton( _('Automatically open the next archive.')) auto_open_next_button.set_active(prefs['auto open next archive']) auto_open_next_button.connect('toggled', self._check_button_cb, 'auto open next archive') auto_open_next_button.set_tooltip_text( _('Automatically open the next archive in the directory when flipping past the last page, or the previous archive when flipping past the first page.')) page.add_row(auto_open_next_button) auto_open_last_button = gtk.CheckButton( _('Automatically open the last viewed file on startup.')) auto_open_last_button.set_active(prefs['auto load last file']) auto_open_last_button.connect('toggled', self._check_button_cb, 'auto load last file') auto_open_last_button.set_tooltip_text( _('Automatically open, on startup, the file that was open when Comix was last closed.')) page.add_row(auto_open_last_button) store_recent_button = gtk.CheckButton( _('Store information about recently opened files.')) store_recent_button.set_active(prefs['store recent file info']) store_recent_button.connect('toggled', self._check_button_cb, 'store recent file info') store_recent_button.set_tooltip_text( _('Add information about all files opened from within Comix to the shared recent files list.')) page.add_row(store_recent_button) create_thumbs_button = gtk.CheckButton( _('Store thumbnails for opened files.')) create_thumbs_button.set_active(prefs['create thumbnails']) create_thumbs_button.connect('toggled', self._check_button_cb, 'create thumbnails') create_thumbs_button.set_tooltip_text( _('Store thumbnails for opened files according to the freedesktop.org specification. These thumbnails are shared by many other applications, such as most file managers.')) page.add_row(create_thumbs_button) page.new_section(_('Cache')) cache_button = gtk.CheckButton(_('Use a cache to speed up browsing.')) cache_button.set_active(prefs['cache']) cache_button.connect('toggled', self._check_button_cb, 'cache') cache_button.set_tooltip_text( _('Cache the images that are next to the currently viewed image in order to speed up browsing. Since the speed improvements are quite big, it is recommended that you have this preference set, unless you are running short on free RAM.')) page.add_row(cache_button) page.new_section(_('Image Animation')) gif_button = gtk.CheckButton(_('Play GIF image animations.')) gif_button.set_active(prefs['animate gifs']) gif_button.connect('toggled', self._check_button_cb, 'animate gifs') gif_button.set_tooltip_text( # TODO: Change if PixbufAnimation gets resizing _('Play animations for GIF files, if there is one. If this is set, animated GIF images will not be resized.')) page.add_row(gif_button) notebook.append_page(page, gtk.Label(_('Behaviour'))) # ---------------------------------------------------------------- # The "Display" tab. # ---------------------------------------------------------------- page = _PreferencePage(180) page.new_section(_('Default modes')) double_page_button = gtk.CheckButton( _('Use double page mode by default.')) double_page_button.set_active(prefs['default double page']) double_page_button.connect('toggled', self._check_button_cb, 'default double page') page.add_row(double_page_button) fullscreen_button = gtk.CheckButton(_('Use fullscreen by default.')) fullscreen_button.set_active(prefs['default fullscreen']) fullscreen_button.connect('toggled', self._check_button_cb, 'default fullscreen') page.add_row(fullscreen_button) manga_button = gtk.CheckButton(_('Use manga mode by default.')) manga_button.set_active(prefs['default manga mode']) manga_button.connect('toggled', self._check_button_cb, 'default manga mode') page.add_row(manga_button) label = gtk.Label('%s:' % _('Default zoom mode')) zoom_combo = gtk.combo_box_new_text() zoom_combo.append_text(_('Best fit mode')) zoom_combo.append_text(_('Fit width mode')) zoom_combo.append_text(_('Fit height mode')) zoom_combo.append_text(_('Manual zoom mode')) # Change this if the combobox entries are reordered. zoom_combo.set_active(prefs['default zoom mode']) zoom_combo.connect('changed', self._combo_box_cb) page.add_row(label, zoom_combo) page.new_section(_('Fullscreen')) hide_in_fullscreen_button = gtk.CheckButton( _('Automatically hide all toolbars in fullscreen.')) hide_in_fullscreen_button.set_active(prefs['hide all in fullscreen']) hide_in_fullscreen_button.connect('toggled', self._check_button_cb, 'hide all in fullscreen') page.add_row(hide_in_fullscreen_button) page.new_section(_('Slideshow')) label = gtk.Label('%s:' % _('Slideshow delay (in seconds)')) adjustment = gtk.Adjustment(prefs['slideshow delay'] / 1000.0, 0.5, 3600.0, 0.1, 1) delay_spinner = gtk.SpinButton(adjustment, digits=1) delay_spinner.connect('value_changed', self._spinner_cb, 'slideshow delay') page.add_row(label, delay_spinner) page.new_section(_('Comments')) label = gtk.Label('%s:' % _('Comment extensions')) extensions_entry = gtk.Entry() extensions_entry.set_text(', '.join(prefs['comment extensions'])) extensions_entry.connect('activate', self._entry_cb) extensions_entry.connect('focus_out_event', self._entry_cb) extensions_entry.set_tooltip_text( _('Treat all files found within archives, that have one of these file endings, as comments.')) page.add_row(label, extensions_entry) page.new_section(_('Rotation')) auto_rotate_button = gtk.CheckButton( _('Automatically rotate images according to their metadata.')) auto_rotate_button.set_active(prefs['auto rotate from exif']) auto_rotate_button.connect('toggled', self._check_button_cb, 'auto rotate from exif') auto_rotate_button.set_tooltip_text( _('Automatically rotate images when an orientation is specified in the image metadata, such as in an Exif tag.')) page.add_row(auto_rotate_button) notebook.append_page(page, gtk.Label(_('Display'))) self.show_all()
def add_widget(self, widget): widget_type = type(widget) # print widget_type if (widget_type == Button or isinstance(widget, Button)): widget.instance = gtk.Button(widget.text) widget.instance.set_size_request(widget.width, widget.height) self.fixed.put(widget.instance, widget.position_X, widget.position_Y) widget.instance.show() if (widget.callbackMethod != None): widget.instance.connect('clicked', widget.callbackMethod) elif (widget_type == TextBox or isinstance(widget, TextBox)): widget.instance = gtk.TextView(widget.buffer) widget.instance.set_size_request(widget.width, widget.height) self.fixed.put(widget.instance, widget.position_X, widget.position_Y) widget.instance.show() elif (widget_type == CheckBox or isinstance(widget, CheckBox)): widget.instance = gtk.CheckButton(widget.title) widget.instance.set_size_request(widget.width, widget.height) self.fixed.put(widget.instance, widget.position_X, widget.position_Y) widget.instance.show() widget.instance.set_active(widget.value) elif (widget_type == RadioButtons or isinstance(widget, RadioButtons)): widget.instance = [] radio_instance = gtk.RadioButton(None, widget.labels[0]) radio_instance.set_size_request(widget.width, widget.height) self.fixed.put(radio_instance, widget.position_X[0], widget.position_Y[0]) radio_instance.show() widget.instance.append(radio_instance) for i in range(1, len(widget.labels)): radio_instance = gtk.RadioButton(widget.instance[0], widget.labels[i]) radio_instance.set_size_request(widget.width, widget.height) self.fixed.put(radio_instance, widget.position_X[i], widget.position_Y[i]) radio_instance.show() widget.instance.append(radio_instance) if (widget.selected_pos != None): widget.instance[widget.selected_pos].set_active(True) elif (widget_type == LabelText or isinstance(widget, LabelText)): widget.instance = gtk.Label(widget.text) widget.instance.set_size_request(widget.width, widget.height) self.fixed.put(widget.instance, widget.position_X, widget.position_Y) widget.instance.show() elif (widget_type == TextField or isinstance(widget, TextField)): widget.instance = gtk.Entry() widget.instance.set_size_request(widget.width, widget.height) self.fixed.put(widget.instance, widget.position_X, widget.position_Y) widget.instance.set_text(widget.title) widget.instance.show() elif (widget_type == TextFieldPass or isinstance(widget, TextField)): widget.instance = gtk.Entry() widget.instance.set_visibility(False) widget.instance.set_size_request(widget.width, widget.height) self.fixed.put(widget.instance, widget.position_X, widget.position_Y) widget.instance.set_text(widget.title) widget.instance.show() elif (widget_type == ValueList or isinstance(widget, ValueList)): widget.instance = gtk.OptionMenu() widget.instance.set_size_request(widget.width, widget.height) menu = gtk.Menu() for name in widget.choices: item = gtk.MenuItem(name) item.show() menu.append(item) #print "gis" widget.instance.set_menu(menu) widget.instance.show() self.fixed.put(widget.instance, widget.position_X, widget.position_Y) elif (widget_type == "Slider" or isinstance(widget, Slider)): ''' frame = self.abs_frame(widget) widget.instance = gtk.HScale(frame, from_=widget.start, to=widget.end , orient=root.HORIZONTAL) widget.instance.pack(fill=root.BOTH, expand=1) ''' adj1 = gtk.Adjustment(0.0, widget.start, widget.end, 0.1, 1.0, 1.0) widget.instance = gtk.HScale(adj1) widget.instance.set_size_request(widget.width, widget.height) self.fixed.put(widget.instance, widget.position_X, widget.position_Y) widget.instance.show() elif (widget_type == "SpinBox" or isinstance(widget, SpinBox)): ''' frame = self.abs_frame(widget) widget.instance = root.Spinbox(frame, from_=widget.start, to=widget.end ) widget.instance.pack(fill=root.BOTH, expand=1) ''' #adj = gtk.Adjustment(0, widget.start, widget.end, 1.0, 1.0, 0.0) adj = gtk.Adjustment(0.0, widget.start, widget.end, 0.1, 0.1, 0.0) widget.instance = gtk.SpinButton(adj, 0.1, 1) widget.instance.set_size_request(widget.width, widget.height) self.fixed.put(widget.instance, widget.position_X, widget.position_Y) widget.instance.show()
def get_property_pages(self, files): self.files = filter(lambda f: f.get_uri_scheme() == 'file' and not f.is_directory() and f.get_mime_type() in SUPPORTED_FORMATS, files) if len(self.files) == 0: return # TODO: Support multiple files (is this even feasible?) mime_type = self.files[0].get_mime_type() filename = os.path.normpath( urllib.unquote( '://'.join(self.files[0].get_uri().split('://')[1:]) ) ) if not os.access(filename, os.R_OK): return self.alignment = gtk.Alignment(xalign=0.0, yalign=0.0, xscale=1.0, yscale=1.0) self.alignment.set_padding(0, 0, 6, 6) self.table = gtk.Table(rows=2, columns=2, homogeneous=False) self.alignment.add(self.table) if mime_type in LINK_FORMATS: #try: link_object = wine.binary.windows_link(filename) #except: # print("Couln't load shell link: ", filename) # return self.property_label = gtk.Label(_('Link info')) prefix = False row_nr = 0 if 'location' in link_object: label = gtk.Label(_("Target:"+' ')) label.set_alignment(0.0, 0.0) #try: if link_object['location'] == 'network': text = _("A network location") else: text = unicode(link_object['location']) try: prefix = wine.prefixes.get_prefixpath_from_filepath(filename) wine.prefixes.use(prefix) text = '{0}\n<small>({1})</small>'.format( text, wine.util.wintounix(text) ) except: pass label_target = gtk.Label() label_target.set_markup(text) label_target.set_selectable(True) label_target.set_alignment(0.0, 0.0) self.table.attach(label, 0,1, row_nr,row_nr+1, gtk.FILL,gtk.FILL, 6,6) self.table.attach(label_target, 1,2, row_nr,row_nr+1, gtk.FILL,0, 6,6) row_nr += 1 #except: # pass if 'work dir' in link_object: label = gtk.Label(_("Execute in:"+' ')) label.set_alignment(0.0, 0.0) try: text = unicode(link_object['work dir']) try: if prefix is False: prefix = wine.prefixes.get_prefixpath_from_filepath(filename) wine.prefixes.use(prefix) text = '{0}\n<small>({1})</small>'.format( text, wine.util.wintounix(text) ) except: pass label_dir = gtk.Label() label_dir.set_markup(text) label_dir.set_selectable(True) label_dir.set_alignment(0.0, 0.0) self.table.attach(label, 0,1, row_nr,row_nr+1, gtk.FILL,gtk.FILL, 6,6) self.table.attach(label_dir, 1,2, row_nr,row_nr+1, gtk.FILL,0, 6,6) row_nr += 1 except: pass if 'arguments' in link_object: label = gtk.Label(_("Arguments:"+' ')) label.set_alignment(0.0, 0.5) try: label_args = gtk.Label(link_object['arguments']) label_args.set_selectable(True) label_args.set_alignment(0.0, 0.5) self.table.attach(label, 0,1, row_nr,row_nr+1, gtk.FILL,0, 6,6) self.table.attach(label_args, 1,2, row_nr,row_nr+1, gtk.FILL,0, 6,6) row_nr += 1 except: pass if 'show window as' in link_object: label = gtk.Label(_("Opens in a:"+' ')) label.set_alignment(0.0, 0.5) try: text = str(link_object['show window as']) if text == 'normal': text = _("Normal window") elif text == 'maximized': text = _("Maximised window") elif text == 'minimized': text = _("Minimised window") label_window = gtk.Label(text) label_window.set_alignment(0.0, 0.5) self.table.attach(label, 0,1, row_nr,row_nr+1, gtk.FILL,0, 6,6) self.table.attach(label_window, 1,2, row_nr,row_nr+1, gtk.FILL,0, 6,6) row_nr += 1 except: pass else: self.property_label = gtk.Label(_('Compatibility')) self.settings = {} self.settings['program'] = os.path.basename(filename.strip()) # Get Windows version used for program, in the form of something like "win2k" self.settings['version'] = wine.version.get(self.settings['program']) # Translate that version to something readable, like "Windows 2000" self.settings['version'] = wine.version.windowsversions[self.settings['version']][0] # Get the size of the programs desktop window, or None if it's not set self.settings['desktop'] = wine.desktop.get(self.settings['program']) # # Setup widgets # version_label = gtk.Label(_('Operate as:')) version_label.set_alignment(0.0, 0.5) self.version_value = gtk.combo_box_new_text() for version in ['Windows 7', 'Windows Vista', 'Windows 2003', 'Windows XP %s' % _("(default)"), 'Windows 2000', 'Windows NT 4.0', 'Windows NT 3.51', 'Windows ME', 'Windows 98', 'Windows 95', 'Windows 3.11', 'Windows 3.0', 'Windows 2.0']: self.version_value.append_text(version) self.table.attach(version_label, 0,1, 0,1, gtk.FILL,0, 6,6) self.table.attach(self.version_value, 1,2, 0,1, gtk.FILL,0, 6,6) desktop_label = gtk.Label(_('Open in:')) desktop_label.set_alignment(0.0, 0.0) desktop_value_box = gtk.VBox() self.desktop_value_check = gtk.CheckButton(_('Open program windows in a virtual desktop')) desktop_value_box.pack_start(self.desktop_value_check) self.desktop_table = gtk.Table(rows=2, columns=3, homogeneous=False) desktop_width = gtk.Label(_('Desktop width: ')) desktop_width.set_padding(24,0) desktop_width.set_alignment(0.0, 0.5) self.desktop_width_spin = gtk.SpinButton(climb_rate=1.0) self.desktop_width_spin.get_adjustment().set_all(1024.0, lower=0, upper=10000, step_increment=1, page_increment=10, page_size=0) desktop_width_label = gtk.Label(_('pixels')) desktop_width_label.set_padding(6,0) desktop_height = gtk.Label(_('Desktop height: ')) desktop_height.set_padding(24,0) desktop_height.set_alignment(0.0, 0.5) self.desktop_height_spin = gtk.SpinButton(climb_rate=1.0) self.desktop_height_spin.get_adjustment().set_all(768.0, lower=0, upper=10000, step_increment=1, page_increment=10, page_size=0) desktop_height_label = gtk.Label(_('pixels')) desktop_height_label.set_padding(6,0) self.desktop_table.attach(desktop_width, 0,1, 0,1, gtk.FILL,0, 0,0) self.desktop_table.attach(self.desktop_width_spin, 1,2, 0,1, gtk.FILL,0, 0,0) self.desktop_table.attach(desktop_width_label, 2,3, 0,1, gtk.FILL,0, 0,0) self.desktop_table.attach(desktop_height, 0,1, 1,2, gtk.FILL,0, 0,0) self.desktop_table.attach(self.desktop_height_spin, 1,2, 1,2, gtk.FILL,0, 0,0) self.desktop_table.attach(desktop_height_label, 2,3, 1,2, gtk.FILL,0, 0,0) desktop_value_box.pack_start(self.desktop_table) self.table.attach(desktop_label, 0,1, 1,2, gtk.FILL,gtk.FILL, 6,6) self.table.attach(desktop_value_box, 1,2, 1,2, gtk.FILL,0, 6,6) # # Load settings into widgets # GtkSelectCombobox(self.version_value, self.settings['version'], startswith=True) if self.settings['desktop']: self.desktop_value_check.set_active(True) self.desktop_width_spin.set_value(self.settings['desktop'][0]) self.desktop_height_spin.set_value(self.settings['desktop'][1]) self.desktop_table.set_sensitive(True) else: self.desktop_value_check.set_active(False) self.desktop_width_spin.set_value(1024.0) self.desktop_height_spin.set_value(768.0) self.desktop_table.set_sensitive(False) # # Connect widget logic # self.version_value.connect("changed", self.set_version) self.desktop_value_check.connect("toggled", self.set_desktop) self.desktop_width_spin.connect("value_changed", self.set_desktop_size) self.desktop_height_spin.connect("value_changed", self.set_desktop_size) self.alignment.show_all() return nautilus.PropertyPage("NautilusPython::vineyard", self.property_label, self.alignment),
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 python_export_scaled(img, drawable) : global percent_e, width_e, height_e, orig_width, orig_height, warning_label orig_filename = img.filename orig_width = img.width orig_height = img.height # Do we already have defaults? para = img.parasite_find('export-scaled') if para : [ init_filename, init_percent, init_width, init_height ] = \ para.data.split('\n') else : init_filename = orig_filename init_percent = 100 init_width = img.width init_height = img.height chooser = gtk.FileChooserDialog(title=None, action=gtk.FILE_CHOOSER_ACTION_SAVE, buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE, gtk.RESPONSE_OK)) if init_filename : chooser.set_current_name(os.path.basename(init_filename)) chooser.set_current_folder(os.path.dirname(init_filename)) vbox = gtk.VBox(spacing=8) hbox = gtk.HBox(spacing=8) l = gtk.Label("Export size:") l.set_alignment(1, 0) l.show() hbox.pack_start(l) l = gtk.Label("Percent") l.set_alignment(1, 0) hbox.pack_start(l) l.show() adj = gtk.Adjustment(float(init_percent), 1, 10000, 1, 10, 0) percent_e = gtk.SpinButton(adj) #, 0, 0) #percent_e = gtk.Entry() #percent_e.set_width_chars(5) #percent_e.set_text("100") # XXX Later, remember size from last time percent_e.connect("changed", entry_changed, 'p'); percent_e.show() hbox.pack_start(percent_e) l = gtk.Label("%") l.set_alignment(0, 1) hbox.pack_start(l) l.show() l = gtk.Label("Width") l.set_alignment(1, 0) hbox.pack_start(l) l.show() adj = gtk.Adjustment(float(init_width), 1, 10000, 1, 10, 0) width_e = gtk.SpinButton(adj) #width_e = gtk.Entry() #width_e.set_width_chars(7) #width_e.set_text(str(img.width)) # XXX Later, remember size from previous run width_e.connect("changed", entry_changed, 'w'); width_e.show() hbox.pack_start(width_e) l = gtk.Label("Height") l.set_alignment(1, 0) hbox.pack_start(l) l.show() adj = gtk.Adjustment(float(init_height), 1, 10000, 1, 10, 0) height_e = gtk.SpinButton(adj) #height_e = gtk.Entry() #height_e.set_width_chars(7) #height_e.set_text(str(img.height)) height_e.connect("changed", entry_changed, 'h'); hbox.pack_start(height_e) height_e.show() hbox.show() vbox.pack_start(hbox) warning_label = gtk.Label("") warning_label.show() vbox.pack_start(warning_label) chooser.set_extra_widget(vbox) # Oh, cool, we could have shortcuts to image folders, # and maybe remove the stupid fstab shortcuts GTK adds for us. #chooser.add_shortcut_folder(folder) #chooser.remove_shortcut_folder(folder) # Loop to catch errors/warnings: while True : response = chooser.run() if response != gtk.RESPONSE_OK: chooser.destroy() return percent = float(percent_e.get_text()) width = int(width_e.get_text()) height = int(height_e.get_text()) filename = chooser.get_filename() if filename == orig_filename : warning_label.set_text("Change the name or the directory -- don't overwrite original file!") continue # Whew, it's not the original filename, so now we can export. #print "export from", orig_filename, "to", filename, \ # "at", width, "x", height # Is there any point to pushing and popping the context? #gimp.context_pop() newimg = pdb.gimp_image_duplicate(img) # If it's XCF, we don't need to flatten or process it further, # just scale it: base, ext = os.path.splitext(filename) ext = ext.lower() if ext == '.gz' or ext == '.bz2' : base, ext = os.path.splitext(base) ext = ext.lower() if ext != '.xcf' : newimg.flatten() # XXX This could probably be smarter about flattening. Oh, well. pdb.gimp_image_merge_visible_layers(copyimg, CLIP_TO_IMAGE) newimg.scale(width, height) # Find any image type settings parasites (e.g. jpeg settings) # that got set during save, so we'll be able to use them # next time. def copy_settings_parasites(fromimg, toimg) : for pname in fromimg.parasite_list() : if pname[-9:] == '-settings' or pname[-13:] == '-save-options' : para = fromimg.parasite_find(pname) if para : toimg.attach_new_parasite(pname, para.flags, para.data) # Copy any settings parasites we may have saved from previous runs: copy_settings_parasites(img, newimg) # gimp-file-save insists on being passed a valid layer, # even if saving to a multilayer format such as XCF. Go figure. try : # I don't get it. What's the rule for whether gimp_file_save # will prompt for jpg parameters? Saving back to an existing # file doesn't seem to help. # run_mode=RUN_WITH_LAST_VALS is supposed to prevent prompting, # but actually seems to do nothing. Copying the -save-options # parasites is more effective. dpy = chooser.get_display() chooser.hide() dpy.sync() pdb.gimp_file_save(newimg, newimg.active_layer, filename, filename, run_mode=RUN_WITH_LAST_VALS) except RuntimeError, e : #warning_label.set_text("Didn't save to " + filename # + ":" + str(e)) markup = '<span foreground="red" size="larger" weight=\"bold">' markup_end = '</span>' warning_label.set_markup(markup + "Didn't save to " + filename + ":" + str(e) + markup_end) gimp.delete(newimg) chooser.show() continue chooser.destroy() #gimp.context_pop() copy_settings_parasites(newimg, img) gimp.delete(newimg) #gimp.Display(newimg) # Save parameters as a parasite, even if saving failed, # so we can default to them next time. # Save: percent, width, height # I have no idea what the flags are -- the doc doesn't say. para = img.attach_new_parasite('export-scaled', 0, '%s\n%d\n%d\n%d' % (filename, percent, width, height)) # img.parasite_attach(para) return
def make_toolbar(self, toolbar, tips, use_stock_icons): # bold tool self.bold = self._make_toggle_button( toolbar, tips, "Bold", "bold.png", gtk.STOCK_BOLD, lambda: self._editor.get_textview().toggle_font_mod("bold"), use_stock_icons) # italic tool self.italic = self._make_toggle_button( toolbar, tips, "Italic", "italic.png", gtk.STOCK_ITALIC, lambda: self._editor.get_textview().toggle_font_mod("italic"), use_stock_icons) # underline tool self.underline = self._make_toggle_button( toolbar, tips, "Underline", "underline.png", gtk.STOCK_UNDERLINE, lambda: self._editor.get_textview().toggle_font_mod("underline"), use_stock_icons) # strikethrough self.strike = self._make_toggle_button( toolbar, tips, "Strike", "strike.png", gtk.STOCK_STRIKETHROUGH, lambda: self._editor.get_textview().toggle_font_mod("strike"), use_stock_icons) # fixed-width tool self.fixed_width = self._make_toggle_button( toolbar, tips, "Monospace", "fixed-width.png", None, lambda: self._editor.get_textview().toggle_font_mod("tt"), use_stock_icons) # link self.link = self._make_toggle_button(toolbar, tips, "Make Link", "link.png", None, self.on_toggle_link, use_stock_icons) # no wrap tool self.no_wrap = self._make_toggle_button( toolbar, tips, "No Wrapping", "no-wrap.png", None, lambda: self._editor.get_textview().toggle_font_mod("nowrap"), use_stock_icons) # family combo self.font_family_combo = FontSelector() self.font_family_combo.set_size_request(150, 25) item = gtk.ToolItem() item.add(self.font_family_combo) tips.set_tip(item, "Font Family") toolbar.insert(item, -1) self.font_family_id = self.font_family_combo.connect( "changed", lambda w: self.on_family_set()) self._font_ui_signals.append( FontUI(self.font_family_combo, self.font_family_id)) # font size DEFAULT_FONT_SIZE = 10 self.font_size_button = gtk.SpinButton( gtk.Adjustment(value=DEFAULT_FONT_SIZE, lower=2, upper=500, step_incr=1)) self.font_size_button.set_size_request(-1, 25) #self.font_size_button.set_range(2, 100) self.font_size_button.set_value(DEFAULT_FONT_SIZE) self.font_size_button.set_editable(False) item = gtk.ToolItem() item.add(self.font_size_button) tips.set_tip(item, "Font Size") toolbar.insert(item, -1) self.font_size_id = self.font_size_button.connect( "value-changed", lambda w: self.on_font_size_change(self.font_size_button.get_value( ))) self._font_ui_signals.append( FontUI(self.font_size_button, self.font_size_id)) # font fg color # TODO: code in proper default color self.fg_color_button = FgColorTool(14, 15, (0, 0, 0)) self.fg_color_button.connect( "set-color", lambda w, color: self.on_color_set("fg", color)) tips.set_tip(self.fg_color_button, "Set Text Color") toolbar.insert(self.fg_color_button, -1) # font bg color self.bg_color_button = BgColorTool(14, 15, (65535, 65535, 65535)) self.bg_color_button.connect( "set-color", lambda w, color: self.on_color_set("bg", color)) tips.set_tip(self.bg_color_button, "Set Background Color") toolbar.insert(self.bg_color_button, -1) # separator toolbar.insert(gtk.SeparatorToolItem(), -1) # left tool self.left_align = self._make_toggle_button( toolbar, tips, "Left Align", "alignleft.png", gtk.STOCK_JUSTIFY_LEFT, lambda: self.on_justify("left"), use_stock_icons) # center tool self.center_align = self._make_toggle_button( toolbar, tips, "Center Align", "aligncenter.png", gtk.STOCK_JUSTIFY_CENTER, lambda: self.on_justify("center"), use_stock_icons) # right tool self.right_align = self._make_toggle_button( toolbar, tips, "Right Align", "alignright.png", gtk.STOCK_JUSTIFY_RIGHT, lambda: self.on_justify("right"), use_stock_icons) # justify tool self.fill_align = self._make_toggle_button( toolbar, tips, "Justify Align", "alignjustify.png", gtk.STOCK_JUSTIFY_FILL, lambda: self.on_justify("fill"), use_stock_icons) # bullet list tool self.bullet = self._make_toggle_button(toolbar, tips, "Bullet List", "bullet.png", None, lambda: self.on_bullet_list(), use_stock_icons)
def createPreExistFSOptionSection(origrequest, maintable, row, mountCombo, partitions, ignorefs=[], luksdev=None): """ createPreExistFSOptionSection: given inputs for a preexisting partition, create a section that will provide format and migrate options Returns the value of row after packing into the maintable, and a dictionary consistenting of: formatcb - checkbutton for 'format as new fs' fstype - part of format fstype menu fstypeMenu - part of format fstype menu migratecb - checkbutton for migrate fs migfstypeMenu - menu for migrate fs types lukscb - checkbutton for 'encrypt using LUKS/dm-crypt' resizecb - checkbutton for 'resize fs' resizesb - spinbutton with resize target """ rc = {} if luksdev: origfs = luksdev.format else: origfs = origrequest.format if origfs.formattable or not origfs.type: formatcb = gtk.CheckButton(label=_("_Format as:")) maintable.attach(formatcb, 0, 1, row, row + 1) formatcb.set_active(origfs.formattable and not origfs.exists) rc["formatcb"] = formatcb fstypeCombo = createFSTypeMenu(origfs, fstypechangeCB, mountCombo, ignorefs=ignorefs) fstypeCombo.set_sensitive(formatcb.get_active()) maintable.attach(fstypeCombo, 1, 2, row, row + 1) row += 1 rc["fstypeCombo"] = fstypeCombo else: formatcb = None fstypeCombo = None if formatcb and not formatcb.get_active() and not origfs.migrate: mountCombo.set_data("prevmountable", origfs.mountable) # this gets added to the table a bit later on lukscb = gtk.CheckButton(_("_Encrypt")) if origfs.migratable and origfs.exists: migratecb = gtk.CheckButton(label=_("Mi_grate filesystem to:")) if formatcb is not None: migratecb.set_active(origfs.migrate and (not formatcb.get_active())) else: migratecb.set_active(origfs.migrate) migtypes = [origfs.migrationTarget] maintable.attach(migratecb, 0, 1, row, row + 1) migfstypeCombo = createFSTypeMenu(origfs, None, None, availablefstypes=migtypes) migfstypeCombo.set_sensitive(migratecb.get_active()) maintable.attach(migfstypeCombo, 1, 2, row, row + 1) row = row + 1 rc["migratecb"] = migratecb rc["migfstypeCombo"] = migfstypeCombo migratecb.connect("toggled", formatMigrateOptionCB, (migfstypeCombo, mountCombo, origfs, None, fstypeCombo, formatcb, FLAG_MIGRATE)) else: migratecb = None migfstypeCombo = None if formatcb: formatcb.connect("toggled", formatMigrateOptionCB, (fstypeCombo, mountCombo, origfs, lukscb, migfstypeCombo, migratecb, FLAG_FORMAT)) if origrequest.resizable and origfs.exists: resizecb = gtk.CheckButton(label=_("_Resize")) resizecb.set_active(origfs.resizable and \ (origfs.currentSize != origfs.targetSize) and \ (origfs.currentSize != 0)) rc["resizecb"] = resizecb maintable.attach(resizecb, 0, 1, row, row + 1) if origrequest.targetSize is not None: value = origrequest.targetSize else: value = origrequest.size (reqlower, requpper) = getResizeMinMax(origrequest) adj = gtk.Adjustment(value=value, lower=reqlower, upper=requpper, step_incr=1) resizesb = gtk.SpinButton(adj, digits=0) resizesb.set_property('numeric', True) resizesb.set_data("requpper", requpper) resizesb.set_data("reqlower", reqlower) rc["resizesb"] = resizesb maintable.attach(resizesb, 1, 2, row, row + 1) resizecb.connect('toggled', resizeOptionCB, (formatcb, resizesb)) resizeOptionCB(resizecb, (formatcb, resizesb)) row = row + 1 if formatcb: formatcb.connect("toggled", formatOptionResizeCB, (resizecb, resizesb, origfs)) if luksdev: lukscb.set_active(1) if origrequest.originalFormat.type == "luks": lukscb.set_data("encrypted", 1) else: lukscb.set_data("encrypted", 0) if formatcb: lukscb.set_sensitive(formatcb.get_active()) lukscb.set_data("formatstate", formatcb.get_active()) else: lukscb.set_sensitive(0) lukscb.set_data("formatstate", 0) rc["lukscb"] = lukscb maintable.attach(lukscb, 0, 2, row, row + 1) row = row + 1 return (row, rc)
def __init__(self): gtk.VBox.__init__(self) from application import get_app app = get_app() self.app = app self.ani = app.doc.ani.model self.is_playing = False self.set_size_request(200, 150) self.app.doc.model.doc_observers.append(self.doc_structure_modified_cb) # create list: self.listmodel = self.create_list() # create tree view: self.treeview = gtk.TreeView(self.listmodel) self.treeview.set_rules_hint(True) self.treeview.set_headers_visible(False) treesel = self.treeview.get_selection() treesel.set_mode(gtk.SELECTION_SINGLE) self.changed_handler = treesel.connect('changed', self.on_row_changed) self.add_columns() layers_scroll = gtk.ScrolledWindow() layers_scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) layers_scroll.set_placement(gtk.CORNER_TOP_RIGHT) layers_scroll.add(self.treeview) # xsheet controls: def pixbuf_button(pixbuf): b = gtk.Button() img = gtk.Image() img.set_from_pixbuf(pixbuf) b.add(img) return b pixbuf_key = self.app.pixmaps.keyframe_add self.key_button = pixbuf_button(pixbuf_key) self.key_button.connect('clicked', self.on_toggle_key) self.key_button.set_tooltip_text(_('Toggle Keyframe')) pixbuf_skip = self.app.pixmaps.cel_skip self.skip_button = pixbuf_button(pixbuf_skip) self.skip_button.connect('clicked', self.on_toggle_skip) self.skip_button.set_tooltip_text(_('Set/Unset onion skin')) self.chdesc_button = stock_button(gtk.STOCK_ITALIC) self.chdesc_button.connect('clicked', self.on_change_description) self.chdesc_button.set_tooltip_text(_('Change Cel Description')) pixbuf_add = self.app.pixmaps.cel_add self.add_cel_button = pixbuf_button(pixbuf_add) self.add_cel_button.connect('clicked', self.on_add_cel) self.add_cel_button.set_tooltip_text(_('Add cel to this frame')) pixbuf_remove = self.app.pixmaps.cel_remove self.remove_cel_button = pixbuf_button(pixbuf_remove) self.remove_cel_button.connect('clicked', self.on_remove_cel) self.remove_cel_button.set_tooltip_text(_('Remove cel of this frame')) buttons_hbox = gtk.HBox() buttons_hbox.pack_start(self.key_button) buttons_hbox.pack_start(self.skip_button) buttons_hbox.pack_start(self.chdesc_button) buttons_hbox.pack_start(self.add_cel_button) buttons_hbox.pack_start(self.remove_cel_button) # player controls: self.previous_button = stock_button(gtk.STOCK_GO_UP) self.previous_button.connect('clicked', self.on_previous_frame) self.previous_button.set_tooltip_text(_('Previous Frame')) self.next_button = stock_button(gtk.STOCK_GO_DOWN) self.next_button.connect('clicked', self.on_next_frame) self.next_button.set_tooltip_text(_('Next Frame')) self.play_button = stock_button(gtk.STOCK_MEDIA_PLAY) self.play_button.connect('clicked', self.on_animation_play) self.play_button.set_tooltip_text(_('Play animation')) self.pause_button = stock_button(gtk.STOCK_MEDIA_PAUSE) self.pause_button.connect('clicked', self.on_animation_pause) self.pause_button.set_tooltip_text(_('Pause animation')) self.stop_button = stock_button(gtk.STOCK_MEDIA_STOP) self.stop_button.connect('clicked', self.on_animation_stop) self.stop_button.set_tooltip_text(_('Stop animation')) anibuttons_hbox = gtk.HBox() anibuttons_hbox.pack_start(self.previous_button) anibuttons_hbox.pack_start(self.next_button) anibuttons_hbox.pack_start(self.play_button) anibuttons_hbox.pack_start(self.pause_button) anibuttons_hbox.pack_start(self.stop_button) # frames edit controls: insert_frame_button = stock_button(gtk.STOCK_ADD) insert_frame_button.connect('clicked', self.on_insert_frames) insert_frame_button.set_tooltip_text(_('Insert frames')) self.insert_frame_button = insert_frame_button remove_frame_button = stock_button(gtk.STOCK_REMOVE) remove_frame_button.connect('clicked', self.on_remove_frames) remove_frame_button.set_tooltip_text(_('Remove frames')) self.remove_frame_button = remove_frame_button cut_button = stock_button(gtk.STOCK_CUT) cut_button.connect('clicked', self.on_cut) cut_button.set_tooltip_text(_('Cut cel')) self.cut_button = cut_button copy_button = stock_button(gtk.STOCK_COPY) copy_button.connect('clicked', self.on_copy) copy_button.set_tooltip_text(_('Copy cel')) self.copy_button = copy_button paste_button = stock_button(gtk.STOCK_PASTE) paste_button.connect('clicked', self.on_paste) paste_button.set_tooltip_text(_('Paste cel')) self.paste_button = paste_button editbuttons_hbox = gtk.HBox() editbuttons_hbox.pack_start(insert_frame_button) editbuttons_hbox.pack_start(remove_frame_button) editbuttons_hbox.pack_start(cut_button) editbuttons_hbox.pack_start(copy_button) editbuttons_hbox.pack_start(paste_button) # lightbox controls: adj = gtk.Adjustment(lower=0, upper=100, step_incr=1, page_incr=10) self.opacity_scale = gtk.HScale(adj) opa = self.app.preferences.get('lightbox.factor', 100) self.opacity_scale.set_value(opa) self.opacity_scale.set_value_pos(gtk.POS_LEFT) opacity_lbl = gtk.Label(_('Opacity:')) opacity_hbox = gtk.HBox() opacity_hbox.pack_start(opacity_lbl, expand=False) opacity_hbox.pack_start(self.opacity_scale, expand=True) self.opacity_scale.connect('value-changed', self.on_opacityfactor_changed) self.expander_prefs_loaded = False self.connect("show", self.show_cb) def opacity_checkbox(attr, label, tooltip=None): cb = gtk.CheckButton(label) pref = "lightbox.%s" % (attr, ) default = DEFAULT_ACTIVE_CELS[attr] cb.set_active(self.app.preferences.get(pref, default)) cb.connect('toggled', self.on_opacity_toggled, attr) if tooltip is not None: cb.set_tooltip_text(tooltip) opacityopts_vbox.pack_start(cb, expand=False) opacityopts_vbox = gtk.VBox() opacity_checkbox('cel', _('Inmediate'), _("Show the inmediate next and previous cels.")) opacity_checkbox( 'key', _('Inmediate keys'), _("Show the cel keys that are after and before the current cel.")) opacity_checkbox( 'inbetweens', _('Inbetweens'), _("Show the cels that are between the inmediate key cels.")) opacity_checkbox('other keys', _('Other keys'), _("Show the other keys cels.")) opacity_checkbox('other', _('Other'), _("Show the rest of the cels.")) self.framerate_adjustment = gtk.Adjustment(value=self.ani.framerate, lower=1, upper=120, step_incr=1.0) self.framerate_adjustment.connect("value-changed", self.on_framerate_changed) self.framerate_entry = gtk.SpinButton( adjustment=self.framerate_adjustment, digits=2, climb_rate=1.5) framerate_lbl = gtk.Label(_('Frame rate:')) framerate_hbox = gtk.HBox() framerate_hbox.pack_start(framerate_lbl, False, False) framerate_hbox.pack_start(self.framerate_entry, False, False) icons_cb = gtk.CheckButton(_("Small icons")) icons_cb.set_active( self.app.preferences.get("xsheet.small_icons", False)) icons_cb.connect('toggled', self.on_smallicons_toggled) icons_cb.set_tooltip_text( _("Use smaller icons, better to see more rows.")) play_lightbox_cb = gtk.CheckButton(_("Play with lightbox on")) play_lightbox_cb.set_active( self.app.preferences.get("xsheet.play_lightbox", False)) play_lightbox_cb.connect('toggled', self.on_playlightbox_toggled) play_lightbox_cb.set_tooltip_text( _("Show other frames while playing, this is slower.")) showprev_cb = gtk.CheckButton(_("Lightbox show previous")) showprev_cb.set_active( self.app.preferences.get("xsheet.lightbox_show_previous", True)) showprev_cb.connect('toggled', self.on_shownextprev_toggled, 'previous') showprev_cb.set_tooltip_text(_("Show previous cels in the lightbox.")) shownext_cb = gtk.CheckButton(_("Lightbox show next")) shownext_cb.set_active( self.app.preferences.get("xsheet.lightbox_show_next", False)) shownext_cb.connect('toggled', self.on_shownextprev_toggled, 'next') shownext_cb.set_tooltip_text(_("Show next cels in the lightbox.")) controls_vbox = gtk.VBox() controls_vbox.pack_start(buttons_hbox, expand=False) controls_vbox.pack_start(anibuttons_hbox, expand=False) controls_vbox.pack_start(editbuttons_hbox, expand=False) preferences_vbox = gtk.VBox() preferences_vbox.pack_start(framerate_hbox, expand=False) preferences_vbox.pack_start(icons_cb, expand=False) preferences_vbox.pack_start(play_lightbox_cb, expand=False) preferences_vbox.pack_start(showprev_cb, expand=False) preferences_vbox.pack_start(shownext_cb, expand=False) preferences_vbox.pack_start(opacity_hbox, expand=False) preferences_vbox.pack_start(opacityopts_vbox, expand=False) self.controls_expander = gtk.Expander(label=_('Controls')) self.controls_expander.add(controls_vbox) self.controls_expander.connect("notify::expanded", self.expanded_cb, 'controls') self.prefs_expander = gtk.Expander(label=_('Preferences')) self.prefs_expander.add(preferences_vbox) self.prefs_expander.connect("notify::expanded", self.expanded_cb, 'preferences') self.pack_start(layers_scroll) self.pack_start(self.controls_expander, expand=False) self.pack_start(self.prefs_expander, expand=False) self.show_all() self._change_player_buttons() self.app.doc.model.doc_observers.append(self.update)
def create_window(self): """ Set up the window with all its widgets :return: the created window """ window = gtk.Window(gtk.WINDOW_TOPLEVEL) window.set_border_width(2) window.set_title('Enter LaTeX Formula - TexText {0}'.format( self.textext_version)) # File chooser and Scale Adjustment if hasattr(gtk, 'FileChooserButton'): self._preamble_widget = gtk.FileChooserButton("...") self._preamble_widget.set_action(gtk.FILE_CHOOSER_ACTION_OPEN) else: self._preamble_widget = gtk.Entry() self.set_preamble() # --- Preamble file --- preamble_delete = gtk.Button(label="Clear") preamble_delete.connect('clicked', self.clear_preamble) preamble_delete.set_tooltip_text("Clear the preamble file setting") preamble_frame = gtk.Frame("Preamble File") preamble_box = gtk.HBox(homogeneous=False, spacing=2) preamble_frame.add(preamble_box) preamble_box.pack_start(self._preamble_widget, True, True, 2) preamble_box.pack_start(preamble_delete, False, False, 2) # --- Tex command --- texcmd_frame = gtk.Frame("TeX command") texcmd_box = gtk.HBox(homogeneous=False, spacing=2) texcmd_frame.add(texcmd_box) self._texcmd_cbox = gtk.combo_box_new_text() cell = gtk.CellRendererText() self._texcmd_cbox.pack_start(cell) self._texcmd_cbox.set_wrap_width(1) for tex_command in self.TEX_COMMANDS: self._texcmd_cbox.append_text(tex_command) self._texcmd_cbox.set_active( self.TEX_COMMANDS.index(self.current_texcmd)) self._texcmd_cbox.set_tooltip_text( "TeX command used for compiling.") texcmd_box.pack_start(self._texcmd_cbox, True, True, 2) # --- Scaling --- scale_frame = gtk.Frame("Scale Factor") scale_box = gtk.HBox(homogeneous=False, spacing=2) scale_frame.add(scale_box) self._scale_adj = gtk.Adjustment(lower=0.001, upper=180, step_incr=0.001, page_incr=1) self._scale = gtk.SpinButton(self._scale_adj) self._scale.set_digits(3) self._scale_adj.set_value(self.scale_factor_after_loading()) self._scale.set_tooltip_text( "Change the scale of the LaTeX output") # We need buttons with custom labels and stock icons, so we make some reset_scale = self.current_scale_factor if self.current_scale_factor else self.global_scale_factor items = [('tt-reset', 'Reset ({0:.3f})'.format(reset_scale), 0, 0, None), ('tt-global', 'As previous ({0:.3f})'.format(self.global_scale_factor), 0, 0, None)] # Forcibly show icons settings = gtk.settings_get_default() settings.props.gtk_button_images = True # Make copies of stock icons aliases = [('tt-reset', gtk.STOCK_UNDO), ('tt-global', gtk.STOCK_COPY)] gtk.stock_add(items) factory = gtk.IconFactory() factory.add_default() style = window.get_style() for new_stock, alias in aliases: icon_set = style.lookup_icon_set(alias) factory.add(new_stock, icon_set) scale_reset_button = gtk.Button(stock='tt-reset') scale_reset_button.set_tooltip_text( "Set scale factor to the value this node has been created with ({0:.3f})" .format(reset_scale)) scale_reset_button.connect('clicked', self.reset_scale_factor) if self.text == "": scale_reset_button.set_sensitive(False) scale_global_button = gtk.Button(stock='tt-global') scale_global_button.set_tooltip_text( "Set scale factor to the value of the previously edited node in Inkscape ({0:.3f})" .format(self.global_scale_factor)) scale_global_button.connect('clicked', self.use_global_scale_factor) scale_box.pack_start(self._scale, True, True, 2) scale_box.pack_start(scale_reset_button, False, False, 2) scale_box.pack_start(scale_global_button, False, False, 2) # --- Alignment box --- alignment_frame = gtk.Frame("Alignment") alignment_box = gtk.HBox(homogeneous=False, spacing=2) alignment_frame.add(alignment_box) liststore = gtk.ListStore(str) for a in self.ALIGNMENT_LABELS: liststore.append([a]) self._alignment_combobox = gtk.ComboBox() cell = gtk.CellRendererText() self._alignment_combobox.pack_start(cell) self._alignment_combobox.add_attribute(cell, 'text', 0) self._alignment_combobox.set_model(liststore) self._alignment_combobox.set_wrap_width(3) self._alignment_combobox.set_active( self.ALIGNMENT_LABELS.index(self.current_alignment)) self._alignment_combobox.set_tooltip_text( "Set alignment anchor position") if self.text == "": self._alignment_combobox.set_sensitive(False) alignment_box.pack_start(self._alignment_combobox, True, True, 2) # --- Scale and alignment together in one "line" scale_align_hbox = gtk.HBox(homogeneous=False, spacing=2) scale_align_hbox.pack_start(scale_frame, False, False, 0) scale_align_hbox.pack_start(alignment_frame, True, True, 0) # --- TeX code window --- # Scrolling Window with Source View inside scroll_window = gtk.ScrolledWindow() scroll_window.set_shadow_type(gtk.SHADOW_IN) if TOOLKIT == GTKSOURCEVIEW: # Source code view text_buffer = gtksourceview2.Buffer() # set LaTeX as highlighting language, so that pasted text is also highlighted as such lang_manager = gtksourceview2.LanguageManager() latex_language = lang_manager.get_language("latex") text_buffer.set_language(latex_language) text_buffer.set_data('languages-manager', lang_manager) source_view = gtksourceview2.View(text_buffer) else: # normal text view text_buffer = gtk.TextBuffer() source_view = gtk.TextView(text_buffer) self._source_buffer = text_buffer self._source_view = source_view self._source_buffer.set_text(self.text) scroll_window.add(self._source_view) set_monospace_font(self._source_view) # Action group and UI manager ui_manager = gtk.UIManager() accel_group = ui_manager.get_accel_group() window.add_accel_group(accel_group) ui_manager.add_ui_from_string(self._view_ui_description) action_group = gtk.ActionGroup('ViewActions') action_group.add_actions(self._view_actions, source_view) action_group.add_actions(self.buffer_actions, text_buffer) if TOOLKIT == GTKSOURCEVIEW: action_group.add_toggle_actions(self._toggle_actions, source_view) action_group.add_radio_actions( self._radio_actions, -1, AskTextGTKSource.tabs_toggled_cb, source_view) ui_manager.insert_action_group(action_group, 0) # Menu menu = ui_manager.get_widget('/MainMenu') # Cursor position label pos_label = gtk.Label('Position') source_view.set_data('pos_label', pos_label) # latex preview self._preview = gtk.Image() # Vertical Layout vbox = gtk.VBox(False, 4) window.add(vbox) vbox.pack_start(menu, False, False, 0) vbox.pack_start(preamble_frame, False, False, 0) vbox.pack_start(texcmd_frame, False, False, 0) vbox.pack_start(scale_align_hbox, False, False, 0) vbox.pack_start(scroll_window, True, True, 0) vbox.pack_start(pos_label, False, False, 0) vbox.pack_start(self._preview, False, False, 0) vbox.pack_start(self.create_buttons(), False, False, 0) vbox.show_all() # preselect menu check items if TOOLKIT == GTKSOURCEVIEW: groups = ui_manager.get_action_groups() # retrieve the view action group at position 0 in the list action_group = groups[0] action = action_group.get_action('ShowNumbers') action.set_active(True) action = action_group.get_action('AutoIndent') action.set_active(True) action = action_group.get_action('InsertSpaces') action.set_active(True) action = action_group.get_action('TabsWidth4') action.set_active(True) # Connect event callbacks window.connect("key-press-event", self.cb_key_press) text_buffer.connect('changed', self.update_position_label, source_view) window.connect('delete-event', self.window_deleted_cb, source_view) text_buffer.connect('mark_set', self.move_cursor_cb, source_view) return window
def show_options(self, origin, table=None): """Creates the text and menu widget for every possible value on a given track""" if table == None: table = self.table model = origin.get_model() for child in table.get_children(): if type(child) is gtk.Label and child.get_text() == "Type": pass elif child == origin: pass else: table.remove(child) table.resize(1, 1) klass = model[origin.get_active()][1] options = klass.gc_parameters row = 2 for name in klass.order: values = options[name] #for name,values in options.iteritems(): kind = values["type"] label = gtk.Label(name.title()) label.set_width_chars(20) label.set_alignment(0.0, 0.5) table.attach(label, 0, 1, row, row + 1, False, False, 0, 0) if kind in ["text", "device", "caps"]: widget = gtk.Entry() widget.set_text(values['default']) widget.set_alignment(0.0) elif kind == "flavor": store = gtk.ListStore(str) widget = gtk.ComboBox(store) for option in FLAVORS: store.append([option]) cell = gtk.CellRendererText() widget.pack_start(cell, True) widget.add_attribute(cell, 'text', 0) widget.set_active(FLAVORS.index(values['default'])) elif kind == "integer": adjust = gtk.Adjustment(values["default"], values["range"][0], values["range"][1], 1, 1) widget = gtk.SpinButton(adjust, 1.0, 0) widget.set_alignment(0.0) elif kind == "float": adjust = gtk.Adjustment(values["default"], values["range"][0], values["range"][1], 0.1, 1) widget = gtk.SpinButton(adjust, 0.1, 1) widget.set_alignment(0.0) elif kind == "boolean": widget = gtk.CheckButton("Active") if values['default'] in [ "False", "false", "no", "No", ]: widget.set_mode(False) else: widget.set_mode(True) widget.set_alignment(0.0, 0.5) elif kind == "select": store = gtk.ListStore(str) widget = gtk.ComboBox(store) for value in values['options']: store.append([value]) cell = gtk.CellRendererText() widget.pack_start(cell, True) widget.add_attribute(cell, 'text', 0) widget.set_active(values['options'].index(values['default'])) widget.set_name(name) if kind not in ['integer', 'float']: table.attach(widget, 1, 2, row, row + 1, gtk.FILL, False, 0, 0) else: table.attach(widget, 1, 2, row, row + 1, False, False, 0, 0) label.show() widget.show() row += 1
def create_prefs_page(self): #Select Widget hover = gtk.Label() self.scheduler_select = SchedulerSelectWidget(hover) vbox = gtk.VBox(False, 5) hbox = gtk.HBox(False, 5) vbox_days = gtk.VBox() for day in DAYS: vbox_days.pack_start(gtk.Label(day)) hbox.pack_start(vbox_days, False, False) hbox.pack_start(self.scheduler_select, True, True) frame = gtk.Frame() label = gtk.Label() label.set_markup("<b>Schedule</b>") frame.set_label_widget(label) frame.set_shadow_type(gtk.SHADOW_NONE) frame.add(hbox) vbox.pack_start(frame, True, True) vbox.pack_start(hover) frame = gtk.Frame() label = gtk.Label() label.set_markup(_("<b>Forced Settings</b>")) frame.set_label_widget(label) forcedvbox = gtk.VBox(False, 1) self.chkIndividual = gtk.CheckButton("Use Individual Scheduling") forcedvbox.pack_start(self.chkIndividual) self.chkUnforceFinished = gtk.CheckButton("Un-Force on Finished") forcedvbox.pack_start(self.chkUnforceFinished) frame.add(forcedvbox) vbox.pack_start(frame, False, False) table = gtk.Table(3, 4) label = gtk.Label(_("Download Limit:")) label.set_alignment(0.0, 0.6) table.attach(label, 0, 1, 0, 1, gtk.FILL) self.spin_download = gtk.SpinButton() self.spin_download.set_numeric(True) self.spin_download.set_range(-1.0, 99999.0) self.spin_download.set_increments(1, 10) table.attach(self.spin_download, 1, 2, 0, 1, gtk.FILL) label = gtk.Label(_("Upload Limit:")) label.set_alignment(0.0, 0.6) table.attach(label, 0, 1, 1, 2, gtk.FILL) self.spin_upload = gtk.SpinButton() self.spin_upload.set_numeric(True) self.spin_upload.set_range(-1.0, 99999.0) self.spin_upload.set_increments(1, 10) table.attach(self.spin_upload, 1, 2, 1, 2, gtk.FILL) label = gtk.Label(_("Active Torrents:")) label.set_alignment(0.0, 0.6) table.attach(label, 2, 3, 0, 1, gtk.FILL) self.spin_active = gtk.SpinButton() self.spin_active.set_numeric(True) self.spin_active.set_range(-1, 9999) self.spin_active.set_increments(1, 10) table.attach(self.spin_active, 3, 4, 0, 1, gtk.FILL) label = gtk.Label(_("Active Downloading:")) label.set_alignment(0.0, 0.6) table.attach(label, 2, 3, 1, 2, gtk.FILL) self.spin_active_down = gtk.SpinButton() self.spin_active_down.set_numeric(True) self.spin_active_down.set_range(-1, 9999) self.spin_active_down.set_increments(1, 10) table.attach(self.spin_active_down, 3, 4, 1, 2, gtk.FILL) label = gtk.Label(_("Active Seeding:")) label.set_alignment(0.0, 0.6) table.attach(label, 2, 3, 2, 3, gtk.FILL) self.spin_active_up = gtk.SpinButton() self.spin_active_up.set_numeric(True) self.spin_active_up.set_range(-1, 9999) self.spin_active_up.set_increments(1, 10) table.attach(self.spin_active_up, 3, 4, 2, 3, gtk.FILL) eventbox = gtk.EventBox() eventbox.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#EDD400")) eventbox.add(table) frame = gtk.Frame() label = gtk.Label() label.set_markup(_("<b>Slow Settings</b>")) frame.set_label_widget(label) frame.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#CDB400")) frame.set_border_width(2) frame.add(eventbox) vbox.pack_start(frame, False, False) vbox.show_all() component.get("Preferences").add_page(_("MyScheduler"), vbox)
def __init__(self): qtwindow.QTWindow.__init__(self, 'watch', 'Watch') self.connect("delete-event", self._delete_event_cb) qt.flow.connect('measurement-start', self._mstart_cb) qt.flow.connect('measurement-end', self._mend_cb) self._watch = {} self._paused = False self._frame = gtk.Frame() self._frame.set_label(_L('Add variable')) self._ins_combo = dropdowns.InstrumentDropdown() self._ins_combo.connect('changed', self._instrument_changed_cb) self._param_combo = dropdowns.InstrumentParameterDropdown() self._param_combo.connect('changed', self._parameter_changed_cb) label = gtk.Label(_L('Interval')) self._interval = gtk.SpinButton(climb_rate=1, digits=0) self._interval.set_range(0, 100000) self._interval.set_value(500) interval = gui.pack_hbox( [label, self._interval, gtk.Label('ms')], False, False) self._graph_check = gtk.CheckButton('Graph') self._graph_check.set_active(True) self._graph_check.connect('toggled', self._graph_toggled_cb) label = gtk.Label('Data points') self._npoints = gtk.SpinButton(climb_rate=1, digits=0) self._npoints.set_range(10, 1000) self._npoints.set_value(100) self._npoints.set_increments(1, 10) graph = gui.pack_hbox([self._graph_check, label, self._npoints], True, False) self._ma_check = gtk.CheckButton('Moving average') self._ma_check.set_active(False) self._ma_check.connect('toggled', self._ma_toggled_cb) label = gtk.Label('Constant') self._ma_const = gtk.SpinButton(climb_rate=0.01, digits=2) self._ma_const.set_sensitive(False) self._ma_const.set_range(0, 1.0) self._ma_const.set_increments(0.01, 0.1) self._ma_const.set_value(0.95) ma = gui.pack_hbox([self._ma_check, label, self._ma_const], True, False) self._add_button = gtk.Button(_L('Add')) self._add_button.connect('clicked', self._add_clicked_cb) self._remove_button = gtk.Button(_L('Remove')) self._remove_button.connect('clicked', self._remove_clicked_cb) self._pause_button = gtk.ToggleButton(_L('Pause')) self._pause_button.set_active(False) self._pause_button.connect('clicked', self._toggle_pause_cb) self._apply_button = gtk.Button(_L('Apply')) self._apply_button.connect('clicked', self._apply_clicked_cb) self._clear_button = gtk.Button(_L('Clear')) self._clear_button.connect('clicked', self._clear_clicked_cb) buttons = gui.pack_hbox([ self._add_button, self._remove_button, self._pause_button, self._apply_button, self._clear_button ], False, False) self._tree_model = gtk.ListStore(str, str, str) self._tree_view = QTTable([ (_L('Parameter'), {}), (_L('Delay'), {}), (_L('Value'), { 'scale': 3.0 }), ], self._tree_model) vbox = gui.pack_vbox([ self._ins_combo, self._param_combo, interval, graph, ma, buttons, ], False, False) vbox.set_border_width(4) self._frame.add(vbox) vbox = gui.pack_vbox([ self._frame, self._tree_view, ], False, False) self.add(vbox) vbox.show_all()
def __init__(self, gui): SetupWindow.__init__(self) self.set_title(_("Nanotube")) vbox = gtk.VBox() # Intoductory text self.packtext(vbox, introtext) # Choose the element and bond length label1 = gtk.Label(_("Element: ")) #label.set_alignment(0.0, 0.2) self.element = gtk.Entry(max=3) self.element.set_text("C") self.element.connect('activate', self.makeatoms) self.bondlength = gtk.Adjustment(1.42, 0.0, 1000.0, 0.01) label2 = gtk.Label(_(" Bond length: ")) label3 = gtk.Label(_(u"Å")) bond_box = gtk.SpinButton(self.bondlength, 10.0, 3) pack(vbox, [label1, self.element, label2, bond_box, label3]) self.elementinfo = gtk.Label("") self.elementinfo.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#FF0000')) pack(vbox, [self.elementinfo]) pack(vbox, gtk.Label("")) # Choose the structure. pack(vbox, [gtk.Label(_("Select roll-up vector (n,m) " "and tube length:"))]) label1 = gtk.Label("n: ") label2 = gtk.Label(" m: ") self.n = gtk.Adjustment(5, 1, 100, 1) self.m = gtk.Adjustment(5, 0, 100, 1) spinn = gtk.SpinButton(self.n, 0, 0) spinm = gtk.SpinButton(self.m, 0, 0) label3 = gtk.Label(_(" Length: ")) self.length = gtk.Adjustment(1, 1, 100, 1) spinl = gtk.SpinButton(self.length, 0, 0) pack(vbox, [label1, spinn, label2, spinm, label3, spinl]) self.err = gtk.Label("") self.err.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#FF0000')) pack(vbox, [self.err]) pack(vbox, gtk.Label("")) self.status = gtk.Label("") pack(vbox, [self.status]) pack(vbox, [gtk.Label("")]) # Buttons self.pybut = PyButton(_("Creating a nanoparticle.")) self.pybut.connect('clicked', self.makeatoms) buts = cancel_apply_ok(cancel=lambda widget: self.destroy(), apply=self.apply, ok=self.ok) pack(vbox, [self.pybut, buts], end=True, bottom=True) # Finalize setup self.makeatoms() self.bondlength.connect('value-changed', self.makeatoms) self.m.connect('value-changed', self.makeatoms) self.n.connect('value-changed', self.makeatoms) self.length.connect('value-changed', self.makeatoms) self.add(vbox) vbox.show() self.show() self.gui = gui
def __init__(self): gtk.Dialog.__init__(self, 'Video 2 Gif', None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, (gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT)) self.set_title('Video 2 Gif') vbox = gtk.VBox(spacing=5) vbox.set_border_width(5) self.get_content_area().add(vbox) frame = gtk.Frame() vbox.add(frame) table = gtk.Table(5, 4) frame.add(table) label11 = gtk.Label('Video:') label11.set_alignment(0.0, 0.5) table.attach(label11, 0, 1, 0, 1, xoptions=gtk.EXPAND | gtk.FILL, yoptions=gtk.EXPAND | gtk.FILL, xpadding=5, ypadding=5) self.entry12 = gtk.Entry() self.entry12.set_editable(False) self.entry12.set_width_chars(40) table.attach(self.entry12, 1, 3, 0, 1, xoptions=gtk.EXPAND | gtk.FILL, yoptions=gtk.EXPAND | gtk.FILL, xpadding=5, ypadding=5) button13 = gtk.Button('Selecciona') table.attach(button13, 3, 4, 0, 1, xoptions=gtk.EXPAND | gtk.FILL, yoptions=gtk.EXPAND | gtk.FILL, xpadding=5, ypadding=5) button13.connect('clicked', self.on_button13_clicked) ################################################################ label21 = gtk.Label('Inicio:') label21.set_alignment(0.0, 0.5) table.attach(label21, 0, 1, 1, 2, xoptions=gtk.EXPAND | gtk.FILL, yoptions=gtk.EXPAND | gtk.FILL, xpadding=5, ypadding=5) self.hscale22 = gtk.HScale( gtk.Adjustment(value=0, lower=0, upper=50, step_incr=1, page_incr=10, page_size=1)) self.hscale22.connect('value-changed', self.on_value_changed_in_hscale22) table.attach(self.hscale22, 1, 4, 1, 2, xoptions=gtk.EXPAND | gtk.FILL, yoptions=gtk.EXPAND | gtk.FILL, xpadding=5, ypadding=5) label31 = gtk.Label('Fin:') label31.set_alignment(0.0, 0.5) table.attach(label31, 0, 1, 2, 3, xoptions=gtk.EXPAND | gtk.FILL, yoptions=gtk.EXPAND | gtk.FILL, xpadding=5, ypadding=5) self.hscale32 = gtk.HScale( gtk.Adjustment(value=0, lower=0, upper=50, step_incr=1, page_incr=10, page_size=1)) table.attach(self.hscale32, 1, 4, 2, 3, xoptions=gtk.EXPAND | gtk.FILL, yoptions=gtk.EXPAND | gtk.FILL, xpadding=5, ypadding=5) label41 = gtk.Label('Dimensiones:') label41.set_alignment(0.0, 0.5) table.attach(label41, 0, 1, 3, 4, xoptions=gtk.EXPAND | gtk.FILL, yoptions=gtk.EXPAND | gtk.FILL, xpadding=5, ypadding=5) self.entry42 = gtk.Entry() table.attach(self.entry42, 1, 2, 3, 4, xoptions=gtk.EXPAND | gtk.FILL, yoptions=gtk.EXPAND | gtk.FILL, xpadding=5, ypadding=5) label43 = gtk.Label('x') label43.set_alignment(0.5, 0.5) table.attach(label43, 2, 3, 3, 4, xoptions=gtk.EXPAND | gtk.FILL, yoptions=gtk.EXPAND | gtk.FILL, xpadding=5, ypadding=5) self.entry44 = gtk.Entry() table.attach(self.entry44, 3, 4, 3, 4, xoptions=gtk.EXPAND | gtk.FILL, yoptions=gtk.EXPAND | gtk.FILL, xpadding=5, ypadding=5) label51 = gtk.Label('Imágenes por segundo:') label51.set_alignment(0.0, 0.5) table.attach(label51, 0, 2, 4, 5, xoptions=gtk.EXPAND | gtk.FILL, yoptions=gtk.EXPAND | gtk.FILL, xpadding=5, ypadding=5) self.spinbutton52 = gtk.SpinButton() self.spinbutton52.set_digits(0) self.spinbutton52.set_range(1, 30) self.spinbutton52.set_adjustment( gtk.Adjustment(value=1, lower=1, upper=30, step_incr=1, page_incr=1, page_size=0)) table.attach(self.spinbutton52, 3, 4, 4, 5, xoptions=gtk.EXPAND | gtk.FILL, yoptions=gtk.EXPAND | gtk.FILL, xpadding=5, ypadding=5) # self.show_all()
def insert_event(user, password): # デフォルトのイベント開始・終了 日時 datetime_start = datetime.date.today() datetime_end = datetime.date.today() # 検索開始年月日と、ユーザ名・パスワードを入力するダイアログを表示する dlg = gtk.MessageDialog(type=gtk.MESSAGE_INFO, buttons=gtk.BUTTONS_OK_CANCEL, message_format='条件の設定を行います') dlg.set_title("GoogleカレンダーWriter") dlg_content = dlg.get_content_area() hbox_title = gtk.HBox() hbox_title.add(gtk.Label("予定の名称")) text_entry_title = gtk.Entry() text_entry_title.set_text("") hbox_title.add(text_entry_title) dlg_content.add(hbox_title) hbox_place = gtk.HBox() hbox_place.add(gtk.Label("場所")) text_entry_place = gtk.Entry() text_entry_place.set_text("") hbox_place.add(text_entry_place) dlg_content.add(hbox_place) hbox_content = gtk.HBox() hbox_content.add(gtk.Label("説明")) text_entry_content = gtk.Entry() text_entry_content.set_text("") hbox_content.add(text_entry_content) dlg_content.add(hbox_content) check_allday = gtk.CheckButton("終日の予定(時刻を無視する)") check_allday.set_active(True) dlg_content.add(check_allday) hbox_calendar = gtk.HBox() vbox_calendar_start = gtk.VBox() vbox_calendar_start.add(gtk.Label("予定開始日")) calendar_start = gtk.Calendar() calendar_start.select_month(datetime_start.month-1, datetime_start.year) calendar_start.select_day(datetime_start.day) hbox_monthday_start = gtk.HBox() hour_start = gtk.Adjustment(value=0, lower=0, upper=12, step_incr=1) spin_hour_start = gtk.SpinButton(hour_start) minute_start = gtk.Adjustment(value=0, lower=0, upper=59, step_incr=1) spin_minute_start = gtk.SpinButton(minute_start) hbox_monthday_start.add(spin_hour_start) hbox_monthday_start.add(gtk.Label("時")) hbox_monthday_start.add(spin_minute_start) hbox_monthday_start.add(gtk.Label("分")) vbox_calendar_start.add(calendar_start) vbox_calendar_start.add(hbox_monthday_start) vbox_calendar_end = gtk.VBox() vbox_calendar_end.add(gtk.Label("予定終了日")) calendar_end = gtk.Calendar() calendar_end.select_month(datetime_end.month-1, datetime_end.year) calendar_end.select_day(datetime_end.day) hbox_monthday_end = gtk.HBox() hour_end = gtk.Adjustment(value=0, lower=0, upper=12, step_incr=1) spin_hour_end = gtk.SpinButton(hour_end) minute_end = gtk.Adjustment(value=0, lower=0, upper=59, step_incr=1) spin_minute_end = gtk.SpinButton(minute_end) hbox_monthday_end.add(spin_hour_end) hbox_monthday_end.add(gtk.Label("時")) hbox_monthday_end.add(spin_minute_end) hbox_monthday_end.add(gtk.Label("分")) vbox_calendar_end.add(calendar_end) vbox_calendar_end.add(hbox_monthday_end) hbox_calendar.add(vbox_calendar_start) hbox_calendar.add(vbox_calendar_end) dlg_content.add(hbox_calendar) hbox_user = gtk.HBox() hbox_user.add(gtk.Label("Googleユーザ名")) text_entry_user = gtk.Entry() text_entry_user.set_text(user) hbox_user.add(text_entry_user) dlg_content.add(hbox_user) hbox_password = gtk.HBox() hbox_password.add(gtk.Label("パスワード")) text_entry_password = gtk.Entry() text_entry_password.set_width_chars(30) text_entry_password.set_visibility(False) text_entry_password.set_text(password) hbox_password.add(text_entry_password) dlg_content.add(hbox_password) dlg.show_all() ret = dlg.run() # ダイアログに設定された内容を読み取る if ret == gtk.RESPONSE_OK: # 予定 title = text_entry_title.get_text().decode('utf8') place = text_entry_place.get_text().decode('utf8') content = text_entry_content.get_text().decode('utf8') # 開始日 year, month, day = calendar_start.get_date() month = month + 1 hour = hour_start.get_value() minute = minute_start.get_value() datetime_start = datetime.datetime(int(year), int(month), int(day), int(hour), int(minute), 0) # 検索終了日 year, month, day = calendar_end.get_date() month = month + 1 hour = hour_end.get_value() minute = minute_end.get_value() datetime_end = datetime.datetime(int(year), int(month), int(day), int(hour), int(minute), 0) if datetime_end < datetime_start: datetime_end = datetime_start # 終日 allday = check_allday.get_active() # ユーザ名とパスワード user = text_entry_user.get_text().decode('utf8') password = text_entry_password.get_text().decode('utf8') else: return dlg.destroy() # Googleサーバに接続し、カレンダー イベントを追加する try: insert_event_google_calendar(datetime_start, datetime_end, allday, title, place, content, user, password) except: # 書きこみ失敗のメッセージボックスを表示 dlg = gtk.MessageDialog(type=gtk.MESSAGE_INFO, buttons=gtk.BUTTONS_OK, message_format='Googleカレンダーに書き込めません') dlg.set_title("GoogleカレンダーWriter") dlg.show_all() ret = dlg.run() dlg.destroy() return # ユーザ名とパスワードを設定ファイルに書きこんで保存する config_file_write(user, password) # 書きこみ成功のメッセージボックスを表示 dlg = gtk.MessageDialog(type=gtk.MESSAGE_INFO, buttons=gtk.BUTTONS_OK, message_format='予定を書き込みました') dlg.set_title("GoogleカレンダーWriter") dlg.show_all() ret = dlg.run() dlg.destroy()
def __init__(self, model, context): super(WinImport, self).__init__() self.dialog = gtk.Dialog(title=_("Import from CSV"), parent=self.parent, flags=gtk.DIALOG_DESTROY_WITH_PARENT) 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() 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_alignment(0.0, 0.0) img_button = gtk.Image() img_button.set_from_stock('tryton-list-add', gtk.ICON_SIZE_BUTTON) button_add.set_image(img_button) 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_alignment(0.0, 0.0) img_button = gtk.Image() img_button.set_from_stock('tryton-list-remove', gtk.ICON_SIZE_BUTTON) button_remove.set_image(img_button) 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_alignment(0.0, 0.0) img_button = gtk.Image() img_button.set_from_stock('tryton-clear', gtk.ICON_SIZE_BUTTON) button_remove_all.set_image(img_button) 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) button_autodetect = gtk.Button(_("Auto-Detect"), stock=None, use_underline=True) button_autodetect.set_alignment(0.0, 0.0) img_button = gtk.Image() img_button.set_from_stock('tryton-find', gtk.ICON_SIZE_BUTTON) button_autodetect.set_image(img_button) button_autodetect.connect_after('clicked', self.sig_autodetect) vbox_buttons.pack_start(button_autodetect, False, False, 0) frame_import = gtk.Frame() frame_import.set_shadow_type(gtk.SHADOW_NONE) viewport_import = gtk.Viewport() scrolledwindow_import = gtk.ScrolledWindow() scrolledwindow_import.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) viewport_import.add(scrolledwindow_import) frame_import.add(viewport_import) label_fields_import = gtk.Label(_("<b>Fields to import</b>")) label_fields_import.set_use_markup(True) frame_import.set_label_widget(label_fields_import) hbox_mapping.pack_start(frame_import, True, True, 0) frame_csv_param = gtk.Frame(None) 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) hbox_csv_import = gtk.HBox() vbox_csv_param.pack_start(hbox_csv_import, False, True, 4) label_csv_import = gtk.Label(_("File to Import:")) hbox_csv_import.pack_start(label_csv_import, False, False, 0) self.import_csv_file = gtk.FileChooserButton(_("Open...")) hbox_csv_import.pack_start(self.import_csv_file, True, True, 0) expander_csv_import = gtk.Expander(None) vbox_csv_param.pack_start(expander_csv_import, False, True, 0) label_import_csv_param = gtk.Label(_("CSV Parameters")) expander_csv_import.set_label_widget(label_import_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_import.add(table) label_import_csv_sep = gtk.Label(_("Field Separator:")) label_import_csv_sep.set_alignment(1, 0.5) table.attach(label_import_csv_sep, 0, 1, 0, 1) self.import_csv_sep = gtk.Entry() self.import_csv_sep.set_max_length(1) self.import_csv_sep.set_text(",") self.import_csv_sep.set_width_chars(1) table.attach(self.import_csv_sep, 1, 2, 0, 1) label_import_csv_del = gtk.Label(_("Text Delimiter:")) label_import_csv_del.set_alignment(1, 0.5) table.attach(label_import_csv_del, 2, 3, 0, 1) self.import_csv_del = gtk.Entry() self.import_csv_del.set_text("\"") self.import_csv_del.set_width_chars(1) table.attach(self.import_csv_del, 3, 4, 0, 1) label_import_csv_enc = gtk.Label(_("Encoding:")) label_import_csv_enc.set_alignment(1, 0.5) table.attach(label_import_csv_enc, 0, 1, 1, 2) self.import_csv_enc = gtk.combo_box_new_text() self.import_csv_enc.append_text("UTF-8") self.import_csv_enc.append_text("Latin1") self.import_csv_enc.set_active(0) table.attach(self.import_csv_enc, 1, 2, 1, 2) label_import_csv_skip = gtk.Label(_("Lines to Skip:")) label_import_csv_skip.set_alignment(1, 0.5) table.attach(label_import_csv_skip, 2, 3, 1, 2) self.import_csv_skip_adj = gtk.Adjustment(0, 0, 100, 1, 10) self.import_csv_skip = gtk.SpinButton(self.import_csv_skip_adj, 1, 0) table.attach(self.import_csv_skip, 3, 4, 1, 2) button_cancel = gtk.Button("gtk-cancel", stock="gtk-cancel") self.dialog.add_action_widget(button_cancel, gtk.RESPONSE_CANCEL) button_cancel.set_flags(gtk.CAN_DEFAULT) button_ok = gtk.Button("gtk-ok", stock="gtk-ok") self.dialog.add_action_widget(button_ok, gtk.RESPONSE_OK) button_ok.set_flags(gtk.CAN_DEFAULT) self.dialog.vbox.pack_start(dialog_vbox) self.model = model self.context = context self.fields_data = {} self.import_csv_file.set_current_folder(CONFIG['client.default_path']) 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_import.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, background=2) 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, gobject.TYPE_STRING) self.model2 = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING) self.fields = {} self.fields_invert = {} self.model_populate(self._get_fields(model)) self.view1.set_model(self.model1) self.view2.set_model(self.model2) sensible_allocation = self.sensible_widget.get_allocation() self.dialog.set_default_size(int(sensible_allocation.width * 0.9), int(sensible_allocation.height * 0.9)) self.dialog.show_all() common.center_window(self.dialog, self.parent, self.sensible_widget) self.register()
def _make_plugin_settings_widget(self, plugin_id): plugin_settings = plugins.get_plugin_attribute( plugin_id, plugins.settings_attribute) if not plugin_settings: return None title_label = gtk.Label() # TRANS: Plugin-specific configuration (header) title_label.set_markup(u"<b>%s</b>" % _("Configuration")) title_label.set_alignment(0, 0) vbox = gtk.VBox() vbox.pack_start(title_label, False) #vbox.set_property("spacing", 5) plugin_settings_keys = iter(plugin_settings) if plugin_settings else () for setting in plugin_settings_keys: typ = plugin_settings.get_value_type(setting) alternatives = plugin_settings.get_alternatives(setting) tooltip = plugin_settings.get_tooltip(setting) wid = None hbox = gtk.HBox() hbox.set_property("spacing", 10) if tooltip: hbox.set_tooltip_text(tooltip) label = plugin_settings.get_label(setting) if issubclass(typ, plugin_support.UserNamePassword): wid = gtk.Button(label or _("Set username and password")) wid.connect( "clicked", self._get_plugin_credentials_callback(plugin_id, setting)) hbox.pack_start(wid, False) vbox.pack_start(hbox, False) continue label_wid = wrapped_label(label, maxwid=200) if issubclass(typ, basestring): if alternatives: wid = gtk.combo_box_new_text() val = plugin_settings[setting] active_index = -1 for idx, text in enumerate(alternatives): wid.append_text(text) if text == val: active_index = idx if active_index < 0: wid.prepend_text(val) active_index = 0 wid.set_active(active_index) wid.connect( "changed", self._get_plugin_change_callback( plugin_id, setting, typ, "get_active_text")) else: wid = gtk.Entry() wid.set_text(plugin_settings[setting]) wid.connect( "changed", self._get_plugin_change_callback(plugin_id, setting, typ, "get_text", no_false_values=True)) hbox.pack_start(label_wid, False) hbox.pack_start(wid, True) elif issubclass(typ, bool): wid = gtk.CheckButton(label) wid.set_active(plugin_settings[setting]) hbox.pack_start(wid, False) wid.connect( "toggled", self._get_plugin_change_callback(plugin_id, setting, typ, "get_active")) elif issubclass(typ, int): wid = gtk.SpinButton() wid.set_increments(1, 1) wid.set_range(0, 1000) wid.set_value(plugin_settings[setting]) hbox.pack_start(label_wid, False) hbox.pack_start(wid, False) wid.connect( "changed", self._get_plugin_change_callback(plugin_id, setting, typ, "get_text", no_false_values=True)) vbox.pack_start(hbox, False) vbox.show_all() return vbox
def time_control(self, b): dialog = gtk.Dialog("Time Control", None, 0, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK)) dialog.set_title('Time Control') dialog.vbox.set_spacing(20) # list of time control types combobox = gtk.combo_box_new_text() combobox.append_text("Byoyomi") combobox.append_text("Classical") combobox.append_text("Incremental") combobox.append_text("Fixed Time Per Move") combobox.append_text("Fixed Search Depth") combobox.append_text("Infinite Search") combobox.append_text("Nodes") combobox.set_active(self.type) al = gtk.Alignment(xalign=0.0, yalign=1.0, xscale=0.0, yscale=0.5) # top, bottom, left, right al.set_padding(9, 0, 9, 9) al.add(combobox) dialog.vbox.pack_start(al, False, True, 5) self.combobox = combobox dialog.connect("expose_event", self.dialog_expose_event) # # settings for the byoyomi time control type # # byoyomi # e.g. 60 mins available time plus 10 seconds byoyomi # go btime 3600000 wtime 3600000 byoyomi 10000 # # list of time control vboxes. 1 per time control type self.tcvb = [ gtk.VBox(False, 0), gtk.VBox(False, 0), gtk.VBox(False, 0), gtk.VBox(False, 0), gtk.VBox(False, 0), gtk.VBox(False, 0), gtk.VBox(False, 0), gtk.VBox(False, 0) ] byo_frame1 = gtk.Frame("Available Time") vb = gtk.VBox(False, 0) byo_frame1.add(vb) # available time - hours minimum = 0 maximum = 10 default = self.byo_hours byo_adj_hours = gtk.Adjustment(float(default), float(minimum), float(maximum), 1, 5, 0) spinner = gtk.SpinButton(byo_adj_hours, 1.0, 0) al = gtk.Alignment(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0) al.add(spinner) hb = gtk.HBox(False, 0) hb.pack_start(gtk.Label("Hours:"), False, False, 0) hb.pack_start(al, True, True, 10) vb.pack_start(hb, False, True, 0) # available time - minutes minimum = 0 maximum = 59 default = self.byo_minutes byo_adj_mins = gtk.Adjustment(float(default), float(minimum), float(maximum), 1, 5, 0) spinner = gtk.SpinButton(byo_adj_mins, 1.0, 0) al = gtk.Alignment(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0) al.add(spinner) lbl = gtk.Label("Minutes :") hb = gtk.HBox(False, 0) hb.pack_start(lbl, False, False, 0) hb.pack_start(al, True, True, 10) vb.pack_start(hb, False, True, 0) # byoyomi - seconds byo_frame2 = gtk.Frame("Byoyomi") minimum = 0 maximum = 60 default = self.byo_byoyomi byo_adj_byoyomi = gtk.Adjustment(float(default), float(minimum), float(maximum), 1, 5, 0) spinner = gtk.SpinButton(byo_adj_byoyomi, 1.0, 0) al = gtk.Alignment(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0) al.add(spinner) hb = gtk.HBox(False, 0) hb.pack_start(gtk.Label("Seconds:"), False, False, 0) hb.pack_start(al, True, True, 10) byo_frame2.add(hb) self.tcvb[0].pack_start(byo_frame1, False, False, 0) self.tcvb[0].pack_start(byo_frame2, False, False, 0) self.tcvb[0].set_spacing(20) # # settings for the classical time control type # # classical # e.g. 40 moves in 5 minutes # go wtime 300000 btime 300000 movestogo 40 # cls_frame1 = gtk.Frame() vb = gtk.VBox(False, 0) cls_frame1.add(vb) adj_cls_settings = [] for i in range(0, self.cls_max_sessions): (moves_to_go, minutes, repeat_times) = self.cls_settings[i] # session hb = gtk.HBox(False, 0) if i != 0: vb.pack_start(gtk.HSeparator(), False, True, 0) hb.pack_start(gtk.Label('#' + str(i + 1)), False, False, 0) #if i != 0: # hb.pack_start(gtk.CheckButton(), True, True, 10) vb.pack_start(hb, False, True, 0) # moves minimum = 1 maximum = 200 default = moves_to_go #default = 40 #if i == 0: # default = 40 #else: # default = 0 adj_moves_to_go = gtk.Adjustment(float(default), float(minimum), float(maximum), 1, 5, 0) spinner = gtk.SpinButton(adj_moves_to_go, 1.0, 0) al = gtk.Alignment(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0) al.add(spinner) hb = gtk.HBox(False, 0) hb.pack_start(gtk.Label("Moves:"), False, False, 0) hb.pack_start(al, True, True, 10) vb.pack_start(hb, False, True, 0) # minutes minimum = 0 maximum = 500 #default = 5 default = minutes #if i == 0: # default = 5 #else: # default = 0 adj_cls_mins = gtk.Adjustment(float(default), float(minimum), float(maximum), 1, 5, 0) spinner = gtk.SpinButton(adj_cls_mins, 1.0, 0) al = gtk.Alignment(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0) al.add(spinner) lbl = gtk.Label("Minutes :") hb = gtk.HBox(False, 0) hb.pack_start(lbl, False, False, 0) hb.pack_start(al, True, True, 10) vb.pack_start(hb, False, True, 0) # repeating minimum = 0 maximum = 9 default = repeat_times #if i == 0: # default = 1 #else: # default = 0 adj_cls_repeat = gtk.Adjustment(float(default), float(minimum), float(maximum), 1, 5, 0) spinner = gtk.SpinButton(adj_cls_repeat, 1.0, 0) al = gtk.Alignment(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0) al.add(spinner) lbl = gtk.Label("Count :") hb = gtk.HBox(False, 0) hb.pack_start(lbl, False, False, 0) hb.pack_start(al, True, True, 10) vb.pack_start(hb, False, True, 0) # enabled #lbl = gtk.Label("Enabled :") #hb = gtk.HBox(False, 0) #hb.pack_start(lbl, False, False, 0) #hb.pack_start(gtk.CheckButton(), True, True, 10) #vb.pack_start(hb, False, True, 0) adj_cls_settings.append( (adj_moves_to_go, adj_cls_mins, adj_cls_repeat)) self.tcvb[1].pack_start(cls_frame1, False, False, 0) # Blitz (incremental) # e.g. 2 mins 0 seconds for whole game, 6 seconds 0 milliseconds bonus per move # base is for whole game, bonus will be given for every move made # go wtime 126000 btime 120000 winc 6000 binc 6000 # go wtime 130591 btime 118314 winc 6000 binc 6000 # go wtime 135329 btime 118947 winc 6000 binc 6000 inc_frame1 = gtk.Frame("Time") vb = gtk.VBox(False, 0) inc_frame1.add(vb) # available time - hours minimum = 0 maximum = 10 default = self.inc_hours inc_adj_hours = gtk.Adjustment(float(default), float(minimum), float(maximum), 1, 5, 0) spinner = gtk.SpinButton(inc_adj_hours, 1.0, 0) al = gtk.Alignment(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0) al.add(spinner) hb = gtk.HBox(False, 0) hb.pack_start(gtk.Label("Hours:"), False, False, 0) hb.pack_start(al, True, True, 10) vb.pack_start(hb, False, True, 0) # available time - minutes minimum = 0 maximum = 59 default = self.inc_minutes inc_adj_mins = gtk.Adjustment(float(default), float(minimum), float(maximum), 1, 5, 0) spinner = gtk.SpinButton(inc_adj_mins, 1.0, 0) al = gtk.Alignment(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0) al.add(spinner) lbl = gtk.Label("Minutes :") hb = gtk.HBox(False, 0) hb.pack_start(lbl, False, False, 0) hb.pack_start(al, True, True, 10) vb.pack_start(hb, False, True, 0) # bonus time per move - seconds inc_frame2 = gtk.Frame("Bonus Time per Move") minimum = 0 maximum = 60 default = self.inc_bonus inc_adj_bonus = gtk.Adjustment(float(default), float(minimum), float(maximum), 1, 5, 0) spinner = gtk.SpinButton(inc_adj_bonus, 1.0, 0) al = gtk.Alignment(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0) al.add(spinner) hb = gtk.HBox(False, 0) hb.pack_start(gtk.Label("Seconds:"), False, False, 0) hb.pack_start(al, True, True, 10) inc_frame2.add(hb) self.tcvb[2].pack_start(inc_frame1, False, False, 0) self.tcvb[2].pack_start(inc_frame2, False, False, 0) self.tcvb[2].set_spacing(20) # # settings for the fixed time per move time control type # # fixed time per move # e.g. 6 seconds per move # go movetime 6000 #ftpm_frame1 = gtk.Frame("Fixed Time Per Move") ftpm_frame1 = gtk.Frame() ftpm_frame1.set_shadow_type(gtk.SHADOW_NONE) vb = gtk.VBox(False, 0) ftpm_frame1.add(vb) # seconds per move minimum = 0 maximum = 10000 default = self.ftpm_seconds adj_ftpm_secs = gtk.Adjustment(float(default), float(minimum), float(maximum), 1, 5, 0) spinner = gtk.SpinButton(adj_ftpm_secs, 1.0, 0) al = gtk.Alignment(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0) al.add(spinner) lbl = gtk.Label("Seconds :") hb = gtk.HBox(False, 0) hb.pack_start(lbl, False, False, 0) hb.pack_start(al, True, True, 10) vb.pack_start(hb, False, True, 0) self.tcvb[3].pack_start(ftpm_frame1, False, False, 0) # # settings for the fixed search depth time control type # # fixed search depth # e.g. # go depth 8 dpth_frame1 = gtk.Frame() dpth_frame1.set_shadow_type(gtk.SHADOW_NONE) vb = gtk.VBox(False, 0) dpth_frame1.add(vb) # depth minimum = 0 maximum = 999 default = self.dpth_depth adj_dpth_depth = gtk.Adjustment(float(default), float(minimum), float(maximum), 1, 5, 0) spinner = gtk.SpinButton(adj_dpth_depth, 1.0, 0) al = gtk.Alignment(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0) al.add(spinner) lbl = gtk.Label("Search Depth :") hb = gtk.HBox(False, 0) hb.pack_start(lbl, False, False, 0) hb.pack_start(al, True, True, 10) vb.pack_start(hb, False, True, 0) self.tcvb[4].pack_start(dpth_frame1, False, False, 0) # calculate to engines maximum search depth # (sends back bestmove if it gets the stop command) # go infinite # there are no cutomisable options for go infinite self.tcvb[5].pack_start(gtk.Label("No customisable options")) # # settings for the fixed no. of nodes time control type # # fixed no. of nodes # e.g. search for 1 million nodes # go nodes 1000000 nodes_frame1 = gtk.Frame() nodes_frame1.set_shadow_type(gtk.SHADOW_NONE) vb = gtk.VBox(False, 0) nodes_frame1.add(vb) # nodes minimum = 1 maximum = 2000000000 default = self.nodes_nodes adj_nodes_nodes = gtk.Adjustment(float(default), float(minimum), float(maximum), 1, 5, 0) spinner = gtk.SpinButton(adj_nodes_nodes, 1.0, 0) al = gtk.Alignment(xalign=1.0, yalign=0.0, xscale=0.0, yscale=0.0) al.add(spinner) lbl = gtk.Label("No. of Nodes to Search :") hb = gtk.HBox(False, 0) hb.pack_start(lbl, False, False, 0) hb.pack_start(al, True, True, 10) vb.pack_start(hb, False, True, 0) self.tcvb[6].pack_start(nodes_frame1, False, False, 0) # mate search # e.g. look for mate in 5 moves # go mate 5 self.al = gtk.Alignment(xalign=0.5, yalign=0.5, xscale=1.0, yscale=0.0) # top, bottom, left, right self.al.set_padding(0, 0, 9, 9) self.al.add(self.tcvb[self.type]) dialog.vbox.pack_start(self.al, False, True, 0) combobox.connect("changed", self.tc_method_changed, dialog) dialog.set_default_response(gtk.RESPONSE_OK) dialog.show_all() self.set_frame_visibility(self.type) while True: response = dialog.run() if response != gtk.RESPONSE_OK: # cancelled - exit loop break # OK pressed - validate input" #print "ok pressed" self.type = combobox.get_active() # byoyomi if self.type == 0: byo_hours = int(byo_adj_hours.value) byo_minutes = int(byo_adj_mins.value) byo_byoyomi = int(byo_adj_byoyomi.value) if byo_hours == 0 and byo_minutes == 0 and byo_byoyomi == 0: self.gui.info_box("Time fields cannot all be zero!") else: # input ok - exit loop self.byo_hours = byo_hours self.byo_minutes = byo_minutes self.byo_byoyomi = byo_byoyomi self.reset_clock() self.set_toolbar_time_control(self.type, 0, WHITE) self.set_toolbar_time_control(self.type, 0, BLACK) break # classical elif self.type == 1: self.cls_settings = [] rep_zero = True for i in range(0, self.cls_max_sessions): moves_to_go, mins, rep = adj_cls_settings[i] if rep.value != 0: rep_zero = False if rep_zero: self.gui.info_box("Count fields cannot all be zero!") else: for i in range(0, self.cls_max_sessions): moves_to_go, mins, rep = adj_cls_settings[i] self.cls_settings.append( (moves_to_go.value, mins.value, rep.value)) # fields for go command self.reset_clock() self.set_toolbar_time_control(self.type, 0, WHITE) self.set_toolbar_time_control(self.type, 0, BLACK) break # incremental if self.type == 2: inc_hours = int(inc_adj_hours.value) inc_minutes = int(inc_adj_mins.value) inc_bonus = int(inc_adj_bonus.value) if inc_hours == 0 and inc_minutes == 0 and inc_bonus == 0: self.gui.info_box( "Incremental Time fields cannot all be zero!") else: # input ok - exit loop self.inc_hours = inc_hours self.inc_minutes = inc_minutes self.inc_bonus = inc_bonus self.reset_clock() self.set_toolbar_time_control(self.type, 0, WHITE) self.set_toolbar_time_control(self.type, 0, BLACK) break # fixed time per move elif self.type == 3: self.ftpm_seconds = int(adj_ftpm_secs.value) # fields for go command self.reset_clock() self.set_toolbar_time_control(self.type, 0, WHITE) self.set_toolbar_time_control(self.type, 0, BLACK) break # fixed search depth elif self.type == 4: self.dpth_depth = int(adj_dpth_depth.value) # fields for go command self.reset_clock() self.set_toolbar_time_control(self.type, 0, WHITE) self.set_toolbar_time_control(self.type, 0, BLACK) break # infinite search elif self.type == 5: break # fixed number of nodes search elif self.type == 6: self.nodes_nodes = int(adj_nodes_nodes.value) # fields for go command self.reset_clock() self.set_toolbar_time_control(self.type, 0, WHITE) self.set_toolbar_time_control(self.type, 0, BLACK) break dialog.destroy()
def _create_layout(self): self._option_frame = gtk.Frame() self._option_frame.set_label(_L('Options')) self._option_vbox = gtk.VBox() self._option_frame.add(self._option_vbox) self._name_entry = gtk.Entry() self._option_vbox.pack_start( gui.pack_hbox([gtk.Label(_L('Name')), self._name_entry]), False, False) self._delay = gtk.SpinButton(climb_rate=0.1, digits=0) self._delay.set_range(0, 100000) self._delay.set_increments(1, 2) self._delay.set_value(100) self._option_vbox.pack_start( gui.pack_hbox([gtk.Label(_L('Delay (ms)')), self._delay]), False, False) self._plot_type_combo = gtk.combo_box_new_text() self._plot_type_combo.append_text(_L('Image')) self._plot_type_combo.append_text(_L('Line')) self._plot_type_combo.connect('changed', self._plot_type_changed_cb) self._plot_type_combo.set_active(0) self._option_vbox.pack_start( gui.pack_hbox([gtk.Label(_L('Plot type')), self._plot_type_combo])) self._hold_check = gtk.CheckButton() self._hold_check.connect('toggled', self._hold_toggled_cb) self._option_vbox.pack_start( gui.pack_hbox([gtk.Label(_L('Hold')), self._hold_check])) self._sweep_z = QTSweepVarSettings('Z loop') self._sweep_y = QTSweepVarSettings('Y loop') self._sweep_x = QTSweepVarSettings('X loop') self._measure_1 = QTMeasureVarSettings('Measurement 1') self._measure_2 = QTMeasureVarSettings('Measurement 2') self._start_but = gtk.Button(_L('Start')) self._start_but.connect('clicked', self._start_clicked_cb) self._stop_but = gtk.Button(_L('Stop')) self._stop_but.connect('clicked', self._stop_clicked_cb) self._stop_but.set_sensitive(False) self._status_label = gtk.Label(_L('Idle')) self._vbox = gtk.VBox() self._vbox.pack_start(self._option_frame, False, False) self._vbox.pack_start(self._sweep_z.get_layout(), False, False) self._vbox.pack_start(self._sweep_y.get_layout(), False, False) self._vbox.pack_start(self._sweep_x.get_layout(), False, False) self._vbox.pack_start(self._measure_1.get_layout(), False, False) self._vbox.pack_start(self._measure_2.get_layout(), False, False) self._vbox.pack_start(gui.pack_hbox([self._start_but, self._stop_but]), False, False) self._vbox.pack_start(self._status_label) self.add(self._vbox) self._vbox.show_all()
def add(self, widget): WidgetName = type(widget) #finding type of widget being added #print WidgetName if (WidgetName == Button): #if added widget is button widget.controller = gtk.Button( widget.text) #setting name for button widget.controller.set_size_request( widget.width, widget.height) #setting the size of button self.fixed.put(widget.controller, widget.position_X, widget.position_Y) #setting location for button widget.controller.show() #showing the button if (widget.callbackMethod != None): #setting callback method for button widget.controller.connect('clicked', widget.callbackMethod) elif (WidgetName == TextArea): #if added widget is TextArea widget.controller = gtk.TextView( widget.buffer) #setting buffer for the TextArea widget.controller.set_size_request( widget.width, widget.height) #setting the size of TextArea self.fixed.put(widget.controller, widget.position_X, widget.position_Y) # setting location for TextArea widget.controller.show() #showing the TextArea if (widget.callbackMethod != None): widget.controller.connect( 'clicked', widget.callbackMethod) #adding callback method to Textarea elif (WidgetName == TextLine): #if widget added is TextLine widget.controller = gtk.Entry() #setting a widget for TextLine widget.controller.set_size_request( widget.width, widget.height) #setting the size of TextLine self.fixed.put(widget.controller, widget.position_X, widget.position_Y) # setting location for TextLine widget.controller.show() #showing the TextLine elif (WidgetName == CheckBox): #if widget added is CheckBox widget.controller = gtk.CheckButton( widget.title) #setting name for CheckBox widget.controller.set_size_request( widget.width, widget.height) #setting the size of CheckBox self.fixed.put(widget.controller, widget.position_X, widget.position_Y) #setting location for CheckBox widget.controller.show() #showing the CheckBox widget.controller.set_active( widget.value) #activating the CheckBox #### elif (WidgetName == Password): #if widget added is Password widget.controller = gtk.Entry() #adding a TextLine for Password widget.controller.set_visibility( 0) #making the characters invisible widget.controller.set_size_request( widget.width, widget.height) #setting the size of PassWord self.fixed.put( widget.controller, widget.position_X, widget.position_Y) #setting the position of PassWord widget.controller.show() elif (WidgetName == Slider): #if widget added is Slider widget.controller = gtk.HScale() #getting a Widget for Hscale widget.controller.set_range( widget.start, widget.end) #setting the range of Slider Widget widget.controller.set_size_request( widget.width, widget.height) #setting the size of Slider self.fixed.put(widget.controller, widget.position_X, widget.position_Y) #setting the position of Slider widget.controller.show() elif (WidgetName == SpinBox): #if widget added is SpinBox widget.controller = gtk.SpinButton( ) #getting a SpinButton for SpinBox widget.controller.set_range( widget.start, widget.end) #setting the range of SpinBox Widget widget.controller.set_increments( 1, 1) #setting the increment for SpinBox widget.controller.set_size_request( widget.width, widget.height) ##setting the size of SpinBox self.fixed.put(widget.controller, widget.position_X, widget.position_Y) #setting the size of SpinBox widget.controller.show() elif (WidgetName == Label): #if widget added is Label widget.controller = gtk.Label( widget.text) #getting a Label with widget.text widget.controller.set_size_request( widget.width, widget.height) #setting the size of Label self.fixed.put(widget.controller, widget.position_X, widget.position_Y) #setting the position of Label widget.controller.show() ### elif (WidgetName == RadioGroup): #if widget added is RadioGroup widget.controller = [] # radio_controller = gtk.RadioButton( None, widget.labels[0]) #getting RadioButtons for the group radio_controller.set_size_request( widget.width, widget.height) #setting the size of RadioGroup self.fixed.put( radio_controller, widget.position_X[0], widget.position_Y[0]) #setting the position of RadioGroup radio_controller.show() #showing the RadioButton widget.controller.append( radio_controller) #appending RadioButton to RadioController for i in range( 1, len(widget.labels) ): #for adding the remaining RadioButtons we have used the same procedure radio_controller = gtk.RadioButton(widget.controller[0], widget.labels[i]) radio_controller.set_size_request(widget.width, widget.height) self.fixed.put(radio_controller, widget.position_X[i], widget.position_Y[i]) radio_controller.show() widget.controller.append(radio_controller) if ( widget.selected_pos != None ): #setting the position of the selected RadioButton if it is not NULL widget.controller[widget.selected_pos].set_active(True) elif (WidgetName == DropDownList): #if widget added is DropDownList widget.controller = gtk.OptionMenu( ) #gettin an Option Menu for DropDownList widget.controller.set_size_request( widget.width, widget.height) #setting the size of DropDownList menu = gtk.Menu() for name in widget.choices: #adding menus in the menubar item = gtk.MenuItem(name) # item.show() #showing the items added menu.append(item) #appending item to the menu widget.controller.set_menu(menu) widget.controller.show() #showing the OptionMenu self.fixed.put( widget.controller, widget.position_X, widget.position_Y) #setting the position of DropDownList elif (WidgetName == SelectList): #if widget is SelectList store = gtk.ListStore( str ) #making a store variable to store the values Of SelectList for act in widget.choices: store.append([act]) #storing the values in store variable widget.controller = gtk.TreeView( store) # making a TreeView for the values in List widget.controller.show() widget.controller.set_size_request( widget.width, widget.height) #setting the size of SelectList self.fixed.put( widget.controller, widget.position_X, widget.position_Y) #setting the position of SelectList rendererText = gtk.CellRendererText() column = gtk.TreeViewColumn( "", rendererText, text=0) #making columns for the values stored in store column.set_sort_column_id(0) widget.controller.append_column( column) #appending the columns to SelectList
def _build_widget(self): self.adjust = gtk.Adjustment(lower=self.minimum, upper=self.maximum, step_incr=self.step) self.widget = gtk.SpinButton(self.adjust) self.widget.connect("value-changed", self._value_changed)
)) dialog.connect("response", lambda d, id: start(id)) table = gtk.Table(2, 2) table.show() dialog.vbox.pack_start(table) ehost = gtk.Entry() ehost.set_text('localhost') ehost.show() lbl = gtk.Label("Host: ") lbl.show() table.attach(lbl, 0, 1, 0, 1) table.attach(ehost, 1, 2, 0, 1) eport = gtk.SpinButton() eport.set_range(0, 99999) eport.set_increments(1, 10) eport.set_value(port) eport.show() lbl = gtk.Label("Port: ") lbl.show() table.attach(lbl, 0, 1, 1, 2) table.attach(eport, 1, 2, 1, 2) # Settings for automatic liquidsoap run erunconf = gtk.Table(2, 7) enable_mic = gtk.CheckButton( "Use microphone input (may not be functional)") enable_mic.show()
def __init__(self, project): gtk.Dialog.__init__(self, 'Project Settings', None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, (gtk.STOCK_OK, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)) self.set_default_response(gtk.RESPONSE_OK) self.project = project # Set up some spacing values for the UI layout. insideframe_padding = 14 tabpadding_tops = 24 tabpadding_sides = 18 # Set up the tabs ("notebook") for the project settings. nb = gtk.Notebook() nb.set_border_width(8) nb.set_tab_pos(gtk.POS_TOP) # Create the UI elements for the trace file settings tab. mainvb = gtk.VBox(False, 16) tracevb = gtk.VBox(False, 20) tracevb.set_border_width(insideframe_padding) # Get the consensus sequence settings from the project. cssettings = self.project.getConsensSeqSettings() # Set up UI components for the trace file location. vb = gtk.VBox() tf_hb1 = gtk.HBox() tf_hb1.pack_start(gtk.Label('Location of trace files:'), False) tf_hb2 = gtk.HBox() self.fc_entry = gtk.Entry() self.fc_entry.set_width_chars(40) self.fc_entry.set_text(self.project.getTraceFileDir()) tf_hb2.pack_start(self.fc_entry) # use the STOCK_DIRECTORY icon for the button gtk.stock_add([('choose_dir', 'C_hoose...', 0, 0, None)]) icfact = gtk.IconFactory() icfact.add_default() icfact.add('choose_dir', self.get_style().lookup_icon_set(gtk.STOCK_DIRECTORY)) fc_button = gtk.Button(stock='choose_dir') fc_button.connect('clicked', self.chooseDirectory, self.fc_entry) #fc_button.set_label('Choose...') tf_hb2.pack_start(fc_button) vb.pack_start(tf_hb1) vb.pack_start(tf_hb2) self.fc_checkbox = gtk.CheckButton('Use relative folder path') if os.path.isabs(self.project.getTraceFileDir()): self.fc_checkbox.set_active(False) else: self.fc_checkbox.set_active(True) self.fc_cb_hid = self.fc_checkbox.connect('toggled', self.useRelPathToggled) vb.pack_start(self.fc_checkbox) tracevb.pack_start(vb) # Set up UI components for the forward/reverse trace file search strings. vb = gtk.VBox() tfs_hb1 = gtk.HBox() tfs_hb1.pack_start(gtk.Label('Search strings for identifying forward and reverse trace files:'), False) # Create a layout table for the labels and text entries. table = gtk.Table(2, 2) self.tfs_fwd_entry = gtk.Entry() self.tfs_fwd_entry.set_width_chars(12) self.tfs_fwd_entry.set_text(self.project.getFwdTraceSearchStr()) table.attach(gtk.Label('Forward: '), 0, 1, 0, 1, xoptions=0) table.attach(self.tfs_fwd_entry, 1, 2, 0, 1, xoptions=0) self.tfs_rev_entry = gtk.Entry() self.tfs_rev_entry.set_width_chars(12) self.tfs_rev_entry.set_text(self.project.getRevTraceSearchStr()) table.attach(gtk.Label('Reverse: '), 0, 1, 1, 2, xoptions=0) table.attach(self.tfs_rev_entry, 1, 2, 1, 2, xoptions=0) vb.pack_start(tfs_hb1) vb.pack_start(table) tracevb.pack_start(vb) frame = gtk.Frame('Trace files') frame.add(tracevb) mainvb.pack_start(frame) # Set up UI components for the forward/reverse primer strings. vb = gtk.VBox() vb = gtk.VBox(False, 20) vb.set_border_width(insideframe_padding) # Create a layout table for the labels and text entries. table = gtk.Table(2, 2) self.fwdprimer_entry = gtk.Entry() self.fwdprimer_entry.set_width_chars(38) self.fwdprimer_entry.set_text(cssettings.getForwardPrimer()) table.attach(gtk.Label('Forward primer: '), 0, 1, 0, 1, xoptions=0) table.attach(self.fwdprimer_entry, 1, 2, 0, 1, xoptions=0) self.revprimer_entry = gtk.Entry() self.revprimer_entry.set_width_chars(38) self.revprimer_entry.set_text(cssettings.getReversePrimer()) table.attach(gtk.Label('Reverse primer: '), 0, 1, 1, 2, xoptions=0) table.attach(self.revprimer_entry, 1, 2, 1, 2, xoptions=0) vb.pack_start(table) frame = gtk.Frame("Primer sequences (5' to 3')") frame.add(vb) mainvb.pack_start(frame) # Use another VBox to get extra padding on the sides. vbpad = gtk.VBox(False, 0) vbpad.set_border_width(tabpadding_sides) vbpad.pack_start(mainvb, expand=False, padding=(tabpadding_tops - tabpadding_sides)) nb.append_page(vbpad, gtk.Label('Trace settings')) # Create the UI components for the sequence processing tab. mainvb = gtk.VBox(False, 16) # Set up UI components for choosing the confidence score cutoff value. vb = gtk.VBox(False, 12) vb.set_border_width(insideframe_padding) hb1 = gtk.HBox() hb1.pack_start(gtk.Label('Min. confidence score: '), False) self.ph_adj = gtk.Adjustment(cssettings.getMinConfScore(), 1, 61, 1) spin = gtk.SpinButton(self.ph_adj) hb1.pack_start(spin, False, False) vb.pack_start(hb1) # Create the UI components for choosing a consensus algorithm. hb1 = gtk.HBox() hb1.pack_start(gtk.Label('Consensus algorithm: '), False) self.cons_bayes_rb = gtk.RadioButton(None, 'Bayesian ') hb1.pack_start(self.cons_bayes_rb, False) self.cons_legacy_rb = gtk.RadioButton(self.cons_bayes_rb, 'SeqTrace 0.8') if cssettings.getConsensusAlgorithm() == 'Bayesian': self.cons_bayes_rb.set_active(True) else: self.cons_legacy_rb.set_active(True) hb1.pack_start(self.cons_legacy_rb) vb.pack_start(hb1) frame = gtk.Frame('Consensus settings') frame.add(vb) mainvb.pack_start(frame) # Set up UI components for sequence trimming settings. vb = gtk.VBox(False, 24) vb.set_border_width(insideframe_padding) self.autotrim_checkbox = gtk.CheckButton('Automatically trim sequence ends') self.autotrim_checkbox.connect('toggled', self.autoTrimToggled) vb.pack_start(self.autotrim_checkbox) # Create UI components for primer trimming. vb2 = gtk.VBox(False, 6) hb2 = gtk.HBox() self.trimprimers_checkbox = gtk.CheckButton('Trim primers if ') self.trimprimers_checkbox.set_active(cssettings.getTrimPrimers()) hb2.pack_start(self.trimprimers_checkbox, False) self.primermatch_th_adj = gtk.Adjustment(int(cssettings.getPrimerMatchThreshold() * 100), 1, 100, 1) self.primermatch_th_spin = gtk.SpinButton(self.primermatch_th_adj) hb2.pack_start(self.primermatch_th_spin, False, False) self.trimprimers_label = gtk.Label(' % of the primer alignment matches.') hb2.pack_start(self.trimprimers_label, False) vb2.pack_start(hb2) # Check box for end gap trimming. self.trimgaps_checkbox = gtk.CheckButton('Trim alignment end gap regions') self.trimgaps_checkbox.set_active(cssettings.getTrimEndGaps()) vb2.pack_start(self.trimgaps_checkbox) qualtrim_winsize, qualtrim_basecnt = cssettings.getQualityTrimParams() # Check box and spin buttons for end quality trimming. hb2 = gtk.HBox() self.qualtrim_checkbox = gtk.CheckButton('Trim until at least ') self.qualtrim_checkbox.set_active(cssettings.getDoQualityTrim()) hb2.pack_start(self.qualtrim_checkbox, False) self.qualtrim_basecnt_adj = gtk.Adjustment(qualtrim_basecnt, 1, qualtrim_winsize, 1) self.qualtrim_basecnt_spin = gtk.SpinButton(self.qualtrim_basecnt_adj) hb2.pack_start(self.qualtrim_basecnt_spin, False, False) self.qualtrim_label1 = gtk.Label(' out of ') hb2.pack_start(self.qualtrim_label1, False) self.qualtrim_winsize_adj = gtk.Adjustment(qualtrim_winsize, 1, 20, 1) self.qualtrim_winsize_spin = gtk.SpinButton(self.qualtrim_winsize_adj) hb2.pack_start(self.qualtrim_winsize_spin, False, False) self.qualtrim_winsize_adj.connect('value_changed', self.autoTrimWinSizeChanged) self.qualtrim_label2 = gtk.Label(' bases are correctly called.') hb2.pack_start(self.qualtrim_label2, False) vb2.pack_start(hb2) self.autotrim_checkbox.set_active(cssettings.getTrimConsensus()) self.autotrim_checkbox.toggled() vb.pack_start(vb2) frame = gtk.Frame('Sequence trimming') frame.add(vb) mainvb.pack_start(frame) # Use another VBox to get extra padding on the sides. vbpad = gtk.VBox(False, 0) vbpad.set_border_width(tabpadding_sides) vbpad.pack_start(mainvb, expand=False, padding=(tabpadding_tops - tabpadding_sides)) nb.append_page(vbpad, gtk.Label('Sequence processing')) self.vbox.pack_start(nb) self.vbox.show_all()
def dialog_tablehandle(self, title, is_insert): """Opens the Table Handle Dialog""" dialog = gtk.Dialog(title=title, parent=self.dad.window, flags=gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT)) dialog.set_default_size(300, -1) dialog.set_position(gtk.WIN_POS_CENTER_ON_PARENT) label_rows = gtk.Label(_("Rows")) adj_rows = gtk.Adjustment(value=self.dad.table_rows, lower=1, upper=10000, step_incr=1) spinbutton_rows = gtk.SpinButton(adj_rows) spinbutton_rows.set_value(self.dad.table_rows) label_columns = gtk.Label(_("Columns")) adj_columns = gtk.Adjustment(value=self.dad.table_columns, lower=1, upper=10000, step_incr=1) spinbutton_columns = gtk.SpinButton(adj_columns) spinbutton_columns.set_value(self.dad.table_columns) hbox_rows_cols = gtk.HBox() hbox_rows_cols.pack_start(label_rows, expand=False) hbox_rows_cols.pack_start(spinbutton_rows, expand=False) hbox_rows_cols.pack_start(label_columns, expand=False) hbox_rows_cols.pack_start(spinbutton_columns, expand=False) hbox_rows_cols.set_spacing(5) size_align = gtk.Alignment() size_align.set_padding(6, 6, 6, 6) size_align.add(hbox_rows_cols) size_frame = gtk.Frame(label="<b>" + _("Table Size") + "</b>") size_frame.get_label_widget().set_use_markup(True) size_frame.set_shadow_type(gtk.SHADOW_NONE) size_frame.add(size_align) label_col_min = gtk.Label(_("Min Width")) adj_col_min = gtk.Adjustment(value=self.dad.table_col_min, lower=1, upper=10000, step_incr=1) spinbutton_col_min = gtk.SpinButton(adj_col_min) spinbutton_col_min.set_value(self.dad.table_col_min) label_col_max = gtk.Label(_("Max Width")) adj_col_max = gtk.Adjustment(value=self.dad.table_col_max, lower=1, upper=10000, step_incr=1) spinbutton_col_max = gtk.SpinButton(adj_col_max) spinbutton_col_max.set_value(self.dad.table_col_max) hbox_col_min_max = gtk.HBox() hbox_col_min_max.pack_start(label_col_min, expand=False) hbox_col_min_max.pack_start(spinbutton_col_min, expand=False) hbox_col_min_max.pack_start(label_col_max, expand=False) hbox_col_min_max.pack_start(spinbutton_col_max, expand=False) hbox_col_min_max.set_spacing(5) col_min_max_align = gtk.Alignment() col_min_max_align.set_padding(6, 6, 6, 6) col_min_max_align.add(hbox_col_min_max) col_min_max_frame = gtk.Frame(label="<b>" + _("Column Properties") + "</b>") col_min_max_frame.get_label_widget().set_use_markup(True) col_min_max_frame.set_shadow_type(gtk.SHADOW_NONE) col_min_max_frame.add(col_min_max_align) checkbutton_table_ins_from_file = gtk.CheckButton(label=_("Import from CSV File")) content_area = dialog.get_content_area() content_area.set_spacing(5) if is_insert: content_area.pack_start(size_frame) content_area.pack_start(col_min_max_frame) if is_insert: content_area.pack_start(checkbutton_table_ins_from_file) content_area.show_all() def on_key_press_tablehandle(widget, event): keyname = gtk.gdk.keyval_name(event.keyval) if keyname == cons.STR_KEY_RETURN: spinbutton_rows.update() spinbutton_columns.update() spinbutton_col_min.update() spinbutton_col_max.update() try: dialog.get_widget_for_response(gtk.RESPONSE_ACCEPT).clicked() except: print cons.STR_PYGTK_222_REQUIRED return True return False def on_checkbutton_table_ins_from_file_toggled(checkbutton): size_frame.set_sensitive(not checkbutton.get_active()) col_min_max_frame.set_sensitive(not checkbutton.get_active()) dialog.connect('key_press_event', on_key_press_tablehandle) checkbutton_table_ins_from_file.connect('toggled', on_checkbutton_table_ins_from_file_toggled) response = dialog.run() dialog.hide() if response == gtk.RESPONSE_ACCEPT: self.dad.table_rows = int(spinbutton_rows.get_value()) self.dad.table_columns = int(spinbutton_columns.get_value()) self.dad.table_col_min = int(spinbutton_col_min.get_value()) self.dad.table_col_max = int(spinbutton_col_max.get_value()) ret_csv = checkbutton_table_ins_from_file.get_active() return [True, ret_csv] return [False, None]
def __init__(self, configurator, handler, curr_sdk_mach, curr_distro, pclass, pmake, bbthread, selected_image_types, all_image_types, gplv3disabled, build_toolchain, build_toolchain_headers): """ """ gtk.Dialog.__init__(self, "Preferences", None, gtk.DIALOG_DESTROY_WITH_PARENT, (gtk.STOCK_CLOSE, gtk.RESPONSE_OK)) self.set_border_width(6) self.vbox.set_property("spacing", 12) self.action_area.set_property("spacing", 12) self.action_area.set_property("border-width", 6) self.handler = handler self.configurator = configurator self.curr_sdk_mach = curr_sdk_mach self.curr_distro = curr_distro self.curr_package_format = pclass self.pmake = pmake self.bbthread = bbthread self.selected_image_types = selected_image_types.split(" ") self.gplv3disabled = gplv3disabled self.build_toolchain = build_toolchain self.build_toolchain_headers = build_toolchain_headers self.reload_required = False self.distro_handler_id = None self.sdk_machine_handler_id = None self.package_handler_id = None left = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL) right = gtk.SizeGroup(gtk.SIZE_GROUP_HORIZONTAL) label = gtk.Label() label.set_markup("<b>Policy</b>") label.show() frame = gtk.Frame() frame.set_label_widget(label) frame.set_shadow_type(gtk.SHADOW_NONE) frame.show() self.vbox.pack_start(frame) pbox = gtk.VBox(False, 12) pbox.show() frame.add(pbox) hbox = gtk.HBox(False, 12) hbox.show() pbox.pack_start(hbox, expand=False, fill=False, padding=6) # Distro selector label = gtk.Label("Distribution:") label.show() hbox.pack_start(label, expand=False, fill=False, padding=6) self.distro_combo = gtk.combo_box_new_text() self.distro_combo.set_tooltip_text("Select the Yocto distribution you would like to use") self.distro_combo.show() hbox.pack_start(self.distro_combo, expand=False, fill=False, padding=6) # Exclude GPLv3 check = gtk.CheckButton("Exclude GPLv3 packages") check.set_tooltip_text("Check this box to prevent GPLv3 packages from being included in your image") check.show() check.set_active(self.gplv3disabled) check.connect("toggled", self.include_gplv3_cb) hbox.pack_start(check, expand=False, fill=False, padding=6) hbox = gtk.HBox(False, 12) hbox.show() pbox.pack_start(hbox, expand=False, fill=False, padding=6) # Package format selector label = gtk.Label("Package format:") label.show() hbox.pack_start(label, expand=False, fill=False, padding=6) self.package_combo = gtk.combo_box_new_text() self.package_combo.set_tooltip_text("""The package format is that used in creation of the root filesystem and also dictates the package manager used in your image""") self.package_combo.show() hbox.pack_start(self.package_combo, expand=False, fill=False, padding=6) if all_image_types: # Image output type selector label = gtk.Label("Image output types:") label.show() hbox.pack_start(label, expand=False, fill=False, padding=6) chk_cnt = 3 for it in all_image_types.split(" "): chk_cnt = chk_cnt + 1 if chk_cnt % 6 == 0: hbox = gtk.HBox(False, 12) hbox.show() pbox.pack_start(hbox, expand=False, fill=False, padding=6) chk = gtk.CheckButton(it) if it in self.selected_image_types: chk.set_active(True) chk.set_tooltip_text("Build an %s image" % it) chk.connect("toggled", self.output_type_toggled_cb, handler) chk.show() hbox.pack_start(chk, expand=False, fill=False, padding=3) # BitBake label = gtk.Label() label.set_markup("<b>BitBake</b>") label.show() frame = gtk.Frame() frame.set_label_widget(label) frame.set_shadow_type(gtk.SHADOW_NONE) frame.show() self.vbox.pack_start(frame) pbox = gtk.VBox(False, 12) pbox.show() frame.add(pbox) hbox = gtk.HBox(False, 12) hbox.show() pbox.pack_start(hbox, expand=False, fill=False, padding=6) label = gtk.Label("BitBake threads:") label.show() # NOTE: may be a good idea in future to intelligently cap the maximum # values but we need more data to make an educated decision, for now # set a high maximum as a value for upper bounds is required by the # gtk.Adjustment spin_max = 30 # seems like a high enough arbitrary number hbox.pack_start(label, expand=False, fill=False, padding=6) bbadj = gtk.Adjustment(value=self.bbthread, lower=1, upper=spin_max, step_incr=1) bbspinner = gtk.SpinButton(adjustment=bbadj, climb_rate=1, digits=0) bbspinner.show() bbspinner.connect("value-changed", self.change_bb_threads_cb) hbox.pack_start(bbspinner, expand=False, fill=False, padding=6) label = gtk.Label("Make threads:") label.show() hbox.pack_start(label, expand=False, fill=False, padding=6) madj = gtk.Adjustment(value=self.pmake, lower=1, upper=spin_max, step_incr=1) makespinner = gtk.SpinButton(adjustment=madj, climb_rate=1, digits=0) makespinner.connect("value-changed", self.change_make_threads_cb) makespinner.show() hbox.pack_start(makespinner, expand=False, fill=False, padding=6) # Toolchain label = gtk.Label() label.set_markup("<b>External Toolchain</b>") label.show() frame = gtk.Frame() frame.set_label_widget(label) frame.set_shadow_type(gtk.SHADOW_NONE) frame.show() self.vbox.pack_start(frame) pbox = gtk.VBox(False, 12) pbox.show() frame.add(pbox) hbox = gtk.HBox(False, 12) hbox.show() pbox.pack_start(hbox, expand=False, fill=False, padding=6) toolcheck = gtk.CheckButton("Build external development toolchain with image") toolcheck.show() toolcheck.set_active(self.build_toolchain) toolcheck.connect("toggled", self.toggle_toolchain_cb) hbox.pack_start(toolcheck, expand=False, fill=False, padding=6) hbox = gtk.HBox(False, 12) hbox.show() pbox.pack_start(hbox, expand=False, fill=False, padding=6) label = gtk.Label("Toolchain host:") label.show() hbox.pack_start(label, expand=False, fill=False, padding=6) self.sdk_machine_combo = gtk.combo_box_new_text() self.sdk_machine_combo.set_tooltip_text("Select the host architecture of the external machine") self.sdk_machine_combo.show() hbox.pack_start(self.sdk_machine_combo, expand=False, fill=False, padding=6) # headerscheck = gtk.CheckButton("Include development headers with toolchain") # headerscheck.show() # headerscheck.set_active(self.build_toolchain_headers) # headerscheck.connect("toggled", self.toggle_headers_cb) # hbox.pack_start(headerscheck, expand=False, fill=False, padding=6) self.connect("response", self.prefs_response_cb)
def __init__(self, controls): self.controls = controls box = gtk.VBox(False, 0) box.hide() """count""" cbox = gtk.HBox(False, 0) cbox.show() tab_label = gtk.Label(_("Count of tabs:")) tab_label.set_size_request(150, -1) tab_label.show() adjustment = gtk.Adjustment(value=1, lower=1, upper=20, step_incr=1, page_incr=10, page_size=0) self.tabs_count = gtk.SpinButton(adjustment) self.tabs_count.show() cbox.pack_start(tab_label, False, False, 0) cbox.pack_start(self.tabs_count, False, True, 0) """len""" lbox = gtk.HBox(False, 0) lbox.show() tab_label = gtk.Label(_("Max length of tab:")) tab_label.set_size_request(150, -1) tab_label.show() adjustment = gtk.Adjustment(value=0, lower=-1, upper=300, step_incr=1, page_incr=10, page_size=0) self.tab_len = gtk.SpinButton(adjustment) self.tab_len.show() lbox.pack_start(tab_label, False, False, 0) lbox.pack_start(self.tab_len, False, True, 0) """position""" pbox = gtk.HBox(False, 10) pbox.show() label = gtk.Label(_("Tab position:")) label.set_size_request(150, -1) label.show() self.radio_tab_left = gtk.RadioButton(None, _("Left")) self.radio_tab_left.show() self.radio_tab_top = gtk.RadioButton(self.radio_tab_left, _("Top")) self.radio_tab_top.show() self.radio_tab_no = gtk.RadioButton(self.radio_tab_left, _("No Tabs")) self.radio_tab_no.show() pbox.pack_start(label, False, False, 0) pbox.pack_start(self.radio_tab_left, False, False, 0) pbox.pack_start(self.radio_tab_top, False, False, 0) pbox.pack_start(self.radio_tab_no, False, False, 0) """closed type """ close_label_box = gtk.HBox(False, 10) close_label_box.show() close_label = gtk.Label(_("Close tab sign:")) close_label.set_size_request(150, -1) close_label.show() self.radio_tab_label = gtk.RadioButton(None, "x") self.radio_tab_label.show() self.radio_tab_button = gtk.RadioButton(self.radio_tab_label, None) self.radio_tab_button.show() self.tab_close_box = gtk.HBox() self.tab_close_box.pack_start(self.radio_tab_button, False, True, 0) self.tab_close_box.pack_start(tab_close_button(), False, False, 0) self.tab_close_box.show() self.radio_tab_none = gtk.RadioButton(self.radio_tab_label, _("None")) self.radio_tab_none.show() close_label_box.pack_start(close_label, False, False, 0) close_label_box.pack_start(self.radio_tab_label, False, False, 0) close_label_box.pack_start(self.tab_close_box, False, False, 0) close_label_box.pack_start(self.radio_tab_none, False, False, 0) """global pack""" box.pack_start(cbox, False, True, 0) box.pack_start(lbox, False, True, 0) box.pack_start(pbox, False, True, 0) box.pack_start(close_label_box, False, True, 0) self.widget = box
def createOptionWidgets(self): n = 0 if self.option_label: n = 1 lab = gtk.Label() lab.set_text('<span weight="bold"><u>%s</u></span>' % self.option_label) lab.set_use_markup(True) lab.set_alignment(0.0, 0.5) lab.set_justify(gtk.JUSTIFY_LEFT) self.attach(lab, 0, 1, 0, 1, xpadding=self.xpadding, ypadding=self.ypadding) #xoptions=gtk.SHRINK, yoptions=gtk.SHRINK) lab.show() if self.value_label: n = 1 lab = gtk.Label() lab.set_markup('<span weight="bold"><u>%s</u></span>' % self.value_label) lab.set_alignment(0, 0.5) lab.set_justify(gtk.JUSTIFY_CENTER) self.attach(lab, 1, 2, 0, 1, xpadding=self.xpadding, ypadding=self.ypadding, xoptions=gtk.SHRINK, yoptions=gtk.SHRINK) lab.show() for l, v in self.options: if isinstance(v, CustomOption): w = v self.widgets.append([v, 'get_value', 'set_value']) v.connect('changed', lambda *args: self.emit('changed')) elif type(v) == type(True): w = gtk.CheckButton() w.set_active(v) # widgets contains the widget, the get method and the set method self.widgets.append([w, 'get_active', 'set_active']) w.connect('toggled', lambda *args: self.emit('changed')) if self.changedcb: w.connect('toggled', self.changedcb) elif type(v) in [type(""), type(u'')]: w = gtk.Entry() w.set_text(v) self.widgets.append([w, 'get_text', 'set_text']) w.connect('changed', lambda *args: self.emit('changed')) if self.changedcb: w.connect('changed', self.changedcb) elif type(v) == type(1) or type(v) == type(float(1)): adj = gtk.Adjustment(value=0, lower=0, upper=100 * (v or 1), step_incr=(v or 1) * 0.1, page_incr=(v or 1) * 0.5) if type(v) == type(1): # if an integer... w = gtk.SpinButton(adj, digits=0) self.widgets.append([w, 'get_value_as_int', 'set_value']) else: w = gtk.SpinButton(adj, digits=2) self.widgets.append([w, 'get_value', 'set_value']) w.set_value(v) w.connect('changed', lambda *args: self.emit('changed')) if self.changedcb: w.connect('changed', self.changedcb) elif type(v) in (list, tuple): default, value_list = v w = gtk.combo_box_new_text() for itm in value_list: w.append_text(itm) cb_extras.cb_set_active_text(w, default) cb_extras.setup_typeahead(w) self.widgets.append( [w, 'get_active_text', cb_extras.cb_set_active_text]) w.connect('changed', lambda *args: self.emit('changed')) if self.changedcb: w.connect('changed', self.changedcb) else: raise Exception( "I don't know what to do with a value of type %s (%s)" % (type(v), v)) # attach out label and our widget lab = gtk.Label() lab.set_text_with_mnemonic(l) lab.set_mnemonic_widget(w) lab.set_justify(gtk.JUSTIFY_LEFT) lab.set_alignment(0, 0) self.attach(lab, 0, 1, n, n + 1, xpadding=self.xpadding, ypadding=self.ypadding, xoptions=gtk.FILL, yoptions=gtk.SHRINK) lab.show() self.attach(w, 1, 2, n, n + 1, xpadding=self.xpadding, ypadding=self.ypadding, xoptions=gtk.FILL, yoptions=gtk.SHRINK) w.show() n += 1
def __init__(self, project, mainview): """ Creates a new instance of TimeLineBar Parameters: project -- reference to Project (Project.py). mainview -- reference to MainApp (JokosherApp.py). """ gtk.HBox.__init__(self) self.project = project self.mainview = mainview self.timeline = TimeLine.TimeLine(self.project, mainview) self.Updating = False # add click / bpm / signature box self.clickbutton = gtk.VolumeButton() self.clickbutton.set_value(0) self.clickbutton.set_relief(gtk.RELIEF_NORMAL) self.clickbutton.set_property("size", gtk.ICON_SIZE_BUTTON) self.clickbutton_metronome_image = gtk.Image() self.clickbutton_metronome_image.set_from_file( os.path.join(Globals.IMAGE_PATH, "icon_click.png")) # use get_child() not get_image here because GtkScaleButton # uses gtk_container_add() in its internal implementation self.clickbutton_volume_image = self.clickbutton.get_child() self.clickbutton.set_image(self.clickbutton_metronome_image) image_size_group = gtk.SizeGroup(gtk.SIZE_GROUP_BOTH) image_size_group.add_widget(self.clickbutton_metronome_image) image_size_group.add_widget(self.clickbutton_volume_image) self.clickbutton.set_tooltip_text(_("Adjust volume of click track")) self.bpmeventbox = gtk.EventBox() self.bpmframe = gtk.Frame() self.bpmeventbox.set_tooltip_text(_("Beats per minute")) self.bpmframe.set_shadow_type(gtk.SHADOW_ETCHED_OUT) self.bpmlabel = gtk.Label() self.bpmlabel.set_use_markup(True) self.bpmlabel.set_markup("<b>%s</b>" % (self.project.bpm)) self.bpmlabel.set_padding(5, 5) self.bpmeventbox.add(self.bpmlabel) self.bpmframe.add(self.bpmeventbox) self.bpmedit = gtk.SpinButton() self.bpmedit.set_range(1, 400) self.bpmedit.set_increments(1, 5) self.bpmedit.set_value(self.project.bpm) self.bpmedit.connect("activate", self.OnAcceptEditBPM) self.bpmedit.connect("key_press_event", self.OnEditBPMKey) self.bpmedit.connect_after("button-release-event", self.OnEditBPMClick) self.sigeventbox = gtk.EventBox() self.sigeventbox.set_tooltip_text(_("Time signature")) self.sigframe = gtk.Frame() self.sigframe.set_shadow_type(gtk.SHADOW_ETCHED_OUT) self.siglabel = gtk.Label() self.siglabel.set_use_markup(True) self.siglabel.set_markup( "<b>%d/%d</b>" % (self.project.meter_nom, self.project.meter_denom)) self.siglabel.set_padding(5, 5) self.sigeventbox.add(self.siglabel) self.sigframe.add(self.sigeventbox) self.sigeditPacked = False # set events self.clickbutton.connect("value-changed", self.OnClickTrackVolume) self.clickbutton.connect("enter_notify_event", self.OnClickButtonEnter) self.clickbutton.connect("leave_notify_event", self.OnClickButtonEnter) self.bpmeventbox.set_events(gtk.gdk.BUTTON_PRESS_MASK) self.bpmeventbox.connect("button_release_event", self.OnEditBPM) self.bpmeventbox.connect("enter_notify_event", self.OnMouseMoveBPM) self.bpmeventbox.connect("leave_notify_event", self.OnMouseMoveBPM) self.sigeventbox.set_events(gtk.gdk.BUTTON_PRESS_MASK) self.sigeventbox.connect("button_press_event", self.OnEditSig) self.sigeventbox.connect("enter_notify_event", self.OnMouseMoveTimeSig) self.sigeventbox.connect("leave_notify_event", self.OnMouseMoveTimeSig) self.project.connect("bpm", self.OnProjectBPMChange) self.project.connect("time-signature", self.OnProjectSigChange) self.project.connect("click-track", self.OnProjectClickTrackChange) self.sigDialog = None # ########################################################### self.headerhbox = gtk.HBox() self.headerhbox.set_border_width(2) self.headerhbox.set_spacing(5) self.headerhbox.pack_start(self.clickbutton, True, True) self.headerhbox.pack_start(self.bpmframe, True, True) self.headerhbox.pack_start(self.sigframe, True, True) self.headerVBox = gtk.VBox() self.headerVBox.pack_start(self.headerhbox, True, True) self.headerVBox.pack_start(gtk.HSeparator(), False, False) self.timelineVBox = gtk.VBox() self.timelineVBox.pack_start(self.timeline, True, True) separator = EventLaneHSeparator.EventLaneHSeparator( self.project, self.project.transport) self.timelineVBox.pack_start(separator, False, False) self.pack_start(self.headerVBox, False, False) self.pack_start(self.timelineVBox)
def __init__(self, settings, config, sql=None): self.settings = settings self.config = config self.importer = fpdb_import.Importer(self, self.settings, config, sql) self.vbox = gtk.VBox(False, 0) self.vbox.show() self.chooser = gtk.FileChooserWidget() self.chooser.set_filename(self.settings['bulkImport-defaultPath']) self.chooser.set_select_multiple(True) self.vbox.add(self.chooser) self.chooser.show() # Table widget to hold the settings self.table = gtk.Table(rows=5, columns=5, homogeneous=False) self.vbox.add(self.table) self.table.show() # checkbox - print start/stop? self.chk_st_st = gtk.CheckButton(_('Print Start/Stop Info')) self.table.attach(self.chk_st_st, 0, 1, 0, 1, xpadding=10, ypadding=0, yoptions=gtk.SHRINK) self.chk_st_st.show() self.chk_st_st.set_active(True) # label - status self.lab_status = gtk.Label(_("Hands/status print:")) self.table.attach(self.lab_status, 1, 2, 0, 1, xpadding=0, ypadding=0, yoptions=gtk.SHRINK) self.lab_status.show() self.lab_status.set_justify(gtk.JUSTIFY_RIGHT) self.lab_status.set_alignment(1.0, 0.5) # spin button - status status_adj = gtk.Adjustment( value=100, lower=0, upper=300, step_incr=10, page_incr=1, page_size=0) #not sure what upper value should be! self.spin_status = gtk.SpinButton(adjustment=status_adj, climb_rate=0.0, digits=0) self.table.attach(self.spin_status, 2, 3, 0, 1, xpadding=10, ypadding=0, yoptions=gtk.SHRINK) self.spin_status.show() # label - threads self.lab_threads = gtk.Label(_("Number of threads:")) self.table.attach(self.lab_threads, 3, 4, 0, 1, xpadding=0, ypadding=0, yoptions=gtk.SHRINK) self.lab_threads.show() if not self.allowThreads: self.lab_threads.set_sensitive(False) self.lab_threads.set_justify(gtk.JUSTIFY_RIGHT) self.lab_threads.set_alignment(1.0, 0.5) # spin button - threads threads_adj = gtk.Adjustment( value=0, lower=0, upper=32, step_incr=1, page_incr=1, page_size=0) #not sure what upper value should be! self.spin_threads = gtk.SpinButton(adjustment=threads_adj, climb_rate=0.0, digits=0) self.table.attach(self.spin_threads, 4, 5, 0, 1, xpadding=10, ypadding=0, yoptions=gtk.SHRINK) self.spin_threads.show() if not self.allowThreads: self.spin_threads.set_sensitive(False) # checkbox - fail on error? self.chk_fail = gtk.CheckButton(_('Fail on error')) self.table.attach(self.chk_fail, 0, 1, 1, 2, xpadding=10, ypadding=0, yoptions=gtk.SHRINK) self.chk_fail.show() # label - hands self.lab_hands = gtk.Label(_("Hands/file:")) self.table.attach(self.lab_hands, 1, 2, 1, 2, xpadding=0, ypadding=0, yoptions=gtk.SHRINK) self.lab_hands.show() self.lab_hands.set_justify(gtk.JUSTIFY_RIGHT) self.lab_hands.set_alignment(1.0, 0.5) # spin button - hands to import hands_adj = gtk.Adjustment( value=0, lower=0, upper=10, step_incr=1, page_incr=1, page_size=0) #not sure what upper value should be! self.spin_hands = gtk.SpinButton(adjustment=hands_adj, climb_rate=0.0, digits=0) self.table.attach(self.spin_hands, 2, 3, 1, 2, xpadding=10, ypadding=0, yoptions=gtk.SHRINK) self.spin_hands.show() # label - drop indexes self.lab_drop = gtk.Label(_("Drop indexes:")) self.table.attach(self.lab_drop, 3, 4, 1, 2, xpadding=0, ypadding=0, yoptions=gtk.SHRINK) self.lab_drop.show() self.lab_drop.set_justify(gtk.JUSTIFY_RIGHT) self.lab_drop.set_alignment(1.0, 0.5) # ComboBox - drop indexes self.cb_dropindexes = gtk.combo_box_new_text() self.cb_dropindexes.append_text(_('auto')) self.cb_dropindexes.append_text(_("don't drop")) self.cb_dropindexes.append_text(_('drop')) self.cb_dropindexes.set_active(0) self.table.attach(self.cb_dropindexes, 4, 5, 1, 2, xpadding=10, ypadding=0, yoptions=gtk.SHRINK) self.cb_dropindexes.show() self.cb_testmode = gtk.CheckButton(_('HUD Test mode')) self.table.attach(self.cb_testmode, 0, 1, 2, 3, xpadding=10, ypadding=0, yoptions=gtk.SHRINK) self.cb_testmode.show() # label - filter self.lab_filter = gtk.Label(_("Site filter:")) self.table.attach(self.lab_filter, 1, 2, 2, 3, xpadding=0, ypadding=0, yoptions=gtk.SHRINK) self.lab_filter.show() self.lab_filter.set_justify(gtk.JUSTIFY_RIGHT) self.lab_filter.set_alignment(1.0, 0.5) # ComboBox - filter self.cbfilter = gtk.combo_box_new_text() disabled_sites = [] # move disabled sites to bottom of list for w in self.config.hhcs: try: if self.config.supported_sites[ w].enabled: # include enabled ones first print w self.cbfilter.append_text(w) else: disabled_sites.append(w) except: # self.supported_sites[w] may not exist if hud_config is bad disabled_sites.append(w) for w in disabled_sites: # then disabled ones print w self.cbfilter.append_text(w) self.cbfilter.set_active(0) self.table.attach(self.cbfilter, 2, 3, 2, 3, xpadding=10, ypadding=1, yoptions=gtk.SHRINK) self.cbfilter.show() # label - drop hudcache self.lab_hdrop = gtk.Label(_("Drop HudCache:")) self.table.attach(self.lab_hdrop, 3, 4, 2, 3, xpadding=0, ypadding=0, yoptions=gtk.SHRINK) self.lab_hdrop.show() self.lab_hdrop.set_justify(gtk.JUSTIFY_RIGHT) self.lab_hdrop.set_alignment(1.0, 0.5) # ComboBox - drop hudcache self.cb_drophudcache = gtk.combo_box_new_text() self.cb_drophudcache.append_text(_('auto')) self.cb_drophudcache.append_text(_("don't drop")) self.cb_drophudcache.append_text(_('drop')) self.cb_drophudcache.set_active(0) self.table.attach(self.cb_drophudcache, 4, 5, 2, 3, xpadding=10, ypadding=0, yoptions=gtk.SHRINK) self.cb_drophudcache.show() # button - Import self.load_button = gtk.Button( _('_Bulk Import')) # todo: rename variables to import too self.load_button.connect('clicked', self.load_clicked, _('Import clicked')) self.table.attach(self.load_button, 2, 3, 4, 5, xpadding=0, ypadding=0, yoptions=gtk.SHRINK) self.load_button.show() # label - spacer (keeps rows 3 & 5 apart) self.lab_spacer = gtk.Label() self.table.attach(self.lab_spacer, 3, 5, 3, 4, xpadding=0, ypadding=0, yoptions=gtk.SHRINK) self.lab_spacer.show() # label - info # self.lab_info = gtk.Label() # self.table.attach(self.lab_info, 3, 5, 4, 5, xpadding = 0, ypadding = 0, yoptions=gtk.SHRINK) # self.lab_info.show() self.progressbar = gtk.ProgressBar() self.table.attach(self.progressbar, 3, 5, 4, 5, xpadding=0, ypadding=0, yoptions=gtk.SHRINK) self.progressbar.set_text(_("Waiting...")) self.progressbar.set_fraction(0) self.progressbar.show() # see how many hands are in the db and adjust accordingly tcursor = self.importer.database.cursor tcursor.execute("Select count(1) from Hands") row = tcursor.fetchone() tcursor.close() self.importer.database.rollback() self.n_hands_in_db = row[0] if self.n_hands_in_db == 0: self.cb_dropindexes.set_active(2) self.cb_dropindexes.set_sensitive(False) self.lab_drop.set_sensitive(False) self.cb_drophudcache.set_active(2) self.cb_drophudcache.set_sensitive(False) self.lab_hdrop.set_sensitive(False)