/* $TOG: IconG.c /main/28 1999/01/26 15:30:46 mgreess $ */

/*

 * 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 HAVE_CONFIG_H

#include <config.h>

#endif

#include <Xm/AccColorT.h>

#include <Xm/CareVisualT.h>

#include <Xm/ContItemT.h>

#include <Xm/ContainerT.h>

#include <Xm/PointInT.h>

#include <Xm/DrawP.h>

#include <Xm/IconGP.h>

#include <Xm/TraitP.h>		/* for XmeTraitSet */

#include <Xm/XmosP.h>

#include <Xm/VaSimpleP.h>

#include "BaseClassI.h"

#include "CacheI.h"

#include "ColorI.h"

#include "DrawI.h"

#include "ExtObjectI.h"

#include "ImageCachI.h"

#include "MessagesI.h"

#include "PixConvI.h"

#include "RepTypeI.h"

#include "ScreenI.h"

#include "SyntheticI.h"

#include "TravActI.h"

#include "XmI.h"

#include "XmTabListI.h"

#include "XmosI.h"

#include "IconGI.h"

#include <Xm/XmP.h>

/* spacing between the line and the detail string.

   Those could be moved as plain resources later. */

#define DEFAULT_LABEL_MARGIN_WIDTH	2 

#define DEFAULT_LABEL_MARGIN_HEIGHT	2 

#define DEFAULT_HOR_SPACING		4 

/* This macro should probably be put in XmI.h and used everywhere */

#define PIXMAP_VALID(pix) \

    (pix != XmUNSPECIFIED_PIXMAP && pix != None)

#define SHOW_DETAIL(wid, container_data) \

    (IG_Detail(wid) && IG_DetailCount(wid) && \

     (container_data)->detail_order_count)

#define INVALID_DIMENSION ((Dimension)-1)

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

       /* XmRCallProcs */

static void 			CheckSetRenderTable(

					Widget 		wid,

					int		offset, 

					XrmValue 	*value); 

       /* Converters */

static Boolean CvtStringToIconPixmap( 

                        Display *dpy,

                        XrmValue *args,

                        Cardinal *numArgs,

                        XrmValue *fromVal,

                        XrmValue *toVal,

                        XtPointer *closure_ret) ;

        /* Hooks */

static	void			GetLabelString(

					Widget		wid,

					int		offset,

					XtArgVal	*value);

	/* BaseClass methods */

static void SecondaryObjectCreate( 

                        Widget req,

                        Widget new_w,

                        ArgList args,

                        Cardinal *num_args) ;

static void InitializePosthook( 

                        Widget req,

                        Widget new_w,

                        ArgList args,

                        Cardinal *num_args) ;

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 int IconGCacheCompare( 

                        XtPointer A,

                        XtPointer B) ;

static Cardinal GetIconGClassSecResData( 

                        WidgetClass w_class,

                        XmSecondaryResourceData **data_rtn) ;

static XtPointer GetIconGClassSecResBase( 

                        Widget widget,

                        XtPointer client_data) ;

	/* RectObj methods */

static	void			ClassInitialize( void );

static	void			ClassPartInitialize(

					WidgetClass	wc);

static	void			Initialize(

					Widget		rw,

					Widget          nw,

					ArgList         args,

					Cardinal        *num_args);

static	void			Destroy(

					Widget  wid);

static	void			Redisplay(

					Widget		wid,

					XEvent		*event,

					Region		region);

static	Boolean			SetValues(

					Widget		cw,

					Widget		rw,

					Widget		nw,

					ArgList		args,

					Cardinal	*num_args);

static	XtGeometryResult	QueryGeometry(

					Widget		wid,

					XtWidgetGeometry *intended,

					XtWidgetGeometry *reply);

	/* XmGadget methods */

static  void 			HighlightBorder( 

						Widget w) ;

static  void 			UnhighlightBorder( 

						Widget w) ;

static	void			InputDispatch(

					Widget		wid,

					XEvent		*event,

					Mask		event_mask);

static	Boolean			GetBaselines(

					Widget		wid,

					Dimension	**baselines,

					int		*line_count);

static	void			MarginsProc(

					Widget		w,

				        XmBaselineMargins *margins_rec);

static	Boolean			GetDisplayRect(

					Widget		wid,

					XRectangle	*displayrect);

	/* XmIconGadget methods */

	/* Action procs */

	/* Internal functions */

static	void                    GetLabelXY(

					   Widget		wid,

					   Position * x_ret,

					   Position * y_ret);

static	Position                GetLargeIconX(

					      Widget		wid);

static	Position                GetSmallIconY(

					      Widget		wid);

static	Dimension		GetIconLabelWidth(

					Widget		wid);

static	Dimension		GetIconLabelHeight(

					Widget		wid);

static Cardinal                 GetShapeInfo(

					     Widget wid,

					     Position large_icon_x,

					     Position small_icon_y,

					     Position label_x,

					     Position label_y,

					     Dimension first_column_width,

					     Dimension ht,

					     XPoint * points);

static  void                    GetContainerData(

					Widget wid,

					XmContainerData container_data);

static	void			ChangeHighlightGC(

						  Widget	wid,

						  XtEnum selection_mode,

						  int    line_width);

static	void			UpdateSelectGCs(

						Widget		wid,

						Pixel select_color);

static	void			UpdateGCs(

					Widget		wid);

static	XmStringTable           GetStringTableReOrdered(

							XmStringTable st,

							Cardinal st_count,

							Cardinal * order,

							Cardinal order_count);

static	void                    GetStringTableExtent(

						     Screen * screen,

						     XmStringTable st,

						     Cardinal st_count,

						     XmRenderTable render_table,

						     XmTabList tab_list,

						     Dimension hor_spacing, 

						     Dimension * width_ret,

						     Dimension * height_ret,

						     Position * baseline_ret);

static	void			GetSize(

					Widget		wid,

					Dimension	*ideal_width,

					Dimension	*ideal_height);

	/* Trait methods */

static	void ContItemSetValues(Widget w, 

			       XmContainerItemData contItemData);

static	void ContItemGetValues(Widget w, 

			       XmContainerItemData contItemData);

static  Boolean HandleRedraw (Widget kid, 

			      Widget cur_parent,

			      Widget new_parent,

			      Mask visual_flag);

static  void GetColors(Widget widget, 

		       XmAccessColorData color_data);

static  Boolean PointIn(Widget widget, 

		        Position x, Position y);

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

/*** Xt trivia: How do you manage a flag that tells you that something 

     happened during a resource conversion ?

     We need a association outside the widget instance for the

     OwnIconMask flag. This is because the converter sets this flag

     and the widget Initialize cannot initialize it afterward without

     overiding it.

     So we use the XContext manager for that. 

     (I could probably have used private resource too...)  ***/

/* those are created in ClassInitialize and filled by the

   IconConverter. */

static XContext 	largeIconContext = (XContext) NULL;

static XContext		smallIconContext = (XContext) NULL;

static XPointer dummy;

#define OwnLargeMask(widget) \

        (XFindContext(XtDisplay(widget),  \

		     (Window) widget,   \

		     largeIconContext,  \

		     &dummy) == 0)

#define OwnSmallMask(widget) \

        (XFindContext(XtDisplay(widget),  \

		     (Window) widget,   \

		     smallIconContext,  \

		     &dummy) == 0)

#define MESSAGE0	_XmMMsgPixConv_0000

/***** The resources of this class */

static	XtResource		resources[] = 

{

    /* The following hackery is a way in Xt to see if a

       widget has been initialized. We need to know whether or not 

       the gadget cache is valid. We use "." in the name so that

       an end user cannot access it from a resource file.

       With that in place, we just need to check IG_Cache(w) != NULL

       to see if the gadget has been initialized. */

    {

	XmNdotCache, XmCDotCache, XmRPointer, sizeof(XtPointer),

	XtOffset(XmIconGadget, icong.cache), 

	XtRImmediate, (XtPointer) NULL},

    {

	XmNlabelString,XmCXmString,XmRXmString,sizeof(XmString),

	XtOffset(XmIconGadget,icong.label_string),

	XmRImmediate,(XtPointer)NULL},

    {

	XmNlargeIconMask,XmCIconMask,XmRBitmap,sizeof(Pixmap),

	XtOffset(XmIconGadget,icong.large_icon_mask),

	XmRImmediate,(XtPointer)XmUNSPECIFIED_PIXMAP},

    {

	XmNlargeIconPixmap,XmCIconPixmap,XmRLargeIconPixmap,sizeof(Pixmap),

	XtOffset(XmIconGadget,icong.large_icon_pixmap),

	XmRImmediate,(XtPointer)XmUNSPECIFIED_PIXMAP},

    {

	XmNsmallIconMask,XmCIconMask,XmRBitmap,sizeof(Pixmap),

	XtOffset(XmIconGadget,icong.small_icon_mask),

	XmRImmediate,(XtPointer)XmUNSPECIFIED_PIXMAP},

    {

	XmNsmallIconPixmap,XmCIconMask,XmRSmallIconPixmap,sizeof(Pixmap),

	XtOffset(XmIconGadget,icong.small_icon_pixmap),

	XmRImmediate,(XtPointer)XmUNSPECIFIED_PIXMAP},

    {

	XmNviewType,XmCViewType,XmRViewType,sizeof(unsigned char),

	XtOffset(XmIconGadget,icong.viewtype),

	XmRImmediate,(XtPointer)XmLARGE_ICON},

    {

	XmNvisualEmphasis,XmCVisualEmphasis,XmRVisualEmphasis,

	sizeof(unsigned char),

	XtOffset(XmIconGadget,icong.visual_emphasis),

	XmRImmediate,(XtPointer)XmNOT_SELECTED},

    {

	XmNdetail,XmCDetail,XmRXmStringTable,

	sizeof(XmStringTable),

	XtOffset(XmIconGadget,icong.detail),

	XmRImmediate,(XtPointer)NULL},

    {

	XmNdetailCount,XmCDetailCount,XmRCardinal,sizeof(Cardinal),

	XtOffset(XmIconGadget,icong.detail_count),

	XmRImmediate,(XtPointer)0},

   {

	"pri.vate","Pri.vate",XmRBoolean,

	sizeof(Boolean), 

	XtOffset(XmIconGadget, icong.check_set_render_table),

	XmRImmediate, (XtPointer) False},

};

static XtResource cache_resources[] = 

{

   {

     XmNfontList, XmCFontList, XmRFontList,

     sizeof(XmRenderTable),

     XtOffsetOf(XmIconGCacheObjRec, icon_cache.render_table),

     XmRCallProc,(XtPointer)CheckSetRenderTable

   },

   {

     XmNrenderTable, XmCRenderTable, XmRRenderTable,

     sizeof(XmRenderTable),

     XtOffsetOf(XmIconGCacheObjRec, icon_cache.render_table),

     XmRCallProc,(XtPointer)CheckSetRenderTable

   },

   {

     XmNbackground, XmCBackground, XmRPixel, 

     sizeof (Pixel), 

     XtOffsetOf(XmIconGCacheObjRec, icon_cache.background),

     XmRCallProc, (XtPointer) _XmBackgroundColorDefault

   },

   {

     XmNforeground, XmCForeground, XmRPixel, 

     sizeof (Pixel),

     XtOffsetOf(XmIconGCacheObjRec, icon_cache.foreground),

     XmRCallProc, (XtPointer) _XmForegroundColorDefault

   },

   {

     XmNtopShadowColor, XmCTopShadowColor, XmRPixel, 

     sizeof (Pixel),

     XtOffsetOf(XmIconGCacheObjRec, icon_cache.top_shadow_color),

     XmRCallProc, (XtPointer) _XmTopShadowColorDefault

   },

   {

     XmNbottomShadowColor, XmCBottomShadowColor, XmRPixel, 

     sizeof (Pixel),

     XtOffsetOf(XmIconGCacheObjRec, icon_cache.bottom_shadow_color),

     XmRCallProc, (XtPointer) _XmBottomShadowColorDefault

   },

   {

     XmNhighlightColor, XmCHighlightColor, XmRPixel, 

     sizeof (Pixel),

     XtOffsetOf(XmIconGCacheObjRec, icon_cache.highlight_color),

     XmRCallProc, (XtPointer) _XmHighlightColorDefault

   },

   {

     XmNbackgroundPixmap, XmCBackgroundPixmap, XmRPixmap,

     sizeof (Pixmap),

     XtOffsetOf(XmIconGCacheObjRec, icon_cache.background_pixmap),

     XmRImmediate, (XtPointer) XmUNSPECIFIED_PIXMAP

   },

   {

     XmNtopShadowPixmap, XmCTopShadowPixmap, XmRTopShadowPixmap,

     sizeof (Pixmap),

     XtOffsetOf(XmIconGCacheObjRec, icon_cache.top_shadow_pixmap),

     XmRCallProc, (XtPointer) _XmTopShadowPixmapDefault

   },

   {

     XmNbottomShadowPixmap, XmCBottomShadowPixmap, XmRBottomShadowPixmap,

     sizeof (Pixmap),

     XtOffsetOf(XmIconGCacheObjRec, icon_cache.bottom_shadow_pixmap),

     XmRImmediate, (XtPointer) XmUNSPECIFIED_PIXMAP

   },

   {

     XmNhighlightPixmap, XmCHighlightPixmap, XmRHighlightPixmap,

     sizeof (Pixmap),

     XtOffsetOf(XmIconGCacheObjRec, icon_cache.highlight_pixmap),

     XmRCallProc, (XtPointer) _XmHighlightPixmapDefault

   },

   {

     XmNalignment, XmCAlignment, XmRAlignment, sizeof(unsigned char),

     XtOffsetOf(XmIconGCacheObjRec, icon_cache.alignment),

     XmRImmediate, (XtPointer) XmALIGNMENT_CENTER

   },

   {

     XmNspacing, XmCSpacing, XmRHorizontalDimension, sizeof(Dimension),

     XtOffsetOf(XmIconGCacheObjRec, icon_cache.spacing),

     XmRImmediate, (XtPointer) 4

   },

   {

     XmNmarginWidth, XmCMarginWidth, XmRHorizontalDimension, 

     sizeof(Dimension),

     XtOffsetOf(XmIconGCacheObjRec, icon_cache.margin_width), 

     XmRImmediate, (XtPointer) 2

   },

   {

     XmNmarginHeight, XmCMarginHeight, XmRVerticalDimension, 

     sizeof(Dimension),

     XtOffsetOf(XmIconGCacheObjRec, icon_cache.margin_height),

     XmRImmediate, (XtPointer) 2

   },

};

static	XmSyntheticResource	syn_resources[] =

{

    {

	XmNlabelString,sizeof(XmString),

	XtOffset(XmIconGadget,icong.label_string),GetLabelString,NULL

	},

};

static	XmSyntheticResource	cache_syn_resources[] =

{

    { 

      XmNspacing, sizeof(Dimension),

      XtOffsetOf(XmIconGCacheObjRec, icon_cache.spacing), 

      XmeFromHorizontalPixels, XmeToHorizontalPixels 

    },

    { 

      XmNmarginWidth, sizeof(Dimension),

      XtOffsetOf(XmIconGCacheObjRec, icon_cache.margin_width), 

      XmeFromHorizontalPixels, XmeToHorizontalPixels 

    },

    { 

      XmNmarginHeight, sizeof(Dimension),

      XtOffsetOf(XmIconGCacheObjRec, icon_cache.margin_height),

      XmeFromVerticalPixels, XmeToVerticalPixels 

    },

};

/* ext rec static initialization */

externaldef(xmicongcacheobjclassrec)

XmIconGCacheObjClassRec xmIconGCacheObjClassRec =

{

  {

    /* superclass         */    (WidgetClass) &xmExtClassRec,

    /* class_name         */    "XmIconGadget",

    /* widget_size        */    sizeof(XmIconGCacheObjRec),

    /* 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 */   cache_syn_resources,

    /* num_syn_resources   */   XtNumber(cache_syn_resources),

    /* extension           */   NULL,

  }

};

static XmBaseClassExtRec   iconGBaseClassExtRec = {

    NULL,    					/* next_extension        */

    NULLQUARK,					/* record_typ            */

    XmBaseClassExtVersion,			/* version               */

    sizeof(XmBaseClassExtRec),			/* record_size           */

    XmInheritInitializePrehook,			/* initializePrehook     */

    SetValuesPrehook,				/* setValuesPrehook      */

    InitializePosthook,				/* initializePosthook    */

    SetValuesPosthook,				/* setValuesPosthook     */

    (WidgetClass)&xmIconGCacheObjClassRec,	/* secondaryObjectClass  */

    SecondaryObjectCreate,		        /* secondaryObjectCreate */

    GetIconGClassSecResData,	                /* getSecResData */

    {0},			                /* Other Flags           */

    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          */

};

static XmCacheClassPart IconGClassCachePart = {

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

    _XmCacheCopy,       /* Copy routine     */

    _XmCacheDelete,     /* Delete routine   */

    IconGCacheCompare,    /* Comparison routine   */

};

static XmGadgetClassExtRec GadClassExtRec = {

    NULL,

    NULLQUARK,

    XmGadgetClassExtVersion,

    sizeof(XmGadgetClassExtRec),

    GetBaselines,			/* widget_baseline */

    GetDisplayRect,			/* widget_display_rect */

    MarginsProc,                        /* widget_margins */

};

externaldef( xmicongadgetclassrec) XmIconGadgetClassRec	xmIconGadgetClassRec =

{	/* RectObjClassPart */

    {	

	(WidgetClass) &xmGadgetClassRec, /* superclass		*/

	"XmIconGadget",			/* class_name		*/

	sizeof (XmIconGadgetRec),	/* widget_size		*/

	ClassInitialize,		/* class_initialize	*/

	ClassPartInitialize,		/* class_part_initialize*/

	False,				/* class_inited		*/

	Initialize,			/* initialize		*/

	NULL,				/* initialize_hook	*/

	NULL,				/* realize		*/

	NULL,				/* actions		*/

	0,				/* num_actions		*/

	resources,			/* resources		*/

	XtNumber (resources),		/* num_resources	*/

	NULLQUARK,			/* xrm_class		*/

	True,				/* compress_motion	*/

	True,				/* compress_exposure	*/

	True,				/* compress_enterleave	*/

	False,				/* visible_interest	*/	

	Destroy,		 	/* destroy		*/	

	NULL,				/* resize		*/

	Redisplay,			/* expose		*/	

	SetValues,			/* set_values		*/	

	NULL,				/* set_values_hook	*/

	XtInheritSetValuesAlmost,	/* set_values_almost	*/

	NULL,				/* get_values_hook	*/

	NULL,				/* accept_focus		*/	

	XtVersion,			/* version		*/

	NULL,				/* callback private	*/

	NULL,				/* tm_table		*/

	QueryGeometry,			/* query_geometry	*/

	NULL,				/* display_accelerator	*/

	(XtPointer)&iconGBaseClassExtRec,	/* extension	*/

    },

    /* XmGadget Class Part */

    {

	HighlightBorder,		        /* border_highlight	*/

	UnhighlightBorder,		        /* border_unhighlight	*/

	NULL,					/* arm_and_activate	*/

	InputDispatch,				/* input_dispatch	*/

	NULL,				        /* visual_change	*/

	syn_resources,				/* get_resources	*/

	XtNumber(syn_resources),		/* num_get_resources	*/

	&IconGClassCachePart,		        /* class_cache_part	*/

	(XtPointer)&GadClassExtRec,	        /* extension		*/

    },

	/* XmIconGadget Class Part */

    {

	NULL,		/* get_container_parent	*/

	NULL,		/* extension	*/

    },

};

externaldef(xmicongadgetclass) WidgetClass

	xmIconGadgetClass=(WidgetClass)&xmIconGadgetClassRec;

/* ContainerItem Trait record for IconGadget */

static XmConst XmContainerItemTraitRec iconCIT = {

  0,		/* version */

  ContItemSetValues,

  ContItemGetValues,

};

/* CareVisual Trait record for IconGadget */

static XmConst XmCareVisualTraitRec iconCVT = {

    0,		/* version */

    HandleRedraw,

};

/* Access Colors Trait record for IconGadget */

static XmConst XmAccessColorsTraitRec iconACT = {

  0,			/* version */

  GetColors

};

/* Point In Trait record for IconGadget */

static XmConst XmPointInTraitRec iconPIT = {

  0,			/* version */

  PointIn,

};

/******** for the special IconPixmap/Mask converter */

static XtConvertArgRec largeIconArgs[] =

{

   { XtBaseOffset, (XtPointer) 0, sizeof (int) },

   { XtAddress, (XtPointer)(int)XmLARGE_ICON, 0}

};

static XtConvertArgRec smallIconArgs[] =

{

   { XtBaseOffset, (XtPointer) 0, sizeof (int) },

   { XtAddress, (XtPointer)(int)XmSMALL_ICON, 0}

};

/*** XmRCallProcs ***/

/*

 * XmRCallProc routine for checking icon_cache.render_table before setting 

 * it to NULL. If "check_set_render_table" is True, then function has 

 * been called twice on same widget, thus resource needs to be set NULL, 

 * otherwise leave it alone.

 */

/*ARGSUSED*/

static void 

CheckSetRenderTable(Widget wid,

		    int offset,

		    XrmValue *value)

{

  XmIconGadget ig = (XmIconGadget)wid;

  /* Check if been here before */

  if (ig->icong.check_set_render_table)

      value->addr = NULL;

  else {

      ig->icong.check_set_render_table = True;

      value->addr = (char*)&(IG_RenderTable(ig));

  }

}

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

 *

 *  FetchPixmap

 *

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

/*ARGSUSED*/

static void 

FetchPixmap(

        Widget widget,

        String image_name,

        unsigned char res_type,

        Pixmap * pixmap)	

{

   int depth ;

   XtPointer mask_addr ;

   XmAccessColorDataRec acc_color_rec;

   XmAccessColorsTrait access_colors_trait ;

   depth = - XtParent(widget)->core.depth;

   /* this is the convention used by XmGetPixmapByDepth, pass

      a negative depth means do bitmap if you can */

   /* always called when the cache is valid and the colors

      can be returned */

   access_colors_trait = (XmAccessColorsTrait) 

       XmeTraitGet((XtPointer)XtClass(widget), XmQTaccessColors) ;

   access_colors_trait->getColors(widget, &acc_color_rec);

   *pixmap = _XmGetScaledPixmap (XtScreen(widget), widget,

				 image_name, &acc_color_rec, 

				 depth, FALSE, 0);

   if (*pixmap == XmUNSPECIFIED_PIXMAP) {

       return ;   

   }

   /* now we see if a mask is to be fetched too */

   if (res_type == XmLARGE_ICON) {

       mask_addr = (XtPointer)&(IG_LargeIconMask(widget)) ;

   } else {

       mask_addr = (XtPointer)&(IG_SmallIconMask(widget)) ;

   }	   

   /* fetch only if a mask has not been specified in the resource slot */

   if (*(Pixmap *)mask_addr == XmUNSPECIFIED_PIXMAP) {

       char mask_name[255] ;

       /* Fetch the mask out of image_name and ask for it.

	  ImageCache:

	  The mask_name returned is the same as the one used by the 

	  ImageCache reader to cache the mask associated with an XPM file, 

	  so we will get it from the cache if an XPM file with a mask was

	  specified for image_name. When an XPM file with a mask 

	  in it is read, the mask is cached with mask_name. */

       _XmOSGenerateMaskName(image_name, mask_name) ;

       *(Pixmap*)mask_addr = (Pixmap) XmGetScaledPixmap(widget,

							mask_name,

							1, 0, 1, 0);

       /* mark that we have to destroy the mask */

       if (*(Pixmap *)mask_addr != XmUNSPECIFIED_PIXMAP) {

	   if (res_type == XmLARGE_ICON) {

	       XSaveContext(XtDisplay(widget), 

			    (Window) widget, 

			    largeIconContext, 

			    (XPointer) True);

	   } else {

	       XSaveContext(XtDisplay(widget), 

			    (Window) widget, 

			    smallIconContext, 

			    (XPointer) True);

	   }	   

       }

   }

}

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

 *

 *  CvtStringToIconPixmap

 *

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

/*ARGSUSED*/

static Boolean 

CvtStringToIconPixmap(

        Display *dpy,

        XrmValue *args,

        Cardinal *numArgs,

        XrmValue *fromVal,

        XrmValue *toVal,

        XtPointer *closure_ret)	/* unused */

{

   Pixmap pixmap = XmUNSPECIFIED_PIXMAP;

   String image_name = (String) (fromVal->addr);

   Widget widget ;

   unsigned char res_type;

   if (*numArgs != 2) {

       XtAppWarningMsg (XtDisplayToApplicationContext(dpy),

			"wrongParameters", "cvtStringToPixmap",

			"XtToolkitError", MESSAGE0,

			(String *) NULL, (Cardinal *)NULL);

       return False;

   }

   /* CR 7568: Set widget before we use it. */

   widget = *((Widget *) args[0].addr);

   /* get back the resource type: LARGE or SMALL_ICON */

   res_type = (unsigned char) (int) (long) args[1].addr;

   if (XmeNamesAreEqual(image_name, "none")) {

       pixmap = None ;

       _XM_CONVERTER_DONE ( toVal, Pixmap, pixmap, 

	     XmDestroyPixmap(XtScreen(widget), pixmap) ;)

   }

   if (XmeNamesAreEqual(image_name, XmSunspecified_pixmap)) {

       pixmap = XmUNSPECIFIED_PIXMAP ;

       _XM_CONVERTER_DONE ( toVal, Pixmap, pixmap, 

	     XmDestroyPixmap(XtScreen(widget), pixmap) ;)

   }

   /* First we have to check if the gadget has been initialized

      before trying to create the pixmap. We need the colors

      and if the cache is not yet created, we have to delay

      the conversion. */

   if (!IG_Cache(widget)) {

       pixmap = XmDELAYED_PIXMAP;

       /* we need to stach away the name of the pixmap resource,

	  since we'll need it in Initialize, when XmDELAYED_PIXMAP is

	  treated, and XtGetSubResources is not going to work for

	  XtVaTypeArg time resource, which are not in the database. */

       if (res_type == XmLARGE_ICON)

	   IG_LargePixmapName(widget) = image_name ;

       else

	   IG_SmallPixmapName(widget) = image_name ;

       _XM_CONVERTER_DONE ( toVal, Pixmap, pixmap, 

	     XmDestroyPixmap(XtScreen(widget), pixmap) ;)

   }

   /* fetch the pixmap */

   FetchPixmap(widget, image_name, res_type, &pixmap);

   if (pixmap == XmUNSPECIFIED_PIXMAP) {

       XtDisplayStringConversionWarning(dpy, image_name, 

					"Large/SmallIconPixmap");

       return False;   

   }

   _XM_CONVERTER_DONE ( toVal, Pixmap, pixmap, 

		       XmDestroyPixmap(XtScreen(widget), pixmap) ;)

}

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

 * GetLabelString

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

/*ARGSUSED*/

static	void

GetLabelString(

	Widget		wid,

	int		offset,	/* unused */

	XtArgVal	*value)

{

    XmString	string = NULL;

    if (IG_LabelString(wid)) 

	string = XmStringCopy(IG_LabelString(wid));

    *value = (XtArgVal)string;

}

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

*

*  SecondaryObjectCreate

*

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

/* ARGSUSED */

static void 

SecondaryObjectCreate(

        Widget req,

        Widget new_w,

        ArgList args,

        Cardinal *num_args )

{

  XmBaseClassExt              *cePtr;

  XmWidgetExtData             extData;

  WidgetClass                 wc;