Pileus Git - wmpus/blob - wm-wmii.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3
   4 #include "util.h"
   5 #include "sys.h"
   6 #include "wm.h"
   7
   8 #define MODKEY ctrl
   9
  10 /* Loca types */
  11 struct win_wm {
  12         list_t *col;
  13         list_t *row;
  14 };
  15
  16 typedef enum {
  17         none, move, resize
  18 } drag_t;
  19
  20 typedef enum {
  21         stack, split, max, tab
  22 } group_t;
  23
  24 typedef struct {
  25         int     width;
  26         group_t group;
  27         list_t *wins;
  28 } col_t;
  29
  30 /* Mouse drag data */
  31 drag_t move_mode;
  32 win_t *move_win;
  33 ptr_t  move_prev;
  34
  35 /* Window management data */
  36 list_t *wm_cols;
  37 win_t  *wm_root;
  38
  39 /* Helper functions */
  40 static void set_mode(drag_t drag, win_t *win, ptr_t ptr)
  41 {
  42         printf("set_mode: %d - %p@%d,%d\n",
  43                         drag, win, ptr.rx, ptr.ry);
  44         move_mode = drag;
  45         if (drag == move || drag == resize) {
  46                 move_win  = win;
  47                 move_prev = ptr;
  48         }
  49 }
  50
  51 static void print_txt(list_t *cols)
  52 {
  53         for (list_t *cnode = cols; cnode; cnode = cnode->next) {
  54                 col_t *col = cnode->data;
  55                 printf("col:\t%p - %dpx @ %d\n", col, col->width, col->group);
  56                 for (list_t *wnode = col->wins; wnode; wnode = wnode->next) {
  57                         win_t *win = wnode->data;
  58                         printf("  win:\t%p - %dpx\n", win, win->h);
  59                 }
  60         }
  61 }
  62
  63 static void arrange(list_t *cols)
  64 {
  65         int  x=0,  y=0; // Current window top-left position
  66         int tx=0, ty=0; // Total x/y size
  67         int mx=0, my=0; // Maximum x/y size (screen size)
  68
  69         mx = wm_root->w;
  70         my = wm_root->h;
  71
  72         /* Scale horizontally */
  73         for (list_t *lx = cols; lx; lx = lx->next)
  74                 tx += ((col_t*)lx->data)->width;
  75         for (list_t *lx = cols; lx; lx = lx->next)
  76                 ((col_t*)lx->data)->width *= (float)mx / tx;
  77
  78         /* Scale each column vertically */
  79         for (list_t *lx = cols; lx; lx = lx->next) {
  80                 col_t *col = lx->data;
  81                 for (list_t *ly = col->wins; ly; ly = ly->next)
  82                         ty += ((win_t*)ly->data)->h;
  83                 y = 0;
  84                 for (list_t *ly = col->wins; ly; ly = ly->next) {
  85                         win_t *win = ly->data;
  86                         sys_move(win, x, y, col->width,
  87                                 win->h * ((float)my / ty));
  88                         y += win->h;
  89                 }
  90                 x += col->width;
  91         }
  92 }
  93
  94 static void shift_window(win_t *win, int col, int row)
  95 {
  96         printf("shift_window: %p - %+d,%+d\n", win, col, row);
  97 }
  98
  99 static void shift_focus(win_t *win, int col, int row)
 100 {
 101         printf("shift_focus: %p - %+d,%+d\n", win, col, row);
 102         list_t *node  = NULL;
 103         if (row != 0) {
 104                 if (row < 0) node = win->wm->row->prev;
 105                 if (row > 0) node = win->wm->row->next;
 106         } else {
 107                 if (col < 0) node = win->wm->col->prev;
 108                 if (col > 0) node = win->wm->col->next;
 109                 if (node) node = ((col_t*)node->data)->wins;
 110         }
 111         if (node)
 112                 sys_focus(node->data);
 113 }
 114
 115 /* Window management functions */
 116 int wm_handle_key(win_t *win, Key_t key, mod_t mod, ptr_t ptr)
 117 {
 118         if (!win) return 0;
 119         //printf("wm_handle_key: %p - %x\n", win, key);
 120
 121         /* Raise */
 122         if (key == key_f2)
 123                 return sys_focus(win), 1;
 124         if (key == key_f4)
 125                 return sys_raise(win), 1;
 126         if (key == key_f1 && mod.MODKEY)
 127                 sys_raise(win);
 128         if (key_mouse0 <= key && key <= key_mouse7)
 129                 sys_raise(win);
 130
 131         /* Key commands */
 132         if (mod.MODKEY && mod.shift) {
 133                 switch (key) {
 134                 case 'h': case 'H': return shift_window(win,-1, 0), 1;
 135                 case 'k': case 'K': return shift_window(win, 0,-1), 1;
 136                 case 'j': case 'J': return shift_window(win,+1, 0), 1;
 137                 case 'l': case 'L': return shift_window(win, 0,+1), 1;
 138                 default: break;
 139                 }
 140         }
 141         else if (mod.MODKEY) {
 142                 switch (key) {
 143                 case 'h': case 'H': return shift_focus(win,-1, 0), 1;
 144                 case 'k': case 'K': return shift_focus(win, 0,-1), 1;
 145                 case 'j': case 'J': return shift_focus(win,+1, 0), 1;
 146                 case 'l': case 'L': return shift_focus(win, 0,+1), 1;
 147                 default: break;
 148                 }
 149         }
 150
 151         /* Mouse movement */
 152         if (key_mouse0 <= key && key <= key_mouse7 && mod.up)
 153                 return set_mode(none,win,ptr), 1;
 154         else if (key == key_mouse1 && mod.MODKEY)
 155                 return set_mode(move,win,ptr), 1;
 156         else if (key == key_mouse3 && mod.MODKEY)
 157                 return set_mode(resize,win,ptr), 1;
 158
 159         return 0;
 160 }
 161
 162 int wm_handle_ptr(win_t *cwin, ptr_t ptr)
 163 {
 164         //printf("wm_handle_ptr: %p - %d,%d %d,%d (%d) -- \n",
 165         //              cwin, ptr.x, ptr.y, ptr.rx, ptr.ry, move_mode);
 166         if (move_mode == none)
 167                 return 0;
 168         win_t *mwin = move_win;
 169         int dx = ptr.rx - move_prev.rx;
 170         int dy = ptr.ry - move_prev.ry;
 171         move_prev = ptr;
 172         if (move_mode == move)
 173                 sys_move(mwin, mwin->x+dx, mwin->y+dy, mwin->w, mwin->h);
 174         else if (move_mode == resize)
 175                 sys_move(mwin, mwin->x, mwin->y, mwin->w+dx, mwin->h+dy);
 176         return 0;
 177 }
 178
 179 void wm_insert(win_t *win)
 180 {
 181         printf("wm_insert: %p\n", win);
 182         print_txt(wm_cols);
 183
 184         /* Add to screen */
 185         col_t *col = wm_cols->data;
 186         int nwins = list_length(col->wins);
 187         col->wins = list_insert(col->wins, win);
 188
 189         /* Setup window */
 190         win->wm = new0(win_wm_t);
 191         win->wm->col = wm_cols;
 192         win->wm->row = col->wins;
 193         if (nwins) win->h = wm_root->h / nwins;
 194
 195         /* Arrange */
 196         arrange(wm_cols);
 197         print_txt(wm_cols);
 198 }
 199
 200 void wm_remove(win_t *win)
 201 {
 202         printf("wm_remove: %p - (%p,%p)\n", win,
 203                         win->wm->col, win->wm->row);
 204         print_txt(wm_cols);
 205         col_t *col = win->wm->col->data;
 206         col->wins = list_remove(col->wins, win->wm->row);
 207         arrange(wm_cols);
 208         print_txt(wm_cols);
 209 }
 210
 211 void wm_init(win_t *root)
 212 {
 213         printf("wm_init: %p\n", root);
 214         wm_root = root;
 215         sys_watch(root, key_f1,     MOD(.MODKEY=1));
 216         sys_watch(root, key_mouse1, MOD(.MODKEY=1));
 217         sys_watch(root, key_mouse3, MOD(.MODKEY=1));
 218         key_t keys[] = {'h', 'j', 'k', 'l', 'H', 'J', 'K', 'L'};
 219         for (int i = 0; i < countof(keys); i++)
 220                 sys_watch(root, keys[i], MOD(.MODKEY=1));
 221         col_t *col = new0(col_t);
 222         col->group = stack;
 223         col->width = root->w;
 224         wm_cols = list_insert(wm_cols, col);
 225 }