/*

 * (c) Copyright 1993, Silicon Graphics, Inc.

 * ALL RIGHTS RESERVED 

 * Permission to use, copy, modify, and distribute this software for 

 * any purpose and without fee is hereby granted, provided that the above

 * copyright notice appear in all copies and that both the copyright notice

 * and this permission notice appear in supporting documentation, and that 

 * the name of Silicon Graphics, Inc. not be used in advertising

 * or publicity pertaining to distribution of the software without specific,

 * written prior permission. 

 *

 * THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU "AS-IS"

 * AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR OTHERWISE,

 * INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF MERCHANTABILITY OR

 * FITNESS FOR A PARTICULAR PURPOSE.  IN NO EVENT SHALL SILICON

 * GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE ELSE FOR ANY DIRECT,

 * SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY

 * KIND, OR ANY DAMAGES WHATSOEVER, INCLUDING WITHOUT LIMITATION,

 * LOSS OF PROFIT, LOSS OF USE, SAVINGS OR REVENUE, OR THE CLAIMS OF

 * THIRD PARTIES, WHETHER OR NOT SILICON GRAPHICS, INC.  HAS BEEN

 * ADVISED OF THE POSSIBILITY OF SUCH LOSS, HOWEVER CAUSED AND ON

 * ANY THEORY OF LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE

 * POSSESSION, USE OR PERFORMANCE OF THIS SOFTWARE.

 * 

 * 

 * US Government Users Restricted Rights 

 * Use, duplication, or disclosure by the Government is subject to

 * restrictions set forth in FAR 52.227.19(c)(2) or subparagraph

 * (c)(1)(ii) of the Rights in Technical Data and Computer Software

 * clause at DFARS 252.227-7013 and/or in similar or successor

 * clauses in the FAR or the DOD or NASA FAR Supplement.

 * Unpublished-- rights reserved under the copyright laws of the

 * United States.  Contractor/manufacturer is Silicon Graphics,

 * Inc., 2011 N.  Shoreline Blvd., Mountain View, CA 94039-7311.

 *

 * OpenGL(TM) is a trademark of Silicon Graphics, Inc.

 */

/*

 *

 * This file has been slightly modified from the original for use with Mesa

 *

 *     Jeroen van der Zijp

 *

 *     jvz@cyberia.cfdrc.com

 *

 */

#include <X11/IntrinsicP.h>

#include <X11/StringDefs.h>

#include <GL/glx.h>

#include <GL/gl.h>

#ifdef __GLX_MOTIF

#include <Xm/PrimitiveP.h>

#include "GLwMDrawAP.h"

#else 

#include "GLwDrawAP.h"

#endif 

#include <assert.h>

#include <stdio.h>

#ifdef __GLX_MOTIF

#define GLwDrawingAreaWidget             GLwMDrawingAreaWidget

#define GLwDrawingAreaClassRec           GLwMDrawingAreaClassRec

#define glwDrawingAreaClassRec           glwMDrawingAreaClassRec

#define glwDrawingAreaWidgetClass        glwMDrawingAreaWidgetClass

#define GLwDrawingAreaRec                GLwMDrawingAreaRec

#endif 

#define ATTRIBLIST_SIZE 32

#define offset(field) XtOffset(GLwDrawingAreaWidget,glwDrawingArea.field)

/* forward definitions */

static void createColormap(GLwDrawingAreaWidget w,int offset,XrmValue *value);

static void Initialize(GLwDrawingAreaWidget req,GLwDrawingAreaWidget neww,ArgList args,Cardinal *num_args);

static void Realize(Widget w,Mask *valueMask,XSetWindowAttributes *attributes);

static void Redraw(GLwDrawingAreaWidget w,XEvent *event,Region region);

static void Resize(GLwDrawingAreaWidget glw);

static void Destroy(GLwDrawingAreaWidget glw);

static void glwInput(GLwDrawingAreaWidget glw,XEvent *event,String *params,Cardinal *numParams);

static char defaultTranslations[] =

#ifdef __GLX_MOTIF

     "<Key>osfHelp:PrimitiveHelp() \n"

#endif

    "<KeyDown>:   glwInput() \n\

     <KeyUp>:     glwInput() \n\

     <BtnDown>:   glwInput() \n\

     <BtnUp>:     glwInput() \n\

     <BtnMotion>: glwInput() ";

static XtActionsRec actions[] = {

  {"glwInput",(XtActionProc)glwInput},                /* key or mouse input */

  };

/*

 * There is a bit of unusual handling of the resources here.

 * Because Xt insists on allocating the colormap resource when it is

 * processing the core resources (even if we redeclare the colormap

 * resource here, we need to do a little trick.  When Xt first allocates

 * the colormap, we allow it to allocate the default one, since we have

 * not yet determined the appropriate visual (which is determined from

 * resources parsed after the colormap).  We also let it allocate colors

 * in that default colormap.

 *

 * In the initialize proc we calculate the actual visual.  Then, we

 * reobtain the colormap resource using XtGetApplicationResources in

 * the initialize proc.  If requested, we also reallocate colors in

 * that colormap using the same method.

 */

static XtResource resources[] = {

  /* The GLX attributes.  Add any new attributes here */

  {GLwNbufferSize, GLwCBufferSize, XtRInt, sizeof (int),

       offset(bufferSize), XtRImmediate, (XtPointer) 0},

  {GLwNlevel, GLwCLevel, XtRInt, sizeof (int),

       offset(level), XtRImmediate, (XtPointer) 0},

  {GLwNrgba, GLwCRgba, XtRBoolean, sizeof (Boolean),

       offset(rgba), XtRImmediate, (XtPointer) FALSE},

  {GLwNdoublebuffer, GLwCDoublebuffer, XtRBoolean, sizeof (Boolean),

       offset(doublebuffer), XtRImmediate, (XtPointer) FALSE},

  {GLwNstereo, GLwCStereo, XtRBoolean, sizeof (Boolean),

       offset(stereo), XtRImmediate, (XtPointer) FALSE},

  {GLwNauxBuffers, GLwCAuxBuffers, XtRInt, sizeof (int),

       offset(auxBuffers), XtRImmediate, (XtPointer) 0},

  {GLwNredSize, GLwCColorSize, XtRInt, sizeof (int),

       offset(redSize), XtRImmediate, (XtPointer) 1},

  {GLwNgreenSize, GLwCColorSize, XtRInt, sizeof (int),

       offset(greenSize), XtRImmediate, (XtPointer) 1},

  {GLwNblueSize, GLwCColorSize, XtRInt, sizeof (int),

       offset(blueSize), XtRImmediate, (XtPointer) 1},

  {GLwNalphaSize, GLwCAlphaSize, XtRInt, sizeof (int),

       offset(alphaSize), XtRImmediate, (XtPointer) 0},

  {GLwNdepthSize, GLwCDepthSize, XtRInt, sizeof (int),

       offset(depthSize), XtRImmediate, (XtPointer) 0},

  {GLwNstencilSize, GLwCStencilSize, XtRInt, sizeof (int),

       offset(stencilSize), XtRImmediate, (XtPointer) 0},

  {GLwNaccumRedSize, GLwCAccumColorSize, XtRInt, sizeof (int),

       offset(accumRedSize), XtRImmediate, (XtPointer) 0},

  {GLwNaccumGreenSize, GLwCAccumColorSize, XtRInt, sizeof (int),

       offset(accumGreenSize), XtRImmediate, (XtPointer) 0},

  {GLwNaccumBlueSize, GLwCAccumColorSize, XtRInt, sizeof (int),

       offset(accumBlueSize), XtRImmediate, (XtPointer) 0},

  {GLwNaccumAlphaSize, GLwCAccumAlphaSize, XtRInt, sizeof (int),

       offset(accumAlphaSize), XtRImmediate, (XtPointer) 0},

  /* the attribute list */

  {GLwNattribList, GLwCAttribList, XtRPointer, sizeof(int *),

       offset(attribList), XtRImmediate, (XtPointer) NULL},

  /* the visual info */

  {GLwNvisualInfo, GLwCVisualInfo, GLwRVisualInfo, sizeof (XVisualInfo *),

       offset(visualInfo), XtRImmediate, (XtPointer) NULL},

  /* miscellaneous resources */

  {GLwNinstallColormap, GLwCInstallColormap, XtRBoolean, sizeof (Boolean),

       offset(installColormap), XtRImmediate, (XtPointer) TRUE},

  {GLwNallocateBackground, GLwCAllocateColors, XtRBoolean, sizeof (Boolean),

       offset(allocateBackground), XtRImmediate, (XtPointer) FALSE},

  {GLwNallocateOtherColors, GLwCAllocateColors, XtRBoolean, sizeof (Boolean),

       offset(allocateOtherColors), XtRImmediate, (XtPointer) FALSE},

  {GLwNinstallBackground, GLwCInstallBackground, XtRBoolean, sizeof (Boolean),

       offset(installBackground), XtRImmediate, (XtPointer) TRUE},

  {GLwNginitCallback, GLwCCallback, XtRCallback, sizeof (XtCallbackList),

       offset(ginitCallback), XtRImmediate, (XtPointer) NULL},

  {GLwNinputCallback, GLwCCallback, XtRCallback, sizeof (XtCallbackList),

       offset(inputCallback), XtRImmediate, (XtPointer) NULL},

  {GLwNresizeCallback, GLwCCallback, XtRCallback, sizeof (XtCallbackList),

       offset(resizeCallback), XtRImmediate, (XtPointer) NULL},

  {GLwNexposeCallback, GLwCCallback, XtRCallback, sizeof (XtCallbackList),

       offset(exposeCallback), XtRImmediate, (XtPointer) NULL},

  /* Changes to Motif primitive resources */

#ifdef __GLX_MOTIF

  {XmNtraversalOn, XmCTraversalOn, XmRBoolean, sizeof (Boolean),

   XtOffset (GLwDrawingAreaWidget, primitive.traversal_on), XmRImmediate,

   (XtPointer)FALSE},

  /* highlighting is normally disabled, as when Motif tries to disable

   * highlighting, it tries to reset the color back to the parent's

   * background (usually Motif blue).  Unfortunately, that is in a

   * different colormap, and doesn't work too well.

   */

  {XmNhighlightOnEnter, XmCHighlightOnEnter, XmRBoolean, sizeof (Boolean),

   XtOffset (GLwDrawingAreaWidget, primitive.highlight_on_enter),

   XmRImmediate, (XtPointer) FALSE},

  {XmNhighlightThickness, XmCHighlightThickness, XmRHorizontalDimension,

   sizeof (Dimension),

   XtOffset (GLwDrawingAreaWidget, primitive.highlight_thickness),

   XmRImmediate, (XtPointer) 0},

#endif 

  };

/*

** The following resources are reobtained using XtGetApplicationResources

** in the initialize proc.

*/

/* The colormap */

static XtResource initializeResources[] = {

  /* reobtain the colormap with the new visual */

  {XtNcolormap, XtCColormap, XtRColormap, sizeof(Colormap),

   XtOffset(GLwDrawingAreaWidget, core.colormap),

   XtRCallProc,(XtPointer) createColormap},

  };

/* reallocate any colors we need in the new colormap */

/* The background is obtained only if the allocateBackground resource is TRUE*/

static XtResource backgroundResources[] = {

#ifdef __GLX_MOTIF

  {XmNbackground, XmCBackground,XmRPixel, 

   sizeof(Pixel),XtOffset(GLwDrawingAreaWidget,core.background_pixel),

   XmRString,(XtPointer)"lightgrey"},

   /*XmRCallProc,(XtPointer)_XmBackgroundColorDefault},*/

  {XmNbackgroundPixmap,XmCPixmap,XmRXmBackgroundPixmap, 

   sizeof(Pixmap),XtOffset(GLwDrawingAreaWidget,core.background_pixmap),

   XmRImmediate,(XtPointer)XmUNSPECIFIED_PIXMAP},

#else

  {XtNbackground,XtCBackground,XtRPixel,sizeof(Pixel),

   XtOffset(GLwDrawingAreaWidget,core.background_pixel),

   XtRString,(XtPointer)"lightgrey"},

   /*XtRString,(XtPointer)"XtDefaultBackground"},*/

  {XtNbackgroundPixmap, XtCPixmap, XtRPixmap, sizeof(Pixmap),

   XtOffset(GLwDrawingAreaWidget,core.background_pixmap),

   XtRImmediate,(XtPointer)XtUnspecifiedPixmap},

#endif  

  };

/* The other colors such as the foreground are allocated only if

 * allocateOtherColors are set.  These resources only exist in Motif.

 */

#ifdef __GLX_MOTIF

static XtResource otherColorResources[] = {

  {XmNforeground,XmCForeground,XmRPixel, 

   sizeof(Pixel),XtOffset(GLwDrawingAreaWidget,primitive.foreground),

   XmRString,(XtPointer)"lightgrey"},

   /*XmRCallProc, (XtPointer) _XmForegroundColorDefault},*/

  {XmNhighlightColor,XmCHighlightColor,XmRPixel,sizeof(Pixel),

   XtOffset(GLwDrawingAreaWidget,primitive.highlight_color),

   XmRString,(XtPointer)"lightgrey"},

   /*XmRCallProc,(XtPointer)_XmHighlightColorDefault},*/

  {XmNhighlightPixmap,XmCHighlightPixmap,XmRPrimHighlightPixmap,

   sizeof(Pixmap),

   XtOffset(GLwDrawingAreaWidget,primitive.highlight_pixmap),

   XmRImmediate,(XtPointer)XmUNSPECIFIED_PIXMAP},

   /*XmRCallProc,(XtPointer)_XmPrimitiveHighlightPixmapDefault},*/

  };

#endif

#undef offset

GLwDrawingAreaClassRec glwDrawingAreaClassRec = {

  { /* core fields */

#ifdef __GLX_MOTIF

    /* superclass                */        (WidgetClass) &xmPrimitiveClassRec,

    /* class_name                */        "GLwMDrawingArea",

#else /* not __GLX_MOTIF */

    /* superclass                */        (WidgetClass) &widgetClassRec,

    /* class_name                */        "GLwDrawingArea",

#endif /* __GLX_MOTIF */

    /* widget_size               */        sizeof(GLwDrawingAreaRec),

    /* class_initialize          */        NULL,

    /* class_part_initialize     */        NULL,

    /* class_inited              */        FALSE,

    /* initialize                */        (XtInitProc) Initialize,

    /* initialize_hook           */        NULL,

    /* realize                   */        Realize,

    /* actions                   */        actions,

    /* num_actions               */        XtNumber(actions),

    /* resources                 */        resources,

    /* num_resources             */        XtNumber(resources),

    /* xrm_class                 */        NULLQUARK,

    /* compress_motion           */        TRUE,

    /* compress_exposure         */        TRUE,

    /* compress_enterleave       */        TRUE,

    /* visible_interest          */        TRUE,

    /* destroy                   */        (XtWidgetProc) Destroy,

    /* resize                    */        (XtWidgetProc) Resize,

    /* expose                    */        (XtExposeProc) Redraw,

    /* set_values                */        NULL,

    /* set_values_hook           */        NULL,

    /* set_values_almost         */        XtInheritSetValuesAlmost,

    /* get_values_hook           */        NULL,

    /* accept_focus              */        NULL,

    /* version                   */        XtVersion,

    /* callback_private          */        NULL,

    /* tm_table                  */        defaultTranslations,

    /* query_geometry            */        XtInheritQueryGeometry,

    /* display_accelerator       */        XtInheritDisplayAccelerator,

    /* extension                 */        NULL

  },

#ifdef __GLX_MOTIF /* primitive resources */

  {

    /* border_highlight          */        XmInheritBorderHighlight,

    /* border_unhighlight        */        XmInheritBorderUnhighlight,

    /* translations              */        XtInheritTranslations,

    /* arm_and_activate          */        NULL,

    /* get_resources             */        NULL,

    /* num get_resources         */        0,

    /* extension                 */        NULL,                                

  }

#endif 

  };

WidgetClass glwDrawingAreaWidgetClass=(WidgetClass)&glwDrawingAreaClassRec;

static void error(Widget w,char* string){

  char buf[100];

#ifdef __GLX_MOTIF

  sprintf(buf,"GLwMDrawingArea: %s\n",string);

#else

  sprintf(buf,"GLwDrawingArea: %s\n",string);

#endif

  XtAppError(XtWidgetToApplicationContext(w),buf);

  }

static void warning(Widget w,char* string){

  char buf[100];

#ifdef __GLX_MOTIF

  sprintf (buf, "GLwMDraw: %s\n", string);

#else

  sprintf (buf, "GLwDraw: %s\n", string);

#endif

  XtAppWarning(XtWidgetToApplicationContext(w), buf);

  }

/* Initialize the attribList based on the attributes */

static void createAttribList(GLwDrawingAreaWidget w){

  int *ptr;

  w->glwDrawingArea.attribList = (int*)XtMalloc(ATTRIBLIST_SIZE*sizeof(int));

  if(!w->glwDrawingArea.attribList){

    error((Widget)w,"Unable to allocate attribute list");

    }

  ptr = w->glwDrawingArea.attribList;

  *ptr++ = GLX_BUFFER_SIZE;

  *ptr++ = w->glwDrawingArea.bufferSize;

  *ptr++ = GLX_LEVEL;

  *ptr++ = w->glwDrawingArea.level;

  if(w->glwDrawingArea.rgba) *ptr++ = GLX_RGBA;

  if(w->glwDrawingArea.doublebuffer) *ptr++ = GLX_DOUBLEBUFFER;

  if(w->glwDrawingArea.stereo) *ptr++ = GLX_STEREO;

  *ptr++ = GLX_AUX_BUFFERS;

  *ptr++ = w->glwDrawingArea.auxBuffers;

  *ptr++ = GLX_RED_SIZE;

  *ptr++ = w->glwDrawingArea.redSize;

  *ptr++ = GLX_GREEN_SIZE;

  *ptr++ = w->glwDrawingArea.greenSize;

  *ptr++ = GLX_BLUE_SIZE;

  *ptr++ = w->glwDrawingArea.blueSize;

  *ptr++ = GLX_ALPHA_SIZE;

  *ptr++ = w->glwDrawingArea.alphaSize;

  *ptr++ = GLX_DEPTH_SIZE;

  *ptr++ = w->glwDrawingArea.depthSize;

  *ptr++ = GLX_STENCIL_SIZE;

  *ptr++ = w->glwDrawingArea.stencilSize;

  *ptr++ = GLX_ACCUM_RED_SIZE;

  *ptr++ = w->glwDrawingArea.accumRedSize;

  *ptr++ = GLX_ACCUM_GREEN_SIZE;

  *ptr++ = w->glwDrawingArea.accumGreenSize;

  *ptr++ = GLX_ACCUM_BLUE_SIZE;

  *ptr++ = w->glwDrawingArea.accumBlueSize;

  *ptr++ = GLX_ACCUM_ALPHA_SIZE;

  *ptr++ = w->glwDrawingArea.accumAlphaSize;

  *ptr++ = None;

  assert((ptr-w->glwDrawingArea.attribList)

  }

/* Initialize the visualInfo based on the attribute list */

static void createVisualInfo(GLwDrawingAreaWidget w){

  assert(w->glwDrawingArea.attribList);

  w->glwDrawingArea.visualInfo=glXChooseVisual(XtDisplay(w),XScreenNumberOfScreen(XtScreen(w)),w->glwDrawingArea.attribList);

  if(!w->glwDrawingArea.visualInfo) error((Widget)w,"requested visual not supported");

  }

/* Initialize the colormap based on the visual info.

 * This routine maintains a cache of visual-infos to colormaps.  If two

 * widgets share the same visual info, they share the same colormap.

 * This function is called by the callProc of the colormap resource entry.

 */

static void createColormap(GLwDrawingAreaWidget w,int offset,XrmValue *value){

  static struct cmapCache { Visual *visual; Colormap cmap; } *cmapCache;

  static int cacheEntries=0;

  static int cacheMalloced=0;

  register int i;

  assert(w->glwDrawingArea.visualInfo);

  /* see if we can find it in the cache */

  for(i=0; i

    if(cmapCache[i].visual==w->glwDrawingArea.visualInfo->visual){

      value->addr=(XtPointer)(&cmapCache[i].cmap);

      return;

      }

    }

  /* not in the cache, create a new entry */

  if(cacheEntries >= cacheMalloced){

    /* need to malloc a new one.  Since we are likely to have only a

     * few colormaps, we allocate one the first time, and double

     * each subsequent time.

     */

    if(cacheMalloced==0){

      cacheMalloced=1;

      cmapCache=(struct cmapCache*)XtMalloc(sizeof(struct cmapCache));

      }

    else{

      cacheMalloced<<=1;

      cmapCache=(struct cmapCache*)XtRealloc((char*)cmapCache,sizeof(struct cmapCache)*cacheMalloced);

      }

    }

  cmapCache[cacheEntries].cmap=XCreateColormap(XtDisplay(w),

                                               RootWindow(XtDisplay(w),

                                               w->glwDrawingArea.visualInfo->screen),

                                               w->glwDrawingArea.visualInfo->visual,

                                               AllocNone);

  cmapCache[cacheEntries].visual=w->glwDrawingArea.visualInfo->visual;

  value->addr=(XtPointer)(&cmapCache[cacheEntries++].cmap);

  }

static void Initialize(GLwDrawingAreaWidget req,GLwDrawingAreaWidget neww,ArgList args,Cardinal *num_args){

  /* fix size */

  if(req->core.width==0) neww->core.width=100;

  if(req->core.height==0) neww->core.height=100;

  /* create the attribute list if needed */

  neww->glwDrawingArea.myList=FALSE;

  if(neww->glwDrawingArea.attribList==NULL){

    neww->glwDrawingArea.myList=TRUE;

    createAttribList(neww);

    }

  /* Gotta have it */

  assert(neww->glwDrawingArea.attribList);

  /* determine the visual info if needed */

  neww->glwDrawingArea.myVisual=FALSE;

  if(neww->glwDrawingArea.visualInfo==NULL){

    neww->glwDrawingArea.myVisual=TRUE;

    createVisualInfo(neww);

    }

  /* Gotta have that too */

  assert(neww->glwDrawingArea.visualInfo);

  neww->core.depth=neww->glwDrawingArea.visualInfo->depth;

  /* Reobtain the colormap and colors in it using XtGetApplicationResources*/

  XtGetApplicationResources((Widget)neww,neww,initializeResources,XtNumber(initializeResources),args,*num_args);

  /* obtain the color resources if appropriate */

  if(req->glwDrawingArea.allocateBackground){

    XtGetApplicationResources((Widget)neww,neww,backgroundResources,XtNumber(backgroundResources),args,*num_args);

    }

#ifdef __GLX_MOTIF

  if(req->glwDrawingArea.allocateOtherColors){

    XtGetApplicationResources((Widget)neww,neww,otherColorResources,XtNumber(otherColorResources),args,*num_args);

    }

#endif 

  }

static void Realize(Widget w,Mask *valueMask,XSetWindowAttributes *attributes){

  register GLwDrawingAreaWidget glw=(GLwDrawingAreaWidget)w;

  GLwDrawingAreaCallbackStruct cb;

  Widget parentShell;

  Status status;

  Window windows[2],*windowsReturn,*windowList;

  int countReturn,i;

  /* if we haven't requested that the background be both installed and

   * allocated, don't install it.

   */

  if(!(glw->glwDrawingArea.installBackground && glw->glwDrawingArea.allocateBackground)){

    *valueMask&=~CWBackPixel;

    }

  XtCreateWindow(w,(unsigned int)InputOutput,glw->glwDrawingArea.visualInfo->visual,*valueMask,attributes);

  /* if appropriate, call XSetWMColormapWindows to install the colormap */

  if(glw->glwDrawingArea.installColormap){

    /* Get parent shell */

    for(parentShell=XtParent(w); parentShell&&!XtIsShell(parentShell); parentShell=XtParent(parentShell));

    if(parentShell && XtWindow(parentShell)){

      /* check to see if there is already a property */

      status=XGetWMColormapWindows(XtDisplay(parentShell),XtWindow(parentShell),&windowsReturn,&countReturn);

      /* if no property, just create one */

      if(!status){

        windows[0]=XtWindow(w);

        windows[1]=XtWindow(parentShell);

        XSetWMColormapWindows(XtDisplay(parentShell),XtWindow(parentShell),windows,2);

        }

      /* there was a property, add myself to the beginning */

      else{

        windowList=(Window *)XtMalloc((sizeof(Window))*(countReturn+1));

        windowList[0]=XtWindow(w);

        for(i=0; i

        XSetWMColormapWindows(XtDisplay(parentShell),XtWindow(parentShell),windowList,countReturn+1);

        XtFree((char*)windowList);

        XtFree((char*)windowsReturn);

        }

      }

    else{

      warning(w,"Could not set colormap property on parent shell");

      }

    }

  /* Invoke callbacks */

  cb.reason=GLwCR_GINIT;

  cb.event=NULL;

  cb.width=glw->core.width;

  cb.height=glw->core.height;

  XtCallCallbackList((Widget)glw,glw->glwDrawingArea.ginitCallback,&cb;;

  }

static void Redraw(GLwDrawingAreaWidget w,XEvent *event,Region region){

  GLwDrawingAreaCallbackStruct cb;

  if(!XtIsRealized((Widget)w)) return;

  cb.reason=GLwCR_EXPOSE;

  cb.event=event;

  cb.width=w->core.width;

  cb.height=w->core.height;

  XtCallCallbackList((Widget)w,w->glwDrawingArea.exposeCallback,&cb;;

  }

static void Resize(GLwDrawingAreaWidget glw){

  GLwDrawingAreaCallbackStruct cb;

  if(!XtIsRealized((Widget)glw)) return;

  cb.reason=GLwCR_RESIZE;

  cb.event=NULL;

  cb.width=glw->core.width;

  cb.height=glw->core.height;

  XtCallCallbackList((Widget)glw,glw->glwDrawingArea.resizeCallback,&cb;;

  }

static void Destroy(GLwDrawingAreaWidget glw){

  Window *windowsReturn;

  Widget parentShell;

  Status status;

  int countReturn;

  register int i;

  if(glw->glwDrawingArea.myList && glw->glwDrawingArea.attribList){

    XtFree((XtPointer)glw->glwDrawingArea.attribList);

    }

  if(glw->glwDrawingArea.myVisual && glw->glwDrawingArea.visualInfo){

    XtFree((XtPointer)glw->glwDrawingArea.visualInfo);

    }

  /* if my colormap was installed, remove it */

  if(glw->glwDrawingArea.installColormap){

    /* Get parent shell */

    for(parentShell=XtParent(glw); parentShell&&!XtIsShell(parentShell); parentShell=XtParent(parentShell));

    if(parentShell && XtWindow(parentShell)){

      /* make sure there is a property */

      status=XGetWMColormapWindows(XtDisplay(parentShell),XtWindow(parentShell),&windowsReturn,&countReturn);

      /* if no property, just return.  If there was a property, continue */

      if(status){

        /* search for a match */

        for(i=0; i

          if(windowsReturn[i]==XtWindow(glw)){

            /* we found a match, now copy the rest down */

            for(i++; i

            XSetWMColormapWindows(XtDisplay(parentShell),XtWindow(parentShell),windowsReturn,countReturn-1);

            break; 

            }

          }

        XtFree((char *)windowsReturn);

        }

      }

    }

  }

/* Action routine for keyboard and mouse events */

static void glwInput(GLwDrawingAreaWidget glw,XEvent *event,String *params,Cardinal *numParams){

  GLwDrawingAreaCallbackStruct cb;

  cb.reason=GLwCR_INPUT;

  cb.event=event;

  cb.width=glw->core.width;

  cb.height=glw->core.height;

  XtCallCallbackList((Widget)glw,glw->glwDrawingArea.inputCallback,&cb;;

  }

#ifdef __GLX_MOTIF

/* Create routine */

Widget GLwCreateMDrawingArea(Widget parent, char *name,ArgList arglist,Cardinal argcount){

  return XtCreateWidget(name,glwMDrawingAreaWidgetClass, parent, arglist,argcount);

  }

#endif

#ifndef __GLX_MOTIF

/* Make context current */

void GLwDrawingAreaMakeCurrent(Widget w,GLXContext ctx){

  glXMakeCurrent(XtDisplay(w),XtWindow(w),ctx);

  }

/* Swap buffers convenience function */

void GLwDrawingAreaSwapBuffers(Widget w){

  glXSwapBuffers(XtDisplay(w),XtWindow(w));

  }

#endif