painter.h

Go to the documentation of this file.

/*
  libwt - Vassilis Virvilis Toolkit - a widget library
  Copyright (C) 2006 Vassilis Virvilis <vasvir2@fastmail.fm>
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 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
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the
  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  Boston, MA  02111-1307, SA.
*/

#ifndef WT_PAINTER_H
#define WT_PAINTER_H

#include <stack>

#include <wt/color.h>
#include <wt/font.h>
#include <wt/pixmap.h>

namespace Wt {

class Point;
class Rect;
class Region;

class Pen {
public:
    Pen() :
    color_("white") {}

    Pen(const Color& color) : color_(color) {}

    ~Pen() {}

    const Color& color() const {
        return color_;
    }
    void setColor(const Color& color) {
        color_ = color;
    }

private:
    Color color_;
    /// \todo Pen width, Style, CapStyle, JoinStyle
};

class Brush {
public:
    typedef enum {
        NoBrush,
        SolidPattern
    } Style;

    Brush()
            : style_(NoBrush), color_("black") {}

    Brush(const Color& color, Style style = SolidPattern)
            : style_(style), color_(color) {}

    ~Brush() {}

    Style style() const {
        return style_;
    }

    void setStyle(Style style) {
        style_ = style;
    }

    const Color& color() const {
        return color_;
    }

    void setColor(const Color& color) {
        color_ = color;
    }

private:
    Style style_;
    Color color_;
    /// \todo more styles, pixmap
};

/// class that allows drawing graphics primitives onto a Pixmap
class Painter {
public:
    /// constructor - binds this Painter to the \p pixmap
    Painter(const Pixmap* pixmap = 0, bool clipping = true);
    ~Painter();

    bool begin(const Pixmap* pixmap, bool clipping = true);
    bool begin();
    bool end();

    Pixmap* pixmap() const {
        return pixmap_;
    }
    bool isActive () const;

    const Font& font() const {
        return state.font;
    }

    void setFont(const Font& font) {
        state.font = font;
    }

    const Pen& pen() const {
        return state.pen;
    }

    void setPen(const Pen& pen) {
        state.pen = pen;
        state.font.setForegroundColor(pen.color());
    }

    const Brush& brush () const {
        return state.brush;
    }

    void setBrush(const Brush& brush) {
        state.brush = brush;
    }

    const Color& backgroundColor() const {
        return state.bg_color;
    }

    void setBackgroundColor(const Color& color) {
        state.bg_color = color;
        state.font.setBackgroundColor(color);
    }

    void save() {
        state_stack.push(state);
    }

    void restore() {
        assert(!state_stack.empty());
        state = state_stack.top();
        state_stack.pop();
    }

    void flush() {}

    typedef enum {
        CopyROP,    /// dst = src
        OrROP,      /// dst = src | dst
        AndROP,     /// dst = src & dst
        XorROP      /// dst = src ^ dst
    } RasterOp;

    RasterOp rasterOp() const {
        return state.raster_op;
    }

    void setRasterOp(RasterOp raster_op) {
        state.raster_op = raster_op;
    }

    void setClipping(bool enable) {
        state.clipping = enable;
    }

    bool clipping() const {
        return state.clipping;
    }

    /// \deprecated
    bool hasClipping() const {
        return clipping();
    }

    void drawPoint(int x, int y);
    void drawPoint(const Point& p);

    void drawPoints(const PointArray& points, int start = 0, int end = -1);

    void drawHorizontalLine(int x1, int x2, int y);
    void drawVerticalLine(int x, int y1, int y2);

    void drawLine(int x1, int y1, int x2, int y2);
    void drawLine(const Point& p1, const Point& p2);

    void fillRect(const Rect& r, const Brush& brush);
    void fillRect(int x, int y, int w, int h, const Brush& brush);
    void fillRegion(const Region& r, const Brush& brush);
    void blendRect(const Rect& r, const Brush& brush);
    void blendRect(int x, int y, int w, int h, const Brush& brush);
    void blendRegion(const Region& r, const Brush& brush);
    void eraseRect(const Rect& r);
    void eraseRect(int x, int y, int w, int h);
    void eraseRegion(const Region& r);
    void drawRect(int x, int y, int w, int h);
    void drawRect(const Rect& r);

    void drawLineSegments(const PointArray& points,
                          int start = 0, int end = -1);
    void drawPolyline(const PointArray& points, int start = 0, int end = -1);
    void drawPolygon(const PointArray& points, int start = 0, int end = -1);

    void drawPixmap(const Point& p, const Pixmap& src, const Rect& sr);
    void drawPixmap(const Point& p, const Pixmap& src);
    void drawPixmap(int x, int y, const Pixmap& src,
                    int sx = 0, int sy = 0, int sw = -1, int sh = -1);
    void drawPixmap(const Rect& r, const Pixmap& src);

    void drawTiledPixmap(const Rect& r,
                         const Pixmap& src, const Point& sp);
    void drawTiledPixmap(const Rect& r, const Pixmap& src);
    void drawTiledPixmap(int x, int y, int w, int h,
                         const Pixmap& src, int sx = 0, int sy = 0);
    /// \todo missing functionality: paragraphs, multi line text, text aligining (low priority)
    void drawText(int x, int y, const std::string& text, int len = -1);
    void drawText(const Point& p, const std::string& text, int len = -1);
    void drawText(int x, int y, const std::string& text, int pos, int len);
    void drawText(const Point& p, const std::string& text, int pos, int len);
    Rect boundingRect(const std::string& text, int pos = 0, int len = -1);

protected:
    bool isClipped(int x, int y) const;
    bool isClipped(const Point& p) const;

    void rop(int pixeladdr, int pixel);

private:
    bool active_;
    Pixmap* pixmap_;

    class State {
    public:
        State() :
                pen("white"),
                brush("gray80"),
                bg_color("black"),
                raster_op(CopyROP),
        clipping(true)  {}

        Pen pen;
        Brush brush;
        Color bg_color;
        RasterOp raster_op;
        bool clipping;
        Font font;
    };

    std::stack<State> state_stack;
    State state;

    /// \todo missing: ellipse
};

}

#endif // !WT_PAINTER_H

---

Generated Fri Jul 28 19:23:00 2006.
Copyright © 1998-2003 by the respective authors.

This document is licensed under the terms of the GNU Free Documentation License and may be freely distributed under the conditions given by this license.