hooks: fix mouseover compat
[awesome.git] / client.c
blob6f3f2f93cf92b92750845d5aa5d7371888957833
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 <xcb/xcb_atom.h>
24 #include "cnode.h"
25 #include "tag.h"
26 #include "window.h"
27 #include "ewmh.h"
28 #include "screen.h"
29 #include "titlebar.h"
30 #include "systray.h"
31 #include "property.h"
32 #include "layouts/floating.h"
33 #include "common/markup.h"
34 #include "common/atoms.h"
36 extern awesome_t globalconf;
38 DO_LUA_NEW(extern, client_t, client, "client", client_ref)
39 DO_LUA_EQ(client_t, client, "client")
40 DO_LUA_GC(client_t, client, "client", client_unref)
42 /** Load windows properties, restoring client's tag
43 * and floating state before awesome was restarted if any.
44 * \param c A client pointer.
45 * \param screen A virtual screen.
46 * \return True if client had property, false otherwise.
48 static bool
49 client_loadprops(client_t * c, screen_t *screen)
51 ssize_t len;
52 tag_array_t *tags = &screen->tags;
53 char *prop = NULL;
54 xcb_get_property_cookie_t floating_q, fullscreen_q;
55 xcb_get_property_reply_t *reply;
56 void *data;
58 if(!xutil_text_prop_get(globalconf.connection, c->win, _AWESOME_TAGS,
59 &prop, &len))
60 return false;
62 /* Send the GetProperty requests which will be processed later */
63 floating_q = xcb_get_property_unchecked(globalconf.connection, false, c->win,
64 _AWESOME_FLOATING, CARDINAL, 0, 1);
66 fullscreen_q = xcb_get_property_unchecked(globalconf.connection, false, c->win,
67 _AWESOME_FULLSCREEN, CARDINAL, 0, 1);
69 /* ignore property if the tag count isn't matching */
70 if(len == tags->len)
71 for(int i = 0; i < tags->len; i++)
72 if(prop[i] == '1')
73 tag_client(c, tags->tab[i]);
74 else
75 untag_client(c, tags->tab[i]);
77 p_delete(&prop);
79 /* check for floating */
80 reply = xcb_get_property_reply(globalconf.connection, floating_q, NULL);
82 if(reply && reply->value_len && (data = xcb_get_property_value(reply)))
83 client_setfloating(c, *(bool *) data);
84 p_delete(&reply);
86 /* check for fullscreen */
87 reply = xcb_get_property_reply(globalconf.connection, fullscreen_q, NULL);
89 if(reply && reply->value_len && (data = xcb_get_property_value(reply)))
90 client_setfullscreen(c, *(bool *) data);
91 p_delete(&reply);
93 return true;
96 /** Check if client supports protocol a protocole in WM_PROTOCOL.
97 * \param win The window.
98 * \return True if client has the atom in protocol, false otherwise.
100 static bool
101 window_hasproto(xcb_window_t win, xcb_atom_t atom)
103 uint32_t i;
104 xcb_get_wm_protocols_reply_t protocols;
105 bool ret = false;
107 if(xcb_get_wm_protocols_reply(globalconf.connection,
108 xcb_get_wm_protocols_unchecked(globalconf.connection,
109 win, WM_PROTOCOLS),
110 &protocols, NULL))
112 for(i = 0; !ret && i < protocols.atoms_len; i++)
113 if(protocols.atoms[i] == atom)
114 ret = true;
115 xcb_get_wm_protocols_reply_wipe(&protocols);
117 return ret;
120 /** Returns true if a client is tagged
121 * with one of the tags of the specified screen.
122 * \param c The client to check.
123 * \param screen Virtual screen number.
124 * \return true if the client is visible, false otherwise.
126 bool
127 client_maybevisible(client_t *c, int screen)
129 if(c->screen == screen)
131 if(c->issticky || c->type == WINDOW_TYPE_DESKTOP)
132 return true;
134 tag_array_t *tags = &globalconf.screens[screen].tags;
136 for(int i = 0; i < tags->len; i++)
137 if(tags->tab[i]->selected && is_client_tagged(c, tags->tab[i]))
138 return true;
140 return false;
143 /** Get a client by its window.
144 * \param w The client window to find.
145 * \return A client pointer if found, NULL otherwise.
147 client_t *
148 client_getbywin(xcb_window_t w)
150 client_t *c;
151 for(c = globalconf.clients; c && c->win != w; c = c->next);
152 return c;
155 /** Unfocus a client.
156 * \param c The client.
158 static void
159 client_unfocus(client_t *c)
161 globalconf.screens[c->phys_screen].client_focus = NULL;
163 /* Call hook */
164 luaA_client_userdata_new(globalconf.L, c);
165 luaA_dofunction(globalconf.L, globalconf.hooks.unfocus, 1, 0);
167 ewmh_update_net_active_window(c->phys_screen);
170 /** Ban client and unmap it.
171 * \param c The client.
173 void
174 client_ban(client_t *c)
176 if(globalconf.screen_focus->client_focus == c)
177 client_unfocus(c);
178 xcb_unmap_window(globalconf.connection, c->win);
179 if(c->ishidden)
180 window_state_set(c->win, XCB_WM_STATE_ICONIC);
181 else
182 window_state_set(c->win, XCB_WM_STATE_WITHDRAWN);
183 if(c->titlebar)
184 xcb_unmap_window(globalconf.connection, c->titlebar->sw.window);
187 /** Give focus to client, or to first client if client is NULL.
188 * \param c The client or NULL.
189 * \return True if a window (even root) has received focus, false otherwise.
191 static void
192 client_focus(client_t *c)
194 if(!client_maybevisible(c, c->screen) || c->nofocus)
195 return;
197 /* unfocus current selected client */
198 if(globalconf.screen_focus->client_focus
199 && c != globalconf.screen_focus->client_focus)
200 client_unfocus(globalconf.screen_focus->client_focus);
202 /* stop hiding c */
203 c->ishidden = false;
204 client_setminimized(c, false);
206 /* unban the client before focusing or it will fail */
207 client_unban(c);
209 globalconf.screen_focus = &globalconf.screens[c->phys_screen];
210 globalconf.screen_focus->client_focus = c;
212 xcb_set_input_focus(globalconf.connection, XCB_INPUT_FOCUS_POINTER_ROOT,
213 c->win, XCB_CURRENT_TIME);
215 /* Some layouts use focused client differently, so call them back.
216 * And anyway, we have maybe unhidden */
217 client_need_arrange(c);
219 /* execute hook */
220 luaA_client_userdata_new(globalconf.L, globalconf.screen_focus->client_focus);
221 luaA_dofunction(globalconf.L, globalconf.hooks.focus, 1, 0);
223 ewmh_update_net_active_window(c->phys_screen);
226 /** Stack a window below.
227 * \param c The client.
228 * \param mode The mode.
229 * \param previous The previous window on the stack.
230 * \param return The next-previous!
232 static xcb_window_t
233 client_stack_position(client_t *c, xcb_stack_mode_t mode, xcb_window_t previous)
235 uint32_t config_win_vals[2];
237 config_win_vals[0] = previous;
238 config_win_vals[1] = mode;
240 if(c->titlebar)
242 xcb_configure_window(globalconf.connection,
243 c->titlebar->sw.window,
244 XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE,
245 config_win_vals);
246 config_win_vals[0] = c->titlebar->sw.window;
248 xcb_configure_window(globalconf.connection, c->win,
249 XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE,
250 config_win_vals);
251 return c->win;
254 /** Stacking layout layers */
255 typedef enum
257 /** This one is a special layer */
258 LAYER_TRANSIENT_FOR,
259 LAYER_DESKTOP,
260 LAYER_BELOW,
261 LAYER_TILE,
262 LAYER_FLOAT,
263 LAYER_ABOVE,
264 LAYER_FULLSCREEN,
265 LAYER_ONTOP,
266 LAYER_OUTOFSPACE
267 } layer_t;
269 /** Get the real layer of a client according to its attribute (fullscreen, …)
270 * \param c The client.
271 * \return The real layer.
273 static layer_t
274 client_layer_translator(client_t *c)
276 if(c->isontop)
277 return LAYER_ONTOP;
278 else if(c->isfullscreen)
279 return LAYER_FULLSCREEN;
280 else if(c->isabove)
281 return LAYER_ABOVE;
282 else if(c->isfloating)
283 return LAYER_FLOAT;
284 else if(c->transient_for)
285 return LAYER_TRANSIENT_FOR;
287 switch(c->type)
289 case WINDOW_TYPE_DOCK:
290 return LAYER_ABOVE;
291 case WINDOW_TYPE_DESKTOP:
292 return LAYER_DESKTOP;
293 default:
294 return LAYER_TILE;
298 /** Restack clients.
299 * \todo It might be worth stopping to restack everyone and only stack `c'
300 * relatively to the first matching in the list.
302 void
303 client_stack()
305 uint32_t config_win_vals[2];
306 client_node_t *node, *last = *client_node_list_last(&globalconf.stack);
307 layer_t layer;
308 int screen;
310 config_win_vals[0] = XCB_NONE;
311 config_win_vals[1] = XCB_STACK_MODE_ABOVE;
313 /* first stack not ontop wibox window */
314 for(screen = 0; screen < globalconf.nscreen; screen++)
315 for(int i = 0; i < globalconf.screens[screen].wiboxes.len; i++)
317 wibox_t *sb = globalconf.screens[screen].wiboxes.tab[i];
318 if(!sb->ontop)
320 xcb_configure_window(globalconf.connection,
321 sb->sw.window,
322 XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE,
323 config_win_vals);
324 config_win_vals[0] = sb->sw.window;
328 /* stack bottom layers */
329 for(layer = LAYER_DESKTOP; layer < LAYER_FULLSCREEN; layer++)
330 for(node = last; node; node = node->prev)
331 if(client_layer_translator(node->client) == layer)
332 config_win_vals[0] = client_stack_position(node->client,
333 XCB_STACK_MODE_ABOVE,
334 config_win_vals[0]);
336 /* then stack ontop wibox window */
337 for(screen = 0; screen < globalconf.nscreen; screen++)
338 for(int i = 0; i < globalconf.screens[screen].wiboxes.len; i++)
340 wibox_t *sb = globalconf.screens[screen].wiboxes.tab[i];
341 if(sb->ontop)
343 xcb_configure_window(globalconf.connection,
344 sb->sw.window,
345 XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE,
346 config_win_vals);
347 config_win_vals[0] = sb->sw.window;
351 /* finally stack ontop and fullscreen windows */
352 for(layer = LAYER_FULLSCREEN; layer < LAYER_OUTOFSPACE; layer++)
353 for(node = last; node; node = node->prev)
354 if(client_layer_translator(node->client) == layer)
355 config_win_vals[0] = client_stack_position(node->client,
356 XCB_STACK_MODE_ABOVE,
357 config_win_vals[0]);
359 /* stack transient window on top of their parents */
360 for(node = last; node; node = node->prev)
361 if(client_layer_translator(node->client) == LAYER_TRANSIENT_FOR)
362 client_stack_position(node->client,
363 XCB_STACK_MODE_ABOVE,
364 node->client->transient_for->win);
368 /** Manage a new client.
369 * \param w The window.
370 * \param wgeom Window geometry.
371 * \param phys_screen Physical screen number.
372 * \param screen Virtual screen number where to manage client.
374 void
375 client_manage(xcb_window_t w, xcb_get_geometry_reply_t *wgeom, int phys_screen, int screen)
377 xcb_get_property_cookie_t ewmh_icon_cookie;
378 client_t *c;
379 image_t *icon;
380 const uint32_t select_input_val[] =
382 XCB_EVENT_MASK_STRUCTURE_NOTIFY
383 | XCB_EVENT_MASK_PROPERTY_CHANGE
384 | XCB_EVENT_MASK_ENTER_WINDOW
387 /* Send request to get NET_WM_ICON property as soon as possible... */
388 ewmh_icon_cookie = ewmh_window_icon_get_unchecked(w);
389 xcb_change_window_attributes(globalconf.connection, w, XCB_CW_EVENT_MASK, select_input_val);
391 if(systray_iskdedockapp(w))
393 systray_request_handle(w, phys_screen, NULL);
394 return;
397 c = p_new(client_t, 1);
399 c->screen = screen_getbycoord(screen, wgeom->x, wgeom->y);
401 c->phys_screen = phys_screen;
403 /* Initial values */
404 c->win = w;
405 c->geometry.x = c->f_geometry.x = c->m_geometry.x = wgeom->x;
406 c->geometry.y = c->f_geometry.y = c->m_geometry.y = wgeom->y;
407 c->geometry.width = c->f_geometry.width = c->m_geometry.width = wgeom->width;
408 c->geometry.height = c->f_geometry.height = c->m_geometry.height = wgeom->height;
409 client_setborder(c, wgeom->border_width);
410 if((icon = ewmh_window_icon_get_reply(ewmh_icon_cookie)))
411 c->icon = image_ref(&icon);
413 /* we honor size hints by default */
414 c->honorsizehints = true;
416 /* update hints */
417 property_update_wm_normal_hints(c, NULL);
418 property_update_wm_hints(c, NULL);
419 property_update_wm_transient_for(c, NULL);
421 if(c->transient_for)
422 screen = c->transient_for->screen;
424 /* Try to load props if any */
425 client_loadprops(c, &globalconf.screens[screen]);
428 /* Then check clients hints */
429 ewmh_client_check_hints(c);
431 /* move client to screen, but do not tag it for now */
432 screen_client_moveto(c, screen, false, true);
434 /* Check if client has been tagged by loading props, or maybe with its
435 * hints.
436 * If not, we tag it with current selected ones.
437 * This could be done on Lua side, but it's a sane behaviour. */
438 if(!c->issticky)
440 int i;
441 tag_array_t *tags = &globalconf.screens[screen].tags;
442 for(i = 0; i < tags->len; i++)
443 if(is_client_tagged(c, tags->tab[i]))
444 break;
446 /* if no tag, set current selected */
447 if(i == tags->len)
448 for(i = 0; i < tags->len; i++)
449 if(tags->tab[i]->selected)
450 tag_client(c, tags->tab[i]);
453 /* Push client in client list */
454 client_list_push(&globalconf.clients, client_ref(&c));
456 /* Push client in stack */
457 client_raise(c);
459 /* update window title */
460 property_update_wm_name(c);
461 property_update_wm_icon_name(c);
463 /* update strut */
464 ewmh_client_strut_update(c, NULL);
466 ewmh_update_net_client_list(c->phys_screen);
468 /* Call hook to notify list change */
469 luaA_dofunction(globalconf.L, globalconf.hooks.clients, 0, 0);
471 /* call hook */
472 luaA_client_userdata_new(globalconf.L, c);
473 luaA_dofunction(globalconf.L, globalconf.hooks.manage, 1, 0);
476 /** Compute client geometry with respect to its geometry hints.
477 * \param c The client.
478 * \param geometry The geometry that the client might receive.
479 * \return The geometry the client must take respecting its hints.
481 area_t
482 client_geometry_hints(client_t *c, area_t geometry)
484 double dx, dy, max, min, ratio;
486 if(c->minay > 0 && c->maxay > 0 && (geometry.height - c->baseh) > 0
487 && (geometry.width - c->basew) > 0)
489 dx = (double) (geometry.width - c->basew);
490 dy = (double) (geometry.height - c->baseh);
491 min = (double) (c->minax) / (double) (c->minay);
492 max = (double) (c->maxax) / (double) (c->maxay);
493 ratio = dx / dy;
494 if(max > 0 && min > 0 && ratio > 0)
496 if(ratio < min)
498 dy = (dx * min + dy) / (min * min + 1);
499 dx = dy * min;
500 geometry.width = (int) dx + c->basew;
501 geometry.height = (int) dy + c->baseh;
503 else if(ratio > max)
505 dy = (dx * min + dy) / (max * max + 1);
506 dx = dy * min;
507 geometry.width = (int) dx + c->basew;
508 geometry.height = (int) dy + c->baseh;
512 if(c->minw && geometry.width < c->minw)
513 geometry.width = c->minw;
514 if(c->minh && geometry.height < c->minh)
515 geometry.height = c->minh;
516 if(c->maxw && geometry.width > c->maxw)
517 geometry.width = c->maxw;
518 if(c->maxh && geometry.height > c->maxh)
519 geometry.height = c->maxh;
520 if(c->incw)
521 geometry.width -= (geometry.width - c->basew) % c->incw;
522 if(c->inch)
523 geometry.height -= (geometry.height - c->baseh) % c->inch;
525 return geometry;
528 /** Resize client window.
529 * \param c Client to resize.
530 * \param geometry New window geometry.
531 * \param hints Use size hints.
533 void
534 client_resize(client_t *c, area_t geometry, bool hints)
536 int new_screen;
537 area_t area;
538 layout_t *layout = layout_get_current(c->screen);
539 bool fixed;
540 /* Values to configure a window is an array where values are
541 * stored according to 'value_mask' */
542 uint32_t values[5];
544 if(c->titlebar && !c->ismoving && !client_isfloating(c) && layout != layout_floating)
545 geometry = titlebar_geometry_remove(c->titlebar, c->border, geometry);
547 if(hints)
548 geometry = client_geometry_hints(c, geometry);
550 if(geometry.width <= 0 || geometry.height <= 0)
551 return;
553 /* offscreen appearance fixes */
554 area = display_area_get(c->phys_screen, NULL,
555 &globalconf.screens[c->screen].padding);
557 fixed = client_isfixed(c);
559 if(geometry.x > area.width)
560 geometry.x = area.width - geometry.width - 2 * c->border;
561 if(geometry.y > area.height)
562 geometry.y = area.height - geometry.height - 2 * c->border;
563 if(geometry.x + geometry.width + 2 * c->border < 0)
564 geometry.x = 0;
565 if(geometry.y + geometry.height + 2 * c->border < 0)
566 geometry.y = 0;
568 /* fixed windows can only change their x,y */
569 if((fixed && (c->geometry.x != geometry.x || c->geometry.y != geometry.y))
570 || (!fixed && (c->geometry.x != geometry.x
571 || c->geometry.y != geometry.y
572 || c->geometry.width != geometry.width
573 || c->geometry.height != geometry.height)))
575 new_screen = screen_getbycoord(c->screen, geometry.x, geometry.y);
577 c->geometry.x = values[0] = geometry.x;
578 c->geometry.width = values[2] = geometry.width;
579 c->geometry.y = values[1] = geometry.y;
580 c->geometry.height = values[3] = geometry.height;
581 values[4] = c->border;
583 /* save the floating geometry if the window is floating but not
584 * maximized */
585 if(c->ismoving || client_isfloating(c)
586 || layout_get_current(new_screen) == layout_floating)
587 if(!c->isfullscreen)
588 c->f_geometry = geometry;
590 titlebar_update_geometry_floating(c);
592 xcb_configure_window(globalconf.connection, c->win,
593 XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y |
594 XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT |
595 XCB_CONFIG_WINDOW_BORDER_WIDTH,
596 values);
597 window_configure(c->win, geometry, c->border);
599 if(c->screen != new_screen)
600 screen_client_moveto(c, new_screen, true, false);
602 /* execute hook */
603 hooks_property(c, "geometry");
607 /** Set a clinet floating.
608 * \param c The client.
609 * \param floating Set floating, or not.
610 * \param layer Layer to put the floating window onto.
612 void
613 client_setfloating(client_t *c, bool floating)
615 if(c->isfloating != floating
616 && (c->type == WINDOW_TYPE_NORMAL))
618 if((c->isfloating = floating))
619 if(!c->isfullscreen)
620 client_resize(c, c->f_geometry, false);
621 client_need_arrange(c);
622 client_stack();
623 xcb_change_property(globalconf.connection,
624 XCB_PROP_MODE_REPLACE,
625 c->win, _AWESOME_FLOATING, CARDINAL, 8, 1,
626 &c->isfloating);
627 /* execute hook */
628 hooks_property(c, "floating");
632 /** Set a client minimized, or not.
633 * \param c The client.
634 * \param s Set or not the client minimized.
636 void
637 client_setminimized(client_t *c, bool s)
639 if(c->isminimized != s)
641 client_need_arrange(c);
642 c->isminimized = s;
643 client_need_arrange(c);
644 ewmh_client_update_hints(c);
645 /* execute hook */
646 hooks_property(c, "minimized");
650 /** Set a client sticky, or not.
651 * \param c The client.
652 * \param s Set or not the client sticky.
654 void
655 client_setsticky(client_t *c, bool s)
657 if(c->issticky != s)
659 client_need_arrange(c);
660 c->issticky = s;
661 client_need_arrange(c);
662 ewmh_client_update_hints(c);
663 hooks_property(c, "sticky");
667 /** Set a client fullscreen, or not.
668 * \param c The client.
669 * \param s Set or not the client fullscreen.
671 void
672 client_setfullscreen(client_t *c, bool s)
674 if(c->isfullscreen != s)
676 area_t geometry;
678 /* become fullscreen! */
679 if((c->isfullscreen = s))
681 geometry = screen_area_get(c->screen, NULL, NULL, false);
682 c->m_geometry = c->geometry;
683 c->oldborder = c->border;
684 client_setborder(c, 0);
686 else
688 geometry = c->m_geometry;
689 client_setborder(c, c->oldborder);
690 client_resize(c, c->m_geometry, false);
692 client_resize(c, geometry, false);
693 client_need_arrange(c);
694 client_stack();
695 xcb_change_property(globalconf.connection,
696 XCB_PROP_MODE_REPLACE,
697 c->win, _AWESOME_FULLSCREEN, CARDINAL, 8, 1,
698 &c->isfullscreen);
699 ewmh_client_update_hints(c);
700 hooks_property(c, "fullscreen");
704 /** Set a client above, or not.
705 * \param c The client.
706 * \param s Set or not the client above.
708 void
709 client_setabove(client_t *c, bool s)
711 if(c->isabove != s)
713 c->isabove = s;
714 client_stack();
715 ewmh_client_update_hints(c);
716 /* execute hook */
717 hooks_property(c, "above");
721 /** Set a client below, or not.
722 * \param c The client.
723 * \param s Set or not the client below.
725 void
726 client_setbelow(client_t *c, bool s)
728 if(c->isbelow != s)
730 c->isbelow = s;
731 client_stack();
732 ewmh_client_update_hints(c);
733 /* execute hook */
734 hooks_property(c, "below");
738 /** Set a client modal, or not.
739 * \param c The client.
740 * \param s Set or not the client moda.
742 void
743 client_setmodal(client_t *c, bool s)
745 if(c->ismodal != s)
747 c->ismodal = s;
748 client_stack();
749 ewmh_client_update_hints(c);
750 /* execute hook */
751 hooks_property(c, "modal");
755 /** Set a client ontop, or not.
756 * \param c The client.
757 * \param s Set or not the client moda.
759 void
760 client_setontop(client_t *c, bool s)
762 if(c->isontop != s)
764 c->isontop = s;
765 client_stack();
766 /* execute hook */
767 hooks_property(c, "ontop");
771 /** Save client properties as an X property.
772 * \param c The client.
774 void
775 client_saveprops_tags(client_t *c)
777 tag_array_t *tags = &globalconf.screens[c->screen].tags;
778 unsigned char *prop = p_alloca(unsigned char, tags->len + 1);
779 int i;
781 for(i = 0; i < tags->len; i++)
782 prop[i] = is_client_tagged(c, tags->tab[i]) ? '1' : '0';
784 xcb_change_property(globalconf.connection, XCB_PROP_MODE_REPLACE, c->win, _AWESOME_TAGS, STRING, 8, i, prop);
787 /** Unban a client.
788 * \param c The client.
790 void
791 client_unban(client_t *c)
793 xcb_map_window(globalconf.connection, c->win);
794 window_state_set(c->win, XCB_WM_STATE_NORMAL);
795 if(c->titlebar)
797 if(c->isfullscreen || !c->titlebar->isvisible)
798 xcb_unmap_window(globalconf.connection, c->titlebar->sw.window);
799 else
800 xcb_map_window(globalconf.connection, c->titlebar->sw.window);
804 /** Unmanage a client.
805 * \param c The client.
807 void
808 client_unmanage(client_t *c)
810 tag_array_t *tags = &globalconf.screens[c->screen].tags;
812 if(globalconf.screens[c->phys_screen].client_focus == c)
813 client_unfocus(c);
815 /* remove client everywhere */
816 client_list_detach(&globalconf.clients, c);
817 stack_client_delete(c);
818 for(int i = 0; i < tags->len; i++)
819 untag_client(c, tags->tab[i]);
821 /* call hook */
822 luaA_client_userdata_new(globalconf.L, c);
823 luaA_dofunction(globalconf.L, globalconf.hooks.unmanage, 1, 0);
825 /* Call hook to notify list change */
826 luaA_dofunction(globalconf.L, globalconf.hooks.clients, 0, 0);
828 /* The server grab construct avoids race conditions. */
829 xcb_grab_server(globalconf.connection);
831 xcb_configure_window(globalconf.connection, c->win,
832 XCB_CONFIG_WINDOW_BORDER_WIDTH,
833 (uint32_t *) &c->oldborder);
835 xcb_ungrab_button(globalconf.connection, XCB_BUTTON_INDEX_ANY, c->win,
836 XCB_BUTTON_MASK_ANY);
837 window_state_set(c->win, XCB_WM_STATE_WITHDRAWN);
839 xcb_flush(globalconf.connection);
840 xcb_ungrab_server(globalconf.connection);
842 titlebar_client_detach(c);
844 ewmh_update_net_client_list(c->phys_screen);
846 /* delete properties */
847 xcb_delete_property(globalconf.connection, c->win, _AWESOME_TAGS);
848 xcb_delete_property(globalconf.connection, c->win, _AWESOME_FLOATING);
850 if(client_hasstrut(c))
851 /* All the wiboxes (may) need to be repositioned */
852 for(int screen = 0; screen < globalconf.nscreen; screen++)
853 for(int i = 0; i < globalconf.screens[screen].wiboxes.len; i++)
855 wibox_t *s = globalconf.screens[screen].wiboxes.tab[i];
856 wibox_position_update(s);
859 /* set client as invalid */
860 c->invalid = true;
862 client_unref(&c);
865 /** Kill a client via a WM_DELETE_WINDOW request or KillClient if not
866 * supported.
867 * \param c The client to kill.
869 void
870 client_kill(client_t *c)
872 if(window_hasproto(c->win, WM_DELETE_WINDOW))
874 xcb_client_message_event_t ev;
876 /* Initialize all of event's fields first */
877 p_clear(&ev, 1);
879 ev.response_type = XCB_CLIENT_MESSAGE;
880 ev.window = c->win;
881 ev.format = 32;
882 ev.data.data32[1] = XCB_CURRENT_TIME;
883 ev.type = WM_PROTOCOLS;
884 ev.data.data32[0] = WM_DELETE_WINDOW;
886 xcb_send_event(globalconf.connection, false, c->win,
887 XCB_EVENT_MASK_NO_EVENT, (char *) &ev);
889 else
890 xcb_kill_client(globalconf.connection, c->win);
893 /** Get all clients into a table.
894 * \param L The Lua VM state.
895 * \return The number of elements pushed on stack.
896 * \luastack
897 * \lparam An optional screen nunmber.
898 * \lreturn A table with all clients.
900 static int
901 luaA_client_get(lua_State *L)
903 int i = 1, screen;
904 client_t *c;
906 screen = luaL_optnumber(L, 1, 0) - 1;
908 lua_newtable(L);
910 if(screen == SCREEN_UNDEF)
911 for(c = globalconf.clients; c; c = c->next)
913 luaA_client_userdata_new(globalconf.L, c);
914 lua_rawseti(L, -2, i++);
916 else
918 luaA_checkscreen(screen);
919 for(c = globalconf.clients; c; c = c->next)
920 if(c->screen == screen)
922 luaA_client_userdata_new(globalconf.L, c);
923 lua_rawseti(L, -2, i++);
927 return 1;
930 /** Get only visible clients for a screen (DEPRECATED).
931 * \param L The Lua VM state.
932 * \return The number of elements pushed on stack.
933 * \luastack
934 * \lparam A screen number.
935 * \lreturn A table with all visible clients for this screen.
937 static int
938 luaA_client_visible_get(lua_State *L)
940 int i = 1;
941 client_t *c;
942 int screen = luaL_checknumber(L, 1) - 1;
944 luaA_checkscreen(screen);
946 deprecate(L);
948 lua_newtable(L);
950 for(c = globalconf.clients; c; c = c->next)
951 if(client_isvisible(c, screen))
953 luaA_client_userdata_new(L, c);
954 lua_rawseti(L, -2, i++);
957 return 1;
960 /** Check if a client is visible on its screen.
961 * \param L The Lua VM state.
962 * \return The number of elements pushed on stack.
963 * \luastack
964 * \lvalue A client.
965 * \lreturn A boolean value, true if the client is visible, false otherwise.
967 static int
968 luaA_client_isvisible(lua_State *L)
970 client_t **c = luaA_checkudata(L, 1, "client");
971 lua_pushboolean(L, client_isvisible(*c, (*c)->screen));
972 return 1;
975 /** Set client border width.
976 * \param c The client.
977 * \param width The border width.
979 void
980 client_setborder(client_t *c, int width)
982 uint32_t w = width;
984 if(width > 0 && (c->type == WINDOW_TYPE_DOCK
985 || c->type == WINDOW_TYPE_SPLASH
986 || c->type == WINDOW_TYPE_DESKTOP
987 || c->isfullscreen))
988 return;
990 if(width == c->border || width < 0)
991 return;
993 c->border = width;
994 xcb_configure_window(globalconf.connection, c->win,
995 XCB_CONFIG_WINDOW_BORDER_WIDTH, &w);
997 if(client_isvisible(c, c->screen))
999 if(client_isfloating(c) || layout_get_current(c->screen) == layout_floating)
1000 titlebar_update_geometry_floating(c);
1001 else
1002 globalconf.screens[c->screen].need_arrange = true;
1005 hooks_property(c, "border_width");
1008 /** Kill a client.
1009 * \param L The Lua VM state.
1011 * \luastack
1012 * \lvalue A client.
1014 static int
1015 luaA_client_kill(lua_State *L)
1017 client_t **c = luaA_checkudata(L, 1, "client");
1018 client_kill(*c);
1019 return 0;
1022 /** Swap a client with another one.
1023 * \param L The Lua VM state.
1024 * \luastack
1025 * \lvalue A client.
1026 * \lparam A client to swap with.
1028 static int
1029 luaA_client_swap(lua_State *L)
1031 client_t **c = luaA_checkudata(L, 1, "client");
1032 client_t **swap = luaA_checkudata(L, 2, "client");
1033 client_list_swap(&globalconf.clients, *swap, *c);
1034 client_need_arrange(*c);
1035 client_need_arrange(*swap);
1037 /* Call hook to notify list change */
1038 luaA_dofunction(L, globalconf.hooks.clients, 0, 0);
1040 return 0;
1043 /** Access or set the client tags.
1044 * \param L The Lua VM state.
1045 * \return The number of elements pushed on stack.
1046 * \lparam A table with tags to set, or none to get the current tags table.
1047 * \return The clients tag.
1049 static int
1050 luaA_client_tags(lua_State *L)
1052 tag_array_t *tags;
1053 tag_t **tag;
1054 client_t **c = luaA_checkudata(L, 1, "client");
1055 int j = 0;
1057 if(lua_gettop(L) == 2)
1059 luaA_checktable(L, 2);
1060 tags = &globalconf.screens[(*c)->screen].tags;
1061 for(int i = 0; i < tags->len; i++)
1062 untag_client(*c, tags->tab[i]);
1063 lua_pushnil(L);
1064 while(lua_next(L, 2))
1066 tag = luaA_checkudata(L, -1, "tag");
1067 tag_client(*c, *tag);
1068 lua_pop(L, 1);
1070 lua_pop(L, 1);
1073 tags = &globalconf.screens[(*c)->screen].tags;
1074 luaA_otable_new(L);
1075 for(int i = 0; i < tags->len; i++)
1076 if(is_client_tagged(*c, tags->tab[i]))
1078 luaA_tag_userdata_new(L, tags->tab[i]);
1079 lua_rawseti(L, -2, ++j);
1082 return 1;
1085 /** Raise a client on top of others which are on the same layer.
1086 * \param L The Lua VM state.
1088 * \luastack
1089 * \lvalue A client.
1091 static int
1092 luaA_client_raise(lua_State *L)
1094 client_t **c = luaA_checkudata(L, 1, "client");
1095 client_raise(*c);
1096 return 0;
1099 /** Redraw a client by unmapping and mapping it quickly.
1100 * \param L The Lua VM state.
1102 * \luastack
1103 * \lvalue A client.
1105 static int
1106 luaA_client_redraw(lua_State *L)
1108 client_t **c = luaA_checkudata(L, 1, "client");
1110 xcb_unmap_window(globalconf.connection, (*c)->win);
1111 xcb_map_window(globalconf.connection, (*c)->win);
1113 /* Set the focus on the current window if the redraw has been
1114 performed on the window where the pointer is currently on
1115 because after the unmapping/mapping, the focus is lost */
1116 if(globalconf.screen_focus->client_focus == *c)
1117 xcb_set_input_focus(globalconf.connection, XCB_INPUT_FOCUS_POINTER_ROOT,
1118 (*c)->win, XCB_CURRENT_TIME);
1120 return 0;
1123 /** Stop managing a client.
1124 * \param L The Lua VM state.
1125 * \return The number of elements pushed on stack.
1126 * \luastack
1127 * \lvalue A client.
1129 static int
1130 luaA_client_unmanage(lua_State *L)
1132 client_t **c = luaA_checkudata(L, 1, "client");
1133 client_unmanage(*c);
1134 return 0;
1137 /** Return client geometry.
1138 * \param L The Lua VM state.
1139 * \return The number of elements pushed on stack.
1140 * \luastack
1141 * \lparam A table with new coordinates, or none.
1142 * \lreturn A table with client coordinates.
1144 static int
1145 luaA_client_geometry(lua_State *L)
1147 client_t **c = luaA_checkudata(L, 1, "client");
1149 if(lua_gettop(L) == 2)
1151 if((*c)->isfloating || layout_get_current((*c)->screen) == layout_floating)
1153 area_t geometry;
1155 luaA_checktable(L, 2);
1156 geometry.x = luaA_getopt_number(L, 2, "x", (*c)->geometry.x);
1157 geometry.y = luaA_getopt_number(L, 2, "y", (*c)->geometry.y);
1158 geometry.width = luaA_getopt_number(L, 2, "width", (*c)->geometry.width);
1159 geometry.height = luaA_getopt_number(L, 2, "height", (*c)->geometry.height);
1160 client_resize(*c, geometry, false);
1164 return luaA_pusharea(L, (*c)->geometry);
1167 static int
1168 luaA_client_coords(lua_State *L)
1170 deprecate(L);
1171 return luaA_client_geometry(L);
1174 /** Return client geometry, using also titlebar and border width.
1175 * \param L The Lua VM state.
1176 * \return The number of elements pushed on stack.
1177 * \luastack
1178 * \lparam A table with new coordinates, or none.
1179 * \lreturn A table with client coordinates.
1181 static int
1182 luaA_client_fullgeometry(lua_State *L)
1184 client_t **c = luaA_checkudata(L, 1, "client");
1185 area_t geometry;
1187 if(lua_gettop(L) == 2)
1189 if((*c)->isfloating || layout_get_current((*c)->screen) == layout_floating)
1191 luaA_checktable(L, 2);
1192 geometry.x = luaA_getopt_number(L, 2, "x", (*c)->geometry.x);
1193 geometry.y = luaA_getopt_number(L, 2, "y", (*c)->geometry.y);
1194 geometry.width = luaA_getopt_number(L, 2, "width", (*c)->geometry.width);
1195 geometry.height = luaA_getopt_number(L, 2, "height", (*c)->geometry.height);
1196 geometry = titlebar_geometry_remove((*c)->titlebar,
1197 (*c)->border,
1198 geometry);
1199 client_resize(*c, geometry, false);
1203 return luaA_pusharea(L, titlebar_geometry_add((*c)->titlebar,
1204 (*c)->border,
1205 (*c)->geometry));
1208 static int
1209 luaA_client_fullcoords(lua_State *L)
1211 deprecate(L);
1212 return luaA_client_fullgeometry(L);
1215 /** Client newindex.
1216 * \param L The Lua VM state.
1217 * \return The number of elements pushed on stack.
1220 luaA_client_newindex(lua_State *L)
1222 size_t len;
1223 client_t **c = luaA_checkudata(L, 1, "client");
1224 const char *buf = luaL_checklstring(L, 2, &len);
1225 bool b;
1226 double d;
1227 int i;
1228 wibox_t **t = NULL;
1229 image_t **image;
1231 if((*c)->invalid)
1232 luaL_error(L, "client is invalid\n");
1234 switch(a_tokenize(buf, len))
1236 case A_TK_SCREEN:
1237 if(globalconf.xinerama_is_active)
1239 i = luaL_checknumber(L, 3) - 1;
1240 luaA_checkscreen(i);
1241 if(i != (*c)->screen)
1242 screen_client_moveto(*c, i, true, true);
1244 break;
1245 case A_TK_HIDE:
1246 b = luaA_checkboolean(L, 3);
1247 if(b != (*c)->ishidden)
1249 client_need_arrange(*c);
1250 (*c)->ishidden = b;
1251 client_need_arrange(*c);
1253 break;
1254 case A_TK_MINIMIZE:
1255 client_setminimized(*c, luaA_checkboolean(L, 3));
1256 break;
1257 case A_TK_FULLSCREEN:
1258 client_setfullscreen(*c, luaA_checkboolean(L, 3));
1259 break;
1260 case A_TK_ICON:
1261 image = luaA_checkudata(L, 3, "image");
1262 image_unref(&(*c)->icon);
1263 image_ref(image);
1264 (*c)->icon = *image;
1265 /* execute hook */
1266 hooks_property(*c, "icon");
1267 break;
1268 case A_TK_OPACITY:
1269 if(lua_isnil(L, 3))
1270 window_opacity_set((*c)->win, -1);
1271 else
1273 d = luaL_checknumber(L, 3);
1274 if(d >= 0 && d <= 1)
1275 window_opacity_set((*c)->win, d);
1277 break;
1278 case A_TK_FLOATING:
1279 client_setfloating(*c, luaA_checkboolean(L, 3));
1280 break;
1281 case A_TK_STICKY:
1282 client_setsticky(*c, luaA_checkboolean(L, 3));
1283 break;
1284 case A_TK_HONORSIZEHINTS:
1285 (*c)->honorsizehints = luaA_checkboolean(L, 3);
1286 client_need_arrange(*c);
1287 break;
1288 case A_TK_BORDER_WIDTH:
1289 client_setborder(*c, luaL_checknumber(L, 3));
1290 break;
1291 case A_TK_ONTOP:
1292 client_setontop(*c, luaA_checkboolean(L, 3));
1293 break;
1294 case A_TK_BORDER_COLOR:
1295 if((buf = luaL_checklstring(L, 3, &len))
1296 && xcolor_init_reply(xcolor_init_unchecked(&(*c)->border_color, buf, len)))
1297 xcb_change_window_attributes(globalconf.connection, (*c)->win,
1298 XCB_CW_BORDER_PIXEL, &(*c)->border_color.pixel);
1299 break;
1300 case A_TK_TITLEBAR:
1301 if(lua_isnil(L, 3))
1302 titlebar_client_detach(*c);
1303 else
1305 t = luaA_checkudata(L, 3, "wibox");
1306 titlebar_client_attach(*c, *t);
1308 break;
1309 default:
1310 return 0;
1313 return 0;
1316 /** Client object.
1317 * \param L The Lua VM state.
1318 * \return The number of elements pushed on stack.
1319 * \luastack
1320 * \lfield name The client title.
1321 * \lfield skip_taskbar True if the client does not want to be in taskbar.
1322 * \lfield type The window type (desktop, normal, dock, …).
1323 * \lfield class The client class.
1324 * \lfield instance The client instance.
1325 * \lfield pid The client PID, if available.
1326 * \lfield role The window role, if available.
1327 * \lfield machine The machine client is running on.
1328 * \lfield icon_name The client name when iconified.
1329 * \lfield screen Client screen number.
1330 * \lfield hide Define if the client must be hidden, i.e. never mapped,
1331 * invisible in taskbar.
1332 * \lfield minimize Define it the client must be iconify, i.e. only visible in
1333 * taskbar.
1334 * \lfield icon_path Path to the icon used to identify.
1335 * \lfield floating True always floating.
1336 * \lfield honorsizehints Honor size hints, i.e. respect size ratio.
1337 * \lfield border_width The client border width.
1338 * \lfield border_color The client border color.
1339 * \lfield titlebar The client titlebar.
1340 * \lfield urgent The client urgent state.
1341 * \lfield focus The focused client.
1342 * \lfield opacity The client opacity between 0 and 1.
1343 * \lfield ontop The client is on top of every other windows.
1344 * \lfield fullscreen The client is fullscreen or not.
1346 static int
1347 luaA_client_index(lua_State *L)
1349 size_t len;
1350 ssize_t slen;
1351 client_t **c = luaA_checkudata(L, 1, "client");
1352 const char *buf = luaL_checklstring(L, 2, &len);
1353 char *value;
1354 void *data;
1355 xcb_get_wm_class_reply_t hint;
1356 xcb_get_property_cookie_t prop_c;
1357 xcb_get_property_reply_t *prop_r = NULL;
1358 double d;
1360 if((*c)->invalid)
1361 luaL_error(L, "client is invalid\n");
1363 if(luaA_usemetatable(L, 1, 2))
1364 return 1;
1366 switch(a_tokenize(buf, len))
1368 case A_TK_NAME:
1369 lua_pushstring(L, (*c)->name);
1370 break;
1371 case A_TK_SKIP_TASKBAR:
1372 lua_pushboolean(L, (*c)->skiptb);
1373 break;
1374 case A_TK_TYPE:
1375 switch((*c)->type)
1377 case WINDOW_TYPE_DESKTOP:
1378 lua_pushliteral(L, "desktop");
1379 break;
1380 case WINDOW_TYPE_DOCK:
1381 lua_pushliteral(L, "dock");
1382 break;
1383 case WINDOW_TYPE_SPLASH:
1384 lua_pushliteral(L, "splash");
1385 break;
1386 case WINDOW_TYPE_DIALOG:
1387 lua_pushliteral(L, "dialog");
1388 break;
1389 default:
1390 lua_pushliteral(L, "normal");
1391 break;
1393 break;
1394 case A_TK_CLASS:
1395 if(!xcb_get_wm_class_reply(globalconf.connection,
1396 xcb_get_wm_class_unchecked(globalconf.connection, (*c)->win),
1397 &hint, NULL))
1398 return 0;
1399 lua_pushstring(L, hint.class);
1400 xcb_get_wm_class_reply_wipe(&hint);
1401 break;
1402 case A_TK_INSTANCE:
1403 if(!xcb_get_wm_class_reply(globalconf.connection,
1404 xcb_get_wm_class_unchecked(globalconf.connection, (*c)->win),
1405 &hint, NULL))
1406 return 0;
1407 lua_pushstring(L, hint.name);
1408 xcb_get_wm_class_reply_wipe(&hint);
1409 break;
1410 case A_TK_ROLE:
1411 if(!xutil_text_prop_get(globalconf.connection, (*c)->win,
1412 WM_WINDOW_ROLE, &value, &slen))
1413 return 0;
1414 lua_pushlstring(L, value, slen);
1415 p_delete(&value);
1416 break;
1417 case A_TK_PID:
1418 prop_c = xcb_get_property_unchecked(globalconf.connection, false, (*c)->win, _NET_WM_PID, CARDINAL, 0L, 1L);
1419 prop_r = xcb_get_property_reply(globalconf.connection, prop_c, NULL);
1421 if(prop_r && prop_r->value_len && (data = xcb_get_property_value(prop_r)))
1422 lua_pushnumber(L, *(uint32_t *)data);
1423 else
1425 p_delete(&prop_r);
1426 return 0;
1428 break;
1429 case A_TK_MACHINE:
1430 if(!xutil_text_prop_get(globalconf.connection, (*c)->win,
1431 WM_CLIENT_MACHINE, &value, &slen))
1432 return 0;
1433 lua_pushlstring(L, value, slen);
1434 p_delete(&value);
1435 break;
1436 case A_TK_ICON_NAME:
1437 lua_pushstring(L, (*c)->icon_name);
1438 break;
1439 case A_TK_SCREEN:
1440 lua_pushnumber(L, 1 + (*c)->screen);
1441 break;
1442 case A_TK_HIDE:
1443 lua_pushboolean(L, (*c)->ishidden);
1444 break;
1445 case A_TK_MINIMIZE:
1446 lua_pushboolean(L, (*c)->isminimized);
1447 break;
1448 case A_TK_FULLSCREEN:
1449 lua_pushboolean(L, (*c)->isfullscreen);
1450 break;
1451 case A_TK_ICON:
1452 if((*c)->icon)
1453 luaA_image_userdata_new(L, (*c)->icon);
1454 else
1455 return 0;
1456 break;
1457 case A_TK_OPACITY:
1458 if((d = window_opacity_get((*c)->win)) >= 0)
1459 lua_pushnumber(L, d);
1460 else
1461 return 0;
1462 break;
1463 case A_TK_FLOATING:
1464 lua_pushboolean(L, (*c)->isfloating);
1465 break;
1466 case A_TK_ONTOP:
1467 lua_pushboolean(L, (*c)->isontop);
1468 break;
1469 case A_TK_STICKY:
1470 lua_pushboolean(L, (*c)->issticky);
1471 break;
1472 case A_TK_HONORSIZEHINTS:
1473 lua_pushboolean(L, (*c)->honorsizehints);
1474 break;
1475 case A_TK_BORDER_WIDTH:
1476 lua_pushnumber(L, (*c)->border);
1477 break;
1478 case A_TK_BORDER_COLOR:
1479 luaA_pushcolor(L, &(*c)->border_color);
1480 break;
1481 case A_TK_TITLEBAR:
1482 if((*c)->titlebar)
1483 return luaA_wibox_userdata_new(L, (*c)->titlebar);
1484 return 0;
1485 case A_TK_URGENT:
1486 lua_pushboolean(L, (*c)->isurgent);
1487 break;
1488 case A_TK_SIZEHINTS:
1489 lua_newtable(L);
1490 lua_pushboolean(L, (*c)->size_hints.flags & XCB_SIZE_HINT_US_POSITION);
1491 lua_setfield(L, -2, "user_position");
1492 lua_pushboolean(L, (*c)->size_hints.flags & XCB_SIZE_HINT_US_SIZE);
1493 lua_setfield(L, -2, "user_size");
1494 lua_pushboolean(L, (*c)->size_hints.flags & XCB_SIZE_HINT_P_POSITION);
1495 lua_setfield(L, -2, "program_position");
1496 lua_pushboolean(L, (*c)->size_hints.flags & XCB_SIZE_HINT_P_SIZE);
1497 lua_setfield(L, -2, "program_size");
1498 break;
1499 default:
1500 return 0;
1503 return 1;
1506 /** Get or set mouse buttons bindings for a client.
1507 * \param L The Lua VM state.
1508 * \return The number of element pushed on stack.
1509 * \luastack
1510 * \lvalue A client.
1511 * \lparam An array of mouse button bindings objects, or nothing.
1512 * \return The array of mouse button bindings objects of this client.
1514 static int
1515 luaA_client_buttons(lua_State *L)
1517 client_t **client = luaA_checkudata(L, 1, "client");
1518 button_array_t *buttons = &(*client)->buttons;
1520 if(lua_gettop(L) == 2)
1521 luaA_button_array_set(L, 2, buttons);
1523 return luaA_button_array_get(L, buttons);
1526 /* Client module.
1527 * \param L The Lua VM state.
1528 * \return The number of pushed elements.
1530 static int
1531 luaA_client_module_index(lua_State *L)
1533 size_t len;
1534 const char *buf = luaL_checklstring(L, 2, &len);
1536 switch(a_tokenize(buf, len))
1538 case A_TK_FOCUS:
1539 if(globalconf.screen_focus->client_focus)
1540 luaA_client_userdata_new(L, globalconf.screen_focus->client_focus);
1541 else
1542 return 0;
1543 break;
1544 default:
1545 return 0;
1548 return 1;
1551 /* Client module new index.
1552 * \param L The Lua VM state.
1553 * \return The number of pushed elements.
1555 static int
1556 luaA_client_module_newindex(lua_State *L)
1558 size_t len;
1559 const char *buf = luaL_checklstring(L, 2, &len);
1560 client_t **c;
1562 switch(a_tokenize(buf, len))
1564 case A_TK_FOCUS:
1565 c = luaA_checkudata(L, 3, "client");
1566 client_focus(*c);
1567 break;
1568 default:
1569 break;
1572 return 0;
1575 const struct luaL_reg awesome_client_methods[] =
1577 { "get", luaA_client_get },
1578 { "visible_get", luaA_client_visible_get },
1579 { "__index", luaA_client_module_index },
1580 { "__newindex", luaA_client_module_newindex },
1581 { NULL, NULL }
1583 const struct luaL_reg awesome_client_meta[] =
1585 { "isvisible", luaA_client_isvisible },
1586 { "geometry", luaA_client_geometry },
1587 { "fullgeometry", luaA_client_fullgeometry },
1588 { "buttons", luaA_client_buttons },
1589 { "tags", luaA_client_tags },
1590 { "kill", luaA_client_kill },
1591 { "swap", luaA_client_swap },
1592 { "raise", luaA_client_raise },
1593 { "redraw", luaA_client_redraw },
1594 { "mouse_resize", luaA_client_mouse_resize },
1595 { "mouse_move", luaA_client_mouse_move },
1596 { "unmanage", luaA_client_unmanage },
1597 { "__index", luaA_client_index },
1598 { "__newindex", luaA_client_newindex },
1599 { "__eq", luaA_client_eq },
1600 { "__gc", luaA_client_gc },
1601 { "__tostring", luaA_client_tostring },
1602 /* deprecated */
1603 { "coords", luaA_client_coords },
1604 { "fullcoords", luaA_client_fullcoords },
1605 { NULL, NULL }
1608 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=80