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()