static void gtk_application_window_real_realize (GtkWidget *widget) { GtkApplicationWindow *window = GTK_APPLICATION_WINDOW (widget); GtkApplication *application; GtkSettings *settings; application = gtk_window_get_application (GTK_WINDOW (window)); settings = gtk_widget_get_settings (widget); g_signal_connect (settings, "notify::gtk-shell-shows-app-menu", G_CALLBACK (gtk_application_window_shell_shows_app_menu_changed), window); g_signal_connect (settings, "notify::gtk-shell-shows-menubar", G_CALLBACK (gtk_application_window_shell_shows_menubar_changed), window); if (!window->priv->muxer_initialised) { g_action_muxer_insert (G_ACTION_MUXER (window->priv->muxer), "app", G_ACTION_GROUP (application)); g_action_muxer_insert (G_ACTION_MUXER (window->priv->muxer), "win", G_ACTION_GROUP (window)); window->priv->muxer_initialised = TRUE; } gtk_application_window_update_shell_shows_app_menu (window, settings); gtk_application_window_update_shell_shows_menubar (window, settings); gtk_application_window_update_menubar (window); gtk_application_window_update_accels (window); GTK_WIDGET_CLASS (gtk_application_window_parent_class) ->realize (widget); #ifdef GDK_WINDOWING_X11 { GdkWindow *gdkwindow; gdkwindow = gtk_widget_get_window (GTK_WIDGET (window)); if (GDK_IS_X11_WINDOW (gdkwindow) && window->priv->session) { gdk_x11_window_set_utf8_property (gdkwindow, "_GTK_APPLICATION_ID", g_application_get_application_id (G_APPLICATION (application))); gdk_x11_window_set_utf8_property (gdkwindow, "_GTK_UNIQUE_BUS_NAME", g_dbus_connection_get_unique_name (window->priv->session)); gdk_x11_window_set_utf8_property (gdkwindow, "_GTK_APPLICATION_OBJECT_PATH", g_application_get_dbus_object_path (G_APPLICATION (application))); gdk_x11_window_set_utf8_property (gdkwindow, "_GTK_WINDOW_OBJECT_PATH", window->priv->object_path); gdk_x11_window_set_utf8_property (gdkwindow, "_GTK_APP_MENU_OBJECT_PATH", gtk_application_get_app_menu_object_path (application)); gdk_x11_window_set_utf8_property (gdkwindow, "_GTK_MENUBAR_OBJECT_PATH", gtk_application_get_menubar_object_path (application)); } } #endif }
static void call_prepare_print (GtkPrintOperation *op, PortalData *portal) { GtkPrintOperationPrivate *priv = op->priv; GVariant *settings; GVariant *setup; GVariantBuilder opt_builder; GVariant *options; char *parent_window_str = NULL; g_variant_builder_init (&opt_builder, G_VARIANT_TYPE_VARDICT); options = g_variant_builder_end (&opt_builder); if (priv->print_settings) settings = gtk_print_settings_to_gvariant (priv->print_settings); else { GVariantBuilder builder; g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT); settings = g_variant_builder_end (&builder); } if (priv->default_page_setup) setup = gtk_page_setup_to_gvariant (priv->default_page_setup); else { GtkPageSetup *page_setup = gtk_page_setup_new (); setup = gtk_page_setup_to_gvariant (page_setup); g_object_unref (page_setup); } if (portal->parent != NULL && gtk_widget_is_visible (GTK_WIDGET (portal->parent))) { GdkWindow *window = gtk_widget_get_window (GTK_WIDGET (portal->parent)); #ifdef GDK_WINDOWING_X11 if (GDK_IS_X11_WINDOW (window)) parent_window_str = g_strdup_printf ("x11:%x", (guint32)gdk_x11_window_get_xid (window)); #endif } g_dbus_proxy_call (portal->proxy, "PreparePrint", g_variant_new ("(ss@a{sv}@a{sv}@a{sv})", parent_window_str ? parent_window_str : "", _("Print"), /* title */ settings, setup, options), G_DBUS_CALL_FLAGS_NONE, -1, NULL, prepare_print_called, portal); g_free (parent_window_str); }
static void gtk_application_window_real_realize (GtkWidget *widget) { GtkApplicationWindow *window = GTK_APPLICATION_WINDOW (widget); GtkApplication *application; GtkSettings *settings; application = gtk_window_get_application (GTK_WINDOW (window)); settings = gtk_widget_get_settings (widget); g_signal_connect (settings, "notify::gtk-shell-shows-app-menu", G_CALLBACK (gtk_application_window_shell_shows_app_menu_changed), window); g_signal_connect (settings, "notify::gtk-shell-shows-menubar", G_CALLBACK (gtk_application_window_shell_shows_menubar_changed), window); gtk_application_window_update_shell_shows_app_menu (window, settings); gtk_application_window_update_shell_shows_menubar (window, settings); gtk_application_window_update_menubar (window); /* Update the accelerators, and ensure we do again * if the accel map changes */ gtk_application_window_update_accels (window); window->priv->accel_map_changed_id = g_signal_connect_swapped (gtk_accel_map_get (), "changed", G_CALLBACK (gtk_application_window_update_accels), window); GTK_WIDGET_CLASS (gtk_application_window_parent_class) ->realize (widget); #ifdef GDK_WINDOWING_X11 { GdkWindow *gdkwindow; gdkwindow = gtk_widget_get_window (GTK_WIDGET (window)); if (GDK_IS_X11_WINDOW (gdkwindow) && window->priv->session) { gdk_x11_window_set_utf8_property (gdkwindow, "_GTK_APPLICATION_ID", g_application_get_application_id (G_APPLICATION (application))); gdk_x11_window_set_utf8_property (gdkwindow, "_GTK_UNIQUE_BUS_NAME", g_dbus_connection_get_unique_name (window->priv->session)); gdk_x11_window_set_utf8_property (gdkwindow, "_GTK_APPLICATION_OBJECT_PATH", g_application_get_dbus_object_path (G_APPLICATION (application))); gdk_x11_window_set_utf8_property (gdkwindow, "_GTK_WINDOW_OBJECT_PATH", window->priv->object_path); gdk_x11_window_set_utf8_property (gdkwindow, "_GTK_APP_MENU_OBJECT_PATH", gtk_application_get_app_menu_object_path (application)); gdk_x11_window_set_utf8_property (gdkwindow, "_GTK_MENUBAR_OBJECT_PATH", gtk_application_get_menubar_object_path (application)); } } #endif }
static const struct backend_callbacks * get_backend_callbacks(GdkWindow *window) { #if defined(GDK_WINDOWING_WAYLAND) && defined(COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT) if (GDK_IS_WAYLAND_WINDOW(window)) { static const struct backend_callbacks cbs = { COGL_WINSYS_ID_EGL_WAYLAND, wayland_init, noop_get_scale, wayland_set_window, wayland_resize, }; return &cbs; } #endif #if defined(GDK_WINDOWING_X11) && defined(COGL_HAS_XLIB_SUPPORT) if (GDK_IS_X11_WINDOW(window)) { static const struct backend_callbacks cbs = { //COGL_WINSYS_ID_EGL_XLIB, COGL_WINSYS_ID_GLX, x11_init, x11_get_scale, x11_set_window, x11_resize, }; return &cbs; } #endif #if defined(GDK_WINDOWING_WIN32) && defined(COGL_HAS_WIN32_SUPPORT) if (GDK_IS_WIN32_WINDOW(window)) { static const struct backend_callbacks cbs = { COGL_WINSYS_ID_WGL, noop_init, noop_get_scale, win32_set_window, noop_resize, }; return &cbs; } #endif static const struct backend_callbacks cbs = { COGL_WINSYS_ID_STUB, noop_init, noop_get_scale, noop_set_window, noop_resize, }; return &cbs; }
bool S9xOpenGLDisplayDriver::create_context() { gdk_window = gtk_widget_get_window (drawing_area); #ifdef GDK_WINDOWING_WAYLAND if (GDK_IS_WAYLAND_WINDOW (gdk_window)) { context = &wl; } #endif #ifdef GDK_WINDOWING_X11 if (GDK_IS_X11_WINDOW (gdk_window)) { context = &glx; } #endif if (!context->attach (drawing_area)) return false; if (!context->create_context ()) return false; output_window_width = context->width; output_window_height = context->height; context->make_current (); legacy = false; version = epoxy_gl_version (); if (version < 20) { printf ("OpenGL version is only %d.%d. Recommended version is 2.0.\n", version / 10, version % 10); legacy = true; } int profile_mask = 0; glGetIntegerv (GL_CONTEXT_PROFILE_MASK, &profile_mask); if (profile_mask & GL_CONTEXT_CORE_PROFILE_BIT) core = true; else core = false; return true; }
static void pk_search_mime_async (GtkAppChooserOnline *obj, const gchar *content_type, GtkWindow *parent, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GtkAppChooserOnlinePk *self = GTK_APP_CHOOSER_ONLINE_PK (obj); guint xid = 0; GdkWindow *window; const gchar *mime_types[2]; self->priv->result = g_simple_async_result_new (G_OBJECT (self), callback, user_data, _gtk_app_chooser_online_search_for_mimetype_async); #ifdef GDK_WINDOWING_X11 window = gtk_widget_get_window (GTK_WIDGET (parent)); if (GDK_IS_X11_WINDOW (window)) xid = GDK_WINDOW_XID (window); #endif mime_types[0] = content_type; mime_types[1] = NULL; g_dbus_proxy_call (self->priv->proxy, "InstallMimeTypes", g_variant_new ("(u^ass)", xid, mime_types, "hide-confirm-search"), G_DBUS_CALL_FLAGS_NONE, G_MAXINT, /* no timeout */ cancellable, install_mime_types_ready_cb, self); }
/* Takes care of moving the window to the current workspace. */ void tpaw_window_present_with_time (GtkWindow *window, guint32 timestamp) { GdkWindow *gdk_window; g_return_if_fail (GTK_IS_WINDOW (window)); /* Move the window to the current workspace before trying to show it. * This is the behaviour people expect when clicking on the statusbar icon. */ gdk_window = gtk_widget_get_window (GTK_WIDGET (window)); if (gdk_window) { gint x, y; gint w, h; #ifdef GDK_WINDOWING_X11 /* Has no effect if the WM has viewports, like compiz */ if (GDK_IS_X11_WINDOW (gdk_window)) gdk_x11_window_move_to_current_desktop (gdk_window); #endif /* If window is still off-screen, hide it to force it to * reposition on the current workspace. */ gtk_window_get_position (window, &x, &y); gtk_window_get_size (window, &w, &h); if (!TPAW_RECT_IS_ON_SCREEN (x, y, w, h)) gtk_widget_hide (GTK_WIDGET (window)); } if (timestamp == GDK_CURRENT_TIME) gtk_window_present (window); else gtk_window_present_with_time (window, timestamp); }
gboolean socket_lock_input_cb(GIOChannel *source, GIOCondition condition, gpointer data) { gint fd, sock; gchar buf[BUFFER_LENGTH]; gchar *command = NULL; struct sockaddr_in caddr; socklen_t caddr_len = sizeof(caddr); GtkWidget *window = data; gboolean popup = FALSE; fd = g_io_channel_unix_get_fd(source); sock = accept(fd, (struct sockaddr *)&caddr, &caddr_len); /* first get the command */ while (socket_fd_gets(sock, buf, sizeof(buf)) != -1) { command = g_strdup(buf); geany_debug("Received IPC command from remote instance: %s", g_strstrip(command)); g_free(command); if (strncmp(buf, "open", 4) == 0) { cl_options.readonly = strncmp(buf+4, "ro", 2) == 0; /* open in readonly? */ while (socket_fd_gets(sock, buf, sizeof(buf)) != -1 && *buf != '.') { gsize buf_len = strlen(buf); /* remove trailing newline */ if (buf_len > 0 && buf[buf_len - 1] == '\n') buf[buf_len - 1] = '\0'; handle_input_filename(buf); } popup = TRUE; } else if (strncmp(buf, "doclist", 7) == 0) { gchar *doc_list = build_document_list(); if (!EMPTY(doc_list)) socket_fd_write_all(sock, doc_list, strlen(doc_list)); /* send ETX (end-of-text) so reader knows to stop reading */ socket_fd_write_all(sock, "\3", 1); g_free(doc_list); } else if (strncmp(buf, "line", 4) == 0) { while (socket_fd_gets(sock, buf, sizeof(buf)) != -1 && *buf != '.') { g_strstrip(buf); /* remove \n char */ /* on any error we get 0 which should be safe enough as fallback */ cl_options.goto_line = atoi(buf); } } else if (strncmp(buf, "column", 6) == 0) { while (socket_fd_gets(sock, buf, sizeof(buf)) != -1 && *buf != '.') { g_strstrip(buf); /* remove \n char */ /* on any error we get 0 which should be safe enough as fallback */ cl_options.goto_column = atoi(buf); } } #ifdef G_OS_WIN32 else if (strncmp(buf, "window", 6) == 0) { # if GTK_CHECK_VERSION(3, 0, 0) HWND hwnd = (HWND) gdk_win32_window_get_handle(gtk_widget_get_window(window)); # else HWND hwnd = (HWND) gdk_win32_drawable_get_handle( GDK_DRAWABLE(gtk_widget_get_window(window))); # endif socket_fd_write(sock, (gchar *)&hwnd, sizeof(hwnd)); } #endif } if (popup) { #ifdef GDK_WINDOWING_X11 GdkWindow *x11_window = gtk_widget_get_window(window); /* Set the proper interaction time on the window. This seems necessary to make * gtk_window_present() really bring the main window into the foreground on some * window managers like Gnome's metacity. * Code taken from Gedit. */ # if GTK_CHECK_VERSION(3, 0, 0) if (GDK_IS_X11_WINDOW(x11_window)) # endif { gdk_x11_window_set_user_time(x11_window, gdk_x11_get_server_time(x11_window)); } #endif gtk_window_present(GTK_WINDOW(window)); #ifdef G_OS_WIN32 gdk_window_show(gtk_widget_get_window(window)); #endif } socket_fd_close(sock); return TRUE; }
static gboolean clutter_stage_gdk_realize (ClutterStageWindow *stage_window) { ClutterStageGdk *stage_gdk = CLUTTER_STAGE_GDK (stage_window); ClutterStageCogl *stage_cogl = CLUTTER_STAGE_COGL (stage_window); ClutterBackend *backend = CLUTTER_BACKEND (stage_cogl->backend); ClutterBackendGdk *backend_gdk = CLUTTER_BACKEND_GDK (backend); GdkWindowAttr attributes; gboolean cursor_visible; gboolean use_alpha; gfloat width, height; if (stage_gdk->foreign_window) { width = gdk_window_get_width (stage_gdk->window); height = gdk_window_get_height (stage_gdk->window); } else { if (stage_gdk->window != NULL) { /* complete realizing the stage */ cairo_rectangle_int_t geometry; clutter_stage_gdk_get_geometry (stage_window, &geometry); clutter_actor_set_size (CLUTTER_ACTOR (stage_cogl->wrapper), geometry.width, geometry.height); gdk_window_ensure_native (stage_gdk->window); gdk_window_set_events (stage_gdk->window, CLUTTER_STAGE_GDK_EVENT_MASK); return TRUE; } else { attributes.title = NULL; g_object_get (stage_cogl->wrapper, "cursor-visible", &cursor_visible, "title", &attributes.title, "width", &width, "height", &height, "use-alpha", &use_alpha, NULL); attributes.width = width; attributes.height = height; attributes.wclass = GDK_INPUT_OUTPUT; attributes.window_type = GDK_WINDOW_TOPLEVEL; attributes.event_mask = CLUTTER_STAGE_GDK_EVENT_MASK; attributes.cursor = NULL; if (!cursor_visible) { if (stage_gdk->blank_cursor == NULL) stage_gdk->blank_cursor = gdk_cursor_new_for_display (backend_gdk->display, GDK_BLANK_CURSOR); attributes.cursor = stage_gdk->blank_cursor; } attributes.visual = NULL; if (use_alpha) { attributes.visual = gdk_screen_get_rgba_visual (backend_gdk->screen); if (attributes.visual == NULL) clutter_stage_set_use_alpha (stage_cogl->wrapper, FALSE); } if (attributes.visual == NULL) { /* This could still be an RGBA visual, although normally it's not */ attributes.visual = gdk_screen_get_system_visual (backend_gdk->screen); } stage_gdk->foreign_window = FALSE; stage_gdk->window = gdk_window_new (NULL, &attributes, GDK_WA_TITLE | GDK_WA_CURSOR | GDK_WA_VISUAL); g_free (attributes.title); } clutter_stage_gdk_set_gdk_geometry (stage_gdk); } gdk_window_ensure_native (stage_gdk->window); g_object_set_data (G_OBJECT (stage_gdk->window), "clutter-stage-window", stage_gdk); stage_cogl->onscreen = cogl_onscreen_new (backend->cogl_context, width, height); #if defined(GDK_WINDOWING_X11) && defined(COGL_HAS_XLIB_SUPPORT) if (GDK_IS_X11_WINDOW (stage_gdk->window)) { cogl_x11_onscreen_set_foreign_window_xid (stage_cogl->onscreen, GDK_WINDOW_XID (stage_gdk->window), clutter_stage_gdk_update_foreign_event_mask, stage_gdk); } else #endif #if defined(GDK_WINDOWING_WAYLAND) && defined(COGL_HAS_EGL_PLATFORM_WAYLAND_SUPPORT) if (GDK_IS_WAYLAND_WINDOW (stage_gdk->window)) { cogl_wayland_onscreen_set_foreign_surface (stage_cogl->onscreen, gdk_wayland_window_get_wl_surface (stage_gdk->window)); } else #endif #if defined(GDK_WINDOWING_WIN32) && defined(COGL_HAS_WIN32_SUPPORT) if (GDK_IS_WIN32_WINDOW (stage_gdk->window)) { cogl_win32_onscreen_set_foreign_window (stage_cogl->onscreen, gdk_win32_window_get_handle (stage_gdk->window)); } else #endif { g_warning ("Cannot find an appropriate CoglWinsys for a " "GdkWindow of type %s", G_OBJECT_TYPE_NAME (stage_gdk->window)); cogl_object_unref (stage_cogl->onscreen); stage_cogl->onscreen = NULL; if (!stage_gdk->foreign_window) gdk_window_destroy (stage_gdk->window); stage_gdk->window = NULL; return FALSE; } return clutter_stage_window_parent_iface->realize (stage_window); }
const guint16 const *vnc_display_keymap_gdk2xtkbd_table(GdkWindow *window, size_t *maplen) { #ifdef GDK_WINDOWING_X11 if (GDK_IS_X11_WINDOW(window)) { XkbDescPtr desc; const gchar *keycodes = NULL; GdkDisplay *dpy = gdk_window_get_display(window); /* There is no easy way to determine what X11 server * and platform & keyboard driver is in use. Thus we * do best guess heuristics. * * This will need more work for people with other * X servers..... patches welcomed. */ desc = XkbGetKeyboard(gdk_x11_display_get_xdisplay(dpy), XkbGBN_AllComponentsMask, XkbUseCoreKbd); if (desc) { if (desc->names) { keycodes = gdk_x11_get_xatom_name(desc->names->keycodes); if (!keycodes) g_warning("could not lookup keycode name"); } XkbFreeKeyboard(desc, XkbGBN_AllComponentsMask, True); } if (check_for_xwin(dpy)) { VNC_DEBUG("Using xwin keycode mapping"); *maplen = G_N_ELEMENTS(keymap_xorgxwin2xtkbd); return keymap_xorgxwin2xtkbd; } else if (check_for_xquartz(dpy)) { VNC_DEBUG("Using xquartz keycode mapping"); *maplen = G_N_ELEMENTS(keymap_xorgxquartz2xtkbd); return keymap_xorgxquartz2xtkbd; } else if (keycodes && STRPREFIX(keycodes, "evdev_")) { VNC_DEBUG("Using evdev keycode mapping"); *maplen = G_N_ELEMENTS(keymap_xorgevdev2xtkbd); return keymap_xorgevdev2xtkbd; } else if (keycodes && STRPREFIX(keycodes, "xfree86_")) { VNC_DEBUG("Using xfree86 keycode mapping"); *maplen = G_N_ELEMENTS(keymap_xorgkbd2xtkbd); return keymap_xorgkbd2xtkbd; } else { g_warning("Unknown keycode mapping '%s'.\n" "Please report to [email protected]\n" "including the following information:\n" "\n" " - Operating system\n" " - GDK build\n" " - X11 Server\n" " - xprop -root\n" " - xdpyinfo\n", keycodes); return NULL; } } #endif #ifdef GDK_WINDOWING_WIN32 if (GDK_IS_WIN32_WINDOW(window)) { VNC_DEBUG("Using Win32 virtual keycode mapping"); *maplen = G_N_ELEMENTS(keymap_win322xtkbd); return keymap_win322xtkbd; } #endif #ifdef GDK_WINDOWING_QUARTZ if (GDK_IS_QUARTZ_WINDOW(window)) { VNC_DEBUG("Using OS-X virtual keycode mapping"); *maplen = G_N_ELEMENTS(keymap_osx2xtkbd); return keymap_osx2xtkbd; } #endif #ifdef GDK_WINDOWING_WAYLAND if (GDK_IS_WAYLAND_WINDOW(window)) { VNC_DEBUG("Using Wayland Xorg/evdev virtual keycode mapping"); *maplen = G_N_ELEMENTS(keymap_xorgevdev2xtkbd); return keymap_xorgevdev2xtkbd; } #endif #ifdef GDK_WINDOWING_BROADWAY if (GDK_IS_BROADWAY_WINDOW(window)) { g_warning("experimental: using broadway, x11 virtual keysym mapping - with very limited support. See also https://bugzilla.gnome.org/show_bug.cgi?id=700105"); *maplen = G_N_ELEMENTS(keymap_x112xtkbd); return keymap_x112xtkbd; } #endif g_warning("Unsupported GDK Windowing platform.\n" "Disabling extended keycode tables.\n" "Please report to [email protected]\n" "including the following information:\n" "\n" " - Operating system\n" " - GDK Windowing system build\n"); return NULL; }
gboolean gtk_file_chooser_native_portal_show (GtkFileChooserNative *self) { FilechooserPortalData *data; GtkWindow *transient_for; GDBusConnection *connection; char *parent_window_str; GDBusMessage *message; GVariantBuilder opt_builder; GtkFileChooserAction action; gboolean multiple; const char *method_name; if (!gtk_should_use_portal ()) return FALSE; connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL); if (connection == NULL) return FALSE; action = gtk_file_chooser_get_action (GTK_FILE_CHOOSER (self)); multiple = gtk_file_chooser_get_select_multiple (GTK_FILE_CHOOSER (self)); if (action == GTK_FILE_CHOOSER_ACTION_OPEN) method_name = "OpenFile"; else if (action == GTK_FILE_CHOOSER_ACTION_SAVE) method_name = "SaveFile"; else { g_warning ("GTK_FILE_CHOOSER_ACTION_%s is not supported by GtkFileChooserNativePortal", action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ? "SELECT_FOLDER" : "CREATE_FOLDER"); return FALSE; } data = g_new0 (FilechooserPortalData, 1); data->self = g_object_ref (self); data->connection = connection; message = g_dbus_message_new_method_call ("org.freedesktop.portal.Desktop", "/org/freedesktop/portal/desktop", "org.freedesktop.portal.FileChooser", method_name); parent_window_str = NULL; transient_for = gtk_native_dialog_get_transient_for (GTK_NATIVE_DIALOG (self)); if (transient_for != NULL && gtk_widget_is_visible (GTK_WIDGET (transient_for))) { GdkWindow *window = gtk_widget_get_window (GTK_WIDGET (transient_for)); #ifdef GDK_WINDOWING_X11 if (GDK_IS_X11_WINDOW(window)) parent_window_str = g_strdup_printf ("x11:%x", (guint32)gdk_x11_window_get_xid (window)); #endif } if (gtk_native_dialog_get_modal (GTK_NATIVE_DIALOG (self))) data->modal = TRUE; if (data->modal && transient_for != NULL) { data->grab_widget = gtk_invisible_new_for_screen (gtk_widget_get_screen (GTK_WIDGET (transient_for))); gtk_grab_add (GTK_WIDGET (data->grab_widget)); } g_variant_builder_init (&opt_builder, G_VARIANT_TYPE_VARDICT); g_variant_builder_add (&opt_builder, "{sv}", "multiple", g_variant_new_boolean (multiple)); if (self->accept_label) g_variant_builder_add (&opt_builder, "{sv}", "accept_label", g_variant_new_string (self->accept_label)); if (self->cancel_label) g_variant_builder_add (&opt_builder, "{sv}", "cancel_label", g_variant_new_string (self->cancel_label)); g_variant_builder_add (&opt_builder, "{sv}", "modal", g_variant_new_boolean (data->modal)); g_variant_builder_add (&opt_builder, "{sv}", "filters", get_filters (GTK_FILE_CHOOSER (self))); if (GTK_FILE_CHOOSER_NATIVE (self)->current_name) g_variant_builder_add (&opt_builder, "{sv}", "current_name", g_variant_new_string (GTK_FILE_CHOOSER_NATIVE (self)->current_name)); if (GTK_FILE_CHOOSER_NATIVE (self)->current_folder) { gchar *path; path = g_file_get_path (GTK_FILE_CHOOSER_NATIVE (self)->current_folder); g_variant_builder_add (&opt_builder, "{sv}", "current_folder", g_variant_new_bytestring (path)); g_free (path); } if (GTK_FILE_CHOOSER_NATIVE (self)->current_file) { gchar *path; path = g_file_get_path (GTK_FILE_CHOOSER_NATIVE (self)->current_file); g_variant_builder_add (&opt_builder, "{sv}", "current_file", g_variant_new_bytestring (path)); g_free (path); } if (GTK_FILE_CHOOSER_NATIVE (self)->choices) g_variant_builder_add (&opt_builder, "{sv}", "choices", serialize_choices (GTK_FILE_CHOOSER_NATIVE (self))); g_dbus_message_set_body (message, g_variant_new ("(ss@a{sv})", parent_window_str ? parent_window_str : "", gtk_native_dialog_get_title (GTK_NATIVE_DIALOG (self)), g_variant_builder_end (&opt_builder))); g_free (parent_window_str); g_dbus_connection_send_message_with_reply (data->connection, message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, G_MAXINT, NULL, NULL, open_file_msg_cb, data); g_object_unref (message); self->mode_data = data; return TRUE; }