Finding a Little Zen

Zenity is a command-line GUI creator that has been around since 2012 and is pre-installed on most versions of Linux, including Raspberry Pis. Zenity isn't designed to be a high-level GUI development tool, but if you just need some basic scripting with dialogs, then Zenity might be a perfect fit.

I was amazed that in one line of Bash code I was able to show:

• stats in a message dialog
• a web page in a dialog
• CSV data or SQL queries in a list dialog

After looking at slightly more complex applications, I found I was able to create:

• a progress bar with dynamic values (about seven lines)
• a form to insert user data into an SQL database (about eight lines)
• a four-button dialog to control a Rasp PI Rover (~20 lines)

In this article, I introduce Zenity with some examples.

Getting Started

The Zenity [1] command-line utility is supported on Linux, macOS, and Windows. Zenity can display calendar, color selector, file selector, form, list, message, notification, progress, scale, and text dialogs.

The Zenity message dialog can be used like a Bash echo statement; for example, to show an information message, enter:

zenity --info --text="Some text" --title="My Title"

Information from command-line tools and utilities can be passed to Zenity. For example, the instantaneous CPU idle time from the top utility can be parsed and passed to a Zenity dialog (Figure 1):

zenity --info --text=$(top -n 1 | grep %Cpu | awk '{print $8}') --title="CPU Idle Time"

Figure 1: Message dialog with CPU idle time.

Text font and size can be modified in message dialogs in Pango markup language syntax [2]. Pango is similar to HTML, and the <span> … </span> set of tags is typically used to encode font and color definitions (Figure 2):

zenity --warning --text=' HIGH Temperature' --title="HDD Check"

Figure 2: Message dialog with font changes.

For scripting applications that need to pass more information to users, text-info dialogs can pass text files and URL links (Figure 3):

zenity --text-info --title="Background Reading" --html --url="https://developer.gnome.org" --checkbox="I read it...and I'm good to go"

Figure 3: Web page within a dialog.

For dialogs with OK and Cancel buttons, Zenity returns a   to confirm and a 1 to cancel. Zenity will not process JavaScript on a web page.

Simple dialogs like the info, warning and error dialogs will only have an OK button. All the other dialogs will have Cancel buttons, as well. The button text can be changed with the --ok-label and the --cancel-label options. More buttons can be added with the --extra-button option.

Dynamic Values

A Zenity progress dialog can show dynamic updates with scripts that use subshells. A subshell is configured with parentheses. Step executions within the subshell are paused by sleep statements.

The following code shows a three-step example of a subshell with a Zenity progress dialog (Figure 4):

(
echo "33"; echo "# 1/3 done" ; sleep 5;
echo "66"; echo "# 2/3 done" ; sleep 5;
echo "100";echo "# Finished" ) | zenity --progress --title="3 step test"

Figure 4: A three-step progress dialog.

When a step outputs a value, the progress bar updates. The text on the progress dialog is changed by outputting a text string that starts with a # character.

Listing 1 and Figure 5 show an example of current seconds with the progress bar rescaled from 0 to 60.

#!/bin/bash
# show_seconds.sh - progress dialog to show seconds
echo "Press [CTRL+C] to stop..."
(
  while :; do
  echo "# $(date +'%S')"
  # Scale 0-60 to 0-100
  echo "$(date +'%S')*100/60" | bc
  sleep 1
  done
  ) | zenity --progress  --title="Show Time in Seconds"

Figure 5: Continuous updates in a progress dialog.

The Bash while statement lets you show dynamic values continuously until the Cancel button is pressed.

CSV Data in List Dialogs

For simple text files and known datasets, the list dialog works quite well. The dialog expects the data to be sequential. The following code creates a two-column example (Figure 6) with inline data:

zenity --list --title="2 Column Example" --column="Month" --column="Sales" Jan 100 Feb 95 Mar 77 Apr 110 May 111

Figure 6: List dialog showing inline data.

To pass a data file (CSV or text) into Zenity, the text needs to be reformatted. The tr command can replace CSV field separators like commas with a newline (\n) character (Listing 2).

$ cat pidata.csv
10:00,12,running
10:20,14,stopped
10:30,13,running
$ cat pidata.csv | tr ',' '\n'
10:00
12
running
10:20
14
stopped
10:30
13
running

The output can then be passed to a Zenity list with column headings (Figure 7):

cat pidata.csv | tr ',' '\n' | zenity --list --title="Pi Data" --column="Time" --column="Temp" --column="Pump"

Figure 7: List dialog showing CSV data.

Once you have some Zenity and Bash basics down, you can start doing more advanced operations, such as:

awk -F "\"*,\"*" '{print $3 "\n" $1}' pidata.csv | zenity --list --column="field3" --column="field1"

This one-line example uses Awk to parse specific data (fields 1 and 3) in the CSV file.

SQL Data in List Dialogs

SQL command-line utilities can output SQL queries to a Zenity list dialog. Like the earlier CSV examples, the SQL output needs to reformatted to a sequential list. The SQL output from the command-line tools will vary by database; for example, MySQL uses tabs between the fields, whereas SQLite uses a vertical bar (|).

For my testing, I used an SQLite3 database (someuser.db) with a table (users) of fields containing first and last names, age, and job. To output a SELECT query, I entered:

$ sqlite3 someuser.db "select fname,lname,age,job from users"
Brooke|Metcalfe|18|Student
Leah|Metcalfe|18|Co-op
Pete|Metcalfe|100|Old dude
...
Willy|Coyote|99|Evil genius

The SQLite query output can be modified with the tr command and shown in a Zenity list dialog (Figure 8):

$ sqlite3 someuser.db "select fname,lname,age,job from users" | tr '|' '\n' | zenity --list --title="My Database" --column="first name" --column="last name" --column=age --column=job

Figure 8: List dialog showing SQL query.

The Zenity list dialog supports a number of useful options, such as radio buttons and checkboxes. The lists are editable, and the selected fields or rows can be used in further scripting.

Insert SQL Data in a Zenity Form

Zenity forms allows for the creation of basic data entry dialogs. In about eight lines of Bash code (Listing 3), I created a Zenity form (Figure 9) I can use to insert data into my SQLite users table.

01 #!/bin/bash
02 row=$(zenity --forms --title="Create user" --text="Add new user" --add-entry="First Name" --add-entry="Last Name" --add-entry="Age" --add-entry="Job" --separator="','")
03 if [[ -n $row ]] # Some data found
04 then
05   cmd="sqlite3 someuser.db  \"INSERT INTO users (Fname,Lname,Age,Job) VALUES ('$row')\""
06   eval $cmd
07   echo "Added data: '$row'"
08 fi

Figure 9: SQL input form.

The OK button will pass the user-entered data as a string, whereas the Cancel button will not pass any data. An if statement checks to see whether any data has been entered.

The SQL INSERT statement needs VALUES to be in the format

("value1","value2,"value3,"value4")

The formatting can be done by setting the Zenity --separator option to a comma, defined with single quotes within double quotes (line 2).

This example is quite basic, so the next step would be to add data validation.

Final Comments

For simple dialogs, Zenity works amazingly well. I found that as the requirements started to get more complicated, a Python solution appeared to be cleaner and simpler. I was able to control a Raspberry Pi rover in about 20 lines of Bash and Zenity code, but it only took 15 lines of Python and Tkinter code.

There is a Python library (Zenity 2.0) that emulates Zenity, so if you're feeling comfortable with the Zenity dialogs and you don't need complex dialogs, this might be something to consider.

If you are looking for a more complete command-line GUI tool, try YAD [3].