[gnome-panel/wip/geiger/geometry: 4/6] panel-multiscreen: remove obsolete code



commit ecf5b4ce4b49298e2a735f53734b7c3f10d3fb0c
Author: Sebastian Geiger <sbastig gmx net>
Date:   Fri Feb 16 23:37:24 2018 +0100

    panel-multiscreen: remove obsolete code

 gnome-panel/panel-multiscreen.c |  633 +++------------------------------------
 gnome-panel/panel-multiscreen.h |   27 +--
 gnome-panel/panel-toplevel.c    |  119 ++++----
 3 files changed, 107 insertions(+), 672 deletions(-)
---
diff --git a/gnome-panel/panel-multiscreen.c b/gnome-panel/panel-multiscreen.c
index ca6fd68..b365187 100644
--- a/gnome-panel/panel-multiscreen.c
+++ b/gnome-panel/panel-multiscreen.c
@@ -23,354 +23,13 @@
  *          Mark McLoughlin <mark skynet ie>
  */
 
-#include <config.h>
-
-#include <X11/Xatom.h>
-#include <X11/Xlib.h>
-#include <X11/extensions/Xrandr.h>
-#include <gdk/gdkx.h>
-
+#include "config.h"
 #include "panel-multiscreen.h"
+#include "panel-monitor.h"
 
-#include <string.h>
-
-static int            screens     = 0;
-static int           *monitors    = NULL;
-static GdkRectangle **geometries  = NULL;
-static gboolean       initialized = FALSE;
-static gboolean       have_randr  = FALSE;
-static gboolean       have_randr_1_3 = FALSE;
-static guint          reinit_id   = 0;
-
-static gboolean
-_panel_multiscreen_output_should_be_first (Display       *xdisplay,
-                                          RROutput       output,
-                                          XRROutputInfo *info,
-                                          RROutput       primary)
-{
-       if (primary)
-               return output == primary;
-
-       if (have_randr_1_3) {
-               Atom           connector_type_atom;
-               Atom           actual_type;
-               int            actual_format;
-               unsigned long  nitems;
-               unsigned long  bytes_after;
-               unsigned char *prop;
-               char          *connector_type;
-               gboolean       retval;
-
-               connector_type_atom = XInternAtom (xdisplay, "ConnectorType", False);
-
-               if (XRRGetOutputProperty (xdisplay, output, connector_type_atom,
-                                         0, 100, False, False, None,
-                                         &actual_type, &actual_format,
-                                         &nitems, &bytes_after, &prop) == Success) {
-                       if (actual_type == XA_ATOM && nitems == 1 && actual_format == 32) {
-                               connector_type = XGetAtomName (xdisplay, prop[0]);
-                               retval = g_strcmp0 (connector_type, "Panel") == 0;
-                               XFree (connector_type);
-                               return retval;
-                       }
-               }
-       }
-
-       /* Pre-1.3 fallback:
-        * "LVDS" is the oh-so-intuitive name that X gives to laptop LCDs.
-        * It can actually be LVDS0, LVDS-0, Lvds, etc.
-        */
-       return (g_ascii_strncasecmp (info->name, "LVDS", strlen ("LVDS")) == 0);
-}
-
-static gboolean
-panel_multiscreen_get_randr_monitors_for_screen (GdkScreen     *screen,
-                                                int           *monitors_ret,
-                                                GdkRectangle **geometries_ret)
-{
-       Display            *xdisplay;
-       Window              xroot;
-       XRRScreenResources *resources;
-       RROutput            primary;
-       GArray             *geometries;
-       int                 i;
-       gboolean            driver_is_pre_randr_1_2;
-
-       if (!have_randr)
-               return FALSE;
-
-       /* GTK+ 2.14.x uses the Xinerama API, instead of RANDR, to get the
-        * monitor geometries. It does this to avoid calling
-        * XRRGetScreenResources(), which is slow as it re-detects all the
-        * monitors --- note that XRRGetScreenResourcesCurrent() had not been
-        * introduced yet.  Using Xinerama in GTK+ has the bad side effect that
-        * gdk_screen_get_monitor_plug_name() will return NULL, as Xinerama
-        * does not provide that information, unlike RANDR.
-        *
-        * Here we need to identify the output names, so that we can put the
-        * built-in LCD in a laptop *before* all other outputs.  This is so
-        * that gnome-panel will normally prefer to appear on the "native"
-        * display rather than on an external monitor.
-        *
-        * To get the output names and geometries, we will not use
-        * gdk_screen_get_n_monitors() and friends, but rather we will call
-        * XRR*() directly.
-        *
-        * See https://bugzilla.novell.com/show_bug.cgi?id=479684 for this
-        * particular bug, and and
-        * http://bugzilla.gnome.org/show_bug.cgi?id=562944 for a more
-        * long-term solution.
-        */
-
-       xdisplay = GDK_SCREEN_XDISPLAY (screen);
-       xroot = GDK_WINDOW_XID (gdk_screen_get_root_window (screen));
-
-       if (have_randr_1_3) {
-               resources = XRRGetScreenResourcesCurrent (xdisplay, xroot);
-               if (resources->noutput == 0) {
-                       /* This might happen if nothing tried to get randr
-                        * resources from the server before, so we need an
-                        * active probe. See comment #27 in
-                        * https://bugzilla.gnome.org/show_bug.cgi?id=597101 */
-                       XRRFreeScreenResources (resources);
-                       resources = XRRGetScreenResources (xdisplay, xroot);
-               }
-       } else
-               resources = XRRGetScreenResources (xdisplay, xroot);
-
-       if (!resources)
-               return FALSE;
-
-       primary = None;
-       if (have_randr_1_3)
-               primary = XRRGetOutputPrimary (xdisplay, xroot);
-
-       geometries = g_array_sized_new (FALSE, FALSE,
-                                       sizeof (GdkRectangle),
-                                       resources->noutput);
-
-       driver_is_pre_randr_1_2 = FALSE;
-
-       for (i = 0; i < resources->noutput; i++) {
-               XRROutputInfo *output;
-
-               output = XRRGetOutputInfo (xdisplay, resources,
-                                          resources->outputs[i]);
-
-               /* Drivers before RANDR 1.2 return "default" for the output
-                * name */
-               if (g_strcmp0 (output->name, "default") == 0)
-                       driver_is_pre_randr_1_2 = TRUE;
-
-               if (output->connection != RR_Disconnected &&
-                   output->crtc != 0) {
-                       XRRCrtcInfo  *crtc;
-                       GdkRectangle  rect;
-
-                       crtc = XRRGetCrtcInfo (xdisplay, resources,
-                                              output->crtc);
-
-                       rect.x      = crtc->x;
-                       rect.y      = crtc->y;
-                       rect.width  = crtc->width;
-                       rect.height = crtc->height;
-
-                       XRRFreeCrtcInfo (crtc);
-
-                       if (_panel_multiscreen_output_should_be_first (xdisplay,
-                                                                      resources->outputs[i],
-                                                                      output, primary))
-                               g_array_prepend_vals (geometries, &rect, 1);
-                       else
-                               g_array_append_vals (geometries, &rect, 1);
-               }
-
-               XRRFreeOutputInfo (output);
-       }
-
-       XRRFreeScreenResources (resources);
-
-       if (driver_is_pre_randr_1_2) {
-               /* Drivers before RANDR 1.2 don't provide useful info about
-                * outputs */
-               g_array_free (geometries, TRUE);
-               return FALSE;
-       }
-
-       if (geometries->len == 0) {
-               /* This can happen in at least one case:
-                * https://bugzilla.novell.com/show_bug.cgi?id=543876 where all
-                * monitors appear disconnected (possibly because the  screen
-                * is behing a KVM switch) -- see comment #8.
-                * There might be other cases too, so we stay on the safe side.
-                */
-               g_array_free (geometries, TRUE);
-               return FALSE;
-       }
-
-       *monitors_ret = geometries->len;
-       *geometries_ret = (GdkRectangle *) g_array_free (geometries, FALSE);
+static guint         reinit_id   = 0;
 
-       return TRUE;
-}
-
-static void
-panel_multiscreen_get_gdk_monitors_for_screen (GdkScreen     *screen,
-                                              int           *monitors_ret,
-                                              GdkRectangle **geometries_ret)
-{
-       int           num_monitors;
-       GdkRectangle *geometries;
-       int           i;
-
-       num_monitors = gdk_screen_get_n_monitors (screen);
-       geometries = g_new (GdkRectangle, num_monitors);
-
-       for (i = 0; i < num_monitors; i++)
-               gdk_screen_get_monitor_geometry (screen, i, &(geometries[i]));
-
-       *monitors_ret = num_monitors;
-       *geometries_ret = geometries;
-}
-
-static void
-panel_multiscreen_get_raw_monitors_for_screen (GdkScreen     *screen,
-                                              int           *monitors_ret,
-                                              GdkRectangle **geometries_ret)
-{
-       gboolean res;
-
-       *monitors_ret = 0;
-       *geometries_ret = NULL;
-
-       res = panel_multiscreen_get_randr_monitors_for_screen (screen,
-                                                              monitors_ret,
-                                                              geometries_ret);
-       if (res && *monitors_ret > 0)
-               return;
-
-       panel_multiscreen_get_gdk_monitors_for_screen (screen,
-                                                      monitors_ret,
-                                                      geometries_ret);
-}
-
-static inline gboolean
-rectangle_overlaps (GdkRectangle *a,
-                   GdkRectangle *b)
-{
-       return gdk_rectangle_intersect (a, b, NULL);
-}
-
-static long
-pixels_in_rectangle (GdkRectangle *r)
-{
-       return (long) (r->width * r->height);
-}
-
-static void
-panel_multiscreen_compress_overlapping_monitors (int           *num_monitors_inout,
-                                                GdkRectangle **geometries_inout)
-{
-       int           num_monitors;
-       GdkRectangle *geometries;
-       int           i;
-
-       num_monitors = *num_monitors_inout;
-       geometries = *geometries_inout;
-
-       /* http://bugzilla.gnome.org/show_bug.cgi?id=530969
-        * https://bugzilla.novell.com/show_bug.cgi?id=310208
-        * and many other such bugs...
-        *
-        * RANDR sometimes gives us monitors that overlap (i.e. outputs whose
-        * bounding rectangles overlap). This is sometimes right and sometimes
-        * wrong:
-        *
-        *   * Right - two 1024x768 outputs at the same offset (0, 0) that show
-        *     the same thing.  Think "laptop plus projector with the same
-        *     resolution".
-        *
-        *   * Wrong - one 1280x1024 output ("laptop internal LCD") and another
-        *     1024x768 output ("external monitor"), both at offset (0, 0).
-        *     There is no way for the monitor with the small resolution to
-        *     show the complete image from the laptop's LCD, unless one uses
-        *     panning (but nobody wants panning, right!?).
-        *
-        * With overlapping monitors, we may end up placing the panel with
-        * respect to the "wrong" one.  This is always wrong, as the panel
-        * appears "in the middle of the screen" of the monitor with the
-        * smaller resolution, instead of at the edge.
-        *
-        * Our strategy is to find the subsets of overlapping monitors, and
-        * "compress" each such set to being like if there were a single
-        * monitor with the biggest resolution of each of that set's monitors.
-        * Say we have four monitors
-        *
-        *      A, B, C, D
-        *
-        * where B and D overlap.  In that case, we'll generate a new list that
-        * looks like
-        *
-        *      A, MAX(B, D), C
-        *
-        * with three monitors.
-        *
-        * NOTE FOR THE FUTURE: We could avoid most of this mess if we had a
-        * concept of a "primary monitor". Also, we could look at each
-        * output's name or properties to see if it is the built-in LCD in a
-        * laptop. However, with GTK+ 2.14.x we don't get output names, since
-        * it gets the list outputs from Xinerama, not RANDR (and Xinerama
-        * doesn't provide output names).
-        */
-
-       for (i = 0; i < num_monitors; i++) {
-               long max_pixels;
-               int  j;
-
-               max_pixels = pixels_in_rectangle (&geometries[i]);
-
-               j = i + 1;
-
-               while (j < num_monitors) {
-                       if (rectangle_overlaps (&geometries[i],
-                                               &geometries[j])) {
-                               long pixels;
-
-                               pixels = pixels_in_rectangle (&geometries[j]);
-                               if (pixels > max_pixels) {
-                                       max_pixels = pixels;
-                                       /* keep the maximum */
-                                       geometries[i] = geometries[j];
-                               }
-
-                               /* Shift the remaining monitors to the left */
-                               if (num_monitors - j - 1 > 0)
-                                       memmove (&geometries[j],
-                                                &geometries[j + 1],
-                                                sizeof (geometries[0]) * (num_monitors - j - 1));
-
-                               num_monitors--;
-                               g_assert (num_monitors > 0);
-                       } else
-                               j++;
-               }
-       }
-
-       *num_monitors_inout = num_monitors;
-       *geometries_inout = geometries;
-}
-
-static void
-panel_multiscreen_get_monitors_for_screen (GdkScreen     *screen,
-                                          int           *monitors_ret,
-                                          GdkRectangle **geometries_ret)
-{
-       panel_multiscreen_get_raw_monitors_for_screen (screen,
-                                                      monitors_ret,
-                                                      geometries_ret);
-       panel_multiscreen_compress_overlapping_monitors (monitors_ret,
-                                                        geometries_ret);
-}
+static void panel_multiscreen_reinit (void);
 
 static gboolean
 panel_multiscreen_reinit_idle (gpointer data)
@@ -390,95 +49,28 @@ panel_multiscreen_queue_reinit (void)
        reinit_id = g_idle_add (panel_multiscreen_reinit_idle, NULL);
 }
 
-static void
-panel_multiscreen_init_randr (GdkDisplay *display)
-{
-       Display *xdisplay;
-       int      event_base, error_base;
-
-       have_randr = FALSE;
-       have_randr_1_3 = FALSE;
-
-       xdisplay = GDK_DISPLAY_XDISPLAY (display);
-
-       /* We don't remember the event/error bases, as we expect to get "screen
-        * changed" events from GdkScreen instead.
-        */
-
-       if (XRRQueryExtension (xdisplay, &event_base, &error_base)) {
-               int major, minor;
-
-               XRRQueryVersion (xdisplay, &major, &minor);
-               if ((major == 1 && minor >= 2) || major > 1)
-                       have_randr = TRUE;
-
-               if ((major == 1 && minor >= 3) || major > 1)
-                       have_randr_1_3 = TRUE;
-       }
-}
-
 void
 panel_multiscreen_init (void)
 {
-       GdkDisplay *display;
-       int         i;
+  GdkScreen *screen;
 
-       if (initialized)
-               return;
-
-       display = gdk_display_get_default ();
-       screens = 1;
-
-       panel_multiscreen_init_randr (display);
-
-       monitors   = g_new0 (int, screens);
-       geometries = g_new0 (GdkRectangle *, screens);
-
-       for (i = 0; i < screens; i++) {
-               GdkScreen *screen;
-
-               screen = gdk_display_get_screen (display, i);
+  screen = gdk_screen_get_default ();
 
-               /* We connect to both signals to be on the safe side, but in
-                * theory, it should be enough to only connect to
-                * monitors-changed. Since we'll likely get two signals, we do
-                * the real callback in the idle loop. */
-               g_signal_connect (screen, "size-changed",
-                                 G_CALLBACK (panel_multiscreen_queue_reinit), NULL);
-               g_signal_connect (screen, "monitors-changed",
-                                 G_CALLBACK (panel_multiscreen_queue_reinit), NULL);
-
-               panel_multiscreen_get_monitors_for_screen (screen,
-                                                          &(monitors[i]),
-                                                          &(geometries[i]));
-       }
-
-       initialized = TRUE;
+  /* We connect to both signals to be on the safe side, but in
+   * theory, it should be enough to only connect to
+   * monitors-changed. Since we'll likely get two signals, we do
+   * the real callback in the idle loop. */
+  g_signal_connect (screen, "size-changed",
+                    G_CALLBACK(panel_multiscreen_queue_reinit), NULL);
+  g_signal_connect (screen, "monitors-changed",
+                    G_CALLBACK(panel_multiscreen_queue_reinit), NULL);
 }
 
-void
+static void
 panel_multiscreen_reinit (void)
 {
-       GdkScreen *screen;
        GList     *toplevels, *l;
 
-       if (monitors)
-               g_free (monitors);
-
-       if (geometries) {
-               int j;
-
-               for (j = 0; j < screens; j++)
-                       g_free (geometries[j]);
-               g_free (geometries);
-       }
-
-       screen = gdk_screen_get_default ();
-       g_signal_handlers_disconnect_by_func (screen, panel_multiscreen_queue_reinit, NULL);
-
-       initialized = FALSE;
-       panel_multiscreen_init ();
-
        toplevels = gtk_window_list_toplevels ();
 
        for (l = toplevels; l; l = l->next)
@@ -486,153 +78,6 @@ panel_multiscreen_reinit (void)
 
        g_list_free (toplevels);
 }
-       
-int
-panel_multiscreen_screens (void)
-{
-       return screens;
-}
-
-int
-panel_multiscreen_monitors (GdkScreen *screen)
-{
-       int n_screen;
-
-       n_screen = gdk_screen_get_number (screen);
-
-       g_return_val_if_fail (n_screen >= 0 && n_screen < screens, 1);
-
-       return monitors [n_screen];
-}
-
-int
-panel_multiscreen_x (GdkScreen *screen,
-                    int        monitor)
-{
-       int n_screen;
-
-       n_screen = gdk_screen_get_number (screen);
-
-       g_return_val_if_fail (n_screen >= 0 && n_screen < screens, 0);
-       g_return_val_if_fail (monitor >= 0 && monitor < monitors [n_screen], 0);
-
-       return geometries [n_screen][monitor].x;
-}
-
-int
-panel_multiscreen_y (GdkScreen *screen,
-                    int        monitor)
-{
-       int n_screen;
-
-       n_screen = gdk_screen_get_number (screen);
-
-       g_return_val_if_fail (n_screen >= 0 && n_screen < screens, 0);
-       g_return_val_if_fail (monitor >= 0 && monitor < monitors [n_screen], 0);
-
-       return geometries [n_screen][monitor].y;
-}
-
-int
-panel_multiscreen_width (GdkScreen *screen,
-                        int        monitor)
-{
-       int n_screen;
-
-       n_screen = gdk_screen_get_number (screen);
-
-       g_return_val_if_fail (n_screen >= 0 && n_screen < screens, 0);
-       g_return_val_if_fail (monitor >= 0 && monitor < monitors [n_screen], 0);
-
-       return geometries [n_screen][monitor].width;
-}
-
-int
-panel_multiscreen_height (GdkScreen *screen,
-                         int        monitor)
-{
-       int n_screen;
-
-       n_screen = gdk_screen_get_number (screen);
-
-       g_return_val_if_fail (n_screen >= 0 && n_screen < screens, 0);
-       g_return_val_if_fail (monitor >= 0 && monitor < monitors [n_screen], 0);
-
-       return geometries [n_screen][monitor].height;
-}
-
-int
-panel_multiscreen_locate_widget_monitor (GtkWidget *widget)
-{
-       GtkWidget *toplevel;
-       int        retval = -1;
-
-       toplevel = gtk_widget_get_toplevel (widget);
-       if (!toplevel)
-               return -1;
-       
-       g_object_get (toplevel, "monitor", &retval, NULL);
-
-       return retval;
-}
-
-static int
-axis_distance (int p, int axis_start, int axis_size)
-{
-       if (p >= axis_start && p < axis_start + axis_size)
-               return 0;
-       else if (p < axis_start)
-               return (axis_start - p);
-       else
-               return (p - (axis_start + axis_size - 1));
-}
-
-/* The panel can't use gdk_screen_get_monitor_at_point() since it has its own
- * view of which monitors are present. Look at get_monitors_for_screen() above
- * to see why. */
-int
-panel_multiscreen_get_monitor_at_point (GdkScreen *screen,
-                                       int        x,
-                                       int        y)
-{
-       int n_screen;
-       int i;
-       int n_monitors;
-       GdkRectangle *geoms;
-       int min_dist_squared;
-       int closest_monitor;
-
-       /* not -1 as callers expect a real monitor */
-       g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
-
-       n_screen = gdk_screen_get_number (screen);
-
-       n_monitors = monitors[n_screen];
-       geoms = geometries[n_screen];
-
-       min_dist_squared = G_MAXINT32;
-       closest_monitor = 0;
-
-       for (i = 0; i < n_monitors; i++) {
-               int dist_x, dist_y;
-               int dist_squared;
-
-               dist_x = axis_distance (x, geoms[i].x, geoms[i].width);
-               dist_y = axis_distance (y, geoms[i].y, geoms[i].height);
-
-               if (dist_x == 0 && dist_y == 0)
-                       return i;
-
-               dist_squared = dist_x * dist_x + dist_y * dist_y;
-
-               if (dist_squared < min_dist_squared) {
-                       min_dist_squared = dist_squared;
-                       closest_monitor = i;
-               }
-       }
-
-       return closest_monitor;
-}
 
 typedef struct {
        int x0;
@@ -642,56 +87,56 @@ typedef struct {
 } MonitorBounds;
 
 static inline void
-get_monitor_bounds (int            n_screen,
-                   int            n_monitor,
-                   MonitorBounds *bounds)
+get_monitor_bounds (int            n_monitor,
+                    MonitorBounds *bounds)
 {
-       g_assert (n_screen >= 0 && n_screen < screens);
-       g_assert (n_monitor >= 0 || n_monitor < monitors [n_screen]);
        g_assert (bounds != NULL);
 
-       bounds->x0 = geometries [n_screen][n_monitor].x;
-       bounds->y0 = geometries [n_screen][n_monitor].y;
-       bounds->x1 = bounds->x0 + geometries [n_screen][n_monitor].width;
-       bounds->y1 = bounds->y0 + geometries [n_screen][n_monitor].height;
+       int x, y, height, width;
+
+       panel_monitor_get_geometry (n_monitor,
+                                   &x, &y, &height, &width);
+
+       bounds->x0 = x;
+       bounds->y0 = y;
+       bounds->x1 = bounds->x0 + width;
+       bounds->y1 = bounds->y0 + height;
 }
 
 /* determines whether a given monitor is along the visible
  * edge of the logical screen.
  */
 void
-panel_multiscreen_is_at_visible_extreme (GdkScreen *screen,
-                                        int        n_monitor,
-                                        gboolean  *leftmost,
-                                        gboolean  *rightmost,
-                                        gboolean  *topmost,
-                                        gboolean  *bottommost)
+panel_multiscreen_is_at_visible_extreme (int        monitor_index,
+                                         gboolean  *leftmost,
+                                         gboolean  *rightmost,
+                                         gboolean  *topmost,
+                                         gboolean  *bottommost)
 {
        MonitorBounds monitor;
-       int           n_screen, i;
+       int i, n_monitors;
 
-       n_screen = gdk_screen_get_number (screen);
+       n_monitors = gdk_display_get_n_monitors (gdk_display_get_default ());
 
        *leftmost   = TRUE;
        *rightmost  = TRUE;
        *topmost    = TRUE;
        *bottommost = TRUE;
 
-       g_return_if_fail (n_screen >= 0 && n_screen < screens);
-       g_return_if_fail (n_monitor >= 0 && n_monitor < monitors [n_screen]);
+       g_return_if_fail (monitor_index >= 0 && monitor_index < n_monitors);
+
+       get_monitor_bounds (monitor_index, &monitor);
 
-       get_monitor_bounds (n_screen, n_monitor, &monitor);
-       
        /* go through each monitor and try to find one either right,
         * below, above, or left of the specified monitor
         */
 
-       for (i = 0; i < monitors [n_screen]; i++) {
+       for (i = 0; i < n_monitors; i++) {
                MonitorBounds iter;
 
-               if (i == n_monitor) continue;
+               if (i == monitor_index) continue;
 
-               get_monitor_bounds (n_screen, i, &iter);
+               get_monitor_bounds (i, &iter);
 
                if ((iter.y0 >= monitor.y0 && iter.y0 <  monitor.y1) ||
                    (iter.y1 >  monitor.y0 && iter.y1 <= monitor.y1)) {
diff --git a/gnome-panel/panel-multiscreen.h b/gnome-panel/panel-multiscreen.h
index 2e4934c..f9467db 100644
--- a/gnome-panel/panel-multiscreen.h
+++ b/gnome-panel/panel-multiscreen.h
@@ -29,28 +29,11 @@
 #include <gtk/gtk.h>
 
 void   panel_multiscreen_init                  (void);
-void   panel_multiscreen_reinit                (void);
 
-int    panel_multiscreen_screens               (void);
-int    panel_multiscreen_monitors              (GdkScreen *screen);
-
-int    panel_multiscreen_x                     (GdkScreen *screen,
-                                                int        monitor);
-int    panel_multiscreen_y                     (GdkScreen *screen,
-                                                int        monitor);
-int    panel_multiscreen_width                 (GdkScreen *screen,
-                                                int        monitor);
-int    panel_multiscreen_height                (GdkScreen *screen,
-                                                int        monitor);
-int    panel_multiscreen_locate_widget_monitor (GtkWidget *widget);
-int     panel_multiscreen_get_monitor_at_point  (GdkScreen *screen,
-                                                int        x,
-                                                int        y);
-void    panel_multiscreen_is_at_visible_extreme (GdkScreen *screen,
-                                                int        monitor,
-                                                gboolean  *leftmost,
-                                                gboolean  *rightmost,
-                                                gboolean  *topmost,
-                                                gboolean  *bottommost);
+void    panel_multiscreen_is_at_visible_extreme (int        monitor_index,
+                                                 gboolean  *leftmost,
+                                                 gboolean  *rightmost,
+                                                 gboolean  *topmost,
+                                                 gboolean  *bottommost);
 
 #endif /* __PANEL_MULTISCREEN_H__ */
diff --git a/gnome-panel/panel-toplevel.c b/gnome-panel/panel-toplevel.c
index 43d718b..13bf418 100644
--- a/gnome-panel/panel-toplevel.c
+++ b/gnome-panel/panel-toplevel.c
@@ -46,6 +46,7 @@
 #include "panel-struts.h"
 #include "panel-lockdown.h"
 #include "panel-schemas.h"
+#include "panel-monitor.h"
 
 G_DEFINE_TYPE (PanelToplevel, panel_toplevel, GTK_TYPE_WINDOW)
 
@@ -414,27 +415,16 @@ panel_toplevel_get_screen_geometry (PanelToplevel *toplevel,
        return screen;
 }
 
-static GdkScreen *
+static void
 panel_toplevel_get_monitor_geometry (PanelToplevel *toplevel,
-                                    int           *x,
-                                    int           *y,
-                                    int           *width,
-                                    int           *height)
+                                     int           *x,
+                                     int           *y,
+                                     int           *width,
+                                     int           *height)
 {
-       GdkScreen *screen;
+  int monitor_index = toplevel->priv->monitor;
 
-       g_return_val_if_fail (PANEL_IS_TOPLEVEL (toplevel), NULL);
-       g_return_val_if_fail (width != NULL && height != NULL, NULL);
-
-       screen = gtk_window_get_screen (GTK_WINDOW (toplevel));
-
-       if (x) *x = panel_multiscreen_x (screen, toplevel->priv->monitor);
-       if (y) *y = panel_multiscreen_y (screen, toplevel->priv->monitor);
-
-       if (width)  *width  = panel_multiscreen_width  (screen, toplevel->priv->monitor);
-       if (height) *height = panel_multiscreen_height (screen, toplevel->priv->monitor);
-
-       return screen;
+  panel_monitor_get_geometry (monitor_index, x, y, height, width);
 }
 
 static GdkCursorType
@@ -749,25 +739,26 @@ panel_toplevel_calc_new_orientation (PanelToplevel *toplevel,
                                     int            pointer_y)
 {
        PanelOrientation  new_orientation;
-       GdkScreen        *screen;
+       GdkRectangle      geometry;
+
        int               hborder, vborder;
-       int               monitor;
        int               monitor_width, monitor_height;
        int               new_x, new_y;
 
-       screen = gtk_window_get_screen (GTK_WINDOW (toplevel));
+       GdkMonitor *monitor = gdk_display_get_monitor_at_point(gdk_display_get_default(),
+                                                              pointer_x, pointer_y);
 
-       monitor = panel_multiscreen_get_monitor_at_point (screen, pointer_x, pointer_y);
+       gdk_monitor_get_geometry(monitor, &geometry);
 
        if (toplevel->priv->geometry.height < toplevel->priv->geometry.width)
                vborder = hborder = (3 * toplevel->priv->geometry.height) >> 1;
        else
                vborder = hborder = (3 * toplevel->priv->geometry.width)  >> 1;
 
-       new_x = pointer_x - panel_multiscreen_x (screen, monitor);
-       new_y = pointer_y - panel_multiscreen_y (screen, monitor);
-       monitor_width = panel_multiscreen_width (screen, monitor);
-       monitor_height = panel_multiscreen_height (screen, monitor);
+       new_x = pointer_x - geometry.x;
+       new_y = pointer_y - geometry.y;
+       monitor_width = geometry.width;
+       monitor_height = geometry.height;
 
        new_orientation = toplevel->priv->orientation;
 
@@ -821,7 +812,19 @@ panel_toplevel_calc_new_orientation (PanelToplevel *toplevel,
                break;
        }
 
-       panel_toplevel_set_monitor (toplevel, monitor);
+       // this is a temporary hack until we can port all panel_toplevel_* functions
+       // to make use of GdkMonitor instead of the monitor index.
+       int monitor_index = 0;
+
+       for (int i=0; i < gdk_display_get_n_monitors (gdk_display_get_default ()); i++)
+         {
+            if (monitor == gdk_display_get_monitor (gdk_display_get_default (), i))
+              {
+               monitor_index = i;
+             }
+         }
+
+       panel_toplevel_set_monitor (toplevel, monitor_index);
        panel_toplevel_set_orientation (toplevel, new_orientation);
 }
 
@@ -834,6 +837,7 @@ panel_toplevel_move_to (PanelToplevel *toplevel,
        PanelOrientation  new_orientation;
        gboolean          x_centered, y_centered;
        int               screen_width, screen_height;
+       int               new_monitor_x, new_monitor_y;
        int               monitor_width, monitor_height;
        int               width, height;
        int               new_monitor;
@@ -869,16 +873,20 @@ panel_toplevel_move_to (PanelToplevel *toplevel,
                 toplevel->priv->orientation & PANEL_HORIZONTAL_MASK)
                new_orientation = PANEL_ORIENTATION_BOTTOM;
 
-       new_monitor = panel_multiscreen_get_monitor_at_point (screen, new_x, new_y);
+       new_monitor = gdk_screen_get_monitor_at_point (screen, new_x, new_y);
 
        panel_toplevel_get_monitor_geometry (
                        toplevel, NULL, NULL, &monitor_width, &monitor_height);
 
+       panel_monitor_get_geometry (new_monitor,
+                                   &new_monitor_x, &new_monitor_y,
+                                   NULL, NULL);
+
        x_centered = toplevel->priv->x_centered;
        y_centered = toplevel->priv->y_centered;
 
-       x = new_x - panel_multiscreen_x (screen, new_monitor);
-       y = new_y - panel_multiscreen_y (screen, new_monitor);
+       x = new_x - new_monitor_x;
+       y = new_y - new_monitor_y;
 
        if (toplevel->priv->orientation & PANEL_HORIZONTAL_MASK) {
                y_centered = FALSE;
@@ -1442,7 +1450,6 @@ static gboolean
 panel_toplevel_update_struts (PanelToplevel *toplevel, gboolean end_of_animation)
 {
        PanelOrientation  orientation;
-       GdkScreen        *screen;
        gboolean          geometry_changed = FALSE;
        int               strut, strut_start, strut_end;
        int               x, y, width, height;
@@ -1466,17 +1473,17 @@ panel_toplevel_update_struts (PanelToplevel *toplevel, gboolean end_of_animation
                        panel_toplevel_calculate_animation_end_geometry (toplevel);
        }
 
-       screen = panel_toplevel_get_monitor_geometry (toplevel,
-                                                     &monitor_x,
-                                                     &monitor_y,
-                                                     &monitor_width,
-                                                     &monitor_height);
+       panel_toplevel_get_monitor_geometry (toplevel,
+                                            &monitor_x,
+                                            &monitor_y,
+                                            &monitor_width,
+                                            &monitor_height);
 
        if (end_of_animation) {
                x = toplevel->priv->animation_end_x;
                y = toplevel->priv->animation_end_y;
-               x += panel_multiscreen_x (screen, toplevel->priv->monitor);
-               y += panel_multiscreen_y (screen, toplevel->priv->monitor);
+               x += monitor_x;
+               y += monitor_y;
                if (toplevel->priv->animation_end_width != -1)
                        width = toplevel->priv->animation_end_width;
                else
@@ -1869,17 +1876,15 @@ get_delta (int       src,
 static void
 panel_toplevel_update_animating_position (PanelToplevel *toplevel)
 {
-       GdkScreen *screen;
        GTimeVal   time_val;
        int        deltax, deltay, deltaw = 0, deltah = 0;
        int        monitor_offset_x, monitor_offset_y;
 
        g_get_current_time (&time_val);
 
-       screen = gtk_window_get_screen (GTK_WINDOW (toplevel));
-
-       monitor_offset_x = panel_multiscreen_x (screen, toplevel->priv->monitor);
-       monitor_offset_y = panel_multiscreen_y (screen, toplevel->priv->monitor);
+       panel_toplevel_get_monitor_geometry (toplevel,
+                                            &monitor_offset_x, &monitor_offset_y,
+                                            NULL, NULL);
 
        if (toplevel->priv->animation_end_width != -1)
                deltaw = get_delta (toplevel->priv->geometry.width,
@@ -1983,12 +1988,12 @@ panel_toplevel_update_expanded_position (PanelToplevel *toplevel)
                break;
        }
 
-       monitor = panel_multiscreen_get_monitor_at_point (screen, x, y);
+       monitor = gdk_screen_get_monitor_at_point (screen, x, y);
 
        panel_toplevel_set_monitor_internal (toplevel, monitor, TRUE);
 
-       x -= panel_multiscreen_x (screen, monitor);
-       y -= panel_multiscreen_y (screen, monitor);
+       x -= monitor_x;
+       y -= monitor_y;
 
        g_object_freeze_notify (G_OBJECT (toplevel));
 
@@ -2020,11 +2025,12 @@ panel_toplevel_update_position (PanelToplevel *toplevel)
 {
        int        x, y;
        int        w, h;
+       int        monitor_x, monitor_y;
        int        monitor_width, monitor_height;
-       GdkScreen *screen;
 
-       panel_toplevel_get_monitor_geometry (
-                       toplevel, NULL, NULL, &monitor_width, &monitor_height);
+       panel_toplevel_get_monitor_geometry (toplevel,
+                                            &monitor_x, &monitor_y,
+                                            &monitor_width, &monitor_height);
 
        if (toplevel->priv->animating) {
                panel_toplevel_update_animating_position (toplevel);
@@ -2108,9 +2114,8 @@ panel_toplevel_update_position (PanelToplevel *toplevel)
        if (h != -1)
                toplevel->priv->geometry.height = h;
 
-       screen = gtk_window_get_screen (GTK_WINDOW (toplevel));
-       x += panel_multiscreen_x (screen, toplevel->priv->monitor);
-       y += panel_multiscreen_y (screen, toplevel->priv->monitor);
+       x += monitor_x;
+       y += monitor_y;
 
        toplevel->priv->geometry.x = x;
        toplevel->priv->geometry.y = y;
@@ -2939,10 +2944,10 @@ panel_toplevel_calculate_animation_end_geometry (PanelToplevel *toplevel)
 static void
 panel_toplevel_start_animation (PanelToplevel *toplevel)
 {
-       GdkScreen      *screen;
        GtkRequisition  requisition;
        int             deltax, deltay, deltaw = 0, deltah = 0;
        int             cur_x = -1, cur_y = -1;
+       int             monitor_x, monitor_y;
        long            t;
 
        panel_toplevel_calculate_animation_end_geometry (toplevel);
@@ -2959,10 +2964,12 @@ panel_toplevel_start_animation (PanelToplevel *toplevel)
 
        gdk_window_get_origin (gtk_widget_get_window (GTK_WIDGET (toplevel)), &cur_x, &cur_y);
 
-       screen = gtk_widget_get_screen (GTK_WIDGET (toplevel));
+       panel_toplevel_get_monitor_geometry (toplevel,
+                                            &monitor_x, &monitor_y,
+                                            NULL, NULL);
 
-       cur_x -= panel_multiscreen_x (screen, toplevel->priv->monitor);
-       cur_y -= panel_multiscreen_y (screen, toplevel->priv->monitor);
+       cur_x -= monitor_x;
+       cur_y -= monitor_y;
 
        deltax = toplevel->priv->animation_end_x - cur_x;
        deltay = toplevel->priv->animation_end_y - cur_y;


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]