xref: /dports/editors/e93/e93/xgui/window.c

// Generic window handling
// Copyright (C) 2000 Core Technologies.

// This file is part of e93.
//
// e93 is free software; you can redistribute it and/or modify
// it under the terms of the e93 LICENSE AGREEMENT.
//
// e93 is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// e93 LICENSE AGREEMENT for more details.
//
// You should have received a copy of the e93 LICENSE AGREEMENT
// along with e93; see the file "LICENSE.TXT".

#include	"includes.h"

static bool
	hadInvalidation=false;

void GetEditorDisplayDimensions(UINT32 *width,UINT32 *height)
// Return the dimensions of the total display (across all screens).
// NOTE: this information is looked up each time it is needed. Although
// that's a little inefficient, it means that the display size can be adjusted
// and e93 will adapt on the fly.
{
	XWindowAttributes
		attributes;

	XGetWindowAttributes(xDisplay,RootWindow(xDisplay,xScreenNum),&attributes);
	*width=attributes.width;
	*height=attributes.height;
}

void GetEditorScreenOffsetAndDimensions(INT32 *xOffset,INT32 *yOffset,UINT32 *width,UINT32 *height)
// Return the offset and dimensions of the primary screen that the editor is
// running on.
// NOTE: On multi-head displays, it is possible that the primary screen
// (the one that e93 is opening windows onto) is not at offset 0,0 within
// the entire display.
// NOTE: this information is looked up each time it is needed. Although
// that's a little inefficient, it means that the screens can be adjusted
// and e93 will adapt on the fly.
{
	XineramaScreenInfo
		*screenInfo;
	int
		numHeads;
	XWindowAttributes
		attributes;

	if((screenInfo=XineramaQueryScreens(xDisplay,&numHeads)))	// success implies numHeads>0
	{
		// use the 0th display as the primary one
		*xOffset=screenInfo[0].x_org;
		*yOffset=screenInfo[0].y_org;
		*width=screenInfo[0].width;
		*height=screenInfo[0].height;
		XFree(screenInfo);
	}
	else	// single head
	{
		XGetWindowAttributes(xDisplay,RootWindow(xDisplay,xScreenNum),&attributes);
		*xOffset=0;
		*yOffset=0;
		*width=attributes.width;
		*height=attributes.height;
	}
}

void InvalidateWindowRect(EDITOR_WINDOW *window,EDITOR_RECT *rect)
// Invalidate rect of window, so it is drawn the next time we redraw.
{
	XRectangle
		windowRect;

	if(rect->w&&rect->h)	// NOTE: this gets around a bug in X11/MOTIF (does not properly handle adding 0 width or height to a region!)
	{
		windowRect.x=rect->x;
		windowRect.y=rect->y;
		windowRect.width=rect->w;
		windowRect.height=rect->h;
		XUnionRectWithRegion(&windowRect,((WINDOW_LIST_ELEMENT *)(window->userData))->invalidRegion,((WINDOW_LIST_ELEMENT *)(window->userData))->invalidRegion);	// add to invalid region of the window
		hadInvalidation=true;
	}
}

void InvalidateWindowRegion(EDITOR_WINDOW *window,Region region)
// Invalidate region of window, so it is drawn the next time we redraw.
{
	XUnionRegion(region,((WINDOW_LIST_ELEMENT *)window->userData)->invalidRegion,((WINDOW_LIST_ELEMENT *)window->userData)->invalidRegion);	// make this part invalid
	hadInvalidation=true;
}

void RedrawInvalidWindows()
// Run though the window list, and redraw anything that
// has invalid area.
// NOTE: for efficiency, this checks a global which tells
// if any invalidations have happened, and if not, it does nothing.
{
	WINDOW_LIST_ELEMENT
		*element;

	if(hadInvalidation)
	{
		hadInvalidation=false;									// clear now, so updates can cause further invalidation (not that they should want to, but just to be correct)
		element=windowListHead;									// update all windows that need it
		while(element)
		{
			switch(element->editorWindow->windowType)
			{
				case EWT_DOCUMENT:
					UpdateDocumentWindow(element->editorWindow);
					break;
				case EWT_DIALOG:
					UpdateDialogWindow(element->editorWindow);
					break;
				case EWT_MENU:
					UpdateMenuWindow(element->editorWindow);
					break;
				default:
					break;
			}
			element=element->nextElement;
		}
	}
}

void SetClassHints(EDITOR_WINDOW *window)
// Set the class hints for this window.
// Used to create a class of windows so that window list applications can group things properly.
{
	XClassHint
		classHints;
	WINDOW_LIST_ELEMENT
		*windowElement;
	char
		uniqueClass[64];

	windowElement=(WINDOW_LIST_ELEMENT *)window->userData;

	classHints.res_name=(char *)"e93";
	sprintf(uniqueClass,"e93 (%d)",getpid());
	classHints.res_class=uniqueClass;
	XSetClassHint(xDisplay,windowElement->xWindow,&classHints);
}

static Bool MapEventPredicate(Display *display,XEvent *event,char *arg)
// Use this to locate the mapping event for the given window.
{
	if((event->type==MapNotify)&&(event->xmap.window==*((Window *)arg)))
	{
		return(True);
	}
	return(False);
}

static Bool FocusEventPredicate(Display *display,XEvent *event,char *arg)
// Use this to locate the focus event for the given window.
{
	if((event->type==FocusIn)&&(event->xfocus.window==*((Window *)arg)))
	{
		return(True);
	}
	return(False);
}

static Bool DestroyEventPredicate(Display *display,XEvent *event,char *arg)
// Use this to locate the destroy event for the given window (actually, this
// gets ANY event for the window -- that way, no stray events are left after
// the window is gone).
{
	if(event->xmap.window==*((Window *)arg))
	{
		return(True);
	}
	return(False);
}

void WaitUntilMappedNoFocus(EDITOR_WINDOW *window)
// Wait until a mapping event for window arrives.
{
	XEvent
		event;
	WINDOW_LIST_ELEMENT
		*windowElement;

	windowElement=(WINDOW_LIST_ELEMENT *)window->userData;
	XIfEvent(xDisplay,&event,MapEventPredicate,(char *)&windowElement->xWindow);	// wait here until our window is mapped
}

void WaitUntilMapped(EDITOR_WINDOW *window)
// Wait until a mapping event for window arrives, then set the focus to that window, and
// wait for it to complete.
{
	XEvent
		event;
	WINDOW_LIST_ELEMENT
		*windowElement;

	windowElement=(WINDOW_LIST_ELEMENT *)window->userData;
	XIfEvent(xDisplay,&event,MapEventPredicate,(char *)&windowElement->xWindow);	// wait here until our window is mapped
	XSetInputFocus(xDisplay,windowElement->xWindow,RevertToPointerRoot,CurrentTime);
	XIfEvent(xDisplay,&event,FocusEventPredicate,(char *)&windowElement->xWindow);	// wait here until our window has focus
}

void WaitUntilDestroyed(EDITOR_WINDOW *window)
// Wait until a the destroy event for window arrives, eat all other events arriving for the window
// while we wait.
{
	XEvent
		event;
	WINDOW_LIST_ELEMENT
		*windowElement;

	windowElement=(WINDOW_LIST_ELEMENT *)window->userData;
	do
	{
		XIfEvent(xDisplay,&event,DestroyEventPredicate,(char *)&windowElement->xWindow);	// wait here until our window is destroyed
	}
	while(event.type!=DestroyNotify);
}

void LinkWindowElement(WINDOW_LIST_ELEMENT *element)
// Passed a WINDOW_LIST_ELEMENT, link it to the start of the global list.
{
	if(windowListHead)								// point previous back to new
	{
		windowListHead->previousElement=element;
	}
	element->nextElement=windowListHead;			// point to the old head of the list
	element->previousElement=NULL;					// no previous element
	windowListHead=element;							// point the head at the new element
}

void UnlinkWindowElement(WINDOW_LIST_ELEMENT *element)
// Passed a WINDOW_LIST_ELEMENT, unlink it from the global list.
{
	if(element->nextElement)
	{
		element->nextElement->previousElement=element->previousElement;
	}
	if(element->previousElement)
	{
		element->previousElement->nextElement=element->nextElement;
	}
	else
	{
		windowListHead=element->nextElement;		// this one was at the head, so update
	}
}

static bool CheckChildMatch(Window testWindow,unsigned int numChildren,Window *children)
// See if testWindow matches any of the children in the passed list.
// Return true if so, false if not.
{
	unsigned int
		i;

	for(i=0;i<numChildren;i++)
	{
		if(testWindow==children[i])
		{
			return(true);
		}
	}
	return(false);
}

WINDOW_LIST_ELEMENT *LocateWindowElement(Window xWindow)
// Passed an xWindow which is a client window (potentially one of ours),
// locate the editor window element associated with it (if there is one).
// NOTE: this expects that the window is a *client* window (not a window
// made by the WM as decoration).
{
	WINDOW_LIST_ELEMENT
		*element;
	bool
		found;

	element=windowListHead;
	found=false;
	while(element&&!found)
	{
		if(element->xWindow==xWindow)
		{
			found=true;
		}
		else
		{
			element=element->nextElement;
		}
	}
	return(element);
}

static WINDOW_LIST_ELEMENT *LocateArbitraryWindowElement(Window xWindow)
// Passed an arbitrary xWindow, see if it contains one of our client windows.
// NOTE: since windows can be reparented by the WM (and changed on the fly),
// this must look through the list of children of the given X window for the editor window.
{
	Window
		root,
		parent,
		*children;
	unsigned int
		numChildren;
	WINDOW_LIST_ELEMENT
		*element;
	bool
		found;

	element=LocateWindowElement(xWindow);			// start by just seeing if it is a client window

	if(!element)									// do it the hard way by looking through the children
	{
		if(XQueryTree(xDisplay,xWindow,&root,&parent,&children,&numChildren))	// get the children of this window (window could be going away, so we must allow this to fail)
		{
			element=windowListHead;
			found=false;
			while(element&&!found)
			{
				if(CheckChildMatch(element->xWindow,numChildren,children))
				{
					found=true;
				}
				else
				{
					element=element->nextElement;
				}
			}
			if(children)
			{
				XFree(children);
			}
		}
	}
	return(element);
}

void MinimizeEditorWindow(EDITOR_WINDOW *window)
// Iconify the passed window.
{
	WINDOW_LIST_ELEMENT
		*windowElement;

	windowElement=(WINDOW_LIST_ELEMENT *)window->userData;			// get the x window information associated with this document window
	XIconifyWindow(xDisplay,windowElement->xWindow,xScreenNum);
}

void UnminimizeEditorWindow(EDITOR_WINDOW *window)
// Undo what MinimizeEditorWindow did.
{
	WINDOW_LIST_ELEMENT
		*windowElement;

	windowElement=(WINDOW_LIST_ELEMENT *)window->userData;			// get the x window information associated with this document window
	XMapWindow(xDisplay,windowElement->xWindow);
}

EDITOR_WINDOW *GetTopEditorWindow()
// Return the top-most editor window, or NULL if there is none.
{
	WINDOW_LIST_ELEMENT
		*element;
	EDITOR_WINDOW
		*window;
	Window
		root,
		parent,
		*children;
	unsigned int
		child,
		numChildren;

	XQueryTree(xDisplay,RootWindow(xDisplay,xScreenNum),&root,&parent,&children,&numChildren);	// get all the children of the root (in order)
	window=NULL;
	for(child=numChildren;!window&&(child>0);child--)
	{
		if((element=LocateArbitraryWindowElement(children[child-1])))	// see if this window contains an editor window
		{
			window=element->editorWindow;
		}
	}
	if(children)
	{
		XFree((char *)children);
	}
	return(window);
}

void SetTopEditorWindow(EDITOR_WINDOW *window)
// Set the passed document window to the top of the display
// NOTE: X windows has evolved since e93 was written. It has become even
// more needlessly complex, and now window managers don't always honor
// XRaiseWindow requests (Metacity, I'm looking at you).
// The Window Manager authors apparently feel it is the duty of the WM to
// police which applications can raise windows and when.
// To me, this is nonsense. When I call XRaiseWindow, it should raise
// the damn window.
// Now however, to try to convince these misguided WMs, e93 attempts to follow:
// http://standards.freedesktop.org/wm-spec/wm-spec-1.3.html#id2506353
// by sending a _NET_ACTIVE_WINDOW message to the root window.
// If it works, the effect will be the same as having called XRaiseWindow --
// just more complex and difficult to follow.
{
	WINDOW_LIST_ELEMENT
		*windowElement;
	XEvent
		xEvent;

	windowElement=(WINDOW_LIST_ELEMENT *)window->userData;			// get the x window information associated with this document window
	XMapWindow(xDisplay,windowElement->xWindow);					// make sure it's not iconified -- Thanks Michael Manning
	XRaiseWindow(xDisplay,windowElement->xWindow);					// place it on top
	XSetInputFocus(xDisplay,windowElement->xWindow,RevertToPointerRoot,CurrentTime);	// give it the focus

	xEvent.xclient.type=ClientMessage;
	xEvent.xclient.serial=0;
	xEvent.xclient.send_event=True;
	xEvent.xclient.display=xDisplay;
	xEvent.xclient.window=windowElement->xWindow;
	xEvent.xclient.message_type=XInternAtom(xDisplay,"_NET_ACTIVE_WINDOW",True);
	xEvent.xclient.format=32;
	xEvent.xclient.data.l[0]=1;					// 1 tells the WM we're an application
	xEvent.xclient.data.l[1]=CurrentTime;		// for now, send the timestamp as CurrentTime, later if it matters, figure out what we really need
	xEvent.xclient.data.l[2]=0;					// for now, send the currently active window as 0, later if it matters, figure out what we really need
	xEvent.xclient.data.l[3]=0;
	xEvent.xclient.data.l[4]=0;
	XSendEvent(xDisplay,XDefaultRootWindow(xDisplay),False,SubstructureRedirectMask|SubstructureNotifyMask,&xEvent);
}

EDITOR_WINDOW *GetTopEditorWindowType(UINT16 windowType)
// Return the top-most window of windowType, or NULL if there is none.
{
	WINDOW_LIST_ELEMENT
		*element;
	EDITOR_WINDOW
		*window;
	Window
		root,
		parent,
		*children;
	unsigned int
		child,
		numChildren;

	XQueryTree(xDisplay,RootWindow(xDisplay,xScreenNum),&root,&parent,&children,&numChildren);	// get all the children of the root (in order) (which may reparent editor windows)
	window=NULL;
	for(child=numChildren;!window&&(child>0);child--)
	{
		if((element=LocateArbitraryWindowElement(children[child-1])))	// see if this window contains an editor window
		{
			if(element->editorWindow->windowType==windowType)
			{
				window=element->editorWindow;
			}
		}
	}
	if(children)
	{
		XFree((char *)children);
	}
	return(window);
}

bool GetSortedEditorWindowTypeList(UINT16 windowType,UINT32 *numElements,EDITOR_WINDOW ***list)
// Return a list of window pointers, sorted top to bottom for the given type.
// If there is a problem, SetError, and return false.
// If true is returned, then list must be MDisposePtr'ed later (even if numElements
// is 0).
{
	WINDOW_LIST_ELEMENT
		*element;
	Window
		root,
		parent,
		*children;
	unsigned int
		child,
		numChildren;
	bool
		fail;

	fail=false;
	*numElements=0;																	// no elements yet
	XQueryTree(xDisplay,RootWindow(xDisplay,xScreenNum),&root,&parent,&children,&numChildren);
	if(((*list)=(EDITOR_WINDOW **)MNewPtr(sizeof(EDITOR_WINDOW *)*numChildren)))	// create a list of pointers large enough to hold the maximum number of windows located
	{
		for(child=numChildren;child>0;child--)
		{
			if((element=LocateArbitraryWindowElement(children[child-1])))			// hunt down the window based on this
			{
				if(element->editorWindow->windowType==windowType)					// see if it belongs on the list
				{
					(*list)[(*numElements)++]=element->editorWindow;				// assign it to the list
				}
			}
		}
	}
	else
	{
		fail=true;
	}
	if(children)
	{
		XFree((char *)children);
	}
	return(!fail);
}

EDITOR_WINDOW *GetEditorFocusWindow()
// Return the editor window with the focus, or the top window
// if none has focus.
// If there is no top window, return NULL.
{
	EDITOR_WINDOW
		*window;
	WINDOW_LIST_ELEMENT
		*windowElement;
	Window
		xWindow;
	int
		focusRevert;

	XGetInputFocus(xDisplay,&xWindow,&focusRevert);			// find out who has the focus
	if((windowElement=LocateWindowElement(xWindow)))		// see if it is one of ours
	{
		if((windowElement->editorWindow->windowType==EWT_DOCUMENT)||(windowElement->editorWindow->windowType==EWT_DIALOG))
		{
			return(windowElement->editorWindow);			// if there is one of our documents/dialogs with focus, it is preferred
		}
		else
		{
			if((window=GetTopEditorWindowType(EWT_DIALOG)))		// try to find the top-most dialog
			{
				return(window);
			}
			else
			{
				if((window=GetTopEditorWindowType(EWT_DOCUMENT)))	// try to find the top-most document
				{
					return(window);
				}
				else
				{
					return(windowElement->editorWindow);	// no document/dialog, so give back whatever it was we found in the first place
				}
			}
		}
	}
	if((window=GetTopEditorWindowType(EWT_DIALOG)))			// if focus window was not ours try to find the top-most dialog
	{
		return(window);
	}
	else
	{
		if((window=GetTopEditorWindowType(EWT_DOCUMENT)))	// try to find the top-most document
		{
			return(window);
		}
	}
	return(rootMenuWindow);									// as a last resort, give back the root menu
}

void FocusAwayFrom(EDITOR_WINDOW *window)
// Set the focus to the topmost window that is not window.
// This is done to fool X into not readjusting the focus when we
// delete window.
{
	WINDOW_LIST_ELEMENT
		*element;
	bool
		haveFocus;
	Window
		focusWindow;
	Window
		root,
		parent,
		*children;
	unsigned int
		child,
		numChildren;

	XQueryTree(xDisplay,RootWindow(xDisplay,xScreenNum),&root,&parent,&children,&numChildren);
	haveFocus=false;
	focusWindow=0;		// stop compiler from complaining
	for(child=numChildren;!haveFocus&&(child>0);child--)
	{
		if((element=LocateArbitraryWindowElement(children[child-1])))
		{
			if(element->editorWindow!=window)
			{
				focusWindow=element->xWindow;
				haveFocus=true;
			}
		}
	}
	if(children)
	{
		XFree((char *)children);
	}
	if(haveFocus)
	{
		XSetInputFocus(xDisplay,focusWindow,RevertToPointerRoot,CurrentTime);	// give focus to this window
		XSync(xDisplay,false);
	}
}