[gnome-panel/wip-format] multiscreen: reformat code



commit 4ca5d89a8349ad1639476256553572aaa0f6c62b
Author: Sebastian Geiger <sbastig gmx net>
Date:   Tue Feb 25 10:46:50 2020 +0100

    multiscreen: reformat code

 gnome-panel/panel-multiscreen.c | 925 +++++++++++++++++++++-------------------
 1 file changed, 479 insertions(+), 446 deletions(-)
---
diff --git a/gnome-panel/panel-multiscreen.c b/gnome-panel/panel-multiscreen.c
index 8a6668a97..5b43f2983 100644
--- a/gnome-panel/panel-multiscreen.c
+++ b/gnome-panel/panel-multiscreen.c
@@ -11,7 +11,7 @@
  *
  * This program 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
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
@@ -34,608 +34,641 @@
 
 #include <string.h>
 
-static int            monitors    = 0;
-static GdkRectangle  *monitor_geometries  = NULL;
-static gboolean       initialized = FALSE;
-static gboolean       have_randr  = FALSE;
-static gboolean       have_randr_1_3 = FALSE;
-static guint          reinit_id   = 0;
+static int monitors = 0;
+static GdkRectangle *monitor_geometries = NULL;
+static gboolean initialized = FALSE;
+static gboolean have_randr = FALSE;
+static gboolean have_randr_1_3 = FALSE;
+static guint reinit_id = 0;
 
 static void panel_multiscreen_reinit (void);
 
 static gboolean
 _panel_multiscreen_output_should_be_first (Display       *xdisplay,
-                                          RROutput       output,
-                                          XRROutputInfo *info,
-                                          RROutput       primary)
+                                           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);
+  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 (int           *monitors_ret,
-                                                GdkRectangle **geometries_ret)
+                                                 GdkRectangle **geometries_ret)
 {
-       GdkScreen          *screen;
-       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.
-        */
-
-       screen = gdk_screen_get_default ();
-       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);
-
-       return TRUE;
+  GdkScreen *screen;
+  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.
+   */
+
+  screen = gdk_screen_get_default ();
+  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);
+
+  return TRUE;
 }
 
 static void
 panel_multiscreen_get_gdk_monitors_for_screen (int           *monitors_ret,
-                                              GdkRectangle **geometries_ret)
+                                               GdkRectangle **geometries_ret)
 {
-       GdkDisplay   *display;
-       int           num_monitors;
-       GdkRectangle *geometries;
-       int           i;
+  GdkDisplay *display;
+  int num_monitors;
+  GdkRectangle *geometries;
+  int i;
 
-       display = gdk_display_get_default ();
-       num_monitors = gdk_display_get_n_monitors (display);
-       geometries = g_new (GdkRectangle, num_monitors);
+  display = gdk_display_get_default ();
+  num_monitors = gdk_display_get_n_monitors (display);
+  geometries = g_new (GdkRectangle, num_monitors);
 
-       for (i = 0; i < num_monitors; i++) {
-               GdkMonitor *monitor;
+  for (i = 0; i < num_monitors; i++)
+    {
+      GdkMonitor *monitor;
 
-               monitor = gdk_display_get_monitor (display, i);
-               gdk_monitor_get_geometry (monitor, &(geometries[i]));
-       }
+      monitor = gdk_display_get_monitor (display, i);
+      gdk_monitor_get_geometry (monitor, &(geometries[i]));
+    }
 
-       *monitors_ret = num_monitors;
-       *geometries_ret = geometries;
+  *monitors_ret = num_monitors;
+  *geometries_ret = geometries;
 }
 
 static void
 panel_multiscreen_get_raw_monitors_for_screen (int           *monitors_ret,
-                                              GdkRectangle **geometries_ret)
+                                               GdkRectangle **geometries_ret)
 {
-       gboolean res;
+  gboolean res;
 
-       *monitors_ret = 0;
-       *geometries_ret = NULL;
+  *monitors_ret = 0;
+  *geometries_ret = NULL;
 
-       res = panel_multiscreen_get_randr_monitors_for_screen (monitors_ret,
-                                                              geometries_ret);
-       if (res && *monitors_ret > 0)
-               return;
+  res = panel_multiscreen_get_randr_monitors_for_screen (monitors_ret,
+                                                         geometries_ret);
+  if (res && *monitors_ret > 0)
+    return;
 
-       panel_multiscreen_get_gdk_monitors_for_screen (monitors_ret,
-                                                      geometries_ret);
+  panel_multiscreen_get_gdk_monitors_for_screen (monitors_ret,
+                                                 geometries_ret);
 }
 
 static inline gboolean
 rectangle_overlaps (GdkRectangle *a,
-                   GdkRectangle *b)
+                    GdkRectangle *b)
 {
-       return gdk_rectangle_intersect (a, b, NULL);
+  return gdk_rectangle_intersect (a, b, NULL);
 }
 
 static long
 pixels_in_rectangle (GdkRectangle *r)
 {
-       return (long) (r->width * r->height);
+  return (long) (r->width * r->height);
 }
 
 static void
 panel_multiscreen_compress_overlapping_monitors (int           *num_monitors_inout,
-                                                GdkRectangle **geometries_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;
+  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 (int           *monitors_ret,
-                                          GdkRectangle **geometries_ret)
+                                           GdkRectangle **geometries_ret)
 {
-       panel_multiscreen_get_raw_monitors_for_screen (monitors_ret,
-                                                      geometries_ret);
-       panel_multiscreen_compress_overlapping_monitors (monitors_ret,
-                                                        geometries_ret);
+  panel_multiscreen_get_raw_monitors_for_screen (monitors_ret,
+                                                 geometries_ret);
+  panel_multiscreen_compress_overlapping_monitors (monitors_ret,
+                                                   geometries_ret);
 }
 
 static gboolean
 panel_multiscreen_reinit_idle (gpointer data)
 {
-       panel_multiscreen_reinit ();
-       reinit_id = 0;
+  panel_multiscreen_reinit ();
+  reinit_id = 0;
 
-       return FALSE;
+  return FALSE;
 }
 
 static void
 panel_multiscreen_queue_reinit (void)
 {
-       if (reinit_id)
-               return;
+  if (reinit_id)
+    return;
 
-       reinit_id = g_idle_add (panel_multiscreen_reinit_idle, NULL);
+  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;
+  Display *xdisplay;
+  int event_base, error_base;
 
-       have_randr = FALSE;
-       have_randr_1_3 = FALSE;
+  have_randr = FALSE;
+  have_randr_1_3 = FALSE;
 
-       xdisplay = GDK_DISPLAY_XDISPLAY (display);
+  xdisplay = GDK_DISPLAY_XDISPLAY (display);
 
-       /* We don't remember the event/error bases, as we expect to get "screen
-        * changed" events from GdkScreen instead.
-        */
+  /* 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;
 
-       if (XRRQueryExtension (xdisplay, &event_base, &error_base)) {
-               int major, minor;
+      XRRQueryVersion (xdisplay, &major, &minor);
 
-               XRRQueryVersion (xdisplay, &major, &minor);
-               if ((major == 1 && minor >= 2) || major > 1)
-                       have_randr = TRUE;
+      if ((major == 1 && minor >= 2) || major > 1)
+        have_randr = TRUE;
 
-               if ((major == 1 && minor >= 3) || major > 1)
-                       have_randr_1_3 = TRUE;
-       }
+      if ((major == 1 && minor >= 3) || major > 1)
+        have_randr_1_3 = TRUE;
+    }
 }
 
 void
 panel_multiscreen_init (void)
 {
-       GdkDisplay *display;
-       GdkScreen *screen;
+  GdkDisplay *display;
+  GdkScreen *screen;
 
-       if (initialized)
-               return;
+  if (initialized)
+    return;
 
-       display = gdk_display_get_default ();
+  display = gdk_display_get_default ();
 
-       panel_multiscreen_init_randr (display);
+  panel_multiscreen_init_randr (display);
 
-       screen = gdk_screen_get_default ();
+  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);
+  /* 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 (&monitors, &monitor_geometries);
+  panel_multiscreen_get_monitors_for_screen (&monitors, &monitor_geometries);
 
-       initialized = TRUE;
+  initialized = TRUE;
 }
 
 static void
 panel_multiscreen_reinit (void)
 {
-       GdkScreen *screen;
-       GList     *toplevels, *l;
+  GdkScreen *screen;
+  GList *toplevels, *l;
 
-       if (monitor_geometries) {
-               g_free (monitor_geometries);
-       }
+  if (monitor_geometries)
+    {
+      g_free (monitor_geometries);
+    }
 
-       screen = gdk_screen_get_default ();
-       g_signal_handlers_disconnect_by_func (screen, panel_multiscreen_queue_reinit, NULL);
+  screen = gdk_screen_get_default ();
+  g_signal_handlers_disconnect_by_func (screen, panel_multiscreen_queue_reinit, NULL);
 
-       initialized = FALSE;
-       panel_multiscreen_init ();
+  initialized = FALSE;
+  panel_multiscreen_init ();
 
-       toplevels = gtk_window_list_toplevels ();
+  toplevels = gtk_window_list_toplevels ();
 
-       for (l = toplevels; l; l = l->next)
-               gtk_widget_queue_resize (l->data);
+  for (l = toplevels; l; l = l->next)
+    gtk_widget_queue_resize (l->data);
 
-       g_list_free (toplevels);
+  g_list_free (toplevels);
 }
 
 int
 panel_multiscreen_x (GdkScreen *screen,
-                    int        monitor)
+                     int        monitor)
 {
-       g_return_val_if_fail (monitor >= 0 && monitor < monitors, 0);
+  g_return_val_if_fail (monitor >= 0 && monitor < monitors, 0);
 
-       return monitor_geometries [monitor].x;
+  return monitor_geometries[monitor].x;
 }
 
 int
 panel_multiscreen_y (GdkScreen *screen,
-                    int        monitor)
+                     int        monitor)
 {
-       g_return_val_if_fail (monitor >= 0 && monitor < monitors, 0);
+  g_return_val_if_fail (monitor >= 0 && monitor < monitors, 0);
 
-       return monitor_geometries [monitor].y;
+  return monitor_geometries[monitor].y;
 }
 
 int
 panel_multiscreen_width (GdkScreen *screen,
-                        int        monitor)
+                         int        monitor)
 {
-       g_return_val_if_fail (monitor >= 0 && monitor < monitors, 0);
+  g_return_val_if_fail (monitor >= 0 && monitor < monitors, 0);
 
-       return monitor_geometries [monitor].width;
+  return monitor_geometries[monitor].width;
 }
 
 int
 panel_multiscreen_height (GdkScreen *screen,
-                         int        monitor)
+                          int        monitor)
 {
-       g_return_val_if_fail (monitor >= 0 && monitor < monitors, 0);
+  g_return_val_if_fail (monitor >= 0 && monitor < monitors, 0);
 
-       return monitor_geometries [monitor].height;
+  return monitor_geometries[monitor].height;
 }
 
 int
 panel_multiscreen_locate_widget_monitor (GtkWidget *widget)
 {
-       GtkWidget *toplevel;
-       int        retval = -1;
+  GtkWidget *toplevel;
+  int retval = -1;
 
-       toplevel = gtk_widget_get_toplevel (widget);
-       if (!toplevel)
-               return -1;
-       
-       g_object_get (toplevel, "monitor", &retval, NULL);
+  toplevel = gtk_widget_get_toplevel (widget);
+  if (!toplevel)
+    return -1;
 
-       return retval;
+  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));
+  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 (int        x,
-                                       int        y)
+panel_multiscreen_get_monitor_at_point (int x,
+                                        int y)
 {
-       int i;
-       int min_dist_squared;
-       int closest_monitor;
+  int i;
+  int min_dist_squared;
+  int closest_monitor;
 
-       min_dist_squared = G_MAXINT32;
-       closest_monitor = 0;
+  min_dist_squared = G_MAXINT32;
+  closest_monitor = 0;
 
-       for (i = 0; i < monitors; i++) {
-               int dist_x, dist_y;
-               int dist_squared;
+  for (i = 0; i < monitors; i++)
+    {
+      int dist_x, dist_y;
+      int dist_squared;
 
-               dist_x = axis_distance (x, monitor_geometries[i].x, monitor_geometries[i].width);
-               dist_y = axis_distance (y, monitor_geometries[i].y, monitor_geometries[i].height);
+      dist_x = axis_distance (x, monitor_geometries[i].x, monitor_geometries[i].width);
+      dist_y = axis_distance (y, monitor_geometries[i].y, monitor_geometries[i].height);
 
-               if (dist_x == 0 && dist_y == 0)
-                       return i;
+      if (dist_x == 0 && dist_y == 0)
+        return i;
 
-               dist_squared = dist_x * dist_x + dist_y * dist_y;
+      dist_squared = dist_x * dist_x + dist_y * dist_y;
 
-               if (dist_squared < min_dist_squared) {
-                       min_dist_squared = dist_squared;
-                       closest_monitor = i;
-               }
-       }
+      if (dist_squared < min_dist_squared)
+        {
+          min_dist_squared = dist_squared;
+          closest_monitor = i;
+        }
+    }
 
-       return closest_monitor;
+  return closest_monitor;
 }
 
-typedef struct {
-       int x0;
-       int y0;
-       int x1;
-       int y1;
+typedef struct
+{
+  int x0;
+  int y0;
+  int x1;
+  int y1;
 } MonitorBounds;
 
 static inline void
 get_monitor_bounds (int            n_monitor,
-                   MonitorBounds *bounds)
+                    MonitorBounds *bounds)
 {
-       g_assert (n_monitor >= 0 || n_monitor < monitors);
-       g_assert (bounds != NULL);
+  g_assert (n_monitor >= 0 || n_monitor < monitors);
+  g_assert (bounds != NULL);
 
-       bounds->x0 = monitor_geometries [n_monitor].x;
-       bounds->y0 = monitor_geometries [n_monitor].y;
-       bounds->x1 = bounds->x0 + monitor_geometries [n_monitor].width;
-       bounds->y1 = bounds->y0 + monitor_geometries [n_monitor].height;
+  bounds->x0 = monitor_geometries[n_monitor].x;
+  bounds->y0 = monitor_geometries[n_monitor].y;
+  bounds->x1 = bounds->x0 + monitor_geometries[n_monitor].width;
+  bounds->y1 = bounds->y0 + monitor_geometries[n_monitor].height;
 }
 
 /* determines whether a given monitor is along the visible
  * edge of the logical screen.
  */
 void
-panel_multiscreen_is_at_visible_extreme (int        n_monitor,
-                                        gboolean  *leftmost,
-                                        gboolean  *rightmost,
-                                        gboolean  *topmost,
-                                        gboolean  *bottommost)
+panel_multiscreen_is_at_visible_extreme (int       n_monitor,
+                                         gboolean *leftmost,
+                                         gboolean *rightmost,
+                                         gboolean *topmost,
+                                         gboolean *bottommost)
 {
-       MonitorBounds monitor;
-       int i;
-
-       *leftmost   = TRUE;
-       *rightmost  = TRUE;
-       *topmost    = TRUE;
-       *bottommost = TRUE;
-
-       g_return_if_fail (n_monitor >= 0 && n_monitor < monitors);
-
-       get_monitor_bounds (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; i++) {
-               MonitorBounds iter;
-
-               if (i == n_monitor) continue;
-
-               get_monitor_bounds (i, &iter);
-
-               if ((iter.y0 >= monitor.y0 && iter.y0 <  monitor.y1) ||
-                   (iter.y1 >  monitor.y0 && iter.y1 <= monitor.y1)) {
-                       if (iter.x0 < monitor.x0)
-                               *leftmost = FALSE;
-                       if (iter.x1 > monitor.x1)
-                               *rightmost = FALSE;
-               }
-
-               if ((iter.x0 >= monitor.x0 && iter.x0 <  monitor.x1) ||
-                   (iter.x1 >  monitor.x0 && iter.x1 <= monitor.x1)) {
-                       if (iter.y0 < monitor.y0)
-                               *topmost = FALSE;
-                       if (iter.y1 > monitor.y1)
-                               *bottommost = FALSE;
-               }
-       }
+  MonitorBounds monitor;
+  int i;
+
+  *leftmost = TRUE;
+  *rightmost = TRUE;
+  *topmost = TRUE;
+  *bottommost = TRUE;
+
+  g_return_if_fail (n_monitor >= 0 && n_monitor < monitors);
+
+  get_monitor_bounds (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; i++)
+    {
+      MonitorBounds iter;
+
+      if (i == n_monitor)
+        continue;
+
+      get_monitor_bounds (i, &iter);
+
+      if ((iter.y0 >= monitor.y0 && iter.y0 < monitor.y1) ||
+          (iter.y1 > monitor.y0 && iter.y1 <= monitor.y1))
+        {
+          if (iter.x0 < monitor.x0)
+            *leftmost = FALSE;
+          if (iter.x1 > monitor.x1)
+            *rightmost = FALSE;
+        }
+
+      if ((iter.x0 >= monitor.x0 && iter.x0 < monitor.x1) ||
+          (iter.x1 > monitor.x0 && iter.x1 <= monitor.x1))
+        {
+          if (iter.y0 < monitor.y0)
+            *topmost = FALSE;
+          if (iter.y1 > monitor.y1)
+            *bottommost = FALSE;
+        }
+    }
 }


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