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)
