windows/rect.c

   1 /*
   2  * Rectangle-related functions
   3  *
   4  * Copyright 1993, 1996 Alexandre Julliard
   5  *
   6  */
   7
   8 #include "windef.h"
   9 #include "wingdi.h"
  10 #include "wine/winuser16.h"
  11 #include "winuser.h"
  12
  13 /***********************************************************************
  14  *              SetRect (USER.72)
  15  */
  16 void WINAPI SetRect16( LPRECT16 rect, INT16 left, INT16 top,
  17                        INT16 right, INT16 bottom )
  18 {
  19     rect->left   = left;
  20     rect->right  = right;
  21     rect->top    = top;
  22     rect->bottom = bottom;
  23 }
  24
  25
  26 /***********************************************************************
  27  *              SetRect (USER32.@)
  28  */
  29 BOOL WINAPI SetRect( LPRECT rect, INT left, INT top,
  30                        INT right, INT bottom )
  31 {
  32     if (!rect) return FALSE;
  33     rect->left   = left;
  34     rect->right  = right;
  35     rect->top    = top;
  36     rect->bottom = bottom;
  37     return TRUE;
  38 }
  39
  40
  41 /***********************************************************************
  42  *              SetRectEmpty (USER.73)
  43  */
  44 void WINAPI SetRectEmpty16( LPRECT16 rect )
  45 {
  46     rect->left = rect->right = rect->top = rect->bottom = 0;
  47 }
  48
  49
  50 /***********************************************************************
  51  *              SetRectEmpty (USER32.@)
  52  */
  53 BOOL WINAPI SetRectEmpty( LPRECT rect )
  54 {
  55     if (!rect) return FALSE;
  56     rect->left = rect->right = rect->top = rect->bottom = 0;
  57     return TRUE;
  58 }
  59
  60
  61 /***********************************************************************
  62  *              CopyRect (USER.74)
  63  */
  64 BOOL16 WINAPI CopyRect16( RECT16 *dest, const RECT16 *src )
  65 {
  66     *dest = *src;
  67     return TRUE;
  68 }
  69
  70
  71 /***********************************************************************
  72  *              CopyRect (USER32.@)
  73  */
  74 BOOL WINAPI CopyRect( RECT *dest, const RECT *src )
  75 {
  76     if (!dest || !src)
  77         return FALSE;
  78     *dest = *src;
  79     return TRUE;
  80 }
  81
  82
  83 /***********************************************************************
  84  *              IsRectEmpty (USER.75)
  85  *
  86  * Bug compat: Windows checks for 0 or negative width/height.
  87  */
  88 BOOL16 WINAPI IsRectEmpty16( const RECT16 *rect )
  89 {
  90     return ((rect->left >= rect->right) || (rect->top >= rect->bottom));
  91 }
  92
  93
  94 /***********************************************************************
  95  *              IsRectEmpty (USER32.@)
  96  *
  97  * Bug compat: Windows checks for 0 or negative width/height.
  98  */
  99 BOOL WINAPI IsRectEmpty( const RECT *rect )
 100 {
 101     if (!rect) return TRUE;
 102     return ((rect->left >= rect->right) || (rect->top >= rect->bottom));
 103 }
 104
 105
 106 /***********************************************************************
 107  *              PtInRect (USER.76)
 108  */
 109 BOOL16 WINAPI PtInRect16( const RECT16 *rect, POINT16 pt )
 110 {
 111     return ((pt.x >= rect->left) && (pt.x < rect->right) &&
 112             (pt.y >= rect->top) && (pt.y < rect->bottom));
 113 }
 114
 115
 116 /***********************************************************************
 117  *              PtInRect (USER32.@)
 118  */
 119 BOOL WINAPI PtInRect( const RECT *rect, POINT pt )
 120 {
 121     if (!rect) return FALSE;
 122     return ((pt.x >= rect->left) && (pt.x < rect->right) &&
 123             (pt.y >= rect->top) && (pt.y < rect->bottom));
 124 }
 125
 126
 127 /***********************************************************************
 128  *              OffsetRect (USER.77)
 129  */
 130 void WINAPI OffsetRect16( LPRECT16 rect, INT16 x, INT16 y )
 131 {
 132     rect->left   += x;
 133     rect->right  += x;
 134     rect->top    += y;
 135     rect->bottom += y;
 136 }
 137
 138
 139 /***********************************************************************
 140  *              OffsetRect (USER32.@)
 141  */
 142 BOOL WINAPI OffsetRect( LPRECT rect, INT x, INT y )
 143 {
 144     if (!rect) return FALSE;
 145     rect->left   += x;
 146     rect->right  += x;
 147     rect->top    += y;
 148     rect->bottom += y;
 149     return TRUE;
 150 }
 151
 152
 153 /***********************************************************************
 154  *              InflateRect (USER.78)
 155  */
 156 void WINAPI InflateRect16( LPRECT16 rect, INT16 x, INT16 y )
 157 {
 158     rect->left   -= x;
 159     rect->top    -= y;
 160     rect->right  += x;
 161     rect->bottom += y;
 162 }
 163
 164
 165 /***********************************************************************
 166  *              InflateRect (USER32.@)
 167  */
 168 BOOL WINAPI InflateRect( LPRECT rect, INT x, INT y )
 169 {
 170     if (!rect) return FALSE;
 171     rect->left   -= x;
 172     rect->top    -= y;
 173     rect->right  += x;
 174     rect->bottom += y;
 175     return TRUE;
 176 }
 177
 178
 179 /***********************************************************************
 180  *              IntersectRect (USER.79)
 181  */
 182 BOOL16 WINAPI IntersectRect16( LPRECT16 dest, const RECT16 *src1,
 183                                const RECT16 *src2 )
 184 {
 185     if (IsRectEmpty16(src1) || IsRectEmpty16(src2) ||
 186         (src1->left >= src2->right) || (src2->left >= src1->right) ||
 187         (src1->top >= src2->bottom) || (src2->top >= src1->bottom))
 188     {
 189         SetRectEmpty16( dest );
 190         return FALSE;
 191     }
 192     dest->left   = max( src1->left, src2->left );
 193     dest->right  = min( src1->right, src2->right );
 194     dest->top    = max( src1->top, src2->top );
 195     dest->bottom = min( src1->bottom, src2->bottom );
 196     return TRUE;
 197 }
 198
 199
 200 /***********************************************************************
 201  *              IntersectRect (USER32.@)
 202  */
 203 BOOL WINAPI IntersectRect( LPRECT dest, const RECT *src1,
 204                                const RECT *src2 )
 205 {
 206     if (!dest || !src1 || !src2) return FALSE;
 207     if (IsRectEmpty(src1) || IsRectEmpty(src2) ||
 208         (src1->left >= src2->right) || (src2->left >= src1->right) ||
 209         (src1->top >= src2->bottom) || (src2->top >= src1->bottom))
 210     {
 211         SetRectEmpty( dest );
 212         return FALSE;
 213     }
 214     dest->left   = max( src1->left, src2->left );
 215     dest->right  = min( src1->right, src2->right );
 216     dest->top    = max( src1->top, src2->top );
 217     dest->bottom = min( src1->bottom, src2->bottom );
 218     return TRUE;
 219 }
 220
 221
 222 /***********************************************************************
 223  *              UnionRect (USER.80)
 224  */
 225 BOOL16 WINAPI UnionRect16( LPRECT16 dest, const RECT16 *src1,
 226                            const RECT16 *src2 )
 227 {
 228     if (IsRectEmpty16(src1))
 229     {
 230         if (IsRectEmpty16(src2))
 231         {
 232             SetRectEmpty16( dest );
 233             return FALSE;
 234         }
 235         else *dest = *src2;
 236     }
 237     else
 238     {
 239         if (IsRectEmpty16(src2)) *dest = *src1;
 240         else
 241         {
 242             dest->left   = min( src1->left, src2->left );
 243             dest->right  = max( src1->right, src2->right );
 244             dest->top    = min( src1->top, src2->top );
 245             dest->bottom = max( src1->bottom, src2->bottom );
 246         }
 247     }
 248     return TRUE;
 249 }
 250
 251
 252 /***********************************************************************
 253  *              UnionRect (USER32.@)
 254  */
 255 BOOL WINAPI UnionRect( LPRECT dest, const RECT *src1,
 256                            const RECT *src2 )
 257 {
 258     if (!dest) return FALSE;
 259     if (IsRectEmpty(src1))
 260     {
 261         if (IsRectEmpty(src2))
 262         {
 263             SetRectEmpty( dest );
 264             return FALSE;
 265         }
 266         else *dest = *src2;
 267     }
 268     else
 269     {
 270         if (IsRectEmpty(src2)) *dest = *src1;
 271         else
 272         {
 273             dest->left   = min( src1->left, src2->left );
 274             dest->right  = max( src1->right, src2->right );
 275             dest->top    = min( src1->top, src2->top );
 276             dest->bottom = max( src1->bottom, src2->bottom );
 277         }
 278     }
 279     return TRUE;
 280 }
 281
 282
 283 /***********************************************************************
 284  *              EqualRect (USER.244)
 285  */
 286 BOOL16 WINAPI EqualRect16( const RECT16* rect1, const RECT16* rect2 )
 287 {
 288     return ((rect1->left == rect2->left) && (rect1->right == rect2->right) &&
 289             (rect1->top == rect2->top) && (rect1->bottom == rect2->bottom));
 290 }
 291
 292
 293 /***********************************************************************
 294  *              EqualRect (USER32.@)
 295  */
 296 BOOL WINAPI EqualRect( const RECT* rect1, const RECT* rect2 )
 297 {
 298     if (!rect1 || !rect2) return FALSE;
 299     return ((rect1->left == rect2->left) && (rect1->right == rect2->right) &&
 300             (rect1->top == rect2->top) && (rect1->bottom == rect2->bottom));
 301 }
 302
 303
 304 /***********************************************************************
 305  *              SubtractRect (USER.373)
 306  */
 307 BOOL16 WINAPI SubtractRect16( LPRECT16 dest, const RECT16 *src1,
 308                               const RECT16 *src2 )
 309 {
 310     RECT16 tmp;
 311
 312     if (IsRectEmpty16( src1 ))
 313     {
 314         SetRectEmpty16( dest );
 315         return FALSE;
 316     }
 317     *dest = *src1;
 318     if (IntersectRect16( &tmp, src1, src2 ))
 319     {
 320         if (EqualRect16( &tmp, dest ))
 321         {
 322             SetRectEmpty16( dest );
 323             return FALSE;
 324         }
 325         if ((tmp.top == dest->top) && (tmp.bottom == dest->bottom))
 326         {
 327             if (tmp.left == dest->left) dest->left = tmp.right;
 328             else if (tmp.right == dest->right) dest->right = tmp.left;
 329         }
 330         else if ((tmp.left == dest->left) && (tmp.right == dest->right))
 331         {
 332             if (tmp.top == dest->top) dest->top = tmp.bottom;
 333             else if (tmp.bottom == dest->bottom) dest->bottom = tmp.top;
 334         }
 335     }
 336     return TRUE;
 337 }
 338
 339
 340 /***********************************************************************
 341  *              SubtractRect (USER32.@)
 342  */
 343 BOOL WINAPI SubtractRect( LPRECT dest, const RECT *src1,
 344                               const RECT *src2 )
 345 {
 346     RECT tmp;
 347
 348     if (!dest) return FALSE;
 349     if (IsRectEmpty( src1 ))
 350     {
 351         SetRectEmpty( dest );
 352         return FALSE;
 353     }
 354     *dest = *src1;
 355     if (IntersectRect( &tmp, src1, src2 ))
 356     {
 357         if (EqualRect( &tmp, dest ))
 358         {
 359             SetRectEmpty( dest );
 360             return FALSE;
 361         }
 362         if ((tmp.top == dest->top) && (tmp.bottom == dest->bottom))
 363         {
 364             if (tmp.left == dest->left) dest->left = tmp.right;
 365             else if (tmp.right == dest->right) dest->right = tmp.left;
 366         }
 367         else if ((tmp.left == dest->left) && (tmp.right == dest->right))
 368         {
 369             if (tmp.top == dest->top) dest->top = tmp.bottom;
 370             else if (tmp.bottom == dest->bottom) dest->bottom = tmp.top;
 371         }
 372     }
 373     return TRUE;
 374 }