vcl/source/gdi/textlayout.cxx

   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 <vcl/ctrl.hxx>
  21 #include <vcl/outdev.hxx>
  22
  23 #include <textlayout.hxx>
  24
  25 #include <osl/diagnose.h>
  26 #include <tools/fract.hxx>
  27 #include <sal/log.hxx>
  28
  29 #if OSL_DEBUG_LEVEL > 1
  30 #include <rtl/strbuf.hxx>
  31 #endif
  32
  33 #include <memory>
  34 #include <iterator>
  35
  36 namespace vcl
  37 {
  38
  39     DefaultTextLayout::~DefaultTextLayout()
  40     {
  41     }
  42
  43     tools::Long DefaultTextLayout::GetTextWidth( const OUString& _rText, sal_Int32 _nStartIndex, sal_Int32 _nLength ) const
  44     {
  45         return m_rTargetDevice.GetTextWidth( _rText, _nStartIndex, _nLength );
  46     }
  47
  48     void DefaultTextLayout::DrawText( const Point& _rStartPoint, const OUString& _rText, sal_Int32 _nStartIndex,
  49         sal_Int32 _nLength, std::vector< tools::Rectangle >* _pVector, OUString* _pDisplayText )
  50     {
  51         m_rTargetDevice.DrawText( _rStartPoint, _rText, _nStartIndex, _nLength, _pVector, _pDisplayText );
  52     }
  53
  54     void DefaultTextLayout::GetCaretPositions( const OUString& _rText, tools::Long* _pCaretXArray,
  55         sal_Int32 _nStartIndex, sal_Int32 _nLength ) const
  56     {
  57         m_rTargetDevice.GetCaretPositions( _rText, _pCaretXArray, _nStartIndex, _nLength );
  58     }
  59
  60     sal_Int32 DefaultTextLayout::GetTextBreak( const OUString& _rText, tools::Long _nMaxTextWidth, sal_Int32 _nStartIndex, sal_Int32 _nLength ) const
  61     {
  62         return m_rTargetDevice.GetTextBreak( _rText, _nMaxTextWidth, _nStartIndex, _nLength );
  63     }
  64
  65     bool DefaultTextLayout::DecomposeTextRectAction() const
  66     {
  67         return false;
  68     }
  69
  70     class ReferenceDeviceTextLayout : public ITextLayout
  71     {
  72     public:
  73         ReferenceDeviceTextLayout( const Control& _rControl, OutputDevice& _rTargetDevice, OutputDevice& _rReferenceDevice );
  74         virtual ~ReferenceDeviceTextLayout();
  75
  76         // ITextLayout
  77         virtual tools::Long        GetTextWidth( const OUString& rStr, sal_Int32 nIndex, sal_Int32 nLen ) const override;
  78         virtual void        DrawText( const Point& _rStartPoint, const OUString& _rText, sal_Int32 _nStartIndex, sal_Int32 _nLength, std::vector< tools::Rectangle >* _pVector, OUString* _pDisplayText ) override;
  79         virtual void        GetCaretPositions( const OUString& _rText, tools::Long* _pCaretXArray, sal_Int32 _nStartIndex, sal_Int32 _nLength ) const override;
  80         virtual sal_Int32   GetTextBreak(const OUString& _rText, tools::Long _nMaxTextWidth, sal_Int32 _nStartIndex, sal_Int32 _nLength) const override;
  81         virtual bool        DecomposeTextRectAction() const override;
  82
  83     public:
  84         // equivalents to the respective OutputDevice methods, which take the reference device into account
  85         tools::Rectangle   DrawText( const tools::Rectangle& _rRect, const OUString& _rText, DrawTextFlags _nStyle, std::vector< tools::Rectangle >* _pVector, OUString* _pDisplayText, const Size* i_pDeviceSize );
  86         tools::Rectangle   GetTextRect( const tools::Rectangle& _rRect, const OUString& _rText, DrawTextFlags _nStyle, Size* o_pDeviceSize );
  87
  88     private:
  89         tools::Long        GetTextArray( const OUString& _rText, tools::Long* _pDXAry, sal_Int32 _nStartIndex, sal_Int32 _nLength ) const;
  90
  91         OutputDevice&   m_rTargetDevice;
  92         OutputDevice&   m_rReferenceDevice;
  93         const bool      m_bRTLEnabled;
  94
  95         tools::Rectangle       m_aCompleteTextRect;
  96     };
  97
  98     ReferenceDeviceTextLayout::ReferenceDeviceTextLayout( const Control& _rControl, OutputDevice& _rTargetDevice,
  99         OutputDevice& _rReferenceDevice )
 100         :m_rTargetDevice( _rTargetDevice )
 101         ,m_rReferenceDevice( _rReferenceDevice )
 102         ,m_bRTLEnabled( _rControl.IsRTLEnabled() )
 103     {
 104         Font const aUnzoomedPointFont( _rControl.GetUnzoomedControlPointFont() );
 105         const Fraction& aZoom( _rControl.GetZoom() );
 106         m_rTargetDevice.Push( PushFlags::MAPMODE | PushFlags::FONT | PushFlags::TEXTLAYOUTMODE );
 107
 108         MapMode aTargetMapMode( m_rTargetDevice.GetMapMode() );
 109         OSL_ENSURE( aTargetMapMode.GetOrigin() == Point(), "ReferenceDeviceTextLayout::ReferenceDeviceTextLayout: uhm, the code below won't work here ..." );
 110
 111         // normally, controls simulate "zoom" by "zooming" the font. This is responsible for (part of) the discrepancies
 112         // between text in Writer and text in controls in Writer, though both have the same font.
 113         // So, if we have a zoom set at the control, then we do not scale the font, but instead modify the map mode
 114         // to accommodate for the zoom.
 115         aTargetMapMode.SetScaleX( aZoom );    // TODO: shouldn't this be "current_scale * zoom"?
 116         aTargetMapMode.SetScaleY( aZoom );
 117
 118         // also, use a higher-resolution map unit than "pixels", which should save us some rounding errors when
 119         // translating coordinates between the reference device and the target device.
 120         OSL_ENSURE( aTargetMapMode.GetMapUnit() == MapUnit::MapPixel,
 121             "ReferenceDeviceTextLayout::ReferenceDeviceTextLayout: this class is not expected to work with such target devices!" );
 122             // we *could* adjust all the code in this class to handle this case, but at the moment, it's not necessary
 123         const MapUnit eTargetMapUnit = m_rReferenceDevice.GetMapMode().GetMapUnit();
 124         aTargetMapMode.SetMapUnit( eTargetMapUnit );
 125         OSL_ENSURE( aTargetMapMode.GetMapUnit() != MapUnit::MapPixel,
 126             "ReferenceDeviceTextLayout::ReferenceDeviceTextLayout: a reference device which has map mode PIXEL?!" );
 127
 128         m_rTargetDevice.SetMapMode( aTargetMapMode );
 129
 130         // now that the Zoom is part of the map mode, reset the target device's font to the "unzoomed" version
 131         Font aDrawFont( aUnzoomedPointFont );
 132         aDrawFont.SetFontSize( OutputDevice::LogicToLogic(aDrawFont.GetFontSize(), MapMode(MapUnit::MapPoint), MapMode(eTargetMapUnit)) );
 133         _rTargetDevice.SetFont( aDrawFont );
 134
 135         // transfer font to the reference device
 136         m_rReferenceDevice.Push( PushFlags::FONT | PushFlags::TEXTLAYOUTMODE );
 137         Font aRefFont( aUnzoomedPointFont );
 138         aRefFont.SetFontSize( OutputDevice::LogicToLogic(
 139             aRefFont.GetFontSize(), MapMode(MapUnit::MapPoint), m_rReferenceDevice.GetMapMode()) );
 140         m_rReferenceDevice.SetFont( aRefFont );
 141     }
 142
 143     ReferenceDeviceTextLayout::~ReferenceDeviceTextLayout()
 144     {
 145         m_rReferenceDevice.Pop();
 146         m_rTargetDevice.Pop();
 147     }
 148
 149     namespace
 150     {
 151         bool lcl_normalizeLength( const OUString& _rText, const sal_Int32 _nStartIndex, sal_Int32& _io_nLength )
 152         {
 153             sal_Int32 nTextLength = _rText.getLength();
 154             if ( _nStartIndex > nTextLength )
 155                 return false;
 156             if ( _nStartIndex + _io_nLength > nTextLength )
 157                 _io_nLength = nTextLength - _nStartIndex;
 158             return true;
 159         }
 160     }
 161
 162     tools::Long ReferenceDeviceTextLayout::GetTextArray( const OUString& _rText, tools::Long* _pDXAry, sal_Int32 _nStartIndex, sal_Int32 _nLength ) const
 163     {
 164         if ( !lcl_normalizeLength( _rText, _nStartIndex, _nLength ) )
 165             return 0;
 166
 167         // retrieve the character widths from the reference device
 168         tools::Long nTextWidth = m_rReferenceDevice.GetTextArray( _rText, _pDXAry, _nStartIndex, _nLength );
 169 #if OSL_DEBUG_LEVEL > 1
 170         if ( _pDXAry )
 171         {
 172             OStringBuffer aTrace;
 173             aTrace.append( "ReferenceDeviceTextLayout::GetTextArray( " );
 174             aTrace.append( OUStringToOString( _rText, RTL_TEXTENCODING_UTF8 ) );
 175             aTrace.append( " ): " );
 176             aTrace.append( nTextWidth );
 177             aTrace.append( " = ( " );
 178             for ( sal_Int32 i=0; i<_nLength; )
 179             {
 180                 aTrace.append( _pDXAry[i] );
 181                 if ( ++i < _nLength )
 182                     aTrace.append( ", " );
 183             }
 184             aTrace.append( ")" );
 185             SAL_INFO( "vcl", aTrace.makeStringAndClear() );
 186         }
 187 #endif
 188         return nTextWidth;
 189     }
 190
 191     tools::Long ReferenceDeviceTextLayout::GetTextWidth( const OUString& _rText, sal_Int32 _nStartIndex, sal_Int32 _nLength ) const
 192     {
 193         return GetTextArray( _rText, nullptr, _nStartIndex, _nLength );
 194     }
 195
 196     void ReferenceDeviceTextLayout::DrawText( const Point& _rStartPoint, const OUString& _rText, sal_Int32 _nStartIndex, sal_Int32 _nLength, std::vector< tools::Rectangle >* _pVector, OUString* _pDisplayText )
 197     {
 198         if ( !lcl_normalizeLength( _rText, _nStartIndex, _nLength ) )
 199             return;
 200
 201         if ( _pVector && _pDisplayText )
 202         {
 203             std::vector< tools::Rectangle > aGlyphBounds;
 204             m_rReferenceDevice.GetGlyphBoundRects( _rStartPoint, _rText, _nStartIndex, _nLength, aGlyphBounds );
 205             _pVector->insert( _pVector->end(), aGlyphBounds.begin(), aGlyphBounds.end() );
 206             *_pDisplayText += _rText.subView( _nStartIndex, _nLength );
 207             return;
 208         }
 209
 210         std::unique_ptr<tools::Long[]> pCharWidths(new tools::Long[ _nLength ]);
 211         tools::Long nTextWidth = GetTextArray( _rText, pCharWidths.get(), _nStartIndex, _nLength );
 212         m_rTargetDevice.DrawTextArray( _rStartPoint, _rText, pCharWidths.get(), _nStartIndex, _nLength );
 213         pCharWidths.reset();
 214
 215         m_aCompleteTextRect.Union( tools::Rectangle( _rStartPoint, Size( nTextWidth, m_rTargetDevice.GetTextHeight() ) ) );
 216     }
 217
 218     void ReferenceDeviceTextLayout::GetCaretPositions( const OUString& _rText, tools::Long* _pCaretXArray,
 219                                                        sal_Int32 _nStartIndex, sal_Int32 _nLength ) const
 220     {
 221         if ( !lcl_normalizeLength( _rText, _nStartIndex, _nLength ) )
 222             return;
 223
 224         // retrieve the caret positions from the reference device
 225         m_rReferenceDevice.GetCaretPositions( _rText, _pCaretXArray, _nStartIndex, _nLength );
 226     }
 227
 228     sal_Int32 ReferenceDeviceTextLayout::GetTextBreak( const OUString& _rText, tools::Long _nMaxTextWidth, sal_Int32 _nStartIndex, sal_Int32 _nLength ) const
 229     {
 230         if ( !lcl_normalizeLength( _rText, _nStartIndex, _nLength ) )
 231             return 0;
 232
 233         return m_rReferenceDevice.GetTextBreak( _rText, _nMaxTextWidth, _nStartIndex, _nLength );
 234     }
 235
 236     bool ReferenceDeviceTextLayout::DecomposeTextRectAction() const
 237     {
 238         return true;
 239     }
 240
 241     tools::Rectangle ReferenceDeviceTextLayout::DrawText( const tools::Rectangle& _rRect, const OUString& _rText, DrawTextFlags _nStyle,
 242                                                    std::vector< tools::Rectangle >* _pVector, OUString* _pDisplayText, const Size* i_pDeviceSize )
 243     {
 244         if ( _rText.isEmpty() )
 245             return tools::Rectangle();
 246
 247         // determine text layout mode from the RTL-ness of the control whose text we render
 248         ComplexTextLayoutFlags nTextLayoutMode = m_bRTLEnabled ? ComplexTextLayoutFlags::BiDiRtl : ComplexTextLayoutFlags::Default;
 249         m_rReferenceDevice.SetLayoutMode( nTextLayoutMode );
 250         m_rTargetDevice.SetLayoutMode( nTextLayoutMode | ComplexTextLayoutFlags::TextOriginLeft );
 251
 252         // ComplexTextLayoutFlags::TextOriginLeft is because when we do actually draw the text (in DrawText( Point, ... )), then
 253         // our caller gives us the left border of the draw position, regardless of script type, text layout,
 254         // and the like in our ctor, we set the map mode of the target device from pixel to twip, but our caller doesn't know this,
 255         // but passed pixel coordinates. So, adjust the rect.
 256         tools::Rectangle aRect( m_rTargetDevice.PixelToLogic( _rRect ) );
 257         if (i_pDeviceSize)
 258         {
 259             //if i_pDeviceSize is passed in here, it was the original pre logic-to-pixel size of _rRect
 260             SAL_WARN_IF(std::abs(_rRect.GetSize().Width() - m_rTargetDevice.LogicToPixel(*i_pDeviceSize).Width()) > 1, "vcl", "DeviceSize width was expected to match Pixel width");
 261             SAL_WARN_IF(std::abs(_rRect.GetSize().Height() - m_rTargetDevice.LogicToPixel(*i_pDeviceSize).Height()) > 1, "vcl", "DeviceSize height was expected to match Pixel height");
 262             aRect.SetSize(*i_pDeviceSize);
 263         }
 264
 265         m_aCompleteTextRect.SetEmpty();
 266         m_rTargetDevice.DrawText( aRect, _rText, _nStyle, _pVector, _pDisplayText, this );
 267         tools::Rectangle aTextRect = m_aCompleteTextRect;
 268
 269         if ( aTextRect.IsEmpty() && !aRect.IsEmpty() )
 270         {
 271             // this happens for instance if we're in a PaintToDevice call, where only a MetaFile is recorded,
 272             // but no actual painting happens, so our "DrawText( Point, ... )" is never called
 273             // In this case, calculate the rect from what OutputDevice::GetTextRect would give us. This has
 274             // the disadvantage of less accuracy, compared with the approach to calculate the rect from the
 275             // single "DrawText( Point, ... )" calls, since more intermediate arithmetic will translate
 276             // from ref- to target-units.
 277             aTextRect = m_rTargetDevice.GetTextRect( aRect, _rText, _nStyle, nullptr, this );
 278         }
 279
 280         // similar to above, the text rect now contains TWIPs (or whatever unit the ref device has), but the caller
 281         // expects pixel coordinates
 282         aTextRect = m_rTargetDevice.LogicToPixel( aTextRect );
 283
 284         // convert the metric vector
 285         if ( _pVector )
 286         {
 287             for ( auto& rCharRect : *_pVector )
 288             {
 289                 rCharRect = m_rTargetDevice.LogicToPixel( rCharRect );
 290             }
 291         }
 292
 293         return aTextRect;
 294     }
 295
 296     tools::Rectangle ReferenceDeviceTextLayout::GetTextRect( const tools::Rectangle& _rRect, const OUString& _rText, DrawTextFlags _nStyle, Size* o_pDeviceSize )
 297     {
 298         if ( _rText.isEmpty() )
 299             return tools::Rectangle();
 300
 301         // determine text layout mode from the RTL-ness of the control whose text we render
 302         ComplexTextLayoutFlags nTextLayoutMode = m_bRTLEnabled ? ComplexTextLayoutFlags::BiDiRtl : ComplexTextLayoutFlags::Default;
 303         m_rReferenceDevice.SetLayoutMode( nTextLayoutMode );
 304         m_rTargetDevice.SetLayoutMode( nTextLayoutMode | ComplexTextLayoutFlags::TextOriginLeft );
 305
 306         // ComplexTextLayoutFlags::TextOriginLeft is because when we do actually draw the text (in DrawText( Point, ... )), then
 307         // our caller gives us the left border of the draw position, regardless of script type, text layout,
 308         // and the like in our ctor, we set the map mode of the target device from pixel to twip, but our caller doesn't know this,
 309         // but passed pixel coordinates. So, adjust the rect.
 310         tools::Rectangle aRect( m_rTargetDevice.PixelToLogic( _rRect ) );
 311
 312         tools::Rectangle aTextRect = m_rTargetDevice.GetTextRect( aRect, _rText, _nStyle, nullptr, this );
 313
 314         //if o_pDeviceSize is available, stash the pre logic-to-pixel size in it
 315         if (o_pDeviceSize)
 316         {
 317             *o_pDeviceSize = aTextRect.GetSize();
 318         }
 319
 320         // similar to above, the text rect now contains TWIPs (or whatever unit the ref device has), but the caller
 321         // expects pixel coordinates
 322         aTextRect = m_rTargetDevice.LogicToPixel( aTextRect );
 323
 324         return aTextRect;
 325     }
 326
 327     ControlTextRenderer::ControlTextRenderer( const Control& _rControl, OutputDevice& _rTargetDevice, OutputDevice& _rReferenceDevice )
 328         :m_pImpl( new ReferenceDeviceTextLayout( _rControl, _rTargetDevice, _rReferenceDevice ) )
 329     {
 330     }
 331
 332     ControlTextRenderer::~ControlTextRenderer()
 333     {
 334     }
 335
 336     tools::Rectangle ControlTextRenderer::DrawText( const tools::Rectangle& _rRect, const OUString& _rText, DrawTextFlags _nStyle,
 337         std::vector< tools::Rectangle >* _pVector, OUString* _pDisplayText, const Size* i_pDeviceSize )
 338     {
 339         return m_pImpl->DrawText( _rRect, _rText, _nStyle, _pVector, _pDisplayText, i_pDeviceSize );
 340     }
 341
 342     tools::Rectangle ControlTextRenderer::GetTextRect( const tools::Rectangle& _rRect, const OUString& _rText, DrawTextFlags _nStyle, Size* o_pDeviceSize = nullptr )
 343     {
 344         return m_pImpl->GetTextRect( _rRect, _rText, _nStyle, o_pDeviceSize );
 345     }
 346
 347 } // namespace vcl
 348
 349 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */