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

41
src/virtManager/choosecd.py
View File

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

41
src/virtManager/clone.py
View File

@ -169,10 +169,10 @@ class vmmCloneVM(vmmGObjectUI):
self.bind_escape_key_close() self.bind_escape_key_close()
# XXX: Help docs useless/out of date # 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, finish_img = gtk.image_new_from_stock(gtk.STOCK_NEW,
gtk.ICON_SIZE_BUTTON) 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() self.set_initial_state()
@ -226,10 +226,9 @@ class vmmCloneVM(vmmGObjectUI):
def set_initial_state(self): def set_initial_state(self):
blue = gtk.gdk.color_parse("#0072A8") blue = gtk.gdk.color_parse("#0072A8")
self.window.get_widget("clone-header").modify_bg(gtk.STATE_NORMAL, self.widget("clone-header").modify_bg(gtk.STATE_NORMAL, blue)
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", image = gtk.image_new_from_icon_name("vm_clone_wizard",
gtk.ICON_SIZE_DIALOG) gtk.ICON_SIZE_DIALOG)
image.show() image.show()
@ -237,14 +236,14 @@ class vmmCloneVM(vmmGObjectUI):
# Populate state # Populate state
def reset_state(self): def reset_state(self):
self.window.get_widget("clone-cancel").grab_focus() self.widget("clone-cancel").grab_focus()
# Populate default clone values # Populate default clone values
self.setup_clone_info() self.setup_clone_info()
cd = self.clone_design cd = self.clone_design
self.window.get_widget("clone-orig-name").set_text(cd.original_guest) self.widget("clone-orig-name").set_text(cd.original_guest)
self.window.get_widget("clone-new-name").set_text(cd.clone_name) self.widget("clone-new-name").set_text(cd.clone_name)
# We need to determine which disks fail (and why). # We need to determine which disks fail (and why).
self.storage_list, self.target_list = self.check_all_storage() self.storage_list, self.target_list = self.check_all_storage()
@ -271,7 +270,7 @@ class vmmCloneVM(vmmGObjectUI):
return cd return cd
def populate_network_list(self): 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(): for c in net_box.get_children():
net_box.remove(c) net_box.remove(c)
c.destroy() c.destroy()
@ -337,9 +336,8 @@ class vmmCloneVM(vmmGObjectUI):
build_net_row(label, mac, newmac) build_net_row(label, mac, newmac)
no_net = bool(len(self.net_list.keys()) == 0) no_net = bool(len(self.net_list.keys()) == 0)
self.window.get_widget("clone-network-box").set_property("visible", self.widget("clone-network-box").set_property("visible", not no_net)
not no_net) self.widget("clone-no-net").set_property("visible", no_net)
self.window.get_widget("clone-no-net").set_property("visible", no_net)
def check_all_storage(self): def check_all_storage(self):
""" """
@ -447,7 +445,7 @@ class vmmCloneVM(vmmGObjectUI):
def set_paths_from_clone_name(self): def set_paths_from_clone_name(self):
cd = self.clone_design 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: if not newname:
return return
@ -551,7 +549,7 @@ class vmmCloneVM(vmmGObjectUI):
disk[STORAGE_INFO_COMBO] = option_combo disk[STORAGE_INFO_COMBO] = option_combo
def populate_storage_lists(self): 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(): for c in storage_box.get_children():
storage_box.remove(c) storage_box.remove(c)
c.destroy() c.destroy()
@ -562,16 +560,15 @@ class vmmCloneVM(vmmGObjectUI):
num_c = min(len(self.target_list), 3) num_c = min(len(self.target_list), 3)
if num_c: 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) scroll.set_size_request(-1, 80 * num_c)
storage_box.show_all() storage_box.show_all()
no_storage = not bool(len(self.target_list)) no_storage = not bool(len(self.target_list))
self.window.get_widget("clone-storage-box").set_property("visible", self.widget("clone-storage-box").set_property("visible",
not no_storage) not no_storage)
self.window.get_widget("clone-no-storage-pass").set_property( self.widget("clone-no-storage-pass").set_property("visible",
"visible", no_storage)
no_storage)
skip_targets = [] skip_targets = []
new_disks = [] new_disks = []
@ -598,7 +595,7 @@ class vmmCloneVM(vmmGObjectUI):
tooltip = _("One or more disks cannot be cloned or shared.") tooltip = _("One or more disks cannot be cloned or shared.")
break break
ok_button = self.window.get_widget("clone-ok") ok_button = self.widget("clone-ok")
ok_button.set_sensitive(clone) ok_button.set_sensitive(clone)
util.tooltip_wrapper(ok_button, tooltip) util.tooltip_wrapper(ok_button, tooltip)
@ -742,7 +739,7 @@ class vmmCloneVM(vmmGObjectUI):
# Listeners # Listeners
def validate(self): def validate(self):
self.set_paths_from_clone_name() 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 # Make another clone_design
cd = self.build_new_clone_design(name) 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): def set_initial_state(self):
stock_img = gtk.image_new_from_stock(gtk.STOCK_CONNECT, stock_img = gtk.image_new_from_stock(gtk.STOCK_CONNECT,
gtk.ICON_SIZE_BUTTON) gtk.ICON_SIZE_BUTTON)
self.window.get_widget("connect").set_image(stock_img) self.widget("connect").set_image(stock_img)
self.window.get_widget("connect").grab_default() self.widget("connect").grab_default()
# Hostname combo box entry # Hostname combo box entry
hostListModel = gtk.ListStore(str, str, str) hostListModel = gtk.ListStore(str, str, str)
host = self.window.get_widget("hostname") host = self.widget("hostname")
host.set_model(hostListModel) host.set_model(hostListModel)
host.set_text_column(2) host.set_text_column(2)
hostListModel.set_sort_column_id(2, gtk.SORT_ASCENDING) hostListModel.set_sort_column_id(2, gtk.SORT_ASCENDING)
self.window.get_widget("hostname").child.connect("changed", self.widget("hostname").child.connect("changed", self.hostname_changed)
self.hostname_changed)
def reset_state(self): def reset_state(self):
self.set_default_hypervisor() self.set_default_hypervisor()
self.window.get_widget("connection").set_active(0) self.widget("connection").set_active(0)
self.window.get_widget("autoconnect").set_sensitive(True) self.widget("autoconnect").set_sensitive(True)
self.window.get_widget("autoconnect").set_active(True) self.widget("autoconnect").set_active(True)
self.window.get_widget("hostname").get_model().clear() self.widget("hostname").get_model().clear()
self.window.get_widget("hostname").child.set_text("") self.widget("hostname").child.set_text("")
self.window.get_widget("connect-remote").set_active(False) self.widget("connect-remote").set_active(False)
self.window.get_widget("username-entry").set_text("") self.widget("username-entry").set_text("")
self.stop_browse() self.stop_browse()
self.connect_remote_toggled(self.window.get_widget("connect-remote")) self.connect_remote_toggled(self.widget("connect-remote"))
self.populate_uri() self.populate_uri()
def is_remote(self): def is_remote(self):
# Whether user is requesting a remote connection # 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): def set_default_hypervisor(self):
default = virtinst.util.default_connection() default = virtinst.util.default_connection()
if default is None: if default is None:
self.window.get_widget("hypervisor").set_active(-1) self.widget("hypervisor").set_active(-1)
elif default.startswith("xen"): elif default.startswith("xen"):
self.window.get_widget("hypervisor").set_active(0) self.widget("hypervisor").set_active(0)
elif default.startswith("qemu"): 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): def add_service(self, interface, protocol, name, type, domain, flags):
ignore = flags ignore = flags
@ -171,7 +170,7 @@ class vmmConnect(vmmGObjectUI):
ignore = type ignore = type
try: try:
model = self.window.get_widget("hostname").get_model() model = self.widget("hostname").get_model()
name = str(name) name = str(name)
for row in model: for row in model:
if row[0] == name: if row[0] == name:
@ -191,7 +190,7 @@ class vmmConnect(vmmGObjectUI):
ignore = port ignore = port
try: try:
model = self.window.get_widget("hostname").get_model() model = self.widget("hostname").get_model()
for row in model: for row in model:
if row[2] == str(name): if row[2] == str(name):
# Already present in list # Already present in list
@ -246,7 +245,7 @@ class vmmConnect(vmmGObjectUI):
if not entry: if not entry:
entry = ip entry = ip
self.window.get_widget("hostname").child.set_text(entry) self.widget("hostname").child.set_text(entry)
def hostname_changed(self, src_ignore): def hostname_changed(self, src_ignore):
self.populate_uri() self.populate_uri()
@ -259,10 +258,10 @@ class vmmConnect(vmmGObjectUI):
def connect_remote_toggled(self, src_ignore): def connect_remote_toggled(self, src_ignore):
is_remote = self.is_remote() is_remote = self.is_remote()
self.window.get_widget("hostname").set_sensitive(is_remote) self.widget("hostname").set_sensitive(is_remote)
self.window.get_widget("connection").set_sensitive(is_remote) self.widget("connection").set_sensitive(is_remote)
self.window.get_widget("autoconnect").set_active(not is_remote) self.widget("autoconnect").set_active(not is_remote)
self.window.get_widget("username-entry").set_sensitive(is_remote) self.widget("username-entry").set_sensitive(is_remote)
if is_remote and self.can_browse: if is_remote and self.can_browse:
self.start_browse() self.start_browse()
else: else:
@ -277,18 +276,18 @@ class vmmConnect(vmmGObjectUI):
def populate_uri(self): def populate_uri(self):
uri = self.generate_uri() 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): 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) 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): def generate_uri(self):
hv = self.window.get_widget("hypervisor").get_active() hv = self.widget("hypervisor").get_active()
conn = self.window.get_widget("connection").get_active() conn = self.widget("connection").get_active()
host = self.window.get_widget("hostname").child.get_text() host = self.widget("hostname").child.get_text()
user = self.window.get_widget("username-entry").get_text() user = self.widget("username-entry").get_text()
is_remote = self.is_remote() is_remote = self.is_remote()
hvstr = "" hvstr = ""
@ -324,7 +323,7 @@ class vmmConnect(vmmGObjectUI):
def validate(self): def validate(self):
is_remote = self.is_remote() 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: if is_remote and not host:
return self.err.val_err(_("A hostname is required for " return self.err.val_err(_("A hostname is required for "
@ -338,8 +337,8 @@ class vmmConnect(vmmGObjectUI):
readonly = False readonly = False
auto = False auto = False
if self.window.get_widget("autoconnect").get_property("sensitive"): if self.widget("autoconnect").get_property("sensitive"):
auto = self.window.get_widget("autoconnect").get_active() auto = self.widget("autoconnect").get_active()
uri = self.generate_uri() uri = self.generate_uri()
logging.debug("Generate URI=%s, auto=%s, readonly=%s" % 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.windowname = "vmm-details"
self.window = window self.window = window
self.topwin = self.window.get_widget(self.windowname) self.topwin = self.widget(self.windowname)
self.err = vmmErrorDialog(self.topwin) self.err = vmmErrorDialog(self.topwin)
self.pointer_is_grabbed = False self.pointer_is_grabbed = False
@ -565,13 +565,12 @@ class vmmConsolePages(vmmGObjectUI):
finish_img = gtk.image_new_from_stock(gtk.STOCK_YES, finish_img = gtk.image_new_from_stock(gtk.STOCK_YES,
gtk.ICON_SIZE_BUTTON) 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 # Make viewer widget background always be black
black = gtk.gdk.Color(0, 0, 0) black = gtk.gdk.Color(0, 0, 0)
self.window.get_widget("console-vnc-viewport").modify_bg( self.widget("console-vnc-viewport").modify_bg(gtk.STATE_NORMAL,
gtk.STATE_NORMAL, black)
black)
# Signals are added by vmmDetails. Don't use signal_autoconnect here # Signals are added by vmmDetails. Don't use signal_autoconnect here
# or it changes will be overwritten # or it changes will be overwritten
@ -579,7 +578,7 @@ class vmmConsolePages(vmmGObjectUI):
self.add_gconf_handle( self.add_gconf_handle(
self.vm.on_console_scaling_changed(self.refresh_scaling)) 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) scroll.connect("size-allocate", self.scroll_size_allocate)
self.add_gconf_handle( self.add_gconf_handle(
self.config.on_console_accels_changed(self.set_enable_accel)) self.config.on_console_accels_changed(self.set_enable_accel))
@ -611,8 +610,8 @@ class vmmConsolePages(vmmGObjectUI):
########################## ##########################
def init_fs_toolbar(self): def init_fs_toolbar(self):
scroll = self.window.get_widget("console-vnc-scroll") scroll = self.widget("console-vnc-scroll")
pages = self.window.get_widget("console-pages") pages = self.widget("console-pages")
pages.remove(scroll) pages.remove(scroll)
self.fs_toolbar = gtk.Toolbar() self.fs_toolbar = gtk.Toolbar()
@ -729,11 +728,11 @@ class vmmConsolePages(vmmGObjectUI):
def refresh_scaling(self, ignore1=None, ignore2=None, ignore3=None, def refresh_scaling(self, ignore1=None, ignore2=None, ignore3=None,
ignore4=None): ignore4=None):
self.scale_type = self.vm.get_console_scaling() 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.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.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.scale_type == self.config.CONSOLE_SCALE_FULLSCREEN)
self.update_scaling() self.update_scaling()
@ -742,11 +741,11 @@ class vmmConsolePages(vmmGObjectUI):
if not src.get_active(): if not src.get_active():
return 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 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 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.scale_type = self.config.CONSOLE_SCALE_NEVER
self.vm.set_console_scaling(self.scale_type) self.vm.set_console_scaling(self.scale_type)
@ -757,8 +756,8 @@ class vmmConsolePages(vmmGObjectUI):
return return
curscale = self.viewer.get_scaling() curscale = self.viewer.get_scaling()
fs = self.window.get_widget("control-fullscreen").get_active() fs = self.widget("control-fullscreen").get_active()
vnc_scroll = self.window.get_widget("console-vnc-scroll") vnc_scroll = self.widget("console-vnc-scroll")
if (self.scale_type == self.config.CONSOLE_SCALE_NEVER if (self.scale_type == self.config.CONSOLE_SCALE_NEVER
and curscale == True): and curscale == True):
@ -785,22 +784,22 @@ class vmmConsolePages(vmmGObjectUI):
self._change_fullscreen(False) self._change_fullscreen(False)
def _change_fullscreen(self, do_fullscreen): 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: if do_fullscreen:
self.topwin.fullscreen() self.topwin.fullscreen()
self.fs_toolbar.show() self.fs_toolbar.show()
self.fs_drawer.set_active(True) self.fs_drawer.set_active(True)
self.window.get_widget("toolbar-box").hide() self.widget("toolbar-box").hide()
self.window.get_widget("details-menubar").hide() self.widget("details-menubar").hide()
else: else:
self.fs_toolbar.hide() self.fs_toolbar.hide()
self.fs_drawer.set_active(False) self.fs_drawer.set_active(False)
self.topwin.unfullscreen() self.topwin.unfullscreen()
if self.window.get_widget("details-menu-view-toolbar").get_active(): if self.widget("details-menu-view-toolbar").get_active():
self.window.get_widget("toolbar-box").show() self.widget("toolbar-box").show()
self.window.get_widget("details-menubar").show() self.widget("details-menubar").show()
self.update_scaling() self.update_scaling()
@ -836,7 +835,7 @@ class vmmConsolePages(vmmGObjectUI):
self.activate_unavailable_page(_("Guest has crashed")) self.activate_unavailable_page(_("Guest has crashed"))
def close_viewer(self): def close_viewer(self):
viewport = self.window.get_widget("console-vnc-viewport") viewport = self.widget("console-vnc-viewport")
if self.viewer is None: if self.viewer is None:
return return
@ -854,7 +853,7 @@ class vmmConsolePages(vmmGObjectUI):
def update_widget_states(self, vm, status_ignore): def update_widget_states(self, vm, status_ignore):
runable = vm.is_runable() runable = vm.is_runable()
pages = self.window.get_widget("console-pages") pages = self.widget("console-pages")
page = pages.get_current_page() page = pages.get_current_page()
if runable: if runable:
@ -884,49 +883,49 @@ class vmmConsolePages(vmmGObjectUI):
with care with care
""" """
self.close_viewer() self.close_viewer()
self.window.get_widget("console-pages").set_current_page(PAGE_UNAVAILABLE) self.widget("console-pages").set_current_page(PAGE_UNAVAILABLE)
self.window.get_widget("details-menu-vm-screenshot").set_sensitive(False) self.widget("details-menu-vm-screenshot").set_sensitive(False)
self.window.get_widget("console-unavailable").set_label("<b>" + msg + "</b>") self.widget("console-unavailable").set_label("<b>" + msg + "</b>")
def activate_auth_page(self, withPassword=True, withUsername=False): def activate_auth_page(self, withPassword=True, withUsername=False):
(pw, username) = self.config.get_console_password(self.vm) (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: if withPassword:
self.window.get_widget("console-auth-password").show() self.widget("console-auth-password").show()
self.window.get_widget("label-auth-password").show() self.widget("label-auth-password").show()
else: else:
self.window.get_widget("console-auth-password").hide() self.widget("console-auth-password").hide()
self.window.get_widget("label-auth-password").hide() self.widget("label-auth-password").hide()
if withUsername: if withUsername:
self.window.get_widget("console-auth-username").show() self.widget("console-auth-username").show()
self.window.get_widget("label-auth-username").show() self.widget("label-auth-username").show()
else: else:
self.window.get_widget("console-auth-username").hide() self.widget("console-auth-username").hide()
self.window.get_widget("label-auth-username").hide() self.widget("label-auth-username").hide()
self.window.get_widget("console-auth-username").set_text(username) self.widget("console-auth-username").set_text(username)
self.window.get_widget("console-auth-password").set_text(pw) self.widget("console-auth-password").set_text(pw)
if self.config.has_keyring(): 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 != "": if pw != "" or username != "":
self.window.get_widget("console-auth-remember").set_active(True) self.widget("console-auth-remember").set_active(True)
else: else:
self.window.get_widget("console-auth-remember").set_active(False) self.widget("console-auth-remember").set_active(False)
else: else:
self.window.get_widget("console-auth-remember").set_sensitive(False) self.widget("console-auth-remember").set_sensitive(False)
self.window.get_widget("console-pages").set_current_page(PAGE_AUTHENTICATE) self.widget("console-pages").set_current_page(PAGE_AUTHENTICATE)
if withUsername: if withUsername:
self.window.get_widget("console-auth-username").grab_focus() self.widget("console-auth-username").grab_focus()
else: else:
self.window.get_widget("console-auth-password").grab_focus() self.widget("console-auth-password").grab_focus()
def activate_viewer_page(self): def activate_viewer_page(self):
self.window.get_widget("console-pages").set_current_page(PAGE_VIEWER) self.widget("console-pages").set_current_page(PAGE_VIEWER)
self.window.get_widget("details-menu-vm-screenshot").set_sensitive(True) self.widget("details-menu-vm-screenshot").set_sensitive(True)
if self.viewer and self.viewer.get_widget(): if self.viewer and self.viewer.get_widget():
self.viewer.get_widget().grab_focus() self.viewer.get_widget().grab_focus()
@ -934,15 +933,15 @@ class vmmConsolePages(vmmGObjectUI):
self.set_allow_fullscreen() self.set_allow_fullscreen()
def set_allow_fullscreen(self): def set_allow_fullscreen(self):
cpage = self.window.get_widget("console-pages").get_current_page() cpage = self.widget("console-pages").get_current_page()
dpage = self.window.get_widget("details-pages").get_current_page() dpage = self.widget("details-pages").get_current_page()
allow_fullscreen = (dpage == 0 and allow_fullscreen = (dpage == 0 and
cpage == PAGE_VIEWER and cpage == PAGE_VIEWER and
self.viewer_connected) self.viewer_connected)
self.window.get_widget("control-fullscreen").set_sensitive(allow_fullscreen) self.widget("control-fullscreen").set_sensitive(allow_fullscreen)
self.window.get_widget("details-menu-view-fullscreen").set_sensitive(allow_fullscreen) self.widget("details-menu-view-fullscreen").set_sensitive(allow_fullscreen)
def disconnected(self): def disconnected(self):
errout = "" errout = ""
@ -1073,7 +1072,7 @@ class vmmConsolePages(vmmGObjectUI):
try: try:
if protocol == "vnc": if protocol == "vnc":
self.viewer = VNCViewer(self) self.viewer = VNCViewer(self)
self.window.get_widget("console-vnc-viewport").add( self.widget("console-vnc-viewport").add(
self.viewer.get_widget()) self.viewer.get_widget())
self.viewer.init_widget() self.viewer.init_widget()
elif protocol == "spice": elif protocol == "spice":
@ -1102,14 +1101,14 @@ class vmmConsolePages(vmmGObjectUI):
_("Error connecting to graphical console") + ":\n%s" % e) _("Error connecting to graphical console") + ":\n%s" % e)
def set_credentials(self, src_ignore=None): 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: if passwd.flags() & gtk.VISIBLE:
self.viewer.set_credential_password(passwd.get_text()) 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: if username.flags() & gtk.VISIBLE:
self.viewer.set_credential_username(username.get_text()) 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(), self.config.set_console_password(self.vm, passwd.get_text(),
username.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 isn't a hard requirment so the user can still shrink the window
again, as opposed to set_size_request again, as opposed to set_size_request
""" """
widget = self.window.get_widget("console-vnc-scroll") widget = self.widget("console-vnc-scroll")
signal_holder = [] signal_holder = []
def restore_scroll(src): def restore_scroll(src):
@ -1163,7 +1162,7 @@ class vmmConsolePages(vmmGObjectUI):
if not self.viewer or not self.viewer.get_desktop_resolution(): if not self.viewer or not self.viewer.get_desktop_resolution():
return return
scroll = self.window.get_widget("console-vnc-scroll") scroll = self.widget("console-vnc-scroll")
is_scale = self.viewer.get_scaling() is_scale = self.viewer.get_scaling()
dx = 0 dx = 0

374
src/virtManager/create.py
View File

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

98
src/virtManager/createinterface.py
View File

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

159
src/virtManager/createnet.py
View File

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

135
src/virtManager/createpool.py
View File

@ -93,10 +93,10 @@ class vmmCreatePool(vmmGObjectUI):
self.bind_escape_key_close() self.bind_escape_key_close()
# XXX: Help docs useless/out of date # 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, finish_img = gtk.image_new_from_stock(gtk.STOCK_QUIT,
gtk.ICON_SIZE_BUTTON) 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() self.set_initial_state()
@ -118,16 +118,16 @@ class vmmCreatePool(vmmGObjectUI):
vmmGObjectUI.cleanup(self) vmmGObjectUI.cleanup(self)
def set_initial_state(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_model = gtk.ListStore(str, str)
type_list.set_model(type_model) type_list.set_model(type_model)
text1 = gtk.CellRendererText() text1 = gtk.CellRendererText()
type_list.pack_start(text1, True) type_list.pack_start(text1, True)
type_list.add_attribute(text1, 'text', 1) 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_model = gtk.ListStore(str, str)
format_list.set_model(format_model) format_list.set_model(format_model)
text2 = gtk.CellRendererText() text2 = gtk.CellRendererText()
@ -135,7 +135,7 @@ class vmmCreatePool(vmmGObjectUI):
format_list.add_attribute(text2, 'text', 1) format_list.add_attribute(text2, 'text', 1)
# Target path combo box entry # 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_path, Label, pool class instance
target_model = gtk.ListStore(str, str, object) target_model = gtk.ListStore(str, str, object)
target_model.set_sort_column_id(0, gtk.SORT_ASCENDING) target_model.set_sort_column_id(0, gtk.SORT_ASCENDING)
@ -145,7 +145,7 @@ class vmmCreatePool(vmmGObjectUI):
"target_path", "pool-info2") "target_path", "pool-info2")
# Source path combo box entry # 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_path, Label, pool class instance
source_model = gtk.ListStore(str, str, object) source_model = gtk.ListStore(str, str, object)
source_model.set_sort_column_id(0, gtk.SORT_ASCENDING) source_model.set_sort_column_id(0, gtk.SORT_ASCENDING)
@ -156,24 +156,26 @@ class vmmCreatePool(vmmGObjectUI):
self.populate_pool_type() self.populate_pool_type()
self.window.get_widget("pool-info-box1").modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("grey")) self.widget("pool-info-box1").modify_bg(gtk.STATE_NORMAL,
self.window.get_widget("pool-info-box2").modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("grey")) gtk.gdk.color_parse("grey"))
self.widget("pool-info-box2").modify_bg(gtk.STATE_NORMAL,
gtk.gdk.color_parse("grey"))
def reset_state(self): def reset_state(self):
self.window.get_widget("pool-pages").set_current_page(0) self.widget("pool-pages").set_current_page(0)
self.window.get_widget("pool-forward").show() self.widget("pool-forward").show()
self.window.get_widget("pool-finish").hide() self.widget("pool-finish").hide()
self.window.get_widget("pool-back").set_sensitive(False) self.widget("pool-back").set_sensitive(False)
self.window.get_widget("pool-name").set_text("") self.widget("pool-name").set_text("")
self.window.get_widget("pool-name").grab_focus() self.widget("pool-name").grab_focus()
self.window.get_widget("pool-type").set_active(0) self.widget("pool-type").set_active(0)
self.window.get_widget("pool-target-path").child.set_text("") self.widget("pool-target-path").child.set_text("")
self.window.get_widget("pool-source-path").child.set_text("") self.widget("pool-source-path").child.set_text("")
self.window.get_widget("pool-hostname").set_text("") self.widget("pool-hostname").set_text("")
self.window.get_widget("pool-format").set_active(-1) self.widget("pool-format").set_active(-1)
self.window.get_widget("pool-build").set_sensitive(True) self.widget("pool-build").set_sensitive(True)
self.window.get_widget("pool-build").set_active(False) self.widget("pool-build").set_active(False)
def hostname_changed(self, ignore): def hostname_changed(self, ignore):
@ -181,25 +183,26 @@ class vmmCreatePool(vmmGObjectUI):
self.populate_pool_sources() self.populate_pool_sources()
def populate_pool_type(self): def populate_pool_type(self):
model = self.window.get_widget("pool-type").get_model() model = self.widget("pool-type").get_model()
model.clear() model.clear()
types = Storage.StoragePool.get_pool_types() types = Storage.StoragePool.get_pool_types()
types.sort() types.sort()
for typ in types: 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): def populate_pool_format(self, formats):
model = self.window.get_widget("pool-format").get_model() model = self.widget("pool-format").get_model()
model.clear() model.clear()
for f in formats: for f in formats:
model.append([f, f]) model.append([f, f])
def populate_pool_sources(self): 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 = source_list.get_model()
source_model.clear() 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 = target_list.get_model()
target_model.clear() target_model.clear()
@ -278,31 +281,31 @@ class vmmCreatePool(vmmGObjectUI):
Storage.StoragePool.TYPE_SCSI]: Storage.StoragePool.TYPE_SCSI]:
src_b = False src_b = False
self.window.get_widget("pool-target-button").set_sensitive(tgt_b) self.widget("pool-target-button").set_sensitive(tgt_b)
self.window.get_widget("pool-source-button").set_sensitive(src_b) self.widget("pool-source-button").set_sensitive(src_b)
self.window.get_widget("pool-source-path").set_sensitive(src) self.widget("pool-source-path").set_sensitive(src)
self.window.get_widget("pool-hostname").set_sensitive(host) self.widget("pool-hostname").set_sensitive(host)
self.window.get_widget("pool-format").set_sensitive(fmt) self.widget("pool-format").set_sensitive(fmt)
self.window.get_widget("pool-format").set_active(-1) self.widget("pool-format").set_active(-1)
if fmt: if fmt:
self.populate_pool_format(getattr(self._pool, "formats")) 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() self.populate_pool_sources()
def get_config_type(self): def get_config_type(self):
typ = self.window.get_widget("pool-type") typ = self.widget("pool-type")
if typ.get_active_iter() != None: if typ.get_active_iter() != None:
return typ.get_model().get_value(typ.get_active_iter(), 0) return typ.get_model().get_value(typ.get_active_iter(), 0)
return None return None
def get_config_name(self): 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): 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"): if not src.get_property("sensitive"):
return None return None
@ -315,7 +318,7 @@ class vmmCreatePool(vmmGObjectUI):
return src.child.get_text() return src.child.get_text()
def get_config_source_path(self): 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"): if not src.get_property("sensitive"):
return None return None
@ -328,13 +331,13 @@ class vmmCreatePool(vmmGObjectUI):
return src.child.get_text().strip() return src.child.get_text().strip()
def get_config_host(self): def get_config_host(self):
host = self.window.get_widget("pool-hostname") host = self.widget("pool-hostname")
if host.get_property("sensitive"): if host.get_property("sensitive"):
return host.get_text().strip() return host.get_text().strip()
return None return None
def get_config_format(self): def get_config_format(self):
format_combo = self.window.get_widget("pool-format") format_combo = self.widget("pool-format")
model = format_combo.get_model() model = format_combo.get_model()
if format_combo.get_active_iter() != None: if format_combo.get_active_iter() != None:
model = format_combo.get_model() model = format_combo.get_model()
@ -363,34 +366,34 @@ class vmmCreatePool(vmmGObjectUI):
source = self._browse_file(_("Choose source path"), source = self._browse_file(_("Choose source path"),
startfolder="/dev", foldermode=False) startfolder="/dev", foldermode=False)
if source: 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): def browse_target_path(self, ignore1=None):
target = self._browse_file(_("Choose target directory"), target = self._browse_file(_("Choose target directory"),
startfolder="/var/lib/libvirt", startfolder="/var/lib/libvirt",
foldermode=True) foldermode=True)
if target: 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): def forward(self, ignore=None):
notebook = self.window.get_widget("pool-pages") notebook = self.widget("pool-pages")
try: try:
if(self.validate(notebook.get_current_page()) != True): if(self.validate(notebook.get_current_page()) != True):
return return
if notebook.get_current_page() == PAGE_FORMAT: if notebook.get_current_page() == PAGE_FORMAT:
self.finish() self.finish()
else: else:
self.window.get_widget("pool-forward").grab_focus() self.widget("pool-forward").grab_focus()
notebook.next_page() notebook.next_page()
except Exception, e: except Exception, e:
self.err.show_err(_("Uncaught error validating input: %s") % str(e)) self.err.show_err(_("Uncaught error validating input: %s") % str(e))
return return
def back(self, ignore=None): def back(self, ignore=None):
self.window.get_widget("pool-finish").hide() self.widget("pool-finish").hide()
self.window.get_widget("pool-forward").show() self.widget("pool-forward").show()
self.window.get_widget("pool-pages").prev_page() self.widget("pool-pages").prev_page()
def finish(self): def finish(self):
self.topwin.set_sensitive(False) self.topwin.set_sensitive(False)
@ -422,26 +425,27 @@ class vmmCreatePool(vmmGObjectUI):
self._pool.conn = newconn self._pool.conn = newconn
logging.debug("Starting backround pool creation.") 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 = self._pool.install(create=True, meter=meter, build=build)
poolobj.setAutostart(True) poolobj.setAutostart(True)
logging.debug("Pool creation succeeded") logging.debug("Pool creation succeeded")
def page_changed(self, notebook_ignore, page_ignore, page_number): def page_changed(self, notebook_ignore, page_ignore, page_number):
if page_number == PAGE_NAME: if page_number == PAGE_NAME:
self.window.get_widget("pool-back").set_sensitive(False) self.widget("pool-back").set_sensitive(False)
self.window.get_widget("pool-finish").hide() self.widget("pool-finish").hide()
self.window.get_widget("pool-forward").show() self.widget("pool-forward").show()
self.window.get_widget("pool-forward").grab_focus() self.widget("pool-forward").grab_focus()
elif page_number == PAGE_FORMAT: elif page_number == PAGE_FORMAT:
self.window.get_widget("pool-target-path").child.set_text(self._pool.target_path) self.widget("pool-target-path").child.set_text(
self.window.get_widget("pool-back").set_sensitive(True) self._pool.target_path)
self.widget("pool-back").set_sensitive(True)
buildret = self.get_build_default() buildret = self.get_build_default()
self.window.get_widget("pool-build").set_sensitive(buildret[1]) self.widget("pool-build").set_sensitive(buildret[1])
self.window.get_widget("pool-build").set_active(buildret[0]) self.widget("pool-build").set_active(buildret[0])
self.window.get_widget("pool-finish").show() self.widget("pool-finish").show()
self.window.get_widget("pool-finish").grab_focus() self.widget("pool-finish").grab_focus()
self.window.get_widget("pool-forward").hide() self.widget("pool-forward").hide()
self.show_options_by_pool() self.show_options_by_pool()
def get_pool_to_validate(self): 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 For most pools this will be the one we built after step 1, but for
pools we find via FindPoolSources, this will be different pools we find via FindPoolSources, this will be different
""" """
source_list = self.window.get_widget("pool-source-path") source_list = self.widget("pool-source-path")
target_list = self.window.get_widget("pool-target-path") target_list = self.widget("pool-target-path")
pool = copy.copy(self._pool) pool = copy.copy(self._pool)
@ -496,9 +500,8 @@ class vmmCreatePool(vmmGObjectUI):
except ValueError, e: except ValueError, e:
return self.err.val_err(_("Pool Parameter Error"), str(e)) return self.err.val_err(_("Pool Parameter Error"), str(e))
buildval = self.window.get_widget("pool-build").get_active() buildval = self.widget("pool-build").get_active()
buildsen = self.window.get_widget("pool-build").get_property( buildsen = self.widget("pool-build").get_property("sensitive")
"sensitive")
if buildsen and buildval: if buildsen and buildval:
ret = self.err.yes_no(_("Building a pool of this type will " ret = self.err.yes_no(_("Building a pool of this type will "
"format the source device. Are you " "format the source device. Are you "
@ -511,7 +514,7 @@ class vmmCreatePool(vmmGObjectUI):
def update_doc(self, ignore1, ignore2, param, infobox): def update_doc(self, ignore1, ignore2, param, infobox):
doc = self._build_doc_str(param) 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): def update_build_doc(self, ignore1, ignore2):
doc = "" doc = ""
@ -523,7 +526,7 @@ class vmmCreatePool(vmmGObjectUI):
if docstr: if docstr:
doc = self._build_doc_str("build", 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): def update_doc_changed(self, ignore1, param, infobox):
# Wrapper for update_doc and 'changed' signal # 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() 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_model = gtk.ListStore(str, str)
format_list.set_model(format_model) format_list.set_model(format_model)
text2 = gtk.CellRendererText() text2 = gtk.CellRendererText()
format_list.pack_start(text2, False) format_list.pack_start(text2, False)
format_list.add_attribute(text2, 'text', 1) format_list.add_attribute(text2, 'text', 1)
self.window.get_widget("vol-info-view").modify_bg(gtk.STATE_NORMAL, self.widget("vol-info-view").modify_bg(gtk.STATE_NORMAL,
gtk.gdk.color_parse("grey")) gtk.gdk.color_parse("grey"))
# XXX: Help docs useless/out of date # 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, finish_img = gtk.image_new_from_stock(gtk.STOCK_QUIT,
gtk.ICON_SIZE_BUTTON) 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() self.reset_state()
@ -125,32 +125,36 @@ class vmmCreateVolume(vmmGObjectUI):
def reset_state(self): def reset_state(self):
default_name = self.default_vol_name() default_name = self.default_vol_name()
self.window.get_widget("vol-name").set_text("") self.widget("vol-name").set_text("")
self.window.get_widget("vol-create").set_sensitive(False) self.widget("vol-create").set_sensitive(False)
if default_name: 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_format()
self.populate_vol_suffix() self.populate_vol_suffix()
if len(self.vol_class.formats): if len(self.vol_class.formats):
self.window.get_widget("vol-format").set_sensitive(True) self.widget("vol-format").set_sensitive(True)
self.window.get_widget("vol-format").set_active(0) self.widget("vol-format").set_active(0)
else: 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.widget("vol-allocation").set_range(0,
self.window.get_widget("vol-allocation").set_value(DEFAULT_ALLOC) int(self.parent_pool.get_available() / 1024 / 1024))
self.window.get_widget("vol-capacity").set_range(1, int(self.parent_pool.get_available() / 1024 / 1024)) self.widget("vol-allocation").set_value(DEFAULT_ALLOC)
self.window.get_widget("vol-capacity").set_value(DEFAULT_CAP) 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.widget("vol-parent-name").set_markup(
self.window.get_widget("vol-parent-space").set_text(self.parent_pool.get_pretty_available()) "<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): def get_config_format(self):
format_combo = self.window.get_widget("vol-format") format_combo = self.widget("vol-format")
model = format_combo.get_model() model = format_combo.get_model()
if format_combo.get_active_iter() != None: if format_combo.get_active_iter() != None:
model = format_combo.get_model() model = format_combo.get_model()
@ -158,7 +162,7 @@ class vmmCreateVolume(vmmGObjectUI):
return None return None
def populate_vol_format(self): def populate_vol_format(self):
model = self.window.get_widget("vol-format").get_model() model = self.widget("vol-format").get_model()
model.clear() model.clear()
formats = self.vol_class.formats formats = self.vol_class.formats
@ -172,14 +176,14 @@ class vmmCreateVolume(vmmGObjectUI):
suffix = self.default_suffix() suffix = self.default_suffix()
if self.vol_class == Storage.FileVolume: if self.vol_class == Storage.FileVolume:
suffix = ".img" 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): def vol_name_changed(self, src):
text = src.get_text() 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): def vol_allocation_changed(self, src):
cap_widget = self.window.get_widget("vol-capacity") cap_widget = self.widget("vol-capacity")
alloc = src.get_value() alloc = src.get_value()
cap = cap_widget.get_value() cap = cap_widget.get_value()
@ -188,10 +192,10 @@ class vmmCreateVolume(vmmGObjectUI):
cap_widget.set_value(alloc) cap_widget.set_value(alloc)
def vol_capacity_changed(self, src): def vol_capacity_changed(self, src):
alloc_widget = self.window.get_widget("vol-allocation") alloc_widget = self.widget("vol-allocation")
cap = src.get_value() cap = src.get_value()
alloc = self.window.get_widget("vol-allocation").get_value() alloc = self.widget("vol-allocation").get_value()
if cap < alloc: if cap < alloc:
alloc_widget.set_value(cap) alloc_widget.set_value(cap)
@ -240,12 +244,12 @@ class vmmCreateVolume(vmmGObjectUI):
self.vol.install(meter=meter) self.vol.install(meter=meter)
def validate(self): def validate(self):
name = self.window.get_widget("vol-name").get_text() name = self.widget("vol-name").get_text()
suffix = self.window.get_widget("vol-name-suffix").get_text() suffix = self.widget("vol-name-suffix").get_text()
volname = name + suffix volname = name + suffix
fmt = self.get_config_format() fmt = self.get_config_format()
alloc = self.window.get_widget("vol-allocation").get_value() alloc = self.widget("vol-allocation").get_value()
cap = self.window.get_widget("vol-capacity").get_value() cap = self.widget("vol-capacity").get_value()
try: try:
self.vol = self.vol_class(name=volname, 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", image = gtk.image_new_from_icon_name("vm_delete_wizard",
gtk.ICON_SIZE_DIALOG) gtk.ICON_SIZE_DIALOG)
image.show() 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): def toggle_remove_storage(self, src):
dodel = src.get_active() 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): def show(self, vm, parent):
@ -94,19 +94,19 @@ class vmmDeleteDialog(vmmGObjectUI):
# Set VM name in title' # Set VM name in title'
title_str = ("<span size='x-large'>%s '%s'</span>" % title_str = ("<span size='x-large'>%s '%s'</span>" %
(_("Delete"), self.vm.get_name())) (_("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 # Disable storage removal by default
self.window.get_widget("delete-remove-storage").set_active(False) self.widget("delete-remove-storage").set_active(False)
self.window.get_widget("delete-remove-storage").toggled() 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) self.vm, self.conn)
def get_config_format(self): def get_config_format(self):
format_combo = self.window.get_widget("vol-format") format_combo = self.widget("vol-format")
model = format_combo.get_model() model = format_combo.get_model()
if format_combo.get_active_iter() != None: if format_combo.get_active_iter() != None:
model = format_combo.get_model() model = format_combo.get_model()
@ -114,11 +114,11 @@ class vmmDeleteDialog(vmmGObjectUI):
return None return None
def get_paths_to_delete(self): 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() model = del_list.get_model()
paths = [] paths = []
if self.window.get_widget("delete-remove-storage").get_active(): if self.widget("delete-remove-storage").get_active():
for row in model: for row in model:
if (not row[STORAGE_ROW_CANT_DELETE] and if (not row[STORAGE_ROW_CANT_DELETE] and
row[STORAGE_ROW_CONFIRM]): 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() self.init_conn_state()
# Set up signals # Set up signals
self.window.get_widget("net-list").get_selection().connect("changed", self.net_selected) self.widget("net-list").get_selection().connect("changed",
self.window.get_widget("vol-list").get_selection().connect("changed", self.vol_selected) self.net_selected)
self.window.get_widget("interface-list").get_selection().connect("changed", self.interface_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() self.init_net_state()
@ -126,24 +129,24 @@ class vmmHost(vmmGObjectUI):
}) })
# XXX: Help docs useless/out of date # 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, finish_img = gtk.image_new_from_stock(gtk.STOCK_DELETE,
gtk.ICON_SIZE_BUTTON) 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, finish_img = gtk.image_new_from_stock(gtk.STOCK_NEW,
gtk.ICON_SIZE_BUTTON) 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.conn.connect("resources-sampled", self.refresh_resources)
self.reset_state() self.reset_state()
def init_net_state(self): 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 ] # [ unique, label, icon name, icon size, is_active ]
netListModel = gtk.ListStore(str, str, str, int, bool) 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 = gtk.TreeViewColumn("Networks")
netCol.set_spacing(6) netCol.set_spacing(6)
@ -155,13 +158,13 @@ class vmmHost(vmmGObjectUI):
netCol.add_attribute(net_txt, 'sensitive', 4) netCol.add_attribute(net_txt, 'sensitive', 4)
netCol.add_attribute(net_img, 'icon-name', 2) netCol.add_attribute(net_img, 'icon-name', 2)
netCol.add_attribute(net_img, 'stock-size', 3) 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) netListModel.set_sort_column_id(1, gtk.SORT_ASCENDING)
self.populate_networks(netListModel) self.populate_networks(netListModel)
def init_storage_state(self): 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() self.volmenu = gtk.Menu()
volCopyPath = gtk.ImageMenuItem(_("Copy Volume Path")) volCopyPath = gtk.ImageMenuItem(_("Copy Volume Path"))
@ -173,49 +176,49 @@ class vmmHost(vmmGObjectUI):
self.volmenu.add(volCopyPath) self.volmenu.add(volCopyPath)
volListModel = gtk.ListStore(str, str, str, str, str) 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") volCol = gtk.TreeViewColumn("Volumes")
vol_txt1 = gtk.CellRendererText() vol_txt1 = gtk.CellRendererText()
volCol.pack_start(vol_txt1, True) volCol.pack_start(vol_txt1, True)
volCol.add_attribute(vol_txt1, 'text', 1) volCol.add_attribute(vol_txt1, 'text', 1)
volCol.set_sort_column_id(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") volSizeCol = gtk.TreeViewColumn("Size")
vol_txt2 = gtk.CellRendererText() vol_txt2 = gtk.CellRendererText()
volSizeCol.pack_start(vol_txt2, False) volSizeCol.pack_start(vol_txt2, False)
volSizeCol.add_attribute(vol_txt2, 'text', 2) volSizeCol.add_attribute(vol_txt2, 'text', 2)
volSizeCol.set_sort_column_id(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") volFormatCol = gtk.TreeViewColumn("Format")
vol_txt3 = gtk.CellRendererText() vol_txt3 = gtk.CellRendererText()
volFormatCol.pack_start(vol_txt3, False) volFormatCol.pack_start(vol_txt3, False)
volFormatCol.add_attribute(vol_txt3, 'text', 3) volFormatCol.add_attribute(vol_txt3, 'text', 3)
volFormatCol.set_sort_column_id(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") volUseCol = gtk.TreeViewColumn("Used By")
vol_txt4 = gtk.CellRendererText() vol_txt4 = gtk.CellRendererText()
volUseCol.pack_start(vol_txt4, False) volUseCol.pack_start(vol_txt4, False)
volUseCol.add_attribute(vol_txt4, 'text', 4) volUseCol.add_attribute(vol_txt4, 'text', 4)
volUseCol.set_sort_column_id(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) 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) self.pool_selected)
populate_storage_pools(self.window.get_widget("pool-list"), populate_storage_pools(self.widget("pool-list"),
self.conn) self.conn)
def init_interface_state(self): 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 ] # [ unique, label, icon name, icon size, is_active ]
interfaceListModel = gtk.ListStore(str, str, str, int, bool) 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 = gtk.TreeViewColumn("Interfaces")
interfaceCol.set_spacing(6) interfaceCol.set_spacing(6)
@ -227,16 +230,15 @@ class vmmHost(vmmGObjectUI):
interfaceCol.add_attribute(interface_txt, 'sensitive', 4) interfaceCol.add_attribute(interface_txt, 'sensitive', 4)
interfaceCol.add_attribute(interface_img, 'icon-name', 2) interfaceCol.add_attribute(interface_img, 'icon-name', 2)
interfaceCol.add_attribute(interface_img, 'stock-size', 3) 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) interfaceListModel.set_sort_column_id(1, gtk.SORT_ASCENDING)
# Starmode combo # Starmode combo
uihelpers.build_startmode_combo( uihelpers.build_startmode_combo(self.widget("interface-startmode"))
self.window.get_widget("interface-startmode"))
# [ name, type ] # [ name, type ]
childListModel = gtk.ListStore(str, str) childListModel = gtk.ListStore(str, str)
childList = self.window.get_widget("interface-child-list") childList = self.widget("interface-child-list")
childList.set_model(childListModel) childList.set_model(childListModel)
childNameCol = gtk.TreeViewColumn("Name") childNameCol = gtk.TreeViewColumn("Name")
@ -265,22 +267,22 @@ class vmmHost(vmmGObjectUI):
arch = self.conn.host_architecture() arch = self.conn.host_architecture()
auto = self.conn.get_autoconnect() auto = self.conn.get_autoconnect()
self.window.get_widget("overview-uri").set_text(uri) self.widget("overview-uri").set_text(uri)
self.window.get_widget("overview-hostname").set_text(host) self.widget("overview-hostname").set_text(host)
self.window.get_widget("overview-hypervisor").set_text(drv) self.widget("overview-hypervisor").set_text(drv)
self.window.get_widget("overview-memory").set_text(memory) self.widget("overview-memory").set_text(memory)
self.window.get_widget("overview-cpus").set_text(str(proc)) self.widget("overview-cpus").set_text(str(proc))
self.window.get_widget("overview-arch").set_text(arch) self.widget("overview-arch").set_text(arch)
self.window.get_widget("config-autoconnect").set_active(auto) self.widget("config-autoconnect").set_active(auto)
self.cpu_usage_graph = Sparkline() self.cpu_usage_graph = Sparkline()
self.cpu_usage_graph.show() 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 = Sparkline()
self.memory_usage_graph.show() self.memory_usage_graph.show()
self.window.get_widget("performance-table").attach(self.memory_usage_graph, self.widget("performance-table").attach(self.memory_usage_graph,
1, 2, 1, 2) 1, 2, 1, 2)
def show(self): def show(self):
@ -356,7 +358,7 @@ class vmmHost(vmmGObjectUI):
# Update autostart value # Update autostart value
auto = self.conn.get_autoconnect() 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): def refresh_resources(self, ignore=None):
vm_memory = self.conn.pretty_stats_memory() vm_memory = self.conn.pretty_stats_memory()
@ -367,9 +369,9 @@ class vmmHost(vmmGObjectUI):
cpu_vector.reverse() cpu_vector.reverse()
memory_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.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)s of %(maxmem)s") %
{'currentmem': vm_memory, 'maxmem': host_memory}) {'currentmem': vm_memory, 'maxmem': host_memory})
@ -378,9 +380,9 @@ class vmmHost(vmmGObjectUI):
def conn_state_changed(self, ignore1=None): def conn_state_changed(self, ignore1=None):
state = (self.conn.get_state() == vmmConnection.STATE_ACTIVE) state = (self.conn.get_state() == vmmConnection.STATE_ACTIVE)
self.window.get_widget("menu_file_restore_saved").set_sensitive(state) self.widget("menu_file_restore_saved").set_sensitive(state)
self.window.get_widget("net-add").set_sensitive(state) self.widget("net-add").set_sensitive(state)
self.window.get_widget("pool-add").set_sensitive(state) self.widget("pool-add").set_sensitive(state)
# Set error pages # Set error pages
if not state: if not state:
@ -458,22 +460,22 @@ class vmmHost(vmmGObjectUI):
logging.debug("Applying changes for network '%s'" % net.get_name()) logging.debug("Applying changes for network '%s'" % net.get_name())
try: try:
auto = self.window.get_widget("net-autostart").get_active() auto = self.widget("net-autostart").get_active()
net.set_autostart(auto) net.set_autostart(auto)
except Exception, e: except Exception, e:
self.err.show_err(_("Error setting net autostart: %s") % str(e)) self.err.show_err(_("Error setting net autostart: %s") % str(e))
return return
self.window.get_widget("net-apply").set_sensitive(False) self.widget("net-apply").set_sensitive(False)
def net_autostart_changed(self, src_ignore): def net_autostart_changed(self, src_ignore):
auto = self.window.get_widget("net-autostart").get_active() auto = self.widget("net-autostart").get_active()
self.window.get_widget("net-autostart").set_label(auto and self.widget("net-autostart").set_label(auto and
_("On Boot") or _("On Boot") or
_("Never")) _("Never"))
self.window.get_widget("net-apply").set_sensitive(True) self.widget("net-apply").set_sensitive(True)
def current_network(self): def current_network(self):
sel = self.window.get_widget("net-list").get_selection() sel = self.widget("net-list").get_selection()
active = sel.get_selected() active = sel.get_selected()
if active[1] != None: if active[1] != None:
curruuid = active[0].get_value(active[1], 0) curruuid = active[0].get_value(active[1], 0)
@ -481,7 +483,7 @@ class vmmHost(vmmGObjectUI):
return None return None
def refresh_network(self, src_ignore, uri_ignore, uuid): 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() sel = uilist.get_selection()
active = sel.get_selected() active = sel.get_selected()
@ -496,8 +498,8 @@ class vmmHost(vmmGObjectUI):
def set_net_error_page(self, msg): def set_net_error_page(self, msg):
self.reset_net_state() self.reset_net_state()
self.window.get_widget("network-pages").set_current_page(1) self.widget("network-pages").set_current_page(1)
self.window.get_widget("network-error-label").set_text(msg) self.widget("network-error-label").set_text(msg)
def net_selected(self, src): def net_selected(self, src):
selected = src.get_selected() selected = src.get_selected()
@ -506,7 +508,7 @@ class vmmHost(vmmGObjectUI):
self.set_net_error_page(_("No virtual network selected.")) self.set_net_error_page(_("No virtual network selected."))
return 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)) net = self.conn.get_net(selected[0].get_value(selected[1], 0))
try: try:
@ -515,79 +517,80 @@ class vmmHost(vmmGObjectUI):
logging.exception(e) logging.exception(e)
self.set_net_error_page(_("Error selecting network: %s") % 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): def populate_net_state(self, net):
active = net.is_active() active = net.is_active()
self.window.get_widget("net-details").set_sensitive(True) self.widget("net-details").set_sensitive(True)
self.window.get_widget("net-name").set_text(net.get_name()) self.widget("net-name").set_text(net.get_name())
dev = active and net.get_bridge_device() or "" dev = active and net.get_bridge_device() or ""
state = active and _("Active") or _("Inactive") state = active and _("Active") or _("Inactive")
icon = (active and self.ICON_RUNNING or icon = (active and self.ICON_RUNNING or
self.ICON_SHUTOFF) self.ICON_SHUTOFF)
self.window.get_widget("net-device").set_text(dev) self.widget("net-device").set_text(dev)
self.window.get_widget("net-device").set_sensitive(active) self.widget("net-device").set_sensitive(active)
self.window.get_widget("net-state").set_text(state) self.widget("net-state").set_text(state)
self.window.get_widget("net-state-icon").set_from_icon_name( self.widget("net-state-icon").set_from_icon_name(icon,
icon, gtk.ICON_SIZE_MENU) gtk.ICON_SIZE_MENU)
self.window.get_widget("net-start").set_sensitive(not active) self.widget("net-start").set_sensitive(not active)
self.window.get_widget("net-stop").set_sensitive(active) self.widget("net-stop").set_sensitive(active)
self.window.get_widget("net-delete").set_sensitive(not active) self.widget("net-delete").set_sensitive(not active)
autostart = net.get_autostart() autostart = net.get_autostart()
autolabel = autostart and _("On Boot") or _("Never") autolabel = autostart and _("On Boot") or _("Never")
self.window.get_widget("net-autostart").set_active(autostart) self.widget("net-autostart").set_active(autostart)
self.window.get_widget("net-autostart").set_label(autolabel) self.widget("net-autostart").set_label(autolabel)
network = net.get_ipv4_network() 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() dhcp = net.get_ipv4_dhcp_range()
start = dhcp and str(dhcp[0]) or _("Disabled") start = dhcp and str(dhcp[0]) or _("Disabled")
end = dhcp and str(dhcp[1]) or _("Disabled") end = dhcp and str(dhcp[1]) or _("Disabled")
self.window.get_widget("net-ip4-dhcp-start").set_text(start) self.widget("net-ip4-dhcp-start").set_text(start)
self.window.get_widget("net-ip4-dhcp-end").set_text(end) self.widget("net-ip4-dhcp-end").set_text(end)
forward, ignore = net.get_ipv4_forward() forward, ignore = net.get_ipv4_forward()
iconsize = gtk.ICON_SIZE_MENU iconsize = gtk.ICON_SIZE_MENU
icon = forward and gtk.STOCK_CONNECT or gtk.STOCK_DISCONNECT icon = forward and gtk.STOCK_CONNECT or gtk.STOCK_DISCONNECT
self.window.get_widget("net-ip4-forwarding-icon").set_from_stock( self.widget("net-ip4-forwarding-icon").set_from_stock(icon, iconsize)
icon, iconsize)
forward_str = net.pretty_forward_mode() 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): def reset_net_state(self):
self.window.get_widget("net-details").set_sensitive(False) self.widget("net-details").set_sensitive(False)
self.window.get_widget("net-name").set_text("") self.widget("net-name").set_text("")
self.window.get_widget("net-device").set_text("") self.widget("net-device").set_text("")
self.window.get_widget("net-device").set_sensitive(False) self.widget("net-device").set_sensitive(False)
self.window.get_widget("net-state").set_text(_("Inactive")) self.widget("net-state").set_text(_("Inactive"))
self.window.get_widget("net-state-icon").set_from_icon_name( self.widget("net-state-icon").set_from_icon_name(self.ICON_SHUTOFF,
self.ICON_SHUTOFF, gtk.ICON_SIZE_MENU) gtk.ICON_SIZE_MENU)
self.window.get_widget("net-start").set_sensitive(False) self.widget("net-start").set_sensitive(False)
self.window.get_widget("net-stop").set_sensitive(False) self.widget("net-stop").set_sensitive(False)
self.window.get_widget("net-delete").set_sensitive(False) self.widget("net-delete").set_sensitive(False)
self.window.get_widget("net-autostart").set_label(_("Never")) self.widget("net-autostart").set_label(_("Never"))
self.window.get_widget("net-autostart").set_active(False) self.widget("net-autostart").set_active(False)
self.window.get_widget("net-ip4-network").set_text("") self.widget("net-ip4-network").set_text("")
self.window.get_widget("net-ip4-dhcp-start").set_text("") self.widget("net-ip4-dhcp-start").set_text("")
self.window.get_widget("net-ip4-dhcp-end").set_text("") self.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.widget("net-ip4-forwarding-icon").set_from_stock(
self.window.get_widget("net-ip4-forwarding").set_text(_("Isolated virtual network")) gtk.STOCK_DISCONNECT, gtk.ICON_SIZE_MENU)
self.window.get_widget("net-apply").set_sensitive(False) 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): 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): def populate_networks(self, model):
net_list = self.window.get_widget("net-list") net_list = self.widget("net-list")
model.clear() model.clear()
for uuid in self.conn.list_net_uuids(): for uuid in self.conn.list_net_uuids():
net = self.conn.get_net(uuid) net = self.conn.get_net(uuid)
@ -704,7 +707,7 @@ class vmmHost(vmmGObjectUI):
self.refresh_storage_pool(None, None, cp.get_uuid()) self.refresh_storage_pool(None, None, cp.get_uuid())
def current_pool(self): def current_pool(self):
sel = self.window.get_widget("pool-list").get_selection() sel = self.widget("pool-list").get_selection()
active = sel.get_selected() active = sel.get_selected()
if active[1] != None: if active[1] != None:
curruuid = active[0].get_value(active[1], 0) curruuid = active[0].get_value(active[1], 0)
@ -715,7 +718,7 @@ class vmmHost(vmmGObjectUI):
pool = self.current_pool() pool = self.current_pool()
if not pool: if not pool:
return None return None
sel = self.window.get_widget("vol-list").get_selection() sel = self.widget("vol-list").get_selection()
active = sel.get_selected() active = sel.get_selected()
if active[1] != None: if active[1] != None:
curruuid = active[0].get_value(active[1], 0) 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()) logging.debug("Applying changes for pool '%s'" % pool.get_name())
try: try:
do_auto = self.window.get_widget("pool-autostart").get_active() do_auto = self.widget("pool-autostart").get_active()
pool.set_autostart(do_auto) pool.set_autostart(do_auto)
except Exception, e: except Exception, e:
self.err.show_err(_("Error setting pool autostart: %s") % str(e)) self.err.show_err(_("Error setting pool autostart: %s") % str(e))
return return
self.window.get_widget("pool-apply").set_sensitive(False) self.widget("pool-apply").set_sensitive(False)
def pool_autostart_changed(self, src_ignore): def pool_autostart_changed(self, src_ignore):
auto = self.window.get_widget("pool-autostart").get_active() auto = self.widget("pool-autostart").get_active()
self.window.get_widget("pool-autostart").set_label(auto and self.widget("pool-autostart").set_label(auto and
_("On Boot") or _("On Boot") or
_("Never")) _("Never"))
self.window.get_widget("pool-apply").set_sensitive(True) self.widget("pool-apply").set_sensitive(True)
def set_storage_error_page(self, msg): def set_storage_error_page(self, msg):
self.reset_pool_state() self.reset_pool_state()
self.window.get_widget("storage-pages").set_current_page(1) self.widget("storage-pages").set_current_page(1)
self.window.get_widget("storage-error-label").set_text(msg) self.widget("storage-error-label").set_text(msg)
def pool_selected(self, src): def pool_selected(self, src):
selected = src.get_selected() selected = src.get_selected()
@ -755,7 +758,7 @@ class vmmHost(vmmGObjectUI):
self.set_storage_error_page(_("No storage pool selected.")) self.set_storage_error_page(_("No storage pool selected."))
return 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) uuid = selected[0].get_value(selected[1], 0)
try: try:
@ -764,7 +767,7 @@ class vmmHost(vmmGObjectUI):
logging.exception(e) logging.exception(e)
self.set_storage_error_page(_("Error selecting pool: %s") % 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): def populate_pool_state(self, uuid):
pool = self.conn.get_pool(uuid) pool = self.conn.get_pool(uuid)
@ -772,74 +775,73 @@ class vmmHost(vmmGObjectUI):
active = pool.is_active() active = pool.is_active()
# Set pool details state # Set pool details state
self.window.get_widget("pool-details").set_sensitive(True) self.widget("pool-details").set_sensitive(True)
self.window.get_widget("pool-name").set_markup("<b>%s:</b>" % self.widget("pool-name").set_markup("<b>%s:</b>" %
pool.get_name()) pool.get_name())
self.window.get_widget("pool-sizes").set_markup( self.widget("pool-sizes").set_markup(
"""<span size="large">%s Free</span> / <i>%s In Use</i>""" % """<span size="large">%s Free</span> / <i>%s In Use</i>""" %
(pool.get_pretty_available(), pool.get_pretty_allocation())) (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())) 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()) 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), ((active and self.ICON_RUNNING) or self.ICON_SHUTOFF),
gtk.ICON_SIZE_MENU) gtk.ICON_SIZE_MENU)
self.window.get_widget("pool-state").set_text( self.widget("pool-state").set_text(
(active and _("Active")) or _("Inactive")) (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")) (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.populate_storage_volumes()
self.window.get_widget("pool-delete").set_sensitive(not active) self.widget("pool-delete").set_sensitive(not active)
self.window.get_widget("pool-stop").set_sensitive(active) self.widget("pool-stop").set_sensitive(active)
self.window.get_widget("pool-start").set_sensitive(not active) self.widget("pool-start").set_sensitive(not active)
self.window.get_widget("vol-add").set_sensitive(active) self.widget("vol-add").set_sensitive(active)
self.window.get_widget("vol-delete").set_sensitive(False) self.widget("vol-delete").set_sensitive(False)
def refresh_storage_pool(self, src_ignore, uri_ignore, uuid): def refresh_storage_pool(self, src_ignore, uri_ignore, uuid):
refresh_pool_in_list(self.window.get_widget("pool-list"), refresh_pool_in_list(self.widget("pool-list"), self.conn, uuid)
self.conn, uuid)
curpool = self.current_pool() curpool = self.current_pool()
if curpool.uuid != uuid: if curpool.uuid != uuid:
return return
# Currently selected pool changed state: force a 'pool_selected' to # Currently selected pool changed state: force a 'pool_selected' to
# update vol list # 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): def reset_pool_state(self):
self.window.get_widget("pool-details").set_sensitive(False) self.widget("pool-details").set_sensitive(False)
self.window.get_widget("pool-name").set_text("") self.widget("pool-name").set_text("")
self.window.get_widget("pool-sizes").set_markup("""<span size="large"> </span>""") self.widget("pool-sizes").set_markup("""<span size="large"> </span>""")
self.window.get_widget("pool-type").set_text("") self.widget("pool-type").set_text("")
self.window.get_widget("pool-location").set_text("") self.widget("pool-location").set_text("")
self.window.get_widget("pool-state-icon").set_from_icon_name( self.widget("pool-state-icon").set_from_icon_name(self.ICON_SHUTOFF,
self.ICON_SHUTOFF, gtk.ICON_SIZE_MENU) gtk.ICON_SIZE_MENU)
self.window.get_widget("pool-state").set_text(_("Inactive")) self.widget("pool-state").set_text(_("Inactive"))
self.window.get_widget("vol-list").get_model().clear() self.widget("vol-list").get_model().clear()
self.window.get_widget("pool-autostart").set_label(_("Never")) self.widget("pool-autostart").set_label(_("Never"))
self.window.get_widget("pool-autostart").set_active(False) self.widget("pool-autostart").set_active(False)
self.window.get_widget("pool-delete").set_sensitive(False) self.widget("pool-delete").set_sensitive(False)
self.window.get_widget("pool-stop").set_sensitive(False) self.widget("pool-stop").set_sensitive(False)
self.window.get_widget("pool-start").set_sensitive(False) self.widget("pool-start").set_sensitive(False)
self.window.get_widget("pool-apply").set_sensitive(False) self.widget("pool-apply").set_sensitive(False)
self.window.get_widget("vol-add").set_sensitive(False) self.widget("vol-add").set_sensitive(False)
self.window.get_widget("vol-delete").set_sensitive(False) self.widget("vol-delete").set_sensitive(False)
self.window.get_widget("vol-list").set_sensitive(False) self.widget("vol-list").set_sensitive(False)
def vol_selected(self, src): def vol_selected(self, src):
selected = src.get_selected() selected = src.get_selected()
if selected[1] is None or \ if selected[1] is None or \
selected[0].get_value(selected[1], 0) is None: 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 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): def popup_vol_menu(self, widget_ignore, event):
if event.button != 3: if event.button != 3:
@ -858,12 +860,12 @@ class vmmHost(vmmGObjectUI):
def repopulate_storage_pools(self, src_ignore, uri_ignore, uuid_ignore): 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) populate_storage_pools(pool_list, self.conn)
def populate_storage_volumes(self): def populate_storage_volumes(self):
pool = self.current_pool() pool = self.current_pool()
model = self.window.get_widget("vol-list").get_model() model = self.widget("vol-list").get_model()
model.clear() model.clear()
vols = pool.get_volumes() vols = pool.get_volumes()
for key in vols.keys(): for key in vols.keys():
@ -951,7 +953,7 @@ class vmmHost(vmmGObjectUI):
self.refresh_interface(None, None, cp.get_name()) self.refresh_interface(None, None, cp.get_name())
def current_interface(self): def current_interface(self):
sel = self.window.get_widget("interface-list").get_selection() sel = self.widget("interface-list").get_selection()
active = sel.get_selected() active = sel.get_selected()
if active[1] != None: if active[1] != None:
currname = active[0].get_value(active[1], 0) currname = active[0].get_value(active[1], 0)
@ -964,7 +966,7 @@ class vmmHost(vmmGObjectUI):
if interface is None: if interface is None:
return return
start_list = self.window.get_widget("interface-startmode") start_list = self.widget("interface-startmode")
model = start_list.get_model() model = start_list.get_model()
newmode = model[start_list.get_active()][0] newmode = model[start_list.get_active()][0]
@ -978,16 +980,15 @@ class vmmHost(vmmGObjectUI):
return return
# XXX: This will require an interface restart # 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): 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): def set_interface_error_page(self, msg):
self.reset_interface_state() self.reset_interface_state()
self.window.get_widget("interface-pages").set_current_page( self.widget("interface-pages").set_current_page(INTERFACE_PAGE_ERROR)
INTERFACE_PAGE_ERROR) self.widget("interface-error-label").set_text(msg)
self.window.get_widget("interface-error-label").set_text(msg)
def interface_selected(self, src): def interface_selected(self, src):
selected = src.get_selected() selected = src.get_selected()
@ -996,8 +997,7 @@ class vmmHost(vmmGObjectUI):
self.set_interface_error_page(_("No interface selected.")) self.set_interface_error_page(_("No interface selected."))
return return
self.window.get_widget("interface-pages").set_current_page( self.widget("interface-pages").set_current_page(INTERFACE_PAGE_INFO)
INTERFACE_PAGE_INFO)
name = selected[0].get_value(selected[1], 0) name = selected[0].get_value(selected[1], 0)
try: try:
@ -1007,7 +1007,7 @@ class vmmHost(vmmGObjectUI):
self.set_interface_error_page(_("Error selecting interface: %s") % self.set_interface_error_page(_("Error selecting interface: %s") %
e) e)
self.window.get_widget("interface-apply").set_sensitive(False) self.widget("interface-apply").set_sensitive(False)
def populate_interface_state(self, name): def populate_interface_state(self, name):
interface = self.conn.get_interface(name) interface = self.conn.get_interface(name)
@ -1019,22 +1019,22 @@ class vmmHost(vmmGObjectUI):
ipv4 = interface.get_ipv4() ipv4 = interface.get_ipv4()
ipv6 = interface.get_ipv6() ipv6 = interface.get_ipv6()
self.window.get_widget("interface-details").set_sensitive(True) self.widget("interface-details").set_sensitive(True)
self.window.get_widget("interface-name").set_markup( self.widget("interface-name").set_markup(
"<b>%s %s:</b>" % (interface.get_pretty_type(), "<b>%s %s:</b>" % (interface.get_pretty_type(),
interface.get_name())) 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), ((active and self.ICON_RUNNING) or self.ICON_SHUTOFF),
gtk.ICON_SIZE_MENU) gtk.ICON_SIZE_MENU)
self.window.get_widget("interface-state").set_text( self.widget("interface-state").set_text(
(active and _("Active")) or _("Inactive")) (active and _("Active")) or _("Inactive"))
# Set start mode # Set start mode
start_list = self.window.get_widget("interface-startmode") start_list = self.widget("interface-startmode")
start_model = start_list.get_model() 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_list.hide()
start_label.show() start_label.show()
start_label.set_text(startmode) start_label.set_text(startmode)
@ -1049,19 +1049,19 @@ class vmmHost(vmmGObjectUI):
idx += 1 idx += 1
used_by = util.iface_in_use_by(self.conn, name) 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 # IP info
self.window.get_widget("interface-ipv4-expander").set_property( self.widget("interface-ipv4-expander").set_property("visible",
"visible", bool(ipv4)) bool(ipv4))
self.window.get_widget("interface-ipv6-expander").set_property( self.widget("interface-ipv6-expander").set_property("visible",
"visible", bool(ipv6)) bool(ipv6))
if ipv4: if ipv4:
mode = ipv4[0] and "DHCP" or "Static" mode = ipv4[0] and "DHCP" or "Static"
addr = ipv4[1] or "-" addr = ipv4[1] or "-"
self.window.get_widget("interface-ipv4-mode").set_text(mode) self.widget("interface-ipv4-mode").set_text(mode)
self.window.get_widget("interface-ipv4-address").set_text(addr) self.widget("interface-ipv4-address").set_text(addr)
if ipv6: if ipv6:
mode = "" mode = ""
@ -1077,22 +1077,21 @@ class vmmHost(vmmGObjectUI):
if ipv6[2]: if ipv6[2]:
addrstr = reduce(lambda x, y: x + "\n" + y, ipv6[2]) addrstr = reduce(lambda x, y: x + "\n" + y, ipv6[2])
self.window.get_widget("interface-ipv6-mode").set_text(mode) self.widget("interface-ipv6-mode").set_text(mode)
self.window.get_widget("interface-ipv6-address").set_text(addrstr) self.widget("interface-ipv6-address").set_text(addrstr)
self.window.get_widget("interface-delete").set_sensitive(not active) self.widget("interface-delete").set_sensitive(not active)
self.window.get_widget("interface-stop").set_sensitive(active) self.widget("interface-stop").set_sensitive(active)
self.window.get_widget("interface-start").set_sensitive(not active) self.widget("interface-start").set_sensitive(not active)
show_child = (children or show_child = (children or
itype in [Interface.Interface.INTERFACE_TYPE_BRIDGE, itype in [Interface.Interface.INTERFACE_TYPE_BRIDGE,
Interface.Interface.INTERFACE_TYPE_BOND]) Interface.Interface.INTERFACE_TYPE_BOND])
self.window.get_widget("interface-child-box").set_property("visible", self.widget("interface-child-box").set_property("visible", show_child)
show_child)
self.populate_interface_children() self.populate_interface_children()
def refresh_interface(self, src_ignore, uri_ignore, name): 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() sel = iface_list.get_selection()
active = sel.get_selected() active = sel.get_selected()
@ -1108,18 +1107,18 @@ class vmmHost(vmmGObjectUI):
def reset_interface_state(self): def reset_interface_state(self):
if not self.conn.interface_capable: if not self.conn.interface_capable:
self.window.get_widget("interface-add").set_sensitive(False) self.widget("interface-add").set_sensitive(False)
self.window.get_widget("interface-delete").set_sensitive(False) self.widget("interface-delete").set_sensitive(False)
self.window.get_widget("interface-stop").set_sensitive(False) self.widget("interface-stop").set_sensitive(False)
self.window.get_widget("interface-start").set_sensitive(False) self.widget("interface-start").set_sensitive(False)
self.window.get_widget("interface-apply").set_sensitive(False) self.widget("interface-apply").set_sensitive(False)
def repopulate_interfaces(self, src_ignore, uri_ignore, name_ignore): 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()) self.populate_interfaces(interface_list.get_model())
def populate_interfaces(self, model): def populate_interfaces(self, model):
iface_list = self.window.get_widget("interface-list") iface_list = self.widget("interface-list")
model.clear() model.clear()
for name in self.conn.list_interface_names(): for name in self.conn.list_interface_names():
iface = self.conn.get_interface(name) iface = self.conn.get_interface(name)
@ -1134,7 +1133,7 @@ class vmmHost(vmmGObjectUI):
def populate_interface_children(self): def populate_interface_children(self):
interface = self.current_interface() 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 = child_list.get_model()
model.clear() model.clear()

94
src/virtManager/manager.py
View File

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

89
src/virtManager/migrate.py
View File

@ -70,12 +70,12 @@ class vmmMigrateDialog(vmmGObjectUI):
self.bind_escape_key_close() self.bind_escape_key_close()
blue = gtk.gdk.color_parse("#0072A8") 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) blue)
image = gtk.image_new_from_icon_name("vm_clone_wizard", image = gtk.image_new_from_icon_name("vm_clone_wizard",
gtk.ICON_SIZE_DIALOG) gtk.ICON_SIZE_DIALOG)
image.show() 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() self.init_state()
@ -97,14 +97,14 @@ class vmmMigrateDialog(vmmGObjectUI):
self.destconn_rows = None self.destconn_rows = None
# Not sure why we need to do this manually, but it matters # 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) vmmGObjectUI.cleanup(self)
def init_state(self): def init_state(self):
# [hostname, conn, can_migrate, tooltip] # [hostname, conn, can_migrate, tooltip]
dest_model = gtk.ListStore(str, object, bool, str) 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) dest_combo.set_model(dest_model)
text = gtk.CellRendererText() text = gtk.CellRendererText()
dest_combo.pack_start(text, True) dest_combo.pack_start(text, True)
@ -121,31 +121,31 @@ class vmmMigrateDialog(vmmGObjectUI):
def reset_state(self): def reset_state(self):
title_str = ("<span size='large' color='white'>%s '%s'</span>" % title_str = ("<span size='large' color='white'>%s '%s'</span>" %
(_("Migrate"), self.vm.get_name())) (_("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() name = self.vm.get_name()
srchost = self.conn.get_hostname() srchost = self.conn.get_hostname()
self.window.get_widget("migrate-label-name").set_text(name) self.widget("migrate-label-name").set_text(name)
self.window.get_widget("migrate-label-src").set_text(srchost) self.widget("migrate-label-src").set_text(srchost)
self.window.get_widget("migrate-advanced-expander").set_expanded(False) self.widget("migrate-advanced-expander").set_expanded(False)
self.window.get_widget("migrate-set-interface").set_active(False) self.widget("migrate-set-interface").set_active(False)
self.window.get_widget("migrate-set-rate").set_active(False) self.widget("migrate-set-rate").set_active(False)
self.window.get_widget("migrate-set-port").set_active(False) self.widget("migrate-set-port").set_active(False)
self.window.get_widget("migrate-set-maxdowntime").set_active(False) self.widget("migrate-set-maxdowntime").set_active(False)
self.window.get_widget("migrate-max-downtime").set_value(30) self.widget("migrate-max-downtime").set_value(30)
running = self.vm.is_active() running = self.vm.is_active()
self.window.get_widget("migrate-offline").set_active(not running) self.widget("migrate-offline").set_active(not running)
self.window.get_widget("migrate-offline").set_sensitive(running) self.widget("migrate-offline").set_sensitive(running)
self.window.get_widget("migrate-rate").set_value(0) self.widget("migrate-rate").set_value(0)
self.window.get_widget("migrate-secure").set_active(False) 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() support_downtime = self.vm.support_downtime()
downtime_tooltip = "" downtime_tooltip = ""
if not support_downtime: if not support_downtime:
@ -156,12 +156,12 @@ class vmmMigrateDialog(vmmGObjectUI):
if self.conn.is_xen(): if self.conn.is_xen():
# Default xen port is 8002 # Default xen port is 8002
self.window.get_widget("migrate-port").set_value(8002) self.widget("migrate-port").set_value(8002)
else: else:
# QEMU migrate port range is 49152+64 # 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") support_secure = hasattr(libvirt, "VIR_MIGRATE_TUNNELLED")
secure_tooltip = "" secure_tooltip = ""
if not support_secure: if not support_secure:
@ -184,31 +184,30 @@ class vmmMigrateDialog(vmmGObjectUI):
if active == -1: if active == -1:
tooltip = _("A valid destination connection must be selected.") tooltip = _("A valid destination connection must be selected.")
self.window.get_widget("migrate-finish").set_sensitive(active != -1) self.widget("migrate-finish").set_sensitive(active != -1)
util.tooltip_wrapper(self.window.get_widget("migrate-finish"), tooltip) util.tooltip_wrapper(self.widget("migrate-finish"), tooltip)
def toggle_set_rate(self, src): def toggle_set_rate(self, src):
enable = src.get_active() 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): def toggle_set_interface(self, src):
enable = src.get_active() enable = src.get_active()
port_enable = self.window.get_widget("migrate-set-port").get_active() port_enable = self.widget("migrate-set-port").get_active()
self.window.get_widget("migrate-interface").set_sensitive(enable) self.widget("migrate-interface").set_sensitive(enable)
self.window.get_widget("migrate-set-port").set_sensitive(enable) self.widget("migrate-set-port").set_sensitive(enable)
self.window.get_widget("migrate-port").set_sensitive(enable and self.widget("migrate-port").set_sensitive(enable and port_enable)
port_enable)
def toggle_set_maxdowntime(self, src): def toggle_set_maxdowntime(self, src):
enable = src.get_active() 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): def toggle_set_port(self, src):
enable = src.get_active() 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): def get_config_destconn(self):
combo = self.window.get_widget("migrate-dest") combo = self.widget("migrate-dest")
model = combo.get_model() model = combo.get_model()
idx = combo.get_active() idx = combo.get_active()
@ -222,39 +221,39 @@ class vmmMigrateDialog(vmmGObjectUI):
return row[1] return row[1]
def get_config_offline(self): 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): def get_config_max_downtime(self):
if not self.get_config_max_downtime_enabled(): if not self.get_config_max_downtime_enabled():
return 0 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): 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): 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): 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): def get_config_rate(self):
if not self.get_config_rate_enabled(): if not self.get_config_rate_enabled():
return 0 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): 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): def get_config_interface(self):
if not self.get_config_interface_enabled(): if not self.get_config_interface_enabled():
return None return None
return self.window.get_widget("migrate-interface").get_text() return self.widget("migrate-interface").get_text()
def get_config_port_enabled(self): 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): def get_config_port(self):
if not self.get_config_port_enabled(): if not self.get_config_port_enabled():
return 0 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): def build_localhost_uri(self, destconn):
desthost = destconn.get_qualified_hostname() desthost = destconn.get_qualified_hostname()
@ -313,7 +312,7 @@ class vmmMigrateDialog(vmmGObjectUI):
self.populate_dest_combo() self.populate_dest_combo()
def populate_dest_combo(self): def populate_dest_combo(self):
combo = self.window.get_widget("migrate-dest") combo = self.widget("migrate-dest")
model = combo.get_model() model = combo.get_model()
idx = combo.get_active() idx = combo.get_active()
idxconn = None idxconn = None
@ -349,7 +348,7 @@ class vmmMigrateDialog(vmmGObjectUI):
combo.set_active(idx) combo.set_active(idx)
def dest_add_connection(self, engine_ignore, conn): def dest_add_connection(self, engine_ignore, conn):
combo = self.window.get_widget("migrate-dest") combo = self.widget("migrate-dest")
model = combo.get_model() model = combo.get_model()
newrow = self.build_dest_row(conn) 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() self.bind_escape_key_close()
# XXX: Help docs useless/out of date # 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): def close(self, ignore1=None, ignore2=None):
self.topwin.hide() self.topwin.hide()
@ -105,39 +105,39 @@ class vmmPreferences(vmmGObjectUI):
def refresh_view_system_tray(self, ignore1=None, ignore2=None, def refresh_view_system_tray(self, ignore1=None, ignore2=None,
ignore3=None, ignore4=None): ignore3=None, ignore4=None):
val = self.config.get_view_system_tray() 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, def refresh_update_interval(self, ignore1=None, ignore2=None,
ignore3=None, ignore4=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()) self.config.get_stats_update_interval())
def refresh_history_length(self, ignore1=None, ignore2=None, def refresh_history_length(self, ignore1=None, ignore2=None,
ignore3=None, ignore4=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()) self.config.get_stats_history_length())
def refresh_console_accels(self, ignore1=None, ignore2=None, def refresh_console_accels(self, ignore1=None, ignore2=None,
ignore3=None, ignore4=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()) self.config.get_console_accels())
def refresh_console_scaling(self, ignore1=None, ignore2=None, def refresh_console_scaling(self, ignore1=None, ignore2=None,
ignore3=None, ignore4=None): ignore3=None, ignore4=None):
val = self.config.get_console_scaling() val = self.config.get_console_scaling()
if val == None: if val == None:
val = 0 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, def refresh_sound_local(self, ignore1=None, ignore2=None, ignore=None,
ignore4=None): ignore4=None):
self.window.get_widget("prefs-sound-local").set_active( self.widget("prefs-sound-local").set_active(
self.config.get_local_sound()) self.config.get_local_sound())
def refresh_sound_remote(self, ignore1=None, ignore2=None, ignore=None, def refresh_sound_remote(self, ignore1=None, ignore2=None, ignore=None,
ignore4=None): ignore4=None):
self.window.get_widget("prefs-sound-remote").set_active( self.widget("prefs-sound-remote").set_active(
self.config.get_remote_sound()) self.config.get_remote_sound())
def refresh_graphics_type(self, ignore1=None, ignore2=None, ignore=None, def refresh_graphics_type(self, ignore1=None, ignore2=None, ignore=None,
ignore4=None): ignore4=None):
combo = self.window.get_widget("prefs-graphics-type") combo = self.widget("prefs-graphics-type")
model = combo.get_model() model = combo.get_model()
gtype = self.config.get_graphics_type() gtype = self.config.get_graphics_type()
@ -148,15 +148,15 @@ class vmmPreferences(vmmGObjectUI):
active = rowidx active = rowidx
break 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, def refresh_disk_poll(self, ignore1=None, ignore2=None, ignore3=None,
ignore4=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()) self.config.get_stats_enable_disk_poll())
def refresh_net_poll(self, ignore1=None, ignore2=None, ignore3=None, def refresh_net_poll(self, ignore1=None, ignore2=None, ignore3=None,
ignore4=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()) self.config.get_stats_enable_net_poll())
def refresh_grabkeys_combination(self, ignore1=None, ignore2=None, def refresh_grabkeys_combination(self, ignore1=None, ignore2=None,
@ -165,8 +165,8 @@ class vmmPreferences(vmmGObjectUI):
if val is None: if val is None:
val = "Control_L+Alt_L" val = "Control_L+Alt_L"
prefs_button = self.window.get_widget("prefs-keys-grab-changebtn") prefs_button = self.widget("prefs-keys-grab-changebtn")
self.window.get_widget("prefs-keys-grab-sequence").set_text(val) self.widget("prefs-keys-grab-sequence").set_text(val)
if not self.config.vnc_grab_keys_supported(): if not self.config.vnc_grab_keys_supported():
util.tooltip_wrapper(prefs_button, util.tooltip_wrapper(prefs_button,
_("Installed version of GTK-VNC doesn't " _("Installed version of GTK-VNC doesn't "
@ -174,19 +174,24 @@ class vmmPreferences(vmmGObjectUI):
def refresh_confirm_forcepoweroff(self, ignore1=None, ignore2=None, def refresh_confirm_forcepoweroff(self, ignore1=None, ignore2=None,
ignore3=None, ignore4=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, def refresh_confirm_poweroff(self, ignore1=None, ignore2=None,
ignore3=None, ignore4=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, def refresh_confirm_pause(self, ignore1=None, ignore2=None,
ignore3=None, ignore4=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, def refresh_confirm_removedev(self, ignore1=None, ignore2=None,
ignore3=None, ignore4=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, def refresh_confirm_interface(self, ignore1=None, ignore2=None,
ignore3=None, ignore4=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): def grabkeys_get_string(self, keysyms):
keystr = None 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, finish_img = gtk.image_new_from_stock(gtk.STOCK_NEW,
gtk.ICON_SIZE_BUTTON) 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, finish_img = gtk.image_new_from_stock(gtk.STOCK_OPEN,
gtk.ICON_SIZE_BUTTON) 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() self.set_initial_state()
@ -116,11 +116,11 @@ class vmmStorageBrowser(vmmGObjectUI):
self.vm_name = name self.vm_name = name
def set_initial_state(self): 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) virtManager.host.init_pool_list(pool_list, self.pool_selected)
# (Key, Name, Cap, Format, Used By, sensitive) # (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) volListModel = gtk.ListStore(str, str, str, str, str, bool)
vol_list.set_model(volListModel) vol_list.set_model(volListModel)
@ -164,7 +164,7 @@ class vmmStorageBrowser(vmmGObjectUI):
self.remove_conn() self.remove_conn()
self.conn = 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) virtManager.host.populate_storage_pools(pool_list, self.conn)
ids = [] ids = []
@ -187,10 +187,10 @@ class vmmStorageBrowser(vmmGObjectUI):
tooltip = None tooltip = None
is_remote = self.conn.is_remote() 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: if is_remote:
tooltip = _("Cannot use local storage on remote connection.") 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) tooltip)
# Set data based on browse type # Set data based on browse type
@ -213,7 +213,7 @@ class vmmStorageBrowser(vmmGObjectUI):
return data["enable_create"] return data["enable_create"]
def current_pool(self): 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: if not row:
return return
return self.conn.get_pool(row[0]) return self.conn.get_pool(row[0])
@ -221,7 +221,7 @@ class vmmStorageBrowser(vmmGObjectUI):
def current_vol_row(self): def current_vol_row(self):
if not self.current_pool(): if not self.current_pool():
return 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): def current_vol(self):
pool = self.current_pool() pool = self.current_pool()
@ -231,7 +231,7 @@ class vmmStorageBrowser(vmmGObjectUI):
return pool.get_volume(row[0]) return pool.get_volume(row[0])
def refresh_storage_pool(self, src_ignore, uri_ignore, uuid): 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) virtManager.host.refresh_pool_in_list(pool_list, self.conn, uuid)
curpool = self.current_pool() curpool = self.current_pool()
if curpool.uuid != uuid: if curpool.uuid != uuid:
@ -239,10 +239,10 @@ class vmmStorageBrowser(vmmGObjectUI):
# Currently selected pool changed state: force a 'pool_selected' to # Currently selected pool changed state: force a 'pool_selected' to
# update vol list # 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): 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) virtManager.host.populate_storage_pools(pool_list, self.conn)
@ -255,14 +255,14 @@ class vmmStorageBrowser(vmmGObjectUI):
newvol = pool.is_active() newvol = pool.is_active()
newvol = newvol and self.allow_create() 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() self.populate_storage_volumes()
def vol_selected(self, ignore=None): def vol_selected(self, ignore=None):
vol = self.current_vol_row() vol = self.current_vol_row()
canchoose = bool(vol and vol[5]) 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): def refresh_current_pool(self, ignore):
cp = self.current_pool() cp = self.current_pool()
@ -310,7 +310,7 @@ class vmmStorageBrowser(vmmGObjectUI):
# Do stuff! # Do stuff!
def populate_storage_volumes(self): def populate_storage_volumes(self):
model = self.window.get_widget("vol-list").get_model() model = self.widget("vol-list").get_model()
model.clear() model.clear()
dironly = self.browse_reason == self.config.CONFIG_DIR_FS dironly = self.browse_reason == self.config.CONFIG_DIR_FS