/*
* (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)<ATTRIBLIST_SIZE);
}
/* 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<cacheEntries; 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<countReturn; i++) windowList[i+1]=windowsReturn[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<countReturn; i++){
if(windowsReturn[i]==XtWindow(glw)){
/* we found a match, now copy the rest down */
for(i++; i<countReturn; i++){ windowsReturn[i-1]=windowsReturn[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