sync code with last improvements from OpenBSD
This commit is contained in:
commit
88965415ff
GPG key ID:
F42C07F07E2E35B7
26235 changed files with 29195616 additions and 0 deletions
732
lib/libGLw/GLwDrawA.c
Normal file
732
lib/libGLw/GLwDrawA.c
Normal file
|
|
@ -0,0 +1,732 @@
|
|||
/*
|
||||
** License Applicability. Except to the extent portions of this file are
|
||||
** made subject to an alternative license as permitted in the SGI Free
|
||||
** Software License B, Version 1.1 (the "License"), the contents of this
|
||||
** file are subject only to the provisions of the License. You may not use
|
||||
** this file except in compliance with the License. You may obtain a copy
|
||||
** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
|
||||
** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
|
||||
**
|
||||
** http://oss.sgi.com/projects/FreeB
|
||||
**
|
||||
** Note that, as provided in the License, the Software is distributed on an
|
||||
** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
|
||||
** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
|
||||
** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
|
||||
** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
|
||||
**
|
||||
** Original Code. The Original Code is: OpenGL Sample Implementation,
|
||||
** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
|
||||
** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
|
||||
** Copyright in any portions created by third parties is as indicated
|
||||
** elsewhere herein. All Rights Reserved.
|
||||
**
|
||||
** Additional Notice Provisions: The application programming interfaces
|
||||
** established by SGI in conjunction with the Original Code are The
|
||||
** OpenGL(R) Graphics System: A Specification (Version 1.2.1), released
|
||||
** April 1, 1999; The OpenGL(R) Graphics System Utility Library (Version
|
||||
** 1.3), released November 4, 1998; and OpenGL(R) Graphics with the X
|
||||
** Window System(R) (Version 1.3), released October 19, 1998. This software
|
||||
** was created using the OpenGL(R) version 1.2.1 Sample Implementation
|
||||
** published by SGI, but has not been independently verified as being
|
||||
** compliant with the OpenGL(R) version 1.2.1 Specification.
|
||||
**
|
||||
*/
|
||||
/* $XFree86$ */
|
||||
|
||||
#include <stdio.h>
|
||||
#include <GL/glx.h>
|
||||
#include <GL/gl.h>
|
||||
#ifdef __GLX_MOTIF
|
||||
#include "GLwMDrawAP.h"
|
||||
#else /* not __GLX_MOTIF */
|
||||
#include "GLwDrawAP.h"
|
||||
#include <X11/IntrinsicP.h>
|
||||
#include <X11/StringDefs.h>
|
||||
#endif /* __GLX_MOTIF */
|
||||
#include <assert.h>
|
||||
|
||||
#ifdef __GLX_MOTIF
|
||||
/* The MOTIF version differs only in the inclusion of the primitive
|
||||
* widget class and in a vew variable and type name differences.
|
||||
* Rather than put ifdefs all over the place, we just use a few defines
|
||||
* to make it use motif types and names
|
||||
*/
|
||||
#define GLwDrawingAreaWidget GLwMDrawingAreaWidget
|
||||
#define GLwDrawingAreaClassRec GLwMDrawingAreaClassRec
|
||||
#define glwDrawingAreaClassRec glwMDrawingAreaClassRec
|
||||
#define glwDrawingAreaWidgetClass glwMDrawingAreaWidgetClass
|
||||
#define GLwDrawingAreaRec GLwMDrawingAreaRec
|
||||
#endif /* __GLX_MOTIF */
|
||||
|
||||
/* forward definitions */
|
||||
/* resource default procs */
|
||||
static void createColormap(GLwDrawingAreaWidget w,
|
||||
int offset, XrmValue *value);
|
||||
|
||||
/* widget methods */
|
||||
static void Initialize(GLwDrawingAreaWidget req, GLwDrawingAreaWidget new,
|
||||
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);
|
||||
|
||||
#define offset(field) XtOffset(GLwDrawingAreaWidget, glwDrawingArea.field)
|
||||
|
||||
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 void glwInput(GLwDrawingAreaWidget glw, XEvent *event,
|
||||
String *, Cardinal *);
|
||||
|
||||
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},
|
||||
|
||||
#ifdef __GLX_MOTIF
|
||||
/* Changes to Motif primitive resources */
|
||||
{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 /* __GLX_MOTIF */
|
||||
};
|
||||
|
||||
/* 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),
|
||||
XmRCallProc, (XtPointer) _XmBackgroundColorDefault
|
||||
},
|
||||
{
|
||||
XmNbackgroundPixmap, XmCPixmap, XmRXmBackgroundPixmap,
|
||||
sizeof (Pixmap), XtOffset(GLwDrawingAreaWidget, core.background_pixmap),
|
||||
XmRImmediate, (XtPointer) XmUNSPECIFIED_PIXMAP
|
||||
},
|
||||
|
||||
#else /* ! __GLX_MOTIF */
|
||||
{XtNbackground, XtCBackground, XtRPixel,sizeof(Pixel),
|
||||
XtOffset(GLwDrawingAreaWidget,core.background_pixel),
|
||||
XtRString, (XtPointer)"XtDefaultBackground"},
|
||||
{XtNbackgroundPixmap, XtCPixmap, XtRPixmap, sizeof(Pixmap),
|
||||
XtOffset(GLwDrawingAreaWidget,core.background_pixmap),
|
||||
XtRImmediate, (XtPointer)XtUnspecifiedPixmap},
|
||||
#endif /* __GLX_MOTIF */
|
||||
};
|
||||
|
||||
/* 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),
|
||||
XmRCallProc, (XtPointer) _XmForegroundColorDefault
|
||||
},
|
||||
|
||||
{
|
||||
XmNhighlightColor, XmCHighlightColor, XmRPixel, sizeof (Pixel),
|
||||
XtOffset(GLwDrawingAreaWidget, primitive.highlight_color),
|
||||
XmRCallProc, (XtPointer) _XmHighlightColorDefault
|
||||
},
|
||||
|
||||
{
|
||||
XmNhighlightPixmap, XmCHighlightPixmap, XmRPrimHighlightPixmap,
|
||||
sizeof (Pixmap),
|
||||
XtOffset(GLwDrawingAreaWidget, primitive.highlight_pixmap),
|
||||
XmRCallProc, (XtPointer) _XmPrimitiveHighlightPixmapDefault
|
||||
},
|
||||
};
|
||||
#endif /* __GLX_MOTIF */
|
||||
|
||||
struct attribInfo
|
||||
{
|
||||
int offset;
|
||||
int attribute;
|
||||
};
|
||||
|
||||
static struct attribInfo intAttribs[] =
|
||||
{
|
||||
{ offset(bufferSize), GLX_BUFFER_SIZE },
|
||||
{ offset(level), GLX_LEVEL },
|
||||
{ offset(auxBuffers), GLX_AUX_BUFFERS },
|
||||
{ offset(redSize), GLX_RED_SIZE },
|
||||
{ offset(greenSize), GLX_GREEN_SIZE },
|
||||
{ offset(blueSize), GLX_BLUE_SIZE },
|
||||
{ offset(alphaSize), GLX_ALPHA_SIZE },
|
||||
{ offset(depthSize), GLX_DEPTH_SIZE },
|
||||
{ offset(stencilSize), GLX_STENCIL_SIZE },
|
||||
{ offset(accumRedSize), GLX_ACCUM_RED_SIZE },
|
||||
{ offset(accumGreenSize), GLX_ACCUM_GREEN_SIZE },
|
||||
{ offset(accumBlueSize), GLX_ACCUM_BLUE_SIZE },
|
||||
{ offset(accumAlphaSize), GLX_ACCUM_ALPHA_SIZE },
|
||||
{ 0, None },
|
||||
};
|
||||
|
||||
static struct attribInfo booleanAttribs[] =
|
||||
{
|
||||
{ offset(rgba), GLX_RGBA },
|
||||
{ offset(doublebuffer), GLX_DOUBLEBUFFER },
|
||||
{ offset(stereo), GLX_STEREO },
|
||||
{ 0, None },
|
||||
};
|
||||
|
||||
#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 /* __GLX_MOTIF */
|
||||
};
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
/* resource initialization methods */
|
||||
/* Initialize the attribList based on the attributes */
|
||||
static void createAttribList(GLwDrawingAreaWidget w)
|
||||
{
|
||||
int listLength;
|
||||
register struct attribInfo *ap;
|
||||
int *ip;
|
||||
|
||||
/* first find out how long a list we need */
|
||||
listLength=1; /* include the terminating NULL */
|
||||
for (ap = booleanAttribs; ap->attribute; ap++)
|
||||
{
|
||||
if (*(Boolean *)(((char *)w)+ap->offset))
|
||||
listLength++; /* one word for a boolean */
|
||||
}
|
||||
for (ap = intAttribs; ap->attribute; ap++)
|
||||
{
|
||||
if (*(int *)(((char *)w)+ap->offset))
|
||||
listLength+=2; /* one word for an int */
|
||||
}
|
||||
w->glwDrawingArea.attribList = (int *)XtMalloc(listLength*sizeof(int));
|
||||
ip = w->glwDrawingArea.attribList;
|
||||
for (ap = booleanAttribs; ap->attribute; ap++)
|
||||
{
|
||||
if (*(Boolean *)(((char *)w)+ap->offset))
|
||||
*ip++ = ap->attribute;
|
||||
}
|
||||
for (ap = intAttribs; ap->attribute; ap++)
|
||||
{
|
||||
if (*(int *)(((char *)w)+ap->offset))
|
||||
{
|
||||
*ip++ = ap->attribute;
|
||||
*ip++ = *(int *)(((char *)w)+ap->offset);
|
||||
}
|
||||
}
|
||||
*ip = None;
|
||||
}
|
||||
|
||||
/* 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;
|
||||
int screen;
|
||||
} *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 &&
|
||||
cmapCache[i].screen == w->glwDrawingArea.visualInfo->screen)
|
||||
{
|
||||
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;
|
||||
cmapCache[cacheEntries].screen = w->glwDrawingArea.visualInfo->screen;
|
||||
value->addr = (XtPointer) (&cmapCache[cacheEntries++].cmap);
|
||||
}
|
||||
|
||||
static void
|
||||
Initialize (GLwDrawingAreaWidget req, GLwDrawingAreaWidget new,
|
||||
ArgList args, Cardinal *num_args)
|
||||
{
|
||||
|
||||
if (req->core.width == 0)
|
||||
new->core.width = 100;
|
||||
if (req->core.height == 0)
|
||||
new->core.width = 100;
|
||||
|
||||
/* create the attribute list if needed */
|
||||
if (new->glwDrawingArea.attribList == NULL)
|
||||
{
|
||||
new->glwDrawingArea.myList = TRUE;
|
||||
createAttribList(new);
|
||||
}
|
||||
else
|
||||
new->glwDrawingArea.myList = FALSE;
|
||||
|
||||
/* determine the visual info if needed */
|
||||
if (new->glwDrawingArea.visualInfo == NULL)
|
||||
{
|
||||
new->glwDrawingArea.myVisual = TRUE;
|
||||
createVisualInfo(new);
|
||||
}
|
||||
else
|
||||
new->glwDrawingArea.myVisual = FALSE;
|
||||
|
||||
new->core.depth = new->glwDrawingArea.visualInfo->depth;
|
||||
|
||||
/* Reobtain the colormap and colors in it using XtGetApplicationResources*/
|
||||
XtGetApplicationResources((Widget) new, new,
|
||||
initializeResources,
|
||||
XtNumber(initializeResources),
|
||||
args, *num_args);
|
||||
|
||||
/* obtain the color resources if appropriate */
|
||||
if (req->glwDrawingArea.allocateBackground)
|
||||
XtGetApplicationResources((Widget) new, new,
|
||||
backgroundResources,
|
||||
XtNumber(backgroundResources),
|
||||
args, *num_args);
|
||||
|
||||
#ifdef __GLX_MOTIF
|
||||
if (req->glwDrawingArea.allocateOtherColors)
|
||||
XtGetApplicationResources((Widget) new, new,
|
||||
otherColorResources,
|
||||
XtNumber(otherColorResources),
|
||||
args, *num_args);
|
||||
#endif /* __GLX_MOTIF */
|
||||
|
||||
}
|
||||
|
||||
static void
|
||||
Realize(Widget w, Mask *valueMask, XSetWindowAttributes *attributes)
|
||||
{
|
||||
register GLwDrawingAreaWidget glw = (GLwDrawingAreaWidget)w;
|
||||
GLwDrawingAreaCallbackStruct cb;
|
||||
|
||||
/* 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)
|
||||
{
|
||||
Widget parentShell = XtParent(w);
|
||||
Status status;
|
||||
Window *windowsReturn;
|
||||
int countReturn;
|
||||
|
||||
while (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)
|
||||
{
|
||||
Window windows[2];
|
||||
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
|
||||
{
|
||||
Window *windows = (Window *)XtMalloc((sizeof(Window))*
|
||||
(countReturn+1));
|
||||
register int i;
|
||||
windows[0] = XtWindow(w);
|
||||
for (i=0; i<countReturn; i++)
|
||||
windows[i+1] = windowsReturn[i];
|
||||
XSetWMColormapWindows(XtDisplay(parentShell),
|
||||
XtWindow(parentShell),
|
||||
windows, countReturn+1);
|
||||
XtFree((char *) windows);
|
||||
XFree((char *) windowsReturn);
|
||||
}
|
||||
}
|
||||
else
|
||||
warning((Widget)w,
|
||||
"Could not set colormap property on parent shell");
|
||||
}
|
||||
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;
|
||||
|
||||
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 we get a resize event before being realized, we can't handle it */
|
||||
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)
|
||||
{
|
||||
if (glw->glwDrawingArea.myList && glw->glwDrawingArea.attribList)
|
||||
XtFree ((XtPointer)glw->glwDrawingArea.attribList);
|
||||
if (glw->glwDrawingArea.myVisual && glw->glwDrawingArea.visualInfo)
|
||||
XFree ((XtPointer)glw->glwDrawingArea.visualInfo);
|
||||
|
||||
/* if my colormap was installed, remove it */
|
||||
if (glw->glwDrawingArea.installColormap)
|
||||
{
|
||||
Widget parentShell = XtParent(glw);
|
||||
Status status;
|
||||
Window *windowsReturn;
|
||||
int countReturn;
|
||||
register int i;
|
||||
|
||||
/* find the parent shell */
|
||||
while (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 copu the rest down */
|
||||
for (i++; i<countReturn; i++)
|
||||
{
|
||||
windowsReturn[i-1] = windowsReturn[i];
|
||||
}
|
||||
XSetWMColormapWindows(XtDisplay(parentShell),
|
||||
XtWindow(parentShell),
|
||||
windowsReturn, countReturn-1);
|
||||
break; /* from outer for */
|
||||
}
|
||||
}
|
||||
XFree((char *) windowsReturn);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Action routine for keyboard and mouse events */
|
||||
/* ARGSUSED */
|
||||
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
|
||||
/* Provide a Motif-style create routine */
|
||||
Widget GLwCreateMDrawingArea(Widget parent, char *name,
|
||||
ArgList arglist, Cardinal argcount)
|
||||
{
|
||||
return (XtCreateWidget (name, glwMDrawingAreaWidgetClass, parent, arglist,
|
||||
argcount));
|
||||
}
|
||||
#endif
|
||||
Loading…
Add table
Add a link
Reference in a new issue