kigpainter.h

Go to the documentation of this file.

#ifndef KIGPAINTER_H
#define KIGPAINTER_H

#include "coordinate.h"
#include "rect.h"
#include "screeninfo.h"

#include <qpainter.h>
#include <qcolor.h>
#include <qfont.h>

#include <vector>

class KigWidget;
class QPaintDevice;
class CoordinateSystem;
class LineData;
class CurveImp;
class KigDocument;
class ObjectHolder;

class KigPainter
//  : public Qt
{
protected:
  // don't blaim me for this mutable hack.  It's TT that hasn't got
  // its consts correctly...
  mutable QPainter mP;

  QColor color;
  Qt::PenStyle style;
  int pointstyle;
  int width;
  Qt::BrushStyle brushStyle;
  QColor brushColor;

  const KigDocument& mdoc;
  ScreenInfo msi;

  bool mNeedOverlay;
  int overlayenlarge;
  bool mSelected;
public:
  KigPainter( const ScreenInfo& r, QPaintDevice* device, const KigDocument& doc,
              bool needOverlay = true );
  ~KigPainter();

  Rect window();

  QPoint toScreen( const Coordinate& p ) const;
  QRect toScreen( const Rect& r ) const;
  QRect toScreenEnlarge( const Rect& r ) const;
  Coordinate fromScreen( const QPoint& p ) const;
  Rect fromScreen( const QRect& r ) const;

  // colors and stuff...
  void setStyle( Qt::PenStyle c );
  void setColor( const QColor& c );
  void setWidth( int c );
  void setPointStyle( int p );
  void setPen( const QPen& p );
  void setBrushStyle( Qt::BrushStyle c );
  void setBrush( const QBrush& b );
  void setBrushColor( const QColor& c );

  void setFont( const QFont& f );

  void setSelected( bool selected );

  QColor getColor() const;
  bool getNightVision( ) const;

  double pixelWidth();

  void setWholeWinOverlay();

  void drawObject( const ObjectHolder* o, bool sel );
  void drawObjects( const std::vector<ObjectHolder*>& os, bool sel );
  template<typename iter>
  void drawObjects( iter begin, iter end, bool sel )
    {
      for ( ; begin != end; ++begin )
        drawObject( *begin, sel );
    }

  void drawCurve( const CurveImp* curve );

  void drawTextStd( const QPoint& p, const QString& s );

  void drawFilledRect( const QRect& );

  void drawRect( const Rect& r );

  void drawRect( const QRect& r );

  void drawCircle( const Coordinate& center, double radius );

  void drawSegment ( const Coordinate& from, const Coordinate& to );
  void drawSegment( const LineData& d );

  void drawRay( const Coordinate& a, const Coordinate& b );
  void drawRay( const LineData& d );

  void drawLine ( const Coordinate& p1, const Coordinate& p2 );
  void drawLine( const LineData& d );

  void drawPoint( const Coordinate& p );

  void drawFatPoint( const Coordinate& p );

  void drawPolygon( const std::vector<QPoint>& pts, Qt::FillRule fillRule = Qt::OddEvenFill );
  void drawPolygon( const std::vector<Coordinate>& pts, Qt::FillRule fillRule = Qt::OddEvenFill );

  void drawArea( const std::vector<Coordinate>& pts, bool border = true );

  void drawAngle( const Coordinate& point, double startangle, double angle, int radius );
  
  void drawRightAngle( const Coordinate& point, double startangle, int diagonal );
  
  void drawArc( const Coordinate& center, double radius,
                double startangle, double angle );

  void drawVector( const Coordinate& a, const Coordinate& b );

  void drawText( const Rect& r, const QString& s, int textFlags = 0 );
  void drawText( const Coordinate& p, const QString& s, int textFlags = 0 );

  void drawSimpleText( const Coordinate& c, const QString& s );
  void drawTextFrame( const Rect& frame, const QString& s, bool needframe );

  const Rect boundingRect( const Rect& r, const QString& s, int f = 0 ) const;

  const Rect boundingRect( const Coordinate& c, const QString& s, int f = 0 ) const;

  const Rect simpleBoundingRect( const Coordinate& c, const QString& s );

  void drawGrid( const CoordinateSystem& c, bool showGrid = true, bool showAxes = true );

  const std::vector<QRect>& overlay() { return mOverlay; }

protected:
  void circleOverlay( const Coordinate& centre, double radius );
  // this works recursively...
  void circleOverlayRecurse( const Coordinate& centre, double radius, const Rect& currentRect );

  void segmentOverlay( const Coordinate& p1, const Coordinate& p2 );

  void pointOverlay( const Coordinate& p1 );

  void textOverlay( const QRect& r, const QString& s, int textFlags );

  double overlayRectSize();

  void unsetSelected();

  std::vector<QRect> mOverlay;
};

#endif