src/resize.c

   1 /*
   2  * ion/resize.c
   3  *
   4  * Copyright (c) Tuomo Valkonen 1999-2001.
   5  * See the included file LICENSE for details.
   6  */
   7
   8 #include "common.h"
   9 #include "global.h"
  10 #include "split.h"
  11 #include "resize.h"
  12 #include "signal.h"
  13 #include "event.h"
  14 #include "cursor.h"
  15 #include "sizehint.h"
  16 #include "draw.h"
  17 #include "grab.h"
  18
  19
  20 #define XOR_RESIZE (!wglobal.opaque_resize)
  21
  22 static bool resize_handler(WThing *thing, XEvent *ev);
  23
  24 static bool resize_mode=FALSE;
  25 static int tmpsize;
  26 static WResizeTmp rtmp;
  27
  28
  29 /*{{{ Resize timer */
  30
  31
  32 static void tmr_end_resize(WTimer *unused)
  33 {
  34         WThing *holder;
  35         if(!resize_mode){
  36                 return;
  37         }
  38         holder=grab_get_holder(resize_handler);
  39         assert(holder && WTHING_IS(holder, WWindow));
  40
  41         end_resize((WWindow*)holder);
  42 }
  43
  44 static WTimer resize_timer=INIT_TIMER(tmr_end_resize);
  45
  46
  47 /*}}}*/
  48
  49
  50 /*{{{ Rubberband and size display */
  51
  52
  53 static void res_draw_rubberband(WScreen *scr, WRectangle geom)
  54 {
  55         if(rtmp.startnode!=NULL){
  56                 if(WOBJ_IS(rtmp.startnode, WWindow))
  57                         geom=((WWindow*)rtmp.startnode)->geom;
  58                 else
  59                         geom=((WWsSplit*)rtmp.startnode)->geom;
  60         }
  61
  62         if(rtmp.dir==HORIZONTAL){
  63                 geom.x=rtmp.winpostmp;
  64                 geom.w=rtmp.winsizetmp;
  65         }else{
  66                 geom.y=rtmp.winpostmp;
  67                 geom.h=rtmp.winsizetmp;
  68         }
  69
  70         draw_rubberband(scr, geom, rtmp.dir==VERTICAL);
  71 }
  72
  73
  74 static void cwin_size(WScreen *scr, int *w, int *h, XSizeHints *sh)
  75 {
  76         correct_size(w, h, sh, FALSE);
  77
  78         if(sh->flags&PBaseSize){
  79                 *w-=sh->base_width;
  80                 *h-=sh->base_height;
  81         }
  82
  83         if(sh->flags&PResizeInc){
  84                 *w/=sh->width_inc;
  85                 *h/=sh->height_inc;
  86         }else{
  87                 *w/=scr->w_unit;
  88                 *h/=scr->h_unit;
  89         }
  90 }
  91
  92
  93 static void res_draw_moveres(WScreen *scr, WWindow *wwin)
  94 {
  95         int w, h, x, y;
  96         WClientWin *cwin;
  97
  98         if(rtmp.dir==HORIZONTAL){
  99                 x=rtmp.winpostmp;
 100                 w=rtmp.winsizetmp;
 101                 h=wwin->geom.h;
 102                 y=wwin->geom.y;
 103         }else{
 104                 x=wwin->geom.x;
 105                 w=wwin->geom.w;
 106                 y=rtmp.winpostmp;
 107                 h=rtmp.winsizetmp;
 108         }
 109
 110         if(WTHING_IS(wwin, WFrame)){
 111                 w+=FRAME_CLIENT_WOFF(scr);
 112                 h+=FRAME_CLIENT_HOFF(scr);
 113                 if(((WFrame*)wwin)->current_client!=NULL &&
 114                         (cwin=FIRST_THING(((WFrame*)wwin)->current_client,
 115                                                           WClientWin))!=NULL){
 116                         cwin_size(scr, &w, &h, &(cwin->size_hints));
 117                 }else{
 118                         w/=scr->w_unit;
 119                         h/=scr->h_unit;
 120                 }
 121         }
 122
 123         set_moveres_size(scr, w, h);
 124 }
 125
 126
 127 /*}}}*/
 128
 129
 130 /*{{{ Resize/common */
 131
 132
 133 static int do_calc_resize(int s, int unit, int off)
 134 {
 135         s-=off;
 136         s=(s/unit)*unit;
 137         return s+off;
 138 }
 139
 140
 141 static int calc_resize(WScreen *scr, int s, int dir)
 142 {
 143         if(dir==VERTICAL)
 144                 return do_calc_resize(s, scr->h_unit, FRAME_CLIENT_HOFF(scr));
 145         else
 146                 return do_calc_resize(s, scr->w_unit, FRAME_CLIENT_WOFF(scr));
 147 }
 148
 149
 150 void begin_resize(WWindow *wwin, int dir, int primn)
 151 {
 152         WScreen *scr=SCREEN_OF(wwin);
 153
 154         tmpsize=wwin_size(wwin, dir);
 155         resize_mode=TRUE;
 156
 157         if(XOR_RESIZE)
 158                 XGrabServer(wglobal.dpy);
 159
 160         XMoveWindow(wglobal.dpy, scr->grdata.moveres_win,
 161                                 wwin->geom.x+(wwin->geom.w-scr->grdata.moveres_geom.w)/2,
 162                                 wwin->geom.y+(wwin->geom.h-scr->grdata.moveres_geom.h)/2);
 163         XMapRaised(wglobal.dpy, scr->grdata.moveres_win);
 164
 165         calcresize_window(wwin, dir, primn, tmpsize, &rtmp);
 166
 167         res_draw_moveres(scr, wwin);
 168
 169         if(XOR_RESIZE)
 170                 res_draw_rubberband(scr, wwin->geom);
 171 }
 172
 173
 174 void resize(WWindow *wwin, int delta, int primn, bool settmp)
 175 {
 176         WScreen *scr=SCREEN_OF(wwin);
 177         int s, old;
 178         int dir=rtmp.dir;
 179
 180         if(XOR_RESIZE)
 181                 res_draw_rubberband(scr, wwin->geom);
 182
 183         tmpsize+=delta;
 184         s=calc_resize(SCREEN_OF(wwin), tmpsize, dir);
 185         old=rtmp.winsizetmp;
 186
 187         calcresize_window(wwin, dir, primn, s, &rtmp);
 188
 189         if(settmp)
 190                 tmpsize=rtmp.winsizetmp;
 191
 192         res_draw_moveres(scr, wwin);
 193
 194         if(XOR_RESIZE)
 195                 res_draw_rubberband(scr, wwin->geom);
 196         else
 197                 resize_tmp(&rtmp);
 198 }
 199
 200
 201 void end_resize(WWindow *wwin)
 202 {
 203         WScreen *scr=SCREEN_OF(wwin);
 204
 205         if(!resize_mode)
 206                 return;
 207
 208         resize_mode=FALSE;
 209
 210         reset_timer(&resize_timer);
 211
 212         if(XOR_RESIZE){
 213                 res_draw_rubberband(scr, wwin->geom);
 214                 resize_tmp(&rtmp);
 215                 XUngrabServer(wglobal.dpy);
 216         }
 217         XUnmapWindow(wglobal.dpy, scr->grdata.moveres_win);
 218 }
 219
 220
 221 void cancel_resize(WWindow *wwin)
 222 {
 223         WScreen *scr=SCREEN_OF(wwin);
 224
 225         if(!resize_mode)
 226                 return;
 227
 228         resize_mode=FALSE;
 229
 230         reset_timer(&resize_timer);
 231
 232         if(XOR_RESIZE){
 233                 res_draw_rubberband(scr, wwin->geom);
 234                 XUngrabServer(wglobal.dpy);
 235         }
 236         XUnmapWindow(wglobal.dpy, scr->grdata.moveres_win);
 237 }
 238
 239
 240 /*}}}*/
 241
 242
 243 /*{{{ Keyboard resize */
 244
 245 static bool resize_handler(WThing *thing, XEvent *xev)
 246 {
 247         XKeyEvent *ev=&xev->xkey;
 248         WScreen *scr;
 249         WBinding *binding=NULL;
 250         WBindmap **bindptr;
 251
 252         if(!resize_mode){
 253                 return TRUE;
 254         }
 255
 256         if(ev->type==KeyRelease)
 257                 return FALSE;
 258
 259         assert(thing && WTHING_IS(thing, WWindow));
 260         binding=lookup_binding(&wglobal.moveres_bindmap, ACT_KEYPRESS, ev->state, ev->keycode);
 261
 262         if(!binding)
 263                 return FALSE;
 264
 265         if(binding){
 266                 /* Get the screen now for waitrel grab - the thing might
 267                  * have been destroyed when call_binding returns.
 268                  */
 269                 scr=SCREEN_OF(thing);
 270                 call_binding(binding, thing);
 271         }
 272
 273         return !resize_mode;
 274 }
 275
 276 static void begin_keyresize(WWindow *wwin, int dir)
 277 {
 278         if(resize_mode)
 279                 return;
 280
 281         begin_resize(wwin, dir, ANY);
 282
 283         grab_establish((WThing*)wwin, resize_handler, FocusChangeMask);
 284         change_grab_cursor(CURSOR_RESIZE);
 285 }
 286
 287
 288 static int get_unit(WWindow *wwin)
 289 {
 290         WScreen *scr=SCREEN_OF(wwin);
 291         return (rtmp.dir==VERTICAL ? scr->h_unit : scr->w_unit);
 292 }
 293
 294
 295 void grow(WWindow *wwin)
 296 {
 297         if(!resize_mode)
 298                 resize_vert(wwin);
 299         resize(wwin, get_unit(wwin), ANY, TRUE);
 300         set_timer(&resize_timer, wglobal.resize_delay);
 301 }
 302
 303
 304 void shrink(WWindow *wwin)
 305 {
 306         if(!resize_mode)
 307                 resize_vert(wwin);
 308         resize(wwin, -get_unit(wwin), ANY, TRUE);
 309         set_timer(&resize_timer, wglobal.resize_delay);
 310 }
 311
 312
 313 void resize_vert(WWindow *wwin)
 314 {
 315         begin_keyresize(wwin, VERTICAL);
 316 }
 317
 318
 319 void resize_horiz(WWindow *wwin)
 320 {
 321         begin_keyresize(wwin, HORIZONTAL);
 322 }
 323
 324
 325 /*}}}*/
 326
 327
 328 /*{{{ Maximize */
 329
 330
 331 static void do_maximize(WWindow *wwin, int dir, int flag,
 332                                                 int *saved_size, int max_size)
 333 {
 334         WResizeTmp rtmp;
 335
 336         if(wwin->flags&flag){
 337                 calcresize_window(wwin, dir, ANY, *saved_size, &rtmp);
 338                 resize_tmp(&rtmp);
 339                 wwin->flags&=~flag;
 340         }else{
 341                 *saved_size=wwin_size(wwin, dir);
 342                 calcresize_window(wwin, dir, ANY, max_size, &rtmp);
 343                 resize_tmp(&rtmp);
 344                 wwin->flags|=flag;
 345         }
 346 }
 347
 348
 349 void maximize_vert(WWindow *wwin)
 350 {
 351         WScreen *scr=SCREEN_OF(wwin);
 352
 353         if(scr!=NULL){
 354                 do_maximize(wwin, VERTICAL, WWINDOW_HFORCED,
 355                                         &(wwin->saved_h), scr->root.geom.h);
 356         }
 357 }
 358
 359
 360 void maximize_horiz(WWindow *wwin)
 361 {
 362         WScreen *scr=SCREEN_OF(wwin);
 363
 364         if(scr!=NULL){
 365                 do_maximize(wwin, HORIZONTAL, WWINDOW_WFORCED,
 366                                         &(wwin->saved_w), scr->root.geom.w);
 367         }
 368 }
 369
 370
 371 /*}}}*/
 372
 373
 374 /*{{{ Set size */
 375
 376
 377 void set_height(WWindow *wwin, uint h)
 378 {
 379         WResizeTmp rtmp;
 380         calcresize_window(wwin, VERTICAL, ANY, h, &rtmp);
 381         resize_tmp(&rtmp);
 382 }
 383
 384
 385 void set_width(WWindow *wwin, uint w)
 386 {
 387         WResizeTmp rtmp;
 388         calcresize_window(wwin, HORIZONTAL, ANY, w, &rtmp);
 389         resize_tmp(&rtmp);
 390 }
 391
 392 void set_heightq(WWindow *wwin, double q)
 393 {
 394         WScreen *scr=SCREEN_OF(wwin);
 395         set_height(wwin, q*(double)scr->root.geom.h);
 396 }
 397
 398 void set_widthq(WWindow *wwin, double q)
 399 {
 400         WScreen *scr=SCREEN_OF(wwin);
 401         set_width(wwin, q*(double)scr->root.geom.w);
 402 }
 403
 404 /*}}}*/
 405