mouse.c

   1 /*
   2  * mouse.c - mouse managing
   3  *
   4  * Copyright © 2007-2008 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 <math.h>
  23
  24 #include <xcb/xcb.h>
  25 #include <xcb/xcb_aux.h>
  26
  27 #include "mouse.h"
  28 #include "screen.h"
  29 #include "tag.h"
  30 #include "event.h"
  31 #include "client.h"
  32 #include "titlebar.h"
  33 #include "layouts/floating.h"
  34 #include "layouts/tile.h"
  35 #include "common/xscreen.h"
  36
  37 #define MOUSEMASK      (XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_POINTER_MOTION)
  38
  39 extern AwesomeConf globalconf;
  40
  41 static area_t
  42 mouse_snapclienttogeometry_outside(area_t geometry, area_t snap_geometry, int snap)
  43 {
  44     if(geometry.x < snap + snap_geometry.x + snap_geometry.width
  45        && geometry.x > snap_geometry.x + snap_geometry.width)
  46         geometry.x = snap_geometry.x + snap_geometry.width;
  47     else if(geometry.x + geometry.width < snap_geometry.x
  48             && geometry.x + geometry.width > snap_geometry.x - snap)
  49         geometry.x = snap_geometry.x - geometry.width;
  50
  51
  52     if(geometry.y < snap + snap_geometry.y + snap_geometry.height
  53        && geometry.y > snap_geometry.y + snap_geometry.height)
  54         geometry.y = snap_geometry.y + snap_geometry.height;
  55     else if(geometry.y + geometry.height < snap_geometry.y
  56             && geometry.y + geometry.height > snap_geometry.y - snap)
  57         geometry.y = snap_geometry.y - geometry.height;
  58
  59     return geometry;
  60 }
  61
  62 static area_t
  63 mouse_snapclienttogeometry_inside(area_t geometry, area_t snap_geometry, int snap)
  64 {
  65     if(abs(geometry.x) < snap + snap_geometry.x && geometry.x > snap_geometry.x)
  66         geometry.x = snap_geometry.x;
  67     else if(abs((snap_geometry.x + snap_geometry.width) - (geometry.x + geometry.width))
  68             < snap)
  69         geometry.x = snap_geometry.x + snap_geometry.width - geometry.width;
  70     if(abs(geometry.y) < snap + snap_geometry.y && geometry.y > snap_geometry.y)
  71         geometry.y = snap_geometry.y;
  72     else if(abs((snap_geometry.y + snap_geometry.height) - (geometry.y + geometry.height))
  73             < snap)
  74         geometry.y = snap_geometry.y + snap_geometry.height - geometry.height;
  75
  76     return geometry;
  77 }
  78
  79 static area_t
  80 mouse_snapclient(Client *c, area_t geometry)
  81 {
  82     Client *snapper;
  83     int snap = globalconf.screens[c->screen].snap;
  84     area_t snapper_geometry;
  85     area_t screen_geometry =
  86         screen_get_area(c->screen,
  87                         globalconf.screens[c->screen].statusbar,
  88                         &globalconf.screens[c->screen].padding);
  89
  90     geometry = titlebar_geometry_add(&c->titlebar, geometry);
  91     geometry.width += 2 * c->border;
  92     geometry.height += 2 * c->border;
  93
  94     geometry =
  95         mouse_snapclienttogeometry_inside(geometry, screen_geometry, snap);
  96
  97     for(snapper = globalconf.clients; snapper; snapper = snapper->next)
  98         if(snapper != c && client_isvisible(c, c->screen))
  99         {
 100             snapper_geometry = snapper->geometry;
 101             snapper_geometry.width += 2 * c->border;
 102             snapper_geometry.height += 2 * c->border;
 103             snapper_geometry = titlebar_geometry_add(&snapper->titlebar,
 104                                                      snapper_geometry);
 105             geometry =
 106                 mouse_snapclienttogeometry_outside(geometry,
 107                                                    snapper_geometry,
 108                                                    snap);
 109         }
 110
 111     geometry.width -= 2 * c->border;
 112     geometry.height -= 2 * c->border;
 113     return titlebar_geometry_remove(&c->titlebar, geometry);
 114 }
 115
 116 static void
 117 mouse_resizebar_draw(DrawCtx *ctx, style_t style, SimpleWindow *sw, area_t geometry, int border)
 118 {
 119     area_t draw_geometry = { 0, 0, ctx->width, ctx->height, NULL, NULL };
 120     char size[64];
 121
 122     snprintf(size, sizeof(size), "%dx%d+%d+%d",
 123              geometry.x, geometry.y, geometry.width, geometry.height);
 124     draw_text(ctx, draw_geometry, AlignCenter, style.font->height / 2, size, style);
 125     simplewindow_move(sw,
 126                       geometry.x + ((2 * border + geometry.width) - sw->geometry.width) / 2,
 127                       geometry.y + ((2 * border + geometry.height) - sw->geometry.height) / 2);
 128     simplewindow_refresh_drawable(sw, sw->phys_screen);
 129 }
 130
 131 /** Move the focused window with the mouse.
 132  * \param screen Screen ID
 133  * \param arg Unused
 134  * \ingroup ui_callback
 135  */
 136 void
 137 uicb_client_movemouse(int screen, char *arg __attribute__ ((unused)))
 138 {
 139     int ocx, ocy, newscreen;
 140     area_t geometry;
 141     Client *c = globalconf.focus->client, *target;
 142     Layout *layout = layout_get_current(screen);
 143     SimpleWindow *sw = NULL;
 144     DrawCtx *ctx;
 145     style_t style;
 146     xcb_generic_event_t *ev = NULL;
 147     xcb_motion_notify_event_t *ev_motion = NULL;
 148     xcb_grab_pointer_reply_t *grab_pointer_r = NULL;
 149     xcb_query_pointer_reply_t *query_pointer_r = NULL, *mquery_pointer_r = NULL;
 150     xcb_screen_t *s = xcb_aux_get_screen(globalconf.connection, c->phys_screen);
 151
 152     if(!c
 153        || !(grab_pointer_r = xcb_grab_pointer_reply(globalconf.connection,
 154                                                     xcb_grab_pointer(globalconf.connection, false,
 155                                                                      s->root,
 156                                                                      MOUSEMASK, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC,
 157                                                                      s->root,
 158                                                                      globalconf.cursor[CurMove], XCB_CURRENT_TIME),
 159                                                     NULL)))
 160         return;
 161
 162     p_delete(&grab_pointer_r);
 163
 164     query_pointer_r = xcb_query_pointer_reply(globalconf.connection,
 165                                               xcb_query_pointer_unchecked(globalconf.connection,
 166                                                                           s->root),
 167                                               NULL);
 168
 169     geometry = c->geometry;
 170     ocx = geometry.x;
 171     ocy = geometry.y;
 172     c->ismax = false;
 173
 174     style = globalconf.screens[c->screen].styles.focus;
 175
 176     if(c->isfloating || layout->arrange == layout_floating)
 177     {
 178         sw = simplewindow_new(globalconf.connection, c->phys_screen, 0, 0,
 179                               draw_textwidth(globalconf.connection,
 180                                              globalconf.default_screen,
 181                                              globalconf.screens[c->screen].styles.focus.font,
 182                                              "0000x0000+0000+0000") + style.font->height,
 183                               1.5 * style.font->height, 0);
 184
 185         ctx = draw_context_new(globalconf.connection, sw->phys_screen,
 186                                sw->geometry.width, sw->geometry.height,
 187                                sw->drawable);
 188         xutil_map_raised(globalconf.connection, sw->window);
 189         mouse_resizebar_draw(ctx, style, sw, geometry, c->border);
 190     }
 191
 192     for(;;)
 193     {
 194         /* TODO: need a review
 195          *
 196          * XMaskEvent  allows to retrieve  only specified  events from
 197          * the queue and requeue the other events...
 198          */
 199         while((ev = xcb_poll_for_event(globalconf.connection)))
 200         {
 201             switch((ev->response_type & 0x7f))
 202             {
 203             case XCB_BUTTON_RELEASE:
 204                 xcb_ungrab_pointer(globalconf.connection, XCB_CURRENT_TIME);
 205                 if(sw)
 206                 {
 207                     draw_context_delete(&ctx);
 208                     simplewindow_delete(&sw);
 209                 }
 210
 211                 p_delete(&query_pointer_r);
 212                 p_delete(&ev);
 213                 return;
 214             case XCB_MOTION_NOTIFY:
 215                 if(c->isfloating || layout->arrange == layout_floating)
 216                 {
 217                     ev_motion = (xcb_motion_notify_event_t *) ev;
 218
 219                     geometry.x = ocx + (ev_motion->event_x - query_pointer_r->root_x);
 220                     geometry.y = ocy + (ev_motion->event_y - query_pointer_r->root_y);
 221
 222                     geometry = mouse_snapclient(c, geometry);
 223
 224                     if(sw)
 225                         mouse_resizebar_draw(ctx, style, sw, c->geometry, c->border);
 226
 227                     xcb_aux_sync(globalconf.connection);
 228                     p_delete(&ev);
 229                 }
 230                 else
 231                 {
 232                     mquery_pointer_r = xcb_query_pointer_reply(globalconf.connection,
 233                                                                xcb_query_pointer_unchecked(globalconf.connection,
 234                                                                                            s->root),
 235                                                                NULL);
 236                     if((newscreen = screen_get_bycoord(globalconf.screens_info, c->screen,
 237                                                        mquery_pointer_r->root_x,
 238                                                        mquery_pointer_r->root_y)) != c->screen)
 239                     {
 240                         move_client_to_screen(c, newscreen, true);
 241                         globalconf.screens[c->screen].need_arrange = true;
 242                         globalconf.screens[newscreen].need_arrange = true;
 243                         layout_refresh();
 244                     }
 245                     if((target = client_get_bywin(globalconf.clients, mquery_pointer_r->child))
 246                        && target != c && !target->isfloating)
 247                     {
 248                         client_list_swap(&globalconf.clients, c, target);
 249                         globalconf.screens[c->screen].need_arrange = true;
 250                         layout_refresh();
 251                     }
 252
 253                     p_delete(&mquery_pointer_r);
 254                 }
 255                 break;
 256             case XCB_CONFIGURE_REQUEST:
 257             case XCB_EXPOSE:
 258             case XCB_MAP_REQUEST:
 259             case XCB_ENTER_NOTIFY:
 260             /* Handle errors */
 261             case 0:
 262                 xcb_handle_event(globalconf.evenths, ev);
 263                 break;
 264             }
 265
 266             p_delete(&ev);
 267         }
 268     }
 269
 270     p_delete(&query_pointer_r);
 271 }
 272
 273 /** Resize the focused window with the mouse.
 274  * \param screen Screen ID
 275  * \param arg Unused
 276  * \ingroup ui_callback
 277  */
 278 void
 279 uicb_client_resizemouse(int screen, char *arg __attribute__ ((unused)))
 280 {
 281     int ocx = 0, ocy = 0, n;
 282     xcb_generic_event_t *ev = NULL;
 283     xcb_motion_notify_event_t *ev_motion = NULL;
 284     Client *c = globalconf.focus->client;
 285     Tag **curtags = tags_get_current(screen);
 286     Layout *layout = curtags[0]->layout;
 287     area_t area = { 0, 0, 0, 0, NULL, NULL }, geometry = { 0, 0, 0, 0, NULL, NULL };
 288     double mwfact;
 289     SimpleWindow *sw = NULL;
 290     DrawCtx *ctx = NULL;
 291     style_t style;
 292     xcb_grab_pointer_cookie_t grab_pointer_c;
 293     xcb_grab_pointer_reply_t *grab_pointer_r = NULL;
 294     xcb_screen_t *s = xcb_aux_get_screen(globalconf.connection, c->phys_screen);
 295
 296     /* only handle floating and tiled layouts */
 297     if(!c || c->isfixed)
 298         return;
 299
 300     style = globalconf.screens[c->screen].styles.focus;
 301
 302     if(layout->arrange == layout_floating || c->isfloating)
 303     {
 304         ocx = c->geometry.x;
 305         ocy = c->geometry.y;
 306         c->ismax = false;
 307
 308         sw = simplewindow_new(globalconf.connection, c->phys_screen, 0, 0,
 309                               draw_textwidth(globalconf.connection,
 310                                              globalconf.default_screen,
 311                                              globalconf.screens[c->screen].styles.focus.font,
 312                                              "0000x0000+0000+0000") + style.font->height,
 313                               1.5 * style.font->height, 0);
 314
 315         ctx = draw_context_new(globalconf.connection, sw->phys_screen,
 316                                sw->geometry.width, sw->geometry.height,
 317                                sw->drawable);
 318         xutil_map_raised(globalconf.connection, sw->window);
 319         mouse_resizebar_draw(ctx, style, sw, geometry, c->border);
 320     }
 321     else if (layout->arrange == layout_tile || layout->arrange == layout_tileleft
 322              || layout->arrange == layout_tilebottom || layout->arrange == layout_tiletop)
 323     {
 324         for(n = 0, c = globalconf.clients; c; c = c->next)
 325             if(IS_TILED(c, screen))
 326                 n++;
 327
 328         if(n <= curtags[0]->nmaster) return;
 329
 330         for(c = globalconf.clients; c && !IS_TILED(c, screen); c = c->next);
 331         if(!c) return;
 332
 333         area = screen_get_area(screen,
 334                                globalconf.screens[c->screen].statusbar,
 335                                &globalconf.screens[c->screen].padding);
 336     }
 337     else
 338         return;
 339
 340     grab_pointer_c = xcb_grab_pointer(globalconf.connection, false, s->root,
 341                                       MOUSEMASK, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC,
 342                                       s->root, globalconf.cursor[CurResize], XCB_CURRENT_TIME);
 343
 344     if(layout->arrange == layout_floating || c->isfloating)
 345     {
 346         ocx = c->geometry.x;
 347         ocy = c->geometry.y;
 348         c->ismax = false;
 349     }
 350     else if (layout->arrange == layout_tile || layout->arrange == layout_tileleft
 351              || layout->arrange == layout_tilebottom || layout->arrange == layout_tiletop)
 352     {
 353         for(n = 0, c = globalconf.clients; c; c = c->next)
 354             if(IS_TILED(c, screen))
 355                 n++;
 356
 357         if(n <= curtags[0]->nmaster) return;
 358
 359         for(c = globalconf.clients; c && !IS_TILED(c, screen); c = c->next);
 360         if(!c) return;
 361
 362         area = screen_get_area(screen,
 363                                globalconf.screens[c->screen].statusbar,
 364                                &globalconf.screens[c->screen].padding);
 365     }
 366
 367     if((grab_pointer_r = xcb_grab_pointer_reply(globalconf.connection,
 368                                                 grab_pointer_c, NULL)) == NULL)
 369         return;
 370
 371     p_delete(&grab_pointer_r);
 372
 373     if(curtags[0]->layout->arrange == layout_tileleft)
 374         xcb_warp_pointer(globalconf.connection, XCB_NONE, c->win, 0, 0,
 375                          0, 0, 0, c->geometry.height + c->border - 1);
 376     else if(curtags[0]->layout->arrange == layout_tilebottom)
 377         xcb_warp_pointer(globalconf.connection, XCB_NONE, c->win,
 378                          0, 0, 0, 0, c->geometry.width + c->border - 1,
 379                          c->geometry.height + c->border - 1);
 380     else if(curtags[0]->layout->arrange == layout_tiletop)
 381         xcb_warp_pointer(globalconf.connection, XCB_NONE, c->win, 0, 0,
 382                          0, 0, c->geometry.width + c->border - 1, 0);
 383     else
 384         xcb_warp_pointer(globalconf.connection, XCB_NONE, c->win, 0, 0,
 385                          0, 0, c->geometry.width + c->border - 1,
 386                          c->geometry.height + c->border - 1);
 387
 388     xcb_aux_sync(globalconf.connection);
 389
 390     for(;;)
 391     {
 392         /* TODO: need a review
 393          *
 394          * XMaskEvent  allows to retrieve  only specified  events from
 395          * the queue and requeue the other events...
 396          */
 397         while((ev = xcb_poll_for_event(globalconf.connection)))
 398         {
 399             switch((ev->response_type & 0x7f))
 400             {
 401             case XCB_BUTTON_RELEASE:
 402                 if(sw)
 403                 {
 404                     draw_context_delete(&ctx);
 405                     simplewindow_delete(&sw);
 406                 }
 407                 xcb_ungrab_pointer(globalconf.connection, XCB_CURRENT_TIME);
 408                 p_delete(&ev);
 409                 return;
 410             case XCB_MOTION_NOTIFY:
 411                 ev_motion = (xcb_motion_notify_event_t *) ev;
 412
 413                 if(layout->arrange == layout_floating || c->isfloating)
 414                 {
 415                     if((geometry.width = ev_motion->event_x - ocx - 2 * c->border + 1) <= 0)
 416                         geometry.width = 1;
 417                     if((geometry.height = ev_motion->event_y - ocy - 2 * c->border + 1) <= 0)
 418                         geometry.height = 1;
 419                     geometry.x = c->geometry.x;
 420                     geometry.y = c->geometry.y;
 421                     client_resize(c, geometry, true);
 422                     if(sw)
 423                         mouse_resizebar_draw(ctx, style, sw, c->geometry, c->border);
 424                     xcb_aux_sync(globalconf.connection);
 425                 }
 426                 else if(layout->arrange == layout_tile || layout->arrange == layout_tileleft
 427                         || layout->arrange == layout_tiletop || layout->arrange == layout_tilebottom)
 428                 {
 429                     if(layout->arrange == layout_tile)
 430                         mwfact = (double) (ev_motion->event_x - area.x) / area.width;
 431                     else if(curtags[0]->layout->arrange == layout_tileleft)
 432                         mwfact = 1 - (double) (ev_motion->event_x - area.x) / area.width;
 433                     else if(curtags[0]->layout->arrange == layout_tilebottom)
 434                         mwfact = (double) (ev_motion->event_y - area.y) / area.height;
 435                     else
 436                         mwfact = 1 - (double) (ev_motion->event_y - area.y) / area.height;
 437                     mwfact = MAX(globalconf.screens[screen].mwfact_lower_limit,
 438                                  MIN(globalconf.screens[screen].mwfact_upper_limit, mwfact));
 439                     if(fabs(curtags[0]->mwfact - mwfact) >= 0.01)
 440                     {
 441                         curtags[0]->mwfact = mwfact;
 442                         globalconf.screens[screen].need_arrange = true;
 443                         layout_refresh();
 444                     }
 445                 }
 446
 447                 break;
 448             case XCB_CONFIGURE_REQUEST:
 449             case XCB_EXPOSE:
 450             case XCB_MAP_REQUEST:
 451             /* Handle errors */
 452             case 0:
 453                 xcb_handle_event(globalconf.evenths, ev);
 454                 break;
 455             }
 456
 457             p_delete(&ev);
 458         }
 459     }
 460     p_delete(&curtags);
 461 }
 462
 463 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80