LabVIEW Idea Exchange

Currently, you can place a probe on a wire while developing, which is an indicator of the data on a wire. I want the ability to CONTROL the data on the wire, with a data forcing mechanism.

The implementation would be very simple... right click on a wire, and in the context menu the option "Force" would be right under "Probe." It would pop up a window of the forcing control, and while the VI is running and forcing is set to "Enable", the programmer can control the values that pass on the wire. If the force window were set to "Disable", the data in the wire would be completely controlled by the VI's logic.

I think the implementation by NI could be trivially simple. If you only allow a forcing control to be added during edit mode (not while the VI is running), the force could be added as an inline VI (as denoted by the green rectangle on the wire). The code inside the inline VI would be as follows, and the front panel would be "Data Force (1)" as shown above.

Of course, if you could add a force to a wire during runtime like probes, props NI. But I would be PERFECTLY happy if you could only add these force controls in edit mode prior to running.

One level further (and this would be AMAZING, NI, AMAZING): enable and disable certain parts of the cluster that you would like to force and allow the other elements to be controlled by the VI logic. I made the example above because it would be very natural to ONLY force Sensor1 and Sensor2, and letting the output run it's course from your forced input.

What if I had this:

Then I wanted to insert something with similar terminals:

I'd end up with this:

But the Error terminals aren't wired! So maybe I should be able to select both wires:

Then Right Click » Insert Write Node:

Then I'd have this:

How easy would that be!?

I think it would be nice if LabVIEW was smart enough to know that when I drop a For Loop around scalar inputs it doesn't auto-index output tunnels - but rather uses Shift Registers - for matching inputs and outputs.

The common use case for this is with the Error input/output - it annoys me how it becomes an Array output.

As it is already wired, inline and not broken, dropping a For Loop around it should not break my code! 

Reference or Class inputs are other use case too - I want to pass the same thing around not create an Array. 

Shift registers are better than non-auto-indexed tunnels (other option) as they protect the inputs on zero iterations.

This would remove one step required for most use cases, speeding up my development experience.

Working with class method VIs becomes easily confusing if you need to use VIs from several classes that are inherited from each other. Every class adds or overwrites VIs from one of the ancestor classes but usually you don't know which one. And if you're just user and not developer of this class structure you're usually also not interested in the exact inheritance hierarchy.

Look at the picture: As programmer of the application "main.vi" I'm just interested in Class 3 but I also need to know the internals of Class 1 and Class 2 whereby Class 1 is not even in my project. So I can't see that there are also other cool methods within Class 1 and to get methods from Class 2 I also have to search inside of it and compare against Class 3.

As reference: This is the content of Class 1

What I suggest and expect is the following:

=> The class tree shows all available methods within each single class!

bright colors: Methods that are defined in this class; pale colors: inherited methods

There should be an easy way to replace a control/indicator/constants of a certain type to an array of that same type, and vice-versa.

tl;dr  There's a summary at the bottom if this is too long for you.

Quick Drop is pretty useful when it comes to dropping things and the fact that it also gets items from the project is great.

What I don't like about QD, however, is the keyboard shortcuts. These allow you to perform custom actions in LV and the concept itself is great, but the implementation QD uses has some issues which other similar tools like the right-click framework and LabVIEW Speak don't have, such as the items in the following list.

The problems:

• It requires you to remember keyboard combos to call the plugins. That's great as a secondary access mechanism, but is terrible as a main one for a few reasons:
1. It is not discoverable.
2. It requires you to remember key combos.
3. It doesn't work if you want a longer list of macros which perform all kinds of useful operations, because you run out of available shortcuts.
4. Likewise, you have shortcut collisions, because people want to use the same shortcut for different plugins, so you might say "Ctrl+T", and it will mean something else to the person you're talking to.
• Setting options on the plugins is done by pressing the Shift key or other similar magic combos instead of having a clear representation in the user interface.

So, what can we do about it?

I think a good first step would be to stop thinking of these as "keyboard shortcuts". They should be thought of as custom actions or macros and they should simply appear in the list
along with the regular items, like so:

There are a few things to point out in this image:

• The actions appear in the list using their full names and they have a glyph to set them apart from the other items.
• The actions may (or may not) have a shortcut.
• The actions may (or may not) have a keyboard shortcut (and there's no reason in principle why regular items can't have them too). This solves the existing problem of the shortcut limit - you only assign shortcuts to actions you access regularly, just like you can already do today with menu items.
• There's a ring on the bottom which shows just the items, just the actions, or both. Ideally, the value of this ring would also be settable by other means (e.g. open QD using Ctrl+Shift+Space and the list only shows the actions or open QD when you have a selection and the list only shows the actions).

OK, so that's step one and it solves the first issue - the actions are discoverable, accessible and not limited in number.

Now step two - some of you may have noticed that the image has another new thing - there's an expand button on the right side.
Clicking that button will open this panel:

This area shows the details of the currently selected action and allows selecting options for it.

Here's what we see in this example:

• A title.
• A description.
• An image.
• In the settings area, I gave the "Build array of references" action an option - you can choose to align the Build Array node to the center, the top or the bottom of the references.

The panel should remember its last open setting between calls and when it's open, it should work asynchronously, so that it doesn't delay the operation of QD.
For the VIs which appear in the panel, there should be a standard template for loading and saving values, for showing titles and help data and for shutting down. If the VI fails to respond to the shutdown command within N ms, Quick Drop should proceed and not wait for it.

Of course, once we have this panel, the next logical step is to also have it show the help for standard items, similar to this idea:

So, to sum up:

1. Custom actions should be in the list of Quick Drop items.
2. Shortcuts for actions and items should be fully customizable. That means that you can still use keyboard shortcuts to call the actions, just like today.
   
3. There should be a panel which allows customizing options for actions and show the help for regular items.

I would like to be able to see that a constant is linked to a typedef without clicking it, especially enums.

This could be a light border around the constant, marching ants, or a flag of some type such as the example I have posted. You can quickly tell that the top enum is not linked to a typedef, whereas the bottom one has the little "td" flag.

 

Clusters are powerful and necessary, but they can easily clutter up otherwise immaculate code.  Why not have a "View As Icon" option (a la Express VIs) for cluster constants?

Right-click menu change...

There have been similar suggestions, but I think we need a clean, simple solution.

It has come up here in a different discussion, but I think it should be a separate idea, so here it is!

If we disable part of the code using the diagram disable structure, the disabled code gets lighter in color. The new compiler is good at eliminating dead code (i.e. things that don't need to be computed because there is no output), so it could be useful if these code parts are also bleached in a similar way to indicate that fact.

Here's how it could look like.

I would even suggest this to be enabled by default. Of course there also needs to be an option to turn it off....

(I was about to write up this idea, but then, searching for "dead code", I found comment by SynchronizationOverhead. So the original credit goes there, of course ;))

On project folder ... 

It would be great if in the project tree,

Just like any items that are called and not on project are in dependencies...

The other way would be for

- Update icons (grayed them out) for items in project without callers to be greyed out or have a different icon like an exclamation mark or similar...

that way it would be easier to know if an item is

dead code or not called by anyone

When cleaning or developing is common to forget which vis are no longer used or needed.