LabVIEW
Prevent restoring minimized Labview windows when opening another vi file
@Novgorod wrote:
@Andrey_Dmitriev wrote:
Well, hopefully NI will fix it. But to be honest, not many users open VIs directly from Explorer; usually, they are organized in projects and libraries
I'd argue the exact opposite. Most users in the science and engineering field aren't professional software devs who work on neatly organized huge projects...
By the way, I was completely wrong when I described the “double-click” mechanism. It’s not based on Windows messages, of course. Sorry for forgetting such a basic detail. I’m still learning.
We can «fix it», but I should first explain how it works. There’s no rocket science here.
The *.VI file type is registered in Windows under the Registry key HKEY_CLASSES_ROOT\.VI
It’s important to understand that these two keys are updated every time LabVIEW starts. If you work with multiple LabVIEW versions, the most recently used version will always be launched-this is how LabVIEW “remembers” which version was last used.
I rarely use double-click myself, but when I do, it’s annoying that the “wrong” LabVIEW version is launched sometimes.
Additionally, when LabVIEW is already running, then I’ve seen with Spy++ that, in this case, all open LabVIEW windows receive a WM_ACTIVATEAPP message. From that point, I’m not sure if this is really a LabVIEW issue.
Anyway, let’s take everything into our own hands. The idea is simple: I’ll replace the «default» LabVIEW launcher with my own. This will also help me in the future to launch the correct LabVIEW version according to the VI’s saved version.
First, we’ll change the HKEY_CLASSES_ROOT\.VI
rust#![windows_subsystem = "windows"]
use std::thread;
use std::time::Duration;
use winreg::RegKey;
use winreg::enums::*;
fn main() {
loop {
// Open HKEY_CLASSES_ROOT\.VI with write access
let hkcr = RegKey::predef(HKEY_CLASSES_ROOT);
match hkcr.open_subkey_with_flags(".VI", KEY_SET_VALUE) {
Ok(subkey) => {
// Set the (Default) value to "LabVIEWHelper"
if let Err(_e) = subkey.set_value("", &"LabVIEWHelper") {
// Handle error (optional: log or ignore)
}
}
Err(_e) => {
// Handle error (optional: log or ignore)
}
}
// Sleep for 5 seconds
thread::sleep(Duration::from_secs(5));
}
}cargo.toml:
text[package]
name = "lv_helper_reg"
version = "0.1.0"
edition = "2024"
[dependencies]
winreg = "0.55.0"
windows = "0.61.1"
textWindows Registry Editor Version 5.00
[HKEY_CLASSES_ROOT\LabVIEWHelper]
@="LabVIEW Instrument"
[HKEY_CLASSES_ROOT\LabVIEWHelper\DefaultIcon]
@="C:\\Program Files\\National Instruments\\LabVIEW 2024\\LabVIEW.exe,-2"
[HKEY_CLASSES_ROOT\LabVIEWHelper\shell]
@="Open"
[HKEY_CLASSES_ROOT\LabVIEWHelper\shell\open]
@="&Open"
[HKEY_CLASSES_ROOT\LabVIEWHelper\shell\open\command]
@="\"C:\\Program Files\\National Instruments\\LabVIEW 2024\\lv_helper_2024x64.exe\" \"%1\""
[HKEY_CLASSES_ROOT\LabVIEWHelper\shell\open\ddeexec]
@="\"C:\\Program Files\\National Instruments\\LabVIEW 2024\\lv_helper_2024x64.exe\" \"%1\""
[HKEY_CLASSES_ROOT\LabVIEWHelper\shell\open\ddeexec\application]
@=" "
[HKEY_CLASSES_ROOT\LabVIEWHelper\shell\open\ddeexec\ifexec]
@=" "The helper application code is straightforward:
rust#![windows_subsystem = "windows"] // prevent console window
use std::env;
use std::process::{Command, exit};
fn main() {
let args: Vec<String> = env::args().collect();
if args.len() != 2 {
eprintln!("Usage: {} <file>", args[0]);
exit(1);
}
let file_arg = &args[1];
// Start LabVIEW.exe and immediately return without waiting
if let Err(e) =
Command::new("C:\\Program Files\\National Instruments\\LabVIEW 2024\\LabVIEW.exe")
.arg(file_arg)
.spawn()
{
eprintln!("Failed to start LabVIEW.exe: {}", e);
exit(1);
}
}Now, instead of LabVIEW, my own application will be launched in the background:
this will launch LabVIEW, resolving the issue:
[allowmultipleinstances=TRUE] (which is OFF by default), this will launch a separate instance for each VI.
lv_helper_reg.exe and lv_helper_2024x64.exe
Now I've achieved what I wanted, with the help of a LabVIEW-written DLL
an and the following Rust code:
#![windows_subsystem = "windows"]
use libloading::{Library, Symbol};
use std::env;
use std::ffi::CStr;
use std::os::raw::{c_char, c_int, c_short, c_uint};
use std::process::{Command, exit};
fn main() {
let args: Vec<String> = env::args().collect();
if args.len() != 2 {
eprintln!("Usage: {} <file>", args[0]);
exit(1);
}
let file_arg = &args[1];
let dll_path = "get_vi_version.dll";
// Path to your VI file
// Get the path to the VI file from command line arguments
let vi_path = &args[1];
// Check if the path is valid
if !std::path::Path::new(vi_path).exists() {
eprintln!("The specified VI file does not exist: {}", vi_path);
exit(1);
}
// Prepare input and output buffers
let mut vi_path_buf = [0u8; 260]; // adjust size if needed
let vi_path_bytes = vi_path.as_bytes();
vi_path_buf[..vi_path_bytes.len()].copy_from_slice(vi_path_bytes);
let mut code: c_int = 0;
let mut status: c_short = 0;
let mut version_number: c_uint = 0;
let mut version_string = [0u8; 64]; // adjust size if needed
unsafe {
// Load the DLL
let lib = Library::new(dll_path).expect("Could not load DLL");
// Define the function signature
type GetViVersionFn = unsafe extern "C" fn(
vi_path: *mut c_char,
code: *mut c_int,
status: *mut c_short,
version_number: *mut c_uint,
version_string: *mut c_char,
len: c_int,
);
// Get the function
let func: Symbol<GetViVersionFn> =
lib.get(b"Get_vi_version").expect("Could not find function");
// Call the function
func(
vi_path_buf.as_mut_ptr() as *mut c_char,
&mut code,
&mut status,
&mut version_number,
version_string.as_mut_ptr() as *mut c_char,
version_string.len() as c_int,
);
// Convert version_string to Rust String
let c_str = CStr::from_ptr(version_string.as_ptr() as *const c_char);
let version_str = c_str.to_string_lossy();
println!("Code: {}", code);
println!("Status: {}", status);
println!("Version Number: {}", version_number);
println!("Version String: {}", version_str);
// Extract the version number from the version string
let version_year: u32 = version_str
.split('.')
.next()
.and_then(|v| v.parse::<u32>().ok())
.unwrap_or_else(|| {
eprintln!(
"Failed to parse version number from version string: {}",
version_str
);
exit(1);
});
// Determine the LabVIEW version year based on the version number
let labview_year = if version_year == 24 {
"2024"
} else if version_year == 25 {
"2025"
} else {
eprintln!("Unsupported LabVIEW version: {}", version_year);
exit(1);
};
// Start LabVIEW.exe and immediately return without waiting
let labview_exe_path = format!(
"C:\\Program Files\\National Instruments\\LabVIEW {}\\LabVIEW.exe",
labview_year
);
if let Err(e) = Command::new(labview_exe_path).arg(file_arg).spawn() {
eprintln!("Failed to start LabVIEW.exe: {}", e);
exit(1);
}
} // Close the unsafe block
} // Close the main function
Not only this issue above fixed, but the launcher now automatically starts the correct LabVIEW version according to the VI's version-2024 for VIs saved in 2024, and 2025 for VIs saved in 2025.
No more annoying messages
and no more (or less at least) accidentally saving VIs in a higher version!
Thank you so much for starting this topic! I need to polish this a löittle bit for project and libraries and deal with bitness, but in general it works.
