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 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 __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 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 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_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 __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 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 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 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 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 pkg_type(item):
s = item.get("type")
if s == "pkg":
return _("Package");
if s == "bundle":
return _("Bundle");
return s or _("Unknown")
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_type(item):
s = item.get("type")
if s == "pkg":
return _("Package")
if s == "bundle":
return _("Bundle")
return s or _("Unknown")
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 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 __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 __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 __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 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 __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 __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 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())
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())
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 build_verified_ok_page(self):
page = self.page
box = gtk.HBox(0, 0)
box.pack_start(gtk.Label(""), expand=1, fill=1)
img = red_pixbuf.get_widget("verify")
box.pack_start(img, expand=0, fill=1, padding=4)
msg1 = "<span size=\"large\"><b>%s</b></span>" \
% _("System Verified")
msg2 = _("All package dependencies are satisfied, and no corrective actions are required.")
msg = msg1+"\n"+string.join(rcd_util.linebreak(msg2, width=30), "\n")
label = gtk.Label("")
label.set_markup(msg)
box.pack_start(label, expand=0, fill=1, padding=4)
box.pack_start(gtk.Label(""), expand=1, fill=1)
frame = gtk.Frame(None)
frame.add(box)
bg = gtk.EventBox()
style = bg.get_style().copy()
color = bg.get_colormap().alloc_color("white")
style.bg[gtk.STATE_NORMAL] = color
bg.set_style(style)
bg.add(frame)
page.pack_start(bg, expand=1, fill=1)
buttons = gtk.HButtonBox()
buttons.set_layout(gtk.BUTTONBOX_END)
button = gtk.Button(gtk.STOCK_OK)
button.set_use_stock(1)
buttons.add(button)
page.pack_end(buttons, 0, 0, 0)
button.set_flags(gtk.CAN_DEFAULT)
button.grab_default()
button.connect("clicked", lambda x:self.pop())
page.show_all()
def update_pending_cb(pending, step_pending, pv):
if pv.__finished:
return
if pending and pending["messages"]:
msg = rcd_util.transaction_status(pending["messages"][-1])
pv.set_label(msg)
if step_pending:
if step_pending["status"] == "running":
pv.update_from_pending(step_pending, show_rate=0)
else:
pv.update_pulse()
if pending:
if pv.download_complete:
percent = DOWNLOAD_MULTIPLIER * 100 + \
pending["percent_complete"] * (1 - DOWNLOAD_MULTIPLIER)
else:
percent = pending["percent_complete"]
if step_pending \
and pending.has_key("total_size"):
slice = 1.0 / pending["total_size"]
if pv.download_complete:
slice *= 1 - DOWNLOAD_MULTIPLIER
percent += slice * step_pending["percent_complete"]
# We don't get step_pending notification every time, but
# we never want to reduce the total progress bar
if percent > self.total_percent:
pv.update_total(percent)
self.total_percent = percent
if pending and pending["status"] == "finished":
red_pendingops.clear_packages_with_actions()
pv.transaction_finished(msg=_("The transaction has " \
"completed successfully"))
self.update_total(100)
pv.__finished = 1
elif pending and pending["status"] == "failed":
msg = _("Transaction failed") + ":\n" + pending["error_msg"]
pv.transaction_finished(msg,
title=_("Transaction Failed"))
pv.__finished = 1
if pending and step_pending:
pv.__working_query = 0
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 update_pending_cb(pending, step_pending, pv):
if pv.__finished:
return
if pending and pending["messages"]:
msg = rcd_util.transaction_status(pending["messages"][-1])
pv.set_label(msg)
if step_pending:
if step_pending["status"] == "running":
pv.update_from_pending(step_pending, show_rate=0)
else:
pv.update_pulse()
if pending:
if pv.download_complete:
percent = DOWNLOAD_MULTIPLIER * 100 + \
pending["percent_complete"] * (1 - DOWNLOAD_MULTIPLIER)
else:
percent = pending["percent_complete"]
if step_pending \
and pending.has_key("total_size"):
slice = 1.0 / pending["total_size"]
if pv.download_complete:
slice *= 1 - DOWNLOAD_MULTIPLIER
percent += slice * step_pending["percent_complete"]
# We don't get step_pending notification every time, but
# we never want to reduce the total progress bar
if percent > self.total_percent:
pv.update_total(percent)
self.total_percent = percent
if pending and pending["status"] == "finished":
red_pendingops.clear_packages_with_actions()
pv.transaction_finished(msg=_("The transaction has " \
"completed successfully"))
self.update_total(100)
pv.__finished = 1
elif pending and pending["status"] == "failed":
msg = _("Transaction failed") + ":\n" + pending["error_msg"]
pv.transaction_finished(msg, title=_("Transaction Failed"))
pv.__finished = 1
if pending and step_pending:
pv.__working_query = 0
def transaction_finished(self, msg, title=_("Transaction Finished")):
self.finished()
self.switch_cancel_button_to_ok()
self.set_title(title)
self.set_label(msg)
self.step_label.set_selectable(1)
self.update_fill()
def update_download(self):
if self.__working_query:
return
self.step_label.set_text(_("Downloading packages"))
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)
serv = rcd_util.get_server_proxy()
th = serv.rcd.system.poll_pending(self.download_id)
th.connect("ready", download_pending_cb, self)
self.__working_query = 1
def select_and_dump(parent):
def filesel_destroy(app):
if getattr(app, "__filesel", None):
app.__filesel.destroy()
app.__filesel = None
def get_file_cb(button, parent):
filename = parent.__filesel.get_filename()
if filename:
dump_xml(filename)
filesel_destroy(parent)
# We only allow one filesel window at a time
if getattr(parent, "__filesel", None):
parent.__filesel.present()
return
filesel = gtk.FileSelection(_("Choose file to write XML to"))
filesel.set_filename(os.environ.get("HOME", "") + "/") # need trailing /
filesel.ok_button.connect("clicked", get_file_cb, parent)
filesel.cancel_button.connect("clicked", lambda x,y:filesel_destroy(y), parent)
filesel.set_transient_for(parent)
filesel.show()
parent.__filesel = filesel
def __init__(self, download_id, transact_id, step_id, parent=None):
PendingView.__init__(self,
_("Updating System"),
allow_cancel=1,
parent=parent,
total_progress_bar=1)
self.download_id = download_id
self.transact_id = transact_id
self.step_id = step_id
self.download_complete = 0
self.__working_query = 0
self.__finished = 0
self.total_percent = 0
self.iconified = 0
self.connect("window-state-event",
lambda x, y: x.window_state_event_cb(y))
self.set_icons(
("spinning-rupert-1", "spinning-rupert-2", "spinning-rupert-3"))
red_serverlistener.freeze_polling()
self.start_polling() # this is a different kind of polling
def append_status_column(self,
column_title=_("Status"),
show_status_icon=1,
show_status_name=1):
col = gtk.TreeViewColumn()
col.set_title(column_title)
if show_status_icon:
render_icon = gtk.CellRendererPixbuf()
expand = not show_status_name
col.pack_start(render_icon, expand)
col.set_attributes(render_icon,
pixbuf=red_packagearray.COLUMN_STATUS_ICON)
render_icon.set_property("xalign", 0.5)
if show_status_name:
render_text = gtk.CellRendererText()
col.pack_start(render_text, 0)
col.set_attributes(render_text,
markup=red_packagearray.COLUMN_STATUS)
self.add_column(col,
title=column_title,
initially_visible=1,
sort_id=red_packagearray.COLUMN_STATUS
)
return col
def show_daemon_dialog_real():
dialog = gtk.MessageDialog(None, 0, gtk.MESSAGE_ERROR, gtk.BUTTONS_NONE,
_("Lost contact with the daemon!"))
dialog.add_button(_("Exit Red Carpet"), 1)
dialog.set_modal(1)
def dialog_response_cb(dialog, val):
gtk.mainquit()
dialog.connect("response", dialog_response_cb)
dialog.show_all()
gtk.timeout_add(500, wait_for_server_cb, dialog)
return 0
def __init__(self):
gtk.Dialog.__init__(self, red_main.get_title())
b = self.add_button(gtk.STOCK_OK, gtk.RESPONSE_CLOSE)
b.connect("clicked", lambda b, w: w.destroy(), self)
hbox = gtk.HBox(spacing=6)
self.vbox.pack_start(hbox, padding=6)
vbox = gtk.VBox(spacing=2)
hbox.pack_start(vbox, padding=6)
title = gtk.Label("")
title.set_alignment(0.0, 0.5)
title.set_markup('<span size="xx-large"><b>%s</b></span>' %
red_main.red_name)
vbox.pack_start(title)
copyright = gtk.Label(red_main.red_copyright.encode("utf-8"))
copyright.set_alignment(0.0, 0.5)
vbox.pack_start(copyright)
license = gtk.Label(
_("Licensed under the GNU "
"General Public License, version 2"))
license.set_alignment(0.0, 0.5)
vbox.pack_start(license)
self.vbox.show_all()
def append_name_column(self,
column_title=_("Package"),
show_channel_icon=0,
show_section_icon=0):
col = gtk.TreeViewColumn()
col.set_title(column_title)
if show_channel_icon:
render_icon = gtk.CellRendererPixbuf()
col.pack_start(render_icon, 0)
col.set_attributes(render_icon,
pixbuf=red_packagearray.COLUMN_CH_ICON)
if show_section_icon:
render_icon = gtk.CellRendererPixbuf()
col.pack_start(render_icon, 0)
col.set_attributes(render_icon,
pixbuf=red_packagearray.COLUMN_SEC_ICON)
render_text = gtk.CellRendererText()
col.pack_start(render_text, 1)
col.set_attributes(render_text, text=red_packagearray.COLUMN_NAME)
self.add_column(col,
title=column_title,
initially_visible=1,
sort_id=red_packagearray.COLUMN_NAME
)
return col
def update_frame_label(ud, u, frame):
if u:
label = _("Set %s's password") % u.name_get()
else:
label = ""
frame.set_label(label)
def __init__(self):
self.__pending_messages = []
self.__pending_handler = 0
img = red_pixbuf.get_widget("console")
box = gtk.HBox(0, 0)
box.pack_start(img, expand=0, fill=0, padding=3)
box.pack_start(gtk.VSeparator(), expand=0, fill=1, padding=3)
self.textview = gtk.TextView()
self.textview.set_editable(0)
self.textview.set_cursor_visible(0)
self.textview.set_size_request(300, 200)
self.scrolled = gtk.ScrolledWindow()
self.scrolled.add(self.textview)
self.scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
box.pack_start(self.scrolled, expand=1, fill=1)
self.window = gtk.Dialog()
self.window.set_title(_("ZENworks Error Console"))
self.window.add_button(gtk.STOCK_OK, gtk.RESPONSE_CLOSE)
self.window.vbox.add(box)
self.window.connect("response", lambda d, x: d.hide())
def update_frame_label(ud, u, frame):
if u:
label = _("Set %s's password") % u.name_get()
else:
label = ""
frame.set_label(label)
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)
def show_package_info(pkg, parent=None):
key = rcd_util.get_package_key(pkg)
if package_infos.has_key(key):
dialog = package_infos[key]
dialog.present()
return
book = PackageBook()
book.set_tab_pos(gtk.POS_TOP)
book.add_page(red_packagepage_info.PackagePage_Info())
if rcd_util.get_package_type(pkg) == rcd_util.PACKAGE_TYPE_PACKAGE:
book.add_page(red_packagepage.PackagePage_History())
book.add_page(red_packagepage_deps.PackagePage_Deps())
book.set_package(pkg)
title = _("Package Information") + ": " + pkg["name"]
dialog = gtk.Dialog(title, parent=parent)
dialog.set_default_size(450, 350)
button = dialog.add_button(gtk.STOCK_CLOSE, 0)
# grab_default() is not sufficient here.
button.grab_focus()
dialog.connect("response", lambda d, code: d.destroy())
dialog.vbox.add(book)
def destroy_cb(dialog, key):
del package_infos[key]
package_infos[key] = dialog
dialog.connect("destroy", destroy_cb, key)
book.show_all()
dialog.show_all()
def add_column(self, column, sort_id=None, title=None, widget=None, initially_visible=0, resizable=1):
if not title and not widget:
title = _("Untitled")
self.__column_info[column] = {
"title": title,
"widget": widget,
"visible": initially_visible,
"sort_id": sort_id,
}
self.__column_order.append(column)
if title:
column.set_title(title)
column.set_alignment(0.0)
if widget:
column.set_widget(widget)
column.set_alignment(0.5)
if resizable:
column.set_resizable(1)
column.set_visible(initially_visible)
self.append_column(column)
model = self.get_model()
if sort_id and model.can_sort(sort_id):
column.data_id = sort_id
column.connect("clicked", lambda x, y, z: y.sort_by(z), self, sort_id)
column.set_clickable(1)
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)
def update_download(self):
if self.__working_query:
return
self.step_label.set_text(_("Downloading packages"))
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)
serv = rcd_util.get_server_proxy()
th = serv.rcd.system.poll_pending(self.download_id)
th.connect("ready", download_pending_cb, self)
self.__working_query = 1
def add_status_column(self,
column_title=_("Status"),
show_status_icon=1,
show_status_name=1):
col = gtk.TreeViewColumn()
col.set_title(column_title)
if show_status_icon:
render_icon = gtk.CellRendererPixbuf()
expand = not show_status_name
col.pack_start(render_icon, expand)
col.set_attributes(render_icon,
pixbuf=red_bundlearray.COLUMN_STATUS_ICON)
render_icon.set_property("xalign", 0.5)
if show_status_name:
render_text = gtk.CellRendererText()
col.pack_start(render_text, 0)
col.set_attributes(render_text,
markup=red_bundlearray.COLUMN_STATUS)
self.add_column(col,
title=column_title,
initially_visible=1,
sort_id=red_bundlearray.COLUMN_STATUS)
return col
