Persistent font Settings

[PJM_Labview]

One of the annoyance of designing a UI is that you will never know for sure how it will look on another user computer.

For instance, you design your UI with the default 13 point font size and when a user that has it default font size set to say 16 (and with a different font type) open your UI everything is a mess (text run out of the screen, text overlay controls ...).

In built application (meaning in an exe) one can add the following line to the executable and this fix the problem by coercing the font type and size.

• AppFont=""Tahoma" 13"
• DialogFont="Tahoma" 13
• SystemFont="Tahoma" 13
• CurrentFont="Tahoma" 13

But what about a reusable tool that are basically a source code distribution?

Currently, the simplest way to ensure this outcome is to write a reusable VI that will recursively set the font size and type of every labels or string to be what you designed your UI to use. This VI has to be run by the UI every time it starts.

What I propose is to add a global VI settings (probably somewhere in the VI properties) that will persist whatever font settings was used to design the UI.

This setting should default to false.

The image above is one possible solution (the simplest one).

Another solution would be to explicitely defined what every font style&size should be for every font type (something very similar to the explicit definition one can use in an ini that I mentioned above). In that case, there could be an entirely new font category in the VI properties.

PJM

[altenbach]

> Currently, the simplest way to ensure this outcome is to write a reusable VI that will recursively set the font size and type of every labels or string to be what you designed your UI to use. This VI has to be run by the UI every time it starts.

It actually would need to be significantly more complicated than that, because many of my labels use mixed fonts (often partially "symbol"). This suggestion would e.g. turn my "βD" label into "bD", for example.

[Nathan-P]

The font not being compatable, or the same on different machines prevents LabVIEW front panels from being portable.  It would be a large step for UI designers to have LabVIEW act more like a "What you see is what you get" editor.  

For reference, this bug/feature request is discuessed heavily here.

[rthorpe]

What's really needed is portability.  It should be possible to have a VI that looks the same across different versions of Windows *and* Linux, and whatever other OSes NI support. That may have to mean requiring that the user choose a "portable VI" setting before programming begins. But, as far as I can see that's what's needed.

[AStankov]

I think the key is to be able to include the fonts used with the VI or at least with the executable. This is how it is done with in desktop publishing and with PDFs.

Or NI should at least be able to create a LabVIEW font that is available on all systems and set it as the default font.

It is really ridiculous that LabVIEW runs on Win, Linux, Mac but simple font settings break the front panels.

[shb]

Idea about the same problem, but more general (also in Development and in Block Diagram): Fix Font Behaviour ...

[littlesphaeroid]

LV2017: Font situation still horrible.

[AristosQueue (NI)]

LabVIEW NXG has addressed all of this.

[littlesphaeroid]

Oh, excitement. I wonder if I can port my large application over to NXG...

[Darren]

Available in LabVIEW NXG. The concept of symbolic fonts (App, System, Dialog) is not present in NXG, which means that whatever font is used to develop a GVI will not change, regardless of the settings of the machine on which the GVI is opened. Also, the fonts used by default on the diagram and panel are installed with LV and will be available on all targets.

[AristosQueue (NI)]

littlesphaeroid: Can you port? Maybe. Many applications can port at this point. The larger the app, the less likely that becomes. NXG is a work in progress for most users, but is a viable product at some levels. Regardless, that is where this request was addressed -- the whole point of building NXG was that LabVIEW 20xx is based on 30+ years of bitmaps and fixed-size graphics, and all the scalability features that it does have are grafted on after the fact. The architecture doesn't support most of the modern UI niceties, and refactoring is, well... it's equivalent to rolling NXG. 🙂 Thus, NXG.

NXG is releasing new versions every six months, and each one has added substantially to the list of LV features that can successfully port across.