// Copyright (c) 2008  GeometryFactory Sarl (France).
// All rights reserved.
//
// This file is part of CGAL (www.cgal.org); you may redistribute it under
// the terms of the Q Public License version 1.0.
// See the file LICENSE.QPL distributed with CGAL.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $URL$
// $Id$
// 
//
// Author(s)     : Andreas Fabri <Andreas.Fabri@geometryfactory.com>
//                 Laurent Rineau <Laurent.Rineau@geometryfactory.com>

#ifndef CGAL_QT_PAINTER_OSTREAM_H
#define CGAL_QT_PAINTER_OSTREAM_H

#include <QPainter>
#include <QPen>
#include <QRectF>
#include <CGAL/Qt/Converter.h>

namespace CGAL {
namespace Qt {

template <typename K>
class PainterOstream {

private:
  QPainter* qp;
  Converter<K> convert;
  
public:
  PainterOstream(QPainter* p, QRectF rect = QRectF())
    : qp(p), convert(rect)
  {}

  PainterOstream& operator<<(const Point_2<K>& p)
  {
    qp->drawPoint(convert(p));
    return *this;
  }
  
  PainterOstream& operator<<(const Segment_2<K>& s)
  {
    qp->drawLine(convert(s.source()), convert(s.target()));
    return *this;
  }
  
  
  PainterOstream& operator<<(const Ray_2<K>& r)
  {
    qp->drawLine(convert(r));
    return *this;
  }

  
  PainterOstream& operator<<(const Line_2<K>& l)
  {
    qp->drawLine(convert(l));
    return *this;
  }


  PainterOstream& operator<<(const Triangle_2<K>& t)
  {
    qp->drawPolygon(convert(t));
    return *this;
  }

  PainterOstream& operator<<(const Iso_rectangle_2<K>& r)
  {
    qp->drawRect(convert(r));
    return *this;
  }

  PainterOstream& operator<<(const Circle_2<K>& c)
  {
    qp->drawEllipse(convert(c.bbox()));
    return *this;
  }

#if 0
  PainterOstream& operator<<(const Circular_arc_2<K>& arc)
  {
    const typename K::Circle_2 & circ = arc.supporting_circle();
    const typename K::Point_2 & center = circ.center();
    const typename K::Circular_arc_point_2 & source = arc.source();
    const typename K::Circular_arc_point_2 & target = arc.target();
    double radius = std::sqrt(CGAL::to_double(circ.squared_radius()));


    double a   = std::atan2( to_double(source.y() - center.y()),
		             to_double(source.x() - center.x())); 
    double a2p = std::atan2( to_double(target.y() - center.y()),
		             to_double(target.x() - center.x()));

    std::cout << "a = " << a << "  a2p = " << a2p << std::endl;
    if (a2p <= a)
        a2p += 2 * CGAL_PI;

    double alen2 = a - a2p;

    double diff = 180/CGAL_PI*16;
    
    std::cout << "start " << (int)(a * diff) << std::endl;
    std::cout << "angle " << (int)(alen2 * diff) << std::endl;
    
    //    qp->drawEllipse(convert(circ.bbox()));
    qp->drawArc(convert(circ.bbox()), 
				 (int)(a * diff), 
				 (int)(alen2 * diff));
    return *this;
  }
#endif
};

} // namespace Qt
} // namespace CGAL

#endif // CGAL_QT_PAINTER_OSTREAM_H