GTK - killing all subprocesses when application window is closed - gtk

I noticed that if I kill the app launched from the command line, with CTRL+C - then the subprocesses get killed, while, when clicking the close button of the window title, the process remains running.
static void * spawn_process(void *data)
{
GError *local_error = NULL;
GError **error = &local_error;
GSubprocess *process = g_subprocess_new (
G_SUBPROCESS_FLAGS_INHERIT_FDS,
error,
"podman",
"system",
"service",
"--time=0",
"unix:///tmp/podman.sock",
"--log-level=debug",
NULL
);
g_assert_no_error (local_error);
g_subprocess_wait_check(process, NULL, error);
g_assert_no_error (local_error);
g_object_unref (process);
return NULL;
}
static void activate(GtkApplication *app) {
GtkWidget *window = gtk_application_window_new(app);
GThread *process_thread = g_thread_new("Podman service", &spawn_process, NULL);
}
int main(int argc, char **argv) {
GtkApplication *app = gtk_application_new("com.github.application.name",G_APPLICATION_FLAGS_NONE);
g_signal_connect(app, "activate", G_CALLBACK (activate), NULL);
int status = g_application_run(G_APPLICATION (app), argc, argv);
g_object_unref(app);
return status;
}

I believe this is because you either have to join or abort the thread when you quit the application normally; otherwise it's orphaned and continues to run with no way to stop it. The same goes for the subprocess, you should make sure either to signal it to stop somehow (depends on which process you are spawning) or use g_subprocess_force_exit() when quitting the application.
However, if you are already spawning a subprocess, there is actually no need to start a new thread to do it in! You can use g_subprocess_wait_check_async().

Related

How to avoid blocking function g_application_run

I have an application with the following pattern (it's an embedded application) that I don't want to change:
void
main(int argc, char *argv[])
{
some_init_functions();
while(1) {
some_functions();
}
}
I'd like to simulate the application on Windows so I'd like to use Gtk+3 to show a window that simulate the display used in the original application.
The problem is the function g_application_run() that is blocking.
Is it possible to manually call a Gtk+/GLib function to process pending events only and returns immediately? I would call this function in the while(1) loop.
I read about gtk_main_iteration_do(), but I didn't understand how to use it without calling g_application_run().
It's your job to integrate your application in the GUI, not the other way around. What you should do is call g_application_run, and add an event source with g_timeout_add or g_idle_add that will call your callback. In that callback, just call some_functions() once. The GTK main loop will take care of calling it again and again.
It is possible to get out of the g_application_run loop. Events can be handled by g_main_context_iteration(GMainContext *context, gboolean may_block). With may_block = TRUE, it will only return to the main loop after an event has been handled. With may_block = FALSE, only the highest priority events will be handled after which control returns to the loop.
The code below is based upon the example-0.c code from the GTK Reference Manual, yet making the process flow from g_application_run explicit. Note that command line arguments are not processed, and several checks are omitted.
A timeout event is added such that, in combination with may_block = TRUE, the main loop advances at least once per second. Also, a callback is added on the destroy event, such that, in combination with a global variable, the main loop can stop if the window is closed.
As a direct answer to the question asked: you would need to make sure correct set-up and break-down is performed, and add g_main_context_iteration (context, may_block); to your while (1) loop.
#include <gtk/gtk.h>
static bool application_running; // As use_count is private
// Add close_window event watcher to tell our application loop we should stop
static void
close_window (void)
{
printf("Window is closed\n");
application_running = FALSE;
}
// Add timeout to make sure the application loop is unblocked once per second
static gboolean
timeout (gpointer data)
{
printf("timeout\n");
return true;
}
static void
activate (GtkApplication* app,
gpointer user_data)
{
GtkWidget *window;
window = gtk_application_window_new (app);
// Add destroy call-back so we know when window is closed.
g_signal_connect (window, "destroy", G_CALLBACK (close_window), NULL);
gtk_window_set_title (GTK_WINDOW (window), "Window");
gtk_window_set_default_size (GTK_WINDOW (window), 200, 200);
gtk_widget_show (window);
}
int
main (int argc,
char **argv)
{
GtkApplication *app;
int status;
app = gtk_application_new ("org.gtk.example", G_APPLICATION_FLAGS_NONE);
g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
g_timeout_add_seconds (1, timeout, NULL);
// **** begin g_application_run alternative ****
// Setup
GMainContext *context;
gboolean acquired_context;
context = g_main_context_default ();
acquired_context = g_main_context_acquire (context);
g_return_val_if_fail (acquired_context, 0);
GError *error = NULL;
if (!g_application_register (G_APPLICATION (app), NULL, &error))
{
g_printerr ("Failed to register: %s\n", error->message);
g_error_free (error);
return 1;
}
g_application_activate (G_APPLICATION (app));
// Main event loop
application_running = true;
int loop = 0;
while (application_running) {
bool may_block = TRUE;
// may_block = TRUE: g_main_context_iteration blocks execution if no events are coming
// may_block = FALSE: g_main_context_iterations processes pending events and continues
g_main_context_iteration (context, may_block);
printf("Loop %i\n", loop++);
}
// Release
g_settings_sync ();
while (g_main_context_iteration (context, FALSE))
;
g_main_context_release (context);
// **** end g_application_run alternative ****
g_object_unref (app);
return status;
}

What could be wrong: GLib-GObject-WARNING **: cannot register existing type 'PangoCairoFont'

I spent many weeks trying to get gtk+ 3.22 to build on Visual Studio 2015. Finally I got it built but the small GUI program failed to initialize gtk. The error is shown as below:
gtk+_gtk_test.exe:15980): Gtk-WARNING **: Could not find the icon 'window-minimize-symbolic-ltr'. The 'hicolor' theme
was not found either, perhaps you need to install it.
You can get a copy from:
http://icon-theme.freedesktop.org/releases
(gtk+_gtk_test.exe:15980): GLib-GObject-WARNING **: cannot register existing type 'PangoCairoFont'
(gtk+_gtk_test.exe:15980): GLib-GObject-CRITICAL **: g_type_interface_add_prerequisite: assertion 'G_TYPE_IS_INTERFACE (interface_type)' failed
(gtk+_gtk_test.exe:15980): Glib-CRITICAL **: g_once_init_leave: assertion 'result != 0' failed
The first warning exists because the executable cannot locate the icon files. I have already figured out how to fix this. However, I am unable to get the second Warning fixed. This is my first gtk+ project. When I debug the code, it seems that PangoCairoFont type failed because of the existence of PangoCairoWin32Font type.
What could be wrong here? Appreciate your advice.
Source code of the program:
#include <gtk/gtk.h>
void hello(GtkWidget *widget, gpointer data)
{
g_print("Hello, World\n");
}
gint delete_event(GtkWidget *widget, GdkEvent event, gpointer data)
{
/* when this fucntion returns FALSE, the delete-event
signal becomes a destroy signal*/
return FALSE;
}
void end_program(GtkWidget *widget, gpointer data)
{
/* End the main loop */
gtk_main_quit();
}
int main(int argc, char **argv)
{
GtkWindow *window;
GtkButton *button;
/* initialize Gtk+ */
gtk_init(&argc, &argv);
/* create window, set default height and width to 200px */
window = g_object_new(GTK_TYPE_WINDOW,
"default-height", 200,
"default-width", 200,
"border-width", 12,
"title", "GtkHello",
NULL);
/* add signal handlers for window */
g_signal_connect(window, "delete-event", G_CALLBACK(delete_event),
NULL);
g_signal_connect(window,
"destroy", G_CALLBACK(end_program),
NULL);
/* create button */
button = g_object_new(GTK_TYPE_BUTTON,
"label", "_Hello, World!\nClick here.",
"use-underline", TRUE,
NULL);
g_signal_connect(button,
"clicked", G_CALLBACK(hello),
NULL);
g_signal_connect_swapped(button,
"clicked", G_CALLBACK(gtk_widget_destroy),
window);
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(button));
gtk_widget_show_all(GTK_WIDGET(window));
/* start main loop */
gtk_main();
return 0;
}
I figured out. I mistakenly built pangocairo module into a static lib instead of DLL. This lib is further linked into different DLLs so the global variable has several copies, which caused the problem.

blank dialogue box without my text nor OK button

I'm trying to popup an OK message box in my gtk browser, but all I'm getting is blank grey square patch without my text in it and even button is not visible.
PFB the function which I'm using to render message box :
Void DisplayOKPopup()
{
dialogue=gtk_message_dialogue_new(GTK_WINDOW(WebtBrowserWindow),
GTK_DIALOGUE_DESTROY_WITH_PARENT,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
"text message");
gtk_widget_show(dialogue);
LOGDEBUG(" 1");
gtk_dialogue_run(GTK_DIALOGUE (dialogue));
LOGDEBUG("2");
gtk_widget_destroy (dialogue);
}
As per my debug log, I can see that control is passing till LOGDEBUG("1") and after that it goes to gtk_dialogue_run after that UI is getting crashed, the line next to run i.e LOGDEBUG("2") is not getting executed.
Kindly provide your inputs as I'm working on this since 3 days:!
As concluded, the problem arises from the use of threads. There are several approaches to solve the issue but since there is not code, I'll try with a simple example so that you can recreate it on your code.
Take a global Boolean variable as a flag and on your thread, set it to true so that a "periodic" idle callback can check it and if the flag is TRUE then show the dialog. The logic is that the Gtk UI functions are called from the mainloop/main thread and not from the worker threads.
DisplayOkPopup just has a simple "counter" from 0 to MAX_INT (32 bits) and set's the global flag as TRUE.
check_for_dialog it's a callback that runs on mainloop idle time and check for the flag, if TRUE then runs the dialog.
exit is dirty and will output errors but the goal ain't that, its just a tip/hint for your solution.
Example:
#include <gtk/gtk.h>
gboolean dialog_active;
gboolean show_dialog_popup;
GtkWidget *window;
gpointer DisplayOKPopup (gpointer user_data) {
int i;
while (TRUE) {
for (i = 0; i < G_MAXINT32; i++) {
// nop
}
show_dialog_popup = TRUE;
}
return NULL;
}
gboolean check_for_dialog (gpointer user_data) {
if (show_dialog_popup == TRUE && dialog_active == FALSE) {
dialog_active = TRUE;
GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
"text message");
gtk_dialog_run(GTK_DIALOG (dialog));
show_dialog_popup = FALSE;
dialog_active = FALSE;
gtk_widget_destroy(dialog);
}
return TRUE;
}
static void app_activate(GtkApplication *app, gpointer user_data) {
window = gtk_application_window_new(app);
gtk_window_set_title(GTK_WINDOW(window), "Window Title Here");
gtk_window_set_default_size(GTK_WINDOW(window), 700, 400);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
//gtk_container_add(GTK_CONTAINER(window), fixed);
gtk_widget_show_all(window);
g_idle_add(check_for_dialog, NULL);
g_thread_new("my thread", DisplayOKPopup, NULL);
}
int main(int argc, char **argv) {
GtkApplication *app;
int status;
show_dialog_popup = FALSE;
dialog_active = FALSE;
app = gtk_application_new("your.application.id", G_APPLICATION_FLAGS_NONE);
g_signal_connect(app, "activate", G_CALLBACK(app_activate), NULL);
status = g_application_run(G_APPLICATION(app), argc, argv);
g_object_unref(app);
return status;
}
Build and run:
$ gcc -o test test.c `pkg-config --cflags --libs gtk+-3.0`
$ ./test
Result:
EDIT:
Answer to your comment is:
To have custom buttons on your dialog then use:
gtk_dialog_new_with_buttons
gtk_dialog_add_button (if dialog exists, will add 1 button)
gtk_dialog_add_buttons (same as above but can add many buttons)
Example for 1):
dialog = gtk_dialog_new_with_buttons ("My dialog",
main_app_window,
flags,
"_OK",
GTK_RESPONSE_ACCEPT,
"_Cancel",
GTK_RESPONSE_REJECT,
NULL);
Example for 2):
gtk_dialog_add_button (GTK_DIALOG(dialog),
"This is my button",
GTK_RESPONSE_ACCEPT);
Example for 3) is same as 2) but can handle many buttons and terminates with NULL.

goocanvas signal handling corrupted after using a dialog

I use a goocanvas and use signals for mouse events connected to some graphical items. If I use a dialog from a signal handler, all signals are broken after closing the dialog. Is this a bug of gtkmm/goocanvas or is this some kind of misuse in my program?
The wrong behavior is:
You can click somewhere in the canvas area, nothing is happen which is correct. If you click on the circle the signal handler starts the dialog which is also expected. After closing the dialog ( OK button ) you can click somewhere on the canvas and the signal handler is called which is wrong.
In my real program the signal handlers are sometimes never called and sometimes called on wrong areas and so on. A bit strange behavior. I hope someone can find the problem.
#include <gtkmm.h>
#include <goocanvasmm.h>
#include <sigc++/sigc++.h>
bool ShowDialog( const Glib::RefPtr<Goocanvas::Item>& item, GdkEventButton* ev)
{
enum { OK };
Gtk::Dialog dialog;
dialog.add_button( Gtk::Stock::OK, OK);
dialog.show_all_children();
dialog.run();
return false;
}
int main(int argc, char* argv[])
{
Gtk::Main app(&argc, &argv);
Goocanvas::init("example", "0.1", argc, argv);
Gtk::Window win;
Goocanvas::Canvas m_canvas;
m_canvas.set_size_request(640, 480);
m_canvas.set_bounds(0, 0, 800, 800);
Glib::RefPtr<Goocanvas::Item> root = m_canvas.get_root_item();
Glib::RefPtr<Goocanvas::Ellipse> outer = Goocanvas::Ellipse::create( 100,100,20,20);
outer->property_line_width() = 5;
outer->property_stroke_color() = "red";
outer->property_fill_color()="blue";
root->add_child( outer );
sigc::connection conn2= outer->signal_button_press_event().connect( sigc::ptr_fun(&ShowDialog));
win.add(m_canvas);
win.show_all_children();
Gtk::Main::run(win);
return 0;
}

How do I send a client-event asynchronously to a GtkWidget?

I'm trying to send and receive a client-event using a GtkWidget on the win32 platform. The sending code looks like this:
GtkWidget *Wnd;
GdkNativeWindow Hnd =
#ifdef WIN32
GDK_WINDOW_HWND(Wnd->window);
#else
GDK_WINDOW_XWINDOW(Wnd->window);
#endif
GdkEvent *Event = gdk_event_new(GDK_CLIENT_EVENT);
// fill out Event params
gdk_event_send_client_message(Event, Hnd);
Receiving code looks like this:
static gboolean MyClientEvent(GtkWidget *widget, GdkEventClient *ev, MyWnd *Wnd)
{
// breakpoint here...
return TRUE;
}
GtkWidget *Wnd = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect( G_OBJECT(Wnd),
"client-event",
G_CALLBACK(MyClientEvent),
this);
gtk_widget_add_events(Wnd, GDK_ALL_EVENTS_MASK);
I used Spy++ to see the message getting sent, so I know the sending side is ok. The receiving side however doesn't get the client-event. I was expecting my breakpoint in the callback to trigger... but it doesn't.
I'm not even sure if a GtkWindow can receive a client-event... from past experience on X11 I thought it was pretty much the same as any other GtkWidget in that respect. Maybe on the win32 platform it's kinda different. But still I'd like to be able to get this working.
I would like this to work with asynchronously, and in a thread-safe fashion, so that I can send events from worker threads up to the GUI thread.
I have a solution that seems to work. It may not be optimal but it's in the ball park.
struct GlibEventParams
{
GtkWidget *w;
GdkEvent *e;
};
static gboolean
GlibPostMessage(GlibEventParams *p)
{
GDK_THREADS_ENTER ();
gtk_propagate_event(p->w, p->e);
gdk_event_free(p->e);
delete p;
GDK_THREADS_LEAVE ();
return FALSE;
}
bool MySendEvent(GtkWidget *Wnd, GtkEvent *Event)
{
bool Status = false;
if (Event && Wnd)
{
GlibEventParams *p = new GlibEventParams;
p->w = Wnd;
p->e = gdk_event_new(GDK_CLIENT_EVENT);
*p->e = *Event;
Status = g_idle_add((GSourceFunc)GlibPostMessage, p) > 0;
}
else assert(!"No Event or Wnd");
return Status;
}
If someone else has constructive comments I'll add/modify this as required.