LabVIEW Idea Exchange

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

We need a “modal when called” behavior where the VI is NOT modal when the VI is not currently running (being called). Otherwise, accidentally opening the VI during development while the main VI is running will make it so you can’t interact with any other front panels, block diagrams, or any other LabVIEW windows; and you’re stuck — you have to kill LabVIEW from task manager or cmd.exe (taskkill /f /im LabVIEW.exe)

 

2020-12-11_12-28-19.png

 

My work-around is to add this little snippet of code that uses a Floating behavior in development and a Modal behavior in a built application (EXE).

 

 

2020-12-11_12-34-49.png

I find often the need of creating array indicators with many elements, and of labelling them is a way which allows easy identification of the element index.

Normally the labels of the elements can be made visible, like in the left example shown:

 

array index labelling example

 

One way of doing it, if the array has a fixed size, and all of the array is shown at once, is to juxtapose a set of text labels identifying the elements. Tedious to build.

 

If the array changes size, if it is larger than shown, if it is supposed to be scrolled on the FP, static labels are useless. Currently the label of the element can be made visible, but all elements share the same label. The index display of the array can be shown, but it relates to a single element, which makes cumbersome to identify elements of long arrays.

 

I usually resort to more sophisticate contraptions, like arrays of clusters, each composed of the element in question and of a numeric indicator; or to two parallel array indicators, one for the elements itself and one for the indices. Both solutions are more cumbersome to build and to size and align equally; the index content has to be prefilled and maintained in sync when array elements are added or deleted (programmatically or via contextual menu); in the second case, a lot of events have to be trapped programmatically, for instance to maintain synchronism when the main array is scrolled.

 

What I would like to have is an additional label natively visible, showing the element index, like on the right.

The labels could be made optionally visible with a contextual menu ---- left click->visible items->index label.

Options (perhaps properties) in order to set the value of the first element (e.g. 0 or 1 or any other value) and the step value if different than 1 would also be useful. Standard options about location and orientation of the label with respect to the array element would apply.

 

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:

QD0.png


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:

QD2.png


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:

QD3.png



 

 


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.

 

Check out this nice readable diagram:

labels.png

Whoa there pardner, not so fast. The control reference labeled "Numeric 1" is actually linked to the "Numeric 3" control. And the property node labeled "Numeric 2" is actually linked to the "Numeric 1" control. Etc., etc.

 

I see no reason to change the labels of Control References and Implicit Property/Invoke Nodes. If you need to document them beyond their label, attach a free label to them. We don't allow changing the labels of subVIs, so the precedent has been set. For the sake of diagram readability, we shouldn't allow changing labels of these objects either. 

Help! I need a way to pack more Classes onto my Block Diagrams!

 

This idea is simple and quite subtle- reduce the size of the Class Constant on the Block Diagram. The majority of the footprint belongs to the Class Icon, which cannot be sized smaller, but the additional border graphic that creates the "Object Cube" effect can be reduced to give a total footprint of 42x42 pixels down from 48x48 pixels. (If you're counting, that's a 42% reduction in "fluff", discounting the 32x32 that must remain!)

 

Idea.png

 

 

If you're not crazy about the first-draft artwork, feel free to post a new rendition in the Comments section!

Suggestion: Double clicking a connected terminal on the connector pane highlights and jumps to the connected control. This would be useful for controls that are off screen or hidden.

 

Similar behavior to double clicking the associated terminal/icon on the block diagram, where it automatically repositions the front panel's view.

 

Suggestion.jpg

Hello,

Being able to rotate some indicators, controls, graphics or anything else would be great in my opinion.

Indeed, for example, when you have to represent an electrical circuit in your HMI, you must have several images of the same component with an angle of rotation of 0°/90°/-90°/180°.

So allowing a LabVIEW user to rotate some elements with an angle which could be set, would be more convenient.

 MALT.PNG

  Four images for one element. If we have 2.000 différent elements we must store 8.000 images.

 

 For Example mimic.PNG

When your certification expires, do you instantly forget everything you knew? Of course not.

 

I think the Certifications should be tied to a LabVIEW version. That way, there's an "implied age" to one's Certification (if they haven't taken a newer one), but you are still allowed to produce the Certification on cards, job interviews, etc.

 

 

CLAD logo Idea.JPG

Add a slider on the toolbar which would allow changing the zoom level on the diagram. This should also be controllable more easily (for example, by using shift + mouse wheel scroll).

 

Personally, I want this less for zooming out and more for zooming in. It's sometimes convenient to have a larger display of a specific area.

 

I know some people feel that a zoom is a terrible idea because it will encourage people to create huge diagrams. Personally, I doubt that (since you can't work on zoomed out code and zooming out and in repeatedly isn't that convenient), but I don't mind if people do that. It's their code (as long as I don't have to work on it later).

If people really insist, this can also be prevented by setting the maximum value of the slider to 1, so that people can't zoom out, but I doubt this would have any value.

 

The zoom should snap to 1 when you get near it and should center on the mouse cursor.

I really, really don't like this behavior:

 

key_focus_border.png

 

Whenever you use the KeyFocus property, or simply the tab key on a running VI, whatever control has key focus gets that ugly black border around it.  Can we just eliminate this feature, or at the very least, have the ability to disable it?  The border doesn't appear on System-style front panel controls, but it does for anything else.  I've written all sorts of hacks over the years (the latest being in Quick Drop) where I have to figure out a way to hide that ugly border when a control gets key focus.

Let’s take the Value Changed from OpenG, This polymorphic as 30+ VIs to support all data type and array size up to 2D. But basically it’s the same VI for all data type.

 PolymorphicVI.pngI think it could be a “.vip” and when you define the connector pane you select constraint of the possible data type that can be accepted.

LabVIEW  has a somewhat hidden feature built into the variant attributes functionality that easily allows the implementation of high performance associative arrays. As discussed elsewhere, it is implemented as a red-black tree.

 

I wonder if this functionality could be exposed with a more intuitive set of tools that does not require dummy variants and somewhat obscure VIs hidden deeply in the variant palette (who would ever look there!).

 

Also, the key is currently restricted to strings (Of course we can flatten anything to strings to make a "name" for a more generalized use of all this).

 

I imagine a set of associative array tools:

 

 

  • Create associative array (key datatype, element datatype)
  • insert key/element pair (replace if key exists)
  • lookup key (index key) to get element
  • read all keys
  • delete key/element
  • delete all keys/elements
  • dump associative array to disk
  • restore associative array from disk
  • destroy associative array
  • ... (I probably forgot a few more)
 
 
I am currently writing such a tool set as a high performance cache to avoid duplicate expensive calculations during fitting (Key: flattened input parameters, element: calculated array).
 
However, I cannot easily write it in a truly generalized way, just as a version targeted for my specific datatype. I've done some casual testing and the variant attribute implementation is crazy fast for lookup and insertion. Somebody at NI really did a fantastic job and it would be great to get more exposure for it.
 
Example performance: (Key size: 1200bytes, element size 4096: bytes, 10000 elements) 
insert: ~60 microseconds
random lookup: ~12 microseconds
(compare with a random lookup using linear search (search array): 10ms average. 1000x slower!)
 
Thanks! 

 

Hello,

 

I'm telling my strudents how they should use the error cluster and how important it is. In subvis no error dialogs should be shown and so on (see topics of LabVIEW Core 1 / Core 2).

 

But many VIs written by NI have been programmed very sloppy.

 

Example: VI "Write into spreadsheet file". The error cluster is not wired to the inputs/outputs and if an error occures, an error dialog would pop up. Here is the block diagram of your V "Write into spreadsheet file"I:

 

spreadsheed_file.PNG

 

Please check all of your VIs and do a revision that we can make well-coded applications where the error handling will work correctly.

 

Regards

When entering debug mode (turn execution highlight on) it can be hard to see what is happening.

 

With event structures it can be hard, but there are subtile changes. Sometimes it's impossible. For instance, if you run this VI, and wait a while, it is impossible to why the VI has not stopped. In this case it's easy to deduce, but it can be really hard. Probes also don't provide a solution here...

Parallel Loops.png

 

SubVI's get a green arrow when they are executing. So, could structures get them as well?

 

Parallel Loops proposal.png

The idea is simple: if the label ends in a number (i.e. consecutive string of numeric characters), increment that number:

 

Control auto numbering.png

 

It seems like it only works if there is a space character. If there is a good reason for doing it that way, help me understand what it is.

 

I linked some similar ideas below. I like these discussions for the most part, but they tend to have broader scopes than what I'm suggesting.

http://forums.ni.com/t5/LabVIEW-Idea-Exchange/Smart-er-automatic-label-names-on-copy/idi-p/1873663

http://forums.ni.com/t5/LabVIEW-Idea-Exchange/Auto-increment-number-in-middle-of-control-name/idi-p/977710

http://forums.ni.com/t5/LabVIEW-Idea-Exchange/Don-t-skip-quot-1-quot-during-automatic-naming-of-copies/idi-p/977300#A2089

You might not know this, but if you drop a String constant on the block diagram (or create one from a terminal), you can use shift+enter to define the bounds as you type.

 

You start typing the first line. As you type, the constant gets larger. Hit shift+enter. Now as you continue typing, the string constant grows vertically only, using word wrap at the bounds of the string constant. Now hit shift+enter again. The string stops growing vertically and the vertical scrollbar appears on the constant. 

 

This behavior is very nice for creating string constants inside of structure nodes without having to create the item, then resize it, then come back and start typing your text. 

 

Wouldn't it be nice if the same shift+enter trick worked when typing free labels?  I think so.

Is LabVIEW available for Android based systems and other touch interface systems.If not how about using LabVIEW for mobile measurements using these systems.

I'm totally on board with Embedding Labels for Property and Invoke Nodes! Here are some additional improvements to those nodes:

 

Property Node Concepts

22360i1B976CE68F1194B3

 

Scripting and Invoke Node Concepts

22364iA43FCE953263A787
  1. Most importantly, the banner now more closely resembles a Static Control Reference.
  2. The directionality arrows are a pixel width's larger - more distinct, and matching the size of the new LV2010 Local Variables.
  3. The node banner is the same height as the unlinked property node.
  4. Property Nodes and Invoke Nodes are distinguished by the Property Wrench and the Action Arrow glyph.
  5. Scripting properties/methods are now more distinct. Currently, the small node banner inherits a few pixels of light blue distinction if any one property on the property stack IsAScriptingProperty. Proposed, shading will be applied on a per-property basis, allowing better visual distinction and a more coherent choice for what to shade.

Discussions/suggestions/insults/questions encouraged in comments section!

What's wrong with the current LabVIEW Fonts option dialog? Plenty!

 

Let's have a look:

 

 

  • We can only see one of the three font groups
  • It does not tell us the name of the current font, just how it looks!

 

If we specify a custom font, we get a dialog that has confused me since I started out with LabVIEW 4.0 way over 10 years ago.

 

 

Especially the two checkboxes in the lower left corner have bugged me since day one, because they are very confusing.

 

  • If we open this dialog from the options menu, both boxes are unchecked.
  • If we open this dialog from the BD or FP font pulldown, one of the checkboxes in inoperational, but not greyed out. Why???
  • Unless we read the help, it is not clear what they actually do and what they actually show.
  • Do I click these to make whatever I have selected the default or do I click these to revert back to the default???
  • ...

 

This font dialog needs to go and be redesigned from scratch!

 

IDEA:

 

Why not make the Font options a bit more intuitive. Here's a quick draft. Even if we select the default font, it should show what it is but have the parts on the right greyed out.

 

It probably would need a small preview area below each selection (not shown). Each can be much smaller than the current preview window. (It does not matter if a 500pt font is clipped a bit.)

 

Message Edited by altenbach on 07-28-2009 09:41 AM
Download All