Let’s code a GTK Theme Switcher for XFCE in OCaml

I’m using XFCE4 since a couple of years and despite newer desktop environments for Linux, I always went back to XFCE beause it’s the least invasive and lets me do the things I want. Changing the XFWM window manager for XMonad or even EXWM? No problem.

But XFCE lacks an easy way to quickly switch from a light theme to a dark mode and back via key shortcut.

Normally, someone would come up with a shell script to do things like that, but I’m about to learn OCaml anyway, so let’s write that in OCaml.

One can select a GTK theme in XFCE with xfce4-appearance-settings. XFCE remembers what theme I’ve set, so my first guess is that we’ll have to find out how and where XFCE does this – in order to change it.

Linux is quite simple as most user preferences are stored in “config files”, which are just plain text files located somewhere in ~/.config. So we can probably do something like this:

1. Find the config file where the information about the selected theme is stored
   
2. Change the information about the dark/light mode there
   
3. Tell XFCE to reload the config file in order apply the change immediately
   

Not so bad for a first guess, but the glorious ArchLinux wiki has a better idea about setting light or dark mode for GTK apps:

To change the light/dark mode, you have to change the used theme. Most themes do have a dark variant and those have by convention the suffix -dark. For example the default GTK theme Adwaita has the variant Adwaita-dark.

Further, the wiki tells us:

To switch themes instantly for running programs, either a daemon providing the xsettings spec or gsettings is required. For desktops running with Xorg, an xsettings daemon is needed. For desktops running with Wayland, gsettings is queried.

Mmmmkay, so the functionality already exists in XFCE4. And it’s not about a config file to change, but speaking to daemons. You can issue those commands just straight from the command line (try it!):

If you want to follow the walktrough, you’ll need at least:

• opam (the OCaml package manager) must be installed and configured
  
• A computer running either Linux/Unix with XFCE or GNOME Desktop
  
• A proper editor (e.g. Emacs, Vim or VS Code) with OCaml support
  
• Very basic programming knowledge (what’s a function, variable, etc.)
  

What do we need our program to do? Let’s make a quick list:

• [ ] Determine the currently active GTK theme
  
• [ ] Toggle the UI (GTK) theme
  
• [ ] Change the icon theme accordingly
  
• [ ] Read the preferences from a config file:
  
  • [ ] … which backend to use (either xsettings or gsettings)
    
  • [ ] … or check/select the available backend automatically
    
  • [ ] … preferred dark/light UI themes
    
  • [ ] … preferred dark/light icon themes
    
• [ ] Write the initial config file if it doesn’t yet exist
  
• [ ] Compile a standalone executable
  

I would like to see the baby! Alright, let’s implement the core feature first: toggle between the light theme and the dark theme.

When there’s only one key combination to switch between light and dark theme, our programm has to make a decision: which theme to set when we press the key. Therefore, at some point our program needs to find out which theme is currently “on”. That’s a start, eh?

Getting the name of the currently active theme

Remember, we can find out what theme is currently active with the shell command we talked about before:

xfconf-query -c xsettings -p /Net/ThemeName

Adwaita

We have to execute the shell command from inside our program, and then capture the output of the shell command, so that our program can use this information internally to make a decision. In OCaml, we are doing things with functions. We can use the function Unix.open_process_in from OCaml’s Unix module:

Unix.open_process_in "xfconf-query -c xsettings -p /Net/ThemeName"

This function opens an in_channel, but doesn’t yet spit out the theme name; rather we have to get the theme name from that in_channel. We can use another function input_line that reads from the in_channel line by line (Each time input_line is applied, it returns the next line, until there is none left – but here we call it only once).

input_line (Unix.open_process_in "xfconf-query -c xsettings -p /Net/ThemeName")

Look at the parenthesis: in OCaml we use the parens for grouping, like we do in maths. The parens ensure that the value of the inner function (Unix.open_process_in "xfconf-query …") is going to be computed first, and the resulting value is passed to the function input_line. So eventually, the two nested functions above will produce the output we’re looking for:

- : string = "Adwaita"

Setting the GTK- and icon themes

Once again we’re about to wrap shell commands. The set_theme function is almost the same, so I’ll make it short. We’re going to use the types again to tell the function which backend to use, and if either the Ui theme or the Icon theme is going to be set. Additionally, we’ll pass the theme name to the function as it will become part of the shell commands (via string concatenation through the ^ operator).

let set_theme backend widget name =
  match backend, widget with
  | Xsettings, Ui ->
    Unix.open_process
      ("xfconf-query -c xsettings -p /Net/ThemeName -s " ^ name)
  | Xsettings, Icon ->
    Unix.open_process
      ("xfconf-query -c xsettings -p /Net/IconThemeName -s " ^ name)
  | Gsettings, Ui ->
    Unix.open_process
      ("gsettings set org.gnome.desktop.interface gtk-theme " ^ name)
  | Gsettings, Icon ->
    Unix.open_process
      ("gsettings set org.gnome.desktop.interface icon-theme " ^ name)

let _ = set_theme Xsettings Icon "Papirus-Dark" (* apply the function *)

Making a decision

Until now, we have built two functions get_theme and set_theme. Let’s use those in our third function and bring the action!

Our toggle function needs to know several preferences to wield its magic. First, we are going to specify the preferences directly within the function with let … in bindings (for simplicity’s sake). Later, when we know the function works, we are going to use a config file.

• Which backend to get/set the themes –> identifier backend
  
• Name of the currently active UI theme –> identifier current_ui
  
• Name of the dark UI theme –> identifier ui_dark
  
• Name of the light UI theme –> identifier ui_light
  
• Name of the dark icon theme –> identifier icon_dark
  
• Name of the light icon theme –> identifier icon_light
  

“Magic” is a bit of an exaggeration – we use simple conditions here. As the themes come in pairs, the program just needs to set “the other one”. The decision which theme to set, depends on the currently active UI theme current_ui. So we’re going to match current_ui with pattern(s).

1. For the first branch, we can do:
   “When current_ui equals the value of ui_dark -> use the backend to set the UI theme ui_light; then use the backend to set the icon theme icon_light”.
   
2. The second branch does the same, but vice-versa.
   
3. But what should happen if there has been set a different theme, which is none of the preconfigured dark/light theme pair? E.g. set by the XFCE appearance control panel? We can address this by introducing a third branch – the catch-all: Whenever the identifier current_ui carries an unexpected value, fall back to the preconfigured ui_light and icon_light.
   

let toggle () =
  let backend = Xsettings in
  let current_ui = get_theme backend Ui in (* 2nd argument is the value above *)
  let ui_dark = "Adwaita-dark" in
  let ui_light = "Adwaita" in
  let icon_dark = "Papirus-Dark" in
  let icon_light = "Papirus-Light" in
  match current_ui with
  | c when String.equal c ui_dark ->
    let _ = set_theme backend Ui ui_light in
    set_theme backend Icon icon_light
  | c when String.equal c ui_light ->
    let _ = set_theme backend Ui ui_dark in
    set_theme backend Icon icon_dark
  | _ ->
    let _ = set_theme backend Ui ui_light in
    set_theme backend Icon icon_light

let _ = toggle ()

There may arise some questions:

• What does c mean in the 1st and 2nd branch?
  When matching a pattern, we can simultaneously bind one or more identifiers to certain parts of the matched object to use those parts in other places within the same branch. Here, we bind the whole value of current_ui to c.
  
• What does the when keyword do?
  when introduces a guard expression. If the guard expression evaluates to true, then evaluate the expression after the arrow; if false, just continue with the next branch.
  
• Why has the expression after the arrow the form let _ = <expression1> in <expression2>?
  We can use the nested let … in forms to do more than one thing after the other. And the single underscore (wildcard) means that we don’t care to give it a name. It’s evaluated only for its side effects (to trigger the shell commands).
  

Ok ok, relax. We are not there yet. For now it runs in the toplevel, yes. Take a little break and do some Push-ups. Here’s the code we cooked up so far:

type backend = Xsettings | Gsettings
type widget = Ui | Icon

let get_theme backend widget =
  let clean s =
    Str.global_replace (Str.regexp "^'\\|'$") "" s in
  match backend, widget with
  | Xsettings, Ui ->
    clean (input_line
             (Unix.open_process_in
                "xfconf-query -c xsettings -p /Net/ThemeName"))
  | Xsettings, Icon ->
    clean (input_line
             (Unix.open_process_in
                "xfconf-query -c xsettings -p /Net/IconThemeName"))
  | Gsettings, Ui ->
    clean (input_line
             (Unix.open_process_in
                "gsettings get org.gnome.desktop.interface gtk-theme"))
  | Gsettings, Icon ->
    clean (input_line
             (Unix.open_process_in
                "gsettings get org.gnome.desktop.interface icon-theme"))

let set_theme backend widget name =
  match backend, widget with
  | Xsettings, Ui ->
    Unix.open_process
      ("xfconf-query -c xsettings -p /Net/ThemeName -s " ^ name)
  | Xsettings, Icon ->
    Unix.open_process
      ("xfconf-query -c xsettings -p /Net/IconThemeName -s " ^ name)
  | Gsettings, Ui ->
    Unix.open_process
      ("gsettings set org.gnome.desktop.interface gtk-theme " ^ name)
  | Gsettings, Icon ->
    Unix.open_process
      ("gsettings set org.gnome.desktop.interface icon-theme " ^ name)

let toggle () =
  let backend = Xsettings in
  let current_ui = get_theme backend Ui in
  let ui_dark = "Adwaita-dark" in
  let ui_light = "Adwaita" in
  let icon_dark = "Papirus-Dark" in
  let icon_light = "Papirus-Light" in
  match current_ui with
  | c when String.equal c ui_dark ->
    let _ = set_theme backend Ui ui_light in
    set_theme backend Icon icon_light
  | c when String.equal c ui_light ->
    let _ = set_theme backend Ui ui_dark in
    set_theme backend Icon icon_dark
  | _ ->
    let _ = set_theme backend Ui ui_light in
    set_theme backend Icon icon_light

let _ = toggle ()

We’re going to finish this in the next episode!

Where do we stand now?

• [X] Determine the currently active GTK theme
  
• [X] Toggle the UI (GTK) theme
  
• [X] Change the icon theme accordingly
  

What’s next?

• [ ] Read the preferences from a config file:
  
  • [ ] … preferred dark/light UI themes
    
  • [ ] … preferred dark/light icon themes
    
  • [ ] … which backend to use (either xsettings or gsettings)
    
  • [ ] … or check/select the available backend automatically?
    
• [ ] Write the initial config file if it doesn’t exist yet
  
• [ ] Compile a standalone executable