QtVCP Widgets

This widget allows the user to check a box to set a HAL pin true or false.

It is based on PyQt’s QCheckButton.

This container widget works just like a QTabWidget -it displays multiple panels one at a time with tabs to select.
If you double click the tab or drag the tab, the tab will detach from the main window.
When a tab is detached, the contents are placed into a QDialog.
The tab can be re-attached by closing the dialog or by double clicking on its window frame.

It is based on PyQt’s QTabWidget

This widget is a spin button entry widget used for setting a s32 and float HAL pin.

It has an internal scale factor, set to a default of 1, that can be set programmatically or using a QtSignal.

The setInput slot can be connected to an integer, or a float signal.

The HAL pins will be set to the value of the internal scale times the widget displayed value.

This widget places a colored overlay over the screen, usually while a dialog is showing.

Used to create a focused feel and to draw attention to critical information.

It can also show a translucent image.
It can also display message text and buttons.

This widget can be controlled with STATUS messages.

Round Gauge can be used in a LinuxCNC GUI to display an input parameter on the dial face.

There are several properties that are user settable in order to customize the appearance of the gauge.

The following parameters can be set either programmatically or via the Qt Designer property editor.

There are 2 inputs that are not customizable. They can be set via HAL pins, programmatically or via signals from other widgets:

This widget is used to connect an arbitrary Qt widget to HAL using signals/slots.

It is used for widgets that should respond to HAL pin changes.

This widget is used to connect an arbitrary Qt widget to HAL using signals/slots.

It is used for widgets that should control HAL pins.

This widget controls if the widgets inside it are enabled or disabled.

Disabled widgets typically have a different color and do not respond to actions.

It is based on PyQt’s QGridLayout.

This widget is used to indicate level or value, usually of a HAL s32/float pin.
You can also disable the HAL pin and use Qt signals or Python commands to change the level.

This widget looks and acts like a 5 buttons D-pad, with an LED ring.

Each button has an selectable type (Bit, S32 or Float) output HAL pin.

The LED center ring has selectable colors for off and on and is controlled by a bit HAL pin.

There are enumerated constants used:

You use the widget name in Qt Designer plus the reference constant:

The above properties could be set in styles sheets.

This widget displays values sent to it.

Values can be sent from:

There is a textTemplate property to set the rich text and/or to format the text.
Basic formatting might be:

A rich text example might be:

The setDisplay slot can be connected to an integer, a float or a bool signal.

If the property pin_name is not set the widget name will be used.

There are function calls to display values:

It is based on PyQt’s QLabel.

This widget displays HAL float/s32/bit values in a LCD looking way.

It can display numbers in decimal, hexadecimal, binary and octal formats by setting the mode property.

When using floats you can set a formatting string.

You must set the digitCount property to an appropriate setting to display the largest number.

It is based on PyQt’s QLCDNumber.

A LED like indicator that optionally follows a HAL pin’s logic.

The LED properties can be defined in a stylesheet with the following code added to the .qss file, name_of_led being the widget name defined in Qt Designer’s editor:

This widget allows a user to set a HAL pin true or false with the push of a button.

As an option it can be a toggle button.

For a LED Indicator Option, see [sub:qtvcp:widgets:indicatedpushbutton][IndicatedPushButton] below for more info.

It also has other options.

It is based on PyQt’s QPushButton.

This widget allows a user to set HAL pins true or false. Only one RadioButton widget of a group can be true at a time.

It is based on PyQt’s QRadioButton.

Allows one to adjust a HAL pin value using a sliding pointer.

This widget allows the tab height to be adjusted with stylesheets

The TabWidget properties can be defined in a stylesheet with the following code added to the .qss file.
name_of_tab being the widget name defined in Qt Designer’s editor.
If you omit the #name_of_tab text, all TabWidgets tab height will be set.
This shows how to set a particular widget’s tab height:

It is based on PyQt’s QTabWidget

This is used to switch the view of a multi-widget layout to show just one widget, i.e. to flip between a large view of a widget and a smaller multi widget view.

It is different from a stacked widget as it can pull a widget from anywhere in the screen and place it in its page with a different layout than it originally had.

The original widget must be in a layout for switcher to put it back.

In Qt Designer you will:

There are function calls to display specific widgets.
By calling one of these functions, you control what widget is currently displayed:

It is based on the QStack widget.

Allows one to embed a program into the widget.

Only programs that utilize the xembed protocol will work such as:

These buttons are used for control actions on the machine controller.

They are built on top of IndicatedPushButton so can have LEDs overlaid.

You can select one of these:

These set attributes of the selected action (availability depends on the widget):

Action buttons are subclassed from [sub:qtvcp:widgets:indicatedpushbutton][IndicatedPushButton]. See the following sections for more information about:

ActionToolButton buttons are similar in concept to action buttons, but they use QToolButtons to allow for optional actions to be selected by pushing and holding the button till the option menu pops up.

Currently there is only one option: userView.

It is based on PyQt’s QToolButton.

User View tool button allows to record and return to an arbitrary graphics view.

Press and hold the button to have the menu pop up and press record view to record the currently displayed graphics view.

Click the button normally to return to the last recorded position.

The recorded position will be remembered at shutdown if a preference file option is set up.

This allows one to select and set an axis.

If the button is set checkable, it will indicate which axis is selected.

If you press and hold the button a pop up menu will show allowing one to:

You must have selected an entry dialog widget that corresponds to the dialog_code_string, usually this is selected from the screenOptions widget.

These are the click-and-hold menu properties:

Here is a sample stylesheet entry:

It is based on PyQt’s QToolButton.

Widget for probing on a mill. Used by the QtDragon screen.

This widget displays a image from a web camera.

It overlays an adjustable circular and cross hair target over the image.

CamView was built with precise visual positioning in mind.

This is used to align the work piece or zero part features using a webcam.

It uses OpenCV vision library.

This will display the current position of an axis.
You can also click on the label and see a list of actions.

These are the click-on-menu options:

The DROLabel widget holds a property isHomed that can be used with a stylesheet to change the color of the DRO_Label based on homing state of the joint number in LinuxCNC.

Here is a sample stylesheet entry that:

Here is how you specify a particular widget by its objectName in Qt Designer:

It is based on PyQt’s QLabel.

This widget is used to select files to load.

It has a the ability to scroll the names with hardware such as a MPG.

One can class patch the function load(self,fname) to customize file loading.

The function getCurrentSelected() will return a Python tuple, containing the file path and whether it is a file.

It is based on PyQt’s FIXME

This displays G-code in text form, highlighting the currently running line.

This can also display:

It has a signal percentDone(int) that can be connected to a slot (such as a progressBar to display percent run).

The GcodeDisplay properties can be set in a stylesheet with the following code added to the .qss file (the following color choices are random).

For GcodeDisplay widget’s default G-code lexer:

Font definitions:

It is based on PyQt’s QsciScintilla.

This is an extension of the GcodeDisplay widget that adds editing convenience.

It is based on PyQt’s QWidget which incorporates GcodeDisplay widget.

This displays the current G-code in a graphical form.

The ACTION library can control the G-code graphics widget.

It is based on PyQt’s OpenGL widget.

FIXME JointEnableWidget documentation

This widget allows the user to select jog increment values for jogging.

The jogging values come from the INI file under:

This will be available to all widgets through STATUS.

You can select linear or angular increments by the property linear_option in Qt Designer property editor.

It is based on PyQt’s ComboBox.

This widget allows a user to select and adjust special macro programs for doing small jobs.

It uses images for visual representation of the macro and for an icon.

It searches for special macros using the INI definition:

The macros are O-word subroutines with special comments to work with the launcher. The first three lines must have the keywords below, the fourth is optional.

Here is a sample for the first four lines in an O-word file:

This is the first line in the O-word file.

It is a comma separated list of text to display above an entry.
There will be one for every variable required in the O-word function.

If the macro does not require variables, leave it empty:

This must be the second line in the O-word file.

It is a comma separated list of the default values for each variable in the O-word function.

If you use the word true or false in the list, a *checkbutton* will be shown.

This must be the third line in the O-word file.

If the keyword is present but the entries are missing, no images will be used.

This optional line must be the fourth line in the O-word file.

It is a comma separated list of keyword and data:

One can enter MDI commands here.

A popup keyboard is available.

There are also embedded commands available from this widget.

Enter any of these case sensitive commands to load the respective program or access the feature:

It is based on PyQt’s QLineEdit.

Displays a scrollable list of past MDI command.

An edit line is embedded for MDI commands. The same MDILine embedded commands may be accessed from this widget.

The history is recorded on a file defined in the INI under the heading [DISPLAY] (this shows the default):

This widget displays buttons and entry lines to use for entering MDI commands.

Based on LinuxCNC’s Touchy screen’s MDI entry process, its large buttons are most useful for touch screens.

To use MDITouchy:

The widget requires an explicit call to MDITouchy Python code to actually run the MDI command:

The macro button cycles though macros defined in the INI [DISPLAY] heading.

Add one or more MACRO lines of the following format:

In the example below, increment is the name of the macro, and it accepts two parameters, named xinc and yinc.

Now, place the macro in a file named macro_name.ngc in the PROGRAM_PREFIX directory, or into any directory in the SUBROUTINE_PATH specified in the INI file.

Keeping on with the example above, it would be named increment.ngc and its content could look like:

Notice the name of the sub matches the file name and macro name exactly, including case.

When you invoke the macro by pressing the Macro button you can enter values for parameters (xinc and yinc in our example).
These are passed to the macro as positional parameters: #1, #2… #N respectively.
Parameters you leave empty are passed as value 0.

If there are several different macros, press the Macro button repeatedly to cycle through them.

In this simple example, if you enter -1 for xinc and invoke the running of the MDI cycle, a rapid G0 move will be invoked, moving one unit to the left.

This macro capability is useful for edge/hole probing and other setup tasks, as well as perhaps hole milling or other simple operations that can be done from the panel without requiring specially-written G-code programs.

This widget allows one to visualize and modify User System Origin offsets directly.

It will update LinuxCNC’s Parameter file for changes made or found.

The settings can only be changed in LinuxCNC after homing and when the motion controller is idle.

The display and entry will change between metric and imperial, based on LinuxCNC’s current G20 / G21 setting.

The current in-use user system will be highlighted.

Extra actions can be integrated to manipulate settings.
These actions depend on extra code added either to a combined widget, like originoffsetview dialog, or the screens handler code.
Typical actions might be Clear Current User offsets or Zero X.

Clicking on the columns and rows allows one to adjust the settings.

A dialog can be made to popup for data or text entry.

The comments section will be recorded in the preference file.

It is based on PyQt’s QTableView, QAbstractTableModel, and ItemEditorFactory.
Properties, functions and styles of the PyQt base objects are always available.

OriginOffsetView has the following properties:

These can be set in:

FIXME RadioAxisSelector documentation

Round buttons work the same as ActionButtons other than the button is cropped round.

They are intended only to be visually different.

They have two path properties for displaying images on true and false.

This will display a label based on the machine controller modes true/false states.

You can select between different texts based on true or false.

The states are selectable via these properties:

It is based on PyQt’s QLabel.

This will display a label based on selectable status of the machine controller.
You can change how the status will be displayed by substituting Python formatting code in the text template. You can also use rich text for different fonts/colors etc.

These states are selectable:

It is based on PyQt’s QLabel.

Status image switcher will switch between images based on LinuxCNC states.

Here is an example of using it to display an icon of Z axis homing state:

In the properties section notice that:

If you double click the image_list a dialog will show and allow you to add image paths to.

If you have one image as an icon and one clear image then that will look like it shows and hides the icon.

Selecting image paths can be done by selecting the pixmap property and selecting an image.

Do that again for the next image.
Use a clear image to represent a hidden icon.

You can test the images display from the image list by changing the image number. In this case 0 is unhomed and 1 would be homed.
This is for test display only and will be ignored outside of Qt Designer.

This widget displays one of three panels based on LinuxCNC’s mode.

This allows you to automatically display different widgets on Manual, MDI and Auto modes.

It is based on PyQt’s QStacked widget.

This widget doesn’t add anything visually to a screen but sets up important options.

This is the preferred way to use these options.

These properties can be set in Qt Designer, in Python handler code or (if appropriate) in stylesheets.

These include:

The screen designer chooses the default settings of the screenOptions widget.

Once chosen, most won’t ever need to be changed. But if needed, some can be changed in the handler file or in stylesheets.

Some settings are only checked on startup so will not cause changes after startup. In these cases you would need to make the changes in Qt Designer only.

If the preference file option is selected, screenOption widget will make an INI based preference file.

While other QtVCP widgets will add to this list, the screenOptions widget will add these entries under the following headings:

This widget allow the user to adjust a LinuxCNC setting via a slider.

The widget can adjust:

StatusSlider has the following properties:

These can be set in:

It is based on PyQt’s QSlider.

This widget gives status on the selected LinuxCNC state.

The state options are:

There are properties that can be changed:

The LED properties can be defined in a stylesheet with the following code added to the .qss file.

It is based on the LED widget.

This widget allows setting values using buttons while displaying a bar.

It also has an optional hi/low toggle button that can be held down to set the levels.

The widget can adjust:

It is based on PyQt’s QProgressBar.

This widget allows you to manually select a G5x user system by pressing and holding.

If you don’t set the button text it will automatically update to the current system.

It is based on PyQt’s QToolButton.

This is a container that other widgets can be placed in.

Embedded widgets are be greyed-out when the StateEnableGridlayout is disabled.

It can selectably react to:

It is based on PyQt’s QGridLayout.

This widget will display images based on LinuxCNC status.

You can watch:

It is based on PyQt’s FIXME

This widget displays and allows one to modify tools offsets.

It will update LinuxCNC’s tool table for changes made or found.

The tool settings can only be changed in LinuxCNC after homing and when the motion controller is idle.

The display and entry will change between metric and imperial based on LinuxCNC’s current G20/G21 setting.

The current in-use tool will be highlighted, and the current selected tool will be highlighted in a different color.

The checkbox beside each tool can be used to select too for an action that depends on extra code added either to a combined widget, like the toolOffsetView dialog or the screens handler code.
Typical actions are load selected tool, delete selected tools, etc.

Clicking on the columns and rows allows one to adjust the settings.

A dialog can be made to popup for data or text entry.

The comments section will typically be displayed in the manual tool change dialog.

If using a lathe configuration, there can be columns for X and Z wear.

To use these columns to adjust the tool wear, it requires a remapped tool change routine.

It is based on PyQt’s QTableView, QAbstractTableModel, and ItemEditorFactory.
Properties, functions and styles of the PyQt base objects are always available.

ToolOffsetView has properties that can be set in Qt Designer, in Python handler code or (if appropriate) in stylesheets:

In a handler file:

and in style sheets:

ToolOffsetView has some functions useful for screen builders to add actions:

Widget for probing on a mill. Used by the QtDragon screen.

This is a general message dialog widget.

If there is a Focus Overlay widget present, it can signal it to display.

If the sound library is set up it can play sounds.

There are options that can be set when requesting a dialog, these would be added to the message dict.

When using STATUS 's request-dialog function, the default launch name is MESSAGE.

It is based on PyQt’s QMessagebox.

This is used as a manual tool change prompt.

It has HAL pins to connect to the machine controller. The pins are named the same as the original AXIS manual tool prompt and works the same.

The tool change dialog can only be launched by HAL pins.

If there is a Focus Overlay widget present, it will signal it to display.

It is based on PyQt’s QMessagebox.

This is used to load G-code files.

If there is a Focus Overlay widget present, it will signal it to display.

When using STATUS 's request-dialog function, the default launch names are LOAD or SAVE.

There are options that can be set when requesting a dialog, these would be added to the message dict:

An example Python call, for a load dialog:

And for a save dialog

It is based on PyQt’s QMessagebox.

This widget allows one to modify User System origin offsets directly in a dialog form.

If there is an Focus Overlay widget present, it will signal it to display.

When using STATUS 's request-dialog function, the default launch name is ORIGINOFFSET.

It is based on PyQt’s QDialog.

This widget allows one to modify Tool offsets directly in a dialog form.

If there is an Focus Overlay widget present, it will signal it to display.

When using STATUS 's request-dialog function, the default launch name is TOOLOFFSET.

It is based on PyQt’s QDialog.

FIXME MachineLog documentation

This is a dialog to display the macrotab widget.

MacroTab displays a choice of macro programs to run using icons.

If there is a Focus Overlay widget present, it will signal it to display.

When using ``STATUS``'s request-dialog function, the default launch name is MACROTAB.

It is based on PyQt’s QDialog.

This is a dialog to display the CamView widget for Webcam part alignment.

When using ``STATUS``'s request-dialog function, the default launch name is CAMVIEW.

It is based on PyQt’s QDialog.

This is a dialog to display an edit line for information entry, such as origin offset.

It returns the entry via STATUS messages using a Python DICT.

The DICT contains at minimum, the name of the dialog requested and an ID code.

When using ``STATUS``'s request-dialog function, the default launch name is ENTRY.

It is based on PyQt’s QDialog.

This is a dialog to display a calculator for numeric entry, such as origin offset.

It returns the entry via STATUS messages using a Python DICT.

The DICT contains at minimum, the name of the dialog requested and an ID code.

When using ``STATUS``'s request-dialog function, the default launch name is CALCULATOR.

It is based on PyQt’s QDialog.

Dialog to preset spindle settings before running a program from a specific line.

It is based on PyQt’s QDialog.

This is a dialog to display a part probing screen based on Verser Probe v2.

It is based on PyQt’s QDialog.

This is a dialog to display the machine log and QtVCP’s debugging log.

It is based on PyQt’s QDialog.

The Nurbs editor allows you to manipulate a NURBS based geometry on screen and then convert NURBS to G-code.

You can edit the G-code on screen and then send it to LinuxCNC.

It is based on PyQt’s QDialog.

It is the base class for the HALPad widget.

This widget looks and acts like a 5 button D-pad, with a LED like indicators in a ring.

You can put text or icons in each of the button positions.

You can connect to output signals when the buttons are pressed.

There are also input slots to change the color of the indicator(s).

There are enumerated constants used to reference indicator positions.
They are used in Qt Designer editor’s property editor or in Python code.

As coded these function issue (emit) PyQt5 signals (joy_btn_pressed and joy<letter>_pressed) for the any button pressed or released_.

Signal joy_btn_pressed outputs a string code for the button.
Signal joy_<letter>_pressed outputs a bool value.

You could override the functions to do something else if making a custom widget:

These signals will be sent when buttons are pressed.

They can be connected to in Qt Designer editor or Python code.

The first two output a string that indicates the button pressed:

They are based on PyQt’s Signal (QtCore.pyqtSignal())

Slots can be connected to in Qt Designer editor or Python code:

These can be set in stylesheets or Python code:

The above properties could be set in:

This widget will create a html/pdf viewing page using the QtWebKit or QtWebEngine libraries. The newer QtWebEngine is preferred if both are on the system.
If the QtWebEngine library is used with the Qt Designer editor, a placeholder QWidget will show in Qesigner. This will be replaced with the QtWebEngine widget at run time.

This class modifies QPushButton behaviour.

Widget for measuring two heights with a probe.
For setup.

Widgets for performing common machining processes.

Slab or face a definable area with different strategies.

Drill multiple holes on a bolt hole circle.

QtVCP’s version of NGC subroutine selector (Shown as used in QtDragon).

Allows adding loadable PDFs to a screen.

Use this to build/add OpenGl simulated machines.

This widget is combobox that will allows selection of a pin or signal on the system.

Det er funksjonskall