[X2Go-Commits] [nx-libs] 02/09: nx-X11/programs/Xserver/hw/nxagent/Screen.c: add high-level wrapper to generate and select a solution for a given base screen boxes list and remote Xinerama information.
git-admin at x2go.org
git-admin at x2go.org
Fri May 18 09:33:33 CEST 2018
This is an automated email from the git hooks/post-receive script.
x2go pushed a commit to branch 3.6.x-rpm-debug
in repository nx-libs.
commit addff188ffc257a2dc99407b668aea992d75f349
Author: Mihai Moldovan <ionic at ionic.de>
Date: Tue Apr 24 14:58:55 2018 +0200
nx-X11/programs/Xserver/hw/nxagent/Screen.c: add high-level wrapper to generate and select a solution for a given base screen boxes list and remote Xinerama information.
---
nx-X11/programs/Xserver/hw/nxagent/Screen.c | 389 ++++++++++++++++++++++++++++
1 file changed, 389 insertions(+)
diff --git a/nx-X11/programs/Xserver/hw/nxagent/Screen.c b/nx-X11/programs/Xserver/hw/nxagent/Screen.c
index d71ad9a..8fbfdde 100644
--- a/nx-X11/programs/Xserver/hw/nxagent/Screen.c
+++ b/nx-X11/programs/Xserver/hw/nxagent/Screen.c
@@ -6759,6 +6759,395 @@ static nxagentScreenCrtcsSolutions* nxagentScreenCrtcsGenerateSolutions(const nx
ret = best_ret;
+ return(ret);
+}
+
+/* Helper printing out a screen boxes list. */
+static char* nxagentPrintScreenBoxes(const nxagentScreenBoxes *boxes) {
+ char *ret = NULL;
+
+ if ((!(boxes))) {
+ return(ret);
+ }
+
+ char *construct = NULL;
+ /* FIXME: xorg_list_is_empty is not const-correct. */
+ if (xorg_list_is_empty((struct xorg_list *)(&(boxes->head)))) {
+ if (-1 == asprintf(&construct, "empty")) {
+ return(ret);
+ }
+ }
+ else {
+ size_t total_length = 512,
+ last_pos = 0;
+ construct = calloc(total_length, sizeof(char));
+
+ if (!(construct)) {
+ return(ret);
+ }
+
+ nxagentScreenBoxesElem *cur = NULL;
+ xorg_list_for_each_entry(cur, &(boxes->head), entry) {
+ char *box_str = nxagentPrintScreenBoxesElem(cur);
+
+ if (!(box_str)) {
+ SAFE_FREE(construct);
+ }
+ else {
+ const size_t box_str_raw_len = (strlen(box_str) + 1);
+
+ /* v-- implicit " -- " chars */
+ while (((box_str_raw_len + 4) + last_pos) > total_length) {
+ /* Buffer space needs to be expanded. */
+ total_length += 512;
+ char *new_construct = realloc(construct, total_length);
+
+ if (!(new_construct)) {
+ SAFE_FREE(construct);
+
+ break;
+ }
+ else {
+ construct = new_construct;
+
+ memset((construct + last_pos), 0, (total_length - last_pos));
+ }
+ }
+
+ if (construct) {
+ const size_t write_count = snprintf((construct + last_pos), (total_length - last_pos), "%s -- ", box_str);
+
+ if (0 > write_count) {
+ const int errno_save = errno;
+
+ fprintf(stderr, "%s: error writing box string representation to buffer: %s\n", __func__, strerror(errno_save));
+
+ SAFE_FREE(construct);
+ }
+ else if (write_count >= (total_length - last_pos)) {
+ fprintf(stderr, "%s: buffer was too small to hold new box string representation. Algorithm error.\n", __func__);
+
+ SAFE_FREE(construct);
+ }
+ else {
+ last_pos += write_count;
+ }
+ }
+ }
+
+ SAFE_FREE(box_str);
+
+ if (!(construct)) {
+ break;
+ }
+ }
+
+ if (construct) {
+ /* Drop the last delimiter (" -- ") character string. */
+ construct[last_pos - 4] = 0;
+ }
+ }
+
+ ret = construct;
+
+ return(ret);
+}
+
+/*
+ * Helper generating a "fake" solutions list based on the global window data.
+ *
+ * This is useful if no screens intersect the nxagent window.
+ *
+ * No pointer parameters might be NULL.
+ *
+ * On success, returns a "fake" solutions list, otherwise NULL.
+ */
+static nxagentScreenCrtcsSolutions* nxagentScreenCrtcsGenerateFakeSolutions(const nxagentScreenBoxes *all_boxes) {
+ nxagentScreenCrtcsSolutions *ret = NULL;
+
+ if (!(all_boxes)) {
+ return(ret);
+ }
+
+ ret = calloc(1, sizeof(nxagentScreenCrtcsSolutions));
+
+ if (!(ret)) {
+ return(ret);
+ }
+
+ xorg_list_init(ret);
+
+ nxagentScreenBoxes *fake_screen = calloc(1, sizeof(nxagentScreenBoxes));
+
+ if (!(fake_screen)) {
+ SAFE_FREE(ret);
+
+ return(ret);
+ }
+
+ xorg_list_init(&(fake_screen->head));
+ fake_screen->screen_id = -1;
+
+ nxagentScreenBoxesElem *fake_screen_box = calloc(1, sizeof(nxagentScreenBoxesElem));
+
+ if (!(fake_screen_box)) {
+ SAFE_FREE(fake_screen);
+
+ SAFE_FREE(ret);
+
+ return(ret);
+ }
+
+ xorg_list_init(&(fake_screen_box->entry));
+ fake_screen_box->screen_id = -1;
+
+ BoxPtr *fake_screen_box_data = calloc(1, sizeof(BoxRec));
+
+ if (!(fake_screen_box_data)) {
+ SAFE_FREE(fake_screen_box);
+
+ SAFE_FREE(fake_screen);
+
+ SAFE_FREE(ret);
+
+ return(ret);
+ }
+
+ fake_screen_box_data->x1 = fake_screen_box_data->x2 = nxagentOption(X);
+ fake_screen_box_data->y1 = fake_screen_box_data->y2 = nxagentOption(Y);
+ fake_screen_box_data->x2 += nxagentOption(Width);
+ fake_screen_box_data->y2 += nxagentOption(Height);
+
+ fake_screen_box->box = fake_screen_box_data;
+
+ xorg_list_append(&(fake_screen_box->entry), fake_screen);
+
+ nxagentScreenCrtcsSolution *solution = nxagentScreenCrtcsGenerateFakeSolution(all_boxes, fake_screen);
+
+ nxagentFreeScreenBoxes(fake_screen, TRUE);
+
+ SAFE_FREE(fake_screen);
+
+ if (!(solution)) {
+ SAFE_FREE(ret);
+
+ return(ret);
+ }
+
+ xorg_list_append(&(solution->entry), ret);
+
+ return(ret);
+}
+
+/*
+ * High-level wrapper generating a screen partition solution based upon a list
+ * of base boxes and the remote Xinerama screen information.
+ *
+ * No pointers might be NULL. screen_count might not be zero.
+ *
+ * On success, returns one specific screen partition solution, otherwise NULL.
+ */
+static nxagentScreenCrtcsSolution* nxagentMergeScreenCrtcs(nxagentScreenBoxes *boxes, const XineramaScreenInfo *screen_info, const size_t screen_count) {
+ nxagentScreenCrtcsSolution *ret = NULL;
+
+ if ((!(boxes)) || (!(screen_info)) || (!(screen_count))) {
+ return(ret);
+ }
+
+ size_t boxes_count = 0;
+ nxagentScreenBoxesElem *cur = NULL;
+ xorg_list_for_each_entry(cur, &(boxes->head), entry) {
+ ++boxes_count;
+ }
+
+ /*
+ * Step 1: consolidate boxes.
+ *
+ * Boxes might intersect with one screen, multiple screens or no screen.
+ * We will consolidate boxes on a per-screen basis, in a way such that each
+ * box will not be next to another that intersects the same screens.
+ * Overlapping screens are handled by leaving a box in place if intersected
+ * by multiple screens, if its neighbors are not also intersected by the
+ * same screens.
+ *
+ * Example:
+ *
+ * ┌─────┬──────┬─────┬─────┐
+ * │ 1 │ 1,2 │ 2 │ │
+ * ├─────┼──────┼─────┼─────┤
+ * │ 1 │ 1 │ │ │
+ * └─────┴──────┴─────┴─────┘
+ *
+ * Will/should be merged to:
+ *
+ * ┌─────┬──────┬─────┬─────┐
+ * │ 1 │ 1,2 │ 2 │ │
+ * │ └──────┼─────┼─────┤
+ * │ 1 1 │ │ │
+ * └────────────┴─────┴─────┘
+ *
+ * I.e., after the operation, these boxes will/should exist:
+ *
+ * ┌────────────┐ ┌────────────┐
+ * │ 1 │ │ 2 │
+ * │ │ └────────────┘
+ * └────────────┘
+ */
+
+ nxagentScreenBoxes *screen_boxes = calloc(screen_count, sizeof(nxagentScreenBoxes));
+
+ if (!(screen_boxes)) {
+ nxagentFreeScreenBoxes(boxes, TRUE);
+
+ return(ret);
+ }
+
+ for (size_t i = 0; i < screen_count; ++i) {
+ xorg_list_init(&((screen_boxes + i)->head));
+ }
+
+ nxagentScreenBoxes *initial_screens = calloc(1, sizeof(nxagentScreenBoxes));
+
+ if (!(initial_screens)) {
+ nxagentFreeScreenBoxes(boxes, TRUE);
+
+ return(ret);
+ }
+
+ xorg_list_init(&(initial_screens->head));
+ initial_screens->screen_id = -1;
+
+ if (!(nxagentMergeScreenBoxes(boxes, screen_boxes, screen_info, screen_count))) {
+ for (size_t i = 0; i < screen_count; ++i) {
+ nxagentFreeScreenBoxes((screen_boxes + i), TRUE);
+ }
+
+ SAFE_FREE(screen_boxes);
+
+ nxagentFreeScreenBoxes(boxes, TRUE);
+
+ return(ret);
+ }
+
+ /* Step 2: merge screen boxes into initial_screens. */
+ size_t real_screen_count = 0;
+ for (size_t i = 0; i < screen_count; ++i) {
+ /* Filter out boxes with no intersections. */
+ if (!(xorg_list_is_empty(&((screen_boxes) + i)->head))) {
+ /* If merging was successful, we should only have one box per list. */
+ nxagentScreenBoxesElem *cur = xorg_list_first_entry(&((screen_boxes + i)->head), nxagentScreenBoxesElem, entry);
+
+ /* Remove from old list. */
+ xorg_list_del(&(cur->entry));
+
+ /* Add to the other list. */
+ xorg_list_append(&(cur->entry), &(initial_screens->head));
+
+ ++real_screen_count;
+
+#ifdef WARNING
+ if (i != cur->screen_id) {
+ const unsigned long long idx = i;
+ const signed long long screen_id = cur->screen_id;
+ fprintf(stderr, "%s: internal screen id %lld doesn't match expected screen id %llu! Algorithm warning.\n", __func__, screen_id, idx);
+ }
+#endif
+ }
+ }
+
+ /* Lists should be all empty now, get rid of list heads. */
+ SAFE_FREE(screen_boxes);
+
+#ifdef DEBUG
+ fprintf(stderr, "%s: merged initial screens into initial_screens, all boxes should be correctly marked.\n", __func__);
+
+ fprintf(stderr, "%s: dumping initial_screens:\n", __func__);
+ {
+ char *initial_screens_str = nxagentPrintScreenBoxes(initial_screens);
+
+ if (initial_screens_str) {
+ fprintf(stderr, "%s: %s\n", __func__, initial_screens_str);
+ }
+ else {
+ fprintf(stderr, "%s: error!\n", __func__);
+ }
+
+ SAFE_FREE(initial_screens_str);
+ }
+
+ fprintf(stderr, "%s: dumping all boxes:\n", __func__);
+ {
+ char *boxes_str = nxagentPrintScreenBoxes(boxes);
+
+ if (boxes_str) {
+ fprintf(stderr, "%s: %s\n", __func__, boxes_str);
+ }
+ else {
+ fprintf(stderr, "%s: error!\n", __func__);
+ }
+
+ SAFE_FREE(boxes_str);
+ }
+#endif
+
+ nxagentScreenCrtcsSolutions *solutions = NULL;
+ /* Step 3: extend original screen boxes to cover the whole area. */
+ if (real_screen_count) {
+ solutions = nxagentScreenCrtcsGenerateSolutions(boxes, initial_screens, boxes_count, real_screen_count, NULL);
+ }
+ else {
+ /*
+ * No screens intersecting the window maeans that we can create a fake
+ * solution containing just one (virtual) screen and just use that one.
+ */
+ solutions = nxagentScreenCrtcsGenerateFakeSolutions(boxes);
+ }
+
+ /*
+ * Everything should be copied internally, so get rid of our original data.
+ */
+ nxagentFreeScreenBoxes(initial_screens, TRUE);
+
+ SAFE_FREE(initial_screens);
+
+ if ((!(solutions)) || (xorg_list_is_empty(solutions))) {
+ /*
+ * Invalid or empty solutions list means that something is wrong.
+ * Error out.
+ */
+#ifdef WARNING
+ fprintf(stderr, "%s: solutions list empty or invalid. Algorithm error.\n", __func__);
+#endif
+
+ nxagentScreenCrtcsFreeSolutions(solutions);
+
+ SAFE_FREE(solutions);
+
+ return(ret);
+ }
+
+ /*
+ * Step 4: select specific solution.
+ * Should be valid, checked for emptiness before. It's possible to have
+ * multiple solutions (logically with the same rating), but we have to select
+ * a specific one here.
+ * We'll use the very first one.
+ */
+ nxagentScreenCrtcsSolution *first_entry = xorg_list_first_entry(solutions, nxagentScreenCrtcsSolution, entry);
+
+ ret = nxagentScreenCrtcsSolutionCopy(first_entry);
+
+ nxagentScreenCrtcsFreeSolutions(solutions);
+
+ SAFE_FREE(solutions);
+
+ if (!(ret)) {
+#ifdef WARNING
+ fprintf(stderr, "%s: unable to copy first solution entry.\n", __func__);
+#endif
+
+ return(ret);
+ }
return(ret);
}
--
Alioth's /home/x2go-admin/maintenancescripts/git/hooks/post-receive-email on /srv/git/code.x2go.org/nx-libs.git
More information about the x2go-commits
mailing list