ui/gtk/window.c

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2017 Olaf Wintermann. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "../ui/window.h"
#include "../ui/properties.h"
#include "../common/context.h"
#include "../common/menu.h"
#include "../common/toolbar.h"
#include "../common/utils.h"

#include <cx/mempool.h>

#include "menu.h"
#include "toolbar.h"
#include "container.h"
#include "headerbar.h"
#include "button.h"
#include "window.h"

static int nwindows = 0;

static int window_default_width = 650;
static int window_default_height = 550;

static int splitview_window_default_pos = -1;
static UiBool splitview_window_use_prop = TRUE;

static gboolean ui_window_destroy(void *data)  {
    UiObject *obj = data;
    uic_object_destroy(obj);
    
    nwindows--;
#ifdef UI_GTK2
    if(nwindows == 0) {
        gtk_main_quit();
    }
#endif
    
    return FALSE;
}

void ui_window_widget_destroy(UiObject *obj) {
#if GTK_MAJOR_VERSION >= 4
    gtk_window_destroy(GTK_WINDOW(obj->widget));
#else
    gtk_widget_destroy(obj->widget);
#endif
}

void ui_exit_event(GtkWidget *widget, gpointer data) {
    // delay exit handler  
    g_idle_add(ui_window_destroy, data);
}

gboolean ui_window_close_request(UiObject *obj) {
    if(obj->widget) {
        void *appwindow = g_object_get_data(G_OBJECT(obj->widget), "ui.appwindow");
        if(appwindow) {
            int width = 0;
            int height = 0;
#if GTK_CHECK_VERSION(4, 10, 0)
            graphene_rect_t bounds;
            if(gtk_widget_compute_bounds(obj->widget, obj->widget, &bounds)) {
                width = bounds.size.width;
                height = bounds.size.height;
            }
#elif GTK_CHECK_VERSION(4, 0, 0)
            GtkAllocation alloc;
            gtk_widget_get_allocation(GTK_WIDGET(obj->widget), &alloc);
            width = alloc.width;
            height = alloc.height;
#else
            gtk_window_get_size(GTK_WINDOW(obj->widget), &width, &height);
#endif
            if(width > 0 && height > 0) {
                char width_str[32];
                char height_str[32];
                snprintf(width_str, 32, "%d", width);
                snprintf(height_str, 32, "%d", height);
                ui_set_property("ui.window.width", width_str);
                ui_set_property("ui.window.height", height_str);
            }
        }
    }
    
    obj->ref--;
    if(obj->ref > 0) {
#if GTK_CHECK_VERSION(2, 18, 0)
        gtk_widget_set_visible(obj->widget, FALSE);
#else
        gtk_widget_hide(obj->widget);
#endif
        return TRUE;
    } else {
        uic_context_prepare_close(obj->ctx);
        return FALSE;
    }
}

#if GTK_MAJOR_VERSION >= 4
static gboolean close_request(GtkWindow* self, UiObject *obj) {
    return ui_window_close_request(obj);
}
#else
static gboolean close_request(GtkWidget* self, GdkEvent* event, UiObject *obj) {
    return ui_window_close_request(obj);
}
#endif

static void save_window_splitview_pos(GtkWidget *widget, void *unused) {
    int pos = gtk_paned_get_position(GTK_PANED(widget));
    char buf[32];
    snprintf(buf, 32, "%d", pos);
    ui_set_property("ui.window.splitview.pos", buf);
}

static UiObject* create_window(const char *title, UiBool sidebar, UiBool splitview, UiBool simple) {
    UiObject *obj = uic_object_new_toplevel();
   
#ifdef UI_LIBADWAITA
    obj->widget = adw_application_window_new(ui_get_application());
#elif !defined(UI_GTK2)
    obj->widget = gtk_application_window_new(ui_get_application());
#else
    obj->widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
#endif
    
#if GTK_CHECK_VERSION(4, 0, 0)
    obj->ctx->action_map = G_ACTION_MAP(obj->widget);
#endif
    
    if(title != NULL) {
        gtk_window_set_title(GTK_WINDOW(obj->widget), title);
    }
    
    if(!simple) {
        g_object_set_data(G_OBJECT(obj->widget), "ui.appwindow", obj);
    }
    
    int window_width = window_default_width;
    int window_height = window_default_height;
    if(!simple) {
        ui_get_window_default_width(&window_width, &window_height);
    }
    gtk_window_set_default_size(
                GTK_WINDOW(obj->widget),
                window_width,
                window_height);
    
    obj->destroy = ui_window_widget_destroy;
    g_signal_connect(
            obj->widget,
            "destroy",
            G_CALLBACK(ui_exit_event),
            obj);
#if GTK_MAJOR_VERSION >= 4
    g_signal_connect(
            obj->widget,
            "close-request",
            G_CALLBACK(close_request),
            obj);
#else
    g_signal_connect(
            obj->widget,
            "delete-event",
            G_CALLBACK(close_request),
            obj);
#endif
    
    int splitview_pos = 0;
    if(splitview) {
        const char *splitview_pos_str = ui_get_property("ui.window.splitview.pos");
        splitview_pos= splitview_window_default_pos;
        if(splitview_pos < 0) {
            splitview_pos = window_width / 2;
        }
        if(splitview_pos_str && splitview_window_use_prop) {
            int sv_pos = atoi(splitview_pos_str);
            if(sv_pos > 0) {
                splitview_pos = sv_pos;
            }
        }
    }
    
    GtkWidget *vbox = ui_gtk_vbox_new(0);
#ifdef UI_LIBADWAITA
    GtkWidget *toolbar_view = adw_toolbar_view_new();
    adw_toolbar_view_set_content(ADW_TOOLBAR_VIEW(toolbar_view), vbox);
    
    GtkWidget *headerbar_sidebar = NULL;
    GtkWidget *headerbar_main = adw_header_bar_new();
    GtkWidget *headerbar_right = NULL;
    
    GtkWidget *content = toolbar_view;
    if(splitview) {
        content = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
        g_signal_connect(
                content,
                "destroy",
                G_CALLBACK(save_window_splitview_pos),
                NULL);
        
        gtk_paned_set_position(GTK_PANED(content), splitview_pos);
        
        GtkWidget *right_panel = adw_toolbar_view_new();
        GtkWidget *right_vbox = ui_gtk_vbox_new(0);
        adw_toolbar_view_set_content(ADW_TOOLBAR_VIEW(right_panel), right_vbox);
        
        headerbar_right = adw_header_bar_new();
        adw_header_bar_set_show_title(ADW_HEADER_BAR(headerbar_right), FALSE);
        adw_toolbar_view_add_top_bar(ADW_TOOLBAR_VIEW(right_panel), headerbar_right);
        
        adw_header_bar_set_show_end_title_buttons(ADW_HEADER_BAR(headerbar_main), FALSE);
        
        gtk_paned_set_start_child(GTK_PANED(content), toolbar_view);
        gtk_paned_set_end_child(GTK_PANED(content), right_panel);
        
        g_object_set_data(G_OBJECT(obj->widget), "ui_window_splitview", content);
        g_object_set_data(G_OBJECT(obj->widget), "ui_left_panel", vbox);
        g_object_set_data(G_OBJECT(obj->widget), "ui_right_panel", right_vbox);
    }
    
    GtkWidget *content_box = vbox;
    
    if(sidebar) {
        GtkWidget *splitview = adw_overlay_split_view_new();
        adw_application_window_set_content(ADW_APPLICATION_WINDOW(obj->widget), splitview);
        
        GtkWidget *sidebar_toolbar_view = adw_toolbar_view_new();
        adw_overlay_split_view_set_sidebar(ADW_OVERLAY_SPLIT_VIEW(splitview), sidebar_toolbar_view);
        headerbar_sidebar = adw_header_bar_new();
        adw_header_bar_set_show_title(ADW_HEADER_BAR(headerbar_sidebar), FALSE);
        adw_toolbar_view_add_top_bar(ADW_TOOLBAR_VIEW(sidebar_toolbar_view), headerbar_sidebar);
        
        adw_overlay_split_view_set_content(ADW_OVERLAY_SPLIT_VIEW(splitview), content);
        
        g_object_set_data(G_OBJECT(obj->widget), "ui_sidebar", sidebar_toolbar_view);
    } else {
        adw_application_window_set_content(ADW_APPLICATION_WINDOW(obj->widget), content);
    }
    
    const char *show_title = ui_get_property("ui.gtk.window.showtitle");
    if(show_title) {
        if(!strcmp(show_title, "main") && sidebar) {
            adw_header_bar_set_show_title(ADW_HEADER_BAR(headerbar_sidebar), FALSE);
        } else if(!strcmp(show_title, "sidebar")) {
            adw_header_bar_set_show_title(ADW_HEADER_BAR(headerbar_main), FALSE);
            adw_header_bar_set_show_title(ADW_HEADER_BAR(headerbar_sidebar), TRUE);
        } else if(!strcmp(show_title, "false")) {
            adw_header_bar_set_show_title(ADW_HEADER_BAR(headerbar_sidebar), FALSE);
            adw_header_bar_set_show_title(ADW_HEADER_BAR(headerbar_main), FALSE);
        } else {
            fprintf(stderr, "Unknown value '%s' for property ui.gtk.window.showtitle\n", show_title);
            adw_header_bar_set_show_title(ADW_HEADER_BAR(headerbar_sidebar), FALSE);
        }
    } else {
        adw_header_bar_set_show_title(ADW_HEADER_BAR(headerbar_main), FALSE);
        if(sidebar) {
            adw_header_bar_set_show_title(ADW_HEADER_BAR(headerbar_sidebar), TRUE);
        }
    }
    
    adw_toolbar_view_add_top_bar(ADW_TOOLBAR_VIEW(toolbar_view), headerbar_main);
    g_object_set_data(G_OBJECT(obj->widget), "ui_headerbar", headerbar_main);
    
    if(!simple) {
        ui_fill_headerbar(obj, headerbar_sidebar, headerbar_main, headerbar_right);
    }
#else
    if(!simple) {
        // menu
        if(uic_get_menu_list()) {
            GtkWidget *mb = ui_create_menubar(obj);
            if(mb) {
                BOX_ADD(vbox, mb);
            }
        }

        // toolbar
#if GTK_MAJOR_VERSION >= 4
        // TODO: gtk4 toolbar
#else
        if(uic_toolbar_isenabled()) {
            GtkWidget *tb = ui_create_toolbar(obj, sidebar);
            if(tb) {
                BOX_ADD(vbox, tb);
            }
        }
#endif
        //GtkWidget *hb = ui_create_headerbar(obj);
        //gtk_window_set_titlebar(GTK_WINDOW(obj->widget), hb);
    }
    
    GtkWidget *content_box = ui_gtk_vbox_new(0);
    WINDOW_SET_CONTENT(obj->widget, vbox);
    if(sidebar || splitview) {
        GtkWidget *paned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
        if(sidebar) {
            GtkWidget *sidebar_vbox = ui_gtk_vbox_new(0);
            PANED_SET_CHILD1(paned, sidebar_vbox);
            g_object_set_data(G_OBJECT(obj->widget), "ui_sidebar", sidebar_vbox);
            gtk_paned_set_position(GTK_PANED(paned), 200);
        }
        
        if(splitview) {
            GtkWidget *content_paned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
            gtk_paned_set_position(GTK_PANED(content_paned), splitview_pos);
            PANED_SET_CHILD2(paned, content_paned);
            
            GtkWidget *right_content_box = ui_gtk_vbox_new(0);
            PANED_SET_CHILD1(content_paned, content_box);
            PANED_SET_CHILD2(content_paned, right_content_box);
            
            g_object_set_data(G_OBJECT(obj->widget), "ui_window_splitview", content_paned);
            g_object_set_data(G_OBJECT(obj->widget), "ui_left_panel", content_box);
            g_object_set_data(G_OBJECT(obj->widget), "ui_right_panel", right_content_box);
        } else {
            PANED_SET_CHILD2(paned, content_box);
        }
        
        BOX_ADD_EXPAND(GTK_BOX(vbox), paned);
    } else {
        BOX_ADD_EXPAND(GTK_BOX(vbox), content_box);
    }
    
#endif
    
    // window content
    // the content has a (TODO: not yet) configurable frame
    // TODO: really? why
    /*
    GtkWidget *frame = gtk_frame_new(NULL);
    gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_NONE);
    gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0);
    
    // content vbox
    GtkWidget *content_box = ui_gtk_vbox_new(0);
    gtk_container_add(GTK_CONTAINER(frame), content_box);
    obj->container = ui_box_container(obj, content_box);
    */
    UiContainerX *container = ui_box_container(obj, content_box, UI_CONTAINER_VBOX);
    uic_object_push_container(obj, container);
    
    nwindows++;
    return obj;
}


UiObject* ui_window(const char *title) {
    return create_window(title, FALSE, FALSE, FALSE);
}

UiObject *ui_sidebar_window(const char *title) {
    return create_window(title, TRUE, FALSE, FALSE);
}

UiObject *ui_splitview_window(const char *title, UiBool sidebar) {
    return create_window(title, sidebar, TRUE, FALSE);
}

UiObject* ui_simple_window(const char *title) {
    return create_window(title, FALSE, FALSE, TRUE);
}

void ui_window_size(UiObject *obj, int width, int height) {
    gtk_window_set_default_size(
                GTK_WINDOW(obj->widget),
                width,
                height);
}

void ui_window_default_size(int width, int height) {
    window_default_width = width;
    window_default_height = height;
}

void ui_splitview_window_set_pos(UiObject *obj, int pos) {
    GtkWidget *splitview = g_object_get_data(G_OBJECT(obj->widget), "ui_window_splitview");
    if(splitview) {
        gtk_paned_set_position(GTK_PANED(splitview), pos);
    } else {
        fprintf(stderr, "Error: window has no splitview\n");
    }
}

int ui_splitview_window_get_pos(UiObject *obj) {
    GtkWidget *splitview = g_object_get_data(G_OBJECT(obj->widget), "ui_window_splitview");
    if(splitview) {
        return gtk_paned_get_position(GTK_PANED(splitview));
    } else {
        fprintf(stderr, "Error: window has no splitview\n");
    }
    return 0;
}

void ui_splitview_window_set_default_pos(int pos) {
    splitview_window_default_pos = pos;
}

void ui_splitview_window_use_property(UiBool enable) {
    splitview_window_use_prop = enable;
}

UIEXPORT void ui_splitview_window_set_visible(UiObject *obj, int pane, UiBool visible) {
    GtkWidget *panel = NULL;
    if(pane == 0) {
        panel = g_object_get_data(G_OBJECT(obj->widget), "ui_left_panel");
    } else if(pane == 1) {
        panel = g_object_get_data(G_OBJECT(obj->widget), "ui_right_panel");
    }
    
    if(panel == NULL) {
        fprintf(stderr, "Error: obj is not a splitview window or invalid pane %d specified\n", pane);
        return;
    }
    
    gtk_widget_set_visible(panel, visible);
}

#ifdef UI_LIBADWAITA

static void dialog_response(AdwAlertDialog *self, gchar *response, UiEventData *data) {
    UiEvent evt;
    evt.obj = data->obj;
    evt.document = evt.obj->ctx->document;
    evt.window = evt.obj->window;
    evt.eventdata = NULL;
    evt.eventdatatype = 0;
    evt.intval = 0;
    
    if(!strcmp(response, "btn1")) {
        evt.intval = 1;
    } else if(!strcmp(response, "btn2")) {
        evt.intval = 2;
    }
    
    if(data->customdata) {
        GtkWidget *entry = data->customdata;
        evt.eventdata = (void*)ENTRY_GET_TEXT(GTK_ENTRY(entry));
        evt.eventdatatype = UI_EVENT_DATA_STRING;
    }
    
    if(data->callback) {
        data->callback(&evt, data->userdata);
    }
}

void ui_dialog_create(UiObject *parent, UiDialogArgs *args) {
    AdwDialog *dialog = adw_alert_dialog_new(args->title, args->content);
    UiEventData *event = malloc(sizeof(UiEventData));
    event->callback = args->result;
    event->userdata = args->resultdata;
    event->customdata = NULL;
    event->customint = 0;
    event->value = 0;
    event->obj = parent;
    
    if(args->button1_label) {
        adw_alert_dialog_add_response(ADW_ALERT_DIALOG(dialog), "btn1", args->button1_label);
    }
    if(args->button2_label) {
        adw_alert_dialog_add_response(ADW_ALERT_DIALOG(dialog), "btn2", args->button2_label);
    }
    if(args->closebutton_label) {
        adw_alert_dialog_add_response(ADW_ALERT_DIALOG(dialog), "close", args->closebutton_label);
        adw_alert_dialog_set_close_response(ADW_ALERT_DIALOG(dialog), "close");
    }
    
    GtkWidget *entry = NULL;
    if(args->input || args->password) {
        entry = gtk_entry_new();
        if(args->password) {
            gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
        }
        if(args->input_value) {
            ENTRY_SET_TEXT(entry, args->input_value);
        }
        adw_alert_dialog_set_extra_child(ADW_ALERT_DIALOG(dialog), entry);
        event->customdata = entry;
        event->customint = 0;
    }
    
    g_signal_connect(
                dialog,
                "destroy",
                G_CALLBACK(ui_destroy_userdata),
                event);
    
    g_signal_connect(dialog, "response", G_CALLBACK(dialog_response), event);
    adw_dialog_present(dialog, parent->widget);
    
    if(entry) {
        gtk_entry_grab_focus_without_selecting(GTK_ENTRY(entry));
    }
}
#else

static void ui_dialog_response (GtkDialog* self, gint response_id, gpointer user_data) {
    UiEventData *data = user_data;
    UiEvent evt;
    evt.obj = data->obj;
    evt.document = evt.obj->ctx->document;
    evt.window = evt.obj->window;
    evt.eventdata = NULL;
    evt.intval = 0;
    
    if(data->customdata) {
        GtkWidget *entry = data->customdata;
        evt.eventdata = (void*)ENTRY_GET_TEXT(GTK_ENTRY(entry));
        
    }
    
    if(response_id == 1 || response_id == 2) {
        evt.intval = response_id;
    }
    
    
    if(data->callback) {
        data->callback(&evt, data->userdata);
    }
    
    WINDOW_DESTROY(GTK_WIDGET(self));
}

void ui_dialog_create(UiObject *parent, UiDialogArgs *args) {
    GtkDialog *dialog = GTK_DIALOG(gtk_dialog_new());
    gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(parent->widget));
    gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
    
    GtkWidget *dialog_w = GTK_WIDGET(dialog);
    if(args->title) {
        gtk_window_set_title(GTK_WINDOW(dialog), args->title);
    }
    if(args->button1_label) {
        gtk_dialog_add_button(dialog, args->button1_label, 1);
    }
    if(args->button2_label) {
        gtk_dialog_add_button(dialog, args->button2_label, 2);
    }
    if(args->closebutton_label) {
        gtk_dialog_add_button(dialog, args->closebutton_label, 0);
    }
    
    GtkWidget *content_area = gtk_dialog_get_content_area(dialog);
    if(args->content) {
        GtkWidget *label = gtk_label_new(args->content);
        BOX_ADD(content_area, label);
    }
    
    GtkWidget *textfield = NULL;
    if(args->input || args->password) {
        textfield = gtk_entry_new();
        if(args->password) {
            gtk_entry_set_visibility(GTK_ENTRY(textfield), FALSE);
        }
        if(args->input_value) {
            ENTRY_SET_TEXT(textfield, args->input_value);
        }
        BOX_ADD(content_area, textfield);
    }
    
    UiEventData *event = malloc(sizeof(UiEventData));
    event->obj = parent;
    event->callback = args->result;
    event->userdata = args->resultdata;
    event->value = 0;
    event->customdata = textfield;
    
    g_signal_connect(dialog_w,
                           "response",
                           G_CALLBACK(ui_dialog_response),
                           event);
    
    WINDOW_SHOW(GTK_WIDGET(dialog_w));
}
#endif


#if GTK_MAJOR_VERSION >= 3
UiFileList listmodel2filelist(GListModel *selection) {
    UiFileList flist;
    flist.files = NULL;
    flist.nfiles = 0;
    flist.nfiles = g_list_model_get_n_items(selection);
    flist.files = calloc(flist.nfiles, sizeof(char*));
    for(int i=0;i<flist.nfiles;i++) {
        GFile *file = g_list_model_get_item(selection, i);
        char *path = g_file_get_path(file);
        flist.files[i] = path ? strdup(path) : NULL;
        g_object_unref(file);
    }
    return flist;
}
#endif


#if GTK_CHECK_VERSION(4, 10, 0)

#define UI_GTK_FILEDIALOG_OPEN 16
#define UI_GTK_FILEDIALOG_SAVE 32

static void filechooser_opened(GObject *source, GAsyncResult *result, void *data) {
    UiEventData *event = data;
    
    GFile *file = NULL;
    GListModel *selection = NULL;
    GError *error = NULL;
    
    int mode = event->value;
    int multi = mode & UI_FILEDIALOG_SELECT_MULTI;
    if((mode & UI_FILEDIALOG_SELECT_FOLDER) == UI_FILEDIALOG_SELECT_FOLDER) {
        if(multi) {
            selection = gtk_file_dialog_select_multiple_folders_finish(GTK_FILE_DIALOG(source), result, &error);
        } else {
            file = gtk_file_dialog_select_folder_finish(GTK_FILE_DIALOG(source), result, &error);
        }
    } else if((mode & UI_GTK_FILEDIALOG_OPEN) == UI_GTK_FILEDIALOG_OPEN) {
        if(multi) {
            selection = gtk_file_dialog_open_multiple_finish(GTK_FILE_DIALOG(source), result, &error);
        } else {
            file = gtk_file_dialog_open_finish(GTK_FILE_DIALOG(source), result, &error);
        }
    } else {
        file = gtk_file_dialog_save_finish(GTK_FILE_DIALOG(source), result, &error);
    }
    
    UiEvent evt;
    evt.obj = event->obj;
    evt.document = evt.obj->ctx->document;
    evt.window = evt.obj->window;
    evt.intval = 0;
    
    UiFileList flist;
    flist.files = NULL;
    flist.nfiles = 0;
    evt.eventdata = &flist;
    evt.eventdatatype = UI_EVENT_DATA_FILE_LIST;
    
    if(selection) {
        flist = listmodel2filelist(selection);
        g_object_unref(selection);
    } else if(file) {
        char *path = g_file_get_path(file);
        if(path) {
            flist.nfiles = 1;
            flist.files = calloc(flist.nfiles, sizeof(char*));
            flist.files[0] = strdup(path);
        }
        g_object_unref(file); 
    }
    
    if(event->callback) {
        event->callback(&evt, event->userdata);
    }
    
    for(int i=0;i<flist.nfiles;i++) {
        free(flist.files[i]);
    }
}

static void ui_gtkfilechooser(UiObject *obj, GtkFileChooserAction action, unsigned int mode, const char *name, ui_callback file_selected_callback, void *cbdata) {
    if(action == GTK_FILE_CHOOSER_ACTION_OPEN) {
        mode |= UI_GTK_FILEDIALOG_OPEN;
    } else {
        mode |= UI_GTK_FILEDIALOG_SAVE;
    }
    
    UiEventData *event = malloc(sizeof(UiEventData));
    event->callback = file_selected_callback;
    event->userdata = cbdata;
    event->customdata = NULL;
    event->customint = 0;
    event->value = mode;
    event->obj = obj;
    
    GtkWindow *parent = GTK_WINDOW(gtk_widget_get_root(obj->widget));
    GtkFileDialog *dialog = gtk_file_dialog_new();
    if(name) {
        gtk_file_dialog_set_initial_name(dialog, name);
    }
    
    int multi = mode & UI_FILEDIALOG_SELECT_MULTI;
    if((mode & UI_FILEDIALOG_SELECT_FOLDER) == UI_FILEDIALOG_SELECT_FOLDER) {
        if(multi) {
            gtk_file_dialog_select_multiple_folders(dialog, parent, NULL, filechooser_opened, event);
        } else {
            gtk_file_dialog_select_folder(dialog, parent, NULL, filechooser_opened, event);
        }
    } else if(action == GTK_FILE_CHOOSER_ACTION_OPEN) {
        if(multi) {
            gtk_file_dialog_open_multiple(dialog, parent, NULL, filechooser_opened, event);
        } else {
            gtk_file_dialog_open(dialog, parent, NULL, filechooser_opened, event);
        }
    } else {
        gtk_file_dialog_save(dialog, parent, NULL, filechooser_opened, event);
    }
    
    g_object_unref(dialog);
}
#else


static void filechooser_response(GtkDialog* self, gint response_id, UiEventData *data) {
    UiEvent evt;
    evt.obj = data->obj;
    evt.document = evt.obj->ctx->document;
    evt.window = evt.obj->window;
    evt.intval = 0;
    
    UiFileList flist;
    flist.files = NULL;
    flist.nfiles = 0;
    evt.eventdata = &flist;
    
    if(response_id == GTK_RESPONSE_ACCEPT) {
#if GTK_CHECK_VERSION(4, 0, 0)
        GListModel *selection = gtk_file_chooser_get_files(GTK_FILE_CHOOSER(self));
        flist = flist = listmodel2filelist(selection);
        g_object_unref(selection);
#else
        GSList *selection = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(self));
        flist.nfiles = g_slist_length(selection);
        flist.files = calloc(flist.nfiles, sizeof(char*));
        int i = 0;
        while(selection) {
            char *file = selection->data;
            flist.files[i] = strdup(file);
            g_free(file);
            selection = selection->next;
            i++;
        }
        g_slist_free(selection);
#endif
    }
    
    
    if(data->callback) {
        data->callback(&evt, data->userdata);
    }
    
    for(int i=0;i<flist.nfiles;i++) {
        free(flist.files[i]);
    }
    
    WINDOW_DESTROY(GTK_WIDGET(self));
}

static void ui_gtkfilechooser(UiObject *obj, GtkFileChooserAction action, unsigned int mode, const char *name, ui_callback file_selected_callback, void *cbdata) {
    char *button;
    char *title;
    
    GtkWidget *dialog;
    if((mode & UI_FILEDIALOG_SELECT_FOLDER) == UI_FILEDIALOG_SELECT_FOLDER) {
        dialog = gtk_file_chooser_dialog_new (
                "Open Folder",
                GTK_WINDOW(obj->widget),
                GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
                "Cancel",
                GTK_RESPONSE_CANCEL,
                "Select Folder",
                GTK_RESPONSE_ACCEPT,
                NULL);
    } else if(action == GTK_FILE_CHOOSER_ACTION_OPEN) {
        dialog = gtk_file_chooser_dialog_new (
                "Select Folder",
                GTK_WINDOW(obj->widget),
                action,
                "Cancel",
                GTK_RESPONSE_CANCEL,
                "Open File",
                GTK_RESPONSE_ACCEPT,
                NULL);
    } else {
        dialog = gtk_file_chooser_dialog_new (
                "Save File",
                GTK_WINDOW(obj->widget),
                action,
                "Cancel",
                GTK_RESPONSE_CANCEL,
                "Save File",
                GTK_RESPONSE_ACCEPT,
                NULL);
    }
    
    if((mode & UI_FILEDIALOG_SELECT_MULTI) == UI_FILEDIALOG_SELECT_MULTI) {
        gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
    }
    
    UiEventData *event = malloc(sizeof(UiEventData));
    event->obj = obj;
    event->userdata = cbdata;
    event->callback = file_selected_callback;
    event->value = 0;
    event->customdata = NULL;
    
    g_signal_connect(
                dialog,
                "response",
                G_CALLBACK(filechooser_response),
                event);
    g_signal_connect(
                dialog,
                "destroy",
                G_CALLBACK(ui_destroy_userdata),
                event);
    
    gtk_widget_show(dialog);
}
#endif

void ui_openfiledialog(UiObject *obj, unsigned int mode, ui_callback file_selected_callback, void *cbdata) {
    ui_gtkfilechooser(obj, GTK_FILE_CHOOSER_ACTION_OPEN, mode, NULL, file_selected_callback, cbdata);
}

void ui_savefiledialog(UiObject *obj, const char *name, ui_callback file_selected_callback, void *cbdata) {
    ui_gtkfilechooser(obj, GTK_FILE_CHOOSER_ACTION_SAVE, 0, name, file_selected_callback, cbdata);
}

#if GTK_CHECK_VERSION(4, 10, 0)
#define DIALOG_NEW() gtk_window_new()
#else
#define DIALOG_NEW() gtk_dialog_new()

static void ui_dialogwindow_response(GtkDialog* self, gint response_id, gpointer user_data) {
    UiEventData *event = user_data;
    // TODO: do we need to check if response_id == GTK_RESPONSE_DELETE_EVENT?
    if(event->callback) {
        UiEvent e;
        e.obj = event->obj;
        e.window = event->obj->window;
        e.document = event->obj->ctx->document;
        e.eventdata = NULL;
        e.intval = event->value;
        event->callback(&e, event->userdata);
    }
}

#endif

#if GTK_CHECK_VERSION(4, 0, 0)
#define HEADERBAR_SHOW_CLOSEBUTTON(headerbar, set) gtk_header_bar_set_show_title_buttons(GTK_HEADER_BAR(headerbar), set)
#define DEFAULT_BUTTON(window, button) gtk_window_set_default_widget(GTK_WINDOW(window), button)
#else
#define HEADERBAR_SHOW_CLOSEBUTTON(headerbar, set) gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(headerbar), set)
#define DEFAULT_BUTTON(window, button) gtk_widget_set_can_default(button, TRUE); gtk_window_set_default(GTK_WINDOW(window), button)
#endif


UiObject* ui_dialog_window_create(UiObject *parent, UiDialogWindowArgs *args) {
    GtkWidget *dialog = DIALOG_NEW();
    if(args->width > 0 || args->height > 0) {
        gtk_window_set_default_size(
                GTK_WINDOW(dialog),
                args->width,
                args->height);
    }
    
    
    gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(parent->widget));
    if(args->modal != UI_OFF) {
        gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
    }
    
    UiObject *obj = uic_object_new_toplevel(); 
    obj->widget = dialog;
    obj->ref = 0;
    obj->destroy = ui_window_widget_destroy;
    nwindows++;
    
    if(args->title != NULL) {
        gtk_window_set_title(GTK_WINDOW(dialog), args->title);
    }
    
#if ! GTK_CHECK_VERSION(4, 10, 0)
    UiEventData *event = malloc(sizeof(UiEventData));
    event->obj = obj;
    event->userdata = args->onclickdata;
    event->callback = args->onclick;
    event->value = 0;
    event->customdata = NULL;

    g_signal_connect(dialog, "response", G_CALLBACK(ui_dialogwindow_response), event);
    g_signal_connect(
            dialog,
            "destroy",
            G_CALLBACK(ui_destroy_userdata),
            event);
#endif
    
    g_signal_connect(
            dialog,
            "destroy",
            G_CALLBACK(ui_exit_event),
            obj);
#if GTK_MAJOR_VERSION >= 4
    g_signal_connect(
            obj->widget,
            "close-request",
            G_CALLBACK(close_request),
            obj);
#else
    g_signal_connect(
            obj->widget,
            "delete-event",
            G_CALLBACK(close_request),
            obj);
#endif
    
#if GTK_MAJOR_VERSION < 4
    GtkWidget *c = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
    gtk_container_remove(GTK_CONTAINER(dialog), c);
#endif
    
    GtkWidget *content_vbox = ui_gtk_vbox_new(0);
    UiContainerX *container = ui_box_container(obj, content_vbox, UI_CONTAINER_VBOX);
    uic_object_push_container(obj, container);
    if(args->lbutton1 || args->lbutton2 || args->rbutton3 || args->rbutton4) {
#if GTK_CHECK_VERSION(3, 10, 0)
        if(args->titlebar_buttons != UI_OFF) {
            GtkWidget *headerbar = gtk_header_bar_new();
            gtk_window_set_titlebar(GTK_WINDOW(dialog), headerbar);
            if(args->show_closebutton == UI_OFF) {
                HEADERBAR_SHOW_CLOSEBUTTON(headerbar, FALSE);
            }
            
            if(args->lbutton1) {
                GtkWidget *button = ui_create_button(obj, args->lbutton1, NULL, NULL/*tooltip*/, args->onclick, args->onclickdata, 1, args->default_button == 1);
                gtk_header_bar_pack_start(GTK_HEADER_BAR(headerbar), button);
                if(args->default_button == 1) {
                    WIDGET_ADD_CSS_CLASS(button, "suggested-action");
                    DEFAULT_BUTTON(dialog, button);
                }
            }
            if(args->lbutton2) {
                GtkWidget *button = ui_create_button(obj, args->lbutton2, NULL, NULL/*tooltip*/, args->onclick, args->onclickdata, 2, args->default_button == 2);
                gtk_header_bar_pack_start(GTK_HEADER_BAR(headerbar), button);
                if(args->default_button == 2) {
                    WIDGET_ADD_CSS_CLASS(button, "suggested-action");
                    DEFAULT_BUTTON(dialog, button);
                }
            }
            
            if(args->rbutton4) {
                GtkWidget *button = ui_create_button(obj, args->rbutton4, NULL, NULL/*tooltip*/, args->onclick, args->onclickdata, 4, args->default_button == 4);
                gtk_header_bar_pack_end(GTK_HEADER_BAR(headerbar), button);
                if(args->default_button == 4) {
                    WIDGET_ADD_CSS_CLASS(button, "suggested-action");
                    DEFAULT_BUTTON(dialog, button);
                }
            }
            if(args->rbutton3) {
                GtkWidget *button = ui_create_button(obj, args->rbutton3, NULL, NULL/*tooltip*/, args->onclick, args->onclickdata, 3, args->default_button == 3);
                gtk_header_bar_pack_end(GTK_HEADER_BAR(headerbar), button);
                if(args->default_button == 3) {
                    WIDGET_ADD_CSS_CLASS(button, "suggested-action");
                    DEFAULT_BUTTON(dialog, button);
                }
            }
            WINDOW_SET_CONTENT(obj->widget, content_vbox);
            return obj;
        }
#endif
        GtkWidget *vbox = ui_gtk_vbox_new(0);
        WINDOW_SET_CONTENT(obj->widget, vbox);
        
        GtkWidget *separator = gtk_separator_new(GTK_ORIENTATION_HORIZONTAL);
        
        GtkWidget *grid = ui_create_grid_widget(10, 10);
        GtkWidget *widget = ui_gtk_set_margin(grid, 16, 0, 0, 0, 0);
        gtk_grid_set_column_homogeneous(GTK_GRID(grid), TRUE); 
        
        if(args->lbutton1) {
            GtkWidget *button = ui_create_button(obj, args->lbutton1, NULL, NULL/*tooltip*/, args->onclick, args->onclickdata, 1, args->default_button == 1);
            gtk_grid_attach(GTK_GRID(grid), button, 0, 0, 1, 1);
            if(args->default_button == 1) {
                WIDGET_ADD_CSS_CLASS(button, "suggested-action");
                DEFAULT_BUTTON(dialog, button);
            }
        }
        if(args->lbutton2) {
            GtkWidget *button = ui_create_button(obj, args->lbutton2, NULL, NULL/*tooltip*/, args->onclick, args->onclickdata, 2, args->default_button == 2);
            gtk_grid_attach(GTK_GRID(grid), button, 1, 0, 1, 1);
            if(args->default_button == 2) {
                WIDGET_ADD_CSS_CLASS(button, "suggested-action");
                DEFAULT_BUTTON(dialog, button);
            }
        }
        GtkWidget *space = gtk_label_new(NULL);
        gtk_widget_set_hexpand(space, TRUE);
        gtk_grid_attach(GTK_GRID(grid), space, 2, 0, 1, 1);
        if(args->rbutton3) {
            GtkWidget *button = ui_create_button(obj, args->rbutton3, NULL, NULL/*tooltip*/, args->onclick, args->onclickdata, 3, args->default_button == 3);
            gtk_grid_attach(GTK_GRID(grid), button, 3, 0, 1, 1);
            if(args->default_button == 3) {
                WIDGET_ADD_CSS_CLASS(button, "suggested-action");
                DEFAULT_BUTTON(dialog, button);
            }
        }
        if(args->rbutton4) {
            GtkWidget *button = ui_create_button(obj, args->rbutton4, NULL, NULL/*tooltip*/, args->onclick, args->onclickdata, 4, args->default_button == 4);
            gtk_grid_attach(GTK_GRID(grid), button, 4, 0, 1, 1);
            if(args->default_button == 4) {
                WIDGET_ADD_CSS_CLASS(button, "suggested-action");
                DEFAULT_BUTTON(dialog, button);
            }
        }
        
        BOX_ADD_EXPAND(vbox, content_vbox);   
        BOX_ADD_NO_EXPAND(vbox, separator);
        BOX_ADD_NO_EXPAND(vbox, widget);
    } else {
        WINDOW_SET_CONTENT(obj->widget, content_vbox);
    }
    
    return obj;
}