main.c

#include "config.h"
#include "main.h"

Display *display;
Screen *screen;

int scr_num;

Window root;
Bar bar;

XWindowAttributes attr;

unsigned int width;
unsigned int height;

XButtonEvent start;
XEvent e;
XKeyEvent key;

static Client *head = NULL;
static Client *current = NULL;

static Desktop desktops[NUM_DESKTOPS];
static int bar_desktop_end[NUM_DESKTOPS];
int current_desktop = 0;
int current_colorscheme = 0;
int time_x;

unsigned int error_occurred = 0;

int o_bar_size;

//int total_bar_size = bar_size + bar_padding_y + (bar_border_size * 2);

static inline void logger(char *msg) {
  printf(ANSI_COLOR_GREEN " -> weem INFO:" ANSI_COLOR_RESET " %s\n", msg);
}

static inline void err(char *msg) {
  printf(ANSI_COLOR_RED " -> weem  ERR:" ANSI_COLOR_RESET " %s\n" , msg);
}

static inline void kill(Window window) {
  if (window == None) return;
  // Since I have no idea how to handle this, I took (stole) it from:
  // https://github.com/dacousb/clarawm/blob/master/clarawm.c
  XEvent ke;
  ke.type = ClientMessage;
  ke.xclient.window = window;
  ke.xclient.message_type = XInternAtom(display, "WM_PROTOCOLS", True);
  ke.xclient.format = 32;
  ke.xclient.data.l[0] = XInternAtom(display, "WM_DELETE_WINDOW", True);
  ke.xclient.data.l[1] = CurrentTime;
  XSendEvent(display, window, False, NoEventMask, &ke);
}

static inline void spawn(char *args) {
  if (fork() == 0) {
    setsid();
    system(args);
    exit(EXIT_SUCCESS);
  }
}

static inline int IsBar(Window window) {
  if (window == bar.window) return true;
  
  XClassHint class_hint;
  if (XGetClassHint(display, window, &class_hint)) {
    int is_bar = strcmp(class_hint.res_name, "weembar") == 0;

    XFree(class_hint.res_name);
    XFree(class_hint.res_class);

    return is_bar;
  }

  return false;
}

static inline void KillClient() {
  if (current == NULL) return;
 
  kill(current->window);
}

static inline void UpdateCurrent() {
  Client *c;

  for (c = head; c; c = c->next) {
    if (current == c) {
      XSetWindowBorderWidth(display, c->window, border_width);

      XSetWindowBorder(display, c->window, colorschemes[current_colorscheme].border_focus);
      XSetInputFocus(display, c->window, RevertToParent, CurrentTime);
    } else {
      XSetWindowBorder(display, c->window, colorschemes[current_colorscheme].border_unfocus);
    }

    if (c->is_floating) {
      XRaiseWindow(display, c->window);
    }
  }
  
  if (current && (current->is_floating || current->is_fullscreen)) {
    XRaiseWindow(display, current->window);
  }
}

static inline void TileWindows() {
  if (desktops[current_desktop].layout == MASTER_STACK || desktops[current_desktop].layout == FLOATING) {
    unsigned int tiled_windows = 0;
    unsigned int stack_windows = 0;
    Client *c;

    for (c = head; c; c = c->next) {
      if (c->desktop == current_desktop && c->is_tiled) {
        tiled_windows++;
      }
    }

    stack_windows = tiled_windows - 1;
    unsigned int win_height = height - bar_size - bar_padding_y - bar_border_size;

    if (tiled_windows == 0) {
      return;
    }

    if (tiled_windows == 1) {
      unsigned int x, y, w, h;

      for (c = head; c; c = c->next) {
        if (!c->is_fullscreen && !c->is_floating) break;
      }

      x = desktops[current_desktop].gap_width;
      y = (bar_position == top) ? (bar_size + desktops[current_desktop].gap_width + bar_padding_y + (bar_border_size * 2)) : (desktops[current_desktop].gap_width);
      w = width - (2 * desktops[current_desktop].gap_width) - (2 * border_width);
      h = win_height - (2 * desktops[current_desktop].gap_width) - (2 * border_width);

      XMoveResizeWindow(display, c->window, x, y, w, h);
    } else {
      unsigned int master_width = (width * desktops[current_desktop].master) - (desktops[current_desktop].gap_width * 2);
      unsigned int stack_width = (width * (1 - desktops[current_desktop].master)) - (desktops[current_desktop].gap_width * 2);

      unsigned int n = 0;
      for (c = head; c; c = c->next) {
        if (c->desktop == current_desktop && !c->is_fullscreen && !c->is_floating) {
          unsigned int x, y, w, h;

          if (n == 0) {
            x = desktops[current_desktop].gap_width;
            y = (bar_position == top) ? (bar_size + desktops[current_desktop].gap_width + bar_padding_y) : (desktops[current_desktop].gap_width);
            w = master_width - (border_width * 2);
            h = win_height - (border_width * 2) - (desktops[current_desktop].gap_width * 2);
          } else { 
            x = width * desktops[current_desktop].master;
            w = stack_width - (border_width * 2) + (desktops[current_desktop].gap_width);
            h = (win_height - (2 * border_width * stack_windows) - desktops[current_desktop].gap_width * (stack_windows + 1)) / stack_windows;
            y = ((bar_position == top) ? (bar_size + desktops[current_desktop].gap_width + bar_padding_y) : (desktops[current_desktop].gap_width)) + ((n - 1) * (h + desktops[current_desktop].gap_width + (2 * border_width)));
          }

          XMoveResizeWindow(display, c->window, x, y, w, h);
          n++;
        }
      }
    }
  } else if (desktops[current_desktop].layout == STRIPES_VERTICAL) {
    int windows = 0;
    Client *c;

    for (c = head; c; c = c->next) {
      if (c->is_tiled) windows ++;
    }

    if (windows == 0) return;

    int window_width = (width - (windows + 1) * desktops[current_desktop].gap_width) / windows;
    int window_height = height - bar_size - 3 * desktops[current_desktop].gap_width;

    int offset = desktops[current_desktop].gap_width;

    for (c = head; c; c = c->next) {
      if (!c->is_tiled) continue;

      XMoveResizeWindow(display, c->window, offset, desktops[current_desktop].gap_width, window_width, window_height);
      offset += window_width + desktops[current_desktop].gap_width;
    }
  } else if (desktops[current_desktop].layout == STRIPES_HORIZONTAL) {
    int windows = 0;
    Client *c;

    for (c = head; c; c = c->next) {
      if (c->is_tiled) windows ++;
    }
  
    if (windows == 0) return;

    int window_width = width - desktops[current_desktop].gap_width * 2;
    int window_height = (height - bar_size - desktops[current_desktop].gap_width - (windows + 1) * gap_width) / windows;

    int offset = desktops[current_desktop].gap_width;

    for (c = head; c; c = c->next) {
      if (!c->is_tiled) continue;

      XMoveResizeWindow(display, c->window, desktops[current_desktop].gap_width, offset, window_width, window_height);
      offset += window_height + desktops[current_desktop].gap_width;
    }
  }

  UpdateCurrent();
}


static inline void TileWindow() {
  if (current == NULL) return;

  current->is_fullscreen = 0;
  current->is_floating = 0;
  current->is_tiled = 1;

  TileWindows();
  UpdateCurrent();
}

static inline void FloatWindow() {
  if (current == NULL) return;

  current->is_fullscreen = 0;
  current->is_tiled = 0;
  current->is_floating = 1;

  TileWindows();
  UpdateCurrent();
}

static inline void FullscreenWindow() {
  if (current == NULL) return;

  if (!current->is_fullscreen) {
    XWindowAttributes attributes;
    XGetWindowAttributes(display, current->window, &attributes);

    current->old_x = attributes.x;
    current->old_y = attributes.y;
    current->old_w = attributes.width;
    current->old_h = attributes.height;

    if (current->is_tiled) current->prev_state = 1;
    else current->prev_state = 2;

    current->is_fullscreen = 1;
    current->is_tiled = 0;
    current->is_floating = 0;

    int screen = DefaultScreen(display);
    int screenWidth = DisplayWidth(display, screen);
    int screenHeight = DisplayHeight(display, screen);

    XMoveResizeWindow(display, current->window, -border_width, -border_width, screenWidth + border_width, screenHeight + border_width);
    XMapWindow(display, current->window);

    UpdateCurrent();
  } else {
    current->is_fullscreen = 0;
    
    if (current->prev_state == 1) {
      current->is_tiled = 1;
      current->is_floating = 0;

      TileWindows();
    } else {
      current->is_tiled = 0;
      current->is_floating = 1;

      XMoveResizeWindow(display, current->window, current->old_x, current->old_y, current->old_w, current->old_h);
      XMapWindow(display, current->window);
    }
    UpdateCurrent();
  }
}

static inline void TrimString(char *string, int max_length) {
  int length = strlen(string);
  
  if (length > max_length) {
    string[max_length - 3] = '.';
    string[max_length - 2] = '.';
    string[max_length - 1] = '.';
    string[max_length] = '\0';
  }
}

static inline void SetClientName(Client *client) {
  if (client == NULL) return;

  char *name = NULL;

  XFetchName(display, client->window, &name);

  if (name) {
    client->name = strdup(name);
    TrimString(client->name, max_name_length);
    XFree(name);
  } else {
    client->name = NULL;
  }
}

static inline void AddWin(Window window) {
  Client *c;

  int tile_or_float;

  Atom type;
  int format;
  unsigned long num_items, bytes_after;
  unsigned char *prop_value = NULL;

  if (XGetWindowProperty(display, window, XInternAtom(display, "_NET_WM_WINDOW_TYPE", False), 0, 1, False, XA_ATOM, &type, &format, &num_items, &bytes_after, &prop_value) == Success) {
    if (num_items > 0) {
      Atom hint = ((Atom *)prop_value)[0];

      if (hint == XInternAtom(display, "_NET_WM_WINDOW_TYPE_NORMAL", False)) {
        tile_or_float = 1;
      } else {
        tile_or_float = 0;
      }
    }
  }

  if (desktops[current_desktop].layout == FLOATING) {
    tile_or_float = 0;
  }

  if (!(c = (Client *)calloc(1, sizeof(Client))))
    err("calloc error");
 
  // Remove fullscreen
  if (current && current->is_fullscreen) {
    FullscreenWindow();
  }

  if (head == NULL) {
    // no wins in desktop, so this one will be head
    c->next = NULL;
    c->prev = NULL;
    c->window = window;
    
    head = c;
    head->desktop = current_desktop;

    if (tile_or_float)
      head->is_tiled = 1;
    else
      head->is_floating = 1;
  } else {
    Client *t;
    for (t = head; t->next; t = t->next);

    c->next = NULL;
    c->prev = t;
    c->window = window;

    t->next = c;

    t->next->desktop = current_desktop;
    
    if (tile_or_float) 
      t->next->is_tiled = 1;
    else
      t->next->is_floating = 1;
  }

  SetClientName(c);

  current = c;

  UpdateCurrent();
  TileWindows();
}

static inline void RemoveWindow(Window window) {
  Client *c;
  
  for (c = head; c; c = c->next) {
    if (c->window == window) {
      if (c->prev == NULL && c->next == NULL) {
        free(head);
        head = NULL;
        current = NULL;
        return;
      }
      if (c->prev == NULL) {
        head = c->next;
        c->next->prev = NULL;
        current = c->next;
      } else if (c->next == NULL) {
        c->prev->next = NULL;
        current = c->prev;
      } else {
        c->prev->next = c->next;
        c->next->prev = c->prev;
        current = c->prev;
      }

      free(c);
      TileWindows();
      return;
    }
  }
}

static inline void SendDesk(int num) {
  if (num == current_desktop || current == None) return;

  Client *target = current;
  XUnmapWindow(display, current->window);
  
  if (current->prev) current = current->prev;
  else current = current->next;

  if (target->prev) {
    target->prev->next = target->next;
  } else {
    head = target->next;
  }

  if (target->next) {
    target->next->prev = target->prev;
  }
  
  if (desktops[num].head) {
    Client *t;

    for (t = desktops[num].head; t->next; t = t->next);

    t->next = target;

    target->next = NULL;
    target->prev = t;
  } else {
    desktops[num].head = target;
    target->next = NULL;
    target->prev = NULL;
  }

  target->desktop = num;
  if (!desktops[num].current) desktops[num].current = target;

  UpdateCurrent();
  TileWindows();
}

static inline void ChangeDesk(int num) {
  Client *c;

  if (num == current_desktop) {
    return;
  }

  // Unmap windows
  if (head != NULL) {
    for (c = head; c; c = c->next) {
      XUnmapWindow(display, c->window);
    }
  }

  desktops[current_desktop].head = head;
  desktops[current_desktop].current = current;

  head = desktops[num].head;
  current = desktops[num].current;
  current_desktop = num;
  
  // Map windows
  if (head != NULL) {
    for (c = head; c; c = c->next) {
      XMapWindow(display, c->window);
    }
  }

  UpdateCurrent();
  TileWindows();
}

XRenderColor LongToXRenderColor(unsigned long color) {
  XRenderColor xcolor;

  xcolor.red = ((color >> 16) & 0xFF) * 257;
  xcolor.green = ((color >> 8) & 0xFF) * 257;
  xcolor.blue = (color & 0xFF) * 257;
  xcolor.alpha = 0xFFFF;

  return xcolor;
}

FontStruct CreateFont(char *font_name, unsigned long color_fg, unsigned long color_selected, unsigned long color_occupied, Window window) {
  FontStruct fs;

  XftFont *xft_font = XftFontOpenName(display, DefaultScreen(display), font_name);

  XftDraw *xft_draw = XftDrawCreate(display, window, DefaultVisual(display, DefaultScreen(display)), DefaultColormap(display, DefaultScreen(display)));

  XRenderColor xcolor_fg = LongToXRenderColor(color_fg);
  XRenderColor xcolor_selected = LongToXRenderColor(color_selected);
  XRenderColor xcolor_occupied = LongToXRenderColor(color_occupied);

  XftColorAllocValue(display, DefaultVisual(display, CopyFromParent), DefaultColormap(display, CopyFromParent), &xcolor_fg, &fs.xft_color_fg);
  XftColorAllocValue(display, DefaultVisual(display, CopyFromParent), DefaultColormap(display, CopyFromParent), &xcolor_selected, &fs.xft_color_selected);
  XftColorAllocValue(display, DefaultVisual(display, CopyFromParent), DefaultColormap(display, CopyFromParent), &xcolor_occupied, &fs.xft_color_occupied);

  fs.xft_font = xft_font;
  fs.xft_draw = xft_draw;
  
  return fs;
}

static inline void DrawStr(char *string, FontStruct font, int x, int y, int color_index) {
  XftColor color;

  if (color_index == 0) {
    color = font.xft_color_selected;
  } else if (color_index == 1) {
    color = font.xft_color_fg;
  } else if (color_index == 2) {
    color = font.xft_color_occupied;
  }
  
  XftDrawStringUtf8(font.xft_draw, &color, font.xft_font, x, y, (XftChar8 *)string, strlen(string));
}

static inline void DrawDesktopsAndType() {
  unsigned int offset = icons_offset;

  for (unsigned int i = 0; i < NUM_DESKTOPS; i++) {
    XSetForeground(display, DefaultGC(display, DefaultScreen(display)), (i == current_desktop) ? colorschemes[current_colorscheme].desktop_focus : colorschemes[current_colorscheme].desktop_unfocus);
    XFillRectangle(display, bar.window, DefaultGC(display, DefaultScreen(display)), offset, 0, (int)icons_size * strlen(desktop_icons[i]) + icons_padding, bar_size);

    if (desktops[i].head) {
      XSetForeground(display, DefaultGC(display, DefaultScreen(display)), colorschemes[current_colorscheme].desktop_focus);
      if (bar_occu_type == overline) {
        XFillRectangle(display, bar.window, DefaultGC(display, DefaultScreen(display)), offset, 0, (int)icons_size * strlen(desktop_icons[i]) + icons_padding, bar_occu_size);
      } else {
        XFillRectangle(display, bar.window, DefaultGC(display, DefaultScreen(display)), offset, bar_size - bar_occu_size, (int)icons_size * strlen(desktop_icons[i]) + icons_padding, bar_occu_size);
      }
    }

    DrawStr(desktop_icons[i], bar.font, offset + (font_size / 2), (bar_size / 2) + (font_size / 2), (i == current_desktop) ? (0) : ((desktops[i].head) ? (2) : (1)));

    offset += icons_padding + (icons_size * strlen(desktop_icons[i]));
    if (!bar_desktop_end[i]) bar_desktop_end[i] = offset;
  }

  XSetForeground(display, DefaultGC(display, DefaultScreen(display)), colorschemes[current_colorscheme].desktop_unfocus);

  offset += icons_padding;

  if (show_indicators) {
    if (current) {
      int indicator = (current->is_tiled) ? (0) : (1);

      XFillRectangle(display, bar.window, DefaultGC(display, DefaultScreen(display)), offset, 0, (int)icons_size * strlen(bar_indicators[indicator]) + icons_padding, bar_size);

      offset += (font_size / 2);
      DrawStr(bar_indicators[indicator], bar.font, offset, (bar_size / 2) + (font_size / 2), 1);
      offset += strlen(bar_indicators[indicator]) * icons_size;
    }
  }

  if (current && current->name) {
    DrawStr(current->name, bar.font, offset + icons_padding, (bar_size / 2) + (font_size / 2), 1);
  }
}

static inline void DrawTimeAndCustom() {
  time_t now = time(NULL);
  struct tm *tm_info = localtime(&now);
  char time_str[100];

  if (twelve_hour_time)
    if (show_seconds)
      strftime(time_str, sizeof(time_str), "%a %d %b %I:%M:%S %p", tm_info);
    else
      strftime(time_str, sizeof(time_str), "%a %d %b %I:%M %p", tm_info);
  else
    if (show_seconds)
      strftime(time_str, sizeof(time_str), "%a %d %b %H:%M:%S", tm_info);
    else
      strftime(time_str, sizeof(time_str), "%a %d %b %H:%M", tm_info);
  
  time_x = width - strlen(time_str) * icons_size - bar_padding_x - bar_border_size;
  int time_y = (bar_size / 2) + (font_size / 2);

  XSetForeground(display, DefaultGC(display, DefaultScreen(display)), colorschemes[current_colorscheme].desktop_unfocus);
  XFillRectangle(display, bar.window, DefaultGC(display, DefaultScreen(display)), time_x - icons_padding, 0, strlen(time_str) * icons_size + icons_padding, bar_size);
 
  DrawStr(time_str, bar.font, time_x - icons_padding, time_y, 1);

  int clock_width = strlen(time_str) * icons_size + icons_padding * 2;

  char custom_text[500];
  
  char *home_dir = getenv("HOME");

  char path[100];
  snprintf(path, sizeof(path), "%s/.weembar", home_dir);

  FILE *fp = fopen(path, "r");
  if (fp != NULL) {
    fgets(custom_text, sizeof(custom_text), fp);
    fclose(fp);

    char* newline = strchr(custom_text, '\n');
    if (newline != NULL) {
      *newline = '\0';
    }

    int custom_text_width = strlen(custom_text) * icons_size;
    int custom_text_x = time_x - custom_text_width - icons_padding;
    int custom_text_y = (bar_size / 2) + (font_size / 2);

    
    XFillRectangle(display, bar.window, DefaultGC(display, DefaultScreen(display)), custom_text_x - icons_padding, 0, custom_text_width + icons_padding, bar_size);
    
    DrawStr(custom_text, bar.font, custom_text_x, custom_text_y, 1);
  } else {
    err("could not open ~/.weembar");
  }
}

void *CurrentUpdateLoop() {
  while (true) {
    SetClientName(current);
    usleep(50000);
  }
}

void *BarUpdateLoop() {
  while (true) {
    XClearWindow(display, bar.window);

    DrawDesktopsAndType();
    DrawTimeAndCustom();
    
    XFlush(display);
    usleep(bar_refresh_rate);
  }

  return NULL;
}

static inline void CreateBar() {
  if (!show_bar) return;

  if (bar_position == top)
    bar.window = XCreateSimpleWindow(display, root, bar_padding_x, bar_padding_y + bar_border_size, width - (bar_padding_x * 2) - (bar_border_size * 2), bar_size, bar_border_size, colorschemes[current_colorscheme].bar_border, colorschemes[current_colorscheme].bar_color);
  else
    bar.window = XCreateSimpleWindow(display, root, bar_padding_x, height - bar_size - bar_padding_y - (bar_border_size * 2), width - (bar_padding_x * 2) - (bar_border_size * 2), bar_size, bar_border_size, colorschemes[current_colorscheme].bar_border, colorschemes[current_colorscheme].bar_color);
  
  XSelectInput(display, bar.window, SubstructureRedirectMask | SubstructureNotifyMask);

  XClassHint classHint;
  classHint.res_name = "weembar";
  classHint.res_class = "weembar";
  XSetClassHint(display, bar.window, &classHint);
  
  XSetStandardProperties(display, bar.window, "weembar", "weembar", None, NULL, 0, NULL);

  XMapWindow(display, bar.window);
  bar.font = CreateFont(font_name, colorschemes[current_colorscheme].font_color, colorschemes[current_colorscheme].font_color_sel, colorschemes[current_colorscheme].font_color_occu, bar.window);
}

static inline void MoveUp() {
  if (!current || !current->prev) return;

  Client *new_next = current->prev;

  if (current->next) {
    current->next->prev = current->prev;
  }

  current->prev->next = current->next;
  current->prev = current->prev->prev;

  if (current->prev) {
    current->prev->next = current;
  } else {
    head = current;
  }

  current->next = new_next;
  current->next->prev = current;

  UpdateCurrent();
  TileWindows();
}

static inline void MoveDown() {
  if (!current || !current->next) return;

  Client *new_prev = current->next;

  if (current->prev) {
    current->prev->next = current->next;
  } else {
    head = current->next;
  }

  current->next->prev = current->prev;
  current->next = current->next->next;

  if (current->next) {
    current->next->prev = current;
  }

  current->prev = new_prev;
  current->prev->next = current;

  UpdateCurrent();
  TileWindows();
}

static inline void IncMaster() {
  desktops[current_desktop].master += master_tick;
  desktops[current_desktop].master = MIN(MAX(desktops[current_desktop].master, 0.2), 0.8);
  TileWindows();
}

static inline void DecMaster() {
  desktops[current_desktop].master -= master_tick;
  desktops[current_desktop].master = MIN(MAX(desktops[current_desktop].master, 0.2), 0.8);
  TileWindows();
}

static inline void IncGapWidth() {
  desktops[current_desktop].gap_width += 1;
  desktops[current_desktop].gap_width = MIN(desktops[current_desktop].gap_width, max_gap_width);
  TileWindows();
}

static inline void DecGapWidth() {
  desktops[current_desktop].gap_width -= 1;
  desktops[current_desktop].gap_width = MAX(desktops[current_desktop].gap_width, min_gap_width);
  TileWindows();
}

static inline void CycleColorschemeUp() {
  current_colorscheme = (current_colorscheme + 1) % NUM_COLORSCHEMES;
  XftFontClose(display, bar.font.xft_font);
  XDestroyWindow(display, bar.window);

  CreateBar();
  bar.font = CreateFont(font_name, colorschemes[current_colorscheme].font_color, colorschemes[current_colorscheme].font_color_sel, colorschemes[current_colorscheme].font_color_occu, bar.window);

  UpdateCurrent();
  TileWindows();
}

static inline void CycleColorschemeDown() {
  current_colorscheme = (NUM_COLORSCHEMES + current_colorscheme - 1) % NUM_COLORSCHEMES;
  XftFontClose(display, bar.font.xft_font);
  XDestroyWindow(display, bar.window);

  CreateBar();
  bar.font = CreateFont(font_name, colorschemes[current_colorscheme].font_color, colorschemes[current_colorscheme].font_color_sel, colorschemes[current_colorscheme].font_color_occu, bar.window);

  UpdateCurrent();
  TileWindows();
}

static inline void ToggleBarPosition() {
  bar_position ^= 1;

  if (bar_position == top) {
    XMoveWindow(display, bar.window, bar_padding_x, bar_padding_y);
  } else {
    XMoveWindow(display, bar.window, bar_padding_x, height - bar_size - bar_padding_y - (bar_border_size * 2));
  }

  UpdateCurrent();
  TileWindows();
}

static inline void ToggleBar() {
  if (show_bar) {
    XUnmapWindow(display, bar.window);
    o_bar_size = bar_size;
    bar_size = 0;
    show_bar = 0;
  } else {
    XMapWindow(display, bar.window);
    bar_size = o_bar_size;
    show_bar = 1;
  }

  UpdateCurrent();
  TileWindows();
}

static inline int ErrorHandler(Display *display, XErrorEvent *event) {
  char error_message[256];
  XGetErrorText(display, event->error_code, error_message, sizeof(error_message));
  err(error_message);
  error_occurred = 1;

  return 0;
}

static inline void OnButtonPress(XEvent e) {
  if (e.xbutton.subwindow == None) return;
  start = e.xbutton;
 
  if (show_bar) {
    if ((bar_position == top && start.y <= bar_size) || (bar_position == bottom && start.y >= height - bar_size)) {
      int index = 0;

      if (start.x >= time_x && start.button == 1) {
        show_seconds ^= 1;

        return;
      }

      if (start.x > bar_desktop_end[NUM_DESKTOPS - 1]) return;

      if (start.button == 4) {
        ChangeDesk((current_desktop + NUM_DESKTOPS + 1) % NUM_DESKTOPS);
        return;
      }

      if (start.button == 5) {
        ChangeDesk((current_desktop + NUM_DESKTOPS - 1) % NUM_DESKTOPS);
        return;
      }

      while (index <= NUM_DESKTOPS) {
        if (start.x <= bar_desktop_end[index]) break;
        index ++;
      }

      if (start.button == 1)
        ChangeDesk(index);

      return;
    }
  }

  // Hacky way to get current client
  Client *c;

  for (c = head; c; c = c->next) {
    if (c->window == start.subwindow) {
      current = c;
      UpdateCurrent();
    }
  }

  XGetWindowAttributes(display, start.subwindow, &attr);
}

static inline void ExitWeem() {
  system("killall bar.sh");
  XCloseDisplay(display);
  exit(EXIT_SUCCESS);
}

static inline void OnKeyPress(XEvent e) {
  key = e.xkey;

  for (int i = 0; i < num_keys; i ++) {
    if (key.keycode == XKeysymToKeycode(display, keymap[i].keymod.keysym) && (key.state ^ keymap[i].keymod.mod) == 0) {
      spawn(keymap[i].cmd);
      break;
    }
  }

  if (key.keycode == XKeysymToKeycode(display, set_layout_master_stack.keysym) && (key.state ^ set_layout_master_stack.mod) == 0) {
    desktops[current_desktop].layout = MASTER_STACK;
    TileWindows();
    return;
  }

  if (key.keycode == XKeysymToKeycode(display, set_layout_stripes_horizontal.keysym) && (key.state ^ set_layout_stripes_horizontal.mod) == 0) {
    desktops[current_desktop].layout = STRIPES_HORIZONTAL;
    TileWindows();
    return;
  }

  if (key.keycode == XKeysymToKeycode(display, set_layout_stripes_vertical.keysym) && (key.state ^ set_layout_stripes_vertical.mod) == 0) {
    desktops[current_desktop].layout = STRIPES_VERTICAL;
    TileWindows();
    return;
  }

  if (key.keycode == XKeysymToKeycode(display, set_layout_floating.keysym) && (key.state ^ set_layout_floating.mod) == 0) {
    desktops[current_desktop].layout = FLOATING;
    TileWindows();
    return;
  }

  if (key.keycode == XKeysymToKeycode(display, kill_win.keysym) && (key.state ^ kill_win.mod) == 0) {
    KillClient();
    return;
  }

  if (key.keycode == XKeysymToKeycode(display, fullscreen.keysym) && (key.state ^ fullscreen.mod) == 0) {
    FullscreenWindow();
    return;
  }

  if (key.keycode == XKeysymToKeycode(display, tile.keysym) && (key.state ^ tile.mod) == 0) {
    TileWindow();
    return;
  }

  if (key.keycode == XKeysymToKeycode(display, floating.keysym) && (key.state ^ floating.mod) == 0) {
    FloatWindow();
    return;
  }

  if (key.keycode == XKeysymToKeycode(display, up.keysym) && (key.state ^ up.mod) == 0) {
    MoveUp();
    return;
  }

  if (key.keycode == XKeysymToKeycode(display, down.keysym) && (key.state ^ down.mod) == 0) {
    MoveDown();
    return;
  }

  if (key.keycode == XKeysymToKeycode(display, right.keysym) && (key.state ^ right.mod) == 0) {
    IncMaster();
    return;
  }

  if (key.keycode == XKeysymToKeycode(display, inc_gap_width.keysym) && (key.state ^ inc_gap_width.mod) == 0) {
    IncGapWidth();
    return;
  }

  if (key.keycode == XKeysymToKeycode(display, dec_gap_width.keysym) && (key.state ^ dec_gap_width.mod) == 0) {
    DecGapWidth();
    return;
  }

  if (key.keycode == XKeysymToKeycode(display, cycle_colorscheme_up.keysym) && (key.state ^ cycle_colorscheme_up.mod) == 0) {
    CycleColorschemeUp();
    return;
  }

  if (key.keycode == XKeysymToKeycode(display, cycle_colorscheme_down.keysym) && (key.state ^ cycle_colorscheme_down.mod) == 0) {
    CycleColorschemeDown();
    return;
  }

  if (key.keycode == XKeysymToKeycode(display, left.keysym) && (key.state ^ left.mod) == 0) {
    DecMaster();
    return;
  }

  for (int i = 0; i < NUM_DESKTOPS; i ++) {
    if (key.keycode == XKeysymToKeycode(display, changedesktop[i].keysym)) {
      if (key.state & ShiftMask) {
        SendDesk(changedesktop[i].desktop);
      } else {
        ChangeDesk(changedesktop[i].desktop);
      }
    }
  }

  if (key.keycode == XKeysymToKeycode(display, toggle_bar_position.keysym) && (key.state ^ toggle_bar_position.mod) == 0) {
    ToggleBarPosition();
    return;
  }

  if (key.keycode == XKeysymToKeycode(display, toggle_bar.keysym) && (key.state ^ toggle_bar.mod) == 0) {
    ToggleBar();
    return;
  }

  if (key.keycode == XKeysymToKeycode(display, die.keysym) && (key.state ^ die.mod) == 0) {
    ExitWeem();
  }
}

static inline void OnMotionNotify(XEvent e) {
  if (start.subwindow == None) return;
  if (IsBar(start.subwindow)) return;

  int xdiff = e.xbutton.x_root - start.x_root;
  int ydiff = e.xbutton.y_root - start.y_root;

  if (start.button == 1 && !current->is_tiled && !current->is_fullscreen) {
    int new_x = attr.x + xdiff;
    int new_y = attr.y + ydiff;
    int max_x = width - attr.width - (2 * border_width);
    int max_y = height - attr.height - (2 * border_width);

    if (snap) {
      if (new_x < snap_threshold) {
        new_x = 0;
      } else if (new_x > max_x - snap_threshold && new_x < max_x + snap_threshold) {
        new_x = max_x;
      }

      if (new_y < snap_threshold + ((bar_position == top) ? (bar_size) : (0))) {
        new_y = 0;

        if (bar_position == top) {
          new_y = bar_size;
        }
      } else if (new_y > max_y - ((bar_position == bottom) ? (bar_size) : (0)) - snap_threshold && new_y < max_y - ((bar_position == bottom) ? (bar_size) : (0)) + snap_threshold) {
        new_y = max_y;

        if (bar_position == bottom) {
          new_y = max_y - bar_size;
        }
      }
    }

    XMoveWindow(display, start.subwindow, new_x, new_y);
  }

  if (start.button == 3 && !current->is_tiled && !current->is_fullscreen) {
    XMoveResizeWindow(display, start.subwindow,
      attr.x,
      attr.y,
      MAX(1, attr.width + xdiff),
      MAX(1, attr.height + ydiff));
  }

  if (start.button == 3 && current->is_tiled) {
    desktops[current_desktop].master = (float)(attr.width + xdiff) / width;
    desktops[current_desktop].master = MIN(MAX(desktops[current_desktop].master, 0.2), 0.8);
    TileWindows();
  }

  XFlush(display);
}

static inline void OnMapRequest(XEvent e) {
  if (IsBar(e.xmaprequest.window)) {
    XWindowAttributes attributes;
    XGetWindowAttributes(display, e.xmaprequest.window, &attributes);

    XMapWindow(display, e.xmaprequest.window);
    XMoveResizeWindow(display, e.xmaprequest.window, 0, 0, width, attributes.height);
  } else {
    XWindowAttributes attributes;

    if (!XGetWindowAttributes(display, e.xmaprequest.window, &attributes) || attributes.override_redirect) 
      return;
    
    AddWin(e.xmaprequest.window);
    XMoveWindow(display, e.xmaprequest.window, width/2 - attributes.width/2, height/2 - attributes.height/2);
    XMapWindow(display, e.xmaprequest.window);

    TileWindows();
    UpdateCurrent();
  }
}

static inline void OnUnmapNotify(XEvent e) {
  XWindowAttributes attributes;

  if (!XGetWindowAttributes(display, e.xunmap.window, &attributes) || attributes.override_redirect)
    return;

  XUnmapWindow(display, e.xunmap.window);
  RemoveWindow(e.xunmap.window);
}

static inline void OnConfigureRequest(XEvent e) {
  XWindowChanges changes;

  XConfigureRequestEvent event = e.xconfigurerequest;
  changes.x = event.x;
  changes.y = event.y;
  changes.width = event.width;
  changes.height = event.height;
  changes.border_width = event.border_width;
  changes.sibling = event.above;
  changes.stack_mode = event.detail;

  XWindowAttributes attributes;

 if (XGetWindowAttributes(display, event.window, &attributes)) {
    XConfigureWindow(display, event.window, event.value_mask, &changes);
  } else {
    err("configuration error");
  }
}

static inline void OnDestroyNotify(XEvent e) {
  Client *c;

  int i = 0;
  for (c = head; c; c = c->next) {
    if (e.xdestroywindow.window == c->window) {
      i ++;
    } 
  }

  if (i == 0) {
    return;
  } 

  RemoveWindow(e.xdestroywindow.window);
  UpdateCurrent();
}

void loop() {
  while (true) {
    if (XNextEvent(display, &e) != 0) {
      err("event error");
      break;
    }

    switch (e.type) {
      case KeyPress: OnKeyPress(e); break;
      case ButtonPress: OnButtonPress(e); break;
      case MotionNotify: OnMotionNotify(e); break;
      case ButtonRelease: start.subwindow = None; break;
      case MapRequest: OnMapRequest(e); break;
      case UnmapNotify: OnUnmapNotify(e); break;
      case ConfigureRequest: OnConfigureRequest(e); break;
      case DestroyNotify: OnDestroyNotify(e); break;
    }
  }
}

void init() {
  display = XOpenDisplay(NULL);

  if (display == NULL) {
    err("failed to open display");
  } else {
    root = DefaultRootWindow(display);
    screen = DefaultScreenOfDisplay(display);
    scr_num = XDefaultScreen(display);

    #ifdef WIDTH
      width = WIDTH;
    #else
      width = XDisplayWidth(display, scr_num);
    #endif

    #ifdef HEIGHT
      height = HEIGHT;
    #else
      height = XDisplayHeight(display, scr_num);
    #endif

    // Grab
    for (int i = 0; i < num_keys; i ++) {
      XGrabKey(display, XKeysymToKeycode(display, keymap[i].keymod.keysym), keymap[i].keymod.mod, root, True, GrabModeAsync, GrabModeAsync);
    }

    for (int i = 0; i < NUM_DESKTOPS; i ++) {
      XGrabKey(display, XKeysymToKeycode(display, changedesktop[i].keysym), MOD, root, True, GrabModeAsync, GrabModeAsync);
      XGrabKey(display, XKeysymToKeycode(display, changedesktop[i].keysym), MOD | ShiftMask, root, True, GrabModeAsync, GrabModeAsync);
      desktops[i].head = head;
      desktops[i].current = current;
      desktops[i].master = master_size;
      desktops[i].gap_width = gap_width;
      desktops[i].layout = DEFAULT_LAYOUT;
    }

    ChangeDesk(0);

    XGrabKey(display, XKeysymToKeycode(display, kill_win.keysym), kill_win.mod, root, True, GrabModeAsync, GrabModeAsync);
    XGrabKey(display, XKeysymToKeycode(display, die.keysym), die.mod, root, True, GrabModeAsync, GrabModeAsync);
    XGrabKey(display, XKeysymToKeycode(display, fullscreen.keysym), fullscreen.mod, root, True, GrabModeAsync, GrabModeAsync);
    XGrabKey(display, XKeysymToKeycode(display, tile.keysym), tile.mod, root, True, GrabModeAsync, GrabModeAsync);
    XGrabKey(display, XKeysymToKeycode(display, floating.keysym), floating.mod, root, True, GrabModeAsync, GrabModeAsync);

    XGrabKey(display, XKeysymToKeycode(display, up.keysym), up.mod, root, True, GrabModeAsync, GrabModeAsync);
    XGrabKey(display, XKeysymToKeycode(display, down.keysym), down.mod, root, True, GrabModeAsync, GrabModeAsync);
    XGrabKey(display, XKeysymToKeycode(display, left.keysym), left.mod, root, True, GrabModeAsync, GrabModeAsync);
    XGrabKey(display, XKeysymToKeycode(display, right.keysym), right.mod, root, True, GrabModeAsync, GrabModeAsync);

    XGrabKey(display, XKeysymToKeycode(display, set_layout_master_stack.keysym), set_layout_master_stack.mod, root, True, GrabModeAsync, GrabModeAsync);
    XGrabKey(display, XKeysymToKeycode(display, set_layout_stripes_horizontal.keysym), set_layout_stripes_horizontal.mod, root, True, GrabModeAsync, GrabModeAsync);    
    XGrabKey(display, XKeysymToKeycode(display, set_layout_stripes_vertical.keysym), set_layout_stripes_vertical.mod, root, True, GrabModeAsync, GrabModeAsync);
    XGrabKey(display, XKeysymToKeycode(display, set_layout_floating.keysym), set_layout_floating.mod, root, True, GrabModeAsync, GrabModeAsync);

    XGrabKey(display, XKeysymToKeycode(display, toggle_bar.keysym), toggle_bar.mod, root, True, GrabModeAsync, GrabModeAsync);
    XGrabKey(display, XKeysymToKeycode(display, toggle_bar_position.keysym), toggle_bar_position.mod, root, True, GrabModeAsync, GrabModeAsync);

    XGrabKey(display, XKeysymToKeycode(display, inc_gap_width.keysym), inc_gap_width.mod, root, True, GrabModeAsync, GrabModeAsync);
    XGrabKey(display, XKeysymToKeycode(display, dec_gap_width.keysym), inc_gap_width.mod, root, True, GrabModeAsync, GrabModeAsync);

    XGrabKey(display, XKeysymToKeycode(display, cycle_colorscheme_up.keysym), cycle_colorscheme_up.mod, root, True, GrabModeAsync, GrabModeAsync);
    XGrabKey(display, XKeysymToKeycode(display, cycle_colorscheme_down.keysym), cycle_colorscheme_down.mod, root, True, GrabModeAsync, GrabModeAsync);

    XGrabButton(display, AnyButton, MOD, root, True, ButtonPressMask | ButtonReleaseMask | PointerMotionMask | OwnerGrabButtonMask, GrabModeAsync, GrabModeAsync, None, None);

    XSelectInput(display, root, SubstructureNotifyMask | SubstructureRedirectMask);

    XSetWindowAttributes attributes;
    attributes.event_mask = ButtonPress | KeyPress | SubstructureRedirectMask | SubstructureNotifyMask | PropertyChangeMask;
    attributes.cursor = XCreateFontCursor(display, XC_left_ptr);
    XChangeWindowAttributes(display, root, CWEventMask | CWCursor, &attributes);
    
    if (!show_bar) bar_size = 0;
    CreateBar();
    system("~/.config/weem/autostart.sh");
  }
}

int main(void) {
  init(); 

  pthread_t bar_thread;
  pthread_create(&bar_thread, NULL, BarUpdateLoop, NULL);

  pthread_t current_thread;
  pthread_create(&current_thread, NULL, CurrentUpdateLoop, NULL);

  XSetErrorHandler(ErrorHandler);
  loop();
  XSetErrorHandler(NULL);

  ExitWeem();
  return 0;
}