LCOV - code coverage report
Current view: top level - starmath/source - rect.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 287 329 87.2 %
Date: 2015-06-13 12:38:46 Functions: 21 25 84.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <osl/diagnose.h>
      21             : #include <vcl/svapp.hxx>
      22             : #include <vcl/wrkwin.hxx>
      23             : #include <vcl/virdev.hxx>
      24             : 
      25             : 
      26             : #include "rect.hxx"
      27             : #include "types.hxx"
      28             : #include "utility.hxx"
      29             : #include "smmod.hxx"
      30             : 
      31             : 
      32             : 
      33             : 
      34             : 
      35             : // '\0' terminated Array with symbol, which should be treat as letters in
      36             : // StarMath Font, (to get a normal (non-clipped) SmRect in contrast to the
      37             : // other operators and symbols).
      38             : static sal_Unicode const aMathAlpha[] =
      39             : {
      40             :     MS_ALEPH,               MS_IM,                  MS_RE,
      41             :     MS_WP,                  sal_Unicode(0xE070),    MS_EMPTYSET,
      42             :     sal_Unicode(0x2113),    sal_Unicode(0xE0D6),    sal_Unicode(0x2107),
      43             :     sal_Unicode(0x2127),    sal_Unicode(0x210A),    MS_HBAR,
      44             :     MS_LAMBDABAR,           MS_SETN,                MS_SETZ,
      45             :     MS_SETQ,                MS_SETR,                MS_SETC,
      46             :     sal_Unicode(0x2373),    sal_Unicode(0xE0A5),    sal_Unicode(0x2112),
      47             :     sal_Unicode(0x2130),    sal_Unicode(0x2131),
      48             :     sal_Unicode('\0')
      49             : };
      50             : 
      51        4347 : bool SmIsMathAlpha(const OUString &rText)
      52             :     // true iff symbol (from StarMath Font) should be treated as letter
      53             : {
      54        4347 :     if (rText.isEmpty())
      55          15 :         return false;
      56             : 
      57             :     OSL_ENSURE(rText.getLength() == 1, "Sm : string must be exactly one character long");
      58        4332 :     sal_Unicode cChar = rText[0];
      59             : 
      60             :     // is it a greek symbol?
      61        4332 :     if (sal_Unicode(0xE0AC) <= cChar  &&  cChar <= sal_Unicode(0xE0D4))
      62           0 :         return true;
      63             :     else
      64             :     {
      65             :         // appears it in 'aMathAlpha'?
      66        4332 :         const sal_Unicode *pChar = aMathAlpha;
      67      108300 :         while (*pChar  &&  *pChar != cChar)
      68       99636 :             pChar++;
      69        4332 :         return *pChar != '\0';
      70             :     }
      71             : }
      72             : 
      73             : 
      74             : 
      75             : 
      76             : // SmRect members
      77             : 
      78             : 
      79             : 
      80       15862 : SmRect::SmRect()
      81             :     // constructs empty rectangle at (0, 0) with width and height 0.
      82             : {
      83             :     OSL_ENSURE(aTopLeft == Point(0, 0), "Sm: ooops...");
      84             :     OSL_ENSURE(aSize == Size(0, 0), "Sm: ooops...");
      85             : 
      86       15862 :     bHasBaseline = bHasAlignInfo = false;
      87             :     nBaseline = nAlignT = nAlignM = nAlignB =
      88             :     nGlyphTop = nGlyphBottom =
      89             :     nItalicLeftSpace = nItalicRightSpace =
      90       15862 :     nLoAttrFence = nHiAttrFence = 0;
      91       15862 :     nBorderWidth = 0;
      92       15862 : }
      93             : 
      94             : 
      95       16312 : SmRect::SmRect(const SmRect &rRect)
      96             : :   aTopLeft(rRect.aTopLeft),
      97       16312 :     aSize(rRect.aSize)
      98             : {
      99       16312 :     bHasBaseline  = rRect.bHasBaseline;
     100       16312 :     nBaseline     = rRect.nBaseline;
     101       16312 :     nAlignT       = rRect.nAlignT;
     102       16312 :     nAlignM       = rRect.nAlignM;
     103       16312 :     nAlignB       = rRect.nAlignB;
     104       16312 :     nGlyphTop     = rRect.nGlyphTop;
     105       16312 :     nGlyphBottom  = rRect.nGlyphBottom;
     106       16312 :     nHiAttrFence  = rRect.nHiAttrFence;
     107       16312 :     nLoAttrFence  = rRect.nLoAttrFence;
     108       16312 :     bHasAlignInfo = rRect.bHasAlignInfo;
     109       16312 :     nItalicLeftSpace  = rRect.nItalicLeftSpace;
     110       16312 :     nItalicRightSpace = rRect.nItalicRightSpace;
     111       16312 :     nBorderWidth  = rRect.nBorderWidth;
     112       16312 : }
     113             : 
     114             : 
     115         104 : void SmRect::CopyAlignInfo(const SmRect &rRect)
     116             : {
     117         104 :     nBaseline     = rRect.nBaseline;
     118         104 :     bHasBaseline  = rRect.bHasBaseline;
     119         104 :     nAlignT       = rRect.nAlignT;
     120         104 :     nAlignM       = rRect.nAlignM;
     121         104 :     nAlignB       = rRect.nAlignB;
     122         104 :     bHasAlignInfo = rRect.bHasAlignInfo;
     123         104 :     nLoAttrFence  = rRect.nLoAttrFence;
     124         104 :     nHiAttrFence  = rRect.nHiAttrFence;
     125         104 : }
     126             : 
     127             : 
     128        8838 : void SmRect::BuildRect(const OutputDevice &rDev, const SmFormat *pFormat,
     129             :                        const OUString &rText, sal_uInt16 nBorder)
     130             : {
     131             :     OSL_ENSURE(aTopLeft == Point(0, 0), "Sm: Ooops...");
     132             : 
     133        8838 :     aSize = Size(rDev.GetTextWidth(rText), rDev.GetTextHeight());
     134             : 
     135        8838 :     const FontMetric  aFM (rDev.GetFontMetric());
     136        8838 :     bool              bIsMath  = aFM.GetName().equalsIgnoreAsciiCase( FONTNAME_MATH );
     137        8838 :     bool              bAllowSmaller = bIsMath && !SmIsMathAlpha(rText);
     138        8838 :     const long        nFontHeight = rDev.GetFont().GetSize().Height();
     139             : 
     140        8838 :     nBorderWidth  = nBorder;
     141        8838 :     bHasAlignInfo = true;
     142        8838 :     bHasBaseline  = true;
     143        8838 :     nBaseline     = aFM.GetAscent();
     144        8838 :     nAlignT       = nBaseline - nFontHeight * 750L / 1000L;
     145        8838 :     nAlignM       = nBaseline - nFontHeight * 121L / 422L;
     146             :         // that's where the horizontal bars of '+', '-', ... are
     147             :         // (1/3 of ascent over baseline)
     148             :         // (121 = 1/3 of 12pt ascent, 422 = 12pt fontheight)
     149        8838 :     nAlignB       = nBaseline;
     150             : 
     151             :     // workaround for printer fonts with very small (possible 0 or even
     152             :     // negative(!)) leading
     153        8838 :     if (aFM.GetIntLeading() < 5  &&  rDev.GetOutDevType() == OUTDEV_PRINTER)
     154             :     {
     155           8 :         OutputDevice    *pWindow = Application::GetDefaultDevice();
     156             : 
     157           8 :         pWindow->Push(PushFlags::MAPMODE | PushFlags::FONT);
     158             : 
     159           8 :         pWindow->SetMapMode(rDev.GetMapMode());
     160           8 :         pWindow->SetFont(rDev.GetFontMetric());
     161             : 
     162           8 :         long  nDelta = pWindow->GetFontMetric().GetIntLeading();
     163           8 :         if (nDelta == 0)
     164             :         {   // this value approx. fits a Leading of 80 at a
     165             :             // Fontheight of 422 (12pt)
     166           0 :             nDelta = nFontHeight * 8L / 43;
     167             :         }
     168           8 :         SetTop(GetTop() - nDelta);
     169             : 
     170           8 :         pWindow->Pop();
     171             :     }
     172             : 
     173             :     // get GlyphBoundRect
     174        8838 :     Rectangle  aGlyphRect;
     175        8838 :     bool bSuccess = SmGetGlyphBoundRect(rDev, rText, aGlyphRect);
     176        8838 :     if (!bSuccess)
     177             :         SAL_WARN("starmath", "Ooops... (Font missing?)");
     178             : 
     179        8838 :     nItalicLeftSpace  = GetLeft() - aGlyphRect.Left() + nBorderWidth;
     180        8838 :     nItalicRightSpace = aGlyphRect.Right() - GetRight() + nBorderWidth;
     181        8838 :     if (nItalicLeftSpace  < 0  &&  !bAllowSmaller)
     182         664 :         nItalicLeftSpace  = 0;
     183        8838 :     if (nItalicRightSpace < 0  &&  !bAllowSmaller)
     184         949 :         nItalicRightSpace = 0;
     185             : 
     186        8838 :     long  nDist = 0;
     187        8838 :     if (pFormat)
     188        7744 :         nDist = (rDev.GetFont().GetSize().Height()
     189        7744 :                 * pFormat->GetDistance(DIS_ORNAMENTSIZE)) / 100L;
     190             : 
     191        8838 :     nHiAttrFence = aGlyphRect.TopLeft().Y() - 1 - nBorderWidth - nDist;
     192        8838 :     nLoAttrFence = SmFromTo(GetAlignB(), GetBottom(), 0.0);
     193             : 
     194        8838 :     nGlyphTop    = aGlyphRect.Top() - nBorderWidth;
     195        8838 :     nGlyphBottom = aGlyphRect.Bottom() + nBorderWidth;
     196             : 
     197        8838 :     if (bAllowSmaller)
     198             :     {
     199             :         // for symbols and operators from the StarMath Font
     200             :         // we adjust upper and lower margin of the symbol
     201        4347 :         SetTop(nGlyphTop);
     202        4347 :         SetBottom(nGlyphBottom);
     203             :     }
     204             : 
     205        8838 :     if (nHiAttrFence < GetTop())
     206        4356 :         nHiAttrFence = GetTop();
     207             : 
     208        8838 :     if (nLoAttrFence > GetBottom())
     209        1137 :         nLoAttrFence = GetBottom();
     210             : 
     211             :     OSL_ENSURE(rText.isEmpty() || !IsEmpty(),
     212        8838 :                "Sm: empty rectangle created");
     213        8838 : }
     214             : 
     215             : 
     216        8838 : void SmRect::Init(const OutputDevice &rDev, const SmFormat *pFormat,
     217             :                   const OUString &rText, sal_uInt16 nEBorderWidth)
     218             :     // get rectangle fitting for drawing 'rText' on OutputDevice 'rDev'
     219             : {
     220        8838 :     BuildRect(rDev, pFormat, rText, nEBorderWidth);
     221        8838 : }
     222             : 
     223             : 
     224        8838 : SmRect::SmRect(const OutputDevice &rDev, const SmFormat *pFormat,
     225        8838 :                const OUString &rText, long nEBorderWidth)
     226             : {
     227             :     OSL_ENSURE( nEBorderWidth >= 0, "BorderWidth is negative" );
     228        8838 :     if (nEBorderWidth < 0)
     229           0 :         nEBorderWidth = 0;
     230        8838 :     Init(rDev, pFormat, rText, (sal_uInt16) nEBorderWidth);
     231        8838 : }
     232             : 
     233             : 
     234        1516 : SmRect::SmRect(long nWidth, long nHeight)
     235             :     // this constructor should never be used for anything textlike because
     236             :     // it will not provide useful values for baseline, AlignT and AlignB!
     237             :     // It's purpose is to get a 'SmRect' for the horizontal line in fractions
     238             :     // as used in 'SmBinVerNode'.
     239        1516 : :   aSize(nWidth, nHeight)
     240             : {
     241             :     OSL_ENSURE(aTopLeft == Point(0, 0), "Sm: ooops...");
     242             : 
     243        1516 :     bHasBaseline  = false;
     244        1516 :     bHasAlignInfo = true;
     245        1516 :     nBaseline     = 0;
     246        1516 :     nAlignT       = GetTop();
     247        1516 :     nAlignB       = GetBottom();
     248        1516 :     nAlignM       = (nAlignT + nAlignB) / 2;        // this is the default
     249        1516 :     nItalicLeftSpace = nItalicRightSpace = 0;
     250        1516 :     nGlyphTop    = nHiAttrFence  = GetTop();
     251        1516 :     nGlyphBottom = nLoAttrFence  = GetBottom();
     252        1516 :     nBorderWidth  = 0;
     253        1516 : }
     254             : 
     255             : 
     256        8148 : void SmRect::SetLeft(long nLeft)
     257             : {
     258        8148 :     if (nLeft <= GetRight())
     259        8077 :     {   aSize.Width() = GetRight() - nLeft + 1;
     260        8077 :         aTopLeft.X()  = nLeft;
     261             :     }
     262        8148 : }
     263             : 
     264             : 
     265        8148 : void SmRect::SetRight(long nRight)
     266             : {
     267        8148 :     if (nRight >= GetLeft())
     268        8148 :         aSize.Width() = nRight - GetLeft() + 1;
     269        8148 : }
     270             : 
     271             : 
     272       12634 : void SmRect::SetBottom(long nBottom)
     273             : {
     274       12634 :     if (nBottom >= GetTop())
     275       12619 :         aSize.Height() = nBottom - GetTop() + 1;
     276       12634 : }
     277             : 
     278             : 
     279       12503 : void SmRect::SetTop(long nTop)
     280             : {
     281       12503 :     if (nTop <= GetBottom())
     282       12483 :     {   aSize.Height()   = GetBottom() - nTop + 1;
     283       12483 :         aTopLeft.Y() = nTop;
     284             :     }
     285       12503 : }
     286             : 
     287             : 
     288       31152 : void SmRect::Move(const Point &rPosition)
     289             :     // move rectangle by position 'rPosition'.
     290             : {
     291       31152 :     aTopLeft  += rPosition;
     292             : 
     293       31152 :     long  nDelta = rPosition.Y();
     294       31152 :     nBaseline += nDelta;
     295       31152 :     nAlignT   += nDelta;
     296       31152 :     nAlignM   += nDelta;
     297       31152 :     nAlignB   += nDelta;
     298       31152 :     nGlyphTop    += nDelta;
     299       31152 :     nGlyphBottom += nDelta;
     300       31152 :     nHiAttrFence += nDelta;
     301       31152 :     nLoAttrFence += nDelta;
     302       31152 : }
     303             : 
     304             : 
     305        8260 : const Point SmRect::AlignTo(const SmRect &rRect, RectPos ePos,
     306             :                             RectHorAlign eHor, RectVerAlign eVer) const
     307        8260 : {   Point  aPos (GetTopLeft());
     308             :         // will become the topleft point of the new rectangle position
     309             : 
     310             :     // set horizontal or vertical new rectangle position depending on
     311             :     // 'ePos' is one of 'RP_LEFT', 'RP_RIGHT' or 'RP_TOP', 'RP_BOTTOM'
     312        8260 :     switch (ePos)
     313             :     {   case RP_LEFT :
     314         893 :             aPos.X() = rRect.GetItalicLeft() - GetItalicRightSpace()
     315         893 :                        - GetWidth();
     316         893 :             break;
     317             :         case RP_RIGHT :
     318        4941 :             aPos.X() = rRect.GetItalicRight() + 1 + GetItalicLeftSpace();
     319        4941 :             break;
     320             :         case RP_TOP :
     321         422 :             aPos.Y() = rRect.GetTop() - GetHeight();
     322         422 :             break;
     323             :         case RP_BOTTOM :
     324        1750 :             aPos.Y() = rRect.GetBottom() + 1;
     325        1750 :             break;
     326             :         case RP_ATTRIBUT :
     327         254 :             aPos.X() = rRect.GetItalicCenterX() - GetItalicWidth() / 2
     328         254 :                        + GetItalicLeftSpace();
     329         254 :             break;
     330             :         default :
     331             :             SAL_WARN("starmath", "unknown case");
     332             :     }
     333             : 
     334             :     // check if horizontal position is already set
     335        8260 :     if (ePos == RP_LEFT  ||  ePos == RP_RIGHT  ||  ePos == RP_ATTRIBUT)
     336             :         // correct error in current vertical position
     337        6088 :         switch (eVer)
     338             :         {   case RVA_TOP :
     339         447 :                 aPos.Y() += rRect.GetAlignT() - GetAlignT();
     340         447 :                 break;
     341             :             case RVA_MID :
     342         162 :                 aPos.Y() += rRect.GetAlignM() - GetAlignM();
     343         162 :                 break;
     344             :             case RVA_BASELINE :
     345             :                 // align baselines if possible else align mid's
     346        4063 :                 if (HasBaseline() && rRect.HasBaseline())
     347        3643 :                     aPos.Y() += rRect.GetBaseline() - GetBaseline();
     348             :                 else
     349         420 :                     aPos.Y() += rRect.GetAlignM() - GetAlignM();
     350        4063 :                 break;
     351             :             case RVA_BOTTOM :
     352         236 :                 aPos.Y() += rRect.GetAlignB() - GetAlignB();
     353         236 :                 break;
     354             :             case RVA_CENTERY :
     355         926 :                 aPos.Y() += rRect.GetCenterY() - GetCenterY();
     356         926 :                 break;
     357             :             case RVA_ATTRIBUT_HI:
     358         218 :                 aPos.Y() += rRect.GetHiAttrFence() - GetBottom();
     359         218 :                 break;
     360             :             case RVA_ATTRIBUT_MID :
     361          36 :                 aPos.Y() += SmFromTo(rRect.GetAlignB(), rRect.GetAlignT(), 0.4)
     362          36 :                             - GetCenterY();
     363          18 :                 break;
     364             :             case RVA_ATTRIBUT_LO :
     365          18 :                 aPos.Y() += rRect.GetLoAttrFence() - GetTop();
     366          18 :                 break;
     367             :         default :
     368             :                 SAL_WARN("starmath", "unknown case");
     369             :         }
     370             : 
     371             :     // check if vertical position is already set
     372        8260 :     if (ePos == RP_TOP  ||  ePos == RP_BOTTOM)
     373             :         // correct error in current horizontal position
     374        2172 :         switch (eHor)
     375             :         {   case RHA_LEFT :
     376           0 :                 aPos.X() += rRect.GetItalicLeft() - GetItalicLeft();
     377           0 :                 break;
     378             :             case RHA_CENTER :
     379        2117 :                 aPos.X() += rRect.GetItalicCenterX() - GetItalicCenterX();
     380        2117 :                 break;
     381             :             case RHA_RIGHT :
     382          55 :                 aPos.X() += rRect.GetItalicRight() - GetItalicRight();
     383          55 :                 break;
     384             :             default :
     385             :                 SAL_WARN("starmath", "unknown case");
     386             :         }
     387             : 
     388        8260 :     return aPos;
     389             : }
     390             : 
     391             : 
     392        8235 : SmRect & SmRect::Union(const SmRect &rRect)
     393             :     // rectangle union of current one with 'rRect'. The result is to be the
     394             :     // smallest rectangles that covers the space of both rectangles.
     395             :     // (empty rectangles cover no space)
     396             :     //! Italic correction is NOT taken into account here!
     397             : {
     398        8235 :     if (rRect.IsEmpty())
     399          87 :         return *this;
     400             : 
     401        8148 :     long  nL  = rRect.GetLeft(),
     402        8148 :           nR  = rRect.GetRight(),
     403        8148 :           nT  = rRect.GetTop(),
     404        8148 :           nB  = rRect.GetBottom(),
     405        8148 :           nGT = rRect.nGlyphTop,
     406        8148 :           nGB = rRect.nGlyphBottom;
     407        8148 :     if (!IsEmpty())
     408             :     {   long  nTmp;
     409             : 
     410        8053 :         if ((nTmp = GetLeft()) < nL)
     411        6334 :             nL = nTmp;
     412        8053 :         if ((nTmp = GetRight()) > nR)
     413        2295 :             nR = nTmp;
     414        8053 :         if ((nTmp = GetTop()) < nT)
     415        3874 :             nT = nTmp;
     416        8053 :         if ((nTmp = GetBottom()) > nB)
     417        2595 :             nB = nTmp;
     418        8053 :         if ((nTmp = nGlyphTop) < nGT)
     419        4336 :             nGT = nTmp;
     420        8053 :         if ((nTmp = nGlyphBottom) > nGB)
     421        2881 :             nGB = nTmp;
     422             :     }
     423             : 
     424        8148 :     SetLeft(nL);
     425        8148 :     SetRight(nR);
     426        8148 :     SetTop(nT);
     427        8148 :     SetBottom(nB);
     428        8148 :     nGlyphTop    = nGT;
     429        8148 :     nGlyphBottom = nGB;
     430             : 
     431        8148 :     return *this;
     432             : }
     433             : 
     434             : 
     435        8235 : SmRect & SmRect::ExtendBy(const SmRect &rRect, RectCopyMBL eCopyMode)
     436             :     // let current rectangle be the union of itself and 'rRect'
     437             :     // (the smallest rectangle surrounding both). Also adapt values for
     438             :     // 'AlignT', 'AlignM', 'AlignB', baseline and italic-spaces.
     439             :     // The baseline is set according to 'eCopyMode'.
     440             :     // If one of the rectangles has no relevant info the other one is copied.
     441             : {
     442             :     // get some values used for (italic) spaces adaption
     443             :     // ! (need to be done before changing current SmRect) !
     444        8235 :     long  nL = std::min(GetItalicLeft(),  rRect.GetItalicLeft()),
     445        8235 :           nR = std::max(GetItalicRight(), rRect.GetItalicRight());
     446             : 
     447        8235 :     Union(rRect);
     448             : 
     449        8235 :     SetItalicSpaces(GetLeft() - nL, nR - GetRight());
     450             : 
     451        8235 :     if (!HasAlignInfo())
     452         104 :         CopyAlignInfo(rRect);
     453        8131 :     else if (rRect.HasAlignInfo())
     454        8116 :     {   nAlignT = std::min(GetAlignT(), rRect.GetAlignT());
     455        8116 :         nAlignB = std::max(GetAlignB(), rRect.GetAlignB());
     456        8116 :         nHiAttrFence = std::min(GetHiAttrFence(), rRect.GetHiAttrFence());
     457        8116 :         nLoAttrFence = std::max(GetLoAttrFence(), rRect.GetLoAttrFence());
     458             :         OSL_ENSURE(HasAlignInfo(), "Sm: ooops...");
     459             : 
     460        8116 :         switch (eCopyMode)
     461             :         {   case RCP_THIS:
     462             :                 // already done
     463        2454 :                 break;
     464             :             case RCP_ARG:
     465        1082 :                 CopyMBL(rRect);
     466        1082 :                 break;
     467             :             case RCP_NONE:
     468         757 :                 ClearBaseline();
     469         757 :                 nAlignM = (nAlignT + nAlignB) / 2;
     470         757 :                 break;
     471             :             case RCP_XOR:
     472        3823 :                 if (!HasBaseline())
     473         156 :                     CopyMBL(rRect);
     474        3823 :                 break;
     475             :             default :
     476             :                 SAL_WARN("starmath", "unknown case");
     477             :         }
     478             :     }
     479             : 
     480        8235 :     return *this;
     481             : }
     482             : 
     483             : 
     484         273 : SmRect & SmRect::ExtendBy(const SmRect &rRect, RectCopyMBL eCopyMode,
     485             :                           long nNewAlignM)
     486             :     // as 'ExtendBy' but sets AlignM value to 'nNewAlignM'.
     487             :     // (this version will be used in 'SmBinVerNode' to provide means to
     488             :     // align eg "{a over b} over c" correctly where AlignM should not
     489             :     // be (AlignT + AlignB) / 2)
     490             : {
     491             :     OSL_ENSURE(HasAlignInfo(), "Sm: no align info");
     492             : 
     493         273 :     ExtendBy(rRect, eCopyMode);
     494         273 :     nAlignM = nNewAlignM;
     495             : 
     496         273 :     return *this;
     497             : }
     498             : 
     499             : 
     500        1261 : SmRect & SmRect::ExtendBy(const SmRect &rRect, RectCopyMBL eCopyMode,
     501             :                           bool bKeepVerAlignParams)
     502             :     // as 'ExtendBy' but keeps original values for AlignT, -M and -B and
     503             :     // baseline.
     504             :     // (this is used in 'SmSupSubNode' where the sub-/supscripts shouldn't
     505             :     // be allowed to modify these values.)
     506             : {
     507        1261 :     long  nOldAlignT   = GetAlignT(),
     508        1261 :           nOldAlignM   = GetAlignM(),
     509        1261 :           nOldAlignB   = GetAlignB(),
     510        1261 :           nOldBaseline = nBaseline;     //! depends not on 'HasBaseline'
     511        1261 :     bool  bOldHasAlignInfo = HasAlignInfo();
     512             : 
     513        1261 :     ExtendBy(rRect, eCopyMode);
     514             : 
     515        1261 :     if (bKeepVerAlignParams)
     516        1261 :     {   nAlignT   = nOldAlignT;
     517        1261 :         nAlignM   = nOldAlignM;
     518        1261 :         nAlignB   = nOldAlignB;
     519        1261 :         nBaseline = nOldBaseline;
     520        1261 :         bHasAlignInfo = bOldHasAlignInfo;
     521             :     }
     522             : 
     523        1261 :     return *this;
     524             : }
     525             : 
     526             : 
     527           0 : long SmRect::OrientedDist(const Point &rPoint) const
     528             :     // return oriented distance of rPoint to the current rectangle,
     529             :     // especially the return value is <= 0 iff the point is inside the
     530             :     // rectangle.
     531             :     // For simplicity the maximum-norm is used.
     532             : {
     533           0 :     bool  bIsInside = IsInsideItalicRect(rPoint);
     534             : 
     535             :     // build reference point to define the distance
     536           0 :     Point  aRef;
     537           0 :     if (bIsInside)
     538           0 :     {   Point  aIC (GetItalicCenterX(), GetCenterY());
     539             : 
     540           0 :         aRef.X() = rPoint.X() >= aIC.X() ? GetItalicRight() : GetItalicLeft();
     541           0 :         aRef.Y() = rPoint.Y() >= aIC.Y() ? GetBottom() : GetTop();
     542             :     }
     543             :     else
     544             :     {
     545             :         // x-coordinate
     546           0 :         if (rPoint.X() > GetItalicRight())
     547           0 :             aRef.X() = GetItalicRight();
     548           0 :         else if (rPoint.X() < GetItalicLeft())
     549           0 :             aRef.X() = GetItalicLeft();
     550             :         else
     551           0 :             aRef.X() = rPoint.X();
     552             :         // y-coordinate
     553           0 :         if (rPoint.Y() > GetBottom())
     554           0 :             aRef.Y() = GetBottom();
     555           0 :         else if (rPoint.Y() < GetTop())
     556           0 :             aRef.Y() = GetTop();
     557             :         else
     558           0 :             aRef.Y() = rPoint.Y();
     559             :     }
     560             : 
     561             :     // build distance vector
     562           0 :     Point  aDist (aRef - rPoint);
     563             : 
     564           0 :     long nAbsX = labs(aDist.X()),
     565           0 :          nAbsY = labs(aDist.Y());
     566             : 
     567           0 :     return bIsInside ? - std::min(nAbsX, nAbsY) : std::max (nAbsX, nAbsY);
     568             : }
     569             : 
     570             : 
     571           0 : bool SmRect::IsInsideRect(const Point &rPoint) const
     572             : {
     573           0 :     return     rPoint.Y() >= GetTop()
     574           0 :            &&  rPoint.Y() <= GetBottom()
     575           0 :            &&  rPoint.X() >= GetLeft()
     576           0 :            &&  rPoint.X() <= GetRight();
     577             : }
     578             : 
     579             : 
     580           0 : bool SmRect::IsInsideItalicRect(const Point &rPoint) const
     581             : {
     582           0 :     return     rPoint.Y() >= GetTop()
     583           0 :            &&  rPoint.Y() <= GetBottom()
     584           0 :            &&  rPoint.X() >= GetItalicLeft()
     585           0 :            &&  rPoint.X() <= GetItalicRight();
     586             : }
     587             : 
     588           0 : SmRect SmRect::AsGlyphRect() const
     589             : {
     590           0 :     SmRect aRect (*this);
     591           0 :     aRect.SetTop(nGlyphTop);
     592           0 :     aRect.SetBottom(nGlyphBottom);
     593           0 :     return aRect;
     594             : }
     595             : 
     596        8838 : bool SmGetGlyphBoundRect(const vcl::RenderContext &rDev,
     597             :                          const OUString &rText, Rectangle &rRect)
     598             :     // basically the same as 'GetTextBoundRect' (in class 'OutputDevice')
     599             :     // but with a string as argument.
     600             : {
     601             :     // handle special case first
     602        8838 :     if (rText.isEmpty())
     603             :     {
     604          24 :         rRect.SetEmpty();
     605          24 :         return true;
     606             :     }
     607             : 
     608             :     // get a device where 'OutputDevice::GetTextBoundRect' will be successful
     609             :     OutputDevice *pGlyphDev;
     610        8814 :     if (rDev.GetOutDevType() != OUTDEV_PRINTER)
     611        8724 :         pGlyphDev = const_cast<OutputDevice *>(&rDev);
     612             :     else
     613             :     {
     614             :         // since we format for the printer (where GetTextBoundRect will fail)
     615             :         // we need a virtual device here.
     616          90 :         pGlyphDev = &SM_MOD()->GetDefaultVirtualDev();
     617             :     }
     618             : 
     619        8814 :     const FontMetric  aDevFM (rDev.GetFontMetric());
     620             : 
     621        8814 :     pGlyphDev->Push(PushFlags::FONT | PushFlags::MAPMODE);
     622       17628 :     vcl::Font aFnt(rDev.GetFont());
     623        8814 :     aFnt.SetAlign(ALIGN_TOP);
     624             : 
     625             :     // use scale factor when calling GetTextBoundRect to counter
     626             :     // negative effects from antialiasing which may otherwise result
     627             :     // in significant incorrect bounding rectangles for some characters.
     628        8814 :     Size aFntSize = aFnt.GetSize();
     629             : 
     630             :     // Workaround to avoid HUGE font sizes and resulting problems
     631        8814 :     long nScaleFactor = 1;
     632       17628 :     while( aFntSize.Height() > 2000 * nScaleFactor )
     633           0 :         nScaleFactor *= 2;
     634             : 
     635        8814 :     aFnt.SetSize( Size( aFntSize.Width() / nScaleFactor, aFntSize.Height() / nScaleFactor ) );
     636        8814 :     pGlyphDev->SetFont(aFnt);
     637             : 
     638        8814 :     long nTextWidth = rDev.GetTextWidth(rText);
     639        8814 :     Point aPoint;
     640        8814 :     Rectangle   aResult (aPoint, Size(nTextWidth, rDev.GetTextHeight())),
     641        8814 :                 aTmp;
     642             : 
     643        8814 :     bool bSuccess = pGlyphDev->GetTextBoundRect(aTmp, rText, 0, 0);
     644             :     OSL_ENSURE( bSuccess, "GetTextBoundRect failed" );
     645             : 
     646             : 
     647        8814 :     if (!aTmp.IsEmpty())
     648             :     {
     649       17628 :         aResult = Rectangle(aTmp.Left() * nScaleFactor, aTmp.Top() * nScaleFactor,
     650       26442 :                             aTmp.Right() * nScaleFactor, aTmp.Bottom() * nScaleFactor);
     651        8814 :         if (&rDev != pGlyphDev) /* only when rDev is a printer... */
     652             :         {
     653          90 :             long nGDTextWidth  = pGlyphDev->GetTextWidth(rText);
     654          90 :             if (nGDTextWidth != 0  &&
     655             :                 nTextWidth != nGDTextWidth)
     656             :             {
     657          90 :                 aResult.Right() *= nTextWidth;
     658          90 :                 aResult.Right() /= nGDTextWidth * nScaleFactor;
     659             :             }
     660             :         }
     661             :     }
     662             : 
     663             :     // move rectangle to match possibly different baselines
     664             :     // (because of different devices)
     665        8814 :     long nDelta = aDevFM.GetAscent() - pGlyphDev->GetFontMetric().GetAscent() * nScaleFactor;
     666        8814 :     aResult.Move(0, nDelta);
     667             : 
     668        8814 :     pGlyphDev->Pop();
     669             : 
     670        8814 :     rRect = aResult;
     671       17628 :     return bSuccess;
     672          42 : }
     673             : 
     674             : 
     675             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11