~ctwm/ctwm/trunk

/*

 * Copyright 1989 Massachusetts Institute of Technology

 * Copyright 1992 Claude Lecommandeur.

 */

/***********************************************************************

 *

 * $XConsortium: iconmgr.c,v 1.48 91/09/10 15:27:07 dave Exp $

 *

 * Icon Manager routines

 *

 * 09-Mar-89 Tom LaStrange              File Created

 *

 * Do the necessary modification to be integrated in ctwm.

 * Can no longer be used for the standard twm.

 *

 * 22-April-92 Claude Lecommandeur.

 *

 *

 ***********************************************************************/

#include "ctwm.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <strings.h>

#include <X11/Xatom.h>

#include "util.h"

#include "iconmgr.h"

#include "icons_builtin.h"

#include "screen.h"

#include "drawing.h"

#include "functions_defs.h"

#include "list.h"

#include "occupation.h"

#include "otp.h"

#include "add_window.h"

#include "gram.tab.h"

#include "vscreen.h"

#include "win_decorations.h"

#include "win_resize.h"

#include "win_utils.h"

#include "xparsegeometry.h"

/* Where we start drawing the name in the icon manager */

static int iconmgr_textx;

static WList *Active = NULL;

static WList *Current = NULL;

WList *DownIconManager = NULL;

/***********************************************************************

 *

 *  Procedure:

 *      CreateIconManagers - creat all the icon manager windows

 *              for this screen.

 *

 *  Returned Value:

 *      none

 *

 *  Inputs:

 *      none

 *

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

 */

void CreateIconManagers(void)

{

	WorkSpace    *ws;

	if(Scr->NoIconManagers) {

		return;

	}

	/*

	 * Move past the iconified icon to start the text.

	 * XXX Semi-arbitrary magic add'l padding, to deal with various inner

	 * positioning of the icon subwindow.  Be smarter (or at least

	 * clearer) about this...

	 */

	iconmgr_textx = im_iconified_icon_width + 11;

	if(Scr->use3Diconmanagers) {

		iconmgr_textx += Scr->IconManagerShadowDepth;

	}

	if(Scr->siconifyPm == None) {

		Scr->siconifyPm = Create2DIconManagerIcon();

	}

	// This loop is confusing.  The inner for() loops p over the ->next

	// elements in the list, which is all the iconmgr's in the workspace.

	// The outer for() loops q over the ->nextv (<-- extra 'v' on the

	// end), which is a link to the head of the iconmgr list for the

	// _next_ workspace.

	ws = Scr->workSpaceMgr.workSpaceList;

	for(IconMgr *q = Scr->iconmgr; q != NULL; q = q->nextv) {

		for(IconMgr *p = q; p != NULL; p = p->next) {

			int gx, gy;

			char imname[100];

			int mask;

			int gravity;

			int bw;

			Pixel background;

			snprintf(imname, sizeof(imname), "%s Icon Manager", p->name);

			if(!p->geometry || !strlen(p->geometry)) {

				p->geometry = "+0+0";

			}

			mask = RLayoutXParseGeometry(Scr->Layout, p->geometry,

			                             &gx, &gy,

			                             (unsigned int *) &p->width, (unsigned int *)&p->height);

			bw = LookInList(Scr->NoBorder, imname, NULL) ? 0 :

			     (Scr->ThreeDBorderWidth ? Scr->ThreeDBorderWidth : Scr->BorderWidth);

			if(mask & XNegative) {

				gx += Scr->rootw - p->width - 2 * bw;

				gravity = (mask & YNegative) ? SouthEastGravity : NorthEastGravity;

			}

			else {

				gravity = (mask & YNegative) ? SouthWestGravity : NorthWestGravity;

			}

			if(mask & YNegative) {

				gy += Scr->rooth - p->height - 2 * bw;

			}

			background = Scr->IconManagerC.back;

			GetColorFromList(Scr->IconManagerBL, p->name, NULL,

			                 &background);

			if(p->width  < 1) {

				p->width  = 1;

			}

			if(p->height < 1) {

				p->height = 1;

			}

			p->w = XCreateSimpleWindow(dpy, Scr->Root,

			                           gx, gy, p->width, p->height, 1,

			                           Scr->Black, background);

			/* Scr->workSpaceMgr.activeWSPC = ws; */

			/* Setup various WM properties on the iconmgr's window */

			{

				char *icon_name;

				XWMHints wmhints;

				XClassHint clhints;

				if(p->icon_name) {

					icon_name = strdup(p->icon_name);

				}

				else {

					asprintf(&icon_name, "%s Icons", p->name);

				}

				wmhints.initial_state = NormalState;

				wmhints.input         = True;

				wmhints.flags         = InputHint | StateHint;

				clhints.res_name  = icon_name;

				clhints.res_class = "TwmIconManager";

				XmbSetWMProperties(dpy, p->w, imname, icon_name, NULL, 0, NULL,

				                   &wmhints, &clhints);

				free(icon_name);

			}

			p->twm_win = AddWindow(p->w, AWT_ICON_MANAGER, p, Scr->currentvs);

			// SetupOccupation() called from AddWindow() doesn't setup

			// occupation for icon managers, nor clear vs if occupation

			// lacks.  So make it occupy the one we're setting up, or the

			// 1st if we ran out somehow...

			if(ws) {

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

				// ConfigureWorkSpaceManager() ran before us, so we can

				// tell whether we're in the ws to reveal this IM.

				if(ws->number != Scr->currentvs->wsw->currentwspc->number) {

					p->twm_win->vs = NULL;

				}

			}

			else {

				p->twm_win->occupation = 1;

			}

#ifdef DEBUG_ICONMGR

			fprintf(stderr,

			        "CreateIconManagers: IconMgr %p: twm_win=%p win=0x%lx "

			        "name='%s' x=%d y=%d w=%d h=%d occupation=%x\n",

			        p, p->twm_win, p->twm_win->w, p->name,

			        gx, gy,  p->width, p->height, p->twm_win->occupation);

#endif

			{

				XSizeHints sizehints;

				sizehints.flags       = PWinGravity;

				sizehints.win_gravity = gravity;

				XSetWMSizeHints(dpy, p->w, &sizehints, XA_WM_NORMAL_HINTS);

			}

			p->twm_win->mapped = false;

			SetMapStateProp(p->twm_win, WithdrawnState);

			if(p->twm_win && (p->twm_win->wmhints->initial_state == IconicState)) {

				p->twm_win->isicon = true;

			}

			else if(!Scr->NoIconManagers && Scr->ShowIconManager) {

				p->twm_win->isicon = false;

			}

			else {

				p->twm_win->isicon = true;

			}

		}

		if(ws != NULL) {

			ws = ws->next;

		}

	}

	if(Scr->workSpaceManagerActive) {

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

	}

	/*

	 * Grab buttons/keystrokes for icon managers appropriately.

	 * Normally, this is done in AddWindow(), but it explicitly skips it

	 * for icon managers.  It's not at all clear why GrabButtons() would

	 * do so; I don't think it needs to.  GrabKeys() does do some looping

	 * over the Scr->iconmgr list at the end though, so it's possible we

	 * need to delay calling it until now when the list is all filled up.

	 * This needs further investigation; it may be that the special case

	 * and this code can be removed.  X-ref comments in add_window.c

	 * about it.

	 */

	for(IconMgr *q = Scr->iconmgr; q != NULL; q = q->nextv) {

		for(IconMgr *p = q; p != NULL; p = p->next) {

			GrabButtons(p->twm_win);

			GrabKeys(p->twm_win);

		}

	}

}

/***********************************************************************

 *

 *  Procedure:

 *      AllocateIconManager - allocate a new icon manager

 *

 *  Inputs:

 *      name    - the name of this icon manager

 *      icon_name - the name of the associated icon

 *      geom    - a geometry string to eventually parse

 *      columns - the number of columns this icon manager has

 *

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

 */

IconMgr *AllocateIconManager(char *name, char *icon_name, char *geom,

                             int columns)

{

	IconMgr *p;

#ifdef DEBUG_ICONMGR

	fprintf(stderr, "AllocateIconManager\n");

	fprintf(stderr, "  name=\"%s\" icon_name=\"%s\", geom=\"%s\", col=%d\n",

	        name, icon_name, geom, columns);

#endif

	if(Scr->NoIconManagers) {

		return NULL;

	}

	if(columns < 1) {

		columns = 1;

	}

	p = calloc(1, sizeof(IconMgr));

	p->name      = name;

	p->icon_name = icon_name;

	p->geometry  = geom;

	p->columns   = columns;

	p->scr       = Scr;

	p->width     = 150;

	p->height    = 10;

	if(Scr->iconmgr == NULL) {

		Scr->iconmgr = p;

		Scr->iconmgr->lasti = p;

	}

	else {

		Scr->iconmgr->lasti->next = p;

		p->prev = Scr->iconmgr->lasti;

		Scr->iconmgr->lasti = p;

	}

	return(p);

}

/*

 * Each workspace has its own [set of] icon manager[s].  The initial main

 * one was setup via AllocateIconManager() early in startup.  The others

 * were setup during parsing the config file.  Then this gets called late

 * in startup, after all the workspaces are setup, to copy them all into

 * each one.

 *

 * Note this is distinct from CreateIconManagers(); that creates and

 * draws the windows, this creates and connects up the data structures.

 */

void AllocateOtherIconManagers(void)

{

	IconMgr   *imfirst; // First IM on each workspace

	WorkSpace *ws;

	/* No defined workspaces?  Nothing to do. */

	if(! Scr->workSpaceManagerActive) {

		return;

	}

	/* The first workspace just gets the ones we already have */

	ws = Scr->workSpaceMgr.workSpaceList;

	ws->iconmgr = Scr->iconmgr;

	/* From the second on, we start copying */

	imfirst = ws->iconmgr;

	for(ws = ws->next; ws != NULL; ws = ws->next) {

		IconMgr *ip, *previ, *p = NULL;

		/* Copy in the first iconmgr */

		ws->iconmgr  = malloc(sizeof(IconMgr));

		*ws->iconmgr = *imfirst;

		/*

		 * This first is now the nextv to the first in the previous WS,

		 * and we don't [yet] have a nextv of our own.

		 * */

		imfirst->nextv = ws->iconmgr;

		ws->iconmgr->nextv = NULL;

		/*

		 * Start from the second, and copy them each from the prior

		 * workspace we just went through.

		 * */

		previ = ws->iconmgr;

		for(ip = imfirst->next; ip != NULL; ip = ip->next) {

			/* Copy the base bits */

			p  = malloc(sizeof(IconMgr));

			*p = *ip;

			/* Link up the double-links, and there's no nextv [yet] */

			previ->next = p;

			p->prev     = previ;

			p->next     = NULL;

			p->nextv    = NULL;

			/* We're now the nextv to that one in the old workspace */

			ip->nextv  = p;

			/* And back around to the next one to copy into this WS */

			previ = p;

		}

		/* Each one has a pointer to the last IM in this WS, so save those */

		for(ip = ws->iconmgr; ip != NULL; ip = ip->next) {

			ip->lasti = p;

		}

		/*

		 * And back around to the next workspace, which works from those

		 * we made for this WS.  We go from imfirst rather than

		 * Scr->iconmgr so the ip->nextv rewrites are correct above; we

		 * have to fill them in on the next loop.

		 */

		imfirst = ws->iconmgr;

	}

}

/***********************************************************************

 *

 *  Procedure:

 *      MoveIconManager - move the pointer around in an icon manager

 *

 *  Inputs:

 *      dir     - one of the following:

 *                      F_FORWICONMGR   - forward in the window list

 *                      F_BACKICONMGR   - backward in the window list

 *                      F_UPICONMGR     - up one row

 *                      F_DOWNICONMGR   - down one row

 *                      F_LEFTICONMGR   - left one column

 *                      F_RIGHTICONMGR  - right one column

 *

 *  Special Considerations:

 *      none

 *

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

 */

void MoveIconManager(int dir)

{

	IconMgr *ip;

	WList *tmp = NULL;

	int cur_row, cur_col, new_row, new_col;

	int row_inc, col_inc;

	bool got_it;

	if(!Current) {

		return;

	}

	cur_row = Current->row;

	cur_col = Current->col;

	ip = Current->iconmgr;

	row_inc = 0;

	col_inc = 0;

	got_it = false;

	switch(dir) {

		case F_FORWICONMGR:

			if((tmp = Current->next) == NULL) {

				tmp = ip->first;

			}

			got_it = true;

			break;

		case F_BACKICONMGR:

			if((tmp = Current->prev) == NULL) {

				tmp = ip->last;

			}

			got_it = true;

			break;

		case F_UPICONMGR:

			row_inc = -1;

			break;

		case F_DOWNICONMGR:

			row_inc = 1;

			break;

		case F_LEFTICONMGR:

			col_inc = -1;

			break;

		case F_RIGHTICONMGR:

			col_inc = 1;

			break;

	}

	/* If got_it is false ast this point then we got a left, right,

	 * up, or down, command.  We will enter this loop until we find

	 * a window to warp to.

	 */

	new_row = cur_row;

	new_col = cur_col;

	while(!got_it) {

		new_row += row_inc;

		new_col += col_inc;

		if(new_row < 0) {

			new_row = ip->cur_rows - 1;

		}

		if(new_col < 0) {

			new_col = ip->cur_columns - 1;

		}

		if(new_row >= ip->cur_rows) {

			new_row = 0;

		}

		if(new_col >= ip->cur_columns) {

			new_col = 0;

		}

		/* Now let's go through the list to see if there is an entry with this

		 * new position

		 */

		for(tmp = ip->first; tmp != NULL; tmp = tmp->next) {

			if(tmp->row == new_row && tmp->col == new_col) {

				got_it = true;

				break;

			}

		}

	}

	if(!got_it) {

		fprintf(stderr,

		        "%s:  unable to find window (%d, %d) in icon manager\n",

		        ProgramName, new_row, new_col);

		return;

	}

	if(tmp == NULL) {

		return;

	}

	/* raise the frame so the icon manager is visible */

	if(ip->twm_win->mapped) {

		OtpRaise(ip->twm_win, WinWin);

		XWarpPointer(dpy, None, tmp->icon, 0, 0, 0, 0, 5, 5);

	}

	else {

		if(tmp->twm->title_height) {

			int tbx = Scr->TBInfo.titlex;

			int x = tmp->twm->highlightxr;

			XWarpPointer(dpy, None, tmp->twm->title_w, 0, 0, 0, 0,

			             tbx + (x - tbx) / 2,

			             Scr->TitleHeight / 4);

		}

		else {

			XWarpPointer(dpy, None, tmp->twm->w, 0, 0, 0, 0, 5, 5);

		}

	}

}

/***********************************************************************

 *

 *  Procedure:

 *      MoveMappedIconManager - move the pointer around in an icon manager

 *

 *  Inputs:

 *      dir     - one of the following:

 *                      F_FORWMAPICONMGR        - forward in the window list

 *                      F_BACKMAPICONMGR        - backward in the window list

 *

 *  Special Considerations:

 *      none

 *

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

 */

void MoveMappedIconManager(int dir)

{

	IconMgr *ip;

	WList *tmp = NULL;

	WList *orig = NULL;

	bool got_it;

	if(!Current) {

		Current = Active;

	}

	if(!Current) {

		return;

	}

	ip = Current->iconmgr;

	got_it = false;

	tmp = Current;

	orig = Current;

	while(!got_it) {

		switch(dir) {

			case F_FORWMAPICONMGR:

				if((tmp = tmp->next) == NULL) {

					tmp = ip->first;

				}

				break;

			case F_BACKMAPICONMGR:

				if((tmp = tmp->prev) == NULL) {

					tmp = ip->last;

				}

				break;

		}

		if(tmp->twm->mapped) {

			got_it = true;

			break;

		}

		if(tmp == orig) {

			break;

		}

	}

	if(!got_it) {

		fprintf(stderr, "%s:  unable to find open window in icon manager\n",

		        ProgramName);

		return;

	}

	if(tmp == NULL) {

		return;

	}

	/* raise the frame so the icon manager is visible */

	if(ip->twm_win->mapped) {

		OtpRaise(ip->twm_win, WinWin);

		XWarpPointer(dpy, None, tmp->icon, 0, 0, 0, 0, 5, 5);

	}

	else {

		if(tmp->twm->title_height) {

			XWarpPointer(dpy, None, tmp->twm->title_w, 0, 0, 0, 0,

			             tmp->twm->title_width / 2,

			             Scr->TitleHeight / 4);

		}

		else {

			XWarpPointer(dpy, None, tmp->twm->w, 0, 0, 0, 0, 5, 5);

		}

	}

}

/***********************************************************************

 *

 *  Procedure:

 *      JumpIconManager - jump from one icon manager to another,

 *              possibly even on another screen

 *

 *  Inputs:

 *      dir     - one of the following:

 *                      F_NEXTICONMGR   - go to the next icon manager

 *                      F_PREVICONMGR   - go to the previous one

 *

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

 */

void JumpIconManager(int dir)

{

	IconMgr *ip, *tmp_ip = NULL;

	bool got_it = false;

	ScreenInfo *sp;

	int screen;

	if(!Current) {

		return;

	}

#define ITER(i) (dir == F_NEXTICONMGR ? (i)->next : (i)->prev)

#define IPOFSP(sp) (dir == F_NEXTICONMGR ? sp->iconmgr : sp->iconmgr->lasti)

#define TEST(ip) if ((ip)->count != 0 && (ip)->twm_win->mapped) \

                 { got_it = true; break; }

	ip = Current->iconmgr;

	for(tmp_ip = ITER(ip); tmp_ip; tmp_ip = ITER(tmp_ip)) {

		TEST(tmp_ip);

	}

	if(!got_it) {

		int origscreen = ip->scr->screen;

		int inc = (dir == F_NEXTICONMGR ? 1 : -1);

		for(screen = origscreen + inc; ; screen += inc) {

			if(screen >= NumScreens) {

				screen = 0;

			}

			else if(screen < 0) {

				screen = NumScreens - 1;

			}

			sp = ScreenList[screen];

			if(sp) {

				for(tmp_ip = IPOFSP(sp); tmp_ip; tmp_ip = ITER(tmp_ip)) {

					TEST(tmp_ip);

				}

			}

			if(got_it || screen == origscreen) {

				break;

			}

		}

	}

#undef ITER

#undef IPOFSP

#undef TEST

	if(!got_it) {

		XBell(dpy, 0);

		return;

	}

	/* raise the frame so it is visible */

	OtpRaise(tmp_ip->twm_win, WinWin);

	if(tmp_ip->active) {

		XWarpPointer(dpy, None, tmp_ip->active->icon, 0, 0, 0, 0, 5, 5);

	}

	else {

		XWarpPointer(dpy, None, tmp_ip->w, 0, 0, 0, 0, 5, 5);

	}

}

/***********************************************************************

 *

 *  Procedure:

 *      AddIconManager - add a window to an icon manager

 *

 *  Inputs:

 *      tmp_win - the TwmWindow structure

 *

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

 */

WList *AddIconManager(TwmWindow *tmp_win)

{

	WList *tmp, *old;

	IconMgr *ip;

	/* Some window types don't wind up in icon managers ever */

	if(tmp_win->isiconmgr || tmp_win->istransient || tmp_win->iswspmgr

	                || tmp_win->w == Scr->workSpaceMgr.occupyWindow->w) {

		return NULL;

	}

	/* Icon managers can be shut off wholesale in the config */

	if(Scr->NoIconManagers) {

		return NULL;

	}

	/* Config could declare not to IMify this type of window in two ways */

	if(LookInList(Scr->IconMgrNoShow, tmp_win->name, &tmp_win->class)) {

		return NULL;

	}

	if(Scr->IconManagerDontShow

	                && !LookInList(Scr->IconMgrShow, tmp_win->name, &tmp_win->class)) {