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);
}
