/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * The contents of this file are subject to the Netscape Public License
 * Version 1.0 (the "NPL"); you may not use this file except in
 * compliance with the NPL.  You may obtain a copy of the NPL at
 * http://www.mozilla.org/NPL/
 *
 * Software distributed under the NPL is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
 * for the specific language governing rights and limitations under the
 * NPL.
 *
 * The Initial Developer of this code under the NPL is Netscape
 * Communications Corporation.  Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
 * Reserved.
 */

/*
 * The following source code is part of the Microline Widget Library.
 * The Microline widget library is made available to Mozilla developers
 * under the Netscape Public License (NPL) by Neuron Data.  To learn
 * more about Neuron Data, please visit the Neuron Data Home Page at
 * http://www.neurondata.com.
 */

#include <XmL/XmL.h>
#include <Xm/XmP.h>
#include <Xm/LabelP.h>
#include <Xm/DrawnBP.h>
#include <Xm/MessageB.h>
#include <Xm/Protocols.h>
#include <Xm/AtomMgr.h>
#ifdef MOTIF11
#include <Xm/VendorE.h>
#else
#include <Xm/VendorS.h>
#endif
#include <Xm/BulletinB.h>
#include <Xm/MenuShell.h>

#include <stdlib.h>
#include <stdio.h>

#ifdef SUNOS4
int fprintf(FILE *, char *, ...);
#endif

static void XmLDrawnBDestroyCB(Widget w, XtPointer clientData, XtPointer);
static void XmLDrawnBDrawCB(Widget, XtPointer, XtPointer);
static void XmLDrawnBDrawStringCB(Widget, XtPointer, XtPointer);
static int XmLDrawCalc(Widget w, Dimension width, Dimension height,
	unsigned char alignment, XRectangle *rect, XRectangle *clipRect,
	int *x, int *y);
static void XmLFontGetAverageWidth(XFontStruct *fs, short *width);
static void XmLMessageBoxResponse(Widget, XtPointer, XtPointer);
static void XmLMessageBoxWMDelete(Widget, XtPointer, XtPointer);
static void XmLSortFunc(char *lvec, char *rvec);

struct _XmLArrayRec
	{
	char _autonumber, _growFast;
	int _count, _size;
	void **_items;
	};

XmLArray
XmLArrayNew(char autonumber,
	    char growFast)
	{
	XmLArray array;

	array = (XmLArray)malloc(sizeof(struct _XmLArrayRec));
	array->_count = 0;
	array->_size = 0;
	array->_items = 0;
	array->_autonumber = autonumber;
	array->_growFast = growFast;
	return array;
	}

void
XmLArrayFree(XmLArray array)
	{
	if (array->_items)
		free((char *)array->_items);
	free((char *)array);
	}

void
XmLArrayAdd(XmLArray array,
	    int pos,
	    int count)
	{
	int i;
	void **items;

	if (count < 1)
		return;
	if (pos < 0 || pos > array->_count)
		pos = array->_count;
	if (array->_count + count >= array->_size)
		{
		if (array->_growFast)
			{
			if (!array->_size)
				array->_size = count + 256;
			else
				array->_size = (array->_count + count) * 2;
			}
		else
			array->_size = array->_count + count;
		items = (void **)malloc(sizeof(void *) * array->_size);
		if (array->_items)
			{
			for (i = 0; i < array->_count; i++)
				items[i] = array->_items[i];
			free((char *)array->_items);
			}
		array->_items = items;
		}
	for (i = array->_count + count - 1; i >= pos + count; i--)
		{
		array->_items[i] = array->_items[i - count];
		if (array->_autonumber)
			((XmLArrayItem *)array->_items[i])->pos = i;
		}
	for (i = pos; i < pos + count; i++)
		array->_items[i] = 0;
	array->_count += count;
	}

int
XmLArrayDel(XmLArray array,
	    int pos,
	    int count)
	{
	int i;

	if (pos < 0 || pos + count > array->_count)
		return -1;
	for (i = pos; i < array->_count - count; i++)
		{
		array->_items[i] = array->_items[i + count];
		if (array->_autonumber)
			((XmLArrayItem *)array->_items[i])->pos = i;
		}
	array->_count -= count;
	if (!array->_count)
		{
		if (array->_items)
			free((char *)array->_items);
		array->_items = 0;
		array->_size = 0;
		}
	return 0;
	}

int
XmLArraySet(XmLArray array,
	    int pos,
	    void *item)
	{
	if (pos < 0 || pos >= array->_count)
		return -1;
	if (array->_items[pos])
		fprintf(stderr, "XmLArraySet: warning: overwriting pointer\n");
	array->_items[pos] = item;
	if (array->_autonumber)
		((XmLArrayItem *)array->_items[pos])->pos = pos;
	return 0;
	}

void *
XmLArrayGet(XmLArray array,
	    int pos)
	{
	if (pos < 0 || pos >= array->_count)
		return 0;
	return array->_items[pos];
	}

int
XmLArrayGetCount(XmLArray array)
	{
	return array->_count;
	}

int
XmLArrayMove(XmLArray array,
	     int newPos,
	     int pos,
	     int count)
	{
	void **items;
	int i;

	if (count <= 0)
		return -1;
	if (newPos < 0 || newPos + count > array->_count)
		return -1;
	if (pos < 0 || pos + count > array->_count)
		return -1;
	if (pos == newPos)
		return 0;
	/* copy items to move */
	items = (void **)malloc(sizeof(void *) * count);
	for (i = 0; i < count; i++)
		items[i] = array->_items[pos + i];
	/* move real items around */
	if (newPos < pos)
		for (i = pos + count - 1; i >= newPos + count; i--)
			{
			array->_items[i] = array->_items[i - count];
			if (array->_autonumber)
				((XmLArrayItem *)array->_items[i])->pos = i;
			}
	else
		for (i = pos; i < newPos; i++)
			{
			array->_items[i] = array->_items[i + count];
			if (array->_autonumber)
				((XmLArrayItem *)array->_items[i])->pos = i;
			}
	/* move items copy back */
	for (i = 0; i < count; i++)
		{
		array->_items[newPos + i] = items[i];
		if (array->_autonumber)
			((XmLArrayItem *)array->_items[newPos + i])->pos = newPos + i;
		}
	free((char *)items);
	return 0;
	}

int
XmLArrayReorder(XmLArray array,
		int *newPositions,
		int pos,
		int count)
	{
	int i;
	void **items;

	if (count <= 0)
		return -1;
	if (pos < 0 || pos + count > array->_count)
		return -1;
	for (i = 0; i < count; i++)
		{
		if (newPositions[i] < pos || newPositions[i] >= pos + count)
			return -1;
		}
	items = (void **)malloc(sizeof(void *) * count);
	for (i = 0; i < count; i++)
		items[i] = array->_items[newPositions[i]];
	for (i = 0; i < count; i++)
		{
		array->_items[pos + i] = items[i];
		if (array->_autonumber)
			((XmLArrayItem *)array->_items[pos + i])->pos = pos + i;
		}
	free((char *)items);
	return 0;
	}

int
XmLArraySort(XmLArray array,
	     XmLArrayCompareFunc compare,
	     void *userData,
	     int pos,
	     int count)
	{
	int i;

	if (pos < 0 || pos + count > array->_count)
		return -1;
	XmLSort(&array->_items[pos], count, sizeof(void *),
		(XmLSortCompareFunc)compare, userData);
	if (array->_autonumber)
		for (i = pos; i < pos + count; i++)
			((XmLArrayItem *)array->_items[i])->pos = i;
	return 0;
	}


Boolean
XmLCvtStringToUChar(Display *dpy,
		    char *resname,
		    XmLStringToUCharMap *map,
		    XrmValuePtr fromVal,
		    XrmValuePtr toVal)
{
	char *from;
	int i, /*num,*/ valid;

	from = (char *)fromVal->addr;
	valid = 0;
	i = 0;
	while (map[i].name)
		{
		if (!strcmp(from, map[i].name))
			{
			valid = 1;
			break;
			}
		i++;
		}
	if (!valid)
		{
		XtDisplayStringConversionWarning(dpy, from, resname);
		toVal->size = 0;
		toVal->addr = 0;
		return False;
		}
	if (toVal->addr)
		{
		if (toVal->size < sizeof(unsigned char))
			{
			toVal->size = sizeof(unsigned char);
			return False;
			}
		*(unsigned char *)(toVal->addr) = map[i].value;
		}
	else
		toVal->addr = (caddr_t)&map[i].value;
	toVal->size = sizeof(unsigned char);
	return True;
	}

int
XmLDateDaysInMonth(int m,
		   int y)
{
	static int d[12] = {31,28,31,30,31,30,31,31,30,31,30,31};

	if (m < 1 || m > 12 || y < 1753 || y > 9999)
		return -1;
	if (m == 2 && (!((y % 4) && (y % 100)) || !(y % 400)))
		return 29;
	return d[m - 1];
}

/* Calculation from Communications Of The ACM, Vol 6, No 8, p 444 */
/* sun is 0, sat is 6 */
int
XmLDateWeekDay(int m,
	       int d,
	       int y)
{
	long jd, j1, j2;

	if (m < 1 || m > 12 || d < 1 || d > XmLDateDaysInMonth(m, y) ||
		y < 1753 || y > 9999)
		return -1;
	if (m > 2)
		m -= 3;
	else
		{
		m += 9;
		y--;
		}
	j1 = y / 100;
	j2 = y - 100 * j1;
	jd = (146097 * j1) / 4 + (1461 * j2) / 4 + (153 * m + 2) / 5 +
		1721119 + d;
        return (jd + 1) % 7;
}

typedef struct
	{
	GC gc;
	int type;
	int dir;
	XFontStruct *fontStruct;
	} XmLDrawnBData;

void
XmLDrawnButtonSetType(Widget w,
		      int drawnType,
		      int drawnDir)
	{
	XmLDrawnBData *dd;
	XmDrawnButtonWidget b;
	XmString str;
	XmFontList fontlist;
	XGCValues values;
	XtGCMask mask;
	Dimension width, height, dim;
	Dimension highlightThickness, shadowThickness;
	Dimension marginWidth, marginHeight;
	Dimension marginTop, marginBottom, marginLeft, marginRight;

	if (!XtIsSubclass(w, xmDrawnButtonWidgetClass))
		{
		XmLWarning(w, "DrawnButtonSetType() - not an XmDrawnButton");
		return;
		}
	XtVaSetValues(w,
		XmNpushButtonEnabled, True,
		NULL);
	XtRemoveAllCallbacks(w, XmNexposeCallback);
	XtRemoveAllCallbacks(w, XmNresizeCallback);
	if (drawnType == XmDRAWNB_STRING && drawnDir == XmDRAWNB_RIGHT)
		{
		XtVaSetValues(w,
			XmNlabelType, XmSTRING,
			NULL);
		return;
		}
	b = (XmDrawnButtonWidget)w;
	dd = (XmLDrawnBData *)malloc(sizeof(XmLDrawnBData));
	dd->type = drawnType;
	dd->dir = drawnDir;
	dd->gc = 0;
	if (dd->type == XmDRAWNB_STRING)
		{
		XtVaGetValues(w,
			XmNlabelString, &str,
			XmNfontList, &fontlist,
			XmNhighlightThickness, &highlightThickness,
			XmNshadowThickness, &shadowThickness,
			XmNmarginHeight, &marginHeight,
			XmNmarginWidth, &marginWidth,
			XmNmarginTop, &marginTop,
			XmNmarginBottom, &marginBottom,
			XmNmarginLeft, &marginLeft,
			XmNmarginRight, &marginRight,
			NULL);
		if (!str && XtName(w))
			str = XmStringCreateSimple(XtName(w));
		if (!str)
			str = XmStringCreateSimple("");
		XmStringExtent(fontlist, str, &width, &height);
		XmStringFree(str);
		if (drawnDir == XmDRAWNB_UP || drawnDir == XmDRAWNB_DOWN)
			{
			dim = width;
			width = height;
			height = dim;
			}
		height += (highlightThickness + shadowThickness +
			marginHeight) * 2 + marginTop + marginBottom;
		width += (highlightThickness + shadowThickness +
			marginWidth) * 2 + marginLeft + marginRight;
		/* change to pixmap type so label string isnt drawn */
		XtVaSetValues(w,
			XmNlabelType, XmPIXMAP,
			NULL);
		XtVaSetValues(w,
			XmNwidth, width,
			XmNheight, height,
			NULL);
		XtAddCallback(w, XmNexposeCallback, XmLDrawnBDrawStringCB,
			(XtPointer)dd);
		XtAddCallback(w, XmNresizeCallback, XmLDrawnBDrawStringCB,
			(XtPointer)dd);
		}
	else
		{
		mask = GCForeground;
		values.foreground = b->primitive.foreground;
		dd->gc = XtGetGC(w, mask, &values);
		XtAddCallback(w, XmNexposeCallback, XmLDrawnBDrawCB, (XtPointer)dd);
		XtAddCallback(w, XmNresizeCallback, XmLDrawnBDrawCB, (XtPointer)dd);
		}
	XtAddCallback(w, XmNdestroyCallback, XmLDrawnBDestroyCB, (XtPointer)dd);
	}

static void
XmLDrawnBDestroyCB(Widget w,
		   XtPointer clientData,
		   XtPointer callData)
	{
	XmLDrawnBData *dd;

	dd = (XmLDrawnBData *)clientData;
	if (dd->type == XmDRAWNB_STRING)
		{
		if (dd->gc)
			{
			XFreeGC(XtDisplay(w), dd->gc);
			XFreeFont(XtDisplay(w), dd->fontStruct);
			}
		}
	else
		XtReleaseGC(w, dd->gc);
	free((char *)dd);
	}

static void
XmLDrawnBDrawStringCB(Widget w,
		      XtPointer clientData,
		      XtPointer callData)
	{
	XmLDrawnBData *dd;
	XmFontList fontlist;
	XmString str;
	XmStringDirection stringDir;
	unsigned char drawDir, alignment;
	int width, height, xoff, yoff, drawWidth;
	Pixel fg;
	Dimension highlightThickness;
	Dimension shadowThickness, marginWidth, marginHeight;
	Dimension marginLeft, marginRight, marginTop, marginBottom;

	if (!XtIsRealized(w))
		return;
	dd = (XmLDrawnBData *)clientData;
	XtVaGetValues(w,
		XmNlabelString, &str,
		NULL);
	if (!str && XtName(w))
		str = XmStringCreateSimple(XtName(w));
	if (!str)
		return;
	XtVaGetValues(w,
		XmNforeground, &fg,
		XmNfontList, &fontlist,
		XmNalignment, &alignment,
		XmNhighlightThickness, &highlightThickness,
		XmNshadowThickness, &shadowThickness,
		XmNmarginWidth, &marginWidth,
		XmNmarginHeight, &marginHeight, 
		XmNmarginLeft, &marginLeft,
		XmNmarginRight, &marginRight,
		XmNmarginTop, &marginTop,
		XmNmarginBottom, &marginBottom,
		NULL);
	xoff = highlightThickness + shadowThickness + marginLeft + marginWidth;
	yoff = highlightThickness + shadowThickness + marginTop + marginHeight;
	width = XtWidth(w) - xoff - xoff + marginLeft - marginRight;
	height = XtHeight(w) - yoff - yoff + marginTop - marginBottom;
	if (XmIsManager(XtParent(w)))
		XtVaGetValues(XtParent(w),
			XmNstringDirection, &stringDir,
			NULL);
	else
		stringDir = XmSTRING_DIRECTION_L_TO_R;
	switch (dd->dir)
		{
		case XmDRAWNB_LEFT:
			drawDir = XmSTRING_LEFT;
			break;
		case XmDRAWNB_UP:
			drawDir = XmSTRING_UP;
			break;
		case XmDRAWNB_DOWN:
			drawDir = XmSTRING_DOWN;
			break;
		default:
			drawDir = XmSTRING_RIGHT;
			break;
		}
	if (drawDir == XmSTRING_LEFT || drawDir == XmSTRING_RIGHT)
		drawWidth = width;
	else
		drawWidth = height;
	if (!dd->gc)
		{
		dd->gc = XCreateGC(XtDisplay(w), XtWindow(w), 0, NULL);
		dd->fontStruct = XLoadQueryFont(XtDisplay(w), "fixed");
		if (!dd->fontStruct)
			{
			XmLWarning(w, "DrawnBDrawString() - FATAL can't load fixed font");
			return;
			}
		XSetFont(XtDisplay(w), dd->gc, dd->fontStruct->fid);
		}
	XSetForeground(XtDisplay(w), dd->gc, fg);
	XmLStringDrawDirection(XtDisplay(w), XtWindow(w), fontlist,
		str, dd->gc, xoff, yoff, drawWidth, alignment, stringDir, drawDir);
	XmStringFree(str);
	}

static void
XmLDrawnBDrawCB(Widget w,
		XtPointer clientData,
		XtPointer callData)
	{
	XmLDrawnBData *dd;
	XmDrawnButtonWidget b;
	/*	unsigned char drawDir;*/
	/*	unsigned char alignment;*/
	Display *dpy;
	Window win;
	GC gc;
	XPoint p[2][5];
	XSegment seg;
	int np[2];
	int i, j, temp;
	int md, type, dir;
	int avgx, avgy, xoff, yoff, st;

	if (!XtIsRealized(w))
		return;
	dd = (XmLDrawnBData *)clientData;
	type = dd->type;
	dir = dd->dir;
	gc = dd->gc;
	b = (XmDrawnButtonWidget)w;
	win = XtWindow(w);
	dpy = XtDisplay(w);
	st = b->primitive.shadow_thickness;
	i = st * 2 + b->primitive.highlight_thickness * 2;
	/* calculate max dimension */
	md = XtWidth(w) - i;
	if (md > ((int)XtHeight(w) - i))
		md = XtHeight(w) - i;
	if (md < 4)
		return;
	xoff = ((int)XtWidth(w) - md) / 2;
	yoff = ((int)XtHeight(w) - md) / 2;
	np[0] = 0;
	np[1] = 0;
	switch (type)
		{
		case XmDRAWNB_SMALLARROW:
			p[0][0].x = md / 4;
			p[0][0].y = md / 4;
			p[0][1].x = md / 4;
			p[0][1].y = md - md / 4;
			p[0][2].x = md - md / 4;
			p[0][2].y = md / 2;
			np[0] = 3;
			break;
		case XmDRAWNB_ARROW:
			p[0][0].x = md / 6;
			p[0][0].y = md / 6;
			p[0][1].x = md / 6;
			p[0][1].y = md - md / 6;
			p[0][2].x = md - md / 6;
			p[0][2].y = md / 2;
			np[0] = 3;
			break;
		case XmDRAWNB_ARROWLINE:
			p[0][0].x = md / 5;
			p[0][0].y = md / 5;
			p[0][1].x = md / 5;
			p[0][1].y = md - md / 5;
			p[0][2].x = md - md / 5;
			p[0][2].y = md / 2;
			np[0] = 3;
			p[1][0].x = md - md / 5 + 1;
			p[1][0].y = md / 5;
			p[1][1].x = md - md / 5 + 1;
			p[1][1].y = md - md / 5;
			p[1][2].x = md - md / 10;
			p[1][2].y = md - md / 5;
			p[1][3].x = md - md / 10;
			p[1][3].y = md / 5;
			np[1] = 4;
			break;
		case XmDRAWNB_DOUBLEARROW:
			/* odd major dimensions can give jagged lines */
			if (md % 2)
				md -= 1;
			p[0][0].x = md / 10;
			p[0][0].y = md / 10;
			p[0][1].x = md / 10;
			p[0][1].y = md - md / 10;
			p[0][2].x = md / 2;
			p[0][2].y = md / 2;
			np[0] = 3;
			p[1][0].x = md - md / 2;
			p[1][0].y = md / 10;
			p[1][1].x = md - md / 2;
			p[1][1].y = md - md / 10;
			p[1][2].x = md - md / 10;
			p[1][2].y = md / 2;
			np[1] = 3;
			break;
		case XmDRAWNB_SQUARE:
			p[0][0].x = md / 3;
			p[0][0].y = md / 3;
			p[0][1].x = md / 3;
			p[0][1].y = md - md / 3;
			p[0][2].x = md - md / 3;
			p[0][2].y = md - md / 3;
			p[0][3].x = md - md / 3;
			p[0][3].y = md / 3;
			np[0] = 4;
			break;
		case XmDRAWNB_DOUBLEBAR:
			p[0][0].x = md / 3;
			p[0][0].y = md / 4;
			p[0][1].x = md / 3;
			p[0][1].y = md - md / 4;
			p[0][2].x = md / 2 - md / 10;
			p[0][2].y = md - md / 4;
			p[0][3].x = md / 2 - md / 10;
			p[0][3].y = md / 4;
			np[0] = 4;
			p[1][0].x = md - md / 3;
			p[1][0].y = md / 4;
			p[1][1].x = md - md / 3;
			p[1][1].y = md - md / 4;
			p[1][2].x = md - md / 2 + md / 10;
			p[1][2].y = md - md / 4;
			p[1][3].x = md - md / 2 + md / 10;
			p[1][3].y = md / 4;
			np[1] = 4;
			break;
		}
	for (i = 0; i < 2; i++)
		{
		avgx = 0;
		avgy = 0;
		for (j = 0; j < np[i]; j++)
			{
			switch (dir)
				{
				case XmDRAWNB_RIGHT:
					/* points unchanged */
					break;
				case XmDRAWNB_LEFT:
					p[i][j].x = md - p[i][j].x - 1;
					break;
				case XmDRAWNB_UP:
					temp = p[i][j].x;
					p[i][j].x = p[i][j].y;
					p[i][j].y = md - temp;
					break;
				case XmDRAWNB_DOWN:
					temp = p[i][j].x;
					p[i][j].x = p[i][j].y;
					p[i][j].y = temp;
					break;
			}
			p[i][j].x += xoff;
			p[i][j].y += yoff;
			avgx += p[i][j].x;
			avgy += p[i][j].y;
			}
		if (!np[i])
			continue;
		avgx /= np[i];
		avgy /= np[i];
		XFillPolygon(dpy, win, gc, p[i], np[i], Nonconvex, CoordModeOrigin);
		p[i][np[i]].x = p[i][0].x;
		p[i][np[i]].y = p[i][0].y;
		for (j = 0; j < np[i]; j++)
			{
			seg.x1 = p[i][j].x;
			seg.y1 = p[i][j].y;
			seg.x2 = p[i][j + 1].x;
			seg.y2 = p[i][j + 1].y;
			if ((seg.x1 <= avgx && seg.x2 <= avgx) ||
				(seg.y1 <= avgy && seg.y2 <= avgy))
				XDrawSegments(dpy, win,
					b->primitive.bottom_shadow_GC, &seg, 1);
			else
				XDrawSegments(dpy, win,
					b->primitive.top_shadow_GC, &seg, 1);
			}
		}
	}

#define XmLDrawNODRAW  0
#define XmLDrawNOCLIP  1
#define XmLDrawCLIPPED 2

static int
XmLDrawCalc(Widget w,
	    Dimension width,
	    Dimension height,
	    unsigned char alignment,
	    XRectangle *rect,
	    XRectangle *clipRect,
	    int *x,
	    int *y)
	{
	if (rect->width <= 4 || rect->height <= 4 ||
		clipRect->width < 3 || clipRect->height < 3 ||
		!width || !height ||
		!XtIsRealized(w) ||
		XmLRectIntersect(rect, clipRect) == XmLRectOutside)
		return XmLDrawNODRAW;
	if (alignment == XmALIGNMENT_TOP_LEFT ||
		alignment == XmALIGNMENT_LEFT ||
		alignment == XmALIGNMENT_BOTTOM_LEFT)
		*x = rect->x + 2;
	else if (alignment == XmALIGNMENT_TOP ||
		alignment == XmALIGNMENT_CENTER ||
		alignment == XmALIGNMENT_BOTTOM)
		*x = rect->x + ((int)rect->width - (int)width) / 2;
	else
		*x = rect->x + rect->width - width - 2;
	if (alignment == XmALIGNMENT_TOP ||
		alignment == XmALIGNMENT_TOP_LEFT ||
		alignment == XmALIGNMENT_TOP_RIGHT)
		*y = rect->y + 2;
	else if (alignment == XmALIGNMENT_LEFT ||
		alignment == XmALIGNMENT_CENTER ||
		alignment == XmALIGNMENT_RIGHT)
		*y = rect->y + ((int)rect->height - (int)height) / 2;
	else
		*y = rect->y + rect->height - height - 2;
	if (clipRect->x == rect->x &&
		clipRect->y == rect->y &&
		clipRect->width == rect->width &&
		clipRect->height == rect->height &&
		(int)width + 4 <= (int)clipRect->width &&
		(int)height + 4 <= (int)clipRect->height)
		return XmLDrawNOCLIP;
	return XmLDrawCLIPPED;
	}

void
XmLDrawToggle(Widget w,
	      Boolean state,
	      Dimension size,
	      unsigned char alignment,
	      GC gc,
	      Pixel backgroundColor,
	      Pixel topColor,
	      Pixel bottomColor,
	      Pixel checkColor,
	      XRectangle *rect,
	      XRectangle *clipRect)
	{
	Display *dpy;
	Window win;
	XPoint point[5];
	int x, y, cx[3], cy[4], drawType;

	drawType = XmLDrawCalc(w, size, size, alignment, rect, clipRect, &x, &y);
	if (size < 3 || drawType == XmLDrawNODRAW)
		return;
	dpy = XtDisplay(w);
	win = XtWindow(w);
	if (drawType == XmLDrawCLIPPED)
		XSetClipRectangles(dpy, gc, 0, 0, clipRect, 1, Unsorted);
	/* background */
	XSetForeground(dpy, gc, backgroundColor);
	XFillRectangle(dpy, win, gc, x, y, size, size);
	/* box shadow */
	XSetForeground(dpy, gc, topColor);
	point[0].x = x;
	point[0].y = y + size - 1;
	point[1].x = x;
	point[1].y = y;
	point[2].x = x + size - 1;
	point[2].y = y;
	XDrawLines(dpy, win, gc, point, 3, CoordModeOrigin);
	point[1].x = x + size - 1;
	point[1].y = y + size - 1;
	XSetForeground(dpy, gc, bottomColor);
	XDrawLines(dpy, win, gc, point, 3, CoordModeOrigin);
	if (state == True)
		{
		/* check */
		cx[0] = x + 1;
		cx[1] = x + (((int)size - 3) / 3) + 1;
		cx[2] = x + size - 2;
		cy[0] = y + 1;
		cy[1] = y + (((int)size - 3) / 2) + 1;
		cy[2] = y + ((((int)size - 3) * 2) / 3) + 1;
		cy[3] = y + size - 2;
		point[0].x = cx[0];
		point[0].y = cy[1];
		point[1].x = cx[1];
		point[1].y = cy[3];
		point[2].x = cx[2];
		point[2].y = cy[0];
		point[3].x = cx[1];
		point[3].y = cy[2];
		point[4].x = point[0].x;
		point[4].y = point[0].y;
		XSetForeground(dpy, gc, checkColor);
		XFillPolygon(dpy, win, gc, point, 4, Nonconvex, CoordModeOrigin);
		XDrawLines(dpy, win, gc, point, 5, CoordModeOrigin);
		}
	if (drawType == XmLDrawCLIPPED)
		XSetClipMask(dpy, gc, None);
	}

int
XmLRectIntersect(XRectangle *r1,
		 XRectangle *r2)
	{
	if (!r1->width || !r1->height || !r2->width || !r2->height)
		return XmLRectOutside;
	if (r1->x + (int)r1->width - 1 < r2->x ||
		r1->x > r2->x + (int)r2->width - 1 ||
		r1->y + (int)r1->height - 1 < r2->y ||
		r1->y > r2->y + (int)r2->height - 1)
		return XmLRectOutside;
	if (r1->x >= r2->x &&
		r1->x + (int)r1->width <= r2->x + (int)r2->width &&
		r1->y >= r2->y &&
		r1->y + (int)r1->height <= r2->y + (int)r2->height)
		return XmLRectInside; /* r1 inside r2 */
	return XmLRectPartial;
	}


XmFontList
XmLFontListCopyDefault(Widget widget)
	{
	Widget parent;
	XFontStruct *font;
	XmFontList fontList, fl;

	fontList = 0;
	parent = XtParent(widget);
	while (parent)
		{
		fl = 0;
		if (XmIsVendorShell(parent) || XmIsMenuShell(parent))
			XtVaGetValues(parent, XmNdefaultFontList, &fl, NULL);
		else if (XmIsBulletinBoard(parent))
			XtVaGetValues(parent, XmNbuttonFontList, &fl, NULL);
		if (fl)
			{
			fontList = XmFontListCopy(fl);
			parent = 0;
			}
		if (parent)
			parent = XtParent(parent);
		}
	if (!fontList)
		{
		font = XLoadQueryFont(XtDisplay(widget), "fixed");
		if (!font)
			XmLWarning(widget,
				"FontListCopyDefault() - FATAL ERROR - can't load fixed font");
		fontList = XmFontListCreate(font, XmSTRING_DEFAULT_CHARSET);
		}
	return fontList;
	}

void
XmLFontListGetDimensions(XmFontList fontList,
			 short *width,
			 short *height,
			 Boolean useAverageWidth)
	{
	XmStringCharSet charset;
	XmFontContext context;
	XFontStruct *fs;
	short w, h;
#if XmVersion < 2000
	/* --- begin code to work around Motif 1.x internal bug */
	typedef struct {
		XmFontList nextFontList;
		Boolean unused;
	} XmFontListContextRec;
	typedef struct {
		XFontStruct *font;
		XmStringCharSet unused;
	} XmFontListRec;
	XmFontList nextFontList;
#endif

	*width = 0;
	*height = 0;
	if (XmFontListInitFontContext(&context, fontList))
		{
		while (1)
			{
#if XmVersion < 2000
			/* --- begin code to work around Motif internal bug */
			/* --- this code must be removed for Motif 2.0    */
			nextFontList = ((XmFontListContextRec *)context)->nextFontList;
			if (!nextFontList)
				break;
			if (!((XmFontListRec *)nextFontList)->font)
				break;
			/* --- end Motif workaround code */
#endif
			if (XmFontListGetNextFont(context, &charset, &fs) == False)
				break;
			XtFree(charset);
			if (useAverageWidth == True)
				XmLFontGetAverageWidth(fs, &w);
			else
				w = fs->max_bounds.width;
			h = fs->max_bounds.ascent + fs->max_bounds.descent;
			if (*height < h)
				*height = h;
			if (*width < w)
				*width = w;
			}	
		XmFontListFreeFontContext(context);
		}
	}

static void
XmLFontGetAverageWidth(XFontStruct *fs,
		       short *width)
	{
	long aw, n;
	int r, c, mm, i;
	XCharStruct *cs;

	n = 0;
	aw = 0;
	mm = fs->max_char_or_byte2 - fs->min_char_or_byte2 + 1;
	for (r = fs->min_byte1; r <= fs->max_byte1; r++)
		for (c = fs->min_char_or_byte2; c <= fs->max_char_or_byte2; c++)
			{
			if (!fs->per_char)
				continue;
			i = ((r - fs->min_byte1) * mm) + (c - fs->min_char_or_byte2);
			cs = &fs->per_char[i];
			if (!cs->width)
				continue;
			aw += cs->width;
			n++;
			}
	if (n)
		aw = aw / n;
	else
		aw = fs->min_bounds.width;
	*width = (short)aw;
	}

int _XmLKey;

void XmLInitialize(void)
	{
	static int first = 1;
	
	if (!first)
		return;
	first = 0;

#ifdef XmLEVAL
	fprintf(stderr, "XmL: This is an evalation version of the Microline\n");
	fprintf(stderr, "XmL: Widget Library.  Some features are disabled.\n");
#endif

#ifdef XmLJAVA
	if (_XmLKey != 444)
		{
		fprintf(stderr, "XmL: Error: This version of the library will only");
		fprintf(stderr, "XmL: work with JAVA.\n");
		exit(0);
		}
#endif
	}

int
XmLMessageBox(Widget w,
	      char *string,
	      Boolean okOnly)
	{
	int status = 0;
	Widget dialog, shell;
	Arg args[3];
	XtAppContext context;
	XmString str, titleStr;
	String shellTitle;
	Atom WM_DELETE_WINDOW;

	str = XmStringCreateLtoR(string, XmSTRING_DEFAULT_CHARSET);
	XtSetArg(args[0], XmNmessageString, str);
	XtSetArg(args[1], XmNdialogStyle, XmDIALOG_APPLICATION_MODAL);
	shell = XmLShellOfWidget(w);
	if (shell)
		XtVaGetValues(shell, XmNtitle, &shellTitle, NULL);
	if (shell && shellTitle)
		titleStr = XmStringCreateLtoR(shellTitle,
			XmSTRING_DEFAULT_CHARSET);
	else
		titleStr = XmStringCreateSimple("Notice");
	XtSetArg(args[2], XmNdialogTitle, titleStr);
	if (okOnly == True)
		dialog = XmCreateMessageDialog(XtParent(w), "popup", args, 3);
	else
		dialog = XmCreateQuestionDialog(XtParent(w), "popup", args, 3);
	WM_DELETE_WINDOW = XmInternAtom(XtDisplay(w), "WM_DELETE_WINDOW",
		False);
	XmAddWMProtocolCallback(shell, WM_DELETE_WINDOW, XmLMessageBoxWMDelete,
		(caddr_t)&status);
	XmStringFree(str);
	XmStringFree(titleStr);
	XtAddCallback(dialog, XmNokCallback, XmLMessageBoxResponse,
		(XtPointer)&status);
	if (okOnly == True)
		{
		XtUnmanageChild(XmMessageBoxGetChild(dialog,
			XmDIALOG_CANCEL_BUTTON));
		XtUnmanageChild(XmMessageBoxGetChild(dialog,
			XmDIALOG_HELP_BUTTON));
		}
	else
		{
		XtAddCallback(dialog, XmNcancelCallback, XmLMessageBoxResponse,
			(XtPointer)&status);
		XtAddCallback(dialog, XmNhelpCallback, XmLMessageBoxResponse,
			(XtPointer)&status);
		}
	XtManageChild(dialog);

	context = XtWidgetToApplicationContext(w);
	while (!status ||  XtAppPending(context))
		XtAppProcessEvent(context, XtIMAll);
	XtDestroyWidget(dialog);
	return status;
	}

static void
XmLMessageBoxWMDelete(Widget w,
		      XtPointer clientData,
		      XtPointer callData)
	{
	int *status = (int *)clientData;
	*status = 1;
	}

static void
XmLMessageBoxResponse(Widget w,
		      XtPointer clientData,
		      XtPointer callData)
	{
	int *status = (int *)clientData;
	XmAnyCallbackStruct *reason;

	reason = (XmAnyCallbackStruct *)callData;
	switch (reason->reason)
		{
		case XmCR_OK:
			*status = 1;
			break;
		case XmCR_CANCEL:
			*status = 2;
			break;
		case XmCR_HELP:
			*status = 3;
			break;
		}
	}

void
XmLPixmapDraw(Widget w,
	      Pixmap pixmap,
	      Pixmap pixmask,
	      int pixmapWidth,
	      int pixmapHeight,
	      unsigned char alignment,
	      GC gc,
	      XRectangle *rect,
	      XRectangle *clipRect)
	{
	Display *dpy;
	Window win;
	int px, py, x, y, width, height, drawType;

	if (pixmap == XmUNSPECIFIED_PIXMAP)
		return;
	dpy = XtDisplay(w);
	win = XtWindow(w);
	width = pixmapWidth;
	height = pixmapHeight;
	if (!width || !height)
		{
		alignment = XmALIGNMENT_TOP_LEFT;
		width = clipRect->width - 4;
		height = clipRect->height - 4;
		}
	drawType = XmLDrawCalc(w, width, height, alignment,
		rect, clipRect, &x, &y);
	if (drawType == XmLDrawNODRAW)
		return;
	px = 0;
	py = 0;
	/* clip top */
	if (clipRect->y > y && clipRect->y < y + height - 1)
		{
		py = clipRect->y - y;
		y += py;
		height -= py;
		}
	/* clip bottom */
	if (clipRect->y + (int)clipRect->height - 1 >= y &&
		clipRect->y + (int)clipRect->height - 1 <= y + height - 1)
		height = clipRect->y + clipRect->height - y;
	/* clip left */
	if (clipRect->x > x && clipRect->x < x + width - 1)
		{
		px = clipRect->x - x;
		x += px;
		width -= px;
		}
	/* clip right */
	if (clipRect->x + (int)clipRect->width - 1 >= x &&
		clipRect->x + (int)clipRect->width - 1 <= x + width - 1)
		width = clipRect->x + clipRect->width - x;

	if (pixmask != XmUNSPECIFIED_PIXMAP)
		{
		XSetClipMask(dpy, gc, pixmask);
		XSetClipOrigin(dpy, gc, x - px, y - py);
		}
	XSetGraphicsExposures(dpy, gc, False);
	XCopyArea(dpy, pixmap, win, gc, px, py, width, height, x, y);
	XSetGraphicsExposures(dpy, gc, True);
	if (pixmask != XmUNSPECIFIED_PIXMAP)
		{
		XSetClipMask(dpy, gc, None);
		XSetClipOrigin(dpy, gc, 0, 0);
		}
	}

Widget
XmLShellOfWidget(Widget w)
	{
	while(1)
		{
		if (!w)
			return 0;
		if (XtIsSubclass(w, shellWidgetClass))
			return w;
		w = XtParent(w);
		}	
	}

static XmLSortCompareFunc XmLSortCompare;
static int XmLSortEleSize;
static void *XmLSortUserData;

void
XmLSort(void *base,
	int numItems,
	unsigned int itemSize,
	XmLSortCompareFunc compare,
	void *userData)
	{
	XmLSortCompareFunc oldCompare;
	int oldEleSize;
	void *oldUserData;
	char *lvec, *rvec;

	if (numItems < 2)
		return;

	/* for sorts within a sort compare function, we must
	   save any global sort variables on the local stack
	   and restore them when finished */
	oldCompare = XmLSortCompare;
	oldEleSize = XmLSortEleSize;
	oldUserData = XmLSortUserData;
	XmLSortCompare = compare;
	XmLSortEleSize = itemSize;
	XmLSortUserData = userData;

	lvec = (char *)base;
	rvec = lvec + (numItems - 1) * itemSize;
	XmLSortFunc(lvec, rvec);

	XmLSortCompare = oldCompare;
	XmLSortEleSize = oldEleSize;
	XmLSortUserData = oldUserData;
	}

#define SWAP(p1, p2) \
		{ \
		if (p1 != p2) \
			{ \
			int zi; \
			char zc; \
			for (zi = 0; zi < XmLSortEleSize; zi++) \
				{ \
				zc = (p1)[zi]; \
				(p1)[zi] = (p2)[zi]; \
				(p2)[zi] = zc; \
				} \
			}\
		}

static void
XmLSortFunc(char *lvec,
	    char *rvec)
	{
	int i;
	char *nlvec, *nrvec, *pvec;

start:
	i = (*XmLSortCompare)(XmLSortUserData, lvec, rvec);

	/* two item sort */
	if (rvec == lvec + XmLSortEleSize)
		{
		if (i > 0)
			SWAP(lvec, rvec)
		return;
		}

	/* find mid of three items */
	pvec = lvec + ((rvec - lvec) / (XmLSortEleSize * 2)) * XmLSortEleSize;
	if (i < 0)
		{
		i = (*XmLSortCompare)(XmLSortUserData, lvec, pvec);
		if (i > 0)
			pvec = lvec;
		else if (i == 0)
			pvec = rvec;
		}
	else if (i > 0)
		{
		i = (*XmLSortCompare)(XmLSortUserData, rvec, pvec);
		if (i > 0)
			pvec = rvec;
		else if (i == 0)
			pvec = lvec;
		}
	else
		{
		pvec = lvec + XmLSortEleSize;
		while (1)
			{
			i = (*XmLSortCompare)(XmLSortUserData, lvec, pvec);
			if (i < 0)
				break;
			else if (i > 0)
				{
				pvec = lvec;
				break;
				}
			if (pvec == rvec)
				return;
			pvec += XmLSortEleSize;
			}
		}

	/* partition the set */
	nlvec = lvec;
	nrvec = rvec;
	while (1)
		{
		if (pvec == nrvec)
			pvec = nlvec;
		else if (pvec == nlvec)
			pvec = nrvec;
		SWAP(nrvec, nlvec)
		while ((*XmLSortCompare)(XmLSortUserData, nlvec, pvec) < 0)
			nlvec += XmLSortEleSize;
		while ((*XmLSortCompare)(XmLSortUserData, nrvec, pvec) >= 0)
			nrvec -= XmLSortEleSize;
		if (nlvec > nrvec)
			break;
		}

	/* sort partitioned sets */
	if (lvec < nlvec - XmLSortEleSize)
		XmLSortFunc(lvec, nlvec - XmLSortEleSize);
	if (nlvec < rvec)
		{
		lvec = nlvec;
		goto start;
		}
	}

void
XmLStringDraw(Widget w,
	      XmString string,
	      XmStringDirection stringDir,
	      XmFontList fontList,
	      unsigned char alignment,
	      GC gc,
	      XRectangle *rect,
	      XRectangle *clipRect)
	{
	Display *dpy;
	Window win;
	Dimension width, height;
	int x, y, drawType;
	unsigned char strAlignment;

	if (!string)
		return;
	dpy = XtDisplay(w);
	win = XtWindow(w);
	XmStringExtent(fontList, string, &width, &height);
	drawType = XmLDrawCalc(w, width, height, alignment,
		rect, clipRect, &x, &y);
	if (drawType == XmLDrawNODRAW)
		return;
	x = rect->x + 2;
	if (alignment == XmALIGNMENT_LEFT ||
		alignment == XmALIGNMENT_TOP_LEFT ||
		alignment == XmALIGNMENT_BOTTOM_LEFT)
		strAlignment = XmALIGNMENT_BEGINNING;
	else if (alignment == XmALIGNMENT_CENTER ||
		alignment == XmALIGNMENT_TOP ||
		alignment == XmALIGNMENT_BOTTOM)
		strAlignment = XmALIGNMENT_CENTER;
	else
		strAlignment = XmALIGNMENT_END;
	/* XmStringDraw clipping doesnt work in all cases
	   so we use a clip region for clipping */
	if (drawType == XmLDrawCLIPPED)
		XSetClipRectangles(dpy, gc, 0, 0, clipRect, 1, Unsorted);
	XmStringDraw(dpy, win, fontList, string, gc,
		x, y, rect->width - 4, strAlignment, stringDir, clipRect);
	if (drawType == XmLDrawCLIPPED)
		XSetClipMask(dpy, gc, None);
	}

void
XmLStringDrawDirection(Display *dpy,
		       Window win,
		       XmFontList fontlist,
		       XmString string,
		       GC gc,
		       int x,
		       int y,
		       Dimension width,
		       unsigned char alignment,
		       unsigned char layout_direction,
		       unsigned char drawing_direction)
{
	Screen *screen;
	XFontStruct *fontStruct;
	XImage *sourceImage, *destImage;
	Pixmap pixmap;
	GC pixmapGC;
	/*	int sourceWidth, sourceHeight;*/
	int destWidth, destHeight;
	int stringWidth, stringHeight;
	int i, j, bytesPerLine;
	Dimension dW, dH;
	char *data;

	screen = DefaultScreenOfDisplay(dpy);
	XmStringExtent(fontlist, string, &dW, &dH);
	stringWidth = (int)dW;
	stringHeight = (int)dH;
	if (!stringWidth || !stringHeight)
		return;

	/* draw string into 1 bit deep pixmap */
	pixmap = XCreatePixmap(dpy, win, stringWidth, stringHeight, 1);
	pixmapGC = XCreateGC(dpy, pixmap, 0, NULL);
	fontStruct = XLoadQueryFont(dpy, "fixed");
	if (!fontStruct)
		{
		fprintf(stderr, "XmLStringDrawDirection: error - ");
		fprintf(stderr, "can't load fixed font\n");
		return;
		}
	XSetFont(dpy, pixmapGC, fontStruct->fid);
	XSetBackground(dpy, pixmapGC, 0L);
	XSetForeground(dpy, pixmapGC, 0L);
	XFillRectangle(dpy, pixmap, pixmapGC, 0, 0, stringWidth, stringHeight);
	XSetForeground(dpy, pixmapGC, 1L);
	XmStringDraw(dpy, pixmap, fontlist, string, pixmapGC, 0, 0, stringWidth,
		XmALIGNMENT_BEGINNING, layout_direction, 0);
	XFreeFont(dpy, fontStruct);

	/* copy 1 bit deep pixmap into source image */
	sourceImage = XGetImage(dpy, pixmap, 0, 0, stringWidth, stringHeight,
		1, XYPixmap);
	XFreePixmap(dpy, pixmap);

	/* draw rotated text into destination image */
	if (drawing_direction == XmSTRING_UP || drawing_direction == XmSTRING_DOWN)
		{
		destWidth = stringHeight;
		destHeight = stringWidth;
		}
	else
		{
		destWidth = stringWidth;
		destHeight = stringHeight;
		}
	bytesPerLine  = (destWidth - 1) / 8 + 1;
	data = (char *)malloc(bytesPerLine * destHeight);
	destImage = XCreateImage(dpy, DefaultVisualOfScreen(screen),
	    1, XYBitmap, 0, data, destWidth, destHeight, 8, 0);
	for (i = 0; i < stringWidth; i++)
		for (j = 0; j < stringHeight; j++)
			{
			if (drawing_direction == XmSTRING_UP)
				XPutPixel(destImage, j, i,
					XGetPixel(sourceImage, stringWidth - i - 1, j));
			else if (drawing_direction == XmSTRING_DOWN)
				XPutPixel(destImage, stringHeight - j - 1, stringWidth - i - 1,
					XGetPixel(sourceImage, stringWidth - i - 1, j));
			else if (drawing_direction == XmSTRING_LEFT)
				XPutPixel(destImage, i, stringHeight - j - 1,
					XGetPixel(sourceImage, stringWidth - i - 1, j));
			else
				XPutPixel(destImage, i, j,
					XGetPixel(sourceImage, i, j));
			}
	XDestroyImage(sourceImage);

	/* copy rotated image into 1 bit deep pixmap */
	pixmap = XCreatePixmap(dpy, win, destWidth, destHeight, 1);
	XPutImage(dpy, pixmap, pixmapGC, destImage, 0, 0, 0, 0,
	    destWidth, destHeight);
	XDestroyImage(destImage);
	XFreeGC(dpy, pixmapGC);

	/* adjust position for alignment */
	if (drawing_direction == XmSTRING_UP || drawing_direction == XmSTRING_DOWN)
		{
		if (alignment == XmALIGNMENT_BEGINNING)
			;
		else if (alignment == XmALIGNMENT_CENTER)
			y += width / 2 - stringWidth / 2;
		else if (alignment == XmALIGNMENT_END)
			y += (int)width - stringWidth;
		}
	else
		{
		if (alignment == XmALIGNMENT_BEGINNING)
			;
		else if (alignment == XmALIGNMENT_CENTER)
			x += width / 2 - stringWidth / 2;
		else if (alignment == XmALIGNMENT_END)
			x += (int)width - stringWidth;
		}

	/* draw the pixmap as a stipple in the window */
	XSetStipple(dpy, gc, pixmap);
	XSetFillStyle(dpy, gc, FillStippled);
	XSetTSOrigin(dpy, gc, x % destWidth, y % destHeight);
	XFillRectangle(dpy, win, gc, x, y, destWidth, destHeight);
	XFreePixmap(dpy, pixmap);
	XSetFillStyle(dpy, gc, FillSolid);
	}

void
XmLWarning(Widget w,
	   char *msg)
	{
	XtAppContext app;
	char s[512], *cname, *name;
	WidgetClass c;

	app = XtWidgetToApplicationContext(w);
	name = XtName(w);
	if (!name)
		name = "[No Name]";
	c = XtClass(w);
	cname = c->core_class.class_name;
	if (!cname)
		cname = "[No Class]";
	sprintf(s, "%s: %s: %s\n", cname, name, msg);
	XtAppWarning(app, s);
	}