LabVIEW Idea Exchange

This idea is all about culling clicks.

Example:

I have created a subVI based on another VI and I realized that I needed some additional input from the calling VI to perform the task within the subVI:

Since I want to get the right data structure, I can't really create a Control within the subVI, add it to the connector pane and connect the corresponding data from the calling VI.

So I need to:

1) Go to the calling VI

2) Drop a dummy Sequence structure on the BD

3) Pull a wire from the data structure I want to connect to the subVI and connect it to the dummy Sequence

4) Create a subVI from that sequence

5) Copy the resulting control on the subVI's panel

6) Destroy the temporary subVI (that involves a "Do you want to Save this VI?" dialog, so it is really a two-step process)

7) Go to the target subVI

😎 Paste the Control

9) Connect the control to the Connector Pane

10) Go back to the main VI and connect the data

What I suggest is to replace all these steps by a 2-step process:

1) Pull a wire from the data source

2) Bring that wire OVER the target subVI and by a magic combination of keypress and mouse click (for instance "I" for "Insert" and a Right-Click), open up a dialog allowing me to connect that wire into an available connector on the target subVI (a Control being created in the process - I am fine with having to convert it to an Indicator later).

Basically, this "action" would provide access to the connector pane of the subVI with an automatic creation of a control upon clicking on the connector. Existing rules for Control name generation would be fine.

Something like that:

The interface could switch from the subVI icon view to the connector pane view, for instance.

I find myself wanting this alot for things as simple as passing a Graph reference to a subVI, where I want the reference to correspond exactly to the graph type.

I looked for a similar idea, but I didn't' find anything. I find that hard to believe, so I may have missed it somehow.

LabVIEW has arrays the dynamically grow. This is great. Love it. It makes it very easy to do things like Loop A below.

But that can lead to performance issues as LabVIEW constantly has to allocate new memory as the array grows. However, and this is important, LV is smart enough to over allocate so that not every append results in new memory allocation. Somewhere in the LV code NI is keeping track of the size allocated and the size used.

If performance is a concern, we've always been told to do something like Loop B. Preallocate a big array and use Replace. But there are problems here. First, a lot of the built in array functions will return 'wrong' values (Array Size, etc.). Second, what if the initial size is just a best guess. If we need something larger (say 5050 elements), we have to have a special case to Append instead of Replace once we hit the initial allocation. BUT, LV is already doing all this internally, it just isn't exposed to us in a way that we can take advantage of.

So, I propose Loop C. (sorry, too lazy to create a good icon). This new primitive would return an empty array (like Loop A), but with memory already allocated for a much larger array (like Loop B). LabVIEW already has the code to handle this. So, if we know the array will grow to ~5000 we can preallocate that amount, have all the built in functions work and not have to worry about going over 5000.