root/window/rect.cc

/*
 * Copyright (c) 2004-2006  Kazunori "jagarl" Ueno
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


#include "rect.h"

using namespace std;

inline int MAX(int a, int b) {
        if (a>b) return a;
        return b;
}

inline int MIN(int a, int b) {
        if (a>b) return b;
        return a;
}

Rect::Rect(int x1, int y1) {
        lx = rx = x1;
        ty = by = y1;
}

Rect::Rect(int x1, int y1, int x2, int y2) {
        lx = MIN(x1,x2);
        rx = MAX(x1,x2);
        ty = MIN(y1,y2);
        by = MAX(y1,y2);
}

Rect::Rect(const Rect& r) {
        lx = r.lx;
        rx = r.rx;
        ty = r.ty;
        by = r.by;
}

bool Rect::is_inner(const Rect& inner_rect) const {
        Rect r = *this;
        r.intersect(inner_rect);
        return r == inner_rect;
}

bool Rect::is_nearly_inner(const Rect& inner_rect, int delta) const {
        Rect r = *this;
        r.lx -= delta;
        r.ty -= delta;
        r.rx += delta;
        r.by += delta;
        r.intersect(inner_rect);
        return r == inner_rect;
}

bool Rect::is_crossed(const Rect& rect) const {
        Rect r = *this;
        r.intersect(rect);
        return !(r.empty());
}

void Rect::intersect(const Rect& r) {
        if (lx > r.rx) rx = lx;
        else if (rx < r.lx) lx = rx;
        else {
                lx = MAX(lx, r.lx);
                rx = MIN(rx, r.rx);
        }

        if (ty > r.by) by = ty;
        else if (by < r.ty) ty = by;
        else {
                ty = MAX(ty, r.ty);
                by = MIN(by, r.by);
        }
}

void Rect::join(const Rect& r) {
        lx = MIN(lx, r.lx);
        rx = MAX(rx, r.rx);
        ty = MIN(ty, r.ty);
        by = MAX(by, r.by);
}

void Rect::rmove(int add_x, int add_y) {
        lx += add_x;
        rx += add_x;
        ty += add_y;
        by += add_y;
}

void Rect::subtract(const Rect& rect, vector<Rect>& ret_array) const {
        Rect r = *this;
        r.intersect(rect);
        if (r.empty()) { // not intersect the rects
                ret_array.push_back(*this);
                return;
        }
        if (r ==*this) { // identical; no rect rests
                return;
        }
        // push top area
        if (ty != r.ty) {
                ret_array.push_back(Rect(lx, ty, rx, r.ty));
        }
        // push bottom area
        if (by != r.by) {
                ret_array.push_back(Rect(lx, r.by, rx, by));
        }
        // push left area
        if (lx != r.lx) {
                ret_array.push_back(Rect(lx, r.ty, r.lx, r.by));
        }
        // push right area
        if (rx != r.rx) {
                ret_array.push_back(Rect(r.rx, r.ty, rx, r.by));
        }
}