This file is indexed.

/usr/include/Wt/WVmlImage is in libwt-dev 3.3.0-1build1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
// 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_