GRect.h

/*
    \file
    \author Matthew Allen
    \date 22/8/1997
*/

#ifndef __GDCREGION_H
#define __GDCREGION_H

#if defined WIN32

    #define CornerOffset 1
    typedef RECT OsRect;

#elif defined BEOS

    #define CornerOffset 0
    typedef BRect OsRect;

#elif defined ATHEOS

    #include <gui/rect.h>
    #define CornerOffset 0
    typedef os::Rect OsRect;

#elif defined MAC

    #define CornerOffset 0
    typedef Rect OsRect;

#else

    // Implement as required
    #define CornerOffset 0
    struct OsRect
    {
        int left, right, top, bottom;
    };

#endif

class LgiClass GRect
{
    friend LgiClass bool operator ==(GRect &a, GRect &b);
    friend LgiClass bool operator !=(GRect &a, GRect &b);

public:
    int x1, y1, x2, y2;

    GRect() {}
    GRect(int X1, int Y1, int X2, int Y2)
    {
        x1 = X1;
        x2 = X2;
        y1 = Y1;
        y2 = Y2;
    }

    GRect(GRect *r)
    {
        x1 = r->x1;
        x2 = r->x2;
        y1 = r->y1;
        y2 = r->y2;
    }

    int X() { return x2 - x1 + 1; }
    
    int Y() { return y2 - y1 + 1; }
    
    void Set(int X1, int Y1, int X2, int Y2)
    {
        x1 = X1;
        x2 = X2;
        y1 = Y1;
        y2 = Y2;
    }

    void ZOff(int x, int y);
    
    void Normal();
    
    bool Valid();
    
    void Offset(int x, int y);
    
    void Offset(GRect *a);
    
    void Size(int x, int y);

    void Size(GRect *a);

    void Dimension(int x, int y);

    void Dimension(GRect *a);

    void Bound(GRect *b);

    bool Overlap(int x, int y);

    bool Overlap(GRect *b);
    
    void Union(int x, int y);

    void Union(GRect *a);

    void Union(GRect *a, GRect *b);

    void Intersection(GRect *a);

    void Intersection(GRect *a, GRect *b);

    char *GetStr();
    char *Describe() { return GetStr(); }

    bool SetStr(char *s);

    operator OsRect()
    {
        OsRect r;

        r.left = x1;
        r.top = y1;
        r.right = x2+CornerOffset;
        r.bottom = y2+CornerOffset;

        return r;
    }

    GRect &operator =(const GRect &r);  
    
    GRect &operator =(OsRect &r)
    {
        x1 = (int) r.left;
        y1 = (int) r.top;
        x2 = (int) r.right - CornerOffset;
        y2 = (int) r.bottom - CornerOffset;
        return *this;
    }

    GRect(OsRect r)
    {
        x1 = (int) r.left;
        y1 = (int) r.top;
        x2 = (int) r.right - CornerOffset;
        y2 = (int) r.bottom - CornerOffset;
    }
    
    #ifdef MAC
    GRect &operator =(HIRect &r)
    {
        x1 = (int)r.origin.x;
        y1 = (int)r.origin.y;
        x2 = x1 + (int)r.size.width - 1;
        y2 = y1 + (int)r.size.height - 1;
        return *this;
    }
    #endif
};

LgiClass bool operator ==(GRect &a, GRect &b);
LgiClass bool operator !=(GRect &a, GRect &b);

class LgiClass GRegion : public GRect
{
    int Size;
    int Alloc;
    int Current;
    GRect *a;

    bool SetSize(int s);
    GRect *NewOne() { return (SetSize(Size+1)) ? a+(Size-1) : 0; }
    bool Delete(int i);

public:
    GRegion();
    GRegion(int X1, int Y1, int X2, int Y2);
    GRegion(GRect &r);
    GRegion(OsRect &r);
    GRegion(GRegion &c);
    ~GRegion();

    int X() { return x2 - x1 + 1; }
    int Y() { return y2 - y1 + 1; }
    int Length() { return Size; }
    GRect *operator [](int i) { return (i >= 0 AND i < Size) ? a+i : 0; }
    GRect *First();
    GRect *Last();
    GRect *Next();
    GRect *Prev();

    void Empty();
    void ZOff(int x, int y);
    void Normal();
    bool Valid();
    void Offset(int x, int y);
    void Bound(GRect *b);
    GRect Bound();
    bool Overlap(GRect *b);
    bool Overlap(int x, int y);
    
    void Union(GRect *a);
    void Intersect(GRect *a);
    void Subtract(GRect *a);

    friend bool operator ==(GRegion &a, GRegion &b);
    friend bool operator !=(GRegion &a, GRegion &b);
};

#endif

---