AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
f5e0470f6f
gtk2/gdk/x11/gdkscreen-x11.c
Owen Taylor 425b9886c9 Start of integration of Erwann Chenede's multihead work from the 
Thu Apr 25 16:51:40 2002  Owen Taylor  <otaylor@redhat.com>

        Start of integration of Erwann Chenede's multihead work
        from the gtk-multihead branch.

        * gdk/gdkdisplay.[ch] gdk/gdkscreen.[ch]
        gdk/x11/gdkdisplay-x11.[ch] gdk/x11/gdkscreen-x11.[ch]
        New classes representing a set of screens with attached
        input devices and a single contiguous area, respectively.

        * gdk/gdk.[ch] gdk/gdkinternals.h gdk/x11/gdkmain-x11.c:
        gdk/x11/gdkprivate-x11.h: Make the initialization interface
        simple _gdk_windowing_init() and do the rest in
        gdk_open_display() calls.

        * gdk/gdk.[ch]: Add gdk_parse_args() which can be used
        to do the display-independent part of initialization
        instead of gdk_init_[check].

        * gdk/gdkcursor.h gdk/gdkfont.h gdk/gdkkeys.h gdk/gdkpixmap.h
        gdk/gdkproperty.h gdk/gdkselection.h gdk/gdkwindow.h:
        Add multihead variants (_for_display(), for_screen()) of functions
        getting information specific to a particular screen screen or
        display.

        * gdk/gdkscreen.[ch]: Add gdk_screen__* variants of functions
        like gdk_rgb_get_colormap() that used to get/list global
        objects.

        * gdk/x11/gdkx.h: Add functions for converting GdkScreen
        and GdkDisplay into the X equivalents.

        * gdk/x11/gdkwindow-x11.c: Removed gdk_window_xid_at_coords()
        not in the headers and unused.

        * configure.in gdk/x11/{gxid.c,gxid_lib.[ch],gdkinput-gxi.c}:
        Remove gxid support ... has not been tested for a long time...
        "xfree" support is more portable to non XFree86.

        * gdk/**.h: Add a GDK_MULTIHEAD_SAFE define that can be
        used to turn off functions that are inherently non-multihead
        safe.

        * gdk/**.c: add GDK_NOTE(multihead, ...) calls when functions
        are used in non-multihead-safe ways.

        * gdk/*.c gdk/x11/*.c: Changes to make the internals of GDK
        multihead safe.
2002-04-25 22:29:14 +00:00

351 lines
10 KiB
C
Raw Blame History

/*
* gdkscreen-x11.c
*
* Copyright 2001 Sun Microsystems Inc.
*
* Erwann Chenede <erwann.chenede@sun.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include <glib.h>
#include "gdkscreen.h"
#include "gdkscreen-x11.h"
#include "gdkdisplay.h"
#include "gdkdisplay-x11.h"
#include "gdkx.h"
static void gdk_screen_x11_class_init (GdkScreenX11Class *klass);
static GdkDisplay * gdk_screen_x11_get_display (GdkScreen *screen);
static gint gdk_screen_x11_get_width (GdkScreen *screen);
static gint gdk_screen_x11_get_height (GdkScreen *screen);
static gint gdk_screen_x11_get_width_mm (GdkScreen *screen);
static gint gdk_screen_x11_get_height_mm (GdkScreen *screen);
static gint gdk_screen_x11_get_default_depth (GdkScreen *screen);
static GdkWindow * gdk_screen_x11_get_root_window (GdkScreen *screen);
static gint gdk_screen_x11_get_screen_num (GdkScreen *screen);
static GdkColormap *gdk_screen_x11_get_default_colormap (GdkScreen *screen);
static void gdk_screen_x11_set_default_colormap (GdkScreen *screen,
GdkColormap *colormap);
static GdkWindow * gdk_screen_x11_get_window_at_pointer (GdkScreen *screen,
gint *win_x,
gint *win_y);
static void gdk_screen_x11_finalize (GObject *object);
static gboolean gdk_screen_x11_use_virtual_screen (GdkScreen *screen);
static gint gdk_screen_x11_get_n_monitors (GdkScreen *screen);
static GdkRectangle *gdk_screen_x11_get_monitor_geometry (GdkScreen *screen,
gint num_monitor);
static gint gdk_screen_x11_get_monitor_at_point (GdkScreen *screen,
gint x,
gint y);
static gint gdk_screen_x11_get_monitor_at_window (GdkScreen *screen,
GdkNativeWindow anid);
GType gdk_screen_x11_get_type ();
static gpointer parent_class = NULL;
GType
gdk_screen_x11_get_type ()
{
static GType object_type = 0;
if (!object_type)
{
static const GTypeInfo object_info =
{
sizeof (GdkScreenX11Class),
(GBaseInitFunc) NULL,
(GBaseFinalizeFunc) gdk_screen_x11_finalize,
(GClassInitFunc) gdk_screen_x11_class_init,
NULL, /* class_finalize */
NULL, /* class_data */
sizeof (GdkScreenX11),
0, /* n_preallocs */
(GInstanceInitFunc) NULL,
};
object_type = g_type_register_static (GDK_TYPE_SCREEN,
"GdkScreenX11",
&object_info, 0);
}
return object_type;
}
void
gdk_screen_x11_class_init (GdkScreenX11Class * klass)
{
GdkScreenClass *screen_class = GDK_SCREEN_CLASS (klass);
screen_class->get_display = gdk_screen_x11_get_display;
screen_class->get_width = gdk_screen_x11_get_width;
screen_class->get_height = gdk_screen_x11_get_height;
screen_class->get_width_mm = gdk_screen_x11_get_width_mm;
screen_class->get_height_mm = gdk_screen_x11_get_height_mm;
screen_class->get_root_depth = gdk_screen_x11_get_default_depth;
screen_class->get_screen_num = gdk_screen_x11_get_screen_num;
screen_class->get_root_window = gdk_screen_x11_get_root_window;
screen_class->get_default_colormap = gdk_screen_x11_get_default_colormap;
screen_class->set_default_colormap = gdk_screen_x11_set_default_colormap;
screen_class->get_window_at_pointer = gdk_screen_x11_get_window_at_pointer;
screen_class->use_virtual_screen = gdk_screen_x11_use_virtual_screen;
screen_class->get_n_monitors = gdk_screen_x11_get_n_monitors;
screen_class->get_monitor_geometry = gdk_screen_x11_get_monitor_geometry;
screen_class->get_monitor_at_point = gdk_screen_x11_get_monitor_at_point;
screen_class->get_monitor_at_window = gdk_screen_x11_get_monitor_at_window;
G_OBJECT_CLASS (klass)->finalize = gdk_screen_x11_finalize;
parent_class = g_type_class_peek_parent (klass);
}
static GdkDisplay *
gdk_screen_x11_get_display (GdkScreen *screen)
{
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
return screen_x11->display;
}
static gint
gdk_screen_x11_get_width (GdkScreen *screen)
{
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
return WidthOfScreen (screen_x11->xscreen);
}
static gint
gdk_screen_x11_get_height (GdkScreen *screen)
{
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
return HeightOfScreen (screen_x11->xscreen);
}
static gint
gdk_screen_x11_get_width_mm (GdkScreen *screen)
{
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
return WidthMMOfScreen (screen_x11->xscreen);
}
static gint
gdk_screen_x11_get_height_mm (GdkScreen *screen)
{
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
return HeightMMOfScreen (screen_x11->xscreen);
}
static gint
gdk_screen_x11_get_default_depth (GdkScreen *screen)
{
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
return DefaultDepthOfScreen (screen_x11->xscreen);
}
static gint
gdk_screen_x11_get_screen_num (GdkScreen *screen)
{
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
return screen_x11->screen_num;
}
static GdkWindow *
gdk_screen_x11_get_root_window (GdkScreen *screen)
{
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
gdk_drawable_ref (screen_x11->root_window);
return screen_x11->root_window;
}
static GdkColormap *
gdk_screen_x11_get_default_colormap (GdkScreen *screen)
{
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
return screen_x11->default_colormap;
}
static void
gdk_screen_x11_set_default_colormap (GdkScreen *screen,
GdkColormap * colormap)
{
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
screen_x11->default_colormap = colormap;
}
static GdkWindow *
gdk_screen_x11_get_window_at_pointer (GdkScreen *screen,
gint *win_x,
gint *win_y)
{
GdkWindow *window;
Window root;
Window xwindow;
Window xwindow_last = 0;
Display *xdisplay;
int rootx = -1, rooty = -1;
int winx, winy;
unsigned int xmask;
xwindow = GDK_SCREEN_XROOTWIN (screen);
xdisplay = GDK_SCREEN_XDISPLAY (screen);
XGrabServer (xdisplay);
while (xwindow)
{
xwindow_last = xwindow;
XQueryPointer (xdisplay, xwindow,
&root, &xwindow, &rootx, &rooty, &winx, &winy, &xmask);
}
XUngrabServer (xdisplay);
window = gdk_window_lookup_for_display (GDK_SCREEN_DISPLAY(screen),
xwindow_last);
if (win_x)
*win_x = window ? winx : -1;
if (win_y)
*win_y = window ? winy : -1;
return window;
}
static void
gdk_screen_x11_finalize (GObject *object)
{
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (object);
/* int i; */
g_object_unref (G_OBJECT (screen_x11->root_window));
/* Visual Part (Need to implement finalize for Visuals for a clean
* finalize) */
/* for (i=0;i<screen_x11->nvisuals;i++)
g_object_unref (G_OBJECT (screen_x11->visuals[i]));*/
g_free (screen_x11->visuals);
g_hash_table_destroy (screen_x11->visual_hash);
/* X settings */
g_free (screen_x11->xsettings_client);
G_OBJECT_CLASS (parent_class)->finalize (object);
}
static gboolean
gdk_screen_x11_use_virtual_screen (GdkScreen *screen)
{
g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
return GDK_SCREEN_X11 (screen)->use_virtual_screen;
}
static gint
gdk_screen_x11_get_n_monitors (GdkScreen *screen)
{
g_return_val_if_fail (GDK_IS_SCREEN (screen), 1);
return GDK_SCREEN_X11 (screen)->num_monitors;
}
static GdkRectangle *
gdk_screen_x11_get_monitor_geometry (GdkScreen *screen,
gint num_monitor)
{
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
g_return_val_if_fail (num_monitor < GDK_SCREEN_X11 (screen)->num_monitors, NULL);
return &GDK_SCREEN_X11 (screen)->monitors[num_monitor];
}
static gint
gdk_screen_x11_get_monitor_at_point (GdkScreen *screen,
gint x,
gint y)
{
GdkScreenX11 *screen_x11 = GDK_SCREEN_X11 (screen);
int i;
GdkRectangle *monitor;
g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
for (i = 0, monitor = screen_x11->monitors;
i < screen_x11->num_monitors;
i++, monitor++)
{
if (x >= monitor->x &&
x < monitor->x + monitor->width &&
y >= monitor->y &&
y < (monitor->y + monitor->height))
return i;
}
return -1;
}
static gint
gdk_screen_x11_get_monitor_at_window (GdkScreen *screen,
GdkNativeWindow anid)
{
gint x, y, width, height, depth;
gint left_monitor, right_monitor, diff_monitor;
GdkRectangle *left_monitor_rect, *right_monitor_rect;
GdkWindow *window = gdk_window_lookup_for_display (GDK_SCREEN_DISPLAY (screen), anid);
gdk_window_get_geometry (window, &x, &y, &width, &height, &depth);
gdk_window_get_position (window, &x, &y);
left_monitor = gdk_screen_x11_get_monitor_at_point (screen, x, y);
right_monitor = gdk_screen_x11_get_monitor_at_point (screen, x + width,
y + height);
left_monitor_rect = gdk_screen_x11_get_monitor_geometry (screen,
left_monitor);
right_monitor_rect = gdk_screen_x11_get_monitor_geometry (screen,
right_monitor);
diff_monitor = right_monitor - left_monitor;
if (diff_monitor == 0)
{
return left_monitor;
}
if (diff_monitor == 1)
{
int dist_left, dist_right;
dist_left = left_monitor_rect->x + left_monitor_rect->width - x;
dist_right = x + width - right_monitor_rect->x;
if (dist_left >= dist_right)
return left_monitor;
return right_monitor;
}
/* Window window span on at least 3 monitors */
return left_monitor + 1;
}
Screen *
gdk_x11_screen_get_xscreen (GdkScreen *screen)
{
return GDK_SCREEN_X11 (screen)->xscreen;
}
int
gdk_x11_screen_get_screen_number (GdkScreen *screen)
{
return GDK_SCREEN_X11 (screen)->screen_num;
}
Reference in New Issue View Git Blame Copy Permalink