Linux GTK Glade Compiler

Latest Source Code Version:

The Glade Compiler is included in the Mumps distribution in the projects directory:

The Glade Compiler

What is Glade?

"... Glade is a RAD tool to enable quick & easy development of user interfaces for the GTK toolkit and the GNOME desktop environment.

The user interfaces designed in Glade are saved as XML, and by using the GtkBuilder GTK object these can be loaded by applications dynamically as needed.

By using GtkBuilder, Glade XML files can be used in numerous programming languages including C, C++, C#, Vala, Java, Perl, Python,and others.

Glade is Free Software released under the GNU GPL License. ..." The Glade Project

• Glade produces an XML representation of your GTK GUI layout. The XML file can be read by GTK functions that, together with your code, can build and display this layout.
• Each active widget in the layout (for example, a button) will most likely have a signal defined in the layout. Signals are raised when actions are performed on a widget. In the case of a button widget, the most common signal is "clicked".
• Glade will build the XML file describing to your app. This includes iformation giving the location, size, function, and signals associated each widget in the app.
• The programmer is responsible to build a program based to implement the GUI layout. This includes the basic GTK main loop, declaration of GTK pointers and creation of signal handlers.
• When a user of an app generates a signal, for example, clicking a button, the GTK main loop attempts to call the signal handler associated with the action or event (for example, a button clicked signal handler). The programmer is responsible for writing the handler to do whatever clicking the button is supposed to do.
• While the working content of any app is mainly found in the signal or event handlers, the setup to build the code to the point where signal handlers can be written can be tedious.
• The purpose of this compiler is to read the XML file and create the basic software, including skeletal signal handlers, to realize a working model of the basic layout.
• Each signal handler created by the compiler contains basic code to support the signal including accessing data from the signaling widget (for example, determining the position of a GUI slider whose movement resulted in a slider moved signal).
• In summary, if you can build a layout, the compiler will build you a working version of it.
• Based on user choice, the compiler generates code in C, C++, or Mumps.
• Not all GTK widgets are supported at present and work is in process to add more recognized widgets as well as add additional GUI support features. As of this point in time, the dfollowing widgets are supported:

Examples

The following examples use the mumps/Mumps-Projects/GTK-Compiler/C-Examples/Button-Widgets directory and code from the distro.

Before you attempt to run the examples, you will need to install software. The installation scripts are in the distro directory:

mumps/Mumps-Language-Processors/Mumps-Interpreter-Compiler-Library

In that directory, as root, run:

ConfigureNativeMumps.script

followed by:

CompileNativeSingleUserMumps.script

DO NOT run the Makefile.

The first script will check if you have the needed software and, if not, install it. This only woks of systems that use apt/apt-get.

The second script configures the code, compiles it, then installs it to /usr/bin.

All examples were run under Linux Mint 20.3 Una with Mate 1.26.0 and GTK 3.22.16 and Glade 3.22.2

The following image shows the Glade GUI with an example layout containing several common button related widgets.

To run the Glade GUI from mumps/Mumps-Projects/Glade-Compiler/C-Examples directory on your computer, in a file explorer, double click on the file mumps.glade or type the command

glade mumps.glade

The button highlighted is a GtkToggleButton whose name (see ID at top of rightmost panel) is SampleGtkTogglebutton. The ID is assigned by the programmer/designer of the app.

Near the bottom of the rightmost panel, under Label with Optional Image, is the text that appears inside the button. The remainder of the rightmost settings panel are defaults.

In the following figure we see the second tab of the right most panel:

This is the tab where you position the widget within the app container. The numbers are in pixels where 0 represents the rightmost / topmost pixel of the app window.

Next is the tab where you establish signals for events you want to process:

The main action for a toggle button is the toggled signal. The name of the signal handler is: on_SampleGtkToggleButton_toggled. The programmer enters this name. This is the name of the function that will be invoked if the button is toggled. The name should be on_ followed by the widget ID followed by _toggled.

Hint: a standard name such as shown will be inserted for you if you click on the text and begin typing on.... The Glade GUI will fill in the rest.

BE SURE TO HIT ENTER to confirm you selection.

The XML file from Glade is a text file named xxx.glade where xxx is set by the user when they create the project.

In the case of the code for the GtkCompiler, it is assumed, at present, that this file is named mumps.glade.

Once the layout has been saved, you run make -B which builds the skelatal project code:

rm -f on.* key.dat data.dat
../../GtkCompiler.mps "C" < mumps.glade

Mumps GTK Application Builder Mon Aug  1 12:26:13 2022
-----------
ComboBoxExample GtkComboBox
     signal=on_ComboBoxExample_changed
Creating signal handler: on.ComboBoxExample.changed.h
ExampleFontButton GtkFontButton
     signal=on_ExampleFontButton_font_set
Creating signal handler: on.ExampleFontButton.font.set.h
ExampleSwitch GtkSwitch
     signal=on_ExampleSwitch_state_set
Creating signal handler: on.ExampleSwitch.state.set.h
SampleColorButton GtkColorButton
     signal=on_SampleColorButton_color_set
Creating signal handler: on.SampleColorButton.color.set.h
SampleGtkButton GtkButton
     signal=on_SampleGtkButton_clicked
Creating signal handler: on.SampleGtkButton.clicked.h
SampleGtkCheckButton GtkCheckButton
     signal=on_SampleGtkCheckButton_toggled
Creating signal handler: on.SampleGtkCheckButton.toggled.h
SampleGtkRadio1 GtkRadioButton
     signal=on_SampleGtkRadio1_toggled
Creating signal handler: on.SampleGtkRadio1.toggled.h
SampleGtkRadio2 GtkRadioButton
     signal=on_SampleGtkRadio2_toggled
Creating signal handler: on.SampleGtkRadio2.toggled.h
SampleGtkRadio3 GtkRadioButton
     signal=on_SampleGtkRadio3_toggled
Creating signal handler: on.SampleGtkRadio3.toggled.h
SampleGtkToggleButton GtkToggleButton
     signal=on_SampleGtkToggleButton_toggled
Creating signal handler: on.SampleGtkToggleButton.toggled.h
cbentry GtkEntry
     signal=on_cbentry_changed
Creating signal handler: on.cbentry.changed.h
entrybuffer1 GtkEntryBuffer
fixed1 GtkFixed
label1 GtkLabel
label2 GtkLabel
label3 GtkLabel
lbl4 GtkLabel
liststore1 GtkListStore
page_0 GtkFixed
page_1 GtkFixed
stack1 GtkStack
window GtkWindow
-----------

gcc -O3 -fdiagnostics-color=never \
	-pthread `pkg-config --cflags --libs glib-2.0` \
	-o gtk gtk.c `pkg-config --libs glib-2.0` -lpthread \
	`pkg-config --cflags --libs gtk+-3.0` -export-dynamic

The files created by this process are:

1. -rw-rw-r-- 1 okane okane   702 Aug  1 12:26 gtk1.h
   -rw-rw-r-- 1 okane okane  2055 Aug  1 12:26 gtk2.h
   -rw-rw-r-- 1 okane okane   541 Aug  1 12:26 gtk3.h
   

   These are files that containg declarations, initializations, and #include code that will be incorporated into the template file gtk.c.

2. on.cbentry.changed.h 
   on.SampleColorButton.color.set.h 
   on.SampleGtkRadio2.toggled.h 
   on.ComboBoxExample.changed.h
   on.SampleGtkButton.clicked.h 
   on.SampleGtkRadio3.toggled.h 
   on.ExampleFontButton.font.set.h
   on.SampleGtkCheckButton.toggled.h
   on.SampleGtkToggleButton.toggled.h
   on.ExampleSwitch.state.set.h
   on.SampleGtkRadio1.toggled.h
   

   These are the signal handler files. Each contains a function to handle the named signal. If the name of the signal handler function is on_SampleGtkRadio1_toggled the files name will be on.SampleGtkCheckButton.toggled.h These files will also be included into the gtk.c template program at the end.

3. The file gtk is the exectutable. If you execute it you get:
   

4. The signal handler for the SampleGtkToggleButton toggled signal is in file on.SampleGtkToggleButton.toggled.h which contains the following:

   void on_SampleGtkToggleButton_toggled(GtkWidget *w) {
   printf("%s\n", "on.SampleGtkToggleButton.toggled.h");
   printf("\ttoggled = %d\n", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w)));
   }
   

5. If, in the app window, you click the SampleGtkToggleButton, the button will darken to indicate it has been depressed. This will raise the toggled signal and the function in on.SampleGtkToggleButton.toggled.h will be invoked. This will cause a message to appear on the invoking terminal window indicating that the button is active or inactive. This message is from the signal handler:
   

   Upon invocation of the handler and indication of the button status, the user can perform whatever action the button was intended for.

Files Created and Used in the Button Example:

gtk1.h (created by the compiler)

Other Widget Collections

1. Directory mumps/Mumps-Projects/GTK-Compiler/C-Examples/Input-Widgets
   

2. Directory mumps/Mumps-Projects/GTK-Compiler/C-Examples/Slider-Widgets
   

3. Improved buttons example mumps/Mumps-Projects/Glade-Compiler/C-Examples/Button-Widgets
   

4. Directory mumps/Mumps-Projects/GTK-Compiler/MDH-Examples/Mesh-Tree