QTvcp Handler file code snippets

Here is how to load and save at closing time a number and some text:
You must have included a preference file option in the screenoptions widget.

under the def initialized__(self): function add:

under the def closing_cleanup__(self): function add:

Being able to edit a style on a running screen is convienant.

In the IMPORT SECTION:

In the INITIALIZE SECTION Under the __init__.(self, halcomp, widgets, paths): function

Finally lets make f12 launch it.
In the KEYBINDING SECTION add:

Qtvcp uses STATUS messages to pop up and return information from dialogs.
prebuilt dialogs keep track of their last position and include options for focus shading and sound.
To get information back from the dialog requires using a STATUS general message.

In the IMPORT SECTION make sure there is an entry similar to this:

This loads and initializes the STATUS library.

In the INITIALIZE SECTION Under the __init__.(self, halcomp, widgets, paths): function

This registers STATUS to call the function self.return_value when a general message is sent.

In the GENERAL FUNCTIONS SECTION

This is the function to request an entry dialog.
NAME needs to be set to the dialogs unique launch name.
ID needs to be set to a unique name that the function supplies
It creates a python dict. The NAME sets which dialog to request - ENTRY or CALCULATOR allows entering numbers.
The ID should be a unique key. TITLE sets the dialog title. You can also add arbitrary data to the dict -+ the dialog will ignore them but send them back to the return code.

In the CALLBACKS FROM STATUS SECTION

This catches all general messages so must check the dialog type and id code to confirm it’s our dialog.
In this case we had requested an ENTRY dialog and our unique id was ENTRY_NUMBER, so now we know the message is for us.
Entry or Calculator dialogs return a float number.

This requires the espeak library installed on the system.

In the IMPORT SECTION make sure there is an entry similar to this:

In the INITIALIZE SECTION Under the __init__.(self, halcomp, widgets, paths): function

SPEAK is a key work, everything after it will be pronounced

Toolbar buttons and submenus are added in Designer but the code to make them do something is added in the handler file.
In this example we assume you added a tool bar with one submenu and three actions.
These will be configure to creat a recent file selection menu, an about pop up dialog action, a quit program action and
a user defined function action.
You can add submenus in designer by adding an qaction (by typing in the toolbar column) then clicking the plus icon on the right.
This will ad a sub column that you need to type a name into. Now the original Qaction will be a Qmenu instead.
Now erase the Qaction you added to that Qmenu - the menu will stay as a menu.

The objectName of the toolbar button is used to identify the button when configuring it - descriptive names help.
Using the action editor menu, right click and select edit. Edit the object name, text, and button type for an appropriate action.
In this example the submenu name must be : menuRecent. The actions must be actionAbout, actionQuit, actionMyFunction

In the IMPORT SECTION add:

Loads the toolbar library.

in the INSTANTIATE LIBRARY Section add:

In the SPECIAL FUNCTIONS SECTION Under the def initialized__(self): function add:

Configures the action.

In the GENERAL FUNCTIONS SECTION ADD:

The function to be called if the actionMyFunction button is pressed.

In this way you don’t need to poll the state of input pins.
Under the initialised__ function, make sure there is an entry similar to this:

Add a function that gets called when the pin state changes.
This function assumes there is a Tab widget named mainTab
that has tabs with the names tab_auto, tab_graphics,
tab_filemanager and tab_mdi. In this way the cycle start
button works differently depending on what tab is showing.
This is simplified - checking state and error trapping might
be helpful.

In the GENERAL FUNCTIONS SECTION add:

Some times you want to build a widget to do something not built in.
The built in Max velocity slider acts on units per minute, here we show how to do percent:
The STATUS command makes sure the slider adjusts if linuxcnc changes the current max velocity.
valueChanged.connect() calls a function when the slider is moved.

In Designer add a QSlider widget called mvPercent Then add the code to the handler file.

Generally selecting continuous jogging is a momentary button, that requires you to select
the previous jog increment after. We will build a button that toggles between continuous jog and whatever
increment that was already selected.

In Designer:
use an action button with no action. call it btn_toggle_continuous
set the AbstractButton property checkable true
set the ActionButton properties incr_imperial_number and incr_mm_number to 0
Use designer’s slot editor to use the button signal clicked(bool) to call form’s handler function toggle_continuous_clicked()
Using Designer to add slots
Then add this code snippets to the handler file:
Under the initialized__ function, make sure there is an entry similar to this:

In the GENERAL FUNCTIONS SECTION ADD:

In the CALLBACKS FROM FORM SECTION ADD:

The File manager widget is designed to load a selected program in linuxcnc.
But maybe you want to print the file name first.
We can class patch the library to redirect the function call.

In the IMPORT SECTION add:

Here we are going to keep a reference to the original function, so we can still call it
Then we redirect the class to call our custom function in the handler file instead.

Ok Now we write a custom function to replace the original.
This function must have the same signature as the original function.
In this example we are still going to call the original function by using the
reference to it we recorded earlier. It requires the first argument to be the widget instance
which in this case is self.w.filemanager (the name given in the designer editor)

Now our custom function will print the file path to the terminal before loading the file.
Obviously boring but shows the principle.

There is another slightly different way to do this that can have advantages.
You can store the reference to the original function in the original class.
the trick here is to make sure the function name you use to store it, is not already
used in the class. super__ added to the function name would be a good choice
We won’t use that in built in qtvcp widgets.

In some situation it is only possible to add widgets with python code rather then using the Designer editor.
When adding Qtvcp widgets programmatically, sometimes there are extra steps to be taken.
Here we are going to add a spindle speed indicator bar and up-to-speed LED to a tab widget corner.
Designer does not support adding corner widgets to tabs but PyQt does.
This is a cut down example from Qtaxis screen’s handler file.

First we must import the libraries we need.
often these libraries are already imported in the handler file.
QtWidgets gives us access to the QProgress bar
QColor is for the LED color
StateLED is the Qtvcp library used to create the spindle-at-speed LED
Status is used to catch linuxcnc status information.
Info gives us information about the machine configuration.

STATUS and INFO are initialized outside the handler class so as to be a global reference (no self. in front)

For the spindle speed indicator we need to know the current spindle speed:
We register with STATUS to catch the actual-spindle-speed-changed signal to call
a function named: self.update_spindle()

We need to make sure the Designer widgets are already built before we try to add to them.
We add a function call self.make_corner_widgets() to build our extra widgets at the right time.

Ok let’s code the function to build the widgets and add them in the tab widget.
We are assuming there is a tab widget built with Designer called rightTab.

self.w.led = LED() - this initializes the basic StateLed widget and uses self.w.led as the reference from then on.
self.w.led.setProperty("is_spindle_at_speed_status",True) - since the stateLED can be used for many indications
we must set the property that designates it as a spindle-at-speed LED.
self.w.led.setProperty("color",QColor(0,255,0,255)) this sets it as green when on.
self.w.led.hal_init(HAL_NAME = "spindle_is_at_speed") - this is the extra function call required with some Qtvcp widgets.
If HAL_NAME is omitted it will use the widget objectName if there is one.
It gives the special widgets reference to:

self.w.rpm_bar = QtWidgets.QProgressBar() - initialize a PyQt5 QProgress bar.
self.w.rpm_bar.setRange(0, INFO.MAX_SPINDLE_SPEED) - set the max range of the Progress bar to the max specified in the INI.

Since you can only add one widget to the tab corner and we have two we want there, we must add the two into a container.
We create a QWidget and add a QHBoxLayout to the QWidget.
The we add our QProgress bar and LED to the layout.

self.w.rightTab.setCornerWidget(w) - finally we add the QWidget (with our QProgress bar and LED in it) to the tab widget’s corner.

Now we build the function to actually update out QProgressBar when STATUS updates the spindle speed.
self.w.rpm_bar.setInvertedAppearance() - In this case we chose to display left-to-right or right-to-left depending if we are turning clockwise or anticlockwise.
self.w.rpm_bar.setFormat() - This formats the writing in the bar.
self.w.rpm_bar.setValue() - This sets the length of the colored bar.

Sometimes you want to control the screen with a separate program.
Qtvcp can automatically set up ZMQ messaging to send and/or receive remote messages.
It uses ZMQ’s publish/subscribe pattern of messages.
As always consider security before letting programs interface though messaging.
In the screenoptions widget, you can select the property use_receive_zmq_option
You could also set this property directly in the handler file (as in this sample).
We assume the screenoption widget is called screen_options in designer:

This allows an external program to call functions in the handler file.
Let’s add a specific function for testing.
You will need to run linuxcnc from a terminal to see the printed text.

Here is a sample program to call a function.
It alternates between two data sets every second.
Run this in a separate terminal from linuxcnc to see the sent messages.

Note the line x = {"FUNCTION": "test_zmq_function", "ARGS": [True,200]} sets
the function to call and the arguments to send to that function.
you will need to know the signature of the function you wish to call.
Also note that the message is converted to a json object.
This is because ZMQ sends byte messages not python objects.
json converts python to bytes and will be converted back when received.

You also my want to communicate with a separate program from the screen.
Qtvcp can automatically set up ZMQ messaging to send and/or receive remote messages.
It uses ZMQ’s publish/subscribe pattern of messages.
As always consider security before letting programs interface though messaging.
In the screenoptions widget, you can select the property use_send_zmq_message
You could also set this property directly in the handler file (as in this sample).
We assume the screenoption widget is called screen_options in designer:

This allows sending messages to a separate program.
The message sent will depend on what the external program is expecting.
Let’s add a specific function for testing.
You will need to run linuxcnc from a terminal to see the printed text.
We assume the screenoption widget is called screen_options in designer:
You need to add something to call this function, such as a button click.

Here is a sample program that will receive the message and print it to the terminal.