/*

* client.c - client management

*

* Copyright © 2007-2008 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/xtest.h>

#include <xcb/xcb_atom.h>

#include <xcb/xcb_image.h>

#include "cnode.h"

#include "tag.h"

#include "window.h"

#include "ewmh.h"

#include "screen.h"

#include "titlebar.h"

#include "systray.h"

#include "property.h"

#include "wibox.h"

#include "common/atoms.h"

extern awesome_t globalconf;

DO_LUA_NEW(extern, client_t, client, "client", client_ref)

DO_LUA_EQ(client_t, client, "client")

DO_LUA_GC(client_t, client, "client", client_unref)

/** Load windows properties, restoring client's tag

* and floating state before awesome was restarted if any.

* \param c A client pointer.

* \param screen A virtual screen.

* \return True if client had property, false otherwise.

*/

static bool

client_loadprops(client_t * c, screen_t *screen)

{

ssize_t len;

tag_array_t *tags = &screen->tags;

char *prop = NULL;

xcb_get_property_cookie_t fullscreen_q;

xcb_get_property_reply_t *reply;

void *data;

if(!xutil_text_prop_get(globalconf.connection, c->win, _AWESOME_TAGS,

&prop, &len))

return false;

/* Send the GetProperty requests which will be processed later */

fullscreen_q = xcb_get_property_unchecked(globalconf.connection, false, c->win,

_AWESOME_FULLSCREEN, CARDINAL, 0, 1);

/* ignore property if the tag count isn't matching */

if(len == tags->len)

for(int i = 0; i < tags->len; i++)

{

if(prop[i] == '1')

tag_client(c, tags->tab[i]);

else

untag_client(c, tags->tab[i]);

}

p_delete(&prop);

/* check for fullscreen */

reply = xcb_get_property_reply(globalconf.connection, fullscreen_q, NULL);

if(reply && reply->value_len && (data = xcb_get_property_value(reply)))

client_setfullscreen(c, *(bool *) data);

p_delete(&reply);

return true;

}

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

* \param win The window.

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

*/

static bool

window_hasproto(xcb_window_t win, xcb_atom_t atom)

{

uint32_t i;

xcb_get_wm_protocols_reply_t protocols;

bool ret = false;

if(xcb_get_wm_protocols_reply(globalconf.connection,

xcb_get_wm_protocols_unchecked(globalconf.connection,

win, WM_PROTOCOLS),

&protocols, NULL))

{

for(i = 0; !ret && i < protocols.atoms_len; i++)

if(protocols.atoms[i] == atom)

ret = true;

xcb_get_wm_protocols_reply_wipe(&protocols);

}

return ret;

}

/** Send WM_TAKE_FOCUS client message to window

* \param win destination window

*/

static void

window_takefocus(xcb_window_t win)

{

xcb_client_message_event_t ev;

/* Initialize all of event's fields first */

p_clear(&ev, 1);

ev.response_type = XCB_CLIENT_MESSAGE;

ev.window = win;

ev.format = 32;

ev.data.data32[1] = XCB_CURRENT_TIME;

ev.type = WM_PROTOCOLS;

ev.data.data32[0] = WM_TAKE_FOCUS;

xcb_send_event(globalconf.connection, false, win,

XCB_EVENT_MASK_NO_EVENT, (char *) &ev);

}

/** Change the clients urgency flag.

* \param c The client

* \param urgent The new flag state

*/

void

client_seturgent(client_t *c, bool urgent)

{

if(c->isurgent != urgent)

{

xcb_get_property_cookie_t hints =

xcb_get_wm_hints_unchecked(globalconf.connection, c->win);

c->isurgent = urgent;

ewmh_client_update_hints(c);

/* update ICCCM hints */

xcb_wm_hints_t wmh;

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

if(urgent)

wmh.flags |= XCB_WM_HINT_X_URGENCY;

else

wmh.flags &= ~XCB_WM_HINT_X_URGENCY;

xcb_set_wm_hints(globalconf.connection, c->win, &wmh);

hooks_property(c, "urgent");

}

}

/** 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 number.

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

*/

bool

client_maybevisible(client_t *c, int screen)

{

if(c->screen == screen)

{

if(c->issticky || c->type == WINDOW_TYPE_DESKTOP)

return true;

tag_array_t *tags = &globalconf.screens[screen].tags;

for(int i = 0; i < tags->len; i++)

if(tags->tab[i]->selected && is_client_tagged(c, tags->tab[i]))

return true;

}

return false;

}

/** Return the content of a client as an image.

* That's just take a screenshot.

* \param c The client.

* \return An image.

*/

static image_t *

client_getcontent(client_t *c)

{

xcb_image_t *ximage = xcb_image_get(globalconf.connection,

c->win,

0, 0,

c->geometries.internal.width,

c->geometries.internal.height,

~0, XCB_IMAGE_FORMAT_Z_PIXMAP);

if(!ximage || ximage->bpp < 24)

return NULL;

uint32_t *data = p_alloca(uint32_t, ximage->width * ximage->height);

for(int y = 0; y < ximage->height; y++)

for(int x = 0; x < ximage->width; x++)

{

data[y * ximage->width + x] = xcb_image_get_pixel(ximage, x, y);

data[y * ximage->width + x] |= 0xff000000; /* set alpha to 0xff */

}

image_t *image = image_new_from_argb32(ximage->width, ximage->height, data);

xcb_image_destroy(ximage);

return image;

}

/** 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)

{

client_t *c;

for(c = globalconf.clients; c && c->win != w; c = c->next);

return c;

}

/** Call unfocus hook.

* \param c Client being unfocused

*/

static void

client_unfocus_hook(client_t *c)

{

/* Call hook */

if(globalconf.hooks.unfocus != LUA_REFNIL)

{

luaA_client_userdata_new(globalconf.L, c);

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

}

}

/** Unfocus a client.

* \param c The client.

*/

static void

client_unfocus(client_t *c)

{

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

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

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

xcb_set_input_focus(globalconf.connection, XCB_INPUT_FOCUS_POINTER_ROOT,

root_win, XCB_CURRENT_TIME);

client_unfocus_hook(c);

ewmh_update_net_active_window(c->phys_screen);

}

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

* \param c The client.

*/

void

client_ban(client_t *c)

{

if(!c->isbanned)

{

/* Move all clients out of the physical viewport into negative coordinate space. */

/* They will all be put on top of each other. */

uint32_t request[2] = { - (c->geometries.internal.width + 2 * c->border),

- (c->geometries.internal.height + 2 * c->border) };

xcb_configure_window(globalconf.connection, c->win,

XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y,

request);

titlebar_ban(c->titlebar);

c->isbanned = true;

/* All the wiboxes (may) need to be repositioned. */

if(client_hasstrut(c))

wibox_update_positions();

}

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

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

client_unfocus(c);

}

/** Call focus hook.

* \param c Client being focused.

*/

static void

client_focus_hook(client_t *c)

{

/* execute hook */

if(globalconf.hooks.focus != LUA_REFNIL)

{

luaA_client_userdata_new(globalconf.L, c);

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

}

}

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

* \param c The client or NULL.

* \param sendmessage true, if we should send message.

*/

void

client_focus(client_t *c, bool sendmessage)

{

/* Handle c == NULL case */

if(!c)

{

if(sendmessage)

c = globalconf.clients;

if(!c)

return;

}

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

return;

/* Does client window support WM_TAKE_FOCUS protocol ? */

bool takefocus = window_hasproto(c->win, WM_TAKE_FOCUS);

/* Disallow setting focus on client with No Input Model */

if(sendmessage && !takefocus && c->nofocus)

return;

/* Save current focused client */

client_t *focused_before = globalconf.screen_focus->client_focus;

if(c == focused_before)

return;

/* stop hiding c */

c->ishidden = false;

client_setminimized(c, false);

/* unban the client before focusing or it will fail */

client_unban(c);

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

globalconf.screen_focus->client_focus = c;

if(sendmessage)

{

if(!c->nofocus)

/* Input models: Passive, Locally Active */

xcb_set_input_focus(globalconf.connection, XCB_INPUT_FOCUS_POINTER_ROOT,

c->win, XCB_CURRENT_TIME);

if(takefocus)

/* Input models: No Input, Globally Active */

window_takefocus(c->win);

}

/* Some layouts use focused client differently, so call them back.

* And anyway, we have maybe unhidden */

client_need_arrange(c);

/* unfocus current selected client

* We don't really need to unfocus here,

* because client already received FocusOut event.

* What we need to do is call unfocus hook, to

* inform lua script, about this event.

*/

if(focused_before)

client_unfocus_hook(focused_before);

client_focus_hook(c);

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

client_seturgent(c, false);

ewmh_update_net_active_window(c->phys_screen);

}

/** Stack a window below.

* \param c The client.

* \param previous The previous window on the stack.

* \param 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->win,

XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE,

config_win_vals);

config_win_vals[0] = c->win;

if(c->titlebar)

{

xcb_configure_window(globalconf.connection,

c->titlebar->sw.window,

XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE,

config_win_vals);

previous = c->titlebar->sw.window;

}

else

previous = c->win;

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

for(client_node_t *node = *client_node_list_last(&globalconf.stack);

node; node = node->prev)

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

previous = client_stack_above(node->client, 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,

LAYER_OUTOFSPACE

} 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->isontop)

return LAYER_ONTOP;

else if(c->isfullscreen)

return LAYER_FULLSCREEN;

else if(c->isabove)

return LAYER_ABOVE;

else if(c->isbelow)

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_DOCK:

return LAYER_ABOVE;

case WINDOW_TYPE_DESKTOP:

return LAYER_DESKTOP;

case WINDOW_TYPE_DIALOG:

case WINDOW_TYPE_MENU:

case WINDOW_TYPE_TOOLBAR:

case WINDOW_TYPE_UTILITY:

return LAYER_ABOVE;

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.

*/

void

client_stack()

{

uint32_t config_win_vals[2];

client_node_t *node, *last = *client_node_list_last(&globalconf.stack);

layer_t layer;

int screen;

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++)

for(node = last; node; node = node->prev)

if(client_layer_translator(node->client) == layer)

config_win_vals[0] = client_stack_above(node->client,

config_win_vals[0]);

/* first stack not ontop wibox window */

for(screen = 0; screen < globalconf.nscreen; screen++)

for(int i = 0; i < globalconf.screens[screen].wiboxes.len; i++)

{

wibox_t *sb = globalconf.screens[screen].wiboxes.tab[i];

if(!sb->ontop)

{

xcb_configure_window(globalconf.connection,

sb->sw.window,

XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE,

config_win_vals);

config_win_vals[0] = sb->sw.window;

}

}

/* then stack clients */

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

for(node = last; node; node = node->prev)

if(client_layer_translator(node->client) == layer)

config_win_vals[0] = client_stack_above(node->client,

config_win_vals[0]);

/* then stack ontop wibox window */

for(screen = 0; screen < globalconf.nscreen; screen++)

for(int i = 0; i < globalconf.screens[screen].wiboxes.len; i++)

{

wibox_t *sb = globalconf.screens[screen].wiboxes.tab[i];

if(sb->ontop)

{

xcb_configure_window(globalconf.connection,

sb->sw.window,

XCB_CONFIG_WINDOW_SIBLING | XCB_CONFIG_WINDOW_STACK_MODE,

config_win_vals);

config_win_vals[0] = sb->sw.window;

}

}

}

/** 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)

{

xcb_get_property_cookie_t ewmh_icon_cookie;

client_t *c, *tc = NULL;

image_t *icon;

int screen;

const uint32_t select_input_val[] =

{

XCB_EVENT_MASK_STRUCTURE_NOTIFY

| XCB_EVENT_MASK_PROPERTY_CHANGE

| XCB_EVENT_MASK_ENTER_WINDOW

| XCB_EVENT_MASK_LEAVE_WINDOW

| XCB_EVENT_MASK_FOCUS_CHANGE

};

if(systray_iskdedockapp(w))

{

systray_request_handle(w, phys_screen, NULL);

return;

}

/* Send request to get NET_WM_ICON property as soon as possible... */

ewmh_icon_cookie = ewmh_window_icon_get_unchecked(w);

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

c = p_new(client_t, 1);

screen = c->screen = screen_getbycoord(phys_screen, wgeom->x, wgeom->y);

c->phys_screen = phys_screen;

/* Initial values */

c->win = w;

c->geometry.x = wgeom->x;

c->geometry.y = wgeom->y;

/* Border will be added later. */

c->geometry.width = wgeom->width;

c->geometry.height = wgeom->height;

/* Also set internal geometry (client_ban() needs it). */

c->geometries.internal.x = wgeom->x;

c->geometries.internal.y = wgeom->y;

c->geometries.internal.width = wgeom->width;

c->geometries.internal.height = wgeom->height;

client_setborder(c, wgeom->border_width);

if((icon = ewmh_window_icon_get_reply(ewmh_icon_cookie)))

c->icon = image_ref(&icon);

/* we honor size hints by default */

c->size_hints_honor = true;

/* 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);

/* Recursively find the parent. */

for(tc = c; tc->transient_for; tc = tc->transient_for);

if(tc != c && tc->phys_screen == c->phys_screen)

screen = tc->screen;

/* Try to load props */

client_loadprops(c, &globalconf.screens[screen]);

/* Then check clients hints */

ewmh_client_check_hints(c);

/* move client to screen, but do not tag it */

screen_client_moveto(c, screen, false, true);

/* Push client in client list */

client_list_push(&globalconf.clients, client_ref(&c));

/* Push client in stack */

client_raise(c);

/* update window title */

property_update_wm_name(c);

property_update_wm_icon_name(c);

/* 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 proces 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->win, XCB_WM_STATE_NORMAL);

/* Move window outside the viewport before mapping it. */

client_ban(c);

xcb_map_window(globalconf.connection, c->win);

/* Call hook to notify list change */

if(globalconf.hooks.clients != LUA_REFNIL)

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

/* call hook */

if(globalconf.hooks.manage != LUA_REFNIL)

{

luaA_client_userdata_new(globalconf.L, c);

lua_pushboolean(globalconf.L, startup);

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

}

}

/** 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;

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

if(c->size_hints.flags & XCB_SIZE_HINT_P_SIZE)

{

basew = c->size_hints.base_width;

baseh = c->size_hints.base_height;

}

else if(c->size_hints.flags & XCB_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_SIZE_HINT_P_MIN_SIZE)

{

minw = c->size_hints.min_width;

minh = c->size_hints.min_height;

}

else if(c->size_hints.flags & XCB_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_SIZE_HINT_P_ASPECT

&& c->size_hints.min_aspect_num > 0

&& c->size_hints.min_aspect_den > 0

&& geometry.height - baseh > 0

&& geometry.width - basew > 0)

{

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

double dy = (double) (geometry.height - 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.min_aspect_den;

double ratio = dx / dy;

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

{

if(ratio < min)

{

dy = (dx * min + dy) / (min * min + 1);

dx = dy * min;

geometry.width = (int) dx + basew;

geometry.height = (int) dy + baseh;

}

else if(ratio > max)

{

dy = (dx * min + dy) / (max * max + 1);

dx = dy * min;

geometry.width = (int) dx + basew;

geometry.height = (int) dy + baseh;

}

}

}

if(minw)

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

if(minh)

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

if(c->size_hints.flags & XCB_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_SIZE_HINT_P_RESIZE_INC | XCB_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 sizse 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)

{

int new_screen;

area_t geometry_internal;

area_t area;

/* offscreen appearance fixes */

area = display_area_get(c->phys_screen, NULL,

&globalconf.screens[c->screen].padding);

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. */

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

if(hints)

geometry_internal = client_geometry_hints(c, geometry_internal);

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

return false;

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

geometry = titlebar_geometry_add(c->titlebar, c->border, 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)

{

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);

/* The idea is to give a client a resize even when banned. */

/* We just have to move the (x,y) to keep it out of the viewport. */

/* This at least doesn't break expectations about events. */

if (c->isbanned)

{

geometry_internal.x = values[0] = - (geometry_internal.width + 2 * c->border);

geometry_internal.y = values[1] = - (geometry_internal.height + 2 * c->border);

}

xcb_configure_window(globalconf.connection, c->win,

XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y

| XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT,

values);

window_configure(c->win, geometry_internal, c->border);

screen_client_moveto(c, new_screen, true, false);

/* execute hook */

hooks_property(c, "geometry");

return true;

}

return false;

}

/** Set a client minimized, or not.

* \param c The client.

* \param s Set or not the client minimized.

*/

void

client_setminimized(client_t *c, bool s)

{

if(c->isminimized != s)

{

client_need_arrange(c);

c->isminimized = s;

client_need_arrange(c);

ewmh_client_update_hints(c);

/* execute hook */

hooks_property(c, "minimized");

}

}

/** Set a client sticky, or not.

* \param c The client.

* \param s Set or not the client sticky.

*/

void

client_setsticky(client_t *c, bool s)

{

if(c->issticky != s)

{

client_need_arrange(c);

c->issticky = s;

client_need_arrange(c);

ewmh_client_update_hints(c);

hooks_property(c, "sticky");

}

}

/** Set a client fullscreen, or not.

* \param c The client.

* \param s Set or not the client fullscreen.

*/

void

client_setfullscreen(client_t *c, bool s)

{

if(c->isfullscreen != s)

{

area_t geometry;

/* become fullscreen! */

if((c->isfullscreen = s))

{

/* remove any max state */

client_setmaxhoriz(c, false);

client_setmaxvert(c, false);

/* You can only be part of one of the special layers. */

client_setbelow(c, false);

client_setabove(c, false);

client_setontop(c, false);

geometry = screen_area_get(c->screen, NULL, NULL, false);

c->geometries.fullscreen = c->geometry;

c->border_fs = c->border;

client_setborder(c, 0);

}

else

{

geometry = c->geometries.fullscreen;

client_setborder(c, c->border_fs);

}

client_resize(c, geometry, false);

client_need_arrange(c);

client_stack();

xcb_change_property(globalconf.connection,

XCB_PROP_MODE_REPLACE,

c->win, _AWESOME_FULLSCREEN, CARDINAL, 8, 1,

&c->isfullscreen);

ewmh_client_update_hints(c);

hooks_property(c, "fullscreen");

}

}

/** Set a client horizontally maximized.

* \param c The client.

* \param s The maximized status.

*/

void

client_setmaxhoriz(client_t *c, bool s)

{

if(c->ismaxhoriz != s)

{

area_t geometry;

if((c->ismaxhoriz = s))

{

/* remove fullscreen mode */

client_setfullscreen(c, false);

geometry = screen_area_get(c->screen,

&globalconf.screens[c->screen].wiboxes,

&globalconf.screens[c->screen].padding,

true);

geometry.y = c->geometry.y;

geometry.height = c->geometry.height;

c->geometries.max.x = c->geometry.x;

c->geometries.max.width = c->geometry.width;

}

else

{

geometry = c->geometry;

geometry.x = c->geometries.max.x;

geometry.width = c->geometries.max.width;

}

client_resize(c, geometry, c->size_hints_honor);

client_need_arrange(c);

client_stack();

ewmh_client_update_hints(c);

hooks_property(c, "maximized_horizontal");

}

}

/** Set a client vertically maximized.

* \param c The client.

* \param s The maximized status.

*/

void

client_setmaxvert(client_t *c, bool s)

{

if(c->ismaxvert != s)

{

area_t geometry;

if((c->ismaxvert = s))

{

/* remove fullscreen mode */

client_setfullscreen(c, false);

geometry = screen_area_get(c->screen,

&globalconf.screens[c->screen].wiboxes,

&globalconf.screens[c->screen].padding,

true);

geometry.x = c->geometry.x;

geometry.width = c->geometry.width;

c->geometries.max.y = c->geometry.y;

c->geometries.max.height = c->geometry.height;

}

else

{

geometry = c->geometry;

geometry.y = c->geometries.max.y;

geometry.height = c->geometries.max.height;

}

client_resize(c, geometry, c->size_hints_honor);

client_need_arrange(c);