void QXcbScreen::updateGeometry(xcb_timestamp_t timestamp) { if (connection()->hasXRandr()) { xcb_randr_get_crtc_info_reply_t *crtc = xcb_randr_get_crtc_info_reply(xcb_connection(), xcb_randr_get_crtc_info_unchecked(xcb_connection(), m_crtc, timestamp), NULL); if (crtc) { m_geometry = QRect(crtc->x, crtc->y, crtc->width, crtc->height); m_availableGeometry = m_geometry; free(crtc); } } xcb_get_property_reply_t * workArea = xcb_get_property_reply(xcb_connection(), xcb_get_property_unchecked(xcb_connection(), false, screen()->root, atom(QXcbAtom::_NET_WORKAREA), XCB_ATOM_CARDINAL, 0, 1024), NULL); if (workArea && workArea->type == XCB_ATOM_CARDINAL && workArea->format == 32 && workArea->value_len >= 4) { // If workArea->value_len > 4, the remaining ones seem to be for virtual desktops. // But QScreen doesn't know about that concept. In reality there could be a // "docked" panel (with _NET_WM_STRUT_PARTIAL atom set) on just one desktop. // But for now just assume the first 4 values give us the geometry of the // "work area", AKA "available geometry" uint32_t *geom = (uint32_t*)xcb_get_property_value(workArea); QRect virtualAvailableGeometry(geom[0], geom[1], geom[2], geom[3]); // Take the intersection of the desktop's available geometry with this screen's geometry // to get the part of the available geometry which belongs to this screen. m_availableGeometry = m_geometry & virtualAvailableGeometry; } free(workArea); }
std::vector<std::shared_ptr<monitor_t>> get_list(xcb_connection_t *connection, xcb_window_t root) { std::vector<std::shared_ptr<monitor_t>> monitors; xcb_randr_get_screen_resources_reply_t *sres = xcb_randr_get_screen_resources_reply(connection, xcb_randr_get_screen_resources(connection, root), nullptr); if (sres == nullptr) return monitors; int len = xcb_randr_get_screen_resources_outputs_length(sres); xcb_randr_output_t *outputs = xcb_randr_get_screen_resources_outputs(sres); for (int i = 0; i < len; i++) { xcb_randr_get_output_info_cookie_t cookie = xcb_randr_get_output_info(connection, outputs[i], XCB_CURRENT_TIME); xcb_randr_get_output_info_reply_t *info = xcb_randr_get_output_info_reply(connection, cookie, nullptr); xcb_randr_get_output_info(connection, outputs[i], XCB_CURRENT_TIME); if (info == nullptr) continue; if (info->crtc == XCB_NONE) { free(info); continue; } xcb_randr_get_crtc_info_reply_t *cir = xcb_randr_get_crtc_info_reply(connection, xcb_randr_get_crtc_info(connection, info->crtc, XCB_CURRENT_TIME), nullptr); if (cir == nullptr) { free(info); continue; } char *monitor_name = (char *) xcb_randr_get_output_info_name(info); monitors.emplace_back(make_object(monitor_name, info->name_len, i, {cir->x, cir->y, cir->width, cir->height})); free(cir); } std::sort(monitors.begin(), monitors.end(), [](std::shared_ptr<monitor_t> m1, std::shared_ptr<monitor_t> m2) -> bool { if (m1->bounds.x < m2->bounds.x || m1->bounds.y + m1->bounds.height <= m2->bounds.y) return 1; if (m1->bounds.x > m2->bounds.x || m1->bounds.y + m1->bounds.height > m2->bounds.y) return -1; return 0; }); return monitors; }
xcb_randr_get_crtc_info_reply_t * get_output_crtc_info(xcb_connection_t * conn, xcb_randr_crtc_t crtc) { xcb_randr_get_crtc_info_cookie_t cic; cic = xcb_randr_get_crtc_info(conn, crtc, 0); xcb_randr_get_crtc_info_reply_t *crtc_info_reply; crtc_info_reply = xcb_randr_get_crtc_info_reply(conn, cic, NULL); return crtc_info_reply; }
/* * Initialize RandR and obtain current monitors */ static int ya_init_randr() { xcb_randr_get_screen_resources_current_reply_t *res_reply; res_reply = xcb_randr_get_screen_resources_current_reply(ya.c, xcb_randr_get_screen_resources_current(ya.c, ya.scr->root), NULL); if (!res_reply) { return -1; //just report error } int mon_num = xcb_randr_get_screen_resources_current_outputs_length(res_reply); xcb_randr_output_t *ops = xcb_randr_get_screen_resources_current_outputs(res_reply); xcb_randr_get_output_info_reply_t *op_reply; xcb_randr_get_crtc_info_reply_t *crtc_reply; ya_monitor_t *tmpmon; char *tname; int tname_len; for (int i=0; i < mon_num; i++) { op_reply = xcb_randr_get_output_info_reply(ya.c, xcb_randr_get_output_info(ya.c, ops[i], XCB_CURRENT_TIME), NULL); if (op_reply->crtc == XCB_NONE) continue; crtc_reply = xcb_randr_get_crtc_info_reply(ya.c, xcb_randr_get_crtc_info(ya.c, op_reply->crtc, XCB_CURRENT_TIME), NULL); if(!crtc_reply) continue; tmpmon = calloc(1, sizeof(ya_monitor_t)); tmpmon->pos = (xcb_rectangle_t){crtc_reply->x, crtc_reply->y, crtc_reply->width, crtc_reply->height}; tname = (char *)xcb_randr_get_output_info_name(op_reply); tname_len = xcb_randr_get_output_info_name_length(op_reply); strncpy(tmpmon->name, tname, tname_len); tmpmon->name[CMONLEN-1] = '\0'; if (ya.curmon) { ya.curmon->next_mon = tmpmon; tmpmon->prev_mon = ya.curmon; } ya.curmon = tmpmon; //printf("%s %d %d %d %d %d\n", tmpmon->name, tname_len, tmpmon->pos.x, // tmpmon->pos.y, tmpmon->pos.width, tmpmon->pos.height); } return 0; }
static gboolean _eventd_nd_xcb_randr_check_primary(EventdNdBackendContext *self) { xcb_randr_get_output_primary_cookie_t pcookie; xcb_randr_get_output_primary_reply_t *primary; pcookie = xcb_randr_get_output_primary(self->xcb_connection, self->screen->root); if ( ( primary = xcb_randr_get_output_primary_reply(self->xcb_connection, pcookie, NULL) ) == NULL ) return FALSE; gboolean found = FALSE; xcb_randr_get_output_info_cookie_t ocookie; xcb_randr_get_output_info_reply_t *output; ocookie = xcb_randr_get_output_info(self->xcb_connection, primary->output, 0); if ( ( output = xcb_randr_get_output_info_reply(self->xcb_connection, ocookie, NULL) ) != NULL ) { xcb_randr_get_crtc_info_cookie_t ccookie; xcb_randr_get_crtc_info_reply_t *crtc; ccookie = xcb_randr_get_crtc_info(self->xcb_connection, output->crtc, output->timestamp); if ( ( crtc = xcb_randr_get_crtc_info_reply(self->xcb_connection, ccookie, NULL) ) != NULL ) { found = TRUE; self->geometry.x = crtc->x; self->geometry.y = crtc->y; self->geometry.w = crtc->width; self->geometry.h = crtc->height; free(crtc); } free(output); } free(primary); return found; }
bool randr(void) { if (!xcb_get_extension_data(cfg.conn, &xcb_randr_id)->present) { warn("randr is not present\n"); return false; } const xcb_randr_get_screen_resources_cookie_t cookie = xcb_randr_get_screen_resources_unchecked(cfg.conn, cfg.screen->root); xcb_randr_get_screen_resources_reply_t *reply = xcb_randr_get_screen_resources_reply(cfg.conn, cookie, (void *)0); if (!reply) return false; const xcb_randr_crtc_t *info = xcb_randr_get_screen_resources_crtcs(reply); PRINTF("randr num crtcs: %u\n", reply->num_crtcs); xcb_randr_get_crtc_info_cookie_t cookies[reply->num_crtcs]; for (uint16_t crtc = 0; crtc < reply->num_crtcs; crtc++) cookies[crtc] = xcb_randr_get_crtc_info_unchecked(cfg.conn, info[crtc], XCB_CURRENT_TIME); for (uint16_t crtc = 0; crtc < reply->num_crtcs; crtc++) { xcb_randr_get_crtc_info_reply_t *reply = xcb_randr_get_crtc_info_reply(cfg.conn, cookies[crtc], (void *)0); if (!reply) continue; PRINTF("adding crtc: %u\n", crtc); monitor_add(reply->x, reply->y, reply->width, reply->height); free(reply); } free(reply); return true; }
/* * Get RANDR resources and figure out how many outputs there are. */ void randr_get(xcb_connection_t * conn,xcb_screen_t * screen) { xcb_randr_get_screen_resources_current_cookie_t rcookie; xcb_randr_get_screen_resources_current_reply_t *res; xcb_randr_output_t *outputs; int len; xcb_timestamp_t timestamp; rcookie = xcb_randr_get_screen_resources_current(conn, screen->root); res = xcb_randr_get_screen_resources_current_reply(conn, rcookie, NULL); if (NULL == res) { printf("No RANDR extension available.\n"); return; } timestamp = res->config_timestamp; len = xcb_randr_get_screen_resources_current_outputs_length(res); outputs = xcb_randr_get_screen_resources_current_outputs(res); free(res); PDEBUG("Found %d outputs.\n", len); /* Request information for all outputs. */ char *name; xcb_randr_get_crtc_info_cookie_t icookie; xcb_randr_get_crtc_info_reply_t *crtc = NULL; xcb_randr_get_output_info_reply_t *output; struct monitor *mon; struct monitor *clonemon; xcb_randr_get_output_info_cookie_t ocookie[len]; int i; for (i = 0; i < len; i++) { ocookie[i] = xcb_randr_get_output_info(conn, outputs[i], timestamp); } /* Loop through all outputs. */ for (i = 0; i < len; i ++) { output = xcb_randr_get_output_info_reply(conn, ocookie[i], NULL); if (output == NULL) { continue; } asprintf(&name, "%.*s", xcb_randr_get_output_info_name_length(output), xcb_randr_get_output_info_name(output)); PDEBUG("Name: %s\n", name); PDEBUG("id: %d\n" , outputs[i]); PDEBUG("Size: %d x %d mm.\n", output->mm_width, output->mm_height); if (XCB_NONE != output->crtc) { icookie = xcb_randr_get_crtc_info(conn, output->crtc, timestamp); crtc = xcb_randr_get_crtc_info_reply(conn, icookie, NULL); if (NULL == crtc) { return; } PDEBUG("CRTC: at %d, %d, size: %d x %d.\n", crtc->x, crtc->y, crtc->width, crtc->height); /* Check if it's a clone. */ clonemon = findclones(outputs[i], crtc->x, crtc->y); if (NULL != clonemon) { PDEBUG("Monitor %s, id %d is a clone of %s, id %d. Skipping.\n", name, outputs[i], clonemon->name, clonemon->id); continue; } /* Do we know this monitor already? */ if (NULL == (mon = findmonitor(outputs[i]))) { PDEBUG("Monitor not known, adding to list.\n"); addmonitor(outputs[i], name, crtc->x, crtc->y, crtc->width, crtc->height); } else { bool changed = false; /* * We know this monitor. Update information. If it's * smaller than before, rearrange windows. */ PDEBUG("Known monitor. Updating info.\n"); if (crtc->x != mon->x) { mon->x = crtc->x; changed = true; } if (crtc->y != mon->y) { mon->y = crtc->y; changed = true; } if (crtc->width != mon->width) { mon->width = crtc->width; changed = true; } if (crtc->height != mon->height) { mon->height = crtc->height; changed = true; } if (changed) { arrbymon(mon); } } free(crtc); } else { PDEBUG("Monitor not used at the moment.\n"); /* * Check if it was used before. If it was, do something. */ if ((mon = findmonitor(outputs[i]))) { struct item *item; struct client *client; /* Check all windows on this monitor and move them to * the next or to the first monitor if there is no * next. * * FIXME: Use per monitor workspace list instead of * global window list. */ for (item = winlist; item != NULL; item = item->next) { client = item->data; if (client->monitor == mon) { if (NULL == client->monitor->item->next) { if (NULL == monlist) { client->monitor = NULL; } else { client->monitor = monlist->data; } } else { client->monitor = client->monitor->item->next->data; } fitonscreen(client); } } /* for */ /* It's not active anymore. Forget about it. */ delmonitor(mon); } } free(output); } /* for */ }
bool import_monitors(void) { PUTS("import monitors"); xcb_randr_get_screen_resources_current_reply_t *sres = xcb_randr_get_screen_resources_current_reply(dpy, xcb_randr_get_screen_resources_current(dpy, root), NULL); if (sres == NULL) return false; monitor_t *m, *mm = NULL; int len = xcb_randr_get_screen_resources_current_outputs_length(sres); xcb_randr_output_t *outputs = xcb_randr_get_screen_resources_current_outputs(sres); xcb_randr_get_output_info_cookie_t cookies[len]; for (int i = 0; i < len; i++) cookies[i] = xcb_randr_get_output_info(dpy, outputs[i], XCB_CURRENT_TIME); for (m = mon_head; m != NULL; m = m->next) m->wired = false; for (int i = 0; i < len; i++) { xcb_randr_get_output_info_reply_t *info = xcb_randr_get_output_info_reply(dpy, cookies[i], NULL); if (info != NULL) { if (info->crtc != XCB_NONE) { xcb_randr_get_crtc_info_reply_t *cir = xcb_randr_get_crtc_info_reply(dpy, xcb_randr_get_crtc_info(dpy, info->crtc, XCB_CURRENT_TIME), NULL); if (cir != NULL) { xcb_rectangle_t rect = (xcb_rectangle_t) {cir->x, cir->y, cir->width, cir->height}; mm = get_monitor_by_id(outputs[i]); if (mm != NULL) { mm->rectangle = rect; update_root(mm); for (desktop_t *d = mm->desk_head; d != NULL; d = d->next) for (node_t *n = first_extrema(d->root); n != NULL; n = next_leaf(n, d->root)) translate_client(mm, mm, n->client); arrange(mm, mm->desk); mm->wired = true; PRINTF("update monitor %s (0x%X)\n", mm->name, mm->id); } else { mm = add_monitor(rect); char *name = (char *)xcb_randr_get_output_info_name(info); size_t name_len = MIN(sizeof(mm->name), (size_t)xcb_randr_get_output_info_name_length(info) + 1); snprintf(mm->name, name_len, "%s", name); mm->id = outputs[i]; PRINTF("add monitor %s (0x%X)\n", mm->name, mm->id); } } free(cir); } else if (!remove_disabled_monitor && info->connection != XCB_RANDR_CONNECTION_DISCONNECTED) { m = get_monitor_by_id(outputs[i]); if (m != NULL) m->wired = true; } } free(info); } /* initially focus the primary monitor and add the first desktop to it */ xcb_randr_get_output_primary_reply_t *gpo = xcb_randr_get_output_primary_reply(dpy, xcb_randr_get_output_primary(dpy, root), NULL); if (gpo != NULL) { pri_mon = get_monitor_by_id(gpo->output); if (!running && pri_mon != NULL) { if (mon != pri_mon) mon = pri_mon; add_desktop(pri_mon, make_desktop(NULL)); ewmh_update_current_desktop(); } } free(gpo); /* handle overlapping monitors */ m = mon_head; while (m != NULL) { monitor_t *next = m->next; if (m->wired) { for (monitor_t *mb = mon_head; mb != NULL; mb = mb->next) if (mb != m && mb->wired && (m->desk == NULL || mb->desk == NULL) && contains(mb->rectangle, m->rectangle)) { if (mm == m) mm = mb; merge_monitors(m, mb); remove_monitor(m); break; } } m = next; } /* merge and remove disconnected monitors */ m = mon_head; while (m != NULL) { monitor_t *next = m->next; if (!m->wired) { merge_monitors(m, mm); remove_monitor(m); } m = next; } /* add one desktop to each new monitor */ for (m = mon_head; m != NULL; m = m->next) if (m->desk == NULL && (running || pri_mon == NULL || m != pri_mon)) add_desktop(m, make_desktop(NULL)); free(sres); update_motion_recorder(); return (num_monitors > 0); }
/* @brief Attempts to find secondary displays and updates settings.screen_* data * with the dimensions of the found screens. * * Note: failure is somewhat expected and is handled by simply using the default * xcb screen's dimension parameters. * * @param connection A connection to the Xorg server. * @param screen A screen created by xcb's xcb_setup_roots function. * @return 0 on success and 1 on failure. */ static int32_t get_multiscreen_settings(xcb_connection_t *connection, xcb_screen_t *screen) { /* First check randr. */ const xcb_query_extension_reply_t *extension_reply = xcb_get_extension_data(connection, &xcb_randr_id); if (extension_reply && extension_reply->present) { debug("Found randr support, searching for displays.\n"); /* Find x, y and width, height. */ xcb_randr_get_screen_resources_current_reply_t *randr_reply = xcb_randr_get_screen_resources_current_reply(connection, xcb_randr_get_screen_resources_current(connection, screen->root), NULL); if (!randr_reply) { fprintf(stderr, "Failed to get randr set up.\n"); } else { int32_t num_outputs = xcb_randr_get_screen_resources_current_outputs_length(randr_reply); if (num_outputs < settings.screen) { fprintf(stderr, "Screen selected not found.\n"); /* Default back to the first screen. */ settings.screen = 0; } xcb_randr_output_t *outputs = xcb_randr_get_screen_resources_current_outputs(randr_reply); uint32_t output_index = settings.screen; xcb_randr_get_output_info_reply_t *randr_output = NULL; do { if (randr_output) { free(randr_output); } randr_output = xcb_randr_get_output_info_reply(connection, xcb_randr_get_output_info(connection, outputs[output_index], XCB_CURRENT_TIME), NULL); output_index++; } while ((randr_output->connection != XCB_RANDR_CONNECTION_CONNECTED) && (output_index < num_outputs)); if (randr_output) { xcb_randr_get_crtc_info_reply_t *randr_crtc = xcb_randr_get_crtc_info_reply(connection, xcb_randr_get_crtc_info(connection, randr_output->crtc, XCB_CURRENT_TIME), NULL); if (!randr_crtc) { fprintf(stderr, "Unable to connect to randr crtc\n"); free(randr_output); free(randr_reply); goto xinerama; } settings.screen_width = randr_crtc->width; settings.screen_height = randr_crtc->height; settings.screen_x = randr_crtc->x; settings.screen_y = randr_crtc->y; debug("randr screen initialization successful, x: %u y: %u w: %u h: %u.\n", settings.screen_x, settings.screen_y, settings.screen_width, settings.screen_height); free(randr_crtc); free(randr_output); free(randr_reply); return 0; } free(randr_output); free(randr_reply); } } xinerama: debug("Did not find randr support, attempting xinerama\n"); /* Still here? Let's try xinerama! */ extension_reply = xcb_get_extension_data(connection, &xcb_xinerama_id); if (extension_reply && extension_reply->present) { debug("Found xinerama support, searching for displays.\n"); xcb_xinerama_is_active_reply_t *xinerama_is_active_reply = xcb_xinerama_is_active_reply(connection, xcb_xinerama_is_active(connection), NULL); if (xinerama_is_active_reply && xinerama_is_active_reply->state) { free(xinerama_is_active_reply); /* Find x, y and width, height. */ xcb_xinerama_query_screens_reply_t *screen_reply = xcb_xinerama_query_screens_reply(connection, xcb_xinerama_query_screens_unchecked(connection), NULL); xcb_xinerama_screen_info_iterator_t iter = xcb_xinerama_query_screens_screen_info_iterator(screen_reply); free(screen_reply); if (iter.rem < settings.screen) { fprintf(stderr, "Screen selected not found.\n"); /* Default back to the first screen. */ settings.screen = 0; } /* Jump to the appropriate screen. */ int32_t i = 0; while (i < settings.screen) { xcb_xinerama_screen_info_next(&iter); i++; } settings.screen_width = iter.data->width; settings.screen_height = iter.data->height; settings.screen_x = iter.data->x_org; settings.screen_y = iter.data->y_org; debug("xinerama screen initialization successful, x: %u y: %u w: %u h: %u.\n", settings.screen_x, settings.screen_y, settings.screen_width, settings.screen_height); return 0; } } debug("Multiscreen search failed.\n"); return 1; }
bool update_monitors(void) { xcb_randr_get_screen_resources_reply_t *sres = xcb_randr_get_screen_resources_reply(dpy, xcb_randr_get_screen_resources(dpy, root), NULL); if (sres == NULL) { return false; } monitor_t *m, *mm = NULL; int len = xcb_randr_get_screen_resources_outputs_length(sres); xcb_randr_output_t *outputs = xcb_randr_get_screen_resources_outputs(sres); xcb_randr_get_output_info_cookie_t cookies[len]; for (int i = 0; i < len; i++) { cookies[i] = xcb_randr_get_output_info(dpy, outputs[i], XCB_CURRENT_TIME); } for (m = mon_head; m != NULL; m = m->next) { m->wired = false; } for (int i = 0; i < len; i++) { xcb_randr_get_output_info_reply_t *info = xcb_randr_get_output_info_reply(dpy, cookies[i], NULL); if (info != NULL) { if (info->crtc != XCB_NONE) { xcb_randr_get_crtc_info_reply_t *cir = xcb_randr_get_crtc_info_reply(dpy, xcb_randr_get_crtc_info(dpy, info->crtc, XCB_CURRENT_TIME), NULL); if (cir != NULL) { xcb_rectangle_t rect = (xcb_rectangle_t) {cir->x, cir->y, cir->width, cir->height}; mm = get_monitor_by_randr_id(outputs[i]); if (mm != NULL) { update_root(mm, &rect); mm->wired = true; } else { mm = make_monitor(&rect, XCB_NONE); char *name = (char *)xcb_randr_get_output_info_name(info); int len = xcb_randr_get_output_info_name_length(info); size_t name_size = MIN(sizeof(mm->name), (size_t) len + 1); snprintf(mm->name, name_size, "%s", name); mm->randr_id = outputs[i]; add_monitor(mm); } } free(cir); } else if (!remove_disabled_monitors && info->connection != XCB_RANDR_CONNECTION_DISCONNECTED) { m = get_monitor_by_randr_id(outputs[i]); if (m != NULL) { m->wired = true; } } } free(info); } xcb_randr_get_output_primary_reply_t *gpo = xcb_randr_get_output_primary_reply(dpy, xcb_randr_get_output_primary(dpy, root), NULL); if (gpo != NULL) { pri_mon = get_monitor_by_randr_id(gpo->output); } free(gpo); /* handle overlapping monitors */ if (merge_overlapping_monitors) { m = mon_head; while (m != NULL) { monitor_t *next = m->next; if (m->wired) { monitor_t *mb = mon_head; while (mb != NULL) { monitor_t *mb_next = mb->next; if (m != mb && mb->wired && contains(m->rectangle, mb->rectangle)) { if (mm == mb) { mm = m; } if (next == mb) { next = mb_next; } merge_monitors(mb, m); remove_monitor(mb); } mb = mb_next; } } m = next; } } /* merge and remove disconnected monitors */ if (remove_unplugged_monitors) { m = mon_head; while (m != NULL) { monitor_t *next = m->next; if (!m->wired) { merge_monitors(m, mm); remove_monitor(m); } m = next; } } /* add one desktop to each new monitor */ for (m = mon_head; m != NULL; m = m->next) { if (m->desk == NULL) { add_desktop(m, make_desktop(NULL, XCB_NONE)); } } if (!running && mon != NULL) { if (pri_mon != NULL) { mon = pri_mon; } center_pointer(mon->rectangle); ewmh_update_current_desktop(); } free(sres); return (mon != NULL); }
static gboolean _eventd_nd_xcb_randr_check_outputs(EventdNdBackendContext *self) { if ( ( self->follow_focus == EVENTD_ND_XCB_FOLLOW_FOCUS_NONE ) && ( self->outputs == NULL ) ) return FALSE; xcb_randr_get_screen_resources_current_cookie_t rcookie; xcb_randr_get_screen_resources_current_reply_t *ressources; rcookie = xcb_randr_get_screen_resources_current(self->xcb_connection, self->screen->root); if ( ( ressources = xcb_randr_get_screen_resources_current_reply(self->xcb_connection, rcookie, NULL) ) == NULL ) { g_warning("Couldn't get RandR screen ressources"); return FALSE; } xcb_timestamp_t cts; xcb_randr_output_t *randr_outputs; gint i, length; cts = ressources->config_timestamp; length = xcb_randr_get_screen_resources_current_outputs_length(ressources); randr_outputs = xcb_randr_get_screen_resources_current_outputs(ressources); EventdNdXcbRandrOutput outputs[length + 1]; EventdNdXcbRandrOutput *output; output = outputs; for ( i = 0 ; i < length ; ++i ) { xcb_randr_get_output_info_cookie_t ocookie; ocookie = xcb_randr_get_output_info(self->xcb_connection, randr_outputs[i], cts); if ( ( output->output = xcb_randr_get_output_info_reply(self->xcb_connection, ocookie, NULL) ) == NULL ) continue; xcb_randr_get_crtc_info_cookie_t ccookie; ccookie = xcb_randr_get_crtc_info(self->xcb_connection, output->output->crtc, cts); if ( ( output->crtc = xcb_randr_get_crtc_info_reply(self->xcb_connection, ccookie, NULL) ) == NULL ) free(output->output); else ++output; } output->output = NULL; gboolean found; if ( self->follow_focus != EVENTD_ND_XCB_FOLLOW_FOCUS_NONE ) found = _eventd_nd_xcb_randr_check_focused(self, outputs); else found = _eventd_nd_xcb_randr_check_config_outputs(self, outputs); for ( output = outputs ; output->output != NULL ; ++output ) { free(output->crtc); free(output->output); } return found; }
bool ScreenManager::scanRandR(xcb_connection_t *conn) { if (!configureRandR(conn)) { LOG_ERROR("RandR extension not found."); return false; } xcb_randr_get_screen_resources_current_reply_t *res = xcb_randr_get_screen_resources_current_reply(conn, xcb_randr_get_screen_resources_current(conn, _rootWindow), NULL); if (!res) { LOG_ERROR("Failed to retrieve screen resources by RandR."); return false; } int length = xcb_randr_get_screen_resources_current_outputs_length(res); xcb_randr_output_t *outputs = xcb_randr_get_screen_resources_current_outputs(res); std::vector<xcb_randr_get_output_info_cookie_t> cookies; xcb_randr_get_output_info_reply_t *output_info; xcb_randr_get_crtc_info_reply_t *crtc; char *output_name; if (length == 0) { LOG_ERROR("No screen found using RandR."); return false; } else { LOG_INFO("Found %d screen(s).", length); } for (int i = 0; i < length; i++) { cookies.push_back(xcb_randr_get_output_info(conn, outputs[i], res->config_timestamp)); } for (auto iter = cookies.begin(); iter != cookies.end(); ++iter) { output_info = xcb_randr_get_output_info_reply(conn, *iter, NULL); if (output_info == NULL) { continue; } asprintf(&output_name, "%.*s", xcb_randr_get_output_info_name_length(output_info), xcb_randr_get_output_info_name(output_info)); Screen s; s.setName(output_name); free(output_name); if (output_info->crtc == XCB_NONE) { LOG_INFO(" Screen %s is disabled.", s.getName().c_str()); continue; } crtc = xcb_randr_get_crtc_info_reply(conn, xcb_randr_get_crtc_info( conn, output_info->crtc, res->config_timestamp), NULL); if (!crtc) { LOG_ERROR("Failed to retrieve CRTC on screen %s.", s.getName().c_str()); return 0; } s.setX(crtc->x); s.setY(crtc->y); s.setWidth(crtc->width); s.setHeight(crtc->height); updateScreen(s); free(crtc); free(output_info); } free(res); return true; }