GNOME.org
 

Re: Pause and resume GtkApplication

Well, in the case, I will tell something about me, first I've never used
the GtkApplication just main window maybe sub windows (dialogs) too, and my
programs did not do as what you are trying to do. Second I'm a C
programmer, in my opinion, you should redesign your app because sometimes
we must do that to gain our main target not about GUI which we only need
for rendering/displaying to the user. Nothing is perfect! If we don't want
the user see the private data or something else, we just don't show it by
doing in another thread. Yes, the main loop of GTK always runs after we
called gtk_main (), but we can create another thread before gtk_init () is
called and run it anytime we need by gdk_threads_enter and
gdk_threads_leave, for more detail see GThreads
<https://developer.gnome.org/glib/stable/glib-Threads.html#g-thread-new>
and IDLES <https://developer.gnome.org/gdk2/stable/gdk2-Threads.html>.
Finally just reload/refresh our new data/thing again to the user or show a
message dialog says somthing else, for example "Your data changed!". I
wonder is there some programs which have the same what you are trying to
do? If there's one or more, please send me the link, I really want to test
them.

On Fri, Jan 26, 2018 at 5:10 AM, Alexander Koeppe <alexander@koeppe.rocks>
wrote:


Thanks Lucky,

Good idea to create the widget right away and hide it until it's time.

However, just by accident, I got back the app-menu in the window.

Try this with the code below:

1. After I selected "Restart" simulating the pause and resume, the
app-menu disappeared.
2. Then I double-clicked the header-bar to maximise the window and the
app-menu reappeared.
3. Again double-clicked the header-bar to restore the original geometry
the app-menu is still there.

This is what I want. Question is, what happens when I double click the
header-bar and can I emulate this event in code?

I feel being just 1 grain off my goal....

Thanks

   -Alex


Am 23.01.2018 um 22:37 schrieb Lucky B.C:

Wow, I see your problem is that you did not understand what GtkBuilder
and Gtk are doing, Because If I'm not wrong, each choice (entry) is a
function to start something you want to do after the user/you clicked
to the button called "restart". Here's my solution, it's maybe help
you.

*) You can use gtk_widget_hide (target) function to hide any widget,
in this case it's the main window. Then you can do your low-level
functions what the other can see at the time after the signal
"clicked" activated.

Note: Some programs I saw the program did not exit when it's called to
restart, there's only the changed/related data must be reload to
buffer/ram, and the program must stop rendering/running at the time,
after the reloading's done the program continues to render/display the
new data in the screen. The reloading can be done in a new thread too,
after used you can delete it too.

On Wed, Jan 24, 2018 at 2:52 AM, Alexander Koeppe
<alexander@koeppe.rocks> wrote:

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
https://mail.gnome.org/mailman/listinfo/gtk-app-devel-list
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]