def __init__(self, uuid, data, spices, size_groups):
super(DownloadSpicesRow, self).__init__()
self.uuid = uuid
self.data = data
self.spices = spices
self.name = data['name']
self.description = data['description']
self.score = data['score']
self.timestamp = data['last_edited']
self.has_update = False
self.status_ids = {}
self.installed = self.spices.get_is_installed(uuid)
widget = SettingsWidget()
widget.set_spacing(15)
self.add(widget)
icon = spices.get_icon(uuid)
widget.pack_start(icon, False, False, 0)
desc_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
desc_box.set_hexpand(True)
desc_box.set_halign(Gtk.Align.FILL)
name_label = Gtk.Label()
name_markup = GLib.markup_escape_text(self.name)
name_label.set_markup('<b>{}</b>'.format(name_markup))
name_label.set_hexpand(True)
name_label.set_halign(Gtk.Align.START)
desc_box.pack_start(name_label, False, False, 0)
description_label = SettingsLabel()
description_markup = GLib.markup_escape_text(
sanitize_html(self.description))
description_label.set_markup(
'<small>{}</small>'.format(description_markup))
desc_box.pack_start(description_label, False, False, 0)
widget.pack_start(desc_box, True, True, 0)
score_box = Gtk.Box()
score_image = Gtk.Image.new_from_icon_name('starred-symbolic', 2)
score_box.pack_start(score_image, False, False, 0)
score_label = Gtk.Label(self.score)
score_box.pack_start(score_label, False, False, 5)
widget.pack_start(score_box, False, False, 0)
size_groups[0].add_widget(score_box)
self.status_box = Gtk.Box()
self.status_box.set_spacing(4)
widget.pack_start(self.status_box, False, False, 0)
size_groups[1].add_widget(self.status_box)
self.button_box = Gtk.Box()
self.button_box.set_valign(Gtk.Align.CENTER)
self.button_box.set_baseline_position(Gtk.BaselinePosition.CENTER)
widget.pack_start(self.button_box, False, False, 0)
size_groups[2].add_widget(self.button_box)
if not self.installed:
download_button = Gtk.Button.new_from_icon_name(
'go-down-symbolic', 2)
self.button_box.pack_start(download_button, False, False, 0)
download_button.connect('clicked', self.download)
download_button.set_tooltip_text(_("Install"))
elif self.spices.get_has_update(uuid):
self.has_update = True
download_button = Gtk.Button.new_from_icon_name(
'view-refresh-symbolic', 2)
self.button_box.pack_start(download_button, False, False, 0)
download_button.connect('clicked', self.download)
download_button.set_tooltip_text(_("Update"))
if self.installed:
self.add_status('installed', 'object-select-symbolic',
_("Installed"))
self.show_all()
def __init__(self, book: Book):
self.book: Book = book
self.ui = cozy.ui.main_view.CozyUI()
self.ONLINE_TOOLTIP_TEXT = _("Open book overview")
self.OFFLINE_TOOLTIP_TEXT = _("Currently offline")
super().__init__()
self.event_box = Gtk.EventBox()
self.add_events(Gdk.EventMask.KEY_PRESS_MASK)
self.box = Gtk.Box()
self.box.set_orientation(Gtk.Orientation.VERTICAL)
self.box.set_spacing(7)
self.box.set_halign(Gtk.Align.CENTER)
self.box.set_valign(Gtk.Align.START)
self.box.set_margin_top(10)
# label contains the book name and is limited to x chars
title_label = Gtk.Label()
title = tools.shorten_string(self.book.name, MAX_BOOK_LENGTH)
title_label.set_text(title)
title_label.get_style_context().add_class("bold")
title_label.set_xalign(0.5)
title_label.set_line_wrap(Pango.WrapMode.WORD_CHAR)
title_label.props.max_width_chars = 30
title_label.props.justify = Gtk.Justification.CENTER
author_label = Gtk.Label.new(
tools.shorten_string(self.book.author, MAX_BOOK_LENGTH))
author_label.set_xalign(0.5)
author_label.set_line_wrap(Pango.WrapMode.WORD_CHAR)
author_label.props.max_width_chars = 30
author_label.props.justify = Gtk.Justification.CENTER
author_label.get_style_context().add_class("dim-label")
self.art = AlbumElement(self.book,
180,
self.ui.window.get_scale_factor(),
bordered=True,
square=False)
if is_external(self.book.db_object
) and not self.book.offline and not FilesystemMonitor(
).get_book_online(self.book):
super().set_sensitive(False)
self.box.set_tooltip_text(self.OFFLINE_TOOLTIP_TEXT)
else:
self.box.set_tooltip_text(self.ONLINE_TOOLTIP_TEXT)
# assemble finished element
self.box.add(self.art)
self.box.add(title_label)
self.box.add(author_label)
self.event_box.add(self.box)
self.add(self.event_box)
self.art.connect("play-pause-clicked", self._on_album_art_press_event)
self.event_box.connect("button-press-event",
self.__on_button_press_event)
self.connect("key-press-event", self.__on_key_press_event)
FilesystemMonitor().add_listener(self.__on_storage_changed)
Settings().add_listener(self.__on_storage_changed)
def create_ui(self, with_nsm):
self.channels = []
self.output_channels = []
self.window = Gtk.Window(type=Gtk.WindowType.TOPLEVEL)
self.window.set_icon_name('jack_mixer')
self.gui_factory = gui.Factory(self.window, self.meter_scales,
self.slider_scales)
self.gui_factory.connect('midi-behavior-mode-changed',
self.on_midi_behavior_mode_changed)
self.gui_factory.emit_midi_behavior_mode()
self.vbox_top = Gtk.VBox()
self.window.add(self.vbox_top)
self.menu_accelgroup = Gtk.AccelGroup()
self.window.add_accel_group(self.menu_accelgroup)
self.menubar = Gtk.MenuBar()
self.vbox_top.pack_start(self.menubar, False, True, 0)
mixer_menu_item = Gtk.MenuItem.new_with_mnemonic("_Mixer")
self.menubar.append(mixer_menu_item)
edit_menu_item = Gtk.MenuItem.new_with_mnemonic('_Edit')
self.menubar.append(edit_menu_item)
help_menu_item = Gtk.MenuItem.new_with_mnemonic('_Help')
self.menubar.append(help_menu_item)
self.width = 420
self.height = 420
self.paned_position = 210
self.window.set_default_size(self.width, self.height)
self.mixer_menu = Gtk.Menu()
mixer_menu_item.set_submenu(self.mixer_menu)
self.mixer_menu.append(
self.new_menu_item('New _Input Channel', self.on_add_input_channel,
"<Control>N"))
self.mixer_menu.append(
self.new_menu_item('New Output _Channel',
self.on_add_output_channel,
"<Shift><Control>N"))
self.mixer_menu.append(Gtk.SeparatorMenuItem())
if not with_nsm:
self.mixer_menu.append(
self.new_menu_item('_Open...', self.on_open_cb, "<Control>O"))
self.mixer_menu.append(
self.new_menu_item('_Save', self.on_save_cb, "<Control>S"))
if not with_nsm:
self.mixer_menu.append(
self.new_menu_item('Save _As...', self.on_save_as_cb,
"<Shift><Control>S"))
self.mixer_menu.append(Gtk.SeparatorMenuItem())
if with_nsm:
self.mixer_menu.append(
self.new_menu_item('_Hide', self.nsm_hide_cb, "<Control>W"))
else:
self.mixer_menu.append(
self.new_menu_item('_Quit', self.on_quit_cb, "<Control>Q"))
edit_menu = Gtk.Menu()
edit_menu_item.set_submenu(edit_menu)
self.channel_edit_input_menu_item = self.new_menu_item(
'_Edit Input Channel', enabled=False)
edit_menu.append(self.channel_edit_input_menu_item)
self.channel_edit_input_menu = Gtk.Menu()
self.channel_edit_input_menu_item.set_submenu(
self.channel_edit_input_menu)
self.channel_edit_output_menu_item = self.new_menu_item(
'E_dit Output Channel', enabled=False)
edit_menu.append(self.channel_edit_output_menu_item)
self.channel_edit_output_menu = Gtk.Menu()
self.channel_edit_output_menu_item.set_submenu(
self.channel_edit_output_menu)
self.channel_remove_input_menu_item = self.new_menu_item(
'_Remove Input Channel', enabled=False)
edit_menu.append(self.channel_remove_input_menu_item)
self.channel_remove_input_menu = Gtk.Menu()
self.channel_remove_input_menu_item.set_submenu(
self.channel_remove_input_menu)
self.channel_remove_output_menu_item = self.new_menu_item(
'Re_move Output Channel', enabled=False)
edit_menu.append(self.channel_remove_output_menu_item)
self.channel_remove_output_menu = Gtk.Menu()
self.channel_remove_output_menu_item.set_submenu(
self.channel_remove_output_menu)
edit_menu.append(Gtk.SeparatorMenuItem())
edit_menu.append(
self.new_menu_item('Shrink Input Channels',
self.on_narrow_input_channels_cb,
"<Control>minus"))
edit_menu.append(
self.new_menu_item('Expand Input Channels',
self.on_widen_input_channels_cb,
"<Control>plus"))
edit_menu.append(Gtk.SeparatorMenuItem())
edit_menu.append(
self.new_menu_item('_Clear', self.on_channels_clear, "<Control>X"))
edit_menu.append(Gtk.SeparatorMenuItem())
edit_menu.append(
self.new_menu_item('_Preferences', self.on_preferences_cb,
"<Control>P"))
help_menu = Gtk.Menu()
help_menu_item.set_submenu(help_menu)
help_menu.append(self.new_menu_item('_About', self.on_about, "F1"))
self.hbox_top = Gtk.HBox()
self.vbox_top.pack_start(self.hbox_top, True, True, 0)
self.scrolled_window = Gtk.ScrolledWindow()
self.scrolled_window.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
self.hbox_inputs = Gtk.Box()
self.hbox_inputs.set_spacing(0)
self.hbox_inputs.set_border_width(0)
self.hbox_top.set_spacing(0)
self.hbox_top.set_border_width(0)
self.scrolled_window.add(self.hbox_inputs)
self.hbox_outputs = Gtk.Box()
self.hbox_outputs.set_spacing(0)
self.hbox_outputs.set_border_width(0)
self.scrolled_output = Gtk.ScrolledWindow()
self.scrolled_output.set_policy(Gtk.PolicyType.AUTOMATIC,
Gtk.PolicyType.AUTOMATIC)
self.scrolled_output.add(self.hbox_outputs)
self.paned = Gtk.HPaned()
self.paned.set_wide_handle(True)
self.hbox_top.pack_start(self.paned, True, True, 0)
self.paned.pack1(self.scrolled_window, True, False)
self.paned.pack2(self.scrolled_output, True, False)
self.window.connect("destroy", Gtk.main_quit)
self.window.connect('delete-event', self.on_delete_event)
def __init__(self, parent, start_slot=1, channel_size=3):
Gtk.Window.__init__(self, title="EMPR Display - Channel Viewer")
self.parent = parent
self.set_default_size(200, 200)
self.set_border_width(10)
self.start_slot = start_slot
self.channel_size = channel_size
self.colour_label = None
self.colour_area = None
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
vbox.set_homogeneous(False)
label = Gtk.Label(label="Channel Data")
vbox.pack_start(label, False, True, 0)
scrolledwindow = Gtk.ScrolledWindow()
liststore = Gtk.ListStore(str, str)
self.packet_data = liststore
for i in range(channel_size):
if i + start_slot < 513:
liststore.append([str(i + start_slot), "0x00"])
else:
liststore.append([str(i + start_slot), "Out of Range"])
self.update_values()
treeview = Gtk.TreeView(model=liststore)
fontdesc = Pango.FontDescription("monospace 10")
treeview.modify_font(fontdesc)
renderer_slot = Gtk.CellRendererText()
column_slot = Gtk.TreeViewColumn("Slot", renderer_slot, text=0)
treeview.append_column(column_slot)
renderer_value = Gtk.CellRendererText()
column_value = Gtk.TreeViewColumn("Value", renderer_value, text=1)
treeview.append_column(column_value)
scrolledwindow.add(treeview)
vbox.pack_start(scrolledwindow, True, True, 0)
if channel_size == 3 or 9 > channel_size > 6:
label = Gtk.Label(label="Channel Colour")
vbox.pack_start(label, False, True, 0)
area = Gtk.DrawingArea()
area.set_size_request(24, 24)
self.colour_area = area
vbox.pack_start(area, False, True, 0)
label = Gtk.Label(label="Channel Colour Hex Code")
vbox.pack_start(label, False, True, 0)
label = Gtk.Label(label="#ffffff")
self.colour_label = label
vbox.pack_start(label, False, True, 0)
self.update_values()
self.add(vbox)
self.show_all()
self.id = UIChannelDisplay.channel_window_index
self.connect("destroy", self.on_close)
UIChannelDisplay.channel_window_index += 1
def __init__(self, **options):
name = _("Dynamic Workspaces")
Gtk.ListBox.__init__(self)
_GSettingsTweak.__init__(self,
name,
"org.gnome.mutter",
"dynamic-workspaces",
loaded=_shell_loaded)
self.set_selection_mode(Gtk.SelectionMode.NONE)
# Needs other page elements to get margins too
# self.props.margin_left = 50
# self.props.margin_right = 50
row = Gtk.ListBoxRow()
hbox = Gtk.Box()
hbox.props.margin = 10
row.add(hbox)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
lbl = Gtk.Label(name, xalign=0)
lbl.props.xalign = 0.0
desc = _(
"Workspaces can be created on demand, and are automatically removed when empty."
)
lbl_desc = Gtk.Label()
lbl_desc.set_line_wrap(True)
lbl_desc.get_style_context().add_class("dim-label")
lbl_desc.set_markup("<span size='small'>" +
GLib.markup_escape_text(desc) + "</span>")
self.check1 = Gtk.Image.new_from_icon_name("object-select-symbolic",
Gtk.IconSize.SMALL_TOOLBAR)
self.check1.set_no_show_all(True)
self.check1.set_visible(self.settings[self.key_name])
vbox.pack_start(lbl, False, False, 0)
vbox.pack_start(lbl_desc, False, False, 0)
hbox.pack_start(vbox, False, False, 0)
hbox.pack_end(self.check1, False, False, 0)
self.add(row)
row = Gtk.ListBoxRow()
hbox = Gtk.Box()
hbox.props.margin = 10
row.add(hbox)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
lbl = Gtk.Label(_("Static Workspaces"), xalign=0)
lbl.props.xalign = 0.0
desc = _("Number of workspaces is fixed.")
lbl_desc = Gtk.Label()
lbl_desc.set_line_wrap(True)
lbl_desc.get_style_context().add_class("dim-label")
lbl_desc.set_markup("<span size='small'>" +
GLib.markup_escape_text(desc) + "</span>")
self.check2 = Gtk.Image.new_from_icon_name("object-select-symbolic",
Gtk.IconSize.SMALL_TOOLBAR)
self.check2.set_no_show_all(True)
self.check2.set_visible(not self.settings[self.key_name])
vbox.pack_start(lbl, False, False, 0)
vbox.pack_start(lbl_desc, False, False, 0)
hbox.pack_start(vbox, False, False, 0)
hbox.pack_end(self.check2, False, False, 0)
self.add(row)
self.connect('row-activated', self.on_row_clicked)
def __init__(self, app):
super().__init__(orientation=Gtk.Orientation.VERTICAL)
self.app = app
control_box = Gtk.Box()
self.pack_start(control_box, False, False, 0)
link_button = Gtk.Button.new_with_label(_('New Link Task'))
link_button.connect('clicked', self.on_link_button_clicked)
control_box.pack_start(link_button, False, False, 0)
reload_button = Gtk.Button.new_with_label(_('Reload'))
reload_button.props.margin_left = 40
reload_button.connect('clicked', self.on_reload_button_clicked)
control_box.pack_start(reload_button, False, False, 0)
open_button = Gtk.Button.new_with_label(_('Open Directory'))
open_button.connect('clicked', self.on_open_button_clicked)
control_box.pack_start(open_button, False, False, 0)
clear_button = Gtk.Button.new_with_label(_('Clear'))
clear_button.set_tooltip_text(_('Clear finished or canceled tasks'))
clear_button.connect('clicked', self.on_clear_button_clicked)
control_box.pack_end(clear_button, False, False, 0)
remove_button = Gtk.Button.new_with_label(_('Remove'))
remove_button.set_tooltip_text(_('Remove selected tasks'))
remove_button.connect('clicked', self.on_remove_button_clicked)
control_box.pack_end(remove_button, False, False, 0)
cancel_button = Gtk.Button.new_with_label(_('Cancel'))
cancel_button.set_tooltip_text(_('Cancel selected tasks'))
cancel_button.connect('clicked', self.on_cancel_button_clicked)
control_box.pack_end(cancel_button, False, False, 0)
# show loading process
self.loading_spin = Gtk.Spinner()
self.loading_spin.props.margin_right = 5
control_box.pack_end(self.loading_spin, False, False, 0)
scrolled_win = Gtk.ScrolledWindow()
self.pack_start(scrolled_win, True, True, 0)
# task_id, name, path, source_url, size, finished_size,
# status, percent, human_size, tooltip
self.liststore = Gtk.ListStore(str, str, str, str, GObject.TYPE_INT64,
GObject.TYPE_INT64, int, int, str, str)
self.treeview = Gtk.TreeView(model=self.liststore)
self.treeview.set_headers_clickable(True)
self.treeview.set_reorderable(True)
self.treeview.set_search_column(NAME_COL)
self.treeview.set_tooltip_column(TOOLTIP_COL)
self.selection = self.treeview.get_selection()
scrolled_win.add(self.treeview)
name_cell = Gtk.CellRendererText(ellipsize=Pango.EllipsizeMode.END,
ellipsize_set=True)
name_col = Gtk.TreeViewColumn(_('Name'), name_cell, text=NAME_COL)
name_col.set_expand(True)
self.treeview.append_column(name_col)
name_col.set_sort_column_id(NAME_COL)
self.liststore.set_sort_func(NAME_COL, gutil.tree_model_natsort)
size_cell = Gtk.CellRendererText()
size_col = Gtk.TreeViewColumn(_('Size'), size_cell, text=HUMANSIZE_COL)
self.treeview.append_column(size_col)
size_col.props.min_width = 145
size_col.set_sort_column_id(SIZE_COL)
percent_cell = Gtk.CellRendererProgress()
percent_col = Gtk.TreeViewColumn(_('Progress'),
percent_cell,
value=PERCENT_COL)
self.treeview.append_column(percent_col)
percent_col.props.min_width = 145
percent_col.set_sort_column_id(PERCENT_COL)
def __init__(self, videodict):
Gtk.EventBox.__init__(self)
self.set_border_width(2)
self.videodict = videodict
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
keys = self.videodict.keys()
if "previews" in keys:
imagen = Gtk.Image()
hbox.pack_start(imagen, False, False, 3)
if type(self.videodict["previews"]) == list:
# FIXME: siempre hay 4 previews.
url = self.videodict["previews"][0][0]
import time
archivo = "/dev/shm/preview%d" % time.time()
try:
# FIXME: Porque Falla si no hay Conexión.
import urllib
fileimage, headers = urllib.urlretrieve(url, archivo)
pixbuf = GdkPixbuf.Pixbuf.new_from_file_at_size(
fileimage, 200, 150)
imagen.set_from_pixbuf(pixbuf)
### Convertir imagen a string por si se quiere guardar.
import base64
pixbuf_file = open(fileimage, 'rb')
image_string = base64.b64encode(pixbuf_file.read())
pixbuf_file.close()
self.videodict["previews"] = image_string
except:
print "No hay Conexión a Internet."
if os.path.exists(archivo):
os.remove(archivo)
else:
import base64
loader = GdkPixbuf.PixbufLoader()
loader.set_size(200, 150)
image_string = base64.b64decode(self.videodict["previews"])
loader.write(image_string)
loader.close()
pixbuf = loader.get_pixbuf()
imagen.set_from_pixbuf(pixbuf)
vbox.pack_start(Gtk.Label("%s: %s" % ("id",
self.videodict["id"])), True, True, 0)
vbox.pack_start(Gtk.Label("%s: %s" % ("Título",
self.videodict["titulo"])), True, True, 0)
vbox.pack_start(Gtk.Label("%s: %s" % ("Categoría",
self.videodict["categoria"])), True, True, 0)
#vbox.pack_start(gtk.Label("%s: %s" % ("Etiquetas",
# self.videodict["etiquetas"])), True, True, 0)
#vbox.pack_start(gtk.Label("%s: %s" % ("Descripción",
# self.videodict["descripcion"])), True, True, 0)
vbox.pack_start(Gtk.Label("%s: %s %s" % ("Duración",
int(float(self.videodict["duracion"]) / 60.0), "Minutos")),
True, True, 0)
#vbox.pack_start(gtk.Label("%s: %s" % ("Reproducción en la Web",
# self.videodict["flash player"])), True, True, 0)
vbox.pack_start(Gtk.Label("%s: %s" % ("url",
self.videodict["url"])), True, True, 0)
for label in vbox.get_children():
label.set_alignment(0.0, 0.5)
hbox.pack_start(vbox, False, False, 5)
self.add(hbox)
self.show_all()
self.connect("button_press_event", self.__button_press)
def __create_headerbar(self):
headerbar = Gtk.HeaderBar()
headerbar.set_show_close_button(True)
back_button = Gtk.Button.new_from_icon_name("go-previous-symbolic",
Gtk.IconSize.SMALL_TOOLBAR)
back_button.set_always_show_image(True)
back_button.set_tooltip_text(_("Close project"))
back_button.connect("clicked", self.__close_project_cb)
back_button.set_margin_right(4 * PADDING)
headerbar.pack_start(back_button)
undo_button = Gtk.Button.new_from_icon_name("edit-undo-symbolic",
Gtk.IconSize.SMALL_TOOLBAR)
undo_button.set_always_show_image(True)
undo_button.set_label(_("Undo"))
undo_button.set_action_name("app.undo")
undo_button.set_use_underline(True)
redo_button = Gtk.Button.new_from_icon_name("edit-redo-symbolic",
Gtk.IconSize.SMALL_TOOLBAR)
redo_button.set_always_show_image(True)
redo_button.set_action_name("app.redo")
redo_button.set_use_underline(True)
self.save_button = Gtk.Button.new_with_label(_("Save"))
self.save_button.set_focus_on_click(False)
self.render_button = Gtk.Button.new_from_icon_name(
"system-run-symbolic", Gtk.IconSize.SMALL_TOOLBAR)
self.render_button.set_always_show_image(True)
self.render_button.set_label(_("Render"))
self.render_button.set_tooltip_text(
_("Export your project as a finished movie"))
self.render_button.set_sensitive(False) # The only one we have to set.
self.render_button.connect("clicked", self._renderCb)
undo_redo_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL,
spacing=0)
undo_redo_box.get_style_context().add_class("linked")
undo_redo_box.pack_start(undo_button,
expand=False,
fill=False,
padding=0)
undo_redo_box.pack_start(redo_button,
expand=False,
fill=False,
padding=0)
headerbar.pack_start(undo_redo_box)
self.builder.add_from_file(
os.path.join(get_ui_dir(), "mainmenubutton.ui"))
self.menu_button = self.builder.get_object("menubutton")
headerbar.pack_end(self.menu_button)
headerbar.pack_end(self.save_button)
headerbar.pack_end(self.render_button)
headerbar.show_all()
return headerbar
def __init__(self, title, description, button_text, text_array):
Template.__init__(self, title, description, button_text)
self.button_container = Gtk.Box(orientation=Gtk.Orientation.VERTICAL,
spacing=0)
self.buttons = []
self.box.pack_start(self.button_container, False, False, 0)
def __init__(self,
parent,
subtitle,
name=None,
rolls=None,
style_css=None):
if rolls is None:
rolls = []
self.rolls = copy.deepcopy(rolls)
self.name = name
Gtk.Dialog.__init__(
self,
'Template',
parent,
Gtk.DialogFlags.MODAL,
use_header_bar=True,
)
self.set_size_request(600, 900)
self.add_button('Cancel', Gtk.ResponseType.CANCEL)
self.add_button('OK', Gtk.ResponseType.OK)
# Create the header bar.
header = self.get_header_bar()
header.set_title('Template')
header.set_subtitle(subtitle)
# Create the main grid.
dlg_grid = Gtk.Grid()
dlg_grid.set_row_spacing(18)
dlg_grid.set_column_spacing(12)
dlg_grid.set_border_width(18)
self.get_content_area().add(dlg_grid)
# Create the add roll grid.
add_grid = Gtk.Grid()
add_grid.set_row_spacing(8)
add_grid.set_column_spacing(12)
dlg_grid.attach(add_grid, 0, 0, 1, 1)
# Create the template details main label.
details_lbl = Gtk.Label()
details_lbl.set_markup(
'<span size="x-large">Template Details</span>', )
details_lbl.set_alignment(0, 0.5)
details_lbl.set_margin_bottom(5)
add_grid.attach_next_to(
details_lbl,
None,
Gtk.PositionType.RIGHT,
3,
1,
)
# Create the template name row.
name_lbl = Gtk.Label('Name')
name_lbl.set_alignment(1, 0.5)
add_grid.attach_next_to(
name_lbl,
details_lbl,
Gtk.PositionType.BOTTOM,
1,
1,
)
self.name_ent = Gtk.Entry()
self.name_ent.set_hexpand(True)
add_grid.attach_next_to(
self.name_ent,
name_lbl,
Gtk.PositionType.RIGHT,
2,
1,
)
# Create the add roll main label.
add_lbl = Gtk.Label()
add_lbl.set_markup('<span size=\'x-large\'>Add Roll</span>')
add_lbl.set_alignment(0, 0.5)
add_lbl.set_margin_top(5)
add_lbl.set_margin_bottom(5)
add_grid.attach_next_to(
add_lbl,
name_lbl,
Gtk.PositionType.BOTTOM,
3,
1,
)
# Create the roll row.
roll_row_lbl = Gtk.Label('Roll')
roll_row_lbl.set_alignment(1, 0.5)
add_grid.attach_next_to(
roll_row_lbl,
add_lbl,
Gtk.PositionType.BOTTOM,
1,
1,
)
roll_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
self.count_ent = Gtk.Entry()
self.count_ent.set_width_chars(4)
self.count_ent.props.xalign = 0.5
roll_box.pack_start(self.count_ent, False, False, 0)
self.count_error_popover = Gtk.Popover()
self.count_error_popover.set_relative_to(self.count_ent)
d_lbl = Gtk.Label('d')
roll_box.pack_start(d_lbl, True, True, 0)
self.die_ent = Gtk.Entry()
self.die_ent.set_width_chars(4)
self.die_ent.props.xalign = 0.5
roll_box.pack_start(self.die_ent, False, False, 0)
self.die_error_popover = Gtk.Popover()
self.die_error_popover.set_relative_to(self.die_ent)
plus_lbl = Gtk.Label('+')
roll_box.pack_start(plus_lbl, True, True, 0)
self.mod_ent = Gtk.Entry()
self.mod_ent.set_width_chars(4)
self.mod_ent.props.xalign = 0.5
roll_box.pack_start(self.mod_ent, False, False, 0)
self.mod_error_popover = Gtk.Popover()
self.mod_error_popover.set_relative_to(self.mod_ent)
self.mod_chk = Gtk.CheckButton('Add modifier to every roll')
self.mod_chk.set_active(True)
self.mod_chk.set_margin_left(12)
roll_box.pack_start(self.mod_chk, False, False, 0)
add_grid.attach_next_to(
roll_box,
roll_row_lbl,
Gtk.PositionType.RIGHT,
2,
1,
)
# Create the critical row.
crit_lbl = Gtk.Label('On critical')
crit_lbl.set_alignment(1, 0.5)
crit_store = Gtk.ListStore(str, int)
for crit_option in CRITICAL_OPTIONS:
crit_store.append(crit_option)
self.crit_cbox = Gtk.ComboBox.new_with_model(crit_store)
self.crit_cbox.set_active(0)
crit_renderer = Gtk.CellRendererText()
self.crit_cbox.pack_start(crit_renderer, True)
self.crit_cbox.add_attribute(crit_renderer, 'text', 0)
add_grid.attach_next_to(
crit_lbl,
roll_row_lbl,
Gtk.PositionType.BOTTOM,
1,
1,
)
add_grid.attach_next_to(
self.crit_cbox,
crit_lbl,
Gtk.PositionType.RIGHT,
2,
1,
)
# Create the critical multiplier row.
crit_placeholder_lbl = Gtk.Label('')
crit_mult_lbl = Gtk.Label('Multiplier')
crit_mult_lbl.set_margin_right(12)
self.crit_ent = Gtk.Entry()
self.crit_ent.set_width_chars(4)
self.crit_ent.props.xalign = 0.5
crit_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
self.crit_error_popover = Gtk.Popover()
self.crit_error_popover.set_relative_to(self.crit_ent)
crit_box.pack_start(crit_mult_lbl, False, False, 0)
crit_box.pack_start(self.crit_ent, False, False, 0)
add_grid.attach_next_to(
crit_placeholder_lbl,
crit_lbl,
Gtk.PositionType.BOTTOM,
1,
1,
)
add_grid.attach_next_to(
crit_box,
crit_placeholder_lbl,
Gtk.PositionType.RIGHT,
2,
1,
)
# Create the minimum value row.
min_value_lbl = Gtk.Label('Minimum value')
min_value_lbl.set_alignment(1, 0.5)
self.min_value_ent = Gtk.Entry()
self.min_value_ent.set_placeholder_text('No minimum value')
self.min_value_ent.set_hexpand(True)
add_grid.attach_next_to(
min_value_lbl,
crit_placeholder_lbl,
Gtk.PositionType.BOTTOM,
1,
1,
)
add_grid.attach_next_to(
self.min_value_ent,
min_value_lbl,
Gtk.PositionType.RIGHT,
2,
1,
)
# Create the description row.
desc_lbl = Gtk.Label('Name')
desc_lbl.set_alignment(1, 0.5)
desc_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
Gtk.StyleContext.add_class(desc_box.get_style_context(), 'linked')
self.desc_ent = Gtk.Entry()
self.desc_ent.set_hexpand(True)
desc_box.add(self.desc_ent)
self.desc_error_popover = Gtk.Popover()
self.desc_error_popover.set_relative_to(self.desc_ent)
self.add_btn = Gtk.Button('Add Roll')
desc_box.add(self.add_btn)
add_grid.attach_next_to(
desc_lbl,
min_value_lbl,
Gtk.PositionType.BOTTOM,
1,
1,
)
add_grid.attach_next_to(
desc_box,
desc_lbl,
Gtk.PositionType.RIGHT,
2,
1,
)
# Create the rolls grid.
roll_grid = Gtk.Grid()
roll_grid.set_row_spacing(0)
roll_grid.set_column_spacing(12)
dlg_grid.attach(roll_grid, 0, 1, 1, 1)
# Create the rolls main label.
roll_lbl = Gtk.Label()
roll_lbl.set_markup('<span size=\'x-large\'>Rolls</span>')
roll_lbl.set_alignment(0, 0.5)
roll_lbl.set_margin_bottom(10)
roll_grid.attach_next_to(roll_lbl, None, Gtk.PositionType.RIGHT, 1, 1)
# Create the rolls list.
roll_scroll_win = Gtk.ScrolledWindow()
roll_scroll_win.set_hexpand(True)
roll_scroll_win.set_vexpand(True)
roll_grid.attach_next_to(
roll_scroll_win,
roll_lbl,
Gtk.PositionType.BOTTOM,
1,
1,
)
self.roll_store = Gtk.ListStore(int, str, str, str)
self.roll_tree = Gtk.TreeView(model=self.roll_store)
self.roll_tree.get_selection().set_mode(Gtk.SelectionMode.MULTIPLE)
self.roll_tree.set_reorderable(True)
desc_text = Gtk.CellRendererText()
desc_text.set_padding(5, 5)
self.desc_col = Gtk.TreeViewColumn('Name', desc_text, text=1)
self.desc_col.set_expand(True)
self.roll_tree.append_column(self.desc_col)
roll_text = Gtk.CellRendererText()
roll_text.set_padding(5, 5)
self.roll_col = Gtk.TreeViewColumn('Roll', roll_text, text=2)
self.roll_col.set_expand(True)
self.roll_tree.append_column(self.roll_col)
crit_text = Gtk.CellRendererText()
crit_text.set_padding(5, 5)
self.crit_col = Gtk.TreeViewColumn('Critical', crit_text, text=3)
self.crit_col.set_expand(True)
self.roll_tree.append_column(self.crit_col)
roll_scroll_win.add(self.roll_tree)
# Create the roll list action bar.
self.roll_action_bar = Gtk.ActionBar()
self.roll_action_bar.get_style_context().add_class("inline-toolbar")
roll_grid.attach_next_to(
self.roll_action_bar,
roll_scroll_win,
Gtk.PositionType.BOTTOM,
1,
1,
)
# Create the template list buttons.
roll_btn_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
Gtk.StyleContext.add_class(roll_btn_box.get_style_context(), 'linked')
self.roll_action_bar.pack_start(roll_btn_box)
self.edit_btn = Gtk.Button()
self.edit_btn.add(load_symbolic('edit'))
self.edit_btn.set_tooltip_text('Edit selected roll')
self.delete_btn = Gtk.Button()
self.delete_btn.add(load_symbolic('list-remove'))
self.delete_btn.set_tooltip_text('Remove selected roll')
roll_btn_box.add(self.edit_btn)
roll_btn_box.add(self.delete_btn)
# Create the roll drag and drop help text.
drag_roll_lbl = Gtk.Label('Drag and drop to rearrange roll order', )
drag_roll_lbl.set_margin_top(10)
roll_grid.attach_next_to(
drag_roll_lbl,
self.roll_action_bar,
Gtk.PositionType.BOTTOM,
1,
1,
)
self.style_provider = Gtk.CssProvider()
self.style_context = Gtk.StyleContext()
self.style_context.add_provider_for_screen(
Gdk.Screen.get_default(),
self.style_provider,
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION,
)
self.style_provider.load_from_data(style_css)
save_btn = self.get_widget_for_response(
response_id=Gtk.ResponseType.OK, )
save_btn.set_can_default(True)
save_btn.grab_default()
self.add_btn.connect(
'clicked',
lambda x: self.add_roll(),
)
self.edit_btn.connect(
'clicked',
lambda x: self.edit_roll(),
)
self.delete_btn.connect(
'clicked',
lambda x: self.remove_roll(),
)
self.crit_cbox.connect(
'changed',
lambda x: self.update_multipler_active(),
)
self.roll_tree.connect(
'row-activated',
lambda x, y, z: self.edit_roll(),
)
self.roll_tree.connect(
'drag-end',
lambda x, y: self.reorder_rolls(),
)
self.desc_ent.connect(
'changed',
lambda x: self.check_edit_name(),
)
self.register_limit_inputs()
if self.name is not None:
self.name_ent.set_text(self.name)
self.update_list()
self.show_all()
def __init__(self):
super().__init__(title="还原备份")
self.set_default_size(640, 480)
self.set_deletable(False)
self.skip_next = False
self.exit_code = 0
paned = Gtk.Paned()
self.add(paned)
paned.show()
scrolled = Gtk.ScrolledWindow()
paned.pack1(scrolled, True, False)
scrolled.show()
textview = Gtk.TextView()
textview.set_editable(False)
scrolled.add(textview)
textview.show()
self.buffer = textview.get_buffer()
self.log("日志开始")
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
paned.pack2(vbox, False, False)
vbox.show()
scrolled = Gtk.ScrolledWindow(hscrollbar_policy=Gtk.PolicyType.NEVER)
vbox.pack_start(scrolled, True, True, 0)
scrolled.show()
self.store = Gtk.ListStore(str, int, str)
listiter = self.store.append(["", 0, "1970-01-01 08:00:00"])
for i in sorted(map(self.parse_backup, os.listdir(BACKUPS_DIR)),
reverse=True):
self.store.append(i[1:])
GLib.idle_add(self.store.remove, listiter)
self.treeview = Gtk.TreeView(model=self.store)
self.treeview.append_column(
Gtk.TreeViewColumn("存档", Gtk.CellRendererText(), text=1))
self.treeview.append_column(
Gtk.TreeViewColumn("时间", Gtk.CellRendererText(), text=2))
scrolled.add(self.treeview)
self.treeview.show()
hbox = Gtk.Box()
vbox.pack_start(hbox, False, True, 0)
hbox.show()
button = Gtk.Button(label="删除")
button.connect("clicked", self.delete_clicked)
hbox.pack_start(button, True, True, 0)
button.show()
button = Gtk.Button(label="还原")
button.connect("clicked", self.restore_clicked)
hbox.pack_start(button, True, True, 0)
button.show()
# 如果不保存FileMonitor，就不会生效（Bug？）
self.monitor = Gio.File.new_for_path(SAVES_DIR).monitor(
Gio.FileMonitorFlags.NONE, None)
self.monitor.connect("changed", self.monitor_changed)
threading.Thread(target=self.open_process).start()
def __init__(self):
Gtk.Window.__init__(self, title="ListBox Demo")
self.set_border_width(10)
# Create the box widget
box_outer = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
self.add(box_outer)
# Create the listbox widget
listbox = Gtk.ListBox()
listbox.set_selection_mode(Gtk.SelectionMode.NONE)
# Add the listbox widget to the box widget
box_outer.pack_start(listbox, True, True, 0)
# Create a list box row
row = Gtk.ListBoxRow()
# Create another box widget to add to the box_outer
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=50)
# Add a horizontal box to the row
row.add(hbox)
# Create a vertical box
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
hbox.pack_start(vbox, True, True, 0)
# Create two label widgets
label1 = Gtk.Label(label="Automatic Date & Time", xalign=0)
label2 = Gtk.Label(label="Requires internet access", xalign=0)
# Add the two label widgets to the vertical box
vbox.pack_start(label1, True, True, 0)
vbox.pack_start(label2, True, True, 0)
# Create a switch widget
switch = Gtk.Switch()
switch.props.valign = Gtk.Align.CENTER
# Add the switch to the horizontal box
hbox.pack_start(switch, False, True, 0)
listbox.add(row)
# Create another row widget
row = Gtk.ListBoxRow()
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=50)
row.add(hbox)
label = Gtk.Label(label="Enable Automatic Update", xalign=0)
check = Gtk.CheckButton()
# Add the label and check button to the row with relative positions
hbox.pack_start(label, True, True, 0)
# Expand is set to False
hbox.pack_start(check, False, True, 0)
# Add this row to the listbox widget
listbox.add(row)
# Create the final row
row = Gtk.ListBoxRow()
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=50)
row.add(hbox)
label = Gtk.Label(label="Date Format", xalign=0)
# Create a combo box
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)
def __init__(self):
super(MessageArea, self).__init__()
self.set_name("MessageArea")
self.hbox = Gtk.Box(Gtk.Orientation.HORIZONTAL)
self.hbox.show()
self.text = ""
self.set_app_paintable(True)
self.anim = WidgetFade(
self.hbox,
self.hbox.get_style_context().get_background_color(
Gtk.StateFlags.NORMAL))
self.hl_anim = WidgetFade(self.hbox, Gdk.RGBA(1, 0, 0, 1))
self.setting_style = False
self.hbox.props.spacing = 4
self.hbox.set_border_width(2)
self.icon = Gtk.Image()
self.label = Gtk.Label()
self.label.props.xalign = 0
self.label.set_ellipsize(Pango.EllipsizeMode.END)
self.label.set_single_line_mode(True)
self.label.set_selectable(True)
self.b_more = Gtk.Button(_("More"))
im = Gtk.Image()
im.set_from_icon_name("dialog-information", Gtk.IconSize.MENU)
im.show()
self.b_more.set_image(im)
self.b_more.props.relief = Gtk.ReliefStyle.NONE
im = Gtk.Image()
im.set_from_icon_name("window-close", Gtk.IconSize.MENU)
im.show()
self.b_close = Gtk.Button()
self.b_close.add(im)
self.b_close.props.relief = Gtk.ReliefStyle.NONE
self.b_close.props.tooltip_text = _("Close")
self.hbox.pack_start(self.icon, False, False, 4)
self.hbox.pack_start(self.label, True, False, 0)
self.hbox.pack_start(self.b_more, False, False, 0)
self.hbox.pack_start(self.b_close, False, False, 0)
self.add(self.hbox)
self.icon.show()
self.b_close.show()
self.label.show()
self.b_more.show()
self.b_close.connect("clicked", self.on_close)
self.b_more.connect("clicked", self.on_more)
self.hbox.connect("draw", self.draw)
self.b_close.connect("style-set", self.style_set)
def __init__(self, parent, collection_type, spices, window):
super(DownloadSpicesPage, self).__init__()
self.expand = True
self.set_spacing(0)
self.set_margin_top(5)
self.parent = parent
self.collection_type = collection_type
self.spices = spices
self.window = window
self.has_filter = False
self.extension_rows = []
self._signals = []
self.top_box = Gtk.Box()
self.pack_start(self.top_box, False, False, 10)
sort_label = Gtk.Label()
sort_label.set_text(_("Sort by"))
self.top_box.pack_start(sort_label, False, False, 4)
self.sort_combo = Gtk.ComboBox()
sort_types = Gtk.ListStore(str, str)
self.sort_combo.set_model(sort_types)
renderer_text = Gtk.CellRendererText()
self.sort_combo.pack_start(renderer_text, True)
self.sort_combo.add_attribute(renderer_text, "text", 1)
self.sort_combo.set_id_column(0)
sort_types.append(['name', _("Name")])
sort_types.append(['score', _("Popularity")])
sort_types.append(['date', _("Date")])
sort_types.append(['installed', _("Installed")])
sort_types.append(['update', _("Upgradable")])
self.sort_combo.set_active(1) #Rating
self.sort_combo.connect('changed', self.sort_changed)
self.top_box.pack_start(self.sort_combo, False, False, 4)
self.search_entry = Gtk.Entry()
self.search_entry.set_icon_from_icon_name(
Gtk.EntryIconPosition.PRIMARY, 'edit-find-symbolic')
self.search_entry.set_placeholder_text(_("Search"))
self.search_entry.connect('changed', self.on_entry_refilter)
self.top_box.pack_end(self.search_entry, False, False, 4)
frame = Gtk.Frame()
frame.set_shadow_type(Gtk.ShadowType.IN)
frame_style = frame.get_style_context()
frame_style.add_class('view')
self.pack_start(frame, True, True, 0)
main_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
frame.add(main_box)
scw = Gtk.ScrolledWindow()
scw.expand = True
scw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
scw.set_shadow_type(Gtk.ShadowType.NONE)
main_box.pack_start(scw, True, True, 0)
self.box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
scw.add(self.box)
self.infobar_holder = Gtk.Frame(shadow_type=Gtk.ShadowType.NONE)
self.box.add(self.infobar_holder)
self.list_box = Gtk.ListBox()
self.list_box.set_selection_mode(Gtk.SelectionMode.SINGLE)
self.list_box.set_header_func(list_header_func, None)
self.list_box.connect('row-selected', self.on_row_selected)
self.box.add(self.list_box)
button_toolbar = Gtk.Toolbar.new()
Gtk.StyleContext.add_class(
Gtk.Widget.get_style_context(button_toolbar), 'inline-toolbar')
self.add(button_toolbar)
button_holder = Gtk.ToolItem()
button_holder.set_expand(True)
button_toolbar.add(button_holder)
box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
box.set_halign(Gtk.Align.CENTER)
button_holder.add(box)
# buttons
self.more_info_button = Gtk.Button.new_from_icon_name(
"dialog-information-symbolic", Gtk.IconSize.MENU)
self.more_info_button.set_size_request(50, -1)
self.more_info_button.set_tooltip_text(_("More info"))
self.more_info_button.connect('clicked', self.get_more_info)
box.add(self.more_info_button)
self.more_info_button.set_sensitive(False)
self.uninstall_button = Gtk.Button.new_from_icon_name(
"edit-delete-symbolic", Gtk.IconSize.MENU)
self.uninstall_button.set_size_request(50, -1)
self.uninstall_button.set_tooltip_text(_("Uninstall"))
self.uninstall_button.connect('clicked', self.uninstall)
box.add(self.uninstall_button)
self.uninstall_button.set_sensitive(False)
self.update_all_button = Gtk.Button.new_from_icon_name(
"software-update-available-symbolic", Gtk.IconSize.MENU)
self.update_all_button.set_size_request(50, -1)
self.update_all_button.connect('clicked', self.update_all)
box.add(self.update_all_button)
self.update_all_button.set_sensitive(False)
self.refresh_button = Gtk.Button.new_from_icon_name(
"emblem-synchronizing-symbolic", Gtk.IconSize.MENU)
self.refresh_button.set_size_request(50, -1)
self.refresh_button.set_tooltip_text(_("Refresh"))
self.refresh_button.connect('clicked', self.refresh)
box.add(self.refresh_button)
# progress bar
self.progress_bar = self.spices.get_progressbar()
pb_container = Gtk.Box()
pb_container.set_margin_top(20)
pb_container.pack_start(self.progress_bar, True, True, 0)
self.pack_end(pb_container, False, False, 0)
self.install_list = []
self.update_list = {}
self.current_num_updates = 0
self.sort_changed()
self.connect('map', self.on_page_map)
self.spices.connect('cache-loaded', self.build_list)
self.spices.connect('installed-changed', self.build_list)
self.build_list()
def on_open_clicked(self, open_button):
if (self.first_run is False):
self.context_id = self.status_bar.push(self.context_id,\
_("Go on to open a new Database"))
backup_url = self.choose_database_file()
if (backup_url is None):
self.context_id = self.status_bar.push(self.context_id,\
_("No Database chosen, try again"))
return
self.backup_path = os.path.dirname(backup_url)
manifest_file = os.path.join(self.backup_path, 'Manifest.plist')
self.manifest = self.read_binary_plist(manifest_file)
status_file = os.path.join(self.backup_path, 'Status.plist')
self.status = self.read_binary_plist(status_file)
try:
sqliteConnection = sqlite3.connect(backup_url)
cursor = sqliteConnection.cursor()
self.context_id = self.status_bar.push(self.context_id,\
_("Database created and successfully connected to SQLite"))
query = "SELECT * FROM Files"
cursor.execute(query)
self.records = cursor.fetchall()
# order column names into first tuple of the list
self.names = list(zip(*cursor.description))
# truncate list to first tuple
del self.names[1:]
cursor.close()
except sqlite3.Error as error:
self.context_id = self.status_bar.push(self.context_id,\
_("Error while connecting to sqlite"))
finally:
if (sqliteConnection):
sqliteConnection.close()
self.context_id = self.status_bar.push(self.context_id,\
_("The SQLite connection is closed after reading"))
listmodel = self.combo.get_model()
treemodel = self.treeview.get_model()
if (len(self.naked_domains)):
del self.naked_domains[:]
# clear entry and models
self.combo.set_active(-1)
entry = self.combo.get_child()
entry.set_text(str())
entry.set_placeholder_text(_("Please select domain to display"))
listmodel.clear()
treemodel.clear()
# filter out "naked" domains where relativePath is empty
for record in self.records:
path = record[2]
if (not path):
self.naked_domains.append(record[1])
# sort in ascending order
self.naked_domains.sort()
# fill combobox listmodel
index = 0
for naked_domain in self.naked_domains:
index += 1
listmodel.append([naked_domain, index])
self.context_id = self.status_bar.push(self.context_id,\
f(_('Combobox filled with {index} domain names, please select one')))
self.remove(self.vbox)
if (self.first_run):
# prepare scrolled window
self.scrolled_window.add(self.treeview)
self.scrolled_window.show()
# add new widgets and reorder
self.vbox.remove(self.label_box)
# add horizontal combobox
self.vbox.pack_start(self.domain_box, False, False, 0)
self.vbox.pack_start(self.scrolled_window, False, True, 0)
self.vbox.pack_start(self.label_box, True, True, 0)
# generate horizontal box at bottom for manifest, status, export
self.bottom_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL,
spacing=0)
self.bottom_box.set_border_width(0)
# prepare button for Manifest.plist
self.manifest_button = Gtk.Button.new_with_label("Manifest.plist")
self.manifest_button.connect("clicked",
self.on_manifest_show_clicked, True)
self.bottom_box.pack_start(self.manifest_button, False, True, 0)
# prepare button for Status.plist
self.status_button = Gtk.Button.new_with_label("Status.plist")
self.status_button.connect("clicked", self.on_status_show_clicked,
True)
self.bottom_box.pack_start(self.status_button, True, False, 0)
export_button = Gtk.Button.new_with_label(_("Export CSV..."))
export_button.connect("clicked", self.on_export_csv_clicked)
self.bottom_box.pack_end(export_button, False, True, 0)
self.bottom_box.pack_end(export_button, True, True, 0)
self.vbox.pack_start(self.bottom_box, False, True, 0)
self.first_run = False
self.manifest_button.set_sensitive(self.manifest is not None)
self.status_button.set_sensitive(self.status is not None)
self.add(self.vbox)
self.show_all()
def __build_window(self):
"""Build up the widget"""
# toplevel widget
self.top_vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.add(self.top_vbox)
# header line: icon, grid with name and "hide in wv"
# FIXME
self.hdr_align = Gtk.Alignment()
self.top_vbox.pack_start(self.hdr_align, False, True, 0)
self.hdr_align.set_padding(0, 5, 0, 0)
self.hdr_box = Gtk.Box()
self.clear_box = Gtk.Box()
self.hdr_align.add(self.hdr_box)
self.hdr_box.set_spacing(10)
# Button to tag icon selector
self.ti_bt = Gtk.Button()
self.ti_bt_label = Gtk.Label()
self.ti_bt.add(self.ti_bt_label)
self.hidden_entry = Gtk.Entry()
self.hidden_entry.set_width_chars(1)
self.ti_bt_label.get_style_context().add_class('icon')
self.hidden_entry.get_style_context().add_class('hidden')
self.hdr_box.pack_start(self.ti_bt, False, False, 0)
self.hdr_box.pack_start(self.hidden_entry, False, False, 0)
self.ti_bt.set_size_request(64, 64)
self.hidden_entry.set_size_request(0, 0)
self.ti_bt.set_relief(Gtk.ReliefStyle.HALF)
self.ti_bt_clear = Gtk.Button()
self.ti_bt_clear.set_label(_('Remove icon'))
self.clear_box.add(self.ti_bt_clear)
# vbox for tag name and hid in WV
self.tp_grid = Gtk.Grid()
self.hdr_box.pack_start(self.tp_grid, False, True, 0)
self.tp_grid.set_column_spacing(5)
self.tn_entry_lbl_align = Gtk.Alignment.new(0, 0.5, 0, 0)
self.tp_grid.add(self.tn_entry_lbl_align)
self.tn_entry_lbl = Gtk.Label()
self.tn_entry_lbl.set_markup("<span weight='bold'>%s</span>" %
_("Name : "))
self.tn_entry_lbl_align.add(self.tn_entry_lbl)
self.tn_entry = Gtk.Entry()
self.tn_entry.set_width_chars(20)
self.tp_grid.attach(self.tn_entry, 1, 0, 1, 1)
self.tn_cb_lbl_align = Gtk.Alignment.new(0, 0.5, 0, 0)
self.tp_grid.attach(self.tn_cb_lbl_align, 0, 1, 1, 1)
self.tn_cb_lbl = Gtk.Label(label=_('Show Tag in "Actionable" view:'))
self.tn_cb_lbl_align.add(self.tn_cb_lbl)
self.tn_cb = Gtk.CheckButton()
self.tp_grid.attach(self.tn_cb, 1, 1, 1, 1)
# Tag color
self.tc_vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.top_vbox.pack_start(self.clear_box, False, False, 0)
self.top_vbox.pack_start(self.tc_vbox, False, True, 0)
self.tc_label_align = Gtk.Alignment()
self.tc_vbox.pack_start(self.tc_label_align, False, True, 0)
self.tc_label_align.set_padding(25, 0, 0, 0)
self.tc_label = Gtk.Label()
self.tc_label_align.add(self.tc_label)
self.tc_label.set_markup("<span weight='bold'>%s</span>" %
_("Select Tag Color:"))
self.tc_label.set_alignment(0, 0.5)
# Tag color chooser
self.tc_cc_align = Gtk.Alignment.new(0.5, 0.5, 0, 0)
self.tc_vbox.pack_start(self.tc_cc_align, False, False, 0)
self.tc_cc_align.set_padding(25, 15, 10, 10)
self.tc_cc_colsel = SimpleColorSelector()
# self.tc_cc_colsel = Gtk.ColorChooserWidget()
self.tc_cc_align.add(self.tc_cc_colsel)
def load(self, persp):
self.persp = persp
self.box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
self.tv = Gtk.TreeView()
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(_("Title"), renderer, text=1)
self.tv.append_column(column)
renderer = Gtk.CellRendererText()
column = Gtk.TreeViewColumn(_("Source"), renderer, text=2)
self.tv.append_column(column)
renderer = Gtk.CellRendererProgress()
column = Gtk.TreeViewColumn(_("Progress"), renderer, text=3, value=4)
self.tv.append_column(column)
self.tv.connect("row-activated", self.row_activated)
def on_progress_updated(solving_progress, key, progress):
for i, row in enumerate(self.store):
if row[0] == key:
solved = progress.count(1)
percent = 0 if not solved else round(
(solved * 100.) / len(progress))
treeiter = self.store.get_iter(Gtk.TreePath(i))
self.store[treeiter][3] = "%s / %s" % (solved,
len(progress))
self.store[treeiter][4] = percent
puzzles_solving_progress.connect("progress_updated",
on_progress_updated)
self.store = Gtk.ListStore(str, str, str, str, int)
@asyncio.coroutine
def coro():
for file_name, title, author in PUZZLES:
progress = puzzles_solving_progress.get(file_name)
solved = progress.count(1)
percent = 0 if not solved else round(
(solved * 100.) / len(progress))
self.store.append([
file_name, title, author,
"%s / %s" % (solved, len(progress)), percent
])
yield from asyncio.sleep(0)
asyncio. async (coro())
self.tv.set_model(self.store)
self.tv.get_selection().set_mode(Gtk.SelectionMode.BROWSE)
self.tv.set_cursor(conf.get("learncombo%s" % PUZZLE))
scrollwin = Gtk.ScrolledWindow()
scrollwin.add(self.tv)
scrollwin.show_all()
self.box.pack_start(scrollwin, True, True, 0)
self.box.show_all()
return self.box
def _setup_view(self):
self._search = Search()
self._searchbar = SearchBar()
self._searchbar.props.stack = self._stack
self._headerbar = HeaderBar()
self._search.bind_property(
"search-mode-active", self._headerbar, "search-mode-active",
GObject.BindingFlags.BIDIRECTIONAL
| GObject.BindingFlags.SYNC_CREATE)
self._search.bind_property("search-mode-active", self._searchbar,
"search-mode-enabled",
GObject.BindingFlags.SYNC_CREATE)
self._search.bind_property("state", self._searchbar, "search-state",
GObject.BindingFlags.SYNC_CREATE)
self._player_toolbar = PlayerToolbar()
self._player_toolbar.props.player = self._player
self._headerbar.connect('back-button-clicked',
self._switch_back_from_childview)
self.bind_property('selected-items-count', self._headerbar,
'selected-items-count')
self.bind_property("selected-items-count", self._selection_toolbar,
"selected-items-count")
self.bind_property(
'selection-mode', self._headerbar, 'selection-mode',
GObject.BindingFlags.BIDIRECTIONAL
| GObject.BindingFlags.SYNC_CREATE)
self.bind_property("selection-mode", self._player_toolbar, "visible",
GObject.BindingFlags.INVERT_BOOLEAN)
self.bind_property("selection-mode", self._selection_toolbar,
"visible")
self.connect("notify::selection-mode", self._on_selection_mode_changed)
self.views = [Gtk.Box()] * len(View)
# Create only the empty view at startup
# if no music, switch to empty view and hide stack
# if some music is available, populate stack with mainviews,
# show stack and set empty_view to empty_search_view
self.views[View.EMPTY] = EmptyView()
self._stack.add_named(self.views[View.EMPTY], "emptyview")
# Add the 'background' styleclass so it properly hides the
# bottom line of the searchbar
self._stack.get_style_context().add_class('background')
# FIXME: Need to find a proper way to do this.
self._overlay.add_overlay(self._searchbar._dropdown)
self._box.pack_start(self._searchbar, False, False, 0)
self._box.reorder_child(self._searchbar, 0)
self._box.pack_end(self._player_toolbar, False, False, 0)
self.set_titlebar(self._headerbar)
self._selection_toolbar.connect('add-to-playlist',
self._on_add_to_playlist)
self._search.connect("notify::state", self._on_search_state_changed)
self._headerbar.props.state = HeaderBar.State.MAIN
self._headerbar.show()
def songs_available_cb(available):
if available:
self._switch_to_player_view()
else:
self._switch_to_empty_view()
if Query().music_folder:
grilo.songs_available(songs_available_cb)
else:
self._switch_to_empty_view()
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
def cliquer(bouton):
print('clic')
print('Bouton> ' + str(bouton))
win = Gtk.Window(title='Foody')
win.set_title('Foody')
print(dir(win))
win.connect("destroy", Gtk.main_quit)
b1 = Gtk.Button(label='clic')
b1.connect('clicked', cliquer)
b2 = Gtk.Button(label='clic')
b2.connect('clicked', cliquer)
box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
box.pack_start(b1, False, False, 2)
box.pack_start(b2, False, False, 2)
win.add(box)
win.show_all()
Gtk.main()
def __init__(self):
Controller.__init__(self)
self.prefs_dialog = None # preferences dialog controller
self.window.set_position(gtk.WindowPosition.CENTER)
self.window.set_default_icon_name("org.gnome.Hamster.GUI")
self.window.set_default_size(700, 500)
self.storage = hamster.client.Storage()
self.storage.connect("facts-changed", self.on_facts_changed)
self.storage.connect("activities-changed", self.on_facts_changed)
self.header_bar = HeaderBar()
self.window.set_titlebar(self.header_bar)
main = gtk.Box(orientation=1)
self.window.add(main)
self.report_chooser = None
self.search_box = gtk.Revealer()
space = gtk.Box(border_width=5)
self.search_box.add(space)
self.filter_entry = gtk.Entry()
self.filter_entry.set_icon_from_icon_name(
gtk.EntryIconPosition.PRIMARY, "edit-find-symbolic")
self.filter_entry.connect("changed", self.on_search_changed)
self.filter_entry.connect("icon-press", self.on_search_icon_press)
space.pack_start(self.filter_entry, True, True, 0)
main.pack_start(self.search_box, False, True, 0)
window = gtk.ScrolledWindow()
window.set_policy(gtk.PolicyType.NEVER, gtk.PolicyType.AUTOMATIC)
self.fact_tree = FactTree()
self.fact_tree.connect("on-activate-row", self.on_row_activated)
self.fact_tree.connect("on-delete-called", self.on_row_delete_called)
window.add(self.fact_tree)
main.pack_start(window, True, True, 1)
self.totals = Totals()
main.pack_start(self.totals, False, True, 1)
# FIXME: should store and recall date_range from hamster.lib.configuration.conf
hamster_day = dt.hday.today()
self.header_bar.range_pick.set_range(hamster_day)
self.header_bar.range_pick.connect("range-selected",
self.on_range_selected)
self.header_bar.add_activity_button.connect(
"clicked", self.on_add_activity_clicked)
self.header_bar.stop_button.connect("clicked", self.on_stop_clicked)
self.header_bar.search_button.connect("toggled",
self.on_search_toggled)
self.header_bar.menu_prefs.connect("activate", self.on_prefs_clicked)
self.header_bar.menu_export.connect("activate", self.on_export_clicked)
self.header_bar.menu_help.connect("activate", self.on_help_clicked)
self.window.connect("key-press-event", self.on_key_press)
self.facts = []
self.find_facts()
# update every minute (necessary if an activity is running)
gobject.timeout_add_seconds(60, self.on_timeout)
self.window.show_all()
def __init__(self):
gtk.Window.__init__(self, title="Logs")
self.set_border_width(10)
self.set_position(gtk.WindowPosition.CENTER)
self.set_default_size(300, 450)
#self.outter_box = gtk.Box(gtk.Orientation.HORIZONTAL, spacing=10)
self.outter_box = gtk.VBox(False, spacing=10)
self.add(self.outter_box)
c.execute("select * from Logs")
software_list = c.fetchall()
self.software_liststore = gtk.ListStore(str, str, int)
for software_ref in software_list:
self.software_liststore.append(list(software_ref))
self.tree = gtk.TreeView(self.software_liststore)
self.tree_selection = self.tree.get_selection()
self.tree_selection.connect("changed", self.onSelectionChanged)
for i, column_title in enumerate(["Plate", "Entry Time", "Inside"]):
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(column_title, renderer, text=i)
self.tree.append_column(column)
self.scrollable_treelist = gtk.ScrolledWindow()
self.scrollable_treelist.set_vexpand(True)
self.scrollable_treelist.set_hexpand(True)
self.outter_box.pack_start(self.scrollable_treelist, False, True, 0)
self.scrollable_treelist.add(self.tree)
hbox2 = gtk.Box(gtk.Orientation.HORIZONTAL)
self.outter_box.pack_start(hbox2, False, False, 0)
#hbox2.set_layout(gtk.CENTER)
self.entryid = gtk.Entry()
self.entry = gtk.Entry()
self.entry2 = gtk.Entry()
hbox2.add(self.entry)
hbox2.add(self.entry2)
hbox = gtk.ButtonBox.new(gtk.Orientation.HORIZONTAL)
hbox.set_layout(gtk.ButtonBoxStyle.CENTER)
self.outter_box.pack_start(hbox, False, True, 0)
# Add CSS "linked" class
hbox.get_style_context().add_class("linked")
button_add = gtk.Button(label="Add")
hbox.add(button_add)
button_add.connect("clicked", self.add_btn_clicked)
button_update = gtk.Button(label="Update")
hbox.add(button_update)
button_update.connect("clicked", self.update_btn_clicked)
button_remove = gtk.Button(label="Remove")
hbox.add(button_remove)
button_remove.connect("clicked", self.remove_btn_clicked)
button_quit = gtk.Button(label="Quit", stock=gtk.STOCK_QUIT)
button_quit.show()
hbox.add(button_quit)
button_quit.connect("clicked", self.on_close_clicked)
button_refresh = gtk.Button(label="Refresh")
hbox.add(button_refresh)
button_refresh.connect("clicked", self.refresh_btn_clicked)
def create_window(self):
if os.path.exists('data/xpander.svg'):
self.set_icon_from_file(os.path.abspath('data/xpander.svg'))
else:
self.set_icon_name('xpander')
# General layout
main_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
self.add(main_box)
stack = Gtk.Stack(
transition_type=Gtk.StackTransitionType.SLIDE_LEFT_RIGHT)
paned = Gtk.Paned()
stack.add_titled(paned, 'manager', _('Manager'))
prefs_grid = Gtk.Grid(column_spacing=10,
row_spacing=10,
margin=10,
halign=Gtk.Align.START)
stack.add_titled(prefs_grid, 'prefs', _('Preferences'))
stack_switcher = Gtk.StackSwitcher(halign=Gtk.Align.CENTER)
stack_switcher.set_stack(stack)
main_box.pack_start(stack_switcher, False, True, 0)
main_box.pack_start(stack, True, True, 0)
# Manager
left_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
treeview_frame = Gtk.Frame(shadow_type=Gtk.ShadowType.IN)
scrollable_treelist = Gtk.ScrolledWindow(width_request=200)
scrollable_treelist.set_vexpand(True)
# Treeview
self.treestore = Gtk.TreeStore(str, str, str, Gdk.RGBA)
self.treeview = Gtk.TreeView.new_with_model(self.treestore)
self.add_mnemonic(Gdk.KEY_m, self.treeview)
self.treeview.set_headers_visible(False)
self.treeview.set_search_column(1)
icon_renderer = Gtk.CellRendererPixbuf()
icon_column = Gtk.TreeViewColumn('', icon_renderer, icon_name=0)
self.treeview.append_column(icon_column)
text_renderer = Gtk.CellRendererText()
text_renderer.set_property('editable', True)
text_column = Gtk.TreeViewColumn('Phrases', text_renderer, text=1)
self.treeview.append_column(text_column)
string_renderer = Gtk.CellRendererText()
context = self.treeview.get_style_context()
self.color_normal = context.get_background_color(Gtk.StateFlags.NORMAL)
self.color_disabled = context.get_background_color(
Gtk.StateFlags.INSENSITIVE)
string_renderer.set_property('editable', False)
string_column = Gtk.TreeViewColumn('Abbreviatios',
string_renderer,
text=2,
background_rgba=3)
self.treeview.append_column(string_column)
self.load_phrases()
# Drag and drop
target = Gtk.TargetEntry.new('row', Gtk.TargetFlags.SAME_WIDGET, 0)
self.treeview.enable_model_drag_source(
Gdk.ModifierType.BUTTON1_MASK, [target],
Gdk.DragAction.DEFAULT | Gdk.DragAction.MOVE)
self.treeview.enable_model_drag_dest([target], Gdk.DragAction.DEFAULT
| Gdk.DragAction.MOVE)
# Selection
self.selection = self.treeview.get_selection()
# Toolbar
toolbar = Gtk.Box(margin=2, spacing=2)
remove_icon = Gtk.Image.new_from_icon_name('list-remove-symbolic', 0)
remove_button = Gtk.Button()
remove_button.add_accelerator('clicked', self.gui_hotkeys,
Gdk.KEY_Delete,
Gdk.ModifierType.CONTROL_MASK,
Gtk.AccelFlags.VISIBLE)
remove_button.add(remove_icon)
toolbar.pack_end(remove_button, False, False, 0)
add_menu = Gtk.Menu()
add_phrase = Gtk.MenuItem('New phrase')
add_phrase.add_accelerator('activate', self.gui_hotkeys, Gdk.KEY_n,
Gdk.ModifierType.CONTROL_MASK,
Gtk.AccelFlags.VISIBLE)
add_folder = Gtk.MenuItem('New folder')
add_folder.add_accelerator(
'activate', self.gui_hotkeys, Gdk.KEY_n,
Gdk.ModifierType.CONTROL_MASK | Gdk.ModifierType.SHIFT_MASK,
Gtk.AccelFlags.VISIBLE)
add_menu.append(add_phrase)
add_menu.append(add_folder)
add_menu.show_all()
add_icon = Gtk.Image.new_from_icon_name('list-add-symbolic', 0)
add_button = Gtk.MenuButton()
add_button.add(add_icon)
add_button.set_popup(add_menu)
toolbar.pack_end(add_button, False, False, 0)
# Editor
editor_frame = Gtk.Frame(shadow_type=Gtk.ShadowType.IN)
self.right_grid = Gtk.Grid(column_spacing=6, row_spacing=6, margin=6)
self.right_grid.set_sensitive(False)
self.plain_text = Gtk.RadioButton.new_with_mnemonic_from_widget(
None, _('_Plain text'))
self.right_grid.attach(self.plain_text, 0, 0, 1, 1)
self.command = Gtk.RadioButton.new_with_label_from_widget(
self.plain_text, _('Command'))
self.right_grid.attach(self.command, 1, 0, 1, 1)
text_wrap = Gtk.CheckButton.new_with_mnemonic(_('_Wrap text'))
self.right_grid.attach(text_wrap, 5, 0, 1, 1)
scrollable_textview = Gtk.ScrolledWindow()
scrollable_textview.set_hexpand(True)
scrollable_textview.set_vexpand(True)
self.textview = Gtk.TextView()
self.add_mnemonic(Gdk.KEY_b, self.textview)
scrollable_textview.add(self.textview)
self.right_grid.attach(scrollable_textview, 0, 1, 6, 5)
token_label = Gtk.Label(
_('$| marks cursor position. $C inserts clipboard contents.'))
self.right_grid.attach(token_label, 0, 6, 3, 1)
string_label = Gtk.Label.new_with_mnemonic(_('_Abbreviation:'))
self.right_grid.attach(string_label, 0, 7, 1, 1)
self.string = Gtk.Entry(max_length=128)
string_label.set_mnemonic_widget(self.string)
self.right_grid.attach_next_to(self.string, string_label,
Gtk.PositionType.RIGHT, 2, 1)
send_label = Gtk.Label.new_with_mnemonic(_('_Send via:'))
self.right_grid.attach(send_label, 3, 7, 1, 1)
self.send = Gtk.ComboBoxText()
send_label.set_mnemonic_widget(self.send)
self.send.set_entry_text_column(0)
for method in SEND:
self.send.append_text(method)
self.right_grid.attach_next_to(self.send, send_label,
Gtk.PositionType.RIGHT, 2, 1)
filter_class_label = Gtk.Label.new_with_mnemonic(
_('Filter by window _class:'))
self.right_grid.attach(filter_class_label, 0, 8, 1, 1)
self.filter_class = Gtk.Entry()
self.right_grid.attach_next_to(self.filter_class, filter_class_label,
Gtk.PositionType.RIGHT, 2, 1)
set_filter_class = Gtk.ToggleButton(_('Select'))
filter_class_label.set_mnemonic_widget(set_filter_class)
self.right_grid.attach_next_to(set_filter_class, self.filter_class,
Gtk.PositionType.RIGHT, 1, 1)
filter_title_label = Gtk.Label.new_with_mnemonic(
_('_Filter by window title:'))
self.right_grid.attach(filter_title_label, 0, 9, 1, 1)
self.filter_title = Gtk.Entry()
self.right_grid.attach_next_to(self.filter_title, filter_title_label,
Gtk.PositionType.RIGHT, 2, 1)
set_filter_title = Gtk.ToggleButton(_('Select'))
filter_title_label.set_mnemonic_widget(set_filter_title)
self.right_grid.attach_next_to(set_filter_title, self.filter_title,
Gtk.PositionType.RIGHT, 1, 1)
self.filter_case = Gtk.CheckButton.new_with_mnemonic(
_('Case _sensitive'))
self.right_grid.attach_next_to(self.filter_case, set_filter_title,
Gtk.PositionType.RIGHT, 1, 1)
save_phrase = Gtk.Button(_('Save'))
save_phrase.add_accelerator('clicked', self.gui_hotkeys, Gdk.KEY_s,
Gdk.ModifierType.CONTROL_MASK,
Gtk.AccelFlags.VISIBLE)
self.right_grid.attach(save_phrase, 0, 10, 6, 1)
# Preferences
phrase_dir_label = Gtk.Label.new_with_mnemonic(
_('Phrase _directory (needs restart)'))
phrase_dir_label.set_xalign(0)
prefs_grid.attach(phrase_dir_label, 0, 0, 2, 1)
phrase_dir = Gtk.FileChooserButton.new(
_('Phrase directory'), Gtk.FileChooserAction.SELECT_FOLDER)
phrase_dir.set_create_folders(True)
phrase_dir.set_current_folder(shared.config['phrases_dir'])
phrase_dir_label.set_mnemonic_widget(phrase_dir)
prefs_grid.attach(phrase_dir, 4, 0, 1, 1)
indicator_theme_label = Gtk.Label.new_with_mnemonic(
_('Prefer light _indicator icon theme'))
prefs_grid.attach(indicator_theme_label, 0, 1, 2, 1)
indicator_theme = Gtk.Switch()
indicator_theme.set_active(shared.config['indicator_theme_light'])
indicator_theme_label.set_mnemonic_widget(indicator_theme)
hbox = Gtk.Box(Gtk.Orientation.HORIZONTAL, 5)
hbox.pack_start(indicator_theme, False, False, 0)
prefs_grid.attach(hbox, 4, 1, 1, 1)
folder_warning_label = Gtk.Label.new_with_mnemonic(
_('_Warn when deleting a folder'))
folder_warning_label.set_xalign(0)
prefs_grid.attach(folder_warning_label, 0, 2, 2, 1)
folder_warning_switch = Gtk.Switch()
folder_warning_switch.set_active(shared.config['warn_folder_delete'])
folder_warning_label.set_mnemonic_widget(folder_warning_switch)
hbox = Gtk.Box(Gtk.Orientation.HORIZONTAL, 5)
hbox.pack_start(folder_warning_switch, False, False, 0)
prefs_grid.attach(hbox, 4, 2, 1, 1)
pause_expansion_label = Gtk.Label.new_with_mnemonic(
_('_Pause expansion'))
pause_expansion_label.set_xalign(0)
prefs_grid.attach(pause_expansion_label, 0, 5, 1, 1)
self.pause_expansion = Gtk.Entry()
self.pause_expansion.set_editable(False)
key, mod_strings = shared.config['key_pause']
key = self.get_key(key)
if key:
self.pause_expansion.set_text(''.join(mod_strings) + key)
else:
self.pause_expansion.set_text('')
prefs_grid.attach(self.pause_expansion, 2, 5, 2, 1)
pause_expansion_set = Gtk.Button(_('Set'))
pause_expansion_label.set_mnemonic_widget(pause_expansion_set)
prefs_grid.attach(pause_expansion_set, 4, 5, 1, 1)
show_manager_label = Gtk.Label.new_with_mnemonic(_('_Show manager'))
show_manager_label.set_xalign(0)
prefs_grid.attach(show_manager_label, 0, 6, 1, 1)
self.show_manager = Gtk.Entry()
self.show_manager.set_editable(False)
key, mod_strings = shared.config['key_show_manager']
key = self.get_key(key)
if key:
self.show_manager.set_text(''.join(mod_strings) + key)
else:
self.show_manager.set_text('')
prefs_grid.attach(self.show_manager, 2, 6, 2, 1)
show_manager_set = Gtk.Button(_('Set'))
show_manager_label.set_mnemonic_widget(show_manager_set)
prefs_grid.attach(show_manager_set, 4, 6, 1, 1)
# Packing
scrollable_treelist.add(self.treeview)
treeview_frame.add(scrollable_treelist)
left_box.pack_start(treeview_frame, True, True, 0)
toolbar_frame = Gtk.Frame(shadow_type=Gtk.ShadowType.IN)
toolbar_frame.add(toolbar)
left_box.pack_start(toolbar_frame, False, True, 0)
paned.add1(left_box)
editor_frame.add(self.right_grid)
paned.add2(editor_frame)
# Signals
# Manager
text_renderer.connect('edited', self.row_edited)
self.treeview.connect('drag-data-get', self.drag_data_get)
self.treeview.connect('drag-data-received', self.drag_data_received)
self.treeview.connect('button-press-event', self.treeview_clicked)
add_phrase.connect('activate', self.new_phrase)
add_folder.connect('activate', self.new_folder)
remove_button.connect('clicked', self.remove_item)
self.selection.connect('changed', self.selection_changed)
# Editor
self.string.connect('key-press-event', self.string_handle_keypress)
text_wrap.connect('toggled', self.wrap_text)
set_filter_class.connect('toggled', self.set_window_class)
set_filter_title.connect('toggled', self.set_window_title)
save_phrase.connect('clicked', self.save_phrase)
# Preferences
phrase_dir.connect('file-set', self.set_phrase_dir)
indicator_theme.connect('notify::active', self.set_indicator_theme)
folder_warning_switch.connect('notify::active',
self.folder_warning_toggle)
pause_expansion_set.connect('clicked', self.get_pause_expansion)
show_manager_set.connect('clicked', self.get_show_manager)
# Avoid deleting window, causes segfault
self.connect('delete-event', self.close_window)
def __init__(self, **options):
name = _("Workspaces")
Gtk.ListBox.__init__(self)
Tweak.__init__(
self,
_("Display Handling"),
_("Workspaces span displays"),
loaded=_shell_loaded,
)
_GSettingsTweak.__init__(self,
name,
"org.gnome.mutter",
"workspaces-only-on-primary",
loaded=_shell_loaded)
self.set_selection_mode(Gtk.SelectionMode.NONE)
# Needs other page elements to get margins too
# self.props.margin_left = 50
# self.props.margin_right = 50
row = Gtk.ListBoxRow()
hbox = Gtk.Box()
hbox.props.margin = 10
row.add(hbox)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
lbl = Gtk.Label(_("Workspaces on primary display only"), xalign=0)
lbl.props.xalign = 0.0
desc = _("Additional displays are treated as independent workspaces.")
lbl_desc = Gtk.Label()
lbl_desc.set_line_wrap(True)
lbl_desc.get_style_context().add_class("dim-label")
lbl_desc.set_markup("<span size='small'>" +
GLib.markup_escape_text(desc) + "</span>")
self.check1 = Gtk.Image.new_from_icon_name("object-select-symbolic",
Gtk.IconSize.SMALL_TOOLBAR)
self.check1.set_no_show_all(True)
self.check1.set_visible(self.settings[self.key_name])
vbox.pack_start(lbl, False, False, 0)
vbox.pack_start(lbl_desc, False, False, 0)
hbox.pack_start(vbox, False, False, 0)
hbox.pack_end(self.check1, False, False, 0)
self.add(row)
row = Gtk.ListBoxRow()
hbox = Gtk.Box()
hbox.props.margin = 10
row.add(hbox)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
lbl = Gtk.Label(_("Workspaces span displays"), xalign=0)
lbl.props.xalign = 0.0
desc = _("The current workspace includes additional displays.")
lbl_desc = Gtk.Label()
lbl_desc.set_line_wrap(True)
lbl_desc.get_style_context().add_class("dim-label")
lbl_desc.set_markup("<span size='small'>" +
GLib.markup_escape_text(desc) + "</span>")
self.check2 = Gtk.Image.new_from_icon_name("object-select-symbolic",
Gtk.IconSize.SMALL_TOOLBAR)
self.check2.set_no_show_all(True)
self.check2.set_visible(not self.settings[self.key_name])
vbox.pack_start(lbl, False, False, 0)
vbox.pack_start(lbl_desc, False, False, 0)
hbox.pack_start(vbox, False, False, 0)
hbox.pack_end(self.check2, False, False, 0)
self.add(row)
self.connect('row-activated', self.on_row_clicked)
def do_load(self, parentWidget, enclosures):
if parentWidget == None:
print("ERROR: Could not find media player insertion widget!")
# Test whether Media Player widget already exists
childList = Gtk.Container.get_children(parentWidget)
if len(childList) == 1:
# We need to add a media player...
vbox = Gtk.Box(Gtk.Orientation.HORIZONTAL, 0)
vbox.props.margin = GMARGIN
vbox.props.spacing = GMARGIN
Gtk.Box.pack_start(parentWidget, vbox, True, True, 0)
image = Gtk.Image()
image.set_from_icon_name("media-skip-backward",
Gtk.IconSize.BUTTON)
self.prevButton = Gtk.Button.new()
self.prevButton.add(image)
self.prevButton.connect("clicked", self.prev)
self.prevButton.set_direction(Gtk.TextDirection.LTR)
Gtk.Box.pack_start(vbox, self.prevButton, False, False, 0)
self.playButtonImage = Gtk.Image()
self.playButtonImage.set_from_icon_name("media-playback-start",
Gtk.IconSize.BUTTON)
self.playButton = Gtk.Button.new()
self.playButton.add(self.playButtonImage)
self.playButton.connect("clicked", self.playToggled)
self.playButton.set_direction(Gtk.TextDirection.LTR)
Gtk.Box.pack_start(vbox, self.playButton, False, False, 0)
image = Gtk.Image()
image.set_from_icon_name("media-skip-forward", Gtk.IconSize.BUTTON)
self.nextButton = Gtk.Button.new()
self.nextButton.add(image)
self.nextButton.connect("clicked", self.next)
self.nextButton.set_direction(Gtk.TextDirection.LTR)
Gtk.Box.pack_start(vbox, self.nextButton, False, False, 0)
self.slider = Gtk.Scale(orientation=Gtk.Orientation.HORIZONTAL)
self.slider.set_draw_value(False)
self.slider.set_range(0, 100)
self.slider.set_increments(1, 10)
self.slider.connect("change-value", self.on_slider_change_value)
self.slider.connect("button-press-event",
self.on_slider_button_press)
self.slider.connect("button-release-event",
self.on_slider_button_release)
self.slider.set_direction(Gtk.TextDirection.LTR)
Gtk.Box.pack_start(vbox, self.slider, True, True, 0)
self.label = Gtk.Label()
self.set_label(0)
Gtk.Box.pack_start(vbox, self.label, False, False, 0)
Gtk.Widget.show_all(vbox)
self.enclosures = enclosures
self.pos = 0
self.player.set_state(Gst.State.NULL) # FIXME: Make this configurable?
self.on_finished(self.player)
from gi.repository import Gtk
def calendar_change(checkbutton, option):
display_options = []
if checkbutton.get_active():
display_options.append(option)
calendar.set_display_options(Gtk.CalendarDisplayOptions.SHOW_HEADING)
window = Gtk.Window()
window.connect("destroy", lambda q: Gtk.main_quit())
hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=2)
window.add(hbox)
calendar = Gtk.Calendar()
hbox.pack_start(calendar, True, True, 0)
vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
hbox.pack_start(vbox, False, False, 0)
checkbutton_heading = Gtk.CheckButton(label="Show heading")
checkbutton_heading.connect("toggled", calendar_change,
Gtk.CalendarDisplayOptions.SHOW_HEADING)
vbox.pack_start(checkbutton_heading, False, False, 0)
checkbutton_daynames = Gtk.CheckButton(label="Show day names")
checkbutton_daynames.connect("toggled", calendar_change,
def show_drivers(self):
self.driver_changes = []
self.orig_selection = {}
# HACK: the case where the selection is actually "Do not use"; is a little
# tricky to implement because you can't check for whether a package is
# installed or any such thing. So let's keep a list of all the
# "Do not use" radios, set those active first, then iterate through
# orig_selection when doing a Reset.
self.no_drv = []
self.nonfree_drivers = 0
self.ui_building = True
self.dynamic_device_status = {}
drivers_found = False
if len(self.devices) != 0:
for device in sorted(self.devices.keys()):
(overall_status, icon,
drivers) = self.gather_device_data(self.devices[device])
is_cpu = False
if "intel-microcode" in self.devices[device][
'drivers'] or "amd64-microcode" in self.devices[
device]['drivers']:
is_cpu = True
overall_status = _("Processor microcode")
brand_icon = Gtk.Image()
brand_icon.set_valign(Gtk.Align.START)
brand_icon.set_halign(Gtk.Align.CENTER)
brand_icon.set_from_pixbuf(
self.get_device_icon(self.devices[device]))
driver_status = Gtk.Image()
driver_status.set_valign(Gtk.Align.START)
driver_status.set_halign(Gtk.Align.CENTER)
driver_status.set_from_icon_name(icon, Gtk.IconSize.MENU)
device_box = Gtk.Box(spacing=6,
orientation=Gtk.Orientation.HORIZONTAL)
device_box.pack_start(brand_icon, False, False, 6)
device_detail = Gtk.Box(spacing=6,
orientation=Gtk.Orientation.VERTICAL)
device_box.pack_start(device_detail, True, True, 0)
model_name = self.devices[device].get('model', None)
vendor_name = self.devices[device].get('vendor', None)
if is_cpu:
device_name = self.get_cpu_name()
elif vendor_name is None and model_name is None:
device_name = _("Unknown")
elif vendor_name is None:
device_name = model_name
elif model_name is None:
device_name = vendor_name
else:
device_name = "%s: %s" % (vendor_name, model_name)
if "vmware" in device_name.lower(
) or "virtualbox" in device_name.lower():
print("Ignoring device %s" % device_name)
continue
if drivers["manually_installed"]:
print("Ignoring device: %s (manually_installed)" %
device_name)
continue
drivers_found = True
widget = Gtk.Label(label=device_name)
widget.set_halign(Gtk.Align.START)
device_detail.pack_start(widget, True, False, 0)
widget = Gtk.Label(
label="<small>{}</small>".format(overall_status))
widget.set_halign(Gtk.Align.START)
widget.set_use_markup(True)
device_detail.pack_start(widget, True, False, 0)
self.dynamic_device_status[device] = (driver_status, widget)
option_group = None
# define the order of introspection
for section in ('recommended', 'alternative',
'manually_installed', 'no_driver'):
for driver in sorted(drivers[section],
key=lambda x: self.sort_string(
drivers[section], x)):
if str(driver).startswith("nvidia-driver") and str(
driver).endswith("-server"):
print("Ignoring server NVIDIA driver: ", driver)
continue
radio_button = Gtk.RadioButton.new(None)
label = Gtk.Label()
label.set_markup(
drivers[section][driver]['description'])
radio_button.add(label)
if option_group:
radio_button.join_group(option_group)
else:
option_group = radio_button
device_detail.pack_start(radio_button, True, False, 0)
radio_button.set_active(
drivers[section][driver]['selected'])
if section == 'no_driver':
self.no_drv.append(radio_button)
if is_cpu:
label.set_markup(
_("Do not update the CPU microcode"))
if section in ('manually_install', 'no_driver') or (
'builtin' in drivers[section][driver]
and drivers[section][driver]['builtin']):
radio_button.connect(
"toggled", self.on_driver_selection_changed,
device)
else:
radio_button.connect(
"toggled", self.on_driver_selection_changed,
device, driver)
if drivers[
'manually_installed'] and section != 'manually_installed' and "firmware" not in str(
driver):
radio_button.set_sensitive(False)
self.box_driver_detail.pack_start(device_box, False, False, 6)
self.stack.set_visible_child_name("drivers_page")
if not drivers_found:
self.stack.set_visible_child_name("no_drivers_page")
print("Your computer does not need any additional drivers")
self.spinner.stop()
self.ui_building = False
self.box_driver_detail.show_all()
self.set_driver_action_status()
def __init__(self, uuid):
Budgie.Applet.__init__(self)
self.red_time = 60
self.yellow_time = 300
# --- panelgrid ---
self.panelgrid = Gtk.Grid()
# space section. make it depend on panel size?
spacer_img = Gtk.Image.new_from_file(
os.path.join(path, "cr_spacer.png"))
self.panelgrid.attach(spacer_img, 0, 0, 2, 1)
self.panelgrid.set_row_spacing(10) # <-- make depend on panel height
# icons
grey = os.path.join(path, "cr_grey.png")
green = os.path.join(path, "cr_green.png")
yellow = os.path.join(path, "cr_yellow.png")
red = os.path.join(path, "cr_red.png")
# pixbuf
self.iconset = [
GdkPixbuf.Pixbuf.new_from_file(ic)
for ic in [red, yellow, green, grey]
]
# initial icon
self.seticon = Gtk.Image.new_from_pixbuf(self.iconset[0])
self.panelgrid.attach(self.seticon, 0, 1, 1, 1)
# menu label
self.timer = Gtk.Label(" 00:00:00")
self.panelgrid.attach(self.timer, 1, 1, 1, 1)
# --- menugrid ---
self.menugrid = Gtk.Grid()
self.menugrid.set_column_spacing(15)
self.menugrid.set_row_spacing(5)
# left space
self.menugrid.attach(Gtk.Label(""), 1, 0, 1, 1)
# hrs
self.hrs_label = Gtk.Label("Hours: ", xalign=0)
self.menugrid.attach(self.hrs_label, 1, 2, 1, 1)
adjustment = Gtk.Adjustment(0, 0, 23, 1)
self.hoursbutton = Gtk.SpinButton()
self.hoursbutton.set_adjustment(adjustment)
self.menugrid.attach(self.hoursbutton, 2, 2, 1, 1)
# mins
self.mins_label = Gtk.Label("Minutes: ", xalign=0)
self.menugrid.attach(self.mins_label, 1, 3, 1, 1)
adjustment = Gtk.Adjustment(0, 0, 59, 1)
self.minsbutton = Gtk.SpinButton()
self.minsbutton.set_adjustment(adjustment)
self.menugrid.attach(self.minsbutton, 2, 3, 1, 1)
# secs
self.secs_label = Gtk.Label("Seconds: ", xalign=0)
self.menugrid.attach(self.secs_label, 1, 4, 1, 1)
adjustment = Gtk.Adjustment(0, 0, 59, 1)
self.secsbutton = Gtk.SpinButton()
self.secsbutton.set_adjustment(adjustment)
self.menugrid.attach(self.secsbutton, 2, 4, 1, 1)
for sp in [self.hoursbutton, self.minsbutton, self.secsbutton]:
sp.set_numeric(True)
sp.set_update_policy(True)
# prevent pause
self.sleep = Gtk.CheckButton("Prevent pausing countdown")
self.menugrid.attach(self.sleep, 1, 6, 2, 1)
sep = Gtk.Separator()
self.menugrid.attach(sep, 4, 1, 1, 8)
self.bbox = Gtk.Box()
self.menugrid.attach(self.bbox, 0, 10, 9, 2)
self.menugrid.attach(Gtk.Label(""), 1, 9, 1, 1)
# apply
self.applybutton = Gtk.Button("Run")
# set style start/stop
self.context_start = self.applybutton.get_style_context()
self.applybutton.set_size_request(80, 20)
self.bbox.pack_end(self.applybutton, False, False, 0)
self.applybutton.connect("clicked", self.handle_apply)
self.nf_bell = Gtk.CheckButton("Ring bell")
self.menugrid.attach(self.nf_bell, 5, 2, 1, 1)
self.nf_icon = Gtk.CheckButton("Flash icon")
self.menugrid.attach(self.nf_icon, 5, 3, 1, 1)
self.nf_message = Gtk.CheckButton("Display window")
self.menugrid.attach(self.nf_message, 5, 4, 1, 1)
self.runcomm = Gtk.CheckButton("Run command:")
self.menugrid.attach(self.runcomm, 5, 5, 1, 1)
self.command_entry = Gtk.Entry()
self.command_entry.connect("key-release-event", self.update_command)
self.menugrid.attach(self.command_entry, 5, 6, 1, 1)
# button, file, related variable-key
self.settingsdata = [
[self.nf_bell, "mute_ringbell", "ringbell"],
[self.nf_icon, "mute_flashicon", "flashicon"],
[self.nf_message, "mute_showwindow", "showwindow"],
[self.sleep, "mute_nosleep", "keeprun"],
[self.runcomm, "runcommand", "runcmd"],
]
self.vals = []
# fetch values for checkbuttons (except command: separate)
for item in self.settingsdata[:-1]:
val = True if self.get_setting(item) is False else False
subj = item[0]
item[0].set_active(val)
self.vals.append(val)
item[0].connect("toggled", self.manage_checkbox)
# fetch command if True, set checkbutton
command_set = self.settingsdata[-1]
commandval = self.get_setting(command_set, True)
try:
data = ast.literal_eval(commandval[1])
except TypeError:
self.runcomm.set_active(False)
self.command_entry.set_sensitive(False)
else:
self.runcmd = data[0]
self.command_entry.set_text(data[1])
self.runcomm.set_active(self.runcmd)
self.command_entry.set_sensitive(self.runcmd)
self.runcomm.connect("toggled", self.manage_checkbox)
self.runvars = {
"ringbell": self.vals[0],
"flashicon": self.vals[1],
"showwindow": self.vals[2],
"keeprun": self.vals[3],
"runcmd": self.runcomm.get_active(),
}
self.countdown, self.span = 0, 0
self.cancel = True
# panel
self.box = Gtk.EventBox()
self.box.add(self.panelgrid)
self.add(self.box)
# menu
self.popover = Budgie.Popover.new(self.box)
self.popover.add(self.menugrid)
self.popover.get_child().show_all()
self.box.show_all()
self.show_all()
self.box.connect("button-press-event", self.on_press)
GObject.threads_init()
# thread
self.update = Thread(target=self.run_countdown)
# daemonize the thread to make the indicator stopable
self.update.setDaemon(True)
self.update.start()
self.seticon.set_from_pixbuf(self.iconset[1])
def __init__(self):
Gtk.Window.__init__(self, title="Gtk+: iOS Backup - Read Manifest.db")
self.set_border_width(8)
self.set_default_size(1024, 768)
loader = GdkPixbuf.PixbufLoader()
loader.write(svg.encode())
loader.close()
pixbuf = loader.get_pixbuf()
self.set_icon(pixbuf)
# vertical box to hold the widgets
self.vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=8)
# a toolbar created in the method create_toolbar (see below)
toolbar = self.create_toolbar()
# with extra horizontal space
toolbar.set_hexpand(True)
# show the toolbar
toolbar.show()
# add the toolbar to the vertical box
self.vbox.pack_start(toolbar, False, True, 0)
label = Gtk.Label()
label.set_markup(
"<span face=\"mono\" weight=\"bold\">iOSBackup </span>")
self.label_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL,
spacing=8)
self.label_box.pack_start(label, True, True, 0)
self.vbox.pack_start(self.label_box, True, True, 0)
# some needed stuff
self.first_run = True
self.backup_path = str()
# records of 'naked' domains
self.naked_domains = []
self.domain_items = []
self.clipboard = Gtk.Clipboard.get(Gdk.SELECTION_CLIPBOARD)
self.dialog_label = Gtk.Label()
self.dialog_label.set_justify(Gtk.Justification.LEFT)
# create combobox with entry
listmodel = Gtk.ListStore(str, int)
self.combo = Gtk.ComboBox.new_with_model_and_entry(model=listmodel)
# cellrenderers to render the data
renderer_text = Gtk.CellRendererText()
self.combo.pack_start(renderer_text, True)
self.combo.add_attribute(renderer_text, "text", 1)
# active row at the beginning is undefined
self.combo.set_active(-1)
self.combo.connect("changed", self.on_combo_changed)
self.combo.set_entry_text_column(0)
entry = self.combo.get_child()
# handles Enter pressed
entry.connect("activate", self.on_entry_activate)
entry.set_placeholder_text(_("Please select domain to display"))
# button extract domain
domain_button = Gtk.Button.new_with_label(_("Extract Domain..."))
domain_button.set_tooltip_text(_("Extract domain content"))
# label is shown
domain_button.show()
# set the name of the action associated with the button.
domain_button.connect("clicked", self.on_extract_domain_clicked)
# combination of combobox and button
self.domain_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL,
spacing=8)
self.domain_box.pack_start(self.combo, True, True, 0)
self.domain_box.pack_end(domain_button, False, True, 0)
# create scrolled_window for treeview under the combobox
self.scrolled_window = Gtk.ScrolledWindow()
self.scrolled_window.set_size_request(-1, 384)
self.scrolled_window.set_border_width(0)
# there is always the scrollbar (otherwise: ALWAYS NEVER)
self.scrolled_window.set_policy(\
Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
# model creation for the treeview
treemodel = Gtk.ListStore(str, str, 'glong')
# create TreeView
self.treeview = Gtk.TreeView(model=treemodel)
# treeview column headers
rendererText = Gtk.CellRendererText()
treeview_cols = ['fileID', 'relativePath', 'flags']
for num, name in enumerate(treeview_cols):
column_name = Gtk.TreeViewColumn(name, rendererText, text=num)
self.treeview.append_column(column_name)
# make all the columns reorderable and resizable
# this is not necessary, but it's nice to show the feature
for column in self.treeview.get_columns():
column.set_reorderable(True)
column.set_resizable(True)
column.set_alignment(0.7)
# Connect signal handler
self.treeview.connect("row_activated", self.on_row_activated)
'''
# create the Text Buffer
text_buffer = Gtk.TextBuffer.new()
text_view = Gtk.TextView()
text_view.set_buffer(text_buffer);
# add the TextView, inside a ScrolledWindow under the tableview
text_window = Gtk.ScrolledWindow()
text_window.set_size_request(-1, 60)
text_window.add(text_view);
# only show the scrollbars when they are necessary:
text_window.set_policy(\
Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) '''
self.status_frame = Gtk.Frame()
self.status_bar = Gtk.Statusbar()
self.status_frame.add(self.status_bar)
self.vbox.pack_end(self.status_frame, False, True, 0)
self.context_id = self.status_bar.push(
0, _("Choose a Database, click Open"))
self.add(self.vbox)
self.show_all()
def __init__(self):
Gtk.Window.__init__(self, title="Registrar un Usuario")
self.set_border_width(10)
self.bbdd = dbapi2.connect("TiendaInformatica.db")
self.cursor = self.bbdd.cursor()
cajaCrearClientes = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL,
spacing=6)
grid = Gtk.Grid()
grid.set_row_spacing(20)
grid.set_column_spacing(10)
"""
Etiquetas con los nombres de los datos que queremos insertar
"""
lblNombre = Gtk.Label("Nombre:")
lblApellido = Gtk.Label("Apellidos:")
lblDni = Gtk.Label("DNI:")
lblDireccion = Gtk.Label("Direccion:")
lblNumeroCliente = Gtk.Label("Numero de cliente:")
lblSexo = Gtk.Label("Sexo:")
"""
Componentes entry para introducir los datos.
ComboBox para el sexo.
"""
self.txtNombre = Gtk.Entry()
self.txtApellido = Gtk.Entry()
self.txtDni = Gtk.Entry()
self.txtDireccion = Gtk.Entry()
self.txtNumeroCliente = Gtk.Entry()
self.cmbSexo = Gtk.ComboBoxText()
self.cmbSexo.insert(0, '0', "M")
self.cmbSexo.insert(1, '1', "H")
btnInsertar = Gtk.Button("Insertar Cliente")
btnInsertar.connect("clicked", self.on_btnInsertar_clicked)
btnVolver = Gtk.Button("Volver")
btnVolver.connect("clicked", self.on_btnVolver_clicked)
"""
Con grid attach lo que hacemos es establecer el orden en los que se colocan los componentes en el grid
"""
grid.attach(lblNombre, 0, 0, 1, 1)
grid.attach(self.txtNombre, 1, 0, 1, 1)
grid.attach_next_to(lblApellido, self.txtNombre,
Gtk.PositionType.RIGHT, 1, 1)
grid.attach_next_to(self.txtApellido, lblApellido,
Gtk.PositionType.RIGHT, 1, 1)
grid.attach_next_to(lblDni, lblNombre, Gtk.PositionType.BOTTOM, 1, 1)
grid.attach_next_to(self.txtDni, lblDni, Gtk.PositionType.RIGHT, 1, 1)
grid.attach_next_to(lblDireccion, self.txtDni, Gtk.PositionType.RIGHT,
1, 1)
grid.attach_next_to(self.txtDireccion, lblDireccion,
Gtk.PositionType.RIGHT, 1, 1)
grid.attach_next_to(lblNumeroCliente, lblDni, Gtk.PositionType.BOTTOM,
1, 1)
grid.attach_next_to(self.txtNumeroCliente, lblNumeroCliente,
Gtk.PositionType.RIGHT, 1, 1)
grid.attach_next_to(lblSexo, self.txtNumeroCliente,
Gtk.PositionType.RIGHT, 1, 1)
grid.attach_next_to(self.cmbSexo, lblSexo, Gtk.PositionType.RIGHT, 1,
1)
grid.attach_next_to(btnInsertar, self.lblSexo, Gtk.PositionType.BOTTOM,
1, 1)
grid.attach_next_to(btnVolver, btnInsertar, Gtk.PositionType.RIGHT, 1,
1)
cajaCrearClientes.add(grid)
self.add(cajaCrearClientes)
self.show_all()
def __init__(self, parent, collection_type, spices, window):
super(ManageSpicesPage, self).__init__()
self.expand = True
self.set_spacing(0)
self.set_margin_top(5)
self.parent = parent
self.collection_type = collection_type
self.spices = spices
self.has_filter = False
self.window = window
self.extension_rows = []
self.top_box = Gtk.Box()
self.pack_start(self.top_box, False, False, 10)
self.search_entry = Gtk.Entry()
self.search_entry.set_icon_from_icon_name(
Gtk.EntryIconPosition.PRIMARY, 'edit-find-symbolic')
self.search_entry.set_placeholder_text(_("Search"))
self.search_entry.connect('changed', self.on_entry_refilter)
self.top_box.pack_end(self.search_entry, False, False, 4)
frame = Gtk.Frame()
frame.set_shadow_type(Gtk.ShadowType.IN)
frame_style = frame.get_style_context()
frame_style.add_class('view')
self.pack_start(frame, True, True, 0)
main_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
frame.add(main_box)
scw = Gtk.ScrolledWindow()
scw.expand = True
scw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
scw.set_shadow_type(Gtk.ShadowType.NONE)
main_box.pack_start(scw, True, True, 0)
self.box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
scw.add(self.box)
self.infobar_holder = Gtk.Frame(shadow_type=Gtk.ShadowType.NONE)
self.box.add(self.infobar_holder)
def sort_rows(row1, row2):
if row1.writable == row2.writable:
name1 = row1.name.lower()
name2 = row2.name.lower()
if name1 < name2:
return -1
elif name2 < name1:
return 1
else:
return 0
elif row1.writable:
return -1
else:
return 1
self.list_box = Gtk.ListBox()
self.list_box.set_selection_mode(Gtk.SelectionMode.SINGLE)
self.list_box.set_sort_func(sort_rows)
self.list_box.set_header_func(list_header_func, None)
self.list_box.connect('row-selected', self.update_button_states)
self.box.add(self.list_box)
button_toolbar = Gtk.Toolbar.new()
Gtk.StyleContext.add_class(
Gtk.Widget.get_style_context(button_toolbar), 'inline-toolbar')
self.add(button_toolbar)
button_holder = Gtk.ToolItem()
button_holder.set_expand(True)
button_toolbar.add(button_holder)
box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL)
box.set_halign(Gtk.Align.CENTER)
button_holder.add(box)
# buttons
self.instance_button = Gtk.Button.new_from_icon_name(
"list-add-symbolic", Gtk.IconSize.MENU)
self.instance_button.set_size_request(50, -1)
self.instance_button.set_tooltip_text(self.instance_button_text)
self.instance_button.connect('clicked', self.add_instance)
box.add(self.instance_button)
self.instance_button.set_sensitive(False)
self.remove_button = Gtk.Button.new_from_icon_name(
"list-remove-symbolic", Gtk.IconSize.MENU)
self.remove_button.set_size_request(50, -1)
self.remove_button.set_tooltip_text(self.remove_button_text)
self.remove_button.connect('clicked', self.remove_all_instances)
box.add(self.remove_button)
self.remove_button.set_sensitive(False)
self.uninstall_button = Gtk.Button.new_from_icon_name(
"edit-delete-symbolic", Gtk.IconSize.MENU)
self.uninstall_button.set_size_request(50, -1)
self.uninstall_button.set_tooltip_text(self.uninstall_button_text)
self.uninstall_button.connect('clicked', self.uninstall_extension)
box.add(self.uninstall_button)
self.uninstall_button.set_sensitive(False)
self.restore_button = Gtk.Button.new_from_icon_name(
"edit-undo-symbolic", Gtk.IconSize.MENU)
self.restore_button.set_size_request(50, -1)
self.restore_button.set_tooltip_text(self.restore_button_text)
self.restore_button.connect('clicked', self.restore_to_default)
box.add(self.restore_button)
self.about_button = Gtk.Button.new_from_icon_name(
"help-about-symbolic", Gtk.IconSize.MENU)
self.about_button.set_size_request(50, -1)
self.about_button.set_tooltip_text(_("About"))
self.about_button.connect('clicked', self.about)
box.add(self.about_button)
self.about_button.set_sensitive(False)
# progress bar
self.progress_bar = self.spices.get_progressbar()
pb_container = Gtk.Box()
pb_container.set_margin_top(20)
pb_container.pack_start(self.progress_bar, True, True, 0)
self.pack_end(pb_container, False, False, 0)
self.load_extensions()
self.connect('map', self.on_page_map)
self.spices.connect('installed-changed', self.load_extensions)
self.spices.connect('status-changed', self.update_status)
