def __init__(self):
self.treestore = gtk.TreeStore(
gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING)
return
def __create_widgets(self):
"""
"""
self.__cell = gtk.CellRendererText()
# texteditor widgets
self.__texteditor = BWTextEditor()
self.__texteditor.bw_modify_font(self.__font)
self.__texteditor.bw_set_editable(False)
self.__texteditor.set_border_width(0)
self.__select_combobox = gtk.combo_box_new_text()
self.__select_combobox.connect('changed', self.__change_text_value)
self.__viewer = BWVBox(spacing=6)
self.__viewer.set_border_width(6)
self.__viewer.bw_pack_start_noexpand_nofill(self.__select_combobox)
self.__viewer.bw_pack_start_expand_fill(self.__texteditor)
self.__text = list()
# ports information
number_of_ports = len(self.__node.get_info('ports'))
self.__ports_label = BWLabel(_('Ports (%s)') % number_of_ports)
self.__ports_scroll = BWScrolledWindow()
self.__ports_store = gtk.TreeStore(
gobject.TYPE_INT, gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_BOOLEAN)
self.__ports_treeview = gtk.TreeView(self.__ports_store)
for port in self.__node.get_info('ports'):
color = get_service_color(port['state']['state'])
service_name = port['service'].get('name', _('<unknown>'))
service_method = port['service'].get('method', _('<none>'))
reference = self.__ports_store.append(None, [
port['id'], port['protocol'], port['state']['state'],
service_name, service_method, color, True
])
for key in port['state']:
self.__ports_store.append(reference, [
port['id'], 'state', key, port['state'][key], '', 'white',
True
])
for key in port['service']:
if key in ['servicefp']:
text = _('[%d] service: %s') % (port['id'], key)
self.__select_combobox.append_text(text)
self.__text.append(port['service'][key])
value = _('<special field>')
else:
value = port['service'][key]
self.__ports_store.append(
reference,
[port['id'], 'service', key, value, '', 'white', True])
#for script in port['scripts']:
# text = _('[%d] script: %s') % (port['id'], script['id'])
# self.__select_combobox.append_text(text)
# self.__text.append(script['output'])
#
# self.__ports_store.append(reference,
# [port['id'],
# 'script',
# 'id',
# script['id'],
# _('<special field>'),
# 'white',
# True])
self.__ports_column = list()
for i in range(len(PORTS_HEADER)):
column = gtk.TreeViewColumn(PORTS_HEADER[i], self.__cell, text=i)
self.__ports_column.append(column)
self.__ports_column[i].set_reorderable(True)
self.__ports_column[i].set_resizable(True)
self.__ports_column[i].set_sort_column_id(i)
self.__ports_column[i].set_attributes(self.__cell,
text=i,
background=5,
editable=6)
self.__ports_treeview.append_column(self.__ports_column[i])
self.__ports_scroll.add_with_viewport(self.__ports_treeview)
# extraports information
number_of_xports = 0
self.__xports_scroll = BWScrolledWindow()
self.__xports_store = gtk.TreeStore(gobject.TYPE_INT,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_BOOLEAN)
self.__xports_treeview = gtk.TreeView(self.__xports_store)
for xports in self.__node.get_info('extraports'):
color = get_service_color(xports['state'])
number_of_xports += xports['count']
reference = self.__xports_store.append(None, [
xports['count'], xports['state'], ", ".join(xports['reason']),
color, True
])
for xreason in xports['all_reason']:
self.__xports_store.append(reference, [
xreason['count'], xports['state'], xreason['reason'],
'white', True
])
self.__xports_column = list()
for i in range(len(EXTRAPORTS_HEADER)):
column = gtk.TreeViewColumn(EXTRAPORTS_HEADER[i],
self.__cell,
text=i)
self.__xports_column.append(column)
self.__xports_column[i].set_reorderable(True)
self.__xports_column[i].set_resizable(True)
self.__xports_column[i].set_sort_column_id(i)
self.__xports_column[i].set_attributes(self.__cell,
text=i,
background=3,
editable=4)
self.__xports_treeview.append_column(self.__xports_column[i])
xports_label_text = _('Extraports (%s)') % number_of_xports
self.__xports_label = BWLabel(xports_label_text)
self.__xports_scroll.add_with_viewport(self.__xports_treeview)
self.append_page(self.__ports_scroll, self.__ports_label)
self.append_page(self.__xports_scroll, self.__xports_label)
self.append_page(self.__viewer, BWLabel(_('Special fields')))
if len(self.__text) > 0:
self.__select_combobox.set_active(0)
def __init__(self, policy, widgets):
tree_view = widgets.get_widget('components')
tree_view.set_property('has-tooltip', True)
def callback(widget, x, y, keyboard_mode, tooltip):
x, y = tree_view.convert_widget_to_bin_window_coords(x, y)
pos = tree_view.get_path_at_pos(x, y)
if pos:
tree_view.set_tooltip_cell(tooltip, pos[0], pos[1], None)
path = pos[0]
try:
col_index = column_objects.index(pos[1])
except ValueError:
return False
else:
col = self.columns[col_index][1]
row = self.model[path]
iface = row[InterfaceBrowser.INTERFACE]
main_feed = self.policy.config.iface_cache.get_feed(
iface.uri)
tooltip.set_text(
get_tooltip_text(self, iface, main_feed, col))
return True
else:
return False
tree_view.connect('query-tooltip', callback)
self.policy = policy
self.cached_icon = {} # URI -> GdkPixbuf
self.default_icon = tree_view.style.lookup_icon_set(
gtk.STOCK_EXECUTE).render_icon(tree_view.style, gtk.TEXT_DIR_NONE,
gtk.STATE_NORMAL,
gtk.ICON_SIZE_SMALL_TOOLBAR,
tree_view, None)
self.model = gtk.TreeStore(object, str, str, str, str, gtk.gdk.Pixbuf,
str, bool)
self.tree_view = tree_view
tree_view.set_model(self.model)
column_objects = []
text = gtk.CellRendererText()
coloured_text = gtk.CellRendererText()
for name, model_column in self.columns:
if model_column == InterfaceBrowser.INTERFACE_NAME:
column = gtk.TreeViewColumn(name,
IconAndTextRenderer(),
text=model_column,
image=InterfaceBrowser.ICON)
elif model_column == None:
menu_column = column = gtk.TreeViewColumn(
'', MenuIconRenderer())
else:
if model_column == InterfaceBrowser.SUMMARY:
text_ellip = gtk.CellRendererText()
try:
text_ellip.set_property('ellipsize',
pango.ELLIPSIZE_END)
except:
pass
column = gtk.TreeViewColumn(name,
text_ellip,
text=model_column)
column.set_expand(True)
elif model_column == InterfaceBrowser.VERSION:
column = gtk.TreeViewColumn(
name,
coloured_text,
text=model_column,
background=InterfaceBrowser.BACKGROUND)
else:
column = gtk.TreeViewColumn(name, text, text=model_column)
tree_view.append_column(column)
column_objects.append(column)
tree_view.set_enable_search(True)
selection = tree_view.get_selection()
def button_press(tree_view, bev):
pos = tree_view.get_path_at_pos(int(bev.x), int(bev.y))
if not pos:
return False
path, col, x, y = pos
if (bev.button == 3 or (bev.button < 4 and col is menu_column)) \
and bev.type == gtk.gdk.BUTTON_PRESS:
selection.select_path(path)
iface = self.model[path][InterfaceBrowser.INTERFACE]
self.show_popup_menu(iface, bev)
return True
if bev.button != 1 or bev.type != gtk.gdk._2BUTTON_PRESS:
return False
properties.edit(policy,
self.model[path][InterfaceBrowser.INTERFACE],
self.compile,
show_versions=True)
tree_view.connect('button-press-event', button_press)
tree_view.connect('destroy',
lambda s: policy.watchers.remove(self.build_tree))
policy.watchers.append(self.build_tree)
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 any(rows_are_descendants))
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 emf_gentree():
# Record/Group Name Rec. Type Min. Length Template
model = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_INT,
gobject.TYPE_STRING, gobject.TYPE_PYOBJECT)
view = gtk.TreeView(model)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn('Group/Record', renderer, text=0)
column2 = gtk.TreeViewColumn('Length', renderer, text=2)
view.append_column(column)
view.append_column(column2)
# Bitmap Record Types
bmprec = (0x72, 0x4c, 0x4e, 0x4f, 0x50, 0x4d, 0x51, 0x74)
# CLipping Record Types
cliprec = (0x1a, 0x1c, 0x1d, 0x1e, 0x43, 0x4b)
# Comment Record Type and Control Record Types
ctrlrec = (0x46, 0x1, 0xE)
# Drawing Record Types
drawrec= ((0x2,28), (0x3,28), (0x4,28), (0x5,28), (0x6,28), (0x7,32), (0x8,28), (0xF,20), (0x29, 28), (0x2a, 24), (0x2b,24), (0x2c,32), (0x2d, 40), (0x2e, 40), (0x2f,40),\
(0x35,24), (0x36,16), (0x37, 40), (0x38,28), (0x3e,24), (0x3f,24), (0x40,24), (0x47,32), (0x48,40), (0x4a,28), (0x53, 36), (0x54,36), (0x55,28),\
(0x56,28),(0x57,28), (0x58,28), (0x59,28), (0x5a,32), (0x5b,32), (0x5c,28), (0x60,36), (0x61,36), (0x6c,52), (0x76,36))
# Escape Record Types
escrec = (0x69, 0x6a, 0x6e)
# Object Creation Record Types
objcrec = ((0x5d, 32), (0x5e, 32), (0x5f, 32), (0x7a, 20), (0x26, 28),
(0x27, 24), (0x31, 12), (0x52, 16), (0x63, 12))
# Object Manipulation Record Types
objmrec = (0x25, 0x28, 0x30, 0x32, 0x33, 0x64, 0x65, 0x6f)
# OpenGL Record Types
## 0x66, 0x67
# Path Bracket Record Types
pathrec = (0x3b, 0x3c, 0x3d, 0x41, 0x42, 0x44)
# State Record Types
staterec = (0xa, 0xb, 0xc, 0xd, 0x17, 0x1b, 0x1f, 0x9, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,\
0x16, 0x18, 0x19, 0x20, 0x21, 0x22, 0x34, 0x39, 0x3a, 0x49, 0x62, 0x68, 0x6d,\
0x70, 0x71, 0x73, 0x77, 0x78, 0x79)
# Transform Record Types
## 0x23, 0x24
# EMF+ Record Templates
plusrec = (
(2, 0x30, "\x08\x40\x01\x02\x30\x00\x00\x00\x24\x00\x00\x00\x02\x10\xc0\xdb"+"\x00"*4+"\x80\x00\x00\x00\x02"+"\x00"*5+"\x80\x3f"+"\x00"*4+"\x02\x10\xc0\xdb"+"\x00"*8),
(3, 0x28, "\x08\x40\x00\x03\xc4\x00\x00\x00\xb8\x00\x00\x00\x02\x10\xc0\xdb\x04" +"\x00"*40 + "\x01\x01\x81"),
(6, 0x30, "\x08\x40\x02\x06\x30\x00\x00\x00\x24\x00\x00\x00\x02\x10\xc0\xdb\x00\x22\xbc\x3d"+"\x00"*12+"\x05\x00\x00\x00\x41\x00\x52\x00\x49\x00\x41\x00\x4c\x00\x00\x00"),
(0x4001, 0x1c, "\x01\x40\x01\x00\x1c\x00\x00\x00\x10\x00\x00\x00\x02\x10\xc0\xdb\x01\x00\x00\x00"+"\x60\x00\x00\x00"*2),
(0x4002, 0xc, "\x02\x40\x00\x00\x0c"+"\x00"*7),
(0x4004, 0xc, "\x04\x40\x00\x00\x0c"+"\x00"*7),
(0x400a, 0x24, "\x0a\x40\x00\x00\x24\x00\x00\x00\x18"+"\x00\x00\x00\x01"*2+"\x00"*13+"\x20\x41\x00\x00\x80\x40"),
(0x4014, 0x10, "\x14\x40\x00\x80\x10\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\x00"),
(0x4015, 0x10, "\x15\x40\x00\x00\x10\x00\x00\x00\x04"+"\x00"*7),
(0x401d, 0x14, "\x1d\x40\x00\x00\x14\x00\x00\x00\x08"+"\x00"*11),
(0x401e, 0xc, "\x1e\x40\x0b\x00\x0c"+"\x00"*7),
(0x401f, 0xc, "\x1e\x40\x05\x00\x0c"+"\x00"*7),
(0x4021, 0xc, "\x21\x40\x07\x00\x0c"+"\x00"*7),
(0x4022, 0xc, "\x21\x40\x03\x00\x0c"+"\x00"*7),
(0x4024, 0xc, "\x24\x40\x02\x00\x0c"+"\x00"*7),
(0x4025, 0x10, "\x25\x40\x00\x00\x10\x00\x00\x00\x04"+"\x00"*7),
(0x4026, 0x10, "\x29\x40\x00\x00\x10\x00\x00\x00\x04"+"\x00"*7),
(0x4028, 0x10, "\x28\x40\x00\x00\x10\x00\x00\x00\x04"+"\x00"*7),
(0x4029, 0x10, "\x29\x40\x00\x00\x10\x00\x00\x00\x04"+"\x00"*7),
(0x402a, 0x24, "\x2a\x40\x00\x00\x24\x00\x00\x00\x18" +"\x00"*5+"x80\x3f"+"\x00"*10+"\x80\x3f"+"\x00"*8),
(0x402b, 0xc, "\x2b\x40\x00\x00\x0c"+"\x00"*7),
(0x402c, 0x24, "\x2c\x40\x00\x00\x24\x00\x00\x00\x18" +"\x00"*5+"x80\x3f"+"\x00"*10+"\x80\x3f"+"\x00"*8),
(0x4030, 0x10, "\x30\x40\x02\x00\x10\x00\x00\x00\x04"+"\x00"*5+"\x80\x3f"),
(0x4033, 0xc, "\x33\x40\x00\x01\x0c"+"\x00"*7),
(0x4034, 0xc, "\x34\x40\x04\x00\x0c"+"\x00"*7),
(0x4036, 0x5c, "\x36\x40\x02\x80\x5c\x00\x00\x00\x50\x00\x00\x00\xff\xff\xff\xff"+"\x01\x00\x00\x00"*2\
+ "\x04\x00\x00\x00\x54\x00\x45\x00\x53\x00\x54\x00"+("\x00"*7+"\x3f"+ "\x00\x00\x80\x3f\x00\x00\xc0\x3f")*2\
+"\x00\x00\x80\x3f"+"\x00"*10+"\x80\x3f"+"\x00"*8),
)
iter = model.append(None, None)
model.set(iter, 0, "EMF+ Records", 1, -1, 2, "")
for i in range(len(plusrec)):
niter = model.append(iter, None)
if plusrec[i][0] > 0x4000:
model.set(niter, 0, emrplus_ids[plusrec[i][0]], 1, plusrec[i][0],
2, plusrec[i][1], 3, plusrec[i][2])
else:
model.set(niter, 0,
"Object %s" % emfplus.ObjectType[plusrec[i][0]], 1,
0x4008, 2, plusrec[i][1], 3, plusrec[i][2])
iter = model.append(None, None)
model.set(iter, 0, "Bitmap Records", 1, -1, 2, "")
for i in range(len(bmprec)):
niter = model.append(iter, None)
model.set(niter, 0, emr_ids[bmprec[i]], 1, bmprec[i], 2, 8)
iter = model.append(None, None)
model.set(iter, 0, "Clipping Records", 1, -1, 2, "")
for i in range(len(cliprec)):
niter = model.append(iter, None)
model.set(niter, 0, emr_ids[cliprec[i]], 1, cliprec[i], 2, 8)
iter = model.append(None, None)
model.set(iter, 0, "Comment & Control Records", 1, -1, 2, "")
for i in range(len(ctrlrec)):
niter = model.append(iter, None)
model.set(niter, 0, emr_ids[ctrlrec[i]], 1, ctrlrec[i], 2, 8)
iter = model.append(None, None)
model.set(iter, 0, "Drawing Records", 1, -1, 2, "")
for i in range(len(drawrec)):
niter = model.append(iter, None)
model.set(niter, 0, emr_ids[drawrec[i][0]], 1, drawrec[i][0], 2,
drawrec[i][1])
iter = model.append(None, None)
model.set(iter, 0, "Escape Records", 1, -1, 2, "")
for i in range(len(escrec)):
niter = model.append(iter, None)
model.set(niter, 0, emr_ids[escrec[i]], 1, escrec[i], 2, 8)
iter = model.append(None, None)
model.set(iter, 0, "Object Creation Records", 1, -1, 2, "")
for i in range(len(objcrec)):
niter = model.append(iter, None)
model.set(niter, 0, emr_ids[objcrec[i][0]], 1, objcrec[i][0], 2,
objcrec[i][1])
iter = model.append(None, None)
model.set(iter, 0, "Object Modification Records", 1, -1, 2, "")
for i in range(len(objmrec)):
niter = model.append(iter, None)
model.set(niter, 0, emr_ids[objmrec[i]], 1, objmrec[i], 2, 8)
iter = model.append(None, None)
model.set(iter, 0, "OpenGL Records", 1, -1, 2, "")
niter = model.append(iter, None)
model.set(niter, 0, emr_ids[0x66], 1, 0x66, 2, 8)
niter = model.append(iter, None)
model.set(niter, 0, emr_ids[0x67], 1, 0x67, 2, 8)
iter = model.append(None, None)
model.set(iter, 0, "Path Bracket Records", 1, -1, 2, "")
for i in range(len(pathrec)):
niter = model.append(iter, None)
model.set(niter, 0, emr_ids[pathrec[i]], 1, pathrec[i], 2, 8)
iter = model.append(None, None)
model.set(iter, 0, "State Records", 1, -1, 2, "")
for i in range(len(staterec)):
niter = model.append(iter, None)
model.set(niter, 0, emr_ids[staterec[i]], 1, staterec[i], 2, 8)
iter = model.append(None, None)
model.set(iter, 0, "Transform Records", 1, -1, 2, "")
niter = model.append(iter, None)
model.set(niter, 0, emr_ids[0x23], 1, 0x23, 2, 8)
niter = model.append(iter, None)
model.set(niter, 0, emr_ids[0x24], 1, 0x24, 2, 8)
return model, view
def __init__(self, session):
'''class constructor'''
self._model = None
pbr = extension.get_default('avatar renderer')
self.pbr = pbr()
gui.ContactList.__init__(self, session)
gtk.TreeView.__init__(self)
self.set_enable_search(False) # Enable our searching widget
# with CTRL+F in MainWindow.py
self.online_group_iter = None # added
self.no_group_iter = None
self.offline_group_iter = None
self.hide_on_filtering = False
self.enable_model_drag_source(gtk.gdk.BUTTON1_MASK,
[('emesene-contact', 0, 0),
('text/html', 0, 1),
('text/plain', 0, 2),
('emesene-invite', 0, 3)],
gtk.gdk.ACTION_COPY)
self.enable_model_drag_dest([('emesene-contact', 0, 0)],
gtk.gdk.ACTION_DEFAULT)
self.contact_handler = gui.base.ContactHandler(session, self)
self.group_handler = gui.base.GroupHandler(session, self)
if self.session.config.d_weights is None:
self.session.config.d_weights = {}
# [0] the image (None for groups),
# [1] the object (group or contact),
# [2] the string to display
# [3] a boolean indicating if the pixbuf should
# be shown (False for groups, True for contacts)
# [4] the status image
# [5] an int that is used to allow ordering specified by the user
# [6] a boolean indicating special groups always False for contacts,
# True for special groups like "No group"
# [7] a boolean indicating if the contact is offline
self._model = gtk.TreeStore(gtk.Image, object, str, bool,
gtk.gdk.Pixbuf, int, bool, bool)
self.model = self._model.filter_new(root=None)
self.model.set_visible_func(self._visible_func)
self._model.set_sort_func(1, self._sort_method)
self._model.set_sort_column_id(1, gtk.SORT_ASCENDING)
self.set_model(self.model)
self.tooltips = Tooltips.Tooltips()
self.connect('motion-notify-event', self.tooltips.on_motion)
self.connect('leave-notify-event', self.tooltips.on_leave)
self.crt = extension.get_and_instantiate('nick renderer')
self.column = gtk.TreeViewColumn()
self.column.set_expand(True)
self.column.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE)
self.exp_column = gtk.TreeViewColumn()
self.exp_column.set_max_width(16)
self.append_column(self.exp_column)
self.append_column(self.column)
self.set_expander_column(self.exp_column)
self.prepare_contactlist_column()
self.set_search_column(2)
self.set_headers_visible(False)
self.connect('row-activated', self._on_row_activated)
self.connect('button-release-event', self._on_button_press_event)
self.connect('row-expanded', self._on_expand)
self.connect('row-collapsed', self._on_collapse)
self.connect('drag-data-get', self._on_drag_data_get)
self.connect('drag-drop', self._on_drag_drop)
extension.subscribe(self.on_nick_renderer_changed, 'nick renderer')
def __init__(self, w3af, style, config_panel):
self.mainwin = w3af.mainwin
self.w3af = w3af
self.config_panel = config_panel
# create the TreeStore, with the following columns:
# 1. the plugin name, to show it
# 2. checkbox status, active or not
# 3. checkbox status, inconsistant or not
# 4. the plugin name, just to store and bold it or not
# 5. a image to show if the plugin is configurable
self.treestore = gtk.TreeStore(str, gobject.TYPE_BOOLEAN,
gobject.TYPE_BOOLEAN, str,
gtk.gdk.Pixbuf)
# decide which type in function of style
if style == "standard":
plugins_toshow = sorted(x for x in w3af.plugins.get_plugin_types()
if x != "output")
col_title = _("Plugin")
elif style == "output":
plugins_toshow = ("output", )
col_title = _("Plugin")
else:
raise ValueError("Invalid PluginTree style: %r" % style)
# just build the tree with the plugin names
for plugintype in plugins_toshow:
# let's see if some of the children are activated or not
pluginlist = w3af.plugins.get_plugin_list(plugintype)
activated = set(w3af.plugins.get_enabled_plugins(plugintype))
if not activated:
activ = 0
incons = 0
elif len(activated) == len(pluginlist):
activ = 1
incons = 0
else:
activ = 0
incons = 1
father = self.treestore.append(
None, [plugintype, activ, incons, plugintype, None])
dlg = gtk.Dialog()
editpixbuf = dlg.render_icon(gtk.STOCK_EDIT, gtk.ICON_SIZE_MENU)
for plugin in sorted(w3af.plugins.get_plugin_list(plugintype)):
activ = int(plugin in activated)
if self._getEditablePlugin(plugin, plugintype):
thispixbuf = editpixbuf
else:
thispixbuf = None
self.treestore.append(father,
[plugin, activ, 0, plugin, thispixbuf])
# we will not ask for the plugin instances until needed, we'll
# keep them here:
self.plugin_instances = {}
# we'll supervise the status of all changed configurations (if it
# does not exist here, never was changed)
self.config_status = {}
# create the TreeView using treestore
super(PluginTree, self).__init__(self.treestore)
self.connect('cursor-changed', self.configure_plugin)
# button events
self.connect('button-release-event', self.popup_menu)
self.connect('button-press-event', self._doubleClick)
# create a TreeViewColumn for the checkbox
tvcolumn = gtk.TreeViewColumn(_('Active'))
cell = gtk.CellRendererToggle()
cell.set_property('activatable', True)
cell.connect('toggled', self.activate_plugin)
tvcolumn.pack_start(cell, False)
tvcolumn.add_attribute(cell, 'active', 1)
tvcolumn.add_attribute(cell, 'inconsistent', 2)
self.append_column(tvcolumn)
# create a TreeViewColumn for the text and icon
tvcolumn = gtk.TreeViewColumn(col_title)
cell = gtk.CellRendererPixbuf()
tvcolumn.pack_start(cell, expand=False)
tvcolumn.add_attribute(cell, "pixbuf", 4)
cell = gtk.CellRendererText()
tvcolumn.pack_start(cell, True)
tvcolumn.add_attribute(cell, 'markup', 0)
self.append_column(tvcolumn)
self.show()
def __init__(self):
"""Setup the preferences dialog interface, loading images,
adding filters to file choosers and connecting some signals.
"""
super(PrefsDialog, self).__init__(gladefile('prefs.glade'),
root='config-window')
self.add_callbacks(PrefsCallbacks())
self.client = gconf.client_get_default()
# setting evtbox title bg
eventbox = self.get_widget('eventbox-title')
eventbox.modify_bg(gtk.STATE_NORMAL,
eventbox.get_colormap().alloc_color("#ffffff"))
# images
ipath = pixmapfile('guake-notification.png')
self.get_widget('image_logo').set_from_file(ipath)
ipath = pixmapfile('quick-open.png')
self.get_widget('image_quick_open').set_from_file(ipath)
# the first position in tree will store the keybinding path in gconf,
# and the user doesn't worry with this, let's hide that =D
model = gtk.TreeStore(str, str, object, bool)
treeview = self.get_widget('treeview-keys')
treeview.set_model(model)
treeview.set_rules_hint(True)
treeview.connect('button-press-event', self.start_editing)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn('keypath', renderer, text=0)
column.set_visible(False)
treeview.append_column(column)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn(_('Action'), renderer, text=1)
column.set_property('expand', True)
treeview.append_column(column)
renderer = gtk.CellRendererAccel()
renderer.set_property('editable', True)
renderer.connect('accel-edited', self.on_key_edited, model)
renderer.connect('accel-cleared', self.on_key_cleared, model)
column = gtk.TreeViewColumn(_('Shortcut'), renderer)
column.set_cell_data_func(renderer, self.cell_data_func)
column.set_property('expand', False)
treeview.append_column(column)
self.demo_terminal = GuakeTerminal()
demo_terminal_box = self.get_widget('demo_terminal_box')
demo_terminal_box.add(self.demo_terminal)
default_params = {}
pid = self.demo_terminal.fork_command(**default_params)
self.demo_terminal.pid = pid
self.populate_shell_combo()
self.populate_keys_tree()
self.populate_display_n()
self.load_configs()
self.get_widget('config-window').hide()
# Preview when selecting a bgimage
self.selection_preview = gtk.Image()
self.file_filter = gtk.FileFilter()
self.file_filter.add_pattern("*.jpg")
self.file_filter.add_pattern("*.png")
self.file_filter.add_pattern("*.svg")
self.file_filter.add_pattern("*.jpeg")
self.bgfilechooser = self.get_widget('background_image')
self.bgfilechooser.set_preview_widget(self.selection_preview)
self.bgfilechooser.set_filter(self.file_filter)
self.bgfilechooser.connect('update-preview', self.update_preview,
self.selection_preview)
def __init__(self, mainWin, VERSION):
self.configs = mainWin.configs
self.VERSION = VERSION
self.subscribedGroups = mainWin.subscribed_groups
self.win = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.win.connect("delete_event", self.delete_event)
#self.win.connect("destroy",self.destroy)
self.win.set_title(_("Outbox Manager"))
self.win.set_icon(gtk.gdk.pixbuf_new_from_file("pixmaps/outbox.xpm"))
vbox = gtk.VBox()
#MenuBar
self.create_ui()
menubar = self.ui.get_widget("/OutboxMenuBar")
vbox.pack_start(menubar, False, True)
menubar.show()
#ToolBar
toolbar = self.ui.get_widget("/OutboxToolBar")
vbox.pack_start(toolbar, False, True)
toolbar.show()
#toolbar.set_icon_size(gtk.ICON_SIZE_LARGE_TOOLBAR)
toolbar.set_orientation(gtk.ORIENTATION_HORIZONTAL)
toolbar.set_style(gtk.TOOLBAR_ICONS)
toolbar.set_style(gtk.SHADOW_NONE)
self.win.add(vbox)
#HBox
hpaned = gtk.HPaned()
vbox.pack_start(hpaned, True, True)
#Folder Tree
self.folderTree = gtk.TreeView()
model = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_STRING,
gtk.gdk.Pixbuf)
self.folderTree.set_model(model)
text_renderer_bold = gtk.CellRendererText()
text_renderer_bold.set_property("weight", 1000)
text_renderer_number = gtk.CellRendererText()
text_renderer_number.set_property("xalign", .5)
pix_renderer = gtk.CellRendererPixbuf()
self.folderTreeColumnFolder = gtk.TreeViewColumn(_("Folder"))
self.folderTreeColumnFolder.pack_start(pix_renderer)
self.folderTreeColumnFolder.pack_start(text_renderer_bold)
self.folderTreeColumnFolder.set_attributes(pix_renderer, pixbuf=2)
self.folderTreeColumnFolder.set_attributes(text_renderer_bold, text=0)
self.folderTreeColumnNumber = gtk.TreeViewColumn(_("Number"),
text_renderer_number,
text=1)
self.folderTree.append_column(self.folderTreeColumnFolder)
self.folderTree.append_column(self.folderTreeColumnNumber)
#self.folderTree.set_expander_column(self.folderTreeColumn)
hpaned.add(self.folderTree)
#Preview Tree
scrolledwin = gtk.ScrolledWindow()
scrolledwin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolledwin.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.previewTree = gtk.TreeView()
scrolledwin.add(self.previewTree)
# 0: Subject, 1: Newsgroups/To, 2: Date, 3: Article, 4: IsMail, 5: PathToArticle, 6: Seconds
model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING, gobject.TYPE_PYOBJECT,
gobject.TYPE_BOOLEAN, gobject.TYPE_STRING,
gobject.TYPE_INT)
self.previewTree.set_model(model)
text_renderer = gtk.CellRendererText()
self.previewTreeColumnSubject = gtk.TreeViewColumn(_("Subject"),
text_renderer,
text=0)
self.previewTreeColumnSubject.set_resizable(True)
self.previewTreeColumnSubject.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
self.previewTreeColumnSubject.set_fixed_width(300)
self.previewTreeColumnSubject.set_sort_column_id(0)
self.previewTreeColumnTo = gtk.TreeViewColumn(_("Newsgroups/To"),
text_renderer,
text=1)
self.previewTreeColumnTo.set_resizable(True)
self.previewTreeColumnTo.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
self.previewTreeColumnTo.set_fixed_width(150)
self.previewTreeColumnTo.set_sort_column_id(1)
self.previewTreeColumnDate = gtk.TreeViewColumn(_("Date"),
text_renderer,
text=2)
self.previewTreeColumnDate.set_sort_column_id(6)
self.previewTree.append_column(self.previewTreeColumnSubject)
self.previewTree.append_column(self.previewTreeColumnTo)
self.previewTree.append_column(self.previewTreeColumnDate)
hpaned.add(scrolledwin)
model.set_sort_column_id(6, gtk.SORT_ASCENDING)
self.statusbar = gtk.Statusbar()
vbox.pack_start(self.statusbar, False, True)
#self.win.maximize()
self.wdir = get_wdir()
#self.folderTree.connect("row_activated",self.openFolder)
self.folderTree.get_selection().connect("changed", self.openFolder)
self.previewTree.connect("row_activated", self.openArticle)
self.set_sizes()
self.outboxwin_width = None
self.outboxwin_height = None
self.populateFolderTree()
def __init__(self, parent, playlist_manager,
smart_manager, collection, name):
"""
Intializes the playlists panel
@param playlist_manager: The playlist manager
"""
panel.Panel.__init__(self, parent, name)
BasePlaylistPanelMixin.__init__(self)
self.playlist_manager = playlist_manager
self.smart_manager = smart_manager
self.collection = collection
self.box = self.builder.get_object('playlists_box')
self._refresh_id = None
self.playlist_name_info = 500
self.track_target = ("text/uri-list", 0, 0)
self.playlist_target = ("playlist_name", gtk.TARGET_SAME_WIDGET,
self.playlist_name_info)
self.deny_targets = [('',0,0)]
self.tree = PlaylistDragTreeView(self)
self.tree.connect('row-activated', self.open_item)
self.tree.set_headers_visible(False)
self.tree.connect('drag-motion', self.drag_motion)
self.tree.drag_source_set(
gtk.gdk.BUTTON1_MASK, [self.track_target, self.playlist_target],
gtk.gdk.ACTION_COPY|gtk.gdk.ACTION_MOVE)
self.scroll = gtk.ScrolledWindow()
self.scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.scroll.add(self.tree)
self.scroll.set_shadow_type(gtk.SHADOW_IN)
self.box.pack_start(self.scroll, True, True)
self.box.show_all()
pb = gtk.CellRendererPixbuf()
cell = gtk.CellRendererText()
if settings.get_option('gui/ellipsize_text_in_panels', False):
import pango
cell.set_property( 'ellipsize-set', True)
cell.set_property( 'ellipsize', pango.ELLIPSIZE_END)
col = gtk.TreeViewColumn('Text')
col.pack_start(pb, False)
col.pack_start(cell, True)
col.set_attributes(pb, pixbuf=0)
col.set_attributes(cell, text=1)
self.tree.append_column(col)
self.model = gtk.TreeStore(gtk.gdk.Pixbuf, str, object)
self.tree.set_model(self.model)
# icons
self.folder = self.tree.render_icon(
gtk.STOCK_DIRECTORY, gtk.ICON_SIZE_SMALL_TOOLBAR)
self.playlist_image = icons.MANAGER.pixbuf_from_icon_name(
'music-library', gtk.ICON_SIZE_SMALL_TOOLBAR)
# menus
self.playlist_menu = menus.PlaylistsPanelPlaylistMenu(self)
self.smart_menu = menus.PlaylistsPanelPlaylistMenu(self)
self.default_menu = menus.PlaylistPanelMenu(self)
self.track_menu = menus.TrackPanelMenu(self)
self._connect_events()
self._load_playlists()
def __init__(self, hosts=None, owner=None, poll_interval=None):
gobject.threads_init()
set_exception_hook_dialog("cylc gscan")
setup_icons()
if not hosts:
hosts = GLOBAL_CFG.get(["suite host scanning", "hosts"])
self.hosts = hosts
if owner is None:
owner = USER
self.owner = owner
self.window = gtk.Window()
self.window.set_title("cylc gscan")
self.window.set_icon(get_icon())
self.vbox = gtk.VBox()
self.vbox.show()
self.theme_name = gcfg.get(['use theme'])
self.theme = gcfg.get(['themes', self.theme_name])
self.dots = DotMaker(self.theme)
suite_treemodel = gtk.TreeStore(str, str, bool, str, int, str, str)
self._prev_tooltip_location_id = None
self.suite_treeview = gtk.TreeView(suite_treemodel)
# Construct the host column.
host_name_column = gtk.TreeViewColumn("Host")
cell_text_host = gtk.CellRendererText()
host_name_column.pack_start(cell_text_host, expand=False)
host_name_column.set_cell_data_func(cell_text_host,
self._set_cell_text_host)
host_name_column.set_sort_column_id(0)
host_name_column.set_visible("host" in gsfg.get(["columns"]))
host_name_column.set_resizable(True)
# Construct the suite name column.
suite_name_column = gtk.TreeViewColumn("Suite")
cell_text_name = gtk.CellRendererText()
suite_name_column.pack_start(cell_text_name, expand=False)
suite_name_column.set_cell_data_func(cell_text_name,
self._set_cell_text_name)
suite_name_column.set_sort_column_id(1)
suite_name_column.set_visible("suite" in gsfg.get(["columns"]))
suite_name_column.set_resizable(True)
# Construct the suite title column.
suite_title_column = gtk.TreeViewColumn("Title")
cell_text_title = gtk.CellRendererText()
suite_title_column.pack_start(cell_text_title, expand=False)
suite_title_column.set_cell_data_func(cell_text_title,
self._set_cell_text_title)
suite_title_column.set_sort_column_id(3)
suite_title_column.set_visible("title" in gsfg.get(["columns"]))
suite_title_column.set_resizable(True)
# Construct the update time column.
time_column = gtk.TreeViewColumn("Updated")
cell_text_time = gtk.CellRendererText()
time_column.pack_start(cell_text_time, expand=False)
time_column.set_cell_data_func(cell_text_time,
self._set_cell_text_time)
time_column.set_sort_column_id(4)
time_column.set_visible("updated" in gsfg.get(["columns"]))
time_column.set_resizable(True)
self.suite_treeview.append_column(host_name_column)
self.suite_treeview.append_column(suite_name_column)
self.suite_treeview.append_column(suite_title_column)
self.suite_treeview.append_column(time_column)
# Construct the status column.
status_column = gtk.TreeViewColumn("Status")
status_column.set_sort_column_id(5)
status_column.set_visible("status" in gsfg.get(["columns"]))
status_column.set_resizable(True)
status_column_info = 6
cycle_column_info = 5
cell_text_cycle = gtk.CellRendererText()
status_column.pack_start(cell_text_cycle, expand=False)
status_column.set_cell_data_func(cell_text_cycle,
self._set_cell_text_cycle,
cycle_column_info)
self.suite_treeview.append_column(status_column)
for i in range(len(TASK_STATUSES_ORDERED)):
cell_pixbuf_state = gtk.CellRendererPixbuf()
status_column.pack_start(cell_pixbuf_state, expand=False)
status_column.set_cell_data_func(cell_pixbuf_state,
self._set_cell_pixbuf_state,
(status_column_info, i))
self.suite_treeview.show()
if hasattr(self.suite_treeview, "set_has_tooltip"):
self.suite_treeview.set_has_tooltip(True)
try:
self.suite_treeview.connect('query-tooltip',
self._on_query_tooltip)
except TypeError:
# Lower PyGTK version.
pass
self.suite_treeview.connect("button-press-event",
self._on_button_press_event)
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled_window.add(self.suite_treeview)
scrolled_window.show()
self.vbox.pack_start(scrolled_window, expand=True, fill=True)
self.updater = ScanAppUpdater(self.hosts,
suite_treemodel,
self.suite_treeview,
owner=self.owner,
poll_interval=poll_interval)
self.updater.start()
self.window.add(self.vbox)
self.window.connect("destroy", self._on_destroy_event)
self.window.set_default_size(300, 150)
self.suite_treeview.grab_focus()
self.window.show()
def ma_set_choices(self, choices):
import gtk
def cell_data_func(unused_column, cell, model, iterator):
val = model.get_value(iterator, 1)
if model.iter_children(iterator):
# Windows XP...
text = '%s <small><i>%s (%s)</i></small>' % \
(val['user'], val['os'], val['part'])
else:
# Gaim, Yahoo, etc
text = model.get_value(iterator, 1)
try:
cell.set_property("markup", unicode(text))
except:
cell.set_property("text", '%s %s (%s)' % \
(val['user'], val['os'], val['part']))
# Showing the interface for the second time.
if self.matreeview.get_model():
for col in self.matreeview.get_columns():
self.matreeview.remove_column(col)
# For the previous selected item.
self.ma_previous_selection = None
# TODO evand 2007-01-11 I'm on the fence as to whether or not skipping
# the page would be better than showing the user this error.
if not choices:
# TODO cjwatson 2009-04-01: i18n
msg = 'There were no users or operating systems suitable for ' \
'importing from.'
liststore = gtk.ListStore(str)
liststore.append([msg])
self.matreeview.set_model(liststore)
column = gtk.TreeViewColumn('item', gtk.CellRendererText(), text=0)
self.matreeview.append_column(column)
else:
treestore = gtk.TreeStore(bool, object)
# We save the choices list so we can preserve state, should the user
# decide to move back through the interface. We cannot just put the
# old list back as the options could conceivably change. For
# example, the user moves back to the partitioning page, removes a
# partition, and moves forward to the migration-assistant page.
# TODO evand 2007-12-04: simplify.
for choice in choices:
kept = False
for old_choice in self.ma_choices:
if (old_choice['user'] == choice['user']) and \
(old_choice['part'] == choice['part']):
piter = treestore.append(None, \
[old_choice['selected'], choice])
choice['selected'] = old_choice['selected']
new_items = []
for item in choice['items']:
if item in old_choice['items']:
treestore.append(piter, [True, item])
new_items.append(item)
else:
treestore.append(piter, [False, item])
choice['items'] = new_items
kept = True
break
if not kept:
piter = treestore.append(None, [False, choice])
for item in choice['items']:
treestore.append(piter, [False, item])
choice['items'] = []
self.matreeview.set_model(treestore)
renderer = gtk.CellRendererToggle()
renderer.connect('toggled', self.ma_cb_toggle, treestore)
column = gtk.TreeViewColumn('boolean', renderer, active=0)
column.set_clickable(True)
column.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE)
self.matreeview.append_column(column)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn('item', renderer)
column.set_cell_data_func(renderer, cell_data_func)
self.matreeview.append_column(column)
self.matreeview.set_search_column(1)
self.matreeview.show_all()
# Save the list so we can preserve state.
self.ma_choices = choices
def __init_model(self):
"""Initialise and return the model for the data."""
self.__model = gtk.TreeStore(*self.FIELDS)
return self.__model
def getScreen(self, anaconda):
# We skip the filter UI in basic storage mode
if anaconda.simpleFilter:
anaconda.storage.config.exclusiveDisks = []
return None
(self.xml, self.vbox) = gui.getGladeWidget("filter.glade", "vbox")
self.buttonBox = self.xml.get_widget("buttonBox")
self.notebook = self.xml.get_widget("notebook")
self.addAdvanced = self.xml.get_widget("addAdvancedButton")
self.notebook.connect("switch-page", self._page_switched)
self.addAdvanced.connect("clicked", self._add_advanced_clicked)
self.pages = []
self.anaconda = anaconda
# One common store that all the views on all the notebook tabs share.
# Yes, this means a whole lot of columns that are going to be empty or
# unused much of the time. Oh well.
# Object,
# visible, active (checked), immutable,
# device, model, capacity, vendor, interconnect, serial number, wwid
# paths, port, target, lun
self.store = gtk.TreeStore(gobject.TYPE_PYOBJECT,
gobject.TYPE_BOOLEAN, gobject.TYPE_BOOLEAN,
gobject.TYPE_BOOLEAN,
gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING)
self.store.set_sort_column_id(MODEL_COL, gtk.SORT_ASCENDING)
# if we've already populated the device tree at least once we should
# do our best to make sure any active devices get deactivated
anaconda.storage.devicetree.teardownAll()
# So that drives onlined by these show up in the filter UI
iscsi.iscsi().startup(anaconda.intf)
fcoe.fcoe().startup(anaconda.intf)
zfcp.ZFCP().startup(anaconda.intf)
dasd.DASD().startup(anaconda.intf,
anaconda.storage.config.exclusiveDisks,
anaconda.storage.config.zeroMbr)
disks = self._getFilterDisks()
mcw = MultipathConfigWriter()
cfg = mcw.write()
open("/etc/multipath.conf", "w+").write(cfg)
del cfg
del mcw
topology = MultipathTopology(disks)
# The device list could be really long, so we really only want to
# iterate over it the bare minimum of times. Dividing this list up
# now means fewer elements to iterate over later.
singlepaths = filter(lambda info: self._device_size_is_nonzero(info),
topology.singlepaths_iter())
(raids, nonraids) = self.split_list(lambda d: isRAID(d) and not isCCISS(d),
singlepaths)
self.pages = [self._makeBasic(), self._makeRAID(),
self._makeMPath(), self._makeOther(),
self._makeSearch()]
self.populate(nonraids, topology.multipaths_iter(), raids)
# If the "Add Advanced" button is ever clicked, we need to have a list
# of what devices previously existed so we know what's new. Then we
# can just add the new devices to the UI. This is going to be slow,
# but the user has to click a button to get to the slow part.
self._cachedDevices = NameCache(singlepaths)
self._cachedRaidDevices = NameCache(raids)
# Multipath is a little more complicated. Since mpaths is a list of
# lists, we can't directly store that into the cache. Instead we want
# to flatten it into a single list of all components of all multipaths
# and store that.
mpath_chain = itertools.chain(*topology.multipaths_iter())
self._cachedMPaths = NameCache(mpath_chain)
# Switch to the first notebook page that displays any devices.
i = 0
for pg in self.pages:
if pg.getNVisible():
self.notebook.set_current_page(i)
break
i += 1
return self.vbox
def __init__(
self, hosts=None, patterns_name=None, patterns_owner=None,
comms_timeout=None, poll_interval=None):
gobject.threads_init()
set_exception_hook_dialog("cylc gscan")
setup_icons()
if not hosts:
hosts = GLOBAL_CFG.get(["suite host scanning", "hosts"])
self.hosts = hosts
self.window = gtk.Window()
title = "cylc gscan"
for opt, items, skip in [
("-n", patterns_name, None), ("-o", patterns_owner, USER)]:
if items:
for pattern in items:
if pattern != skip:
title += " %s %s" % (opt, pattern)
self.window.set_title(title)
self.window.set_icon(get_icon())
self.vbox = gtk.VBox()
self.vbox.show()
self.warnings = {}
self.theme_name = gcfg.get(['use theme'])
self.theme = gcfg.get(['themes', self.theme_name])
self.dots = DotMaker(self.theme)
suite_treemodel = gtk.TreeStore(
str, # group
str, # host
str, # owner
str, # suite
bool, # is_stopped
str, # title
int, # update_time
str, # states
str, # states_text
str) # warning_text
self._prev_tooltip_location_id = None
self.suite_treeview = gtk.TreeView(suite_treemodel)
# Visibility of columns
vis_cols = gsfg.get(["columns"])
# Doesn't make any sense without suite name column
if gsfg.COL_SUITE not in vis_cols:
vis_cols.append(gsfg.COL_SUITE.lower())
# In multiple host environment, add host column by default
if hosts:
vis_cols.append(gsfg.COL_HOST.lower())
# In multiple owner environment, add owner column by default
if patterns_owner != [USER]:
vis_cols.append(gsfg.COL_OWNER.lower())
# Construct the group, host, owner, suite, title, update time column.
for col_title, col_id, col_cell_text_setter in [
(gsfg.COL_GROUP, self.GROUP_COLUMN, self._set_cell_text_group),
(gsfg.COL_HOST, self.HOST_COLUMN, self._set_cell_text_host),
(gsfg.COL_OWNER, self.OWNER_COLUMN, self._set_cell_text_owner),
(gsfg.COL_SUITE, self.SUITE_COLUMN, self._set_cell_text_name),
(gsfg.COL_TITLE, self.TITLE_COLUMN, self._set_cell_text_title),
(gsfg.COL_UPDATED, self.UPDATE_TIME_COLUMN,
self._set_cell_text_time),
]:
column = gtk.TreeViewColumn(col_title)
cell_text = gtk.CellRendererText()
column.pack_start(cell_text, expand=False)
column.set_cell_data_func(cell_text, col_cell_text_setter)
column.set_sort_column_id(col_id)
column.set_visible(col_title.lower() in vis_cols)
column.set_resizable(True)
self.suite_treeview.append_column(column)
# Construct the status column.
status_column = gtk.TreeViewColumn(gsfg.COL_STATUS)
status_column.set_sort_column_id(self.STATUS_COLUMN)
status_column.set_visible(gsfg.COL_STATUS.lower() in vis_cols)
status_column.set_resizable(True)
cell_text_cycle = gtk.CellRendererText()
status_column.pack_start(cell_text_cycle, expand=False)
status_column.set_cell_data_func(
cell_text_cycle, self._set_cell_text_cycle, self.CYCLE_COLUMN)
self.suite_treeview.append_column(status_column)
# Warning icon.
warn_icon = gtk.CellRendererPixbuf()
image = gtk.Image()
pixbuf = image.render_icon(
gtk.STOCK_DIALOG_WARNING, gtk.ICON_SIZE_LARGE_TOOLBAR)
self.warn_icon_colour = pixbuf.scale_simple( # colour warn icon pixbuf
self.ICON_SIZE, self.ICON_SIZE, gtk.gdk.INTERP_HYPER)
self.warn_icon_grey = pixbuf.scale_simple(
self.ICON_SIZE, self.ICON_SIZE, gtk.gdk.INTERP_HYPER)
self.warn_icon_colour.saturate_and_pixelate(
self.warn_icon_grey, 0, False) # b&w warn icon pixbuf
status_column.pack_start(warn_icon, expand=False)
status_column.set_cell_data_func(warn_icon, self._set_error_icon_state)
self.warn_icon_blank = gtk.gdk.Pixbuf( # Transparent pixbuff.
gtk.gdk.COLORSPACE_RGB, True, 8, self.ICON_SIZE, self.ICON_SIZE
).fill(0x00000000)
# Task status icons.
for i in range(len(TASK_STATUSES_ORDERED)):
cell_pixbuf_state = gtk.CellRendererPixbuf()
status_column.pack_start(cell_pixbuf_state, expand=False)
status_column.set_cell_data_func(
cell_pixbuf_state, self._set_cell_pixbuf_state, i)
self.suite_treeview.show()
if hasattr(self.suite_treeview, "set_has_tooltip"):
self.suite_treeview.set_has_tooltip(True)
try:
self.suite_treeview.connect('query-tooltip',
self._on_query_tooltip)
except TypeError:
# Lower PyGTK version.
pass
self.suite_treeview.connect("button-press-event",
self._on_button_press_event)
scrolled_window = gtk.ScrolledWindow()
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
scrolled_window.add(self.suite_treeview)
scrolled_window.show()
self.vbox.pack_start(scrolled_window, expand=True, fill=True)
patterns = {"name": None, "owner": None}
for label, items in [
("owner", patterns_owner), ("name", patterns_name)]:
if items:
patterns[label] = r"\A(?:" + r")|(?:".join(items) + r")\Z"
try:
patterns[label] = re.compile(patterns[label])
except re.error:
raise ValueError("Invalid %s pattern: %s" % (label, items))
self.updater = ScanAppUpdater(
self.window, self.hosts, suite_treemodel, self.suite_treeview,
comms_timeout=comms_timeout, poll_interval=poll_interval,
group_column_id=self.GROUP_COLUMN,
name_pattern=patterns["name"], owner_pattern=patterns["owner"])
self.updater.start()
self.window.add(self.vbox)
self.window.connect("destroy", self._on_destroy_event)
self.window.set_default_size(300, 150)
self.suite_treeview.grab_focus()
self.window.show()
self.warning_icon_shown = []
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.id.storage.disks)
# Skip this screen as well if there's only one disk to use.
if len(disks) == 1:
anaconda.id.storage.clearPartDisks = [disks[0].name]
anaconda.id.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.id.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.id.storage.clearPartDisks
rightActive = rightVisible and \
d.name in self.anaconda.id.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.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.id.storage.clearPartType == CLEARPART_TYPE_LINUX:
self.installTargetTip.set_markup(_("<b>Tip:</b> All Linux filesystems on install target devices will be reformatted and wiped of any data. Make sure you have backups."))
elif self.anaconda.id.storage.clearPartType == CLEARPART_TYPE_ALL:
self.installTargetTip.set_markup(_("<b>Tip:</b> 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 install target devices will not be wiped unless you choose to do so during customization."))
return self.vbox
def __init__(self, userbrowses, user, conn, data_dir):
self.data_dir = data_dir
# Build the window
builder = gtk.Builder()
builder.set_translation_domain('nicotine')
builder.add_from_file(
os.path.join(os.path.dirname(os.path.realpath(__file__)), "ui",
"userbrowse.ui"))
self.UserBrowseTab = builder.get_object("UserBrowseTab")
for i in builder.get_objects():
try:
self.__dict__[gtk.Buildable.get_name(i)] = i
except TypeError:
pass
self.UserBrowseTab.remove(self.Main)
self.UserBrowseTab.destroy()
builder.connect_signals(self)
self.userbrowses = userbrowses
self.frame = userbrowses.frame
self.user = user
self.conn = conn
# selected_folder is the current selected folder
self.selected_folder = None
self.search_list = []
self.query = None
self.search_position = 0
self.selected_files = []
self.shares = []
# Iters for current DirStore
self.directories = {}
# Iters for current FileStore
self.files = {}
self.totalsize = 0
self.encoding, m = EncodingsMenu(self.frame.np, "userencoding", user)
# Encoding Combobox
self.Elist = {}
self.EncodingStore = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_STRING)
self.Encoding.set_model(self.EncodingStore)
cell = gtk.CellRendererText()
self.Encoding.pack_start(cell, True)
self.Encoding.add_attribute(cell, 'text', 0)
cell2 = gtk.CellRendererText()
self.Encoding.pack_start(cell2, False)
self.Encoding.add_attribute(cell2, 'text', 1)
for item in m:
self.Elist[item[1]] = self.EncodingStore.append([item[1], item[0]])
if self.encoding == item[1]:
self.Encoding.set_active_iter(self.Elist[self.encoding])
self.DirStore = gtk.TreeStore(str, str)
self.FolderTreeView.set_headers_visible(True)
self.FolderTreeView.set_enable_tree_lines(True)
cols = InitialiseColumns(
self.FolderTreeView,
[_("Directories"), -1, "text", self.CellDataFunc] # 0
)
cols[0].set_sort_column_id(0)
self.popup_menu_users = PopupMenu(self.frame)
self.popup_menu_users2 = PopupMenu(self.frame)
for menu in [self.popup_menu_users, self.popup_menu_users2]:
menu.setup(("#" + _("Send _message"), menu.OnSendMessage),
("#" + _("Show IP a_ddress"), menu.OnShowIPaddress),
("#" + _("Get user i_nfo"), menu.OnGetUserInfo),
("#" + _("Gi_ve privileges"), menu.OnGivePrivileges),
("", None),
("$" + _("_Add user to list"), menu.OnAddToList),
("$" + _("_Ban this user"), menu.OnBanUser),
("$" + _("_Ignore this user"), menu.OnIgnoreUser))
self.popup_menu_downloads_folders = PopupMenu(self.frame)
self.popup_menu_downloads_folders.setup(
("#" + _("_Download directory"), self.OnDownloadDirectory),
("#" + _("Download directory _to..."), self.OnDownloadDirectoryTo),
("#" + _("Download _recursive"),
self.OnDownloadDirectoryRecursive),
("#" + _("Download r_ecursive to..."),
self.OnDownloadDirectoryRecursiveTo))
self.popup_menu_downloads_files = PopupMenu(self.frame)
self.popup_menu_downloads_files.setup(
("#" + _("_Download file(s)"), self.OnDownloadFiles),
("#" + _("Download _to..."), self.OnDownloadFilesTo), ("", None),
("#" + _("_Download directory"), self.OnDownloadDirectory),
("#" + _("Download directory _to..."), self.OnDownloadDirectoryTo),
("#" + _("Download _recursive"),
self.OnDownloadDirectoryRecursive),
("#" + _("Download r_ecursive to..."),
self.OnDownloadDirectoryRecursiveTo))
self.popup_menu_uploads_folders = PopupMenu(self.frame)
self.popup_menu_uploads_folders.setup(
("#" + _("Upload Directory to..."), self.OnUploadDirectoryTo),
("#" + _("Upload Directory recursive to..."),
self.OnUploadDirectoryRecursiveTo))
self.popup_menu_uploads_files = PopupMenu(self.frame)
self.popup_menu_uploads_files.setup(
("#" + _("Upload Directory to..."), self.OnUploadDirectoryTo),
("#" + _("Upload Directory recursive to..."),
self.OnUploadDirectoryRecursiveTo),
("#" + _("Up_load file(s)"), self.OnUploadFiles))
self.folder_popup_menu = PopupMenu(self.frame)
self.folder_popup_menu.set_user(user)
if user == self.frame.np.config.sections["server"]["login"]:
self.folder_popup_menu.setup(
("USERMENU", _("User"), self.popup_menu_users,
self.OnPopupMenuFolderUser), ("", None),
(1, _("Download"), self.popup_menu_downloads_folders,
self.OnPopupMenuDummy),
(1, _("Upload"), self.popup_menu_uploads_folders,
self.OnPopupMenuDummy), ("", None),
("#" + _("Copy _URL"), self.OnCopyDirURL),
("#" + _("Open in File Manager"), self.OnFileManager))
else:
self.folder_popup_menu.setup(
("USERMENU", _("User"), self.popup_menu_users,
self.OnPopupMenuFolderUser), ("", None),
(1, _("Download"), self.popup_menu_downloads_folders,
self.OnPopupMenuDummy), ("", None),
("#" + _("Copy _URL"), self.OnCopyDirURL))
self.FolderTreeView.connect("button_press_event", self.OnFolderClicked)
self.FolderTreeView.get_selection().connect("changed",
self.OnSelectDir)
# DecodedFilename, HSize, Bitrate, HLength, Size, Length, RawFilename
self.FileStore = gtk.ListStore(str, str, str, str, gobject.TYPE_INT64,
int, str)
self.FileTreeView.set_model(self.FileStore)
cols = InitialiseColumns(
self.FileTreeView, [_("Filename"), 250, "text", self.CellDataFunc],
[_("Size"), 100, "text", self.CellDataFunc],
[_("Bitrate"), 70, "text", self.CellDataFunc],
[_("Length"), 50, "text", self.CellDataFunc])
cols[0].set_sort_column_id(0)
cols[1].set_sort_column_id(4)
cols[2].set_sort_column_id(2)
cols[3].set_sort_column_id(5)
self.FileStore.set_sort_column_id(0, gtk.SORT_ASCENDING)
for i in range(4):
parent = cols[i].get_widget().get_ancestor(gtk.Button)
if parent:
parent.connect('button_press_event', PressHeader)
# Read Show / Hide column settings from last session
self.FileTreeView.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.FileTreeView.set_headers_clickable(True)
self.FileTreeView.set_property("rules-hint", True)
self.file_popup_menu = PopupMenu(self.frame)
if user == self.frame.np.config.sections["server"]["login"]:
self.file_popup_menu.setup(
("USERMENU", "User", self.popup_menu_users2,
self.OnPopupMenuFileUser), ("", None),
(1, _("Download"), self.popup_menu_downloads_files,
self.OnPopupMenuDummy),
(1, _("Upload"), self.popup_menu_uploads_files,
self.OnPopupMenuDummy), ("", None),
("#" + _("Copy _URL"), self.OnCopyURL),
("#" + _("Send to _player"), self.OnPlayFiles),
("#" + _("Open in File Manager"), self.OnFileManager))
else:
self.file_popup_menu.setup(
("USERMENU", "User", self.popup_menu_users2,
self.OnPopupMenuFileUser), ("", None),
(1, _("Download"), self.popup_menu_downloads_files,
self.OnPopupMenuDummy), ("", None),
("#" + _("Copy _URL"), self.OnCopyURL))
self.FileTreeView.connect("button_press_event", self.OnFileClicked)
self.ChangeColours()
for name, object in self.__dict__.items():
if type(object) is PopupMenu:
object.set_user(self.user)
def initModel(self):
# create tree store
return gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_BOOLEAN,
gobject.TYPE_BOOLEAN, gobject.TYPE_BOOLEAN)
def __init__(self, tv):
self.trusted_keys = gtk.TreeStore(str, object)
tv.set_model(self.trusted_keys)
tc = gtk.TreeViewColumn(_('Trusted keys'),
gtk.CellRendererText(),
text=0)
tv.append_column(tc)
trust.trust_db.ensure_uptodate()
def update_keys():
# Remember which ones are open
expanded_elements = set()
def add_row(tv, path, unused=None):
if len(path) == 1:
domain = self.trusted_keys[path][0]
expanded_elements.add(domain)
tv.map_expanded_rows(add_row, None)
self.trusted_keys.clear()
domains = {}
keys = gpg.load_keys(list(trust.trust_db.keys.keys()))
for fingerprint in keys:
for domain in trust.trust_db.keys[fingerprint]:
if domain not in domains:
domains[domain] = set()
domains[domain].add(keys[fingerprint])
for domain in sorted(domains):
iter = self.trusted_keys.append(None, [domain, None])
for key in domains[domain]:
self.trusted_keys.append(iter, [key.name, key])
def may_expand(model, path, iter, unused):
if len(path) == 1:
if model[iter][0] in expanded_elements:
tv.expand_row(path, False)
self.trusted_keys.foreach(may_expand, None)
trust.trust_db.watchers.append(update_keys)
tv.connect('destroy',
lambda w: trust.trust_db.watchers.remove(update_keys))
update_keys()
def remove_key(fingerprint, domain):
trust.trust_db.untrust_key(fingerprint, domain)
trust.trust_db.notify()
def trusted_keys_button_press(tv, bev):
if bev.type == gtk.gdk.BUTTON_PRESS and bev.button == 3:
pos = tv.get_path_at_pos(int(bev.x), int(bev.y))
if not pos:
return False
path, col, x, y = pos
if len(path) != 2:
return False
key = self.trusted_keys[path][1]
if isinstance(path, tuple):
path = path[:-1] # PyGTK
else:
path.up() # PyGObject
domain = self.trusted_keys[path][0]
global menu # Needed to stop Python 3 GCing the menu and closing it instantly
menu = gtk.Menu()
item = gtk.MenuItem()
item.set_label(_('Remove key for "%s"') % key.get_short_name())
item.connect('activate',
lambda item, fp=key.fingerprint, d=domain:
remove_key(fp, d))
item.show()
menu.append(item)
if sys.version_info[0] > 2:
menu.popup(None, None, None, None, bev.button, bev.time)
else:
menu.popup(None, None, None, bev.button, bev.time)
return True
return False
tv.connect('button-press-event', trusted_keys_button_press)
def __init__(self, title, parent, tmpdir, timeout):
if timeout:
self.timeout = float(timeout)
else:
self.timeout = None
self.chosen = None
self.updater = None
self.tmpdir = tmpdir
self.gcapture_windows = []
gobject.threads_init()
# self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window = gtk.Dialog(
"Choose a suite",
parent,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OK,
gtk.RESPONSE_OK))
# self.window.set_modal(True)
self.window.set_title(title)
self.window.set_size_request(750, 400)
# TODO: not needed for a dialog window?
self.window.set_icon(get_icon())
# self.window.set_border_width(5)
self.window.connect("delete_event", self.delete_all_event)
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.regd_treeview = gtk.TreeView()
self.regd_treestore = gtk.TreeStore(str, str, str, str, str, str, str)
self.regd_treeview.set_model(self.regd_treestore)
self.regd_treeview.set_rules_hint(True)
# search column zero (Ctrl-F)
self.regd_treeview.connect('key_press_event', self.on_suite_select)
self.regd_treeview.connect('button_press_event', self.on_suite_select)
self.regd_treeview.set_search_column(0)
regd_ts = self.regd_treeview.get_selection()
regd_ts.set_mode(gtk.SELECTION_SINGLE)
cr = gtk.CellRendererText()
# cr.set_property('cell-background', '#def')
tvc = gtk.TreeViewColumn(
'Suite', cr, text=0, foreground=4, background=5)
tvc.set_resizable(True)
tvc.set_sort_column_id(0)
self.regd_treeview.append_column(tvc)
cr = gtk.CellRendererText()
tvc = gtk.TreeViewColumn(
'Host:Port', cr, text=1, foreground=4, background=5)
tvc.set_resizable(True)
# not sure how this sorting works
# tvc.set_sort_column_id(1)
self.regd_treeview.append_column(tvc)
cr = gtk.CellRendererText()
# cr.set_property('cell-background', '#def')
tvc = gtk.TreeViewColumn(
'Title', cr, markup=2, foreground=4, background=6)
tvc.set_resizable(True)
# vc.set_sort_column_id(2)
self.regd_treeview.append_column(tvc)
cr = gtk.CellRendererText()
tvc = gtk.TreeViewColumn(
'Location', cr, text=3, foreground=4, background=5)
tvc.set_resizable(True)
# vc.set_sort_column_id(3)
self.regd_treeview.append_column(tvc)
vbox = self.window.vbox
sw.add(self.regd_treeview)
vbox.pack_start(sw, True)
self.selected_label_text = (
'(double-click or OK to select; right-click for db options)')
self.selected_label = gtk.Label(self.selected_label_text)
filter_entry = EntryTempText()
filter_entry.set_width_chars(7) # Reduce width in toolbar
filter_entry.connect("activate", self.filter)
filter_entry.set_temp_text("filter")
filter_toolitem = gtk.ToolItem()
filter_toolitem.add(filter_entry)
tooltip = gtk.Tooltips()
tooltip.enable()
tooltip.set_tip(
filter_toolitem, "Filter suites \n(enter a sub-string or regex)")
expand_button = gtk.ToolButton()
image = gtk.image_new_from_stock(
gtk.STOCK_ADD, gtk.ICON_SIZE_SMALL_TOOLBAR)
expand_button.set_icon_widget(image)
expand_button.connect(
'clicked', lambda x: self.regd_treeview.expand_all())
collapse_button = gtk.ToolButton()
image = gtk.image_new_from_stock(
gtk.STOCK_REMOVE, gtk.ICON_SIZE_SMALL_TOOLBAR)
collapse_button.set_icon_widget(image)
collapse_button.connect(
'clicked', lambda x: self.regd_treeview.collapse_all())
hbox = gtk.HBox()
eb = gtk.EventBox()
eb.add(self.selected_label)
eb.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#bbc'))
hbox.pack_start(eb, True)
hbox.pack_start(expand_button, False)
hbox.pack_start(collapse_button, False)
hbox.pack_start(filter_toolitem, False)
vbox.pack_start(hbox, False)
self.window.show_all()
self.start_updater()
def show(self):
self.builder = gtk.Builder()
# The main dialog
self.builder.add_from_file(
deluge.common.resource_filename(
"deluge.ui.gtkui",
os.path.join("glade", "create_torrent_dialog.ui")))
# The remote path dialog
self.builder.add_from_file(
deluge.common.resource_filename(
"deluge.ui.gtkui",
os.path.join("glade", "create_torrent_dialog.remote_path.ui")))
# The remote save dialog
self.builder.add_from_file(
deluge.common.resource_filename(
"deluge.ui.gtkui",
os.path.join("glade", "create_torrent_dialog.remote_save.ui")))
# The progress dialog
self.builder.add_from_file(
deluge.common.resource_filename(
"deluge.ui.gtkui",
os.path.join("glade", "create_torrent_dialog.progress.ui")))
self.config = ConfigManager("gtkui.conf")
self.dialog = self.builder.get_object("create_torrent_dialog")
self.dialog.set_transient_for(component.get("MainWindow").window)
self.builder.connect_signals({
"on_button_file_clicked":
self._on_button_file_clicked,
"on_button_folder_clicked":
self._on_button_folder_clicked,
"on_button_remote_path_clicked":
self._on_button_remote_path_clicked,
"on_button_cancel_clicked":
self._on_button_cancel_clicked,
"on_button_save_clicked":
self._on_button_save_clicked,
"on_button_up_clicked":
self._on_button_up_clicked,
"on_button_add_clicked":
self._on_button_add_clicked,
"on_button_remove_clicked":
self._on_button_remove_clicked,
"on_button_down_clicked":
self._on_button_down_clicked
})
# path, icon, size
self.files_treestore = gtk.TreeStore(str, str, gobject.TYPE_UINT64)
column = gtk.TreeViewColumn(_("Filename"))
render = gtk.CellRendererPixbuf()
column.pack_start(render, False)
column.add_attribute(render, "stock-id", 1)
render = gtk.CellRendererText()
column.pack_start(render, True)
column.add_attribute(render, "text", 0)
column.set_expand(True)
self.builder.get_object("treeview_files").append_column(column)
column = gtk.TreeViewColumn(_("Size"))
render = gtk.CellRendererText()
column.pack_start(render)
column.set_cell_data_func(render, listview.cell_data_size, 2)
self.builder.get_object("treeview_files").append_column(column)
self.builder.get_object("treeview_files").set_model(
self.files_treestore)
self.builder.get_object("treeview_files").set_show_expanders(False)
# tier, url
self.trackers_liststore = gtk.ListStore(int, str)
self.builder.get_object("tracker_treeview").append_column(
gtk.TreeViewColumn(_("Tier"), gtk.CellRendererText(), text=0))
self.builder.get_object("tracker_treeview").append_column(
gtk.TreeViewColumn(_("Tracker"), gtk.CellRendererText(), text=1))
self.builder.get_object("tracker_treeview").set_model(
self.trackers_liststore)
self.trackers_liststore.set_sort_column_id(0, gtk.SORT_ASCENDING)
if not client.is_localhost() and client.connected():
self.builder.get_object("button_remote_path").show()
else:
self.builder.get_object("button_remote_path").hide()
self.dialog.show()
def treeview(self):
import main_treeview
# set up the treeview to do multiple selection
tree = self.widgets['treeview']
self.treemodel = gtk.TreeStore(str, gtk.gdk.Pixbuf, str, str, str, str, bool, str, str, int, str, str)
tree.set_model(self.treemodel)
tree.set_headers_visible(True)
tree.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.widgets['treeview'].get_selection().connect("changed", main_treeview.on_tree_selection, self)
# number column
renderer = gtk.CellRendererText()
self.number_column = gtk.TreeViewColumn(_('No.'), renderer, text=0)
self.number_column.set_name('number')
self.number_column.set_resizable(True)
self.number_column.set_sort_column_id(0)
self.number_column.set_reorderable(True)
self.widgets['treeview'].append_column(self.number_column)
# pic column
renderer = gtk.CellRendererPixbuf()
self.image_column = gtk.TreeViewColumn(_('Image'), renderer, pixbuf=1)
self.image_column.set_name('image')
self.image_column.set_resizable(False)
self.image_column.set_reorderable(True)
self.widgets['treeview'].append_column(self.image_column)
# original title column
renderer = gtk.CellRendererText()
self.otitle_column = gtk.TreeViewColumn(_('Original Title'), renderer, text=2)
self.otitle_column.set_name('otitle')
self.otitle_column.set_resizable(True)
self.otitle_column.set_sort_column_id(2)
self.otitle_column.set_reorderable(True)
self.widgets['treeview'].append_column(self.otitle_column)
# title column
renderer = gtk.CellRendererText()
self.title_column = gtk.TreeViewColumn(_('Title'), renderer, text=3)
self.title_column.set_name('title')
self.title_column.set_resizable(True)
self.title_column.set_sort_column_id(3)
self.title_column.set_reorderable(True)
self.widgets['treeview'].append_column(self.title_column)
# director column
renderer = gtk.CellRendererText()
self.director_column = gtk.TreeViewColumn(_('Director'), renderer, text=4)
self.director_column.set_name('director')
self.director_column.set_sort_column_id(4)
self.director_column.set_resizable(True)
self.director_column.set_reorderable(True)
self.widgets['treeview'].append_column(self.director_column)
# genre column
renderer = gtk.CellRendererText()
self.genre_column = gtk.TreeViewColumn(_('Genre'), renderer, text=5)
self.genre_column.set_name('genre')
self.genre_column.set_sort_column_id(5)
self.genre_column.set_resizable(True)
self.genre_column.set_reorderable(True)
self.widgets['treeview'].append_column(self.genre_column)
# seen column
renderer = gtk.CellRendererToggle()
self.seen_column = gtk.TreeViewColumn(_('Seen it'), renderer, active=6)
self.seen_column.set_name('seen')
self.seen_column.set_sort_column_id(6)
self.seen_column.set_resizable(True)
self.seen_column.set_reorderable(True)
self.widgets['treeview'].insert_column(self.seen_column, 1)
# year column
renderer = gtk.CellRendererText()
renderer.set_property('xalign', 0.5)
self.year_column = gtk.TreeViewColumn(_('Year'), renderer, text=7)
self.year_column.set_name('year')
self.year_column.set_sort_column_id(7)
self.year_column.set_resizable(True)
self.year_column.set_alignment(0.5)
self.year_column.set_reorderable(True)
self.widgets['treeview'].append_column(self.year_column)
# runtime column
renderer = gtk.CellRendererText()
renderer.set_property('xalign', 1)
self.runtime_column = gtk.TreeViewColumn(_('Runtime'), renderer, text=8)
self.runtime_column.set_name('runtime')
self.runtime_column.set_sort_column_id(8)
self.runtime_column.set_resizable(True)
self.runtime_column.set_alignment(1)
self.runtime_column.set_reorderable(True)
self.widgets['treeview'].append_column(self.runtime_column)
# rating column
renderer = gtk.CellRendererText()
renderer.set_property('xalign', 0.5)
self.rating_column = gtk.TreeViewColumn(_('Rating'), renderer, text=9)
self.rating_column.set_name('rating')
self.rating_column.set_sort_column_id(9)
self.rating_column.set_resizable(True)
self.rating_column.set_alignment(0.5)
self.rating_column.set_reorderable(True)
self.widgets['treeview'].append_column(self.rating_column)
# created column
renderer = gtk.CellRendererText()
renderer.set_property('xalign', 0.5)
self.created_column = gtk.TreeViewColumn(_('Created'), renderer, text=10)
self.created_column.set_name('created')
self.created_column.set_sort_column_id(10)
self.created_column.set_resizable(True)
self.created_column.set_alignment(0.5)
self.created_column.set_reorderable(True)
self.widgets['treeview'].append_column(self.created_column)
# updated column
renderer = gtk.CellRendererText()
renderer.set_property('xalign', 0.5)
self.updated_column = gtk.TreeViewColumn(_('Updated'), renderer, text=11)
self.updated_column.set_name('updated')
self.updated_column.set_sort_column_id(11)
self.updated_column.set_resizable(True)
self.updated_column.set_alignment(0.5)
self.updated_column.set_reorderable(True)
self.widgets['treeview'].append_column(self.updated_column)
# reflect saved column order and column sizes
columnorder = self.config.get('columnorder', None, section='mainlist')
if columnorder:
columnmapping = dict([(column.get_name(), column) for column in self.widgets['treeview'].get_columns()])
currentcol = None
columnordersplitted = re.split('[ \t]*,[ \t]*', columnorder)
for col in columnordersplitted:
if col in columnmapping:
self.widgets['treeview'].move_column_after(columnmapping[col], currentcol)
currentcol = columnmapping[col]
columnsizes = self.config.get('columnsizes', None, section='mainlist')
if columnsizes:
columnsizessplitted = re.split('[ \t]*,[ \t]*', columnsizes)
currentcol = 0
for columnsize in columnsizessplitted:
try:
columnsize = int(columnsize)
self.widgets['treeview'].get_column(currentcol).set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
self.widgets['treeview'].get_column(currentcol).set_fixed_width(columnsize)
except:
pass
currentcol = currentcol + 1
# reflect saved column sorting
columnsortid = self.config.get('columnsortid', None, section='mainlist')
columnsortorder = self.config.get('columnsortorder', None, section='mainlist')
try:
if columnsortid:
columnsortid = int(columnsortid)
if columnsortorder:
columnsortorder = gtk.SortType(int(columnsortorder))
else:
columnsortorder = gtk.SORT_ASCENDING
self.treemodel.set_sort_column_id(columnsortid, columnsortorder)
except:
log.exception('')
# add data to treeview
self.total = self.db.session.query(db.Movie).count()
self.widgets['treeview'].set_search_equal_func(search_func_treeview)
self.widgets['treeview'].show()
# adding some completion fields - TODO: move it to initialize
self.completion = gtk.EntryCompletion()
self.widgets['add']['o_title'].set_completion(self.completion)
self.completion.set_model(self.treemodel)
self.completion.set_text_column(3)
# ... title
self.completion_t = gtk.EntryCompletion()
self.widgets['add']['title'].set_completion(self.completion_t)
self.completion_t.set_model(self.treemodel)
self.completion_t.set_text_column(4)
def __init__(self, *args, **kwargs):
super(SongListWindow, self).__init__(gtk.WINDOW_TOPLEVEL, *args,
**kwargs)
# Connect the basic event handlers
self.connect("destroy", self.destroy)
# Read the songs from the database
songs = Song.objects.all()
####### Window furniture
# Set up the appearance of the window
self.set_default_size(300, 800)
self.set_title("Jazznotate - The Jazz Parser Annotation GUI")
# A box to put all the widgets in
vbox = gtk.VBox()
self.add(vbox)
######## The song list
# Set up the tree to contain the songs and their sequences
treestore = gtk.TreeStore(gobject.TYPE_STRING)
# Add all the songs from the database to the store
self.songs = []
for song in songs:
song_pos = treestore.append(None, [song.name])
song_seqs = []
for sequence in song.chordsequence_set.all():
treestore.append(song_pos, [sequence.sequence_distinguisher])
song_seqs.append(sequence)
self.songs.append((song, song_seqs))
treeview = gtk.TreeView(treestore)
self.treeview = treeview
# Let the list respond to clicks
self.treeview.connect("button_press_event", self.list_clicked)
# Add a column to the treeview to display the song names
name_column = gtk.TreeViewColumn("Song name")
self.treeview.append_column(name_column)
# Render the song names as text
name_renderer = gtk.CellRendererText()
name_column.pack_start(name_renderer, True)
name_column.add_attribute(name_renderer, "text", 0)
# Make it possible to search the signs
self.treeview.set_search_column(0)
# Put the treeview in scrollbars
treeview_scroll = gtk.ScrolledWindow()
treeview_scroll.add_with_viewport(treeview)
vbox.add(treeview_scroll)
# Add buttons at the bottom
button_box = gtk.HButtonBox()
button_box.set_layout(gtk.BUTTONBOX_END)
midi_button = gtk.Button("Midis")
midi_button.connect("clicked", self.open_midis)
edit_button = gtk.Button("Edit sequence")
edit_button.connect("clicked", self.open_sequence)
meta_edit_button = gtk.Button("Edit sequence details")
meta_edit_button.connect("clicked", self.open_sequence_meta)
song_edit_button = gtk.Button("Edit song details")
song_edit_button.connect("clicked", self.open_song)
button_box.pack_end(midi_button, expand=False, padding=5)
button_box.pack_end(song_edit_button, expand=False, padding=5)
button_box.pack_end(meta_edit_button, expand=False, padding=5)
button_box.pack_end(edit_button, expand=False, padding=5)
vbox.pack_end(button_box, expand=False, padding=5)
# Prepare popup menus for right-clicking on the list
# Two menus for different conditions
sequence_meta_item = gtk.MenuItem("Edit sequence details")
sequence_meta_item.connect("activate", self.open_sequence_meta)
sequence_meta_item.show()
sequence_edit_item = gtk.MenuItem("Edit sequence")
sequence_edit_item.connect("activate", self.open_sequence)
sequence_edit_item.show()
midis_item = gtk.MenuItem("Show midi records")
midis_item.connect("activate", self.open_midis)
midis_item.show()
song_edit_item = gtk.MenuItem("Edit song details")
song_edit_item.connect("activate", self.open_song)
song_edit_item.show()
self.menu_sequence_and_song = gtk.Menu()
self.menu_sequence_and_song.append(sequence_meta_item)
self.menu_sequence_and_song.append(sequence_edit_item)
self.menu_sequence_and_song.append(midis_item)
self.menu_sequence_and_song.append(song_edit_item)
song_edit_item2 = gtk.MenuItem("Edit song details")
song_edit_item2.connect("button_press_event", self.open_song)
song_edit_item2.show()
self.menu_song = gtk.Menu()
self.menu_song.append(song_edit_item2)
self.show_all()
def lang_treeview(self):
treeview = self.widgets['add']['lang_treeview']
self.lang['model'] = gtk.TreeStore(str, str, str, str, str)
treeview.set_model(self.lang['model'])
treeview.set_headers_visible(True)
model = self.lang['lang'] = gtk.ListStore(int, str)
for i in self.db.session.query(db.Lang.lang_id, db.Lang.name).all():
model.append([i.lang_id, i.name])
combo = gtk.CellRendererCombo()
combo.set_property('model', model)
combo.set_property('text-column', 1)
combo.set_property('editable', True)
combo.set_property('has-entry', False)
combo.connect('edited', self.on_tv_lang_combo_edited, 0)
column = gtk.TreeViewColumn(_('Language'), combo, text=0)
column.set_property('min-width', 80)
column.set_property('resizable', True)
column.set_sort_column_id(0)
treeview.append_column(column)
model = self.lang['type'] = gtk.ListStore(int, str)
#i = 0
#for lang_type in self._lang_types:
# model.append([i, lang_type])
# i += 1
model.append([0, ''])
model.append([1, _('lector')])
model.append([2, _('dubbing')])
model.append([3, _('subtitles')])
model.append([4, _("commentary")])
combo = gtk.CellRendererCombo()
combo.set_property('model', model)
combo.set_property('text-column', 1)
combo.set_property('editable', True)
combo.set_property('has-entry', False)
combo.connect('edited', self.on_tv_lang_combo_edited, 1)
column = gtk.TreeViewColumn(_('Type'), combo, text=1)
column.set_property('min-width', 80)
column.set_property('resizable', True)
column.set_sort_column_id(1)
treeview.append_column(column)
model = self.lang['acodec'] = gtk.ListStore(int, str)
for i in self.db.session.query(db.ACodec.acodec_id, db.ACodec.name).all():
model.append([i.acodec_id, i.name])
combo = gtk.CellRendererCombo()
combo.set_property('model', model)
combo.set_property('text-column', 1)
combo.set_property('editable', True)
combo.set_property('has-entry', False)
combo.connect('edited', self.on_tv_lang_combo_edited, 2)
column = gtk.TreeViewColumn(_('Codec'), combo, text=2)
column.set_property('min-width', 80)
column.set_property('resizable', True)
column.set_sort_column_id(2)
treeview.append_column(column)
model = self.lang['achannel'] = gtk.ListStore(int, str)
for i in self.db.session.query(db.AChannel.achannel_id, db.AChannel.name).all():
model.append([i.achannel_id, i.name])
combo = gtk.CellRendererCombo()
combo.set_property('model', model)
combo.set_property('text-column', 1)
combo.set_property('editable', True)
combo.set_property('has-entry', False)
combo.connect('edited', self.on_tv_lang_combo_edited, 3)
column = gtk.TreeViewColumn(_('Channels'), combo, text=3)
column.set_property('min-width', 80)
column.set_property('resizable', True)
column.set_sort_column_id(3)
treeview.append_column(column)
model = self.lang['subformat'] = gtk.ListStore(int, str)
for i in self.db.session.query(db.SubFormat.subformat_id, db.SubFormat.name).all():
model.append([i.subformat_id, i.name])
combo = gtk.CellRendererCombo()
combo.set_property('model', model)
combo.set_property('text-column', 1)
combo.set_property('editable', True)
combo.set_property('has-entry', False)
combo.connect('edited', self.on_tv_lang_combo_edited, 4)
column = gtk.TreeViewColumn(_('Subtitle format'), combo, text=4)
column.set_property('min-width', 80)
column.set_property('resizable', True)
column.set_sort_column_id(4)
treeview.append_column(column)
treeview.show_all()
def wmf_gentree():
# Record/Group Name Rec. Type Min. Length Template
model = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_INT,
gobject.TYPE_STRING, gobject.TYPE_PYOBJECT)
view = gtk.TreeView(model)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn('Group/Record', renderer, text=0)
column2 = gtk.TreeViewColumn('Length', renderer, text=2)
view.append_column(column)
view.append_column(column2)
# Drawing Record Types
# 2610:ExtTextOut,
drawrec = (
(0x213, 10, "\x05\x00\x00\x00\x13\x02\x00\x00\x00\x00"), #LineTo
(0x214, 10, "\x05\x00\x00\x00\x14\x02\x00\x00\x00\x00"), #MoveTo
(0x324, 20,
"\x0a\x00\x00\x00\x24\x03\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
), #Polygon
(0x325, 20,
"\x0a\x00\x00\x00\x25\x03\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
), #Polyline
(0x418, 14,
"\x07\x00\x00\x00\x18\x04\x00\x00\x00\x00\x00\x00\x00\x00"), #Ellipse
(0x41b, 14, "\x07\x00\x00\x00\x1b\x04\x00\x00\x00\x00\x00\x00\x00\x00"
), #Rectangle
(0x538, 22,
"\x0b\x00\x00\x00\x38\x05\x01\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
), #PolyPolygon
(0x61c, 18,
"\x09\x00\x00\x00\x1c\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
), #RoundRect
(0x817, 22,
"\x0b\x00\x00\x00\x17\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
), #Arc
(0x81a, 22,
"\x0b\x00\x00\x00\x1a\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
), #Pie
(0x830, 22,
"\x0b\x00\x00\x00\x30\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
), #Chord
)
# Object Creation Record Types
objcrec = ((0x5d, 32), (0x5e, 32), (0x5f, 32), (0x7a, 20), (0x26, 28),
(0x27, 24), (0x31, 12), (0x52, 16), (0x63, 12))
# Object Manipulation Record Types
objmrec = (0x25, 0x28, 0x30, 0x32, 0x33, 0x64, 0x65, 0x6f)
# State Record Types
staterec = (0xa, 0xb, 0xc, 0xd, 0x17, 0x1b, 0x1f, 0x9, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15,\
0x16, 0x18, 0x19, 0x20, 0x21, 0x22, 0x34, 0x39, 0x3a, 0x49, 0x62, 0x68, 0x6d,\
0x70, 0x71, 0x73, 0x77, 0x78, 0x79)
iter = model.append(None, None)
model.set(iter, 0, "Drawing Records", 1, -1, 2, "")
for i in range(len(drawrec)):
niter = model.append(iter, None)
model.set(niter, 0, wmr_ids[drawrec[i][0]], 1, drawrec[i][0], 2,
drawrec[i][1], 3, drawrec[i][2])
return model, view
def extension_preferences(self, module, enabled):
# preferences window
p_vbox = self.widgets['extensions']['preferences_vbox']
configwidgets = {}
label = "%s v%s <i>(%s <%s>)</i>" % (module.name, module.version, module.author, module.email)
expander = gtk.Expander(label=label)
expander.get_label_widget().set_tooltip_markup(module.description)
expander.set_use_markup(True)
vbox = gtk.VBox()
# extension details
hbox = gtk.HBox()
vbox.pack_start(hbox, expand=False)
enabled_cb = gtk.CheckButton(label=_('Enable this extension'))
enabled_cb.set_active(enabled)
configwidgets['enabled'] = enabled_cb
vbox.pack_start(enabled_cb, expand=False)
for pref_name in module.preferences:
name = module.preferences[pref_name].get('name', pref_name)
hint = module.preferences[pref_name].get('hint')
value = module.preferences[pref_name].get('default')
value = self.config.get("%s_%s" % (module.name, pref_name), value, section='extensions')
type_ = module.preferences[pref_name].get('type', unicode)
hbox = gtk.HBox()
hbox.pack_start(gtk.Label(name), expand=False, padding=4)
if type_ is unicode:
w = gtk.Entry()
w.insert_text(value)
# TODO: min, max
# elif type is int: # TODO
elif type_ is bool:
w = gtk.CheckButton()
w.set_active(bool(value))
elif isinstance(type_, (list, tuple, dict)):
model = gtk.TreeStore(str, str)
if isinstance(type_, dict):
iterable = type_.iteritems()
else:
iterable = enumerate(type_)
pos = None
count = 0
for code, codevalue in iterable:
myiter = model.append(None, None)
model.set_value(myiter, 0, unicode(code))
model.set_value(myiter, 1, unicode(codevalue))
if value and value == codevalue:
pos = count
count = count + 1
# combobox with complex binding to a model needs cell renderer
w = gtk.ComboBox(model=model)
renderer = gtk.CellRendererText()
w.pack_start(renderer)
w.add_attribute(renderer, 'text', 1)
if pos is not None:
w.set_active(int(pos))
else:
log.error('type not recognized %s', type(type_))
continue
if hint:
w.set_tooltip_markup(hint)
hbox.pack_start(w)
vbox.pack_start(hbox, expand=False)
configwidgets[pref_name] = w
expander.add(vbox)
p_vbox.pack_start(expander, expand=False)
p_vbox.show_all()
return configwidgets
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.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.joinButton.connect("clicked", self.joinGame_cb)
bbox.add(self.joinButton)
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 treeview_widgets(self):
self.sort_col_num = 0
self.ttreestore = gtk.TreeStore(str, str, str, str, str, str, str, str,
str, str, str, gtk.gdk.Pixbuf, int)
self.ttreeview = gtk.TreeView()
self.ttreeview.set_rules_hint(True)
# TODO - REMOVE FILTER HERE?
self.tmodelfilter = self.ttreestore.filter_new()
self.tmodelsort = gtk.TreeModelSort(self.tmodelfilter)
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 system',
'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=11)
if n == 8:
# Pack in progress and text cell renderers.
prog_cr = gtk.CellRendererProgress()
tvc.pack_start(prog_cr, True)
tvc.set_cell_data_func(prog_cr, self._set_cell_text_time, n)
cr = gtk.CellRendererText()
tvc.pack_start(cr, True)
if n == 6 or n == 7 or n == 8:
tvc.set_cell_data_func(cr, self._set_cell_text_time, 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)
vbox = gtk.VBox()
vbox.pack_start(sw, True)
return vbox
def parse (cmd, entry, page):
if cmd[0] == "$":
pos = cmd.find("@")
if pos != -1:
chtype = cmd[1:pos]
chaddr = cmd[pos+1:]
else:
chtype = cmd[1:]
chaddr = "0"
print("Command: ",chtype,chaddr)
treeSelection = page.view.get_selection()
model, iter1 = treeSelection.get_selected()
if iter1 == None:
page.view.set_cursor_on_cell(0)
treeSelection = page.view.get_selection()
model, iter1 = treeSelection.get_selected()
buf = model.get_value(iter1,3)
if "ole" == chtype.lower():
if buf[int(chaddr,16):int(chaddr,16)+8] == "\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1":
ole.ole_open (buf[int(chaddr,16):],page,iter1)
else:
print("OLE stream not found at ",chaddr)
elif "bmp" == chtype.lower():
#try:
if 1:
addr,bpp,w,h = chaddr.split(":")
dib_data = "\x28\x00\x00\x00"+struct.pack("<I",int(w))+struct.pack("<I",int(h))+"\x01\x00"
dib_data += struct.pack("<H",int(bpp))+"\x00"*8+struct.pack("<I",160)*2+"\x00"*8
dib_data += buf[int(addr,16):]
iter2 = add_pgiter (page,"[BMP]","escher","Blip",dib2bmp(dib_data),iter1)
model.set_value(iter2,1,("escher","odraw","Blip"))
#except:
# print 'Failed to construct DIB data'
elif "b64" == chtype.lower():
b64decode (page,buf[int(chaddr,16):],iter1)
elif "cvx" == chtype.lower():
cvx.parse (page,buf[int(chaddr,16):],iter1)
elif "esc" == chtype.lower():
escher.parse (model,buf[int(chaddr,16):],iter1)
elif "cmx" == chtype.lower():
cdr.cdr_open (buf[int(chaddr,16):],page,iter1)
elif "icc" == chtype.lower():
icc.parse (page,buf[int(chaddr,16):],iter1)
elif "cdx" == chtype.lower():
chdraw.open (page,buf[int(chaddr,16):],iter1)
elif "yep" == chtype.lower():
yep.parse (page,buf[int(chaddr,16):],iter1)
elif "yep0" == chtype.lower():
yep.parse (page,buf[int(chaddr,16):],iter1,0)
elif "emf" == chtype.lower():
pt = page.type
page.type = "EMF"
mf.mf_open (buf[int(chaddr,16):],page,iter1)
page.type = pt
elif "pix" == chtype.lower():
# try:
off = int(chaddr,16)
ntype = model.get_value(iter1,1)
if off:
iter2 = add_pgiter(page,"Picture","escher","Blip",buf[off:],iter1)
model.set_value(iter2,1,("escher","odraw","Blip"))
else:
model.set_value(iter1,1,("escher","odraw","Blip"))
page.hd.hv.parent.on_row_activated(page.hd.hv,model.get_path(iter1),None)
# except:
# print "Failed to add as a picture"
elif "dump" == chtype.lower():
dlg = gtk.FileChooserDialog('Save...', action=gtk.FILE_CHOOSER_ACTION_SAVE, buttons=(gtk.STOCK_OK,gtk.RESPONSE_OK,gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL))
dlg.set_local_only(True)
resp = dlg.run()
fname = dlg.get_filename()
dlg.hide()
if resp != gtk.RESPONSE_CANCEL:
nlen = model.get_value(iter1,2)
if chaddr != 0:
pos = chaddr.find(":")
if pos != -1:
endaddr = chaddr[pos+1:]
chaddr = chaddr[:pos]
value = model.get_value(iter1,3)[int(chaddr,16):int(endaddr,16)]
else:
value = model.get_value(iter1,3)[int(chaddr,16):]
else:
value = model.get_value(iter1,3)[int(chaddr,16):]
if nlen != None:
f = open(fname,'wb')
f.write(value)
f.close()
else:
print("Nothing to save")
elif "wmf" == chtype.lower() or "apwmf" == chtype.lower():
pt = page.type
page.type = chtype.upper()
mf.mf_open (buf[int(chaddr,16):],page,iter1)
page.type = pt
elif "xls" == chtype.lower():
ch2 = chaddr[1]
if ch2.isdigit():
coladdr = ord(chaddr[0].lower()) - 97
rowaddr = int(chaddr[1:]) - 1
else:
coladdr = 26*(ord(chaddr[0].lower()) - 96)+ ord(chaddr[1].lower()) - 97
rowaddr = int(chaddr[2:]) - 1
page.search = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_INT, gobject.TYPE_STRING, gobject.TYPE_INT)
model.foreach(xlsfind,(page,rowaddr,coladdr))
page.show_search("XLS: cell %s"%chaddr)
elif "rx2" == chtype.lower():
newL = struct.unpack('>I', buf[int(chaddr,16)+4:int(chaddr,16)+8])[0]
rx2.parse (model,buf[int(chaddr,16):int(chaddr,16)+newL],0,iter1)
elif "dib" == chtype.lower():
iter2 = add_pgiter (page,"[BMP]","",0,dib2bmp(buf[int(chaddr,16):]),iter1)
model.set_value(iter2,1,("escher","odraw","Blip"))
elif "pct" == chtype.lower():
pict.parse (page,buf,iter1)
elif "pm6" == chtype.lower():
off = int(chaddr,16)
pm6.open (page,buf,iter1,off)
elif "vba" == chtype.lower():
# off = int(chaddr,16)
vba.parse (page,buf,iter1)
elif "zip" == chtype.lower():
try:
print(int(chaddr,16))
decobj = zlib.decompressobj()
output = decobj.decompress(buf[int(chaddr,16):])
add_pgiter (page,"[Decompressed data]","",0,output,iter1)
tail = decobj.unused_data
if len(tail) > 0:
add_pgiter (page,"[Tail]","",0,tail,iter1)
except:
print("Failed to decompress as zlib")
try:
f = StringIO.StringIO(buf[int(chaddr,16):])
pkzip.open(f, page, iter1)
f.close()
except:
print("Failed to decompress as pkzip")
elif cmd[0] == "?":
ctype = cmd[1]
carg = cmd[2:]
# convert line to hex or unicode if required
data = arg_conv(ctype,carg)
model = page.view.get_model()
page.search = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_INT, gobject.TYPE_STRING, gobject.TYPE_INT)
if ctype == 'r' or ctype == 'R':
model.foreach(recfind,(page,data))
else:
model.foreach(cmdfind,(page,data))
page.show_search(carg)
def __init__(self):
component.Component.__init__(self, "FilterTreeView", interval=2)
self.window = component.get("MainWindow")
main_builder = self.window.get_builder()
self.hpaned = main_builder.get_object("main_window_hpaned")
self.scrolled = main_builder.get_object("scrolledwindow_sidebar")
self.sidebar = component.get("SideBar")
self.config = ConfigManager("gtkui.conf")
self.tracker_icons = component.get("TrackerIcons")
self.label_view = gtk.TreeView()
self.sidebar.add_tab(self.label_view, "filters", "Filters")
#set filter to all when hidden:
self.sidebar.notebook.connect("hide", self._on_hide)
#menu
builder = gtk.Builder()
builder.add_from_file(
deluge.common.resource_filename(
"deluge.ui.gtkui", os.path.join("glade",
"filtertree_menu.ui")))
self.menu = builder.get_object("filtertree_menu")
builder.connect_signals({
"select_all": self.on_select_all,
"pause_all": self.on_pause_all,
"resume_all": self.on_resume_all
})
self.default_menu_items = self.menu.get_children()
# Create the liststore
#cat, value, label, count, pixmap, visible
self.treestore = gtk.TreeStore(str, str, str, int, gtk.gdk.Pixbuf,
bool)
# Create the column
column = gtk.TreeViewColumn("Filters")
column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
render = gtk.CellRendererPixbuf()
self.renderpix = render
column.pack_start(render, expand=False)
column.add_attribute(render, 'pixbuf', 4)
render = gtk.CellRendererText()
column.pack_start(render, expand=False)
column.set_cell_data_func(render, self.render_cell_data, None)
self.label_view.append_column(column)
#style:
self.label_view.set_show_expanders(True)
self.label_view.set_headers_visible(False)
self.label_view.set_level_indentation(-35)
# Force the theme to use an expander-size of 15 so that we don't cut out
# entries due to our indentation hack.
gtk.rc_parse_string(
'style "treeview-style" { GtkTreeView::expander-size = 15 } class "GtkTreeView" style "treeview-style"'
)
self.label_view.set_model(self.treestore)
self.label_view.get_selection().connect("changed",
self.on_selection_changed)
self.create_model_filter()
#init.....
self.label_view.connect("button-press-event",
self.on_button_press_event)
#colors using current theme.
style = self.window.window.get_style()
self.colour_background = style.bg[gtk.STATE_NORMAL]
self.colour_foreground = style.fg[gtk.STATE_NORMAL]
