rect.h

Go to the documentation of this file.

#ifndef RECT_H
#define RECT_H

#ifdef _WINDOWS_
typedef RECT Rect;
typedef POINT XY;
#else
typedef struct
{
    int left;
    int top;
    int right;  /* One pixel beyond actual right edge */
    int bottom; /* One pixel beyond actual bottom edge */
} Rect;
typedef struct
{
    int x;
    int y;
} XY;
#endif

#define RectAutoXYWH(x,y,w,h)       { (x), (y), (x) + (w), (y) + (h) }

#define RectSetXYWH(r,x,y,w,h)      { (r).left = (x); (r).top = (y); (r).right = (x) + (w); (r).bottom = (y) + (h); }

#define RectAutoLTRB(l,t,r,b)       { (l), (t), (r), (b) }

#define RectSetLTRB(rc,l,t,r,b)     { (rc).left = (l); (rc).top = (t); (rc).right = (r); (rc).bottom = (b); }

#define RectAutoClear()             { 0,0,0,0 }

#define RectClear(r)                { (r).left = (r).top = (r).right = (r).bottom = 0; }

#define RectAutoMax()               { (-(int)(~0u>>2)),(-(int)(~0u>>2)), ((int)(~0u>>2)),((int)(~0u>>2)) }

#define RectSetMax(r)               { (r).left = (r).top = (-(int)(~0u>>2)); (r).right = (r).bottom = (int)(~0u>>2); }

#define RectEmpty(r)                ( RectWide(r) < 1 || RectHigh(r) < 1 )

#define RectWide(r)                 ((r).right - (r).left)

#define RectHigh(r)                 ((r).bottom - (r).top)

#define RectPtInRect(r,x,y)         ( (x)>=(r).left && (x)<(r).right && (y)>=(r).top && (y)<(r).bottom )

#define RectEqual(r1,r2)            ((r1).left == (r2).left && (r1).top == (r2).top && (r1).right == (r2).right && (r1).bottom == (r2).bottom )

#define RectInRect(r,r2)            (!RectOutside(r,r2))

#define RectOutside(r,r2)           ( ((r).left>=(r2).right) || ((r).right<=(r2).left) || ((r).top>=(r2).bottom) || ((r).bottom<=(r2).top) )

#define RectContainsRect(r,r2)      ( ((r2).left>=(r).left) && ((r2).top>=(r).top) && ((r2).right<=(r).right) && ((r2).bottom<=(r).bottom) )

#define RectCenterX(r)              (((r).left+(r).right)/2)

#define RectCenterY(r)              (((r).top+(r).bottom)/2)

#define RectCenterPt(r,x,y)         { (x)=RectCenterX(r); (y)=RectCenterY(r); }

#define RectSetWide(r,w)            ((r).right=(r).left+(w))

#define RectSetHigh(r,h)            ((r).bottom=(r).top+(h))

#define RectLeftTo(r,x)             {int _m_x = (x); int _m_tmp=RectWide(r); (r).left=_m_x; (r).right=_m_x+_m_tmp; }

#define RectTopTo(r,y)              {int _m_y = (y); int _m_tmp=RectHigh(r); (r).top=_m_y; (r).bottom=_m_y+_m_tmp; }

#define RectRightTo(r,x)            {int _m_x = (x); int _m_tmp=RectWide(r); (r).left=_m_x-_m_tmp;(r).right=_m_x;}

#define RectBottomTo(r,y)           {int _m_y = (y); int _m_tmp=RectHigh(r); (r).top=_m_y-_m_tmp;(r).bottom=_m_y;}

#define RectMove(r,x,y)             {RectLeftTo(r,x); RectTopTo(r,y);}

#define RectMoveBy(r,x,y)           { (r).left += (x); (r).right += (x); (r).top += (y); (r).bottom += (y); }

#define RectGrow(r,x,y)             { (r).left -= (x); (r).right += (x); (r).top -= (y); (r).bottom += (y); }

#define RectShrink(r,x,y)           { (r).left += (x); (r).right -= (x); (r).top += (y); (r).bottom -= (y); }

#define RectHAlign(r,pow2)          { const int rha_mask=~((pow2)-1); (r).left &= rha_mask; (r).right = ((r).right+~rha_mask) & rha_mask; }

#define RectVAlign(r,pow2)          { const int rha_mask=~((pow2)-1); (r).top &= rha_mask; (r).bottom = ((r).bottom+~rha_mask) & rha_mask; }

#define RectUnionRect(r,r2) \
    { \
        if(RectEmpty(r))\
        {\
            (r)=(r2);\
        }\
        else if(!RectEmpty(r2))\
        {\
            if( (r).left > (r2).left ) (r).left = (r2).left;\
            if( (r).top > (r2).top ) (r).top = (r2).top;\
            if( (r).right < (r2).right ) (r).right = (r2).right;\
            if( (r).bottom < (r2).bottom ) (r).bottom = (r2).bottom;\
        }\
    }

#define RectUnionPt(r,x,y)  \
    {\
        if(RectEmpty(r))\
        {\
            (r).left=(x);\
            (r).top=(y);\
            (r).right=(x)+1;\
            (r).bottom=(y)+1;\
        }\
        else\
        {\
            if( (r).left > (x) ) (r).left = (x);\
            if( (r).top > (y) ) (r).top = (y);\
            if( (r).right < (x) ) (r).right = (x);\
            if( (r).bottom < (y) ) (r).bottom = (y);\
        }\
    }

#define RectCenterOnX(r,x)          RectLeftTo(r,(x)-(RectWide(r)/2))

#define RectCenterOnY(r,y)          RectTopTo(r,(y)-(RectHigh(r)/2))

#define RectCenterOnPt(r,x,y)       { int _m_mx = (x)-(RectWide(r)/2); int _m_my = (y)-(RectHigh(r)/2); RectMove(r,_m_mx,_m_my); }

#define RectCenterOnRect(r,r2)      { int _m_x,_m_y; RectCenterPt(r2,_m_x,_m_y); RectCenterOnPt((r),_m_x,_m_y); }

#define RectIntRect(r,r2)           \
{\
    if( (r).left < (r2).left ) (r).left = (r2).left;\
    if( (r).top < (r2).top ) (r).top = (r2).top;\
    if( (r).right > (r2).right ) (r).right = (r2).right;\
    if( (r).bottom > (r2).bottom ) (r).bottom = (r2).bottom;\
}

#define RectBoundtoRect(r,rb)       \
{\
    if((r).right>(rb).right) \
        RectRightTo(r,(rb).right);\
    if( (r).bottom > (rb).bottom ) \
        RectBottomTo(r,(rb).bottom);\
    if( (r).left < (rb).left ) \
        RectLeftTo( r,(rb).left );\
    if( (r).top < (rb).top ) \
        RectTopTo( r,(rb).top );\
}


/*
 * Macro Structures For Initializing and Operating on Constants
 */

#define IXY_X(decl) IXY_X_##decl
#define     IXY_X_X(v)  (v)
#define     IXY_X_Y(v)
#define IXY_Y(decl) IXY_Y_##decl
#define     IXY_Y_X(v)  
#define     IXY_Y_Y(v)  (v)

#define ILTRB_L(decl)   ILTRB_L_##decl
#define     ILTRB_L_L(v)    (v)
#define     ILTRB_L_T(v)
#define     ILTRB_L_R(v)
#define     ILTRB_L_B(v)
#define ILTRB_T(decl)   ILTRB_T_##decl
#define     ILTRB_T_L(v)
#define     ILTRB_T_T(v)    (v)
#define     ILTRB_T_R(v)
#define     ILTRB_T_B(v)
#define ILTRB_R(decl)   ILTRB_R_##decl
#define     ILTRB_R_L(v)
#define     ILTRB_R_T(v)
#define     ILTRB_R_R(v)    (v)
#define     ILTRB_R_B(v)
#define ILTRB_B(decl)   ILTRB_B_##decl
#define     ILTRB_B_L(v)
#define     ILTRB_B_T(v)
#define     ILTRB_B_R(v)
#define     ILTRB_B_B(v)    (v)

#define ILTRB_WIDE(ir)              (ir(ILTRB_R)-ir(ILTRB_L))

#define ILTRB_HIGH(ir)              (ir(ILTRB_B)-ir(ILTRB_T))

#define ILTRB_CX(ir)                ((ir(ILTRB_L)+ir(ILTRB_R))/2)

#define ILTRB_CY(ir)                ((ir(ILTRB_T)+ir(ILTRB_B))/2)

#define ILTRB_SCALEX(ir,e,d)        (ir(ILTRB_L)+((e)*ILTRB_WIDE(ir))/(d)))

#define ILTRB_SCALEY(ir,e,d)        (ir(ILTRB_T)+((e)*ILTRB_HIGH(ir)/(d)))

#define XYIn_LTRB( xy, ir )         ( (xy).x >= ir(ILTRB_L) && (xy).x < ir(ILTRB_R) && (xy).y >= ir(ILTRB_T) && (xy).y < ir(ILTRB_B) )

#define PtIn_LTRB( x, y, ir )           ( (x) >= ir(ILTRB_L) && (x) < ir(ILTRB_R) && (y) >= ir(ILTRB_T) && (y) < ir(ILTRB_B) )

#define RectOutside_LTRB( r, ir )   ( ((r).left>=ir(ILTRB_R)) || ((r).right<=ir(ILTRB_L)) || ((r).top>=ir(ILTRB_B)) || ((r).bottom<=ir(ILTRB_T)) )

#define RectIn_LTRB( r, ir )        ( !RectOutside_LTRB( r, ir ) )

#define XY_AUTO_LT(ir)              { ir(ILTRB_L), ir(ILTRB_T) }
#define XY_AUTO_RB(ir)              { ir(ILTRB_R)-1, ir(ILTRB_B)-1 }
#define XY_AUTO_CTR(ir)             { ILTRB_CX(ir), ILTRB_CY(ir) }
#define XY_AUTO(ixy)                { ixy(IXY_X), ixy(IXY_Y) }
#define LTRB_AUTO(ir)               { ir(ILTRB_L), ir(ILTRB_T), ir(ILTRB_R), ir(ILTRB_B) }
#define LTRB_AUTO_IXY(ixy0,ixy1)    { ixy0(IXY_X), ixy0(IXY_Y), ixy1(IXY_X), ixy1(IXY_Y) }

#endif /* RECT_H */