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     if(pdcattr->ulDirty_ & DIRTY_TEXT)
 114         EBRUSHOBJ_vUpdate(&pdc->eboText, pdc->eboText.pbrush, pdc);
 115
 116     /* Update the eboText's solid color */
 117     EBRUSHOBJ_vSetSolidBrushColor(&pdc->eboText, pdcattr->crForegroundClr);
 118
 119     /* Clear flag */
 120     pdcattr->ulDirty_ &= ~DIRTY_TEXT;
 121 }
 122
 123 VOID
 124 FASTCALL
 125 DC_vUpdateBackgroundBrush(PDC pdc)
 126 {
 127     PDC_ATTR pdcattr = pdc->pdcattr;
 128
 129     if(pdcattr->ulDirty_ & DIRTY_BACKGROUND)
 130         EBRUSHOBJ_vUpdate(&pdc->eboBackground, pdc->eboBackground.pbrush, pdc);
 131
 132     /* Update the eboBackground's solid color */
 133     EBRUSHOBJ_vSetSolidBrushColor(&pdc->eboBackground, pdcattr->crBackgroundClr);
 134
 135     /* Clear flag */
 136     pdcattr->ulDirty_ &= ~DIRTY_BACKGROUND;
 137 }
 138
 139 HPALETTE
 140 FASTCALL
 141 GdiSelectPalette(
 142     HDC hDC,
 143     HPALETTE hpal,
 144     BOOL ForceBackground)
 145 {
 146     PDC pdc;
 147     HPALETTE oldPal = NULL;
 148     PPALETTE ppal;
 149
 150     // FIXME: mark the palette as a [fore\back]ground pal
 151     pdc = DC_LockDc(hDC);
 152     if (!pdc)
 153     {
 154         return NULL;
 155     }
 156
 157     /* Check if this is a valid palette handle */
 158     ppal = PALETTE_ShareLockPalette(hpal);
 159     if (!ppal)
 160     {
 161         DC_UnlockDc(pdc);
 162         return NULL;
 163     }
 164
 165     // FIXME: This looks wrong
 166     /* Is this a valid palette for this depth? */
 167     if ((pdc->rosdc.bitsPerPixel <= 8 && ppal->Mode == PAL_INDEXED) ||
 168         (pdc->rosdc.bitsPerPixel > 8))
 169     {
 170         /* Get old palette, set new one */
 171         oldPal = pdc->dclevel.hpal;
 172         pdc->dclevel.hpal = hpal;
 173         DC_vSelectPalette(pdc, ppal);
 174
 175         /* Mark the brushes invalid */
 176         pdc->pdcattr->ulDirty_ |= DIRTY_FILL | DIRTY_LINE |
 177                                   DIRTY_BACKGROUND | DIRTY_TEXT;
 178     }
 179
 180     PALETTE_ShareUnlockPalette(ppal);
 181     DC_UnlockDc(pdc);
 182
 183     return oldPal;
 184 }
 185
 186  /*
 187  * @implemented
 188  */
 189 HBRUSH
 190 APIENTRY
 191 NtGdiSelectBrush(
 192     IN HDC hDC,
 193     IN HBRUSH hBrush)
 194 {
 195     PDC pDC;
 196     HBRUSH hOrgBrush;
 197
 198     if (hDC == NULL || hBrush == NULL) return NULL;
 199
 200     pDC = DC_LockDc(hDC);
 201     if (!pDC)
 202     {
 203         return NULL;
 204     }
 205
 206     /* Simply return the user mode value, without checking */
 207     hOrgBrush = pDC->pdcattr->hbrush;
 208     pDC->pdcattr->hbrush = hBrush;
 209     DC_vUpdateFillBrush(pDC);
 210
 211     DC_UnlockDc(pDC);
 212
 213     return hOrgBrush;
 214 }
 215
 216  /*
 217  * @implemented
 218  */
 219 HPEN
 220 APIENTRY
 221 NtGdiSelectPen(
 222     IN HDC hDC,
 223     IN HPEN hPen)
 224 {
 225     PDC pDC;
 226     HPEN hOrgPen;
 227
 228     if (hDC == NULL || hPen == NULL) return NULL;
 229
 230     pDC = DC_LockDc(hDC);
 231     if (!pDC)
 232     {
 233         return NULL;
 234     }
 235
 236     /* Simply return the user mode value, without checking */
 237     hOrgPen = pDC->pdcattr->hpen;
 238     pDC->pdcattr->hpen = hPen;
 239     DC_vUpdateLineBrush(pDC);
 240
 241     DC_UnlockDc(pDC);
 242
 243     return hOrgPen;
 244 }
 245
 246 /*
 247  * @implemented
 248  */
 249 HBITMAP
 250 APIENTRY
 251 NtGdiSelectBitmap(
 252     IN HDC hDC,
 253     IN HBITMAP hBmp)
 254 {
 255     PDC pDC;
 256     PDC_ATTR pdcattr;
 257     HBITMAP hOrgBmp;
 258     PSURFACE psurfBmp, psurfOld;
 259     HRGN hVisRgn;
 260
 261     if (hDC == NULL || hBmp == NULL) return NULL;
 262
 263     pDC = DC_LockDc(hDC);
 264     if (!pDC)
 265     {
 266         return NULL;
 267     }
 268     pdcattr = pDC->pdcattr;
 269
 270     /* must be memory dc to select bitmap */
 271     if (pDC->dctype != DC_TYPE_MEMORY)
 272     {
 273         DC_UnlockDc(pDC);
 274         return NULL;
 275     }
 276
 277     psurfBmp = SURFACE_LockSurface(hBmp);
 278     if (!psurfBmp)
 279     {
 280         DC_UnlockDc(pDC);
 281         return NULL;
 282     }
 283
 284     /* Get the handle for the old bitmap */
 285     psurfOld = pDC->dclevel.pSurface;
 286     hOrgBmp = psurfOld ? psurfOld->BaseObject.hHmgr : NULL;
 287
 288     /* Release the old bitmap, reference the new */
 289     DC_vSelectSurface(pDC, psurfBmp);
 290
 291     // If Info DC this is zero and pSurface is moved to DC->pSurfInfo.
 292     psurfBmp->hDC = hDC;
 293
 294     // if we're working with a DIB, get the palette
 295     // [fixme: only create if the selected palette is null]
 296     if (psurfBmp->hSecure)
 297     {
 298 //        pDC->rosdc.bitsPerPixel = psurfBmp->dib->dsBmih.biBitCount; ???
 299         pDC->rosdc.bitsPerPixel = BitsPerFormat(psurfBmp->SurfObj.iBitmapFormat);
 300     }
 301     else
 302     {
 303         pDC->rosdc.bitsPerPixel = BitsPerFormat(psurfBmp->SurfObj.iBitmapFormat);
 304     }
 305
 306     /* FIXME; improve by using a region without a handle and selecting it */
 307     hVisRgn = IntSysCreateRectRgn( 0,
 308                                    0,
 309                                    psurfBmp->SurfObj.sizlBitmap.cx,
 310                                    psurfBmp->SurfObj.sizlBitmap.cy);
 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         return FALSE;
 362     }
 363
 364     /* Construct a region from the path */
 365     else if (PATH_PathToRegion(pPath, pdcattr->jFillMode, &hrgnPath))
 366     {
 367         success = GdiExtSelectClipRgn(pdc, hrgnPath, Mode) != ERROR;
 368         GreDeleteObject( hrgnPath );
 369
 370         /* Empty the path */
 371         if (success)
 372             PATH_EmptyPath(pPath);
 373
 374         /* FIXME: Should this function delete the path even if it failed? */
 375     }
 376
 377     PATH_UnlockPath(pPath);
 378     DC_UnlockDc(pdc);
 379
 380     return success;
 381 }
 382
 383 HANDLE
 384 APIENTRY
 385 NtGdiGetDCObject(HDC hDC, INT ObjectType)
 386 {
 387     HGDIOBJ SelObject;
 388     DC *pdc;
 389     PDC_ATTR pdcattr;
 390
 391     /* From Wine: GetCurrentObject does not SetLastError() on a null object */
 392     if(!hDC) return NULL;
 393
 394     if(!(pdc = DC_LockDc(hDC)))
 395     {
 396         SetLastWin32Error(ERROR_INVALID_HANDLE);
 397         return NULL;
 398     }
 399     pdcattr = pdc->pdcattr;
 400
 401     if (pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
 402         DC_vUpdateFillBrush(pdc);
 403
 404     if (pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
 405         DC_vUpdateLineBrush(pdc);
 406
 407     switch(ObjectType)
 408     {
 409         case GDI_OBJECT_TYPE_EXTPEN:
 410         case GDI_OBJECT_TYPE_PEN:
 411             SelObject = pdcattr->hpen;
 412             break;
 413
 414         case GDI_OBJECT_TYPE_BRUSH:
 415             SelObject = pdcattr->hbrush;
 416             break;
 417
 418         case GDI_OBJECT_TYPE_PALETTE:
 419             SelObject = pdc->dclevel.hpal;
 420             break;
 421
 422         case GDI_OBJECT_TYPE_FONT:
 423             SelObject = pdcattr->hlfntNew;
 424             break;
 425
 426         case GDI_OBJECT_TYPE_BITMAP:
 427         {
 428             SURFACE *psurf = pdc->dclevel.pSurface;
 429             SelObject = psurf ? psurf->BaseObject.hHmgr : NULL;
 430             break;
 431         }
 432
 433         case GDI_OBJECT_TYPE_COLORSPACE:
 434             DPRINT1("FIXME: NtGdiGetCurrentObject() ObjectType OBJ_COLORSPACE not supported yet!\n");
 435             // SelObject = dc->dclevel.pColorSpace.BaseObject.hHmgr; ?
 436             SelObject = NULL;
 437             break;
 438
 439         default:
 440             SelObject = NULL;
 441             SetLastWin32Error(ERROR_INVALID_PARAMETER);
 442             break;
 443     }
 444
 445     DC_UnlockDc(pdc);
 446     return SelObject;
 447 }
 448
 449 ULONG
 450 APIENTRY
 451 NtGdiEnumObjects(
 452     IN HDC hdc,
 453     IN INT iObjectType,
 454     IN ULONG cjBuf,
 455     OUT OPTIONAL PVOID pvBuf)
 456 {
 457     UNIMPLEMENTED;
 458     return 0;
 459 }
 460