GLPixelCanvas.h

Go to the documentation of this file.

//# GLPixelCanvas.h: Class defining OpenGL version PixelCanvas.
//# Copyright (C) 2001
//# Associated Universities, Inc. Washington DC, USA.
//#
//# This library is free software; you can redistribute it and/or modify it
//# under the terms of the GNU Library General Public License as published by
//# the Free Software Foundation; either version 2 of the License, or (at your
//# option) any later version.
//#
//# This library is distributed in the hope that it will be useful, but WITHOUT
//# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
//# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Library General Public
//# License for more details.
//#
//# You should have received a copy of the GNU Library General Public License
//# along with this library; if not, write to the Free Software Foundation,
//# Inc., 675 Massachusetts Ave, Cambridge, MA 02139, USA.
//#
//# Correspondence concerning AIPS++ should be addressed as follows:
//#        Internet email: aips2-request@nrao.edu.
//#        Postal address: AIPS++ Project Office
//#                        National Radio Astronomy Observatory
//#                        520 Edgemont Road
//#                        Charlottesville, VA 22903-2475 USA
//#
//# $Id $

#ifndef TRIALDISPLAY_GLPIXELCANVAS_H
#define TRIALDISPLAY_GLPIXELCANVAS_H

#include <casa/aips.h>
#include <graphics/X11/X_enter.h>
#include <X11/Xlib.h>
#include <X11/Intrinsic.h>
#include <X11/Xutil.h>
#include <GL/gl.h>
#include <GL/glx.h>
#include <graphics/X11/X_exit.h>

#include <display/Display/PixelCanvas.h>
#include <display/Display/GLPixelCanvasColorTable.h>
#include <display/Display/GLSupport.h>

namespace casa { //# NAMESPACE CASA - BEGIN

        class GLPCDisplayList;
        class GLPCDisplayListEntry;
        class GLPCDisplayListElement;
        class GLPCTextureParams;

// <summary>
//      OpenGL implementation of PixelCanvas.
// </summary>

// <use visibility=export>

// <prerequisite>
// <li> <linkto class="PixelCanvasColorTable">PixelCanvasColorTable</linkto>
// <li> <linkto class="GLPixelCanvasColorTable">GLPixelCanvasColorTable</linkto>
// <li> <linkto class="PixelCanvas">PixelCanvas</linkto>
// <li> <linkto class="X11PixelCanvas"> Knowledge of X11PixelCanvas could help</linkto>
// </prerequisite>
//
// <synopsis>
// Implementation of PixelCanvas for OpenGL. Most, but not all of the
// PixelCanvas functions are available. There is very little support for
// 3D.
// </synopsis>
// <thrown>
//    None
// </thrown>
// <todo asof="2001/09/25">
//#   <li>
// </todo>

        class GLPixelCanvas : public PixelCanvas {
        public:
// <note role=caution>
// Drawing can not take place until the window exists!
// </note>
                GLPixelCanvas(Widget parent, GLPixelCanvasColorTable * glpcctbl,
                              uInt width, uInt height);
                virtual ~GLPixelCanvas();

                // enabling/disabling of event tracking (unimplemented)
                // <group>
                virtual void enableMotionEvents();
                virtual void disableMotionEvents();
                virtual void enablePositionEvents();
                virtual void disablePositionEvents();
                // </group>

                // Does this canvas support cached display lists?  The user of the
                // canvas should always check this, because undefined behaviour can
                // result when an attempt is made to use a list on a PixelCanvas
                // which does not support lists.
                virtual Bool supportsLists();

                // begin caching display commands - return list ID
                virtual uInt newList();
                // end caching display commands
                virtual void endList();
                // (Cacheable) recall cached display commands
                virtual void drawList(uInt list);
                // translate all lists
                virtual void translateAllLists(Int xt, Int yt);
                // translate the list
                virtual void translateList(uInt list, Int xt, Int yt);
                // remove list from cache
                virtual void deleteList(uInt list);
                // flush all lists from the cache
                virtual void deleteLists();
                // return True if the list exists
                virtual Bool validList(uInt list);

                // (Cacheable) Set the font to the recognizable font name. (unimplemented)
                virtual Bool setFont(const String &fontName);
                // (Cacheable) Draw text using that font aligned in some way to the
                // position. (unimplemented)
                virtual void drawText(Int x, Int y, const String &text,
                                      Display::TextAlign alignment = Display::AlignCenter);

                // (Cacheable) Draw an array of 2D color data as a raster image for zoom = <1,1>
                // <group>
                virtual void drawImage(const Matrix<uInt> &data, Int x, Int y);
                virtual void drawImage(const Matrix<Int> &data, Int x, Int y);
                virtual void drawImage(const Matrix<uLong> &data, Int x, Int y);
                virtual void drawImage(const Matrix<Float> &data, Int x, Int y);
                virtual void drawImage(const Matrix<Double> &data, Int x, Int y);
                // </group>
                // (Cacheable) Draw an image using color indexes. If in RGB mode,
                // the virtual colortable is used.
                void GLPixelCanvas::drawIndexedImage( const Matrix<uInt> &data,
                                                      Float x=0.0, Float y=0.0, Float z=0.0,
                                                      Float xscl=1.0, Float yscl=1.0);
                // (Cacheable) Draw an array of 2D color data as a raster image,
                // taking note of the <src>Bool</src> mask.
                // (opaqueMask ignored/unimplemented)
                // <group>
                virtual void drawImage(const Int &x, const Int &y,
                                       const Matrix<uInt> &data,
                                       const Matrix<Bool> &mask,
                                       Bool opaqueMask=False);
                // </group>

                // (Cacheable) Draw an array of 2D color data as a raster image for any positive integer zoom
                // <group>
                virtual void drawImage(const Matrix<uInt> &data, Int x, Int y,
                                       uInt xzoom, uInt yzoom);
                virtual void drawImage(const Matrix<Int> &data, Int x, Int y,
                                       uInt xzoom, uInt yzoom);
                virtual void drawImage(const Matrix<uLong> &data, Int x, Int y,
                                       uInt xzoom, uInt yzoom);
                virtual void drawImage(const Matrix<Float> &data, Int x, Int y,
                                       uInt xzoom, uInt yzoom);
                virtual void drawImage(const Matrix<Double> &data, Int x, Int y,
                                       uInt xzoom, uInt yzoom);
                // </group>

                // (Cacheable) Draw a component of a multi-channel image, storing it
                // in buffers until flushComponentImages() is called.
                virtual void drawImage(const Matrix<uInt> &data, const Int &x, const Int &y,
                                       const Display::ColorComponent &colorcomponent);

                // Fill one of the channel buffers.
                virtual void bufferComponent(const Matrix<uInt> &data,
                                             const Int &x, const Int &y,
                                             const Display::ColorComponent
                                             &colorcomponent);

                // (NOT CACHEABLE!) Flush the component buffers.
                virtual void flushComponentBuffers();

                // (Cacheable) Draw a single point using current color
                // <group>
                virtual void drawPoint(Int x1, Int y1);
                virtual void drawPoint(Float x1, Float y1);
                virtual void drawPoint3D(Float x1, Float y1, Float z1);
                virtual void drawPoint(Double x1, Double y1);
                // </group>

                // (Cacheable) Draw N points specified as a Nx2 matrix
                // <group>
                virtual void drawPoints(const Matrix<Int> &verts);
                virtual void drawPoints(const Matrix<Float> &verts);
                void drawPoints3D(const Matrix<Float> &verts);
                virtual void drawPoints(const Matrix<Double> &verts);
                // </group>

                // (Cacheable) Draw a bunch of points using current color
                // <group>
                virtual void drawPoints(const Vector<Int> &x1, const Vector<Int> &y1);
                virtual void drawPoints(const Vector<Float> &x1,
                                        const Vector<Float> &y1);
                virtual void drawPoints3D(const Vector<Float> &x1,
                                          const Vector<Float> &y1, const Vector<Float> &z1);
                virtual void drawPoints(const Vector<Double> &x1,
                                        const Vector<Double> &y1);
                // </group>
// (cacheable) Change the size of the points (in pixels) drawn by drawPoints.
                void setPointSize(const uInt pointsize);

                // (Cacheable) Draw a single line using current color
                // <group>
                virtual void drawLine(Int x1, Int y1, Int x2, Int y2);
                virtual void drawLine(Float x1, Float y1, Float x2, Float y2);
                virtual void drawLine3D(Float x1, Float y1, Float z1,
                                        Float x2, Float y2, Float z2);
                virtual void drawLine(Double x1, Double y1, Double x2, Double y2);
                // </group>

                // (Cacheable) Draw N/2 lines from an Nx2 matrix
                // <group>
                virtual void drawLines(const Matrix<Int> &verts);
                virtual void drawLines(const Matrix<Float> &verts);
                virtual void drawLines3D(const Matrix<Float> &verts);
                virtual void drawLines(const Matrix<Double> &verts);
                // </group>

                // (Cacheable) Draw a bunch of unrelated lines using current color
                // <group>
                virtual void drawLines(const Vector<Int> &x1, const Vector<Int> &y1,
                                       const Vector<Int> &x2, const Vector<Int> &y2);
                virtual void drawLines(const Vector<Float> &x1, const Vector<Float> &y1,
                                       const Vector<Float> &x2,
                                       const Vector<Float> &y2);
                virtual void drawLines(const Vector<Double> &x1, const Vector<Double> &y1,
                                       const Vector<Double> &x2,
                                       const Vector<Double> &y2);
                // </group>

                // (Cacheable) Draw a single connected line between the given points.
                // <group>
                virtual void drawPolyline(const Vector<Int> &x1,
                                          const Vector<Int> &y1);
                virtual void drawPolyline(const Vector<Float> &x1,
                                          const Vector<Float> &y1);
                virtual void drawPolyline3D(const Vector<Float> &x1,
                                            const Vector<Float> &y1,
                                            const Vector<Float> &z1);
                virtual void drawPolyline(const Vector<Double> &x1,
                                          const Vector<Double> &y1);
                // </group>

                // (Cacheable) Draw N-1 connected lines from Nx2 matrix of vertices
                // <group>
                virtual void drawPolyline(const Matrix<Int> &verts);
                virtual void drawPolyline(const Matrix<Float> &verts);
                virtual void drawPolyline(const Matrix<Double> &verts);
                // </group>

                // (Cacheable) Draw a closed polygon
                // <group>
                virtual void drawPolygon(const Vector<Int> &x1, const Vector<Int> &y1);
                virtual void drawPolygon(const Vector<Float> &x1,
                                         const Vector<Float> &y1);
                virtual void drawPolygon3D(const Vector<Float> &x1,
                                           const Vector<Float> &y1,
                                           const Vector<Float> &z1);
                virtual void drawPolygon(const Vector<Double> &x1,
                                         const Vector<Double> &y1);
                // </group>

                // (Cacheable) Draw and fill a closed polygon
                // <group>
                virtual void drawFilledPolygon(const Vector<Int> &x1,
                                               const Vector<Int> &y1);
                virtual void drawFilledPolygon(const Vector<Float> &x1,
                                               const Vector<Float> &y1);
                virtual void drawFilledPolygon3D(const Vector<Float> &x1,
                                                 const Vector<Float> &y1,
                                                 const Vector<Float> &z1);
                virtual void drawFilledPolygon(const Vector<Double> &x1,
                                               const Vector<Double> &y1);
                // </group>

                // (Cacheable) Draw a closed N-sided polygon from Nx2 matrix of vertices
                // <group>
                virtual void drawPolygon(const Matrix<Int> &verts);
                virtual void drawPolygon(const Matrix<Float> &verts);
                virtual void drawPolygon3D(const Matrix<Float> &verts);
                virtual void drawPolygon(const Matrix<Double> &verts);
                // </group>

                // (Cacheable) Draw a rectangle
                // <group>
                virtual void drawRectangle(Int x1, Int y1, Int x2, Int y2);
                virtual void drawRectangle(Float x1, Float y1, Float x2, Float y2);
                virtual void drawRectangle(Double x1, Double y1, Double x2, Double y2);
                // </group>

                // (Cacheable) Draw a filled rectangle
                // <group>
                virtual void drawFilledRectangle(Int x1, Int y1, Int x2, Int y2);
                virtual void drawFilledRectangle(Float x1, Float y1, Float x2, Float y2);
                virtual void drawFilledRectangle(Double x1, Double y1, Double x2,
                                                 Double y2);
                // </group>

                // (Cacheable) Draw a set of points, specifying a color per point to be drawn.
                // <group>
                virtual void drawColoredPoints(const Vector<Int> &x1,
                                               const Vector<Int> &y1,
                                               const Vector<uInt> &colors);
                virtual void drawColoredPoints(const Vector<Float> &x1,
                                               const Vector<Float> &y1,
                                               const Vector<uInt> &colors);
                virtual void drawColoredPoints(const Vector<Double> &x1,
                                               const Vector<Double> &y1,
                                               const Vector<uInt> &colors);
                virtual void drawColoredPoints(const Matrix<Int> &xy,
                                               const Vector<uInt> &colors);
                virtual void drawColoredPoints(const Matrix<Float> &xy,
                                               const Vector<uInt> &colors);

                virtual void drawColoredPoints(const Matrix<Double> &xy,
                                               const Vector<uInt> &colors);

                // </group>

                // (Cacheable) Draw a set of lines, specifying a color per line to be drawn.
                // <group>
                virtual void drawColoredLines(const Vector<Int> &x1,
                                              const Vector<Int> &y1,
                                              const Vector<Int> &x2,
                                              const Vector<Int> &y2,
                                              const Vector<uInt> &colors);
                virtual void drawColoredLines(const Vector<Float> &x1,
                                              const Vector<Float> &y1,
                                              const Vector<Float> &x2,
                                              const Vector<Float> &y2,
                                              const Vector<uInt> &colors);
                virtual void drawColoredLines(const Vector<Double> &x1,
                                              const Vector<Double> &y1,
                                              const Vector<Double> &x2,
                                              const Vector<Double> &y2,
                                              const Vector<uInt> &colors);
                // </group>

                // Set Graphics Attributes
                // Options for functions with enum argument
                // listed in <linkto class=Display>DisplayEnums</linkto>
                // <group>
                virtual void setForeground(uLong color);
                virtual void setLineWidth(Float width);
                virtual void setLineStyle(Display::LineStyle style);
                virtual void setFillStyle(Display::FillStyle style);
                virtual void setDrawFunction(Display::DrawFunction function);
                // </group>

                // Unimplemented set graphics functions.
                // <group>
                virtual void setBackground(uLong color);
                virtual void setCapStyle(Display::CapStyle style);
                virtual void setJoinStyle(Display::JoinStyle style);
                virtual void setFillRule(Display::FillRule rule);
                virtual void setArcMode(Display::ArcMode mode);
                // </group>

                // Implemented get Graphics Attributes functions.
                // <group>
                virtual uLong                 getForeground()   const;
                virtual Float                 getLineWidth()    const;
                virtual Display::LineStyle    getLineStyle()    const;
                virtual Display::FillStyle    getFillStyle()    const;
                virtual Display::DrawFunction getDrawFunction() const;
                // </group>
                // Unimplemented get Graphics Attributes.
                // <group>
                virtual uLong                 getBackground()   const;
                virtual Display::CapStyle     getCapStyle()     const;
                virtual Display::JoinStyle    getJoinStyle()    const;
                virtual Display::FillRule     getFillRule()     const;
                virtual Display::ArcMode      getArcMode()      const;
                // </group>

                // (Cacheable) Option Control
                // Options listed in <linkto class=Display>DisplayEnums</linkto>
                // Only Display::ClipWindow is implemented.
                // <group>
                virtual Bool enable(Display::Option option);
                virtual Bool disable(Display::Option option);
                // </group>

                // Control the image-caching strategy. (Ignored)
                virtual void setImageCacheStrategy(Display::ImageCacheStrategy strategy);
                virtual Display::ImageCacheStrategy imageCacheStrategy() const;

                // (Cacheable) Setup the clip window.  The clip window, when enabled, allows
                // a user to clip all graphics output to a rectangular region on
                // the screen.
                // <group>
                virtual void setClipWindow(Int x1, Int y1, Int x2, Int y2);
                virtual void getClipWindow(Int &x1, Int &y1, Int &x2, Int &y2);
                // </group>

                // (Not Cacheable) Redraw the window
                // <group>
                void redraw() {
                        repaint(True);
                }
                virtual void refresh(const Display::RefreshReason &reason =
                                         Display::UserCommand,
                                     const Bool &explicitrequest = True);
                // Just redraws window. (If redraw is T, the window will be redrawn. If
                // F, it will only be redrawn if autoRefresh is T.
                void repaint(const Bool redraw=False);
                // </group>

                // Cause display to flush any graphics commands not yet drawn
                virtual void flush();

                // (Cacheable) Clear the window using the background color
                // <note role=tip> If you want to clear the window use clear(),
                // not clear(IIII).
                // </note>
                // <group>
                virtual void clear();
                virtual void clear(Int x1, Int y1, Int x2, Int y2);
                // </group>

                // (Cacheable) Set the color to use for clearing the display
                // <group>
                virtual void setClearColor(uInt colorIndex);
                // <note role=caution> Setting named colors for Index mode isn't implemented.
                // </note>
                virtual void setClearColor(const String &colorname);
                virtual void setClearColor(float r, float g, float b);
                // </group>

                // (Not Cacheable) Get the current color to use for clearing the display.
                virtual uInt clearColor() const;
                virtual void getClearColor(float &r, float &g, float &b) const;

                // Get/set the current foreground/background colors.  These colors
                // should be used when the special Strings "foreground" and "background"
                // are given for a color.
                // <group>
                virtual void setDeviceForegroundColor(const String colorname);
                virtual String deviceForegroundColor() const;
                virtual void setDeviceBackgroundColor(const String colorname);
                virtual String deviceBackgroundColor() const;
                // </group>

                // Return the width of the GLPixelCanvas in pixels
                virtual uInt width() const;
                // Return the height of the GLPixelCanvas in pixels
                virtual uInt height() const;
                // Return the depth of the GLPixelCanvas in bits
                virtual uInt depth() const;
                // Get the pixel density (in dots per inch [dpi]) of the GLPixelCanvas
                // <note role=tip> The X server is queried. It may or may not have the
                // correct answer. </note>
                virtual void pixelDensity(Float &xdpi, Float &ydpi) const;

                // (Cacheable) Set current color (works in RGB or colormap mode)
                // <group>
                // <note role=tip> setColor(colorIndex) when called in RGB mode gets the
                // RGB values from the virtual color table. setForeground assumes the
                // value is a packed pixel. </note>
                virtual void setColor(uInt colorIndex);
                virtual void setColor(const String &colorname);
                // <note role=caution> Calling setRGBColor when in Index mode ignores
                // r, g & b and uses the current index value. </note>
                virtual void setRGBColor(float r, float g, float b);
                // </group>

                // Get color components in range 0 to 1 without actually
                // allocating the color.  This is needed to set up other
                // devices, for example PgPlot.
                virtual Bool getColorComponents(const String &colorname, Float &r,
                                                Float &g, Float &b);

                // (Not Cacheable) Returns the current color as a color index
                // <note> In RGB mode, this is only valid if setColor(index) has
                // been called. </note>
                virtual uInt color() const;

                // (Not Cacheable) Retuns the current color as an RGB triple
                virtual void getColor(float &r, float &g, float &b) const;

                // (Not Cacheable) Get color index value (works in RGB or colormap mode)
                // <note role=tip> Don't bother. No existing canvas implements these.
                // </note>
                // <group>
                virtual Bool getColor(Int x, Int y, uInt &color);
                // This should be removed since no one implements it.
                virtual Bool getRGBColor(Int x, Int y, float &r, float &g, float &b);
                // </group>

                // (Not Cacheable) resize request.  returns true if window was resized.
                // Will refresh if doCallbacks is True.
                virtual Bool resize(uInt reqXSize, uInt reqYSize, Bool doCallbacks = True);

                // (Not Cacheable) resize the colortable by requesting a new number of cells
                virtual Bool resizeColorTable(uInt newSize);

                // (Not Cacheable) resize the colortable by requesting a new RGB/HSV cube
                virtual Bool resizeColorTable(uInt nReds, uInt nGreens, uInt nBlues);

                // Need a mechanism to return the GLPixelCanvasColorTable so
                // drawing functions within classes can operate.
                virtual GLPixelCanvasColorTable * glpcctbl() const {
                        return glpcctbl_;
                }
                // Return the pixel canvas color table
                PixelCanvasColorTable * pcctbl() const {
                        return glpcctbl_;
                }

                void setPcctbl(PixelCanvasColorTable * pcctbl) {
                        glpcctbl_ = (GLPixelCanvasColorTable *) pcctbl;
                }

                // save/restore the current translation.  This is called pushMatrix because
                // eventually we may want scaling or rotation to play a modest
                // role here.
                // <note role=tip> GLPixelCanvas uses OpenGL's push/pop matrix. </note>
                // <group>
                virtual void pushMatrix();
                virtual void popMatrix();
                // </group>
                // zero the current translation
                virtual void loadIdentity();

                // translation functions
                // translate applies a relative translation to the current matrix and
                // can be used to position graphics.  Together with pushMatrix and
                // popMatrix it can be used to build heirarchical scenes.
                // <group>
                virtual void translate(Int xt, Int yt);
                // <note role=tip> get/x/yTranslation are not currently implemented. </note>
                virtual void getTranslation(Int &xt, Int &yt) const;
                virtual Int xTranslation() const;
                virtual Int yTranslation() const;
                // </group>

                // (Not cacheable) set the draw buffer
                // <note role=caution> The draw buffer is always set to BACK if double
                // buffered and FRONT if single buffered. </note>
                virtual void setDrawBuffer(Display::DrawBuffer buf);
                // buffer memory exchanges
                // (Not cacheable)
                // <group>
                // <note role=caution> Of this group, only swapbuffers() works. </note>
                static void copyBuffer(GLenum from, GLenum to,
                                       GLint x, GLint y,
                                       GLsizei width, GLsizei height);
                void copyBuffer(GLenum from, GLenum to);
                virtual void copyBackBufferToFrontBuffer();
                virtual void copyFrontBufferToBackBuffer();
                virtual void swapBuffers();
                // </group>

                // partial buffer memory exchanges.  (x1,y1 are blc, x2,y2 are trc)
                // None of these are implemented.
                // <group>
                virtual void copyBackBufferToFrontBuffer(Int x1, Int y1, Int x2, Int y2);
                virtual void copyFrontBufferToBackBuffer(Int x1, Int y1, Int x2, Int y2);
                virtual void swapBuffers(Int x1, Int y1, Int x2, Int y2);
                // </group>

                // return True if refresh is allowed right now...
                virtual Bool refreshAllowed() const;

                // Make this canvas's context current.
                // <note role=caution> This must be called when switching between
                // GLPixelCanvases or else drawing will go to the wrong canvas. It is
                // not needed unless more than one GLPixelCanvas is active at a time.
                // </note>
                void makeCurrent();
                // Wait for X or GL commands to finish. Usually not needed.
                // <group>
                void waitX();
                void waitGL();
                // </group>
                // Print any GL error messages.
                // if msg is non NULL, it is printed first if there is an error.
                // nspaces is the number of spaces to indent the text.
                // Returns the number of errors. Usually only used internally.
                // <group>
                int glcheck(const char *msg=NULL, uInt nspaces=0);
                static int glCheck(const char *msg=NULL, uInt nspaces=0);
                // </group>

                // Various ways to draw images. Used internally.
                // <group>
                void drawTexturedImage(GLfloat x, GLfloat y, GLfloat z,
                                       GLsizei width, GLsizei height,
                                       GLfloat xscale, GLfloat yscale,
                                       GLenum format, const GLushort *pixels,
                                       GLPCTextureParams *params = NULL);

                void drawImagePixels( GLfloat x, GLfloat y, GLfloat z,
                                      GLsizei width, GLsizei height,
                                      GLfloat xscale, GLfloat yscale,
                                      GLenum format, const GLushort *pixels);

                static void drawPixels(GLfloat x, GLfloat y, GLfloat z,
                                       GLsizei width, GLsizei height,
                                       GLfloat xscale, GLfloat yscale,
                                       GLenum format, GLenum type,
                                       const GLvoid *pixels);

                // Calls drawImagePixels if in indexed mode or drawTexturedImage if RGB.
                void drawGLImage(GLfloat x, GLfloat y, GLfloat z,
                                 GLsizei width, GLsizei height,
                                 GLfloat xscale, GLfloat yscale,
                                 GLenum format, const GLushort *pixels);
// </group>

                void bufferZValue(const Float z=0.0) {
                        itsComponentZ_ = z;
                }

                // Tracing support. May be useful when debugging graphics code.
                // <group>
                // Turn tracing on/off.
                void trace(Boolean trace) {
                        trace_ = trace;
                }
                Boolean tracing()const {
                        return trace_;
                }
                // Set trace level. (actually a mask). default is GLTraceNormal.
                // NOT fully implemented.
                void traceLevel(const uLong traceLevel) {
                        traceLevel_ = traceLevel;
                }
                uLong traceLevel()const {
                        return traceLevel_;
                }
                void postToStream(Bool p=False) {
                        log_.postToStream(p);
                }
                void postToString(String *s=NULL) {
                        log_.postToString(s);
                }
                void postString() {
                        log_.postString();
                }
                // Add a note entry to traced output.
                void note(const char *note);
                // </group>

                // Normally GLPixelCanvas repaints the window when it is damaged. If
                // the user wishes to handle this, turn off auto refreshing.
                // <group>
                Boolean autoRefresh()const {
                        return autoRefresh_;
                }
                void autoRefresh(Boolean refresh) {
                        autoRefresh_ = refresh;
                }
                // </group>

                // OpenGL's push/popAttrib functions
                void pushAttrib(const GLbitfield attrib);
                void popAttrib();
                Boolean doubleBuffered()const {
                        return doubleBuffered_;
                }
                Boolean isRGB()const {
                        return isRGB_;
                }
        protected:

        private:
                // Handle the X expose event.  This is caught by the pixel canvas
                // and forwarded as a refresh event only if the pixel canvas changed
                // dimensions.  If there was no size change, the pixel canvas simply
                // copies its pixmap to the display without generating a refresh.
                void exposeHandler();

                // Called when window is resized.
                void resizeHandler();
                // Event Handling
                // <group>
                static void handleEventsCB(Widget w, GLPixelCanvas * xpc,
                                           XEvent * ev, Boolean *);
                void handleEvents(Widget w, XEvent * ev);
                Boolean handleResizeEvent(uInt w, uInt h);
                // handle colorTable resize
                static void colorTableResizeCB(PixelCanvasColorTable * pcctbl, uInt,
                                               GLPixelCanvas * xpc,
                                               Display::RefreshReason reason);

                // </group>

        private:
                void initComponents();

                // Internal handling of display lists.
                // There is a list of GLPCDisplayLists. Item 0 always exists and is used
                // to redraw the window after expose events. Any other entries are
                // created in response to newList() calls.
                // <group>
                // Return a pointer to a new GLPC display list.
                GLPCDisplayList *createList(const char *name=NULL);
                // Create a new display list and add to the list of lists.
                uInt makeList(const char *name=NULL);
                // Grow the list.
                void resizeList();
                // Go through the list of display lists removing any unused lists.
                void cleanLists();
                // Called when the window is resized or cleared. Deletes the repaint
                // list.
                void purgeLists();
                // Remove a display list from list of lists. Returns True if list
                // was removed. False if listid is invalid or list has already been removed.
                Boolean removeList(uInt listid);
                // Called to begin caching.
                void beginListEntry(const char *name=NULL);
                void beginListEntry(GLPCDisplayListElement *e);
                // Called to end caching.
                void endListEntry();
                // </group>

                // Print <name> if tracing is turned on.
                // Most user callable drawing routines call this.
                // <group>
                void traceCheck(const char *name, uLong traceLevel, uInt nspaces);
                void traceCheck(const char *name, uLong traceLevel) {
                        traceCheck(name, traceLevel, nspaces_);
                }
                // </group>
                // Holds both a color index and RGBA values.
                class GLPCColorValue {
                public:
                        GLPCColorValue() {
                                index=0;
                                red=green=blue=0.0;
                                alpha=1.0;
                        }
                        uLong index;    // Index for PseudoColor, packed for RGB.
                        Float red, green, blue, alpha;
                };
                // Store the new value in the struct.
                //  If RGB mode, index is interpreted as a packed RGB value.
                void storeColorValue(GLPCColorValue &v, uLong value);
                //  If RGB mode, index is interpreted as an index into the virtual CT.
                void storeColorIndex(GLPCColorValue &v, uInt index);
                void storeColorValue(GLPCColorValue &v, Float r, Float g, Float b);
                void storeColorValue(GLPCColorValue &v,
                                     Float r, Float g, Float b, Float a);
                // index is always treated as an index. (In RGB mode, the virtual
                // color table is used.
                void setCurrentColorIndex(uInt index, const char *name=NULL);
                void setCurrentColorValue(uLong value, const char *name=NULL);
                void setCurrentColorValue(Float r, Float g, Float b,
                                          const char *name=NULL);
                void setCurrentColorValue(Float r, Float g, Float b, Float a,
                                          const char *name=NULL);
                void setCurrentColorValue(const GLPCColorValue &v, const char *name=NULL);

                void setClearColorIndex(uInt index, const char *name=NULL);
                void setClearColorValue(uLong index, const char *name=NULL);
                void setClearColorValue(Float r, Float g, Float b,
                                        const char *name=NULL);
                void setClearColorValue(Float r, Float g, Float b, Float a,
                                        const char *name=NULL);
                // Tell OpenGL to use the given color index or RGB value depending
                // on whether we're in Index or RGB mode. If name is not NULL,
                // wrap the call in the usual begin/endListEntry, tracecheck.
                void setClearColorValue(const GLPCColorValue &v, const char *name=NULL);

                // Internal versions of public functions
                void drawColoredPoints_(const char *Name, const Vector<Int> &x1,
                                        const Vector<Int> &y1,
                                        const Vector<uInt> &colors);
                void drawColoredPoints_(const char *Name, const Vector<Float> &x1,
                                        const Vector<Float> &y1,
                                        const Vector<uInt> &colors);
                void drawColoredPoints_(const char *Name, const Vector<Double> &x1,
                                        const Vector<Double> &y1,
                                        const Vector<uInt> &colors);
                void pRWbuf(const char *str=NULL, int nspaces=0);
                // Routines to print warnings.
                void warn(const char *routine, const char *msg,
                          const SourceLocation *where)const;
                void unimplemented(const char *routine, const SourceLocation *where)const;

        private:
                ::XDisplay      *display_;
                Widget  parent_;
                Widget  form_;
                Widget  drawArea_;
                XVisualInfo     *visualInfo_;
                Visual  *visual_;
                uInt            BlackPixel_;
                //  GL information.
                Bool            doubleBuffered_;
                Bool            isRGB_;                 // If not, it's indexed.
                //
                GLPixelCanvasColorTable *glpcctbl_;
                GLXContext      context_;
                GLbitfield      bufferMask_;
                uInt            width_;
                uInt            height_;
                uInt            depth_;
                Boolean doClipping_;
                Int             clipX1_, clipY1_;
                Int             clipX2_, clipY2_;
                String  itsDeviceForegroundColor_, itsDeviceBackgroundColor_;
                GLPCColorValue currentColor_;
                // Clear color.
                GLPCColorValue clearColor_;

                Display::LineStyle      lineStyle_;  // Store style types
                Display::FillStyle      fillStyle_;  // for 'get's.
                Boolean exposeHandlerFirstTime_;
                // Component / multi-channel buffers etc.
                uShort  *itsComponents_;                // Length = 3*width*height.
                Float           itsComponentX_, itsComponentY_, itsComponentZ_;
                Float           itsComponentScaleX_, itsComponentScaleY_;
                uLong           itsComponentWidth_, itsComponentHeight_;
                // Display lists.
                uInt            listSize_;
                uInt            numinuse_;
                uInt            nextfree_;
                uInt            sizeincr_;
                uInt            currentListID_;                 // Current display list id.
                GLPCDisplayList **dlists_;                      // List of display lists.
                GLPCDisplayListElement *currentElement_;        // Current caching element.

                Boolean trace_;         // Print tracing info?
                uLong           traceLevel_;
                uInt            nspaces_;       // # of spaces to indent trace printout.
                mutable GLLogIO log_;
                Boolean autoRefresh_;
        };


} //# NAMESPACE CASA - END

#endif