~ctwm/ctwm/trunk

/*

 * Various workspace handling and utilities.

 */

#include "ctwm.h"

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <X11/Xatom.h>

#include "animate.h"

#include "clicktofocus.h"

#include "ctwm_atoms.h"

#include "drawing.h"

#include "functions.h"

#include "iconmgr.h"

#include "image.h"

#include "otp.h"

#include "screen.h"

#include "vscreen.h"

#include "win_ops.h"

#include "win_utils.h"

#include "workspace_manager.h"

#include "workspace_utils.h"

#ifdef EWMH

#  include "ewmh_atoms.h"

#endif

/*

 * XXX I'm not sure this should be here; maybe it's more of a per-screen

 * thing, and so should be in the Screen struct?

 */

bool useBackgroundInfo = false;

/*

 * Move the display (of a given vs) over to a new workspace.

 */

void

GotoWorkSpace(VirtualScreen *vs, WorkSpace *ws)

{

	TwmWindow            *twmWin;

	WorkSpace            *oldws, *newws;

	WList                *wl, *wl1;

	WinList              *winl;

	XSetWindowAttributes attr;

	long                 eventMask;

	IconMgr              *iconmgr;

	Window               oldw;

	Window               neww;

	TwmWindow            *focuswindow;

	VirtualScreen        *tmpvs;

	if(! Scr->workSpaceManagerActive) {

		return;

	}

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

		if(ws == tmpvs->wsw->currentwspc) {

			XBell(dpy, 0);

			return;

		}

	}

	oldws = vs->wsw->currentwspc;

	newws = ws;

	if(oldws == newws) {

		return;

	}

	/* XXX X-ref CTAG_BGDRAW in CreateWorkSpaceManager() and below */

	if(useBackgroundInfo && ! Scr->DontPaintRootWindow) {

		if(newws->image == NULL) {

			XSetWindowBackground(dpy, vs->window, newws->backcp.back);

		}

		else {

			XSetWindowBackgroundPixmap(dpy, vs->window, newws->image->pixmap);

		}

		XClearWindow(dpy, vs->window);

	}

	/* If SaveWorkspaceFocus is on, save the focus of the last window. */

	if(Scr->SaveWorkspaceFocus) {

		oldws->save_focus = Scr->Focus;

	}

	focuswindow = NULL;

	/* For better visual effect, the order or map/unmap is important:

	   - map from top to bottom.

	   - unmap from bottom to top.

	   - unmap after mapping.

	   The guiding factor: at any point during the transition, something

	   should be visible only if it was visible before the transition or if

	   it will be visible at the end.  */

	OtpCheckConsistency();

	for(twmWin = OtpTopWin(); twmWin != NULL;

	                twmWin = OtpNextWinDown(twmWin)) {

		if(OCCUPY(twmWin, newws)) {

			if(!twmWin->vs) {

				DisplayWin(vs, twmWin);

			}

#ifdef EWMH

			if(OCCUPY(twmWin, oldws)) {

				/*

				 * If the window remains visible, re-order the workspace

				 * numbers in NET_WM_DESKTOP.

				 */

				EwmhSet_NET_WM_DESKTOP_ws(twmWin, newws);

			}

#endif

		}

	}

	for(twmWin = OtpBottomWin(); twmWin != NULL;

	                twmWin = OtpNextWinUp(twmWin)) {

		if(twmWin->vs == vs) {

			if(!OCCUPY(twmWin, newws)) {

				VirtualScreen *tvs;

				Vanish(vs, twmWin);

				/*

				 * Now that the window has Vanished from one virtual screen,

				 * check to see if it is wanted on another one.

				 * This is relatively rare, so don't bother with the

				 * top-to-bottom order here.

				 */

				if(Scr->numVscreens > 1) {

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

						if(tvs == vs) { /* no, not back on the old one */

							continue;

						}

						if(OCCUPY(twmWin, tvs->wsw->currentwspc)) {

							DisplayWin(tvs, twmWin);

							break;

						}

					}

				}

			}

			else if(twmWin->hasfocusvisible) {

				focuswindow = twmWin;

				SetFocusVisualAttributes(focuswindow, false);

			}

		}

	}

	OtpCheckConsistency();

	/*

	   Reorganize icon manager window lists

	*/

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

		wl = twmWin->iconmanagerlist;

		if(wl == NULL) {

			continue;

		}

		if(OCCUPY(wl->iconmgr->twm_win, newws)) {

			continue;

		}

		wl1 = wl;

		wl  = wl->nextv;

		while(wl != NULL) {

			if(OCCUPY(wl->iconmgr->twm_win, newws)) {

				break;

			}

			wl1 = wl;

			wl  = wl->nextv;

		}

		if(wl != NULL) {

			wl1->nextv = wl->nextv;

			wl->nextv  = twmWin->iconmanagerlist;

			twmWin->iconmanagerlist = wl;

		}

	}

	wl = NULL;

	for(iconmgr = newws->iconmgr; iconmgr; iconmgr = iconmgr->next) {

		if(iconmgr->first) {

			wl = iconmgr->first;

			break;

		}

	}

	CurrentIconManagerEntry(wl);

	if(focuswindow) {

		SetFocusVisualAttributes(focuswindow, true);

	}

	vs->wsw->currentwspc = newws;

	if(Scr->ReverseCurrentWorkspace && vs->wsw->state == WMS_map) {

		MapSubwindow *msw = vs->wsw->mswl [oldws->number];

		for(winl = msw->wl; winl != NULL; winl = winl->next) {

			WMapRedrawName(vs, winl);

		}

		msw = vs->wsw->mswl [newws->number];

		for(winl = msw->wl; winl != NULL; winl = winl->next) {

			WMapRedrawName(vs, winl);

		}

	}

	else if(vs->wsw->state == WMS_buttons) {

		ButtonSubwindow *bsw = vs->wsw->bswl [oldws->number];

		PaintWsButton(WSPCWINDOW, vs, bsw->w, oldws->label, oldws->cp, off);

		bsw = vs->wsw->bswl [newws->number];

		PaintWsButton(WSPCWINDOW, vs, bsw->w, newws->label, newws->cp,  on);

	}

	oldws->iconmgr = Scr->iconmgr;

	Scr->iconmgr = newws->iconmgr;

	/* XXX X-ref CTAG_BGDRAW in CreateWorkSpaceManager() and above */

	oldw = vs->wsw->mswl [oldws->number]->w;

	neww = vs->wsw->mswl [newws->number]->w;

	if(useBackgroundInfo) {

		if(oldws->image == NULL || Scr->NoImagesInWorkSpaceManager) {

			XSetWindowBackground(dpy, oldw, oldws->backcp.back);

		}

		else {

			XSetWindowBackgroundPixmap(dpy, oldw, oldws->image->pixmap);

		}

	}

	else {

		if(Scr->workSpaceMgr.defImage == NULL || Scr->NoImagesInWorkSpaceManager) {

			XSetWindowBackground(dpy, oldw, Scr->workSpaceMgr.defColors.back);

		}

		else {

			XSetWindowBackgroundPixmap(dpy, oldw, Scr->workSpaceMgr.defImage->pixmap);

		}

	}

	attr.border_pixel = Scr->workSpaceMgr.defBorderColor;

	XChangeWindowAttributes(dpy, oldw, CWBorderPixel, &attr);

	if(Scr->workSpaceMgr.curImage == NULL) {

		if(Scr->workSpaceMgr.curPaint) {

			XSetWindowBackground(dpy, neww, Scr->workSpaceMgr.curColors.back);

		}

	}

	else {

		XSetWindowBackgroundPixmap(dpy, neww, Scr->workSpaceMgr.curImage->pixmap);

	}

	attr.border_pixel =  Scr->workSpaceMgr.curBorderColor;

	XChangeWindowAttributes(dpy, neww, CWBorderPixel, &attr);

	XClearWindow(dpy, oldw);

	XClearWindow(dpy, neww);

	eventMask = mask_out_event(Scr->Root, PropertyChangeMask);

	XChangeProperty(dpy, Scr->Root, XA_WM_CURRENTWORKSPACE, XA_STRING, 8,

	                PropModeReplace, (unsigned char *) newws->name, strlen(newws->name));

#ifdef EWMH

	{

		long number = newws->number;

		/*

		 * TODO: this should probably not use Scr->Root but ->XineramaRoot.

		 * That is the real root window if we're using virtual screens.

		 * Also, on the real root it would need values for each of the

		 * virtual roots, but that doesn't fit in the EWMH ideas.

		 */

		XChangeProperty(dpy, Scr->Root, XA__NET_CURRENT_DESKTOP,

		                XA_CARDINAL, 32,

		                PropModeReplace, (unsigned char *) &number, 1);

	}

#endif /* EWMH */

	restore_mask(Scr->Root, eventMask);

	/*    XDestroyWindow (dpy, cachew);*/

	if(Scr->ChangeWorkspaceFunction.func != 0) {

		char *action;

		XEvent event;

		action = Scr->ChangeWorkspaceFunction.item ?

		         Scr->ChangeWorkspaceFunction.item->action : NULL;

		ExecuteFunction(Scr->ChangeWorkspaceFunction.func, action,

		                (Window) 0, NULL, &event, C_ROOT, false);

	}

	/* If SaveWorkspaceFocus is on, try to restore the focus to the last

	   window which was focused when we left this workspace. */

	if(Scr->SaveWorkspaceFocus && newws->save_focus) {

		twmWin = newws->save_focus;

		if(OCCUPY(twmWin, newws)) {     /* check should not even be needed anymore */

			WarpToWindow(twmWin, false);

		}

		else {

			newws->save_focus = NULL;

		}

	}

	/* keep track of the order of the workspaces across restarts */

	CtwmSetVScreenMap(dpy, Scr->Root, Scr->vScreenList);

	XSync(dpy, 0);

	if(Scr->ClickToFocus || Scr->SloppyFocus) {

		set_last_window(newws);

	}

	MaybeAnimate = true;

}

/*

 * Various frontends to GotoWorkSpace()

 */

/*

 * Simplify redundant checks.  If no multiple workspaces, or no vs given

 * to the func, there's nothing to do.

 */

#define GWS_CHECK do { \

                if(! Scr->workSpaceManagerActive) {   \

                        return;                       \

                }                                     \

                if(!vs) {                             \

                        return;                       \

                }                                     \

        } while(0)

void

GotoWorkSpaceByName(VirtualScreen *vs, const char *wname)

{

	WorkSpace *ws;

	GWS_CHECK;

	ws = GetWorkspace(wname);

	if(ws == NULL) {

		return;

	}

	GotoWorkSpace(vs, ws);

}

void

GotoWorkSpaceByNumber(VirtualScreen *vs, int workspacenum)

{

	WorkSpace *ws;

	GWS_CHECK;

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

		if(ws->number == workspacenum) {

			break;

		}

	}

	if(ws == NULL) {

		return;

	}

	GotoWorkSpace(vs, ws);

}

void

GotoPrevWorkSpace(VirtualScreen *vs)

{

	WorkSpace *ws1, *ws2;

	GWS_CHECK;

	ws1 = Scr->workSpaceMgr.workSpaceList;

	if(ws1 == NULL) {

		return;

	}

	ws2 = ws1->next;

	while((ws2 != vs->wsw->currentwspc) && (ws2 != NULL)) {

		ws1 = ws2;

		ws2 = ws2->next;

	}

	GotoWorkSpace(vs, ws1);

}

void

GotoNextWorkSpace(VirtualScreen *vs)

{

	WorkSpace *ws;

	GWS_CHECK;

	ws = vs->wsw->currentwspc;

	ws = (ws->next != NULL) ? ws->next : Scr->workSpaceMgr.workSpaceList;

	GotoWorkSpace(vs, ws);

}

void

GotoRightWorkSpace(VirtualScreen *vs)

{

	WorkSpace *ws;

	int number, columns, count;

	GWS_CHECK;

	ws      = vs->wsw->currentwspc;

	number  = ws->number;

	columns = Scr->workSpaceMgr.columns;

	count   = Scr->workSpaceMgr.count;

	number++;

	if((number % columns) == 0) {

		number -= columns;

	}

	else if(number >= count) {

		number = (number / columns) * columns;

	}

	GotoWorkSpaceByNumber(vs, number);

}

void

GotoLeftWorkSpace(VirtualScreen *vs)

{

	WorkSpace *ws;

	int number, columns, count;

	GWS_CHECK;

	ws      = vs->wsw->currentwspc;

	number  = ws->number;

	columns = Scr->workSpaceMgr.columns;

	count   = Scr->workSpaceMgr.count;

	number += (number % columns) ? -1 : (columns - 1);

	if(number >= count) {

		number = count - 1;

	}

	GotoWorkSpaceByNumber(vs, number);

}

void

GotoUpWorkSpace(VirtualScreen *vs)

{

	WorkSpace *ws;

	int number, lines, columns, count;

	GWS_CHECK;

	ws      = vs->wsw->currentwspc;

	number  = ws->number;

	lines   = Scr->workSpaceMgr.lines;

	columns = Scr->workSpaceMgr.columns;

	count   = Scr->workSpaceMgr.count;

	number -=  columns;

	if(number < 0) {

		number += lines * columns;

		/* If the number of workspaces is not a multiple of nr of columns */

		if(number >= count) {

			number -= columns;

		}

	}

	GotoWorkSpaceByNumber(vs, number);

}

void

GotoDownWorkSpace(VirtualScreen *vs)

{

	WorkSpace *ws;

	int number, columns, count;

	GWS_CHECK;

	ws      = vs->wsw->currentwspc;

	number  = ws->number;

	columns = Scr->workSpaceMgr.columns;

	count   = Scr->workSpaceMgr.count;

	number +=  columns;

	if(number >= count) {

		number %= columns;

	}

	GotoWorkSpaceByNumber(vs, number);

}

#undef GWS_CHECK

/*

 * Show the background (by hiding all windows) or undo it.

 * f.showbackground, also can be called via EWMH bits.

 *

 * newstate is the desired showing state.

 * Pass -1 to toggle, 1 to show the background,

 * or 0 to re-show the windows.

 *

 * XXX Doesn't really belong here; more of a functions.c-ish thing

 * probably.  But left here for the moment.

 */

void

ShowBackground(VirtualScreen *vs, int newstate)

{

	static int state = 0;

	TwmWindow *twmWin;

	if(newstate == state) {

		return;

	}

	if(state) {

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

			if(twmWin->savevs == vs) {

				DisplayWin(vs, twmWin);

			}

			twmWin->savevs = NULL;

		}

		state = 0;

	}

	else {

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

			if(twmWin->vs == vs

#ifdef EWMH

			                /* leave wt_Desktop and wt_Dock visible */

			                && twmWin->ewmhWindowType == wt_Normal

#endif /* EWMH */

			  ) {

				twmWin->savevs = twmWin->vs;

				Vanish(vs, twmWin);

			}

		}

		state = 1;

	}

#ifdef EWMH

	EwmhSet_NET_SHOWING_DESKTOP(state);

#endif /* EWMH */

}

/*

 * Get the name of the currently active WS.  Used in Execute() for

 * sub'ing in $currentworkspace in executing commands.

 */

char *

GetCurrentWorkSpaceName(VirtualScreen *vs)

{

	if(! Scr->workSpaceManagerActive) {

		return (NULL);

	}

	if(!vs) {

		vs = Scr->vScreenList;

	}

	return vs->wsw->currentwspc->name;

}

/*

 * Find workspace by name

 */

WorkSpace *

GetWorkspace(const char *wname)

{

	WorkSpace *ws;

	/* Guard */

	if(!wname) {

		return (NULL);

	}

	/* Check by label */

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

		if(strcmp(ws->label, wname) == 0) {

			return ws;

		}

	}

	/* Check by name */

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

		if(strcmp(ws->name, wname) == 0) {

			return ws;

		}

	}

	/* Nope */

	return NULL;

}