win32ss/gdi/eng/clip.c

   1 /*
   2  * COPYRIGHT:         See COPYING in the top level directory
   3  * PROJECT:           ReactOS kernel
   4  * PURPOSE:           GDI Clipping Functions
   5  * FILE:              win32ss/gdi/eng/clip.c
   6  * PROGRAMER:         Jason Filby
   7  */
   8
   9 #include <win32k.h>
  10 DBG_DEFAULT_CHANNEL(EngClip);
  11
  12
  13 static __inline int
  14 CompareRightDown(
  15     const RECTL *r1,
  16     const RECTL *r2)
  17 {
  18     int Cmp;
  19
  20     if (r1->top < r2->top)
  21     {
  22         Cmp = -1;
  23     }
  24     else if (r2->top < r1->top)
  25     {
  26         Cmp = +1;
  27     }
  28     else
  29     {
  30         ASSERT(r1->bottom == r2->bottom);
  31         if (r1->left < r2->left)
  32         {
  33             Cmp = -1;
  34         }
  35         else if (r2->left < r1->left)
  36         {
  37             Cmp = +1;
  38         }
  39         else
  40         {
  41             ASSERT(r1->right == r2->right);
  42             Cmp = 0;
  43         }
  44     }
  45
  46     return Cmp;
  47 }
  48
  49 static __inline int
  50 CompareRightUp(
  51     const RECTL *r1,
  52     const RECTL *r2)
  53 {
  54     int Cmp;
  55
  56     if (r1->bottom < r2->bottom)
  57     {
  58         Cmp = +1;
  59     }
  60     else if (r2->bottom < r1->bottom)
  61     {
  62         Cmp = -1;
  63     }
  64     else
  65     {
  66         ASSERT(r1->top == r2->top);
  67         if (r1->left < r2->left)
  68         {
  69             Cmp = -1;
  70         }
  71         else if (r2->left < r1->left)
  72         {
  73             Cmp = +1;
  74         }
  75         else
  76         {
  77             ASSERT(r1->right == r2->right);
  78             Cmp = 0;
  79         }
  80     }
  81
  82     return Cmp;
  83 }
  84
  85 static __inline int
  86 CompareLeftDown(
  87     const RECTL *r1,
  88     const RECTL *r2)
  89 {
  90     int Cmp;
  91
  92     if (r1->top < r2->top)
  93     {
  94         Cmp = -1;
  95     }
  96     else if (r2->top < r1->top)
  97     {
  98         Cmp = +1;
  99     }
 100     else
 101     {
 102         ASSERT(r1->bottom == r2->bottom);
 103         if (r1->right < r2->right)
 104         {
 105             Cmp = +1;
 106         }
 107         else if (r2->right < r1->right)
 108         {
 109             Cmp = -1;
 110         }
 111         else
 112         {
 113             ASSERT(r1->left == r2->left);
 114             Cmp = 0;
 115         }
 116     }
 117
 118     return Cmp;
 119 }
 120
 121 static __inline int
 122 CompareLeftUp(
 123     const RECTL *r1,
 124     const RECTL *r2)
 125 {
 126     int Cmp;
 127
 128     if (r1->bottom < r2->bottom)
 129     {
 130         Cmp = +1;
 131     }
 132     else if (r2->bottom < r1->bottom)
 133     {
 134         Cmp = -1;
 135     }
 136     else
 137     {
 138         ASSERT(r1->top == r2->top);
 139         if (r1->right < r2->right)
 140         {
 141             Cmp = +1;
 142         }
 143         else if (r2->right < r1->right)
 144         {
 145             Cmp = -1;
 146         }
 147         else
 148         {
 149             ASSERT(r1->left == r2->left);
 150             Cmp = 0;
 151         }
 152     }
 153     return Cmp;
 154 }
 155
 156 VOID
 157 FASTCALL
 158 IntEngInitClipObj(XCLIPOBJ *Clip)
 159 {
 160     Clip->Rects = &Clip->rclBounds;
 161 }
 162
 163 VOID FASTCALL
 164 IntEngFreeClipResources(XCLIPOBJ *Clip)
 165 {
 166     if (Clip->Rects != &Clip->rclBounds)
 167         EngFreeMem(Clip->Rects);
 168 }
 169
 170
 171 VOID
 172 FASTCALL
 173 IntEngUpdateClipRegion(
 174     XCLIPOBJ* Clip,
 175     ULONG count,
 176     const RECTL* pRect,
 177     const RECTL* rcBounds)
 178 {
 179     if(count > 1)
 180     {
 181         RECTL* NewRects = EngAllocMem(0, FIELD_OFFSET(ENUMRECTS, arcl[count]), GDITAG_CLIPOBJ);
 182
 183         if(NewRects != NULL)
 184         {
 185             Clip->RectCount = count;
 186             Clip->iDirection = CD_ANY;
 187             RtlCopyMemory(NewRects, pRect, count * sizeof(RECTL));
 188
 189             Clip->iDComplexity = DC_COMPLEX;
 190             Clip->iFComplexity = ((Clip->RectCount <= 4) ? FC_RECT4 : FC_COMPLEX);
 191             Clip->iMode = TC_RECTANGLES;
 192             Clip->rclBounds = *rcBounds;
 193
 194             if (Clip->Rects != &Clip->rclBounds)
 195                 EngFreeMem(Clip->Rects);
 196             Clip->Rects = NewRects;
 197         }
 198     }
 199     else
 200     {
 201         Clip->iDirection = CD_ANY;
 202
 203         Clip->iDComplexity = (((rcBounds->top == rcBounds->bottom) &&
 204                                      (rcBounds->left == rcBounds->right))
 205                                      ? DC_TRIVIAL : DC_RECT);
 206
 207         Clip->iFComplexity = FC_RECT;
 208         Clip->iMode = TC_RECTANGLES;
 209         Clip->rclBounds = *rcBounds;
 210         Clip->RectCount = 1;
 211         if (Clip->Rects != &Clip->rclBounds)
 212             EngFreeMem(Clip->Rects);
 213         Clip->Rects = &Clip->rclBounds;
 214     }
 215 }
 216
 217 /*
 218  * @implemented
 219  */
 220 CLIPOBJ *
 221 APIENTRY
 222 EngCreateClip(VOID)
 223 {
 224     XCLIPOBJ *Clip = EngAllocMem(FL_ZERO_MEMORY, sizeof(XCLIPOBJ), GDITAG_CLIPOBJ);
 225     if(Clip != NULL)
 226     {
 227         IntEngInitClipObj(Clip);
 228         TRACE("Created Clip Obj %p.\n", Clip);
 229         return (CLIPOBJ *)Clip;
 230     }
 231
 232     ERR("Clip object allocation failed!\n");
 233     return NULL;
 234 }
 235
 236 /*
 237  * @implemented
 238  */
 239 VOID
 240 APIENTRY
 241 EngDeleteClip(
 242     _In_ _Post_ptr_invalid_ CLIPOBJ *pco)
 243 {
 244     XCLIPOBJ* pxco = (XCLIPOBJ *)pco;
 245     TRACE("Deleting %p.\n", pco);
 246     IntEngFreeClipResources(pxco);
 247     EngFreeMem(pxco);
 248 }
 249
 250 /*
 251  * @implemented
 252  */
 253 ULONG
 254 APIENTRY
 255 CLIPOBJ_cEnumStart(
 256     _Inout_ CLIPOBJ *pco,
 257     _In_ BOOL bAll,
 258     _In_ ULONG iType,
 259     _In_ ULONG iDirection,
 260     _In_ ULONG cMaxRects)
 261 {
 262     XCLIPOBJ* Clip = (XCLIPOBJ *)pco;
 263     SORTCOMP CompareFunc;
 264
 265     Clip->bAll    = bAll;
 266     Clip->iType   = iType;
 267     Clip->EnumPos = 0;
 268     Clip->EnumMax = (cMaxRects > 0) ? cMaxRects : Clip->RectCount;
 269
 270     if (CD_ANY != iDirection && Clip->iDirection != iDirection)
 271     {
 272         switch (iDirection)
 273         {
 274             case CD_RIGHTDOWN:
 275                 CompareFunc = (SORTCOMP) CompareRightDown;
 276                 break;
 277
 278             case CD_RIGHTUP:
 279                 CompareFunc = (SORTCOMP) CompareRightUp;
 280                 break;
 281
 282             case CD_LEFTDOWN:
 283                 CompareFunc = (SORTCOMP) CompareLeftDown;
 284                 break;
 285
 286             case CD_LEFTUP:
 287                 CompareFunc = (SORTCOMP) CompareLeftUp;
 288                 break;
 289
 290             default:
 291                 ERR("Invalid iDirection %lu\n", iDirection);
 292                 iDirection = Clip->iDirection;
 293                 CompareFunc = NULL;
 294                 break;
 295         }
 296
 297         if (NULL != CompareFunc)
 298         {
 299             EngSort((PBYTE) Clip->Rects, sizeof(RECTL), Clip->RectCount, CompareFunc);
 300         }
 301
 302         Clip->iDirection = iDirection;
 303     }
 304
 305     /* Return the number of rectangles enumerated */
 306     if ((cMaxRects > 0) && (Clip->RectCount > cMaxRects))
 307     {
 308         return 0xFFFFFFFF;
 309     }
 310
 311     return Clip->RectCount;
 312 }
 313
 314 /*
 315  * @implemented
 316  */
 317 BOOL
 318 APIENTRY
 319 CLIPOBJ_bEnum(
 320     _In_ CLIPOBJ *pco,
 321     _In_ ULONG cj,
 322     _Out_bytecap_(cj) ULONG *pulEnumRects)
 323 {
 324     const RECTL* src;
 325     XCLIPOBJ* Clip = (XCLIPOBJ *)pco;
 326     ULONG nCopy;
 327     ENUMRECTS* pERects = (ENUMRECTS*)pulEnumRects;
 328
 329     // Calculate how many rectangles we should copy
 330     nCopy = min( Clip->EnumMax - Clip->EnumPos,
 331             min( Clip->RectCount - Clip->EnumPos,
 332             (cj - sizeof(ULONG)) / sizeof(RECTL)));
 333
 334     if(nCopy == 0)
 335     {
 336         return FALSE;
 337     }
 338
 339     /* Copy rectangles */
 340     src = &Clip->Rects[Clip->EnumPos];
 341     RtlCopyMemory(pERects->arcl, src, nCopy * sizeof(RECTL));
 342
 343     pERects->c = nCopy;
 344
 345     Clip->EnumPos+=nCopy;
 346
 347     return Clip->EnumPos < Clip->RectCount;
 348 }
 349
 350 /* EOF */