From d2e202f9929f6b3cd1d45d39f8414ee8679e639c Mon Sep 17 00:00:00 2001 From: necoro <> Date: Mon, 6 Nov 2006 19:34:56 +0000 Subject: Rewritten the gtk-gui to use glade --- geneticone.py | 7 +- geneticone/constants.py | 17 + geneticone/gui/gtk/glade/geneticone.glade | 940 ++++++++++++++++++++++++++++ geneticone/gui/gtk/windows.py | 983 ++++++++++++------------------ setup.py | 7 +- 5 files changed, 1338 insertions(+), 616 deletions(-) create mode 100644 geneticone/constants.py create mode 100644 geneticone/gui/gtk/glade/geneticone.glade diff --git a/geneticone.py b/geneticone.py index df44769..9abefd3 100755 --- a/geneticone.py +++ b/geneticone.py @@ -12,18 +12,19 @@ # # Written by René 'Necoro' Neumann -from geneticone.gui import MainWindow +from geneticone.constants import VERSION import sys if __name__ == "__main__": if len(sys.argv) > 1 and sys.argv[1] in ("--help","--version","-h","-v"): - print """Genetic/One SVN-Version + print """Genetic/One %s Copyright (C) 2006 René 'Necoro' Neumann This is free software. You may redistribute copies of it under the terms of the GNU General Public License . There is NO WARRANTY, to the extent permitted by law. -Written by René 'Necoro' Neumann """ +Written by René 'Necoro' Neumann """ % VERSION else: + from geneticone.gui import MainWindow m = MainWindow() m.main() diff --git a/geneticone/constants.py b/geneticone/constants.py new file mode 100644 index 0000000..1e4fc6b --- /dev/null +++ b/geneticone/constants.py @@ -0,0 +1,17 @@ +# -*- coding: utf-8 -*- +# +# File: geneticone/constants.py +# This file is part of the Genetic/One-Project, a graphical portage-frontend. +# +# Copyright (C) 2006 René 'Necoro' Neumann +# This is free software. You may redistribute copies of it under the terms of +# the GNU General Public License version 2. +# There is NO WARRANTY, to the extent permitted by law. +# +# Written by René 'Necoro' Neumann + +CONFIG_DIR = "/etc/geneticone/" +CONFIG_LOCATION = CONFIG_DIR+"geneticone.cfg" + +DATA_DIR = "geneticone/gui/gtk/glade/" +VERSION = 9999 diff --git a/geneticone/gui/gtk/glade/geneticone.glade b/geneticone/gui/gtk/glade/geneticone.glade new file mode 100644 index 0000000..63f54e8 --- /dev/null +++ b/geneticone/gui/gtk/glade/geneticone.glade @@ -0,0 +1,940 @@ + + + + + + 2 + GTK_WIN_POS_CENTER_ALWAYS + + + + True + + + True + + + True + _File + True + + + True + + + True + _Preferences + True + + + + + + True + _Reload Portage + True + + + + + True + + + + + True + _Close + True + + + + + + + + + + True + _Emerge + True + + + True + + + True + _Emerge + True + + + + + + True + _Unmerge + True + + + + + + True + Update _World + True + + + + + + True + _Sync + True + + + + + + + + + + True + _? + True + + + True + + + True + _About + True + + + + + + + + + + False + + + + + True + 3 + + + True + + + + 5 + + + + + True + _Search + True + + + + False + 1 + + + + + False + False + 1 + + + + + True + 300 + + + True + 0 + 0 + GTK_SHADOW_IN + + + True + 5 + True + + + True + GTK_POLICY_AUTOMATIC + GTK_POLICY_AUTOMATIC + + + True + 0 + + + + + + + + True + GTK_POLICY_AUTOMATIC + GTK_POLICY_AUTOMATIC + + + True + 0 + + + + + + 1 + + + + + + + + label_item + + + + + False + + + + + True + True + + + True + 4 + 2 + + + True + GTK_POLICY_AUTOMATIC + GTK_POLICY_AUTOMATIC + + + True + + + + + 2 + 2 + 3 + 5 + + + + + True + + + + + + 1 + 2 + GTK_FILL + + + + + True + GTK_JUSTIFY_CENTER + True + + + 2 + GTK_FILL + GTK_EXPAND + 10 + + + + + True + 1 + True + + + True + True + Installed + True + + + + + + True + True + Masked + True + + + + 1 + + + + + True + True + Testing + True + + + + 2 + + + + + 1 + 2 + 1 + 2 + GTK_FILL + 5 + + + + + True + True + <span foreground='red'><b>MISSING KEYWORD</b></span> + True + + + 1 + 2 + 1 + 2 + GTK_FILL + + + + + True + True + <b>Installed, but not in portage anymore</b> + True + + + 1 + 2 + 1 + 2 + GTK_FILL + + + + + True + GTK_BUTTONBOX_SPREAD + + + True + _Emerge + True + + + + + + True + _Unmerge + True + + + + 1 + + + + + True + Re_vert + True + + + + 2 + + + + + 2 + 3 + 4 + + + + + False + False + + + + + True + Package + + + tab + False + False + + + + + True + + + True + GTK_POLICY_AUTOMATIC + GTK_POLICY_AUTOMATIC + + + True + False + False + + + + + + + + + True + True + GTK_BUTTONBOX_SPREAD + + + True + E_merge + True + + + + + + True + _Unmerge + True + + + + 1 + + + + + True + Update _World + True + + + 2 + + + + + True + _Remove + True + + + + 3 + + + + + False + False + 5 + 1 + + + + + 1 + False + + + + + True + Queue + True + + + tab + 1 + False + False + + + + + True + + + + + + + + + 2 + False + + + + + True + Console + True + + + tab + 2 + False + False + + + + + + + 2 + + + + + True + + + False + 3 + + + + + + + About + False + True + GTK_WIN_POS_CENTER_ON_PARENT + 1 + 1 + True + True + + + True + + + True + True + GTK_JUSTIFY_CENTER + True + + + + + True + _OK + True + + + + False + False + 1 + + + + + + + Search + False + True + GTK_WIN_POS_CENTER_ON_PARENT + 1 + 1 + True + True + + + + + + 5 + Preferences + True + GTK_WIN_POS_CENTER_ON_PARENT + True + True + + + True + 5 + + + True + 0 + + + True + 12 + + + True + Debug + True + + + + + + + True + <b>General Options</b> + True + + + label_item + + + + + + + True + 0 + + + True + 12 + + + True + + + True + --deep + True + + + False + + + + + True + --newuse + True + + + False + 1 + + + + + + + + + True + <b>Update World Options</b> + True + + + label_item + + + + + 1 + + + + + True + 0 + + + True + 5 + 12 + 5 + + + True + 10 + 2 + + + True + 0 + 5 + <u><i>Masking Keywords</i></u> + True + True + + + 7 + 8 + 5 + + + + + True + 0 + 5 + <u><i>Testing Keywords</i></u> + True + True + + + 4 + 5 + 5 + + + + + True + 0 + 5 + <u><i>Use-Flags</i></u> + True + True + + + 1 + 2 + 6 + + + + + + + + + + + + + + True + + + True + 0 + GTK_SHADOW_OUT + + + True + 0.029999999329447746 + <u>You may use the following placeholders:</u> + +<i>$(cat)</i>: category +<i>$(pkg)</i>: package name +<i>$(cat-1)/$(cat-2)</i>: first/second part of the category + True + + + + + + label_item + + + + + + + 2 + + + + + True + Add only exact version to package.mask/package.unmask + True + + + 2 + 8 + 9 + + + + + True + 0 + File name to use, if package.mask/package.unmask is a directory: + True + + + 9 + 10 + + + + + True + + + 1 + 2 + 9 + 10 + + + + + True + + + 1 + 2 + 6 + 7 + + + + + True + 0 + File name to use, if package.keywords is a directory: + True + + + 6 + 7 + + + + + True + Add only exact version to package.keywords + True + + + 2 + 5 + 6 + + + + + True + Add only exact version to package.use + True + + + 2 + 2 + 3 + + + + + True + 0 + File name to use, if package.use is a directory: + True + + + 3 + 4 + + + + + True + + + 1 + 2 + 3 + 4 + + + + + + + + + True + <b>Use Flag and Keyword Options</b> + True + + + label_item + + + + + 2 + + + + + True + True + GTK_BUTTONBOX_SPREAD + + + True + _OK + True + + + + + + True + _Cancel + True + + + + 1 + + + + + 3 + + + + + + diff --git a/geneticone/gui/gtk/windows.py b/geneticone/gui/gtk/windows.py index 0f36a67..3ce01f9 100644 --- a/geneticone/gui/gtk/windows.py +++ b/geneticone/gui/gtk/windows.py @@ -10,17 +10,16 @@ # # Written by René 'Necoro' Neumann -VERSION = "0.4.6-svn" -CONFIG_LOCATION = "/etc/geneticone/geneticone.cfg" - # gtk stuff import pygtk pygtk.require("2.0") import gtk +import gtk.glade import gobject #our backend stuff from geneticone.helper import * +from geneticone.constants import CONFIG_LOCATION, VERSION, DATA_DIR from geneticone import backend from geneticone.backend import flags from geneticone.backend.exceptions import * @@ -36,34 +35,45 @@ import vte # other from portage_util import unique_array -class AbstractDialog: +class Window: + def __init__ (self): + self.tree = gtk.glade.XML(DATA_DIR+"geneticone.glade", root = self.__class__.__name__) + self.tree.signal_autoconnect(self) + self.window = self.tree.get_widget(self.__class__.__name__) + + @staticmethod + def watch_cursor (func): + """This is a decorator for functions being so time consuming, that it is appropriate to show the watch-cursor. + @attention: this function relies on the gtk.Window-Object being stored as self.window""" + def wrapper (self, *args, **kwargs): + ret = None + def cb_idle(): + try: + ret = func(self, *args, **kwargs) + finally: + self.window.window.set_cursor(None) + return False + + watch = gtk.gdk.Cursor(gtk.gdk.WATCH) + self.window.window.set_cursor(watch) + gobject.idle_add(cb_idle) + return ret + return wrapper + +class AbstractDialog (Window): """A class all our dialogs get derived from. It sets useful default vars and automatically handles the ESC-Button.""" - def __init__ (self, parent, title): + def __init__ (self, parent): """Constructor. @param parent: the parent window - @type parent: gtk.Window - @param title: the title of the window - @type title: string""" - - # create new - self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) - - # set title - self.window.set_title(title) + @type parent: gtk.Window""" - # set modal and transient for the parent --> you have to close this one to get back to the parent - self.window.set_modal(True) - self.window.set_transient_for(parent) - self.window.set_destroy_with_parent(True) + Window.__init__(self) - # not resizable - self.window.set_resizable(False) + # set parent + self.window.set_transient_for(parent) - # default size = (1,1) ==> as small as possible - self.window.set_default_size(1,1) - # catch the ESC-key self.window.connect("key-press-event", self.cb_key_pressed) @@ -71,11 +81,14 @@ class AbstractDialog: """Closes the window if ESC is pressed.""" keyname = gtk.gdk.keyval_name(event.keyval) if keyname == "Escape": - self.window.destroy() + self.close() return True else: return False + def close (self, *args): + self.window.destroy() + class AboutWindow (AbstractDialog): """A window showing the "about"-informations.""" @@ -84,15 +97,10 @@ class AboutWindow (AbstractDialog): @param parent: the parent window @type parent: gtk.Window""" - - AbstractDialog.__init__(self, parent, "About Genetic/One") - box = gtk.VBox(False) - self.window.add(box) - - # about label - label = gtk.Label() - label.set_justify(gtk.JUSTIFY_CENTER) + AbstractDialog.__init__(self, parent) + + label = self.tree.get_widget("aboutLabel") label.set_markup(""" Genetic/One v.%s A Portage-GUI @@ -102,14 +110,7 @@ Copyright (C) 2006 René 'Necoro' Neumann <necoro@necoro.net> Thanks to Fred for support and ideas :P """ % VERSION) - box.pack_start(label) - # button - okBtn = gtk.Button("OK") - okBtn.connect("clicked", lambda x: self.window.destroy()) - box.pack_start(okBtn) - - # finished -> show self.window.show_all() class SearchWindow (AbstractDialog): @@ -125,49 +126,54 @@ class SearchWindow (AbstractDialog): @param jump_to: function to call if "OK"-Button is hit @type jump_to: function(string)""" - AbstractDialog.__init__(self, parent, "Search results") + AbstractDialog.__init__(self, parent) self.list = list # list to show self.jump_to = jump_to # function to call for jumping - - box = gtk.HBox(False) - self.window.add(box) - + # combo box self.combo = gtk.combo_box_new_text() for x in list: self.combo.append_text(x) self.combo.set_active(0) # first item self.combo.connect("key-press-event", self.cb_key_pressed_combo) - - box.pack_start(self.combo) - - # ok-button - okBtn = gtk.Button("OK") - okBtn.connect("clicked", self.cb_ok_btn_clicked) - box.pack_start(okBtn) + + self.window.add(self.combo) # finished --> show self.window.show_all() - def cb_ok_btn_clicked (self, button): - """Called if the OK-Button is clicked. - Calls self.jump_to(selected_entry) and closes the window.""" - self.window.destroy() - self.jump_to(self.list[self.combo.get_active()]) - return True - def cb_key_pressed_combo (self, widget, event): """Emulates a ok-button-click.""" keyname = gtk.gdk.keyval_name(event.keyval) if keyname == "Return": # take it as an "OK" if Enter is pressed - self.cb_ok_btn_clicked(widget) + self.window.destroy() + self.jump_to(self.list[self.combo.get_active()]) return True else: return False class PreferenceWindow (AbstractDialog): """Window displaying some preferences.""" + + # all checkboxes in the window + # widget name -> option name + checkboxes = { + "debugCheck" : "debug_opt", + "deepCheck" : "deep_opt", + "newUseCheck" : "newuse_opt", + "maskPerVersionCheck" : "maskPerVersion_opt", + "usePerVersionCheck" : "usePerVersion_opt", + "testPerVersionCheck" : "testingPerVersion_opt" + } + + # all edits in the window + # widget name -> option name + edits = { + "maskFileEdit" : "maskFile_opt", + "testFileEdit" : "testingFile_opt", + "useFileEdit" : "useFile_opt" + } def __init__ (self, parent, cfg): """Constructor. @@ -176,239 +182,139 @@ class PreferenceWindow (AbstractDialog): @type parent: gtk.Window @param cfg: configuration object @type cfg: gui_helper.Config""" - - AbstractDialog.__init__(self, parent, "Preferences") - self.window.set_resizable(True) # override the default of the AbstractDialog + AbstractDialog.__init__(self, parent) + # our config self.cfg = cfg - box = gtk.VBox() - box.set_spacing(5) + # set the bg-color of the hint + hintEB = self.tree.get_widget("hintEB") + hintEB.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("#f3f785")) - self.window.add(box) - # En-/Disable Debugging - self.debugCb = self.draw_cb(box, "Debugging modus", "debug_opt") + for box in self.checkboxes: + self.tree.get_widget(box).\ + set_active(self.cfg.get_boolean(\ + self.cfg.const[self.checkboxes[box]])) - # --deep - self.deepCb = self.draw_cb(box, "--deep", "deep_opt") + for edit in self.edits: + self.tree.get_widget(edit).\ + set_text(self.cfg.get(\ + self.cfg.const[self.edits[edit]])) - # --newuse - self.newuseCb = self.draw_cb(box, "--newuse", "newuse_opt") - - pHolderLabel = gtk.Label("""For the following options, you might use these placeholders: -$(cat) = category -$(pkg) = package-name -$(cat-1)/$(cat-2) = first/second part of the category""") - pHolderLabel.set_use_markup(True) - pHolderLabel.set_alignment(0,0) - box.pack_start(pHolderLabel) - - # The use/mask/keywording checkboxes and edits - self.usePerVersionCb, self.useFileEdit = self.draw_cb_and_edit(box, "package.use", "usePerVersion_opt", "useFile_opt") - self.maskPerVersionCb, self.maskFileEdit = self.draw_cb_and_edit(box, "package.mask/package.unmask", "maskPerVersion_opt", "maskFile_opt") - self.testPerVersionCb, self.testFileEdit = self.draw_cb_and_edit(box, "package.keywords", "testingPerVersion_opt", "testingFile_opt") - # buttons - buttonHB = gtk.HButtonBox() - buttonHB.set_layout(gtk.BUTTONBOX_SPREAD) - - okBtn = gtk.Button("_OK") - cancelBtn = gtk.Button("_Cancel") - okBtn.connect("clicked", self.cb_ok_clicked) - cancelBtn.connect("clicked", lambda x: self.window.destroy()) - buttonHB.pack_start(okBtn) - buttonHB.pack_start(cancelBtn) - - box.pack_start(buttonHB, True, True, 5) - - # finished --> show all self.window.show_all() - def draw_cb_and_edit (self, box, string, cb_opt, edit_opt): - """Draws a checkbox and an edit-field. - - @param box: box to place the both things into - @type box: gtk.Box - @param string: string to show - @type string: string - @param cb_opt: the option string for the Config.const-dict - @type cb_opt: string - @param edit_opt: the option string for the Config.const-dic - @type edit_opt: string - - @return: the checkbox and the edit-field - @rtype: (gtk.CheckButton, gtk.Edit)""" - - # check-button - cb = self.draw_cb(box, label=("Add to %s on a per-version-base" % string), opt = cb_opt) - - # edit with label - hBox = gtk.HBox() - label = gtk.Label("File name to use if %s is a directory:" % string) - edit = gtk.Entry() - edit.set_text(self.cfg.get(self.cfg.const[edit_opt])) - hBox.pack_start(label, False) - hBox.pack_start(edit, True, True, 5) - box.pack_start(hBox, True, True) - - return (cb, edit) - - def draw_cb (self, box, label, opt): - """Draws a checkbox. - - @param box: box to place the cb into - @type box: gtk.Box - @param label: Label to show - @type label: string - @param opt: the option string for the Config.const-dict - @type opt: string - @returns: the checkbox - @rtype: gtk.CheckButton""" - - cb = gtk.CheckButton(label=label) - cb.set_active(self.cfg.get_boolean(self.cfg.const[opt])) - box.pack_start(cb, True, True) - - return cb - def _save(self): """Sets all options in the Config-instance.""" - self.cfg.set(self.cfg.const["usePerVersion_opt"], str(self.usePerVersionCb.get_active())) - self.cfg.set(self.cfg.const["useFile_opt"], self.useFileEdit.get_text()) - self.cfg.set(self.cfg.const["maskPerVersion_opt"], str(self.maskPerVersionCb.get_active())) - self.cfg.set(self.cfg.const["maskFile_opt"], self.maskFileEdit.get_text()) - self.cfg.set(self.cfg.const["testingPerVersion_opt"], str(self.testPerVersionCb.get_active())) - self.cfg.set(self.cfg.const["testingFile_opt"], self.testFileEdit.get_text()) - self.cfg.set(self.cfg.const["debug_opt"], str(self.debugCb.get_active())) - self.cfg.set(self.cfg.const["deep_opt"], str(self.deepCb.get_active())) - self.cfg.set(self.cfg.const["newuse_opt"], str(self.newuseCb.get_active())) + + for box in self.checkboxes: + self.cfg.set(\ + self.cfg.const[self.checkboxes[box]],\ + str(self.tree.get_widget(box).get_active())) + for edit in self.edits: + self.cfg.set(\ + self.cfg.const[self.edits[edit]],\ + self.tree.get_widget(edit).get_text()) + def cb_ok_clicked(self, button): """Saves, writes to config-file and closes the window.""" self._save() self.cfg.write() self.window.destroy() -class PackageWindow (AbstractDialog): + def cb_cancel_clicked (self, button): + """Just closes - w/o saving.""" + self.window.destroy() + +class PackageTable: """A window with data about a specfic package.""" - def __init__ (self, parent, cp, queue = None, version = None, delOnClose = True, doEmerge = True): + def __init__ (self, main): """Build up window contents. - @param parent: the parent window - @type parent: gtk.Window + @param main: the main window + @type main: MainWindow""" + + self.main = main + self.tree = main.tree + self.window = main.window + self.tree.signal_autoconnect(self) + + # the table + self.table = self.tree.get_widget("PackageTable") + + # chechboxes + self.installedCheck = self.tree.get_widget("installedCheck") + self.maskedCheck = self.tree.get_widget("maskedCheck") + self.testingCheck = self.tree.get_widget("testingCheck") + + # labels + self.notInSysLabel = self.tree.get_widget("notInSysLabel") + self.missingLabel = self.tree.get_widget("missingLabel") + + # buttons + self.emergeBtn = self.tree.get_widget("pkgEmergeBtn") + self.unmergeBtn = self.tree.get_widget("pkgUnmergeBtn") + self.cancelBtn = self.tree.get_widget("pkgCancelBtn") + + # useList + self.useListScroll = self.tree.get_widget("useListScroll") + self.useList = None + + def update (self, cp, queue = None, version = None, doEmerge = True, instantChange = False): + """Updates the table to show the contents for the package. + @param cp: the selected package @type cp: string (cp) @param queue: emerge-queue (if None the emerge-buttons are disabled) @type queue: EmergeQueue @param version: if not None, specifies the version to select @type version: string - @param delOnClose: if True (default) changed flags are changed on closing - @type delOnClose: boolean @param doEmerge: if False, the emerge buttons are disabled - @type doEmerge: False""" - - AbstractDialog.__init__(self, parent, cp) - + @type doEmerge: False + @param instantChange: if True the changed keywords are updated instantly + @type instantChange: boolean""" + self.cp = cp # category/package self.version = version # version - if not None this is used self.queue = queue - self.delOnClose = delOnClose self.doEmerge = doEmerge - self.flagChanged = False + self.instantChange = instantChange # packages and installed packages self.packages = backend.sort_package_list(backend.get_all_versions(cp)) self.instPackages = backend.sort_package_list(backend.get_all_installed_versions(cp)) - # main structure - the table - self.table = gtk.Table(rows=4,columns=2) - self.window.add(self.table) - # version-combo-box self.vCombo = self.build_vers_combo() - self.table.attach(self.vCombo, 0, 1, 1, 2, yoptions = gtk.FILL) if not self.doEmerge: self.vCombo.set_sensitive(False) + vb = self.tree.get_widget("comboVB") + children = vb.get_children() + if children: + for c in children: vb.remove(c) + vb.pack_start(self.vCombo) # the label (must be here, because it depends on the combo box) - desc = self.actual_package().get_env_var("DESCRIPTION") + desc = self.actual_package().get_env_var("DESCRIPTION").replace("&","&") if not desc: desc = "" use_markup = False else: desc = ""+desc+"" use_markup = True - self.descLabel = gtk.Label(desc) - self.descLabel.set_line_wrap(True) - self.descLabel.set_justify(gtk.JUSTIFY_CENTER) + self.descLabel = self.tree.get_widget("descLabel") self.descLabel.set_use_markup(use_markup) - self.table.attach(self.descLabel, 0, 2, 0, 1, xoptions = gtk.FILL, ypadding = 10) - - # the check boxes - checkHB = gtk.HBox (True, 1) - self.table.attach(checkHB, 1, 2, 1, 2, yoptions = gtk.FILL) - - self.installedCheck = gtk.CheckButton() - self.installedCheck.connect("button-press-event", self.cb_button_pressed) - self.installedCheck.set_label("Installed") - self.installedCheck.set_no_show_all(True) - checkHB.pack_start(self.installedCheck, True, False) - - self.maskedCheck = gtk.CheckButton() - self.maskedCheck.connect("toggled", self.cb_masked_toggled) - self.maskedCheck.set_label("Masked") - self.maskedCheck.set_no_show_all(True) - checkHB.pack_start(self.maskedCheck, True, False) - - self.testingCheck = gtk.CheckButton() - self.testingCheck.connect("toggled", self.cb_testing_toggled) - self.testingCheck.set_label("Testing") - self.testingCheck.set_no_show_all(True) - checkHB.pack_start(self.testingCheck, True, False) - - self.missing_label = gtk.Label("MISSING KEYWORD") - self.missing_label.set_use_markup(True) - self.missing_label.set_no_show_all(True) - self.table.attach(self.missing_label, 1, 2, 1, 2, yoptions = gtk.FILL) - - self.not_in_sys_label = gtk.Label("Installed, but not in portage anymore") - self.not_in_sys_label.set_use_markup(True) - self.not_in_sys_label.set_no_show_all(True) - self.table.attach(self.not_in_sys_label, 1, 2, 1, 2, yoptions = gtk.FILL) - - # use list - self.useList = self.build_use_list() - self.useListScroll = gtk.ScrolledWindow() - self.useListScroll.add(self.useList) - self.useListScroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_NEVER) # XXX: make this work correctly - self.table.attach(self.useListScroll, 0, 2, 2, 3, ypadding = 10) + self.descLabel.set_label(desc) - # buttons - buttonHB = gtk.HButtonBox() - buttonHB.set_layout(gtk.BUTTONBOX_SPREAD) - self.table.attach(buttonHB, 0, 2, 3, 4) - - self.emergeBtn = gtk.Button("_Emerge") - self.unmergeBtn = gtk.Button("_Unmerge") if not self.queue or not self.doEmerge: self.emergeBtn.set_sensitive(False) self.unmergeBtn.set_sensitive(False) - self.cancelBtn = gtk.Button("_Cancel") - if not self.delOnClose: - self.cancelBtn.set_label("_Close") - self.cancelBtn.connect("clicked", self.cb_cancel_clicked) - self.emergeBtn.connect("clicked", self.cb_emerge_clicked) - self.unmergeBtn.connect("clicked", self.cb_unmerge_clicked) - buttonHB.pack_start(self.emergeBtn) - buttonHB.pack_start(self.unmergeBtn) - buttonHB.pack_start(self.cancelBtn) - + # current status self.cb_combo_changed(self.vCombo) - - # show - self.window.show_all() + self.table.show_all() def fill_use_list(self, store): """Fills a given ListStore with the use-flag data. @@ -488,12 +394,30 @@ class PackageWindow (AbstractDialog): return self.packages[self.vCombo.get_active()] + def _update_keywords (self, emerge, update = False): + if emerge: + try: + try: + self.queue.append(self.actual_package().get_cpv(), unmerge = False, update = update) + except backend.PackageNotFoundException, e: + if unmask_dialog(e[0]) == gtk.RESPONSE_YES: + self.queue.append(self.actual_package().get_cpv(), unmerge = False, unmask = True, update = update) + except BlockedException, e: + blocked_dialog(e[0], e[1]) + else: + try: + self.queue.append(self.actual_package().get_cpv(), unmerge = True) + except backend.PackageNotFoundException, e: + masked_dialog(e[0]) + def cb_combo_changed (self, combo): """Callback for the changed ComboBox. It then rebuilds the useList and the checkboxes.""" # remove old useList - self.useListScroll.remove(self.useList) + w = self.useListScroll.get_child() + if w: + self.useListScroll.remove(w) # build new self.useList = self.build_use_list() @@ -505,19 +429,19 @@ class PackageWindow (AbstractDialog): # if (not pkg.is_in_system()) or pkg.is_missing_keyword(): if not pkg.is_in_system(): - self.missing_label.hide() - self.not_in_sys_label.show() + self.missingLabel.hide() + self.notInSysLabel.show() else: # missing keyword - self.missing_label.show() - self.not_in_sys_label.hide() + self.missingLabel.show() + self.notInSysLabel.hide() self.installedCheck.hide() self.maskedCheck.hide() self.testingCheck.hide() self.emergeBtn.set_sensitive(False) else: - self.missing_label.hide() - self.not_in_sys_label.hide() + self.missingLabel.hide() + self.notInSysLabel.hide() self.installedCheck.show() self.maskedCheck.show() self.testingCheck.show() @@ -541,9 +465,8 @@ class PackageWindow (AbstractDialog): self.emergeBtn.set_label("R_emerge") self.unmergeBtn.set_sensitive(True) - # refresh - make window as small as possible self.table.show_all() - self.window.resize(1,1) + return True def cb_button_pressed (self, b, event): @@ -552,54 +475,29 @@ class PackageWindow (AbstractDialog): b.emit_stop_by_name("button-press-event") return True - def cb_cancel_clicked (self, button, data = None): + def cb_package_revert_clicked (self, button): """Callback for pressed cancel-button. Closes the window.""" - if self.delOnClose: - self.actual_package().remove_new_use_flags() - self.actual_package().remove_new_masked() - self.actual_package().remove_new_testing() - elif self.flagChanged: - if self.queue: - try: - try: - self.queue.append(self.actual_package().get_cpv(), update = True) - except backend.PackageNotFoundException, e: - if unmask_dialog(e[0]) == gtk.RESPONSE_YES: - self.queue.append(self.actual_package().get_cpv(), update = True, unmask = True) - except backend.BlockedException, e: - blocked_dialog(e[0], e[1]) - - self.window.destroy() + self.actual_package().remove_new_use_flags() + self.actual_package().remove_new_masked() + self.actual_package().remove_new_testing() + self.cb_combo_changed(self.vCombo) return True - def cb_emerge_clicked (self, button, data = None): + def cb_package_emerge_clicked (self, button): """Callback for pressed emerge-button. Adds the package to the EmergeQueue.""" if not am_i_root(): not_root_dialog() else: - try: - try: - self.queue.append(self.actual_package().get_cpv(), unmerge = False) - self.window.destroy() - except backend.PackageNotFoundException, e: - if unmask_dialog(e[0]) == gtk.RESPONSE_YES: - self.queue.append(self.actual_package().get_cpv(), unmerge = False, unmask = True) - self.window.destroy() - except BlockedException, e: - blocked_dialog(e[0], e[1]) + self._update_keywords(True) + self.main.notebook.set_current_page(self.main.QUEUE_PAGE) return True - def cb_unmerge_clicked (self, button, data = None): + def cb_package_unmerge_clicked (self, button): """Callback for pressed unmerge-button clicked. Adds the package to the UnmergeQueue.""" if not am_i_root(): not_root_dialog() else: - try: - self.queue.append(self.actual_package().get_cpv(), unmerge = True) - except backend.PackageNotFoundException, e: - masked_dialog(e[0]) - - self.window.destroy() + self._update_keywords(False) return True def cb_testing_toggled (self, button): @@ -619,14 +517,20 @@ class PackageWindow (AbstractDialog): button.set_label("(Testing)") button.get_child().set_use_markup(True) button.set_active(True) - self.flagChanged = True + + if self.instantChange: + self._update_keywords(True, update = True) + return True def cb_masked_toggled (self, button): """Callback for toggled masking-checkbox.""" status = button.get_active() self.actual_package().set_masked(status) - self.flagChanged = True + + if self.instantChange: + self._update_keywords(True, update = True) + return True def cb_use_flag_toggled (self, cell, path, store): @@ -636,27 +540,33 @@ class PackageWindow (AbstractDialog): if not store[path][0]: prefix = "-" self.actual_package().set_use_flag(prefix+store[path][1]) - self.flagChanged = True + + if self.instantChange: + self._update_keywords(True, update = True) + return True -class MainWindow: +class MainWindow (Window): """Application main window.""" + + # NOTEBOOK PAGE CONSTANTS + PKG_PAGE = 0 + QUEUE_PAGE = 1 + CONSOLE_PAGE = 2 - def __init__ (self): + def __init__ (self): """Build up window""" - # window - self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) + + # main window stuff + Window.__init__(self) self.window.set_title(("Genetic/One (%s)" % VERSION)) - self.window.connect("destroy", self.cb_destroy) - self.window.set_border_width(2) - self.window.set_resizable(True) - mHeight = 800 if gtk.gdk.screen_height() <= 800: mHeight = 600 self.window.set_geometry_hints (self.window, min_width = 600, min_height = mHeight, max_height = gtk.gdk.screen_height(), max_width = gtk.gdk.screen_width()) # booleans self.doUpdate = False + self.packageInit = True # package db self.db = Database() @@ -666,101 +576,20 @@ class MainWindow: self.cfg = Config(CONFIG_LOCATION) self.cfg.modify_external_configs() - # actions needed - self.emergeAction = gtk.Action("Emerge", "_Emerge", None, None) - self.emergeAction.connect("activate", self.cb_emerge_clicked) - self.unmergeAction = gtk.Action("Unmerge", "_Unmerge", None, None) - self.unmergeAction.connect("activate", self.cb_emerge_clicked) - self.updateAction = gtk.Action("UpdateWorld", "Update _World", None, None) - self.updateAction.connect("activate", self.cb_update_clicked) - - # main vb - vb = gtk.VBox(False, 1) - self.window.add(vb) - - # menus - self.uimanager = self.create_uimanager() - self.queuePopup = self.uimanager.get_widget("/popupQueue") - menubar = self.uimanager.get_widget("/bar") - vb.pack_start(menubar, False) - - # search - self.searchEntry = gtk.Entry() - self.searchBtn = gtk.Button("_Search") - self.searchBtn.connect("clicked", self.cb_search_clicked) - self.searchEntry.connect("activate", self.cb_search_clicked) - hbSearch = gtk.HBox(False, 5) - hbSearch.pack_start(self.searchEntry, True, True) - hbSearch.pack_start(self.searchBtn, False, False) - vb.pack_start(hbSearch, False, False, 5) - - # VPaned holding the lists and the Terminal - vpaned = gtk.VPaned() + # set vpaned position + vpaned = self.tree.get_widget("vpaned") vpaned.set_position(mHeight/2) - vb.pack_start(vpaned, True, True) - - # a HB holding the lists - hb = gtk.HBox(True, 5) - hbFrame = gtk.Frame() - hbFrame.add(hb) - hbFrame.set_shadow_type(gtk.SHADOW_IN) - vpaned.pack1(hbFrame, shrink = True, resize = True) - - self.scroll_1 = gtk.ScrolledWindow() - self.scroll_2 = gtk.ScrolledWindow() - self.scroll_1.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) - self.scroll_2.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC) - hb.pack_start(self.scroll_1, True, True) - hb.pack_start(self.scroll_2, True, True) - - # create cat List - self.catList = self.create_cat_list() - self.scroll_1.add(self.catList) - - # create pkg list - self.pkgList = self.create_pkg_list() - self.scroll_2.add(self.pkgList) - + + # cat and pkg list + self.catList = self.tree.get_widget("catList") + self.pkgList = self.tree.get_widget("pkgList") + self.build_cat_list() + self.build_pkg_list() + # queue list - queueHB = gtk.HBox(False, 0) - - queueScroll = gtk.ScrolledWindow() - queueScroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) - emergeStore = gtk.TreeStore(str,str) - self.emergeView = gtk.TreeView(emergeStore) - cell = gtk.CellRendererText() - col = gtk.TreeViewColumn("Queue", cell, text = 0) - self.emergeView.append_column(col) - col = gtk.TreeViewColumn("Options", cell, markup = 1) - self.emergeView.append_column(col) - self.emergeView.connect("row-activated", self.cb_row_activated, emergeStore) - self.emergeView.connect("button-press-event", self.cb_queue_right_click) - self.emergeView.set_headers_visible(False) - queueScroll.add(self.emergeView) - queueHB.pack_start(queueScroll, True, True) - - # buttons right to the queue list - buttonBox = gtk.VButtonBox() - buttonBox.set_layout(gtk.BUTTONBOX_SPREAD) - queueHB.pack_start(buttonBox, False) - - emergeBtn = gtk.Button() - self.emergeAction.connect_proxy(emergeBtn) - - updateBtn = gtk.Button() - self.updateAction.connect_proxy(updateBtn) + self.queueList = self.tree.get_widget("queueList") + self.build_queue_list() - unmergeBtn = gtk.Button() - self.unmergeAction.connect_proxy(unmergeBtn) - - removeBtn = gtk.Button("_Remove") - removeBtn.connect("clicked", self.cb_remove_clicked) - - buttonBox.pack_start(emergeBtn) - buttonBox.pack_start(unmergeBtn) - buttonBox.pack_start(updateBtn) - buttonBox.pack_start(removeBtn) - # the terminal term = vte.Terminal() term.set_scrollback_lines(1024) @@ -769,129 +598,42 @@ class MainWindow: # XXX why is this not working with the colors term.set_color_background(gtk.gdk.color_parse("white")) term.set_color_foreground(gtk.gdk.color_parse("black")) - termBox = gtk.HBox(False, 0) + termHB = self.tree.get_widget("termHB") termScroll = gtk.VScrollbar(term.get_adjustment()) - termBox.pack_start(term, True, True) - termBox.pack_start(termScroll, False) + termHB.pack_start(term, True, True) + termHB.pack_start(termScroll, False) # notebook - self.notebook = gtk.Notebook() - self.notebook.append_page(queueHB, gtk.Label("Queue")) - self.notebook.append_page(termBox, gtk.Label("Console")) - - vpaned.pack2(self.notebook, shrink = True, resize = True) - - # the status line - self.statusLabel = gtk.Label("Genetic/One - A Portage GUI") - self.statusLabel.set_alignment(0.0,0.7) - self.statusLabel.set_single_line_mode(True) - vb.pack_start(self.statusLabel, False, False) - - # show + self.notebook = self.tree.get_widget("notebook") self.window.show_all() + + # table + self.packageTable = PackageTable(self) + self.packageTable.table.hide_all() # set emerge queue - self.queue = EmergeQueue(console = GtkConsole(term), tree = GtkTree(emergeStore), db = self.db) - - def create_uimanager(self): - """Creates a UIManager holding the menubar and the popups. - @returns: created UIManager - @rtype: gtk.UIManager""" - - ui =""" - - - - - - - - - - - - - - - - - - - - - - """ - - um = gtk.UIManager() - - # menubar - group = gtk.ActionGroup("MenuActions") - group.add_actions([ - ("File", None, "_File"), - ("EmergeMenu", None, "_Emerge"), - ("Help", None, "_?"), - ("Sync", None, "_Sync", None, None, self.cb_sync_clicked), - ("Prefs", None, "_Preferences", None, None, lambda x: PreferenceWindow(self.window, self.cfg)), - ("Reload", None, "_Reload Portage", None, None, self.cb_reload_clicked), - ("Close", None, "_Close", None, None, self.cb_destroy), - ("About", None, "_About", None, None, lambda x: AboutWindow(self.window))]) - # the following actions are defined in __init__, because they are used for buttons too - group.add_action(self.emergeAction) - group.add_action(self.unmergeAction) - group.add_action(self.updateAction) - - um.insert_action_group(group,0) - - # popup - group = gtk.ActionGroup("PopupActions") - group.add_actions([ - ("Oneshot", None, "Oneshot", None, None, self.cb_oneshot_clicked)]) - - um.insert_action_group(group, 1) - - um.add_ui_from_string(ui) - return um + self.queue = EmergeQueue(console = GtkConsole(term), tree = GtkTree(self.queueList.get_model()), db = self.db) - def fill_pkg_store (self, store, name = None): - """Fills a given ListStore with the packages in a category. - - @param store: the store to fill - @type store: gtk.ListStore - @param name: the name of the category - @type name: string - @returns: the filled store - @rtype: gtk.ListStore""" + def show_package (self, *args, **kwargs): + self.packageTable.update(*args, **kwargs) + self.notebook.set_current_page(self.PKG_PAGE) - if name: - for p in self.db.get_cat(name): - store.append([p]) - return store - - def create_pkg_list (self, name = None): - """Creates the package list. - - @param name: name of the selected catetegory - @type name: string - @returns: the filled package list - @rtype: gtk.TreeView""" + def build_queue_list (self): + """Builds the queue list.""" + + store = gtk.TreeStore(str,str) - store = gtk.ListStore(str) - self.fill_pkg_store(store,name) + self.queueList.set_model(store) - # build view - pkgList = gtk.TreeView(store) cell = gtk.CellRendererText() - col = gtk.TreeViewColumn("Packages", cell, text = 0) - pkgList.append_column(col) - pkgList.connect("row-activated", self.cb_row_activated, store) - - return pkgList - - def create_cat_list (self): - """Creates the category list. + col = gtk.TreeViewColumn("Queue", cell, text = 0) + self.queueList.append_column(col) - @returns: created view - @rtype: gtk.TreeView""" + col = gtk.TreeViewColumn("Options", cell, markup = 1) + self.queueList.append_column(col) + + def build_cat_list (self): + """Builds the category list.""" store = gtk.ListStore(str) @@ -901,23 +643,44 @@ class MainWindow: # sort them alphabetically store.set_sort_column_id(0, gtk.SORT_ASCENDING) - view = gtk.TreeView(store) + self.catList.set_model(store) cell = gtk.CellRendererText() col = gtk.TreeViewColumn("Categories", cell, text = 0) - view.append_column(col) - view.connect("cursor-changed", self.cb_cat_list_selection) - view.connect("row-activated", lambda v,p,c : self.cb_cat_list_selection(v)) - view.set_search_column(0) + self.catList.append_column(col) - return view + def build_pkg_list (self, name = None): + """Builds the package list. + + @param name: name of the selected catetegory + @type name: string""" + + store = gtk.ListStore(str) + self.fill_pkg_store(store,name) + + # build view + self.pkgList.set_model(store) + cell = gtk.CellRendererText() + col = gtk.TreeViewColumn("Packages", cell, text = 0) + self.pkgList.append_column(col) + + def fill_pkg_store (self, store, name = None): + """Fills a given ListStore with the packages in a category. + + @param store: the store to fill + @type store: gtk.ListStore + @param name: the name of the category + @type name: string + @returns: the filled store + @rtype: gtk.ListStore""" + + if name: + for p in self.db.get_cat(name): + store.append([p]) + return store def jump_to (self, cp): """Is called when we want to jump to a specific package.""" - PackageWindow(self.window, cp, self.queue) - - def cb_destroy (self, widget, data = None): - """Calls main_quit().""" - gtk.main_quit() + self.show_package(cp, self.queue) def cb_cat_list_selection (self, view): """Callback for a category-list selection. Updates the package list with the packages in the category.""" @@ -930,90 +693,55 @@ class MainWindow: self.fill_pkg_store(self.pkgList.get_model(), self.selCatName) return True - def cb_row_activated (self, view, path, col, store = None): - """Callback for an activated row in the pkgList or in the emergeQueue. Opens a package window.""" - if view == self.pkgList: - package = store.get_value(store.get_iter(path), 0) + def cb_pkg_list_selection (self, view): + """Callback for a package-list selection. Updates the package info.""" + sel = view.get_selection() + store, it = sel.get_selected() + if it: + package = store.get_value(it, 0) if package[-1] == '*': package = package[:-1] - PackageWindow(self.window, self.selCatName+"/"+package, self.queue) - elif view == self.emergeView: - if len(path) > 1: - package = store.get_value(store.get_iter(path), 0) - cat, name, vers, rev = backend.split_package_name(package) - if rev != "r0": vers = vers+"-"+rev - PackageWindow(self.window, cat+"/"+name, queue = self.queue, version = vers, delOnClose = False, doEmerge = False) + self.show_package(self.selCatName+"/"+package, self.queue) return True - def cb_remove_clicked (self, button): - """Removes a selected item in the (un)emerge-queue if possible.""" - selected = self.emergeView.get_selection() - - if selected: - model, iter = selected.get_selected() - - if iter == None: return False - - if not model.iter_parent(iter): # top-level - if model.iter_n_children(iter) > 0: # and has children which can be removed :) - if remove_queue_dialog() == gtk.RESPONSE_YES : - self.queue.remove_children(iter) - self.doUpdate = False - - elif model.iter_parent(model.iter_parent(iter)): # this is in the 3rd level => dependency - remove_deps_dialog() - else: - self.queue.remove_children(iter) # remove children first - self.queue.remove(iter) - self.doUpdate = False - + def cb_row_activated (self, view, path, *args): + """Callback for an activated row in the emergeQueue. Opens a package window.""" + store = view.get_model() + if len(path) > 1: + package = store.get_value(store.get_iter(path), 0) + cat, name, vers, rev = backend.split_package_name(package) + if rev != "r0": vers = vers+"-"+rev + self.show_package(cat+"/"+name, queue = self.queue, version = vers, instantChange = True, doEmerge = False) return True def cb_emerge_clicked (self, action): - """Do emerge or unemerge.""" + """Do emerge.""" - self.notebook.set_current_page(1) + self.notebook.set_current_page(self.CONSOLE_PAGE) - if action == self.emergeAction: - if len(flags.newUseFlags) > 0: - changed_flags_dialog("use flags") - flags.write_use_flags() - - if len(flags.new_masked)>0 or len(flags.new_unmasked)>0 or len(flags.newTesting)>0: - changed_flags_dialog("masking keywords") - flags.write_masked() - flags.write_testing() - backend.reload_settings() - - if not self.doUpdate: - self.queue.emerge(force=True) - else: - self.queue.update_world(force=True, newuse = self.cfg.get_boolean(self.cfg.const["newuse_opt"]), deep = self.cfg.get_boolean(self.cfg.const["deep_opt"])) - self.doUpdate = False + if len(flags.newUseFlags) > 0: + changed_flags_dialog("use flags") + flags.write_use_flags() + + if len(flags.new_masked)>0 or len(flags.new_unmasked)>0 or len(flags.newTesting)>0: + changed_flags_dialog("masking keywords") + flags.write_masked() + flags.write_testing() + backend.reload_settings() - elif action == self.unmergeAction: - self.queue.unmerge(force=True) + if not self.doUpdate: + self.queue.emerge(force=True) + else: + self.queue.update_world(force=True, newuse = self.cfg.get_boolean(self.cfg.const["newuse_opt"]), deep = self.cfg.get_boolean(self.cfg.const["deep_opt"])) + self.doUpdate = False + + def cb_unmerge_clicked (self, button): + """Do unmerge.""" + self.notebook.set_current_page(self.CONSOLE_PAGE) + self.queue.unmerge(force=True) return True - def watch_cursor (func): - """This is a decorator for functions being so time consuming, that it is appropriate to show the watch-cursor. - @attention: this function relies on the gtk.Window-Object being stored as self.window""" - def wrapper (self, *args, **kwargs): - ret = None - def cb_idle(): - try: - ret = func(self, *args, **kwargs) - finally: - self.window.window.set_cursor(None) - return False - - watch = gtk.gdk.Cursor(gtk.gdk.WATCH) - self.window.window.set_cursor(watch) - gobject.idle_add(cb_idle) - return ret - return wrapper - - @watch_cursor + @Window.watch_cursor def cb_update_clicked (self, action): if not backend.am_i_root(): not_root_dialog() @@ -1030,23 +758,47 @@ class MainWindow: if len(updating): self.doUpdate = True return True + def cb_remove_clicked (self, button): + """Removes a selected item in the (un)emerge-queue if possible.""" + selected = self.queueList.get_selection() + + if selected: + model, iter = selected.get_selected() + + if iter == None: return False + + if not model.iter_parent(iter): # top-level + if model.iter_n_children(iter) > 0: # and has children which can be removed :) + if remove_queue_dialog() == gtk.RESPONSE_YES : + self.queue.remove_children(iter) + self.doUpdate = False + + elif model.iter_parent(model.iter_parent(iter)): # this is in the 3rd level => dependency + remove_deps_dialog() + else: + self.queue.remove_children(iter) # remove children first + self.queue.remove(iter) + self.doUpdate = False + + return True + def cb_sync_clicked (self, action): - self.notebook.set_current_page(1) + self.notebook.set_current_page(self.CONSOLE_PAGE) self.queue.sync() - @watch_cursor + @Window.watch_cursor def cb_reload_clicked (self, action): """Reloads the portage settings and the database.""" backend.reload_settings() del self.db self.db = Database() self.db.populate() - - @watch_cursor - def cb_search_clicked (self, button, data = None): + + @Window.watch_cursor + def cb_search_clicked (self, entry): """Do a search.""" - if self.searchEntry.get_text() != "": - packages = backend.find_all_packages(self.searchEntry.get_text(), withVersion = False) + if entry.get_text() != "": + packages = backend.find_all_packages(entry.get_text(), withVersion = False) if packages == []: nothing_found_dialog() @@ -1056,35 +808,48 @@ class MainWindow: else: SearchWindow(self.window, packages, self.jump_to) + def cb_preferences_clicked (self, button): + PreferenceWindow(self.window, self.cfg) + return True + + def cb_about_clicked (self, button): + AboutWindow(self.window) + return True + def cb_queue_right_click (self, queue, event): - if event.button == 3: - x = int(event.x) - y = int(event.y) - time = event.time - pthinfo = queue.get_path_at_pos(x, y) - if pthinfo is not None: - path, col, cellx, celly = pthinfo - queue.grab_focus() - queue.set_cursor(path, col, 0) - self.queuePopup.popup(None, None, None, event.button, time) - return True - else: - return False + pass + # if event.button == 3: + # x = int(event.x) + # y = int(event.y) + # time = event.time + # pthinfo = queue.get_path_at_pos(x, y) + # if pthinfo is not None: + # path, col, cellx, celly = pthinfo + # queue.grab_focus() + # queue.set_cursor(path, col, 0) + # self.queuePopup.popup(None, None, None, event.button, time) + # return True + # else: + # return False def cb_oneshot_clicked (self, action): - sel = self.emergeView.get_selection() - store, it = sel.get_selected() - if it: - package = store.get_value(it, 0) - if not self.cfg.get_local(package, self.cfg.const["oneshot_opt"]): - set = True - else: - set = False - - self.cfg.set_local(package, self.cfg.const["oneshot_opt"], set) - self.queue.append(package, update = True, oneshot = set, forceUpdate = True) - - + pass + # sel = self.queueList.get_selection() + # store, it = sel.get_selected() + # if it: + # package = store.get_value(it, 0) + # if not self.cfg.get_local(package, self.cfg.const["oneshot_opt"]): + # set = True + # else: + # set = False + # + # self.cfg.set_local(package, self.cfg.const["oneshot_opt"], set) + # self.queue.append(package, update = True, oneshot = set, forceUpdate = True) + + def cb_destroy (self, widget): + """Calls main_quit().""" + gtk.main_quit() + def main (self): """Main.""" gobject.threads_init() diff --git a/setup.py b/setup.py index 26796a7..80d4eb5 100644 --- a/setup.py +++ b/setup.py @@ -2,14 +2,13 @@ # -*- coding: utf-8 -*- from distutils.core import setup, Extension - -#thread = Extension("geneticone.modules.geneticthread", sources=["geneticone/modules/geneticthread.c"]) +from geneticone.constants import VERSION, DATA_DIR setup(name="Genetic/One", - version="SVN", + version=VERSION, author="René 'Necoro' Neumann", license="GPLv2", author_email="necoro@necoro.net", packages=["geneticone", "geneticone.gui", "geneticone.backend", "geneticone.gui.gtk"], - #ext_modules=[thread] + data_files={DATA_DIR: ["geneticone/gui/gtk/glade/geneticone.glade"]} ) -- cgit v1.2.3-54-g00ecf