def add_config(self, fullname):
     # Hardwired b/c there is only one Executable() above
     index = 0
     baseName = os.path.basename(self.distribution.executables[index].targetName)
     # http://stackoverflow.com/questions/24195311/how-to-set-shortcut-working-directory-in-cx-freeze-msi-bundle
     msilib.add_data(
         self.db,
         "Shortcut",
         [
             (
                 "S_APP_%s" % index,
                 "DesktopFolder",
                 "QWeb",
                 "TARGETDIR",
                 "[TARGETDIR]%s" % baseName,
                 None,
                 None,
                 None,
                 None,
                 None,
                 None,
                 "TARGETDIR",
             )
         ],
     )
     cx_Freeze.bdist_msi.add_config(self, fullname)

 def add_find_python(self):
     """Adds code to the installer to compute the location of Python.
     Properties PYTHON.MACHINE, PYTHON.USER, PYTHONDIR and PYTHON will be set
     in both the execute and UI sequences; PYTHONDIR will be set from
     PYTHON.USER if defined, else from PYTHON.MACHINE.
     PYTHON is PYTHONDIR\python.exe"""
     install_path = r"SOFTWARE\Python\PythonCore\%s\InstallPath" % self.target_version
     add_data(self.db, "RegLocator",
             [("python.machine", 2, install_path, None, 2),
              ("python.user", 1, install_path, None, 2)])
     add_data(self.db, "AppSearch",
             [("PYTHON.MACHINE", "python.machine"),
              ("PYTHON.USER", "python.user")])
     add_data(self.db, "CustomAction",
             [("PythonFromMachine", 51+256, "PYTHONDIR", "[PYTHON.MACHINE]"),
              ("PythonFromUser", 51+256, "PYTHONDIR", "[PYTHON.USER]"),
              ("PythonExe", 51+256, "PYTHON", "[PYTHONDIR]\\python.exe"),
              ("InitialTargetDir", 51+256, "TARGETDIR", "[PYTHONDIR]")])
     add_data(self.db, "InstallExecuteSequence",
             [("PythonFromMachine", "PYTHON.MACHINE", 401),
              ("PythonFromUser", "PYTHON.USER", 402),
              ("PythonExe", None, 403),
              ("InitialTargetDir", 'TARGETDIR=""', 404),
             ])
     add_data(self.db, "InstallUISequence",
             [("PythonFromMachine", "PYTHON.MACHINE", 401),
              ("PythonFromUser", "PYTHON.USER", 402),
              ("PythonExe", None, 403),
              ("InitialTargetDir", 'TARGETDIR=""', 404),
             ])

		def control_service(service):
			start_on = service.control.get('start_on', 0)
			stop_on = service.control.get('stop_on', 0)
			remove_on = service.control.get('remove_on', 0)

			if not (start_on or stop_on or remove_on):
				log.warn('skipping controller for %s service, no events specified', service.name)
			else:
				log.info('adding controller for %s service', service.name)

			comp_id = get_service_comp(service)

			event = (
			(Service._msidbServiceControlEventStart if start_on & Service.INSTALL else 0) |
			(Service._msidbServiceControlEventStop if stop_on & Service.INSTALL else 0) |
			(Service._msidbServiceControlEventDelete if remove_on & Service.INSTALL else 0) |
			(Service._msidbServiceControlEventUninstallStart if start_on & Service.UNINSTALL else 0) |
			(Service._msidbServiceControlEventUninstallStop if stop_on & Service.UNINSTALL else 0) |
			(Service._msidbServiceControlEventUninstallDelete if remove_on & Service.UNINSTALL else 0))

			msilib.add_data(self.db, 'ServiceControl', [(
				comp_id,  # ServiceControl
				service.name,  # Name
				event,  # Event
				'~'.join(service.control.get('args', [])),  # Arguments
				1 if service.control.get('wait', True) else 0,  # Wait
				comp_id  # Component_
			)])

 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")
         f = open(scriptfn, "w")
         # 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')
         f.write(open(self.pre_install_script).read())
         f.close()
         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_scripts(self):
     if self.install_script:
         add_data(self.db, "CustomAction",
                 [("install_script", 50, "PYTHON", self.install_script_key)])
         add_data(self.db, "InstallExecuteSequence",
                 [("install_script", "NOT Installed", 6800)])
     if self.pre_install_script:
         scriptfn = os.path.join(self.bdist_dir, "preinstall.bat")
         f = open(scriptfn, "w")
         # 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')
         f.write(open(self.pre_install_script).read())
         f.close()
         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_exit_dialog(self):
            # Add the license screen
            if self.get_licence() is not None:
                self.add_licence_dialog()

            # Allow to customize the MSI
            if hasattr(self.attribs, 'customize_msi'):
                self.attribs.customize_msi(self.db)

            # Add the product icon in control panel Install/Remove softwares
            icon_file = os.path.join(self.attribs.get_icons_home(),
                                     self.attribs.get_win_icon())
            if os.path.exists(icon_file):
                msilib.add_data(self.db, 'Property', [
                    ('ARPPRODUCTICON', 'InstallIcon'),
                ])
                msilib.add_data(self.db, 'Icon', [(
                    'InstallIcon', msilib.Binary(icon_file))])

            # Copy/paste from parent's method
            dialog = distutils.command.bdist_msi.PyDialog(
                self.db, 'ExitDialog',
                self.x, self.y, self.width, self.height, self.modal,
                self.title, 'Finish', 'Finish', 'Finish')
            dialog.title('Completing the [ProductName]')
            dialog.back('< Back', 'Finish', active=False)
            dialog.cancel('Cancel', 'Back', active=False)
            dialog.text(
                'Description', 15, 235, 320, 20, 0x30003,
                'Click the Finish button to exit the installer.')
            button = dialog.next('Finish', 'Cancel', name='Finish')
            button.event('EndDialog', 'Return')

            """

 def add_text_styles(self):
     msilib.add_data(self.db, 'TextStyle',
             [("DlgFont8", "Tahoma", 9, None, 0),
              ("DlgFontBold8", "Tahoma", 8, None, 1),
              ("VerdanaBold10", "Verdana", 10, None, 1),
              ("VerdanaRed9", "Verdana", 9, 255, 0)
             ])

def merge(msi, feature, rootdir, modules):
    cab_and_filecount = []
    # Step 1: Merge databases, extract cabfiles
    m = msilib.MakeMerge2()
    m.OpenLog("merge.log")
    print "Opened Log"
    m.OpenDatabase(msi)
    print "Opened DB"
    for module in modules:
        print module
        m.OpenModule(module, 0)
        print "Opened Module", module
        m.Merge(feature, rootdir)
        print "Errors:"
        for e in m.Errors:
            print e.Type, e.ModuleTable, e.DatabaseTable
            print "   Modkeys:",
            for s in e.ModuleKeys:
                print s,
            print
            print "   DBKeys:",
            for s in e.DatabaseKeys:
                print s,
            print
        cabname = tempfile.mktemp(suffix=".cab")
        m.ExtractCAB(cabname)
        cab_and_filecount.append((cabname, len(m.ModuleFiles)))
        m.CloseModule()
    m.CloseDatabase(True)
    m.CloseLog()

    # Step 2: Add CAB files
    i = msilib.MakeInstaller()
    db = i.OpenDatabase(msi, win32com.client.constants.msiOpenDatabaseModeTransact)

    v = db.OpenView("SELECT LastSequence FROM Media")
    v.Execute(None)
    maxmedia = -1
    while 1:
        r = v.Fetch()
        if not r:
            break
        seq = r.IntegerData(1)
        if seq > maxmedia:
            maxmedia = seq
    print "Start of Media", maxmedia

    for cabname, count in cab_and_filecount:
        stream = "merged%d" % maxmedia
        msilib.add_data(db, "Media", [(maxmedia + 1, maxmedia + count, None, "#" + stream, None, None)])
        msilib.add_stream(db, stream, cabname)
        os.unlink(cabname)
        maxmedia += count
    # The merge module sets ALLUSERS to 1 in the property table.
    # This is undesired; delete that
    v = db.OpenView("DELETE FROM Property WHERE Property='ALLUSERS'")
    v.Execute(None)
    v.Close()
    db.Commit()

	def run(self):
		if not (os.path.isdir(self.bdist_dir) and self.skip_build):
			self.run_command('py2exe')

		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()
		sversion = '%d.%d.%d' % StrictVersion(version).version
		product_name = self.distribution.get_name()

		log.info('creating MSI package %s', installer_name)

		self.db = msilib.init_database(installer_name, schema,
				product_name, self.product_code or msilib.gen_uuid(), sversion, author)

		msilib.add_tables(self.db, sequence)

		props = []

		if self.upgrade_code:
			props.extend([
				('UpgradeCode', self.upgrade_code),
				('SecureCustomProperties', 'REPLACE')
			])

			msilib.add_data(self.db, 'Upgrade', [(
				self.upgrade_code,  # UpgradeCode
				None,  # VersionMin, detect all
				sversion,  # VersionMax
				None,  # Language
				0,  # Attributes
				None,  # Remove, REMOVE=ALL
				'REPLACE'  # ActionProperty
			)])

		if props:
			msilib.add_data(self.db, 'Property', props)

		self.add_files()
		self.add_services()

		self.db.Commit()

		if not self.keep_temp:
			remove_tree(self.bdist_dir, dry_run=self.dry_run)
			remove_tree(self.get_finalized_command('build').build_base)

 def add_upgrade_config(self, sversion):
     if self.upgrade_code is not None:
         msilib.add_data(self.db, 'Upgrade',
                 [(self.upgrade_code, None, sversion, None, 513, None,
                         "REMOVEOLDVERSION"),
                  (self.upgrade_code, sversion, None, None, 257, None,
                         "REMOVENEWVERSION")
                 ])

 def customize_msi(self, db):
     import msilib
     # Add the possibility to bind an engine with MSI
     msilib.add_data(db, "CustomAction", [("NuxeoDriveBinder", 82,
                     self.get_win_targetName(),
                     "bind-server --password \"[TARGETPASSWORD]\" --local-folder \"[TARGETDRIVEFOLDER]\" [TARGETUSERNAME] [TARGETURL]")])
     msilib.add_data(db, "InstallExecuteSequence", [("NuxeoDriveBinder",
                           'NOT (TARGETUSERNAME="" OR TARGETURL="")', -1)])

 def add_config(self, fullname):
     """add the uninstaller icon"""
     windist.bdist_msi.add_config(self, fullname)
     msilib.add_data(self.db, "Registry", [("DisplayIcon",  # Registry
                                            -1,  # Root
                                            r"Software\Microsoft\Windows\CurrentVersion\Uninstall\%s" %
                                            self.productcode(),  # Key
                                            "DisplayIcon",  # Name
                                            r"[icons]kajongg.ico",  # Value
                                            "TARGETDIR")])  # default Component

    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)
        return

 def commit(self, db):
     filename = tempfile.mktemp()
     msilib.FCICreate(filename, self.files)
     print filename, os.path.getsize(filename)
     sys.stderr.write(str((self.diskId, self.index, None, "#"+self.name, None, None)) + "\n")
     msilib.add_data(db, "Media",
                     [(self.diskId, self.index, None, "#"+self.name, None, None)])
     msilib.add_stream(db, self.name, filename)
     self.diskId += 1
     db.Commit()
     os.unlink(filename)

 def add_scripts(self):
     super().add_scripts()
     start = 6850
     for ver in self.versions + [self.other_version]:
         install_action = "post_batgen." + ver
         exe_prop = "PYTHON" + ver
         add_data(self.db, "CustomAction",
                 [(install_action, 50, exe_prop, '-m shenv.batgen --overwrite -f \"[EmgrBatDir]\\shenv.bat\"')])
         add_data(self.db, "InstallExecuteSequence",
                 [(install_action, "&Python%s=3" % ver, start)])
         start += 1

    def generate_MSI(self):
        shutil.copy(self.template, self.msifile.path)
        #1 Add exe and ini file to cab
        filelist = [(self.exefile.path, "ExeFile"), (self.inifile.path, "IniFile")]
        cabfile  = os.path.join(self.tempdir, "files.cab")
        msilib.FCICreate(cabfile, filelist)

        #2 Open the MSI database
        #database = msilib.init_database(self.msifile.path, msilib.schema, self.msifile.name,  self.productcode, self.productversion, self.manufacturer)
        #print self.msifile.path
        #msilib.add_tables(database, msilib.schema)
        database = msilib.OpenDatabase(self.msifile.path, msilib.MSIDBOPEN_DIRECT)
        msilib.add_stream(database, "Wpkg_GP.cab", cabfile)

        # Update Product Code
        summaryinformation = database.GetSummaryInformation(1)
        summaryinformation.SetProperty(msilib.PID_REVNUMBER, self.package_GUID)
        summaryinformation.Persist()
        
        # Add information to Media
        # DiskId | LastSequence | DiskPrompt | Cabinet | VolumeLabel | Source
        table = "Media"
        records = [(1, 2, None, "#Wpkg_GP.cab", None, None)]
        msilib.add_data(database, table, records)

        #CAB = msilib.CAB("Wpkg_GP.cab")
        #CAB.append(self.exefile.path, "ExeFile", "ExeFile")
        #CAB.append(self.inifile.path, "IniFile", "IniFile")
        #CAB.commit(database)

        # Add information to File
        # File | Component_ | FileName | FileSize| Version | Language | Attributes | Sequence
        table = "File"
        records = [
            ("ExeFile", "Installer", self.exefile.name, self.exefile.size, None, None, 512, 1),
            ("IniFile", "Installer", self.inifile.name, self.inifile.size, None, None, 512, 2)
            ]
        msilib.add_data(database, table, records)

        
        # Add information to CustomAction
        # Action | Type | Source | Target
        # For Type, see: http://msdn.microsoft.com/en-us/library/aa372048%28v=VS.85%29.aspx

        # Add information to Property
        # Property | Value
        # Update version
        view = database.OpenView("UPDATE Property SET Value='%s' WHERE Property='ProductVersion'" % self.exefile.get_fileversion_as_string())
        view.Execute(None)
        view = database.OpenView("UPDATE Property Set Value='%s' WHERE Property='ProductCode'" % self.product_GUID)
        view.Execute(None)

        database.Commit()

def create_msi_installer(package, run_node, msi_root_node, installer_name=None, output_dir="dist"):
    meta = PackageMetadata.from_package(package)

    string_version = "%d.%d.%d" % (meta.version_major, meta.version_minor, meta.version_micro)

    fullname = "%s-%s" % (package.name, string_version)
    if installer_name is None:
        installer_name = "%s-%s.msi" % (package.name, string_version)
    parent_node = run_node.make_node(output_dir)
    if parent_node is None:
        raise IOError()
    installer_node = parent_node.make_node(installer_name)
    installer_name = installer_node.abspath()
    installer_node.parent.mkdir()

    author = meta.author

    short_version = sysconfig.get_python_version()

    has_ext_modules = True
    if has_ext_modules:
        target_version = short_version
    else:
        target_version = None

    if target_version:
        product_name = "Python %s %s" % (target_version, meta.fullname)
    else:
        product_name = "Python %s" % meta.fullname

    if target_version:
        versions = [target_version]
    else:
        versions = list(ALL_VERSIONS)

    db = msilib.init_database(installer_name, schema, product_name, msilib.gen_uuid(), string_version, author)
    msilib.add_tables(db, sequence)

    props = [("DistVersion", meta.version)]
    email = meta.author_email or meta.maintainer_email
    if email:
        props.append(("ARPCONTACT", email))
    if meta.url:
        props.append(("ARPURLINFOABOUT", meta.url))
    if props:
        add_data(db, "Property", props)

    add_find_python(db, versions)
    add_files(db, msi_root_node, versions, OTHER_VERSION)
    add_scripts(db)
    add_ui(db, fullname, versions, OTHER_VERSION)
    db.Commit()

def add_files(db, msi_node, versions, other_version, install_script=None):
    if install_script is not None:
        raise NotImplementedError("Support for msi install script not yet implemented")
    cab = msilib.CAB("distfiles")
    rootdir = msi_node.abspath()

    root = Directory(db, cab, None, rootdir, "TARGETDIR", "SourceDir")
    f = Feature(db, "Python", "Python", "Everything", 0, 1, directory="TARGETDIR")

    items = [(f, root, "")]
    for version in versions + [other_version]:
        target = "TARGETDIR" + version
        name = default = "Python" + version
        desc = "Everything"
        if version is 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 == install_script:
                            if install_script_key:
                                raise DistutilsOptionError("Multiple files with name %s" % file)
                            install_script_key = "[#%s]" % key
                    else:
                        key = seen[afile]
                        add_data(db, "DuplicateFile", [(key + version, dir.component, key, None, dir.logical)])
        db.Commit()
    cab.commit(db)

 def add_exit_dialog(self):
     import msilib
     if self.get_license() is not None:
         self.add_licence_dialog()
     dialog = distutils.command.bdist_msi.PyDialog(self.db, "ExitDialog",
             self.x, self.y, self.width, self.height, self.modal,
             self.title, "Finish", "Finish", "Finish")
     dialog.title("Completing the [ProductName]")
     dialog.back("< Back", "Finish", active=False)
     dialog.cancel("Cancel", "Back", active=False)
     dialog.text("Description", 15, 235, 320, 20, 0x30003,
             "Click the Finish button to exit the installer.")
     button = dialog.next("Finish", "Cancel", name="Finish")
     button.event("EndDialog", "Return")
     msilib.add_data(self.db, "Property",
              [("StartClient", "1")])
     # Launch product checkbox
     c = dialog.control("LaunchAfterInstall", "CheckBox",
                        15, 200, 320, 20, 0x3,
                        "StartClient", "Launch [ProductName]", None, None)
     c.condition("Hide", 'Progress1<>"Install"')
     # 18 is for execute a .exe from install
     msilib.add_data(self.db, "CustomAction", [("LaunchNuxeoDrive", 18,
                                                "launcher.exe",
                                                self.get_executable())])
     button.event("DoAction", "LaunchNuxeoDrive",
                  'StartClient=1 and Progress1="Install"')
     msilib.add_data(self.db, "CustomAction", [("NuxeoDriveCleanUp", 18,
                                                self.get_executable(),
                                                "uninstall")])
     msilib.add_data(self.db, "InstallExecuteSequence",
                     [("NuxeoDriveCleanUp",
                       'REMOVE="ALL" AND NOT UPGRADINGPRODUCTCODE', 1260)])

    def add_ui(self):
        super().add_ui();
        
        db = self.db
        x = y = 50
        w = 370
        h = 300
        title = "[ProductName] Setup"

        # see "Dialog Style Bits"
        modal = 3      # visible | modal
        modeless = 1   # visible

        add_data(db, "Property",
             # See "DefaultUIFont Property"
             [("EmgrBatDir", "c:\\utility"),
             ])


        add_data(db, "InstallUISequence", [
                 ("SelectBatDest", "Not Installed", 1231),
                 ])
        
        #####################################################################
        # Feature (Python directory) selection
        seldlg = PyDialog(db, "SelectBatDest", x, y, w, h, modal, title,
                        "Next", "Next", "Cancel")
        seldlg.title("Select the destination for the shenv.bat file")

        seldlg.text("Hint", 15, 30, 300, 20, 3,
                    "Select the directory where the shenv.bat file is installed."
                    )
        
        seldlg.back("< Back", None, active=1)
        c = seldlg.next("Next >", "Cancel")
        order = 1
        c.event("SpawnWaitDialog", "WaitForCostingDlg", ordering=order + 1)
        c.event("EndDialog", "Return", ordering=order + 2)
        c = seldlg.cancel("Cancel", "PathEdit")  #TODO : next cointrol
        c.event("SpawnDialog", "CancelDlg")

        c = seldlg.control("PathEdit", "PathEdit", 15, 60, 300, 16, 3,
                   "EmgrBatDir", "YoMan", "Next", None)