NuKVM/virt-manager
3
0
Fork 0
mirror of https://github.com/virt-manager/virt-manager.git synced 2025-02-25 18:55:27 -06:00
Code Issues Packages Projects Releases Wiki Activity

Add a smaller helper for self.window.get_widget

Browse Source 
Saves us from having crazy long lines in a few places, and less characters
to type!
This commit is contained in:
Cole Robinson 2011-07-14 13:13:13 -04:00
parent 25f5bc90a7
commit a84d10cee8
19 changed files with 1277 additions and 1303 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

292
src/virtManager/addhardware.py
View File

@ -107,21 +107,21 @@ class vmmAddHardware(vmmGObjectUI):
self.bind_escape_key_close()
# XXX: Help docs useless/out of date
self.window.get_widget("create-help").hide()
self.widget("create-help").hide()
finish_img = gtk.image_new_from_stock(gtk.STOCK_QUIT,
gtk.ICON_SIZE_BUTTON)
self.window.get_widget("create-finish").set_image(finish_img)
self.widget("create-finish").set_image(finish_img)
self.set_initial_state()
hwlist = self.window.get_widget("hardware-list")
hwlist = self.widget("hardware-list")
hwlist.get_selection().connect("changed", self.hw_selected)
def update_doc(self, ignore1, ignore2, param):
doc = self._build_doc_str(param)
self.window.get_widget("char-info").set_markup(doc)
self.widget("char-info").set_markup(doc)
def update_doc_changed(self, ignore1, param):
# Wrapper for update_doc and 'changed' signal
@ -188,17 +188,16 @@ class vmmAddHardware(vmmGObjectUI):
##########################
def set_initial_state(self):
notebook = self.window.get_widget("create-pages")
notebook = self.widget("create-pages")
notebook.set_show_tabs(False)
black = gtk.gdk.color_parse("#000")
self.window.get_widget("page-title-box").modify_bg(
gtk.STATE_NORMAL, black)
self.widget("page-title-box").modify_bg(gtk.STATE_NORMAL, black)
# Name, icon name, page number, is sensitive, tooltip, icon size,
# device type (serial/parallel)...
model = gtk.ListStore(str, str, int, bool, str, str)
hw_list = self.window.get_widget("hardware-list")
hw_list = self.widget("hardware-list")
hw_list.set_model(model)
hw_col = gtk.TreeViewColumn("Hardware")
@ -218,16 +217,16 @@ class vmmAddHardware(vmmGObjectUI):
hw_list.append_column(hw_col)
# Virtual network list
net_list = self.window.get_widget("net-list")
bridge_box = self.window.get_widget("net-bridge-box")
net_list = self.widget("net-list")
bridge_box = self.widget("net-bridge-box")
uihelpers.init_network_list(net_list, bridge_box)
# Network model list
netmodel_list = self.window.get_widget("net-model")
netmodel_list = self.widget("net-model")
uihelpers.build_netmodel_combo(self.vm, netmodel_list)
# Disk device type / bus
target_list = self.window.get_widget("config-storage-devtype")
target_list = self.widget("config-storage-devtype")
target_model = gtk.ListStore(str, str, str, str, int)
target_list.set_model(target_model)
icon = gtk.CellRendererPixbuf()
@ -240,19 +239,19 @@ class vmmAddHardware(vmmGObjectUI):
target_list.add_attribute(text, 'text', 3)
# Disk cache mode
cache_list = self.window.get_widget("config-storage-cache")
cache_list = self.widget("config-storage-cache")
uihelpers.build_cache_combo(self.vm, cache_list)
# Disk format mode
format_list = self.window.get_widget("config-storage-format")
format_list = self.widget("config-storage-format")
uihelpers.build_storage_format_combo(self.vm, format_list)
# Sparse tooltip
sparse_info = self.window.get_widget("config-storage-nosparse-info")
sparse_info = self.widget("config-storage-nosparse-info")
uihelpers.set_sparse_tooltip(sparse_info)
# Input device type
input_list = self.window.get_widget("input-type")
input_list = self.widget("input-type")
input_model = gtk.ListStore(str, str, str, bool)
input_list.set_model(input_model)
text = gtk.CellRendererText()
@ -261,7 +260,7 @@ class vmmAddHardware(vmmGObjectUI):
input_list.add_attribute(text, 'sensitive', 3)
# Graphics type
graphics_list = self.window.get_widget("graphics-type")
graphics_list = self.widget("graphics-type")
graphics_model = gtk.ListStore(str, str)
graphics_list.set_model(graphics_model)
text = gtk.CellRendererText()
@ -269,12 +268,12 @@ class vmmAddHardware(vmmGObjectUI):
graphics_list.add_attribute(text, 'text', 0)
# Sound model list
sound_list = self.window.get_widget("sound-model")
sound_list = self.widget("sound-model")
uihelpers.build_sound_combo(self.vm, sound_list)
# Host device list
# model = [ Description, nodedev name ]
host_dev = self.window.get_widget("host-device")
host_dev = self.widget("host-device")
host_dev_model = gtk.ListStore(str, str)
host_dev.set_model(host_dev_model)
@ -286,11 +285,11 @@ class vmmAddHardware(vmmGObjectUI):
host_dev.append_column(host_col)
# Video device
video_dev = self.window.get_widget("video-model")
video_dev = self.widget("video-model")
uihelpers.build_video_combo(self.vm, video_dev)
# Character dev mode
char_mode = self.window.get_widget("char-mode")
char_mode = self.widget("char-mode")
# Mode name, desc
char_mode_model = gtk.ListStore(str, str)
char_mode.set_model(char_mode_model)
@ -302,19 +301,18 @@ class vmmAddHardware(vmmGObjectUI):
desc = VirtualCharDevice.get_char_mode_desc(t)
char_mode_model.append([t, desc + " (%s)" % t])
self.window.get_widget("char-info-box").modify_bg(
gtk.STATE_NORMAL,
gtk.gdk.color_parse("grey"))
self.widget("char-info-box").modify_bg(gtk.STATE_NORMAL,
gtk.gdk.color_parse("grey"))
# Watchdog widgets
combo = self.window.get_widget("watchdog-model")
combo = self.widget("watchdog-model")
uihelpers.build_watchdogmodel_combo(self.vm, combo)
combo = self.window.get_widget("watchdog-action")
combo = self.widget("watchdog-action")
uihelpers.build_watchdogaction_combo(self.vm, combo)
def simple_store_set(comboname, values):
combo = self.window.get_widget(comboname)
combo = self.widget(comboname)
model = gtk.ListStore(str, str)
combo.set_model(model)
text = gtk.CellRendererText()
@ -332,7 +330,7 @@ class vmmAddHardware(vmmGObjectUI):
self.show_pair_combo("fs-type", self.conn.is_openvz())
# Smartcard widgets
combo = self.window.get_widget("smartcard-mode")
combo = self.widget("smartcard-mode")
uihelpers.build_smartcard_mode_combo(self.vm, combo)
# Available HW options
@ -345,7 +343,7 @@ class vmmAddHardware(vmmGObjectUI):
storage_tooltip = _("Connection does not support storage"
" management.")
hwlist = self.window.get_widget("hardware-list")
hwlist = self.widget("hardware-list")
model = hwlist.get_model()
model.clear()
@ -402,33 +400,33 @@ class vmmAddHardware(vmmGObjectUI):
def reset_state(self):
# Storage init
label_widget = self.window.get_widget("phys-hd-label")
label_widget = self.widget("phys-hd-label")
label_widget.set_markup("")
if not self.host_storage_timer:
self.host_storage_timer = self.safe_timeout_add(3 * 1000,
uihelpers.host_space_tick,
self.conn,
label_widget)
self.window.get_widget("config-storage-create").set_active(True)
self.window.get_widget("config-storage-size").set_value(8)
self.window.get_widget("config-storage-entry").set_text("")
self.window.get_widget("config-storage-nosparse").set_active(True)
self.widget("config-storage-create").set_active(True)
self.widget("config-storage-size").set_value(8)
self.widget("config-storage-entry").set_text("")
self.widget("config-storage-nosparse").set_active(True)
# Don't specify by default, so we don't overwrite possibly working
# libvirt detection
self.window.get_widget("config-storage-format").child.set_text("")
target_list = self.window.get_widget("config-storage-devtype")
self.widget("config-storage-format").child.set_text("")
target_list = self.widget("config-storage-devtype")
self.populate_target_device_model(target_list.get_model())
if len(target_list.get_model()) > 0:
target_list.set_active(0)
# Network init
newmac = uihelpers.generate_macaddr(self.conn)
self.window.get_widget("mac-address").set_active(bool(newmac))
self.window.get_widget("create-mac-address").set_text(newmac)
self.widget("mac-address").set_active(bool(newmac))
self.widget("create-mac-address").set_text(newmac)
self.change_macaddr_use()
net_list = self.window.get_widget("net-list")
net_warn = self.window.get_widget("net-list-warn")
net_list = self.widget("net-list")
net_warn = self.widget("net-list-warn")
uihelpers.populate_network_list(net_list, self.conn)
error = self.conn.netdev_error
@ -438,49 +436,49 @@ class vmmAddHardware(vmmGObjectUI):
else:
net_warn.hide()
netmodel = self.window.get_widget("net-model")
netmodel = self.widget("net-model")
uihelpers.populate_netmodel_combo(self.vm, netmodel)
netmodel.set_active(0)
# Input device init
input_box = self.window.get_widget("input-type")
input_box = self.widget("input-type")
self.populate_input_model(input_box.get_model())
input_box.set_active(0)
# Graphics init
self.change_port_auto()
graphics_box = self.window.get_widget("graphics-type")
graphics_box = self.widget("graphics-type")
self.populate_graphics_model(graphics_box.get_model())
graphics_box.set_active(0)
self.window.get_widget("graphics-address").set_active(False)
self.window.get_widget("graphics-port-auto").set_active(True)
self.window.get_widget("graphics-password").set_text("")
self.window.get_widget("graphics-keymap").set_text("")
self.window.get_widget("graphics-keymap-chk").set_active(True)
self.widget("graphics-address").set_active(False)
self.widget("graphics-port-auto").set_active(True)
self.widget("graphics-password").set_text("")
self.widget("graphics-keymap").set_text("")
self.widget("graphics-keymap-chk").set_active(True)
# Sound init
sound_box = self.window.get_widget("sound-model")
sound_box = self.widget("sound-model")
sound_box.set_active(0)
# Char parameters
self.window.get_widget("char-device-type").set_active(0)
self.window.get_widget("char-path").set_text("")
self.window.get_widget("char-host").set_text("127.0.0.1")
self.window.get_widget("char-port").get_adjustment().value = 4555
self.window.get_widget("char-bind-host").set_text("127.0.0.1")
self.window.get_widget("char-bind-port").get_adjustment().value = 4556
self.window.get_widget("char-use-telnet").set_active(False)
self.window.get_widget("char-target-name").set_text("com.redhat.spice.0")
self.widget("char-device-type").set_active(0)
self.widget("char-path").set_text("")
self.widget("char-host").set_text("127.0.0.1")
self.widget("char-port").get_adjustment().value = 4555
self.widget("char-bind-host").set_text("127.0.0.1")
self.widget("char-bind-port").get_adjustment().value = 4556
self.widget("char-use-telnet").set_active(False)
self.widget("char-target-name").set_text("com.redhat.spice.0")
# FS params
self.window.get_widget("fs-type-combo").set_active(0)
self.window.get_widget("fs-mode-combo").set_active(0)
self.window.get_widget("fs-source").set_text("")
self.window.get_widget("fs-target").set_text("")
self.widget("fs-type-combo").set_active(0)
self.widget("fs-mode-combo").set_active(0)
self.widget("fs-source").set_text("")
self.widget("fs-target").set_text("")
# Hide all notebook pages, so the wizard isn't as big as the largest
# page
notebook = self.window.get_widget("create-pages")
notebook = self.widget("create-pages")
for page in range(notebook.get_n_pages()):
widget = notebook.get_nth_page(page)
widget.hide()
@ -531,7 +529,7 @@ class vmmAddHardware(vmmGObjectUI):
model.append([_("Local SDL window"), "sdl"])
def populate_host_device_model(self, devtype, devcap, subtype, subcap):
devlist = self.window.get_widget("host-device")
devlist = self.widget("host-device")
model = devlist.get_model()
model.clear()
subdevs = []
@ -565,24 +563,24 @@ class vmmAddHardware(vmmGObjectUI):
# Disk getters
def is_default_storage(self):
return self.window.get_widget("config-storage-create").get_active()
return self.widget("config-storage-create").get_active()
def get_storage_info(self):
path = None
size = self.window.get_widget("config-storage-size").get_value()
sparse = not self.window.get_widget("config-storage-nosparse").get_active()
size = self.widget("config-storage-size").get_value()
sparse = not self.widget("config-storage-nosparse").get_active()
if self.is_default_storage():
path = util.get_default_path(self.conn,
self.vm.get_name())
logging.debug("Default storage path is: %s" % path)
else:
path = self.window.get_widget("config-storage-entry").get_text()
path = self.widget("config-storage-entry").get_text()
return (path, size, sparse)
def get_config_disk_target(self):
target = self.window.get_widget("config-storage-devtype")
target = self.widget("config-storage-devtype")
model = target.get_model()
idx = target.get_active()
if idx == -1:
@ -593,19 +591,19 @@ class vmmAddHardware(vmmGObjectUI):
return bus, device
def get_config_disk_cache(self, label=False):
cache = self.window.get_widget("config-storage-cache")
cache = self.widget("config-storage-cache")
idx = 0
if label:
idx = 1
return cache.get_model()[cache.get_active()][idx]
def get_config_disk_format(self):
fmt = self.window.get_widget("config-storage-format")
fmt = self.widget("config-storage-format")
return fmt.child.get_text()
# Input getters
def get_config_input(self):
target = self.window.get_widget("input-type")
target = self.widget("input-type")
label = target.get_model().get_value(target.get_active_iter(), 0)
_type = target.get_model().get_value(target.get_active_iter(), 1)
bus = target.get_model().get_value(target.get_active_iter(), 2)
@ -613,37 +611,37 @@ class vmmAddHardware(vmmGObjectUI):
# Graphics getters
def get_config_graphics(self):
_type = self.window.get_widget("graphics-type")
_type = self.widget("graphics-type")
if _type.get_active_iter() is None:
return None
return _type.get_model().get_value(_type.get_active_iter(), 1)
def get_config_graphics_port(self):
port = self.window.get_widget("graphics-port")
portAuto = self.window.get_widget("graphics-port-auto")
port = self.widget("graphics-port")
portAuto = self.widget("graphics-port-auto")
if portAuto.get_active():
return -1
return int(port.get_value())
def get_config_graphics_tls_port(self):
port = self.window.get_widget("graphics-tls-port")
portAuto = self.window.get_widget("graphics-port-auto")
port = self.widget("graphics-tls-port")
portAuto = self.widget("graphics-port-auto")
if portAuto.get_active():
return -1
return int(port.get_value())
def get_config_graphics_address(self):
addr = self.window.get_widget("graphics-address")
addr = self.widget("graphics-address")
if addr.get_active():
return "0.0.0.0"
return "127.0.0.1"
def get_config_graphics_password(self):
pw = self.window.get_widget("graphics-password")
pw = self.widget("graphics-password")
return pw.get_text()
def get_config_keymap(self):
g = self.window.get_widget("graphics-keymap")
g = self.widget("graphics-keymap")
if g.get_property("sensitive") and g.get_text() != "":
return g.get_text()
else:
@ -651,8 +649,8 @@ class vmmAddHardware(vmmGObjectUI):
# Network getters
def get_config_network(self):
net_list = self.window.get_widget("net-list")
bridge_ent = self.window.get_widget("net-bridge")
net_list = self.widget("net-list")
bridge_ent = self.widget("net-bridge")
net_type, net_src = uihelpers.get_network_selection(net_list,
bridge_ent)
@ -660,7 +658,7 @@ class vmmAddHardware(vmmGObjectUI):
return net_type, net_src
def get_config_net_model(self):
model = self.window.get_widget("net-model")
model = self.widget("net-model")
if model.get_active_iter():
modelxml = model.get_model().get_value(model.get_active_iter(), 0)
modelstr = model.get_model().get_value(model.get_active_iter(), 1)
@ -670,13 +668,13 @@ class vmmAddHardware(vmmGObjectUI):
def get_config_macaddr(self):
macaddr = None
if self.window.get_widget("mac-address").get_active():
macaddr = self.window.get_widget("create-mac-address").get_text()
if self.widget("mac-address").get_active():
macaddr = self.widget("create-mac-address").get_text()
return macaddr
# Sound getters
def get_config_sound_model(self):
model = self.window.get_widget("sound-model")
model = self.widget("sound-model")
modelstr = model.get_model().get_value(model.get_active_iter(), 0)
return modelstr
@ -691,35 +689,35 @@ class vmmAddHardware(vmmGObjectUI):
return usb_info
def get_config_host_device_info(self):
devrow = util.get_list_selection(self.window.get_widget("host-device"))
devrow = util.get_list_selection(self.widget("host-device"))
if not devrow:
return []
return devrow
# Video Getters
def get_config_video_model(self):
modbox = self.window.get_widget("video-model")
modbox = self.widget("video-model")
return modbox.get_model()[modbox.get_active()][0]
# Watchdog getters
def get_config_watchdog_model(self):
modbox = self.window.get_widget("watchdog-model")
modbox = self.widget("watchdog-model")
return modbox.get_model()[modbox.get_active()][0]
def get_config_watchdog_action(self):
modbox = self.window.get_widget("watchdog-action")
modbox = self.widget("watchdog-action")
return modbox.get_model()[modbox.get_active()][0]
# FS getters
def get_config_fs_mode(self):
name = "fs-mode-combo"
combo = self.window.get_widget(name)
combo = self.widget(name)
if not combo.get_property("visible"):
return None
return combo.get_model()[combo.get_active()][0]
def get_config_fs_type(self):
name = "fs-type-combo"
combo = self.window.get_widget(name)
combo = self.widget(name)
if not combo.get_property("visible"):
return None
@ -727,7 +725,7 @@ class vmmAddHardware(vmmGObjectUI):
# Smartcard getters
def get_config_smartcard_mode(self):
mode = self.window.get_widget("smartcard-mode")
mode = self.widget("smartcard-mode")
modestr = mode.get_model().get_value(mode.get_active_iter(), 0)
return modestr
@ -736,14 +734,14 @@ class vmmAddHardware(vmmGObjectUI):
################
def set_hw_selection(self, page):
util.set_list_selection(self.window.get_widget("hardware-list"), page)
util.set_list_selection(self.widget("hardware-list"), page)
def get_hw_selection(self):
return util.get_list_selection(self.window.get_widget("hardware-list"))
return util.get_list_selection(self.widget("hardware-list"))
def update_char_device_type_model(self):
# Char device type
char_devtype = self.window.get_widget("char-device-type")
char_devtype = self.widget("char-device-type")
dev_type = self.get_char_type()
# Type name, desc
char_devtype_model = gtk.ListStore(str, str)
@ -761,7 +759,7 @@ class vmmAddHardware(vmmGObjectUI):
def hw_selected(self, src=None):
ignore = src
self._dev = None
notebook = self.window.get_widget("create-pages")
notebook = self.widget("create-pages")
row = self.get_hw_selection()
if not row:
@ -774,11 +772,11 @@ class vmmAddHardware(vmmGObjectUI):
if not sens:
page = PAGE_ERROR
self.window.get_widget("hardware-info").set_text(msg)
self.widget("hardware-info").set_text(msg)
if page == PAGE_CHAR:
self.update_char_device_type_model()
devtype = self.window.get_widget("char-device-type")
devtype = self.widget("char-device-type")
self.change_char_device_type(devtype)
if page == PAGE_HOSTDEV:
@ -792,7 +790,7 @@ class vmmAddHardware(vmmGObjectUI):
notebook.set_current_page(page)
def finish(self, ignore=None):
notebook = self.window.get_widget("create-pages")
notebook = self.widget("create-pages")
try:
if self.validate(notebook.get_current_page()) == False:
return
@ -823,63 +821,63 @@ class vmmAddHardware(vmmGObjectUI):
self.close()
def show_pair_combo(self, basename, show_combo):
combo = self.window.get_widget(basename + "-combo")
label = self.window.get_widget(basename + "-label")
combo = self.widget(basename + "-combo")
label = self.widget(basename + "-label")
combo.set_property("visible", show_combo)
label.set_property("visible", not show_combo)
# Storage listeners
def browse_storage(self, ignore1):
self._browse_file(self.window.get_widget("config-storage-entry"))
self._browse_file(self.widget("config-storage-entry"))
def toggle_storage_select(self, src):
act = src.get_active()
self.window.get_widget("config-storage-browse-box").set_sensitive(act)
self.widget("config-storage-browse-box").set_sensitive(act)
def set_disk_storage_path(self, ignore, path):
self.window.get_widget("config-storage-entry").set_text(path)
self.widget("config-storage-entry").set_text(path)
# Network listeners
def change_macaddr_use(self, ignore=None):
if self.window.get_widget("mac-address").get_active():
self.window.get_widget("create-mac-address").set_sensitive(True)
if self.widget("mac-address").get_active():
self.widget("create-mac-address").set_sensitive(True)
else:
self.window.get_widget("create-mac-address").set_sensitive(False)
self.widget("create-mac-address").set_sensitive(False)
# Graphics listeners
def change_graphics_type(self, ignore=None):
graphics = self.get_config_graphics()
if graphics in ["vnc", "spice"]:
self.window.get_widget("graphics-port-auto").set_sensitive(True)
self.window.get_widget("graphics-address").set_sensitive(True)
self.window.get_widget("graphics-password").set_sensitive(True)
self.window.get_widget("graphics-keymap-chk").set_sensitive(True)
self.widget("graphics-port-auto").set_sensitive(True)
self.widget("graphics-address").set_sensitive(True)
self.widget("graphics-password").set_sensitive(True)
self.widget("graphics-keymap-chk").set_sensitive(True)
self.change_port_auto()
else:
self.window.get_widget("graphics-port").set_sensitive(False)
self.window.get_widget("graphics-tls-port").set_sensitive(False)
self.window.get_widget("graphics-port-auto").set_sensitive(False)
self.window.get_widget("graphics-address").set_sensitive(False)
self.window.get_widget("graphics-password").set_sensitive(False)
self.window.get_widget("graphics-keymap-chk").set_sensitive(False)
self.window.get_widget("graphics-keymap").set_sensitive(False)
self.widget("graphics-port").set_sensitive(False)
self.widget("graphics-tls-port").set_sensitive(False)
self.widget("graphics-port-auto").set_sensitive(False)
self.widget("graphics-address").set_sensitive(False)
self.widget("graphics-password").set_sensitive(False)
self.widget("graphics-keymap-chk").set_sensitive(False)
self.widget("graphics-keymap").set_sensitive(False)
def change_port_auto(self, ignore=None):
graphics = self.get_config_graphics()
tls_enable = graphics == "spice"
if self.window.get_widget("graphics-port-auto").get_active():
self.window.get_widget("graphics-port").set_sensitive(False)
self.window.get_widget("graphics-tls-port").set_sensitive(False)
if self.widget("graphics-port-auto").get_active():
self.widget("graphics-port").set_sensitive(False)
self.widget("graphics-tls-port").set_sensitive(False)
else:
self.window.get_widget("graphics-port").set_sensitive(True)
self.window.get_widget("graphics-tls-port").set_sensitive(tls_enable)
self.widget("graphics-port").set_sensitive(True)
self.widget("graphics-tls-port").set_sensitive(tls_enable)
def change_keymap(self, ignore=None):
if self.window.get_widget("graphics-keymap-chk").get_active():
self.window.get_widget("graphics-keymap").set_sensitive(False)
if self.widget("graphics-keymap-chk").get_active():
self.widget("graphics-keymap").set_sensitive(False)
else:
self.window.get_widget("graphics-keymap").set_sensitive(True)
self.widget("graphics-keymap").set_sensitive(True)
# Char device listeners
def get_char_type(self):
@ -928,7 +926,7 @@ class vmmAddHardware(vmmGObjectUI):
title = self.dev_to_title(page)
markup = ("""<span weight="heavy" size="xx-large" """
"""foreground="#FFF">%s</span>""") % title
self.window.get_widget("page-title-label").set_markup(markup)
self.widget("page-title-label").set_markup(markup)
def change_char_device_type(self, src):
self.update_doc(None, None, "char_type")
@ -950,21 +948,19 @@ class vmmAddHardware(vmmGObjectUI):
if make_visible:
show_something = True
self.window.get_widget(widget_name).set_property("visible",
self.widget(widget_name).set_property("visible", make_visible)
self.widget(widget_name + "-label").set_property("visible",
make_visible)
self.window.get_widget(widget_name + "-label").set_property(
"visible", make_visible)
self.window.get_widget("char-param-box").set_property("visible",
show_something)
self.widget("char-param-box").set_property("visible", show_something)
has_mode = self._dev.supports_property("source_mode")
if has_mode and self.window.get_widget("char-mode").get_active() == -1:
self.window.get_widget("char-mode").set_active(0)
if has_mode and self.widget("char-mode").get_active() == -1:
self.widget("char-mode").set_active(0)
# FS listeners
def browse_fs_source(self, ignore1):
self._browse_file(self.window.get_widget("fs-source"), isdir=True)
self._browse_file(self.widget("fs-source"), isdir=True)
def change_fs_type(self, src):
idx = src.get_active()
@ -980,8 +976,8 @@ class vmmAddHardware(vmmGObjectUI):
source_text = _("_Source path:")
show_mode_combo = self.conn.is_qemu()
self.window.get_widget("fs-source-title").set_text(source_text)
self.window.get_widget("fs-source-title").set_use_underline(True)
self.widget("fs-source-title").set_text(source_text)
self.widget("fs-source-title").set_use_underline(True)
self.show_pair_combo("fs-mode", show_mode_combo)
@ -1257,20 +1253,20 @@ class vmmAddHardware(vmmGObjectUI):
def validate_page_char(self):
chartype = self.get_char_type()
devbox = self.window.get_widget("char-device-type")
devbox = self.widget("char-device-type")
devtype = devbox.get_model()[devbox.get_active()][0]
conn = self.conn.vmm
devclass = VirtualCharDevice.get_dev_instance(conn, chartype, devtype)
source_path = self.window.get_widget("char-path").get_text()
source_host = self.window.get_widget("char-host").get_text()
bind_host = self.window.get_widget("char-bind-host").get_text()
source_port = self.window.get_widget("char-port").get_adjustment().value
bind_port = self.window.get_widget("char-bind-port").get_adjustment().value
target_name = self.window.get_widget("char-target-name").get_text()
source_path = self.widget("char-path").get_text()
source_host = self.widget("char-host").get_text()
bind_host = self.widget("char-bind-host").get_text()
source_port = self.widget("char-port").get_adjustment().value
bind_port = self.widget("char-bind-port").get_adjustment().value
target_name = self.widget("char-target-name").get_text()
if self.window.get_widget("char-use-telnet").get_active():
if self.widget("char-use-telnet").get_active():
protocol = VirtualCharDevice.CHAR_PROTOCOL_TELNET
else:
protocol = VirtualCharDevice.CHAR_PROTOCOL_RAW
@ -1324,8 +1320,8 @@ class vmmAddHardware(vmmGObjectUI):
def validate_page_filesystem(self):
conn = self.conn.vmm
source = self.window.get_widget("fs-source").get_text()
target = self.window.get_widget("fs-target").get_text()
source = self.widget("fs-source").get_text()
target = self.widget("fs-target").get_text()
mode = self.get_config_fs_mode()
fstype = self.get_config_fs_type()
@ -1380,7 +1376,7 @@ class vmmAddHardware(vmmGObjectUI):
def show_help(self, src_ignore):
# help to show depends on the notebook page, yahoo
page = self.window.get_widget("create-pages").get_current_page()
page = self.widget("create-pages").get_current_page()
if page == PAGE_ERROR:
self.emit("action-show-help", "virt-manager-create-wizard")
elif page == PAGE_DISK:

16
src/virtManager/asyncjob.py
View File

@ -109,17 +109,17 @@ class vmmAsyncJob(vmmGObjectUI):
self.cancel_args = cancel_args or []
self.cancel_args = [self] + self.cancel_args
if self.cancel_job:
self.window.get_widget("cancel-async-job").show()
self.widget("cancel-async-job").show()
else:
self.window.get_widget("cancel-async-job").hide()
self.widget("cancel-async-job").hide()
self.job_canceled = False
self._error_info = None
self._data = None
self.stage = self.window.get_widget("pbar-stage")
self.pbar = self.window.get_widget("pbar")
self.window.get_widget("pbar-text").set_text(text)
self.stage = self.widget("pbar-stage")
self.pbar = self.widget("pbar")
self.widget("pbar-text").set_text(text)
self.topwin.set_transient_for(parent)
args = [self] + args
@ -188,12 +188,12 @@ class vmmAsyncJob(vmmGObjectUI):
self.stage.set_text(text)
def hide_warning(self):
self.window.get_widget("warning-box").hide()
self.widget("warning-box").hide()
def show_warning(self, summary):
markup = "<small>%s</small>" % summary
self.window.get_widget("warning-box").show()
self.window.get_widget("warning-text").set_markup(markup)
self.widget("warning-box").show()
self.widget("warning-text").set_markup(markup)
def can_cancel(self):
return bool(self.cancel_job)

5
src/virtManager/baseclass.py
View File

@ -204,11 +204,14 @@ class vmmGObjectUI(vmmGObject):
self.window = gtk.glade.XML(self.gladefile,
self.windowname,
domain="virt-manager")
self.topwin = self.window.get_widget(self.windowname)
self.topwin = self.widget(self.windowname)
self.topwin.hide()
self.err = virtManager.error.vmmErrorDialog(self.topwin)
def widget(self, name):
return self.window.get_widget(name)
def cleanup(self):
vmmGObject.cleanup(self)
self.window = None

41
src/virtManager/choosecd.py
View File

@ -44,7 +44,7 @@ class vmmChooseCD(vmmGObjectUI):
"on_cancel_clicked": self.close,
})
self.window.get_widget("iso-image").set_active(True)
self.widget("iso-image").set_active(True)
self.initialize_opt_media()
self.reset_state()
@ -77,21 +77,21 @@ class vmmChooseCD(vmmGObjectUI):
vmmGObjectUI.cleanup(self)
def reset_state(self):
cd_path = self.window.get_widget("cd-path")
cd_path = self.widget("cd-path")
use_cdrom = (cd_path.get_active() > -1)
if use_cdrom:
self.window.get_widget("physical-media").set_active(True)
self.widget("physical-media").set_active(True)
else:
self.window.get_widget("iso-image").set_active(True)
self.widget("iso-image").set_active(True)
def ok(self, ignore1=None, ignore2=None):
path = None
if self.window.get_widget("iso-image").get_active():
path = self.window.get_widget("iso-path").get_text()
if self.widget("iso-image").get_active():
path = self.widget("iso-path").get_text()
else:
cd = self.window.get_widget("cd-path")
cd = self.widget("cd-path")
idx = cd.get_active()
model = cd.get_model()
if idx != -1:
@ -112,14 +112,14 @@ class vmmChooseCD(vmmGObjectUI):
self.close()
def media_toggled(self, ignore1=None, ignore2=None):
if self.window.get_widget("physical-media").get_active():
self.window.get_widget("cd-path").set_sensitive(True)
self.window.get_widget("iso-path").set_sensitive(False)
self.window.get_widget("iso-file-chooser").set_sensitive(False)
if self.widget("physical-media").get_active():
self.widget("cd-path").set_sensitive(True)
self.widget("iso-path").set_sensitive(False)
self.widget("iso-file-chooser").set_sensitive(False)
else:
self.window.get_widget("cd-path").set_sensitive(False)
self.window.get_widget("iso-path").set_sensitive(True)
self.window.get_widget("iso-file-chooser").set_sensitive(True)
self.widget("cd-path").set_sensitive(False)
self.widget("iso-path").set_sensitive(True)
self.widget("iso-file-chooser").set_sensitive(True)
def change_cd_path(self, ignore1=None, ignore2=None):
pass
@ -128,8 +128,8 @@ class vmmChooseCD(vmmGObjectUI):
self._browse_file()
def initialize_opt_media(self):
widget = self.window.get_widget("cd-path")
warn = self.window.get_widget("cd-path-warn")
widget = self.widget("cd-path")
warn = self.widget("cd-path-warn")
error = self.conn.mediadev_error
uihelpers.init_mediadev_combo(widget)
@ -141,15 +141,14 @@ class vmmChooseCD(vmmGObjectUI):
else:
warn.hide()
self.window.get_widget("physical-media").set_sensitive(not bool(error))
self.widget("physical-media").set_sensitive(not bool(error))
if self.media_type == MEDIA_FLOPPY:
self.window.get_widget("physical-media").set_label(
_("Floppy D_rive"))
self.window.get_widget("iso-image").set_label(_("Floppy _Image"))
self.widget("physical-media").set_label(_("Floppy D_rive"))
self.widget("iso-image").set_label(_("Floppy _Image"))
def set_storage_path(self, src_ignore, path):
self.window.get_widget("iso-path").set_text(path)
self.widget("iso-path").set_text(path)
def _browse_file(self):
if self.storage_browser == None:

41
src/virtManager/clone.py
View File

@ -169,10 +169,10 @@ class vmmCloneVM(vmmGObjectUI):
self.bind_escape_key_close()
# XXX: Help docs useless/out of date
self.window.get_widget("clone-help").hide()
self.widget("clone-help").hide()
finish_img = gtk.image_new_from_stock(gtk.STOCK_NEW,
gtk.ICON_SIZE_BUTTON)
self.window.get_widget("clone-ok").set_image(finish_img)
self.widget("clone-ok").set_image(finish_img)
self.set_initial_state()
@ -226,10 +226,9 @@ class vmmCloneVM(vmmGObjectUI):
def set_initial_state(self):
blue = gtk.gdk.color_parse("#0072A8")
self.window.get_widget("clone-header").modify_bg(gtk.STATE_NORMAL,
blue)
self.widget("clone-header").modify_bg(gtk.STATE_NORMAL, blue)
box = self.window.get_widget("clone-vm-icon-box")
box = self.widget("clone-vm-icon-box")
image = gtk.image_new_from_icon_name("vm_clone_wizard",
gtk.ICON_SIZE_DIALOG)
image.show()
@ -237,14 +236,14 @@ class vmmCloneVM(vmmGObjectUI):
# Populate state
def reset_state(self):
self.window.get_widget("clone-cancel").grab_focus()
self.widget("clone-cancel").grab_focus()
# Populate default clone values
self.setup_clone_info()
cd = self.clone_design
self.window.get_widget("clone-orig-name").set_text(cd.original_guest)
self.window.get_widget("clone-new-name").set_text(cd.clone_name)
self.widget("clone-orig-name").set_text(cd.original_guest)
self.widget("clone-new-name").set_text(cd.clone_name)
# We need to determine which disks fail (and why).
self.storage_list, self.target_list = self.check_all_storage()
@ -271,7 +270,7 @@ class vmmCloneVM(vmmGObjectUI):
return cd
def populate_network_list(self):
net_box = self.window.get_widget("clone-network-box")
net_box = self.widget("clone-network-box")
for c in net_box.get_children():
net_box.remove(c)
c.destroy()
@ -337,9 +336,8 @@ class vmmCloneVM(vmmGObjectUI):
build_net_row(label, mac, newmac)
no_net = bool(len(self.net_list.keys()) == 0)
self.window.get_widget("clone-network-box").set_property("visible",
not no_net)
self.window.get_widget("clone-no-net").set_property("visible", no_net)
self.widget("clone-network-box").set_property("visible", not no_net)
self.widget("clone-no-net").set_property("visible", no_net)
def check_all_storage(self):
"""
@ -447,7 +445,7 @@ class vmmCloneVM(vmmGObjectUI):
def set_paths_from_clone_name(self):
cd = self.clone_design
newname = self.window.get_widget("clone-new-name").get_text()
newname = self.widget("clone-new-name").get_text()
if not newname:
return
@ -551,7 +549,7 @@ class vmmCloneVM(vmmGObjectUI):
disk[STORAGE_INFO_COMBO] = option_combo
def populate_storage_lists(self):
storage_box = self.window.get_widget("clone-storage-box")
storage_box = self.widget("clone-storage-box")
for c in storage_box.get_children():
storage_box.remove(c)
c.destroy()
@ -562,16 +560,15 @@ class vmmCloneVM(vmmGObjectUI):
num_c = min(len(self.target_list), 3)
if num_c:
scroll = self.window.get_widget("clone-storage-scroll")
scroll = self.widget("clone-storage-scroll")
scroll.set_size_request(-1, 80 * num_c)
storage_box.show_all()
no_storage = not bool(len(self.target_list))
self.window.get_widget("clone-storage-box").set_property("visible",
not no_storage)
self.window.get_widget("clone-no-storage-pass").set_property(
"visible",
no_storage)
self.widget("clone-storage-box").set_property("visible",
not no_storage)
self.widget("clone-no-storage-pass").set_property("visible",
no_storage)
skip_targets = []
new_disks = []
@ -598,7 +595,7 @@ class vmmCloneVM(vmmGObjectUI):
tooltip = _("One or more disks cannot be cloned or shared.")
break
ok_button = self.window.get_widget("clone-ok")
ok_button = self.widget("clone-ok")
ok_button.set_sensitive(clone)
util.tooltip_wrapper(ok_button, tooltip)
@ -742,7 +739,7 @@ class vmmCloneVM(vmmGObjectUI):
# Listeners
def validate(self):
self.set_paths_from_clone_name()
name = self.window.get_widget("clone-new-name").get_text()
name = self.widget("clone-new-name").get_text()
# Make another clone_design
cd = self.build_new_clone_design(name)

67
src/virtManager/connect.py
View File

@ -109,43 +109,42 @@ class vmmConnect(vmmGObjectUI):
def set_initial_state(self):
stock_img = gtk.image_new_from_stock(gtk.STOCK_CONNECT,
gtk.ICON_SIZE_BUTTON)
self.window.get_widget("connect").set_image(stock_img)
self.window.get_widget("connect").grab_default()
self.widget("connect").set_image(stock_img)
self.widget("connect").grab_default()
# Hostname combo box entry
hostListModel = gtk.ListStore(str, str, str)
host = self.window.get_widget("hostname")
host = self.widget("hostname")
host.set_model(hostListModel)
host.set_text_column(2)
hostListModel.set_sort_column_id(2, gtk.SORT_ASCENDING)
self.window.get_widget("hostname").child.connect("changed",
self.hostname_changed)
self.widget("hostname").child.connect("changed", self.hostname_changed)
def reset_state(self):
self.set_default_hypervisor()
self.window.get_widget("connection").set_active(0)
self.window.get_widget("autoconnect").set_sensitive(True)
self.window.get_widget("autoconnect").set_active(True)
self.window.get_widget("hostname").get_model().clear()
self.window.get_widget("hostname").child.set_text("")
self.window.get_widget("connect-remote").set_active(False)
self.window.get_widget("username-entry").set_text("")
self.widget("connection").set_active(0)
self.widget("autoconnect").set_sensitive(True)
self.widget("autoconnect").set_active(True)
self.widget("hostname").get_model().clear()
self.widget("hostname").child.set_text("")
self.widget("connect-remote").set_active(False)
self.widget("username-entry").set_text("")
self.stop_browse()
self.connect_remote_toggled(self.window.get_widget("connect-remote"))
self.connect_remote_toggled(self.widget("connect-remote"))
self.populate_uri()
def is_remote(self):
# Whether user is requesting a remote connection
return self.window.get_widget("connect-remote").get_active()
return self.widget("connect-remote").get_active()
def set_default_hypervisor(self):
default = virtinst.util.default_connection()
if default is None:
self.window.get_widget("hypervisor").set_active(-1)
self.widget("hypervisor").set_active(-1)
elif default.startswith("xen"):
self.window.get_widget("hypervisor").set_active(0)
self.widget("hypervisor").set_active(0)
elif default.startswith("qemu"):
self.window.get_widget("hypervisor").set_active(1)
self.widget("hypervisor").set_active(1)
def add_service(self, interface, protocol, name, type, domain, flags):
ignore = flags
@ -171,7 +170,7 @@ class vmmConnect(vmmGObjectUI):
ignore = type
try:
model = self.window.get_widget("hostname").get_model()
model = self.widget("hostname").get_model()
name = str(name)
for row in model:
if row[0] == name:
@ -191,7 +190,7 @@ class vmmConnect(vmmGObjectUI):
ignore = port
try:
model = self.window.get_widget("hostname").get_model()
model = self.widget("hostname").get_model()
for row in model:
if row[2] == str(name):
# Already present in list
@ -246,7 +245,7 @@ class vmmConnect(vmmGObjectUI):
if not entry:
entry = ip
self.window.get_widget("hostname").child.set_text(entry)
self.widget("hostname").child.set_text(entry)
def hostname_changed(self, src_ignore):
self.populate_uri()
@ -259,10 +258,10 @@ class vmmConnect(vmmGObjectUI):
def connect_remote_toggled(self, src_ignore):
is_remote = self.is_remote()
self.window.get_widget("hostname").set_sensitive(is_remote)
self.window.get_widget("connection").set_sensitive(is_remote)
self.window.get_widget("autoconnect").set_active(not is_remote)
self.window.get_widget("username-entry").set_sensitive(is_remote)
self.widget("hostname").set_sensitive(is_remote)
self.widget("connection").set_sensitive(is_remote)
self.widget("autoconnect").set_active(not is_remote)
self.widget("username-entry").set_sensitive(is_remote)
if is_remote and self.can_browse:
self.start_browse()
else:
@ -277,18 +276,18 @@ class vmmConnect(vmmGObjectUI):
def populate_uri(self):
uri = self.generate_uri()
self.window.get_widget("uri-entry").set_text(uri)
self.widget("uri-entry").set_text(uri)
def populate_default_user(self):
conn = self.window.get_widget("connection").get_active()
conn = self.widget("connection").get_active()
default_user = default_conn_user(conn)
self.window.get_widget("username-entry").set_text(default_user)
self.widget("username-entry").set_text(default_user)
def generate_uri(self):
hv = self.window.get_widget("hypervisor").get_active()
conn = self.window.get_widget("connection").get_active()
host = self.window.get_widget("hostname").child.get_text()
user = self.window.get_widget("username-entry").get_text()
hv = self.widget("hypervisor").get_active()
conn = self.widget("connection").get_active()
host = self.widget("hostname").child.get_text()
user = self.widget("username-entry").get_text()
is_remote = self.is_remote()
hvstr = ""
@ -324,7 +323,7 @@ class vmmConnect(vmmGObjectUI):
def validate(self):
is_remote = self.is_remote()
host = self.window.get_widget("hostname").child.get_text()
host = self.widget("hostname").child.get_text()
if is_remote and not host:
return self.err.val_err(_("A hostname is required for "
@ -338,8 +337,8 @@ class vmmConnect(vmmGObjectUI):
readonly = False
auto = False
if self.window.get_widget("autoconnect").get_property("sensitive"):
auto = self.window.get_widget("autoconnect").get_active()
if self.widget("autoconnect").get_property("sensitive"):
auto = self.widget("autoconnect").get_active()
uri = self.generate_uri()
logging.debug("Generate URI=%s, auto=%s, readonly=%s" %

113
src/virtManager/console.py
View File

@ -536,7 +536,7 @@ class vmmConsolePages(vmmGObjectUI):
self.windowname = "vmm-details"
self.window = window
self.topwin = self.window.get_widget(self.windowname)
self.topwin = self.widget(self.windowname)
self.err = vmmErrorDialog(self.topwin)
self.pointer_is_grabbed = False
@ -565,13 +565,12 @@ class vmmConsolePages(vmmGObjectUI):
finish_img = gtk.image_new_from_stock(gtk.STOCK_YES,
gtk.ICON_SIZE_BUTTON)
self.window.get_widget("console-auth-login").set_image(finish_img)
self.widget("console-auth-login").set_image(finish_img)
# Make viewer widget background always be black
black = gtk.gdk.Color(0, 0, 0)
self.window.get_widget("console-vnc-viewport").modify_bg(
gtk.STATE_NORMAL,
black)
self.widget("console-vnc-viewport").modify_bg(gtk.STATE_NORMAL,
black)
# Signals are added by vmmDetails. Don't use signal_autoconnect here
# or it changes will be overwritten
@ -579,7 +578,7 @@ class vmmConsolePages(vmmGObjectUI):
self.add_gconf_handle(
self.vm.on_console_scaling_changed(self.refresh_scaling))
scroll = self.window.get_widget("console-vnc-scroll")
scroll = self.widget("console-vnc-scroll")
scroll.connect("size-allocate", self.scroll_size_allocate)
self.add_gconf_handle(
self.config.on_console_accels_changed(self.set_enable_accel))
@ -611,8 +610,8 @@ class vmmConsolePages(vmmGObjectUI):
##########################
def init_fs_toolbar(self):
scroll = self.window.get_widget("console-vnc-scroll")
pages = self.window.get_widget("console-pages")
scroll = self.widget("console-vnc-scroll")
pages = self.widget("console-pages")
pages.remove(scroll)
self.fs_toolbar = gtk.Toolbar()
@ -729,11 +728,11 @@ class vmmConsolePages(vmmGObjectUI):
def refresh_scaling(self, ignore1=None, ignore2=None, ignore3=None,
ignore4=None):
self.scale_type = self.vm.get_console_scaling()
self.window.get_widget("details-menu-view-scale-always").set_active(
self.widget("details-menu-view-scale-always").set_active(
self.scale_type == self.config.CONSOLE_SCALE_ALWAYS)
self.window.get_widget("details-menu-view-scale-never").set_active(
self.widget("details-menu-view-scale-never").set_active(
self.scale_type == self.config.CONSOLE_SCALE_NEVER)
self.window.get_widget("details-menu-view-scale-fullscreen").set_active(
self.widget("details-menu-view-scale-fullscreen").set_active(
self.scale_type == self.config.CONSOLE_SCALE_FULLSCREEN)
self.update_scaling()
@ -742,11 +741,11 @@ class vmmConsolePages(vmmGObjectUI):
if not src.get_active():
return
if src == self.window.get_widget("details-menu-view-scale-always"):
if src == self.widget("details-menu-view-scale-always"):
self.scale_type = self.config.CONSOLE_SCALE_ALWAYS
elif src == self.window.get_widget("details-menu-view-scale-fullscreen"):
elif src == self.widget("details-menu-view-scale-fullscreen"):
self.scale_type = self.config.CONSOLE_SCALE_FULLSCREEN
elif src == self.window.get_widget("details-menu-view-scale-never"):
elif src == self.widget("details-menu-view-scale-never"):
self.scale_type = self.config.CONSOLE_SCALE_NEVER
self.vm.set_console_scaling(self.scale_type)
@ -757,8 +756,8 @@ class vmmConsolePages(vmmGObjectUI):
return
curscale = self.viewer.get_scaling()
fs = self.window.get_widget("control-fullscreen").get_active()
vnc_scroll = self.window.get_widget("console-vnc-scroll")
fs = self.widget("control-fullscreen").get_active()
vnc_scroll = self.widget("console-vnc-scroll")
if (self.scale_type == self.config.CONSOLE_SCALE_NEVER
and curscale == True):
@ -785,22 +784,22 @@ class vmmConsolePages(vmmGObjectUI):
self._change_fullscreen(False)
def _change_fullscreen(self, do_fullscreen):
self.window.get_widget("control-fullscreen").set_active(do_fullscreen)
self.widget("control-fullscreen").set_active(do_fullscreen)
if do_fullscreen:
self.topwin.fullscreen()
self.fs_toolbar.show()
self.fs_drawer.set_active(True)
self.window.get_widget("toolbar-box").hide()
self.window.get_widget("details-menubar").hide()
self.widget("toolbar-box").hide()
self.widget("details-menubar").hide()
else:
self.fs_toolbar.hide()
self.fs_drawer.set_active(False)
self.topwin.unfullscreen()
if self.window.get_widget("details-menu-view-toolbar").get_active():
self.window.get_widget("toolbar-box").show()
self.window.get_widget("details-menubar").show()
if self.widget("details-menu-view-toolbar").get_active():
self.widget("toolbar-box").show()
self.widget("details-menubar").show()
self.update_scaling()
@ -836,7 +835,7 @@ class vmmConsolePages(vmmGObjectUI):
self.activate_unavailable_page(_("Guest has crashed"))
def close_viewer(self):
viewport = self.window.get_widget("console-vnc-viewport")
viewport = self.widget("console-vnc-viewport")
if self.viewer is None:
return
@ -854,7 +853,7 @@ class vmmConsolePages(vmmGObjectUI):
def update_widget_states(self, vm, status_ignore):
runable = vm.is_runable()
pages = self.window.get_widget("console-pages")
pages = self.widget("console-pages")
page = pages.get_current_page()
if runable:
@ -884,49 +883,49 @@ class vmmConsolePages(vmmGObjectUI):
with care
"""
self.close_viewer()
self.window.get_widget("console-pages").set_current_page(PAGE_UNAVAILABLE)
self.window.get_widget("details-menu-vm-screenshot").set_sensitive(False)
self.window.get_widget("console-unavailable").set_label("<b>" + msg + "</b>")
self.widget("console-pages").set_current_page(PAGE_UNAVAILABLE)
self.widget("details-menu-vm-screenshot").set_sensitive(False)
self.widget("console-unavailable").set_label("<b>" + msg + "</b>")
def activate_auth_page(self, withPassword=True, withUsername=False):
(pw, username) = self.config.get_console_password(self.vm)
self.window.get_widget("details-menu-vm-screenshot").set_sensitive(False)
self.widget("details-menu-vm-screenshot").set_sensitive(False)
if withPassword:
self.window.get_widget("console-auth-password").show()
self.window.get_widget("label-auth-password").show()
self.widget("console-auth-password").show()
self.widget("label-auth-password").show()
else:
self.window.get_widget("console-auth-password").hide()
self.window.get_widget("label-auth-password").hide()
self.widget("console-auth-password").hide()
self.widget("label-auth-password").hide()
if withUsername:
self.window.get_widget("console-auth-username").show()
self.window.get_widget("label-auth-username").show()
self.widget("console-auth-username").show()
self.widget("label-auth-username").show()
else:
self.window.get_widget("console-auth-username").hide()
self.window.get_widget("label-auth-username").hide()
self.widget("console-auth-username").hide()
self.widget("label-auth-username").hide()
self.window.get_widget("console-auth-username").set_text(username)
self.window.get_widget("console-auth-password").set_text(pw)
self.widget("console-auth-username").set_text(username)
self.widget("console-auth-password").set_text(pw)
if self.config.has_keyring():
self.window.get_widget("console-auth-remember").set_sensitive(True)
self.widget("console-auth-remember").set_sensitive(True)
if pw != "" or username != "":
self.window.get_widget("console-auth-remember").set_active(True)
self.widget("console-auth-remember").set_active(True)
else:
self.window.get_widget("console-auth-remember").set_active(False)
self.widget("console-auth-remember").set_active(False)
else:
self.window.get_widget("console-auth-remember").set_sensitive(False)
self.window.get_widget("console-pages").set_current_page(PAGE_AUTHENTICATE)
self.widget("console-auth-remember").set_sensitive(False)
self.widget("console-pages").set_current_page(PAGE_AUTHENTICATE)
if withUsername:
self.window.get_widget("console-auth-username").grab_focus()
self.widget("console-auth-username").grab_focus()
else:
self.window.get_widget("console-auth-password").grab_focus()
self.widget("console-auth-password").grab_focus()
def activate_viewer_page(self):
self.window.get_widget("console-pages").set_current_page(PAGE_VIEWER)
self.window.get_widget("details-menu-vm-screenshot").set_sensitive(True)
self.widget("console-pages").set_current_page(PAGE_VIEWER)
self.widget("details-menu-vm-screenshot").set_sensitive(True)
if self.viewer and self.viewer.get_widget():
self.viewer.get_widget().grab_focus()
@ -934,15 +933,15 @@ class vmmConsolePages(vmmGObjectUI):
self.set_allow_fullscreen()
def set_allow_fullscreen(self):
cpage = self.window.get_widget("console-pages").get_current_page()
dpage = self.window.get_widget("details-pages").get_current_page()
cpage = self.widget("console-pages").get_current_page()
dpage = self.widget("details-pages").get_current_page()
allow_fullscreen = (dpage == 0 and
cpage == PAGE_VIEWER and
self.viewer_connected)
self.window.get_widget("control-fullscreen").set_sensitive(allow_fullscreen)
self.window.get_widget("details-menu-view-fullscreen").set_sensitive(allow_fullscreen)
self.widget("control-fullscreen").set_sensitive(allow_fullscreen)
self.widget("details-menu-view-fullscreen").set_sensitive(allow_fullscreen)
def disconnected(self):
errout = ""
@ -1073,7 +1072,7 @@ class vmmConsolePages(vmmGObjectUI):
try:
if protocol == "vnc":
self.viewer = VNCViewer(self)
self.window.get_widget("console-vnc-viewport").add(
self.widget("console-vnc-viewport").add(
self.viewer.get_widget())
self.viewer.init_widget()
elif protocol == "spice":
@ -1102,14 +1101,14 @@ class vmmConsolePages(vmmGObjectUI):
_("Error connecting to graphical console") + ":\n%s" % e)
def set_credentials(self, src_ignore=None):
passwd = self.window.get_widget("console-auth-password")
passwd = self.widget("console-auth-password")
if passwd.flags() & gtk.VISIBLE:
self.viewer.set_credential_password(passwd.get_text())
username = self.window.get_widget("console-auth-username")
username = self.widget("console-auth-username")
if username.flags() & gtk.VISIBLE:
self.viewer.set_credential_username(username.get_text())
if self.window.get_widget("console-auth-remember").get_active():
if self.widget("console-auth-remember").get_active():
self.config.set_console_password(self.vm, passwd.get_text(),
username.get_text())
@ -1119,7 +1118,7 @@ class vmmConsolePages(vmmGObjectUI):
isn't a hard requirment so the user can still shrink the window
again, as opposed to set_size_request
"""
widget = self.window.get_widget("console-vnc-scroll")
widget = self.widget("console-vnc-scroll")
signal_holder = []
def restore_scroll(src):
@ -1163,7 +1162,7 @@ class vmmConsolePages(vmmGObjectUI):
if not self.viewer or not self.viewer.get_desktop_resolution():
return
scroll = self.window.get_widget("console-vnc-scroll")
scroll = self.widget("console-vnc-scroll")
is_scale = self.viewer.get_scaling()
dx = 0

374
src/virtManager/create.py
View File

@ -209,42 +209,41 @@ class vmmCreate(vmmGObjectUI):
# State init methods
def startup_error(self, error):
self.have_startup_error = True
self.window.get_widget("startup-error-box").show()
self.window.get_widget("install-box").hide()
self.window.get_widget("create-forward").set_sensitive(False)
self.widget("startup-error-box").show()
self.widget("install-box").hide()
self.widget("create-forward").set_sensitive(False)
self.window.get_widget("startup-error").set_text("Error: %s" % error)
self.widget("startup-error").set_text("Error: %s" % error)
return False
def startup_warning(self, error):
self.window.get_widget("startup-error-box").show()
self.window.get_widget("startup-error").set_text("Warning: %s" %
error)
self.widget("startup-error-box").show()
self.widget("startup-error").set_text("Warning: %s" % error)
def set_initial_state(self):
self.window.get_widget("create-pages").set_show_tabs(False)
self.window.get_widget("install-method-pages").set_show_tabs(False)
self.widget("create-pages").set_show_tabs(False)
self.widget("install-method-pages").set_show_tabs(False)
# FIXME: Unhide this when we make some documentation
self.window.get_widget("create-help").hide()
self.widget("create-help").hide()
finish_img = gtk.image_new_from_stock(gtk.STOCK_QUIT,
gtk.ICON_SIZE_BUTTON)
self.window.get_widget("create-finish").set_image(finish_img)
self.widget("create-finish").set_image(finish_img)
blue = gtk.gdk.color_parse("#0072A8")
self.window.get_widget("create-header").modify_bg(gtk.STATE_NORMAL,
self.widget("create-header").modify_bg(gtk.STATE_NORMAL,
blue)
box = self.window.get_widget("create-vm-icon-box")
box = self.widget("create-vm-icon-box")
image = gtk.image_new_from_icon_name("vm_new_wizard",
gtk.ICON_SIZE_DIALOG)
image.show()
box.pack_end(image, False)
# Connection list
self.window.get_widget("create-conn-label").set_text("")
self.window.get_widget("startup-error").set_text("")
conn_list = self.window.get_widget("create-conn")
self.widget("create-conn-label").set_text("")
self.widget("startup-error").set_text("")
conn_list = self.widget("create-conn")
conn_model = gtk.ListStore(str, str)
conn_list.set_model(conn_model)
text = gtk.CellRendererText()
@ -252,35 +251,35 @@ class vmmCreate(vmmGObjectUI):
conn_list.add_attribute(text, 'text', 1)
# ISO media list
iso_list = self.window.get_widget("install-local-box")
iso_list = self.widget("install-local-box")
iso_model = gtk.ListStore(str)
iso_list.set_model(iso_model)
iso_list.set_text_column(0)
self.window.get_widget("install-local-box").child.connect("activate",
self.widget("install-local-box").child.connect("activate",
self.detect_media_os)
# Lists for the install urls
media_url_list = self.window.get_widget("install-url-box")
media_url_list = self.widget("install-url-box")
media_url_model = gtk.ListStore(str)
media_url_list.set_model(media_url_model)
media_url_list.set_text_column(0)
self.window.get_widget("install-url-box").child.connect("activate",
self.widget("install-url-box").child.connect("activate",
self.detect_media_os)
ks_url_list = self.window.get_widget("install-ks-box")
ks_url_list = self.widget("install-ks-box")
ks_url_model = gtk.ListStore(str)
ks_url_list.set_model(ks_url_model)
ks_url_list.set_text_column(0)
# Lists for distro type + variant
os_type_list = self.window.get_widget("install-os-type")
os_type_list = self.widget("install-os-type")
os_type_model = gtk.ListStore(str, str)
os_type_list.set_model(os_type_model)
text = gtk.CellRendererText()
os_type_list.pack_start(text, True)
os_type_list.add_attribute(text, 'text', 1)
os_variant_list = self.window.get_widget("install-os-version")
os_variant_list = self.widget("install-os-version")
os_variant_model = gtk.ListStore(str, str)
os_variant_list.set_model(os_variant_model)
text = gtk.CellRendererText()
@ -288,25 +287,25 @@ class vmmCreate(vmmGObjectUI):
os_variant_list.add_attribute(text, 'text', 1)
# Physical CD-ROM model
cd_list = self.window.get_widget("install-local-cdrom-combo")
cd_list = self.widget("install-local-cdrom-combo")
uihelpers.init_mediadev_combo(cd_list)
# Networking
# [ interface type, device name, label, sensitive ]
net_list = self.window.get_widget("config-netdev")
bridge_box = self.window.get_widget("config-netdev-bridge-box")
net_list = self.widget("config-netdev")
bridge_box = self.widget("config-netdev-bridge-box")
uihelpers.init_network_list(net_list, bridge_box)
# Archtecture
archModel = gtk.ListStore(str)
archList = self.window.get_widget("config-arch")
archList = self.widget("config-arch")
text = gtk.CellRendererText()
archList.pack_start(text, True)
archList.add_attribute(text, 'text', 0)
archList.set_model(archModel)
hyperModel = gtk.ListStore(str, str, str, bool)
hyperList = self.window.get_widget("config-hv")
hyperList = self.widget("config-hv")
text = gtk.CellRendererText()
hyperList.pack_start(text, True)
hyperList.add_attribute(text, 'text', 0)
@ -314,7 +313,7 @@ class vmmCreate(vmmGObjectUI):
hyperList.set_model(hyperModel)
# Sparse tooltip
sparse_info = self.window.get_widget("config-storage-nosparse-info")
sparse_info = self.widget("config-storage-nosparse-info")
uihelpers.set_sparse_tooltip(sparse_info)
def reset_state(self, urihint=None):
@ -324,16 +323,16 @@ class vmmCreate(vmmGObjectUI):
self.disk = None
self.nic = None
self.window.get_widget("create-pages").set_current_page(PAGE_NAME)
self.widget("create-pages").set_current_page(PAGE_NAME)
self.page_changed(None, None, PAGE_NAME)
self.window.get_widget("startup-error-box").hide()
self.window.get_widget("install-box").show()
self.widget("startup-error-box").hide()
self.widget("install-box").show()
# Name page state
self.window.get_widget("create-vm-name").set_text("")
self.window.get_widget("create-vm-name").grab_focus()
self.window.get_widget("method-local").set_active(True)
self.window.get_widget("create-conn").set_active(-1)
self.widget("create-vm-name").set_text("")
self.widget("create-vm-name").grab_focus()
self.widget("method-local").set_active(True)
self.widget("create-conn").set_active(-1)
activeconn = self.populate_conn_list(urihint)
try:
@ -349,53 +348,53 @@ class vmmCreate(vmmGObjectUI):
# Everything from this point forward should be connection independent
# Distro/Variant
self.toggle_detect_os(self.window.get_widget("install-detect-os"))
self.toggle_detect_os(self.widget("install-detect-os"))
self.populate_os_type_model()
self.window.get_widget("install-os-type").set_active(0)
self.widget("install-os-type").set_active(0)
self.window.get_widget("install-local-box").child.set_text("")
iso_model = self.window.get_widget("install-local-box").get_model()
self.widget("install-local-box").child.set_text("")
iso_model = self.widget("install-local-box").get_model()
self.populate_media_model(iso_model, self.conn.config_get_iso_paths())
# Install URL
self.window.get_widget("install-urlopts-entry").set_text("")
self.window.get_widget("install-ks-box").child.set_text("")
self.window.get_widget("install-url-box").child.set_text("")
self.window.get_widget("install-url-options").set_expanded(False)
urlmodel = self.window.get_widget("install-url-box").get_model()
ksmodel = self.window.get_widget("install-ks-box").get_model()
self.widget("install-urlopts-entry").set_text("")
self.widget("install-ks-box").child.set_text("")
self.widget("install-url-box").child.set_text("")
self.widget("install-url-options").set_expanded(False)
urlmodel = self.widget("install-url-box").get_model()
ksmodel = self.widget("install-ks-box").get_model()
self.populate_media_model(urlmodel, self.config.get_media_urls())
self.populate_media_model(ksmodel, self.config.get_kickstart_urls())
# Install import
self.window.get_widget("install-import-entry").set_text("")
self.widget("install-import-entry").set_text("")
# Install container app
self.window.get_widget("install-app-entry").set_text("/bin/sh")
self.widget("install-app-entry").set_text("/bin/sh")
# Install container OS
self.window.get_widget("install-oscontainer-fs").set_text("")
self.widget("install-oscontainer-fs").set_text("")
# Mem / CPUs
self.window.get_widget("config-mem").set_value(DEFAULT_MEM)
self.window.get_widget("config-cpus").set_value(1)
self.widget("config-mem").set_value(DEFAULT_MEM)
self.widget("config-cpus").set_value(1)
# Storage
label_widget = self.window.get_widget("phys-hd-label")
label_widget = self.widget("phys-hd-label")
label_widget.set_markup("")
if not self.host_storage_timer:
self.host_storage_timer = self.safe_timeout_add(3 * 1000,
uihelpers.host_space_tick,
self.conn,
label_widget)
self.window.get_widget("enable-storage").set_active(True)
self.window.get_widget("config-storage-create").set_active(True)
self.window.get_widget("config-storage-size").set_value(8)
self.window.get_widget("config-storage-entry").set_text("")
self.window.get_widget("config-storage-nosparse").set_active(True)
self.widget("enable-storage").set_active(True)
self.widget("config-storage-create").set_active(True)
self.widget("config-storage-size").set_value(8)
self.widget("config-storage-entry").set_text("")
self.widget("config-storage-nosparse").set_active(True)
# Final page
self.window.get_widget("summary-customize").set_active(False)
self.widget("summary-customize").set_active(False)
# Make sure window is a sane size
self.topwin.resize(1, 1)
@ -403,7 +402,7 @@ class vmmCreate(vmmGObjectUI):
def set_conn_state(self):
# Update all state that has some dependency on the current connection
self.window.get_widget("create-forward").set_sensitive(True)
self.widget("create-forward").set_sensitive(True)
if self.conn.is_read_only():
return self.startup_error(_("Connection is read only."))
@ -453,10 +452,10 @@ class vmmCreate(vmmGObjectUI):
is_container = self.conn.is_container()
# Install Options
method_tree = self.window.get_widget("method-tree")
method_pxe = self.window.get_widget("method-pxe")
method_local = self.window.get_widget("method-local")
method_container_app = self.window.get_widget("method-container-app")
method_tree = self.widget("method-tree")
method_pxe = self.widget("method-pxe")
method_local = self.widget("method-local")
method_container_app = self.widget("method-container-app")
method_tree.set_sensitive(is_local)
method_local.set_sensitive(not is_pv)
@ -494,16 +493,16 @@ class vmmCreate(vmmGObjectUI):
# Container install options
method_container_app.set_active(True)
self.window.get_widget("virt-install-box").set_property(
"visible", not is_container)
self.window.get_widget("container-install-box").set_property(
"visible", is_container)
self.widget("virt-install-box").set_property("visible",
not is_container)
self.widget("container-install-box").set_property("visible",
is_container)
# Install local
iso_option = self.window.get_widget("install-local-iso")
cdrom_option = self.window.get_widget("install-local-cdrom")
cdrom_list = self.window.get_widget("install-local-cdrom-combo")
cdrom_warn = self.window.get_widget("install-local-cdrom-warn")
iso_option = self.widget("install-local-iso")
cdrom_option = self.widget("install-local-cdrom")
cdrom_list = self.widget("install-local-cdrom-combo")
cdrom_warn = self.widget("install-local-cdrom-warn")
sigs = uihelpers.populate_mediadev_combo(self.conn, cdrom_list,
MEDIA_CDROM)
@ -536,8 +535,8 @@ class vmmCreate(vmmGObjectUI):
{'maxmem': self.pretty_memory(memory)})
mem_label = ("<span size='small' color='#484848'>%s</span>" %
mem_label)
self.window.get_widget("config-mem").set_range(50, memory / 1024)
self.window.get_widget("phys-mem-label").set_markup(mem_label)
self.widget("config-mem").set_range(50, memory / 1024)
self.widget("phys-mem-label").set_markup(mem_label)
# CPU
phys_cpus = self.conn.host_active_processor_count()
@ -550,8 +549,7 @@ class vmmCreate(vmmGObjectUI):
max_v)
else:
cpu_tooltip = None
util.tooltip_wrapper(self.window.get_widget("config-cpus"),
cpu_tooltip)
util.tooltip_wrapper(self.widget("config-cpus"), cpu_tooltip)
cmax = int(cmax)
if cmax <= 0:
@ -560,15 +558,15 @@ class vmmCreate(vmmGObjectUI):
{'numcpus': int(phys_cpus)})
cpu_label = ("<span size='small' color='#484848'>%s</span>" %
cpu_label)
self.window.get_widget("config-cpus").set_range(1, cmax)
self.window.get_widget("phys-cpu-label").set_markup(cpu_label)
self.widget("config-cpus").set_range(1, cmax)
self.widget("phys-cpu-label").set_markup(cpu_label)
# Storage
have_storage = (is_local or is_storage_capable)
storage_tooltip = None
use_storage = self.window.get_widget("config-storage-select")
storage_area = self.window.get_widget("config-storage-area")
use_storage = self.widget("config-storage-select")
storage_area = self.widget("config-storage-area")
storage_area.set_sensitive(have_storage)
if not have_storage:
@ -578,10 +576,10 @@ class vmmCreate(vmmGObjectUI):
util.tooltip_wrapper(storage_area, storage_tooltip)
# Networking
net_list = self.window.get_widget("config-netdev")
net_expander = self.window.get_widget("config-advanced-expander")
net_warn_icon = self.window.get_widget("config-netdev-warn-icon")
net_warn_box = self.window.get_widget("config-netdev-warn-box")
net_list = self.widget("config-netdev")
net_expander = self.widget("config-advanced-expander")
net_warn_icon = self.widget("config-netdev-warn-icon")
net_warn_box = self.widget("config-netdev-warn-box")
net_expander.hide()
net_warn_icon.hide()
net_warn_box.hide()
@ -592,14 +590,14 @@ class vmmCreate(vmmGObjectUI):
self.conn.netdev_error, True)
newmac = uihelpers.generate_macaddr(self.conn)
self.window.get_widget("config-set-macaddr").set_active(bool(newmac))
self.window.get_widget("config-macaddr").set_text(newmac)
self.widget("config-set-macaddr").set_active(bool(newmac))
self.widget("config-macaddr").set_text(newmac)
def set_net_warn(self, show_warn, msg, do_tooltip):
net_warn_icon = self.window.get_widget("config-netdev-warn-icon")
net_warn_box = self.window.get_widget("config-netdev-warn-box")
net_warn_label = self.window.get_widget("config-netdev-warn-label")
net_expander = self.window.get_widget("config-advanced-expander")
net_warn_icon = self.widget("config-netdev-warn-icon")
net_warn_box = self.widget("config-netdev-warn-box")
net_warn_label = self.widget("config-netdev-warn-label")
net_expander = self.widget("config-advanced-expander")
if show_warn:
net_expander.set_expanded(True)
@ -614,7 +612,7 @@ class vmmCreate(vmmGObjectUI):
net_warn_label.set_markup(markup)
def populate_hv(self):
hv_list = self.window.get_widget("config-hv")
hv_list = self.widget("config-hv")
model = hv_list.get_model()
model.clear()
@ -650,7 +648,7 @@ class vmmCreate(vmmGObjectUI):
model.append([label, gtype, domtype, sensitive])
hv_info = self.window.get_widget("config-hv-info")
hv_info = self.widget("config-hv-info")
if tooltip:
hv_info.show()
util.tooltip_wrapper(hv_info, tooltip)
@ -660,7 +658,7 @@ class vmmCreate(vmmGObjectUI):
hv_list.set_active(default)
def populate_arch(self):
arch_list = self.window.get_widget("config-arch")
arch_list = self.widget("config-arch")
model = arch_list.get_model()
model.clear()
@ -678,7 +676,7 @@ class vmmCreate(vmmGObjectUI):
arch_list.set_active(default)
def populate_conn_list(self, urihint=None):
conn_list = self.window.get_widget("create-conn")
conn_list = self.widget("create-conn")
model = conn_list.get_model()
model.clear()
@ -709,18 +707,18 @@ class vmmCreate(vmmGObjectUI):
activeuri, activedesc = model[default]
activeconn = self.engine.connections[activeuri]["connection"]
self.window.get_widget("create-conn-label").set_text(activedesc)
self.widget("create-conn-label").set_text(activedesc)
if len(model) <= 1:
self.window.get_widget("create-conn").hide()
self.window.get_widget("create-conn-label").show()
self.widget("create-conn").hide()
self.widget("create-conn-label").show()
else:
self.window.get_widget("create-conn").show()
self.window.get_widget("create-conn-label").hide()
self.widget("create-conn").show()
self.widget("create-conn-label").hide()
return activeconn
def populate_os_type_model(self):
model = self.window.get_widget("install-os-type").get_model()
model = self.widget("install-os-type").get_model()
model.clear()
model.append([OS_GENERIC, _("Generic")])
types = virtinst.FullVirtGuest.list_os_types()
@ -728,7 +726,7 @@ class vmmCreate(vmmGObjectUI):
model.append([t, virtinst.FullVirtGuest.get_os_type_label(t)])
def populate_os_variant_model(self, _type):
model = self.window.get_widget("install-os-version").get_model()
model = self.widget("install-os-version").get_model()
model.clear()
if _type == OS_GENERIC:
model.append([OS_GENERIC, _("Generic")])
@ -825,43 +823,43 @@ class vmmCreate(vmmGObjectUI):
title = "Ready to begin installation of <b>%s</b>" % self.guest.name
self.window.get_widget("summary-title").set_markup(title)
self.window.get_widget("summary-os").set_text(osstr)
self.window.get_widget("summary-install").set_text(install)
self.window.get_widget("summary-mem").set_text(mem)
self.window.get_widget("summary-cpu").set_text(cpu)
self.window.get_widget("summary-storage").set_markup(storage)
self.widget("summary-title").set_markup(title)
self.widget("summary-os").set_text(osstr)
self.widget("summary-install").set_text(install)
self.widget("summary-mem").set_text(mem)
self.widget("summary-cpu").set_text(cpu)
self.widget("summary-storage").set_markup(storage)
# get_* methods
def get_config_name(self):
return self.window.get_widget("create-vm-name").get_text()
return self.widget("create-vm-name").get_text()
def is_install_page(self):
notebook = self.window.get_widget("create-pages")
notebook = self.widget("create-pages")
curpage = notebook.get_current_page()
return curpage == PAGE_INSTALL
def get_config_install_page(self):
if self.window.get_widget("virt-install-box").get_property("visible"):
if self.window.get_widget("method-local").get_active():
if self.widget("virt-install-box").get_property("visible"):
if self.widget("method-local").get_active():
return INSTALL_PAGE_ISO
elif self.window.get_widget("method-tree").get_active():
elif self.widget("method-tree").get_active():
return INSTALL_PAGE_URL
elif self.window.get_widget("method-pxe").get_active():
elif self.widget("method-pxe").get_active():
return INSTALL_PAGE_PXE
elif self.window.get_widget("method-import").get_active():
elif self.widget("method-import").get_active():
return INSTALL_PAGE_IMPORT
else:
if self.window.get_widget("method-container-app").get_active():
if self.widget("method-container-app").get_active():
return INSTALL_PAGE_CONTAINER_APP
if self.window.get_widget("method-container-os").get_active():
if self.widget("method-container-os").get_active():
return INSTALL_PAGE_CONTAINER_OS
def get_config_os_info(self):
d_list = self.window.get_widget("install-os-type")
d_list = self.widget("install-os-type")
d_idx = d_list.get_active()
v_list = self.window.get_widget("install-os-version")
v_list = self.widget("install-os-version")
v_idx = v_list.get_active()
distro = None
dlabel = None
@ -876,10 +874,10 @@ class vmmCreate(vmmGObjectUI):
return (distro, variant, dlabel, vlabel)
def get_config_local_media(self, store_media=False):
if self.window.get_widget("install-local-cdrom").get_active():
return self.window.get_widget("install-local-cdrom-combo").get_active_text()
if self.widget("install-local-cdrom").get_active():
return self.widget("install-local-cdrom-combo").get_active_text()
else:
ret = self.window.get_widget("install-local-box").child.get_text()
ret = self.widget("install-local-box").child.get_text()
if ret and store_media:
self.conn.config_add_iso_path(ret)
return ret
@ -891,16 +889,16 @@ class vmmCreate(vmmGObjectUI):
if instpage == INSTALL_PAGE_ISO:
media = self.get_config_local_media()
elif instpage == INSTALL_PAGE_URL:
media = self.window.get_widget("install-url-box").get_active_text()
media = self.widget("install-url-box").get_active_text()
elif instpage == INSTALL_PAGE_IMPORT:
media = self.window.get_widget("install-import-entry").get_text()
media = self.widget("install-import-entry").get_text()
return media
def get_config_url_info(self, store_media=False):
media = self.window.get_widget("install-url-box").get_active_text().strip()
extra = self.window.get_widget("install-urlopts-entry").get_text().strip()
ks = self.window.get_widget("install-ks-box").get_active_text().strip()
media = self.widget("install-url-box").get_active_text().strip()
extra = self.widget("install-urlopts-entry").get_text().strip()
ks = self.widget("install-ks-box").get_active_text().strip()
if media and store_media:
self.config.add_media_url(media)
@ -910,13 +908,13 @@ class vmmCreate(vmmGObjectUI):
return (media.strip(), extra.strip(), ks.strip())
def get_config_import_path(self):
return self.window.get_widget("install-import-entry").get_text()
return self.widget("install-import-entry").get_text()
def get_config_container_app_path(self):
return self.window.get_widget("install-app-entry").get_text()
return self.widget("install-app-entry").get_text()
def get_config_container_fs_path(self):
return self.window.get_widget("install-oscontainer-fs").get_text()
return self.widget("install-oscontainer-fs").get_text()
def get_default_path(self, name):
# Don't generate a new path if the install failed
@ -927,14 +925,14 @@ class vmmCreate(vmmGObjectUI):
return util.get_default_path(self.conn, name)
def is_default_storage(self):
usedef = self.window.get_widget("config-storage-create").get_active()
usedef = self.widget("config-storage-create").get_active()
isimport = (self.get_config_install_page() == INSTALL_PAGE_IMPORT)
return usedef and not isimport
def get_storage_info(self):
path = None
size = self.window.get_widget("config-storage-size").get_value()
sparse = not self.window.get_widget("config-storage-nosparse").get_active()
size = self.widget("config-storage-size").get_value()
sparse = not self.widget("config-storage-nosparse").get_active()
if self.get_config_install_page() == INSTALL_PAGE_IMPORT:
path = self.get_config_import_path()
@ -945,14 +943,14 @@ class vmmCreate(vmmGObjectUI):
path = self.get_default_path(self.guest.name)
logging.debug("Default storage path is: %s" % path)
else:
path = self.window.get_widget("config-storage-entry").get_text()
path = self.widget("config-storage-entry").get_text()
return (path, size, sparse)
def get_config_network_info(self):
net_list = self.window.get_widget("config-netdev")
bridge_ent = self.window.get_widget("config-netdev-bridge")
macaddr = self.window.get_widget("config-macaddr").get_text()
net_list = self.widget("config-netdev")
bridge_ent = self.widget("config-netdev-bridge")
macaddr = self.widget("config-macaddr").get_text()
net_type, net_src = uihelpers.get_network_selection(net_list,
bridge_ent)
@ -968,10 +966,10 @@ class vmmCreate(vmmGObjectUI):
return self.config.get_graphics_type()
def get_config_customize(self):
return self.window.get_widget("summary-customize").get_active()
return self.widget("summary-customize").get_active()
def is_detect_active(self):
return self.window.get_widget("install-detect-os").get_active()
return self.widget("install-detect-os").get_active()
# Listeners
@ -1000,7 +998,7 @@ class vmmCreate(vmmGObjectUI):
self.check_network_selection()
def check_network_selection(self):
src = self.window.get_widget("config-netdev")
src = self.widget("config-netdev")
idx = src.get_active()
show_pxe_warn = True
pxe_install = (self.get_config_install_page() == INSTALL_PAGE_PXE)
@ -1049,7 +1047,7 @@ class vmmCreate(vmmGObjectUI):
# If the url_entry has focus, don't fire detect_media_os, it means
# the user is probably typing
self.mediaDetected = False
if (self.window.get_widget("install-url-box").child.flags() &
if (self.widget("install-url-box").child.flags() &
gtk.HAS_FOCUS):
return
self.detect_media_os()
@ -1068,17 +1066,17 @@ class vmmCreate(vmmGObjectUI):
dodetect = src.get_active()
if dodetect:
self.window.get_widget("install-os-type-label").show()
self.window.get_widget("install-os-version-label").show()
self.window.get_widget("install-os-type").hide()
self.window.get_widget("install-os-version").hide()
self.widget("install-os-type-label").show()
self.widget("install-os-version-label").show()
self.widget("install-os-type").hide()
self.widget("install-os-version").hide()
self.mediaDetected = False
self.detect_media_os() # Run detection
else:
self.window.get_widget("install-os-type-label").hide()
self.window.get_widget("install-os-version-label").hide()
self.window.get_widget("install-os-type").show()
self.window.get_widget("install-os-version").show()
self.widget("install-os-type-label").hide()
self.widget("install-os-version-label").hide()
self.widget("install-os-type").show()
self.widget("install-os-version").show()
def change_os_type(self, box):
model = box.get_model()
@ -1086,28 +1084,28 @@ class vmmCreate(vmmGObjectUI):
_type = model.get_value(box.get_active_iter(), 0)
self.populate_os_variant_model(_type)
variant = self.window.get_widget("install-os-version")
variant = self.widget("install-os-version")
variant.set_active(0)
def toggle_local_cdrom(self, src):
combo = self.window.get_widget("install-local-cdrom-combo")
combo = self.widget("install-local-cdrom-combo")
is_active = src.get_active()
if is_active:
if combo.get_active() != -1:
# Local CDROM was selected with media preset, detect distro
self.detect_media_os()
self.window.get_widget("install-local-cdrom-combo").set_sensitive(is_active)
self.widget("install-local-cdrom-combo").set_sensitive(is_active)
def toggle_local_iso(self, src):
uselocal = src.get_active()
self.window.get_widget("install-local-box").set_sensitive(uselocal)
self.window.get_widget("install-local-browse").set_sensitive(uselocal)
self.widget("install-local-box").set_sensitive(uselocal)
self.widget("install-local-browse").set_sensitive(uselocal)
def detect_visibility_changed(self, src, ignore=None):
is_visible = src.get_property("visible")
detect_chkbox = self.window.get_widget("install-detect-os")
nodetect_label = self.window.get_widget("install-nodetect-label")
detect_chkbox = self.widget("install-detect-os")
nodetect_label = self.widget("install-nodetect-label")
detect_chkbox.set_active(is_visible)
detect_chkbox.toggled()
@ -1119,46 +1117,46 @@ class vmmCreate(vmmGObjectUI):
def browse_oscontainer(self, ignore1=None, ignore2=None):
def set_path(ignore, path):
self.window.get_widget("install-oscontainer-fs").set_text(path)
self.widget("install-oscontainer-fs").set_text(path)
self._browse_file(set_path, is_media=False, is_dir=True)
def browse_app(self, ignore1=None, ignore2=None):
def set_path(ignore, path):
self.window.get_widget("install-app-entry").set_text(path)
self.widget("install-app-entry").set_text(path)
self._browse_file(set_path, is_media=False)
def browse_import(self, ignore1=None, ignore2=None):
def set_path(ignore, path):
self.window.get_widget("install-import-entry").set_text(path)
self.widget("install-import-entry").set_text(path)
self._browse_file(set_path, is_media=False)
def browse_iso(self, ignore1=None, ignore2=None):
def set_path(ignore, path):
self.window.get_widget("install-local-box").child.set_text(path)
self.widget("install-local-box").child.set_text(path)
self._browse_file(set_path, is_media=True)
self.window.get_widget("install-local-box").activate()
self.widget("install-local-box").activate()
def browse_storage(self, ignore1):
def set_path(ignore, path):
self.window.get_widget("config-storage-entry").set_text(path)
self.widget("config-storage-entry").set_text(path)
self._browse_file(set_path, is_media=False)
def toggle_enable_storage(self, src):
self.window.get_widget("config-storage-box").set_sensitive(src.get_active())
self.widget("config-storage-box").set_sensitive(src.get_active())
def toggle_storage_select(self, src):
act = src.get_active()
self.window.get_widget("config-storage-browse-box").set_sensitive(act)
self.widget("config-storage-browse-box").set_sensitive(act)
def toggle_macaddr(self, src):
self.window.get_widget("config-macaddr").set_sensitive(src.get_active())
self.widget("config-macaddr").set_sensitive(src.get_active())
# Navigation methods
def set_install_page(self):
instnotebook = self.window.get_widget("install-method-pages")
detectbox = self.window.get_widget("install-detect-os-box")
osbox = self.window.get_widget("install-os-distro-box")
instnotebook = self.widget("install-method-pages")
detectbox = self.widget("install-detect-os-box")
osbox = self.widget("install-os-distro-box")
instpage = self.get_config_install_page()
# Setting OS value for a container guest doesn't really matter
@ -1195,7 +1193,7 @@ class vmmCreate(vmmGObjectUI):
INSTALL_PAGE_CONTAINER_OS]
def back(self, src_ignore):
notebook = self.window.get_widget("create-pages")
notebook = self.widget("create-pages")
curpage = notebook.get_current_page()
next_page = curpage - 1
@ -1208,7 +1206,7 @@ class vmmCreate(vmmGObjectUI):
notebook.set_current_page(next_page)
def forward(self, src_ignore=None):
notebook = self.window.get_widget("create-pages")
notebook = self.widget("create-pages")
curpage = notebook.get_current_page()
if self.have_startup_error:
@ -1232,7 +1230,7 @@ class vmmCreate(vmmGObjectUI):
# Skip storage page for import installs
next_page += 1
self.window.get_widget("create-forward").grab_focus()
self.widget("create-forward").grab_focus()
notebook.set_current_page(next_page)
def set_page_num_text(self, cur):
@ -1246,37 +1244,37 @@ class vmmCreate(vmmGObjectUI):
_("Step %(current_page)d of %(max_page)d") %
{'current_page': cur, 'max_page': final})
self.window.get_widget("config-pagenum").set_markup(page_lbl)
self.widget("config-pagenum").set_markup(page_lbl)
def page_changed(self, ignore1, ignore2, pagenum):
# Update page number
self.set_page_num_text(pagenum)
if pagenum == PAGE_NAME:
self.window.get_widget("create-back").set_sensitive(False)
self.widget("create-back").set_sensitive(False)
else:
self.window.get_widget("create-back").set_sensitive(True)
self.widget("create-back").set_sensitive(True)
if pagenum == PAGE_INSTALL:
self.detect_media_os()
self.window.get_widget("install-os-distro-box").set_property(
self.widget("install-os-distro-box").set_property(
"visible",
not self.container_install())
if pagenum != PAGE_FINISH:
self.window.get_widget("create-forward").show()
self.window.get_widget("create-finish").hide()
self.widget("create-forward").show()
self.widget("create-finish").hide()
return
# PAGE_FINISH
# This is hidden in reset_state, so that it doesn't distort
# the size of the wizard if it is expanded by default due to
# error
self.window.get_widget("config-advanced-expander").show()
self.widget("config-advanced-expander").show()
self.window.get_widget("create-forward").hide()
self.window.get_widget("create-finish").show()
self.window.get_widget("create-finish").grab_focus()
self.widget("create-forward").hide()
self.widget("create-finish").show()
self.widget("create-finish").grab_focus()
self.populate_summary()
# Repopulate the HV list, so we can make install method relevant
@ -1498,8 +1496,8 @@ class vmmCreate(vmmGObjectUI):
return True
def validate_mem_page(self):
cpus = self.window.get_widget("config-cpus").get_value()
mem = self.window.get_widget("config-mem").get_value()
cpus = self.widget("config-cpus").get_value()
mem = self.widget("config-mem").get_value()
# VCPUS
try:
@ -1517,7 +1515,7 @@ class vmmCreate(vmmGObjectUI):
return True
def validate_storage_page(self, revalidate=True):
use_storage = self.window.get_widget("enable-storage").get_active()
use_storage = self.widget("enable-storage").get_active()
instcd = self.get_config_install_page() == INSTALL_PAGE_ISO
# CD/ISO install and no disks implies LiveCD
@ -1664,7 +1662,7 @@ class vmmCreate(vmmGObjectUI):
def finish(self, src_ignore):
# Validate the final page
page = self.window.get_widget("create-pages").get_current_page()
page = self.widget("create-pages").get_current_page()
if self.validate(page) != True:
return False
@ -1849,8 +1847,8 @@ class vmmCreate(vmmGObjectUI):
if not self.is_detect_active():
return
self.window.get_widget("install-os-type-label").set_text(distro)
self.window.get_widget("install-os-version-label").set_text(ver)
self.widget("install-os-type-label").set_text(distro)
self.widget("install-os-version-label").set_text(ver)
def set_os_val(self, os_widget, value):
# Helper method to set the OS Type/Variant selections to the passed
@ -1880,9 +1878,9 @@ class vmmCreate(vmmGObjectUI):
if not self.is_detect_active():
return
dl = self.set_os_val(self.window.get_widget("install-os-type"),
dl = self.set_os_val(self.widget("install-os-type"),
distro)
vl = self.set_os_val(self.window.get_widget("install-os-version"),
vl = self.set_os_val(self.widget("install-os-version"),
ver)
self.set_distro_labels(dl, vl)
@ -1894,7 +1892,7 @@ class vmmCreate(vmmGObjectUI):
gtk.gdk.threads_leave()
def _set_forward_sensitive(self, val):
self.window.get_widget("create-forward").set_sensitive(val)
self.widget("create-forward").set_sensitive(val)
# The actual detection routine
def do_detect(self, forward):

98
src/virtManager/createinterface.py
View File

@ -177,26 +177,26 @@ class vmmCreateInterface(vmmGObjectUI):
def set_initial_state(self):
self.window.get_widget("pages").set_show_tabs(False)
self.widget("pages").set_show_tabs(False)
self.bond_config_win.get_widget("bond-pages").set_show_tabs(False)
# FIXME: Unhide this when we make some documentation
self.window.get_widget("help").hide()
self.widget("help").hide()
finish_img = gtk.image_new_from_stock(gtk.STOCK_QUIT,
gtk.ICON_SIZE_BUTTON)
self.window.get_widget("finish").set_image(finish_img)
self.widget("finish").set_image(finish_img)
blue = gtk.gdk.color_parse("#0072A8")
self.window.get_widget("header").modify_bg(gtk.STATE_NORMAL, blue)
self.widget("header").modify_bg(gtk.STATE_NORMAL, blue)
box = self.window.get_widget("header-icon-box")
box = self.widget("header-icon-box")
image = gtk.image_new_from_icon_name("network-idle",
gtk.ICON_SIZE_DIALOG)
image.show()
box.pack_end(image, False)
# Interface type
type_list = self.window.get_widget("interface-type")
type_list = self.widget("interface-type")
type_model = gtk.ListStore(str, str)
type_list.set_model(type_model)
text = gtk.CellRendererText()
@ -213,10 +213,10 @@ class vmmCreateInterface(vmmGObjectUI):
# Start mode
uihelpers.build_startmode_combo(
self.window.get_widget("interface-startmode"))
self.widget("interface-startmode"))
# Parent/slave Interface list
slave_list = self.window.get_widget("interface-list")
slave_list = self.widget("interface-list")
# [ vmmInterface, selected, selectabel, name, type, is defined,
# is active, in use by str, mac]
slave_model = gtk.ListStore(object, bool, bool, str, str, bool, bool,
@ -339,16 +339,16 @@ class vmmCreateInterface(vmmGObjectUI):
def reset_state(self):
self.window.get_widget("pages").set_current_page(PAGE_TYPE)
self.widget("pages").set_current_page(PAGE_TYPE)
self.page_changed(None, None, PAGE_TYPE)
self.window.get_widget("interface-type").set_active(0)
self.widget("interface-type").set_active(0)
# General details
self.window.get_widget("interface-name-entry").set_text("")
self.window.get_widget("interface-name-label").set_text("")
self.window.get_widget("interface-startmode").set_active(0)
self.window.get_widget("interface-activate").set_active(False)
self.widget("interface-name-entry").set_text("")
self.widget("interface-name-label").set_text("")
self.widget("interface-startmode").set_active(0)
self.widget("interface-activate").set_active(False)
# Bridge config
self.bridge_config_win.get_widget("bridge-delay").set_value(0)
@ -384,8 +384,8 @@ class vmmCreateInterface(vmmGObjectUI):
itype = self.get_config_interface_type()
# Set up default interface name
self.window.get_widget("interface-name-entry").hide()
self.window.get_widget("interface-name-label").hide()
self.widget("interface-name-entry").hide()
self.widget("interface-name-label").hide()
if itype in [Interface.Interface.INTERFACE_TYPE_BRIDGE,
Interface.Interface.INTERFACE_TYPE_BOND]:
@ -393,7 +393,7 @@ class vmmCreateInterface(vmmGObjectUI):
else:
widget = "interface-name-label"
self.window.get_widget(widget).show()
self.widget(widget).show()
default_name = self.get_default_name()
self.set_interface_name(default_name)
@ -406,10 +406,8 @@ class vmmCreateInterface(vmmGObjectUI):
for key, value in type_dict.items():
do_show = (key == itype)
self.window.get_widget("%s-label" % value).set_property("visible",
do_show)
self.window.get_widget("%s-box" % value).set_property("visible",
do_show)
self.widget("%s-label" % value).set_property("visible", do_show)
self.widget("%s-box" % value).set_property("visible", do_show)
if itype == Interface.Interface.INTERFACE_TYPE_BRIDGE:
self.update_bridge_desc()
@ -501,7 +499,7 @@ class vmmCreateInterface(vmmGObjectUI):
self.update_ip_desc()
def populate_interface_list(self, itype):
iface_list = self.window.get_widget("interface-list")
iface_list = self.widget("interface-list")
model = iface_list.get_model()
model.clear()
@ -519,7 +517,7 @@ class vmmCreateInterface(vmmGObjectUI):
elif itype == Interface.Interface.INTERFACE_TYPE_ETHERNET:
msg = _("Choose an unconfigured interface:")
self.window.get_widget("interface-list-text").set_text(msg)
self.widget("interface-list-text").set_text(msg)
iface_list = []
row_dict = {}
@ -583,7 +581,7 @@ class vmmCreateInterface(vmmGObjectUI):
iface = ifaces[0][INTERFACE_ROW_NAME]
if itype == Interface.Interface.INTERFACE_TYPE_VLAN:
tag = self.window.get_widget("vlan-tag").get_value()
tag = self.widget("vlan-tag").get_value()
name = "%s.%s" % (iface, int(tag))
elif itype == Interface.Interface.INTERFACE_TYPE_ETHERNET:
@ -597,29 +595,29 @@ class vmmCreateInterface(vmmGObjectUI):
#########################
def get_config_interface_type(self):
type_list = self.window.get_widget("interface-type")
type_list = self.widget("interface-type")
return type_list.get_model()[type_list.get_active()][0]
def set_interface_name(self, name):
if self.window.get_widget("interface-name-entry").get_property("visible"):
if self.widget("interface-name-entry").get_property("visible"):
widget = "interface-name-entry"
else:
widget = "interface-name-label"
self.window.get_widget(widget).set_text(name)
self.widget(widget).set_text(name)
def get_config_interface_name(self):
if self.window.get_widget("interface-name-entry").get_property("visible"):
return self.window.get_widget("interface-name-entry").get_text()
if self.widget("interface-name-entry").get_property("visible"):
return self.widget("interface-name-entry").get_text()
else:
return self.window.get_widget("interface-name-label").get_text()
return self.widget("interface-name-label").get_text()
def get_config_interface_startmode(self):
start_list = self.window.get_widget("interface-startmode")
start_list = self.widget("interface-startmode")
return start_list.get_model()[start_list.get_active()][0]
def get_config_selected_interfaces(self):
iface_list = self.window.get_widget("interface-list")
iface_list = self.widget("interface-list")
model = iface_list.get_model()
ret = []
@ -714,7 +712,7 @@ class vmmCreateInterface(vmmGObjectUI):
txt = "STP %s" % (stp and "on" or "off")
txt += ", delay %d sec" % int(delay)
self.window.get_widget("bridge-config-label").set_text(txt)
self.widget("bridge-config-label").set_text(txt)
def update_bond_desc(self):
mode_list = self.bond_config_win.get_widget("bond-mode")
@ -729,7 +727,7 @@ class vmmCreateInterface(vmmGObjectUI):
if mon:
txt += ", %s" % mon
self.window.get_widget("bond-config-label").set_text(txt)
self.widget("bond-config-label").set_text(txt)
def update_ip_desc(self):
is_manual, name, ipv4, ipv6, ignore = self.get_config_ip_info()
@ -763,10 +761,10 @@ class vmmCreateInterface(vmmGObjectUI):
if not label:
label = "No configuration"
self.window.get_widget("ip-config-label").set_text(label)
self.widget("ip-config-label").set_text(label)
def get_config_ip_info(self):
if not self.window.get_widget("ip-label").get_property("visible"):
if not self.widget("ip-label").get_property("visible"):
return [True, None, None, None, None]
if not self.validate_ip_info():
@ -872,18 +870,18 @@ class vmmCreateInterface(vmmGObjectUI):
#######################
def back(self, src):
notebook = self.window.get_widget("pages")
notebook = self.widget("pages")
curpage = notebook.get_current_page()
notebook.set_current_page(curpage - 1)
def forward(self, ignore):
notebook = self.window.get_widget("pages")
notebook = self.widget("pages")
curpage = notebook.get_current_page()
if self.validate(notebook.get_current_page()) != True:
return
self.window.get_widget("forward").grab_focus()
self.widget("forward").grab_focus()
notebook.set_current_page(curpage + 1)
def page_changed(self, ignore1, ignore2, pagenum):
@ -893,22 +891,22 @@ class vmmCreateInterface(vmmGObjectUI):
_("Step %(current_page)d of %(max_page)d") %
{'current_page': next_page, 'max_page': PAGE_DETAILS + 1})
self.window.get_widget("header-pagenum").set_markup(page_lbl)
self.widget("header-pagenum").set_markup(page_lbl)
if pagenum == 0:
self.window.get_widget("back").set_sensitive(False)
self.widget("back").set_sensitive(False)
else:
self.window.get_widget("back").set_sensitive(True)
self.widget("back").set_sensitive(True)
if pagenum == PAGE_DETAILS:
self.populate_details_page()
self.window.get_widget("forward").hide()
self.window.get_widget("finish").show()
self.window.get_widget("finish").grab_focus()
self.widget("forward").hide()
self.widget("finish").show()
self.widget("finish").grab_focus()
else:
self.window.get_widget("forward").show()
self.window.get_widget("finish").hide()
self.widget("forward").show()
self.widget("finish").hide()
def validate(self, pagenum):
try:
@ -1067,7 +1065,7 @@ class vmmCreateInterface(vmmGObjectUI):
def validate_vlan(self, iobj, ifaces):
idx = self.window.get_widget("vlan-tag").get_value()
idx = self.widget("vlan-tag").get_value()
iobj.tag = int(idx)
return True
@ -1115,11 +1113,11 @@ class vmmCreateInterface(vmmGObjectUI):
def finish(self, src):
# Validate the final page
page = self.window.get_widget("pages").get_current_page()
page = self.widget("pages").get_current_page()
if self.validate(page) != True:
return False
activate = self.window.get_widget("interface-activate").get_active()
activate = self.widget("interface-activate").get_active()
# Start the install
self.topwin.set_sensitive(False)

159
src/virtManager/createnet.py
View File

@ -59,10 +59,10 @@ class vmmCreateNetwork(vmmGObjectUI):
self.bind_escape_key_close()
# XXX: Help docs useless/out of date
self.window.get_widget("create-help").hide()
self.widget("create-help").hide()
finish_img = gtk.image_new_from_stock(gtk.STOCK_QUIT,
gtk.ICON_SIZE_BUTTON)
self.window.get_widget("create-finish").set_image(finish_img)
self.widget("create-finish").set_image(finish_img)
self.set_initial_state()
@ -87,15 +87,15 @@ class vmmCreateNetwork(vmmGObjectUI):
vmmGObjectUI.cleanup(self)
def set_initial_state(self):
notebook = self.window.get_widget("create-pages")
notebook = self.widget("create-pages")
notebook.set_show_tabs(False)
black = gtk.gdk.color_parse("#000")
for num in range(PAGE_SUMMARY + 1):
name = "page" + str(num) + "-title"
self.window.get_widget(name).modify_bg(gtk.STATE_NORMAL, black)
self.widget(name).modify_bg(gtk.STATE_NORMAL, black)
fw_list = self.window.get_widget("net-forward")
fw_list = self.widget("net-forward")
# [ label, dev name ]
fw_model = gtk.ListStore(str, str)
fw_list.set_model(fw_model)
@ -109,7 +109,7 @@ class vmmCreateNetwork(vmmGObjectUI):
fw_model.append([_("Physical device %s") % (net.get_name()),
net.get_name()])
mode_list = self.window.get_widget("net-forward-mode")
mode_list = self.widget("net-forward-mode")
# [ label, mode ]
mode_model = gtk.ListStore(str, str)
mode_list.set_model(mode_model)
@ -121,32 +121,32 @@ class vmmCreateNetwork(vmmGObjectUI):
mode_model.append([_("Routed"), "route"])
def reset_state(self):
notebook = self.window.get_widget("create-pages")
notebook = self.widget("create-pages")
notebook.set_current_page(0)
self.page_changed(None, None, 0)
self.window.get_widget("net-name").set_text("")
self.window.get_widget("net-network").set_text("192.168.100.0/24")
self.window.get_widget("net-dhcp-enable").set_active(True)
self.window.get_widget("net-dhcp-start").set_text("")
self.window.get_widget("net-dhcp-end").set_text("")
self.window.get_widget("net-forward-none").set_active(True)
self.widget("net-name").set_text("")
self.widget("net-network").set_text("192.168.100.0/24")
self.widget("net-dhcp-enable").set_active(True)
self.widget("net-dhcp-start").set_text("")
self.widget("net-dhcp-end").set_text("")
self.widget("net-forward-none").set_active(True)
self.window.get_widget("net-forward").set_active(0)
self.window.get_widget("net-forward-mode").set_active(0)
self.widget("net-forward").set_active(0)
self.widget("net-forward-mode").set_active(0)
def forward(self, ignore=None):
notebook = self.window.get_widget("create-pages")
notebook = self.widget("create-pages")
if self.validate(notebook.get_current_page()) != True:
return
self.window.get_widget("create-forward").grab_focus()
self.widget("create-forward").grab_focus()
notebook.next_page()
def back(self, ignore=None):
notebook = self.window.get_widget("create-pages")
notebook = self.widget("create-pages")
notebook.prev_page()
def change_network(self, src):
@ -159,11 +159,11 @@ class vmmCreateNetwork(vmmGObjectUI):
# No IP specified or invalid IP
if ip is None or ip.version() != 4:
src.modify_base(gtk.STATE_NORMAL, red)
self.window.get_widget("net-info-netmask").set_text("")
self.window.get_widget("net-info-broadcast").set_text("")
self.window.get_widget("net-info-gateway").set_text("")
self.window.get_widget("net-info-size").set_text("")
self.window.get_widget("net-info-type").set_text("")
self.widget("net-info-netmask").set_text("")
self.widget("net-info-broadcast").set_text("")
self.widget("net-info-gateway").set_text("")
self.widget("net-info-size").set_text("")
self.widget("net-info-type").set_text("")
return
# We've got a valid IP
@ -171,30 +171,29 @@ class vmmCreateNetwork(vmmGObjectUI):
src.modify_base(gtk.STATE_NORMAL, red)
else:
src.modify_base(gtk.STATE_NORMAL, green)
self.window.get_widget("net-info-netmask").set_text(str(ip.netmask()))
self.window.get_widget("net-info-broadcast").set_text(
str(ip.broadcast()))
self.widget("net-info-netmask").set_text(str(ip.netmask()))
self.widget("net-info-broadcast").set_text(str(ip.broadcast()))
if ip.len() <= 1:
self.window.get_widget("net-info-gateway").set_text("")
self.widget("net-info-gateway").set_text("")
else:
self.window.get_widget("net-info-gateway").set_text(str(ip[1]))
self.window.get_widget("net-info-size").set_text(_("%d addresses") %
self.widget("net-info-gateway").set_text(str(ip[1]))
self.widget("net-info-size").set_text(_("%d addresses") %
(ip.len()))
if ip.iptype() == "PUBLIC":
self.window.get_widget("net-info-type").set_text(_("Public"))
self.widget("net-info-type").set_text(_("Public"))
elif ip.iptype() == "PRIVATE":
self.window.get_widget("net-info-type").set_text(_("Private"))
self.widget("net-info-type").set_text(_("Private"))
elif ip.iptype() == "RESERVED":
self.window.get_widget("net-info-type").set_text(_("Reserved"))
self.widget("net-info-type").set_text(_("Reserved"))
else:
self.window.get_widget("net-info-type").set_text(_("Other"))
self.widget("net-info-type").set_text(_("Other"))
def change_dhcp_enable(self, src):
val = src.get_active()
self.window.get_widget("net-dhcp-start").set_sensitive(val)
self.window.get_widget("net-dhcp-end").set_sensitive(val)
self.widget("net-dhcp-start").set_sensitive(val)
self.widget("net-dhcp-end").set_sensitive(val)
def change_dhcp_start(self, src):
end = self.get_config_dhcp_start()
@ -217,95 +216,89 @@ class vmmCreateNetwork(vmmGObjectUI):
src.modify_base(gtk.STATE_NORMAL, green)
def change_forward_type(self, src_ignore):
skip_fwd = self.window.get_widget("net-forward-none").get_active()
skip_fwd = self.widget("net-forward-none").get_active()
self.window.get_widget("net-forward-mode").set_sensitive(not skip_fwd)
self.window.get_widget("net-forward").set_sensitive(not skip_fwd)
self.widget("net-forward-mode").set_sensitive(not skip_fwd)
self.widget("net-forward").set_sensitive(not skip_fwd)
def get_config_name(self):
return self.window.get_widget("net-name").get_text()
return self.widget("net-name").get_text()
def get_config_ip4(self):
try:
return IP(self.window.get_widget("net-network").get_text())
return IP(self.widget("net-network").get_text())
except:
return None
def get_config_dhcp_start(self):
try:
return IP(self.window.get_widget("net-dhcp-start").get_text())
return IP(self.widget("net-dhcp-start").get_text())
except:
return None
def get_config_dhcp_end(self):
try:
return IP(self.window.get_widget("net-dhcp-end").get_text())
return IP(self.widget("net-dhcp-end").get_text())
except:
return None
def get_config_forwarding(self):
if self.window.get_widget("net-forward-none").get_active():
if self.widget("net-forward-none").get_active():
return [None, None]
else:
dev = self.window.get_widget("net-forward")
dev = self.widget("net-forward")
model = dev.get_model()
active = dev.get_active()
name = model[active][1]
mode_w = self.window.get_widget("net-forward-mode")
mode_w = self.widget("net-forward-mode")
mode = mode_w.get_model()[mode_w.get_active()][1]
return [name, mode]
def get_config_dhcp_enable(self):
return self.window.get_widget("net-dhcp-enable").get_active()
return self.widget("net-dhcp-enable").get_active()
def populate_summary(self):
dodhcp = self.get_config_dhcp_enable()
self.window.get_widget("summary-name").set_text(self.get_config_name())
self.widget("summary-name").set_text(self.get_config_name())
ip = self.get_config_ip4()
self.window.get_widget("summary-ip4-network").set_text(str(ip))
self.window.get_widget("summary-ip4-gateway").set_text(str(ip[1]))
self.window.get_widget("summary-ip4-netmask").set_text(
str(ip.netmask()))
self.widget("summary-ip4-network").set_text(str(ip))
self.widget("summary-ip4-gateway").set_text(str(ip[1]))
self.widget("summary-ip4-netmask").set_text(str(ip.netmask()))
self.window.get_widget("label-dhcp-end").set_property("visible",
dodhcp)
self.window.get_widget("summary-dhcp-end").set_property("visible",
dodhcp)
self.widget("label-dhcp-end").set_property("visible", dodhcp)
self.widget("summary-dhcp-end").set_property("visible", dodhcp)
if dodhcp:
start = self.get_config_dhcp_start()
end = self.get_config_dhcp_end()
self.window.get_widget("summary-dhcp-start").set_text(str(start))
self.window.get_widget("summary-dhcp-end").set_text(str(end))
self.window.get_widget("label-dhcp-start").set_text(
_("Start address:"))
self.window.get_widget("label-dhcp-end").show()
self.window.get_widget("summary-dhcp-end").show()
self.widget("summary-dhcp-start").set_text(str(start))
self.widget("summary-dhcp-end").set_text(str(end))
self.widget("label-dhcp-start").set_text(_("Start address:"))
self.widget("label-dhcp-end").show()
self.widget("summary-dhcp-end").show()
else:
self.window.get_widget("label-dhcp-start").set_text(
_("Status:"))
self.window.get_widget("summary-dhcp-start").set_text(
_("Disabled"))
self.widget("label-dhcp-start").set_text(_("Status:"))
self.widget("summary-dhcp-start").set_text(_("Disabled"))
forward_txt = ""
dev, mode = self.get_config_forwarding()
forward_txt = vmmNetwork.pretty_desc(mode, dev)
self.window.get_widget("summary-forwarding").set_text(forward_txt)
self.widget("summary-forwarding").set_text(forward_txt)
def populate_dhcp(self):
ip = self.get_config_ip4()
start = int(ip.len() / 2)
end = ip.len() - 2
if self.window.get_widget("net-dhcp-start").get_text() == "":
self.window.get_widget("net-dhcp-start").set_text(str(ip[start]))
if self.window.get_widget("net-dhcp-end").get_text() == "":
self.window.get_widget("net-dhcp-end").set_text(str(ip[end]))
if self.widget("net-dhcp-start").get_text() == "":
self.widget("net-dhcp-start").set_text(str(ip[start]))
if self.widget("net-dhcp-end").get_text() == "":
self.widget("net-dhcp-end").set_text(str(ip[end]))
def page_changed(self, ignore1, ignore2, page_number):
if page_number == PAGE_NAME:
name_widget = self.window.get_widget("net-name")
name_widget = self.widget("net-name")
name_widget.grab_focus()
elif page_number == PAGE_DHCP:
self.populate_dhcp()
@ -313,17 +306,17 @@ class vmmCreateNetwork(vmmGObjectUI):
self.populate_summary()
if page_number == PAGE_INTRO:
self.window.get_widget("create-back").set_sensitive(False)
self.widget("create-back").set_sensitive(False)
else:
self.window.get_widget("create-back").set_sensitive(True)
self.widget("create-back").set_sensitive(True)
if page_number == PAGE_SUMMARY:
self.window.get_widget("create-forward").hide()
self.window.get_widget("create-finish").show()
self.window.get_widget("create-finish").grab_focus()
self.widget("create-forward").hide()
self.widget("create-finish").show()
self.widget("create-finish").grab_focus()
else:
self.window.get_widget("create-forward").show()
self.window.get_widget("create-finish").hide()
self.widget("create-forward").show()
self.widget("create-finish").hide()
def finish(self, ignore=None):
@ -366,7 +359,7 @@ class vmmCreateNetwork(vmmGObjectUI):
self.close()
def validate_name(self):
name = self.window.get_widget("net-name").get_text()
name = self.widget("net-name").get_text()
if len(name) > 50 or len(name) == 0:
return self.err.val_err(_("Invalid Network Name"),
_("Network name must be non-blank and less than "
@ -404,7 +397,7 @@ class vmmCreateNetwork(vmmGObjectUI):
ip = self.get_config_ip4()
start = self.get_config_dhcp_start()
end = self.get_config_dhcp_end()
enabled = self.window.get_widget("net-dhcp-enable").get_active()
enabled = self.widget("net-dhcp-enable").get_active()
if enabled and start is None:
return self.err.val_err(_("Invalid DHCP Address"),
@ -424,10 +417,10 @@ class vmmCreateNetwork(vmmGObjectUI):
return True
def validate_forwarding(self):
if not self.window.get_widget("net-forward-dev").get_active():
if not self.widget("net-forward-dev").get_active():
return True
dev = self.window.get_widget("net-forward")
dev = self.widget("net-forward")
if dev.get_active() == -1:
return self.err.val_err(_("Invalid forwarding mode"),
_("Please select where the traffic should be forwarded"))
@ -446,7 +439,7 @@ class vmmCreateNetwork(vmmGObjectUI):
def show_help(self, src_ignore):
# help to show depends on the notebook page, yahoo
page = self.window.get_widget("create-pages").get_current_page()
page = self.widget("create-pages").get_current_page()
if page == PAGE_INTRO:
self.emit("action-show-help", "virt-manager-create-net-intro")
elif page == PAGE_NAME:

135
src/virtManager/createpool.py
View File

@ -93,10 +93,10 @@ class vmmCreatePool(vmmGObjectUI):
self.bind_escape_key_close()
# XXX: Help docs useless/out of date
self.window.get_widget("pool-help").hide()
self.widget("pool-help").hide()
finish_img = gtk.image_new_from_stock(gtk.STOCK_QUIT,
gtk.ICON_SIZE_BUTTON)
self.window.get_widget("pool-finish").set_image(finish_img)
self.widget("pool-finish").set_image(finish_img)
self.set_initial_state()
@ -118,16 +118,16 @@ class vmmCreatePool(vmmGObjectUI):
vmmGObjectUI.cleanup(self)
def set_initial_state(self):
self.window.get_widget("pool-pages").set_show_tabs(False)
self.widget("pool-pages").set_show_tabs(False)
type_list = self.window.get_widget("pool-type")
type_list = self.widget("pool-type")
type_model = gtk.ListStore(str, str)
type_list.set_model(type_model)
text1 = gtk.CellRendererText()
type_list.pack_start(text1, True)
type_list.add_attribute(text1, 'text', 1)
format_list = self.window.get_widget("pool-format")
format_list = self.widget("pool-format")
format_model = gtk.ListStore(str, str)
format_list.set_model(format_model)
text2 = gtk.CellRendererText()
@ -135,7 +135,7 @@ class vmmCreatePool(vmmGObjectUI):
format_list.add_attribute(text2, 'text', 1)
# Target path combo box entry
target_list = self.window.get_widget("pool-target-path")
target_list = self.widget("pool-target-path")
# target_path, Label, pool class instance
target_model = gtk.ListStore(str, str, object)
target_model.set_sort_column_id(0, gtk.SORT_ASCENDING)
@ -145,7 +145,7 @@ class vmmCreatePool(vmmGObjectUI):
"target_path", "pool-info2")
# Source path combo box entry
source_list = self.window.get_widget("pool-source-path")
source_list = self.widget("pool-source-path")
# source_path, Label, pool class instance
source_model = gtk.ListStore(str, str, object)
source_model.set_sort_column_id(0, gtk.SORT_ASCENDING)
@ -156,24 +156,26 @@ class vmmCreatePool(vmmGObjectUI):
self.populate_pool_type()
self.window.get_widget("pool-info-box1").modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("grey"))
self.window.get_widget("pool-info-box2").modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("grey"))
self.widget("pool-info-box1").modify_bg(gtk.STATE_NORMAL,
gtk.gdk.color_parse("grey"))
self.widget("pool-info-box2").modify_bg(gtk.STATE_NORMAL,
gtk.gdk.color_parse("grey"))
def reset_state(self):
self.window.get_widget("pool-pages").set_current_page(0)
self.window.get_widget("pool-forward").show()
self.window.get_widget("pool-finish").hide()
self.window.get_widget("pool-back").set_sensitive(False)
self.widget("pool-pages").set_current_page(0)
self.widget("pool-forward").show()
self.widget("pool-finish").hide()
self.widget("pool-back").set_sensitive(False)
self.window.get_widget("pool-name").set_text("")
self.window.get_widget("pool-name").grab_focus()
self.window.get_widget("pool-type").set_active(0)
self.window.get_widget("pool-target-path").child.set_text("")
self.window.get_widget("pool-source-path").child.set_text("")
self.window.get_widget("pool-hostname").set_text("")
self.window.get_widget("pool-format").set_active(-1)
self.window.get_widget("pool-build").set_sensitive(True)
self.window.get_widget("pool-build").set_active(False)
self.widget("pool-name").set_text("")
self.widget("pool-name").grab_focus()
self.widget("pool-type").set_active(0)
self.widget("pool-target-path").child.set_text("")
self.widget("pool-source-path").child.set_text("")
self.widget("pool-hostname").set_text("")
self.widget("pool-format").set_active(-1)
self.widget("pool-build").set_sensitive(True)
self.widget("pool-build").set_active(False)
def hostname_changed(self, ignore):
@ -181,25 +183,26 @@ class vmmCreatePool(vmmGObjectUI):
self.populate_pool_sources()
def populate_pool_type(self):
model = self.window.get_widget("pool-type").get_model()
model = self.widget("pool-type").get_model()
model.clear()
types = Storage.StoragePool.get_pool_types()
types.sort()
for typ in types:
model.append([typ, "%s: %s" % (typ, Storage.StoragePool.get_pool_type_desc(typ))])
model.append([typ, "%s: %s" %
(typ, Storage.StoragePool.get_pool_type_desc(typ))])
def populate_pool_format(self, formats):
model = self.window.get_widget("pool-format").get_model()
model = self.widget("pool-format").get_model()
model.clear()
for f in formats:
model.append([f, f])
def populate_pool_sources(self):
source_list = self.window.get_widget("pool-source-path")
source_list = self.widget("pool-source-path")
source_model = source_list.get_model()
source_model.clear()
target_list = self.window.get_widget("pool-target-path")
target_list = self.widget("pool-target-path")
target_model = target_list.get_model()
target_model.clear()
@ -278,31 +281,31 @@ class vmmCreatePool(vmmGObjectUI):
Storage.StoragePool.TYPE_SCSI]:
src_b = False
self.window.get_widget("pool-target-button").set_sensitive(tgt_b)
self.window.get_widget("pool-source-button").set_sensitive(src_b)
self.window.get_widget("pool-source-path").set_sensitive(src)
self.window.get_widget("pool-hostname").set_sensitive(host)
self.window.get_widget("pool-format").set_sensitive(fmt)
self.window.get_widget("pool-format").set_active(-1)
self.widget("pool-target-button").set_sensitive(tgt_b)
self.widget("pool-source-button").set_sensitive(src_b)
self.widget("pool-source-path").set_sensitive(src)
self.widget("pool-hostname").set_sensitive(host)
self.widget("pool-format").set_sensitive(fmt)
self.widget("pool-format").set_active(-1)
if fmt:
self.populate_pool_format(getattr(self._pool, "formats"))
self.window.get_widget("pool-format").set_active(0)
self.widget("pool-format").set_active(0)
self.populate_pool_sources()
def get_config_type(self):
typ = self.window.get_widget("pool-type")
typ = self.widget("pool-type")
if typ.get_active_iter() != None:
return typ.get_model().get_value(typ.get_active_iter(), 0)
return None
def get_config_name(self):
return self.window.get_widget("pool-name").get_text()
return self.widget("pool-name").get_text()
def get_config_target_path(self):
src = self.window.get_widget("pool-target-path")
src = self.widget("pool-target-path")
if not src.get_property("sensitive"):
return None
@ -315,7 +318,7 @@ class vmmCreatePool(vmmGObjectUI):
return src.child.get_text()
def get_config_source_path(self):
src = self.window.get_widget("pool-source-path")
src = self.widget("pool-source-path")
if not src.get_property("sensitive"):
return None
@ -328,13 +331,13 @@ class vmmCreatePool(vmmGObjectUI):
return src.child.get_text().strip()
def get_config_host(self):
host = self.window.get_widget("pool-hostname")
host = self.widget("pool-hostname")
if host.get_property("sensitive"):
return host.get_text().strip()
return None
def get_config_format(self):
format_combo = self.window.get_widget("pool-format")
format_combo = self.widget("pool-format")
model = format_combo.get_model()
if format_combo.get_active_iter() != None:
model = format_combo.get_model()
@ -363,34 +366,34 @@ class vmmCreatePool(vmmGObjectUI):
source = self._browse_file(_("Choose source path"),
startfolder="/dev", foldermode=False)
if source:
self.window.get_widget("pool-source-path").child.set_text(source)
self.widget("pool-source-path").child.set_text(source)
def browse_target_path(self, ignore1=None):
target = self._browse_file(_("Choose target directory"),
startfolder="/var/lib/libvirt",
foldermode=True)
if target:
self.window.get_widget("pool-target-path").child.set_text(target)
self.widget("pool-target-path").child.set_text(target)
def forward(self, ignore=None):
notebook = self.window.get_widget("pool-pages")
notebook = self.widget("pool-pages")
try:
if(self.validate(notebook.get_current_page()) != True):
return
if notebook.get_current_page() == PAGE_FORMAT:
self.finish()
else:
self.window.get_widget("pool-forward").grab_focus()
self.widget("pool-forward").grab_focus()
notebook.next_page()
except Exception, e:
self.err.show_err(_("Uncaught error validating input: %s") % str(e))
return
def back(self, ignore=None):
self.window.get_widget("pool-finish").hide()
self.window.get_widget("pool-forward").show()
self.window.get_widget("pool-pages").prev_page()
self.widget("pool-finish").hide()
self.widget("pool-forward").show()
self.widget("pool-pages").prev_page()
def finish(self):
self.topwin.set_sensitive(False)
@ -422,26 +425,27 @@ class vmmCreatePool(vmmGObjectUI):
self._pool.conn = newconn
logging.debug("Starting backround pool creation.")
build = self.window.get_widget("pool-build").get_active()
build = self.widget("pool-build").get_active()
poolobj = self._pool.install(create=True, meter=meter, build=build)
poolobj.setAutostart(True)
logging.debug("Pool creation succeeded")
def page_changed(self, notebook_ignore, page_ignore, page_number):
if page_number == PAGE_NAME:
self.window.get_widget("pool-back").set_sensitive(False)
self.window.get_widget("pool-finish").hide()
self.window.get_widget("pool-forward").show()
self.window.get_widget("pool-forward").grab_focus()
self.widget("pool-back").set_sensitive(False)
self.widget("pool-finish").hide()
self.widget("pool-forward").show()
self.widget("pool-forward").grab_focus()
elif page_number == PAGE_FORMAT:
self.window.get_widget("pool-target-path").child.set_text(self._pool.target_path)
self.window.get_widget("pool-back").set_sensitive(True)
self.widget("pool-target-path").child.set_text(
self._pool.target_path)
self.widget("pool-back").set_sensitive(True)
buildret = self.get_build_default()
self.window.get_widget("pool-build").set_sensitive(buildret[1])
self.window.get_widget("pool-build").set_active(buildret[0])
self.window.get_widget("pool-finish").show()
self.window.get_widget("pool-finish").grab_focus()
self.window.get_widget("pool-forward").hide()
self.widget("pool-build").set_sensitive(buildret[1])
self.widget("pool-build").set_active(buildret[0])
self.widget("pool-finish").show()
self.widget("pool-finish").grab_focus()
self.widget("pool-forward").hide()
self.show_options_by_pool()
def get_pool_to_validate(self):
@ -450,8 +454,8 @@ class vmmCreatePool(vmmGObjectUI):
For most pools this will be the one we built after step 1, but for
pools we find via FindPoolSources, this will be different
"""
source_list = self.window.get_widget("pool-source-path")
target_list = self.window.get_widget("pool-target-path")
source_list = self.widget("pool-source-path")
target_list = self.widget("pool-target-path")
pool = copy.copy(self._pool)
@ -496,9 +500,8 @@ class vmmCreatePool(vmmGObjectUI):
except ValueError, e:
return self.err.val_err(_("Pool Parameter Error"), str(e))
buildval = self.window.get_widget("pool-build").get_active()
buildsen = self.window.get_widget("pool-build").get_property(
"sensitive")
buildval = self.widget("pool-build").get_active()
buildsen = self.widget("pool-build").get_property("sensitive")
if buildsen and buildval:
ret = self.err.yes_no(_("Building a pool of this type will "
"format the source device. Are you "
@ -511,7 +514,7 @@ class vmmCreatePool(vmmGObjectUI):
def update_doc(self, ignore1, ignore2, param, infobox):
doc = self._build_doc_str(param)
self.window.get_widget(infobox).set_markup(doc)
self.widget(infobox).set_markup(doc)
def update_build_doc(self, ignore1, ignore2):
doc = ""
@ -523,7 +526,7 @@ class vmmCreatePool(vmmGObjectUI):
if docstr:
doc = self._build_doc_str("build", docstr)
self.window.get_widget("pool-info2").set_markup(doc)
self.widget("pool-info2").set_markup(doc)
def update_doc_changed(self, ignore1, param, infobox):
# Wrapper for update_doc and 'changed' signal

62
src/virtManager/createvol.py
View File

@ -52,20 +52,20 @@ class vmmCreateVolume(vmmGObjectUI):
})
self.bind_escape_key_close()
format_list = self.window.get_widget("vol-format")
format_list = self.widget("vol-format")
format_model = gtk.ListStore(str, str)
format_list.set_model(format_model)
text2 = gtk.CellRendererText()
format_list.pack_start(text2, False)
format_list.add_attribute(text2, 'text', 1)
self.window.get_widget("vol-info-view").modify_bg(gtk.STATE_NORMAL,
gtk.gdk.color_parse("grey"))
self.widget("vol-info-view").modify_bg(gtk.STATE_NORMAL,
gtk.gdk.color_parse("grey"))
# XXX: Help docs useless/out of date
self.window.get_widget("pool-help").hide()
self.widget("pool-help").hide()
finish_img = gtk.image_new_from_stock(gtk.STOCK_QUIT,
gtk.ICON_SIZE_BUTTON)
self.window.get_widget("vol-create").set_image(finish_img)
self.widget("vol-create").set_image(finish_img)
self.reset_state()
@ -125,32 +125,36 @@ class vmmCreateVolume(vmmGObjectUI):
def reset_state(self):
default_name = self.default_vol_name()
self.window.get_widget("vol-name").set_text("")
self.window.get_widget("vol-create").set_sensitive(False)
self.widget("vol-name").set_text("")
self.widget("vol-create").set_sensitive(False)
if default_name:
self.window.get_widget("vol-name").set_text(default_name)
self.widget("vol-name").set_text(default_name)
self.window.get_widget("vol-name").grab_focus()
self.widget("vol-name").grab_focus()
self.populate_vol_format()
self.populate_vol_suffix()
if len(self.vol_class.formats):
self.window.get_widget("vol-format").set_sensitive(True)
self.window.get_widget("vol-format").set_active(0)
self.widget("vol-format").set_sensitive(True)
self.widget("vol-format").set_active(0)
else:
self.window.get_widget("vol-format").set_sensitive(False)
self.widget("vol-format").set_sensitive(False)
self.window.get_widget("vol-allocation").set_range(0, int(self.parent_pool.get_available() / 1024 / 1024))
self.window.get_widget("vol-allocation").set_value(DEFAULT_ALLOC)
self.window.get_widget("vol-capacity").set_range(1, int(self.parent_pool.get_available() / 1024 / 1024))
self.window.get_widget("vol-capacity").set_value(DEFAULT_CAP)
self.widget("vol-allocation").set_range(0,
int(self.parent_pool.get_available() / 1024 / 1024))
self.widget("vol-allocation").set_value(DEFAULT_ALLOC)
self.widget("vol-capacity").set_range(1,
int(self.parent_pool.get_available() / 1024 / 1024))
self.widget("vol-capacity").set_value(DEFAULT_CAP)
self.window.get_widget("vol-parent-name").set_markup("<b>" + self.parent_pool.get_name() + "'s</b>")
self.window.get_widget("vol-parent-space").set_text(self.parent_pool.get_pretty_available())
self.widget("vol-parent-name").set_markup(
"<b>" + self.parent_pool.get_name() + "'s</b>")
self.widget("vol-parent-space").set_text(
self.parent_pool.get_pretty_available())
def get_config_format(self):
format_combo = self.window.get_widget("vol-format")
format_combo = self.widget("vol-format")
model = format_combo.get_model()
if format_combo.get_active_iter() != None:
model = format_combo.get_model()
@ -158,7 +162,7 @@ class vmmCreateVolume(vmmGObjectUI):
return None
def populate_vol_format(self):
model = self.window.get_widget("vol-format").get_model()
model = self.widget("vol-format").get_model()
model.clear()
formats = self.vol_class.formats
@ -172,14 +176,14 @@ class vmmCreateVolume(vmmGObjectUI):
suffix = self.default_suffix()
if self.vol_class == Storage.FileVolume:
suffix = ".img"
self.window.get_widget("vol-name-suffix").set_text(suffix)
self.widget("vol-name-suffix").set_text(suffix)
def vol_name_changed(self, src):
text = src.get_text()
self.window.get_widget("vol-create").set_sensitive(bool(text))
self.widget("vol-create").set_sensitive(bool(text))
def vol_allocation_changed(self, src):
cap_widget = self.window.get_widget("vol-capacity")
cap_widget = self.widget("vol-capacity")
alloc = src.get_value()
cap = cap_widget.get_value()
@ -188,10 +192,10 @@ class vmmCreateVolume(vmmGObjectUI):
cap_widget.set_value(alloc)
def vol_capacity_changed(self, src):
alloc_widget = self.window.get_widget("vol-allocation")
alloc_widget = self.widget("vol-allocation")
cap = src.get_value()
alloc = self.window.get_widget("vol-allocation").get_value()
alloc = self.widget("vol-allocation").get_value()
if cap < alloc:
alloc_widget.set_value(cap)
@ -240,12 +244,12 @@ class vmmCreateVolume(vmmGObjectUI):
self.vol.install(meter=meter)
def validate(self):
name = self.window.get_widget("vol-name").get_text()
suffix = self.window.get_widget("vol-name-suffix").get_text()
name = self.widget("vol-name").get_text()
suffix = self.widget("vol-name-suffix").get_text()
volname = name + suffix
fmt = self.get_config_format()
alloc = self.window.get_widget("vol-allocation").get_value()
cap = self.window.get_widget("vol-capacity").get_value()
alloc = self.widget("vol-allocation").get_value()
cap = self.widget("vol-capacity").get_value()
try:
self.vol = self.vol_class(name=volname,

22
src/virtManager/delete.py
View File

@ -58,13 +58,13 @@ class vmmDeleteDialog(vmmGObjectUI):
image = gtk.image_new_from_icon_name("vm_delete_wizard",
gtk.ICON_SIZE_DIALOG)
image.show()
self.window.get_widget("icon-box").pack_end(image, False)
self.widget("icon-box").pack_end(image, False)
prepare_storage_list(self.window.get_widget("delete-storage-list"))
prepare_storage_list(self.widget("delete-storage-list"))
def toggle_remove_storage(self, src):
dodel = src.get_active()
self.window.get_widget("delete-storage-list").set_sensitive(dodel)
self.widget("delete-storage-list").set_sensitive(dodel)
def show(self, vm, parent):
@ -94,19 +94,19 @@ class vmmDeleteDialog(vmmGObjectUI):
# Set VM name in title'
title_str = ("<span size='x-large'>%s '%s'</span>" %
(_("Delete"), self.vm.get_name()))
self.window.get_widget("delete-main-label").set_markup(title_str)
self.widget("delete-main-label").set_markup(title_str)
self.window.get_widget("delete-cancel").grab_focus()
self.widget("delete-cancel").grab_focus()
# Disable storage removal by default
self.window.get_widget("delete-remove-storage").set_active(False)
self.window.get_widget("delete-remove-storage").toggled()
self.widget("delete-remove-storage").set_active(False)
self.widget("delete-remove-storage").toggled()
populate_storage_list(self.window.get_widget("delete-storage-list"),
populate_storage_list(self.widget("delete-storage-list"),
self.vm, self.conn)
def get_config_format(self):
format_combo = self.window.get_widget("vol-format")
format_combo = self.widget("vol-format")
model = format_combo.get_model()
if format_combo.get_active_iter() != None:
model = format_combo.get_model()
@ -114,11 +114,11 @@ class vmmDeleteDialog(vmmGObjectUI):
return None
def get_paths_to_delete(self):
del_list = self.window.get_widget("delete-storage-list")
del_list = self.widget("delete-storage-list")
model = del_list.get_model()
paths = []
if self.window.get_widget("delete-remove-storage").get_active():
if self.widget("delete-remove-storage").get_active():
for row in model:
if (not row[STORAGE_ROW_CANT_DELETE] and
row[STORAGE_ROW_CONFIRM]):

532
src/virtManager/details.py
View File

File diff suppressed because it is too large Load Diff

367
src/virtManager/host.py
View File

@ -62,9 +62,12 @@ class vmmHost(vmmGObjectUI):
self.init_conn_state()
# Set up signals
self.window.get_widget("net-list").get_selection().connect("changed", self.net_selected)
self.window.get_widget("vol-list").get_selection().connect("changed", self.vol_selected)
self.window.get_widget("interface-list").get_selection().connect("changed", self.interface_selected)
self.widget("net-list").get_selection().connect("changed",
self.net_selected)
self.widget("vol-list").get_selection().connect("changed",
self.vol_selected)
self.widget("interface-list").get_selection().connect("changed",
self.interface_selected)
self.init_net_state()
@ -126,24 +129,24 @@ class vmmHost(vmmGObjectUI):
})
# XXX: Help docs useless/out of date
self.window.get_widget("help_menuitem").hide()
self.widget("help_menuitem").hide()
finish_img = gtk.image_new_from_stock(gtk.STOCK_DELETE,
gtk.ICON_SIZE_BUTTON)
self.window.get_widget("vol-delete").set_image(finish_img)
self.widget("vol-delete").set_image(finish_img)
finish_img = gtk.image_new_from_stock(gtk.STOCK_NEW,
gtk.ICON_SIZE_BUTTON)
self.window.get_widget("vol-add").set_image(finish_img)
self.widget("vol-add").set_image(finish_img)
self.conn.connect("resources-sampled", self.refresh_resources)
self.reset_state()
def init_net_state(self):
self.window.get_widget("network-pages").set_show_tabs(False)
self.widget("network-pages").set_show_tabs(False)
# [ unique, label, icon name, icon size, is_active ]
netListModel = gtk.ListStore(str, str, str, int, bool)
self.window.get_widget("net-list").set_model(netListModel)
self.widget("net-list").set_model(netListModel)
netCol = gtk.TreeViewColumn("Networks")
netCol.set_spacing(6)
@ -155,13 +158,13 @@ class vmmHost(vmmGObjectUI):
netCol.add_attribute(net_txt, 'sensitive', 4)
netCol.add_attribute(net_img, 'icon-name', 2)
netCol.add_attribute(net_img, 'stock-size', 3)
self.window.get_widget("net-list").append_column(netCol)
self.widget("net-list").append_column(netCol)
netListModel.set_sort_column_id(1, gtk.SORT_ASCENDING)
self.populate_networks(netListModel)
def init_storage_state(self):
self.window.get_widget("storage-pages").set_show_tabs(False)
self.widget("storage-pages").set_show_tabs(False)
self.volmenu = gtk.Menu()
volCopyPath = gtk.ImageMenuItem(_("Copy Volume Path"))
@ -173,49 +176,49 @@ class vmmHost(vmmGObjectUI):
self.volmenu.add(volCopyPath)
volListModel = gtk.ListStore(str, str, str, str, str)
self.window.get_widget("vol-list").set_model(volListModel)
self.widget("vol-list").set_model(volListModel)
volCol = gtk.TreeViewColumn("Volumes")
vol_txt1 = gtk.CellRendererText()
volCol.pack_start(vol_txt1, True)
volCol.add_attribute(vol_txt1, 'text', 1)
volCol.set_sort_column_id(1)
self.window.get_widget("vol-list").append_column(volCol)
self.widget("vol-list").append_column(volCol)
volSizeCol = gtk.TreeViewColumn("Size")
vol_txt2 = gtk.CellRendererText()
volSizeCol.pack_start(vol_txt2, False)
volSizeCol.add_attribute(vol_txt2, 'text', 2)
volSizeCol.set_sort_column_id(2)
self.window.get_widget("vol-list").append_column(volSizeCol)
self.widget("vol-list").append_column(volSizeCol)
volFormatCol = gtk.TreeViewColumn("Format")
vol_txt3 = gtk.CellRendererText()
volFormatCol.pack_start(vol_txt3, False)
volFormatCol.add_attribute(vol_txt3, 'text', 3)
volFormatCol.set_sort_column_id(3)
self.window.get_widget("vol-list").append_column(volFormatCol)
self.widget("vol-list").append_column(volFormatCol)
volUseCol = gtk.TreeViewColumn("Used By")
vol_txt4 = gtk.CellRendererText()
volUseCol.pack_start(vol_txt4, False)
volUseCol.add_attribute(vol_txt4, 'text', 4)
volUseCol.set_sort_column_id(4)
self.window.get_widget("vol-list").append_column(volUseCol)
self.widget("vol-list").append_column(volUseCol)
volListModel.set_sort_column_id(1, gtk.SORT_ASCENDING)
init_pool_list(self.window.get_widget("pool-list"),
init_pool_list(self.widget("pool-list"),
self.pool_selected)
populate_storage_pools(self.window.get_widget("pool-list"),
populate_storage_pools(self.widget("pool-list"),
self.conn)
def init_interface_state(self):
self.window.get_widget("interface-pages").set_show_tabs(False)
self.widget("interface-pages").set_show_tabs(False)
# [ unique, label, icon name, icon size, is_active ]
interfaceListModel = gtk.ListStore(str, str, str, int, bool)
self.window.get_widget("interface-list").set_model(interfaceListModel)
self.widget("interface-list").set_model(interfaceListModel)
interfaceCol = gtk.TreeViewColumn("Interfaces")
interfaceCol.set_spacing(6)
@ -227,16 +230,15 @@ class vmmHost(vmmGObjectUI):
interfaceCol.add_attribute(interface_txt, 'sensitive', 4)
interfaceCol.add_attribute(interface_img, 'icon-name', 2)
interfaceCol.add_attribute(interface_img, 'stock-size', 3)
self.window.get_widget("interface-list").append_column(interfaceCol)
self.widget("interface-list").append_column(interfaceCol)
interfaceListModel.set_sort_column_id(1, gtk.SORT_ASCENDING)
# Starmode combo
uihelpers.build_startmode_combo(
self.window.get_widget("interface-startmode"))
uihelpers.build_startmode_combo(self.widget("interface-startmode"))
# [ name, type ]
childListModel = gtk.ListStore(str, str)
childList = self.window.get_widget("interface-child-list")
childList = self.widget("interface-child-list")
childList.set_model(childListModel)
childNameCol = gtk.TreeViewColumn("Name")
@ -265,22 +267,22 @@ class vmmHost(vmmGObjectUI):
arch = self.conn.host_architecture()
auto = self.conn.get_autoconnect()
self.window.get_widget("overview-uri").set_text(uri)
self.window.get_widget("overview-hostname").set_text(host)
self.window.get_widget("overview-hypervisor").set_text(drv)
self.window.get_widget("overview-memory").set_text(memory)
self.window.get_widget("overview-cpus").set_text(str(proc))
self.window.get_widget("overview-arch").set_text(arch)
self.window.get_widget("config-autoconnect").set_active(auto)
self.widget("overview-uri").set_text(uri)
self.widget("overview-hostname").set_text(host)
self.widget("overview-hypervisor").set_text(drv)
self.widget("overview-memory").set_text(memory)
self.widget("overview-cpus").set_text(str(proc))
self.widget("overview-arch").set_text(arch)
self.widget("config-autoconnect").set_active(auto)
self.cpu_usage_graph = Sparkline()
self.cpu_usage_graph.show()
self.window.get_widget("performance-table").attach(self.cpu_usage_graph, 1, 2, 0, 1)
self.widget("performance-table").attach(self.cpu_usage_graph, 1, 2, 0, 1)
self.memory_usage_graph = Sparkline()
self.memory_usage_graph.show()
self.window.get_widget("performance-table").attach(self.memory_usage_graph,
1, 2, 1, 2)
self.widget("performance-table").attach(self.memory_usage_graph,
1, 2, 1, 2)
def show(self):
@ -356,7 +358,7 @@ class vmmHost(vmmGObjectUI):
# Update autostart value
auto = self.conn.get_autoconnect()
self.window.get_widget("config-autoconnect").set_active(auto)
self.widget("config-autoconnect").set_active(auto)
def refresh_resources(self, ignore=None):
vm_memory = self.conn.pretty_stats_memory()
@ -367,9 +369,9 @@ class vmmHost(vmmGObjectUI):
cpu_vector.reverse()
memory_vector.reverse()
self.window.get_widget("performance-cpu").set_text("%d %%" %
self.widget("performance-cpu").set_text("%d %%" %
self.conn.host_cpu_time_percentage())
self.window.get_widget("performance-memory").set_text(
self.widget("performance-memory").set_text(
_("%(currentmem)s of %(maxmem)s") %
{'currentmem': vm_memory, 'maxmem': host_memory})
@ -378,9 +380,9 @@ class vmmHost(vmmGObjectUI):
def conn_state_changed(self, ignore1=None):
state = (self.conn.get_state() == vmmConnection.STATE_ACTIVE)
self.window.get_widget("menu_file_restore_saved").set_sensitive(state)
self.window.get_widget("net-add").set_sensitive(state)
self.window.get_widget("pool-add").set_sensitive(state)
self.widget("menu_file_restore_saved").set_sensitive(state)
self.widget("net-add").set_sensitive(state)
self.widget("pool-add").set_sensitive(state)
# Set error pages
if not state:
@ -458,22 +460,22 @@ class vmmHost(vmmGObjectUI):
logging.debug("Applying changes for network '%s'" % net.get_name())
try:
auto = self.window.get_widget("net-autostart").get_active()
auto = self.widget("net-autostart").get_active()
net.set_autostart(auto)
except Exception, e:
self.err.show_err(_("Error setting net autostart: %s") % str(e))
return
self.window.get_widget("net-apply").set_sensitive(False)
self.widget("net-apply").set_sensitive(False)
def net_autostart_changed(self, src_ignore):
auto = self.window.get_widget("net-autostart").get_active()
self.window.get_widget("net-autostart").set_label(auto and
_("On Boot") or
_("Never"))
self.window.get_widget("net-apply").set_sensitive(True)
auto = self.widget("net-autostart").get_active()
self.widget("net-autostart").set_label(auto and
_("On Boot") or
_("Never"))
self.widget("net-apply").set_sensitive(True)
def current_network(self):
sel = self.window.get_widget("net-list").get_selection()
sel = self.widget("net-list").get_selection()
active = sel.get_selected()
if active[1] != None:
curruuid = active[0].get_value(active[1], 0)
@ -481,7 +483,7 @@ class vmmHost(vmmGObjectUI):
return None
def refresh_network(self, src_ignore, uri_ignore, uuid):
uilist = self.window.get_widget("net-list")
uilist = self.widget("net-list")
sel = uilist.get_selection()
active = sel.get_selected()
@ -496,8 +498,8 @@ class vmmHost(vmmGObjectUI):
def set_net_error_page(self, msg):
self.reset_net_state()
self.window.get_widget("network-pages").set_current_page(1)
self.window.get_widget("network-error-label").set_text(msg)
self.widget("network-pages").set_current_page(1)
self.widget("network-error-label").set_text(msg)
def net_selected(self, src):
selected = src.get_selected()
@ -506,7 +508,7 @@ class vmmHost(vmmGObjectUI):
self.set_net_error_page(_("No virtual network selected."))
return
self.window.get_widget("network-pages").set_current_page(0)
self.widget("network-pages").set_current_page(0)
net = self.conn.get_net(selected[0].get_value(selected[1], 0))
try:
@ -515,79 +517,80 @@ class vmmHost(vmmGObjectUI):
logging.exception(e)
self.set_net_error_page(_("Error selecting network: %s") % e)
self.window.get_widget("net-apply").set_sensitive(False)
self.widget("net-apply").set_sensitive(False)
def populate_net_state(self, net):
active = net.is_active()
self.window.get_widget("net-details").set_sensitive(True)
self.window.get_widget("net-name").set_text(net.get_name())
self.widget("net-details").set_sensitive(True)
self.widget("net-name").set_text(net.get_name())
dev = active and net.get_bridge_device() or ""
state = active and _("Active") or _("Inactive")
icon = (active and self.ICON_RUNNING or
self.ICON_SHUTOFF)
self.window.get_widget("net-device").set_text(dev)
self.window.get_widget("net-device").set_sensitive(active)
self.window.get_widget("net-state").set_text(state)
self.window.get_widget("net-state-icon").set_from_icon_name(
icon, gtk.ICON_SIZE_MENU)
self.widget("net-device").set_text(dev)
self.widget("net-device").set_sensitive(active)
self.widget("net-state").set_text(state)
self.widget("net-state-icon").set_from_icon_name(icon,
gtk.ICON_SIZE_MENU)
self.window.get_widget("net-start").set_sensitive(not active)
self.window.get_widget("net-stop").set_sensitive(active)
self.window.get_widget("net-delete").set_sensitive(not active)
self.widget("net-start").set_sensitive(not active)
self.widget("net-stop").set_sensitive(active)
self.widget("net-delete").set_sensitive(not active)
autostart = net.get_autostart()
autolabel = autostart and _("On Boot") or _("Never")
self.window.get_widget("net-autostart").set_active(autostart)
self.window.get_widget("net-autostart").set_label(autolabel)
self.widget("net-autostart").set_active(autostart)
self.widget("net-autostart").set_label(autolabel)
network = net.get_ipv4_network()
self.window.get_widget("net-ip4-network").set_text(str(network))
self.widget("net-ip4-network").set_text(str(network))
dhcp = net.get_ipv4_dhcp_range()
start = dhcp and str(dhcp[0]) or _("Disabled")
end = dhcp and str(dhcp[1]) or _("Disabled")
self.window.get_widget("net-ip4-dhcp-start").set_text(start)
self.window.get_widget("net-ip4-dhcp-end").set_text(end)
self.widget("net-ip4-dhcp-start").set_text(start)
self.widget("net-ip4-dhcp-end").set_text(end)
forward, ignore = net.get_ipv4_forward()
iconsize = gtk.ICON_SIZE_MENU
icon = forward and gtk.STOCK_CONNECT or gtk.STOCK_DISCONNECT
self.window.get_widget("net-ip4-forwarding-icon").set_from_stock(
icon, iconsize)
self.widget("net-ip4-forwarding-icon").set_from_stock(icon, iconsize)
forward_str = net.pretty_forward_mode()
self.window.get_widget("net-ip4-forwarding").set_text(forward_str)
self.widget("net-ip4-forwarding").set_text(forward_str)
def reset_net_state(self):
self.window.get_widget("net-details").set_sensitive(False)
self.window.get_widget("net-name").set_text("")
self.window.get_widget("net-device").set_text("")
self.window.get_widget("net-device").set_sensitive(False)
self.window.get_widget("net-state").set_text(_("Inactive"))
self.window.get_widget("net-state-icon").set_from_icon_name(
self.ICON_SHUTOFF, gtk.ICON_SIZE_MENU)
self.window.get_widget("net-start").set_sensitive(False)
self.window.get_widget("net-stop").set_sensitive(False)
self.window.get_widget("net-delete").set_sensitive(False)
self.window.get_widget("net-autostart").set_label(_("Never"))
self.window.get_widget("net-autostart").set_active(False)
self.window.get_widget("net-ip4-network").set_text("")
self.window.get_widget("net-ip4-dhcp-start").set_text("")
self.window.get_widget("net-ip4-dhcp-end").set_text("")
self.window.get_widget("net-ip4-forwarding-icon").set_from_stock(gtk.STOCK_DISCONNECT, gtk.ICON_SIZE_MENU)
self.window.get_widget("net-ip4-forwarding").set_text(_("Isolated virtual network"))
self.window.get_widget("net-apply").set_sensitive(False)
self.widget("net-details").set_sensitive(False)
self.widget("net-name").set_text("")
self.widget("net-device").set_text("")
self.widget("net-device").set_sensitive(False)
self.widget("net-state").set_text(_("Inactive"))
self.widget("net-state-icon").set_from_icon_name(self.ICON_SHUTOFF,
gtk.ICON_SIZE_MENU)
self.widget("net-start").set_sensitive(False)
self.widget("net-stop").set_sensitive(False)
self.widget("net-delete").set_sensitive(False)
self.widget("net-autostart").set_label(_("Never"))
self.widget("net-autostart").set_active(False)
self.widget("net-ip4-network").set_text("")
self.widget("net-ip4-dhcp-start").set_text("")
self.widget("net-ip4-dhcp-end").set_text("")
self.widget("net-ip4-forwarding-icon").set_from_stock(
gtk.STOCK_DISCONNECT, gtk.ICON_SIZE_MENU)
self.widget("net-ip4-forwarding").set_text(
_("Isolated virtual network"))
self.widget("net-apply").set_sensitive(False)
def repopulate_networks(self, src_ignore, uri_ignore, uuid_ignore):
self.populate_networks(self.window.get_widget("net-list").get_model())
self.populate_networks(self.widget("net-list").get_model())
def populate_networks(self, model):
net_list = self.window.get_widget("net-list")
net_list = self.widget("net-list")
model.clear()
for uuid in self.conn.list_net_uuids():
net = self.conn.get_net(uuid)
@ -704,7 +707,7 @@ class vmmHost(vmmGObjectUI):
self.refresh_storage_pool(None, None, cp.get_uuid())
def current_pool(self):
sel = self.window.get_widget("pool-list").get_selection()
sel = self.widget("pool-list").get_selection()
active = sel.get_selected()
if active[1] != None:
curruuid = active[0].get_value(active[1], 0)
@ -715,7 +718,7 @@ class vmmHost(vmmGObjectUI):
pool = self.current_pool()
if not pool:
return None
sel = self.window.get_widget("vol-list").get_selection()
sel = self.widget("vol-list").get_selection()
active = sel.get_selected()
if active[1] != None:
curruuid = active[0].get_value(active[1], 0)
@ -729,24 +732,24 @@ class vmmHost(vmmGObjectUI):
logging.debug("Applying changes for pool '%s'" % pool.get_name())
try:
do_auto = self.window.get_widget("pool-autostart").get_active()
do_auto = self.widget("pool-autostart").get_active()
pool.set_autostart(do_auto)
except Exception, e:
self.err.show_err(_("Error setting pool autostart: %s") % str(e))
return
self.window.get_widget("pool-apply").set_sensitive(False)
self.widget("pool-apply").set_sensitive(False)
def pool_autostart_changed(self, src_ignore):
auto = self.window.get_widget("pool-autostart").get_active()
self.window.get_widget("pool-autostart").set_label(auto and
_("On Boot") or
_("Never"))
self.window.get_widget("pool-apply").set_sensitive(True)
auto = self.widget("pool-autostart").get_active()
self.widget("pool-autostart").set_label(auto and
_("On Boot") or
_("Never"))
self.widget("pool-apply").set_sensitive(True)
def set_storage_error_page(self, msg):
self.reset_pool_state()
self.window.get_widget("storage-pages").set_current_page(1)
self.window.get_widget("storage-error-label").set_text(msg)
self.widget("storage-pages").set_current_page(1)
self.widget("storage-error-label").set_text(msg)
def pool_selected(self, src):
selected = src.get_selected()
@ -755,7 +758,7 @@ class vmmHost(vmmGObjectUI):
self.set_storage_error_page(_("No storage pool selected."))
return
self.window.get_widget("storage-pages").set_current_page(0)
self.widget("storage-pages").set_current_page(0)
uuid = selected[0].get_value(selected[1], 0)
try:
@ -764,7 +767,7 @@ class vmmHost(vmmGObjectUI):
logging.exception(e)
self.set_storage_error_page(_("Error selecting pool: %s") % e)
self.window.get_widget("pool-apply").set_sensitive(False)
self.widget("pool-apply").set_sensitive(False)
def populate_pool_state(self, uuid):
pool = self.conn.get_pool(uuid)
@ -772,74 +775,73 @@ class vmmHost(vmmGObjectUI):
active = pool.is_active()
# Set pool details state
self.window.get_widget("pool-details").set_sensitive(True)
self.window.get_widget("pool-name").set_markup("<b>%s:</b>" %
pool.get_name())
self.window.get_widget("pool-sizes").set_markup(
self.widget("pool-details").set_sensitive(True)
self.widget("pool-name").set_markup("<b>%s:</b>" %
pool.get_name())
self.widget("pool-sizes").set_markup(
"""<span size="large">%s Free</span> / <i>%s In Use</i>""" %
(pool.get_pretty_available(), pool.get_pretty_allocation()))
self.window.get_widget("pool-type").set_text(
self.widget("pool-type").set_text(
Storage.StoragePool.get_pool_type_desc(pool.get_type()))
self.window.get_widget("pool-location").set_text(
self.widget("pool-location").set_text(
pool.get_target_path())
self.window.get_widget("pool-state-icon").set_from_icon_name(
self.widget("pool-state-icon").set_from_icon_name(
((active and self.ICON_RUNNING) or self.ICON_SHUTOFF),
gtk.ICON_SIZE_MENU)
self.window.get_widget("pool-state").set_text(
self.widget("pool-state").set_text(
(active and _("Active")) or _("Inactive"))
self.window.get_widget("pool-autostart").set_label(
self.widget("pool-autostart").set_label(
(auto and _("On Boot")) or _("Never"))
self.window.get_widget("pool-autostart").set_active(auto)
self.widget("pool-autostart").set_active(auto)
self.window.get_widget("vol-list").set_sensitive(active)
self.widget("vol-list").set_sensitive(active)
self.populate_storage_volumes()
self.window.get_widget("pool-delete").set_sensitive(not active)
self.window.get_widget("pool-stop").set_sensitive(active)
self.window.get_widget("pool-start").set_sensitive(not active)
self.window.get_widget("vol-add").set_sensitive(active)
self.window.get_widget("vol-delete").set_sensitive(False)
self.widget("pool-delete").set_sensitive(not active)
self.widget("pool-stop").set_sensitive(active)
self.widget("pool-start").set_sensitive(not active)
self.widget("vol-add").set_sensitive(active)
self.widget("vol-delete").set_sensitive(False)
def refresh_storage_pool(self, src_ignore, uri_ignore, uuid):
refresh_pool_in_list(self.window.get_widget("pool-list"),
self.conn, uuid)
refresh_pool_in_list(self.widget("pool-list"), self.conn, uuid)
curpool = self.current_pool()
if curpool.uuid != uuid:
return
# Currently selected pool changed state: force a 'pool_selected' to
# update vol list
self.pool_selected(self.window.get_widget("pool-list").get_selection())
self.pool_selected(self.widget("pool-list").get_selection())
def reset_pool_state(self):
self.window.get_widget("pool-details").set_sensitive(False)
self.window.get_widget("pool-name").set_text("")
self.window.get_widget("pool-sizes").set_markup("""<span size="large"> </span>""")
self.window.get_widget("pool-type").set_text("")
self.window.get_widget("pool-location").set_text("")
self.window.get_widget("pool-state-icon").set_from_icon_name(
self.ICON_SHUTOFF, gtk.ICON_SIZE_MENU)
self.window.get_widget("pool-state").set_text(_("Inactive"))
self.window.get_widget("vol-list").get_model().clear()
self.window.get_widget("pool-autostart").set_label(_("Never"))
self.window.get_widget("pool-autostart").set_active(False)
self.widget("pool-details").set_sensitive(False)
self.widget("pool-name").set_text("")
self.widget("pool-sizes").set_markup("""<span size="large"> </span>""")
self.widget("pool-type").set_text("")
self.widget("pool-location").set_text("")
self.widget("pool-state-icon").set_from_icon_name(self.ICON_SHUTOFF,
gtk.ICON_SIZE_MENU)
self.widget("pool-state").set_text(_("Inactive"))
self.widget("vol-list").get_model().clear()
self.widget("pool-autostart").set_label(_("Never"))
self.widget("pool-autostart").set_active(False)
self.window.get_widget("pool-delete").set_sensitive(False)
self.window.get_widget("pool-stop").set_sensitive(False)
self.window.get_widget("pool-start").set_sensitive(False)
self.window.get_widget("pool-apply").set_sensitive(False)
self.window.get_widget("vol-add").set_sensitive(False)
self.window.get_widget("vol-delete").set_sensitive(False)
self.window.get_widget("vol-list").set_sensitive(False)
self.widget("pool-delete").set_sensitive(False)
self.widget("pool-stop").set_sensitive(False)
self.widget("pool-start").set_sensitive(False)
self.widget("pool-apply").set_sensitive(False)
self.widget("vol-add").set_sensitive(False)
self.widget("vol-delete").set_sensitive(False)
self.widget("vol-list").set_sensitive(False)
def vol_selected(self, src):
selected = src.get_selected()
if selected[1] is None or \
selected[0].get_value(selected[1], 0) is None:
self.window.get_widget("vol-delete").set_sensitive(False)
self.widget("vol-delete").set_sensitive(False)
return
self.window.get_widget("vol-delete").set_sensitive(True)
self.widget("vol-delete").set_sensitive(True)
def popup_vol_menu(self, widget_ignore, event):
if event.button != 3:
@ -858,12 +860,12 @@ class vmmHost(vmmGObjectUI):
def repopulate_storage_pools(self, src_ignore, uri_ignore, uuid_ignore):
pool_list = self.window.get_widget("pool-list")
pool_list = self.widget("pool-list")
populate_storage_pools(pool_list, self.conn)
def populate_storage_volumes(self):
pool = self.current_pool()
model = self.window.get_widget("vol-list").get_model()
model = self.widget("vol-list").get_model()
model.clear()
vols = pool.get_volumes()
for key in vols.keys():
@ -951,7 +953,7 @@ class vmmHost(vmmGObjectUI):
self.refresh_interface(None, None, cp.get_name())
def current_interface(self):
sel = self.window.get_widget("interface-list").get_selection()
sel = self.widget("interface-list").get_selection()
active = sel.get_selected()
if active[1] != None:
currname = active[0].get_value(active[1], 0)
@ -964,7 +966,7 @@ class vmmHost(vmmGObjectUI):
if interface is None:
return
start_list = self.window.get_widget("interface-startmode")
start_list = self.widget("interface-startmode")
model = start_list.get_model()
newmode = model[start_list.get_active()][0]
@ -978,16 +980,15 @@ class vmmHost(vmmGObjectUI):
return
# XXX: This will require an interface restart
self.window.get_widget("interface-apply").set_sensitive(False)
self.widget("interface-apply").set_sensitive(False)
def interface_startmode_changed(self, src_ignore):
self.window.get_widget("interface-apply").set_sensitive(True)
self.widget("interface-apply").set_sensitive(True)
def set_interface_error_page(self, msg):
self.reset_interface_state()
self.window.get_widget("interface-pages").set_current_page(
INTERFACE_PAGE_ERROR)
self.window.get_widget("interface-error-label").set_text(msg)
self.widget("interface-pages").set_current_page(INTERFACE_PAGE_ERROR)
self.widget("interface-error-label").set_text(msg)
def interface_selected(self, src):
selected = src.get_selected()
@ -996,8 +997,7 @@ class vmmHost(vmmGObjectUI):
self.set_interface_error_page(_("No interface selected."))
return
self.window.get_widget("interface-pages").set_current_page(
INTERFACE_PAGE_INFO)
self.widget("interface-pages").set_current_page(INTERFACE_PAGE_INFO)
name = selected[0].get_value(selected[1], 0)
try:
@ -1007,7 +1007,7 @@ class vmmHost(vmmGObjectUI):
self.set_interface_error_page(_("Error selecting interface: %s") %
e)
self.window.get_widget("interface-apply").set_sensitive(False)
self.widget("interface-apply").set_sensitive(False)
def populate_interface_state(self, name):
interface = self.conn.get_interface(name)
@ -1019,22 +1019,22 @@ class vmmHost(vmmGObjectUI):
ipv4 = interface.get_ipv4()
ipv6 = interface.get_ipv6()
self.window.get_widget("interface-details").set_sensitive(True)
self.window.get_widget("interface-name").set_markup(
self.widget("interface-details").set_sensitive(True)
self.widget("interface-name").set_markup(
"<b>%s %s:</b>" % (interface.get_pretty_type(),
interface.get_name()))
self.window.get_widget("interface-mac").set_text(mac or _("Unknown"))
self.widget("interface-mac").set_text(mac or _("Unknown"))
self.window.get_widget("interface-state-icon").set_from_icon_name(
self.widget("interface-state-icon").set_from_icon_name(
((active and self.ICON_RUNNING) or self.ICON_SHUTOFF),
gtk.ICON_SIZE_MENU)
self.window.get_widget("interface-state").set_text(
self.widget("interface-state").set_text(
(active and _("Active")) or _("Inactive"))
# Set start mode
start_list = self.window.get_widget("interface-startmode")
start_list = self.widget("interface-startmode")
start_model = start_list.get_model()
start_label = self.window.get_widget("interface-startmode-label")
start_label = self.widget("interface-startmode-label")
start_list.hide()
start_label.show()
start_label.set_text(startmode)
@ -1049,19 +1049,19 @@ class vmmHost(vmmGObjectUI):
idx += 1
used_by = util.iface_in_use_by(self.conn, name)
self.window.get_widget("interface-inuseby").set_text(used_by or "-")
self.widget("interface-inuseby").set_text(used_by or "-")
# IP info
self.window.get_widget("interface-ipv4-expander").set_property(
"visible", bool(ipv4))
self.window.get_widget("interface-ipv6-expander").set_property(
"visible", bool(ipv6))
self.widget("interface-ipv4-expander").set_property("visible",
bool(ipv4))
self.widget("interface-ipv6-expander").set_property("visible",
bool(ipv6))
if ipv4:
mode = ipv4[0] and "DHCP" or "Static"
addr = ipv4[1] or "-"
self.window.get_widget("interface-ipv4-mode").set_text(mode)
self.window.get_widget("interface-ipv4-address").set_text(addr)
self.widget("interface-ipv4-mode").set_text(mode)
self.widget("interface-ipv4-address").set_text(addr)
if ipv6:
mode = ""
@ -1077,22 +1077,21 @@ class vmmHost(vmmGObjectUI):
if ipv6[2]:
addrstr = reduce(lambda x, y: x + "\n" + y, ipv6[2])
self.window.get_widget("interface-ipv6-mode").set_text(mode)
self.window.get_widget("interface-ipv6-address").set_text(addrstr)
self.widget("interface-ipv6-mode").set_text(mode)
self.widget("interface-ipv6-address").set_text(addrstr)
self.window.get_widget("interface-delete").set_sensitive(not active)
self.window.get_widget("interface-stop").set_sensitive(active)
self.window.get_widget("interface-start").set_sensitive(not active)
self.widget("interface-delete").set_sensitive(not active)
self.widget("interface-stop").set_sensitive(active)
self.widget("interface-start").set_sensitive(not active)
show_child = (children or
itype in [Interface.Interface.INTERFACE_TYPE_BRIDGE,
Interface.Interface.INTERFACE_TYPE_BOND])
self.window.get_widget("interface-child-box").set_property("visible",
show_child)
self.widget("interface-child-box").set_property("visible", show_child)
self.populate_interface_children()
def refresh_interface(self, src_ignore, uri_ignore, name):
iface_list = self.window.get_widget("interface-list")
iface_list = self.widget("interface-list")
sel = iface_list.get_selection()
active = sel.get_selected()
@ -1108,18 +1107,18 @@ class vmmHost(vmmGObjectUI):
def reset_interface_state(self):
if not self.conn.interface_capable:
self.window.get_widget("interface-add").set_sensitive(False)
self.window.get_widget("interface-delete").set_sensitive(False)
self.window.get_widget("interface-stop").set_sensitive(False)
self.window.get_widget("interface-start").set_sensitive(False)
self.window.get_widget("interface-apply").set_sensitive(False)
self.widget("interface-add").set_sensitive(False)
self.widget("interface-delete").set_sensitive(False)
self.widget("interface-stop").set_sensitive(False)
self.widget("interface-start").set_sensitive(False)
self.widget("interface-apply").set_sensitive(False)
def repopulate_interfaces(self, src_ignore, uri_ignore, name_ignore):
interface_list = self.window.get_widget("interface-list")
interface_list = self.widget("interface-list")
self.populate_interfaces(interface_list.get_model())
def populate_interfaces(self, model):
iface_list = self.window.get_widget("interface-list")
iface_list = self.widget("interface-list")
model.clear()
for name in self.conn.list_interface_names():
iface = self.conn.get_interface(name)
@ -1134,7 +1133,7 @@ class vmmHost(vmmGObjectUI):
def populate_interface_children(self):
interface = self.current_interface()
child_list = self.window.get_widget("interface-child-list")
child_list = self.widget("interface-child-list")
model = child_list.get_model()
model.clear()

94
src/virtManager/manager.py
View File

@ -137,11 +137,11 @@ class vmmManager(vmmGObjectUI):
self.init_context_menus()
# XXX: Help docs useless/out of date
self.window.get_widget("menu_help").hide()
self.widget("menu_help").hide()
self.vm_selected()
self.window.get_widget("vm-list").get_selection().connect("changed",
self.vm_selected)
self.widget("vm-list").get_selection().connect("changed",
self.vm_selected)
# Initialize stat polling columns based on global polling
# preferences (we want signal handlers for this)
@ -154,7 +154,7 @@ class vmmManager(vmmGObjectUI):
self.engine.connect("connection-removed", self._remove_connection)
# Select first list entry
vmlist = self.window.get_widget("vm-list")
vmlist = self.widget("vm-list")
if len(vmlist.get_model()) != 0:
vmlist.get_selection().select_iter(
vmlist.get_model().get_iter_first())
@ -225,8 +225,8 @@ class vmmManager(vmmGObjectUI):
return bool(self.topwin.flags() & gtk.VISIBLE)
def set_startup_error(self, msg):
self.window.get_widget("vm-notebook").set_current_page(1)
self.window.get_widget("startup-error-label").set_text(msg)
self.widget("vm-notebook").set_current_page(1)
self.widget("startup-error-label").set_text(msg)
################
# Init methods #
@ -256,26 +256,25 @@ class vmmManager(vmmGObjectUI):
COL_NETWORK))
self.window.get_widget("menu_view_stats_guest_cpu").set_active(
self.widget("menu_view_stats_guest_cpu").set_active(
self.config.is_vmlist_guest_cpu_usage_visible())
self.window.get_widget("menu_view_stats_host_cpu").set_active(
self.widget("menu_view_stats_host_cpu").set_active(
self.config.is_vmlist_host_cpu_usage_visible())
self.window.get_widget("menu_view_stats_disk").set_active(
self.widget("menu_view_stats_disk").set_active(
self.config.is_vmlist_disk_io_visible())
self.window.get_widget("menu_view_stats_network").set_active(
self.widget("menu_view_stats_network").set_active(
self.config.is_vmlist_network_traffic_visible())
def init_toolbar(self):
self.window.get_widget("vm-new").set_icon_name("vm_new")
self.window.get_widget("vm-open").set_icon_name("icon_console")
uihelpers.build_shutdown_button_menu(
self.window.get_widget("vm-shutdown"),
self.poweroff_vm,
self.reboot_vm,
self.destroy_vm,
self.save_vm)
self.widget("vm-new").set_icon_name("vm_new")
self.widget("vm-open").set_icon_name("icon_console")
uihelpers.build_shutdown_button_menu(self.widget("vm-shutdown"),
self.poweroff_vm,
self.reboot_vm,
self.destroy_vm,
self.save_vm)
tool = self.window.get_widget("vm-toolbar")
tool = self.widget("vm-toolbar")
util.safe_set_prop(tool, "icon-size", gtk.ICON_SIZE_LARGE_TOOLBAR)
for c in tool.get_children():
c.set_homogeneous(False)
@ -358,8 +357,8 @@ class vmmManager(vmmGObjectUI):
self.connmenu.show()
def init_vmlist(self):
vmlist = self.window.get_widget("vm-list")
self.window.get_widget("vm-notebook").set_show_tabs(False)
vmlist = self.widget("vm-list")
self.widget("vm-notebook").set_show_tabs(False)
# Handle, name, markup, status, status icon name, key/uuid, hint,
# is conn, is conn connected, is vm, is vm running, fg color
@ -438,7 +437,7 @@ class vmmManager(vmmGObjectUI):
##################
def current_row(self):
vmlist = self.window.get_widget("vm-list")
vmlist = self.widget("vm-list")
selection = vmlist.get_selection()
active = selection.get_selected()
@ -472,7 +471,7 @@ class vmmManager(vmmGObjectUI):
return vm.get_uuid()
def current_connection_uri(self, default_selection=False):
vmlist = self.window.get_widget("vm-list")
vmlist = self.widget("vm-list")
model = vmlist.get_model()
conn = self.current_connection()
@ -564,7 +563,7 @@ class vmmManager(vmmGObjectUI):
self.delete_dialog.show(vm, self.topwin)
def set_pause_state(self, state):
src = self.window.get_widget("vm-pause")
src = self.widget("vm-pause")
try:
self.ignore_pause = True
src.set_active(state)
@ -678,13 +677,13 @@ class vmmManager(vmmGObjectUI):
vm.connect("resources-sampled", self.vm_resources_sampled)
vm.connect("config-changed", self.vm_resources_sampled)
vmlist = self.window.get_widget("vm-list")
vmlist = self.widget("vm-list")
model = vmlist.get_model()
self._append_vm(model, vm, connection)
def vm_removed(self, connection, uri_ignore, vmuuid):
vmlist = self.window.get_widget("vm-list")
vmlist = self.widget("vm-list")
model = vmlist.get_model()
parent = self.rows[connection.get_uri()].iter
@ -758,8 +757,7 @@ class vmmManager(vmmGObjectUI):
self.rows[row_key] = model[path]
# Expand a connection when adding a vm to it
self.window.get_widget("vm-list").expand_row(model.get_path(parent),
False)
self.widget("vm-list").expand_row(model.get_path(parent), False)
def _append_connection(self, model, conn):
row = []
@ -785,7 +783,7 @@ class vmmManager(vmmGObjectUI):
def _add_connection(self, engine_ignore, conn):
# Make sure error page isn't showing
self.window.get_widget("vm-notebook").set_current_page(0)
self.widget("vm-notebook").set_current_page(0)
if conn.get_uri() in self.rows:
return
@ -797,7 +795,7 @@ class vmmManager(vmmGObjectUI):
conn.connect("connect-error", self._connect_error)
# add the connection to the treeModel
vmlist = self.window.get_widget("vm-list")
vmlist = self.widget("vm-list")
row = self._append_connection(vmlist.get_model(), conn)
vmlist.get_selection().select_iter(row)
@ -820,7 +818,7 @@ class vmmManager(vmmGObjectUI):
self.conn_refresh_resources(conn, newname)
def _remove_connection(self, engine_ignore, uri):
model = self.window.get_widget("vm-list").get_model()
model = self.widget("vm-list").get_model()
parent = self.rows[uri].iter
if parent is None:
@ -844,7 +842,7 @@ class vmmManager(vmmGObjectUI):
ignore = newstatus
ignore = oldstatus
parent = self.rows[vm.get_connection().get_uri()].iter
vmlist = self.window.get_widget("vm-list")
vmlist = self.widget("vm-list")
model = vmlist.get_model()
missing = True
@ -862,7 +860,7 @@ class vmmManager(vmmGObjectUI):
self.vm_resources_sampled(vm)
def vm_resources_sampled(self, vm):
vmlist = self.window.get_widget("vm-list")
vmlist = self.widget("vm-list")
model = vmlist.get_model()
if self.vm_row_key(vm) not in self.rows:
@ -882,7 +880,7 @@ class vmmManager(vmmGObjectUI):
self.vm_selected()
def conn_refresh_resources(self, conn, newname=None):
vmlist = self.window.get_widget("vm-list")
vmlist = self.widget("vm-list")
model = vmlist.get_model()
row = self.rows[conn.get_uri()]
@ -915,7 +913,7 @@ class vmmManager(vmmGObjectUI):
strip_text = text.replace("_", "")
self.vmmenu_items["run"].get_child().set_label(text)
self.window.get_widget("vm-run").set_label(strip_text)
self.widget("vm-run").set_label(strip_text)
def vm_selected(self, ignore=None):
conn = self.current_connection()
@ -938,21 +936,21 @@ class vmmManager(vmmGObjectUI):
if vm and vm.managedsave_supported:
self.change_run_text(vm.hasSavedImage())
self.window.get_widget("vm-open").set_sensitive(show_open)
self.window.get_widget("vm-run").set_sensitive(show_run)
self.window.get_widget("vm-shutdown").set_sensitive(show_shutdown)
self.widget("vm-open").set_sensitive(show_open)
self.widget("vm-run").set_sensitive(show_run)
self.widget("vm-shutdown").set_sensitive(show_shutdown)
self.set_pause_state(is_paused)
self.window.get_widget("vm-pause").set_sensitive(show_pause)
self.widget("vm-pause").set_sensitive(show_pause)
self.window.get_widget("menu_edit_details").set_sensitive(show_details)
self.window.get_widget("menu_host_details").set_sensitive(host_details)
self.window.get_widget("menu_edit_delete").set_sensitive(delete)
self.widget("menu_edit_details").set_sensitive(show_details)
self.widget("menu_host_details").set_sensitive(host_details)
self.widget("menu_edit_delete").set_sensitive(delete)
def popup_vm_menu_key(self, widget_ignore, event):
if gtk.gdk.keyval_name(event.keyval) != "Menu":
return False
vmlist = self.window.get_widget("vm-list")
vmlist = self.widget("vm-list")
treeselection = vmlist.get_selection()
model, _iter = treeselection.get_selected()
self.popup_vm_menu(model, _iter, event)
@ -1052,7 +1050,7 @@ class vmmManager(vmmGObjectUI):
widgn = "menu_view_stats_disk"
elif userdata == COL_NETWORK:
widgn = "menu_view_stats_network"
widget = self.window.get_widget(widgn)
widget = self.widget(widgn)
tool_text = ""
@ -1078,22 +1076,22 @@ class vmmManager(vmmGObjectUI):
def toggle_network_traffic_visible_widget(self, *ignore):
val = self.config.is_vmlist_network_traffic_visible()
self.netcol.set_visible(val)
self.window.get_widget("menu_view_stats_network").set_active(val)
self.widget("menu_view_stats_network").set_active(val)
def toggle_disk_io_visible_widget(self, *ignore):
val = self.config.is_vmlist_disk_io_visible()
self.diskcol.set_visible(val)
self.window.get_widget("menu_view_stats_disk").set_active(val)
self.widget("menu_view_stats_disk").set_active(val)
def toggle_guest_cpu_usage_visible_widget(self, *ignore):
val = self.config.is_vmlist_guest_cpu_usage_visible()
self.guestcpucol.set_visible(val)
self.window.get_widget("menu_view_stats_guest_cpu").set_active(val)
self.widget("menu_view_stats_guest_cpu").set_active(val)
def toggle_host_cpu_usage_visible_widget(self, *ignore):
val = self.config.is_vmlist_host_cpu_usage_visible()
self.hostcpucol.set_visible(val)
self.window.get_widget("menu_view_stats_host_cpu").set_active(val)
self.widget("menu_view_stats_host_cpu").set_active(val)
def toggle_stats_visible(self, src, stats_id):
visible = src.get_active()

89
src/virtManager/migrate.py
View File

@ -70,12 +70,12 @@ class vmmMigrateDialog(vmmGObjectUI):
self.bind_escape_key_close()
blue = gtk.gdk.color_parse("#0072A8")
self.window.get_widget("migrate-header").modify_bg(gtk.STATE_NORMAL,
self.widget("migrate-header").modify_bg(gtk.STATE_NORMAL,
blue)
image = gtk.image_new_from_icon_name("vm_clone_wizard",
gtk.ICON_SIZE_DIALOG)
image.show()
self.window.get_widget("migrate-vm-icon-box").pack_end(image, False)
self.widget("migrate-vm-icon-box").pack_end(image, False)
self.init_state()
@ -97,14 +97,14 @@ class vmmMigrateDialog(vmmGObjectUI):
self.destconn_rows = None
# Not sure why we need to do this manually, but it matters
self.window.get_widget("migrate-dest").get_model().clear()
self.widget("migrate-dest").get_model().clear()
vmmGObjectUI.cleanup(self)
def init_state(self):
# [hostname, conn, can_migrate, tooltip]
dest_model = gtk.ListStore(str, object, bool, str)
dest_combo = self.window.get_widget("migrate-dest")
dest_combo = self.widget("migrate-dest")
dest_combo.set_model(dest_model)
text = gtk.CellRendererText()
dest_combo.pack_start(text, True)
@ -121,31 +121,31 @@ class vmmMigrateDialog(vmmGObjectUI):
def reset_state(self):
title_str = ("<span size='large' color='white'>%s '%s'</span>" %
(_("Migrate"), self.vm.get_name()))
self.window.get_widget("migrate-main-label").set_markup(title_str)
self.widget("migrate-main-label").set_markup(title_str)
self.window.get_widget("migrate-cancel").grab_focus()
self.widget("migrate-cancel").grab_focus()
name = self.vm.get_name()
srchost = self.conn.get_hostname()
self.window.get_widget("migrate-label-name").set_text(name)
self.window.get_widget("migrate-label-src").set_text(srchost)
self.widget("migrate-label-name").set_text(name)
self.widget("migrate-label-src").set_text(srchost)
self.window.get_widget("migrate-advanced-expander").set_expanded(False)
self.window.get_widget("migrate-set-interface").set_active(False)
self.window.get_widget("migrate-set-rate").set_active(False)
self.window.get_widget("migrate-set-port").set_active(False)
self.window.get_widget("migrate-set-maxdowntime").set_active(False)
self.window.get_widget("migrate-max-downtime").set_value(30)
self.widget("migrate-advanced-expander").set_expanded(False)
self.widget("migrate-set-interface").set_active(False)
self.widget("migrate-set-rate").set_active(False)
self.widget("migrate-set-port").set_active(False)
self.widget("migrate-set-maxdowntime").set_active(False)
self.widget("migrate-max-downtime").set_value(30)
running = self.vm.is_active()
self.window.get_widget("migrate-offline").set_active(not running)
self.window.get_widget("migrate-offline").set_sensitive(running)
self.widget("migrate-offline").set_active(not running)
self.widget("migrate-offline").set_sensitive(running)
self.window.get_widget("migrate-rate").set_value(0)
self.window.get_widget("migrate-secure").set_active(False)
self.widget("migrate-rate").set_value(0)
self.widget("migrate-secure").set_active(False)
downtime_box = self.window.get_widget("migrate-maxdowntime-box")
downtime_box = self.widget("migrate-maxdowntime-box")
support_downtime = self.vm.support_downtime()
downtime_tooltip = ""
if not support_downtime:
@ -156,12 +156,12 @@ class vmmMigrateDialog(vmmGObjectUI):
if self.conn.is_xen():
# Default xen port is 8002
self.window.get_widget("migrate-port").set_value(8002)
self.widget("migrate-port").set_value(8002)
else:
# QEMU migrate port range is 49152+64
self.window.get_widget("migrate-port").set_value(49152)
self.widget("migrate-port").set_value(49152)
secure_box = self.window.get_widget("migrate-secure-box")
secure_box = self.widget("migrate-secure-box")
support_secure = hasattr(libvirt, "VIR_MIGRATE_TUNNELLED")
secure_tooltip = ""
if not support_secure:
@ -184,31 +184,30 @@ class vmmMigrateDialog(vmmGObjectUI):
if active == -1:
tooltip = _("A valid destination connection must be selected.")
self.window.get_widget("migrate-finish").set_sensitive(active != -1)
util.tooltip_wrapper(self.window.get_widget("migrate-finish"), tooltip)
self.widget("migrate-finish").set_sensitive(active != -1)
util.tooltip_wrapper(self.widget("migrate-finish"), tooltip)
def toggle_set_rate(self, src):
enable = src.get_active()
self.window.get_widget("migrate-rate").set_sensitive(enable)
self.widget("migrate-rate").set_sensitive(enable)
def toggle_set_interface(self, src):
enable = src.get_active()
port_enable = self.window.get_widget("migrate-set-port").get_active()
self.window.get_widget("migrate-interface").set_sensitive(enable)
self.window.get_widget("migrate-set-port").set_sensitive(enable)
self.window.get_widget("migrate-port").set_sensitive(enable and
port_enable)
port_enable = self.widget("migrate-set-port").get_active()
self.widget("migrate-interface").set_sensitive(enable)
self.widget("migrate-set-port").set_sensitive(enable)
self.widget("migrate-port").set_sensitive(enable and port_enable)
def toggle_set_maxdowntime(self, src):
enable = src.get_active()
self.window.get_widget("migrate-max-downtime").set_sensitive(enable)
self.widget("migrate-max-downtime").set_sensitive(enable)
def toggle_set_port(self, src):
enable = src.get_active()
self.window.get_widget("migrate-port").set_sensitive(enable)
self.widget("migrate-port").set_sensitive(enable)
def get_config_destconn(self):
combo = self.window.get_widget("migrate-dest")
combo = self.widget("migrate-dest")
model = combo.get_model()
idx = combo.get_active()
@ -222,39 +221,39 @@ class vmmMigrateDialog(vmmGObjectUI):
return row[1]
def get_config_offline(self):
return self.window.get_widget("migrate-offline").get_active()
return self.widget("migrate-offline").get_active()
def get_config_max_downtime(self):
if not self.get_config_max_downtime_enabled():
return 0
return int(self.window.get_widget("migrate-max-downtime").get_value())
return int(self.widget("migrate-max-downtime").get_value())
def get_config_secure(self):
return self.window.get_widget("migrate-secure").get_active()
return self.widget("migrate-secure").get_active()
def get_config_max_downtime_enabled(self):
return self.window.get_widget("migrate-max-downtime").get_property("sensitive")
return self.widget("migrate-max-downtime").get_property("sensitive")
def get_config_rate_enabled(self):
return self.window.get_widget("migrate-rate").get_property("sensitive")
return self.widget("migrate-rate").get_property("sensitive")
def get_config_rate(self):
if not self.get_config_rate_enabled():
return 0
return int(self.window.get_widget("migrate-rate").get_value())
return int(self.widget("migrate-rate").get_value())
def get_config_interface_enabled(self):
return self.window.get_widget("migrate-interface").get_property("sensitive")
return self.widget("migrate-interface").get_property("sensitive")
def get_config_interface(self):
if not self.get_config_interface_enabled():
return None
return self.window.get_widget("migrate-interface").get_text()
return self.widget("migrate-interface").get_text()
def get_config_port_enabled(self):
return self.window.get_widget("migrate-port").get_property("sensitive")
return self.widget("migrate-port").get_property("sensitive")
def get_config_port(self):
if not self.get_config_port_enabled():
return 0
return int(self.window.get_widget("migrate-port").get_value())
return int(self.widget("migrate-port").get_value())
def build_localhost_uri(self, destconn):
desthost = destconn.get_qualified_hostname()
@ -313,7 +312,7 @@ class vmmMigrateDialog(vmmGObjectUI):
self.populate_dest_combo()
def populate_dest_combo(self):
combo = self.window.get_widget("migrate-dest")
combo = self.widget("migrate-dest")
model = combo.get_model()
idx = combo.get_active()
idxconn = None
@ -349,7 +348,7 @@ class vmmMigrateDialog(vmmGObjectUI):
combo.set_active(idx)
def dest_add_connection(self, engine_ignore, conn):
combo = self.window.get_widget("migrate-dest")
combo = self.widget("migrate-dest")
model = combo.get_model()
newrow = self.build_dest_row(conn)

43
src/virtManager/preferences.py
View File

@ -88,7 +88,7 @@ class vmmPreferences(vmmGObjectUI):
self.bind_escape_key_close()
# XXX: Help docs useless/out of date
self.window.get_widget("prefs-help").hide()
self.widget("prefs-help").hide()
def close(self, ignore1=None, ignore2=None):
self.topwin.hide()
@ -105,39 +105,39 @@ class vmmPreferences(vmmGObjectUI):
def refresh_view_system_tray(self, ignore1=None, ignore2=None,
ignore3=None, ignore4=None):
val = self.config.get_view_system_tray()
self.window.get_widget("prefs-system-tray").set_active(bool(val))
self.widget("prefs-system-tray").set_active(bool(val))
def refresh_update_interval(self, ignore1=None, ignore2=None,
ignore3=None, ignore4=None):
self.window.get_widget("prefs-stats-update-interval").set_value(
self.widget("prefs-stats-update-interval").set_value(
self.config.get_stats_update_interval())
def refresh_history_length(self, ignore1=None, ignore2=None,
ignore3=None, ignore4=None):
self.window.get_widget("prefs-stats-history-len").set_value(
self.widget("prefs-stats-history-len").set_value(
self.config.get_stats_history_length())
def refresh_console_accels(self, ignore1=None, ignore2=None,
ignore3=None, ignore4=None):
self.window.get_widget("prefs-console-accels").set_active(
self.widget("prefs-console-accels").set_active(
self.config.get_console_accels())
def refresh_console_scaling(self, ignore1=None, ignore2=None,
ignore3=None, ignore4=None):
val = self.config.get_console_scaling()
if val == None:
val = 0
self.window.get_widget("prefs-console-scaling").set_active(val)
self.widget("prefs-console-scaling").set_active(val)
def refresh_sound_local(self, ignore1=None, ignore2=None, ignore=None,
ignore4=None):
self.window.get_widget("prefs-sound-local").set_active(
self.widget("prefs-sound-local").set_active(
self.config.get_local_sound())
def refresh_sound_remote(self, ignore1=None, ignore2=None, ignore=None,
ignore4=None):
self.window.get_widget("prefs-sound-remote").set_active(
self.widget("prefs-sound-remote").set_active(
self.config.get_remote_sound())
def refresh_graphics_type(self, ignore1=None, ignore2=None, ignore=None,
ignore4=None):
combo = self.window.get_widget("prefs-graphics-type")
combo = self.widget("prefs-graphics-type")
model = combo.get_model()
gtype = self.config.get_graphics_type()
@ -148,15 +148,15 @@ class vmmPreferences(vmmGObjectUI):
active = rowidx
break
self.window.get_widget("prefs-graphics-type").set_active(active)
self.widget("prefs-graphics-type").set_active(active)
def refresh_disk_poll(self, ignore1=None, ignore2=None, ignore3=None,
ignore4=None):
self.window.get_widget("prefs-stats-enable-disk").set_active(
self.widget("prefs-stats-enable-disk").set_active(
self.config.get_stats_enable_disk_poll())
def refresh_net_poll(self, ignore1=None, ignore2=None, ignore3=None,
ignore4=None):
self.window.get_widget("prefs-stats-enable-net").set_active(
self.widget("prefs-stats-enable-net").set_active(
self.config.get_stats_enable_net_poll())
def refresh_grabkeys_combination(self, ignore1=None, ignore2=None,
@ -165,8 +165,8 @@ class vmmPreferences(vmmGObjectUI):
if val is None:
val = "Control_L+Alt_L"
prefs_button = self.window.get_widget("prefs-keys-grab-changebtn")
self.window.get_widget("prefs-keys-grab-sequence").set_text(val)
prefs_button = self.widget("prefs-keys-grab-changebtn")
self.widget("prefs-keys-grab-sequence").set_text(val)
if not self.config.vnc_grab_keys_supported():
util.tooltip_wrapper(prefs_button,
_("Installed version of GTK-VNC doesn't "
@ -174,19 +174,24 @@ class vmmPreferences(vmmGObjectUI):
def refresh_confirm_forcepoweroff(self, ignore1=None, ignore2=None,
ignore3=None, ignore4=None):
self.window.get_widget("prefs-confirm-forcepoweroff").set_active(self.config.get_confirm_forcepoweroff())
self.widget("prefs-confirm-forcepoweroff").set_active(
self.config.get_confirm_forcepoweroff())
def refresh_confirm_poweroff(self, ignore1=None, ignore2=None,
ignore3=None, ignore4=None):
self.window.get_widget("prefs-confirm-poweroff").set_active(self.config.get_confirm_poweroff())
self.widget("prefs-confirm-poweroff").set_active(
self.config.get_confirm_poweroff())
def refresh_confirm_pause(self, ignore1=None, ignore2=None,
ignore3=None, ignore4=None):
self.window.get_widget("prefs-confirm-pause").set_active(self.config.get_confirm_pause())
self.widget("prefs-confirm-pause").set_active(
self.config.get_confirm_pause())
def refresh_confirm_removedev(self, ignore1=None, ignore2=None,
ignore3=None, ignore4=None):
self.window.get_widget("prefs-confirm-removedev").set_active(self.config.get_confirm_removedev())
self.widget("prefs-confirm-removedev").set_active(
self.config.get_confirm_removedev())
def refresh_confirm_interface(self, ignore1=None, ignore2=None,
ignore3=None, ignore4=None):
self.window.get_widget("prefs-confirm-interface").set_active(self.config.get_confirm_interface())
self.widget("prefs-confirm-interface").set_active(
self.config.get_confirm_interface())
def grabkeys_get_string(self, keysyms):
keystr = None

30
src/virtManager/storagebrowse.py
View File

@ -62,10 +62,10 @@ class vmmStorageBrowser(vmmGObjectUI):
finish_img = gtk.image_new_from_stock(gtk.STOCK_NEW,
gtk.ICON_SIZE_BUTTON)
self.window.get_widget("new-volume").set_image(finish_img)
self.widget("new-volume").set_image(finish_img)
finish_img = gtk.image_new_from_stock(gtk.STOCK_OPEN,
gtk.ICON_SIZE_BUTTON)
self.window.get_widget("choose-volume").set_image(finish_img)
self.widget("choose-volume").set_image(finish_img)
self.set_initial_state()
@ -116,11 +116,11 @@ class vmmStorageBrowser(vmmGObjectUI):
self.vm_name = name
def set_initial_state(self):
pool_list = self.window.get_widget("pool-list")
pool_list = self.widget("pool-list")
virtManager.host.init_pool_list(pool_list, self.pool_selected)
# (Key, Name, Cap, Format, Used By, sensitive)
vol_list = self.window.get_widget("vol-list")
vol_list = self.widget("vol-list")
volListModel = gtk.ListStore(str, str, str, str, str, bool)
vol_list.set_model(volListModel)
@ -164,7 +164,7 @@ class vmmStorageBrowser(vmmGObjectUI):
self.remove_conn()
self.conn = conn
pool_list = self.window.get_widget("pool-list")
pool_list = self.widget("pool-list")
virtManager.host.populate_storage_pools(pool_list, self.conn)
ids = []
@ -187,10 +187,10 @@ class vmmStorageBrowser(vmmGObjectUI):
tooltip = None
is_remote = self.conn.is_remote()
self.window.get_widget("browse-local").set_sensitive(not is_remote)
self.widget("browse-local").set_sensitive(not is_remote)
if is_remote:
tooltip = _("Cannot use local storage on remote connection.")
util.tooltip_wrapper(self.window.get_widget("browse-local"),
util.tooltip_wrapper(self.widget("browse-local"),
tooltip)
# Set data based on browse type
@ -213,7 +213,7 @@ class vmmStorageBrowser(vmmGObjectUI):
return data["enable_create"]
def current_pool(self):
row = util.get_list_selection(self.window.get_widget("pool-list"))
row = util.get_list_selection(self.widget("pool-list"))
if not row:
return
return self.conn.get_pool(row[0])
@ -221,7 +221,7 @@ class vmmStorageBrowser(vmmGObjectUI):
def current_vol_row(self):
if not self.current_pool():
return
return util.get_list_selection(self.window.get_widget("vol-list"))
return util.get_list_selection(self.widget("vol-list"))
def current_vol(self):
pool = self.current_pool()
@ -231,7 +231,7 @@ class vmmStorageBrowser(vmmGObjectUI):
return pool.get_volume(row[0])
def refresh_storage_pool(self, src_ignore, uri_ignore, uuid):
pool_list = self.window.get_widget("pool-list")
pool_list = self.widget("pool-list")
virtManager.host.refresh_pool_in_list(pool_list, self.conn, uuid)
curpool = self.current_pool()
if curpool.uuid != uuid:
@ -239,10 +239,10 @@ class vmmStorageBrowser(vmmGObjectUI):
# Currently selected pool changed state: force a 'pool_selected' to
# update vol list
self.pool_selected(self.window.get_widget("pool-list").get_selection())
self.pool_selected(self.widget("pool-list").get_selection())
def repopulate_storage_pools(self, src_ignore, uri_ignore, uuid_ignore):
pool_list = self.window.get_widget("pool-list")
pool_list = self.widget("pool-list")
virtManager.host.populate_storage_pools(pool_list, self.conn)
@ -255,14 +255,14 @@ class vmmStorageBrowser(vmmGObjectUI):
newvol = pool.is_active()
newvol = newvol and self.allow_create()
self.window.get_widget("new-volume").set_sensitive(newvol)
self.widget("new-volume").set_sensitive(newvol)
self.populate_storage_volumes()
def vol_selected(self, ignore=None):
vol = self.current_vol_row()
canchoose = bool(vol and vol[5])
self.window.get_widget("choose-volume").set_sensitive(canchoose)
self.widget("choose-volume").set_sensitive(canchoose)
def refresh_current_pool(self, ignore):
cp = self.current_pool()
@ -310,7 +310,7 @@ class vmmStorageBrowser(vmmGObjectUI):
# Do stuff!
def populate_storage_volumes(self):
model = self.window.get_widget("vol-list").get_model()
model = self.widget("vol-list").get_model()
model.clear()
dironly = self.browse_reason == self.config.CONFIG_DIR_FS