nx-X11/programs/Xserver/hw/nxagent/Screen.c: add screen boxes generation algorithm/function.

Author: Ionic

nx-X11/programs/Xserver/hw/nxagent/Screen.c

@@ -55,6 +55,7 @@ is" without express or implied warranty.
 #include "../../randr/randrstr.h"
 #include "inputstr.h"
 #include "mivalidate.h"
+#include "list.h"
 
 #include "Agent.h"
 #include "Display.h"
@@ -3931,6 +3932,28 @@ typedef struct {
   INT32  *y_splits;
 } nxagentScreenSplits;
 
+/*
+ * Structure containing the boxes an nxagent session window is split into.
+ *
+ * Only used locally, not exported.
+ */
+typedef struct {
+  struct xorg_list entry;
+  BoxRec box; /*
+               * You might be tempted to use RegionRec here. Do not.
+               * A region is really an ordered and minimal set of horizontal
+               * bands. A window tiling will in most cases not be minimal,
+               * due to the need to split at display boundaries.
+               * A Region is more minimal than this.
+               * C.f., https://web.archive.org/web/20170520132137/http://magcius.github.io:80/xplain/article/regions.html
+               */
+} nxagentScreenBoxesElem;
+
+/*
+ * Can't typedef struct xorg_list to nxagentScreenBoxes, or else I would have.
+ */
+typedef struct xorg_list nxagentScreenBoxes;
+
 /*
  * Helper function that takes a potential split point, the window bounds,
  * a split count and a splits array.
@@ -4118,6 +4141,161 @@ static nxagentScreenSplits* nxagentGenerateScreenSplitList(XineramaScreenInfo *s
   return(ret);
 }
 
+/* Helper function printing out a splits list. */
+static void nxagentPrintSplitsList(const INT32 *splits, const size_t count, const char *func, Bool is_x) {
+  fprintf(stderr, "%s: ", func);
+  if (is_x) {
+    fprintf(stderr, "X");
+  }
+  else {
+    fprintf(stderr, "Y");
+  }
+  fprintf(stderr, " split list: [");
+
+  for (size_t i = 0; i < count; ++i) {
+    if (i > 0) {
+      fprintf(stderr, ", ");
+    }
+
+    fprintf(stderr, "%u", splits[i]);
+  }
+
+  fprintf(stderr, "]\n");
+}
+
+/* Helper to clear out a screen boxes list. */
+static void nxagentFreeScreenBoxes(nxagentScreenBoxes *boxes) {
+  if (!(boxes)) {
+    return;
+  }
+
+  nxagentScreenBoxesElem *cur  = NULL,
+                         *next = NULL;
+
+  xorg_list_for_each_entry_safe(cur, next, boxes, entry) {
+    xorg_list_del(&(cur->entry));
+    SAFE_FREE(cur);
+  }
+
+  xorg_list_init(boxes);
+}
+
+/*
+ * Given a list of splits, sorts them and calculates a tile pattern for the
+ * current window.
+ * In case of errors, returns an empty list.
+ */
+static nxagentScreenBoxes* nxagentGenerateScreenCrtcs(nxagentScreenSplits *splits) {
+  struct xorg_list *ret = NULL;
+
+  ret = calloc(sizeof(nxagentScreenBoxes), 1);
+  if (!(ret)) {
+    return(ret);
+  }
+
+  xorg_list_init(ret);
+
+  if (!(splits)) {
+    return(ret);
+  }
+
+  qsort(splits->x_splits, splits->x_count, sizeof(*splits->x_splits), nxagentCompareSplits);
+  qsort(splits->y_splits, splits->y_count, sizeof(*splits->y_splits), nxagentCompareSplits);
+
+#ifdef DEBUG
+  nxagentPrintSplitsList(splits->x_splits, splits->x_count, __func__, TRUE);
+  nxagentPrintSplitsList(splits->y_splits, splits->y_count, __func__, FALSE);
+#endif
+
+  /*
+   * Since the split lists are sorted now, we can go ahead and create boxes in
+   * an iterative manner.
+   */
+#ifdef DEBUG
+  {
+    /* Avoid using %zu printf specifier which may not be supported everywhere. */
+    long long unsigned x_splits = splits->x_splits;
+    long long unsigned x_splits = splits->x_splits;
+    fprintf(stderr, "%s: should generate (x_splits [%llu] + 1) * (y_splits [%llu] + 1) = %llu boxes.\n", __func__, x_splits, y_splits, (x_splits + 1) * (y_splits + 1));
+  }
+#endif
+  /*                    v-- implicit split point at agent window's bottommost edge! */
+  for (size_t i = 0; i <= splits->y_count; ++i) {
+    /* Looping over "rows" here (hence y splits). */
+    CARD32 start_y = -1,
+           end_y   = -1;
+
+    if (0 == i) {
+      start_y = nxagentOption(Y);
+    }
+    else {
+      start_y = splits->y_splits[i - 1];
+    }
+
+    if (i == splits->y_count) {
+      end_y = splits->y_splits[i];
+    }
+    else {
+      end_y = (start_y + nxagentOption(Height));
+    }
+
+  /*                      v-- implicit split point at agent window's rightmost edge! */
+    for (size_t y = 0; y <= splits->x_count; ++y) {
+      /* Looping over "cols" here (hence x splits). */
+      CARD32 start_x = -1,
+             end_x   = -1;
+
+      if (0 == y) {
+        start_x = nxagentOption(X);
+      }
+      else {
+        start_x = splits->x_splits[y - 1];
+      }
+
+      if (y == splits->x_count) {
+        end_x = splits->x_splits[y];
+      }
+      else {
+        end_x = (start_x + nxagentOption(Width));
+      }
+
+      nxagentScreenBoxesElem *new_box = calloc(sizeof(nxagentScreenBoxesElem), 1);
+
+      if (!(new_box)) {
+        nxagentFreeScreenBoxes(ret);
+        return(ret);
+      }
+
+      /* Box extends from (start_x, start_y) to (end_x, end_y). */
+      new_box->box.x1 = start_x;
+      new_box->box.x2 = end_x;
+      new_box->box.y1 = start_y;
+      new_box->box.y2 = end_y;
+
+      xorg_list_add(&(new_box->entry), ret);
+    }
+  }
+
+#if defined(DEBUG) || defined(WARNING)
+  {
+    long long unsigned count = 0;
+    nxagentScreenBoxesElem *cur = NULL;
+    xorg_list_for_each_entry(cur, ret, entry) {
+      ++count;
+    }
+#ifdef DEBUG
+    fprintf(stderr, "%s: generated %llu boxes\n", __func__, count);
+#endif
+    if (count < ((splits->x_count + 1) * (splits->y_count + 1))) {
+      long long unsigned expect = ((splits->x_count + 1) * (splits->y_count + 1));
+      fprintf(stderr, "%s: WARNING! Generated only %llu boxes, expected: %llu\n", __func__, count, expect);
+    }
+  }
+#endif
+
+  return(ret);
+}
+
 /*
  Destroy an output after removing it from any crtc that might reference it
  */