Style Guide - Revision history

Logmanoriginal: /* Organization and Names of Files */ Wikify

2025-01-25T13:30:28Z

Organization and Names of Files: Wikify

← Older revision		Revision as of 13:30, 25 January 2025
Line 6:		Line 6:
	The following guidance is applicable to all the items and artifacts that are contained within a LabVIEW Project, including VIs and containers such as Projects, Libraries, and Classes.		The following guidance is applicable to all the items and artifacts that are contained within a LabVIEW Project, including VIs and containers such as Projects, Libraries, and Classes.

	== Organize all files logically ==		;Organize all files logically
			:You should organize directories and files so that someone with a reasonable skill level is able to navigate the directory structure.
	You should organize directories and files so that someone with a reasonable skill level is able to navigate the directory structure.		:
			:If you are consistently working on similar projects, you may want to come up with standards for your projects. The authors of this Guide have seen several different and reasonable directory organizations that were appropriate for different projects, which is why this Guide isn't detailed on this topic.
	If you are consistently working on similar projects, you may want to come up with standards for your projects. The authors of this Guide have seen several different and reasonable directory organizations that were appropriate for different projects, which is why this Guide isn't detailed on this topic.

	== Naming Files and Directories ==		== Naming Files and Directories ==

Logmanoriginal: /* Guidelines for LabVIEW FPGA */ Wikify

2025-01-25T13:29:40Z

Guidelines for LabVIEW FPGA: Wikify

← Older revision		Revision as of 13:29, 25 January 2025
Line 921:		Line 921:
	= Guidelines for LabVIEW FPGA =		= Guidelines for LabVIEW FPGA =

	~~'''~~ Keep in mind that top-level VI controls and indicators are resource intensive ~~'''~~		;Keep in mind that top-level VI controls and indicators are resource intensive
	When you plan how to use FPGA resources, keep in mind that top-level VI controls and indicators are resource intensive.		:When you plan how to use FPGA resources, keep in mind that top-level VI controls and indicators are resource intensive.

	~~'''~~ Handle errors locally on FPGA ~~'''~~		;Handle errors locally on FPGA
	If you use a node that has an error output, include code to handle the error immediately.		:If you use a node that has an error output, include code to handle the error immediately.
			:
			:''Details:''
			:* Localized error handling in FPGAs typically results in lower FPGA resource utilization because the error cluster in FPGA consists of 33 bits, one bit for status and 32 for the error code. You can often reduce 33 bits down to one.

	~~''Details~~:''		;Avoid writing to hardware outputs inside Case structures in timed loops
	- ~~Localized error handling in FPGAs typically results in lower FPGA resource utilization because the error cluster in FPGA consists of 33 bits~~, ~~one bit~~ for ~~status~~ and ~~32 for~~ the ~~error code. You can often reduce 33 bits down to one~~.		:Avoid writing to hardware outputs inside a Case structure, especially when inside a single-cycle Timed Loop. Instead, explicitly define hardware outputs for each case and write to hardware outputs outside the Case structure.

	''~~' Avoid writing to hardware outputs inside Case structures in timed loops '~~''		;Monitor DMA FIFO timeouts
	~~Avoid writing to hardware outputs inside~~ a ~~Case structure, especially when inside~~ a ~~single-cycle Timed Loop~~. ~~Instead~~, ~~explicitly define hardware outputs for each case~~ and ~~write~~ to ~~hardware outputs outside the Case structure~~.		:Monitor the timeout output of DMA FIFO reads and writes and respond accordingly.
			:
			:''Details:''
			:* Also monitor the timeout output of target-scoped FIFOs unless you either do not care if a timeout occurs or are certain a timeout will never occur.
			:* To handle the length of timeouts, either latch the output and notify the host that the FPGA should be restarted to ensure data integrity or use a handshaking protocol to handle resending data.

	~~''' Monitor DMA FIFO timeouts '''~~		;Use 4-Wire handshaking protocol where applicable
	~~Monitor~~ the ~~timeout~~ output ~~of DMA FIFO reads and writes~~ and ~~respond accordingly~~.		:Use 4-Wire handshaking anywhere appropriate, and be sure to label the wires, such as "input valid," "ready for output," "output valid," and "ready for input".

	~~''Details:''~~		;Convert fractional data types to single precision before sending to host
	~~- Also monitor the timeout output of target-scoped FIFOs unless you either do not care if a timeout occurs or are certain a timeout will never occur.~~		:Consider converting fractional data types to the single data type before passing them up to the host.
	~~- To handle the length of timeouts, either latch the output and notify the host that the FPGA should be restarted to ensure data integrity or use a handshaking protocol to handle resending data.~~

	~~''' Use 4-Wire handshaking protocol where applicable '''~~
	~~Use 4-Wire handshaking anywhere appropriate, and be sure to label the wires, such as "input valid," "ready for output," "output valid," and "ready for input".~~

	~~'''~~ Convert fractional data types to single precision before sending to host ~~'''~~
	Consider converting fractional data types to the single data type before passing them up to the host.

	== FPGA Host Interface ==		== FPGA Host Interface ==

	~~'''~~ Call the Reset and Run methods explicitly ~~'''~~		;Call the Reset and Run methods explicitly
	Consider calling the Reset and Run methods specifically instead of automatically running the VI from the Open FPGA Reference function. This ensures the FPGA is in a known state before it executes.		:Consider calling the Reset and Run methods specifically instead of automatically running the VI from the Open FPGA Reference function. This ensures the FPGA is in a known state before it executes.

	~~''' Avoid reallocating memory or polling the CPU when reading from DMA FIFOs '''~~
	~~When reading from DMA FIFOs, do not reallocate memory or poll the CPU~~.

	''Details:''		;Avoid reallocating memory or polling the CPU when reading from DMA FIFOs
	- Consider using the Configure method to set an appropriate host-side buffer. Avoid using large FPGA size buffers when possible to preserve block RAM.		:When reading from DMA FIFOs, do not reallocate memory or poll the CPU.
	- Set the DMA Read timeout to 0.		:
	- Read a fixed-size number of elements (a multiple of the number of data channels).		:''Details:''
	- Wait until the buffer is full before reading elements.		:* Consider using the Configure method to set an appropriate host-side buffer. Avoid using large FPGA size buffers when possible to preserve block RAM.
			:* Set the DMA Read timeout to 0.
			:* Read a fixed-size number of elements (a multiple of the number of data channels).
			:* Wait until the buffer is full before reading elements.

	~~'''~~ Use the Dynamic reference type for FPGA APIs ~~'''~~		;Use the Dynamic reference type for FPGA APIs
	Use the Dynamic reference type when creating an API that communicates with an FPGA.		:Use the Dynamic reference type when creating an API that communicates with an FPGA.

	= Appendix A: Book Title Case =		= Appendix A: Book Title Case =

Logmanoriginal: /* Guidelines for LabVIEW RT */ Wikify

2025-01-25T13:28:26Z

Guidelines for LabVIEW RT: Wikify

← Older revision		Revision as of 13:28, 25 January 2025
Line 849:		Line 849:
	= Guidelines for LabVIEW RT =		= Guidelines for LabVIEW RT =

	~~'''~~ Use while loops for non-deterministic tasks ~~'''~~		;Use while loops for non-deterministic tasks
	Whenever possible, use while loops, not timed loops, for non-deterministic tasks.		:Whenever possible, use while loops, not timed loops, for non-deterministic tasks.

	~~'''~~ Use the term "deterministic" instead of "time critical" ~~'''~~		;Use the term "deterministic" instead of "time critical"
	In your documentation, use the term "deterministic" instead of "time critical" to describe code running in timed loops. The term "time critical" is commonly recognized as a VI priority you can use to schedule parallel tasks.		:In your documentation, use the term "deterministic" instead of "time critical" to describe code running in timed loops. The term "time critical" is commonly recognized as a VI priority you can use to schedule parallel tasks.

	~~'''~~ Use timed structures instead of deterministic priority setting on SubVIs ~~'''~~		;Use timed structures instead of deterministic priority setting on SubVIs
	Whenever possible, use timed structures instead of a deterministic priority setting on SubVIs.		:Whenever possible, use timed structures instead of a deterministic priority setting on SubVIs.

	~~'''~~ Serialize code within timed structures ~~'''~~		;Serialize code within timed structures
	Serialize code within timed structures so that it executes in a defined, sequential order.		:Serialize code within timed structures so that it executes in a defined, sequential order.

	~~'''~~ Use inline property for VIs in timed structures ~~'''~~		;Use inline property for VIs in timed structures
	To minimize subVI overhead, use the inline property for VIs in timed structures.		:To minimize subVI overhead, use the inline property for VIs in timed structures.

	~~'''~~ Use subroutine priority with Skip Subroutine Call If Busy ~~'''~~		;Use subroutine priority with Skip Subroutine Call If Busy
	When you use subVIs in timed loops that access a shared resource, consider using subroutine priority and the Skip Subroutine Call If Busy setting.		:When you use subVIs in timed loops that access a shared resource, consider using subroutine priority and the Skip Subroutine Call If Busy setting.
			:
			:''Tip:''
			:* To turn on Skip Subroutine Call If Busy on a subVI, right-click on the subVI and select the menu option.

	~~''Tip~~:''		;Avoid placing controls or indicators in timed loops
	- ~~To turn on Skip Subroutine Call If Busy on a subVI, right-click on the subVI and select the menu option~~.		:Avoid placing controls or indicators within timed loops because they execute slowly and non-deterministically.

	~~''' Avoid placing controls or indicators~~ in timed loops ~~'''~~		;Merge errors properly in timed loops
	~~Avoid placing controls or indicators within~~ timed loops ~~because they execute slowly and non-deterministically~~.		:With timed loops, merge inner left ear error with error input to catch any configuration errors. Also, merge outer right ear error with error outputs.

	~~''' Merge errors properly~~ in ~~timed loops '''~~		;Use the Select function instead of a Case structure in deterministic code
	~~With timed loops~~, ~~merge inner left ear error with error input to catch any configuration errors~~. ~~Also, merge outer right ear error with error outputs~~.		:If possible, use the Select function instead of a Case structure in deterministic code. The Select function provides greater determinism.

	~~''' Use the Select function instead of a Case structure in deterministic code '''~~		;Check time-critical loops for lateness
	~~If possible, use the Select function instead of a Case structure in deterministic code. The Select function provides greater determinism.~~		:Check all time-critical loops for lateness.

	~~'''~~ Check time-critical loops for lateness ~~'''~~
	Check all time-critical loops for lateness.

	== Handling Data Guidelines ==		== Handling Data Guidelines ==

	~~'''~~ Optimize file I/O performance by establishing appropriate chunk sizes ~~'''~~		;Optimize file I/O performance by establishing appropriate chunk sizes
	If file I/O performance matters, establish the best chunk size for writing and reading. Note that this may vary by target.		:If file I/O performance matters, establish the best chunk size for writing and reading. Note that this may vary by target.

	~~'''~~ Use RT FIFO functions for streaming data ~~'''~~		;Use RT FIFO functions for streaming data
	Use RT FIFO functions instead of RT FIFO-enabled Shared Variables for streaming data. However, you can use RT FIFO-enabled shared variables for current value communication.		:Use RT FIFO functions instead of RT FIFO-enabled Shared Variables for streaming data. However, you can use RT FIFO-enabled shared variables for current value communication.

	~~'''~~ Use the Flush File function to handle critical data ~~'''~~		;Use the Flush File function to handle critical data
	For critical data, use the Flush File function to flush the file frequently. Reliance and FAT only flush once per second.		:For critical data, use the Flush File function to flush the file frequently. Reliance and FAT only flush once per second.

	~~'''~~ Limit size and quantity of log files ~~'''~~		;Limit size and quantity of log files
	Limit the size and quantity of log files to improve system reliability. A directory with a large and growing number of files can grow slow and demonstrate changes in system behavior. As a result, you may encounter unexpected behavior.		:Limit the size and quantity of log files to improve system reliability. A directory with a large and growing number of files can grow slow and demonstrate changes in system behavior. As a result, you may encounter unexpected behavior.

	== Initialization and Shutdown Guidelines ==		== Initialization and Shutdown Guidelines ==

	~~'''~~ Implement shutdown code to stop initialized resources ~~'''~~		;Implement shutdown code to stop initialized resources
	Implement shutdown code to stop anything initialized, even if the next step calls for a reboot.		:Implement shutdown code to stop anything initialized, even if the next step calls for a reboot.

	~~'''~~ Avoid writing to configuration files from within the application ~~'''~~		;Avoid writing to configuration files from within the application
	Avoid writing to configuration files from within the application. Writing to configuration files can corrupt the file and prevent you from properly initializing the next reboot. If you must write to a configuration file, develop a strategy to recover from or limit the damage of corruption.		:Avoid writing to configuration files from within the application. Writing to configuration files can corrupt the file and prevent you from properly initializing the next reboot. If you must write to a configuration file, develop a strategy to recover from or limit the damage of corruption.

	~~'''~~ Place reboot code in a conditional disable structure ~~'''~~		;Place reboot code in a conditional disable structure
	Place code that reboots a controller in a conditional disable structure so you can easily disable the reboot at the end of a program. If you place reboot code in a conditional disable structure, you can disable the code when debugging and enable the code when deploying the application.		:Place code that reboots a controller in a conditional disable structure so you can easily disable the reboot at the end of a program. If you place reboot code in a conditional disable structure, you can disable the code when debugging and enable the code when deploying the application.

	== Miscellaneous ==		== Miscellaneous ==

	~~'''~~ Use RT Timing palette for real-time timing ~~'''~~		;Use RT Timing palette for real-time timing
	Use Timing VIs from the Real-Time>RT Timing palette instead of the ones from the Programming>Timing palette.		:Use Timing VIs from the Real-Time>RT Timing palette instead of the ones from the Programming>Timing palette.

	~~''' Monitor processor and memory usage from development through deployment '''~~
	~~Monitor the processor and memory usage for the system from development through deployment~~.

	''Details:''		;Monitor processor and memory usage from development through deployment
	- Ensure processor usage does not stay high long enough to cause unacceptable thread starvation when a thread does not get time to execute.		:Monitor the processor and memory usage for the system from development through deployment.
	- Verify that memory usage does not grow continually and that a plan exists to recover in case memory usage does grow continuously.		:
			:''Details:''
			:* Ensure processor usage does not stay high long enough to cause unacceptable thread starvation when a thread does not get time to execute.
			:* Verify that memory usage does not grow continually and that a plan exists to recover in case memory usage does grow continuously.

	= Guidelines for LabVIEW FPGA =		= Guidelines for LabVIEW FPGA =

Logmanoriginal: /* Programming VI Block Diagrams */ Wikify

2025-01-25T13:26:17Z

Programming VI Block Diagrams: Wikify

Show changes

Logmanoriginal: /* Control and Indicator Labels/Captions */ Fix anchor link

2025-01-25T13:08:01Z

Control and Indicator Labels/Captions: Fix anchor link

← Older revision		Revision as of 13:08, 25 January 2025
Line 353:		Line 353:
	:		:
	:''Details:''		:''Details:''
	:* Refer to [[#Appendix B: ~~The~~ International System of Units\|Appendix B: ~~The~~ International System of Units]] for a list of conventional units.		:* Refer to [[#Appendix B: International System of Units\|Appendix B: International System of Units]] for a list of conventional units.

	;Use "Size to Text" for labels		;Use "Size to Text" for labels

Logmanoriginal: /* VI, Library, and Class Interfaces */ Wikify

2025-01-25T13:07:13Z

VI, Library, and Class Interfaces: Wikify

Show changes

Logmanoriginal: /* VI Window Considerations */ Wikify

2025-01-25T12:39:41Z

VI Window Considerations: Wikify

← Older revision		Revision as of 12:39, 25 January 2025
Line 145:		Line 145:
	= VI Window Considerations =		= VI Window Considerations =

	== Size the windows so the entire toolbar fits ==		;Size the windows so the entire toolbar fits
	(VI Analyzer) Size the windows so the entire toolbar fits.		:([[VI Analyzer]]) Size the windows so the entire toolbar fits.
			:
			:''Tip:''
			:* Use front panel cleanup to comply with this guideline for front panels. Use Arrange VI Window Quick Drop (Ctrl-Space, Ctrl-F) to comply with this guideline for block diagrams.

	''Tip:''		;Size front panels and block diagram windows appropriately
	~~- Use front panel cleanup to comply with this guideline for front panels.~~ Use Arrange VI Window Quick Drop (Ctrl-Space, Ctrl-F) to comply with this guideline ~~for block diagrams~~.		:Size the front panel and block diagram windows reasonably for the content and never full-screen.
			:
			:''Tip:''
			:* Use Arrange VI Window Quick Drop (Ctrl-Space, Ctrl-F) to comply with this guideline.

	~~== Size front~~ panels ~~and block diagram windows appropriately ==~~		;Consider sizing panels with tall type definitions
	~~Size~~ the ~~front~~ panel and ~~block diagram windows reasonably for~~ the ~~content and never full-screen~~.		:If a front panel contains a tall type definition cluster, consider sizing the panel to fit existing regular controls and include part of the type definition.
			:
			:[[File:Items.png\|frameless]]

	~~''Tip~~:''		;Include wide type definition clusters in the panel
	~~- Use Arrange VI Window Quick Drop (Ctrl-Space~~, ~~Ctrl-F)~~ to ~~comply with this guideline~~.		:If a front panel contains a wide type definition cluster, consider including the cluster below the visible screen and a note indicating that the user can scroll down to see it.
			:[[File:Items wide.gif\|frameless]]

	~~== Consider sizing panels with tall type definitions ==~~		;Entire block diagram should fit on the monitor
	~~If a front panel contains a tall type definition cluster, consider sizing the panel to fit existing regular controls and include part of the type definition.~~		:The entire block diagram of a VI should fit on the monitor.
			:
	~~[[File:Items.png\|thumb]]~~		:''Details:''
			:* If this guideline is impossible to comply with, write the block diagram so you can read it scrolling in only one direction.
	~~== Include wide type definition clusters in the panel ==~~
	~~If a front panel contains a wide type definition cluster, consider including the cluster below the visible screen and a note indicating that the user can scroll down to see it.~~
	~~[[File:Items wide.gif\|thumb]]~~

	== Entire block diagram should fit on the monitor ==
	The entire block diagram of a VI should fit on the monitor.

	''Details:''
	- If this guideline is impossible to comply with, write the block diagram so you can read it scrolling in only one direction.

	= VI, Library, and Class Interfaces =		= VI, Library, and Class Interfaces =

Logmanoriginal: /* Monitor Size, Window Size, and Window Placement */ Fix wikilink

2025-01-25T12:36:31Z

Monitor Size, Window Size, and Window Placement: Fix wikilink

← Older revision		Revision as of 12:36, 25 January 2025
Line 133:		Line 133:
	:''Details:''		:''Details:''
	:* If you have a computer running Windows 10, 1536 x 824 pixels corresponds to 1920 x 1080 pixel resolution with 125% scaling. These are often default settings on a 15" laptop.		:* If you have a computer running Windows 10, 1536 x 824 pixels corresponds to 1920 x 1080 pixel resolution with 125% scaling. These are often default settings on a 15" laptop.
	:* With properly configured [[LabVIEW.ini]] tokens you can use the [[Arrange VI Window ~~(Quick Drop)~~]] Quick Drop (Ctrl-Space, Ctrl-F) to make sure your VI front panel and block diagram windows comply with this guideline.		:* With properly configured [[LabVIEW.ini]] tokens you can use the [[Arrange VI Window]] Quick Drop (Ctrl-Space, Ctrl-F) to make sure your VI front panel and block diagram windows comply with this guideline.
	:* VIWin.DisplayWorkspaceRight=1536		:* VIWin.DisplayWorkspaceRight=1536
	:* VIWin.DisplayWorkspaceBottom=824		:* VIWin.DisplayWorkspaceBottom=824

Logmanoriginal: /* Monitor Size, Window Size, and Window Placement */ Wikify

2025-01-25T12:34:27Z

Monitor Size, Window Size, and Window Placement: Wikify

← Older revision		Revision as of 12:34, 25 January 2025
Line 128:		Line 128:
	= Monitor Size, Window Size, and Window Placement =		= Monitor Size, Window Size, and Window Placement =

	* Code should look good on a 1536 x 824 monitor: Write code so that it looks good on a monitor with 1536 x 824 pixels for most individual file windows, or the target monitor size if designing a UI front panel.		;Code should look good on a 1536 x 824 monitor
			: Write code so that it looks good on a monitor with 1536 x 824 pixels for most individual file windows, or the target monitor size if designing a UI front panel.
			:
			:''Details:''
			:* If you have a computer running Windows 10, 1536 x 824 pixels corresponds to 1920 x 1080 pixel resolution with 125% scaling. These are often default settings on a 15" laptop.
			:* With properly configured [[LabVIEW.ini]] tokens you can use the [[Arrange VI Window (Quick Drop)]] Quick Drop (Ctrl-Space, Ctrl-F) to make sure your VI front panel and block diagram windows comply with this guideline.
			:* VIWin.DisplayWorkspaceRight=1536
			:* VIWin.DisplayWorkspaceBottom=824

	~~''Details:''~~		;Save files with minimal white space
	* If you have a computer running Windows 10, 1536 x 824 pixels corresponds to 1920 x 1080 pixel resolution with ~~125% scaling. These are often default settings on a 15" laptop.~~		:Save files so all relevant content that can be shown is shown without showing a lot of extraneous white space.
	* With properly configured LabVIEW.ini tokens you can ~~use the Arrange VI Window Quick Drop (Ctrl-Space, Ctrl-F) to make sure your VI front panel and block diagram windows comply with this guideline.~~
	* VIWin.DisplayWorkspaceRight=1536
	* VIWin.~~DisplayWorkspaceBottom=824~~

	~~== Save files with minimal white space ==~~		;Position window near the upper-left corner of the monitor
	~~Save files so all relevant content that can be shown is shown without showing a lot of extraneous white space.~~		:Save files so the upper left corner of the window is close to the upper left corner of the monitor.

	== Position window near the upper-left corner of the monitor ==
	Save files so the upper left corner of the window is close to the upper left corner of the monitor.

	= VI Window Considerations =		= VI Window Considerations =

Logmanoriginal: /* LabVIEW Classes */ Wikify

2025-01-25T12:31:06Z

LabVIEW Classes: Wikify

← Older revision		Revision as of 12:31, 25 January 2025
Line 99:		Line 99:
	== LabVIEW Classes ==		== LabVIEW Classes ==

	~~'''~~ Name all classes as nouns ~~'''~~		;Name all classes as nouns
	''Example:''		:''Example:''
	- Name an example class Waveform Reader.lvclass rather than Reads Waveforms.lvclass.		:* Name an example class <code>Waveform Reader.lvclass</code> rather than <code>Reads Waveforms.lvclass</code>.

	~~'''~~ Name all member VIs of a LabVIEW class as verbs ~~'''~~		;Name all member VIs of a LabVIEW class as verbs
	''Example:''		:''Example:''
	- Name an example member VI Read Value.vi rather than Value.vi.		:* Name an example member <code>VI Read Value.vi</code> rather than <code>Value.vi</code>.

	~~'''~~ Avoid including the name of the class in VI names ~~'''~~		;Avoid including the name of the class in VI names
	''Example:''		:''Example:''
	- If we have a class ''Circle'' and it needs a VI to return the area, this VI should just be called ''Calculate Area'' as opposed to ''Calculate Circle Area'' or ''Circle Calculate Area.'' Note that LabVIEW provides a namespace for VIs in a library such that it is considered as ''Circle: Calculate Area.''		:* If we have a class <code>Circle</code> and it needs a VI to return the area, this VI should just be called <code>Calculate Area</code> as opposed to <code>Calculate Circle Area</code> or <code>Circle Calculate Area</code>. Note that LabVIEW provides a namespace for VIs in a library such that it is considered as <code>Circle.lvclass:Calculate Area.vi</code>.

	~~'''~~ Use "Read" for VIs that read data ~~'''~~		;Use "Read" for VIs that read data
	Use the word "Read" to begin the name of any VI that strictly reads data from the private data of a class. Avoid using the word "Get" or any synonym of "Get."		:Use the word "Read" to begin the name of any VI that strictly reads data from the private data of a class. Avoid using the word "Get" or any synonym of "Get".

	~~'''~~ Use "Write" for VIs that bundle data into the private data ~~'''~~		;Use "Write" for VIs that bundle data into the private data
	Use the word "Write" to begin the name of any VI that strictly bundles data into the private data of a class. Avoid using the word "Set" or any synonym of "Set."		:Use the word "Write" to begin the name of any VI that strictly bundles data into the private data of a class. Avoid using the word "Set" or any synonym of "Set".

	~~'''~~ Use Book Title Case for class virtual folders and VI names ~~'''~~		;Use Book Title Case for class virtual folders and VI names
	Use Book Title Case for all class virtual folders and VI names.		:Use Book Title Case for all class virtual folders and VI names.
			:
	''Details:''		:''Details:''
	- When auto-created by LV, the class property virtual folder name and the class property VI names may initially match the case of the control label in the class control. Since labels should follow the label guidelines listed in section ~~3.1.8~~, you may need to change the class property virtual folder and VI names to be Book Title Case.		:* When auto-created by LabVIEW, the class property virtual folder name and the class property VI names may initially match the case of the control label in the class control. Since labels should follow the label guidelines listed in section [[#Control and Indicator Labels/Captions\|Control and Indicator Labels/Captions]], you may need to change the class property virtual folder and VI names to be Book Title Case.
	- The name of a class property virtual folder is used as the name in a class property node.		:* The name of a class property virtual folder is used as the name in a class property node.
	- Because this is auto-generated by LV and may be tedious to change, this guideline is a recommendation at this time.		:* Because this is auto-generated by LV and may be tedious to change, this guideline is a recommendation at this time.
	- A LabVIEW Developer tool may be created that will correct the auto-generated virtual folder and VI names to match these guidelines.		:* A LabVIEW Developer tool may be created that will correct the auto-generated virtual folder and VI names to match these guidelines.

	= Monitor Size, Window Size, and Window Placement =		= Monitor Size, Window Size, and Window Placement =