LabVIEW Idea Exchange

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

One of the fiddly things I seem to do more than I'd like is adjust the bottom of block diagram comments to the right height. At a minimum there, but also for similar text boxes on the front panel or subdiagram labels, etc. I'd like to have a snap feature that sizes to a multiple of the text height. Examples:

 

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!

Right now a lot of SubVIs in Vision Development Module looks like that:

 

IMAQ Vision Connector Pane.png

 

Because in most cases we using IMAQ Images on the top and error outputs - the wires fully misaligned. It would be nice if all (or most) of them will have standard and same "default" connector pane (if possible, of course).

Thank you!

 

Andrey.

 

It would be useful to be able to disable the handling of a single Event Case in an Event Handler Structure. Note that this is distinctly different from merely Diagram Disabling the contents of the Event Case; using that method, the Timeout event case will be reset, and additionally program execution will continue past the Event Handler Structure (in the example below, continue to the next iteration in the While Loop).

 

Here's an example of what a Disabled Event Case might look like - the Event Structure and contained code is "washed out" as if Diagram Disabled - additionally, the disabled event in the list of Event Cases is struck-out and in italics:

DiagramDisabledEventHandlerCase.png

 

And here's a proposal for how one might disable a given Event Case, using the context menu that pops up by right-clicking the border of the Event Handler Structure:

 

HowToDisableAnEventCase.png

Put a copy of the Empty String/Path? on the Variant palette since "this function is also designed to work with variants...; see https://www.ni.com/docs/en-US/bundle/labview/page/glang/empty_string_path.html .

 

For an example of the difficulty in finding this function, see https://forums.ni.com/t5/forums/editpage/board-id/170/message-id/1248895

 

For precedent of the same functions on different palettes see the Array to Cluster and Cluster to Array functions on both the array and the cluster palettes.

Idea/bug-report:

If you have a multicolumn listbox with column headers and you want to delete one of the columns you can right-click on the column and select delete column, but if there are no items in that column LabVIEW will not actually do anything(!):

 

This also applies to empty rows with headers. This is non-intuitive and makes it cumbersome to remove a header and keep the width/height of the ones you want to keep...

In general I would like to see LabVIEW more in line with the OS GUI standards. We have dialog controls and colors, however they are not set up to be the default choice - and we lack other GUI elements like status bars, notify icons, child windows etc. etc. A large part of LV-programmers' time is spent on ways to get LV to mimic what users will recognise and therefor intuitively understand.

 

In this case I simply miss the "sort glyph" that indicates that a table or listbox is sorted based on a given column and in which direction.

 

I imagine we could show or hide this and set its direction with a property node...It would not handle the sorting (although that would have been neat as well - if you had an in-built sorting that just needed to know a few parameters about the column data to do the job)...

Often, when modifying code, I need to reduce the size of a structure due to removing code.  If I have a nested structure system (e.g. event structure in a case statement in a loop), this can get very tedious.  It would be nice to have a "shrinkwrap structure" functionality on the right-click menu as a counterpoint to the autogrow.  This would be an action that would reduce the structure size to something a bit bigger than the largest contents.  An option to set how much extra space to include would be nice.

As the number of classes in a project increases it gets harder and  harder to figure out which methods in a class are overridden because you need to scroll up and down to compare the methods listed under each class. A distinctive glyph or icon in the project explorer window would be very helpful. I understand that there are workarounds like creating an override virtual folder and moving the overridden vis inside it or right clicking the class and opening the "VI for Override" window and checking if the vi is listed. However, a distinctive icon would drastically increase code readability.

reza0146_0-1709836120851.png

 

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! 

 

One of my pet peeves when using the Unbundle or Bundle by Name occurs when I remove or add an item from a cluster and LabVIEW attempts to find the item with a similiar name.  The behavior should always break when the specific item in the Unbundle/Bundle by name is removed.

 

More often than not LabVIEW picks the wrong thing and introduces programming bugs. 

Picture says it all.

 

Concatenate with an option of 'concatenate to new line'

 

 


I am not allergic to Kudos, in fact I love Kudos.

CLA_Short.jpg

 Make your LabVIEW experience more CONVENIENT.


Similar to the library banner functionality, I find myself wanting to replace the icon of method overrides with the icon in the parent. This is done automatically for new overrides, but I haven't seen any way to apply a new parent method icon to its overrides once they exist already.

 

I imagine this working like the library banner: whenever the VI icon of a dynamic dispatch VI with overrides in memory is changed a dialog could pop up and ask if you want to apply it to the children as if the icon had been freshly generated the way it is for new overrides.

When loading a VI where some or many of the VI's are missing (like a forum post where the person used 3rd party driver subVI's you don't have or used numerous subVI's and typedef's that they did not bundle into their attachments) you have to click ignore on each subVI as it comes up with the dialog box as it searches for it on your system.  If there are only a few such subVI's, it is no big deal.  But some people will be missing dozens of VI's, and you have to continually click ignore over and over again until the main VI loads broken.

 

It would be good if that dialog box had an Ignore All button, so that once you come across the first subVI it can't find, it will ignore it and all other subVI's it can't find.  Then the main VI can load in it broken state in just one or two clicks.

My goal is to reduce palette bloat!

 

Let's look at the conversion palette. Certainly looks impressive, but why do we need so many different bullets??? They are basically all the same function:  A universal input and an output type.

 

I suggest that the 16 marked bullets on the image, plus some others (e.g. "to variant"), be combined into a single universal bullet where we can select the desired output type by a simple right-click. Whatever we select will determine the actual icon, so once things are in place, everything will look exactly as before.

 

When we first drop the universal icon on the diagram (or insert it into a wire), the context menu appears and we must select the desired output.

For those of you who haven't signed up yet, you should go and have a look at the Next Generation LabVIEW Features Technology Preview (a mouthful, but in short, it is a UI and Development Environment demonstration version of what NI is cooking up for future versions of LabVIEW). There are some cool things and some downright awful ones.

One of them has been sneaking its ugly neck in LabVIEW 2016: reduced contrast. I am (my eyes) getting tired of it. A few examples of the changes introduced in 2016 are shown below:

 

2015:

Screen Shot 2016-10-29 at 10.10.59.png

2016:

Screen Shot 2016-10-29 at 10.12.28.png

 

Considering that the trend is for displays to not increase that much in size but increase in resolution, we have now to factors to fight against: the reduction in size AND the reduction in contrast. I won't mention laptop displays going in economy mode and reducing their luminosity, but the point is that it is making LabVIEW even more difficult and unengaging to use. Way to go to loose any chance to attract new users, and run the risk to loose old timers due to added eye strain.

 

Put simply: Restore high contrast icons  and please, do not go ahead with the washed out IDE and UI objects showcased in Tech Preview.

 

 

This is one of those existing "features" that I cannot understand, no matter how long I ponder why it is implemented this way. (WHY!!!?????). Somebody must have consciously programmed this behavior in the early days of LabVIEW, but I simply don't get it. ๐Ÿ˜‰

 

Try the following yourself and you'll see what I mean: ๐Ÿ˜„

  1. Create a structure (For loop, while loop, case, event, etc) with a few tunnels.
  2. Select one of the tunnels, and, using the arrow keys move it towards one of the structure corners.
  3. Observe: As soon as we move within a few pixels of the corner, the tunnel jumps to the corner and can no longer be moved with the arrow keys alone.
  4. To move it away again, we need to grab it with the cursor using the mouse and move it at least a few pixels away from the corner or use "shift-arrow" to move it by a bigger step. THis should not be necessary.

Idea: There should be no such stickyness!

 

IF a tunnel is moved towards a structure corner with the arrow keys, it should simply stop moving at the corner and we should be able to move it away again by pressing the opposite arrow key (or the arrow key following around the corner by 90 degrees)

When improperly stopping a project that has launched asynchronous vis set to fire and forget, you end up with classes and libraries that are locked.

 

Reserved VIs.PNG 

 

There seems to be no way of unlocking them other than to close the project. There is an idea to abort called VIs when the parent stops but from the lack of kudos and by reading the comments it doesn't seem like a good one.

 

I know about and use the Abort.vi but it does not work in this case. The dropdown is empty:

 

Not running.PNG

 

Not even the LabVIEW Task Manager can help.

 

 

Task Manager.png

 

My idea is to have a button that does whatever closing the project does when it unlocks the class or library. Maybe this means it transparently closes the project and opens it again in the state it was in when the button was pressed. I don't know.

 

Abort Project.png

 

 

I know there are some similar ideas but as far as I can tell this is not a duplicate.

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.

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.