LabVIEW Idea Exchange

Community Browser
cancel
Showing results for 
Search instead for 
Did you mean: 
Post an idea

It's hard to believe that this is the first post to request something like this (pun intended), but I couldn't find it after a few queries.

 

The base idea would be that both the static and dynamic connectors used to connect the methods to the owning class shall be defaulting to the owner class, a.k.a. this object in text based languages. The main problem is the use case for refactoring. When moving around methods the class controls and indicators have to be replaced every time. It doesn't matter if I'm moving methods between classes or to interfaces it is the same pain: replace the connectors (with QuickDrop), then change the names to class names, then update the icon, finally move the VI to the new location.

 

I know that this could and maybe is already solved with scripting, but I think the development environment shall grant the option to change the control and indicator to this object that will always default to the owning class, without manual updates. Even the labels could be This in and This out, and replaced in real time with the actual class implementation on the block diagram of the calling VIs.

 

The proposed solution would also get rid of the error telling about the dynamic dispatch controls shall reference the owning class, since it would happen automatically.

The new debug window in LabVIEW 2025 Q3 automatically expands arrays to show all elements across multiple lines. While this full view can be helpful, it often becomes disruptive during debugging.

I have attached a video that shows a side-by-side comparison. The left side is LabVIEW 2025 Q3, and the right side is LabVIEW 2024 Q3.

As you can see, when an array contains many elements, the new multi-line display consumes a large amount of vertical space on the block diagram. This pushes other probes and data displays down, causing their positions to shift and making it difficult to monitor them. There are many cases where I only need to see that the array contains data, not every single element, and I would prefer the more compact, single-line view.

I propose adding a feature to allow users to select the display mode for arrays in the debug window. It would be ideal to have a toggle or option to switch between the new multi-line view and the classic single-line view, similar to how it worked in LabVIEW 2024 Q3 and older versions.

This would provide the flexibility to choose the most appropriate view for the situation, greatly improving the debugging workflow and the visibility of other data on the diagram.

If we want a ring of a string type we can use a combo box and if undefined items are not to be allowed it *could* behave as a regular ring (integer type) with no text editing/input, but that is not an option in LabVIEW now. Having such an option would allow us the keep the behaviour of multiple ring controls identical (and hence more intuitive to the users) although their types behind the scene for programmatic convenience are different.

If you want to keep the ring as a string (to not have to deal with it indirectly though the ring/enum string array property, which would be the current workaround...) you are currently forced to accept that the this ring will behave differently than other ring controls or enums:

 

In Microsoft applications the suggested feature is available by setting the style of the combo box to DropDropDownList.

 

It would be nice if the format to string would support arrays.
Something like this:

MikaelH_0-1760513019416.png

 



I'm not sure if someone has requested it yet, but it would be very helpful if I could clear the probe watch window of the last retained values. This way I don't need to look at the timestamps and it will speed up the debugging.

Similar to a Static VI Reference, you could have a static file reference which would function just like a path but would allow non-VI files such as a script to be called by a sysexec call or a python node, etc. to be implicitly included in a build without having to remember to add them as "always included".

(NOTE: This idea is the opposite of this one, so not the same)

 

The properties page of "boolean array to number" should prominently include the sign extension mode so we don't run into this confusion.

 

altenbach_1-1750952300236.png

 

 

altenbach_0-1750952204508.png

 

 

 

Problem: Currently, the native nodes and VIs that can be used for error manipulation are located in the Dialog & User Interface palette. While manipulating errors can mean generating dialogues, and can influence the User Interface/User Experience, error manipulation is a broader and stand-alone topic.

 

Solution: Nodes and VIs that are relevant to error handling/error manipulation should be given their own subpalette inside the Programming palette. The new subpalette could be named "Error Handling", "Error Manipulation" or "Errors".

 

1 (annotated).png

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

2 (annotated).png

For string controls and indicators please add a vertical alignment option. We have applications where we will programmatically change the font size, which requires a string control/indicator to be sized for the largest option. Since there isn't a vertical alignment option, the string is always aligned to the top and it can make the front panel layout look strange.

 

Other applications have long strings that may be a single line or may be a variable number of multiple lines, but we'd like to be able to center the text vertically. Again, this requires the control/indicator to be sized for the largest option, but all the text is always vertically aligned to the top of the front panel object.

Currently, on Windows, File:Save As:Rename does not work when changing only the capitalization of a filename. I would prefer that it did. See this discussion for workarounds.

 

littlesphaeroid_0-1744996386796.png

saving with lowercase:

littlesphaeroid_1-1744996447782.png

Has no affect on the filename in the finder or in LV.

 

Quiztus2_0-1741871908439.png

I couldn't find this explicitly mentioned here, but it seems related to:

 

Block diagram references should be 16 pixels tall (currently 19 pixels) - NI Community

Same Height of Unbundle by Name / Terminal / Local Variable - NI Community 

 

Although making changes like this could hurt legacy code, earlier implementation is preferable. Local variables are already the same size as bundles and property nodes, but constants are not. My suggestion is to increase the size of bundle/unbundle elements by one pixel and decrease the size of constants by two pixels by reducing their border thickness. Since numerics require a type indicator, a 1 px border wouldn't compromise recognition. Numeric constant type visualization - NI Community


I often find my self right-clicking the VI, either in the block diagram where it's used or on the icon at the top-right, but each time I'm reminded that this function does not exist (yet!). It would be really useful when navigating in large projects if you could right-click the VI and find it in the project. Often I want to get to its class to find other VIs that I'm looking for and sometimes to check where the class is used by the rest of the code.

LeifSwe_0-1747299264232.png

 

It would be really nice if you were able to resize properties dialog boxes for controls, indicators, constants, and other nodes on a front panel or block diagram. Sometimes the information entered in a dialog is larger than the allotted space. Fortunately, in those situations, there is usually a tip strip that shows all of the information rather than just the visible portion of the information, such as shown in the enum properties dialog box picture below. To make all information visible, it would be great if properties dialog box windows were resizable and the contents of the tab control pages automatically scaled with the size of the dialog. It would also be nice if pages containing objects with columns (e.g. multi-column listboxes, etc.) allowed the columns to be resized as depicted in the picture below. 

 

Ryan_Wright__2-1731433895037.png

This topic keeps coming up randomly.  A LabVIEW class keeps a mutation history so that it can load older versions of the class.  But how often does this actually need to be done?  I have never needed it.  Many others I have talked with have never needed it.  But it often causes problems as projects and histories get large.  For reference: Slow Editor Performance with Large LabVIEW Projects Containing Many Classes.  The history is also just added bloat to your files (lvclass and any built files that use the lvclass) for something most of us do not need and sometimes causes build errors.

 

My proposal is to add an option to the class properties to keep the mutation history.  It can be enabled by default to keep the current behavior.  But allowing me to uncheck this option and then never have to worry about clearing the history again would be well worth it.

If you e.g. open a project in a newer LV and then close it; it starts recompiling everything with no abort option, and only after having recompiled 2000 VI's i can choose to _not_ save them ...

I just opened it to check a few things and ended up with Kill Process to get out of it.

 

Let us cancel/abort the recompile when shutting down.

I want an event to trigger when the user switches from linear to logarithmic mapping for a control. 

Screenshot 2025-04-01 124800.png

None of these currently existing events trigger for this scale change

Screenshot 2025-04-01 125545.png

Related forum discussions:

https://forums.ni.com/t5/LabVIEW/Can-I-detect-a-plot-name-change-event-in-a-plot-legend/td-p/2741164

https://forums.ni.com/t5/LabVIEW/XY-Plot-Scale-Legend-Mapping-Mode-Changed-Event/m-p/4226689

 

Control and indicator references are currently 19 pixels tall. They should be 16 pixels tall. References would then align better with other items which are already 16 pixels tall, such as the Bundle By Name and Unbundle By Name nodes.

 

1 (edited).png

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

This idea is inspired by this idea and this idea.

It'd be quite helpful if you could have several search result windows (or tabs) since it's not that uncommon that you e.g. search for some text and want to keep that list of VIs while searching for something else. Especially when the projects get into several thousand VIs it takes a while to do the search, thus i prefer to not do it again ...

For anyone that has used CAD software, you know how much of a timesaver this feature is. It is very similar to quick drop but relies more on graphical selection than keyboard input (although, these shortcuts often allow text entry as well and have a configurable menu).

 

For example, pressing the "S" key in SolidWorks pops up a contextual, configurable menu at the current cursor position that allows you to rapidly click on common operations as well as customized shortcuts.

 

I have my own janky extension to quickdrop that makes a graphical menu present after pressing multiple buttons (ctrl+space, ctrl+q, then one of WASD or a mouse click on the popup .vi front panel), but it would be nice if I didn't have to go through multiple shortcut selections to hit my toolbar-of-target. Said another way, a more extensible quickdrop-like shortcut bar would be nice. Something like the right click and shortcut keypresses for Autodesk Fusion and Solidworks are the inspiration.

After working with text-based languages recently, I've become more aware of a very painful flaw in the LabVIEW IDE.

 

First of all, as software engineer, I like to perform experiments. Make a small change, test it. If it doesn't work, then just use Git to roll back the changes. I've been doing this for years, and with LabVIEW it has been fairly painful. Until recently I didn't realize there was a better way.

Why is it painful? Everytime I use Git to check out a different branch or roll things back, I am forced to close LabVIEW or at least close the project so that LabVIEW detects and loads the new code from disk instead of whatever it has in memory. I lived with that for years because I didn't know any better.

 

Enter text-based programming and IDEs: VSCode, PyCharm, probably any other modern IDE. I try an experiment, it doesn't work. I roll the changes back in Git and guess what? I don't have to open and close anything! The IDE just automatically detects the file has changed and loads the new file!

 

When is LabVIEW going to get with the times?