canvas/source/vcl/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
  21 #include <canvas/debug.hxx>
  22 #include <tools/diagnose_ex.h>
  23 #include <canvas/canvastools.hxx>
  24
  25 #include <com/sun/star/rendering/CompositeOperation.hpp>
  26 #include <com/sun/star/rendering/TextDirection.hpp>
  27 #include <cppuhelper/supportsservice.hxx>
  28
  29 #include <vcl/metric.hxx>
  30 #include <vcl/virdev.hxx>
  31
  32 #include <basegfx/matrix/b2dhommatrix.hxx>
  33 #include <basegfx/numeric/ftools.hxx>
  34 #include <basegfx/tools/canvastools.hxx>
  35
  36 #include "impltools.hxx"
  37 #include "textlayout.hxx"
  38
  39 #include <boost/scoped_array.hpp>
  40
  41 using namespace ::com::sun::star;
  42
  43 namespace vclcanvas
  44 {
  45     namespace
  46     {
  47         void setupLayoutMode( OutputDevice& rOutDev,
  48                               sal_Int8      nTextDirection )
  49         {
  50             // TODO(P3): avoid if already correctly set
  51             ComplexTextLayoutMode nLayoutMode = TEXT_LAYOUT_DEFAULT;
  52             switch( nTextDirection )
  53             {
  54                 case rendering::TextDirection::WEAK_LEFT_TO_RIGHT:
  55                     break;
  56                 case rendering::TextDirection::STRONG_LEFT_TO_RIGHT:
  57                     nLayoutMode = TEXT_LAYOUT_BIDI_STRONG;
  58                     break;
  59                 case rendering::TextDirection::WEAK_RIGHT_TO_LEFT:
  60                     nLayoutMode = TEXT_LAYOUT_BIDI_RTL;
  61                     break;
  62                 case rendering::TextDirection::STRONG_RIGHT_TO_LEFT:
  63                     nLayoutMode = TEXT_LAYOUT_BIDI_RTL | TEXT_LAYOUT_BIDI_STRONG;
  64                     break;
  65                 default:
  66                     break;
  67             }
  68
  69             // set calculated layout mode. Origin is always the left edge,
  70             // as required at the API spec
  71             rOutDev.SetLayoutMode( nLayoutMode | TEXT_LAYOUT_TEXTORIGIN_LEFT );
  72         }
  73     }
  74
  75     TextLayout::TextLayout( const rendering::StringContext&                  aText,
  76                             sal_Int8                                         nDirection,
  77                             sal_Int64                                        nRandomSeed,
  78                             const CanvasFont::Reference&                     rFont,
  79                             const uno::Reference<rendering::XGraphicDevice>& xDevice,
  80                             const OutDevProviderSharedPtr&                   rOutDev ) :
  81         TextLayout_Base( m_aMutex ),
  82         maText( aText ),
  83         maLogicalAdvancements(),
  84         mpFont( rFont ),
  85         mxDevice( xDevice ),
  86         mpOutDevProvider( rOutDev ),
  87         mnTextDirection( nDirection )
  88     {
  89         (void)nRandomSeed;
  90     }
  91
  92     void SAL_CALL TextLayout::disposing()
  93     {
  94         SolarMutexGuard aGuard;
  95
  96         mpOutDevProvider.reset();
  97         mxDevice.clear();
  98         mpFont.clear();
  99     }
 100
 101     // XTextLayout
 102     uno::Sequence< uno::Reference< rendering::XPolyPolygon2D > > SAL_CALL TextLayout::queryTextShapes(  ) throw (uno::RuntimeException, std::exception)
 103     {
 104         SolarMutexGuard aGuard;
 105
 106         OutputDevice& rOutDev = mpOutDevProvider->getOutDev();
 107         ScopedVclPtrInstance< VirtualDevice > pVDev( rOutDev );
 108         pVDev->SetFont( mpFont->getVCLFont() );
 109
 110         setupLayoutMode( *pVDev.get(), mnTextDirection );
 111
 112         const rendering::ViewState aViewState(
 113             geometry::AffineMatrix2D(1,0,0, 0,1,0),
 114             NULL);
 115
 116         rendering::RenderState aRenderState (
 117             geometry::AffineMatrix2D(1,0,0,0,1,0),
 118             NULL,
 119             uno::Sequence<double>(4),
 120             rendering::CompositeOperation::SOURCE);
 121
 122         ::boost::scoped_array< long > aOffsets(new long[maLogicalAdvancements.getLength()]);
 123         setupTextOffsets(aOffsets.get(), maLogicalAdvancements, aViewState, aRenderState);
 124
 125         uno::Sequence< uno::Reference< rendering::XPolyPolygon2D> > aOutlineSequence;
 126         ::basegfx::B2DPolyPolygonVector aOutlines;
 127         if (pVDev->GetTextOutlines(
 128             aOutlines,
 129             maText.Text,
 130             maText.StartPosition,
 131             maText.StartPosition,
 132             maText.Length,
 133             false,
 134             0,
 135             aOffsets.get()))
 136         {
 137             aOutlineSequence.realloc(aOutlines.size());
 138             sal_Int32 nIndex (0);
 139             for (::basegfx::B2DPolyPolygonVector::const_iterator
 140                      iOutline(aOutlines.begin()),
 141                      iEnd(aOutlines.end());
 142                  iOutline!=iEnd;
 143                  ++iOutline)
 144             {
 145                 aOutlineSequence[nIndex++] = ::basegfx::unotools::xPolyPolygonFromB2DPolyPolygon(
 146                     mxDevice,
 147                     *iOutline);
 148             }
 149         }
 150
 151         return aOutlineSequence;
 152     }
 153
 154     uno::Sequence< geometry::RealRectangle2D > SAL_CALL TextLayout::queryInkMeasures(  ) throw (uno::RuntimeException, std::exception)
 155     {
 156         SolarMutexGuard aGuard;
 157
 158
 159         OutputDevice& rOutDev = mpOutDevProvider->getOutDev();
 160         ScopedVclPtrInstance< VirtualDevice > pVDev( rOutDev );
 161         pVDev->SetFont( mpFont->getVCLFont() );
 162
 163         setupLayoutMode( *pVDev.get(), mnTextDirection );
 164
 165         const rendering::ViewState aViewState(
 166             geometry::AffineMatrix2D(1,0,0, 0,1,0),
 167             NULL);
 168
 169         rendering::RenderState aRenderState (
 170             geometry::AffineMatrix2D(1,0,0,0,1,0),
 171             NULL,
 172             uno::Sequence<double>(4),
 173             rendering::CompositeOperation::SOURCE);
 174
 175         ::boost::scoped_array< long > aOffsets(new long[maLogicalAdvancements.getLength()]);
 176         setupTextOffsets(aOffsets.get(), maLogicalAdvancements, aViewState, aRenderState);
 177
 178         MetricVector aMetricVector;
 179         uno::Sequence<geometry::RealRectangle2D> aBoundingBoxes;
 180         if (pVDev->GetGlyphBoundRects(
 181             Point(0,0),
 182             maText.Text,
 183             ::canvas::tools::numeric_cast<sal_uInt16>(maText.StartPosition),
 184             ::canvas::tools::numeric_cast<sal_uInt16>(maText.Length),
 185             ::canvas::tools::numeric_cast<sal_uInt16>(maText.StartPosition),
 186             aMetricVector))
 187         {
 188             aBoundingBoxes.realloc(aMetricVector.size());
 189             sal_Int32 nIndex (0);
 190             for (MetricVector::const_iterator
 191                      iMetric(aMetricVector.begin()),
 192                      iEnd(aMetricVector.end());
 193                  iMetric!=iEnd;
 194                  ++iMetric)
 195             {
 196                 aBoundingBoxes[nIndex++] = geometry::RealRectangle2D(
 197                     iMetric->getX(),
 198                     iMetric->getY(),
 199                     iMetric->getX() + iMetric->getWidth(),
 200                     iMetric->getY() + iMetric->getHeight());
 201             }
 202         }
 203         return aBoundingBoxes;
 204     }
 205
 206     uno::Sequence< geometry::RealRectangle2D > SAL_CALL TextLayout::queryMeasures(  ) throw (uno::RuntimeException, std::exception)
 207     {
 208         SolarMutexGuard aGuard;
 209
 210         // TODO(F1)
 211         return uno::Sequence< geometry::RealRectangle2D >();
 212     }
 213
 214     uno::Sequence< double > SAL_CALL TextLayout::queryLogicalAdvancements(  ) throw (uno::RuntimeException, std::exception)
 215     {
 216         SolarMutexGuard aGuard;
 217
 218         return maLogicalAdvancements;
 219     }
 220
 221     void SAL_CALL TextLayout::applyLogicalAdvancements( const uno::Sequence< double >& aAdvancements ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception)
 222     {
 223         SolarMutexGuard aGuard;
 224
 225         ENSURE_ARG_OR_THROW( aAdvancements.getLength() == maText.Length,
 226                          "TextLayout::applyLogicalAdvancements(): mismatching number of advancements" );
 227
 228         maLogicalAdvancements = aAdvancements;
 229     }
 230
 231     geometry::RealRectangle2D SAL_CALL TextLayout::queryTextBounds(  ) throw (uno::RuntimeException, std::exception)
 232     {
 233         SolarMutexGuard aGuard;
 234
 235         if( !mpOutDevProvider )
 236             return geometry::RealRectangle2D();
 237
 238         OutputDevice& rOutDev = mpOutDevProvider->getOutDev();
 239
 240         ScopedVclPtrInstance< VirtualDevice > pVDev( rOutDev );
 241         pVDev->SetFont( mpFont->getVCLFont() );
 242
 243         // need metrics for Y offset, the XCanvas always renders
 244         // relative to baseline
 245         const ::FontMetric& aMetric( pVDev->GetFontMetric() );
 246
 247         setupLayoutMode( *pVDev.get(), mnTextDirection );
 248
 249         const sal_Int32 nAboveBaseline( /*-aMetric.GetIntLeading()*/ - aMetric.GetAscent() );
 250         const sal_Int32 nBelowBaseline( aMetric.GetDescent() );
 251
 252         if( maLogicalAdvancements.getLength() )
 253         {
 254             return geometry::RealRectangle2D( 0, nAboveBaseline,
 255                                               maLogicalAdvancements[ maLogicalAdvancements.getLength()-1 ],
 256                                               nBelowBaseline );
 257         }
 258         else
 259         {
 260             return geometry::RealRectangle2D( 0, nAboveBaseline,
 261                                               pVDev->GetTextWidth(
 262                                                   maText.Text,
 263                                                   ::canvas::tools::numeric_cast<sal_uInt16>(maText.StartPosition),
 264                                                   ::canvas::tools::numeric_cast<sal_uInt16>(maText.Length) ),
 265                                               nBelowBaseline );
 266         }
 267     }
 268
 269     double SAL_CALL TextLayout::justify( double nSize ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception)
 270     {
 271         SolarMutexGuard aGuard;
 272
 273         (void)nSize;
 274
 275         // TODO(F1)
 276         return 0.0;
 277     }
 278
 279     double SAL_CALL TextLayout::combinedJustify( const uno::Sequence< uno::Reference< rendering::XTextLayout > >& aNextLayouts,
 280                                                  double                                                           nSize ) throw (lang::IllegalArgumentException, uno::RuntimeException, std::exception)
 281     {
 282         SolarMutexGuard aGuard;
 283
 284         (void)aNextLayouts;
 285         (void)nSize;
 286
 287         // TODO(F1)
 288         return 0.0;
 289     }
 290
 291     rendering::TextHit SAL_CALL TextLayout::getTextHit( const geometry::RealPoint2D& aHitPoint ) throw (uno::RuntimeException, std::exception)
 292     {
 293         SolarMutexGuard aGuard;
 294
 295         (void)aHitPoint;
 296
 297         // TODO(F1)
 298         return rendering::TextHit();
 299     }
 300
 301     rendering::Caret SAL_CALL TextLayout::getCaret( sal_Int32 nInsertionIndex, sal_Bool bExcludeLigatures ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 302     {
 303         SolarMutexGuard aGuard;
 304
 305         (void)nInsertionIndex;
 306         (void)bExcludeLigatures;
 307
 308         // TODO(F1)
 309         return rendering::Caret();
 310     }
 311
 312     sal_Int32 SAL_CALL TextLayout::getNextInsertionIndex( sal_Int32 nStartIndex, sal_Int32 nCaretAdvancement, sal_Bool bExcludeLigatures ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 313     {
 314         SolarMutexGuard aGuard;
 315
 316         (void)nStartIndex;
 317         (void)nCaretAdvancement;
 318         (void)bExcludeLigatures;
 319
 320         // TODO(F1)
 321         return 0;
 322     }
 323
 324     uno::Reference< rendering::XPolyPolygon2D > SAL_CALL TextLayout::queryVisualHighlighting( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 325     {
 326         SolarMutexGuard aGuard;
 327
 328         (void)nStartIndex;
 329         (void)nEndIndex;
 330
 331         // TODO(F1)
 332         return uno::Reference< rendering::XPolyPolygon2D >();
 333     }
 334
 335     uno::Reference< rendering::XPolyPolygon2D > SAL_CALL TextLayout::queryLogicalHighlighting( sal_Int32 nStartIndex, sal_Int32 nEndIndex ) throw (lang::IndexOutOfBoundsException, uno::RuntimeException, std::exception)
 336     {
 337         SolarMutexGuard aGuard;
 338
 339         (void)nStartIndex;
 340         (void)nEndIndex;
 341
 342         // TODO(F1)
 343         return uno::Reference< rendering::XPolyPolygon2D >();
 344     }
 345
 346     double SAL_CALL TextLayout::getBaselineOffset(  ) throw (uno::RuntimeException, std::exception)
 347     {
 348         SolarMutexGuard aGuard;
 349
 350         // TODO(F1)
 351         return 0.0;
 352     }
 353
 354     sal_Int8 SAL_CALL TextLayout::getMainTextDirection(  ) throw (uno::RuntimeException, std::exception)
 355     {
 356         SolarMutexGuard aGuard;
 357
 358         return mnTextDirection;
 359     }
 360
 361     uno::Reference< rendering::XCanvasFont > SAL_CALL TextLayout::getFont(  ) throw (uno::RuntimeException, std::exception)
 362     {
 363         SolarMutexGuard aGuard;
 364
 365         return mpFont.get();
 366     }
 367
 368     rendering::StringContext SAL_CALL TextLayout::getText(  ) throw (uno::RuntimeException, std::exception)
 369     {
 370         SolarMutexGuard aGuard;
 371
 372         return maText;
 373     }
 374
 375     bool TextLayout::draw( OutputDevice&                 rOutDev,
 376                            const Point&                  rOutpos,
 377                            const rendering::ViewState&   viewState,
 378                            const rendering::RenderState& renderState ) const
 379     {
 380         SolarMutexGuard aGuard;
 381
 382         setupLayoutMode( rOutDev, mnTextDirection );
 383
 384         if( maLogicalAdvancements.getLength() )
 385         {
 386             // TODO(P2): cache that
 387             ::boost::scoped_array< long > aOffsets(new long[maLogicalAdvancements.getLength()]);
 388             setupTextOffsets( aOffsets.get(), maLogicalAdvancements, viewState, renderState );
 389
 390             // TODO(F3): ensure correct length and termination for DX
 391             // array (last entry _must_ contain the overall width)
 392
 393             rOutDev.DrawTextArray( rOutpos,
 394                                    maText.Text,
 395                                    aOffsets.get(),
 396                                    ::canvas::tools::numeric_cast<sal_uInt16>(maText.StartPosition),
 397                                    ::canvas::tools::numeric_cast<sal_uInt16>(maText.Length) );
 398         }
 399         else
 400         {
 401             rOutDev.DrawText( rOutpos,
 402                               maText.Text,
 403                               ::canvas::tools::numeric_cast<sal_uInt16>(maText.StartPosition),
 404                               ::canvas::tools::numeric_cast<sal_uInt16>(maText.Length) );
 405         }
 406
 407         return true;
 408     }
 409
 410     namespace
 411     {
 412         class OffsetTransformer
 413         {
 414         public:
 415             OffsetTransformer( const ::basegfx::B2DHomMatrix& rMat ) :
 416                 maMatrix( rMat )
 417             {
 418             }
 419
 420             sal_Int32 operator()( const double& rOffset )
 421             {
 422                 // This is an optimization of the normal rMat*[x,0]
 423                 // transformation of the advancement vector (in x
 424                 // direction), followed by a length calculation of the
 425                 // resulting vector: advancement' =
 426                 // ||rMat*[x,0]||. Since advancements are vectors, we
 427                 // can ignore translational components, thus if [x,0],
 428                 // it follows that rMat*[x,0]=[x',0] holds. Thus, we
 429                 // just have to calc the transformation of the x
 430                 // component.
 431
 432                 // TODO(F2): Handle non-horizontal advancements!
 433                 return ::basegfx::fround( hypot(maMatrix.get(0,0)*rOffset,
 434                                                 maMatrix.get(1,0)*rOffset) );
 435             }
 436
 437         private:
 438             ::basegfx::B2DHomMatrix maMatrix;
 439         };
 440     }
 441
 442     void TextLayout::setupTextOffsets( long*                       outputOffsets,
 443                                        const uno::Sequence< double >&   inputOffsets,
 444                                        const rendering::ViewState&      viewState,
 445                                        const rendering::RenderState&    renderState     ) const
 446     {
 447         ENSURE_OR_THROW( outputOffsets!=NULL,
 448                           "TextLayout::setupTextOffsets offsets NULL" );
 449
 450         ::basegfx::B2DHomMatrix aMatrix;
 451
 452         ::canvas::tools::mergeViewAndRenderTransform(aMatrix,
 453                                                      viewState,
 454                                                      renderState);
 455
 456         // fill integer offsets
 457         ::std::transform( inputOffsets.getConstArray(),
 458                           inputOffsets.getConstArray()+inputOffsets.getLength(),
 459                           outputOffsets,
 460                           OffsetTransformer( aMatrix ) );
 461     }
 462
 463     OUString SAL_CALL TextLayout::getImplementationName() throw( uno::RuntimeException, std::exception )
 464     {
 465         return OUString( "VCLCanvas::TextLayout" );
 466     }
 467
 468     sal_Bool SAL_CALL TextLayout::supportsService( const OUString& ServiceName ) throw( uno::RuntimeException, std::exception )
 469     {
 470         return cppu::supportsService( this, ServiceName );
 471     }
 472
 473     uno::Sequence< OUString > SAL_CALL TextLayout::getSupportedServiceNames()  throw( uno::RuntimeException, std::exception )
 474     {
 475         uno::Sequence< OUString > aRet(1);
 476         aRet[0] = "com.sun.star.rendering.TextLayout";
 477
 478         return aRet;
 479     }
 480 }
 481
 482 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */