MINI SHELL

import os, sys, rpm
import string
import time

import gtk
import gtk.glade
import gobject

import yum
import yum.Errors
import repomd.mdErrors as mdErrors
from yum.constants import *

from pirut.constants import *

I18N_DOMAIN = "pirut"

if os.access("data/PackageList.glade", os.R_OK):
    gladefn = "data/PackageList.glade"
else:
    gladefn = "/usr/share/pirut/ui/PackageList.glade"

PO_COLUMN = 0
PO_SELECTED_COLUMN = 1
PO_PIX_COLUMN = 2
PO_DISPLAYSTR_COLUMN = 3
PO_PKGTYPE_COLUMN = 4

if os.access("data/remove.png", os.R_OK):
    removepb = gtk.gdk.pixbuf_new_from_file("data/remove.png")
else:
    removepb = gtk.gdk.pixbuf_new_from_file(PIRUTPIX + "remove.png")

if os.access("data/install.png", os.R_OK):
    installpb = gtk.gdk.pixbuf_new_from_file("data/install.png")
else:
    installpb = gtk.gdk.pixbuf_new_from_file(PIRUTPIX + "install.png")

if os.access("data/installed.png", os.R_OK):
    installedpb = gtk.gdk.pixbuf_new_from_file("data/installed.png")
else:
    installedpb = gtk.gdk.pixbuf_new_from_file(PIRUTPIX + "installed.png")
installedpix = (installedpb, installpb)
removepix = (removepb,)

class PirutPackageList(gtk.VBox):
    __gsignals__ = {
        'changed': (gobject.SIGNAL_RUN_FIRST, gobject.TYPE_NONE,
                    (gobject.TYPE_PYOBJECT,))
    }
    
    def __init__(self, yumobj):
        gtk.VBox.__init__(self)
        self.ayum = yumobj
        self.xml = gtk.glade.XML(gladefn, domain=I18N_DOMAIN,
                                 root = "packageListBox")
        w = self.xml.get_widget("packageListBox")
        self.add(w)
        self._showPackageType = SHOW_ALL

        self._createPackageStore(self.xml.get_widget("packageListTree"))

        sigs = {"on_allRadioButton_toggled": self._showAllPackages,
                "on_installedRadioButton_toggled": self._showInstalledPackages,
                "on_availableRadioButton_toggled": self._showAvailablePackages}
        self.xml.signal_autoconnect(sigs)

        # reset the radio button to what it was last
        if self._showPackageType == SHOW_ALL:
            self.xml.get_widget("allRadioButton").set_active(True)
        elif self._showPackageType == SHOW_INSTALLED:
            self.xml.get_widget("installedRadioButton").set_active(True)
        elif self._showPackageType == SHOW_AVAIL:
            self.xml.get_widget("availableRadioButton").set_active(True)

        self.pkgFilter = None
        self.show()

    def addPackage(self, po, type = SHOW_AVAIL):
        desc = po.returnSimple('summary').replace("\n", "")
        desc = gobject.markup_escape_text(desc)

        if apply(self.ayum.tsInfo.matchNaevr, po.returnPackageTuple()):
            if type == SHOW_INSTALLED:
                pix = removepb
            else:
                pix = installpb
        elif type == SHOW_INSTALLED:
            pix = installedpb
        else:
            pix = None

        self.pkgStore.append([po, pix in installedpix, pix,
                              "<b>%s</b> - %s" %(po, desc), type])

    def doneAdding(self):
        # XXX this is a hack, but we want to do the filter/sort after
        # adding everything to make the time more reasonable
        self.sortedStore = gtk.TreeModelSort(self.pkgStore)
        self.sortedStore.set_sort_column_id(PO_DISPLAYSTR_COLUMN,
                                            gtk.SORT_ASCENDING)
        self.pkgFilter = self.sortedStore.filter_new()
        self.pkgFilter.set_visible_func(self.__filter_package_list)

        tree = self.xml.get_widget("packageListTree")        
        tree.set_model(self.pkgFilter)

    def clear(self):
        self.pkgStore.clear()

    def grab_focus(self):
        self.xml.get_widget("packageListTree").grab_focus()

    def __search_pkgs(self, model, col, key, i):
        val = model.get_value(i, PO_COLUMN).returnSimple('name')
        if val.lower().startswith(key.lower()):
            return False
        return True

    def __filter_package_list(self, model, i):
        if self._showPackageType == SHOW_ALL:
            return True
        elif self._showPackageType != model.get_value(i, PO_PKGTYPE_COLUMN):
            return False
        return True

    def _createPackageStore(self, tree):
        self.pkgStore = gtk.ListStore(gobject.TYPE_PYOBJECT,
                                      gobject.TYPE_BOOLEAN,
                                      gobject.TYPE_OBJECT,
                                      gobject.TYPE_STRING,
                                      gobject.TYPE_INT)

        column = gtk.TreeViewColumn(None, None)
        pixr = gtk.CellRendererPixbuf()
        column.pack_start(pixr, False)
        column.add_attribute(pixr, 'pixbuf', PO_PIX_COLUMN)
        tree.append_column(column)

        column = gtk.TreeViewColumn(None, None)
        cbr = gtk.CellRendererToggle()
        column.pack_start(cbr, False)
        column.add_attribute(cbr, 'active', PO_SELECTED_COLUMN)
        cbr.connect("toggled", self._packageToggled)
        tree.append_column(column)

        column = gtk.TreeViewColumn(None, None)
        txtr = gtk.CellRendererText()
        column.pack_start(txtr, False)
        column.add_attribute(txtr, 'markup', 3)
        tree.append_column(column)

        tree.set_search_equal_func(self.__search_pkgs)

        selection = tree.get_selection()
        selection.connect('changed', self._packageSelected)

    def _packageSelected(self, selection):
        (model, i) = selection.get_selected()
        if not i:
            po = None
        else:
            po = model.get_value(i, PO_COLUMN)
        self.emit('changed', po)
        
    def _packageToggled(self, widget, path):
        newpath = self.pkgFilter.convert_path_to_child_path(path)
        newpath = self.sortedStore.convert_path_to_child_path(newpath)        
        i = self.pkgStore.get_iter(newpath)
        po = self.pkgStore.get_value(i, PO_COLUMN)
        cb = self.pkgStore.get_value(i, PO_SELECTED_COLUMN)
        pkgtup = po.returnPackageTuple()
        if cb and po.repoid == "installed":
            self.ayum.remove(po)
            self.pkgStore.set_value(i, PO_PIX_COLUMN, removepb)
        elif cb:
            self.ayum.tsInfo.remove(pkgtup)
            self.pkgStore.set_value(i, PO_PIX_COLUMN, None)
        elif po.repoid == "installed":
            self.ayum.tsInfo.remove(pkgtup)
            self.pkgStore.set_value(i, PO_PIX_COLUMN, installedpb)
        else:
            self.ayum.install(po)
            self.pkgStore.set_value(i, PO_PIX_COLUMN, installpb)
        self.pkgStore.set_value(i, PO_SELECTED_COLUMN, not cb)

    def _showAllPackages(self, w):
        if not w.get_active():
            return
        self._showPackageType = SHOW_ALL
        if self.pkgFilter: gobject.idle_add(self.pkgFilter.refilter)        

    def _showInstalledPackages(self, w):
        if not w.get_active():
            return
        self._showPackageType = SHOW_INSTALLED
        if self.pkgFilter: gobject.idle_add(self.pkgFilter.refilter)        

    def _showAvailablePackages(self, w):
        if not w.get_active():
            return
        self._showPackageType = SHOW_AVAIL
        if self.pkgFilter: gobject.idle_add(self.pkgFilter.refilter)

gobject.type_register(PirutPackageList)


class PackageListTester(yum.YumBase):
    def __init__(self):
        yum.YumBase.__init__(self)
        self.doConfigSetup()
        self.doPluginSetup(types=(yum.plugins.TYPE_CORE,))
        self.closeRpmDB()
        self.doTsSetup()
        self.doRpmDBSetup()
        self.doRepoSetup()
        self.doSackSetup()

        self.window = gtk.Window()
        self.window.connect("destroy", self._quit)

        self.plist = PirutPackageList(self)
        self.window.add(self.plist)

    def simpleDBInstalled(self, name):
        # FIXME: doing this directly instead of using self.rpmdb.installed()
        # speeds things up by 400%
        mi = self.ts.ts.dbMatch('name', name)
        if mi.count() > 0:
            return True
        return False

    def isPackageInstalled(self, pkgname):
        # FIXME: this sucks.  we should probably suck it into yum proper
        # but it'll need a bit of cleanup first.  
        installed = False
        if self.rpmdb.installed(name = pkgname):
            installed = True
            
        lst = self.tsInfo.matchNaevr(name = pkgname)
        for txmbr in lst:
            if txmbr.po.state in TS_INSTALL_STATES:
                return True
        if installed and len(lst) > 0:
            # if we get here, then it was installed, but it's in the tsInfo
            # for an erase or obsoleted --> not going to be installed at end
            return False
        return installed

    def errorlog(self, level, msg):
        if level <= 0:
            print >> sys.stderr, "ERROR:", msg
        else:
            print >> sys.stderr, "WARNING:", msg

    def log(self, level, msg):
        if level <= 0:
            print >> sys.stderr, "LOG:", msg

    def _quit(self, *args):
        sys.exit(0)

    def run(self):
        from yum.packages import YumInstalledPackage

        pos = self.pkgSack.returnNewestByNameArch()
        for po in pos:
            if self.simpleDBInstalled(po.returnSimple('name')):
                continue
            self.plist.addPackage(po, SHOW_AVAIL)
        for hdr in self.rpmdb.getHdrList():
            po = YumInstalledPackage(hdr)
            self.plist.addPackage(po, SHOW_INSTALLED)
        self.plist.doneAdding()

        self.window.show()
        gtk.main()

if __name__ == "__main__":
    w = PackageListTester()
    w.run()