DisplayShapeInterface.h

Go to the documentation of this file.

//# DisplayShapeInterface.h: Simple wrapper for DisplayShapes
//# Copyright (C) 1998,1999,2000,2001,2002
//# 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_DISPLAYSHAPEINTERFACE_H
#define TRIALDISPLAY_DISPLAYSHAPEINTERFACE_H


#include <casa/aips.h>

#include <display/DisplayShapes/DisplayShape.h>
#include <display/Display/PixelCanvas.h>
#include <display/Display/WorldCanvas.h>
#include <casa/Containers/Record.h>

namespace casa { //# NAMESPACE CASA - BEGIN

//class PixelCanvas;
//class WorldCanvas;

// <summary>
// Wrapper for DisplayShapes;provides easier/unified constr. of DisplayShapes
// </summary>
//
// <prerequisite>
// <li> <linkto class="DisplayShape">DisplayShape</linkto>
// </prerequisite>
//
// <etymology>
// DisplayShapeInterface makes it easier to work with DisplayShapes.
// </etymology>
//
// <synopsis>
// DisplayShapeInterface simply contains a pointer to a DisplayShape object.
// It allows all DisplayShapes to be constructed via a single constructor. i.e.
// the DisplayShapeInterface constructor actually decides which shape to
// create based on the information in the Record passed to it. It makes 
// creating new shapes look a little nice, since:
// <srcblock>
// record1.define("type", "square");
// and
// record2.define("type", "circle");
// </srcblock>
// can both be simply made into a new DisplayShapeInterface, e.g.
// <srcblock>
// DisplayShapeInterface* myShape = new DisplayShapeInterface(record1);
// or
// DisplayShapeInterface* myShape = new DisplayShapeInterface(record2);
// </srcblock>
// It also guarantees consistant interfaces between shapes.
// </synopsis>
//
// <motivation>
// The creation of an interface to DisplayShapes makes use of the simpler.
// </motivation>
//
// <example>
// </example>




class DisplayShapeInterface {

public:
  enum Coord {Pixels, Relative, World};

  // Constructor for a standard shape. The shape will be totally based on
  // pixel sizes, both for it's position and sizes.
  DisplayShapeInterface(const Record& shapeInfo);
  
  // Constructor for shape based on relative screen positions. if
  // scaled is true, relative screen positions will be used for 
  // height etc also. If not, positions only will be based on relative
  // screen pos, heights will be based on an absolute pixel value.
  DisplayShapeInterface(const Record& shapeInfo, const PixelCanvas* pc,
                        const Bool scale = True);

  // Constructor for shape based on world co-ordinates (NYI)
  DisplayShapeInterface(const Record shapeInfo, const WorldCanvas* wc);

  // Copy cons
  DisplayShapeInterface(const DisplayShapeInterface& other);

  virtual ~DisplayShapeInterface();

  
  // DisplayShape functionality. All of these functions simply wrap those
  // of the underlying DisplayShape (and add conversion functionality). 
  // Please see <linkto class="DisplayShape">DisplayShape</linkto>
  // for a full description of these functions.
  // <group>
  virtual Bool inObject(const Float xPos, const Float yPos);
  virtual Bool onHandles(const Float xPos, const Float yPos);
  virtual Vector<Float> getCenter() const;
  virtual void setCenter(const Float xPos, const Float yPos);
  virtual Bool whichHandle(const Float xPos, const Float yPos, Int& out);
  virtual void changePoint(const Vector<Float>& newPos);
  virtual void changePoint(const Vector<Float>& newPoint, const Int nPoint);
  virtual void addPoint(const Vector<Float>& newPoint);
  virtual void rotate(const Float angle);
  virtual void scale(const Float angle);
  virtual void draw(PixelCanvas* toDrawTo);
  virtual void move(const Float dX, const Float dY);
  virtual void addLocked(DisplayShapeInterface* toLock);
  virtual void removeLocked(DisplayShapeInterface* removeLock);
  virtual void setDrawHandles(const Bool& draw);
  virtual Bool setOptions(const Record& newOptions);
  virtual Record getOptions() ;
  // </group>

  // Update the pixel location of this shape, based on the stored information
  // on its location. If the shape is being used in pixel mode this will do 
  // nothing. If being used in relative screen mode or WC mode, this will
  // update its location. Returns false if a conversion to pixels fail.
  virtual Bool updatePixelPosition();

  // If the shape is being used in absolute pixel co-ordinates, this will do 
  // nothing. If being used in relative screen or WC mode, this will update
  // the position based on its current pixel location. Returns false if the
  // conversion to the other co-ord type fails. 
  virtual Bool updateNonPixelPosition();

  // Returns the pointer to the underlying object
  virtual DisplayShape* getObject();

  // If the shape is a PolyLine, this function will change it to a polygon.
  // This is designed for use in the creation of polygon by the user clicking
  // out a polyline, for example.
  virtual void toPolygon();


private:
  Record toPixOpts(const Record& notPix);

  // Will return an option set with whatever the current 
  // coords method is.
  Record fromPixOpts(const Record& pix) ;

  Record pixToRelOpts(const Record& pixel);
  Record relToPixOpts(const Record& relative);
  Record pixToWorldOpts(const Record& pix);
  Record worldToPixOpts(const Record& world);
  
  Vector<Float> pixToRel(const Vector<Float>& pix);
  Vector<Float> relToPix(const Vector<Float>& rel);
  Float relToPixWidth(const Float rel);
  Float relToPixHeight(const Float rel);
  Float pixToRelWidth(const Float pix);
  Float pixToRelHeight(const Float pix);

  DisplayShape* itsShape;
  DisplayShapeInterface::Coord itsCoords;
  const PixelCanvas* itsPc;
  const WorldCanvas* itsWc;

  void makeShape(const Record& shapeInfo);

  // Scale widths and heights in relative mode?
  Bool itsScale;

  // Copy of shape, however in its alternate coord form
  Record altCoords;
};



} //# NAMESPACE CASA - END

#endif