client.c

   1 /*
   2  * client.c - client management
   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 <stdio.h>
  23 #include <X11/Xatom.h>
  24 #include <X11/extensions/shape.h>
  25 #include <X11/extensions/Xinerama.h>
  26
  27 #include "client.h"
  28 #include "awesome.h"
  29 #include "tag.h"
  30 #include "rules.h"
  31 #include "util.h"
  32 #include "xutil.h"
  33 #include "statusbar.h"
  34 #include "window.h"
  35 #include "focus.h"
  36 #include "ewmh.h"
  37 #include "screen.h"
  38 #include "layouts/floating.h"
  39
  40
  41 extern AwesomeConf globalconf;
  42
  43 /** Load windows properties, restoring client's tag
  44  * and floating state before awesome was restarted if any
  45  * \todo this may bug if number of tags is != than before
  46  * \param c Client ref
  47  * \param screen Screen ID
  48  */
  49 static Bool
  50 client_loadprops(Client * c, int screen)
  51 {
  52     int i, ntags = 0;
  53     Tag *tag;
  54     char *prop;
  55     Bool result = False;
  56
  57     for(tag = globalconf.screens[screen].tags; tag; tag = tag->next)
  58         ntags++;
  59
  60     prop = p_new(char, ntags + 2);
  61
  62     if(xgettextprop(globalconf.display, c->win, AWESOMEPROPS_ATOM(globalconf.display), prop, ntags + 2))
  63     {
  64         for(i = 0, tag = globalconf.screens[screen].tags; tag && i < ntags && prop[i]; i++, tag = tag->next)
  65             if(prop[i] == '1')
  66             {
  67                 tag_client(c, tag);
  68                 result = True;
  69             }
  70             else
  71                 untag_client(c, tag);
  72
  73         if(i <= ntags && prop[i])
  74             c->isfloating = prop[i] == '1';
  75     }
  76
  77     p_delete(&prop);
  78
  79     return result;
  80 }
  81
  82 /** Check if client supports protocol WM_DELETE_WINDOW
  83  * \param disp the display
  84  * \param win the Window
  85  * \return True if client has WM_DELETE_WINDOW
  86  */
  87 static Bool
  88 isprotodel(Display *disp, Window win)
  89 {
  90     int i, n;
  91     Atom *protocols;
  92     Bool ret = False;
  93
  94     if(XGetWMProtocols(disp, win, &protocols, &n))
  95     {
  96         for(i = 0; !ret && i < n; i++)
  97             if(protocols[i] == XInternAtom(disp, "WM_DELETE_WINDOW", False))
  98                 ret = True;
  99         XFree(protocols);
 100     }
 101     return ret;
 102 }
 103
 104 /** Swap two client in the linked list clients
 105  * \param head pointer ito the client list head
 106  * \param c1 first client
 107  * \param c2 second client
 108  */
 109 static void
 110 client_swap(Client **head, Client *c1, Client *c2)
 111 {
 112     Client *tmp;
 113
 114     tmp = c1->next;
 115     c1->next = c2->next;
 116     c2->next = (tmp == c2 ? c1 : tmp);
 117
 118     tmp = c2->prev;
 119     c2->prev = c1->prev;
 120     c1->prev = (tmp == c1 ? c2 : tmp );
 121
 122     if(c1->next)
 123         c1->next->prev = c1;
 124
 125     if(c1->prev)
 126         c1->prev->next = c1;
 127
 128     if(c2->next)
 129         c2->next->prev = c2;
 130
 131     if(c2->prev)
 132         c2->prev->next = c2;
 133
 134     if(*head == c1)
 135         *head = c2;
 136 }
 137
 138 /** Get a Client by its window
 139  * \param list Client list to look info
 140  * \param w Client window to find
 141  * \return client
 142  */
 143 Client *
 144 get_client_bywin(Client *list, Window w)
 145 {
 146     Client *c;
 147
 148     for(c = list; c && c->win != w; c = c->next);
 149     return c;
 150 }
 151
 152
 153 /** Get a client by its name
 154  * \param list Client list
 155  * \param name name to search
 156  * \return first matching client
 157  */
 158 Client *
 159 get_client_byname(Client *list, char *name)
 160 {
 161     Client *c;
 162
 163     for(c = list; c; c = c->next)
 164         if(strstr(c->name, name))
 165             return c;
 166
 167     return NULL;
 168 }
 169
 170 /** Update client name attribute with its title
 171  * \param c the client
 172  */
 173 void
 174 client_updatetitle(Client *c)
 175 {
 176     if(!xgettextprop(globalconf.display, c->win, XInternAtom(globalconf.display, "_NET_WM_NAME", False), c->name, sizeof(c->name)))
 177         xgettextprop(globalconf.display, c->win, XInternAtom(globalconf.display, "WM_NAME", False), c->name, sizeof(c->name));
 178 }
 179
 180 /** Ban client and unmap it
 181  * \param c the client
 182  */
 183 void
 184 client_ban(Client * c)
 185 {
 186     XUnmapWindow(globalconf.display, c->win);
 187     window_setstate(c->win, IconicState);
 188 }
 189
 190
 191 static void
 192 client_attach_at_end(Client *c)
 193 {
 194     Client *iter;
 195     for(iter = globalconf.clients; iter && iter->next; iter = iter->next);
 196     /* stack is empty */
 197     if(!iter)
 198         globalconf.clients = c;
 199     else
 200     {
 201         c->prev = iter;
 202         iter->next = c;
 203     }
 204 }
 205
 206 /** Attach client to the beginning of the clients stack
 207  * \param c the client
 208  */
 209 void
 210 client_attach(Client *c)
 211 {
 212     if(globalconf.clients)
 213         (globalconf.clients)->prev = c;
 214     c->next = globalconf.clients;
 215     globalconf.clients = c;
 216 }
 217
 218 /** Detach client from clients list
 219  * \param c client to detach
 220  */
 221 void
 222 client_detach(Client *c)
 223 {
 224     if(c->prev)
 225         c->prev->next = c->next;
 226     if(c->next)
 227         c->next->prev = c->prev;
 228     if(c == globalconf.clients)
 229         globalconf.clients = c->next;
 230     c->next = c->prev = NULL;
 231 }
 232
 233 /** Give focus to client, or to first client if c is NULL
 234  * \param c client
 235  * \param selscreen True if current screen is selected
 236  * \param screen Screen ID
 237  */
 238 void
 239 focus(Client *c, Bool selscreen, int screen)
 240 {
 241     int phys_screen = get_phys_screen(screen);
 242
 243     /* unfocus current selected client */
 244     if(globalconf.focus->client)
 245     {
 246         window_grabbuttons(get_phys_screen(globalconf.focus->client->screen),
 247                            globalconf.focus->client->win, False, True);
 248         XSetWindowBorder(globalconf.display, globalconf.focus->client->win,
 249                          globalconf.screens[screen].colors_normal[ColBorder].pixel);
 250         window_settrans(globalconf.focus->client->win,
 251                         globalconf.screens[screen].opacity_unfocused);
 252     }
 253
 254
 255     /* if c is NULL or invisible, take next client in the focus history */
 256     if((!c && selscreen) || (c && !client_isvisible(c, screen)))
 257     {
 258         c = focus_get_current_client(screen);
 259         /* if c is still NULL take next client in the stack */
 260         if(!c)
 261             for(c = globalconf.clients; c && (c->skip || !client_isvisible(c, screen)); c = c->next);
 262     }
 263
 264     if(c)
 265     {
 266         XSetWindowBorder(globalconf.display, c->win, globalconf.screens[screen].colors_selected[ColBorder].pixel);
 267         window_grabbuttons(phys_screen, c->win, True, True);
 268     }
 269
 270     if(!selscreen)
 271         return;
 272
 273     /* save sel in focus history */
 274     focus_add_client(c);
 275
 276     statusbar_draw_all(screen);
 277
 278     if(globalconf.focus->client)
 279     {
 280         XSetInputFocus(globalconf.display,
 281                        globalconf.focus->client->win, RevertToPointerRoot, CurrentTime);
 282         for(c = globalconf.clients; c; c = c->next)
 283             if(c != globalconf.focus->client)
 284                 window_settrans(globalconf.focus->client->win,
 285                                 globalconf.screens[screen].opacity_unfocused);
 286         window_settrans(globalconf.focus->client->win, -1);
 287     }
 288     else
 289         XSetInputFocus(globalconf.display,
 290                        RootWindow(globalconf.display, phys_screen),
 291                        RevertToPointerRoot, CurrentTime);
 292
 293     ewmh_update_net_active_window(phys_screen);
 294 }
 295
 296 /** Manage a new client
 297  * \param w The window
 298  * \param wa Window attributes
 299  * \param screen Screen ID
 300  */
 301 void
 302 client_manage(Window w, XWindowAttributes *wa, int screen)
 303 {
 304     Client *c, *t = NULL;
 305     Window trans;
 306     Status rettrans;
 307     XWindowChanges wc;
 308     Area area, darea;
 309     Tag *tag;
 310     Rule *rule;
 311     int phys_screen = get_phys_screen(screen);
 312
 313     area = get_screen_area(screen, NULL, NULL);
 314
 315     c = p_new(Client, 1);
 316
 317     c->win = w;
 318     c->x = c->rx = wa->x;
 319     c->y = c->ry = wa->y;
 320     c->w = c->rw = wa->width;
 321     c->h = c->rh = wa->height;
 322     c->oldborder = wa->border_width;
 323
 324     c->screen = get_screen_bycoord(c->x, c->y);
 325
 326     move_client_to_screen(c, screen, True);
 327
 328     /* update window title */
 329     client_updatetitle(c);
 330
 331     if(c->w == area.width && c->h == area.height)
 332         c->border = wa->border_width;
 333     else
 334         c->border = globalconf.screens[screen].borderpx;
 335
 336     ewmh_check_client_hints(c);
 337     /* loadprops or apply rules if no props */
 338     if(!client_loadprops(c, screen))
 339         tag_client_with_rules(c);
 340
 341
 342     /* if window request fullscreen mode */
 343     if(c->w == area.width && c->h == area.height)
 344     {
 345         c->x = area.x;
 346         c->y = area.y;
 347     }
 348     else
 349     {
 350         darea = get_display_area(phys_screen,
 351                                  globalconf.screens[screen].statusbar,
 352                                  &globalconf.screens[screen].padding);
 353
 354         if(c->x + c->w + 2 * c->border > darea.x + darea.width)
 355             c->x = c->rx = darea.x + darea.width - c->w - 2 * c->border;
 356         if(c->y + c->h + 2 * c->border > darea.y + darea.height)
 357             c->y = c->ry = darea.y + darea.height - c->h - 2 * c->border;
 358         if(c->x < darea.x)
 359             c->x = c->rx = darea.x;
 360         if(c->y < darea.y)
 361             c->y = c->ry = darea.y;
 362     }
 363
 364     /* set borders */
 365     wc.border_width = c->border;
 366     XConfigureWindow(globalconf.display, w, CWBorderWidth, &wc);
 367     XSetWindowBorder(globalconf.display, w, globalconf.screens[screen].colors_normal[ColBorder].pixel);
 368
 369     /* propagates border_width, if size doesn't change */
 370     window_configure(c->win, c->x, c->y, c->w, c->h, c->border);
 371
 372     /* update hints */
 373     client_updatesizehints(c);
 374     client_updatewmhints(c);
 375
 376     XSelectInput(globalconf.display, w, StructureNotifyMask | PropertyChangeMask | EnterWindowMask);
 377
 378     /* handle xshape */
 379     if(globalconf.have_shape)
 380     {
 381         XShapeSelectInput(globalconf.display, w, ShapeNotifyMask);
 382         window_setshape(phys_screen, c->win);
 383     }
 384
 385     /* grab buttons */
 386     window_grabbuttons(phys_screen, c->win, False, True);
 387
 388     /* check for transient and set tags like its parent */
 389     if((rettrans = XGetTransientForHint(globalconf.display, w, &trans) == Success)
 390        && (t = get_client_bywin(globalconf.clients, trans)))
 391         for(tag = globalconf.screens[c->screen].tags; tag; tag = tag->next)
 392             if(is_client_tagged(t, tag))
 393                 tag_client(c, tag);
 394
 395     /* should be floating if transsient or fixed */
 396     if(!c->isfloating)
 397         c->isfloating = (rettrans == Success) || c->isfixed;
 398
 399     /* save new props */
 400     client_saveprops(c);
 401
 402     /* attach to the stack */
 403     for(rule = globalconf.rules; rule; rule = rule->next)
 404         if(rule->not_master && client_match_rule(c, rule))
 405         {
 406             client_attach_at_end(c);
 407             break;
 408         }
 409     if(!rule)
 410     {
 411         if(globalconf.screens[c->screen].new_become_master)
 412             client_attach(c);
 413         else
 414             client_attach_at_end(c);
 415     }
 416
 417     /* some windows require this */
 418     XMoveResizeWindow(globalconf.display, c->win, c->x, c->y, c->w, c->h);
 419
 420     focus(c, True, screen);
 421
 422     ewmh_update_net_client_list(phys_screen);
 423
 424     /* rearrange to display new window */
 425     arrange(screen);
 426 }
 427
 428 /** Resize client window
 429  * \param c client to resize
 430  * \param x x coord
 431  * \param y y coord
 432  * \param w width
 433  * \param h height
 434  * \param sizehints respect size hints
 435  * \param volatile_coords register coords in rx/ry/rw/rh
 436  */
 437 void
 438 client_resize(Client *c, int x, int y, int w, int h,
 439               Bool sizehints, Bool volatile_coords)
 440 {
 441     double dx, dy, max, min, ratio;
 442     XWindowChanges wc;
 443     Area area;
 444     Tag **curtags;
 445
 446     if(sizehints)
 447     {
 448         if(c->minay > 0 && c->maxay > 0 && (h - c->baseh) > 0 && (w - c->basew) > 0)
 449         {
 450             dx = (double) (w - c->basew);
 451             dy = (double) (h - c->baseh);
 452             min = (double) (c->minax) / (double) (c->minay);
 453             max = (double) (c->maxax) / (double) (c->maxay);
 454             ratio = dx / dy;
 455             if(max > 0 && min > 0 && ratio > 0)
 456             {
 457                 if(ratio < min)
 458                 {
 459                     dy = (dx * min + dy) / (min * min + 1);
 460                     dx = dy * min;
 461                     w = (int) dx + c->basew;
 462                     h = (int) dy + c->baseh;
 463                 }
 464                 else if(ratio > max)
 465                 {
 466                     dy = (dx * min + dy) / (max * max + 1);
 467                     dx = dy * min;
 468                     w = (int) dx + c->basew;
 469                     h = (int) dy + c->baseh;
 470                 }
 471             }
 472         }
 473         if(c->minw && w < c->minw)
 474             w = c->minw;
 475         if(c->minh && h < c->minh)
 476             h = c->minh;
 477         if(c->maxw && w > c->maxw)
 478             w = c->maxw;
 479         if(c->maxh && h > c->maxh)
 480             h = c->maxh;
 481         if(c->incw)
 482             w -= (w - c->basew) % c->incw;
 483         if(c->inch)
 484             h -= (h - c->baseh) % c->inch;
 485     }
 486     if(w <= 0 || h <= 0)
 487         return;
 488     /* offscreen appearance fixes */
 489     area = get_display_area(get_phys_screen(c->screen),
 490                             NULL,
 491                             &globalconf.screens[c->screen].padding);
 492     if(x > area.width)
 493         x = area.width - w - 2 * c->border;
 494     if(y > area.height)
 495         y = area.height - h - 2 * c->border;
 496     if(x + w + 2 * c->border < 0)
 497         x = 0;
 498     if(y + h + 2 * c->border < 0)
 499         y = 0;
 500     if(c->x != x || c->y != y || c->w != w || c->h != h)
 501     {
 502         c->x = wc.x = x;
 503         c->y = wc.y = y;
 504         c->w = wc.width = w;
 505         c->h = wc.height = h;
 506         curtags = get_current_tags(c->screen);
 507         if(!volatile_coords
 508            && (c->isfloating
 509                || curtags[0]->layout->arrange == layout_floating))
 510         {
 511             c->rx = c->x;
 512             c->ry = c->y;
 513             c->rw = c->w;
 514             c->rh = c->h;
 515         }
 516         p_delete(&curtags);
 517         wc.border_width = c->border;
 518         XConfigureWindow(globalconf.display, c->win, CWX | CWY | CWWidth | CWHeight | CWBorderWidth, &wc);
 519         window_configure(c->win, c->x, c->y, c->w, c->h, c->border);
 520         XSync(globalconf.display, False);
 521         if((c->x >= 0 || c->y >= 0) && XineramaIsActive(globalconf.display))
 522         {
 523             int new_screen = get_screen_bycoord(c->x, c->y);
 524             if(c->screen != new_screen)
 525                 move_client_to_screen(c, new_screen, False);
 526         }
 527     }
 528 }
 529
 530 /** Save client properties as an X property
 531  * \param c client
 532  */
 533 void
 534 client_saveprops(Client *c)
 535 {
 536     int i = 0, ntags = 0;
 537     char *prop;
 538     Tag *tag;
 539
 540     for(tag = globalconf.screens[c->screen].tags; tag; tag = tag->next)
 541         ntags++;
 542
 543     prop = p_new(char, ntags + 2);
 544
 545     for(tag = globalconf.screens[c->screen].tags; tag; tag = tag->next, i++)
 546         prop[i] = is_client_tagged(c, tag) ? '1' : '0';
 547
 548     if(i <= ntags)
 549         prop[i] = c->isfloating ? '1' : '0';
 550
 551     prop[++i] = '\0';
 552
 553     XChangeProperty(globalconf.display, c->win, AWESOMEPROPS_ATOM(globalconf.display), XA_STRING, 8,
 554                     PropModeReplace, (unsigned char *) prop, i);
 555
 556     p_delete(&prop);
 557 }
 558
 559 void
 560 client_unban(Client *c)
 561 {
 562     XMapWindow(globalconf.display, c->win);
 563     window_setstate(c->win, NormalState);
 564 }
 565
 566 void
 567 client_unmanage(Client *c, long state)
 568 {
 569     XWindowChanges wc;
 570     Tag *tag;
 571
 572     wc.border_width = c->oldborder;
 573     /* The server grab construct avoids race conditions. */
 574     XGrabServer(globalconf.display);
 575     XConfigureWindow(globalconf.display, c->win, CWBorderWidth, &wc);  /* restore border */
 576     client_detach(c);
 577     if(globalconf.focus->client == c)
 578         focus(NULL, True, c->screen);
 579     focus_delete_client(c);
 580     for(tag = globalconf.screens[c->screen].tags; tag; tag = tag->next)
 581         untag_client(c, tag);
 582     XUngrabButton(globalconf.display, AnyButton, AnyModifier, c->win);
 583     window_setstate(c->win, state);
 584     XSync(globalconf.display, False);
 585     XSetErrorHandler(xerror);
 586     XUngrabServer(globalconf.display);
 587     if(state != NormalState)
 588         arrange(c->screen);
 589     p_delete(&c);
 590 }
 591
 592 void
 593 client_updatewmhints(Client *c)
 594 {
 595     XWMHints *wmh;
 596
 597     if((wmh = XGetWMHints(globalconf.display, c->win)))
 598     {
 599         c->isurgent = (wmh->flags & XUrgencyHint);
 600         if((wmh->flags & StateHint) && wmh->initial_state == WithdrawnState)
 601             c->skip = True;
 602         XFree(wmh);
 603     }
 604 }
 605
 606 void
 607 client_updatesizehints(Client *c)
 608 {
 609     long msize;
 610     XSizeHints size;
 611
 612     if(!XGetWMNormalHints(globalconf.display, c->win, &size, &msize) || !size.flags)
 613         size.flags = PSize;
 614     c->flags = size.flags;
 615     if(c->flags & PBaseSize)
 616     {
 617         c->basew = size.base_width;
 618         c->baseh = size.base_height;
 619     }
 620     else if(c->flags & PMinSize)
 621     {
 622         c->basew = size.min_width;
 623         c->baseh = size.min_height;
 624     }
 625     else
 626         c->basew = c->baseh = 0;
 627     if(c->flags & PResizeInc)
 628     {
 629         c->incw = size.width_inc;
 630         c->inch = size.height_inc;
 631     }
 632     else
 633         c->incw = c->inch = 0;
 634
 635     if(c->flags & PMaxSize)
 636     {
 637         c->maxw = size.max_width;
 638         c->maxh = size.max_height;
 639     }
 640     else
 641         c->maxw = c->maxh = 0;
 642
 643     if(c->flags & PMinSize)
 644     {
 645         c->minw = size.min_width;
 646         c->minh = size.min_height;
 647     }
 648     else if(c->flags & PBaseSize)
 649     {
 650         c->minw = size.base_width;
 651         c->minh = size.base_height;
 652     }
 653     else
 654         c->minw = c->minh = 0;
 655
 656     if(c->flags & PAspect)
 657     {
 658         c->minax = size.min_aspect.x;
 659         c->maxax = size.max_aspect.x;
 660         c->minay = size.min_aspect.y;
 661         c->maxay = size.max_aspect.y;
 662     }
 663     else
 664         c->minax = c->maxax = c->minay = c->maxay = 0;
 665
 666     if(c->maxw && c->minw && c->maxh && c->minh
 667        && c->maxw == c->minw && c->maxh == c->minh)
 668         c->isfixed = True;
 669 }
 670
 671 /** Returns True if a client is tagged
 672  * with one of the tags
 673  * \return True or False
 674  */
 675 Bool
 676 client_isvisible(Client *c, int screen)
 677 {
 678     Tag *tag;
 679
 680     if(c->screen != screen)
 681         return False;
 682
 683     for(tag = globalconf.screens[screen].tags; tag; tag = tag->next)
 684         if(tag->selected && is_client_tagged(c, tag))
 685             return True;
 686     return False;
 687 }
 688
 689 /** Set selected client transparency
 690  * \param screen Screen ID
 691  * \param arg unused arg
 692  * \ingroup ui_callback
 693  */
 694 void
 695 uicb_client_settrans(int screen __attribute__ ((unused)), char *arg)
 696 {
 697     double delta = 100.0, current_opacity = 100.0;
 698     unsigned char *data;
 699     Atom actual;
 700     int format;
 701     unsigned long n, left;
 702     unsigned int current_opacity_raw = 0;
 703     int set_prop = 0;
 704     Client *sel = globalconf.focus->client;
 705
 706     if(!sel)
 707         return;
 708
 709     XGetWindowProperty(globalconf.display, sel->win,
 710                        XInternAtom(globalconf.display, "_NET_WM_WINDOW_OPACITY", False),
 711                        0L, 1L, False, XA_CARDINAL, &actual, &format, &n, &left,
 712                        (unsigned char **) &data);
 713     if(data)
 714     {
 715         memcpy(&current_opacity_raw, data, sizeof(unsigned int));
 716         XFree(data);
 717         current_opacity = (current_opacity_raw * 100.0) / 0xffffffff;
 718     }
 719     else
 720         set_prop = 1;
 721
 722     delta = compute_new_value_from_arg(arg, current_opacity);
 723
 724     if(delta <= 0.0)
 725         delta = 0.0;
 726     else if(delta > 100.0)
 727     {
 728         delta = 100.0;
 729         set_prop = 1;
 730     }
 731
 732     if(delta == 100.0 && !set_prop)
 733         window_settrans(sel->win, -1);
 734     else
 735         window_settrans(sel->win, delta);
 736 }
 737
 738 /** Swap current with next client
 739  * \param screen Screen ID
 740  * \param arg nothing
 741  * \ingroup ui_callback
 742  */
 743 void
 744 uicb_client_swapnext(int screen, char *arg __attribute__ ((unused)))
 745 {
 746     Client *next, *sel = globalconf.focus->client;
 747
 748     if(!sel)
 749         return;
 750
 751     for(next = sel->next; next && !client_isvisible(next, screen); next = next->next);
 752     if(next)
 753     {
 754         client_swap(&globalconf.clients, sel, next);
 755         arrange(screen);
 756         /* restore focus */
 757         focus(sel, True, screen);
 758     }
 759 }
 760
 761 /** Swap current with previous client
 762  * \param screen Screen ID
 763  * \param arg nothing
 764  * \ingroup ui_callback
 765  */
 766 void
 767 uicb_client_swapprev(int screen, char *arg __attribute__ ((unused)))
 768 {
 769     Client *prev, *sel = globalconf.focus->client;
 770
 771     if(!sel)
 772         return;
 773
 774     for(prev = sel->prev; prev && !client_isvisible(prev, screen); prev = prev->prev);
 775     if(prev)
 776     {
 777         client_swap(&globalconf.clients, prev, sel);
 778         arrange(screen);
 779         /* restore focus */
 780         focus(sel, True, screen);
 781     }
 782 }
 783
 784 /** Move and resize client
 785  * \param screen Screen ID
 786  * \param arg x y w h
 787  * \ingroup ui_callback
 788  */
 789 void
 790 uicb_client_moveresize(int screen, char *arg)
 791 {
 792     int nx, ny, nw, nh, ox, oy, ow, oh;
 793     char x[8], y[8], w[8], h[8];
 794     int mx, my, dx, dy, nmx, nmy;
 795     unsigned int dui;
 796     Window dummy;
 797     Client *sel = globalconf.focus->client;
 798     Tag **curtags = get_current_tags(screen);
 799
 800     if(curtags[0]->layout->arrange != layout_floating)
 801         if(!sel || !sel->isfloating || sel->isfixed || !arg)
 802         {
 803             p_delete(&curtags);
 804             return;
 805         }
 806     p_delete(&curtags);
 807     if(sscanf(arg, "%s %s %s %s", x, y, w, h) != 4)
 808         return;
 809     nx = (int) compute_new_value_from_arg(x, sel->x);
 810     ny = (int) compute_new_value_from_arg(y, sel->y);
 811     nw = (int) compute_new_value_from_arg(w, sel->w);
 812     nh = (int) compute_new_value_from_arg(h, sel->h);
 813
 814     ox = sel->x;
 815     oy = sel->y;
 816     ow = sel->w;
 817     oh = sel->h;
 818
 819     Bool xqp = XQueryPointer(globalconf.display,
 820                              RootWindow(globalconf.display,
 821                                         get_phys_screen(screen)),
 822                              &dummy, &dummy, &mx, &my, &dx, &dy, &dui);
 823     client_resize(sel, nx, ny, nw, nh, True, False);
 824     if (xqp && ox <= mx && (ox + ow) >= mx && oy <= my && (oy + oh) >= my)
 825     {
 826         nmx = mx - ox + sel->w - ow - 1 < 0 ? 0 : mx - ox + sel->w - ow - 1;
 827         nmy = my - oy + sel->h - oh - 1 < 0 ? 0 : my - oy + sel->h - oh - 1;
 828         XWarpPointer(globalconf.display,
 829                      None, sel->win,
 830                      0, 0, 0, 0, nmx, nmy);
 831     }
 832 }
 833
 834
 835 void
 836 client_kill(Client *c)
 837 {
 838     XEvent ev;
 839
 840     if(isprotodel(globalconf.display, c->win))
 841     {
 842         ev.type = ClientMessage;
 843         ev.xclient.window = c->win;
 844         ev.xclient.message_type = XInternAtom(globalconf.display, "WM_PROTOCOLS", False);
 845         ev.xclient.format = 32;
 846         ev.xclient.data.l[0] = XInternAtom(globalconf.display, "WM_DELETE_WINDOW", False);
 847         ev.xclient.data.l[1] = CurrentTime;
 848         XSendEvent(globalconf.display, c->win, False, NoEventMask, &ev);
 849     }
 850     else
 851         XKillClient(globalconf.display, c->win);
 852 }
 853
 854 /** Kill selected client
 855  * \param screen Screen ID
 856  * \param arg unused
 857  * \ingroup ui_callback
 858  */
 859 void
 860 uicb_client_kill(int screen __attribute__ ((unused)), char *arg __attribute__ ((unused)))
 861 {
 862     Client *sel = globalconf.focus->client;
 863
 864     if(sel)
 865         client_kill(sel);
 866 }
 867
 868 void
 869 client_maximize(Client *c, int x, int y, int w, int h, Bool borders)
 870 {
 871     if((c->ismax = !c->ismax))
 872     {
 873         if(borders)
 874         {
 875             c->oldborder = c->border;
 876             c->border = 0;
 877         }
 878         c->wasfloating = c->isfloating;
 879         c->isfloating = True;
 880         client_resize(c, x, y, w, h, False, True);
 881     }
 882     else if(c->wasfloating)
 883         client_resize(c, c->rx, c->ry, c->rw, c->rh, True, False);
 884     else
 885         c->isfloating = False;
 886
 887     if(borders)
 888         c->border = c->oldborder;
 889
 890     arrange(c->screen);
 891 }
 892
 893 /** Toggle maximize for client
 894  * \param screen Screen ID
 895  * \param arg Unused
 896  * \ingroup ui_callback
 897  */
 898 void
 899 uicb_client_togglemax(int screen, char *arg __attribute__ ((unused)))
 900 {
 901     Client *sel = globalconf.focus->client;
 902     Area area = get_screen_area(screen,
 903                                 globalconf.screens[screen].statusbar,
 904                                 &globalconf.screens[screen].padding);
 905     if(sel)
 906         client_maximize(sel, area.x, area.y,
 907                         area.width - 2 * sel->border,
 908                         area.height - 2 * sel->border, False);
 909 }
 910
 911 /** Toggle vertical maximize for client
 912  * \param screen Screen ID
 913  * \param arg Unused
 914  * \ingroup ui_callback
 915  */
 916 void
 917 uicb_client_toggleverticalmax(int screen, char *arg __attribute__ ((unused)))
 918 {
 919     Client *sel = globalconf.focus->client;
 920     Area area = get_screen_area(screen,
 921                                 globalconf.screens[screen].statusbar,
 922                                 &globalconf.screens[screen].padding);
 923
 924     if(sel)
 925         client_maximize(sel, sel->x, area.y,
 926                         sel->w,
 927                         area.height - 2 * sel->border, False);
 928 }
 929
 930
 931 /** Toggle horizontal maximize for client
 932  * \param screen Screen ID
 933  * \param arg Unused
 934  * \ingroup ui_callback
 935  */
 936 void
 937 uicb_client_togglehorizontalmax(int screen, char *arg __attribute__ ((unused)))
 938 {
 939     Client *sel = globalconf.focus->client;
 940     Area area = get_screen_area(screen,
 941                                 globalconf.screens[screen].statusbar,
 942                                 &globalconf.screens[screen].padding);
 943
 944     if(sel)
 945         client_maximize(sel, area.x, sel->y,
 946                         area.height - 2 * sel->border,
 947                         sel->h, False);
 948 }
 949
 950 /** Zoom client
 951  * \param screen Screen ID
 952  * \param arg Unused
 953  * \ingroup ui_callback
 954  */
 955 void
 956 uicb_client_zoom(int screen, char *arg __attribute__ ((unused)))
 957 {
 958     Client *sel = globalconf.focus->client;
 959
 960     if(globalconf.clients == sel)
 961          for(sel = sel->next; sel && !client_isvisible(sel, screen); sel = sel->next);
 962
 963     if(!sel)
 964         return;
 965
 966     client_detach(sel);
 967     client_attach(sel);
 968
 969     focus(sel, True, screen);
 970     arrange(screen);
 971 }
 972
 973 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80