QtPixelCanvas.qo.h

Go to the documentation of this file.

//# QtPixelCanvas.qo.h: (barebones) Qt implementation of PixelCanvas
//# Copyright (C) 2005
//# 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 QTPIXELCANVAS_H
#define QTPIXELCANVAS_H

#include <casa/aips.h>
#include <casa/Arrays/Matrix.h>
#include <display/Display/DisplayEnums.h>
#include <display/Display/PixelCanvas.h>
//#include <display/DisplayEvents/PCMotionEH.h>
#include <casa/BasicMath/Math.h>
#include <display/QtViewer/QtPCColorTable.h>
//#include "PCEventDispatcher.h"
#include <list>

#include <graphics/X11/X_enter.h>
#  include <QWidget>
#  include <QPainter>
#  include <QPixmap>
#  include <QPicture>
#  include <QImage>
#  include <QPen>
#include <graphics/X11/X_exit.h>


namespace casa {

class q_draw;

class QtPixelCanvas : public QWidget, public PixelCanvas {

 //# (Note: derivation from QWidget must be first above, for Qt's
 //# 'meta-object compiler' to correctly process the following macro).

  Q_OBJECT      //# Allows slot/signal definition.  Must only occur in
                //# implement/.../*.h files; also, makefile must include
                //# name of this file in 'mocs' section.

 public:

//# RELEVANT (OR ALREADY-IMPLEMENTED) METHODS
  
  
  QtPixelCanvas(QWidget *parent=0);
  ~QtPixelCanvas();

  void beginLabelAndAxisCaching( ) { cache_label_and_axis = True; }
  void endLabelAndAxisCaching( QPainter &qp );
 
 protected:

  std::list<q_draw*> label_and_axis_cache;

  // QT EVENT HANDLERS -- these create PixelCanvas events.
  // <group>
  void paintEvent(QPaintEvent* e);
  void resizeEvent(QResizeEvent* e);
  void mouseMoveEvent(QMouseEvent* e);
  void mousePressEvent(QMouseEvent* e);
  void mouseReleaseEvent(QMouseEvent* e);
  void keyPressEvent(QKeyEvent* e ); 
  void enterEvent( QEvent* e );
  // </group>
  
  Bool cache_label_and_axis;
  
 public:

  //# OTHER QWIDGET DERIVED METHODS.
  
  // Returns a reasonable suggestion for canvas size; it will
  // be used initially unless overridden by a resize/setGeometry
  // call, on this widget or a parent.
  virtual QSize sizeHint() const { return QSize(400, 300);  }

  
  
  
  //#     PIXELCANVAS METHODS 
   
 
  //#     Refresh Cycle Methods -- not to be called by
  //#     refresh / drawing handlers (rather the reverse).
  //#     Not cacheable.
    
  
  virtual void refresh(const Display::RefreshReason &reason = 
                       Display::UserCommand,
                       const Bool &explicitrequest = True);

  static void colorTableResizeCB(PixelCanvasColorTable *, uInt,
                          QtPixelCanvas * qtpc,
                          Display::RefreshReason reason);

  
  // set the draw buffer
  // Only 'FrontBuffer' and 'BackBuffer' are supported; This value
  // will be 'Display::BackBuffer', unless explicitly set to 
  // 'Display::FrontBuffer'.
  virtual void setDrawBuffer(Display::DrawBuffer buf) {
    if(buf==Display::FrontBuffer) setDrawBuffer_(buf);
    else setDrawBuffer_(Display::BackBuffer);
    p_begin_();  }      // Refocus painter on new buffer if necessary.
  

 // buffer memory exchanges
  // <group>
  virtual void copyBackBufferToFrontBuffer();
  virtual void copyFrontBufferToBackBuffer();
  virtual void swapBuffers();
  // </group>

  // partial buffer memory exchanges.  (x1,y1 are blc, x2,y2 are trc)
  // <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>
  
  

    
  //#    Drawing Methods.  (Buffer and draw mode should already be set.
  //#    QPainter p_ should (and will) be open on current paint device).
  //#    cacheable.

    
  // Clear the window using the background color
  // <group>
  virtual void clear();
  virtual void clear(Int x1, Int y1, Int x2, Int y2);
  // </group>

  // Draw an array of 2D color data as a raster image
  //#dk note:   Color data Arrays passed to draw*()
  //#           are produced by maptoColor[3] (see below).
  virtual void drawImage(const Matrix<uInt> &data, Int x, Int y);
  
  // The version used with masks.
  //# (the one with the gratuitously transposed arguments...)
  // Set opaqueMask to True to draw masked pixels in the background color;
  // otherwise they will be transparent, letting whatever was drawn
  // previously at that point show through.
  virtual void drawImage(const Int &x, const Int &y, 
                         const Matrix<uInt> &data,
                         const Matrix<Bool> &mask,
                         Bool opaqueMask=False) ;


  virtual void drawLines(const Matrix<Float> &verts);
  
  virtual void drawRectangle(Int x1, Int y1,  Int x2, Int y2);
  
  virtual void drawFilledRectangle(Int x1, Int y1,  Int x2, Int y2);
  
  virtual void drawPolygon(const Vector<Float> &x, 
                           const Vector<Float> &y);
  
  virtual void drawFilledPolygon(const Vector<Float> &x, 
                                 const Vector<Float> &y);

  
//# (This routine was cut in favor of the PixelCanvas one, mainly
//# because Qt's method of implementing stretch (transformation QMatrix)
//# affects drawing line widths as well, which is not what was wanted
//# in the case of beam ellipses.  dk  6/07).
//#
//#   // Draw a single ellipse using the current pen (ie. color,
//#   // thickness, style).  The x and y location must be given, along
//#   // with the semi-major and -minor axis lengths, and the position
//#   // angle measured in degrees positive from the x axis in a
//#   // counter-clockwise direction. If outline is False, the
//#   // ellipse is solid filled, else it is just outlined.
//#   // xstretch, ystretch should be left defaulted to 1 in most cases; 
//#   // see usage example in WorldCanvas::drawBeamEllipse(), where they are
//#   // used to stretch a beam ellipse when the display is also linearly
//#   // stretched away from the aspect ratio natural to the sky projection.
//#   // They multiply the relative x and y screen coordinates of ellipse
//#   // points, _before_ they are added to cx and cy.  xstretch, ystretch
//#   // can be negative (though smajor, sminor normally would not be).
//#   virtual void drawEllipse(const Float &cx, const Float &cy,
//#                        const Float &smajor, const Float &sminor,
//#                        const Float &pangle, Bool outline = True,
//#                        Float xstretch = 1.0, Float ystretch = 1.0);


  
  

  
  //# (...That's it?... all that's really used??   (!!))

    
  //#dk Note: mapToColor[3] are implemented in the base class; they just
  //#   pass the chore to [Qt]PCCT.  The ones actually used are:
  //#
  //#  virtual void mapToColor(const Colormap * map, 
  //#                     Array<uInt> & outArray, 
  //#                     const Array<uInt> & inArray, 
  //#                     Bool rangeCheck = True) const;
  //#
  //#  
  //#   [and, when/if non-Index (3-channel)  ColorModels
  //#   are implemented for QtPixelCanvas]:
  //#  
  //#  virtual void mapToColor3(Array<uLong> & out,
  //#                      const Array<uInt> & chan1in,
  //#                      const Array<uInt> & chan2in,
  //#                      const Array<uInt> & chan3in) {  }
  //#
  //#   The color data output matrix is passed to drawImage, above


  
  
  
    
  //#    Graphics Context Methods
   
   
  // 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>

  virtual void setColor(const String &colorname);
  virtual void setRGBColor(float r, float g, float b);

  // Set/enable/disable clip window.  'ClipWindow' is the only
  // Display::Option supported at present.  Clip window must be
  // enabled as well as set, to operate.
  // <group>
  virtual void setClipWindow(Int x1, Int y1, Int x2, Int y2);
  virtual Bool enable(Display::Option option);
  virtual Bool disable(Display::Option option);
  // </group>

  
    
  //#    Informational Methods
  
  
  // Return the width of the PixelCanvas in pixels
  virtual uInt width() const{ return uInt(QWidget::width());  }
  
  // Return the height of the PixelCanvas in pixels
  virtual uInt height() const { return uInt(QWidget::height());  }
  
  // Return the depth of the PixelCanvas in bits
  virtual uInt depth() const { return itspcctbl->depth();  }
  
  // Return the pixel density (in dots per inch [dpi]) of the PixelCanvas
  virtual void pixelDensity(Float &xdpi, Float &ydpi) const;

  
  // 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);

  // return the PixelCanvasColorTable
  virtual PixelCanvasColorTable * pcctbl() const {
    return itspcctbl;  };

  
  
  // drawlist caching
  //# (uses QPictures)
  
  // <group>
  virtual Bool supportsLists();
  virtual uInt newList();
  virtual void endList();
  virtual void drawList(uInt list);
  virtual void deleteList(uInt list);
  virtual void deleteLists();
  virtual Bool validList(uInt list);
  // </group>


  


  //# METHODS OF QTPIXELCANVAS AND DERIVATIONS ONLY -- NOT GENERIC PIXELCANVAS
  
  // Return a QPixmap* with a copy of current widget contents.
  // Caller is responsible for deleting.
  virtual QPixmap* contents() { return new QPixmap(*frontBuffer_);  }
  virtual QPixmap* getBackBuffer() {return backBuffer_;  }

  
  /*//#dk 
  //# Hold and release of refresh.  Counted; releaseAll() to release them all.
  //# Note: NOT REALLY IMPLEMENTED yet (holdcount_ test disabled) -- check
  //# interaction with (new) allowBackToFront_ first.
  // <group>
  virtual void hold() { holdcount_++;  }
  
  virtual void release() { 
    holdcount_ = (holdcount_>0)? holdcount_-1 : 0;
    if(holdcount_==0 && needsRefresh_) {
      refresh();
      needsRefresh_ = False;  }
      
  virtual void releaseAll() { holdcount_=0; release();  }
  // </group>
  //*/
 
  
  
  // Hold / release of display widget/pixmap painting (used during
  // printing and graphics file saving.)  Be sure to return to unblocked
  // state when done.
  // <group>
  virtual void setAllowBackToFront(Bool allowed=True) {
    allowBackToFront_ = allowed;  }

  virtual void setUpdateAllowed(Bool allowed=True) {
    if(allowed) {
      if(saveBuf_!=0) { delete saveBuf_; saveBuf_ = 0;  }  }
    else if(saveBuf_==0) saveBuf_ = contents();  }
  // </group>



 signals: 
  
  // Emitted in resizeEvent().
  void resizing(QResizeEvent* ev);
     
 
 
 private:
   
  // Versions of p_.begin(currentPaintDevice_()) and p_.end() ,that just
  // put p_ in desired state, without complaining if it was already there.
  // (In general, p_ will be active (on the current PaintDevice) between
  // calls to QtPixelCanvas methods...).
  // (A certain amount of painter 'state' ('graphics context') is
  // also preserved over p_end_ -- p_begin_ -- still determining this).
  // <group>
  void p_end_();
  void p_begin_();
  // </group>

  
  // PixelCanvas coordinate (0,0) is the bottom-left corner;
  // in Qt it is the top-left.  This translates the y coordinate.
  // (converts either way).
  Int    q_(Int pY)    { return QWidget::height()-1 - pY;  }
  Float  q_(Float pY)  { return QWidget::height()-1 - pY;  }
  Double q_(Double pY) { return QWidget::height()-1 - pY;  }

  // Translates PC rectangle pixel coords x1,y1,x2,y2 to Qt coords qx,qy,qw,qh
  void qFromPC_(Int  x1, Int  y1,   Int x2,  Int y2,
                Int& qx, Int& qy,   Int& qw, Int& qh) {
    qw = abs(x2-x1)+1;  qh = abs(y2-y1)+1;
    qx = min(x1,x2);    qy = q_(max(y1,y2));  }
  
  // returns QRect from PC rectangle (corner) pixel coordinates.
  QRect qrect_(Int x1, Int y1, Int x2, Int y2) {
    Int qx,qy,qw,qh;
    qFromPC_(x1,y1,x2,y2, qx,qy,qw,qh);
    return QRect(qx,qy,qw,qh);  }

      
  // translate color component in the range [0., 1.]
  // to clrByte, with 0 <= clrByte < 256
  Int clrByte_(Float f) { return Int(min( max(0.f,f)*256.f, 255.f ));  }

  Bool inDrawMode_() { return (drawMode()!=Display::Compile);  }
  
  QPixmap* currentBuffer_() {
    return (drawBuffer() == Display::FrontBuffer)?
                       frontBuffer_ : backBuffer_;  }
  
  void clearBuffer_() { p_.eraseRect(0,0, currentBuffer_()->width(),
                                          currentBuffer_()->height());  }
  
  QPaintDevice* currentPaintDevice_() {
    if(inDrawMode_()) return currentBuffer_();
    else              return drawList_;  }
    
  
  
  // Translate Qt KeyboardModifiers and MouseButtons to 
  // mask of Display Library KeyModifiers.
  // <group>
  uInt dlKeyMods_(Qt::KeyboardModifiers);
  uInt dlKeyMods_(QMouseEvent* e);
 // </group>

  
  
   
  //#     Data / State

    
  QPixmap* frontBuffer_;        // The actual buffers.  (Qt4's elimination
  QPixmap* backBuffer_;         // of resize() requires these to replaced
                                // often on the heap...).
  
  
  QPainter p_;          // This Painter is used for the drawing commands, and
                        // paints either to the Buffer Pixmaps ('Draw' mode)
                        // or to a drawlist QPicture ('Compile' DrawMode).
                        // It will remain open (painting 'begun', active) on
                        // the currentPaintDevice_() between PC method calls.
  
  QPainter pw_;         // This painter is used only to copy the front buffer
                        // to the widget during paintEvents.

  
  QPicture* drawList_;          // Will point to drawlist currently
                                // under construction, in Compile mode.
  uInt drawListNo_;             // Number of drawlist currently being compiled.
 
  SimpleOrderedMap<uInt, void*> drawlists_;
                                // cache of all current draw lists.  
  
  
  
  String itsDeviceForegroundColor, itsDeviceBackgroundColor;
  
  //# 'painter state' or 'graphics context'
  
  QPen itsPen;
  
  QFont itsFont;
  
  QRect clipRect_;
  Bool clipEnabled_;
  
  QtPCColorTable* itspcctbl;
  
  
  
  //# Hold/release of refresh.  (Note: not yet used)
  //<group>
  Int holdcount_;
  Bool needsRefresh_;
  //</group>
  

  // other hold / release of widget/pixmap painting (used during
  // printing / graphics file saving.)
  //<group>
  bool allowBackToFront_;
  QPixmap* saveBuf_;
        //# If non-zero, saveBuf_ holds a 'frozen' state for painting the
        //# PC's widget when the rendering on frontBuffer_ is being used
        //# for another purpose (notably, when a .jpg, etc. of the PC is
        //# being saved at a  larger scale.  (It isn't effective for smaller
        //# scales; probably wasn't worth the effort, but it's there now....))
  //<group>
  
  
  
 
//############################################################################
//############################################################################
//############################################################################
//############################################################################
//################   End of the Useful Stuff   ###############################
//############################################################################
//############################################################################
//############################################################################
//############################################################################





//#       POSSIBLY USEFUL TO IMPLEMENT IN THE FUTURE
   
 
 public:
  
  
  
//# (for 3-channel drawing)
  
  // return the colorModel
  Display::ColorModel colorModel() const { return Display::Index;  }

  // (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*/) {  }


  
  
  // Set the input color model for multichannel color
  void setColorModel(Display::ColorModel colorModel);

  // 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() {  }





  
//#        RELEVANCE TO BE DETERMINED

  
  
  // return True if the refresh is active.
  //#dk PC probably can't determine this usefully, since individual
  //#   WCs may initiate their own refresh/drawing cycles....
  Bool refreshActive() const;

  // return True if refresh is allowed right now...
  virtual Bool refreshAllowed() const;
 
  // 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*/) {
     // cout << "WYSISWYN " << __FILE__ << " " << __LINE__ << endl;
  }
  virtual void drawColoredPoints(const Matrix<Int> &xy,
                                 const Vector<uInt> &colors) {
    drawColoredPoints(xy.column(0), xy.column(1), colors); }
  // </group>

  // Cause display to flush any graphics commands not yet drawn
  virtual void flush();
  
  static void drawText(QPainter& painter, const QPoint& p, const QFont& font,
           const QPen& pen, const String& text, double angle,
           Display::TextAlign alignment);
  virtual void drawText(Int x, Int y, const String &text, const Float& angle,
               Display::TextAlign alignment = Display::AlignCenter);
  virtual void drawText(Int x, Int y, const String &text, 
               Display::TextAlign alignment = Display::AlignCenter);
  
  virtual Int textWidth(const String& text);
  
  virtual Int textHeight(const String& text);
  
  virtual void setHSVColor(float /*h*/, float /*s*/, float /*v*/) {  }
 

  // (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 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);
  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 drawPoints(const Vector<Double> &x1, 
                          const Vector<Double> &y1);
  // </group>

  // (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 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<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 points given
  // <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 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>

  // Let PixelCanvas::drawMarker take care of this.
  /*
  // Draw a "marker". See <linkto class="Display">Display</linkto> 
  // for a list of available markers.
  // <group>

   virtual void drawMarker(const Int& x1, const Int& y1,
                          const Display::Marker& marker, 
                          const Int& pixelHeight);
  virtual void drawMarker(const Float& x1, const Float& y1,
                          const Display::Marker& marker, 
                          const Int& pixelHeight);
  virtual void drawMarker(const Double& x1, const Double& y1,
                          const Display::Marker& marker, 
                          const Int& pixelHeight);
  
  // </group>
  */
      
  // (Cacheable) Draw a closed polygon
  // <group>
  virtual void drawPolygon(const Vector<Int> &x1, 
                           const Vector<Int> &y1);
  virtual void drawPolygon(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 drawPolygon(const Matrix<Double> &verts);
  // </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<Double> &x1, 
                                 const Vector<Double> &y1);
  // </group>

  // (Cacheable) Draw a rectangle
  // <group>
  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(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 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>

  // vector primitive buffering
  
  // Set Graphics Attributes
  // Options for functions with enum argument
  // listed in <linkto class=Display>DisplayEnums</linkto>
  // <group>
  virtual void setDrawFunction(Display::DrawFunction function);
  virtual void setForeground(uLong color);
  virtual void setBackground(uLong color);
  virtual void setLineWidth(Float width);
  virtual void setLineStyle(Display::LineStyle style);
  virtual void setCapStyle(Display::CapStyle style);
  virtual void setJoinStyle(Display::JoinStyle style);
  virtual void setFillStyle(Display::FillStyle style);
  virtual void setFillRule(Display::FillRule rule);
  virtual void setArcMode(Display::ArcMode mode);
  // </group>
  
  // This method is NOT in PixelCanvas.
  virtual void setQtLineStyle(Qt::PenStyle style);

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


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

  // (Cacheable) Set the color to use for clearing the display
  // <group>
  
  //#dk probably unneeded -- can clear using deviceBkgd(?)
  //#  (what _else_ is deviceBkgd for?...)
  virtual void setClearColor(uInt colorIndex);
  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;

  virtual void enableMotionEvents() {  }
  virtual void disableMotionEvents() {  }
  virtual void enablePositionEvents() {  }
  virtual void disablePositionEvents() {  }
  
  virtual void translateAllLists(Int /*xt*/, Int /*yt*/) {  }
  virtual void translateList(uInt /*list*/, Int /*xt*/, Int /*yt*/) {  }
  
  virtual Bool setFont(const String &fontName);
  virtual Bool setFont(DLFont* /*font*/) { return False; }
  virtual Bool setFont(const String& fontName, const Int fontSize);
  
  // These setFont methods are NOT in PixelCanvas.
  // <group>
  virtual Bool setFont(const String& fontName, bool bold, bool italic);
  virtual Bool setFont(const String& fontName, const Int fontSize, bool bold,
                       bool italic);
  // </group>
  
  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*/) {  }
  
  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*/) {  }


  // (Cacheable) Set current color (works in RGB or colormap mode)
  // <group>
  virtual void setColor(uInt colorIndex);
  // </group>

  // (Not Cacheable) Returns the current color as a color index
  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)
  // <group>
  virtual Bool getColor(Int x, Int y, uInt &color);
  virtual Bool getRGBColor(Int x, Int y, 
                                 float &r, float &g, float &b);
  virtual Bool getHSVColor(Int x, Int y, 
                                 float &h, float &s, float &v);
  // </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);
  
  // save/restore the current translation.  This is called pushMatrix because
  // eventually we may want scaling or rotation to play a modest
  // role here.
  // <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*/) {  }
  virtual void getTranslation(Int &/*xt*/, Int &/*yt*/) const {  }
  virtual Int xTranslation() const { return 0;  }
  virtual Int yTranslation() const { return 0;  }
  // </group>




//#         CONFIRMED IRRELEVANT / UNUSED

  
    
  virtual void drawColoredEllipses(const Matrix<Float> &/*centres*/,
        const Vector<Float> &/*smajor*/, const Vector<Float> &/*sminor*/,
        const Vector<Float> &/*pangle*/, const Vector<uInt> &/*colors*/,
        const Float &/*scale*/ = 1.0, const Bool &/*outline*/ = True) {  }
  
  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<Float> &xy,
                                 const Vector<uInt> &colors) {
    drawColoredPoints(xy.column(0), xy.column(1), colors);  }
  virtual void drawColoredPoints(const Matrix<Double> &xy,
                                 const Vector<uInt> &colors) {
    drawColoredPoints(xy.column(0), xy.column(1), colors);  }
  
  
  virtual void getClipWindow(Int &/*x1*/, Int &/*y1*/, Int &/*x2*/, Int &/*y2*/) {  }
  
  virtual void setPcctbl(PixelCanvasColorTable * /*pcctbl*/) {  }

};      // class QtPixelCanvas

}       // namespace casa

#endif