layout.c

   1 /*
   2  * layout.c - layout management
   3  *
   4  * Copyright © 2007 Julien Danjou <julien@danjou.info>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  */
  21
  22 #include <X11/Xatom.h>
  23 #include <X11/Xutil.h>
  24
  25 #include "screen.h"
  26 #include "layout.h"
  27 #include "tag.h"
  28 #include "util.h"
  29 #include "statusbar.h"
  30 #include "layouts/floating.h"
  31
  32 /* extern */
  33 extern Client *clients, *sel;   /* global client list */
  34
  35 void
  36 arrange(Display * disp, DC *drawcontext, awesome_config *awesomeconf)
  37 {
  38     Client *c;
  39
  40     for(c = clients; c; c = c->next)
  41     {
  42         if(isvisible(c, awesomeconf->screen, awesomeconf->tags, awesomeconf->ntags))
  43             unban(c);
  44         /* we don't touch other screens windows */
  45         else if(c->screen == awesomeconf->screen)
  46             ban(c);
  47     }
  48     awesomeconf->current_layout->arrange(disp, awesomeconf);
  49     focus(disp, drawcontext, NULL, True, awesomeconf);
  50     restack(disp, drawcontext, awesomeconf);
  51 }
  52
  53 void
  54 uicb_focusnext(Display *disp __attribute__ ((unused)),
  55                DC *drawcontext,
  56                awesome_config * awesomeconf,
  57                const char *arg __attribute__ ((unused)))
  58 {
  59     Client *c;
  60
  61     if(!sel)
  62         return;
  63     for(c = sel->next; c && !isvisible(c, awesomeconf->screen, awesomeconf->tags, awesomeconf->ntags); c = c->next);
  64     if(!c)
  65         for(c = clients; c && !isvisible(c, awesomeconf->screen, awesomeconf->tags, awesomeconf->ntags); c = c->next);
  66     if(c)
  67     {
  68         focus(c->display, drawcontext, c, True, awesomeconf);
  69         restack(c->display, drawcontext, awesomeconf);
  70     }
  71 }
  72
  73 void
  74 uicb_focusprev(Display *disp __attribute__ ((unused)),
  75                DC *drawcontext,
  76                awesome_config *awesomeconf,
  77                const char *arg __attribute__ ((unused)))
  78 {
  79     Client *c;
  80
  81     if(!sel)
  82         return;
  83     for(c = sel->prev; c && !isvisible(c, awesomeconf->screen, awesomeconf->tags, awesomeconf->ntags); c = c->prev);
  84     if(!c)
  85     {
  86         for(c = clients; c && c->next; c = c->next);
  87         for(; c && !isvisible(c, awesomeconf->screen, awesomeconf->tags, awesomeconf->ntags); c = c->prev);
  88     }
  89     if(c)
  90     {
  91         focus(c->display, drawcontext, c, True, awesomeconf);
  92         restack(c->display, drawcontext, awesomeconf);
  93     }
  94 }
  95
  96 void
  97 loadawesomeprops(Display *disp, awesome_config * awesomeconf)
  98 {
  99     int i;
 100     char *prop;
 101
 102     prop = p_new(char, awesomeconf->ntags + 1);
 103
 104     if(xgettextprop(disp, RootWindow(disp, awesomeconf->screen), AWESOMEPROPS_ATOM(disp), prop, awesomeconf->ntags + 1))
 105         for(i = 0; i < awesomeconf->ntags && prop[i]; i++)
 106             awesomeconf->tags[i].selected = prop[i] == '1';
 107
 108     p_delete(&prop);
 109 }
 110
 111 void
 112 restack(Display * disp, DC * drawcontext, awesome_config *awesomeconf)
 113 {
 114     Client *c;
 115     XEvent ev;
 116     XWindowChanges wc;
 117
 118     drawstatusbar(disp, drawcontext, awesomeconf);
 119     if(!sel)
 120         return;
 121     if(sel->isfloating || IS_ARRANGE(layout_floating))
 122         XRaiseWindow(disp, sel->win);
 123     if(!IS_ARRANGE(layout_floating))
 124     {
 125         wc.stack_mode = Below;
 126         wc.sibling = awesomeconf->statusbar.window;
 127         if(!sel->isfloating)
 128         {
 129             XConfigureWindow(disp, sel->win, CWSibling | CWStackMode, &wc);
 130             wc.sibling = sel->win;
 131         }
 132         for(c = clients; c; c = c->next)
 133         {
 134             if(!IS_TILED(c, awesomeconf->screen, awesomeconf->tags, awesomeconf->ntags) || c == sel)
 135                 continue;
 136             XConfigureWindow(disp, c->win, CWSibling | CWStackMode, &wc);
 137             wc.sibling = c->win;
 138         }
 139     }
 140     XSync(disp, False);
 141     while(XCheckMaskEvent(disp, EnterWindowMask, &ev));
 142 }
 143
 144 void
 145 saveawesomeprops(Display *disp, awesome_config *awesomeconf)
 146 {
 147     int i;
 148     char *prop;
 149
 150     prop = p_new(char, awesomeconf->ntags + 1);
 151     for(i = 0; i < awesomeconf->ntags; i++)
 152         prop[i] = awesomeconf->tags[i].selected ? '1' : '0';
 153     prop[i] = '\0';
 154     XChangeProperty(disp, RootWindow(disp, awesomeconf->screen),
 155                     AWESOMEPROPS_ATOM(disp), XA_STRING, 8,
 156                     PropModeReplace, (unsigned char *) prop, i);
 157     p_delete(&prop);
 158 }
 159
 160 void
 161 uicb_setlayout(Display *disp,
 162                DC *drawcontext,
 163                awesome_config * awesomeconf,
 164                const char *arg)
 165 {
 166     int i, j;
 167     Client *c;
 168
 169     if(!arg)
 170     {
 171         if(!(++awesomeconf->current_layout)->symbol)
 172             awesomeconf->current_layout = awesomeconf->layouts;
 173     }
 174     else
 175     {
 176         i = strtol(arg, NULL, 10);
 177         if(i < 0 || i >= awesomeconf->nlayouts)
 178              return;
 179         awesomeconf->current_layout = &awesomeconf->layouts[i];
 180     }
 181
 182     for(c = clients; c; c = c->next)
 183         c->ftview = True;
 184
 185     if(sel)
 186         arrange(disp, drawcontext, awesomeconf);
 187     else
 188         drawstatusbar(disp, drawcontext, awesomeconf);
 189
 190     saveawesomeprops(disp, awesomeconf);
 191
 192     for(j = 0; j < awesomeconf->ntags; j++)
 193         if (awesomeconf->tags[j].selected)
 194             awesomeconf->tags[j].layout = awesomeconf->current_layout;
 195 }
 196
 197 static void
 198 maximize(int x, int y, int w, int h, DC *drawcontext, awesome_config *awesomeconf)
 199 {
 200     if(!sel)
 201         return;
 202
 203     if((sel->ismax = !sel->ismax))
 204     {
 205         sel->wasfloating = sel->isfloating;
 206         sel->isfloating = True;
 207         sel->rx = sel->x;
 208         sel->ry = sel->y;
 209         sel->rw = sel->w;
 210         sel->rh = sel->h;
 211         resize(sel, x, y, w, h, awesomeconf, True);
 212     }
 213     else if(sel->wasfloating)
 214         resize(sel, sel->rx, sel->ry, sel->rw, sel->rh, awesomeconf, True);
 215     else
 216         sel->isfloating = False;
 217
 218     arrange(sel->display, drawcontext, awesomeconf);
 219 }
 220
 221 void
 222 uicb_togglemax(Display *disp,
 223                DC *drawcontext,
 224                awesome_config *awesomeconf,
 225                const char *arg __attribute__ ((unused)))
 226 {
 227     int dummy;
 228     ScreenInfo *si = get_screen_info(disp, awesomeconf->screen, &awesomeconf->statusbar, &dummy);
 229
 230     maximize(si[awesomeconf->screen].x_org, si[awesomeconf->screen].y_org,
 231              si[awesomeconf->screen].width - 2 * awesomeconf->borderpx,
 232              si[awesomeconf->screen].height - 2 * awesomeconf->borderpx,
 233              drawcontext, awesomeconf);
 234     XFree(si);
 235 }
 236
 237 void
 238 uicb_toggleverticalmax(Display *disp,
 239                        DC *drawcontext,
 240                        awesome_config *awesomeconf,
 241                        const char *arg __attribute__ ((unused)))
 242 {
 243     int dummy;
 244     ScreenInfo *si = get_screen_info(disp, awesomeconf->screen, &awesomeconf->statusbar, &dummy);
 245
 246     if(sel)
 247         maximize(sel->x, si[awesomeconf->screen].y_org,
 248                  sel->w, si[awesomeconf->screen].height - 2 * awesomeconf->borderpx,
 249                  drawcontext, awesomeconf);
 250     XFree(si);
 251 }
 252
 253
 254 void
 255 uicb_togglehorizontalmax(Display *disp,
 256                          DC *drawcontext,
 257                          awesome_config *awesomeconf,
 258                          const char *arg __attribute__ ((unused)))
 259 {
 260     int dummy;
 261     ScreenInfo *si = get_screen_info(disp, awesomeconf->screen, &awesomeconf->statusbar, &dummy);
 262
 263     if(sel)
 264         maximize(si[awesomeconf->screen].x_org, sel->y,
 265                  si[awesomeconf->screen].height - 2 * awesomeconf->borderpx, sel->h,
 266                  drawcontext, awesomeconf);
 267     XFree(si);
 268 }
 269
 270 void
 271 uicb_zoom(Display *disp __attribute__ ((unused)),
 272           DC *drawcontext __attribute__ ((unused)),
 273           awesome_config *awesomeconf,
 274           const char *arg __attribute__ ((unused)))
 275 {
 276     if(!sel)
 277         return;
 278     detach(sel);
 279     attach(sel);
 280     focus(sel->display, drawcontext, sel, True, awesomeconf);
 281     arrange(sel->display, drawcontext, awesomeconf);
 282 }
 283