def initialize(self):
"""
The initialize method that is called after the instance is created.
The difference between __init__ and this method is that this may take
a long time and thus could be called in a separated thread.
:see: pyanaconda.ui.common.UIObject.initialize
"""
NormalSpoke.initialize(self)
self.initialize_start()
self._storage_playground = None
config.log_dir = "/tmp"
self.client = osinstall.BlivetGUIAnacondaClient()
box = self.builder.get_object("BlivetGuiViewport")
self.label_actions = self.builder.get_object("summary_label")
self.button_reset = self.builder.get_object("resetAllButton")
self.button_undo = self.builder.get_object("undoLastActionButton")
config.default_fstype = self._storage.default_fstype
self.blivetgui = osinstall.BlivetGUIAnaconda(self.client, self, box)
# this needs to be done when the spoke is already "realized"
self.entered.connect(self.blivetgui.ui_refresh)
# set up keyboard shurtcuts for blivet-gui (and unset them after
# user lefts the spoke)
self.entered.connect(self.blivetgui.set_keyboard_shortcuts)
self.exited.connect(self.blivetgui.unset_keyboard_shortcuts)
self.initialize_done()
def initialize(self):
"""
The initialize method that is called after the instance is created.
The difference between __init__ and this method is that this may take
a long time and thus could be called in a separated thread.
:see: pyanaconda.ui.common.UIObject.initialize
"""
NormalSpoke.initialize(self)
self.button1 = self.builder.get_object("button1")
self.button1a = self.builder.get_object("button1a")
self.button1b = self.builder.get_object("button1b")
self.button2 = self.builder.get_object("button2")
self.link = self.builder.get_object("fileurl")
# Check if Values Provided in KickStart
if self.data.addons.org_centos_cloud.state == "False":
# ADDON : DISABLED
self.button2.set_active(True)
else:
# No Value Given choose : DEFAULT = ENABLED
self.data.addons.org_centos_cloud.state = "True"
self.button1.set_active(True)
# If no argument provided DEFAULT --allinone is assumed
if not (str (self.data.addons.org_centos_cloud.arguments).startswith("--answer-file")):
self.data.addons.org_centos_cloud.arguments = "--allinone"
def initialize(self):
"""
The initialize method that is called after the instance is created.
The difference between __init__ and this method is that this may take
a long time and thus could be called in a separated thread.
:see: pyanaconda.ui.common.UIObject.initialize
"""
NormalSpoke.initialize(self)
self.button1 = self.builder.get_object("button1")
self.button1a = self.builder.get_object("button1a")
self.button1b = self.builder.get_object("button1b")
self.button2 = self.builder.get_object("button2")
self.link = self.builder.get_object("fileurl")
# Check if Values Provided in KickStart
if self.data.addons.org_centos_cloud.state == "False":
# ADDON : DISABLED
self.button2.set_active(True)
else:
# No Value Given choose : DEFAULT = ENABLED
self.data.addons.org_centos_cloud.state = "True"
self.button1.set_active(True)
# If no argument provided DEFAULT --allinone is assumed
if not (str(self.data.addons.org_centos_cloud.arguments).
startswith("--answer-file")):
self.data.addons.org_centos_cloud.arguments = "--allinone"
def initialize(self):
from pyanaconda.ui.gui.utils import setViewportBackground
NormalSpoke.initialize(self)
# Wouldn't it be nice if glade knew how to do this?
label = self.builder.get_object("summary_button").get_children()[0]
markup = "<span foreground='blue'><u>%s</u></span>" % label.get_text()
label.set_use_markup(True)
label.set_markup(markup)
specializedButton = self.builder.get_object("addSpecializedButton")
# It's uh... uh... it's down there somewhere, let me take another look.
label = specializedButton.get_children()[0].get_children()[0].get_children()[1]
markup = "<span size='large'><b>%s</b></span>" % label.get_text()
label.set_use_markup(True)
label.set_markup(markup)
specializedButton.show_all()
self.local_disks_box = self.builder.get_object("local_disks_box")
self.specialized_disks_box = self.builder.get_object("specialized_disks_box")
threadMgr.add(AnacondaThread(name=constants.THREAD_STORAGE_WATCHER,
target=self._initialize))
def initialize(self):
"""
The initialize method that is called after the instance is created.
The difference between __init__ and this method is that this may take
a long time and thus could be called in a separated thread.
:see: pyanaconda.ui.common.UIObject.initialize
"""
NormalSpoke.initialize(self)
self.success = False
self.complete = False
self.data.addons.org_centos_cloud.env = "firstboot"
self.button = self.builder.get_object("button1")
self.progressbar = self.builder.get_object("progressbar1")
if self.data.addons.org_centos_cloud.state == "False":
# Addon is disabled
self.complete = True
elif self.data.addons.org_centos_cloud.state == "True":
#print("--disable")
if self.data.addons.org_centos_cloud.arguments == "--allinone":
pass # call run packstack --allinone or activate click button
elif self.data.addons.org_centos_cloud.arguments: # --answer-file
pass # call packstack --answer-file ()
else:
self.complete = False
def initialize(self):
"""
The initialize method that is called after the instance is created.
The difference between __init__ and this method is that this may take
a long time and thus could be called in a separated thread.
:see: pyanaconda.ui.common.UIObject.initialize
"""
NormalSpoke.initialize(self)
import logging
self.log = logging.getLogger("anaconda")
self.log.info("Rocks was here")
# self.builder.connect_signals(self)
# Get the Main Window, and connect the "destroy" event
# self.window = self.builder.get_object("RollsWindow")
self.rollUrl = self.builder.get_object("rollUrl")
self.rollUrl.set_text(self.defaultUrl)
self.listStore = self.builder.get_object("listRoll")
self.selectStore = self.builder.get_object("selectedRolls")
self.rollSelectCombo = self.builder.get_object("rollSelectCombo")
sys.path.append("/opt/rocks/lib/python2.7/site-packages")
import rocks.media
import rocks.installcgi
self.media = rocks.media.Media()
self.install = rocks.installcgi.InstallCGI(rootdir="/tmp/rocks")
def initialize(self):
"""
The initialize method that is called after the instance is created.
The difference between __init__ and this method is that this may take
a long time and thus could be called in a separated thread.
:see: pyanaconda.ui.common.UIObject.initialize
"""
NormalSpoke.initialize(self)
self.initialize_start()
self._storage_playground = None
config.log_dir = "/tmp"
self.client = osinstall.BlivetGUIAnacondaClient()
box = self.builder.get_object("BlivetGuiViewport")
self.label_actions = self.builder.get_object("summary_label")
self.button_reset = self.builder.get_object("resetAllButton")
self.button_undo = self.builder.get_object("undoLastActionButton")
config.default_fstype = self._storage.default_fstype
self.blivetgui = osinstall.BlivetGUIAnaconda(self.client, self, box)
# this needs to be done when the spoke is already "realized"
self.entered.connect(self.blivetgui.ui_refresh)
# set up keyboard shurtcuts for blivet-gui (and unset them after
# user lefts the spoke)
self.entered.connect(self.blivetgui.set_keyboard_shortcuts)
self.exited.connect(self.blivetgui.unset_keyboard_shortcuts)
self.initialize_done()
def initialize(self):
NormalSpoke.initialize(self)
self._enableButton = self.builder.get_object("enableKdumpCheck")
self._reservationTypeLabel = self.builder.get_object("reservationTypeLabel")
self._autoButton = self.builder.get_object("autoButton")
self._manualButton = self.builder.get_object("manualButton")
self._currentlyReservedLabel = self.builder.get_object("currentlyReservedLabel")
self._currentlyReservedMB = self.builder.get_object("currentlyReservedMB")
self._toBeReservedLabel = self.builder.get_object("toBeReservedLabel")
self._toBeReservedSpin = self.builder.get_object("toBeReservedSpin")
self._totalMemLabel = self.builder.get_object("totalMemLabel")
self._totalMemMB = self.builder.get_object("totalMemMB")
self._usableMemLabel = self.builder.get_object("usableMemLabel")
self._usableMemMB = self.builder.get_object("usableMemMB")
self._config_buffer = self.builder.get_object("advancedConfigBuffer")
# Set an initial value and adjustment on the spin button
lower, upper, step = getMemoryBounds()
adjustment = Gtk.Adjustment(lower, lower, upper, step, step, 0)
self._toBeReservedSpin.set_adjustment(adjustment)
self._toBeReservedSpin.set_value(lower)
# Initialize the advanced config area with the contents of /etc/kdump.conf
try:
with open(CONFIG_FILE, "r") as fobj:
self._config_buffer.set_text(fobj.read())
except IOError:
self._config_buffer.set_text("")
def initialize(self):
NormalSpoke.initialize(self)
self.initialize_start()
self.pages = [
SearchPage(self.storage, self.builder),
MultipathPage(self.storage, self.builder),
OtherPage(self.storage, self.builder),
ZPage(self.storage, self.builder)
]
self._notebook = self.builder.get_object("advancedNotebook")
if not arch.is_s390():
self._notebook.remove_page(-1)
self.builder.get_object("addZFCPButton").destroy()
self.builder.get_object("addDASDButton").destroy()
if not has_fcoe():
self.builder.get_object("addFCOEButton").destroy()
if not iscsi.available:
self.builder.get_object("addISCSIButton").destroy()
self._store = self.builder.get_object("diskStore")
self._addDisksButton = self.builder.get_object("addDisksButton")
# report that we are done
self.initialize_done()
def initialize(self):
"""
The initialize method that is called after the instance is created.
The difference between __init__ and this method is that this may take
a long time and thus could be called in a separated thread.
:see: pyanaconda.ui.common.UIObject.initialize
"""
NormalSpoke.initialize(self)
self.success = False
self.complete = False
self.data.addons.org_centos_cloud.env = "firstboot"
self.button = self.builder.get_object("button1")
self.progressbar = self.builder.get_object("progressbar1")
if self.data.addons.org_centos_cloud.state == "False":
# Addon is disabled
self.complete = True
elif self.data.addons.org_centos_cloud.state == "True":
#print("--disable")
if self.data.addons.org_centos_cloud.arguments == "--allinone":
pass # call run packstack --allinone or activate click button
elif self.data.addons.org_centos_cloud.arguments: # --answer-file
pass # call packstack --answer-file ()
else:
self.complete = False
def initialize(self):
NormalSpoke.initialize(self)
self.initialize_start()
self.pages = [SearchPage(self.storage, self.builder),
MultipathPage(self.storage, self.builder),
OtherPage(self.storage, self.builder),
ZPage(self.storage, self.builder)]
self._notebook = self.builder.get_object("advancedNotebook")
if not arch.is_s390():
self._notebook.remove_page(-1)
self.builder.get_object("addZFCPButton").destroy()
self.builder.get_object("addDASDButton").destroy()
if not has_fcoe():
self.builder.get_object("addFCOEButton").destroy()
if not iscsi.available:
self.builder.get_object("addISCSIButton").destroy()
self._store = self.builder.get_object("diskStore")
self._addDisksButton = self.builder.get_object("addDisksButton")
# report that we are done
self.initialize_done()
def initialize(self):
NormalSpoke.initialize(self)
self._done = False
init_dep_injection()
facts = inj.require(inj.FACTS)
backend = managergui.Backend()
self._registergui = registergui.RegisterScreen(backend, facts,
callbacks=[self.finished])
self._action_area = self.builder.get_object("RHSMSpokeWindow-action_area1")
self._register_box = self._registergui.dialog_vbox6
# FIXME: close_window handling is kind of a mess. Standlone subman gui,
# the firstboot screens, and initial-setup need it to do different
# things. Potentially a 'Im done with this window now' signal, with
# each attaching different handlers.
self._registergui.close_window_callback = self._close_window_callback
# we have a ref to _register_box, but need to remove it from
# the regustergui.window (a GtkDialog), and add it to the main
# box in the action area of our initial-setup screen.
self._registergui.window.remove(self._register_box)
self._action_area.pack_end(self._register_box, True, True, 0)
self._action_area.show()
self._register_box.show_all()
self._registergui.initialize()
def initialize(self):
from pyanaconda.ui.gui.utils import setViewportBackground
NormalSpoke.initialize(self)
# Wouldn't it be nice if glade knew how to do this?
label = self.builder.get_object("summary_button").get_children()[0]
markup = "<span foreground='blue'><u>%s</u></span>" % label.get_text()
label.set_use_markup(True)
label.set_markup(markup)
specializedButton = self.builder.get_object("addSpecializedButton")
# It's uh... uh... it's down there somewhere, let me take another look.
label = specializedButton.get_children()[0].get_children(
)[0].get_children()[1]
markup = "<span size='large'><b>%s</b></span>" % label.get_text()
label.set_use_markup(True)
label.set_markup(markup)
specializedButton.show_all()
self.local_disks_box = self.builder.get_object("local_disks_box")
self.specialized_disks_box = self.builder.get_object(
"specialized_disks_box")
threadMgr.add(
AnacondaThread(name=constants.THREAD_STORAGE_WATCHER,
target=self._initialize))
def initialize(self):
"""
The initialize method that is called after the instance is created.
The difference between __init__ and this method is that this may take
a long time and thus could be called in a separated thread.
:see: pyanaconda.ui.common.UIObject.initialize
"""
NormalSpoke.initialize(self)
self.initialize_start()
self._storage_playground = None
self.client = osinstall.BlivetGUIAnacondaClient()
box = self.builder.get_object("BlivetGuiViewport")
self.label_actions = self.builder.get_object("summary_label")
self.button_reset = self.builder.get_object("resetAllButton")
self.button_undo = self.builder.get_object("undoLastActionButton")
config.default_fstype = self._storage.default_fstype
self.blivetgui = osinstall.BlivetGUIAnaconda(self.client, self, box)
self.initialize_done()
def initialize(self):
NormalSpoke.initialize(self)
self._grabObjects()
# I shouldn't have to do this outside GtkBuilder, but it really doesn't
# want to let me pass in user data.
self._autodetectButton.connect("toggled", self.on_source_toggled,
self._autodetectBox)
self._isoButton.connect("toggled", self.on_source_toggled,
self._isoBox)
self._networkButton.connect("toggled", self.on_source_toggled,
self._networkBox)
# Show or hide the updates option based on the installclass
if self.instclass.installUpdates:
really_show(self._updatesBox)
else:
really_hide(self._updatesBox)
self._repoNameWarningBox = self.builder.get_object(
"repoNameWarningBox")
self._repoNameWarningLabel = self.builder.get_object(
"repoNameWarningLabel")
self._repoNamesWarningBox = self.builder.get_object(
"repoNamesWarningBox")
self._repoNamesWarningLabel = self.builder.get_object(
"repoNamesWarningLabel")
threadMgr.add(
AnacondaThread(name=constants.THREAD_SOURCE_WATCHER,
target=self._initialize))
def initialize(self):
"""
The initialize method that is called after the instance is created.
The difference between __init__ and this method is that this may take
a long time and thus could be called in a separated thread.
:see: pyanaconda.ui.common.UIObject.initialize
"""
NormalSpoke.initialize(self)
import logging
self.log = logging.getLogger('anaconda')
self.log.info("Initialize Cluster Config")
self.infoStore = self.builder.get_object("ClusterInfoStore")
self.infoFilter = self.builder.get_object("ClusterInfoFilter")
self.infoFilter.set_visible_column(FIELDNAMES.index("display"))
jsoninfo = self.populate()
self.mapAnacondaValues(jsoninfo)
# merge entries into self.data.addons.org_rocks_rolls.info
self.merge(jsoninfo)
self.visited = False
self.readyState = True
def initialize(self):
NormalSpoke.initialize(self)
self.local_disks_box = self.builder.get_object("local_disks_box")
self.specialized_disks_box = self.builder.get_object("specialized_disks_box")
threadMgr.add(AnacondaThread(name=constants.THREAD_STORAGE_WATCHER,
target=self._initialize))
def initialize(self):
NormalSpoke.initialize(self)
# place holders for the text boxes
self.pw = self.builder.get_object("pw")
self.confirm = self.builder.get_object("confirmPW")
# Install the password checks:
# - Has a password been specified?
# - If a password has been specified and there is data in the confirm box, do they match?
# - How strong is the password?
# - Does the password contain non-ASCII characters?
# - Is there any data in the confirm box?
self.add_check(self.pw, self._checkPasswordEmpty)
# The password confirmation needs to be checked whenever either of the password
# fields change. Separate checks are created for each field so that edits on either
# will trigger a new check and so that the last edited field will get focus when
# Done is clicked. The checks are saved here so that either check can trigger the
# other check in order to reset the status on both when either field is changed.
# The check_data field is used as a flag to prevent infinite recursion.
self._confirm_check = self.add_check(self.confirm,
self._checkPasswordConfirm)
self._password_check = self.add_check(self.pw,
self._checkPasswordConfirm)
# Keep a reference for these checks, since they have to be manually run for the
# click Done twice check.
self._pwStrengthCheck = self.add_check(self.pw,
self._checkPasswordStrength)
self._pwASCIICheck = self.add_check(self.pw, self._checkPasswordASCII)
self.add_check(self.confirm, self._checkPasswordEmpty)
# Counters for checks that ask the user to click Done to confirm
self._waiveStrengthClicks = 0
self._waiveASCIIClicks = 0
# Password validation data
self._pw_error_message = None
self._pw_score = 0
self._kickstarted = self.data.rootpw.seen
if self._kickstarted:
self.pw.set_placeholder_text(_("The password is set."))
self.confirm.set_placeholder_text(_("The password is set."))
self.pw_bar = self.builder.get_object("password_bar")
self.pw_label = self.builder.get_object("password_label")
# Configure levels for the password bar
self.pw_bar.add_offset_value("low", 2)
self.pw_bar.add_offset_value("medium", 3)
self.pw_bar.add_offset_value("high", 4)
# Configure the password policy, if available. Otherwise use defaults.
self.policy = self.data.anaconda.pwpolicy.get_policy("root")
if not self.policy:
self.policy = self.data.anaconda.PwPolicyData()
def initialize(self):
NormalSpoke.initialize(self)
self.initialize_start()
# set X keyboard defaults
# - this needs to be done early in spoke initialization so that
# the spoke status does not show outdated keyboard selection
keyboard.set_x_keyboard_defaults(self.data, self._xkl_wrapper)
# make sure the x_layouts list has at least one keyboard layout
if not self.data.keyboard.x_layouts:
self.data.keyboard.x_layouts.append(DEFAULT_KEYBOARD)
self._add_dialog = AddLayoutDialog(self.data)
self._add_dialog.initialize()
if flags.can_touch_runtime_system("hide runtime keyboard configuration "
"warning", touch_live=True):
self.builder.get_object("warningBox").hide()
# We want to store layouts' names but show layouts as
# 'language (description)'.
layoutColumn = self.builder.get_object("layoutColumn")
layoutRenderer = self.builder.get_object("layoutRenderer")
override_cell_property(layoutColumn, layoutRenderer, "text", _show_layout,
self._xkl_wrapper)
self._store = self.builder.get_object("addedLayoutStore")
self._add_data_layouts()
self._selection = self.builder.get_object("layoutSelection")
self._switching_dialog = ConfigureSwitchingDialog(self.data)
self._switching_dialog.initialize()
self._layoutSwitchLabel = self.builder.get_object("layoutSwitchLabel")
if not flags.can_touch_runtime_system("test X layouts", touch_live=True):
# Disable area for testing layouts as we cannot make
# it work without modifying runtime system
widgets = [self.builder.get_object("testingLabel"),
self.builder.get_object("testingWindow"),
self.builder.get_object("layoutSwitchLabel")]
# Use testingLabel's text to explain why this part is not
# sensitive.
widgets[0].set_text(_("Testing layouts configuration not "
"available."))
for widget in widgets:
widget.set_sensitive(False)
hubQ.send_not_ready(self.__class__.__name__)
hubQ.send_message(self.__class__.__name__,
_("Getting list of layouts..."))
threadMgr.add(AnacondaThread(name=THREAD_KEYBOARD_INIT,
target=self._wait_ready))
def initialize(self):
NormalSpoke.initialize(self)
# place holders for the text boxes
self.pw = self.builder.get_object("pw")
self.confirm = self.builder.get_object("confirmPW")
self.lock = self.builder.get_object("lock")
# Install the password checks:
# - Has a password been specified?
# - If a password has been specified and there is data in the confirm box, do they match?
# - How strong is the password?
# - Does the password contain non-ASCII characters?
# - Is there any data in the confirm box?
self.add_check(self.pw, self._checkPasswordEmpty)
# the password confirmation needs to be checked whenever either of the password
# fields change. attach to the confirm field so that errors focus on confirm,
# and check changes to the password field in on_password_changed
self._confirm_check = self.add_check(self.confirm, self._checkPasswordConfirm)
# Keep a reference for these checks, since they have to be manually run for the
# click Done twice check.
self._pwStrengthCheck = self.add_check(self.pw, self._checkPasswordStrength)
self._pwASCIICheck = self.add_check(self.pw, self._checkPasswordASCII)
self.add_check(self.confirm, self._checkPasswordEmpty)
# Counters for checks that ask the user to click Done to confirm
self._waiveStrengthClicks = 0
self._waiveASCIIClicks = 0
# Password validation data
self._pwq_error = None
self._pwq_valid = True
self._kickstarted = self.data.rootpw.seen
if self._kickstarted:
self.pw.set_placeholder_text(_("The password is set."))
self.confirm.set_placeholder_text(_("The password is set."))
self.pw_bar = self.builder.get_object("password_bar")
self.pw_label = self.builder.get_object("password_label")
# Configure levels for the password bar
self.pw_bar.add_offset_value("low", 2)
self.pw_bar.add_offset_value("medium", 3)
self.pw_bar.add_offset_value("high", 4)
self.pw_bar.add_offset_value("full", 4)
# Configure the password policy, if available. Otherwise use defaults.
self.policy = self.data.anaconda.pwpolicy.get_policy("root")
if not self.policy:
self.policy = self.data.anaconda.PwPolicyData()
# set the visibility of the password entries
set_password_visibility(self.pw, False)
set_password_visibility(self.confirm, False)
def initialize(self):
NormalSpoke.initialize(self)
self._softwareListBox = self.builder.get_object("softwareListBox")
self._countSelectedSoftware = 0
for key, value in self.data.addons.se_nauman_packages.software.items():
self._add_row(self._softwareListBox, key, value["Desc"], value["Active"])
if value["Active"] is True:
self._countSelectedSoftware += 1
def initialize(self):
NormalSpoke.initialize(self)
self.local_disks_box = self.builder.get_object("local_disks_box")
self.specialized_disks_box = self.builder.get_object(
"specialized_disks_box")
threadMgr.add(
AnacondaThread(name=constants.THREAD_STORAGE_WATCHER,
target=self._initialize))
def initialize(self):
"""
The initialize method that is called after the instance is created.
The difference between __init__ and this method is that this may take
a long time and thus could be called in a separated thread.
:see: pyanaconda.ui.common.UIObject.initialize
"""
NormalSpoke.initialize(self)
def initialize(self):
"""
The initialize method that is called after the instance is created.
The difference between __init__ and this method is that this may take
a long time and thus could be called in a separated thread.
:see: pyanaconda.ui.common.UIObject.initialize
"""
NormalSpoke.initialize(self)
def initialize(self):
"""
The initialize method that is called after the instance is created.
The difference between __init__ and this method is that this may take
a long time and thus could be called in a separated thread.
:see: pyanaconda.ui.common.UIObject.initialize
"""
NormalSpoke.initialize(self)
self._entry = self.builder.get_object("textLines")
self._reverse = self.builder.get_object("reverseCheckButton")
def initialize(self):
NormalSpoke.initialize(self)
self._yubikeyCheckBox = self.builder.get_object("yubikey")
# Get Yubikey. Will assign self._yubikey and set self._yubikeyVersion
try:
self._getYubikey()
except ValueError as e:
self._yubikeyError = e
# Generate and set passphrase
self._updateDiskCrypto()
def initialize(self):
"""
The initialize method that is called after the instance is created.
The difference between __init__ and this method is that this may take
a long time and thus could be called in a separated thread.
:see: pyanaconda.ui.common.UIObject.initialize
"""
NormalSpoke.initialize(self)
self._entry = self.builder.get_object('textLines')
self._print_packages(self._package_remove_module.Lines)
self.apply()
def initialize(self):
NormalSpoke.initialize(self)
# place holders for the text boxes
self.pw = self.builder.get_object("pw")
self.confirm = self.builder.get_object("confirmPW")
# Install the password checks:
# - Has a password been specified?
# - If a password has been specified and there is data in the confirm box, do they match?
# - How strong is the password?
# - Does the password contain non-ASCII characters?
# - Is there any data in the confirm box?
self.add_check(self.pw, self._checkPasswordEmpty)
# the password confirmation needs to be checked whenever either of the password
# fields change. attach to the confirm field so that errors focus on confirm,
# and check changes to the password field in on_password_changed
self._confirm_check = self.add_check(self.confirm, self._checkPasswordConfirm)
# Keep a reference for these checks, since they have to be manually run for the
# click Done twice check.
self._pwStrengthCheck = self.add_check(self.pw, self._checkPasswordStrength)
self._pwASCIICheck = self.add_check(self.pw, self._checkPasswordASCII)
self.add_check(self.confirm, self._checkPasswordEmpty)
# Counters for checks that ask the user to click Done to confirm
self._waiveStrengthClicks = 0
self._waiveASCIIClicks = 0
# Password validation data
self._pwq_error = None
self._pwq_valid = True
self._kickstarted = self.data.rootpw.seen
if self._kickstarted:
self.pw.set_placeholder_text(_("The password is set."))
self.confirm.set_placeholder_text(_("The password is set."))
self.pw_bar = self.builder.get_object("password_bar")
self.pw_label = self.builder.get_object("password_label")
# Configure levels for the password bar
self.pw_bar.add_offset_value("low", 2)
self.pw_bar.add_offset_value("medium", 3)
self.pw_bar.add_offset_value("high", 4)
self.pw_bar.add_offset_value("full", 4)
# Configure the password policy, if available. Otherwise use defaults.
self.policy = self.data.anaconda.pwpolicy.get_policy("root")
if not self.policy:
self.policy = self.data.anaconda.PwPolicyData()
def initialize(self):
NormalSpoke.initialize(self)
self._add_dialog = AddLayoutDialog(self.data)
self._add_dialog.initialize()
if flags.can_touch_runtime_system(
"hide runtime keyboard configuration "
"warning", touch_live=True):
self.builder.get_object("warningBox").hide()
# We want to store layouts' names but show layouts as
# 'language (description)'.
layoutColumn = self.builder.get_object("layoutColumn")
layoutRenderer = self.builder.get_object("layoutRenderer")
override_cell_property(layoutColumn, layoutRenderer, "text",
_show_layout, self._xkl_wrapper)
self._store = self.builder.get_object("addedLayoutStore")
self._add_data_layouts()
self._selection = self.builder.get_object("layoutSelection")
self._switching_dialog = ConfigureSwitchingDialog(self.data)
self._switching_dialog.initialize()
self._layoutSwitchLabel = self.builder.get_object("layoutSwitchLabel")
if not flags.can_touch_runtime_system("test X layouts",
touch_live=True):
# Disable area for testing layouts as we cannot make
# it work without modifying runtime system
widgets = [
self.builder.get_object("testingLabel"),
self.builder.get_object("testingWindow"),
self.builder.get_object("layoutSwitchLabel")
]
# Use testingLabel's text to explain why this part is not
# sensitive.
widgets[0].set_text(
_("Testing layouts configuration not "
"available."))
for widget in widgets:
widget.set_sensitive(False)
hubQ.send_not_ready(self.__class__.__name__)
hubQ.send_message(self.__class__.__name__,
_("Getting list of layouts..."))
threadMgr.add(
AnacondaThread(name=THREAD_KEYBOARD_INIT, target=self._wait_ready))
def initialize(self):
NormalSpoke.initialize(self)
# place holders for the text boxes
self.pw = self.builder.get_object("pw")
self.confirm = self.builder.get_object("confirm")
self._kickstarted = self.data.rootpw.seen
if self._kickstarted:
self.pw.set_placeholder_text(_("The password is set."))
self.confirm.set_placeholder_text(_("The password is set."))
self.pw_bar = self.builder.get_object("password_bar")
self.pw_label = self.builder.get_object("password_label")
def initialize(self):
NormalSpoke.initialize(self)
self.initialize_start()
# place holders for the text boxes
self.pw = self.builder.get_object("pw")
self.confirm = self.builder.get_object("confirmPW")
# Install the password checks:
# - Has a password been specified?
# - If a password has been specified and there is data in the confirm box, do they match?
# - How strong is the password?
# - Does the password contain non-ASCII characters?
# - Is there any data in the confirm box?
self._confirm_check = self.add_check(self.confirm,
self.check_password_confirm)
# Keep a reference for these checks, since they have to be manually run for the
# click Done twice check.
self._pwEmptyCheck = self.add_check(self.pw, self.check_password_empty)
self._pwStrengthCheck = self.add_check(
self.pw, self.check_user_password_strength)
self._pwASCIICheck = self.add_check(self.pw, self.check_password_ASCII)
self._kickstarted = self.data.rootpw.seen
if self._kickstarted:
self.pw.set_placeholder_text(_("The password is set."))
self.confirm.set_placeholder_text(_("The password is set."))
self.pw_bar = self.builder.get_object("password_bar")
self.pw_label = self.builder.get_object("password_label")
# Configure levels for the password bar
self.pw_bar.add_offset_value("low", 2)
self.pw_bar.add_offset_value("medium", 3)
self.pw_bar.add_offset_value("high", 4)
self.pw_bar.add_offset_value("full", 4)
# Configure the password policy, if available. Otherwise use defaults.
self.policy = self.data.anaconda.pwpolicy.get_policy("root")
if not self.policy:
self.policy = self.data.anaconda.PwPolicyData()
# set the visibility of the password entries
set_password_visibility(self.pw, False)
set_password_visibility(self.confirm, False)
# Send ready signal to main event loop
hubQ.send_ready(self.__class__.__name__, False)
# report that we are done
self.initialize_done()
def initialize(self):
NormalSpoke.initialize(self)
# place holders for the text boxes
self.pw = self.builder.get_object("pw")
self.confirm = self.builder.get_object("confirm")
self.lock = self.builder.get_object("lock")
# Install the password checks:
# - Has a password been specified?
# - If a password has been specified and there is data in the confirm box, do they match?
# - How strong is the password?
# - Is there any data in the confirm box?
self.add_check(self.pw, self._checkPasswordEmpty)
# The password confirmation needs to be checked whenever either of the password
# fields change. Separate checks are created for each field so that edits on either
# will trigger a new check and so that the last edited field will get focus when
# Done is clicked. The checks are saved here so that either check can trigger the
# other check in order to reset the status on both when either field is changed.
# The check_data field is used as a flag to prevent infinite recursion.
self._confirm_check = self.add_check(self.confirm,
self._checkPasswordConfirm)
self._password_check = self.add_check(self.pw,
self._checkPasswordConfirm)
# Keep a reference for this check, since it has to be manually run for the
# click Done twice check.
self._pwStrengthCheck = self.add_check(self.pw,
self._checkPasswordStrength)
self.add_check(self.confirm, self._checkPasswordEmpty)
# Counter for the click Done twice check override
self._waivePasswordClicks = 0
# Password validation data
self._pwq_error = None
self._pwq_valid = True
self._kickstarted = self.data.rootpw.seen
if self._kickstarted:
self.pw.set_placeholder_text(_("The password is set."))
self.confirm.set_placeholder_text(_("The password is set."))
self.pw_bar = self.builder.get_object("password_bar")
self.pw_label = self.builder.get_object("password_label")
# Configure levels for the password bar
self.pw_bar.add_offset_value("low", 2)
self.pw_bar.add_offset_value("medium", 3)
self.pw_bar.add_offset_value("high", 4)
def initialize(self):
from pyanaconda.threads import threadMgr, AnacondaThread
NormalSpoke.initialize(self)
self._grabObjects()
# I shouldn't have to do this outside GtkBuilder, but it really doesn't
# want to let me pass in user data.
self._autodetectButton.connect("toggled", self.on_source_toggled, self._autodetectBox)
self._isoButton.connect("toggled", self.on_source_toggled, self._isoBox)
self._networkButton.connect("toggled", self.on_source_toggled, self._networkBox)
threadMgr.add(AnacondaThread(name=constants.THREAD_SOURCE_WATCHER, target=self._initialize))
def initialize(self):
NormalSpoke.initialize(self)
self._daysStore = self.builder.get_object("days")
self._monthsStore = self.builder.get_object("months")
self._yearsStore = self.builder.get_object("years")
self._regionsStore = self.builder.get_object("regions")
self._citiesStore = self.builder.get_object("cities")
self._tzmap = self.builder.get_object("tzmap")
# we need to know it the new value is the same as previous or not
self._old_region = None
self._old_city = None
self._regionCombo = self.builder.get_object("regionCombobox")
self._cityCombo = self.builder.get_object("cityCombobox")
self._monthCombo = self.builder.get_object("monthCombobox")
self._dayCombo = self.builder.get_object("dayCombobox")
self._yearCombo = self.builder.get_object("yearCombobox")
self._daysFilter = self.builder.get_object("daysFilter")
self._daysFilter.set_visible_func(self.existing_date, None)
self._citiesFilter = self.builder.get_object("citiesFilter")
self._citiesFilter.set_visible_func(self.city_in_region, None)
self._hoursLabel = self.builder.get_object("hoursLabel")
self._minutesLabel = self.builder.get_object("minutesLabel")
self._amPmUp = self.builder.get_object("amPmUpButton")
self._amPmDown = self.builder.get_object("amPmDownButton")
self._amPmLabel = self.builder.get_object("amPmLabel")
self._radioButton24h = self.builder.get_object("timeFormatRB")
self._ntpSwitch = self.builder.get_object("networkTimeSwitch")
self._regions_zones = get_all_regions_and_timezones()
self._months_nums = dict()
# Set the initial sensitivity of the AM/PM toggle based on the time-type selected
self._radioButton24h.emit("toggled")
if not flags.can_touch_runtime_system("modify system time and date"):
self._set_date_time_setting_sensitive(False)
self._config_dialog = NTPconfigDialog(self.data)
self._config_dialog.initialize()
threadMgr.add(AnacondaThread(name=constants.THREAD_DATE_TIME,
target=self._initialize))
def initialize(self):
NormalSpoke.initialize(self)
self.initialize_start()
# place holders for the text boxes
self.pw = self.builder.get_object("pw")
self.confirm = self.builder.get_object("confirmPW")
# Install the password checks:
# - Has a password been specified?
# - If a password has been specified and there is data in the confirm box, do they match?
# - How strong is the password?
# - Does the password contain non-ASCII characters?
# - Is there any data in the confirm box?
self._confirm_check = self.add_check(self.confirm, self.check_password_confirm)
# Keep a reference for these checks, since they have to be manually run for the
# click Done twice check.
self._pwEmptyCheck = self.add_check(self.pw, self.check_password_empty)
self._pwStrengthCheck = self.add_check(self.pw, self.check_user_password_strength)
self._pwASCIICheck = self.add_check(self.pw, self.check_password_ASCII)
self._kickstarted = self.data.rootpw.seen
if self._kickstarted:
self.pw.set_placeholder_text(_("The password is set."))
self.confirm.set_placeholder_text(_("The password is set."))
self.pw_bar = self.builder.get_object("password_bar")
self.pw_label = self.builder.get_object("password_label")
# Configure levels for the password bar
self.pw_bar.add_offset_value("low", 2)
self.pw_bar.add_offset_value("medium", 3)
self.pw_bar.add_offset_value("high", 4)
self.pw_bar.add_offset_value("full", 4)
# Configure the password policy, if available. Otherwise use defaults.
self.policy = self.data.anaconda.pwpolicy.get_policy("root")
if not self.policy:
self.policy = self.data.anaconda.PwPolicyData()
# set the visibility of the password entries
set_password_visibility(self.pw, False)
set_password_visibility(self.confirm, False)
# Send ready signal to main event loop
hubQ.send_ready(self.__class__.__name__, False)
# report that we are done
self.initialize_done()
def initialize(self):
NormalSpoke.initialize(self)
self._done = False
init_dep_injection()
facts = inj.require(inj.FACTS)
backend = managergui.Backend()
self.info = registergui.RegisterInfo()
self.info.connect('notify::register-status',
self._on_register_status_change)
self._status = self.info.get_property('register-status')
self.register_widget = registergui.RegisterWidget(
backend, facts, reg_info=self.info, parent_window=self.main_window)
self.register_box = self.builder.get_object("register_box")
self.button_box = self.builder.get_object('navigation_button_box')
self.proceed_button = self.builder.get_object('proceed_button')
self.back_button = self.builder.get_object('back_button')
self.register_box.pack_start(self.register_widget.register_widget,
True, True, 0)
# Hook up the nav buttons in the gui
# TODO: add a 'start over'?
self.proceed_button.connect('clicked',
self._on_register_button_clicked)
self.back_button.connect('clicked', self._on_back_button_clicked)
# initial-setup will likely
self.register_widget.connect('finished', self._on_finished)
self.register_widget.connect('register-finished',
self._on_register_finished)
self.register_widget.connect('register-error', self._on_register_error)
self.register_widget.connect('register-message',
self._on_register_message)
# update the 'next/register button on page change'
self.register_widget.connect('notify::register-button-label',
self._on_register_button_label_change)
self.register_widget.connect('notify::screen-ready',
self._on_register_screen_ready_change)
self.register_box.show_all()
self.register_widget.initialize()
self.back_button.set_sensitive(False)
def initialize(self):
NormalSpoke.initialize(self)
# place holders for the text boxes
self.pw = self.builder.get_object("pw")
self.confirm = self.builder.get_object("confirm")
self.lock = self.builder.get_object("lock")
# Install the password checks:
# - Has a password been specified?
# - If a password has been specified and there is data in the confirm box, do they match?
# - How strong is the password?
# - Is there any data in the confirm box?
self.add_check(self.pw, self._checkPasswordEmpty)
# The password confirmation needs to be checked whenever either of the password
# fields change. Separate checks are created for each field so that edits on either
# will trigger a new check and so that the last edited field will get focus when
# Done is clicked. The checks are saved here so that either check can trigger the
# other check in order to reset the status on both when either field is changed.
# The check_data field is used as a flag to prevent infinite recursion.
self._confirm_check = self.add_check(self.confirm, self._checkPasswordConfirm)
self._password_check = self.add_check(self.pw, self._checkPasswordConfirm)
# Keep a reference for this check, since it has to be manually run for the
# click Done twice check.
self._pwStrengthCheck = self.add_check(self.pw, self._checkPasswordStrength)
self.add_check(self.confirm, self._checkPasswordEmpty)
# Counter for the click Done twice check override
self._waivePasswordClicks = 0
# Password validation data
self._pwq_error = None
self._pwq_valid = True
self._kickstarted = self.data.rootpw.seen
if self._kickstarted:
self.pw.set_placeholder_text(_("The password is set."))
self.confirm.set_placeholder_text(_("The password is set."))
self.pw_bar = self.builder.get_object("password_bar")
self.pw_label = self.builder.get_object("password_label")
# Configure levels for the password bar
self.pw_bar.add_offset_value("low", 2)
self.pw_bar.add_offset_value("medium", 3)
self.pw_bar.add_offset_value("high", 4)
def initialize(self):
NormalSpoke.initialize(self)
self._add_dialog = AddLayoutDialog(self.data)
self._add_dialog.initialize()
if flags.can_touch_runtime_system("hide runtime keyboard configuration "
"warning", touch_live=True):
self.builder.get_object("warningBox").hide()
# We want to store layouts' names but show layouts as
# 'language (description)'.
layoutColumn = self.builder.get_object("layoutColumn")
layoutRenderer = self.builder.get_object("layoutRenderer")
layoutColumn.set_cell_data_func(layoutRenderer, _show_layout,
self._xkl_wrapper)
self._store = self.builder.get_object("addedLayoutStore")
self._add_data_layouts()
self._selection = self.builder.get_object("layoutSelection")
self._switching_dialog = ConfigureSwitchingDialog(self.data)
self._switching_dialog.initialize()
self._layoutSwitchLabel = self.builder.get_object("layoutSwitchLabel")
if not flags.can_touch_runtime_system("test X layouts", touch_live=True):
# Disable area for testing layouts as we cannot make
# it work without modifying runtime system
widgets = [self.builder.get_object("testingLabel"),
self.builder.get_object("testingWindow"),
self.builder.get_object("layoutSwitchLabel")]
# Use testingLabel's text to explain why this part is not
# sensitive.
widgets[0].set_text(_("Testing layouts configuration not "
"available."))
for widget in widgets:
widget.set_sensitive(False)
hubQ.send_not_ready(self.__class__.__name__)
hubQ.send_message(self.__class__.__name__,
_("Getting list of layouts..."))
threadMgr.add(AnacondaThread(name=THREAD_KEYBOARD_INIT,
target=self._wait_ready))
def initialize(self):
NormalSpoke.initialize(self)
self.initialize_start()
# Connect the viewport adjustments to the child widgets
# See also https://bugzilla.gnome.org/show_bug.cgi?id=744721
self._local_disks_box.set_focus_hadjustment(
Gtk.Scrollable.get_hadjustment(self._local_viewport))
self._specialized_disks_box.set_focus_hadjustment(
Gtk.Scrollable.get_hadjustment(self._specialized_viewport))
self._main_box.set_focus_vadjustment(
Gtk.Scrollable.get_vadjustment(self._main_viewport))
threadMgr.add(AnacondaThread(name=constants.THREAD_STORAGE_WATCHER,
target=self._initialize))
def initialize(self):
NormalSpoke.initialize(self)
# place holders for the text boxes
self.pw = self.builder.get_object("pw")
self.confirm = self.builder.get_object("confirm")
self._kickstarted = self.data.rootpw.seen
if self._kickstarted:
self.pw.set_placeholder_text(_("The password is set."))
self.confirm.set_placeholder_text(_("The password is set."))
# set up passphrase quality checker
self._pwq = pwquality.PWQSettings()
self._pwq.read_config()
self.pw_bar = self.builder.get_object("password_bar")
self.pw_label = self.builder.get_object("password_label")
def initialize(self):
NormalSpoke.initialize(self)
self._done = False
init_dep_injection()
backend = managergui.Backend()
self.info = registergui.RegisterInfo()
self.info.connect('notify::register-status', self._on_register_status_change)
self._status = self.info.get_property('register-status')
self.register_widget = registergui.RegisterWidget(
backend,
reg_info=self.info,
parent_window=self.main_window
)
self.register_box = self.builder.get_object("register_box")
self.button_box = self.builder.get_object('navigation_button_box')
self.proceed_button = self.builder.get_object('proceed_button')
self.back_button = self.builder.get_object('back_button')
self.register_box.pack_start(self.register_widget.register_widget,
True, True, 0)
# Hook up the nav buttons in the gui
# TODO: add a 'start over'?
self.proceed_button.connect('clicked', self._on_register_button_clicked)
self.back_button.connect('clicked', self._on_back_button_clicked)
# initial-setup will likely
self.register_widget.connect('finished', self._on_finished)
self.register_widget.connect('register-finished', self._on_register_finished)
self.register_widget.connect('register-error', self._on_register_error)
self.register_widget.connect('register-message', self._on_register_message)
# update the 'next/register button on page change'
self.register_widget.connect('notify::register-button-label',
self._on_register_button_label_change)
self.register_widget.connect('notify::screen-ready',
self._on_register_screen_ready_change)
self.register_box.show_all()
self.register_widget.initialize()
self.back_button.set_sensitive(False)
def initialize(self):
NormalSpoke.initialize(self)
if self.data.user.userList:
self._user = self.data.user.userList[0]
else:
self._user = self.data.UserData()
self._wheel = self.data.GroupData(name="wheel")
self._groupDict = {"wheel": self._wheel}
# placeholders for the text boxes
self.fullname = self.builder.get_object("t_fullname")
self.username = self.builder.get_object("t_username")
self.pw = self.builder.get_object("t_password")
self.confirm = self.builder.get_object("t_verifypassword")
self.admin = self.builder.get_object("c_admin")
self.usepassword = self.builder.get_object("c_usepassword")
self.b_advanced = self.builder.get_object("b_advanced")
self.guesser = {self.username: True}
# set up passphrase quality checker
self._pwq = pwquality.PWQSettings()
self._pwq.read_config()
self.pw_bar = self.builder.get_object("password_bar")
self.pw_label = self.builder.get_object("password_label")
# indicate when the password was set by kickstart
self._user.password_kickstarted = self.data.user.seen
if self._user.password_kickstarted:
self.usepassword.set_active(self._user.password != "")
if not self._user.isCrypted:
self.pw.set_text(self._user.password)
self.confirm.set_text(self._user.password)
else:
self.usepassword.set_active(True)
self.pw.set_placeholder_text(
_("The password was set by kickstart."))
self.confirm.set_placeholder_text(
_("The password was set by kickstart."))
self._advanced = AdvancedUserDialog(self._user, self._groupDict,
self.data)
self._advanced.initialize()
def initialize(self):
NormalSpoke.initialize(self)
if self.data.user.userList:
self._user = self.data.user.userList[0]
else:
self._user = self.data.UserData()
self._wheel = self.data.GroupData(name = "wheel")
self._groupDict = {"wheel": self._wheel}
# placeholders for the text boxes
self.fullname = self.builder.get_object("t_fullname")
self.username = self.builder.get_object("t_username")
self.pw = self.builder.get_object("t_password")
self.confirm = self.builder.get_object("t_verifypassword")
self.admin = self.builder.get_object("c_admin")
self.usepassword = self.builder.get_object("c_usepassword")
self.b_advanced = self.builder.get_object("b_advanced")
self.guesser = {
self.username: True
}
# set up passphrase quality checker
self._pwq = pwquality.PWQSettings()
self._pwq.read_config()
self.pw_bar = self.builder.get_object("password_bar")
self.pw_label = self.builder.get_object("password_label")
# indicate when the password was set by kickstart
self._user.password_kickstarted = self.data.user.seen
if self._user.password_kickstarted:
self.usepassword.set_active(self._user.password != "")
if not self._user.isCrypted:
self.pw.set_text(self._user.password)
self.confirm.set_text(self._user.password)
else:
self.usepassword.set_active(True)
self.pw.set_placeholder_text(_("The password was set by kickstart."))
self.confirm.set_placeholder_text(_("The password was set by kickstart."))
self._advanced = AdvancedUserDialog(self._user, self._groupDict,
self.data)
self._advanced.initialize()
def initialize(self):
NormalSpoke.initialize(self)
self._grabObjects()
# I shouldn't have to do this outside GtkBuilder, but it really doesn't
# want to let me pass in user data.
self._autodetectButton.connect("toggled", self.on_source_toggled, self._autodetectBox)
self._isoButton.connect("toggled", self.on_source_toggled, self._isoBox)
self._networkButton.connect("toggled", self.on_source_toggled, self._networkBox)
# Show or hide the updates option based on the installclass
if self.instclass.installUpdates:
really_show(self._updatesBox)
else:
really_hide(self._updatesBox)
threadMgr.add(AnacondaThread(name=constants.THREAD_SOURCE_WATCHER, target=self._initialize))
def initialize(self):
NormalSpoke.initialize(self)
self.local_disks_box = self.builder.get_object("local_disks_box")
self.specialized_disks_box = self.builder.get_object("specialized_disks_box")
# Connect the viewport adjustments to the child widgets
# See also https://bugzilla.gnome.org/show_bug.cgi?id=744721
localViewport = self.builder.get_object("localViewport")
specializedViewport = self.builder.get_object("specializedViewport")
self.local_disks_box.set_focus_hadjustment(localViewport.get_hadjustment())
self.specialized_disks_box.set_focus_hadjustment(specializedViewport.get_hadjustment())
mainViewport = self.builder.get_object("storageViewport")
mainBox = self.builder.get_object("storageMainBox")
mainBox.set_focus_vadjustment(mainViewport.get_vadjustment())
threadMgr.add(AnacondaThread(name=constants.THREAD_STORAGE_WATCHER,
target=self._initialize))
def initialize(self):
NormalSpoke.initialize(self)
self._daysStore = self.builder.get_object("days")
self._monthsStore = self.builder.get_object("months")
self._yearsStore = self.builder.get_object("years")
self._regionsStore = self.builder.get_object("regions")
self._citiesStore = self.builder.get_object("cities")
self._tzmap = self.builder.get_object("tzmap")
# we need to know it the new value is the same as previous or not
self._old_region = None
self._old_city = None
self._regionCombo = self.builder.get_object("regionCombobox")
self._cityCombo = self.builder.get_object("cityCombobox")
self._monthCombo = self.builder.get_object("monthCombobox")
self._dayCombo = self.builder.get_object("dayCombobox")
self._yearCombo = self.builder.get_object("yearCombobox")
self._daysFilter = self.builder.get_object("daysFilter")
self._daysFilter.set_visible_func(self.existing_date, None)
self._citiesFilter = self.builder.get_object("citiesFilter")
self._citiesFilter.set_visible_func(self.city_in_region, None)
self._citiesSort = self.builder.get_object("citiesSort")
self._citiesSort.set_sort_column_id(0, Gtk.SortType.ASCENDING)
self._hoursLabel = self.builder.get_object("hoursLabel")
self._minutesLabel = self.builder.get_object("minutesLabel")
self._amPmUp = self.builder.get_object("amPmUpButton")
self._amPmDown = self.builder.get_object("amPmDownButton")
self._amPmLabel = self.builder.get_object("amPmLabel")
self._radioButton24h = self.builder.get_object("timeFormatRB")
self._ntpSwitch = self.builder.get_object("networkTimeSwitch")
self._regions_zones = get_all_regions_and_timezones()
self._months_nums = dict()
threadMgr.add(AnacondaThread(name=constants.THREAD_DATE_TIME,
target=self._initialize))
def initialize(self):
NormalSpoke.initialize(self)
if flags.can_touch_runtime_system(
"hide runtime keyboard configuration "
"warning", touch_live=True):
self.builder.get_object("warningBox").hide()
# We want to store layouts' names but show layouts as
# 'language (description)'.
layoutColumn = self.builder.get_object("layoutColumn")
layoutRenderer = self.builder.get_object("layoutRenderer")
layoutColumn.set_cell_data_func(layoutRenderer, _show_layout,
self._xkl_wrapper)
self._store = self.builder.get_object("addedLayoutStore")
self._add_data_layouts()
self._switching_dialog = ConfigureSwitchingDialog(self.data)
self._switching_dialog.initialize()
self._layoutSwitchLabel = self.builder.get_object("layoutSwitchLabel")
if not flags.can_touch_runtime_system("test X layouts",
touch_live=True):
# Disable area for testing layouts as we cannot make
# it work without modifying runtime system
widgets = [
self.builder.get_object("testingLabel"),
self.builder.get_object("testingWindow"),
self.builder.get_object("layoutSwitchLabel")
]
# Use testingLabel's text to explain why this part is not
# sensitive.
widgets[0].set_text(
_("Testing layouts configuration not "
"available."))
for widget in widgets:
widget.set_sensitive(False)
def initialize(self):
NormalSpoke.initialize(self)
self.pages = [SearchPage(self.storage, self.builder),
MultipathPage(self.storage, self.builder),
OtherPage(self.storage, self.builder),
RaidPage(self.storage, self.builder),
ZPage(self.storage, self.builder)]
self._notebook = self.builder.get_object("advancedNotebook")
if not arch.isS390():
self._notebook.remove_page(-1)
self.builder.get_object("addZFCPButton").destroy()
if not has_fcoe():
self.builder.get_object("addFCOEButton").destroy()
self._store = self.builder.get_object("diskStore")
self._addDisksButton = self.builder.get_object("addDisksButton")
def initialize(self):
NormalSpoke.initialize(self)
self._enableButton = self.builder.get_object("enableKdumpCheck")
self._fadumpButton = self.builder.get_object("fadumpCheck")
if os.path.exists(FADUMP_CAPABLE_FILE):
self._fadumpButton.show()
else:
self._fadumpButton.hide()
self._toBeReservedLabel = self.builder.get_object("toBeReservedLabel")
self._toBeReservedSpin = self.builder.get_object("toBeReservedSpin")
self._totalMemLabel = self.builder.get_object("totalMemLabel")
self._totalMemMB = self.builder.get_object("totalMemMB")
self._usableMemLabel = self.builder.get_object("usableMemLabel")
self._usableMemMB = self.builder.get_object("usableMemMB")
# Set an initial value and adjustment on the spin button
lower, upper, step = getMemoryBounds()
adjustment = Gtk.Adjustment(lower, lower, upper, step, step, 0)
self._toBeReservedSpin.set_adjustment(adjustment)
self._toBeReservedSpin.set_value(lower)
def initialize(self):
NormalSpoke.initialize(self)
self._enableButton = self.builder.get_object("enableKdumpCheck")
self._fadumpButton = self.builder.get_object("fadumpCheck")
if os.path.exists(FADUMP_CAPABLE_FILE):
self._fadumpButton.show()
else:
self._fadumpButton.hide()
self._toBeReservedLabel = self.builder.get_object("toBeReservedLabel")
self._toBeReservedSpin = self.builder.get_object("toBeReservedSpin")
self._totalMemLabel = self.builder.get_object("totalMemLabel")
self._totalMemMB = self.builder.get_object("totalMemMB")
self._usableMemLabel = self.builder.get_object("usableMemLabel")
self._usableMemMB = self.builder.get_object("usableMemMB")
# Set an initial value and adjustment on the spin button
lower, upper, step = getMemoryBounds()
adjustment = Gtk.Adjustment(lower, lower, upper, step, step, 0)
self._toBeReservedSpin.set_adjustment(adjustment)
self._toBeReservedSpin.set_value(lower)
def initialize(self):
NormalSpoke.initialize(self)
self.pages = [SearchPage(self.storage, self.builder),
MultipathPage(self.storage, self.builder),
OtherPage(self.storage, self.builder),
ZPage(self.storage, self.builder)]
self._notebook = self.builder.get_object("advancedNotebook")
if not arch.isS390():
self._notebook.remove_page(-1)
self.builder.get_object("addZFCPButton").destroy()
self.builder.get_object("addDASDButton").destroy()
if not has_fcoe():
self.builder.get_object("addFCOEButton").destroy()
self._store = self.builder.get_object("diskStore")
self._addDisksButton = self.builder.get_object("addDisksButton")
# Connect focus events in scrolled viewport children to scrolling on the viewport
searchScrolledViewport = self.builder.get_object("searchScrolledViewport")
searchGrid = self.builder.get_object("searchGrid")
searchGrid.set_focus_hadjustment(searchScrolledViewport.get_hadjustment())
searchGrid.set_focus_vadjustment(searchScrolledViewport.get_vadjustment())
multipathViewport = self.builder.get_object("multipathViewport")
multipathGrid = self.builder.get_object("multipathGrid")
multipathGrid.set_focus_hadjustment(multipathViewport.get_hadjustment())
multipathGrid.set_focus_vadjustment(multipathViewport.get_vadjustment())
otherViewport = self.builder.get_object("otherViewport")
otherGrid = self.builder.get_object("otherGrid")
otherGrid.set_focus_hadjustment(otherViewport.get_hadjustment())
otherGrid.set_focus_vadjustment(otherViewport.get_vadjustment())
zViewport = self.builder.get_object("zViewport")
zGrid = self.builder.get_object("zGrid")
zGrid.set_focus_hadjustment(zViewport.get_hadjustment())
zGrid.set_focus_vadjustment(zViewport.get_vadjustment())
def initialize(self):
NormalSpoke.initialize(self)
self._enableButton = self.builder.get_object("enableKdumpCheck")
KdumpSpoke.OS = getOS()
if KdumpSpoke.OS == "redhat":
self._reservationTypeLabel = self.builder.get_object("reservationTypeLabel")
self._autoButton = self.builder.get_object("autoButton")
self._manualButton = self.builder.get_object("manualButton")
self._toBeReservedLabel = self.builder.get_object("toBeReservedLabel")
self._toBeReservedSpin = self.builder.get_object("toBeReservedSpin")
self._totalMemLabel = self.builder.get_object("totalMemLabel")
self._totalMemMB = self.builder.get_object("totalMemMB")
self._usableMemLabel = self.builder.get_object("usableMemLabel")
self._usableMemMB = self.builder.get_object("usableMemMB")
# Set an initial value and adjustment on the spin button
lower, upper, step = getMemoryBounds()
adjustment = Gtk.Adjustment(lower, lower, upper, step, step, 0)
self._toBeReservedSpin.set_adjustment(adjustment)
self._toBeReservedSpin.set_value(lower)
def initialize(self):
NormalSpoke.initialize(self)
self._done = False
init_dep_injection()
facts = inj.require(inj.FACTS)
backend = managergui.Backend()
self.info = registergui.RegisterInfo()
self.register_widget = registergui.RegisterWidget(
backend, facts, reg_info=self.info, parent_window=self.main_window
)
self.register_box = self.builder.get_object("register_box")
self.button_box = self.builder.get_object("navigation_button_box")
self.proceed_button = self.builder.get_object("proceed_button")
self.back_button = self.builder.get_object("back_button")
self.register_box.pack_start(self.register_widget.register_widget, True, True, 0)
# Hook up the nav buttons in the gui
# TODO: add a 'start over'?
self.proceed_button.connect("clicked", self._on_register_button_clicked)
self.back_button.connect("clicked", self._on_back_button_clicked)
# initial-setup will likely
self.register_widget.connect("finished", self._on_finished)
self.register_widget.connect("register-finished", self._on_register_finished)
self.register_widget.connect("register-error", self._on_register_error)
self.register_widget.connect("register-message", self._on_register_message)
# update the 'next/register button on page change'
self.register_widget.connect("notify::register-button-label", self._on_register_button_label_change)
self.register_widget.connect("notify::screen-ready", self._on_register_screen_ready_change)
self.register_box.show_all()
self.register_widget.initialize()
def initialize(self):
log.debug("initializing the EULA spoke")
NormalSpoke.initialize(self)
self._have_eula = True
self._eula_buffer = self.builder.get_object("eulaBuffer")
self._agree_check_button = self.builder.get_object("agreeCheckButton")
self._agree_label = self._agree_check_button.get_child()
self._agree_text = self._agree_label.get_text()
log.debug("looking for the license file")
license_file = get_license_file_name()
if not license_file:
log.error("no license found")
self._have_eula = False
self._eula_buffer.set_text(
_("No license found. Please report this "
"at http://bugzilla.redhat.com"))
return
self._eula_buffer.set_text("")
itr = self._eula_buffer.get_iter_at_offset(0)
log.debug("opening the license file")
with open(license_file, "r") as fobj:
# insert the first line without prefixing with space
try:
first_line = next(fobj)
except StopIteration:
# nothing in the file
return
self._eula_buffer.insert(itr, first_line.strip())
# EULA file is preformatted for the console, we want to let Gtk
# format it (blank lines should be preserved)
for line in fobj:
stripped_line = line.strip()
if stripped_line:
self._eula_buffer.insert(itr, " " + stripped_line)
else:
self._eula_buffer.insert(itr, "\n\n")
def initialize(self):
NormalSpoke.initialize(self)
if flags.can_touch_runtime_system("hide runtime keyboard configuration "
"warning"):
self.builder.get_object("warningBox").hide()
# We want to store layouts' names but show layouts as
# 'language (description)'.
layoutColumn = self.builder.get_object("layoutColumn")
layoutRenderer = self.builder.get_object("layoutRenderer")
layoutColumn.set_cell_data_func(layoutRenderer, _show_layout,
self._xkl_wrapper)
self._store = self.builder.get_object("addedLayoutStore")
self._add_data_layouts()
self._switching_dialog = ConfigureSwitchingDialog(self.data)
self._switching_dialog.initialize()
self._layoutSwitchLabel = self.builder.get_object("layoutSwitchLabel")
if not flags.can_touch_runtime_system("test X layouts"):
# Disable area for testing layouts as we cannot make
# it work without modifying runtime system
widgets = [self.builder.get_object("testingLabel"),
self.builder.get_object("testingWindow"),
self.builder.get_object("layoutSwitchLabel")]
# Use testingLabel's text to explain why this part is not
# sensitive.
widgets[0].set_text(_("Testing layouts configuration not "
"available."))
for widget in widgets:
widget.set_sensitive(False)
def initialize(self):
NormalSpoke.initialize(self)
self._done = False
init_dep_injection()
facts = inj.require(inj.FACTS)
backend = managergui.Backend()
self.register_widget = registergui.RegisterWidget(backend, facts,
parent_window=self.main_window)
self.register_box = self.builder.get_object("register_box")
self.button_box = self.builder.get_object('navigation_button_box')
self.proceed_button = self.builder.get_object('proceed_button')
self.cancel_button = self.builder.get_object('cancel_button')
self.register_box.pack_start(self.register_widget.register_widget,
True, True, 0)
# Hook up the nav buttons in the gui
# TODO: add a 'start over'?
self.proceed_button.connect('clicked', self._on_register_button_clicked)
self.cancel_button.connect('clicked', self.cancel)
# initial-setup will likely
self.register_widget.connect('finished', self.finished)
self.register_widget.connect('register-finished', self.register_finished)
self.register_widget.connect('register-error', self._on_register_error)
# update the 'next/register button on page change'
self.register_widget.connect('notify::register-button-label',
self._on_register_button_label_change)
self.register_box.show_all()
self.register_widget.initialize()
