EmbeddedPkg: Extend NvVarStoreFormattedLib LIBRARY_CLASS

[mirror_edk2.git] / AppPkg / Applications / Python / Python-2.7.2 / Tools / msi / msi.py

# Python MSI Generator\r
# (C) 2003 Martin v. Loewis\r
# See "FOO" in comments refers to MSDN sections with the title FOO.\r
import msilib, schema, sequence, os, glob, time, re, shutil, zipfile\r
from msilib import Feature, CAB, Directory, Dialog, Binary, add_data\r
import uisample\r
from win32com.client import constants\r
from distutils.spawn import find_executable\r
from uuids import product_codes\r
import tempfile\r
\r
# Settings can be overridden in config.py below\r
# 0 for official python.org releases\r
# 1 for intermediate releases by anybody, with\r
# a new product code for every package.\r
snapshot = 1\r
# 1 means that file extension is px, not py,\r
# and binaries start with x\r
testpackage = 0\r
# Location of build tree\r
srcdir = os.path.abspath("../..")\r
# Text to be displayed as the version in dialogs etc.\r
# goes into file name and ProductCode. Defaults to\r
# current_version.day for Snapshot, current_version otherwise\r
full_current_version = None\r
# Is Tcl available at all?\r
have_tcl = True\r
# path to PCbuild directory\r
PCBUILD="PCbuild"\r
# msvcrt version\r
MSVCR = "90"\r
# Name of certificate in default store to sign MSI with\r
certname = None\r
# Make a zip file containing the PDB files for this build?\r
pdbzip = True\r
\r
try:\r
    from config import *\r
except ImportError:\r
    pass\r
\r
# Extract current version from Include/patchlevel.h\r
lines = open(srcdir + "/Include/patchlevel.h").readlines()\r
major = minor = micro = level = serial = None\r
levels = {\r
    'PY_RELEASE_LEVEL_ALPHA':0xA,\r
    'PY_RELEASE_LEVEL_BETA': 0xB,\r
    'PY_RELEASE_LEVEL_GAMMA':0xC,\r
    'PY_RELEASE_LEVEL_FINAL':0xF\r
    }\r
for l in lines:\r
    if not l.startswith("#define"):\r
        continue\r
    l = l.split()\r
    if len(l) != 3:\r
        continue\r
    _, name, value = l\r
    if name == 'PY_MAJOR_VERSION': major = value\r
    if name == 'PY_MINOR_VERSION': minor = value\r
    if name == 'PY_MICRO_VERSION': micro = value\r
    if name == 'PY_RELEASE_LEVEL': level = levels[value]\r
    if name == 'PY_RELEASE_SERIAL': serial = value\r
\r
short_version = major+"."+minor\r
# See PC/make_versioninfo.c\r
FIELD3 = 1000*int(micro) + 10*level + int(serial)\r
current_version = "%s.%d" % (short_version, FIELD3)\r
\r
# This should never change. The UpgradeCode of this package can be\r
# used in the Upgrade table of future packages to make the future\r
# package replace this one. See "UpgradeCode Property".\r
# upgrade_code gets set to upgrade_code_64 when we have determined\r
# that the target is Win64.\r
upgrade_code_snapshot='{92A24481-3ECB-40FC-8836-04B7966EC0D5}'\r
upgrade_code='{65E6DE48-A358-434D-AA4F-4AF72DB4718F}'\r
upgrade_code_64='{6A965A0C-6EE6-4E3A-9983-3263F56311EC}'\r
\r
if snapshot:\r
    current_version = "%s.%s.%s" % (major, minor, int(time.time()/3600/24))\r
    product_code = msilib.gen_uuid()\r
else:\r
    product_code = product_codes[current_version]\r
\r
if full_current_version is None:\r
    full_current_version = current_version\r
\r
extensions = [\r
    'bz2.pyd',\r
    'pyexpat.pyd',\r
    'select.pyd',\r
    'unicodedata.pyd',\r
    'winsound.pyd',\r
    '_elementtree.pyd',\r
    '_bsddb.pyd',\r
    '_socket.pyd',\r
    '_ssl.pyd',\r
    '_testcapi.pyd',\r
    '_tkinter.pyd',\r
    '_msi.pyd',\r
    '_ctypes.pyd',\r
    '_ctypes_test.pyd',\r
    '_sqlite3.pyd',\r
    '_hashlib.pyd',\r
    '_multiprocessing.pyd'\r
]\r
\r
# Well-known component UUIDs\r
# These are needed for SharedDLLs reference counter; if\r
# a different UUID was used for each incarnation of, say,\r
# python24.dll, an upgrade would set the reference counter\r
# from 1 to 2 (due to what I consider a bug in MSI)\r
# Using the same UUID is fine since these files are versioned,\r
# so Installer will always keep the newest version.\r
# NOTE: All uuids are self generated.\r
pythondll_uuid = {\r
    "24":"{9B81E618-2301-4035-AC77-75D9ABEB7301}",\r
    "25":"{2e41b118-38bd-4c1b-a840-6977efd1b911}",\r
    "26":"{34ebecac-f046-4e1c-b0e3-9bac3cdaacfa}",\r
    "27":"{4fe21c76-1760-437b-a2f2-99909130a175}",\r
    } [major+minor]\r
\r
# Compute the name that Sphinx gives to the docfile\r
docfile = ""\r
if int(micro):\r
    docfile = micro\r
if level < 0xf:\r
    if level == 0xC:\r
        docfile += "rc%s" % (serial,)\r
    else:\r
        docfile += '%x%s' % (level, serial)\r
docfile = 'python%s%s%s.chm' % (major, minor, docfile)\r
\r
# Build the mingw import library, libpythonXY.a\r
# This requires 'nm' and 'dlltool' executables on your PATH\r
def build_mingw_lib(lib_file, def_file, dll_file, mingw_lib):\r
    warning = "WARNING: %s - libpythonXX.a not built"\r
    nm = find_executable('nm')\r
    dlltool = find_executable('dlltool')\r
\r
    if not nm or not dlltool:\r
        print warning % "nm and/or dlltool were not found"\r
        return False\r
\r
    nm_command = '%s -Cs %s' % (nm, lib_file)\r
    dlltool_command = "%s --dllname %s --def %s --output-lib %s" % \\r
        (dlltool, dll_file, def_file, mingw_lib)\r
    export_match = re.compile(r"^_imp__(.*) in python\d+\.dll").match\r
\r
    f = open(def_file,'w')\r
    print >>f, "LIBRARY %s" % dll_file\r
    print >>f, "EXPORTS"\r
\r
    nm_pipe = os.popen(nm_command)\r
    for line in nm_pipe.readlines():\r
        m = export_match(line)\r
        if m:\r
            print >>f, m.group(1)\r
    f.close()\r
    exit = nm_pipe.close()\r
\r
    if exit:\r
        print warning % "nm did not run successfully"\r
        return False\r
\r
    if os.system(dlltool_command) != 0:\r
        print warning % "dlltool did not run successfully"\r
        return False\r
\r
    return True\r
\r
# Target files (.def and .a) go in PCBuild directory\r
lib_file = os.path.join(srcdir, PCBUILD, "python%s%s.lib" % (major, minor))\r
def_file = os.path.join(srcdir, PCBUILD, "python%s%s.def" % (major, minor))\r
dll_file = "python%s%s.dll" % (major, minor)\r
mingw_lib = os.path.join(srcdir, PCBUILD, "libpython%s%s.a" % (major, minor))\r
\r
have_mingw = build_mingw_lib(lib_file, def_file, dll_file, mingw_lib)\r
\r
# Determine the target architecture\r
dll_path = os.path.join(srcdir, PCBUILD, dll_file)\r
msilib.set_arch_from_file(dll_path)\r
if msilib.pe_type(dll_path) != msilib.pe_type("msisupport.dll"):\r
    raise SystemError, "msisupport.dll for incorrect architecture"\r
if msilib.Win64:\r
    upgrade_code = upgrade_code_64\r
    # Bump the last digit of the code by one, so that 32-bit and 64-bit\r
    # releases get separate product codes\r
    digit = hex((int(product_code[-2],16)+1)%16)[-1]\r
    product_code = product_code[:-2] + digit + '}'\r
\r
if testpackage:\r
    ext = 'px'\r
    testprefix = 'x'\r
else:\r
    ext = 'py'\r
    testprefix = ''\r
\r
if msilib.Win64:\r
    SystemFolderName = "[System64Folder]"\r
    registry_component = 4|256\r
else:\r
    SystemFolderName = "[SystemFolder]"\r
    registry_component = 4\r
\r
msilib.reset()\r
\r
# condition in which to install pythonxy.dll in system32:\r
# a) it is Windows 9x or\r
# b) it is NT, the user is privileged, and has chosen per-machine installation\r
sys32cond = "(Windows9x or (Privileged and ALLUSERS))"\r
\r
def build_database():\r
    """Generate an empty database, with just the schema and the\r
    Summary information stream."""\r
    if snapshot:\r
        uc = upgrade_code_snapshot\r
    else:\r
        uc = upgrade_code\r
    if msilib.Win64:\r
        productsuffix = " (64-bit)"\r
    else:\r
        productsuffix = ""\r
    # schema represents the installer 2.0 database schema.\r
    # sequence is the set of standard sequences\r
    # (ui/execute, admin/advt/install)\r
    msiname = "python-%s%s.msi" % (full_current_version, msilib.arch_ext)\r
    db = msilib.init_database(msiname,\r
                  schema, ProductName="Python "+full_current_version+productsuffix,\r
                  ProductCode=product_code,\r
                  ProductVersion=current_version,\r
                  Manufacturer=u"Python Software Foundation",\r
                  request_uac = True)\r
    # The default sequencing of the RemoveExistingProducts action causes\r
    # removal of files that got just installed. Place it after\r
    # InstallInitialize, so we first uninstall everything, but still roll\r
    # back in case the installation is interrupted\r
    msilib.change_sequence(sequence.InstallExecuteSequence,\r
                           "RemoveExistingProducts", 1510)\r
    msilib.add_tables(db, sequence)\r
    # We cannot set ALLUSERS in the property table, as this cannot be\r
    # reset if the user choses a per-user installation. Instead, we\r
    # maintain WhichUsers, which can be "ALL" or "JUSTME". The UI manages\r
    # this property, and when the execution starts, ALLUSERS is set\r
    # accordingly.\r
    add_data(db, "Property", [("UpgradeCode", uc),\r
                              ("WhichUsers", "ALL"),\r
                              ("ProductLine", "Python%s%s" % (major, minor)),\r
                             ])\r
    db.Commit()\r
    return db, msiname\r
\r
def remove_old_versions(db):\r
    "Fill the upgrade table."\r
    start = "%s.%s.0" % (major, minor)\r
    # This requests that feature selection states of an older\r
    # installation should be forwarded into this one. Upgrading\r
    # requires that both the old and the new installation are\r
    # either both per-machine or per-user.\r
    migrate_features = 1\r
    # See "Upgrade Table". We remove releases with the same major and\r
    # minor version. For an snapshot, we remove all earlier snapshots. For\r
    # a release, we remove all snapshots, and all earlier releases.\r
    if snapshot:\r
        add_data(db, "Upgrade",\r
            [(upgrade_code_snapshot, start,\r
              current_version,\r
              None,                     # Ignore language\r
              migrate_features,\r
              None,                     # Migrate ALL features\r
              "REMOVEOLDSNAPSHOT")])\r
        props = "REMOVEOLDSNAPSHOT"\r
    else:\r
        add_data(db, "Upgrade",\r
            [(upgrade_code, start, current_version,\r
              None, migrate_features, None, "REMOVEOLDVERSION"),\r
             (upgrade_code_snapshot, start, "%s.%d.0" % (major, int(minor)+1),\r
              None, migrate_features, None, "REMOVEOLDSNAPSHOT")])\r
        props = "REMOVEOLDSNAPSHOT;REMOVEOLDVERSION"\r
\r
    props += ";TARGETDIR;DLLDIR"\r
    # Installer collects the product codes of the earlier releases in\r
    # these properties. In order to allow modification of the properties,\r
    # they must be declared as secure. See "SecureCustomProperties Property"\r
    add_data(db, "Property", [("SecureCustomProperties", props)])\r
\r
class PyDialog(Dialog):\r
    """Dialog class with a fixed layout: controls at the top, then a ruler,\r
    then a list of buttons: back, next, cancel. Optionally a bitmap at the\r
    left."""\r
    def __init__(self, *args, **kw):\r
        """Dialog(database, name, x, y, w, h, attributes, title, first,\r
        default, cancel, bitmap=true)"""\r
        Dialog.__init__(self, *args)\r
        ruler = self.h - 36\r
        bmwidth = 152*ruler/328\r
        if kw.get("bitmap", True):\r
            self.bitmap("Bitmap", 0, 0, bmwidth, ruler, "PythonWin")\r
        self.line("BottomLine", 0, ruler, self.w, 0)\r
\r
    def title(self, title):\r
        "Set the title text of the dialog at the top."\r
        # name, x, y, w, h, flags=Visible|Enabled|Transparent|NoPrefix,\r
        # text, in VerdanaBold10\r
        self.text("Title", 135, 10, 220, 60, 0x30003,\r
                  r"{\VerdanaBold10}%s" % title)\r
\r
    def back(self, title, next, name = "Back", active = 1):\r
        """Add a back button with a given title, the tab-next button,\r
        its name in the Control table, possibly initially disabled.\r
\r
        Return the button, so that events can be associated"""\r
        if active:\r
            flags = 3 # Visible|Enabled\r
        else:\r
            flags = 1 # Visible\r
        return self.pushbutton(name, 180, self.h-27 , 56, 17, flags, title, next)\r
\r
    def cancel(self, title, next, name = "Cancel", active = 1):\r
        """Add a cancel button with a given title, the tab-next button,\r
        its name in the Control table, possibly initially disabled.\r
\r
        Return the button, so that events can be associated"""\r
        if active:\r
            flags = 3 # Visible|Enabled\r
        else:\r
            flags = 1 # Visible\r
        return self.pushbutton(name, 304, self.h-27, 56, 17, flags, title, next)\r
\r
    def next(self, title, next, name = "Next", active = 1):\r
        """Add a Next button with a given title, the tab-next button,\r
        its name in the Control table, possibly initially disabled.\r
\r
        Return the button, so that events can be associated"""\r
        if active:\r
            flags = 3 # Visible|Enabled\r
        else:\r
            flags = 1 # Visible\r
        return self.pushbutton(name, 236, self.h-27, 56, 17, flags, title, next)\r
\r
    def xbutton(self, name, title, next, xpos):\r
        """Add a button with a given title, the tab-next button,\r
        its name in the Control table, giving its x position; the\r
        y-position is aligned with the other buttons.\r
\r
        Return the button, so that events can be associated"""\r
        return self.pushbutton(name, int(self.w*xpos - 28), self.h-27, 56, 17, 3, title, next)\r
\r
def add_ui(db):\r
    x = y = 50\r
    w = 370\r
    h = 300\r
    title = "[ProductName] Setup"\r
\r
    # see "Dialog Style Bits"\r
    modal = 3      # visible | modal\r
    modeless = 1   # visible\r
    track_disk_space = 32\r
\r
    add_data(db, 'ActionText', uisample.ActionText)\r
    add_data(db, 'UIText', uisample.UIText)\r
\r
    # Bitmaps\r
    if not os.path.exists(srcdir+r"\PC\python_icon.exe"):\r
        raise "Run icons.mak in PC directory"\r
    add_data(db, "Binary",\r
             [("PythonWin", msilib.Binary(r"%s\PCbuild\installer.bmp" % srcdir)), # 152x328 pixels\r
              ("py.ico",msilib.Binary(srcdir+r"\PC\py.ico")),\r
             ])\r
    add_data(db, "Icon",\r
             [("python_icon.exe", msilib.Binary(srcdir+r"\PC\python_icon.exe"))])\r
\r
    # Scripts\r
    # CheckDir sets TargetExists if TARGETDIR exists.\r
    # UpdateEditIDLE sets the REGISTRY.tcl component into\r
    # the installed/uninstalled state according to both the\r
    # Extensions and TclTk features.\r
    if os.system("nmake /nologo /c /f msisupport.mak") != 0:\r
        raise "'nmake /f msisupport.mak' failed"\r
    add_data(db, "Binary", [("Script", msilib.Binary("msisupport.dll"))])\r
    # See "Custom Action Type 1"\r
    if msilib.Win64:\r
        CheckDir = "CheckDir"\r
        UpdateEditIDLE = "UpdateEditIDLE"\r
    else:\r
        CheckDir =  "_CheckDir@4"\r
        UpdateEditIDLE = "_UpdateEditIDLE@4"\r
    add_data(db, "CustomAction",\r
        [("CheckDir", 1, "Script", CheckDir)])\r
    if have_tcl:\r
        add_data(db, "CustomAction",\r
        [("UpdateEditIDLE", 1, "Script", UpdateEditIDLE)])\r
\r
    # UI customization properties\r
    add_data(db, "Property",\r
             # See "DefaultUIFont Property"\r
             [("DefaultUIFont", "DlgFont8"),\r
              # See "ErrorDialog Style Bit"\r
              ("ErrorDialog", "ErrorDlg"),\r
              ("Progress1", "Install"),   # modified in maintenance type dlg\r
              ("Progress2", "installs"),\r
              ("MaintenanceForm_Action", "Repair")])\r
\r
    # Fonts, see "TextStyle Table"\r
    add_data(db, "TextStyle",\r
             [("DlgFont8", "Tahoma", 9, None, 0),\r
              ("DlgFontBold8", "Tahoma", 8, None, 1), #bold\r
              ("VerdanaBold10", "Verdana", 10, None, 1),\r
              ("VerdanaRed9", "Verdana", 9, 255, 0),\r
             ])\r
\r
    compileargs = r'-Wi "[TARGETDIR]Lib\compileall.py" -f -x "bad_coding|badsyntax|site-packages|py3_" "[TARGETDIR]Lib"'\r
    lib2to3args = r'-c "import lib2to3.pygram, lib2to3.patcomp;lib2to3.patcomp.PatternCompiler()"'\r
    # See "CustomAction Table"\r
    add_data(db, "CustomAction", [\r
        # msidbCustomActionTypeFirstSequence + msidbCustomActionTypeTextData + msidbCustomActionTypeProperty\r
        # See "Custom Action Type 51",\r
        # "Custom Action Execution Scheduling Options"\r
        ("InitialTargetDir", 307, "TARGETDIR",\r
         "[WindowsVolume]Python%s%s" % (major, minor)),\r
        ("SetDLLDirToTarget", 307, "DLLDIR", "[TARGETDIR]"),\r
        ("SetDLLDirToSystem32", 307, "DLLDIR", SystemFolderName),\r
        # msidbCustomActionTypeExe + msidbCustomActionTypeSourceFile\r
        # See "Custom Action Type 18"\r
        ("CompilePyc", 18, "python.exe", compileargs),\r
        ("CompilePyo", 18, "python.exe", "-O "+compileargs),\r
        ("CompileGrammar", 18, "python.exe", lib2to3args),\r
        ])\r
\r
    # UI Sequences, see "InstallUISequence Table", "Using a Sequence Table"\r
    # Numbers indicate sequence; see sequence.py for how these action integrate\r
    add_data(db, "InstallUISequence",\r
             [("PrepareDlg", "Not Privileged or Windows9x or Installed", 140),\r
              ("WhichUsersDlg", "Privileged and not Windows9x and not Installed", 141),\r
              ("InitialTargetDir", 'TARGETDIR=""', 750),\r
              # In the user interface, assume all-users installation if privileged.\r
              ("SetDLLDirToSystem32", 'DLLDIR="" and ' + sys32cond, 751),\r
              ("SetDLLDirToTarget", 'DLLDIR="" and not ' + sys32cond, 752),\r
              ("SelectDirectoryDlg", "Not Installed", 1230),\r
              # XXX no support for resume installations yet\r
              #("ResumeDlg", "Installed AND (RESUME OR Preselected)", 1240),\r
              ("MaintenanceTypeDlg", "Installed AND NOT RESUME AND NOT Preselected", 1250),\r
              ("ProgressDlg", None, 1280)])\r
    add_data(db, "AdminUISequence",\r
             [("InitialTargetDir", 'TARGETDIR=""', 750),\r
              ("SetDLLDirToTarget", 'DLLDIR=""', 751),\r
             ])\r
\r
    # Execute Sequences\r
    add_data(db, "InstallExecuteSequence",\r
            [("InitialTargetDir", 'TARGETDIR=""', 750),\r
             ("SetDLLDirToSystem32", 'DLLDIR="" and ' + sys32cond, 751),\r
             ("SetDLLDirToTarget", 'DLLDIR="" and not ' + sys32cond, 752),\r
             ("UpdateEditIDLE", None, 1050),\r
             ("CompilePyc", "COMPILEALL", 6800),\r
             ("CompilePyo", "COMPILEALL", 6801),\r
             ("CompileGrammar", "COMPILEALL", 6802),\r
            ])\r
    add_data(db, "AdminExecuteSequence",\r
            [("InitialTargetDir", 'TARGETDIR=""', 750),\r
             ("SetDLLDirToTarget", 'DLLDIR=""', 751),\r
             ("CompilePyc", "COMPILEALL", 6800),\r
             ("CompilePyo", "COMPILEALL", 6801),\r
             ("CompileGrammar", "COMPILEALL", 6802),\r
            ])\r
\r
    #####################################################################\r
    # Standard dialogs: FatalError, UserExit, ExitDialog\r
    fatal=PyDialog(db, "FatalError", x, y, w, h, modal, title,\r
                 "Finish", "Finish", "Finish")\r
    fatal.title("[ProductName] Installer ended prematurely")\r
    fatal.back("< Back", "Finish", active = 0)\r
    fatal.cancel("Cancel", "Back", active = 0)\r
    fatal.text("Description1", 135, 70, 220, 80, 0x30003,\r
               "[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.")\r
    fatal.text("Description2", 135, 155, 220, 20, 0x30003,\r
               "Click the Finish button to exit the Installer.")\r
    c=fatal.next("Finish", "Cancel", name="Finish")\r
    # See "ControlEvent Table". Parameters are the event, the parameter\r
    # to the action, and optionally the condition for the event, and the order\r
    # of events.\r
    c.event("EndDialog", "Exit")\r
\r
    user_exit=PyDialog(db, "UserExit", x, y, w, h, modal, title,\r
                 "Finish", "Finish", "Finish")\r
    user_exit.title("[ProductName] Installer was interrupted")\r
    user_exit.back("< Back", "Finish", active = 0)\r
    user_exit.cancel("Cancel", "Back", active = 0)\r
    user_exit.text("Description1", 135, 70, 220, 80, 0x30003,\r
               "[ProductName] setup was interrupted.  Your system has not been modified.  "\r
               "To install this program at a later time, please run the installation again.")\r
    user_exit.text("Description2", 135, 155, 220, 20, 0x30003,\r
               "Click the Finish button to exit the Installer.")\r
    c = user_exit.next("Finish", "Cancel", name="Finish")\r
    c.event("EndDialog", "Exit")\r
\r
    exit_dialog = PyDialog(db, "ExitDialog", x, y, w, h, modal, title,\r
                         "Finish", "Finish", "Finish")\r
    exit_dialog.title("Completing the [ProductName] Installer")\r
    exit_dialog.back("< Back", "Finish", active = 0)\r
    exit_dialog.cancel("Cancel", "Back", active = 0)\r
    exit_dialog.text("Acknowledgements", 135, 95, 220, 120, 0x30003,\r
      "Special Windows thanks to:\n"\r
      "    Mark Hammond, without whose years of freely \n"\r
      "    shared Windows expertise, Python for Windows \n"\r
      "    would still be Python for DOS.")\r
\r
    c = exit_dialog.text("warning", 135, 200, 220, 40, 0x30003,\r
            "{\\VerdanaRed9}Warning: Python 3.3.0 is the last "\r
            "Python release for Windows 2000.")\r
    c.condition("Hide", "VersionNT > 500")\r
\r
    exit_dialog.text("Description", 135, 235, 220, 20, 0x30003,\r
               "Click the Finish button to exit the Installer.")\r
    c = exit_dialog.next("Finish", "Cancel", name="Finish")\r
    c.event("EndDialog", "Return")\r
\r
    #####################################################################\r
    # Required dialog: FilesInUse, ErrorDlg\r
    inuse = PyDialog(db, "FilesInUse",\r
                     x, y, w, h,\r
                     19,                # KeepModeless|Modal|Visible\r
                     title,\r
                     "Retry", "Retry", "Retry", bitmap=False)\r
    inuse.text("Title", 15, 6, 200, 15, 0x30003,\r
               r"{\DlgFontBold8}Files in Use")\r
    inuse.text("Description", 20, 23, 280, 20, 0x30003,\r
               "Some files that need to be updated are currently in use.")\r
    inuse.text("Text", 20, 55, 330, 50, 3,\r
               "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.")\r
    inuse.control("List", "ListBox", 20, 107, 330, 130, 7, "FileInUseProcess",\r
                  None, None, None)\r
    c=inuse.back("Exit", "Ignore", name="Exit")\r
    c.event("EndDialog", "Exit")\r
    c=inuse.next("Ignore", "Retry", name="Ignore")\r
    c.event("EndDialog", "Ignore")\r
    c=inuse.cancel("Retry", "Exit", name="Retry")\r
    c.event("EndDialog","Retry")\r
\r
\r
    # See "Error Dialog". See "ICE20" for the required names of the controls.\r
    error = Dialog(db, "ErrorDlg",\r
                   50, 10, 330, 101,\r
                   65543,       # Error|Minimize|Modal|Visible\r
                   title,\r
                   "ErrorText", None, None)\r
    error.text("ErrorText", 50,9,280,48,3, "")\r
    error.control("ErrorIcon", "Icon", 15, 9, 24, 24, 5242881, None, "py.ico", None, None)\r
    error.pushbutton("N",120,72,81,21,3,"No",None).event("EndDialog","ErrorNo")\r
    error.pushbutton("Y",240,72,81,21,3,"Yes",None).event("EndDialog","ErrorYes")\r
    error.pushbutton("A",0,72,81,21,3,"Abort",None).event("EndDialog","ErrorAbort")\r
    error.pushbutton("C",42,72,81,21,3,"Cancel",None).event("EndDialog","ErrorCancel")\r
    error.pushbutton("I",81,72,81,21,3,"Ignore",None).event("EndDialog","ErrorIgnore")\r
    error.pushbutton("O",159,72,81,21,3,"Ok",None).event("EndDialog","ErrorOk")\r
    error.pushbutton("R",198,72,81,21,3,"Retry",None).event("EndDialog","ErrorRetry")\r
\r
    #####################################################################\r
    # Global "Query Cancel" dialog\r
    cancel = Dialog(db, "CancelDlg", 50, 10, 260, 85, 3, title,\r
                    "No", "No", "No")\r
    cancel.text("Text", 48, 15, 194, 30, 3,\r
                "Are you sure you want to cancel [ProductName] installation?")\r
    cancel.control("Icon", "Icon", 15, 15, 24, 24, 5242881, None,\r
                   "py.ico", None, None)\r
    c=cancel.pushbutton("Yes", 72, 57, 56, 17, 3, "Yes", "No")\r
    c.event("EndDialog", "Exit")\r
\r
    c=cancel.pushbutton("No", 132, 57, 56, 17, 3, "No", "Yes")\r
    c.event("EndDialog", "Return")\r
\r
    #####################################################################\r
    # Global "Wait for costing" dialog\r
    costing = Dialog(db, "WaitForCostingDlg", 50, 10, 260, 85, modal, title,\r
                     "Return", "Return", "Return")\r
    costing.text("Text", 48, 15, 194, 30, 3,\r
                 "Please wait while the installer finishes determining your disk space requirements.")\r
    costing.control("Icon", "Icon", 15, 15, 24, 24, 5242881, None,\r
                    "py.ico", None, None)\r
    c = costing.pushbutton("Return", 102, 57, 56, 17, 3, "Return", None)\r
    c.event("EndDialog", "Exit")\r
\r
    #####################################################################\r
    # Preparation dialog: no user input except cancellation\r
    prep = PyDialog(db, "PrepareDlg", x, y, w, h, modeless, title,\r
                    "Cancel", "Cancel", "Cancel")\r
    prep.text("Description", 135, 70, 220, 40, 0x30003,\r
              "Please wait while the Installer prepares to guide you through the installation.")\r
    prep.title("Welcome to the [ProductName] Installer")\r
    c=prep.text("ActionText", 135, 110, 220, 20, 0x30003, "Pondering...")\r
    c.mapping("ActionText", "Text")\r
    c=prep.text("ActionData", 135, 135, 220, 30, 0x30003, None)\r
    c.mapping("ActionData", "Text")\r
    prep.back("Back", None, active=0)\r
    prep.next("Next", None, active=0)\r
    c=prep.cancel("Cancel", None)\r
    c.event("SpawnDialog", "CancelDlg")\r
\r
    #####################################################################\r
    # Target directory selection\r
    seldlg = PyDialog(db, "SelectDirectoryDlg", x, y, w, h, modal, title,\r
                    "Next", "Next", "Cancel")\r
    seldlg.title("Select Destination Directory")\r
    c = seldlg.text("Existing", 135, 25, 235, 30, 0x30003,\r
                    "{\VerdanaRed9}This update will replace your existing [ProductLine] installation.")\r
    c.condition("Hide", 'REMOVEOLDVERSION="" and REMOVEOLDSNAPSHOT=""')\r
    seldlg.text("Description", 135, 50, 220, 40, 0x30003,\r
               "Please select a directory for the [ProductName] files.")\r
\r
    seldlg.back("< Back", None, active=0)\r
    c = seldlg.next("Next >", "Cancel")\r
    c.event("DoAction", "CheckDir", "TargetExistsOk<>1", order=1)\r
    # If the target exists, but we found that we are going to remove old versions, don't bother\r
    # confirming that the target directory exists. Strictly speaking, we should determine that\r
    # the target directory is indeed the target of the product that we are going to remove, but\r
    # I don't know how to do that.\r
    c.event("SpawnDialog", "ExistingDirectoryDlg", 'TargetExists=1 and REMOVEOLDVERSION="" and REMOVEOLDSNAPSHOT=""', 2)\r
    c.event("SetTargetPath", "TARGETDIR", 'TargetExists=0 or REMOVEOLDVERSION<>"" or REMOVEOLDSNAPSHOT<>""', 3)\r
    c.event("SpawnWaitDialog", "WaitForCostingDlg", "CostingComplete=1", 4)\r
    c.event("NewDialog", "SelectFeaturesDlg", 'TargetExists=0 or REMOVEOLDVERSION<>"" or REMOVEOLDSNAPSHOT<>""', 5)\r
\r
    c = seldlg.cancel("Cancel", "DirectoryCombo")\r
    c.event("SpawnDialog", "CancelDlg")\r
\r
    seldlg.control("DirectoryCombo", "DirectoryCombo", 135, 70, 172, 80, 393219,\r
                   "TARGETDIR", None, "DirectoryList", None)\r
    seldlg.control("DirectoryList", "DirectoryList", 135, 90, 208, 136, 3, "TARGETDIR",\r
                   None, "PathEdit", None)\r
    seldlg.control("PathEdit", "PathEdit", 135, 230, 206, 16, 3, "TARGETDIR", None, "Next", None)\r
    c = seldlg.pushbutton("Up", 306, 70, 18, 18, 3, "Up", None)\r
    c.event("DirectoryListUp", "0")\r
    c = seldlg.pushbutton("NewDir", 324, 70, 30, 18, 3, "New", None)\r
    c.event("DirectoryListNew", "0")\r
\r
    #####################################################################\r
    # SelectFeaturesDlg\r
    features = PyDialog(db, "SelectFeaturesDlg", x, y, w, h, modal|track_disk_space,\r
                        title, "Tree", "Next", "Cancel")\r
    features.title("Customize [ProductName]")\r
    features.text("Description", 135, 35, 220, 15, 0x30003,\r
                  "Select the way you want features to be installed.")\r
    features.text("Text", 135,45,220,30, 3,\r
                  "Click on the icons in the tree below to change the way features will be installed.")\r
\r
    c=features.back("< Back", "Next")\r
    c.event("NewDialog", "SelectDirectoryDlg")\r
\r
    c=features.next("Next >", "Cancel")\r
    c.mapping("SelectionNoItems", "Enabled")\r
    c.event("SpawnDialog", "DiskCostDlg", "OutOfDiskSpace=1", order=1)\r
    c.event("EndDialog", "Return", "OutOfDiskSpace<>1", order=2)\r
\r
    c=features.cancel("Cancel", "Tree")\r
    c.event("SpawnDialog", "CancelDlg")\r
\r
    # The browse property is not used, since we have only a single target path (selected already)\r
    features.control("Tree", "SelectionTree", 135, 75, 220, 95, 7, "_BrowseProperty",\r
                     "Tree of selections", "Back", None)\r
\r
    #c=features.pushbutton("Reset", 42, 243, 56, 17, 3, "Reset", "DiskCost")\r
    #c.mapping("SelectionNoItems", "Enabled")\r
    #c.event("Reset", "0")\r
\r
    features.control("Box", "GroupBox", 135, 170, 225, 90, 1, None, None, None, None)\r
\r
    c=features.xbutton("DiskCost", "Disk &Usage", None, 0.10)\r
    c.mapping("SelectionNoItems","Enabled")\r
    c.event("SpawnDialog", "DiskCostDlg")\r
\r
    c=features.xbutton("Advanced", "Advanced", None, 0.30)\r
    c.event("SpawnDialog", "AdvancedDlg")\r
\r
    c=features.text("ItemDescription", 140, 180, 210, 30, 3,\r
                  "Multiline description of the currently selected item.")\r
    c.mapping("SelectionDescription","Text")\r
\r
    c=features.text("ItemSize", 140, 210, 210, 45, 3,\r
                    "The size of the currently selected item.")\r
    c.mapping("SelectionSize", "Text")\r
\r
    #####################################################################\r
    # Disk cost\r
    cost = PyDialog(db, "DiskCostDlg", x, y, w, h, modal, title,\r
                    "OK", "OK", "OK", bitmap=False)\r
    cost.text("Title", 15, 6, 200, 15, 0x30003,\r
              "{\DlgFontBold8}Disk Space Requirements")\r
    cost.text("Description", 20, 20, 280, 20, 0x30003,\r
              "The disk space required for the installation of the selected features.")\r
    cost.text("Text", 20, 53, 330, 60, 3,\r
              "The highlighted volumes (if any) do not have enough disk space "\r
              "available for the currently selected features.  You can either "\r
              "remove some files from the highlighted volumes, or choose to "\r
              "install less features onto local drive(s), or select different "\r
              "destination drive(s).")\r
    cost.control("VolumeList", "VolumeCostList", 20, 100, 330, 150, 393223,\r
                 None, "{120}{70}{70}{70}{70}", None, None)\r
    cost.xbutton("OK", "Ok", None, 0.5).event("EndDialog", "Return")\r
\r
    #####################################################################\r
    # WhichUsers Dialog. Only available on NT, and for privileged users.\r
    # This must be run before FindRelatedProducts, because that will\r
    # take into account whether the previous installation was per-user\r
    # or per-machine. We currently don't support going back to this\r
    # dialog after "Next" was selected; to support this, we would need to\r
    # find how to reset the ALLUSERS property, and how to re-run\r
    # FindRelatedProducts.\r
    # On Windows9x, the ALLUSERS property is ignored on the command line\r
    # and in the Property table, but installer fails according to the documentation\r
    # if a dialog attempts to set ALLUSERS.\r
    whichusers = PyDialog(db, "WhichUsersDlg", x, y, w, h, modal, title,\r
                        "AdminInstall", "Next", "Cancel")\r
    whichusers.title("Select whether to install [ProductName] for all users of this computer.")\r
    # A radio group with two options: allusers, justme\r
    g = whichusers.radiogroup("AdminInstall", 135, 60, 235, 80, 3,\r
                              "WhichUsers", "", "Next")\r
    g.condition("Disable", "VersionNT=600") # Not available on Vista and Windows 2008\r
    g.add("ALL", 0, 5, 150, 20, "Install for all users")\r
    g.add("JUSTME", 0, 25, 235, 20, "Install just for me (not available on Windows Vista)")\r
\r
    whichusers.back("Back", None, active=0)\r
\r
    c = whichusers.next("Next >", "Cancel")\r
    c.event("[ALLUSERS]", "1", 'WhichUsers="ALL"', 1)\r
    c.event("EndDialog", "Return", order = 2)\r
\r
    c = whichusers.cancel("Cancel", "AdminInstall")\r
    c.event("SpawnDialog", "CancelDlg")\r
\r
    #####################################################################\r
    # Advanced Dialog.\r
    advanced = PyDialog(db, "AdvancedDlg", x, y, w, h, modal, title,\r
                        "CompilePyc", "Ok", "Ok")\r
    advanced.title("Advanced Options for [ProductName]")\r
    # A radio group with two options: allusers, justme\r
    advanced.checkbox("CompilePyc", 135, 60, 230, 50, 3,\r
                      "COMPILEALL", "Compile .py files to byte code after installation", "Ok")\r
\r
    c = advanced.cancel("Ok", "CompilePyc", name="Ok") # Button just has location of cancel button.\r
    c.event("EndDialog", "Return")\r
\r
    #####################################################################\r
    # Existing Directory dialog\r
    dlg = Dialog(db, "ExistingDirectoryDlg", 50, 30, 200, 80, modal, title,\r
                   "No", "No", "No")\r
    dlg.text("Title", 10, 20, 180, 40, 3,\r
             "[TARGETDIR] exists. Are you sure you want to overwrite existing files?")\r
    c=dlg.pushbutton("Yes", 30, 60, 55, 17, 3, "Yes", "No")\r
    c.event("[TargetExists]", "0", order=1)\r
    c.event("[TargetExistsOk]", "1", order=2)\r
    c.event("EndDialog", "Return", order=3)\r
    c=dlg.pushbutton("No", 115, 60, 55, 17, 3, "No", "Yes")\r
    c.event("EndDialog", "Return")\r
\r
    #####################################################################\r
    # Installation Progress dialog (modeless)\r
    progress = PyDialog(db, "ProgressDlg", x, y, w, h, modeless, title,\r
                        "Cancel", "Cancel", "Cancel", bitmap=False)\r
    progress.text("Title", 20, 15, 200, 15, 0x30003,\r
                  "{\DlgFontBold8}[Progress1] [ProductName]")\r
    progress.text("Text", 35, 65, 300, 30, 3,\r
                  "Please wait while the Installer [Progress2] [ProductName]. "\r
                  "This may take several minutes.")\r
    progress.text("StatusLabel", 35, 100, 35, 20, 3, "Status:")\r
\r
    c=progress.text("ActionText", 70, 100, w-70, 20, 3, "Pondering...")\r
    c.mapping("ActionText", "Text")\r
\r
    #c=progress.text("ActionData", 35, 140, 300, 20, 3, None)\r
    #c.mapping("ActionData", "Text")\r
\r
    c=progress.control("ProgressBar", "ProgressBar", 35, 120, 300, 10, 65537,\r
                       None, "Progress done", None, None)\r
    c.mapping("SetProgress", "Progress")\r
\r
    progress.back("< Back", "Next", active=False)\r
    progress.next("Next >", "Cancel", active=False)\r
    progress.cancel("Cancel", "Back").event("SpawnDialog", "CancelDlg")\r
\r
    # Maintenance type: repair/uninstall\r
    maint = PyDialog(db, "MaintenanceTypeDlg", x, y, w, h, modal, title,\r
                     "Next", "Next", "Cancel")\r
    maint.title("Welcome to the [ProductName] Setup Wizard")\r
    maint.text("BodyText", 135, 63, 230, 42, 3,\r
               "Select whether you want to repair or remove [ProductName].")\r
    g=maint.radiogroup("RepairRadioGroup", 135, 108, 230, 60, 3,\r
                        "MaintenanceForm_Action", "", "Next")\r
    g.add("Change", 0, 0, 200, 17, "&Change [ProductName]")\r
    g.add("Repair", 0, 18, 200, 17, "&Repair [ProductName]")\r
    g.add("Remove", 0, 36, 200, 17, "Re&move [ProductName]")\r
\r
    maint.back("< Back", None, active=False)\r
    c=maint.next("Finish", "Cancel")\r
    # Change installation: Change progress dialog to "Change", then ask\r
    # for feature selection\r
    c.event("[Progress1]", "Change", 'MaintenanceForm_Action="Change"', 1)\r
    c.event("[Progress2]", "changes", 'MaintenanceForm_Action="Change"', 2)\r
\r
    # Reinstall: Change progress dialog to "Repair", then invoke reinstall\r
    # Also set list of reinstalled features to "ALL"\r
    c.event("[REINSTALL]", "ALL", 'MaintenanceForm_Action="Repair"', 5)\r
    c.event("[Progress1]", "Repairing", 'MaintenanceForm_Action="Repair"', 6)\r
    c.event("[Progress2]", "repairs", 'MaintenanceForm_Action="Repair"', 7)\r
    c.event("Reinstall", "ALL", 'MaintenanceForm_Action="Repair"', 8)\r
\r
    # Uninstall: Change progress to "Remove", then invoke uninstall\r
    # Also set list of removed features to "ALL"\r
    c.event("[REMOVE]", "ALL", 'MaintenanceForm_Action="Remove"', 11)\r
    c.event("[Progress1]", "Removing", 'MaintenanceForm_Action="Remove"', 12)\r
    c.event("[Progress2]", "removes", 'MaintenanceForm_Action="Remove"', 13)\r
    c.event("Remove", "ALL", 'MaintenanceForm_Action="Remove"', 14)\r
\r
    # Close dialog when maintenance action scheduled\r
    c.event("EndDialog", "Return", 'MaintenanceForm_Action<>"Change"', 20)\r
    c.event("NewDialog", "SelectFeaturesDlg", 'MaintenanceForm_Action="Change"', 21)\r
\r
    maint.cancel("Cancel", "RepairRadioGroup").event("SpawnDialog", "CancelDlg")\r
\r
\r
# See "Feature Table". The feature level is 1 for all features,\r
# and the feature attributes are 0 for the DefaultFeature, and\r
# FollowParent for all other features. The numbers are the Display\r
# column.\r
def add_features(db):\r
    # feature attributes:\r
    # msidbFeatureAttributesFollowParent == 2\r
    # msidbFeatureAttributesDisallowAdvertise == 8\r
    # Features that need to be installed with together with the main feature\r
    # (i.e. additional Python libraries) need to follow the parent feature.\r
    # Features that have no advertisement trigger (e.g. the test suite)\r
    # must not support advertisement\r
    global default_feature, tcltk, htmlfiles, tools, testsuite, ext_feature, private_crt\r
    default_feature = Feature(db, "DefaultFeature", "Python",\r
                              "Python Interpreter and Libraries",\r
                              1, directory = "TARGETDIR")\r
    shared_crt = Feature(db, "SharedCRT", "MSVCRT", "C Run-Time (system-wide)", 0,\r
                         level=0)\r
    private_crt = Feature(db, "PrivateCRT", "MSVCRT", "C Run-Time (private)", 0,\r
                          level=0)\r
    add_data(db, "Condition", [("SharedCRT", 1, sys32cond),\r
                               ("PrivateCRT", 1, "not "+sys32cond)])\r
    # We don't support advertisement of extensions\r
    ext_feature = Feature(db, "Extensions", "Register Extensions",\r
                          "Make this Python installation the default Python installation", 3,\r
                         parent = default_feature, attributes=2|8)\r
    if have_tcl:\r
        tcltk = Feature(db, "TclTk", "Tcl/Tk", "Tkinter, IDLE, pydoc", 5,\r
                    parent = default_feature, attributes=2)\r
    htmlfiles = Feature(db, "Documentation", "Documentation",\r
                        "Python HTMLHelp File", 7, parent = default_feature)\r
    tools = Feature(db, "Tools", "Utility Scripts",\r
                    "Python utility scripts (Tools/", 9,\r
                    parent = default_feature, attributes=2)\r
    testsuite = Feature(db, "Testsuite", "Test suite",\r
                        "Python test suite (Lib/test/)", 11,\r
                        parent = default_feature, attributes=2|8)\r
\r
def extract_msvcr90():\r
    # Find the redistributable files\r
    if msilib.Win64:\r
        arch = "amd64"\r
    else:\r
        arch = "x86"\r
    dir = os.path.join(os.environ['VS90COMNTOOLS'], r"..\..\VC\redist\%s\Microsoft.VC90.CRT" % arch)\r
\r
    result = []\r
    installer = msilib.MakeInstaller()\r
    # omit msvcm90 and msvcp90, as they aren't really needed\r
    files = ["Microsoft.VC90.CRT.manifest", "msvcr90.dll"]\r
    for f in files:\r
        path = os.path.join(dir, f)\r
        kw = {'src':path}\r
        if f.endswith('.dll'):\r
            kw['version'] = installer.FileVersion(path, 0)\r
            kw['language'] = installer.FileVersion(path, 1)\r
        result.append((f, kw))\r
    return result\r
\r
def generate_license():\r
    import shutil, glob\r
    out = open("LICENSE.txt", "w")\r
    shutil.copyfileobj(open(os.path.join(srcdir, "LICENSE")), out)\r
    shutil.copyfileobj(open("crtlicense.txt"), out)\r
    for name, pat, file in (("bzip2","bzip2-*", "LICENSE"),\r
                      ("Berkeley DB", "db-*", "LICENSE"),\r
                      ("openssl", "openssl-*", "LICENSE"),\r
                      ("Tcl", "tcl8*", "license.terms"),\r
                      ("Tk", "tk8*", "license.terms"),\r
                      ("Tix", "tix-*", "license.terms")):\r
        out.write("\nThis copy of Python includes a copy of %s, which is licensed under the following terms:\n\n" % name)\r
        dirs = glob.glob(srcdir+"/../"+pat)\r
        if not dirs:\r
            raise ValueError, "Could not find "+srcdir+"/../"+pat\r
        if len(dirs) > 2:\r
            raise ValueError, "Multiple copies of "+pat\r
        dir = dirs[0]\r
        shutil.copyfileobj(open(os.path.join(dir, file)), out)\r
    out.close()\r
\r
\r
class PyDirectory(Directory):\r
    """By default, all components in the Python installer\r
    can run from source."""\r
    def __init__(self, *args, **kw):\r
        if not kw.has_key("componentflags"):\r
            kw['componentflags'] = 2 #msidbComponentAttributesOptional\r
        Directory.__init__(self, *args, **kw)\r
\r
# See "File Table", "Component Table", "Directory Table",\r
# "FeatureComponents Table"\r
def add_files(db):\r
    cab = CAB("python")\r
    tmpfiles = []\r
    # Add all executables, icons, text files into the TARGETDIR component\r
    root = PyDirectory(db, cab, None, srcdir, "TARGETDIR", "SourceDir")\r
    default_feature.set_current()\r
    if not msilib.Win64:\r
        root.add_file("%s/w9xpopen.exe" % PCBUILD)\r
    root.add_file("README.txt", src="README")\r
    root.add_file("NEWS.txt", src="Misc/NEWS")\r
    generate_license()\r
    root.add_file("LICENSE.txt", src=os.path.abspath("LICENSE.txt"))\r
    root.start_component("python.exe", keyfile="python.exe")\r
    root.add_file("%s/python.exe" % PCBUILD)\r
    root.start_component("pythonw.exe", keyfile="pythonw.exe")\r
    root.add_file("%s/pythonw.exe" % PCBUILD)\r
\r
    # msidbComponentAttributesSharedDllRefCount = 8, see "Component Table"\r
    dlldir = PyDirectory(db, cab, root, srcdir, "DLLDIR", ".")\r
\r
    pydll = "python%s%s.dll" % (major, minor)\r
    pydllsrc = os.path.join(srcdir, PCBUILD, pydll)\r
    dlldir.start_component("DLLDIR", flags = 8, keyfile = pydll, uuid = pythondll_uuid)\r
    installer = msilib.MakeInstaller()\r
    pyversion = installer.FileVersion(pydllsrc, 0)\r
    if not snapshot:\r
        # For releases, the Python DLL has the same version as the\r
        # installer package.\r
        assert pyversion.split(".")[:3] == current_version.split(".")\r
    dlldir.add_file("%s/python%s%s.dll" % (PCBUILD, major, minor),\r
                    version=pyversion,\r
                    language=installer.FileVersion(pydllsrc, 1))\r
    DLLs = PyDirectory(db, cab, root, srcdir + "/" + PCBUILD, "DLLs", "DLLS|DLLs")\r
\r
    # msvcr90.dll: Need to place the DLL and the manifest into the root directory,\r
    # plus another copy of the manifest in the DLLs directory, with the manifest\r
    # pointing to the root directory\r
    root.start_component("msvcr90", feature=private_crt)\r
    # Results are ID,keyword pairs\r
    manifest, crtdll = extract_msvcr90()\r
    root.add_file(manifest[0], **manifest[1])\r
    root.add_file(crtdll[0], **crtdll[1])\r
    # Copy the manifest\r
    # Actually, don't do that anymore - no DLL in DLLs should have a manifest\r
    # dependency on msvcr90.dll anymore, so this should not be necessary\r
    #manifest_dlls = manifest[0]+".root"\r
    #open(manifest_dlls, "w").write(open(manifest[1]['src']).read().replace("msvcr","../msvcr"))\r
    #DLLs.start_component("msvcr90_dlls", feature=private_crt)\r
    #DLLs.add_file(manifest[0], src=os.path.abspath(manifest_dlls))\r
\r
    # Now start the main component for the DLLs directory;\r
    # no regular files have been added to the directory yet.\r
    DLLs.start_component()\r
\r
    # Check if _ctypes.pyd exists\r
    have_ctypes = os.path.exists(srcdir+"/%s/_ctypes.pyd" % PCBUILD)\r
    if not have_ctypes:\r
        print "WARNING: _ctypes.pyd not found, ctypes will not be included"\r
        extensions.remove("_ctypes.pyd")\r
\r
    # Add all .py files in Lib, except lib-tk, test\r
    dirs={}\r
    pydirs = [(root,"Lib")]\r
    while pydirs:\r
        # Commit every now and then, or else installer will complain\r
        db.Commit()\r
        parent, dir = pydirs.pop()\r
        if dir == ".svn" or dir.startswith("plat-"):\r
            continue\r
        elif dir in ["lib-tk", "idlelib", "Icons"]:\r
            if not have_tcl:\r
                continue\r
            tcltk.set_current()\r
        elif dir in ['test', 'tests', 'data', 'output']:\r
            # test: Lib, Lib/email, Lib/bsddb, Lib/ctypes, Lib/sqlite3\r
            # tests: Lib/distutils\r
            # data: Lib/email/test\r
            # output: Lib/test\r
            testsuite.set_current()\r
        elif not have_ctypes and dir == "ctypes":\r
            continue\r
        else:\r
            default_feature.set_current()\r
        lib = PyDirectory(db, cab, parent, dir, dir, "%s|%s" % (parent.make_short(dir), dir))\r
        # Add additional files\r
        dirs[dir]=lib\r
        lib.glob("*.txt")\r
        if dir=='site-packages':\r
            lib.add_file("README.txt", src="README")\r
            continue\r
        files = lib.glob("*.py")\r
        files += lib.glob("*.pyw")\r
        if files:\r
            # Add an entry to the RemoveFile table to remove bytecode files.\r
            lib.remove_pyc()\r
        if dir.endswith('.egg-info'):\r
            lib.add_file('entry_points.txt')\r
            lib.add_file('PKG-INFO')\r
            lib.add_file('top_level.txt')\r
            lib.add_file('zip-safe')\r
            continue\r
        if dir=='test' and parent.physical=='Lib':\r
            lib.add_file("185test.db")\r
            lib.add_file("audiotest.au")\r
            lib.add_file("cfgparser.1")\r
            lib.add_file("sgml_input.html")\r
            lib.add_file("testtar.tar")\r
            lib.add_file("test_difflib_expect.html")\r
            lib.add_file("check_soundcard.vbs")\r
            lib.add_file("empty.vbs")\r
            lib.add_file("Sine-1000Hz-300ms.aif")\r
            lib.glob("*.uue")\r
            lib.glob("*.pem")\r
            lib.glob("*.pck")\r
            lib.add_file("zipdir.zip")\r
        if dir=='tests' and parent.physical=='distutils':\r
            lib.add_file("Setup.sample")\r
        if dir=='decimaltestdata':\r
            lib.glob("*.decTest")\r
        if dir=='xmltestdata':\r
            lib.glob("*.xml")\r
            lib.add_file("test.xml.out")\r
        if dir=='output':\r
            lib.glob("test_*")\r
        if dir=='idlelib':\r
            lib.glob("*.def")\r
            lib.add_file("idle.bat")\r
        if dir=="Icons":\r
            lib.glob("*.gif")\r
            lib.add_file("idle.icns")\r
        if dir=="command" and parent.physical=="distutils":\r
            lib.glob("wininst*.exe")\r
        if dir=="setuptools":\r
            lib.add_file("cli.exe")\r
            lib.add_file("gui.exe")\r
        if dir=="lib2to3":\r
            lib.removefile("pickle", "*.pickle")\r
        if dir=="data" and parent.physical=="test" and parent.basedir.physical=="email":\r
            # This should contain all non-.svn files listed in subversion\r
            for f in os.listdir(lib.absolute):\r
                if f.endswith(".txt") or f==".svn":continue\r
                if f.endswith(".au") or f.endswith(".gif"):\r
                    lib.add_file(f)\r
                else:\r
                    print "WARNING: New file %s in email/test/data" % f\r
        for f in os.listdir(lib.absolute):\r
            if os.path.isdir(os.path.join(lib.absolute, f)):\r
                pydirs.append((lib, f))\r
    # Add DLLs\r
    default_feature.set_current()\r
    lib = DLLs\r
    lib.add_file("py.ico", src=srcdir+"/PC/py.ico")\r
    lib.add_file("pyc.ico", src=srcdir+"/PC/pyc.ico")\r
    dlls = []\r
    tclfiles = []\r
    for f in extensions:\r
        if f=="_tkinter.pyd":\r
            continue\r
        if not os.path.exists(srcdir + "/" + PCBUILD + "/" + f):\r
            print "WARNING: Missing extension", f\r
            continue\r
        dlls.append(f)\r
        lib.add_file(f)\r
    # Add sqlite\r
    if msilib.msi_type=="Intel64;1033":\r
        sqlite_arch = "/ia64"\r
    elif msilib.msi_type=="x64;1033":\r
        sqlite_arch = "/amd64"\r
        tclsuffix = "64"\r
    else:\r
        sqlite_arch = ""\r
        tclsuffix = ""\r
    lib.add_file("sqlite3.dll")\r
    if have_tcl:\r
        if not os.path.exists("%s/%s/_tkinter.pyd" % (srcdir, PCBUILD)):\r
            print "WARNING: Missing _tkinter.pyd"\r
        else:\r
            lib.start_component("TkDLLs", tcltk)\r
            lib.add_file("_tkinter.pyd")\r
            dlls.append("_tkinter.pyd")\r
            tcldir = os.path.normpath(srcdir+("/../tcltk%s/bin" % tclsuffix))\r
            for f in glob.glob1(tcldir, "*.dll"):\r
                lib.add_file(f, src=os.path.join(tcldir, f))\r
    # check whether there are any unknown extensions\r
    for f in glob.glob1(srcdir+"/"+PCBUILD, "*.pyd"):\r
        if f.endswith("_d.pyd"): continue # debug version\r
        if f in dlls: continue\r
        print "WARNING: Unknown extension", f\r
\r
    # Add headers\r
    default_feature.set_current()\r
    lib = PyDirectory(db, cab, root, "include", "include", "INCLUDE|include")\r
    lib.glob("*.h")\r
    lib.add_file("pyconfig.h", src="../PC/pyconfig.h")\r
    # Add import libraries\r
    lib = PyDirectory(db, cab, root, PCBUILD, "libs", "LIBS|libs")\r
    for f in dlls:\r
        lib.add_file(f.replace('pyd','lib'))\r
    lib.add_file('python%s%s.lib' % (major, minor))\r
    # Add the mingw-format library\r
    if have_mingw:\r
        lib.add_file('libpython%s%s.a' % (major, minor))\r
    if have_tcl:\r
        # Add Tcl/Tk\r
        tcldirs = [(root, '../tcltk%s/lib' % tclsuffix, 'tcl')]\r
        tcltk.set_current()\r
        while tcldirs:\r
            parent, phys, dir = tcldirs.pop()\r
            lib = PyDirectory(db, cab, parent, phys, dir, "%s|%s" % (parent.make_short(dir), dir))\r
            if not os.path.exists(lib.absolute):\r
                continue\r
            for f in os.listdir(lib.absolute):\r
                if os.path.isdir(os.path.join(lib.absolute, f)):\r
                    tcldirs.append((lib, f, f))\r
                else:\r
                    lib.add_file(f)\r
    # Add tools\r
    tools.set_current()\r
    tooldir = PyDirectory(db, cab, root, "Tools", "Tools", "TOOLS|Tools")\r
    for f in ['i18n', 'pynche', 'Scripts', 'versioncheck', 'webchecker']:\r
        lib = PyDirectory(db, cab, tooldir, f, f, "%s|%s" % (tooldir.make_short(f), f))\r
        lib.glob("*.py")\r
        lib.glob("*.pyw", exclude=['pydocgui.pyw'])\r
        lib.remove_pyc()\r
        lib.glob("*.txt")\r
        if f == "pynche":\r
            x = PyDirectory(db, cab, lib, "X", "X", "X|X")\r
            x.glob("*.txt")\r
        if os.path.exists(os.path.join(lib.absolute, "README")):\r
            lib.add_file("README.txt", src="README")\r
        if f == 'Scripts':\r
            lib.add_file("2to3.py", src="2to3")\r
            if have_tcl:\r
                lib.start_component("pydocgui.pyw", tcltk, keyfile="pydocgui.pyw")\r
                lib.add_file("pydocgui.pyw")\r
    # Add documentation\r
    htmlfiles.set_current()\r
    lib = PyDirectory(db, cab, root, "Doc", "Doc", "DOC|Doc")\r
    lib.start_component("documentation", keyfile=docfile)\r
    lib.add_file(docfile, src="build/htmlhelp/"+docfile)\r
\r
    cab.commit(db)\r
\r
    for f in tmpfiles:\r
        os.unlink(f)\r
\r
# See "Registry Table", "Component Table"\r
def add_registry(db):\r
    # File extensions, associated with the REGISTRY.def component\r
    # IDLE verbs depend on the tcltk feature.\r
    # msidbComponentAttributesRegistryKeyPath = 4\r
    # -1 for Root specifies "dependent on ALLUSERS property"\r
    tcldata = []\r
    if have_tcl:\r
        tcldata = [\r
            ("REGISTRY.tcl", msilib.gen_uuid(), "TARGETDIR", registry_component, None,\r
             "py.IDLE")]\r
    add_data(db, "Component",\r
             # msidbComponentAttributesRegistryKeyPath = 4\r
             [("REGISTRY", msilib.gen_uuid(), "TARGETDIR", registry_component, None,\r
               "InstallPath"),\r
              ("REGISTRY.doc", msilib.gen_uuid(), "TARGETDIR", registry_component, None,\r
               "Documentation"),\r
              ("REGISTRY.def", msilib.gen_uuid(), "TARGETDIR", registry_component,\r
               None, None)] + tcldata)\r
    # See "FeatureComponents Table".\r
    # The association between TclTk and pythonw.exe is necessary to make ICE59\r
    # happy, because the installer otherwise believes that the IDLE and PyDoc\r
    # shortcuts might get installed without pythonw.exe being install. This\r
    # is not true, since installing TclTk will install the default feature, which\r
    # will cause pythonw.exe to be installed.\r
    # REGISTRY.tcl is not associated with any feature, as it will be requested\r
    # through a custom action\r
    tcldata = []\r
    if have_tcl:\r
        tcldata = [(tcltk.id, "pythonw.exe")]\r
    add_data(db, "FeatureComponents",\r
             [(default_feature.id, "REGISTRY"),\r
              (htmlfiles.id, "REGISTRY.doc"),\r
              (ext_feature.id, "REGISTRY.def")] +\r
              tcldata\r
              )\r
    # Extensions are not advertised. For advertised extensions,\r
    # we would need separate binaries that install along with the\r
    # extension.\r
    pat = r"Software\Classes\%sPython.%sFile\shell\%s\command"\r
    ewi = "Edit with IDLE"\r
    pat2 = r"Software\Classes\%sPython.%sFile\DefaultIcon"\r
    pat3 = r"Software\Classes\%sPython.%sFile"\r
    pat4 = r"Software\Classes\%sPython.%sFile\shellex\DropHandler"\r
    tcl_verbs = []\r
    if have_tcl:\r
        tcl_verbs=[\r
             ("py.IDLE", -1, pat % (testprefix, "", ewi), "",\r
              r'"[TARGETDIR]pythonw.exe" "[TARGETDIR]Lib\idlelib\idle.pyw" -e "%1"',\r
              "REGISTRY.tcl"),\r
             ("pyw.IDLE", -1, pat % (testprefix, "NoCon", ewi), "",\r
              r'"[TARGETDIR]pythonw.exe" "[TARGETDIR]Lib\idlelib\idle.pyw" -e "%1"',\r
              "REGISTRY.tcl"),\r
        ]\r
    add_data(db, "Registry",\r
            [# Extensions\r
             ("py.ext", -1, r"Software\Classes\."+ext, "",\r
              "Python.File", "REGISTRY.def"),\r
             ("pyw.ext", -1, r"Software\Classes\."+ext+'w', "",\r
              "Python.NoConFile", "REGISTRY.def"),\r
             ("pyc.ext", -1, r"Software\Classes\."+ext+'c', "",\r
              "Python.CompiledFile", "REGISTRY.def"),\r
             ("pyo.ext", -1, r"Software\Classes\."+ext+'o', "",\r
              "Python.CompiledFile", "REGISTRY.def"),\r
             # MIME types\r
             ("py.mime", -1, r"Software\Classes\."+ext, "Content Type",\r
              "text/plain", "REGISTRY.def"),\r
             ("pyw.mime", -1, r"Software\Classes\."+ext+'w', "Content Type",\r
              "text/plain", "REGISTRY.def"),\r
             #Verbs\r
             ("py.open", -1, pat % (testprefix, "", "open"), "",\r
              r'"[TARGETDIR]python.exe" "%1" %*', "REGISTRY.def"),\r
             ("pyw.open", -1, pat % (testprefix, "NoCon", "open"), "",\r
              r'"[TARGETDIR]pythonw.exe" "%1" %*', "REGISTRY.def"),\r
             ("pyc.open", -1, pat % (testprefix, "Compiled", "open"), "",\r
              r'"[TARGETDIR]python.exe" "%1" %*', "REGISTRY.def"),\r
             ] + tcl_verbs + [\r
             #Icons\r
             ("py.icon", -1, pat2 % (testprefix, ""), "",\r
              r'[DLLs]py.ico', "REGISTRY.def"),\r
             ("pyw.icon", -1, pat2 % (testprefix, "NoCon"), "",\r
              r'[DLLs]py.ico', "REGISTRY.def"),\r
             ("pyc.icon", -1, pat2 % (testprefix, "Compiled"), "",\r
              r'[DLLs]pyc.ico', "REGISTRY.def"),\r
             # Descriptions\r
             ("py.txt", -1, pat3 % (testprefix, ""), "",\r
              "Python File", "REGISTRY.def"),\r
             ("pyw.txt", -1, pat3 % (testprefix, "NoCon"), "",\r
              "Python File (no console)", "REGISTRY.def"),\r
             ("pyc.txt", -1, pat3 % (testprefix, "Compiled"), "",\r
              "Compiled Python File", "REGISTRY.def"),\r
             # Drop Handler\r
             ("py.drop", -1, pat4 % (testprefix, ""), "",\r
              "{60254CA5-953B-11CF-8C96-00AA00B8708C}", "REGISTRY.def"),\r
             ("pyw.drop", -1, pat4 % (testprefix, "NoCon"), "",\r
              "{60254CA5-953B-11CF-8C96-00AA00B8708C}", "REGISTRY.def"),\r
             ("pyc.drop", -1, pat4 % (testprefix, "Compiled"), "",\r
              "{60254CA5-953B-11CF-8C96-00AA00B8708C}", "REGISTRY.def"),\r
            ])\r
\r
    # Registry keys\r
    prefix = r"Software\%sPython\PythonCore\%s" % (testprefix, short_version)\r
    add_data(db, "Registry",\r
             [("InstallPath", -1, prefix+r"\InstallPath", "", "[TARGETDIR]", "REGISTRY"),\r
              ("InstallGroup", -1, prefix+r"\InstallPath\InstallGroup", "",\r
               "Python %s" % short_version, "REGISTRY"),\r
              ("PythonPath", -1, prefix+r"\PythonPath", "",\r
               r"[TARGETDIR]Lib;[TARGETDIR]DLLs;[TARGETDIR]Lib\lib-tk", "REGISTRY"),\r
              ("Documentation", -1, prefix+r"\Help\Main Python Documentation", "",\r
               "[TARGETDIR]Doc\\"+docfile , "REGISTRY.doc"),\r
              ("Modules", -1, prefix+r"\Modules", "+", None, "REGISTRY"),\r
              ("AppPaths", -1, r"Software\Microsoft\Windows\CurrentVersion\App Paths\Python.exe",\r
               "", r"[TARGETDIR]Python.exe", "REGISTRY.def"),\r
              ("DisplayIcon", -1,\r
               r"Software\Microsoft\Windows\CurrentVersion\Uninstall\%s" % product_code,\r
               "DisplayIcon", "[TARGETDIR]python.exe", "REGISTRY")\r
              ])\r
    # Shortcuts, see "Shortcut Table"\r
    add_data(db, "Directory",\r
             [("ProgramMenuFolder", "TARGETDIR", "."),\r
              ("MenuDir", "ProgramMenuFolder", "PY%s%s|%sPython %s.%s" % (major,minor,testprefix,major,minor))])\r
    add_data(db, "RemoveFile",\r
             [("MenuDir", "TARGETDIR", None, "MenuDir", 2)])\r
    tcltkshortcuts = []\r
    if have_tcl:\r
        tcltkshortcuts = [\r
              ("IDLE", "MenuDir", "IDLE|IDLE (Python GUI)", "pythonw.exe",\r
               tcltk.id, r'"[TARGETDIR]Lib\idlelib\idle.pyw"', None, None, "python_icon.exe", 0, None, "TARGETDIR"),\r
              ("PyDoc", "MenuDir", "MODDOCS|Module Docs", "pythonw.exe",\r
               tcltk.id, r'"[TARGETDIR]Tools\scripts\pydocgui.pyw"', None, None, "python_icon.exe", 0, None, "TARGETDIR"),\r
              ]\r
    add_data(db, "Shortcut",\r
             tcltkshortcuts +\r
             [# Advertised shortcuts: targets are features, not files\r
              ("Python", "MenuDir", "PYTHON|Python (command line)", "python.exe",\r
               default_feature.id, None, None, None, "python_icon.exe", 2, None, "TARGETDIR"),\r
              # Advertising the Manual breaks on (some?) Win98, and the shortcut lacks an\r
              # icon first.\r
              #("Manual", "MenuDir", "MANUAL|Python Manuals", "documentation",\r
              # htmlfiles.id, None, None, None, None, None, None, None),\r
              ## Non-advertised shortcuts: must be associated with a registry component\r
              ("Manual", "MenuDir", "MANUAL|Python Manuals", "REGISTRY.doc",\r
               "[#%s]" % docfile, None,\r
               None, None, None, None, None, None),\r
              ("Uninstall", "MenuDir", "UNINST|Uninstall Python", "REGISTRY",\r
               SystemFolderName+"msiexec",  "/x%s" % product_code,\r
               None, None, None, None, None, None),\r
              ])\r
    db.Commit()\r
\r
def build_pdbzip():\r
    pdbexclude = ['kill_python.pdb', 'make_buildinfo.pdb',\r
                  'make_versioninfo.pdb']\r
    path = "python-%s%s-pdb.zip" % (full_current_version, msilib.arch_ext)\r
    pdbzip = zipfile.ZipFile(path, 'w')\r
    for f in glob.glob1(os.path.join(srcdir, PCBUILD), "*.pdb"):\r
        if f not in pdbexclude and not f.endswith('_d.pdb'):\r
            pdbzip.write(os.path.join(srcdir, PCBUILD, f), f)\r
    pdbzip.close()\r
\r
db,msiname = build_database()\r
try:\r
    add_features(db)\r
    add_ui(db)\r
    add_files(db)\r
    add_registry(db)\r
    remove_old_versions(db)\r
    db.Commit()\r
finally:\r
    del db\r
\r
# Merge CRT into MSI file. This requires the database to be closed.\r
mod_dir = os.path.join(os.environ["ProgramFiles"], "Common Files", "Merge Modules")\r
if msilib.Win64:\r
    modules = ["Microsoft_VC90_CRT_x86_x64.msm", "policy_9_0_Microsoft_VC90_CRT_x86_x64.msm"]\r
else:\r
    modules = ["Microsoft_VC90_CRT_x86.msm","policy_9_0_Microsoft_VC90_CRT_x86.msm"]\r
\r
for i, n in enumerate(modules):\r
    modules[i] = os.path.join(mod_dir, n)\r
\r
def merge(msi, feature, rootdir, modules):\r
    cab_and_filecount = []\r
    # Step 1: Merge databases, extract cabfiles\r
    m = msilib.MakeMerge2()\r
    m.OpenLog("merge.log")\r
    m.OpenDatabase(msi)\r
    for module in modules:\r
        print module\r
        m.OpenModule(module,0)\r
        m.Merge(feature, rootdir)\r
        print "Errors:"\r
        for e in m.Errors:\r
            print e.Type, e.ModuleTable, e.DatabaseTable\r
            print "   Modkeys:",\r
            for s in e.ModuleKeys: print s,\r
            print\r
            print "   DBKeys:",\r
            for s in e.DatabaseKeys: print s,\r
            print\r
        cabname = tempfile.mktemp(suffix=".cab")\r
        m.ExtractCAB(cabname)\r
        cab_and_filecount.append((cabname, len(m.ModuleFiles)))\r
        m.CloseModule()\r
    m.CloseDatabase(True)\r
    m.CloseLog()\r
\r
    # Step 2: Add CAB files\r
    i = msilib.MakeInstaller()\r
    db = i.OpenDatabase(msi, constants.msiOpenDatabaseModeTransact)\r
\r
    v = db.OpenView("SELECT LastSequence FROM Media")\r
    v.Execute(None)\r
    maxmedia = -1\r
    while 1:\r
        r = v.Fetch()\r
        if not r: break\r
        seq = r.IntegerData(1)\r
        if seq > maxmedia:\r
            maxmedia = seq\r
    print "Start of Media", maxmedia\r
\r
    for cabname, count in cab_and_filecount:\r
        stream = "merged%d" % maxmedia\r
        msilib.add_data(db, "Media",\r
                [(maxmedia+1, maxmedia+count, None, "#"+stream, None, None)])\r
        msilib.add_stream(db, stream,  cabname)\r
        os.unlink(cabname)\r
        maxmedia += count\r
    # The merge module sets ALLUSERS to 1 in the property table.\r
    # This is undesired; delete that\r
    v = db.OpenView("DELETE FROM Property WHERE Property='ALLUSERS'")\r
    v.Execute(None)\r
    v.Close()\r
    db.Commit()\r
\r
merge(msiname, "SharedCRT", "TARGETDIR", modules)\r
\r
# certname (from config.py) should be (a substring of)\r
# the certificate subject, e.g. "Python Software Foundation"\r
if certname:\r
    os.system('signtool sign /n "%s" /t http://timestamp.verisign.com/scripts/timestamp.dll %s' % (certname, msiname))\r
\r
if pdbzip:\r
    build_pdbzip()\r