kbgwm

monitor.c (6410B)

---

 /*
  * kbgwm, a sucklessy floating window manager
  * Copyright (c) 2020-2021, Kebigon <git@kebigon.xyz>
  *
  * Permission to use, copy, modify, and/or distribute this software for any
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
  *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 
 #include "monitor.h"
 
 #include <stdlib.h>
 
 #include "list.h"
 #include "log.h"
 #include "xcbutils.h"
 
 extern xcb_connection_t *c;
 extern xcb_screen_t *screen;
 extern const uint_least8_t workspaces_length;
 extern struct item *workspaces[];
 
 int_least16_t randr_base = -1;
 struct item *monitors;
 
 void monitor_add(xcb_randr_output_t, int16_t, int16_t, uint16_t, uint16_t);
 struct item *monitor_find_by_id(const xcb_randr_output_t);
 
 void setup_monitors()
 {
     const xcb_query_extension_reply_t *extension = xcb_get_extension_data(c, &xcb_randr_id);
     if (!extension->present)
     {
         LOG_WARN("Unable to retrieve the RANDR extension");
         return;
     }
 
     monitors_refresh_config();
 
     randr_base = extension->first_event;
     xcb_randr_select_input(
         c, screen->root,
         XCB_RANDR_NOTIFY_MASK_SCREEN_CHANGE | XCB_RANDR_NOTIFY_MASK_OUTPUT_CHANGE |
             XCB_RANDR_NOTIFY_MASK_CRTC_CHANGE | XCB_RANDR_NOTIFY_MASK_OUTPUT_PROPERTY);
 }
 
 void monitor_add(xcb_randr_output_t id, int16_t x, int16_t y, uint16_t width, uint16_t height)
 {
     LOG_DEBUG_VA("monitor_add: id=%d, x=%d, y=%d, width=%d, height=%d", id, x, y, width, height);
 
     struct monitor *monitor = emalloc(sizeof(struct monitor));
     monitor->id = id;
     monitor->x = x;
     monitor->y = y;
     monitor->width = width;
     monitor->height = height;
 
     list_add(&monitors, monitor);
 }
 
 void monitor_update(struct monitor *monitor, xcb_randr_get_crtc_info_reply_t *crtc)
 {
     if (crtc->x != monitor->x)
         monitor->x = crtc->x;
     if (crtc->y != monitor->y)
         monitor->y = crtc->y;
     if (crtc->width != monitor->width)
         monitor->width = crtc->width;
     if (crtc->height != monitor->height)
         monitor->height = crtc->height;
 
     // TODO: rearrange clients
 }
 
 void monitor_delete(struct item *mon_item)
 {
     // Replace the deleted by the next one, or the first one
     struct monitor *new_mon = (mon_item->next != NULL ? mon_item->next : monitors)->data;
     struct monitor *monitor = list_remove(&monitors, mon_item);
 
     struct client *client;
     struct item *cli_item;
 
     // move clients to another monitor
     for (uint_fast8_t workspace = 0; workspace != workspaces_length; workspace++)
     {
         for (cli_item = workspaces[workspace]; cli_item != NULL; cli_item = cli_item->next)
         {
             client = cli_item->data;
 
             // Not the removed monitor
             if (client->monitor->id != monitor->id)
                 continue;
 
             client->monitor = new_mon;
             client->x = new_mon->x;
             client->y = new_mon->y;
 
             // Sanitize
             client_sanitize_position(client);
             client_sanitize_dimensions(client);
         }
     }
 }
 
 void monitors_refresh_config()
 {
     const xcb_randr_get_screen_resources_current_cookie_t cookie =
         xcb_randr_get_screen_resources_current(c, screen->root);
     xcb_randr_get_screen_resources_current_reply_t *res =
         xcb_randr_get_screen_resources_current_reply(c, cookie, NULL);
     if (NULL == res)
     {
         LOG_WARN("Unable to retrieve the RANDR screen resources");
         return;
     }
 
     int32_t len = xcb_randr_get_screen_resources_current_outputs_length(res);
     xcb_randr_output_t *outputs = xcb_randr_get_screen_resources_current_outputs(res);
 
     int_fast32_t i;
 
     // Request information for all outputs.
     xcb_randr_get_output_info_cookie_t ocookie[len];
     for (i = 0; i != len; i++)
     {
         ocookie[i] = xcb_randr_get_output_info(c, outputs[i], res->config_timestamp);
     }
 
     xcb_randr_get_output_info_reply_t *info;
     xcb_randr_get_crtc_info_reply_t *crtc;
     struct item *item;
 
     // Process information replies
     for (i = 0; i != len; i++)
     {
         info = xcb_randr_get_output_info_reply(c, ocookie[i], NULL);
         if (info == NULL)
             continue;
 
         // Disabled / disconnected output
         if (info->crtc == XCB_NONE || info->connection == XCB_RANDR_CONNECTION_DISCONNECTED)
         {
             // Already registered monitor -> delete it
             if ((item = monitor_find_by_id(outputs[i])) != NULL)
             {
                 monitor_delete(item);
             }
 
             continue;
         }
 
         crtc = xcb_randr_get_crtc_info_reply(
             c, xcb_randr_get_crtc_info(c, info->crtc, res->config_timestamp), NULL);
 
         // CRTC info not found -> skipping
         if (crtc == NULL)
             continue;
 
         // Already registered monitor -> update it
         if ((item = monitor_find_by_id(outputs[i])) != NULL)
         {
             monitor_update(item->data, crtc);
         }
         // New monitor -> add it to the list
         else
         {
             monitor_add(outputs[i], crtc->x, crtc->y, crtc->width, crtc->height);
         }
 
         free(crtc);
         free(info);
     }
 
     free(res);
 }
 
 bool monitor_contains(struct monitor *monitor, uint16_t x, uint16_t y)
 {
     return monitor->x <= x && x <= monitor->x + monitor->width && //
            monitor->y <= y && y <= monitor->y + monitor->height;
 }
 
 // Find a monitor from its id
 struct item *monitor_find_by_id(const xcb_randr_output_t id)
 {
     for (struct item *item = monitors; item != NULL; item = item->next)
         if (((struct monitor *)item->data)->id == id)
             return item;
 
     return NULL;
 }
 
 struct item *monitor_find_by_position(const uint16_t x, const uint16_t y)
 {
     for (struct item *item = monitors; item != NULL; item = item->next)
         if (monitor_contains(item->data, x, y))
             return item;
 
     return NULL;
 }