Comprehensive Guide to Retrieving and Passing Installation Paths in Inno Setup Scripts

Mastering ISS Scripts: Seamlessly Integrate User Installation Paths with Batch Scripts

Key Takeaways

• Customize Installation Paths: Allow users to select their preferred installation directory during setup.
• Retrieve Installation Path: Utilize registry entries and script variables to store and access the installation path.
• Integrate with Batch Scripts: Pass the installation path to batch files through parameters, environment variables, or configuration files.

---

Introduction

In the realm of software installation on Windows systems, Inno Setup (ISS) stands out as a robust and versatile installer creator. One of the common requirements during installation is to obtain the user-specified installation path and utilize it across various scripts, including batch files (.bat). This comprehensive guide delves into the methodologies and best practices for achieving this seamlessly using ISS scripts.

Customizing the Installation Path in Inno Setup

Allowing users to choose their installation directory enhances flexibility and user satisfaction. In ISS, this can be achieved by configuring specific directives and leveraging built-in constants.

Using Built-in Constants

Inno Setup provides several constants that represent common directories. The most pertinent for installation paths include:

• {app}: Represents the main application directory chosen by the user.
• {userdocs}: Points to the user's Documents folder.
• {pf}: Refers to "Program Files" directory.

By setting the DefaultDirName in the [Setup] section, you can define the default installation path:

[Setup]
  AppName=YourAppName
  AppVersion=1.0
  DefaultDirName={userdocs}\YourAppName
  DefaultGroupName=YourAppName
  

This configuration allows users to modify the installation directory during the setup process, providing them the flexibility to choose a preferred location.

Creating Directory Structures

To ensure the installation directory is correctly set up with necessary permissions and subdirectories, use the [Dirs] section:

[Dirs]
  Name: "{userdocs}\YourAppName"; Permissions: everyone-full
  

This script snippet creates the main application directory with full permissions for all users, ensuring that the application functions correctly regardless of user privileges.

Retrieving the Installation Path

Once the user selects the installation path, it's crucial to retrieve and store this information for subsequent use, especially when interfacing with batch scripts.

Storing Installation Path in the Registry

Utilizing the Windows Registry to store the installation path ensures persistent and system-wide accessibility. Here's how to implement this:

[Registry]
  Root: HKLM; Subkey: "Software\YourAppName"; ValueType: string; ValueName: "InstallPath"; ValueData: "{app}"; Flags: uninsdeletekey
  

This directive writes the installation path to the registry under HKLM\Software\YourAppName, making it accessible for retrieval by other scripts or applications.

Using Inno Setup Script Variables

In the [Code] section of your ISS script, define a global variable to hold the installation path:

[Code]
  var
    InstallPath: string;

  procedure InitializeWizard();
  begin
    InstallPath := ExpandConstant('{app}');
  end;
  

This script initializes the InstallPath variable with the user-selected directory, allowing it to be used throughout the installation process.

Reading Existing Installation Paths

To handle scenarios where the application is already installed, and you need to retrieve the existing installation path:

function GetExistingInstallPath(): String;
  begin
    if RegValueExists(HKLM, 'Software\YourAppName', 'InstallPath') then
      Result := RegQueryStringValue(HKLM, 'Software\YourAppName', 'InstallPath')
    else
      Result := ExpandConstant('{app}');
  end;
  

This function checks the registry for an existing installation path and returns it. If not found, it defaults to the current installation path.

---

Passing the Installation Path to Batch Scripts

Integrating the installation path with batch scripts is pivotal for automating tasks post-installation. There are multiple methods to achieve this:

Method 1: Passing as Command-Line Parameters

One of the most straightforward approaches is to pass the installation path as a parameter when executing the batch script.

[Run]
  Filename: "{app}\yourbatchscript.bat"; Parameters: """{app}"""
  

This line in the [Run] section executes the batch script, passing the installation path as an argument. In the batch script, you can access this parameter using %1:

@echo off
  set InstallPath=%1
  echo Installation path is: %InstallPath%
  

This method ensures that the batch script receives the exact path chosen by the user during installation.

Method 2: Writing to a Configuration File

Another effective technique is to write the installation path to a configuration file, which the batch script can then read:

[Run]
  Filename: "cmd.exe"; Parameters: "/C echo installPath={app} > ""{app}\config.txt"""; Flags: runhidden
  

The corresponding batch script reads the configuration file:

@echo off
  for /f "tokens=2 delims==" %%i in (config.txt) do set INSTALL_PATH=%%i
  echo Installation path is: %INSTALL_PATH%
  

This approach is beneficial when dealing with multiple variables or when you prefer not to pass parameters directly.

Method 3: Using Environment Variables

Setting an environment variable allows any subsequent scripts or applications to access the installation path globally:

[Registry]
  ; Setting a user environment variable
  Root: HKCU; Subkey: "Environment"; ValueType: string; ValueName: "YOUR_APP_PATH"; ValueData: "{app}"; Flags: preservestringtype
  

For system-wide access (requires administrative privileges), modify the system environment variables:

[Registry]
  ; Setting a system environment variable
  Root: HKLM; Subkey: "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"; ValueType: string; ValueName: "YOUR_APP_PATH"; ValueData: "{app}"; Flags: preservestringtype
  

After setting the environment variable, notify the system of the change:

[Code]
  procedure UpdateEnvironment();
  begin
    SendMessageTimeout(HWND_BROADCAST, WM_SETTINGCHANGE, 0, LPARAM(PChar('Environment')), SMTO_ABORTIFHUNG, 5000, PDWORD(nil)^);
  end;

  procedure CurStepChanged(CurStep: TSetupStep);
  begin
    if CurStep = ssPostInstall then
      UpdateEnvironment();
  end;
  

The batch script can now access the environment variable %YOUR_APP_PATH%:

@echo off
  echo Installation path is: %YOUR_APP_PATH%
  

This method is optimal for scenarios where the installation path needs to be accessed by multiple scripts or applications without explicitly passing parameters.

---

Implementing the Integration

Bringing all the pieces together ensures a smooth installation process where the installation path is accurately retrieved and utilized by batch scripts.

Step-by-Step Implementation

1. Define Installation Directories

Set up the [Setup] and [Dirs] sections to allow user customization and directory creation:

[Setup]
  AppName=YourAppName
  AppVersion=1.0
  DefaultDirName={pf}\YourAppName
  DefaultGroupName=YourAppName
  

[Dirs]
  Name: "{app}"; Permissions: everyone-full
  

2. Store Installation Path in the Registry

Ensure the installation path is stored for future retrieval:

[Registry]
  Root: HKLM; Subkey: "Software\YourAppName"; ValueType: string; ValueName: "InstallPath"; ValueData: "{app}"; Flags: uninsdeletekey
  

3. Retrieve Installation Path in the Script

In the [Code] section, define a variable and retrieve the installation path:

[Code]
  var
    InstallPath: string;

  procedure InitializeWizard();
  begin
    InstallPath := ExpandConstant('{app}');
  end;
  

4. Pass Installation Path to Batch Script

Choose a method to pass the installation path. Here's an example using command-line parameters:

[Run]
  Filename: "{app}\yourbatchscript.bat"; Parameters: """{app}"""; Flags: runhidden
  

And the corresponding batch script:

@echo off
  set InstallPath=%1
  echo Installation path is: %InstallPath%
  

5. Handling Permissions and Environment Variables

If opting to use environment variables, ensure that the installer has the necessary permissions to modify system-wide variables. Use the following script to set and notify changes:

[Registry]
  Root: HKLM; Subkey: "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"; ValueType: string; ValueName: "YOUR_APP_PATH"; ValueData: "{app}"; Flags: preservestringtype

  [Code]
  procedure UpdateEnvironment();
  begin
    SendMessageTimeout(HWND_BROADCAST, WM_SETTINGCHANGE, 0, LPARAM(PChar('Environment')), SMTO_ABORTIFHUNG, 5000, PDWORD(nil)^);
  end;

  procedure CurStepChanged(CurStep: TSetupStep);
  begin
    if CurStep = ssPostInstall then
      UpdateEnvironment();
  end;
  

This ensures that the environment variable YOUR_APP_PATH is set and recognized by the system immediately after installation.

---

Error Handling and Best Practices

Implementing robust error handling ensures that any issues during the installation process are gracefully managed, enhancing user experience.

Ensuring Correct Path Retrieval

Always validate that the installation path is correctly retrieved and stored. Use conditional checks within your scripts:

[Code]
  function GetInstallPath(): String;
  begin
    if RegValueExists(HKLM, 'Software\YourAppName', 'InstallPath') then
      Result := RegQueryStringValue(HKLM, 'Software\YourAppName', 'InstallPath')
    else
      Result := ExpandConstant('{app}');
  end;
  

Handling User Permissions

Modifying system environment variables requires administrative rights. Ensure that your installer requests the necessary permissions:

[Setup]
  PrivilegesRequired=admin
  

Alternatively, opt for user-level environment variables to avoid permission issues.

Validating Batch Script Execution

Ensure that the batch scripts execute successfully by checking the return codes and providing user feedback:

[Code]
  procedure ExecuteBatchScript();
  var
    ResultCode: Integer;
  begin
    if not Exec(ExpandConstant('{app}\yourbatchscript.bat'), '', '', SW_SHOWNORMAL, ewWaitUntilTerminated, ResultCode) then
      MsgBox('Batch script execution failed.', mbError, MB_OK);
  end;

  procedure CurStepChanged(CurStep: TSetupStep);
  begin
    if CurStep = ssPostInstall then
      ExecuteBatchScript();
  end;
  

This script attempts to run the batch file and notifies the user if execution fails.

---

Practical Examples

To solidify understanding, let's walk through a complete example integrating all the discussed methods.

Complete Inno Setup Script Example

The following ISS script allows users to select an installation path, stores it in the registry, sets an environment variable, and passes the path to a batch script:

[Setup]
  AppName=SampleApp
  AppVersion=1.0
  DefaultDirName={pf}\SampleApp
  DefaultGroupName=SampleApp
  PrivilegesRequired=admin

  [Dirs]
  Name: "{app}"; Permissions: everyone-full

  [Registry]
  ; Store installation path in registry
  Root: HKLM; Subkey: "Software\SampleApp"; ValueType: string; ValueName: "InstallPath"; ValueData: "{app}"; Flags: uninsdeletekey
  ; Set system environment variable
  Root: HKLM; Subkey: "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"; ValueType: string; ValueName: "SAMPLE_APP_PATH"; ValueData: "{app}"; Flags: preservestringtype

  [Files]
  Source: "yourbatchscript.bat"; DestDir: "{app}"; Flags: ignoreversion

  [Run]
  ; Execute the batch script with installation path as parameter
  Filename: "{app}\yourbatchscript.bat"; Parameters: """{app}"""; Flags: runhidden

  [Code]
  procedure UpdateEnvironment();
  begin
    SendMessageTimeout(HWND_BROADCAST, WM_SETTINGCHANGE, 0, LPARAM(PChar('Environment')), SMTO_ABORTIFHUNG, 5000, PDWORD(nil)^);
  end;

  procedure CurStepChanged(CurStep: TSetupStep);
  begin
    if CurStep = ssPostInstall then
      UpdateEnvironment();
  end;
  

Corresponding Batch Script Example

The batch script receives the installation path as a parameter and performs actions based on it:

@echo off
  REM Receive the installation path as the first argument
  set InstallPath=%1
  echo Installation Path Received: %InstallPath%

  REM Example action: Create a log file in the installation directory
  echo Installation completed on %date% at %time% > "%InstallPath%\install_log.txt"

  REM Additional batch operations can be added here
  pause
  

This script echoes the received installation path, creates a log file in the installation directory, and waits for user input before closing.

---

Conclusion

Effectively retrieving and passing the user-specified installation path in Inno Setup scripts is fundamental for creating versatile and user-friendly installers. By leveraging registry entries, environment variables, and configuration files, developers can ensure seamless integration with batch scripts and other post-installation processes. Adhering to best practices in error handling and permissions management further enhances the reliability and robustness of the installation experience.

References