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):
DBusGMainLoop(set_as_default=True)
self.session_bus = dbus.SessionBus()
self.proxy = self.session_bus.get_object('org.xiphos.remote',
'/org/xiphos/remote/ipc')
self.session_bus.add_signal_receiver(
self.receive_navigation,
dbus_interface='org.xiphos.remote',
signal_name='navigationSignal')
self.session_bus.add_signal_receiver(
self.receive_search_event,
dbus_interface='org.xiphos.remote',
signal_name='searchPerformedSignal')
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("destroy", self.destroy)
self.window.set_border_width(10)
self.vbox = gtk.VBox()
self.window.add(self.vbox)
self.vbox.show()
self.hbox = gtk.HBox()
self.vbox.pack_start(self.hbox)
self.hbox.show()
self.entry = gtk.Entry()
self.hbox.pack_start(self.entry)
self.entry.show()
self.button = gtk.Button("Navigate Xiphos")
self.button.connect("clicked", self.navigate_xiphos, None)
self.hbox.pack_end(self.button)
self.button.show()
self.hbox_ref = gtk.HBox()
self.vbox.pack_end(self.hbox_ref)
self.hbox_ref.show()
self.label_ref_static = gtk.Label('Current Reference: ')
self.hbox_ref.pack_start(self.label_ref_static)
self.label_ref_static.show()
self.label_ref = gtk.Label(self.proxy.getCurrentReference())
self.hbox_ref.pack_end(self.label_ref)
self.label_ref.show()
self.hbox_res = gtk.HBox()
self.vbox.pack_end(self.hbox_res)
self.hbox_res.show()
self.scrollbox = gtk.ScrolledWindow()
self.hbox_res.pack_end(self.scrollbox)
self.scrollbox.show()
self.results_tree = gtk.TreeView()
self.results_tree.set_size_request(-1, 200)
self.cell = gtk.CellRendererText()
self.column = gtk.TreeViewColumn('Reference')
self.column.pack_start(self.cell, True)
self.column.add_attribute(self.cell, 'text', 0)
self.results_tree.append_column(self.column)
self.scrollbox.add(self.results_tree)
self.results_tree.show()
self.window.show()
def create_pane(self):
self.pane = gtk.Table(2, 5, False)
self.pane.set_border_width(5)
self.pane.set_row_spacings(5)
self.pane.set_col_spacings(5)
label1 = gtk.Label('')
label1.set_text_with_mnemonic('_Recipe name')
label1.set_alignment(1.0, 0.5)
self.pane.attach(label1, 0, 1, 0, 1, gtk.FILL, 0, 0, 0)
self.recipe_entry = gtk.Entry()
label1.set_mnemonic_widget(self.recipe_entry)
self.pane.attach(self.recipe_entry, 1, 5, 0, 1, gtk.FILL | gtk.EXPAND,
0, 0, 0)
label2 = gtk.Label('')
label2.set_text_with_mnemonic('_Category')
label2.set_alignment(1.0, 0.5)
self.pane.attach(label2, 0, 1, 1, 2, gtk.FILL, 0, 0, 0)
self.category_combo = gnutr_widgets.GnutrComboBox()
label2.set_mnemonic_widget(self.category_combo)
self.pane.attach(self.category_combo, 1, 2, 1, 2,
gtk.FILL | gtk.EXPAND, 0, 0, 0)
label3 = gtk.Label(" ")
self.pane.attach(label3, 2, 3, 1, 2, gtk.FILL, 0, 0, 0)
label4 = gtk.Label('')
label4.set_text_with_mnemonic('_Num. servings')
label4.set_alignment(1, 0.5)
self.pane.attach(label4, 3, 4, 1, 2, gtk.FILL, 0, 0, 0)
self.num_serv_entry = gtk.Entry()
label4.set_mnemonic_widget(self.num_serv_entry)
self.pane.attach(self.num_serv_entry, 4, 5, 1, 2,
gtk.FILL | gtk.EXPAND, 0, 0, 0)
self.vpaned = gtk.VPaned()
self.pane.attach(self.vpaned, 0, 5, 2, 3, gtk.FILL | gtk.EXPAND,
gtk.FILL | gtk.EXPAND, 0, 0)
vbox1 = gtk.VBox(False, 0)
self.vpaned.pack1(vbox1, True, True)
self.vbox2 = gtk.VBox(False, 0)
self.vpaned.pack2(self.vbox2, True, True)
frame1 = gtk.Frame()
frame1.set_shadow_type(gtk.SHADOW_IN)
vbox1.pack_start(frame1, False, False, 0)
button1 = gtk.Button(label="Ingredients")
frame1.add(button1)
frame2 = gtk.Frame()
frame2.set_shadow_type(gtk.SHADOW_IN)
self.vbox2.pack_start(frame2, False, False, 0)
button2 = gtk.Button(label='Recipe Instructions')
frame2.add(button2)
scrolledwindow1 = gtk.ScrolledWindow()
scrolledwindow1.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
vbox1.pack_start(scrolledwindow1, True, True, 0)
self.treemodel = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_OBJECT)
self.treeview = gtk.TreeView(self.treemodel)
self.treeview.set_rules_hint(True)
self.selection = self.treeview.get_selection()
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn('Amount', renderer, text=0)
self.treeview.append_column(column)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn('Measure', renderer, text=1)
self.treeview.append_column(column)
renderer = gtk.CellRendererText()
column = gtk.TreeViewColumn('Food', renderer, text=2)
self.treeview.append_column(column)
scrolledwindow1.add(self.treeview)
self.scrolledwindow2 = gtk.ScrolledWindow()
self.scrolledwindow2.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
self.vbox2.pack_start(self.scrolledwindow2, True, True, 0)
self.text_box = gtk.TextView()
self.text_buffer = gtk.TextBuffer(None)
self.text_box.set_buffer(self.text_buffer)
self.text_box.set_editable(True)
self.text_box.set_cursor_visible(True)
self.scrolledwindow2.add(self.text_box)
self.pane.show_all()
def __init__(self):
gtk.Entry.__init__(self)
self.news = False
self.activities = None
self.external_activities = [] # suggestions from outer space
self.categories = None
self.filter = None
self.max_results = 10 # limit popup size to 10 results
self.popup = gtk.Window(type = gtk.WINDOW_POPUP)
box = gtk.ScrolledWindow()
box.set_shadow_type(gtk.SHADOW_IN)
box.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.tree = gtk.TreeView()
self.tree.set_headers_visible(False)
self.tree.set_hover_selection(True)
self.time_icon_cell = gtk.CellRendererPixbuf()
self.time_icon_cell.set_property("icon-name", "appointment-new")
self.time_icon_column = gtk.TreeViewColumn("", self.time_icon_cell)
self.tree.append_column(self.time_icon_column)
self.time_cell = gtk.CellRendererText()
self.time_cell.set_property("scale", 0.8)
self.time_column = gtk.TreeViewColumn("Time",
self.time_cell,
text = 3)
self.tree.append_column(self.time_column)
self.activity_column = gtk.TreeViewColumn("Activity",
gtk.CellRendererText(),
text=1)
self.activity_column.set_expand(True)
self.tree.append_column(self.activity_column)
self.category_cell = gtk.CellRendererText()
self.category_cell.set_property('alignment', pango.ALIGN_RIGHT)
self.category_cell.set_property('scale', pango.SCALE_SMALL)
self.category_cell.set_property('yalign', 0.0)
self.category_column = gtk.TreeViewColumn("Category",
self.category_cell,
text=2)
self.tree.append_column(self.category_column)
self.tree.connect("button-press-event", self._on_tree_button_press_event)
box.add(self.tree)
self.popup.add(box)
self.connect("button-press-event", self._on_button_press_event)
self.connect("key-press-event", self._on_key_press_event)
self.connect("key-release-event", self._on_key_release_event)
self.connect("focus-out-event", self._on_focus_out_event)
self.connect("changed", self._on_text_changed)
self._parent_click_watcher = None # bit lame but works
self.external_listeners = [
(runtime.storage, runtime.storage.connect('activities-changed',self.after_activity_update)),
]
self.show()
self.populate_suggestions()
self.connect("destroy", self.on_destroy)
def __init__(self, colheaders, formatterd=None):
"""
xalignd if not None, is a dict mapping col header to xalignent (default 1)
formatterd if not None, is a dict mapping col header to a ColumnFormatter
"""
gtk.ScrolledWindow.__init__(self)
self.colheaders = colheaders
self.seq = None # not initialized with accts
self.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
types = [gobject.TYPE_STRING] * len(colheaders)
model = self.model = gtk.ListStore(*types)
treeview = gtk.TreeView(self.model)
treeview.show()
treeview.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
treeview.set_rules_hint(True)
class Clicked:
def __init__(self, parent, i):
self.parent = parent
self.i = i
self.num = 0
def __call__(self, column):
ind = []
dsu = []
for rownum, thisiter in enumerate(self.parent.iters):
val = model.get_value(thisiter, self.i)
try:
val = float(val.strip().rstrip('%'))
except ValueError:
pass
if mlab.safe_isnan(val):
val = npy.inf # force nan to sort uniquely
dsu.append((val, rownum))
dsu.sort()
if not self.num % 2: dsu.reverse()
vals, otherind = list(zip(*dsu))
ind.extend(otherind)
self.parent.model.reorder(ind)
newiters = []
for i in ind:
newiters.append(self.parent.iters[i])
self.parent.iters = newiters[:]
for i, thisiter in enumerate(self.parent.iters):
key = tuple([
self.parent.model.get_value(thisiter, j)
for j in range(len(colheaders))
])
self.parent.rownumd[i] = key
self.num += 1
if formatterd is None:
formatterd = dict()
formatterd = formatterd.copy()
for i, header in enumerate(colheaders):
renderer = gtk.CellRendererText()
if header not in formatterd:
formatterd[header] = ColumnFormatter()
formatter = formatterd[header]
column = gtk.TreeViewColumn(header, renderer, text=i)
renderer.set_property('xalign', formatter.xalign)
renderer.set_property('editable', True)
renderer.connect("edited", self.position_edited, i)
column.connect('clicked', Clicked(self, i))
column.set_property('clickable', True)
if formatter.cell is not None:
column.set_cell_data_func(renderer, formatter.cell)
treeview.append_column(column)
self.formatterd = formatterd
self.lastcol = column
self.add(treeview)
self.treeview = treeview
self.clear()
def __init__(self, instance, uiman):
gtk.VBox.__init__(self)
Loggable.__init__(self)
self.app = instance
self.settings = instance.settings
self._dragButton = None
self._dragStarted = False
self._dragSelection = False
self._dragX = 0
self._dragY = 0
#Tooltip handling
self._current_effect_name = None
self._current_tooltip_icon = None
#Searchbox and combobox
hfilters = gtk.HBox()
hfilters.set_spacing(SPACING)
hfilters.set_border_width(
3) # Prevents being flush against the notebook
self.effectType = gtk.combo_box_new_text()
self.effectType.append_text(_("Video effects"))
self.effectType.append_text(_("Audio effects"))
self.effectCategory = gtk.combo_box_new_text()
self.effectType.set_active(VIDEO_EFFECT)
hfilters.pack_start(self.effectType, expand=True)
hfilters.pack_end(self.effectCategory, expand=True)
hsearch = gtk.HBox()
hsearch.set_spacing(SPACING)
hsearch.set_border_width(
3) # Prevents being flush against the notebook
searchStr = gtk.Label(_("Search:"))
self.searchEntry = gtk.Entry()
self.searchEntry.set_icon_from_stock(gtk.ENTRY_ICON_SECONDARY,
"gtk-clear")
hsearch.pack_start(searchStr, expand=False)
hsearch.pack_end(self.searchEntry, expand=True)
# Store
self.storemodel = gtk.ListStore(str, str, int, object, object, str,
gtk.gdk.Pixbuf)
# Scrolled Windows
self.treeview_scrollwin = gtk.ScrolledWindow()
self.treeview_scrollwin.set_policy(gtk.POLICY_NEVER,
gtk.POLICY_AUTOMATIC)
self.treeview_scrollwin.set_shadow_type(gtk.SHADOW_ETCHED_IN)
self.iconview_scrollwin = gtk.ScrolledWindow()
self.iconview_scrollwin.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
self.iconview_scrollwin.set_shadow_type(gtk.SHADOW_ETCHED_IN)
# TreeView
# Displays name, description
self.treeview = gtk.TreeView(self.storemodel)
self.treeview_scrollwin.add(self.treeview)
self.treeview.set_property("rules_hint", True)
self.treeview.set_property("has_tooltip", True)
self.treeview.set_property("headers-clickable", False)
tsel = self.treeview.get_selection()
tsel.set_mode(gtk.SELECTION_SINGLE)
namecol = gtk.TreeViewColumn(_("Name"))
namecol.set_sort_column_id(COL_NAME_TEXT)
self.treeview.append_column(namecol)
namecol.set_spacing(SPACING)
namecol.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
namecol.set_fixed_width(150)
namecell = gtk.CellRendererText()
namecell.props.xpad = 6
namecell.set_property("ellipsize", pango.ELLIPSIZE_END)
namecol.pack_start(namecell)
namecol.add_attribute(namecell, "text", COL_NAME_TEXT)
desccol = gtk.TreeViewColumn(_("Description"))
desccol.set_sort_column_id(COL_DESC_TEXT)
self.treeview.append_column(desccol)
desccol.set_expand(True)
desccol.set_spacing(SPACING)
desccol.set_sizing(gtk.TREE_VIEW_COLUMN_AUTOSIZE)
desccol.set_min_width(150)
desccell = gtk.CellRendererText()
desccell.props.xpad = 6
desccell.set_property("ellipsize", pango.ELLIPSIZE_END)
desccol.pack_start(desccell)
desccol.add_attribute(desccell, "text", COL_DESC_TEXT)
self.iconview = gtk.IconView(self.storemodel)
self.iconview.set_pixbuf_column(COL_ICON)
self.iconview.set_text_column(COL_NAME_TEXT)
self.iconview.set_item_width(102)
self.iconview_scrollwin.add(self.iconview)
self.iconview.set_property("has_tooltip", True)
self.effectType.connect("changed", self._effectTypeChangedCb)
self.effectCategory.connect("changed", self._effectCategoryChangedCb)
self.searchEntry.connect("changed", self.searchEntryChangedCb)
self.searchEntry.connect("button-press-event",
self.searchEntryActivateCb)
self.searchEntry.connect("focus-out-event",
self.searchEntryDesactvateCb)
self.searchEntry.connect("icon-press", self.searchEntryIconClickedCb)
self.treeview.connect("button-press-event", self._buttonPressEventCb)
self.treeview.connect("select-cursor-row", self._enterPressEventCb)
self.treeview.connect("motion-notify-event", self._motionNotifyEventCb)
self.treeview.connect("query-tooltip", self._queryTooltipCb)
self.treeview.connect("button-release-event", self._buttonReleaseCb)
self.treeview.drag_source_set(0, [], gtk.gdk.ACTION_COPY)
self.treeview.connect("drag_begin", self._dndDragBeginCb)
self.treeview.connect("drag_data_get", self._dndDataGetCb)
self.iconview.connect("button-press-event", self._buttonPressEventCb)
self.iconview.connect("activate-cursor-item", self._enterPressEventCb)
self.iconview.connect("query-tooltip", self._queryTooltipCb)
self.iconview.drag_source_set(0, [], gtk.gdk.ACTION_COPY)
self.iconview.connect("motion-notify-event", self._motionNotifyEventCb)
self.iconview.connect("button-release-event", self._buttonReleaseCb)
self.iconview.connect("drag_begin", self._dndDragBeginCb)
self.iconview.connect("drag_data_get", self._dndDataGetCb)
self.pack_start(hfilters, expand=False)
self.pack_start(hsearch, expand=False)
self.pack_end(self.treeview_scrollwin, expand=True)
self.pack_end(self.iconview_scrollwin, expand=True)
#create the filterModel
self.modelFilter = self.storemodel.filter_new()
self.modelFilter.set_visible_func(self._setRowVisible, data=None)
self.treeview.set_model(self.modelFilter)
self.iconview.set_model(self.modelFilter)
#Add factories
self._addFactories(self.app.effects.getAllVideoEffects(), VIDEO_EFFECT)
self._addFactories(self.app.effects.getAllAudioEffects(), AUDIO_EFFECT)
self._addMenuItems(uiman)
self.show_categories(VIDEO_EFFECT)
hfilters.show_all()
hsearch.show_all()
def __init__(self):
gtk.Window.__init__(self)
self.set_title("Dependency Explorer")
self.set_default_size(500, 500)
self.connect("delete-event", gtk.main_quit)
# Create the data models
self.pkg_model = gtk.ListStore(gobject.TYPE_STRING)
self.pkg_model.set_sort_column_id(COL_PKG_NAME, gtk.SORT_ASCENDING)
self.depends_model = gtk.ListStore(gobject.TYPE_INT,
gobject.TYPE_STRING,
gobject.TYPE_STRING)
self.depends_model.set_sort_column_id(COL_DEP_PACKAGE,
gtk.SORT_ASCENDING)
pane = gtk.HPaned()
pane.set_position(250)
self.add(pane)
# The master list of packages
scrolled = gtk.ScrolledWindow()
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled.set_shadow_type(gtk.SHADOW_IN)
self.pkg_treeview = gtk.TreeView(self.pkg_model)
self.pkg_treeview.get_selection().connect("changed",
self.on_cursor_changed)
column = gtk.TreeViewColumn("Package",
gtk.CellRendererText(),
text=COL_PKG_NAME)
self.pkg_treeview.append_column(column)
pane.add1(scrolled)
scrolled.add(self.pkg_treeview)
box = gtk.VBox(homogeneous=True, spacing=4)
# Runtime Depends
scrolled = gtk.ScrolledWindow()
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled.set_shadow_type(gtk.SHADOW_IN)
self.rdep_treeview = PackageDepView(self.depends_model, TYPE_RDEP,
"Runtime Depends")
self.rdep_treeview.connect("row-activated", self.on_package_activated,
COL_DEP_PACKAGE)
scrolled.add(self.rdep_treeview)
box.add(scrolled)
# Build Depends
scrolled = gtk.ScrolledWindow()
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled.set_shadow_type(gtk.SHADOW_IN)
self.dep_treeview = PackageDepView(self.depends_model, TYPE_DEP,
"Build Depends")
self.dep_treeview.connect("row-activated", self.on_package_activated,
COL_DEP_PACKAGE)
scrolled.add(self.dep_treeview)
box.add(scrolled)
pane.add2(box)
# Reverse Depends
scrolled = gtk.ScrolledWindow()
scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled.set_shadow_type(gtk.SHADOW_IN)
self.revdep_treeview = PackageReverseDepView(self.depends_model,
"Reverse Depends")
self.revdep_treeview.connect("row-activated",
self.on_package_activated, COL_DEP_PARENT)
scrolled.add(self.revdep_treeview)
box.add(scrolled)
pane.add2(box)
self.show_all()
def __init__(self, coherence, device):
self.coherence = coherence
self.device = device
self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.window.connect("delete_event", self.hide)
self.window.set_default_size(480, 200)
try:
title = 'InternetGatewayDevice %s' % device.get_friendly_name()
except:
title = 'InternetGatewayDevice'
self.window.set_title(title)
vbox = gtk.VBox(homogeneous=False, spacing=10)
hbox = gtk.HBox(homogeneous=False, spacing=10)
text = gtk.Label("<b>Link:</b>")
text.set_use_markup(True)
self.link_state_image = gtk.Image()
icon = resource_filename(__name__, os.path.join('icons', 'red.png'))
self.link_down_icon = gtk.gdk.pixbuf_new_from_file(icon)
icon = resource_filename(__name__, os.path.join('icons', 'green.png'))
self.link_up_icon = gtk.gdk.pixbuf_new_from_file(icon)
self.link_state_image.set_from_pixbuf(self.link_down_icon)
hbox.add(text)
hbox.add(self.link_state_image)
self.link_type = gtk.Label("<b>Type:</b> unknown (n/a)")
self.link_type.set_use_markup(True)
hbox.add(self.link_type)
vbox.pack_start(hbox, False, False, 2)
hbox = gtk.HBox(homogeneous=False, spacing=10)
label = gtk.Label("<b>Uptime:</b>")
label.set_use_markup(True)
hbox.add(label)
self.uptime = gtk.Label(" ")
self.uptime.set_use_markup(True)
hbox.add(self.uptime)
label = gtk.Label("<b>External IP:</b>")
label.set_use_markup(True)
hbox.add(label)
self.external_ip = gtk.Label(" ")
self.external_ip.set_use_markup(True)
hbox.add(self.external_ip)
label = gtk.Label("<b>IN-Bytes:</b>")
label.set_use_markup(True)
hbox.add(label)
self.bytes_in = gtk.Label(" ")
self.bytes_in.set_use_markup(True)
hbox.add(self.bytes_in)
label = gtk.Label("<b>OUT-Bytes:</b>")
label.set_use_markup(True)
hbox.add(label)
self.bytes_out = gtk.Label(" ")
self.bytes_out.set_use_markup(True)
hbox.add(self.bytes_out)
vbox.pack_start(hbox, False, False, 2)
hbox = gtk.HBox(homogeneous=False, spacing=10)
label = gtk.Label("<b>Port-Mappings:</b>")
label.set_use_markup(True)
hbox.add(label)
vbox.pack_start(hbox, False, False, 2)
self.nat_store = gtk.ListStore(str, str, str, str, str, str, str, str,
str)
self.nat_view = gtk.TreeView(self.nat_store)
self.nat_view.connect("button_press_event", self.button_action)
i = 0
for c in [
'index', 'enabled', 'protocol', 'remote host', 'external port',
'internal host', 'internal port', 'lease duration',
'description'
]:
column = gtk.TreeViewColumn(c)
self.nat_view.append_column(column)
text_cell = gtk.CellRendererText()
column.pack_start(text_cell, True)
column.add_attribute(text_cell, "text", i)
i += 1
vbox.pack_start(self.nat_view, expand=True, fill=True)
self.window.add(vbox)
self.window.show_all()
self.wan_device = None
self.wan_connection_device = None
try:
self.wan_device = self.device.get_embedded_device_by_type(
'WANDevice')[0]
print self.wan_device
service = self.wan_device.get_service_by_type(
'WANCommonInterfaceConfig')
service.subscribe_for_variable('PhysicalLinkStatus',
callback=self.state_variable_change)
self.get_traffic_loop = task.LoopingCall(self.get_traffic, service)
self.get_traffic_loop.start(10, now=True)
except IndexError:
pass
if self.wan_device != None:
try:
self.wan_connection_device = self.wan_device.get_embedded_device_by_type(
'WANConnectionDevice')[0]
service = self.wan_connection_device.get_service_by_type(
['WANIPConnection', 'WANPPPConnection'])
service.subscribe_for_variable(
'PortMappingNumberOfEntries',
callback=self.state_variable_change)
service.subscribe_for_variable(
'ExternalIPAddress', callback=self.state_variable_change)
self.get_state_loop = task.LoopingCall(self.get_state, service)
self.get_state_loop.start(10, now=True)
except IndexError:
pass
def __drives_page(self):
// 드라이브 추가를 위한 콜백함수
def add_drive_cb(button):
// title과 pathname 선언
title = _("Choose a folder")
pathname = GuiBasic.browse_folder(self.parent, title,
multiple=False, stock_button=gtk.STOCK_ADD)
if pathname:
liststore.append([pathname])
pathnames.append(pathname)
options.set_list('shred_drives', pathnames)
// 드라이버 제거를 위한 콜백 함수
def remove_drive_cb(button):
treeselection = treeview.get_selection()
(model, _iter) = treeselection.get_selected()
if None == _iter:
// 아무것도 선택되지 않으면
return
pathname = model[_iter][0]
liststore.remove(_iter)
pathnames.remove(pathname)
options.set_list('shred_drives', pathnames)
vbox = gtk.VBox()
notice = gtk.Label(
_("Choose a writable folder for each drive for which to overwrite free space."))
notice.set_line_wrap(True)
vbox.pack_start(notice, False)
liststore = gtk.ListStore(str)
pathnames = options.get_list('shred_drives')
if pathnames:
pathnames = sorted(pathnames)
if not pathnames:
pathnames = []
for pathname in pathnames:
liststore.append([pathname])
treeview = gtk.TreeView(model=liststore)
crt = gtk.CellRendererText()
tvc = gtk.TreeViewColumn(None, crt, text=0)
treeview.append_column(tvc)
vbox.pack_start(treeview)
// 추가버튼 추가
button_add = gtk.Button(_p('button', 'Add'))
button_add.connect("clicked", add_drive_cb)
//제거버튼 추가
button_remove = gtk.Button(_p('button', 'Remove'))
button_remove.connect("clicked", remove_drive_cb)
button_box = gtk.HButtonBox()
button_box.set_layout(gtk.BUTTONBOX_START)
button_box.pack_start(button_add)
button_box.pack_start(button_remove)
vbox.pack_start(button_box, False)
return vbox
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, options, db, initial_filter):
gtk.Dialog.__init__(self)
OpenDialogBase.__init__(self, options, db, initial_filter)
self.set_title("Quick open...")
self.set_size_request(1000,400)
self.add_button("_Open",gtk.RESPONSE_OK)
self.add_button("Cancel",gtk.RESPONSE_CANCEL)
model = gtk.ListStore(object)
treeview = gtk.TreeView(model)
treeview.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
treeview.get_selection().connect('changed', self._on_treeview_selection_changed)
self.connect('response', self.response)
text_cell_renderer = gtk.CellRendererText()
def add_column(title,accessor_cb):
column = gtk.TreeViewColumn(title, text_cell_renderer)
column.set_cell_data_func(text_cell_renderer, lambda column, cell, model, iter: cell.set_property('text', accessor_cb(model.get(iter,0)[0])))
treeview.append_column(column)
return column
add_column("Rank",lambda obj: obj[1])
add_column("File",lambda obj: os.path.basename(obj[0]))
add_column("Path",lambda obj: os.path.dirname(obj[0]))
self.connect('destroy', self.on_destroy)
truncated_bar = InfoBarGtk()
bad_result_button = gtk.Button("Bad result")
bad_result_button.connect('clicked', lambda *args: self.on_badresult_clicked())
reindex_button = gtk.Button("_Reindex")
reindex_button.connect('clicked', lambda *args: self.on_reindex_clicked())
status_label = gtk.Label()
self.status_label = status_label
filter_entry = gtk.Entry()
filter_entry.set_text(self._filter_text)
filter_entry.connect('key_press_event', self._on_filter_entry_keypress)
filter_entry.connect('changed', self._on_filter_text_changed)
# attach everything up
vbox = self.vbox
table_vbox = gtk.VBox()
treeview_scroll_window = gtk.ScrolledWindow()
treeview_scroll_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
table_options_hbox = gtk.HBox()
button_hbox = gtk.HBox()
vbox.pack_start(table_vbox,True,True,1)
table_vbox.pack_start(table_options_hbox,False,False,0)
table_options_hbox.pack_start(status_label,False,False,10)
table_options_hbox.pack_end(bad_result_button,False,False,0)
table_options_hbox.pack_end(reindex_button,False,False,0)
table_vbox.pack_start(treeview_scroll_window,True,True,0)
table_vbox.pack_start(truncated_bar,False,True,0)
table_vbox.pack_start(filter_entry,False,True,0)
treeview_scroll_window.add(treeview)
vbox.show_all()
truncated_bar.hide()
# remember things that need remembering
self._treeview = treeview
self._model = model
self._truncated_bar = truncated_bar
self._filter_entry = filter_entry
filter_entry.grab_focus()
if self.should_position_cursor_for_replace:
filter_entry.set_position(0)
filter_entry.select_region(0, len(self._filter_text))
else:
filter_entry.set_position(len(self._filter_text))
self.show_all()
def __locations_page(self, page_type):
"""Return a widget containing a list of files and folders"""
def add_whitelist_file_cb(button):
"""Callback for adding a file"""
title = _("Choose a file")
pathname = GuiBasic.browse_file(self.parent, title)
if pathname:
for this_pathname in pathnames:
if pathname == this_pathname[1]:
print "warning: '%s' already exists in whitelist" % pathname
return
liststore.append([_('File'), pathname])
pathnames.append(['file', pathname])
options.set_whitelist_paths(pathnames)
def add_whitelist_folder_cb(button):
"""Callback for adding a folder"""
title = _("Choose a folder")
pathname = GuiBasic.browse_folder(self.parent,
title,
multiple=False,
stock_button=gtk.STOCK_ADD)
if pathname:
for this_pathname in pathnames:
if pathname == this_pathname[1]:
print "warning: '%s' already exists in whitelist" % pathname
return
liststore.append([_('Folder'), pathname])
pathnames.append(['folder', pathname])
options.set_whitelist_paths(pathnames)
def remove_whitelist_path_cb(button):
"""Callback for removing a path"""
treeselection = treeview.get_selection()
(model, _iter) = treeselection.get_selected()
if None == _iter:
# nothing selected
return
pathname = model[_iter][1]
liststore.remove(_iter)
for this_pathname in pathnames:
if this_pathname[1] == pathname:
pathnames.remove(this_pathname)
options.set_whitelist_paths(pathnames)
def add_custom_file_cb(button):
"""Callback for adding a file"""
title = _("Choose a file")
pathname = GuiBasic.browse_file(self.parent, title)
if pathname:
for this_pathname in pathnames:
if pathname == this_pathname[1]:
print "warning: '%s' already exists in whitelist" % pathname
return
liststore.append([_('File'), pathname])
pathnames.append(['file', pathname])
options.set_custom_paths(pathnames)
def add_custom_folder_cb(button):
"""Callback for adding a folder"""
title = _("Choose a folder")
pathname = GuiBasic.browse_folder(self.parent,
title,
multiple=False,
stock_button=gtk.STOCK_ADD)
if pathname:
for this_pathname in pathnames:
if pathname == this_pathname[1]:
print "warning: '%s' already exists in whitelist" % pathname
return
liststore.append([_('Folder'), pathname])
pathnames.append(['folder', pathname])
options.set_custom_paths(pathnames)
def remove_custom_path_cb(button):
"""Callback for removing a path"""
treeselection = treeview.get_selection()
(model, _iter) = treeselection.get_selected()
if None == _iter:
# nothing selected
return
pathname = model[_iter][1]
liststore.remove(_iter)
for this_pathname in pathnames:
if this_pathname[1] == pathname:
pathnames.remove(this_pathname)
options.set_custom_paths(pathnames)
vbox = gtk.VBox()
# load data
if LOCATIONS_WHITELIST == page_type:
pathnames = options.get_whitelist_paths()
elif LOCATIONS_CUSTOM == page_type:
pathnames = options.get_custom_paths()
liststore = gtk.ListStore(str, str)
for paths in pathnames:
type_code = paths[0]
type_str = None
if type_code == 'file':
type_str = _('File')
elif type_code == 'folder':
type_str = _('Folder')
else:
raise RuntimeError("Invalid type code: '%s'" % type_code)
path = paths[1]
liststore.append([type_str, path])
if LOCATIONS_WHITELIST == page_type:
# TRANSLATORS: "Paths" is used generically to refer to both files
# and folders
notice = gtk.Label(
_("Theses paths will not be deleted or modified."))
elif LOCATIONS_CUSTOM == page_type:
notice = gtk.Label(
_("These locations can be selected for deletion."))
vbox.pack_start(notice, False)
# create treeview
treeview = gtk.TreeView(liststore)
# create column views
self.renderer0 = gtk.CellRendererText()
self.column0 = gtk.TreeViewColumn(_("Type"), self.renderer0, text=0)
treeview.append_column(self.column0)
self.renderer1 = gtk.CellRendererText()
# TRANSLATORS: In the tree view "Path" is used generically to refer to a
# file, a folder, or a pattern describing either
self.column1 = gtk.TreeViewColumn(_("Path"), self.renderer1, text=1)
treeview.append_column(self.column1)
treeview.set_search_column(1)
# finish tree view
swindow = gtk.ScrolledWindow()
swindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
swindow.set_size_request(300, 200)
swindow.add(treeview)
vbox.pack_start(swindow)
# buttons that modify the list
button_add_file = gtk.Button(_p('button', 'Add file'))
if LOCATIONS_WHITELIST == page_type:
button_add_file.connect("clicked", add_whitelist_file_cb)
elif LOCATIONS_CUSTOM == page_type:
button_add_file.connect("clicked", add_custom_file_cb)
button_add_folder = gtk.Button(_p('button', 'Add folder'))
if LOCATIONS_WHITELIST == page_type:
button_add_folder.connect("clicked", add_whitelist_folder_cb)
elif LOCATIONS_CUSTOM == page_type:
button_add_folder.connect("clicked", add_custom_folder_cb)
button_remove = gtk.Button(_p('button', 'Remove'))
if LOCATIONS_WHITELIST == page_type:
button_remove.connect("clicked", remove_whitelist_path_cb)
elif LOCATIONS_CUSTOM == page_type:
button_remove.connect("clicked", remove_custom_path_cb)
button_box = gtk.HButtonBox()
button_box.set_layout(gtk.BUTTONBOX_START)
button_box.pack_start(button_add_file)
button_box.pack_start(button_add_folder)
button_box.pack_start(button_remove)
vbox.pack_start(button_box, False)
# return page
return vbox
def __drives_page(self):
"""Return widget containing the drives page"""
def add_drive_cb(button):
"""Callback for adding a drive"""
title = _("Choose a folder")
pathname = GuiBasic.browse_folder(self.parent,
title,
multiple=False,
stock_button=gtk.STOCK_ADD)
if pathname:
liststore.append([pathname])
pathnames.append(pathname)
options.set_list('shred_drives', pathnames)
def remove_drive_cb(button):
"""Callback for removing a drive"""
treeselection = treeview.get_selection()
(model, _iter) = treeselection.get_selected()
if None == _iter:
# nothing selected
return
pathname = model[_iter][0]
liststore.remove(_iter)
pathnames.remove(pathname)
options.set_list('shred_drives', pathnames)
vbox = gtk.VBox()
# TRANSLATORS: 'free' means 'unallocated'
notice = gtk.Label(
_("Choose a writable folder for each drive for which to overwrite free space."
))
notice.set_line_wrap(True)
vbox.pack_start(notice, False)
liststore = gtk.ListStore(str)
pathnames = options.get_list('shred_drives')
if pathnames:
pathnames = sorted(pathnames)
if not pathnames:
pathnames = []
for pathname in pathnames:
liststore.append([pathname])
treeview = gtk.TreeView(model=liststore)
crt = gtk.CellRendererText()
tvc = gtk.TreeViewColumn(None, crt, text=0)
treeview.append_column(tvc)
vbox.pack_start(treeview)
# TRANSLATORS: In the preferences dialog, this button adds a path to
# the list of paths
button_add = gtk.Button(_p('button', 'Add'))
button_add.connect("clicked", add_drive_cb)
# TRANSLATORS: In the preferences dialog, this button removes a path
# from the list of paths
button_remove = gtk.Button(_p('button', 'Remove'))
button_remove.connect("clicked", remove_drive_cb)
button_box = gtk.HButtonBox()
button_box.set_layout(gtk.BUTTONBOX_START)
button_box.pack_start(button_add)
button_box.pack_start(button_remove)
vbox.pack_start(button_box, False)
return vbox
def addGrid(self, vbox, query, numTourneys, tourneyTypes, playerids,
sitenos, seats):
#print "start of addGrid query", query
#print "start of addGrid. numTourneys:",numTourneys,"tourneyTypes:", tourneyTypes, "playerids:",playerids
counter = 0
row = 0
sqlrow = 0
grid = numTourneys #TODO: should this be numTourneyTypes?
query = self.sql.query[query]
query = self.refineQuery(query, numTourneys, tourneyTypes, playerids,
sitenos, seats)
#print "DEBUG:\n%s" % query
self.cursor.execute(query)
result = self.cursor.fetchall()
#print "result of the big query in addGrid:",result
colnames = [desc[0] for desc in self.cursor.description]
# pre-fetch some constant values:
#self.cols_to_show = [x for x in self.columns if x[colshow]]
#htourneytypeid_idx = colnames.index('tourneyTypeId')
tabOps = self.filters.getTabOps()
self.cols_to_show = []
for i in self.columns:
if tabOps[i[0]] == 'ON':
i[1] = True
self.cols_to_show.append(i) #TODO do i need above 2 lines?
else:
i[1] = False
assert len(self.liststore) == grid, "len(self.liststore)=" + str(
len(self.liststore)) + " grid-1=" + str(grid)
self.liststore.append(gtk.ListStore(*([str] * len(self.cols_to_show))))
view = gtk.TreeView(model=self.liststore[grid])
view.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH)
#vbox.pack_start(view, expand=False, padding=3)
vbox.add(view)
textcell = gtk.CellRendererText()
textcell50 = gtk.CellRendererText()
textcell50.set_property('xalign', 0.5)
numcell = gtk.CellRendererText()
numcell.set_property('xalign', 1.0)
assert len(self.listcols) == grid
self.listcols.append([])
# Create header row eg column: ("game", True, "Game", 0.0, "%s")
for col, column in enumerate(self.cols_to_show):
if tabOps[column[colalias]] == 'ON':
if column[colalias] == 'game' and holecards:
s = [x for x in self.columns
if x[colalias] == 'hand'][0][colheading]
else:
s = column[colheading]
self.listcols[grid].append(gtk.TreeViewColumn(s))
view.append_column(self.listcols[grid][col])
if column[colformat] == '%s':
if column[colxalign] == 0.0:
self.listcols[grid][col].pack_start(textcell,
expand=True)
self.listcols[grid][col].add_attribute(
textcell, 'text', col)
cellrend = textcell
else:
self.listcols[grid][col].pack_start(textcell50,
expand=True)
self.listcols[grid][col].add_attribute(
textcell50, 'text', col)
cellrend = textcell50
self.listcols[grid][col].set_expand(True)
else:
self.listcols[grid][col].pack_start(numcell, expand=True)
self.listcols[grid][col].add_attribute(
numcell, 'text', col)
self.listcols[grid][col].set_expand(True)
cellrend = numcell
#self.listcols[grid][col].set_alignment(column[colxalign]) # no effect?
self.listcols[grid][col].set_clickable(True)
self.listcols[grid][col].connect("clicked", self.sortCols,
(col, grid))
if col == 0:
self.listcols[grid][col].set_sort_order(
gtk.SORT_DESCENDING)
self.listcols[grid][col].set_sort_indicator(True)
if column[coltype] == 'cash':
self.listcols[grid][col].set_cell_data_func(
numcell, self.ledger_style_render_func)
else:
self.listcols[grid][col].set_cell_data_func(
cellrend, self.reset_style_render_func)
rows = len(result) # +1 for title row
while sqlrow < rows:
treerow = []
for col, column in enumerate(self.cols_to_show):
if column[colalias] in colnames:
value = result[sqlrow][colnames.index(column[colalias])]
else:
value = 111
if column[colalias] == 'siteName':
if result[sqlrow][colnames.index('speed')] != 'Normal':
if (result[sqlrow][colnames.index('speed')] == 'Hyper'
and result[sqlrow][colnames.index('siteName')]
== 'Full Tilt Poker'):
value = value + ' ' + 'Super Turbo'
else:
value = value + ' ' + result[sqlrow][
colnames.index('speed')]
if value != None and value != -999:
treerow.append(column[colformat] % value)
else:
treerow.append(' ')
#print "addGrid, just before end of big for. grid:",grid,"treerow:",treerow
iter = self.liststore[grid].append(treerow)
sqlrow += 1
row += 1
vbox.show_all()
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 __locations_page(self, page_type):
// 파일 추가를 위한 콜백 함수
def add_whitelist_file_cb(button):
title = _("Choose a file")
pathname = GuiBasic.browse_file(self.parent, title)
if pathname:
for this_pathname in pathnames:
if pathname == this_pathname[1]:
logger.warning("'%s' already exists in whitelist", pathname)
return
liststore.append([_('File'), pathname])
pathnames.append(['file', pathname])
options.set_whitelist_paths(pathnames)
// 파일 추가를 위한 콜백 함수
def add_whitelist_folder_cb(button):
title = _("Choose a folder")
pathname = GuiBasic.browse_folder(self.parent, title,
multiple=False, stock_button=gtk.STOCK_ADD)
if pathname:
for this_pathname in pathnames:
if pathname == this_pathname[1]:
logger.warning("'%s' already exists in whitelist", pathname)
return
liststore.append([_('Folder'), pathname])
pathnames.append(['folder', pathname])
options.set_whitelist_paths(pathnames)
// 경로를 삭제하기 위한 콜백 함수
def remove_whitelist_path_cb(button):
"""Callback for removing a path"""
treeselection = treeview.get_selection()
(model, _iter) = treeselection.get_selected()
if None == _iter:
// 아무것도 선택되지 않았다면
return
pathname = model[_iter][1]
liststore.remove(_iter)
for this_pathname in pathnames:
if this_pathname[1] == pathname:
pathnames.remove(this_pathname)
options.set_whitelist_paths(pathnames)
// 파일 추가를 위한 콜백 함수
def add_custom_file_cb(button):
title = _("Choose a file")
pathname = GuiBasic.browse_file(self.parent, title)
if pathname:
for this_pathname in pathnames:
if pathname == this_pathname[1]:
logger.warning("'%s' already exists in whitelist", pathname)
return
liststore.append([_('File'), pathname])
pathnames.append(['file', pathname])
options.set_custom_paths(pathnames)
// 폴더 추가를 위한 콜백 함수
def add_custom_folder_cb(button):
title = _("Choose a folder")
pathname = GuiBasic.browse_folder(self.parent, title,
multiple=False, stock_button=gtk.STOCK_ADD)
if pathname:
for this_pathname in pathnames:
if pathname == this_pathname[1]:
logger.warning("'%s' already exists in whitelist", pathname)
return
liststore.append([_('Folder'), pathname])
pathnames.append(['folder', pathname])
options.set_custom_paths(pathnames)
// 경로 삭제를 위한 콜백 함수
def remove_custom_path_cb(button):
"""Callback for removing a path"""
treeselection = treeview.get_selection()
(model, _iter) = treeselection.get_selected()
if None == _iter:
// 아무것도 선택되지
return
pathname = model[_iter][1]
liststore.remove(_iter)
for this_pathname in pathnames:
if this_pathname[1] == pathname:
pathnames.remove(this_pathname)
options.set_custom_paths(pathnames)
vbox = gtk.VBox()
// 데이터 가져옴
if LOCATIONS_WHITELIST == page_type:
pathnames = options.get_whitelist_paths()
elif LOCATIONS_CUSTOM == page_type:
pathnames = options.get_custom_paths()
liststore = gtk.ListStore(str, str)
for paths in pathnames:
type_code = paths[0]
type_str = None
if type_code == 'file':
type_str = _('File')
elif type_code == 'folder':
type_str = _('Folder')
else:
raise RuntimeError("Invalid type code: '%s'" % type_code)
path = paths[1]
liststore.append([type_str, path])
if LOCATIONS_WHITELIST == page_type:
notice = gtk.Label(
_("Theses paths will not be deleted or modified."))
elif LOCATIONS_CUSTOM == page_type:
notice = gtk.Label(
_("These locations can be selected for deletion."))
vbox.pack_start(notice, False)
// 트리 뷰 생성
treeview = gtk.TreeView(liststore)
// 칼럼 뷰 생성
self.renderer0 = gtk.CellRendererText()
self.column0 = gtk.TreeViewColumn(_("Type"), self.renderer0, text=0)
treeview.append_column(self.column0)
self.renderer1 = gtk.CellRendererText()
self.column1 = gtk.TreeViewColumn(_("Path"), self.renderer1, text=1)
treeview.append_column(self.column1)
treeview.set_search_column(1)
// 트리 뷰 끝냄
swindow = gtk.ScrolledWindow()
swindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
swindow.set_size_request(300, 200)
swindow.add(treeview)
vbox.pack_start(swindow)
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 = []
class PreferencesDialog:
// 초기화 함수
// dialog창을 띄우기 위해 초기화함. self, parent, cb_refresh_operations를 매개변수로 사용
def __init__(self, parent, cb_refresh_operations):
self.cb_refresh_operations = cb_refresh_operations
self.parent = parent
self.dialog = gtk.Dialog(title=_("Preferences"),
parent=parent,
flags=gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT)
self.dialog.set_default_size(300, 200)
//notebook 변수 선언
notebook = gtk.Notebook()
notebook.append_page(self.__general_page(), gtk.Label(_("General")))
notebook.append_page(self.__locations_page(
LOCATIONS_CUSTOM), gtk.Label(_("Custom")))
notebook.append_page(self.__drives_page(), gtk.Label(_("Drives")))
// 만약 'posix'가 os.name 이면 Unix 파일 import하여 notebook에 append_page실행
if 'posix' == os.name:
notebook.append_page(
self.__languages_page(), gtk.Label(_("Languages")))
notebook.append_page(self.__locations_page(
LOCATIONS_WHITELIST), gtk.Label(_("Whitelist")))
//self.diaglof 실행
self.dialog.vbox.pack_start(notebook, True)
//self.dialog에 버튼 더함
self.dialog.add_button(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE)
// 콜백 함수를 사용하여 옵션 전환
def __toggle_callback(self, cell, path):
options.toggle(path)
// online_update_notification_enabled 이면
if online_update_notification_enabled:
self.cb_beta.set_sensitive(options.get('check_online_updates'))
// 'nt' == os.name이면 Windows파일 import하여 self.cb_winapp2.set_sensitive 실행
if 'nt' == os.name:
self.cb_winapp2.set_sensitive(
options.get('check_online_updates'))
// 만약 'auto_hide' == path이면 self.cb_refresh_operations() 수행
if 'auto_hide' == path:
self.cb_refresh_operations()
// 만약 'auto_start' == path이고
if 'auto_start' == path:
// 'nt' == os.name이면 Windows파일 import하여 swc = Windows.start_with_computer 선언
if 'nt' == os.name:
swc = Windows.start_with_computer
// 'posix' == os.name이면 Unix파일 import하여 swc = Unix.start_with_computer선언
if 'posix' == os.name:
swc = Unix.start_with_computer
try:
swc(options.get(path))
except:
traceback.print_exc()
dlg = gtk.MessageDialog(self.parent,
type=gtk.MESSAGE_ERROR,
buttons=gtk.BUTTONS_OK,
message_format=str(sys.exc_info()[1]))
dlg.run()
dlg.destroy()
// 일반 페이지가 포함된 위젯 반환
def __general_page(self):
//'nt' == os.name이면 Windows파일 import하여 swc = Windows.start_with_computer_check 선언
if 'nt' == os.name:
swcc = Windows.start_with_computer_check
// 'posix' == os.name이면 Unix파일 import하여 swc = Unix.start_with_computer_check 선언
if 'posix' == os.name:
swcc = Unix.start_with_computer_check
options.set('auto_start', swcc())
vbox = gtk.VBox()
// online_update_notification_enabled 이면
if online_update_notification_enabled:
cb_updates = gtk.CheckButton(
_("Check periodically for software updates via the Internet"))
cb_updates.set_active(options.get('check_online_updates'))
cb_updates.connect(
'toggled', self.__toggle_callback, 'check_online_updates')
cb_updates.set_tooltip_text(
_("If an update is found, you will be given the option to view information about it. Then, you may manually download and install the update."))
vbox.pack_start(cb_updates, False)
updates_box = gtk.VBox()
updates_box.set_border_width(10)
self.cb_beta = gtk.CheckButton(_("Check for new beta releases"))
self.cb_beta.set_active(options.get('check_beta'))
self.cb_beta.set_sensitive(options.get('check_online_updates'))
self.cb_beta.connect(
'toggled', self.__toggle_callback, 'check_beta')
updates_box.pack_start(self.cb_beta, False)
if 'nt' == os.name:
self.cb_winapp2 = gtk.CheckButton(
_("Download and update cleaners from community (winapp2.ini)"))
self.cb_winapp2.set_active(options.get('update_winapp2'))
self.cb_winapp2.set_sensitive(
options.get('check_online_updates'))
self.cb_winapp2.connect(
'toggled', self.__toggle_callback, 'update_winapp2')
updates_box.pack_start(self.cb_winapp2, False)
vbox.pack_start(updates_box, False)
// '무관한 클리너 숨김' 버튼 생성 및 연결
cb_auto_hide = gtk.CheckButton(_("Hide irrelevant cleaners"))
cb_auto_hide.set_active(options.get('auto_hide'))
cb_auto_hide.connect('toggled', self.__toggle_callback, 'auto_hide')
vbox.pack_start(cb_auto_hide, False)
// '파일 삭제 기능' 버튼 생성 및 연결
cb_shred = gtk.CheckButton(_("Overwrite contents of files to prevent recovery"))
cb_shred.set_active(options.get('shred'))
cb_shred.connect('toggled', self.__toggle_callback, 'shred')
cb_shred.set_tooltip_text(
_("Overwriting is ineffective on some file systems and with certain BleachBit operations. Overwriting is significantly slower."))
vbox.pack_start(cb_shred, False)
// '블리치비트 시작' 버튼 생성 및 연결
cb_start = gtk.CheckButton(_("Start BleachBit with computer"))
cb_start.set_active(options.get('auto_start'))
cb_start.connect('toggled', self.__toggle_callback, 'auto_start')
vbox.pack_start(cb_start, False)
// 클리너 완료 후 프로그램 종료 버튼 생성 및 연결
cb_exit = gtk.CheckButton(_("Exit after cleaning"))
cb_exit.set_active(options.get('exit_done'))
cb_exit.connect('toggled', self.__toggle_callback, 'exit_done')
vbox.pack_start(cb_exit, False)
// 삭제 전 확인 버튼 생성 및 연결
cb_popup = gtk.CheckButton(_("Confirm before delete"))
cb_popup.set_active(options.get('delete_confirmation'))
cb_popup.connect(
'toggled', self.__toggle_callback, 'delete_confirmation')
vbox.pack_start(cb_popup, False)
cb_units_iec = gtk.CheckButton(
_("Use IEC sizes (1 KiB = 1024 bytes) instead of SI (1 kB = 1000 bytes)"))
cb_units_iec.set_active(options.get("units_iec"))
cb_units_iec.connect('toggled', self.__toggle_callback, 'units_iec')
vbox.pack_start(cb_units_iec, False)
return vbox
// 드라이브 페이지가 포함된 위젯 반환 함수
def __drives_page(self):
// 드라이브 추가를 위한 콜백함수
def add_drive_cb(button):
// title과 pathname 선언
title = _("Choose a folder")
pathname = GuiBasic.browse_folder(self.parent, title,
multiple=False, stock_button=gtk.STOCK_ADD)
if pathname:
liststore.append([pathname])
pathnames.append(pathname)
options.set_list('shred_drives', pathnames)
// 드라이버 제거를 위한 콜백 함수
def remove_drive_cb(button):
treeselection = treeview.get_selection()
(model, _iter) = treeselection.get_selected()
if None == _iter:
// 아무것도 선택되지 않으면
return
pathname = model[_iter][0]
liststore.remove(_iter)
pathnames.remove(pathname)
options.set_list('shred_drives', pathnames)
vbox = gtk.VBox()
notice = gtk.Label(
_("Choose a writable folder for each drive for which to overwrite free space."))
notice.set_line_wrap(True)
vbox.pack_start(notice, False)
liststore = gtk.ListStore(str)
pathnames = options.get_list('shred_drives')
if pathnames:
pathnames = sorted(pathnames)
if not pathnames:
pathnames = []
for pathname in pathnames:
liststore.append([pathname])
treeview = gtk.TreeView(model=liststore)
crt = gtk.CellRendererText()
tvc = gtk.TreeViewColumn(None, crt, text=0)
treeview.append_column(tvc)
vbox.pack_start(treeview)
// 추가버튼 추가
button_add = gtk.Button(_p('button', 'Add'))
button_add.connect("clicked", add_drive_cb)
//제거버튼 추가
button_remove = gtk.Button(_p('button', 'Remove'))
button_remove.connect("clicked", remove_drive_cb)
button_box = gtk.HButtonBox()
button_box.set_layout(gtk.BUTTONBOX_START)
button_box.pack_start(button_add)
button_box.pack_start(button_remove)
vbox.pack_start(button_box, False)
return vbox
// 언어 페이지가 포함된 위젯 반환 함수
def __languages_page(self):
// 보존 row를 전환하기 위한 콜백 함수
def preserve_toggled_cb(cell, path, liststore):
__iter = liststore.get_iter_from_string(path)
value = not liststore.get_value(__iter, 0)
liststore.set(__iter, 0, value)
langid = liststore[path][1]
options.set_language(langid, value)
vbox = gtk.VBox()
notice = gtk.Label(
_("All languages will be deleted except those checked."))
vbox.pack_start(notice, False)
// 데이터 채움
liststore = gtk.ListStore('gboolean', str, str)
for lang, native in sorted(Unix.Locales.native_locale_names.items()):
liststore.append([(options.get_language(lang)), lang, native])
// 트리뷰 생성
treeview = gtk.TreeView(liststore)
//컬럼뷰 생성
self.renderer0 = gtk.CellRendererToggle()
self.renderer0.set_property('activatable', True)
self.renderer0.connect('toggled', preserve_toggled_cb, liststore)
self.column0 = gtk.TreeViewColumn(
_("Preserve"), self.renderer0, active=0)
treeview.append_column(self.column0)
self.renderer1 = gtk.CellRendererText()
self.column1 = gtk.TreeViewColumn(_("Code"), self.renderer1, text=1)
treeview.append_column(self.column1)
self.renderer2 = gtk.CellRendererText()
self.column2 = gtk.TreeViewColumn(_("Name"), self.renderer2, text=2)
treeview.append_column(self.column2)
treeview.set_search_column(2)
// 종료
swindow = gtk.ScrolledWindow()
swindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
swindow.set_size_request(300, 200)
swindow.add(treeview)
vbox.pack_start(swindow)
return vbox
def __init__(self, markup_text, button_texts, callback=None, callback_args=(), table_header=None, table_data=None,
toggled_callback=None, message_type=gtk.MESSAGE_INFO, parent=None, width=None, standalone=True):
super(RAFCONCheckBoxTableDialog, self).__init__(markup_text, button_texts,
callback=callback, callback_args=callback_args,
message_type=message_type, parent=parent,
width=width, standalone=False)
if table_header is None:
table_header = ["CheckBox", "Description"]
if table_data is None:
table_data = [[True, "That is true."]]
if toggled_callback is None:
# set default toggled callback
def on_toggled(cell, path, column_id):
self.list_store[path][column_id] = False if cell.get_active() else True
toggled_callback = on_toggled
# check if data is consistent
if not all(len(row) == len(table_header) or not isinstance(row[-1], (str, basestring, bool)) and
len(row) == 1 + len(table_header) for row in table_data):
raise ValueError("All rows of the table_data list has to be the same length as the table_header list "
"(+1 data element), here length = {0}". format(len(table_header)))
if not all([isinstance(row_elem, (bool, str, basestring))
for index, row_elem in enumerate(table_data[0]) if not index + 1 == len(table_data[0])]):
raise TypeError("All row elements have to be of type boolean or string except of last one.")
first_row_data_types = [type(row_elem) for row_elem in table_data[0]]
for row_index, row in enumerate(table_data):
for column_index, row_elem in enumerate(row):
if not isinstance(row_elem, first_row_data_types[column_index]):
raise TypeError("All rows have to have the same type at the same column index. Here you have at "
"column index {0} and row_index {1} type: {2} and in row 0 at this index type: {3}"
"".format(column_index, row_index, type(row_elem), type(first_row_data_types[column_index])))
# create tree view
self.tree_view = gtk.TreeView()
self.vbox.pack_start(self.tree_view)
for index, column_type in enumerate(first_row_data_types):
if column_type is bool:
# create checkbox column
check_box_renderer = gtk.CellRendererToggle()
if toggled_callback is not None:
check_box_renderer.connect("toggled", toggled_callback, index)
checkbox_column = gtk.TreeViewColumn(table_header[index], check_box_renderer, active=index)
self.tree_view.append_column(checkbox_column)
elif column_type in (str, basestring):
text_renderer = gtk.CellRendererText()
text_column = gtk.TreeViewColumn(table_header[index], text_renderer, text=index)
self.tree_view.append_column(text_column)
else:
if not len(first_row_data_types) == index + 1:
logger.error("Unexpected case, the widget is not generate column of type: {0} and "
"the column is not the last in the list.".format(column_type))
# correct last list element if not boolean or string and table data length is +1 compared to table header
if first_row_data_types and len(first_row_data_types) == len(table_header) + 1 and \
not isinstance(first_row_data_types[-1], (bool, str, basestring)):
first_row_data_types[-1] = gobject.TYPE_PYOBJECT
# fill list store
self.list_store = gtk.ListStore(*first_row_data_types)
self.tree_view.set_model(self.list_store)
for row in table_data:
self.list_store.append(row)
self.show_grab_focus_and_run(standalone)
def __create_widgets(self):
"""
"""
self.__cell = gtk.CellRendererText()
# texteditor widgets
self.__texteditor = bw.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 = bw.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 = bw.BWLabel(_("Ports (%s)") % number_of_ports)
self.__ports_scroll = bw.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 = SERVICE_COLORS[port['state']['state']]
if port['service'].has_key('name'):
service_name = port['service']['name']
else:
service_name = _("<unknown>")
if port['service'].has_key('method'):
service_method = port['service']['method']
else:
service_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', 'extrainfo']:
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 = bw.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 = SERVICE_COLORS[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 = bw.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, bw.BWLabel(_("Special fields")))
if len(self.__text) > 0:
self.__select_combobox.set_active(0)
def __init__(self, core):
super(SectionsDialog,self).__init__('Extended sections information', None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, (gtk.STOCK_OK,gtk.RESPONSE_ACCEPT))
self.uicore = core
self.sec_bars = ''
#self.vbox = gtk.VBox(False, 0)
# the cancel button
self.butt_cancel = self.action_area.get_children()[0]
self.butt_cancel.connect("clicked", lambda x: self.destroy())
# Positions
self.resize(700, 400)
self.set_position(gtk.WIN_POS_CENTER)
self.set_icon_from_file(os.path.dirname(__file__)+os.sep+'data'+os.sep+'bokken.svg')
# Label...
self.hbox = gtk.HBox(False, 1)
self.label = gtk.Label('')
self.label.set_markup('<big>List of binary sections with their data and size</big>')
self.label.set_alignment(0.02, 0.5)
self.icon = gtk.Image()
self.icon.set_from_stock(gtk.STOCK_INFO, gtk.ICON_SIZE_MENU)
self.hbox.pack_start(self.icon, False, False, 2)
self.hbox.pack_start(self.label, True, True, 0)
# ScrolledWindow
self.scrolled_window = gtk.ScrolledWindow()
self.scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.scrolled_window.is_visible = True
# List view
self.store = gtk.ListStore(str, str, str, str, str, int)
self.tv = gtk.TreeView(self.store)
self.tv.set_rules_hint(True)
# Columns
rendererText = gtk.CellRendererText()
column = gtk.TreeViewColumn("Start offset", rendererText, text=0)
self.store.set_sort_column_id(0, gtk.SORT_ASCENDING)
column.set_sort_column_id(0)
self.tv.append_column(column)
# Color Bar
rendererBar = ColoredBarRenderer()
column = gtk.TreeViewColumn("Section size", rendererBar, text=1, start=0, end=2, size=5)
column.set_min_width(300)
column.set_sort_column_id(1)
self.tv.append_column(column)
rendererText = gtk.CellRendererText()
column = gtk.TreeViewColumn("End offset", rendererText, text=2)
column.set_sort_column_id(2)
self.tv.append_column(column)
rendererText = gtk.CellRendererText()
column = gtk.TreeViewColumn("Flags", rendererText, text=3)
column.set_sort_column_id(3)
self.tv.append_column(column)
self.tv.set_model(self.store)
rendererText = gtk.CellRendererText()
column = gtk.TreeViewColumn("Name", rendererText, text=4)
column.set_sort_column_id(4)
self.tv.append_column(column)
self.tv.set_model(self.store)
self.vbox.set_spacing(3)
self.set_border_width(3)
# Packing
self.scrolled_window.add(self.tv)
self.vbox.pack_start(self.hbox, False, False)
self.vbox.pack_start(self.scrolled_window, True, True)
self._get_section_bars()
self.show_all()
def __create_widgets(self):
"""
"""
self.__vbox = bw.BWVBox()
self.__vbox.set_border_width(6)
self.__cell = gtk.CellRendererText()
self.__general_frame = bw.BWExpander(_("General information"))
self.__sequences_frame = bw.BWExpander(_("Sequences"))
self.__os_frame = bw.BWExpander(_("Operating System"))
self.__sequences_frame.bw_add(gtk.Label(_("No sequence information.")))
self.__os_frame.bw_add(gtk.Label(_("No OS information.")))
# general information widgets
self.__general = bw.BWTable(3, 2)
self.__address_label = bw.BWSectionLabel(_("Address:"))
self.__address_list = gtk.combo_box_entry_new_text()
self.__address_list.child.set_editable(False)
for address in self.__node.get_info('addresses'):
params = address['type'], address['addr']
address_text = SYSTEM_ADDRESS_TEXT % params
if address['vendor'] != None:
address_text += " (%s)" % address['vendor']
self.__address_list.append_text(address_text)
self.__address_list.set_active(0)
self.__general.bw_attach_next(self.__address_label,
yoptions=gtk.FILL,
xoptions=gtk.FILL)
self.__general.bw_attach_next(self.__address_list, yoptions=gtk.FILL)
if self.__node.get_info('hostnames') != None:
self.__hostname_label = bw.BWSectionLabel(_("Hostname:"))
self.__hostname_list = gtk.combo_box_entry_new_text()
self.__hostname_list.child.set_editable(False)
for hostname in self.__node.get_info('hostnames'):
params = hostname['type'], hostname['name']
self.__hostname_list.append_text(SYSTEM_ADDRESS_TEXT % params)
self.__hostname_list.set_active(0)
self.__general.bw_attach_next(self.__hostname_label,
yoptions=gtk.FILL,
xoptions=gtk.FILL)
self.__general.bw_attach_next(self.__hostname_list,
yoptions=gtk.FILL)
if self.__node.get_info('uptime') != None:
self.__uptime_label = bw.BWSectionLabel(_("Last boot:"))
seconds = self.__node.get_info('uptime')['seconds']
lastboot = self.__node.get_info('uptime')['lastboot']
text = _("%s (%s seconds).") % (lastboot, seconds)
self.__uptime_value = bw.BWLabel(text)
self.__uptime_value.set_selectable(True)
self.__uptime_value.set_line_wrap(False)
self.__general.bw_attach_next(self.__uptime_label,
yoptions=gtk.FILL,
xoptions=gtk.FILL)
self.__general.bw_attach_next(self.__uptime_value,
yoptions=gtk.FILL)
self.__general_frame.bw_add(self.__general)
self.__general_frame.set_expanded(True)
# sequences information widgets
self.__sequences = bw.BWTable(5, 3)
sequences = self.__node.get_info('sequences')
if len(sequences) > 0:
self.__sequences.attach(bw.BWSectionLabel(_("Class")), 1, 2, 0, 1)
self.__sequences.attach(bw.BWSectionLabel(_("Values")), 2, 3, 0, 1)
self.__sequences.attach(bw.BWSectionLabel(_("TCP *")), 0, 1, 1, 2)
self.__sequences.attach(bw.BWSectionLabel(_("IP ID")), 0, 1, 2, 3)
self.__sequences.attach(bw.BWSectionLabel(_("TCP Timestamp")), 0,
1, 3, 4)
# tcp sequence values
tcp = sequences['tcp']
tcp_class = bw.BWLabel(tcp['class'])
tcp_class.set_selectable(True)
self.__sequences.attach(tcp_class, 1, 2, 1, 2)
tcp_values = gtk.combo_box_entry_new_text()
for value in tcp['values']:
tcp_values.append_text(value)
tcp_values.set_active(0)
self.__sequences.attach(tcp_values, 2, 3, 1, 2)
tcp_note = bw.BWLabel()
tcp_note.set_selectable(True)
tcp_note.set_line_wrap(False)
tcp_note.set_alignment(1.0, 0.5)
tcp_note.set_markup(TCP_SEQ_NOTE %
(tcp['index'], tcp['difficulty']))
self.__sequences.attach(tcp_note, 0, 3, 4, 5)
# ip id sequence values
ip_id = sequences['ip_id']
ip_id_class = bw.BWLabel(ip_id['class'])
ip_id_class.set_selectable(True)
self.__sequences.attach(ip_id_class, 1, 2, 2, 3)
ip_id_values = gtk.combo_box_entry_new_text()
for value in ip_id['values']:
ip_id_values.append_text(value)
ip_id_values.set_active(0)
self.__sequences.attach(ip_id_values, 2, 3, 2, 3)
# tcp sequence values
tcp_ts = sequences['tcp_ts']
tcp_ts_class = bw.BWLabel(tcp_ts['class'])
tcp_ts_class.set_selectable(True)
self.__sequences.attach(tcp_ts_class, 1, 2, 3, 4)
if tcp_ts['values'] != None:
tcp_ts_values = gtk.combo_box_entry_new_text()
for value in tcp_ts['values']:
tcp_ts_values.append_text(value)
tcp_ts_values.set_active(0)
self.__sequences.attach(tcp_ts_values, 2, 3, 3, 4)
self.__sequences_frame.bw_add(self.__sequences)
# operating system information widgets
self.__os = gtk.Notebook()
self.__os.set_tab_pos(gtk.POS_LEFT)
os = self.__node.get_info('os')
if os != None:
if os.has_key('matches'):
self.__match_scroll = bw.BWScrolledWindow()
self.__match_store = gtk.ListStore(gobject.TYPE_INT,
gobject.TYPE_STRING,
gobject.TYPE_INT,
gobject.TYPE_BOOLEAN)
self.__match_treeview = gtk.TreeView(self.__match_store)
for os_match in os['matches']:
self.__match_store.append([
os_match['accuracy'], os_match['name'],
os_match['db_line'], True
])
self.__match_column = list()
for i in range(len(OSMATCH_HEADER)):
column = gtk.TreeViewColumn(OSMATCH_HEADER[i],
self.__cell,
text=i)
self.__match_column.append(column)
self.__match_column[i].set_reorderable(True)
self.__match_column[i].set_resizable(True)
self.__match_column[i].set_attributes(self.__cell,
text=i,
editable=3)
self.__match_column[i].set_sort_column_id(i)
self.__match_treeview.append_column(self.__match_column[i])
self.__match_scroll.add_with_viewport(self.__match_treeview)
self.__os.append_page(self.__match_scroll,
bw.BWLabel(_("Match")))
if os.has_key('classes'):
self.__class_scroll = bw.BWScrolledWindow()
self.__class_store = gtk.ListStore(gobject.TYPE_INT,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_STRING,
gobject.TYPE_BOOLEAN)
self.__class_treeview = gtk.TreeView(self.__class_store)
for os_class in os['classes']:
os_gen = ''
if os_class.has_key('os_gen'):
os_gen = os_class['os_gen']
self.__class_store.append([
os_class['accuracy'], os_class['vendor'],
os_class['type'], os_class['os_family'], os_gen, True
])
self.__class_column = list()
for i in range(len(OSCLASS_HEADER)):
column = gtk.TreeViewColumn(OSCLASS_HEADER[i],
self.__cell,
text=i)
self.__class_column.append(column)
self.__class_column[i].set_reorderable(True)
self.__class_column[i].set_resizable(True)
self.__class_column[i].set_attributes(self.__cell,
text=i,
editable=5)
self.__class_column[i].set_sort_column_id(i)
self.__class_treeview.append_column(self.__class_column[i])
self.__class_scroll.add_with_viewport(self.__class_treeview)
self.__os.append_page(self.__class_scroll,
bw.BWLabel(_("Class")))
self.__fp_viewer = bw.BWTextEditor()
self.__fp_viewer.bw_modify_font(self.__font)
self.__fp_viewer.bw_set_editable(False)
self.__fp_viewer.bw_set_text(os['fingerprint'])
self.__fp_ports = bw.BWHBox()
self.__fp_label = bw.BWSectionLabel(_("Used ports:"))
self.__fp_ports_list = gtk.combo_box_entry_new_text()
self.__fp_ports_list.child.set_editable(False)
self.__fp_vbox = bw.BWVBox()
if os.has_key('used_ports'):
used_ports = os['used_ports']
for port in used_ports:
params = port['id'], port['protocol'], port['state']
self.__fp_ports_list.append_text(USED_PORTS_TEXT % params)
self.__fp_ports_list.set_active(0)
self.__fp_ports.bw_pack_start_noexpand_nofill(self.__fp_label)
self.__fp_ports.bw_pack_start_expand_fill(self.__fp_ports_list)
self.__fp_vbox.bw_pack_start_noexpand_nofill(self.__fp_ports)
self.__os.append_page(self.__fp_viewer,
bw.BWLabel(_("Fingerprint")))
self.__fp_vbox.bw_pack_start_expand_fill(self.__os)
self.__os_frame.bw_add(self.__fp_vbox)
self.__os_frame.set_expanded(True)
self.__vbox.bw_pack_start_noexpand_nofill(self.__general_frame)
self.__vbox.bw_pack_start_expand_fill(self.__os_frame)
self.__vbox.bw_pack_start_noexpand_nofill(self.__sequences_frame)
self.add_with_viewport(self.__vbox)
def create_channel_window(self, closeable):
# Creates GUI for channel
last_index = len(self.lobby_channel_names) - 1
gtk.threads_enter()
# Label
label_box = gtk.EventBox()
if closeable == True:
label = gtk.Label('#' + self.lobby_channel_names[last_index])
else:
label = gtk.Label(self.lobby_channel_names[last_index])
label.show()
label_box.show()
label_box.add(label)
# Vertical Pane
vpane = gtk.HPaned()
vpane.show()
# Frame
frame = gtk.Frame(None)
frame.set_border_width(0)
frame.set_size_request(100, 75)
frame.show()
vpane.pack1(frame, True, True)
if closeable == True:
frame2 = gtk.Frame(None)
frame2.set_border_width(0)
frame2.show()
vpane.pack2(frame2, True, True)
# Player Window (scrolled)
player_window = gtk.ScrolledWindow()
player_window.set_border_width(0)
player_window.set_policy(gtk.POLICY_AUTOMATIC,
gtk.POLICY_AUTOMATIC)
player_window.show()
# Player ListStore
# 0 Username
# 1 Country
# 2 Cpu
# 3 IP
# 4 Status -> InGame / Away
# 5 Rank
# 6 Admin
player_liststore = gtk.ListStore(str, gtk.gdk.Pixbuf, str, str,
gtk.gdk.Pixbuf, gtk.gdk.Pixbuf,
gtk.gdk.Pixbuf)
self.lobby_channel_users.append(player_liststore)
player_treeview = gtk.TreeView(player_liststore)
player_column_0 = gtk.TreeViewColumn('') # Away
player_column_1 = gtk.TreeViewColumn('') # Country
player_column_2 = gtk.TreeViewColumn('') # Name Rank Mod
player_treeview.append_column(player_column_0)
player_treeview.append_column(player_column_1)
player_treeview.append_column(player_column_2)
player_treeview.set_headers_visible(False)
player_treeview.show()
player_window.add(player_treeview)
frame2.add(player_window)
# Add Mouse Click event to player_treeview
player_treeview.add_events(gtk.gdk.BUTTON_PRESS_MASK)
player_treeview.connect('event', self.player_popup_menu)
# Create a CellRenderers to render the data
cell0 = gtk.CellRendererPixbuf()
cell1 = gtk.CellRendererPixbuf()
cell2 = gtk.CellRendererText()
cell3 = gtk.CellRendererPixbuf()
cell4 = gtk.CellRendererPixbuf()
self.lobby_channel_users_columns.append(
[player_column_0, player_column_1, player_column_2])
self.lobby_channel_users_cells.append(
[cell0, cell1, cell2, cell3, cell4])
# Add the cells to the columns
player_column_0.pack_start(cell0, False)
player_column_1.pack_start(cell1, False)
player_column_2.pack_start(cell2, False)
player_column_2.pack_start(cell3, False)
player_column_2.pack_start(cell4, False)
# Set the cell attributes to the appropriate liststore column
player_column_2.set_attributes(cell2, text=0)
# Allow sorting on the column
player_column_2.set_sort_column_id(0)
tag_table = self.lobby_channel_buffers[last_index].get_tag_table()
join_tag = gtk.TextTag("join")
join_tag.set_property("foreground", "blue")
tag_table.add(join_tag)
left_tag = gtk.TextTag("left")
left_tag.set_property("foreground", "grey")
tag_table.add(left_tag)
topic_tag = gtk.TextTag("topic")
topic_tag.set_property("foreground", "purple")
tag_table.add(topic_tag)
else:
self.lobby_channel_users.append(None)
self.lobby_channel_users_cells.append(None)
self.lobby_channel_users_columns.append(None)
# Table
table = gtk.Table(rows=1, columns=4, homogeneous=False)
frame.add(table)
table.show()
# Scrolled Window
scrolled_window = gtk.ScrolledWindow(hadjustment=None,
vadjustment=None)
scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scrolled_window.add(self.lobby_channel_textview[last_index])
scrolled_window.show()
table.attach(scrolled_window, 0, 2, 0, 1)
# Entrys
entry = gtk.Entry(max=0)
entry.show()
entry.connect("activate", self.parse_output,
self.lobby_channel_names[last_index])
table.attach(entry, 0, 2, 1, 2, gtk.FILL, gtk.FILL, 0, 0)
# Notebook Page
tab_index = self.lobby_notebook.append_page(vpane, label_box)
if closeable == True:
label_box.connect('event', self.on_chat_tab_click, frame,
self.lobby_channel_names[last_index], tab_index)
gtk.threads_leave()
def __create_widgets(self):
"""
"""
if self.__node.get_info('trace') == None:
self.__trace_label = gtk.Label(NO_TRACE_TEXT)
self.pack_start(self.__trace_label, True, True)
else:
# add hops
hops = self.__node.get_info('trace')['hops']
ttls = [int(i['ttl']) for i in hops]
self.__cell = gtk.CellRendererText()
self.__trace_scroll = bw.BWScrolledWindow()
self.__trace_scroll.set_border_width(0)
self.__trace_store = gtk.ListStore(
gobject.TYPE_INT, gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_STRING, gobject.TYPE_STRING, gobject.TYPE_BOOLEAN)
self.__trace_treeview = gtk.TreeView(self.__trace_store)
count = 0
for i in range(1, max(ttls) + 1):
if i in ttls:
hop = hops[count]
count += 1
self.__trace_store.append([
hop['ttl'], hop['rtt'], hop['ip'], hop['hostname'],
HOP_COLOR['known'], True
])
else:
self.__trace_store.append([
i, '',
_("<unknown>"), '', HOP_COLOR['unknown'], True
])
self.__trace_column = list()
for i in range(len(TRACE_HEADER)):
column = gtk.TreeViewColumn(TRACE_HEADER[i],
self.__cell,
text=i)
self.__trace_column.append(column)
self.__trace_column[i].set_reorderable(True)
self.__trace_column[i].set_resizable(True)
self.__trace_column[i].set_attributes(self.__cell,
text=i,
background=4,
editable=5)
self.__trace_treeview.append_column(self.__trace_column[i])
self.__trace_column[0].set_sort_column_id(0)
self.__trace_scroll.add_with_viewport(self.__trace_treeview)
self.__trace_info = (self.__node.get_info('trace')['port'],
len(self.__node.get_info('trace')['hops']))
self.__trace_label = bw.BWLabel(TRACE_TEXT % self.__trace_info)
self.__trace_label.set_use_markup(True)
self.bw_pack_start_expand_fill(self.__trace_scroll)
self.bw_pack_start_noexpand_nofill(self.__trace_label)
def make_frames_view(self, layers):
import gobject
texture_format = self.cb_tf.get_active()
self.liststore = gtk.ListStore(gobject.TYPE_PYOBJECT,
gtk.gdk.Pixbuf, str,
gobject.TYPE_BOOLEAN,
gobject.TYPE_INT, gobject.TYPE_INT,
gobject.TYPE_PYOBJECT)
for l in layers:
frames = [gl for gl in reversed(l.layers)
] if pdb.gimp_item_is_group(l) else [l]
for f in frames:
thumbnail_data = make_thumbnail_data(f)
pixbuf = get_thumbnail(thumbnail_data, texture_format)
size_info = '<b>Size</b>: %d x %d' % (f.width, f.height)
parasite_origins = f.parasite_find('spr_origins')
if parasite_origins:
origin_x, origin_y = unpack('<2i',
parasite_origins.data[:8])
else:
origin_x, origin_y = -f.width // 2, f.height // 2
self.liststore.append([
f, pixbuf, size_info, True, origin_x, origin_y,
thumbnail_data
])
self.export_frames_num = len(self.liststore)
self.iconview = gtk.TreeView(self.liststore)
self.iconview.set_reorderable(True)
self.iconview.set_enable_search(False)
self.iconview.set_grid_lines(gtk.TREE_VIEW_GRID_LINES_BOTH)
# Column 'Export'
def on_cb_export_toggled(widget, path):
export = not self.liststore[path][LS_EXPORT]
self.liststore[path][LS_EXPORT] = export
self.export_frames_num += 1 if export else -1
self.set_btn_export_sensitive(self.export_frames_num > 0)
self.img_view_frame.set_label('Frames to export: %d' %
self.export_frames_num)
cb_export = gtk.CellRendererToggle()
cb_export.connect('toggled', on_cb_export_toggled)
col_export = gtk.TreeViewColumn('Export',
cb_export,
active=LS_EXPORT)
col_export_header = gtk.Label('Export')
col_export_header.show()
tt_export = gtk.Tooltips()
tt_export.set_tip(col_export_header, 'Export frame to file.')
col_export.set_sort_order(gtk.SORT_DESCENDING)
col_export.set_sort_column_id(4)
col_export.set_widget(col_export_header)
self.iconview.append_column(col_export)
# Column 'Frame'
pixrend = gtk.CellRendererPixbuf()
col_pixbuf = gtk.TreeViewColumn('Frame', pixrend, pixbuf=LS_PIXBUF)
col_pixbuf.set_min_width(THUMB_MAXSIZE)
self.iconview.append_column(col_pixbuf)
# Column 'Settings'
col_info = gtk.TreeViewColumn()
col_info_header = gtk.Label('Settings')
col_info_header.show()
col_info.set_widget(col_info_header)
tt_info = gtk.Tooltips()
tt_info.set_tip(col_info_header, 'Frame export options.')
# Info text
renderer = gtk.CellRendererText()
renderer.set_property('yalign', 0.3)
renderer.set_property('xalign', 0.0)
renderer.set_property('width', 0)
renderer.set_property('height', THUMB_MAXSIZE)
col_info.pack_start(renderer, False)
col_info.set_attributes(renderer, markup=LS_SIZE_INFO)
# Label origin X
adjustment = gtk.Adjustment(lower=MIN_FRAME_ORIGIN,
upper=MAX_FRAME_ORIGIN,
step_incr=1)
renderer = gtk.CellRendererText()
renderer.set_property('markup', '<b>Origin X</b>:')
renderer.set_property('width', 64)
col_info.pack_start(renderer, False)
# crs origin x
adjustment = gtk.Adjustment(lower=MIN_FRAME_ORIGIN,
upper=MAX_FRAME_ORIGIN,
step_incr=1)
renderer = gtk.CellRendererSpin()
renderer.set_property('editable', True)
renderer.set_property('adjustment', adjustment)
def on_crs_origin_x_changed(widget, path, val):
val = min(max(int(val), MIN_FRAME_ORIGIN), MAX_FRAME_ORIGIN)
self.liststore[path][LS_ORIGIN_X] = val
renderer.connect('edited', on_crs_origin_x_changed)
col_info.pack_start(renderer)
col_info.set_attributes(renderer, markup=LS_ORIGIN_X)
# Label origin y
renderer = gtk.CellRendererText()
renderer.set_property('markup', '<b>Origin Y</b>:')
renderer.set_property('width', 64)
col_info.pack_start(renderer, False)
# crs origin y
renderer = gtk.CellRendererSpin()
renderer.set_property('editable', True)
renderer.set_property('adjustment', adjustment)
def on_crs_origin_x_changed(widget, path, val):
val = min(max(int(val), MIN_FRAME_ORIGIN), MAX_FRAME_ORIGIN)
self.liststore[path][LS_ORIGIN_Y] = val
renderer.connect('edited', on_crs_origin_x_changed)
col_info.pack_start(renderer)
col_info.set_attributes(renderer, markup=LS_ORIGIN_Y)
self.iconview.append_column(col_info)
scrl_win = gtk.ScrolledWindow()
scrl_win.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
scrl_win.add(self.iconview)
scrl_win.set_size_request(THUMB_MAXSIZE, THUMB_MAXSIZE * 4)
frame_imgs = gimpui.Frame('Frames to export: %d' %
self.export_frames_num)
frame_imgs.set_property('label-xalign', 0.05)
frame_imgs.set_shadow_type(gtk.SHADOW_IN)
frame_imgs.add(scrl_win)
frame_imgs.set_size_request(535, -1)
return frame_imgs
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 __init__(self, driver, app):
""" Constructor. """
gtk.VBox.__init__(self)
scrolledWindow = gtk.ScrolledWindow()
scrolledWindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.app = app
self.driver = driver
self.nameEditable = app.device.config.writable and not driver
self.valueEditable = app.device.config.writable
# copy options (dict function does not exist in Python 2.1 :( )
opts = {}
for name, val in app.options.items():
opts[name] = val
# remove all options known to the driver
self.driverOpts = {}
if driver:
for sect in driver.optSections:
for opt in sect.optList:
self.driverOpts[opt.name] = opt
if opts.has_key(opt.name):
del opts[opt.name]
# short cut
self.opts = []
if driver and len(opts) == 0:
return
# list all remaining options here
self.store = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING,
gobject.TYPE_BOOLEAN, gobject.TYPE_BOOLEAN)
self.view = gtk.TreeView(self.store)
self.view.set_rules_hint(True)
optionRenderer = gtk.CellRendererText()
optionRenderer.connect("edited", self.editedSignal, 0)
column = gtk.TreeViewColumn(_("Option"),
optionRenderer,
text=0,
editable=2)
self.view.append_column(column)
valueRenderer = gtk.CellRendererText()
valueRenderer.connect("edited", self.editedSignal, 1)
column = gtk.TreeViewColumn(_("Value"),
valueRenderer,
text=1,
editable=3)
self.view.append_column(column)
self.view.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
for name, val in opts.items():
self.store.set(self.store.append(), 0, str(name), 1, str(val), 2,
self.nameEditable, 3, self.valueEditable)
self.opts.append(name)
self.view.show()
scrolledWindow.add(self.view)
scrolledWindow.show()
self.pack_start(scrolledWindow, True, True, 0)
buttonBox = gtk.HButtonBox()
buttonBox.set_layout(gtk.BUTTONBOX_END)
if not self.driver:
newButton = gtk.Button(stock="gtk-add")
newButton.connect("clicked", self.newSetting)
newButton.set_sensitive(app.device.config.writable)
newButton.show()
buttonBox.add(newButton)
deleteButton = gtk.Button(stock="gtk-remove")
deleteButton.connect("clicked", self.deleteSelection)
deleteButton.set_sensitive(app.device.config.writable)
deleteButton.show()
buttonBox.add(deleteButton)
helpButton = gtk.Button(stock="gtk-help")
helpButton.connect("clicked", self.help)
helpButton.show()
buttonBox.add(helpButton)
buttonBox.set_child_secondary(helpButton, True)
buttonBox.show()
self.pack_start(buttonBox, False, False, 0)
def __init__(self):
self.profile = Profile(PROFILE_NAME)
self.recentSaved = True
# Create Window
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.set_border_width(1)
window.set_default_size(770, 500)
window.set_title("Expense Manager")
window.set_position(gtk.WIN_POS_CENTER)
# Fixed Container
fixed = gtk.Fixed()
window.add(fixed)
# To hold menu->File items
fileMenu = gtk.Menu()
# Menu - File->New Profile
fileMenu_newProfile = gtk.MenuItem("New Profile")
fileMenu.append(fileMenu_newProfile)
fileMenu_newProfile.connect("activate", self.new_profile)
fileMenu_newProfile.show()
#Menu - File->Load Profile
fileMenu_openProfile = gtk.MenuItem("Load Profile")
fileMenu.append(fileMenu_openProfile)
fileMenu_openProfile.connect("activate", self.load_profile)
fileMenu_openProfile.show()
#Menu - File->Save Profile
fileMenu_saveProfile = gtk.MenuItem("Save Profile")
fileMenu.append(fileMenu_saveProfile)
fileMenu_saveProfile.connect("activate", self.save_profile)
fileMenu_saveProfile.show()
#Menu - File->Save Profile As
fileMenu_saveProfileAs = gtk.MenuItem("Save Profile As..")
fileMenu.append(fileMenu_saveProfileAs)
fileMenu_saveProfileAs.connect("activate", self.save_profile_as)
fileMenu_saveProfileAs.show()
#Menu - File->Exit
fileMenu_exit = gtk.MenuItem("Exit")
fileMenu.append(fileMenu_exit)
fileMenu_exit.connect("activate", self.exit_program)
fileMenu_exit.show()
#Menu - File
root_fileMenu = gtk.MenuItem("File")
root_fileMenu.show()
root_fileMenu.set_submenu(fileMenu)
# To hold Menu->Edit items
editMenu = gtk.Menu()
# Menu - Edit->Expense Range
editMenu_expenseRange = gtk.MenuItem("Expense Range")
editMenu.append(editMenu_expenseRange)
editMenu_expenseRange.connect("activate", self.expense_range)
editMenu_expenseRange.show()
# Menu - Edit->Categories
editMenu_categories = gtk.MenuItem("Categories")
editMenu.append(editMenu_categories)
editMenu_categories.connect("activate", self.categories)
editMenu_categories.show()
# Menu - Edit
root_editMenu = gtk.MenuItem("Edit")
root_editMenu.show()
root_editMenu.set_submenu(editMenu)
# To hold Menu->Graph items
viewMenu = gtk.Menu()
# Menu - View->Graph
viewMenu_graph = gtk.MenuItem("Graph")
viewMenu.append(viewMenu_graph)
viewMenu_graph.connect("activate", self.plot_graph)
viewMenu_graph.show()
# Menu - View
root_viewMenu = gtk.MenuItem("View")
root_viewMenu.show()
root_viewMenu.set_submenu(viewMenu)
# Menu bar
menu_bar = gtk.MenuBar()
menu_bar.append(root_fileMenu)
menu_bar.append(root_editMenu)
menu_bar.append(root_viewMenu)
menu_bar.set_size_request(770, 20)
fixed.put(menu_bar, 0, 0)
menu_bar.show()
# Button - Add
button_add = gtk.Button("Add")
button_add.set_size_request(100, 25)
button_add.connect("clicked", self.add_item, "Added!")
fixed.put(button_add, 130, 460)
button_add.show()
# Button - Remove
button_remove = gtk.Button("Remove")
button_remove.set_size_request(100, 25)
button_remove.connect("clicked", self.remove_item)
fixed.put(button_remove, 250, 460)
button_remove.show()
# Button - Exit
button_exit = gtk.Button("Exit")
button_exit.set_size_request(100, 25)
button_exit.connect("clicked", self.exit_program)
fixed.put(button_exit, 620, 460)
button_exit.show()
# Scrollable treeview for placing receipts
self.liststore = gtk.ListStore(str, str, str, str, str)
self.treeview = gtk.TreeView(self.liststore)
# Item Column
column_date = gtk.TreeViewColumn('Date')
cell_icon = gtk.CellRendererPixbuf()
cell_icon.set_property('cell-background', 'light blue')
column_date.pack_start(cell_icon, False)
column_date.set_attributes(cell_icon, stock_id=0)
cell_date = gtk.CellRendererText()
cell_date.set_property('cell-background', 'white')
column_date.pack_start(cell_date, True)
column_date.set_attributes(cell_date, text=1)
# Description Column
column_description = gtk.TreeViewColumn('Description')
cell_description = gtk.CellRendererText()
cell_description.set_property('cell-background', 'white')
column_description.pack_start(cell_description, True)
column_description.set_attributes(cell_description, text=2)
# Category Column
column_category = gtk.TreeViewColumn("Category")
cell_category = gtk.CellRendererText()
cell_category.set_property("cell-background", "white")
column_category.pack_start(cell_category, True)
column_category.set_attributes(cell_category, text=3)
# Price Column
column_price = gtk.TreeViewColumn("Price")
cell_price = gtk.CellRendererText()
cell_price.set_property("cell-background", "white")
column_price.pack_start(cell_price, True)
column_price.set_attributes(cell_price, text=4)
#Set up treeview
self.treeview.append_column(column_date)
self.treeview.append_column(column_description)
self.treeview.append_column(column_category)
self.treeview.append_column(column_price)
self.treeview.set_search_column(0)
self.treeview.set_reorderable(True)
self.treeview.set_size_request(530, 390)
self.treeview.connect("row-activated", self.edit_item)
# Embed treeview in scrollable window
sw = gtk.ScrolledWindow()
sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
sw.add(self.treeview)
fixed.put(sw, 10, 60)
# Display profile currently in use
self.profile_label = gtk.Label("Profile: " + self.profile.getName())
fixed.put(self.profile_label, 20, 30)
aLabel = gtk.Label()
aLabel.set_markup(
'<span color="#002200" size="large"> Total expense for the last </span>'
)
bLabel = gtk.Label()
bLabel.set_markup(
'<span color="#002200" size="large"> month(s): </span>')
self.expenseDaysLabel = gtk.Label()
self.expenseDaysLabel.set_markup('<span color="#AA0000" size="x-large">' + \
self.profile.expenseRange + '</span>')
self.priceLabel = gtk.Label()
self.priceLabel.set_markup('<span color="#009A00" size="x-large">$' + \
self.profile.getExpense() + '</span>')
fixed.put(aLabel, 560, 70)
fixed.put(bLabel, 595, 100)
fixed.put(self.expenseDaysLabel, 565, 98)
fixed.put(self.priceLabel, 675, 98)
window.show_all()
window.set_keep_above(True)
window.set_keep_above(False)
self.display_items()
def __subWidgets__(self):
self.labels = {}
self.boxes = {}
self.labelbox = {}
self.eboxes = {}
for i in range(4):
self.labelbox[i] = gtk.VBox(homogeneous=False, spacing=20)
self.notebook = gtk.Notebook()
#Files page
for i in range(2):
self.labels[i] = gtk.Label(prefLabelStrings[i])
self.labels[i].set_justify(gtk.JUSTIFY_LEFT)
self.boxes[i] = gtk.HBox(homogeneous=False, spacing=40)
self.boxes[i].pack_start(self.labels[i], expand=False, fill=False)
self.labels[i].show()
self.eboxes[i] = gtk.EventBox()
self.eboxes[i].add(self.boxes[i])
self.labelbox[0].pack_start(self.eboxes[i],
expand=False,
fill=False)
self.workdir_layout = gtk.HBox(homogeneous=False, spacing=0)
self.overwriteFilesButton = gtk.CheckButton(label=None)
self.overwriteFilesButton.set_active(self.values[20])
self.overwriteFilesButton.show()
self.boxes[0].pack_end(self.overwriteFilesButton,
expand=False,
fill=False)
self.workdirEntry = gtk.Entry(max=0)
self.workdirEntry.set_text(self.values[17])
self.workdirEntry.show()
#self.boxes[1].pack_end(self.workdirEntry,expand=False,fill=False)
#self.file_button=gtk.Button(None,gtk.STOCK_SAVE_AS)
#self.file_button.show()
self.workdir_button = gtk.Button(None, gtk.STOCK_SAVE_AS)
self.workdir_button.show()
self.workdir_layout.pack_start(self.workdirEntry,
expand=True,
fill=True)
self.workdir_layout.pack_start(self.workdir_button,
expand=False,
fill=False)
self.workdir_layout.show()
self.labelbox[0].pack_start(self.workdir_layout,
expand=False,
fill=False)
#Performance page
for i in xrange(2, 7):
self.labels[i] = gtk.Label(prefLabelStrings[i])
self.labels[i].set_justify(gtk.JUSTIFY_LEFT)
self.boxes[i] = gtk.HBox(homogeneous=False, spacing=40)
self.boxes[i].pack_start(self.labels[i], expand=False, fill=False)
self.labels[i].show()
self.eboxes[i] = gtk.EventBox()
self.eboxes[i].add(self.boxes[i])
self.labelbox[1].pack_start(self.eboxes[i],
expand=False,
fill=False)
self.fpsAdjustment = gtk.Adjustment(value=self.values[0],
lower=1,
upper=50,
step_incr=1,
page_incr=5,
page_size=0)
self.fpsSpinButton = gtk.SpinButton(self.fpsAdjustment,
climb_rate=0.5,
digits=0)
self.fpsSpinButton.show()
self.boxes[2].pack_end(self.fpsSpinButton, expand=False, fill=False)
self.onTheFlyComboBox = gtk.CheckButton(" ")
self.onTheFlyComboBox.set_active(int(not self.values[18]))
self.onTheFlyComboBox.show()
self.boxes[3].pack_end(self.onTheFlyComboBox, expand=False, fill=False)
self.zeroCmpComboBox = gtk.CheckButton(" ")
self.zeroCmpComboBox.set_active(int(not self.values[19]))
self.zeroCmpComboBox.show()
self.boxes[4].pack_end(self.zeroCmpComboBox, expand=False, fill=False)
self.quickComboBox = gtk.CheckButton(" ")
self.quickComboBox.set_active(int(not self.values[16]))
self.quickComboBox.show()
self.boxes[5].pack_end(self.quickComboBox, expand=False, fill=False)
self.fullComboBox = gtk.CheckButton(" ")
self.fullComboBox.set_active(int(not self.values[3]))
self.fullComboBox.show()
self.boxes[6].pack_end(self.fullComboBox, expand=False, fill=False)
#sound page
for i in xrange(7, 10):
self.labels[i] = gtk.Label(prefLabelStrings[i])
self.labels[i].set_justify(gtk.JUSTIFY_LEFT)
self.boxes[i] = gtk.HBox(homogeneous=False, spacing=0)
self.boxes[i].pack_start(self.labels[i], expand=False, fill=False)
self.labels[i].show()
self.eboxes[i] = gtk.EventBox()
self.eboxes[i].add(self.boxes[i])
self.labelbox[2].pack_start(self.eboxes[i],
expand=False,
fill=False)
self.jack_button = gtk.CheckButton(prefStrings['UseJack'])
self.jack_lsp_label = gtk.Label(prefStrings['SelectPorts'])
self.jack_lsp_liststore = gtk.ListStore(str)
self.jack_lsp_listview = gtk.TreeView(self.jack_lsp_liststore)
self.jack_lsp_tvc = gtk.TreeViewColumn(prefStrings['AvailablePorts'])
self.jack_lsp_listview.append_column(self.jack_lsp_tvc)
self.cell = gtk.CellRendererText()
self.jack_lsp_tvc.pack_start(self.cell, True)
self.jack_lsp_tvc.add_attribute(self.cell, 'text', 0)
self.jack_lsp_listview.set_search_column(0)
self.jack_lsp_listview.set_reorderable(True)
self.jack_lsp_listview.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
self.jack_scroll = gtk.ScrolledWindow(hadjustment=None,
vadjustment=None)
self.jack_scroll.add_with_viewport(self.jack_lsp_listview)
self.jack_lsp_refresh = gtk.Button(None, gtk.STOCK_REFRESH)
self.jack_box = gtk.VBox(homogeneous=False, spacing=10)
self.jack_box.pack_start(self.jack_button, expand=False, fill=False)
self.jack_box.pack_start(self.jack_lsp_label, expand=False, fill=False)
self.jack_box.pack_start(self.jack_scroll, expand=True, fill=True)
self.jack_box.pack_start(self.jack_lsp_refresh,
expand=False,
fill=False)
self.jack_button.set_active(self.values[22])
self.jack_button.show()
self.jack_lsp_label.show()
self.jack_lsp_listview.show()
self.jack_scroll.set_size_request(-1, 200)
self.jack_scroll.show()
self.jack_lsp_refresh.show()
self.jack_ebox = gtk.EventBox()
self.jack_ebox.add(self.jack_box)
self.jack_box.show()
sep1 = gtk.HSeparator()
self.labelbox[2].pack_start(sep1, expand=False, fill=False)
self.labelbox[2].pack_start(self.jack_ebox, expand=True, fill=True)
sep1.show()
self.jack_ebox.show()
self.channelsAdjustment = gtk.Adjustment(value=self.values[7],
lower=1,
upper=2,
step_incr=1,
page_incr=1,
page_size=1)
self.channelsSpinButton = gtk.SpinButton(self.channelsAdjustment,
climb_rate=0.5,
digits=0)
self.channelsSpinButton.show()
self.boxes[7].pack_end(self.channelsSpinButton,
expand=False,
fill=False)
self.freqAdjustment = gtk.Adjustment(value=self.values[8],
lower=0,
upper=48000,
step_incr=1,
page_incr=100,
page_size=0)
self.freqSpinButton = gtk.SpinButton(self.freqAdjustment,
climb_rate=0.5,
digits=0)
self.freqSpinButton.show()
self.boxes[8].pack_end(self.freqSpinButton, expand=False, fill=False)
self.deviceEntry = gtk.Entry(max=0)
self.deviceEntry.set_text(self.values[9])
self.deviceEntry.show()
self.boxes[9].pack_end(self.deviceEntry, expand=False, fill=False)
#misc page
for i in xrange(10, 19):
self.labels[i] = gtk.Label(prefLabelStrings[i])
self.labels[i].set_justify(gtk.JUSTIFY_LEFT)
self.boxes[i] = gtk.HBox(homogeneous=False, spacing=0)
self.boxes[i].pack_start(self.labels[i], expand=False, fill=False)
self.labels[i].show()
self.eboxes[i] = gtk.EventBox()
self.eboxes[i].add(self.boxes[i])
self.labelbox[3].pack_start(self.eboxes[i],
expand=False,
fill=False)
self.displayEntry = gtk.Entry(max=0)
self.displayEntry.set_text(self.values[12])
self.displayEntry.show()
self.boxes[10].pack_end(self.displayEntry, expand=False, fill=False)
self.mouseComboBox = gtk.combo_box_new_text()
for i in range(4):
self.mouseComboBox.append_text(prefMouseStrings[i])
self.mouseComboBox.set_active(self.values[1])
self.mouseComboBox.show()
self.boxes[11].pack_end(self.mouseComboBox, expand=False, fill=False)
self.followMouseComboBox = gtk.CheckButton(" ")
self.followMouseComboBox.set_active(int(not self.values[15]))
self.followMouseComboBox.show()
self.boxes[12].pack_end(self.followMouseComboBox,
expand=False,
fill=False)
self.sharedComboBox = gtk.CheckButton(" ")
self.sharedComboBox.set_active(int(not self.values[13]))
self.sharedComboBox.show()
self.boxes[13].pack_end(self.sharedComboBox, expand=False, fill=False)
self.winDecoComboBox = gtk.CheckButton(" ")
self.winDecoComboBox.set_active(int(not self.values[21]))
self.winDecoComboBox.show()
self.boxes[14].pack_end(self.winDecoComboBox, expand=False, fill=False)
self.tooltipsComboBox = gtk.CheckButton(" ")
self.tooltipsComboBox.set_active(int(not self.values[24]))
self.tooltipsComboBox.show()
self.boxes[15].pack_end(self.tooltipsComboBox,
expand=False,
fill=False)
self.rFrameComboBox = gtk.CheckButton(" ")
self.rFrameComboBox.set_active(int(not self.values[25]))
self.rFrameComboBox.show()
self.boxes[16].pack_end(self.rFrameComboBox, expand=False, fill=False)
self.areaResetComboBox = gtk.CheckButton(" ")
self.areaResetComboBox.set_active(int(not self.values[14]))
self.areaResetComboBox.show()
self.boxes[17].pack_end(self.areaResetComboBox,
expand=False,
fill=False)
self.extraOptsEntry = gtk.Entry(max=0)
self.extraOptsEntry.set_text(self.values[26])
self.extraOptsEntry.show()
self.boxes[18].pack_end(self.extraOptsEntry, expand=False, fill=False)
for i in range(19):
self.boxes[i].show()
self.eboxes[i].show()
#append and show
for i in range(4):
self.notebook.append_page(self.labelbox[i],
gtk.Label(prefTabStrings[i]))
self.window.add(self.notebook)
for i in range(4):
self.labelbox[i].show()
self.notebook.show()
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()
