script "InstallerUtilities"

# This is the back-end installer, updater and uninstaller code.

# This code doesn't know anything about the product it is installing, and should be capable

# of being re-used for products other than LiveCode. It reads a "manifest" file, which contains

# a list of files to be installed and some metadata. The files are then installed according to command

# line options. Uninstallation uses a "record" file, which is created by the installer. This is basically the same

# as the manifest file, but with a little less information.

constant kRunOnce = "HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce"

################################################################################

local sIsFaceless

local sFacelessLog

private function isInstallerEnvironment

return (the environment begins with "installer")

end isInstallerEnvironment

################################################################################

#

# FRONT-END FUNCTIONS

#

local sInstallerStack

local sInstallerProcess

local sInstallerError

command installerRun pPath, pRecord, pOptions, pWithoutElevation

local tCommand

if isInstallerEnvironment() then

put the effective filename of stack "Installer" into tCommand

else

put specialFolderPath("Desktop") & "/installbackend.exe" into tCommand

end if

if tCommand contains space then

put quote & tCommand & quote into tCommand

end if

local tArguments

put "doinstall -path" && quote & pPath & quote && "-record" && quote & pRecord & quote into tArguments

repeat for each key tOption in pOptions

if pOptions[tOption] is "true" then

put space & "-enable" & tOption after tArguments

else if pOptions[tOption] is "false" then

put space & "-disable" & tOption after tArguments

else

put space & tOption && quote & pOptions[tOption] & quote after tArguments

end if

end repeat

put empty into sInstallerError

put tCommand && tArguments into sInstallerProcess

put the long id of stack "InstallerUI" of stack "Installer" into sInstallerStack

-- Make sure we do a log entry non-admin side. This ensures it has the correct owner on Linux.

log "Commencing install action with:" && sInstallerProcess

if pWithoutElevation or elevationNotSupported() then

open process sInstallerProcess for binary update

else

do "open elevated process sInstallerProcess for binary update"

end if

if the result is not empty then

if the result is "access denied" then

installerDispatchFinished "Request to launch elevated installer slave failed."

else

installerDispatchFinished "Could not launch installer slave."

end if

exit installerRun

end if

installerMonitor

end installerRun

command installerRunUninstall pPath, pRecord, pWithoutElevation

local tCommand

if isInstallerEnvironment() then

put the effective filename of stack "Installer" into tCommand

else

put "C:/Users/Mark/Desktop/installbackend.exe" into tCommand

end if

if tCommand contains space then

put quote & tCommand & quote into tCommand

end if

local tArguments

put "douninstall -path" && quote & pPath & quote && "-record" && quote & pRecord & quote into tArguments

put empty into sInstallerError

put tCommand && tArguments into sInstallerProcess

put the long id of stack "UninstallerUI" of stack "Installer" into sInstallerStack

-- Make sure we do a log entry non-admin side. This ensures it has the correct owner on Linux.

log "Commencing uninstall action with:" && sInstallerProcess

if pWithoutElevation or elevationNotSupported() then

open process sInstallerProcess for binary update

else

do "open elevated process sInstallerProcess for binary update"

end if

if the result is not empty then

if the result is "access denied" then

installerDispatchFinished "Request to launch elevated uninstaller slave failed."

else

installerDispatchFinished "Could not launch uninstaller slave."

end if

exit installerRunUninstall

end if

installerMonitor

end installerRunUninstall

-- Temporary function to determine if elevation is not supported on linux

private function elevationNotSupported

if the platform is not "linux" then

return false

end if

set the itemDelimiter to ":"

repeat for each item tPath in $PATH

if there is a file (tPath & slash & "gksu") then

return false

end if

end repeat

return true

end elevationNotSupported

command installerMonitor

-- We loop each time until there is no more data to read from the slave process.

set the itemDelimiter to tab

repeat forever

-- If the slave process has gone away unexpectedly, dispatch a finished.

if sInstallerProcess is not among the lines of the openProcesses then

put empty into sInstallerProcess

installerDispatchFinished "Installer slave quit without eof."

exit repeat

end if

-- Attempt to read a line from the installer process

read from process sInstallerProcess for 1 line in 0 millisecs

switch the result

case empty

-- If there was no error, process the line (first eliminate the return char at end)

get line 1 of it

if item 1 of it is "error" then

put item 2 of it into sInstallerError

else if item 1 of it is "phase" then

installerDispatchPhase item 2 of it

else if item 1 of it is "progress" then

installerDispatchProgress item 2 of it, item 3 of it

else if item 1 of it is "done" then

close process sInstallerProcess

put empty into sInstallerProcess

installerDispatchFinished

exit repeat

end if

break

case "timed out"

-- If the read timed out, exit the repeat

exit repeat

break

case "eof"

default

-- If there was an eof or unexpected error, close the process and dispatch

-- finished

close process sInstallerProcess

put empty into sInstallerProcess

installerDispatchFinished "Installer slave quit unexpectedly."

exit repeat

break

end switch

end repeat

-- If we still have a process, then send an update message in a short period of time

if sInstallerProcess is not empty then

send "installerMonitor" to me in 20 millisecs

end if

end installerMonitor

command installerCancel

if sInstallerProcess is not empty and sInstallerProcess is among the lines of the openProcesses then

write "cancel" & return to process sInstallerProcess

end if

end installerCancel

private command installerDispatchPhase pPhase

dispatch "installerPhaseChanged" to this card of stack sInstallerStack with pPhase

end installerDispatchPhase

private command installerDispatchProgress pPercentage, pMessage

dispatch "installerProgressChanged" to this card of stack sInstallerStack with pPercentage, pMessage

end installerDispatchProgress

private command installerDispatchFinished pDefaultError

if sInstallerError is empty then

put pDefaultError into sInstallerError

end if

dispatch "installerFinished" to this card of stack sInstallerStack with sInstallerError

put empty into sInstallerError

end installerDispatchFinished

################################################################################

#

# BACK-END FUNCTIONS

#

-- InstallerUI mode requires no command line options and opens the 'InstallerUI'

-- substack to continue the install. If, however, there is a second parameter it is

-- taken to be where the install should occur - skipping the target selection screen.

command runInstallerUI

-- We are showing a UI, so hide this stack and switch the process

-- to foreground (required for Mac OS X).

hide me

-- Configure the UI options and switch to the installer UI stack.

go invisible to card "Launch" of stack "InstallerUI"

end runInstallerUI

-- UninstallerUI mode requires no command line options and opens the

-- 'UinstallerUI' substack to continue the uninstall.

command runUninstallerUI

-- We are showing a UI, so hide this stack and switch the process

-- to foreground (required for Mac OS X).

hide me

-- Configure the UI options and switch to the uninstaller UI stack

go invisible to card "Launch" stack "UninstallerUI"

end runUninstallerUI

-- Faceless install option

command runFacelessInstall

put true into sIsFaceless

try

send "runFaceless" to stack "InstallerUI"

catch tError

quit 1

end try

quit 0

end runFacelessInstall

-- Faceless uninstall option

command runFacelessUninstall

put true into sIsFaceless

try

send "runFaceless" to stack "UninstallerUI"

catch tError

quit 1

end try

quit 0

end runFacelessUninstall

-- InstallerActions mode is backend process for installation. It reads the

-- following command line options:

-- -path <target> : the location the install should occur

-- -record <target> : where the record file should be placed

-- -enable-* : enable the given option

-- -disable-* : disable the given option

-- The record and path options are mandatory.

command runInstallerActions

log "Installer actions launched from '" & $0 & "'."

try

-- The installer requires the parameter '-path' to determine where

-- it is reinstalling.

local tPath

put ensureStringOption("path") into tPath

-- Next parse the record parameter.

local tRecord

put ensureStringOption("record") into tRecord

-- Now parse the boolean enable/disable options.

local tOptions

put parseBooleanOptions() into tOptions

-- Run the install action.

actionInstall tPath, tRecord, tOptions

catch tError

quit 1

end try

quit 0

end runInstallerActions

command runUninstallerActions

log "Uninstaller actions launched from '" & $0 & "'."

try

-- The installer requires the parameter '-path' to determine where

-- it is reinstalling.

local tPath

put ensureStringOption("path") into tPath

-- Next parse the record parameter.

local tRecord

put ensureStringOption("record") into tRecord

-- Now parse the boolean enable/disable options.

local tOptions

put parseBooleanOptions() into tOptions

-- Run the uninstall action.

reportPhase "Uninstall"

actionUninstall tPath, tRecord, false

catch tError

quit 1

end try

quit 0

end runUninstallerActions

##########

function parseBooleanOptions

local tOptions

repeat with x = 1 to $#

local tParam

put value("$" & x) into tParam

if tParam begins with "-enable-" then

put true into tOptions[char 9 to -1 of tParam]

log "Enabled option '" & char 9 to -1 of tParam & "'."

else if tParam begins with "-disable-" then

put false into tOptions[char 9 to -1 of tParam]

log "Disabled option '" & char 9 to -1 of tParam & "'."

end if

end repeat

return tOptions

end parseBooleanOptions

function parseStringOption pName

repeat with x = 1 to $#

local tParam

put value("$" & x) into tParam

if tParam is ("-" & pName) then

if x + 1 <= $# then

local tValue

put value("$" & (x + 1)) into tValue

-- The subsequent parameter must be of the form "...".

if char 1 of tValue is not "-" then

log "Option -" & pName && "has value '" & char 1 to -1 of tValue & "'."

if char 1 of tValue is quote then

delete char 1 of tValue

delete char -1 of tValue

end if

return tValue

end if

end if

-- If this was the last parameter, or the next parameter was an option

-- then its an error.

log "Option -" & pName && "specified with no value"

reportError "Invocation error (no parameter for option)."

end if

end repeat

return empty

end parseStringOption

function ensureStringOption pName

local tValue

put parseStringOption(pName) into tValue

if tValue is empty then

log "No -" & pName && "option specified."

reportError "Invocation error (expected option not present)"

end if

return tValue

end ensureStringOption

################################################################################

#

# BACK-END INSTALLER IMPLEMENTATION

#

-- This command performs all actions related to an install. Any errors that occur cause 'reportError'

-- to be executed which will terminate. If an error occurs during an install, cleanup will be performed

-- before exiting.

command actionInstall pPath, pRecord, pOptions

local tManifest, tManifestItems

-- Make sure the filetype is empty so extensions are use

set the fileType to empty

-- If there is a 'log' option then set the log file (but only if we are faceless)

if sIsFaceless and pOptions["log"] is not empty then

put pOptions["log"] into sFacelessLog

end if

-- If there is a record file, then run an uninstall first.

if there is a file pRecord then

reportPhase "Uninstall"

actionUninstall pPath, pRecord, true

end if

-- We are in 'install' phase

reportPhase "Install"

-- Open the internal payload archive that was inserted at deploy time.

log "Install: Opening payload archive."

payloadOpen pOptions["archive"]

-- Extract the manifest from the payload. The manifest will be returned to us as a standard text

-- file (i.e. LF line endings).

log "Install: Extracting payload manifest."

installExtractManifest tManifest

replace "[[installFolder]]" with pPath in tManifest

-- Parse the manifest into an array of items.

log "Install: Parsing manifest."

installParseManifest tManifest, tManifestItems

-- Calculate item sizes/progress for each manifest item

log "Install: Instrumenting manifest with progress."

installInstrumentManifest tManifestItems

-- Make sure we have the record file ready to go

log "Install: Creating record file at '" & pRecord & "'"

installEnsureRecord pRecord

-- We need the target installation folder before doing anything else.

reportProgress 0, "Creating installation folder."

installEnsureFolder pPath

installRecord pRecord, "folder", pPath

-- We use try/catch here to ensure that we do an implicit uninstall if an error

-- occurs.

try

-- Now loop through all the items in the manifest performing appropriate steps in each case.

repeat for each element tManifestItem in tManifestItems

-- Check for cancellation and report it if present

reportCheckCancel

-- If the 'delay' option is specified, then wait for a bit (this is to help testing)

if pOptions["delay"] then

wait 5 millisecs

end if

-- Now perform item specific actions

switch tManifestItem["type"]

-- An empty type means this was a comment or empty line, so we do nothing.

case empty

break

case "file"

reportProgress tManifestItem["progress"], "Extracting file '" & tManifestItem["path"] & "'"

payloadExtractItemToFile tManifestItem["name"], tManifestItem["base_name"], tManifestItem["path"]

installRecord pRecord, tManifestItem["type"], tManifestItem["path"]

break

case "executable"

reportProgress tManifestItem["progress"], "Extracting executable file '" & tManifestItem["path"] & "'"

payloadExtractItemToFile tManifestItem["name"], tManifestItem["base_name"], tManifestItem["path"]

installMakeExecutable tManifestItem["path"]

installRecord pRecord, tManifestItem["type"], tManifestItem["path"]

break

case "folder"

reportProgress tManifestItem["progress"], "Creating folder '" & tManifestItem["path"] & "'"

installEnsureFolder tManifestItem["path"]

installRecord pRecord, tManifestItem["type"], tManifestItem["path"]

break

case "uninstaller"

reportProgress tManifestItem["progress"], "Installing uninstaller to '" & tManifestItem["path"] & "'"

installCopyUninstaller tManifestItem["path"]

installRecord pRecord, "uninstaller", tManifestItem["path"]

break

case "registry key"

reportProgress tManifestItem["progress"], "Creating registry key '" & tManifestItem["key"] & "' with value '" & tManifestItem["value"] & "'"

get tManifestItem["key"]

if pOptions["allusers"] then

replace "HKEY_CURRENT_USER" with "HKEY_LOCAL_MACHINE" in it

else

replace "HKEY_LOCAL_MACHINE" with "HKEY_CURRENT_USER" in it

end if

installSetRegistryKey it, tManifestItem["value"], tManifestItem["value_type"]

installRecord pRecord, "registry key", it

break

case "registry value"

reportProgress tManifestItem["progress"], "Creating registry entry '" & tManifestItem["entry"] & "' in key '" & tManifestItem["key"] & "' with value '" & tManifestItem["value"] & "'"

get tManifestItem["key"]

if pOptions["allusers"] then

replace "HKEY_CURRENT_USER" with "HKEY_LOCAL_MACHINE" in it

else

replace "HKEY_LOCAL_MACHINE" with "HKEY_CURRENT_USER" in it

end if

installSetRegistryValue it, tManifestItem["entry"], tManifestItem["value"], tManifestItem["value_type"]

installRecord pRecord, "registry value", it & "\" & tManifestItem["entry"]

break

case "shortcut"

set the itemDelimiter to slash

if (pOptions["desktopshortcut"] and item 1 of tManifestItem["path"] is "Desktop") or \

(pOptions["startmenu"] and item 1 of tManifestItem["path"] is "Programs") or \

item 1 of tManifestItem["path"] is "Plugins" then

reportProgress tManifestItem["progress"], "Creating shortcut '" & tManifestItem["path"] & "'"

installMakeShortcut tManifestItem["path"], tManifestItem["target"], pOptions["allusers"]

installRecord pRecord, "shortcut", tManifestItem["path"], pOptions["allusers"]

end if

set the itemDelimiter to slash

break

case "desktop-application"

if pOptions["startmenu"] then

reportProgress tManifestItem["progress"], "Installing application menu entry for '" & tManifestItem["name"] & "'"

installDesktopApplication pRecord, tManifestItem["name"], tManifestItem["source"], pPath, pOptions["allusers"]

end if

break

case "desktop-icon"

if pOptions["startmenu"] then

reportProgress tManifestItem["progress"], "Installing icon for '" & tManifestItem["name"] & "'"

installDesktopIcon pRecord, tManifestItem["name"], tManifestItem["source"], pOptions["allusers"]

end if

break

case "rename"

reportProgress tManifestItem["progress"], "Moving to final destination"

installRename pRecord, tManifestItem["source"], tManifestItem["target"]

break

case "record"

-- Legacy item type - ignored for now

break

default

log "Install: Invalid manifest item type '" & tManifestItem["type"] & "'"

reportError "Internal error (illegal manifest item type found)."

break

end switch

end repeat

catch tError

-- If an execution error occurs, then we log it and leave the installation how it is, otherwise

-- it was a caught error and we attempt to uninstall before anything else.

if item 1 of tError is not a number then

reportPhase "Cleanup"

actionUninstall pPath, pRecord, true

else

log "Install: Execution error - " & tError

reportError "Internal error."

put "internal" into tError

end if

end try

log "Install: Closing payload archive."

payloadClose

-- If there was no error, report that we are done. Otherwise, if this was not a 'cancel' error,

-- then throw it.

if tError is empty or tError is "cancel" then

reportFinished

else

throw tError

end if

end actionInstall

private command installExtractManifest @rManifest

-- Extract the item to the target variable

payloadExtractItemToVariable "manifest.txt", rManifest

-- Make sure we normalize line-endings to Rev standard LFs

replace (numToChar(13) & numToChar(10)) with numToChar(10) in rManifest

replace numToChar(13) with numToChar(10) in rManifest

end installExtractManifest

private command installParseManifest pManifest, @rManifestItems

log "ParseManifest: Parsing manifest of length" && the number of chars in pManifest

-- Manifest file uses 'tabs' as item delimiter

set the itemDelimiter to tab

-- Start off with an empty list of items

put empty into rManifestItems

-- Loop through each line, creating items as we go

repeat for each line tLine in pManifest

-- If the line is just whitepace, ignore it

if word 1 to -1 of tLine is empty then

next repeat

end if

-- If the first non-whitepsace char is '#', or '--' then ignore it

if word 1 of tLine begins with "#" or \

word 1 of tLine begins with "--" then

next repeat

end if

-- Decode into the the 'tItem' array

local tItem

-- First parse the type portion (item 1)

-- [ shared ] ( folder | registry | file | executable | shortcut | uninstaller )

local tType, tShared

put item 1 of tLine into tItem["type"]

if word 1 of tType is "shared" then

put word 2 of tType into tItem["type"]

put true into tItem["shared"]

else

put false into tItem["shared"]

end if

-- Now decode type specific actions

switch tItem["type"]

case "folder"

put item 2 of tLine into tItem["path"]

break

case "file"

case "executable"

put item 2 of tLine into tItem["path"]

put item 3 of tLine into tItem["name"]

put item 4 of tLine into tItem["base_name"]

break

case "registry key"

put item 2 of tLine into tItem["key"]

put item 3 of tLine into tItem["value"]

put item 4 of tLine into tItem["value_type"]

replace "/" with "\" in tItem["key"]

replace "\\" with "/" in tItem["key"]

replace "HKCU\" with "HKEY_CURRENT_USER\" in tItem["key"]

replace "HKLM\" with "HKEY_LOCAL_MACHINE\" in tItem["key"]

break

case "registry value"

get offset("//", item 2 of tLine)

put char 1 to it -1 of item 2 of tLine into tItem["key"]

put char it + 2 to -1 of item 2 of tLine into tItem["entry"]

put item 3 of tLine into tItem["value"]

put item 4 of tLine into tItem["value_type"]

replace "/" with "\" in tItem["key"]

replace "\\" with "/" in tItem["key"]

replace "HKCU\" with "HKEY_CURRENT_USER\" in tItem["key"]

replace "HKLM\" with "HKEY_LOCAL_MACHINE\" in tItem["key"]

break

case "shortcut"

put item 2 of tLine into tItem["path"]

put item 3 of tLine into tItem["target"]

break

case "uninstaller"

put item 2 of tLine into tItem["path"]

break

case "rename"

put item 2 of tLine into tItem["target"]

put item 3 of tLine into tItem["source"]

break

case "record"

-- This is a no-op now, the record path is passed in by the UI

break

case "desktop-icon"

case "desktop-application"

put item 2 of tLine into tItem["name"]

put item 3 of tLine into tItem["source"]

break

default

log "ParseManifest: invalid manifest item type '" & tItem["type"] & "'"

reportError "Internal error (illegal manifest item type found)."

break

end switch

-- Finally add the item to the item array

put tItem into rManifestItems[the number of elements of rManifestItems + 1]

end repeat

end installParseManifest

private command installInstrumentManifest @xManifest

-- First loop through putting the running total into the progress field

local tCurrentTotal

put 0 into tCurrentTotal

repeat with i = 1 to the number of elements of xManifest

if xManifest[i]["type"] is among the items of "file,executable" then

add item 3 of payloadDescribeItem(xManifest[i]["name"]) to tCurrentTotal

else

add 100 to tCurrentTotal

end if

put tCurrentTotal into xManifest[i]["progress"]

end repeat

-- Now normalize the progress field's to percentages

repeat with i = 1 to the number of elements of xManifest

divide xManifest[i]["progress"] by (tCurrentTotal / 100.0)

end repeat

end installInstrumentManifest

private command installEnsureFolder pPath

log "EnsureFolder: Ensure '" & pPath & "' exists."

-- MM-2011-12-12: Allow Windows network drive installaitons.

if pPath begins with "//" then

get 4

else

get 2

end if

-- Otherwise make sure we create all folders up to and including

-- our target folder.

set the itemDelimiter to slash

repeat with i = it to the number of items of pPath

local tFolderPrefix, tShortFolderPrefix

put item 1 to i of pPath into tFolderPrefix

put installShortenPath(tFolderPrefix) into tShortFolderPrefix

if there is a folder tShortFolderPrefix or tShortFolderPrefix is empty then

next repeat

end if

log "EnsureFolder: creating folder '" & tShortFolderPrefix & "'."

create folder tShortFolderPrefix

if the result is not empty then

log "EnsureFolder: folder creation failed -" && the result

reportError "Unable to create required folder at '" & pPath & "'."

end if

end repeat

end installEnsureFolder

private command installCopyUninstaller pTarget

log "CopyUninstaller: Place uninstaller at '" & pTarget & "'"

if the platform is "macos" then

-- MM - copy the uninstaller app folder

--

set the itemDel to slash

installCopyUninstallerFolder item 1 to - 4 of the effective filename of stack "Installer", pTarget

if the result is not empty then

log "CopyUninstaller: copying failed -" && the result

reportError "Unable to copy uninstaller to '" & pTarget & "'."

end if

set the itemDel to comma

else

put url ("binfile:" & the effective filename of stack "Installer") into url ("binfile:" & installShortenPath(pTarget))

if the result is not empty then

log "CopyUninstaller: copying failed -" && the result

reportError "Unable to copy uninstaller to '" & pTarget & "'."

end if

// SN-2014-10-28: [[ Bug 16410 ]] The uninstaller needs the execution permission

// (on Linux)

if the platform contains "linux" then

local tChmodResult

get shell("chmod +x " & quote & installShortenPath(pTarget) & quote)

if it is not empty then

log "CopyUninstaller: setting executable permission failed - " & it

reportError "Unable to copy uninstaller to '" & pTarget & "'."

end if

end if

end if

end installCopyUninstaller

-- MM - recursive copying of a folder, making sure to set the executable bit of the installer itself

--

private command installCopyUninstallerFolder pSrcFolder, pDestFolder

local tOldFolder

put the folder into tOldFolder

if not (there is a folder pDestFolder) then

log "CopyUninstaller: creating folder" && pDestFolder

create folder pDestFolder

if the result is not empty then

return pDestFolder && the result

end if

end if

set the folder to pSrcFolder

repeat for each line tFolder in the folders

if not (tFolder begins with ".") then

installCopyUninstallerFolder pSrcFolder & slash & tFolder, pDestFolder & slash & tFolder

if the result is not empty then

return pDestFolder & slash & tFolder && the result

end if

end if

end repeat

repeat for each line tFile in the files

log "CopyUninstaller: copying file" && pDestFolder & slash & tFile

put url ("binfile:" & pSrcFolder & slash & tFile) into url ("binfile:" & pDestFolder & slash & tFile)

if the result is not empty then

return pDestFolder & slash & tFile && the result

end if

if tFile is "installer" then

installMakeExecutable pDestFolder & slash & tFile

end if

end repeat

set the folder to tOldFolder

return empty

end installCopyUninstallerFolder

private command installMakeExecutable pPath

log "MakeExecutable: Ensuring file '" & pPath & "' is executable"

-- Only need to set executable bit on mac and linux

if the platform is not among the items of "macos,linux" then

exit installMakeExecutable

end if

-- Use the 'chmod' shell command

local tCommand, tCommandResult

put "chmod 755 " & quote & pPath & quote into tCommand

put shell(tCommand) into tCommandResult

if the result is not 0 then

log "MakeExecutable: 'chmod' failed - " & tCommandResult

reportError "Failed to mark file as executable."

end if

end installMakeExecutable

private command installMakeShortcut pPath, pTarget, pAllUsers

log "MakeShortcut: Creating shortcut '" & pPath & "' to '" & pTarget & "'"

set the itemDelimiter to slash

-- Determine the base folder for the shortcut

local tBaseFolder

if item 1 of pPath is "Desktop" then

if pAllUsers then

put specialFolderPath(0x0019) into tBaseFolder

else

put specialFolderPath("desktop") into tBaseFolder

end if

else if item 1 of pPath is "Programs" then

if pAllUsers then

put specialFolderPath(0x0017) into tBaseFolder

else

put specialFolderPath(0x0002) into tBaseFolder

end if

else if item 1 of pPath is "Plugins" then

if the platform is "linux" then

put $HOME & slash & ".mozilla/plugins" into tBaseFolder

else if the platform is "macos" then

if pAllUsers then

put "/Library/Internet Plug-Ins" into tBaseFolder

else

put specialFolderPath("cusr") & slash & "Library" & slash & "Internet Plug-Ins" into tBaseFolder

end if

end if

end if

-- If the basefolder was not found, then this type of shortcut is

-- not supported on this platform.

if tBaseFolder is empty then

exit installMakeShortcut

end if

-- Remove the first item as it just indicates the shortcut type

delete item 1 of pPath

-- If there is no target, this is just a folder creation

if pTarget is empty then

installEnsureFolder tBaseFolder & slash & pPath

exit installMakeShortcut

end if

-- Make sure the appropriate folder structure is present

if the number of items of pPath > 1 then

installEnsureFolder tBaseFolder & slash & (item 1 to -2 of pPath)

end if

-- Create the shortcut

if the platform is "win32" then

put ".lnk" after pPath

end if

if the platform is not "macos" then

create alias tBaseFolder & slash & pPath to file pTarget

if the result is not empty then

log "MakeShortcut: 'create alias' failed -" && the result

reportError "Failed to create " & item 1 of pPath & " shortcut."

end if

else

get shell("ln -s" && quote & pTarget & quote && quote & tBaseFolder & slash & pPath & quote)

if it is not empty then

log "MakeShortcut: 'ln' failed -" && it

reportError "Failed to create " & item 1 of pPAth & " shortcut."

end if

end if

end installMakeShortcut

private command installDesktopApplication pRecord, pName, pSource, pInstallPath, pAllUsers

local tTargetPath

put xdgDataPath(pAllUsers) & slash & "applications" into tTargetPath

-- Make sure the target path exists

installEnsureFolder tTargetPath

local tData

payloadExtractItemToVariable pSource, tData

replace "[[installFolder]]" with pInstallPath in tData

put tData into url ("binfile:" & tTargetPath & slash & pName & ".desktop")

get shell("touch" && tTargetPath)

installRecord pRecord, "file", tTargetPath & slash & pName & ".desktop"

end installDesktopApplication

private command installDesktopIcon pRecord, pName, pSource, pAllUsers

local tTargetPath

put xdgDataPath(pAllUsers) & slash & "icons/hicolor/48x48/apps" into tTargetPath

-- Make sure the target path exists

installEnsureFolder tTargetPath

payloadExtractItemToFile pSource, empty, tTargetPath & slash & pName & ".png"

get shell("touch" && tTargetPath)

-- Regenerate the icon cache

-- Errors are ignored as the utility may not be present

get shell("gtk-update-icon-cache" && xdgDataPath(pAllUsers) & "/icons/hicolor")

installRecord pRecord, "file", tTargetPath & slash & pName & ".png"

end installDesktopIcon

private command installEnsureRecord pRecord

log "EnsureRecord: Ensuring new record exists at '" & pRecord & "'"

-- Make sure the target folder exists, note we can't use 'ensurefolder'

-- as this requires a writable record.

set the itemDelimiter to slash

installEnsureFolder item 1 to -2 of pRecord

set the itemDelimiter to comma

-- Now ensure the file is created and is empty

put empty into url ("file:" & installShortenPath(pRecord))

if the result is not empty then

log "EnsureRecord: failed to create record - " & the result

reportError "Internal error (couldn't create install record)."

end if

end installEnsureRecord

private command installSetRegistryKey pKey, pValue, pType

log "SetRegistryKey: Setting key '" & pKey & "' to '" & pValue & "' of type" && pType

if pType is "number" then

put "dword" into pType

put binaryEncode("i", pValue) into pValue

else if pType is "path" then

replace "/" with "\" in pValue

end if

set the itemDelimiter to "\"

installEnsureRegistryKey item 1 to -2 of pKey

get setRegistry(pKey & "\", pValue, pType)

if the result is not empty and (the result is not "can't delete value" or pValue is not empty) then

log "SetRegistryKey: failed to set key - " & the result

reportError "Unable to set registry key '" & pKey & "' to required value."

end if

end installSetRegistryKey

private command installSetRegistryValue pKey, pEntry, pValue, pType

log "SetRegistryValue: Setting value '" & pEntry & "' of key '" & pKey & "' to '" & pValue & "' of type" && pType

if pType is "number" then

put "dword" into pType

put binaryEncode("i", pValue) into pValue

else if pType is "path" then

replace "/" with "\" in pValue

end if

installEnsureRegistryKey pKey

get setRegistry(pKey & "\" & pEntry, pValue, pType)

if the result is not empty then

log "SetRegistryValue: failed to set value of key -" && the result

reportError "Unable to set registry value '" & pValue & "' of key '" & pKey & "' to required setting."

end if

end installSetRegistryValue

private command installEnsureRegistryKey pKey

log "EnsureRegistryKey: Ensure registry key '" & pKey & "' exists"

set the itemDelimiter to "\"

repeat with x = 2 to the number of items of pKey

local tKeyPrefix

put item 1 to x of pKey into tKeyPrefix

get queryRegistry(tKeyPrefix)

if the result is not "can't find key" then

next repeat

end if

log "EnsureRegistryKey: creating registry key '" & tKeyPrefix & "'"

get setRegistry(tKeyPrefix & "\", empty)

if the result is not empty then

log "EnsureRegistryKey: registry key creation failed -" && the result

reportError "Unable to create required registry key at '" & pKey & "'."

end if

end repeat

end installEnsureRegistryKey

private command installRename pRecord, pSource, pTarget

log "Rename: Renaming '" & pSource & "' to '" & pTarget & "'"

rename installShortenPath(pSource) to installShortenPath(pTarget)

if the result is not empty then

log "Rename: failed -" && the result

reportError "Unable to move components to final location."

end if

installRecord pRecord, "rename", pTarget, pSource

end installRename

private command installRecord pRecord, pType, pPath, pPath2

-- Shorten the path first

local tShortRecord

put installShortenPath(pRecord) into tShortRecord

-- Now enter the item in the record - note we open and close the file each entry. This ensures

-- that each action is written atomically, in case the installer crashes or suffers some other fate.

log "Record: Recording item of type '" & pType & "' with path '" & pPath & "'"

open file tShortRecord for text append

if the result is not empty then

log "Record: failed to open record - " && the result

reportError "Internal error (couldn't update install record)."

end if

write pType & tab & pPath & tab & pPath2 & return to file tShortRecord

if the result is not empty then

log "Record: failed to write to record - " && the result

reportError "Internal error (couldn't write to install record)."

end if