/********************************************************************\
* gnc_restore_window_size *
* restores the position and size of the given window, if these *
* these parameters have been saved earlier. Does nothing if no *
* saved values are found. *
* *
* Args: group - the preferences group to look in for saved coords *
* window - the window for which the coords are to be *
* restored *
* Returns: nothing *
\*******************************************************************/
void
gnc_restore_window_size(const char *group, GtkWindow *window)
{
gint wpos[2], wsize[2];
GVariant *geometry;
ENTER("");
g_return_if_fail(group != NULL);
g_return_if_fail(window != NULL);
if (!gnc_prefs_get_bool(GNC_PREFS_GROUP_GENERAL, GNC_PREF_SAVE_GEOMETRY))
return;
geometry = gnc_prefs_get_value (group, GNC_PREF_LAST_GEOMETRY);
if (g_variant_is_of_type (geometry, (const GVariantType *) "(iiii)") )
{
gint screen_width;
gint screen_height;
#if GTK_CHECK_VERSION(3,22,0)
GdkWindow *win = gdk_screen_get_root_window (gtk_window_get_screen (window));
GdkMonitor *mon = gdk_display_get_monitor_at_window (gtk_widget_get_display (GTK_WIDGET(window)), win);
GdkRectangle monitor_size;
gdk_monitor_get_geometry (mon, &monitor_size);
screen_width = monitor_size.width;
screen_height = monitor_size.height;
#else
screen_width = gdk_screen_width(); //default screen
screen_height = gdk_screen_height(); //default screen
#endif
g_variant_get (geometry, "(iiii)",
&wpos[0], &wpos[1],
&wsize[0], &wsize[1]);
DEBUG("geometry from preferences - wpos[0]: %d, wpos[1]: %d, wsize[0]: %d, wsize[1]: %d",
wpos[0], wpos[1], wsize[0], wsize[1]);
/* (-1, -1) means no geometry was saved (default preferences value) */
if ((wpos[0] != -1) && (wpos[1] != -1))
{
/* Keep the window on screen if possible */
if (screen_width != 0)
wpos[0] = wpos[0] % screen_width;
if (screen_height != 0)
wpos[1] = wpos[1] % screen_height;
DEBUG("geometry after screen adaption - wpos[0]: %d, wpos[1]: %d, wsize[0]: %d, wsize[1]: %d",
wpos[0], wpos[1], wsize[0], wsize[1]);
gtk_window_move(window, wpos[0], wpos[1]);
}
/* Don't attempt to restore invalid sizes */
if ((wsize[0] > 0) && (wsize[1] > 0))
gtk_window_resize(window, wsize[0], wsize[1]);
}
g_variant_unref (geometry);
LEAVE("");
}
gdouble
ev_document_misc_get_screen_dpi (GdkScreen *screen, GdkMonitor *monitor)
{
gdouble dp, di;
int mmX, mmY;
GdkRectangle monitorRect;
/*diagonal in pixels*/
gdk_monitor_get_geometry(monitor, &monitorRect);
/*diagonal in inches*/
mmX = gdk_monitor_get_width_mm(monitor);
mmY = gdk_monitor_get_height_mm(monitor);
/* Fallback in cases where devices report their aspect ratio */
if ((mmX == 160 && (mmY == 90 || mmY == 100)) ||
(mmX == 16 && (mmY == 9 || mmY == 10)) ||
mmX == 0 || mmY == 0 ||
monitorRect.width == 0 || monitorRect.height == 0) {
return 96.0;
}
dp = hypot (monitorRect.width, monitorRect.height);
di = hypot (mmX, mmY) / 25.4;
di /= gdk_monitor_get_scale_factor(monitor);
return (dp / di);
}
static void
update_bounding_box (GdkScreen *screen)
{
GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
GdkX11Display *x11_display = GDK_X11_DISPLAY (x11_screen->display);
gint i, x1, y1, x2, y2;
x1 = y1 = G_MAXINT;
x2 = y2 = G_MININT;
for (i = 0; i < x11_display->monitors->len; i++)
{
GdkX11Monitor *monitor = x11_display->monitors->pdata[i];
GdkRectangle geometry;
gdk_monitor_get_geometry (GDK_MONITOR (monitor), &geometry);
x1 = MIN (x1, geometry.x);
y1 = MIN (y1, geometry.y);
x2 = MAX (x2, geometry.x + geometry.width);
y2 = MAX (y2, geometry.y + geometry.height);
}
x11_screen->width = x2 - x1;
x11_screen->height = y2 - y1;
}
static void
gs_manager_create_window_for_monitor (GSManager *manager,
GdkMonitor *monitor)
{
GSWindow *window;
GdkRectangle rect;
gdk_monitor_get_geometry (monitor, &rect);
gs_debug ("Creating a window [%d,%d] (%dx%d)",
rect.x, rect.y, rect.width, rect.height);
window = gs_window_new (monitor, manager->priv->lock_active);
gs_window_set_user_switch_enabled (window, manager->priv->user_switch_enabled);
gs_window_set_logout_enabled (window, manager->priv->logout_enabled);
gs_window_set_logout_timeout (window, manager->priv->logout_timeout);
gs_window_set_logout_command (window, manager->priv->logout_command);
gs_window_set_keyboard_enabled (window, manager->priv->keyboard_enabled);
gs_window_set_keyboard_command (window, manager->priv->keyboard_command);
gs_window_set_status_message (window, manager->priv->status_message);
connect_window_signals (manager, window);
manager->priv->windows = g_slist_append (manager->priv->windows, window);
if (manager->priv->active && !manager->priv->fading)
{
gtk_widget_show (GTK_WIDGET (window));
}
}
static void
nimf_candidate_show (NimfCandidatable *candidatable,
NimfServiceIC *target,
gboolean show_entry)
{
g_debug (G_STRLOC ": %s", G_STRFUNC);
NimfCandidate *candidate = NIMF_CANDIDATE (candidatable);
GtkRequisition natural_size;
int x, y, w, h;
GdkRectangle geometry;
const NimfRectangle *cursor_area;
cursor_area = nimf_service_ic_get_cursor_location (target);
#if GTK_CHECK_VERSION (3, 22, 0)
GdkDisplay *display = gtk_widget_get_display (candidate->window);
GdkMonitor *monitor;
monitor = gdk_display_get_monitor_at_point (display,
cursor_area->x, cursor_area->y);
gdk_monitor_get_geometry (monitor, &geometry);
#else
GdkScreen *screen = gtk_widget_get_screen (candidate->window);
gint monitor_num = gdk_screen_get_monitor_at_point (screen,
cursor_area->x,
cursor_area->y);
gdk_screen_get_monitor_geometry (screen, monitor_num, &geometry);
#endif
candidate->target = target;
if (show_entry)
gtk_widget_show (candidate->entry);
else
gtk_widget_hide (candidate->entry);
gtk_widget_show_all (candidate->window);
gtk_widget_get_preferred_size (candidate->window, NULL, &natural_size);
gtk_window_resize (GTK_WINDOW (candidate->window),
natural_size.width, natural_size.height);
gtk_window_get_size (GTK_WINDOW (candidate->window), &w, &h);
x = cursor_area->x - cursor_area->width;
y = cursor_area->y + cursor_area->height;
if (x + w > geometry.x + geometry.width)
x = geometry.x + geometry.width - w;
if ((y + h > geometry.y + geometry.height) &&
((cursor_area->y - h) >= geometry.y))
y = cursor_area->y - h;
gtk_window_move (GTK_WINDOW (candidate->window), x, y);
}
int
main(int argc, char **argv)
{
GError *error = NULL;
GdkMonitor *monitor;
GdkRectangle monitor_bounds;
GOptionContext *context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, options, NULL);
frame_stats_add_options (g_option_context_get_main_group (context));
g_option_context_add_group (context,
gtk_get_option_group (TRUE));
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("Option parsing failed: %s\n", error->message);
return 1;
}
g_print ("# Load factor: %g\n",
load_factor);
g_print ("# Resizing?: %s\n",
cb_no_resize ? "no" : "yes");
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
frame_stats_ensure (GTK_WINDOW (window));
gtk_window_set_keep_above (GTK_WINDOW (window), TRUE);
gtk_window_set_gravity (GTK_WINDOW (window), GDK_GRAVITY_CENTER);
gtk_widget_set_app_paintable (window, TRUE);
g_signal_connect (window, "draw",
G_CALLBACK (on_window_draw), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (window, "map-event",
G_CALLBACK (on_map_event), NULL);
on_frame (0.);
monitor = gdk_display_get_primary_monitor (gtk_widget_get_display (window));
gdk_monitor_get_geometry (monitor, &monitor_bounds);
gtk_window_move (GTK_WINDOW (window),
monitor_bounds.x + (monitor_bounds.width - window_width) / 2,
monitor_bounds.y + (monitor_bounds.height - window_height) / 2);
gtk_widget_show (window);
gtk_main ();
return 0;
}
bool BigEnough()
{
#if GTK3_MONITOR_API
GdkMonitor *monitor = gdk_display_get_primary_monitor(gdk_display_get_default());
// int scale = gdk_monitor_get_scale_factor(monitor);
GdkRectangle my_geometry;
gdk_monitor_get_geometry(monitor, &my_geometry);
return my_geometry.height > 1000;
#else
return (gdk_screen_get_height(gdk_screen_get_default()) > 1000);
#endif
}
void wxDisplaySize( int *width, int *height )
{
#ifdef __WXGTK4__
GdkMonitor* monitor = gdk_display_get_primary_monitor(gdk_display_get_default());
GdkRectangle rect;
gdk_monitor_get_geometry(monitor, &rect);
if (width) *width = rect.width;
if (height) *height = rect.height;
#else
wxGCC_WARNING_SUPPRESS(deprecated-declarations)
if (width) *width = gdk_screen_width();
if (height) *height = gdk_screen_height();
wxGCC_WARNING_RESTORE()
#endif
}
/**
* gdk_screen_get_monitor_geometry:
* @screen: a #GdkScreen
* @monitor_num: the monitor number
* @dest: (out) (allow-none): a #GdkRectangle to be filled with
* the monitor geometry
*
* Retrieves the #GdkRectangle representing the size and position of
* the individual monitor within the entire screen area. The returned
* geometry is in ”application pixels”, not in ”device pixels” (see
* gdk_screen_get_monitor_scale_factor()).
*
* Monitor numbers start at 0. To obtain the number of monitors of
* @screen, use gdk_screen_get_n_monitors().
*
* Note that the size of the entire screen area can be retrieved via
* gdk_screen_get_width() and gdk_screen_get_height().
*
* Since: 2.2
*/
void
gdk_screen_get_monitor_geometry (GdkScreen *screen,
gint monitor_num,
GdkRectangle *dest)
{
GdkMonitor *monitor;
g_return_if_fail (GDK_IS_SCREEN (screen));
monitor = get_monitor (screen, monitor_num);
g_return_if_fail (monitor != NULL);
gdk_monitor_get_geometry (monitor, dest);
}
/********************************************************************\
* gnc_window_adjust_for_screen *
* adjust the window size if it is bigger than the screen size. *
* *
* Args: window - the window to adjust *
* Returns: nothing *
\********************************************************************/
void
gnc_window_adjust_for_screen(GtkWindow * window)
{
#if GTK_CHECK_VERSION(3,22,0)
GdkWindow *win;
GdkMonitor *mon;
GdkRectangle monitor_size;
#endif
gint screen_width;
gint screen_height;
gint width;
gint height;
if (window == NULL)
return;
g_return_if_fail(GTK_IS_WINDOW(window));
if (gtk_widget_get_window (GTK_WIDGET(window)) == NULL)
return;
#if GTK_CHECK_VERSION(3,22,0)
win = gdk_screen_get_root_window (gtk_window_get_screen (window));
mon = gdk_display_get_monitor_at_window (gtk_widget_get_display (GTK_WIDGET(window)), win);
gdk_monitor_get_geometry (mon, &monitor_size);
screen_width = monitor_size.width;
screen_height = monitor_size.height;
#else
screen_width = gdk_screen_width();
screen_height = gdk_screen_height();
#endif
width = gdk_window_get_width (gtk_widget_get_window (GTK_WIDGET(window)));
height = gdk_window_get_height (gtk_widget_get_window (GTK_WIDGET(window)));
if ((width <= screen_width) && (height <= screen_height))
return;
width = MIN(width, screen_width - 10);
width = MAX(width, 0);
height = MIN(height, screen_height - 10);
height = MAX(height, 0);
gdk_window_resize(gtk_widget_get_window (GTK_WIDGET(window)), width, height);
gtk_widget_queue_resize(GTK_WIDGET(window));
}
static void
gdk_x11_monitor_get_workarea (GdkMonitor *monitor,
GdkRectangle *dest)
{
GdkScreen *screen = gdk_display_get_default_screen (monitor->display);
GdkRectangle workarea;
gdk_monitor_get_geometry (monitor, dest);
/* The EWMH constrains workarea to be a rectangle, so it
* can't adequately deal with L-shaped monitor arrangements.
* As a workaround, we ignore the workarea for anything
* but the primary monitor. Since that is where the 'desktop
* chrome' usually lives, this works ok in practice.
*/
if (gdk_monitor_is_primary (monitor) &&
!gdk_monitor_has_fullscreen_window (monitor))
{
gdk_x11_screen_get_work_area (screen, &workarea);
if (gdk_rectangle_intersect (dest, &workarea, &workarea))
*dest = workarea;
}
}
static gboolean
init_randr13 (GdkScreen *screen, gboolean *changed)
{
#ifdef HAVE_RANDR
GdkDisplay *display = gdk_screen_get_display (screen);
GdkX11Display *x11_display = GDK_X11_DISPLAY (display);
GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
XRRScreenResources *resources;
RROutput primary_output = None;
RROutput first_output = None;
int i;
gboolean randr12_compat = FALSE;
int old_primary;
if (!x11_display->have_randr13)
return FALSE;
resources = XRRGetScreenResourcesCurrent (x11_screen->xdisplay,
x11_screen->xroot_window);
if (!resources)
return FALSE;
for (i = 0; i < x11_display->monitors->len; i++)
{
GdkX11Monitor *monitor = x11_display->monitors->pdata[i];
monitor->add = FALSE;
monitor->remove = TRUE;
}
for (i = 0; i < resources->noutput; ++i)
{
RROutput output = resources->outputs[i];
XRROutputInfo *output_info =
XRRGetOutputInfo (x11_screen->xdisplay, resources, output);
/* Non RandR1.2+ X driver have output name "default" */
randr12_compat |= !g_strcmp0 (output_info->name, "default");
if (output_info->connection == RR_Disconnected)
{
XRRFreeOutputInfo (output_info);
continue;
}
if (output_info->crtc)
{
GdkX11Monitor *monitor;
XRRCrtcInfo *crtc = XRRGetCrtcInfo (x11_screen->xdisplay, resources, output_info->crtc);
char *name;
GdkRectangle geometry;
GdkRectangle newgeo;
int j;
int refresh_rate = 0;
for (j = 0; j < resources->nmode; j++)
{
XRRModeInfo *xmode = &resources->modes[j];
if (xmode->id == crtc->mode)
{
refresh_rate = (1000 * xmode->dotClock) / (xmode->hTotal *xmode->vTotal);
break;
}
}
monitor = find_monitor_by_output (x11_display, output);
if (monitor)
monitor->remove = FALSE;
else
{
monitor = g_object_new (gdk_x11_monitor_get_type (),
"display", display,
NULL);
monitor->output = output;
monitor->add = TRUE;
g_ptr_array_add (x11_display->monitors, monitor);
}
gdk_monitor_get_geometry (GDK_MONITOR (monitor), &geometry);
name = g_strndup (output_info->name, output_info->nameLen);
newgeo.x = crtc->x / x11_screen->window_scale;
newgeo.y = crtc->y / x11_screen->window_scale;
newgeo.width = crtc->width / x11_screen->window_scale;
newgeo.height = crtc->height / x11_screen->window_scale;
if (newgeo.x != geometry.x ||
newgeo.y != geometry.y ||
newgeo.width != geometry.width ||
newgeo.height != geometry.height ||
output_info->mm_width != gdk_monitor_get_width_mm (GDK_MONITOR (monitor)) ||
output_info->mm_height != gdk_monitor_get_height_mm (GDK_MONITOR (monitor)) ||
g_strcmp0 (name, gdk_monitor_get_model (GDK_MONITOR (monitor))) != 0)
*changed = TRUE;
gdk_monitor_set_position (GDK_MONITOR (monitor), newgeo.x, newgeo.y);
gdk_monitor_set_size (GDK_MONITOR (monitor), newgeo.width, newgeo.height);
g_object_notify (G_OBJECT (monitor), "workarea");
gdk_monitor_set_physical_size (GDK_MONITOR (monitor),
output_info->mm_width,
output_info->mm_height);
gdk_monitor_set_subpixel_layout (GDK_MONITOR (monitor),
translate_subpixel_order (output_info->subpixel_order));
gdk_monitor_set_refresh_rate (GDK_MONITOR (monitor), refresh_rate);
gdk_monitor_set_scale_factor (GDK_MONITOR (monitor), x11_screen->window_scale);
gdk_monitor_set_model (GDK_MONITOR (monitor), name);
g_free (name);
XRRFreeCrtcInfo (crtc);
}
XRRFreeOutputInfo (output_info);
}
if (resources->noutput > 0)
first_output = resources->outputs[0];
XRRFreeScreenResources (resources);
if (randr12_compat)
{
for (i = 0; i < x11_display->monitors->len; i++)
{
GdkX11Monitor *monitor = x11_display->monitors->pdata[i];
if (monitor->remove)
gdk_display_monitor_removed (display, GDK_MONITOR (monitor));
}
g_ptr_array_remove_range (x11_display->monitors, 0, x11_display->monitors->len);
return FALSE;
}
for (i = x11_display->monitors->len - 1; i >= 0; i--)
{
GdkX11Monitor *monitor = x11_display->monitors->pdata[i];
if (monitor->add)
{
gdk_display_monitor_added (display, GDK_MONITOR (monitor));
*changed = TRUE;
}
else if (monitor->remove)
{
g_object_ref (monitor);
g_ptr_array_remove (x11_display->monitors, monitor);
gdk_display_monitor_removed (display, GDK_MONITOR (monitor));
g_object_unref (monitor);
*changed = TRUE;
}
}
old_primary = x11_display->primary_monitor;
x11_display->primary_monitor = 0;
primary_output = XRRGetOutputPrimary (x11_screen->xdisplay,
x11_screen->xroot_window);
for (i = 0; i < x11_display->monitors->len; ++i)
{
GdkX11Monitor *monitor = x11_display->monitors->pdata[i];
if (monitor->output == primary_output)
{
x11_display->primary_monitor = i;
break;
}
/* No RandR1.3+ available or no primary set, fall back to prefer LVDS as primary if present */
if (primary_output == None &&
g_ascii_strncasecmp (gdk_monitor_get_model (GDK_MONITOR (monitor)), "LVDS", 4) == 0)
{
x11_display->primary_monitor = i;
break;
}
/* No primary specified and no LVDS found */
if (monitor->output == first_output)
x11_display->primary_monitor = i;
}
if (x11_display->primary_monitor != old_primary)
*changed = TRUE;
return x11_display->monitors->len > 0;
#endif
return FALSE;
}
static gboolean
gnc_reconcile_view_tooltip_cb (GNCQueryView *qview, gint x, gint y,
gboolean keyboard_mode, GtkTooltip *tooltip, gpointer *user_data)
{
GtkTreeModel* model;
GtkTreeIter iter;
// If the Description is longer than can be display, show it in a tooltip
if (gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (qview), &x, &y, keyboard_mode, &model, NULL, &iter))
{
GtkTreeViewColumn *col;
GList *cols;
gint col_pos, col_width;
gchar* desc_text = NULL;
/* Are we in keyboard tooltip mode, displays tooltip below/above treeview CTRL+F1 */
if (keyboard_mode == FALSE)
{
if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (qview), x, y, NULL, &col, NULL, NULL) == FALSE)
return FALSE;
}
else
gtk_tree_view_get_cursor (GTK_TREE_VIEW (qview), NULL, &col);
cols = gtk_tree_view_get_columns (GTK_TREE_VIEW (qview));
col_width = gtk_tree_view_column_get_width (col);
col_pos = g_list_index (cols, col);
g_list_free (cols);
/* If column is not description, do not show tooltip */
if (col_pos != (REC_DESC - 1)) // allow for the pointer model column at 0
return FALSE;
gtk_tree_model_get (model, &iter, REC_DESC, &desc_text, -1);
if (desc_text)
{
PangoLayout* layout;
gint text_width;
gint root_x, root_y;
gint cur_x, cur_y;
layout = gtk_widget_create_pango_layout (GTK_WIDGET (qview), desc_text);
pango_layout_get_pixel_size (layout, &text_width, NULL);
g_object_unref (layout);
/* If text_width + 10 <= column_width, do not show tooltip */
if ((text_width + 10) <= col_width)
{
g_free (desc_text);
return FALSE;
}
if (keyboard_mode == FALSE)
{
#if GTK_CHECK_VERSION(3,20,0)
GdkSeat *seat;
#else
GdkDeviceManager *device_manager;
#endif
GdkDevice *pointer;
GtkWindow *tip_win = NULL;
GdkWindow *parent_window;
GList *win_list, *node;
parent_window = gtk_widget_get_parent_window (GTK_WIDGET (qview));
#if GTK_CHECK_VERSION(3,20,0)
seat = gdk_display_get_default_seat (gdk_window_get_display (parent_window));
pointer = gdk_seat_get_pointer (seat);
#else
device_manager = gdk_display_get_device_manager (gdk_window_get_display (parent_window));
pointer = gdk_device_manager_get_client_pointer (device_manager);
#endif
gdk_window_get_device_position (parent_window, pointer, &cur_x, &cur_y, NULL);
gdk_window_get_origin (parent_window, &root_x, &root_y);
/* Get a list of toplevel windows */
win_list = gtk_window_list_toplevels ();
/* Look for the gtk-tooltip window, we do this as gtk_widget_get_tooltip_window
does not seem to work for the default tooltip window, custom yes */
for (node = win_list; node != NULL; node = node->next)
{
if (g_strcmp0 (gtk_widget_get_name (node->data), "gtk-tooltip") == 0)
tip_win = node->data;
}
g_list_free (win_list);
gtk_tooltip_set_text (tooltip, desc_text);
if (GTK_IS_WINDOW (tip_win))
{
#if GTK_CHECK_VERSION(3,22,0)
GdkMonitor *mon;
#else
GdkScreen *screen;
gint monitor_num;
#endif
GdkRectangle monitor;
GtkRequisition requisition;
gint x, y;
gtk_widget_get_preferred_size (GTK_WIDGET (tip_win), &requisition, NULL);
x = root_x + cur_x + 10;
y = root_y + cur_y + 10;
#if GTK_CHECK_VERSION(3,22,0)
mon = gdk_display_get_monitor_at_point (gdk_display_get_default(), x, y);
gdk_monitor_get_geometry (mon, &monitor);
#else
screen = gtk_widget_get_screen (GTK_WIDGET (qview));
monitor_num = gdk_screen_get_monitor_at_point (screen, x, y);
gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
#endif
if (x + requisition.width > monitor.x + monitor.width)
x -= x - (monitor.x + monitor.width) + requisition.width;
else if (x < monitor.x)
x = monitor.x;
if (y + requisition.height > monitor.y + monitor.height)
y -= y - (monitor.y + monitor.height) + requisition.height;
gtk_window_move (tip_win, x, y);
}
}
gtk_tooltip_set_text (tooltip, desc_text);
g_free (desc_text);
return TRUE;
}
}
return FALSE;
}
/**
* gimp_session_info_read_geometry:
* @info: A #GimpSessionInfo
* @cevent A #GdkEventConfigure. If set, use the size from here
* instead of from the window allocation.
*
* Read geometry related information from the associated widget.
**/
void
gimp_session_info_read_geometry (GimpSessionInfo *info,
GdkEventConfigure *cevent)
{
GdkWindow *window;
GdkDisplay *display;
g_return_if_fail (GIMP_IS_SESSION_INFO (info));
g_return_if_fail (GTK_IS_WINDOW (info->p->widget));
window = gtk_widget_get_window (info->p->widget);
display = gtk_widget_get_display (info->p->widget);
if (window)
{
gint x, y;
GdkMonitor *monitor;
GdkRectangle geometry;
gtk_window_get_position (GTK_WINDOW (info->p->widget), &x, &y);
/* Don't write negative values to the sessionrc, they are
* interpreted as relative to the right, respective bottom edge
* of the display.
*/
info->p->x = MAX (0, x);
info->p->y = MAX (0, y);
monitor = gdk_display_get_monitor_at_point (display,
info->p->x, info->p->y);
gdk_monitor_get_geometry (monitor, &geometry);
/* Always store window coordinates relative to the monitor */
info->p->x -= geometry.x;
info->p->y -= geometry.y;
if (gimp_session_info_get_remember_size (info))
{
gtk_window_get_size (GTK_WINDOW (info->p->widget),
&info->p->width, &info->p->height);
}
else
{
info->p->width = 0;
info->p->height = 0;
}
info->p->monitor = DEFAULT_MONITOR;
if (monitor != gdk_display_get_primary_monitor (display))
info->p->monitor = monitor;
}
info->p->open = FALSE;
if (gimp_session_info_get_remember_if_open (info))
{
GimpDialogVisibilityState visibility;
visibility =
GPOINTER_TO_INT (g_object_get_data (G_OBJECT (info->p->widget),
GIMP_DIALOG_VISIBILITY_KEY));
switch (visibility)
{
case GIMP_DIALOG_VISIBILITY_UNKNOWN:
info->p->open = gtk_widget_get_visible (info->p->widget);
break;
case GIMP_DIALOG_VISIBILITY_INVISIBLE:
info->p->open = FALSE;
break;
case GIMP_DIALOG_VISIBILITY_HIDDEN:
case GIMP_DIALOG_VISIBILITY_VISIBLE:
/* Even if a dialog is hidden (with Windows->Hide docks) it
* is still considered open. It will be restored the next
* time GIMP starts
*/
info->p->open = TRUE;
break;
}
}
}
gboolean
_gdk_win32_display_init_monitors (GdkWin32Display *win32_display)
{
GdkDisplay *display = GDK_DISPLAY (win32_display);
GPtrArray *new_monitors;
gint i;
gboolean changed = FALSE;
GdkWin32Monitor *primary_to_move = NULL;
for (i = 0; i < win32_display->monitors->len; i++)
GDK_WIN32_MONITOR (g_ptr_array_index (win32_display->monitors, i))->remove = TRUE;
new_monitors = _gdk_win32_display_get_monitor_list (win32_display);
for (i = 0; i < new_monitors->len; i++)
{
GdkWin32Monitor *w32_m;
GdkMonitor *m;
GdkWin32Monitor *w32_ex_monitor;
GdkMonitor *ex_monitor;
GdkRectangle geometry, ex_geometry;
GdkRectangle workarea, ex_workarea;
w32_m = GDK_WIN32_MONITOR (g_ptr_array_index (new_monitors, i));
m = GDK_MONITOR (w32_m);
ex_monitor = _gdk_win32_display_find_matching_monitor (win32_display, m);
w32_ex_monitor = GDK_WIN32_MONITOR (ex_monitor);
if (ex_monitor == NULL)
{
w32_m->add = TRUE;
changed = TRUE;
continue;
}
w32_ex_monitor->remove = FALSE;
if (i == 0)
primary_to_move = w32_ex_monitor;
gdk_monitor_get_geometry (m, &geometry);
gdk_monitor_get_geometry (ex_monitor, &ex_geometry);
gdk_monitor_get_workarea (m, &workarea);
gdk_monitor_get_workarea (ex_monitor, &ex_workarea);
if (memcmp (&workarea, &ex_workarea, sizeof (GdkRectangle)) != 0)
{
w32_ex_monitor->work_rect = workarea;
changed = TRUE;
}
if (memcmp (&geometry, &ex_geometry, sizeof (GdkRectangle)) != 0)
{
gdk_monitor_set_size (ex_monitor, geometry.width, geometry.height);
gdk_monitor_set_position (ex_monitor, geometry.x, geometry.y);
changed = TRUE;
}
if (gdk_monitor_get_width_mm (m) != gdk_monitor_get_width_mm (ex_monitor) ||
gdk_monitor_get_height_mm (m) != gdk_monitor_get_height_mm (ex_monitor))
{
gdk_monitor_set_physical_size (ex_monitor,
gdk_monitor_get_width_mm (m),
gdk_monitor_get_height_mm (m));
changed = TRUE;
}
if (g_strcmp0 (gdk_monitor_get_model (m), gdk_monitor_get_model (ex_monitor)) != 0)
{
gdk_monitor_set_model (ex_monitor,
gdk_monitor_get_model (m));
changed = TRUE;
}
if (g_strcmp0 (gdk_monitor_get_manufacturer (m), gdk_monitor_get_manufacturer (ex_monitor)) != 0)
{
gdk_monitor_set_manufacturer (ex_monitor,
gdk_monitor_get_manufacturer (m));
changed = TRUE;
}
if (gdk_monitor_get_refresh_rate (m) != gdk_monitor_get_refresh_rate (ex_monitor))
{
gdk_monitor_set_refresh_rate (ex_monitor, gdk_monitor_get_refresh_rate (m));
changed = TRUE;
}
if (gdk_monitor_get_scale_factor (m) != gdk_monitor_get_scale_factor (ex_monitor))
{
gdk_monitor_set_scale_factor (ex_monitor, gdk_monitor_get_scale_factor (m));
changed = TRUE;
}
if (gdk_monitor_get_subpixel_layout (m) != gdk_monitor_get_subpixel_layout (ex_monitor))
{
gdk_monitor_set_subpixel_layout (ex_monitor, gdk_monitor_get_subpixel_layout (m));
changed = TRUE;
}
}
for (i = win32_display->monitors->len - 1; i >= 0; i--)
{
GdkWin32Monitor *w32_ex_monitor;
GdkMonitor *ex_monitor;
w32_ex_monitor = GDK_WIN32_MONITOR (g_ptr_array_index (win32_display->monitors, i));
ex_monitor = GDK_MONITOR (w32_ex_monitor);
if (!w32_ex_monitor->remove)
continue;
changed = TRUE;
gdk_display_monitor_removed (display, ex_monitor);
g_ptr_array_remove_index (win32_display->monitors, i);
}
for (i = 0; i < new_monitors->len; i++)
{
GdkWin32Monitor *w32_m;
GdkMonitor *m;
w32_m = GDK_WIN32_MONITOR (g_ptr_array_index (new_monitors, i));
m = GDK_MONITOR (w32_m);
if (!w32_m->add)
continue;
gdk_display_monitor_added (display, m);
if (i == 0)
g_ptr_array_insert (win32_display->monitors, 0, g_object_ref (w32_m));
else
g_ptr_array_add (win32_display->monitors, g_object_ref (w32_m));
}
g_ptr_array_free (new_monitors, TRUE);
if (primary_to_move)
{
g_ptr_array_remove (win32_display->monitors, g_object_ref (primary_to_move));
g_ptr_array_insert (win32_display->monitors, 0, primary_to_move);
changed = TRUE;
}
return changed;
}
static gboolean
init_randr15 (GdkX11Screen *x11_screen, gboolean *changed)
{
#ifdef HAVE_RANDR15
GdkDisplay *display = GDK_SCREEN_DISPLAY (x11_screen);
GdkX11Display *x11_display = GDK_X11_DISPLAY (display);
XRRScreenResources *resources;
RROutput primary_output = None;
RROutput first_output = None;
int i;
XRRMonitorInfo *rr_monitors;
int num_rr_monitors;
int old_primary;
if (!x11_display->have_randr15)
return FALSE;
resources = XRRGetScreenResourcesCurrent (x11_screen->xdisplay,
x11_screen->xroot_window);
if (!resources)
return FALSE;
rr_monitors = XRRGetMonitors (x11_screen->xdisplay,
x11_screen->xroot_window,
True,
&num_rr_monitors);
if (!rr_monitors)
return FALSE;
for (i = 0; i < x11_display->monitors->len; i++)
{
GdkX11Monitor *monitor = x11_display->monitors->pdata[i];
monitor->add = FALSE;
monitor->remove = TRUE;
}
for (i = 0; i < num_rr_monitors; i++)
{
RROutput output = rr_monitors[i].outputs[0];
XRROutputInfo *output_info;
GdkX11Monitor *monitor;
GdkRectangle geometry;
GdkRectangle newgeo;
char *name;
int refresh_rate = 0;
gdk_x11_display_error_trap_push (display);
output_info = XRRGetOutputInfo (x11_screen->xdisplay, resources, output);
if (gdk_x11_display_error_trap_pop (display))
continue;
if (output_info == NULL)
continue;
if (output_info->connection == RR_Disconnected)
{
XRRFreeOutputInfo (output_info);
continue;
}
if (first_output == None)
first_output = output;
if (output_info->crtc)
{
XRRCrtcInfo *crtc = XRRGetCrtcInfo (x11_screen->xdisplay, resources, output_info->crtc);
int j;
for (j = 0; j < resources->nmode; j++)
{
XRRModeInfo *xmode = &resources->modes[j];
if (xmode->id == crtc->mode)
{
if (xmode->hTotal != 0 && xmode->vTotal != 0)
refresh_rate = (1000 * xmode->dotClock) / (xmode->hTotal * xmode->vTotal);
break;
}
}
XRRFreeCrtcInfo (crtc);
}
monitor = find_monitor_by_output (x11_display, output);
if (monitor)
monitor->remove = FALSE;
else
{
monitor = g_object_new (GDK_TYPE_X11_MONITOR,
"display", display,
NULL);
monitor->output = output;
monitor->add = TRUE;
g_ptr_array_add (x11_display->monitors, monitor);
}
gdk_monitor_get_geometry (GDK_MONITOR (monitor), &geometry);
name = g_strndup (output_info->name, output_info->nameLen);
newgeo.x = rr_monitors[i].x / x11_screen->surface_scale;
newgeo.y = rr_monitors[i].y / x11_screen->surface_scale;
newgeo.width = rr_monitors[i].width / x11_screen->surface_scale;
newgeo.height = rr_monitors[i].height / x11_screen->surface_scale;
if (newgeo.x != geometry.x ||
newgeo.y != geometry.y ||
newgeo.width != geometry.width ||
newgeo.height != geometry.height ||
rr_monitors[i].mwidth != gdk_monitor_get_width_mm (GDK_MONITOR (monitor)) ||
rr_monitors[i].mheight != gdk_monitor_get_height_mm (GDK_MONITOR (monitor)) ||
g_strcmp0 (name, gdk_monitor_get_model (GDK_MONITOR (monitor))))
*changed = TRUE;
gdk_monitor_set_position (GDK_MONITOR (monitor), newgeo.x, newgeo.y);
gdk_monitor_set_size (GDK_MONITOR (monitor), newgeo.width, newgeo.height);
g_object_notify (G_OBJECT (monitor), "workarea");
gdk_monitor_set_physical_size (GDK_MONITOR (monitor),
rr_monitors[i].mwidth,
rr_monitors[i].mheight);
gdk_monitor_set_subpixel_layout (GDK_MONITOR (monitor),
translate_subpixel_order (output_info->subpixel_order));
gdk_monitor_set_refresh_rate (GDK_MONITOR (monitor), refresh_rate);
gdk_monitor_set_scale_factor (GDK_MONITOR (monitor), x11_screen->surface_scale);
gdk_monitor_set_model (GDK_MONITOR (monitor), name);
g_free (name);
if (rr_monitors[i].primary)
primary_output = monitor->output;
XRRFreeOutputInfo (output_info);
}
XRRFreeMonitors (rr_monitors);
XRRFreeScreenResources (resources);
for (i = x11_display->monitors->len - 1; i >= 0; i--)
{
GdkX11Monitor *monitor = x11_display->monitors->pdata[i];
if (monitor->add)
{
gdk_display_monitor_added (display, GDK_MONITOR (monitor));
*changed = TRUE;
}
else if (monitor->remove)
{
g_object_ref (monitor);
g_ptr_array_remove (x11_display->monitors, monitor);
gdk_display_monitor_removed (display, GDK_MONITOR (monitor));
g_object_unref (monitor);
*changed = TRUE;
}
}
old_primary = x11_display->primary_monitor;
x11_display->primary_monitor = 0;
for (i = 0; i < x11_display->monitors->len; ++i)
{
GdkX11Monitor *monitor = x11_display->monitors->pdata[i];
if (monitor->output == primary_output)
{
x11_display->primary_monitor = i;
break;
}
/* No RandR1.3+ available or no primary set, fall back to prefer LVDS as primary if present */
if (primary_output == None &&
g_ascii_strncasecmp (gdk_monitor_get_model (GDK_MONITOR (monitor)), "LVDS", 4) == 0)
{
x11_display->primary_monitor = i;
break;
}
/* No primary specified and no LVDS found */
if (monitor->output == first_output)
x11_display->primary_monitor = i;
}
if (x11_display->primary_monitor != old_primary)
*changed = TRUE;
return x11_display->monitors->len > 0;
#endif
return FALSE;
}
static void
init_no_multihead (GdkScreen *screen, gboolean *changed)
{
GdkX11Screen *x11_screen = GDK_X11_SCREEN (screen);
GdkX11Display *x11_display = GDK_X11_DISPLAY (x11_screen->display);
GdkX11Monitor *monitor;
GdkRectangle geometry;
int i;
for (i = 0; i < x11_display->monitors->len; i++)
{
GdkX11Monitor *monitor = x11_display->monitors->pdata[i];
monitor->add = FALSE;
monitor->remove = TRUE;
}
monitor = find_monitor_by_output (x11_display, 0);
if (monitor)
monitor->remove = FALSE;
else
{
monitor = g_object_new (gdk_x11_monitor_get_type (),
"display", x11_display,
NULL);
monitor->output = 0;
monitor->add = TRUE;
g_ptr_array_add (x11_display->monitors, monitor);
}
gdk_monitor_get_geometry (GDK_MONITOR (monitor), &geometry);
if (0 != geometry.x ||
0 != geometry.y ||
gdk_screen_get_width (screen) != geometry.width ||
gdk_screen_get_height (screen) != geometry.height ||
gdk_screen_get_width_mm (screen) != gdk_monitor_get_width_mm (GDK_MONITOR (monitor)) ||
gdk_screen_get_height_mm (screen) != gdk_monitor_get_height_mm (GDK_MONITOR (monitor)))
*changed = TRUE;
gdk_monitor_set_position (GDK_MONITOR (monitor), 0, 0);
gdk_monitor_set_size (GDK_MONITOR (monitor),
gdk_screen_get_width (screen),
gdk_screen_get_height (screen));
g_object_notify (G_OBJECT (monitor), "workarea");
gdk_monitor_set_physical_size (GDK_MONITOR (monitor),
gdk_screen_get_height_mm (screen),
gdk_screen_get_height_mm (screen));
gdk_monitor_set_scale_factor (GDK_MONITOR (monitor), x11_screen->window_scale);
if (x11_display->primary_monitor != 0)
*changed = TRUE;
x11_display->primary_monitor = 0;
for (i = x11_display->monitors->len - 1; i >= 0; i--)
{
GdkX11Monitor *monitor = x11_display->monitors->pdata[i];
if (monitor->add)
{
gdk_display_monitor_added (GDK_DISPLAY (x11_display), GDK_MONITOR (monitor));
*changed = TRUE;
}
else if (monitor->remove)
{
g_object_ref (monitor);
g_ptr_array_remove (x11_display->monitors, monitor);
gdk_display_monitor_removed (GDK_DISPLAY (x11_display), GDK_MONITOR (monitor));
g_object_unref (monitor);
*changed = TRUE;
}
}
}
/**
* gimp_session_info_apply_geometry:
* @info:
* @monitor:
* @current_monitor:
*
* Apply the geometry stored in the session info object to the
* associated widget.
**/
void
gimp_session_info_apply_geometry (GimpSessionInfo *info,
GdkMonitor *current_monitor,
gboolean apply_stored_monitor)
{
GdkMonitor *monitor;
GdkRectangle rect;
GdkRectangle work_rect;
GdkGravity gravity;
GdkWindowHints hints;
gint width;
gint height;
g_return_if_fail (GIMP_IS_SESSION_INFO (info));
g_return_if_fail (GTK_IS_WINDOW (info->p->widget));
g_return_if_fail (GDK_IS_MONITOR (current_monitor));
monitor = current_monitor;
if (apply_stored_monitor)
{
GdkDisplay *display = gdk_monitor_get_display (current_monitor);
gint n_monitors;
n_monitors = gdk_display_get_n_monitors (display);
if (info->p->monitor != DEFAULT_MONITOR &&
monitor_number (info->p->monitor) < n_monitors)
{
monitor = info->p->monitor;
}
else
{
monitor = gdk_display_get_primary_monitor (display);
}
}
gdk_monitor_get_geometry (monitor, &rect);
gdk_monitor_get_workarea (monitor, &work_rect);
info->p->x += rect.x;
info->p->y += rect.y;
if (gimp_session_info_get_remember_size (info) &&
info->p->width > 0 &&
info->p->height > 0)
{
width = info->p->width;
height = info->p->height;
}
else
{
GtkRequisition requisition;
gtk_widget_get_preferred_size (info->p->widget, NULL, &requisition);
width = requisition.width;
height = requisition.height;
}
info->p->x = CLAMP (info->p->x,
work_rect.x,
work_rect.x + work_rect.width - width);
info->p->y = CLAMP (info->p->y,
work_rect.y,
work_rect.y + work_rect.height - height);
if (gimp_session_info_get_remember_size (info) &&
info->p->width > 0 &&
info->p->height > 0)
{
/* This used to call gtk_window_set_default_size() which worked
* fine in gtk2 and should continue to work, but doesn't for
* dock windows. gtk_window_resize() seems to work fine for all
* windows. Leave this comment here until we figured what's
* going on...
*
* XXX If we end up updating this code, also do the same to the
* gtk_window_resize() call in gimp_session_info_dialog_show()
* signal handler.
*/
#if 1
gtk_window_resize (GTK_WINDOW (info->p->widget),
info->p->width, info->p->height);
#else
gtk_window_set_default_size (GTK_WINDOW (info->p->widget),
info->p->width, info->p->height);
#endif
}
gtk_window_get_size (GTK_WINDOW (info->p->widget), &width, &height);
gravity = GDK_GRAVITY_NORTH_WEST;
if (info->p->right_align && info->p->bottom_align)
{
gravity = GDK_GRAVITY_SOUTH_EAST;
}
else if (info->p->right_align)
{
gravity = GDK_GRAVITY_NORTH_EAST;
}
else if (info->p->bottom_align)
{
gravity = GDK_GRAVITY_SOUTH_WEST;
}
if (gravity == GDK_GRAVITY_SOUTH_EAST ||
gravity == GDK_GRAVITY_NORTH_EAST)
info->p->x = work_rect.x + work_rect.width - width;
if (gravity == GDK_GRAVITY_SOUTH_WEST ||
gravity == GDK_GRAVITY_SOUTH_EAST)
info->p->y = work_rect.y + work_rect.height - height;
gtk_window_set_gravity (GTK_WINDOW (info->p->widget), gravity);
gtk_window_move (GTK_WINDOW (info->p->widget),
info->p->x, info->p->y);
hints = GDK_HINT_USER_POS;
if (gimp_session_info_get_remember_size (info))
hints |= GDK_HINT_USER_SIZE;
gtk_window_set_geometry_hints (GTK_WINDOW (info->p->widget),
NULL, NULL, hints);
/* Window managers and windowing systems suck. They have their own
* ideas about WM standards and when it's appropriate to honor
* user/application-set window positions and when not. Therefore,
* use brute force and "manually" position dialogs whenever they
* are shown. This is important especially for transient dialogs,
* because window managers behave even "smarter" then...
*/
if (GTK_IS_WINDOW (info->p->widget))
g_signal_connect (info->p->widget, "show",
G_CALLBACK (gimp_session_info_dialog_show),
info);
}
void
create_main_window (GsmApplication *app)
{
GtkApplicationWindow *main_window;
GtkStack *stack;
GtkMenuButton *process_menu_button;
GMenuModel *process_menu_model;
GdkDisplay *display;
GdkMonitor *monitor;
GdkRectangle monitor_geometry;
const char* session;
int width, height, xpos, ypos;
GtkBuilder *builder = gtk_builder_new();
gtk_builder_add_from_resource (builder, "/org/gnome/gnome-system-monitor/data/interface.ui", NULL);
gtk_builder_add_from_resource (builder, "/org/gnome/gnome-system-monitor/data/menus.ui", NULL);
main_window = GTK_APPLICATION_WINDOW (gtk_builder_get_object (builder, "main_window"));
gtk_window_set_application (GTK_WINDOW (main_window), app->gobj());
gtk_widget_set_name (GTK_WIDGET (main_window), "gnome-system-monitor");
app->main_window = main_window;
session = g_getenv ("XDG_CURRENT_DESKTOP");
if (session && !strstr (session, "GNOME")){
GtkBox *mainbox;
GtkHeaderBar *headerbar;
mainbox = GTK_BOX (gtk_builder_get_object (builder, "main_box"));
headerbar = GTK_HEADER_BAR (gtk_builder_get_object (builder, "header_bar"));
gtk_style_context_remove_class (gtk_widget_get_style_context (GTK_WIDGET (headerbar)), "titlebar");
gtk_window_set_titlebar (GTK_WINDOW (main_window), NULL);
gtk_header_bar_set_show_close_button (headerbar, FALSE);
gtk_box_pack_start (mainbox, GTK_WIDGET (headerbar), FALSE, FALSE, 0);
}
g_settings_get (app->settings->gobj(), GSM_SETTING_WINDOW_STATE, "(iiii)",
&width, &height, &xpos, &ypos);
display = gdk_display_get_default ();
monitor = gdk_display_get_monitor_at_point (display, xpos, ypos);
if (monitor == NULL) {
monitor = gdk_display_get_monitor (display, 0);
}
gdk_monitor_get_geometry (monitor, &monitor_geometry);
width = CLAMP (width, 50, monitor_geometry.width);
height = CLAMP (height, 50, monitor_geometry.height);
xpos = CLAMP (xpos, 0, monitor_geometry.width - width);
ypos = CLAMP (ypos, 0, monitor_geometry.height - height);
gtk_window_set_default_size (GTK_WINDOW (main_window), width, height);
gtk_window_move (GTK_WINDOW (main_window), xpos, ypos);
if (app->settings->get_boolean (GSM_SETTING_MAXIMIZED))
gtk_window_maximize (GTK_WINDOW (main_window));
app->process_menu_button = process_menu_button = GTK_MENU_BUTTON (gtk_builder_get_object (builder, "process_menu_button"));
process_menu_model = G_MENU_MODEL (gtk_builder_get_object (builder, "process-window-menu"));
gtk_menu_button_set_menu_model (process_menu_button, process_menu_model);
app->end_process_button = GTK_BUTTON (gtk_builder_get_object (builder, "end_process_button"));
app->search_button = GTK_BUTTON (gtk_builder_get_object (builder, "search_button"));
GActionEntry win_action_entries[] = {
{ "about", on_activate_about, NULL, NULL, NULL },
{ "search", on_activate_search, "b", "false", NULL },
{ "send-signal-stop", on_activate_send_signal, "i", NULL, NULL },
{ "send-signal-cont", on_activate_send_signal, "i", NULL, NULL },
{ "send-signal-end", on_activate_send_signal, "i", NULL, NULL },
{ "send-signal-kill", on_activate_send_signal, "i", NULL, NULL },
{ "priority", on_activate_priority, "i", "@i 0", change_priority_state },
{ "memory-maps", on_activate_memory_maps, NULL, NULL, NULL },
{ "open-files", on_activate_open_files, NULL, NULL, NULL },
{ "process-properties", on_activate_process_properties, NULL, NULL, NULL },
{ "refresh", on_activate_refresh, NULL, NULL, NULL },
{ "show-page", on_activate_radio, "s", "'resources'", change_show_page_state },
{ "show-whose-processes", on_activate_radio, "s", "'all'", change_show_processes_state },
{ "show-dependencies", on_activate_toggle, NULL, "false", change_show_dependencies_state }
};
g_action_map_add_action_entries (G_ACTION_MAP (main_window),
win_action_entries,
G_N_ELEMENTS (win_action_entries),
app);
GdkScreen* screen = gtk_widget_get_screen(GTK_WIDGET (main_window));
GdkVisual* visual = gdk_screen_get_rgba_visual(screen);
/* use visual, if available */
if (visual)
gtk_widget_set_visual(GTK_WIDGET (main_window), visual);
/* create the main stack */
app->stack = stack = GTK_STACK (gtk_builder_get_object (builder, "stack"));
create_proc_view(app, builder);
create_sys_view (app, builder);
create_disk_view (app, builder);
g_settings_bind (app->settings->gobj (), GSM_SETTING_CURRENT_TAB, stack, "visible-child-name", G_SETTINGS_BIND_DEFAULT);
g_signal_connect (G_OBJECT (stack), "notify::visible-child",
G_CALLBACK (cb_change_current_page), app);
g_signal_connect (G_OBJECT (main_window), "delete_event",
G_CALLBACK (cb_main_window_delete),
app);
g_signal_connect (G_OBJECT (main_window), "window-state-event",
G_CALLBACK (cb_main_window_state_changed),
app);
GAction *action;
action = g_action_map_lookup_action (G_ACTION_MAP (main_window),
"show-dependencies");
g_action_change_state (action,
g_settings_get_value (app->settings->gobj (), GSM_SETTING_SHOW_DEPENDENCIES));
action = g_action_map_lookup_action (G_ACTION_MAP (main_window),
"show-whose-processes");
g_action_change_state (action,
g_settings_get_value (app->settings->gobj (), GSM_SETTING_SHOW_WHOSE_PROCESSES));
gtk_widget_show (GTK_WIDGET (main_window));
update_page_activities (app);
g_object_unref (G_OBJECT (builder));
}
char *iupdrvGetGlobal(const char *name)
{
if (iupStrEqual(name, "VIRTUALSCREEN"))
{
GdkScreen *screen = gdk_screen_get_default();
GdkWindow *root = gdk_screen_get_root_window(gdk_screen_get_default());
int x = 0;
int y = 0;
int w = gdk_screen_get_width(screen);
int h = gdk_screen_get_height(screen);
gdk_window_get_root_origin(root, &x, &y);
return iupStrReturnStrf("%d %d %d %d", x, y, w, h);
}
if (iupStrEqual(name, "MONITORSINFO"))
{
int i;
#if GTK_CHECK_VERSION(3, 22, 0)
GdkDisplay *display = gdk_display_get_default();
int monitors_count = gdk_display_get_n_monitors(display);
#else
GdkScreen *screen = gdk_screen_get_default();
int monitors_count = gdk_screen_get_n_monitors(screen);
#endif
char *str = iupStrGetMemory(monitors_count * 50);
char* pstr = str;
GdkRectangle rect;
for (i = 0; i < monitors_count; i++)
{
#if GTK_CHECK_VERSION(3, 22, 0)
GdkMonitor* monitor = gdk_display_get_monitor(display, i);
gdk_monitor_get_geometry(monitor, &rect);
#else
gdk_screen_get_monitor_geometry(screen, i, &rect);
#endif
pstr += sprintf(pstr, "%d %d %d %d\n", rect.x, rect.y, rect.width, rect.height);
}
return str;
}
if (iupStrEqual(name, "MONITORSCOUNT"))
{
#if GTK_CHECK_VERSION(3, 22, 0)
GdkDisplay *display = gdk_display_get_default();
int monitors_count = gdk_display_get_n_monitors(display);
#else
GdkScreen *screen = gdk_screen_get_default();
int monitors_count = gdk_screen_get_n_monitors(screen);
#endif
return iupStrReturnInt(monitors_count);
}
if (iupStrEqual(name, "TRUECOLORCANVAS"))
{
return iupStrReturnBoolean(gdk_visual_get_best_depth() > 8);
}
if (iupStrEqual(name, "UTF8MODE"))
{
return iupStrReturnBoolean(iupgtkStrGetUTF8Mode());
}
if (iupStrEqual(name, "UTF8AUTOCONVERT"))
{
return iupStrReturnBoolean(!iupgtkStrGetUTF8Mode());
}
#ifndef WIN32
if (iupStrEqual(name, "EXEFILENAME"))
{
char* argv0 = IupGetGlobal("ARGV0");
if (argv0)
{
char* exefilename = realpath(argv0, NULL);
if (exefilename)
{
char* str = iupStrReturnStr(exefilename);
free(exefilename);
return str;
}
}
}
#endif
if (iupStrEqual(name, "SHOWMENUIMAGES"))
{
gboolean menu_images;
g_object_get (gtk_settings_get_default (), "gtk-menu-images", &menu_images, NULL);
return iupStrReturnBoolean(menu_images);
}
return NULL;
}
