LabVIEW Idea Exchange

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 ;))

The VI documentation window could use some improvement and several additions could be made to make editing the text a lot easier.

Improving adding control and indicator name.

Typically the text in the documentation window does refer to the control and indicator connected to the connetor pane.

It would be very convenient to have this information already in that window so we don't have look it up when needed. Additionally, the control and indicators are typically bolded in the resulting text using the <b></b> tag. It would be convenient if this would be done automatically for us.

In the propose idea (see image below) the VI icon with the controls and indicators is shown and the controls and indicators when clicked do insert their name into the VI description. 

Note: The control name may be made to look like an hyperlink to indicate that there are click able.

For example, in the image below, clicking the "Items to filter" will insert the "<b>Items to filter</b> tagged text in the VI description.

Improve general text editing

While fancy text editing is limited in the VI description, adding a toolbar to improve text formatting would be useful.

Hello, this is my first post in this forum and I don't found ideas about this topic. I hope you like it.

Well, time ago I started to work with LabVIEW, It's powerful, but there are some kind of issues that I want to explain here. Now I'm get involved in a big project for a very big aerospace company, and I'm developing a complex application to acquire some data and process it. Well, this software is in development by some people and I have an idea for the work flow.

I explain it with an example:

If we have in every VI a little data base with some notes ordered by type or something we can read the code or we can start to work in a VI faster. Imagine that you have an event structure with several cases, and you put some notes like you can see in the following image:

Now, I'm able to revise quickly the code reading all the notes and start working only in the "TO DO" zone. But let's do a more complex design: Now I open my project explorer, and open the "Note manager" that could be like this.

Here it is the real advantage of this tool: All the design are done and now I want to improve the application. Lets go only to the notes that interest to me: "TO DO" notes. If I double click on an element LabVIEW opens for me the VI centered in the zone that is interesting for me. And some more: I can check the work I've done and I can add new notes only with a click.

The more complex the project is, the more useful is this system. So, what do you think?

Some very useful properties for UI manipulation on graphs and charts do not exist. This makes it impossible to make very dynamic UI's with variable number of plots or dynamic resizing in panels.

It is possible to set Legend.number of plots and Legend position. It is not possible to set:

Graph palette, scale legend or cursor legend position. This makes resizing graphs very limiting.   

Further, it is possible to programmatically create a custom legend.  However it is not possible with cursors because there is no property available to get the current cursor values. Please can we have cursor.values[] and cursor.legend.number of rows

It would be nice if the Strip Path function had a recursive option rather than having to string Strip Paths together or use an external loop.

 eg change from this:

to this:

regards

Ray

For projects, libraries, and their associated files, if the "Save Version" property is set to an earlier version of LabVIEW, the project and its files are not recompiled to the editor version.  There should be an option on the Mass Compile dialog that allows the "Save Version" property of projects, libraries, and classes to be overridden.