f73b3741f0
Apply result of "git diff anaconda-18.37.11-1..anaconda-20.25.16-1" and resolve conflicts.
810 lines
30 KiB
Python
810 lines
30 KiB
Python
# Base classes for the graphical user interface.
|
|
#
|
|
# Copyright (C) 2011-2012 Red Hat, Inc.
|
|
#
|
|
# This copyrighted material is made available to anyone wishing to use,
|
|
# modify, copy, or redistribute it subject to the terms and conditions of
|
|
# the GNU General Public License v.2, or (at your option) any later version.
|
|
# This program is distributed in the hope that it will be useful, but WITHOUT
|
|
# ANY WARRANTY expressed or implied, including the implied warranties of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
|
|
# Public License for more details. You should have received a copy of the
|
|
# GNU General Public License along with this program; if not, write to the
|
|
# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
# 02110-1301, USA. Any Red Hat trademarks that are incorporated in the
|
|
# source code or documentation are not subject to the GNU General Public
|
|
# License and may only be used or replicated with the express permission of
|
|
# Red Hat, Inc.
|
|
#
|
|
# Red Hat Author(s): Chris Lumens <clumens@redhat.com>
|
|
#
|
|
import inspect, os, sys, time, site
|
|
import meh.ui.gui
|
|
|
|
from gi.repository import Gdk, Gtk, AnacondaWidgets
|
|
|
|
from pyanaconda.i18n import _
|
|
from pyanaconda import product
|
|
|
|
from pyanaconda.ui import UserInterface, common
|
|
from pyanaconda.ui.gui.utils import enlightbox, gtk_action_wait, busyCursor, unbusyCursor
|
|
import os.path
|
|
|
|
import logging
|
|
log = logging.getLogger("anaconda")
|
|
|
|
__all__ = ["GraphicalUserInterface", "QuitDialog"]
|
|
|
|
_screenshotIndex = 0
|
|
|
|
ANACONDA_WINDOW_GROUP = Gtk.WindowGroup()
|
|
|
|
class GUICheck(object):
|
|
"""Handle an input validation check."""
|
|
|
|
# Use as a return value to indicate a passed check
|
|
CHECK_OK = None
|
|
|
|
def __init__(self, parent, editable, run_check, check_data, set_error):
|
|
"""Create a new input validation check.
|
|
|
|
:param parent: The parent GUIObject. When a check state changes,
|
|
the GUICheck will call set_error(check, check-state)
|
|
:type parent: GUIObject
|
|
|
|
:param editable: The input field being checked
|
|
:type editable: GtkEditable
|
|
|
|
:param run_check: The check function. The function is called as
|
|
check(editable, check_data). The return value is an
|
|
error state object or CHECK_OK if the check succeeds.
|
|
:type run_check: function
|
|
|
|
:param check_data: An optional parameter passed to check().
|
|
|
|
:param set_error: A function called when the state of this check
|
|
changes. The parameters are (GUICheck, run_check_return).
|
|
The return value is ignored.
|
|
:type set_error: function
|
|
"""
|
|
|
|
self._parent = parent
|
|
self._editable = editable
|
|
self._run_check = run_check
|
|
self._check_data = check_data
|
|
self._set_error = set_error
|
|
|
|
# Set to the Gtk handler ID in enable()
|
|
self._handler_id = None
|
|
|
|
# Initial check state
|
|
self._check_status = None
|
|
|
|
self.enable()
|
|
|
|
def enable(self):
|
|
"""Enable the check.
|
|
|
|
enable() does not check the current state of the input field. To
|
|
check the current state, run update_check_status() after enable().
|
|
"""
|
|
if not self._handler_id:
|
|
self._handler_id = self._editable.connect_after("changed", self.update_check_status)
|
|
|
|
def disable(self):
|
|
"""Disable the check. The check will no longer appear in failed_checks,
|
|
but disabling the check does not call set_error to update the
|
|
GUIObject's state.
|
|
"""
|
|
if self._handler_id:
|
|
self._editable.disconnect(self._handler_id)
|
|
self._handler_id = None
|
|
self._check_status = None
|
|
|
|
def update_check_status(self, editable=None, check_data=None):
|
|
"""Run an input validation check."""
|
|
|
|
# Allow check parameters to be overriden in parameters
|
|
if editable is None:
|
|
editable = self._editable
|
|
if check_data is None:
|
|
check_data = self._check_data
|
|
|
|
new_check_status = self._run_check(editable, check_data)
|
|
check_status_changed = (self._check_status != new_check_status)
|
|
self._check_status = new_check_status
|
|
|
|
if check_status_changed:
|
|
self._set_error(self, self._check_status)
|
|
|
|
@property
|
|
def check_status(self):
|
|
return self._check_status
|
|
|
|
@property
|
|
def editable(self):
|
|
return self._editable
|
|
|
|
@property
|
|
def check_data(self):
|
|
return self._check_data
|
|
|
|
class GUIObject(common.UIObject):
|
|
"""This is the base class from which all other GUI classes are derived. It
|
|
thus contains only attributes and methods that are common to everything
|
|
else. It should not be directly instantiated.
|
|
|
|
Class attributes:
|
|
|
|
builderObjects -- A list of UI object names that should be extracted from
|
|
uiFile and exposed for this class to use. If this list
|
|
is empty, all objects will be exposed.
|
|
|
|
Only the following kinds of objects need to be exported:
|
|
|
|
(1) Top-level objects (like GtkDialogs) that are directly
|
|
used in Python.
|
|
|
|
(2) Top-level objects that are not directly used in
|
|
Python, but are used by another object somewhere down
|
|
in the hierarchy. This includes things like a custom
|
|
GtkImage used by a button that is part of an exported
|
|
dialog, and a GtkListStore that is the model of a
|
|
Gtk*View that is part of an exported object.
|
|
mainWidgetName -- The name of the top-level widget this object
|
|
object implements. This will be the widget searched
|
|
for in uiFile by the window property.
|
|
uiFile -- The location of an XML file that describes the layout
|
|
of widgets shown by this object. UI files are
|
|
searched for relative to the same directory as this
|
|
object's module.
|
|
"""
|
|
builderObjects = []
|
|
mainWidgetName = None
|
|
uiFile = ""
|
|
|
|
screenshots_directory = "/tmp/anaconda-screenshots"
|
|
|
|
def __init__(self, data):
|
|
"""Create a new UIObject instance, including loading its uiFile and
|
|
all UI-related objects.
|
|
|
|
Instance attributes:
|
|
|
|
data -- An instance of a pykickstart Handler object. The Hub
|
|
never directly uses this instance. Instead, it passes
|
|
it down into Spokes when they are created and applied.
|
|
The Hub simply stores this instance so it doesn't need
|
|
to be passed by the user.
|
|
skipTo -- If this attribute is set to something other than None,
|
|
it must be the name of a class (as a string). Then,
|
|
the interface will skip to the first instance of that
|
|
class in the action list instead of going on to
|
|
whatever the next action is normally.
|
|
|
|
Note that actions may only skip ahead, never backwards.
|
|
Also, standalone spokes may not skip to an individual
|
|
spoke off a hub. They can only skip to the hub
|
|
itself.
|
|
"""
|
|
common.UIObject.__init__(self, data)
|
|
|
|
if self.__class__ is GUIObject:
|
|
raise TypeError("GUIObject is an abstract class")
|
|
|
|
self.skipTo = None
|
|
self.applyOnSkip = False
|
|
|
|
self.builder = Gtk.Builder()
|
|
self.builder.set_translation_domain("anaconda")
|
|
self._window = None
|
|
|
|
if self.builderObjects:
|
|
self.builder.add_objects_from_file(self._findUIFile(), self.builderObjects)
|
|
else:
|
|
self.builder.add_from_file(self._findUIFile())
|
|
|
|
ANACONDA_WINDOW_GROUP.add_window(self.window)
|
|
self.builder.connect_signals(self)
|
|
self.window.connect("key-release-event", self._handlePrntScreen)
|
|
|
|
self._check_list = []
|
|
|
|
def _findUIFile(self):
|
|
path = os.environ.get("UIPATH", "./:/tmp/updates/:/tmp/updates/ui/:/usr/share/anaconda/ui/")
|
|
dirs = path.split(":")
|
|
|
|
# append the directory where this UIObject is defined
|
|
dirs.append(os.path.dirname(inspect.getfile(self.__class__)))
|
|
|
|
for d in dirs:
|
|
testPath = os.path.join(d, self.uiFile)
|
|
if os.path.isfile(testPath) and os.access(testPath, os.R_OK):
|
|
return testPath
|
|
|
|
raise IOError("Could not load UI file '%s' for object '%s'" % (self.uiFile, self))
|
|
|
|
def _handlePrntScreen(self, window, event):
|
|
global _screenshotIndex
|
|
|
|
if event.keyval != Gdk.KEY_Print:
|
|
return
|
|
|
|
# Make sure the screenshot directory exists.
|
|
if not os.access(self.screenshots_directory, os.W_OK):
|
|
os.mkdir(self.screenshots_directory)
|
|
|
|
fn = os.path.join(self.screenshots_directory,
|
|
"screenshot-%04d.png" % _screenshotIndex)
|
|
|
|
win = window.get_window()
|
|
width = win.get_width()
|
|
height = win.get_height()
|
|
|
|
pixbuf = Gdk.pixbuf_get_from_window(win, 0, 0, width, height)
|
|
pixbuf.savev(fn, "png", [], [])
|
|
|
|
_screenshotIndex += 1
|
|
|
|
@property
|
|
def window(self):
|
|
"""Return the top-level object out of the GtkBuilder representation
|
|
previously loaded by the load method.
|
|
"""
|
|
|
|
# This will raise an AttributeError if the subclass failed to set a
|
|
# mainWidgetName attribute, which is exactly what I want.
|
|
if not self._window:
|
|
self._window = self.builder.get_object(self.mainWidgetName)
|
|
|
|
return self._window
|
|
|
|
def clear_info(self):
|
|
"""Clear any info bar from the bottom of the screen."""
|
|
self.window.clear_info()
|
|
|
|
def set_error(self, msg):
|
|
"""Display an info bar along the bottom of the screen with the provided
|
|
message. This method is used to display critical errors anaconda
|
|
may not be able to do anything about, but that the user may. A
|
|
suitable background color and icon will be displayed.
|
|
"""
|
|
self.window.set_error(msg)
|
|
|
|
def set_info(self, msg):
|
|
"""Display an info bar along the bottom of the screen with the provided
|
|
message. This method is used to display informational text -
|
|
non-critical warnings during partitioning, for instance. The user
|
|
should investigate these messages but doesn't have to. A suitable
|
|
background color and icon will be displayed.
|
|
"""
|
|
self.window.set_info(msg)
|
|
|
|
def set_warning(self, msg):
|
|
"""Display an info bar along the bottom of the screen with the provided
|
|
message. This method is used to display errors the user needs to
|
|
attend to in order to continue installation. This is the bulk of
|
|
messages. A suitable background color and icon will be displayed.
|
|
"""
|
|
self.window.set_warning(msg)
|
|
|
|
def add_check(self, editable, run_check, check_data=None, set_error=None):
|
|
"""Add an input validation check to this object.
|
|
|
|
This function creates new GUICheck object and adds it to this
|
|
GUIObject. The check is run any time the input field changes.
|
|
If the result of a check changes, the check object will call
|
|
the set_error function. By default, set_error will call
|
|
self.set_warning with the status of the first failed check.
|
|
|
|
:param editable: the input field to validate
|
|
:type editable: GtkEditable
|
|
|
|
:param run_check: a function called to validate the input field. The
|
|
parameters are (editable, check_data). The return
|
|
value is an object used by update_check, or
|
|
GUICheck.CHECK_OK if the check passes.
|
|
:type run_check: function
|
|
|
|
:param check_data: additional data to pass to the check function
|
|
|
|
:param set_error: a function called when a check changes state. The
|
|
parameters are (GUICheck, run_check_return). The
|
|
return value is ignored.
|
|
:type set_error: function
|
|
|
|
:returns: A check object
|
|
:rtype: GUICheck
|
|
"""
|
|
|
|
if not set_error:
|
|
set_error = self.set_check_error
|
|
|
|
checkRef = GUICheck(self, editable, run_check, check_data, set_error)
|
|
self._check_list.append(checkRef)
|
|
return checkRef
|
|
|
|
def add_re_check(self, editable, regex, message, set_error=None):
|
|
"""Add a check using a regular expresion.
|
|
|
|
:param editable: the input field to validate
|
|
:type editable: GtkEditable
|
|
|
|
:param regex: the regular expression to use to check the input
|
|
:type regex: re.RegexObject
|
|
|
|
:param message: The message to set if the regex does not match
|
|
:type message: str
|
|
|
|
:param set_error: a function called when a check changes state. The
|
|
parameters are (GUICheck, run_check_return). The
|
|
return value is ignored.
|
|
:type set_error: function
|
|
|
|
:returns: A check object
|
|
:rtype: GUICheck
|
|
"""
|
|
if not set_error:
|
|
set_error = self.set_check_error
|
|
return self.add_check(editable=editable, run_check=check_re,
|
|
check_data={'regex': regex, 'message': message}, set_error=set_error)
|
|
|
|
def update_check(self, check, check_status):
|
|
"""This method is called when the state of a check in the check list changes.
|
|
|
|
:param check: The check object that changed
|
|
:type check: GUICheck
|
|
|
|
:param check_status: The new status of the check
|
|
"""
|
|
raise NotImplementedError()
|
|
|
|
def set_check_error(self, check, check_return):
|
|
"""Update the warning with the input validation check error."""
|
|
# Grab the first failed check
|
|
failed_check = next(self.failed_checks, None)
|
|
|
|
self.clear_info()
|
|
if failed_check:
|
|
self.set_warning(failed_check.check_status)
|
|
self.window.show_all()
|
|
|
|
@property
|
|
def failed_checks(self):
|
|
"""A generator of all failed input checks"""
|
|
return (c for c in self._check_list if c.check_status)
|
|
|
|
@property
|
|
def checks(self):
|
|
"""An iterator over all input checks"""
|
|
return self._check_list.__iter__()
|
|
|
|
class GUIDialog(GUIObject):
|
|
"""This is an abstract for creating dialog windows. It implements the
|
|
update_check interface to display an error message when an input
|
|
validation fails.
|
|
|
|
GUIDialog does not define where errors are displayed, so classes
|
|
that derive from GUIDialog must define error labels and include them
|
|
as the check_data parameter to add_check. More than one check can use
|
|
the same label: the message from the first failed check will update the
|
|
label.
|
|
"""
|
|
|
|
def __init__(self, data):
|
|
if self.__class__ is GUIDialog:
|
|
raise TypeError("GUIDialog is an abstract class")
|
|
|
|
GUIObject.__init__(self, data)
|
|
|
|
def add_check_with_error_label(self, editable, error_label, run_check,
|
|
check_data=None, set_error=None):
|
|
"""Add an input validation check to this dialog. The error_label will
|
|
be added to the check_data for the validation check and will be
|
|
used to display the error message if the check fails.
|
|
|
|
:param editable: the input field to validate
|
|
:type editable: GtkEditable
|
|
|
|
:param error_label: the label in which to display the error data
|
|
:type error_label: GtkLabel
|
|
|
|
:param run_check: a function called to validate the input field. The
|
|
parameters are (editable, check_data). The return
|
|
value is an object used by update_check, or
|
|
GUICheck.CHECK_OK if the check passes.
|
|
:type run_check: function
|
|
|
|
:param check_data: additional data to pass to the check function
|
|
|
|
:param set_error: a function called when a check changes state. The
|
|
parameters are (GUICheck, run_check_return). The
|
|
return value is ignored.
|
|
:type set_error: function
|
|
|
|
:returns: A check object
|
|
:rtype: GUICheck
|
|
"""
|
|
if not set_error:
|
|
set_error = self.set_check_error
|
|
|
|
return self.add_check(editable=editable, run_check=run_check,
|
|
check_data={'error_label': error_label, 'message': check_data},
|
|
set_error=set_error)
|
|
|
|
def add_re_check_with_error_label(self, editable, error_label, regex, message, set_error=None):
|
|
"""Add a check using a regular expression."""
|
|
# Use the GUIObject function so we can create the check_data dictionary here
|
|
if not set_error:
|
|
set_error = self.set_check_error
|
|
|
|
return self.add_check(editable=editable, run_check=check_re,
|
|
check_data={'error_label': error_label, 'message': message, 'regex': regex},
|
|
set_error=set_error)
|
|
|
|
def set_check_error(self, check, check_return):
|
|
"""Update all input check failure messages.
|
|
|
|
If multiple checks use the same GtkLabel, only the first one will
|
|
be used.
|
|
"""
|
|
|
|
# If the signaling check passed, clear its error label
|
|
if not check_return:
|
|
if 'error_label' in check.check_data:
|
|
check.check_data['error_label'].set_text('')
|
|
|
|
# Keep track of which labels have errors set. If we see an error for
|
|
# a label that's already been set, skip it.
|
|
labels_seen = []
|
|
for failed_check in self.failed_checks:
|
|
if not 'error_label' in failed_check.check_data:
|
|
continue
|
|
|
|
label = failed_check.check_data['error_label']
|
|
if label not in labels_seen:
|
|
labels_seen.append(label)
|
|
label.set_text(failed_check.check_status)
|
|
|
|
class QuitDialog(GUIObject):
|
|
builderObjects = ["quitDialog"]
|
|
mainWidgetName = "quitDialog"
|
|
uiFile = "main.glade"
|
|
|
|
MESSAGE = ""
|
|
|
|
def run(self):
|
|
if self.MESSAGE:
|
|
self.builder.get_object("quit_message").set_label(_(self.MESSAGE))
|
|
rc = self.window.run()
|
|
return rc
|
|
|
|
class GraphicalUserInterface(UserInterface):
|
|
"""This is the standard GTK+ interface we try to steer everything to using.
|
|
It is suitable for use both directly and via VNC.
|
|
"""
|
|
def __init__(self, storage, payload, instclass,
|
|
distributionText = product.distributionText, isFinal = product.isFinal,
|
|
quitDialog = QuitDialog):
|
|
|
|
UserInterface.__init__(self, storage, payload, instclass)
|
|
|
|
self._actions = []
|
|
self._currentAction = None
|
|
self._ui = None
|
|
|
|
self.data = None
|
|
|
|
self._distributionText = distributionText
|
|
self._isFinal = isFinal
|
|
self._quitDialog = quitDialog
|
|
self._mehInterface = GraphicalExceptionHandlingIface(
|
|
self.lightbox_over_current_action)
|
|
|
|
basemask = "pyanaconda.ui.gui"
|
|
basepath = os.path.dirname(__file__)
|
|
updatepath = "/tmp/updates/pyanaconda/ui/gui"
|
|
sitepackages = [os.path.join(dir, "pyanaconda", "ui", "gui")
|
|
for dir in site.getsitepackages()]
|
|
pathlist = set([updatepath, basepath] + sitepackages)
|
|
|
|
paths = UserInterface.paths + {
|
|
"categories": [(basemask + ".categories.%s",
|
|
os.path.join(path, "categories"))
|
|
for path in pathlist],
|
|
"spokes": [(basemask + ".spokes.%s",
|
|
os.path.join(path, "spokes"))
|
|
for path in pathlist],
|
|
"hubs": [(basemask + ".hubs.%s",
|
|
os.path.join(path, "hubs"))
|
|
for path in pathlist]
|
|
}
|
|
|
|
@property
|
|
def tty_num(self):
|
|
return 7
|
|
|
|
@property
|
|
def meh_interface(self):
|
|
return self._mehInterface
|
|
|
|
def _list_hubs(self):
|
|
"""Return a list of Hub classes to be imported to this interface"""
|
|
from pyanaconda.ui.gui.hubs.summary import SummaryHub
|
|
from pyanaconda.ui.gui.hubs.progress import ProgressHub
|
|
return [SummaryHub, ProgressHub]
|
|
|
|
def _is_standalone(self, obj):
|
|
"""Is the spoke passed as obj standalone?"""
|
|
from pyanaconda.ui.gui.spokes import StandaloneSpoke
|
|
return isinstance(obj, StandaloneSpoke)
|
|
|
|
def setup(self, data):
|
|
busyCursor()
|
|
|
|
self._actions = self.getActionClasses(self._list_hubs())
|
|
self.data = data
|
|
|
|
def getActionClasses(self, hubs):
|
|
"""Grab all relevant standalone spokes, add them to the passed
|
|
list of hubs and order the list according to the
|
|
relationships between hubs and standalones."""
|
|
from pyanaconda.ui.gui.spokes import StandaloneSpoke
|
|
|
|
# First, grab a list of all the standalone spokes.
|
|
standalones = self._collectActionClasses(self.paths["spokes"], StandaloneSpoke)
|
|
|
|
# Second, order them according to their relationship
|
|
return self._orderActionClasses(standalones, hubs)
|
|
|
|
def lightbox_over_current_action(self, window):
|
|
"""
|
|
Creates lightbox over current action for the given window. Or
|
|
DOES NOTHING IF THERE ARE NO ACTIONS.
|
|
|
|
"""
|
|
|
|
# if there are no actions (not populated yet), we can do nothing
|
|
if len(self._actions) > 0 and self._currentAction:
|
|
lightbox = AnacondaWidgets.Lightbox(parent_window=self._currentAction.window)
|
|
ANACONDA_WINDOW_GROUP.add_window(lightbox)
|
|
window.main_window.set_transient_for(lightbox)
|
|
|
|
def _instantiateAction(self, actionClass):
|
|
from pyanaconda.ui.gui.spokes import StandaloneSpoke
|
|
|
|
# Instantiate an action on-demand, passing the arguments defining our
|
|
# spoke API and setting up continue/quit signal handlers.
|
|
obj = actionClass(self.data, self.storage, self.payload, self.instclass)
|
|
|
|
# set spoke search paths in Hubs
|
|
if hasattr(obj, "set_path"):
|
|
obj.set_path("spokes", self.paths["spokes"])
|
|
obj.set_path("categories", self.paths["categories"])
|
|
|
|
# If we are doing a kickstart install, some standalone spokes
|
|
# could already be filled out. In that case, we do not want
|
|
# to display them.
|
|
if self._is_standalone(obj) and obj.completed:
|
|
del(obj)
|
|
return None
|
|
|
|
obj.register_event_cb("continue", self._on_continue_clicked)
|
|
obj.register_event_cb("quit", self._on_quit_clicked)
|
|
|
|
return obj
|
|
|
|
def run(self):
|
|
(success, args) = Gtk.init_check(None)
|
|
if not success:
|
|
raise RuntimeError("Failed to initialize Gtk")
|
|
|
|
if Gtk.main_level() > 0:
|
|
# Gtk main loop running. That means python-meh caught exception
|
|
# and runs its main loop. Do not crash Gtk by running another one
|
|
# from a different thread and just wait until python-meh is
|
|
# finished, then quit.
|
|
unbusyCursor()
|
|
log.error("Unhandled exception caught, waiting for python-meh to "\
|
|
"exit")
|
|
while Gtk.main_level() > 0:
|
|
time.sleep(2)
|
|
|
|
sys.exit(0)
|
|
|
|
while not self._currentAction:
|
|
self._currentAction = self._instantiateAction(self._actions[0])
|
|
if not self._currentAction:
|
|
self._actions.pop(0)
|
|
|
|
if not self._actions:
|
|
return
|
|
|
|
self._currentAction.initialize()
|
|
self._currentAction.refresh()
|
|
|
|
self._currentAction.window.set_beta(not self._isFinal)
|
|
self._currentAction.window.set_property("distribution", self._distributionText().upper())
|
|
|
|
# Set some program-wide settings.
|
|
settings = Gtk.Settings.get_default()
|
|
settings.set_property("gtk-font-name", "Cantarell")
|
|
settings.set_property("gtk-icon-theme-name", "gnome")
|
|
|
|
# Apply the application stylesheet
|
|
provider = Gtk.CssProvider()
|
|
provider.load_from_path("/usr/share/anaconda/anaconda-gtk.css")
|
|
Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(), provider,
|
|
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
|
|
|
|
self._currentAction.window.show_all()
|
|
|
|
# Do this at the last possible minute.
|
|
unbusyCursor()
|
|
|
|
Gtk.main()
|
|
|
|
###
|
|
### MESSAGE HANDLING METHODS
|
|
###
|
|
@gtk_action_wait
|
|
def showError(self, message):
|
|
dlg = Gtk.MessageDialog(flags=Gtk.DialogFlags.MODAL,
|
|
message_type=Gtk.MessageType.ERROR,
|
|
buttons=Gtk.ButtonsType.NONE,
|
|
message_format=message)
|
|
dlg.set_decorated(False)
|
|
dlg.add_button(_("_Exit Installer"), 0)
|
|
|
|
with enlightbox(self._currentAction.window, dlg):
|
|
dlg.run()
|
|
dlg.destroy()
|
|
|
|
@gtk_action_wait
|
|
def showDetailedError(self, message, details):
|
|
from pyanaconda.ui.gui.spokes.lib.detailederror import DetailedErrorDialog
|
|
dlg = DetailedErrorDialog(None, buttons=[_("_Quit")],
|
|
label=message)
|
|
|
|
with enlightbox(self._currentAction.window, dlg.window):
|
|
dlg.refresh(details)
|
|
rc = dlg.run()
|
|
dlg.window.destroy()
|
|
|
|
@gtk_action_wait
|
|
def showYesNoQuestion(self, message):
|
|
dlg = Gtk.MessageDialog(flags=Gtk.DialogFlags.MODAL,
|
|
message_type=Gtk.MessageType.QUESTION,
|
|
buttons=Gtk.ButtonsType.NONE,
|
|
message_format=message)
|
|
dlg.set_decorated(False)
|
|
dlg.add_buttons(_("_No"), 0, _("_Yes"), 1)
|
|
dlg.set_default_response(1)
|
|
|
|
with enlightbox(self._currentAction.window, dlg):
|
|
rc = dlg.run()
|
|
dlg.destroy()
|
|
|
|
return bool(rc)
|
|
|
|
###
|
|
### SIGNAL HANDLING METHODS
|
|
###
|
|
def _on_continue_clicked(self):
|
|
# If we're on the last screen, clicking Continue quits.
|
|
if len(self._actions) == 1:
|
|
Gtk.main_quit()
|
|
return
|
|
|
|
nextAction = None
|
|
ndx = 0
|
|
|
|
# If the current action wants us to jump to an arbitrary point ahead,
|
|
# look for where that is now.
|
|
if self._currentAction.skipTo:
|
|
found = False
|
|
for ndx in range(1, len(self._actions)):
|
|
if self._actions[ndx].__class__.__name__ == self._currentAction.skipTo:
|
|
found = True
|
|
break
|
|
|
|
# If we found the point in question, compose a new actions list
|
|
# consisting of the current action, the one to jump to, and all
|
|
# the ones after. That means the rest of the code below doesn't
|
|
# have to change.
|
|
if found:
|
|
self._actions = [self._actions[0]] + self._actions[ndx:]
|
|
|
|
# _instantiateAction returns None for actions that should not be
|
|
# displayed (because they're already completed, for instance) so skip
|
|
# them here.
|
|
while not nextAction:
|
|
nextAction = self._instantiateAction(self._actions[1])
|
|
if not nextAction:
|
|
self._actions.pop(1)
|
|
|
|
if not self._actions:
|
|
sys.exit(0)
|
|
return
|
|
|
|
nextAction.initialize()
|
|
nextAction.window.set_beta(self._currentAction.window.get_beta())
|
|
nextAction.window.set_property("distribution", self._distributionText().upper())
|
|
|
|
if not nextAction.showable:
|
|
self._currentAction.window.hide()
|
|
self._actions.pop(0)
|
|
self._on_continue_clicked()
|
|
return
|
|
|
|
nextAction.refresh()
|
|
|
|
# Do this last. Setting up curAction could take a while, and we want
|
|
# to leave something on the screen while we work.
|
|
nextAction.window.show_all()
|
|
self._currentAction.window.hide()
|
|
self._currentAction = nextAction
|
|
self._actions.pop(0)
|
|
|
|
def _on_quit_clicked(self):
|
|
dialog = self._quitDialog(None)
|
|
with enlightbox(self._currentAction.window, dialog.window):
|
|
rc = dialog.run()
|
|
dialog.window.destroy()
|
|
|
|
if rc == 1:
|
|
sys.exit(0)
|
|
|
|
class GraphicalExceptionHandlingIface(meh.ui.gui.GraphicalIntf):
|
|
"""
|
|
Class inheriting from python-meh's GraphicalIntf and overriding methods
|
|
that need some modification in Anaconda.
|
|
|
|
"""
|
|
|
|
def __init__(self, lightbox_func):
|
|
"""
|
|
:param lightbox_func: a function that creates lightbox for a given
|
|
window
|
|
:type lightbox_func: GtkWindow -> None
|
|
|
|
"""
|
|
meh.ui.gui.GraphicalIntf.__init__(self)
|
|
|
|
self._lightbox_func = lightbox_func
|
|
|
|
def mainExceptionWindow(self, text, exn_file, *args, **kwargs):
|
|
meh_intf = meh.ui.gui.GraphicalIntf()
|
|
exc_window = meh_intf.mainExceptionWindow(text, exn_file)
|
|
exc_window.main_window.set_decorated(False)
|
|
|
|
self._lightbox_func(exc_window)
|
|
|
|
# without a new GtkWindowGroup, python-meh's window is insensitive if it
|
|
# appears above a spoke (Gtk.Window running its own Gtk.main loop)
|
|
window_group = Gtk.WindowGroup()
|
|
window_group.add_window(exc_window.main_window)
|
|
|
|
# the busy cursor may be set
|
|
unbusyCursor()
|
|
|
|
return exc_window
|
|
|
|
def check_re(editable, data):
|
|
"""Perform an input validation check against a regular expression.
|
|
|
|
:param editable: The input field being checked
|
|
:type editable: GtkEditable
|
|
|
|
:param data: The check_data set in add_check. This data must
|
|
be a dictionary that includes the keys
|
|
'regex' and 'message'.
|
|
:type data: dict
|
|
|
|
:returns: error_data if the check fails, otherwise GUICheck.CHECK_OK.
|
|
"""
|
|
if data['regex'].match(editable.get_text()):
|
|
return GUICheck.CHECK_OK
|
|
else:
|
|
return data['message']
|