void MultiMon_Construct() { // detect multiple monitors GdkScreen* screen = gdk_display_get_default_screen(gdk_display_get_default()); gint m = gdk_screen_get_n_monitors(screen); globalOutputStream() << "default screen has " << m << " monitors\n"; for(int j = 0; j != m; ++j) { GdkRectangle geom; gdk_screen_get_monitor_geometry(screen, j, &geom); globalOutputStream() << "monitor " << j << " geometry: " << geom.x << ", " << geom.y << ", " << geom.width << ", " << geom.height << "\n"; if(j == 0) { // I am making the assumption that monitor 0 is always the primary monitor on win32. Tested on WinXP with gtk+-2.4. primaryMonitor = geom; } } if(m > 1) { g_multimon_globals.m_bStartOnPrimMon = true; } GlobalPreferenceSystem().registerPreference("StartOnPrimMon", BoolImportStringCaller(g_multimon_globals.m_bStartOnPrimMon), BoolExportStringCaller(g_multimon_globals.m_bStartOnPrimMon)); GlobalPreferenceSystem().registerPreference("NoSysMenuPopups", BoolImportStringCaller(g_Multimon_enableSysMenuPopups.m_latched), BoolExportStringCaller(g_Multimon_enableSysMenuPopups.m_latched)); g_Multimon_enableSysMenuPopups.useLatched(); PreferencesDialog_addInterfacePreferences(FreeCaller1<PreferencesPage&, MultiMonitor_constructPreferences>()); }
static void test_window (void) { GSWindow *window; gboolean lock_active; gboolean user_switch_enabled; GdkDisplay *display; #if GTK_CHECK_VERSION (3, 22, 0) GdkMonitor *monitor; #else GdkScreen *screen; int monitor; #endif lock_active = TRUE; user_switch_enabled = TRUE; display = gdk_display_get_default (); #if GTK_CHECK_VERSION (3, 22, 0) monitor = gdk_display_get_primary_monitor (display); #else screen = gdk_display_get_default_screen (display); monitor = gdk_screen_get_primary_monitor (screen); #endif window = gs_window_new (display, monitor, lock_active); gs_window_set_user_switch_enabled (window, user_switch_enabled); connect_window_signals (window); gs_window_show (window); }
static gboolean gdk_monitor_has_fullscreen_window (GdkMonitor *monitor) { GdkScreen *screen = gdk_display_get_default_screen (monitor->display); GList *toplevels, *l; GdkWindow *window; gboolean has_fullscreen; toplevels = gdk_screen_get_toplevel_windows (screen); has_fullscreen = FALSE; for (l = toplevels; l; l = l->next) { window = l->data; if ((gdk_window_get_state (window) & GDK_WINDOW_STATE_FULLSCREEN) == 0) continue; if (gdk_window_get_fullscreen_mode (window) == GDK_FULLSCREEN_ON_ALL_MONITORS || gdk_display_get_monitor_at_window (monitor->display, window) == monitor) { has_fullscreen = TRUE; break; } } g_list_free (toplevels); return has_fullscreen; }
static GdkScreen * get_inspector_screen (void) { static GdkDisplay *display = NULL; if (display == NULL) { const gchar *name; name = g_getenv ("GTK_INSPECTOR_DISPLAY"); display = gdk_display_open (name); if (display) g_debug ("Using display %s for GtkInspector", name); else g_message ("Failed to open display %s", name); } if (!display) { display = gdk_display_open (NULL); if (display) g_debug ("Using default display for GtkInspector"); else g_message ("Failed to separate connection to default display"); } if (!display) display = gdk_display_get_default (); return gdk_display_get_default_screen (display); }
static void ensure_size_window (MetaResizePopup *popup) { GtkWidget *frame; if (popup->size_window) return; popup->size_window = gtk_window_new (GTK_WINDOW_POPUP); gtk_window_set_screen (GTK_WINDOW (popup->size_window), gdk_display_get_default_screen (gdk_x11_lookup_xdisplay (popup->display))); /* never shrink the size window */ gtk_window_set_resizable (GTK_WINDOW (popup->size_window), TRUE); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_OUT); gtk_container_add (GTK_CONTAINER (popup->size_window), frame); popup->size_label = gtk_label_new (""); gtk_widget_set_margin_start (popup->size_label, 3); gtk_widget_set_margin_end (popup->size_label, 3); gtk_widget_set_margin_top (popup->size_label, 3); gtk_widget_set_margin_bottom (popup->size_label, 3); gtk_container_add (GTK_CONTAINER (frame), popup->size_label); gtk_widget_show_all (frame); }
static void fix_without_wm(GtkWidget* child) { GdkDisplay* default_display; GdkScreen* default_screen; gint primary_monitor; GdkRectangle dest; default_display = gdk_display_get_default(); default_screen = gdk_display_get_default_screen(default_display); GdkCursor* cursor = gdk_cursor_new_for_display (default_display, GDK_LEFT_PTR); gdk_window_set_cursor (gdk_get_default_root_window (), cursor); g_object_unref(cursor); // NOTE: width/height is total width/height of multiple-screens. // So, in this way, web-container window is forced to position in center // of all screens. //INSTALLER_WIN_WIDTH = gdk_screen_width(); //INSTALLER_WIN_HEIGHT = gdk_screen_height(); gtk_window_move(GTK_WINDOW(installer_container), 0, 0); gtk_window_fullscreen(GTK_WINDOW(installer_container)); primary_monitor = gdk_screen_get_primary_monitor(default_screen); gdk_screen_get_monitor_geometry(default_screen, primary_monitor, &dest); INSTALLER_WIN_WIDTH = dest.width; INSTALLER_WIN_HEIGHT = dest.height; g_message("[%s] installer container, width: %d, height: %d\n", __func__, INSTALLER_WIN_WIDTH, INSTALLER_WIN_HEIGHT); BackgroundInfo* bg_info = create_background_info(installer_container, child); background_info_set_background_by_file(bg_info, BACKGROUND); setup_monitor_background(); }
static void run_dialog (GdkDisplay *display, GdkScreen *screen, guint32 timestamp) { Atom action_atom; Atom atom; Window root; XClientMessageEvent ev; if (!display) display = gdk_display_get_default (); if (!screen) screen = gdk_display_get_default_screen (display); root = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window (screen)); action_atom = gdk_x11_get_xatom_by_name_for_display (display, "_MATE_PANEL_ACTION"); atom = gdk_x11_get_xatom_by_name_for_display (display, "_MATE_PANEL_ACTION_RUN_DIALOG"); ev.type = ClientMessage; ev.window = root; ev.message_type = action_atom; ev.format = 32; ev.data.l[0] = atom; ev.data.l[1] = timestamp; gdk_error_trap_push (); XSendEvent (gdk_x11_display_get_xdisplay (display), root, False, StructureNotifyMask, (XEvent*) &ev); gdk_flush (); gdk_error_trap_pop (); }
int main(int argc, char ** argv) { /* Init GTK+ */ gtk_init( &argc, &argv ); builder = gtk_builder_new(); MainWindow* window = new MainWindow(GTK_BUILDER(builder)); gtk_builder_connect_signals( GTK_BUILDER(builder), window ); /* ============== CSS ============== */ GtkCssProvider *provider; GdkDisplay *display; GdkScreen *screen; provider = gtk_css_provider_new (); display = gdk_display_get_default (); screen = gdk_display_get_default_screen (display); gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_USER); gtk_css_provider_load_from_path(GTK_CSS_PROVIDER(provider), "style.css", NULL); g_object_unref (provider); /* ============== /// ============== */ /* Start main loop */ gtk_main(); return 0; }
void side_set_application_mode(int type) { GSettings *theme = g_settings_new("org.jetspace.desktop.session"); GdkDisplay *display; GdkScreen *screen; display = gdk_display_get_default (); screen = gdk_display_get_default_screen (display); mode = type; if(g_variant_get_boolean(g_settings_get_value(theme, "use-custom-theme"))) { GtkCssProvider *provider; provider = gtk_css_provider_new (); gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); gsize bytes, read; const gchar* t = g_strdup_printf( "%s%s",g_variant_get_string(g_settings_get_value(theme, "custom-theme-path"), NULL), "/side-session/gtk.css"); if(access(t, F_OK) != 0) { system("side-notifier --theme-not-found &"); return; } gtk_css_provider_load_from_path (provider,g_filename_to_utf8(t, strlen(t), &read, &bytes, NULL),NULL); g_object_unref (provider); } }
void mpl_gdk_windowing_launch_failed (GAppLaunchContext *context, const char *startup_notify_id) { #if 0 GdkAppLaunchContextPrivate *priv; #endif GdkScreen *screen; StartupTimeoutData *data; StartupNotificationData *sn_data; GSList *l; #if 0 priv = GDK_APP_LAUNCH_CONTEXT (context)->priv; if (priv->screen) screen = priv->screen; else if (priv->display) screen = gdk_display_get_default_screen (priv->display); else #endif screen = gdk_display_get_default_screen (gdk_display_get_default ()); data = g_object_get_data (G_OBJECT (screen), "appinfo-startup-data"); if (data) { for (l = data->contexts; l != NULL; l = l->next) { sn_data = l->data; if (strcmp (startup_notify_id, sn_data->startup_id) == 0) { data->contexts = g_slist_remove (data->contexts, sn_data); end_startup_notification (sn_data->display, sn_data->startup_id); free_startup_notification_data (sn_data); break; } } if (data->contexts == NULL) { g_source_remove (data->timeout_id); data->timeout_id = 0; } } }
/* This function queries the _XROOTPMAP_ID property from the root window * to determine the current root window background pixmap and returns a * surface to draw directly to it. * If _XROOTPMAP_ID is not set, then NULL returned. */ static cairo_surface_t * get_root_pixmap_id_surface (GdkDisplay *display) { GdkScreen *screen; Display *xdisplay; Visual *xvisual; Window xroot; Atom type; int format, result; unsigned long nitems, bytes_after; unsigned char *data; cairo_surface_t *surface = NULL; g_return_val_if_fail (display != NULL, NULL); screen = gdk_display_get_default_screen (display); xdisplay = GDK_DISPLAY_XDISPLAY (display); xvisual = GDK_VISUAL_XVISUAL (gdk_screen_get_system_visual (screen)); xroot = RootWindow (xdisplay, GDK_SCREEN_XNUMBER (screen)); result = XGetWindowProperty (xdisplay, xroot, gdk_x11_get_xatom_by_name ("_XROOTPMAP_ID"), 0L, 1L, False, XA_PIXMAP, &type, &format, &nitems, &bytes_after, &data); if (result != Success || type != XA_PIXMAP || format != 32 || nitems != 1) { XFree (data); data = NULL; } if (data != NULL) { Pixmap pixmap = *(Pixmap *) data; Window root_ret; int x_ret, y_ret; unsigned int w_ret, h_ret, bw_ret, depth_ret; gdk_x11_display_error_trap_push (display); if (XGetGeometry (xdisplay, pixmap, &root_ret, &x_ret, &y_ret, &w_ret, &h_ret, &bw_ret, &depth_ret)) { surface = cairo_xlib_surface_create (xdisplay, pixmap, xvisual, w_ret, h_ret); } gdk_x11_display_error_trap_pop_ignored (display); XFree (data); } gdk_display_flush (display); return surface; }
void gimp_session_info_restore (GimpSessionInfo *info, GimpDialogFactory *factory) { GtkWidget *dialog = NULL; GdkDisplay *display = NULL; GdkScreen *screen = NULL; GimpRestoreDocksData *data = NULL; g_return_if_fail (GIMP_IS_SESSION_INFO (info)); g_return_if_fail (GIMP_IS_DIALOG_FACTORY (factory)); g_object_ref (info); display = gdk_display_get_default (); if (info->p->screen != DEFAULT_SCREEN) screen = gdk_display_get_screen (display, info->p->screen); if (! screen) screen = gdk_display_get_default_screen (display); info->p->open = FALSE; info->p->screen = DEFAULT_SCREEN; if (info->p->factory_entry && info->p->factory_entry->restore_func) { dialog = info->p->factory_entry->restore_func (factory, screen, info); } if (GIMP_IS_SESSION_MANAGED (dialog) && info->p->aux_info) gimp_session_managed_set_aux_info (GIMP_SESSION_MANAGED (dialog), info->p->aux_info); /* In single-window mode, gimp_session_managed_set_aux_info() * will set the size of the dock areas at the sides. If we don't * wait for those areas to get their size-allocation, we can't * properly restore the docks inside them, so do that in an idle * callback. */ /* Objects are unreffed again in the callback */ data = g_slice_new0 (GimpRestoreDocksData); data->info = g_object_ref (info); data->factory = g_object_ref (factory); data->screen = g_object_ref (screen); data->dialog = g_object_ref (dialog); g_idle_add ((GSourceFunc) gimp_session_info_restore_docks, data); g_object_unref (info); }
static GdkRectangle m_get_monitor_geo() { GdkRectangle r; GdkDisplay* disp = gdk_display_get_default(); GdkScreen* screen = gdk_display_get_default_screen(disp); gint mon_id = gdk_screen_get_primary_monitor(screen); gdk_screen_get_monitor_geometry(screen, mon_id, &r); return r; }
GdkColormap * get_colormap_for_drawable (GdkDrawable *d) { GdkDisplay *display = gdk_display_get_default (); GdkScreen *screen = gdk_display_get_default_screen (display); if (gdk_drawable_get_depth (d) == 32) return gdk_screen_get_rgba_colormap (screen); return gdk_screen_get_rgb_colormap (screen); }
GdkWindow * create_gdk_window (Window xframe) { GdkDisplay *display = gdk_display_get_default (); GdkScreen *screen = gdk_display_get_default_screen (display); GdkWindow *window = create_foreign_window (xframe); GdkColormap *cmap = gdk_screen_get_rgb_colormap (screen); gdk_drawable_set_colormap (GDK_DRAWABLE (window), cmap); return window; }
/** * gdk_screen_get_default: * * Gets the default screen for the default display. (See * gdk_display_get_default ()). * * Returns: (transfer none): a #GdkScreen, or %NULL if there is no default display. * * Since: 2.2 */ GdkScreen * gdk_screen_get_default (void) { GdkDisplay *default_display; default_display = gdk_display_get_default (); if (default_display) return gdk_display_get_default_screen (default_display); else return NULL; }
void side_modify_css(char *str) { GdkDisplay *display; GdkScreen *screen; display = gdk_display_get_default (); screen = gdk_display_get_default_screen (display); GtkCssProvider *provider; provider = gtk_css_provider_new (); gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); gtk_css_provider_load_from_data(provider, str, -1, NULL); g_object_unref (provider); }
void Editor::setStyle() { GtkCssProvider *provider = gtk_css_provider_get_default(); GdkDisplay *display = gdk_display_get_default(); GdkScreen *screen = gdk_display_get_default_screen(display); OovString path = Project::getBinDirectory(); path += "OovEdit.css"; GError *err = 0; gtk_css_provider_load_from_path(provider, path.getStr(), &err); gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); g_object_unref(provider); }
static void send_event (GdkWindow *window, GdkDevice *device, GdkEvent *event) { GdkDisplay *display; GList *node; gdk_event_set_device (event, device); gdk_event_set_source_device (event, device); gdk_event_set_screen (event, gdk_display_get_default_screen (gdk_window_get_display (window))); event->any.window = g_object_ref (window); display = gdk_window_get_display (window); node = _gdk_event_queue_append (display, event); _gdk_windowing_got_event (display, node, event, _gdk_display_get_next_serial (display)); }
/* Prompts the user for a toplevel window to move, and then moves * that window to the currently selected display */ static void query_change_display (ChangeDisplayInfo *info) { GdkScreen *screen = gtk_widget_get_screen (info->window); GtkWidget *toplevel; toplevel = query_for_toplevel (screen, "Please select the toplevel\n" "to move to the new screen"); if (toplevel) gtk_window_set_screen (GTK_WINDOW (toplevel), gdk_display_get_default_screen (info->current_display)); else gdk_display_beep (gdk_screen_get_display (screen)); }
void cc_style_setup() { GtkCssProvider* provider=gtk_css_provider_new(); GdkScreen*screen=gdk_display_get_default_screen(gdk_display_get_default()); GFile* cssfile=g_file_new_for_path(STYLE_PATH "image.css"); gtk_css_provider_load_from_file(GTK_CSS_PROVIDER(provider),cssfile,NULL); gtk_style_context_add_provider_for_screen(screen,GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_USER); g_object_unref(provider); }
void move_resize_window (WnckWindow *win, int direction, decor_event *gtkwd_event) { Display *xdisplay; GdkDisplay *gdkdisplay; GdkScreen *screen; Window xroot; XEvent ev; gdkdisplay = gdk_display_get_default (); xdisplay = GDK_DISPLAY_XDISPLAY (gdkdisplay); screen = gdk_display_get_default_screen (gdkdisplay); xroot = RootWindowOfScreen (gdk_x11_screen_get_xscreen (screen)); if (action_menu_mapped) { gtk_object_destroy (GTK_OBJECT (action_menu)); return; } ev.xclient.type = ClientMessage; ev.xclient.display = xdisplay; ev.xclient.serial = 0; ev.xclient.send_event = TRUE; ev.xclient.window = wnck_window_get_xid (win); ev.xclient.message_type = wm_move_resize_atom; ev.xclient.format = 32; ev.xclient.data.l[0] = gtkwd_event->x_root; ev.xclient.data.l[1] = gtkwd_event->y_root; ev.xclient.data.l[2] = direction; ev.xclient.data.l[3] = gtkwd_event->button; ev.xclient.data.l[4] = 1; XUngrabPointer (xdisplay, gtkwd_event->time); XUngrabKeyboard (xdisplay, gtkwd_event->time); XSendEvent (xdisplay, xroot, FALSE, SubstructureRedirectMask | SubstructureNotifyMask, &ev); XSync (xdisplay, FALSE); }
/* * Create all bindings, using stored configuration */ static void create_bindings() { GdkDisplay *display = gdk_display_get_default(); GdkScreen *screen = gdk_display_get_default_screen(display); if (!screen) return; GdkWindow *root = gdk_screen_get_root_window(screen); gdk_window_add_filter(root, (GdkFilterFunc) filter_keys, NULL); /* bind shortcuts */ for (Accelerator *acl = accelerators_list; acl->action != NULL; ++acl) if (acl->key != 0) grab_key(acl->key, acl->mask, root); }
static void hildon_desktop_ms_init (HildonDesktopMultiscreen *dms) { GdkDisplay *display; gint i; display = gdk_display_get_default (); #ifndef ONE_SCREEN_MONITOR dms->screens = gdk_display_get_n_screens (display); dms->monitors = g_new0 (gint, dms->screens); dms->geometries = g_new0 (GdkRectangle *, dms->screens); #else dms->screens = 1; dms->monitors = g_new0(gint,1); dms->geometries = g_new0(GdkRectangle *,1); #endif #ifndef ONE_SCREEN_MONITOR for (i = 0; i < dms->screens; i++) { GdkScreen *screen; gint j; screen = gdk_display_get_screen (display, i); g_signal_connect_swapped (screen, "size-changed", G_CALLBACK (hildon_desktop_ms_reinit), dms); dms->monitors [i] = gdk_screen_get_n_monitors (screen); dms->geometries [i] = g_new0 (GdkRectangle, dms->monitors[i]); for (j = 0; j < dms->monitors[i]; j++) gdk_screen_get_monitor_geometry (screen, j, &(dms->geometries [i][j])); } #else GdkScreen *screen = gdk_display_get_default_screen (display); g_signal_connect_swapped (screen, "size-changed", G_CALLBACK (hildon_desktop_ms_reinit), dms); dms->monitors[0] = 1; dms->geometries[0] = g_new0 (GdkRectangle,1); gdk_screen_get_monitor_geometry (screen, 1, &geometries [0][0]); #endif }
static GdkWindow * gdk_broadway_device_window_at_position (GdkDevice *device, gdouble *win_x, gdouble *win_y, GdkModifierType *mask, gboolean get_toplevel) { GdkScreen *screen; GdkWindow *root_window; GdkWindow *window; screen = gdk_display_get_default_screen (gdk_device_get_display (device)); root_window = gdk_screen_get_root_window (screen); gdk_broadway_device_query_state (device, root_window, NULL, &window, NULL, NULL, win_x, win_y, mask); return window; }
static void set_styles (void) { GtkCssProvider *provider; GdkScreen *screen; provider = gtk_css_provider_new (); if (!gtk_css_provider_load_from_data (provider, CSS, -1, NULL)) { g_assert_not_reached (); } screen = gdk_display_get_default_screen (gdk_display_get_default ()); gtk_style_context_add_provider_for_screen (screen, GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); }
static gboolean _clutter_backend_gdk_post_parse (ClutterBackend *backend, GError **error) { ClutterBackendGdk *backend_gdk = CLUTTER_BACKEND_GDK (backend); if (_foreign_dpy != NULL) backend_gdk->display = _foreign_dpy; /* Init Gdk, if outside code did not already */ if (!gdk_init_check (NULL, NULL)) return FALSE; /* * Only open connection if not already set by prior call to * clutter_gdk_set_display() */ if (backend_gdk->display == NULL) backend_gdk->display = g_object_ref (gdk_display_get_default ()); g_assert (backend_gdk->display != NULL); #ifdef GDK_WINDOWING_X11 if (GDK_IS_X11_DISPLAY (backend_gdk->display)) { /* Cogl needs to know the Xlib display connection for CoglTexturePixmapX11 */ cogl_xlib_set_display (gdk_x11_display_get_xdisplay (backend_gdk->display)); } #endif backend_gdk->screen = gdk_display_get_default_screen (backend_gdk->display); /* add event filter for Cogl events */ gdk_window_add_filter (NULL, cogl_gdk_filter, NULL); clutter_backend_gdk_init_settings (backend_gdk); CLUTTER_NOTE (BACKEND, "Gdk Display '%s' opened", gdk_display_get_name (backend_gdk->display)); return TRUE; }
static int sg_font_width(PangoFontDescription *font) { /* returns size in pixels */ int wid = 0; double dpi = 96.0; /* see below */ PangoContext *ctx; PangoFontMetrics *m; #if HAVE_GTK_LINK_BUTTON_NEW dpi = gdk_screen_get_resolution(gdk_display_get_default_screen(gdk_display_get_default())); /* pixels/inch */ #endif ctx = gdk_pango_context_get(); m = pango_context_get_metrics(ctx, font, gtk_get_default_language()); /* returns size in pango-scaled points (1024/72 inch) */ wid = (int)((dpi / 72.0) * PANGO_PIXELS(pango_font_metrics_get_approximate_char_width(m))); pango_font_metrics_unref(m); g_object_unref(ctx); return(wid); }
// Setup background image on all monitors. static void setup_monitor_background() { g_message("[%s]\n", __func__); GtkWidget* window; GtkWidget* image; GdkPixbuf* pixbuf; GdkScreen* default_screen; GdkRectangle geometry; GError* error = NULL; gint monitor_id; gint n_monitors; default_screen = gdk_display_get_default_screen(gdk_display_get_default()); n_monitors = gdk_screen_get_n_monitors(default_screen); for (monitor_id = 0; monitor_id < n_monitors; ++monitor_id) { window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_type_hint(GTK_WINDOW(window), GDK_WINDOW_TYPE_HINT_DESKTOP); gdk_screen_get_monitor_geometry(default_screen, monitor_id, &geometry); g_message("[%s] monitor: %d, x: %d, y: %d, width: %d, height: %d\n", __func__, monitor_id, geometry.x, geometry.y, geometry.width, geometry.height); image = gtk_image_new(); pixbuf = gdk_pixbuf_new_from_file_at_scale(BACKGROUND, geometry.width, geometry.height, FALSE, &error); if (error != NULL) { g_warning("[%s] failed to load background image: %s\n", __func__, BACKGROUND); g_error_free(error); return; } gtk_image_set_from_pixbuf(GTK_IMAGE(image), pixbuf); gtk_window_move(GTK_WINDOW(window), geometry.x, geometry.y); gtk_window_set_default_size(GTK_WINDOW(window), geometry.width, geometry.height); gtk_window_fullscreen(GTK_WINDOW(window)); gtk_container_add(GTK_CONTAINER(window), image); gtk_widget_show_all(window); } }
static void style_window(GtkWidget *window, wconf_t conf) { GdkDisplay *display; GdkScreen *screen; GtkCssProvider *provider; GFile *file; GError *err; gtk_window_set_decorated(GTK_WINDOW(window), FALSE); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_window_set_default_size(GTK_WINDOW(window), SEARCH_WIDTH, SEARCH_HEIGHT); gtk_window_set_title(GTK_WINDOW(window), "Morun"); gtk_window_set_resizable(GTK_WINDOW(window), FALSE); char path[256]; if (conf.style == NULL) snprintf(path, sizeof(path), "%s/.morun.css", getenv("HOME")); else snprintf(path, sizeof(path), "%s", conf.style); file = g_file_new_for_path(path); provider = gtk_css_provider_new(); display = gdk_display_get_default(); screen = gdk_display_get_default_screen(display); err = NULL; gtk_style_context_add_provider_for_screen(screen, GTK_STYLE_PROVIDER(provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); gtk_css_provider_load_from_file(GTK_CSS_PROVIDER(provider), file, &err); if (err != NULL) { printf("Error occurred while loading style:\n%s\n", err->message); exit(1); } g_object_unref(provider); }