#include "unmap_all.h" #include <X11/X.h>            // for Window, None, IsUnmapped#include <X11/Xlib.h>         // for XFree, XGetWindowAttributes, XMapWindow#include <X11/Xmu/WinUtil.h>  // for XmuClientWindow#include <X11/Xutil.h>        // for XClassHint, XGetClassHint#include <string.h>           // for NULL, strcmp int InitUnmapAllWindowsState(UnmapAllWindowsState* state, Display* display,                             Window root_window, const Window* ignored_windows,                             unsigned int n_ignored_windows,                             const char* my_res_class, const char* my_res_name,                             int include_frame) {  int should_proceed = 1;  state->display = display;  state->root_window = root_window;  state->windows = NULL;  state->n_windows = 0;   Window unused_root_return, unused_parent_return;  XQueryTree(state->display, state->root_window, &unused_root_return,             &unused_parent_return, &state->windows, &state->n_windows);  state->first_unmapped_window = state->n_windows;  // That means none unmapped.  for (unsigned int i = 0; i < state->n_windows; ++i) {    XWindowAttributes xwa;    XGetWindowAttributes(display, state->windows[i], &xwa);    // Not mapped -> nothing to do.    if (xwa.map_state == IsUnmapped) {      state->windows[i] = None;      continue;    }    // Go down to the next WM_STATE window if available, as unmapping window    // frames may confuse WMs.    if (!include_frame) {      state->windows[i] = XmuClientWindow(display, state->windows[i]);    }    // If any window we'd be unmapping is in the ignore list, skip it.    for (unsigned int j = 0; j < n_ignored_windows; ++j) {      if (state->windows[i] == ignored_windows[j]) {        state->windows[i] = None;      }    }    if (state->windows[i] == None) {      continue;    }    XClassHint cls;    if (XGetClassHint(state->display, state->windows[i], &cls)) {      // If any window has my window class, we better not proceed with      // unmapping as doing so could accidentally unlock the screen or      // otherwise cause more damage than good.      if ((my_res_class || my_res_name) &&          (!my_res_class || strcmp(my_res_class, cls.res_class) == 0) &&          (!my_res_name || strcmp(my_res_name, cls.res_name) == 0)) {        state->windows[i] = None;        should_proceed = 0;      }      // HACK: Bspwm creates some subwindows of the root window that we      // absolutely shouldn't ever unmap, as remapping them confuses Bspwm.      if (!strcmp(cls.res_class, "Bspwm")) {        state->windows[i] = None;      }      XFree(cls.res_class);      cls.res_class = NULL;      XFree(cls.res_name);      cls.res_name = NULL;    }  }  return should_proceed;} int UnmapAllWindows(UnmapAllWindowsState* state,                    int (*just_unmapped_can_we_stop)(Window w, void* arg),                    void* arg) {  if (state->first_unmapped_window == 0) {  // Already all unmapped.    return 0;  }  for (unsigned int i = state->first_unmapped_window - 1;;       --i) {  // Top-to-bottom order!    if (state->windows[i] != None) {      XUnmapWindow(state->display, state->windows[i]);      state->first_unmapped_window = i;      int ret;      if (just_unmapped_can_we_stop != NULL &&          (ret = just_unmapped_can_we_stop(state->windows[i], arg))) {        return ret;      }    }    if (i == 0) {      return 0;    }  }} void RemapAllWindows(UnmapAllWindowsState* state) {  for (unsigned int i = state->first_unmapped_window; i < state->n_windows;       ++i) {    if (state->windows[i] != None) {      XMapWindow(state->display, state->windows[i]);    }  }  state->first_unmapped_window = state->n_windows;} void ClearUnmapAllWindowsState(UnmapAllWindowsState* state) {  state->display = NULL;  state->root_window = None;  XFree(state->windows);  state->windows = NULL;  state->n_windows = 0;  state->first_unmapped_window = 0;}