rect.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_RECT_H
#define WT_RECT_H

#include "sdlrect.h"

#include <wt/point.h>
#include <wt/size.h>
#include <wt/flags.h>

namespace Wt {

/// Rectangle class.  Has corners, fill, etc.
class Rect : public SDLRect {
public:
    /// Create an empty rectangle at (0, 0)
    Rect() : SDLRect() {
        assert(sizeof(Rect) == sizeof(SDLRect));
    }
    /// Create a rectangle
    Rect(int x_, int y_, int w_, int h_)
            : SDLRect(x_, y_, w_, h_) {
        assert(sizeof(Rect) == sizeof(SDLRect));
    }
    Rect(const Point& p, const Size& size)
            : SDLRect(p.x(), p.y(), size.width(), size.height()) {
        assert(sizeof(Rect) == sizeof(SDLRect));
    }
    /// Create a rectangle from a SDLRect
    Rect(const SDLRect& sdlrect)
            : SDLRect(sdlrect) {
        assert(sizeof(Rect) == sizeof(SDLRect));
    }
    /// set's a rect from a SDLRect
    Rect& operator=(const SDLRect &r) {
        *this = Rect(r);
        return *this;
    }
    ///
    ~Rect() {}

    /// An invalid rectangle
    static Rect invalid;
    /// An empty (w == h == 0) rectangle
    static Rect empty;
    /// Returns true if the rectangle is empty
    bool isEmpty() const {
        return width() == 0 && height() == 0;
    }
    /// Returns true if the rectangle is valid (dimensions non-negative)
    bool isValid() const {
        return (width() > 0 && height() > 0);
    }

    using SDLRect::contains;
    /// Returns true if the rectangle contains p
    bool contains(const Point &p) const {
        return contains(p.x(), p.y());
    }

    using SDLRect::moveTopLeft;
    ///move the rectangle, specifying new upperleft corner
    void moveTopLeft(const Point &p) {
        moveTopLeft(p.x(), p.y());
    }

    /// Return the smallest rectangle which contains both *this and r
    Rect unite(const Rect &r)    const;
    /// Return the largest rectangle which is contained by both *this and r
    Rect intersect(const Rect &r) const;

    /// Return the topleft corner of the rectangle
    Point topLeft() const {
        return Point(x(), y());
    }

    /// Return the width of the rectangle
    Size size() const {
        return Size(width(), height());
    }
    /// set's the size of the rect.
    void setSize(const Size& size) {
        resize(size.width(), size.height());
    }
    /// set's the rect's.
    void setCoords(int x1, int y1, int x2, int y2) {
        setRect(x1, y1, x2 - x1 + 1, y2 - y1 + 1);
    }

    /// add a margin (smaller rectangle)
    Rect operator>>(int margin) const {
        return Rect(x() + margin, y() + margin,
                    width() - 2 * margin, height() - 2 * margin);
    }

    /// add a margin (smaller rectangle)
    Rect& operator>>(int margin) {
        setRect(x() + margin, y() + margin,
                width() - 2 * margin, height() - 2 * margin);
        return *this;
    }

    /// subtract a margin (bigger rectangle)
    Rect operator<<(int margin) const {
        return Rect(x() - margin, y() - margin,
                    width() + 2 * margin, height() + 2 * margin);
    }

    /// subtract a margin (bigger rectangle)
    Rect& operator<<(int margin) {
        setRect(x() - margin, y() - margin,
                width() + 2 * margin, height() + 2 * margin);
        return *this;
    }

    void setLeft(int x1) {
        setRect(x1, y(), x() - x1 + width(), height());
    }
    void setTop(int y1) {
        setRect(x(), y1, width(), y() - y1 + height());
    }
    void setRight(int x2) {
        setRect(x(), y(), x2 - x() + 1, height());
    }
    void setBottom(int y2) {
        setRect(x(), y(), width(), y2 - y() + 1);
    }

    bool clipLine(int& x1, int& y1, int& x2, int& y2) const;
    bool clipLine(Point& p1, Point& p2) const;

    Rect operator&(const Rect& other) const {
        return intersect(other);
    };

    Rect& operator&=(const Rect& other) {
        *this = intersect(other);
        return *this;
    };

    static Rect align(const Rect& container, const Size& size, int alignment);

protected:
    typedef enum {
        Left = 1 << 0,
        Right = 1 << 1,
        Top = 1 << 2,
        Bottom = 1 << 3
    } BorderCross;

    int borderCross(int x, int y) const;
};

/// Print a rectangle to a stream, formatted as (x,y,w,h)
std::ostream& operator<<(std::ostream& s, const Rect& p);

typedef std::vector<Rect> RectArray;
} // namespace Wt

#endif // WT_RECT_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.