rect.cpp

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.
*/

#include <iostream>

#include <wt/rect.h>

namespace Wt {

Rect Rect::invalid = Rect(0, 0, -1, -1);
Rect Rect::empty = Rect(0, 0, 0, 0);

Rect Rect::unite(const Rect &r) const {
    if(!isValid() || !r.isValid())
        return invalid;

    int min_x = std::min(left(), r.left());
    int min_y = std::min(top(), r.top());
    int max_x = std::max(right(), r.right()) + 1;
    int max_y = std::max(bottom(), r.bottom()) + 1;

    assert(min_x <= max_x);
    assert(min_y <= max_y);

    return Rect(min_x, min_y, max_x - min_x, max_y - min_y);
}

/**
 * Returns an invalid rectangle if *this and r don't intersect
 **/
Rect Rect::intersect(const Rect &r) const {
    if(!isValid() || !r.isValid())
        return invalid;

    int min_x = std::max(left(), r.left());
    int min_y = std::max(top(), r.top());
    int max_x = std::min(right(), r.right()) + 1;
    int max_y = std::min(bottom(), r.bottom()) + 1;

    if(min_x > max_x || min_y > max_y)
        return invalid;

    return Rect(min_x, min_y, max_x - min_x, max_y - min_y);
}

int Rect::borderCross(int x, int y) const {
    int border_cross = 0;

    border_cross |= (x < left()) ? Left : 0;
    border_cross |= (x > right()) ? Right : 0;
    border_cross |= (y < top()) ? Top : 0;
    border_cross |= (y > bottom()) ? Bottom : 0;

    return border_cross;
}

bool Rect::clipLine(int& x1, int& y1, int& x2, int& y2) const {

    int b1 = borderCross(x1, y1);
    int b2 = borderCross(x2, y2);

    while (b1 || b2) {
        int b;
        int x, y;

        if (b1 & b2) {
            // trivially reject
            return false;
        } else {
            b = (b1) ? b1 : b2;
        }

        if (b & Left) {
            x = left();
            y = y1 + (y2 - y1) * (x - x1) / (x2 - x1);
        } else if (b & Right) {
            x = right();
            y = y1 + (y2 - y1) * (x - x1) / (x2 - x1);
        } else if (b & Top) {
            y = top();
            x = x1 + (x2 - x1) * (y - y1) / (y2 - y1);
        } else { // if (b & Bottom) {
            y = bottom();
            x = x1 + (x2 - x1) * (y - y1) / (y2 - y1);
        }

        if (b == b1) {
            x1 = x;
            y1 = y;
            b1 = borderCross(x1, y1);
        } else {
            x2 = x;
            y2 = y;
            b2 = borderCross(x2, y2);
        }
    };

    return true;
}

bool Rect::clipLine(Point& p1, Point& p2) const {
    int x1 = p1.x();
    int y1 = p1.y();
    int x2 = p2.x();
    int y2 = p2.y();
    bool clip = clipLine(x1, y1, x2, y2);
    p1.setX(x1);
    p1.setY(y1);
    p2.setX(x2);
    p2.setY(y2);
    return clip;
}

Rect Rect::align(const Rect& container, const Size& size, int alignment) {
    int xc = 0, yc = 0;

    if (alignment == AlignAuto)
        alignment = AlignCenter;
    else if (! (alignment & AlignHorizontal_Mask) )
        alignment |= AlignHCenter;
    else if (! (alignment & AlignVertical_Mask) )
        alignment |= AlignVCenter;

    switch (alignment & AlignHorizontal_Mask) {
    case AlignLeft:
        xc = container.x();
        break;
    case AlignRight:
        xc = container.x() + container.width() - size.width();
        break;
    case AlignHCenter:
        xc = container.x() + ((container.width() - size.width()) >> 1);
        break;
    case AlignJustify:
    default:
        //Error("Unimplemented Alignment flag %d\n", alignment);
        return invalid;
        break;
    }

    switch (alignment & AlignVertical_Mask) {
    case AlignTop:
        yc = container.y();
        break;
    case AlignBottom:
        yc = container.y() + container.height() - size.height();
        break;
    case AlignVCenter:
        yc = container.y() + ((container.height() - size.height()) >> 1);
        break;
    default:
        //Error("Unimplemented Alignment flag %d\n", alignment);
        return invalid;
        break;
    }

    return Rect(xc, yc, size.width(), size.height());
}

std::ostream& operator<<(std::ostream& s, const Point& p) {
    s << "[" << p.x() << ", " << p.y() << "]";
    return s;
}

std::ostream& operator<<(std::ostream& s, const Size& size) {
    s << "[ " << size.width() << " x " << size.height() << " ]";
    return s;
}

std::ostream& operator<<(std::ostream& s, const Rect& r) {
    s << "(" << r.x() << "," << r.y() << "," << r.width() << "," << r.height() << ")";
    return s;
}

} // 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.