openbox/moveresize.c

   1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
   2
   3    moveresize.c for the Openbox window manager
   4    Copyright (c) 2006        Mikael Magnusson
   5    Copyright (c) 2003-2007   Dana Jansens
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    See the COPYING file for a copy of the GNU General Public License.
  18 */
  19
  20 #include "grab.h"
  21 #include "framerender.h"
  22 #include "screen.h"
  23 #include "prop.h"
  24 #include "client.h"
  25 #include "frame.h"
  26 #include "openbox.h"
  27 #include "resist.h"
  28 #include "popup.h"
  29 #include "moveresize.h"
  30 #include "config.h"
  31 #include "event.h"
  32 #include "debug.h"
  33 #include "extensions.h"
  34 #include "render/render.h"
  35 #include "render/theme.h"
  36
  37 #include <X11/Xlib.h>
  38 #include <glib.h>
  39
  40 /* how far windows move and resize with the keyboard arrows */
  41 #define KEY_DIST 4
  42
  43 gboolean moveresize_in_progress = FALSE;
  44 ObClient *moveresize_client = NULL;
  45 #ifdef SYNC
  46 XSyncAlarm moveresize_alarm = None;
  47 #endif
  48
  49 static gboolean moving = FALSE; /* TRUE - moving, FALSE - resizing */
  50
  51 static gint start_x, start_y, start_cx, start_cy, start_cw, start_ch;
  52 static gint cur_x, cur_y;
  53 static guint button;
  54 static guint32 corner;
  55 static ObCorner lockcorner;
  56 #ifdef SYNC
  57 static gboolean waiting_for_sync;
  58 #endif
  59
  60 static ObPopup *popup = NULL;
  61
  62 static void client_dest(ObClient *client, gpointer data)
  63 {
  64     if (moveresize_client == client)
  65         moveresize_end(TRUE);
  66 }
  67
  68 void moveresize_startup(gboolean reconfig)
  69 {
  70     popup = popup_new(FALSE);
  71
  72     if (!reconfig)
  73         client_add_destructor(client_dest, NULL);
  74 }
  75
  76 void moveresize_shutdown(gboolean reconfig)
  77 {
  78     if (!reconfig) {
  79         if (moveresize_in_progress)
  80             moveresize_end(FALSE);
  81         client_remove_destructor(client_dest);
  82     }
  83
  84     popup_free(popup);
  85     popup = NULL;
  86 }
  87
  88 static void get_resize_position(gint *x, gint *y, gboolean cancel)
  89 {
  90     gint dw, dh;
  91     gint w, h, lw, lh;
  92
  93     *x = moveresize_client->frame->area.x;
  94     *y = moveresize_client->frame->area.y;
  95
  96     if (cancel) {
  97         w = start_cw;
  98         h = start_ch;
  99     } else {
 100         w = cur_x;
 101         h = cur_y;
 102     }
 103
 104     /* see how much it is actually going to resize */
 105     {
 106         gint cx = *x, cy = *y;
 107         frame_frame_gravity(moveresize_client->frame, &cx, &cy, w, h);
 108         client_try_configure(moveresize_client, &cx, &cy, &w, &h,
 109                              &lw, &lh, TRUE);
 110     }
 111     dw = w - moveresize_client->area.width;
 112     dh = h - moveresize_client->area.height;
 113
 114     switch (lockcorner) {
 115     case OB_CORNER_TOPLEFT:
 116         break;
 117     case OB_CORNER_TOPRIGHT:
 118         *x -= dw;
 119         break;
 120     case OB_CORNER_BOTTOMLEFT:
 121         *y -= dh;
 122         break;
 123     case OB_CORNER_BOTTOMRIGHT:
 124         *x -= dw;
 125         *y -= dh;
 126         break;
 127     }
 128
 129     frame_frame_gravity(moveresize_client->frame, x, y, w, h);
 130 }
 131
 132 static void popup_coords(ObClient *c, const gchar *format, gint a, gint b)
 133 {
 134     gchar *text;
 135
 136     text = g_strdup_printf(format, a, b);
 137     if (config_resize_popup_pos == 1) /* == "Top" */
 138         popup_position(popup, SouthGravity,
 139                        c->frame->area.x
 140                      + c->frame->area.width/2,
 141                        c->frame->area.y - ob_rr_theme->fbwidth);
 142     else /* == "Center" */
 143         popup_position(popup, CenterGravity,
 144                        c->frame->area.x + c->frame->size.left +
 145                        c->area.width / 2,
 146                        c->frame->area.y + c->frame->size.top +
 147                        c->area.height / 2);
 148     popup_show(popup, text);
 149     g_free(text);
 150 }
 151
 152 void moveresize_start(ObClient *c, gint x, gint y, guint b, guint32 cnr)
 153 {
 154     ObCursor cur;
 155
 156     moving = (cnr == prop_atoms.net_wm_moveresize_move ||
 157               cnr == prop_atoms.net_wm_moveresize_move_keyboard);
 158
 159     if (moveresize_in_progress || !c->frame->visible ||
 160         !(moving ?
 161           (c->functions & OB_CLIENT_FUNC_MOVE) :
 162           (c->functions & OB_CLIENT_FUNC_RESIZE)))
 163         return;
 164
 165     frame_end_iconify_animation(c->frame);
 166
 167     moveresize_client = c;
 168     start_cx = c->area.x;
 169     start_cy = c->area.y;
 170     /* these adjustments for the size_inc make resizing a terminal more
 171        friendly. you essentially start the resize in the middle of the
 172        increment instead of at 0, so you have to move half an increment
 173        either way instead of a full increment one and 1 px the other. and this
 174        is one large mother fucking comment. */
 175     start_cw = c->area.width + c->size_inc.width / 2;
 176     start_ch = c->area.height + c->size_inc.height / 2;
 177     start_x = x;
 178     start_y = y;
 179     corner = cnr;
 180     button = b;
 181
 182     /*
 183       have to change start_cx and start_cy if going to do this..
 184     if (corner == prop_atoms.net_wm_moveresize_move_keyboard ||
 185         corner == prop_atoms.net_wm_moveresize_size_keyboard)
 186         XWarpPointer(ob_display, None, c->window, 0, 0, 0, 0,
 187                      c->area.width / 2, c->area.height / 2);
 188     */
 189
 190     if (moving) {
 191         cur_x = start_cx;
 192         cur_y = start_cy;
 193     } else {
 194         cur_x = start_cw;
 195         cur_y = start_ch;
 196     }
 197
 198     moveresize_in_progress = TRUE;
 199
 200     if (corner == prop_atoms.net_wm_moveresize_size_topleft)
 201         cur = OB_CURSOR_NORTHWEST;
 202     else if (corner == prop_atoms.net_wm_moveresize_size_top)
 203         cur = OB_CURSOR_NORTH;
 204     else if (corner == prop_atoms.net_wm_moveresize_size_topright)
 205         cur = OB_CURSOR_NORTHEAST;
 206     else if (corner == prop_atoms.net_wm_moveresize_size_right)
 207         cur = OB_CURSOR_EAST;
 208     else if (corner == prop_atoms.net_wm_moveresize_size_bottomright)
 209         cur = OB_CURSOR_SOUTHEAST;
 210     else if (corner == prop_atoms.net_wm_moveresize_size_bottom)
 211         cur = OB_CURSOR_SOUTH;
 212     else if (corner == prop_atoms.net_wm_moveresize_size_bottomleft)
 213         cur = OB_CURSOR_SOUTHWEST;
 214     else if (corner == prop_atoms.net_wm_moveresize_size_left)
 215         cur = OB_CURSOR_WEST;
 216     else if (corner == prop_atoms.net_wm_moveresize_size_keyboard)
 217         cur = OB_CURSOR_SOUTHEAST;
 218     else if (corner == prop_atoms.net_wm_moveresize_move)
 219         cur = OB_CURSOR_MOVE;
 220     else if (corner == prop_atoms.net_wm_moveresize_move_keyboard)
 221         cur = OB_CURSOR_MOVE;
 222     else
 223         g_assert_not_reached();
 224
 225 #ifdef SYNC
 226     if (config_resize_redraw && !moving && extensions_shape &&
 227         moveresize_client->sync_request && moveresize_client->sync_counter)
 228     {
 229         /* Initialize values for the resize syncing, and create an alarm for
 230            the client's xsync counter */
 231
 232         XSyncValue val;
 233         XSyncAlarmAttributes aa;
 234
 235         /* set the counter to an initial value */
 236         XSyncIntToValue(&val, 0);
 237         XSyncSetCounter(ob_display, moveresize_client->sync_counter, val);
 238
 239         /* this will be incremented when we tell the client what we're
 240            looking for */
 241         moveresize_client->sync_counter_value = 0;
 242
 243         /* the next sequence we're waiting for with the alarm */
 244         XSyncIntToValue(&val, 1);
 245
 246         /* set an alarm on the counter */
 247         aa.trigger.counter = moveresize_client->sync_counter;
 248         aa.trigger.wait_value = val;
 249         aa.trigger.value_type = XSyncAbsolute;
 250         aa.trigger.test_type = XSyncPositiveTransition;
 251         aa.events = True;
 252         XSyncIntToValue(&aa.delta, 1);
 253         moveresize_alarm = XSyncCreateAlarm(ob_display,
 254                                             XSyncCACounter |
 255                                             XSyncCAValue |
 256                                             XSyncCAValueType |
 257                                             XSyncCATestType |
 258                                             XSyncCADelta |
 259                                             XSyncCAEvents,
 260                                             &aa);
 261
 262         waiting_for_sync = FALSE;
 263     }
 264 #endif
 265
 266     grab_pointer(TRUE, FALSE, cur);
 267     grab_keyboard(TRUE);
 268 }
 269
 270 void moveresize_end(gboolean cancel)
 271 {
 272     gint x, y;
 273
 274     grab_keyboard(FALSE);
 275     grab_pointer(FALSE, FALSE, OB_CURSOR_NONE);
 276
 277     popup_hide(popup);
 278
 279     if (moving) {
 280         client_move(moveresize_client,
 281                     (cancel ? start_cx : cur_x),
 282                     (cancel ? start_cy : cur_y));
 283     } else {
 284 #ifdef SYNC
 285         /* turn off the alarm */
 286         if (moveresize_alarm != None) {
 287             XSyncDestroyAlarm(ob_display, moveresize_alarm);
 288             moveresize_alarm = None;
 289         }
 290 #endif
 291
 292         get_resize_position(&x, &y, cancel);
 293         client_configure(moveresize_client, x, y,
 294                          (cancel ? start_cw : cur_x),
 295                          (cancel ? start_ch : cur_y), TRUE, TRUE);
 296     }
 297
 298     moveresize_in_progress = FALSE;
 299     moveresize_client = NULL;
 300 }
 301
 302 static void do_move(gboolean keyboard)
 303 {
 304     gint resist;
 305
 306     if (keyboard) resist = KEY_DIST - 1; /* resist for one key press */
 307     else resist = config_resist_win;
 308     resist_move_windows(moveresize_client, resist, &cur_x, &cur_y);
 309     if (!keyboard) resist = config_resist_edge;
 310     resist_move_monitors(moveresize_client, resist, &cur_x, &cur_y);
 311
 312     client_configure(moveresize_client, cur_x, cur_y,
 313                      moveresize_client->area.width,
 314                      moveresize_client->area.height, TRUE, FALSE);
 315     if (config_resize_popup_show == 2) /* == "Always" */
 316         popup_coords(moveresize_client, "%d x %d",
 317                      moveresize_client->frame->area.x,
 318                      moveresize_client->frame->area.y);
 319 }
 320
 321 static void do_resize()
 322 {
 323 #ifdef SYNC
 324     if (config_resize_redraw && extensions_sync &&
 325         moveresize_client->sync_request && moveresize_client->sync_counter)
 326     {
 327         XEvent ce;
 328         XSyncValue val;
 329         gint x, y, w, h, lw, lh;
 330
 331         /* are we already waiting for the sync counter to catch up? */
 332         if (waiting_for_sync)
 333             return;
 334
 335         /* see if it is actually going to resize */
 336         x = 0;
 337         y = 0;
 338         w = cur_x;
 339         h = cur_y;
 340         client_try_configure(moveresize_client, &x, &y, &w, &h,
 341                              &lw, &lh, TRUE);
 342         if (w == moveresize_client->area.width &&
 343             h == moveresize_client->area.height)
 344         {
 345             return;
 346         }
 347
 348         /* increment the value we're waiting for */
 349         ++moveresize_client->sync_counter_value;
 350         XSyncIntToValue(&val, moveresize_client->sync_counter_value);
 351
 352         /* tell the client what we're waiting for */
 353         ce.xclient.type = ClientMessage;
 354         ce.xclient.message_type = prop_atoms.wm_protocols;
 355         ce.xclient.display = ob_display;
 356         ce.xclient.window = moveresize_client->window;
 357         ce.xclient.format = 32;
 358         ce.xclient.data.l[0] = prop_atoms.net_wm_sync_request;
 359         ce.xclient.data.l[1] = event_curtime;
 360         ce.xclient.data.l[2] = XSyncValueLow32(val);
 361         ce.xclient.data.l[3] = XSyncValueHigh32(val);
 362         ce.xclient.data.l[4] = 0l;
 363         XSendEvent(ob_display, moveresize_client->window, FALSE,
 364                    NoEventMask, &ce);
 365
 366         waiting_for_sync = TRUE;
 367     }
 368 #endif
 369
 370     {
 371         gint x, y;
 372         get_resize_position(&x, &y, FALSE);
 373         client_configure(moveresize_client, x, y, cur_x, cur_y, TRUE, FALSE);
 374     }
 375
 376     /* this would be better with a fixed width font ... XXX can do it better
 377        if there are 2 text boxes */
 378     if (config_resize_popup_show == 2 || /* == "Always" */
 379             (config_resize_popup_show == 1 && /* == "Nonpixel" */
 380              moveresize_client->size_inc.width > 1 &&
 381              moveresize_client->size_inc.height > 1))
 382         popup_coords(moveresize_client, "%d x %d",
 383                      moveresize_client->logical_size.width,
 384                      moveresize_client->logical_size.height);
 385 }
 386
 387 static void calc_resize(gboolean keyboard)
 388 {
 389     gint resist;
 390
 391     /* resist_size_* needs the frame size */
 392     cur_x += moveresize_client->frame->size.left +
 393         moveresize_client->frame->size.right;
 394     cur_y += moveresize_client->frame->size.top +
 395         moveresize_client->frame->size.bottom;
 396
 397     if (keyboard) resist = KEY_DIST - 1; /* resist for one key press */
 398     else resist = config_resist_win;
 399     resist_size_windows(moveresize_client, resist, &cur_x, &cur_y, lockcorner);
 400     if (!keyboard) resist = config_resist_edge;
 401     resist_size_monitors(moveresize_client, resist, &cur_x, &cur_y,lockcorner);
 402
 403     cur_x -= moveresize_client->frame->size.left +
 404         moveresize_client->frame->size.right;
 405     cur_y -= moveresize_client->frame->size.top +
 406         moveresize_client->frame->size.bottom;
 407 }
 408
 409 gboolean moveresize_event(XEvent *e)
 410 {
 411     gboolean used = FALSE;
 412
 413     g_assert(moveresize_in_progress);
 414
 415     if (e->type == ButtonPress) {
 416         if (!button) {
 417             start_x = e->xbutton.x_root;
 418             start_y = e->xbutton.y_root;
 419             button = e->xbutton.button; /* this will end it now */
 420         }
 421         used = e->xbutton.button == button;
 422     } else if (e->type == ButtonRelease) {
 423         if (!button || e->xbutton.button == button) {
 424             moveresize_end(FALSE);
 425             used = TRUE;
 426         }
 427     } else if (e->type == MotionNotify) {
 428         if (moving) {
 429             cur_x = start_cx + e->xmotion.x_root - start_x;
 430             cur_y = start_cy + e->xmotion.y_root - start_y;
 431             do_move(FALSE);
 432         } else {
 433             if (corner == prop_atoms.net_wm_moveresize_size_topleft) {
 434                 cur_x = start_cw - (e->xmotion.x_root - start_x);
 435                 cur_y = start_ch - (e->xmotion.y_root - start_y);
 436                 lockcorner = OB_CORNER_BOTTOMRIGHT;
 437             } else if (corner == prop_atoms.net_wm_moveresize_size_top) {
 438                 cur_x = start_cw;
 439                 cur_y = start_ch - (e->xmotion.y_root - start_y);
 440                 lockcorner = OB_CORNER_BOTTOMRIGHT;
 441             } else if (corner == prop_atoms.net_wm_moveresize_size_topright) {
 442                 cur_x = start_cw + (e->xmotion.x_root - start_x);
 443                 cur_y = start_ch - (e->xmotion.y_root - start_y);
 444                 lockcorner = OB_CORNER_BOTTOMLEFT;
 445             } else if (corner == prop_atoms.net_wm_moveresize_size_right) {
 446                 cur_x = start_cw + (e->xmotion.x_root - start_x);
 447                 cur_y = start_ch;
 448                 lockcorner = OB_CORNER_BOTTOMLEFT;
 449             } else if (corner ==
 450                        prop_atoms.net_wm_moveresize_size_bottomright) {
 451                 cur_x = start_cw + (e->xmotion.x_root - start_x);
 452                 cur_y = start_ch + (e->xmotion.y_root - start_y);
 453                 lockcorner = OB_CORNER_TOPLEFT;
 454             } else if (corner == prop_atoms.net_wm_moveresize_size_bottom) {
 455                 cur_x = start_cw;
 456                 cur_y = start_ch + (e->xmotion.y_root - start_y);
 457                 lockcorner = OB_CORNER_TOPLEFT;
 458             } else if (corner ==
 459                        prop_atoms.net_wm_moveresize_size_bottomleft) {
 460                 cur_x = start_cw - (e->xmotion.x_root - start_x);
 461                 cur_y = start_ch + (e->xmotion.y_root - start_y);
 462                 lockcorner = OB_CORNER_TOPRIGHT;
 463             } else if (corner == prop_atoms.net_wm_moveresize_size_left) {
 464                 cur_x = start_cw - (e->xmotion.x_root - start_x);
 465                 cur_y = start_ch;
 466                 lockcorner = OB_CORNER_TOPRIGHT;
 467             } else if (corner == prop_atoms.net_wm_moveresize_size_keyboard) {
 468                 cur_x = start_cw + (e->xmotion.x_root - start_x);
 469                 cur_y = start_ch + (e->xmotion.y_root - start_y);
 470                 lockcorner = OB_CORNER_TOPLEFT;
 471             } else
 472                 g_assert_not_reached();
 473
 474             calc_resize(FALSE);
 475             do_resize();
 476         }
 477         used = TRUE;
 478     } else if (e->type == KeyPress) {
 479         if (e->xkey.keycode == ob_keycode(OB_KEY_ESCAPE)) {
 480             moveresize_end(TRUE);
 481             used = TRUE;
 482         } else if (e->xkey.keycode == ob_keycode(OB_KEY_RETURN)) {
 483             moveresize_end(FALSE);
 484             used = TRUE;
 485         } else if (e->xkey.keycode == ob_keycode(OB_KEY_RIGHT) ||
 486                    e->xkey.keycode == ob_keycode(OB_KEY_LEFT) ||
 487                    e->xkey.keycode == ob_keycode(OB_KEY_DOWN) ||
 488                    e->xkey.keycode == ob_keycode(OB_KEY_UP))
 489         {
 490             if (corner == prop_atoms.net_wm_moveresize_size_keyboard) {
 491                 gint dx = 0, dy = 0, ox = cur_x, oy = cur_y;
 492
 493                 if (e->xkey.keycode == ob_keycode(OB_KEY_RIGHT))
 494                     dx = MAX(KEY_DIST, moveresize_client->size_inc.width);
 495                 else if (e->xkey.keycode == ob_keycode(OB_KEY_LEFT))
 496                     dx = -MAX(KEY_DIST, moveresize_client->size_inc.width);
 497                 else if (e->xkey.keycode == ob_keycode(OB_KEY_DOWN))
 498                     dy = MAX(KEY_DIST, moveresize_client->size_inc.height);
 499                 else /* if (e->xkey.keycode == ob_keycode(OB_KEY_UP)) */
 500                     dy = -MAX(KEY_DIST, moveresize_client->size_inc.height);
 501
 502                 cur_x += dx;
 503                 cur_y += dy;
 504                 XWarpPointer(ob_display, None, None, 0, 0, 0, 0, dx, dy);
 505                 /* steal the motion events this causes */
 506                 XSync(ob_display, FALSE);
 507                 {
 508                     XEvent ce;
 509                     while (XCheckTypedEvent(ob_display, MotionNotify, &ce));
 510                 }
 511
 512                 calc_resize(TRUE);
 513                 do_resize();
 514
 515                 /* because the cursor moves even though the window does
 516                    not nessesarily (resistance), this adjusts where the curor
 517                    thinks it started so that it keeps up with where the window
 518                    actually is */
 519                 start_x += dx - (cur_x - ox);
 520                 start_y += dy - (cur_y - oy);
 521
 522                 used = TRUE;
 523             } else if (corner == prop_atoms.net_wm_moveresize_move_keyboard) {
 524                 gint dx = 0, dy = 0, ox = cur_x, oy = cur_y;
 525                 gint opx, px, opy, py;
 526
 527                 if (e->xkey.keycode == ob_keycode(OB_KEY_RIGHT))
 528                     dx = KEY_DIST;
 529                 else if (e->xkey.keycode == ob_keycode(OB_KEY_LEFT))
 530                     dx = -KEY_DIST;
 531                 else if (e->xkey.keycode == ob_keycode(OB_KEY_DOWN))
 532                     dy = KEY_DIST;
 533                 else /* if (e->xkey.keycode == ob_keycode(OB_KEY_UP)) */
 534                     dy = -KEY_DIST;
 535
 536                 cur_x += dx;
 537                 cur_y += dy;
 538                 screen_pointer_pos(&opx, &opy);
 539                 XWarpPointer(ob_display, None, None, 0, 0, 0, 0, dx, dy);
 540                 /* steal the motion events this causes */
 541                 XSync(ob_display, FALSE);
 542                 {
 543                     XEvent ce;
 544                     while (XCheckTypedEvent(ob_display, MotionNotify, &ce));
 545                 }
 546                 screen_pointer_pos(&px, &py);
 547
 548                 do_move(TRUE);
 549
 550                 /* because the cursor moves even though the window does
 551                    not nessesarily (resistance), this adjusts where the curor
 552                    thinks it started so that it keeps up with where the window
 553                    actually is */
 554                 start_x += (px - opx) - (cur_x - ox);
 555                 start_y += (py - opy) - (cur_y - oy);
 556
 557                 used = TRUE;
 558             }
 559         }
 560     }
 561 #ifdef SYNC
 562     else if (e->type == extensions_sync_event_basep + XSyncAlarmNotify)
 563     {
 564         waiting_for_sync = FALSE; /* we got our sync... */
 565         do_resize(); /* ...so try resize if there is more change pending */
 566         used = TRUE;
 567     }
 568 #endif
 569     return used;
 570 }