/* 

 * 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: SeparatoG.c /main/18 1999/01/26 15:32:56 mgreess $"

#endif

#endif

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

#include <stdio.h>

#include <X11/IntrinsicP.h>

#include <X11/ShellP.h>

#include <Xm/AccColorT.h>

#include <Xm/CareVisualT.h>

#include <Xm/DrawP.h>

#include <Xm/LabelGP.h>

#include <Xm/MenuT.h>

#include <Xm/RowColumnP.h>

#include <Xm/TraitP.h>

#include <Xm/VaSimpleP.h>

#include "BaseClassI.h"

#include "CacheI.h"

#include "ColorI.h"

#include "ExtObjectI.h"

#include "PixConvI.h"

#include "RepTypeI.h"

#include "SeparatoGI.h"

#include "SyntheticI.h"

#include "XmI.h"

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

static void SetTopShadowPixmapDefault(

				      Widget widget,

				      int offset,

				      XrmValue * value);

static void InputDispatch( 

                        Widget sg,

                        XEvent *event,

                        Mask event_mask) ;

static void ClassInitialize( void ) ;

static void ClassPartInitialize( 

                        WidgetClass wc) ;

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 void Initialize( 

                        Widget rw,

                        Widget nw,

                        ArgList args,

                        Cardinal *num_args) ;

static void GetSeparatorGC( 

                        XmSeparatorGadget sg) ;

static void GetBackgroundGC(

                        XmSeparatorGadget sg) ;

static void Redisplay( 

                        Widget wid,

                        XEvent *event,

                        Region region) ;

static void Destroy( 

                        Widget sg) ;

static Boolean SetValues( 

                        Widget cw,

                        Widget rw,

                        Widget nw,

                        ArgList args,

                        Cardinal *num_args) ;

static void Help( 

                        Widget sg,

                        XEvent *event) ;

static Cardinal GetSeparatorGClassSecResData( 

                        WidgetClass w_class,

                        XmSecondaryResourceData **data_rtn) ;

static XtPointer GetSeparatorGClassSecResBase( 

                        Widget widget,

                        XtPointer client_data) ;

static Boolean HandleRedraw (Widget kid, 

		       Widget cur_parent,

		       Widget new_parent,

		       Mask visual_flag);

static void 

InitNewColorBehavior(

		     XmSeparatorGadget sg);

static void DealWithColors(

			   XmSeparatorGadget sg);

static void DealWithPixmaps(

			   XmSeparatorGadget sg);

static void InitNewPixmapBehavior(

			   XmSeparatorGadget sg);

static void GetColors(Widget widget, 

		      XmAccessColorData color_data);

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

/* Menu Savvy trait record */

static XmConst XmMenuSavvyTraitRec MenuSavvySeparatorRecord = {

  0,				/* version */

  NULL,				/* disableCallback */

  NULL,				/* getAccelerator */

  NULL,				/* getMnemonic */

  NULL,				/* getActivateCBName */

};

static XmConst XmCareVisualTraitRec SeparatoGCVT = {

    0,		/* version */

    HandleRedraw,

};

/* Access Colors Trait record for separator */

static XmConst XmAccessColorsTraitRec sepACT = {

  0,			/* version */

  GetColors

};

/*  Resource list for Separator  */

static XtResource resources[] =

{

   {

     XmNtraversalOn, XmCTraversalOn, XmRBoolean, sizeof (Boolean),

     XtOffsetOf( struct _XmGadgetRec, gadget.traversal_on),

     XmRImmediate, (XtPointer) False

   },

   {

     XmNhighlightThickness, XmCHighlightThickness, XmRHorizontalDimension,

     sizeof (Dimension),

     XtOffsetOf( struct _XmGadgetRec, gadget.highlight_thickness),

     XmRImmediate, (XtPointer) 0

   },

   {

     XmNshadowThickness, XmCShadowThickness, XmRHorizontalDimension,

     sizeof (Dimension),

     XtOffsetOf( struct _XmGadgetRec, gadget.shadow_thickness),

     XmRImmediate, (XtPointer) 2

   },

};

static XtResource cache_resources[] = 

{

   {

      XmNseparatorType,

      XmCSeparatorType,

      XmRSeparatorType,

      sizeof (unsigned char),

      XtOffsetOf( struct _XmSeparatorGCacheObjRec,

		 separator_cache.separator_type),

      XmRImmediate, (XtPointer) XmSHADOW_ETCHED_IN

   },

   {

      XmNmargin, 

      XmCMargin, 

      XmRHorizontalDimension, 

      sizeof (Dimension),

      XtOffsetOf( struct _XmSeparatorGCacheObjRec, separator_cache.margin),

      XmRImmediate, (XtPointer)  0

   },

   {

      XmNorientation,

      XmCOrientation,

      XmROrientation,

      sizeof (unsigned char),

      XtOffsetOf( struct _XmSeparatorGCacheObjRec,

		 separator_cache.orientation),

      XmRImmediate, (XtPointer) XmHORIZONTAL

   },

   {

     XmNbackground, XmCBackground, XmRPixel, 

     sizeof (Pixel), XtOffsetOf(struct _XmSeparatorGCacheObjRec,

				separator_cache.background),

     XmRImmediate, (XtPointer) INVALID_PIXEL

   },

   {

     XmNforeground, XmCForeground, XmRPixel, 

     sizeof (Pixel),

     XtOffsetOf(struct _XmSeparatorGCacheObjRec, separator_cache.foreground),

     XmRImmediate, (XtPointer) INVALID_PIXEL

   },

   {

     XmNtopShadowColor, XmCTopShadowColor, XmRPixel, 

     sizeof (Pixel),

     XtOffsetOf(struct _XmSeparatorGCacheObjRec,

		separator_cache.top_shadow_color),

     XmRImmediate, (XtPointer) INVALID_PIXEL

   },

   {

     XmNtopShadowPixmap, XmCTopShadowPixmap, XmRNoScalingDynamicPixmap,

     sizeof (Pixmap),

     XtOffsetOf(struct _XmSeparatorGCacheObjRec,

		separator_cache.top_shadow_pixmap),

     XmRImmediate, (XtPointer) INVALID_PIXEL

   },

   {

     XmNbottomShadowColor, XmCBottomShadowColor, XmRPixel, 

     sizeof (Pixel),

     XtOffsetOf(struct _XmSeparatorGCacheObjRec,

		separator_cache.bottom_shadow_color),

     XmRImmediate, (XtPointer) INVALID_PIXEL

   },

   {

     XmNbottomShadowPixmap, XmCBottomShadowPixmap, XmRNoScalingDynamicPixmap,

     sizeof (Pixmap),

     XtOffsetOf(struct _XmSeparatorGCacheObjRec,

		separator_cache.bottom_shadow_pixmap),

     XmRImmediate, (XtPointer) XmUNSPECIFIED_PIXMAP

   },

};

static XmSyntheticResource cache_syn_resources[] = 

{

   {

      XmNmargin, 

      sizeof (Dimension),

      XtOffsetOf( struct _XmSeparatorGCacheObjRec, separator_cache.margin),

      XmeFromHorizontalPixels,

      XmeToHorizontalPixels,

   },

};

/* ext rec static initialization */

externaldef(xmseparatorgcacheobjclassrec)

XmSeparatorGCacheObjClassRec xmSeparatorGCacheObjClassRec =

{

  {

    /* superclass         */    (WidgetClass) &xmExtClassRec,

    /* class_name         */    "XmSeparatorGadget",

    /* widget_size        */    sizeof(XmSeparatorGCacheObjRec),

    /* 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   separatorBaseClassExtRec = {

    NULL,    					/* next_extension        */

    NULLQUARK,					/* record_typ            */

    XmBaseClassExtVersion,			/* version               */

    sizeof(XmBaseClassExtRec),			/* record_size           */

    XmInheritInitializePrehook,			/* initializePrehook     */

    SetValuesPrehook,				/* setValuesPrehook      */

    InitializePosthook,				/* initializePosthook    */

    SetValuesPosthook,				/* setValuesPosthook     */

    (WidgetClass)&xmSeparatorGCacheObjClassRec,	/* secondaryObjectClass  */

    SecondaryObjectCreate,		        /* secondaryObjectCreate */

    GetSeparatorGClassSecResData,	        /* getSecResData */

    {0},			                /* Other Flags           */

    GetValuesPrehook,				/* getValuesPrehook      */

    GetValuesPosthook,				/* getValuesPosthook     */

};

static XmCacheClassPart SeparatorClassCachePart = {

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

    _XmCacheCopy,       /* Copy routine     */

    _XmCacheDelete,     /* Delete routine   */

    _XmSeparatorCacheCompare,    /* Comparison routine   */

};

/*  The Separator class record definition  */

externaldef(xmseparatorgadgetclassrec) XmSeparatorGadgetClassRec xmSeparatorGadgetClassRec =

{

   {

      (WidgetClass) &xmGadgetClassRec,  /* superclass            */

      "XmSeparatorGadget",              /* class_name	         */

      sizeof(XmSeparatorGadgetRec),     /* 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              */

      NULL,                             /* query_geometry        */

      NULL,				/* display_accelerator   */

      (XtPointer)&separatorBaseClassExtRec, /* extension         */

   },

   {

      NULL, 			/* border highlight   */

      NULL,      		/* border_unhighlight */

      NULL,			/* arm_and_activate   */

      InputDispatch,		/* input dispatch     */

      XmInheritVisualChange,	/* visual_change      */

      NULL,			/* syn_resources      */

      0,  			/* num_syn_resources  */

      &SeparatorClassCachePart, /* class cache part   */

      NULL,         		/* extension          */

   },

   {

      NULL,         		/* extension */

   }

};

externaldef(xmseparatorgadgetclass) WidgetClass xmSeparatorGadgetClass = 

   (WidgetClass) &xmSeparatorGadgetClassRec;

/*ARGSUSED*/

static void 

SetTopShadowPixmapDefault(

        Widget widget,

        int offset,		/* unused */

        XrmValue *value )

{

   XmSeparatorGadget sg = (XmSeparatorGadget) widget;

   XmManagerWidget mw = (XmManagerWidget)XtParent(sg);

   static Pixmap pixmap;

   pixmap = XmUNSPECIFIED_PIXMAP;

   value->addr = (char *) &pixmap;

   value->size = sizeof (Pixmap);

   if (SEPG_TopShadowColor(sg) == SEPG_Background(sg))

      pixmap = XmGetPixmapByDepth (XtScreen (sg), XmS50_foreground,

                            SEPG_TopShadowColor(sg),

                            SEPG_Foreground(sg),

                            mw->core.depth);

   else if (DefaultDepthOfScreen (XtScreen (widget)) == 1)

      pixmap = XmGetPixmapByDepth (XtScreen (sg), XmS50_foreground,

                            SEPG_TopShadowColor(sg),

                            SEPG_Background(sg),

                            mw->core.depth);

}

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

 *

 *  InputDispatch

 *     This function catches input sent by a manager and dispatches it

 *     to the individual routines.

 *

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

static void 

InputDispatch(

        Widget sg,

        XEvent *event,

        Mask event_mask )

{

   if (event_mask & XmHELP_EVENT) Help (sg, event);

}

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

 *

 *  _XmSeparatorCacheCompare

 *

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

int 

_XmSeparatorCacheCompare(

        XtPointer A,

        XtPointer B )

{

        XmSeparatorGCacheObjPart *separator_inst =

                                               (XmSeparatorGCacheObjPart *) A ;

        XmSeparatorGCacheObjPart *separator_cache_inst =

                                               (XmSeparatorGCacheObjPart *) B ;

    if((separator_inst->margin == separator_cache_inst->margin) &&

       (separator_inst->orientation == separator_cache_inst->orientation) &&

       (separator_inst->separator_type == separator_cache_inst->separator_type) &&

       (separator_inst-> separator_GC == separator_cache_inst->separator_GC) &&

       (separator_inst-> background_GC == separator_cache_inst->background_GC) &&

       (separator_inst-> top_shadow_GC == separator_cache_inst->top_shadow_GC) &&

       (separator_inst-> bottom_shadow_GC == separator_cache_inst->bottom_shadow_GC) &&

       (separator_inst-> background == separator_cache_inst->background) &&

       (separator_inst-> top_shadow_color == separator_cache_inst->top_shadow_color) &&

       (separator_inst-> top_shadow_pixmap == separator_cache_inst->top_shadow_pixmap) &&

       (separator_inst-> bottom_shadow_color ==

	separator_cache_inst->bottom_shadow_color) &&

       (separator_inst-> bottom_shadow_pixmap ==

	                 separator_cache_inst->bottom_shadow_pixmap))

       return 1;

    else

       return 0;

 }

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

*

*  ClassInitialize

*

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

static void 

ClassInitialize( void )

{

    separatorBaseClassExtRec.record_type = XmQmotif;

    /* Install the menu savvy trait. */

    XmeTraitSet((XtPointer) xmSeparatorGadgetClass, XmQTmenuSavvy,

		(XtPointer) &MenuSavvySeparatorRecord);

}

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

 *

 *  ClassPartInitialize

 *     Set up the fast subclassing for the widget

 *

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

static void 

ClassPartInitialize(

        WidgetClass wc )

{

   _XmFastSubclassInit (wc, XmSEPARATOR_GADGET_BIT);

   /* Install the careParentVisual trait for all subclasses as well. */

   XmeTraitSet((XtPointer)wc, XmQTcareParentVisual, (XtPointer)&SeparatoGCVT);

   /* Install the accessColors trait for all subclasses as well. */

   XmeTraitSet((XtPointer)wc, XmQTaccessColors, (XtPointer)&sepACT);

}

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

*

*  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();

/*

 *  Update pointers in instance records now so references to resources

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

 */

  SEPG_Cache(new_w) = &(((XmSeparatorGCacheObject)newSec)->separator_cache);

  SEPG_Cache(req) = &(((XmSeparatorGCacheObject)reqSec)->separator_cache);

    /*

     * fetch the resources in superclass to subclass order

     */

  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;

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

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

  _XmPushWidgetExtData(new_w, extData,

                      ((XmSeparatorGCacheObject)newSec)->ext.extensionType);

   memcpy(reqSec, newSec, size);

}

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

 *

 *  InitializePosthook

 *

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

/* ARGSUSED */

static void 

InitializePosthook(

        Widget req,

        Widget new_w,

        ArgList args,

        Cardinal *num_args )

{

    XmWidgetExtData     ext;

    XmSeparatorGadget sw = (XmSeparatorGadget)new_w;

    /*

     * - register parts in cache.

     * - update cache pointers

     * - and free req

     */

    _XmProcessLock();

    SEPG_Cache(sw) = (XmSeparatorGCacheObjPart *)

      _XmCachePart( SEPG_ClassCachePart(sw),

                    (XtPointer) SEPG_Cache(sw),

                    sizeof(XmSeparatorGCacheObjPart));

    /*

     * 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) sw, &ext, XmCACHE_EXTENSION);

    _XmExtObjFree((XtPointer) ext->widget);

    _XmExtObjFree((XtPointer) ext->reqWidget);

    _XmProcessUnlock();

    XtFree( (char *) ext);

}

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

 *

 *  SetValuesPrehook

 *

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

/* ARGSUSED */

static Boolean 

SetValuesPrehook(

        Widget oldParent,

        Widget refParent,

        Widget newParent,

        ArgList args,

        Cardinal *num_args )

{

    XmWidgetExtData             extData;

    XmBaseClassExt              *cePtr;

    WidgetClass                 ec;

    XmSeparatorGCacheObject     newSec, reqSec;

    Cardinal                    size;

    _XmProcessLock();

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

    ec = (*cePtr)->secondaryObjectClass;

    size = ec->core_class.widget_size;

    newSec = (XmSeparatorGCacheObject)_XmExtObjAlloc(size);

    reqSec = (XmSeparatorGCacheObject)_XmExtObjAlloc(size);

    _XmProcessUnlock();

    newSec->object.self = (Widget)newSec;

    newSec->object.widget_class = ec;

    newSec->object.parent = XtParent(newParent);

    newSec->object.xrm_name = newParent->core.xrm_name;

    newSec->object.being_destroyed = False;

    newSec->object.destroy_callbacks = NULL;

    newSec->object.constraints = NULL;

    newSec->ext.logicalParent = newParent;

    newSec->ext.extensionType = XmCACHE_EXTENSION;

    memcpy( &(newSec->separator_cache),

            SEPG_Cache(newParent),

            sizeof(XmSeparatorGCacheObjPart));

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

    extData->widget = (Widget)newSec;

    extData->reqWidget = (Widget)reqSec;

    _XmPushWidgetExtData(newParent, extData, XmCACHE_EXTENSION);

    XtSetSubvalues((XtPointer)newSec,

                   ec->core_class.resources,

                   ec->core_class.num_resources,

                   args, *num_args);

    memcpy((XtPointer)reqSec, (XtPointer)newSec, size);

    SEPG_Cache(newParent) = &(((XmSeparatorGCacheObject)newSec)->separator_cache);

    SEPG_Cache(refParent) =

	      &(((XmSeparatorGCacheObject)extData->reqWidget)->separator_cache);

    _XmExtImportArgs((Widget)newSec, args, num_args);

    return FALSE;

}

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

 *

 *  GetValuesPrehook

 *

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

/* ARGSUSED */

static void 

GetValuesPrehook(

        Widget newParent,

        ArgList args,

        Cardinal *num_args )

{

    XmWidgetExtData             extData;

    XmBaseClassExt              *cePtr;

    WidgetClass                 ec;

    XmSeparatorGCacheObject     newSec;

    Cardinal                    size;

    _XmProcessLock();

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

    ec = (*cePtr)->secondaryObjectClass;

    size = ec->core_class.widget_size;

    newSec = (XmSeparatorGCacheObject)_XmExtObjAlloc(size);

    _XmProcessUnlock();

    newSec->object.self = (Widget)newSec;

    newSec->object.widget_class = ec;

    newSec->object.parent = XtParent(newParent);

    newSec->object.xrm_name = newParent->core.xrm_name;

    newSec->object.being_destroyed = False;

    newSec->object.destroy_callbacks = NULL;

    newSec->object.constraints = NULL;

    newSec->ext.logicalParent = newParent;

    newSec->ext.extensionType = XmCACHE_EXTENSION;

    memcpy( &(newSec->separator_cache), 

            SEPG_Cache(newParent),

            sizeof(XmSeparatorGCacheObjPart));

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

    extData->widget = (Widget)newSec;

    _XmPushWidgetExtData(newParent, extData, XmCACHE_EXTENSION);

    XtGetSubvalues((XtPointer)newSec,

                   ec->core_class.resources,

                   ec->core_class.num_resources,

                   args, *num_args);

    _XmExtGetValuesHook((Widget)newSec, args, num_args);

}

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

 *

 *  GetValuesPosthook

 *

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

/* ARGSUSED */

static void 

GetValuesPosthook(

        Widget new_w,

        ArgList args,

        Cardinal *num_args )

{

    XmWidgetExtData ext;

    _XmPopWidgetExtData(new_w, &ext, XmCACHE_EXTENSION);

    _XmProcessLock();

    _XmExtObjFree((XtPointer) ext->widget);

    _XmProcessUnlock();

    XtFree( (char *) ext);

}

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

 *

 *  SetValuesPosthook

 *

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

/*ARGSUSED*/

static Boolean 

SetValuesPosthook(

        Widget current,

        Widget req,

        Widget new_w,

        ArgList args,

        Cardinal *num_args )

{

    XmWidgetExtData             ext;

    /*

     * - register parts in cache.

     * - update cache pointers

     * - and free req

     */

    /* assign if changed! */

    _XmProcessLock();

    if (!_XmSeparatorCacheCompare((XtPointer) SEPG_Cache(new_w),

				  (XtPointer) SEPG_Cache(current)))

    {

          _XmCacheDelete( (XtPointer) SEPG_Cache(current));  /* delete the old one */

          SEPG_Cache(new_w) = (XmSeparatorGCacheObjPart *)

            _XmCachePart(SEPG_ClassCachePart(new_w),

                         (XtPointer) SEPG_Cache(new_w),

                         sizeof(XmSeparatorGCacheObjPart));

     } else

           SEPG_Cache(new_w) = SEPG_Cache(current);

    _XmPopWidgetExtData(new_w, &ext, XmCACHE_EXTENSION);

    _XmExtObjFree((XtPointer) ext->widget);

    _XmExtObjFree((XtPointer) ext->reqWidget);

    _XmProcessUnlock();

    XtFree( (char *) ext);

    return FALSE;

}

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

 *

 *  Initialize

 *     The main widget instance initialization routine.

 *

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

/*ARGSUSED*/

static void 

Initialize(

        Widget rw,

        Widget nw,

        ArgList args,

        Cardinal *num_args )

{

    XmSeparatorGadget request = (XmSeparatorGadget) rw ;

    XmSeparatorGadget new_w = (XmSeparatorGadget) nw ;

   new_w -> gadget.traversal_on = FALSE;

   /* Force highlightThickness to zero if in a menu. */

   if (XmIsRowColumn(XtParent(new_w)) &&

       ((RC_Type(XtParent(new_w)) == XmMENU_PULLDOWN) ||

        (RC_Type(XtParent(new_w)) == XmMENU_POPUP)))

     new_w->gadget.highlight_thickness = 0;

    if(    !XmRepTypeValidValue( XmRID_SEPARATOR_TYPE,

                                   SEPG_SeparatorType( new_w), (Widget) new_w)    )

   {

      SEPG_SeparatorType(new_w) = XmSHADOW_ETCHED_IN;

   }

   if(    !XmRepTypeValidValue( XmRID_ORIENTATION,

                                     SEPG_Orientation( new_w), (Widget) new_w)    )

   {

      SEPG_Orientation(new_w) = XmHORIZONTAL;

   }

   if (SEPG_Orientation(new_w) == XmHORIZONTAL)

   {

      if (request -> rectangle.width == 0)

	 new_w -> rectangle.width = 2 * new_w -> gadget.highlight_thickness +2;

      if (request -> rectangle.height == 0)

      {

	 new_w -> rectangle.height = 2 * new_w -> gadget.highlight_thickness;

	 if (SEPG_SeparatorType(new_w) == XmSINGLE_LINE ||

	     SEPG_SeparatorType(new_w) == XmSINGLE_DASHED_LINE)

	    new_w -> rectangle.height += 3;

	 else if (SEPG_SeparatorType(new_w) == XmSHADOW_ETCHED_IN ||

		  SEPG_SeparatorType(new_w) == XmSHADOW_ETCHED_OUT ||