Wt::Painter Class Reference

class that allows drawing graphics primitives onto a Pixmap More...

#include <painter.h>

Collaboration diagram for Wt::Painter:

[legend]List of all members.

Public Types
	CopyROP
	OrROP
	dst = src
	AndROP
	dst = src | dst
	XorROP
	dst = src ^ dst
enum	RasterOp { CopyROP, OrROP, AndROP, XorROP }
Public Member Functions
	Painter (const Pixmap *pixmap=0, bool clipping=true)
	constructor - binds this Painter to the pixmap
	~Painter ()
bool	begin (const Pixmap *pixmap, bool clipping=true)
bool	begin ()
bool	end ()
Pixmap *	pixmap () const
bool	isActive () const
const Font &	font () const
void	setFont (const Font &font)
const Pen &	pen () const
void	setPen (const Pen &pen)
const Brush &	brush () const
void	setBrush (const Brush &brush)
const Color &	backgroundColor () const
void	setBackgroundColor (const Color &color)
void	save ()
void	restore ()
void	flush ()
RasterOp	rasterOp () const
void	setRasterOp (RasterOp raster_op)
void	setClipping (bool enable)
bool	clipping () const
bool	hasClipping () const
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)
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 Member Functions
bool	isClipped (int x, int y) const
bool	isClipped (const Point &p) const
void	rop (int pixeladdr, int pixel)
Private Attributes
bool	active_
Pixmap *	pixmap_
std::stack< State >	state_stack
State	state
Classes
class	State

---

Detailed Description

class that allows drawing graphics primitives onto a Pixmap

Definition at line 95 of file painter.h.

---

Member Enumeration Documentation

enum Wt::Painter::RasterOp

Enumerator:

CopyROP
OrROP	dst = src
AndROP	dst = src | dst
XorROP	dst = src ^ dst

Definition at line 156 of file painter.h.

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

---

Constructor & Destructor Documentation

Wt::Painter::Painter	(	const Pixmap *	pixmap = 0,
		bool	clipping = true
	)

constructor - binds this Painter to the pixmap

Definition at line 34 of file painter.cpp.

References begin(), and pixmap_.

                                                    :
        active_(false),
pixmap_(const_cast<Pixmap *>(pixmap)) {
    begin(pixmap_, clipping);
}

Here is the call graph for this function:

Wt::Painter::~Painter

(

)

Definition at line 40 of file painter.cpp.

References end().

                  {
    end();
}

Here is the call graph for this function:

---

Member Function Documentation

const Color& Wt::Painter::backgroundColor

(

)

const [inline]

Definition at line 135 of file painter.h.

References Wt::Painter::State::bg_color, and state.

Referenced by Wt::Widget::backgroundColor(), and Wt::Widget::setBackgroundColor().

                                         {
        return state.bg_color;
    }

bool Wt::Painter::begin

(

)

Definition at line 57 of file painter.cpp.

References pixmap_.

Referenced by Painter().

                    {
    return begin(pixmap_);
}

bool Wt::Painter::begin	(	const Pixmap *	pixmap,
		bool	clipping = true
	)

Definition at line 44 of file painter.cpp.

References active_, pixmap(), pixmap_, and setClipping().

Referenced by Wt::Widget::erase(), and Wt::Widget::paintEvent().

                                                       {
    bool status = false;
    if (!active_) {
        pixmap_ = const_cast<Pixmap *>(pixmap);
        if (pixmap_ && *pixmap_) {
            setClipping(clipping);
            active_ = true;
            status = true;
        }
    }
    return status;
}

Here is the call graph for this function:

void Wt::Painter::blendRect	(	int	x,
		int	y,
		int	w,
		int	h,
		const Brush &	brush
	)

Definition at line 310 of file painter.cpp.

References blendRect(), and brush().

                                                                      {
    blendRect(Rect(x, y, w, h), brush);
}

Here is the call graph for this function:

void Wt::Painter::blendRect	(	const Rect &	r,
		const Brush &	brush
	)

Definition at line 303 of file painter.cpp.

References Wt::PixmapOf< SDLPixmap >::blend(), brush(), Wt::Brush::color(), Wt::Brush::NoBrush, pixmap_, and Wt::Brush::style().

Referenced by blendRect(), and Wt::PushButton::drawButton().

                                                         {
    if (brush.style() == Brush::NoBrush)
        return;

    pixmap_->blend(r, brush.color());
}

Here is the call graph for this function:

void Wt::Painter::blendRegion	(	const Region &	r,
		const Brush &	brush
	)

Definition at line 314 of file painter.cpp.

References Wt::PixmapOf< SDLPixmap >::blend(), brush(), Wt::Brush::color(), Wt::Brush::NoBrush, pixmap_, and Wt::Brush::style().

                                                             {
    if (brush.style() == Brush::NoBrush)
        return;

    pixmap_->blend(r, brush.color());
}

Here is the call graph for this function:

Rect Wt::Painter::boundingRect	(	const std::string &	text,
		int	pos = 0,
		int	len = -1
	)

Definition at line 468 of file painter.cpp.

References Wt::Font::boundingRect(), Wt::Painter::State::font, and state.

                                                                  {
    len = (len - 1) ? text.length() : len;
    return state.font.boundingRect(text.substr(pos, len));
}

Here is the call graph for this function:

const Brush& Wt::Painter::brush

(

)

const [inline]

Definition at line 127 of file painter.h.

References Wt::Painter::State::brush, and state.

Referenced by blendRect(), blendRegion(), fillRect(), fillRegion(), and setBrush().

                                {
        return state.brush;
    }

bool Wt::Painter::clipping

(

)

const [inline]

Definition at line 175 of file painter.h.

References Wt::Painter::State::clipping, and state.

Referenced by hasClipping().

                          {
        return state.clipping;
    }

void Wt::Painter::drawHorizontalLine	(	int	x1,
		int	x2,
		int	y
	)

Definition at line 143 of file painter.cpp.

References Wt::Painter::State::clipping, Wt::Pen::color(), isActive(), Wt::Painter::State::pen, pixmap_, rop(), and state.

Referenced by Wt::Frame::drawFrame(), drawLine(), and drawRect().

                                                      {
    if(!isActive() || y < 0 || y >= pixmap_->height())
        return;

    int w = pixmap_->width();

    if (state.clipping) {
        x1 = std::max(0, x1);
        x1 = std::min(x1, w - 1);
        x2 = std::max(0, x2);
        x2 = std::min(x2, w - 1);
    }

    if (x1 > x2)
        std::swap(x1, x2);

    int pixel = pixmap_->pixelFormat().mapToPixelValue(state.pen.color());
    int pixel_offset = pixmap_->pixelOffset(x1, y);
    int skip = pixmap_->pixelFormat().bytesPerPixel();

    pixmap_->lock()
    ;
    while(x1 <= x2) {
        rop(pixel_offset, pixel);
        x1++;
        pixel_offset += skip;
    }
    pixmap_->unlock();

}

Here is the call graph for this function:

void Wt::Painter::drawLine	(	const Point &	p1,
		const Point &	p2
	)

Definition at line 281 of file painter.cpp.

References drawLine(), Wt::Point::x(), and Wt::Point::y().

                                                       {
    drawLine(p1.x(), p1.y(), p2.x(), p2.y());
}

Here is the call graph for this function:

void Wt::Painter::drawLine	(	int	x1,
		int	y1,
		int	x2,
		int	y2
	)

Definition at line 204 of file painter.cpp.

References Wt::Rect::clipLine(), Wt::Painter::State::clipping, Wt::Pen::color(), drawHorizontalLine(), drawVerticalLine(), isActive(), Wt::Painter::State::pen, pixmap_, Wt::PixmapOf< SDLPixmap >::rect(), rop(), and state.

Referenced by drawLine(), drawLineSegments(), drawPolygon(), and drawPolyline().

                                                     {
    if(!isActive())
        return;

    int dx, dy, sdx, sdy, x, y, px, py;

    dx = x2 - x1;
    dy = y2 - y1;

    //check if we may optimize to either vLine or hLine ...
    if(dx == 0) {
        //this is a vertical line, call vLine and return
        drawVerticalLine(x1, y1, y2);
        return;
    }
    if(dy == 0) {
        //this is a horizontal line, call hLine and return
        drawHorizontalLine(x1, x2, y1);
        return;
    }

    // if clipping is enabled x1, y1, x2, y2 are the clipped values
    if (state.clipping && !pixmap_->rect().clipLine(x1, y1, x2, y2)) {
        dx = x2 - x1;
        dy = y2 - y1;
        return;
    }

    // here comes the hard job ... bresenham:

    sdx = (dx < 0) ? -1 : 1;
    sdy = (dy < 0) ? -1 : 1;

    dx = sdx * dx + 1;
    dy = sdy * dy + 1;

    x = y = 0;

    px = x1;
    py = y1;

    // map the color to the appropriate bit pattern to write ...
    int pixel = pixmap_->pixelFormat().mapToPixelValue(state.pen.color());
    int pixel_offset;

    /// \todo the calculation of the pixel_offset could be reduced to addings ...
    /// no multiplies are needed in fact
    pixmap_->lock()
    ;
    if (dx >= dy) {
        for (x = 0; x < dx; x++) {
            pixel_offset = pixmap_->pixelOffset(px, py);
            rop(pixel_offset, pixel);

            y += dy;
            if (y >= dx) {
                y -= dx;
                py += sdy;
            }
            px += sdx;
        }
    } else {
        for (y = 0; y < dy; y++) {
            pixel_offset = pixmap_->pixelOffset(px, py);
            rop(pixel_offset, pixel);

            x += dx;
            if (x >= dy) {
                x -= dy;
                px += sdx;
            }
            py += sdy;
        }
    }
    pixmap_->unlock();
}

Here is the call graph for this function:

void Wt::Painter::drawLineSegments	(	const PointArray &	points,
		int	start = 0,
		int	end = -1
	)

Definition at line 351 of file painter.cpp.

References drawLine(), and end().

                                                                           {
    int i;
    end = (end > 0) ? end : points.size();

    for (i = start; i < end - 1; i += 2) {
        drawLine(points[i], points[i + 1]);
    }
}

Here is the call graph for this function:

void Wt::Painter::drawPixmap	(	const Rect &	r,
		const Pixmap &	src
	)

Definition at line 394 of file painter.cpp.

References Wt::PixmapOf< SDLPixmap >::blit(), pixmap_, Wt::PixmapOf< SDLPixmap >::scale(), Wt::Rect::size(), and Wt::Rect::topLeft().

                                                         {
    pixmap_->blit(r.topLeft(), src.scale(r.size()));
}

Here is the call graph for this function:

void Wt::Painter::drawPixmap	(	int	x,
		int	y,
		const Pixmap &	src,
		int	sx = 0,
		int	sy = 0,
		int	sw = -1,
		int	sh = -1
	)

Definition at line 390 of file painter.cpp.

References Wt::PixmapOf< SDLPixmap >::blit(), and pixmap_.

                                                                                        {
    pixmap_->blit(x, y, src, Rect(sx, sy, sw, sh));
}

Here is the call graph for this function:

void Wt::Painter::drawPixmap	(	const Point &	p,
		const Pixmap &	src
	)

Definition at line 386 of file painter.cpp.

References Wt::PixmapOf< SDLPixmap >::blit(), pixmap_, Wt::Point::x(), and Wt::Point::y().

                                                          {
    pixmap_->blit(p.x(), p.y(), src);
}

Here is the call graph for this function:

void Wt::Painter::drawPixmap	(	const Point &	p,
		const Pixmap &	src,
		const Rect &	sr
	)

Definition at line 382 of file painter.cpp.

References Wt::PixmapOf< SDLPixmap >::blit(), and pixmap_.

Referenced by Wt::PushButton::drawButton(), Wt::Label::drawContents(), and Wt::Widget::erase().

                                                                          {
    pixmap_->blit(p.x(), p.y(), src, sr);
}

Here is the call graph for this function:

void Wt::Painter::drawPoint

(

const Point &

p

)

Definition at line 121 of file painter.cpp.

References drawPoint(), Wt::Point::x(), and Wt::Point::y().

                                      {
    drawPoint(p.x(), p.y());
}

Here is the call graph for this function:

void Wt::Painter::drawPoint	(	int	x,
		int	y
	)

Definition at line 109 of file painter.cpp.

References Wt::Pen::color(), isClipped(), Wt::Painter::State::pen, pixmap_, rop(), and state.

Referenced by drawPoint().

                                    {
    if (!isClipped(x, y)) {
        int pixel_offset = pixmap_->pixelOffset(x, y);
        int pixel = pixmap_->pixelFormat().mapToPixelValue(state.pen.color());

        pixmap_->lock()
        ;
        rop(pixel_offset, pixel);
        pixmap_->unlock();
    }
}

Here is the call graph for this function:

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

Definition at line 125 of file painter.cpp.

References Wt::Pen::color(), end(), isClipped(), Wt::Painter::State::pen, pixmap_, rop(), and state.

                                                                     {
    int i;
    int pixel = pixmap_->pixelFormat().mapToPixelValue(state.pen.color());

    end = (end > 0) ? end : points.size();

    pixmap_->lock()
    ;
    for (i = start; i < end; i++) {
        const Point& p = points[i];
        if (!isClipped(p)) {
            int pixel_offset = pixmap_->pixelOffset(p.x(), p.y());
            rop(pixel_offset, pixel);
        }
    }
    pixmap_->unlock();
}

Here is the call graph for this function:

void Wt::Painter::drawPolygon	(	const PointArray &	points,
		int	start = 0,
		int	end = -1
	)

Definition at line 369 of file painter.cpp.

References Wt::Painter::State::brush, drawLine(), end(), Wt::Brush::NoBrush, state, and Wt::Brush::style().

                                                                      {
    int i;
    end = (end > 0) ? end : points.size();

    for (i = start; i < end; i++) {
        drawLine(points[i], points[i + 1 % end]);
    }

    if (state.brush.style() != Brush::NoBrush) {
        /// \todo we have to actually fill the damn thing
    }
}

Here is the call graph for this function:

void Wt::Painter::drawPolyline	(	const PointArray &	points,
		int	start = 0,
		int	end = -1
	)

Definition at line 360 of file painter.cpp.

References drawLine(), and end().

                                                                       {
    int i;
    end = (end > 0) ? end : points.size();

    for (i = start; i < end; i++) {
        drawLine(points[i], points[i + 1]);
    }
}

Here is the call graph for this function:

void Wt::Painter::drawRect

(

const Rect &

r

)

Definition at line 347 of file painter.cpp.

References drawRect(), Wt::SDLRect::height(), Wt::SDLRect::left(), Wt::SDLRect::top(), and Wt::SDLRect::width().

                                     {
    drawRect(r.left(), r.top(), r.width(), r.height());
}

Here is the call graph for this function:

void Wt::Painter::drawRect	(	int	x,
		int	y,
		int	w,
		int	h
	)

Definition at line 333 of file painter.cpp.

References Wt::Painter::State::brush, drawHorizontalLine(), drawVerticalLine(), fillRect(), Wt::Brush::NoBrush, state, and Wt::Brush::style().

Referenced by drawRect().

                                                 {
    int x2 = x + w - 1;
    int y2 = y + h - 1;

    drawHorizontalLine(x, x2, y);
    drawVerticalLine(x, y, y2);
    drawHorizontalLine(x, x2, y2);
    drawVerticalLine(x2, y, y2);

    if (state.brush.style() != Brush::NoBrush) {
        fillRect(x + 1, y + 1, w - 1, h - 1, state.brush);
    }
}

Here is the call graph for this function:

void Wt::Painter::drawText	(	const Point &	p,
		const std::string &	text,
		int	pos,
		int	len
	)

Definition at line 456 of file painter.cpp.

References drawText().

                                                                {
    len = (len - 1) ? text.length() : len;
    const std::string& t = text.substr(pos, len);
    drawText(p, t);
}

Here is the call graph for this function:

void Wt::Painter::drawText	(	int	x,
		int	y,
		const std::string &	text,
		int	pos,
		int	len
	)

Definition at line 463 of file painter.cpp.

References drawText().

                                                                {
    drawText(Point(x, y), text, pos, len);
}

Here is the call graph for this function:

void Wt::Painter::drawText	(	const Point &	p,
		const std::string &	text,
		int	len = -1
	)

Definition at line 441 of file painter.cpp.

References Wt::SDLColor::alpha(), Wt::Font::ascent(), Wt::Painter::State::bg_color, Wt::PixmapOf< SDLPixmap >::blit(), Wt::PixmapOf< SDLPixmap >::blitAlphaCopy(), Wt::Font::blitText(), Wt::Painter::State::font, pixmap_, state, and Wt::SDLColor::Transparent.

                                                                     {
    const std::string& t = (len == -1) ? text : text.substr(0, len);
    const Point p1 = p - Point(0, state.font.ascent());

    if (state.bg_color.alpha() != Color::Transparent) {
        pixmap_->blit(p1, state.font.blitText(t));
    } else {
        pixmap_->blitAlphaCopy(p1, state.font.blitText(t));
    }
}

Here is the call graph for this function:

void Wt::Painter::drawText	(	int	x,
		int	y,
		const std::string &	text,
		int	len = -1
	)

Todo:

missing functionality: paragraphs, multi line text, text aligining (low priority)

Definition at line 452 of file painter.cpp.

Referenced by Wt::PushButton::drawButtonLabel(), Wt::Label::drawContents(), Wt::Widget::drawText(), and drawText().

                                                                   {
    drawText(Point(x, y), text, len);
}

void Wt::Painter::drawTiledPixmap	(	int	x,
		int	y,
		int	w,
		int	h,
		const Pixmap &	src,
		int	sx = 0,
		int	sy = 0
	)

Definition at line 436 of file painter.cpp.

References drawTiledPixmap().

                                                                 {
    drawTiledPixmap(Rect(x, y, w, h), src, Point(sx, sy));
}

Here is the call graph for this function:

void Wt::Painter::drawTiledPixmap	(	const Rect &	r,
		const Pixmap &	src
	)

Definition at line 432 of file painter.cpp.

References drawTiledPixmap().

                                                              {
    drawTiledPixmap(r, src, Point(0, 0));
}

Here is the call graph for this function:

void Wt::Painter::drawTiledPixmap	(	const Rect &	r,
		const Pixmap &	src,
		const Point &	sp
	)

Definition at line 398 of file painter.cpp.

References Wt::PixmapOf< SDLPixmap >::blit(), Wt::SDLRect::bottom(), Wt::SDLRect::height(), Wt::SDLRect::left(), pixmap_, Wt::SDLRect::right(), Wt::SDLRect::setHeight(), Wt::SDLRect::setWidth(), Wt::SDLRect::setX(), Wt::SDLRect::setY(), Wt::SDLRect::top(), Wt::Rect::topLeft(), trace, Wt::SDLRect::width(), Wt::Point::x(), and Wt::Point::y().

Referenced by drawTiledPixmap(), and Wt::Widget::updateBackground().

                                                                  {

    int src_w = src.width();
    int src_h = src.height();
    int dst_w = r.width();
    int dst_h = r.height();
    int x, y, w;
    int h = src_h - sp.y();
    Rect dst_rect(0, 0, 0, h);
    Rect src_rect(sp, Size(0, h));

    trace("painter") << "Tiling a " << Size(src_w, src_h)
    << " background onto a " << Size(dst_w, dst_h) << " surface" << std::endl;

    for(y = r.top(); y <= r.bottom(); y += h) {
        dst_rect.setY(y);
        w = src_w - sp.x();
        dst_rect.setWidth(w);
        src_rect.setWidth(w);
        for(x = r.left(); x <= r.right(); x += w) {
            dst_rect.setX(x);
            trace("painter")  << "Blitting tile at " << dst_rect.topLeft() << std::endl;
            pixmap_->blit(dst_rect.topLeft(), src, src_rect);
            w = src_w;
            dst_rect.setWidth(w);
            src_rect.setWidth(w);
        }
        h = src_h;
        dst_rect.setHeight(h);
        src_rect.setHeight(h);
    }
}

Here is the call graph for this function:

void Wt::Painter::drawVerticalLine	(	int	x,
		int	y1,
		int	y2
	)

Definition at line 174 of file painter.cpp.

References Wt::Painter::State::clipping, Wt::Pen::color(), isActive(), Wt::Painter::State::pen, pixmap_, rop(), and state.

Referenced by Wt::Frame::drawFrame(), drawLine(), and drawRect().

                                                    {
    if(!isActive() || x < 0 || x >= pixmap_->width())
        return;

    int h = pixmap_->height();

    if (state.clipping) {
        y1 = std::max(0, y1);
        y1 = std::min(y1, h - 1);
        y2 = std::max(0, y2);
        y2 = std::min(y2, h - 1);
    }

    if (y1 > y2)
        std::swap(y1, y2);

    int pixel = pixmap_->pixelFormat().mapToPixelValue(state.pen.color());
    int pixel_offset = pixmap_->pixelOffset(x, y1);
    int skip = pixmap_->bytesPerLine();

    pixmap_->lock()
    ;
    while(y1 <= y2) {
        rop(pixel_offset, pixel);
        y1++;
        pixel_offset += skip;
    }
    pixmap_->unlock();
}

Here is the call graph for this function:

bool Wt::Painter::end

(

)

Definition at line 61 of file painter.cpp.

References active_, restore(), and state_stack.

Referenced by drawLineSegments(), drawPoints(), drawPolygon(), drawPolyline(), Wt::Widget::erase(), Wt::Widget::paintEvent(), and ~Painter().

                  {
    bool status = false;
    if (active_) {
        while (!state_stack.empty()) {
            restore();
        }
        active_ = false;
        status = true;
    }
    return status;
}

Here is the call graph for this function:

void Wt::Painter::eraseRect	(	int	x,
		int	y,
		int	w,
		int	h
	)

Definition at line 325 of file painter.cpp.

References eraseRect().

                                                  {
    eraseRect(Rect(x, y, w, h));
}

Here is the call graph for this function:

void Wt::Painter::eraseRect

(

const Rect &

r

)

Definition at line 321 of file painter.cpp.

References Wt::Painter::State::bg_color, fillRect(), and state.

Referenced by Wt::Widget::erase(), and eraseRect().

                                     {
    fillRect(r, state.bg_color);
}

Here is the call graph for this function:

void Wt::Painter::eraseRegion

(

const Region &

r

)

Definition at line 329 of file painter.cpp.

References Wt::Painter::State::bg_color, fillRegion(), and state.

Referenced by Wt::Widget::erase().

                                         {
    fillRegion(r, state.bg_color);
}

Here is the call graph for this function:

void Wt::Painter::fillRect	(	int	x,
		int	y,
		int	w,
		int	h,
		const Brush &	brush
	)

Definition at line 292 of file painter.cpp.

References brush(), and fillRect().

                                                                     {
    fillRect(Rect(x, y, w, h), brush);
}

Here is the call graph for this function:

void Wt::Painter::fillRect	(	const Rect &	r,
		const Brush &	brush
	)

Definition at line 285 of file painter.cpp.

References brush(), Wt::Brush::color(), Wt::PixmapOf< SDLPixmap >::fill(), Wt::Brush::NoBrush, pixmap_, and Wt::Brush::style().

Referenced by drawRect(), eraseRect(), and fillRect().

                                                        {
    if (brush.style() == Brush::NoBrush)
        return;

    pixmap_->fill(r, brush.color());
}

Here is the call graph for this function:

void Wt::Painter::fillRegion	(	const Region &	r,
		const Brush &	brush
	)

Definition at line 296 of file painter.cpp.

References brush(), Wt::Brush::color(), Wt::PixmapOf< SDLPixmap >::fill(), Wt::Brush::NoBrush, pixmap_, and Wt::Brush::style().

Referenced by eraseRegion().

                                                            {
    if (brush.style() == Brush::NoBrush)
        return;

    pixmap_->fill(r, brush.color());
}

Here is the call graph for this function:

void Wt::Painter::flush

(

)

[inline]

Definition at line 154 of file painter.h.

{}

const Font& Wt::Painter::font

(

)

const [inline]

Definition at line 110 of file painter.h.

References Wt::Painter::State::font, and state.

Referenced by Wt::Widget::font(), and setFont().

                             {
        return state.font;
    }

bool Wt::Painter::hasClipping

(

)

const [inline]

Deprecated:

Definition at line 180 of file painter.h.

References clipping().

                             {
        return clipping();
    }

Here is the call graph for this function:

bool Wt::Painter::isActive

(

)

const

Definition at line 73 of file painter.cpp.

References active_.

Referenced by drawHorizontalLine(), drawLine(), drawVerticalLine(), and isClipped().

                              {
    return active_;
}

bool Wt::Painter::isClipped

(

const Point &

p

)

const [protected]

Definition at line 81 of file painter.cpp.

References isClipped(), Wt::Point::x(), and Wt::Point::y().

                                            {
    return isClipped(p.x(), p.y());
}

Here is the call graph for this function:

bool Wt::Painter::isClipped	(	int	x,
		int	y
	)			const [protected]

Definition at line 77 of file painter.cpp.

References Wt::Painter::State::clipping, Wt::Rect::contains(), isActive(), pixmap_, Wt::PixmapOf< SDLPixmap >::rect(), and state.

Referenced by drawPoint(), drawPoints(), and isClipped().

                                          {
    return !isActive() || (state.clipping && !pixmap_->rect().contains(x, y));
}

Here is the call graph for this function:

const Pen& Wt::Painter::pen

(

)

const [inline]

Definition at line 118 of file painter.h.

References Wt::Painter::State::pen, and state.

Referenced by Wt::Widget::foregroundColor(), Wt::Widget::setForegroundColor(), and setPen().

                           {
        return state.pen;
    }

Pixmap* Wt::Painter::pixmap

(

)

const [inline]

Definition at line 105 of file painter.h.

References pixmap_.

Referenced by begin().

                           {
        return pixmap_;
    }

RasterOp Wt::Painter::rasterOp

(

)

const [inline]

Definition at line 163 of file painter.h.

References Wt::Painter::State::raster_op, and state.

                              {
        return state.raster_op;
    }

void Wt::Painter::restore

(

)

[inline]

Definition at line 148 of file painter.h.

References state, and state_stack.

Referenced by Wt::PushButton::drawButtonLabel(), Wt::Frame::drawFrame(), and end().

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

void Wt::Painter::rop	(	int	pixeladdr,
		int	pixel
	)			[protected]

Definition at line 85 of file painter.cpp.

References AndROP, CopyROP, OrROP, Wt::PixmapOf< SDLPixmap >::pixel(), pixmap_, Wt::Painter::State::raster_op, Wt::PixmapOf< SDLPixmap >::setPixel(), state, Warn, and XorROP.

Referenced by drawHorizontalLine(), drawLine(), drawPoint(), drawPoints(), and drawVerticalLine().

                                             {
    switch(state.raster_op) {
    case CopyROP:
        pixmap_->setPixel(pixel_offset, pixel);
        break;
    case XorROP:
        pixel = pixel ^ pixmap_->pixel(pixel_offset);
        pixmap_->setPixel(pixel_offset, pixel);
        break;
    case AndROP:
        pixel = pixel & pixmap_->pixel(pixel_offset);
        pixmap_->setPixel(pixel_offset, pixel);
        break;
    case OrROP:
        pixel = pixel | pixmap_->pixel(pixel_offset);
        pixmap_->setPixel(pixel_offset, pixel);
        break;
    default:
        Warn("Unknown Raster Operation %d\n", state.raster_op);
        pixmap_->setPixel(pixel_offset, pixel);
        break;
    }
}

Here is the call graph for this function:

void Wt::Painter::save

(

)

[inline]

Definition at line 144 of file painter.h.

References state, and state_stack.

Referenced by Wt::PushButton::drawButtonLabel(), and Wt::Frame::drawFrame().

                {
        state_stack.push(state);
    }

void Wt::Painter::setBackgroundColor

(

const Color &

color

)

[inline]

Definition at line 139 of file painter.h.

References Wt::Painter::State::bg_color, Wt::Painter::State::font, Wt::Font::setBackgroundColor(), and state.

Referenced by Wt::Widget::setBackgroundColor().

                                                {
        state.bg_color = color;
        state.font.setBackgroundColor(color);
    }

Here is the call graph for this function:

void Wt::Painter::setBrush

(

const Brush &

brush

)

[inline]

Definition at line 131 of file painter.h.

References brush(), Wt::Painter::State::brush, and state.

                                      {
        state.brush = brush;
    }

Here is the call graph for this function:

void Wt::Painter::setClipping

(

bool

enable

)

[inline]

Definition at line 171 of file painter.h.

References Wt::Painter::State::clipping, and state.

Referenced by begin().

                                  {
        state.clipping = enable;
    }

void Wt::Painter::setFont

(

const Font &

font

)

[inline]

Definition at line 114 of file painter.h.

References font(), Wt::Painter::State::font, and state.

Referenced by Wt::Widget::reparent(), Wt::Widget::setFont(), and Wt::Widget::Widget().

                                   {
        state.font = font;
    }

Here is the call graph for this function:

void Wt::Painter::setPen

(

const Pen &

pen

)

[inline]

Definition at line 122 of file painter.h.

References Wt::Pen::color(), Wt::Painter::State::font, pen(), Wt::Painter::State::pen, Wt::Font::setForegroundColor(), and state.

Referenced by Wt::PushButton::drawButtonLabel(), Wt::Frame::drawFrame(), and Wt::Widget::setForegroundColor().

                                {
        state.pen = pen;
        state.font.setForegroundColor(pen.color());
    }

Here is the call graph for this function:

void Wt::Painter::setRasterOp

(

RasterOp

raster_op

)

[inline]

Definition at line 167 of file painter.h.

References Wt::Painter::State::raster_op, and state.

                                         {
        state.raster_op = raster_op;
    }

---

Member Data Documentation

bool Wt::Painter::active_ [private]

Definition at line 237 of file painter.h.

Referenced by begin(), end(), and isActive().

Pixmap* Wt::Painter::pixmap_ [private]

Definition at line 238 of file painter.h.

Referenced by begin(), blendRect(), blendRegion(), drawHorizontalLine(), drawLine(), drawPixmap(), drawPoint(), drawPoints(), drawText(), drawTiledPixmap(), drawVerticalLine(), fillRect(), fillRegion(), isClipped(), Painter(), pixmap(), and rop().

State Wt::Painter::state [private]

Definition at line 258 of file painter.h.

Referenced by backgroundColor(), boundingRect(), brush(), clipping(), drawHorizontalLine(), drawLine(), drawPoint(), drawPoints(), drawPolygon(), drawRect(), drawText(), drawVerticalLine(), eraseRect(), eraseRegion(), font(), isClipped(), pen(), rasterOp(), restore(), rop(), save(), setBackgroundColor(), setBrush(), setClipping(), setFont(), setPen(), and setRasterOp().

std::stack<State> Wt::Painter::state_stack [private]

Definition at line 257 of file painter.h.

Referenced by end(), restore(), and save().

---

The documentation for this class was generated from the following files:

• painter.h
• painter.cpp

---

Generated Fri Jul 28 19:30:51 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.