I would like to introduce you to a PowerShell tool I built in 2023 and have been continually developing and adding features until this release. If you or your customer runs Maptek Vulcan, especially in a virtualised desktop platform from Vendors such as Citrix, Omnissa, Parallels, Dizzion, Microsoft and Amazon, you may want to consider using this tool to assist users with the support challenges for Maptek products, specifically Vulcan and BlastLogic. It primarily empowers the users with the ability to set, change and verify required Vulcan variables, ODBC connections, and mapped drives. It also facilitates setting the TEMP & TMP variables to a RAM Disk (if present), for the current process only, before starting Vulcan.
The Maptek products aside, this tool can be used as a template and modified to help enhance the delivery and experience for any application.
The following screen shot shows the user interface in two forms. Can you spot the differences? I will explain below what this means and all the functions the tool provides.
Background
Maptek Vulcan is specialised 3D mining software used for geological modelling, mine design, and mine planning. It has been widely used in the mining industry since the mid 1980s by Geologists, Surveyors, Mine and Geotechnical Engineers to analyse, visualise, and optimise mineral resources. It is also used for resource evaluation, feasibility studies, and operational planning. It integrates with many other mining applications.
From an IT Support point of view, it’s a beast of an application that has several limitations due to legacy code and settings that creates challenges for users when deployed into a Virtual Desktop platform. It’s written to run on high end laptops and workstations where users are not locked down too heavily. So when you add Cyber policies and locked down devices and desktops, it can be challenging for users to configure the software as needed without assistance.
The Challenges
Vulcan requires a few environment variables, drive mappings, and sometimes ODBC connections to be added/updated/changed depending on what the user is doing and which mine site data set they are working on. Also, different business units within the company may have a completely different set of standards, or none at all! So we need to allow for all of this. Setting these variables, drive mappings, and ODBC connections via policies based on group membership, for example, doesn’t provide the user with flexibility to change things on the fly as needed, especially in a 24×7 business. They cannot sit around and wait for someone to action a request. Even if it’s an automated request, it may still take some time to be implemented by Group Policy, SCCM, Intune, or other 3rd party tools. If they want to be able to change or set a variable on the fly, as an example, they should be able to do it themselves without an interruption to their work flows.
The odd button out in the UI is “Delete the BlastLogic Cache”. This is a known support issue for the Drill & Blast Engineers when using Maptek BlastLogic. The software can throw an error and will fail if there is an issue with the stored cache in their profile. This button enables them to simply clear it for themselves when this happens.
Vulcan can be challenging to deploy in a Citrix PVS non-persistent image. The main challenge can be with rapid consumption of Citrix PVS write-cache, depending on what tasks users were executing. With many mining apps there is a lot of importing and exporting, where a considerable amount of data will cycle through the users TEMP folder. Therefore the write-cache consumption could be quite aggressive over a working day.
I built a really valuable relationship the the Vendor support team that provided me plenty of valuable information over the years to help understand the requirements and deliver great outcomes for the business.
About the User Interface
A lot of thought went into the User Interface (UI) to ensure it was presented clearly to the users and provided enough functionality to help them perform their day to day tasks whilst reducing incidents and requests for support.
- As per the screen shot above it can append the Business Unit name to the “Maptek User Support Tools” in the title. This is not hard coded into the script. You need to call the script and use the BusinessUnit parameter, which will then be appended to the title.
- It says that “This is not a Maptek developed or supported tool”. This was important to remove confusion and ensure the users didn’t go directly to Maptek for any issues they may of experienced with the tool itself.
- It tells the users which Host they are running on. This is helpful from a support point of view.
- The tool defaults to Basic Feature only unless the Advanced parameter is specified. When you select Advanced Features, 3 extra buttons are enabled:
- Edit vulcan.prefs with Notepad++ (only enabled if it’s installed).
- Rename vulcan.prefs with time & date stamp.
- Open GPU Profiler Tool (only enabled if its installed).
- As per the screen shot above and the following screen shot and you’ll notice the difference between the two interfaces are the ENVIS_RESO, VULCAN_CORPORATE and CLIENT_LAVA environment variable settings. The “AU Iron Ore” Business Unit has standards that are added to the drop down list, whereas the “AU Coal” Business Unit does not implement standards for these variables, so users are free to browse to a local or network location if they want to set them.
- These standards are implemented via an XML file. When you call the script with the BusinessUnit parameter, it looks up that name in an accompanying XML file. If the values for these variables exist, it presents them in a drop down list, otherwise it presents the read-only text field with the Browse and Remove buttons.
- The VULCAN_THREADING variable allows multiple processing for tasks that don’t require dependent outputs. This is a good option to speed up processes involving calculations. A good practice is to set the variable to the number of logical CPU cores minus 1, which is the default action of this script. In an 8 core machine where we have 8 logical processors (with hyperthreading disabled), VULCAN_THREADING is set to 7. We use the minus 1 principle here to avoid starving Windows and other applications of all the CPU resources. Sometimes users may want to change this, so we allow it in this tool.
- Maptek recommends enabling the VULCAN_POLYLINES_CACHE environmental variable, by setting it to 1. This will stabilise and reduce the frequency of design database (dgd.isis) corruptions experienced in versions less than 2024.2. Polyline caching is automatically enabled from version 2024.2 onward. However, it’s a good practice to always leave this variable enabled in case Maptek experience code regression, which isn’t unheard of!
- The ENVIS_MAXTRI and ENVIS_MAXTRP variables are not used from version 9.0 and will be ignored. Vulcan 8.2.3 was the last version to use them. This tool will remove them altogether to avoid confusion when troubleshooting.
- Explanation for the next 15 buttons:
- Display Maptek Environment Variables – This provides an output of all important Vulcan variables so users can see and confirm what is set in both the user environment and also the current process to be confident that it’s setup as they expect. The list of variables we check for can be extended by updating the $VulcanUserVariables array in the script. The following screen shot is an example of the output.
- Run vulcan.prefs best practice analyser (BPA). This is a future feature I may add and have left a placeholder for it in the interface. I have found over the years that sometimes these preference files contain invalid settings that can cause issues for the users. Vulcan does not verify the settings each time it starts. The vulcan.prefs can be a rather complex file of different settings, so this feature may be challenging to complete. This would be great support functionality that Maptek should write. Maybe they will get to it before I do! Examples where I’ve seen issues:
- When migrating the Virtual Desktops from Windows 8.1 to Windows 10 1809, we found that the “fallback_font” was causing issues for the Maptek Vulcan Preferences config tool under Windows 10. This needed to be fixed for all users.
- The OpenCL settings for BCALC Engine and Implicit Modelling also need to reset with deployments of Virtual Machines that span across different NVIDIA GPU types, like P40, A40 and L40, etc. Users just need to go into the Maptek Preferences Config tool and tick a box, but it would be nice to automate for them.
- Edit vulcan.prefs with Notepad++ – This is an Advanced Feature that will only work if Notepad++ is also installed. Users can edit/view the vulcan.prefs file if needed, which sits in the root folder of their profile. Really only ever used by advanced users and Maptek Support. This can easily be changed over to any text editor if needed.
- Rename vulcan.prefs with time & date stamp – This is an Advanced Feature that will rename the vulcan.prefs so a new one will be created next time they start Vulcan. This helps them get back up and running in urgent situations where they are unable to wait for assistance. Or maybe they have received some advice from Maptek Support to rename/delete it.
- Delete the BlastLogic Cache – This will clear the BlastLogic cache stored in their Roaming Profile under the “%APPDATA%\Maptek\BlastLogic\Cache” folder.
- Open System Information Tool – This allows the users and Maptek Support to see the system specifications, should there be any doubt about supportability.
- Open File Explorer – This help them quickly open file explorer, especially when they are accessing this tool and Vulcan via Citrix Published Applications.
- Edit Environment Variables – This opens the Windows Environment Variables UI, where they can make direct changes to their user variables.
- Open Task Manager – This opens Task Manager, allowing them to monitor processes, performance, or end their tasks that may of hung, etc.
- Open Map Network Drive Dialog – This opens the Map Network Drive wizard to help them easily change or add mapped drives as needed.
- Open 32-bit ODBC Data Source Administrator – This opens the ODBC Data Source Administrator (32-bit) if they need to review connections. I’m not really sure this is still required, but left it in the tool for legacy purposes.
- Open 64-bit ODBC Data Source Administrator – This opens the ODBC Data Source Administrator (64-bit) if they need to review, change or add connections.
- Open NVIDIA Control Panel – Allowing users to open NVIDIA Control Panel is important if they feel there is a rendering or performance issue and want to experiment with different “3D App” profiles on the professional-grade Quadro GPUs. For most mining and Geoscience apps I set the default to “3D App – Visual Simulation”, which optimises performance for applications that heavily rely on 3D rendering and visual simulations. Maptek, recommend using either this profile or the “3D App – Game Development” profile.
- Open NVIDIA GPU Utilization Tool – This is another tool to help them monitor GPU usage in their session.
- Open GPU Profiler Tool – This is an Advanced Feature that opens the GPU Profiler Tool from Jeremy Main, if installed. This is an awesome tool that users can launch to capture data in real time if we feel they are hitting performance limitations for certain tasks. Then we can adjust the system configuration. I would normally sit with them or do a screen share to help them through it. If you run awesome tools like uberAgent, you can also get this data from the Splunk App, as an example.
- Display Maptek Environment Variables – This provides an output of all important Vulcan variables so users can see and confirm what is set in both the user environment and also the current process to be confident that it’s setup as they expect. The list of variables we check for can be extended by updating the $VulcanUserVariables array in the script. The following screen shot is an example of the output.
- The “Select a version of Vulcan to start” drop down list is populated by all installed versions of Vulcan. The default version displayed can be set using the VulcanDefaultVersion parameter. If you only want the default version displayed, use the DisplayDefaultVersionOnly parameter. The “HKEY_LOCAL_MACHINE\SOFTWARE\IT Audit” key is created by the Vulcan installer and is much more accurate than the Microsoft Uninstall key. So this key is what we use to accurately enumerate a list of all installed versions with the following information:
- Full Product Info
- Display Version
- Product Name
- Product Label
- Product Version
- Installation Directory
- The “Set Vulcan paths and variables to this version” button will set the paths and variables for both the user and current process.
- The “Set Vulcan paths and variables to this version when starting Vulcan” checkbox, will ONLY set the paths and variables for the current process when the Start Vulcan button is selected.
- Change the TEMP & TMP variables before starting Vulcan:
- If it cannot find an installed version of Vulcan, this option will be greyed out.
- A RAM Disk MUST be present, or this option will be greyed out. Therefore a prerequisite to deploying this script is to implement a RAM Disk solution. The PowerShell script is coded to leverage Arsenal Image Mounter (AIM) from Arsenal Recon for the detection of the Arsenal Image Mounter SCSI device, and uses the command line tool “C:\Program Files\Arsenal Image Mounter\aim_cli.exe” to enumerate available RAM Disks. Please refer to the following articles on why I chose this and how it’s deployed:
- I have also give the user an opt-out option for changing the TEMP & TMP variables. So if they or Maptek Support feel that this is causing issues, they can simply select “A RAM disk is not required” before selecting to “Start Vulcan”.
- Alternatively, if you use the DisableChangeTEMP command line parameter, this option will be greyed out.
- This will ONLY set the variables for the current process when the Start Vulcan button is selected.
- When the Start Vulcan button is selected, two command line arguments will be passed to WorkbenchLauncher.exe in the form of “/packageversion Maptek.Vulcan <Product Version. /drop_catcher” where…
- packageversion – Is the product version of Vulcan we want to default to in Workbench. We get this via the “IT Audit” registry key.
- drop_catcher – Allows Workbench to support drag-and-drop action.
- Whenever something in the tool is selected verbose output is displayed in the message area at the bottom and the UI.
- Once launched the UI will stay open for a maximum of 30 minutes, which ensures it is not left sitting idle keeping remote sessions alive when the application itself is closed.
Deployment
Download the PowerShell script and XML file (if needed) as documented below, which I place in the “C:\Program Files\Maptek” folder.
Setup a Start Menu shortcut, Desktop shortcut or Published App so that users will start “Maptek Support Tools” by running the Maptek-UserSupportTools.ps1 PowerShell script.
The script will run with no parameters by default. But it accepts up to 5 parameters if you want to change the default behaviour:
- BusinessUnit : This is a string that is used for two purposes.
- It will be appended to the name in the UI header.
- It is used to find a valid Location Name in the XML file, if that is required.
- VulcanDefaultVersion : If you have multiple versions of Vulcan installed, this will set a specific version as the default in the drop down list.
- DisplayDefaultVersionOnly : If you have multiple versions of Vulcan installed, setting this to True will only display the version defined by the VulcanDefaultVersion variable.
- Advanced : Setting this to True will enable the Advanced features by default.
- UseRAMDisk : If this setting is set to True it will default the UI radio button to “Use the detected RAM disk”. If not specified, or set to False, it will default to “A RAM disk is not required”.
- DisableChangeTEMP : Setting this to True will disable the ability for users to change the TEMP & TMP variable location to the RAM Disk for the current process. If the parameter is not set, or set to False, changing the TEMP & TMP variable location is enabled in this tool by default.
Note that if the BusinessUnit parameter contains a space in the name, simply escape the space with a backtick as per the following example command lines.
Example command lines:
Command line argument for Australian Iron Ore Business that sets the “Use the detected RAM disk” radio button to be enabled by default:
PowerShell -ExecutionPolicy Bypass "C:\Program Files\Maptek\Maptek-UserSupportTools.ps1" -BusinessUnit:"AU` Iron` Ore" -UseRAMDisk
You can see from the following screen shot of the WorkbenchClient.exe and WorkbenchServer.exe processes that the Vulcan environment variables were set to the version I launched as well as the TEMP and TMP variables are set to the RAM Disk for the current process and child/sub processes ONLY.
Command line argument for Australian Coal Business that sets version 2023.4 as the default and only version in the “Select a version of Vulcan to start” drop down list.
PowerShell -ExecutionPolicy Bypass "C:\Program Files\Maptek\Maptek-UserSupportTools.ps1" -BusinessUnit:"AU` Coal" -VulcanDefaultVersion:"2023.4" -DisplayDefaultVersionOnly
Command line argument for Americas Copper Business that sets version 2022.4 as the default version in the “Select a version of Vulcan to start” drop down list.
PowerShell -ExecutionPolicy Bypass "C:\Program Files\Maptek\Maptek-UserSupportTools.ps1" -BusinessUnit:"AMER` Copper" -VulcanDefaultVersion:"2022.4"
Logging
The users will see logging in the message area at the bottom and the UI like this…
There is also a full Maptek-UserSupportTools.log transcription file written to their standard TEMP folder…
The XML File
The XML file is self explanatory. The sample is included in the download with the PowerShell script.
<?xml version="1.0" encoding="utf-8"?>
<!--
' // ***************************************************************************
' //
' // Written by Jeremy Saunders (jeremy@jhouseconsulting.com) 22nd September 2023
' //
' // File: Maptek-UserSupportTools.xml
' //
' // Version: 1.0
' //
' // If data in your XML tags use specical characters, it will generate an exception
' // when read as it's considered invalid. For example, the '&' character is invalid
' // and using it as is will generate an exception. Instead, we need to replace it
' // with its escaped equivalent. The following table lists the characters that need
' // to be escaped.
' //
' // Invalid character Replace with
' // < <
' // > >
' // " "
' // ' '
' // & &
' //
' // ***************************************************************************
-->
<configuration>
<Location Name="AU Iron Ore">
<ENVIS_RESO>
<!--
For the ENVIS_RESO environment variable we set "V:\Vulcan\Resources\ENVIS_RESO" for everyone, which is available across all file servers.
However, some members of the Drill & Blast team set it to "V:\Working_Areas\Drill_and_Blast\Vulcan\ENVIS_RESO\resources" for the WoopWoop
Mine Site.
The ENVIS_RESO environment variable is where the plotting sheets go. Whilst all Mine Sites use the standard plotting function, the Drill &
Blast team at WoopWoop are the only ones that have custom plot sheets.
-->
<Setting Name="Standard = V:\Vulcan\Resources\ENVIS_RESO">
<Path>V:\Vulcan\Resources\ENVIS_RESO</Path>
</Setting>
<Setting Name="Drill & Blast (WoopWoop) = V:\Working_Areas\Drill_and_Blast\Vulcan\ENVIS_RESO\resources">
<Path>V:\Working_Areas\Drill_and_Blast\Vulcan\ENVIS_RESO\resources</Path>
</Setting>
</ENVIS_RESO>
<VULCAN_CORPORATE>
<!--
Users can enable or disable the VULCAN_CORPORATE environment variable. We set it to "V:\Vulcan\Master_Area\Corporate_Standard", which is
available across all file servers. However, sometimes users may not want this to apply, so they have the option to remove it.
-->
<Setting Name="V:\Vulcan\Master_Area\Corporate_Standard">
<Path>V:\Vulcan\Master_Area\Corporate_Standard</Path>
</Setting>
</VULCAN_CORPORATE>
<CLIENT_LAVA>
<!--
Users can enable or disable the CLIENT_LAVA environment variable. We set it to "V:\Vulcan\Resources\LAVA_SCRIPTS", which is available across
all file servers. However, sometimes users may not want this to apply, so they have the option to remove it.
-->
<Setting Name="V:\Vulcan\Resources\LAVA_SCRIPTS">
<Path>V:\Vulcan\Resources\LAVA_SCRIPTS</Path>
</Setting>
</CLIENT_LAVA>
</Location>
</configuration>
The Script
Here is the Maptek-UserSupportTools (4 downloads) script as a zip with the sample XML file included.
<#
This PowerShell UI has been written to assist with many support challenges for Maptek products, specifically Vulcan and BlastLogic. It
primarily empowers the users with the ability to set, change and verify required Vulcan variables, as well as setting the TEMP & TMP
variables to a RAM Disk for the current process only.
This tool will work with Vulcan 10 and above that use the WorkbenchLauncher.exe
For companies or business units that use standards for the ENVIS_RESO, VULCAN_CORPORATE and CLIENT_LAVA variables, an accompanying XML
file can be used to allow these variables to be set and unset to specific locations only.
Example of XML:
<configuration>
<Location Name="AU Iron Ore">
<ENVIS_RESO>
<Setting Name="Standard = V:\Vulcan\Resources\ENVIS_RESO">
<Path>V:\Vulcan\Resources\ENVIS_RESO</Path>
</Setting>
<Setting Name="Drill & Blast (WoopWoop) = V:\Working_Areas\Drill_and_Blast\Vulcan\ENVIS_RESO\resources">
<Path>V:\Working_Areas\Drill_and_Blast\Vulcan\ENVIS_RESO\resources</Path>
</Setting>
</ENVIS_RESO>
<VULCAN_CORPORATE>
<Setting Name="V:\Vulcan\Master_Area\Corporate_Standard">
<Path>V:\Vulcan\Master_Area\Corporate_Standard</Path>
</Setting>
</VULCAN_CORPORATE>
<CLIENT_LAVA>
<Setting Name="V:\Vulcan\Resources\LAVA_SCRIPTS">
<Path>V:\Vulcan\Resources\LAVA_SCRIPTS</Path>
</Setting>
</CLIENT_LAVA>
</Location>
</configuration>
Otherwise the CLIENT_LAVA, ENVIS_RESO and VULCAN_CORPORATE variables can be set to valid network paths using a browse button.
The VULCAN_THREADING variable allows multiple processing for tasks that don't require dependent outputs. This is a good option to speed up
processes involving calculations. A good practice is to set the variable to the number of logical CPU cores minus 1, which is the default action
of this script. In an 8 core machine where we have 8 logical processors (with hyperthreading disabled), VULCAN_THREADING is set to 7. We use the
minus 1 principle here to avoid starving Windows and other applications of all the CPU resources. Sometimes users may want to change this, so we
allow it in this tool.
Maptek recommends enabling the VULCAN_POLYLINES_CACHE environmental variable, by setting it to 1. This will stabilise and reduce the frequency
of design database (dgd.isis) corruptions experienced in versions less than 2024.2. Polyline caching is automatically enabled from version 2024.2
onward. However, it's a good practice to always leave this variable enabled in case Maptek experience code regression.
The ENVIS_MAXTRI and ENVIS_MAXTRP variables are not used from version 9.0 and will be ignored. Vulcan 8.2.3 was the last version to use them.
This tool will remove them altogether to avoid confusion when troubleshooting.
The "HKEY_LOCAL_MACHINE\SOFTWARE\IT Audit" key is created by the Vulcan installer and is much more accurate than the Microsoft Uninstall key.
From here we can accurately get the following information for each installed version:
- Full Product Info
- Display Version
- Product Name
- Product Label
- Product Version
- Installation Directory
When you select the Start Vulcan button...
1) The MMT_VULCAN, VULCAN, VULCAN_EXE_RP variables need to be changed/set appropriately for each version of Vulcan.
- MMT_VULCAN = C:\Program Files\Maptek\Vulcan <version>
- VULCAN = C:\Program Files\Maptek\Vulcan <version>
- VULCAN_EXE_RP = C:\Program Files\Maptek\Vulcan <version>\bin\exe
2) Existing "vulcan" paths in the PATH variable will be removed and the following 3 paths will be appended to the use PATH variable:
- C:\Program Files\Maptek\Vulcan <version>\bin\exe;C:\Program Files\Maptek\Vulcan <version>\lib\perl;C:\Program Files\Maptek\Vulcan <version>\bin\cygnus\bin
Note that the PATH variable is a combined result of the system and user variables. The user path is appended to the system path.
When launching Vulcan it requires two command line arguments:
- packageversion - We set this to the Version of Vulcan we want to default to in Workbench. We get this via the "IT Audit" registry key.
- drop_catcher - This allows Workbench to support drag-and-drop action.
If we want to deploy multiple versions of Vulcan side-by-side, but ensure that only the production version is available to use via Workbench,
we can "hide" it by editing the registry to stop the Workbench detecting the installed Vulcan version(s). We would need to use SetACL to
deprotect the following registry keys during installation, and then this script can manage the keys based on script variables, etc:
- HKEY_LOCAL_MACHINE\SOFTWARE\Maptek\Workbench\Client\PluginSearchPaths
- HKEY_LOCAL_MACHINE\SOFTWARE\Maptek\Workbench\Server\PluginSearchPaths
3rd Party Tools - The following tools are required to be installed. If they are not installed, the buttons in the tool will be disabled.
- Notepad++
- NVIDIA Control Panel and NVIDIA GPU Utilization tool, which is installed with NVIDIA Control Panel
Refer to my article: https://www.jhouseconsulting.com/2024/07/14/restoring-the-nvidia-control-panel-and-tools-after-the-appx-package-change-2903
- GPUProfiler (by Jeremy Main): https://github.com/JeremyMain/GPUProfiler
Some Windows processes need elevated privileges to run:
- Task Manager (Taskmgr.exe)
- ODBC Data Source Administrator (odbcad32.exe)
GPUProfiler will be started with elevated privileges to avoid restructions when collecting performance data.
The script will run with no parameters by default. But it accepts up to 5 parameters if you want to change the default behaviour:
- BusinessUnit : This is a string that is used for two purposes.
1) It will be appended to the name in the UI header.
2) It is used to find a valid Location Name in the XML file, if that is required.
If the BusinessUnit parameter contains a space in the name, simply escape the space with a backtick.
- VulcanDefaultVersion : If you have multiple versions of Vulcan installed, this will set a specific version as the default in the drop down list.
- DisplayDefaultVersionOnly : If you have multiple versions of Vulcan installed, setting this to True will only display the version defined by the
VulcanDefaultVersion variable.
- Advanced : Setting this to True will enable the Advanced features by default.
- UseRAMDisk : If this setting is set to True it will default the UI radio button to "Use the detected RAM disk". If not specified, or set to False,
it will default to "A RAM disk is not required".
- DisableChangeTEMP : Setting this to True will disable the ability for users to change the TEMP & TMP variable location to the RAM Disk for the
current process. If the parameter is not set, or set to False, changing the TEMP & TMP variable location is enabled in this tool
by default.
Create a published app in Citrix Studio to launch it:
- Application Name: Maptek User Support Tools
- Path to executable file: C:\WINDOWS\system32\WindowsPowerShell\v1.0\powershell.exe
- Example command lines:
- Command line argument for Australian Iron Ore Business: -ExecutionPolicy Bypass -WindowStyle Hidden -File "C:\Program Files\Maptek\Maptek-UserSupportTools.ps1" -BusinessUnit:"AU` Iron` Ore" -VulcanDefaultVersion:"2024.3" -UseRAMDisk
- Command line argument for Australian Coal Business: -ExecutionPolicy Bypass -WindowStyle Hidden -File "C:\Program Files\Maptek\Maptek-UserSupportTools.ps1" -BusinessUnit:"AU` Coal" -VulcanDefaultVersion:"2023.4" -DisplayDefaultVersionOnly
- Command line argument for Americas Copper Business: -ExecutionPolicy Bypass -WindowStyle Hidden -File "C:\Program Files\Maptek\Maptek-UserSupportTools.ps1" -BusinessUnit:"AMER` Copper" -VulcanDefaultVersion:"2020.2" -DisplayDefaultVersionOnly
Future Updates:
- Code the vulcan.prefs best practice analyzer. I have found over the years that sometimes these preference files contain invalid settings that
can cause issues for the users. The vulcan.prefs can be a rather complex file of different settings, so this feature may be challenging to
complete, which should really be written by Maptek!
Script Name: Maptek-UserSupportTools.ps1
Release 1.8
Written by Jeremy Saunders (jeremy@jhouseconsulting.com) 12th April 2023
Modified by Jeremy Saunders (jeremy@jhouseconsulting.com) 1st April 2025
#>
#-------------------------------------------------------------
[cmdletbinding()]
param (
[string]$BusinessUnit,
[string]$VulcanDefaultVersion,
[switch]$DisplayDefaultVersionOnly,
[switch]$Advanced,
[switch]$UseRAMDisk,
[switch]$DisableChangeTEMP,
[switch]$RemoveRedundantVariables=$True,
[switch]$HideConsole
)
# Set Powershell Compatibility Mode
Set-StrictMode -Version 2.0
# Enable verbose, warning and error mode
$VerbosePreference = 'Continue'
$WarningPreference = 'Continue'
$ErrorPreference = 'Continue'
#-------------------------------------------------------------
$StartDTM = (Get-Date)
# Set the working folder to the users TEMP folder
$LogFolder = [System.IO.Path]::GetTempPath()
# Get the script path
$ScriptPath = {Split-Path $MyInvocation.ScriptName}
$ScriptPath = $(&$ScriptPath)
# Get the script name
$ScriptName = [System.IO.Path]::GetFilenameWithoutExtension($MyInvocation.MyCommand.Path.ToString())
# Start the transcript
try {
Start-Transcript "$LogFolder$ScriptName.log"
}
catch {
Write-Verbose "$(Get-Date -format "dd/MM/yyyy HH:mm:ss"): This host does not support transcription"
}
#-------------------------------------------------------------
# Make sure the release version is updated accordingly so it's correct in the form Title Bar.
$Release = "1.8"
# Setting an empty string will exclude it from the form Title Bar.
$DevelopedBy = "Jeremy Saunders"
# Set the name and path for the XMLFile
$XMLFilePath = "$ScriptPath\$ScriptName.xml"
#-------------------------------------------------------------
# Hide the PowerShell console window without hiding the other child windows that it spawns
# - http://powershell.cz/2013/04/04/hide-and-show-console-window-from-gui/
$Code = @"
[DllImport("Kernel32.dll")]
public static extern IntPtr GetConsoleWindow();
[DllImport("user32.dll")]
public static extern bool ShowWindow(IntPtr hWnd, Int32 nCmdShow);
"@
# Create new types as per the definition above.
Add-Type -Namespace Console -Name Window -MemberDefinition $code -PassThru | out-null
Function Show-Console {
$consolePtr = [Console.Window]::GetConsoleWindow()
#5 show
[Console.Window]::ShowWindow($consolePtr, 5)
}
Function Hide-Console {
$consolePtr = [Console.Window]::GetConsoleWindow()
#0 hide
[Console.Window]::ShowWindow($consolePtr, 0)
}
If ($HideConsole) {
Hide-Console | out-null
}
#-------------------------------------------------------------
# This function has been written to return all the installed versions of Vulcan.
# The "IT Audit" key is created by the Vulcan installer and seems to be more accurate than the Uninstall key.
Function GetVulcanInstalledVersions {
$computername = "$env:computername"
$results = @()
#Define the variable to hold the location of Currently Installed versions
$ITAuditKeys=@("SOFTWARE\IT Audit")
#Create an instance of the Registry Object and open the HKLM base key
Try {
$reg=[microsoft.win32.registrykey]::OpenRemoteBaseKey('LocalMachine',$computername)
ForEach($ITAuditKey in $ITAuditKeys) {
#Drill down into the Uninstall key using the OpenSubKey Method
$regkey=$reg.OpenSubKey("$ITAuditKey")
#Retrieve an array of string that contain all the subkey names
$subkeys=$regkey.GetSubKeyNames()
#Open each Subkey and use the GetValue Method to return the string value for DisplayName for each
foreach($key in $subkeys){
$ResultProps = @{
FullProductInfo = $null
DisplayVersion = $null
ProductName = $null
InstallationDirectory = $null
ProductLabel = $null
ProductVersion = $null
}
$ResultProps.FullProductInfo = $key
$thisKey=$ITAuditKey+"\\"+$key+"\PRODUCT"
$thisSubKey=$reg.OpenSubKey($thisKey)
$ResultProps.DisplayVersion = $thisSubKey.GetValue("Display Version")
$ResultProps.ProductName = $thisSubKey.GetValue("Product Name")
$ResultProps.ProductLabel = $thisSubKey.GetValue("Product Label")
$ResultProps.ProductVersion = $thisSubKey.GetValue("Product Version")
$thisSubKey.Dispose()
$thisKey=$ITAuditKey+"\\"+$key+"\INSTALLATION"
$thisSubKey=$reg.OpenSubKey($thisKey)
$ResultProps.InstallationDirectory = $thisSubKey.GetValue("Installation Directory")
$thisSubKey.Dispose()
$results += New-Object PsObject -Property $ResultProps
}
$regkey.Dispose()
}
$reg.Dispose()
}
Catch {
#
}
return $results
}
#-------------------------------------------------------------
Function Get-TotalSystemRAM {
$TotalRAM = 0
$CanConnect = $false
Try {
$ComputerInformation = Get-WmiObject -Class Win32_ComputerSystem -ErrorAction Stop | Select-Object `
@{N="TotalPhysicalRam"; E={[math]::round(($_.TotalPhysicalMemory / 1GB),0)}}
$CanConnect = $true
}
Catch {
$ErrorDescription = "Error connecting using the Get-WmiObject cmdlet."
write-warning "*ERROR*: $ErrorDescription" -verbose
}
if ($CanConnect) {
$TotalRam = $ComputerInformation.totalphysicalram
}
return $TotalRam
}
#-------------------------------------------------------------
Function Get-FSLogixLocalProfilePath {
$ResultProps = @{
LocalProfilePathFound = $False
FullPath = ""
FolderName = ""
}
$Value = ""
$ErrorActionPreference = "stop"
try {
If ((Get-ItemProperty -Path "HKCU:\SOFTWARE\FSLogix\Profiles\Session" | Select-Object -ExpandProperty "LocalProfilePath") -ne $null) {
$ResultProps.LocalProfilePathFound = $True
$ResultProps.FullPath = (Get-ItemProperty -Path "HKCU:\SOFTWARE\FSLogix\Profiles\Session" | Select-Object -ExpandProperty "LocalProfilePath")
# Extract the child folder from the USERPROFILE path
$ResultProps.FolderName = (Split-Path -Path $($ResultProps.FullPath) -Leaf)
}
}
catch {
#
}
$ErrorActionPreference = "Continue"
return $ResultProps
}
#-------------------------------------------------------------
Function Get-UserProfileChildFolder {
$userProfileChildFolder = ""
# Get the USERPROFILE environment variable
#$userProfile = [Environment]::GetEnvironmentVariable("USERPROFILE", "Process")
$userProfile = $env:USERPROFILE
# Extract the child folder from the USERPROFILE path
$userProfileChildFolder = (Split-Path -Path "${env:USERPROFILE}" -Leaf)
return $userProfileChildFolder
}
#-------------------------------------------------------------
Function Get-FirstAvailableRAMDisk {
# Set the path for the Arsenal Image Mounter CLI (AIM CLI)
$Executable = "${env:ProgramFiles}\Arsenal Image Mounter\aim_cli.exe"
$DriveLetters = @()
$IsDriverInstalled = $false
$CanConnect = $false
Try {
$PnPSignedDriver = Get-WmiObject -Class Win32_PnPSignedDriver -ErrorAction Stop | Where {$_.Description -eq "Arsenal Image Mounter"}
$CanConnect = $true
}
Catch {
$ErrorDescription = "Error connecting using the Get-WmiObject cmdlet."
write-warning "*ERROR*: $ErrorDescription" -verbose
}
if ($CanConnect -AND $null -ne $PnPSignedDriver) {
$IsDriverInstalled = $true
write-verbose "The Arsenal Image Mounter SCSI device is installed" -verbose
write-verbose "- Device ID: $($PnPSignedDriver.DeviceID)" -verbose
write-verbose "- Device Version: $($PnPSignedDriver.DriverVersion)" -verbose
} Else {
write-verbose "The Arsenal Image Mounter SCSI device is not installed" -verbose
}
If ($IsDriverInstalled -AND (Test-Path -Path "$Executable")) {
$AllRamDisks = $null
$MyArgs = "--list"
write-verbose "Get all RAM disk devices" -verbose
write-verbose "- Starting the process: `"$Executable`"" -verbose
write-verbose "- with the arguments: $MyArgs" -verbose
$pinfo = New-Object System.Diagnostics.Process
$pinfo.StartInfo.FileName = $Executable
# WindowStyle; 1 = hidden, 2 =maximized, 3=minimized, 4=normal
$pinfo.StartInfo.WindowStyle = 1
$pinfo.StartInfo.Arguments = $MyArgs
$pinfo.StartInfo.RedirectStandardError = $True
$pinfo.StartInfo.RedirectStandardOutput = $True
$pinfo.StartInfo.UseShellExecute = $false
Try {
$null = $pinfo.start() | Out-Null
$AllRamDisks = $pinfo.StandardOutput.ReadToEnd().Trim().Split("`r`n")
$AllRamDisks += $pinfo.StandardError.ReadToEnd().Trim().Split("`r`n")
}
Catch {
#
}
$pinfo.Dispose()
If ($AllRamDisks -Like "*No virtual disks*") {
write-verbose "No virtual disks mounted" -verbose
} Else {
$TotalRAMDisks = 0
ForEach ($Line in $AllRamDisks) {
$MountedAt = ""
If ($Line -like "*Mounted at*") {
$MountedAt = ($Line.Trim() -Split("Mounted at"))[1].Trim()
}
if (!([String]::IsNullOrEmpty($MountedAt))) {
$TotalRAMDisks++
$DriveLetters += $MountedAt
}
}
If ($TotalRAMDisks -eq 1) {
write-verbose "$TotalRAMDisks RAM disk found" -verbose
} Else {
write-verbose "$TotalRAMDisks RAM disks found" -verbose
}
}
}
return $DriveLetters
}
#-------------------------------------------------------------
Function IsAccessAllowed {
param(
[string]$Folder,
[switch]$ConsoleOutput
)
If (TEST-PATH $Folder) {
If ($ConsoleOutput) {
write-verbose "Testing access to: $Folder" -verbose
}
Get-ChildItem -path $Folder -EA SilentlyContinue -ErrorVariable ErrVar is
# The -ErrorVariable common parameter creates an ArrayList. This variable
# always initialized which means it will never be $null. The proper way
# to test if an ArrayList is empty or not is to use the Count property. It
# should be empty or equal to 0 if there are no errors.
If ($ErrVar.count -eq 0) {
If ($ConsoleOutput) {
write-verbose "Access is good" -verbose
}
$return = $True
} Else {
If ($ConsoleOutput) {
write-warning "Access denied" -verbose
}
$return = $False
}
} Else {
If ($ConsoleOutput) {
write-warning "The `"$Folder`" does not exist" -verbose
}
$return = $False
}
return $return
}
#-------------------------------------------------------------
Function Get-RamDisks {
# Check for existance of a RAM disk
# - Get the drive letter, size, freespace, and build an array for the drop down list.
# - Set the largest available RAM disk as the preferred for the drop down list.
$ResultProps = @{
RAMDiskFound = $False
RAMDISKS = @()
PreferredRAMDisk = ""
}
$RAMDiskLetters = Get-FirstAvailableRAMDisk
$LargestRAMDiskSize = 0
ForEach ($Letter in $RAMDiskLetters) {
$RAMDiskLetter = $Letter.TrimEnd("\")
$RAMDiskLetter = $RAMDiskLetter.TrimEnd(":")
If (IsAccessAllowed -Folder "${RAMDiskLetter}:\") {
$ResultProps.RAMDiskFound = $True
$RAMDiskSize = 0
$RAMDiskFreeSpace = 0
$CanConnect = $false
Try {
$LogicalDiskInformation = Get-WmiObject -Class Win32_LogicalDisk -Filter "DeviceID='${RAMDiskLetter}:'" -ErrorAction Stop | Select-Object `
@{N="TotalSize"; E={[math]::round(($_.Size / 1GB),0)}},@{N="TotalFreeSpace"; E={[math]::round(($_.FreeSpace / 1GB),0)}}
$CanConnect = $true
}
Catch {
$ErrorDescription = "Error connecting using the Get-WmiObject cmdlet."
write-warning "*ERROR*: $ErrorDescription" -verbose
}
if ($CanConnect) {
$RAMDiskSize = ($LogicalDiskInformation.TotalSize).ToString()
$RAMDiskFreeSpace = ($LogicalDiskInformation.TotalFreeSpace).ToString()
}
If ($RAMDiskSize -gt $LargestRAMDiskSize) {
$LargestRAMDiskSize = $RAMDiskSize
$ResultProps.PreferredRAMDisk = $RAMDiskLetter
}
$ResultProps.RAMDISKS += @([pscustomobject]@{name=" ${RAMDiskLetter}: Drive - Total size of $RAMDiskSize GB with $RAMDiskFreeSpace GB of free space";description=$RAMDiskLetter})
}
}
return $ResultProps
}
#-------------------------------------------------------------
Function Get-EnvVariable {
Param
(
[Parameter(Mandatory=$true)]
[string]$Name,
[switch]$Process,
[switch]$Machine
)
$MyVar = $null
If ($Machine -eq $False) {
If ($Process -eq $False) {
$keyPath = "Registry::HKEY_CURRENT_USER\Environment"
$Scope = [System.EnvironmentVariableTarget]::User
} Else {
$keyPath = ""
$Scope = [System.EnvironmentVariableTarget]::Process
}
} Else {
$keyPath = "Registry::HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Environment"
$Scope = [System.EnvironmentVariableTarget]::Machine
}
# Get the Environment Variable
$Value = [System.Environment]::GetEnvironmentVariable($Name, $Scope)
If (![String]::IsNullOrEmpty($Value)) {
$MyVar = [pscustomobject]@{
Name = $Name
Value = $Value
}
}
# If this function is run directly after a software install, the Environment Variables may not be available.
# So we get that directly from the registry.
If ($Process -eq $False) {
If ([String]::IsNullOrEmpty($MyVar)) {
$MyVar = Get-Item -literalPath $keyPath -PipelineVariable key | Get-ItemProperty | ForEach-Object {
$_.PSObject.Properties | Where-Object Name -eq $Name | ForEach-Object {
[pscustomobject]@{
Name = $_.Name
Value = $_.Value
}
}
}
}
}
return $myvar
}
#-------------------------------------------------------------
Function Get-LogicalProcessorCount {
$NumberOfLogicalProcessors = 0
$ProcessorCountArray = @()
Try {
$ProcessorCountArray = Get-WmiObject -Class win32_Processor -ErrorAction Stop | Select-Object DeviceID, SocketDesignation, NumberOfLogicalProcessors
ForEach ($ProcessorCount in $ProcessorCountArray) {
$NumberOfLogicalProcessors = $NumberOfLogicalProcessors + $ProcessorCount.NumberOfLogicalProcessors
}
}
Catch [System.Exception]{
#$($Error[0].Exception.Message)
}
return $NumberOfLogicalProcessors
}
#-------------------------------------------------------------
Function Get-NVIDIAControlPanelTool {
# This function was witten to help overcome NVIDIA bug #4644253 as referenced in Case 00697597.
param (
[string]$Program
)
$results = @()
$ResultProps = @{
Commandline = $null
Arguments = $null
}
$Found = $False
If (TEST-PATH "${env:ProgramFiles}\NVIDIA Corporation\Control Panel Client\$Program") {
$Found = $True
$ResultProps.Commandline = "${env:ProgramFiles}\NVIDIA Corporation\Control Panel Client\$Program"
$ResultProps.Arguments = ""
}
If ($Found -eq $False) {
ForEach ($AppPackage in (Get-AppxPackage -Name "Nvidia*")) {
ForEach ($Application in (Get-AppxPackageManifest $AppPackage).package.applications.application) {
If ($Application.Executable -eq "$Program") {
$Found = $True
$ResultProps.Commandline = "${env:SystemRoot}\explorer.exe"
$ResultProps.Arguments = "shell:appsFolder\" + $AppPackage.packagefamilyname + "!" + $Application.Id
}
}
}
}
If ($Found -eq $False) {
#write-warning "The `"$Program`" NVIDIA Control Panel tool was not found on this computer!" -verbose
}
$results += New-Object PsObject -Property $ResultProps
return $results
}
#-------------------------------------------------------------
Function EnvironmentRefresh {
# Send a WM_SETTINGCHANGE broadcast message with "Environment" as the parameter to all open windows, indicating a change in the
# environment variables. It is used to reload/refresh the environment variables in all running processes without the need for a
# system restart.
# This is used in scenarios where a change in user and system environment variables needs to be propagated immediately to all
# running applications and services.
# Notes:
# - Applications and services that have a top-level window will be notified of a change in the environment variables.
# - A restart of some applications and services may still be necessary for the changes to take effect, as some processes only
# read environment variables at startup.
# - Not all applications will respond to the WM_SETTINGCHANGE message, especially those that do not have a top-level window or
# those that simply choose to ignore the message. In those cases, a system restart or individual application/service restart
# might still be necessary.
param (
[switch]$EnableDebug
)
$HWND_BROADCAST = [IntPtr] 0xffff;
$WM_SETTINGCHANGE = 0x1a;
$result = [UIntPtr]::Zero
if (-not ("Win32.NativeMethods" -as [Type])) {
# import sendmessagetimeout from win32
Add-Type -Namespace Win32 -Name NativeMethods -MemberDefinition @"
[DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)]
public static extern IntPtr SendMessageTimeout(
IntPtr hWnd, uint Msg, UIntPtr wParam, string lParam,
uint fuFlags, uint uTimeout, out UIntPtr lpdwResult);
"@
}
# notify all windows of environment block change
If ($EnableDebug) {
write-verbose "Sending a WM_SETTINGCHANGE message to all the open windows..." -verbose
}
[void][Win32.Nativemethods]::SendMessageTimeout($HWND_BROADCAST, $WM_SETTINGCHANGE, [UIntPtr]::Zero, "Environment", 2, 5000, [ref] $result)
If ($EnableDebug) {
if ($result -eq 0) {
write-warning "- Failed to reload environment variables." -verbose
} else {
write-verbose "- Environment variables have been reloaded." -verbose
}
}
}
#-------------------------------------------------------------
Function Get-FolderName {
# To ensure the dialog window shows in the foreground, you need to get a Window Handle from the owner process.
# This handle must implement System.Windows.Forms.IWin32Window
# Create a wrapper class that implements IWin32Window.
# The IWin32Window interface contains only a single property that must be implemented to expose the underlying handle.
Param
(
[string]$RootFolder = 'MyComputer',
[string]$Description = "Select Staging Folder.",
[switch]$ShowNewFolderButton
)
$code = @"
using System;
using System.Windows.Forms;
public class Win32Window : IWin32Window
{
public Win32Window(IntPtr handle)
{
Handle = handle;
}
public IntPtr Handle { get; private set; }
}
"@
if (-not ([System.Management.Automation.PSTypeName]'Win32Window').Type) {
Add-Type -TypeDefinition $code -ReferencedAssemblies System.Windows.Forms.dll -Language CSharp
}
# Get the window handle from the current process
# $owner = New-Object Win32Window -ArgumentList ([System.Diagnostics.Process]::GetCurrentProcess().MainWindowHandle)
# Or write like this:
$owner = [Win32Window]::new([System.Diagnostics.Process]::GetCurrentProcess().MainWindowHandle)
# Or use the the window handle from the desktop
# $owner = New-Object Win32Window -ArgumentList (Get-Process -Name explorer).MainWindowHandle
# Or write like this:
# $owner = [Win32Window]::new((Get-Process -Name explorer).MainWindowHandle)
$FolderBrowser = New-Object System.Windows.Forms.FolderBrowserDialog -Property @{
RootFolder = $RootFolder
ShowNewFolderButton = $ShowNewFolderButton
Description = $Description
}
# set the return value only if a selection was made
$result = $null
If ($FolderBrowser.ShowDialog($owner) -eq "OK") {
$result = $FolderBrowser.SelectedPath
}
# clear the dialog from memory
$FolderBrowser.Dispose()
return $result
}
#-------------------------------------------------------------
Function Set-MyVariable{
Param
(
[ValidateSet('Set','Remove')]
[string]$Action,
[string]$Name,
[string]$Value,
[switch]$SetUserVariableTarget,
[switch]$Redundant,
[switch]$SHowUI,
[switch]$Silent
)
# https://stackoverflow.com/questions/40679456/what-is-the-proper-way-to-set-a-user-environment-variable-in-a-powershell-script
If ($Action -eq "Set") {
If ($Silent -eq $False) {
$StatusMessage = "Setting the `"$Name`" user environment variable to..."
If ($SHowUI) {
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
}
write-verbose "$StatusMessage" -verbose
$StatusMessage = "- $Value"
If ($SHowUI) {
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
}
write-verbose "$StatusMessage" -verbose
}
${env:Name} = $Value
[System.Environment]::SetEnvironmentVariable($Name, $Value, [System.EnvironmentVariableTarget]::Process)
If ($SetUserVariableTarget) {
[System.Environment]::SetEnvironmentVariable($Name, $Value, [System.EnvironmentVariableTarget]::User)
}
}
If ($Action -eq "Remove") {
If ($Silent -eq $False) {
$StatusMessage = "Clearing the `"$Name`" user environment variable"
If ($Redundant) {
$StatusMessage = "Clearing the `"$Name`" user environment variable as it's no longer used"
}
If ($SHowUI) {
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
}
write-verbose "$StatusMessage" -verbose
}
${env:Name} = $null
[System.Environment]::SetEnvironmentVariable($Name, $null, [System.EnvironmentVariableTarget]::Process)
If ($SetUserVariableTarget) {
[System.Environment]::SetEnvironmentVariable($Name, $null, [System.EnvironmentVariableTarget]::User)
}
}
}
#-------------------------------------------------------------
Function Create-Folder{
Param
(
[string]$Name,
[switch]$SHowUI
)
$StatusMessage = ""
If (-not(TEST-PATH "$Name")) {
$StatusMessage = "Creating the `"$Name`" folder"
New-Item -Path "$Name" -ItemType Directory | out-null
} Else {
$StatusMessage = "The `"$Name`" folder already exists"
}
if (!([String]::IsNullOrEmpty($StatusMessage))) {
write-verbose "$StatusMessage" -verbose
If ($SHowUI) {
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
}
}
}
#-------------------------------------------------------------
Function Set-PathVariable {
# The original function this is based on was written by Anthony Howell
# Reference: https://github.com/ThePoShWolf/Utilities/blob/master/Misc/Set-PathVariable.ps1
param
(
[ValidateSet('Append','Remove')]
[string]$Action,
[string]$Path,
[ValidateSet('Process', 'User', 'Machine')]
[string]$Scope = 'User',
[switch]$ExactMatch
)
$arrPaths = [System.Environment]::GetEnvironmentVariable('PATH', $Scope) -split ';'
If ($Action -eq "Append") {
$StatusMessage = "Appending the `"$Path`" path to the PATH variable"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$value = ($arrPaths + $Path) -join ';'
}
If ($Action -eq "Remove") {
$regexPaths = @([regex]::Escape($Path))
If ($ExactMatch) {
$StatusMessage = "Removing the `"$Path`" path from the PATH variable"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
ForEach ($regexPath in $regexPaths) {
$arrPaths = $arrPaths | Where-Object { $_ -notMatch "^$regexPath\\?" }
}
} Else {
$StatusMessage = "Removing all paths that contain `"$Path`" from the PATH variable"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
ForEach ($regexPath in $regexPaths) {
$arrPaths = $arrPaths | Where-Object { $_ -notMatch ".*$regexPath\\?" }
}
}
$value = ($arrPaths) -join ';'
}
# https://stackoverflow.com/questions/40679456/what-is-the-proper-way-to-set-a-user-environment-variable-in-a-powershell-script
If ($Scope -eq "Process") {
${env:PATH} = $value
}
[System.Environment]::SetEnvironmentVariable('PATH', $value, $Scope)
}
#-------------------------------------------------------------
Function Set-Vulcan-Paths {
Param
(
[string]$UseInstallationDirectory,
[switch]$SetUserVariableTarget,
[switch]$InitiateEnvRefresh
)
If ($UseInstallationDirectory -ne "Not found") {
If (Test-Path "$UseInstallationDirectory") {
Set-MyVariable -Action:"Set" -Name:"MMT_VULCAN" -Value:"$UseInstallationDirectory" -SetUserVariableTarget:$SetUserVariableTarget
Set-MyVariable -Action:"Set" -Name:"VULCAN" -Value:"$UseInstallationDirectory" -SetUserVariableTarget:$SetUserVariableTarget
Set-MyVariable -Action:"Set" -Name:"VULCAN_EXE_RP" -Value:"$UseInstallationDirectory\bin\exe" -SetUserVariableTarget:$SetUserVariableTarget
}
} Else {
Set-MyVariable -Action:"Remove" -Name:"MMT_VULCAN" -SetUserVariableTarget:$SetUserVariableTarget
Set-MyVariable -Action:"Remove" -Name:"VULCAN" -SetUserVariableTarget:$SetUserVariableTarget
Set-MyVariable -Action:"Remove" -Name:"VULCAN_EXE_RP" -SetUserVariableTarget:$SetUserVariableTarget
}
$Scope = "Process"
If ($SetUserVariableTarget) {
$Scope = "User"
}
Set-PathVariable -Action:"Remove" -Path:"Vulcan" -Scope:"$Scope"
If ($UseInstallationDirectory -ne "Not found") {
If (Test-Path "$UseInstallationDirectory") {
Set-PathVariable -Action:"Append" -Path:"$UseInstallationDirectory\bin\exe" -Scope:"$Scope"
Set-PathVariable -Action:"Append" -Path:"$UseInstallationDirectory\lib\perl" -Scope:"$Scope"
Set-PathVariable -Action:"Append" -Path:"$UseInstallationDirectory\bin\cygnus\bin" -Scope:"$Scope"
}
}
If ($InitiateEnvRefresh) {
# Refresh environment variables
EnvironmentRefresh
}
}
#-------------------------------------------------------------
Function Launch-App{
Param
(
[string]$AppName,
[string]$AppExecutable,
[string]$CmdLineArgs="",
[string]$WorkingDirectory = "${env:HOMEDRIVE}${env:HOMEPATH}\",
[switch]$Elevate,
[switch]$SHowUI
)
$StatusMessage = "Starting ${AppName}..."
If ($ShowUI) {
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
}
write-verbose "$StatusMessage" -verbose
$Successful = $False
If (Test-Path -Path "$AppExecutable") {
$LaunchProcess = "$AppExecutable"
$LaunchArguments = "$CmdLineArgs"
$pinfo = New-Object System.Diagnostics.ProcessStartInfo
$pinfo.FileName = $LaunchProcess
If ($Elevate -eq $False) {
$pinfo.UseShellExecute = $false
} Else {
$pinfo.UseShellExecute = $true
$pinfo.Verb = "runas"
}
$pinfo.Arguments = $LaunchArguments
$pinfo.WorkingDirectory = $WorkingDirectory
$p = New-Object System.Diagnostics.Process
$p.StartInfo = $pinfo
Try {
$p.Start() | Out-Null
Write-Verbose "Successfully executed" -Verbose
$Successful = $True
}
Catch {
Write-Warning "Failed to execute" -Verbose
}
$p.Dispose()
} Else {
write-verbose "${AppName} was not found on this computer." -verbose
}
return $Successful
}
#-------------------------------------------------------------
Function Get-FirstAvailableRAMDisk {
# Set the path for the Arsenal Image Mounter CLI (AIM CLI)
$Executable = "${env:ProgramFiles}\Arsenal Image Mounter\aim_cli.exe"
$DriveLetters = @()
$IsDriverInstalled = $false
$CanConnect = $false
Try {
$PnPSignedDriver = Get-WmiObject -Class Win32_PnPSignedDriver -ErrorAction Stop | Where {$_.Description -eq "Arsenal Image Mounter"}
$CanConnect = $true
}
Catch {
$ErrorDescription = "Error connecting using the Get-WmiObject cmdlet."
write-warning "*ERROR*: $ErrorDescription" -verbose
}
if ($CanConnect -AND $null -ne $PnPSignedDriver) {
$IsDriverInstalled = $true
write-verbose "The Arsenal Image Mounter SCSI device is installed" -verbose
write-verbose "- Device ID: $($PnPSignedDriver.DeviceID)" -verbose
write-verbose "- Device Version: $($PnPSignedDriver.DriverVersion)" -verbose
} Else {
write-verbose "The Arsenal Image Mounter SCSI device is not installed" -verbose
}
If ($IsDriverInstalled -AND (Test-Path -Path "$Executable")) {
$AllRamDisks = $null
$MyArgs = "--list"
write-verbose "Get all RAM disk devices" -verbose
write-verbose "- Starting the process: `"$Executable`"" -verbose
write-verbose "- with the arguments: $MyArgs" -verbose
$pinfo = New-Object System.Diagnostics.Process
$pinfo.StartInfo.FileName = $Executable
# WindowStyle; 1 = hidden, 2 =maximized, 3=minimized, 4=normal
$pinfo.StartInfo.WindowStyle = 1
$pinfo.StartInfo.Arguments = $MyArgs
$pinfo.StartInfo.RedirectStandardError = $True
$pinfo.StartInfo.RedirectStandardOutput = $True
$pinfo.StartInfo.UseShellExecute = $false
Try {
$null = $pinfo.start() | Out-Null
$AllRamDisks = $pinfo.StandardOutput.ReadToEnd().Trim().Split("`r`n")
$AllRamDisks += $pinfo.StandardError.ReadToEnd().Trim().Split("`r`n")
}
Catch {
#
}
$pinfo.Dispose()
If ($AllRamDisks -Like "*No virtual disks*") {
write-verbose "No virtual disks mounted" -verbose
} Else {
$TotalRAMDisks = 0
ForEach ($Line in $AllRamDisks) {
$MountedAt = ""
If ($Line -like "*Mounted at*") {
$MountedAt = ($Line.Trim() -Split("Mounted at"))[1].Trim()
}
if (!([String]::IsNullOrEmpty($MountedAt))) {
$TotalRAMDisks++
$DriveLetters += $MountedAt
}
}
If ($TotalRAMDisks -eq 1) {
write-verbose "$TotalRAMDisks RAM disk found" -verbose
} Else {
write-verbose "$TotalRAMDisks RAM disks found" -verbose
}
}
}
return $DriveLetters
}
#-------------------------------------------------------------
Function IsAccessAllowed {
param(
[string]$Folder,
[switch]$ConsoleOutput
)
If (TEST-PATH $Folder) {
If ($ConsoleOutput) {
write-verbose "Testing access to: $Folder" -verbose
}
Get-ChildItem -path $Folder -EA SilentlyContinue -ErrorVariable ErrVar is
# The -ErrorVariable common parameter creates an ArrayList. This variable
# always initialized which means it will never be $null. The proper way
# to test if an ArrayList is empty or not is to use the Count property. It
# should be empty or equal to 0 if there are no errors.
If ($ErrVar.count -eq 0) {
If ($ConsoleOutput) {
write-verbose "Access is good" -verbose
}
$return = $True
} Else {
If ($ConsoleOutput) {
write-warning "Access denied" -verbose
}
$return = $False
}
} Else {
If ($ConsoleOutput) {
write-warning "The `"$Folder`" does not exist" -verbose
}
$return = $False
}
return $return
}
#-------------------------------------------------------------
Function Get-RamDisks {
# Check for existance of a RAM disk
# - Get the drive letter, size, freespace, and build an array for the drop down list.
# - Set the largest available RAM disk as the preferred for the drop down list.
$ResultProps = @{
RAMDiskFound = $False
RAMDISKS = @()
PreferredRAMDisk = ""
}
$RAMDiskLetters = Get-FirstAvailableRAMDisk
$LargestRAMDiskSize = 0
ForEach ($Letter in $RAMDiskLetters) {
$RAMDiskLetter = $Letter.TrimEnd("\")
$RAMDiskLetter = $RAMDiskLetter.TrimEnd(":")
If (IsAccessAllowed -Folder "${RAMDiskLetter}:\") {
$ResultProps.RAMDiskFound = $True
$RAMDiskSize = 0
$RAMDiskFreeSpace = 0
$CanConnect = $false
Try {
$LogicalDiskInformation = Get-WmiObject -Class Win32_LogicalDisk -Filter "DeviceID='${RAMDiskLetter}:'" -ErrorAction Stop | Select-Object `
@{N="TotalSize"; E={[math]::round(($_.Size / 1GB),0)}},@{N="TotalFreeSpace"; E={[math]::round(($_.FreeSpace / 1GB),0)}}
$CanConnect = $true
}
Catch {
$ErrorDescription = "Error connecting using the Get-WmiObject cmdlet."
write-warning "*ERROR*: $ErrorDescription" -verbose
}
if ($CanConnect) {
$RAMDiskSize = ($LogicalDiskInformation.TotalSize).ToString()
$RAMDiskFreeSpace = ($LogicalDiskInformation.TotalFreeSpace).ToString()
}
If ($RAMDiskSize -gt $LargestRAMDiskSize) {
$LargestRAMDiskSize = $RAMDiskSize
$ResultProps.PreferredRAMDisk = $RAMDiskLetter
}
$ResultProps.RAMDISKS += @([pscustomobject]@{name=" ${RAMDiskLetter}: Drive - Total size of $RAMDiskSize GB with $RAMDiskFreeSpace GB of free space";description=$RAMDiskLetter})
}
}
return $ResultProps
}
#-------------------------------------------------------------
function Load-ComboBox {
<#
.SYNOPSIS
This functions helps you load items into a ComboBox.
.DESCRIPTION
Use this function to dynamically load items into the ComboBox control.
With the Load-ComboBox function the ValueMember only works if you are data
binding and using the ComboBox's DataSource property. Instead of ValueMember
you could just access the property from the selected object:
$combobox1.SelectedItem.Description
.PARAMETER ComboBox
The ComboBox control you want to add items to.
.PARAMETER Items
The object or objects you wish to load into the ComboBox's Items collection.
.PARAMETER DisplayMember
Indicates the property to display for the items in this control.
.PARAMETER Append
Adds the item(s) to the ComboBox without clearing the Items collection.
#>
Param
(
[Parameter(Mandatory=$true)]
[System.Windows.Forms.ComboBox]$ComboBox,
[Parameter(Mandatory=$true)]$Items,
[Parameter(Mandatory=$false)]
[string]$DisplayMember,
[string]$ValueMember,
[switch]$Append
)
if(-not $Append)
{
$comboBox.Items.Clear()
}
if($Items -is [Array])
{
$comboBox.Items.AddRange($Items)
}
else
{
$comboBox.Items.Add($Items)
}
$comboBox.ValueMember = "description"
$comboBox.DisplayMember = "name"
}
#-------------------------------------------------------------
Function Call-MainForm {
Param
(
[string]$ToolRelease,
[string]$BusinessUnit,
[string]$VulcanDefaultVersion,
[switch]$Advanced,
[switch]$RAMDiskFound,
[array]$RAMDISKS,
[string]$PreferredRAMDisk,
[switch]$UseRAMDisk,
[switch]$DisableChangeTEMP,
[switch]$RemoveRedundantVariables,
[int]$CloseAfterInMinutes=30
)
#-------------------------------------------------------------
# 3rd Party tools and utilities referenced in this tool.
# Notepad++
$TextEditor = "${env:ProgramFiles}\Notepad++\notepad++.exe"
# NVIDIA Control Panel
$nvcplui = Get-NVIDIAControlPanelTool -Program:"nvcplui.exe"
# NVIDIA GPU Utilization tool (typically installed with NVIDIA Control Panel)
$NvGpuUtilization = Get-NVIDIAControlPanelTool -Program:"NvGpuUtilization.exe"
# GPUProfiler by Jeremy Main
$GPUProfiler = "${env:ProgramFiles(x86)}\GPUProfiler\GPUProfiler.exe"
#-------------------------------------------------------------
# Set the file to extract the icon from
$IconFile = "${env:CommonProgramFiles}\Maptek\Workbench\WorkbenchLauncher.exe"
$codeDisableX = @"
using System.Windows.Forms;
namespace MyForm {
public class FormWithoutX : Form {
protected override CreateParams CreateParams {
get {
CreateParams cp = base.CreateParams;
cp.ClassStyle = cp.ClassStyle | 0x200;
return cp;
}
}
}
}
"@
$codeFolderBrowserDialogEx = @"
// This class comes from the DotNetZip project: http://dotnetzip.codeplex.com
// It is licensed under the MS-PL: http://dotnetzip.codeplex.com/license
//
// A replacement for the builtin System.Windows.Forms.FolderBrowserDialog class.
// This one includes an edit box, and also displays the full path in the edit box.
//
using System;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.ComponentModel;
using System.Security.Permissions;
using System.Security;
using System.Threading;
//[Designer("System.Windows.Forms.Design.FolderBrowserDialogDesigner, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"), DefaultEvent("HelpRequest"), SRDescription("DescriptionFolderBrowserDialog"), DefaultProperty("SelectedPath")]
public class FolderBrowserDialogEx : System.Windows.Forms.CommonDialog
{
private static readonly int MAX_PATH = 260;
// Fields
private PInvoke.BrowseFolderCallbackProc _callback;
private string _descriptionText;
private Environment.SpecialFolder _rootFolder;
private string _selectedPath;
private bool _selectedPathNeedsCheck;
private bool _showNewFolderButton;
private bool _showEditBox;
private bool _showBothFilesAndFolders;
private bool _newStyle = true;
private bool _showFullPathInEditBox = true;
private bool _dontIncludeNetworkFoldersBelowDomainLevel;
private int _uiFlags;
private IntPtr _hwndEdit;
private IntPtr _rootFolderLocation;
// Events
//[Browsable(false), EditorBrowsable(EditorBrowsableState.Never)]
public new event EventHandler HelpRequest
{
add
{
base.HelpRequest += value;
}
remove
{
base.HelpRequest -= value;
}
}
// ctor
public FolderBrowserDialogEx()
{
this.Reset();
}
// Factory Methods
public static FolderBrowserDialogEx PrinterBrowser()
{
FolderBrowserDialogEx x = new FolderBrowserDialogEx();
// avoid MBRO comppiler warning when passing _rootFolderLocation as a ref:
x.BecomePrinterBrowser();
return x;
}
public static FolderBrowserDialogEx ComputerBrowser()
{
FolderBrowserDialogEx x = new FolderBrowserDialogEx();
// avoid MBRO comppiler warning when passing _rootFolderLocation as a ref:
x.BecomeComputerBrowser();
return x;
}
// Helpers
private void BecomePrinterBrowser()
{
_uiFlags += BrowseFlags.BIF_BROWSEFORPRINTER;
Description = "Select a printer:";
PInvoke.Shell32.SHGetSpecialFolderLocation(IntPtr.Zero, CSIDL.PRINTERS, ref this._rootFolderLocation);
ShowNewFolderButton = false;
ShowEditBox = false;
}
private void BecomeComputerBrowser()
{
_uiFlags += BrowseFlags.BIF_BROWSEFORCOMPUTER;
Description = "Select a computer:";
PInvoke.Shell32.SHGetSpecialFolderLocation(IntPtr.Zero, CSIDL.NETWORK, ref this._rootFolderLocation);
ShowNewFolderButton = false;
ShowEditBox = false;
}
private class CSIDL
{
public const int PRINTERS = 4;
public const int NETWORK = 0x12;
}
private class BrowseFlags
{
public const int BIF_DEFAULT = 0x0000;
public const int BIF_BROWSEFORCOMPUTER = 0x1000;
public const int BIF_BROWSEFORPRINTER = 0x2000;
public const int BIF_BROWSEINCLUDEFILES = 0x4000;
public const int BIF_BROWSEINCLUDEURLS = 0x0080;
public const int BIF_DONTGOBELOWDOMAIN = 0x0002;
public const int BIF_EDITBOX = 0x0010;
public const int BIF_NEWDIALOGSTYLE = 0x0040;
public const int BIF_NONEWFOLDERBUTTON = 0x0200;
public const int BIF_RETURNFSANCESTORS = 0x0008;
public const int BIF_RETURNONLYFSDIRS = 0x0001;
public const int BIF_SHAREABLE = 0x8000;
public const int BIF_STATUSTEXT = 0x0004;
public const int BIF_UAHINT = 0x0100;
public const int BIF_VALIDATE = 0x0020;
public const int BIF_NOTRANSLATETARGETS = 0x0400;
}
private static class BrowseForFolderMessages
{
// messages FROM the folder browser
public const int BFFM_INITIALIZED = 1;
public const int BFFM_SELCHANGED = 2;
public const int BFFM_VALIDATEFAILEDA = 3;
public const int BFFM_VALIDATEFAILEDW = 4;
public const int BFFM_IUNKNOWN = 5;
// messages TO the folder browser
public const int BFFM_SETSTATUSTEXT = 0x464;
public const int BFFM_ENABLEOK = 0x465;
public const int BFFM_SETSELECTIONA = 0x466;
public const int BFFM_SETSELECTIONW = 0x467;
}
private int FolderBrowserCallback(IntPtr hwnd, int msg, IntPtr lParam, IntPtr lpData)
{
switch (msg)
{
case BrowseForFolderMessages.BFFM_INITIALIZED:
if (this._selectedPath.Length != 0)
{
PInvoke.User32.SendMessage(new HandleRef(null, hwnd), BrowseForFolderMessages.BFFM_SETSELECTIONW, 1, this._selectedPath);
if (this._showEditBox && this._showFullPathInEditBox)
{
// get handle to the Edit box inside the Folder Browser Dialog
_hwndEdit = PInvoke.User32.FindWindowEx(new HandleRef(null, hwnd), IntPtr.Zero, "Edit", null);
PInvoke.User32.SetWindowText(_hwndEdit, this._selectedPath);
}
}
break;
case BrowseForFolderMessages.BFFM_SELCHANGED:
IntPtr pidl = lParam;
if (pidl != IntPtr.Zero)
{
if (((_uiFlags & BrowseFlags.BIF_BROWSEFORPRINTER) == BrowseFlags.BIF_BROWSEFORPRINTER) ||
((_uiFlags & BrowseFlags.BIF_BROWSEFORCOMPUTER) == BrowseFlags.BIF_BROWSEFORCOMPUTER))
{
// we're browsing for a printer or computer, enable the OK button unconditionally.
PInvoke.User32.SendMessage(new HandleRef(null, hwnd), BrowseForFolderMessages.BFFM_ENABLEOK, 0, 1);
}
else
{
IntPtr pszPath = Marshal.AllocHGlobal(MAX_PATH * Marshal.SystemDefaultCharSize);
bool haveValidPath = PInvoke.Shell32.SHGetPathFromIDList(pidl, pszPath);
String displayedPath = Marshal.PtrToStringAuto(pszPath);
Marshal.FreeHGlobal(pszPath);
// whether to enable the OK button or not. (if file is valid)
PInvoke.User32.SendMessage(new HandleRef(null, hwnd), BrowseForFolderMessages.BFFM_ENABLEOK, 0, haveValidPath ? 1 : 0);
// Maybe set the Edit Box text to the Full Folder path
if (haveValidPath && !String.IsNullOrEmpty(displayedPath))
{
if (_showEditBox && _showFullPathInEditBox)
{
if (_hwndEdit != IntPtr.Zero)
PInvoke.User32.SetWindowText(_hwndEdit, displayedPath);
}
if ((_uiFlags & BrowseFlags.BIF_STATUSTEXT) == BrowseFlags.BIF_STATUSTEXT)
PInvoke.User32.SendMessage(new HandleRef(null, hwnd), BrowseForFolderMessages.BFFM_SETSTATUSTEXT, 0, displayedPath);
}
}
}
break;
}
return 0;
}
private static PInvoke.IMalloc GetSHMalloc()
{
PInvoke.IMalloc[] ppMalloc = new PInvoke.IMalloc[1];
PInvoke.Shell32.SHGetMalloc(ppMalloc);
return ppMalloc[0];
}
public override void Reset()
{
this._rootFolder = (Environment.SpecialFolder)0;
this._descriptionText = string.Empty;
this._selectedPath = string.Empty;
this._selectedPathNeedsCheck = false;
this._showNewFolderButton = true;
this._showEditBox = true;
this._newStyle = true;
this._dontIncludeNetworkFoldersBelowDomainLevel = false;
this._hwndEdit = IntPtr.Zero;
this._rootFolderLocation = IntPtr.Zero;
}
protected override bool RunDialog(IntPtr hWndOwner)
{
bool result = false;
if (_rootFolderLocation == IntPtr.Zero)
{
PInvoke.Shell32.SHGetSpecialFolderLocation(hWndOwner, (int)this._rootFolder, ref _rootFolderLocation);
if (_rootFolderLocation == IntPtr.Zero)
{
PInvoke.Shell32.SHGetSpecialFolderLocation(hWndOwner, 0, ref _rootFolderLocation);
if (_rootFolderLocation == IntPtr.Zero)
{
throw new InvalidOperationException("FolderBrowserDialogNoRootFolder");
}
}
}
_hwndEdit = IntPtr.Zero;
//_uiFlags = 0;
if (_dontIncludeNetworkFoldersBelowDomainLevel)
_uiFlags += BrowseFlags.BIF_DONTGOBELOWDOMAIN;
if (this._newStyle)
_uiFlags += BrowseFlags.BIF_NEWDIALOGSTYLE;
if (!this._showNewFolderButton)
_uiFlags += BrowseFlags.BIF_NONEWFOLDERBUTTON;
if (this._showEditBox)
_uiFlags += BrowseFlags.BIF_EDITBOX;
if (this._showBothFilesAndFolders)
_uiFlags += BrowseFlags.BIF_BROWSEINCLUDEFILES;
if (Control.CheckForIllegalCrossThreadCalls && (Application.OleRequired() != ApartmentState.STA))
{
throw new ThreadStateException("DebuggingException: ThreadMustBeSTA");
}
IntPtr pidl = IntPtr.Zero;
IntPtr hglobal = IntPtr.Zero;
IntPtr pszPath = IntPtr.Zero;
try
{
PInvoke.BROWSEINFO browseInfo = new PInvoke.BROWSEINFO();
hglobal = Marshal.AllocHGlobal(MAX_PATH * Marshal.SystemDefaultCharSize);
pszPath = Marshal.AllocHGlobal(MAX_PATH * Marshal.SystemDefaultCharSize);
this._callback = new PInvoke.BrowseFolderCallbackProc(this.FolderBrowserCallback);
browseInfo.pidlRoot = _rootFolderLocation;
browseInfo.Owner = hWndOwner;
browseInfo.pszDisplayName = hglobal;
browseInfo.Title = this._descriptionText;
browseInfo.Flags = _uiFlags;
browseInfo.callback = this._callback;
browseInfo.lParam = IntPtr.Zero;
browseInfo.iImage = 0;
pidl = PInvoke.Shell32.SHBrowseForFolder(browseInfo);
if (((_uiFlags & BrowseFlags.BIF_BROWSEFORPRINTER) == BrowseFlags.BIF_BROWSEFORPRINTER) ||
((_uiFlags & BrowseFlags.BIF_BROWSEFORCOMPUTER) == BrowseFlags.BIF_BROWSEFORCOMPUTER))
{
this._selectedPath = Marshal.PtrToStringAuto(browseInfo.pszDisplayName);
result = true;
}
else
{
if (pidl != IntPtr.Zero)
{
PInvoke.Shell32.SHGetPathFromIDList(pidl, pszPath);
this._selectedPathNeedsCheck = true;
this._selectedPath = Marshal.PtrToStringAuto(pszPath);
result = true;
}
}
}
finally
{
PInvoke.IMalloc sHMalloc = GetSHMalloc();
sHMalloc.Free(_rootFolderLocation);
_rootFolderLocation = IntPtr.Zero;
if (pidl != IntPtr.Zero)
{
sHMalloc.Free(pidl);
}
if (pszPath != IntPtr.Zero)
{
Marshal.FreeHGlobal(pszPath);
}
if (hglobal != IntPtr.Zero)
{
Marshal.FreeHGlobal(hglobal);
}
this._callback = null;
}
return result;
}
// Properties
//[SRDescription("FolderBrowserDialogDescription"), SRCategory("CatFolderBrowsing"), Browsable(true), DefaultValue(""), Localizable(true)]
/// <summary>
/// This description appears near the top of the dialog box, providing direction to the user.
/// </summary>
public string Description
{
get
{
return this._descriptionText;
}
set
{
this._descriptionText = (value == null) ? string.Empty : value;
}
}
//[Localizable(false), SRCategory("CatFolderBrowsing"), SRDescription("FolderBrowserDialogRootFolder"), TypeConverter(typeof(SpecialFolderEnumConverter)), Browsable(true), DefaultValue(0)]
public Environment.SpecialFolder RootFolder
{
get
{
return this._rootFolder;
}
set
{
if (!Enum.IsDefined(typeof(Environment.SpecialFolder), value))
{
throw new InvalidEnumArgumentException("value", (int)value, typeof(Environment.SpecialFolder));
}
this._rootFolder = value;
}
}
//[Browsable(true), SRDescription("FolderBrowserDialogSelectedPath"), SRCategory("CatFolderBrowsing"), DefaultValue(""), Editor("System.Windows.Forms.Design.SelectedPathEditor, System.Design, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a", typeof(UITypeEditor)), Localizable(true)]
/// <summary>
/// Set or get the selected path.
/// </summary>
public string SelectedPath
{
get
{
if (((this._selectedPath != null) && (this._selectedPath.Length != 0)) && this._selectedPathNeedsCheck)
{
new FileIOPermission(FileIOPermissionAccess.PathDiscovery, this._selectedPath).Demand();
this._selectedPathNeedsCheck = false;
}
return this._selectedPath;
}
set
{
this._selectedPath = (value == null) ? string.Empty : value;
this._selectedPathNeedsCheck = true;
}
}
//[SRDescription("FolderBrowserDialogShowNewFolderButton"), Localizable(false), Browsable(true), DefaultValue(true), SRCategory("CatFolderBrowsing")]
/// <summary>
/// Enable or disable the "New Folder" button in the browser dialog.
/// </summary>
public bool ShowNewFolderButton
{
get
{
return this._showNewFolderButton;
}
set
{
this._showNewFolderButton = value;
}
}
/// <summary>
/// Show an "edit box" in the folder browser.
/// </summary>
/// <remarks>
/// The "edit box" normally shows the name of the selected folder.
/// The user may also type a pathname directly into the edit box.
/// </remarks>
/// <seealso cref="ShowFullPathInEditBox"/>
public bool ShowEditBox
{
get
{
return this._showEditBox;
}
set
{
this._showEditBox = value;
}
}
/// <summary>
/// Set whether to use the New Folder Browser dialog style.
/// </summary>
/// <remarks>
/// The new style is resizable and includes a "New Folder" button.
/// </remarks>
public bool NewStyle
{
get
{
return this._newStyle;
}
set
{
this._newStyle = value;
}
}
public bool DontIncludeNetworkFoldersBelowDomainLevel
{
get { return _dontIncludeNetworkFoldersBelowDomainLevel; }
set { _dontIncludeNetworkFoldersBelowDomainLevel = value; }
}
/// <summary>
/// Show the full path in the edit box as the user selects it.
/// </summary>
/// <remarks>
/// This works only if ShowEditBox is also set to true.
/// </remarks>
public bool ShowFullPathInEditBox
{
get { return _showFullPathInEditBox; }
set { _showFullPathInEditBox = value; }
}
public bool ShowBothFilesAndFolders
{
get { return _showBothFilesAndFolders; }
set { _showBothFilesAndFolders = value; }
}
}
internal static class PInvoke
{
static PInvoke() { }
public delegate int BrowseFolderCallbackProc(IntPtr hwnd, int msg, IntPtr lParam, IntPtr lpData);
internal static class User32
{
[DllImport("user32.dll", CharSet = CharSet.Auto)]
public static extern IntPtr SendMessage(HandleRef hWnd, int msg, int wParam, string lParam);
[DllImport("user32.dll", CharSet = CharSet.Auto)]
public static extern IntPtr SendMessage(HandleRef hWnd, int msg, int wParam, int lParam);
[DllImport("user32.dll", SetLastError = true)]
//public static extern IntPtr FindWindowEx(IntPtr hwndParent, IntPtr hwndChildAfter, string lpszClass, string lpszWindow);
//public static extern IntPtr FindWindowEx(HandleRef hwndParent, HandleRef hwndChildAfter, string lpszClass, string lpszWindow);
public static extern IntPtr FindWindowEx(HandleRef hwndParent, IntPtr hwndChildAfter, string lpszClass, string lpszWindow);
[DllImport("user32.dll", SetLastError = true)]
public static extern Boolean SetWindowText(IntPtr hWnd, String text);
}
[ComImport, Guid("00000002-0000-0000-c000-000000000046"), SuppressUnmanagedCodeSecurity, InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
public interface IMalloc
{
[PreserveSig]
IntPtr Alloc(int cb);
[PreserveSig]
IntPtr Realloc(IntPtr pv, int cb);
[PreserveSig]
void Free(IntPtr pv);
[PreserveSig]
int GetSize(IntPtr pv);
[PreserveSig]
int DidAlloc(IntPtr pv);
[PreserveSig]
void HeapMinimize();
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
public class BROWSEINFO
{
public IntPtr Owner;
public IntPtr pidlRoot;
public IntPtr pszDisplayName;
public string Title;
public int Flags;
public BrowseFolderCallbackProc callback;
public IntPtr lParam;
public int iImage;
}
[SuppressUnmanagedCodeSecurity]
internal static class Shell32
{
// Methods
[DllImport("shell32.dll", CharSet = CharSet.Auto)]
public static extern IntPtr SHBrowseForFolder([In] PInvoke.BROWSEINFO lpbi);
[DllImport("shell32.dll")]
public static extern int SHGetMalloc([Out, MarshalAs(UnmanagedType.LPArray)] PInvoke.IMalloc[] ppMalloc);
[DllImport("shell32.dll", CharSet = CharSet.Auto)]
public static extern bool SHGetPathFromIDList(IntPtr pidl, IntPtr pszPath);
[DllImport("shell32.dll")]
public static extern int SHGetSpecialFolderLocation(IntPtr hwnd, int csidl, ref IntPtr ppidl);
}
}
"@
Add-Type -AssemblyName System.Windows.Forms
Add-Type -TypeDefinition $codeDisableX -ReferencedAssemblies System.Windows.Forms
Add-Type -TypeDefinition $codeFolderBrowserDialogEx -ReferencedAssemblies System.Windows.Forms
Add-Type -AssemblyName System.Drawing
Add-Type -AssemblyName PresentationCore,PresentationFramework
$form = [MyForm.FormWithoutX]::new()
#$form = New-Object System.Windows.Forms.Form
$form.Text = "Maptek User Support Tools v$ToolRelease"
$form.ClientSize = New-Object System.Drawing.Size(545,350)
$form.MaximizeBox = $True
$form.MinimizeBox = $True
$form.MinimumSize = New-Object System.Drawing.Size(545,1060)
$form.MaximumSize = New-Object System.Drawing.Size(545,1060)
$form.FormBorderStyle = "FixedDialog"
$form.SizeGripStyle = "Hide"
If (Test-Path "$IconFile") {
$form.Icon = [System.Drawing.Icon]::ExtractAssociatedIcon("$IconFile")
}
$form.WindowState = 'Normal'
# Start the form from the top left eighth position of the primary screen. This ensures
# it starts consistently in the same location and out of the way of any popups.
$LocationWidth = $(([System.Windows.Forms.Screen]::PrimaryScreen.WorkingArea.Width /16))
$LocationHeight = $(([System.Windows.Forms.Screen]::PrimaryScreen.WorkingArea.Height /32))
$form.Location = New-Object System.Drawing.Point($LocationWidth,$LocationHeight)
$form.StartPosition = 'Manual'
# Set the Maximum width of the header section so that the text can be centred correctly.
$MaxWidth = 545
$labelheader = New-Object 'System.Windows.Forms.Label'
$labelheader.Font = 'Microsoft Sans Serif, 14.25pt'
$labelheader.ForeColor = 'White'
$labelheader.Name = 'labelheader'
If ([String]::IsNullOrEmpty($BusinessUnit)) {
$labelheader.Text = 'Maptek User Support Tools'
} Else {
$labelheader.Text = "Maptek User Support Tools for $BusinessUnit"
}
$TextSize = [System.Windows.Forms.TextRenderer]::MeasureText($labelheader.Text, $labelheader.Font)
$TextWidth = ($MaxWidth - $TextSize.Width) / 2
If ($TextWidth -le 0) { $TextWidth = 1 }
$labelheader.Location = New-Object System.Drawing.Point($TextWidth,10)
$labelheader.Size = New-Object System.Drawing.Size($MaxWidth,23)
$labelheader.TabIndex = 1
$labelheader.TextAlign = 'MiddleLeft'
$labelsubheader1 = New-Object 'System.Windows.Forms.Label'
$labelsubheader1.Font = 'Microsoft Sans Serif, 12pt'
$labelsubheader1.ForeColor = 'White'
$labelsubheader1.Name = 'labelheader'
$labelsubheader1.Text = "This is not a Maptek developed or supported tool"
$TextSize = [System.Windows.Forms.TextRenderer]::MeasureText($labelsubheader1.Text, $labelsubheader1.Font)
$TextWidth = ($MaxWidth - $TextSize.Width) / 2
If ($TextWidth -le 0) { $TextWidth = 1 }
$labelsubheader1.Location = New-Object System.Drawing.Point($TextWidth,40)
$labelsubheader1.Size = New-Object System.Drawing.Size($MaxWidth, 23)
$labelsubheader1.TabIndex = 1
$labelsubheader1.TextAlign = 'MiddleLeft'
$labelsubheader2 = New-Object 'System.Windows.Forms.Label'
$labelsubheader2.Font = 'Microsoft Sans Serif, 12pt'
$labelsubheader2.ForeColor = 'White'
$labelsubheader2.Name = 'labelheader'
$labelsubheader2.Text = "This is running on ${env:COMPUTERNAME}"
$TextSize = [System.Windows.Forms.TextRenderer]::MeasureText($labelsubheader2.Text, $labelsubheader2.Font)
$TextWidth = ($MaxWidth - $TextSize.Width) / 2
If ($TextWidth -le 0) { $TextWidth = 1 }
$labelsubheader2.Location = New-Object System.Drawing.Point($TextWidth,70)
$labelsubheader2.Size = New-Object System.Drawing.Size($MaxWidth, 23)
$labelsubheader2.TabIndex = 1
$labelsubheader2.TextAlign = 'MiddleLeft'
$panelheader = New-Object 'System.Windows.Forms.Panel'
$panelheader.Controls.Add($labelheader)
$panelheader.Controls.Add($labelsubheader1)
$panelheader.Controls.Add($labelsubheader2)
$panelheader.BackColor = '0, 114, 198'
$panelheader.Location = New-Object System.Drawing.Point(0, 0)
$panelheader.Name = 'header'
$panelheader.Size = New-Object System.Drawing.Size($MaxWidth, 100)
$panelheader.TabIndex = 8
$form.Controls.Add($panelheader)
$closeButton = New-Object System.Windows.Forms.Button
$closeButton.Location = New-Object System.Drawing.Point(445,825)
$closeButton.Size = New-Object System.Drawing.Size(75,23)
$closeButton.Text = 'Close'
$closeButton.DialogResult = [System.Windows.Forms.DialogResult]::OK
$form.CancelButton = $closeButton
$form.Controls.Add($closeButton)
$status1label = New-Object System.Windows.Forms.Label
$status1label.Font = 'Microsoft Sans Serif, 9pt'
$status1label.Location = New-Object System.Drawing.Point(10,830)
$status1label.Name = 'status1label'
$status1label.Size = New-Object System.Drawing.Size(100,23)
$status1label.UseMnemonic = $false
$status1label.Text = "Output message:"
$form.Controls.Add($status1label)
$status1TextBox = New-Object System.Windows.Forms.RichTextBox
$status1TextBox.Location = New-Object System.Drawing.Point(10,855)
$status1TextBox.Size = New-Object System.Drawing.Size(510, 145)
$status1TextBox.Multiline = $true
$status1TextBox.WordWrap = $true
$status1TextBox.DetectUrls = $false
$status1TextBox.ScrollBars = [System.Windows.Forms.ScrollBars]::'Vertical'
$status1TextBox.Enabled = $true
$status1TextBox.ReadOnly = $true
$oldFont = $status1label.Font
$newFont = New-Object System.Drawing.Font($oldFont.FontFamily, $oldFont.Size, [System.Drawing.FontStyle]::Bold)
$status1TextBox.Font = $newFont
$form.Controls.Add($status1TextBox)
# Create the Timer object
$GuiTimer = New-Object System.Windows.Forms.Timer
# Set the interval in milliseconds (the interval is how often the timer will "tick" once it's started).
$GuiTimer.Interval = 1800000
# Specify the action to run every time the timer ticks.
$GuiTimer.Add_Tick({
# Disable the timer
$GuiTimer.Enabled = $false
$StatusMessage = "Closing the form."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
# Close the forms
Try {
if($form2.ishandlecreated) {
$form2.Close()
}
}
Catch [System.Exception]{
#$($Error[0].Exception.Message)
}
$form.Close()
})
#-------------------------------------------------------------
# Basic and Advanced Feature Radio Buttons
$RadioButtonFeatures1 = New-Object System.Windows.Forms.RadioButton
$RadioButtonFeatures1.Location = '135,110'
$RadioButtonFeatures1.size = '125,23'
If ($Advanced -eq $False) {
$RadioButtonFeatures1.Checked = $true
} Else {
$RadioButtonFeatures1.Checked = $false
}
$RadioButtonFeatures1.Text = "Basic Features"
$form.Controls.Add($RadioButtonFeatures1)
$RadioButtonFeatures2 = New-Object System.Windows.Forms.RadioButton
$RadioButtonFeatures2.Location = '270,110'
$RadioButtonFeatures2.size = '125,23'
If ($Advanced) {
$RadioButtonFeatures2.Checked = $true
} Else {
$RadioButtonFeatures2.Checked = $false
}
$RadioButtonFeatures2.Text = "Advanced Features"
$form.Controls.Add($RadioButtonFeatures2)
$RadioButtonFeatures1.Add_Click({
$StatusMessage = "Disabling advanced features..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$actionButton_Rename_Vulcan_Pref.Enabled = $False
$actionButton_Edit_Vulcan_Prefs.Enabled = $False
$actionButton_GPU_Profiler.Enabled = $False
})
$RadioButtonFeatures2.Add_Click({
$StatusMessage = "Enabling advanced features..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$actionButton_Rename_Vulcan_Pref.Enabled = $True
If (Test-Path "$TextEditor") {
$actionButton_Edit_Vulcan_Prefs.Enabled = $True
} Else {
$StatusMessage = "- `"$TextEditor`" was not found on this computer."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
}
If (Test-Path "$GPUProfiler") {
$actionButton_GPU_Profiler.Enabled = $True
} Else {
$StatusMessage = "- `"$GPUProfiler`" was not found on this computer."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
}
})
#-------------------------------------------------------------
# Getting the site settings from the XML file to build the drop down lists if used.
$ENVIS_RESO_Found = $False
$VULCAN_CORPORATE_Found = $False
$CLIENT_LAVA_Found = $False
$ENVIS_RESO = @([pscustomobject]@{name="Select an option";description="Select an option"})
$VULCAN_CORPORATE = @([pscustomobject]@{name="Select an option";description="Select an option"})
$CLIENT_LAVA = @([pscustomobject]@{name="Select an option";description="Select an option"})
If (Test-Path -path $XMLFilePath) {
# Create the XML Object and open the XML file
$XmlDocument = Get-Content -path $XMLFilePath
foreach ($Config in $XmlDocument.configuration.Location) {
If ($BusinessUnit -Like "$($Config.Name)*") {
If ($Config | Where-Object { $_['ENVIS_RESO'] -ne $null}) {
If ($Config.ENVIS_RESO | Where-Object { $_['Setting'] -ne $null}) {
ForEach ($ENVIS_RESO_Config in $Config.ENVIS_RESO.Setting) {
$ENVIS_RESO_Found = $True
$ENVIS_RESO += @([pscustomobject]@{name=$ENVIS_RESO_Config.Name;description=$ENVIS_RESO_Config.Path})
}
}
}
If ($Config | Where-Object { $_['VULCAN_CORPORATE'] -ne $null}) {
If ($Config.VULCAN_CORPORATE | Where-Object { $_['Setting'] -ne $null}) {
ForEach ($VULCAN_CORPORATE_Config in $Config.VULCAN_CORPORATE.Setting) {
$VULCAN_CORPORATE_Found = $True
$VULCAN_CORPORATE += @([pscustomobject]@{name=$VULCAN_CORPORATE_Config.Name;description=$VULCAN_CORPORATE_Config.Path})
}
}
}
If ($Config | Where-Object { $_['CLIENT_LAVA'] -ne $null}) {
If ($Config.CLIENT_LAVA | Where-Object { $_['Setting'] -ne $null}) {
ForEach ($CLIENT_LAVA_Config in $Config.CLIENT_LAVA.Setting) {
$CLIENT_LAVA_Found = $True
$CLIENT_LAVA += @([pscustomobject]@{name=$CLIENT_LAVA_Config.Name;description=$CLIENT_LAVA_Config.Path})
}
}
}
}
}
}
$ENVIS_RESO += @([pscustomobject]@{name="Remove the variable";description="Remove the variable"})
$VULCAN_CORPORATE += @([pscustomobject]@{name="Remove the variable";description="Remove the variable"})
$CLIENT_LAVA += @([pscustomobject]@{name="Remove the variable";description="Remove the variable"})
#-------------------------------------------------------------
If ($ENVIS_RESO_Found) {
# Action = ENVIS_RESO
$actionLabel_ENVIS_RESO = New-Object System.Windows.Forms.Label
$actionLabel_ENVIS_RESO.Font = 'Microsoft Sans Serif, 9pt'
$actionLabel_ENVIS_RESO.Location = New-Object System.Drawing.Point(10,140)
$actionLabel_ENVIS_RESO.Name = 'action1label'
$actionLabel_ENVIS_RESO.Size = New-Object System.Drawing.Size(495,23)
$actionLabel_ENVIS_RESO.UseMnemonic = $false
$actionLabel_ENVIS_RESO.Text = "Change the Vulcan ENVIS_RESO environment variable"
$form.Controls.Add($actionLabel_ENVIS_RESO)
$DropDown_ENVIS_RESO = new-object System.Windows.Forms.ComboBox
$DropDown_ENVIS_RESO.Location = new-object System.Drawing.Point(25,165)
$DropDown_ENVIS_RESO.Size = new-object System.Drawing.Size(495,40)
$DropDown_ENVIS_RESO.DropDownStyle = [System.Windows.Forms.ComboBoxStyle]::DropDownList
# Load the values into the combo box
Load-ComboBox $DropDown_ENVIS_RESO $ENVIS_RESO -DisplayMember name -ValueMember description
# Set the selected item for the display
$index_ENVIS_RESO = 0
# Get the current value of the variable
$myvar_ENVIS_RESO = Get-EnvVariable -Name "ENVIS_RESO"
If ($null -ne $myvar_ENVIS_RESO) {
If (![String]::IsNullOrEmpty($myvar_ENVIS_RESO.value)) {
for($i=0;$i-le $ENVIS_RESO.length-1;$i++) {
if ($ENVIS_RESO[$i].description -eq $myvar_ENVIS_RESO.value) {
$index_ENVIS_RESO = $i
}
}
}
}
$DropDown_ENVIS_RESO.SelectedIndex = $index_ENVIS_RESO
$Form.Controls.Add($DropDown_ENVIS_RESO)
$DropDown_ENVIS_RESO.Add_SelectedIndexChanged({
# Inside here you can refer to the ComboBox object as $this
If ($this.SelectedItem.description -eq "Select an option") {
$this.SelectedIndex = $index_ENVIS_RESO
}
If ($this.SelectedItem.description -ne "Select an option") {
If ($this.SelectedItem.description -ne "Remove the variable") {
Set-MyVariable -Action:"Set" -Name:"ENVIS_RESO" -Value:$this.SelectedItem.description -SetUserVariableTarget:$True
} Else {
Set-MyVariable -Action:"Remove" -Name:"ENVIS_RESO"-SetUserVariableTarget:$True
}
# Refresh environment variables
EnvironmentRefresh
}
})
} Else {
$actionLabel_ENVIS_RESO = New-Object System.Windows.Forms.Label
$actionLabel_ENVIS_RESO.Font = 'Microsoft Sans Serif, 9pt'
$actionLabel_ENVIS_RESO.Location = New-Object System.Drawing.Point(10,140)
$actionLabel_ENVIS_RESO.Name = 'action1label'
$actionLabel_ENVIS_RESO.Size = New-Object System.Drawing.Size(495,23)
$actionLabel_ENVIS_RESO.UseMnemonic = $false
$actionLabel_ENVIS_RESO.Text = "Change the Vulcan ENVIS_RESO environment variable"
$form.Controls.Add($actionLabel_ENVIS_RESO)
$textBox_ENVIS_RESO = New-Object System.Windows.Forms.TextBox
$textBox_ENVIS_RESO.Location = New-Object System.Drawing.Point(25,165)
$textBox_ENVIS_RESO.Size = New-Object System.Drawing.Size(355,40)
$textBox_ENVIS_RESO.ReadOnly = $True
$form.Controls.Add($textBox_ENVIS_RESO)
# Get the current value of the variable
$Current_ENVIS_RESO_value = "Not set"
$myvar_ENVIS_RESO = Get-EnvVariable -Name "ENVIS_RESO"
If ($null -ne $myvar_ENVIS_RESO) {
If (![String]::IsNullOrEmpty($myvar_ENVIS_RESO.value)) {
$Current_ENVIS_RESO_value = $myvar_ENVIS_RESO.value
}
}
$textBox_ENVIS_RESO.Text = $Current_ENVIS_RESO_value
$actionButton1_ENVIS_RESO = New-Object System.Windows.Forms.Button
$actionButton1_ENVIS_RESO.Location = New-Object System.Drawing.Point(385,165)
$actionButton1_ENVIS_RESO.Size = New-Object System.Drawing.Size(65,23)
$actionButton1_ENVIS_RESO.Text = 'Browse'
$actionButton1_ENVIS_RESO.Add_Click({
$New_ENVIS_RESO_value = $null
#$New_ENVIS_RESO_value = Get-FolderName -Description:"Browse to a folder for the ENVIS_RESO environment variable" -RootFolder:"MyComputer" -ShowNewFolderButton
$dialog_ENVIS_RESO = New-Object FolderBrowserDialogEx
$dialog_ENVIS_RESO.Description = "Browse to a folder for the ENVIS_RESO environment variable"
$dialog_ENVIS_RESO.ShowNewFolderButton = $true
If ($textBox_ENVIS_RESO.Text -ne "Not set") {
$dialog_ENVIS_RESO.SelectedPath = $textBox_ENVIS_RESO.Text
} else {
$dialog_ENVIS_RESO.SelectedPath = "::{20D04FE0-3AEA-1069-A2D8-08002B30309D}"
}
if ($dialog_ENVIS_RESO.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {
$New_ENVIS_RESO_value = $dialog_ENVIS_RESO.SelectedPath
$StatusMessage = "Selected path: $New_ENVIS_RESO_value"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
} else {
$StatusMessage = "Dialog was canceled"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
}
If (![String]::IsNullOrEmpty($New_ENVIS_RESO_value)) {
$textBox_ENVIS_RESO.Text = $New_ENVIS_RESO_value
Set-MyVariable -Action:"Set" -Name:"ENVIS_RESO" -Value:$New_ENVIS_RESO_value -SetUserVariableTarget:$True
# Refresh environment variables
EnvironmentRefresh
} Else {
write-verbose "Failed to get folder name" -verbose
}
})
$form.AcceptButton = $actionButton1_ENVIS_RESO
$form.Controls.Add($actionButton1_ENVIS_RESO)
$actionButton2_ENVIS_RESO = New-Object System.Windows.Forms.Button
$actionButton2_ENVIS_RESO.Location = New-Object System.Drawing.Point(455,165)
$actionButton2_ENVIS_RESO.Size = New-Object System.Drawing.Size(65,23)
$actionButton2_ENVIS_RESO.Text = 'Remove'
$actionButton2_ENVIS_RESO.Add_Click({
$textBox_ENVIS_RESO.Text = "Not set"
Set-MyVariable -Action:"Remove" -Name:"ENVIS_RESO" -SetUserVariableTarget:$True
# Refresh environment variables
EnvironmentRefresh
})
$form.AcceptButton = $actionButton2_ENVIS_RESO
$form.Controls.Add($actionButton2_ENVIS_RESO)
}
#-------------------------------------------------------------
If ($VULCAN_CORPORATE_Found) {
# Action = VULCAN_CORPORATE
$actionlabel_VULCAN_CORPORATE = New-Object System.Windows.Forms.Label
$actionlabel_VULCAN_CORPORATE.Font = 'Microsoft Sans Serif, 9pt'
$actionlabel_VULCAN_CORPORATE.Location = New-Object System.Drawing.Point(10,195)
$actionlabel_VULCAN_CORPORATE.Name = 'action1label'
$actionlabel_VULCAN_CORPORATE.Size = New-Object System.Drawing.Size(495,23)
$actionlabel_VULCAN_CORPORATE.UseMnemonic = $false
$actionlabel_VULCAN_CORPORATE.Text = "Change the Vulcan VULCAN_CORPORATE environment variable"
$form.Controls.Add($actionlabel_VULCAN_CORPORATE)
$DropDown_VULCAN_CORPORATE = new-object System.Windows.Forms.ComboBox
$DropDown_VULCAN_CORPORATE.Location = new-object System.Drawing.Point(25,220)
$DropDown_VULCAN_CORPORATE.Size = new-object System.Drawing.Size(495,40)
$DropDown_VULCAN_CORPORATE.DropDownStyle = [System.Windows.Forms.ComboBoxStyle]::DropDownList
# Load the values into the combo box
Load-ComboBox $DropDown_VULCAN_CORPORATE $VULCAN_CORPORATE -DisplayMember name -ValueMember description
# Set the selected item for the display
$index_VULCAN_CORPORATE = 0
# Get the current value of the variable
$myvar_VULCAN_CORPORATE = Get-EnvVariable -Name "VULCAN_CORPORATE"
If ($null -ne $myvar_VULCAN_CORPORATE) {
If (![String]::IsNullOrEmpty($myvar_VULCAN_CORPORATE.value)) {
for($i=0;$i-le $VULCAN_CORPORATE.length-1;$i++) {
if ($VULCAN_CORPORATE[$i].description -eq $myvar_VULCAN_CORPORATE.value) {
$index_VULCAN_CORPORATE = $i
}
}
}
}
$DropDown_VULCAN_CORPORATE.SelectedIndex = $index_VULCAN_CORPORATE
$Form.Controls.Add($DropDown_VULCAN_CORPORATE)
$DropDown_VULCAN_CORPORATE.Add_SelectedIndexChanged({
# Inside here you can refer to the ComboBox object as $this
If ($this.SelectedItem.description -eq "Select an option") {
$this.SelectedIndex = $index_VULCAN_CORPORATE
}
If ($this.SelectedItem.description -ne "Select an option") {
If ($this.SelectedItem.description -ne "Remove the variable") {
Set-MyVariable -Action:"Set" -Name:"VULCAN_CORPORATE" -Value:$this.SelectedItem.description -SetUserVariableTarget:$True
} Else {
Set-MyVariable -Action:"Remove" -Name:"VULCAN_CORPORATE" -SetUserVariableTarget:$True
}
# Refresh environment variables
EnvironmentRefresh
}
})
} Else {
$actionLabel_VULCAN_CORPORATE = New-Object System.Windows.Forms.Label
$actionLabel_VULCAN_CORPORATE.Font = 'Microsoft Sans Serif, 9pt'
$actionLabel_VULCAN_CORPORATE.Location = New-Object System.Drawing.Point(10,195)
$actionLabel_VULCAN_CORPORATE.Name = 'action1label'
$actionLabel_VULCAN_CORPORATE.Size = New-Object System.Drawing.Size(495,23)
$actionLabel_VULCAN_CORPORATE.UseMnemonic = $false
$actionLabel_VULCAN_CORPORATE.Text = "Change the Vulcan VULCAN_CORPORATE environment variable"
$form.Controls.Add($actionLabel_VULCAN_CORPORATE)
$textBox_VULCAN_CORPORATE = New-Object System.Windows.Forms.TextBox
$textBox_VULCAN_CORPORATE.Location = New-Object System.Drawing.Point(25,220)
$textBox_VULCAN_CORPORATE.Size = New-Object System.Drawing.Size(355,40)
$textBox_VULCAN_CORPORATE.ReadOnly = $True
$form.Controls.Add($textBox_VULCAN_CORPORATE)
# Get the current value of the variable
$Current_VULCAN_CORPORATE_value = "Not set"
$myvar_VULCAN_CORPORATE = Get-EnvVariable -Name "VULCAN_CORPORATE"
If ($null -ne $myvar_VULCAN_CORPORATE) {
If (![String]::IsNullOrEmpty($myvar_VULCAN_CORPORATE.value)) {
$Current_VULCAN_CORPORATE_value = $myvar_VULCAN_CORPORATE.value
}
}
$textBox_VULCAN_CORPORATE.Text = $Current_VULCAN_CORPORATE_value
$actionButton1_VULCAN_CORPORATE = New-Object System.Windows.Forms.Button
$actionButton1_VULCAN_CORPORATE.Location = New-Object System.Drawing.Point(385,220)
$actionButton1_VULCAN_CORPORATE.Size = New-Object System.Drawing.Size(65,23)
$actionButton1_VULCAN_CORPORATE.Text = 'Browse'
$actionButton1_VULCAN_CORPORATE.Add_Click({
$New_VULCAN_CORPORATE_value = $null
#$New_VULCAN_CORPORATE_value = Get-FolderName -Description:"Browse to a folder for the VULCAN_CORPORATE environment variable" -RootFolder:"MyComputer" -ShowNewFolderButton
$dialog_VULCAN_CORPORATE = New-Object FolderBrowserDialogEx
$dialog_VULCAN_CORPORATE.Description = "Browse to a folder for the VULCAN_CORPORATE environment variable"
$dialog_VULCAN_CORPORATE.ShowNewFolderButton = $true
If ($textBox_VULCAN_CORPORATE.Text -ne "Not set") {
$dialog_VULCAN_CORPORATE.SelectedPath = $textBox_VULCAN_CORPORATE.Text
} else {
$dialog_VULCAN_CORPORATE.SelectedPath = "::{20D04FE0-3AEA-1069-A2D8-08002B30309D}"
}
if ($dialog_VULCAN_CORPORATE.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {
$New_VULCAN_CORPORATE_value = $dialog_VULCAN_CORPORATE.SelectedPath
$StatusMessage = "Selected path: $New_VULCAN_CORPORATE_value"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
} else {
$StatusMessage = "Dialog was canceled"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
}
If (![String]::IsNullOrEmpty($New_VULCAN_CORPORATE_value)) {
$textBox_VULCAN_CORPORATE.Text = $New_VULCAN_CORPORATE_value
Set-MyVariable -Action:"Set" -Name:"VULCAN_CORPORATE" -Value:$New_VULCAN_CORPORATE_value -SetUserVariableTarget:$True
# Refresh environment variables
EnvironmentRefresh
} Else {
write-verbose "Failed to get folder name" -verbose
}
})
$form.AcceptButton = $actionButton1_VULCAN_CORPORATE
$form.Controls.Add($actionButton1_VULCAN_CORPORATE)
$actionButton2_VULCAN_CORPORATE = New-Object System.Windows.Forms.Button
$actionButton2_VULCAN_CORPORATE.Location = New-Object System.Drawing.Point(455,220)
$actionButton2_VULCAN_CORPORATE.Size = New-Object System.Drawing.Size(65,23)
$actionButton2_VULCAN_CORPORATE.Text = 'Remove'
$actionButton2_VULCAN_CORPORATE.Add_Click({
$textBox_VULCAN_CORPORATE.Text = "Not set"
Set-MyVariable -Action:"Remove" -Name:"VULCAN_CORPORATE" -SetUserVariableTarget:$True
# Refresh environment variables
EnvironmentRefresh
})
$form.AcceptButton = $actionButton2_VULCAN_CORPORATE
$form.Controls.Add($actionButton2_VULCAN_CORPORATE)
}
#-------------------------------------------------------------
If ($CLIENT_LAVA_Found) {
# Action = CLIENT_LAVA
$actionlabel_CLIENT_LAVA = New-Object System.Windows.Forms.Label
$actionlabel_CLIENT_LAVA.Font = 'Microsoft Sans Serif, 9pt'
$actionlabel_CLIENT_LAVA.Location = New-Object System.Drawing.Point(10,250)
$actionlabel_CLIENT_LAVA.Name = 'action1label'
$actionlabel_CLIENT_LAVA.Size = New-Object System.Drawing.Size(495,23)
$actionlabel_CLIENT_LAVA.UseMnemonic = $false
$actionlabel_CLIENT_LAVA.Text = "Change the Vulcan CLIENT_LAVA environment variable"
$form.Controls.Add($actionlabel_CLIENT_LAVA)
$DropDown_CLIENT_LAVA = new-object System.Windows.Forms.ComboBox
$DropDown_CLIENT_LAVA.Location = new-object System.Drawing.Point(25,275)
$DropDown_CLIENT_LAVA.Size = new-object System.Drawing.Size(495,40)
$DropDown_CLIENT_LAVA.DropDownStyle = [System.Windows.Forms.ComboBoxStyle]::DropDownList
# Load the values into the combo box
Load-ComboBox $DropDown_CLIENT_LAVA $CLIENT_LAVA -DisplayMember name -ValueMember description
# Set the selected item for the display
$index_CLIENT_LAVA = 0
# Get the current value of the variable
$myvar_CLIENT_LAVA = Get-EnvVariable -Name "CLIENT_LAVA"
If ($null -ne $myvar_CLIENT_LAVA) {
If (![String]::IsNullOrEmpty($myvar_CLIENT_LAVA.value)) {
for($i=0;$i-le $CLIENT_LAVA.length-1;$i++) {
if ($CLIENT_LAVA[$i].description -eq $myvar_CLIENT_LAVA.value) {
$index_CLIENT_LAVA = $i
}
}
}
}
$DropDown_CLIENT_LAVA.SelectedIndex = $index_CLIENT_LAVA
$Form.Controls.Add($DropDown_CLIENT_LAVA)
$DropDown_CLIENT_LAVA.Add_SelectedIndexChanged({
# Inside here you can refer to the ComboBox object as $this
If ($this.SelectedItem.description -eq "Select an option") {
$this.SelectedIndex = $index_CLIENT_LAVA
}
If ($this.SelectedItem.description -ne "Select an option") {
If ($this.SelectedItem.description -ne "Remove the variable") {
Set-MyVariable -Action:"Set" -Name:"CLIENT_LAVA" -Value:$this.SelectedItem.description -SetUserVariableTarget:$True
} Else {
Set-MyVariable -Action:"Remove" -Name:"CLIENT_LAVA" -SetUserVariableTarget:$True
}
# Refresh environment variables
EnvironmentRefresh
}
})
} Else {
$actionLabel_CLIENT_LAVA = New-Object System.Windows.Forms.Label
$actionLabel_CLIENT_LAVA.Font = 'Microsoft Sans Serif, 9pt'
$actionLabel_CLIENT_LAVA.Location = New-Object System.Drawing.Point(10,250)
$actionLabel_CLIENT_LAVA.Name = 'action1label'
$actionLabel_CLIENT_LAVA.Size = New-Object System.Drawing.Size(495,23)
$actionLabel_CLIENT_LAVA.UseMnemonic = $false
$actionLabel_CLIENT_LAVA.Text = "Change the Vulcan CLIENT_LAVA environment variable"
$form.Controls.Add($actionLabel_CLIENT_LAVA)
$textBox_CLIENT_LAVA = New-Object System.Windows.Forms.TextBox
$textBox_CLIENT_LAVA.Location = New-Object System.Drawing.Point(25,275)
$textBox_CLIENT_LAVA.Size = New-Object System.Drawing.Size(355,40)
$textBox_CLIENT_LAVA.ReadOnly = $True
$form.Controls.Add($textBox_CLIENT_LAVA)
# Get the current value of the variable
$Current_CLIENT_LAVA_value = "Not set"
$myvar_CLIENT_LAVA = Get-EnvVariable -Name "CLIENT_LAVA"
If ($null -ne $myvar_CLIENT_LAVA) {
If (![String]::IsNullOrEmpty($myvar_CLIENT_LAVA.value)) {
$Current_CLIENT_LAVA_value = $myvar_CLIENT_LAVA.value
}
}
$textBox_CLIENT_LAVA.Text = $Current_CLIENT_LAVA_value
$actionButton1_CLIENT_LAVA = New-Object System.Windows.Forms.Button
$actionButton1_CLIENT_LAVA.Location = New-Object System.Drawing.Point(385,275)
$actionButton1_CLIENT_LAVA.Size = New-Object System.Drawing.Size(65,23)
$actionButton1_CLIENT_LAVA.Text = 'Browse'
$actionButton1_CLIENT_LAVA.Add_Click({
$New_CLIENT_LAVA_value = $null
#$New_CLIENT_LAVA_value = Get-FolderName -Description:"Browse to a folder for the CLIENT_LAVA environment variable" -RootFolder:"MyComputer" -ShowNewFolderButton
$dialog_CLIENT_LAVA = New-Object FolderBrowserDialogEx
$dialog_CLIENT_LAVA.Description = "Browse to a folder for the CLIENT_LAVA environment variable"
$dialog_CLIENT_LAVA.ShowNewFolderButton = $true
If ($textBox_CLIENT_LAVA.Text -ne "Not set") {
$dialog_CLIENT_LAVA.SelectedPath = $textBox_CLIENT_LAVA.Text
} else {
$dialog_CLIENT_LAVA.SelectedPath = "::{20D04FE0-3AEA-1069-A2D8-08002B30309D}"
}
if ($dialog_CLIENT_LAVA.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) {
$New_CLIENT_LAVA_value = $dialog_CLIENT_LAVA.SelectedPath
$StatusMessage = "Selected path: $New_CLIENT_LAVA_value"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
} else {
$StatusMessage = "Dialog was canceled"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
}
If (![String]::IsNullOrEmpty($New_CLIENT_LAVA_value)) {
$textBox_CLIENT_LAVA.Text = $New_CLIENT_LAVA_value
Set-MyVariable -Action:"Set" -Name:"CLIENT_LAVA" -Value:$New_CLIENT_LAVA_value -SetUserVariableTarget:$True
# Refresh environment variables
EnvironmentRefresh
} Else {
write-verbose "Failed to get folder name" -verbose
}
})
$form.AcceptButton = $actionButton1_CLIENT_LAVA
$form.Controls.Add($actionButton1_CLIENT_LAVA)
$actionButton2_CLIENT_LAVA = New-Object System.Windows.Forms.Button
$actionButton2_CLIENT_LAVA.Location = New-Object System.Drawing.Point(455,275)
$actionButton2_CLIENT_LAVA.Size = New-Object System.Drawing.Size(65,23)
$actionButton2_CLIENT_LAVA.Text = 'Remove'
$actionButton2_CLIENT_LAVA.Add_Click({
$textBox_CLIENT_LAVA.Text = "Not set"
Set-MyVariable -Action:"Remove" -Name:"CLIENT_LAVA" -SetUserVariableTarget:$True
# Refresh environment variables
EnvironmentRefresh
})
$form.AcceptButton = $actionButton2_CLIENT_LAVA
$form.Controls.Add($actionButton2_CLIENT_LAVA)
}
#-------------------------------------------------------------
# Action = VULCAN_THREADING
$actionlabel_VULCAN_THREADING = New-Object System.Windows.Forms.Label
$actionlabel_VULCAN_THREADING.Font = 'Microsoft Sans Serif, 9pt'
$actionlabel_VULCAN_THREADING.Location = New-Object System.Drawing.Point(10,305)
$actionlabel_VULCAN_THREADING.Name = 'action1label'
$actionlabel_VULCAN_THREADING.Size = New-Object System.Drawing.Size(370,23)
$actionlabel_VULCAN_THREADING.UseMnemonic = $false
$actionlabel_VULCAN_THREADING.Text = "Change the Vulcan VULCAN_THREADING environment variable"
$form.Controls.Add($actionlabel_VULCAN_THREADING)
# We get the number of logical processors and set the VULCAN_THREADING environment variable to the total minus 1.
# For Example: If we have 8 logical processors, VULCAN_THREADING is set to 7.
# Sometimes users may want to change this, so we allow it here.
[int]$NumberOfLogicalProcessors = (Get-LogicalProcessorCount) - 1
$VULCAN_THREADING_Options = @([pscustomobject]@{name="Select an option";description="Select an option"})
for($i = $NumberOfLogicalProcessors; $i -gt 0; $i--) {
$VULCAN_THREADING_Options += [pscustomobject]@{name="$i Logical Processors";description=$i}
}
$VULCAN_THREADING_Options += [pscustomobject]@{name="Remove the variable";description="Remove the variable"}
$DropDown_VULCAN_THREADING = new-object System.Windows.Forms.ComboBox
$DropDown_VULCAN_THREADING.Location = new-object System.Drawing.Point(385,305)
$DropDown_VULCAN_THREADING.Size = new-object System.Drawing.Size(135,40)
$DropDown_VULCAN_THREADING.DropDownStyle = [System.Windows.Forms.ComboBoxStyle]::DropDownList
# Load the values into the combo box
Load-ComboBox $DropDown_VULCAN_THREADING $VULCAN_THREADING_Options -DisplayMember name -ValueMember description
# Get the current value of the variable, or set the default if a value does not exist or is too high.
$myvar_VULCAN_THREADING = Get-EnvVariable -Name "VULCAN_THREADING"
$SetDefaultValue = $False
If ($null -eq $myvar_VULCAN_THREADING) {
$SetDefaultValue = $True
} Else {
If (![String]::IsNullOrEmpty($myvar_VULCAN_THREADING.value)) {
$CurrentValue = [Convert]::ToInt32($myvar_VULCAN_THREADING.value)
If ($CurrentValue -eq 0 -OR $CurrentValue -gt $NumberOfLogicalProcessors) {
$SetDefaultValue = $True
}
} Else {
$SetDefaultValue = $True
}
}
If ($SetDefaultValue) {
Set-MyVariable -Action:"Set" -Name:"VULCAN_THREADING" -Value:$NumberOfLogicalProcessors -SetUserVariableTarget:$True -Silent
# Refresh environment variables
EnvironmentRefresh
$myvar_VULCAN_THREADING = Get-EnvVariable -Name "VULCAN_THREADING"
}
# Set the selected item for the display
$index_VULCAN_THREADING = 0
If ($null -ne $myvar_VULCAN_THREADING) {
If (![String]::IsNullOrEmpty($myvar_VULCAN_THREADING.value)) {
for($i=0;$i-le $VULCAN_THREADING_Options.length-1;$i++) {
if ($VULCAN_THREADING_Options[$i].description -eq $myvar_VULCAN_THREADING.value) {
$index_VULCAN_THREADING = $i
}
}
}
}
$DropDown_VULCAN_THREADING.SelectedIndex = $index_VULCAN_THREADING
$Form.Controls.Add($DropDown_VULCAN_THREADING)
$DropDown_VULCAN_THREADING.Add_SelectedIndexChanged({
# Inside here you can refer to the ComboBox object as $this
If ($this.SelectedItem.description -eq "Select an option") {
$this.SelectedIndex = $index_VULCAN_THREADING
}
If ($this.SelectedItem.description -ne "Select an option") {
If ($this.SelectedItem.description -ne "Remove the variable") {
Set-MyVariable -Action:"Set" -Name:"VULCAN_THREADING" -Value:$this.SelectedItem.description -SetUserVariableTarget:$True
} Else {
Set-MyVariable -Action:"Remove" -Name:"VULCAN_THREADING" -SetUserVariableTarget:$True
}
# Refresh environment variables
EnvironmentRefresh
}
})
#-------------------------------------------------------------
# Action = Set_VULCAN_POLYLINES_CACHE_CheckBox
$checkBox_Set_VULCAN_POLYLINES_CACHE = New-Object System.Windows.Forms.CheckBox
$checkBox_Set_VULCAN_POLYLINES_CACHE.Location = New-Object System.Drawing.Point(10,335)
$checkBox_Set_VULCAN_POLYLINES_CACHE.Size = New-Object System.Drawing.Size(495,23)
$checkBox_Set_VULCAN_POLYLINES_CACHE.Text = "Enable the VULCAN_POLYLINES_CACHE environment variable"
# Get the current value of the variable, or set the default if a value does not exist.
$SetDefaultValue = $False
$myvar_VULCAN_POLYLINES_CACHE = Get-EnvVariable -Name "VULCAN_POLYLINES_CACHE"
If ($null -ne $myvar_VULCAN_POLYLINES_CACHE) {
If (![String]::IsNullOrEmpty($myvar_VULCAN_POLYLINES_CACHE.value)) {
$CurrentValue = [Convert]::ToInt32($myvar_VULCAN_POLYLINES_CACHE.value)
If ($CurrentValue -eq 1) {
$SetDefaultValue = $True
} Else {
$SetDefaultValue = $False
}
} Else {
$SetDefaultValue = $True
}
} Else {
$SetDefaultValue = $True
}
If ($SetDefaultValue) {
$checkBox_Set_VULCAN_POLYLINES_CACHE.Checked = $True
Set-MyVariable -Action:"Set" -Name:"VULCAN_POLYLINES_CACHE" -Value:"1" -SetUserVariableTarget:$True -Silent
} Else {
$checkBox_Set_VULCAN_POLYLINES_CACHE.Checked = $False
Set-MyVariable -Action:"Set" -Name:"VULCAN_POLYLINES_CACHE" -Value:"0" -SetUserVariableTarget:$True -Silent
}
# Refresh environment variables
EnvironmentRefresh
$form.Controls.Add($checkBox_Set_VULCAN_POLYLINES_CACHE)
$checkBox_Set_VULCAN_POLYLINES_CACHE.Add_CheckStateChanged({
If ($this.Checked) {
Set-MyVariable -Action:"Set" -Name:"VULCAN_POLYLINES_CACHE" -Value:"1" -SetUserVariableTarget:$True
} Else {
Set-MyVariable -Action:"Set" -Name:"VULCAN_POLYLINES_CACHE" -Value:"0" -SetUserVariableTarget:$True
}
# Refresh environment variables
EnvironmentRefresh
})
#-------------------------------------------------------------
# Action = Remove_Redundant_Variables
If ($RemoveRedundantVariables) {
Set-MyVariable -Action:"Remove" -Name:"ENVIS_MAXTRI" -Redundant -SetUserVariableTarget:$True -Silent
Set-MyVariable -Action:"Remove" -Name:"ENVIS_MAXTRP" -Redundant -SetUserVariableTarget:$True -Silent
# Refresh environment variables
EnvironmentRefresh
}
#-------------------------------------------------------------
# Action = Get_Variables
$VulcanUserVariables = @("CLIENT_LAVA","ENVIS_RESO","HOME","MAPTEK_BORROW","MMT_VULCAN","VULCAN","VULCAN_EXE_RP","VULCAN_CORPORATE","VULCAN_THREADING","VULCAN_POLYLINES_CACHE")
$VulcanUserDepreciatedVariables = @("ENVIS_MAXTRI","ENVIS_MAXTRP")
$VulcanComputerVariables = @()
$arrPaths = @()
$UserTempVariables = @("TEMP","TMP")
$actionButton_Get_Variables = New-Object System.Windows.Forms.Button
$actionButton_Get_Variables.Location = New-Object System.Drawing.Point(10,365)
$actionButton_Get_Variables.Size = New-Object System.Drawing.Size(250,23)
$actionButton_Get_Variables.Text = 'Display Maptek Environment Variables'
$actionButton_Get_Variables.TextAlign = "MiddleLeft"
$actionButton_Get_Variables.Add_Click({
$MessageText = ""
If (($VulcanUserVariables | Measure-Object).Count -gt 0) {
$StatusMessage = "User environment variables that have been set:"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += " `r`n$StatusMessage `r`n"
ForEach ($VulcanUserVariable in $VulcanUserVariables) {
$tempVar = $null
$tempVar = Get-EnvVariable -Name $VulcanUserVariable
If ($null -ne $tempVar) {
If (![String]::IsNullOrEmpty($tempVar.value)) {
$StatusMessage = "- $VulcanUserVariable = $($tempVar.value)"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += "$StatusMessage `r`n"
}
}
}
}
If (($VulcanUserVariables | Measure-Object).Count -gt 0) {
$StatusMessage = "Current process environment variables that have been set. Please note that these override the user environment variables:"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += " `r`n$StatusMessage `r`n"
ForEach ($VulcanUserVariable in $VulcanUserVariables) {
$tempVar = $null
$tempVar = Get-EnvVariable -Name $VulcanUserVariable -Process
If ($null -ne $tempVar) {
If (![String]::IsNullOrEmpty($tempVar.value)) {
$StatusMessage = "- $VulcanUserVariable = $($tempVar.value)"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += "$StatusMessage `r`n"
}
}
}
}
If (($VulcanUserDepreciatedVariables | Measure-Object).Count -gt 0) {
$StatusMessage = "User Level Depreciated Environment Variables:"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += " `r`n$StatusMessage `r`n"
ForEach ($VulcanUserDepreciatedVariable in $VulcanUserDepreciatedVariables) {
$tempVar = $null
$tempVar = Get-EnvVariable -Name $VulcanUserDepreciatedVariable
If ($null -ne $tempVar) {
If (![String]::IsNullOrEmpty($tempVar.value)) {
$StatusMessage = "- $VulcanUserDepreciatedVariable = $($tempVar.value)"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += "$StatusMessage `r`n"
}
} Else {
$StatusMessage = "- $VulcanUserDepreciatedVariable has not been set"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += "$StatusMessage `r`n"
}
}
}
$regexPaths = [regex]::Escape("Vulcan")
$arrPaths = [System.Environment]::GetEnvironmentVariable('PATH', 'User') -split ';'
ForEach ($path in $regexPaths) {
$arrPaths = $arrPaths | Where-Object { $_ -Match ".*$path\\?" }
}
$NoVulcanPathFound = $True
If (($arrPaths | Measure-Object).Count -gt 0) {
$StatusMessage = "Vulcan paths in the user PATH variable:"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += " `r`n$StatusMessage `r`n"
ForEach ($arrPath in $arrPaths) {
$NoVulcanPathFound = $False
$StatusMessage = "- $arrPath"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += "$StatusMessage `r`n"
}
}
If ($NoVulcanPathFound) {
$StatusMessage = "No Vulcan paths could be found in the user PATH variable"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += " `r`n$StatusMessage `r`n"
}
$NoVulcanPathFound = $True
$arrPaths = [System.Environment]::GetEnvironmentVariable('PATH', 'Process') -split ';'
ForEach ($path in $regexPaths) {
$arrPaths = $arrPaths | Where-Object { $_ -Match ".*$path\\?" }
}
If (($arrPaths | Measure-Object).Count -gt 0) {
$StatusMessage = "Vulcan paths in the current process PATH variable. Please note that these override the user PATH variable:"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += " `r`n$StatusMessage `r`n"
ForEach ($arrPath in $arrPaths) {
$NoVulcanPathFound = $False
$StatusMessage = "- $arrPath"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += "$StatusMessage `r`n"
}
}
If ($NoVulcanPathFound) {
$StatusMessage = "No Vulcan paths could be found in the Current process PATH variable"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += " `r`n$StatusMessage `r`n"
}
If (($VulcanComputerVariables | Measure-Object).Count -gt 0) {
$StatusMessage = "Computer Level Environment Variables:"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += " `r`n$StatusMessage `r`n"
ForEach ($VulcanComputerVariable in $VulcanComputerVariables) {
$tempVar = $null
$tempVar = Get-EnvVariable -Name $VulcanComputerVariable
If ($null -ne $tempVar) {
If (![String]::IsNullOrEmpty($tempVar.value)) {
$StatusMessage = "- $VulcanComputerVariable = $($tempVar.value)"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += "$StatusMessage `r`n"
}
} Else {
$StatusMessage = "- $VulcanComputerVariable has not been set"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += "$StatusMessage `r`n"
}
}
}
If (($UserTempVariables | Measure-Object).Count -gt 0) {
$StatusMessage = "User TEMP & TMP environment variables:"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += " `r`n$StatusMessage `r`n"
ForEach ($UserTempVariable in $UserTempVariables) {
$tempVar = $null
$tempVar = Get-EnvVariable -Name $UserTempVariable
If ($null -ne $tempVar) {
If (![String]::IsNullOrEmpty($tempVar.value)) {
$StatusMessage = "- $UserTempVariable = $($tempVar.value)"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += "$StatusMessage `r`n"
}
} Else {
$StatusMessage = "- $UserTempVariable has not been set"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += "$StatusMessage `r`n"
}
}
}
If (($UserTempVariables | Measure-Object).Count -gt 0) {
$StatusMessage = "Current process TEMP & TMP environment variables. Please note that these override the user TEMP & TMP variables:"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += " `r`n$StatusMessage `r`n"
ForEach ($UserTempVariable in $UserTempVariables) {
$tempVar = $null
$tempVar = Get-EnvVariable -Name $UserTempVariable -Process
If ($null -ne $tempVar) {
If (![String]::IsNullOrEmpty($tempVar.value)) {
$StatusMessage = "- $UserTempVariable = $($tempVar.value)"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += "$StatusMessage `r`n"
}
} Else {
$StatusMessage = "- $UserTempVariable has not been set"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$MessageText += "$StatusMessage `r`n"
}
}
}
#$form2 = [MyForm.FormWithoutX]::new()
$form2 = New-Object System.Windows.Forms.Form
$form2.Topmost = $true
$form2.Text = 'Maptek Environment Variables'
$form2.ClientSize = New-Object System.Drawing.Size(450,690)
$form2.MaximizeBox = $False
$form2.MinimizeBox = $False
$form2.MinimumSize = New-Object System.Drawing.Size(450,690)
$form2.MaximumSize = New-Object System.Drawing.Size(450,690)
$form2.FormBorderStyle = "FixedDialog"
$form2.SizeGripStyle = "Hide"
If (Test-Path "$IconFile") {
$form2.Icon = [System.Drawing.Icon]::ExtractAssociatedIcon("$IconFile")
}
$form2.WindowState = 'Normal'
$close2Button = New-Object System.Windows.Forms.Button
$close2Button.Location = New-Object System.Drawing.Point(180,620)
$close2Button.Size = New-Object System.Drawing.Size(75,23)
$close2Button.Text = 'Close'
$close2Button.DialogResult = [System.Windows.Forms.DialogResult]::OK
$form2.CancelButton = $close2Button
$form2.Controls.Add($close2Button)
$status2label = New-Object System.Windows.Forms.Label
$status2label.Font = 'Microsoft Sans Serif, 9pt'
$status2label.Location = New-Object System.Drawing.Point(10,10)
$status2label.Name = 'status2label'
$status2label.Size = New-Object System.Drawing.Size(400,23)
$status2label.UseMnemonic = $false
$status2label.Text = "This is a list of the Maptek Environment Variables and their values:"
$form2.Controls.Add($status2label)
$status2TextBox = New-Object System.Windows.Forms.RichTextBox
$status2TextBox.Location = New-Object System.Drawing.Point(10,40)
$status2TextBox.Size = New-Object System.Drawing.Size(410,570)
$status2TextBox.Multiline = $true
$status2TextBox.WordWrap = $true
$status2TextBox.DetectUrls = $false
$status2TextBox.ScrollBars = [System.Windows.Forms.ScrollBars]::'Vertical'
$status2TextBox.Enabled = $true
$status2TextBox.ReadOnly = $true
$oldFont = $status2label.Font
$newFont = New-Object System.Drawing.Font($oldFont.FontFamily, $oldFont.Size, [System.Drawing.FontStyle]::Bold)
$status1TextBox.Font = $newFont
$form2.Controls.Add($status2TextBox)
$status2TextBox.AppendText("$MessageText")
$status2TextBox.ScrollToCaret()
[void]$Form2.showdialog()
})
$form.AcceptButton = $actionButton_Get_Variables
$form.Controls.Add($actionButton_Get_Variables)
#-------------------------------------------------------------
# Action = Vulcan_Prefs_BPA
$actionButton_Vulcan_Prefs_BPA = New-Object System.Windows.Forms.Button
$actionButton_Vulcan_Prefs_BPA.Location = New-Object System.Drawing.Point(270,365)
$actionButton_Vulcan_Prefs_BPA.Size = New-Object System.Drawing.Size(250,23)
$actionButton_Vulcan_Prefs_BPA.Text = 'Run vulcan.prefs best practice analyser (BPA)'
$actionButton_Vulcan_Prefs_BPA.TextAlign = "MiddleLeft"
$actionButton_Vulcan_Prefs_BPA.Enabled = $False
$actionButton_Vulcan_Prefs_BPA.Add_Click({
$vulcanprefslocation = "${env:USERPROFILE}"
$vulcanprefs = "vulcan.prefs"
if (Test-Path "$vulcanprefslocation\$vulcanprefs") {
$StatusMessage = "This feature will be created in a future release"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
} Else {
$StatusMessage = "`"$vulcanprefslocation\$vulcanprefs`" does not exist"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
}
})
$form.AcceptButton = $actionButton_Vulcan_Prefs_BPA
$form.Controls.Add($actionButton_Vulcan_Prefs_BPA)
#-------------------------------------------------------------
# Action = Edit_Vulcan_Prefs
$actionButton_Edit_Vulcan_Prefs = New-Object System.Windows.Forms.Button
$actionButton_Edit_Vulcan_Prefs.Location = New-Object System.Drawing.Point(10,395)
$actionButton_Edit_Vulcan_Prefs.Size = New-Object System.Drawing.Size(250,23)
$actionButton_Edit_Vulcan_Prefs.Text = 'Edit vulcan.prefs with Notepad++'
$actionButton_Edit_Vulcan_Prefs.TextAlign = "MiddleLeft"
If (Test-Path "$TextEditor") {
If ($Advanced -eq $False) {
$actionButton_Edit_Vulcan_Prefs.Enabled = $False
} Else {
$actionButton_Edit_Vulcan_Prefs.Enabled = $True
}
} Else {
$actionButton_Edit_Vulcan_Prefs.Enabled = $False
$StatusMessage = "Disabling opening vulcan.prefs with Notepad++ button..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$StatusMessage = "- `"$TextEditor`" was not found on this computer."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
}
$actionButton_Edit_Vulcan_Prefs.Add_Click({
$vulcanprefs = "${env:USERPROFILE}\vulcan.prefs"
if (Test-Path "$vulcanprefs") {
$StatusMessage = "Opening vulcan.prefs with Notepad++..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
# Launching the app
$LaunchAppName = "Notepad++"
$LaunchProcess = "$TextEditor"
$LaunchArguments = "$vulcanprefs"
$WorkingDirectory = "${env:HOMEDRIVE}${env:HOMEPATH}\"
Launch-App -AppName:"$LaunchAppName" -AppExecutable:"$LaunchProcess" -CmdLineArgs:"$LaunchArguments" -WorkingDirectory:"$WorkingDirectory" -SHowUI
} Else {
$StatusMessage = "`"$vulcanprefs`" was not found on this computer."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
}
})
$form.AcceptButton = $actionButton_Edit_Vulcan_Prefs
$form.Controls.Add($actionButton_Edit_Vulcan_Prefs)
#-------------------------------------------------------------
# Action = Rename_Vulcan_Prefs
$actionButton_Rename_Vulcan_Pref = New-Object System.Windows.Forms.Button
$actionButton_Rename_Vulcan_Pref.Location = New-Object System.Drawing.Point(270,395)
$actionButton_Rename_Vulcan_Pref.Size = New-Object System.Drawing.Size(250,23)
$actionButton_Rename_Vulcan_Pref.UseMnemonic = $false
$actionButton_Rename_Vulcan_Pref.Text = 'Rename vulcan.prefs with time & date stamp'
$actionButton_Rename_Vulcan_Pref.TextAlign = "MiddleLeft"
If ($Advanced -eq $False) {
$actionButton_Rename_Vulcan_Pref.Enabled = $False
} Else {
$actionButton_Rename_Vulcan_Pref.Enabled = $True
}
$actionButton_Rename_Vulcan_Pref.Add_Click({
$invalidChars = [io.path]::GetInvalidFileNamechars()
$datestampforfilename = ((Get-Date -format s).ToString() -replace "[$invalidChars]","-")
# The s means SortableDateTimePattern, which always uses the invariant culture. This will format the date and time as "yyyy-MM-ddTHH:mm:ss". We then
# replace the : with a -.
$vulcanprefslocation = "${env:USERPROFILE}"
$vulcanprefs = "vulcan.prefs"
$vulcanprefsnew = "vulcan_" + "$datestampforfilename" + ".prefs"
if (Test-Path "$vulcanprefslocation\$vulcanprefs") {
$StatusMessage = "Renaming $vulcanprefs to $vulcanprefsnew ..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
Get-ChildItem -path "$vulcanprefslocation\" -Filter "$vulcanprefs" | where {!$_.PSIsContainer} | Rename-Item -newname ("$vulcanprefslocation\$vulcanprefsnew") -force
# Only keep up to 7 backups to prevent bloat in the user profile.
Get-ChildItem -Path "${ENV:USERPROFILE}" -Filter "$($vulcanprefs.replace('.','*.'))" | where {!$_.PSIsContainer} | Sort-Object -Property LastWriteTime -Descending | Select-Object -Skip 7 | Remove-Item -Force
} Else {
$StatusMessage = "`"$vulcanprefslocation\$vulcanprefs`" does not exist"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
}
})
$form.AcceptButton = $actionButton_Rename_Vulcan_Pref
$form.Controls.Add($actionButton_Rename_Vulcan_Pref)
#-------------------------------------------------------------
# Action = BL_Cache
$actionButton_BL_Cache = New-Object System.Windows.Forms.Button
$actionButton_BL_Cache.Location = New-Object System.Drawing.Point(10,425)
$actionButton_BL_Cache.Size = New-Object System.Drawing.Size(250,23)
$actionButton_BL_Cache.Text = 'Delete the BlastLogic Cache'
$actionButton_BL_Cache.TextAlign = "MiddleLeft"
$actionButton_BL_Cache.Add_Click({
$BlastLogicCache = "${env:APPDATA}\Maptek\BlastLogic\Cache"
If (Test-Path -Path $BlastLogicCache) {
$StatusMessage = "Deleting the BlastLogic cache folders..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
# Set the sting level. 0 = include base folder, 1 = sub-folders only, 2 = start at 2nd level
$StartLevel = 2
# Set number of levels deep to scan
$Depth = 2
# Set the starting path
$BlastLogicCache = "${env:APPDATA}\Maptek\BlastLogic\Cache"
$CacheFolders = $null
For ($i=$StartLevel; $i -le $Depth; $i++) {
$Levels = "\*" * $i
Try {
$CacheFolders = (Resolve-Path $BlastLogicCache$Levels).ProviderPath | Get-Item -ErrorAction Stop | Where PsIsContainer | Select FullName
}
Catch [System.Exception]{
#$($Error[0].Exception.Message)
}
}
If ($null -ne $CacheFolders) {
ForEach ($CacheFolder in $CacheFolders) {
Try {
Get-Item -Path $CacheFolder.FullName | Remove-Item -force -recurse -confirm:$false -ErrorAction Stop
$StatusMessage = "- $($CacheFolder.FullName)"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
}
Catch [System.Exception]{
#$($Error[0].Exception.Message)
}
}
} Else {
$StatusMessage = " - No cache folders were found"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
}
} Else {
$StatusMessage = "The BlastLogic cache folder does not exist"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
}
})
$form.AcceptButton = $actionButton_BL_Cache
$form.Controls.Add($actionButton_BL_Cache)
#-------------------------------------------------------------
# Action = System_Information
$actionButton_System_Information = New-Object System.Windows.Forms.Button
$actionButton_System_Information.Location = New-Object System.Drawing.Point(270,425)
$actionButton_System_Information.Size = New-Object System.Drawing.Size(250,23)
$actionButton_System_Information.Text = 'Open System Information Tool'
$actionButton_System_Information.TextAlign = "MiddleLeft"
$actionButton_System_Information.Add_Click({
# Open System Information Tool
# C:\Windows\System32\msinfo32.exe
$StatusMessage = "Opening System Information..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
# Launching the app
$LaunchAppName = "System Information"
$LaunchProcess = "${env:SystemRoot}\System32\msinfo32.exe"
$LaunchArguments = ""
$WorkingDirectory = "${env:HOMEDRIVE}${env:HOMEPATH}\"
Launch-App -AppName:"$LaunchAppName" -AppExecutable:"$LaunchProcess" -CmdLineArgs:"$LaunchArguments" -WorkingDirectory:"$WorkingDirectory" -SHowUI
})
$form.AcceptButton = $actionButton_System_Information
$form.Controls.Add($actionButton_System_Information)
#-------------------------------------------------------------
# Action = File_Explorer
$actionButton_File_Explorer = New-Object System.Windows.Forms.Button
$actionButton_File_Explorer.Location = New-Object System.Drawing.Point(10,455)
$actionButton_File_Explorer.Size = New-Object System.Drawing.Size(250,23)
$actionButton_File_Explorer.Text = 'Open File Explorer'
$actionButton_File_Explorer.TextAlign = "MiddleLeft"
$actionButton_File_Explorer.Add_Click({
# Open File Explorer
# "C:\Windows\explorer.exe /n ,::{20D04FE0-3AEA-1069-A2D8-08002B30309D}"
$StatusMessage = "Opening File Explorer..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
# Launching the app
$LaunchAppName = "File Explorer"
$LaunchProcess = "${env:SystemRoot}\explorer.exe"
$LaunchArguments = "/n ,::{20D04FE0-3AEA-1069-A2D8-08002B30309D}"
$WorkingDirectory = "${env:HOMEDRIVE}${env:HOMEPATH}\"
Launch-App -AppName:"$LaunchAppName" -AppExecutable:"$LaunchProcess" -CmdLineArgs:"$LaunchArguments" -WorkingDirectory:"$WorkingDirectory" -SHowUI
})
$form.AcceptButton = $actionButton_File_Explorer
$form.Controls.Add($actionButton_File_Explorer)
#-------------------------------------------------------------
# Action = Edit_Variables
$actionButton_Edit_Variables = New-Object System.Windows.Forms.Button
$actionButton_Edit_Variables.Location = New-Object System.Drawing.Point(270,455)
$actionButton_Edit_Variables.Size = New-Object System.Drawing.Size(250,23)
$actionButton_Edit_Variables.Text = 'Edit Environment Variables'
$actionButton_Edit_Variables.TextAlign = "MiddleLeft"
$actionButton_Edit_Variables.Add_Click({
# Environment Variables Dialog
# C:\Windows\System32\rundll32.exe sysdm.cpl,EditEnvironmentVariables
$StatusMessage = "Opening the Environment Variables Dialog..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
# Launching the app
$LaunchAppName = "Environment Variables Dialog"
$LaunchProcess = "${env:SystemRoot}\System32\rundll32.exe"
$LaunchArguments = "sysdm.cpl,EditEnvironmentVariables"
$WorkingDirectory = "${env:HOMEDRIVE}${env:HOMEPATH}\"
Launch-App -AppName:"$LaunchAppName" -AppExecutable:"$LaunchProcess" -CmdLineArgs:"$LaunchArguments" -WorkingDirectory:"$WorkingDirectory" -SHowUI
})
$form.AcceptButton = $actionButton_Edit_Variables
$form.Controls.Add($actionButton_Edit_Variables)
#-------------------------------------------------------------
# Action = Task_Manager
$actionButton_Task_Manager = New-Object System.Windows.Forms.Button
$actionButton_Task_Manager.Location = New-Object System.Drawing.Point(10,485)
$actionButton_Task_Manager.Size = New-Object System.Drawing.Size(250,23)
$actionButton_Task_Manager.Text = 'Open Task Manager'
$actionButton_Task_Manager.TextAlign = "MiddleLeft"
$actionButton_Task_Manager.Add_Click({
# Task Manager
# C:\Windows\System32\Taskmgr.exe
$StatusMessage = "Opening Task Manager..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
# Launching the app
$LaunchAppName = "Task Manager"
$LaunchProcess = "${env:SystemRoot}\System32\Taskmgr.exe"
$LaunchArguments = ""
$WorkingDirectory = "${env:HOMEDRIVE}${env:HOMEPATH}\"
Launch-App -AppName:"$LaunchAppName" -AppExecutable:"$LaunchProcess" -WorkingDirectory:"$WorkingDirectory" -Elevate -SHowUI
})
$form.AcceptButton = $actionButton_Task_Manager
$form.Controls.Add($actionButton_Task_Manager)
#-------------------------------------------------------------
# Action = Map_Drive
$actionButton_Map_Drive = New-Object System.Windows.Forms.Button
$actionButton_Map_Drive.Location = New-Object System.Drawing.Point(270,485)
$actionButton_Map_Drive.Size = New-Object System.Drawing.Size(250,23)
$actionButton_Map_Drive.Text = 'Open Map Network Drive Dialog'
$actionButton_Map_Drive.TextAlign = "MiddleLeft"
$actionButton_Map_Drive.Add_Click({
# Map Network Drive Dialog
# C:\Windows\System32\rundll32.exe SHELL32.DLL,SHHelpShortcuts_RunDLL Connect
$StatusMessage = "Opening the Map Network Drive Dialog..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
# Launching the app
$LaunchAppName = "Map Network Drive Dialog"
$LaunchProcess = "${env:SystemRoot}\System32\rundll32.exe"
$LaunchArguments = "SHELL32.DLL,SHHelpShortcuts_RunDLL Connect"
$WorkingDirectory = "${env:HOMEDRIVE}${env:HOMEPATH}\"
Launch-App -AppName:"$LaunchAppName" -AppExecutable:"$LaunchProcess" -CmdLineArgs:"$LaunchArguments" -WorkingDirectory:"$WorkingDirectory" -SHowUI
})
$form.AcceptButton = $actionButton_Map_Drive
$form.Controls.Add($actionButton_Map_Drive)
#-------------------------------------------------------------
# Action = ODBC_32bit
$actionButton_ODBC_32bit = New-Object System.Windows.Forms.Button
$actionButton_ODBC_32bit.Location = New-Object System.Drawing.Point(10,515)
$actionButton_ODBC_32bit.Size = New-Object System.Drawing.Size(250,23)
$actionButton_ODBC_32bit.Text = 'Open 32-bit ODBC Data Source Administrator'
$actionButton_ODBC_32bit.TextAlign = "MiddleLeft"
$actionButton_ODBC_32bit.Add_Click({
# 32-bit ODBC Data Source Administrator
# C:\Windows\SysWOW64\odbcad32.exe
$StatusMessage = "Opening the 32-bit ODBC Data Source Administrator..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
# Launching the app
$LaunchAppName = "32-bit ODBC Data Source Administrator"
$LaunchProcess = "${env:SystemRoot}\SysWOW64\odbcad32.exe"
$LaunchArguments = ""
$WorkingDirectory = "${env:HOMEDRIVE}${env:HOMEPATH}\"
Launch-App -AppName:"$LaunchAppName" -AppExecutable:"$LaunchProcess" -CmdLineArgs:"$LaunchArguments" -WorkingDirectory:"$WorkingDirectory" -Elevate -SHowUI
})
$form.AcceptButton = $actionButton_ODBC_32bit
$form.Controls.Add($actionButton_ODBC_32bit)
#-------------------------------------------------------------
# Action = ODBC_64bit
$actionButton_ODBC_64bit = New-Object System.Windows.Forms.Button
$actionButton_ODBC_64bit.Location = New-Object System.Drawing.Point(270,515)
$actionButton_ODBC_64bit.Size = New-Object System.Drawing.Size(250,23)
$actionButton_ODBC_64bit.Text = 'Open 64-bit ODBC Data Source Administrator'
$actionButton_ODBC_64bit.TextAlign = "MiddleLeft"
$actionButton_ODBC_64bit.Add_Click({
# 64-bit ODBC Data Source Administrator
# C:\Windows\System32\odbcad32.exe
$StatusMessage = "Opening the 64-bit ODBC Data Source Administrator..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
# Launching the app
$LaunchAppName = "64-bit ODBC Data Source Administrator"
$LaunchProcess = "${env:SystemRoot}\System32\odbcad32.exe"
$LaunchArguments = ""
$WorkingDirectory = "${env:HOMEDRIVE}${env:HOMEPATH}\"
Launch-App -AppName:"$LaunchAppName" -AppExecutable:"$LaunchProcess" -CmdLineArgs:"$LaunchArguments" -WorkingDirectory:"$WorkingDirectory" -Elevate -SHowUI
})
$form.AcceptButton = $actionButton_ODBC_64bit
$form.Controls.Add($actionButton_ODBC_64bit)
#-------------------------------------------------------------
# Action = NVIDIA_CP
$actionButton_NVIDIA_CP = New-Object System.Windows.Forms.Button
$actionButton_NVIDIA_CP.Location = New-Object System.Drawing.Point(10,545)
$actionButton_NVIDIA_CP.Size = New-Object System.Drawing.Size(250,23)
$actionButton_NVIDIA_CP.Text = 'Open NVIDIA Control Panel'
$actionButton_NVIDIA_CP.TextAlign = "MiddleLeft"
$Disable_nvcplui = $True
If ($null -ne "$nvcplui") {
If (![String]::IsNullOrEmpty($nvcplui.Commandline)) {
If (Test-Path "$($nvcplui.Commandline)") {
$actionButton_NVIDIA_CP.Enabled = $True
$Disable_nvcplui = $False
}
}
}
If ($Disable_nvcplui) {
$actionButton_NVIDIA_CP.Enabled = $False
$StatusMessage = "Disabling NVIDIA Control Panel button..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$StatusMessage = "- `"nvcplui.exe`" was not found on this computer."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
}
$actionButton_NVIDIA_CP.Add_Click({
$StatusMessage = "Opening NVIDIA Control Panel..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
# Launching the app
$LaunchAppName = "NVIDIA Control Panel"
$LaunchProcess = $nvcplui.Commandline
$LaunchArguments = $nvcplui.Arguments
$WorkingDirectory = "${env:HOMEDRIVE}${env:HOMEPATH}\"
Launch-App -AppName:"$LaunchAppName" -AppExecutable:"$LaunchProcess" -CmdLineArgs:"$LaunchArguments" -WorkingDirectory:"$WorkingDirectory" -SHowUI
})
$form.AcceptButton = $actionButton_NVIDIA_CP
$form.Controls.Add($actionButton_NVIDIA_CP)
#-------------------------------------------------------------
# Action = NVIDIA_Utilization
$actionButton_NVIDIA_Utilization = New-Object System.Windows.Forms.Button
$actionButton_NVIDIA_Utilization.Location = New-Object System.Drawing.Point(270,545)
$actionButton_NVIDIA_Utilization.Size = New-Object System.Drawing.Size(250,23)
$actionButton_NVIDIA_Utilization.Text = 'Open NVIDIA GPU Utilization Tool'
$actionButton_NVIDIA_Utilization.TextAlign = "MiddleLeft"
$Disable_NvGpuUtilization = $True
If ($null -ne "$NvGpuUtilization") {
If (![String]::IsNullOrEmpty($NvGpuUtilization.Commandline)) {
If (Test-Path "$($NvGpuUtilization.Commandline)") {
$actionButton_NVIDIA_Utilization.Enabled = $True
$Disable_NvGpuUtilization = $False
}
}
}
If ($Disable_NvGpuUtilization) {
$actionButton_NVIDIA_Utilization.Enabled = $False
$StatusMessage = "Disabling NVIDIA GPU Utilization Tool button..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$StatusMessage = "- `"NvGpuUtilization.exe`" was not found on this computer."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
}
$actionButton_NVIDIA_Utilization.Add_Click({
$StatusMessage = "Opening NVIDIA GPU Utilization Tool..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
# Launching the app
$LaunchAppName = "NVIDIA GPU Utilization Tool"
$LaunchProcess = $NvGpuUtilization.Commandline
$LaunchArguments = $NvGpuUtilization.Arguments
$WorkingDirectory = "${env:HOMEDRIVE}${env:HOMEPATH}\"
Launch-App -AppName:"$LaunchAppName" -AppExecutable:"$LaunchProcess" -CmdLineArgs:"$LaunchArguments" -WorkingDirectory:"$WorkingDirectory" -SHowUI
})
$form.AcceptButton = $actionButton_NVIDIA_Utilization
$form.Controls.Add($actionButton_NVIDIA_Utilization)
#-------------------------------------------------------------
# Action = GPU_Profiler
$actionButton_GPU_Profiler = New-Object System.Windows.Forms.Button
$actionButton_GPU_Profiler.Location = New-Object System.Drawing.Point(10,575)
$actionButton_GPU_Profiler.Size = New-Object System.Drawing.Size(250,23)
$actionButton_GPU_Profiler.Text = 'Open GPU Profiler Tool'
$actionButton_GPU_Profiler.TextAlign = "MiddleLeft"
If (Test-Path "$GPUProfiler") {
If ($Advanced -eq $False) {
$actionButton_GPU_Profiler.Enabled = $False
} Else {
$actionButton_GPU_Profiler.Enabled = $True
}
} Else {
$actionButton_GPU_Profiler.Enabled = $False
$StatusMessage = "Disabling GPU Profiler Tool button..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$StatusMessage = "- `"$GPUProfiler`" was not found on this computer."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
}
$actionButton_GPU_Profiler.Add_Click({
$StatusMessage = "Opening GPU Profiler Tool..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
# Launching the app
$LaunchAppName = "GPU Profiler Tool"
$LaunchProcess = $GPUProfiler
$LaunchArguments = ""
$WorkingDirectory = "${env:HOMEDRIVE}${env:HOMEPATH}\"
Launch-App -AppName:"$LaunchAppName" -AppExecutable:"$LaunchProcess" -CmdLineArgs:"$LaunchArguments" -WorkingDirectory:"$WorkingDirectory" -SHowUI
})
$form.AcceptButton = $actionButton_GPU_Profiler
$form.Controls.Add($actionButton_GPU_Profiler)
#-------------------------------------------------------------
# Action = Enumerate_Installed_Versions_Of_Vulcan
$VulcanInstalled = $False
$VULCAN_Version_Installed = @()
# Set the selected item for the display
$index_Start_Vulcan = 0
# Process all the installed versions of Vulcan into a list
$InstallDetails = (GetVulcanInstalledVersions)
If ($null -ne $InstallDetails) {
$VulcanInstalled = $True
$DefaultVersionFound = $False
$i = 0
ForEach($Install in $InstallDetails) {
$ProductName = ($Install.ProductName ).ToString()
$ProductVersion = ($Install.ProductVersion).ToString()
$InstallationDirectory = ($Install.InstallationDirectory).ToString()
#$ProductName
#$ProductVersion
#$InstallationDirectory
$AddToArray = $True
if ($ProductName -Like "*$VulcanDefaultVersion*") {
$DefaultVersionFound = $True
$index_Start_Vulcan = $i
}
# It's important to note that if you set the VulcanDefaultVersion variable incorrectly and also include the
# DisplayDefaultVersionOnly switch, the array will not be built and the UI will display "Not found". This
# is how the script works, but can be confusing.
If ($DisplayDefaultVersionOnly -AND $ProductName -NotLike "*$VulcanDefaultVersion*") {
$AddToArray = $False
}
If ($AddToArray) {
$VULCAN_Version_Installed += [pscustomobject]@{name=$ProductName;description=$ProductVersion;location=$InstallationDirectory}
$i ++
}
}
If ($DefaultVersionFound -eq $False -AND $i -eq 0) {
$VulcanInstalled = $False
$VULCAN_Version_Installed += [pscustomobject]@{name="Not found";description="Not found";location="Not found"}
$StatusMessage = "Vulcan $VulcanDefaultVersion is not installed on this computer."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
}
} Else {
$VULCAN_Version_Installed += [pscustomobject]@{name="Not found";description="Not found";location="Not found"}
$StatusMessage = "Vulcan is not installed on this computer."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
}
#-------------------------------------------------------------
# Actione = Select_Vulcan_Version
$actionlabel_Start_Vulcan = New-Object System.Windows.Forms.Label
$actionlabel_Start_Vulcan.Font = 'Microsoft Sans Serif, 9pt'
$actionlabel_Start_Vulcan.Location = New-Object System.Drawing.Point(10,605)
$actionlabel_Start_Vulcan.Name = 'action1label'
$actionlabel_Start_Vulcan.Size = New-Object System.Drawing.Size(495,23)
$actionlabel_Start_Vulcan.UseMnemonic = $false
$actionlabel_Start_Vulcan.Text = "Select a version of Vulcan to start"
$form.Controls.Add($actionlabel_Start_Vulcan)
$DropDown_Start_Vulcan = new-object System.Windows.Forms.ComboBox
$DropDown_Start_Vulcan.Location = new-object System.Drawing.Point(25,630)
$DropDown_Start_Vulcan.Size = new-object System.Drawing.Size(235,40)
$DropDown_Start_Vulcan.DropDownStyle = [System.Windows.Forms.ComboBoxStyle]::DropDownList
# Load the values into the combo box
Load-ComboBox $DropDown_Start_Vulcan $VULCAN_Version_Installed -DisplayMember name -ValueMember description
$DropDown_Start_Vulcan.SelectedIndex = $index_Start_Vulcan
$Form.Controls.Add($DropDown_Start_Vulcan)
$DropDown_Start_Vulcan.Add_SelectedIndexChanged({
# Inside here you can refer to the ComboBox object as $this
$StatusMessage = "Selection has changed to $($this.SelectedItem.name)"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
})
#-------------------------------------------------------------
# Action = Set_Vulcan_Paths_Button
$actionButton_Set_Vulcan_Paths = New-Object System.Windows.Forms.Button
$actionButton_Set_Vulcan_Paths.Location = New-Object System.Drawing.Point(270,630)
$actionButton_Set_Vulcan_Paths.Size = New-Object System.Drawing.Size(250,23)
$actionButton_Set_Vulcan_Paths.Text = 'Set Vulcan paths and variables to this version'
$actionButton_Set_Vulcan_Paths.TextAlign = "MiddleLeft"
$actionButton_Set_Vulcan_Paths.Add_Click({
$UseProductName = $DropDown_Start_Vulcan.SelectedItem.name
If ($UseProductName -ne "Not found") {
$UseInstallationDirectory = $($DropDown_Start_Vulcan.SelectedItem.location).TrimEnd('\')
Set-Vulcan-Paths -UseInstallationDirectory:"$UseInstallationDirectory" -SetUserVariableTarget:$True
# Refresh environment variables
EnvironmentRefresh
} Else {
write-verbose "Vulcan is not installed on this computer." -verbose
}
})
$form.AcceptButton = $actionButton_Set_Vulcan_Paths
$form.Controls.Add($actionButton_Set_Vulcan_Paths)
#-------------------------------------------------------------
# Action = Set_Vulcan_Paths_CheckBox
$checkBox_Set_Vulcan_Paths = New-Object System.Windows.Forms.CheckBox
$checkBox_Set_Vulcan_Paths.Location = New-Object System.Drawing.Point(25,660)
$checkBox_Set_Vulcan_Paths.Size = New-Object System.Drawing.Size(495,23)
$checkBox_Set_Vulcan_Paths.Text = "Set Vulcan paths and variables to this version when starting Vulcan"
$checkBox_Set_Vulcan_Paths.Checked = $True
$form.Controls.Add($checkBox_Set_Vulcan_Paths)
#-------------------------------------------------------------
# Action = RAM_DISK_TEMP_TMP
$GroupBox1 = New-Object System.Windows.Forms.GroupBox
$GroupBox1.Location = '25,690'
$GroupBox1.size = '495,120'
$GroupBox1.text = 'Change the TEMP && TMP variables before starting Vulcan'
$RadioButton1GroupBox1 = New-Object System.Windows.Forms.RadioButton
$RadioButton1GroupBox1.Location = '10,20'
$RadioButton1GroupBox1.size = '170,20'
$RadioButton1GroupBox1.Checked = $true
$RadioButton1GroupBox1.Text = "Use the detected RAM disk - "
$DropDown_RAM_DISK = new-object System.Windows.Forms.ComboBox
$DropDown_RAM_DISK.Location = new-object System.Drawing.Point(180,20)
$DropDown_RAM_DISK.Size = new-object System.Drawing.Size(310,20)
$DropDown_RAM_DISK.DropDownStyle = [System.Windows.Forms.ComboBoxStyle]::DropDownList
$userProfileChildFolder = Get-UserProfileChildFolder
$PathToSet = "${env:LOCALAPPDATA}"
$FSLogixLocalProfile = Get-FSLogixLocalProfilePath
If ($FSLogixLocalProfile.LocalProfilePathFound) {
$userProfileChildFolder = $FSLogixLocalProfile.FolderName
$PathToSet = $FSLogixLocalProfile.FullPath
}
# Load the values into the combo box
If ($RAMDiskFound) {
Load-ComboBox $DropDown_RAM_DISK $RAMDISKS -DisplayMember name -ValueMember description
# Set the selected item for the display
$index_RAM_DISK = 0
for($i=0;$i-le $RAMDISKS.length-1;$i++) {
if ($RAMDISKS[$i].description -eq $PreferredRAMDisk) {
$index_RAM_DISK = $i
}
}
$DropDown_RAM_DISK.SelectedIndex = $index_RAM_DISK
$RAMDiskLetter = $DropDown_RAM_DISK.SelectedItem.description
$PathToSet = "${RAMDiskLetter}:\${userProfileChildFolder}"
} Else {
$RAMDISKS = @([pscustomobject]@{name="Not found";description="Not found"})
Load-ComboBox $DropDown_RAM_DISK $RAMDISKS -DisplayMember name -ValueMember description
$DropDown_RAM_DISK.SelectedIndex = 0
}
$Label1GroupBox1 = New-Object System.Windows.Forms.Label
$Label1GroupBox1.Font = 'Microsoft Sans Serif, 9pt'
$Label1GroupBox1.Location = New-Object System.Drawing.Point(25,45)
$Label1GroupBox1.Name = 'Label1GroupBox1'
$Label1GroupBox1.Size = New-Object System.Drawing.Size(465,23)
$Label1GroupBox1.UseMnemonic = $false
$Label1GroupBox1.Text = "The TEMP & TMP variables will be set to:"
$textBoxGroupBox1 = New-Object System.Windows.Forms.TextBox
$textBoxGroupBox1.Location = New-Object System.Drawing.Point(25,70)
$textBoxGroupBox1.Size = New-Object System.Drawing.Size(465,40)
$textBoxGroupBox1.ReadOnly = $True
$textBoxGroupBox1.Text = "${PathToSet}\Temp"
$RadioButton2GroupBox1 = New-Object System.Windows.Forms.RadioButton
$RadioButton2GroupBox1.Location = '10,95'
$RadioButton2GroupBox1.size = '400,20'
$RadioButton2GroupBox1.Checked = $False
$RadioButton2GroupBox1.Text = "A RAM disk is not required."
$GroupBox1.Controls.AddRange(@($RadioButton1GroupBox1,$DropDown_RAM_DISK,$Label1GroupBox1,$textBoxGroupBox1,$RadioButton2GroupBox1))
$form.Controls.Add($GroupBox1)
If ($RAMDiskFound -eq $False) {
$RadioButton1GroupBox1.Checked = $False
$RadioButton2GroupBox1.Checked = $True
$RadioButton2GroupBox1.Text = "A RAM disk was not found."
$GroupBox1.Enabled = $False
$StatusMessage = "- Disabling the change TEMP & TMP variables..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
}
$DropDown_RAM_DISK.Add_SelectedIndexChanged({
# Inside here you can refer to the ComboBox object as $this
$RAMDiskLetter = $this.SelectedItem.description
$PathToSet = "${RAMDiskLetter}:\${userProfileChildFolder}"
$textBoxGroupBox1.Text = "${PathToSet}\Temp"
})
$RadioButton1GroupBox1.Add_Click({
$DropDown_RAM_DISK.Enabled = $True
$RAMDiskLetter = $DropDown_RAM_DISK.SelectedItem.description
$PathToSet = "${RAMDiskLetter}:\${userProfileChildFolder}"
$textBoxGroupBox1.Text = "${PathToSet}\Temp"
})
$RadioButton2GroupBox1.Add_Click({
$DropDown_RAM_DISK.Enabled = $False
$PathToSet = "${env:LOCALAPPDATA}"
$FSLogixLocalProfile = Get-FSLogixLocalProfilePath
If ($FSLogixLocalProfile.LocalProfilePathFound) {
$PathToSet = $FSLogixLocalProfile.FullPath
}
$textBoxGroupBox1.Text = "${PathToSet}\Temp"
})
#-------------------------------------------------------------
# Action = Start_Vulcan
$actionButton_Start_Vulcan = New-Object System.Windows.Forms.Button
$actionButton_Start_Vulcan.Location = New-Object System.Drawing.Point(205,815)
$actionButton_Start_Vulcan.Size = New-Object System.Drawing.Size(80,23)
$actionButton_Start_Vulcan.Text = 'Start Vulcan'
#$actionButton_Start_Vulcan.TextAlign = "MiddleLeft"
$actionButton_Start_Vulcan.Add_Click({
$UseProductName = $DropDown_Start_Vulcan.SelectedItem.name
If ($UseProductName -ne "Not found") {
$UseProductVersion = $DropDown_Start_Vulcan.SelectedItem.description
$UseInstallationDirectory = $($DropDown_Start_Vulcan.SelectedItem.location).TrimEnd('\')
$PerformEnvRefresh = $False
If ($checkBox_Set_Vulcan_Paths.Checked) {
Set-Vulcan-Paths -UseInstallationDirectory:"$UseInstallationDirectory" -SetUserVariableTarget:$False
$PerformEnvRefresh = $True
}
# Set TEMP and TMP variables
$CurrentTemp = [System.IO.Path]::GetTempPath().TrimEnd('\')
$DefaultTemp = "${env:LOCALAPPDATA}\Temp"
$NewTemp = "$($textBoxGroupBox1.Text)"
If ($CurrentTemp -ne $NewTemp) {
Set-MyVariable -Action:"Set" -Name:"TEMP" -Value:"$NewTemp" -SetUserVariableTarget:$False -SHowUI
Set-MyVariable -Action:"Set" -Name:"TMP" -Value:"$NewTemp" -SetUserVariableTarget:$False -SHowUI
$PerformEnvRefresh = $True
If ($NewTemp -ne $DefaultTemp) {
Create-Folder -Name:"$NewTemp" -SHowUI
}
}
If ($PerformEnvRefresh) {
# Refresh environment variables
EnvironmentRefresh
}
# This will work with Vulcan 10 and above that use the WorkbenchLauncher.exe to start Vulcan.
$WorkbenchLauncher = "${env:CommonProgramFiles}\Maptek\Workbench\WorkbenchLauncher.exe"
$MyArgs = "/packageversion Maptek.Vulcan $UseProductVersion /drop_catcher"
$StatusMessage = "Starting $UseProductName with command line arguments..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$StatusMessage = "$MyArgs"
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
# Launching the app
$LaunchAppName = "$UseProductName"
$LaunchProcess = $WorkbenchLauncher
$LaunchArguments = $MyArgs
$WorkingDirectory = "${env:HOMEDRIVE}${env:HOMEPATH}\"
Launch-App -AppName:"$LaunchAppName" -AppExecutable:"$LaunchProcess" -CmdLineArgs:"$LaunchArguments" -WorkingDirectory:"$WorkingDirectory" -SHowUI
} Else {
write-verbose "Vulcan is not installed on this computer." -verbose
}
})
$form.AcceptButton = $actionButton_Start_Vulcan
$form.Controls.Add($actionButton_Start_Vulcan)
If ($UseRAMDisk -eq $False) {
$RadioButton1GroupBox1.Checked = $False
$RadioButton2GroupBox1.Checked = $True
$PathToSet = "${env:LOCALAPPDATA}"
$FSLogixLocalProfile = Get-FSLogixLocalProfilePath
If ($FSLogixLocalProfile.LocalProfilePathFound) {
$PathToSet = $FSLogixLocalProfile.FullPath
}
$textBoxGroupBox1.Text = "${PathToSet}\Temp"
}
If ($VulcanInstalled -eq $False) {
$RadioButton1GroupBox1.Checked = $False
$RadioButton2GroupBox1.Checked = $True
$PathToSet = "${env:LOCALAPPDATA}"
$FSLogixLocalProfile = Get-FSLogixLocalProfilePath
If ($FSLogixLocalProfile.LocalProfilePathFound) {
$PathToSet = $FSLogixLocalProfile.FullPath
}
$textBoxGroupBox1.Text = "${PathToSet}\Temp"
$DropDown_Start_Vulcan.Enabled = $False
$actionButton_Start_Vulcan.Enabled = $False
$actionButton_Set_Vulcan_Paths.Enabled = $False
$checkBox_Set_Vulcan_Paths.Enabled = $False
$StatusMessage = "- Disabling the Vulcan version drop down list..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$StatusMessage = "- Disabling the set Vulcan paths and variables button and checkbox..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$GroupBox1.Enabled = $False
$StatusMessage = "- Disabling the change TEMP & TMP variables..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$StatusMessage = "- Disabling the start Vulcan button..."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
}
If ($DisableChangeTEMP) {
$RadioButton1GroupBox1.Checked = $False
$RadioButton2GroupBox1.Checked = $True
$PathToSet = "${env:LOCALAPPDATA}"
$FSLogixLocalProfile = Get-FSLogixLocalProfilePath
If ($FSLogixLocalProfile.LocalProfilePathFound) {
$PathToSet = $FSLogixLocalProfile.FullPath
}
$textBoxGroupBox1.Text = "${PathToSet}\Temp"
$RadioButton2GroupBox1.Text = "The ability to change the TEMP && TMP variables has been disabled."
$GroupBox1.Enabled = $False
}
#-------------------------------------------------------------
# Enable and start the timer
$GuiTimer.Enabled = $true
$GuiTimer.Start()
$timeinstringformat = (Get-Date).AddMinutes($CloseAfterInMinutes).ToShortTimeString()
$StatusMessage = "This form will automatically close $($CloseAfterInMinutes) minutes from now at $timeinstringformat."
$status1TextBox.AppendText("$StatusMessage `r`n")
$status1TextBox.ScrollToCaret()
write-verbose "$StatusMessage" -verbose
$form.Topmost = $true
$form.ShowDialog() | out-null #This starts the GUI
}
#------------------------------------
# Call the function to return all available RAM Disks
$RamDiskResults = (Get-RamDisks)
$RAMDiskFound = $RamDiskResults.RAMDiskFound
$RAMDISKS = $RamDiskResults.RAMDISKS
$PreferredRAMDisk = $RamDiskResults.PreferredRAMDisk
#------------------------------------
If (![String]::IsNullOrEmpty($DevelopedBy)) {
$Release = "$Release developed by $DevelopedBy"
}
Call-MainForm -ToolRelease:"$Release" -BusinessUnit:"$BusinessUnit" -VulcanDefaultVersion:"$VulcanDefaultVersion" -CloseAfterInMinutes:30 -DisplayDefaultVersionOnly -RAMDiskFound:$RAMDiskFound -RAMDISKS:$RAMDISKS -PreferredRAMDisk:"$PreferredRAMDisk" -DisableChangeTEMP:$DisableChangeTEMP -UseRAMDisk:$UseRAMDisk -RemoveRedundantVariables:$RemoveRedundantVariables
#------------------------------------
$EndDTM = (Get-Date)
Write-verbose "Elapsed Time: $(($EndDTM-$StartDTM).TotalSeconds) Seconds" -Verbose
Write-Verbose "Elapsed Time: $(($EndDTM-$StartDTM).TotalMinutes) Minutes" -Verbose
try {
Stop-Transcript
}
catch {
Write-Verbose "$(Get-Date): This host does not support transcription"
}
This is more of the cool stuff I build and implement to reduce operational issues and provide an improved user experience. I put a lot of personal time and research into this and feel it’s important to share for the wider community to use.
Enjoy!
Jeremy Saunders
Technical Architect | DevOps Evangelist | Software Developer | Microsoft, NVIDIA, Citrix and Desktop Virtualisation (VDI) Specialist/Expert | Rapper | Improvisor | Comedian | Property Investor | Kayaking enthusiast at J House Consulting
Jeremy Saunders is the Problem Terminator. He is a highly respected IT Professional with over 35 years’ experience in the industry. Using his exceptional design and problem solving skills with precise methodologies applied at both technical and business levels he is always focused on achieving the best business outcomes. He worked as an independent consultant until September 2017, when he took up a full time role at BHP, one of the largest and most innovative global mining companies. With a diverse skill set, high ethical standards, and attention to detail, coupled with a friendly nature and great sense of humour, Jeremy aligns to industry and vendor best practices, which puts him amongst the leaders of his field. He is intensely passionate about solving technology problems for his organisation, their customers and the tech community, to improve the user experience, reliability and operational support. Views and IP shared on this site belong to Jeremy.
Latest posts by Jeremy Saunders (see all)
- The Maptek User Support Tool to Help Manage Vulcan Support Challenges - April 2, 2025
- Microsoft High Performance Computing (HPC) Pack 2019 Service Resilience - February 19, 2025
- Development Planning for the Citrix Self-Service Session Reset Tool - February 19, 2025