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)
