Why does gtk_recent_manager_add_full () silently fail? - c

Question

The main goal
I wrote a python simple program that adds a file to the recent files list in GTK3. It gets called when vim opens a file. It's working fine, but vim's startup time is multiplied by 10. Now I'm trying to port it to C so as to improve this flaw. Here is a demo of the python script I'm trying to port :
from gi import require_version
require_version('Gtk', '3.0')
from gi.repository import Gtk
manager = Gtk.RecentManager()
recent_data = Gtk.RecentData()
recent_data.app_name = "vim"
recent_data.mime_type = "text/plain"
recent_data.app_exec = "/usr/bin/vim"
manager.add_full("file:///home/lafleur/tweaks.txt", recent_data)
What I attempted
See the code sample below. It compiles fine, but I get a CRITICAL warning when I run it, and then the process succeeds, but the file doesn't show up in the recent files in Nautilus.
Here is the traceback :
$ ./a.out
adding file:///home/lafleur/tweaks.txt to recent files
(process:17646): GLib-GObject-CRITICAL **: 12:37:32.034: g_object_get: assertion 'G_IS_OBJECT (object)' failed
file added to recent files.
I'm unable to tell what went wrong. I followed docs in GNOME's GTK3 documentation. Those docs state that the mandatory arguments to gtk_recent_manager_add_full () are the gtk_recent_manager, a uri and a GtkRecentData object holding the file's MIME type, the application name and its callback. When compiled, the process complains that it needs an application description, which I added in the sample (see below). I found g_object_get ()'s definition here, but that doesn't give me any clue.
The question
My question is : how can I know what's happening and why the process fails to add the existing /home/lafleur/tweaks.txt to Nautilus' recent files listing ? How can I know what in my code is not a valid GObject ? Did I miss some initialization, as stated in this SO answer ?
Here is the code sample :
#include <gtk/gtk.h>
int main (int argc, char **argv)
{
GtkRecentData recent_data;
GtkRecentManager *manager;
GError *error = NULL;
gchar *uri;
gboolean retval;
uri = g_filename_to_uri ("/home/lafleur/tweaks.txt", NULL, &error);
manager = gtk_recent_manager_get_default ();
if (error) {
g_warning ("%s", error->message);
g_error_free (error);
} else {
recent_data.mime_type = "text/plain";
recent_data.app_name = "vim";
recent_data.app_exec = "/usr/bin/vim";
recent_data.description = "the vim editor";
g_print ("adding %s to recent files\n", uri);
retval = gtk_recent_manager_add_full (
manager,
uri,
&recent_data
);
if (retval == TRUE) {
g_print ("file added to recent files.\n");
} else {
g_warning ("there was a problem.\n");
}
g_free (uri);
}
return retval;

Answer 1

When using GTK API from C, you need to initialize GTK itself, with something like:
gtk_init (&argc, &argv);
where argc and argv are pointers to the arguments counter and vector that you get in your main. If you don't do this, anything that follows is undefined behaviour.
The Python bindings, for reasons of backward compatibility in the days of GTK 1 and 2, call gtk_init() automatically when imported.
Additionally, GtkRecentManager queues updates within the GTK main loop, to coalesce multiple writes into one; this is not normally an issue in GUI applications, but if you're writing a CLI tool, you will need to also spin the main loop until the GtkRecentManager emits the "changed" signal.
Your program will work once you modify it to call gtk_init() first, and then spin the main loop until the write is done, e.g.:
#include <stdlib.h>
#include <gtk/gtk.h>
int main (int argc, char **argv)
{
GError *error = NULL;
char *uri = g_filename_to_uri ("/home/lafleur/tweaks.txt", NULL, &error);
// Bail out early in case of error
if (error != NULL) {
g_warning ("%s", error->message);
g_error_free (error);
return EXIT_FAILURE;
}
// You can pass (NULL, NULL) if you don't have arguments; if you
// want to deal with the possibility of not having a display
// connection, you can use gtk_init_check() instead.
gtk_init (&argc, &argv);
// Create the recent manager
GtkRecentManager *manager = gtk_recent_manager_get_default ();
// Create a main loop; the recent manager will schedule writes
// within the loop, so it can coalesce multiple operations.
GMainLoop *loop = g_main_loop_new (NULL, FALSE);
// Once we receive the "changed" signal from the recent manager
// we stop the main loop; we use the "swapped" variant so that
// the callback will be invoked with the signal's user data
// as the first argument; in this case, we're going to call
// g_main_loop_quit() on the loop object
g_signal_connect_swapped (manager, "changed",
G_CALLBACK (g_main_loop_quit),
loop);
GtkRecentData recent_data = {
.mime_type = "text/plain",
.app_name = "vim",
// The "app_exec" key should be the command line needed to open
// the file you're adding; the %f escape sequence means "use the
// path of the file", whereas the %U escape sequence means "use
// the URL of the file".
.app_exec = "/usr/bin/vim %f",
.description = "the vim editor",
};
g_print ("adding %s to recent files\n", uri);
gboolean retval = gtk_recent_manager_add_full (
manager,
uri,
&recent_data
);
// Never compare boolean values for equality; gboolean is an int-sized
// type, which means anything that is not FALSE/0 will have a TRUE value
if (retval) {
g_print ("file added to recent files.\n");
} else {
g_warning ("there was a problem.\n");
}
g_free (uri);
// Start the loop; this will block until GtkRecentManager emits the
// "changed" signal, telling us the the recently used files list has
// been updated
g_main_loop_run (loop);
// Use standard exit codes
return retval ? EXIT_SUCCESS : EXIT_FAILURE;
}
Since you must call gtk_init(), you will need a connection to your display server; this means you cannot run this program under a pure virtual terminal outside of your graphical session. If you need to do that, you will need to write your own "recent manager", using the GBookmarkFile API, which is the same API GTK uses internally. The GBookmarkFile API is definitely more low level, though, and it requires you understand the file format and location used for the recently used files.