vcl/win/gdi/winlayout.cxx

   1
   2 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   3 /*
   4  * This file is part of the LibreOffice project.
   5  *
   6  * This Source Code Form is subject to the terms of the Mozilla Public
   7  * License, v. 2.0. If a copy of the MPL was not distributed with this
   8  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   9  *
  10  * This file incorporates work covered by the following license notice:
  11  *
  12  *   Licensed to the Apache Software Foundation (ASF) under one or more
  13  *   contributor license agreements. See the NOTICE file distributed
  14  *   with this work for additional information regarding copyright
  15  *   ownership. The ASF licenses this file to you under the Apache
  16  *   License, Version 2.0 (the "License"); you may not use this file
  17  *   except in compliance with the License. You may obtain a copy of
  18  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  19  */
  20
  21 #include <memory>
  22 #include <osl/module.h>
  23 #include <osl/file.h>
  24 #include <sal/log.hxx>
  25
  26 #include <comphelper/windowserrorstring.hxx>
  27 #include <comphelper/scopeguard.hxx>
  28
  29 #include <opengl/texture.hxx>
  30 #include <opengl/win/gdiimpl.hxx>
  31
  32 #include <vcl/opengl/OpenGLHelper.hxx>
  33 #include <win/salgdi.h>
  34 #include <win/saldata.hxx>
  35 #include <outdev.h>
  36
  37 #include <win/DWriteTextRenderer.hxx>
  38 #include <win/scoped_gdi.hxx>
  39
  40 #include <sft.hxx>
  41 #include <sallayout.hxx>
  42
  43 #include <cstdio>
  44 #include <cstdlib>
  45
  46 #include <rtl/character.hxx>
  47
  48 #include <boost/functional/hash.hpp>
  49 #include <algorithm>
  50
  51 #include <shlwapi.h>
  52 #include <winver.h>
  53
  54 GlobalOpenGLGlyphCache * GlobalOpenGLGlyphCache::get()
  55 {
  56     SalData *data = GetSalData();
  57     if (!data->m_pGlobalOpenGLGlyphCache)
  58         data->m_pGlobalOpenGLGlyphCache.reset(new GlobalOpenGLGlyphCache);
  59     return data->m_pGlobalOpenGLGlyphCache.get();
  60 }
  61
  62 bool WinFontInstance::CacheGlyphToAtlas(HDC hDC, HFONT hFont, int nGlyphIndex,
  63                                         SalGraphics& rGraphics, const GenericSalLayout& rLayout)
  64 {
  65     OpenGLGlyphDrawElement aElement;
  66
  67     ScopedHDC aHDC(CreateCompatibleDC(hDC));
  68
  69     if (!aHDC)
  70     {
  71         SAL_WARN("vcl.gdi", "CreateCompatibleDC failed: " << WindowsErrorString(GetLastError()));
  72         return false;
  73     }
  74
  75     const HFONT hOrigFont = static_cast<HFONT>(SelectObject(aHDC.get(), hFont));
  76     if (hOrigFont == nullptr)
  77     {
  78         SAL_WARN("vcl.gdi", "SelectObject failed: " << WindowsErrorString(GetLastError()));
  79         return false;
  80     }
  81     const ::comphelper::ScopeGuard aHFONTrestoreScopeGuard(
  82         [&aHDC,hOrigFont]() { SelectFont(aHDC.get(), hOrigFont); });
  83
  84     // For now we assume DWrite is present and we won't bother with fallback paths.
  85     D2DWriteTextOutRenderer * pTxt = dynamic_cast<D2DWriteTextOutRenderer *>(&TextOutRenderer::get(true));
  86     if (!pTxt)
  87         return false;
  88
  89     pTxt->changeTextAntiAliasMode(D2DTextAntiAliasMode::AntiAliased);
  90
  91     if (!pTxt->BindFont(aHDC.get()))
  92     {
  93         SAL_WARN("vcl.gdi", "Binding of font failed. The font might not be supported by DirectWrite.");
  94         return false;
  95     }
  96     const ::comphelper::ScopeGuard aFontReleaseScopeGuard([&pTxt]() { pTxt->ReleaseFont(); });
  97
  98     std::vector<WORD> aGlyphIndices(1);
  99     aGlyphIndices[0] = nGlyphIndex;
 100     // Fetch the ink boxes and calculate the size of the atlas.
 101     tools::Rectangle bounds(0, 0, 0, 0);
 102     auto aInkBoxes = pTxt->GetGlyphInkBoxes(aGlyphIndices.data(), aGlyphIndices.data() + 1);
 103     if (aInkBoxes.empty())
 104         return false;
 105
 106     for (auto &box : aInkBoxes)
 107         bounds.Union(box + Point(bounds.Right(), 0));
 108
 109     // bounds.Top() is the offset from the baseline at (0,0) to the top of the
 110     // inkbox.
 111     aElement.mnBaselineOffset = -bounds.Top();
 112     aElement.mnHeight = bounds.getHeight();
 113     aElement.mbVertical = false;
 114
 115     // Try hard to avoid overlap as we want to be able to use
 116     // individual rectangles for each glyph. The ABC widths don't
 117     // take anti-aliasing into consideration. Let's hope that leaving
 118     // "extra" space between glyphs will help.
 119     std::vector<float> aGlyphAdv(1);   // offsets between glyphs
 120     std::vector<DWRITE_GLYPH_OFFSET> aGlyphOffset(1, {0.0f, 0.0f});
 121     std::vector<int> aEnds(1); // end of each glyph box
 122     float fHScale = getHScale();
 123     float totWidth = 0;
 124     {
 125         int overhang = aInkBoxes[0].Left();
 126         int blackWidth = aInkBoxes[0].getWidth() * fHScale; // width of non-AA pixels
 127         aElement.maLeftOverhangs = overhang;
 128
 129         aGlyphAdv[0] = blackWidth + aElement.getExtraSpace();
 130         aGlyphOffset[0].advanceOffset = -overhang;
 131
 132         totWidth += aGlyphAdv[0];
 133         aEnds[0] = totWidth;
 134     }
 135     // Leave extra space also at top and bottom
 136     int nBitmapWidth = totWidth;
 137     int nBitmapHeight = bounds.getHeight() + aElement.getExtraSpace();
 138
 139     UINT nPos = 0;
 140
 141     aElement.maLocation.SetLeft(nPos);
 142     aElement.maLocation.SetRight(aEnds[0]);
 143     aElement.maLocation.SetTop(0);
 144     aElement.maLocation.SetBottom(bounds.getHeight() + aElement.getExtraSpace());
 145     nPos = aEnds[0];
 146
 147     OpenGLCompatibleDC aDC(rGraphics, 0, 0, nBitmapWidth, nBitmapHeight);
 148
 149     SetTextColor(aDC.getCompatibleHDC(), RGB(0, 0, 0));
 150     SetBkColor(aDC.getCompatibleHDC(), RGB(255, 255, 255));
 151
 152     aDC.fill(RGB(0xff, 0xff, 0xff));
 153
 154     pTxt->BindDC(aDC.getCompatibleHDC(), tools::Rectangle(0, 0, nBitmapWidth, nBitmapHeight));
 155     auto pRT = pTxt->GetRenderTarget();
 156
 157     ID2D1SolidColorBrush* pBrush = nullptr;
 158     if (!SUCCEEDED(pRT->CreateSolidColorBrush(D2D1::ColorF(D2D1::ColorF::Black), &pBrush)))
 159         return false;
 160
 161     D2D1_POINT_2F baseline = {
 162         static_cast<FLOAT>(aElement.getExtraOffset()),
 163         static_cast<FLOAT>(aElement.getExtraOffset() + aElement.mnBaselineOffset)
 164     };
 165
 166     DWRITE_GLYPH_RUN glyphs = {
 167         pTxt->GetFontFace(),
 168         pTxt->GetEmHeight(),
 169         1,
 170         aGlyphIndices.data(),
 171         aGlyphAdv.data(),
 172         aGlyphOffset.data(),
 173         false,
 174         0
 175     };
 176
 177     WinFontTransformGuard aTransformGuard(pRT, fHScale, rLayout, baseline);
 178     pRT->BeginDraw();
 179     pRT->DrawGlyphRun(baseline, &glyphs, pBrush);
 180     HRESULT hResult = pRT->EndDraw();
 181
 182     pBrush->Release();
 183
 184     switch (hResult)
 185     {
 186     case S_OK:
 187         break;
 188     case D2DERR_RECREATE_TARGET:
 189         pTxt->CreateRenderTarget();
 190         break;
 191     default:
 192         SAL_WARN("vcl.gdi", "DrawGlyphRun-EndDraw failed: " << WindowsErrorString(GetLastError()));
 193         return false;
 194     }
 195
 196     if (!OpenGLGlyphCache::ReserveTextureSpace(aElement, nBitmapWidth, nBitmapHeight))
 197         return false;
 198     if (!aDC.copyToTexture(aElement.maTexture))
 199         return false;
 200
 201     maOpenGLGlyphCache.PutDrawElementInCache(aElement, nGlyphIndex);
 202
 203     return true;
 204 }
 205
 206 TextOutRenderer & TextOutRenderer::get(bool bUseDWrite)
 207 {
 208     SalData *const pSalData = GetSalData();
 209
 210     if (!pSalData)
 211     {   // don't call this after DeInitVCL()
 212         fprintf(stderr, "TextOutRenderer fatal error: no SalData");
 213         abort();
 214     }
 215
 216     if (bUseDWrite)
 217     {
 218         if (!pSalData->m_pD2DWriteTextOutRenderer)
 219         {
 220             pSalData->m_pD2DWriteTextOutRenderer.reset(new D2DWriteTextOutRenderer());
 221         }
 222         return *pSalData->m_pD2DWriteTextOutRenderer;
 223     }
 224     if (!pSalData->m_pExTextOutRenderer)
 225     {
 226         pSalData->m_pExTextOutRenderer.reset(new ExTextOutRenderer);
 227     }
 228     return *pSalData->m_pExTextOutRenderer;
 229 }
 230
 231
 232 bool ExTextOutRenderer::operator ()(GenericSalLayout const &rLayout,
 233     SalGraphics & /*rGraphics*/,
 234     HDC hDC)
 235 {
 236     HFONT hFont = static_cast<HFONT>(GetCurrentObject( hDC, OBJ_FONT ));
 237     ScopedHFONT hAltFont;
 238     bool bUseAltFont = false;
 239     bool bShift = false;
 240     if (rLayout.GetFont().GetFontSelectPattern().mbVertical)
 241     {
 242         LOGFONTW aLogFont;
 243         GetObjectW(hFont, sizeof(aLogFont), &aLogFont);
 244         if (aLogFont.lfFaceName[0] == '@')
 245         {
 246             memmove(&aLogFont.lfFaceName[0], &aLogFont.lfFaceName[1],
 247                 sizeof(aLogFont.lfFaceName)-sizeof(aLogFont.lfFaceName[0]));
 248             hAltFont.reset(CreateFontIndirectW(&aLogFont));
 249         }
 250         else
 251         {
 252             bShift = true;
 253             aLogFont.lfEscapement += 2700;
 254             aLogFont.lfOrientation = aLogFont.lfEscapement;
 255             hAltFont.reset(CreateFontIndirectW(&aLogFont));
 256         }
 257     }
 258
 259     UINT nTextAlign = GetTextAlign ( hDC );
 260     int nStart = 0;
 261     Point aPos(0, 0);
 262     const GlyphItem* pGlyph;
 263     while (rLayout.GetNextGlyph(&pGlyph, aPos, nStart))
 264     {
 265         WORD glyphWStr[] = { pGlyph->glyphId() };
 266         if (hAltFont && pGlyph->IsVertical() == bUseAltFont)
 267         {
 268             bUseAltFont = !bUseAltFont;
 269             SelectFont(hDC, bUseAltFont ? hAltFont.get() : hFont);
 270         }
 271         if (bShift && pGlyph->IsVertical())
 272             SetTextAlign(hDC, TA_TOP|TA_LEFT);
 273
 274         ExtTextOutW(hDC, aPos.X(), aPos.Y(), ETO_GLYPH_INDEX, nullptr, LPCWSTR(&glyphWStr), 1, nullptr);
 275
 276         if (bShift && pGlyph->IsVertical())
 277             SetTextAlign(hDC, nTextAlign);
 278     }
 279     if (hAltFont)
 280     {
 281         if (bUseAltFont)
 282             SelectFont(hDC, hFont);
 283     }
 284
 285     return true;
 286 }
 287
 288 std::unique_ptr<GenericSalLayout> WinSalGraphics::GetTextLayout(int nFallbackLevel)
 289 {
 290     assert(mpWinFontEntry[nFallbackLevel]);
 291     if (!mpWinFontEntry[nFallbackLevel])
 292         return nullptr;
 293
 294     assert(mpWinFontEntry[nFallbackLevel]->GetFontFace());
 295
 296     mpWinFontEntry[nFallbackLevel]->SetGraphics(this);
 297     return std::make_unique<GenericSalLayout>(*mpWinFontEntry[nFallbackLevel]);
 298 }
 299
 300 WinFontInstance::WinFontInstance(const WinFontFace& rPFF, const FontSelectPattern& rFSP)
 301     : LogicalFontInstance(rPFF, rFSP)
 302     , m_pGraphics(nullptr)
 303     , m_hFont(nullptr)
 304     , m_fScale(1.0f)
 305 {
 306 }
 307
 308 WinFontInstance::~WinFontInstance()
 309 {
 310     if (m_hFont)
 311         ::DeleteFont(m_hFont);
 312 }
 313
 314 bool WinFontInstance::hasHScale() const
 315 {
 316     const FontSelectPattern &rPattern = GetFontSelectPattern();
 317     int nHeight(rPattern.mnHeight);
 318     int nWidth(rPattern.mnWidth ? rPattern.mnWidth * GetAverageWidthFactor() : nHeight);
 319     return nWidth != nHeight;
 320 }
 321
 322 float WinFontInstance::getHScale() const
 323 {
 324     const FontSelectPattern& rPattern = GetFontSelectPattern();
 325     int nHeight(rPattern.mnHeight);
 326     if (!nHeight)
 327         return 1.0;
 328     float nWidth(rPattern.mnWidth ? rPattern.mnWidth * GetAverageWidthFactor() : nHeight);
 329     return nWidth / nHeight;
 330 }
 331
 332 struct BlobReference
 333 {
 334     hb_blob_t* mpBlob;
 335     BlobReference(hb_blob_t* pBlob) : mpBlob(pBlob)
 336     {
 337         hb_blob_reference(mpBlob);
 338     }
 339     BlobReference(BlobReference const & other)
 340         : mpBlob(other.mpBlob)
 341     {
 342         hb_blob_reference(mpBlob);
 343     }
 344     ~BlobReference() { hb_blob_destroy(mpBlob); }
 345 };
 346 using BlobCacheKey = std::pair<rtl::Reference<PhysicalFontFace>, hb_tag_t>;
 347 struct BlobCacheKeyHash
 348 {
 349     std::size_t operator()(BlobCacheKey const& rKey) const
 350     {
 351         std::size_t seed = 0;
 352         boost::hash_combine(seed, rKey.first.get());
 353         boost::hash_combine(seed, rKey.second);
 354         return seed;
 355     }
 356 };
 357
 358 static hb_blob_t* getFontTable(hb_face_t* /*face*/, hb_tag_t nTableTag, void* pUserData)
 359 {
 360     static o3tl::lru_map<BlobCacheKey, BlobReference, BlobCacheKeyHash> gCache(50);
 361
 362     WinFontInstance* pFont = static_cast<WinFontInstance*>(pUserData);
 363     HDC hDC = pFont->GetGraphics()->getHDC();
 364     HFONT hFont = pFont->GetHFONT();
 365     assert(hDC);
 366     assert(hFont);
 367
 368     BlobCacheKey cacheKey { rtl::Reference<PhysicalFontFace>(pFont->GetFontFace()), nTableTag };
 369     auto it = gCache.find(cacheKey);
 370     if (it != gCache.end())
 371     {
 372         hb_blob_reference(it->second.mpBlob);
 373         return it->second.mpBlob;
 374     }
 375
 376     sal_uLong nLength = 0;
 377     unsigned char* pBuffer = nullptr;
 378
 379     HGDIOBJ hOrigFont = SelectObject(hDC, hFont);
 380     nLength = ::GetFontData(hDC, OSL_NETDWORD(nTableTag), 0, nullptr, 0);
 381     if (nLength > 0 && nLength != GDI_ERROR)
 382     {
 383         pBuffer = new unsigned char[nLength];
 384         ::GetFontData(hDC, OSL_NETDWORD(nTableTag), 0, pBuffer, nLength);
 385     }
 386     SelectObject(hDC, hOrigFont);
 387
 388     if (!pBuffer)
 389         return nullptr;
 390
 391     hb_blob_t* pBlob = hb_blob_create(reinterpret_cast<const char*>(pBuffer), nLength, HB_MEMORY_MODE_READONLY,
 392                                pBuffer, [](void* data){ delete[] static_cast<unsigned char*>(data); });
 393     if (!pBlob)
 394         return pBlob;
 395     gCache.insert({cacheKey, BlobReference(pBlob)});
 396     return pBlob;
 397 }
 398
 399 hb_font_t* WinFontInstance::ImplInitHbFont()
 400 {
 401     assert(m_pGraphics);
 402     hb_font_t* pHbFont = InitHbFont(hb_face_create_for_tables(getFontTable, this, nullptr));
 403
 404     // Calculate the AverageWidthFactor, see LogicalFontInstance::GetScale().
 405     if (GetFontSelectPattern().mnWidth)
 406     {
 407         double nUPEM = hb_face_get_upem(hb_font_get_face(pHbFont));
 408
 409         LOGFONTW aLogFont;
 410         GetObjectW(m_hFont, sizeof(LOGFONTW), &aLogFont);
 411
 412         // Set the height (font size) to EM to minimize rounding errors.
 413         aLogFont.lfHeight = -nUPEM;
 414         // Set width to the default to get the original value in the metrics.
 415         aLogFont.lfWidth = 0;
 416
 417         TEXTMETRICW aFontMetric;
 418         {
 419             // Get the font metrics.
 420             HDC hDC = m_pGraphics->getHDC();
 421             ScopedSelectedHFONT hFont(hDC, CreateFontIndirectW(&aLogFont));
 422             GetTextMetricsW(hDC, &aFontMetric);
 423         }
 424
 425         SetAverageWidthFactor(nUPEM / aFontMetric.tmAveCharWidth);
 426     }
 427
 428     return pHbFont;
 429 }
 430
 431 void WinFontInstance::SetGraphics(WinSalGraphics *pGraphics)
 432 {
 433     m_pGraphics = pGraphics;
 434     if (m_hFont)
 435         return;
 436     HFONT hOrigFont;
 437     m_hFont = m_pGraphics->ImplDoSetFont(GetFontSelectPattern(), GetFontFace(), m_fScale, hOrigFont);
 438     SelectObject(m_pGraphics->getHDC(), hOrigFont);
 439 }
 440
 441 bool WinSalGraphics::CacheGlyphs(const GenericSalLayout& rLayout)
 442 {
 443     static bool bDoGlyphCaching = (std::getenv("SAL_DISABLE_GLYPH_CACHING") == nullptr);
 444     if (!bDoGlyphCaching)
 445         return false;
 446
 447     if (rLayout.GetOrientation())
 448         // Our caching is incomplete, skip it for non-horizontal text.
 449         return false;
 450
 451     HDC hDC = getHDC();
 452     WinFontInstance& rFont = *static_cast<WinFontInstance*>(&rLayout.GetFont());
 453     HFONT hFONT = rFont.GetHFONT();
 454
 455     int nStart = 0;
 456     Point aPos(0, 0);
 457     const GlyphItem* pGlyph;
 458     while (rLayout.GetNextGlyph(&pGlyph, aPos, nStart))
 459     {
 460         if (!rFont.GetOpenGLGlyphCache().IsGlyphCached(pGlyph->glyphId()))
 461         {
 462             if (!rFont.CacheGlyphToAtlas(hDC, hFONT, pGlyph->glyphId(), *this, rLayout))
 463                 return false;
 464         }
 465     }
 466
 467     return true;
 468 }
 469
 470 bool WinSalGraphics::DrawCachedGlyphs(const GenericSalLayout& rLayout)
 471 {
 472     HDC hDC = getHDC();
 473
 474     tools::Rectangle aRect;
 475     rLayout.GetBoundRect(aRect);
 476
 477     COLORREF color = GetTextColor(hDC);
 478     Color salColor(GetRValue(color), GetGValue(color), GetBValue(color));
 479
 480     WinOpenGLSalGraphicsImpl *pImpl = dynamic_cast<WinOpenGLSalGraphicsImpl*>(mpImpl.get());
 481     if (!pImpl)
 482         return false;
 483
 484     WinFontInstance& rFont = *static_cast<WinFontInstance*>(&rLayout.GetFont());
 485
 486     int nStart = 0;
 487     Point aPos(0, 0);
 488     const GlyphItem* pGlyph;
 489     while (rLayout.GetNextGlyph(&pGlyph, aPos, nStart))
 490     {
 491         OpenGLGlyphDrawElement& rElement(rFont.GetOpenGLGlyphCache().GetDrawElement(pGlyph->glyphId()));
 492         OpenGLTexture& rTexture = rElement.maTexture;
 493
 494         if (!rTexture)
 495             return false;
 496
 497         SalTwoRect a2Rects(0, 0,
 498                            rTexture.GetWidth(), rTexture.GetHeight(),
 499                            aPos.X() - rElement.getExtraOffset() + rElement.maLeftOverhangs,
 500                            aPos.Y() - rElement.mnBaselineOffset - rElement.getExtraOffset(),
 501                            rTexture.GetWidth(), rTexture.GetHeight());
 502
 503         pImpl->DeferredTextDraw(rTexture, salColor, a2Rects);
 504     }
 505
 506     return true;
 507 }
 508
 509 void WinSalGraphics::DrawTextLayout(const GenericSalLayout& rLayout, HDC hDC, bool bUseDWrite)
 510 {
 511     TextOutRenderer &render = TextOutRenderer::get(bUseDWrite);
 512     render(rLayout, *this, hDC);
 513 }
 514
 515 void WinSalGraphics::DrawTextLayout(const GenericSalLayout& rLayout)
 516 {
 517     HDC hDC = getHDC();
 518
 519     const WinFontInstance* pWinFont = static_cast<const WinFontInstance*>(&rLayout.GetFont());
 520     const HFONT hLayoutFont = pWinFont->GetHFONT();
 521     bool bUseOpenGL = OpenGLHelper::isVCLOpenGLEnabled() && !mbPrinter;
 522
 523     // Our DirectWrite renderer is incomplete, skip it for vertical text where glyphs are not
 524     // rotated.
 525     bool bForceGDI = rLayout.GetFont().GetFontSelectPattern().mbVertical;
 526
 527     if (!bUseOpenGL)
 528     {
 529         // no OpenGL, just classic rendering
 530         const HFONT hOrigFont = ::SelectFont(hDC, hLayoutFont);
 531         DrawTextLayout(rLayout, hDC, false);
 532         ::SelectFont(hDC, hOrigFont);
 533     }
 534     // if we can't draw the cached OpenGL glyphs, try to draw a full OpenGL layout
 535     else if (bForceGDI || !CacheGlyphs(rLayout) || !DrawCachedGlyphs(rLayout))
 536     {
 537         // We have to render the text to a hidden texture, and draw it.
 538         //
 539         // Note that Windows GDI does not really support the alpha correctly
 540         // when drawing - ie. it draws nothing to the alpha channel when
 541         // rendering the text, even the antialiasing is done as 'real' pixels,
 542         // not alpha...
 543         //
 544         // Luckily, this does not really limit us:
 545         //
 546         // To blend properly, we draw the texture, but then use it as an alpha
 547         // channel for solid color (that will define the text color).  This
 548         // destroys the subpixel antialiasing - turns it into 'classic'
 549         // antialiasing - but that is the best we can do, because the subpixel
 550         // antialiasing needs to know what is in the background: When the
 551         // background is white, or white-ish, it does the subpixel, but when
 552         // there is a color, it just darkens the color (and does this even
 553         // when part of the character is on a colored background, and part on
 554         // white).  It has to work this way, the results would look strange
 555         // otherwise.
 556         //
 557         // For the GL rendering to work even with the subpixel antialiasing,
 558         // we would need to get the current texture from the screen, let GDI
 559         // draw the text to it (so that it can decide well where to use the
 560         // subpixel and where not), and draw the result - but in that case we
 561         // don't need alpha anyway.
 562         //
 563         // TODO: check the performance of this 2nd approach at some stage and
 564         // switch to that if it performs well.
 565
 566         tools::Rectangle aRect;
 567         rLayout.GetBoundRect(aRect);
 568
 569         WinOpenGLSalGraphicsImpl *pImpl = dynamic_cast<WinOpenGLSalGraphicsImpl*>(mpImpl.get());
 570
 571         if (pImpl)
 572         {
 573             pImpl->PreDraw();
 574
 575             OpenGLCompatibleDC aDC(*this, aRect.Left(), aRect.Top(), aRect.GetWidth(), aRect.GetHeight());
 576
 577             // we are making changes to the DC, make sure we got a new one
 578             assert(aDC.getCompatibleHDC() != hDC);
 579
 580             RECT aWinRect = { aRect.Left(), aRect.Top(), aRect.Left() + aRect.GetWidth(), aRect.Top() + aRect.GetHeight() };
 581             ::FillRect(aDC.getCompatibleHDC(), &aWinRect, static_cast<HBRUSH>(::GetStockObject(WHITE_BRUSH)));
 582
 583             // setup the hidden DC with black color and white background, we will
 584             // use the result of the text drawing later as a mask only
 585             const HFONT hOrigFont = ::SelectFont(aDC.getCompatibleHDC(), hLayoutFont);
 586
 587             ::SetTextColor(aDC.getCompatibleHDC(), RGB(0, 0, 0));
 588             ::SetBkColor(aDC.getCompatibleHDC(), RGB(255, 255, 255));
 589
 590             UINT nTextAlign = ::GetTextAlign(hDC);
 591             ::SetTextAlign(aDC.getCompatibleHDC(), nTextAlign);
 592
 593             COLORREF color = ::GetTextColor(hDC);
 594             Color salColor(GetRValue(color), GetGValue(color), GetBValue(color));
 595
 596             // the actual drawing
 597             DrawTextLayout(rLayout, aDC.getCompatibleHDC(), !bForceGDI);
 598
 599             std::unique_ptr<OpenGLTexture> xTexture(aDC.getTexture());
 600             if (xTexture)
 601                 pImpl->DrawMask(*xTexture, salColor, aDC.getTwoRect());
 602
 603             ::SelectFont(aDC.getCompatibleHDC(), hOrigFont);
 604
 605             pImpl->PostDraw();
 606         }
 607     }
 608 }
 609
 610 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */