fix a bug in the tasklist loop that made clicking on tasklist focusing a wrong client
[awesome.git] / client.c
blob5d6e93e1e9651ebcc7bc183b944832dabcc11dc9
1 /*
2 * client.c - client management
4 * Copyright © 2007-2008 Julien Danjou <julien@danjou.info>
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.
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.
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.
22 #include <stdio.h>
23 #include <X11/Xatom.h>
24 #include <X11/extensions/shape.h>
25 #include <X11/extensions/Xinerama.h>
27 #include "client.h"
28 #include "tag.h"
29 #include "rules.h"
30 #include "util.h"
31 #include "xutil.h"
32 #include "window.h"
33 #include "focus.h"
34 #include "ewmh.h"
35 #include "screen.h"
36 #include "widget.h"
37 #include "layouts/floating.h"
40 extern AwesomeConf globalconf;
42 /** Load windows properties, restoring client's tag
43 * and floating state before awesome was restarted if any
44 * \todo this may bug if number of tags is != than before
45 * \param c Client ref
46 * \param screen Screen ID
48 static Bool
49 client_loadprops(Client * c, int screen)
51 int i, ntags = 0;
52 Tag *tag;
53 char *prop;
54 Bool result = False;
56 for(tag = globalconf.screens[screen].tags; tag; tag = tag->next)
57 ntags++;
59 prop = p_new(char, ntags + 2);
61 if(xgettextprop(c->win,
62 XInternAtom(globalconf.display, "_AWESOME_PROPERTIES", False),
63 prop, ntags + 2))
65 for(i = 0, tag = globalconf.screens[screen].tags; tag && i < ntags && prop[i]; i++, tag = tag->next)
66 if(prop[i] == '1')
68 tag_client(c, tag);
69 result = True;
71 else
72 untag_client(c, tag);
74 if(i <= ntags && prop[i])
75 c->isfloating = prop[i] == '1';
78 p_delete(&prop);
80 return result;
83 /** Check if client supports protocol WM_DELETE_WINDOW
84 * \param disp the display
85 * \param win the Window
86 * \return True if client has WM_DELETE_WINDOW
88 static Bool
89 isprotodel(Display *disp, Window win)
91 int i, n;
92 Atom *protocols;
93 Bool ret = False;
95 if(XGetWMProtocols(disp, win, &protocols, &n))
97 for(i = 0; !ret && i < n; i++)
98 if(protocols[i] == XInternAtom(disp, "WM_DELETE_WINDOW", False))
99 ret = True;
100 XFree(protocols);
102 return ret;
105 /** Swap two client in the linked list clients
106 * \param head pointer ito the client list head
107 * \param c1 first client
108 * \param c2 second client
110 static void
111 client_swap(Client **head, Client *c1, Client *c2)
113 Client *tmp;
115 tmp = c1->next;
116 c1->next = c2->next;
117 c2->next = (tmp == c2 ? c1 : tmp);
119 tmp = c2->prev;
120 c2->prev = c1->prev;
121 c1->prev = (tmp == c1 ? c2 : tmp );
123 if(c1->next)
124 c1->next->prev = c1;
126 if(c1->prev)
127 c1->prev->next = c1;
129 if(c2->next)
130 c2->next->prev = c2;
132 if(c2->prev)
133 c2->prev->next = c2;
135 if(*head == c1)
136 *head = c2;
139 /** Get a Client by its window
140 * \param list Client list to look info
141 * \param w Client window to find
142 * \return client
144 Client *
145 get_client_bywin(Client *list, Window w)
147 Client *c;
149 for(c = list; c && c->win != w; c = c->next);
150 return c;
154 /** Get a client by its name
155 * \param list Client list
156 * \param name name to search
157 * \return first matching client
159 Client *
160 get_client_byname(Client *list, char *name)
162 Client *c;
164 for(c = list; c; c = c->next)
165 if(strstr(c->name, name))
166 return c;
168 return NULL;
171 /** Update client name attribute with its title
172 * \param c the client
174 void
175 client_updatetitle(Client *c)
177 if(!xgettextprop(c->win, XInternAtom(globalconf.display, "_NET_WM_NAME", False), c->name, sizeof(c->name)))
178 xgettextprop(c->win, XInternAtom(globalconf.display, "WM_NAME", False), c->name, sizeof(c->name));
180 widget_invalidate_cache(c->screen, WIDGET_CACHE_CLIENTS);
183 /** Ban client and unmap it
184 * \param c the client
186 void
187 client_ban(Client * c)
189 XUnmapWindow(globalconf.display, c->win);
190 window_setstate(c->win, IconicState);
194 static void
195 client_attach_at_end(Client *c)
197 Client *iter;
198 for(iter = globalconf.clients; iter && iter->next; iter = iter->next);
199 /* stack is empty */
200 if(!iter)
201 globalconf.clients = c;
202 else
204 c->prev = iter;
205 iter->next = c;
209 /** Attach client to the beginning of the clients stack
210 * \param c the client
212 void
213 client_attach(Client *c)
215 if(globalconf.clients)
216 (globalconf.clients)->prev = c;
217 c->next = globalconf.clients;
218 globalconf.clients = c;
221 /** Detach client from clients list
222 * \param c client to detach
224 void
225 client_detach(Client *c)
227 if(c->prev)
228 c->prev->next = c->next;
229 if(c->next)
230 c->next->prev = c->prev;
231 if(c == globalconf.clients)
232 globalconf.clients = c->next;
233 c->next = c->prev = NULL;
236 /** Give focus to client, or to first client if c is NULL
237 * \param c client
238 * \param selscreen True if current screen is selected
239 * \param screen Screen ID
241 void
242 focus(Client *c, Bool selscreen, int screen)
244 int phys_screen = get_phys_screen(screen);
246 /* unfocus current selected client */
247 if(globalconf.focus->client)
249 widget_invalidate_cache(globalconf.focus->client->screen, WIDGET_CACHE_CLIENTS);
250 window_grabbuttons(get_phys_screen(globalconf.focus->client->screen),
251 globalconf.focus->client->win, False, True);
252 XSetWindowBorder(globalconf.display, globalconf.focus->client->win,
253 globalconf.screens[screen].colors_normal[ColBorder].pixel);
254 window_settrans(globalconf.focus->client->win,
255 globalconf.screens[screen].opacity_unfocused);
259 /* if c is NULL or invisible, take next client in the focus history */
260 if((!c && selscreen) || (c && !client_isvisible(c, screen)))
262 c = focus_get_current_client(screen);
263 /* if c is still NULL take next client in the stack */
264 if(!c)
265 for(c = globalconf.clients; c && (c->skip || !client_isvisible(c, screen)); c = c->next);
268 if(c)
270 XSetWindowBorder(globalconf.display, c->win, globalconf.screens[screen].colors_selected[ColBorder].pixel);
271 window_grabbuttons(phys_screen, c->win, True, True);
274 if(!selscreen)
275 return;
277 /* save sel in focus history */
278 focus_add_client(c);
280 if(globalconf.focus->client)
282 widget_invalidate_cache(screen, WIDGET_CACHE_CLIENTS);
283 XSetInputFocus(globalconf.display,
284 globalconf.focus->client->win, RevertToPointerRoot, CurrentTime);
285 for(c = globalconf.clients; c; c = c->next)
286 if(c != globalconf.focus->client)
287 window_settrans(globalconf.focus->client->win,
288 globalconf.screens[screen].opacity_unfocused);
289 window_settrans(globalconf.focus->client->win, -1);
291 else
292 XSetInputFocus(globalconf.display,
293 RootWindow(globalconf.display, phys_screen),
294 RevertToPointerRoot, CurrentTime);
296 ewmh_update_net_active_window(phys_screen);
299 /** Manage a new client
300 * \param w The window
301 * \param wa Window attributes
302 * \param screen Screen ID
304 void
305 client_manage(Window w, XWindowAttributes *wa, int screen)
307 Client *c, *t = NULL;
308 Window trans;
309 Bool rettrans;
310 XWindowChanges wc;
311 Area area, darea;
312 Tag *tag;
313 Rule *rule;
314 int phys_screen = get_phys_screen(screen);
316 area = get_screen_area(screen, NULL, NULL);
318 c = p_new(Client, 1);
320 c->win = w;
321 c->geometry.x = c->f_geometry.x = c->m_geometry.x = wa->x;
322 c->geometry.y = c->f_geometry.y = c->m_geometry.y = wa->y;
323 c->geometry.width = c->f_geometry.width = c->m_geometry.width = wa->width;
324 c->geometry.height = c->f_geometry.height = c->m_geometry.height = wa->height;
325 c->oldborder = wa->border_width;
326 c->newcomer = True;
328 c->screen = get_screen_bycoord(c->geometry.x, c->geometry.y);
330 move_client_to_screen(c, screen, True);
332 /* update window title */
333 client_updatetitle(c);
335 if(c->geometry.width == area.width && c->geometry.height == area.height)
336 c->border = wa->border_width;
337 else
338 c->border = globalconf.screens[screen].borderpx;
340 ewmh_check_client_hints(c);
341 /* loadprops or apply rules if no props */
342 if(!client_loadprops(c, screen))
343 tag_client_with_rules(c);
345 /* if window request fullscreen mode */
346 if(c->geometry.width == area.width && c->geometry.height == area.height)
348 c->geometry.x = area.x;
349 c->geometry.y = area.y;
351 else
353 darea = get_display_area(phys_screen,
354 globalconf.screens[screen].statusbar,
355 &globalconf.screens[screen].padding);
357 if(c->geometry.x + c->geometry.width + 2 * c->border > darea.x + darea.width)
358 c->geometry.x = c->f_geometry.x = darea.x + darea.width - c->geometry.width - 2 * c->border;
359 if(c->geometry.y + c->geometry.height + 2 * c->border > darea.y + darea.height)
360 c->geometry.y = c->f_geometry.y = darea.y + darea.height - c->geometry.height - 2 * c->border;
361 if(c->geometry.x < darea.x)
362 c->geometry.x = c->f_geometry.x = darea.x;
363 if(c->geometry.y < darea.y)
364 c->geometry.y = c->f_geometry.y = darea.y;
367 /* XXX if this necessary ? */
368 /* set borders */
369 wc.border_width = c->border;
370 XConfigureWindow(globalconf.display, w, CWBorderWidth, &wc);
371 XSetWindowBorder(globalconf.display, w, globalconf.screens[screen].colors_normal[ColBorder].pixel);
372 /* propagates border_width, if size doesn't change */
373 window_configure(c->win, c->geometry, c->border);
375 /* update hints */
376 client_updatesizehints(c);
377 client_updatewmhints(c);
379 XSelectInput(globalconf.display, w, StructureNotifyMask | PropertyChangeMask | EnterWindowMask);
381 /* handle xshape */
382 if(globalconf.have_shape)
384 XShapeSelectInput(globalconf.display, w, ShapeNotifyMask);
385 window_setshape(phys_screen, c->win);
388 /* grab buttons */
389 window_grabbuttons(phys_screen, c->win, False, True);
391 /* check for transient and set tags like its parent,
392 * XGetTransientForHint returns 1 on success
394 if((rettrans = XGetTransientForHint(globalconf.display, w, &trans))
395 && (t = get_client_bywin(globalconf.clients, trans)))
396 for(tag = globalconf.screens[c->screen].tags; tag; tag = tag->next)
397 if(is_client_tagged(t, tag))
398 tag_client(c, tag);
400 /* should be floating if transsient or fixed */
401 if(!c->isfloating)
402 c->isfloating = rettrans || c->isfixed;
404 /* save new props */
405 client_saveprops(c);
407 /* attach to the stack */
408 for(rule = globalconf.rules; rule; rule = rule->next)
409 if(rule->not_master && client_match_rule(c, rule))
411 client_attach_at_end(c);
412 break;
414 if(!rule)
416 if(globalconf.screens[c->screen].new_become_master)
417 client_attach(c);
418 else
419 client_attach_at_end(c);
422 ewmh_update_net_client_list(phys_screen);
424 /* some windows require this */
425 XMoveResizeWindow(globalconf.display, c->win, c->geometry.x, c->geometry.y,
426 c->geometry.width, c->geometry.height);
428 if(globalconf.screens[c->screen].new_get_focus)
429 focus(c, True, screen);
431 widget_invalidate_cache(c->screen, WIDGET_CACHE_CLIENTS);
433 /* rearrange to display new window */
434 arrange(c->screen);
437 /** Resize client window
438 * \param c client to resize
439 * \param geometry new window geometry
440 * \param sizehints respect size hints
441 * \param return True if resize has been done
443 Bool
444 client_resize(Client *c, Area geometry, Bool sizehints)
446 int new_screen;
447 double dx, dy, max, min, ratio;
448 Area area;
449 XWindowChanges wc;
451 if(sizehints)
453 if(c->minay > 0 && c->maxay > 0 && (geometry.height - c->baseh) > 0
454 && (geometry.width - c->basew) > 0)
456 dx = (double) (geometry.width - c->basew);
457 dy = (double) (geometry.height - c->baseh);
458 min = (double) (c->minax) / (double) (c->minay);
459 max = (double) (c->maxax) / (double) (c->maxay);
460 ratio = dx / dy;
461 if(max > 0 && min > 0 && ratio > 0)
463 if(ratio < min)
465 dy = (dx * min + dy) / (min * min + 1);
466 dx = dy * min;
467 geometry.width = (int) dx + c->basew;
468 geometry.height = (int) dy + c->baseh;
470 else if(ratio > max)
472 dy = (dx * min + dy) / (max * max + 1);
473 dx = dy * min;
474 geometry.width = (int) dx + c->basew;
475 geometry.height = (int) dy + c->baseh;
479 if(c->minw && geometry.width < c->minw)
480 geometry.width = c->minw;
481 if(c->minh && geometry.height < c->minh)
482 geometry.height = c->minh;
483 if(c->maxw && geometry.width > c->maxw)
484 geometry.width = c->maxw;
485 if(c->maxh && geometry.height > c->maxh)
486 geometry.height = c->maxh;
487 if(c->incw)
488 geometry.width -= (geometry.width - c->basew) % c->incw;
489 if(c->inch)
490 geometry.height -= (geometry.height - c->baseh) % c->inch;
492 if(geometry.width <= 0 || geometry.height <= 0)
493 return False;
494 /* offscreen appearance fixes */
495 area = get_display_area(get_phys_screen(c->screen),
496 NULL,
497 &globalconf.screens[c->screen].padding);
498 if(geometry.x > area.width)
499 geometry.x = area.width - geometry.width - 2 * c->border;
500 if(geometry.y > area.height)
501 geometry.y = area.height - geometry.height - 2 * c->border;
502 if(geometry.x + geometry.width + 2 * c->border < 0)
503 geometry.x = 0;
504 if(geometry.y + geometry.height + 2 * c->border < 0)
505 geometry.y = 0;
507 if(c->geometry.x != geometry.x || c->geometry.y != geometry.y
508 || c->geometry.width != geometry.width || c->geometry.height != geometry.height)
510 if(XineramaIsActive(globalconf.display))
511 new_screen = get_screen_bycoord(geometry.x, geometry.y);
512 else
513 new_screen = c->screen;
515 c->geometry.x = wc.x = geometry.x;
516 c->geometry.y = wc.y = geometry.y;
517 c->geometry.width = wc.width = geometry.width;
518 c->geometry.height = wc.height = geometry.height;
519 wc.border_width = c->border;
521 /* save the floating geometry if the window is floating but not
522 * maximized */
523 if((c->isfloating ||
524 get_current_layout(new_screen)->arrange == layout_floating) && !c->ismax)
525 c->f_geometry = geometry;
527 XConfigureWindow(globalconf.display, c->win,
528 CWX | CWY | CWWidth | CWHeight | CWBorderWidth, &wc);
529 window_configure(c->win, geometry, c->border);
531 if(c->screen != new_screen)
532 move_client_to_screen(c, new_screen, False);
534 return True;
536 return False;
539 /** Save client properties as an X property
540 * \param c client
542 void
543 client_saveprops(Client *c)
545 int i = 0, ntags = 0;
546 char *prop;
547 Tag *tag;
549 for(tag = globalconf.screens[c->screen].tags; tag; tag = tag->next)
550 ntags++;
552 prop = p_new(char, ntags + 2);
554 for(tag = globalconf.screens[c->screen].tags; tag; tag = tag->next, i++)
555 prop[i] = is_client_tagged(c, tag) ? '1' : '0';
557 if(i <= ntags)
558 prop[i] = c->isfloating ? '1' : '0';
560 prop[++i] = '\0';
562 XChangeProperty(globalconf.display, c->win,
563 XInternAtom(globalconf.display, "_AWESOME_PROPERTIES", False),
564 XA_STRING, 8, PropModeReplace, (unsigned char *) prop, i);
566 p_delete(&prop);
569 void
570 client_unban(Client *c)
572 XMapWindow(globalconf.display, c->win);
573 window_setstate(c->win, NormalState);
576 void
577 client_unmanage(Client *c)
579 XWindowChanges wc;
580 Tag *tag;
582 wc.border_width = c->oldborder;
584 /* The server grab construct avoids race conditions. */
585 XGrabServer(globalconf.display);
587 XConfigureWindow(globalconf.display, c->win, CWBorderWidth, &wc); /* restore border */
589 /* remove client everywhere */
590 client_detach(c);
591 focus_delete_client(c);
592 for(tag = globalconf.screens[c->screen].tags; tag; tag = tag->next)
593 untag_client(c, tag);
595 if(globalconf.focus->client == c)
596 focus(NULL, True, c->screen);
598 XUngrabButton(globalconf.display, AnyButton, AnyModifier, c->win);
599 window_setstate(c->win, WithdrawnState);
601 XSync(globalconf.display, False);
602 XUngrabServer(globalconf.display);
604 arrange(c->screen);
605 p_delete(&c);
608 void
609 client_updatewmhints(Client *c)
611 XWMHints *wmh;
613 if((wmh = XGetWMHints(globalconf.display, c->win)))
615 if((c->isurgent = (wmh->flags & XUrgencyHint)))
616 widget_invalidate_cache(c->screen, WIDGET_CACHE_CLIENTS);
617 if((wmh->flags & StateHint) && wmh->initial_state == WithdrawnState)
619 c->border = 0;
620 c->skip = True;
622 XFree(wmh);
626 void
627 client_updatesizehints(Client *c)
629 long msize;
630 XSizeHints size;
632 if(!XGetWMNormalHints(globalconf.display, c->win, &size, &msize) || !size.flags)
633 size.flags = PSize;
634 if(size.flags & PBaseSize)
636 c->basew = size.base_width;
637 c->baseh = size.base_height;
639 else if(size.flags & PMinSize)
641 c->basew = size.min_width;
642 c->baseh = size.min_height;
644 else
645 c->basew = c->baseh = 0;
646 if(size.flags & PResizeInc)
648 c->incw = size.width_inc;
649 c->inch = size.height_inc;
651 else
652 c->incw = c->inch = 0;
654 if(size.flags & PMaxSize)
656 c->maxw = size.max_width;
657 c->maxh = size.max_height;
659 else
660 c->maxw = c->maxh = 0;
662 if(size.flags & PMinSize)
664 c->minw = size.min_width;
665 c->minh = size.min_height;
667 else if(size.flags & PBaseSize)
669 c->minw = size.base_width;
670 c->minh = size.base_height;
672 else
673 c->minw = c->minh = 0;
675 if(size.flags & PAspect)
677 c->minax = size.min_aspect.x;
678 c->maxax = size.max_aspect.x;
679 c->minay = size.min_aspect.y;
680 c->maxay = size.max_aspect.y;
682 else
683 c->minax = c->maxax = c->minay = c->maxay = 0;
685 if(c->maxw && c->minw && c->maxh && c->minh
686 && c->maxw == c->minw && c->maxh == c->minh)
687 c->isfixed = True;
690 /** Returns True if a client is tagged
691 * with one of the tags
692 * \return True or False
694 Bool
695 client_isvisible(Client *c, int screen)
697 Tag *tag;
699 if(!c || c->screen != screen)
700 return False;
702 for(tag = globalconf.screens[screen].tags; tag; tag = tag->next)
703 if(tag->selected && is_client_tagged(c, tag))
704 return True;
705 return False;
708 /** Set selected client transparency
709 * \param screen Screen ID
710 * \param arg unused arg
711 * \ingroup ui_callback
713 void
714 uicb_client_settrans(int screen __attribute__ ((unused)), char *arg)
716 double delta = 100.0, current_opacity = 100.0;
717 unsigned char *data;
718 Atom actual;
719 int format;
720 unsigned long n, left;
721 unsigned int current_opacity_raw = 0;
722 int set_prop = 0;
723 Client *sel = globalconf.focus->client;
725 if(!sel)
726 return;
728 XGetWindowProperty(globalconf.display, sel->win,
729 XInternAtom(globalconf.display, "_NET_WM_WINDOW_OPACITY", False),
730 0L, 1L, False, XA_CARDINAL, &actual, &format, &n, &left,
731 (unsigned char **) &data);
732 if(data)
734 memcpy(&current_opacity_raw, data, sizeof(unsigned int));
735 XFree(data);
736 current_opacity = (current_opacity_raw * 100.0) / 0xffffffff;
738 else
739 set_prop = 1;
741 delta = compute_new_value_from_arg(arg, current_opacity);
743 if(delta <= 0.0)
744 delta = 0.0;
745 else if(delta > 100.0)
747 delta = 100.0;
748 set_prop = 1;
751 if(delta == 100.0 && !set_prop)
752 window_settrans(sel->win, -1);
753 else
754 window_settrans(sel->win, delta);
757 /** Swap current with next client
758 * \param screen Screen ID
759 * \param arg nothing
760 * \ingroup ui_callback
762 void
763 uicb_client_swapnext(int screen, char *arg __attribute__ ((unused)))
765 Client *next, *sel = globalconf.focus->client;
767 if(!sel)
768 return;
770 for(next = sel->next; next && !client_isvisible(next, screen); next = next->next);
771 if(next)
773 client_swap(&globalconf.clients, sel, next);
774 arrange(screen);
778 /** Swap current with previous client
779 * \param screen Screen ID
780 * \param arg nothing
781 * \ingroup ui_callback
783 void
784 uicb_client_swapprev(int screen, char *arg __attribute__ ((unused)))
786 Client *prev, *sel = globalconf.focus->client;
788 if(!sel)
789 return;
791 for(prev = sel->prev; prev && !client_isvisible(prev, screen); prev = prev->prev);
792 if(prev)
794 client_swap(&globalconf.clients, prev, sel);
795 arrange(screen);
799 /** Move and resize client
800 * \param screen Screen ID
801 * \param arg x y w h
802 * \ingroup ui_callback
804 void
805 uicb_client_moveresize(int screen, char *arg)
807 int ox, oy, ow, oh;
808 char x[8], y[8], w[8], h[8];
809 int mx, my, dx, dy, nmx, nmy;
810 unsigned int dui;
811 Window dummy;
812 Area area;
813 Client *sel = globalconf.focus->client;
814 Tag **curtags = get_current_tags(screen);
816 if(curtags[0]->layout->arrange != layout_floating)
817 if(!sel || !sel->isfloating || sel->isfixed || !arg)
819 p_delete(&curtags);
820 return;
822 p_delete(&curtags);
823 if(sscanf(arg, "%s %s %s %s", x, y, w, h) != 4)
824 return;
825 area.x = (int) compute_new_value_from_arg(x, sel->geometry.x);
826 area.y = (int) compute_new_value_from_arg(y, sel->geometry.y);
827 area.width = (int) compute_new_value_from_arg(w, sel->geometry.width);
828 area.height = (int) compute_new_value_from_arg(h, sel->geometry.height);
830 ox = sel->geometry.x;
831 oy = sel->geometry.y;
832 ow = sel->geometry.width;
833 oh = sel->geometry.height;
835 Bool xqp = XQueryPointer(globalconf.display,
836 RootWindow(globalconf.display,
837 get_phys_screen(screen)),
838 &dummy, &dummy, &mx, &my, &dx, &dy, &dui);
839 client_resize(sel, area, globalconf.screens[sel->screen].resize_hints);
840 if (xqp && ox <= mx && (ox + ow) >= mx && oy <= my && (oy + oh) >= my)
842 nmx = mx - ox + sel->geometry.width - ow - 1 < 0 ? 0 : mx - ox + sel->geometry.width - ow - 1;
843 nmy = my - oy + sel->geometry.height - oh - 1 < 0 ? 0 : my - oy + sel->geometry.height - oh - 1;
844 XWarpPointer(globalconf.display,
845 None, sel->win,
846 0, 0, 0, 0, nmx, nmy);
851 void
852 client_kill(Client *c)
854 XEvent ev;
856 if(isprotodel(globalconf.display, c->win))
858 ev.type = ClientMessage;
859 ev.xclient.window = c->win;
860 ev.xclient.message_type = XInternAtom(globalconf.display, "WM_PROTOCOLS", False);
861 ev.xclient.format = 32;
862 ev.xclient.data.l[0] = XInternAtom(globalconf.display, "WM_DELETE_WINDOW", False);
863 ev.xclient.data.l[1] = CurrentTime;
864 XSendEvent(globalconf.display, c->win, False, NoEventMask, &ev);
866 else
867 XKillClient(globalconf.display, c->win);
870 /** Kill selected client
871 * \param screen Screen ID
872 * \param arg unused
873 * \ingroup ui_callback
875 void
876 uicb_client_kill(int screen __attribute__ ((unused)), char *arg __attribute__ ((unused)))
878 Client *sel = globalconf.focus->client;
880 if(sel)
881 client_kill(sel);
884 static void
885 client_maximize(Client *c, Area geometry)
888 if((c->ismax = !c->ismax))
890 c->wasfloating = c->isfloating;
891 c->m_geometry = c->geometry;
892 if(get_current_layout(c->screen)->arrange != layout_floating)
893 c->isfloating = True;
894 client_resize(c, geometry, False);
895 restack(c->screen);
896 widget_invalidate_cache(c->screen, WIDGET_CACHE_CLIENTS);
898 else if(c->wasfloating)
900 c->isfloating = True;
901 client_resize(c, c->m_geometry, False);
902 restack(c->screen);
903 widget_invalidate_cache(c->screen, WIDGET_CACHE_CLIENTS);
905 else if(get_current_layout(c->screen)->arrange == layout_floating)
907 client_resize(c, c->m_geometry, False);
908 restack(c->screen);
909 widget_invalidate_cache(c->screen, WIDGET_CACHE_CLIENTS);
911 else
913 c->isfloating = False;
914 arrange(c->screen);
915 widget_invalidate_cache(c->screen, WIDGET_CACHE_CLIENTS);
919 /** Toggle maximize for client
920 * \param screen Screen ID
921 * \param arg Unused
922 * \ingroup ui_callback
924 void
925 uicb_client_togglemax(int screen, char *arg __attribute__ ((unused)))
927 Client *sel = globalconf.focus->client;
928 Area area = get_screen_area(screen,
929 globalconf.screens[screen].statusbar,
930 &globalconf.screens[screen].padding);
932 if(sel)
934 area.width -= 2 * sel->border;
935 area.height -= 2 * sel->border;
936 client_maximize(sel, area);
940 /** Toggle vertical maximize for client
941 * \param screen Screen ID
942 * \param arg Unused
943 * \ingroup ui_callback
945 void
946 uicb_client_toggleverticalmax(int screen, char *arg __attribute__ ((unused)))
948 Client *sel = globalconf.focus->client;
949 Area area = get_screen_area(screen,
950 globalconf.screens[screen].statusbar,
951 &globalconf.screens[screen].padding);
953 if(sel)
955 area.x = sel->geometry.x;
956 area.width = sel->geometry.width;
957 area.height -= 2 * sel->border;
958 client_maximize(sel, area);
963 /** Toggle horizontal maximize for client
964 * \param screen Screen ID
965 * \param arg Unused
966 * \ingroup ui_callback
968 void
969 uicb_client_togglehorizontalmax(int screen, char *arg __attribute__ ((unused)))
971 Client *sel = globalconf.focus->client;
972 Area area = get_screen_area(screen,
973 globalconf.screens[screen].statusbar,
974 &globalconf.screens[screen].padding);
976 if(sel)
978 area.y = sel->geometry.y;
979 area.height = sel->geometry.height;
980 area.width -= 2 * sel->border;
981 client_maximize(sel, area);
985 /** Zoom client
986 * \param screen Screen ID
987 * \param arg Unused
988 * \ingroup ui_callback
990 void
991 uicb_client_zoom(int screen, char *arg __attribute__ ((unused)))
993 Client *c, *sel = globalconf.focus->client;
995 for(c = globalconf.clients; !client_isvisible(c, screen); c = c->next);
996 if(c == sel)
997 for(sel = sel->next; sel && !client_isvisible(sel, screen); sel = sel->next);
999 if(!sel)
1000 return;
1002 client_detach(sel);
1003 client_attach(sel);
1004 arrange(screen);
1007 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80