/* 

 * 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

#ifdef REV_INFO

#ifndef lint

static char rcsid[] = "$TOG: VendorSE.c /main/21 1997/10/13 14:58:18 cshi $"

#endif

#endif

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

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

/* (c) Copyright 1988 MASSACHUSETTS INSTITUTE OF TECHNOLOGY  */

/* (c) Copyright 1988 MICROSOFT CORPORATION */

/*

 *  (c) Copyright 1995 FUJITSU LIMITED

 *  This is source code modified by FUJITSU LIMITED under the Joint

 *  Development Agreement for the CDEnext PST.

 *  This is unpublished proprietary source code of FUJITSU LIMITED

 */

/* Make sure all wm properties can make it out of the resource manager */

#ifndef X_NOT_STDC_ENV

#include <stdlib.h>

#endif

#include <string.h>

#include <Xm/Xm.h>		/* To make cpp on Sun happy. CR 5943 */

#include <X11/IntrinsicP.h>

#include <X11/ShellP.h>

#include <Xm/AtomMgr.h>

#include <Xm/BaseClassP.h>

#include <Xm/LayoutT.h>

#include <Xm/RepType.h>

#include <Xm/TraitP.h>

#include <Xm/VendorSEP.h>

#include "BaseClassI.h"

#include "CallbackI.h"

#include "MessagesI.h"

#include "ResIndI.h"

#include "SyntheticI.h"

#include "TraversalI.h"

#include "VendorSEI.h"

#include "XmI.h"

#define NOTVENDORSHELL	_XmMMsgProtocols_0000

#define DONT_CARE	-1L

#define BIGSIZE		((Dimension)32767)

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

static Boolean CvtStringToHorizontalInt( 

                        Display *dpy,

                        XrmValue *args,

                        Cardinal *num_args,

                        XrmValue *from_val,

                        XrmValue *toVal,

                        XtPointer *data) ;

static Boolean CvtStringToVerticalInt( 

                        Display *dpy,

                        XrmValue *args,

                        Cardinal *num_args,

                        XrmValue *from_val,

                        XrmValue *toVal,

                        XtPointer *data) ;

static void ClassInitialize( void ) ;

static void ClassPartInitialize( 

                        WidgetClass w) ;

static void DeleteWindowHandler( 

                        Widget wid,

                        XtPointer closure,

                        XtPointer call_data) ;

static void OffsetHandler( 

                        Widget shell,

                        XtPointer clientData,

                        XtPointer cd) ;

static void InitializePrehook( 

                        Widget req,

                        Widget new_w,

                        ArgList args,

                        Cardinal *num_args) ;

static void Destroy( 

                        Widget wid) ;

static void GetMWMFunctionsFromProperty( 

                        Widget wid,

                        int resource_offset,

                        XtArgVal *value) ;

static void CheckSetRenderTables(Widget wid,

				int offset,

				XrmValue *value); 

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

static XtConvertArgRec selfConvertArgs[] = {

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

};

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

 *

 * Vendor shell class record

 *

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

#define Offset(field) XtOffsetOf( struct _XmVendorShellExtRec, vendor.field)

static XtResource extResources[] =

{

    {

	XmNextensionType,

	XmCExtensionType, XmRExtensionType, sizeof (unsigned char),

	XtOffsetOf( struct _XmExtRec, ext.extensionType),

	XmRImmediate, (XtPointer)XmSHELL_EXTENSION,

    },

    {

	XmNdefaultFontList,

	XmCDefaultFontList, XmRFontList, sizeof (XmFontList),

	Offset (default_font_list),

	XmRImmediate, (XtPointer) NULL, 

    },

    {

        "pri.vate",

        "Pri.vate", XmRUnsignedChar, sizeof (unsigned char),

        Offset (mapStyle),

	XmRImmediate, 0

    },

    {

        XmNbuttonFontList,

        XmCButtonFontList, XmRButtonFontList, sizeof (XmFontList),

        Offset (button_font_list),

	XmRCallProc, (XtPointer)CheckSetRenderTables, 

    },

    {

        XmNlabelFontList,

        XmCLabelFontList, XmRLabelFontList, sizeof (XmFontList),

        Offset (label_font_list),

	XmRCallProc, (XtPointer)CheckSetRenderTables, 

    },

    {

        XmNtextFontList,

        XmCTextFontList, XmRTextFontList, sizeof (XmFontList),

        Offset (text_font_list),

	XmRCallProc, (XtPointer)CheckSetRenderTables, 

    },

    {

        XmNbuttonRenderTable,

        XmCButtonRenderTable, XmRButtonRenderTable, sizeof (XmRenderTable),

        Offset (button_font_list),

	XmRCallProc, (XtPointer)CheckSetRenderTables, 

    },

    {

        XmNlabelRenderTable,

        XmCLabelRenderTable, XmRLabelRenderTable, sizeof (XmRenderTable),

        Offset (label_font_list),

	XmRCallProc, (XtPointer)CheckSetRenderTables, 

    },

    {

        XmNtextRenderTable,

        XmCTextRenderTable, XmRTextRenderTable, sizeof (XmRenderTable),

        Offset (text_font_list),

	XmRCallProc, (XtPointer)CheckSetRenderTables, 

    },

    {

	XmNaudibleWarning, XmCAudibleWarning, XmRAudibleWarning,

	sizeof (Boolean), Offset (audible_warning),

	XmRImmediate, (XtPointer) XmBELL,

    },    

    {

	XmNshellUnitType, XmCShellUnitType, XmRUnitType, 

	sizeof (unsigned char), Offset (unit_type),

	XmRImmediate, (XtPointer) XmPIXELS,

    },	

    {

	XmNdeleteResponse, XmCDeleteResponse, 

	XmRDeleteResponse, sizeof(unsigned char),

	Offset(delete_response), 

	XmRImmediate, (XtPointer) XmDESTROY,

    },

    {

	XmNinputPolicy, XmCInputPolicy, 

	XmRInputPolicy, sizeof(XmInputPolicy),

	Offset(input_policy), 

	XmRImmediate, (XtPointer) XmPER_SHELL,

    },    

    {

	XmNkeyboardFocusPolicy, XmCKeyboardFocusPolicy, XmRKeyboardFocusPolicy, 

	sizeof(unsigned char),

	Offset(focus_policy), 

	XmRImmediate, (XtPointer)XmEXPLICIT,

    },

    { 

	XmNmwmDecorations, XmCMwmDecorations, XmRInt, 

	sizeof(int), Offset(mwm_hints.decorations), 

	XmRImmediate, (XtPointer) DONT_CARE,

    },

    { 

	XmNmwmFunctions, XmCMwmFunctions, XmRInt, 

	sizeof(int), Offset(mwm_hints.functions), 

	XmRImmediate, (XtPointer) DONT_CARE,

    },

    { 

	XmNmwmInputMode, XmCMwmInputMode, XmRInt, 

	sizeof(int), Offset(mwm_hints.input_mode), 

	XmRImmediate, (XtPointer) DONT_CARE,

    },

    { 

	XmNmwmMenu, XmCMwmMenu, XmRString, 

	sizeof(String), Offset(mwm_menu), 

	XmRImmediate, (XtPointer) NULL, 

    },

    { 

	XmNfocusMovedCallback, XmCCallback, XmRCallback, 

	sizeof(XtCallbackList), Offset(focus_moved_callback), 

	XmRImmediate, NULL,

    },

    { 

	XmNrealizeCallback, XmCCallback, XmRCallback, 

	sizeof(XtCallbackList), Offset(realize_callback), 

	XmRImmediate, NULL,

    },

    { 

	XmNinputMethod, XmCInputMethod, XmRString, 

	sizeof(String), Offset(input_method_string), 

	XmRImmediate, NULL,

    },

    { 

	XmNpreeditType, XmCPreeditType, XmRString, 

	sizeof(String), Offset(preedit_type_string), 

	XmRImmediate, "OverTheSpot,OffTheSpot,Root,OnTheSpot",

    },

    {

      XmNlightThreshold, XmCLightThreshold, XmRInt,

      sizeof(unsigned int), Offset(light_threshold),

      XmRImmediate, NULL,

    },

    {

      XmNdarkThreshold, XmCDarkThreshold, XmRInt,

      sizeof(unsigned int), Offset(dark_threshold),

      XmRImmediate, NULL,

    },

    {

      XmNforegroundThreshold, XmCForegroundThreshold, XmRInt,

      sizeof(unsigned int), Offset(foreground_threshold),

      XmRImmediate, NULL,

    },

    {

      XmNlayoutDirection, XmCLayoutDirection, XmRDirection,

      sizeof(XmDirection), Offset(layout_direction),

      XmRImmediate, (XtPointer) XmLEFT_TO_RIGHT,

    },

    /* add a synonym to ShellUnitType */

    {

	XmNunitType, XmCUnitType, XmRUnitType, 

	sizeof (unsigned char), Offset (unit_type),

	XmRImmediate, (XtPointer) XmPIXELS,

    },	

    {

        XmNverifyPreedit, XmCVerifyPreedit, XmRBoolean,

        sizeof (Boolean), Offset (verify_preedit),

        XmRImmediate, (XtPointer) False,

    },

};

#undef Offset

/*  Definition for resources that need special processing in get values  */

#define ParentOffset(x) 	\

	(XtOffsetOf(VendorShellRec, x) | XmLOGICAL_PARENT_RESOURCE)

#define ExtOffset(x)		XtOffsetOf(XmVendorShellExtRec, x)

static XmSyntheticResource synResources[] =

{

    { 

	XmNx, sizeof (Position),

	ParentOffset (core.x), 

	XmeFromHorizontalPixels,

	XmeToHorizontalPixels,

    },

    {

	XmNy, sizeof (Position),

	ParentOffset (core.y), 

	XmeFromVerticalPixels,

	XmeToVerticalPixels,

    },

    {

	XmNwidth, sizeof (Dimension),

	ParentOffset (core.width), 

	XmeFromHorizontalPixels,

	XmeToHorizontalPixels,

    },

    { 

	XmNheight, sizeof (Dimension),

	ParentOffset (core.height), 

	XmeFromVerticalPixels,

	XmeToVerticalPixels,

    },

    {

	XmNborderWidth, sizeof (Dimension),

	ParentOffset (core.border_width), 

	XmeFromHorizontalPixels,

	XmeToHorizontalPixels,

    },

/* size_hints minus things stored in core */

    { 

	XmNminWidth, sizeof(int),

	ParentOffset(wm.size_hints.min_width), 

	XmeFromHorizontalPixels,

	XmeToHorizontalPixels,

    },	

    { 

	XmNminHeight, sizeof(int),

	ParentOffset(wm.size_hints.min_height), 

	XmeFromVerticalPixels,

	XmeToVerticalPixels,

    },

    { 

	XmNmaxWidth, sizeof(int),

	ParentOffset(wm.size_hints.max_width), 

	XmeFromHorizontalPixels,

	XmeToHorizontalPixels,

    },	

    { 	

	XmNmaxHeight,sizeof(int),

	ParentOffset(wm.size_hints.max_height),

	XmeFromVerticalPixels,

	XmeToVerticalPixels,

    },

/* wm_hints */

    { 

	XmNiconX, sizeof(int),

	ParentOffset(wm.wm_hints.icon_x), 

	XmeFromHorizontalPixels,

	XmeToHorizontalPixels,

    },

    { 

	XmNiconY, sizeof(int),

	ParentOffset(wm.wm_hints.icon_y),  

	XmeFromVerticalPixels,

	XmeToVerticalPixels,

    },

    { 

	XmNmwmFunctions, sizeof(int),

	ExtOffset(vendor.mwm_hints.functions),

	GetMWMFunctionsFromProperty,

	(XmImportProc)NULL,

    },

};

#undef ParentOffset

#undef ExtOffset

static XmBaseClassExtRec myBaseClassExtRec = {

    NULL,                               /* Next extension         */

    NULLQUARK,                          /* record type XmQmotif   */

    XmBaseClassExtVersion,              /* version                */

    sizeof(XmBaseClassExtRec),          /* size                   */

    InitializePrehook,		        /* initialize prehook     */

    XmInheritSetValuesPrehook,	        /* set_values prehook     */

    (XtInitProc)NULL,		        /* initialize posthook    */

    (XtSetValuesFunc)NULL,	        /* set_values posthook    */

    NULL,				/* secondary class        */

    (XtInitProc)NULL,		        /* creation proc          */

    (XmGetSecResDataFunc)NULL,          /* getSecRes data         */

    {0},                                /* fast subclass          */

    XmInheritGetValuesPrehook,	        /* get_values prehook     */

    (XtArgsProc)NULL,		        /* get_values posthook    */

    XmInheritClassPartInitPrehook,	/* class_part_prehook     */

    XmInheritClassPartInitPosthook,     /* class_part_posthook    */

    NULL,	 			/* compiled_ext_resources */   

    NULL,	 			/* ext_resources       	  */   

    0,					/* resource_count     	  */   

    TRUE,				/* use_sub_resources	  */

};

externaldef(xmvendorshellextclassrec)

XmVendorShellExtClassRec xmVendorShellExtClassRec = {

    {	

	(WidgetClass) &xmShellExtClassRec,/* superclass		*/   

	"VendorShell",			/* class_name 		*/   

	sizeof(XmVendorShellExtRec), 	/* size 		*/   

	ClassInitialize, 		/* Class Initializer 	*/   

	ClassPartInitialize,	        /* class_part_init 	*/ 

	FALSE, 				/* Class init'ed ? 	*/   

	(XtInitProc)NULL,		/* initialize         	*/   

	(XtArgsProc)NULL, 		/* initialize_notify    */ 

	NULL,	 			/* realize            	*/   

	NULL,		 		/* actions            	*/   

	0,				/* num_actions        	*/   

	extResources, 			/* resources          	*/   

	XtNumber(extResources),		/* resource_count     	*/   

	NULLQUARK, 			/* xrm_class          	*/   

	FALSE, 				/* compress_motion    	*/   

	FALSE, 				/* compress_exposure  	*/   

	FALSE, 				/* compress_enterleave	*/   

	FALSE, 				/* visible_interest   	*/   

	Destroy,			/* destroy            	*/   

	NULL,	 			/* resize             	*/   

	NULL, 				/* expose             	*/   

	(XtSetValuesFunc)NULL,		/* set_values         	*/   

	(XtArgsFunc)NULL, 		/* set_values_hook      */ 

	NULL,	 			/* set_values_almost    */ 

	(XtArgsProc)NULL,		/* get_values_hook      */ 

	NULL,				/* accept_focus       	*/   

	XtVersion, 			/* intrinsics version 	*/   

	NULL, 				/* callback offsets   	*/   

	NULL,				/* tm_table           	*/   

	NULL, 				/* query_geometry       */ 

	NULL,				/* display_accelerator  */ 

	(XtPointer)&myBaseClassExtRec,	/* extension            */ 

    },	

    {					/* ext			*/

	synResources,			/* synthetic resources	*/

	XtNumber(synResources),		/* num syn resources	*/

	NULL,				/* extension		*/

    },

    {					/* desktop		*/

	NULL,				/* child_class		*/

	XtInheritInsertChild,		/* insert_child		*/

	XtInheritDeleteChild,		/* delete_child		*/

	NULL,				/* extension		*/

    },

    {					/* shell ext		*/

	XmInheritEventHandler,		/* structureNotify	*/

	NULL,				/* extension		*/

    },

    {					/* vendor ext		*/

	DeleteWindowHandler,            /* delete window handler*/

	OffsetHandler,	                /* offset handler	*/

	NULL,				/* extension		*/

    },

};

externaldef(xmVendorShellExtobjectclass) WidgetClass 

       xmVendorShellExtObjectClass = (WidgetClass) (&xmVendorShellExtClassRec);

/* ARGSUSED */

static Boolean 

CvtStringToHorizontalInt(

        Display *display,	

        XrmValue *args,

        Cardinal *num_args,	/* unused */

        XrmValue *from,

        XrmValue *to,

        XtPointer *converter_data)

{

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

    Screen * screen = XtScreen(widget) ;

    unsigned char defaultFromType = _XmGetUnitType(widget) ;

    int tmpPix;

    Boolean parseError;

    tmpPix = (int)

      _XmConvertStringToUnits (screen, from->addr, (int) defaultFromType,

			       XmHORIZONTAL, XmPIXELS, (XtEnum*) &parseError);

    if (parseError)

        {

        XtDisplayStringConversionWarning(display, (char *)from->addr, 

					 XmRHorizontalDimension);

        return False;

        }

    else

        _XM_CONVERTER_DONE( to, int, tmpPix, ; )

}

/* ARGSUSED */

static Boolean 

CvtStringToVerticalInt(

        Display *display,	

        XrmValue *args,

        Cardinal *num_args,	/* unused */

        XrmValue *from,

        XrmValue *to,

        XtPointer *converter_data)

{

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

    Screen * screen = XtScreen(widget) ;

    unsigned char defaultFromType = _XmGetUnitType(widget) ;

    int tmpPix;

    Boolean parseError;

    tmpPix = (int)

	_XmConvertStringToUnits(screen, from->addr, (int) defaultFromType,

				XmVERTICAL, XmPIXELS, (XtEnum*) &parseError);

    if (parseError)

	{

            XtDisplayStringConversionWarning(display, (char *)from->addr, 

					     XmRVerticalPosition);

            return False;

	}

    else

	_XM_CONVERTER_DONE( to, int, tmpPix, ; )

}

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

 *

 *  ClassInitialize

 *    Set up the converters for VendorShell int pixels

 *

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

static void 

ClassInitialize( void )

{

    XtSetTypeConverter(XmRString, 

		       XmRHorizontalInt, 

		       CvtStringToHorizontalInt, 

		       selfConvertArgs, 

		       XtNumber(selfConvertArgs),

		       XtCacheNone, (XtDestructor)NULL);

    XtSetTypeConverter(XmRString, 

		       XmRVerticalInt, 

		       CvtStringToVerticalInt, 

		       selfConvertArgs, 

		       XtNumber(selfConvertArgs),

		       XtCacheNone, (XtDestructor)NULL);

    myBaseClassExtRec.record_type = XmQmotif;

}

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

 *

 *  ClassPartInitialize

 *    Set up the inheritance mechanism for the routines exported by

 *    vendorShells class part.

 *

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

static void 

ClassPartInitialize(

        WidgetClass w )

{

    XmVendorShellExtObjectClass wc = (XmVendorShellExtObjectClass) w;

    XmVendorShellExtObjectClass sc =

      (XmVendorShellExtObjectClass) wc->object_class.superclass;

    if (wc == (XmVendorShellExtObjectClass)xmVendorShellExtObjectClass)

      return;

    if (wc->vendor_class.delete_window_handler == XmInheritProtocolHandler)

      wc->vendor_class.delete_window_handler = 

	sc->vendor_class.delete_window_handler;

    if (wc->vendor_class.offset_handler == XmInheritProtocolHandler)

      wc->vendor_class.offset_handler = 

	sc->vendor_class.offset_handler;

}

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

 *  DeleteWindowHandler

 *

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

/*ARGSUSED*/

static void

DeleteWindowHandler(

        Widget wid,

        XtPointer closure,

        XtPointer call_data )	/* unused */

{

        VendorShellWidget w = (VendorShellWidget) wid ;

    XmVendorShellExtObject ve = (XmVendorShellExtObject) closure;

    switch(ve->vendor.delete_response)

      {

	case XmUNMAP:

	  if (w->shell.popped_up)

	    XtPopdown((Widget) w);

	  else

	    XtUnmapWidget((Widget) w);

	  break;

	case XmDESTROY:

	  if (XtIsApplicationShell((Widget) w))

	    {

		XtDestroyApplicationContext

		  (XtWidgetToApplicationContext((Widget) w));

		exit(0);

	    }

	  else

	    XtDestroyWidget((Widget) w);

	  break;

	case XmDO_NOTHING:

	default:

	  break;

      }

}    

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

 *

 *     OffsetHandler

 *

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

/*ARGSUSED*/

static void

OffsetHandler(

        Widget shell,		/* unused */

        XtPointer clientData,

        XtPointer cd )

{

        XmAnyCallbackStruct *callData = (XmAnyCallbackStruct *) cd ;

    XClientMessageEvent		*offsetEvent;

    XmVendorShellExtObject	ve = (XmVendorShellExtObject)clientData;

    offsetEvent = (XClientMessageEvent *) callData->event;

    ve->vendor.lastOffsetSerial = offsetEvent->serial;

    ve->vendor.xOffset = (Position) offsetEvent->data.l[1];

    ve->vendor.yOffset = (Position) offsetEvent->data.l[2];

}

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

 *

 *     InitializePrehook

 *

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

static void 

InitializePrehook(

        Widget req,

        Widget new_w,

        ArgList args,

        Cardinal *num_args )

{

    XmExtObjectClass		ec = (XmExtObjectClass) XtClass(new_w);

    XmBaseClassExt		*wcePtr;

    XmExtObject			ne = (XmExtObject) new_w;

    Widget			parent = ne->ext.logicalParent;

    XmExtObjectClass		pec = (XmExtObjectClass) XtClass(parent);

    XmBaseClassExt		*pcePtr;

    XmWidgetExtData		extData;

    wcePtr = _XmGetBaseClassExtPtr(ec, XmQmotif);

    pcePtr = _XmGetBaseClassExtPtr(pec, XmQmotif);

    if ((*wcePtr)->use_sub_resources)

      {

          _XmProcessLock();

	  /*

	   * get a uncompiled resource list to use with

	   * XtGetSubresources. We can't do this in

	   * ClassPartInitPosthook because Xt doesn't set class_inited at

	   * the right place and thereby mishandles the

	   * XtGetResourceList call

	   */

	  if ((*wcePtr)->ext_resources == NULL)

	    {

		ec->object_class.resources =

		  (*wcePtr)->compiled_ext_resources;

		ec->object_class.num_resources =		

		  (*wcePtr)->num_ext_resources;

		XtGetResourceList((WidgetClass) ec,

				  &((*wcePtr)->ext_resources),

				  &((*wcePtr)->num_ext_resources));

	    }

	  if ((*pcePtr)->ext_resources == NULL)

	    {

		XtGetResourceList((WidgetClass) pec,

				  &((*pcePtr)->ext_resources),

				  &((*pcePtr)->num_ext_resources));

	    }

	  XtGetSubresources(parent,

			    (XtPointer)new_w,

			    NULL, NULL,

			    (*wcePtr)->ext_resources,

			    (*wcePtr)->num_ext_resources,

			    args, *num_args);

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

	  _XmPushWidgetExtData(parent, extData, ne->ext.extensionType);

	  extData->widget = new_w;

	  extData->reqWidget = (Widget)

	    XtMalloc(XtClass(new_w)->core_class.widget_size);

	  memcpy( extData->reqWidget, req,

		XtClass(new_w)->core_class.widget_size);

	  /*  Convert the fields from unit values to pixel values  */

	  XtGetSubresources(parent,

			    (XtPointer)parent,

			    NULL, NULL,

			    (*pcePtr)->ext_resources,

			    (*pcePtr)->num_ext_resources,

			    args, *num_args);

	  _XmExtImportArgs(new_w, args, num_args);

	  _XmProcessUnlock();

      }

}

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

 *

 *  Destroy

 *

 *    This needs to be in the ext object because the extension gets

 *    blown away before the primary does since it's a child. Otherwise

 *    we'd have it in the primary.

 *

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

static void 

Destroy(

        Widget wid )

{

    XmVendorShellExtObject ve = (XmVendorShellExtObject) wid ;

    if (ve->vendor.mwm_menu)

      XtFree(ve->vendor.mwm_menu);

    if (ve->vendor.input_method_string)

      XtFree(ve->vendor.input_method_string);

    if (ve->vendor.preedit_type_string)

      XtFree(ve->vendor.preedit_type_string);

    if (ve->vendor.label)

	XtDestroyWidget(ve->vendor.label);

    if (ve->vendor.slider)

	XtDestroyWidget(ve->vendor.slider);

    if (ve->vendor.timer)

	XtRemoveTimeOut(ve->vendor.timer);

    if (ve->vendor.duration_timer)

	XtRemoveTimeOut(ve->vendor.duration_timer);

    _XmDestroyFocusData(ve->vendor.focus_data);

}

/*

 * XmRCallProc routine for checking VendorShell render table resources

 * before setting them to NULL if no value is specified

 * for both XmN<foo>renderTable and XmN<foo>fontList.

 * If the appropriate bit in "mapStyle" has been set, then the

 * function has been called twice on same widget and resource offset, thus

 * resource needs to be set NULL, otherwise leave it alone.

 */

/* ARGSUSED */

static void 

CheckSetRenderTables(Widget wid,

		     int offset,

		     XrmValue *value )

{

  XmVendorShellExtObject ve;

  XmWidgetExtData extData;

#define SET_BFL(state) (state |= 0x01)

#define IS_SET_BFL(state) (state & 0x01)

#define SET_LFL(state) (state |= 0x02)

#define IS_SET_LFL(state) (state & 0x02)

#define SET_TFL(state) (state |= 0x04)

#define IS_SET_TFL(state) (state & 0x04)

  extData = _XmGetWidgetExtData(wid, XmSHELL_EXTENSION);

if(extData == NULL)

{

#ifdef DEBUG

        XmeWarning(NULL, "_XmGetWidgetExtData() returned NULL pointer.");

#endif

        return;

}

  ve = (XmVendorShellExtObject)(extData->widget);

  if (((char *)ve + offset) == (char *) &(ve->vendor.button_font_list)) {

	if (IS_SET_BFL(ve->vendor.mapStyle))

		value->addr = NULL;

	else {

		SET_BFL(ve->vendor.mapStyle);

		value->addr = ((char *)ve + offset);

	}

  }

  else if (((char *)ve + offset) == (char *) &(ve->vendor.label_font_list)) {

	if (IS_SET_LFL(ve->vendor.mapStyle))

		value->addr = NULL;

	else {

		SET_LFL(ve->vendor.mapStyle);

		value->addr = ((char *)ve + offset);

	}

  }

  else if (((char *)ve + offset) == (char *) &(ve->vendor.text_font_list)) {

	if (IS_SET_TFL(ve->vendor.mapStyle))

		value->addr = NULL;

	else {

		SET_TFL(ve->vendor.mapStyle);

		value->addr = ((char *)ve + offset);

	}

  }

}

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

 *

 *  _XmGetAudibleWarning

 *       This function is called by a widget to get the audibleWarning

 *   value. This is done by checking to see if any of the widgets, 

 *   in the widget's parent hierarchy is a subclass of VendorShell widget 

 *   class, and if it is, returning the  VendorShell resource value. 

 *   If no VendorShell is found, returns XmBELL, since it is the default

 *   value for this resource.

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

unsigned char

_XmGetAudibleWarning(Widget w)

{

  XmWidgetExtData extData ;

  XmVendorShellExtObject vendorExt;

  while (w) {

    if (XmIsVendorShell (w))

      {

	extData = _XmGetWidgetExtData(w, XmSHELL_EXTENSION); 

        if(extData == NULL)

          {

#ifdef DEBUG

            XmeWarning(NULL, "_XmGetWidgetExtData() returned NULL pointer.");

#endif

            return XmBELL;

        }

	vendorExt = (XmVendorShellExtObject) extData->widget;

	return vendorExt->vendor.audible_warning;

      }

    else

      w = XtParent(w);

  }

  return (XmBELL);

} 

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

/*ARGSUSED*/

static void 

GetMWMFunctionsFromProperty(

        Widget wid,

        int resource_offset,	/* unused */

        XtArgVal *value )

{

  Atom actual_type;

  int actual_format;

  unsigned long num_items, bytes_after;

  PropMwmHints *prop = NULL ;

  XmVendorShellExtObject ve = (XmVendorShellExtObject) wid ;

  Widget shell = ve->ext.logicalParent ;

  Atom mwm_hints_atom ;