2007-04-27 21:58:48 +04:00
|
|
|
/*
|
|
|
|
* calmwm - the calm window manager
|
|
|
|
*
|
|
|
|
* Copyright (c) 2004 Marius Aamodt Eriksen <marius@monkey.org>
|
2008-01-11 19:06:44 +03:00
|
|
|
*
|
|
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
|
|
* copyright notice and this permission notice appear in all copies.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
|
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
2007-04-27 21:58:48 +04:00
|
|
|
*
|
2011-05-11 17:53:51 +04:00
|
|
|
* $OpenBSD$
|
2007-04-27 21:58:48 +04:00
|
|
|
*/
|
|
|
|
|
2009-12-15 07:10:42 +03:00
|
|
|
#include <sys/param.h>
|
2012-11-26 19:27:22 +04:00
|
|
|
#include "queue.h"
|
2009-12-15 07:10:42 +03:00
|
|
|
|
2009-12-15 06:34:34 +03:00
|
|
|
#include <assert.h>
|
2009-12-15 07:10:42 +03:00
|
|
|
#include <err.h>
|
|
|
|
#include <errno.h>
|
2012-11-09 07:52:02 +04:00
|
|
|
#include <stdio.h>
|
2009-12-15 07:10:42 +03:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <unistd.h>
|
2009-12-15 06:34:34 +03:00
|
|
|
|
2007-04-27 21:58:48 +04:00
|
|
|
#include "calmwm.h"
|
|
|
|
|
2009-06-26 16:21:58 +04:00
|
|
|
static struct client_ctx *client_mrunext(struct client_ctx *);
|
|
|
|
static struct client_ctx *client_mruprev(struct client_ctx *);
|
2012-12-17 18:58:46 +04:00
|
|
|
static void client_mtf(struct client_ctx *);
|
2009-12-08 01:21:59 +03:00
|
|
|
static void client_none(struct screen_ctx *);
|
2009-06-26 16:21:58 +04:00
|
|
|
static void client_placecalc(struct client_ctx *);
|
2013-05-19 21:02:04 +04:00
|
|
|
static void client_wm_protocols(struct client_ctx *);
|
2013-12-11 19:46:47 +04:00
|
|
|
static void client_mwm_hints(struct client_ctx *);
|
2009-06-26 16:21:58 +04:00
|
|
|
static int client_inbound(struct client_ctx *, int, int);
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2014-01-03 01:15:39 +04:00
|
|
|
struct client_ctx *curcc = NULL;
|
2007-04-27 21:58:48 +04:00
|
|
|
|
|
|
|
struct client_ctx *
|
|
|
|
client_find(Window win)
|
|
|
|
{
|
2008-07-11 18:21:28 +04:00
|
|
|
struct client_ctx *cc;
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2007-05-28 22:34:27 +04:00
|
|
|
TAILQ_FOREACH(cc, &Clientq, entry)
|
2009-01-16 18:24:14 +03:00
|
|
|
if (cc->win == win)
|
2007-04-27 21:58:48 +04:00
|
|
|
return (cc);
|
|
|
|
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
struct client_ctx *
|
2014-02-04 00:20:39 +04:00
|
|
|
client_init(Window win, struct screen_ctx *sc)
|
2007-04-27 21:58:48 +04:00
|
|
|
{
|
2008-07-11 18:21:28 +04:00
|
|
|
struct client_ctx *cc;
|
|
|
|
XWindowAttributes wattr;
|
2014-01-03 18:23:50 +04:00
|
|
|
long state;
|
2014-02-04 00:20:39 +04:00
|
|
|
int mapped;
|
2007-04-27 21:58:48 +04:00
|
|
|
|
|
|
|
if (win == None)
|
|
|
|
return (NULL);
|
2014-02-03 01:34:05 +04:00
|
|
|
if (!XGetWindowAttributes(X_Dpy, win, &wattr))
|
|
|
|
return (NULL);
|
2014-02-04 00:20:39 +04:00
|
|
|
|
|
|
|
if (sc == NULL) {
|
2014-02-03 01:34:05 +04:00
|
|
|
sc = screen_fromroot(wattr.root);
|
2014-02-04 00:20:39 +04:00
|
|
|
mapped = 1;
|
|
|
|
} else {
|
|
|
|
if (wattr.override_redirect || wattr.map_state != IsViewable)
|
|
|
|
return (NULL);
|
|
|
|
mapped = wattr.map_state != IsUnmapped;
|
|
|
|
}
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2009-06-20 04:22:39 +04:00
|
|
|
cc = xcalloc(1, sizeof(*cc));
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2007-05-28 22:34:27 +04:00
|
|
|
XGrabServer(X_Dpy);
|
2007-04-27 21:58:48 +04:00
|
|
|
|
|
|
|
cc->sc = sc;
|
|
|
|
cc->win = win;
|
2009-05-30 04:30:17 +04:00
|
|
|
|
|
|
|
TAILQ_INIT(&cc->nameq);
|
|
|
|
client_setname(cc);
|
|
|
|
|
|
|
|
conf_client(cc);
|
|
|
|
|
2013-12-11 18:09:21 +04:00
|
|
|
XGetClassHint(X_Dpy, cc->win, &cc->ch);
|
2013-12-11 19:41:11 +04:00
|
|
|
client_wm_hints(cc);
|
2013-12-11 18:09:21 +04:00
|
|
|
client_wm_protocols(cc);
|
|
|
|
client_getsizehints(cc);
|
2013-12-11 19:46:47 +04:00
|
|
|
client_mwm_hints(cc);
|
2013-04-04 00:22:55 +04:00
|
|
|
|
2007-04-27 21:58:48 +04:00
|
|
|
/* Saved pointer position */
|
|
|
|
cc->ptr.x = -1;
|
|
|
|
cc->ptr.y = -1;
|
|
|
|
|
|
|
|
cc->geom.x = wattr.x;
|
|
|
|
cc->geom.y = wattr.y;
|
2012-07-13 21:01:04 +04:00
|
|
|
cc->geom.w = wattr.width;
|
|
|
|
cc->geom.h = wattr.height;
|
2012-12-17 22:35:26 +04:00
|
|
|
cc->colormap = wattr.colormap;
|
2007-04-27 21:58:48 +04:00
|
|
|
|
|
|
|
if (wattr.map_state != IsViewable) {
|
|
|
|
client_placecalc(cc);
|
2013-04-17 17:52:20 +04:00
|
|
|
client_move(cc);
|
2013-12-11 18:16:09 +04:00
|
|
|
if ((cc->wmh) && (cc->wmh->flags & StateHint))
|
|
|
|
client_set_wm_state(cc, cc->wmh->initial_state);
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
2008-05-16 01:56:21 +04:00
|
|
|
XSelectInput(X_Dpy, cc->win, ColormapChangeMask | EnterWindowMask |
|
|
|
|
PropertyChangeMask | KeyReleaseMask);
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2013-12-13 19:56:44 +04:00
|
|
|
XAddToSaveSet(X_Dpy, cc->win);
|
|
|
|
|
2011-09-13 12:41:57 +04:00
|
|
|
client_transient(cc);
|
|
|
|
|
2007-04-27 21:58:48 +04:00
|
|
|
/* Notify client of its configuration. */
|
2013-06-11 01:37:30 +04:00
|
|
|
client_config(cc);
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2013-12-11 18:16:09 +04:00
|
|
|
if ((state = client_get_wm_state(cc)) < 0)
|
|
|
|
state = NormalState;
|
|
|
|
|
2009-06-20 04:55:41 +04:00
|
|
|
(state == IconicState) ? client_hide(cc) : client_unhide(cc);
|
2007-04-27 21:58:48 +04:00
|
|
|
|
|
|
|
TAILQ_INSERT_TAIL(&sc->mruq, cc, mru_entry);
|
2007-05-28 22:34:27 +04:00
|
|
|
TAILQ_INSERT_TAIL(&Clientq, cc, entry);
|
2012-07-03 17:49:03 +04:00
|
|
|
|
|
|
|
xu_ewmh_net_client_list(sc);
|
2013-05-21 01:13:58 +04:00
|
|
|
xu_ewmh_restore_net_wm_state(cc);
|
2008-04-16 00:24:41 +04:00
|
|
|
|
2008-05-16 01:56:21 +04:00
|
|
|
if (mapped)
|
2008-03-22 18:09:45 +03:00
|
|
|
group_autogroup(cc);
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2013-04-03 23:20:50 +04:00
|
|
|
XSync(X_Dpy, False);
|
|
|
|
XUngrabServer(X_Dpy);
|
|
|
|
|
2007-04-27 21:58:48 +04:00
|
|
|
return (cc);
|
|
|
|
}
|
|
|
|
|
2011-06-24 09:40:09 +04:00
|
|
|
void
|
2013-11-13 01:25:00 +04:00
|
|
|
client_delete(struct client_ctx *cc)
|
2007-04-27 21:58:48 +04:00
|
|
|
{
|
2009-08-27 05:38:08 +04:00
|
|
|
struct screen_ctx *sc = cc->sc;
|
2008-07-11 18:21:28 +04:00
|
|
|
struct winname *wn;
|
2007-04-27 21:58:48 +04:00
|
|
|
|
|
|
|
TAILQ_REMOVE(&sc->mruq, cc, mru_entry);
|
2007-05-28 22:34:27 +04:00
|
|
|
TAILQ_REMOVE(&Clientq, cc, entry);
|
2012-07-03 17:49:03 +04:00
|
|
|
|
|
|
|
xu_ewmh_net_client_list(sc);
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2013-05-06 20:03:11 +04:00
|
|
|
if (cc->group != NULL)
|
|
|
|
TAILQ_REMOVE(&cc->group->clients, cc, group_entry);
|
|
|
|
|
2012-12-17 18:26:29 +04:00
|
|
|
if (cc == client_current())
|
2009-12-08 01:21:59 +03:00
|
|
|
client_none(sc);
|
2007-04-27 21:58:48 +04:00
|
|
|
|
|
|
|
while ((wn = TAILQ_FIRST(&cc->nameq)) != NULL) {
|
|
|
|
TAILQ_REMOVE(&cc->nameq, wn, entry);
|
2013-01-01 18:26:29 +04:00
|
|
|
free(wn->name);
|
2012-11-08 00:34:39 +04:00
|
|
|
free(wn);
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
2013-12-11 18:09:21 +04:00
|
|
|
if (cc->ch.res_class)
|
|
|
|
XFree(cc->ch.res_class);
|
|
|
|
if (cc->ch.res_name)
|
|
|
|
XFree(cc->ch.res_name);
|
|
|
|
if (cc->wmh)
|
|
|
|
XFree(cc->wmh);
|
|
|
|
|
2012-11-08 00:34:39 +04:00
|
|
|
free(cc);
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2013-11-27 04:01:23 +04:00
|
|
|
client_setactive(struct client_ctx *cc)
|
2007-04-27 21:58:48 +04:00
|
|
|
{
|
2013-11-27 04:01:23 +04:00
|
|
|
struct screen_ctx *sc = cc->sc;
|
|
|
|
struct client_ctx *oldcc;
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2013-12-13 00:15:07 +04:00
|
|
|
if (cc->flags & CLIENT_HIDDEN)
|
|
|
|
return;
|
|
|
|
|
2013-11-27 04:01:23 +04:00
|
|
|
XInstallColormap(X_Dpy, cc->colormap);
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2013-11-27 04:01:23 +04:00
|
|
|
if ((cc->flags & CLIENT_INPUT) ||
|
|
|
|
((cc->flags & CLIENT_WM_TAKE_FOCUS) == 0)) {
|
|
|
|
XSetInputFocus(X_Dpy, cc->win,
|
|
|
|
RevertToPointerRoot, CurrentTime);
|
|
|
|
}
|
|
|
|
if (cc->flags & CLIENT_WM_TAKE_FOCUS)
|
2013-12-13 00:15:07 +04:00
|
|
|
client_msg(cc, cwmh[WM_TAKE_FOCUS], Last_Event_Time);
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2013-11-27 04:01:23 +04:00
|
|
|
if ((oldcc = client_current())) {
|
|
|
|
oldcc->active = 0;
|
|
|
|
client_draw_border(oldcc);
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
2013-11-27 04:01:23 +04:00
|
|
|
/* If we're in the middle of cycing, don't change the order. */
|
|
|
|
if (!sc->cycling)
|
|
|
|
client_mtf(cc);
|
|
|
|
|
2014-01-03 01:15:39 +04:00
|
|
|
curcc = cc;
|
2013-11-27 04:01:23 +04:00
|
|
|
cc->active = 1;
|
2013-12-13 19:56:44 +04:00
|
|
|
cc->flags &= ~CLIENT_URGENCY;
|
2007-04-27 21:58:48 +04:00
|
|
|
client_draw_border(cc);
|
2013-11-27 04:01:23 +04:00
|
|
|
conf_grab_mouse(cc->win);
|
|
|
|
xu_ewmh_net_active_window(sc, cc->win);
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
2009-12-08 01:21:59 +03:00
|
|
|
/*
|
|
|
|
* set when there is no active client
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
client_none(struct screen_ctx *sc)
|
|
|
|
{
|
|
|
|
Window none = None;
|
|
|
|
|
2012-07-03 17:49:03 +04:00
|
|
|
xu_ewmh_net_active_window(sc, none);
|
|
|
|
|
2014-01-03 01:15:39 +04:00
|
|
|
curcc = NULL;
|
2009-12-08 01:21:59 +03:00
|
|
|
}
|
|
|
|
|
2007-04-27 21:58:48 +04:00
|
|
|
struct client_ctx *
|
|
|
|
client_current(void)
|
|
|
|
{
|
2014-01-03 01:15:39 +04:00
|
|
|
return (curcc);
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
2011-05-07 21:15:37 +04:00
|
|
|
void
|
|
|
|
client_freeze(struct client_ctx *cc)
|
|
|
|
{
|
|
|
|
if (cc->flags & CLIENT_FREEZE)
|
|
|
|
cc->flags &= ~CLIENT_FREEZE;
|
|
|
|
else
|
|
|
|
cc->flags |= CLIENT_FREEZE;
|
|
|
|
}
|
|
|
|
|
2013-12-16 23:02:17 +04:00
|
|
|
void
|
|
|
|
client_fullscreen(struct client_ctx *cc)
|
|
|
|
{
|
|
|
|
struct screen_ctx *sc = cc->sc;
|
|
|
|
struct geom xine;
|
|
|
|
|
|
|
|
if ((cc->flags & CLIENT_FREEZE) &&
|
|
|
|
!(cc->flags & CLIENT_FULLSCREEN))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if ((cc->flags & CLIENT_FULLSCREEN)) {
|
|
|
|
cc->bwidth = Conf.bwidth;
|
|
|
|
cc->geom = cc->fullgeom;
|
|
|
|
cc->flags &= ~(CLIENT_FULLSCREEN | CLIENT_FREEZE);
|
|
|
|
goto resize;
|
|
|
|
}
|
|
|
|
|
|
|
|
cc->fullgeom = cc->geom;
|
|
|
|
|
|
|
|
xine = screen_find_xinerama(sc,
|
|
|
|
cc->geom.x + cc->geom.w / 2,
|
|
|
|
cc->geom.y + cc->geom.h / 2, CWM_NOGAP);
|
|
|
|
|
|
|
|
cc->bwidth = 0;
|
|
|
|
cc->geom = xine;
|
|
|
|
cc->flags |= (CLIENT_FULLSCREEN | CLIENT_FREEZE);
|
|
|
|
|
|
|
|
resize:
|
|
|
|
client_resize(cc, 0);
|
|
|
|
xu_ewmh_set_net_wm_state(cc);
|
|
|
|
}
|
|
|
|
|
2007-04-27 21:58:48 +04:00
|
|
|
void
|
|
|
|
client_maximize(struct client_ctx *cc)
|
|
|
|
{
|
2009-08-27 05:38:08 +04:00
|
|
|
struct screen_ctx *sc = cc->sc;
|
2013-01-02 20:26:34 +04:00
|
|
|
struct geom xine;
|
2008-07-16 02:06:48 +04:00
|
|
|
|
2011-05-07 21:15:37 +04:00
|
|
|
if (cc->flags & CLIENT_FREEZE)
|
|
|
|
return;
|
|
|
|
|
2011-09-04 20:59:31 +04:00
|
|
|
if ((cc->flags & CLIENT_MAXFLAGS) == CLIENT_MAXIMIZED) {
|
2007-04-27 21:58:48 +04:00
|
|
|
cc->geom = cc->savegeom;
|
2013-12-16 23:02:17 +04:00
|
|
|
cc->flags &= ~CLIENT_MAXIMIZED;
|
2011-09-04 20:59:31 +04:00
|
|
|
goto resize;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((cc->flags & CLIENT_VMAXIMIZED) == 0) {
|
2012-07-13 21:01:04 +04:00
|
|
|
cc->savegeom.h = cc->geom.h;
|
2011-09-04 20:59:31 +04:00
|
|
|
cc->savegeom.y = cc->geom.y;
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
2011-09-04 20:59:31 +04:00
|
|
|
if ((cc->flags & CLIENT_HMAXIMIZED) == 0) {
|
2012-07-13 21:01:04 +04:00
|
|
|
cc->savegeom.w = cc->geom.w;
|
2011-09-04 20:59:31 +04:00
|
|
|
cc->savegeom.x = cc->geom.x;
|
|
|
|
}
|
|
|
|
|
2012-07-16 05:36:30 +04:00
|
|
|
/*
|
|
|
|
* pick screen that the middle of the window is on.
|
|
|
|
* that's probably more fair than if just the origin of
|
|
|
|
* a window is poking over a boundary
|
|
|
|
*/
|
|
|
|
xine = screen_find_xinerama(sc,
|
|
|
|
cc->geom.x + cc->geom.w / 2,
|
2013-12-14 02:39:13 +04:00
|
|
|
cc->geom.y + cc->geom.h / 2, CWM_GAP);
|
2012-07-16 05:36:30 +04:00
|
|
|
|
2013-12-16 23:02:17 +04:00
|
|
|
cc->geom.x = xine.x;
|
|
|
|
cc->geom.y = xine.y;
|
|
|
|
cc->geom.w = xine.w - (cc->bwidth * 2);
|
|
|
|
cc->geom.h = xine.h - (cc->bwidth * 2);
|
2011-09-04 20:59:31 +04:00
|
|
|
cc->flags |= CLIENT_MAXIMIZED;
|
|
|
|
|
|
|
|
resize:
|
2012-09-09 23:47:47 +04:00
|
|
|
client_resize(cc, 0);
|
2013-05-21 01:13:58 +04:00
|
|
|
xu_ewmh_set_net_wm_state(cc);
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
2008-07-16 02:12:09 +04:00
|
|
|
void
|
2013-01-04 20:30:03 +04:00
|
|
|
client_vmaximize(struct client_ctx *cc)
|
2008-07-16 02:12:09 +04:00
|
|
|
{
|
2009-08-27 05:38:08 +04:00
|
|
|
struct screen_ctx *sc = cc->sc;
|
2013-01-02 20:26:34 +04:00
|
|
|
struct geom xine;
|
2008-07-16 02:12:09 +04:00
|
|
|
|
2011-05-07 21:15:37 +04:00
|
|
|
if (cc->flags & CLIENT_FREEZE)
|
|
|
|
return;
|
|
|
|
|
2008-07-16 02:12:09 +04:00
|
|
|
if (cc->flags & CLIENT_VMAXIMIZED) {
|
2011-06-24 10:01:47 +04:00
|
|
|
cc->geom.y = cc->savegeom.y;
|
2012-07-13 21:01:04 +04:00
|
|
|
cc->geom.h = cc->savegeom.h;
|
2011-06-24 10:01:47 +04:00
|
|
|
cc->flags &= ~CLIENT_VMAXIMIZED;
|
2011-09-04 20:59:31 +04:00
|
|
|
goto resize;
|
2008-07-16 02:12:09 +04:00
|
|
|
}
|
|
|
|
|
2011-09-04 20:59:31 +04:00
|
|
|
cc->savegeom.y = cc->geom.y;
|
2012-07-13 21:01:04 +04:00
|
|
|
cc->savegeom.h = cc->geom.h;
|
2011-09-04 20:59:31 +04:00
|
|
|
|
2012-07-16 05:36:30 +04:00
|
|
|
xine = screen_find_xinerama(sc,
|
|
|
|
cc->geom.x + cc->geom.w / 2,
|
2013-12-14 02:39:13 +04:00
|
|
|
cc->geom.y + cc->geom.h / 2, CWM_GAP);
|
2012-07-16 05:36:30 +04:00
|
|
|
|
2013-01-08 08:12:51 +04:00
|
|
|
cc->geom.y = xine.y;
|
|
|
|
cc->geom.h = xine.h - (cc->bwidth * 2);
|
2011-09-04 20:59:31 +04:00
|
|
|
cc->flags |= CLIENT_VMAXIMIZED;
|
|
|
|
|
|
|
|
resize:
|
2012-09-09 23:47:47 +04:00
|
|
|
client_resize(cc, 0);
|
2013-05-21 01:13:58 +04:00
|
|
|
xu_ewmh_set_net_wm_state(cc);
|
2008-07-16 02:12:09 +04:00
|
|
|
}
|
|
|
|
|
2009-08-25 03:54:41 +04:00
|
|
|
void
|
2013-01-04 20:30:03 +04:00
|
|
|
client_hmaximize(struct client_ctx *cc)
|
2009-08-25 03:54:41 +04:00
|
|
|
{
|
2009-08-27 05:38:08 +04:00
|
|
|
struct screen_ctx *sc = cc->sc;
|
2013-01-02 20:26:34 +04:00
|
|
|
struct geom xine;
|
2009-08-25 03:54:41 +04:00
|
|
|
|
2011-05-07 21:15:37 +04:00
|
|
|
if (cc->flags & CLIENT_FREEZE)
|
|
|
|
return;
|
|
|
|
|
2009-08-25 03:54:41 +04:00
|
|
|
if (cc->flags & CLIENT_HMAXIMIZED) {
|
2011-06-24 10:01:47 +04:00
|
|
|
cc->geom.x = cc->savegeom.x;
|
2012-07-13 21:01:04 +04:00
|
|
|
cc->geom.w = cc->savegeom.w;
|
2011-06-24 10:01:47 +04:00
|
|
|
cc->flags &= ~CLIENT_HMAXIMIZED;
|
2011-09-04 20:59:31 +04:00
|
|
|
goto resize;
|
2012-05-13 19:15:54 +04:00
|
|
|
}
|
2011-09-04 20:59:31 +04:00
|
|
|
|
|
|
|
cc->savegeom.x = cc->geom.x;
|
2012-07-13 21:01:04 +04:00
|
|
|
cc->savegeom.w = cc->geom.w;
|
2011-09-04 20:59:31 +04:00
|
|
|
|
2012-07-16 05:36:30 +04:00
|
|
|
xine = screen_find_xinerama(sc,
|
|
|
|
cc->geom.x + cc->geom.w / 2,
|
2013-12-14 02:39:13 +04:00
|
|
|
cc->geom.y + cc->geom.h / 2, CWM_GAP);
|
2012-07-16 05:36:30 +04:00
|
|
|
|
2013-01-08 08:12:51 +04:00
|
|
|
cc->geom.x = xine.x;
|
|
|
|
cc->geom.w = xine.w - (cc->bwidth * 2);
|
2011-09-04 20:59:31 +04:00
|
|
|
cc->flags |= CLIENT_HMAXIMIZED;
|
|
|
|
|
|
|
|
resize:
|
2012-09-09 23:47:47 +04:00
|
|
|
client_resize(cc, 0);
|
2013-05-21 01:13:58 +04:00
|
|
|
xu_ewmh_set_net_wm_state(cc);
|
2009-08-25 03:54:41 +04:00
|
|
|
}
|
|
|
|
|
2007-04-27 21:58:48 +04:00
|
|
|
void
|
2012-09-09 23:47:47 +04:00
|
|
|
client_resize(struct client_ctx *cc, int reset)
|
2007-04-27 21:58:48 +04:00
|
|
|
{
|
2012-09-09 23:47:47 +04:00
|
|
|
if (reset) {
|
|
|
|
cc->flags &= ~CLIENT_MAXIMIZED;
|
2013-05-21 01:13:58 +04:00
|
|
|
xu_ewmh_set_net_wm_state(cc);
|
2012-09-09 23:47:47 +04:00
|
|
|
}
|
|
|
|
|
2013-11-11 16:51:15 +04:00
|
|
|
client_draw_border(cc);
|
|
|
|
|
2009-01-22 22:01:56 +03:00
|
|
|
XMoveResizeWindow(X_Dpy, cc->win, cc->geom.x,
|
2012-07-13 21:01:04 +04:00
|
|
|
cc->geom.y, cc->geom.w, cc->geom.h);
|
2013-06-11 01:37:30 +04:00
|
|
|
client_config(cc);
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
client_move(struct client_ctx *cc)
|
|
|
|
{
|
2009-01-22 22:01:56 +03:00
|
|
|
XMoveWindow(X_Dpy, cc->win, cc->geom.x, cc->geom.y);
|
2013-06-11 01:37:30 +04:00
|
|
|
client_config(cc);
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
client_lower(struct client_ctx *cc)
|
|
|
|
{
|
2009-01-16 18:24:14 +03:00
|
|
|
XLowerWindow(X_Dpy, cc->win);
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
client_raise(struct client_ctx *cc)
|
|
|
|
{
|
2009-01-16 18:24:14 +03:00
|
|
|
XRaiseWindow(X_Dpy, cc->win);
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
2013-06-11 01:37:30 +04:00
|
|
|
void
|
|
|
|
client_config(struct client_ctx *cc)
|
|
|
|
{
|
|
|
|
XConfigureEvent cn;
|
|
|
|
|
2013-12-17 20:10:43 +04:00
|
|
|
(void)memset(&cn, 0, sizeof(cn));
|
2013-06-11 01:37:30 +04:00
|
|
|
cn.type = ConfigureNotify;
|
|
|
|
cn.event = cc->win;
|
|
|
|
cn.window = cc->win;
|
|
|
|
cn.x = cc->geom.x;
|
|
|
|
cn.y = cc->geom.y;
|
|
|
|
cn.width = cc->geom.w;
|
|
|
|
cn.height = cc->geom.h;
|
|
|
|
cn.border_width = cc->bwidth;
|
|
|
|
cn.above = None;
|
|
|
|
cn.override_redirect = 0;
|
|
|
|
|
|
|
|
XSendEvent(X_Dpy, cc->win, False, StructureNotifyMask, (XEvent *)&cn);
|
|
|
|
}
|
|
|
|
|
2007-04-27 21:58:48 +04:00
|
|
|
void
|
|
|
|
client_ptrwarp(struct client_ctx *cc)
|
|
|
|
{
|
2008-07-11 18:21:28 +04:00
|
|
|
int x = cc->ptr.x, y = cc->ptr.y;
|
2007-04-27 21:58:48 +04:00
|
|
|
|
|
|
|
if (x == -1 || y == -1) {
|
2012-07-13 21:01:04 +04:00
|
|
|
x = cc->geom.w / 2;
|
|
|
|
y = cc->geom.h / 2;
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
2013-12-11 18:16:09 +04:00
|
|
|
if (cc->flags & CLIENT_HIDDEN)
|
|
|
|
client_unhide(cc);
|
|
|
|
else
|
|
|
|
client_raise(cc);
|
2009-01-16 18:24:14 +03:00
|
|
|
xu_ptr_setpos(cc->win, x, y);
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
client_ptrsave(struct client_ctx *cc)
|
|
|
|
{
|
2008-07-11 18:21:28 +04:00
|
|
|
int x, y;
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2009-01-16 18:24:14 +03:00
|
|
|
xu_ptr_getpos(cc->win, &x, &y);
|
2009-05-18 04:23:35 +04:00
|
|
|
if (client_inbound(cc, x, y)) {
|
2007-04-27 21:58:48 +04:00
|
|
|
cc->ptr.x = x;
|
|
|
|
cc->ptr.y = y;
|
2011-02-13 23:09:57 +03:00
|
|
|
} else {
|
|
|
|
cc->ptr.x = -1;
|
|
|
|
cc->ptr.y = -1;
|
2008-04-16 00:24:41 +04:00
|
|
|
}
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
client_hide(struct client_ctx *cc)
|
|
|
|
{
|
2009-01-16 18:24:14 +03:00
|
|
|
XUnmapWindow(X_Dpy, cc->win);
|
2007-04-27 21:58:48 +04:00
|
|
|
|
|
|
|
cc->active = 0;
|
|
|
|
cc->flags |= CLIENT_HIDDEN;
|
2013-12-11 18:16:09 +04:00
|
|
|
client_set_wm_state(cc, IconicState);
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2012-12-17 18:26:29 +04:00
|
|
|
if (cc == client_current())
|
2009-12-08 01:21:59 +03:00
|
|
|
client_none(cc->sc);
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
client_unhide(struct client_ctx *cc)
|
|
|
|
{
|
2009-01-16 18:24:14 +03:00
|
|
|
XMapRaised(X_Dpy, cc->win);
|
2007-04-27 21:58:48 +04:00
|
|
|
|
|
|
|
cc->flags &= ~CLIENT_HIDDEN;
|
2013-12-11 18:16:09 +04:00
|
|
|
client_set_wm_state(cc, NormalState);
|
2013-12-11 01:27:37 +04:00
|
|
|
client_draw_border(cc);
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
2013-12-13 19:56:44 +04:00
|
|
|
void
|
|
|
|
client_urgency(struct client_ctx *cc)
|
|
|
|
{
|
|
|
|
cc->flags |= CLIENT_URGENCY;
|
|
|
|
}
|
|
|
|
|
2007-04-27 21:58:48 +04:00
|
|
|
void
|
|
|
|
client_draw_border(struct client_ctx *cc)
|
|
|
|
{
|
2009-08-27 05:38:08 +04:00
|
|
|
struct screen_ctx *sc = cc->sc;
|
2009-05-18 03:40:57 +04:00
|
|
|
unsigned long pixel;
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2009-01-16 18:24:14 +03:00
|
|
|
if (cc->active)
|
2012-12-17 21:48:57 +04:00
|
|
|
switch (cc->flags & CLIENT_HIGHLIGHT) {
|
|
|
|
case CLIENT_GROUP:
|
2013-05-20 03:09:59 +04:00
|
|
|
pixel = sc->xftcolor[CWM_COLOR_BORDER_GROUP].pixel;
|
2009-01-16 18:24:14 +03:00
|
|
|
break;
|
2012-12-17 21:48:57 +04:00
|
|
|
case CLIENT_UNGROUP:
|
2013-05-20 03:09:59 +04:00
|
|
|
pixel = sc->xftcolor[CWM_COLOR_BORDER_UNGROUP].pixel;
|
2009-01-16 18:24:14 +03:00
|
|
|
break;
|
|
|
|
default:
|
2013-05-20 03:09:59 +04:00
|
|
|
pixel = sc->xftcolor[CWM_COLOR_BORDER_ACTIVE].pixel;
|
2009-01-16 18:24:14 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
else
|
2013-05-20 03:09:59 +04:00
|
|
|
pixel = sc->xftcolor[CWM_COLOR_BORDER_INACTIVE].pixel;
|
2009-01-22 22:01:56 +03:00
|
|
|
|
2013-12-13 19:56:44 +04:00
|
|
|
if (cc->flags & CLIENT_URGENCY)
|
|
|
|
pixel = sc->xftcolor[CWM_COLOR_BORDER_URGENCY].pixel;
|
|
|
|
|
2009-01-16 18:24:14 +03:00
|
|
|
XSetWindowBorderWidth(X_Dpy, cc->win, cc->bwidth);
|
2009-05-18 03:40:57 +04:00
|
|
|
XSetWindowBorder(X_Dpy, cc->win, pixel);
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
2009-06-26 16:21:58 +04:00
|
|
|
static void
|
2013-05-19 21:02:04 +04:00
|
|
|
client_wm_protocols(struct client_ctx *cc)
|
2007-04-27 21:58:48 +04:00
|
|
|
{
|
2009-11-28 20:52:12 +03:00
|
|
|
Atom *p;
|
2013-05-19 21:02:04 +04:00
|
|
|
int i, j;
|
|
|
|
|
|
|
|
if (XGetWMProtocols(X_Dpy, cc->win, &p, &j)) {
|
|
|
|
for (i = 0; i < j; i++) {
|
2013-07-15 18:50:44 +04:00
|
|
|
if (p[i] == cwmh[WM_DELETE_WINDOW])
|
2013-11-08 21:35:12 +04:00
|
|
|
cc->flags |= CLIENT_WM_DELETE_WINDOW;
|
2013-07-15 18:50:44 +04:00
|
|
|
else if (p[i] == cwmh[WM_TAKE_FOCUS])
|
2013-11-08 21:35:12 +04:00
|
|
|
cc->flags |= CLIENT_WM_TAKE_FOCUS;
|
2013-05-19 21:02:04 +04:00
|
|
|
}
|
|
|
|
XFree(p);
|
|
|
|
}
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
2013-12-11 19:41:11 +04:00
|
|
|
void
|
|
|
|
client_wm_hints(struct client_ctx *cc)
|
|
|
|
{
|
|
|
|
if ((cc->wmh = XGetWMHints(X_Dpy, cc->win)) == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if ((cc->wmh->flags & InputHint) && (cc->wmh->input))
|
|
|
|
cc->flags |= CLIENT_INPUT;
|
2013-12-13 19:56:44 +04:00
|
|
|
|
|
|
|
if ((cc->wmh->flags & XUrgencyHint))
|
|
|
|
client_urgency(cc);
|
2013-12-11 19:41:11 +04:00
|
|
|
}
|
|
|
|
|
2013-06-11 01:37:30 +04:00
|
|
|
void
|
2013-12-13 00:15:07 +04:00
|
|
|
client_msg(struct client_ctx *cc, Atom proto, Time ts)
|
2013-06-11 01:37:30 +04:00
|
|
|
{
|
|
|
|
XClientMessageEvent cm;
|
|
|
|
|
2013-12-17 20:10:43 +04:00
|
|
|
(void)memset(&cm, 0, sizeof(cm));
|
2013-06-11 01:37:30 +04:00
|
|
|
cm.type = ClientMessage;
|
|
|
|
cm.window = cc->win;
|
2013-07-15 18:50:44 +04:00
|
|
|
cm.message_type = cwmh[WM_PROTOCOLS];
|
2013-06-11 01:37:30 +04:00
|
|
|
cm.format = 32;
|
|
|
|
cm.data.l[0] = proto;
|
2013-12-13 00:15:07 +04:00
|
|
|
cm.data.l[1] = ts;
|
2013-06-11 01:37:30 +04:00
|
|
|
|
|
|
|
XSendEvent(X_Dpy, cc->win, False, NoEventMask, (XEvent *)&cm);
|
|
|
|
}
|
|
|
|
|
2007-04-27 21:58:48 +04:00
|
|
|
void
|
|
|
|
client_send_delete(struct client_ctx *cc)
|
|
|
|
{
|
2013-11-08 21:35:12 +04:00
|
|
|
if (cc->flags & CLIENT_WM_DELETE_WINDOW)
|
2013-12-13 00:15:07 +04:00
|
|
|
client_msg(cc, cwmh[WM_DELETE_WINDOW], CurrentTime);
|
2007-04-27 21:58:48 +04:00
|
|
|
else
|
2007-05-28 22:34:27 +04:00
|
|
|
XKillClient(X_Dpy, cc->win);
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
client_setname(struct client_ctx *cc)
|
|
|
|
{
|
2008-07-11 18:21:28 +04:00
|
|
|
struct winname *wn;
|
|
|
|
char *newname;
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2013-07-15 18:50:44 +04:00
|
|
|
if (!xu_getstrprop(cc->win, ewmh[_NET_WM_NAME], &newname))
|
2011-06-24 09:40:09 +04:00
|
|
|
if (!xu_getstrprop(cc->win, XA_WM_NAME, &newname))
|
2013-01-01 18:26:29 +04:00
|
|
|
newname = xstrdup("");
|
2007-04-27 21:58:48 +04:00
|
|
|
|
|
|
|
TAILQ_FOREACH(wn, &cc->nameq, entry)
|
|
|
|
if (strcmp(wn->name, newname) == 0) {
|
|
|
|
/* Move to the last since we got a hit. */
|
|
|
|
TAILQ_REMOVE(&cc->nameq, wn, entry);
|
|
|
|
TAILQ_INSERT_TAIL(&cc->nameq, wn, entry);
|
|
|
|
goto match;
|
|
|
|
}
|
|
|
|
|
2009-06-20 04:22:39 +04:00
|
|
|
wn = xmalloc(sizeof(*wn));
|
2007-04-27 21:58:48 +04:00
|
|
|
wn->name = newname;
|
|
|
|
TAILQ_INSERT_TAIL(&cc->nameq, wn, entry);
|
|
|
|
cc->nameqlen++;
|
|
|
|
|
|
|
|
match:
|
|
|
|
cc->name = wn->name;
|
|
|
|
|
|
|
|
/* Now, do some garbage collection. */
|
|
|
|
if (cc->nameqlen > CLIENT_MAXNAMEQLEN) {
|
|
|
|
wn = TAILQ_FIRST(&cc->nameq);
|
|
|
|
assert(wn != NULL);
|
|
|
|
TAILQ_REMOVE(&cc->nameq, wn, entry);
|
2013-01-01 18:26:29 +04:00
|
|
|
free(wn->name);
|
2012-11-08 00:34:39 +04:00
|
|
|
free(wn);
|
2007-04-27 21:58:48 +04:00
|
|
|
cc->nameqlen--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-24 09:40:09 +04:00
|
|
|
void
|
2011-09-03 13:20:58 +04:00
|
|
|
client_cycle(struct screen_ctx *sc, int flags)
|
2007-04-27 21:58:48 +04:00
|
|
|
{
|
2008-07-11 18:21:28 +04:00
|
|
|
struct client_ctx *oldcc, *newcc;
|
2008-05-01 22:01:13 +04:00
|
|
|
int again = 1;
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2008-07-11 18:21:28 +04:00
|
|
|
oldcc = client_current();
|
|
|
|
|
2008-05-01 22:01:13 +04:00
|
|
|
/* If no windows then you cant cycle */
|
|
|
|
if (TAILQ_EMPTY(&sc->mruq))
|
2011-06-24 09:40:09 +04:00
|
|
|
return;
|
2007-06-05 23:03:20 +04:00
|
|
|
|
2008-05-01 22:01:13 +04:00
|
|
|
if (oldcc == NULL)
|
2013-04-05 21:07:25 +04:00
|
|
|
oldcc = (flags & CWM_RCYCLE ?
|
2012-05-13 19:15:54 +04:00
|
|
|
TAILQ_LAST(&sc->mruq, cycle_entry_q) :
|
2008-05-01 22:01:13 +04:00
|
|
|
TAILQ_FIRST(&sc->mruq));
|
2007-06-05 23:03:20 +04:00
|
|
|
|
2008-05-01 22:01:13 +04:00
|
|
|
newcc = oldcc;
|
|
|
|
while (again) {
|
|
|
|
again = 0;
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2011-09-03 13:20:58 +04:00
|
|
|
newcc = (flags & CWM_RCYCLE ? client_mruprev(newcc) :
|
2008-05-01 22:01:13 +04:00
|
|
|
client_mrunext(newcc));
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2008-06-30 21:52:37 +04:00
|
|
|
/* Only cycle visible and non-ignored windows. */
|
2011-09-03 13:20:58 +04:00
|
|
|
if ((newcc->flags & (CLIENT_HIDDEN|CLIENT_IGNORE))
|
|
|
|
|| ((flags & CWM_INGROUP) && (newcc->group != oldcc->group)))
|
2008-05-01 22:01:13 +04:00
|
|
|
again = 1;
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2008-05-01 22:01:13 +04:00
|
|
|
/* Is oldcc the only non-hidden window? */
|
|
|
|
if (newcc == oldcc) {
|
|
|
|
if (again)
|
2011-06-24 09:40:09 +04:00
|
|
|
return; /* No windows visible. */
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2008-05-19 19:17:50 +04:00
|
|
|
break;
|
2008-05-01 22:01:13 +04:00
|
|
|
}
|
|
|
|
}
|
2008-05-19 19:17:50 +04:00
|
|
|
|
2012-05-13 19:17:13 +04:00
|
|
|
/* reset when cycling mod is released. XXX I hate this hack */
|
|
|
|
sc->cycling = 1;
|
2008-05-01 22:01:13 +04:00
|
|
|
client_ptrsave(oldcc);
|
|
|
|
client_ptrwarp(newcc);
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
|
2012-05-16 05:09:17 +04:00
|
|
|
void
|
2013-11-27 04:01:23 +04:00
|
|
|
client_cycle_leave(struct screen_ctx *sc)
|
2012-05-16 05:09:17 +04:00
|
|
|
{
|
2013-11-27 04:01:23 +04:00
|
|
|
struct client_ctx *cc;
|
|
|
|
|
2012-05-16 05:09:17 +04:00
|
|
|
sc->cycling = 0;
|
|
|
|
|
2013-11-27 04:01:23 +04:00
|
|
|
if ((cc = client_current())) {
|
|
|
|
client_mtf(cc);
|
2012-05-16 05:09:17 +04:00
|
|
|
group_sticky_toggle_exit(cc);
|
|
|
|
XUngrabKeyboard(X_Dpy, CurrentTime);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-26 16:21:58 +04:00
|
|
|
static struct client_ctx *
|
2007-04-27 21:58:48 +04:00
|
|
|
client_mrunext(struct client_ctx *cc)
|
|
|
|
{
|
2009-08-27 05:38:08 +04:00
|
|
|
struct screen_ctx *sc = cc->sc;
|
2008-07-11 18:21:28 +04:00
|
|
|
struct client_ctx *ccc;
|
2007-04-27 21:58:48 +04:00
|
|
|
|
|
|
|
return ((ccc = TAILQ_NEXT(cc, mru_entry)) != NULL ?
|
|
|
|
ccc : TAILQ_FIRST(&sc->mruq));
|
|
|
|
}
|
|
|
|
|
2009-06-26 16:21:58 +04:00
|
|
|
static struct client_ctx *
|
2007-04-27 21:58:48 +04:00
|
|
|
client_mruprev(struct client_ctx *cc)
|
|
|
|
{
|
2009-08-27 05:38:08 +04:00
|
|
|
struct screen_ctx *sc = cc->sc;
|
2008-07-11 18:21:28 +04:00
|
|
|
struct client_ctx *ccc;
|
2007-04-27 21:58:48 +04:00
|
|
|
|
|
|
|
return ((ccc = TAILQ_PREV(cc, cycle_entry_q, mru_entry)) != NULL ?
|
|
|
|
ccc : TAILQ_LAST(&sc->mruq, cycle_entry_q));
|
|
|
|
}
|
|
|
|
|
2009-06-26 16:21:58 +04:00
|
|
|
static void
|
2007-04-27 21:58:48 +04:00
|
|
|
client_placecalc(struct client_ctx *cc)
|
|
|
|
{
|
2009-08-27 05:38:08 +04:00
|
|
|
struct screen_ctx *sc = cc->sc;
|
2009-01-22 22:01:56 +03:00
|
|
|
int xslack, yslack;
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2013-11-02 23:13:56 +04:00
|
|
|
if (cc->hint.flags & (USPosition|PPosition)) {
|
2008-09-30 03:16:46 +04:00
|
|
|
/*
|
|
|
|
* Ignore XINERAMA screens, just make sure it's somewhere
|
|
|
|
* in the virtual desktop. else it stops people putting xterms
|
|
|
|
* at startup in the screen the mouse doesn't start in *sigh*.
|
|
|
|
* XRandR bits mean that {x,y}max shouldn't be outside what's
|
|
|
|
* currently there.
|
|
|
|
*/
|
2012-07-13 21:01:04 +04:00
|
|
|
xslack = sc->view.w - cc->geom.w - cc->bwidth * 2;
|
|
|
|
yslack = sc->view.h - cc->geom.h - cc->bwidth * 2;
|
2013-11-02 01:54:20 +04:00
|
|
|
cc->geom.x = MIN(cc->geom.x, xslack);
|
|
|
|
cc->geom.y = MIN(cc->geom.y, yslack);
|
2007-04-27 21:58:48 +04:00
|
|
|
} else {
|
2013-01-02 20:26:34 +04:00
|
|
|
struct geom xine;
|
2013-01-02 06:19:20 +04:00
|
|
|
int xmouse, ymouse;
|
2008-09-30 03:16:46 +04:00
|
|
|
|
|
|
|
xu_ptr_getpos(sc->rootwin, &xmouse, &ymouse);
|
2013-12-14 02:39:13 +04:00
|
|
|
xine = screen_find_xinerama(sc, xmouse, ymouse, CWM_GAP);
|
2013-01-08 01:53:23 +04:00
|
|
|
xine.w += xine.x;
|
|
|
|
xine.h += xine.y;
|
2013-01-02 20:26:34 +04:00
|
|
|
xmouse = MAX(xmouse, xine.x) - cc->geom.w / 2;
|
|
|
|
ymouse = MAX(ymouse, xine.y) - cc->geom.h / 2;
|
2009-01-22 22:01:56 +03:00
|
|
|
|
2013-01-02 20:26:34 +04:00
|
|
|
xmouse = MAX(xmouse, xine.x);
|
|
|
|
ymouse = MAX(ymouse, xine.y);
|
2008-09-30 03:16:46 +04:00
|
|
|
|
2013-01-02 20:26:34 +04:00
|
|
|
xslack = xine.w - cc->geom.w - cc->bwidth * 2;
|
|
|
|
yslack = xine.h - cc->geom.h - cc->bwidth * 2;
|
2008-09-30 03:16:46 +04:00
|
|
|
|
2013-01-02 20:26:34 +04:00
|
|
|
if (xslack >= xine.x) {
|
2013-01-08 08:12:51 +04:00
|
|
|
cc->geom.x = MAX(MIN(xmouse, xslack), xine.x);
|
2007-04-27 21:58:48 +04:00
|
|
|
} else {
|
2013-01-08 08:12:51 +04:00
|
|
|
cc->geom.x = xine.x;
|
|
|
|
cc->geom.w = xine.w;
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
2013-01-02 20:26:34 +04:00
|
|
|
if (yslack >= xine.y) {
|
2013-01-08 08:12:51 +04:00
|
|
|
cc->geom.y = MAX(MIN(ymouse, yslack), xine.y);
|
2007-04-27 21:58:48 +04:00
|
|
|
} else {
|
2013-01-08 08:12:51 +04:00
|
|
|
cc->geom.y = xine.y;
|
|
|
|
cc->geom.h = xine.h;
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-12-17 18:58:46 +04:00
|
|
|
static void
|
2007-04-27 21:58:48 +04:00
|
|
|
client_mtf(struct client_ctx *cc)
|
|
|
|
{
|
2013-11-27 04:01:23 +04:00
|
|
|
struct screen_ctx *sc = cc->sc;
|
2007-04-27 21:58:48 +04:00
|
|
|
|
|
|
|
TAILQ_REMOVE(&sc->mruq, cc, mru_entry);
|
|
|
|
TAILQ_INSERT_HEAD(&sc->mruq, cc, mru_entry);
|
|
|
|
}
|
|
|
|
|
2009-08-25 03:49:04 +04:00
|
|
|
void
|
|
|
|
client_getsizehints(struct client_ctx *cc)
|
|
|
|
{
|
|
|
|
long tmp;
|
2013-11-27 21:04:35 +04:00
|
|
|
XSizeHints size;
|
2009-08-25 03:49:04 +04:00
|
|
|
|
2013-11-27 21:04:35 +04:00
|
|
|
if (!XGetWMNormalHints(X_Dpy, cc->win, &size, &tmp))
|
|
|
|
size.flags = 0;
|
2009-08-25 03:49:04 +04:00
|
|
|
|
2013-11-27 21:04:35 +04:00
|
|
|
cc->hint.flags = size.flags;
|
2013-11-02 23:13:56 +04:00
|
|
|
|
2013-11-27 21:04:35 +04:00
|
|
|
if (size.flags & PBaseSize) {
|
|
|
|
cc->hint.basew = size.base_width;
|
|
|
|
cc->hint.baseh = size.base_height;
|
|
|
|
} else if (size.flags & PMinSize) {
|
|
|
|
cc->hint.basew = size.min_width;
|
|
|
|
cc->hint.baseh = size.min_height;
|
2009-08-25 03:49:04 +04:00
|
|
|
}
|
2013-11-27 21:04:35 +04:00
|
|
|
if (size.flags & PMinSize) {
|
|
|
|
cc->hint.minw = size.min_width;
|
|
|
|
cc->hint.minh = size.min_height;
|
|
|
|
} else if (size.flags & PBaseSize) {
|
|
|
|
cc->hint.minw = size.base_width;
|
|
|
|
cc->hint.minh = size.base_height;
|
2009-08-25 03:49:04 +04:00
|
|
|
}
|
2013-11-27 21:04:35 +04:00
|
|
|
if (size.flags & PMaxSize) {
|
|
|
|
cc->hint.maxw = size.max_width;
|
|
|
|
cc->hint.maxh = size.max_height;
|
2009-08-25 03:49:04 +04:00
|
|
|
}
|
2013-11-27 21:04:35 +04:00
|
|
|
if (size.flags & PResizeInc) {
|
|
|
|
cc->hint.incw = size.width_inc;
|
|
|
|
cc->hint.inch = size.height_inc;
|
2009-08-25 03:49:04 +04:00
|
|
|
}
|
2011-09-03 13:42:33 +04:00
|
|
|
cc->hint.incw = MAX(1, cc->hint.incw);
|
|
|
|
cc->hint.inch = MAX(1, cc->hint.inch);
|
2009-08-25 05:32:40 +04:00
|
|
|
|
2013-11-27 21:04:35 +04:00
|
|
|
if (size.flags & PAspect) {
|
|
|
|
if (size.min_aspect.x > 0)
|
|
|
|
cc->hint.mina = (float)size.min_aspect.y /
|
|
|
|
size.min_aspect.x;
|
|
|
|
if (size.max_aspect.y > 0)
|
|
|
|
cc->hint.maxa = (float)size.max_aspect.x /
|
|
|
|
size.max_aspect.y;
|
2009-08-25 03:49:04 +04:00
|
|
|
}
|
|
|
|
}
|
2012-05-13 19:15:54 +04:00
|
|
|
|
2009-08-25 03:49:04 +04:00
|
|
|
void
|
|
|
|
client_applysizehints(struct client_ctx *cc)
|
|
|
|
{
|
|
|
|
Bool baseismin;
|
|
|
|
|
2011-09-03 13:42:33 +04:00
|
|
|
baseismin = (cc->hint.basew == cc->hint.minw) &&
|
|
|
|
(cc->hint.baseh == cc->hint.minh);
|
2009-08-25 03:49:04 +04:00
|
|
|
|
|
|
|
/* temporarily remove base dimensions, ICCCM 4.1.2.3 */
|
|
|
|
if (!baseismin) {
|
2012-07-13 21:01:04 +04:00
|
|
|
cc->geom.w -= cc->hint.basew;
|
|
|
|
cc->geom.h -= cc->hint.baseh;
|
2009-08-25 03:49:04 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* adjust for aspect limits */
|
2013-11-27 18:20:32 +04:00
|
|
|
if (cc->hint.mina && cc->hint.maxa) {
|
|
|
|
if (cc->hint.maxa < (float)cc->geom.w / cc->geom.h)
|
2012-07-13 21:01:04 +04:00
|
|
|
cc->geom.w = cc->geom.h * cc->hint.maxa;
|
2013-11-27 18:20:32 +04:00
|
|
|
else if (cc->hint.mina < (float)cc->geom.h / cc->geom.w)
|
2012-07-13 21:01:04 +04:00
|
|
|
cc->geom.h = cc->geom.w * cc->hint.mina;
|
2009-08-25 03:49:04 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* remove base dimensions for increment */
|
|
|
|
if (baseismin) {
|
2012-07-13 21:01:04 +04:00
|
|
|
cc->geom.w -= cc->hint.basew;
|
|
|
|
cc->geom.h -= cc->hint.baseh;
|
2009-08-25 03:49:04 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* adjust for increment value */
|
2012-07-13 21:01:04 +04:00
|
|
|
cc->geom.w -= cc->geom.w % cc->hint.incw;
|
|
|
|
cc->geom.h -= cc->geom.h % cc->hint.inch;
|
2009-08-25 03:49:04 +04:00
|
|
|
|
|
|
|
/* restore base dimensions */
|
2012-07-13 21:01:04 +04:00
|
|
|
cc->geom.w += cc->hint.basew;
|
|
|
|
cc->geom.h += cc->hint.baseh;
|
2009-08-25 03:49:04 +04:00
|
|
|
|
|
|
|
/* adjust for min width/height */
|
2012-07-13 21:01:04 +04:00
|
|
|
cc->geom.w = MAX(cc->geom.w, cc->hint.minw);
|
|
|
|
cc->geom.h = MAX(cc->geom.h, cc->hint.minh);
|
2009-08-25 03:49:04 +04:00
|
|
|
|
|
|
|
/* adjust for max width/height */
|
2011-09-03 13:42:33 +04:00
|
|
|
if (cc->hint.maxw)
|
2012-07-13 21:01:04 +04:00
|
|
|
cc->geom.w = MIN(cc->geom.w, cc->hint.maxw);
|
2011-09-03 13:42:33 +04:00
|
|
|
if (cc->hint.maxh)
|
2012-07-13 21:01:04 +04:00
|
|
|
cc->geom.h = MIN(cc->geom.h, cc->hint.maxh);
|
2014-01-03 00:58:20 +04:00
|
|
|
|
|
|
|
cc->geom.w = MAX(cc->geom.w, 1);
|
|
|
|
cc->geom.h = MAX(cc->geom.h, 1);
|
2009-08-25 03:49:04 +04:00
|
|
|
}
|
|
|
|
|
2009-06-26 16:21:58 +04:00
|
|
|
static void
|
2013-12-11 19:46:47 +04:00
|
|
|
client_mwm_hints(struct client_ctx *cc)
|
2007-04-27 21:58:48 +04:00
|
|
|
{
|
2008-07-11 18:21:28 +04:00
|
|
|
struct mwm_hints *mwmh;
|
2007-04-27 21:58:48 +04:00
|
|
|
|
2013-07-16 03:51:59 +04:00
|
|
|
if (xu_getprop(cc->win, cwmh[_MOTIF_WM_HINTS], cwmh[_MOTIF_WM_HINTS],
|
2013-10-03 17:51:57 +04:00
|
|
|
PROP_MWM_HINTS_ELEMENTS, (unsigned char **)&mwmh) == MWM_NUMHINTS)
|
2007-04-27 21:58:48 +04:00
|
|
|
if (mwmh->flags & MWM_HINTS_DECORATIONS &&
|
|
|
|
!(mwmh->decorations & MWM_DECOR_ALL) &&
|
|
|
|
!(mwmh->decorations & MWM_DECOR_BORDER))
|
|
|
|
cc->bwidth = 0;
|
|
|
|
}
|
|
|
|
|
2011-09-13 12:41:57 +04:00
|
|
|
void
|
|
|
|
client_transient(struct client_ctx *cc)
|
|
|
|
{
|
|
|
|
struct client_ctx *tc;
|
|
|
|
Window trans;
|
|
|
|
|
|
|
|
if (XGetTransientForHint(X_Dpy, cc->win, &trans)) {
|
|
|
|
if ((tc = client_find(trans)) && tc->group) {
|
2013-01-01 18:19:56 +04:00
|
|
|
group_movetogroup(cc, tc->group->shortcut);
|
2011-09-13 12:41:57 +04:00
|
|
|
if (tc->flags & CLIENT_IGNORE)
|
|
|
|
cc->flags |= CLIENT_IGNORE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-15 03:32:35 +03:00
|
|
|
static int
|
2009-05-18 04:23:35 +04:00
|
|
|
client_inbound(struct client_ctx *cc, int x, int y)
|
2007-04-27 21:58:48 +04:00
|
|
|
{
|
2012-07-13 21:01:04 +04:00
|
|
|
return (x < cc->geom.w && x >= 0 &&
|
|
|
|
y < cc->geom.h && y >= 0);
|
2007-04-27 21:58:48 +04:00
|
|
|
}
|
2011-06-24 10:06:24 +04:00
|
|
|
|
|
|
|
int
|
2013-01-03 01:37:21 +04:00
|
|
|
client_snapcalc(int n0, int n1, int e0, int e1, int snapdist)
|
2011-06-24 10:06:24 +04:00
|
|
|
{
|
2013-01-03 01:37:21 +04:00
|
|
|
int s0, s1;
|
2011-06-24 10:06:24 +04:00
|
|
|
|
|
|
|
s0 = s1 = 0;
|
|
|
|
|
2013-01-03 01:37:21 +04:00
|
|
|
if (abs(e0 - n0) <= snapdist)
|
|
|
|
s0 = e0 - n0;
|
2011-06-24 10:06:24 +04:00
|
|
|
|
2013-01-03 01:37:21 +04:00
|
|
|
if (abs(e1 - n1) <= snapdist)
|
|
|
|
s1 = e1 - n1;
|
2011-06-24 10:06:24 +04:00
|
|
|
|
|
|
|
/* possible to snap in both directions */
|
|
|
|
if (s0 != 0 && s1 != 0)
|
|
|
|
if (abs(s0) < abs(s1))
|
2012-05-13 19:15:54 +04:00
|
|
|
return (s0);
|
2011-06-24 10:06:24 +04:00
|
|
|
else
|
2012-05-13 19:15:54 +04:00
|
|
|
return (s1);
|
2011-06-24 10:06:24 +04:00
|
|
|
else if (s0 != 0)
|
2012-05-13 19:15:54 +04:00
|
|
|
return (s0);
|
2011-06-24 10:06:24 +04:00
|
|
|
else if (s1 != 0)
|
2012-05-13 19:15:54 +04:00
|
|
|
return (s1);
|
2011-06-24 10:06:24 +04:00
|
|
|
else
|
2012-05-13 19:15:54 +04:00
|
|
|
return (0);
|
2011-06-24 10:06:24 +04:00
|
|
|
}
|
2013-01-08 19:16:04 +04:00
|
|
|
|
|
|
|
void
|
|
|
|
client_htile(struct client_ctx *cc)
|
|
|
|
{
|
|
|
|
struct client_ctx *ci;
|
|
|
|
struct group_ctx *gc = cc->group;
|
|
|
|
struct screen_ctx *sc = cc->sc;
|
|
|
|
struct geom xine;
|
|
|
|
int i, n, mh, x, h, w;
|
|
|
|
|
|
|
|
if (!gc)
|
|
|
|
return;
|
|
|
|
i = n = 0;
|
|
|
|
|
|
|
|
TAILQ_FOREACH(ci, &gc->clients, group_entry) {
|
|
|
|
if (ci->flags & CLIENT_HIDDEN ||
|
|
|
|
ci->flags & CLIENT_IGNORE || (ci == cc))
|
|
|
|
continue;
|
|
|
|
n++;
|
|
|
|
}
|
|
|
|
if (n == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
xine = screen_find_xinerama(sc,
|
|
|
|
cc->geom.x + cc->geom.w / 2,
|
2013-12-14 02:39:13 +04:00
|
|
|
cc->geom.y + cc->geom.h / 2, CWM_GAP);
|
2013-01-08 19:16:04 +04:00
|
|
|
|
|
|
|
if (cc->flags & CLIENT_VMAXIMIZED ||
|
|
|
|
cc->geom.h + (cc->bwidth * 2) >= xine.h)
|
|
|
|
return;
|
|
|
|
|
|
|
|
cc->flags &= ~CLIENT_HMAXIMIZED;
|
|
|
|
cc->geom.x = xine.x;
|
|
|
|
cc->geom.y = xine.y;
|
|
|
|
cc->geom.w = xine.w - (cc->bwidth * 2);
|
|
|
|
client_resize(cc, 1);
|
|
|
|
client_ptrwarp(cc);
|
|
|
|
|
|
|
|
mh = cc->geom.h + (cc->bwidth * 2);
|
|
|
|
x = xine.x;
|
|
|
|
w = xine.w / n;
|
|
|
|
h = xine.h - mh;
|
|
|
|
TAILQ_FOREACH(ci, &gc->clients, group_entry) {
|
|
|
|
if (ci->flags & CLIENT_HIDDEN ||
|
|
|
|
ci->flags & CLIENT_IGNORE || (ci == cc))
|
|
|
|
continue;
|
|
|
|
ci->bwidth = Conf.bwidth;
|
|
|
|
ci->geom.y = xine.y + mh;
|
|
|
|
ci->geom.x = x;
|
|
|
|
ci->geom.h = h - (ci->bwidth * 2);
|
|
|
|
ci->geom.w = w - (ci->bwidth * 2);
|
|
|
|
if (i + 1 == n)
|
|
|
|
ci->geom.w = xine.x + xine.w -
|
|
|
|
ci->geom.x - (ci->bwidth * 2);
|
|
|
|
x += w;
|
|
|
|
client_resize(ci, 1);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
client_vtile(struct client_ctx *cc)
|
|
|
|
{
|
|
|
|
struct client_ctx *ci;
|
|
|
|
struct group_ctx *gc = cc->group;
|
|
|
|
struct screen_ctx *sc = cc->sc;
|
|
|
|
struct geom xine;
|
|
|
|
int i, n, mw, y, h, w;
|
|
|
|
|
|
|
|
if (!gc)
|
|
|
|
return;
|
|
|
|
i = n = 0;
|
|
|
|
|
|
|
|
TAILQ_FOREACH(ci, &gc->clients, group_entry) {
|
|
|
|
if (ci->flags & CLIENT_HIDDEN ||
|
|
|
|
ci->flags & CLIENT_IGNORE || (ci == cc))
|
|
|
|
continue;
|
|
|
|
n++;
|
|
|
|
}
|
|
|
|
if (n == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
xine = screen_find_xinerama(sc,
|
|
|
|
cc->geom.x + cc->geom.w / 2,
|
2013-12-14 02:39:13 +04:00
|
|
|
cc->geom.y + cc->geom.h / 2, CWM_GAP);
|
2013-01-08 19:16:04 +04:00
|
|
|
|
|
|
|
if (cc->flags & CLIENT_HMAXIMIZED ||
|
|
|
|
cc->geom.w + (cc->bwidth * 2) >= xine.w)
|
|
|
|
return;
|
|
|
|
|
|
|
|
cc->flags &= ~CLIENT_VMAXIMIZED;
|
|
|
|
cc->geom.x = xine.x;
|
|
|
|
cc->geom.y = xine.y;
|
|
|
|
cc->geom.h = xine.h - (cc->bwidth * 2);
|
|
|
|
client_resize(cc, 1);
|
|
|
|
client_ptrwarp(cc);
|
|
|
|
|
|
|
|
mw = cc->geom.w + (cc->bwidth * 2);
|
|
|
|
y = xine.y;
|
|
|
|
h = xine.h / n;
|
|
|
|
w = xine.w - mw;
|
|
|
|
TAILQ_FOREACH(ci, &gc->clients, group_entry) {
|
|
|
|
if (ci->flags & CLIENT_HIDDEN ||
|
|
|
|
ci->flags & CLIENT_IGNORE || (ci == cc))
|
|
|
|
continue;
|
|
|
|
ci->bwidth = Conf.bwidth;
|
|
|
|
ci->geom.y = y;
|
|
|
|
ci->geom.x = xine.x + mw;
|
|
|
|
ci->geom.h = h - (ci->bwidth * 2);
|
|
|
|
ci->geom.w = w - (ci->bwidth * 2);
|
|
|
|
if (i + 1 == n)
|
|
|
|
ci->geom.h = xine.y + xine.h -
|
|
|
|
ci->geom.y - (ci->bwidth * 2);
|
|
|
|
y += h;
|
|
|
|
client_resize(ci, 1);
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
2013-12-11 18:16:09 +04:00
|
|
|
|
|
|
|
long
|
|
|
|
client_get_wm_state(struct client_ctx *cc)
|
|
|
|
{
|
|
|
|
long *p, state = -1;
|
|
|
|
|
|
|
|
if (xu_getprop(cc->win, cwmh[WM_STATE], cwmh[WM_STATE], 2L,
|
|
|
|
(unsigned char **)&p) > 0) {
|
|
|
|
state = *p;
|
|
|
|
XFree(p);
|
|
|
|
}
|
|
|
|
return(state);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
client_set_wm_state(struct client_ctx *cc, long state)
|
|
|
|
{
|
|
|
|
long data[] = { state, None };
|
|
|
|
|
|
|
|
XChangeProperty(X_Dpy, cc->win, cwmh[WM_STATE], cwmh[WM_STATE], 32,
|
|
|
|
PropModeReplace, (unsigned char *)data, 2);
|
|
|
|
}
|
|
|
|
|