cwm/group.c

345 lines
6.8 KiB
C
Raw Normal View History

2007-04-27 21:58:48 +04:00
/*
* calmwm - the calm window manager
*
* Copyright (c) 2004 Andy Adamson <dros@monkey.org>
* Copyright (c) 2004,2005 Marius Aamodt Eriksen <marius@monkey.org>
*
* 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
*
* $Id$
*/
#include "headers.h"
#include "calmwm.h"
#define CALMWM_NGROUPS 9
2008-04-16 00:24:41 +04:00
struct group_ctx *Group_active = NULL;
struct group_ctx Groups[CALMWM_NGROUPS];
int Grouphideall = 0;
struct group_ctx_q Groupq;
2007-04-27 21:58:48 +04:00
static void
_group_add(struct group_ctx *gc, struct client_ctx *cc)
{
if (cc == NULL || gc == NULL)
2008-04-16 00:24:41 +04:00
errx(1, "_group_add: a ctx is NULL");
2007-04-27 21:58:48 +04:00
if (cc->group == gc)
return;
if (cc->group != NULL)
TAILQ_REMOVE(&cc->group->clients, cc, group_entry);
TAILQ_INSERT_TAIL(&gc->clients, cc, group_entry);
cc->group = gc;
}
static void
_group_remove(struct client_ctx *cc)
{
if (cc == NULL || cc->group == NULL)
2008-04-16 00:24:41 +04:00
errx(1, "_group_remove: a ctx is NULL");
2007-04-27 21:58:48 +04:00
TAILQ_REMOVE(&cc->group->clients, cc, group_entry);
cc->group = NULL;
}
static void
_group_hide(struct group_ctx *gc)
{
2008-04-16 00:24:41 +04:00
struct client_ctx *cc;
2007-04-27 21:58:48 +04:00
screen_updatestackingorder();
gc->nhidden = 0;
gc->highstack = 0;
TAILQ_FOREACH(cc, &gc->clients, group_entry) {
client_hide(cc);
gc->nhidden++;
if (cc->stackingorder > gc->highstack)
gc->highstack = cc->stackingorder;
}
gc->hidden = 1; /* XXX: equivalent to gc->nhidden > 0 */
}
static void
_group_show(struct group_ctx *gc)
{
struct client_ctx *cc;
Window *winlist;
u_int i;
int lastempty = -1;
winlist = (Window *) xcalloc(sizeof(*winlist), (gc->highstack + 1));
2007-04-27 21:58:48 +04:00
/*
* Invert the stacking order as XRestackWindows() expects them
* top-to-bottom.
*/
TAILQ_FOREACH(cc, &gc->clients, group_entry) {
winlist[gc->highstack - cc->stackingorder] = cc->pwin;
client_unhide(cc);
}
/* Un-sparseify */
for (i = 0; i <= gc->highstack; i++) {
if (!winlist[i] && lastempty == -1)
lastempty = i;
else if (winlist[i] && lastempty != -1) {
winlist[lastempty] = winlist[i];
if (++lastempty == i)
lastempty = -1;
}
}
XRestackWindows(X_Dpy, winlist, gc->nhidden);
2007-04-27 21:58:48 +04:00
xfree(winlist);
gc->hidden = 0;
Group_active = gc;
2007-04-27 21:58:48 +04:00
}
void
group_init(void)
{
2008-04-16 00:24:41 +04:00
int i;
2007-04-27 21:58:48 +04:00
TAILQ_INIT(&Groupq);
2007-04-27 21:58:48 +04:00
for (i = 0; i < CALMWM_NGROUPS; i++) {
TAILQ_INIT(&Groups[i].clients);
Groups[i].hidden = 0;
Groups[i].shortcut = i + 1;
TAILQ_INSERT_TAIL(&Groupq, &Groups[i], entry);
2007-04-27 21:58:48 +04:00
}
Group_active = &Groups[0];
2007-04-27 21:58:48 +04:00
}
/*
* Colouring for groups upon add/remove.
2007-04-27 21:58:48 +04:00
*/
void
group_sticky_toggle_enter(struct client_ctx *cc)
{
struct group_ctx *gc = Group_active;
2007-04-27 21:58:48 +04:00
if (gc == cc->group) {
_group_remove(cc);
cc->highlight = CLIENT_HIGHLIGHT_RED;
} else {
_group_add(gc, cc);
cc->highlight = CLIENT_HIGHLIGHT_BLUE;
}
client_draw_border(cc);
}
void
group_sticky_toggle_exit(struct client_ctx *cc)
{
cc->highlight = 0;
client_draw_border(cc);
}
/*
2008-04-16 00:24:41 +04:00
* selection list display
2007-04-27 21:58:48 +04:00
*/
/* if group_hidetoggle would produce no effect, toggle the group's hidden state
*/
void
_group_fix_hidden_state(struct group_ctx *gc)
{
2008-04-16 00:24:41 +04:00
struct client_ctx *cc;
2007-04-27 21:58:48 +04:00
int same = 0;
TAILQ_FOREACH(cc, &gc->clients, group_entry) {
if (gc->hidden == ((cc->flags & CLIENT_HIDDEN) ? 1 : 0))
same++;
}
if (same == 0)
gc->hidden = !gc->hidden;
}
void
group_hidetoggle(int idx)
{
struct group_ctx *gc;
if (idx < 0 || idx >= CALMWM_NGROUPS)
err(1, "group_hidetoggle: index out of range (%d)", idx);
gc = &Groups[idx];
2007-04-27 21:58:48 +04:00
_group_fix_hidden_state(gc);
if (gc->hidden)
_group_show(gc);
else {
_group_hide(gc);
if (TAILQ_EMPTY(&gc->clients))
Group_active = gc;
2007-04-27 21:58:48 +04:00
}
}
/*
* Cycle through active groups. If none exist, then just stay put.
2007-04-27 21:58:48 +04:00
*/
void
group_cycle(int reverse)
2007-04-27 21:58:48 +04:00
{
struct group_ctx *gc, *showgroup = NULL;
assert(Group_active != NULL);
2007-04-27 21:58:48 +04:00
gc = Group_active;
2007-04-27 21:58:48 +04:00
for (;;) {
gc = reverse ? TAILQ_PREV(gc, group_ctx_q, entry) :
TAILQ_NEXT(gc, entry);
2007-04-27 21:58:48 +04:00
if (gc == NULL)
gc = reverse ? TAILQ_LAST(&Groupq, group_ctx_q) :
TAILQ_FIRST(&Groupq);
if (gc == Group_active)
2007-04-27 21:58:48 +04:00
break;
if (!TAILQ_EMPTY(&gc->clients) && showgroup == NULL)
showgroup = gc;
else if (!gc->hidden)
_group_hide(gc);
}
if (showgroup == NULL)
return;
_group_hide(Group_active);
2007-04-27 21:58:48 +04:00
if (showgroup->hidden)
_group_show(showgroup);
else
Group_active = showgroup;
2007-04-27 21:58:48 +04:00
}
/* called when a client is deleted */
void
group_client_delete(struct client_ctx *cc)
{
if (cc->group == NULL)
2008-04-16 00:24:41 +04:00
return;
2007-04-27 21:58:48 +04:00
TAILQ_REMOVE(&cc->group->clients, cc, group_entry);
cc->group = NULL; /* he he */
}
void
group_menu(XButtonEvent *e)
{
2008-04-16 00:24:41 +04:00
struct menu_q menuq;
struct menu *mi;
int i;
struct group_ctx *gc;
2007-04-27 21:58:48 +04:00
TAILQ_INIT(&menuq);
for (i = 0; i < CALMWM_NGROUPS; i++) {
gc = &Groups[i];
2007-04-27 21:58:48 +04:00
if (TAILQ_EMPTY(&gc->clients))
continue;
XCALLOC(mi, struct menu);
if (gc->hidden)
snprintf(mi->text, sizeof(mi->text), "%d: [%s]",
gc->shortcut, shortcut_to_name[gc->shortcut]);
2007-04-27 21:58:48 +04:00
else
snprintf(mi->text, sizeof(mi->text), "%d: %s",
gc->shortcut, shortcut_to_name[gc->shortcut]);
2007-04-27 21:58:48 +04:00
mi->ctx = gc;
TAILQ_INSERT_TAIL(&menuq, mi, entry);
}
if (TAILQ_EMPTY(&menuq))
return;
mi = menu_filter(&menuq, NULL, NULL, 0, NULL, NULL);
2007-04-27 21:58:48 +04:00
if (mi == NULL || mi->ctx == NULL)
goto cleanup;
gc = (struct group_ctx *)mi->ctx;
if (gc->hidden)
_group_show(gc);
else
_group_hide(gc);
cleanup:
2007-04-27 21:58:48 +04:00
while ((mi = TAILQ_FIRST(&menuq)) != NULL) {
TAILQ_REMOVE(&menuq, mi, entry);
xfree(mi);
}
}
void
group_alltoggle(void)
{
int i;
2008-04-16 00:24:41 +04:00
for (i = 0; i < CALMWM_NGROUPS; i++) {
if (Grouphideall)
_group_show(&Groups[i]);
2007-04-27 21:58:48 +04:00
else
2008-04-16 00:24:41 +04:00
_group_hide(&Groups[i]);
2007-04-27 21:58:48 +04:00
}
if (Grouphideall)
Grouphideall = 0;
2007-04-27 21:58:48 +04:00
else
Grouphideall = 1;
2007-04-27 21:58:48 +04:00
}
void
group_autogroup(struct client_ctx *cc)
{
struct autogroupwin *aw;
struct group_ctx *gc;
char group[CALMWM_MAXNAMELEN];
if (cc->app_class == NULL || cc->app_name == NULL)
return;
TAILQ_FOREACH(aw, &Conf.autogroupq, entry) {
2007-04-27 21:58:48 +04:00
if (strcmp(aw->class, cc->app_class) == 0 &&
(aw->name == NULL || strcmp(aw->name, cc->app_name) == 0)) {
strlcpy(group, aw->group, sizeof(group));
break;
}
}
if (strncmp("nogroup", group, 7) == 0)
return;
TAILQ_FOREACH(gc, &Groupq, entry) {
if (strcmp(shortcut_to_name[gc->shortcut], group) == 0) {
2007-04-27 21:58:48 +04:00
_group_add(gc, cc);
return;
}
2007-04-27 21:58:48 +04:00
}
if (Conf.flags & CONF_STICKY_GROUPS)
_group_add(Group_active, cc);
2007-04-27 21:58:48 +04:00
}