def show_popup(self): if not self._parent_click_watcher: self._parent_click_watcher = self.get_toplevel().connect( "button-press-event", self._on_focus_out_event) # will be going either 24 hours or from start time to start time + 12 hours start_time = dt.datetime.combine( dt.date.today(), self.start_time) # we will be adding things i_time = start_time # we will be adding things if self.start_time: end_time = i_time + dt.timedelta(hours=12) i_time += dt.timedelta(minutes=15) else: end_time = i_time + dt.timedelta(days=1) focus_time = dt.datetime.combine(dt.date.today(), self.figure_time(self.get_text())) hours = gtk.ListStore(gobject.TYPE_STRING) i, focus_row = 0, None while i_time < end_time: row_text = self._format_time(i_time) if self.start_time: delta = (i_time - start_time).seconds / 60 delta_text = format_duration(delta) row_text += " (%s)" % delta_text hours.append([row_text]) if focus_time and i_time <= focus_time <= i_time + \ dt.timedelta(minutes = 30): focus_row = i if self.start_time: i_time += dt.timedelta(minutes=15) else: i_time += dt.timedelta(minutes=30) i += 1 self.time_tree.set_model(hours) #focus on row if focus_row != None: selection = self.time_tree.get_selection() selection.select_path(focus_row) self.time_tree.scroll_to_cell(focus_row, use_align=True, row_align=0.4) #move popup under the widget alloc = self.get_allocation() w = alloc.width if self.start_time: w = w * 2 self.time_tree.set_size_request(w, alloc.height * 5) window = self.get_parent_window() x, y = window.get_origin() self.popup.move(x + alloc.x, y + alloc.y + alloc.height) self.popup.show_all()
def __init__(self, lc): self.lc = lc self.stdout_maxlines = 2000 self.config_filename = None self.next_cmds_update_time = 0 # create sheriff and subscribe to events self.sheriff = sheriff.Sheriff(self.lc) self.sheriff.connect("command-added", self._on_sheriff_command_added) self.sheriff.connect("command-removed", self._on_sheriff_command_removed) self.sheriff.connect("command-status-changed", self._on_sheriff_command_status_changed) self.sheriff.connect("command-group-changed", self._on_sheriff_command_group_changed) gobject.timeout_add(1000, self._maybe_send_orders) self.group_row_references = {} self.lc.subscribe("PMD_PRINTF", self.on_pmsd_printf) self.lc.subscribe("PMD_ORDERS", self.on_pmsd_orders) # regexes self.warn_regex = re.compile("warning", re.IGNORECASE) self.summary_regex = re.compile("summary", re.IGNORECASE) # setup GUI self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.set_default_size(800, 600) self.window.connect("delete-event", gtk.main_quit) self.window.connect("destroy-event", gtk.main_quit) vbox = gtk.VBox() self.window.add(vbox) # keyboard accelerators. This probably isn't the right way to do it... self.accel_group = gtk.AccelGroup() self.accel_group.connect_group(ord("n"), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, lambda *a: None) self.accel_group.connect_group(ord("s"), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, lambda *a: None) self.accel_group.connect_group(ord("t"), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, lambda *a: None) self.accel_group.connect_group(ord("e"), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, lambda *a: None) self.accel_group.connect_group(ord("q"), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, gtk.main_quit) self.accel_group.connect_group(ord("o"), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, lambda *a: None) self.accel_group.connect_group( ord("a"), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, lambda *a: self.cmds_tv.get_selection().select_all()) self.accel_group.connect_group( ord("d"), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE, lambda *a: self.cmds_tv.get_selection().unselect_all()) # self.accel_group.connect_group (ord("a"), gtk.gdk.CONTROL_MASK, # gtk.ACCEL_VISIBLE, self._do_save_config_dialog) self.accel_group.connect_group(gtk.gdk.keyval_from_name("Delete"), 0, gtk.ACCEL_VISIBLE, self._remove_selected_commands) self.window.add_accel_group(self.accel_group) # setup the menu bar menu_bar = gtk.MenuBar() vbox.pack_start(menu_bar, False, False, 0) file_mi = gtk.MenuItem("_File") options_mi = gtk.MenuItem("_Options") commands_mi = gtk.MenuItem("_Commands") view_mi = gtk.MenuItem("_View") # file menu file_menu = gtk.Menu() file_mi.set_submenu(file_menu) self.load_cfg_mi = gtk.ImageMenuItem(gtk.STOCK_OPEN) self.load_cfg_mi.add_accelerator("activate", self.accel_group, ord("o"), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) self.save_cfg_mi = gtk.ImageMenuItem(gtk.STOCK_SAVE_AS) quit_mi = gtk.ImageMenuItem(gtk.STOCK_QUIT) quit_mi.add_accelerator("activate", self.accel_group, ord("q"), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) file_menu.append(self.load_cfg_mi) file_menu.append(self.save_cfg_mi) file_menu.append(quit_mi) self.load_cfg_mi.connect("activate", self._do_load_config_dialog) self.save_cfg_mi.connect("activate", self._do_save_config_dialog) quit_mi.connect("activate", gtk.main_quit) # commands menu commands_menu = gtk.Menu() commands_mi.set_submenu(commands_menu) self.start_cmd_mi = gtk.MenuItem("_Start") self.start_cmd_mi.add_accelerator("activate", self.accel_group, ord("s"), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) self.start_cmd_mi.connect("activate", self._start_selected_commands) self.start_cmd_mi.set_sensitive(False) commands_menu.append(self.start_cmd_mi) self.stop_cmd_mi = gtk.MenuItem("S_top") self.stop_cmd_mi.add_accelerator("activate", self.accel_group, ord("t"), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) self.stop_cmd_mi.connect("activate", self._stop_selected_commands) self.stop_cmd_mi.set_sensitive(False) commands_menu.append(self.stop_cmd_mi) self.restart_cmd_mi = gtk.MenuItem("R_estart") self.restart_cmd_mi.add_accelerator("activate", self.accel_group, ord("e"), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) self.restart_cmd_mi.connect("activate", self._restart_selected_commands) self.restart_cmd_mi.set_sensitive(False) commands_menu.append(self.restart_cmd_mi) self.remove_cmd_mi = gtk.MenuItem("_Remove") self.remove_cmd_mi.add_accelerator("activate", self.accel_group, gtk.gdk.keyval_from_name("Delete"), 0, gtk.ACCEL_VISIBLE) self.remove_cmd_mi.connect("activate", self._remove_selected_commands) self.remove_cmd_mi.set_sensitive(False) commands_menu.append(self.remove_cmd_mi) commands_menu.append(gtk.SeparatorMenuItem()) self.new_cmd_mi = gtk.MenuItem("_New command") self.new_cmd_mi.add_accelerator("activate", self.accel_group, ord("n"), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) self.new_cmd_mi.connect("activate", self._do_add_command_dialog) commands_menu.append(self.new_cmd_mi) # options menu options_menu = gtk.Menu() options_mi.set_submenu(options_menu) self.is_observer_cmi = gtk.CheckMenuItem("_Observer") self.is_observer_cmi.connect("activate", self.on_observer_mi_activate) options_menu.append(self.is_observer_cmi) # view menu view_menu = gtk.Menu() view_mi.set_submenu(view_menu) menu_bar.append(file_mi) menu_bar.append(options_mi) menu_bar.append(commands_mi) menu_bar.append(view_mi) vpane = gtk.VPaned() vbox.pack_start(vpane, True, True, 0) # setup the command treeview hpane = gtk.HPaned() vpane.add1(hpane) self.cmds_ts = gtk.TreeStore( gobject.TYPE_PYOBJECT, gobject.TYPE_STRING, # command name gobject.TYPE_STRING, # host name gobject.TYPE_STRING, # status actual gobject.TYPE_STRING, # CPU usage gobject.TYPE_INT, # memory vsize gobject.TYPE_STRING # summary ) self.cmds_tv = gtk.TreeView(self.cmds_ts) sw = gtk.ScrolledWindow() sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) hpane.pack1(sw, resize=True) sw.add(self.cmds_tv) cmds_tr = gtk.CellRendererText() cmds_tr.set_property("ellipsize", pango.ELLIPSIZE_END) plain_tr = gtk.CellRendererText() status_tr = gtk.CellRendererText() cols = [] col = gtk.TreeViewColumn("Command", cmds_tr, text=1) col.set_sort_column_id(1) cols.append(col) col = gtk.TreeViewColumn("Host", plain_tr, text=2) col.set_sort_column_id(2) cols.append(col) col = gtk.TreeViewColumn("Status", status_tr, text=3) col.set_sort_column_id(3) col.set_cell_data_func(status_tr, self._status_cell_data_func) cols.append(col) col = gtk.TreeViewColumn("CPU %", plain_tr, text=4) col.set_sort_column_id(4) cols.append(col) col = gtk.TreeViewColumn("Mem (kB)", plain_tr, text=5) col.set_sort_column_id(5) cols.append(col) col = gtk.TreeViewColumn("Summary", plain_tr, text=6) col.set_sort_column_id(6) col.set_expand(True) cols.append(col) for col in cols: col.set_resizable(True) self.cmds_tv.append_column(col) name = col.get_title() col_cmi = gtk.CheckMenuItem(name) col_cmi.set_active(True) col_cmi.connect("activate", lambda cmi, col: col.set_visible(cmi.get_active()), col) view_menu.append(col_cmi) cmds_sel = self.cmds_tv.get_selection() cmds_sel.set_mode(gtk.SELECTION_MULTIPLE) cmds_sel.connect("changed", self.on_cmds_selection_changed) gobject.timeout_add(1000, lambda *s: self._repopulate_cmds_tv() or True) self.cmds_tv.add_events (gtk.gdk.KEY_PRESS_MASK | \ gtk.gdk.BUTTON_PRESS | gtk.gdk._2BUTTON_PRESS) self.cmds_tv.connect("key-press-event", self._on_cmds_tv_key_press_event) self.cmds_tv.connect("button-press-event", self._on_cmds_tv_button_press_event) self.cmds_tv.connect("row-activated", self._on_cmds_tv_row_activated) # commands treeview context menu self.cmd_ctxt_menu = gtk.Menu() self.start_cmd_ctxt_mi = gtk.MenuItem("_Start") self.cmd_ctxt_menu.append(self.start_cmd_ctxt_mi) self.start_cmd_ctxt_mi.connect("activate", self._start_selected_commands) self.stop_cmd_ctxt_mi = gtk.MenuItem("_Stop") self.cmd_ctxt_menu.append(self.stop_cmd_ctxt_mi) self.stop_cmd_ctxt_mi.connect("activate", self._stop_selected_commands) self.restart_cmd_ctxt_mi = gtk.MenuItem("R_estart") self.cmd_ctxt_menu.append(self.restart_cmd_ctxt_mi) self.restart_cmd_ctxt_mi.connect("activate", self._restart_selected_commands) self.remove_cmd_ctxt_mi = gtk.MenuItem("_Remove") self.cmd_ctxt_menu.append(self.remove_cmd_ctxt_mi) self.remove_cmd_ctxt_mi.connect("activate", self._remove_selected_commands) self.change_deputy_ctxt_mi = gtk.MenuItem("_Change Host") self.cmd_ctxt_menu.append(self.change_deputy_ctxt_mi) self.change_deputy_ctxt_mi.show() self.cmd_ctxt_menu.append(gtk.SeparatorMenuItem()) self.new_cmd_ctxt_mi = gtk.MenuItem("_New Command") self.cmd_ctxt_menu.append(self.new_cmd_ctxt_mi) self.new_cmd_ctxt_mi.connect("activate", self._do_add_command_dialog) self.cmd_ctxt_menu.show_all() # # drag and drop command rows for grouping # dnd_targets = [ ('PROCMAN_CMD_ROW', # gtk.TARGET_SAME_APP | gtk.TARGET_SAME_WIDGET, 0) ] # self.cmds_tv.enable_model_drag_source (gtk.gdk.BUTTON1_MASK, # dnd_targets, gtk.gdk.ACTION_MOVE) # self.cmds_tv.enable_model_drag_dest (dnd_targets, # gtk.gdk.ACTION_MOVE) # hosts treeview self.hosts_ts = gtk.ListStore( gobject.TYPE_PYOBJECT, gobject.TYPE_STRING, # deputy name gobject.TYPE_STRING, # last update time gobject.TYPE_STRING, # load gobject.TYPE_STRING, # jitter gobject.TYPE_STRING, # skew ) self.hosts_tv = gtk.TreeView(self.hosts_ts) sw = gtk.ScrolledWindow() sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) hpane.pack2(sw, resize=False) sw.add(self.hosts_tv) col = gtk.TreeViewColumn("Host", plain_tr, text=1) col.set_sort_column_id(1) col.set_resizable(True) self.hosts_tv.append_column(col) col = gtk.TreeViewColumn("Last update", plain_tr, text=2) # col.set_sort_column_id (2) # XXX this triggers really weird bugs... col.set_resizable(True) self.hosts_tv.append_column(col) col = gtk.TreeViewColumn("Load", plain_tr, text=3) col.set_resizable(True) self.hosts_tv.append_column(col) col = gtk.TreeViewColumn("Clock Skew (ms)", plain_tr, text=4) col.set_resizable(True) self.hosts_tv.append_column(col) col = gtk.TreeViewColumn("Jitter (ms)", plain_tr, text=5) col.set_resizable(True) self.hosts_tv.append_column(col) gobject.timeout_add(1000, lambda *s: self._repopulate_hosts_tv() or True) hpane.set_position(500) # stdout textview self.stdout_textview = gtk.TextView() self.stdout_textview.set_property("editable", False) self.sheriff_tb = self.stdout_textview.get_buffer() sw = gtk.ScrolledWindow() sw.add(self.stdout_textview) vpane.add2(sw) vpane.set_position(300) stdout_adj = sw.get_vadjustment() stdout_adj.set_data("scrolled-to-end", 1) stdout_adj.connect("changed", self.on_adj_changed) stdout_adj.connect("value-changed", self.on_adj_value_changed) font_desc = pango.FontDescription("Monospace") self.stdout_textview.modify_font(font_desc) # stdout rate limit maintenance events gobject.timeout_add(500, self._stdout_rate_limit_upkeep) # status bar self.statusbar = gtk.Statusbar() vbox.pack_start(self.statusbar, False, False, 0) vbox.show_all() self.window.show()
def __init__(self, parent, application): # store parameters self._parent = parent self._provider = self._parent.get_provider() self._application = application self._extensions = [] self._path = self._parent.path # create and configure window self.window = gtk.Window(type=gtk.WINDOW_TOPLEVEL) self.window.set_title(_('Advanced rename')) self.window.set_default_size(640, 600) self.window.set_position(gtk.WIN_POS_CENTER_ON_PARENT) self.window.set_transient_for(application) self.window.set_border_width(7) self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_DIALOG) self.window.set_wmclass('Sunflower', 'Sunflower') self.window.connect('key-press-event', self._handle_key_press) # create interface vbox = gtk.VBox(False, 7) # create modifiers notebook self._extension_list = gtk.Notebook() self._extension_list.connect('page-reordered', self.__handle_reorder) # create list self._list = gtk.ListStore(str, str, str) self._names = gtk.TreeView(model=self._list) cell_icon = gtk.CellRendererPixbuf() cell_old_name = gtk.CellRendererText() cell_new_name = gtk.CellRendererText() col_old_name = gtk.TreeViewColumn(_('Old name')) col_old_name.set_expand(True) col_new_name = gtk.TreeViewColumn(_('New name')) col_new_name.set_expand(True) # pack renderer col_old_name.pack_start(cell_icon, False) col_old_name.pack_start(cell_old_name, True) col_new_name.pack_start(cell_new_name, True) # connect renderer attributes col_old_name.add_attribute(cell_icon, 'icon-name', Column.ICON) col_old_name.add_attribute(cell_old_name, 'text', Column.OLD_NAME) col_new_name.add_attribute(cell_new_name, 'text', Column.NEW_NAME) self._names.append_column(col_old_name) self._names.append_column(col_new_name) container = gtk.ScrolledWindow() container.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS) container.set_shadow_type(gtk.SHADOW_IN) # create location vbox_location = gtk.VBox(False, 0) label_location = gtk.Label(_('Items located in:')) label_location.set_alignment(0, 0.5) entry_location = gtk.Entry() entry_location.set_text(self._path) entry_location.set_editable(False) # create controls hbox = gtk.HBox(False, 5) button_close = gtk.Button(stock=gtk.STOCK_CLOSE) button_close.connect('clicked', lambda widget: self.window.destroy()) image_rename = gtk.Image() image_rename.set_from_icon_name('edit-find-replace', gtk.ICON_SIZE_BUTTON) button_rename = gtk.Button(label=_('Rename')) button_rename.set_image(image_rename) button_rename.connect('clicked', self.rename_files) # pack interface vbox_location.pack_start(label_location, False, False, 0) vbox_location.pack_start(entry_location, False, False, 0) hbox.pack_end(button_rename, False, False, 0) hbox.pack_end(button_close, False, False, 0) container.add(self._names) vbox.pack_start(self._extension_list, False, False, 0) vbox.pack_end(hbox, False, False, 0) vbox.pack_end(vbox_location, False, False, 0) vbox.pack_end(container, True, True, 0) self.window.add(vbox) # prepare UI self.__create_extensions() self.__populate_list() # update list initially self.update_list() # show all widgets self.window.show_all()
def __init__(self, model, axis, fields, attrs): self.glade = gtk.glade.XML(common.terp_path("openerp.glade"), 'widget_view_calendar', gettext.textdomain()) self.widget = self.glade.get_widget('widget_view_calendar') self._label_current = self.glade.get_widget('label_current') self._radio_month = self.glade.get_widget('radio_month') self._radio_week = self.glade.get_widget('radio_week') self._radio_day = self.glade.get_widget('radio_day') self._small_calendar = self.glade.get_widget('calendar_small') self._calendar_treeview = self.glade.get_widget('calendar_treeview') mode = attrs.get('mode', 'month') self.log = logging.getLogger('calender') self.fields = fields self.attrs = attrs self.axis = axis self.screen = None if mode == 'day': self._radio_day.set_active(True) elif mode == 'week': self._radio_week.set_active(True) else: self._radio_month.set_active(True) self.mode = mode self.cal_model = TinyCalModel() self.cal_view = Calendar.Calendar(self.cal_model, mode) self.cal_view.connect('event-clicked', self._on_event_clicked) self.cal_view.connect('do_month_back_forward', self._back_forward) self.cal_view.connect('day-selected', self._change_small) vbox = self.glade.get_widget('cal_vbox') vbox.pack_start(self.cal_view) vbox.show_all() self.process = False self.glade.signal_connect('on_but_forward_clicked', self._back_forward, 1) self.glade.signal_connect('on_but_back_clicked', self._back_forward, -1) self.glade.signal_connect('on_but_today_clicked', self._today) self.glade.signal_connect( 'on_calendar_small_day_selected_double_click', self._change_small, False, False) self.glade.signal_connect('on_button_day_clicked', self._change_view, 'day') self.glade.signal_connect('on_button_week_clicked', self._change_view, 'week') self.glade.signal_connect('on_button_month_clicked', self._change_view, 'month') self.date = datetime.today() self.string = attrs.get('string', '') self.date_start = attrs.get('date_start') self.date_delay = attrs.get('date_delay') self.date_stop = attrs.get('date_stop') self.color_field = attrs.get('color') self.color_field_custom = attrs.get('color_custom', 'color') self.color_model = False self.color_filters = {} self.colors = {} self.day_length = int(attrs.get('day_length', 8)) self.models = None self.models_record_group = None if self.color_field: self.color_model = gtk.ListStore(str, str, str, gobject.TYPE_BOOLEAN) self._calendar_treeview.set_model(self.color_model) self._calendar_treeview.get_selection().set_mode( gtk.SELECTION_NONE) for c in (self.TV_COL_ID, self.TV_COL_COLOR): column = gtk.TreeViewColumn(None, gtk.CellRendererText(), text=c) self._calendar_treeview.append_column(column) column.set_visible(False) # Row toogle renderer = gtk.CellRendererToggle() renderer.set_property('activatable', True) renderer.connect('toggled', self._treeview_toggled, self.color_model, self.color_filters) column = gtk.TreeViewColumn(None, renderer) column.add_attribute(renderer, "active", self.TV_COL_TOGGLE) column.set_cell_data_func(renderer, self._treeview_setter) self._calendar_treeview.append_column(column) renderer = gtk.CellRendererText() column = gtk.TreeViewColumn(None, renderer, text=self.TV_COL_LABEL) col_label = gtk.Label('') col_label.set_markup('<b>%s</b>' % self.fields[self.color_field]['string']) col_label.show() column.set_widget(col_label) column.set_cell_data_func(renderer, self._treeview_setter) self._calendar_treeview.append_column(column)
def __init__(self): qtwindow.QTWindow.__init__(self, 'watch', 'Watch') self.connect("delete-event", self._delete_event_cb) qt.flow.connect('measurement-start', self._mstart_cb) qt.flow.connect('measurement-end', self._mend_cb) self._watch = {} self._paused = False self._frame = gtk.Frame() self._frame.set_label(_L('Add variable')) self._ins_combo = dropdowns.InstrumentDropdown() self._ins_combo.connect('changed', self._instrument_changed_cb) self._param_combo = dropdowns.InstrumentParameterDropdown() self._param_combo.connect('changed', self._parameter_changed_cb) label = gtk.Label(_L('Interval')) self._interval = gtk.SpinButton(climb_rate=1, digits=0) self._interval.set_range(0, 100000) self._interval.set_value(500) interval = gui.pack_hbox( [label, self._interval, gtk.Label('ms')], False, False) self._graph_check = gtk.CheckButton('Graph') self._graph_check.set_active(True) self._graph_check.connect('toggled', self._graph_toggled_cb) label = gtk.Label('Data points') self._npoints = gtk.SpinButton(climb_rate=1, digits=0) self._npoints.set_range(10, 1000) self._npoints.set_value(100) self._npoints.set_increments(1, 10) graph = gui.pack_hbox([self._graph_check, label, self._npoints], True, False) self._ma_check = gtk.CheckButton('Moving average') self._ma_check.set_active(False) self._ma_check.connect('toggled', self._ma_toggled_cb) label = gtk.Label('Constant') self._ma_const = gtk.SpinButton(climb_rate=0.01, digits=2) self._ma_const.set_sensitive(False) self._ma_const.set_range(0, 1.0) self._ma_const.set_increments(0.01, 0.1) self._ma_const.set_value(0.95) ma = gui.pack_hbox([self._ma_check, label, self._ma_const], True, False) self._add_button = gtk.Button(_L('Add')) self._add_button.connect('clicked', self._add_clicked_cb) self._remove_button = gtk.Button(_L('Remove')) self._remove_button.connect('clicked', self._remove_clicked_cb) self._pause_button = gtk.ToggleButton(_L('Pause')) self._pause_button.set_active(False) self._pause_button.connect('clicked', self._toggle_pause_cb) self._apply_button = gtk.Button(_L('Apply')) self._apply_button.connect('clicked', self._apply_clicked_cb) self._clear_button = gtk.Button(_L('Clear')) self._clear_button.connect('clicked', self._clear_clicked_cb) buttons = gui.pack_hbox([ self._add_button, self._remove_button, self._pause_button, self._apply_button, self._clear_button ], False, False) self._tree_model = gtk.ListStore(str, str, str) self._tree_view = QTTable([ (_L('Parameter'), {}), (_L('Delay'), {}), (_L('Value'), { 'scale': 3.0 }), ], self._tree_model) vbox = gui.pack_vbox([ self._ins_combo, self._param_combo, interval, graph, ma, buttons, ], False, False) vbox.set_border_width(4) self._frame.add(vbox) vbox = gui.pack_vbox([ self._frame, self._tree_view, ], False, False) self.add(vbox) vbox.show_all()
def __init__(self, uid, panel_id): #AWN Applet Configuration awn.Applet.__init__(self, 'file-browser-launcher', uid, panel_id) self.icon_box = awn.IconBox(self) self.add(self.icon_box) self.icon = awn.ThemedIcon() self.icon.set_tooltip_text(_("File Browser Launcher")) self.icon.set_size(self.get_size()) self.dialog = awn.Dialog(self.icon, self) #AwnConfigClient instance self.client = awn.config_get_default_for_applet(self) #Get the default icon theme self.theme = gtk.icon_theme_get_default() self.icons[24] = {} try: self.icons[24]['folder'] = self.theme.load_icon('folder', 24, 0) except: self.icons[24]['folder'] = None #Docklet... self.mode = self.client.get_int(group, 'mode') self.client.notify_add(group, 'mode', self.update_mode) if self.mode == 2: self.docklet_visible = True self.update_docklet(False) else: self.icon_box.add(self.icon) #Set the icon self.icon.set_info_simple('file-browser-launcher', uid, 'folder') if gio: #This part (and other progress overlay code) adapted from #mhr3's 'Dropper' applet #Set the progress overlay self.timer_overlay = awn.OverlayProgressCircle() self.timer_overlay.props.active = False self.timer_overlay.props.apply_effects = False self.icon.add_overlay(self.timer_overlay) else: #Read fstab for mounting info #(It it assumed that fstab won't change after the applet is started) self.fstab2 = open('/etc/fstab', 'r') self.fstab = self.fstab2.read().split('\n') self.fstab2.close() #Check if nautilus-connect-server is installed if os.path.exists('/usr/bin/nautilus-connect-server') or os.path.exists \ ('/usr/local/bin/nautilus-connect-server'): self.nautilus_connect_server = True else: self.nautilus_connect_server = False if os.path.exists('/usr/share/applications/nautilus-computer.desktop') or \ os.path.exists('/usr/local/share/applications/nautilus-computer.desktop'): self.nautilus_computer = True else: self.nautilus_computer = False def trash_count_cb(*args): if self.show_trash: if gio: self.do_gio_places() else: self.add_places() self.trash = vfs.Trash.get_default() self.trash.connect('file-count-changed', trash_count_cb) #Make the dialog, will only be shown when approiate #Make all the things needed for a treeview for the homefolder, root dir, bookmarks, and mounted drives self.liststore = gtk.ListStore(gtk.gdk.Pixbuf, str, gtk.gdk.Pixbuf, str, int) #Renderers renderer0 = gtk.CellRendererPixbuf() renderer1 = gtk.CellRendererText() self.eject_render = gtk.CellRendererPixbuf() self.eject_render.set_property("mode", gtk.CELL_RENDERER_MODE_ACTIVATABLE) #Add renderers to column column = gtk.TreeViewColumn('0') column.pack_start(renderer0, False) column.add_attribute(renderer0, 'pixbuf', 0) column.pack_start(renderer1, True) column.add_attribute(renderer1, 'markup', 1) column.pack_start(self.eject_render, False) column.add_attribute(self.eject_render, 'pixbuf', 2) #TreeView self.treeview = gtk.TreeView(self.liststore) self.treeview.set_hover_selection(True) self.treeview.set_headers_visible(False) self.treeview.append_column(column) self.treeview.set_no_show_all(True) self.treeview.connect('button-press-event', self.treeview_clicked) self.vbox = gtk.VBox() self.vbox.pack_start(self.treeview) if gio: self.monitor = gio.volume_monitor_get() for signal in ('volume-added', 'volume-changed', 'volume-removed', 'mount-added', 'mount-changed', 'mount-removed'): self.monitor.connect(signal, self.do_gio_places) for key in ('show_computer', 'show_home', 'show_filesystem', 'show_local', 'show_network', 'show_connect', 'show_trash', 'show_bookmarks'): self.client.notify_add(group, key, self.do_gio_places) self.do_gio_places() #(From YAMA by Onox) #Monitor bookmarks file for changes bookmarks_file = os.path.expanduser("~/.gtk-bookmarks") #keep a reference to avoid getting it garbage collected self.__bookmarks_monitor = gio.File(bookmarks_file).monitor_file() def bookmarks_changed_cb(monitor, file, other_file, event): if event in (gio.FILE_MONITOR_EVENT_CHANGES_DONE_HINT, gio.FILE_MONITOR_EVENT_CREATED, gio.FILE_MONITOR_EVENT_DELETED): #Refresh menu to re-initialize the widget self.do_gio_places() self.__bookmarks_monitor.connect("changed", bookmarks_changed_cb) #Entry widget for displaying the path to open self.entry = gtk.Entry() self.entry.set_text(os.environ['HOME']) self.entry.connect('key-release-event', self.detect_enter) self.entry.show() #Open button to run the file browser self.enter = gtk.Button(stock=gtk.STOCK_OPEN) self.enter.connect('clicked', self.launch_fb) self.enter.show() #HBox to put the two together entry_hbox = gtk.HBox() entry_hbox.pack_start(self.entry) entry_hbox.pack_start(self.enter, False) #And add the HBox to the vbox and add the vbox to the dialog self.vbox.pack_end(entry_hbox) self.dialog.add(self.vbox) #Connect to signals self.icon.connect('clicked', self.icon_clicked) self.icon.connect('middle-clicked', self.icon_clicked) self.icon.connect('context-menu-popup', self.show_context_menu) self.connect('size-changed', self.size_changed) self.dialog.connect('focus-out-event', self.dialog_focus_out) self.theme.connect('changed', self.icon_theme_changed) if gio: #Allow the user to drag&drop a file/folder onto the applet. After #a short delay, show the dialog, and allow the file/folder to be dropped #on any place in the TreeView (other than root, Connect to Server..., and #maybe unmounted places). The move the file/folder and (if successful) #open the place in the file browser #The Applet icon - just open the dialog after a short delay self.icon.drag_dest_set(gtk.DEST_DEFAULT_DROP | gtk.DEST_DEFAULT_MOTION, \ [("text/uri-list", 0, 0)], \ gtk.gdk.ACTION_COPY) self.icon.connect('drag-data-received', self.applet_drag_data_received) self.icon.connect('drag-motion', self.applet_drag_motion) self.icon.connect('drag-leave', self.applet_drag_leave) #The TreeView - drop the file to move it to the folder self.treeview.drag_dest_set(gtk.DEST_DEFAULT_DROP | gtk.DEST_DEFAULT_MOTION, \ [("text/uri-list", 0, 0)], \ gtk.gdk.ACTION_MOVE) self.treeview.connect('drag-data-received', self.treeview_drag_data_received) self.treeview.connect('drag-motion', self.treeview_drag_motion) self.treeview.connect('drag-leave', self.treeview_drag_leave) elif self.mode == 2: self.add_places()
def __init__(self, r, formatd=None, stringd=None): """ r is a numpy record array formatd is a dict mapping dtype name to mlab.FormatObj instances stringd, if not None, is a dict mapping dtype names to a list of valid strings for a combo drop down editor """ if stringd is None: stringd = dict() if formatd is None: formatd = mlab.get_formatd(r) self.stringd = stringd self.callbacks = cbook.CallbackRegistry(['cell_changed']) self.r = r self.headers = r.dtype.names self.formats = [ gtkformat_factory(formatd.get(name, mlab.FormatObj()), i) for i, name in enumerate(self.headers) ] # use the gtk attached versions self.formatd = formatd = dict(zip(self.headers, self.formats)) types = [] for format in self.formats: if isinstance(format, mlab.FormatBool): types.append(gobject.TYPE_BOOLEAN) else: types.append(gobject.TYPE_STRING) self.combod = dict() if len(stringd): types.extend([gobject.TYPE_INT] * len(stringd)) keys = stringd.keys() keys.sort() valid = set(r.dtype.names) for ikey, key in enumerate(keys): assert (key in valid) combostore = gtk.ListStore(gobject.TYPE_STRING) for s in stringd[key]: combostore.append([s]) self.combod[key] = combostore, len(self.headers) + ikey gtk.ListStore.__init__(self, *types) for row in r: vals = [] for formatter, val in zip(self.formats, row): if isinstance(formatter, mlab.FormatBool): vals.append(val) else: vals.append(formatter.tostr(val)) if len(stringd): # todo, get correct index here? vals.extend([0] * len(stringd)) self.append(vals)
def setup_port_list(self): '''Sets up the ports/pins/bindings.''' # print "setup port table" pt = self.port_tree pl = gtk.ListStore(str, str) pt.set_model(pl) pl.clear() # Create the columns. name_column = gtk.TreeViewColumn() name_column.set_title("Name") cell = gtk.CellRendererText() name_column.pack_start(cell, True) name_column.add_attribute(cell, "text", 0) dir_column = gtk.TreeViewColumn() dir_column.set_title("Direction") cell = gtk.CellRendererText() dir_column.pack_start(cell, True) dir_column.add_attribute(cell, "text", 1) # Add the columns if they are needed. if pt.get_column(0) is None: pt.insert_column(name_column, 0) if pt.get_column(1) is None: pt.insert_column(dir_column, 1) for c in pt.get_columns(): print "columns: " + c.get_title() ports = self.node.parameters["ports"] ab_ms = self.node.parameters["arbitrator_masters"] for port in ports.keys(): if port == "clk" or port == "rst" or port.partition( "_")[0] == "wbs": continue pre = port.partition("_")[0] if pre in ab_ms: continue direction = ports[port]["direction"] # print "port: %s, direction: %s" % (port, direction) print "port[%s] = %s" % (port, str(ports[port])) # pl.append([port, direction]) size = ports[port]["size"] if size == 1: it = pl.append() pl.set(it, 0, port) pl.set(it, 1, direction) else: min_value = 0 max_value = 1 if "min_val" in ports[port].keys(): min_value = ports[port]["min_val"] if "max_val" in ports[port].keys(): max_value = ports[port]["max_val"] for i in range(min_value, min_value + size): it = pl.append() p = port + str("[%d]" % i) pl.set(it, 0, p) pl.set(it, 1, direction)
def __init__(self, stringlist): self._items = gtk.ListStore(gobject.TYPE_STRING) QTComboBox.__init__(self, model=self._items) self.set_items(stringlist)
def __init__(self): # Comprobamos antes de nada que los 2 directorios existen y que tienen permisos de ejecucion if not access('names', R_OK): self.error_dialog(_("You don't have read permisions on names directory")) sys.exit(1) else: mainwin = gtk.Window() mainwin.set_title('Fantasy Names Generator') mainwin.set_position(gtk.WIN_POS_CENTER_ALWAYS) mainwin.set_default_size(400,300) hbox = gtk.HBox(homogeneous=False) vbox = gtk.VBox() lang_label = gtk.Label(str=_('Select race:')) lang_label.set_alignment(0, 0) vbox.pack_start(lang_label, False, False, 0) self.liststore = gtk.ListStore(str, str, bool) self.lang_select = gtk.ComboBox(self.liststore) cell = gtk.CellRendererText() self.lang_select.pack_start(cell, True) self.lang_select.add_attribute(cell, 'text', 1) self.liststore.append(['drow', _('Drow/Dark elf'), True]) self.liststore.append(['elf', _('Elf'), False]) self.liststore.append(['hafling', 'Hafling', True]) self.liststore.append(['dwarven', _('Dwarven'), True]) self.liststore.append(['gnome', _('Gnomes'), True]) self.liststore.append(['demons', _('Demons'), False]) self.liststore.append(['dragons', _(u'Dragons'), False]) self.liststore.append(['orcs', _('Orcs'), False]) self.lang_select.connect('changed', self.check_combobox) vbox.pack_start(self.lang_select, False, False, 0) sex_label = gtk.Label(str=_('Select sex:')) sex_label.set_alignment(0, 0) vbox.pack_start(sex_label, False, False, 0) liststore2 = gtk.ListStore(str, str) self.sex_select = gtk.ComboBox(liststore2) cell2 = gtk.CellRendererText() self.sex_select.pack_start(cell2, True) self.sex_select.add_attribute(cell2, 'text', 1) liststore2.append(['male', _('Male')]) liststore2.append(['female', _('Female')]) vbox.pack_start(self.sex_select, False, False, 0) self.sex_select.connect('changed', self.check_combobox) self.sex_select.set_sensitive(False) total_label = gtk.Label(str=_('Total generating (1-100):')) sex_label.set_alignment(0, 0) vbox.pack_start(total_label, False, False, 0) self.total_value = gtk.SpinButton() self.total_value.set_range(1, 100) self.total_value.set_increments(1.0, 5.0) vbox.pack_start(self.total_value, False, False, 0) self.generate = gtk.Button(label=_('Generate list')) self.generate.connect('clicked', self.generar) self.generate.set_sensitive(False) vbox.pack_start(self.generate, False, False, 0) self.save = gtk.Button(label=_('Save')) self.save.set_sensitive(False) self.save.connect('clicked', self.save_on_file) vbox.pack_start(self.save, False, False, 0) info = gtk.Button(label=_('About')) info.connect('clicked', self.view_info) vbox.pack_start(info, False, False, 0) hbox.pack_start(vbox, False, False, 0) textview_container = gtk.ScrolledWindow() self.textview = gtk.TextView() self.textview.set_editable(False) textview_container.add(self.textview) hbox.add(textview_container) mainwin.add(hbox) mainwin.show_all() mainwin.connect('destroy', self.destroy)
def __init__(self): gtk.VBox.__init__(self,2) self.cursor = None self.mounted_list = [] self.path_first_button = "" self.path_second_button = "" self.path_third_button = "" #Dbus stuff self.bus = dbus.SystemBus() self.hal_manager_obj = self.bus.get_object("org.freedesktop.Hal", "/org/freedesktop/Hal/Manager") self.hal_manager = dbus.Interface(self.hal_manager_obj,"org.freedesktop.Hal.Manager") #DiskPreviewUtils self.utils = DiskPreviewUtils.DiskPreviewUtils() #Glade stuff GLADEDIR = "/usr/lib/ubiquity/glade/" self.xml = gtk.glade.XML(GLADEDIR + "diskpreview.glade", root="disk_preview_main_hbox") self.disk_preview_main_hbox = self.xml.get_widget("disk_preview_main_hbox") self.disk_preview_sidebar_vbox = self.xml.get_widget("disk_preview_sidebar_vbox") self.disk_preview_browser_vbox = self.xml.get_widget("disk_preview_browser_vbox") self.disk_preview_treeview = self.xml.get_widget("disk_preview_treeview") self.disk_preview_fs_label = self.xml.get_widget("disk_preview_fs_label") self.disk_preview_free_label = self.xml.get_widget("disk_preview_free_label") self.disk_preview_used_label = self.xml.get_widget("disk_preview_ocu_label") self.disk_preview_total_label = self.xml.get_widget("disk_preview_tam_label") self.disk_preview_info_panel = self.xml.get_widget("disk_preview_info_panel") self.disk_preview_info_panel.hide() self.disk_preview_info_panel.set_no_show_all(True) self.disk_preview_path_hbox = self.xml.get_widget("disk_preview_path_hbox") self.disk_preview_path_hbox.hide() self.disk_preview_path_hbox.set_no_show_all(True) self.disk_preview_back_button = self.xml.get_widget("disk_preview_back_button") self.disk_preview_harddisk_button = self.xml.get_widget("disk_preview_harddisk_button") self.disk_preview_first_dir_button = self.xml.get_widget("disk_preview_first_dir_button") self.disk_preview_first_dir_label = self.xml.get_widget("disk_preview_first_dir_label") self.disk_preview_second_dir_button = self.xml.get_widget("disk_preview_second_dir_button") self.disk_preview_second_dir_label = self.xml.get_widget("disk_preview_second_dir_label") self.disk_preview_third_dir_button = self.xml.get_widget("disk_preview_third_dir_button") self.disk_preview_third_dir_label = self.xml.get_widget("disk_preview_third_dir_label") self.disk_preview_forward_button = self.xml.get_widget("disk_preview_forward_button") self.disk_preview_browser_iconview = self.xml.get_widget("disk_preview_browser_iconview") self.disk_preview_browser_model = gtk.ListStore (str, gtk.gdk.Pixbuf, str) self.disk_preview_browser_iconview.set_model(self.disk_preview_browser_model) self.disk_preview_browser_iconview.set_text_column(0) self.disk_preview_browser_iconview.set_pixbuf_column(1) # self.disk_preview_treeview_model : # # gtk.gdk.Pixbuf : hard disk icon # str : Name of the hard disk or partition # str : Total partition space # str : Ocupated partition space # str : Free partition space # str : File system type # str : dev path # str : path of the mounted filesystem self.disk_preview_treeview_model = gtk.TreeStore(gtk.gdk.Pixbuf, str, str, str, str, str, str, str) self.disk_preview_treeview.set_model(self.disk_preview_treeview_model) disk_preview_treeview_sort = gtk.TreeModelSort(self.disk_preview_treeview_model) disk_preview_treeview_sort.set_sort_column_id(1, gtk.SORT_ASCENDING) cellrenderpixbuf = gtk.CellRendererPixbuf() cellrendertext = gtk.CellRendererText() column = gtk.TreeViewColumn('hd_icon', cellrenderpixbuf, pixbuf=0) self.disk_preview_treeview.append_column(column) column = gtk.TreeViewColumn('hd_name', cellrendertext, markup=1) self.disk_preview_treeview.append_column(column) self.pack_start(self.disk_preview_main_hbox, expand=True) selection = self.disk_preview_treeview.get_selection() selection.set_mode(gtk.SELECTION_SINGLE) #Signals selection.connect("changed", self.__disk_preview_treview_row_changed_cb, None) self.disk_preview_browser_iconview.connect("item-activated", self.__disk_preview_browser_iconview_item_activated_cb, None) self.disk_preview_harddisk_button.connect("clicked", self.__disk_preview_harddisk_button_cb, None) self.fdb_handler_id = self.disk_preview_first_dir_button.connect("toggled", self.__disk_preview_first_dir_button_cb, None) self.sdb_handler_id = self.disk_preview_second_dir_button.connect("toggled", self.__disk_preview_second_dir_button_cb, None) self.tdb_handler_id = self.disk_preview_third_dir_button.connect("toggled", self.__disk_preview_third_dir_button_cb, None) self.disk_preview_back_button.connect("clicked", self.__disk_preview_back_button_cb, None) self.disk_preview_forward_button.connect("clicked", self.__disk_preview_forward_button_cb, None)
def _create_store(self): store = gtk.ListStore(str, gtk.gdk.Pixbuf, bool) return store
def table_insert(self, iter_insert, table=None, table_justification=None, text_buffer=None): """Insert a Table at the Given Iter""" if not text_buffer: text_buffer = self.dad.curr_buffer if table != None: self.dad.table_columns = len(table['matrix'][0]) self.dad.table_rows = len(table['matrix']) - 1 headers = table['matrix'][-1] table_col_min = table['col_min'] table_col_max = table['col_max'] else: headers = [_("click me")] * self.dad.table_columns table_col_min = self.dad.table_col_min table_col_max = self.dad.table_col_max anchor = text_buffer.create_child_anchor(iter_insert) anchor.liststore = gtk.ListStore(*(str,) * self.dad.table_columns) anchor.treeview = gtk.TreeView(anchor.liststore) for element in range(self.dad.table_columns): label = gtk.Label('<b>' + headers[element] + '</b>') label.set_use_markup(True) label.set_tooltip_text(_("Click to Edit the Column Settings")) label.show() renderer_text = gtk.CellRendererText() renderer_text.set_property('editable', True) renderer_text.set_property('wrap-width', table_col_max) renderer_text.set_property('wrap-mode', pango.WRAP_WORD_CHAR) renderer_text.set_property('font-desc', pango.FontDescription(self.dad.text_font)) renderer_text.connect('edited', self.on_table_cell_edited, anchor.liststore, element) renderer_text.connect('editing-started', self.on_table_cell_editing_started, anchor.liststore, element) column = gtk.TreeViewColumn("", renderer_text, text=element) column.set_min_width(table_col_min) column.set_clickable(True) column.set_widget(label) column.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE) column.connect('clicked', self.table_column_clicked, anchor, element) anchor.treeview.append_column(column) anchor.headers = headers anchor.table_col_min = table_col_min anchor.table_col_max = table_col_max anchor.treeview.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH) anchor.treeview.connect('button-press-event', self.on_mouse_button_clicked_treeview_table, anchor) anchor.treeview.connect('key_press_event', self.on_key_press_treeview_table, anchor) anchor.frame = gtk.Frame() anchor.frame.add(anchor.treeview) anchor.frame.set_shadow_type(gtk.SHADOW_NONE) anchor.eventbox = gtk.EventBox() anchor.eventbox.add(anchor.frame) self.dad.sourceview.add_child_at_anchor(anchor.eventbox, anchor) anchor.eventbox.show_all() for row in range(self.dad.table_rows): row_iter = anchor.liststore.append([""] * self.dad.table_columns) if table != None: for column in range(self.dad.table_columns): try: anchor.liststore[row_iter][column] = table['matrix'][row][column] except: pass # there are cases when some rows have less columns if table_justification: text_iter = text_buffer.get_iter_at_child_anchor(anchor) self.dad.state_machine.apply_object_justification(text_iter, table_justification, text_buffer) elif self.dad.user_active: # if I apply a justification, the state is already updated self.dad.state_machine.update_state()
def __init__(self, applet): self.ui = gtk.Builder() self.ui.add_from_file(join(invest.BUILDER_DATA_DIR, "prefs-dialog.ui")) self.dialog = self.ui.get_object("preferences") self.treeview = self.ui.get_object("stocks") self.ui.get_object("add").connect('clicked', self.on_add_stock) self.ui.get_object("add").connect('activate', self.on_add_stock) self.ui.get_object("remove").connect('clicked', self.on_remove_stock) self.ui.get_object("remove").connect('activate', self.on_remove_stock) self.treeview.connect('key-press-event', self.on_tree_keypress) self.typs = (str, str, float, float, float) self.names = (_("Symbol"), _("Label"), _("Amount"), _("Price"), _("Commission")) store = gtk.ListStore(*self.typs) store.set_sort_column_id(0, gtk.SORT_ASCENDING) self.treeview.set_model(store) self.model = store def on_cell_edited(cell, path, new_text, col, typ): try: if col == 0: # stock symbols must be uppercase new_text = str.upper(new_text) store[path][col] = typ(new_text) except: pass def get_cell_data(column, cell, model, iter, data): typ, col = data if typ == int: cell.set_property('text', "%d" % typ(model[iter][col])) elif typ == float: cell.set_property('text', "%.2f" % typ(model[iter][col])) else: cell.set_property('text', typ(model[iter][col])) def create_cell(view, column, name, typ): cell_description = gtk.CellRendererText() cell_description.set_property("editable", True) cell_description.connect("edited", on_cell_edited, column, typ) column_description = gtk.TreeViewColumn(name, cell_description) if typ == str: column_description.set_attributes(cell_description, text=column) column_description.set_sort_column_id(column) if typ == float: column_description.set_cell_data_func(cell_description, get_cell_data, (float, column)) view.append_column(column_description) for n in xrange(0, 5): create_cell(self.treeview, n, self.names[n], self.typs[n]) stock_items = invest.STOCKS.items() stock_items.sort() for key, data in stock_items: label = data["label"] purchases = data["purchases"] for purchase in purchases: store.append([ key, label, purchase["amount"], purchase["bought"], purchase["comission"] ]) try: pixbuf = gtk.gdk.pixbuf_new_from_file_at_size( join(invest.ART_DATA_DIR, "invest-16.png"), -1, -1) self.dialog.set_icon(pixbuf) except Exception, msg: invest.debug("Could not load 'invest-16.png' file: %s" % msg) pass
def display(self): self.top = Glade() window = self.top.toplevel self.top.connect_signals({ "destroy_passed_object": self.close, "on_ok_clicked": self.on_ok_clicked, "on_help_clicked": self.on_help_clicked, "on_delete_event": self.close, }) self.list = self.top.get_object("list") self.set_window(window, self.top.get_object('title'), self.label) self.model = gtk.ListStore(gobject.TYPE_BOOLEAN, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING) r = gtk.CellRendererToggle() r.connect('toggled', self.toggled) c = gtk.TreeViewColumn(_('Select'), r, active=0) self.list.append_column(c) c = gtk.TreeViewColumn(_('ID'), gtk.CellRendererText(), text=1) self.list.append_column(c) c = gtk.TreeViewColumn(_('Type'), gtk.CellRendererText(), text=2) self.list.append_column(c) c = gtk.TreeViewColumn(_('Value'), gtk.CellRendererText(), text=3) self.list.append_column(c) c = gtk.TreeViewColumn(_('Current Name'), gtk.CellRendererText(), text=4) self.list.append_column(c) self.list.set_model(self.model) self.nick_hash = {} self.title_hash = {} self.prefix1_hash = {} self.compound_hash = {} self.progress.set_pass(_('Building display'), len(self.handle_to_action.keys())) for key, data in self.handle_to_action.items(): p = self.db.get_person_from_handle(key) gid = p.get_gramps_id() if self.nickid in data: given, nick = data[self.nickid] handle = self.model.append() self.model.set_value(handle, 0, 1) self.model.set_value(handle, 1, gid) self.model.set_value(handle, 2, _('Nickname')) self.model.set_value(handle, 3, nick) self.model.set_value(handle, 4, p.get_primary_name().get_name()) self.nick_hash[key] = handle if self.titleid in data: title, given = data[self.titleid] handle = self.model.append() self.model.set_value(handle, 0, 1) self.model.set_value(handle, 1, gid) self.model.set_value(handle, 2, _('Person|Title')) self.model.set_value(handle, 3, title) self.model.set_value(handle, 4, p.get_primary_name().get_name()) self.title_hash[key] = handle if self.pref1id in data: given, prefixtotal, new_prefix = data[self.pref1id] handle = self.model.append() self.model.set_value(handle, 0, 1) self.model.set_value(handle, 1, gid) self.model.set_value(handle, 2, _('Prefix in given name')) self.model.set_value(handle, 3, prefixtotal) self.model.set_value(handle, 4, p.get_primary_name().get_name()) self.prefix1_hash[key] = handle if self.compid in data: surn_list, pref_list, con_list, prims, origs = data[ self.compid] handle = self.model.append() self.model.set_value(handle, 0, 1) self.model.set_value(handle, 1, gid) self.model.set_value(handle, 2, _('Compound surname')) newval = '' for sur, pre, con in zip(surn_list, pref_list, con_list): if newval: newval += '-[' else: newval = '[' newval += pre + ',' + sur if con: newval += ',' + con + ']' else: newval += ']' self.model.set_value(handle, 3, newval) self.model.set_value(handle, 4, p.get_primary_name().get_name()) self.compound_hash[key] = handle self.progress.step() self.progress.close() self.show()
def __init__(self): """Initialise. """ gtk.EventBox.__init__(self) import application self.app = application.get_app() self.actions = set() self.default_action = None self.bindings = None #: dict of bindings being edited self.vbox = gtk.VBox() self.add(self.vbox) # Display strings for action names self.action_labels = dict() # Model: combo cellrenderer's liststore ls = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING) self.action_liststore = ls self.action_liststore_value_column = 0 self.action_liststore_display_column = 1 # Model: main list's liststore # This is reflected into self.bindings when it changes column_types = [gobject.TYPE_STRING, gobject.TYPE_STRING] ls = gtk.ListStore(*column_types) self.action_column = 0 self.bp_column = 1 for sig in ("row-changed", "row-deleted", "row_inserted"): ls.connect(sig, self._liststore_updated_cb) self.liststore = ls # Bindings hash observers, external interface self.bindings_observers = [] #: List of cb(editor) callbacks # View: treeview scrolledwin = gtk.ScrolledWindow() scrolledwin.set_shadow_type(gtk.SHADOW_IN) tv = gtk.TreeView() tv.set_model(ls) scrolledwin.add(tv) self.vbox.pack_start(scrolledwin, True, True) tv.set_size_request(480, 320) tv.set_headers_clickable(True) self.treeview = tv self.selection = tv.get_selection() self.selection.connect("changed", self._selection_changed_cb) # Column 0: action name cell = gtk.CellRendererCombo() cell.set_property("model", self.action_liststore) cell.set_property("text-column", self.action_liststore_display_column) cell.set_property("mode", gtk.CELL_RENDERER_MODE_EDITABLE) cell.set_property("editable", True) cell.set_property("has-entry", False) cell.connect("changed", self._action_cell_changed_cb) col = gtk.TreeViewColumn(_("Action"), cell) col.set_cell_data_func(cell, self._liststore_action_datafunc) col.set_min_width(150) col.set_resizable(False) col.set_expand(False) col.set_sort_column_id(self.action_column) tv.append_column(col) # Column 1: button press cell = gtk.CellRendererText() cell.set_property("ellipsize", pango.ELLIPSIZE_END) cell.set_property("mode", gtk.CELL_RENDERER_MODE_EDITABLE) cell.set_property("editable", True) cell.connect("edited", self._bp_cell_edited_cb) cell.connect("editing-started", self._bp_cell_editing_started_cb) col = gtk.TreeViewColumn(_("Button press"), cell) col.add_attribute(cell, "text", self.bp_column) col.set_expand(True) col.set_resizable(True) col.set_min_width(200) col.set_sort_column_id(self.bp_column) tv.append_column(col) # List editor toolbar (inline-toolbar for gtk3) list_tools = gtk.Toolbar() list_tools.set_style(gtk.TOOLBAR_ICONS) list_tools.set_icon_size(widgets.ICON_SIZE_LARGE) context = list_tools.get_style_context() context.add_class("inline-toolbar") self.vbox.pack_start(list_tools, False, False) # Add binding btn = gtk.ToolButton() btn.set_tooltip_text(_("Add a new binding")) btn.set_icon_name("mypaint-add-symbolic") btn.connect("clicked", self._add_button_clicked_cb) list_tools.add(btn) # Remove (inactive if list is empty) btn = gtk.ToolButton() btn.set_icon_name("mypaint-remove-symbolic") btn.set_tooltip_text(_("Remove the current binding")) btn.connect("clicked", self._remove_button_clicked_cb) list_tools.add(btn) self.remove_button = btn self._updating_model = False
def create_window(self): """ Set up the window with all its widgets :return: the created window """ window = gtk.Window(gtk.WINDOW_TOPLEVEL) window.set_border_width(2) window.set_title('Enter LaTeX Formula - TexText') # File chooser and Scale Adjustment if hasattr(gtk, 'FileChooserButton'): self._preamble_widget = gtk.FileChooserButton("...") self._preamble_widget.set_action(gtk.FILE_CHOOSER_ACTION_OPEN) else: self._preamble_widget = gtk.Entry() self.clear_preamble() # --- Preamble file --- preamble_delete = gtk.Button(label="Clear") preamble_delete.connect('clicked', self.clear_preamble) preamble_delete.set_tooltip_text("Clear the preamble file setting") preamble_frame = gtk.Frame("Preamble File") preamble_box = gtk.HBox(homogeneous=False, spacing=2) preamble_frame.add(preamble_box) preamble_box.pack_start(self._preamble_widget, True, True, 2) preamble_box.pack_start(preamble_delete, False, False, 2) # --- Tex command --- texcmd_frame = gtk.Frame("TeX command") texcmd_box = gtk.HBox(homogeneous=False, spacing=2) texcmd_frame.add(texcmd_box) self._texcmd_cbox = gtk.combo_box_new_text() cell = gtk.CellRendererText() self._texcmd_cbox.pack_start(cell) self._texcmd_cbox.set_wrap_width(1) for tex_command in self.TEX_COMMANDS: self._texcmd_cbox.append_text(tex_command) self._texcmd_cbox.set_active( self.TEX_COMMANDS.index(self.current_texcmd)) self._texcmd_cbox.set_tooltip_text( "TeX command used for compiling.") texcmd_box.pack_start(self._texcmd_cbox, True, True, 2) # --- Scaling --- scale_frame = gtk.Frame("Scale Factor") scale_box = gtk.HBox(homogeneous=False, spacing=2) scale_frame.add(scale_box) self._scale_adj = gtk.Adjustment(lower=0.001, upper=180, step_incr=0.001, page_incr=1) self._scale = gtk.SpinButton(self._scale_adj) self._scale.set_digits(3) self._scale_adj.set_value(self.scale_factor_after_loading()) self._scale.set_tooltip_text( "Change the scale of the LaTeX output") # We need buttons with custom labels and stock icons, so we make some reset_scale = self.current_scale_factor if self.current_scale_factor else self.global_scale_factor items = [('tt-reset', 'Reset ({0:.3f})'.format(reset_scale), 0, 0, None), ('tt-global', 'As previous ({0:.3f})'.format(self.global_scale_factor), 0, 0, None)] # Forcibly show icons settings = gtk.settings_get_default() settings.props.gtk_button_images = True # Make copies of stock icons aliases = [('tt-reset', gtk.STOCK_UNDO), ('tt-global', gtk.STOCK_COPY)] gtk.stock_add(items) factory = gtk.IconFactory() factory.add_default() style = window.get_style() for new_stock, alias in aliases: icon_set = style.lookup_icon_set(alias) factory.add(new_stock, icon_set) scale_reset_button = gtk.Button(stock='tt-reset') scale_reset_button.set_tooltip_text( "Set scale factor to the value this node has been created with ({0:.3f})" .format(reset_scale)) scale_reset_button.connect('clicked', self.reset_scale_factor) if self.text == "": scale_reset_button.set_sensitive(False) scale_global_button = gtk.Button(stock='tt-global') scale_global_button.set_tooltip_text( "Set scale factor to the value of the previously edited node in Inkscape ({0:.3f})" .format(self.global_scale_factor)) scale_global_button.connect('clicked', self.use_global_scale_factor) scale_box.pack_start(self._scale, True, True, 2) scale_box.pack_start(scale_reset_button, False, False, 2) scale_box.pack_start(scale_global_button, False, False, 2) # --- Alignment box --- alignment_frame = gtk.Frame("Alignment") alignment_box = gtk.HBox(homogeneous=False, spacing=2) alignment_frame.add(alignment_box) liststore = gtk.ListStore(str) for a in self.ALIGNMENT_LABELS: liststore.append([a]) self._alignment_combobox = gtk.ComboBox() cell = gtk.CellRendererText() self._alignment_combobox.pack_start(cell) self._alignment_combobox.add_attribute(cell, 'text', 0) self._alignment_combobox.set_model(liststore) self._alignment_combobox.set_wrap_width(3) self._alignment_combobox.set_active( self.ALIGNMENT_LABELS.index(self.current_alignment)) self._alignment_combobox.set_tooltip_text( "Set alignment anchor position") if self.text == "": self._alignment_combobox.set_sensitive(False) alignment_box.pack_start(self._alignment_combobox, True, True, 2) # --- Scale and alignment together in one "line" scale_align_hbox = gtk.HBox(homogeneous=False, spacing=2) scale_align_hbox.pack_start(scale_frame, False, False, 0) scale_align_hbox.pack_start(alignment_frame, True, True, 0) # --- TeX code window --- # Scrolling Window with Source View inside scroll_window = gtk.ScrolledWindow() scroll_window.set_shadow_type(gtk.SHADOW_IN) if TOOLKIT == GTKSOURCEVIEW: # Source code view text_buffer = gtksourceview2.Buffer() # set LaTeX as highlighting language, so that pasted text is also highlighted as such lang_manager = gtksourceview2.LanguageManager() latex_language = lang_manager.get_language("latex") text_buffer.set_language(latex_language) text_buffer.set_data('languages-manager', lang_manager) source_view = gtksourceview2.View(text_buffer) else: # normal text view text_buffer = gtk.TextBuffer() source_view = gtk.TextView(text_buffer) self._source_buffer = text_buffer self._source_view = source_view self._source_buffer.set_text(self.text) scroll_window.add(self._source_view) set_monospace_font(self._source_view) # Action group and UI manager ui_manager = gtk.UIManager() accel_group = ui_manager.get_accel_group() window.add_accel_group(accel_group) ui_manager.add_ui_from_string(self._view_ui_description) action_group = gtk.ActionGroup('ViewActions') action_group.add_actions(self._view_actions, source_view) action_group.add_actions(self.buffer_actions, text_buffer) if TOOLKIT == GTKSOURCEVIEW: action_group.add_toggle_actions(self._toggle_actions, source_view) action_group.add_radio_actions( self._radio_actions, -1, AskTextGTKSource.tabs_toggled_cb, source_view) ui_manager.insert_action_group(action_group, 0) # Menu menu = ui_manager.get_widget('/MainMenu') # Cursor position label pos_label = gtk.Label('Position') source_view.set_data('pos_label', pos_label) # latex preview self._preview = gtk.Image() # Vertical Layout vbox = gtk.VBox(False, 4) window.add(vbox) vbox.pack_start(menu, False, False, 0) vbox.pack_start(preamble_frame, False, False, 0) vbox.pack_start(texcmd_frame, False, False, 0) vbox.pack_start(scale_align_hbox, False, False, 0) vbox.pack_start(scroll_window, True, True, 0) vbox.pack_start(pos_label, False, False, 0) vbox.pack_start(self._preview, False, False, 0) vbox.pack_start(self.create_buttons(), False, False, 0) vbox.show_all() # preselect menu check items if TOOLKIT == GTKSOURCEVIEW: groups = ui_manager.get_action_groups() # retrieve the view action group at position 0 in the list action_group = groups[0] action = action_group.get_action('ShowNumbers') action.set_active(True) action = action_group.get_action('AutoIndent') action.set_active(True) action = action_group.get_action('InsertSpaces') action.set_active(True) action = action_group.get_action('TabsWidth4') action.set_active(True) # Connect event callbacks window.connect("key-press-event", self.cb_key_press) text_buffer.connect('changed', self.update_position_label, source_view) window.connect('delete-event', self.window_deleted_cb, source_view) text_buffer.connect('mark_set', self.move_cursor_cb, source_view) return window
def __init__(self): gtk.Window.__init__(self) self.set_title("Dependency Explorer") self.set_default_size(500, 500) self.connect("delete-event", gtk.main_quit) # Create the data models self.pkg_model = gtk.ListStore(gobject.TYPE_STRING) self.depends_model = gtk.ListStore(gobject.TYPE_INT, gobject.TYPE_STRING, gobject.TYPE_STRING) pane = gtk.HPaned() pane.set_position(250) self.add(pane) # The master list of packages scrolled = gtk.ScrolledWindow() scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scrolled.set_shadow_type(gtk.SHADOW_IN) self.pkg_treeview = gtk.TreeView(self.pkg_model) self.pkg_treeview.get_selection().connect("changed", self.on_cursor_changed) self.pkg_treeview.append_column( gtk.TreeViewColumn("Package", gtk.CellRendererText(), text=COL_PKG_NAME)) pane.add1(scrolled) scrolled.add(self.pkg_treeview) box = gtk.VBox(homogeneous=True, spacing=4) # Runtime Depends scrolled = gtk.ScrolledWindow() scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scrolled.set_shadow_type(gtk.SHADOW_IN) self.rdep_treeview = PackageDepView(self.depends_model, TYPE_RDEP, "Runtime Depends") self.rdep_treeview.connect("row-activated", self.on_package_activated, COL_DEP_PACKAGE) scrolled.add(self.rdep_treeview) box.add(scrolled) # Build Depends scrolled = gtk.ScrolledWindow() scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scrolled.set_shadow_type(gtk.SHADOW_IN) self.dep_treeview = PackageDepView(self.depends_model, TYPE_DEP, "Build Depends") self.dep_treeview.connect("row-activated", self.on_package_activated, COL_DEP_PACKAGE) scrolled.add(self.dep_treeview) box.add(scrolled) pane.add2(box) # Reverse Depends scrolled = gtk.ScrolledWindow() scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scrolled.set_shadow_type(gtk.SHADOW_IN) self.revdep_treeview = PackageReverseDepView(self.depends_model, "Reverse Depends") self.revdep_treeview.connect("row-activated", self.on_package_activated, COL_DEP_PARENT) scrolled.add(self.revdep_treeview) box.add(scrolled) pane.add2(box) self.show_all()
def __init__(self, colheaders, formatterd=None): """ xalignd if not None, is a dict mapping col header to xalignent (default 1) formatterd if not None, is a dict mapping col header to a ColumnFormatter """ gtk.ScrolledWindow.__init__(self) self.colheaders = colheaders self.seq = None # not initialized with accts self.set_shadow_type(gtk.SHADOW_ETCHED_IN) self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) types = [gobject.TYPE_STRING] * len(colheaders) model = self.model = gtk.ListStore(*types) treeview = gtk.TreeView(self.model) treeview.show() treeview.get_selection().set_mode(gtk.SELECTION_MULTIPLE) treeview.set_rules_hint(True) class Clicked: def __init__(self, parent, i): self.parent = parent self.i = i self.num = 0 def __call__(self, column): ind = [] dsu = [] for rownum, thisiter in enumerate(self.parent.iters): val = model.get_value(thisiter, self.i) try: val = float(val.strip().rstrip('%')) except ValueError: pass if npy.isnan(val): val = npy.inf # force nan to sort uniquely dsu.append((val, rownum)) dsu.sort() if not self.num % 2: dsu.reverse() vals, otherind = zip(*dsu) ind.extend(otherind) self.parent.model.reorder(ind) newiters = [] for i in ind: newiters.append(self.parent.iters[i]) self.parent.iters = newiters[:] for i, thisiter in enumerate(self.parent.iters): key = tuple([ self.parent.model.get_value(thisiter, j) for j in range(len(colheaders)) ]) self.parent.rownumd[i] = key self.num += 1 if formatterd is None: formatterd = dict() formatterd = formatterd.copy() for i, header in enumerate(colheaders): renderer = gtk.CellRendererText() if header not in formatterd: formatterd[header] = ColumnFormatter() formatter = formatterd[header] column = gtk.TreeViewColumn(header, renderer, text=i) renderer.set_property('xalign', formatter.xalign) renderer.set_property('editable', True) renderer.connect("edited", self.position_edited, i) column.connect('clicked', Clicked(self, i)) column.set_property('clickable', True) if formatter.cell is not None: column.set_cell_data_func(renderer, formatter.cell) treeview.append_column(column) self.formatterd = formatterd self.lastcol = column self.add(treeview) self.treeview = treeview self.clear()
def configure(self, widget, data=None): ui = {} dbox = gtk.Dialog(_("Custom Commands Configuration"), None, gtk.DIALOG_MODAL, (gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT, gtk.STOCK_OK, gtk.RESPONSE_ACCEPT)) icon_theme = gtk.icon_theme_get_default() if icon_theme.lookup_icon('terminator-custom-commands', 48, 0): dbox.set_icon_name('terminator-custom-commands') else: dbg('Unable to load Terminator custom command icon') icon = dbox.render_icon(gtk.STOCK_DIALOG_INFO, gtk.ICON_SIZE_BUTTON) dbox.set_icon(icon) store = gtk.ListStore(bool, str, str) for command in [ self.cmd_list[key] for key in sorted(self.cmd_list.keys()) ]: store.append( [command['enabled'], command['name'], command['command']]) treeview = gtk.TreeView(store) #treeview.connect("cursor-changed", self.on_cursor_changed, ui) selection = treeview.get_selection() selection.set_mode(gtk.SELECTION_SINGLE) selection.connect("changed", self.on_selection_changed, ui) ui['treeview'] = treeview renderer = gtk.CellRendererToggle() renderer.connect('toggled', self.on_toggled, ui) column = gtk.TreeViewColumn(_("Enabled"), renderer, active=CC_COL_ENABLED) treeview.append_column(column) renderer = gtk.CellRendererText() column = gtk.TreeViewColumn(_("Name"), renderer, text=CC_COL_NAME) treeview.append_column(column) renderer = gtk.CellRendererText() column = gtk.TreeViewColumn(_("Command"), renderer, text=CC_COL_COMMAND) treeview.append_column(column) scroll_window = gtk.ScrolledWindow() scroll_window.set_size_request(500, 250) scroll_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) scroll_window.add_with_viewport(treeview) hbox = gtk.HBox() hbox.pack_start(scroll_window, True, True) dbox.vbox.pack_start(hbox) button_box = gtk.VBox() button = gtk.Button(stock=gtk.STOCK_GOTO_TOP) button_box.pack_start(button, False, True) button.connect("clicked", self.on_goto_top, ui) button.set_sensitive(False) ui['button_top'] = button button = gtk.Button(stock=gtk.STOCK_GO_UP) button_box.pack_start(button, False, True) button.connect("clicked", self.on_go_up, ui) button.set_sensitive(False) ui['button_up'] = button button = gtk.Button(stock=gtk.STOCK_GO_DOWN) button_box.pack_start(button, False, True) button.connect("clicked", self.on_go_down, ui) button.set_sensitive(False) ui['button_down'] = button button = gtk.Button(stock=gtk.STOCK_GOTO_LAST) button_box.pack_start(button, False, True) button.connect("clicked", self.on_goto_last, ui) button.set_sensitive(False) ui['button_last'] = button button = gtk.Button(stock=gtk.STOCK_NEW) button_box.pack_start(button, False, True) button.connect("clicked", self.on_new, ui) ui['button_new'] = button button = gtk.Button(stock=gtk.STOCK_EDIT) button_box.pack_start(button, False, True) button.set_sensitive(False) button.connect("clicked", self.on_edit, ui) ui['button_edit'] = button button = gtk.Button(stock=gtk.STOCK_DELETE) button_box.pack_start(button, False, True) button.connect("clicked", self.on_delete, ui) button.set_sensitive(False) ui['button_delete'] = button hbox.pack_start(button_box, False, True) dbox.show_all() res = dbox.run() if res == gtk.RESPONSE_ACCEPT: self.update_cmd_list(store) self._save_config() dbox.destroy() return
def __init__(self, parent, application): SettingsPage.__init__(self, parent, application, 'display', _('Display')) notebook = gtk.Notebook() # main window options label_main_window = gtk.Label(_('Main window')) vbox_main_window = gtk.VBox(False, 0) vbox_main_window.set_border_width(5) self._checkbox_hide_on_close = gtk.CheckButton(_('Hide main window on close')) self._checkbox_multiple_instances = gtk.CheckButton(_('Allow multiple instances')) self._checkbox_show_toolbar = gtk.CheckButton(_('Show toolbar')) self._checkbox_show_command_bar = gtk.CheckButton(_('Show command bar')) self._checkbox_show_command_entry = gtk.CheckButton(_('Show command entry')) self._checkbox_hide_on_close.connect('toggled', self._parent.enable_save, True) self._checkbox_multiple_instances.connect('toggled', self._parent.enable_save, True) self._checkbox_show_toolbar.connect('toggled', self._parent.enable_save) self._checkbox_show_command_bar.connect('toggled', self._parent.enable_save) self._checkbox_show_command_entry.connect('toggled', self._parent.enable_save) # tab options label_tabs = gtk.Label(_('Tabs')) vbox_tabs = gtk.VBox(False, 0) vbox_tabs.set_border_width(5) self._checkbox_focus_new_tab = gtk.CheckButton(_('Focus new tab after opening')) self._checkbox_button_relief = gtk.CheckButton(_('Show normal button relief')) self._checkbox_button_icons = gtk.CheckButton(_('Show icons instead of text in tab buttons')) self._checkbox_tab_close_button = gtk.CheckButton(_('Show close button')) self._checkbox_always_show_tabs = gtk.CheckButton(_('Show tab(s) even if there is only one')) self._checkbox_ubuntu_coloring = gtk.CheckButton(_('Use Ubuntu coloring method for tab title bars')) self._checkbox_superuser_notification = gtk.CheckButton(_('Change title bar color when started as super user')) self._checkbox_focus_new_tab.connect('toggled', self._parent.enable_save) self._checkbox_button_relief.connect('toggled', self._parent.enable_save) self._checkbox_button_icons.connect('toggled', self._parent.enable_save, True) self._checkbox_tab_close_button.connect('toggled', self._parent.enable_save) self._checkbox_always_show_tabs.connect('toggled', self._parent.enable_save) self._checkbox_ubuntu_coloring.connect('toggled', self._parent.enable_save) self._checkbox_superuser_notification.connect('toggled', self._parent.enable_save) # status bar table = gtk.Table(2, 2, False) table.set_col_spacing(0, 5) table.set_row_spacings(5) label_status_bar = gtk.Label(_('Show status bar:')) label_status_bar.set_alignment(0, 0.5) list_status_bar = gtk.ListStore(str, int) list_status_bar.append((_('Always'), StatusVisible.ALWAYS)) list_status_bar.append((_('When needed'), StatusVisible.WHEN_NEEDED)) list_status_bar.append((_('Never'), StatusVisible.NEVER)) cell_status_bar = gtk.CellRendererText() self._combobox_status_bar = gtk.ComboBox(list_status_bar) self._combobox_status_bar.connect('changed', self._parent.enable_save) self._combobox_status_bar.pack_start(cell_status_bar) self._combobox_status_bar.add_attribute(cell_status_bar, 'text', 0) # expand tabs label_expand_tab = gtk.Label(_('Expanded tabs:')) label_expand_tab.set_alignment(0, 0.5) list_expand_tab = gtk.ListStore(str, int) list_expand_tab.append((_('None'), TabExpand.NONE)) list_expand_tab.append((_('Active'), TabExpand.ACTIVE)) list_expand_tab.append((_('All'), TabExpand.ALL)) cell_expand_tab = gtk.CellRendererText() self._combobox_expand_tabs = gtk.ComboBox(list_expand_tab) self._combobox_expand_tabs.connect('changed', self._parent.enable_save) self._combobox_expand_tabs.pack_start(cell_expand_tab) self._combobox_expand_tabs.add_attribute(cell_expand_tab, 'text', 0) # other options label_other = gtk.Label(_('Other')) vbox_other = gtk.VBox(False, 0) vbox_other.set_border_width(5) self._checkbox_hide_window_on_minimize = gtk.CheckButton(_('Hide operation window on minimize')) self._checkbox_show_notifications = gtk.CheckButton(_('Show notifications')) self._checkbox_hide_window_on_minimize.connect('toggled', self._parent.enable_save) self._checkbox_show_notifications.connect('toggled', self._parent.enable_save) # size format hbox_size_format = gtk.HBox(False, 5) label_size_format = gtk.Label(_('Size format:')) label_size_format.set_alignment(0, 0.5) list_size_format = gtk.ListStore(str, int) list_size_format.append((_('Localized'), SizeFormat.LOCAL)) list_size_format.append((_('SI <small>(1 kB = 1000 B)</small>'), SizeFormat.SI)) list_size_format.append((_('IEC <small>(1 KiB = 1024 B)</small>'), SizeFormat.IEC)) cell_size_format = gtk.CellRendererText() self._combobox_size_format = gtk.ComboBox(list_size_format) self._combobox_size_format.connect('changed', self._parent.enable_save) self._combobox_size_format.pack_start(cell_size_format) self._combobox_size_format.add_attribute(cell_size_format, 'markup', 0) # pack ui hbox_size_format.pack_start(label_size_format, False, False, 0) hbox_size_format.pack_start(self._combobox_size_format, False, False, 0) table.attach(label_status_bar, 0, 1, 0, 1, xoptions=gtk.FILL) table.attach(self._combobox_status_bar, 1, 2, 0, 1, xoptions=gtk.FILL) table.attach(label_expand_tab, 0, 1, 1, 2, xoptions=gtk.FILL) table.attach(self._combobox_expand_tabs, 1, 2, 1, 2, xoptions=gtk.FILL) vbox_main_window.pack_start(self._checkbox_hide_on_close, False, False, 0) vbox_main_window.pack_start(self._checkbox_multiple_instances, False, False, 0) vbox_main_window.pack_start(self._checkbox_show_toolbar, False, False, 0) vbox_main_window.pack_start(self._checkbox_show_command_bar, False, False, 0) vbox_main_window.pack_start(self._checkbox_show_command_entry, False, False, 0) vbox_tabs.pack_start(self._checkbox_focus_new_tab, False, False, 0) vbox_tabs.pack_start(self._checkbox_button_relief, False, False, 0) vbox_tabs.pack_start(self._checkbox_button_icons, False, False, 0) vbox_tabs.pack_start(self._checkbox_tab_close_button, False, False, 0) vbox_tabs.pack_start(self._checkbox_always_show_tabs, False, False, 0) vbox_tabs.pack_start(self._checkbox_ubuntu_coloring, False, False, 0) vbox_tabs.pack_start(self._checkbox_superuser_notification, False, False, 0) vbox_tabs.pack_start(table, False, False, 5) vbox_other.pack_start(self._checkbox_hide_window_on_minimize, False, False, 0) vbox_other.pack_start(self._checkbox_show_notifications, False, False, 0) vbox_other.pack_start(hbox_size_format, False, False, 0) notebook.append_page(vbox_main_window, label_main_window) notebook.append_page(vbox_tabs, label_tabs) notebook.append_page(vbox_other, label_other) self.pack_start(notebook, True, True, 0)
def __init__(self, app, torrentHash, data, showDoneColumn): self.app = app self.torrentHash = torrentHash self.torrentData = data self.download = None self.showDoneColumn = showDoneColumn #0: File name typeList = [ gobject.TYPE_STRING, #1: Priority gobject.TYPE_INT, #2: Size gobject.TYPE_INT64, #3: Percent done gobject.TYPE_FLOAT ] self.liststore = gtk.ListStore(*typeList) COLUMN_NAMES = ['File', 'Size', 'Priority'] if showDoneColumn: COLUMN_NAMES += ['Completion'] def format_priority(value): if value == -1: return "" elif value == 0: return "High" elif value == 1: return "Normal" elif value == 2: return "Low" else: log_msg( "Bad priority value for format_priority: %s" % (value), 3) return str(value) def format_size(value): value = float(value) / (1024.0 * 1024.0) if value < 1.0: return "%.2f MB" % (value) return "%.0f MB" % (value) modelfilter, treeview = GTKUtils.make_listview(self.liststore, COLUMN_NAMES) GTKUtils.make_toggle_cell(treeview.columns[0], 1) GTKUtils.make_text_cell(treeview.columns[0], 0) GTKUtils.make_text_cell(treeview.columns[1], 2, format_size) GTKUtils.make_text_cell(treeview.columns[2], 1, format_priority) if showDoneColumn: GTKUtils.make_progress_cell(treeview.columns[3], 3) #make treeview searchable treeview.set_search_column(0) #attach the filtermodel and treeview treeview.set_model(gtk.TreeModelSort(modelfilter)) treeview.connect("row-activated", self.row_activate_cb) treeview.connect("button-press-event", self.button_press_cb) treeview.get_selection().set_mode(gtk.SELECTION_MULTIPLE) self.modelfilter, self.treeview = modelfilter, treeview scrolled_window = GTKUtils.make_scroll_box( self.treeview, hPolicy=gtk.POLICY_AUTOMATIC, vPolicy=gtk.POLICY_AUTOMATIC) scrolled_window.set_size_request(-1, 200) scrolled_window.set_border_width(0) treeview.set_border_width(0) self.container = scrolled_window #now add the actual data: fileList = [] i = self.torrentData['metainfo']['info'] if i.has_key('length'): fileList.append([ self.torrentData['file'].replace(".torrent", ""), self.torrentData['length'] ]) elif i.has_key('files'): for entry in i['files']: folderList = entry['path'] fileList.append([os.path.join(*folderList), entry['length']]) else: raise Exception( "Cannot handle torrent without length or files keys") #stick it in the gui for fileName, size in fileList: #TODO: When you try putting some torrents in here, you get this error message: # C:\Projects\web\innominet\gui\BTDisplay.py:386: PangoWarning: Invalid UTF-8 string passed to pango_layout_set_text() # self.dia.show_all() #tried these, but they didnt work: #fileName = fileName.encode("UTF-8") #fileName = unicode( fileName, "utf-8" ) self.liststore.append([fileName, 1, size, 0.0])
def show(self, node=None, window=None): # TODO: factor out main_window.get_notebook() calls self.main_window = window self.node = node self.xml = gtk.glade.XML( keepnote.gui.get_resource("rc", "keepnote.glade"), "node_icon_dialog", keepnote.GETTEXT_DOMAIN) self.dialog = self.xml.get_widget("node_icon_dialog") self.xml.signal_autoconnect(self) self.dialog.connect("close", lambda w: self.dialog.response(gtk.RESPONSE_CANCEL)) self.dialog.set_transient_for(self.main_window) self.icon_entry = self.xml.get_widget("icon_entry") self.icon_open_entry = self.xml.get_widget("icon_open_entry") self.icon_image = self.xml.get_widget("icon_image") self.icon_open_image = self.xml.get_widget("icon_open_image") self.standard_iconview = self.xml.get_widget("standard_iconview") self.notebook_iconview = self.xml.get_widget("notebook_iconview") self.quick_iconview = self.xml.get_widget("quick_pick_iconview") self.standard_iconlist = gtk.ListStore(gtk.gdk.Pixbuf, str) self.notebook_iconlist = gtk.ListStore(gtk.gdk.Pixbuf, str) self.quick_iconlist = gtk.ListStore(gtk.gdk.Pixbuf, str) self.iconviews = [ self.standard_iconview, self.notebook_iconview, self.quick_iconview] self.iconlists = [ self.standard_iconlist, self.notebook_iconlist, self.quick_iconlist] self.iconview_signals = {} for iconview in self.iconviews: self.iconview_signals[iconview] = \ iconview.connect("selection-changed", self.on_iconview_selection_changed) iconview.connect("item-activated", lambda w,it: self.on_set_icon_button_clicked(w)) if node: self.set_icon("icon", node.get_attr("icon", "")) self.set_icon("icon_open", node.get_attr("icon_open", "")) self.populate_iconview() # run dialog response = self.dialog.run() icon_file = None icon_open_file = None if response == gtk.RESPONSE_OK: # icon filenames icon_file = unicode_gtk(self.icon_entry.get_text()) icon_open_file = unicode_gtk(self.icon_open_entry.get_text()) if icon_file.strip() == u"": icon_file = u"" if icon_open_file.strip() == u"": icon_open_file = u"" self.dialog.destroy() return icon_file, icon_open_file
def display(self): self.top = Glade("changenames.glade") window = self.top.toplevel self.top.connect_signals({ "destroy_passed_object" : self.close, "on_ok_clicked" : self.on_ok_clicked, "on_help_clicked" : self.on_help_clicked, "on_delete_event" : self.close, }) self.list = self.top.get_object("list") self.set_window(window, self.top.get_object('title'), self.label) lbl = self.top.get_object('info') lbl.set_line_wrap(True) lbl.set_text( _('Below is a list of Places with the possible data that can ' 'be extracted from the place title. Select the places you ' 'wish Gramps to convert.')) self.model = gtk.ListStore(gobject.TYPE_BOOLEAN, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING) r = gtk.CellRendererToggle() r.connect('toggled', self.toggled) c = gtk.TreeViewColumn(_('Select'), r, active=0) self.list.append_column(c) for (title, col) in COLS: render = gtk.CellRendererText() if col > 1: render.set_property('editable', True) render.connect('edited', self.__change_name, col) self.list.append_column( gtk.TreeViewColumn(title, render, text=col)) self.list.set_model(self.model) self.iter_list = [] self.progress.set_pass(_('Building display'), len(self.name_list)) for (id, data) in self.name_list: place = self.db.get_place_from_handle(id) descr = place.get_title() handle = self.model.append() self.model.set_value(handle, 0, True) self.model.set_value(handle, 1, descr) if data[0]: self.model.set_value(handle, 2, data[0]) if data[1]: self.model.set_value(handle, 3, data[1]) if data[2]: self.model.set_value(handle, 4, data[2]) if data[3]: self.model.set_value(handle, 5, data[3]) self.model.set_value(handle, 6, id) self.iter_list.append(handle) self.progress.step() self.progress.close() self.show()
def __init__(self, config, client, artwork, TAB_LIBRARY, album_filename, settings_save, filtering_entry_make_red, filtering_entry_revert_color, filter_key_pressed, on_add_item, parse_formatting, connected, on_library_button_press, on_library_search_text_click, new_tab): self.artwork = artwork self.config = config self.client = client self.librarymenu = None # cyclic dependency, set later self.album_filename = album_filename self.settings_save = settings_save self.filtering_entry_make_red = filtering_entry_make_red self.filtering_entry_revert_color = filtering_entry_revert_color self.filter_key_pressed = filter_key_pressed self.on_add_item = on_add_item self.parse_formatting = parse_formatting self.connected = connected self.on_library_button_press = on_library_button_press self.on_library_search_text_click = on_library_search_text_click self.NOTAG = _("Untagged") self.VAstr = _("Various Artists") self.search_terms = [_('Artist'), _('Title'), _('Album'), _('Genre'), _('Filename'), _('Everything')] self.search_terms_mpd = ['artist', 'title', 'album', 'genre', 'file', 'any'] self.VIEW_FILESYSTEM_STR = _("Filesystem") self.VIEW_ARTIST_STR = _("Artists") self.VIEW_ALBUM_STR = _("Albums") self.VIEW_GENRE_STR = _("Genres") self.libfilterbox_cmd_buf = None self.libfilterbox_cond = None self.libfilterbox_source = None self.prevlibtodo_base = None self.prevlibtodo_base_results = None self.prevlibtodo = None self.save_timeout = None self.libsearch_last_tooltip = None self.lib_view_filesystem_cache = None self.lib_view_artist_cache = None self.lib_view_genre_cache = None self.lib_view_album_cache = None self.lib_list_genres = None self.lib_list_artists = None self.lib_list_albums = None self.lib_list_years = None self.view_caches_reset() self.libraryvbox = gtk.VBox() self.library = ui.treeview() self.library_selection = self.library.get_selection() expanderwindow2 = ui.scrollwindow(add=self.library) self.searchbox = gtk.HBox() self.searchcombo = ui.combo(items=self.search_terms) self.searchcombo.set_tooltip_text(_("Search terms")) self.searchtext = ui.entry() self.searchtext.set_tooltip_text(_("Search library")) self.searchbutton = ui.button(img=ui.image(stock=gtk.STOCK_CANCEL), h=self.searchcombo.size_request()[1]) self.searchbutton.set_no_show_all(True) self.searchbutton.hide() self.searchbutton.set_tooltip_text(_("End Search")) self.libraryview = ui.button(relief=gtk.RELIEF_NONE) self.libraryview.set_tooltip_text(_("Library browsing view")) self.library_view_assign_image() self.searchbox.pack_start(self.libraryview, False, False, 1) self.searchbox.pack_start(gtk.VSeparator(), False, False, 2) self.searchbox.pack_start(ui.label(_("Search") + ":"), False, False, 3) self.searchbox.pack_start(self.searchtext, True, True, 2) self.searchbox.pack_start(self.searchcombo, False, False, 2) self.searchbox.pack_start(self.searchbutton, False, False, 2) self.libraryvbox.pack_start(expanderwindow2, True, True) self.libraryvbox.pack_start(self.searchbox, False, False, 2) self.tab = new_tab(self.libraryvbox, gtk.STOCK_HARDDISK, TAB_LIBRARY, self.library) # Assign some pixbufs for use in self.library self.openpb = self.library.render_icon(gtk.STOCK_OPEN, gtk.ICON_SIZE_LARGE_TOOLBAR) self.harddiskpb = self.library.render_icon(gtk.STOCK_HARDDISK, gtk.ICON_SIZE_LARGE_TOOLBAR) self.albumpb = gtk.gdk.pixbuf_new_from_file_at_size(album_filename, consts.LIB_COVER_SIZE, consts.LIB_COVER_SIZE) self.genrepb = self.library.render_icon('gtk-orientation-portrait', gtk.ICON_SIZE_LARGE_TOOLBAR) self.artistpb = self.library.render_icon('artist', gtk.ICON_SIZE_LARGE_TOOLBAR) self.sonatapb = self.library.render_icon('sonata', gtk.ICON_SIZE_MENU) self.library.connect('row_activated', self.on_library_row_activated) self.library.connect('button_press_event', self.on_library_button_press) self.library.connect('key-press-event', self.on_library_key_press) self.library.connect('query-tooltip', self.on_library_query_tooltip) expanderwindow2.connect('scroll-event', self.on_library_scrolled) self.libraryview.connect('clicked', self.library_view_popup) self.searchtext.connect('button_press_event', self.on_library_search_text_click) self.searchtext.connect('key-press-event', self.libsearchfilter_key_pressed) self.searchtext.connect('activate', self.libsearchfilter_on_enter) self.searchbutton.connect('clicked', self.on_search_end) self.libfilter_changed_handler = self.searchtext.connect('changed', self.libsearchfilter_feed_loop) searchcombo_changed_handler = self.searchcombo.connect('changed', self.on_library_search_combo_change) # Initialize library data and widget self.libraryposition = {} self.libraryselectedpath = {} self.searchcombo.handler_block(searchcombo_changed_handler) self.searchcombo.set_active(self.config.last_search_num) self.searchcombo.handler_unblock(searchcombo_changed_handler) self.librarydata = gtk.ListStore(gtk.gdk.Pixbuf, gobject.TYPE_PYOBJECT, str) self.library.set_model(self.librarydata) self.library.set_search_column(2) self.librarycell = gtk.CellRendererText() self.librarycell.set_property("ellipsize", pango.ELLIPSIZE_END) self.libraryimg = gtk.CellRendererPixbuf() self.librarycolumn = gtk.TreeViewColumn() self.librarycolumn.pack_start(self.libraryimg, False) self.librarycolumn.pack_start(self.librarycell, True) self.librarycolumn.set_attributes(self.libraryimg, pixbuf=0) self.librarycolumn.set_attributes(self.librarycell, markup=2) self.librarycolumn.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE) self.library.append_column(self.librarycolumn) self.library_selection.set_mode(gtk.SELECTION_MULTIPLE)
def __init__(self, config, column_names, widths, on_apply, tree=False): """ Create the Column Ordering widget based on config config: a configuration file with column data column_names: translated names for the possible columns widths: the widths of the visible columns on_apply: function to run when apply is clicked tree: are the columns for a treeview, if so, the first columns is not changable """ gtk.VBox.__init__(self) self.treeview = tree self.colnames = column_names self.config = config self.on_apply = on_apply self.pack_start(gtk.Label(' '), expand=False, fill=False) self.startrow = 0 if self.treeview: label = gtk.Label( _('Tree View: first column "%s" cannot be changed') % column_names[0]) self.startrow = 1 self.pack_start(label, expand=False, fill=False) self.pack_start(gtk.Label(' '), expand=False, fill=False) self.pack_start(gtk.Label(_('Drag and drop the columns to change' ' the order')), expand=False, fill=False) self.pack_start(gtk.Label(' '), expand=False, fill=False) hbox = gtk.HBox() hbox.set_spacing(10) hbox.pack_start(gtk.Label(' ')) scroll = gtk.ScrolledWindow() scroll.set_size_request(300,300) hbox.pack_start(scroll) self.tree = gtk.TreeView() self.tree.set_reorderable(True) scroll.add(self.tree) self.apply_button = gtk.Button(stock='gtk-apply') btns = gtk.HButtonBox() btns.set_layout(gtk.BUTTONBOX_END) btns.pack_start(self.apply_button) hbox.pack_start(btns, expand=False) self.pack_start(hbox) #Model holds: # bool: column visible or not # str : name of the column # int : order of the column # int : size (width) of the column self.model = gtk.ListStore(gobject.TYPE_BOOLEAN, gobject.TYPE_STRING, gobject.TYPE_INT, gobject.TYPE_INT) self.tree.set_model(self.model) checkbox = gtk.CellRendererToggle() checkbox.connect('toggled', toggled, self.model) renderer = gtk.CellRendererText() column_n = gtk.TreeViewColumn(_('Display'), checkbox, active=0) column_n.set_min_width(50) self.tree.append_column(column_n) column_n = gtk.TreeViewColumn(_('Column Name'), renderer, text=1) column_n.set_min_width(225) self.tree.append_column(column_n) self.apply_button.connect('clicked', self.__on_apply) #obtain the columns from config file self.oldorder = self.config.get('columns.rank') self.oldsize = self.config.get('columns.size') self.oldvis = self.config.get('columns.visible') colord = [] index = 0 for val, size in zip(self.oldorder, self.oldsize): if val in self.oldvis: size = widths[index] index += 1 colord.append((1, val, size)) else: colord.append((0, val, size)) for item in colord[self.startrow:]: node = self.model.append() self.model.set(node, 0, item[0], 1, column_names[item[1]], 2, item[1], 3, item[2])
def __init__(self, parent, deputies, groups, initial_cmd="", initial_deputy=None, initial_group=""): # add command dialog gtk.Dialog.__init__(self, "Add/Modify Command", parent, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, (gtk.STOCK_OK, gtk.RESPONSE_ACCEPT, gtk.STOCK_CANCEL, gtk.RESPONSE_REJECT)) table = gtk.Table(3, 2) # deputy table.attach(gtk.Label("Host"), 0, 1, 0, 1, 0, 0) self.deputy_ls = gtk.ListStore(gobject.TYPE_PYOBJECT, gobject.TYPE_STRING) self.host_cb = gtk.ComboBox(self.deputy_ls) dep_ind = 0 pairs = [(deputy.name, deputy) for deputy in deputies] pairs.sort() for name, deputy in pairs: self.deputy_ls.append((deputy, deputy.name)) if deputy == initial_deputy: self.host_cb.set_active(dep_ind) dep_ind += 1 if self.host_cb.get_active() < 0 and len(deputies) > 0: self.host_cb.set_active(0) deputy_tr = gtk.CellRendererText() self.host_cb.pack_start(deputy_tr, True) self.host_cb.add_attribute(deputy_tr, "text", 1) table.attach(self.host_cb, 1, 2, 0, 1) self.deputies = deputies # command name table.attach(gtk.Label("Name"), 0, 1, 1, 2, 0, 0) self.name_te = gtk.Entry() self.name_te.set_text(initial_cmd) self.name_te.set_width_chars(40) table.attach(self.name_te, 1, 2, 1, 2) self.name_te.connect("activate", lambda e: self.response(gtk.RESPONSE_ACCEPT)) self.name_te.grab_focus() # group table.attach(gtk.Label("Group"), 0, 1, 2, 3, 0, 0) self.group_cbe = gtk.combo_box_entry_new_text() groups = groups[:] groups.sort() for group_name in groups: self.group_cbe.append_text(group_name) table.attach(self.group_cbe, 1, 2, 2, 3) self.group_cbe.child.set_text(initial_group) self.group_cbe.child.connect( "activate", lambda e: self.response(gtk.RESPONSE_ACCEPT)) self.vbox.pack_start(table, False, False, 0) table.show_all()
def addGrid(self, vbox, query, flags, playerids, sitenos, limits, type, seats, groups, dates, games, currencies): counter = 0 row = 0 sqlrow = 0 if not flags: holecards, grid = False, 0 else: holecards, grid = flags[0], flags[2] tmp = self.sql.query[query] tmp = self.refineQuery(tmp, flags, playerids, sitenos, limits, type, seats, groups, dates, games, currencies) #print "DEBUG: query: %s" % tmp self.cursor.execute(tmp) result = self.cursor.fetchall() colnames = [desc[0].lower() for desc in self.cursor.description] # pre-fetch some constant values: colshow = colshowsumm if groups['posn']: colshow = colshowposn self.cols_to_show = [x for x in self.columns if x[colshow]] hgametypeid_idx = colnames.index('hgametypeid') assert len(self.liststore) == grid, "len(self.liststore)=" + str( len(self.liststore)) + " grid-1=" + str(grid) self.liststore.append(gtk.ListStore(*([str] * len(self.cols_to_show)))) view = gtk.TreeView(model=self.liststore[grid]) view.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH) #vbox.pack_start(view, expand=False, padding=3) vbox.add(view) textcell = gtk.CellRendererText() textcell50 = gtk.CellRendererText() textcell50.set_property('xalign', 0.5) numcell = gtk.CellRendererText() numcell.set_property('xalign', 1.0) assert len(self.listcols) == grid self.listcols.append([]) # Create header row eg column: ("game", True, "Game", 0.0, "%s") for col, column in enumerate(self.cols_to_show): if column[colalias] == 'game' and holecards: s = [x for x in self.columns if x[colalias] == 'hand'][0][colheading] else: s = column[colheading] self.listcols[grid].append(gtk.TreeViewColumn(s)) view.append_column(self.listcols[grid][col]) if column[colformat] == '%s': if column[colxalign] == 0.0: self.listcols[grid][col].pack_start(textcell, expand=True) self.listcols[grid][col].add_attribute( textcell, 'text', col) cellrend = textcell else: self.listcols[grid][col].pack_start(textcell50, expand=True) self.listcols[grid][col].add_attribute( textcell50, 'text', col) cellrend = textcell50 self.listcols[grid][col].set_expand(True) else: self.listcols[grid][col].pack_start(numcell, expand=True) self.listcols[grid][col].add_attribute(numcell, 'text', col) self.listcols[grid][col].set_expand(True) cellrend = numcell #self.listcols[grid][col].set_alignment(column[colxalign]) # no effect? self.listcols[grid][col].set_clickable(True) self.listcols[grid][col].connect("clicked", self.sortcols, (col, grid)) if col == 0: self.listcols[grid][col].set_sort_order(gtk.SORT_DESCENDING) self.listcols[grid][col].set_sort_indicator(True) if column[coltype] == 'cash': self.listcols[grid][col].set_cell_data_func( numcell, self.ledger_style_render_func) else: self.listcols[grid][col].set_cell_data_func( cellrend, self.reset_style_render_func) rows = len(result) # +1 for title row while sqlrow < rows: treerow = [] for col, column in enumerate(self.cols_to_show): if column[colalias] in colnames: value = result[sqlrow][colnames.index(column[colalias])] if column[colalias] == 'plposition': if value == 'B': value = 'BB' elif value == 'S': value = 'SB' elif value == '0': value = 'Btn' else: if column[colalias] == 'game': if holecards: value = Card.decodeStartHandValue( result[sqlrow][colnames.index('category')], result[sqlrow][hgametypeid_idx]) else: minbb = result[sqlrow][colnames.index( 'minbigblind')] maxbb = result[sqlrow][colnames.index( 'maxbigblind')] value = result[sqlrow][colnames.index('limittype')] + ' ' \ + result[sqlrow][colnames.index('category')].title() + ' ' \ + result[sqlrow][colnames.index('name')] + ' $' if 100 * int(minbb / 100.0) != minbb: value += '%.2f' % (minbb / 100.0) else: value += '%.0f' % (minbb / 100.0) if minbb != maxbb: if 100 * int(maxbb / 100.0) != maxbb: value += ' - $' + '%.2f' % (maxbb / 100.0) else: value += ' - $' + '%.0f' % (maxbb / 100.0) if result[sqlrow][colnames.index('fast')] == 1: value += ' ' + fast_names[result[sqlrow][ colnames.index('name')]] else: continue if value != None and value != -999: treerow.append(column[colformat] % value) else: treerow.append(' ') iter = self.liststore[grid].append(treerow) #print treerow sqlrow += 1 row += 1 tips = DemoTips(column[colformat]) tips.add_view(view) vbox.show_all() view.show() if len(self.liststore) == 1: #print "view hieght is ", view.get_allocation().height, view.size_request(), view.get_visible_rect().height, view.get_vadjustment().get_value() self.top_pane_height = view.size_request()[1]
def lang_treeview(self): treeview = self.widgets['add']['lang_treeview'] self.lang['model'] = gtk.TreeStore(str, str, str, str, str) treeview.set_model(self.lang['model']) treeview.set_headers_visible(True) model = self.lang['lang'] = gtk.ListStore(int, str) for i in self.db.session.query(db.Lang.lang_id, db.Lang.name).all(): model.append([i.lang_id, i.name]) combo = gtk.CellRendererCombo() combo.set_property('model', model) combo.set_property('text-column', 1) combo.set_property('editable', True) combo.set_property('has-entry', False) combo.connect('edited', self.on_tv_lang_combo_edited, 0) column = gtk.TreeViewColumn(_('Language'), combo, text=0) column.set_property('min-width', 80) column.set_property('resizable', True) column.set_sort_column_id(0) treeview.append_column(column) model = self.lang['type'] = gtk.ListStore(int, str) #i = 0 #for lang_type in self._lang_types: # model.append([i, lang_type]) # i += 1 model.append([0, '']) model.append([1, _('lector')]) model.append([2, _('dubbing')]) model.append([3, _('subtitles')]) model.append([4, _("commentary")]) combo = gtk.CellRendererCombo() combo.set_property('model', model) combo.set_property('text-column', 1) combo.set_property('editable', True) combo.set_property('has-entry', False) combo.connect('edited', self.on_tv_lang_combo_edited, 1) column = gtk.TreeViewColumn(_('Type'), combo, text=1) column.set_property('min-width', 80) column.set_property('resizable', True) column.set_sort_column_id(1) treeview.append_column(column) model = self.lang['acodec'] = gtk.ListStore(int, str) for i in self.db.session.query(db.ACodec.acodec_id, db.ACodec.name).all(): model.append([i.acodec_id, i.name]) combo = gtk.CellRendererCombo() combo.set_property('model', model) combo.set_property('text-column', 1) combo.set_property('editable', True) combo.set_property('has-entry', False) combo.connect('edited', self.on_tv_lang_combo_edited, 2) column = gtk.TreeViewColumn(_('Codec'), combo, text=2) column.set_property('min-width', 80) column.set_property('resizable', True) column.set_sort_column_id(2) treeview.append_column(column) model = self.lang['achannel'] = gtk.ListStore(int, str) for i in self.db.session.query(db.AChannel.achannel_id, db.AChannel.name).all(): model.append([i.achannel_id, i.name]) combo = gtk.CellRendererCombo() combo.set_property('model', model) combo.set_property('text-column', 1) combo.set_property('editable', True) combo.set_property('has-entry', False) combo.connect('edited', self.on_tv_lang_combo_edited, 3) column = gtk.TreeViewColumn(_('Channels'), combo, text=3) column.set_property('min-width', 80) column.set_property('resizable', True) column.set_sort_column_id(3) treeview.append_column(column) model = self.lang['subformat'] = gtk.ListStore(int, str) for i in self.db.session.query(db.SubFormat.subformat_id, db.SubFormat.name).all(): model.append([i.subformat_id, i.name]) combo = gtk.CellRendererCombo() combo.set_property('model', model) combo.set_property('text-column', 1) combo.set_property('editable', True) combo.set_property('has-entry', False) combo.connect('edited', self.on_tv_lang_combo_edited, 4) column = gtk.TreeViewColumn(_('Subtitle format'), combo, text=4) column.set_property('min-width', 80) column.set_property('resizable', True) column.set_sort_column_id(4) treeview.append_column(column) treeview.show_all()
def __init__(self, host_window, progressbar, summary, status, expander, cancel_button, treeview, vb_details, scrolled, parent): BackendProgressHandlerObject.__init__(self) self._mode = self.MODE.HIDDEN self._scrolled = scrolled self._summary = summary self._progressbar = progressbar self._status = status self._parent = parent self._treeview = treeview self._expander = expander self._vb_details = vb_details self._cancel_button = cancel_button self._window = host_window self._store = gtk.ListStore(int, str, str, int, int) self._treeview.set_model(self._store) self._treeview.set_headers_clickable(False) self._download_size = 0 self._package_count = 0 self._download_count = 0 self._packages_finished = 0 self._installed_count = 0 self._cur_install_package = None self._expander.connect("notify::expanded", self._expander_toggled) # List columns progress_renderer = gtk.CellRendererProgress() column_progress = gtk.TreeViewColumn(_("Progress"), progress_renderer) column_progress.set_cell_data_func(progress_renderer, self._progress_col_data_func) column_source = gtk.TreeViewColumn(_("Source"), gtk.CellRendererText(), markup=self.LIST_COL.SOURCE) column_file = gtk.TreeViewColumn(_("File name"), gtk.CellRendererText(), markup=self.LIST_COL.FILE_NAME) partial_renderer = gtk.CellRendererText() column_partial = gtk.TreeViewColumn(_("Downloaded"), partial_renderer) column_partial.set_cell_data_func(partial_renderer, self._partial_col_data_func) size_renderer = gtk.CellRendererText() column_size = gtk.TreeViewColumn(_("Size"), size_renderer) column_size.set_cell_data_func(size_renderer, self._size_col_data_func) self._treeview.append_column(column_progress) self._treeview.append_column(column_source) self._treeview.append_column(column_file) self._treeview.append_column(column_partial) self._treeview.append_column(column_size) self._window.set_title(_('Checking for updates')) self._status.set_markup('') self._window.realize() self._window.window.set_functions(gtk.gdk.FUNC_MOVE | gtk.gdk.FUNC_RESIZE) self._window.set_transient_for(parent.window_main) self._finish_event = threading.Event() self._finish_event.clear() self._store_map = {} self._terminal = vte.Terminal() self._current_items = {} # Connect list signals self.connect("list_begin", self._sig_list_begin) self.connect("list_finished", self._sig_list_finished) self.connect("list_aborted", self._sig_list_aborted) self.connect("list_failed", self._sig_list_failed) self.connect("list_update", self._sig_list_update) self.connect("list_item_update", self._sig_item_update) self.connect("list_item_finished", self._sig_item_finished) # Connect download signals self.connect('download_begin', self._sig_download_begin) self.connect('download_update', self._sig_download_update) self.connect('download_finished', self._sig_download_finished) self.connect('download_aborted', self._sig_download_aborted) self.connect('download_failed', self._sig_download_failed) self.connect('download_item_finished', self._sig_item_finished) self.connect('download_item_update', self._sig_item_update) # Connect install signals self.connect('preparation_begin', self._sig_preparation_begin) self.connect('requires_removal_or_installation', self._sig_removal_or_install) self.connect('install_begin', self._sig_install_begin) self.connect('install_finished', self._sig_install_finished) self.connect('install_failed', self._sig_install_failed) self.connect('install_update', self._sig_install_update) self._cancel_button.connect("clicked", self._sig_cancel_clicked) self._change_mode(reload_cache=False)