painter.cpp

Go to the documentation of this file.

/*
  libwt - Vassilis Virvilis Toolkit - a widget library
  Copyright (C) 2006 Vassilis Virvilis <vasvir2@fastmail.fm>
  Copyright (C) 2002 Malcolm Walker <malcolm@worldforge.org>
  Based on code copyright  (C) 1999-2002  Karsten Laux
 
  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.
*/
// originally written by Karsten Laux, June 1999

#include <wt/painter.h>
#include <wt/pixmap.h>
#include <wt/color.h>
#include <wt/rect.h>
#include <wt/region.h>
#include <wt/rootwindow.h>
#include <wt/trace.h>

namespace Wt {

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

Painter::~Painter() {
    end();
}

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

bool Painter::begin() {
    return begin(pixmap_);
}

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

bool Painter::isActive () const {
    return active_;
}

bool Painter::isClipped(int x, int y) const {
    return !isActive() || (state.clipping && !pixmap_->rect().contains(x, y));
}

bool Painter::isClipped(const Point& p) const {
    return isClipped(p.x(), p.y());
}

void Painter::rop(int pixel_offset, int pixel) {
    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;
    }
}

void Painter::drawPoint(int x, int y) {
    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();
    }
}

void Painter::drawPoint(const Point& p) {
    drawPoint(p.x(), p.y());
}

void Painter::drawPoints(const PointArray& points, int start, int end) {
    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();
}

void Painter::drawHorizontalLine(int x1, int x2, int y) {
    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();

}

void Painter::drawVerticalLine(int x, int y1, int y2) {
    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();
}

void Painter::drawLine(int x1, int y1, int x2, int y2) {
    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();
}

void Painter::drawLine(const Point& p1, const Point& p2) {
    drawLine(p1.x(), p1.y(), p2.x(), p2.y());
}

void Painter::fillRect(const Rect& r, const Brush& brush) {
    if (brush.style() == Brush::NoBrush)
        return;

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

void Painter::fillRect(int x, int y, int w, int h, const Brush& brush) {
    fillRect(Rect(x, y, w, h), brush);
}

void Painter::fillRegion(const Region& r, const Brush& brush) {
    if (brush.style() == Brush::NoBrush)
        return;

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

void Painter::blendRect(const Rect& r, const Brush& brush) {
    if (brush.style() == Brush::NoBrush)
        return;

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

void Painter::blendRect(int x, int y, int w, int h, const Brush& brush) {
    blendRect(Rect(x, y, w, h), brush);
}

void Painter::blendRegion(const Region& r, const Brush& brush) {
    if (brush.style() == Brush::NoBrush)
        return;

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

void Painter::eraseRect(const Rect& r) {
    fillRect(r, state.bg_color);
}

void Painter::eraseRect(int x, int y, int w, int h) {
    eraseRect(Rect(x, y, w, h));
}

void Painter::eraseRegion(const Region& r) {
    fillRegion(r, state.bg_color);
}

void Painter::drawRect(int x, int y, int w, int h) {
    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);
    }
}

void Painter::drawRect(const Rect& r)  {
    drawRect(r.left(), r.top(), r.width(), r.height());
}

void Painter::drawLineSegments(const PointArray& points, int start, int end) {
    int i;
    end = (end > 0) ? end : points.size();

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

void Painter::drawPolyline(const PointArray& points, int start, int end) {
    int i;
    end = (end > 0) ? end : points.size();

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

void Painter::drawPolygon(const PointArray& points, int start, int end) {
    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
    }
}

void Painter::drawPixmap(const Point& p, const Pixmap& src, const Rect& sr) {
    pixmap_->blit(p.x(), p.y(), src, sr);
}

void Painter::drawPixmap(const Point& p, const Pixmap& src) {
    pixmap_->blit(p.x(), p.y(), src);
}

void Painter::drawPixmap(int x, int y, const Pixmap& src, int sx, int sy, int sw, int sh) {
    pixmap_->blit(x, y, src, Rect(sx, sy, sw, sh));
}

void Painter::drawPixmap(const Rect& r, const Pixmap& src) {
    pixmap_->blit(r.topLeft(), src.scale(r.size()));
}

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

    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);
    }
}

void Painter::drawTiledPixmap(const Rect& r, const Pixmap& src) {
    drawTiledPixmap(r, src, Point(0, 0));
}

void Painter::drawTiledPixmap(int x, int y, int w, int h,
                              const Pixmap& src, int sx, int sy) {
    drawTiledPixmap(Rect(x, y, w, h), src, Point(sx, sy));
}

void Painter::drawText(const Point& p, const std::string& text, int len) {
    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));
    }
}

void Painter::drawText(int x, int y, const std::string& text, int len) {
    drawText(Point(x, y), text, len);
}

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

void Painter::drawText(int x, int y,
                       const std::string& text, int pos, int len) {
    drawText(Point(x, y), text, pos, len);
}

Rect Painter::boundingRect(const std::string& text, int pos, int len) {
    len = (len - 1) ? text.length() : len;
    return state.font.boundingRect(text.substr(pos, len));
}

#if 0

void
Painter::circle(const Point& c, unsigned int r, unsigned int t) {
    if(fill_)
        ellipseFill(c,r,r);
    else
        ellipse(c,r,r,t);
}

void
Painter::ellipse(const Point& c,
                 unsigned int rx, unsigned int ry, unsigned int t) {
    if(!pixmap_ || pixmap_->empty())
        return;
    if(rx == 0 || ry == 0)
        return;

    if(fill_) {
        ellipseFill(c,rx,ry);
        return;
    }

    int steps = 3 * (rx > ry) ? rx : ry;

    float alpha = 0;
    float delta = M_PI/2/steps;

    Point p;
    Point v;
    int pixel_offset;

    int pixel = pixmap_->pixelformat().mapToPixel(color_);

    pixmap_->lock()
    ;

    while(steps > 0) {
        v.x = (int)(rx * cos(alpha));
        v.y = (int)(ry * sin(alpha));

        p.x = c.x + v.x;
        p.y = c.y + v.y;

        if(Rect(0,0, pixmap_->width(), pixmap_->height()).contains(p)) {
            pixel_offset=pixmap_->pixelformat().bpp()*p.x +pixmap_->pitch()*p.y;
            for(unsigned int i=0; i < t; i++) {
                writePixel(pixel_offset, pixel);
                pixel_offset++;
            }
        }

        v.x = -v.x;
        p.x = c.x + v.x;

        if(Rect(0,0, pixmap_->width(), pixmap_->height()).contains(p)) {
            pixel_offset=pixmap_->pixelformat().bpp()*p.x +surface_->pitch()*p.y;
            for(unsigned int i=0; i < t; i++) {
                writePixel(pixel_offset, pixel);
                pixel_offset++;
            }
        }

        v.y = -v.y;
        p.y = c.y + v.y;
        if(Rect(0,0, surface_->width(), surface_->height()).contains(p)) {
            pixel_offset=surface_->pixelformat().bpp()*p.x +surface_->pitch()*p.y;
            for(unsigned int i=0; i < t; i++) {
                writePixel(pixel_offset, pixel);
                pixel_offset++;
            }
        }

        v.x = -v.x;
        p.x = c.x + v.x;
        if(Rect(0,0, surface_->width(), surface_->height()).contains(p)) {
            pixel_offset=surface_->pixelformat().bpp()*p.x +surface_->pitch()*p.y;
            for(unsigned int i=0; i < t; i++) {
                writePixel(pixel_offset, pixel);
                pixel_offset++;
            }
        }

        alpha = alpha + delta;
        steps--;
    }


    surface_->unlock();
}


void
Painter::ellipseFill(const Point& c,
                     unsigned int rx, unsigned int ry) {
    if(!surface_ || surface_->empty())
        return;
    if(rx == 0 || ry == 0)
        return;
    unsigned int steps = 0;

    Point p1;
    Point p2;
    Point v;

    while(steps < ry) {

        v.x = (int)(rx * cos(asin((double)steps/ry)));

        p1.x = c.x - v.x;
        p1.y = c.y - steps;

        p2.x = c.x + v.x;
        p2.y = c.y - steps;

        hLine(p1,p2,color_);


        p1.x = c.x - v.x;
        p1.y = c.y + steps;

        p2.x = c.x + v.x;
        p2.y = c.y + steps;

        hLine(p1,p2,color_);

        steps++;
    }
}

#endif

} //namespace Wt

---

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.