Re: Pause and resume GtkApplication

[Alexander Koeppe <alexander@koeppe.rocks>]

I know about the possiblity to fire the low-level functions using an
button callback. However this would draw an exception for other UI
choices the application has: e.g. text, deamon.

Therefore I'm looking for a way to keep the application structure for
all UIs the same.

There is the test app I'm playing with:


#include <gtk/gtk.h>

GtkApplication *app;
GtkWidget *window;
int initialized = 0;

void quit_cb(GSimpleAction *action, GVariant *value, gpointer data)
{
   g_print("quit!\n");
   g_object_unref(app);
   exit(0);
}

void restart_cb(GSimpleAction *action, GVariant *value, gpointer data)
{
   g_print("restart!\n");
   g_application_quit(G_APPLICATION(app));
}

void test_cb(GSimpleAction *action, GVariant *value, gpointer data)
{
  GtkWidget *dialog;
  GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;


  dialog = gtk_message_dialog_new(GTK_WINDOW(window),
                                  flags,
                                  GTK_MESSAGE_ERROR,
                                  GTK_BUTTONS_CLOSE,
                                  "TEst Message");
  g_signal_connect_swapped(dialog, "response",
                           G_CALLBACK(gtk_widget_destroy),
                           dialog);
  gtk_dialog_run(GTK_DIALOG(dialog));
}

static void shutdown(GtkApplication *app, gpointer data)
{
   initialized = 1;
}

static void
activate (GtkApplication *app,
          gpointer        user_data)
{
  GtkWidget *header, *menubutton, *frame, *overlay, *combo, *box;
  GtkBuilder *builder;

  GActionEntry actions[] = {
      {"test_action", test_cb, NULL, NULL, NULL,{}},
      {"restart", restart_cb, NULL, NULL, NULL, {}},
      {"quit", quit_cb, NULL, NULL, NULL, {}}
  };


  g_action_map_add_action_entries(G_ACTION_MAP(app), actions,
      G_N_ELEMENTS(actions), app);



  if (initialized == 0) {
     window = gtk_application_window_new (app);
     gtk_window_set_default_size (GTK_WINDOW (window), 500, 300);
  }
  else {
     gtk_application_add_window(app, GTK_WINDOW(window));
  }
  gtk_window_set_title (GTK_WINDOW (window), "buildertest");

  /* Header Bar */
  header = gtk_header_bar_new();
  gtk_header_bar_set_title(GTK_HEADER_BAR(header), "Yeah");
  gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(header), TRUE);
  gtk_window_set_titlebar(GTK_WINDOW(window), header);

  /* Menu Button */
  menubutton = gtk_menu_button_new();

  /* Menu for Menubutton */
  builder = gtk_builder_new();
  gtk_builder_add_from_string(builder,
         "<interface>"
         "  <menu id='app-menu'>"
         "    <section>"
         "      <item>"
         "        <attribute name='label'
translatable='yes'>Restart</attribute>"
         "        <attribute name='action'>app.restart</attribute>"
         "      </item>"
         "      <item>"
         "        <attribute name='label'
translatable='yes'>Quit</attribute>"
         "        <attribute name='action'>app.quit</attribute>"
         "      </item>"
         "    </section>"
         "  </menu>"
         "  <menu id='test-menu'>"
         "    <section>"
         "    <attribute name='label' translatable='yes'>Test</attribute>"
         "      <item>"
         "        <attribute name='label' translatable='yes'>Test
Entry</attribute>"
         "        <attribute name='action'>app.test_action</attribute>"
         "        <attribute name='accel'>t</attribute>"
         "      </item>"
         "    </section>"
         "  </menu>"
         "</interface>", -1, NULL);

  gtk_application_set_app_menu(GTK_APPLICATION(app),
        G_MENU_MODEL(gtk_builder_get_object(builder, "app-menu")));

  gtk_menu_button_set_menu_model(GTK_MENU_BUTTON(menubutton),
      G_MENU_MODEL(gtk_builder_get_object(builder, "test-menu")));

  gtk_button_set_image(GTK_BUTTON(menubutton),
       gtk_image_new_from_icon_name("open-menu-symbolic",
GTK_ICON_SIZE_MENU));
  gtk_header_bar_pack_end(GTK_HEADER_BAR(header), menubutton);

  /* content area */
  if (initialized) {
     overlay = gtk_bin_get_child(GTK_BIN(window));
     gtk_container_remove(GTK_CONTAINER(window), overlay);
  }

  overlay = gtk_overlay_new();
  gtk_container_add(GTK_CONTAINER(window), overlay);

  frame = gtk_frame_new("Rahmen");
  gtk_container_add(GTK_CONTAINER(overlay), frame);

  box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
  gtk_container_add(GTK_CONTAINER(frame), box);

  combo = gtk_combo_box_text_new();
  gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(combo), "id1", "Entry 1");
  gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(combo), "id2", "Entry 2");
  gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
  gtk_widget_set_hexpand(combo, TRUE);

  gtk_box_pack_start(GTK_BOX(box), combo, FALSE, FALSE, 0);



  gtk_widget_show_all(window);
}

int main(int   argc,
         char *argv[])
{
  app = NULL;
  int status;

  app = gtk_application_new ("org.gnome.Buildertest",
G_APPLICATION_FLAGS_NONE);
  g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
  g_signal_connect (app, "shutdown", G_CALLBACK(shutdown), NULL);
  status = g_application_run (G_APPLICATION (app), argc, argv);

  g_print("some things happen here\n");

  g_object_unref(G_OBJECT(app));

  app = gtk_application_new ("org.gnome.Buildertest",
G_APPLICATION_FLAGS_NONE);
  g_signal_connect (app, "activate", G_CALLBACK (activate), NULL);
  status = g_application_run (G_APPLICATION (app), argc, argv);
 
  return status;
}


Am 22.01.2018 um 22:09 schrieb Lucky B.C:
> Hi, can you show your demo about the way you did? But I think you
> should keep the gtk_main() runs, because you can run your low-level
> functions by "clicked" signal on button.
>
> On Jan 23, 2018 03:44, "Alexander Koeppe" <alexander@koeppe.rocks> wrote:
>
>     Hi,
>
>     I have an application where some things need to be setup in the
>     UI, then
>     some low-level routines to be executed using the setup values and then
>     resuming the UI loop for further operation.
>
>     Since I'm migrating the GTK code from GTK2/3 compatible to
>     GNOME/GTK3, I
>     make use of g_application_run().
>
>     However, I find no simialar way to interrupt the loop (e.g.
>     gtk_main_quit()) and resuming the UI later (gtk_main()).
>
>     The only way I found yet is to quit the application using
>     g_application_quit() but keep the window widget, clearing the
>     application (g_object_unref()) and creating a new application after
>     executing the low-level routines and finally adding the still existing
>     window widget to this new application using
>     gtk_application_add_window(). This way I can reuse the window and
>     avoid
>     any flickering which is the required effect.
>
>     The only caveat is, the added window is not considered being the
>     primary
>     instance of the second application, hence the app-menu isn't
>     displayed.
>
>     Is there any way to define a window added being the primary
>     instance of
>     the application or to show the app-menu (set using
>     gtk_application_set_app_menu()) in such an non-primary window, or
>     even a
>     complete different approach?
>
>
>     Thanks and regards
>
>     - Alex
>
>
>     _______________________________________________
>     gtk-app-devel-list mailing list
>     gtk-app-devel-list gnome org <mailto:gtk-app-devel-list gnome org>
>     https://mail.gnome.org/mailman/listinfo/gtk-app-devel-list
>     <https://mail.gnome.org/mailman/listinfo/gtk-app-devel-list>