~ctwm/ctwm/trunk

/*

 * Occupation handling bits

 *

 * This is in fact pretty tightly tied and extremely similar to the

 * handling of the WorkSpaceManager in workmgr.c, and used to be there.

 * It makes sense to consider them together (and indeed, many of the

 * configs that affect how this works are really WorkSpaceManager* or

 * WMgr* commands.  But having them crammed together in one file is

 * unwieldy.

 */

#include "ctwm.h"

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <X11/Xatom.h>

#include "add_window.h"

#include "ctwm_atoms.h"

#include "drawing.h"

#include "events.h"

#include "iconmgr.h"

#include "list.h"

#include "screen.h"

#include "occupation.h"

#include "otp.h"

#include "util.h"

#include "vscreen.h"

#include "win_iconify.h"

#include "win_regions.h"

#include "win_utils.h"

#include "workspace_manager.h"

#include "workspace_utils.h"

static int GetMaskFromResource(TwmWindow *win, char *res);

static char *mk_nullsep_string(const char *prop, int len);

static bool CanChangeOccupation(TwmWindow **twm_winp);

int fullOccupation = 0;

/*

 * The window whose occupation is currently being manipulated.

 *

 * XXX Should probably be static, but currently needed in

 * WMapRemoveWindow().  Revisit.

 */

TwmWindow *occupyWin = NULL;

/* XXX Share with captive.c? */

static XrmOptionDescRec table [] = {

	{"-xrm",            NULL,           XrmoptionResArg, (XPointer) NULL},

};

/*

 ****************************************************************

 *

 * First, funcs related to setting and changing a window's occupation.

 *

 ****************************************************************

 */

/*

 * Setup the occupation of a TwmWindow.  Called as part of the

 * AddWindow() process.

 *

 * XXX The logic flow in this is kinda weird, and it's not at all clear

 * to what extent it's really doing the right on on what should override

 * what, or which things should expand/contract on others...

 */

void

SetupOccupation(TwmWindow *twm_win, int occupation_hint)

{

	char      **cliargv = NULL;

	int       cliargc;

	WorkSpace *ws;

	/* If there aren't any config'd workspaces, there's only 0 */

	if(! Scr->workSpaceManagerActive) {

		twm_win->occupation = 1 << 0;   /* occupy workspace #0 */

		/* more?... */

		return;

	}

	/* Workspace manager window doesn't get futzed with */

	if(twm_win->iswspmgr) {

		return;

	}

	/*twm_win->occupation = twm_win->iswinbox ? fullOccupation : 0;*/

	twm_win->occupation = 0;

	/* Specified in any Occupy{} config params? */

	for(ws = Scr->workSpaceMgr.workSpaceList; ws != NULL; ws = ws->next) {

		if(LookInList(ws->clientlist, twm_win->name, &twm_win->class)) {

			twm_win->occupation |= 1 << ws->number;

		}

	}

	/* OccupyAll{} */

	if(LookInList(Scr->OccupyAll, twm_win->name, &twm_win->class)) {

		twm_win->occupation = fullOccupation;

	}

	/* See if it specified in -xrm stuff */

	if(XGetCommand(dpy, twm_win->w, &cliargv, &cliargc)) {

		Bool status;

		char *str_type;

		XrmValue value;

		XrmDatabase db = NULL;

		XrmParseCommand(&db, table, 1, "ctwm", &cliargc, cliargv);

		XFreeStringList(cliargv);

		status = XrmGetResource(db, "ctwm.workspace", "Ctwm.Workspace",

		                        &str_type, &value);

		if((status == True) && (value.size != 0)) {

			/* Copy the value.addr because it's in XRM memory not ours */

			char wrkSpcList[512];

			safe_strncpy(wrkSpcList, value.addr, MIN(value.size, 512));

			twm_win->occupation = GetMaskFromResource(twm_win, wrkSpcList);

		}

		XrmDestroyDatabase(db);

	}

	/* Does it have a property telling us */

	if(RestartPreviousState) {

		Atom actual_type;

		int actual_format;

		unsigned long nitems, bytesafter;

		unsigned char *prop;

		if(XGetWindowProperty(dpy, twm_win->w, XA_WM_OCCUPATION, 0L, 2500, False,

		                      XA_STRING, &actual_type, &actual_format, &nitems,

		                      &bytesafter, &prop) == Success) {

			if(nitems != 0) {

				twm_win->occupation = GetMaskFromProperty(prop, nitems);

				XFree(prop);

			}

		}

	}

#ifdef EWMH

	/* Maybe EWMH has something to tell us? */

	if(twm_win->occupation == 0) {

		twm_win->occupation = EwmhGetOccupation(twm_win);

	}

#endif /* EWMH */

	/* Icon Managers shouldn't get altered */

	/* XXX Should this be up near the top? */

	if(twm_win->isiconmgr) {

		return;        /* someone tried to modify occupation of icon managers */

	}

	/*

	 * Transient-ish things go with their parents unless

	 * TransientHasOccupation set in the config.

	 */

	if(! Scr->TransientHasOccupation) {

		TwmWindow *t;

		if(twm_win->istransient) {

			t = GetTwmWindow(twm_win->transientfor);

			if(t != NULL) {

				twm_win->occupation = t->occupation;

			}

		}

		else if(twm_win->group != 0) {

			t = GetTwmWindow(twm_win->group);

			if(t != NULL) {

				twm_win->occupation = t->occupation;

			}

		}

	}

	/* If we were told something specific, go with that */

	if(occupation_hint != 0) {

		twm_win->occupation = occupation_hint;

	}

	/* If it's apparently-nonsensical, put it in its vs's workspace */

	if((twm_win->occupation & fullOccupation) == 0) {

		twm_win->occupation = 1 << twm_win->vs->wsw->currentwspc->number;

	}

	/*

	 * If the occupation would not show it in the current vscreen,

	 * make it vanish.

	 *

	 * If it could be shown in one of the other vscreens, change the vscreen.

	 */

	if(!OCCUPY(twm_win, twm_win->vs->wsw->currentwspc)) {

		twm_win->vs = NULL;

#ifdef VSCREEN

		if(Scr->numVscreens > 1) {

			VirtualScreen *vs;

			for(vs = Scr->vScreenList; vs != NULL; vs = vs->next) {

				if(OCCUPY(twm_win, vs->wsw->currentwspc)) {

					twm_win->vs = vs;

					twm_win->parent_vs = vs;

					break;

				}

			}

		}

#endif

	}

	/* Set the property for the occupation */

	{

		long eventMask;

		char *wsstr;

		int  len;

		/* Ignore the PropertyChange we're about to do */

		if((eventMask = mask_out_event(twm_win->w, PropertyChangeMask)) < 0) {

			/* Window is horked, not much we can do */

			return;

		}

		/* Set the property for the occupation */

		len = GetPropertyFromMask(twm_win->occupation, &wsstr);

		XChangeProperty(dpy, twm_win->w, XA_WM_OCCUPATION, XA_STRING, 8,

		                PropModeReplace, (unsigned char *) wsstr, len);

		free(wsstr);

#ifdef EWMH

		EwmhSet_NET_WM_DESKTOP(twm_win);

#endif

		/* Restore event mask */

		restore_mask(twm_win->w, eventMask);

	}

	/* Set WM_STATE prop */

	{

		int state = NormalState;

		Window icon;

		if(!(RestartPreviousState

		                && GetWMState(twm_win->w, &state, &icon)

		                && (state == NormalState || state == IconicState

		                    || state == InactiveState))) {

			if(twm_win->wmhints->flags & StateHint) {

				state = twm_win->wmhints->initial_state;

			}

		}

		if(visible(twm_win)) {

			if(state == InactiveState) {

				SetMapStateProp(twm_win, NormalState);

			}

		}

		else {

			if(state == NormalState) {

				SetMapStateProp(twm_win, InactiveState);

			}

		}

	}

}

/*

 * Make sure a window is marked in a given workspace.  f.addtoworkspace.

 * Also gets called as part of the process of mapping a window; if we're

 * mapping it here, it should know that it's here.  And Xinerama magic

 * moves.

 */

void

AddToWorkSpace(char *wname, TwmWindow *twm_win)

{

	WorkSpace *ws;

	int newoccupation;

	if(!CanChangeOccupation(&twm_win)) {

		return;

	}

	ws = GetWorkspace(wname);

	if(!ws) {

		return;

	}

	if(twm_win->occupation & (1 << ws->number)) {

		return;

	}

	newoccupation = twm_win->occupation | (1 << ws->number);

	ChangeOccupation(twm_win, newoccupation);

}

/*

 * Converse of the above.  f.removefromworkspace, also called from

 * Xinerama-related magic.

 */

void

RemoveFromWorkSpace(char *wname, TwmWindow *twm_win)

{

	WorkSpace *ws;

	int newoccupation;

	if(!CanChangeOccupation(&twm_win)) {

		return;

	}

	ws = GetWorkspace(wname);

	if(!ws) {

		return;

	}

	newoccupation = twm_win->occupation & ~(1 << ws->number);

	if(!newoccupation) {

		return;

	}

	ChangeOccupation(twm_win, newoccupation);

}

/* f.toggleoccupation - flip setting for [current] workspace */

void

ToggleOccupation(char *wname, TwmWindow *twm_win)

{

	WorkSpace *ws;

	int newoccupation;

	if(!CanChangeOccupation(&twm_win)) {

		return;

	}

	ws = GetWorkspace(wname);

	if(!ws) {

		return;

	}

	newoccupation = twm_win->occupation ^ (1 << ws->number);

	if(!newoccupation) {

		/* Don't allow de-occupying _every_ ws */

		return;

	}

	ChangeOccupation(twm_win, newoccupation);

}

/* f.movetonextworkspace */

void

MoveToNextWorkSpace(VirtualScreen *vs, TwmWindow *twm_win)

{

	WorkSpace *wlist1, *wlist2;

	int newoccupation;

	if(!CanChangeOccupation(&twm_win)) {

		return;

	}

	wlist1 = vs->wsw->currentwspc;

	wlist2 = wlist1->next;

	wlist2 = wlist2 ? wlist2 : Scr->workSpaceMgr.workSpaceList;

	/* Out of (here), into (here+1) */

	newoccupation = (twm_win->occupation ^ (1 << wlist1->number))

	                | (1 << wlist2->number);

	ChangeOccupation(twm_win, newoccupation);

}

/* f.movetonextworkspaceandfollow */

void

MoveToNextWorkSpaceAndFollow(VirtualScreen *vs, TwmWindow *twm_win)

{

	if(!CanChangeOccupation(&twm_win)) {

		return;

	}

	MoveToNextWorkSpace(vs, twm_win);

	GotoNextWorkSpace(vs);

#if 0

	OtpRaise(twm_win, WinWin);  /* XXX really do this? */

#endif

}

/* f.movetoprevworkspaceand */

void

MoveToPrevWorkSpace(VirtualScreen *vs, TwmWindow *twm_win)

{

	WorkSpace *wlist1, *wlist2;

	int newoccupation;

	if(!CanChangeOccupation(&twm_win)) {

		return;

	}

	wlist1 = Scr->workSpaceMgr.workSpaceList;

	wlist2 = vs->wsw->currentwspc;

	if(wlist1 == NULL) {

		return;

	}

	while(wlist1->next != wlist2 && wlist1->next != NULL) {

		wlist1 = wlist1->next;

	}

	/* Out of (here), into (here-1) */

	newoccupation = (twm_win->occupation ^ (1 << wlist2->number))

	                | (1 << wlist1->number);

	ChangeOccupation(twm_win, newoccupation);

}

/* f.movetoprevworkspaceandfollow */

void

MoveToPrevWorkSpaceAndFollow(VirtualScreen *vs, TwmWindow *twm_win)

{

	if(!CanChangeOccupation(&twm_win)) {

		return;

	}

	MoveToPrevWorkSpace(vs, twm_win);

	GotoPrevWorkSpace(vs);

#if 0

	OtpRaise(twm_win, WinWin);          /* XXX really do this? */

#endif

}

/*

 * Set the occupation based on the window name.  This is called if

 * AutoOccupy is set, when we get a notification about a window name

 * change.

 */

void

WmgrRedoOccupation(TwmWindow *win)

{

	WorkSpace *ws;

	int       newoccupation;

	if(LookInList(Scr->OccupyAll, win->name, &win->class)) {

		newoccupation = fullOccupation;

	}

	else {

		newoccupation = 0;

		for(ws = Scr->workSpaceMgr.workSpaceList; ws != NULL; ws = ws->next) {

			if(LookInList(ws->clientlist, win->name, &win->class)) {

				newoccupation |= 1 << ws->number;

			}

		}

	}

	if(newoccupation != 0) {

		ChangeOccupation(win, newoccupation);

	}

}

/* f.vanish */

void

WMgrRemoveFromCurrentWorkSpace(VirtualScreen *vs, TwmWindow *win)

{

	WorkSpace *ws;

	int       newoccupation;

	ws = vs->wsw->currentwspc;

	if(!ws) {

		/* Impossible? */

		return;

	}

	if(! OCCUPY(win, ws)) {

		return;

	}

	newoccupation = win->occupation & ~(1 << ws->number);

	if(newoccupation == 0) {

		return;

	}

	ChangeOccupation(win, newoccupation);

}

/* f.warphere */

void

WMgrAddToCurrentWorkSpaceAndWarp(VirtualScreen *vs, char *winname)

{

	TwmWindow *tw;

	int       newoccupation;

	/* Find named window on this screen */

	for(tw = Scr->FirstWindow; tw != NULL; tw = tw->next) {

		if(match(winname, tw->name)) {

			break;

		}

	}

	/* Didn't find it by name?  Try by class */

	if(!tw) {

		for(tw = Scr->FirstWindow; tw != NULL; tw = tw->next) {

			if(match(winname, tw->class.res_name)) {

				break;

			}

		}

	}

	if(!tw) {

		for(tw = Scr->FirstWindow; tw != NULL; tw = tw->next) {

			if(match(winname, tw->class.res_class)) {

				break;

			}

		}

	}

	/* Still didn't find?  Beep at the user and bail. */

	if(!tw) {

		XBell(dpy, 0);

		return;

	}

	/* If WarpUnmapped isn't set and this isn't mapped, beep and bail */

	if((! Scr->WarpUnmapped) && (! tw->mapped)) {

		XBell(dpy, 0);

		return;

	}

	/* Move it here if it's not */

	if(! OCCUPY(tw, vs->wsw->currentwspc)) {

		newoccupation = tw->occupation | (1 << vs->wsw->currentwspc->number);

		ChangeOccupation(tw, newoccupation);

	}

	/* If we get here, WarpUnmapped is set, so map it if we need to */

	if(! tw->mapped) {

		DeIconify(tw);

	}

	/* And go */

	WarpToWindow(tw, Scr->RaiseOnWarp);

}

/* f.occupyall backend */

void

OccupyAll(TwmWindow *twm_win)

{

	IconMgr *save;

	if(!CanChangeOccupation(&twm_win)) {

		return;

	}

	/*

	 * Temporarily alter Scr->iconmgr because stuff down in

	 * ChangeOccupation winds up adding/removing bits, and that doesn't

	 * work right when we're setting all?  XXX Investigate further.

	 */

	save = Scr->iconmgr;

	Scr->iconmgr = Scr->workSpaceMgr.workSpaceList->iconmgr;

	ChangeOccupation(twm_win, fullOccupation);

	Scr->iconmgr = save;

}

/*

 ****************************************************************

 *

 * Pieces related to the Occupy window

 *

 ****************************************************************

 */

static ColorPair occupyButtoncp;

static char *ok_string         = "OK",

             *cancel_string     = "Cancel",

              *everywhere_string = "All";

/*

 * Create the Occupy window.  Part of startup process.

 *

 * Do not do the layout of the parts, only calculate the initial total

 * size. For the layout, call ResizeOccupyWindow() at the end.

 *

 * There is only one Occupy window (per Screen), it is reparented to each

 * virtual screen as needed.

 */

void

CreateOccupyWindow(void)

{

	int           width; // Caculated and altered, unlike most others

	int           Dummy = 1;

	TwmWindow     *tmp_win;

	/* Shorthands for the Occupy window */

	OccupyWindow  *occwin = Scr->workSpaceMgr.occupyWindow;

	Window        w; // occwin->w

	/* Misc other shorthands */

	const int lines   = Scr->workSpaceMgr.lines;

	const int columns = Scr->workSpaceMgr.columns;

	const int bwidth  = Scr->vScreenList->wsw->bwidth;

	const int bheight = Scr->vScreenList->wsw->bheight;

	const int vspace = occwin->vspace;

	const int hspace = occwin->hspace;

	const int height = ((bheight + vspace) * lines) + bheight + (2 * vspace);

	/* Struct embedded in [struct embedded in] Scr, so memory's waiting */

	/* There isn't anything we should do without workspaces... */

	if(!Scr->workSpaceManagerActive) {

		return;

	}

	/* Initialize font and colorpair bits */

	occwin->font     = Scr->IconManagerFont;

	occwin->cp       = Scr->IconManagerC;

#ifdef COLOR_BLIND_USER

	occwin->cp.shadc = Scr->White;

	occwin->cp.shadd = Scr->Black;

#else

	if(!Scr->BeNiceToColormap) {

		GetShadeColors(&occwin->cp);

	}

#endif

	/* We already know that these should be too */

	occwin->lines   = lines;

	occwin->columns = columns;

	/*

	 * Work out the necessary size of the OK/Cancel/All buttons at the

	 * bottom.

	 */

	{

		XRectangle inc_rect;

		XRectangle logical_rect;

		MyFont font = occwin->font;

		int bbwidth;  // Bottom button width

		/* Window min width based on bottom vs. workspace btns */

		int bb_width, ws_width;

		/* Buttons gotta be as wide as the biggest of the three strings */

		XmbTextExtents(font.font_set, ok_string, strlen(ok_string),

		               &inc_rect, &logical_rect);

		bbwidth = logical_rect.width;

		XmbTextExtents(font.font_set, cancel_string, strlen(cancel_string),

		               &inc_rect, &logical_rect);

		bbwidth = MAX(bbwidth, logical_rect.width);

		XmbTextExtents(font.font_set, everywhere_string,

		               strlen(everywhere_string),

		               &inc_rect, &logical_rect);

		bbwidth = MAX(bbwidth, logical_rect.width);

		/* Plus the padding width */

		bbwidth += hspace;

		/*

		 * So, the final width of those bottom buttons is that, plus the

		 * 3d button look extra on both sides, plus a little extra.  I

		 * guess that extra + 2 is similar to TitlePadding or

		 * ButtonIndent on titlebars, but we don't have a config param

		 * for it on the workspace manager (which is the config used for

		 * the occupy window), so leave it as a magic constant for now.

		 */

		occwin->owidth = bbwidth + 2 * Scr->WMgrButtonShadowDepth + 2;

		/*

		 * The whole thing has to be at least triple the min width of

		 * those bottom buttons, since there are three of them.  The

		 * layout is "hspace button hspace button [...] hspace", to pad

		 * between and on both sides.

		 */

		bb_width = 3 * (bbwidth + hspace) + hspace;

		/*

		 * It also has to be the width of our per-WS buttons.  Per-ws

		 * buttons are sized the same as in the button-state WSM, and

		 * then we add the padding to them as above.

		 */

		ws_width = columns * (bwidth + hspace) + hspace;

		/* So the window has to be as wide as the wider of those */

		width = MAX(bb_width, ws_width);

	}

	/* Now we know the size, so make the window */

	w = occwin->w = XCreateSimpleWindow(dpy, Scr->Root, 0, 0, width, height,

	                                    1, Scr->Black, occwin->cp.back);

	/* Take those base sizes as a minimum */

	occwin->minwidth  = width;

	occwin->minheight = height;

	/*

	 * Make subwindows as buttons for the workspaces.  They're laid out

	 * in a grid mirroring the workspace manager's.

	 */

	{

		int i = 0, j = 0;

		WorkSpace *ws;

		occwin->obuttonw = calloc(Scr->workSpaceMgr.count, sizeof(Window));

		for(ws = Scr->workSpaceMgr.workSpaceList; ws != NULL; ws = ws->next) {

			int idx = (j * columns) + i;

			/*

			 * Make and map.  Note that we're not setting the size or

			 * location at all here; ResizeOccupyWindow() does all that.

			 * We just make 'em.

			 */

			occwin->obuttonw[idx] = XCreateSimpleWindow(dpy, w,

			                        Dummy /* x */,

			                        Dummy /* y */,

			                        Dummy /* width */,

			                        Dummy /* height */,

			                        0, Scr->Black, ws->cp.back);

			XMapWindow(dpy, occwin->obuttonw[idx]);

			/* Inc around to the next location */