// This may look like C code, but it's really -*- C++ -*-
/*
 * Copyright (C) 2008 Emweb bvba, Kessel-Lo, Belgium.
 *
 * See the LICENSE file for terms of use.
 */
#ifndef WVML_IMAGE_H_
#define WVML_IMAGE_H_

#include <Wt/WBrush>
#include <Wt/WPen>
#include <Wt/WRectF>
#include <Wt/WShadow>
#include <Wt/WTransform>
#include <Wt/WVectorImage>
#include <Wt/WResource>

#include <sstream>

namespace Wt {

class WColor;

/*! \class WVmlImage Wt/WVmlImage Wt/WVmlImage
 *  \brief A paint device for rendering using the VML pseudo-standard.
 *
 * The %WVmlImage is used by WPaintedWidget to render to the browser
 * using the Vector Markup Language (VML) (to support graphics on
 * Internet Explorer browsers).
 *
 * \note The current implementation has only limited support for
 * clipping: only rectangular areas aligned with the X/Y axes can be used
 * as clipping path.
 *
 * \ingroup painting
 */
class WT_API WVmlImage : public WVectorImage
{
public:
  /*! \brief Create a VML paint device.
   *
   * If \p paintUpdate is \c true, then only a VML fragment will be
   * rendered that can be used to update the DOM of an existing VML
   * image, instead of a full VML image.
   */
  WVmlImage(const WLength& width, const WLength& height, bool paintUpdate);

  virtual WFlags<FeatureFlag> features() const;
  virtual void setChanged(WFlags<ChangeFlag> flags);
  virtual void drawArc(const WRectF& rect, double startAngle, double spanAngle);
  virtual void drawImage(const WRectF& rect, const std::string& imgUri,
			 int imgWidth, int imgHeight, const WRectF& sourceRect);
  virtual void drawLine(double x1, double y1, double x2, double y2);
  virtual void drawPath(const WPainterPath& path);
  virtual void drawText(const WRectF& rect, 
			WFlags<AlignmentFlag> alignmentFlags,
			TextFlag textFlag,
			const WString& text);
  virtual WTextItem measureText(const WString& text, double maxWidth = -1,
				bool wordWrap = false);
  virtual WFontMetrics fontMetrics();
  virtual void init();
  virtual void done();
  virtual bool paintActive() const { return painter_ != 0; }

  virtual std::string rendered();

  virtual WLength width() const { return width_; }
  virtual WLength height() const { return height_; }

protected:
  virtual WPainter *painter() const { return painter_; }
  virtual void setPainter(WPainter *painter) { painter_ = painter; }

private:
  WLength    width_, height_;
  WPainter  *painter_;
  bool       paintUpdate_;

  bool       penBrushShadowChanged_;
  bool       clippingChanged_;

  WBrush     currentBrush_;
  WPen       currentPen_;
  WShadow    currentShadow_;

  struct ActivePath {
    std::string path;
    WRectF      bbox;

    ActivePath() { };
  };

  std::vector<ActivePath> activePaths_;

  std::stringstream rendered_;

  void        finishPaths();
  void        processClipping();
  std::string fillElement(const WBrush& brush) const;
  std::string strokeElement(const WPen& pen) const;
  std::string skewElement(const WTransform& transform) const;
  std::string shadowElement(const WShadow& shadow) const;
  std::string createShadowFilter() const;

  static std::string colorAttributes(const WColor& color);
  static std::string quote(double s);
  static std::string quote(const std::string& s);

  void startClip(const WRectF& rect);
  void stopClip();

  WRectF currentRect_;
};

}

#endif // WVML_IMAGE_H_
