static void
gs_manager_create_windows_for_display (GSManager *manager,
GdkDisplay *display)
{
int n_monitors;
int i;
g_return_if_fail (manager != NULL);
g_return_if_fail (GS_IS_MANAGER (manager));
g_return_if_fail (GDK_IS_DISPLAY (display));
g_object_ref (manager);
g_object_ref (display);
n_monitors = gdk_display_get_n_monitors (display);
gs_debug ("Creating %d windows for display %s",
n_monitors, gdk_display_get_name (display));
for (i = 0; i < n_monitors; i++)
{
GdkMonitor *mon = gdk_display_get_monitor (display, i);
gs_manager_create_window_for_monitor (manager, mon);
}
g_object_unref (display);
g_object_unref (manager);
}
static void
on_display_monitor_added (GdkDisplay *display,
GdkMonitor *monitor,
GSManager *manager)
{
GSList *l;
int n_monitors;
n_monitors = gdk_display_get_n_monitors (display);
gs_debug ("Monitor added on display %s, now there are %d",
gdk_display_get_name (display), n_monitors);
/* Tear down the unlock dialog in case we want to move it
* to the new monitor
*/
l = manager->priv->windows;
while (l != NULL)
{
gs_window_cancel_unlock_request (GS_WINDOW (l->data));
l = l->next;
}
/* add a new window */
gs_manager_create_window_for_monitor (manager, monitor);
/* and put unlock dialog up whereever it's supposed to be */
gs_manager_request_unlock (manager);
}
/**
* gdk_screen_get_n_monitors:
* @screen: a #GdkScreen
*
* Returns the number of monitors which @screen consists of.
*
* Returns: number of monitors which @screen consists of
*
* Since: 2.2
*/
gint
gdk_screen_get_n_monitors (GdkScreen *screen)
{
GdkDisplay *display;
g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
display = gdk_screen_get_display (screen);
return gdk_display_get_n_monitors (display);
}
static gint
monitor_number (GdkMonitor *monitor)
{
GdkDisplay *display = gdk_monitor_get_display (monitor);
gint n_monitors = gdk_display_get_n_monitors (display);
gint i;
for (i = 0; i < n_monitors; i++)
if (gdk_display_get_monitor (display, i) == monitor)
return i;
return 0;
}
static int
get_monitor_num (GdkMonitor *monitor)
{
GdkDisplay *display;
int n_monitors, i;
display = gdk_monitor_get_display (monitor);
n_monitors = gdk_display_get_n_monitors (display);
for (i = 0; i < n_monitors; i++)
{
if (gdk_display_get_monitor (display, i) == monitor)
return i;
}
return -1;
}
static void
on_display_monitor_removed (GdkDisplay *display,
GdkMonitor *monitor,
GSManager *manager)
{
GSList *l;
int n_monitors;
n_monitors = gdk_display_get_n_monitors (display);
gs_debug ("Monitor removed on display %s, now there are %d",
gdk_display_get_name (display), n_monitors);
gdk_x11_grab_server ();
/* remove the now extra window */
l = manager->priv->windows;
while (l != NULL)
{
GdkDisplay *this_display;
GdkMonitor *this_monitor;
GSList *next = l->next;
this_display = gs_window_get_display (GS_WINDOW (l->data));
this_monitor = gs_window_get_monitor (GS_WINDOW (l->data));
if (this_display == display && this_monitor == monitor)
{
manager_maybe_stop_job_for_window (manager,
GS_WINDOW (l->data));
g_hash_table_remove (manager->priv->jobs, l->data);
gs_window_destroy (GS_WINDOW (l->data));
manager->priv->windows = g_slist_delete_link (manager->priv->windows, l);
}
l = next;
}
gdk_display_flush (display);
gdk_x11_ungrab_server ();
}
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;
}
/**
* 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);
}
