/*

* client.c - client management

*

* Copyright © 2007-2009 Julien Danjou <julien@danjou.info>

*

* This program is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation; either version 2 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License along

* with this program; if not, write to the Free Software Foundation, Inc.,

* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

*

*/

#include <xcb/xcb_atom.h>

#include <xcb/xcb_image.h>

#include "tag.h"

#include "ewmh.h"

#include "screen.h"

#include "titlebar.h"

#include "systray.h"

#include "property.h"

#include "spawn.h"

#include "luaa.h"

#include "common/atoms.h"

#include "common/xutil.h"

client_t *

luaA_client_checkudata(lua_State *L, int ud)

{

client_t *c = luaA_checkudata(L, ud, &client_class);

if(c->invalid)

luaL_error(L, "client is invalid\n");

return c;

}

/** Collect a client.

* \param L The Lua VM state.

* \return The number of element pushed on stack.

*/

static int

luaA_client_gc(lua_State *L)

{

client_t *c = luaA_checkudata(L, 1, &client_class);

button_array_wipe(&c->buttons);

key_array_wipe(&c->keys);

xcb_icccm_get_wm_protocols_reply_wipe(&c->protocols);

p_delete(&c->machine);

p_delete(&c->class);

p_delete(&c->instance);

p_delete(&c->icon_name);

p_delete(&c->alt_icon_name);

p_delete(&c->name);

p_delete(&c->alt_name);

return luaA_object_gc(L);

}

/** Change the client opacity.

* \param L The Lua VM state.

* \param cidx The client index.

* \param opacity The opacity.

*/

void

client_set_opacity(lua_State *L, int cidx, double opacity)

{

client_t *c = luaA_client_checkudata(L, cidx);

if(c->opacity != opacity)

{

c->opacity = opacity;

window_opacity_set(c->window, opacity);

luaA_object_emit_signal(L, cidx, "property::opacity", 0);

}

}

/** Change the clients urgency flag.

* \param L The Lua VM state.

* \param cidx The client index on the stack.

* \param urgent The new flag state.

*/

void

client_set_urgent(lua_State *L, int cidx, bool urgent)

{

client_t *c = luaA_client_checkudata(L, cidx);

if(c->urgent != urgent)

{

xcb_get_property_cookie_t hints =

xcb_icccm_get_wm_hints_unchecked(globalconf.connection, c->window);

c->urgent = urgent;

ewmh_client_update_hints(c);

/* update ICCCM hints */

xcb_icccm_wm_hints_t wmh;

xcb_icccm_get_wm_hints_reply(globalconf.connection, hints, &wmh, NULL);

if(urgent)

wmh.flags |= XCB_ICCCM_WM_HINT_X_URGENCY;

else

wmh.flags &= ~XCB_ICCCM_WM_HINT_X_URGENCY;

xcb_icccm_set_wm_hints(globalconf.connection, c->window, &wmh);

hook_property(c, "urgent");

luaA_object_emit_signal(L, cidx, "property::urgent", 0);

}

}

void

client_set_group_window(lua_State *L, int cidx, xcb_window_t window)

{

client_t *c = luaA_client_checkudata(L, cidx);

if(c->group_window != window)

{

c->group_window = window;

luaA_object_emit_signal(L, cidx, "property::group_window", 0);

}

}

void

client_set_type(lua_State *L, int cidx, window_type_t type)

{

client_t *c = luaA_client_checkudata(L, cidx);

if(c->type != type)

{

c->type = type;

luaA_object_emit_signal(L, cidx, "property::type", 0);

}

}

void

client_set_pid(lua_State *L, int cidx, uint32_t pid)

{

client_t *c = luaA_client_checkudata(L, cidx);

if(c->pid != pid)

{

c->pid = pid;

luaA_object_emit_signal(L, cidx, "property::pid", 0);

}

}

void

client_set_icon_name(lua_State *L, int cidx, char *icon_name)

{

client_t *c = luaA_client_checkudata(L, cidx);

p_delete(&c->icon_name);

c->icon_name = icon_name;

luaA_object_emit_signal(L, cidx, "property::icon_name", 0);

hook_property(c, "icon_name");

}

void

client_set_alt_icon_name(lua_State *L, int cidx, char *icon_name)

{

client_t *c = luaA_client_checkudata(L, cidx);

p_delete(&c->alt_icon_name);

c->alt_icon_name = icon_name;

luaA_object_emit_signal(L, cidx, "property::icon_name", 0);

hook_property(c, "icon_name");

}

void

client_set_role(lua_State *L, int cidx, char *role)

{

client_t *c = luaA_client_checkudata(L, cidx);

p_delete(&c->role);

c->role = role;

luaA_object_emit_signal(L, cidx, "property::role", 0);

}

void

client_set_machine(lua_State *L, int cidx, char *machine)

{

client_t *c = luaA_client_checkudata(L, cidx);

p_delete(&c->machine);

c->machine = machine;

luaA_object_emit_signal(L, cidx, "property::machine", 0);

}

void

client_set_class_instance(lua_State *L, int cidx, const char *class, const char *instance)

{

client_t *c = luaA_client_checkudata(L, cidx);

p_delete(&c->class);

p_delete(&c->instance);

c->class = a_strdup(class);

c->instance = a_strdup(instance);

luaA_object_emit_signal(L, cidx, "property::class", 0);

luaA_object_emit_signal(L, cidx, "property::instance", 0);

}

void

client_set_transient_for(lua_State *L, int cidx, client_t *transient_for)

{

client_t *c = luaA_client_checkudata(L, cidx);

if(c->transient_for != transient_for)

{

c->transient_for = transient_for;

luaA_object_emit_signal(L, cidx, "property::transient_for", 0);

}

}

void

client_set_name(lua_State *L, int cidx, char *name)

{

client_t *c = luaA_client_checkudata(L, cidx);

p_delete(&c->name);

c->name = name;

hook_property(c, "name");

luaA_object_emit_signal(L, cidx, "property::name", 0);

}

void

client_set_alt_name(lua_State *L, int cidx, char *name)

{

client_t *c = luaA_client_checkudata(L, cidx);

p_delete(&c->alt_name);

c->alt_name = name;

hook_property(c, "name");

luaA_object_emit_signal(L, cidx, "property::name", 0);

}

/** Returns true if a client is tagged

* with one of the tags of the specified screen.

* \param c The client to check.

* \param screen Virtual screen.

* \return true if the client is visible, false otherwise.

*/

bool

client_maybevisible(client_t *c, screen_t *screen)

{

if(screen && c->screen == screen)

{

if(c->sticky)

return true;

foreach(tag, screen->tags)

if(tag_get_selected(*tag) && is_client_tagged(c, *tag))

return true;

}

return false;

}

/** Get a client by its window.

* \param w The client window to find.

* \return A client pointer if found, NULL otherwise.

*/

client_t *

client_getbywin(xcb_window_t w)

{

foreach(c, globalconf.clients)

if((*c)->window == w)

return *c;

return NULL;

}

/** Record that a client lost focus.

* \param c Client being unfocused

*/

void

client_unfocus_update(client_t *c)

{

globalconf.screens.tab[c->phys_screen].client_focus = NULL;

ewmh_update_net_active_window(c->phys_screen);

/* Call hook */

if(globalconf.hooks.unfocus != LUA_REFNIL)

{

luaA_object_push(globalconf.L, c);

luaA_dofunction_from_registry(globalconf.L, globalconf.hooks.unfocus, 1, 0);

}

luaA_object_push(globalconf.L, c);

luaA_class_emit_signal(globalconf.L, &client_class, "unfocus", 1);

}

/** Unfocus a client.

* \param c The client.

*/

void

client_unfocus(client_t *c)

{

xcb_window_t root_win = xutil_screen_get(globalconf.connection, c->phys_screen)->root;

/* Set focus on root window, so no events leak to the current window.

* This kind of inlines client_set_focus(), but a root window will never have

* the WM_TAKE_FOCUS protocol.

*/

xcb_set_input_focus(globalconf.connection, XCB_INPUT_FOCUS_PARENT,

root_win, globalconf.timestamp);

client_unfocus_update(c);

}

/** Check if client supports atom a protocol in WM_PROTOCOL.

* \param c The client.

* \param atom The protocol atom to check for.

* \return True if client has the atom in protocol, false otherwise.

*/

bool

client_hasproto(client_t *c, xcb_atom_t atom)

{

for(uint32_t i = 0; i < c->protocols.atoms_len; i++)

if(c->protocols.atoms[i] == atom)

return true;

return false;

}

/** Prepare banning a client by running all needed lua events.

* \param c The client.

*/

void client_ban_unfocus(client_t *c)

{

if(globalconf.screens.tab[c->phys_screen].prev_client_focus == c)

globalconf.screens.tab[c->phys_screen].prev_client_focus = NULL;

/* Wait until the last moment to take away the focus from the window. */

if(globalconf.screens.tab[c->phys_screen].client_focus == c)

client_unfocus(c);

}

/** Ban client and move it out of the viewport.

* \param c The client.

*/

void

client_ban(client_t *c)

{

if(!c->isbanned)

{

xcb_unmap_window(globalconf.connection, c->window);

c->isbanned = true;

client_ban_unfocus(c);

}

}

/** This is part of The Bob Marley Algorithm: we ignore enter and leave window

* in certain cases, like map/unmap or move, so we don't get spurious events.

*/

void

client_ignore_enterleave_events(void)

{

foreach(c, globalconf.clients)

xcb_change_window_attributes(globalconf.connection,

(*c)->window,

XCB_CW_EVENT_MASK,

(const uint32_t []) { CLIENT_SELECT_INPUT_EVENT_MASK & ~(XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW) });

}

void

client_restore_enterleave_events(void)

{

foreach(c, globalconf.clients)

xcb_change_window_attributes(globalconf.connection,

(*c)->window,

XCB_CW_EVENT_MASK,

(const uint32_t []) { CLIENT_SELECT_INPUT_EVENT_MASK });

}

/** Record that a client got focus.

* \param c The client.

*/

void

client_focus_update(client_t *c)

{

if(!client_maybevisible(c, c->screen))

{

/* Focus previously focused client */

client_focus(globalconf.screen_focus->prev_client_focus);

return;

}

if(globalconf.screen_focus

&& globalconf.screen_focus->client_focus)

{

if (globalconf.screen_focus->client_focus != c)

client_unfocus_update(globalconf.screen_focus->client_focus);

else

/* Already focused */

return;

}

globalconf.screen_focus = &globalconf.screens.tab[c->phys_screen];

globalconf.screen_focus->prev_client_focus = c;

globalconf.screen_focus->client_focus = c;

/* according to EWMH, we have to remove the urgent state from a client */

luaA_object_push(globalconf.L, c);

client_set_urgent(globalconf.L, -1, false);

ewmh_update_net_active_window(c->phys_screen);

/* execute hook */

if(globalconf.hooks.focus != LUA_REFNIL)

{

luaA_object_push(globalconf.L, c);

luaA_dofunction_from_registry(globalconf.L, globalconf.hooks.focus, 1, 0);

}

luaA_class_emit_signal(globalconf.L, &client_class, "focus", 1);

}

/** Give focus to client, or to first client if client is NULL.

* \param c The client.

*/

void

client_focus(client_t *c)

{

/* We have to set focus on first client */

if(!c && globalconf.clients.len && !(c = globalconf.clients.tab[0]))

return;

if(!client_maybevisible(c, c->screen))

return;

/* X11 doesn't let you focus a window that isn't viewable */

client_unban(c);

if (!c->nofocus)

{

client_focus_update(c);

xcb_set_input_focus(globalconf.connection, XCB_INPUT_FOCUS_PARENT,

c->window, globalconf.timestamp);

}

if(client_hasproto(c, WM_TAKE_FOCUS))

window_takefocus(c->window);

}

/** Stack a window below.

* \param c The client.

* \param previous The previous window on the stack.

* \return The next-previous!

*/

static xcb_window_t

client_stack_above(client_t *c, xcb_window_t previous)

{

uint32_t config_win_vals[2];

config_win_vals[0] = previous;

config_win_vals[1] = XCB_STACK_MODE_ABOVE;

xcb_configure_window(globalconf.connection, c->window,

XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE,

config_win_vals);

config_win_vals[0] = c->window;

if(c->titlebar)

{

xcb_configure_window(globalconf.connection,

c->titlebar->window,

XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE,

config_win_vals);

previous = c->titlebar->window;

}

else

previous = c->window;

/* stack transient window on top of their parents */

foreach(node, globalconf.stack)

if((*node)->transient_for == c)

previous = client_stack_above(*node, previous);

return previous;

}

/** Stacking layout layers */

typedef enum

{

/** This one is a special layer */

LAYER_IGNORE,

LAYER_DESKTOP,

LAYER_BELOW,

LAYER_NORMAL,

LAYER_ABOVE,

LAYER_FULLSCREEN,

LAYER_ONTOP,

/** This one only used for counting and is not a real layer */

LAYER_COUNT

} layer_t;

/** Get the real layer of a client according to its attribute (fullscreen, …)

* \param c The client.

* \return The real layer.

*/

static layer_t

client_layer_translator(client_t *c)

{

/* first deal with user set attributes */

if(c->ontop)

return LAYER_ONTOP;

else if(c->fullscreen && globalconf.screen_focus->client_focus == c)

return LAYER_FULLSCREEN;

else if(c->above)

return LAYER_ABOVE;

else if(c->below)

return LAYER_BELOW;

/* check for transient attr */

if(c->transient_for)

return LAYER_IGNORE;

/* then deal with windows type */

switch(c->type)

{

case WINDOW_TYPE_DESKTOP:

return LAYER_DESKTOP;

default:

break;

}

return LAYER_NORMAL;

}

/** Restack clients.

* \todo It might be worth stopping to restack everyone and only stack `c'

* relatively to the first matching in the list.

*/

static void

client_stack_refresh_screen(int screen)

{

uint32_t config_win_vals[2];

layer_t layer;

config_win_vals[0] = XCB_NONE;

config_win_vals[1] = XCB_STACK_MODE_ABOVE;

/* stack desktop windows */

for(layer = LAYER_DESKTOP; layer < LAYER_BELOW; layer++)

foreach(node, globalconf.stack)

if((*node)->phys_screen == screen && client_layer_translator(*node) == layer)

config_win_vals[0] = client_stack_above(*node,

config_win_vals[0]);

/* first stack not ontop wibox window */

foreach(_sb, globalconf.wiboxes)

{

wibox_t *sb = *_sb;

if(sb->ctx.phys_screen == screen && !sb->ontop)

{

xcb_configure_window(globalconf.connection,

sb->window,

XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE,

config_win_vals);

config_win_vals[0] = sb->window;

}

}

/* then stack clients */

for(layer = LAYER_BELOW; layer < LAYER_COUNT; layer++)

foreach(node, globalconf.stack)

if((*node)->phys_screen == screen && client_layer_translator(*node) == layer)

config_win_vals[0] = client_stack_above(*node,

config_win_vals[0]);

/* then stack ontop wibox window */

foreach(_sb, globalconf.wiboxes)

{

wibox_t *sb = *_sb;

if(sb->ctx.phys_screen == screen && sb->ontop)

{

xcb_configure_window(globalconf.connection,

sb->window,

XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE,

config_win_vals);

config_win_vals[0] = sb->window;

}

}

}

void

client_stack_refresh()

{

if (!globalconf.client_need_stack_refresh)

return;

globalconf.client_need_stack_refresh = false;

for(int screen = 0;

screen < xcb_setup_roots_length(xcb_get_setup(globalconf.connection));

screen++)

client_stack_refresh_screen(screen);

}

/** Manage a new client.

* \param w The window.

* \param wgeom Window geometry.

* \param phys_screen Physical screen number.

* \param startup True if we are managing at startup time.

*/

void

client_manage(xcb_window_t w, xcb_get_geometry_reply_t *wgeom, int phys_screen, bool startup)

{

const uint32_t select_input_val[] = { CLIENT_SELECT_INPUT_EVENT_MASK };

if(systray_iskdedockapp(w))

{

systray_request_handle(w, phys_screen, NULL);

return;

}

/* If this is a new client that just has been launched, then request its

* startup id. */

xcb_get_property_cookie_t startup_id_q = { 0 };

if(!startup)

startup_id_q = xcb_get_property(globalconf.connection, false, w,

_NET_STARTUP_ID, XCB_GET_PROPERTY_TYPE_ANY, 0, UINT_MAX);

xcb_change_window_attributes(globalconf.connection, w, XCB_CW_EVENT_MASK, select_input_val);

/* Make sure the window is automatically mapped if awesome exits or dies. */

xcb_change_save_set(globalconf.connection, XCB_SET_MODE_INSERT, w);

/* Move this window to the bottom of the stack. Without this we would force

* other windows which will be above this one to redraw themselves because

* this window occludes them for a tiny moment. The next stack_refresh()

* will fix this up and move the window to its correct place. */

xcb_configure_window(globalconf.connection, w,

XCB_CONFIG_WINDOW_STACK_MODE,

(uint32_t[]) { XCB_STACK_MODE_BELOW});

client_t *c = client_new(globalconf.L);

/* This cannot change, ever. */

c->phys_screen = phys_screen;

/* consider the window banned */

c->isbanned = true;

/* Store window */

c->window = w;

luaA_object_emit_signal(globalconf.L, -1, "property::window", 0);

/* Duplicate client and push it in client list */

lua_pushvalue(globalconf.L, -1);

client_array_push(&globalconf.clients, luaA_object_ref(globalconf.L, -1));

/* Set the right screen */

screen_client_moveto(c, screen_getbycoord(&globalconf.screens.tab[phys_screen], wgeom->x, wgeom->y), false);

/* Store initial geometry and emits signals so we inform that geometry have

* been set. */

#define HANDLE_GEOM(attr) \

c->geometry.attr = wgeom->attr; \

c->geometries.internal.attr = wgeom->attr; \

luaA_object_emit_signal(globalconf.L, -1, "property::" #attr, 0);

HANDLE_GEOM(x)

HANDLE_GEOM(y)

HANDLE_GEOM(width)

HANDLE_GEOM(height)

#undef HANDLE_GEOM

luaA_object_emit_signal(globalconf.L, -1, "property::geometry", 0);

/* Push client */

client_set_border_width(globalconf.L, -1, wgeom->border_width);

/* we honor size hints by default */

c->size_hints_honor = true;

luaA_object_emit_signal(globalconf.L, -1, "property::size_hints_honor", 0);

/* update hints */

property_update_wm_normal_hints(c, NULL);

property_update_wm_hints(c, NULL);

property_update_wm_transient_for(c, NULL);

property_update_wm_client_leader(c, NULL);

property_update_wm_client_machine(c, NULL);

property_update_wm_window_role(c, NULL);

property_update_net_wm_pid(c, NULL);

property_update_net_wm_icon(c, NULL);

/* get opacity */

client_set_opacity(globalconf.L, -1, window_opacity_get(c->window));

/* Then check clients hints */

ewmh_client_check_hints(c);

/* Push client in stack */

client_raise(c);

/* update window title */

property_update_wm_name(c, NULL);

property_update_net_wm_name(c, NULL);

property_update_wm_icon_name(c, NULL);

property_update_net_wm_icon_name(c, NULL);

property_update_wm_class(c, NULL);

property_update_wm_protocols(c, NULL);

/* update strut */

ewmh_process_client_strut(c, NULL);

ewmh_update_net_client_list(c->phys_screen);

/* Always stay in NORMAL_STATE. Even though iconified seems more

* appropriate sometimes. The only possible loss is that clients not using

* visibility events may continue to process data (when banned).

* Without any exposes or other events the cost should be fairly limited though.

*

* Some clients may expect the window to be unmapped when STATE_ICONIFIED.

* Two conflicting parts of the ICCCM v2.0 (section 4.1.4):

*

* "Normal -> Iconic - The client should send a ClientMessage event as described later in this section."

* (note no explicit mention of unmapping, while Normal->Widthdrawn does mention that)

*

* "Once a client's window has left the Withdrawn state, the window will be mapped

* if it is in the Normal state and the window will be unmapped if it is in the Iconic state."

*

* At this stage it's just safer to keep it in normal state and avoid confusion.

*/

window_state_set(c->window, XCB_ICCCM_WM_STATE_NORMAL);

if(!startup)

{

/* Request our response */

xcb_get_property_reply_t *reply =

xcb_get_property_reply(globalconf.connection, startup_id_q, NULL);

/* Say spawn that a client has been started, with startup id as argument */

char *startup_id = xutil_get_text_property_from_reply(reply);

p_delete(&reply);

spawn_start_notify(c, startup_id);

p_delete(&startup_id);

}

/* Call hook to notify list change */

if(globalconf.hooks.clients != LUA_REFNIL)

luaA_dofunction_from_registry(globalconf.L, globalconf.hooks.clients, 0, 0);

luaA_class_emit_signal(globalconf.L, &client_class, "list", 0);

/* call hook */

if(globalconf.hooks.manage != LUA_REFNIL)

{

luaA_object_push(globalconf.L, c);

lua_pushboolean(globalconf.L, startup);

luaA_dofunction_from_registry(globalconf.L, globalconf.hooks.manage, 2, 0);

}

/* client is still on top of the stack; push startup value,

* and emit signals with 2 args */

lua_pushboolean(globalconf.L, startup);

luaA_class_emit_signal(globalconf.L, &client_class, "manage", 2);

}

/** Compute client geometry with respect to its geometry hints.

* \param c The client.

* \param geometry The geometry that the client might receive.

* \return The geometry the client must take respecting its hints.

*/

area_t

client_geometry_hints(client_t *c, area_t geometry)

{

int32_t basew, baseh, minw, minh;

int32_t real_basew = 0, real_baseh = 0;

/* base size is substituted with min size if not specified */

if(c->size_hints.flags & XCB_ICCCM_SIZE_HINT_P_SIZE)

{

basew = c->size_hints.base_width;

baseh = c->size_hints.base_height;

real_basew = basew;

real_baseh = baseh;

}

else if(c->size_hints.flags & XCB_ICCCM_SIZE_HINT_P_MIN_SIZE)

{

basew = c->size_hints.min_width;

baseh = c->size_hints.min_height;

}

else

basew = baseh = 0;

/* min size is substituted with base size if not specified */

if(c->size_hints.flags & XCB_ICCCM_SIZE_HINT_P_MIN_SIZE)

{

minw = c->size_hints.min_width;

minh = c->size_hints.min_height;

}

else if(c->size_hints.flags & XCB_ICCCM_SIZE_HINT_P_SIZE)

{

minw = c->size_hints.base_width;

minh = c->size_hints.base_height;

}

else

minw = minh = 0;

if(c->size_hints.flags & XCB_ICCCM_SIZE_HINT_P_ASPECT

&& c->size_hints.min_aspect_den > 0

&& c->size_hints.max_aspect_den > 0

&& geometry.height - real_baseh > 0

&& geometry.width - real_basew > 0)

{

/* ICCCM mandates:

* If a base size is provided along with the aspect ratio fields, the

* base size should be subtracted from the window size prior to checking

* that the aspect ratio falls in range. If a base size is not provided,

* nothing should be subtracted from the window size. (The minimum size

* is not to be used in place of the base size for this purpose.) */

double dx = (double) (geometry.width - real_basew);

double dy = (double) (geometry.height - real_baseh);

double min = (double) c->size_hints.min_aspect_num / (double) c->size_hints.min_aspect_den;

double max = (double) c->size_hints.max_aspect_num / (double) c->size_hints.max_aspect_den;

double ratio = dx / dy;

if(max > 0 && min > 0 && ratio > 0)

{

if(ratio < min)

{

/* dx is lower than allowed, make dy lower to compensate this

* (+ 0.5 to force proper rounding). */

dy = dx / min + 0.5;

geometry.width = (int) dx + real_basew;

geometry.height = (int) dy + real_baseh;

}

else if(ratio > max)

{

/* dx is too high, lower it (+0.5 for proper rounding) */

dx = dy * max + 0.5;

geometry.width = (int) dx + real_basew;

geometry.height = (int) dy + real_baseh;

}

}

}

if(minw)

geometry.width = MAX(geometry.width, minw);

if(minh)

geometry.height = MAX(geometry.height, minh);

if(c->size_hints.flags & XCB_ICCCM_SIZE_HINT_P_MAX_SIZE)

{

if(c->size_hints.max_width)

geometry.width = MIN(geometry.width, c->size_hints.max_width);

if(c->size_hints.max_height)

geometry.height = MIN(geometry.height, c->size_hints.max_height);

}

if(c->size_hints.flags & (XCB_ICCCM_SIZE_HINT_P_RESIZE_INC | XCB_ICCCM_SIZE_HINT_BASE_SIZE)

&& c->size_hints.width_inc && c->size_hints.height_inc)

{

uint16_t t1 = geometry.width, t2 = geometry.height;

unsigned_subtract(t1, basew);

unsigned_subtract(t2, baseh);

geometry.width -= t1 % c->size_hints.width_inc;

geometry.height -= t2 % c->size_hints.height_inc;

}

return geometry;

}

/** Resize client window.

* The sizes given as parameters are with titlebar and borders!

* \param c Client to resize.

* \param geometry New window geometry.

* \param hints Use size hints.

* \return true if an actual resize occurred.

*/

bool

client_resize(client_t *c, area_t geometry, bool hints)

{

area_t geometry_internal;

area_t area;

/* offscreen appearance fixes */

area = display_area_get(c->phys_screen);

if(geometry.x > area.width)

geometry.x = area.width - geometry.width;

if(geometry.y > area.height)

geometry.y = area.height - geometry.height;

if(geometry.x + geometry.width < 0)

geometry.x = 0;

if(geometry.y + geometry.height < 0)

geometry.y = 0;

/* Real client geometry, please keep it contained to C code at the very least. */

if (!c->fullscreen)

geometry_internal = titlebar_geometry_remove(c->titlebar, c->border_width, geometry);

else

geometry_internal = geometry;

if(hints && !c->fullscreen)

geometry_internal = client_geometry_hints(c, geometry_internal);

if(geometry_internal.width == 0 || geometry_internal.height == 0)

return false;

/* Also let client hints propagate to the "official" geometry. */

if (!c->fullscreen)

geometry = titlebar_geometry_add(c->titlebar, c->border_width, geometry_internal);

else

geometry = geometry_internal;

if(c->geometries.internal.x != geometry_internal.x

|| c->geometries.internal.y != geometry_internal.y

|| c->geometries.internal.width != geometry_internal.width

|| c->geometries.internal.height != geometry_internal.height)

{

screen_t *new_screen = screen_getbycoord(c->screen,

geometry_internal.x, geometry_internal.y);

/* Values to configure a window is an array where values are

* stored according to 'value_mask' */

uint32_t values[4];

c->geometries.internal.x = values[0] = geometry_internal.x;

c->geometries.internal.y = values[1] = geometry_internal.y;

c->geometries.internal.width = values[2] = geometry_internal.width;

c->geometries.internal.height = values[3] = geometry_internal.height;

/* Also store geometry including border and titlebar. */

c->geometry = geometry;

titlebar_update_geometry(c);

/* Ignore all spurious enter/leave notify events */

client_ignore_enterleave_events();

xcb_configure_window(globalconf.connection, c->window,

XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y

| XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT,

values);

client_restore_enterleave_events();

screen_client_moveto(c, new_screen, false);

/* execute hook */

hook_property(c, "geometry");

luaA_object_push(globalconf.L, c);

luaA_object_emit_signal(globalconf.L, -1, "property::geometry", 0);

/** \todo This need to be VERIFIED before it is emitted! */

luaA_object_emit_signal(globalconf.L, -1, "property::x", 0);

luaA_object_emit_signal(globalconf.L, -1, "property::y", 0);

luaA_object_emit_signal(globalconf.L, -1, "property::width", 0);

luaA_object_emit_signal(globalconf.L, -1, "property::height", 0);

lua_pop(globalconf.L, 1);

return true;

}

return false;

}

/** Set a client minimized, or not.

* \param L The Lua VM state.

* \param cidx The client index.

* \param s Set or not the client minimized.

*/

void

client_set_minimized(lua_State *L, int cidx, bool s)

{

client_t *c = luaA_client_checkudata(L, cidx);

if(c->minimized != s)

{

c->minimized = s;

banning_need_update((c)->screen);

if(s)

window_state_set(c->window, XCB_ICCCM_WM_STATE_ICONIC);

else

window_state_set(c->window, XCB_ICCCM_WM_STATE_NORMAL);

ewmh_client_update_hints(c);

if(strut_has_value(&c->strut))

screen_emit_signal(globalconf.L, c->screen, "property::workarea", 0);

/* execute hook */

hook_property(c, "minimized");

luaA_object_emit_signal(L, cidx, "property::minimized", 0);

}

}

/** Set a client sticky, or not.

* \param L The Lua VM state.

* \param cidx The client index.

* \param s Set or not the client sticky.

*/

void

client_set_sticky(lua_State *L, int cidx, bool s)

{

client_t *c = luaA_client_checkudata(L, cidx);

if(c->sticky != s)

{

c->sticky = s;

banning_need_update((c)->screen);

ewmh_client_update_hints(c);

hook_property(c, "sticky");

luaA_object_emit_signal(L, cidx, "property::sticky", 0);

}