Spaces:
Runtime error
Runtime error
| # Copyright (C) 2005, 2006 Martin von Löwis | |
| # Licensed to PSF under a Contributor Agreement. | |
| # The bdist_wininst command proper | |
| # based on bdist_wininst | |
| """ | |
| Implements the bdist_msi command. | |
| """ | |
| import os | |
| import sys | |
| import warnings | |
| from distutils.core import Command | |
| from distutils.dir_util import remove_tree | |
| from distutils.sysconfig import get_python_version | |
| from distutils.version import StrictVersion | |
| from distutils.errors import DistutilsOptionError | |
| from distutils.util import get_platform | |
| from distutils import log | |
| import msilib | |
| from msilib import schema, sequence, text | |
| from msilib import Directory, Feature, Dialog, add_data | |
| class PyDialog(Dialog): | |
| """Dialog class with a fixed layout: controls at the top, then a ruler, | |
| then a list of buttons: back, next, cancel. Optionally a bitmap at the | |
| left.""" | |
| def __init__(self, *args, **kw): | |
| """Dialog(database, name, x, y, w, h, attributes, title, first, | |
| default, cancel, bitmap=true)""" | |
| Dialog.__init__(self, *args) | |
| ruler = self.h - 36 | |
| bmwidth = 152*ruler/328 | |
| #if kw.get("bitmap", True): | |
| # self.bitmap("Bitmap", 0, 0, bmwidth, ruler, "PythonWin") | |
| self.line("BottomLine", 0, ruler, self.w, 0) | |
| def title(self, title): | |
| "Set the title text of the dialog at the top." | |
| # name, x, y, w, h, flags=Visible|Enabled|Transparent|NoPrefix, | |
| # text, in VerdanaBold10 | |
| self.text("Title", 15, 10, 320, 60, 0x30003, | |
| r"{\VerdanaBold10}%s" % title) | |
| def back(self, title, next, name = "Back", active = 1): | |
| """Add a back button with a given title, the tab-next button, | |
| its name in the Control table, possibly initially disabled. | |
| Return the button, so that events can be associated""" | |
| if active: | |
| flags = 3 # Visible|Enabled | |
| else: | |
| flags = 1 # Visible | |
| return self.pushbutton(name, 180, self.h-27 , 56, 17, flags, title, next) | |
| def cancel(self, title, next, name = "Cancel", active = 1): | |
| """Add a cancel button with a given title, the tab-next button, | |
| its name in the Control table, possibly initially disabled. | |
| Return the button, so that events can be associated""" | |
| if active: | |
| flags = 3 # Visible|Enabled | |
| else: | |
| flags = 1 # Visible | |
| return self.pushbutton(name, 304, self.h-27, 56, 17, flags, title, next) | |
| def next(self, title, next, name = "Next", active = 1): | |
| """Add a Next button with a given title, the tab-next button, | |
| its name in the Control table, possibly initially disabled. | |
| Return the button, so that events can be associated""" | |
| if active: | |
| flags = 3 # Visible|Enabled | |
| else: | |
| flags = 1 # Visible | |
| return self.pushbutton(name, 236, self.h-27, 56, 17, flags, title, next) | |
| def xbutton(self, name, title, next, xpos): | |
| """Add a button with a given title, the tab-next button, | |
| its name in the Control table, giving its x position; the | |
| y-position is aligned with the other buttons. | |
| Return the button, so that events can be associated""" | |
| return self.pushbutton(name, int(self.w*xpos - 28), self.h-27, 56, 17, 3, title, next) | |
| class bdist_msi(Command): | |
| description = "create a Microsoft Installer (.msi) binary distribution" | |
| user_options = [('bdist-dir=', None, | |
| "temporary directory for creating the distribution"), | |
| ('plat-name=', 'p', | |
| "platform name to embed in generated filenames " | |
| "(default: %s)" % get_platform()), | |
| ('keep-temp', 'k', | |
| "keep the pseudo-installation tree around after " + | |
| "creating the distribution archive"), | |
| ('target-version=', None, | |
| "require a specific python version" + | |
| " on the target system"), | |
| ('no-target-compile', 'c', | |
| "do not compile .py to .pyc on the target system"), | |
| ('no-target-optimize', 'o', | |
| "do not compile .py to .pyo (optimized) " | |
| "on the target system"), | |
| ('dist-dir=', 'd', | |
| "directory to put final built distributions in"), | |
| ('skip-build', None, | |
| "skip rebuilding everything (for testing/debugging)"), | |
| ('install-script=', None, | |
| "basename of installation script to be run after " | |
| "installation or before deinstallation"), | |
| ('pre-install-script=', None, | |
| "Fully qualified filename of a script to be run before " | |
| "any files are installed. This script need not be in the " | |
| "distribution"), | |
| ] | |
| boolean_options = ['keep-temp', 'no-target-compile', 'no-target-optimize', | |
| 'skip-build'] | |
| all_versions = ['2.0', '2.1', '2.2', '2.3', '2.4', | |
| '2.5', '2.6', '2.7', '2.8', '2.9', | |
| '3.0', '3.1', '3.2', '3.3', '3.4', | |
| '3.5', '3.6', '3.7', '3.8', '3.9'] | |
| other_version = 'X' | |
| def __init__(self, *args, **kw): | |
| super().__init__(*args, **kw) | |
| warnings.warn("bdist_msi command is deprecated since Python 3.9, " | |
| "use bdist_wheel (wheel packages) instead", | |
| DeprecationWarning, 2) | |
| def initialize_options(self): | |
| self.bdist_dir = None | |
| self.plat_name = None | |
| self.keep_temp = 0 | |
| self.no_target_compile = 0 | |
| self.no_target_optimize = 0 | |
| self.target_version = None | |
| self.dist_dir = None | |
| self.skip_build = None | |
| self.install_script = None | |
| self.pre_install_script = None | |
| self.versions = None | |
| def finalize_options(self): | |
| self.set_undefined_options('bdist', ('skip_build', 'skip_build')) | |
| if self.bdist_dir is None: | |
| bdist_base = self.get_finalized_command('bdist').bdist_base | |
| self.bdist_dir = os.path.join(bdist_base, 'msi') | |
| short_version = get_python_version() | |
| if (not self.target_version) and self.distribution.has_ext_modules(): | |
| self.target_version = short_version | |
| if self.target_version: | |
| self.versions = [self.target_version] | |
| if not self.skip_build and self.distribution.has_ext_modules()\ | |
| and self.target_version != short_version: | |
| raise DistutilsOptionError( | |
| "target version can only be %s, or the '--skip-build'" | |
| " option must be specified" % (short_version,)) | |
| else: | |
| self.versions = list(self.all_versions) | |
| self.set_undefined_options('bdist', | |
| ('dist_dir', 'dist_dir'), | |
| ('plat_name', 'plat_name'), | |
| ) | |
| if self.pre_install_script: | |
| raise DistutilsOptionError( | |
| "the pre-install-script feature is not yet implemented") | |
| if self.install_script: | |
| for script in self.distribution.scripts: | |
| if self.install_script == os.path.basename(script): | |
| break | |
| else: | |
| raise DistutilsOptionError( | |
| "install_script '%s' not found in scripts" | |
| % self.install_script) | |
| self.install_script_key = None | |
| def run(self): | |
| if not self.skip_build: | |
| self.run_command('build') | |
| install = self.reinitialize_command('install', reinit_subcommands=1) | |
| install.prefix = self.bdist_dir | |
| install.skip_build = self.skip_build | |
| install.warn_dir = 0 | |
| install_lib = self.reinitialize_command('install_lib') | |
| # we do not want to include pyc or pyo files | |
| install_lib.compile = 0 | |
| install_lib.optimize = 0 | |
| if self.distribution.has_ext_modules(): | |
| # If we are building an installer for a Python version other | |
| # than the one we are currently running, then we need to ensure | |
| # our build_lib reflects the other Python version rather than ours. | |
| # Note that for target_version!=sys.version, we must have skipped the | |
| # build step, so there is no issue with enforcing the build of this | |
| # version. | |
| target_version = self.target_version | |
| if not target_version: | |
| assert self.skip_build, "Should have already checked this" | |
| target_version = '%d.%d' % sys.version_info[:2] | |
| plat_specifier = ".%s-%s" % (self.plat_name, target_version) | |
| build = self.get_finalized_command('build') | |
| build.build_lib = os.path.join(build.build_base, | |
| 'lib' + plat_specifier) | |
| log.info("installing to %s", self.bdist_dir) | |
| install.ensure_finalized() | |
| # avoid warning of 'install_lib' about installing | |
| # into a directory not in sys.path | |
| sys.path.insert(0, os.path.join(self.bdist_dir, 'PURELIB')) | |
| install.run() | |
| del sys.path[0] | |
| self.mkpath(self.dist_dir) | |
| fullname = self.distribution.get_fullname() | |
| installer_name = self.get_installer_filename(fullname) | |
| installer_name = os.path.abspath(installer_name) | |
| if os.path.exists(installer_name): os.unlink(installer_name) | |
| metadata = self.distribution.metadata | |
| author = metadata.author | |
| if not author: | |
| author = metadata.maintainer | |
| if not author: | |
| author = "UNKNOWN" | |
| version = metadata.get_version() | |
| # ProductVersion must be strictly numeric | |
| # XXX need to deal with prerelease versions | |
| sversion = "%d.%d.%d" % StrictVersion(version).version | |
| # Prefix ProductName with Python x.y, so that | |
| # it sorts together with the other Python packages | |
| # in Add-Remove-Programs (APR) | |
| fullname = self.distribution.get_fullname() | |
| if self.target_version: | |
| product_name = "Python %s %s" % (self.target_version, fullname) | |
| else: | |
| product_name = "Python %s" % (fullname) | |
| self.db = msilib.init_database(installer_name, schema, | |
| product_name, msilib.gen_uuid(), | |
| sversion, author) | |
| msilib.add_tables(self.db, sequence) | |
| props = [('DistVersion', version)] | |
| email = metadata.author_email or metadata.maintainer_email | |
| if email: | |
| props.append(("ARPCONTACT", email)) | |
| if metadata.url: | |
| props.append(("ARPURLINFOABOUT", metadata.url)) | |
| if props: | |
| add_data(self.db, 'Property', props) | |
| self.add_find_python() | |
| self.add_files() | |
| self.add_scripts() | |
| self.add_ui() | |
| self.db.Commit() | |
| if hasattr(self.distribution, 'dist_files'): | |
| tup = 'bdist_msi', self.target_version or 'any', fullname | |
| self.distribution.dist_files.append(tup) | |
| if not self.keep_temp: | |
| remove_tree(self.bdist_dir, dry_run=self.dry_run) | |
| def add_files(self): | |
| db = self.db | |
| cab = msilib.CAB("distfiles") | |
| rootdir = os.path.abspath(self.bdist_dir) | |
| root = Directory(db, cab, None, rootdir, "TARGETDIR", "SourceDir") | |
| f = Feature(db, "Python", "Python", "Everything", | |
| 0, 1, directory="TARGETDIR") | |
| items = [(f, root, '')] | |
| for version in self.versions + [self.other_version]: | |
| target = "TARGETDIR" + version | |
| name = default = "Python" + version | |
| desc = "Everything" | |
| if version is self.other_version: | |
| title = "Python from another location" | |
| level = 2 | |
| else: | |
| title = "Python %s from registry" % version | |
| level = 1 | |
| f = Feature(db, name, title, desc, 1, level, directory=target) | |
| dir = Directory(db, cab, root, rootdir, target, default) | |
| items.append((f, dir, version)) | |
| db.Commit() | |
| seen = {} | |
| for feature, dir, version in items: | |
| todo = [dir] | |
| while todo: | |
| dir = todo.pop() | |
| for file in os.listdir(dir.absolute): | |
| afile = os.path.join(dir.absolute, file) | |
| if os.path.isdir(afile): | |
| short = "%s|%s" % (dir.make_short(file), file) | |
| default = file + version | |
| newdir = Directory(db, cab, dir, file, default, short) | |
| todo.append(newdir) | |
| else: | |
| if not dir.component: | |
| dir.start_component(dir.logical, feature, 0) | |
| if afile not in seen: | |
| key = seen[afile] = dir.add_file(file) | |
| if file==self.install_script: | |
| if self.install_script_key: | |
| raise DistutilsOptionError( | |
| "Multiple files with name %s" % file) | |
| self.install_script_key = '[#%s]' % key | |
| else: | |
| key = seen[afile] | |
| add_data(self.db, "DuplicateFile", | |
| [(key + version, dir.component, key, None, dir.logical)]) | |
| db.Commit() | |
| cab.commit(db) | |
| def add_find_python(self): | |
| """Adds code to the installer to compute the location of Python. | |
| Properties PYTHON.MACHINE.X.Y and PYTHON.USER.X.Y will be set from the | |
| registry for each version of Python. | |
| Properties TARGETDIRX.Y will be set from PYTHON.USER.X.Y if defined, | |
| else from PYTHON.MACHINE.X.Y. | |
| Properties PYTHONX.Y will be set to TARGETDIRX.Y\\python.exe""" | |
| start = 402 | |
| for ver in self.versions: | |
| install_path = r"SOFTWARE\Python\PythonCore\%s\InstallPath" % ver | |
| machine_reg = "python.machine." + ver | |
| user_reg = "python.user." + ver | |
| machine_prop = "PYTHON.MACHINE." + ver | |
| user_prop = "PYTHON.USER." + ver | |
| machine_action = "PythonFromMachine" + ver | |
| user_action = "PythonFromUser" + ver | |
| exe_action = "PythonExe" + ver | |
| target_dir_prop = "TARGETDIR" + ver | |
| exe_prop = "PYTHON" + ver | |
| if msilib.Win64: | |
| # type: msidbLocatorTypeRawValue + msidbLocatorType64bit | |
| Type = 2+16 | |
| else: | |
| Type = 2 | |
| add_data(self.db, "RegLocator", | |
| [(machine_reg, 2, install_path, None, Type), | |
| (user_reg, 1, install_path, None, Type)]) | |
| add_data(self.db, "AppSearch", | |
| [(machine_prop, machine_reg), | |
| (user_prop, user_reg)]) | |
| add_data(self.db, "CustomAction", | |
| [(machine_action, 51+256, target_dir_prop, "[" + machine_prop + "]"), | |
| (user_action, 51+256, target_dir_prop, "[" + user_prop + "]"), | |
| (exe_action, 51+256, exe_prop, "[" + target_dir_prop + "]\\python.exe"), | |
| ]) | |
| add_data(self.db, "InstallExecuteSequence", | |
| [(machine_action, machine_prop, start), | |
| (user_action, user_prop, start + 1), | |
| (exe_action, None, start + 2), | |
| ]) | |
| add_data(self.db, "InstallUISequence", | |
| [(machine_action, machine_prop, start), | |
| (user_action, user_prop, start + 1), | |
| (exe_action, None, start + 2), | |
| ]) | |
| add_data(self.db, "Condition", | |
| [("Python" + ver, 0, "NOT TARGETDIR" + ver)]) | |
| start += 4 | |
| assert start < 500 | |
| def add_scripts(self): | |
| if self.install_script: | |
| start = 6800 | |
| for ver in self.versions + [self.other_version]: | |
| install_action = "install_script." + ver | |
| exe_prop = "PYTHON" + ver | |
| add_data(self.db, "CustomAction", | |
| [(install_action, 50, exe_prop, self.install_script_key)]) | |
| add_data(self.db, "InstallExecuteSequence", | |
| [(install_action, "&Python%s=3" % ver, start)]) | |
| start += 1 | |
| # XXX pre-install scripts are currently refused in finalize_options() | |
| # but if this feature is completed, it will also need to add | |
| # entries for each version as the above code does | |
| if self.pre_install_script: | |
| scriptfn = os.path.join(self.bdist_dir, "preinstall.bat") | |
| with open(scriptfn, "w") as f: | |
| # The batch file will be executed with [PYTHON], so that %1 | |
| # is the path to the Python interpreter; %0 will be the path | |
| # of the batch file. | |
| # rem =""" | |
| # %1 %0 | |
| # exit | |
| # """ | |
| # <actual script> | |
| f.write('rem ="""\n%1 %0\nexit\n"""\n') | |
| with open(self.pre_install_script) as fin: | |
| f.write(fin.read()) | |
| add_data(self.db, "Binary", | |
| [("PreInstall", msilib.Binary(scriptfn)) | |
| ]) | |
| add_data(self.db, "CustomAction", | |
| [("PreInstall", 2, "PreInstall", None) | |
| ]) | |
| add_data(self.db, "InstallExecuteSequence", | |
| [("PreInstall", "NOT Installed", 450)]) | |
| def add_ui(self): | |
| db = self.db | |
| x = y = 50 | |
| w = 370 | |
| h = 300 | |
| title = "[ProductName] Setup" | |
| # see "Dialog Style Bits" | |
| modal = 3 # visible | modal | |
| modeless = 1 # visible | |
| track_disk_space = 32 | |
| # UI customization properties | |
| add_data(db, "Property", | |
| # See "DefaultUIFont Property" | |
| [("DefaultUIFont", "DlgFont8"), | |
| # See "ErrorDialog Style Bit" | |
| ("ErrorDialog", "ErrorDlg"), | |
| ("Progress1", "Install"), # modified in maintenance type dlg | |
| ("Progress2", "installs"), | |
| ("MaintenanceForm_Action", "Repair"), | |
| # possible values: ALL, JUSTME | |
| ("WhichUsers", "ALL") | |
| ]) | |
| # Fonts, see "TextStyle Table" | |
| add_data(db, "TextStyle", | |
| [("DlgFont8", "Tahoma", 9, None, 0), | |
| ("DlgFontBold8", "Tahoma", 8, None, 1), #bold | |
| ("VerdanaBold10", "Verdana", 10, None, 1), | |
| ("VerdanaRed9", "Verdana", 9, 255, 0), | |
| ]) | |
| # UI Sequences, see "InstallUISequence Table", "Using a Sequence Table" | |
| # Numbers indicate sequence; see sequence.py for how these action integrate | |
| add_data(db, "InstallUISequence", | |
| [("PrepareDlg", "Not Privileged or Windows9x or Installed", 140), | |
| ("WhichUsersDlg", "Privileged and not Windows9x and not Installed", 141), | |
| # In the user interface, assume all-users installation if privileged. | |
| ("SelectFeaturesDlg", "Not Installed", 1230), | |
| # XXX no support for resume installations yet | |
| #("ResumeDlg", "Installed AND (RESUME OR Preselected)", 1240), | |
| ("MaintenanceTypeDlg", "Installed AND NOT RESUME AND NOT Preselected", 1250), | |
| ("ProgressDlg", None, 1280)]) | |
| add_data(db, 'ActionText', text.ActionText) | |
| add_data(db, 'UIText', text.UIText) | |
| ##################################################################### | |
| # Standard dialogs: FatalError, UserExit, ExitDialog | |
| fatal=PyDialog(db, "FatalError", x, y, w, h, modal, title, | |
| "Finish", "Finish", "Finish") | |
| fatal.title("[ProductName] Installer ended prematurely") | |
| fatal.back("< Back", "Finish", active = 0) | |
| fatal.cancel("Cancel", "Back", active = 0) | |
| fatal.text("Description1", 15, 70, 320, 80, 0x30003, | |
| "[ProductName] setup ended prematurely because of an error. Your system has not been modified. To install this program at a later time, please run the installation again.") | |
| fatal.text("Description2", 15, 155, 320, 20, 0x30003, | |
| "Click the Finish button to exit the Installer.") | |
| c=fatal.next("Finish", "Cancel", name="Finish") | |
| c.event("EndDialog", "Exit") | |
| user_exit=PyDialog(db, "UserExit", x, y, w, h, modal, title, | |
| "Finish", "Finish", "Finish") | |
| user_exit.title("[ProductName] Installer was interrupted") | |
| user_exit.back("< Back", "Finish", active = 0) | |
| user_exit.cancel("Cancel", "Back", active = 0) | |
| user_exit.text("Description1", 15, 70, 320, 80, 0x30003, | |
| "[ProductName] setup was interrupted. Your system has not been modified. " | |
| "To install this program at a later time, please run the installation again.") | |
| user_exit.text("Description2", 15, 155, 320, 20, 0x30003, | |
| "Click the Finish button to exit the Installer.") | |
| c = user_exit.next("Finish", "Cancel", name="Finish") | |
| c.event("EndDialog", "Exit") | |
| exit_dialog = PyDialog(db, "ExitDialog", x, y, w, h, modal, title, | |
| "Finish", "Finish", "Finish") | |
| exit_dialog.title("Completing the [ProductName] Installer") | |
| exit_dialog.back("< Back", "Finish", active = 0) | |
| exit_dialog.cancel("Cancel", "Back", active = 0) | |
| exit_dialog.text("Description", 15, 235, 320, 20, 0x30003, | |
| "Click the Finish button to exit the Installer.") | |
| c = exit_dialog.next("Finish", "Cancel", name="Finish") | |
| c.event("EndDialog", "Return") | |
| ##################################################################### | |
| # Required dialog: FilesInUse, ErrorDlg | |
| inuse = PyDialog(db, "FilesInUse", | |
| x, y, w, h, | |
| 19, # KeepModeless|Modal|Visible | |
| title, | |
| "Retry", "Retry", "Retry", bitmap=False) | |
| inuse.text("Title", 15, 6, 200, 15, 0x30003, | |
| r"{\DlgFontBold8}Files in Use") | |
| inuse.text("Description", 20, 23, 280, 20, 0x30003, | |
| "Some files that need to be updated are currently in use.") | |
| inuse.text("Text", 20, 55, 330, 50, 3, | |
| "The following applications are using files that need to be updated by this setup. Close these applications and then click Retry to continue the installation or Cancel to exit it.") | |
| inuse.control("List", "ListBox", 20, 107, 330, 130, 7, "FileInUseProcess", | |
| None, None, None) | |
| c=inuse.back("Exit", "Ignore", name="Exit") | |
| c.event("EndDialog", "Exit") | |
| c=inuse.next("Ignore", "Retry", name="Ignore") | |
| c.event("EndDialog", "Ignore") | |
| c=inuse.cancel("Retry", "Exit", name="Retry") | |
| c.event("EndDialog","Retry") | |
| # See "Error Dialog". See "ICE20" for the required names of the controls. | |
| error = Dialog(db, "ErrorDlg", | |
| 50, 10, 330, 101, | |
| 65543, # Error|Minimize|Modal|Visible | |
| title, | |
| "ErrorText", None, None) | |
| error.text("ErrorText", 50,9,280,48,3, "") | |
| #error.control("ErrorIcon", "Icon", 15, 9, 24, 24, 5242881, None, "py.ico", None, None) | |
| error.pushbutton("N",120,72,81,21,3,"No",None).event("EndDialog","ErrorNo") | |
| error.pushbutton("Y",240,72,81,21,3,"Yes",None).event("EndDialog","ErrorYes") | |
| error.pushbutton("A",0,72,81,21,3,"Abort",None).event("EndDialog","ErrorAbort") | |
| error.pushbutton("C",42,72,81,21,3,"Cancel",None).event("EndDialog","ErrorCancel") | |
| error.pushbutton("I",81,72,81,21,3,"Ignore",None).event("EndDialog","ErrorIgnore") | |
| error.pushbutton("O",159,72,81,21,3,"Ok",None).event("EndDialog","ErrorOk") | |
| error.pushbutton("R",198,72,81,21,3,"Retry",None).event("EndDialog","ErrorRetry") | |
| ##################################################################### | |
| # Global "Query Cancel" dialog | |
| cancel = Dialog(db, "CancelDlg", 50, 10, 260, 85, 3, title, | |
| "No", "No", "No") | |
| cancel.text("Text", 48, 15, 194, 30, 3, | |
| "Are you sure you want to cancel [ProductName] installation?") | |
| #cancel.control("Icon", "Icon", 15, 15, 24, 24, 5242881, None, | |
| # "py.ico", None, None) | |
| c=cancel.pushbutton("Yes", 72, 57, 56, 17, 3, "Yes", "No") | |
| c.event("EndDialog", "Exit") | |
| c=cancel.pushbutton("No", 132, 57, 56, 17, 3, "No", "Yes") | |
| c.event("EndDialog", "Return") | |
| ##################################################################### | |
| # Global "Wait for costing" dialog | |
| costing = Dialog(db, "WaitForCostingDlg", 50, 10, 260, 85, modal, title, | |
| "Return", "Return", "Return") | |
| costing.text("Text", 48, 15, 194, 30, 3, | |
| "Please wait while the installer finishes determining your disk space requirements.") | |
| c = costing.pushbutton("Return", 102, 57, 56, 17, 3, "Return", None) | |
| c.event("EndDialog", "Exit") | |
| ##################################################################### | |
| # Preparation dialog: no user input except cancellation | |
| prep = PyDialog(db, "PrepareDlg", x, y, w, h, modeless, title, | |
| "Cancel", "Cancel", "Cancel") | |
| prep.text("Description", 15, 70, 320, 40, 0x30003, | |
| "Please wait while the Installer prepares to guide you through the installation.") | |
| prep.title("Welcome to the [ProductName] Installer") | |
| c=prep.text("ActionText", 15, 110, 320, 20, 0x30003, "Pondering...") | |
| c.mapping("ActionText", "Text") | |
| c=prep.text("ActionData", 15, 135, 320, 30, 0x30003, None) | |
| c.mapping("ActionData", "Text") | |
| prep.back("Back", None, active=0) | |
| prep.next("Next", None, active=0) | |
| c=prep.cancel("Cancel", None) | |
| c.event("SpawnDialog", "CancelDlg") | |
| ##################################################################### | |
| # Feature (Python directory) selection | |
| seldlg = PyDialog(db, "SelectFeaturesDlg", x, y, w, h, modal, title, | |
| "Next", "Next", "Cancel") | |
| seldlg.title("Select Python Installations") | |
| seldlg.text("Hint", 15, 30, 300, 20, 3, | |
| "Select the Python locations where %s should be installed." | |
| % self.distribution.get_fullname()) | |
| seldlg.back("< Back", None, active=0) | |
| c = seldlg.next("Next >", "Cancel") | |
| order = 1 | |
| c.event("[TARGETDIR]", "[SourceDir]", ordering=order) | |
| for version in self.versions + [self.other_version]: | |
| order += 1 | |
| c.event("[TARGETDIR]", "[TARGETDIR%s]" % version, | |
| "FEATURE_SELECTED AND &Python%s=3" % version, | |
| ordering=order) | |
| c.event("SpawnWaitDialog", "WaitForCostingDlg", ordering=order + 1) | |
| c.event("EndDialog", "Return", ordering=order + 2) | |
| c = seldlg.cancel("Cancel", "Features") | |
| c.event("SpawnDialog", "CancelDlg") | |
| c = seldlg.control("Features", "SelectionTree", 15, 60, 300, 120, 3, | |
| "FEATURE", None, "PathEdit", None) | |
| c.event("[FEATURE_SELECTED]", "1") | |
| ver = self.other_version | |
| install_other_cond = "FEATURE_SELECTED AND &Python%s=3" % ver | |
| dont_install_other_cond = "FEATURE_SELECTED AND &Python%s<>3" % ver | |
| c = seldlg.text("Other", 15, 200, 300, 15, 3, | |
| "Provide an alternate Python location") | |
| c.condition("Enable", install_other_cond) | |
| c.condition("Show", install_other_cond) | |
| c.condition("Disable", dont_install_other_cond) | |
| c.condition("Hide", dont_install_other_cond) | |
| c = seldlg.control("PathEdit", "PathEdit", 15, 215, 300, 16, 1, | |
| "TARGETDIR" + ver, None, "Next", None) | |
| c.condition("Enable", install_other_cond) | |
| c.condition("Show", install_other_cond) | |
| c.condition("Disable", dont_install_other_cond) | |
| c.condition("Hide", dont_install_other_cond) | |
| ##################################################################### | |
| # Disk cost | |
| cost = PyDialog(db, "DiskCostDlg", x, y, w, h, modal, title, | |
| "OK", "OK", "OK", bitmap=False) | |
| cost.text("Title", 15, 6, 200, 15, 0x30003, | |
| r"{\DlgFontBold8}Disk Space Requirements") | |
| cost.text("Description", 20, 20, 280, 20, 0x30003, | |
| "The disk space required for the installation of the selected features.") | |
| cost.text("Text", 20, 53, 330, 60, 3, | |
| "The highlighted volumes (if any) do not have enough disk space " | |
| "available for the currently selected features. You can either " | |
| "remove some files from the highlighted volumes, or choose to " | |
| "install less features onto local drive(s), or select different " | |
| "destination drive(s).") | |
| cost.control("VolumeList", "VolumeCostList", 20, 100, 330, 150, 393223, | |
| None, "{120}{70}{70}{70}{70}", None, None) | |
| cost.xbutton("OK", "Ok", None, 0.5).event("EndDialog", "Return") | |
| ##################################################################### | |
| # WhichUsers Dialog. Only available on NT, and for privileged users. | |
| # This must be run before FindRelatedProducts, because that will | |
| # take into account whether the previous installation was per-user | |
| # or per-machine. We currently don't support going back to this | |
| # dialog after "Next" was selected; to support this, we would need to | |
| # find how to reset the ALLUSERS property, and how to re-run | |
| # FindRelatedProducts. | |
| # On Windows9x, the ALLUSERS property is ignored on the command line | |
| # and in the Property table, but installer fails according to the documentation | |
| # if a dialog attempts to set ALLUSERS. | |
| whichusers = PyDialog(db, "WhichUsersDlg", x, y, w, h, modal, title, | |
| "AdminInstall", "Next", "Cancel") | |
| whichusers.title("Select whether to install [ProductName] for all users of this computer.") | |
| # A radio group with two options: allusers, justme | |
| g = whichusers.radiogroup("AdminInstall", 15, 60, 260, 50, 3, | |
| "WhichUsers", "", "Next") | |
| g.add("ALL", 0, 5, 150, 20, "Install for all users") | |
| g.add("JUSTME", 0, 25, 150, 20, "Install just for me") | |
| whichusers.back("Back", None, active=0) | |
| c = whichusers.next("Next >", "Cancel") | |
| c.event("[ALLUSERS]", "1", 'WhichUsers="ALL"', 1) | |
| c.event("EndDialog", "Return", ordering = 2) | |
| c = whichusers.cancel("Cancel", "AdminInstall") | |
| c.event("SpawnDialog", "CancelDlg") | |
| ##################################################################### | |
| # Installation Progress dialog (modeless) | |
| progress = PyDialog(db, "ProgressDlg", x, y, w, h, modeless, title, | |
| "Cancel", "Cancel", "Cancel", bitmap=False) | |
| progress.text("Title", 20, 15, 200, 15, 0x30003, | |
| r"{\DlgFontBold8}[Progress1] [ProductName]") | |
| progress.text("Text", 35, 65, 300, 30, 3, | |
| "Please wait while the Installer [Progress2] [ProductName]. " | |
| "This may take several minutes.") | |
| progress.text("StatusLabel", 35, 100, 35, 20, 3, "Status:") | |
| c=progress.text("ActionText", 70, 100, w-70, 20, 3, "Pondering...") | |
| c.mapping("ActionText", "Text") | |
| #c=progress.text("ActionData", 35, 140, 300, 20, 3, None) | |
| #c.mapping("ActionData", "Text") | |
| c=progress.control("ProgressBar", "ProgressBar", 35, 120, 300, 10, 65537, | |
| None, "Progress done", None, None) | |
| c.mapping("SetProgress", "Progress") | |
| progress.back("< Back", "Next", active=False) | |
| progress.next("Next >", "Cancel", active=False) | |
| progress.cancel("Cancel", "Back").event("SpawnDialog", "CancelDlg") | |
| ################################################################### | |
| # Maintenance type: repair/uninstall | |
| maint = PyDialog(db, "MaintenanceTypeDlg", x, y, w, h, modal, title, | |
| "Next", "Next", "Cancel") | |
| maint.title("Welcome to the [ProductName] Setup Wizard") | |
| maint.text("BodyText", 15, 63, 330, 42, 3, | |
| "Select whether you want to repair or remove [ProductName].") | |
| g=maint.radiogroup("RepairRadioGroup", 15, 108, 330, 60, 3, | |
| "MaintenanceForm_Action", "", "Next") | |
| #g.add("Change", 0, 0, 200, 17, "&Change [ProductName]") | |
| g.add("Repair", 0, 18, 200, 17, "&Repair [ProductName]") | |
| g.add("Remove", 0, 36, 200, 17, "Re&move [ProductName]") | |
| maint.back("< Back", None, active=False) | |
| c=maint.next("Finish", "Cancel") | |
| # Change installation: Change progress dialog to "Change", then ask | |
| # for feature selection | |
| #c.event("[Progress1]", "Change", 'MaintenanceForm_Action="Change"', 1) | |
| #c.event("[Progress2]", "changes", 'MaintenanceForm_Action="Change"', 2) | |
| # Reinstall: Change progress dialog to "Repair", then invoke reinstall | |
| # Also set list of reinstalled features to "ALL" | |
| c.event("[REINSTALL]", "ALL", 'MaintenanceForm_Action="Repair"', 5) | |
| c.event("[Progress1]", "Repairing", 'MaintenanceForm_Action="Repair"', 6) | |
| c.event("[Progress2]", "repairs", 'MaintenanceForm_Action="Repair"', 7) | |
| c.event("Reinstall", "ALL", 'MaintenanceForm_Action="Repair"', 8) | |
| # Uninstall: Change progress to "Remove", then invoke uninstall | |
| # Also set list of removed features to "ALL" | |
| c.event("[REMOVE]", "ALL", 'MaintenanceForm_Action="Remove"', 11) | |
| c.event("[Progress1]", "Removing", 'MaintenanceForm_Action="Remove"', 12) | |
| c.event("[Progress2]", "removes", 'MaintenanceForm_Action="Remove"', 13) | |
| c.event("Remove", "ALL", 'MaintenanceForm_Action="Remove"', 14) | |
| # Close dialog when maintenance action scheduled | |
| c.event("EndDialog", "Return", 'MaintenanceForm_Action<>"Change"', 20) | |
| #c.event("NewDialog", "SelectFeaturesDlg", 'MaintenanceForm_Action="Change"', 21) | |
| maint.cancel("Cancel", "RepairRadioGroup").event("SpawnDialog", "CancelDlg") | |
| def get_installer_filename(self, fullname): | |
| # Factored out to allow overriding in subclasses | |
| if self.target_version: | |
| base_name = "%s.%s-py%s.msi" % (fullname, self.plat_name, | |
| self.target_version) | |
| else: | |
| base_name = "%s.%s.msi" % (fullname, self.plat_name) | |
| installer_name = os.path.join(self.dist_dir, base_name) | |
| return installer_name | |