def __init__(self,
columns,
column_types,
rows,
box,
default_size=(380, 200)):
assert len(columns) == (len(column_types) - 1)
if (len(rows) > 0) and (len(rows[0]) != len(column_types)):
raise RuntimeError("Wrong number of rows:\n%s" % str(rows[0]))
import gtk
self.liststore = gtk.ListStore(*column_types)
self.listmodel = gtk.TreeModelSort(self.liststore)
self.listctrl = gtk.TreeView(self.listmodel)
self.listctrl.column = [None] * len(columns)
self.listctrl.cell = [None] * len(columns)
for i, column_label in enumerate(columns):
cell = gtk.CellRendererText()
column = gtk.TreeViewColumn(column_label)
self.listctrl.append_column(column)
column.set_sort_column_id(i)
column.pack_start(cell, True)
column.set_attributes(cell, text=i)
self.listctrl.get_selection().set_mode(gtk.SELECTION_SINGLE)
for row in rows:
self.listmodel.get_model().append(row)
self.listctrl.connect("cursor-changed", self.OnChange)
sw = gtk.ScrolledWindow()
w, h = default_size
if len(rows) > 10:
sw.set_size_request(w, h)
else:
sw.set_size_request(w, 30 + (20 * len(rows)))
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
box.pack_start(sw, False, False, 5)
inside_vbox = gtk.VBox(False, 0)
sw.add(self.listctrl)
def __init__(self, store):
assert isinstance(store, _snapshot_store)
self.store = store
self.sorted_store = gtk.TreeModelSort(self.store)
self.sorted_store.set_sort_func(1000, self.store.sort_by_time)
self.sorted_store.set_sort_column_id(1000, gtk.SORT_DESCENDING)
r_time = gtk.CellRendererText()
r_comment = gtk.CellRendererText()
r_comment.set_property('editable', True)
r_comment.connect('edited', self.r_comment_edited)
c_date = gtk.TreeViewColumn()
c_date.set_title(_('Date'))
c_date.pack_start(r_time, False)
c_date.set_cell_data_func(r_time, self.r_time_cell_function)
c_date.set_sort_column_id(1000)
c_comment = gtk.TreeViewColumn()
c_comment.set_title(_('Comment'))
c_comment.pack_start(r_comment)
c_comment.set_cell_data_func(r_comment, self.r_comment_cell_function)
view = self.view = gtk.TreeView(self.sorted_store)
view.set_rules_hint(True)
view.append_column(c_date)
view.append_column(c_comment)
view.get_selection().set_mode(gtk.SELECTION_SINGLE)
view.get_selection().connect('changed', self.row_selected, view)
view.set_tooltip_text(_('Double click to edit comment'))
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll.set_shadow_type(gtk.SHADOW_ETCHED_IN)
scroll.add(view)
scroll.set_size_request(300, -1)
gtk.VBox.__init__(self, False, 5)
self.pack_start(gtk.Label(_('snapshots')), False)
self.pack_start(scroll)
def init_page_1(self):
self.menu_items = []
self.fields1 = self.xml.get_object('f_list_1')
rend = gtk.CellRendererText()
col = gtk.TreeViewColumn(_('Name'), rend, text=0)
self.fields1.append_column(col)
rend = gtk.CellRendererText()
col = gtk.TreeViewColumn(_('Type'), rend, text=1)
self.fields1.append_column(col)
self.fm = gtk.ListStore(str, str, str, object)
self.sfm = gtk.TreeModelSort(self.fm)
self.sfm.set_sort_column_id(2, gtk.SORT_ASCENDING)
self.fields1.set_model(self.sfm)
self.s1 = self.fields1.get_selection()
self.s1.connect('changed', self.list_1_select)
self.fields = copy.copy(Config.get('base/fields').data)
for key, item in self.fields.iteritems():
self.fm.append((item.name, _typename[item.type], key, item))
self.name1 = self.xml.get_object('name1')
self.menu1 = self.xml.get_object('type1')
name_store = gtk.ListStore(str, object)
for k, v in sorted(_typename.items(), key=lambda x: x[1]):
name_store.append([v, k])
self.menu1.set_model(name_store)
self.menu1.set_entry_text_column(0)
renderer_text = gtk.CellRendererText()
self.menu1.pack_start(renderer_text, True)
self.menu1.add_attribute(renderer_text, 'text', 0)
self.menu1.set_active(0)
self.menu_items = [x[1] for x in name_store]
self.current_menu = self.menu_items[0]
self.check()
def __init__(self, stats=None):
super(ProfilerTab, self).__init__()
toolbar = gtk.HBox(spacing=6)
self.pack_start(toolbar, expand=False, fill=True)
self.model = ProfileModel(stats)
self.profile = not stats and Profile()
toggle = gtk.ToggleButton(gtk.STOCK_MEDIA_RECORD)
toggle.set_use_stock(True)
toggle.set_active(False)
toggle.set_sensitive(bool(self.profile))
toggle.connect('toggled', self.__toggle)
toolbar.pack_start(toggle, expand=False)
if not self.profile:
toggle.set_tooltip_text(
_("Loaded profiles cannot resume recording."))
filtered = self.model.filter_new()
align = gtk.Alignment(xscale=1.0, yscale=1.0)
align.set_padding(0, 0, 6, 0)
label = gtk.Label()
self.entry = FilterEntry(filtered)
label.set_mnemonic_widget(self.entry)
label.set_text_with_mnemonic(_("_Filter:"))
try: self.view = HintedTreeView(gtk.TreeModelSort(filtered))
except NameError: self.view = gtk.TreeView(gtk.TreeModelSort(filtered))
self.view.connect('row-activated', self.__open_to_line)
self.view.set_enable_search(True)
self.view.set_search_equal_func(self.model.matches)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
sw.set_shadow_type(gtk.SHADOW_IN)
sw.add(self.view)
box = gtk.HBox(spacing=3)
box.pack_start(label, expand=False)
box.pack_start(self.entry)
align.add(box)
self.pack_start(sw, expand=True)
toolbar.pack_start(align)
cell = gtk.CellRendererText()
cell.props.ellipsize = pango.ELLIPSIZE_MIDDLE
column = gtk.TreeViewColumn(_("Filename"), cell)
column.add_attribute(cell, 'text', 1)
column.set_sort_column_id(1)
column.set_resizable(True)
column.set_expand(True)
self.view.append_column(column)
column = gtk.TreeViewColumn(_("Function"), cell)
column.add_attribute(cell, 'text', 2)
column.set_sort_column_id(2)
column.set_resizable(True)
column.set_expand(True)
self.view.append_column(column)
cell = gtk.CellRendererText()
column = gtk.TreeViewColumn(_("Call #"), cell)
column.add_attribute(cell, 'text', 4)
column.set_sort_column_id(4)
self.view.append_column(column)
column = gtk.TreeViewColumn(_("Total"), cell)
column.add_attribute(cell, 'text', 6)
column.set_sort_column_id(6)
self.view.append_column(column)
column = gtk.TreeViewColumn(_("Inline"), cell)
column.add_attribute(cell, 'text', 7)
column.set_sort_column_id(7)
self.view.append_column(column)
self.totalstats = gtk.Statusbar()
self.pack_start(self.totalstats, expand=False)
self.entry.grab_focus()
self.running = False
self.connect('destroy', self.__on_destroy)
def __init__(self,
path="AddEffect.ui",
root="frmAddEffect",
domain="LibreShot",
parent=None,
form=None,
project=None,
**kwargs):
SimpleGtkBuilderApp.__init__(self, os.path.join(project.UI_DIR, path),
root, domain, **kwargs)
# Add language support
_ = Language_Init.Translator(project).lang.gettext
self.form = form
self.project = project
self.parent = parent
EFFECTS_DIR = self.project.EFFECTS_DIR
# Init Dropdown and model
# create a ListStore
self.store = gtk.ListStore(gtk.gdk.Pixbuf, str)
self.sort_model = gtk.TreeModelSort(self.store)
# Sort Effects ListStore
self.sort_model.set_sort_column_id(1, gtk.SORT_ASCENDING)
# Set the treeview's data model
self.cboEffects.set_model(self.sort_model)
# Init List of Effects
effect_list = self.form.effect_list
# Add effects to dropdown
sorted_list = []
for my_effect in effect_list:
# is frei0r effect library installed?
if self.form.has_frei0r_installed == False and my_effect.service.startswith(
"frei0r"):
# frei0r not installed, and this is a frei0r effect
# skip to next item in loop
continue
# does the frei0r installation include this effect?
if my_effect.service.startswith("frei0r"):
if my_effect.service not in self.form.filters:
# don't add this effect, skip to the next one
continue
# get image for filter
file_path = os.path.join(EFFECTS_DIR, "icons", "small",
my_effect.icon)
# get the pixbuf
pbThumb = gtk.gdk.pixbuf_new_from_file(file_path)
# add effect to tree
item = self.store.append(None)
self.store.set_value(item, 0, pbThumb)
self.store.set_value(item, 1, _(my_effect.title))
# show all controls
self.frmAddEffect.show_all()
def set_layout(self):
self.listore_model = ListoreModel()
self.modelsort = gtk.TreeModelSort(self.listore_model)
self.notify_store = Notify_Store(self.modelsort)
self.text_buffer = gtk.TextBuffer()
self.text_view = gtk.TextView(buffer=self.text_buffer)
self.text_view.set_editable(False)
self.text_view.set_wrap_mode(gtk.WRAP_WORD)
self.text_view.set_justification(gtk.JUSTIFY_FILL)
self.text_view.set_pixels_above_lines(5)
self.text_view.set_pixels_below_lines(15)
self.text_view.set_pixels_inside_wrap(5)
self.text_view.set_left_margin(10)
self.text_view.set_right_margin(10)
self.view = webkit.WebView()
#hpanel = gtk.HPaned()
#hpanel.set_position(350)
hboxGeneral = gtk.HBox(homogeneous=False)
'''
try:
self.store = Store(db_filename="prueba.db")
except:
self.store = Store()'''
self.store = Store()
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll.add_with_viewport(self.notify_store)
scroll.set_size_request(400, -1)
#hpanel.pack1(scroll, resize = True, shrink = False)
hboxGeneral.pack_start(scroll, False, False, 0)
scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll.add_with_viewport(self.view)
#hpanel.pack2(scroll, resize = True, shrink = False)
hboxGeneral.pack_start(scroll, True, True, 0)
vbox = gtk.VBox()
self.info_toolbar = ToolbarInfo()
self.control_toolbar = ToolbarControl()
vbox.pack_start(self.control_toolbar, False, False, 0)
#vbox.pack_start(hpanel, True, True, 0)
vbox.pack_start(hboxGeneral, True, True, 0)
vbox.pack_start(self.info_toolbar, False, False, 0)
#hpanel.show_all()
hboxGeneral.show_all()
self.add(vbox)
def __init__(self, lunch_master=None):
global ICON_FILE
self.master = lunch_master
self.confirm_close = True # should we ask if the user is sure to close the app?
_commands = self.master.get_all_commands()
# ------------------------------------------------------
# Window and its icon
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.set_title("Lunch")
self.window.connect("delete-event", self.destroy_app)
#self.window.connect("destroy", self.destroy_app)
WIDTH = 640
HEIGHT = 480
self.window.set_default_size(WIDTH, HEIGHT)
if not os.path.exists(ICON_FILE):
log.warning("Could not find icon file %s." % (ICON_FILE))
basename = os.path.basename(ICON_FILE)
directory = os.path.dirname(__file__)
parent_dir = "/".join(directory.split("/")[0:-1])
ICON_FILE = os.path.join(parent_dir, basename)
log.warning("Using icon file %s" % (ICON_FILE))
if os.path.exists(ICON_FILE):
icon = gtk.gdk.pixbuf_new_from_file(ICON_FILE)
self.window.set_icon_list(icon)
else:
log.warning("Could not find icon file %s." % (ICON_FILE))
log.warning("Warning: Could not find icon file %s." % (ICON_FILE))
# Vertical Box
vbox = gtk.VBox(homogeneous=False)
self.window.add(vbox)
# ------------------------------------------------------
# Menu bar
self.ui_manager = None
self.menubar = self._create_main_menu(self.window)
vbox.pack_start(self.menubar, expand=False, fill=False)
self.menubar.show()
vpaned = gtk.VPaned()
vbox.pack_start(vpaned, expand=True, fill=True)
# ------------------------------------------------------
# Scrollable with a TreeView
scroller = gtk.ScrolledWindow()
scroller.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
scroller.set_shadow_type(gtk.SHADOW_IN)
scroller.set_size_request(-1, 250)
frame1 = gtk.Frame(label=_("Processes"))
frame1.set_shadow_type(gtk.SHADOW_ETCHED_IN)
frame1.add(scroller)
vpaned.add1(frame1)
# The ListStore contains the data.
list_store = gtk.ListStore(str, str, str, int, str)
# The TreeModelSort sorts the data
self.model_sort = gtk.TreeModelSort(list_store)
# The TreeView displays the sorted data in the GUI.
self.tree_view_widget = gtk.TreeView(self.model_sort)
self._setup_treeview()
# self.tree_view_widget.set_property("has-tooltip", True)
self.tree_view_widget.get_selection().connect(
"changed", self.on_selected_command_changed)
#self.tree_view_widget.connect("query-tooltip", self.on_treeview_tooltip_queried)
scroller.add(self.tree_view_widget)
for command in _commands:
self._add_command_in_tree(command)
self.master.command_added_signal.connect(self.on_command_added)
self.master.command_removed_signal.connect(self.on_command_removed)
# ------------------------------------------------------
# TextView for the details
scroller2 = gtk.ScrolledWindow()
scroller2.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
scroller2.set_shadow_type(gtk.SHADOW_ETCHED_IN)
scroller2.set_size_request(-1, 50)
viewport = gtk.Viewport()
frame2 = gtk.Frame(label=_("Details"))
frame2.set_shadow_type(gtk.SHADOW_ETCHED_IN)
frame2.add(scroller2)
vpaned.add(frame2)
#vbox.pack_start(scroller2, expand=False, fill=True)
self.textview_widget = gtk.TextView()
self._set_textview_appearance()
scroller2.add(viewport)
viewport.add(self.textview_widget)
# ------------------------------------------------------
# Box with buttons.
hbox = gtk.HBox(homogeneous=True)
vbox.pack_start(hbox, expand=False, fill=False)
self.openlog_button_widget = gtk.Button(
_("Open child process log file"))
self.openlog_button_widget.connect("clicked", self.on_openlog_clicked)
hbox.pack_start(self.openlog_button_widget)
self.stop_command_button_widget = gtk.Button(_("Stop child process"))
self.stop_command_button_widget.connect("clicked",
self.on_stop_command_clicked)
hbox.pack_start(self.stop_command_button_widget)
self.start_command_button_widget = gtk.Button(_("Start child process"))
self.start_command_button_widget.connect("clicked",
self.on_start_command_clicked)
hbox.pack_start(self.start_command_button_widget)
self.window.show_all()
def show(self):
self._window = self._xml.get_widget("dialog_tag_editor_ng")
self._window.set_transient_for(self._app.main_window.get_parent())
for key in dir(self.__class__):
if key[:3] == '_on':
self._xml.signal_connect(key, getattr(self,key))
self._feeds_widget = self._xml.get_widget("treeview_feeds")
self._feeds_model = gtk.ListStore(int, str, bool, bool, bool) #feed_id, title, tagged, separator, newly toggled
self._feeds_widget.set_row_separator_func(lambda m,i:m[i][self.SEPARATOR] == True)
self._sorted_model = gtk.TreeModelSort(self._feeds_model)
def feed_sort_func(model, i1, i2):
#use lists to not affect actual values
r1 = list(model[i1])
r2 = list(model[i2])
#if either is newly selected, treat as unchecked for sorting
if r1[self.NEWLY_TOGGLED] == True: r1[self.TAGGED] = not r1[self.TAGGED]
if r2[self.NEWLY_TOGGLED] == True: r2[self.TAGGED] = not r2[self.TAGGED]
#test separator
if r1[self.SEPARATOR] == True:
if r2[self.TAGGED]: return -1
else: return 1
if r2[self.SEPARATOR] == True:
if r1[self.TAGGED]: return 1
else: return -1
#test checkboxes
if r1[self.TAGGED] != r2[self.TAGGED]:
return r1[self.TAGGED] - r2[self.TAGGED]
#correct for weird bug
if r1[self.TITLE] is None: r1[self.TITLE] = ""
if r2[self.TITLE] is None: r2[self.TITLE] = ""
#sort by name
if r1[self.TITLE].upper() < r2[self.TITLE].upper():
return 1
elif r1[self.TITLE].upper() == r2[self.TITLE].upper():
return 0
return -1
self._sorted_model.set_sort_func(0, feed_sort_func)
self._sorted_model.set_sort_column_id(0, gtk.SORT_DESCENDING)
self._feeds_widget.set_model(self._sorted_model)
renderer = gtk.CellRendererToggle()
feed_column = gtk.TreeViewColumn('')
feed_column.pack_start(renderer, True)
self._feeds_widget.append_column(feed_column)
feed_column.set_attributes(renderer, active=2)
renderer.connect('toggled', self._feed_toggled)
renderer = gtk.CellRendererText()
feed_column = gtk.TreeViewColumn('Feeds')
feed_column.pack_start(renderer, True)
feed_column.set_attributes(renderer, markup=1)
self._feeds_widget.append_column(feed_column)
self._tags_widget = self._xml.get_widget("treeview_tags")
tags_model = gtk.ListStore(str) #tag
self._tags_widget.set_model(tags_model)
renderer = gtk.CellRendererText()
renderer.set_property('editable', True)
renderer.connect('edited', self._tag_name_edited)
tag_column = gtk.TreeViewColumn('Tags')
tag_column.pack_start(renderer, True)
tag_column.set_attributes(renderer, markup=0)
self._tags_widget.append_column(tag_column)
self._tags_widget.get_selection().connect('changed', self._tags_widget_changed)
pane = self._xml.get_widget("hpaned1")
pane.set_position(200)
if utils.RUNNING_HILDON:
self._window.resize(650,300)
else:
self._window.resize(500,600)
self._window.show()
self._populate_lists()
def build_tree(self):
hbox = gtk.HBox()
self.pack_start(hbox, False, False, 5)
if not self.small:
hbox.pack_start(gtk.Label('Search: '), False, False, 5)
self.entry = gtk.Entry()
self.entry.connect('key-press-event', self.on_key_entry)
self.entry.set_size_request(-1, -1)
hbox.pack_start(self.entry, False, False, 0)
""" Host List """
self.store = gtk.TreeStore(gtk.gdk.Pixbuf, str, str, str, str, str)
tree_model = gtk.TreeModelSort(self.store)
self.tree = gtk.TreeView(tree_model)
self.tree.connect('row-activated', self.on_connect)
self.tree.connect('button_press_event', self.on_selected_hosts)
self.tree.set_rubber_banding(True)
self.treeselection = self.tree.get_selection()
self.treeselection.set_mode(gtk.SELECTION_MULTIPLE)
pango_font = pango.FontDescription(self.config['font_host_tree'])
renderer_name = gtk.CellRendererText()
renderer_name.set_property('font-desc', pango_font)
render_pixbuf = gtk.CellRendererPixbuf()
column = gtk.TreeViewColumn('Name')
column.pack_start(render_pixbuf, False)
column.pack_start(renderer_name, True)
column.set_attributes(render_pixbuf, pixbuf=0)
column.set_attributes(renderer_name, text=1)
column.set_resizable(True)
column.set_sort_column_id(1)
self.tree.append_column(column)
renderer_host = gtk.CellRendererText()
renderer_host.set_padding(3, 0)
renderer_host.set_property('font-desc', pango_font)
column = gtk.TreeViewColumn('Host', renderer_host, text=2)
column.set_resizable(True)
column.set_sort_column_id(2)
self.tree.append_column(column)
renderer_username = gtk.CellRendererText()
renderer_username.set_property('font-desc', pango_font)
column = gtk.TreeViewColumn('Username', renderer_username, text=3)
column.set_resizable(True)
column.set_sort_column_id(3)
self.tree.append_column(column)
renderer_description = gtk.CellRendererText()
renderer_description.set_property('font-desc', pango_font)
column = gtk.TreeViewColumn('Description',
renderer_description,
text=4)
column.set_resizable(True)
self.tree.append_column(column)
renderer_description = gtk.CellRendererText()
column = gtk.TreeViewColumn('Uuid', renderer_description, text=5)
column.set_visible(False)
self.tree.append_column(column)
scroll = gtk.ScrolledWindow()
scroll.add(self.tree)
self.pack_start(scroll, True, True, 0)
self.rebuild_host_store()
def __init__(self, app, torrentHash, data):
self.app = app
ClientUtil.add_updater(self)
self.torrentHash = torrentHash
self.torrentData = data
self.download = None
#a mapping from peer id to row
self.peerRows = {}
self.attrIdx = {}
self.COLUMNS = [ ("ip", "IP", "string"),
("upRate", "uRate", "rate"),
("downRate", "dRate", "rate"),
("upTotal", "uTotal", "amount"),
("downTotal", "dTotal", "amount"),
("upChoked", "uChoked", "string"),
("downChoked", "dChoked", "string"),
("snub", "Snub", "string"),
("upInterest", "uInterest", "string"),
("downInterest", "dInterest", "string"),
("speed", "Speed", "rate"),
("requests", "Requests", "string"),
("circ", "Circ", "string"),
("amountDone", "Done", "percent"),
("client", "Client", "string"),
("id", "ID", "string")]
COLUMN_NAMES = [columnTuple[1] for columnTuple in self.COLUMNS]
TYPE_LIST = []
for columnTuple in self.COLUMNS:
columnType = columnTuple[2]
if columnType in ("string"):
TYPE_LIST.append(gobject.TYPE_STRING)
elif columnType == "amount":
TYPE_LIST.append(gobject.TYPE_INT)
elif columnType in ("rate", "percent"):
TYPE_LIST.append(gobject.TYPE_FLOAT)
else:
raise Exception("Bad type for column: %s" % (columnType))
self.liststore = gtk.ListStore(*TYPE_LIST)
modelfilter, treeview = GTKUtils.make_listview(self.liststore, COLUMN_NAMES)
for i in range(0, len(self.COLUMNS)):
attrName = self.COLUMNS[i][0]
attrType = self.COLUMNS[i][2]
self.attrIdx[attrName] = i
if attrType == "string":
GTKUtils.make_text_cell(treeview.columns[i], i, makeSortable=True)
else:
cellFunc = getattr(self, "_cell_data_" + attrType)
self._make_number_cell(treeview.columns[i], i, cellFunc)
#make treeview searchable
treeview.set_search_column(0)
#attach the filtermodel and treeview
self.model = gtk.TreeModelSort(modelfilter)
treeview.set_model(self.model)
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)
self.container = scrolled_window
def __init__(self,
index_ext,
opener,
filter_actionable=False,
tag_by_page=False,
use_workweek=False):
self.real_model = gtk.TreeStore(bool, int, str, str, str, bool, bool,
int, object)
# VIS_COL, PRIO_COL, TASK_COL, DATE_COL, PAGE_COL, ACT_COL, OPEN_COL, TASKID_COL, TAGS_COL
model = self.real_model.filter_new()
model.set_visible_column(self.VIS_COL)
model = gtk.TreeModelSort(model)
model.set_sort_column_id(self.PRIO_COL, gtk.SORT_DESCENDING)
BrowserTreeView.__init__(self, model)
self.index_ext = index_ext
self.opener = opener
self.filter = None
self.tag_filter = None
self.label_filter = None
self.filter_actionable = filter_actionable
self.tag_by_page = tag_by_page
self._tags = {}
self._labels = {}
# Add some rendering for the Prio column
def render_prio(col, cell, model, i):
prio = model.get_value(i, self.PRIO_COL)
cell.set_property('text', str(prio))
if prio >= 3: color = HIGH_COLOR
elif prio == 2: color = MEDIUM_COLOR
elif prio == 1: color = ALERT_COLOR
else: color = None
cell.set_property('cell-background', color)
cell_renderer = gtk.CellRendererText()
#~ column = gtk.TreeViewColumn(_('Prio'), cell_renderer)
# T: Column header Task List dialog
column = gtk.TreeViewColumn(' ! ', cell_renderer)
column.set_cell_data_func(cell_renderer, render_prio)
column.set_sort_column_id(self.PRIO_COL)
self.append_column(column)
# Rendering for task description column
cell_renderer = gtk.CellRendererText()
cell_renderer.set_property('ellipsize', pango.ELLIPSIZE_END)
column = gtk.TreeViewColumn(_('Task'),
cell_renderer,
markup=self.TASK_COL)
# T: Column header Task List dialog
column.set_resizable(True)
column.set_sort_column_id(self.TASK_COL)
column.set_expand(True)
if ui_environment['platform'] == 'maemo':
column.set_min_width(250) # don't let this column get too small
else:
column.set_min_width(300) # don't let this column get too small
self.append_column(column)
self.set_expander_column(column)
if gtk.gtk_version >= (2, 12, 0):
self.set_tooltip_column(self.TASK_COL)
# Rendering of the Date column
day_of_week = datetime.date.today().isoweekday()
if use_workweek and day_of_week == 4:
# Today is Thursday - 2nd day ahead is after the weekend
delta1, delta2 = 1, 3
elif use_workweek and day_of_week == 5:
# Today is Friday - next day ahead is after the weekend
delta1, delta2 = 3, 4
else:
delta1, delta2 = 1, 2
today = str(datetime.date.today())
tomorrow = str(datetime.date.today() + datetime.timedelta(days=delta1))
dayafter = str(datetime.date.today() + datetime.timedelta(days=delta2))
def render_date(col, cell, model, i):
date = model.get_value(i, self.DATE_COL)
if date == _NO_DATE:
cell.set_property('text', '')
else:
cell.set_property('text', date)
# TODO allow strftime here
if date <= today: color = HIGH_COLOR
elif date <= tomorrow: color = MEDIUM_COLOR
elif date <= dayafter:
color = ALERT_COLOR
# "<=" because tomorrow and/or dayafter can be after the weekend
else:
color = None
cell.set_property('cell-background', color)
cell_renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(_('Date'), cell_renderer)
# T: Column header Task List dialog
column.set_cell_data_func(cell_renderer, render_date)
column.set_sort_column_id(self.DATE_COL)
self.append_column(column)
# Rendering for page name column
cell_renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(_('Page'),
cell_renderer,
text=self.PAGE_COL)
# T: Column header Task List dialog
column.set_sort_column_id(self.PAGE_COL)
self.append_column(column)
# Finalize
self.refresh()
# HACK because we can not register ourselves :S
self.connect('row_activated', self.__class__.do_row_activated)
def __init__(self):
basetreeview.KeepNoteBaseTreeView.__init__(self)
self._sel_nodes = None
# configurable callback for setting window status
self.on_status = None
# init model
self.set_model(gtk.TreeModelSort(treemodel.KeepNoteTreeModel()))
self.model.connect("sort-column-changed", self._sort_column_changed)
# init view
self.connect("key-release-event", self.on_key_released)
self.connect("button-press-event", self.on_button_press)
self.connect("row-expanded", self._on_listview_row_expanded)
self.connect("row-collapsed", self._on_listview_row_collapsed)
self.set_rules_hint(True)
self.set_fixed_height_mode(True)
# title column
cell_icon = gtk.CellRendererPixbuf()
self.title_text = gtk.CellRendererText()
self.title_column = gtk.TreeViewColumn()
self.title_column.set_title("Title")
self.title_column.set_property("sizing", gtk.TREE_VIEW_COLUMN_FIXED)
self.title_column.set_min_width(10)
self.title_column.set_fixed_width(250)
self.title_column.set_property("resizable", True)
self.title_column.pack_start(cell_icon, False)
self.title_column.pack_start(self.title_text, True)
#self.title_column.connect("clicked", self.on_column_clicked)
self.title_text.set_fixed_height_from_font(1)
self.title_text.connect("edited", self.on_edit_title)
self.title_text.connect("editing-started", self.on_editing_started)
self.title_text.connect("editing-canceled", self.on_editing_canceled)
self.title_text.set_property("editable", True)
self.title_column.set_sort_column_id(
self.rich_model.get_column_by_name("title_sort").pos)
# map cells to columns in model
self.title_column.add_attribute(
cell_icon, 'pixbuf',
self.rich_model.get_column_by_name("icon").pos)
self.title_column.add_attribute(
cell_icon, 'pixbuf-expander-open',
self.rich_model.get_column_by_name("icon_open").pos)
self.title_column.add_attribute(
self.title_text, 'text',
self.rich_model.get_column_by_name("title").pos)
self.append_column(self.title_column)
self.set_expander_column(self.title_column)
# created column
cell_text = gtk.CellRendererText()
cell_text.set_fixed_height_from_font(1)
column = gtk.TreeViewColumn()
column.set_title("Created")
column.set_property("sizing", gtk.TREE_VIEW_COLUMN_FIXED)
column.set_property("resizable", True)
column.set_min_width(10)
column.set_fixed_width(150)
column.set_sort_column_id(
self.rich_model.get_column_by_name("created_time_sort").pos)
#column.connect("clicked", self.on_column_clicked)
#column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
#column.set_property("min-width", 5)
column.pack_start(cell_text, True)
column.add_attribute(
cell_text, 'text',
self.rich_model.get_column_by_name("created_time").pos)
self.append_column(column)
# modified column
cell_text = gtk.CellRendererText()
cell_text.set_fixed_height_from_font(1)
column = gtk.TreeViewColumn()
column.set_title("Modified")
column.set_property("sizing", gtk.TREE_VIEW_COLUMN_FIXED)
column.set_property("resizable", True)
column.set_min_width(10)
column.set_fixed_width(150)
column.set_sort_column_id(
self.rich_model.get_column_by_name("modified_time_sort").pos)
#column.connect("clicked", self.on_column_clicked)
#column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
#column.set_property("min-width", 5)
column.pack_start(cell_text, True)
column.add_attribute(
cell_text, 'text',
self.rich_model.get_column_by_name("modified_time").pos)
self.append_column(column)
# set default sorting
# remember sort per node
self.model.set_sort_column_id(
self.rich_model.get_column_by_name("order").pos,
gtk.SORT_ASCENDING)
self.set_reorder(basetreeview.REORDER_ALL)
self.menu = gtk.Menu()
self.menu.attach_to_widget(self, lambda w, m: None)
self.set_sensitive(False)
def init_gui(self):
wt = gtk.glade.XML(GLADE_FILE)
self.ui = utils.UI(wt.get_widget)
# log view
columns = [('sender', str), ('message', str), ('_message', str),
('created', str), ('_created', str), ('_color', str)]
col_names = [x[0] for x in columns]
col_types = [x[1] for x in columns]
self.ui.model = root_model = gtk.TreeStore(*col_types)
filter_model = root_model.filter_new()
self.ui.log_model = model = gtk.TreeModelSort(filter_model)
model.append = root_model.append
model._iterators = {}
model._columns = columns = dict((v, i) for i, v in enumerate(col_names))
model.set_sort_column_id(columns['_created'], gtk.SORT_ASCENDING)
view = self.ui.log_view
view.set_model(model)
view.modify_font(MONOSPACE_FONT)
view.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
# columns
render = gtk.CellRendererText()
column = gtk.TreeViewColumn('Sender', render, text=columns['sender'],
foreground=columns['_color'])
column.set_resizable(True)
column.set_sort_column_id(columns['sender'])
view.append_column(column)
render = gtk.CellRendererText()
column = gtk.TreeViewColumn('Message', render, text=columns['message'],
foreground=columns['_color'])
column.set_resizable(True)
column.set_expand(True)
column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
column.set_sort_column_id(columns['message'])
view.append_column(column)
render = gtk.CellRendererText()
column = gtk.TreeViewColumn('Created', render, text=columns['created'],
foreground=columns['_color'])
column.set_resizable(True)
column.set_sort_column_id(columns['_created'])
view.append_column(column)
# autoscroll
button = self.ui.log_autoscroll_button
def toggled(button, view):
if button.get_active():
utils.scroll_treeview_to_bottom(view)
button.connect('toggled', toggled, view)
def scroll_to_bottom(model, path, it, view, button):
if button.get_active():
view.set_cursor(path)
model.connect('row-inserted', scroll_to_bottom, view, button)
# filter
filter_model._filters = filters = {'sender': [], 'message': []}
def visible(model, it, data):
columns, filters = data
def match_column(column, query):
if not query:
return True
value = model.get_value(it, columns[column])
if not value:
return False
if self._apply_log_filter(value, query):
return True
return all([match_column(c, q) for c, q in filters.iteritems()])
filter_model.set_visible_func(visible, (columns, filters))
sender_entry = self.ui.log_filter_sender_entry
message_entry = self.ui.log_filter_message_entry
def changed(entry, column, filters, filter_model):
filters[column] = self._parse_log_filter(entry.get_text())
filter_model.refilter()
sender_entry.connect('changed', changed, 'sender', filters, filter_model)
message_entry.connect('changed', changed, 'message', filters, filter_model)
button = self.ui.log_filter_button
box = self.ui.log_filter_box
def toggled(button, box, entry):
active = button.get_active()
box.set_property("visible", active)
if active:
gobject.idle_add(entry.grab_focus)
button.connect('toggled', toggled, box, sender_entry)
button = self.ui.log_filter_clear_button
def clear(button, entries):
for entry in entries:
entry.set_text('')
button.connect('clicked', clear, [sender_entry, message_entry])
# mouse actions
def button_press(view, event):
if event.button == 1 and event.type == gtk.gdk._2BUTTON_PRESS:
# double-click
# popup a dialog with full log message
columns = self.ui.log_model._columns
dialog = self.ui.log_details_dialog
buf = self.ui.log_details_view.get_buffer()
row = utils.get_selected_rows(view)[0]
self.ui.log_details_sender_label.set_text(row[columns['sender']])
self.ui.log_details_time_label.set_text(row[columns['created']])
buf.set_text(row[columns['_message']])
dialog.show()
elif event.button == 3:
# popup menu
menu = self.ui.log_menu
menu.show_all()
menu.popup(None, None, None, event.button, event.time)
# allow right-click to select if 1 or less rows are selected
return len(utils.get_selected_rows(view)) > 1
view.connect('button-press-event', button_press)
button = self.ui.log_details_ok_button
button.connect('clicked', lambda x: self.ui.log_details_dialog.hide())
self.ui.log_details_view.modify_font(MONOSPACE_FONT)
def copy_messages(item, view, columns):
clipboard = gtk.clipboard_get()
buf = []
for row in utils.get_selected_rows(view):
buf.append(row[columns['_message']])
clipboard.set_text('\n'.join(buf))
self.ui.log_copy_messages_menuitem.connect('activate', copy_messages, view, columns)
def copy_logs(item, view, columns):
import io, csv
buf = io.BytesIO()
writer = csv.writer(buf)
copy_columns = ['sender', '_message', 'created']
for row in utils.get_selected_rows(view):
writer.writerow([row[columns[c]] for c in copy_columns])
clipboard = gtk.clipboard_get()
clipboard.set_text(buf.getvalue())
self.ui.log_copy_logs_menuitem.connect('activate', copy_logs, view, columns)
# add logging handler
for logger in self.loggers:
handler = TreeStoreHandler(model, self.gui_call, self.commander)
handler.setLevel(logging.INFO)
logger.addHandler(handler)
def treeview_widgets(self):
# Treeview of current suite state, with filtering and sorting.
# sorting is handled somewhat manually because the simple method
# of interposing a TreeModelSort at the top:
# treestore = gtk.TreeStore(str, ...)
# tms = gtk.TreeModelSort( treestore ) #\
# tmf = tms.filter_new() #-- or other way round?
# tv = gtk.TreeView()
# tv.set_model(tms)
# failed to produce correct results (the data displayed was not
# consistently what should have been displayed given the
# filtering in use) although the exact same code worked for a
# liststore.
self.sort_col_num = 0
self.ttreestore = gtk.TreeStore(str, str, str, str, str, str, str, str,
str, str, gtk.gdk.Pixbuf)
self.tmodelfilter = self.ttreestore.filter_new()
self.tmodelfilter.set_visible_func(self.visible_cb)
self.tmodelsort = gtk.TreeModelSort(self.tmodelfilter)
self.ttreeview = gtk.TreeView()
self.ttreeview.set_rules_hint(True)
self.ttreeview.set_model(self.tmodelsort)
ts = self.ttreeview.get_selection()
ts.set_mode(gtk.SELECTION_SINGLE)
self.ttreeview.connect('button_press_event',
self.on_treeview_button_pressed)
headings = [
None, 'task', 'state', 'host', 'Job ID', 'T-submit', 'T-start',
'T-finish', 'dT-mean', 'latest message'
]
for n in range(1, len(headings)):
# Skip first column (cycle point)
tvc = gtk.TreeViewColumn(headings[n])
if n == 1:
crp = gtk.CellRendererPixbuf()
tvc.pack_start(crp, False)
tvc.set_attributes(crp, pixbuf=10)
cr = gtk.CellRendererText()
tvc.pack_start(cr, True)
if n == 7:
tvc.set_attributes(cr, markup=n)
else:
tvc.set_attributes(cr, text=n)
tvc.set_resizable(True)
tvc.set_clickable(True)
self.ttreeview.append_column(tvc)
tvc.set_sort_column_id(n - 1)
self.tmodelsort.set_sort_func(n - 1, self.sort_column, n - 1)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.add(self.ttreeview)
self.tfilterbox = gtk.VBox()
subbox1 = gtk.HBox(homogeneous=True)
subbox2 = gtk.HBox(homogeneous=True)
self.tfilterbox.pack_start(subbox1)
self.tfilterbox.pack_start(subbox2)
self.tfilter_states = []
dotm = DotMaker(self.theme, size='small')
cnt = 0
for st in task_state.legal:
box = gtk.HBox()
icon = dotm.get_image(st)
cb = gtk.CheckButton(task_state.labels[st])
tooltip = gtk.Tooltips()
tooltip.enable()
tooltip.set_tip(cb, "Filter by task state = %s" % st)
box.pack_start(icon, expand=False)
box.pack_start(cb, expand=False)
cnt += 1
if cnt > (len(task_state.legal) + 1) // 2:
subbox2.pack_start(box, expand=False, fill=True)
else:
subbox1.pack_start(box, expand=False, fill=True)
if st in self.tfilter_states:
cb.set_active(False)
else:
cb.set_active(True)
cb.connect('toggled', self.check_tfilter_buttons)
self.filter_entry = EntryTempText()
self.filter_entry.set_width_chars(7)
self.filter_entry.connect("activate", self.check_filter_entry)
self.filter_entry.set_temp_text("filter")
tooltip = gtk.Tooltips()
tooltip.enable()
tooltip.set_tip(
self.filter_entry, "Filter by task name.\n"
"Enter a sub-string or regex and hit Enter\n"
"(to reset, clear the entry and hit Enter)")
subbox2.pack_start(self.filter_entry)
cnt += 1
if cnt % 2 != 0:
# subbox2 needs another entry to line things up.
subbox2.pack_start(gtk.HBox(), expand=False, fill=True)
filter_hbox = gtk.HBox()
filter_hbox.pack_start(self.tfilterbox, True, True, 10)
vbox = gtk.VBox()
vbox.pack_start(sw, True)
vbox.pack_end(filter_hbox, False)
return vbox
def __on_sort_ascending(self, item):
self.populate()
model = gtk.TreeModelSort(self.store)
model.set_sort_column_id(ProtocolTree.COL_STR, gtk.SORT_ASCENDING)
self.tree.set_rules_hint(True)
self.tree.set_model(model)
def __init__(self):
gtk.Window.__init__(self)
self.port = 8080
while True:
try:
self.server = HTTPProxyServer(self)
break
except socket.error:
self.port += 1
self.server.start()
self.set_title(NAME)
self.set_icon(mygtk.iconfactory.get_icon("httpripper", 32))
self.set_default_size(600, 600)
self.vbox = gtk.VBox()
self.add(self.vbox)
self.info = gtk.Label(
_("HTTPRipper is running on localhost: %i") % self.port)
self.vbox.pack_start(self.info, False, False)
self.model = mygtk.ListStore(date=str, url=str, size=int, path=str,
icon=str, content_type=str)
self.model_filtered = self.model.filter_new()
self.model_filtered.set_visible_func(self.row_visible)
self.model_sort = gtk.TreeModelSort(self.model_filtered)
self.treeview = gtk.TreeView(self.model_sort)
self.treeview.set_rules_hint(True)
self.treeview.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.treeview.connect("row-activated", self.save_file)
self.treeview.set_search_column(self.model.columns.url)
# add rows
col = self.treeview.insert_column_with_attributes(0, _("Time"),
gtk.CellRendererText(), text=self.model.columns.date)
col.set_sort_column_id(self.model.columns.date)
col = self.treeview.insert_column_with_attributes(1, _("Size"),
gtk.CellRendererText(), text=self.model.columns.size)
col.set_cell_data_func(col.get_cell_renderers()[0], byteformatdatafunc)
col.set_sort_column_id(self.model.columns.size)
renderer = gtk.CellRendererText()
col = self.treeview.insert_column_with_attributes(2, _("Content-Type"),
renderer, text=self.model.columns.content_type)
renderer.set_property("ellipsize", pango.ELLIPSIZE_END)
renderer.set_property("width", 100)
col.set_sort_column_id(self.model.columns.content_type)
col = self.treeview.insert_column_with_attributes(3, _("URL"),
gtk.CellRendererText(), text=self.model.columns.url)
col.set_expand(True)
col.set_sort_column_id(self.model.columns.url)
col = self.treeview.insert_column_with_attributes(0, "",
gtk.CellRendererPixbuf(),
**({"icon_name": self.model.columns.icon}))
self.vbox.pack_start(mygtk.scrolled(self.treeview))
#self.treeview.set_fixed_height_mode(True) # makes it a bit faster
# filtering
self.filter_content_type = ContentTypeFilter()
self.filter_size = gtk.Entry()
self.filter_size.connect("changed", lambda entry: self.model_filtered.refilter())
self.filter_content_type.connect("changed", lambda combobox: self.model_filtered.refilter())
self.filter_expander = gtk.Expander(label=_("Filter"))
self.filter_expander.add(
mygtk.make_table([
(llabel(_("Content-Type")), llabel(_("is")), self.filter_content_type),
(llabel(_("Size")), llabel(_("at least (KiB)")), self.filter_size),
])
)
self.vbox.pack_start(self.filter_expander, False, False)
# buttons at the buttom
self.buttonbox = gtk.HButtonBox()
self.vbox.pack_end(self.buttonbox, False, False)
self.button_record = gtk.ToggleButton(gtk.STOCK_MEDIA_RECORD)
self.button_record.set_use_stock(True)
self.button_record.connect("clicked", self.record)
self.buttonbox.pack_start(self.button_record)
self.button_save = gtk.Button(stock=gtk.STOCK_SAVE_AS)
self.button_save.connect("clicked", self.save)
self.buttonbox.pack_start(self.button_save)
self.button_clear = gtk.Button(stock=gtk.STOCK_CLEAR)
self.button_clear.connect("clicked", self.clear)
self.buttonbox.pack_start(self.button_clear)
self.button_about = gtk.Button(stock=gtk.STOCK_ABOUT)
self.button_about.connect("clicked", self.about)
self.buttonbox.pack_start(self.button_about)
self.connect("destroy", self.clear)
self.connect("destroy", lambda *args: self.server.shutdown())
self.connect("destroy", gtk.main_quit)
host, port, enabled, mode = get_proxy()
if host == "localhost" and port == self.port and enabled:
self.button_record.set_active(True)
def __init__(self, parent, mesh=None):
debug.mainthreadTest()
self.parent = parent # Reference to the enclosing BoundaryCondPage.
self.current_mesh = mesh
debug.mainthreadTest()
self.bcliststore = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_PYOBJECT)
self.sortedlist = gtk.TreeModelSort(self.bcliststore)
self.gtk = gtk.TreeView(self.sortedlist)
gtklogger.setWidgetName(self.gtk, "BCList")
# Enable/disable column
enablecell = gtk.CellRendererToggle()
enablecol = gtk.TreeViewColumn("Enable")
enablecol.pack_start(enablecell, expand=False)
enablecol.set_cell_data_func(enablecell, self.renderEnableCell)
self.gtk.append_column(enablecol)
gtklogger.adoptGObject(enablecell,
self.gtk,
access_function=gtklogger.findCellRenderer,
access_kwargs={
'col': 0,
'rend': 0
})
gtklogger.connect(enablecell, 'toggled', self.enableCellCB)
## Click on the column header to sort by Enabled status.
## Currently commented out because clicking on a toggle cell
## when sorting by Enable may trigger an instant re-sort,
## which moves the clicked cell.
# gtklogger.adoptGObject(enablecol, self.gtk,
# access_method=gtk.TreeView.get_column,
# access_args=(0,))
# gtklogger.connect_passive(enablecol, 'clicked')
# enablecol.set_sort_column_id(self.sortByEnableID)
# self.sortedlist.set_sort_func(self.sortByEnableID, self.sortByEnableFn)
# Boundary condition name column
bcnamecell = gtk.CellRendererText()
bcnamecol = gtk.TreeViewColumn('Name')
bcnamecol.pack_start(bcnamecell, expand=False)
bcnamecol.set_attributes(bcnamecell, text=0)
self.gtk.append_column(bcnamecol)
gtklogger.adoptGObject(bcnamecol,
self.gtk,
access_method=gtk.TreeView.get_column,
access_args=(1, ))
gtklogger.connect_passive(bcnamecol, 'clicked')
bcnamecol.set_sort_column_id(self.sortByNameID)
self.sortedlist.set_sort_func(self.sortByNameID, self.sortByNameFn)
# Boundary name column
bdycell = gtk.CellRendererText()
bdycol = gtk.TreeViewColumn('Boundary')
bdycol.pack_start(bdycell, expand=True)
bdycol.set_cell_data_func(bdycell, self.renderBdy)
self.gtk.append_column(bdycol)
gtklogger.adoptGObject(bdycol,
self.gtk,
access_method=gtk.TreeView.get_column,
access_args=(2, ))
gtklogger.connect_passive(bdycol, 'clicked')
bdycol.set_sort_column_id(self.sortByBdyID)
self.sortedlist.set_sort_func(self.sortByBdyID, self.sortByBdyFn)
# Boundary condition column
bccell = gtk.CellRendererText()
bccol = gtk.TreeViewColumn('Condition')
bccol.pack_start(bccell, expand=True)
bccol.set_cell_data_func(bccell, self.renderBC)
self.gtk.append_column(bccol)
selection = self.gtk.get_selection()
gtklogger.adoptGObject(selection,
self.gtk,
access_method=self.gtk.get_selection)
self.signals = (gtklogger.connect(selection, 'changed', self.selectCB),
gtklogger.connect(self.gtk, 'row-activated',
self.doubleClickCB))
# Set initial sorting method
self.lastsortcol = bcnamecol
self.sortedlist.set_sort_column_id(self.sortByNameID,
gtk.SORT_ASCENDING)
def __init__(self, window, app):
self.app = app
self.vbox = gtk.VBox(False, 0)
self.label = gtk.Label(self.app.currentdir)
self.hbox = gtk.HBox(False, 0)
self.vbox.pack_start(self.label, False, False, 0)
self.vbox.pack_start(self.hbox, True, True, 0)
self.label.show()
self.dirlist = gtk.ListStore(str)
self.dirListWin = gtk.ScrolledWindow()
self.dirListWin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
self.dirListSorted = gtk.TreeModelSort(self.dirlist)
self.dirListSorted.set_sort_column_id(0, gtk.SORT_ASCENDING)
self.dirListView = gtk.TreeView(self.dirListSorted)
self.dirlistcol = gtk.TreeViewColumn('')
self.dirListView.append_column(self.dirlistcol)
self.dirListView.set_headers_visible(False)
self.cell1 = gtk.CellRendererText()
self.dirlistcol.pack_start(self.cell1, True)
self.dirlistcol.add_attribute(self.cell1, 'text', 0)
self.dirListWin.add(self.dirListView)
self.dirListView.show()
self.dirListWin.show()
self.dirListView.connect("row-activated", self.dirSelected)
self.filelist = gtk.ListStore(str)
self.fileListWin = gtk.ScrolledWindow()
self.fileListWin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
self.fileListSorted = gtk.TreeModelSort(self.filelist)
self.fileListSorted.set_sort_column_id(0, gtk.SORT_ASCENDING)
self.fileListView = gtk.TreeView(self.fileListSorted)
self.filelistcol = gtk.TreeViewColumn('')
self.fileListView.append_column(self.filelistcol)
self.fileListView.set_headers_visible(False)
self.cell2 = gtk.CellRendererText()
self.filelistcol.pack_start(self.cell2, True)
self.filelistcol.add_attribute(self.cell2, 'text', 0)
self.fileListWin.add(self.fileListView)
self.fileListView.show()
self.fileListWin.show()
self.fileListView.connect("row-activated", self.playSelected)
self.hbox.pack_start(self.dirListWin, True, True, 0)
self.hbox.pack_start(self.fileListWin, True, True, 0)
self.hbox.show()
# Queue and load buttons
self.hbox2 = gtk.HBox(False, 0)
self.queueBtn = gtk.Button("Add to playlist")
self.queueBtn.connect("clicked", self.queueSelected)
self.queueBtn.show()
self.loadBtn = gtk.Button("Play now")
self.loadBtn.connect("clicked", self.playSelected)
self.loadBtn.show()
self.hbox2.pack_start(self.queueBtn, True, True, 0)
self.hbox2.pack_start(self.loadBtn, True, True, 0)
self.hbox2.show()
self.vbox.pack_start(self.hbox2, False, False, 0)
window.add(self.vbox)
self.vbox.show()
window.show()
def load_table(self, table, force_reload=False):
if table == self.table and not force_reload:
return
if self.tables.has_key(table):
if table != self.table and self.table:
# Save the current state
self.save_state()
self.clear_view()
self.table = table
else:
raise KeyError, "The table %s is not supported." % table
# If we are in report mode, just set it and ignore the table setting
if self.mode == oks.MODE_REPORT:
# Clear the previous report description and options
self.label_report_description.set_text("")
clear_gtk_container(self.table_report_options)
self.window.set_title("Relatórios")
self.vbox_report_options_frame.hide_all()
reports = self.tables[table]["reports"]
reports = [(report.NAME, report) for report in reports]
self.combobox_report_type.set_options(*reports)
# Restore the previous state
report, scroll = self.tables[self.table]["report_state"]
if report is not None:
self.combobox_report_type.set_value(report)
self.hpaned.set_position(300)
return
# Window title
self.window.set_title(self.tables[table]["window_title"])
# Search
self.search_box.reset()
for (label, searchWidget) in self.tables[table]["search_widgets"]:
self.search_box.add_field(label, searchWidget)
# Actions
self.title.enable_actions(False)
self.actions_enabled = not self.tables[table]["actions"] == []
self.title.set_actions(*self.tables[table]["actions"])
# Treeview
if table not in self.models.keys():
self.model = self.db.models[table]
self.f_model = self.model.filter_new()
self.f_model.set_visible_func(self.visible_func)
self.sf_model = None
if self.SORT:
self.sf_model = gtk.TreeModelSort(self.f_model)
sort_col, sort_type = self.tables[table]["default_sort"]
if sort_col is not None and sort_type is not None:
self.sf_model.set_sort_column_id(sort_col, sort_type)
self.models[table] = (self.model, self.f_model, self.sf_model)
else:
self.model, self.f_model, self.sf_model = self.models[table]
for column in self.treeview.get_columns():
self.treeview.remove_column(column)
for column in self.tables[table]["columns"]:
self.treeview.append_column(column)
self.selected = None
self.reload_search(False)
if self.SORT:
model = self.sf_model
else:
model = self.f_model
self.treeview.set_model(model)
action_new_label = self.tables[table]["new_stock"]
if action_new_label:
self.action_new.set_sensitive(True)
self.action_new.set_property("label", action_new_label)
self.action_new.set_property("short_label", action_new_label)
else:
self.action_new.set_sensitive(False)
# Completion support
completion = self.services["completion"]
if self.tables[table].has_key("completion"):
for entry, completion_name in self.tables[table]["completion"]:
entry.set_completion(completion(completion_name))
# Restore the previous state
element, scroll = self.tables[self.table]["main_state"]
if element is not None:
self.treeview.get_selection().select_path(element)
self.on_treeview_cursor_changed()
else:
self.clear_view()
if scroll is not None:
# Add a timeout to prevent flickering
cb = lambda: self.treeview.scroll_to_point(scroll.x, scroll.y) \
False
gobject.timeout_add(250, cb)
self.hpaned.set_position(420)
self.search_box.grab_focus()
self.f_model.refilter() # Refilter, so that the sorting works fine
def update_tree_model(self):
"""Construct a data model of other page data."""
sub_sect_names = self.sections.keys()
sub_var_names = []
self.var_id_map = {}
for section, variables in self.variables.items():
for variable in variables:
self.var_id_map[variable.metadata["id"]] = variable
data_rows, column_names = self.get_model_data()
data_rows, column_names, rows_are_descendants = self._apply_grouping(
data_rows, column_names, self.group_index)
self.column_names = column_names
should_redraw = self.column_names != self._last_column_names
if data_rows:
col_types = [str] * len(data_rows[0])
else:
col_types = []
need_new_store = (should_redraw or self.group_index)
if need_new_store:
# We need to construct a new TreeModel.
if self._prev_sort_model is not None:
prev_sort_id = self._prev_sort_model.get_sort_column_id()
store = gtk.TreeStore(*col_types)
self._prev_store = store
else:
store = self._prev_store
parent_iter = None
for i, row_data in enumerate(data_rows):
insert_iter = store.iter_nth_child(None, i)
if insert_iter is not None:
for j, value in enumerate(row_data):
store.set_value(insert_iter, j, value)
elif not rows_are_descendants:
store.append(None, row_data)
elif rows_are_descendants[i]:
store.append(parent_iter, row_data)
else:
parent_data = [row_data[0]] + [None] * len(row_data[1:])
parent_iter = store.append(None, parent_data)
store.append(parent_iter, row_data)
for extra_index in range(i + 1, store.iter_n_children(None)):
remove_iter = store.iter_nth_child(None, extra_index)
if remove_iter is not None:
store.remove(remove_iter)
if need_new_store:
filter_model = store.filter_new()
filter_model.set_visible_func(self._filter_visible)
sort_model = gtk.TreeModelSort(filter_model)
for i in range(len(self.column_names)):
sort_model.set_sort_func(i, self.sort_util.sort_column, i)
if (self._prev_sort_model is not None
and prev_sort_id[0] is not None):
sort_model.set_sort_column_id(*prev_sort_id)
self._prev_sort_model = sort_model
sort_model.connect("sort-column-changed",
self.sort_util.handle_sort_column_change)
if should_redraw:
self.sort_util.clear_sort_columns()
for column in list(self._view.get_columns()):
self._view.remove_column(column)
self._view.set_model(sort_model)
self._last_column_names = self.column_names
return should_redraw
def __init__(self,
tasksview,
opener,
task_labels,
nonactionable_tags=(),
filter_actionable=False,
tag_by_page=False,
use_workweek=False,
compact=False,
flatlist=False,
sort_column=PRIO_COL,
sort_order=gtk.SORT_DESCENDING):
self.real_model = gtk.TreeStore(bool, bool, int, str, str, object, str,
str, int, int, str)
# VIS_COL, ACT_COL, PRIO_COL, START_COL, DUE_COL, TAGS_COL, DESC_COL, PAGE_COL, TASKID_COL, PRIO_SORT_COL, PRIO_SORT_LABEL_COL
model = self.real_model.filter_new()
model.set_visible_column(self.VIS_COL)
model = gtk.TreeModelSort(model)
model.set_sort_column_id(sort_column, sort_order)
BrowserTreeView.__init__(self, model)
self.tasksview = tasksview
self.opener = opener
self.filter = None
self.tag_filter = None
self.label_filter = None
self.filter_actionable = filter_actionable
self.nonactionable_tags = tuple(
t.strip('@').lower() for t in nonactionable_tags)
self.tag_by_page = tag_by_page
self.task_labels = task_labels
self._tags = {}
self._labels = {}
self.flatlist = flatlist
# Add some rendering for the Prio column
def render_prio(col, cell, model, i):
prio = model.get_value(i, self.PRIO_COL)
text = model.get_value(i, self.PRIO_SORT_LABEL_COL)
if text.startswith('>'):
text = '<span color="darkgrey">%s</span>' % text
bg = None
else:
bg = COLORS[min(prio, 3)]
cell.set_property('markup', text)
cell.set_property('cell-background', bg)
cell_renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn('!', cell_renderer)
column.set_cell_data_func(cell_renderer, render_prio)
column.set_sort_column_id(self.PRIO_SORT_COL)
self.append_column(column)
# Rendering for task description column
cell_renderer = gtk.CellRendererText()
cell_renderer.set_property('ellipsize', pango.ELLIPSIZE_END)
column = gtk.TreeViewColumn(_('Task'),
cell_renderer,
markup=self.DESC_COL)
# T: Column header Task List dialog
column.set_resizable(True)
column.set_sort_column_id(self.DESC_COL)
column.set_expand(True)
if compact:
column.set_min_width(100)
else:
column.set_min_width(300) # don't let this column get too small
self.append_column(column)
self.set_expander_column(column)
if gtk.gtk_version >= (2, 12) \
and gtk.pygtk_version >= (2, 12):
# custom tooltip
self.props.has_tooltip = True
self.connect("query-tooltip", self._query_tooltip_cb)
# Rendering of the Date column
day_of_week = datetime.date.today().isoweekday()
if use_workweek and day_of_week == 4:
# Today is Thursday - 2nd day ahead is after the weekend
delta1, delta2 = 1, 3
elif use_workweek and day_of_week == 5:
# Today is Friday - next day ahead is after the weekend
delta1, delta2 = 3, 4
else:
delta1, delta2 = 1, 2
today = str(datetime.date.today())
tomorrow = str(datetime.date.today() + datetime.timedelta(days=delta1))
dayafter = str(datetime.date.today() + datetime.timedelta(days=delta2))
def render_date(col, cell, model, i):
date = model.get_value(i, self.DUE_COL)
if date == _MAX_DUE_DATE:
cell.set_property('text', '')
else:
cell.set_property('text', date)
# TODO allow strftime here
if date <= today: color = HIGH_COLOR
elif date <= tomorrow: color = MEDIUM_COLOR
elif date <= dayafter:
color = ALERT_COLOR
# "<=" because tomorrow and/or dayafter can be after the weekend
else:
color = None
cell.set_property('cell-background', color)
if not compact:
cell_renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(_('Date'), cell_renderer)
# T: Column header Task List dialog
column.set_cell_data_func(cell_renderer, render_date)
column.set_sort_column_id(self.DUE_COL)
self.append_column(column)
# Rendering for page name column
if not compact:
cell_renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(_('Page'),
cell_renderer,
text=self.PAGE_COL)
# T: Column header Task List dialog
column.set_sort_column_id(self.PAGE_COL)
self.append_column(column)
# Finalize
self.refresh()
# HACK because we can not register ourselves :S
self.connect('row_activated', self.__class__.do_row_activated)
self.connect('focus-in-event', self.__class__.do_focus_in_event)
def __init__(self, default, data_function=None):
self._default = default
self._profile = self._highlighted = None
self._selection_active = False
self._olddata = ()
self._title_extra = ""
# TC: profile dialog window title text.
gtk.Dialog.__init__(self, _("IDJC Profile Manager"))
self.set_size_request(600, 300)
self.set_border_width(6)
w = gtk.ScrolledWindow()
w.set_border_width(6)
w.set_shadow_type(gtk.SHADOW_ETCHED_OUT)
w.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.get_content_area().add(w)
self.store = gtk.ListStore(
gtk.gdk.Pixbuf, str, str, int, str, str, int, int)
self.sorted = gtk.TreeModelSort(self.store)
self.sorted.set_sort_func(1, self._sort_func)
self.sorted.set_sort_column_id(1, gtk.SORT_ASCENDING)
self.treeview = gtk.TreeView(self.sorted)
self.treeview.set_headers_visible(True)
self.treeview.set_rules_hint(True)
w.add(self.treeview)
autorend = gtk.CellRendererPixbuf()
autorend.props.width = 16
autorend.props.stock_id = gtk.STOCK_APPLY
autorend.props.stock_size = gtk.ICON_SIZE_MENU
pbrend = gtk.CellRendererPixbuf()
pbrend.props.width = 16
strrend = gtk.CellRendererText()
ledrend = CellRendererLED()
time_rend = CellRendererTime()
strrend_ellip = gtk.CellRendererText()
strrend_ellip.props.ellipsize = pango.ELLIPSIZE_END
# TC: column heading. The available profile names appears below.
c0 = gtk.TreeViewColumn(None, autorend, visible=7)
image = gtk.image_new_from_stock(gtk.STOCK_OPEN, gtk.ICON_SIZE_MENU)
c0.set_widget(image)
image.show()
self.treeview.append_column(c0)
c1 = gtk.TreeViewColumn(_("Profile"))
c1.pack_start(pbrend, expand=False)
c1.pack_start(strrend)
c1.add_attribute(pbrend, "pixbuf", 0)
c1.add_attribute(strrend, "text", 1)
c1.set_spacing(2)
self.treeview.append_column(c1)
# TC: column heading. The profile nicknames.
c2 = gtk.TreeViewColumn(_("Nickname"), strrend, text=5)
self.treeview.append_column(c2)
# TC: column heading.
c3 = gtk.TreeViewColumn(_("Description"), strrend_ellip, text=2)
c3.set_expand(True)
self.treeview.append_column(c3)
# TC: column heading. The time a particular profile has been running.
c4 = gtk.TreeViewColumn(_("Up-time"))
c4.pack_start(ledrend)
c4.pack_start(time_rend)
c4.add_attribute(ledrend, "active", 3)
c4.add_attribute(time_rend, "time", 6)
c4.set_spacing(2)
self.treeview.append_column(c4)
self.selection = self.treeview.get_selection()
self.selection.connect("changed", self._cb_selection)
box = self.get_action_area()
box.set_spacing(6)
for attr, label, sec, stock in zip(
("new", "clone", "edit", "delete", "auto", "cancel", "choose"),
(gtk.STOCK_NEW, gtk.STOCK_COPY, gtk.STOCK_EDIT,
gtk.STOCK_DELETE, _("_Auto"), gtk.STOCK_QUIT, gtk.STOCK_OPEN),
(True,) * 4 + (False,) * 3,
(True,) * 4 + (False,) + (True,) * 2):
w = gtk.Button(label)
w.set_use_stock(stock)
box.add(w)
box.set_child_secondary(w, sec)
setattr(self, attr, w)
self.delete.set_no_show_all(True)
self.cancel.connect("clicked", self._cb_cancel)
self.set_data_function(data_function)
self.connect("notify::visible", self._cb_visible)
for each in self._signal_names:
getattr(self, each).connect("clicked", self._cb_click, each)
for each in self._new_profile_dialog_signal_names:
getattr(self, each).connect("clicked", self._cb_new_profile_dialog,
each)
def __init__(self, controller):
GLIScreen.GLIScreen.__init__(self, controller)
vert = gtk.VBox(False, 0)
vert.set_border_width(10)
self.gateway = ["",""] # device, ip
self.gateway_is_set = False
self.first_run = False
# Treestore that holds the currently setup devices
# -----------------------------------------------
treedata = gtk.ListStore(gobject.TYPE_INT, gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING)
columns = []
treedatasort = gtk.TreeModelSort(treedata)
treeview = gtk.TreeView(treedatasort)
#self.treeview.connect("cursor-changed", self.selection_changed)
columns.append(gtk.TreeViewColumn("Device ", gtk.CellRendererText(), text=1))
columns.append(gtk.TreeViewColumn("IP Address", gtk.CellRendererText(), text=2))
columns.append(gtk.TreeViewColumn("Broadcast ", gtk.CellRendererText(), text=3))
columns.append(gtk.TreeViewColumn("Netmask ", gtk.CellRendererText(), text=4))
columns.append(gtk.TreeViewColumn("DHCP Options ", gtk.CellRendererText(), text=5))
columns.append(gtk.TreeViewColumn("Gateway ", gtk.CellRendererText(), text=6))
col_num = 0
for column in columns:
column.set_resizable(True)
column.set_sort_column_id(col_num)
treeview.append_column(column)
col_num += 1
treewindow = gtk.ScrolledWindow()
treewindow.set_size_request(-1, 125)
treewindow.set_shadow_type(gtk.SHADOW_IN)
treewindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
treewindow.add(treeview)
# -----------------------------------------------
# Interface frame where you select the device
# -----------------------------------------------
#create the outside box for the ethernet device
frame = gtk.Frame()
# create the ethernet dropdown
ethernet_select_combo = gtk.combo_box_entry_new_text()
# pack it all into a box
ethernet_and_label = gtk.HBox(False,0)
label = gtk.Label(" _Interface: ")
label.set_use_underline(True)
save_button = gtk.Button("Save")
save_button.set_size_request(100,-1)
delete_button = gtk.Button("Delete")
delete_button.set_size_request(100,-1)
ethernet_and_label.pack_start(label, expand=False, fill=False, padding=5)
ethernet_and_label.pack_start(ethernet_select_combo, expand=False, fill=False, padding=5)
ethernet_and_label.pack_start(save_button, expand=False, fill=False, padding=5)
ethernet_and_label.pack_start(delete_button, expand=False, fill=False, padding=5)
# set the new widget to be the label plus the ethernet dropdown
frame.set_label_widget(ethernet_and_label)
# align it to the top left of the frame
frame.set_label_align(0.0, .5)
# -----------------------------------------------
# Type Frame where you select static or dhcp
# -----------------------------------------------
# create the type of ethernet frame
ethernet_type_frame_hbox = gtk.HBox(False, 0)
ethernet_type_frame = gtk.Frame()
ethernet_type_frame.set_border_width(5)
# create the combo that holds the different types of interfaces
ethernet_type_select_combo = gtk.combo_box_new_text()
ethernet_type_select_combo.append_text("DHCP")
ethernet_type_select_combo.append_text("Static")
self.dhcp = 0
self.static = 1
# pack it into a box
ethernet_type_and_label = gtk.HBox(False,0)
label = gtk.Label(" _Configuration: ")
label.set_use_underline(True)
ethernet_type_and_label.pack_start(label, expand=False, fill=False, padding=5)
ethernet_type_and_label.pack_start(ethernet_type_select_combo, expand=False, fill=False, padding=5)
# set the new widget to be the label plus the ethernet dropdown
ethernet_type_frame.set_label_widget(ethernet_type_and_label)
# align it to the top left of the frame
ethernet_type_frame.set_label_align(0.0, .5)
# -----------------------------------------------
# Create the gtk.Notebook to hold the static and dhcp configurations
# -----------------------------------------------
static_and_dhcp_notebook = gtk.Notebook()
static_and_dhcp_notebook.set_show_tabs(False) # hide the tabs
static_and_dhcp_notebook.set_show_border(False) # hide the border
#------------------------------------------------
# Static configuration frame of the gtk.Notebook ( page 1 )
# -----------------------------------------------
# create the static configuration frame
ethernet_static_frame_hbox = gtk.HBox(False, 0)
ethernet_static_frame = gtk.Frame()
ethernet_static_frame.set_border_width(5)
ethernet_static_frame.set_shadow_type(gtk.SHADOW_NONE)
#ethernet_static_frame.set_label("Static Configuration")
#ethernet_static_frame.set_label_align(0.0, .5)
# the hbox to pack the entry boxes into
static_entry_table = gtk.Table(rows=4, columns=2, homogeneous=False)
static_entry_table.set_row_spacings(5)
# create the static ip box
staticip_entry = gtk.Entry()
staticip_entry.set_max_length(15)
# pack it all into a box
label = gtk.Label(" _IP Address: ")
label.set_size_request(50,-1)
label.set_use_underline(True)
label.set_alignment(0.0, 0.5)
#label.set_size_request(150, -1)
static_entry_table.attach(label,0,1,0,1)
static_entry_table.attach(staticip_entry,1,2,0,1)
# create the broadcast box
broadcastip_entry = gtk.Entry()
broadcastip_entry.set_max_length(15)
# pack it all into a box
label = gtk.Label(" _Broadcast: ")
label.set_use_underline(True)
label.set_alignment(0.0, 0.5)
static_entry_table.attach(label,0,1,1,2)
static_entry_table.attach(broadcastip_entry,1,2,1,2)
# create the netmask box
netmaskip_entry = gtk.Entry()
netmaskip_entry.set_max_length(15)
# pack it all into a box
label = gtk.Label(" _Netmask: ")
label.set_use_underline(True)
label.set_alignment(0.0, 0.5)
static_entry_table.attach(label,0,1,2,3)
static_entry_table.attach(netmaskip_entry,1,2,2,3)
# create the gateway box
gatewayip_entry = gtk.Entry()
gatewayip_entry.set_max_length(15)
# pack it all into a box
label = gtk.Label(" _Gateway: ")
label.set_use_underline(True)
label.set_alignment(0.0, 0.5)
static_entry_table.attach(label,0,1,3,4)
static_entry_table.attach(gatewayip_entry,1,2,3,4)
# now add the 1 table to the ethernet_static_frame
static_entry_hbox = gtk.HBox(False,0)
static_entry_hbox.set_border_width(5)
static_entry_hbox.pack_start(static_entry_table, expand=False, fill=False, padding=5)
ethernet_static_frame.add(static_entry_hbox)
static_and_dhcp_notebook.append_page(ethernet_static_frame, gtk.Label("static"))
#------------------------------------------------
# Create the DHCP page of the gtk.Notebook ( page 2 )
# -----------------------------------------------
# create the dhcp configuration frame
ethernet_dhcp_frame_hbox = gtk.HBox(False, 0)
ethernet_dhcp_frame = gtk.Frame()
ethernet_dhcp_frame.set_border_width(5)
ethernet_dhcp_frame.set_shadow_type(gtk.SHADOW_NONE)
#ethernet_dhcp_frame.set_label("DHCP Configuration")
#ethernet_dhcp_frame.set_label_align(0.0, .5)
# the hbox to pack the entry boxes into
dhcp_entry_table = gtk.Table(rows=3, columns=2, homogeneous=False)
dhcp_entry_table.set_row_spacings(5)
# create the dhcp box
dhcp_options_entry = gtk.Entry()
dhcp_options_entry.set_max_length(15)
# pack it all into a box
label = gtk.Label(" _DHCP Options: ")
label.set_size_request(50,-1)
label.set_use_underline(True)
label.set_alignment(0.0, 0.5)
#label.set_size_request(150, -1)
dhcp_entry_table.attach(label,0,1,0,1)
dhcp_entry_table.attach(dhcp_options_entry,0,1,1,2)
# now add the 1 table to the ethernet_static_frame
dhcp_entry_hbox = gtk.HBox(False,0)
dhcp_entry_hbox.set_border_width(50)
dhcp_entry_hbox.pack_start(dhcp_entry_table, expand=False, fill=False, padding=5)
ethernet_dhcp_frame.add(dhcp_entry_hbox)
static_and_dhcp_notebook.append_page(ethernet_dhcp_frame, gtk.Label("dhcp"))
# -----------------------------------------------
# Create the wireless frame to hold wireless information
# -----------------------------------------------
# create the wireless frame
wireless_frame_hbox = gtk.HBox(False, 0)
wireless_frame = gtk.Frame()
#wireless_frame.set_border_width(5)
# align it to the top left of the frame
wireless_frame.set_label_align(0.0, .5)
# create the checkbox that will determine if you have wireless or not
wireless_checkbox = gtk.CheckButton("Wireless")
# pack it all into a box
wireless_and_label = gtk.HBox(False,0)
wireless_and_label.pack_start(wireless_checkbox, expand=False, fill=False, padding=5)
# set the new widget to be the checkbox
wireless_frame.set_label_widget(wireless_and_label)
# create the wireless input boxes
wireless_entry_table = gtk.Table(rows=2, columns=2, homogeneous=False)
wireless_entry_table.set_row_spacings(5)
# create the ESSID box
essid_entry = gtk.Entry()
essid_entry.set_max_length(30)
# pack it all into a box
essid_and_label = gtk.HBox(False,0)
label = gtk.Label(" _ESSID: ")
label.set_use_underline(True)
label.set_alignment(0.0, 0.5)
label.set_size_request(50,-1)
wireless_entry_table.attach(label,0,1,0,1)
wireless_entry_table.attach(essid_entry,1,2,0,1)
# create the Key box
key_entry = gtk.Entry()
key_entry.set_max_length(15)
# pack it all into a box
key_and_label = gtk.HBox(False,0)
label = gtk.Label(" _Key: ")
label.set_use_underline(True)
label.set_alignment(0.0, 0.5)
wireless_entry_table.attach(label,0,1,1,2)
wireless_entry_table.attach(key_entry,1,2,1,2)
# add it to the wireless frame
wireless_entry_hbox = gtk.HBox(False,0)
wireless_entry_hbox.set_border_width(5)
wireless_entry_hbox.pack_start(wireless_entry_table, expand=False, fill=False, padding=5)
wireless_frame.add(wireless_entry_hbox)
# -----------------------------------------------
# Ethernet hardware information frame
# -----------------------------------------------
hardware_frame = gtk.Frame()
#hardware_frame.set_border_width(5)
# align it to the top left of the frame
hardware_frame.set_label_align(0.0, .5)
hardware_frame.set_label("Hardware Information")
# create the textview to hold the hardware information
#textview = gtk.TextView(buffer=None)
#textview.set_editable(False)
#textbuffer = textview.get_buffer()
hardware_label = gtk.Label("No Device Selected")
hardware_label.set_size_request(250,75)
hardware_label.set_line_wrap(True)
#textbuffer.set_text(string)
hardware_frame.add(hardware_label)
# -----------------------------------------------
# add the configuration ethernet frame and wireless frame to the hbox.
configuration_and_wireless_hbox = gtk.HBox(False, 0)
wireless_and_hardware_vbox = gtk.VBox(False,0)
wireless_and_hardware_vbox.pack_start(wireless_frame, expand=True, fill=True, padding=5)
wireless_and_hardware_vbox.pack_start(hardware_frame, expand=True, fill=True, padding=5)
configuration_and_wireless_hbox.pack_start(ethernet_type_frame, expand=True, fill=True, padding=5)
configuration_and_wireless_hbox.pack_start(wireless_and_hardware_vbox, expand=True, fill=True, padding=5)
# add wireless and configuration to interface frame
frame.add(configuration_and_wireless_hbox)
# add the 1 hbox to the ethernet_type frame
#ethernet_type_frame.add(ethernet_static_frame)
# add the gtk.Notebook to the ethernet_type frame.
ethernet_type_frame.add(static_and_dhcp_notebook)
# finally show the frames ( after everything has been added )
ethernet_static_frame.show()
wireless_frame.show()
ethernet_type_frame.show()
frame.show()
# add hostname
bottom_hbox = gtk.VBox(False,0)
hostname_entry = gtk.Entry()
hostname_entry.set_max_length(50) # only as long as ipv4 addresses
hostname_entry.set_size_request(150,-1)
hostname_and_label = gtk.HBox(False,0)
label = gtk.Label(" _Hostname: ")
label.set_use_underline(True)
label.set_size_request(150,-1)
hostname_and_label.pack_start(label, expand=False, fill=False, padding=5)
hostname_and_label.pack_start(hostname_entry, expand=False, fill=False, padding=5)
# add dnsdomainname
dnsdomainname_entry = gtk.Entry()
dnsdomainname_entry.set_max_length(50) # only as long as ipv4 addresses
dnsdomainname_entry.set_size_request(150,-1)
dnsdomainname_and_label = gtk.HBox(False,0)
label = gtk.Label(" _DNS Domain Name: ")
label.set_use_underline(True)
label.set_size_request(150,-1)
dnsdomainname_and_label.pack_start(label, expand=False, fill=False, padding=5)
dnsdomainname_and_label.pack_start(dnsdomainname_entry, expand=False, fill=False, padding=5)
# pack the treewindow and overall options into an hbox
top_window_hbox = gtk.HBox(False, 0)
#static_options_vbox = gtk.VBox(False,0)
#static_options_vbox.pack_start(hostname_and_label, expand=False, fill=False, padding=5)
#static_options_vbox.pack_start(dnsdomainname_and_label, expand=False, fill=False, padding=5)
#static_options_vbox.pack_start(gateway_and_label, expand=False, fill=False, padding=5)
treeview_vbox = gtk.VBox(False,0)
#treeview_vbox.pack_start(gtk.Label("Currently Saved Devices:"), expand=False, fill=False, padding=5)
treeview_vbox.pack_start(treewindow, expand=False, fill=False, padding=5)
top_window_hbox.pack_start(treeview_vbox, expand=True, fill=True, padding=5)
#top_window_hbox.pack_end(static_options_vbox, expand=False, fill=False, padding=5)
bottom_hbox.pack_start(hostname_and_label, expand=False, fill=False, padding=5)
bottom_hbox.pack_start(dnsdomainname_and_label, expand=False, fill=False, padding=5)
# pack the topmost frame
vert.pack_start(top_window_hbox, expand=False, fill=False, padding=0)
vert.pack_start(frame, expand=True, fill=True, padding=10)
#vert.pack_start(bottom_hbox, expand=True, fill=True, padding=5)
notebook = gtk.Notebook()
#notebook.set_show_tabs(False)
#self.add_content(vert)
notebook.set_show_border(False)
notebook.append_page(vert, gtk.Label("Device Information"))
notebook.append_page(bottom_hbox, gtk.Label("Hostname / Proxy Information / Other"))
self.add_content(notebook)
# connect to widget events
treeview.connect("cursor-changed", self.selection_changed)
wireless_checkbox.connect("toggled", self.wireless_clicked)
ethernet_type_select_combo.connect("changed", self.ethernet_type_changed)
ethernet_select_combo.connect("changed", self.ethernet_device_selected)
ethernet_select_combo.child.connect("activate", self.ethernet_device_added)
static_and_dhcp_notebook.connect("switch-page", self.switch)
save_button.connect("clicked", self.save_clicked)
delete_button.connect("clicked", self.delete_clicked)
# add all the boxes that we access later to a dictionary
self.widgets = {"essid":essid_entry, "key":key_entry,
"ipaddress":staticip_entry, "broadcast":broadcastip_entry, "netmask":netmaskip_entry,
"ethernet_type":ethernet_type_select_combo, "wireless_checkbox":wireless_checkbox,
"ethernet_device":ethernet_select_combo, "hardware_info":hardware_label,
"static_dhcp_notebook":static_and_dhcp_notebook, "dhcp_options":dhcp_options_entry,
"treedata":treedata, "treeview":treeview, "gateway":gatewayip_entry,
"hostname":hostname_entry, "domainname":dnsdomainname_entry
}
def __init__(self,
path,
args={},
selmode=gtk.SELECTION_SINGLE,
search_column=-1,
filter_func=None,
data=None,
radio_select=None,
radio_select_func=None,
progressbar=None):
gtk.ScrolledWindow.__init__(self)
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.data = JsonList(radio_select)
if data is None:
r = login.getProxy().getResponse(
path, args=args, hlib=login.getProxy().newConnection())
if r.getheader('transfer-encoding') == 'chunked':
# read first chunk, then read data in thread
res = login.getProxy().chunkJson(r)
self.data.data_header(res['h'])
def __load_thread(self, rows, r, progressbar):
for i in range(1, rows + 1):
res = login.getProxy().chunkJson(r)
def _add_row(data, res, progressbar, rows, i):
data.append_row(res)
if progressbar:
progressbar.set_fraction(i / float(rows))
progressbar.set_text('{0} of {1}'.format(
i, rows))
gobject.idle_add(_add_row, self.data, res, progressbar,
rows, i)
threading.Thread(target=__load_thread,
args=(
self,
res['rows'],
r,
progressbar,
)).start()
else:
data = json.loads(r.read())
self.data.data_header(data['h'])
self.data.reload(data['d'])
else:
self.data.data_header(data['h'])
self.data.reload(data['d'])
if filter_func:
self.data = self.data.filter_new()
self.data.set_filter_func(filter_func)
self.sm = gtk.TreeModelSort(self.data)
self.tv = gtk.TreeView(self.sm)
self.tv.set_rules_hint(True)
self.tv.get_selection().set_mode(selmode)
# set sortable functions for
for i in range(0, self.sm.get_n_columns()):
self.sm.set_sort_func(i, _sort_func, i)
if radio_select is not None:
col = gtk.TreeViewColumn(radio_select)
col.set_expand(False)
cel = gtk.CellRendererToggle()
cel.set_property('radio', True)
if radio_select_func is not None:
cel.connect('toggled', radio_select_func)
col.pack_start(cel)
self.tv.append_column(col)
col.add_attribute(cel, 'active', len(self.data.names))
for i in range(0, len(self.data.names)):
col = gtk.TreeViewColumn(self.data.names[i])
col.set_sort_column_id(i)
if self.data.types[i] == str:
col.set_expand(True)
else:
col.set_expand(False)
if self.data.types[i] == bool:
cel = gtk.CellRendererToggle()
col.pack_start(cel)
col.add_attribute(cel, 'active', i)
elif self.data.types[i] == gobject.TYPE_PYOBJECT:
continue
else:
cel = gtk.CellRendererText()
col.pack_start(cel)
if self.data.renders[i] is not None:
col.set_cell_data_func(cel, self.data.renders[i],
self.data.cols[i])
else:
col.set_attributes(cel, text=self.data.cols[i])
self.tv.append_column(col)
self.tv.set_reorderable(True)
self.tv.set_search_column(search_column)
self.add(self.tv)
def initialise_view(self):
if len(self.shortcircuit) == 0:
# Set TreeViews
self.liststorefs = gtk.ListStore(str, str, str, str, str, long,
gobject.TYPE_PYOBJECT)
list_filter = self.liststorefs.filter_new()
list_sort = gtk.TreeModelSort(list_filter)
list_sort.set_sort_column_id(1, gtk.SORT_ASCENDING)
self.snaptreeview = self.xml.get_widget("snaplist")
self.snaptreeview.set_model(self.liststorefs)
self.snaptreeview.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
cell0 = gtk.CellRendererText()
cell1 = gtk.CellRendererText()
cell2 = gtk.CellRendererText()
cell3 = gtk.CellRendererText()
cell4 = gtk.CellRendererText()
cell5 = gtk.CellRendererText()
typecol = gtk.TreeViewColumn(_("Type"),
cell0, text = 0)
typecol.set_sort_column_id(0)
typecol.set_resizable(True)
typecol.connect("clicked",
self.__on_treeviewcol_clicked, 0)
self.snaptreeview.append_column(typecol)
mountptcol = gtk.TreeViewColumn(_("Mount Point"),
cell1, text = 1)
mountptcol.set_sort_column_id(1)
mountptcol.set_resizable(True)
mountptcol.connect("clicked",
self.__on_treeviewcol_clicked, 1)
self.snaptreeview.append_column(mountptcol)
fsnamecol = gtk.TreeViewColumn(_("File System Name"),
cell2, text = 2)
fsnamecol.set_sort_column_id(2)
fsnamecol.set_resizable(True)
fsnamecol.connect("clicked",
self.__on_treeviewcol_clicked, 2)
self.snaptreeview.append_column(fsnamecol)
snaplabelcol = gtk.TreeViewColumn(_("Snapshot Name"),
cell3, text = 3)
snaplabelcol.set_sort_column_id(3)
snaplabelcol.set_resizable(True)
snaplabelcol.connect("clicked",
self.__on_treeviewcol_clicked, 3)
self.snaptreeview.append_column(snaplabelcol)
cell4.props.xalign = 1.0
creationcol = gtk.TreeViewColumn(_("Creation Time"),
cell4, text = 4)
creationcol.set_sort_column_id(5)
creationcol.set_resizable(True)
creationcol.connect("clicked",
self.__on_treeviewcol_clicked, 5)
self.snaptreeview.append_column(creationcol)
# Note to developers.
# The second element is for internal matching and should not
# be i18ned under any circumstances.
typestore = gtk.ListStore(str, str)
typestore.append([_("All"), "All"])
typestore.append([_("Backups"), "Backup"])
typestore.append([_("Snapshots"), "Snapshot"])
self.typefiltercombo = self.xml.get_widget("typefiltercombo")
self.typefiltercombo.set_model(typestore)
typefiltercomboCell = gtk.CellRendererText()
self.typefiltercombo.pack_start(typefiltercomboCell, True)
self.typefiltercombo.add_attribute(typefiltercomboCell, 'text',0)
# Note to developers.
# The second element is for internal matching and should not
# be i18ned under any circumstances.
fsstore = gtk.ListStore(str, str)
fslist = self.datasets.list_filesystems()
fsstore.append([_("All"), None])
for fsname,fsmount in fslist:
fsstore.append([fsname, fsname])
self.fsfilterentry = self.xml.get_widget("fsfilterentry")
self.fsfilterentry.set_model(fsstore)
self.fsfilterentry.set_text_column(0)
fsfilterentryCell = gtk.CellRendererText()
self.fsfilterentry.pack_start(fsfilterentryCell)
schedstore = gtk.ListStore(str, str)
# Note to developers.
# The second element is for internal matching and should not
# be i18ned under any circumstances.
schedstore.append([_("All"), None])
schedstore.append([_("Monthly"), "monthly"])
schedstore.append([_("Weekly"), "weekly"])
schedstore.append([_("Daily"), "daily"])
schedstore.append([_("Hourly"), "hourly"])
schedstore.append([_("1/4 Hourly"), "frequent"])
self.schedfilterentry = self.xml.get_widget("schedfilterentry")
self.schedfilterentry.set_model(schedstore)
self.schedfilterentry.set_text_column(0)
schedentryCell = gtk.CellRendererText()
self.schedfilterentry.pack_start(schedentryCell)
self.schedfilterentry.set_active(0)
self.fsfilterentry.set_active(0)
self.typefiltercombo.set_active(0)
else:
cloned = self.datasets.list_cloned_snapshots()
num_snap = 0
num_rsync = 0
for snapname in self.shortcircuit:
# Filter out snapshots that are the root
# of cloned filesystems or volumes
try:
cloned.index(snapname)
dialog = gtk.MessageDialog(None,
0,
gtk.MESSAGE_ERROR,
gtk.BUTTONS_CLOSE,
_("Snapshot can not be deleted"))
text = _("%s has one or more dependent clones "
"and will not be deleted. To delete "
"this snapshot, first delete all "
"datasets and snapshots cloned from "
"this snapshot.") \
% snapname
dialog.format_secondary_text(text)
dialog.run()
sys.exit(1)
except ValueError:
path = os.path.abspath (snapname)
if not os.path.exists (path):
snapshot = zfs.Snapshot(snapname)
self.backuptodelete.append(snapshot)
num_snap += 1
else:
self.backuptodelete.append(RsyncBackup (snapname))
num_rsync += 1
confirm = self.xml.get_widget("confirmdialog")
summary = self.xml.get_widget("summarylabel")
total = len(self.backuptodelete)
text = ""
if num_rsync != 0 :
if num_rsync == 1:
text = _("1 external backup will be deleted.")
else:
text = _("%d external backups will be deleted.") % num_rsync
if num_snap != 0 :
if len(text) != 0:
text += "\n"
if num_snap == 1:
text += _("1 snapshot will be deleted.")
else:
text += _("%d snapshots will be deleted.") % num_snap
summary.set_text(text )
response = confirm.run()
if response != 2:
sys.exit(0)
else:
# Create the thread in an idle loop in order to
# avoid deadlock inside gtk.
glib.idle_add(self.__init_delete)
return False
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/share/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 getScreen (self, anaconda):
# We can't just use exclusiveDisks here because of kickstart. First,
# the kickstart file could have used ignoredisk --drives= in which case
# exclusiveDisks would be empty. Second, ignoredisk is entirely
# optional in which case neither list would be populated. Luckily,
# storage.disks takes isIgnored into account and that handles both these
# issues.
disks = filter(lambda d: not d.format.hidden, anaconda.storage.disks)
# Skip this screen as well if there's only one disk to use.
if len(disks) == 1:
anaconda.storage.clearPartDisks = [disks[0].name]
anaconda.bootloader.drivelist = [disks[0].name]
return None
(xml, self.vbox) = gui.getGladeWidget("cleardisks.glade", "vbox")
self.leftScroll = xml.get_widget("leftScroll")
self.rightScroll = xml.get_widget("rightScroll")
self.addButton = xml.get_widget("addButton")
self.removeButton = xml.get_widget("removeButton")
self.installTargetImage = xml.get_widget("installTargetImage")
self.installTargetTip = xml.get_widget("installTargetTip")
self.anaconda = anaconda
self.leftVisible = 1
self.leftActive = 2
self.rightVisible = 4
self.rightActive = 5
# One store for both views. First the obejct, then a visible/active for
# the left hand side, then a visible/active for the right hand side, then
# all the other stuff.
#
# NOTE: the third boolean is a placeholder. DeviceSelector uses the third
# slot in the store to determine whether the row is immutable or not. We
# just need to put False in there for everything.
self.store = gtk.TreeStore(gobject.TYPE_PYOBJECT,
gobject.TYPE_BOOLEAN, gobject.TYPE_BOOLEAN,
gobject.TYPE_BOOLEAN,
gobject.TYPE_BOOLEAN, gobject.TYPE_BOOLEAN,
gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING)
self.store.set_sort_column_id(6, gtk.SORT_ASCENDING)
# The left view shows all the drives that will just be mounted, but
# can still be moved to the right hand side.
self.leftFilteredModel = self.store.filter_new()
self.leftSortedModel = gtk.TreeModelSort(self.leftFilteredModel)
self.leftTreeView = gtk.TreeView(self.leftSortedModel)
self.leftFilteredModel.set_visible_func(lambda model, iter, view: model.get_value(iter, self.leftVisible), self.leftTreeView)
self.leftScroll.add(self.leftTreeView)
self.leftDS = DeviceSelector(self.store, self.leftSortedModel,
self.leftTreeView, visible=self.leftVisible,
active=self.leftActive)
self.leftDS.createMenu()
self.leftDS.addColumn(_("Model"), 6)
self.leftDS.addColumn(_("Capacity"), 7)
self.leftDS.addColumn(_("Vendor"), 8)
self.leftDS.addColumn(_("Identifier"), 9)
self.leftDS.addColumn(_("Interconnect"), 10, displayed=False)
# The right view show all the drives that will be wiped during install.
self.rightFilteredModel = self.store.filter_new()
self.rightSortedModel = gtk.TreeModelSort(self.rightFilteredModel)
self.rightTreeView = gtk.TreeView(self.rightSortedModel)
self.rightFilteredModel.set_visible_func(lambda model, iter, view: model.get_value(iter, self.rightVisible), self.rightTreeView)
self.rightScroll.add(self.rightTreeView)
self.rightDS = DeviceSelector(self.store, self.rightSortedModel,
self.rightTreeView, visible=self.rightVisible,
active=self.rightActive)
self.rightDS.createSelectionCol(title=_("Boot\nLoader"), radioButton=True)
self.rightDS.createMenu()
self.rightDS.addColumn(_("Model"), 6)
self.rightDS.addColumn(_("Capacity"), 7)
self.rightDS.addColumn(_("Identifier"), 9)
# Store the first disk (according to our detected BIOS order) for
# auto boot device selection
names = map(lambda d: d.name, disks)
self.bootDisk = sorted(names, self.anaconda.storage.compareDisks)[0]
# The device filtering UI set up exclusiveDisks as a list of the names
# of all the disks we should use later on. Now we need to go get those,
# look up some more information in the devicetree, and set up the
# selector.
for d in disks:
rightVisible = d.name in self.anaconda.storage.clearPartDisks
rightActive = rightVisible and \
d.name in self.anaconda.bootloader.drivelist[:1]
leftVisible = not rightVisible
if hasattr(d, "wwid"):
ident = d.wwid
else:
try:
ident = deviceNameToDiskByPath(d.name)
if ident.startswith("/dev/disk/by-path/"):
ident = ident.replace("/dev/disk/by-path/", "")
except DeviceNotFoundError:
ident = d.name
self.store.append(None, (d,
leftVisible, True, False,
rightVisible, rightActive,
d.model,
str(int(d.size)) + " MB",
d.vendor, ident, d.bus))
self.addButton.connect("clicked", self._add_clicked)
self.removeButton.connect("clicked", self._remove_clicked)
# Also allow moving devices back and forth with double click, enter, etc.
self.leftTreeView.connect("row-activated", self._add_clicked)
self.rightTreeView.disconnect(self.rightDS._activated_id)
self.rightTreeView.connect("row-activated", self._remove_clicked)
# And let the user select multiple devices at a time.
self.leftTreeView.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.rightTreeView.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
if self.anaconda.storage.clearPartType == CLEARPART_TYPE_LINUX:
self.installTargetTip.set_markup(_("<b>Tip:</b> All Linux filesystems on the install target devices will be reformatted and wiped of any data. Make sure you have backups."))
elif self.anaconda.storage.clearPartType == CLEARPART_TYPE_ALL:
self.installTargetTip.set_markup(_("<b>Tip:</b> The install target devices will be reformatted and wiped of any data. Make sure you have backups."))
else:
self.installTargetTip.set_markup(_("<b>Tip:</b> Your filesystems on the install target devices will not be reformatted unless you choose to do so during customization."))
return self.vbox
def createGamesWindow(self):
'''
Create TreeView of all Games on the server.
@return: gtk.VBox containing a TreeView of all Games on the server.
'''
vbox = gtk.VBox(False, 1)
self.gameList = gtk.TreeStore(str, str, str)
self.client.getGameList()
self.gameView = gtk.TreeView(gtk.TreeModelSort(self.gameList))
self.gameView.set_headers_clickable(True)
self.gameView.connect("button-press-event", self.gameListClicked_cb)
title = _('Game')
col1 = gtk.TreeViewColumn('%s' % title)
col1.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE)
cell1 = gtk.CellRendererText()
col1.pack_start(cell1, True)
col1.add_attribute(cell1, 'text', 0)
col1.set_sort_column_id(0)
title = _('Players')
col2 = gtk.TreeViewColumn('# %s' % title)
cell2 = gtk.CellRendererText()
col2.pack_start(cell2, True)
col2.add_attribute(cell2, 'text', 1)
col2.set_sort_column_id(1)
title = _('Status')
col3 = gtk.TreeViewColumn('%s' % title)
cell3 = gtk.CellRendererText()
col3.pack_start(cell3, True)
col3.add_attribute(cell3, 'text', 2)
col3.set_sort_column_id(2)
self.gameView.append_column(col1)
self.gameView.append_column(col2)
self.gameView.append_column(col3)
header = gtk.Label()
title = _('Game Listing')
header.set_markup("<b><big>%s:</big></b>" % title)
header.set_justify(gtk.JUSTIFY_LEFT)
bbox = gtk.HButtonBox()
self.joinButton = gtk.Button(label=_("Join Game"))
self.spectateButton = gtk.Button(label=_("Watch Game"))
self.spectateButton.connect("clicked", self.spectateGame)
self.joinButton.connect("clicked", self.joinGame_cb)
bbox.add(self.joinButton)
bbox.add(self.spectateButton)
window = gtk.ScrolledWindow()
window.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
window.add(self.gameView)
vbox.pack_start(header, False, False, 1)
vbox.pack_start(window, True, True, 0)
vbox.pack_start(bbox, False, False, 0)
return vbox
def makeTreeViews(self):
# User tree
self.treestore = gtk.TreeStore(str)
self.tm = gtk.TreeModelSort(self.treestore)
self.tm.set_sort_column_id(0, gtk.SORT_ASCENDING)
self.treeview = gtk.TreeView(self.tm)
self.tvcolumn = gtk.TreeViewColumn('Online Users')
self.treeview.append_column(self.tvcolumn)
self.cell = gtk.CellRendererText()
self.treeview.set_headers_clickable(True)
self.treeview.connect("button_press_event", self.treeviewCallback,
None)
self.cellpb = gtk.CellRendererPixbuf()
self.tvcolumn.pack_start(self.cellpb, True)
self.tvcolumn.pack_start(self.cell, False)
self.tvcolumn.add_attribute(self.cell, 'text', 0)
self.tvcolumn.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
self.tvcolumn.set_cell_data_func(self.cellpb, self.userImage)
self.tvcolumn.set_sort_column_id(0)
scrolled = gtk.ScrolledWindow()
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled.set_shadow_type(gtk.SHADOW_IN)
scrolled.add(self.treeview)
self.table.attach(scrolled, 4, 6, 0, 8)
self.userPanel = userPanel(self.treestore)
# Channel tree
self.chantreestore = gtk.TreeStore(str, int, str)
self.chantm = gtk.TreeModelSort(self.chantreestore)
self.chantm.set_sort_column_id(0, gtk.SORT_ASCENDING)
self.chantreeview = gtk.TreeView(self.chantm)
tvcolumn = gtk.TreeViewColumn('Channel name')
tvcolumn2 = gtk.TreeViewColumn("Persons")
tvcolumn3 = gtk.TreeViewColumn("Description")
self.chantreeview.set_headers_clickable(True)
self.chantreeview.connect("button_press_event", self.chanviewCallback,
None)
self.chancell = gtk.CellRendererText()
tvcolumn.pack_start(self.chancell, False)
tvcolumn.add_attribute(self.chancell, 'text', 0)
self.tvcolumn.set_sort_column_id(0)
self.chancell = gtk.CellRendererText()
tvcolumn2.pack_start(self.chancell, False)
tvcolumn2.add_attribute(self.chancell, 'text', 1)
tvcolumn2.set_sort_column_id(1)
tvcolumn3.pack_start(self.chancell, False)
tvcolumn3.add_attribute(self.chancell, 'text', 2)
tvcolumn3.set_sort_column_id(2)
self.chantreeview.append_column(tvcolumn)
self.chantreeview.append_column(tvcolumn2)
self.chantreeview.append_column(tvcolumn3)
scrolled = gtk.ScrolledWindow()
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled.set_shadow_type(gtk.SHADOW_IN)
scrolled.add(self.chantreeview)
self.channel_table.attach(scrolled, 0, 6, 0, 8, gtk.FILL, gtk.FILL, 20)
self.chanPanel = chanPanel(self.chantreestore)
# Server tree
server_treestore = gtk.TreeStore(str)
tm = gtk.TreeModelSort(server_treestore)
tm.set_sort_column_id(0, gtk.SORT_ASCENDING)
treeview = gtk.TreeView(tm)
tvcolumn = gtk.TreeViewColumn('Servers')
treeview.append_column(tvcolumn)
treeview.set_headers_clickable(True)
self.server_treeview = treeview
cell = gtk.CellRendererText()
tvcolumn.pack_start(cell, False)
tvcolumn.add_attribute(cell, 'text', 0)
tvcolumn.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
tvcolumn.set_sort_column_id(0)
scrolled = gtk.ScrolledWindow()
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled.set_shadow_type(gtk.SHADOW_IN)
scrolled.add(treeview)
self.server_tab.attach(scrolled, 0, 7, 1, 7, gtk.FILL, gtk.FILL, 20)
self.server_treestore = server_treestore
self.server_model = tm
self.load_servers_from_file()
def load(self):
splash, gui = self.splash, self.gui
# Create the model for the exercise list (cols == columns)
self.ex_ls_cols = {
"file": 0,
"fir": 1,
"sector": 2,
"comment": 3,
"course": 4,
"phase": 5,
"day": 6,
"pass_no": 7,
"shift": 8,
"PDP": 9,
"course_text": 10,
"n_flights": 11,
"CPDP": 12,
"wind_text": 13,
"exercise_id": 14,
"ejer": 15
}
# els = exercise list store
els = self.els = gtk.ListStore(str, str, str, str, int, int, int, int,
str, str, str, int, str, str, str, int)
# This is the mapping between actually displayed cols and the model cols
self.ex_tv_cols = (("FIR", "fir"), ("Sector", "sector"),
("Prom - Fase - Día - Pasada", "CPDP"),
("Ejer.", "ejer"), ("Vuelos", "n_flights"),
("Viento", "wind_text"), ("Comentario", "comment"))
# Process all exercise and fir files
self.exercises = []
self.firs = []
# Find possible directories containing exercices
pb = splash.get_widget("progressbar")
pb.set_text('Cargando ejercicios')
dirs = [
dir for dir in os.listdir(EX_DIR) if dir[-4:] != ".svn"
and S_ISDIR(os.stat(os.path.join(EX_DIR, dir))[ST_MODE])
]
n_dirs = len(dirs)
i = 0.
for dir in dirs: # File includes the path, filename doesn't
pb.set_text(dir)
i += 1. / n_dirs
dir = os.path.join(EX_DIR, dir)
pb.set_fraction(i)
while gtk.events_pending():
gtk.main_iteration()
for e in load_exercises(dir):
els.append(self.get_tvrow_from_ex(e))
self.exercises.append(e)
self.firs += load_firs(dir)
self.etf = etf = els.filter_new() # Exercise TreeFilter
self.filters = {
"fir": "---",
"sector": "---",
"course": "---",
"phase": "---"
}
etf.set_visible_func(self.ex_is_visible)
etv = self.etv # Exercise Tree View
etv.set_model(gtk.TreeModelSort(etf))
etv.get_selection().set_mode(gtk.SELECTION_SINGLE)
renderer = gtk.CellRendererText()
for i, name in [(self.ex_ls_cols[ls_col], name)
for (name, ls_col) in self.ex_tv_cols]:
column = gtk.TreeViewColumn(utf8conv(name), renderer, text=i)
column.set_clickable(True)
column.set_sort_column_id(i)
column.set_resizable(True)
etv.append_column(column)
renderer.props.ypad = 0
self.n_ex = len(els)
self.sb.push(0, utf8conv("Cargados " + str(self.n_ex) + " ejercicios"))
self.set_filter() # Load all combos with all options
UI.set_active_text(self.fircombo, conf.fir_option)
UI.set_active_text(self.sectorcombo, conf.sector_option)
UI.set_active_text(self.coursecombo, conf.course_option)
UI.set_active_text(self.phasecombo, conf.phase_option)
# Load aircraft type information
self.types = BADA.load_types()
# Everything's ready. Hide Splash, present Main Window
splash.get_widget("Splash").destroy()
self.MainWindow.present()