1 /************************************************************************* 2 * 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * Copyright 2000, 2010 Oracle and/or its affiliates. 6 * 7 * OpenOffice.org - a multi-platform office productivity suite 8 * 9 * This file is part of OpenOffice.org. 10 * 11 * OpenOffice.org is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public License version 3 13 * only, as published by the Free Software Foundation. 14 * 15 * OpenOffice.org is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU Lesser General Public License version 3 for more details 19 * (a copy is included in the LICENSE file that accompanied this code). 20 * 21 * You should have received a copy of the GNU Lesser General Public License 22 * version 3 along with OpenOffice.org. If not, see 23 * <http://www.openoffice.org/license.html> 24 * for a copy of the LGPLv3 License. 25 * 26 ************************************************************************/ 27 28 // MARKER(update_precomp.py): autogen include statement, do not remove 29 #include "precompiled_vcl.hxx" 30 31 #include "rtl/ustring.hxx" 32 33 #include "osl/module.h" 34 #include "osl/file.h" 35 36 #include "tools/svwin.h" 37 38 #include "vcl/svapp.hxx" 39 40 #include "win/salgdi.h" 41 #include "win/saldata.hxx" 42 43 // for GetMirroredChar 44 #include "sft.hxx" 45 #include "sallayout.hxx" 46 47 #include <cstdio> 48 #include <malloc.h> 49 #ifndef __MINGW32__ 50 #define alloca _alloca 51 #endif 52 53 #ifdef GCP_KERN_HACK 54 #include <algorithm> 55 #endif // GCP_KERN_HACK 56 57 58 #define USE_UNISCRIBE 59 #ifdef USE_UNISCRIBE 60 #include <Usp10.h> 61 #include <ShLwApi.h> 62 #include <winver.h> 63 #endif // USE_UNISCRIBE 64 65 #include <hash_map> 66 #include <set> 67 68 typedef std::hash_map<int,int> IntMap; 69 typedef std::set<int> IntSet; 70 71 // Graphite headers 72 #ifdef ENABLE_GRAPHITE 73 #include <i18npool/mslangid.hxx> 74 #include <graphite/GrClient.h> 75 #include <graphite/WinFont.h> 76 #include <graphite/Segment.h> 77 #include <graphite_layout.hxx> 78 #include <graphite_cache.hxx> 79 #include <graphite_features.hxx> 80 #endif 81 82 #define DROPPED_OUTGLYPH 0xFFFF 83 84 using namespace rtl; 85 86 // ======================================================================= 87 88 // win32 specific physical font instance 89 class ImplWinFontEntry : public ImplFontEntry 90 { 91 public: 92 ImplWinFontEntry( ImplFontSelectData& ); 93 ~ImplWinFontEntry(); 94 95 private: 96 // TODO: also add HFONT??? Watch out for issues with too many active fonts... 97 98 #ifdef GCP_KERN_HACK 99 public: 100 bool HasKernData() const; 101 void SetKernData( int, const KERNINGPAIR* ); 102 int GetKerning( sal_Unicode, sal_Unicode ) const; 103 private: 104 KERNINGPAIR* mpKerningPairs; 105 int mnKerningPairs; 106 #endif // GCP_KERN_HACK 107 108 #ifdef USE_UNISCRIBE 109 public: 110 SCRIPT_CACHE& GetScriptCache() const 111 { return maScriptCache; } 112 private: 113 mutable SCRIPT_CACHE maScriptCache; 114 #endif // USE_UNISCRIBE 115 116 public: 117 int GetCachedGlyphWidth( int nCharCode ) const; 118 void CacheGlyphWidth( int nCharCode, int nCharWidth ); 119 120 bool InitKashidaHandling( HDC ); 121 int GetMinKashidaWidth() const { return mnMinKashidaWidth; } 122 int GetMinKashidaGlyph() const { return mnMinKashidaGlyph; } 123 124 private: 125 IntMap maWidthMap; 126 mutable int mnMinKashidaWidth; 127 mutable int mnMinKashidaGlyph; 128 }; 129 130 // ----------------------------------------------------------------------- 131 132 inline void ImplWinFontEntry::CacheGlyphWidth( int nCharCode, int nCharWidth ) 133 { 134 maWidthMap[ nCharCode ] = nCharWidth; 135 } 136 137 inline int ImplWinFontEntry::GetCachedGlyphWidth( int nCharCode ) const 138 { 139 IntMap::const_iterator it = maWidthMap.find( nCharCode ); 140 if( it == maWidthMap.end() ) 141 return -1; 142 return it->second; 143 } 144 145 // ======================================================================= 146 147 class WinLayout : public SalLayout 148 { 149 public: 150 WinLayout( HDC, const ImplWinFontData&, ImplWinFontEntry& ); 151 virtual void InitFont() const; 152 void SetFontScale( float f ) { mfFontScale = f; } 153 float GetFontScale() const { return mfFontScale; } 154 HFONT DisableFontScaling( void) const; 155 156 #ifdef USE_UNISCRIBE 157 SCRIPT_CACHE& GetScriptCache() const 158 { return mrWinFontEntry.GetScriptCache(); } 159 #endif // USE_UNISCRIBE 160 161 protected: 162 HDC mhDC; // WIN32 device handle 163 HFONT mhFont; // WIN32 font handle 164 int mnBaseAdv; // x-offset relative to Layout origin 165 float mfFontScale; // allows metrics emulation of huge font sizes 166 167 const ImplWinFontData& mrWinFontData; 168 ImplWinFontEntry& mrWinFontEntry; 169 }; 170 171 // ======================================================================= 172 173 class SimpleWinLayout : public WinLayout 174 { 175 public: 176 SimpleWinLayout( HDC, BYTE nCharSet, const ImplWinFontData&, ImplWinFontEntry& ); 177 virtual ~SimpleWinLayout(); 178 179 virtual bool LayoutText( ImplLayoutArgs& ); 180 virtual void AdjustLayout( ImplLayoutArgs& ); 181 virtual void DrawText( SalGraphics& ) const; 182 183 virtual int GetNextGlyphs( int nLen, sal_GlyphId* pGlyphs, Point& rPos, int&, 184 sal_Int32* pGlyphAdvances, int* pCharIndexes ) const; 185 186 virtual long FillDXArray( long* pDXArray ) const; 187 virtual int GetTextBreak( long nMaxWidth, long nCharExtra, int nFactor ) const; 188 virtual void GetCaretPositions( int nArraySize, long* pCaretXArray ) const; 189 190 // for glyph+font+script fallback 191 virtual void MoveGlyph( int nStart, long nNewXPos ); 192 virtual void DropGlyph( int nStart ); 193 virtual void Simplify( bool bIsBase ); 194 195 protected: 196 void Justify( long nNewWidth ); 197 void ApplyDXArray( const ImplLayoutArgs& ); 198 199 private: 200 int mnGlyphCount; 201 int mnCharCount; 202 WCHAR* mpOutGlyphs; 203 int* mpGlyphAdvances; // if possible this is shared with mpGlyphAdvances[] 204 int* mpGlyphOrigAdvs; 205 int* mpCharWidths; // map rel char pos to char width 206 int* mpChars2Glyphs; // map rel char pos to abs glyph pos 207 int* mpGlyphs2Chars; // map abs glyph pos to abs char pos 208 bool* mpGlyphRTLFlags; // BiDi status for glyphs: true=>RTL 209 mutable long mnWidth; 210 bool mbDisableGlyphs; 211 212 int mnNotdefWidth; 213 BYTE mnCharSet; 214 }; 215 216 // ======================================================================= 217 218 WinLayout::WinLayout( HDC hDC, const ImplWinFontData& rWFD, ImplWinFontEntry& rWFE ) 219 : mhDC( hDC ), 220 mhFont( (HFONT)::GetCurrentObject(hDC,OBJ_FONT) ), 221 mnBaseAdv( 0 ), 222 mfFontScale( 1.0 ), 223 mrWinFontData( rWFD ), 224 mrWinFontEntry( rWFE ) 225 {} 226 227 // ----------------------------------------------------------------------- 228 229 void WinLayout::InitFont() const 230 { 231 ::SelectObject( mhDC, mhFont ); 232 } 233 234 // ----------------------------------------------------------------------- 235 236 // Using reasonably sized fonts to emulate huge fonts works around 237 // a lot of problems in printer and display drivers. Huge fonts are 238 // mostly used by high resolution reference devices which are never 239 // painted to anyway. In the rare case that a huge font needs to be 240 // displayed somewhere then the workaround doesn't help anymore. 241 // If the drivers fail silently for huge fonts, so be it... 242 HFONT WinLayout::DisableFontScaling() const 243 { 244 if( mfFontScale == 1.0 ) 245 return 0; 246 247 LOGFONTW aLogFont; 248 ::GetObjectW( mhFont, sizeof(LOGFONTW), &aLogFont); 249 aLogFont.lfHeight = (LONG)(mfFontScale * aLogFont.lfHeight); 250 aLogFont.lfWidth = (LONG)(mfFontScale * aLogFont.lfWidth); 251 HFONT hHugeFont = ::CreateFontIndirectW( &aLogFont); 252 if( !hHugeFont ) 253 return 0; 254 255 return SelectFont( mhDC, hHugeFont ); 256 } 257 258 // ======================================================================= 259 260 SimpleWinLayout::SimpleWinLayout( HDC hDC, BYTE nCharSet, 261 const ImplWinFontData& rWinFontData, ImplWinFontEntry& rWinFontEntry ) 262 : WinLayout( hDC, rWinFontData, rWinFontEntry ), 263 mnGlyphCount( 0 ), 264 mnCharCount( 0 ), 265 mpOutGlyphs( NULL ), 266 mpGlyphAdvances( NULL ), 267 mpGlyphOrigAdvs( NULL ), 268 mpCharWidths( NULL ), 269 mpChars2Glyphs( NULL ), 270 mpGlyphs2Chars( NULL ), 271 mpGlyphRTLFlags( NULL ), 272 mnWidth( 0 ), 273 mnNotdefWidth( -1 ), 274 mnCharSet( nCharSet ), 275 mbDisableGlyphs( false ) 276 { 277 mbDisableGlyphs = true; 278 } 279 280 // ----------------------------------------------------------------------- 281 282 SimpleWinLayout::~SimpleWinLayout() 283 { 284 delete[] mpGlyphRTLFlags; 285 delete[] mpGlyphs2Chars; 286 delete[] mpChars2Glyphs; 287 if( mpCharWidths != mpGlyphAdvances ) 288 delete[] mpCharWidths; 289 delete[] mpGlyphOrigAdvs; 290 delete[] mpGlyphAdvances; 291 delete[] mpOutGlyphs; 292 } 293 294 // ----------------------------------------------------------------------- 295 296 bool SimpleWinLayout::LayoutText( ImplLayoutArgs& rArgs ) 297 { 298 // prepare layout 299 // TODO: fix case when recyclying old SimpleWinLayout object 300 mbDisableGlyphs |= ((rArgs.mnFlags & SAL_LAYOUT_DISABLE_GLYPH_PROCESSING) != 0); 301 mnCharCount = rArgs.mnEndCharPos - rArgs.mnMinCharPos; 302 303 if( !mbDisableGlyphs ) 304 { 305 // Win32 glyph APIs have serious problems with vertical layout 306 // => workaround is to use the unicode methods then 307 if( rArgs.mnFlags & SAL_LAYOUT_VERTICAL ) 308 mbDisableGlyphs = true; 309 else 310 // use cached value from font face 311 mbDisableGlyphs = mrWinFontData.IsGlyphApiDisabled(); 312 } 313 314 // TODO: use a cached value for bDisableAsianKern from upper layers 315 if( rArgs.mnFlags & SAL_LAYOUT_KERNING_ASIAN ) 316 { 317 TEXTMETRICA aTextMetricA; 318 if( ::GetTextMetricsA( mhDC, &aTextMetricA ) 319 && !(aTextMetricA.tmPitchAndFamily & TMPF_FIXED_PITCH) && !(aTextMetricA.tmCharSet == 0x86) ) 320 rArgs.mnFlags &= ~SAL_LAYOUT_KERNING_ASIAN; 321 } 322 323 // layout text 324 int i, j; 325 326 mnGlyphCount = 0; 327 bool bVertical = (rArgs.mnFlags & SAL_LAYOUT_VERTICAL) != 0; 328 329 // count the number of chars to process if no RTL run 330 rArgs.ResetPos(); 331 bool bHasRTL = false; 332 while( rArgs.GetNextRun( &i, &j, &bHasRTL ) && !bHasRTL ) 333 mnGlyphCount += j - i; 334 335 // if there are RTL runs we need room to remember individual BiDi flags 336 if( bHasRTL ) 337 { 338 mpGlyphRTLFlags = new bool[ mnCharCount ]; 339 for( i = 0; i < mnCharCount; ++i ) 340 mpGlyphRTLFlags[i] = false; 341 } 342 343 // rewrite the logical string if needed to prepare for the API calls 344 const sal_Unicode* pBidiStr = rArgs.mpStr + rArgs.mnMinCharPos; 345 if( (mnGlyphCount != mnCharCount) || bVertical ) 346 { 347 // we need to rewrite the pBidiStr when any of 348 // - BiDirectional layout 349 // - vertical layout 350 // - partial runs (e.g. with control chars or for glyph fallback) 351 // are involved 352 sal_Unicode* pRewrittenStr = (sal_Unicode*)alloca( mnCharCount * sizeof(sal_Unicode) ); 353 pBidiStr = pRewrittenStr; 354 355 // note: glyph to char mapping is relative to first character 356 mpChars2Glyphs = new int[ mnCharCount ]; 357 mpGlyphs2Chars = new int[ mnCharCount ]; 358 for( i = 0; i < mnCharCount; ++i ) 359 mpChars2Glyphs[i] = mpGlyphs2Chars[i] = -1; 360 361 mnGlyphCount = 0; 362 rArgs.ResetPos(); 363 bool bIsRTL = false; 364 while( rArgs.GetNextRun( &i, &j, &bIsRTL ) ) 365 { 366 do 367 { 368 // get the next leftmost character in this run 369 int nCharPos = bIsRTL ? --j : i++; 370 sal_UCS4 cChar = rArgs.mpStr[ nCharPos ]; 371 372 // in the RTL case mirror the character and remember its RTL status 373 if( bIsRTL ) 374 { 375 cChar = ::GetMirroredChar( cChar ); 376 mpGlyphRTLFlags[ mnGlyphCount ] = true; 377 } 378 379 // for vertical writing use vertical alternatives 380 if( bVertical ) 381 { 382 sal_UCS4 cVert = ::GetVerticalChar( cChar ); 383 if( cVert ) 384 cChar = cVert; 385 } 386 387 // rewrite the original string 388 // update the mappings between original and rewritten string 389 // TODO: support surrogates in rewritten strings 390 pRewrittenStr[ mnGlyphCount ] = static_cast<sal_Unicode>(cChar); 391 mpGlyphs2Chars[ mnGlyphCount ] = nCharPos; 392 mpChars2Glyphs[ nCharPos - rArgs.mnMinCharPos ] = mnGlyphCount; 393 ++mnGlyphCount; 394 } while( i < j ); 395 } 396 } 397 398 mpOutGlyphs = new WCHAR[ mnGlyphCount ]; 399 mpGlyphAdvances = new int[ mnGlyphCount ]; 400 401 if( rArgs.mnFlags & (SAL_LAYOUT_KERNING_PAIRS | SAL_LAYOUT_KERNING_ASIAN) ) 402 mpGlyphOrigAdvs = new int[ mnGlyphCount ]; 403 404 #ifndef GCP_KERN_HACK 405 DWORD nGcpOption = 0; 406 // enable kerning if requested 407 if( rArgs.mnFlags & SAL_LAYOUT_KERNING_PAIRS ) 408 nGcpOption |= GCP_USEKERNING; 409 #endif // GCP_KERN_HACK 410 411 for( i = 0; i < mnGlyphCount; ++i ) 412 mpOutGlyphs[i] = pBidiStr[ i ]; 413 mnWidth = 0; 414 for( i = 0; i < mnGlyphCount; ++i ) 415 { 416 // get the current UCS-4 code point, check for surrogate pairs 417 const WCHAR* pCodes = reinterpret_cast<LPCWSTR>(&pBidiStr[i]); 418 unsigned nCharCode = pCodes[0]; 419 bool bSurrogate = ((nCharCode >= 0xD800) && (nCharCode <= 0xDFFF)); 420 if( bSurrogate ) 421 { 422 if( nCharCode >= 0xDC00 ) // this part of a surrogate pair was already processed 423 continue; 424 nCharCode = 0x10000 + ((pCodes[0] - 0xD800) << 10) + (pCodes[1] - 0xDC00); 425 } 426 427 // get the advance width for the current UCS-4 code point 428 int nGlyphWidth = mrWinFontEntry.GetCachedGlyphWidth( nCharCode ); 429 if( nGlyphWidth == -1 ) 430 { 431 ABC aABC; 432 SIZE aExtent; 433 if( ::GetTextExtentPoint32W( mhDC, &pCodes[0], bSurrogate ? 2 : 1, &aExtent) ) 434 nGlyphWidth = aExtent.cx; 435 else if( ::GetCharABCWidthsW( mhDC, nCharCode, nCharCode, &aABC ) ) 436 nGlyphWidth = aABC.abcA + aABC.abcB + aABC.abcC; 437 else if( !::GetCharWidth32W( mhDC, nCharCode, nCharCode, &nGlyphWidth ) 438 && !::GetCharWidthW( mhDC, nCharCode, nCharCode, &nGlyphWidth ) ) 439 nGlyphWidth = 0; 440 mrWinFontEntry.CacheGlyphWidth( nCharCode, nGlyphWidth ); 441 } 442 mpGlyphAdvances[ i ] = nGlyphWidth; 443 mnWidth += nGlyphWidth; 444 445 // remaining codes of surrogate pair get a zero width 446 if( bSurrogate && ((i+1) < mnGlyphCount) ) 447 mpGlyphAdvances[ i+1 ] = 0; 448 449 // check with the font face if glyph fallback is needed 450 if( mrWinFontData.HasChar( nCharCode ) ) 451 continue; 452 453 // request glyph fallback at this position in the string 454 bool bRTL = mpGlyphRTLFlags ? mpGlyphRTLFlags[i] : false; 455 int nCharPos = mpGlyphs2Chars ? mpGlyphs2Chars[i]: i + rArgs.mnMinCharPos; 456 rArgs.NeedFallback( nCharPos, bRTL ); 457 if( bSurrogate && ((nCharPos+1) < rArgs.mnLength) ) 458 rArgs.NeedFallback( nCharPos+1, bRTL ); 459 460 // replace the current glyph shape with the NotDef glyph shape 461 if( rArgs.mnFlags & SAL_LAYOUT_FOR_FALLBACK ) 462 { 463 // when we already are layouting for glyph fallback 464 // then a new unresolved glyph is not interesting 465 mnNotdefWidth = 0; 466 mpOutGlyphs[i] = DROPPED_OUTGLYPH; 467 } 468 else 469 { 470 if( mnNotdefWidth < 0 ) 471 { 472 // get the width of the NotDef glyph 473 SIZE aExtent; 474 WCHAR cNotDef = rArgs.mpStr[ nCharPos ]; 475 mnNotdefWidth = 0; 476 if( ::GetTextExtentPoint32W( mhDC, &cNotDef, 1, &aExtent) ) 477 mnNotdefWidth = aExtent.cx; 478 } 479 // use a better NotDef glyph 480 if( !mbDisableGlyphs && !bSurrogate ) 481 mpOutGlyphs[i] = 0; 482 } 483 if( bSurrogate && ((i+1) < mnGlyphCount) ) 484 mpOutGlyphs[i+1] = DROPPED_OUTGLYPH; 485 486 // adjust the current glyph width to the NotDef glyph width 487 mnWidth += mnNotdefWidth - mpGlyphAdvances[i]; 488 mpGlyphAdvances[i] = mnNotdefWidth; 489 if( mpGlyphOrigAdvs ) 490 mpGlyphOrigAdvs[i] = mnNotdefWidth; 491 } 492 493 #ifdef GCP_KERN_HACK 494 // apply kerning if the layout engine has not yet done it 495 if( rArgs.mnFlags & (SAL_LAYOUT_KERNING_ASIAN|SAL_LAYOUT_KERNING_PAIRS) ) 496 { 497 #else // GCP_KERN_HACK 498 // apply just asian kerning 499 if( rArgs.mnFlags & SAL_LAYOUT_KERNING_ASIAN ) 500 { 501 if( !(rArgs.mnFlags & SAL_LAYOUT_KERNING_PAIRS) ) 502 #endif // GCP_KERN_HACK 503 for( i = 0; i < mnGlyphCount; ++i ) 504 mpGlyphOrigAdvs[i] = mpGlyphAdvances[i]; 505 506 // #99658# also apply asian kerning on the substring border 507 int nLen = mnGlyphCount; 508 if( rArgs.mnMinCharPos + nLen < rArgs.mnLength ) 509 ++nLen; 510 for( i = 1; i < nLen; ++i ) 511 { 512 #ifdef GCP_KERN_HACK 513 if( rArgs.mnFlags & SAL_LAYOUT_KERNING_PAIRS ) 514 { 515 int nKernAmount = mrWinFontEntry.GetKerning( pBidiStr[i-1], pBidiStr[i] ); 516 mpGlyphAdvances[ i-1 ] += nKernAmount; 517 mnWidth += nKernAmount; 518 } 519 else if( rArgs.mnFlags & SAL_LAYOUT_KERNING_ASIAN ) 520 #endif // GCP_KERN_HACK 521 522 if( ( (0x3000 == (0xFF00 & pBidiStr[i-1])) || (0x2010 == (0xFFF0 & pBidiStr[i-1])) || (0xFF00 == (0xFF00 & pBidiStr[i-1]))) 523 && ( (0x3000 == (0xFF00 & pBidiStr[i])) || (0x2010 == (0xFFF0 & pBidiStr[i])) || (0xFF00 == (0xFF00 & pBidiStr[i])) ) ) 524 { 525 long nKernFirst = +CalcAsianKerning( pBidiStr[i-1], true, bVertical ); 526 long nKernNext = -CalcAsianKerning( pBidiStr[i], false, bVertical ); 527 528 long nDelta = (nKernFirst < nKernNext) ? nKernFirst : nKernNext; 529 if( nDelta<0 && nKernFirst!=0 && nKernNext!=0 ) 530 { 531 nDelta = (nDelta * mpGlyphAdvances[i-1] + 2) / 4; 532 mpGlyphAdvances[i-1] += nDelta; 533 mnWidth += nDelta; 534 } 535 } 536 } 537 } 538 539 // calculate virtual char widths 540 if( !mpGlyphs2Chars ) 541 mpCharWidths = mpGlyphAdvances; 542 else 543 { 544 mpCharWidths = new int[ mnCharCount ]; 545 for( i = 0; i < mnCharCount; ++i ) 546 mpCharWidths[ i ] = 0; 547 for( i = 0; i < mnGlyphCount; ++i ) 548 { 549 int j = mpGlyphs2Chars[ i ] - rArgs.mnMinCharPos; 550 if( j >= 0 ) 551 mpCharWidths[ j ] += mpGlyphAdvances[ i ]; 552 } 553 } 554 555 // scale layout metrics if needed 556 // TODO: does it make the code more simple if the metric scaling 557 // is moved to the methods that need metric scaling (e.g. FillDXArray())? 558 if( mfFontScale != 1.0 ) 559 { 560 mnWidth = (long)(mnWidth * mfFontScale); 561 mnBaseAdv = (int)(mnBaseAdv * mfFontScale); 562 for( i = 0; i < mnCharCount; ++i ) 563 mpCharWidths[i] = (int)(mpCharWidths[i] * mfFontScale); 564 if( mpGlyphAdvances != mpCharWidths ) 565 for( i = 0; i < mnGlyphCount; ++i ) 566 mpGlyphAdvances[i] = (int)(mpGlyphAdvances[i] * mfFontScale); 567 if( mpGlyphOrigAdvs && (mpGlyphOrigAdvs != mpGlyphAdvances) ) 568 for( i = 0; i < mnGlyphCount; ++i ) 569 mpGlyphOrigAdvs[i] = (int)(mpGlyphOrigAdvs[i] * mfFontScale); 570 } 571 572 return true; 573 } 574 575 // ----------------------------------------------------------------------- 576 577 int SimpleWinLayout::GetNextGlyphs( int nLen, sal_GlyphId* pGlyphs, Point& rPos, int& nStart, 578 long* pGlyphAdvances, int* pCharIndexes ) const 579 { 580 // return zero if no more glyph found 581 if( nStart >= mnGlyphCount ) 582 return 0; 583 584 // calculate glyph position relative to layout base 585 // TODO: avoid for nStart!=0 case by reusing rPos 586 long nXOffset = mnBaseAdv; 587 for( int i = 0; i < nStart; ++i ) 588 nXOffset += mpGlyphAdvances[ i ]; 589 590 // calculate absolute position in pixel units 591 Point aRelativePos( nXOffset, 0 ); 592 rPos = GetDrawPosition( aRelativePos ); 593 594 int nCount = 0; 595 while( nCount < nLen ) 596 { 597 // update return values {nGlyphIndex,nCharPos,nGlyphAdvance} 598 sal_GlyphId nGlyphIndex = mpOutGlyphs[ nStart ]; 599 if( mbDisableGlyphs ) 600 { 601 if( mnLayoutFlags & SAL_LAYOUT_VERTICAL ) 602 { 603 const sal_UCS4 cChar = static_cast<sal_UCS4>(nGlyphIndex & GF_IDXMASK); 604 if( mrWinFontData.HasGSUBstitutions( mhDC ) 605 && mrWinFontData.IsGSUBstituted( cChar ) ) 606 nGlyphIndex |= GF_GSUB | GF_ROTL; 607 else 608 { 609 nGlyphIndex |= GetVerticalFlags( cChar ); 610 if( (nGlyphIndex & GF_ROTMASK) == 0 ) 611 nGlyphIndex |= GF_VERT; 612 } 613 } 614 nGlyphIndex |= GF_ISCHAR; 615 } 616 ++nCount; 617 *(pGlyphs++) = nGlyphIndex; 618 if( pGlyphAdvances ) 619 *(pGlyphAdvances++) = mpGlyphAdvances[ nStart ]; 620 if( pCharIndexes ) 621 { 622 int nCharPos; 623 if( !mpGlyphs2Chars ) 624 nCharPos = nStart + mnMinCharPos; 625 else 626 nCharPos = mpGlyphs2Chars[nStart]; 627 *(pCharIndexes++) = nCharPos; 628 } 629 630 // stop at last glyph 631 if( ++nStart >= mnGlyphCount ) 632 break; 633 634 // stop when next x-position is unexpected 635 if( !pGlyphAdvances && mpGlyphOrigAdvs ) 636 if( mpGlyphAdvances[nStart-1] != mpGlyphOrigAdvs[nStart-1] ) 637 break; 638 } 639 640 return nCount; 641 } 642 643 // ----------------------------------------------------------------------- 644 645 void SimpleWinLayout::DrawText( SalGraphics& rGraphics ) const 646 { 647 if( mnGlyphCount <= 0 ) 648 return; 649 650 WinSalGraphics& rWinGraphics = static_cast<WinSalGraphics&>(rGraphics); 651 HDC aHDC = rWinGraphics.mhDC; 652 653 HFONT hOrigFont = DisableFontScaling(); 654 655 UINT mnDrawOptions = ETO_GLYPH_INDEX; 656 if( mbDisableGlyphs ) 657 mnDrawOptions = 0; 658 659 Point aPos = GetDrawPosition( Point( mnBaseAdv, 0 ) ); 660 661 // #108267#, break up into glyph portions of a limited size required by Win32 API 662 const unsigned int maxGlyphCount = 8192; 663 UINT numGlyphPortions = mnGlyphCount / maxGlyphCount; 664 UINT remainingGlyphs = mnGlyphCount % maxGlyphCount; 665 666 if( numGlyphPortions ) 667 { 668 // #108267#,#109387# break up string into smaller chunks 669 // the output positions will be updated by windows (SetTextAlign) 670 POINT oldPos; 671 UINT oldTa = ::GetTextAlign( aHDC ); 672 ::SetTextAlign( aHDC, (oldTa & ~TA_NOUPDATECP) | TA_UPDATECP ); 673 ::MoveToEx( aHDC, aPos.X(), aPos.Y(), &oldPos ); 674 unsigned int i = 0; 675 for( unsigned int n = 0; n < numGlyphPortions; ++n, i+=maxGlyphCount ) 676 ::ExtTextOutW( aHDC, 0, 0, mnDrawOptions, NULL, 677 mpOutGlyphs+i, maxGlyphCount, mpGlyphAdvances+i ); 678 ::ExtTextOutW( aHDC, 0, 0, mnDrawOptions, NULL, 679 mpOutGlyphs+i, remainingGlyphs, mpGlyphAdvances+i ); 680 ::MoveToEx( aHDC, oldPos.x, oldPos.y, (LPPOINT) NULL); 681 ::SetTextAlign( aHDC, oldTa ); 682 } 683 else 684 ::ExtTextOutW( aHDC, aPos.X(), aPos.Y(), mnDrawOptions, NULL, 685 mpOutGlyphs, mnGlyphCount, mpGlyphAdvances ); 686 687 if( hOrigFont ) 688 DeleteFont( SelectFont( aHDC, hOrigFont ) ); 689 } 690 691 // ----------------------------------------------------------------------- 692 693 long SimpleWinLayout::FillDXArray( long* pDXArray ) const 694 { 695 if( !mnWidth ) 696 { 697 long mnWidth = mnBaseAdv; 698 for( int i = 0; i < mnGlyphCount; ++i ) 699 mnWidth += mpGlyphAdvances[ i ]; 700 } 701 702 if( pDXArray != NULL ) 703 { 704 for( int i = 0; i < mnCharCount; ++i ) 705 pDXArray[ i ] = mpCharWidths[ i ]; 706 } 707 708 return mnWidth; 709 } 710 711 // ----------------------------------------------------------------------- 712 713 int SimpleWinLayout::GetTextBreak( long nMaxWidth, long nCharExtra, int nFactor ) const 714 // NOTE: the nFactor is used to prevent rounding errors for small nCharExtra values 715 { 716 if( mnWidth ) 717 if( (mnWidth * nFactor + mnCharCount * nCharExtra) <= nMaxWidth ) 718 return STRING_LEN; 719 720 long nExtraWidth = mnBaseAdv * nFactor; 721 for( int n = 0; n < mnCharCount; ++n ) 722 { 723 // skip unused characters 724 if( mpChars2Glyphs && (mpChars2Glyphs[n] < 0) ) 725 continue; 726 // add char widths until max 727 nExtraWidth += mpCharWidths[ n ] * nFactor; 728 if( nExtraWidth >= nMaxWidth ) 729 return (mnMinCharPos + n); 730 nExtraWidth += nCharExtra; 731 } 732 733 return STRING_LEN; 734 } 735 736 // ----------------------------------------------------------------------- 737 738 void SimpleWinLayout::GetCaretPositions( int nMaxIdx, long* pCaretXArray ) const 739 { 740 long nXPos = mnBaseAdv; 741 742 if( !mpGlyphs2Chars ) 743 { 744 for( int i = 0; i < nMaxIdx; i += 2 ) 745 { 746 pCaretXArray[ i ] = nXPos; 747 nXPos += mpGlyphAdvances[ i>>1 ]; 748 pCaretXArray[ i+1 ] = nXPos; 749 } 750 } 751 else 752 { 753 int i; 754 for( i = 0; i < nMaxIdx; ++i ) 755 pCaretXArray[ i ] = -1; 756 757 // assign glyph positions to character positions 758 for( i = 0; i < mnGlyphCount; ++i ) 759 { 760 int nCurrIdx = mpGlyphs2Chars[ i ] - mnMinCharPos; 761 long nXRight = nXPos + mpCharWidths[ nCurrIdx ]; 762 nCurrIdx *= 2; 763 if( !(mpGlyphRTLFlags && mpGlyphRTLFlags[i]) ) 764 { 765 // normal positions for LTR case 766 pCaretXArray[ nCurrIdx ] = nXPos; 767 pCaretXArray[ nCurrIdx+1 ] = nXRight; 768 } 769 else 770 { 771 // reverse positions for RTL case 772 pCaretXArray[ nCurrIdx ] = nXRight; 773 pCaretXArray[ nCurrIdx+1 ] = nXPos; 774 } 775 nXPos += mpGlyphAdvances[ i ]; 776 } 777 } 778 } 779 780 // ----------------------------------------------------------------------- 781 782 void SimpleWinLayout::Justify( long nNewWidth ) 783 { 784 long nOldWidth = mnWidth; 785 mnWidth = nNewWidth; 786 787 if( mnGlyphCount <= 0 ) 788 return; 789 790 if( nNewWidth == nOldWidth ) 791 return; 792 793 // the rightmost glyph cannot be stretched 794 const int nRight = mnGlyphCount - 1; 795 nOldWidth -= mpGlyphAdvances[ nRight ]; 796 nNewWidth -= mpGlyphAdvances[ nRight ]; 797 798 // count stretchable glyphs 799 int nStretchable = 0, i; 800 for( i = 0; i < nRight; ++i ) 801 if( mpGlyphAdvances[i] >= 0 ) 802 ++nStretchable; 803 804 // stretch these glyphs 805 int nDiffWidth = nNewWidth - nOldWidth; 806 for( i = 0; (i < nRight) && (nStretchable > 0); ++i ) 807 { 808 if( mpGlyphAdvances[i] <= 0 ) 809 continue; 810 int nDeltaWidth = nDiffWidth / nStretchable; 811 mpGlyphAdvances[i] += nDeltaWidth; 812 --nStretchable; 813 nDiffWidth -= nDeltaWidth; 814 } 815 } 816 817 // ----------------------------------------------------------------------- 818 819 void SimpleWinLayout::AdjustLayout( ImplLayoutArgs& rArgs ) 820 { 821 SalLayout::AdjustLayout( rArgs ); 822 823 // adjust positions if requested 824 if( rArgs.mpDXArray ) 825 ApplyDXArray( rArgs ); 826 else if( rArgs.mnLayoutWidth ) 827 Justify( rArgs.mnLayoutWidth ); 828 else 829 return; 830 831 // recalculate virtual char widths if they were changed 832 if( mpCharWidths != mpGlyphAdvances ) 833 { 834 int i; 835 if( !mpGlyphs2Chars ) 836 { 837 // standard LTR case 838 for( i = 0; i < mnGlyphCount; ++i ) 839 mpCharWidths[ i ] = mpGlyphAdvances[ i ]; 840 } 841 else 842 { 843 // BiDi or complex case 844 for( i = 0; i < mnCharCount; ++i ) 845 mpCharWidths[ i ] = 0; 846 for( i = 0; i < mnGlyphCount; ++i ) 847 { 848 int j = mpGlyphs2Chars[ i ] - rArgs.mnMinCharPos; 849 if( j >= 0 ) 850 mpCharWidths[ j ] += mpGlyphAdvances[ i ]; 851 } 852 } 853 } 854 } 855 856 // ----------------------------------------------------------------------- 857 858 void SimpleWinLayout::ApplyDXArray( const ImplLayoutArgs& rArgs ) 859 { 860 // try to avoid disturbance of text flow for LSB rounding case; 861 const long* pDXArray = rArgs.mpDXArray; 862 863 int i = 0; 864 long nOldWidth = mnBaseAdv; 865 for(; i < mnCharCount; ++i ) 866 { 867 int j = !mpChars2Glyphs ? i : mpChars2Glyphs[i]; 868 if( j >= 0 ) 869 { 870 nOldWidth += mpGlyphAdvances[ j ]; 871 int nDiff = nOldWidth - pDXArray[ i ]; 872 873 // disabled because of #104768# 874 // works great for static text, but problems when typing 875 // if( nDiff>+1 || nDiff<-1 ) 876 // only bother with changing anything when something moved 877 if( nDiff != 0 ) 878 break; 879 } 880 } 881 if( i >= mnCharCount ) 882 return; 883 884 if( !mpGlyphOrigAdvs ) 885 { 886 mpGlyphOrigAdvs = new int[ mnGlyphCount ]; 887 for( i = 0; i < mnGlyphCount; ++i ) 888 mpGlyphOrigAdvs[ i ] = mpGlyphAdvances[ i ]; 889 } 890 891 mnWidth = mnBaseAdv; 892 for( i = 0; i < mnCharCount; ++i ) 893 { 894 int j = !mpChars2Glyphs ? i : mpChars2Glyphs[i]; 895 if( j >= 0 ) 896 mpGlyphAdvances[j] = pDXArray[i] - mnWidth; 897 mnWidth = pDXArray[i]; 898 } 899 } 900 901 // ----------------------------------------------------------------------- 902 903 void SimpleWinLayout::MoveGlyph( int nStart, long nNewXPos ) 904 { 905 if( nStart > mnGlyphCount ) 906 return; 907 908 // calculate the current x-position of the requested glyph 909 // TODO: cache absolute positions 910 int nXPos = mnBaseAdv; 911 for( int i = 0; i < nStart; ++i ) 912 nXPos += mpGlyphAdvances[i]; 913 914 // calculate the difference to the current glyph position 915 int nDelta = nNewXPos - nXPos; 916 917 // adjust the width of the layout if it was already cached 918 if( mnWidth ) 919 mnWidth += nDelta; 920 921 // depending on whether the requested glyph is leftmost in the layout 922 // adjust either the layout's or the requested glyph's relative position 923 if( nStart > 0 ) 924 mpGlyphAdvances[ nStart-1 ] += nDelta; 925 else 926 mnBaseAdv += nDelta; 927 } 928 929 // ----------------------------------------------------------------------- 930 931 void SimpleWinLayout::DropGlyph( int nStart ) 932 { 933 mpOutGlyphs[ nStart ] = DROPPED_OUTGLYPH; 934 } 935 936 // ----------------------------------------------------------------------- 937 938 void SimpleWinLayout::Simplify( bool /*bIsBase*/ ) 939 { 940 // return early if no glyph has been dropped 941 int i = mnGlyphCount; 942 while( (--i >= 0) && (mpOutGlyphs[ i ] != DROPPED_OUTGLYPH) ); 943 if( i < 0 ) 944 return; 945 946 // convert the layout to a sparse layout if it is not already 947 if( !mpGlyphs2Chars ) 948 { 949 mpGlyphs2Chars = new int[ mnGlyphCount ]; 950 mpCharWidths = new int[ mnCharCount ]; 951 // assertion: mnGlyphCount == mnCharCount 952 for( int k = 0; k < mnGlyphCount; ++k ) 953 { 954 mpGlyphs2Chars[ k ] = mnMinCharPos + k; 955 mpCharWidths[ k ] = mpGlyphAdvances[ k ]; 956 } 957 } 958 959 // remove dropped glyphs that are rightmost in the layout 960 for( i = mnGlyphCount; --i >= 0; ) 961 { 962 if( mpOutGlyphs[ i ] != DROPPED_OUTGLYPH ) 963 break; 964 if( mnWidth ) 965 mnWidth -= mpGlyphAdvances[ i ]; 966 int nRelCharPos = mpGlyphs2Chars[ i ] - mnMinCharPos; 967 if( nRelCharPos >= 0 ) 968 mpCharWidths[ nRelCharPos ] = 0; 969 } 970 mnGlyphCount = i + 1; 971 972 // keep original glyph widths around 973 if( !mpGlyphOrigAdvs ) 974 { 975 mpGlyphOrigAdvs = new int[ mnGlyphCount ]; 976 for( int k = 0; k < mnGlyphCount; ++k ) 977 mpGlyphOrigAdvs[ k ] = mpGlyphAdvances[ k ]; 978 } 979 980 // remove dropped glyphs inside the layout 981 int nNewGC = 0; 982 for( i = 0; i < mnGlyphCount; ++i ) 983 { 984 if( mpOutGlyphs[ i ] == DROPPED_OUTGLYPH ) 985 { 986 // adjust relative position to last valid glyph 987 int nDroppedWidth = mpGlyphAdvances[ i ]; 988 mpGlyphAdvances[ i ] = 0; 989 if( nNewGC > 0 ) 990 mpGlyphAdvances[ nNewGC-1 ] += nDroppedWidth; 991 else 992 mnBaseAdv += nDroppedWidth; 993 994 // zero the virtual char width for the char that has a fallback 995 int nRelCharPos = mpGlyphs2Chars[ i ] - mnMinCharPos; 996 if( nRelCharPos >= 0 ) 997 mpCharWidths[ nRelCharPos ] = 0; 998 } 999 else 1000 { 1001 if( nNewGC != i ) 1002 { 1003 // rearrange the glyph array to get rid of the dropped glyph 1004 mpOutGlyphs[ nNewGC ] = mpOutGlyphs[ i ]; 1005 mpGlyphAdvances[ nNewGC ] = mpGlyphAdvances[ i ]; 1006 mpGlyphOrigAdvs[ nNewGC ] = mpGlyphOrigAdvs[ i ]; 1007 mpGlyphs2Chars[ nNewGC ] = mpGlyphs2Chars[ i ]; 1008 } 1009 ++nNewGC; 1010 } 1011 } 1012 1013 mnGlyphCount = nNewGC; 1014 if( mnGlyphCount <= 0 ) 1015 mnWidth = mnBaseAdv = 0; 1016 } 1017 1018 // ======================================================================= 1019 1020 #ifdef USE_UNISCRIBE 1021 1022 struct VisualItem 1023 { 1024 public: 1025 SCRIPT_ITEM* mpScriptItem; 1026 int mnMinGlyphPos; 1027 int mnEndGlyphPos; 1028 int mnMinCharPos; 1029 int mnEndCharPos; 1030 //long mnPixelWidth; 1031 int mnXOffset; 1032 ABC maABCWidths; 1033 bool mbHasKashidas; 1034 1035 public: 1036 bool IsEmpty() const { return (mnEndGlyphPos <= 0); } 1037 bool IsRTL() const { return mpScriptItem->a.fRTL; } 1038 bool HasKashidas() const { return mbHasKashidas; } 1039 }; 1040 1041 // ----------------------------------------------------------------------- 1042 1043 class UniscribeLayout : public WinLayout 1044 { 1045 public: 1046 UniscribeLayout( HDC, const ImplWinFontData&, ImplWinFontEntry& ); 1047 1048 virtual bool LayoutText( ImplLayoutArgs& ); 1049 virtual void AdjustLayout( ImplLayoutArgs& ); 1050 virtual void DrawText( SalGraphics& ) const; 1051 virtual int GetNextGlyphs( int nLen, sal_GlyphId* pGlyphs, Point& rPos, int&, 1052 sal_Int32* pGlyphAdvances, int* pCharPosAry ) const; 1053 1054 virtual long FillDXArray( long* pDXArray ) const; 1055 virtual int GetTextBreak( long nMaxWidth, long nCharExtra, int nFactor ) const; 1056 virtual void GetCaretPositions( int nArraySize, long* pCaretXArray ) const; 1057 virtual bool IsKashidaPosValid ( int nCharPos ) const; 1058 1059 // for glyph+font+script fallback 1060 virtual void MoveGlyph( int nStart, long nNewXPos ); 1061 virtual void DropGlyph( int nStart ); 1062 virtual void Simplify( bool bIsBase ); 1063 virtual void DisableGlyphInjection( bool bDisable ) { mbDisableGlyphInjection = bDisable; } 1064 1065 protected: 1066 virtual ~UniscribeLayout(); 1067 1068 void Justify( long nNewWidth ); 1069 void ApplyDXArray( const ImplLayoutArgs& ); 1070 1071 bool GetItemSubrange( const VisualItem&, 1072 int& rMinIndex, int& rEndIndex ) const; 1073 1074 private: 1075 // item specific info 1076 SCRIPT_ITEM* mpScriptItems; // in logical order 1077 VisualItem* mpVisualItems; // in visual order 1078 int mnItemCount; // number of visual items 1079 1080 // string specific info 1081 // everything is in logical order 1082 int mnCharCapacity; 1083 WORD* mpLogClusters; // map from absolute_char_pos to relative_glyph_pos 1084 int* mpCharWidths; // map from absolute_char_pos to char_width 1085 int mnSubStringMin; // char_pos of first char in context 1086 1087 // glyph specific info 1088 // everything is in visual order 1089 int mnGlyphCount; 1090 int mnGlyphCapacity; 1091 int* mpGlyphAdvances; // glyph advance width before justification 1092 int* mpJustifications; // glyph advance width after justification 1093 WORD* mpOutGlyphs; // glyphids in visual order 1094 GOFFSET* mpGlyphOffsets; // glyph offsets to the "naive" layout 1095 SCRIPT_VISATTR* mpVisualAttrs; // glyph visual attributes 1096 mutable int* mpGlyphs2Chars; // map from absolute_glyph_pos to absolute_char_pos 1097 1098 // kashida stuff 1099 void InitKashidaHandling(); 1100 void KashidaItemFix( int nMinGlyphPos, int nEndGlyphPos ); 1101 bool KashidaWordFix( int nMinGlyphPos, int nEndGlyphPos, int* pnCurrentPos ); 1102 1103 int mnMinKashidaWidth; 1104 int mnMinKashidaGlyph; 1105 bool mbDisableGlyphInjection; 1106 }; 1107 1108 // ----------------------------------------------------------------------- 1109 // dynamic loading of usp library 1110 1111 static oslModule aUspModule = NULL; 1112 static bool bUspEnabled = true; 1113 1114 static HRESULT ((WINAPI *pScriptIsComplex)( const WCHAR*, int, DWORD )); 1115 static HRESULT ((WINAPI *pScriptItemize)( const WCHAR*, int, int, 1116 const SCRIPT_CONTROL*, const SCRIPT_STATE*, SCRIPT_ITEM*, int* )); 1117 static HRESULT ((WINAPI *pScriptShape)( HDC, SCRIPT_CACHE*, const WCHAR*, 1118 int, int, SCRIPT_ANALYSIS*, WORD*, WORD*, SCRIPT_VISATTR*, int* )); 1119 static HRESULT ((WINAPI *pScriptPlace)( HDC, SCRIPT_CACHE*, const WORD*, int, 1120 const SCRIPT_VISATTR*, SCRIPT_ANALYSIS*, int*, GOFFSET*, ABC* )); 1121 static HRESULT ((WINAPI *pScriptGetLogicalWidths)( const SCRIPT_ANALYSIS*, 1122 int, int, const int*, const WORD*, const SCRIPT_VISATTR*, int* )); 1123 static HRESULT ((WINAPI *pScriptApplyLogicalWidth)( const int*, int, int, const WORD*, 1124 const SCRIPT_VISATTR*, const int*, const SCRIPT_ANALYSIS*, ABC*, int* )); 1125 static HRESULT ((WINAPI *pScriptJustify)( const SCRIPT_VISATTR*, 1126 const int*, int, int, int, int* )); 1127 static HRESULT ((WINAPI *pScriptTextOut)( const HDC, SCRIPT_CACHE*, 1128 int, int, UINT, const RECT*, const SCRIPT_ANALYSIS*, const WCHAR*, 1129 int, const WORD*, int, const int*, const int*, const GOFFSET* )); 1130 static HRESULT ((WINAPI *pScriptGetFontProperties)( HDC, SCRIPT_CACHE*, SCRIPT_FONTPROPERTIES* )); 1131 static HRESULT ((WINAPI *pScriptFreeCache)( SCRIPT_CACHE* )); 1132 1133 static bool bManualCellAlign = true; 1134 1135 // ----------------------------------------------------------------------- 1136 1137 static bool InitUSP() 1138 { 1139 OUString aLibraryName( RTL_CONSTASCII_USTRINGPARAM( "usp10" ) ); 1140 aUspModule = osl_loadModule( aLibraryName.pData, SAL_LOADMODULE_DEFAULT ); 1141 if( !aUspModule ) 1142 return (bUspEnabled = false); 1143 1144 pScriptIsComplex = (HRESULT (WINAPI*)(const WCHAR*,int,DWORD)) 1145 osl_getAsciiFunctionSymbol( aUspModule, "ScriptIsComplex" ); 1146 bUspEnabled &= (NULL != pScriptIsComplex); 1147 1148 pScriptItemize = (HRESULT (WINAPI*)(const WCHAR*,int,int, 1149 const SCRIPT_CONTROL*,const SCRIPT_STATE*,SCRIPT_ITEM*,int*)) 1150 osl_getAsciiFunctionSymbol( aUspModule, "ScriptItemize" ); 1151 bUspEnabled &= (NULL != pScriptItemize); 1152 1153 pScriptShape = (HRESULT (WINAPI*)(HDC,SCRIPT_CACHE*,const WCHAR*, 1154 int,int,SCRIPT_ANALYSIS*,WORD*,WORD*,SCRIPT_VISATTR*,int*)) 1155 osl_getAsciiFunctionSymbol( aUspModule, "ScriptShape" ); 1156 bUspEnabled &= (NULL != pScriptShape); 1157 1158 pScriptPlace = (HRESULT (WINAPI*)(HDC, SCRIPT_CACHE*, const WORD*, int, 1159 const SCRIPT_VISATTR*,SCRIPT_ANALYSIS*,int*,GOFFSET*,ABC*)) 1160 osl_getAsciiFunctionSymbol( aUspModule, "ScriptPlace" ); 1161 bUspEnabled &= (NULL != pScriptPlace); 1162 1163 pScriptGetLogicalWidths = (HRESULT (WINAPI*)(const SCRIPT_ANALYSIS*, 1164 int,int,const int*,const WORD*,const SCRIPT_VISATTR*,int*)) 1165 osl_getAsciiFunctionSymbol( aUspModule, "ScriptGetLogicalWidths" ); 1166 bUspEnabled &= (NULL != pScriptGetLogicalWidths); 1167 1168 pScriptApplyLogicalWidth = (HRESULT (WINAPI*)(const int*,int,int,const WORD*, 1169 const SCRIPT_VISATTR*,const int*,const SCRIPT_ANALYSIS*,ABC*,int*)) 1170 osl_getAsciiFunctionSymbol( aUspModule, "ScriptApplyLogicalWidth" ); 1171 bUspEnabled &= (NULL != pScriptApplyLogicalWidth); 1172 1173 pScriptJustify = (HRESULT (WINAPI*)(const SCRIPT_VISATTR*,const int*, 1174 int,int,int,int*)) 1175 osl_getAsciiFunctionSymbol( aUspModule, "ScriptJustify" ); 1176 bUspEnabled &= (NULL != pScriptJustify); 1177 1178 pScriptGetFontProperties = (HRESULT (WINAPI*)( HDC,SCRIPT_CACHE*,SCRIPT_FONTPROPERTIES*)) 1179 osl_getAsciiFunctionSymbol( aUspModule, "ScriptGetFontProperties" ); 1180 bUspEnabled &= (NULL != pScriptGetFontProperties); 1181 1182 pScriptTextOut = (HRESULT (WINAPI*)(const HDC,SCRIPT_CACHE*, 1183 int,int,UINT,const RECT*,const SCRIPT_ANALYSIS*,const WCHAR*, 1184 int,const WORD*,int,const int*,const int*,const GOFFSET*)) 1185 osl_getAsciiFunctionSymbol( aUspModule, "ScriptTextOut" ); 1186 bUspEnabled &= (NULL != pScriptTextOut); 1187 1188 pScriptFreeCache = (HRESULT (WINAPI*)(SCRIPT_CACHE*)) 1189 osl_getAsciiFunctionSymbol( aUspModule, "ScriptFreeCache" ); 1190 bUspEnabled &= (NULL != pScriptFreeCache); 1191 1192 if( !bUspEnabled ) 1193 { 1194 osl_unloadModule( aUspModule ); 1195 aUspModule = NULL; 1196 } 1197 1198 // get the DLL version info 1199 int nUspVersion = 0; 1200 // TODO: there must be a simpler way to get the friggin version info from OSL? 1201 rtl_uString* pModuleURL = NULL; 1202 osl_getModuleURLFromAddress( (void*)pScriptIsComplex, &pModuleURL ); 1203 rtl_uString* pModuleFileName = NULL; 1204 if( pModuleURL ) 1205 osl_getSystemPathFromFileURL( pModuleURL, &pModuleFileName ); 1206 const sal_Unicode* pModuleFileCStr = NULL; 1207 if( pModuleFileName ) 1208 pModuleFileCStr = rtl_uString_getStr( pModuleFileName ); 1209 if( pModuleFileCStr ) 1210 { 1211 DWORD nHandle; 1212 DWORD nBufSize = ::GetFileVersionInfoSizeW( const_cast<LPWSTR>(reinterpret_cast<LPCWSTR>(pModuleFileCStr)), &nHandle ); 1213 char* pBuffer = (char*)alloca( nBufSize ); 1214 BOOL bRC = ::GetFileVersionInfoW( const_cast<LPWSTR>(reinterpret_cast<LPCWSTR>(pModuleFileCStr)), nHandle, nBufSize, pBuffer ); 1215 VS_FIXEDFILEINFO* pFixedFileInfo = NULL; 1216 UINT nFixedFileSize = 0; 1217 if( bRC ) 1218 ::VerQueryValueW( pBuffer, const_cast<LPWSTR>(L"\\"), (void**)&pFixedFileInfo, &nFixedFileSize ); 1219 if( pFixedFileInfo && pFixedFileInfo->dwSignature == 0xFEEF04BD ) 1220 nUspVersion = HIWORD(pFixedFileInfo->dwProductVersionMS) * 10000 1221 + LOWORD(pFixedFileInfo->dwProductVersionMS); 1222 } 1223 1224 // #i77976# USP>=1.0600 changed the need to manually align glyphs in their cells 1225 if( nUspVersion >= 10600 ) 1226 bManualCellAlign = false; 1227 1228 return bUspEnabled; 1229 } 1230 1231 // ----------------------------------------------------------------------- 1232 1233 UniscribeLayout::UniscribeLayout( HDC hDC, 1234 const ImplWinFontData& rWinFontData, ImplWinFontEntry& rWinFontEntry ) 1235 : WinLayout( hDC, rWinFontData, rWinFontEntry ), 1236 mnItemCount( 0 ), 1237 mpScriptItems( NULL ), 1238 mpVisualItems( NULL ), 1239 mpLogClusters( NULL ), 1240 mpCharWidths( NULL ), 1241 mnCharCapacity( 0 ), 1242 mnSubStringMin( 0 ), 1243 mnGlyphCapacity( 0 ), 1244 mnGlyphCount( 0 ), 1245 mpOutGlyphs( NULL ), 1246 mpGlyphAdvances( NULL ), 1247 mpJustifications( NULL ), 1248 mpGlyphOffsets( NULL ), 1249 mpVisualAttrs( NULL ), 1250 mpGlyphs2Chars( NULL ), 1251 mnMinKashidaGlyph( 0 ), 1252 mbDisableGlyphInjection( false ) 1253 {} 1254 1255 // ----------------------------------------------------------------------- 1256 1257 UniscribeLayout::~UniscribeLayout() 1258 { 1259 delete[] mpScriptItems; 1260 delete[] mpVisualItems; 1261 delete[] mpLogClusters; 1262 delete[] mpCharWidths; 1263 delete[] mpOutGlyphs; 1264 delete[] mpGlyphAdvances; 1265 delete[] mpJustifications; 1266 delete[] mpGlyphOffsets; 1267 delete[] mpVisualAttrs; 1268 delete[] mpGlyphs2Chars; 1269 } 1270 1271 // ----------------------------------------------------------------------- 1272 1273 bool UniscribeLayout::LayoutText( ImplLayoutArgs& rArgs ) 1274 { 1275 // for a base layout only the context glyphs have to be dropped 1276 // => when the whole string is involved there is no extra context 1277 typedef std::vector<int> TIntVector; 1278 TIntVector aDropChars; 1279 if( rArgs.mnFlags & SAL_LAYOUT_FOR_FALLBACK ) 1280 { 1281 // calculate superfluous context char positions 1282 aDropChars.push_back( 0 ); 1283 aDropChars.push_back( rArgs.mnLength ); 1284 int nMin, nEnd; 1285 bool bRTL; 1286 for( rArgs.ResetPos(); rArgs.GetNextRun( &nMin, &nEnd, &bRTL ); ) 1287 { 1288 aDropChars.push_back( nMin ); 1289 aDropChars.push_back( nEnd ); 1290 } 1291 // prepare aDropChars for binary search which will allow to 1292 // not bother with visual items that will be dropped anyway 1293 std::sort( aDropChars.begin(), aDropChars.end() ); 1294 } 1295 1296 // prepare layout 1297 // TODO: fix case when recyclying old UniscribeLayout object 1298 mnMinCharPos = rArgs.mnMinCharPos; 1299 mnEndCharPos = rArgs.mnEndCharPos; 1300 1301 // determine script items from string 1302 1303 // prepare itemization 1304 // TODO: try to avoid itemization since it costs a lot of performance 1305 SCRIPT_STATE aScriptState = {0,false,false,false,false,false,false,false,false,0,0}; 1306 aScriptState.uBidiLevel = (0 != (rArgs.mnFlags & SAL_LAYOUT_BIDI_RTL)); 1307 aScriptState.fOverrideDirection = (0 != (rArgs.mnFlags & SAL_LAYOUT_BIDI_STRONG)); 1308 aScriptState.fDigitSubstitute = (0 != (rArgs.mnFlags & SAL_LAYOUT_SUBSTITUTE_DIGITS)); 1309 aScriptState.fArabicNumContext = aScriptState.fDigitSubstitute & aScriptState.uBidiLevel; 1310 DWORD nLangId = 0; // TODO: get language from font 1311 SCRIPT_CONTROL aScriptControl = {nLangId,false,false,false,false,false,false,false,false,0}; 1312 aScriptControl.fNeutralOverride = aScriptState.fOverrideDirection; 1313 aScriptControl.fContextDigits = (0 != (rArgs.mnFlags & SAL_LAYOUT_SUBSTITUTE_DIGITS)); 1314 // determine relevant substring and work only on it 1315 // when Bidi status is unknown we need to look at the whole string though 1316 mnSubStringMin = 0; 1317 int nSubStringEnd = rArgs.mnLength; 1318 if( aScriptState.fOverrideDirection ) 1319 { 1320 // TODO: limit substring to portion limits 1321 mnSubStringMin = rArgs.mnMinCharPos - 8; 1322 if( mnSubStringMin < 0 ) 1323 mnSubStringMin = 0; 1324 nSubStringEnd = rArgs.mnEndCharPos + 8; 1325 if( nSubStringEnd > rArgs.mnLength ) 1326 nSubStringEnd = rArgs.mnLength; 1327 1328 } 1329 1330 // now itemize the substring with its context 1331 for( int nItemCapacity = 16;; nItemCapacity *= 8 ) 1332 { 1333 mpScriptItems = new SCRIPT_ITEM[ nItemCapacity ]; 1334 HRESULT nRC = (*pScriptItemize)( 1335 reinterpret_cast<LPCWSTR>(rArgs.mpStr + mnSubStringMin), nSubStringEnd - mnSubStringMin, 1336 nItemCapacity - 1, &aScriptControl, &aScriptState, 1337 mpScriptItems, &mnItemCount ); 1338 if( !nRC ) // break loop when everything is correctly itemized 1339 break; 1340 1341 // prepare bigger buffers for another itemization round 1342 delete[] mpScriptItems; 1343 mpScriptItems = NULL; 1344 if( nRC != E_OUTOFMEMORY ) 1345 return false; 1346 if( nItemCapacity > (nSubStringEnd - mnSubStringMin) + 16 ) 1347 return false; 1348 } 1349 1350 // calculate the order of visual items 1351 int nItem, i; 1352 1353 // adjust char positions by substring offset 1354 for( nItem = 0; nItem <= mnItemCount; ++nItem ) 1355 mpScriptItems[ nItem ].iCharPos += mnSubStringMin; 1356 // default visual item ordering 1357 mpVisualItems = new VisualItem[ mnItemCount ]; 1358 for( nItem = 0; nItem < mnItemCount; ++nItem ) 1359 { 1360 // initialize char specific item info 1361 VisualItem& rVisualItem = mpVisualItems[ nItem ]; 1362 SCRIPT_ITEM* pScriptItem = &mpScriptItems[ nItem ]; 1363 rVisualItem.mpScriptItem = pScriptItem; 1364 rVisualItem.mnMinCharPos = pScriptItem[0].iCharPos; 1365 rVisualItem.mnEndCharPos = pScriptItem[1].iCharPos; 1366 } 1367 1368 // reorder visual item order if needed 1369 if( rArgs.mnFlags & SAL_LAYOUT_BIDI_STRONG ) 1370 { 1371 // force RTL item ordering if requested 1372 if( rArgs.mnFlags & SAL_LAYOUT_BIDI_RTL ) 1373 { 1374 VisualItem* pVI0 = &mpVisualItems[ 0 ]; 1375 VisualItem* pVI1 = &mpVisualItems[ mnItemCount ]; 1376 while( pVI0 < --pVI1 ) 1377 { 1378 VisualItem aVtmp = *pVI0; 1379 *(pVI0++) = *pVI1; 1380 *pVI1 = aVtmp; 1381 } 1382 } 1383 } 1384 else if( mnItemCount > 1 ) 1385 { 1386 // apply bidi algorithm's rule L2 on item level 1387 // TODO: use faster L2 algorithm 1388 int nMaxBidiLevel = 0; 1389 VisualItem* pVI = &mpVisualItems[0]; 1390 VisualItem* const pVIend = pVI + mnItemCount; 1391 for(; pVI < pVIend; ++pVI ) 1392 if( nMaxBidiLevel < pVI->mpScriptItem->a.s.uBidiLevel ) 1393 nMaxBidiLevel = pVI->mpScriptItem->a.s.uBidiLevel; 1394 1395 while( --nMaxBidiLevel >= 0 ) 1396 { 1397 for( pVI = &mpVisualItems[0]; pVI < pVIend; ) 1398 { 1399 // find item range that needs reordering 1400 for(; pVI < pVIend; ++pVI ) 1401 if( nMaxBidiLevel < pVI->mpScriptItem->a.s.uBidiLevel ) 1402 break; 1403 VisualItem* pVImin = pVI++; 1404 for(; pVI < pVIend; ++pVI ) 1405 if( nMaxBidiLevel >= pVI->mpScriptItem->a.s.uBidiLevel ) 1406 break; 1407 VisualItem* pVImax = pVI++; 1408 1409 // reverse order of items in this range 1410 while( pVImin < --pVImax ) 1411 { 1412 VisualItem aVtmp = *pVImin; 1413 *(pVImin++) = *pVImax; 1414 *pVImax = aVtmp; 1415 } 1416 } 1417 } 1418 } 1419 1420 // allocate arrays 1421 // TODO: when reusing object reuse old allocations or delete them 1422 // TODO: use only [nSubStringMin..nSubStringEnd) instead of [0..nSubStringEnd) 1423 mnCharCapacity = nSubStringEnd; 1424 mpLogClusters = new WORD[ mnCharCapacity ]; 1425 mpCharWidths = new int[ mnCharCapacity ]; 1426 1427 mnGlyphCount = 0; 1428 mnGlyphCapacity = 16 + 4 * (nSubStringEnd - mnSubStringMin); // worst case assumption 1429 mpGlyphAdvances = new int[ mnGlyphCapacity ]; 1430 mpOutGlyphs = new WORD[ mnGlyphCapacity ]; 1431 mpGlyphOffsets = new GOFFSET[ mnGlyphCapacity ]; 1432 mpVisualAttrs = new SCRIPT_VISATTR[ mnGlyphCapacity ]; 1433 1434 long nXOffset = 0; 1435 for( int j = mnSubStringMin; j < nSubStringEnd; ++j ) 1436 mpCharWidths[j] = 0; 1437 1438 // layout script items 1439 SCRIPT_CACHE& rScriptCache = GetScriptCache(); 1440 for( nItem = 0; nItem < mnItemCount; ++nItem ) 1441 { 1442 VisualItem& rVisualItem = mpVisualItems[ nItem ]; 1443 1444 // initialize glyph specific item info 1445 rVisualItem.mnMinGlyphPos = mnGlyphCount; 1446 rVisualItem.mnEndGlyphPos = 0; 1447 rVisualItem.mnXOffset = nXOffset; 1448 //rVisualItem.mnPixelWidth = 0; 1449 1450 // shortcut ignorable items 1451 if( (rArgs.mnEndCharPos <= rVisualItem.mnMinCharPos) 1452 || (rArgs.mnMinCharPos >= rVisualItem.mnEndCharPos) ) 1453 { 1454 for( int i = rVisualItem.mnMinCharPos; i < rVisualItem.mnEndCharPos; ++i ) 1455 mpLogClusters[i] = sal::static_int_cast<WORD>(~0U); 1456 continue; 1457 } 1458 1459 // override bidi analysis if requested 1460 if( rArgs.mnFlags & SAL_LAYOUT_BIDI_STRONG ) 1461 { 1462 // FIXME: is this intended ? 1463 rVisualItem.mpScriptItem->a.fRTL = (aScriptState.uBidiLevel & 1); 1464 rVisualItem.mpScriptItem->a.s.uBidiLevel = aScriptState.uBidiLevel; 1465 rVisualItem.mpScriptItem->a.s.fOverrideDirection = aScriptState.fOverrideDirection; 1466 } 1467 1468 // convert the unicodes to glyphs 1469 int nGlyphCount = 0; 1470 int nCharCount = rVisualItem.mnEndCharPos - rVisualItem.mnMinCharPos; 1471 HRESULT nRC = (*pScriptShape)( mhDC, &rScriptCache, 1472 reinterpret_cast<LPCWSTR>(rArgs.mpStr + rVisualItem.mnMinCharPos), 1473 nCharCount, 1474 mnGlyphCapacity - rVisualItem.mnMinGlyphPos, // problem when >0xFFFF 1475 &rVisualItem.mpScriptItem->a, 1476 mpOutGlyphs + rVisualItem.mnMinGlyphPos, 1477 mpLogClusters + rVisualItem.mnMinCharPos, 1478 mpVisualAttrs + rVisualItem.mnMinGlyphPos, 1479 &nGlyphCount ); 1480 1481 // find and handle problems in the unicode to glyph conversion 1482 if( nRC == USP_E_SCRIPT_NOT_IN_FONT ) 1483 { 1484 // the whole visual item needs a fallback, but make sure that the next 1485 // fallback request is limited to the characters in the original request 1486 // => this is handled in ImplLayoutArgs::PrepareFallback() 1487 rArgs.NeedFallback( rVisualItem.mnMinCharPos, rVisualItem.mnEndCharPos, 1488 rVisualItem.IsRTL() ); 1489 1490 // don't bother to do a default layout in a fallback level 1491 if( 0 != (rArgs.mnFlags & SAL_LAYOUT_FOR_FALLBACK) ) 1492 continue; 1493 1494 // the primitive layout engine is good enough for the default layout 1495 rVisualItem.mpScriptItem->a.eScript = SCRIPT_UNDEFINED; 1496 nRC = (*pScriptShape)( mhDC, &rScriptCache, 1497 reinterpret_cast<LPCWSTR>(rArgs.mpStr + rVisualItem.mnMinCharPos), 1498 nCharCount, 1499 mnGlyphCapacity - rVisualItem.mnMinGlyphPos, 1500 &rVisualItem.mpScriptItem->a, 1501 mpOutGlyphs + rVisualItem.mnMinGlyphPos, 1502 mpLogClusters + rVisualItem.mnMinCharPos, 1503 mpVisualAttrs + rVisualItem.mnMinGlyphPos, 1504 &nGlyphCount ); 1505 1506 if( nRC != 0 ) 1507 continue; 1508 1509 #if 0 // keep the glyphs for now because they are better than nothing 1510 // mark as NotDef glyphs 1511 for( i = 0; i < nGlyphCount; ++i ) 1512 mpOutGlyphs[ i + rVisualItem.mnMinGlyphPos ] = 0; 1513 #endif 1514 } 1515 else if( nRC != 0 ) 1516 // something undefined happened => give up for this visual item 1517 continue; 1518 else // if( nRC == 0 ) 1519 { 1520 // check if there are any NotDef glyphs 1521 for( i = 0; i < nGlyphCount; ++i ) 1522 if( 0 == mpOutGlyphs[ i + rVisualItem.mnMinGlyphPos ] ) 1523 break; 1524 if( i < nGlyphCount ) 1525 { 1526 // clip charpos limits to the layout string without context 1527 int nMinCharPos = rVisualItem.mnMinCharPos; 1528 if( nMinCharPos < rArgs.mnMinCharPos ) 1529 nMinCharPos = rArgs.mnMinCharPos; 1530 int nEndCharPos = rVisualItem.mnEndCharPos; 1531 if( nEndCharPos > rArgs.mnEndCharPos ) 1532 nEndCharPos = rArgs.mnEndCharPos; 1533 // request fallback for individual NotDef glyphs 1534 do 1535 { 1536 // ignore non-NotDef glyphs 1537 if( 0 != mpOutGlyphs[ i + rVisualItem.mnMinGlyphPos ] ) 1538 continue; 1539 mpOutGlyphs[ i + rVisualItem.mnMinGlyphPos ] = DROPPED_OUTGLYPH; 1540 // request fallback for the whole cell that resulted in a NotDef glyph 1541 // TODO: optimize algorithm 1542 const bool bRTL = rVisualItem.IsRTL(); 1543 if( !bRTL ) 1544 { 1545 // request fallback for the left-to-right cell 1546 for( int c = nMinCharPos; c < nEndCharPos; ++c ) 1547 { 1548 if( mpLogClusters[ c ] == i ) 1549 { 1550 // --> HDU/FME 2005-10-25 #i55716# skip WORDJOINER 1551 if( rArgs.mpStr[ c ] == 0x2060 ) 1552 mpOutGlyphs[ i + rVisualItem.mnMinGlyphPos ] = 1; 1553 else 1554 // <-- 1555 rArgs.NeedFallback( c, false ); 1556 } 1557 } 1558 } 1559 else 1560 { 1561 // request fallback for the right to left cell 1562 for( int c = nEndCharPos; --c >= nMinCharPos; ) 1563 { 1564 if( mpLogClusters[ c ] == i ) 1565 { 1566 // --> HDU/FME 2005-10-25 #i55716# skip WORDJOINER 1567 if( rArgs.mpStr[ c ] == 0x2060 ) 1568 mpOutGlyphs[ i + rVisualItem.mnMinGlyphPos ] = 1; 1569 else 1570 // <-- 1571 rArgs.NeedFallback( c, true ); 1572 } 1573 } 1574 } 1575 } while( ++i < nGlyphCount ); 1576 } 1577 } 1578 1579 // now place the glyphs 1580 nRC = (*pScriptPlace)( mhDC, &rScriptCache, 1581 mpOutGlyphs + rVisualItem.mnMinGlyphPos, 1582 nGlyphCount, 1583 mpVisualAttrs + rVisualItem.mnMinGlyphPos, 1584 &rVisualItem.mpScriptItem->a, 1585 mpGlyphAdvances + rVisualItem.mnMinGlyphPos, 1586 mpGlyphOffsets + rVisualItem.mnMinGlyphPos, 1587 &rVisualItem.maABCWidths ); 1588 1589 if( nRC != 0 ) 1590 continue; 1591 1592 // calculate the logical char widths from the glyph layout 1593 nRC = (*pScriptGetLogicalWidths)( 1594 &rVisualItem.mpScriptItem->a, 1595 nCharCount, nGlyphCount, 1596 mpGlyphAdvances + rVisualItem.mnMinGlyphPos, 1597 mpLogClusters + rVisualItem.mnMinCharPos, 1598 mpVisualAttrs + rVisualItem.mnMinGlyphPos, 1599 mpCharWidths + rVisualItem.mnMinCharPos ); 1600 1601 // update the glyph counters 1602 mnGlyphCount += nGlyphCount; 1603 rVisualItem.mnEndGlyphPos = mnGlyphCount; 1604 1605 // update nXOffset 1606 int nEndGlyphPos; 1607 if( GetItemSubrange( rVisualItem, i, nEndGlyphPos ) ) 1608 for(; i < nEndGlyphPos; ++i ) 1609 nXOffset += mpGlyphAdvances[ i ]; 1610 1611 // TODO: shrink glyphpos limits to match charpos/fallback limits 1612 //pVI->mnMinGlyphPos = nMinGlyphPos; 1613 //pVI->mnEndGlyphPos = nEndGlyphPos; 1614 1615 // drop the superfluous context glyphs 1616 TIntVector::const_iterator it = aDropChars.begin(); 1617 while( it != aDropChars.end() ) 1618 { 1619 // find matching "drop range" 1620 int nMinDropPos = *(it++); // begin of drop range 1621 if( nMinDropPos >= rVisualItem.mnEndCharPos ) 1622 break; 1623 int nEndDropPos = *(it++); // end of drop range 1624 if( nEndDropPos <= rVisualItem.mnMinCharPos ) 1625 continue; 1626 // clip "drop range" to visual item's char range 1627 if( nMinDropPos <= rVisualItem.mnMinCharPos ) 1628 { 1629 nMinDropPos = rVisualItem.mnMinCharPos; 1630 // drop the whole visual item if possible 1631 if( nEndDropPos >= rVisualItem.mnEndCharPos ) 1632 { 1633 rVisualItem.mnEndGlyphPos = 0; 1634 break; 1635 } 1636 } 1637 if( nEndDropPos > rVisualItem.mnEndCharPos ) 1638 nEndDropPos = rVisualItem.mnEndCharPos; 1639 1640 // drop the glyphs which correspond to the charpos range 1641 // drop the corresponding glyphs in the cluster 1642 for( int c = nMinDropPos; c < nEndDropPos; ++c ) 1643 { 1644 int nGlyphPos = mpLogClusters[c] + rVisualItem.mnMinGlyphPos; 1645 // no need to bother when the cluster was already dropped 1646 if( mpOutGlyphs[ nGlyphPos ] != DROPPED_OUTGLYPH ) 1647 { 1648 for(;;) 1649 { 1650 mpOutGlyphs[ nGlyphPos ] = DROPPED_OUTGLYPH; 1651 // until the end of visual item 1652 if( ++nGlyphPos >= rVisualItem.mnEndGlyphPos ) 1653 break; 1654 // until the next cluster start 1655 if( mpVisualAttrs[ nGlyphPos ].fClusterStart ) 1656 break; 1657 } 1658 } 1659 } 1660 } 1661 } 1662 1663 // scale layout metrics if needed 1664 // TODO: does it make the code more simple if the metric scaling 1665 // is moved to the methods that need metric scaling (e.g. FillDXArray())? 1666 if( mfFontScale != 1.0 ) 1667 { 1668 mnBaseAdv = (int)((double)mnBaseAdv*mfFontScale); 1669 1670 for( i = 0; i < mnItemCount; ++i ) 1671 mpVisualItems[i].mnXOffset = (int)((double)mpVisualItems[i].mnXOffset*mfFontScale); 1672 1673 mnBaseAdv = (int)((double)mnBaseAdv*mfFontScale); 1674 for( i = 0; i < mnGlyphCount; ++i ) 1675 { 1676 mpGlyphAdvances[i] = (int)(mpGlyphAdvances[i] * mfFontScale); 1677 mpGlyphOffsets[i].du = (LONG)(mpGlyphOffsets[i].du * mfFontScale); 1678 mpGlyphOffsets[i].dv = (LONG)(mpGlyphOffsets[i].dv * mfFontScale); 1679 // mpJustifications are still NULL 1680 } 1681 1682 for( i = mnSubStringMin; i < nSubStringEnd; ++i ) 1683 mpCharWidths[i] = (int)(mpCharWidths[i] * mfFontScale); 1684 } 1685 1686 return true; 1687 } 1688 1689 // ----------------------------------------------------------------------- 1690 1691 // calculate the range of relevant glyphs for this visual item 1692 bool UniscribeLayout::GetItemSubrange( const VisualItem& rVisualItem, 1693 int& rMinGlyphPos, int& rEndGlyphPos ) const 1694 { 1695 // return early when nothing of interest in this item 1696 if( rVisualItem.IsEmpty() 1697 || (rVisualItem.mnEndCharPos <= mnMinCharPos) 1698 || (mnEndCharPos <= rVisualItem.mnMinCharPos) ) 1699 return false; 1700 1701 // default: subrange is complete range 1702 rMinGlyphPos = rVisualItem.mnMinGlyphPos; 1703 rEndGlyphPos = rVisualItem.mnEndGlyphPos; 1704 1705 // return early when the whole item is of interest 1706 if( (mnMinCharPos <= rVisualItem.mnMinCharPos) 1707 && (rVisualItem.mnEndCharPos <= mnEndCharPos ) ) 1708 return true; 1709 1710 // get glyph range from char range by looking at cluster boundries 1711 // TODO: optimize for case that LTR/RTL correspond to monotonous glyph indexes 1712 rMinGlyphPos = rVisualItem.mnEndGlyphPos; 1713 int nMaxGlyphPos = 0; 1714 1715 int i = mnMinCharPos; 1716 if( i < rVisualItem.mnMinCharPos ) 1717 i = rVisualItem.mnMinCharPos; 1718 int nCharPosLimit = rVisualItem.mnEndCharPos; 1719 if( nCharPosLimit > mnEndCharPos ) 1720 nCharPosLimit = mnEndCharPos; 1721 for(; i < nCharPosLimit; ++i ) 1722 { 1723 int n = mpLogClusters[ i ] + rVisualItem.mnMinGlyphPos; 1724 if( rMinGlyphPos > n ) 1725 rMinGlyphPos = n; 1726 if( nMaxGlyphPos < n ) 1727 nMaxGlyphPos = n; 1728 } 1729 if (nMaxGlyphPos > rVisualItem.mnEndGlyphPos) 1730 nMaxGlyphPos = rVisualItem.mnEndGlyphPos - 1; 1731 1732 // extend the glyph range to account for all glyphs in referenced clusters 1733 if( !rVisualItem.IsRTL() ) // LTR-item 1734 { 1735 // extend to rightmost glyph of rightmost referenced cluster 1736 for( i = nMaxGlyphPos; ++i < rVisualItem.mnEndGlyphPos; nMaxGlyphPos = i ) 1737 if( mpVisualAttrs[i].fClusterStart ) 1738 break; 1739 } 1740 else // RTL-item 1741 { 1742 // extend to leftmost glyph of leftmost referenced cluster 1743 for( i = rMinGlyphPos; --i >= rVisualItem.mnMinGlyphPos; rMinGlyphPos = i ) 1744 if( mpVisualAttrs[i].fClusterStart ) 1745 break; 1746 } 1747 rEndGlyphPos = nMaxGlyphPos + 1; 1748 1749 return true; 1750 } 1751 1752 // ----------------------------------------------------------------------- 1753 1754 int UniscribeLayout::GetNextGlyphs( int nLen, sal_GlyphId* pGlyphs, Point& rPos, 1755 int& nStartx8, sal_Int32* pGlyphAdvances, int* pCharPosAry ) const 1756 { 1757 // HACK to allow fake-glyph insertion (e.g. for kashidas) 1758 // TODO: use iterator idiom instead of GetNextGlyphs(...) 1759 // TODO: else make sure that the limit for glyph injection is sufficient (currently 256) 1760 int nSubIter = nStartx8 & 0xff; 1761 int nStart = nStartx8 >> 8; 1762 1763 // check the glyph iterator 1764 if( nStart > mnGlyphCount ) // nStart>MAX means no more glyphs 1765 return 0; 1766 1767 // find the visual item for the nStart glyph position 1768 int nItem = 0; 1769 const VisualItem* pVI = mpVisualItems; 1770 if( nStart <= 0 ) // nStart<=0 requests the first visible glyph 1771 { 1772 // find first visible item 1773 for(; nItem < mnItemCount; ++nItem, ++pVI ) 1774 if( !pVI->IsEmpty() ) 1775 break; 1776 // it is possible that there are glyphs but no valid visual item 1777 // TODO: get rid of these visual items more early 1778 if( nItem < mnItemCount ) 1779 nStart = pVI->mnMinGlyphPos; 1780 } 1781 else //if( nStart > 0 ) // nStart>0 means absolute glyph pos +1 1782 { 1783 --nStart; 1784 1785 // find matching item 1786 for(; nItem < mnItemCount; ++nItem, ++pVI ) 1787 if( (nStart >= pVI->mnMinGlyphPos) 1788 && (nStart < pVI->mnEndGlyphPos) ) 1789 break; 1790 } 1791 1792 // after the last visual item there are no more glyphs 1793 if( (nItem >= mnItemCount) || (nStart < 0) ) 1794 { 1795 nStartx8 = (mnGlyphCount + 1) << 8; 1796 return 0; 1797 } 1798 1799 // calculate the first glyph in the next visual item 1800 int nNextItemStart = mnGlyphCount; 1801 while( ++nItem < mnItemCount ) 1802 { 1803 if( mpVisualItems[nItem].IsEmpty() ) 1804 continue; 1805 nNextItemStart = mpVisualItems[nItem].mnMinGlyphPos; 1806 break; 1807 } 1808 1809 // get the range of relevant glyphs in this visual item 1810 int nMinGlyphPos, nEndGlyphPos; 1811 bool bRC = GetItemSubrange( *pVI, nMinGlyphPos, nEndGlyphPos ); 1812 DBG_ASSERT( bRC, "USPLayout::GNG GISR() returned false" ); 1813 if( !bRC ) 1814 { 1815 nStartx8 = (mnGlyphCount + 1) << 8; 1816 return 0; 1817 } 1818 1819 // make sure nStart is inside the range of relevant glyphs 1820 if( nStart < nMinGlyphPos ) 1821 nStart = nMinGlyphPos; 1822 1823 // calculate the start glyph xoffset relative to layout's base position, 1824 // advance to next visual glyph position by using adjusted glyph widths 1825 // TODO: speed up the calculation for nStart!=0 case by using rPos as a cache 1826 long nXOffset = pVI->mnXOffset; 1827 const int* pGlyphWidths = mpJustifications ? mpJustifications : mpGlyphAdvances; 1828 for( int i = nMinGlyphPos; i < nStart; ++i ) 1829 nXOffset += pGlyphWidths[ i ]; 1830 1831 // adjust the nXOffset relative to glyph cluster start 1832 int c = mnMinCharPos; 1833 if( !pVI->IsRTL() ) // LTR-case 1834 { 1835 // LTR case: subtract the remainder of the cell from xoffset 1836 int nTmpIndex = mpLogClusters[c]; 1837 while( (--c >= pVI->mnMinCharPos) 1838 && (nTmpIndex == mpLogClusters[c]) ) 1839 nXOffset -= mpCharWidths[c]; 1840 } 1841 else // RTL-case 1842 { 1843 // RTL case: add the remainder of the cell from xoffset 1844 int nTmpIndex = mpLogClusters[ pVI->mnEndCharPos - 1 ]; 1845 while( (--c >= pVI->mnMinCharPos) 1846 && (nTmpIndex == mpLogClusters[c]) ) 1847 nXOffset += mpCharWidths[c]; 1848 1849 // adjust the xoffset if justified glyphs are not positioned at their justified positions yet 1850 if( mpJustifications && !bManualCellAlign ) 1851 nXOffset += mpJustifications[ nStart ] - mpGlyphAdvances[ nStart ]; 1852 } 1853 1854 // create mpGlyphs2Chars[] if it is needed later 1855 if( pCharPosAry && !mpGlyphs2Chars ) 1856 { 1857 // create and reset the new array 1858 mpGlyphs2Chars = new int[ mnGlyphCapacity ]; 1859 for( int i = 0; i < mnGlyphCount; ++i ) 1860 mpGlyphs2Chars[i] = -1; 1861 // calculate the char->glyph mapping 1862 for( nItem = 0; nItem < mnItemCount; ++nItem ) 1863 { 1864 // ignore invisible visual items 1865 const VisualItem& rVI = mpVisualItems[ nItem ]; 1866 if( rVI.IsEmpty() ) 1867 continue; 1868 // calculate the mapping by using mpLogClusters[] 1869 // mpGlyphs2Chars[] should obey the logical order 1870 // => reversing the loop does this by overwriting higher logicals 1871 for( c = rVI.mnEndCharPos; --c >= rVI.mnMinCharPos; ) 1872 { 1873 int i = mpLogClusters[c] + rVI.mnMinGlyphPos; 1874 mpGlyphs2Chars[i] = c; 1875 } 1876 } 1877 } 1878 1879 // calculate the absolute position of the first result glyph in pixel units 1880 const GOFFSET aGOffset = mpGlyphOffsets[ nStart ]; 1881 Point aRelativePos( nXOffset + aGOffset.du, -aGOffset.dv ); 1882 rPos = GetDrawPosition( aRelativePos ); 1883 1884 // fill the result arrays 1885 int nCount = 0; 1886 while( nCount < nLen ) 1887 { 1888 // prepare return values 1889 sal_GlyphId aGlyphId = mpOutGlyphs[ nStart ]; 1890 int nGlyphWidth = pGlyphWidths[ nStart ]; 1891 int nCharPos = -1; // no need to determine charpos 1892 if( mpGlyphs2Chars ) // unless explicitly requested+provided 1893 nCharPos = mpGlyphs2Chars[ nStart ]; 1894 1895 // inject kashida glyphs if needed 1896 if( !mbDisableGlyphInjection 1897 && mpJustifications 1898 && mnMinKashidaWidth 1899 && mpVisualAttrs[nStart].uJustification >= SCRIPT_JUSTIFY_ARABIC_NORMAL ) 1900 { 1901 // prepare draw position adjustment 1902 int nExtraOfs = (nSubIter++) * mnMinKashidaWidth; 1903 // calculate space available for the injected glyphs 1904 nGlyphWidth = mpGlyphAdvances[ nStart ]; 1905 const int nExtraWidth = mpJustifications[ nStart ] - nGlyphWidth; 1906 const int nToFillWidth = nExtraWidth - nExtraOfs; 1907 if( (4*nToFillWidth >= mnMinKashidaWidth) // prevent glyph-injection if there is no room 1908 || ((nSubIter > 1) && (nToFillWidth > 0)) ) // unless they can overlap with others 1909 { 1910 // handle if there is not sufficient room for a full glyph 1911 if( nToFillWidth < mnMinKashidaWidth ) 1912 { 1913 // overlap it with the previously injected glyph if possible 1914 int nOverlap = mnMinKashidaWidth - nToFillWidth; 1915 // else overlap it with both neighboring glyphs 1916 if( nSubIter <= 1 ) 1917 nOverlap /= 2; 1918 nExtraOfs -= nOverlap; 1919 } 1920 nGlyphWidth = mnMinKashidaWidth; 1921 aGlyphId = mnMinKashidaGlyph; 1922 nCharPos = -1; 1923 } 1924 else 1925 { 1926 nExtraOfs += nToFillWidth; // at right of cell 1927 nSubIter = 0; // done with glyph injection 1928 } 1929 if( !bManualCellAlign ) 1930 nExtraOfs -= nExtraWidth; // adjust for right-aligned cells 1931 1932 // adjust the draw position for the injected-glyphs case 1933 if( nExtraOfs ) 1934 { 1935 aRelativePos.X() += nExtraOfs; 1936 rPos = GetDrawPosition( aRelativePos ); 1937 } 1938 } 1939 1940 // update return values 1941 *(pGlyphs++) = aGlyphId; 1942 if( pGlyphAdvances ) 1943 *(pGlyphAdvances++) = nGlyphWidth; 1944 if( pCharPosAry ) 1945 *(pCharPosAry++) = nCharPos; 1946 1947 // increment counter of returned glyphs 1948 ++nCount; 1949 1950 // reduce code complexity by returning early in glyph-injection case 1951 if( nSubIter != 0 ) 1952 break; 1953 1954 // stop after the last visible glyph in this visual item 1955 if( ++nStart >= nEndGlyphPos ) 1956 { 1957 nStart = nNextItemStart; 1958 break; 1959 } 1960 1961 // RTL-justified glyph positioning is not easy 1962 // simplify the code by just returning only one glyph at a time 1963 if( mpJustifications && pVI->IsRTL() ) 1964 break; 1965 1966 // stop when the x-position of the next glyph is unexpected 1967 if( !pGlyphAdvances ) 1968 if( (mpGlyphOffsets && (mpGlyphOffsets[nStart].du != aGOffset.du) ) 1969 || (mpJustifications && (mpJustifications[nStart] != mpGlyphAdvances[nStart]) ) ) 1970 break; 1971 1972 // stop when the y-position of the next glyph is unexpected 1973 if( mpGlyphOffsets && (mpGlyphOffsets[nStart].dv != aGOffset.dv) ) 1974 break; 1975 } 1976 1977 ++nStart; 1978 nStartx8 = (nStart << 8) + nSubIter; 1979 return nCount; 1980 } 1981 1982 // ----------------------------------------------------------------------- 1983 1984 void UniscribeLayout::MoveGlyph( int nStartx8, long nNewXPos ) 1985 { 1986 DBG_ASSERT( !(nStartx8 & 0xff), "USP::MoveGlyph(): glyph injection not disabled!" ); 1987 int nStart = nStartx8 >> 8; 1988 if( nStart > mnGlyphCount ) 1989 return; 1990 1991 VisualItem* pVI = mpVisualItems; 1992 int nMinGlyphPos = 0, nEndGlyphPos; 1993 if( nStart == 0 ) // nStart==0 for first visible glyph 1994 { 1995 for( int i = mnItemCount; --i >= 0; ++pVI ) 1996 if( GetItemSubrange( *pVI, nMinGlyphPos, nEndGlyphPos ) ) 1997 break; 1998 nStart = nMinGlyphPos; 1999 DBG_ASSERT( nStart <= mnGlyphCount, "USPLayout::MoveG overflow" ); 2000 } 2001 else //if( nStart > 0 ) // nStart>0 means absolute_glyphpos+1 2002 { 2003 --nStart; 2004 for( int i = mnItemCount; --i >= 0; ++pVI ) 2005 if( (nStart >= pVI->mnMinGlyphPos) && (nStart < pVI->mnEndGlyphPos) ) 2006 break; 2007 bool bRC = GetItemSubrange( *pVI, nMinGlyphPos, nEndGlyphPos ); 2008 (void)bRC; // avoid var-not-used warning 2009 DBG_ASSERT( bRC, "USPLayout::MoveG GISR() returned false" ); 2010 } 2011 2012 long nDelta = nNewXPos - pVI->mnXOffset; 2013 if( nStart > nMinGlyphPos ) 2014 { 2015 // move the glyph by expanding its left glyph but ignore dropped glyphs 2016 int i, nLastUndropped = nMinGlyphPos - 1; 2017 for( i = nMinGlyphPos; i < nStart; ++i ) 2018 { 2019 if (mpOutGlyphs[i] != DROPPED_OUTGLYPH) 2020 { 2021 nDelta -= (mpJustifications)? mpJustifications[ i ] : mpGlyphAdvances[ i ]; 2022 nLastUndropped = i; 2023 } 2024 } 2025 if (nLastUndropped >= nMinGlyphPos) 2026 { 2027 mpGlyphAdvances[ nLastUndropped ] += nDelta; 2028 if (mpJustifications) mpJustifications[ nLastUndropped ] += nDelta; 2029 } 2030 else 2031 { 2032 pVI->mnXOffset += nDelta; 2033 } 2034 } 2035 else 2036 { 2037 // move the visual item by having an offset 2038 pVI->mnXOffset += nDelta; 2039 } 2040 // move subsequent items - this often isn't necessary because subsequent 2041 // moves will correct subsequent items. However, if there is a contiguous 2042 // range not involving fallback which spans items, this will be needed 2043 while (++pVI - mpVisualItems < mnItemCount) 2044 { 2045 pVI->mnXOffset += nDelta; 2046 } 2047 } 2048 2049 // ----------------------------------------------------------------------- 2050 2051 void UniscribeLayout::DropGlyph( int nStartx8 ) 2052 { 2053 DBG_ASSERT( !(nStartx8 & 0xff), "USP::DropGlyph(): glyph injection not disabled!" ); 2054 int nStart = nStartx8 >> 8; 2055 DBG_ASSERT( nStart<=mnGlyphCount, "USPLayout::MoveG nStart overflow" ); 2056 2057 if( nStart > 0 ) // nStart>0 means absolute glyph pos + 1 2058 --nStart; 2059 else // nStart<=0 for first visible glyph 2060 { 2061 VisualItem* pVI = mpVisualItems; 2062 for( int i = mnItemCount, nDummy; --i >= 0; ++pVI ) 2063 if( GetItemSubrange( *pVI, nStart, nDummy ) ) 2064 break; 2065 DBG_ASSERT( nStart <= mnGlyphCount, "USPLayout::DropG overflow" ); 2066 int nOffset = 0; 2067 int j = pVI->mnMinGlyphPos; 2068 while (mpOutGlyphs[j] == DROPPED_OUTGLYPH) j++; 2069 if (j == nStart) 2070 { 2071 pVI->mnXOffset += ((mpJustifications)? mpJustifications[nStart] : mpGlyphAdvances[nStart]); 2072 } 2073 } 2074 2075 mpOutGlyphs[ nStart ] = DROPPED_OUTGLYPH; 2076 } 2077 2078 // ----------------------------------------------------------------------- 2079 2080 void UniscribeLayout::Simplify( bool /*bIsBase*/ ) 2081 { 2082 static const WCHAR cDroppedGlyph = DROPPED_OUTGLYPH; 2083 int i; 2084 // if there are no dropped glyphs don't bother 2085 for( i = 0; i < mnGlyphCount; ++i ) 2086 if( mpOutGlyphs[ i ] == cDroppedGlyph ) 2087 break; 2088 if( i >= mnGlyphCount ) 2089 return; 2090 2091 // prepare for sparse layout 2092 // => make sure mpGlyphs2Chars[] exists 2093 if( !mpGlyphs2Chars ) 2094 { 2095 mpGlyphs2Chars = new int[ mnGlyphCapacity ]; 2096 for( i = 0; i < mnGlyphCount; ++i ) 2097 mpGlyphs2Chars[ i ] = -1; 2098 for( int nItem = 0; nItem < mnItemCount; ++nItem ) 2099 { 2100 // skip invisible items 2101 VisualItem& rVI = mpVisualItems[ nItem ]; 2102 if( rVI.IsEmpty() ) 2103 continue; 2104 for( i = rVI.mnEndCharPos; --i >= rVI.mnMinCharPos; ) 2105 { 2106 int j = mpLogClusters[ i ] + rVI.mnMinGlyphPos; 2107 mpGlyphs2Chars[ j ] = i; 2108 } 2109 } 2110 } 2111 2112 // remove the dropped glyphs 2113 const int* pGlyphWidths = mpJustifications ? mpJustifications : mpGlyphAdvances; 2114 for( int nItem = 0; nItem < mnItemCount; ++nItem ) 2115 { 2116 VisualItem& rVI = mpVisualItems[ nItem ]; 2117 if( rVI.IsEmpty() ) 2118 continue; 2119 2120 // mark replaced character widths 2121 for( i = rVI.mnMinCharPos; i < rVI.mnEndCharPos; ++i ) 2122 { 2123 int j = mpLogClusters[ i ] + rVI.mnMinGlyphPos; 2124 if( mpOutGlyphs[ j ] == cDroppedGlyph ) 2125 mpCharWidths[ i ] = 0; 2126 } 2127 2128 // handle dropped glyphs at start of visual item 2129 int nMinGlyphPos, nEndGlyphPos, nOrigMinGlyphPos = rVI.mnMinGlyphPos; 2130 GetItemSubrange( rVI, nMinGlyphPos, nEndGlyphPos ); 2131 i = nMinGlyphPos; 2132 while( (mpOutGlyphs[i] == cDroppedGlyph) && (i < nEndGlyphPos) ) 2133 { 2134 //rVI.mnXOffset += pGlyphWidths[ i ]; 2135 rVI.mnMinGlyphPos = ++i; 2136 } 2137 2138 // when all glyphs in item got dropped mark it as empty 2139 if( i >= nEndGlyphPos ) 2140 { 2141 rVI.mnEndGlyphPos = 0; 2142 continue; 2143 } 2144 // If there are still glyphs in the cluster and mnMinGlyphPos 2145 // has changed then we need to remove the dropped glyphs at start 2146 // to correct logClusters, which is unsigned and relative to the 2147 // item start. 2148 if (rVI.mnMinGlyphPos != nOrigMinGlyphPos) 2149 { 2150 // drop any glyphs in the visual item outside the range 2151 for (i = nOrigMinGlyphPos; i < nMinGlyphPos; i++) 2152 mpOutGlyphs[ i ] = cDroppedGlyph; 2153 rVI.mnMinGlyphPos = i = nOrigMinGlyphPos; 2154 } 2155 2156 // handle dropped glyphs in the middle of visual item 2157 for(; i < nEndGlyphPos; ++i ) 2158 if( mpOutGlyphs[ i ] == cDroppedGlyph ) 2159 break; 2160 int j = i; 2161 while( ++i < nEndGlyphPos ) 2162 { 2163 if( mpOutGlyphs[ i ] == cDroppedGlyph ) 2164 continue; 2165 mpOutGlyphs[ j ] = mpOutGlyphs[ i ]; 2166 mpGlyphOffsets[ j ] = mpGlyphOffsets[ i ]; 2167 mpVisualAttrs[ j ] = mpVisualAttrs[ i ]; 2168 mpGlyphAdvances[ j ] = mpGlyphAdvances[ i ]; 2169 if( mpJustifications ) 2170 mpJustifications[ j ] = mpJustifications[ i ]; 2171 const int k = mpGlyphs2Chars[ i ]; 2172 mpGlyphs2Chars[ j ] = k; 2173 const int nRelGlyphPos = (j++) - rVI.mnMinGlyphPos; 2174 if( k < 0) // extra glyphs are already mapped 2175 continue; 2176 mpLogClusters[ k ] = static_cast<WORD>(nRelGlyphPos); 2177 } 2178 2179 rVI.mnEndGlyphPos = j; 2180 } 2181 } 2182 2183 // ----------------------------------------------------------------------- 2184 2185 void UniscribeLayout::DrawText( SalGraphics& ) const 2186 { 2187 HFONT hOrigFont = DisableFontScaling(); 2188 2189 int nBaseClusterOffset = 0; 2190 int nBaseGlyphPos = -1; 2191 for( int nItem = 0; nItem < mnItemCount; ++nItem ) 2192 { 2193 const VisualItem& rVisualItem = mpVisualItems[ nItem ]; 2194 2195 // skip if there is nothing to display 2196 int nMinGlyphPos, nEndGlyphPos; 2197 if( !GetItemSubrange( rVisualItem, nMinGlyphPos, nEndGlyphPos ) ) 2198 continue; 2199 2200 if( nBaseGlyphPos < 0 ) 2201 { 2202 // adjust draw position relative to cluster start 2203 if( rVisualItem.IsRTL() ) 2204 nBaseGlyphPos = nEndGlyphPos - 1; 2205 else 2206 nBaseGlyphPos = nMinGlyphPos; 2207 2208 const int* pGlyphWidths; 2209 if( mpJustifications ) 2210 pGlyphWidths = mpJustifications; 2211 else 2212 pGlyphWidths = mpGlyphAdvances; 2213 2214 int i = mnMinCharPos; 2215 while( (--i >= rVisualItem.mnMinCharPos) 2216 && (nBaseGlyphPos == mpLogClusters[i]) ) 2217 nBaseClusterOffset += mpCharWidths[i]; 2218 2219 if( !rVisualItem.IsRTL() ) 2220 nBaseClusterOffset = -nBaseClusterOffset; 2221 } 2222 2223 // now draw the matching glyphs in this item 2224 Point aRelPos( rVisualItem.mnXOffset + nBaseClusterOffset, 0 ); 2225 Point aPos = GetDrawPosition( aRelPos ); 2226 SCRIPT_CACHE& rScriptCache = GetScriptCache(); 2227 (*pScriptTextOut)( mhDC, &rScriptCache, 2228 aPos.X(), aPos.Y(), 0, NULL, 2229 &rVisualItem.mpScriptItem->a, NULL, 0, 2230 mpOutGlyphs + nMinGlyphPos, 2231 nEndGlyphPos - nMinGlyphPos, 2232 mpGlyphAdvances + nMinGlyphPos, 2233 mpJustifications ? mpJustifications + nMinGlyphPos : NULL, 2234 mpGlyphOffsets + nMinGlyphPos ); 2235 } 2236 2237 if( hOrigFont ) 2238 DeleteFont( SelectFont( mhDC, hOrigFont ) ); 2239 } 2240 2241 // ----------------------------------------------------------------------- 2242 2243 long UniscribeLayout::FillDXArray( long* pDXArray ) const 2244 { 2245 // calculate width of the complete layout 2246 long nWidth = mnBaseAdv; 2247 for( int nItem = mnItemCount; --nItem >= 0; ) 2248 { 2249 const VisualItem& rVI = mpVisualItems[ nItem ]; 2250 2251 // skip if there is nothing to display 2252 int nMinGlyphPos, nEndGlyphPos; 2253 if( !GetItemSubrange( rVI, nMinGlyphPos, nEndGlyphPos ) ) 2254 continue; 2255 2256 // width = xoffset + width of last item 2257 nWidth = rVI.mnXOffset; 2258 const int* pGlyphWidths = mpJustifications ? mpJustifications : mpGlyphAdvances; 2259 for( int i = nMinGlyphPos; i < nEndGlyphPos; ++i ) 2260 nWidth += pGlyphWidths[i]; 2261 break; 2262 } 2263 2264 // copy the virtual char widths into pDXArray[] 2265 if( pDXArray ) 2266 for( int i = mnMinCharPos; i < mnEndCharPos; ++i ) 2267 pDXArray[ i - mnMinCharPos ] = mpCharWidths[ i ]; 2268 2269 return nWidth; 2270 } 2271 2272 // ----------------------------------------------------------------------- 2273 2274 int UniscribeLayout::GetTextBreak( long nMaxWidth, long nCharExtra, int nFactor ) const 2275 { 2276 long nWidth = 0; 2277 for( int i = mnMinCharPos; i < mnEndCharPos; ++i ) 2278 { 2279 nWidth += mpCharWidths[ i ] * nFactor; 2280 2281 // check if the nMaxWidth still fits the current sub-layout 2282 if( nWidth >= nMaxWidth ) 2283 { 2284 // go back to cluster start 2285 // we have to find the visual item first since the mpLogClusters[] 2286 // needed to find the cluster start is relative to to the visual item 2287 int nMinGlyphIndex = 0; 2288 for( int nItem = 0; nItem < mnItemCount; ++nItem ) 2289 { 2290 const VisualItem& rVisualItem = mpVisualItems[ nItem ]; 2291 nMinGlyphIndex = rVisualItem.mnMinGlyphPos; 2292 if( (i >= rVisualItem.mnMinCharPos) 2293 && (i < rVisualItem.mnEndCharPos) ) 2294 break; 2295 } 2296 // now go back to the matching cluster start 2297 do 2298 { 2299 int nGlyphPos = mpLogClusters[i] + nMinGlyphIndex; 2300 if( 0 != mpVisualAttrs[ nGlyphPos ].fClusterStart ) 2301 return i; 2302 } while( --i >= mnMinCharPos ); 2303 2304 // if the cluster starts before the start of the visual item 2305 // then set the visual breakpoint before this item 2306 return mnMinCharPos; 2307 } 2308 2309 // the visual break also depends on the nCharExtra between the characters 2310 nWidth += nCharExtra; 2311 } 2312 2313 // the whole layout did fit inside the nMaxWidth 2314 return STRING_LEN; 2315 } 2316 2317 // ----------------------------------------------------------------------- 2318 2319 void UniscribeLayout::GetCaretPositions( int nMaxIdx, long* pCaretXArray ) const 2320 { 2321 int i; 2322 for( i = 0; i < nMaxIdx; ++i ) 2323 pCaretXArray[ i ] = -1; 2324 long* const pGlyphPos = (long*)alloca( (mnGlyphCount+1) * sizeof(long) ); 2325 for( i = 0; i <= mnGlyphCount; ++i ) 2326 pGlyphPos[ i ] = -1; 2327 2328 long nXPos = 0; 2329 for( int nItem = 0; nItem < mnItemCount; ++nItem ) 2330 { 2331 const VisualItem& rVisualItem = mpVisualItems[ nItem ]; 2332 if( rVisualItem.IsEmpty() ) 2333 continue; 2334 2335 if (mnLayoutFlags & SAL_LAYOUT_FOR_FALLBACK) 2336 { 2337 nXPos = rVisualItem.mnXOffset; 2338 } 2339 // get glyph positions 2340 // TODO: handle when rVisualItem's glyph range is only partially used 2341 for( i = rVisualItem.mnMinGlyphPos; i < rVisualItem.mnEndGlyphPos; ++i ) 2342 { 2343 pGlyphPos[ i ] = nXPos; 2344 nXPos += mpGlyphAdvances[ i ]; 2345 } 2346 // rightmost position of this visualitem 2347 pGlyphPos[ i ] = nXPos; 2348 2349 // convert glyph positions to character positions 2350 i = rVisualItem.mnMinCharPos; 2351 if( i < mnMinCharPos ) 2352 i = mnMinCharPos; 2353 for(; (i < rVisualItem.mnEndCharPos) && (i < mnEndCharPos); ++i ) 2354 { 2355 int j = mpLogClusters[ i ] + rVisualItem.mnMinGlyphPos; 2356 int nCurrIdx = i * 2; 2357 if( !rVisualItem.IsRTL() ) 2358 { 2359 // normal positions for LTR case 2360 pCaretXArray[ nCurrIdx ] = pGlyphPos[ j ]; 2361 pCaretXArray[ nCurrIdx+1 ] = pGlyphPos[ j+1 ]; 2362 } 2363 else 2364 { 2365 // reverse positions for RTL case 2366 pCaretXArray[ nCurrIdx ] = pGlyphPos[ j+1 ]; 2367 pCaretXArray[ nCurrIdx+1 ] = pGlyphPos[ j ]; 2368 } 2369 } 2370 } 2371 2372 if (!(mnLayoutFlags & SAL_LAYOUT_FOR_FALLBACK)) 2373 { 2374 nXPos = 0; 2375 // fixup unknown character positions to neighbor 2376 for( i = 0; i < nMaxIdx; ++i ) 2377 { 2378 if( pCaretXArray[ i ] >= 0 ) 2379 nXPos = pCaretXArray[ i ]; 2380 else 2381 pCaretXArray[ i ] = nXPos; 2382 } 2383 } 2384 } 2385 2386 // ----------------------------------------------------------------------- 2387 2388 void UniscribeLayout::AdjustLayout( ImplLayoutArgs& rArgs ) 2389 { 2390 SalLayout::AdjustLayout( rArgs ); 2391 2392 // adjust positions if requested 2393 if( rArgs.mpDXArray ) 2394 ApplyDXArray( rArgs ); 2395 else if( rArgs.mnLayoutWidth ) 2396 Justify( rArgs.mnLayoutWidth ); 2397 } 2398 2399 // ----------------------------------------------------------------------- 2400 2401 void UniscribeLayout::ApplyDXArray( const ImplLayoutArgs& rArgs ) 2402 { 2403 const long* pDXArray = rArgs.mpDXArray; 2404 2405 // increase char widths in string range to desired values 2406 bool bModified = false; 2407 int nOldWidth = 0; 2408 DBG_ASSERT( mnUnitsPerPixel==1, "UniscribeLayout.mnUnitsPerPixel != 1" ); 2409 int i,j; 2410 for( i = mnMinCharPos, j = 0; i < mnEndCharPos; ++i, ++j ) 2411 { 2412 int nNewCharWidth = (pDXArray[j] - nOldWidth); 2413 // TODO: nNewCharWidth *= mnUnitsPerPixel; 2414 if( mpCharWidths[i] != nNewCharWidth ) 2415 { 2416 mpCharWidths[i] = nNewCharWidth; 2417 bModified = true; 2418 } 2419 nOldWidth = pDXArray[j]; 2420 } 2421 2422 if( !bModified ) 2423 return; 2424 2425 // initialize justifications array 2426 mpJustifications = new int[ mnGlyphCapacity ]; 2427 for( i = 0; i < mnGlyphCount; ++i ) 2428 mpJustifications[ i ] = mpGlyphAdvances[ i ]; 2429 2430 // apply new widths to script items 2431 long nXOffset = 0; 2432 for( int nItem = 0; nItem < mnItemCount; ++nItem ) 2433 { 2434 VisualItem& rVisualItem = mpVisualItems[ nItem ]; 2435 2436 // set the position of this visual item 2437 rVisualItem.mnXOffset = nXOffset; 2438 2439 // ignore empty visual items 2440 if( rVisualItem.IsEmpty() ) 2441 { 2442 for (i = rVisualItem.mnMinCharPos; i < rVisualItem.mnEndCharPos; i++) 2443 nXOffset += mpCharWidths[i]; 2444 continue; 2445 } 2446 // ignore irrelevant visual items 2447 if( (rVisualItem.mnMinCharPos >= mnEndCharPos) 2448 || (rVisualItem.mnEndCharPos <= mnMinCharPos) ) 2449 continue; 2450 2451 // if needed prepare special handling for arabic justification 2452 rVisualItem.mbHasKashidas = false; 2453 if( rVisualItem.IsRTL() ) 2454 { 2455 for( i = rVisualItem.mnMinGlyphPos; i < rVisualItem.mnEndGlyphPos; ++i ) 2456 if ( (1U << mpVisualAttrs[i].uJustification) & 0xFF82 ) // any Arabic justification 2457 { // excluding SCRIPT_JUSTIFY_NONE 2458 // yes 2459 rVisualItem.mbHasKashidas = true; 2460 // so prepare for kashida handling 2461 InitKashidaHandling(); 2462 break; 2463 } 2464 2465 if( rVisualItem.HasKashidas() ) 2466 for( i = rVisualItem.mnMinGlyphPos; i < rVisualItem.mnEndGlyphPos; ++i ) 2467 { 2468 // TODO: check if we still need this hack after correction of kashida placing? 2469 // (i87688): apparently yes, we still need it! 2470 if ( mpVisualAttrs[i].uJustification == SCRIPT_JUSTIFY_NONE ) 2471 // usp decided that justification can't be applied here 2472 // but maybe our Kashida algorithm thinks differently. 2473 // To avoid trouble (gaps within words, last character of 2474 // a word gets a Kashida appended) override this. 2475 2476 // I chose SCRIPT_JUSTIFY_ARABIC_KASHIDA to replace SCRIPT_JUSTIFY_NONE 2477 // just because this previous hack (which I haven't understand, sorry) used 2478 // the same value to replace. Don't know if this is really the best 2479 // thing to do, but it seems to fix things 2480 mpVisualAttrs[i].uJustification = SCRIPT_JUSTIFY_ARABIC_KASHIDA; 2481 } 2482 } 2483 2484 // convert virtual charwidths to glyph justification values 2485 HRESULT nRC = (*pScriptApplyLogicalWidth)( 2486 mpCharWidths + rVisualItem.mnMinCharPos, 2487 rVisualItem.mnEndCharPos - rVisualItem.mnMinCharPos, 2488 rVisualItem.mnEndGlyphPos - rVisualItem.mnMinGlyphPos, 2489 mpLogClusters + rVisualItem.mnMinCharPos, 2490 mpVisualAttrs + rVisualItem.mnMinGlyphPos, 2491 mpGlyphAdvances + rVisualItem.mnMinGlyphPos, 2492 &rVisualItem.mpScriptItem->a, 2493 &rVisualItem.maABCWidths, 2494 mpJustifications + rVisualItem.mnMinGlyphPos ); 2495 2496 if( nRC != 0 ) 2497 { 2498 delete[] mpJustifications; 2499 mpJustifications = NULL; 2500 break; 2501 } 2502 2503 // to prepare for the next visual item 2504 // update nXOffset to the next items position 2505 // before the mpJustifications[] array gets modified 2506 int nMinGlyphPos, nEndGlyphPos; 2507 if( GetItemSubrange( rVisualItem, nMinGlyphPos, nEndGlyphPos ) ) 2508 { 2509 for( i = nMinGlyphPos; i < nEndGlyphPos; ++i ) 2510 nXOffset += mpJustifications[ i ]; 2511 2512 if( rVisualItem.mbHasKashidas ) 2513 KashidaItemFix( nMinGlyphPos, nEndGlyphPos ); 2514 } 2515 2516 // workaround needed for older USP versions: 2517 // right align the justification-adjusted glyphs in their cells for RTL-items 2518 // unless the right alignment is done by inserting kashidas 2519 if( bManualCellAlign && rVisualItem.IsRTL() && !rVisualItem.HasKashidas() ) 2520 { 2521 for( i = nMinGlyphPos; i < nEndGlyphPos; ++i ) 2522 { 2523 const int nXOffsetAdjust = mpJustifications[i] - mpGlyphAdvances[i]; 2524 // #i99862# skip diacritics, we mustn't add extra justification to diacritics 2525 int nIdxAdd = i - 1; 2526 while( (nIdxAdd >= nMinGlyphPos) && !mpGlyphAdvances[nIdxAdd] ) 2527 --nIdxAdd; 2528 if( nIdxAdd < nMinGlyphPos ) 2529 rVisualItem.mnXOffset += nXOffsetAdjust; 2530 else 2531 mpJustifications[nIdxAdd] += nXOffsetAdjust; 2532 mpJustifications[i] -= nXOffsetAdjust; 2533 } 2534 } 2535 } 2536 } 2537 2538 // ----------------------------------------------------------------------- 2539 2540 void UniscribeLayout::InitKashidaHandling() 2541 { 2542 if( mnMinKashidaGlyph != 0 ) // already initialized 2543 return; 2544 2545 mrWinFontEntry.InitKashidaHandling( mhDC ); 2546 mnMinKashidaWidth = static_cast<int>(mfFontScale * mrWinFontEntry.GetMinKashidaWidth()); 2547 mnMinKashidaGlyph = mrWinFontEntry.GetMinKashidaGlyph(); 2548 } 2549 2550 // adjust the kashida placement matching to the WriterEngine 2551 void UniscribeLayout::KashidaItemFix( int nMinGlyphPos, int nEndGlyphPos ) 2552 { 2553 // workaround needed for all known USP versions: 2554 // ApplyLogicalWidth does not match ScriptJustify behaviour 2555 for( int i = nMinGlyphPos; i < nEndGlyphPos; ++i ) 2556 { 2557 // check for vowels 2558 if( (i > nMinGlyphPos && !mpGlyphAdvances[ i-1 ]) 2559 && (1U << mpVisualAttrs[i].uJustification) & 0xFF83 ) // all Arabic justifiction types 2560 { // including SCRIPT_JUSTIFY_NONE 2561 // vowel, we do it like ScriptJustify does 2562 // the vowel gets the extra width 2563 long nSpaceAdded = mpJustifications[ i ] - mpGlyphAdvances[ i ]; 2564 mpJustifications [ i ] = mpGlyphAdvances [ i ]; 2565 mpJustifications [ i - 1 ] += nSpaceAdded; 2566 } 2567 } 2568 2569 // redistribute the widths for kashidas 2570 for( int i = nMinGlyphPos; i < nEndGlyphPos; ) 2571 KashidaWordFix ( nMinGlyphPos, nEndGlyphPos, &i ); 2572 } 2573 2574 bool UniscribeLayout::KashidaWordFix ( int nMinGlyphPos, int nEndGlyphPos, int* pnCurrentPos ) 2575 { 2576 // doing pixel work within a word. 2577 // sometimes we have extra pixels and sometimes we miss some pixels to get to mnMinKashidaWidth 2578 2579 // find the next kashida 2580 int nMinPos = *pnCurrentPos; 2581 int nMaxPos = *pnCurrentPos; 2582 for( int i = nMaxPos; i < nEndGlyphPos; ++i ) 2583 { 2584 if( (mpVisualAttrs[ i ].uJustification >= SCRIPT_JUSTIFY_ARABIC_BLANK) 2585 && (mpVisualAttrs[ i ].uJustification < SCRIPT_JUSTIFY_ARABIC_NORMAL) ) 2586 break; 2587 nMaxPos = i; 2588 } 2589 *pnCurrentPos = nMaxPos + 1; 2590 if( nMinPos == nMaxPos ) 2591 return false; 2592 2593 // calculate the available space for an extra kashida 2594 long nMaxAdded = 0; 2595 int nKashPos = -1; 2596 for( int i = nMaxPos; i >= nMinPos; --i ) 2597 { 2598 long nSpaceAdded = mpJustifications[ i ] - mpGlyphAdvances[ i ]; 2599 if( nSpaceAdded > nMaxAdded ) 2600 { 2601 nKashPos = i; 2602 nMaxAdded = nSpaceAdded; 2603 } 2604 } 2605 2606 // return early if there is no need for an extra kashida 2607 if ( nMaxAdded <= 0 ) 2608 return false; 2609 // return early if there is not enough space for an extra kashida 2610 if( 2*nMaxAdded < mnMinKashidaWidth ) 2611 return false; 2612 2613 // redistribute the extra spacing to the kashida position 2614 for( int i = nMinPos; i <= nMaxPos; ++i ) 2615 { 2616 if( i == nKashPos ) 2617 continue; 2618 // everything else should not have extra spacing 2619 long nSpaceAdded = mpJustifications[ i ] - mpGlyphAdvances[ i ]; 2620 if( nSpaceAdded > 0 ) 2621 { 2622 mpJustifications[ i ] -= nSpaceAdded; 2623 mpJustifications[ nKashPos ] += nSpaceAdded; 2624 } 2625 } 2626 2627 // check if we fulfill minimal kashida width 2628 long nSpaceAdded = mpJustifications[ nKashPos ] - mpGlyphAdvances[ nKashPos ]; 2629 if( nSpaceAdded < mnMinKashidaWidth ) 2630 { 2631 // ugly: steal some pixels 2632 long nSteal = 1; 2633 if ( nMaxPos - nMinPos > 0 && ((mnMinKashidaWidth - nSpaceAdded) > (nMaxPos - nMinPos))) 2634 nSteal = (mnMinKashidaWidth - nSpaceAdded) / (nMaxPos - nMinPos); 2635 for( int i = nMinPos; i <= nMaxPos; ++i ) 2636 { 2637 if( i == nKashPos ) 2638 continue; 2639 nSteal = Min( mnMinKashidaWidth - nSpaceAdded, nSteal ); 2640 if ( nSteal > 0 ) 2641 { 2642 mpJustifications [ i ] -= nSteal; 2643 mpJustifications [ nKashPos ] += nSteal; 2644 nSpaceAdded += nSteal; 2645 } 2646 if( nSpaceAdded >= mnMinKashidaWidth ) 2647 return true; 2648 } 2649 } 2650 2651 // blank padding 2652 long nSpaceMissing = mnMinKashidaWidth - nSpaceAdded; 2653 if( nSpaceMissing > 0 ) 2654 { 2655 // inner glyph: distribute extra space evenly 2656 if( (nMinPos > nMinGlyphPos) && (nMaxPos < nEndGlyphPos - 1) ) 2657 { 2658 mpJustifications [ nKashPos ] += nSpaceMissing; 2659 long nHalfSpace = nSpaceMissing / 2; 2660 mpJustifications [ nMinPos - 1 ] -= nHalfSpace; 2661 mpJustifications [ nMaxPos + 1 ] -= nSpaceMissing - nHalfSpace; 2662 } 2663 // rightmost: left glyph gets extra space 2664 else if( nMinPos > nMinGlyphPos ) 2665 { 2666 mpJustifications [ nMinPos - 1 ] -= nSpaceMissing; 2667 mpJustifications [ nKashPos ] += nSpaceMissing; 2668 } 2669 // leftmost: right glyph gets extra space 2670 else if( nMaxPos < nEndGlyphPos - 1 ) 2671 { 2672 mpJustifications [ nKashPos ] += nSpaceMissing; 2673 mpJustifications [ nMaxPos + 1 ] -= nSpaceMissing; 2674 } 2675 else 2676 return false; 2677 } 2678 2679 return true; 2680 } 2681 2682 // ----------------------------------------------------------------------- 2683 2684 void UniscribeLayout::Justify( long nNewWidth ) 2685 { 2686 long nOldWidth = 0; 2687 int i; 2688 for( i = mnMinCharPos; i < mnEndCharPos; ++i ) 2689 nOldWidth += mpCharWidths[ i ]; 2690 if( nOldWidth <= 0 ) 2691 return; 2692 2693 nNewWidth *= mnUnitsPerPixel; // convert into font units 2694 if( nNewWidth == nOldWidth ) 2695 return; 2696 // prepare to distribute the extra width evenly among the visual items 2697 const double fStretch = (double)nNewWidth / nOldWidth; 2698 2699 // initialize justifications array 2700 mpJustifications = new int[ mnGlyphCapacity ]; 2701 for( i = 0; i < mnGlyphCapacity; ++i ) 2702 mpJustifications[ i ] = mpGlyphAdvances[ i ]; 2703 2704 // justify stretched script items 2705 long nXOffset = 0; 2706 SCRIPT_CACHE& rScriptCache = GetScriptCache(); 2707 for( int nItem = 0; nItem < mnItemCount; ++nItem ) 2708 { 2709 VisualItem& rVisualItem = mpVisualItems[ nItem ]; 2710 if( rVisualItem.IsEmpty() ) 2711 continue; 2712 2713 if( (rVisualItem.mnMinCharPos < mnEndCharPos) 2714 && (rVisualItem.mnEndCharPos > mnMinCharPos) ) 2715 { 2716 long nItemWidth = 0; 2717 for( i = rVisualItem.mnMinCharPos; i < rVisualItem.mnEndCharPos; ++i ) 2718 nItemWidth += mpCharWidths[ i ]; 2719 nItemWidth = (int)((fStretch - 1.0) * nItemWidth + 0.5); 2720 2721 HRESULT nRC = (*pScriptJustify) ( 2722 mpVisualAttrs + rVisualItem.mnMinGlyphPos, 2723 mpGlyphAdvances + rVisualItem.mnMinGlyphPos, 2724 rVisualItem.mnEndGlyphPos - rVisualItem.mnMinGlyphPos, 2725 nItemWidth, 2726 mnMinKashidaWidth, 2727 mpJustifications + rVisualItem.mnMinGlyphPos ); 2728 2729 rVisualItem.mnXOffset = nXOffset; 2730 nXOffset += nItemWidth; 2731 } 2732 } 2733 } 2734 2735 // ----------------------------------------------------------------------- 2736 2737 bool UniscribeLayout::IsKashidaPosValid ( int nCharPos ) const 2738 { 2739 // we have to find the visual item first since the mpLogClusters[] 2740 // needed to find the cluster start is relative to to the visual item 2741 int nMinGlyphIndex = -1; 2742 for( int nItem = 0; nItem < mnItemCount; ++nItem ) 2743 { 2744 const VisualItem& rVisualItem = mpVisualItems[ nItem ]; 2745 if( (nCharPos >= rVisualItem.mnMinCharPos) 2746 && (nCharPos < rVisualItem.mnEndCharPos) ) 2747 { 2748 nMinGlyphIndex = rVisualItem.mnMinGlyphPos; 2749 break; 2750 } 2751 } 2752 // Invalid char pos or leftmost glyph in visual item 2753 if ( nMinGlyphIndex == -1 || !mpLogClusters[ nCharPos ] ) 2754 return false; 2755 2756 // This test didn't give the expected results 2757 /* if( mpLogClusters[ nCharPos+1 ] == mpLogClusters[ nCharPos ]) 2758 // two chars, one glyph 2759 return false;*/ 2760 2761 const int nGlyphPos = mpLogClusters[ nCharPos ] + nMinGlyphIndex; 2762 if( nGlyphPos <= 0 ) 2763 return true; 2764 // justification is only allowed if the glyph to the left has not SCRIPT_JUSTIFY_NONE 2765 // and not SCRIPT_JUSTIFY_ARABIC_BLANK 2766 // special case: glyph to the left is vowel (no advance width) 2767 if ( mpVisualAttrs[ nGlyphPos-1 ].uJustification == SCRIPT_JUSTIFY_ARABIC_BLANK 2768 || ( mpVisualAttrs[ nGlyphPos-1 ].uJustification == SCRIPT_JUSTIFY_NONE 2769 && mpGlyphAdvances [ nGlyphPos-1 ] )) 2770 return false; 2771 return true; 2772 } 2773 2774 #endif // USE_UNISCRIBE 2775 2776 #ifdef ENABLE_GRAPHITE 2777 2778 class GraphiteLayoutWinImpl : public GraphiteLayout 2779 { 2780 public: 2781 GraphiteLayoutWinImpl(const gr::Font & font, ImplWinFontEntry & rFont) 2782 throw() 2783 : GraphiteLayout(font), mrFont(rFont) {}; 2784 virtual ~GraphiteLayoutWinImpl() throw() {}; 2785 virtual sal_GlyphId getKashidaGlyph(int & rWidth); 2786 private: 2787 ImplWinFontEntry & mrFont; 2788 }; 2789 2790 sal_GlyphId GraphiteLayoutWinImpl::getKashidaGlyph(int & rWidth) 2791 { 2792 rWidth = mrFont.GetMinKashidaWidth(); 2793 return mrFont.GetMinKashidaGlyph(); 2794 } 2795 2796 // This class uses the SIL Graphite engine to provide complex text layout services to the VCL 2797 // @author tse 2798 // 2799 class GraphiteWinLayout : public WinLayout 2800 { 2801 private: 2802 mutable GraphiteWinFont mpFont; 2803 grutils::GrFeatureParser * mpFeatures; 2804 mutable GraphiteLayoutWinImpl maImpl; 2805 public: 2806 GraphiteWinLayout(HDC hDC, const ImplWinFontData& rWFD, ImplWinFontEntry& rWFE); 2807 2808 static bool IsGraphiteEnabledFont(HDC hDC) throw(); 2809 2810 // used by upper layers 2811 virtual bool LayoutText( ImplLayoutArgs& ); // first step of layout 2812 virtual void AdjustLayout( ImplLayoutArgs& ); // adjusting after fallback etc. 2813 // virtual void InitFont() const; 2814 virtual void DrawText( SalGraphics& ) const; 2815 2816 // methods using string indexing 2817 virtual int GetTextBreak( long nMaxWidth, long nCharExtra=0, int nFactor=1 ) const; 2818 virtual long FillDXArray( long* pDXArray ) const; 2819 2820 virtual void GetCaretPositions( int nArraySize, long* pCaretXArray ) const; 2821 2822 // methods using glyph indexing 2823 virtual int GetNextGlyphs(int nLen, sal_GlyphId* pGlyphIdxAry, ::Point & rPos, int&, 2824 long* pGlyphAdvAry = 0, int* pCharPosAry = 0 ) const; 2825 2826 // used by glyph+font+script fallback 2827 virtual void MoveGlyph( int nStart, long nNewXPos ); 2828 virtual void DropGlyph( int nStart ); 2829 virtual void Simplify( bool bIsBase ); 2830 ~GraphiteWinLayout() { delete mpFeatures; mpFeatures = NULL; }; 2831 protected: 2832 virtual void ReplaceDC(gr::Segment & segment) const; 2833 virtual void RestoreDC(gr::Segment & segment) const; 2834 }; 2835 2836 bool GraphiteWinLayout::IsGraphiteEnabledFont(HDC hDC) throw() 2837 { 2838 return gr::WinFont::FontHasGraphiteTables(hDC); 2839 } 2840 2841 GraphiteWinLayout::GraphiteWinLayout(HDC hDC, const ImplWinFontData& rWFD, ImplWinFontEntry& rWFE) throw() 2842 : WinLayout(hDC, rWFD, rWFE), mpFont(hDC), 2843 maImpl(mpFont, rWFE) 2844 { 2845 const rtl::OString aLang = MsLangId::convertLanguageToIsoByteString( rWFE.maFontSelData.meLanguage ); 2846 rtl::OString name = rtl::OUStringToOString( 2847 rWFE.maFontSelData.maTargetName, RTL_TEXTENCODING_UTF8 ); 2848 sal_Int32 nFeat = name.indexOf(grutils::GrFeatureParser::FEAT_PREFIX) + 1; 2849 if (nFeat > 0) 2850 { 2851 rtl::OString aFeat = name.copy(nFeat, name.getLength() - nFeat); 2852 mpFeatures = new grutils::GrFeatureParser(mpFont, aFeat.getStr(), aLang.getStr()); 2853 } 2854 else 2855 { 2856 mpFeatures = new grutils::GrFeatureParser(mpFont, aLang.getStr()); 2857 } 2858 maImpl.SetFeatures(mpFeatures); 2859 } 2860 2861 void GraphiteWinLayout::ReplaceDC(gr::Segment & segment) const 2862 { 2863 COLORREF color = GetTextColor(mhDC); 2864 dynamic_cast<gr::WinFont&>(segment.getFont()).replaceDC(mhDC); 2865 SetTextColor(mhDC, color); 2866 } 2867 2868 void GraphiteWinLayout::RestoreDC(gr::Segment & segment) const 2869 { 2870 dynamic_cast<gr::WinFont&>(segment.getFont()).restoreDC(); 2871 } 2872 2873 bool GraphiteWinLayout::LayoutText( ImplLayoutArgs & args) 2874 { 2875 if (args.mnMinCharPos >= args.mnEndCharPos) 2876 { 2877 maImpl.clear(); 2878 return true; 2879 } 2880 HFONT hUnRotatedFont; 2881 if (args.mnOrientation) 2882 { 2883 // Graphite gets very confused if the font is rotated 2884 LOGFONTW aLogFont; 2885 ::GetObjectW( mhFont, sizeof(LOGFONTW), &aLogFont); 2886 aLogFont.lfEscapement = 0; 2887 aLogFont.lfOrientation = 0; 2888 hUnRotatedFont = ::CreateFontIndirectW( &aLogFont); 2889 ::SelectFont(mhDC, hUnRotatedFont); 2890 } 2891 WinLayout::AdjustLayout(args); 2892 mpFont.replaceDC(mhDC); 2893 maImpl.SetFontScale(WinLayout::mfFontScale); 2894 //bool succeeded = maImpl.LayoutText(args); 2895 #ifdef GRCACHE 2896 GrSegRecord * pSegRecord = NULL; 2897 gr::Segment * pSegment = maImpl.CreateSegment(args, &pSegRecord); 2898 #else 2899 gr::Segment * pSegment = maImpl.CreateSegment(args); 2900 #endif 2901 bool bSucceeded = false; 2902 if (pSegment) 2903 { 2904 // replace the DC on the font within the segment 2905 ReplaceDC(*pSegment); 2906 // create glyph vectors 2907 #ifdef GRCACHE 2908 bSucceeded = maImpl.LayoutGlyphs(args, pSegment, pSegRecord); 2909 #else 2910 bSucceeded = maImpl.LayoutGlyphs(args, pSegment); 2911 #endif 2912 // restore original DC 2913 RestoreDC(*pSegment); 2914 #ifdef GRCACHE 2915 if (pSegRecord) pSegRecord->unlock(); 2916 else delete pSegment; 2917 #else 2918 delete pSegment; 2919 #endif 2920 } 2921 mpFont.restoreDC(); 2922 if (args.mnOrientation) 2923 { 2924 // restore the rotated font 2925 ::SelectFont(mhDC, mhFont); 2926 ::DeleteObject(hUnRotatedFont); 2927 } 2928 return bSucceeded; 2929 } 2930 2931 void GraphiteWinLayout::AdjustLayout(ImplLayoutArgs& rArgs) 2932 { 2933 WinLayout::AdjustLayout(rArgs); 2934 maImpl.DrawBase() = WinLayout::maDrawBase; 2935 maImpl.DrawOffset() = WinLayout::maDrawOffset; 2936 if ( (rArgs.mnFlags & SAL_LAYOUT_BIDI_RTL) && rArgs.mpDXArray) 2937 { 2938 mrWinFontEntry.InitKashidaHandling(mhDC); 2939 } 2940 maImpl.AdjustLayout(rArgs); 2941 } 2942 2943 void GraphiteWinLayout::DrawText(SalGraphics &sal_graphics) const 2944 { 2945 HFONT hOrigFont = DisableFontScaling(); 2946 HDC aHDC = static_cast<WinSalGraphics&>(sal_graphics).mhDC; 2947 maImpl.DrawBase() = WinLayout::maDrawBase; 2948 maImpl.DrawOffset() = WinLayout::maDrawOffset; 2949 const int MAX_GLYPHS = 2; 2950 sal_GlyphId glyphIntStr[MAX_GLYPHS]; 2951 WORD glyphWStr[MAX_GLYPHS]; 2952 int glyphIndex = 0; 2953 Point aPos(0,0); 2954 int nGlyphs = 0; 2955 do 2956 { 2957 nGlyphs = maImpl.GetNextGlyphs(1, glyphIntStr, aPos, glyphIndex); 2958 if (nGlyphs < 1) 2959 break; 2960 std::copy(glyphIntStr, glyphIntStr + nGlyphs, glyphWStr); 2961 ::ExtTextOutW(aHDC, aPos.X(), aPos.Y(), ETO_GLYPH_INDEX, 2962 NULL, (LPCWSTR)&(glyphWStr), nGlyphs, NULL); 2963 } while (nGlyphs); 2964 if( hOrigFont ) 2965 DeleteFont( SelectFont( mhDC, hOrigFont ) ); 2966 } 2967 2968 int GraphiteWinLayout::GetTextBreak( long nMaxWidth, long nCharExtra, int nFactor ) const 2969 { 2970 mpFont.replaceDC(mhDC); 2971 int nBreak = maImpl.GetTextBreak(nMaxWidth, nCharExtra, nFactor); 2972 mpFont.restoreDC(); 2973 return nBreak; 2974 } 2975 2976 long GraphiteWinLayout::FillDXArray( long* pDXArray ) const 2977 { 2978 return maImpl.FillDXArray(pDXArray); 2979 } 2980 2981 void GraphiteWinLayout::GetCaretPositions( int nArraySize, long* pCaretXArray ) const 2982 { 2983 maImpl.GetCaretPositions(nArraySize, pCaretXArray); 2984 } 2985 2986 int GraphiteWinLayout::GetNextGlyphs( int length, sal_GlyphId* glyph_out, 2987 ::Point & pos_out, int &glyph_slot, long * glyph_adv, int *char_index) const 2988 { 2989 maImpl.DrawBase() = WinLayout::maDrawBase; 2990 maImpl.DrawOffset() = WinLayout::maDrawOffset; 2991 return maImpl.GetNextGlyphs(length, glyph_out, pos_out, glyph_slot, glyph_adv, char_index); 2992 } 2993 2994 void GraphiteWinLayout::MoveGlyph( int glyph_idx, long new_x_pos ) 2995 { 2996 maImpl.MoveGlyph(glyph_idx, new_x_pos); 2997 } 2998 2999 void GraphiteWinLayout::DropGlyph( int glyph_idx ) 3000 { 3001 maImpl.DropGlyph(glyph_idx); 3002 } 3003 3004 void GraphiteWinLayout::Simplify( bool is_base ) 3005 { 3006 maImpl.Simplify(is_base); 3007 } 3008 #endif // ENABLE_GRAPHITE 3009 // ======================================================================= 3010 3011 SalLayout* WinSalGraphics::GetTextLayout( ImplLayoutArgs& rArgs, int nFallbackLevel ) 3012 { 3013 DBG_ASSERT( mpWinFontEntry[nFallbackLevel], "WinSalGraphics mpWinFontEntry==NULL"); 3014 3015 WinLayout* pWinLayout = NULL; 3016 3017 const ImplWinFontData& rFontFace = *mpWinFontData[ nFallbackLevel ]; 3018 ImplWinFontEntry& rFontInstance = *mpWinFontEntry[ nFallbackLevel ]; 3019 3020 #if defined( USE_UNISCRIBE ) 3021 if( !(rArgs.mnFlags & SAL_LAYOUT_COMPLEX_DISABLED) 3022 && (aUspModule || (bUspEnabled && InitUSP())) ) // CTL layout engine 3023 { 3024 #ifdef ENABLE_GRAPHITE 3025 if (rFontFace.SupportsGraphite()) 3026 pWinLayout = new GraphiteWinLayout(mhDC, rFontFace, rFontInstance); 3027 else 3028 #endif // ENABLE_GRAPHITE 3029 // script complexity is determined in upper layers 3030 pWinLayout = new UniscribeLayout( mhDC, rFontFace, rFontInstance ); 3031 // NOTE: it must be guaranteed that the WinSalGraphics lives longer than 3032 // the created UniscribeLayout, otherwise the data passed into the 3033 // constructor might become invalid too early 3034 } 3035 else 3036 #endif // USE_UNISCRIBE 3037 { 3038 #ifdef GCP_KERN_HACK 3039 if( (rArgs.mnFlags & SAL_LAYOUT_KERNING_PAIRS) && !rFontInstance.HasKernData() ) 3040 { 3041 // TODO: directly cache kerning info in the rFontInstance 3042 // TODO: get rid of kerning methods+data in WinSalGraphics object 3043 GetKernPairs( 0, NULL ); 3044 rFontInstance.SetKernData( mnFontKernPairCount, mpFontKernPairs ); 3045 } 3046 #endif // GCP_KERN_HACK 3047 3048 BYTE eCharSet = ANSI_CHARSET; 3049 if( mpLogFont ) 3050 eCharSet = mpLogFont->lfCharSet; 3051 #ifdef ENABLE_GRAPHITE 3052 if (rFontFace.SupportsGraphite()) 3053 pWinLayout = new GraphiteWinLayout(mhDC, rFontFace, rFontInstance); 3054 else 3055 #endif // ENABLE_GRAPHITE 3056 pWinLayout = new SimpleWinLayout( mhDC, eCharSet, rFontFace, rFontInstance ); 3057 } 3058 3059 if( mfFontScale != 1.0 ) 3060 pWinLayout->SetFontScale( mfFontScale ); 3061 3062 return pWinLayout; 3063 } 3064 3065 // ----------------------------------------------------------------------- 3066 3067 int WinSalGraphics::GetMinKashidaWidth() 3068 { 3069 if( !mpWinFontEntry[0] ) 3070 return 0; 3071 mpWinFontEntry[0]->InitKashidaHandling( mhDC ); 3072 int nMinKashida = static_cast<int>(mfFontScale * mpWinFontEntry[0]->GetMinKashidaWidth()); 3073 return nMinKashida; 3074 } 3075 3076 // ======================================================================= 3077 3078 ImplWinFontEntry::ImplWinFontEntry( ImplFontSelectData& rFSD ) 3079 : ImplFontEntry( rFSD ) 3080 , maWidthMap( 512 ) 3081 , mpKerningPairs( NULL ) 3082 , mnKerningPairs( -1 ) 3083 , mnMinKashidaWidth( -1 ) 3084 , mnMinKashidaGlyph( -1 ) 3085 { 3086 #ifdef USE_UNISCRIBE 3087 maScriptCache = NULL; 3088 #endif // USE_UNISCRIBE 3089 } 3090 3091 // ----------------------------------------------------------------------- 3092 3093 ImplWinFontEntry::~ImplWinFontEntry() 3094 { 3095 #ifdef USE_UNISCRIBE 3096 if( maScriptCache != NULL ) 3097 (*pScriptFreeCache)( &maScriptCache ); 3098 #endif // USE_UNISCRIBE 3099 #ifdef GCP_KERN_HACK 3100 delete[] mpKerningPairs; 3101 #endif // GCP_KERN_HACK 3102 } 3103 3104 // ----------------------------------------------------------------------- 3105 3106 bool ImplWinFontEntry::HasKernData() const 3107 { 3108 return (mnKerningPairs >= 0); 3109 } 3110 3111 // ----------------------------------------------------------------------- 3112 3113 void ImplWinFontEntry::SetKernData( int nPairCount, const KERNINGPAIR* pPairData ) 3114 { 3115 mnKerningPairs = nPairCount; 3116 mpKerningPairs = new KERNINGPAIR[ mnKerningPairs ]; 3117 ::memcpy( mpKerningPairs, (const void*)pPairData, nPairCount*sizeof(KERNINGPAIR) ); 3118 } 3119 3120 // ----------------------------------------------------------------------- 3121 3122 int ImplWinFontEntry::GetKerning( sal_Unicode cLeft, sal_Unicode cRight ) const 3123 { 3124 int nKernAmount = 0; 3125 if( mpKerningPairs ) 3126 { 3127 const KERNINGPAIR aRefPair = { cLeft, cRight, 0 }; 3128 const KERNINGPAIR* pFirstPair = mpKerningPairs; 3129 const KERNINGPAIR* pEndPair = mpKerningPairs + mnKerningPairs; 3130 const KERNINGPAIR* pPair = std::lower_bound( pFirstPair, 3131 pEndPair, aRefPair, ImplCmpKernData ); 3132 if( (pPair != pEndPair) 3133 && (pPair->wFirst == aRefPair.wFirst) 3134 && (pPair->wSecond == aRefPair.wSecond) ) 3135 nKernAmount = pPair->iKernAmount; 3136 } 3137 3138 return nKernAmount; 3139 } 3140 3141 // ----------------------------------------------------------------------- 3142 3143 bool ImplWinFontEntry::InitKashidaHandling( HDC hDC ) 3144 { 3145 if( mnMinKashidaWidth >= 0 ) // already cached? 3146 return mnMinKashidaWidth; 3147 3148 // initialize the kashida width 3149 mnMinKashidaWidth = 0; 3150 mnMinKashidaGlyph = 0; 3151 #ifdef USE_UNISCRIBE 3152 if (aUspModule || (bUspEnabled && InitUSP())) 3153 { 3154 SCRIPT_FONTPROPERTIES aFontProperties; 3155 aFontProperties.cBytes = sizeof (aFontProperties); 3156 SCRIPT_CACHE& rScriptCache = GetScriptCache(); 3157 HRESULT nRC = (*pScriptGetFontProperties)( hDC, &rScriptCache, &aFontProperties ); 3158 if( nRC != 0 ) 3159 return false; 3160 mnMinKashidaWidth = aFontProperties.iKashidaWidth; 3161 mnMinKashidaGlyph = aFontProperties.wgKashida; 3162 } 3163 #endif // USE_UNISCRIBE 3164 3165 return true; 3166 } 3167 3168 // ======================================================================= 3169 3170 ImplFontData* ImplWinFontData::Clone() const 3171 { 3172 if( mpUnicodeMap ) 3173 mpUnicodeMap->AddReference(); 3174 ImplFontData* pClone = new ImplWinFontData( *this ); 3175 return pClone; 3176 } 3177 3178 // ----------------------------------------------------------------------- 3179 3180 ImplFontEntry* ImplWinFontData::CreateFontInstance( ImplFontSelectData& rFSD ) const 3181 { 3182 ImplFontEntry* pEntry = new ImplWinFontEntry( rFSD ); 3183 return pEntry; 3184 } 3185 3186 // ======================================================================= 3187