/* 

 * Motif

 *

 * Copyright (c) 1987-2012, The Open Group. All rights reserved.

 *

 * These libraries and programs are free software; you can

 * redistribute them and/or modify them under the terms of the GNU

 * Lesser General Public License as published by the Free Software

 * Foundation; either version 2 of the License, or (at your option)

 * any later version.

 *

 * These libraries and programs are distributed in the hope that

 * they will be useful, but WITHOUT ANY WARRANTY; without even the

 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

 * PURPOSE. See the GNU Lesser General Public License for more

 * details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with these librararies and programs; if not, write

 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth

 * Floor, Boston, MA 02110-1301 USA

 */ 

/* 

 * HISTORY

*/ 

#ifdef REV_INFO

#ifndef lint

static char rcsid[] = "$TOG: CascadeBG.c /main/28 1999/02/01 18:47:11 mgreess $"

#endif

#endif

/* (c) Copyright 1989, DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. */

/* (c) Copyright 1987, 1988, 1989, 1990, 1991, 1992 HEWLETT-PACKARD COMPANY */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <string.h>

#include "XmI.h"

#include <X11/ShellP.h>

#include <X11/keysymdef.h>

#include <Xm/CacheP.h>

#include <Xm/CascadeBP.h>

#include <Xm/DisplayP.h>

#include <Xm/DrawP.h>

#include <Xm/LabelGP.h>

#include <Xm/LabelP.h>

#include <Xm/MenuShellP.h>

#include <Xm/MenuStateP.h>

#include <Xm/MenuT.h>

#include <Xm/RowColumnP.h>

#include <Xm/TraitP.h>

#include <Xm/VaSimpleP.h>

#include "BaseClassI.h"

#include "CacheI.h"

#include "CascadeBI.h"

#include "CascadeBGI.h"

#include "ExtObjectI.h"

#include "GadgetUtiI.h"

#include "LabelI.h"

#include "LabelGI.h"

#include "MessagesI.h"

#include "MenuProcI.h"

#include "MenuStateI.h"

#include "MenuUtilI.h"

#include "RCMenuI.h"

#include "SyntheticI.h"

#include "TravActI.h"

#include "TraversalI.h"

#include "UniqueEvnI.h"

#define CASCADE_PIX_SPACE     4	/* pixels between label and bit map */

#define MAP_DELAY_DEFAULT   180

#define EVENTS              ((unsigned int) (ButtonPressMask | \

			       ButtonReleaseMask | EnterWindowMask | \

			       LeaveWindowMask))

#define WRONGPARENT	_XmMMsgCascadeB_0000

#define WRONGSUBMENU	_XmMMsgCascadeB_0001

#define WRONGMAPDELAY	_XmMMsgCascadeB_0002

/********    Static Function Declarations    ********/

static void ClassInitialize( void ) ;

static void ClassPartInitialize( 

                        WidgetClass wc) ;

static void SecondaryObjectCreate( 

                        Widget req,

                        Widget new_w,

                        ArgList args,

                        Cardinal *num_args) ;

static void InitializePrehook( 

                        Widget req,

                        Widget new_w,

                        ArgList args,

                        Cardinal *num_args) ;

static void InitializePosthook( 

                        Widget req,

                        Widget new_w,

                        ArgList args,

                        Cardinal *num_args) ;

static int _XmCascadeBCacheCompare( 

                        XtPointer A,

                        XtPointer B) ;

static void BorderHighlight( 

                        Widget wid) ;

static void BorderUnhighlight( 

                        Widget wid) ;

static void DrawShadow( 

                        XmCascadeButtonGadget cb) ;

static void DrawCascade( 

                        register XmCascadeButtonGadget cb) ;

static void position_cascade( 

                        XmCascadeButtonGadget cascadebtn) ;

static void Redisplay( 

                        Widget wid,

                        XEvent *event,

                        Region region) ;

static void InputDispatch( 

                        Widget wid,

                        XEvent *event,

                        Mask event_mask) ;

static void Arm( 

                        XmCascadeButtonGadget cb) ;

static void ArmAndPost( 

                        XmCascadeButtonGadget cb,

                        XEvent *event) ;

static void ArmAndActivate( 

                        Widget wid,

                        XEvent *event,

                        String *params,

                        Cardinal *num_params) ;

static void Disarm( 

                        XmCascadeButtonGadget cb,

#if NeedWidePrototypes

                        int unpost) ;

#else

                        Boolean unpost) ;

#endif /* NeedWidePrototypes */

static void PostTimeout( 

                        XtPointer closure,

                        XtIntervalId *id) ;

static void DelayedArm( 

                        XmCascadeButtonGadget cb,

                        XEvent *event) ;

static void CheckDisarm( 

                        XmCascadeButtonGadget cb,

                        XEvent *event) ;

static void StartDrag( 

                        XmCascadeButtonGadget cb,

                        XEvent *event) ;

static void Select( 

                        XmCascadeButtonGadget cb,

                        XEvent *event,

#if NeedWidePrototypes

                        int doCascade) ;

#else

                        Boolean doCascade) ;

#endif /* NeedWidePrototypes */

static void DoSelect( 

                        XmCascadeButtonGadget cb,

                        XEvent *event) ;

static void KeySelect( 

                        XmCascadeButtonGadget cb,

                        XEvent *event) ;

static void MenuBarSelect( 

                        Widget wid,

                        XEvent *event) ;

static void MenuBarEnter( 

                        Widget wid,

                        XEvent *event) ;

static void MenuBarLeave( 

                        Widget wid) ;

static void size_cascade( 

                        XmCascadeButtonGadget cascadebtn) ;

static void setup_cascade( 

                        XmCascadeButtonGadget cascadebtn,

#if NeedWidePrototypes

                        int adjustWidth,

                        int adjustHeight) ;

#else

                        Boolean adjustWidth,

                        Boolean adjustHeight) ;

#endif /* NeedWidePrototypes */

static void Destroy( 

                        Widget wid) ;

static void Resize( 

                        Widget wid) ;

static Boolean SetValuesPrehook( 

                        Widget oldParent,

                        Widget refParent,

                        Widget newParent,

                        ArgList args,

                        Cardinal *num_args) ;

static void GetValuesPrehook( 

                        Widget newParent,

                        ArgList args,

                        Cardinal *num_args) ;

static void GetValuesPosthook( 

                        Widget new_w,

                        ArgList args,

                        Cardinal *num_args) ;

static Boolean SetValuesPosthook( 

                        Widget current,

                        Widget req,

                        Widget new_w,

                        ArgList args,

                        Cardinal *num_args) ;

static Boolean SetValues( 

                        Widget cw,

                        Widget rw,

                        Widget nw,

                        ArgList args,

                        Cardinal *num_args) ;

static void GetArmGC( 

                        XmCascadeButtonGadget cb) ;

static void GetBackgroundGC( 

                        XmCascadeButtonGadget cb) ;

static void Initialize( 

                        Widget rw,

                        Widget nw,

                        ArgList args,

                        Cardinal *num_args) ;

static Cardinal GetCascadeBGClassSecResData( 

                        WidgetClass w_class,

                        XmSecondaryResourceData **data_rtn) ;

static XtPointer GetCascadeBGClassSecResBase( 

                        Widget widget,

                        XtPointer client_data) ;

/********    End Static Function Declarations    ********/

static XtResource resources[] = 

{

    {   XmNactivateCallback,

        XmCCallback,

        XmRCallback,

        sizeof (XtCallbackList),

        XtOffsetOf( struct _XmCascadeButtonGadgetRec, cascade_button.activate_callback),

        XmRCallback,

        NULL

    },

    {   XmNcascadingCallback,

        XmCCallback,

        XmRCallback,

        sizeof (XtCallbackList),

        XtOffsetOf( struct _XmCascadeButtonGadgetRec,

		   cascade_button.cascade_callback),

        XmRCallback,

        NULL

    },

    {	XmNsubMenuId, 

	XmCMenuWidget,				/* submenu */

	XmRMenuWidget, 

	sizeof (Widget),

	XtOffsetOf( struct _XmCascadeButtonGadgetRec, cascade_button.submenu), 

	XmRMenuWidget, 

	(XtPointer) 0

    },

    {

        XmNshadowThickness,

        XmCShadowThickness,

        XmRHorizontalDimension,

        sizeof (Dimension),

        XtOffsetOf( struct _XmCascadeButtonGadgetRec, gadget.shadow_thickness),

        XmRCallProc,

	(XtPointer) _XmSetThickness

    },

    {

        XmNtraversalOn,

        XmCTraversalOn,

        XmRBoolean,

        sizeof (Boolean),

        XtOffsetOf( struct _XmGadgetRec, gadget.traversal_on),

        XmRImmediate,

        (XtPointer) True

    },

    {

        XmNhighlightThickness,

        XmCHighlightThickness,

        XmRHorizontalDimension,

        sizeof (Dimension),

        XtOffsetOf( struct _XmGadgetRec, gadget.highlight_thickness),

        XmRCallProc,

	(XtPointer) _XmSetThickness

    },

};       

static XtResource cache_resources[] =

{

   {   XmNcascadePixmap, 

       XmCPixmap, 

       XmRDynamicPixmap,

       sizeof(Pixmap),

       XtOffsetOf( struct _XmCascadeButtonGCacheObjRec,

                 cascade_button_cache.cascade_pixmap), 

       XmRImmediate,

       (XtPointer) XmUNSPECIFIED_PIXMAP

   },

   {   XmNmappingDelay,

       XmCMappingDelay,

       XmRInt,

       sizeof (int),

       XtOffsetOf( struct _XmCascadeButtonGCacheObjRec,

	         cascade_button_cache.map_delay),

       XmRImmediate,

       (XtPointer) MAP_DELAY_DEFAULT

   },

};

static XmCacheClassPart CascadeButtonClassCachePart = {

    {NULL, 0, 0},        /* head of class cache list */

    _XmCacheCopy,       /* Copy routine     */

    _XmCacheDelete,     /* Delete routine   */

    _XmCascadeBCacheCompare,    /* Comparison routine   */

};

static XmBaseClassExtRec   CascadeBGClassExtensionRec = {

    NULL,    					    /* next_extension        */

    NULLQUARK,    				    /* record_typ  	     */

    XmBaseClassExtVersion,      		    /* version  	     */

    sizeof(XmBaseClassExtRec),  		    /* record_size  	     */

    InitializePrehook,				    /* initializePrehook     */

    SetValuesPrehook,   			    /* setValuesPrehook	     */

    InitializePosthook,   			    /* initializePosthook    */

    SetValuesPosthook,   			    /* setValuesPosthook     */

    (WidgetClass)&xmCascadeButtonGCacheObjClassRec, /* secondaryObjectClass  */

    SecondaryObjectCreate,                 	    /* secondaryObjectCreate */

    GetCascadeBGClassSecResData,                    /* getSecResData         */

    {0},           				    /* fast subclass         */

    GetValuesPrehook,				    /* getValuesPrehook      */

    GetValuesPosthook,				    /* getValuesPosthook     */

    NULL,                                     /* classPartInitPrehook */

    NULL,                                     /* classPartInitPosthook*/

    NULL,                                     /* ext_resources        */

    NULL,                                     /* compiled_ext_resources*/

    0,                                        /* num_ext_resources    */

    FALSE,                                    /* use_sub_resources    */

    XmInheritWidgetNavigable,                 /* widgetNavigable      */

    XmInheritFocusChange,                     /* focusChange          */

};

/* ext rec static initialization */

externaldef(xmcascadebuttongcacheobjclassrec)

XmCascadeButtonGCacheObjClassRec xmCascadeButtonGCacheObjClassRec =

{

  {

      /* superclass         */    (WidgetClass) &xmLabelGCacheObjClassRec,

      /* class_name         */    "XmCascadeButtonGadget",

      /* widget_size        */    sizeof(XmCascadeButtonGCacheObjRec),

      /* class_initialize   */    NULL,

      /* chained class init */    NULL,

      /* class_inited       */    False,

      /* initialize         */    NULL,

      /* initialize hook    */    NULL,

      /* realize            */    NULL,

      /* actions            */    NULL,

      /* num_actions        */    0,

      /* resources          */    cache_resources,

      /* num_resources      */    XtNumber(cache_resources),

      /* xrm_class          */    NULLQUARK,

      /* compress_motion    */    False,

      /* compress_exposure  */    False,

      /* compress enter/exit*/    False,

      /* visible_interest   */    False,

      /* destroy            */    NULL,

      /* resize             */    NULL,

      /* expose             */    NULL,

      /* set_values         */    NULL,

      /* set values hook    */    NULL,

      /* set values almost  */    NULL,

      /* get values hook    */    NULL,

      /* accept_focus       */    NULL,

      /* version            */    XtVersion,

      /* callback offsetlst */    NULL,

      /* default trans      */    NULL,

      /* query geo proc     */    NULL,

      /* display accelerator*/    NULL,

      /* extension record   */    NULL,

   },

   {

      /* synthetic resources */   NULL,

      /* num_syn_resources   */   0,

      /* extension           */   NULL,

   },

};

/*

 * static initialization of the cascade button widget class record, 

 * must do each field

 */

static XmGadgetClassExtRec _XmCascadeBGadClassExtRec = {

     NULL,

     NULLQUARK,

     XmGadgetClassExtVersion,

     sizeof(XmGadgetClassExtRec),

     XmInheritBaselineProc,                  /* widget_baseline */

     XmInheritDisplayRectProc,               /* widget_display_rect */

     XmInheritMarginsProc,                   /* widget_margins */

};

externaldef(xmcascadebuttongadgetclassrec) XmCascadeButtonGadgetClassRec

	xmCascadeButtonGadgetClassRec = 

{

    {

	(WidgetClass) &xmLabelGadgetClassRec,	/* superclass ptr	*/

	"XmCascadeButtonGadget",		/* class_name	*/

	sizeof (XmCascadeButtonGadgetRec),	/* size of Pulldown widget */

	ClassInitialize,			/* class init proc */

	ClassPartInitialize,			/* chained class init */

	FALSE,					/* class is not init'ed */

	Initialize,				/* widget init proc */

	NULL,					/* init_hook proc */

    	NULL,					/* widget realize proc */

    	NULL,					/* class action table */

	0,

	resources,			       /* this class's resource list */

	XtNumber (resources),			/*  "	  " resource_count */

    	NULLQUARK,				/* xrm_class	        */

    	TRUE,					/* do compress motion */

    	XtExposeCompressMaximal,		/* do compress exposure */

	TRUE,				       /* don't compress enter-leave */

   	FALSE,					/* no VisibilityNotify */

	Destroy,				/* class destroy proc */

	Resize,					/* class resize proc */

	Redisplay,				/* expose proc */

	SetValues,				/* set_value proc */

	NULL,					/* set_value_hook proc */

	XtInheritSetValuesAlmost,		/* set_value_almost proc */

	NULL,					/* get_values_hook */

	NULL,					/* class accept focus proc */

	XtVersion,				/* current version */

    	NULL,					/* callback offset list */

    	NULL,					/* default translation table */

	XtInheritQueryGeometry,			/* query geo proc */

	NULL,				        /* display accelerator*/

	(XtPointer)&CascadeBGClassExtensionRec,	/* extension */

    },

    {

			/* Gadget Class record */

	BorderHighlight,			/* border_highlight */

	BorderUnhighlight,			/* border_uhighlight */

	ArmAndActivate,				/* arm_and_activate */

	InputDispatch,				/* input_dispatch routine */

	XmInheritVisualChange,			/* visual_change routine */

	NULL,					/* syn_resources */

	0,					/* num_syn_resources */

	&CascadeButtonClassCachePart,		/* class cache_part   */

	(XtPointer)&_XmCascadeBGadClassExtRec,	/* extension */

    },

    {			/* Label Class record */

	XmInheritWidgetProc,	        	/* set override callback */

	XmInheritMenuProc,      		/* menu procedures       */

	NULL,					/* extension */

    },

    {			/* cascade_button class record */

        NULL,  				        /* extension          */

    }

};

/*

 * now make a public symbol that points to this class record

 */

externaldef(xmcascadebuttongadgetclass) WidgetClass

	xmCascadeButtonGadgetClass = 

                          (WidgetClass) &xmCascadeButtonGadgetClassRec;

/*

 * use caching to share arrow data

 */

static XmCacheClassPart ArrowPixmapCache = {

   {NULL, 0, 0},                /* head of class cache list */

   _XmCacheCopy,                /* Copy routine     */

   _XmArrowPixmapCacheDelete,   /* Delete routine   */

   _XmArrowPixmapCacheCompare,  /* Comparison routine   */

};

/* Menu Savvy trait record */

static XmMenuSavvyTraitRec MenuSavvyRecord = {

    /* version: */

    -1,

    NULL,

    NULL,

    NULL,

    _XmCBNameActivate,

};

static void 

ClassInitialize( void )

{

  Cardinal                    wc_num_res, sc_num_res;

  XtResource                  *merged_list;

  int                         i, j;

  XtResourceList              uncompiled;

  Cardinal                    num;

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

   Label's and Cascadebutton's resource lists are being merged into one

   and assigned to xmCascadeButtonGCacheObjClassRec. This is for performance

   reasons, since, instead of two calls to XtGetSubResources() XtGetSubvaluse()

   and XtSetSubvalues() for both the superclass and the widget class, now

   we have just one call with a merged resource list.

   NOTE: At this point the resource lists for Label and Cascadebutton do

         have unique entries, but if there are resources in the superclass

         that are being overwritten by the subclass then the merged_lists

         need to be created differently.

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

  wc_num_res = xmCascadeButtonGCacheObjClassRec.object_class.num_resources;

  sc_num_res = xmLabelGCacheObjClassRec.object_class.num_resources;

  merged_list = (XtResource *)XtMalloc((sizeof(XtResource) * (wc_num_res +

                                                                 sc_num_res)));

  _XmTransformSubResources(xmLabelGCacheObjClassRec.object_class.resources,

                           sc_num_res, &uncompiled, &num);

  for (i = 0; i < num; i++)

  {

  merged_list[i] = uncompiled[i];

  }

  XtFree((char *)uncompiled);

  for (i = 0, j = num; i < wc_num_res; i++, j++)

  {

   merged_list[j] =

        xmCascadeButtonGCacheObjClassRec.object_class.resources[i];

  }

  _XmProcessLock();

  xmCascadeButtonGCacheObjClassRec.object_class.resources = merged_list;

  xmCascadeButtonGCacheObjClassRec.object_class.num_resources =

                wc_num_res + sc_num_res ;

  _XmProcessUnlock();

  CascadeBGClassExtensionRec.record_type = XmQmotif;

}

/*

 * set up fast subclassing

 */

static void 

ClassPartInitialize(

        WidgetClass wc )

{

  _XmFastSubclassInit (wc, XmCASCADE_BUTTON_GADGET_BIT);

  _XmLabelGCloneMenuSavvy (wc, &MenuSavvyRecord);

}

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

*

*  SecondaryObjectCreate

*

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

/* ARGSUSED */

static void 

SecondaryObjectCreate(

        Widget req,

        Widget new_w,

        ArgList args,

        Cardinal *num_args )

{

  XmBaseClassExt              *cePtr;

  XmWidgetExtData             extData;

  WidgetClass                 wc;

  Cardinal                    size;

  XtPointer                   newSec, reqSec;

  _XmProcessLock();

  cePtr = _XmGetBaseClassExtPtr(XtClass(new_w), XmQmotif);

  wc = (*cePtr)->secondaryObjectClass;

  size = wc->core_class.widget_size;

  newSec = _XmExtObjAlloc(size);

  reqSec = _XmExtObjAlloc(size);

  _XmProcessUnlock();

    /*

     * Since the resource lists for label and cascadebutton were merged at

     * ClassInitialize time we need to make only one call to

     * XtGetSubresources()

     */

/*

 *  Update pointers in instance records now so references to resources

 * in the cache record will be valid for use in CallProcs.

 * CallProcs are invoked by XtGetSubresources().

 */

  LabG_Cache(new_w) = &(((XmLabelGCacheObject)newSec)->label_cache);

    LabG_Cache(req) = &(((XmLabelGCacheObject)reqSec)->label_cache);

   CBG_Cache(new_w) = &(((XmCascadeButtonGCacheObject)newSec)->

			cascade_button_cache);

     CBG_Cache(req) = &(((XmCascadeButtonGCacheObject)reqSec)->

			cascade_button_cache);

  XtGetSubresources(new_w,

                    newSec,

                    NULL, NULL,

                    wc->core_class.resources,

                    wc->core_class.num_resources,

                    args, *num_args );

  extData = (XmWidgetExtData) XtCalloc(1, sizeof(XmWidgetExtDataRec));

  extData->widget = (Widget)newSec;

  extData->reqWidget = (Widget)reqSec;

  ((XmCascadeButtonGCacheObject)newSec)->ext.extensionType = XmCACHE_EXTENSION;

  ((XmCascadeButtonGCacheObject)newSec)->ext.logicalParent = new_w;

  _XmPushWidgetExtData(new_w, extData,

		       ((XmCascadeButtonGCacheObject)newSec)->

		                                   ext.extensionType);

  memcpy(reqSec, newSec, size);

}

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

 *

 *  InitializePosthook

 *

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

/* ARGSUSED */

static void 

InitializePrehook(

        Widget req,

        Widget new_w,

        ArgList args,

        Cardinal *num_args )

{

  /* CR 2990: Use XmNbuttonFontList as the default. */

  if (LabG_Font(new_w) == NULL)

    LabG_Font(new_w) = XmeGetDefaultRenderTable (new_w, XmBUTTON_FONTLIST);

}

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

 *

 *  InitializePosthook

 *

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

/* ARGSUSED */

static void 

InitializePosthook(

        Widget req,

        Widget new_w,

        ArgList args,

        Cardinal *num_args )

{

    XmWidgetExtData     ext;

    XmCascadeButtonGadget  cbw = (XmCascadeButtonGadget)new_w;

    /*

    * - register parts in cache.

    * - update cache pointers

    * - and free req

    */

    _XmProcessLock();

    LabG_Cache(cbw) = (XmLabelGCacheObjPart *)

      _XmCachePart( LabG_ClassCachePart(cbw),

                    (XtPointer) LabG_Cache(cbw),

                    sizeof(XmLabelGCacheObjPart));

    CBG_Cache(cbw) = (XmCascadeButtonGCacheObjPart *)

           _XmCachePart( CBG_ClassCachePart(cbw),

                         (XtPointer) CBG_Cache(cbw),

                         sizeof(XmCascadeButtonGCacheObjPart));

   /*

    * might want to break up into per-class work that gets explicitly

    * chained. For right now, each class has to replicate all

    * superclass logic in hook routine

    */

   /*

    * free the req subobject used for comparisons

    */

    _XmPopWidgetExtData((Widget) cbw, &ext, XmCACHE_EXTENSION);

    _XmExtObjFree((XtPointer) ext->widget);

    _XmExtObjFree((XtPointer) ext->reqWidget);

    XtFree( (char *) ext);

    _XmProcessUnlock();

}

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

 *

 *  _XmCascadeBCacheCompare

 *

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

static int 

_XmCascadeBCacheCompare(

        XtPointer A,

        XtPointer B )

    {

    XmCascadeButtonGCacheObjPart *cascadeB_inst =

	(XmCascadeButtonGCacheObjPart *) A ;

    XmCascadeButtonGCacheObjPart *cascadeB_cache_inst =

	(XmCascadeButtonGCacheObjPart *) B ;

   if((cascadeB_inst->cascade_pixmap == cascadeB_cache_inst->cascade_pixmap) &&

      (cascadeB_inst->map_delay == cascadeB_cache_inst->map_delay) &&

      (cascadeB_inst->armed_pixmap == cascadeB_cache_inst->armed_pixmap) &&

      (cascadeB_inst->arm_gc == cascadeB_cache_inst->arm_gc) &&

      (cascadeB_inst->background_gc == cascadeB_cache_inst->background_gc)) 

        return 1;

   else

        return 0;

}

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

 * _XmArrowPixmapCacheCompare()

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

int 

_XmArrowPixmapCacheCompare(

        XtPointer A,

        XtPointer B )

{

   XmArrowPixmap *arrowpix_rec = (XmArrowPixmap *) A ;

   XmArrowPixmap *arrowpix_cache_rec = (XmArrowPixmap *) B ;

   if ((arrowpix_rec->height == arrowpix_cache_rec->height) &&

       (arrowpix_rec->width == arrowpix_cache_rec->width) &&

       (arrowpix_rec->screen == arrowpix_cache_rec->screen) &&

       (arrowpix_rec->depth == arrowpix_cache_rec->depth) &&

       (arrowpix_rec->direction == arrowpix_cache_rec->direction) &&

    (arrowpix_rec->top_shadow_color ==

          arrowpix_cache_rec->top_shadow_color) &&

       (arrowpix_rec->bottom_shadow_color ==

          arrowpix_cache_rec->bottom_shadow_color) &&

       (arrowpix_rec->foreground_color ==

          arrowpix_cache_rec->foreground_color))

      return 1;

   else

      return 0;

}

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

 * _XmArrowPixmapCacheDelete()

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

void 

_XmArrowPixmapCacheDelete(

        XtPointer data )

{

        Pixmap pixmap = (Pixmap) data ;

   XmGadgetCachePtr ptr;

   XmArrowPixmap *arrowpix_rec;

   ptr =  (XmGadgetCachePtr)(ClassCacheHead(&ArrowPixmapCache)).next;

   while (ptr)

   {

     arrowpix_rec = (XmArrowPixmap *)(CacheDataPtr(ptr));

     if (pixmap == arrowpix_rec->pixmap)

     {

        if (--ptr->ref_count <= 0)

        {

          (ptr->prev)->next = ptr->next;

          if (ptr->next)                    /* not the last record */

            (ptr->next)->prev = ptr->prev;

          XmDestroyPixmap(arrowpix_rec->screen, arrowpix_rec->pixmap);

          XtFree( (char *) ptr);

        }

        return;

     }

     else

        ptr = (XmGadgetCachePtr)ptr->next;

   }

}

/*

 * Border highlighting is only allowed for option menus.  Otherwise

 * the button is armed (does not pop up submenus).

 */

static void 

BorderHighlight(

        Widget wid )

{

        XmCascadeButtonGadget cb = (XmCascadeButtonGadget) wid ;

   if (LabG_MenuType(cb) == XmMENU_OPTION)

      (* ((XmGadgetClass) xmGadgetClass)->

             gadget_class.border_highlight) ((Widget) cb);

   else

      Arm (cb);

}

/*

 * Border unhighlighting only done in option menus.  Otherwise the button

 * is disarmed (does not pop down submenus).

 */

static void 

BorderUnhighlight(

        Widget wid )

{

        XmCascadeButtonGadget cb = (XmCascadeButtonGadget) wid ;

   if (LabG_MenuType(cb) == XmMENU_OPTION)

      (* ((XmGadgetClass) xmGadgetClass)->

             gadget_class.border_unhighlight) ((Widget) cb);

   else

      Disarm (cb, False);

}

/*

 * Draw the 3D shadow around the widget if its in an option menu or if the

 * widget is armed.

 */

static void 

DrawShadow(

        XmCascadeButtonGadget cb )

{

  XmDisplay dpy = (XmDisplay) XmGetXmDisplay(XtDisplay((Widget) cb));

  Boolean etched_in;

  etched_in = dpy -> display.enable_etched_in_menu 

    && (! (LabG_MenuType(cb) == XmMENU_OPTION)) ;

  if (CBG_IsArmed(cb) ||

      (LabG_MenuType(cb) == XmMENU_OPTION))

    {

      if (XtIsRealized(XtParent(cb)))

      {

	 XmeDrawShadows (XtDisplay (cb), XtWindow (XtParent(cb)),

			LabG_TopShadowGC(cb),

			LabG_BottomShadowGC(cb),

			cb->gadget.highlight_thickness + cb->rectangle.x,

			cb->gadget.highlight_thickness + cb->rectangle.y,

			 cb->rectangle.width - 2 * 

			cb->gadget.highlight_thickness,

			 cb->rectangle.height - 2 * 

			cb->gadget.highlight_thickness,

			cb->gadget.shadow_thickness,

			etched_in ? XmSHADOW_IN : XmSHADOW_OUT);

      }

   }

}

static void 

DrawCascade(

        register XmCascadeButtonGadget cb )

{

   if ((CBG_HasCascade(cb)) && (CBG_Cascade_width(cb) != 0))

   {

      /* draw the casacade */

      if ((LabG_MenuType(cb) == XmMENU_OPTION) &&

	  (CBG_CascadePixmap(cb) == XmUNSPECIFIED_PIXMAP))

      {

	 Dimension height, width;

	 Dimension offset_y;

         Dimension offset_x;

	 switch(CBG_Cascade_height(cb) - 2*G_ShadowThickness(cb)) {

	    case 5:

	    case 6:

	       height = 1;

	       width =  CBG_Cascade_width(cb) - 3;