megab.c

安装DDD之前

/* $Id: MegaB.c,v 1.1 2002/05/14 23:01:27 dannybackx Exp $ */
/*
 * Copyright 1994 John L. Cwikla
 *
 * Permission to use, copy, modify, distribute, and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appears in all copies and that
 * both that copyright notice and this permission notice appear in
 * supporting documentation, and that the name of John L. Cwikla or
 * Wolfram Research, Inc not be used in advertising or publicity
 * pertaining to distribution of the software without specific, written
 * prior permission.	John L. Cwikla and Wolfram Research, Inc make no
 * representations about the suitability of this software for any
 * purpose. It is provided "as is" without express or implied warranty.
 *
 * John L. Cwikla and Wolfram Research, Inc disclaim all warranties with
 * regard to this software, including all implied warranties of
 * merchantability and fitness, in no event shall John L. Cwikla or
 * Wolfram Research, Inc be liable for any special, indirect or
 * consequential damages or any damages whatsoever resulting from loss of
 * use, data or profits, whether in an action of contract, negligence or
 * other tortious action, arising out of or in connection with the use or
 * performance of this software.
 *
 * Author:
 *  John L. Cwikla
 *  X Programmer
 *  Wolfram Research Inc.
 *
 *  [e-mail]
*/

#include <Xm/XmP.h>
#include <Xm/XmosP.h>

#include <Xm/BaseClassP.h>
#include <Xm/DrawP.h>
#include <Xm/MenuShellP.h>
#include <Xm/MenuUtilP.h>
#include <Xm/CascadeB.h>
#include <Xm/CascadeBG.h>
#include <X11/Xfuncs.h>

#if HAVE_SOURCE || defined(LESSTIF_VERSION)
#include "XmI/TraversalI.h"
#endif /* HAVE_SOURCE */

#include "MegaBP.h"

#include <stdio.h>
#include <ctype.h>

#define SCROLL_TIME 100
#define MINI_SEP_HEIGHT 3

static XtWidgetClassProc classPartInit(WidgetClass _wc);
static XtProc classInit();
static XtInitProc initialize(Widget _request, Widget _new, String *_args, 
		Cardinal *_numArg); 
static XtWidgetProc destroy(Widget _mbw);
static void expose(Widget _mbw, XEvent *_event, Region _region);
static Boolean setValues(Widget _current, Widget _request, Widget _new, ArgList args, Cardinal *num_args);
static void borderHighlight(Widget _mbw);
static void borderUnhighlight(Widget _mbw);

static void getMaxWidthPos(Widget _mbw, int *_maxWidthPos, Dimension *_height);
static void drawMiniSeparator(Widget _mbw, Position _y);

static void enterWidget(Widget _mbw, XEvent *_event, String *_params, Cardinal *_numParams);
static void leaveWidget(Widget _mbw, XEvent *_event, String *_params, Cardinal *_numParams);
static void buttonMotion(Widget _mbw, XEvent *_event, String *_params, Cardinal *_numParams);
static void up(Widget _mbw, XEvent *_event, String *_params, Cardinal *_numParams);
static void down(Widget _mbw, XEvent *_event, String *_params, Cardinal *_numParams);
static void buttonUp(Widget _mbw, XEvent *_event, String *_params, Cardinal *_numParams);
static void buttonDown(Widget _mbw, XEvent *_event, String *_params,
		Cardinal *_numParms);
static void armAndActivate(Widget _mbw, XEvent *_event, String *_params, Cardinal *_numParams);
static void focusIn(Widget _mbw, XEvent *_event, String *_params, Cardinal *_numParams);
static void focusOut(Widget _mbw, XEvent *_event, String *_params, Cardinal *_numParams);
static void timedScroll(XtPointer _closure, XtIntervalId *_id);
static Boolean cvtStringToMegaButtonMode(Display *_display, XrmValuePtr _args,
	Cardinal *_numArgs, XrmValuePtr _from, XrmValuePtr _to, XtPointer *_data);

static void drawShadowedItem(Widget _mbw, int _pos, Boolean _clear);
static void drawArrow(Widget _mbw, int _pos, int _direction, Boolean _sensitive);
static void clearArrow(Widget _mbw, int _pos);
static void scroll(Widget _mbw, int _direction, Boolean _addTimeout, int _delay);
static void findGoodShowPos(Widget _mbw);

static void toggleDrawProc(Widget _mbw, Position _x, Position _y, Boolean _on);
static void toggleSpaceProc(Widget _mbw, Dimension *_width, Dimension *_height);

static void recheckSizesAtPos(Widget _mbw, int _pos);

static Widget XtGetShell(Widget _w);

#define CORE(w) (((XmMegaButtonWidget)(w))->core)
#define PRIM(w) (((XmMegaButtonWidget)(w))->primitive)
#define LABEL(w) (((XmMegaButtonWidget)(w))->label)
#define PUSH(w) (((XmMegaButtonWidget)(w))->push_button)
#define MB(w) (((XmMegaButtonWidget)(w))->mega_button)

#define WIDTH(w) (((XmMegaButtonWidget)(w))->core.width)
#define HEIGHT(w) (((XmMegaButtonWidget)(w))->core.height)

#define VIS_COUNT(w) (((XmMegaButtonWidget)(w))->mega_button.visibleItemCount)
#define ICOUNT(w) (((XmMegaButtonWidget)(w))->mega_button.itemCount)
#define ITEMS(w) (((XmMegaButtonWidget)(w))->mega_button._items)
#define EXITEMS(w) (((XmMegaButtonWidget)(w))->mega_button.exitems)
#define VIS_POS(w) (((XmMegaButtonWidget)(w))->mega_button.visiblePos)
#define FPOS(w) (((XmMegaButtonWidget)(w))->mega_button.firstVisibleItem)
#define EL_HEIGHT(w) (((XmMegaButtonWidget)(w))->mega_button.elementHeight)
#define YOFFSET(w) (((XmMegaButtonWidget)(w))->mega_button.yOffset)
#define XOFFSET(w) (((XmMegaButtonWidget)(w))->mega_button.xOffset)
#define HAS_ARROWS(w) (((XmMegaButtonWidget)(w))->mega_button.hasArrows)
#define SET_POS(w) (((XmMegaButtonWidget)(w))->mega_button.setPosition)
#define COPY_GC(w) (((XmMegaButtonWidget)(w))->mega_button.copyGC)
#define TIMER(w) (((XmMegaButtonWidget)(w))->mega_button.timer)
#define TDIR(w) (((XmMegaButtonWidget)(w))->mega_button.timedScrollDirection)
#define SFOS(w) (((XmMegaButtonWidget)(w))->mega_button.savedFillOnSelect)
#define IDELAY(w) (((XmMegaButtonWidget)(w))->mega_button.initialDelay)
#define RDELAY(w) (((XmMegaButtonWidget)(w))->mega_button.repeatDelay)
#define FAKE_ITEM(w) (((XmMegaButtonWidget)(w))->mega_button.fakeItem)
#define CUR_SIZE(w) (((XmMegaButtonWidget)(w))->mega_button.currentSize)
#define DATA(w) (((XmMegaButtonWidget)(w))->mega_button.data)
#define CB_DATA(w) (((XmMegaButtonWidget)(w))->mega_button.cbData)
#define MAX_STRING_POS(w) (((XmMegaButtonWidget)(w))->mega_button.maxStringPos)
#define MAX_STRING_WIDTH(w) (((XmMegaButtonWidget)(w))->mega_button.maxStringWidth)
#define MODE(w) (((XmMegaButtonWidget)(w))->mega_button.mode)
#define TOG_DATA(w) (((XmMegaButtonWidget)(w))->mega_button.toggleData)
#define FILL_ON_SELECT(w) (((XmMegaButtonWidget)(w))->mega_button.fillOnSelect)
#define SELECT_COLOR(w) (((XmMegaButtonWidget)(w))->mega_button.selectColor)
#define SELECT_GC(w) (((XmMegaButtonWidget)(w))->mega_button.selectGC)
#define CHUNK_SIZE(w) (((XmMegaButtonWidget)(w))->mega_button.chunkSize)
#define VIS_W_OFF(w) (((XmMegaButtonWidget)(w))->mega_button.visibleWhenOff)
#define STR_HEIGHT(w) (((XmMegaButtonWidget)(w))->mega_button.stringHeight)

#define DEFAULT_CHUNK_SIZE 50

static char traversalTranslations[] = 
"<Btn1Motion>: BtnMotion() \n\
<Enter>: Enter() \n\
<Leave>: Leave() \n\
<Key>osfHelp:Help() \n\
<Unmap>:Unmap()\n\
<FocusOut>:FocusOut()\n\
<FocusIn>:FocusIn()\n\
<Key>osfCancel:MenuEscape()\n\
<Key>osfUp: MegaButtonTraverseUp() \n\
<Key>osfDown: MegaButtonTraverseDown() \n\
<Key>osfLeft:MenuTraverseLeft()\n\
<Key>osfRight:MenuTraverseRight()\n\
<Key>osfSelect:ArmAndActivate()\n\
<Key>osfActivate:ArmAndActivate()\n\
~s ~m ~a <Key>Return:ArmAndActivate()\n\
~s ~m ~a <Key>space:ArmAndActivate()";

#define TheOffset(field) XtOffset(XmMegaButtonWidget, mega_button.field)
static XtResource resources[] =
{
	{XmNitems, XmCItems, XtRPointer, sizeof(XtPointer),
		TheOffset(exitems), XmRImmediate, (XtPointer)NULL},
	{XmNitemCount, XmCItemCount, XtRInt, sizeof(int),
		TheOffset(itemCount), XmRImmediate, (XtPointer)0},
	{XmNvisibleItemCount, XmCVisibleItemCount, XmRInt, sizeof(int),
		TheOffset(visibleItemCount), XtRImmediate, (XtPointer)0},
	{XmNsetPosition, XmCSetPosition, XtRInt, sizeof(int),
		TheOffset(setPosition), XmRImmediate, (XtPointer)-1},
	{XmNrepeatDelay, XmCRepeatDelay, XmRInt, sizeof(int),
		TheOffset(repeatDelay), XmRImmediate, (XtPointer)50},
	{XmNinitialDelay, XmCInitialDelay, XmRInt, sizeof(int),
		TheOffset(initialDelay), XmRImmediate, (XtPointer)250},
	{XmNbuttonMode, XmCButtonMode, XmRMegaButtonMode, sizeof(unsigned char),
		TheOffset(mode), XmRImmediate, (XtPointer)XmMODE_TOGGLE_BUTTON},
	{XmNselectColor, XmCSelectColor, XmRPixel, sizeof(Pixel),
		TheOffset(selectColor), XmRCallProc, (XtPointer)_XmSelectColorDefault},
	{XmNfillOnSelect, XmCFillOnSelect, XmRBoolean, sizeof(Boolean),
		TheOffset(fillOnSelect), XmRImmediate, (XtPointer)FALSE},
	{XmNchunkSize, XmCChunkSize, XmRInt, sizeof(int),
		TheOffset(chunkSize), XmRImmediate, (XtPointer)DEFAULT_CHUNK_SIZE},
	{XmNcallbackData, XmCCallbackData, XmRPointer, sizeof(XtPointer),
		TheOffset(cbData), XmRImmediate, (XtPointer)NULL},
	{XmNvisibleWhenOff, XmCVisibleWhenOff, XmRBoolean, sizeof(Boolean),
		TheOffset(visibleWhenOff), XtRImmediate, (XtPointer)FALSE},
};

#undef TheOffset

static XtActionsRec actions[] = 
{
	{ "Enter",		  (XtActionProc) enterWidget  },
	{ "Leave",		  (XtActionProc) leaveWidget  },
	{ "BtnMotion",		(XtActionProc) buttonMotion },
	{ "MegaButtonTraverseUp",				(XtActionProc) up },
	{ "MegaButtonTraverseDown",				(XtActionProc) down },
	{ "ArmAndActivate", (XtActionProc) armAndActivate },
	{ "BtnUp",		  (XtActionProc) buttonUp },
	{ "BtnDown",	(XtActionProc) buttonDown},
	{ "FocusIn",	 (XtActionProc) focusIn },
	{ "FocusOut",	(XtActionProc) focusOut},

	{"MenuBtnDown",	 (XtActionProc)down},
	{"MenuBtnUp",		(XtActionProc)up},
	{"PulldownBtnDown",	 (XtActionProc)down},
	{"PulldownBtnUp",		(XtActionProc)up},
	{"PopupBtnDown",		(XtActionProc)down},
	{"PopupBtnUp",		  (XtActionProc)up},
	{"MenuBarBtnDown",	  (XtActionProc)down},
	{"MenuBarBtnUp",		(XtActionProc)up},

	{"MenuTraverseUp",	  (XtActionProc)up},
	{"MenuTraverseDown",	(XtActionProc)down},
	{"MenuFocusIn",		 (XtActionProc)focusIn },
	{"MenuFocusOut",		(XtActionProc)focusOut },
	{"MenuUnmap",			(XtActionProc)leaveWidget },
	{"MenuEnter",			(XtActionProc)enterWidget},

}; /* actions */

static XmBaseClassExtRec		megaBBaseClassExtRec = 
{
	NULL,									 /* Next extension		*/
	NULLQUARK,								/* record type XmQmotif */
	XmBaseClassExtVersion,					/* version			  */
	sizeof(XmBaseClassExtRec),				/* size				 */
	XmInheritInitializePrehook,						/* initialize prehook	*/
	XmInheritSetValuesPrehook,				/* set_values prehook	*/
	XmInheritInitializePosthook,						/* initialize posthook  */
	XmInheritSetValuesPosthook,				/* set_values posthook  */
	XmInheritClass,							/* secondary class	  */
	XmInheritSecObjectCreate,				 /* creation proc		*/
	XmInheritGetSecResData,					/* getSecResData		*/
	{0},									  /* fast subclass		*/
	XmInheritGetValuesPrehook,				/* get_values prehook	*/
	XmInheritGetValuesPosthook,				/* get_values posthook  */
	(XtWidgetClassProc)NULL,				  /* classPartInitPrehook */
	(XtWidgetClassProc)NULL,				  /* classPartInitPosthook*/
	NULL,									 /* ext_resources		*/
	NULL,									 /* compiled_ext_resources*/
	0,										/* num_ext_resources	*/
	FALSE,									/* use_sub_resources	*/
	XmInheritWidgetNavigable,				 /* widgetNavigable	  */
	XmInheritFocusChange,					 /* focusChange		  */
};

XmPrimitiveClassExtRec _XmMegaBPrimClassExtRec = 
{
	NULL,
	NULLQUARK,
	XmPrimitiveClassExtVersion,
	sizeof(XmPrimitiveClassExtRec),
	XmInheritBaselineProc,				  /* widget_baseline */
	XmInheritDisplayRectProc,				/* widget_display_rect */
	(XmWidgetMarginsProc)NULL,			  /* widget_margins */
};


XmMegaButtonClassRec xmMegaButtonClassRec =
{
	{
		(WidgetClass)&xmPushButtonClassRec,			  /* superclass */
		"XmMegaButton",								 /* class_name */
		(Cardinal)sizeof(XmMegaButtonRec),		 /* widget size */
		(XtProc)classInit,							  /* class_init */
		(XtWidgetClassProc)classPartInit,			/* class_part_init */
		(XtEnum)FALSE,								/* class_inited */
		(XtInitProc)initialize,						 /* initialize */
		(XtArgsProc)NULL,								/* init_hook */
		XtInheritRealize,							/* realize */
		(XtActionList)actions,							  /* actions */
		(Cardinal)XtNumber(actions),						/* num_actions */
		(XtResourceList)resources,							/* resources */
		(Cardinal)XtNumber(resources),						/* num_resources */
		NULLQUARK,									/* xrm_class */
		TRUE,										/* compress_motion */
		(XtEnum)FALSE,								/* compress_exposur */
		TRUE,										/* compress enterleave */
		FALSE,									  /* visibility_interest */
		(XtWidgetProc)destroy,							  /* destroy */
		(XtWidgetProc)XtInheritResize,
		(XtExposeProc)expose,
		(XtSetValuesFunc)setValues,						  /* set_values */
		(XtArgsFunc)NULL,								/* set_values_hook */
		XtInheritSetValuesAlmost,					/* set_values_almost */
		(XtArgsProc)NULL,								/* get_values_hook */
		NULL, 						/* accept_focus */
		XtVersion,									/* version */
		(XtPointer)NULL,								/* callback_private */
		XtInheritTranslations,
		(XtGeometryHandler)NULL,		  /* query_geometry */
		XtInheritDisplayAccelerator,				 /* display_accelerator */
		(XtPointer)&megaBBaseClassExtRec,										/* extension */
	},
	{ 	/* xmPrimitiveClass */
		(XtWidgetProc)borderHighlight,
		(XtWidgetProc)borderUnhighlight,
		XtInheritTranslations,
		(XtActionProc)armAndActivate,
		NULL,
		0,
		(XtPointer)&_XmMegaBPrimClassExtRec,
	},
	{	/* xmLabelClass */
		(XtWidgetProc) XmInheritSetOverrideCallback,
		NULL,
		NULL,
		NULL,
	},
	{ 	/* xmPushButtonClass */
		(XtPointer)NULL,
	},
	{
		XmInheritMegaButtonToggleSpaceProc,
		XmInheritMegaButtonToggleDrawProc,
	}
};

WidgetClass xmMegaButtonWidgetClass = (WidgetClass)&xmMegaButtonClassRec;


static XtWidgetClassProc classPartInit(WidgetClass _wc)
{
	XmMegaButtonWidgetClass mbwc;

	_XmFastSubclassInit(_wc, (XmPUSH_BUTTON_BIT | XmLABEL_BIT |
							XmPRIMITIVE_BIT));

	mbwc = (XmMegaButtonWidgetClass)_wc;
	if (mbwc->mega_button_class.toggleSpaceProc == XmInheritMegaButtonToggleSpaceProc)
		mbwc->mega_button_class.toggleSpaceProc = toggleSpaceProc;
	if (mbwc->mega_button_class.toggleDrawProc == XmInheritMegaButtonToggleDrawProc)
		mbwc->mega_button_class.toggleDrawProc = toggleDrawProc;
	return (XtWidgetClassProc)NULL;
}

static XtProc classInit()
{
	xmMegaButtonClassRec.label_class.translations = (String)XtParseTranslationTable(traversalTranslations);

	XtSetTypeConverter(XtRString, XmRMegaButtonMode, cvtStringToMegaButtonMode,
		(XtConvertArgList)NULL, 0,
			XtCacheAll, (XtDestructor)NULL);

	return (XtProc)NULL;
}

static XtInitProc initialize(Widget _request, Widget _new, String *_args, Cardinal *_numArgs)
{
	int i;
	XmString xmstring;
	XGCValues gcValues;
	Dimension width;

	VIS_POS(_new) = -1;

	FPOS(_new) = 0;
	TOG_DATA(_new) = NULL;
	if ((MODE(_new) == XmMODE_TOGGLE_BUTTON) && (SET_POS(_new) > (ICOUNT(_new)-1)))
		SET_POS(_new) = ICOUNT(_new) - 1;

	if (CHUNK_SIZE(_new) < 1)
		CHUNK_SIZE(_new) = DEFAULT_CHUNK_SIZE;

	if (ICOUNT(_new) == 0)
	{
		if (LABEL(_new)._label == (_XmString) XmUNSPECIFIED)
		{
			xmstring = _XmOSGetLocalizedString ((char *) NULL,  /* reserved */
						(Widget)_new,
						XmNlabelString,
						"\0");

			LABEL(_new)._label =  _XmStringCreate(xmstring);
		}
		else
		if (LABEL(_new)._label == NULL)
		{
			xmstring = _XmOSGetLocalizedString ((char *) NULL,  /* reserved */
						(Widget)_new,
						XmNlabelString,
						CORE(_new).name);

			LABEL(_new)._label =  _XmStringCreate(xmstring);
		}
		ICOUNT(_new) = 1;
		ITEMS(_new) = XtNew(_XmString);
		ITEMS(_new)[0] = LABEL(_new)._label;
		DATA(_new) = XtNew(XtPointer);
		DATA(_new)[0] = (XtPointer)NULL;
		FAKE_ITEM(_new) = TRUE;
	}
	else
	{
		ITEMS(_new) = (_XmString *)XtMalloc(sizeof(_XmString) * ICOUNT(_new));
		DATA(_new) = (XtPointer)XtCalloc(ICOUNT(_new), sizeof(XtPointer));
		if (CB_DATA(_new) != NULL)
			for(i=0;i<ICOUNT(_new);i++)
			{
				ITEMS(_new)[i] = _XmStringCreate(EXITEMS(_new)[i]);
				DATA(_new)[i] = CB_DATA(_new)[i];
			}
		else
			for(i=0;i<ICOUNT(_new);i++)
			{
				ITEMS(_new)[i] = _XmStringCreate(EXITEMS(_new)[i]);
				DATA(_new)[i] = NULL;
			}

		FAKE_ITEM(_new) = FALSE;
	}

	CUR_SIZE(_new) = ICOUNT(_new);

	getMaxWidthPos(_new, &MAX_STRING_POS(_new), &EL_HEIGHT(_new));
	_XmStringExtent(LABEL(_new).font, ITEMS(_new)[0], &width, &STR_HEIGHT(_new));


	EL_HEIGHT(_new) += 2 * PRIM(_new).shadow_thickness;
	HEIGHT(_new) = EL_HEIGHT(_new);

	LABEL(_new)._label = ITEMS(_new)[MAX_STRING_POS(_new)];
	_XmCalcLabelDimensions((Widget)_new);
	MAX_STRING_WIDTH(_new) = LABEL(_new).TextRect.width;
	WIDTH(_new) = 0;
	(*xmLabelWidgetClass->core_class.resize) ((Widget)_new);

	YOFFSET(_new) = LABEL(_new).TextRect.y;
	XOFFSET(_new) = LABEL(_new).TextRect.x;

	if ( (MODE(_new) == XmMODE_TOGGLE_BUTTON) && ( ((XmMegaButtonWidgetClass)XtClass(_new))->mega_button_class.toggleSpaceProc))
		(( (XmMegaButtonWidgetClass)XtClass(_new))->mega_button_class.toggleSpaceProc)(_new, &WIDTH(_new), &EL_HEIGHT(_new));

	if (VIS_COUNT(_new) == 0)
	{
		Dimension dheight;
		int vcount;

		dheight = DisplayHeight(XtDisplay(_new), DefaultScreen(XtDisplay(_new)));

		vcount = dheight/EL_HEIGHT(_new) - 4;
		if (vcount <=3)
			vcount = 3;

		VIS_COUNT(_new) = vcount;
	}

	HAS_ARROWS(_new) = ICOUNT(_new) > VIS_COUNT(_new);

	if (HAS_ARROWS(_new))
		HEIGHT(_new) =
			HEIGHT(_new) * (VIS_COUNT(_new) + 2) + (2 * MINI_SEP_HEIGHT);
	else
		HEIGHT(_new) *= ICOUNT(_new);

	gcValues.foreground = CORE(_new).background_pixel;
	COPY_GC(_new) = XtGetGC((Widget)_new, GCForeground, &gcValues);
	
	gcValues.foreground = FILL_ON_SELECT(_new) ? SELECT_COLOR(_new) : CORE(_new).background_pixel;

	SELECT_GC(_new) = XtGetGC((Widget)_new, GCForeground, &gcValues);
	TIMER(_new) = -1;

	return (XtInitProc)NULL;
}

static XtWidgetProc destroy(Widget _mbw)
{
	register int i;

	XtReleaseGC((Widget)_mbw, COPY_GC(_mbw));
	XtReleaseGC((Widget)_mbw, SELECT_GC(_mbw));

      for(i=0;i<ICOUNT(_mbw);i++) {
              if(ITEMS(_mbw)[i] != LABEL(_mbw)._label)
                      _XmStringFree(ITEMS(_mbw)[i]);
      }

	XtFree((char *)ITEMS(_mbw));
	XtFree((char *)DATA(_mbw));

	return (XtWidgetProc)NULL;
}

static void expose(Widget _mbw, XEvent *_event, Region _region)
{
	GC gc;
	int i, first;
	Position y;

	if (_event && _XmIsEventUnique(_event ))
		return; /* from _XmFastExpose... */

	findGoodShowPos(_mbw);

	gc = XtIsSensitive(_mbw) ? LABEL(_mbw).normal_GC : LABEL(_mbw).insensitive_GC;

	first = FPOS(_mbw);
	y = 0;
	if (HAS_ARROWS(_mbw))
	{
		drawArrow(_mbw, 0, XmARROW_UP, (FPOS(_mbw) != 0));
		y += EL_HEIGHT(_mbw);
		drawMiniSeparator(_mbw, EL_HEIGHT(_mbw));
		y += MINI_SEP_HEIGHT;
	}
	
	y += YOFFSET(_mbw);
	LABEL(_mbw).TextRect.x = XOFFSET(_mbw);

	for(i=0;(i<VIS_COUNT(_mbw)) && ((first + i) < ICOUNT(_mbw)); i++)
	{
		LABEL(_mbw)._label = ITEMS(_mbw)[first+i];
		_XmCalcLabelDimensions((Widget)_mbw);
		
		LABEL(_mbw).TextRect.y = y;

		(*xmLabelWidgetClass->core_class.expose) ((Widget)_mbw,  _event, _region);

		if ( (MODE(_mbw) == XmMODE_TOGGLE_BUTTON) && ( ((XmMegaButtonWidgetClass)XtClass(_mbw))->mega_button_class.toggleDrawProc))
		{
			if ((first + i) == SET_POS(_mbw))
				(*((XmMegaButtonWidgetClass)XtClass(_mbw))->mega_button_class.toggleDrawProc)(_mbw, LABEL(_mbw).TextRect.x, y, TRUE);
			else
				if (VIS_W_OFF(_mbw))
				 (*((XmMegaButtonWidgetClass)XtClass(_mbw))->mega_button_class.toggleDrawProc)(_mbw, LABEL(_mbw).TextRect.x, y, FALSE);
		}

		y += EL_HEIGHT(_mbw);
	}

	y -= YOFFSET(_mbw);

	if (HAS_ARROWS(_mbw))
	{
		drawMiniSeparator(_mbw, y);
		y += MINI_SEP_HEIGHT;
		drawArrow(_mbw, VIS_COUNT(_mbw)+1, XmARROW_DOWN, ((ICOUNT(_mbw))-FPOS(_mbw)) > VIS_COUNT(_mbw));
	}

	/* drawShadowedItem(_mbw, VIS_POS(_mbw), FALSE); */
}

static Boolean setValues( Widget _current, Widget _request, Widget _new, ArgList args, Cardinal *num_args)
{
	return FALSE;
}

static void getMaxWidthPos(Widget _mbw, int *_maxWidthPos, Dimension *_height)
{
	int first, i;
	Dimension maxHeight, maxWidth;
	int mwp;

	if (ICOUNT(_mbw) == 0)
	{
		*_maxWidthPos = 0;
		*_height = 1;
		return;