Hi
Just some explanation. Your timeout is is dispatched by gtk_main(). As
doing your call to the backend,
you have to listen on message and then forward the event to the UI.
AgsAudio::set-pads() actually is part of my backend. Sends the message.
Here you need some async non-blocking call to your backend, at your
own taste. E.g. this call
invokes ags_audio_set_pads().
The timeout function polls your messages and forwards the event:
AgsMachine::resize-pads() is part of the UI. You listen to this event within UI.
Connect as usual, note the callback does modify is_available to TRUE:
do_wait = TRUE;
is_available = FALSE;
g_signal_connect_after(machine, "resize-pads",
G_CALLBACK(pads_resized_callback),
&is_available);
Meanwhile you pause execution of UI by calling within gtk_main().
while((do_wait && !is_available[0])){
usleep(1000000 / 30);
g_main_context_iteration(NULL,
FALSE);
}
Your source is dispatched but gtk_main() is still within the loop shown above.
Bests,
Joël
On Thu, Jan 25, 2018 at 11:54 PM, Joël Krähemann <jkraehem...@gmail.com> wrote:
> Hi,
>
> Well there was some redundant code. This actually fixes it:
>
> http://git.savannah.nongnu.org/cgit/gsequencer.git/tree/ags/X/file/ags_simple_file.c?h=1.5.x#n1904
>
> Bests,
> Joël
>
>
> On Thu, Jan 25, 2018 at 11:16 PM, Joël Krähemann <jkraehem...@gmail.com>
> wrote:
>> Hi,
>> You do some async work? Read about:
>>
>> g_timeout_add_full();
>>
>> and
>>
>> g_main_context_iteration();
>>
>> You, can callback the to the UI forwarded event. I do something similar
>> as reading a file from a different thread:
>>
>> http://git.savannah.nongnu.org/cgit/gsequencer.git/tree/ags/X/file/ags_simple_file.c?h=1.4.x#n1957
>>
>> FYI: the UI thread shall run always by gtk_main().
>>
>> Bests,
>> Joël
>>
>> On Thu, Jan 25, 2018 at 11:10 PM, 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
>>>>>
>>>>>
>>>>>
>>>
>>>
>>> _______________________________________________
>>> gtk-app-devel-list mailing list
>>> gtk-app-devel-list@gnome.org
>>> https://mail.gnome.org/mailman/listinfo/gtk-app-devel-list
_______________________________________________
gtk-app-devel-list mailing list
gtk-app-devel-list@gnome.org
https://mail.gnome.org/mailman/listinfo/gtk-app-devel-list
