def build(self):
        ## self.set_has_separator(0)

        table = gtk.Table(rows=3, columns=2)
        table.set_border_width(5)
        table.set_col_spacings(5)
        table.set_row_spacings(5)

        label = gtk.Label(_("Service URL"))
        table.attach(label, 0, 1, 0, 1)

        self.url = gtk.Entry()
        table.attach(self.url, 1, 2, 0, 1)

        label = gtk.Label(_("Service type"))
        table.attach(label, 0, 1, 1, 2)

        self.service_type = ServiceTypesOption()
        table.attach(self.service_type, 1, 2, 1, 2)

        label = gtk.Label(_("Registration key"))
        table.attach(label, 0, 1, 2, 3)

        self.key = gtk.Entry()
        table.attach(self.key, 1, 2, 2, 3)

        table.show_all()
        self.vbox.pack_start(table, expand=1, fill=1, padding=12)

        self.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
        self.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK)

    def make_channel_view(self):
        global model

        view = red_thrashingtreeview.TreeView(model)

        def toggle_cb(cr, path, model):
            c = model.get_list_item(int(path))
            model.toggle_subscribed(c)

        toggle = gtk.CellRendererToggle()
        toggle.set_property("activatable", 1)
        col = gtk.TreeViewColumn(_("Subscribed"),
                                 toggle,
                                 active=red_channelmodel.COLUMN_SUBSCRIBED)
        toggle.connect("toggled", toggle_cb, model)
        view.append_column(col)

        col = gtk.TreeViewColumn()
        col.set_title(_("Catalog Name"))
        r1 = gtk.CellRendererPixbuf()
        r2 = gtk.CellRendererText()
        col.pack_start(r1, 0)
        col.pack_start(r2, 0)
        col.set_attributes(r1, pixbuf=red_channelmodel.COLUMN_ICON)
        col.set_attributes(r2, text=red_channelmodel.COLUMN_NAME)
        view.append_column(col)

        return view

def usage():
    print _("Usage: %s <options> ...") % sys.argv[0]
    print
    print _("The following options are understood:")

    opt_list = []

    for r in opt_table:
        opt = "--" + r[1]
        if r[0]:
            opt = "-" + r[0] + ", " + opt
        if r[2]:
            opt = opt + "=<" + r[2] + ">"

        opt_list.append([opt + "  ", r[3]])

    # By appending [0,0], we insure that this will work even if
    # opt_list is empty (which it never should be)
    max_len = apply(max, map(lambda x:len(x[0]), opt_list) + [0,0])

    for opt, desc_str in opt_list:

        if 79 - max_len > 10:
            desc = rcd_util.linebreak(desc_str, 79 - max_len)
        else:
            desc = [desc_str]

        desc_first = desc.pop(0)
        print string.ljust(opt, max_len) + desc_first
        for d in desc:
            print " " * max_len + d

def pkg_action(pkg):

    pending = red_pendingops.get_action(pkg)
    if pending:
        if pending == red_pendingops.TO_BE_INSTALLED \
           or pending == red_pendingops.TO_BE_INSTALLED_CANCELLED:
            if pkg["name_installed"] > 0:
                str = _("upgrade")
            elif pkg["name_installed"] < 0:
                str = "<b>%s</b>" % _("downgrade")
            else:
                str = _("install")
            if pending == red_pendingops.TO_BE_INSTALLED_CANCELLED:
                str = "<s>%s</s>" % str
            return str
        
        elif pending == red_pendingops.TO_BE_REMOVED \
             or pending == red_pendingops.TO_BE_REMOVED_CANCELLED:
            str = _("remove")
            if pending == red_pendingops.TO_BE_REMOVED_CANCELLED:
                str = "<s>%s</s>" % str
            return str
        
        else:
            return "?Unknown?"
    else:
        return ""

        def add_cb(button, this):
            name = this.user_entry.get_text()
            p1 = this.pwd1.get_text()
            p2 = this.pwd2.get_text()

            msg = None
            if not p1:
                msg = _("Password can not be empty.")
            elif p1 != p2:
                msg = _("Passwords do not match.")
            if not re.compile("^\w+$").match(name):
                msg = _("Invalid user name.")
            elif opt.user_name_exists(name):
                msg = _("User '%s' already exists.") % name

            if msg:
                dialog = gtk.MessageDialog(this, gtk.DIALOG_DESTROY_WITH_PARENT,
                                           gtk.MESSAGE_ERROR, gtk.BUTTONS_OK,
                                           msg)
                dialog.run()
                dialog.destroy()
            else:
                user = User(name, p1, ["view"])
                opt.add_user(user)
                this.destroy()

def pkg_type(item):
    s = item.get("type")
    if s == "pkg":
        return _("Package");
    if s == "bundle":
        return _("Bundle");
    return s or _("Unknown")

    def display_license_window(self, licenses):
        dialog = gtk.MessageDialog(self.parent(), 0,
                                   gtk.MESSAGE_INFO,
                                   gtk.BUTTONS_NONE,
                                   _("You must agree to the licenses "
                                     "covering this software before "
                                     "installing it."))

        license_texts = string.join(licenses, "\n" + "#"*79 + "\n")

        text = gtk.TextView()
        text.set_editable(0)
        text.set_cursor_visible(0)
        text.set_wrap_mode(gtk.WRAP_WORD)

        buf = text.get_buffer()
        buf.set_text(license_texts)

        context = text.get_pango_context()
        font_desc = context.get_font_description()
        font_desc.set_family("monospace")

        # Try to estimate the size of the window we want.
        # "W" being the widest glyph.
        s = ("W"*82 + "\n")*20
        layout = pango.Layout(context)
        layout.set_font_description(font_desc)
        layout.set_text(s)
        width, height = layout.get_pixel_size()
        text.set_size_request(width, height)

        # Create a tag with our monospace font
        tag = buf.create_tag()
        tag.set_property("font-desc", font_desc)
        buf.apply_tag(tag, buf.get_start_iter(), buf.get_end_iter())

        # Get a mark to the start of the buffer and then scroll there
        iter = buf.get_start_iter()
        mark = buf.create_mark("start", iter, left_gravity=1)
        text.scroll_to_mark(mark, 0.0)

        sw = gtk.ScrolledWindow()
        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        sw.set_shadow_type(gtk.SHADOW_IN)
        sw.add(text)
        sw.show_all()
        dialog.vbox.pack_start(sw, expand=1, fill=1)

        dialog.add_button(_("I Agree"), gtk.RESPONSE_OK)
        dialog.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)

        gtk.threads_enter()
        response = dialog.run()
        dialog.destroy()
        gtk.threads_leave()
        if response != gtk.RESPONSE_OK:
            self.pop()
            return 0

        return 1

    def __init__(self):
        red_extra.ListView.__init__(self)
        self.store = gtk.ListStore(gtk.gdk.Pixbuf.__gtype__,
                                   gobject.TYPE_STRING,
                                   gobject.TYPE_STRING, gobject.TYPE_STRING,
                                   gobject.TYPE_STRING)
        self.set_model(self.store)
        self.row = 0

        sel = self.get_selection()
        sel.set_mode(gtk.SELECTION_NONE)

        col = gtk.TreeViewColumn(_("Catalog"), gtk.CellRendererPixbuf(), pixbuf=0)
        self.append_column(col)

        col = gtk.TreeViewColumn(_("Package"), gtk.CellRendererText(), markup=1)
        self.append_column(col)
        
        col = gtk.TreeViewColumn(_("Current Version"), gtk.CellRendererText(), markup=3)
        self.append_column(col)

        col = gtk.TreeViewColumn(_("New Version"), gtk.CellRendererText(), markup=2)
        self.append_column(col)
        
        col = gtk.TreeViewColumn(_("Size"), gtk.CellRendererText(), markup=4)
        self.append_column(col)

    def build(self, model):
        view = red_thrashingtreeview.TreeView(model)
        view.set_rules_hint(1)

        cols = [(_("Time"),        COLUMN_TIME),
                (_("Action"),      COLUMN_ACTION),
                (_("User"),        COLUMN_USER),
                (_("Old Version"), COLUMN_PKG_INITIAL),
                (_("New Version"), COLUMN_PKG_FINAL)]

        for label, id in cols:
            col = gtk.TreeViewColumn(label,
                                     gtk.CellRendererText(),
                                     text=id)
            view.add_column(col,
                            title=label,
                            initially_visible=1,
                            sort_id=id)

        view.sort_by(COLUMN_TIME)
        view.show_all()

        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        self.set_shadow_type(gtk.SHADOW_IN)
        self.add(view)
        self.view = view

    def __init__(self, mirrors):
        gobject.GObject.__init__(self)
        self.__mirrors = mirrors

        sel = self.get_selection()
        sel.set_mode(gtk.SELECTION_NONE)

        self.__store = MirrorsStore(mirrors)
        self.set_model(self.__store)

        def toggle_cb(cr, path, view):
            model = view.get_model()
            n = int(path)
            model.select(n)
            self.emit("selected_mirror", self.__mirrors[n])
            
        toggle = gtk.CellRendererToggle()
        toggle.set_property("activatable", 1)
        toggle.connect("toggled", toggle_cb, self)
        col = gtk.TreeViewColumn("",
                                 toggle,
                                 active=0);
        self.append_column(col)

        col = gtk.TreeViewColumn(_("Mirror"),
                                 gtk.CellRendererText(),
                                 text=1)
        self.append_column(col)

        col = gtk.TreeViewColumn(_("Location"),
                                 gtk.CellRendererText(),
                                 text=2)
        self.append_column(col)

    def __assemble_status_option(self):
        def uninstalled_cb():
            return ("installed", "is", "false")

        def installed_cb():
            return ("installed", "is", "true")

        def all_cb():
            return None

        status_types = (
            (_("All Bundles"), all_cb),
            (_("Uninstalled Bundles"), uninstalled_cb),
            (_("Installed Bundles"), installed_cb),
        )

        menu = gtk.Menu()
        for name, filter_fn in status_types:
            mi = gtk.MenuItem(name)

            def set_cb(x, sbox, fn):
                sbox.__status_filter = fn
                sbox.__changed()

            mi.connect("activate", set_cb, self, filter_fn)
            mi.show()
            menu.append(mi)
        menu.show()

        opt = gtk.OptionMenu()
        opt.set_menu(menu)

        self.__status_filter = all_cb

        return opt

    def update_label(self):
        msg_list = []

        ins_count = red_pendingops.pending_install_count()
        if ins_count:
            if ins_count == 1:
                msg = _("%d pending install") % ins_count
            else:
                msg = _("%d pending installs") % ins_count
            msg_list.append(msg)

        rem_count = red_pendingops.pending_remove_count()
        if rem_count:
            if rem_count == 1:
                msg = _("%d pending removal") % rem_count
            else:
                msg = _("%d pending removals") % rem_count
            msg_list.append(msg)

        if not msg_list:
            msg_list.append(_("No pending actions"))

        msg = string.join(msg_list, "\n")

        for i in range(len(msg_list) - 2, 0):
            msg += "\n"

        self.label.set_text(msg)

    def __init__(self):

        gtk.Dialog.__init__(self, _("Unmount Catalog"))

        self.set_default_size(300, 300)

        model = red_channelmodel.ChannelModel(filter_fn=lambda x:x.get("mounted", 0))

        channels_to_unmount = {}
        for c in model.get_all():
            channels_to_unmount[c["id"]] = 0

        umount_col = model.add_column(lambda x:channels_to_unmount[x["id"]],
                                      gobject.TYPE_BOOLEAN)

        view = red_thrashingtreeview.TreeView(model)

        r = gtk.CellRendererText()
        col = gtk.TreeViewColumn(_("Catalog"), r, text=COLUMN_NAME)
        view.append_column(col)

        def toggle_cb(cr, path, mod):
            def set_cb(m, p):
                c = m.get_list_item(int(p))
                channels_to_unmount[c["id"]] = not channels_to_unmount[c["id"]]
            mod.changed(set_cb, path)

        r = gtk.CellRendererToggle()
        r.set_property("activatable", 1)
        r.set_property("xalign", 0.0)
        r.connect("toggled", toggle_cb, model)
        col = gtk.TreeViewColumn(_("Unmount?"), r, active=umount_col)
        view.append_column(col)

        view.show()

        sw = gtk.ScrolledWindow()
        sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        sw.set_shadow_type(gtk.SHADOW_IN)
        sw.show()

        sw.add(view)
        self.vbox.pack_start(sw)

        b = self.add_button(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)
        b.connect("clicked", lambda x,y:y.destroy(), self)

        b = self.add_button(gtk.STOCK_OK, gtk.RESPONSE_OK)
        b.grab_default()
        def ok_clicked_cb(b, w, s):
            for cid in s:
                if s[cid]:
                    unmount_channel(cid)
            
            w.destroy()

        b.connect("clicked", ok_clicked_cb, self, channels_to_unmount)

def pkg_status(pkg):

    if pkg["installed"]:
        return _("installed")
    elif pkg["name_installed"] > 0: # upgrade
        return _("newer")
    elif pkg["name_installed"] < 0:
        return _("older")
    else:
        return _("not installed")

    def set_bundles(self, bundles, quiet=0):
        if not quiet:
            if len(bundles) > 1:
                msg = _("Found %d matching bundles") % len(bundles)
            elif len(bundles) == 1:
                msg = _("Found 1 matching bundle")
            else:
                msg = _("No matching bundles found")
            self.message_push(msg, transient=1)

        BundlesFromDaemon.set_bundles(self, bundles)

 def set_packages(self, patches, quiet=0):
     if not quiet:
         if len(patches) > 1:
             msg = _("Found %d matching patches") % len(patches)
         elif len(patches) == 1:
             msg = _("Found 1 matching patch")
         else:
             msg = _("No matching patches found")
         self.message_push(msg, transient=1)
         
     PackagesFromDaemon.set_packages(self, patches)

    def __init__(self, opt):
        gtk.ScrolledWindow.__init__(self)

        model = PrivilegesModel(opt)

        view = red_thrashingtreeview.TreeView()
        view.set_model(model)
        view.set_headers_visible(0)

        col = gtk.TreeViewColumn(_("Privilege"),
                                 gtk.CellRendererText(),
                                 text=PRIVILEGE_COLUMN_PRIVILEGE)
        view.append_column(col)

        def activated_cb(renderer, path, model):
            path = (int(path),)
            privilege = model.get_list_item(path[0])
            user = opt.get_selected_user()
            if user:
                current_user = rcd_util.get_current_user()
                if user.name_get() == current_user and privilege == "superuser":
                    # Warn the user about removing their own superuser priv
                    dialog = gtk.MessageDialog(None,
                                               0,
                                               gtk.MESSAGE_WARNING,
                                               gtk.BUTTONS_YES_NO,
                                               _("If you remove superuser "
                                               "privileges from yourself, you "
                                               "will be unable to re-add them."
                                               "\n\n"
                                               "Are you sure you want to do "
                                               "this?"))
                    response = dialog.run()
                    dialog.destroy()
                    if response == gtk.RESPONSE_NO or response == gtk.RESPONSE_DELETE_EVENT:
                        return

                # We want opposite state
                active = not renderer.get_active()
                user.privilege_set(privilege, active)

        r = gtk.CellRendererToggle()
        r.set_property("activatable", 1)
        r.connect("toggled", activated_cb, model)
        col = gtk.TreeViewColumn(_("Enabled"),
                                 r, active=PRIVILEGE_COLUMN_ENABLED)
        view.append_column(col)

        view.show_all()

        self.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        self.set_shadow_type(gtk.SHADOW_IN)
        self.add(view)

        def activate_finished_cb(worker, this):
            if worker.is_cancelled():
                return

            try:
                worker.get_result()
            except ximian_xmlrpclib.Fault, f:
                rcd_util.dialog_from_fault(f,
                                           error_text=_("Unable to activate"),
                                           additional_text=_("Please ensure "
                                           "you typed the email address "
                                           "and registration code correctly"),
                                           parent=self)
                return

 def download_pending_cb(th, pv):
     pv.__working_query = 0
     pending = th.get_result()
     pv.update_from_pending(pending)
     pv.update_total(pending["percent_complete"] * DOWNLOAD_MULTIPLIER)
     if pending["status"] == "finished":
         pv.download_complete = 1
         pv.update_fill()
     elif pending["status"] == "failed":
         pv.download_complete = 1
         pv.__finished = 1
         msg = _("Download Failed") + ":\n"                
         msg += pending.get("error_msg", _("Unknown Error"))
         pv.transaction_finished(msg)

    def assemble_actionbar(self, bar):

        bar.install = bar.add(text=_("Mark for _Installation"),
                              tooltip=_("Mark selected packages for installation"),
                              pixbuf=red_pixbuf.get_pixbuf("to-be-installed"),
                              sensitive_fn=self.install_sensitive_cb,
                              callback=lambda x:self.set_package_action_cb(red_pendingops.TO_BE_INSTALLED))

        bar.remove = bar.add(text=_("Mark for _Removal"),
                             tooltip=_("Mark selected packages for removal"),
                             pixbuf=red_pixbuf.get_pixbuf("to-be-removed"),
                             sensitive_fn=self.remove_sensitive_cb,
                             callback=lambda x:self.set_package_action_cb(red_pendingops.TO_BE_REMOVED))

        bar.cancel = bar.add(text=_("_Cancel"),
                             tooltip=_("Cancel marked package actions"),
                             stock=gtk.STOCK_CANCEL,
                             sensitive_fn=self.cancel_sensitive_cb,
                             callback=lambda x:self.set_package_action_cb(red_pendingops.NO_ACTION))

        bar.info = bar.add(text=_("I_nformation"),
                           tooltip=_("Package information"),
                           pixbuf=red_pixbuf.get_pixbuf("info"),
                           sensitive_fn=self.info_sensitive_cb,
                           callback=lambda x:self.package_info_cb())