win32ss/gdi/ntgdi/font.c

   1 /*
   2  * PROJECT:         ReactOS win32 kernel mode subsystem
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * FILE:            win32ss/gdi/ntgdi/font.c
   5  * PURPOSE:         Font
   6  * PROGRAMMERS:     James Tabor <james.tabor@reactos.org>
   7  *                  Timo Kreuzer <timo.kreuzer@reactos.org>
   8  *                  Katayama Hirofumi MZ <katayama.hirofumi.mz@gmail.com>
   9  */
  10
  11 /** Includes ******************************************************************/
  12
  13 #include <win32k.h>
  14
  15 #define NDEBUG
  16 #include <debug.h>
  17
  18 HFONT APIENTRY HfontCreate( IN PENUMLOGFONTEXDVW pelfw,IN ULONG cjElfw,IN LFTYPE lft,IN FLONG fl,IN PVOID pvCliData );
  19
  20 /** Internal ******************************************************************/
  21
  22 HFONT FASTCALL
  23 GreCreateFontIndirectW( LOGFONTW *lplf )
  24 {
  25     if (lplf)
  26     {
  27         ENUMLOGFONTEXDVW Logfont;
  28
  29         RtlCopyMemory( &Logfont.elfEnumLogfontEx.elfLogFont, lplf, sizeof(LOGFONTW));
  30         RtlZeroMemory( &Logfont.elfEnumLogfontEx.elfFullName,
  31                        sizeof(Logfont.elfEnumLogfontEx.elfFullName));
  32         RtlZeroMemory( &Logfont.elfEnumLogfontEx.elfStyle,
  33                        sizeof(Logfont.elfEnumLogfontEx.elfStyle));
  34         RtlZeroMemory( &Logfont.elfEnumLogfontEx.elfScript,
  35                        sizeof(Logfont.elfEnumLogfontEx.elfScript));
  36
  37         Logfont.elfDesignVector.dvNumAxes = 0;
  38
  39         RtlZeroMemory( &Logfont.elfDesignVector, sizeof(DESIGNVECTOR));
  40
  41         return HfontCreate((PENUMLOGFONTEXDVW)&Logfont, 0, 0, 0, NULL );
  42     }
  43     else return NULL;
  44 }
  45
  46 DWORD
  47 FASTCALL
  48 GreGetKerningPairs(
  49     HDC hDC,
  50     ULONG NumPairs,
  51     LPKERNINGPAIR krnpair)
  52 {
  53   PDC dc;
  54   PDC_ATTR pdcattr;
  55   PTEXTOBJ TextObj;
  56   PFONTGDI FontGDI;
  57   DWORD Count;
  58   KERNINGPAIR *pKP;
  59
  60   dc = DC_LockDc(hDC);
  61   if (!dc)
  62   {
  63      EngSetLastError(ERROR_INVALID_HANDLE);
  64      return 0;
  65   }
  66
  67   pdcattr = dc->pdcattr;
  68   TextObj = RealizeFontInit(pdcattr->hlfntNew);
  69   DC_UnlockDc(dc);
  70
  71   if (!TextObj)
  72   {
  73      EngSetLastError(ERROR_INVALID_HANDLE);
  74      return 0;
  75   }
  76
  77   FontGDI = ObjToGDI(TextObj->Font, FONT);
  78   TEXTOBJ_UnlockText(TextObj);
  79
  80   Count = ftGdiGetKerningPairs(FontGDI,0,NULL);
  81
  82   if ( Count && krnpair )
  83   {
  84      if (Count > NumPairs)
  85      {
  86         EngSetLastError(ERROR_INSUFFICIENT_BUFFER);
  87         return 0;
  88      }
  89      pKP = ExAllocatePoolWithTag(PagedPool, Count * sizeof(KERNINGPAIR), GDITAG_TEXT);
  90      if (!pKP)
  91      {
  92         EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
  93         return 0;
  94      }
  95      ftGdiGetKerningPairs(FontGDI,Count,pKP);
  96
  97      RtlCopyMemory(krnpair, pKP, Count * sizeof(KERNINGPAIR));
  98
  99      ExFreePoolWithTag(pKP,GDITAG_TEXT);
 100   }
 101   return Count;
 102 }
 103
 104 /*
 105
 106   It is recommended that an application use the GetFontLanguageInfo function
 107   to determine whether the GCP_DIACRITIC, GCP_DBCS, GCP_USEKERNING, GCP_LIGATE,
 108   GCP_REORDER, GCP_GLYPHSHAPE, and GCP_KASHIDA values are valid for the
 109   currently selected font. If not valid, GetCharacterPlacement ignores the
 110   value.
 111
 112   M$ must use a preset "compiled in" support for each language based releases.
 113   ReactOS uses FreeType, this will need to be supported. ATM this is hard coded
 114   for GCPCLASS_LATIN!
 115
 116  */
 117 #if 0
 118 DWORD
 119 FASTCALL
 120 GreGetCharacterPlacementW(
 121     HDC hdc,
 122     LPCWSTR pwsz,
 123     INT nCount,
 124     INT nMaxExtent,
 125     LPGCP_RESULTSW pgcpw,
 126     DWORD dwFlags)
 127 {
 128   GCP_RESULTSW gcpwSave;
 129   UINT i, nSet, cSet;
 130   INT *tmpDxCaretPos;
 131   LONG Cx;
 132   SIZE Size = {0,0};
 133
 134   DPRINT1("GreGCPW Start\n");
 135
 136    if (!pgcpw)
 137    {
 138       if (GreGetTextExtentW( hdc, pwsz, nCount, &Size, 1))
 139          return MAKELONG(Size.cx, Size.cy);
 140       return 0;
 141    }
 142
 143   DPRINT1("GreGCPW 1\n");
 144
 145   RtlCopyMemory(&gcpwSave, pgcpw, sizeof(GCP_RESULTSW));
 146
 147   cSet = nSet = nCount;
 148
 149   if ( nCount > gcpwSave.nGlyphs ) cSet = gcpwSave.nGlyphs;
 150
 151   /* GCP_JUSTIFY may only be used in conjunction with GCP_MAXEXTENT. */
 152   if ( dwFlags & GCP_JUSTIFY) dwFlags |= GCP_MAXEXTENT;
 153
 154   if ( !gcpwSave.lpDx && gcpwSave.lpCaretPos )
 155      tmpDxCaretPos = gcpwSave.lpCaretPos;
 156   else
 157      tmpDxCaretPos = gcpwSave.lpDx;
 158
 159   if ( !GreGetTextExtentExW( hdc,
 160                              pwsz,
 161                              cSet,
 162                              nMaxExtent,
 163                             ((dwFlags & GCP_MAXEXTENT) ? (PULONG) &cSet : NULL),
 164                             (PULONG) tmpDxCaretPos,
 165                              &Size,
 166                              0) )
 167   {
 168      return 0;
 169   }
 170
 171   DPRINT1("GreGCPW 2\n");
 172
 173   nSet = cSet;
 174
 175   if ( tmpDxCaretPos && nSet > 0)
 176   {
 177       for (i = (nSet - 1); i > 0; i--)
 178       {
 179           tmpDxCaretPos[i] -= tmpDxCaretPos[i - 1];
 180       }
 181   }
 182
 183   if ( !(dwFlags & GCP_MAXEXTENT) || nSet )
 184   {
 185      if ( (dwFlags & GCP_USEKERNING) &&
 186            ( gcpwSave.lpDx ||
 187              gcpwSave.lpCaretPos ) &&
 188            nSet >= 2 )
 189      {
 190         DWORD Count;
 191         LPKERNINGPAIR pKP;
 192
 193         Count = GreGetKerningPairs( hdc, 0, NULL);
 194         if (Count)
 195         {
 196            pKP = ExAllocatePoolWithTag(PagedPool, Count * sizeof(KERNINGPAIR), GDITAG_TEXT);
 197            if (pKP)
 198            {
 199               if ( GreGetKerningPairs( hdc, Count, pKP) != Count)
 200               {
 201                  ExFreePoolWithTag( pKP, GDITAG_TEXT);
 202                  return 0;
 203               }
 204
 205               if ( (ULONG_PTR)(pKP) < ((ULONG_PTR)(pKP) + (ULONG_PTR)(Count * sizeof(KERNINGPAIR))) )
 206               {
 207                  DPRINT1("We Need to Do Something HERE!\n");
 208               }
 209
 210               ExFreePoolWithTag( pKP, GDITAG_TEXT);
 211
 212               if ( dwFlags & GCP_MAXEXTENT )
 213               {
 214                  if ( Size.cx > nMaxExtent )
 215                  {
 216                     for (Cx = Size.cx; nSet > 0; nSet--)
 217                     {
 218                         Cx -= tmpDxCaretPos[nSet - 1];
 219                         Size.cx = Cx;
 220                         if ( Cx <= nMaxExtent ) break;
 221                     }
 222                  }
 223                  if ( !nSet )
 224                  {
 225                     pgcpw->nGlyphs = 0;
 226                     pgcpw->nMaxFit = 0;
 227                     return 0;
 228                  }
 229               }
 230            }
 231         }
 232      }
 233
 234      if ( (dwFlags & GCP_JUSTIFY) &&
 235            ( gcpwSave.lpDx ||
 236              gcpwSave.lpCaretPos ) &&
 237            nSet )
 238      {
 239          DPRINT1("We Need to Do Something HERE 2!\n");
 240      }
 241
 242      if ( gcpwSave.lpDx && gcpwSave.lpCaretPos )
 243         RtlCopyMemory( gcpwSave.lpCaretPos, gcpwSave.lpDx, nSet * sizeof(LONG));
 244
 245      if ( gcpwSave.lpCaretPos )
 246      {
 247         int pos = 0;
 248         i = 0;
 249         if ( nSet > 0 )
 250         {
 251            do
 252            {
 253               Cx = gcpwSave.lpCaretPos[i];
 254               gcpwSave.lpCaretPos[i] = pos;
 255               pos += Cx;
 256               ++i;
 257            }
 258            while ( i < nSet );
 259         }
 260      }
 261
 262      if ( gcpwSave.lpOutString )
 263         RtlCopyMemory(gcpwSave.lpOutString, pwsz,  nSet * sizeof(WCHAR));
 264
 265      if ( gcpwSave.lpClass )
 266         RtlFillMemory(gcpwSave.lpClass, nSet, GCPCLASS_LATIN);
 267
 268      if ( gcpwSave.lpOrder )
 269      {
 270         for (i = 0; i < nSet; i++)
 271            gcpwSave.lpOrder[i] = i;
 272      }
 273
 274      if ( gcpwSave.lpGlyphs )
 275      {
 276         if ( GreGetGlyphIndicesW( hdc, pwsz, nSet, gcpwSave.lpGlyphs, 0, 0) == GDI_ERROR )
 277         {
 278            nSet = 0;
 279            Size.cx = 0;
 280            Size.cy = 0;
 281         }
 282      }
 283      pgcpw->nGlyphs = nSet;
 284      pgcpw->nMaxFit = nSet;
 285   }
 286   DPRINT1("GreGCPW Exit\n");
 287   return MAKELONG(Size.cx, Size.cy);
 288 }
 289 #endif
 290
 291 ULONG
 292 FASTCALL
 293 FontGetObject(PTEXTOBJ plfont, ULONG cjBuffer, PVOID pvBuffer)
 294 {
 295     ULONG cjMaxSize;
 296     ENUMLOGFONTEXDVW *plf = &plfont->logfont;
 297
 298     /* If buffer is NULL, only the size is requested */
 299     if (pvBuffer == NULL) return sizeof(LOGFONTW);
 300
 301     /* Calculate the maximum size according to number of axes */
 302     cjMaxSize = FIELD_OFFSET(ENUMLOGFONTEXDVW,
 303                     elfDesignVector.dvValues[plf->elfDesignVector.dvNumAxes]);
 304
 305     if (cjBuffer > cjMaxSize) cjBuffer = cjMaxSize;
 306
 307     RtlCopyMemory(pvBuffer, plf, cjBuffer);
 308
 309     return cjBuffer;
 310 }
 311
 312 DWORD
 313 FASTCALL
 314 IntGetCharDimensions(HDC hdc, PTEXTMETRICW ptm, PDWORD height)
 315 {
 316   PDC pdc;
 317   PDC_ATTR pdcattr;
 318   PTEXTOBJ TextObj;
 319   SIZE sz;
 320   TMW_INTERNAL tmwi;
 321   BOOL Good;
 322
 323   static const WCHAR alphabet[] = {
 324         'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q',
 325         'r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H',
 326         'I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z',0};
 327
 328   if(!ftGdiGetTextMetricsW(hdc, &tmwi)) return 0;
 329
 330   pdc = DC_LockDc(hdc);
 331
 332   if (!pdc) return 0;
 333
 334   pdcattr = pdc->pdcattr;
 335
 336   TextObj = RealizeFontInit(pdcattr->hlfntNew);
 337   if ( !TextObj )
 338   {
 339      DC_UnlockDc(pdc);
 340      return 0;
 341   }
 342   Good = TextIntGetTextExtentPoint(pdc, TextObj, alphabet, 52, 0, NULL, 0, &sz, 0);
 343   TEXTOBJ_UnlockText(TextObj);
 344   DC_UnlockDc(pdc);
 345
 346   if (!Good) return 0;
 347   if (ptm) *ptm = tmwi.TextMetric;
 348   if (height) *height = tmwi.TextMetric.tmHeight;
 349
 350   return (sz.cx / 26 + 1) / 2;
 351 }
 352
 353
 354 DWORD
 355 FASTCALL
 356 IntGetFontLanguageInfo(PDC Dc)
 357 {
 358   PDC_ATTR pdcattr;
 359   FONTSIGNATURE fontsig;
 360   static const DWORD GCP_DBCS_MASK=0x003F0000,
 361                 GCP_DIACRITIC_MASK=0x00000000,
 362                 FLI_GLYPHS_MASK=0x00000000,
 363                 GCP_GLYPHSHAPE_MASK=0x00000040,
 364                 GCP_KASHIDA_MASK=0x00000000,
 365                 GCP_LIGATE_MASK=0x00000000,
 366                 GCP_USEKERNING_MASK=0x00000000,
 367                 GCP_REORDER_MASK=0x00000060;
 368
 369   DWORD result=0;
 370
 371   ftGdiGetTextCharsetInfo( Dc, &fontsig, 0 );
 372
 373  /* We detect each flag we return using a bitmask on the Codepage Bitfields */
 374   if( (fontsig.fsCsb[0]&GCP_DBCS_MASK)!=0 )
 375                 result|=GCP_DBCS;
 376
 377   if( (fontsig.fsCsb[0]&GCP_DIACRITIC_MASK)!=0 )
 378                 result|=GCP_DIACRITIC;
 379
 380   if( (fontsig.fsCsb[0]&FLI_GLYPHS_MASK)!=0 )
 381                 result|=FLI_GLYPHS;
 382
 383   if( (fontsig.fsCsb[0]&GCP_GLYPHSHAPE_MASK)!=0 )
 384                 result|=GCP_GLYPHSHAPE;
 385
 386   if( (fontsig.fsCsb[0]&GCP_KASHIDA_MASK)!=0 )
 387                 result|=GCP_KASHIDA;
 388
 389   if( (fontsig.fsCsb[0]&GCP_LIGATE_MASK)!=0 )
 390                 result|=GCP_LIGATE;
 391
 392   if( (fontsig.fsCsb[0]&GCP_USEKERNING_MASK)!=0 )
 393                 result|=GCP_USEKERNING;
 394
 395   pdcattr = Dc->pdcattr;
 396
 397   /* This might need a test for a HEBREW- or ARABIC_CHARSET as well */
 398   if ( pdcattr->lTextAlign & TA_RTLREADING )
 399      if( (fontsig.fsCsb[0]&GCP_REORDER_MASK)!=0 )
 400                     result|=GCP_REORDER;
 401
 402   return result;
 403 }
 404
 405 PTEXTOBJ
 406 FASTCALL
 407 RealizeFontInit(HFONT hFont)
 408 {
 409   NTSTATUS Status = STATUS_SUCCESS;
 410   PTEXTOBJ pTextObj;
 411
 412   pTextObj = TEXTOBJ_LockText(hFont);
 413
 414   if ( pTextObj && !(pTextObj->fl & TEXTOBJECT_INIT))
 415   {
 416      Status = TextIntRealizeFont(hFont, pTextObj);
 417      if (!NT_SUCCESS(Status))
 418      {
 419         TEXTOBJ_UnlockText(pTextObj);
 420         return NULL;
 421      }
 422   }
 423   return pTextObj;
 424 }
 425
 426
 427 /** Functions ******************************************************************/
 428
 429 INT
 430 APIENTRY
 431 NtGdiAddFontResourceW(
 432     IN WCHAR *pwcFiles,
 433     IN ULONG cwc,
 434     IN ULONG cFiles,
 435     IN FLONG fl,
 436     IN DWORD dwPidTid,
 437     IN OPTIONAL DESIGNVECTOR *pdv)
 438 {
 439     UNICODE_STRING SafeFileName;
 440     INT Ret;
 441
 442     DBG_UNREFERENCED_PARAMETER(cFiles);
 443     DBG_UNREFERENCED_PARAMETER(dwPidTid);
 444     DBG_UNREFERENCED_PARAMETER(pdv);
 445
 446     DPRINT("NtGdiAddFontResourceW\n");
 447
 448     /* cwc = Length + trailing zero. */
 449     if ((cwc <= 1) || (cwc > UNICODE_STRING_MAX_CHARS))
 450         return 0;
 451
 452     SafeFileName.MaximumLength = (USHORT)(cwc * sizeof(WCHAR));
 453     SafeFileName.Length = SafeFileName.MaximumLength - sizeof(UNICODE_NULL);
 454     SafeFileName.Buffer = ExAllocatePoolWithTag(PagedPool,
 455                                                 SafeFileName.MaximumLength,
 456                                                 TAG_STRING);
 457     if (!SafeFileName.Buffer)
 458     {
 459         return 0;
 460     }
 461
 462     _SEH2_TRY
 463     {
 464         ProbeForRead(pwcFiles, cwc * sizeof(WCHAR), sizeof(WCHAR));
 465         RtlCopyMemory(SafeFileName.Buffer, pwcFiles, SafeFileName.Length);
 466     }
 467     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 468     {
 469         ExFreePoolWithTag(SafeFileName.Buffer, TAG_STRING);
 470         _SEH2_YIELD(return 0);
 471     }
 472     _SEH2_END;
 473
 474     SafeFileName.Buffer[SafeFileName.Length / sizeof(WCHAR)] = UNICODE_NULL;
 475     Ret = IntGdiAddFontResource(&SafeFileName, fl);
 476
 477     ExFreePoolWithTag(SafeFileName.Buffer, TAG_STRING);
 478     return Ret;
 479 }
 480
 481 HANDLE
 482 APIENTRY
 483 NtGdiAddFontMemResourceEx(
 484     IN PVOID pvBuffer,
 485     IN DWORD cjBuffer,
 486     IN DESIGNVECTOR *pdv,
 487     IN ULONG cjDV,
 488     OUT DWORD *pNumFonts)
 489 {
 490     _SEH2_VOLATILE PVOID Buffer = NULL;
 491     HANDLE Ret;
 492     DWORD NumFonts = 0;
 493
 494     DPRINT("NtGdiAddFontMemResourceEx\n");
 495     DBG_UNREFERENCED_PARAMETER(pdv);
 496     DBG_UNREFERENCED_PARAMETER(cjDV);
 497
 498     if (!pvBuffer || !cjBuffer)
 499         return NULL;
 500
 501     _SEH2_TRY
 502     {
 503         ProbeForRead(pvBuffer, cjBuffer, sizeof(BYTE));
 504         Buffer = ExAllocatePoolWithQuotaTag(PagedPool, cjBuffer, TAG_FONT);
 505         RtlCopyMemory(Buffer, pvBuffer, cjBuffer);
 506     }
 507     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 508     {
 509         if (Buffer != NULL)
 510         {
 511             ExFreePoolWithTag(Buffer, TAG_FONT);
 512         }
 513         _SEH2_YIELD(return NULL);
 514     }
 515     _SEH2_END;
 516
 517     Ret = IntGdiAddFontMemResource(Buffer, cjBuffer, &NumFonts);
 518     ExFreePoolWithTag(Buffer, TAG_FONT);
 519
 520     _SEH2_TRY
 521     {
 522         ProbeForWrite(pNumFonts, sizeof(NumFonts), 1);
 523         *pNumFonts = NumFonts;
 524     }
 525     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 526     {
 527         /* Leak it? */
 528         _SEH2_YIELD(return NULL);
 529     }
 530     _SEH2_END;
 531
 532
 533     return Ret;
 534 }
 535
 536
 537 BOOL
 538 APIENTRY
 539 NtGdiRemoveFontMemResourceEx(
 540     IN HANDLE hMMFont)
 541 {
 542     return IntGdiRemoveFontMemResource(hMMFont);
 543 }
 544
 545
 546  /*
 547  * @unimplemented
 548  */
 549 DWORD
 550 APIENTRY
 551 NtGdiGetCharacterPlacementW(
 552     IN HDC hdc,
 553     IN LPWSTR pwsz,
 554     IN INT nCount,
 555     IN INT nMaxExtent,
 556     IN OUT LPGCP_RESULTSW pgcpw,
 557     IN DWORD dwFlags)
 558 {
 559     UNIMPLEMENTED;
 560     return 0;
 561 #if 0
 562     return GreGetCharacterPlacementW( hdc,
 563                                       pwsz,
 564                                       nCount,
 565                                       nMaxExtent,
 566                                       pgcpw,
 567                                       dwFlags);
 568 #endif
 569 }
 570
 571 DWORD
 572 APIENTRY
 573 NtGdiGetFontData(
 574    HDC hDC,
 575    DWORD Table,
 576    DWORD Offset,
 577    LPVOID Buffer,
 578    DWORD Size)
 579 {
 580   PDC Dc;
 581   PDC_ATTR pdcattr;
 582   HFONT hFont;
 583   PTEXTOBJ TextObj;
 584   PFONTGDI FontGdi;
 585   DWORD Result = GDI_ERROR;
 586   NTSTATUS Status = STATUS_SUCCESS;
 587
 588   if (Buffer && Size)
 589   {
 590      _SEH2_TRY
 591      {
 592          ProbeForRead(Buffer, Size, 1);
 593      }
 594      _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 595      {
 596          Status = _SEH2_GetExceptionCode();
 597      }
 598      _SEH2_END
 599   }
 600
 601   if (!NT_SUCCESS(Status)) return Result;
 602
 603   Dc = DC_LockDc(hDC);
 604   if (Dc == NULL)
 605   {
 606      EngSetLastError(ERROR_INVALID_HANDLE);
 607      return GDI_ERROR;
 608   }
 609   pdcattr = Dc->pdcattr;
 610
 611   hFont = pdcattr->hlfntNew;
 612   TextObj = RealizeFontInit(hFont);
 613   DC_UnlockDc(Dc);
 614
 615   if (TextObj == NULL)
 616   {
 617      EngSetLastError(ERROR_INVALID_HANDLE);
 618      return GDI_ERROR;
 619   }
 620
 621   FontGdi = ObjToGDI(TextObj->Font, FONT);
 622
 623   Result = ftGdiGetFontData(FontGdi, Table, Offset, Buffer, Size);
 624
 625   TEXTOBJ_UnlockText(TextObj);
 626
 627   return Result;
 628 }
 629
 630  /*
 631  * @implemented
 632  */
 633 DWORD
 634 APIENTRY
 635 NtGdiGetFontUnicodeRanges(
 636     IN HDC hdc,
 637     OUT OPTIONAL LPGLYPHSET pgs)
 638 {
 639   PDC pDc;
 640   PDC_ATTR pdcattr;
 641   HFONT hFont;
 642   PTEXTOBJ TextObj;
 643   PFONTGDI FontGdi;
 644   DWORD Size = 0;
 645   PGLYPHSET pgsSafe;
 646   NTSTATUS Status = STATUS_SUCCESS;
 647
 648   pDc = DC_LockDc(hdc);
 649   if (!pDc)
 650   {
 651      EngSetLastError(ERROR_INVALID_HANDLE);
 652      return 0;
 653   }
 654
 655   pdcattr = pDc->pdcattr;
 656
 657   hFont = pdcattr->hlfntNew;
 658   TextObj = RealizeFontInit(hFont);
 659
 660   if ( TextObj == NULL)
 661   {
 662      EngSetLastError(ERROR_INVALID_HANDLE);
 663      goto Exit;
 664   }
 665   FontGdi = ObjToGDI(TextObj->Font, FONT);
 666
 667   Size = ftGetFontUnicodeRanges( FontGdi, NULL);
 668
 669   if (Size && pgs)
 670   {
 671      pgsSafe = ExAllocatePoolWithTag(PagedPool, Size, GDITAG_TEXT);
 672      if (!pgsSafe)
 673      {
 674         EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
 675         Size = 0;
 676         goto Exit;
 677      }
 678
 679      Size = ftGetFontUnicodeRanges( FontGdi, pgsSafe);
 680
 681      if (Size)
 682      {
 683         _SEH2_TRY
 684         {
 685             ProbeForWrite(pgs, Size, 1);
 686             RtlCopyMemory(pgs, pgsSafe, Size);
 687         }
 688         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 689         {
 690            Status = _SEH2_GetExceptionCode();
 691         }
 692         _SEH2_END
 693
 694         if (!NT_SUCCESS(Status)) Size = 0;
 695      }
 696      ExFreePoolWithTag(pgsSafe, GDITAG_TEXT);
 697   }
 698 Exit:
 699   TEXTOBJ_UnlockText(TextObj);
 700   DC_UnlockDc(pDc);
 701   return Size;
 702 }
 703
 704 ULONG
 705 APIENTRY
 706 NtGdiGetGlyphOutline(
 707     IN HDC hdc,
 708     IN WCHAR wch,
 709     IN UINT iFormat,
 710     OUT LPGLYPHMETRICS pgm,
 711     IN ULONG cjBuf,
 712     OUT OPTIONAL PVOID UnsafeBuf,
 713     IN LPMAT2 pmat2,
 714     IN BOOL bIgnoreRotation)
 715 {
 716   ULONG Ret = GDI_ERROR;
 717   PDC dc;
 718   PVOID pvBuf = NULL;
 719   GLYPHMETRICS gm;
 720   NTSTATUS Status = STATUS_SUCCESS;
 721
 722   dc = DC_LockDc(hdc);
 723   if (!dc)
 724   {
 725      EngSetLastError(ERROR_INVALID_HANDLE);
 726      return GDI_ERROR;
 727   }
 728
 729   if (UnsafeBuf && cjBuf)
 730   {
 731      pvBuf = ExAllocatePoolWithTag(PagedPool, cjBuf, GDITAG_TEXT);
 732      if (!pvBuf)
 733      {
 734         EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
 735         goto Exit;
 736      }
 737   }
 738
 739   Ret = ftGdiGetGlyphOutline( dc,
 740                              wch,
 741                          iFormat,
 742                              pgm ? &gm : NULL,
 743                            cjBuf,
 744                            pvBuf,
 745                            pmat2,
 746                  bIgnoreRotation);
 747
 748   if (pvBuf)
 749   {
 750      _SEH2_TRY
 751      {
 752          ProbeForWrite(UnsafeBuf, cjBuf, 1);
 753          RtlCopyMemory(UnsafeBuf, pvBuf, cjBuf);
 754      }
 755      _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 756      {
 757          Status = _SEH2_GetExceptionCode();
 758      }
 759      _SEH2_END
 760
 761      ExFreePoolWithTag(pvBuf, GDITAG_TEXT);
 762   }
 763
 764   if (pgm)
 765   {
 766      _SEH2_TRY
 767      {
 768          ProbeForWrite(pgm, sizeof(GLYPHMETRICS), 1);
 769          RtlCopyMemory(pgm, &gm, sizeof(GLYPHMETRICS));
 770      }
 771      _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 772      {
 773          Status = _SEH2_GetExceptionCode();
 774      }
 775      _SEH2_END
 776   }
 777
 778   if (! NT_SUCCESS(Status))
 779   {
 780      EngSetLastError(ERROR_INVALID_PARAMETER);
 781      Ret = GDI_ERROR;
 782   }
 783
 784 Exit:
 785   DC_UnlockDc(dc);
 786   return Ret;
 787 }
 788
 789 DWORD
 790 APIENTRY
 791 NtGdiGetKerningPairs(HDC  hDC,
 792                      ULONG  NumPairs,
 793                      LPKERNINGPAIR  krnpair)
 794 {
 795   PDC dc;
 796   PDC_ATTR pdcattr;
 797   PTEXTOBJ TextObj;
 798   PFONTGDI FontGDI;
 799   DWORD Count;
 800   KERNINGPAIR *pKP;
 801   NTSTATUS Status = STATUS_SUCCESS;
 802
 803   dc = DC_LockDc(hDC);
 804   if (!dc)
 805   {
 806      EngSetLastError(ERROR_INVALID_HANDLE);
 807      return 0;
 808   }
 809
 810   pdcattr = dc->pdcattr;
 811   TextObj = RealizeFontInit(pdcattr->hlfntNew);
 812   DC_UnlockDc(dc);
 813
 814   if (!TextObj)
 815   {
 816      EngSetLastError(ERROR_INVALID_HANDLE);
 817      return 0;
 818   }
 819
 820   FontGDI = ObjToGDI(TextObj->Font, FONT);
 821   TEXTOBJ_UnlockText(TextObj);
 822
 823   Count = ftGdiGetKerningPairs(FontGDI,0,NULL);
 824
 825   if ( Count && krnpair )
 826   {
 827      if (Count > NumPairs)
 828      {
 829         EngSetLastError(ERROR_INSUFFICIENT_BUFFER);
 830         return 0;
 831      }
 832      pKP = ExAllocatePoolWithTag(PagedPool, Count * sizeof(KERNINGPAIR), GDITAG_TEXT);
 833      if (!pKP)
 834      {
 835         EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
 836         return 0;
 837      }
 838      ftGdiGetKerningPairs(FontGDI,Count,pKP);
 839      _SEH2_TRY
 840      {
 841         ProbeForWrite(krnpair, Count * sizeof(KERNINGPAIR), 1);
 842         RtlCopyMemory(krnpair, pKP, Count * sizeof(KERNINGPAIR));
 843      }
 844      _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 845      {
 846         Status = _SEH2_GetExceptionCode();
 847      }
 848      _SEH2_END
 849      if (!NT_SUCCESS(Status))
 850      {
 851         EngSetLastError(ERROR_INVALID_PARAMETER);
 852         Count = 0;
 853      }
 854      ExFreePoolWithTag(pKP,GDITAG_TEXT);
 855   }
 856   return Count;
 857 }
 858
 859 /*
 860  From "Undocumented Windows 2000 Secrets" Appendix B, Table B-2, page
 861  472, this is NtGdiGetOutlineTextMetricsInternalW.
 862  */
 863 ULONG
 864 APIENTRY
 865 NtGdiGetOutlineTextMetricsInternalW (HDC  hDC,
 866                                    ULONG  Data,
 867                       OUTLINETEXTMETRICW  *otm,
 868                                    TMDIFF *Tmd)
 869 {
 870   PDC dc;
 871   PDC_ATTR pdcattr;
 872   PTEXTOBJ TextObj;
 873   PFONTGDI FontGDI;
 874   HFONT hFont = 0;
 875   ULONG Size;
 876   OUTLINETEXTMETRICW *potm;
 877   NTSTATUS Status = STATUS_SUCCESS;
 878
 879   dc = DC_LockDc(hDC);
 880   if (!dc)
 881   {
 882      EngSetLastError(ERROR_INVALID_HANDLE);
 883      return 0;
 884   }
 885   pdcattr = dc->pdcattr;
 886   hFont = pdcattr->hlfntNew;
 887   TextObj = RealizeFontInit(hFont);
 888   DC_UnlockDc(dc);
 889   if (!TextObj)
 890   {
 891      EngSetLastError(ERROR_INVALID_HANDLE);
 892      return 0;
 893   }
 894   FontGDI = ObjToGDI(TextObj->Font, FONT);
 895   TextIntUpdateSize(dc, TextObj, FontGDI, TRUE);
 896   TEXTOBJ_UnlockText(TextObj);
 897   Size = IntGetOutlineTextMetrics(FontGDI, 0, NULL);
 898   if (!otm) return Size;
 899   if (Size > Data)
 900   {
 901       EngSetLastError(ERROR_INSUFFICIENT_BUFFER);
 902       return 0;
 903   }
 904   potm = ExAllocatePoolWithTag(PagedPool, Size, GDITAG_TEXT);
 905   if (!potm)
 906   {
 907       EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
 908       return 0;
 909   }
 910   IntGetOutlineTextMetrics(FontGDI, Size, potm);
 911   if (otm)
 912   {
 913      _SEH2_TRY
 914      {
 915          ProbeForWrite(otm, Size, 1);
 916          RtlCopyMemory(otm, potm, Size);
 917      }
 918      _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 919      {
 920          Status = _SEH2_GetExceptionCode();
 921      }
 922      _SEH2_END
 923
 924      if (!NT_SUCCESS(Status))
 925      {
 926         EngSetLastError(ERROR_INVALID_PARAMETER);
 927         Size = 0;
 928      }
 929   }
 930   ExFreePoolWithTag(potm,GDITAG_TEXT);
 931   return Size;
 932 }
 933
 934 W32KAPI
 935 BOOL
 936 APIENTRY
 937 NtGdiGetFontResourceInfoInternalW(
 938     IN LPWSTR       pwszFiles,
 939     IN ULONG        cwc,
 940     IN ULONG        cFiles,
 941     IN UINT         cjIn,
 942     IN OUT LPDWORD  pdwBytes,
 943     OUT LPVOID      pvBuf,
 944     IN DWORD        dwType)
 945 {
 946     NTSTATUS Status = STATUS_SUCCESS;
 947     DWORD dwBytes, dwBytesRequested;
 948     UNICODE_STRING SafeFileNames;
 949     BOOL bRet = FALSE;
 950     ULONG cbStringSize;
 951     LPVOID Buffer;
 952
 953     /* FIXME: Handle cFiles > 0 */
 954
 955     /* Check for valid dwType values */
 956     if (dwType > 5)
 957     {
 958         EngSetLastError(ERROR_INVALID_PARAMETER);
 959         return FALSE;
 960     }
 961
 962     /* Allocate a safe unicode string buffer */
 963     cbStringSize = cwc * sizeof(WCHAR);
 964     SafeFileNames.MaximumLength = SafeFileNames.Length = (USHORT)cbStringSize - sizeof(WCHAR);
 965     SafeFileNames.Buffer = ExAllocatePoolWithTag(PagedPool,
 966                                                  cbStringSize,
 967                                                  TAG_USTR);
 968     if (!SafeFileNames.Buffer)
 969     {
 970         EngSetLastError(ERROR_NOT_ENOUGH_MEMORY);
 971         return FALSE;
 972     }
 973     RtlZeroMemory(SafeFileNames.Buffer, SafeFileNames.MaximumLength);
 974
 975     /* Check buffers and copy pwszFiles to safe unicode string */
 976     _SEH2_TRY
 977     {
 978         ProbeForRead(pwszFiles, cbStringSize, 1);
 979         ProbeForWrite(pdwBytes, sizeof(DWORD), 1);
 980         if (pvBuf)
 981             ProbeForWrite(pvBuf, cjIn, 1);
 982
 983         dwBytes = *pdwBytes;
 984         dwBytesRequested = dwBytes;
 985
 986         RtlCopyMemory(SafeFileNames.Buffer, pwszFiles, cbStringSize);
 987         if (dwBytes > 0)
 988         {
 989             Buffer = ExAllocatePoolWithTag(PagedPool, dwBytes, TAG_FINF);
 990         }
 991         else
 992         {
 993             Buffer = ExAllocatePoolWithTag(PagedPool, sizeof(DWORD), TAG_FINF);
 994         }
 995     }
 996     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 997     {
 998         Status = _SEH2_GetExceptionCode();
 999     }
1000     _SEH2_END
1001
1002     if(!NT_SUCCESS(Status))
1003     {
1004         SetLastNtError(Status);
1005         /* Free the string buffer for the safe filename */
1006         ExFreePoolWithTag(SafeFileNames.Buffer, TAG_USTR);
1007         return FALSE;
1008     }
1009
1010     /* Do the actual call */
1011     bRet = IntGdiGetFontResourceInfo(&SafeFileNames,
1012                                      (pvBuf ? Buffer : NULL),
1013                                      &dwBytes, dwType);
1014
1015     /* Check if succeeded */
1016     if (bRet)
1017     {
1018         /* Copy the data back to caller */
1019         _SEH2_TRY
1020         {
1021             /* Buffers are already probed */
1022             if (pvBuf && dwBytesRequested > 0)
1023                 RtlCopyMemory(pvBuf, Buffer, min(dwBytesRequested, dwBytes));
1024             *pdwBytes = dwBytes;
1025         }
1026         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1027         {
1028             Status = _SEH2_GetExceptionCode();
1029         }
1030         _SEH2_END
1031
1032         if(!NT_SUCCESS(Status))
1033         {
1034             SetLastNtError(Status);
1035             bRet = FALSE;
1036         }
1037     }
1038
1039     ExFreePoolWithTag(Buffer, TAG_FINF);
1040     /* Free the string for the safe filenames */
1041     ExFreePoolWithTag(SafeFileNames.Buffer, TAG_USTR);
1042
1043     return bRet;
1044 }
1045
1046  /*
1047  * @unimplemented
1048  */
1049 BOOL
1050 APIENTRY
1051 NtGdiGetRealizationInfo(
1052     IN HDC hdc,
1053     OUT PREALIZATION_INFO pri,
1054     IN HFONT hf)
1055 {
1056   PDC pDc;
1057   PTEXTOBJ pTextObj;
1058   PFONTGDI pFontGdi;
1059   PDC_ATTR pdcattr;
1060   BOOL Ret = FALSE;
1061   INT i = 0;
1062   REALIZATION_INFO ri;
1063
1064   pDc = DC_LockDc(hdc);
1065   if (!pDc)
1066   {
1067      EngSetLastError(ERROR_INVALID_HANDLE);
1068      return 0;
1069   }
1070   pdcattr = pDc->pdcattr;
1071   pTextObj = RealizeFontInit(pdcattr->hlfntNew);
1072   pFontGdi = ObjToGDI(pTextObj->Font, FONT);
1073   TEXTOBJ_UnlockText(pTextObj);
1074   DC_UnlockDc(pDc);
1075
1076   Ret = ftGdiRealizationInfo(pFontGdi, &ri);
1077   if (Ret)
1078   {
1079      if (pri)
1080      {
1081         NTSTATUS Status = STATUS_SUCCESS;
1082         _SEH2_TRY
1083         {
1084             ProbeForWrite(pri, sizeof(REALIZATION_INFO), 1);
1085             RtlCopyMemory(pri, &ri, sizeof(REALIZATION_INFO));
1086         }
1087         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1088         {
1089             Status = _SEH2_GetExceptionCode();
1090         }
1091         _SEH2_END
1092
1093         if(!NT_SUCCESS(Status))
1094         {
1095             SetLastNtError(Status);
1096             return FALSE;
1097         }
1098      }
1099      do
1100      {
1101         if (GdiHandleTable->cfPublic[i].hf == hf)
1102         {
1103            GdiHandleTable->cfPublic[i].iTechnology = ri.iTechnology;
1104            GdiHandleTable->cfPublic[i].iUniq = ri.iUniq;
1105            GdiHandleTable->cfPublic[i].dwUnknown = ri.dwUnknown;
1106            GdiHandleTable->cfPublic[i].dwCFCount = GdiHandleTable->dwCFCount;
1107            GdiHandleTable->cfPublic[i].fl |= CFONT_REALIZATION;
1108         }
1109         i++;
1110      }
1111      while ( i < GDI_CFONT_MAX );
1112   }
1113   return Ret;
1114 }
1115
1116
1117 HFONT
1118 APIENTRY
1119 HfontCreate(
1120   IN PENUMLOGFONTEXDVW pelfw,
1121   IN ULONG cjElfw,
1122   IN LFTYPE lft,
1123   IN FLONG  fl,
1124   IN PVOID pvCliData )
1125 {
1126   HFONT hNewFont;
1127   PLFONT plfont;
1128
1129   if (!pelfw)
1130   {
1131       return NULL;
1132   }
1133
1134   plfont = LFONT_AllocFontWithHandle();
1135   if (!plfont)
1136   {
1137       return NULL;
1138   }
1139   hNewFont = plfont->BaseObject.hHmgr;
1140
1141   plfont->lft = lft;
1142   plfont->fl  = fl;
1143   RtlCopyMemory (&plfont->logfont, pelfw, sizeof(ENUMLOGFONTEXDVW));
1144   ExInitializePushLock(&plfont->lock);
1145
1146   if (pelfw->elfEnumLogfontEx.elfLogFont.lfEscapement !=
1147       pelfw->elfEnumLogfontEx.elfLogFont.lfOrientation)
1148   {
1149     /* This should really depend on whether GM_ADVANCED is set */
1150     plfont->logfont.elfEnumLogfontEx.elfLogFont.lfOrientation =
1151     plfont->logfont.elfEnumLogfontEx.elfLogFont.lfEscapement;
1152   }
1153   LFONT_UnlockFont(plfont);
1154
1155   if (pvCliData && hNewFont)
1156   {
1157     // FIXME: Use GDIOBJ_InsertUserData
1158     KeEnterCriticalRegion();
1159     {
1160        INT Index = GDI_HANDLE_GET_INDEX((HGDIOBJ)hNewFont);
1161        PGDI_TABLE_ENTRY Entry = &GdiHandleTable->Entries[Index];
1162        Entry->UserData = pvCliData;
1163     }
1164     KeLeaveCriticalRegion();
1165   }
1166
1167   return hNewFont;
1168 }
1169
1170
1171 HFONT
1172 APIENTRY
1173 NtGdiHfontCreate(
1174   IN PENUMLOGFONTEXDVW pelfw,
1175   IN ULONG cjElfw,
1176   IN LFTYPE lft,
1177   IN FLONG  fl,
1178   IN PVOID pvCliData )
1179 {
1180   ENUMLOGFONTEXDVW SafeLogfont;
1181   NTSTATUS Status = STATUS_SUCCESS;
1182
1183   /* Silence GCC warnings */
1184   SafeLogfont.elfEnumLogfontEx.elfLogFont.lfEscapement = 0;
1185   SafeLogfont.elfEnumLogfontEx.elfLogFont.lfOrientation = 0;
1186
1187   if (!pelfw)
1188   {
1189       return NULL;
1190   }
1191
1192   _SEH2_TRY
1193   {
1194       ProbeForRead(pelfw, sizeof(ENUMLOGFONTEXDVW), 1);
1195       RtlCopyMemory(&SafeLogfont, pelfw, sizeof(ENUMLOGFONTEXDVW));
1196   }
1197   _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1198   {
1199       Status = _SEH2_GetExceptionCode();
1200   }
1201   _SEH2_END
1202
1203   if (!NT_SUCCESS(Status))
1204   {
1205       return NULL;
1206   }
1207
1208   return HfontCreate(&SafeLogfont, cjElfw, lft, fl, pvCliData);
1209 }
1210
1211
1212 /* EOF */