def __init__(self, parent, plugin_instance):
GObject.GObject.__init__(self, spacing=12)
self.plugin_instance = plugin_instance
# notification text settings
table = Gtk.Table(n_rows=2, n_columns=3)
table.set_col_spacings(6)
table.set_row_spacings(6)
text_frame = qltk.Frame(_("Notification text"), child=table)
title_entry = UndoEntry()
title_entry.set_text(pconfig.gettext("titlepattern"))
def on_entry_changed(entry, cfgname):
pconfig.settext(cfgname, gdecode(entry.get_text()))
title_entry.connect("changed", on_entry_changed, "titlepattern")
table.attach(title_entry, 1, 2, 0, 1)
title_label = Gtk.Label(label=_("_Title:"))
title_label.set_use_underline(True)
title_label.set_alignment(0, 0.5)
title_label.set_mnemonic_widget(title_entry)
table.attach(title_label, 0, 1, 0, 1,
xoptions=Gtk.AttachOptions.FILL |
Gtk.AttachOptions.SHRINK)
title_revert = Gtk.Button()
title_revert.add(Gtk.Image.new_from_icon_name(
Icons.DOCUMENT_REVERT, Gtk.IconSize.MENU))
title_revert.set_tooltip_text(_("Revert to default pattern"))
title_revert.connect(
"clicked", lambda *x: title_entry.set_text(
pconfig.defaults.gettext("titlepattern")))
table.attach(title_revert, 2, 3, 0, 1,
xoptions=Gtk.AttachOptions.SHRINK)
body_textbuffer = TextBuffer()
body_textview = TextView(buffer=body_textbuffer)
body_textview.set_size_request(-1, 85)
body_textview.get_buffer().set_text(pconfig.gettext("bodypattern"))
def on_textbuffer_changed(text_buffer, cfgname):
start, end = text_buffer.get_bounds()
text = gdecode(text_buffer.get_text(start, end, True))
pconfig.settext(cfgname, text)
body_textbuffer.connect("changed", on_textbuffer_changed,
"bodypattern")
body_scrollarea = Gtk.ScrolledWindow()
body_scrollarea.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
body_scrollarea.set_shadow_type(Gtk.ShadowType.ETCHED_OUT)
body_scrollarea.add(body_textview)
table.attach(body_scrollarea, 1, 2, 1, 2)
body_label = Gtk.Label(label=_("_Body:"))
body_label.set_padding(0, 3)
body_label.set_use_underline(True)
body_label.set_alignment(0, 0)
body_label.set_mnemonic_widget(body_textview)
table.attach(body_label, 0, 1, 1, 2, xoptions=Gtk.AttachOptions.SHRINK)
body_revert = Gtk.Button()
body_revert.add(Gtk.Image.new_from_icon_name(
Icons.DOCUMENT_REVERT, Gtk.IconSize.MENU))
body_revert.set_tooltip_text(_("Revert to default pattern"))
body_revert.connect("clicked", lambda *x:
body_textbuffer.set_text(pconfig.defaults.gettext("bodypattern")))
table.attach(
body_revert, 2, 3, 1, 2,
xoptions=Gtk.AttachOptions.SHRINK,
yoptions=Gtk.AttachOptions.FILL | Gtk.AttachOptions.SHRINK)
# preview button
preview_button = qltk.Button(
_("_Show notification"), Icons.SYSTEM_RUN)
preview_button.set_sensitive(app.player.info is not None)
preview_button.connect("clicked", self.on_preview_button_clicked)
self.qlplayer_connected_signals = [
app.player.connect("paused", self.on_player_state_changed,
preview_button),
app.player.connect("unpaused", self.on_player_state_changed,
preview_button),
]
table.attach(
preview_button, 0, 3, 2, 3,
xoptions=Gtk.AttachOptions.FILL | Gtk.AttachOptions.SHRINK)
self.pack_start(text_frame, True, True, 0)
# notification display settings
display_box = Gtk.VBox(spacing=12)
display_frame = qltk.Frame(_("Show notifications"), child=display_box)
radio_box = Gtk.VBox(spacing=6)
display_box.pack_start(radio_box, True, True, 0)
only_user_radio = Gtk.RadioButton(label=_(
"Only on <i>_manual</i> song changes"
), use_underline=True)
only_user_radio.get_child().set_use_markup(True)
only_user_radio.connect("toggled", self.on_radiobutton_toggled,
"show_notifications", "user")
radio_box.pack_start(only_user_radio, True, True, 0)
only_auto_radio = Gtk.RadioButton(group=only_user_radio, label=_(
"Only on <i>_automatic</i> song changes"
), use_underline=True)
only_auto_radio.get_child().set_use_markup(True)
only_auto_radio.connect("toggled", self.on_radiobutton_toggled,
"show_notifications", "auto")
radio_box.pack_start(only_auto_radio, True, True, 0)
all_radio = Gtk.RadioButton(group=only_user_radio, label=_(
"On <i>a_ll</i> song changes"
), use_underline=True)
all_radio.get_child().set_use_markup(True)
all_radio.connect("toggled", self.on_radiobutton_toggled,
"show_notifications", "all")
radio_box.pack_start(all_radio, True, True, 0)
{
"user": only_user_radio,
"auto": only_auto_radio,
"all": all_radio
}.get(pconfig.gettext("show_notifications"),
all_radio).set_active(True)
focus_check = Gtk.CheckButton(
label=_("Only when the main window is not _focused"),
use_underline=True)
focus_check.set_active(pconfig.getboolean("show_only_when_unfocused"))
focus_check.connect("toggled", self.on_checkbutton_toggled,
"show_only_when_unfocused")
display_box.pack_start(focus_check, True, True, 0)
show_next = Gtk.CheckButton(
label=_("Show \"_Next\" button"),
use_underline=True)
show_next.set_active(pconfig.getboolean("show_next_button"))
show_next.connect("toggled", self.on_checkbutton_toggled,
"show_next_button")
display_box.pack_start(show_next, True, True, 0)
self.pack_start(display_frame, True, True, 0)
self.show_all()
self.connect("destroy", self.on_destroyed)
def __init__(self, namespace, dbstate, uistate, track, filterdb, val,
label, update, filter_name):
ManagedWindow.__init__(self, uistate, track, EditRule)
self.namespace = namespace
self.dbstate = dbstate
self.db = dbstate.db
self.filterdb = filterdb
self.update_rule = update
self.filter_name = filter_name
self.active_rule = val
self.define_glade('rule_editor', RULE_GLADE)
self.set_window(self.get_widget('rule_editor'),
self.get_widget('rule_editor_title'), label)
self.setup_configs('interface.edit-rule', 600, 450)
self.window.hide()
self.valuebox = self.get_widget('valuebox')
self.rname_filter = self.get_widget('ruletreefilter')
self.rname = self.get_widget('ruletree')
self.rule_name = self.get_widget('rulename')
self.description = self.get_widget('description')
self.notebook = Gtk.Notebook()
self.notebook.set_show_tabs(0)
self.notebook.set_show_border(0)
self.notebook.show()
self.valuebox.pack_start(self.notebook, True, True, 0)
self.page_num = 0
self.page = []
self.class2page = {}
if self.namespace == 'Person':
class_list = rules.person.editor_rule_list
elif self.namespace == 'Family':
class_list = rules.family.editor_rule_list
elif self.namespace == 'Event':
class_list = rules.event.editor_rule_list
elif self.namespace == 'Source':
class_list = rules.source.editor_rule_list
elif self.namespace == 'Citation':
class_list = rules.citation.editor_rule_list
elif self.namespace == 'Place':
class_list = rules.place.editor_rule_list
elif self.namespace == 'Media':
class_list = rules.media.editor_rule_list
elif self.namespace == 'Repository':
class_list = rules.repository.editor_rule_list
elif self.namespace == 'Note':
class_list = rules.note.editor_rule_list
for class_obj in class_list:
arglist = class_obj.labels
vallist = []
tlist = []
pos = 0
l2 = Gtk.Label(label=class_obj.name, halign=Gtk.Align.START)
l2.show()
grid = Gtk.Grid()
grid.set_border_width(12)
grid.set_column_spacing(6)
grid.set_row_spacing(6)
grid.show()
for v in arglist:
l = Gtk.Label(label=v, halign=Gtk.Align.END)
l.show()
if v == _('Place:'):
t = MyPlaces([])
elif v in [_('Reference count:'), _('Number of instances:')]:
t = MyInteger(0, 999)
elif v == _('Reference count must be:'):
t = MyLesserEqualGreater()
elif v == _('Number must be:'):
t = MyLesserEqualGreater(2)
elif v == _('Number of generations:'):
t = MyInteger(1, 32)
elif v == _('ID:'):
t = MyID(self.dbstate, self.uistate, self.track,
self.namespace)
elif v == _('Source ID:'):
t = MySource(self.dbstate, self.uistate, self.track)
elif v == _('Filter name:'):
t = MyFilters(self.filterdb.get_filters(self.namespace),
self.filter_name)
# filters of another namespace, name may be same as caller!
elif v == _('Person filter name:'):
t = MyFilters(self.filterdb.get_filters('Person'))
elif v == _('Event filter name:'):
t = MyFilters(self.filterdb.get_filters('Event'))
elif v == _('Source filter name:'):
t = MyFilters(self.filterdb.get_filters('Source'))
elif v == _('Repository filter name:'):
t = MyFilters(self.filterdb.get_filters('Repository'))
elif v == _('Place filter name:'):
t = MyFilters(self.filterdb.get_filters('Place'))
elif v in _name2typeclass:
additional = None
if v in (_('Event type:'), _('Personal event:'),
_('Family event:')):
additional = self.db.get_event_types()
elif v == _('Personal attribute:'):
additional = self.db.get_person_attribute_types()
elif v == _('Family attribute:'):
additional = self.db.get_family_attribute_types()
elif v == _('Event attribute:'):
additional = self.db.get_event_attribute_types()
elif v == _('Media attribute:'):
additional = self.db.get_media_attribute_types()
elif v == _('Relationship type:'):
additional = self.db.get_family_relation_types()
elif v == _('Note type:'):
additional = self.db.get_note_types()
elif v == _('Name type:'):
additional = self.db.get_name_types()
elif v == _('Surname origin type:'):
additional = self.db.get_origin_types()
elif v == _('Place type:'):
additional = sorted(self.db.get_place_types(),
key=lambda s: s.lower())
t = MySelect(_name2typeclass[v], additional)
elif v == _('Inclusive:'):
t = MyBoolean(_('Include selected Gramps ID'))
elif v == _('Case sensitive:'):
t = MyBoolean(_('Use exact case of letters'))
elif v == _('Regular-Expression matching:'):
t = MyBoolean(_('Use regular expression'))
elif v == _('Include Family events:'):
t = MyBoolean(
_('Also family events where person is spouse'))
elif v == _('Primary Role:'):
t = MyBoolean(_('Only include primary participants'))
elif v == _('Tag:'):
taglist = ['']
taglist = taglist + [
tag.get_name() for tag in dbstate.db.iter_tags()
]
t = MyList(taglist, taglist)
elif v == _('Confidence level:'):
t = MyList(list(map(str, list(range(5)))),
[_(conf_strings[i]) for i in range(5)])
elif v == _('Date:'):
t = DateEntry(self.uistate, self.track)
elif v == _('Day of Week:'):
long_days = displayer.long_days
days_of_week = long_days[2:] + long_days[1:2]
t = MyList(list(map(str, range(7))), days_of_week)
elif v == _('Units:'):
t = MyList(
[0, 1, 2],
[_('kilometers'),
_('miles'), _('degrees')])
else:
t = MyEntry()
t.set_hexpand(True)
tlist.append(t)
grid.attach(l, 0, pos, 1, 1)
grid.attach(t, 1, pos, 1, 1)
pos += 1
use_regex = None
if class_obj.allow_regex:
use_regex = Gtk.CheckButton(label=_('Use regular expressions'))
tip = _('Interpret the contents of string fields as regular '
'expressions.\n'
'A decimal point will match any character. '
'A question mark will match zero or one occurences '
'of the previous character or group. '
'An asterisk will match zero or more occurences. '
'A plus sign will match one or more occurences. '
'Use parentheses to group expressions. '
'Specify alternatives using a vertical bar. '
'A caret will match the start of a line. '
'A dollar sign will match the end of a line.')
use_regex.set_tooltip_text(tip)
grid.attach(use_regex, 1, pos, 1, 1)
self.page.append((class_obj, vallist, tlist, use_regex))
# put the grid into a scrollable area:
scrolled_win = Gtk.ScrolledWindow()
scrolled_win.add(grid)
scrolled_win.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
scrolled_win.show()
self.notebook.append_page(scrolled_win,
Gtk.Label(label=class_obj.name))
self.class2page[class_obj] = self.page_num
self.page_num = self.page_num + 1
self.page_num = 0
self.store = Gtk.TreeStore(GObject.TYPE_STRING, GObject.TYPE_PYOBJECT)
self.ruletree_filter = self.store.filter_new()
self.ruletree_filter.set_visible_func(self.rtree_visible_func)
self.selection = self.rname.get_selection()
col = Gtk.TreeViewColumn(_('Rule Name'),
Gtk.CellRendererText(),
text=0)
self.rname.append_column(col)
self.rname.set_model(self.ruletree_filter)
prev = None
last_top = None
top_level = {}
top_node = {}
#
# If editing a rule, get the name so that we can select it later
#
sel_node = None
if self.active_rule is not None:
self.sel_class = self.active_rule.__class__
else:
self.sel_class = None
keys = sorted(class_list, key=lambda x: x.name, reverse=True)
catlist = sorted(set(class_obj.category for class_obj in keys))
for category in catlist:
top_node[category] = self.store.insert_after(None, last_top)
top_level[category] = []
last_top = top_node[category]
self.store.set(last_top, 0, category, 1, '')
for class_obj in keys:
category = class_obj.category
top_level[category].append(class_obj.name)
node = self.store.insert_after(top_node[category], prev)
self.store.set(node, 0, class_obj.name, 1, class_obj)
# if this is an edit rule, save the node
if class_obj == self.sel_class:
sel_node = (top_node[category], node)
if sel_node:
self.select_iter(sel_node)
page = self.class2page[self.active_rule.__class__]
self.notebook.set_current_page(page)
self.display_values(self.active_rule.__class__)
(class_obj, vallist, tlist, use_regex) = self.page[page]
r = list(self.active_rule.values())
for i in range(0, min(len(tlist), len(r))):
tlist[i].set_text(r[i])
if class_obj.allow_regex:
use_regex.set_active(self.active_rule.use_regex)
self.selection.connect('changed', self.on_node_selected)
self.rname.connect('button-press-event', self._button_press)
self.rname.connect('key-press-event', self._key_press)
self.get_widget('rule_editor_ok').connect('clicked', self.rule_ok)
self.get_widget('rule_editor_cancel').connect('clicked',
self.close_window)
self.get_widget('rule_editor_help').connect('clicked',
self.on_help_clicked)
self.rname_filter.connect('changed', self.on_rname_filter_changed)
self._set_size()
self.show()
def create_widget(self):
widget = Gtk.CheckButton()
widget.connect('toggled', self.parent_widget.sig_activate)
widget.connect('focus-out-event',
lambda w, e: self.parent_widget._focus_out())
return widget
def __init__(self, start=False, change_handler=None):
self.control = gtk.CheckButton()
self.control.set_active(start)
self.connect("toggled", change_handler)
def __init__(self, url_, parent_):
Gtk.Window.__init__(self, title="Smells")
self.set_border_width(5)
self.set_size_request(600, 300)
self.set_resizable(False)
self.url = url_
self.parent = parent_
r = requests.get(self.url)
data = r.text.split('\n')
self.prj_name = data[3]
self.prj_id = data[4]
self.api = data[2]
self.suse_path = (
os.environ['HOME']
) + '/.sawtooth_projects/.' + self.prj_name + '_' + self.prj_id + '/etc/.suse'
box_outer = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
self.add(box_outer)
# ListStore (lists that TreeViews can display) and specify data types
projects_list_store = Gtk.ListStore(str, str)
# Top Section
self.listbox = Gtk.ListBox()
self.listbox.set_selection_mode(Gtk.SelectionMode.NONE)
box_outer.pack_start(self.listbox, True, True, 0)
self.row = Gtk.ListBoxRow()
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=5)
self.row.add(hbox)
#self.tog_pro_act = Gtk.CheckButton("Proposal active days:")
#self.tog_pro_act.set_active(True)
#self.tog_pro_act.connect("toggled", self.on_tog_pro_act)
self.lbl_pro_act = Gtk.Label('Proposal active days:')
hbox.pack_start(self.lbl_pro_act, True, True, 0)
self.txt_pro_act = Gtk.Entry()
self.txt_pro_act.set_text("0")
hbox.pack_start(self.txt_pro_act, False, True, 0)
self.listbox.add(self.row)
self.row = Gtk.ListBoxRow()
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=5)
self.row.add(hbox)
#self.tog_app_tre = Gtk.CheckButton("Approval threshold:")
#self.tog_app_tre.set_active(True)
#self.tog_app_tre.connect("toggled", self.on_tog_app_tre)
self.lbl_app_tre = Gtk.Label('Approval treshold:')
hbox.pack_start(self.lbl_app_tre, True, True, 0)
self.txt_app_tre = Gtk.Entry()
self.txt_app_tre.set_text("0")
hbox.pack_start(self.txt_app_tre, False, True, 0)
self.listbox.add(self.row)
self.row = Gtk.ListBoxRow()
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=5)
self.row.add(hbox)
self.tog_large_class = Gtk.CheckButton("Large class:")
self.tog_large_class.set_active(True)
self.tog_large_class.connect("toggled", self.on_tog_large_class)
hbox.pack_start(self.tog_large_class, True, True, 0)
self.txt_large_class = Gtk.Entry()
self.txt_large_class.set_text("0")
hbox.pack_start(self.txt_large_class, False, True, 0)
self.listbox.add(self.row)
self.row = Gtk.ListBoxRow()
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=5)
self.row.add(hbox)
self.tog_small_class = Gtk.CheckButton("Small class:")
self.tog_small_class.set_active(True)
self.tog_small_class.connect("toggled", self.on_tog_small_class)
hbox.pack_start(self.tog_small_class, True, True, 0)
self.txt_small_class = Gtk.Entry()
self.txt_small_class.set_text("0")
hbox.pack_start(self.txt_small_class, False, True, 0)
self.listbox.add(self.row)
self.row = Gtk.ListBoxRow()
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=5)
self.row.add(hbox)
self.tog_large_method = Gtk.CheckButton("Large method:")
self.tog_large_method.set_active(True)
self.tog_large_method.connect("toggled", self.on_tog_large_method)
hbox.pack_start(self.tog_large_method, True, True, 0)
self.txt_large_method = Gtk.Entry()
self.txt_large_method.set_text("0")
hbox.pack_start(self.txt_large_method, False, True, 0)
self.listbox.add(self.row)
self.row = Gtk.ListBoxRow()
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=5)
self.row.add(hbox)
self.tog_small_method = Gtk.CheckButton("Small method:")
self.tog_small_method.set_active(True)
self.tog_small_method.connect("toggled", self.on_tog_small_method)
hbox.pack_start(self.tog_small_method, True, True, 0)
self.txt_small_method = Gtk.Entry()
self.txt_small_method.set_text("0")
hbox.pack_start(self.txt_small_method, False, True, 0)
self.listbox.add(self.row)
self.row = Gtk.ListBoxRow()
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=5)
self.row.add(hbox)
self.tog_large_param = Gtk.CheckButton("Large param:")
self.tog_large_param.set_active(True)
self.tog_large_param.connect("toggled", self.on_tog_large_param)
hbox.pack_start(self.tog_large_param, True, True, 0)
self.txt_large_param = Gtk.Entry()
self.txt_large_param.set_text("0")
hbox.pack_start(self.txt_large_param, False, True, 0)
self.listbox.add(self.row)
self.row = Gtk.ListBoxRow()
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=5)
self.row.add(hbox)
self.tog_god_class = Gtk.CheckButton("God class:")
self.tog_god_class.set_active(True)
self.tog_god_class.connect("toggled", self.on_tog_god_class)
hbox.pack_start(self.tog_god_class, True, True, 0)
self.txt_god_class = Gtk.Entry()
self.txt_god_class.set_text("0")
hbox.pack_start(self.txt_god_class, False, True, 0)
self.listbox.add(self.row)
self.row = Gtk.ListBoxRow()
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=5)
self.row.add(hbox)
self.tog_inapp_intm = Gtk.CheckButton("Inappropriate Intimacy:")
self.tog_inapp_intm.set_active(True)
hbox.pack_start(self.tog_inapp_intm, True, True, 0)
self.tog_inapp_intm.connect("toggled", self.on_tog_inapp_intm)
self.txt_inapp_intm = Gtk.Entry()
self.txt_inapp_intm.set_text("0")
hbox.pack_start(self.txt_inapp_intm, False, True, 0)
self.listbox.add(self.row)
self.row = Gtk.ListBoxRow()
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=5)
self.row.add(hbox)
self.tog_ctc_up = Gtk.CheckButton("Comments to code ratio [upper]:")
self.tog_ctc_up.set_active(True)
self.tog_ctc_up.connect("toggled", self.on_tog_ctc_up)
hbox.pack_start(self.tog_ctc_up, True, True, 0)
self.txt_ctc_up = Gtk.Entry()
self.txt_ctc_up.set_text("0.0")
hbox.pack_start(self.txt_ctc_up, False, True, 0)
self.listbox.add(self.row)
self.row = Gtk.ListBoxRow()
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=5)
self.row.add(hbox)
self.tog_ctc_lw = Gtk.CheckButton("Comments to code ratio [lower]:")
self.tog_ctc_lw.set_active(True)
self.tog_ctc_lw.connect("toggled", self.on_tog_ctc_lw)
hbox.pack_start(self.tog_ctc_lw, True, True, 0)
self.txt_ctc_lw = Gtk.Entry()
self.txt_ctc_lw.set_text("0.0")
hbox.pack_start(self.txt_ctc_lw, False, True, 0)
self.listbox.add(self.row)
# keep going if more rows are required.
# Bottom section
self.listbox_3 = Gtk.ListBox()
self.listbox_3.set_selection_mode(Gtk.SelectionMode.NONE)
box_outer.pack_start(self.listbox_3, False, True, 0)
self.row = Gtk.ListBoxRow()
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=10)
self.row.add(hbox)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
hbox.pack_start(vbox, True, True, 0)
self.lbl_project = Gtk.Label(
'Update the code smells values for the project')
vbox.pack_start(self.lbl_project, True, False, 0)
self.button = Gtk.Button.new_with_label("Save")
self.button.connect("clicked", self.save_smells)
hbox.pack_start(self.button, False, True, 0)
self.listbox_3.add(self.row)
self.row = Gtk.ListBoxRow()
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=10)
self.row.add(hbox)
self.lbl_add_fields = Gtk.Label()
self.lbl_add_fields.set_markup(
"<a href=\"mailto:[email protected]\" title=\"Email [email protected]\">Contact support ([email protected]) to add more fields</a>"
)
hbox.pack_start(self.lbl_add_fields, True, True, 0)
self.listbox_3.add(self.row)
self.connect("delete-event", Gtk.main_quit)
self.set_position(Gtk.WindowPosition.CENTER)
self.show_all()
def prepare_dialog(self, options):
self.options = options
grid = Gtk.Grid()
grid.set_row_spacing(3)
grid.set_column_spacing(10)
grid.set_hexpand(True)
grid.set_border_width(10)
self.add(grid)
row_count = 0
box0 = Gtk.Box(spacing=6)
grid.attach(Gtk.Label(label="Preamble File"), 0, row_count, 1, 1)
self.entryPreamble = Gtk.Entry()
self.entryPreamble.set_text(options.preamble)
self.entryPreamble.set_hexpand(True)
box0.pack_start(self.entryPreamble, True, True, 0)
btnSelectPreamble = Gtk.Button(label="...")
btnSelectPreamble.set_hexpand(False)
btnSelectPreamble.connect("clicked", self.on_select_preamble)
box0.pack_start(btnSelectPreamble, False, False, 0)
grid.attach(box0, 1, row_count, 1, 1)
row_count += 1
grid.attach(Gtk.Label(label="Additional Packages"), 0, row_count, 1, 1)
self.entryPackages = Gtk.Entry()
self.entryPackages.set_text(options.packages)
self.entryPackages.set_hexpand(True)
grid.attach(self.entryPackages, 1, row_count, 1, 1)
row_count += 1
grid.attach(Gtk.Label(label="Document base font size"), 0, row_count, 1, 1)
self.entryFontsize = Gtk.SpinButton.new_with_range(1, 32, 1)
self.entryFontsize.set_value(options.fontsize)
self.entryFontsize.set_hexpand(False)
grid.attach(self.entryFontsize, 1, row_count, 1, 1)
row_count += 1
self.entryScale = Gtk.SpinButton.new_with_range(0.01, 20.0, 0.05)
self.entryScale.set_digits(2)
self.entryScale.set_value(options.scale)
grid.attach(Gtk.Label(label="Scale factor"), 0, row_count, 1, 1)
grid.attach(self.entryScale, 1, row_count, 1, 1)
row_count += 1
self.entryDepth = Gtk.SpinButton.new_with_range(0, 100, 1)
self.entryDepth.set_value(options.depth)
grid.attach(Gtk.Label(label="SVG/XML tree max. depth"), 0, row_count, 1, 1)
grid.attach(self.entryDepth, 1, row_count, 1, 1)
row_count += 1
grid.attach(Gtk.Label(label="Add \\\\ at every line break"), 0, row_count, 1, 1)
self.btnNewline = Gtk.CheckButton()
self.btnNewline.set_active(options.newline)
grid.attach(self.btnNewline, 1, row_count, 1, 1)
row_count += 1
grid.attach(Gtk.Label(label="Encapsulate all text with ($..$)"), 0, row_count, 1, 1)
self.btnMath = Gtk.CheckButton()
self.btnMath.set_active(options.math)
grid.attach(self.btnMath, 1, row_count, 1, 1)
row_count += 1
grid.attach(Gtk.Label(label="Show log messages"), 0, row_count, 1, 1)
self.btnShowLog = Gtk.CheckButton()
grid.attach(self.btnShowLog, 1, row_count, 1, 1)
row_count += 2
box1 = Gtk.Box(spacing=6)
grid.attach(box1, 0, row_count, 2, 1)
btnApply = Gtk.Button(label="Apply")
btnApply.connect("clicked", self.on_btnApply_clicked)
box1.pack_end(btnApply, False, False, 0)
btnClose = Gtk.Button(label="Close")
btnClose.connect("clicked", self.on_btnClose_clicked)
box1.pack_end(btnClose, False, False, 0)
self.show_all()
self.entryScale.grab_focus()
btnApply.set_can_default(True)
btnApply.grab_default()
btnApply.grab_focus()
self.set_default(btnApply)
def convert_transcription_cb(self, button=None):
if not self.controller.gui:
self.message(_("Cannot convert the data: no associated package"))
return True
d = Gtk.Dialog(title=_("Converting transcription"),
parent=self.controller.gui.gui.win,
flags=Gtk.DialogFlags.DESTROY_WITH_PARENT,
buttons=( Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
Gtk.STOCK_OK, Gtk.ResponseType.OK,
))
l=Gtk.Label(label=_("Choose the annotation-type where to create annotations.\n"))
l.set_line_wrap(True)
l.show()
d.vbox.pack_start(l, False, True, 0)
# Anticipated declaration of some widgets, which need to be
# updated in the handle_new_type_selection callback.
new_type_dialog=Gtk.VBox()
delete_existing_toggle=Gtk.CheckButton(_("Delete existing annotations in this type"))
delete_existing_toggle.set_active(False)
ats=list(self.controller.package.annotationTypes)
newat=helper.TitledElement(value=None,
title=_("Create a new annotation type"))
ats.append(newat)
def handle_new_type_selection(combo):
el=combo.get_current_element()
if el == newat:
new_type_dialog.show()
delete_existing_toggle.set_sensitive(False)
else:
new_type_dialog.hide()
delete_existing_toggle.set_sensitive(True)
return True
type_selection=dialog.list_selector_widget(members=[ (a, self.controller.get_title(a), self.controller.get_element_color(a)) for a in ats],
callback=handle_new_type_selection,
preselect=self.controller.package.get_element_by_id(self.options['annotation-type-id']))
hb=Gtk.HBox()
hb.pack_start(Gtk.Label(_("Select type") + " "), False, False, 0)
hb.pack_start(type_selection, False, True, 0)
d.vbox.pack_start(hb, False, True, 0)
l=Gtk.Label(label=_("You want to create a new type. Please specify its schema and title."))
l.set_line_wrap(True)
l.show()
new_type_dialog.pack_start(l, False, True, 0)
hb=Gtk.HBox()
hb.pack_start(Gtk.Label(_("Title") + " "), False, False, 0)
new_title=Gtk.Entry()
hb.pack_start(new_title, True, True, 0)
new_type_dialog.pack_start(hb, False, True, 0)
hb=Gtk.HBox()
hb.pack_start(Gtk.Label(_("Containing schema") + " "), False, False, 0)
schemas=list(self.controller.package.schemas)
schema_selection=dialog.list_selector_widget(members=[ (s, self.controller.get_title(s)) for s in schemas])
hb.pack_start(schema_selection, False, True, 0)
new_type_dialog.pack_start(hb, False, True, 0)
new_type_dialog.show_all()
new_type_dialog.set_no_show_all(True)
new_type_dialog.hide()
d.vbox.pack_start(new_type_dialog, True, True, 0)
l=Gtk.Label()
l.set_markup("<b>" + _("Export options") + "</b>")
d.vbox.pack_start(l, False, True, 0)
d.vbox.pack_start(delete_existing_toggle, False, True, 0)
empty_contents_toggle=Gtk.CheckButton(_("Generate annotations for empty contents"))
empty_contents_toggle.set_active(self.options['empty-annotations'])
d.vbox.pack_start(empty_contents_toggle, False, True, 0)
d.connect('key-press-event', dialog.dialog_keypressed_cb)
d.show_all()
dialog.center_on_mouse(d)
finished=None
while not finished:
res=d.run()
if res == Gtk.ResponseType.OK:
at=type_selection.get_current_element()
if at == newat:
new_type_title=new_title.get_text()
if new_type_title == '':
# Empty title. Generate one.
id_=self.controller.package._idgenerator.get_id(AnnotationType)
new_type_title=id_
else:
id_=helper.title2id(new_type_title)
# Check that the id is available
if self.controller.package._idgenerator.exists(id_):
dialog.message_dialog(
_("The %s identifier already exists. Choose another one.") % id_,
icon=Gtk.MessageType.WARNING)
at=None
continue
# Creating a new type
s=schema_selection.get_current_element()
at=s.createAnnotationType(ident=id_)
at.author=config.data.userid
at.date=helper.get_timestamp()
at.title=new_type_title
at.mimetype='text/plain'
at.setMetaData(config.data.namespace, 'color', next(s.rootPackage._color_palette))
at.setMetaData(config.data.namespace, 'item_color', 'here/tag_color')
s.annotationTypes.append(at)
self.controller.notify('AnnotationTypeCreate', annotationtype=at)
if delete_existing_toggle.get_active():
# Remove all annotations of at type
batch_id=object()
for a in at.annotations:
self.controller.delete_element(a, batch=batch_id)
self.options['empty-annotations']=empty_contents_toggle.get_active()
finished=True
else:
at=None
finished=True
d.destroy()
if at is not None:
self.options['annotation-type-id'] = at.id
ti=TranscriptionImporter(package=self.controller.package,
controller=self.controller,
defaulttype=at,
transcription_edit=self)
ti.process_file('transcription')
self.controller.package._modified=True
self.controller.notify("PackageActivate", package=ti.package)
self.message(_('Notes converted'))
self.log(ti.statistics_formatted())
# Feedback
dialog.message_dialog(
_("Conversion completed.\n%s annotations generated.") % ti.statistics['annotation'])
return True
def _init_ui(self):
app = self.app
# Dialog for showing and editing the axis value directly
buttons = (Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT)
dialog = gui.windowing.Dialog(
app, C_(
"symmetry axis options panel: "
"axis position dialog: window title",
u"X axis Position",
),
app.drawWindow,
buttons=buttons,
)
dialog.connect('response', self._axis_pos_dialog_response_cb)
grid = Gtk.Grid()
grid.set_border_width(gui.widgets.SPACING_LOOSE)
grid.set_column_spacing(gui.widgets.SPACING)
grid.set_row_spacing(gui.widgets.SPACING)
label = Gtk.Label(label=self._POSITION_LABEL_X_TEXT)
label.set_hexpand(False)
label.set_vexpand(False)
grid.attach(label, 0, 0, 1, 1)
entry = Gtk.SpinButton(
adjustment=self._axis_pos_adj_x,
climb_rate=0.25,
digits=0
)
entry.set_hexpand(True)
entry.set_vexpand(False)
grid.attach(entry, 1, 0, 1, 1)
dialog_content_box = dialog.get_content_area()
dialog_content_box.pack_start(grid, True, True, 0)
self._axis_pos_x_dialog = dialog
# Dialog for showing and editing the axis value directly
buttons = (Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT)
dialog = gui.windowing.Dialog(
app, C_(
"symmetry axis options panel: "
"axis position dialog: window title",
u"Y axis Position",
),
app.drawWindow,
buttons=buttons,
)
dialog.connect('response', self._axis_pos_dialog_response_cb)
grid = Gtk.Grid()
grid.set_border_width(gui.widgets.SPACING_LOOSE)
grid.set_column_spacing(gui.widgets.SPACING)
grid.set_row_spacing(gui.widgets.SPACING)
label = Gtk.Label(label=self._POSITION_LABEL_Y_TEXT)
label.set_hexpand(False)
label.set_vexpand(False)
grid.attach(label, 0, 0, 1, 1)
entry = Gtk.SpinButton(
adjustment=self._axis_pos_adj_y,
climb_rate=0.25,
digits=0
)
entry.set_hexpand(True)
entry.set_vexpand(False)
grid.attach(entry, 1, 0, 1, 1)
dialog_content_box = dialog.get_content_area()
dialog_content_box.pack_start(grid, True, True, 0)
self._axis_pos_y_dialog = dialog
# Layout grid
row = 0
grid = Gtk.Grid()
grid.set_border_width(gui.widgets.SPACING_CRAMPED)
grid.set_row_spacing(gui.widgets.SPACING_CRAMPED)
grid.set_column_spacing(gui.widgets.SPACING_CRAMPED)
self.add(grid)
row += 1
label = Gtk.Label(label=self._ALPHA_LABEL_TEXT)
label.set_hexpand(False)
label.set_halign(Gtk.Align.START)
grid.attach(label, 0, row, 1, 1)
scale = Gtk.Scale.new_with_range(
orientation = Gtk.Orientation.HORIZONTAL,
min = 0,
max = 1,
step = 0.1,
)
scale.set_draw_value(False)
line_alpha = self.app.preferences.get(_ALPHA_PREFS_KEY, _DEFAULT_ALPHA)
scale.set_value(line_alpha)
scale.set_hexpand(True)
scale.set_vexpand(False)
scale.connect("value-changed", self._scale_value_changed_cb)
grid.attach(scale, 1, row, 1, 1)
row += 1
store = Gtk.ListStore(int, str)
sym_types = lib.tiledsurface.SYMMETRY_TYPES
active_idx = 0
rootstack = self.app.doc.model.layer_stack
starts_with_rotate = (
rootstack.symmetry_type in
{
lib.mypaintlib.SymmetryRotational,
lib.mypaintlib.SymmetrySnowflake,
}
)
for i, sym_type in enumerate(sym_types):
label = lib.tiledsurface.SYMMETRY_STRINGS.get(sym_type)
store.append([sym_type, label])
if sym_type == rootstack.symmetry_type:
active_idx = i
self._symmetry_type_combo = Gtk.ComboBox()
self._symmetry_type_combo.set_model(store)
self._symmetry_type_combo.set_active(active_idx)
self._symmetry_type_combo.set_hexpand(True)
cell = Gtk.CellRendererText()
self._symmetry_type_combo.pack_start(cell, True)
self._symmetry_type_combo.add_attribute(cell, "text", 1)
self._symmetry_type_combo.connect(
'changed',
self._symmetry_type_combo_changed_cb
)
label = Gtk.Label(label=self._SYMMETRY_TYPE_TEXT)
label.set_hexpand(False)
label.set_halign(Gtk.Align.START)
grid.attach(label, 0, row, 1, 1)
grid.attach(self._symmetry_type_combo, 1, row, 1, 1)
row += 1
label = Gtk.Label(label=self._SYMMETRY_ROT_LINES_TEXT)
label.set_hexpand(False)
label.set_halign(Gtk.Align.START)
self._axis_rot_sym_lines_entry = Gtk.SpinButton(
adjustment=self._axis_rot_symmetry_lines,
climb_rate=0.25
)
grid.attach(label, 0, row, 1, 1)
grid.attach(self._axis_rot_sym_lines_entry, 1, row, 1, 1)
row += 1
label = Gtk.Label(label=self._POSITION_LABEL_X_TEXT)
label.set_hexpand(False)
label.set_halign(Gtk.Align.START)
button = Gtk.Button(label=self._POSITION_BUTTON_TEXT_INACTIVE)
button.set_vexpand(False)
button.connect("clicked", self._axis_pos_x_button_clicked_cb)
button.set_hexpand(True)
button.set_vexpand(False)
grid.attach(label, 0, row, 1, 1)
grid.attach(button, 1, row, 1, 1)
self._axis_pos_x_button = button
row += 1
label = Gtk.Label(label=self._POSITION_LABEL_Y_TEXT)
label.set_hexpand(False)
label.set_halign(Gtk.Align.START)
button = Gtk.Button(label=self._POSITION_BUTTON_TEXT_INACTIVE)
button.set_vexpand(False)
button.connect("clicked", self._axis_pos_y_button_clicked_cb)
button.set_hexpand(True)
button.set_vexpand(False)
grid.attach(label, 0, row, 1, 1)
grid.attach(button, 1, row, 1, 1)
self._axis_pos_y_button = button
row += 1
button = Gtk.CheckButton()
toggle_action = self.app.find_action("SymmetryActive")
button.set_related_action(toggle_action)
button.set_label(C_(
"symmetry axis options panel: axis active checkbox",
u'Enabled',
))
button.set_hexpand(True)
button.set_vexpand(False)
grid.attach(button, 1, row, 2, 1)
self._axis_active_button = button
def __init__(self, win):
# Show the Display brand and model
self.model = get_model()
info_message = _(" (Changing this requires a reboot)")
# And the current display resolution
try:
current_resolution = get_status()['resolution']
info_message += _("\n\nCurrent resolution: {}").format(_(current_resolution))
except:
pass
Template.__init__(
self,
_("Display"),
self.model + info_message,
_("APPLY CHANGES")
)
self.win = win
self.win.set_main_widget(self)
self.win.top_bar.enable_prev()
self.win.change_prev_callback(self.win.go_to_home)
self.kano_button.connect('button-release-event', self.apply_changes)
self.kano_button.connect('key-release-event', self.apply_changes)
horizontal_container = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL,
spacing=40)
horizontal_container.set_valign(Gtk.Align.CENTER)
# HDMI mode combo box
self.mode_combo = KanoComboBox(max_display_items=7)
self.mode_combo.connect('changed', self.on_mode_changed)
# Fill list of modes
modes = list_supported_modes()
self.mode_combo.append('auto')
if modes:
for v in modes:
self.mode_combo.append(v)
horizontal_container.pack_start(self.mode_combo, False, False, 0)
self.mode_combo.props.valign = Gtk.Align.CENTER
# Select the current setting in the dropdown list
saved_group, saved_mode = read_hdmi_mode()
active_item = find_matching_mode(modes, saved_group, saved_mode)
self.mode_combo.set_selected_item_index(active_item)
self.init_item = active_item
self.mode_index = active_item
# Overscan button
overscan_button = OrangeButton(_("Overscan"))
horizontal_container.pack_end(overscan_button, False, False, 0)
overscan_button.connect('button-release-event', self.go_to_overscan)
self.box.pack_start(horizontal_container, False, False, 0)
# Create Flip 180 checkbox
flip_button = Gtk.CheckButton(_("Flip Screen"))
flip_button.set_can_focus(False)
flip_button.props.valign = Gtk.Align.CENTER
flip_button.set_active(get_screen_value('display_rotate') == 2)
flip_button.connect('clicked', self.flip)
self.box.pack_start(flip_button, False, False, 0)
self.kano_button.set_sensitive(False)
# Add apply changes button under the main settings content
self.win.show_all()
def __init__(self,
element_obj,
value='',
title='',
description='',
editable=True,
deletable=False,
deleted=False):
self._element_obj = element_obj
self._deletable = True
self._widget = Gtk.Box()
self._widget.set_orientation(Gtk.Orientation.VERTICAL)
self._widget.set_margin_top(5)
self._widget.set_margin_start(5)
self._widget.set_margin_end(5)
self._widget.set_margin_bottom(5)
self._widget.set_spacing(5)
self._value_widget = Gtk.Image()
self._value_widget_sw = Gtk.ScrolledWindow()
self._value_widget_sw.set_size_request(200, 200)
self._value_widget_sw.add(self._value_widget)
self._image_buttons = Gtk.ButtonBox()
self._image_buttons.set_orientation(Gtk.Orientation.HORIZONTAL)
open_img_button = Gtk.Button("Open..")
open_img_button.set_no_show_all(True)
self._open_img_button = open_img_button
open_img_button.connect('clicked', self._on_open_img_button_clicked)
save_img_button = Gtk.Button("Save..")
self._image_buttons.pack_start(open_img_button, False, False, 0)
self._image_buttons.pack_start(save_img_button, False, False, 0)
self._title_widget_box = Gtk.Box()
self._title_widget_box.set_orientation(Gtk.Orientation.HORIZONTAL)
self._title_widget_box.show_all()
present_button = Gtk.CheckButton()
self._present_button = present_button
present_button.set_no_show_all(True)
present_button.hide()
self._title = Gtk.Label()
self._title.set_alignment(0, 0.5)
self._title.set_no_show_all(True)
self._title.hide()
self._description = Gtk.Label()
self._description.set_alignment(0, 0.5)
self._description.set_no_show_all(True)
self._description.hide()
self._title_widget_box.pack_start(present_button, False, False, 0)
self._title_widget_box.pack_start(self._title, True, True, 0)
self._widget.pack_start(self._value_widget_sw, False, False, 0)
self._widget.pack_start(self._image_buttons, False, False, 0)
self._widget.pack_start(self._description, False, False, 0)
self._frame = Gtk.Frame()
self._frame.set_no_show_all(True)
self._frame.hide()
self._frame.add(self._widget)
self._frame.set_label_widget(self._title_widget_box)
self._widget.show_all()
self.set_value(value)
self.set_title(title)
self.set_description(description)
self.set_deletable(deletable)
self.set_deleted(deleted)
self.set_editable(editable)
return
def __init__(self, setting):
super().__init__()
self.setting = setting
# maingrid
maingrid = Gtk.Grid()
maingrid.set_column_homogeneous(False)
maingrid.set_border_width(10)
self.add(maingrid)
# uptime section
uptime_label = Gtk.Label("Work time (min):\t", xalign=0)
maingrid.attach(uptime_label, 0, 0, 1, 1)
uptime_set = tab_settings.get_int("awaketime")
uptime = Gtk.SpinButton.new_with_range(1, 90, 1)
uptime.set_value(uptime_set)
uptime.connect("value-changed", self.update_setting, "awaketime")
maingrid.attach(uptime, 1, 0, 1, 1)
# breaktime section
breaktime_label = Gtk.Label("Break time (min):\t", xalign=0)
maingrid.attach(breaktime_label, 0, 1, 1, 1)
breaktime_set = tab_settings.get_int("sleeptime")
breaktime = Gtk.SpinButton.new_with_range(1, 90, 1)
breaktime.set_value(breaktime_set)
breaktime.connect("value-changed", self.update_setting, "sleeptime")
maingrid.attach(breaktime, 1, 1, 1, 1)
# sep below time section
maingrid.attach(Gtk.Label("\n"), 0, 5, 1, 1)
# show notifications checkbox
shownotify = Gtk.CheckButton("Show notifications")
notify_set = tab_settings.get_boolean("showmessage")
shownotify.set_active(notify_set)
shownotify.connect("toggled", self.update_setting, "showmessage")
maingrid.attach(shownotify, 0, 6, 4, 1)
# smart resume checkbox
smartres = Gtk.CheckButton("Smart resume")
smartres_set = tab_settings.get_boolean("smartresume")
smartres.set_active(smartres_set)
smartres.connect("toggled", self.update_setting, "smartresume")
smartres.set_tooltip_text(
"After a break, start count down when user is active")
maingrid.attach(smartres, 0, 7, 4, 1)
# automatically unlock checkbox
autounlock = Gtk.CheckButton("Automatically unlock after break")
autounlock_set = tab_settings.get_boolean("unlockafterbreak")
autounlock.set_active(autounlock_set)
autounlock.connect("toggled", self.update_setting, "unlockafterbreak")
autounlock.set_tooltip_text(
"After a break, automatically unlock screen")
maingrid.attach(autounlock, 0, 8, 4, 1)
# sep below section
maingrid.attach(Gtk.Label("\n"), 0, 9, 1, 1)
# option label
breaktime_label = Gtk.Label("Effect:\n", xalign=0)
maingrid.attach(breaktime_label, 0, 10, 1, 1)
# dropdown
self.effect_options = [
["rotate", "Screen upside down"],
["dim", "Dim screen"],
["message", "Countdown message"],
["lock", "Lock screen"],
]
effect_set = tab_settings.get_string("mode")
effect_index = [s[0] for s in self.effect_options].index(effect_set)
effect_box = Gtk.Box()
command_combo = Gtk.ComboBoxText()
command_combo.set_entry_text_column(0)
for cmd in self.effect_options:
command_combo.append_text(cmd[1])
command_combo.set_active(effect_index)
command_combo.connect("changed", self.update_setting, "mode")
maingrid.attach(effect_box, 0, 11, 2, 1)
effect_box.pack_start(command_combo, False, True, 0)
self.show_all()
def __init__(self,
element_obj,
value='',
title='',
description='',
editable=True,
deletable=False,
deleted=False,
momentarily_deletable=None):
"""
momentarily_deletable must be None or callable with one parameter,
which receives instance of object to remove (self)
"""
self._element_obj = element_obj
self._momentarily_deletable = momentarily_deletable
self._deletable = True
self._widget = Gtk.Box()
self._widget.set_orientation(Gtk.Orientation.VERTICAL)
self._widget.set_margin_top(5)
self._widget.set_margin_start(5)
self._widget.set_margin_end(5)
self._widget.set_margin_bottom(5)
self._widget.set_spacing(5)
self._value_widget = Gtk.Label()
self._title_widget_box = Gtk.Box()
self._title_widget_box.set_orientation(Gtk.Orientation.HORIZONTAL)
self._title_widget_box.show_all()
present_button = Gtk.CheckButton()
self._present_button = present_button
present_button.set_no_show_all(True)
present_button.hide()
self._title = Gtk.Label()
self._title.set_alignment(0, 0.5)
self._title.set_no_show_all(True)
self._title.hide()
self._description = Gtk.Label()
self._description.set_alignment(0, 0.5)
self._description.set_no_show_all(True)
self._description.hide()
self._title_widget_box.pack_start(present_button, False, False, 0)
self._title_widget_box.pack_start(self._title, True, True, 0)
delete_button = Gtk.Button('x')
delete_button.set_no_show_all(True)
delete_button.hide()
self._delete_button = delete_button
delete_button.connect('clicked', self._on_delete_button_clicked)
self._title_widget_box.pack_start(delete_button, False, False, 0)
self._widget.pack_start(self._value_widget, False, False, 0)
self._widget.pack_start(self._description, False, False, 0)
self._frame = Gtk.Frame()
self._frame.set_no_show_all(True)
self._frame.hide()
self._frame.add(self._widget)
self._frame.set_label_widget(self._title_widget_box)
self._widget.show_all()
self.set_value(value)
self.set_title(title)
self.set_description(description)
self.set_deletable(deletable)
self.set_deleted(deleted)
self.set_editable(editable)
return
def __init__(self):
Gtk.Window.__init__(self, title="ListBox 测试")
self.set_border_width(10)
box_outer = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
self.add(box_outer)
listbox = Gtk.ListBox()
listbox.set_selection_mode(Gtk.SelectionMode.NONE)
box_outer.pack_start(listbox, True, True, 0)
row = Gtk.ListBoxRow()
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=50)
row.add(hbox)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
hbox.pack_start(vbox, True, True, 0)
label1 = Gtk.Label("Automatic Date & Time", xalign=0)
label2 = Gtk.Label("Requires internet access", xalign=0)
vbox.pack_start(label1, True, True, 0)
vbox.pack_start(label2, True, True, 0)
switch = Gtk.Switch()
switch.props.valign = Gtk.Align.CENTER
hbox.pack_start(switch, False, True, 0)
listbox.add(row)
row = Gtk.ListBoxRow()
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=50)
row.add(hbox)
label = Gtk.Label("Enable Automatic Update", xalign=0)
check = Gtk.CheckButton()
hbox.pack_start(label, True, True, 0)
hbox.pack_start(check, False, True, 0)
listbox.add(row)
row = Gtk.ListBoxRow()
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=50)
row.add(hbox)
label = Gtk.Label("Date Format", xalign=0)
combo = Gtk.ComboBoxText()
combo.insert(0, "0", "24-hour")
combo.insert(1, "1", "AM/PM")
hbox.pack_start(label, True, True, 0)
hbox.pack_start(combo, False, True, 0)
listbox.add(row)
listbox_2 = Gtk.ListBox()
items = 'This is a sorted ListBox Fail'.split()
for item in items:
listbox_2.add(ListBoxRowWithData(item))
def sort_func(row_1, row_2, data, notify_destroy):
return row_1.data.lower() > row_2.data.lower()
def filter_func(row, data, notify_destroy):
return False if row.data == 'Fail' else True
listbox_2.set_sort_func(sort_func, None, False)
listbox_2.set_filter_func(filter_func, None, False)
def on_row_activated(listbox_widget, row):
print(row.data)
listbox_2.connect('row-activated', on_row_activated)
box_outer.pack_start(listbox_2, True, True, 0)
listbox_2.show_all()
def __init__(self,ccw):
self.__dev = bus.get_object(interface, "/org/freedesktop/UDisks")
PluginsClass.__init__(self, ccw, caption, category, priority)
vb=Gtk.VBox(False,2)
self.add(vb)
h=Gtk.HBox(False,2); vb.pack_start(h,False,False,6)
l=Gtk.Label(description)
h.pack_start(l,False,False,2)
hb=Gtk.HBox(False,2); vb.pack_start(hb,False,False,6)
hb.pack_start(Gtk.Label(_('Source:')), False,False,2)
self.src_iso_file=Gtk.RadioButton.new_with_label_from_widget(None, label=_('from iso file'))
hb.pack_start(self.src_iso_file, False,False,2)
h=Gtk.HBox(False,2); hb.pack_start(h,False,False,2)
self.iso_file_b=Gtk.FileChooserButton(_('Choose live iso file'))
h.pack_start(self.iso_file_b, False,False,2)
self.src_iso_file.connect('toggled', lambda b: self.iso_file_b.set_sensitive(b.get_active()))
self.src_iso_dev=Gtk.RadioButton.new_with_label_from_widget(self.src_iso_file, label=_('from CD/DVD device'))
hb.pack_start(self.src_iso_dev, False,False,2)
self.src_iso_dev_h=h=Gtk.HBox(False,2); hb.pack_start(h,False,False,2)
self.src_iso_dev.connect('toggled', lambda b: self.src_iso_dev_h.set_sensitive(b.get_active()))
self.iso_dev_ls=Gtk.ComboBoxText()
h.pack_start(self.iso_dev_ls, False,False,2)
b=Gtk.Button(stock=Gtk.STOCK_REFRESH)
b.connect('clicked', self.refresh_src_dev)
h.pack_start(b, False,False,2)
self.src_iso_dev.set_active(True)
self.src_iso_file.set_active(True)
h=Gtk.HBox(False,2); vb.pack_start(h,False,False,6)
h.pack_start(Gtk.Label(_('Target Device:')), False,False,2)
self.target_dev_ls=Gtk.ComboBoxText()
h.pack_start(self.target_dev_ls, True,True,2)
b=Gtk.Button(stock=Gtk.STOCK_REFRESH)
b.connect('clicked', self.refresh_target_dev)
h.pack_start(b, False,False,2)
h=Gtk.HBox(False,2); vb.pack_start(h,False,False,6)
h.pack_start(Gtk.Label(_('Target Options:')), False,False,2)
self.format=Gtk.CheckButton(_('Format target partition'))
self.format.set_tooltip_text(_('uncheck this button to preserve data on target device'))
h.pack_start(self.format, False,False,2)
self.reset_mbr=Gtk.CheckButton(_('Reset MBR'))
self.reset_mbr.set_active(True)
h.pack_start(self.reset_mbr, False,False,2)
h.pack_start(Gtk.Label(_('Overlay size:')), False,False,2)
self.overlay_size=Gtk.SpinButton()
self.overlay_size.set_tooltip_text(_('size of persistent overlay in MB, 0 to disable'))
self.overlay_size.set_adjustment(Gtk.Adjustment(200, 0, 10240, 10, 0, 0))
h.pack_start(self.overlay_size, False,False,2)
h.pack_start(Gtk.Label(_('MB')), False,False,0)
# TODO: all the below options needs interaction to enter the pass-phrase
# h.pack_start(Gtk.Label('Home image size:'), False,False,2)
# self.home_size=Gtk.SpinButton()
# self.home_size.set_tooltip_text(_('size of home image in MB, 0 to use the overlay'))
# self.home_size.set_range(0,10240)
# self.home_size.set_value(0)
# h.pack_start(self.home_size, False,False,2)
# self.home_enc=Gtk.CheckButton(_('encrypted'))
# self.home_enc.set_tooltip_text(_('Encrypt Home image'))
h=Gtk.HBox(False,2); vb.pack_start(h,False,False,6)
b=Gtk.Button(stock=Gtk.STOCK_EXECUTE)
b.connect('clicked', self.execute)
h.pack_start(b, False,False,2)
h.pack_start(Gtk.Label(_("This will take some time.")), False,False,2)
ff=Gtk.FileFilter(); ff.add_pattern('*.[Ii][Ss][Oo]')
self.iso_file_b.set_filter(ff)
self.refresh_src_dev()
self.refresh_target_dev()
def __init__(self):
Gtk.Window.__init__(self, type=Gtk.WindowType.TOPLEVEL)
self.set_default_size(500, 500)
self.connect("destroy", lambda x: Gtk.main_quit())
self.set_title("OpenStreetMap GPS Mapper")
self.vbox = Gtk.VBox(homogeneous=False, spacing=0)
self.add(self.vbox)
if 0:
self.osm = DummyMapNoGpsPoint()
else:
self.osm = osmgpsmap.Map()
self.osm.layer_add(
osmgpsmap.MapOsd(show_dpad=True,
show_zoom=True,
show_crosshair=True))
self.osm.set_property("map-source",
osmgpsmap.MapSource_t.OPENSTREETMAP)
self.osm.layer_add(DummyLayer())
self.last_image = None
self.osm.connect("button_press_event", self.on_button_press)
self.osm.connect("changed", self.on_map_change)
# connect keyboard shortcuts
self.osm.set_keyboard_shortcut(osmgpsmap.MapKey_t.FULLSCREEN,
Gdk.keyval_from_name("F11"))
self.osm.set_keyboard_shortcut(osmgpsmap.MapKey_t.UP,
Gdk.keyval_from_name("Up"))
self.osm.set_keyboard_shortcut(osmgpsmap.MapKey_t.DOWN,
Gdk.keyval_from_name("Down"))
self.osm.set_keyboard_shortcut(osmgpsmap.MapKey_t.LEFT,
Gdk.keyval_from_name("Left"))
self.osm.set_keyboard_shortcut(osmgpsmap.MapKey_t.RIGHT,
Gdk.keyval_from_name("Right"))
# connect to tooltip
self.osm.props.has_tooltip = True
self.osm.connect("query-tooltip", self.on_query_tooltip)
self.latlon_entry = Gtk.Entry()
zoom_in_button = Gtk.Button.new_from_icon_name("zoom-in",
Gtk.IconSize.BUTTON)
zoom_in_button.connect("clicked", self.zoom_in_clicked)
zoom_out_button = Gtk.Button.new_from_icon_name(
"zoom-out", Gtk.IconSize.BUTTON)
zoom_out_button.connect("clicked", self.zoom_out_clicked)
home_button = Gtk.Button.new_from_icon_name("go-home",
Gtk.IconSize.BUTTON)
home_button.connect("clicked", self.home_clicked)
cache_button = Gtk.Button(label="Cache")
cache_button.connect("clicked", self.cache_clicked)
self.vbox.pack_start(self.osm, True, True, 0)
hbox = Gtk.HBox(homogeneous=False, spacing=0)
hbox.pack_start(zoom_in_button, False, True, 0)
hbox.pack_start(zoom_out_button, False, True, 0)
hbox.pack_start(home_button, False, True, 0)
hbox.pack_start(cache_button, False, True, 0)
# add ability to test custom map URIs
ex = Gtk.Expander(label="<b>Map Repository URI</b>")
ex.props.use_markup = True
vb = Gtk.VBox()
self.repouri_entry = Gtk.Entry()
self.repouri_entry.set_text(self.osm.props.repo_uri)
self.image_format_entry = Gtk.Entry()
self.image_format_entry.set_text(self.osm.props.image_format)
lbl = Gtk.Label(label="""Enter an repository URL to fetch map tiles \
from in the box below. Special metacharacters may be included in this url
<i>Metacharacters:</i>
\t#X\tMax X location
\t#Y\tMax Y location
\t#Z\tMap zoom (0 = min zoom, fully zoomed out)
\t#S\tInverse zoom (max-zoom - #Z)
\t#Q\tQuadtree encoded tile (qrts)
\t#W\tQuadtree encoded tile (1234)
\t#U\tEncoding not implemeted
\t#R\tRandom integer, 0-4""")
lbl.props.xalign = 0
lbl.props.use_markup = True
lbl.props.wrap = True
ex.add(vb)
vb.pack_start(lbl, False, True, 0)
hb = Gtk.HBox()
hb.pack_start(Gtk.Label(label="URI: "), False, True, 0)
hb.pack_start(self.repouri_entry, True, True, 0)
vb.pack_start(hb, False, True, 0)
hb = Gtk.HBox()
hb.pack_start(Gtk.Label(label="Image Format: "), False, True, 0)
hb.pack_start(self.image_format_entry, True, True, 0)
vb.pack_start(hb, False, True, 0)
gobtn = Gtk.Button(label="Load Map URI")
gobtn.connect("clicked", self.load_map_clicked)
vb.pack_start(gobtn, False, True, 0)
self.show_tooltips = False
cb = Gtk.CheckButton(label="Show Location in Tooltips")
cb.props.active = self.show_tooltips
cb.connect("toggled", self.on_show_tooltips_toggled)
self.vbox.pack_end(cb, False, True, 0)
cb = Gtk.CheckButton(label="Disable Cache")
cb.props.active = False
cb.connect("toggled", self.disable_cache_toggled)
self.vbox.pack_end(cb, False, True, 0)
self.vbox.pack_end(ex, False, True, 0)
self.vbox.pack_end(self.latlon_entry, False, True, 0)
self.vbox.pack_end(hbox, False, True, 0)
GLib.timeout_add(500, self.print_tiles)
def add(self, key):
sections = key.split('-')
if sections[1] == 'display':
item = Gtk.CheckButton(label=_('Display'))
item.set_active(self.schema.get_boolean(key))
self.hbox0.add(item)
item.connect('toggled', set_boolean, self.schema, key)
elif sections[1] == 'refresh':
item = IntSelect(_('Refresh Time'))
item.set_args(50, 100000, 100, 1000)
item.set_value(self.schema.get_int(key))
self.hbox1.add(item.actor)
item.spin.connect('output', set_int, self.schema, key)
elif sections[1] == 'graph' and sections[2] == 'width':
item = IntSelect(_('Graph Width'))
item.set_args(1, 1000, 1, 10)
item.set_value(self.schema.get_int(key))
self.hbox1.add(item.actor)
item.spin.connect('output', set_int, self.schema, key)
elif sections[1] == 'show' and sections[2] == 'text':
item = Gtk.CheckButton(label=_('Show Text'))
item.set_active(self.schema.get_boolean(key))
self.hbox0.add(item)
item.connect('toggled', set_boolean, self.schema, key)
elif sections[1] == 'style':
item = Select(_('Display Style'))
item.add((_('digit'), _('graph'), _('both')))
item.set_value(self.schema.get_enum(key))
self.hbox1.add(item.actor)
item.selector.connect('changed', set_enum, self.schema, key)
elif sections[1] == 'speed':
item = Gtk.CheckButton(label=_('Show network speed in bits'))
item.set_active(self.schema.get_boolean(key))
self.hbox3.add(item)
item.connect('toggled', set_boolean, self.schema, key)
elif len(sections) == 3 and sections[2] == 'color':
item = ColorSelect(_(sections[1].capitalize()))
item.set_value(self.schema.get_string(key))
self.hbox2.pack_end(item.actor, True, False, 0)
item.picker.connect('color-set', set_color, self.schema, key)
elif sections[1] == 'sensor':
_slist, _strlist = check_sensors()
item = Select(_('Sensor'))
if (len(_slist) == 0):
item.add((_('Please install lm-sensors'), ))
if (len(_slist) == 1):
self.schema.set_string(key, _slist[0])
item.add(_strlist)
try:
item.set_value(_slist.index(self.schema.get_string(key)))
except ValueError:
item.set_value(0)
self.hbox3.add(item.actor)
item.selector.connect('changed', set_string, self.schema, key,
_slist)
elif sections[1] == 'time':
item = Gtk.CheckButton(label=_('Show Time Remaining'))
item.set_active(self.schema.get_boolean(key))
self.hbox3.add(item)
item.connect('toggled', set_boolean, self.schema, key)
elif sections[1] == 'hidesystem':
item = Gtk.CheckButton(label=_('Hide System Icon'))
item.set_active(self.schema.get_boolean(key))
self.hbox3.add(item)
item.connect('toggled', set_boolean, self.schema, key)
elif sections[1] == 'usage':
item = Select(_('Display disk usage as'))
item.add((_('pie'), _('bar'), _('none')))
item.set_value(self.schema.get_enum(key))
self.hbox3.add(item.actor)
item.selector.connect('changed', set_enum, self.schema, key)
# test Gtk.RadioButton:
radio_1 = Gtk.RadioButton.new_with_label_from_widget(None, 'Radio 1')
box.pack_start(radio_1, False, False, 1)
radio_1.show()
radio_2 = Gtk.RadioButton.new_with_label_from_widget(radio_1, 'Radio 2')
box.pack_start(radio_2, False, False, 1)
radio_2.show()
radio_3 = Gtk.RadioButton.new_with_label_from_widget(radio_1, 'Radio 3')
box.pack_start(radio_3, False, False, 1)
radio_3.show()
# test Gtk.CheckButton:
check_1 = Gtk.CheckButton('Check 1')
box.pack_start(check_1, False, False, 1)
check_1.show()
check_2 = Gtk.CheckButton('Check 2')
box.pack_start(check_2, False, False, 1)
check_2.show()
# test Gtk.Button:
button = Gtk.Button('Button')
box.pack_start(button, False, False, 1)
button.show()
# test Gtk.Button insensitive:
def __init__(self, main):
Gtk.Window.__init__(self)
self.progress_dict = {}
self.progress_phase = 0
self.progress_books_in_file = 0
self.progress_element = 0
self.add_dlg = None
self.set_size_request(-1, 400)
## prepare dnd
self.drag_dest_set(Gtk.DestDefaults.ALL, [], Gdk.DragAction.COPY)
self.drag_dest_set_target_list(targets)
self.connect('drag-data-received', self.drop_data_cb)
self.set_title(_('Import Shamela .bok files'))
self.set_type_hint(Gdk.WindowTypeHint.DIALOG)
self.set_modal(True)
self.set_transient_for(main)
self.main = main
self.connect('delete-event', self.close_cb)
self.connect('destroy', self.close_cb)
vb = Gtk.VBox(False, 2)
self.add(vb)
hb0 = Gtk.HBox(False, 2)
vb.pack_start(hb0, False, False, 2)
self.tool = hb = Gtk.HBox(False, 2)
hb0.pack_start(hb, False, False, 2)
b = Gtk.Button(stock=Gtk.STOCK_ADD)
b.connect('clicked', self.add_cb, self)
hb.pack_start(b, False, False, 2)
b = Gtk.Button(stock=Gtk.STOCK_REMOVE)
b.connect('clicked', self.rm)
hb.pack_start(b, False, False, 2)
b = Gtk.Button(stock=Gtk.STOCK_CLEAR)
b.connect('clicked', lambda *a: self.ls.clear())
hb.pack_start(b, False, False, 2)
b = Gtk.Button(stock=Gtk.STOCK_CONVERT)
b.connect('clicked', self.start)
hb.pack_start(b, False, False, 2)
self.progress = Gtk.ProgressBar()
self.progress.set_fraction(0.0)
hb0.pack_start(self.progress, True, True, 2)
self.cancel_b = b = Gtk.Button(stock=Gtk.STOCK_CANCEL)
b.connect('clicked', self.stop)
b.set_sensitive(False)
hb0.pack_start(b, False, False, 2)
self.close_b = b = Gtk.Button(stock=Gtk.STOCK_CLOSE)
b.connect('clicked', self.close_cb)
hb0.pack_start(b, False, False, 2)
self.ls = Gtk.ListStore(str, str, float, int,
str) # fn, basename, percent, pulse, label
self.lsv = Gtk.TreeView(self.ls)
#self.lsv.set_size_request(250, -1)
cells = []
cols = []
cells.append(Gtk.CellRendererText())
cols.append(Gtk.TreeViewColumn('Files', cells[-1], text=1))
cols[-1].set_sizing(Gtk.TreeViewColumnSizing.AUTOSIZE)
cols[-1].set_resizable(True)
cols[-1].set_expand(True)
cells.append(Gtk.CellRendererProgress())
cols.append(
Gtk.TreeViewColumn('%', cells[-1], value=2, pulse=3, text=4))
cols[-1].set_expand(False)
self.lsv.set_headers_visible(True)
self.lsv.get_selection().set_mode(Gtk.SelectionMode.MULTIPLE)
for i in cols:
self.lsv.insert_column(i, -1)
scroll = Gtk.ScrolledWindow()
scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
scroll.add(self.lsv)
vb.pack_start(scroll, True, True, 2)
self.x = x = Gtk.Expander.new(_("Advanced options"))
vb.pack_start(x, False, False, 2)
xvb = Gtk.VBox(False, 2)
x.add(xvb)
f = Gtk.Frame.new(_('Performance tuning:'))
xvb.add(f)
fvb = Gtk.VBox(False, 2)
f.add(fvb)
hb = Gtk.HBox(False, 2)
fvb.add(hb)
self.in_mem = Gtk.CheckButton(_('in memory'))
self.in_mem.set_tooltip_text(
_("faster but consumes more memory and harder to debug."))
hb.pack_start(self.in_mem, False, False, 2)
f = Gtk.Frame.new('Version Control:')
xvb.add(f)
fvb = Gtk.VBox(False, 2)
f.add(fvb)
hb = Gtk.HBox(False, 2)
fvb.add(hb)
hb.pack_start(Gtk.Label(_('Release Major:')), False, False, 2)
adj = Gtk.Adjustment(0, 0, 10000, 1, 10, 0)
self.releaseMajor = s = Gtk.SpinButton()
s.set_adjustment(adj)
hb.pack_start(self.releaseMajor, False, False, 2)
hb.pack_start(Gtk.Label(_('Release Minor:')), False, False, 2)
self.releaseMinor = s = Gtk.SpinButton()
s.set_adjustment(adj)
hb.pack_start(self.releaseMinor, False, False, 2)
f = Gtk.Frame.new('Footnotes:')
xvb.add(f)
fvb = Gtk.VBox(False, 2)
f.add(fvb)
hb = Gtk.HBox(False, 2)
fvb.add(hb)
hb.pack_start(Gtk.Label(_('Prefix:')), False, False, 2)
self.ft_prefix = Gtk.Entry()
self.ft_prefix.set_text('(')
self.ft_prefix.set_width_chars(3)
hb.pack_start(self.ft_prefix, False, False, 2)
hb.pack_start(Gtk.Label(_('Suffix:')), False, False, 2)
self.ft_suffix = Gtk.Entry()
self.ft_suffix.set_text(')')
self.ft_suffix.set_width_chars(3)
hb.pack_start(self.ft_suffix, False, False, 2)
self.ft_at_line_start = Gtk.CheckButton(_('only at line start'))
hb.pack_start(self.ft_at_line_start, False, False, 2)
hb = Gtk.HBox(False, 2)
fvb.add(hb)
hb.pack_start(Gtk.Label(_('in between spaces:')), False, False, 2)
self.ft_sp = [Gtk.RadioButton(group=None, label=_('no spaces'))]
self.ft_sp.append(
Gtk.RadioButton(group=self.ft_sp[0],
label=_('optional white-space')))
self.ft_sp.append(
Gtk.RadioButton(group=self.ft_sp[0],
label=_('optional white-spaces')))
for i in self.ft_sp:
hb.pack_start(i, False, False, 2)
f = Gtk.Frame.new('Footnote anchors in body:')
xvb.add(f)
fvb = Gtk.VBox(False, 2)
f.add(fvb)
hb = Gtk.HBox(False, 2)
fvb.add(hb)
hb.pack_start(Gtk.Label(_('Prefix:')), False, False, 2)
self.bft_prefix = Gtk.Entry()
self.bft_prefix.set_text('(')
self.bft_prefix.set_width_chars(3)
hb.pack_start(self.bft_prefix, False, False, 2)
hb.pack_start(Gtk.Label(_('Suffix:')), False, False, 2)
self.bft_suffix = Gtk.Entry()
self.bft_suffix.set_text(')')
self.bft_suffix.set_width_chars(3)
hb.pack_start(self.bft_suffix, False, False, 2)
hb = Gtk.HBox(False, 2)
fvb.add(hb)
hb.pack_start(Gtk.Label(_('in between spaces:')), False, False, 2)
self.bft_sp = [Gtk.RadioButton(group=None, label=_('no spaces'))]
self.bft_sp.append(
Gtk.RadioButton(group=self.bft_sp[0],
label=_('optional white-space')))
self.bft_sp.append(
Gtk.RadioButton(group=self.bft_sp[0],
label=_('optional white-spaces')))
for i in self.bft_sp:
hb.pack_start(i, False, False, 2)
# TODO: add options to specify version and revision
# TODO: add options to specify wither to break by hno
# TODO: add options for handling existing files (overwrite?)
ft_at_line_start = False
ft_prefix = u'('
ft_suffix = u')'
ft_sp = u'' # can be ur'\s?' or ur'\s*'
body_footnote_re = re.escape(
ft_prefix) + ft_sp + ur'(\d+)' + ft_sp + re.escape(ft_suffix)
footnote_re = (ft_at_line_start and u'^\s*' or u'') + body_footnote_re
ft_prefix_len = len(ft_prefix)
ft_suffix_len = len(ft_suffix)
def create_main_window(self):
self.get_banner()
self.monitors_list, self.monitor_primary = monitors.get_monitors()
self.main_window = Gtk.Window(
title = _("Games Nebula"),
type = Gtk.WindowType.TOPLEVEL,
window_position = Gtk.WindowPosition.CENTER_ALWAYS,
resizable = False,
icon = app_icon,
)
self.main_window.connect('delete-event', self.quit_app)
self.grid = Gtk.Grid(
margin_left = 10,
margin_right = 10,
margin_top = 10,
margin_bottom = 10,
row_spacing = 10,
column_spacing = 10,
column_homogeneous = True,
)
self.banner = Gtk.Image(
file = self.banner_path,
no_show_all = True
)
self.banner.set_visible(self.show_banner)
self.expander = Gtk.Expander(
label = _("Wine")
)
self.frame = Gtk.Frame(
#label = _("Wine"),
label_xalign = 0.5,
#margin_bottom = 10,
margin_left = 10,
margin_right = 10,
)
self.frame_grid = Gtk.Grid(
column_homogeneous = True,
#row_homogeneous = True,
row_spacing = 10,
column_spacing = 10,
margin_top = 10,
margin_bottom = 10,
margin_left = 10,
margin_right = 10,
)
self.rbutton_global = Gtk.RadioButton(
name = 'global',
label = _("Global settings")
)
self.rbutton_sys = Gtk.RadioButton(
name = 'system',
label = _("System version")
)
self.rbutton_sys.join_group(self.rbutton_global)
self.rbutton_path = Gtk.RadioButton(
name = 'path',
label = _("From directory")
)
self.rbutton_path.join_group(self.rbutton_global)
if self.wine == 'global':
self.rbutton_global.set_active(True)
elif self.wine == 'system':
self.rbutton_sys.set_active(True)
if self.wine == 'path':
self.rbutton_path.set_label(_("From directory:"))
self.rbutton_path.set_active(True)
self.filechooser_button = Gtk.FileChooserButton(
title = _("Select a directory"),
action = Gtk.FileChooserAction.SELECT_FOLDER,
no_show_all = True
)
self.filechooser_button.set_filename(self.wine_path)
self.combobox_version = Gtk.ComboBoxText(
no_show_all = True
)
self.populate_wine_versions_combobox()
self.filechooser_button.connect('file-set', self.cb_filechooser_button)
self.combobox_version.connect('changed', self.cb_combobox_version)
self.label_win_ver = Gtk.Label(
label = _("Windows version")
)
self.combobox_win_ver = Gtk.ComboBoxText()
self.populate_win_ver_combobox()
self.combobox_win_ver.connect('changed', self.cb_combobox_win_ver)
self.checkbutton_prefix = Gtk.CheckButton(
label = _("Use own wine prefix"),
active = self.own_prefix
)
self.checkbutton_prefix.connect('toggled', self.cb_checkbutton_prefix)
self.combobox_winearch = Gtk.ComboBoxText(
tooltip_text = _("WINEARCH"),
no_show_all = True
)
self.combobox_winearch.connect('changed', self.cb_combobox_winearch)
self.win64_available()
self.combobox_winearch.append_text('win32')
self.combobox_winearch.append_text('win64')
if self.winearch == 'win32':
self.combobox_winearch.set_active(0)
elif self.winearch == 'win64':
self.combobox_winearch.set_active(1)
self.checkbutton_mouse = Gtk.CheckButton(
label = _("Capture the mouse in fullscreen windows"),
active = self.mouse_capture
)
self.checkbutton_mouse.connect('toggled', self.cb_checkbutton_mouse)
self.checkbutton_virtual_desktop = Gtk.CheckButton(
label = _("Emulate a virtual desktop"),
active = self.virtual_desktop
)
self.checkbutton_virtual_desktop.connect('toggled', self.cb_checkbutton_virtual_desktop)
self.entry_virt_width = Gtk.Entry(
placeholder_text = _("Width"),
max_length = 4,
max_width_chars = 4,
xalign = 0.5,
text = self.virtual_desktop_width,
no_show_all = True
)
self.entry_virt_width.set_visible(self.virtual_desktop)
self.entry_virt_width.connect('changed', self.cb_entry_virt_width)
self.entry_virt_height = Gtk.Entry(
placeholder_text = _("Height"),
max_length = 4,
max_width_chars = 4,
xalign = 0.5,
text = self.virtual_desktop_height,
no_show_all = True
)
self.entry_virt_height.set_visible(self.virtual_desktop)
self.entry_virt_height.connect('changed', self.cb_entry_virt_height)
self.label_version = Gtk.Label(
label = _("Version:"),
halign = Gtk.Align.CENTER,
)
self.label_specific_settings = Gtk.Label(
label = _("Game specific Wine settings:"),
halign = Gtk.Align.CENTER,
)
self.button_wine_settings = Gtk.Button(
label = _("Current wine prefix settings")
)
self.button_wine_settings.connect('clicked', self.cb_button_wine_settings)
self.frame_grid.attach(self.label_version, 0, 0, 2, 1)
self.frame_grid.attach(self.rbutton_global, 0, 1, 2, 1)
self.frame_grid.attach(self.rbutton_sys, 0, 2, 2, 1)
self.frame_grid.attach(self.rbutton_path, 0, 3, 2, 1)
self.frame_grid.attach(self.filechooser_button, 0, 4, 1, 1)
self.frame_grid.attach(self.combobox_version, 1, 4, 1, 1)
self.frame_grid.attach(self.label_specific_settings, 0, 5, 2, 1)
self.frame_grid.attach(self.checkbutton_prefix, 0, 6, 1, 1)
self.frame_grid.attach(self.combobox_winearch, 1, 6, 1, 1)
self.frame_grid.attach(self.checkbutton_mouse, 0, 7, 2, 1)
self.frame_grid.attach(self.checkbutton_virtual_desktop, 0, 8, 2, 1)
self.frame_grid.attach(self.entry_virt_width, 0, 9, 1, 1)
self.frame_grid.attach(self.entry_virt_height, 1, 9, 1, 1)
self.frame_grid.attach(self.label_win_ver, 0, 10, 1, 1)
self.frame_grid.attach(self.combobox_win_ver, 1, 10, 1, 1)
self.frame_grid.attach(self.button_wine_settings, 0, 11, 2, 1)
self.frame.add(self.frame_grid)
self.expander.add(self.frame)
self.rbutton_global.connect('toggled', self.cb_rbuttons)
self.rbutton_sys.connect('toggled', self.cb_rbuttons)
self.rbutton_path.connect('toggled', self.cb_rbuttons)
if (self.wine == 'global') or (self.wine == 'system'):
self.filechooser_button.set_visible(False)
self.combobox_version.set_visible(False)
else:
self.filechooser_button.set_visible(True)
self.combobox_version.set_visible(True)
self.label_monitor = Gtk.Label(
label = _("Monitor"),
)
self.combobox_monitor = Gtk.ComboBoxText()
for output in self.monitors_list:
self.combobox_monitor.append_text(output.replace('\n', ''))
self.combobox_monitor.set_active(self.monitor)
self.combobox_monitor.connect('changed', self.cb_combobox_monitor)
self.button_settings = Gtk.Button(
label = _("Game settings"),
no_show_all = True
)
if not os.path.exists(self.install_dir + '/' + self.game_name + '/settings.sh'):
self.button_settings.set_visible(False)
else:
self.button_settings.set_visible(True)
self.button_settings.connect('clicked', self.cb_button_settings)
expander_before = Gtk.Expander(
label = _("Execute before launching the game")
)
grid_before = Gtk.Grid(
margin_top = 10,
row_spacing = 10,
column_spacing = 5,
)
entry_before = Gtk.Entry(
name = 'command_before',
hexpand = True,
text = self.command_before,
sensitive = False
)
entry_before.connect('changed', self.cb_entries)
def cb_button_edit_before(button):
if entry_before.get_sensitive():
entry_before.set_sensitive(False)
else:
entry_before.set_sensitive(True)
img = Gtk.Image.new_from_icon_name("document-new", Gtk.IconSize.SMALL_TOOLBAR)
button_edit_before = Gtk.Button(
image = img,
tooltip_text = _("Edit")
)
button_edit_before.connect('clicked', cb_button_edit_before)
combobox_before = Gtk.ComboBoxText(
hexpand = True,
tooltip_text = _("Commands templates")
)
for command in sample_commands_list:
combobox_before.append_text(command)
combobox_before.set_active(0)
def cb_button_add_before(button):
new_command = sample_commands[combobox_before.get_active_text()]
current_command = entry_before.get_text()
if current_command == '':
entry_before.set_text(new_command)
else:
entry_before.set_text(current_command + ' && ' + new_command)
img = Gtk.Image.new_from_icon_name("go-up", Gtk.IconSize.SMALL_TOOLBAR)
button_add_before = Gtk.Button(
image = img,
tooltip_text = _("Add command template")
)
button_add_before.connect('clicked', cb_button_add_before)
grid_before.attach(entry_before, 0, 0, 1, 1)
grid_before.attach(button_edit_before, 1, 0, 1, 1)
grid_before.attach(combobox_before, 0, 1, 1, 1)
grid_before.attach(button_add_before, 1, 1, 1, 1)
expander_before.add(grid_before)
expander_after = Gtk.Expander(
label = _("Execute after exiting the game")
)
grid_after = Gtk.Grid(
margin_top = 10,
row_spacing = 10,
column_spacing = 5,
)
entry_after = Gtk.Entry(
name = 'command_after',
hexpand = True,
text = self.command_after,
sensitive = False
)
entry_after.connect('changed', self.cb_entries)
def cb_button_edit_after(button):
if entry_after.get_sensitive():
entry_after.set_sensitive(False)
else:
entry_after.set_sensitive(True)
img = Gtk.Image.new_from_icon_name("document-new", Gtk.IconSize.SMALL_TOOLBAR)
button_edit_after = Gtk.Button(
image = img,
tooltip_text = _("Edit")
)
button_edit_after.connect('clicked', cb_button_edit_after)
combobox_after = Gtk.ComboBoxText(
hexpand = True,
tooltip_text = _("Commands templates")
)
for command in sample_commands_list:
combobox_after.append_text(command)
combobox_after.set_active(0)
def cb_button_add_after(button):
new_command = sample_commands[combobox_after.get_active_text()]
current_command = entry_after.get_text()
if current_command == '':
entry_after.set_text(new_command)
else:
entry_after.set_text(current_command + ' && ' + new_command)
img = Gtk.Image.new_from_icon_name("go-up", Gtk.IconSize.SMALL_TOOLBAR)
button_add_after = Gtk.Button(
image = img,
tooltip_text = _("Add command template")
)
button_add_after.connect('clicked', cb_button_add_after)
grid_after.attach(entry_after, 0, 0, 1, 1)
grid_after.attach(button_edit_after, 1, 0, 1, 1)
grid_after.attach(combobox_after, 0, 1, 1, 1)
grid_after.attach(button_add_after, 1, 1, 1, 1)
expander_after.add(grid_after)
self.button_game = Gtk.Button(
label = _("Launch game")
)
self.button_game.connect('clicked', self.cb_button_game)
self.checkbutton_show_launcher = Gtk.CheckButton(
label = _("Always show launcher")
)
self.checkbutton_show_launcher.set_active(self.launcher)
self.checkbutton_show_launcher.connect('clicked', self.cb_checkbutton_show_launcher)
self.checkbutton_show_banner = Gtk.CheckButton(
halign = Gtk.Align.END,
valign = Gtk.Align.START,
active = self.show_banner
)
self.checkbutton_show_banner.connect('toggled', self.cb_checkbutton_show_banner)
self.grid.attach(self.checkbutton_show_banner, 0, 0, 2, 1)
self.grid.attach(self.banner, 0, 0, 2, 1)
self.grid.attach(self.expander, 0, 1, 2, 1)
self.grid.attach(expander_before, 0, 2, 2, 1)
self.grid.attach(expander_after, 0, 3, 2, 1)
self.grid.attach(self.label_monitor, 0, 4, 1, 1)
self.grid.attach(self.combobox_monitor, 1, 4, 1, 1)
self.grid.attach(self.button_settings, 0, 5, 2, 1)
self.grid.attach(self.button_game, 0, 6, 2, 1)
self.grid.attach(self.checkbutton_show_launcher, 0, 7, 2, 1)
self.main_window.add(self.grid)
if self.launcher == True:
self.main_window.show_all()
else:
self.launch_game()
def handle_savedpd(event, paramdb, guis, configfiles):
if hasattr(gtk, "FileChooserAction") and hasattr(gtk.FileChooserAction,
"OPEN"):
# gtk3
saveparamschooser = gtk.FileChooserDialog(
title="Save parameters",
action=gtk.FileChooserAction.SAVE,
buttons=(gtk.STOCK_CANCEL, gtk.ResponseType.CANCEL, gtk.STOCK_SAVE,
gtk.ResponseType.OK))
pass
else:
saveparamschooser = gtk.FileChooserDialog(
title="Save parameters",
action=gtk.FILE_CHOOSER_ACTION_SAVE,
buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_SAVE,
gtk.RESPONSE_OK))
pass
#saveparamschooser.set_current_folder(os.path.abspath(os.path.join(thisdir, '..', 'conf')))
dpdfilter = gtk.FileFilter()
dpdfilter.set_name("Datacollect parameter database (*.dpd) files")
dpdfilter.add_pattern("*.dpd")
saveparamschooser.add_filter(dpdfilter)
checkboxvbox = gtk.VBox()
nonsettablecheckbox = gtk.CheckButton("Include non-settable fields")
checkboxvbox.pack_start(nonsettablecheckbox)
dcccheckbox = gtk.CheckButton("Include dcc files")
dcccheckbox.set_active(True)
checkboxvbox.pack_start(dcccheckbox)
guicheckbox = gtk.CheckButton("Include guis")
guicheckbox.set_active(True)
checkboxvbox.pack_start(guicheckbox)
saveparamschooser.set_extra_widget(checkboxvbox)
checkboxvbox.show_all()
#saveparamschooser.add_button("FooButton",5)
result = saveparamschooser.run()
fname = saveparamschooser.get_filename()
saveparamschooser.destroy()
if result == RESPONSE_OK:
# load config file here...
# imp.load_source("datacollect_config",fname)
paramdbfile.save_params(configfiles,
guis,
paramdb,
fname,
None,
None,
non_settable=nonsettablecheckbox.get_active(),
dcc=dcccheckbox.get_active(),
gui=guicheckbox.get_active(),
chx=False,
xlg=False)
pass
pass
def __init__(self, operation, view):
Gtk.Grid.__init__(self)
self.set_orientation(Gtk.Orientation.VERTICAL)
self.set_row_spacing(style.DEFAULT_SPACING)
self.set_valign(Gtk.Align.CENTER)
self.set_halign(Gtk.Align.CENTER)
self._view = view
self._operation = operation
self._backend = None
_icon = Icon(icon_name='backup-%s' % operation,
pixel_size=style.XLARGE_ICON_SIZE)
self.add(_icon)
_icon.show()
self._message_label = Gtk.Label()
self._message_label.set_line_wrap(True)
self._message_label.set_width_chars(40)
self._message_label.set_single_line_mode(False)
align = Gtk.Alignment.new(0.5, 0.5, 0, 0)
align.set_padding(0, 0, style.GRID_CELL_SIZE * 2,
style.GRID_CELL_SIZE * 2)
align.show()
align.add(self._message_label)
self.add(align)
self._message_label.show()
self._options_combo = Gtk.ComboBox()
cell = Gtk.CellRendererText()
self._options_combo.pack_start(cell, True)
self._options_combo.add_attribute(cell, 'text', 0)
self.add(self._options_combo)
self._progress_bar = Gtk.ProgressBar()
self.add(self._progress_bar)
self._progress_bar.set_size_request(
Gdk.Screen.width() - style.GRID_CELL_SIZE * 6, -1)
self._confirm_restore_chkbtn = Gtk.CheckButton()
align = Gtk.Alignment()
align.set_padding(0, 0, style.GRID_CELL_SIZE * 2,
style.GRID_CELL_SIZE * 2)
align.show()
align.add(self._confirm_restore_chkbtn)
self.add(align)
btn_box = Gtk.ButtonBox()
btn_box.show()
self._continue_btn = Gtk.Button(_('Continue'))
btn_box.add(self._continue_btn)
self.add(btn_box)
self._continue_btn_handler_id = 0
self.show()
# check if there are activities running
# and request close them if any.
if self._view.manager.need_stop_activities():
self._message_label.set_text(
_('Please close all the activities, and start again'))
# check the backend availables, if there are more than one
# show to the user to select one
if len(self._view.manager.get_backends()) > 1:
if operation == OPERATION_BACKUP:
message = _('Select where you want create your backup')
if operation == OPERATION_RESTORE:
message = _('Select where you want retrieve your restore')
combo_options = []
for backend in self._view.manager.get_backends():
option = {}
option['description'] = backend.get_name()
option['value'] = backend
combo_options.append(option)
self._ask_options(message, combo_options, self._select_backend)
else:
self._backend = self._view.manager.get_backends()[0]
GObject.idle_add(self._start_operation)
def __init__(self, ccw):
PluginsClass.__init__(self, ccw, caption, category, priority)
self.__lspci = None
vb = Gtk.VBox(False, 2)
self.add(vb)
hb = Gtk.HBox(False, 2)
vb.pack_start(hb, True, True, 2)
l = Gtk.Label()
l.set_markup(
_("""This is an advanced tool that should <b>NOT</b> be used in normal cases.
If you tried other tools and it fails you may use this tool."""))
hb.pack_start(l, False, False, 2)
hb = Gtk.HBox(False, 2)
vb.pack_start(hb, False, False, 2)
self.advanced = Gtk.Expander()
self.advanced.set_label(_("Show Advanced options"))
hb.pack_start(self.advanced, False, False, 2)
vbe = Gtk.VBox(False, 2)
self.advanced.add(vbe)
f = Gtk.Frame()
f.set_label(_('initrd generation'))
vbe.pack_start(f, False, False, 2)
vb = Gtk.VBox(False, 2)
f.add(vb)
hb = Gtk.HBox(False, 2)
vb.pack_start(hb, False, False, 2)
l = Gtk.Label(
_("""initrd file could contain old modules that conflict some proprietary drivers.
You may want to generate a new initrd file."""))
hb.pack_start(l, False, False, 2)
hb = Gtk.HBox(False, 2)
vb.pack_start(hb, False, False, 2)
b = Gtk.Button(_("Generate initrd"))
b.set_image(
Gtk.Image.new_from_stock(Gtk.STOCK_EXECUTE, Gtk.IconSize.BUTTON))
b.connect('clicked', self.mkinitrd)
hb.pack_start(b, False, False, 2)
f = Gtk.Frame()
f.set_label(_('Xorg.conf creation tool'))
vbe.pack_start(f, False, False, 2)
vb = Gtk.VBox(False, 2)
f.add(vb)
hb = Gtk.HBox(False, 2)
vb.pack_start(hb, False, False, 2)
l = Gtk.Label(
_("""Xorg.conf is the file that controls X server which is the base of the graphical environment.
This tool will overwrite xorg.conf with a new one that is not based on your working one."""
))
hb.pack_start(l, False, False, 2)
hb = Gtk.HBox(False, 2)
vb.pack_start(hb, False, False, 2)
hb.pack_start(Gtk.Label(_('Driver:')), False, False, 2)
self.driver = Gtk.Entry()
d, tip = self.default_driver()
self.driver.set_text(d)
self.driver.set_tooltip_text(
_('usually a single lower case word like: %s') % tip)
hb.pack_start(self.driver, False, False, 2)
hb = Gtk.HBox(False, 2)
vb.pack_start(hb, False, False, 2)
self.compiz = Gtk.CheckButton(_("Enable Composite extension"))
self.compiz.set_active(True)
self.compiz.set_tooltip_text(
_('This extention is needed by special effects but could case problems in rare cases.'
))
hb.pack_start(self.compiz, False, False, 2)
self.aiglx = Gtk.CheckButton(_("Enable AIGLX"))
self.aiglx.set_active(True)
self.aiglx.set_tooltip_text(
_('Enable Accelerated indirect rendering.'))
hb.pack_start(self.aiglx, False, False, 2)
hb = Gtk.HBox(False, 2)
vb.pack_start(hb, False, False, 2)
hb.pack_start(Gtk.Label(_('Vertical Refresh Rate:')), False, False, 2)
self.auto_vref = Gtk.CheckButton(_('auto'))
self.auto_vref.set_active(True)
hb.pack_start(self.auto_vref, False, False, 2)
self.m_vref = Gtk.CheckButton(_('manual:'))
self.m_vref.set_active(True)
hb.pack_start(self.m_vref, False, False, 2)
self.vref = Gtk.SpinButton()
self.vref.set_tooltip_text(
_('a value of 85Hz would be nicer on your eyes, lower values like 60Hz would work with LCD or old CRT monitors.'
))
self.vref.set_adjustment(Gtk.Adjustment(85, 50, 120, 5, 0, 0))
hb.pack_start(self.vref, False, False, 2)
self.m_vref.connect(
'toggled',
lambda b: self.vref.set_sensitive(self.m_vref.get_active()))
self.res = []
hb = Gtk.HBox(False, 2)
vb.pack_start(hb, False, False, 2)
hb.pack_start(Gtk.Label(_('HD Resolutions:')), False, False, 2)
for i in ['1920×1080', '1280x1024', '1280×720']:
self.res.append(Gtk.CheckButton(i))
hb.pack_start(self.res[-1], False, False, 2)
hb = Gtk.HBox(False, 2)
vb.pack_start(hb, False, False, 2)
hb.pack_start(Gtk.Label(_('LCD Wide Resolutions:')), False, False, 2)
for i in [
'2560x1600', '1920x1200', '1680x1050', '1440x900', '1280x800'
]:
self.res.append(Gtk.CheckButton(i))
hb.pack_start(self.res[-1], False, False, 2)
hb = Gtk.HBox(False, 2)
vb.pack_start(hb, False, False, 2)
hb.pack_start(Gtk.Label(_('Normal Resolutions:')), False, False, 2)
res = [
'1600x1200', '1280x960', '1024x768', '800x600', '640x400',
'320x240', '320x200'
]
for n, i in enumerate(res):
c = Gtk.CheckButton(i)
self.res.append(c)
if n > 1: c.set_active(True)
hb.pack_start(c, False, False, 2)
hb = Gtk.HBox(False, 2)
vb.pack_start(hb, False, False, 2)
b = Gtk.Button(stock=Gtk.STOCK_SAVE)
b.connect('clicked', self.save)
hb.pack_start(b, False, False, 2)
b = Gtk.Button(_('Delete xorg.conf'))
b.set_image(
Gtk.Image.new_from_stock(Gtk.STOCK_DELETE, Gtk.IconSize.BUTTON))
b.set_tooltip_text(_('This will make X use default settings.'))
b.connect('clicked', self.delete)
hb.pack_start(b, False, False, 2)
def PluginPreferences(self, parent):
red = Gdk.RGBA()
red.parse("#ff0000")
def validate_color(entry):
text = entry.get_text()
if not Gdk.RGBA().parse(text):
# Invalid color, make text red
entry.override_color(Gtk.StateFlags.NORMAL, red)
else:
# Reset text color
entry.override_color(Gtk.StateFlags.NORMAL, None)
def elapsed_color_changed(entry):
validate_color(entry)
CONFIG.elapsed_color = entry.get_text()
def hover_color_changed(entry):
validate_color(entry)
CONFIG.hover_color = entry.get_text()
def remaining_color_changed(entry):
validate_color(entry)
CONFIG.remaining_color = entry.get_text()
def on_show_pos_toggled(button, *args):
CONFIG.show_current_pos = button.get_active()
def seek_amount_changed(spinbox):
CONFIG.seek_amount = spinbox.get_value_as_int()
vbox = Gtk.VBox(spacing=6)
def on_show_time_labels_toggled(button, *args):
CONFIG.show_time_labels = button.get_active()
if self._bar is not None:
self._bar.set_time_label_visibility(CONFIG.show_time_labels)
def create_color(label_text, color, callback):
hbox = Gtk.HBox(spacing=6)
hbox.set_border_width(6)
label = Gtk.Label(label=label_text)
hbox.pack_start(label, False, True, 0)
entry = Gtk.Entry()
if color:
entry.set_text(color)
entry.connect('changed', callback)
hbox.pack_start(entry, True, True, 0)
return hbox
box = create_color(_("Override foreground color:"),
CONFIG.elapsed_color, elapsed_color_changed)
vbox.pack_start(box, True, True, 0)
box = create_color(_("Override hover color:"), CONFIG.hover_color,
hover_color_changed)
vbox.pack_start(box, True, True, 0)
box = create_color(_("Override remaining color:"),
CONFIG.remaining_color, remaining_color_changed)
vbox.pack_start(box, True, True, 0)
show_current_pos = Gtk.CheckButton(label=_("Show current position"))
show_current_pos.set_active(CONFIG.show_current_pos)
show_current_pos.connect("toggled", on_show_pos_toggled)
vbox.pack_start(show_current_pos, True, True, 0)
show_time_labels = Gtk.CheckButton(label=_("Show time labels"))
show_time_labels.set_active(CONFIG.show_time_labels)
show_time_labels.connect("toggled", on_show_time_labels_toggled)
vbox.pack_start(show_time_labels, True, True, 0)
hbox = Gtk.HBox(spacing=6)
hbox.set_border_width(6)
label = Gtk.Label(
label=_("Seek amount when scrolling (milliseconds):"))
hbox.pack_start(label, False, True, 0)
seek_amount = Gtk.SpinButton(adjustment=Gtk.Adjustment(
CONFIG.seek_amount, 0, 60000, 1000, 1000, 0))
seek_amount.set_numeric(True)
seek_amount.connect("changed", seek_amount_changed)
hbox.pack_start(seek_amount, True, True, 0)
vbox.pack_start(hbox, True, True, 0)
return vbox
def __init__(self):
Gtk.Window.__init__(self, title=info.__appname__)
self.connect("destroy", Gtk.main_quit)
log.info(info.__appname__ + ' başlatıldı', info.__appname__)
self.box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.add(self.box)
self.menu = Gtk.MenuBar() ## Menu
self.filemenu = Gtk.Menu()
self.file = Gtk.MenuItem(label="Dosya")
self.file.set_submenu(self.filemenu)
self.exittab = Gtk.MenuItem(label="Kapat")
self.exittab.connect("activate", Gtk.main_quit)
self.filemenu.append(self.exittab)
self.helpmenu = Gtk.Menu() ## Yardım Menusu
self.help = Gtk.MenuItem(label="Yardım")
self.help.set_submenu(self.helpmenu)
self.about = Gtk.MenuItem(label="Sürüm Notları")
self.about.connect("activate", self.surum_notlari)
self.helpmenu.append(self.about)
self.about = Gtk.MenuItem(label="Hakkında")
self.about.connect("activate", self.hakkinda)
self.helpmenu.append(self.about)
self.menu.append(self.file)
self.menu.append(self.help)
self.notebook = Gtk.Notebook() # Notebook oluşturuldu
self.box.pack_start(self.menu, False, False, 0)
self.box.pack_start(self.notebook, False, False, 0)
# Dosya Şifreleme Sekmesi
self.page1 = Gtk.Grid(
) #column_homogeneous=True) # Hizalamak için box oluşturuldu.
self.page1.set_border_width(15) # Kenar boşluğu eklendi
self.page1.set_row_spacing(3) # Satır arasındaki boşluk ayarlandı
self.page1.set_column_spacing(3) # Sutun arasındaki boşluk ayarlandı
self.sifrelenecek_dosya = None
self.dosya_metin = Gtk.Label(label='Dosya Seçimi')
self.dosya_metin.set_alignment(0, 0.5) # Sola Hizalandı
self.dosya_entry = Gtk.Entry()
self.dosya_entry.set_placeholder_text('Dosya Seçilmedi')
self.dosya_entry.set_sensitive(False) # Entry kullanımı kaldırıldı
self.dosya_buton = Gtk.Button(label='..')
self.dosya_buton.connect('clicked', self.dosya_secim)
self.cipher_secilen = None
self.cipher_metin = Gtk.Label(label='Cipher Seçimi')
self.cipher_metin.set_alignment(0, 0.5)
self.cipher_list = Gtk.ComboBoxText()
self.cipher_list.connect('changed', self.cipher_enc)
for i in info.cipher_list:
self.cipher_list.append_text(i)
self.digest_secilen = None
self.digest_metin = Gtk.Label(label='Digest Seçimi')
self.digest_metin.set_alignment(0, 0.5)
self.digest_list = Gtk.ComboBoxText()
self.digest_list.connect('changed', self.digest_enc)
for i in info.digest_list:
self.digest_list.append_text(i)
self.parola_metin = Gtk.Label(label='Parola Oluşturun')
self.parola_metin.set_alignment(0, 0.5)
self.parola_entry = Gtk.Entry()
self.parola_entry.set_visibility(False) # Entry görünürlüğü kaldırıldı
self.parola_entry.set_placeholder_text('Parola Giriniz')
self.parola2_metin = Gtk.Label(label='Parolayı Yeniden Oluşturun')
self.parola2_metin.set_alignment(0, 0.5)
self.parola2_entry = Gtk.Entry()
self.parola2_entry.set_visibility(False)
self.parola2_entry.set_placeholder_text('Parolanızı Yeniden Giriniz')
self.onay_buton = Gtk.Button(label='Dosyayı Şifrele')
self.onay_buton.connect("clicked",
self.sifreleme_kontrol) # Surum notu geçici
self.page1.add(self.dosya_metin) # PAGE1 Grid alanı için yerleşim
self.page1.attach(
self.dosya_entry, 2, 0, 1, 1
) # (WİDGET, YATAY-SIRA, DİKEY- SIRA, YATAY-HANGI-SUTUN-KAPSAYACAGI, DİKEY-GENİŞLİK)
self.page1.attach(self.dosya_buton, 3, 0, 1, 1)
self.page1.attach(self.cipher_metin, 0, 1, 1, 1)
self.page1.attach(self.cipher_list, 2, 1, 2, 1)
self.page1.attach(self.digest_metin, 0, 2, 2, 1)
self.page1.attach(self.digest_list, 2, 2, 2, 1)
self.page1.attach(self.parola_metin, 0, 3, 2, 1)
self.page1.attach(self.parola_entry, 2, 3, 2, 1)
self.page1.attach(self.parola2_metin, 0, 4, 2, 1)
self.page1.attach(self.parola2_entry, 2, 4, 2, 1)
self.page1.attach(self.onay_buton, 0, 5, 4, 1)
self.notebook.append_page(self.page1, Gtk.Label(
label='Dosya Şifreleme')) # page1 Box'u NoteBook'a eklendi.
# Dosya Şifre Çözme Sekmesi
self.page2 = Gtk.Grid()
self.page2.set_border_width(15)
self.page2.set_row_spacing(3)
self.page2.set_column_spacing(3)
self.cozulecek_dosya = None
self.dosya_metin_dec = Gtk.Label(label='Şifrelenmiş Dosya Seçimi')
self.dosya_metin_dec.set_alignment(0, 0.5)
self.dosya_entry_dec = Gtk.Entry()
self.dosya_entry_dec.set_placeholder_text('Dosya Seçilmedi')
self.dosya_entry_dec.set_sensitive(False)
self.dosya_entry_dec.set_editable(False)
self.dosya_buton_dec = Gtk.Button(label='..')
self.dosya_buton_dec.connect("clicked", self.dosya_secim_dec)
self.cipher_secilen_dec = None
self.cipher_metin_dec = Gtk.Label(label='Şifrelenmiş Cipher Seçimi')
self.cipher_metin_dec.set_alignment(0, 0.5)
self.cipher_list_dec = Gtk.ComboBoxText()
self.cipher_list_dec.connect('changed', self.cipher_dec)
for i in info.cipher_list:
self.cipher_list_dec.append_text(i)
self.digest_secilen_dec = None
self.digest_metin_dec = Gtk.Label(label='Şifrelenmiş Digest Seçimi')
self.digest_metin_dec.set_alignment(0, 0.5)
self.digest_list_dec = Gtk.ComboBoxText()
self.digest_list_dec.connect('changed', self.digest_dec)
for i in info.digest_list:
self.digest_list_dec.append_text(i)
self.parola_metin_dec = Gtk.Label(label='Oluşturduğunuz Parola')
self.parola_metin_dec.set_alignment(0, 0.5)
self.parola_entry_dec = Gtk.Entry()
self.parola_entry_dec.set_placeholder_text('Parolanızı giriniz')
self.parola_entry_dec.set_visibility(False)
self.onay_buton_dec = Gtk.Button(label='Dosyanın Şifresini Çöz')
self.onay_buton_dec.connect("clicked", self.cozme_kontrol)
self.page2.add(self.dosya_metin_dec)
self.page2.attach(self.dosya_entry_dec, 2, 0, 1, 1)
self.page2.attach(self.dosya_buton_dec, 3, 0, 1, 1)
self.page2.attach(self.cipher_metin_dec, 0, 1, 1, 1)
self.page2.attach(self.cipher_list_dec, 2, 1, 2, 1)
self.page2.attach(self.digest_metin_dec, 0, 2, 1, 1)
self.page2.attach(self.digest_list_dec, 2, 2, 2, 1)
self.page2.attach(self.parola_metin_dec, 0, 3, 1, 1)
self.page2.attach(self.parola_entry_dec, 2, 3, 2, 1)
self.page2.attach(self.onay_buton_dec, 0, 4, 4, 1)
self.notebook.append_page(self.page2, Gtk.Label(label='Dosya Çözme'))
## RSA Oluşturma Grid
self.page3 = Gtk.Grid()
self.page3.set_border_width(15)
self.page3.set_row_spacing(3)
self.page3.set_column_spacing(3)
self.genrsa_label1 = Gtk.Label(label='Kayıt Yeri')
self.genrsa_label1.set_alignment(0, 0.5)
self.kayit_dosya = None
self.genrsa_kayit_yeri = Gtk.Entry()
self.genrsa_kayit_yeri.set_placeholder_text('Dosya Seçilmedi')
self.genrsa_kayit_yeri.set_sensitive(False)
self.genrsa_button1 = Gtk.Button(label='..')
self.genrsa_button1.connect('clicked', self.rsa_kayit_yeri)
self.genrsa_cipher_secilen = None
self.genrsa_anahtaradi = Gtk.Entry()
self.genrsa_anahtaradi.set_placeholder_text('Anahtar Adı Belirleyiniz')
self.genrsa_label2 = Gtk.Label(label='Cipher Seçimi')
self.genrsa_label2.set_alignment(0, 0.5)
self.genrsa_size_secilen = None
self.genrsa_cipher = Gtk.ComboBoxText()
self.genrsa_cipher.connect('changed', self.genrsa_cipher_)
for i in info.genrsa_list:
self.genrsa_cipher.append_text(i)
self.genrsa_label3 = Gtk.Label(label='Anahtar Boyutu')
self.genrsa_label3.set_alignment(0, 0.5)
self.genrsa_size = None
self.genrsa_size = Gtk.ComboBoxText()
self.genrsa_size.connect('changed', self.genrsa_size_)
for i in info.genrsa_size_list:
self.genrsa_size.append_text(i)
self.genrsa_label4 = Gtk.Label(label='Parola Oluşturun')
self.genrsa_label4.set_alignment(0, 0.5)
self.genrsa_parola1 = Gtk.Entry()
self.genrsa_parola1.set_placeholder_text('Parola Giriniz')
self.genrsa_parola1.set_visibility(False)
self.genrsa_label5 = Gtk.Label(label='Parolayı Yeniden Oluşturun')
self.genrsa_label5.set_alignment(0, 0.5)
self.genrsa_parola2 = Gtk.Entry()
self.genrsa_parola2.set_placeholder_text('Parolanızı Yeniden Giriniz')
self.genrsa_parola2.set_visibility(False)
self.genrsa_label7 = Gtk.Label(label='Açık Anahtar')
self.genrsa_label7.set_alignment(0, 0.5)
self.genrsa_acik_anahtar = Gtk.CheckButton(label="Oluşturulsun")
self.genrsa_acik_anahtar.set_active(False)
self.genrsa_olustur = Gtk.Button(label='Anahtarı Oluştur')
self.genrsa_olustur.connect("clicked", self.genrsa_kontrol)
# self.genrsa_olustur.connect("clicked", self.genrsa_kontrol)
self.page3.add(self.genrsa_label1)
self.page3.attach(self.genrsa_kayit_yeri, 1, 0, 1, 1)
self.page3.attach(self.genrsa_button1, 2, 0, 1, 1)
self.page3.attach(self.genrsa_label2, 0, 1, 1, 1)
self.page3.attach(self.genrsa_cipher, 1, 1, 2, 1)
self.page3.attach(self.genrsa_label3, 0, 2, 1, 1)
self.page3.attach(self.genrsa_size, 1, 2, 2, 1)
self.page3.attach(self.genrsa_label4, 0, 3, 1, 1)
self.page3.attach(self.genrsa_parola1, 1, 3, 2, 1)
self.page3.attach(self.genrsa_label5, 0, 4, 1, 1)
self.page3.attach(self.genrsa_parola2, 1, 4, 2, 1)
self.page3.attach(self.genrsa_label7, 0, 5, 1, 1)
self.page3.attach(self.genrsa_acik_anahtar, 1, 5, 2, 1)
self.page3.attach(self.genrsa_olustur, 0, 6, 3, 1)
self.notebook.append_page(self.page3, Gtk.Label(label='GenRSA'))
def __init__(self, *args, **kwargs):
Operation.__init__(self, *args, **kwargs)
self._grid = Gtk.Grid(border_width=5,
row_spacing=5,
column_spacing=5,
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False)
self.add(self._grid)
# we need boxes for at least
# hostname
# port
# username
# password
# auto add new host keys
# remote directory
# create remote directory if necessary
# Hostname
tempgrid = Gtk.Grid(row_spacing=5,
column_spacing=5,
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False)
self._grid.attach(tempgrid, 0, 0, 1, 1)
tempgrid.attach(
Gtk.Label(
label='Hostname',
halign=Gtk.Align.START,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
), 0, 0, 1, 1)
widget = self.register_widget(
Gtk.Entry(
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False,
), 'hostname')
tempgrid.attach(widget, 1, 0, 1, 1)
# Port
tempgrid.attach(
Gtk.Label(
label='Port',
halign=Gtk.Align.CENTER,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
), 2, 0, 1, 1)
widget = self.register_widget(
Gtk.SpinButton(adjustment=Gtk.Adjustment(lower=1,
upper=10000,
value=5,
page_size=0,
step_increment=1),
value=22,
update_policy=Gtk.SpinButtonUpdatePolicy.IF_VALID,
numeric=True,
climb_rate=5,
halign=Gtk.Align.CENTER,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False), 'port')
tempgrid.attach(widget, 3, 0, 1, 1)
# Username
tempgrid = Gtk.Grid(
row_spacing=5,
column_spacing=5,
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False,
)
self._grid.attach(tempgrid, 0, 1, 1, 1)
tempgrid.attach(
Gtk.Label(
label='Username',
halign=Gtk.Align.CENTER,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
), 0, 0, 1, 1)
widget = self.register_widget(
Gtk.Entry(
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False,
), 'username')
tempgrid.attach(widget, 1, 0, 1, 1)
# Password
tempgrid.attach(
Gtk.Label(
label='Password',
halign=Gtk.Align.CENTER,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
), 2, 0, 1, 1)
widget = self.register_widget(Gtk.Entry(
visibility=False,
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False,
),
'password',
exportable=False)
tempgrid.attach(widget, 3, 0, 1, 1)
# Remote directory
tempgrid = Gtk.Grid(
row_spacing=5,
column_spacing=5,
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False,
)
self._grid.attach(tempgrid, 0, 2, 1, 1)
tempgrid.attach(
Gtk.Label(
label='Destination folder',
halign=Gtk.Align.CENTER,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
), 0, 0, 1, 1)
widget = self.register_widget(
Gtk.Entry(
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False,
), 'destination')
tempgrid.attach(widget, 1, 0, 1, 1)
# Create directory
widget = self.register_widget(
Gtk.CheckButton(
active=True,
label="Create destination folder if necessary",
halign=Gtk.Align.END,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
), 'force_folder_creation')
tempgrid.attach(widget, 2, 0, 1, 1)
# Automatically accept new host keys
tempgrid = Gtk.Grid(
row_spacing=5,
column_spacing=5,
halign=Gtk.Align.FILL,
valign=Gtk.Align.CENTER,
hexpand=True,
vexpand=False,
)
self._grid.attach(tempgrid, 0, 3, 1, 1)
widget = self.register_widget(
Gtk.CheckButton(
active=False,
label="Automatically accept new host keys (dangerous!!)",
halign=Gtk.Align.END,
valign=Gtk.Align.CENTER,
hexpand=False,
vexpand=False,
), 'auto_add_keys')
tempgrid.attach(widget, 0, 0, 1, 1)
def __init__(self, filename=None):
Gtk.Dialog.__init__(
self, _('Paginate'), None,
Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
(Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT, Gtk.STOCK_CANCEL,
Gtk.ResponseType.CANCEL))
self.set_size_request(500, 140)
self.set_resizable(False)
self.set_icon_from_file(comun.ICON)
self.connect('destroy', self.close_application)
#
vbox0 = Gtk.VBox(spacing=5)
vbox0.set_border_width(5)
self.get_content_area().add(vbox0)
#
notebook = Gtk.Notebook()
vbox0.add(notebook)
#
frame = Gtk.Frame()
notebook.append_page(frame, tab_label=Gtk.Label(_('Paginate')))
#
table = Gtk.Table(rows=4, columns=2, homogeneous=False)
table.set_border_width(5)
table.set_col_spacings(5)
table.set_row_spacings(5)
frame.add(table)
#
frame1 = Gtk.Frame()
table.attach(frame1,
0,
1,
0,
1,
xoptions=Gtk.AttachOptions.EXPAND,
yoptions=Gtk.AttachOptions.SHRINK)
self.scrolledwindow1 = Gtk.ScrolledWindow()
self.scrolledwindow1.set_size_request(420, 420)
frame1.add(self.scrolledwindow1)
#
self.viewport1 = MiniView()
self.scrolledwindow1.add(self.viewport1)
#
frame2 = Gtk.Frame()
table.attach(frame2,
1,
2,
0,
1,
xoptions=Gtk.AttachOptions.EXPAND,
yoptions=Gtk.AttachOptions.SHRINK)
scrolledwindow2 = Gtk.ScrolledWindow()
scrolledwindow2.set_size_request(420, 420)
frame2.add(scrolledwindow2)
#
self.viewport2 = MiniView()
scrolledwindow2.add(self.viewport2)
self.viewport2.set_text('1/1')
#
self.scale = 100
#
vertical_options = Gtk.ListStore(str, int)
vertical_options.append([_('Top'), TOP])
vertical_options.append([_('Middle'), MIDLE])
vertical_options.append([_('Bottom'), BOTTOM])
#
horizontal_options = Gtk.ListStore(str, int)
horizontal_options.append([_('Left'), LEFT])
horizontal_options.append([_('Center'), CENTER])
horizontal_options.append([_('Right'), RIGHT])
#
self.rbutton0 = Gtk.CheckButton(_('Overwrite original file?'))
table.attach(self.rbutton0,
0,
2,
1,
2,
xoptions=Gtk.AttachOptions.FILL,
yoptions=Gtk.AttachOptions.SHRINK)
# Font 2 3
vbox1 = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=6)
table.attach(vbox1,
0,
2,
2,
3,
xoptions=Gtk.AttachOptions.FILL,
yoptions=Gtk.AttachOptions.SHRINK)
button_font = Gtk.Button(_('Select font'))
button_font.connect('clicked', self.on_button_font_activated)
vbox1.pack_start(button_font, False, False, 0)
button_color = Gtk.Button(_('Select color'))
button_color.connect('clicked', self.on_button_color_activated)
vbox1.pack_start(button_color, False, False, 0)
#
label = Gtk.Label(_('Horizontal position') + ':')
label.set_alignment(0, .5)
table.attach(label,
0,
1,
5,
6,
xoptions=Gtk.AttachOptions.FILL,
yoptions=Gtk.AttachOptions.SHRINK)
#
self.horizontal = Gtk.ComboBox.new_with_model_and_entry(
horizontal_options)
self.horizontal.set_entry_text_column(0)
self.horizontal.set_active(0)
self.horizontal.connect('changed', self.on_value_changed)
table.attach(self.horizontal,
1,
2,
5,
6,
xoptions=Gtk.AttachOptions.FILL,
yoptions=Gtk.AttachOptions.SHRINK)
#
label = Gtk.Label(_('Vertical position') + ':')
label.set_alignment(0, .5)
table.attach(label,
0,
1,
6,
7,
xoptions=Gtk.AttachOptions.FILL,
yoptions=Gtk.AttachOptions.SHRINK)
#
self.vertical = Gtk.ComboBox.new_with_model_and_entry(vertical_options)
self.vertical.set_entry_text_column(0)
self.vertical.set_active(0)
self.vertical.connect('changed', self.on_value_changed)
table.attach(self.vertical,
1,
2,
6,
7,
xoptions=Gtk.AttachOptions.FILL,
yoptions=Gtk.AttachOptions.SHRINK)
#
label = Gtk.Label(_('Set horizontal margin') + ':')
label.set_alignment(0, .5)
table.attach(label,
0,
1,
7,
8,
xoptions=Gtk.AttachOptions.FILL,
yoptions=Gtk.AttachOptions.SHRINK)
self.horizontal_margin = Gtk.SpinButton()
self.horizontal_margin.set_adjustment(
Gtk.Adjustment(5, 0, 100, 1, 10, 10))
table.attach(self.horizontal_margin,
1,
2,
7,
8,
xoptions=Gtk.AttachOptions.FILL,
yoptions=Gtk.AttachOptions.SHRINK)
self.horizontal_margin.connect('value-changed', self.on_margin_changed)
label = Gtk.Label(_('Set vertical margin') + ':')
label.set_alignment(0, .5)
table.attach(label,
0,
1,
8,
9,
xoptions=Gtk.AttachOptions.FILL,
yoptions=Gtk.AttachOptions.SHRINK)
self.vertical_margin = Gtk.SpinButton()
self.vertical_margin.set_adjustment(
Gtk.Adjustment(5, 0, 100, 1, 10, 10))
table.attach(self.vertical_margin,
1,
2,
8,
9,
xoptions=Gtk.AttachOptions.FILL,
yoptions=Gtk.AttachOptions.SHRINK)
self.vertical_margin.connect('value-changed', self.on_margin_changed)
self.show_all()
if filename is not None:
uri = "file://" + filename
document = Poppler.Document.new_from_file(uri, None)
if document.get_n_pages() > 0:
self.viewport1.set_page(document.get_page(0))
self.viewport2.set_page(document.get_page(0))
def add_csv_header_param(self, box):
self.add_field_names = Gtk.CheckButton(label=_("Add field names"))
self.add_field_names.set_active(True)
box.pack_start(
self.add_field_names, expand=False, fill=True, padding=0)
def __init__(self, parent):
Gtk.Dialog.__init__(self, _('Permissions'), parent, 0,
(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
Gtk.STOCK_OK, Gtk.ResponseType.OK))
self.set_default_size(150, 200)
box = self.get_content_area()
frame = Gtk.Frame()
box.pack_start(frame, False, False, 0)
label = Gtk.Label()
label.props.use_markup = True
label.set_markup('<b>' + _('Permissions') + '</b>')
frame.props.label_widget = label
alignment = Gtk.Alignment()
alignment.props.left_padding = 15
alignment.props.top_padding = 15
frame.add(alignment)
hbox = Gtk.HBox()
alignment.add(hbox)
frame1 = Gtk.Frame()
label = Gtk.Label()
label.props.use_markup = True
label.set_markup('<b>' + _('User') + '</b>')
frame1.props.label_widget = label
frame1.props.shadow_type = Gtk.ShadowType.NONE
alignment = Gtk.Alignment()
alignment.props.left_padding = 15
frame1.add(alignment)
vbox = Gtk.VBox()
self.u_r = Gtk.CheckButton(_('Read'))
vbox.pack_start(self.u_r, False, False, 0)
self.u_w = Gtk.CheckButton(_('Write'))
vbox.pack_start(self.u_w, False, False, 0)
self.u_x = Gtk.CheckButton(_('Execute'))
vbox.pack_start(self.u_x, False, False, 0)
alignment.add(vbox)
hbox.pack_start(frame1, False, False, 0)
frame1 = Gtk.Frame()
label = Gtk.Label()
label.props.use_markup = True
label.set_markup('<b>' + _('Group') + '</b>')
frame1.props.label_widget = label
frame1.props.shadow_type = Gtk.ShadowType.NONE
alignment = Gtk.Alignment()
alignment.props.left_padding = 15
frame1.add(alignment)
vbox = Gtk.VBox()
self.g_r = Gtk.CheckButton(_('Read'))
vbox.pack_start(self.g_r, False, False, 0)
self.g_w = Gtk.CheckButton(_('Write'))
vbox.pack_start(self.g_w, False, False, 0)
self.g_x = Gtk.CheckButton(_('Execute'))
vbox.pack_start(self.g_x, False, False, 0)
alignment.add(vbox)
hbox.pack_start(frame1, False, False, 0)
frame1 = Gtk.Frame()
label = Gtk.Label()
label.props.use_markup = True
label.set_markup('<b>' + _('Others') + '</b>')
frame1.props.label_widget = label
frame1.props.shadow_type = Gtk.ShadowType.NONE
alignment = Gtk.Alignment()
alignment.props.left_padding = 15
frame1.add(alignment)
vbox = Gtk.VBox()
self.o_r = Gtk.CheckButton(_('Read'))
vbox.pack_start(self.o_r, False, False, 0)
self.o_w = Gtk.CheckButton(_('Write'))
vbox.pack_start(self.o_w, False, False, 0)
self.o_x = Gtk.CheckButton(_('Execute'))
vbox.pack_start(self.o_x, False, False, 0)
alignment.add(vbox)
hbox.pack_start(frame1, False, False, 0)
def createTraceToolBar(self):
toolbar = Gtk.Toolbar()
#toolbar.set_orientation(Gtk.Orientation.VERTICAL)
#toolbar.set_icon_size(Gtk.IconSize.MENU)
toolbar.set_icon_size(Gtk.IconSize.LARGE_TOOLBAR)
toolbar.set_style(Gtk.ToolbarStyle.ICONS)
toolbar.set_show_arrow(False)
# build the zoom controls
self.zoomin_button = Gtk.ToolButton(Gtk.STOCK_ZOOM_IN)
self.zoomin_button.set_homogeneous(False)
self.zoomin_button.set_tooltip_text('Zoom in')
self.zoomin_button.connect('clicked', self.zoomButtons, 1)
toolbar.insert(self.zoomin_button, -1)
self.zoomout_button = Gtk.ToolButton(Gtk.STOCK_ZOOM_OUT)
self.zoomout_button.set_homogeneous(False)
self.zoomout_button.set_tooltip_text('Zoom out')
self.zoomout_button.connect('clicked', self.zoomButtons, -1)
toolbar.insert(self.zoomout_button, -1)
self.zoom_combo = Gtk.ComboBoxText()
for zoom in self.zoom_levels:
self.zoom_combo.append_text(str(zoom) + '%')
self.zoom_combo.set_active(self.curr_zoom)
self.zoom_combo.connect('changed', self.zoomComboBox)
# Place the combo box in a VButtonBox to prevent it from expanding
# vertically.
vbox = Gtk.VButtonBox()
vbox.pack_start(self.zoom_combo, False, True, 0)
t_item = Gtk.ToolItem()
t_item.add(vbox)
t_item.set_tooltip_text('Adjust the zoom level')
t_item.set_expand(False)
toolbar.insert(t_item, -1)
toolbar.insert(Gtk.SeparatorToolItem(), -1)
# build the y scale adjustment slider
t_item = Gtk.ToolItem()
t_item.add(Gtk.Label(label='Y:'))
toolbar.insert(t_item, -1)
self.vscale_adj = Gtk.Adjustment(0, 0, 0)
hslider = Gtk.Scale(orientation=Gtk.Orientation.HORIZONTAL,
adjustment=self.vscale_adj)
hslider.set_draw_value(False)
self.initYScaleSlider(self.selected_seqtv)
sizereq = hslider.get_size_request()
hslider.set_size_request(60, sizereq.height)
self.y_slider = Gtk.ToolItem()
self.y_slider.add(hslider)
self.y_slider.set_tooltip_text('Adjust the Y scale of the trace view')
toolbar.insert(self.y_slider, -1)
self.vscale_adj.connect('value_changed', self.yScaleChanged)
toolbar.insert(Gtk.SeparatorToolItem(), -1)
# build the toggle button for phred scores
toggle = Gtk.CheckButton()
toggle.set_label('conf. scores')
toggle.set_active(True)
toggle.connect('toggled', self.showConfToggled)
# Place the toggle button in a VButtonBox to prevent it from expanding
# vertically.
vbox = Gtk.VButtonBox()
vbox.pack_start(toggle, False, True, 0)
t_item = Gtk.ToolItem()
t_item.add(vbox)
t_item.set_tooltip_text('Turn the display of phred scores on or off')
t_item.set_expand(False)
toolbar.insert(t_item, -1)
# if we got two sequences, build a combo box to choose between them
if len(self.seqt_viewers) == 2:
trace_combo = Gtk.ComboBoxText()
# see if the forward trace is first or second
if self.seqt_viewers[0].getSequenceTrace().isReverseComplemented():
trace_combo.append_text('Reverse:')
trace_combo.append_text('Forward:')
else:
trace_combo.append_text('Forward:')
trace_combo.append_text('Reverse:')
trace_combo.append_text('Both:')
trace_combo.set_active(0)
trace_combo.connect('changed', self.traceComboBox)
# Place the combo box in a VButtonBox to prevent it from expanding
# vertically.
vbox = Gtk.VButtonBox()
vbox.pack_start(trace_combo, False, True, 0)
t_item = Gtk.ToolItem()
t_item.add(vbox)
#t_item.set_tooltip_text('Adjust the zoom level')
toolbar.insert(t_item, 0)
trace_combo.set_active(2)
return toolbar
def _general_options_panel():
prefs = editorpersistance.prefs
# Widgets
open_in_last_opened_check = Gtk.CheckButton()
open_in_last_opened_check.set_active(prefs.open_in_last_opended_media_dir)
open_in_last_rendered_check = Gtk.CheckButton()
open_in_last_rendered_check.set_active(prefs.remember_last_render_dir)
default_profile_combo = Gtk.ComboBoxText()
profiles = mltprofiles.get_profiles()
for profile in profiles:
default_profile_combo.append_text(profile[0])
default_profile_combo.set_active(mltprofiles.get_default_profile_index())
spin_adj = Gtk.Adjustment(prefs.undos_max,
editorpersistance.UNDO_STACK_MIN,
editorpersistance.UNDO_STACK_MAX, 1)
undo_max_spin = Gtk.SpinButton.new_with_range(
editorpersistance.UNDO_STACK_MIN, editorpersistance.UNDO_STACK_MAX, 1)
undo_max_spin.set_adjustment(spin_adj)
undo_max_spin.set_numeric(True)
autosave_combo = Gtk.ComboBoxText()
# Aug-2019 - SvdB - AS - This is now initialized in app.main
# Using editorpersistance.prefs.AUTO_SAVE_OPTS as source
# AUTO_SAVE_OPTS = ((-1, _("No Autosave")),(1, _("1 min")),(2, _("2 min")),(5, _("5 min")))
for i in range(0, len(editorpersistance.prefs.AUTO_SAVE_OPTS)):
time, desc = editorpersistance.prefs.AUTO_SAVE_OPTS[i]
autosave_combo.append_text(desc)
autosave_combo.set_active(prefs.auto_save_delay_value_index)
load_order_combo = Gtk.ComboBoxText()
load_order_combo.append_text(_("Absolute paths first, relative second"))
load_order_combo.append_text(_("Relative paths first, absolute second"))
load_order_combo.append_text(_("Absolute paths only"))
load_order_combo.set_active(prefs.media_load_order)
# Layout
row1 = _row(
guiutils.get_two_column_box(Gtk.Label(label=_("Default Profile:")),
default_profile_combo, PREFERENCES_LEFT))
row2 = _row(
guiutils.get_checkbox_row_box(
open_in_last_opened_check,
Gtk.Label(label=_("Remember last media directory"))))
row3 = _row(
guiutils.get_two_column_box(Gtk.Label(label=_("Undo stack size:")),
undo_max_spin, PREFERENCES_LEFT))
row5 = _row(
guiutils.get_checkbox_row_box(
open_in_last_rendered_check,
Gtk.Label(label=_("Remember last render directory"))))
row6 = _row(
guiutils.get_two_column_box(
Gtk.Label(label=_("Autosave for crash recovery every:")),
autosave_combo, PREFERENCES_LEFT))
row9 = _row(
guiutils.get_two_column_box(
Gtk.Label(label=_("Media look-up order on load:")),
load_order_combo, PREFERENCES_LEFT))
vbox = Gtk.VBox(False, 2)
vbox.pack_start(row1, False, False, 0)
vbox.pack_start(row6, False, False, 0)
vbox.pack_start(row2, False, False, 0)
vbox.pack_start(row5, False, False, 0)
vbox.pack_start(row3, False, False, 0)
vbox.pack_start(row9, False, False, 0)
vbox.pack_start(Gtk.Label(), True, True, 0)
guiutils.set_margins(vbox, 12, 0, 12, 12)
# Aug-2019 - SvdB - AS - Added autosave_combo
return vbox, (default_profile_combo, open_in_last_opened_check,
open_in_last_rendered_check, undo_max_spin, load_order_combo,
autosave_combo)
