Refactor panel_multiscreen functions into panel_multimonitor ones

author: William Wold <[email protected]> 2019-06-19 18:57:10 +0000
committer: raveit65 <[email protected]> 2019-06-21 18:47:54 +0200
commit: 0a818dee94ddee0a510973e482def9945c0c267e (patch)
tree: 50a4f5c2d89b8a2423fd54e057b57f385910274f
parent: 8c61fc25221e6ef102c77a859c6a44b9b4e25cb6 (diff)
download: mate-panel-0a818dee94ddee0a510973e482def9945c0c267e.tar.bz2
mate-panel-0a818dee94ddee0a510973e482def9945c0c267e.tar.xz
2 files changed, 109 insertions, 204 deletions
diff --git a/mate-panel/panel-multimonitor.c b/mate-panel/panel-multimonitor.c
index c370838b..c73d59ed 100644
--- a/mate-panel/panel-multimonitor.c
+++ b/mate-panel/panel-multimonitor.c
@@ -30,23 +30,29 @@
 #include <X11/extensions/Xrandr.h>
 #include <gdk/gdkx.h>
 
-#include "panel-multiscreen.h"
+#include "panel-multimonitor.h"
 
 #include <string.h>
 
-static int screens = 0;
-static int *monitors = NULL;
-static GdkRectangle **geometries = NULL;
+// The number of logical monitors we are keeping track of
+// May be different than gdk_display_get_n_monitors()
+// (see comment in panel_multimonitor_compress_overlapping_monitors for details)
+static int monitor_count = 0;
+
+// A dynamically allocated array of monitor geometries
+// monitor_count is the length
+static GdkRectangle *geometries = NULL;
+
 static gboolean initialized = FALSE;
 static gboolean have_randr = FALSE;
 static guint reinit_id = 0;
 
 #ifdef HAVE_RANDR
 static gboolean
-_panel_multiscreen_output_should_be_first (Display *xdisplay,
- RROutput output,
- XRROutputInfo *info,
- RROutput primary)
+_panel_multimonitor_output_should_be_first (Display *xdisplay,
+ RROutput output,
+ XRROutputInfo *info,
+ RROutput primary)
 {
 if (primary)
 return output == primary;
@@ -83,12 +89,12 @@ _panel_multiscreen_output_should_be_first (Display *xdisplay,
 #endif
 
 static gboolean
-panel_multiscreen_get_randr_monitors_for_screen (GdkScreen *screen,
- int *monitors_ret,
- GdkRectangle **geometries_ret)
+panel_multimonitor_get_randr_monitors (int *monitors_ret,
+ GdkRectangle **geometries_ret)
 {
 #ifdef HAVE_RANDR
 GdkDisplay *display;
+ GdkScreen *screen;
 GdkMonitor *monitor;
 Display *xdisplay;
 Window xroot;
@@ -123,7 +129,8 @@ panel_multiscreen_get_randr_monitors_for_screen (GdkScreen *screen,
 * http://bugzilla.gnome.org/show_bug.cgi?id=562944 for a more
 * long-term solution.
 */
-
+ display = gdk_display_get_default ();
+ screen = gdk_display_get_default_screen (display);
 xdisplay = GDK_SCREEN_XDISPLAY (screen);
 xroot = GDK_WINDOW_XID (gdk_screen_get_root_window (screen));
 
@@ -141,7 +148,6 @@ panel_multiscreen_get_randr_monitors_for_screen (GdkScreen *screen,
 return FALSE;
 
 primary = XRRGetOutputPrimary (xdisplay, xroot);
- display = gdk_screen_get_display (screen);
 monitor = gdk_display_get_primary_monitor (display);
 
 /* Use scale factor to bring geometries down to device pixels to support HiDPI displays */
@@ -172,9 +178,9 @@ panel_multiscreen_get_randr_monitors_for_screen (GdkScreen *screen,
 
 XRRFreeCrtcInfo (crtc);
 
- if (_panel_multiscreen_output_should_be_first (xdisplay,
- resources->outputs[i],
- output, primary))
+ if (_panel_multimonitor_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);
@@ -206,16 +212,15 @@ panel_multiscreen_get_randr_monitors_for_screen (GdkScreen *screen,
 }
 
 static void
-panel_multiscreen_get_gdk_monitors_for_screen (GdkScreen *screen,
- int *monitors_ret,
- GdkRectangle **geometries_ret)
+panel_multimonitor_get_gdk_monitors (int *monitors_ret,
+ GdkRectangle **geometries_ret)
 {
 GdkDisplay *display;
 int num_monitors;
 GdkRectangle *geometries;
 int i;
 
- display = gdk_screen_get_display (screen);
+ display = gdk_display_get_default ();
 num_monitors = gdk_display_get_n_monitors (display);
 geometries = g_new (GdkRectangle, num_monitors);
 
@@ -227,24 +232,19 @@ panel_multiscreen_get_gdk_monitors_for_screen (GdkScreen *screen,
 }
 
 static void
-panel_multiscreen_get_raw_monitors_for_screen (GdkScreen *screen,
- int *monitors_ret,
- GdkRectangle **geometries_ret)
+panel_multimonitor_get_raw_monitors (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);
+ res = panel_multimonitor_get_randr_monitors (monitors_ret, geometries_ret);
 if (res && *monitors_ret > 0)
 return;
 
- panel_multiscreen_get_gdk_monitors_for_screen (screen,
- monitors_ret,
- geometries_ret);
+ panel_multimonitor_get_gdk_monitors (monitors_ret, geometries_ret);
 }
 
 static inline gboolean
@@ -261,8 +261,8 @@ pixels_in_rectangle (GdkRectangle *r)
 }
 
 static void
-panel_multiscreen_compress_overlapping_monitors (int *num_monitors_inout,
- GdkRectangle **geometries_inout)
+panel_multimonitor_compress_overlapping_monitors (int *num_monitors_inout,
+ GdkRectangle **geometries_inout)
 {
 int num_monitors;
 GdkRectangle *geometries;
@@ -353,38 +353,28 @@ panel_multiscreen_compress_overlapping_monitors (int *num_monitors_ino
 *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 gboolean
-panel_multiscreen_reinit_idle (gpointer data)
+panel_multimonitor_reinit_idle (gpointer data)
 {
- panel_multiscreen_reinit ();
+ panel_multimonitor_reinit ();
 reinit_id = 0;
 
 return FALSE;
 }
 
 static void
-panel_multiscreen_queue_reinit (void)
+panel_multimonitor_handle_monitor_changed (GdkDisplay *display,
+ GdkMonitor *monitor,
+ gpointer user_data)
 {
 if (reinit_id)
 return;
 
- reinit_id = g_idle_add (panel_multiscreen_reinit_idle, NULL);
+ reinit_id = g_idle_add (panel_multimonitor_reinit_idle, NULL);
 }
 
 static void
-panel_multiscreen_init_randr (GdkDisplay *display)
+panel_multimonitor_init_randr (GdkDisplay *display)
 {
 #ifdef HAVE_RANDR
 Display *xdisplay;
@@ -396,8 +386,8 @@ panel_multiscreen_init_randr (GdkDisplay *display)
 #ifdef HAVE_RANDR
 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 monitor
+ * added/removed events from the display instead.
 */
 
 if (XRRQueryExtension (xdisplay, &event_base, &error_base)) {
@@ -411,7 +401,7 @@ panel_multiscreen_init_randr (GdkDisplay *display)
 }
 
 void
-panel_multiscreen_init (void)
+panel_multimonitor_init (void)
 {
 GdkDisplay *display;
 
@@ -419,55 +409,36 @@ panel_multiscreen_init (void)
 return;
 
 display = gdk_display_get_default ();
- screens = 1;
-
- panel_multiscreen_init_randr (display);
 
- monitors = g_new0 (int, screens);
- geometries = g_new0 (GdkRectangle *, screens);
+ panel_multimonitor_init_randr (display);
 
- GdkScreen *screen;
+ /* monitors-changed. Since we'll likely get two signals in some cases,
+ * we do the real callback in the idle loop. */
+ g_signal_connect (display, "monitor-added",
+ G_CALLBACK (panel_multimonitor_handle_monitor_changed), NULL);
+ g_signal_connect (display, "monitor-removed",
+ G_CALLBACK (panel_multimonitor_handle_monitor_changed), NULL);
 
- screen = gdk_display_get_default_screen (display);
-
- /* 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[0]),
- &(geometries[0]));
+ panel_multimonitor_get_raw_monitors (&monitor_count, &geometries);
+ panel_multimonitor_compress_overlapping_monitors (&monitor_count, &geometries);
 
 initialized = TRUE;
 }
 
 void
-panel_multiscreen_reinit (void)
+panel_multimonitor_reinit (void)
 {
- GdkScreen *screen;
- GList *toplevels, *l;
-
- if (monitors)
- g_free (monitors);
-
- if (geometries) {
- int j;
+ GdkDisplay *display;
+ GList *toplevels, *l;
 
- for (j = 0; j < screens; j++)
- g_free (geometries[j]);
+ if (geometries)
 g_free (geometries);
- }
 
- screen = gdk_screen_get_default ();
- g_signal_handlers_disconnect_by_func (screen, panel_multiscreen_queue_reinit, NULL);
+ display = gdk_display_get_default ();
+ g_signal_handlers_disconnect_by_func (display, panel_multimonitor_handle_monitor_changed, NULL);
 
 initialized = FALSE;
- panel_multiscreen_init ();
+ panel_multimonitor_init ();
 
 toplevels = gtk_window_list_toplevels ();
 
@@ -478,81 +449,41 @@ panel_multiscreen_reinit (void)
 }
 
 int
-panel_multiscreen_screens (void)
-{
- return screens;
-}
-
-int
-panel_multiscreen_monitors (GdkScreen *screen)
+panel_multimonitor_monitors ()
 {
- int n_screen;
-
- n_screen = gdk_x11_screen_get_screen_number (screen);
-
- g_return_val_if_fail (n_screen >= 0 && n_screen < screens, 1);
-
- return monitors [n_screen];
+ return monitor_count;
 }
 
 int
-panel_multiscreen_x (GdkScreen *screen,
- int monitor)
+panel_multimonitor_x (int monitor)
 {
- int n_screen;
-
- n_screen = gdk_x11_screen_get_screen_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;
+ g_return_val_if_fail (monitor >= 0 && monitor < monitor_count, 0);
+ return geometries [monitor].x;
 }
 
 int
-panel_multiscreen_y (GdkScreen *screen,
- int monitor)
+panel_multimonitor_y (int monitor)
 {
- int n_screen;
-
- n_screen = gdk_x11_screen_get_screen_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;
+ g_return_val_if_fail (monitor >= 0 && monitor < monitor_count, 0);
+ return geometries [monitor].y;
 }
 
 int
-panel_multiscreen_width (GdkScreen *screen,
- int monitor)
+panel_multimonitor_width (int monitor)
 {
- int n_screen;
-
- n_screen = gdk_x11_screen_get_screen_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;
+ g_return_val_if_fail (monitor >= 0 && monitor < monitor_count, 0);
+ return geometries [monitor].width;
 }
 
 int
-panel_multiscreen_height (GdkScreen *screen,
- int monitor)
+panel_multimonitor_height (int monitor)
 {
- int n_screen;
-
- n_screen = gdk_x11_screen_get_screen_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;
+ g_return_val_if_fail (monitor >= 0 && monitor < monitor_count, 0);
+ return geometries [monitor].height;
 }
 
 int
-panel_multiscreen_locate_widget_monitor (GtkWidget *widget)
+panel_multimonitor_locate_widget_monitor (GtkWidget *widget)
 {
 GtkWidget *toplevel;
 int retval = -1;
@@ -581,34 +512,21 @@ axis_distance (int p, int axis_start, int axis_size)
 * 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)
+panel_multimonitor_get_monitor_at_point (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_x11_screen_get_screen_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++) {
+ for (i = 0; i < monitor_count; 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);
+ dist_x = axis_distance (x, geometries[i].x, geometries[i].width);
+ dist_y = axis_distance (y, geometries[i].y, geometries[i].height);
 
 if (dist_x == 0 && dist_y == 0)
 return i;
@@ -632,56 +550,50 @@ typedef struct {
 } MonitorBounds;
 
 static inline void
-get_monitor_bounds (int n_screen,
- int n_monitor,
+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;
+ g_return_if_fail (n_monitor >= 0 || n_monitor < monitor_count);
+ g_return_if_fail (bounds != NULL);
+
+ bounds->x0 = geometries [n_monitor].x;
+ bounds->y0 = geometries [n_monitor].y;
+ bounds->x1 = bounds->x0 + geometries [n_monitor].width;
+ bounds->y1 = bounds->y0 + 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 (GdkScreen *screen,
- int n_monitor,
- gboolean *leftmost,
- gboolean *rightmost,
- gboolean *topmost,
- gboolean *bottommost)
+panel_multimonitor_is_at_visible_extreme (int n_monitor,
+ gboolean *leftmost,
+ gboolean *rightmost,
+ gboolean *topmost,
+ gboolean *bottommost)
 {
 MonitorBounds monitor;
- int n_screen, i;
-
- n_screen = gdk_x11_screen_get_screen_number (screen);
+ int i;
 
 *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 (n_monitor >= 0 && n_monitor < monitor_count);
 
- get_monitor_bounds (n_screen, n_monitor, &monitor);
+ 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 [n_screen]; i++) {
+ for (i = 0; i < monitor_count; i++) {
 MonitorBounds iter;
 
 if (i == n_monitor) 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/mate-panel/panel-multimonitor.h b/mate-panel/panel-multimonitor.h
index 44ae962e..ea262b17 100644
--- a/mate-panel/panel-multimonitor.h
+++ b/mate-panel/panel-multimonitor.h
@@ -28,29 +28,22 @@
 
 #include <gtk/gtk.h>
 
-void panel_multiscreen_init (void);
-void panel_multiscreen_reinit (void);
+void panel_multimonitor_init (void);
+void panel_multimonitor_reinit (void);
 
-int panel_multiscreen_screens (void);
-int panel_multiscreen_monitors (GdkScreen *screen);
+int panel_multimonitor_monitors (void);
 
-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);
+int panel_multimonitor_x (int monitor);
+int panel_multimonitor_y (int monitor);
+int panel_multimonitor_width (int monitor);
+int panel_multimonitor_height (int monitor);
+
+int panel_multimonitor_locate_widget_monitor (GtkWidget *widget);
+int panel_multimonitor_get_monitor_at_point (int x, int y);
+void panel_multimonitor_is_at_visible_extreme (int monitor_id,
+ gboolean *leftmost,
+ gboolean *rightmost,
+ gboolean *topmost,
+ gboolean *bottommost);
 
 #endif /* __PANEL_MULTIMONITOR_H__ */
author	William Wold <[email protected]>	2019-06-19 18:57:10 +0000
committer	raveit65 <[email protected]>	2019-06-21 18:47:54 +0200
commit	0a818dee94ddee0a510973e482def9945c0c267e (patch)
tree	50a4f5c2d89b8a2423fd54e057b57f385910274f
parent	8c61fc25221e6ef102c77a859c6a44b9b4e25cb6 (diff)
download	mate-panel-0a818dee94ddee0a510973e482def9945c0c267e.tar.bz2 mate-panel-0a818dee94ddee0a510973e482def9945c0c267e.tar.xz