reactos/win32ss/gdi/eng/pdevobj.c

   1 /*
   2  * COPYRIGHT:        See COPYING in the top level directory
   3  * PROJECT:          ReactOS kernel
   4  * PURPOSE:          Support for physical devices
   5  * FILE:             subsystems/win32/win32k/eng/pdevobj.c
   6  * PROGRAMER:        Timo Kreuzer (timo.kreuzer@reactos.org)
   7  */
   8
   9 #include <win32k.h>
  10 #define NDEBUG
  11 #include <debug.h>
  12
  13 PPDEVOBJ gppdevPrimary = NULL;
  14
  15 static PPDEVOBJ gppdevList = NULL;
  16 static HSEMAPHORE ghsemPDEV;
  17
  18 INIT_FUNCTION
  19 NTSTATUS
  20 NTAPI
  21 InitPDEVImpl()
  22 {
  23     ghsemPDEV = EngCreateSemaphore();
  24     if (!ghsemPDEV) return STATUS_INSUFFICIENT_RESOURCES;
  25     return STATUS_SUCCESS;
  26 }
  27
  28 #if DBG
  29 PPDEVOBJ
  30 NTAPI
  31 DbgLookupDHPDEV(DHPDEV dhpdev)
  32 {
  33     PPDEVOBJ ppdev;
  34
  35     /* Lock PDEV list */
  36     EngAcquireSemaphoreShared(ghsemPDEV);
  37
  38     /* Walk through the list of PDEVs */
  39     for (ppdev = gppdevList;  ppdev; ppdev = ppdev->ppdevNext)
  40     {
  41         /* Compare with the given DHPDEV */
  42         if (ppdev->dhpdev == dhpdev) break;
  43     }
  44
  45     /* Unlock PDEV list */
  46     EngReleaseSemaphore(ghsemPDEV);
  47
  48     return ppdev;
  49 }
  50 #endif
  51
  52 PPDEVOBJ
  53 PDEVOBJ_AllocPDEV()
  54 {
  55     PPDEVOBJ ppdev;
  56
  57     ppdev = ExAllocatePoolWithTag(PagedPool, sizeof(PDEVOBJ), GDITAG_PDEV);
  58     if (!ppdev)
  59         return NULL;
  60
  61     RtlZeroMemory(ppdev, sizeof(PDEVOBJ));
  62
  63     ppdev->cPdevRefs = 1;
  64
  65     return ppdev;
  66 }
  67
  68 VOID
  69 NTAPI
  70 PDEVOBJ_vRelease(PPDEVOBJ ppdev)
  71 {
  72     /* Lock loader */
  73     EngAcquireSemaphore(ghsemPDEV);
  74
  75     /* Decrease reference count */
  76     --ppdev->cPdevRefs;
  77
  78     ASSERT(ppdev->cPdevRefs >= 0) ;
  79
  80     /* Check if references are left */
  81     if (ppdev->cPdevRefs == 0)
  82     {
  83         /* Do we have a surface? */
  84         if(ppdev->pSurface)
  85         {
  86             /* Release the surface and let the driver free it */
  87             SURFACE_ShareUnlockSurface(ppdev->pSurface);
  88             ppdev->pfn.DisableSurface(ppdev->dhpdev);
  89         }
  90
  91         /* Do we have a palette? */
  92         if(ppdev->ppalSurf)
  93         {
  94             PALETTE_ShareUnlockPalette(ppdev->ppalSurf);
  95         }
  96
  97         /* Disable PDEV */
  98         ppdev->pfn.DisablePDEV(ppdev->dhpdev);
  99
 100         /* Remove it from list */
 101         if( ppdev == gppdevList )
 102             gppdevList = ppdev->ppdevNext ;
 103         else
 104         {
 105             PPDEVOBJ ppdevCurrent = gppdevList;
 106             BOOL found = FALSE ;
 107             while (!found && ppdevCurrent->ppdevNext)
 108             {
 109                 if (ppdevCurrent->ppdevNext == ppdev)
 110                     found = TRUE;
 111                 else
 112                     ppdevCurrent = ppdevCurrent->ppdevNext ;
 113             }
 114             if(found)
 115                 ppdevCurrent->ppdevNext = ppdev->ppdevNext;
 116         }
 117
 118         /* Is this the primary one ? */
 119         if (ppdev == gppdevPrimary)
 120             gppdevPrimary = NULL;
 121
 122         /* Free it */
 123         ExFreePoolWithTag(ppdev, GDITAG_PDEV );
 124     }
 125
 126     /* Unlock loader */
 127     EngReleaseSemaphore(ghsemPDEV);
 128
 129 }
 130
 131 BOOL
 132 NTAPI
 133 PDEVOBJ_bEnablePDEV(
 134     PPDEVOBJ ppdev,
 135     PDEVMODEW pdevmode,
 136     PWSTR pwszLogAddress)
 137 {
 138     PFN_DrvEnablePDEV pfnEnablePDEV;
 139     ULONG i;
 140
 141     DPRINT("PDEVOBJ_bEnablePDEV()\n");
 142
 143     /* Get the DrvEnablePDEV function */
 144     pfnEnablePDEV = ppdev->pldev->pfn.EnablePDEV;
 145
 146     /* Call the drivers DrvEnablePDEV function */
 147     ppdev->dhpdev = pfnEnablePDEV(pdevmode,
 148                                   pwszLogAddress,
 149                                   HS_DDI_MAX,
 150                                   ppdev->ahsurf,
 151                                   sizeof(GDIINFO),
 152                                   (PULONG)&ppdev->gdiinfo,
 153                                   sizeof(DEVINFO),
 154                                   &ppdev->devinfo,
 155                                   (HDEV)ppdev,
 156                                   ppdev->pGraphicsDevice->pwszDescription,
 157                                   ppdev->pGraphicsDevice->DeviceObject);
 158
 159     /* Fix up some values */
 160     if (ppdev->gdiinfo.ulLogPixelsX == 0)
 161         ppdev->gdiinfo.ulLogPixelsX = 96;
 162
 163     if (ppdev->gdiinfo.ulLogPixelsY == 0)
 164         ppdev->gdiinfo.ulLogPixelsY = 96;
 165
 166     /* Setup Palette */
 167     ppdev->ppalSurf = PALETTE_ShareLockPalette(ppdev->devinfo.hpalDefault);
 168
 169     /* Setup hatch brushes */
 170     for (i = 0; i < HS_DDI_MAX; i++)
 171     {
 172         if (ppdev->ahsurf[i] == NULL)
 173             ppdev->ahsurf[i] = gahsurfHatch[i];
 174     }
 175
 176     DPRINT("PDEVOBJ_bEnablePDEV - dhpdev = %p\n", ppdev->dhpdev);
 177
 178     return TRUE;
 179 }
 180
 181 VOID
 182 NTAPI
 183 PDEVOBJ_vCompletePDEV(
 184     PPDEVOBJ ppdev)
 185 {
 186     /* Call the drivers DrvCompletePDEV function */
 187     ppdev->pldev->pfn.CompletePDEV(ppdev->dhpdev, (HDEV)ppdev);
 188 }
 189
 190 PSURFACE
 191 NTAPI
 192 PDEVOBJ_pSurface(
 193     PPDEVOBJ ppdev)
 194 {
 195     HSURF hsurf;
 196
 197     /* Check if we already have a surface */
 198     if (ppdev->pSurface)
 199     {
 200         /* Increment reference count */
 201         GDIOBJ_vReferenceObjectByPointer(&ppdev->pSurface->BaseObject);
 202     }
 203     else
 204     {
 205         /* Call the drivers DrvEnableSurface */
 206         hsurf = ppdev->pldev->pfn.EnableSurface(ppdev->dhpdev);
 207
 208         /* Lock the surface */
 209         ppdev->pSurface = SURFACE_ShareLockSurface(hsurf);
 210     }
 211
 212     DPRINT("PDEVOBJ_pSurface() returning %p\n", ppdev->pSurface);
 213     return ppdev->pSurface;
 214 }
 215
 216 PDEVMODEW
 217 NTAPI
 218 PDEVOBJ_pdmMatchDevMode(
 219     PPDEVOBJ ppdev,
 220     PDEVMODEW pdm)
 221 {
 222     PGRAPHICS_DEVICE pGraphicsDevice;
 223     PDEVMODEW pdmCurrent;
 224     ULONG i;
 225     DWORD dwFields;
 226
 227     pGraphicsDevice = ppdev->pGraphicsDevice;
 228
 229     for (i = 0; i < pGraphicsDevice->cDevModes; i++)
 230     {
 231         pdmCurrent = pGraphicsDevice->pDevModeList[i].pdm;
 232
 233         /* Compare asked DEVMODE fields
 234          * Only compare those that are valid in both DEVMODE structs */
 235         dwFields = pdmCurrent->dmFields & pdm->dmFields ;
 236
 237         /* For now, we only need those */
 238         if ((dwFields & DM_BITSPERPEL) &&
 239             (pdmCurrent->dmBitsPerPel != pdm->dmBitsPerPel)) continue;
 240         if ((dwFields & DM_PELSWIDTH) &&
 241             (pdmCurrent->dmPelsWidth != pdm->dmPelsWidth)) continue;
 242         if ((dwFields & DM_PELSHEIGHT) &&
 243             (pdmCurrent->dmPelsHeight != pdm->dmPelsHeight)) continue;
 244         if ((dwFields & DM_DISPLAYFREQUENCY) &&
 245             (pdmCurrent->dmDisplayFrequency != pdm->dmDisplayFrequency)) continue;
 246
 247         /* Match! Return the DEVMODE */
 248         return pdmCurrent;
 249     }
 250
 251     /* Nothing found */
 252     return NULL;
 253 }
 254
 255 static
 256 PPDEVOBJ
 257 EngpCreatePDEV(
 258     PUNICODE_STRING pustrDeviceName,
 259     PDEVMODEW pdm)
 260 {
 261     PGRAPHICS_DEVICE pGraphicsDevice;
 262     PPDEVOBJ ppdev;
 263     DPRINT("EngpCreatePDEV(%wZ, %p)\n", pustrDeviceName, pdm);
 264
 265     /* Try to find the GRAPHICS_DEVICE */
 266     if (pustrDeviceName)
 267     {
 268         pGraphicsDevice = EngpFindGraphicsDevice(pustrDeviceName, 0, 0);
 269         if (!pGraphicsDevice)
 270         {
 271             DPRINT1("No GRAPHICS_DEVICE found for %ls!\n",
 272                     pustrDeviceName ? pustrDeviceName->Buffer : 0);
 273             return NULL;
 274         }
 275     }
 276     else
 277     {
 278         pGraphicsDevice = gpPrimaryGraphicsDevice;
 279     }
 280
 281     /* Allocate a new PDEVOBJ */
 282     ppdev = PDEVOBJ_AllocPDEV();
 283     if (!ppdev)
 284     {
 285         DPRINT1("failed to allocate a PDEV\n");
 286         return NULL;
 287     }
 288
 289     /* If no DEVMODEW is given, ... */
 290     if (!pdm)
 291     {
 292         /* ... use the device's default one */
 293         pdm = pGraphicsDevice->pDevModeList[pGraphicsDevice->iDefaultMode].pdm;
 294         DPRINT("Using iDefaultMode = %lu\n", pGraphicsDevice->iDefaultMode);
 295     }
 296
 297     /* Try to get a diplay driver */
 298     ppdev->pldev = EngLoadImageEx(pdm->dmDeviceName, LDEV_DEVICE_DISPLAY);
 299     if (!ppdev->pldev)
 300     {
 301         DPRINT1("Could not load display driver '%ls', '%ls'\n",
 302                 pGraphicsDevice->pDiplayDrivers,
 303                 pdm->dmDeviceName);
 304         ExFreePoolWithTag(ppdev, GDITAG_PDEV);
 305         return NULL;
 306     }
 307
 308     /* Copy the function table */
 309     ppdev->pfn = ppdev->pldev->pfn;
 310
 311     /* Set MovePointer function */
 312     ppdev->pfnMovePointer = ppdev->pfn.MovePointer;
 313     if (!ppdev->pfnMovePointer)
 314         ppdev->pfnMovePointer = EngMovePointer;
 315
 316     ppdev->pGraphicsDevice = pGraphicsDevice;
 317     ppdev->hsemDevLock = EngCreateSemaphore();
 318     // Should we change the ative mode of pGraphicsDevice ?
 319     ppdev->pdmwDev = PDEVOBJ_pdmMatchDevMode(ppdev, pdm) ;
 320
 321     /* FIXME! */
 322     ppdev->flFlags = PDEV_DISPLAY;
 323
 324     /* HACK: Don't use the pointer */
 325     ppdev->Pointer.Exclude.right = -1;
 326
 327     /* Call the driver to enable the PDEV */
 328     if (!PDEVOBJ_bEnablePDEV(ppdev, pdm, NULL))
 329     {
 330         DPRINT1("Failed to enable PDEV!\n");
 331         ASSERT(FALSE);
 332     }
 333
 334     /* FIXME: this must be done in a better way */
 335     pGraphicsDevice->StateFlags |= DISPLAY_DEVICE_ATTACHED_TO_DESKTOP;
 336
 337     /* Tell the driver that the PDEV is ready */
 338     PDEVOBJ_vCompletePDEV(ppdev);
 339
 340     /* Return the PDEV */
 341     return ppdev;
 342 }
 343
 344 VOID
 345 NTAPI
 346 PDEVOBJ_vSwitchPdev(
 347     PPDEVOBJ ppdev,
 348     PPDEVOBJ ppdev2)
 349 {
 350     PDEVOBJ pdevTmp;
 351     DWORD tmpStateFlags;
 352
 353     /* Exchange data */
 354     pdevTmp = *ppdev;
 355
 356     /* Exchange driver functions */
 357     ppdev->pfn = ppdev2->pfn;
 358     ppdev2->pfn = pdevTmp.pfn;
 359
 360     /* Exchange LDEVs */
 361     ppdev->pldev = ppdev2->pldev;
 362     ppdev2->pldev = pdevTmp.pldev;
 363
 364     /* Exchange DHPDEV */
 365     ppdev->dhpdev = ppdev2->dhpdev;
 366     ppdev2->dhpdev = pdevTmp.dhpdev;
 367
 368     /* Exchange surfaces and associate them with their new PDEV */
 369     ppdev->pSurface = ppdev2->pSurface;
 370     ppdev2->pSurface = pdevTmp.pSurface;
 371     ppdev->pSurface->SurfObj.hdev = (HDEV)ppdev;
 372     ppdev2->pSurface->SurfObj.hdev = (HDEV)ppdev2;
 373
 374     /* Exchange devinfo */
 375     ppdev->devinfo = ppdev2->devinfo;
 376     ppdev2->devinfo = pdevTmp.devinfo;
 377
 378     /* Exchange gdiinfo */
 379     ppdev->gdiinfo = ppdev2->gdiinfo;
 380     ppdev2->gdiinfo = pdevTmp.gdiinfo;
 381
 382     /* Exchange DEVMODE */
 383     ppdev->pdmwDev = ppdev2->pdmwDev;
 384     ppdev2->pdmwDev = pdevTmp.pdmwDev;
 385
 386     /* Exchange state flags */
 387     tmpStateFlags = ppdev->pGraphicsDevice->StateFlags;
 388     ppdev->pGraphicsDevice->StateFlags = ppdev2->pGraphicsDevice->StateFlags;
 389     ppdev2->pGraphicsDevice->StateFlags = tmpStateFlags;
 390
 391     /* Notify each driver instance of its new HDEV association */
 392     ppdev->pfn.CompletePDEV(ppdev->dhpdev, (HDEV)ppdev);
 393     ppdev2->pfn.CompletePDEV(ppdev2->dhpdev, (HDEV)ppdev2);
 394 }
 395
 396
 397 BOOL
 398 NTAPI
 399 PDEVOBJ_bSwitchMode(
 400     PPDEVOBJ ppdev,
 401     PDEVMODEW pdm)
 402 {
 403     UNICODE_STRING ustrDevice;
 404     PPDEVOBJ ppdevTmp;
 405     PSURFACE pSurface;
 406     BOOL retval = FALSE;
 407
 408     /* Lock the PDEV */
 409     EngAcquireSemaphore(ppdev->hsemDevLock);
 410     /* And everything else */
 411     EngAcquireSemaphore(ghsemPDEV);
 412
 413     DPRINT1("PDEVOBJ_bSwitchMode, ppdev = %p, pSurface = %p\n", ppdev, ppdev->pSurface);
 414
 415     // Lookup the GraphicsDevice + select DEVMODE
 416     // pdm = PDEVOBJ_pdmMatchDevMode(ppdev, pdm);
 417
 418     /* 1. Temporarily disable the current PDEV */
 419     if (!ppdev->pfn.AssertMode(ppdev->dhpdev, FALSE))
 420     {
 421         DPRINT1("DrvAssertMode failed\n");
 422         goto leave;
 423     }
 424
 425     /* 2. Create new PDEV */
 426     RtlInitUnicodeString(&ustrDevice, ppdev->pGraphicsDevice->szWinDeviceName);
 427     ppdevTmp = EngpCreatePDEV(&ustrDevice, pdm);
 428     if (!ppdevTmp)
 429     {
 430         DPRINT1("Failed to create a new PDEV\n");
 431         goto leave;
 432     }
 433
 434     /* 3. Create a new surface */
 435     pSurface = PDEVOBJ_pSurface(ppdevTmp);
 436     if (!pSurface)
 437     {
 438         DPRINT1("DrvEnableSurface failed\n");
 439         goto leave;
 440     }
 441
 442     /* 4. Get DirectDraw information */
 443     /* 5. Enable DirectDraw Not traced */
 444     /* 6. Copy old PDEV state to new PDEV instance */
 445
 446     /* 7. Switch the PDEVs */
 447     PDEVOBJ_vSwitchPdev(ppdev, ppdevTmp);
 448
 449     /* 8. Disable DirectDraw */
 450
 451     PDEVOBJ_vRelease(ppdevTmp);
 452
 453     /* Update primary display capabilities */
 454     if(ppdev == gppdevPrimary)
 455     {
 456         PDEVOBJ_vGetDeviceCaps(ppdev, &GdiHandleTable->DevCaps);
 457     }
 458
 459     /* Success! */
 460     retval = TRUE;
 461 leave:
 462     /* Unlock PDEV */
 463     EngReleaseSemaphore(ppdev->hsemDevLock);
 464     EngReleaseSemaphore(ghsemPDEV);
 465
 466     DPRINT1("leave, ppdev = %p, pSurface = %p\n", ppdev, ppdev->pSurface);
 467
 468     return retval;
 469 }
 470
 471
 472 PPDEVOBJ
 473 NTAPI
 474 EngpGetPDEV(
 475     _In_opt_ PUNICODE_STRING pustrDeviceName)
 476 {
 477     UNICODE_STRING ustrCurrent;
 478     PPDEVOBJ ppdev;
 479     PGRAPHICS_DEVICE pGraphicsDevice;
 480
 481     /* Acquire PDEV lock */
 482     EngAcquireSemaphore(ghsemPDEV);
 483
 484     /* Did the caller pass a device name? */
 485     if (pustrDeviceName)
 486     {
 487         /* Loop all present PDEVs */
 488         for (ppdev = gppdevList; ppdev; ppdev = ppdev->ppdevNext)
 489         {
 490             /* Get a pointer to the GRAPHICS_DEVICE */
 491             pGraphicsDevice = ppdev->pGraphicsDevice;
 492
 493             /* Compare the name */
 494             RtlInitUnicodeString(&ustrCurrent, pGraphicsDevice->szWinDeviceName);
 495             if (RtlEqualUnicodeString(pustrDeviceName, &ustrCurrent, FALSE))
 496             {
 497                 /* Found! */
 498                 break;
 499             }
 500         }
 501     }
 502     else
 503     {
 504         /* Otherwise use the primary PDEV */
 505         ppdev = gppdevPrimary;
 506     }
 507
 508     /* Did we find one? */
 509     if (ppdev)
 510     {
 511         /* Yes, reference the PDEV */
 512         InterlockedIncrement(&ppdev->cPdevRefs);
 513     }
 514     else
 515     {
 516         /* No, create a new PDEV for the given device */
 517         ppdev = EngpCreatePDEV(pustrDeviceName, NULL);
 518         if (ppdev)
 519         {
 520             /* Insert the PDEV into the list */
 521             ppdev->ppdevNext = gppdevList;
 522             gppdevList = ppdev;
 523
 524             /* Set as primary PDEV, if we don't have one yet */
 525             if (!gppdevPrimary)
 526             {
 527                 gppdevPrimary = ppdev;
 528                 ppdev->pGraphicsDevice->StateFlags |= DISPLAY_DEVICE_PRIMARY_DEVICE;
 529             }
 530         }
 531     }
 532
 533     /* Release PDEV lock */
 534     EngReleaseSemaphore(ghsemPDEV);
 535
 536     return ppdev;
 537 }
 538
 539 INT
 540 NTAPI
 541 PDEVOBJ_iGetColorManagementCaps(PPDEVOBJ ppdev)
 542 {
 543     INT ret = CM_NONE;
 544
 545     if (ppdev->flFlags & PDEV_DISPLAY)
 546     {
 547         if (ppdev->devinfo.iDitherFormat == BMF_8BPP ||
 548             ppdev->devinfo.flGraphicsCaps2 & GCAPS2_CHANGEGAMMARAMP)
 549             ret = CM_GAMMA_RAMP;
 550     }
 551
 552     if (ppdev->devinfo.flGraphicsCaps & GCAPS_CMYKCOLOR)
 553         ret |= CM_CMYK_COLOR;
 554     if (ppdev->devinfo.flGraphicsCaps & GCAPS_ICM)
 555         ret |= CM_DEVICE_ICM;
 556
 557     return ret;
 558 }
 559
 560 VOID
 561 NTAPI
 562 PDEVOBJ_vGetDeviceCaps(
 563     IN PPDEVOBJ ppdev,
 564     OUT PDEVCAPS pDevCaps)
 565 {
 566     PGDIINFO pGdiInfo = &ppdev->gdiinfo;
 567
 568     pDevCaps->ulVersion = pGdiInfo->ulVersion;
 569     pDevCaps->ulTechnology = pGdiInfo->ulTechnology;
 570     pDevCaps->ulHorzSizeM = (pGdiInfo->ulHorzSize + 500) / 1000;
 571     pDevCaps->ulVertSizeM = (pGdiInfo->ulVertSize + 500) / 1000;
 572     pDevCaps->ulHorzSize = pGdiInfo->ulHorzSize;
 573     pDevCaps->ulVertSize = pGdiInfo->ulVertSize;
 574     pDevCaps->ulHorzRes = pGdiInfo->ulHorzRes;
 575     pDevCaps->ulVertRes = pGdiInfo->ulVertRes;
 576     pDevCaps->ulBitsPixel = pGdiInfo->cBitsPixel;
 577     if (pDevCaps->ulBitsPixel == 15) pDevCaps->ulBitsPixel = 16;
 578     pDevCaps->ulPlanes = pGdiInfo->cPlanes;
 579     pDevCaps->ulNumPens = pGdiInfo->ulNumColors;
 580     if (pDevCaps->ulNumPens != -1) pDevCaps->ulNumPens *= 5;
 581     pDevCaps->ulNumFonts = 0; // PDEVOBJ_cFonts(ppdev);
 582     pDevCaps->ulNumColors = pGdiInfo->ulNumColors;
 583     pDevCaps->ulRasterCaps = pGdiInfo->flRaster;
 584     pDevCaps->ulAspectX = pGdiInfo->ulAspectX;
 585     pDevCaps->ulAspectY = pGdiInfo->ulAspectY;
 586     pDevCaps->ulAspectXY = pGdiInfo->ulAspectXY;
 587     pDevCaps->ulLogPixelsX = pGdiInfo->ulLogPixelsX;
 588     pDevCaps->ulLogPixelsY = pGdiInfo->ulLogPixelsY;
 589     pDevCaps->ulSizePalette = pGdiInfo->ulNumPalReg;
 590     pDevCaps->ulColorRes = pGdiInfo->ulDACRed +
 591                            pGdiInfo->ulDACGreen +
 592                            pGdiInfo->ulDACBlue;
 593     pDevCaps->ulPhysicalWidth = pGdiInfo->szlPhysSize.cx;
 594     pDevCaps->ulPhysicalHeight = pGdiInfo->szlPhysSize.cy;
 595     pDevCaps->ulPhysicalOffsetX = pGdiInfo->ptlPhysOffset.x;
 596     pDevCaps->ulPhysicalOffsetY = pGdiInfo->ptlPhysOffset.y;
 597     pDevCaps->ulTextCaps = pGdiInfo->flTextCaps;
 598     pDevCaps->ulTextCaps |= (TC_SO_ABLE|TC_UA_ABLE|TC_CP_STROKE|TC_OP_STROKE|TC_OP_CHARACTER);
 599     if (pGdiInfo->ulTechnology != DT_PLOTTER)
 600         pDevCaps->ulTextCaps |= TC_VA_ABLE;
 601     pDevCaps->ulVRefresh = pGdiInfo->ulVRefresh;
 602     pDevCaps->ulDesktopHorzRes = pGdiInfo->ulHorzRes;
 603     pDevCaps->ulDesktopVertRes = pGdiInfo->ulVertRes;
 604     pDevCaps->ulBltAlignment = pGdiInfo->ulBltAlignment;
 605     pDevCaps->ulPanningHorzRes = pGdiInfo->ulPanningHorzRes;
 606     pDevCaps->ulPanningVertRes = pGdiInfo->ulPanningVertRes;
 607     pDevCaps->xPanningAlignment = pGdiInfo->xPanningAlignment;
 608     pDevCaps->yPanningAlignment = pGdiInfo->yPanningAlignment;
 609     pDevCaps->ulShadeBlend = pGdiInfo->flShadeBlend;
 610     pDevCaps->ulColorMgmtCaps = PDEVOBJ_iGetColorManagementCaps(ppdev);
 611 }
 612
 613
 614 /** Exported functions ********************************************************/
 615
 616 LPWSTR
 617 APIENTRY
 618 EngGetDriverName(IN HDEV hdev)
 619 {
 620     PPDEVOBJ ppdev = (PPDEVOBJ)hdev;
 621
 622     ASSERT(ppdev);
 623     ASSERT(ppdev->pldev);
 624     ASSERT(ppdev->pldev->pGdiDriverInfo);
 625     ASSERT(ppdev->pldev->pGdiDriverInfo->DriverName.Buffer);
 626
 627     return ppdev->pldev->pGdiDriverInfo->DriverName.Buffer;
 628 }
 629
 630
 631 INT
 632 APIENTRY
 633 NtGdiGetDeviceCaps(
 634     HDC hdc,
 635     INT Index)
 636 {
 637     PDC pdc;
 638     DEVCAPS devcaps;
 639
 640     /* Lock the given DC */
 641     pdc = DC_LockDc(hdc);
 642     if (!pdc)
 643     {
 644         EngSetLastError(ERROR_INVALID_HANDLE);
 645         return 0;
 646     }
 647
 648     /* Get the data */
 649     PDEVOBJ_vGetDeviceCaps(pdc->ppdev, &devcaps);
 650
 651     /* Unlock the DC */
 652     DC_UnlockDc(pdc);
 653
 654     /* Return capability */
 655     switch (Index)
 656     {
 657         case DRIVERVERSION:
 658             return devcaps.ulVersion;
 659
 660         case TECHNOLOGY:
 661             return devcaps.ulTechnology;
 662
 663         case HORZSIZE:
 664             return devcaps.ulHorzSize;
 665
 666         case VERTSIZE:
 667             return devcaps.ulVertSize;
 668
 669         case HORZRES:
 670             return devcaps.ulHorzRes;
 671
 672         case VERTRES:
 673             return devcaps.ulVertRes;
 674
 675         case LOGPIXELSX:
 676             return devcaps.ulLogPixelsX;
 677
 678         case LOGPIXELSY:
 679             return devcaps.ulLogPixelsY;
 680
 681         case BITSPIXEL:
 682             return devcaps.ulBitsPixel;
 683
 684         case PLANES:
 685             return devcaps.ulPlanes;
 686
 687         case NUMBRUSHES:
 688             return -1;
 689
 690         case NUMPENS:
 691             return devcaps.ulNumPens;
 692
 693         case NUMFONTS:
 694             return devcaps.ulNumFonts;
 695
 696         case NUMCOLORS:
 697             return devcaps.ulNumColors;
 698
 699         case ASPECTX:
 700             return devcaps.ulAspectX;
 701
 702         case ASPECTY:
 703             return devcaps.ulAspectY;
 704
 705         case ASPECTXY:
 706             return devcaps.ulAspectXY;
 707
 708         case CLIPCAPS:
 709             return CP_RECTANGLE;
 710
 711         case SIZEPALETTE:
 712             return devcaps.ulSizePalette;
 713
 714         case NUMRESERVED:
 715             return 20;
 716
 717         case COLORRES:
 718             return devcaps.ulColorRes;
 719
 720         case DESKTOPVERTRES:
 721             return devcaps.ulVertRes;
 722
 723         case DESKTOPHORZRES:
 724             return devcaps.ulHorzRes;
 725
 726         case BLTALIGNMENT:
 727             return devcaps.ulBltAlignment;
 728
 729         case SHADEBLENDCAPS:
 730             return devcaps.ulShadeBlend;
 731
 732         case COLORMGMTCAPS:
 733             return devcaps.ulColorMgmtCaps;
 734
 735         case PHYSICALWIDTH:
 736             return devcaps.ulPhysicalWidth;
 737
 738         case PHYSICALHEIGHT:
 739             return devcaps.ulPhysicalHeight;
 740
 741         case PHYSICALOFFSETX:
 742             return devcaps.ulPhysicalOffsetX;
 743
 744         case PHYSICALOFFSETY:
 745             return devcaps.ulPhysicalOffsetY;
 746
 747         case VREFRESH:
 748             return devcaps.ulVRefresh;
 749
 750         case RASTERCAPS:
 751             return devcaps.ulRasterCaps;
 752
 753         case CURVECAPS:
 754             return (CC_CIRCLES | CC_PIE | CC_CHORD | CC_ELLIPSES | CC_WIDE |
 755                     CC_STYLED | CC_WIDESTYLED | CC_INTERIORS | CC_ROUNDRECT);
 756
 757         case LINECAPS:
 758             return (LC_POLYLINE | LC_MARKER | LC_POLYMARKER | LC_WIDE |
 759                     LC_STYLED | LC_WIDESTYLED | LC_INTERIORS);
 760
 761         case POLYGONALCAPS:
 762             return (PC_POLYGON | PC_RECTANGLE | PC_WINDPOLYGON | PC_SCANLINE |
 763                     PC_WIDE | PC_STYLED | PC_WIDESTYLED | PC_INTERIORS);
 764
 765         case TEXTCAPS:
 766             return devcaps.ulTextCaps;
 767
 768         case CAPS1:
 769         case PDEVICESIZE:
 770         case SCALINGFACTORX:
 771         case SCALINGFACTORY:
 772         default:
 773             return 0;
 774     }
 775
 776     return 0;
 777 }
 778
 779 _Success_(return!=FALSE)
 780 BOOL
 781 APIENTRY
 782 NtGdiGetDeviceCapsAll(
 783     IN HDC hDC,
 784     OUT PDEVCAPS pDevCaps)
 785 {
 786     PDC pdc;
 787     DEVCAPS devcaps;
 788     BOOL bResult = TRUE;
 789
 790     /* Lock the given DC */
 791     pdc = DC_LockDc(hDC);
 792     if (!pdc)
 793     {
 794         EngSetLastError(ERROR_INVALID_HANDLE);
 795         return FALSE;
 796     }
 797
 798     /* Get the data */
 799     PDEVOBJ_vGetDeviceCaps(pdc->ppdev, &devcaps);
 800
 801     /* Unlock the DC */
 802     DC_UnlockDc(pdc);
 803
 804     /* Copy data to caller */
 805     _SEH2_TRY
 806     {
 807         ProbeForWrite(pDevCaps, sizeof(DEVCAPS), 1);
 808         RtlCopyMemory(pDevCaps, &devcaps, sizeof(DEVCAPS));
 809     }
 810     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 811     {
 812         SetLastNtError(_SEH2_GetExceptionCode());
 813         bResult = FALSE;
 814     }
 815     _SEH2_END;
 816
 817     return bResult;
 818 }
 819
 820 DHPDEV
 821 APIENTRY
 822 NtGdiGetDhpdev(
 823     IN HDEV hdev)
 824 {
 825     PPDEVOBJ ppdev;
 826     DHPDEV dhpdev = NULL;
 827
 828     /* Check parameter */
 829     if (!hdev || (PCHAR)hdev < (PCHAR)MmSystemRangeStart)
 830         return NULL;
 831
 832     /* Lock PDEV list */
 833     EngAcquireSemaphoreShared(ghsemPDEV);
 834
 835     /* Walk through the list of PDEVs */
 836     for (ppdev = gppdevList;  ppdev; ppdev = ppdev->ppdevNext)
 837     {
 838         /* Compare with the given HDEV */
 839         if (ppdev == (PPDEVOBJ)hdev)
 840         {
 841             /* Found the PDEV! Get it's dhpdev and break */
 842             dhpdev = ppdev->dhpdev;
 843             break;
 844         }
 845     }
 846
 847     /* Unlock PDEV list */
 848     EngReleaseSemaphore(ghsemPDEV);
 849
 850     return dhpdev;
 851 }
 852
 853 PSIZEL
 854 FASTCALL
 855 PDEVOBJ_sizl(PPDEVOBJ ppdev, PSIZEL psizl)
 856 {
 857     if (ppdev->flFlags & PDEV_META_DEVICE)
 858     {
 859         psizl->cx = ppdev->ulHorzRes;
 860         psizl->cy = ppdev->ulVertRes;
 861     }
 862     else
 863     {
 864         psizl->cx = ppdev->gdiinfo.ulHorzRes;
 865         psizl->cy = ppdev->gdiinfo.ulVertRes;
 866     }
 867     return psizl;
 868 }