Python NormalSpoke.__init__方法代码示例

# 需要导入模块: from pyanaconda.ui.gui.spokes import NormalSpoke [as 别名]
# 或者: from pyanaconda.ui.gui.spokes.NormalSpoke import __init__ [as 别名]
    def __init__(self, data, storage, payload, instclass):
        """
        :see: pyanaconda.ui.common.Spoke.__init__
        :param data: data object passed to every spoke to load/store data
                     from/to it
        :type data: pykickstart.base.BaseHandler
        :param storage: object storing storage-related information
                        (disks, partitioning, bootloader, etc.)
        :type storage: blivet.Blivet
        :param payload: object storing packaging-related information
        :type payload: pyanaconda.packaging.Payload
        :param instclass: distribution-specific information
        :type instclass: pyanaconda.installclass.BaseInstallClass

        """

        NormalSpoke.__init__(self, data, storage, payload, instclass)
        r = RocksEnv.RocksEnv()
        self.clientInstall = r.clientInstall

        self.defaultCentral ="beta7.rocksclusters.org"
        if r.central is not None:
            self.defaultCentral = r.central
        self.defaultUrl ="http://%s/install/rolls" % self.defaultCentral

        self.defaultCDPath = "/run/install/repo"

        self.selectAll = True
        self.rollSource = NETWORK
        self.version = '7.0'
        self.requireDB = True

        self.requiredRolls = ('core','base','kernel')

# 需要导入模块: from pyanaconda.ui.gui.spokes import NormalSpoke [as 别名]
# 或者: from pyanaconda.ui.gui.spokes.NormalSpoke import __init__ [as 别名]
    def __init__(self, data, storage, payload, instclass):
        """
        :see: pyanaconda.ui.common.Spoke.__init__
        :param data: data object passed to every spoke to load/store data
                     from/to it
        :type data: pykickstart.base.BaseHandler
        :param storage: object storing storage-related information
                        (disks, partitioning, bootloader, etc.)
        :type storage: blivet.Blivet
        :param payload: object storing packaging-related information
        :type payload: pyanaconda.packaging.Payload
        :param instclass: distribution-specific information
        :type instclass: pyanaconda.installclass.BaseInstallClass

        """

        NormalSpoke.__init__(self, data, storage, payload, instclass)

        self.logger = logging.getLogger("anaconda")

        self.main_box = self.builder.get_object("mainBox")
        self.thread_dialog = None

        self.qubes_user = None
        self.qubes_gid = None
        self.default_template = 'fedora-26'

        self.set_stage("Start-up")
        self.done = False

        self.__init_qubes_choices()

# 需要导入模块: from pyanaconda.ui.gui.spokes import NormalSpoke [as 别名]
# 或者: from pyanaconda.ui.gui.spokes.NormalSpoke import __init__ [as 别名]
    def __init__(self, *args, **kwargs):
        NormalSpoke.__init__(self, *args, **kwargs)
        self._errorMsgs = None
        self._tx_id = None
        self._selectFlag = False

        self.selectedGroups = []
        self.excludedGroups = []
        self.environment = None

        self._environmentListBox = self.builder.get_object("environmentListBox")
        self._addonListBox = self.builder.get_object("addonListBox")

        # Connect viewport scrolling with listbox focus events
        environmentViewport = self.builder.get_object("environmentViewport")
        addonViewport = self.builder.get_object("addonViewport")
        self._environmentListBox.set_focus_vadjustment(environmentViewport.get_vadjustment())
        self._addonListBox.set_focus_vadjustment(addonViewport.get_vadjustment())

        # Used to store how the user has interacted with add-ons for the default add-on
        # selection logic. The dictionary keys are group IDs, and the values are selection
        # state constants. See refreshAddons for how the values are used.
        self._addonStates = {}

        # Used for detecting whether anything's changed in the spoke.
        self._origAddons = []
        self._origEnvironment = None

        # Register event listeners to update our status on payload events
        payloadMgr.addListener(payloadMgr.STATE_PACKAGE_MD, self._downloading_package_md)
        payloadMgr.addListener(payloadMgr.STATE_GROUP_MD, self._downloading_group_md)
        payloadMgr.addListener(payloadMgr.STATE_FINISHED, self._payload_finished)
        payloadMgr.addListener(payloadMgr.STATE_ERROR, self._payload_error)

# 需要导入模块: from pyanaconda.ui.gui.spokes import NormalSpoke [as 别名]
# 或者: from pyanaconda.ui.gui.spokes.NormalSpoke import __init__ [as 别名]
 def __init__(self, *args, **kwargs):
     NormalSpoke.__init__(self, *args, **kwargs)
     self._currentIsoFile = None
     self._ready = False
     self._error = False
     self._proxyChange = False
     self._cdrom = None

# 需要导入模块: from pyanaconda.ui.gui.spokes import NormalSpoke [as 别名]
# 或者: from pyanaconda.ui.gui.spokes.NormalSpoke import __init__ [as 别名]
    def __init__(self, *args, **kwargs):
        NormalSpoke.__init__(self, *args, **kwargs)
        self.applyOnSkip = True

        self._ready = False
        self.selected_disks = self.data.ignoredisk.onlyuse[:]

        # This list contains all possible disks that can be included in the install.
        # All types of advanced disks should be set up for us ahead of time, so
        # there should be no need to modify this list.
        self.disks = []

        if not flags.automatedInstall:
            # default to using autopart for interactive installs
            self.data.autopart.autopart = True

        self.autopart = self.data.autopart.autopart
        self.autoPartType = None
        self.clearPartType = CLEARPART_TYPE_NONE

        self._previous_autopart = False

        self._last_clicked_overview = None
        self._cur_clicked_overview = None
        # nkwin7 add begin
        self.hubClass = None
        self.spokeClass = None

# 需要导入模块: from pyanaconda.ui.gui.spokes import NormalSpoke [as 别名]
# 或者: from pyanaconda.ui.gui.spokes.NormalSpoke import __init__ [as 别名]
    def __init__(self, *args):
        NormalSpoke.__init__(self, *args)
        self.applyOnSkip = True

        self.ancestors = []
        self.disks = []
        self.selected_disks = []

# 需要导入模块: from pyanaconda.ui.gui.spokes import NormalSpoke [as 别名]
# 或者: from pyanaconda.ui.gui.spokes.NormalSpoke import __init__ [as 别名]
    def __init__(self, *args, **kwargs):
        StorageChecker.__init__(self)
        NormalSpoke.__init__(self, *args, **kwargs)
        self.applyOnSkip = True

        self._ready = False
        self.autoPartType = None
        self.encrypted = False
        self.passphrase = ""
        self.selected_disks = self.data.ignoredisk.onlyuse[:]

        # This list contains all possible disks that can be included in the install.
        # All types of advanced disks should be set up for us ahead of time, so
        # there should be no need to modify this list.
        self.disks = []

        if not flags.automatedInstall:
            # default to using autopart for interactive installs
            self.data.autopart.autopart = True

        self.autopart = self.data.autopart.autopart
        self.autoPartType = None
        self.clearPartType = CLEARPART_TYPE_NONE

        if self.data.zerombr.zerombr and arch.isS390():
            # run dasdfmt on any unformatted DASDs automatically
            threadMgr.add(AnacondaThread(name=constants.THREAD_DASDFMT,
                            target=self.run_dasdfmt))

        self._previous_autopart = False

        self._last_clicked_overview = None
        self._cur_clicked_overview = None

        self._grabObjects()

# 需要导入模块: from pyanaconda.ui.gui.spokes import NormalSpoke [as 别名]
# 或者: from pyanaconda.ui.gui.spokes.NormalSpoke import __init__ [as 别名]
    def __init__(self, data, storage, payload):
        """
        :see: pyanaconda.ui.common.Spoke.__init__
        :param data: data object passed to every spoke to load/store data
                     from/to it
        :type data: pykickstart.base.BaseHandler
        :param storage: object storing storage-related information
                        (disks, partitioning, bootloader, etc.)
        :type storage: blivet.Blivet
        :param payload: object storing payload-related information
        :type payload: pyanaconda.payload.Payload
        """

        self._error = None
        self._back_already_clicked = False
        self._storage_playground = None
        self.label_actions = None
        self.button_reset = None
        self.button_undo = None

        self._bootloader_observer = STORAGE.get_observer(BOOTLOADER)
        self._bootloader_observer.connect()

        StorageCheckHandler.__init__(self)
        NormalSpoke.__init__(self, data, storage, payload)

# 需要导入模块: from pyanaconda.ui.gui.spokes import NormalSpoke [as 别名]
# 或者: from pyanaconda.ui.gui.spokes.NormalSpoke import __init__ [as 别名]
    def __init__(self, data, storage, payload, instclass):
        """
        :see: pyanaconda.ui.common.Spoke.__init__
        :param data: data object passed to every spoke to load/store data
                     from/to it
        :type data: pykickstart.base.BaseHandler
        :param storage: object storing storage-related information
                        (disks, partitioning, bootloader, etc.)
        :type storage: blivet.Blivet
        :param payload: object storing payload-related information
        :type payload: pyanaconda.payload.Payload
        :param instclass: distribution-specific information
        :type instclass: pyanaconda.installclass.BaseInstallClass

        """

        self._error = None
        self._back_already_clicked = False
        self._storage_playground = None
        self.label_actions = None
        self.button_reset = None
        self.button_undo = None

        StorageCheckHandler.__init__(self)
        NormalSpoke.__init__(self, data, storage, payload, instclass)

# 需要导入模块: from pyanaconda.ui.gui.spokes import NormalSpoke [as 别名]
# 或者: from pyanaconda.ui.gui.spokes.NormalSpoke import __init__ [as 别名]
    def __init__(self, *args, **kwargs):
        NormalSpoke.__init__(self, *args, **kwargs)
        LangLocaleHandler.__init__(self, self.payload)
        self._selected_locales = set()

        self._l12_module = LOCALIZATION.get_observer()
        self._l12_module.connect()

# 需要导入模块: from pyanaconda.ui.gui.spokes import NormalSpoke [as 别名]
# 或者: from pyanaconda.ui.gui.spokes.NormalSpoke import __init__ [as 别名]
    def __init__(self, *args, **kwargs):
        NormalSpoke.__init__(self, *args, **kwargs)
        self._errorMsgs = None
        self._tx_id = None
        self._selectFlag = False

        self.selectedGroups = []
        self.excludedGroups = []
        self.environment = None

        self._environmentListBox = self.builder.get_object("environmentListBox")
        self._addonListBox = self.builder.get_object("addonListBox")

        # Used to determine which add-ons to display for each environment.
        # The dictionary keys are environment IDs. The dictionary values are two-tuples
        # consisting of lists of add-on group IDs. The first list is the add-ons specific
        # to the environment, and the second list is the other add-ons possible for the
        # environment.
        self._environmentAddons = {}

        # Used to store how the user has interacted with add-ons for the default add-on
        # selection logic. The dictionary keys are group IDs, and the values are selection
        # state constants. See refreshAddons for how the values are used.
        self._addonStates = {}

        # Used for detecting whether anything's changed in the spoke.
        self._origAddons = []
        self._origEnvironment = None

# 需要导入模块: from pyanaconda.ui.gui.spokes import NormalSpoke [as 别名]
# 或者: from pyanaconda.ui.gui.spokes.NormalSpoke import __init__ [as 别名]
    def __init__(self, *args):
        NormalSpoke.__init__(self, *args)

        # taking values from the kickstart file?
        self._kickstarted = flags.flags.automatedInstall

        self._update_datetime_timer_id = None
        self._start_updating_timer_id = None

# 需要导入模块: from pyanaconda.ui.gui.spokes import NormalSpoke [as 别名]
# 或者: from pyanaconda.ui.gui.spokes.NormalSpoke import __init__ [as 别名]
    def __init__(self, *args):
        NormalSpoke.__init__(self, *args)
        GUISpokeInputCheckHandler.__init__(self)

        self._users_module = USERS.get_observer()
        self._users_module.connect()

        self._services_module = SERVICES.get_observer()
        self._services_module.connect()

# 需要导入模块: from pyanaconda.ui.gui.spokes import NormalSpoke [as 别名]
# 或者: from pyanaconda.ui.gui.spokes.NormalSpoke import __init__ [as 别名]
    def __init__(self, *args):
        NormalSpoke.__init__(self, *args)
        self._remove_last_attempt = False
        self._confirmed = False
        self._xkl_wrapper = keyboard.XklWrapper.get_instance()

        self._upButton = self.builder.get_object("upButton")
        self._downButton = self.builder.get_object("downButton")
        self._removeButton = self.builder.get_object("removeLayoutButton")
        self._previewButton = self.builder.get_object("previewButton")

# 需要导入模块: from pyanaconda.ui.gui.spokes import NormalSpoke [as 别名]
# 或者: from pyanaconda.ui.gui.spokes.NormalSpoke import __init__ [as 别名]
    def __init__(self, *args):
        NormalSpoke.__init__(self, *args)

        # taking values from the kickstart file?
        self._kickstarted = flags.flags.automatedInstall

        self._update_datetime_timer = None
        self._start_updating_timer = None
        self._shown = False
        self._tz = None

        self._timezone_module = TIMEZONE.get_observer()
        self._timezone_module.connect()
        self._network_module = NETWORK.get_observer()
        self._network_module.connect()