kbgwm

kbgwm.c (9521B)

---

 /*
  * 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 "kbgwm.h"
 #include "events.h"
 #include "list.h"
 #include "log.h"
 #include "monitor.h"
 #include "xcbutils.h"
 #include <X11/keysym.h>
 #include <assert.h>
 #include <inttypes.h>
 #include <math.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <xcb/xcb.h>
 #include <xcb/xcb_icccm.h>
 
 #include "config.h"
 
 bool running = true;
 bool moving = false;
 bool resizing = false;
 xcb_connection_t *c;
 xcb_screen_t *screen;
 uint_least16_t previous_x;
 uint_least16_t previous_y;
 uint16_t numlockmask = 0;
 xcb_atom_t wm_protocols;
 xcb_atom_t wm_delete_window;
 
 uint_fast8_t current_workspace = 0;
 struct item *workspaces[NB_WORKSPACES];
 
 void mousemove(__attribute__((unused)) const union Arg *arg)
 {
     LOG_DEBUG("=======[ user action: mousemove ]=======");
     moving = true;
 
     xcb_grab_pointer(
         c, 0, screen->root, XCB_EVENT_MASK_BUTTON_MOTION | XCB_EVENT_MASK_BUTTON_RELEASE,
         XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC, screen->root, XCB_NONE, XCB_CURRENT_TIME);
     xcb_flush(c);
 }
 
 void mouseresize(__attribute__((unused)) const union Arg *arg)
 {
     LOG_DEBUG("=======[ user action: mouseresize ]=======");
     resizing = true;
 
     xcb_grab_pointer(
         c, 0, screen->root, XCB_EVENT_MASK_BUTTON_MOTION | XCB_EVENT_MASK_BUTTON_RELEASE,
         XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC, screen->root, XCB_NONE, XCB_CURRENT_TIME);
     xcb_flush(c);
 }
 
 void eventLoop()
 {
     xcb_generic_event_t *event;
 
     while (running)
     {
         if ((event = xcb_wait_for_event(c)) != NULL)
         {
             log_debug_event(event);
 
             handle_event(event);
 
             free(event);
             LOG_DEBUG("=======[ event: DONE ]=======\n");
         }
     }
 }
 
 void start(const union Arg *arg)
 {
     LOG_DEBUG("=======[ user action: start ]=======");
     LOG_DEBUG_VA("cmd %s", arg->cmd[0]);
 
     if (fork() == 0)
     {
         // Child process
         setsid();
 
         if (execvp((char *)arg->cmd[0], (char **)arg->cmd) == -1)
         {
             perror(arg->cmd[0]);
             exit(-1);
         }
     }
 }
 
 /*
  * Focus
  */
 
 void focus_apply()
 {
     struct item *item = list_head(&workspaces[current_workspace]);
     assert(item != NULL);
 
     struct client *client = item->data;
 
     // We change the color of the focused client
     xcb_change_window_attributes(c, client->id, XCB_CW_BORDER_PIXEL,
                                  (uint32_t[]){0xFF000000 | FOCUS_COLOR});
 
     // Raise the window so it is on top
     xcb_configure_window(c, client->id, XCB_CONFIG_WINDOW_STACK_MODE,
                          (uint32_t[]){XCB_STACK_MODE_ABOVE});
 
     // Set the keyboard on the focused window
     xcb_set_input_focus(c, XCB_INPUT_FOCUS_POINTER_ROOT, client->id, XCB_CURRENT_TIME);
     client_grab_buttons(client, true);
     xcb_flush(c);
 
     LOG_DEBUG("focus_apply: done");
 }
 
 // Focus the next client in the current workspace list
 // arg->b : reverse mode
 void focus_next(const union Arg *arg)
 {
     LOG_DEBUG("=======[ user action: focus_next ]=======");
     struct item **workspace = &workspaces[current_workspace];
 
     // No clients in the current workspace list
     // Only one client in the current workspace list
     if (list_is_empty(workspace) || list_head(workspace)->next == NULL)
         return; // Nothing to be done
 
     focus_unfocus();
 
     if (arg->b)
         list_move_to_head(workspace, list_tail(workspace));
     else
         list_move_to_tail(workspace, list_head(workspace));
 
     focus_apply();
 }
 
 // Remove the focus from the current client
 void focus_unfocus()
 {
     struct item *item = list_head(&workspaces[current_workspace]);
 
     // No client are focused
     if (item == NULL)
         return; // Nothing to be done
 
     struct client *client = item->data;
 
     // Change the border color to UNFOCUS_COLOR
     xcb_change_window_attributes(c, client->id, XCB_CW_BORDER_PIXEL,
                                  (uint32_t[]){0xFF000000 | UNFOCUS_COLOR});
     client_grab_buttons(client, false);
 }
 
 /*
  * Handling events from the event loop
  */
 
 void quit(__attribute__((unused)) const union Arg *arg)
 {
     LOG_DEBUG("=======[ user action: quit ]=======");
     running = false;
 }
 
 /*
  * Setup
  */
 
 // Retrieve the numlock keycode
 void setup_keyboard()
 {
     xcb_get_modifier_mapping_reply_t *reply =
         xcb_get_modifier_mapping_reply(c, xcb_get_modifier_mapping_unchecked(c), NULL);
     if (!reply)
     {
         LOG_ERROR("Unable to retrieve midifier mapping");
         exit(-1);
     }
 
     xcb_keycode_t *modmap = xcb_get_modifier_mapping_keycodes(reply);
     if (!modmap)
     {
         LOG_ERROR("Unable to retrieve midifier mapping keycodes");
         exit(-1);
     }
 
     xcb_keycode_t *numlock = xcb_get_keycodes(XK_Num_Lock);
 
     // Not sure why 8, I looked at both dwm and 2bwm, and they both do the same
     for (uint_fast8_t i = 0; i < 8; i++)
     {
         for (uint_fast8_t j = 0; j < reply->keycodes_per_modifier; j++)
         {
             xcb_keycode_t keycode = modmap[i * reply->keycodes_per_modifier + j];
 
             if (keycode == *numlock)
             {
                 numlockmask = (1 << i);
                 LOG_DEBUG_VA("numlock is %d", keycode);
             }
         }
     }
 
     free(numlock);
     free(reply);
 }
 
 /*
  * Workspaces
  */
 
 void workspace_change(const union Arg *arg)
 {
     LOG_DEBUG("=======[ user action: workspace_change ]=======");
     LOG_DEBUG_VA("i=%d", arg->i);
 
     workspace_set(arg->i);
 }
 
 void workspace_next(__attribute__((unused)) const union Arg *arg)
 {
     LOG_DEBUG("=======[ user action: workspace_next ]=======");
 
     workspace_set(current_workspace + 1 == workspaces_length ? 0 : current_workspace + 1);
 }
 
 void workspace_previous(__attribute__((unused)) const union Arg *arg)
 {
     LOG_DEBUG("=======[ user action: workspace_previous ]=======");
     workspace_set(current_workspace == 0 ? workspaces_length - 1 : current_workspace - 1);
 }
 
 void workspace_send(const union Arg *arg)
 {
     LOG_DEBUG("=======[ user action: workspace_send ]=======");
     LOG_DEBUG_VA("i=%d", arg->i);
     log_debug_globals();
 
     uint_fast8_t new_workspace = arg->i;
 
     if (current_workspace == new_workspace || list_is_empty(&workspaces[current_workspace]))
         return; // Nothing to be done
 
     struct client *client = client_remove();
     client_add_workspace(client, new_workspace);
 
     xcb_unmap_window(c, client->id);
     xcb_flush(c);
     LOG_DEBUG("workspace_send: done");
 }
 
 void workspace_set(uint_fast8_t new_workspace)
 {
     LOG_DEBUG_VA("workspace_set: old=%d new=%d", current_workspace, new_workspace);
 
     if (current_workspace == new_workspace)
         return; // Nothing to be done
 
     struct item *item;
 
     // Unmap the clients of the current workspace (if any)
     if ((item = list_head(&workspaces[current_workspace])) != NULL)
     {
         do
         {
             xcb_unmap_window(c, ((struct client *)item->data)->id);
         } while ((item = item->next) != NULL);
     }
 
     // Map the clients of the new workspace (if any)
     if ((item = list_head(&workspaces[new_workspace])) != NULL)
     {
         do
         {
             xcb_map_window(c, ((struct client *)item->data)->id);
         } while ((item = item->next) != NULL);
     }
 
     xcb_flush(c);
     current_workspace = new_workspace;
 
     if (!list_is_empty(&workspaces[current_workspace]))
         focus_apply();
 
     LOG_DEBUG("workspace_set: done");
 }
 
 /*
  * Main
  */
 
 int main(void)
 {
     /*
      * displayname = NULL -> use DISPLAY environment variable
      */
     int screenp;
     c = xcb_connect(NULL, &screenp);
 
     if (xcb_connection_has_error(c))
     {
         LOG_ERROR_VA("xcb_connect failed: %d", xcb_connection_has_error(c));
         exit(1);
     }
 
     /*
      * Find the screen
      */
     xcb_screen_iterator_t iter = xcb_setup_roots_iterator(xcb_get_setup(c));
 
     for (int i = 0; i < screenp; ++i)
     {
         xcb_screen_next(&iter);
     }
 
     screen = iter.data;
 
     if (!screen)
     {
         xcb_disconnect(c);
         perror("screen not found");
         exit(1);
     }
 
     xcb_flush(c);
 
     /*
      * Initialize variables
      */
 
     for (uint_fast8_t i = 0; i != workspaces_length; i++)
         workspaces[i] = NULL;
 
     wm_protocols = xcb_get_atom(WM_PROTOCOLS);
     wm_delete_window = xcb_get_atom(WM_DELETE_WINDOW);
 
     setup_keyboard();
     setup_monitors();
     setup_clients();
     setup_events();
 
     // Event loop
     eventLoop();
 
     for (uint_fast8_t i = 0; i != workspaces_length; i++)
     {
         while (workspaces[i] != NULL)
         {
             struct client *client = client_remove_workspace(i);
             free(client);
         }
     }
 
     xcb_disconnect(c);
 
     return (0);
 }