五彩生辉—— LabVIEW 界面配色秘诀

俗话说：“人靠衣装，佛靠金装”，应用程序的界面是提供给使用者的第一印象，直接影响到应用程序的用户体验。

因此，有效、合理的界面能够为程序增色不少。

LabVIEW提供了丰富的界面控件供开发者选择，有经验的程序员往往能够利用这些控件做出令人称赞的界面效果。

在《LabVIEW Development Guidelines》（下载）和《The LabVIEW Style book》（介绍）书中都有专门的章节来论述LabVIEW程序界面设计规范和方法。

本文主要从应用应用开发的角度描述一些通用的界面设计的方法。

1.1控件的分类和排列在LabVIEW中，控件通常被笼统地分为控制型控件（Control）和显示型控件（Indicator）。

而对某一个具体的应用而言，更需要把Control和Indicator进行细分，使得具有同样功能的控件排放在一起，甚至组成若干个Group组。

LabVIEW提供了一系列工具供程序员排列和分布控件的位置以及调整控件的大小，如图1所示。

图(a)是排列对齐工具，其中的图标可以很清楚地知道各个按钮的作用。

使用Ctrl+Shift+A可以重复上一次的排列方式。

图(b)是位置分布工具，可以快速地分布各个控件之间的位置。

图(c)是大小调整工具，可以快速地调整多个不同控件的大小（注意：部分控件的大小是不允许被调整的）。

图(d)是组合和叠放次序工具，Group表示把当前选择的控件组合起来形成一个整体；Ungroup与Group相反，表示分散已经整合起来的各个控件；Lock表示锁定当前选择的控件，此时控件将无法被编辑（包括移动控件的位置，调整控件的大小等）；Unlock是解锁指令；Move Forward、Move Backward、Move to Front和Move to Back表示修改当前选择控件的排放次序。

1 控件排列和分布工具图2是某个测试界面的控件摆放实例，尽管这些控件都是Indicator控件，但是仍然根据显示功能和内容的不同将控件进行了分类。

LabVIEW的面板设计和用户界面优化LabVIEW是一种用于编写控制和测量系统的强大的图形化编程语言。

在设计和开发LabVIEW应用程序时，面板设计和用户界面优化是非常重要的，它不仅可以影响用户的体验，还可以提高程序的可维护性和可扩展性。

本文将探讨如何设计LabVIEW面板和优化用户界面。

一、面板设计原则1. 界面简洁明了：LabVIEW面板应该尽量避免过于复杂和拥挤的设计，只展示必要的控件和指示器。

合理的布局和空白区域可以增强界面的整洁度和可读性。

2. 控件选择与布局：选择适当的控件是关键，不仅要考虑功能需求，还要考虑用户的直观习惯。

应该将相关的控件放在一起，并且进行合理的布局，以提高用户的操作效率。

3. 颜色和样式的搭配：选择合适的颜色和样式可以增强界面的美观性和可视性。

应该避免过多的颜色和装饰，保持简洁和一致性。

4. 错误处理和状态指示：在面板设计中应该考虑到错误处理和状态指示，以便用户能够轻松地识别和解决问题。

可以通过合理的标识、颜色和图标来指示错误状态和程序的运行情况。

二、用户界面优化技巧1. 响应速度优化：用户界面应该尽可能地响应迅速，避免卡顿和延时。

可以通过减少计算量、优化算法和合理使用缓存等方式来提高程序的执行效率。

2. 输入验证和限制：在对用户输入进行处理时，应该进行验证和限制，以确保输入的准确性和合法性。

可以使用适当的控件属性进行输入检查，或者在程序中添加相应的逻辑来处理无效输入。

3. 异常处理和容错设计：优化用户界面还需要考虑到异常情况的处理和容错设计。

在程序出现异常时，应该提供相应的错误信息和解决方案，以便用户能够快速地解决问题。

4. 文档和帮助信息：为了方便用户使用和了解程序，应该提供相应的文档和帮助信息。

可以在界面中添加必要的说明文字、标签和帮助按钮，以引导用户正确地操作。

5. 用户反馈和改进：为了不断改进用户界面，应该收集用户的反馈意见和建议。

可以通过用户调查、反馈按钮等方式主动获取用户的意见，然后根据反馈做出相应的改进。

配色方法，三种UI的选择配色方法方法一:色轮配色色轮由12 种基本的颜色组成。

首先包含的是三原色（Primary colors ），即蓝、黄、红。

原色混合产生了二次色（Secondary colors ），用二次色混合，产生了三次色（tertiary colors ）。

色轮有五个同心环组成，从暗到亮-暗色处于大环，明色处于小环，而中间是颜色的基本色相。

根据颜色的关系有以下几种配色分类a、单色配色单色搭配就是以一个颜色为主，然后利用颜色的深浅来进行搭配的方法，即色轮中，一种色相的暗、中、明三种色调，单一颜色是比较单调，所以利用颜色的深浅变化来增加多彩性。

优点：画面统一，搭配时相对简单而且一般都不会给人难看的感觉，一般不会给人难看的感觉。

b、邻近色配色在色相环上相邻的色彩互为邻近色优点: 色调统一,具有低对比度的和谐美感。

这种颜色搭配产生了一种令人悦目、低对比度的和谐美感。

类比色非常丰富，在设计时应用这种搭配同样让你轻易产生不错的视觉效果。

c、互补色和对比色配色互补色是在色相环上180°相对的两个颜色，而对比色则是在色相环上150°到180°范围内相对的两个颜色。

优点：补色和对比色形成强列的对比效果，传达出活力、能量、兴奋等意义。

补色要达到最佳的效果，最好是其中一种面积比较小，另一种比较大。

比如在一个蓝色的区域里搭配橙色的小圆点。

案例:d、分裂补色配色如果我们同时用补色及类比色的方法来确定的颜色关系，就称为分裂补色。

优点：这种颜色搭配既具有类比色的低对比度的美感，又具有补色的力量感。

形成了一种既和谐又有重点的颜色关系。

如在上面三种颜色中，红色就显得更加突出。

案例:e、原色搭配配色除了在一些儿童的产品中，三原色同时使用是比较少见的。

但是，无论是在中国还是在美国的文化中，红黄搭配都是非常受欢迎。

红黄搭配应用的范围很广――从快餐店到加油站，我们都可以看见这两种颜色同时在一起。

第一讲：认识Labview1.1 Labview 简介在开始菜单里找见NI Labview7.1 点击打开，会出现如下界面：从File>>New VI 或者从右半部分中的New>>Blank VI 都可以打开如下界面：上图中前图是虚拟仪器的前面板，是用户使用的人机界面，后面的是程序框图界面（即后面板）。

在LabVIEW的用户界面上，应特别注意它提供的操作模板，包括工具（Tools）模板、控制（Controls）模板和函数（Functions）模板。

这些模板集中反映了该软件的功能与特征。

下面我们来大致浏览一下。

工具模板（Tools Palette）该模板提供了各种用于创建、修改和调试VI程序的工具。

如果该模板没有出现，则可以在Windows菜单下选择Show ToolsPalette命令以显示该模板。

当从模板内选择了任一种工具后，鼠标箭头就会变成该工具相应的形状。

当从Windows菜单下选择了Show Help Window功能后，把工具模板内选定的任一种工具光标放在流程图程序的子程序（Sub VI）或图标上，就会显示相应的帮助信息。

工具图标有如下几种：图标名称功能１Operate Value（操作值）用于操作前面板的控制和显示。

使用它向数字或字符串控制中键入值时，工具会变成标签工具２Position/Size/Select （选择）用于选择、移动或改变对象的大小。

当它用于改变对象的连框大小时，会变成相应形状。

３Edit Text（编辑文本）用于输入标签文本或者创建自由标签。

当创建自由标签时它会变成相应形状。

４Connect Wire（连线）用于在流程图程序上连接对象。

如果联机帮助的窗口被打开时，把该工具放在任一条连线上，就会显示相应的数据类型。

５ObjectShortcut Menu（对象菜单）用鼠标左键可以弹出对象的弹出式菜单。

６ScrollWindows（窗口漫游）使用该工具就可以不需要使用滚动条而在窗口中漫游。

注：本文为LabVIEW 网络讲坛系列短片的技术文档，第一部《界面风云》中将主要讲述在LabVIEW 中创建用户界面的方法与技巧。

创建一个美观易用的用户界面，和家居布置一样：控件就像是家具，具有各种款式供您灵活选择；实用的家具需要配以和谐的颜色，颜色没有美丑之分，搭配是关键；如何把这些美观实用的控件合理地摆放在用户界面上同样也是一种学问，合理的布局可以达到整洁方便、赏心悦目的作用。

本文旨在向大家介绍如何创建出美观实用的控件。

LabVIEW 作为图形化的操作系统，已经为开发者提供了大量方便实用的控件，使用这些资源，无需任何额外加工和修饰就能创建出如图1所示的直观、可读性强、便于操作的用户界面。

当然，有些时候，针对一些特殊应用，基本控件可能无法满足设计人员的要求，那么我们就可以在LabVIEW 中自定义各种控件，下面的演示中将向大家介绍如何使用自定义控件来丰富前面板内容的。

巧夺天工 —— LabVIEW 控件的妙用NI 资深应用工程师郑凯图bVIEW 示波器界面首先，我们来看第一个范例，一个钢琴的界面（图2）。

如果希望实现如图的效果，即使不了解太多的LabVIEW 编程技巧的工程师也可以实现，无非是把一个布尔类型的控件修改成琴键的形状，然后不断复制控件，并使之排列整齐即可。

但是，如果我们希望改变这些控件的颜色、长度和宽度的时候，就会遇到问题，我们需要手动地去调整和修改所有的控件，当控件的数量较多时，其工作量就会变得非常巨大。

因此，使用自定义控件的方式就能解决这个问题。

我们选择一个控件，右键单击，选择高级，再选择自定义后进入自定义控件编辑模式。

再修改控件至您所需要的样式，将控件保存为严格自定义类型，关闭并保存该控件（图3）。

图bVIEW 钢琴界面图3.设计自定义控件并保存为“严格自定义类型”我们可以再通过复制的方法在前面板添加该自定义控件，添加完毕之后，选择其中任意一个，选中高级的自定义选项，进行外形和颜色的调整，并保存关闭。

LabVIEW界面设计打造简洁易用的用户界面在当前信息化时代，软件界面设计变得越来越重要。

一个好的用户界面能够提升软件的易用性和用户体验，而一个繁复、混乱的界面则可能导致用户流失。

作为一个强大且灵活的控制与测量软件，LabVIEW（Laboratory Virtual Instrument Engineering Workbench）在界面设计方面也备受关注。

本文将介绍如何通过LabVIEW界面设计打造简洁易用的用户界面。

一、功能定位与界面设计在开始设计用户界面之前，我们需要先明确软件的功能定位。

通过明确软件的目标和用户需求，我们能够更好地选择合适的界面设计方案。

在选择界面设计方案时，我们可以考虑以下几个方面：1. 界面整体布局：合理的界面布局能够使用户能够快速找到需要的功能和信息。

我们可以采用经典的三栏式、主从式或者平铺式布局，根据实际需求决定。

2. 导航设计：导航设计关乎用户在软件中的行为流程，合理的导航设计能够提高用户的操作效率。

我们可以通过添加菜单、工具栏和导航面板等形式来实现良好的导航设计。

3. 控件选择：选择合适的控件能够直观地呈现数据或者功能，同时也能够提高用户的操作效率。

在LabVIEW中，我们可以使用按钮、滑动条、图表等控件来实现各种功能的展示和操作。

二、界面美化与风格设计除了功能定位和界面设计，界面美化和风格设计也是打造简洁易用的用户界面的关键。

以下是几个实用的界面美化和风格设计建议：1. 颜色搭配：合理的颜色搭配能够提高界面的美观度和可读性。

我们可以选择简洁明快的颜色，同时避免颜色过于杂乱，影响用户的视觉体验。

2. 图标设计：图标是用户界面中重要的组成部分之一，好的图标设计能够让用户更好地理解功能或者操作内容。

我们可以选择简洁明了的图标，或者自定义特定样式的图标。

3. 字体选择：合适的字体能够提高用户的阅读体验。

我们可以选择易读且符合软件风格的字体，同时避免字体过于花哨、难以辨认。

LabVIEW中的人机交互界面设计技巧LabVIEW是一款非常强大的图形化编程环境，广泛应用于工业自动化、测量与控制领域。

在LabVIEW中，人机交互界面是用户与程序进行信息交流的重要途径。

良好的人机交互界面设计能够提高用户的工作效率，优化用户体验，本文将介绍一些LabVIEW中的人机交互界面设计技巧。

一、界面布局与排版设计1. 合理划分界面区域在设计LabVIEW界面时，首先要根据功能和信息的关联性进行界面区域的划分。

可以使用容器控件，如Tab控件、Cluster等，将相关的控件组织在一起，提高界面的可读性和易用性。

2. 使用合适的控件LabVIEW提供了丰富的控件元素供用户选择，如按钮、滑动条、数字显示等。

在选择控件时，要根据功能需求和用户习惯进行选择，以达到最好的用户体验。

3. 合理调整控件的大小和位置控件的大小和位置对用户的操作和视觉效果有很大影响。

需要根据控件的功能和重要性，合理调整控件的大小和位置，以避免界面混乱和操作困难。

4. 使用合适的配色方案良好的配色方案能够给用户带来舒适的视觉体验。

在LabVIEW 的界面设计中，可以选择适合应用场景和颜色搭配的配色方案，提高界面的美观性和可读性。

二、界面操作方式设计1. 设置合理的交互方式在LabVIEW中可以通过按钮、复选框、滑动条等控件进行用户操作，通过响应事件来实现不同操作的功能。

在设计界面时，要根据实际需求设置合理的交互方式，如单击、双击、拖动等。

2. 提供合适的反馈机制用户操作后，及时给予反馈是良好的用户体验的重要组成部分。

可以在界面中设置合适的提示信息、动态效果或状态指示器等，及时向用户传达操作结果和系统状态。

3. 设计可撤销与重做功能在LabVIEW应用中，用户可能会频繁进行参数调整和试验验证等操作。

为了提高用户操作的自由度，可以设计可撤销与重做功能，使用户可以轻松地回退和恢复操作。

三、界面美化与优化1. 图标与图片的使用在界面设计中，可以使用图标和图片来增加界面的美观性和信息量。

First of all we’ll quickly define what we mean by UI and introduce some rules, or guidelines, that you should follow to help you create quality UIs. UI design principles are no different in LabVIEW as they are for any other programming language and there are many good resources available on the internet and in books; consequently we won’t spend too much of our time here today talking about generic UI principles. Topics such as how to choose nice colors or group like objects are important but since they are covered so well elsewhere I will leave those as a homework assignment and spend most of our time here showing you some techniques and features in LabVIEW which will allow you to create much better UIs without doing too much extra work.Finally, since LabVIEW has such a strong community of developers I’ll leave with a URL where you can go and get some reusable UI components, as well as discuss and share your UI‐related questions.UI stands for user interface. It is the way your applications user gives commands and receives feedback from your application.For those of you who develop applications to sell, the UI is often the “cover” to your book –the crucial first impression. A good UI implies a thorough, professional development team whereas a sloppy UI can turn potential clients off.A good UI makes the user’s job easier since they spend less time trying to figure out how to complete their task (which often translates to less questions for the developer). I bet you can name a few applications off the top of your head where an unintuitive UI makes using that application more difficult than it should be which translates into inefficiency, frustration and resentment from you, the user.Your job as the UI developer is to predict the points of frustration and lay out an interface that helps the user get their job done. Getting the job done is most people’s primary concern.The design of the user interface and the usability of the application are closely intertwined. Any visual element that doesn’t contribute in some way to the efficient completion of tasks in your application is in some ways superfluous “eye candy”. This isn’t necessarily bad but it certainly shouldn’t be where you spend most of your time.Likewise, functionality or features that aren’t represented in the UI can only be considered background tasks since the user has no way of using that functionality.Some general rules I suggest you keep in mind as you develop are 1. Don’t be innovative, 2. Less is more, and 3. Think about your user. I’m not saying that you should never break one of these rules, but if you do you should do so consciously and for good reason.Let’s look a little deeper at each of these rules….My first rule is don’t be innovative.To illustrate this point think about a car interior. Everyone who knows how to drive a car is familiar with a steering wheel, two or three pedals, a gear stick of some kind, normally turn signal stalks etc. You don’t have to relearn how to drive a new car. The basic controls are the same as your old car (the radio or navigation probably isn’t –and for me that is often a point of frustration).Chances are the program you are writing is not going to be the user’s first computer program. Therefore the user has some kind of pre‐learned notions of how to interact with applications. You should fit into those notions rather than forcing the user to learn your way of doing things. A good rule people working on Windows systems is “make your application behave like Microsoft Office” since so many people are familiar with Office. Practically this means using common designs for buttons, using icons people will recognize, putting menus in places people expect them etc.Note that this rule doesn’t mean you can’t be a little creative. There is still space for customization and adding your own touches, just do so in a way that doesn’t impact the usability of your program.Rule#2 Less is More.Don’t clutter up the screen unnecessarily with obscure settings or controls. Hide things that are only used infrequently and give the user a way to bring them back when necessary.Presenting the user with fewer options eliminates distractions and allows them to focus on whatever it is that they ought to be focusing on.One company who is very good at applying this rule is Apple. Both the iPod and the iPhone have been huge successes, despite generally costing more, having fewer features and lower specs than competitors products. One of the big reasons for this success is Apple’s commitment to stripping out unnecessary options and making an attractive user experience that preserves the important core functionality with fewer distractions. The iPod with it’s wheel and the iPhone with it’s solitary button are simple, yet effective.As a developer it’s easy to assume that everyone knows how your application works and how to complete tasks using it –and if you are the intended user that’s great. For those of us who have to develop applications for other people to use then we have to keep those other people in mind as we develop.The first implication of this is helping a user who doesn’t know as much as you do. They might not intrinsically know what each button/control in your applications does (although they might if you follow rule #1). For those cases where you have a unique action in your application use contextual cues to teach your user. Tooltips and status bars are common techniques that allow users to get more information about what a button does before they click on it.Once the user clicks on something they generally expect something to happen. If the task is particularly slow you need to update the user to let them know that your application is working correctly. Just because you know what should happen in a given situation doesn’t mean that your user does.The second major implication of thinking about your user is thinking about how and where the program will be used. Will the user have a mouse or keyboard? If one is missing that has implications as to how you will get input from the user. Touch screens are becoming increasingly popular and have their own sets of requirements (such as larger buttons and not relying on mouseover effects). Is your application going to be used outdoors or on low color displays? If so you will want to pick color schemes that do not rely on the user being able to see subtle differences in contrast.We’ll spend most of the rest of this presentation looking at three different UI scenarios and some techniques you can implement in LabVIEW to improve your applications.The Windows Desktop App is used on a PC with a high‐resolution monitor, a keyboard and a mouse. The user spends a fair amount of time engrossed by the application and expects this application to sit alongside other applications that they have installed on their computer.This is a very common scenario where users generally have a lot of established UI expectations that you should take advantage of. Luckily LabVIEW has a number of features that can help you do just that.Before we dive into LabVIEW let’s review the rules and discuss how they apply to this scenario.LabVIEW contains three different sets of controls. The “Modern” style is set as the default but you can change this preference in Tools»Options»Front Panel. Since I primarily develop for desktop applications I tend to set my default to be the System controls since they match the operating system that the application is being run on.A quick and easy way to convey more meaning with your buttons is by adding decals.People know that a floppy disk icon means save and a picture of a housecorresponds to a “Home” screen. Using these icons in your application lets theuser almost work on autopilot as their visual brain can recognize the button and not rely on reading every word./watch?v=2NdqXh67makHow to Add Decals to Buttons1.Drop a System OK Button on the front panel.2.Right click on the control and select Advanced»Customize…3.Edit»Import Picture to Clipboard and select your image ‐•PNG files work best since transparency is preserved4.Right click on the control and select Import Picture from Clipboard»Decal5.Click the wrench icon to change customize mode6.Move the decal or the text so they aren’t overlapping7.Save your custom controlReuse tip:If you give your customized control an icon and save it in <LabVIEW>\user.lib it will show up in the controls palette under User Controls.Tooltips are the explanatory text that appears when the mouse hovers over a UI element for a few seconds. There is no better way to help and unsure user figure out exactly what a given button does by popping it up right as they hover over the button in a state of indecision.LabVIEW has this capability built in for all controls./watch?v=NGeElmr1q2gThe default graphs in LabVIEW were designed to look similar to the physical instruments that virtual instruments often replace. Since we are developing for a different type of user –namely the desktop PC use case –we can change the color scheme to better fit the work environment and also help our user with their primary task.In this application I am assuming that the user is trying to identify whether or not a given sine wave violates a simple limit test./watch?v=rOUcBvyHj5EThe LabVIEW toolbar is for you, the LabVIEW developer. It includes all the debugging and editing tools you need to create your application. It is unlikely that your end user cares about these tools and worse yet, the extra buttons may distract and confuse your user. Hiding the toolbar while your application is running is generally a good idea once you know that the application is functioning correctly./watch?v=2CbKuBVGzo0The run‐time menu is the familiar File, Edit, etc menu you see at the top of most Windows applications. LabVIEW has a default run‐time menu with a large set of entries which may or may not be applicable to your user.LabVIEW allows you to easily edit the menu to contain as many or as few of the default options as you wish. You can also add your own menu items and use the event structure to handle the user’s selection./watch?v=wkpiAmHFddMYou can also customize the run‐time shortcut (right click) menus for any control by right‐clicking on the control and going to Advanced»Run‐Time Shortcut Menu»Edit.Grouping infrequently changed options or controls in a separate dialog is a quick, easy, and common way of freeing up space on the main display.Dialogs work best for “set‐and‐forget” type of options that you don’t expect people to regularly interact with or need to reference. They also work well for controls that require lots of contextual information to assist the user in making a decision./watch?v=L‐hNmzQ9tFcCompartmentalizing is a common organizational strategy that groups like objects in their own areas. Just like a workspace or a child’s bedroom ‐‐It’s much easier to keep places tidy if everything has it’s own place.Panes are areas of a front panel that are separated by splitters. By default, front panels start with just one big pane which works great for small, simple applications. For larger or more complex apps I like to separate the front panel into several panes for a few reasons: 1.Panes allow some parts of the front panel to remain in place while other parts scroll ormove.2.Panes can be fixed to either edge of the screen and can have a fixed width or share theavailable screen size proportionally. This makes it much easier to handle differentscreen sizes./watch?v=hZ180R7ADtoAnother advantage of panes is that since a splitter is a GObject we can change it’s position programmatically using VI Server. Using a button, event structure and property node we can give the user the ability to “hide” a panel completely and then bring it back with the click of a mouse.Another special‐use case for panes can be to create a persistent status bar. In the bottom left of your status bar add a string control and simply update the text contained in the status bar via local variable wherever you need to.This simple technique is one of the most effective ways of keeping your user informed as to what state your application is in or what task it is busy performing.Along the lines of keeping the user updated –LabVIEW lets you change the cursor to a busy cursor programmatically. The busy cursor is an OS‐wide UI element that most users are quite familiar with (it means –“wait, I’m trying to do something!”)./watch?v=_mosr‐oTgRMPutting everything together you have a few options for updating the user. Personally I think the best approach is to use all of them! I even include a progress bar if I know how long a given task will take.If you don’t update the cursor or inform the user in some other way you run the risk of your user thinking that clicking a button or performing some other action went unnoticed by your application. Impatient users have a tendency to re‐click or otherwise attempt to force some change (including the dreaded Ctrl‐Alt‐Delete) if they don’t think the application is responding. It is up to you to let them know that everything is OK and that the app is just busy.For really long tasks (longer than a couple of seconds) you might want to add a cancel capability if possible. You don’t want a mis‐click to tie up the application for a long time.The next application we will look at is for a small touch screen display. Here our primary concerns are the small screen size, the need to account for fingers rather than a much more precise mouse cursor and the possibility of glare or direct sunlight impairing the contrast of our display.Again, applying the rules really ensures we think about our requirements.First of all since we want simple, high contrast controls, that more resemble physical buttons the modern control style makes more sense than system in this case.Secondly since the screen real‐estate problem is probably our biggest challenge here. Lets spend some time looking at a creative solution.Tab controls are a common way of displaying multiple pages worth of information. The “tabs” at the top allow the user to see what displays are available and switch between them.Having switchable pages of displays is perfect for our use case since we have such a small screen. However the “tabs” themselves could be problematic since the touch screen might not be accurate enough to press in such small locations reliably.VI Server comes in very handy again here since we can hide the tabs and change the page programmatically.In the demo I use two tab controls. One to contain the sliding menu and one to contain the pages of controls/graphs etc.The sliding menu tab control only has one page and has the tabs hidden. The reason I use the tab control is that it is a convenient container that I can move programmatically.The other tab control has several pages which are changed using VI Server according to which button the user presses in the menu.This is the SubVI which does the sliding. In the demo I use it to move a tab control that contains all the menu buttons but it works with any type of front panel control.The basic premise of the VI is that in order to move an object from it’s initial position to a desired position it moves the object halfway and then iterates until the object gets to the desired location. This approach generates the natural sliding appearance where the object moves quickly at first and then slows down as it stops.Putting the tab control containers, move.vi and an event structure together you have all the elements of the sliding menu. When the menu button is clicked we slide the tab control to the visible position and store the old position in shift register. Then when the user makes a selection we slide the menu tab control back to it’s original position (storing the visible position in the shift register) and switch the main content tab control to the desired page.The last application we will look at today is an informative kiosk display. This type of application has a unique set of demands since there isn’t much user interaction –the primary concern is allowing a user to consume some important information with just a quick glance.We are assuming the information density is fairly low and an attractive appearance is an important consideration in order to attract attention.Just like your computer desktop background you can use an image as the background of your front panel. A well chosen background image can provide context (i.e. “I know this is the pond temperature monitoring VI because I can see the pond in the background”) or visual appeal.On the other hand –too complicated of a background image can be distracting and make important controls and data hard to read. There is rarely an absolute right or wrong in this regard but if you know what LabVIEW is capable of and keep the 3 rules in mind you are in a good place to make your own determination./watch?v=gxXJfonTlFcIn the demo you will see that I used a “busy” background image but still made the controls easy to read by including a semi‐transparent decoration with a nice gradient fill and drop shadows. LabVIEW currently doesn’t have these kind of effects built in but you can easily import images from other applications when you need them.This particular decoration I created in Microsoft PowerPoint and imported into LabVIEW as an image which sits on top of my background image./watch?v=gjYfqhlv2hQAnother default behavior that you may choose to override is the frame applied to all controls and indicators. For most applications the frame is beneficial to separate the controls contents from surrounding labels. The default behavior of white backgrounds for controls and gray backgrounds for indicators is another usability feature that subtly indicates to the user whether or not a given object accepts input or not.If you choose to go without these features you do have that ability. For this particular application we aren’t concerned about users becoming confused about controls vs indicators since it’s a read‐only application./watch?v=jgUB1oDmf‐4The weather icon indicator is a special case of the previous technique. By combining a transparent picture ring control with some transparent PNGs you can create some pretty powerful, nice looking graphics which will add some visual appeal to your application and also increase the usability of your UI by providing instantly recognizable icons for various states./watch?v=AmDLCsnOegwYou’ll also notice the gauge control in our demo doesn’t look anything like the default gauge control.Most of the default controls in LabVIEW can be customized by replacing most of the source imagery using the control editor. Since doing so requires a fair amount of artistic ability and knowledge of external images editors we aren’t going to cover exactly how to create your own controls in this presentation.This particular control is part of the Inspired Control Suite available for download from the community. In the community you can also find a tutorial explaining the details of how to create customized controls.。