subsystems/win32/win32k/objects/dcobjs.c

   1 /*
   2  * COPYRIGHT:         See COPYING in the top level directory
   3  * PROJECT:           ReactOS kernel
   4  * PURPOSE:           Functions for creation and destruction of DCs
   5  * FILE:              subsystem/win32/win32k/objects/dcobjs.c
   6  * PROGRAMER:         Timo Kreuzer (timo.kreuzer@rectos.org)
   7  */
   8
   9 #include <win32k.h>
  10
  11 #define NDEBUG
  12 #include <debug.h>
  13
  14 VOID
  15 FASTCALL
  16 DC_vUpdateFillBrush(PDC pdc)
  17 {
  18     PDC_ATTR pdcattr = pdc->pdcattr;
  19     PBRUSH pbrFill;
  20
  21     /* Check if the brush handle has changed */
  22     if (pdcattr->hbrush != pdc->dclevel.pbrFill->BaseObject.hHmgr)
  23     {
  24         /* Try to lock the new brush */
  25         pbrFill = BRUSH_ShareLockBrush(pdcattr->hbrush);
  26         if (pbrFill)
  27         {
  28             /* Unlock old brush, set new brush */
  29             BRUSH_ShareUnlockBrush(pdc->dclevel.pbrFill);
  30             pdc->dclevel.pbrFill = pbrFill;
  31
  32             /* Mark eboFill as dirty */
  33             pdcattr->ulDirty_ |= DIRTY_FILL;
  34         }
  35         else
  36         {
  37             /* Invalid brush handle, restore old one */
  38             pdcattr->hbrush = pdc->dclevel.pbrFill->BaseObject.hHmgr;
  39         }
  40     }
  41
  42     /* Check if the EBRUSHOBJ needs update */
  43     if (pdcattr->ulDirty_ & DIRTY_FILL)
  44     {
  45         /* Update eboFill */
  46         EBRUSHOBJ_vUpdate(&pdc->eboFill, pdc->dclevel.pbrFill, pdc);
  47     }
  48
  49     /* Check for DC brush */
  50     if (pdcattr->hbrush == StockObjects[DC_BRUSH])
  51     {
  52         /* ROS HACK, should use surf xlate */
  53         /* Update the eboFill's solid color */
  54         EBRUSHOBJ_vSetSolidBrushColor(&pdc->eboFill, pdcattr->crPenClr);
  55     }
  56
  57     /* Clear flags */
  58     pdcattr->ulDirty_ &= ~(DIRTY_FILL | DC_BRUSH_DIRTY);
  59 }
  60
  61 VOID
  62 FASTCALL
  63 DC_vUpdateLineBrush(PDC pdc)
  64 {
  65     PDC_ATTR pdcattr = pdc->pdcattr;
  66     PBRUSH pbrLine;
  67
  68     /* Check if the pen handle has changed */
  69     if (pdcattr->hpen != pdc->dclevel.pbrLine->BaseObject.hHmgr)
  70     {
  71         /* Try to lock the new pen */
  72         pbrLine = PEN_ShareLockPen(pdcattr->hpen);
  73         if (pbrLine)
  74         {
  75             /* Unlock old brush, set new brush */
  76             BRUSH_ShareUnlockBrush(pdc->dclevel.pbrLine);
  77             pdc->dclevel.pbrLine = pbrLine;
  78
  79             /* Mark eboLine as dirty */
  80             pdcattr->ulDirty_ |= DIRTY_LINE;
  81         }
  82         else
  83         {
  84             /* Invalid pen handle, restore old one */
  85             pdcattr->hpen = pdc->dclevel.pbrLine->BaseObject.hHmgr;
  86         }
  87     }
  88
  89     /* Check if the EBRUSHOBJ needs update */
  90     if (pdcattr->ulDirty_ & DIRTY_LINE)
  91     {
  92         /* Update eboLine */
  93         EBRUSHOBJ_vUpdate(&pdc->eboLine, pdc->dclevel.pbrLine, pdc);
  94     }
  95
  96     /* Check for DC pen */
  97     if (pdcattr->hpen == StockObjects[DC_PEN])
  98     {
  99         /* Update the eboLine's solid color */
 100         EBRUSHOBJ_vSetSolidBrushColor(&pdc->eboLine, pdcattr->crPenClr);
 101     }
 102
 103     /* Clear flags */
 104     pdcattr->ulDirty_ &= ~(DIRTY_LINE | DC_PEN_DIRTY);
 105 }
 106
 107 VOID
 108 FASTCALL
 109 DC_vUpdateTextBrush(PDC pdc)
 110 {
 111     PDC_ATTR pdcattr = pdc->pdcattr;
 112
 113     /* Timo : The text brush should never be changed.
 114      * Jérôme : Yeah, but its palette must be updated anyway! */
 115     if(pdcattr->ulDirty_ & DIRTY_TEXT)
 116         EBRUSHOBJ_vUpdate(&pdc->eboText, pbrDefaultBrush, pdc);
 117
 118     /* Update the eboText's solid color */
 119     EBRUSHOBJ_vSetSolidBrushColor(&pdc->eboText, pdcattr->crForegroundClr);
 120
 121     /* Clear flag */
 122     pdcattr->ulDirty_ &= ~DIRTY_TEXT;
 123 }
 124
 125 VOID
 126 FASTCALL
 127 DC_vUpdateBackgroundBrush(PDC pdc)
 128 {
 129     PDC_ATTR pdcattr = pdc->pdcattr;
 130
 131     if(pdcattr->ulDirty_ & DIRTY_BACKGROUND)
 132         EBRUSHOBJ_vUpdate(&pdc->eboBackground, pbrDefaultBrush, pdc);
 133
 134     /* Update the eboBackground's solid color */
 135     EBRUSHOBJ_vSetSolidBrushColor(&pdc->eboBackground, pdcattr->crBackgroundClr);
 136
 137     /* Clear flag */
 138     pdcattr->ulDirty_ &= ~DIRTY_BACKGROUND;
 139 }
 140
 141 HPALETTE
 142 FASTCALL
 143 GdiSelectPalette(
 144     HDC hDC,
 145     HPALETTE hpal,
 146     BOOL ForceBackground)
 147 {
 148     PDC pdc;
 149     HPALETTE oldPal = NULL;
 150     PPALETTE ppal;
 151
 152     // FIXME: mark the palette as a [fore\back]ground pal
 153     pdc = DC_LockDc(hDC);
 154     if (!pdc)
 155     {
 156         return NULL;
 157     }
 158
 159     /* Check if this is a valid palette handle */
 160     ppal = PALETTE_ShareLockPalette(hpal);
 161     if (!ppal)
 162     {
 163         DC_UnlockDc(pdc);
 164         return NULL;
 165     }
 166
 167     /* Is this a valid palette for this depth? */
 168         if ((BitsPerFormat(pdc->dclevel.pSurface->SurfObj.iBitmapFormat) <= 8
 169                                         && ppal->Mode == PAL_INDEXED) ||
 170                         (BitsPerFormat(pdc->dclevel.pSurface->SurfObj.iBitmapFormat) > 8))
 171     {
 172         /* Get old palette, set new one */
 173         oldPal = pdc->dclevel.hpal;
 174         pdc->dclevel.hpal = hpal;
 175         DC_vSelectPalette(pdc, ppal);
 176
 177         /* Mark the brushes invalid */
 178         pdc->pdcattr->ulDirty_ |= DIRTY_FILL | DIRTY_LINE |
 179                                   DIRTY_BACKGROUND | DIRTY_TEXT;
 180     }
 181
 182     PALETTE_ShareUnlockPalette(ppal);
 183     DC_UnlockDc(pdc);
 184
 185     return oldPal;
 186 }
 187
 188  /*
 189  * @implemented
 190  */
 191 HBRUSH
 192 APIENTRY
 193 NtGdiSelectBrush(
 194     IN HDC hDC,
 195     IN HBRUSH hBrush)
 196 {
 197     PDC pDC;
 198     HBRUSH hOrgBrush;
 199
 200     if (hDC == NULL || hBrush == NULL) return NULL;
 201
 202     pDC = DC_LockDc(hDC);
 203     if (!pDC)
 204     {
 205         return NULL;
 206     }
 207
 208     /* Simply return the user mode value, without checking */
 209     hOrgBrush = pDC->pdcattr->hbrush;
 210     pDC->pdcattr->hbrush = hBrush;
 211     DC_vUpdateFillBrush(pDC);
 212
 213     DC_UnlockDc(pDC);
 214
 215     return hOrgBrush;
 216 }
 217
 218  /*
 219  * @implemented
 220  */
 221 HPEN
 222 APIENTRY
 223 NtGdiSelectPen(
 224     IN HDC hDC,
 225     IN HPEN hPen)
 226 {
 227     PDC pDC;
 228     HPEN hOrgPen;
 229
 230     if (hDC == NULL || hPen == NULL) return NULL;
 231
 232     pDC = DC_LockDc(hDC);
 233     if (!pDC)
 234     {
 235         return NULL;
 236     }
 237
 238     /* Simply return the user mode value, without checking */
 239     hOrgPen = pDC->pdcattr->hpen;
 240     pDC->pdcattr->hpen = hPen;
 241     DC_vUpdateLineBrush(pDC);
 242
 243     DC_UnlockDc(pDC);
 244
 245     return hOrgPen;
 246 }
 247
 248 /*
 249  * @implemented
 250  */
 251 HBITMAP
 252 APIENTRY
 253 NtGdiSelectBitmap(
 254     IN HDC hDC,
 255     IN HBITMAP hBmp)
 256 {
 257     PDC pDC;
 258     PDC_ATTR pdcattr;
 259     HBITMAP hOrgBmp;
 260     PSURFACE psurfBmp, psurfOld;
 261     HRGN hVisRgn;
 262
 263     if (hDC == NULL || hBmp == NULL) return NULL;
 264
 265     pDC = DC_LockDc(hDC);
 266     if (!pDC)
 267     {
 268         return NULL;
 269     }
 270     pdcattr = pDC->pdcattr;
 271
 272     /* must be memory dc to select bitmap */
 273     if (pDC->dctype != DC_TYPE_MEMORY)
 274     {
 275         DC_UnlockDc(pDC);
 276         return NULL;
 277     }
 278
 279     psurfBmp = SURFACE_LockSurface(hBmp);
 280     if (!psurfBmp)
 281     {
 282         DC_UnlockDc(pDC);
 283         return NULL;
 284     }
 285
 286     /* Get the handle for the old bitmap */
 287     psurfOld = pDC->dclevel.pSurface;
 288     hOrgBmp = psurfOld ? psurfOld->BaseObject.hHmgr : NULL;
 289
 290     /* Release the old bitmap, reference the new */
 291     DC_vSelectSurface(pDC, psurfBmp);
 292
 293     // If Info DC this is zero and pSurface is moved to DC->pSurfInfo.
 294     psurfBmp->hdc = hDC;
 295
 296     /* FIXME; improve by using a region without a handle and selecting it */
 297     hVisRgn = IntSysCreateRectRgn( 0,
 298                                    0,
 299                                    psurfBmp->SurfObj.sizlBitmap.cx,
 300                                    psurfBmp->SurfObj.sizlBitmap.cy);
 301
 302     if(psurfBmp->hSecure)
 303     {
 304         /* Set DIBSECTION attribute */
 305         pdcattr->ulDirty_ |= DC_DIBSECTION;
 306     }
 307     else
 308     {
 309         pdcattr->ulDirty_ &= ~DC_DIBSECTION;
 310     }
 311
 312     /* Release the exclusive lock */
 313     SURFACE_UnlockSurface(psurfBmp);
 314
 315     /* Mark the brushes invalid */
 316     pdcattr->ulDirty_ |= DIRTY_FILL | DIRTY_LINE;
 317
 318     DC_UnlockDc(pDC);
 319
 320     if (hVisRgn)
 321     {
 322         GdiSelectVisRgn(hDC, hVisRgn);
 323         REGION_FreeRgnByHandle(hVisRgn);
 324     }
 325
 326     return hOrgBmp;
 327 }
 328
 329
 330 BOOL
 331 APIENTRY
 332 NtGdiSelectClipPath(
 333     HDC hDC,
 334     int Mode)
 335 {
 336     HRGN  hrgnPath;
 337     PPATH pPath;
 338     BOOL  success = FALSE;
 339     PDC_ATTR pdcattr;
 340     PDC pdc;
 341
 342     pdc = DC_LockDc(hDC);
 343     if (!pdc)
 344     {
 345         SetLastWin32Error(ERROR_INVALID_PARAMETER);
 346         return FALSE;
 347     }
 348     pdcattr = pdc->pdcattr;
 349
 350     pPath = PATH_LockPath(pdc->dclevel.hPath);
 351     if (!pPath)
 352     {
 353         DC_UnlockDc(pdc);
 354         return FALSE;
 355     }
 356
 357     /* Check that path is closed */
 358     if (pPath->state != PATH_Closed)
 359     {
 360         SetLastWin32Error(ERROR_CAN_NOT_COMPLETE);
 361         DC_UnlockDc(pdc);
 362         return FALSE;
 363     }
 364
 365     /* Construct a region from the path */
 366     else if (PATH_PathToRegion(pPath, pdcattr->jFillMode, &hrgnPath))
 367     {
 368         success = GdiExtSelectClipRgn(pdc, hrgnPath, Mode) != ERROR;
 369         GreDeleteObject( hrgnPath );
 370
 371         /* Empty the path */
 372         if (success)
 373             PATH_EmptyPath(pPath);
 374
 375         /* FIXME: Should this function delete the path even if it failed? */
 376     }
 377
 378     PATH_UnlockPath(pPath);
 379     DC_UnlockDc(pdc);
 380
 381     return success;
 382 }
 383
 384 HANDLE
 385 APIENTRY
 386 NtGdiGetDCObject(HDC hDC, INT ObjectType)
 387 {
 388     HGDIOBJ SelObject;
 389     DC *pdc;
 390     PDC_ATTR pdcattr;
 391
 392     /* From Wine: GetCurrentObject does not SetLastError() on a null object */
 393     if(!hDC) return NULL;
 394
 395     if(!(pdc = DC_LockDc(hDC)))
 396     {
 397         SetLastWin32Error(ERROR_INVALID_HANDLE);
 398         return NULL;
 399     }
 400     pdcattr = pdc->pdcattr;
 401
 402     if (pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
 403         DC_vUpdateFillBrush(pdc);
 404
 405     if (pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
 406         DC_vUpdateLineBrush(pdc);
 407
 408     switch(ObjectType)
 409     {
 410         case GDI_OBJECT_TYPE_EXTPEN:
 411         case GDI_OBJECT_TYPE_PEN:
 412             SelObject = pdcattr->hpen;
 413             break;
 414
 415         case GDI_OBJECT_TYPE_BRUSH:
 416             SelObject = pdcattr->hbrush;
 417             break;
 418
 419         case GDI_OBJECT_TYPE_PALETTE:
 420             SelObject = pdc->dclevel.hpal;
 421             break;
 422
 423         case GDI_OBJECT_TYPE_FONT:
 424             SelObject = pdcattr->hlfntNew;
 425             break;
 426
 427         case GDI_OBJECT_TYPE_BITMAP:
 428         {
 429             SURFACE *psurf = pdc->dclevel.pSurface;
 430             SelObject = psurf ? psurf->BaseObject.hHmgr : NULL;
 431             break;
 432         }
 433
 434         case GDI_OBJECT_TYPE_COLORSPACE:
 435             DPRINT1("FIXME: NtGdiGetCurrentObject() ObjectType OBJ_COLORSPACE not supported yet!\n");
 436             // SelObject = dc->dclevel.pColorSpace.BaseObject.hHmgr; ?
 437             SelObject = NULL;
 438             break;
 439
 440         default:
 441             SelObject = NULL;
 442             SetLastWin32Error(ERROR_INVALID_PARAMETER);
 443             break;
 444     }
 445
 446     DC_UnlockDc(pdc);
 447     return SelObject;
 448 }
 449
 450 ULONG
 451 APIENTRY
 452 NtGdiEnumObjects(
 453     IN HDC hdc,
 454     IN INT iObjectType,
 455     IN ULONG cjBuf,
 456     OUT OPTIONAL PVOID pvBuf)
 457 {
 458     UNIMPLEMENTED;
 459     return 0;
 460 }
 461