685 lines
24 KiB
C
685 lines
24 KiB
C
/*
|
|
* (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.width=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
|