LCOV - code coverage report
Current view: top level - sdext/source/presenter - PresenterTextView.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 529 0.0 %
Date: 2014-04-14 Functions: 0 59 0.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 "PresenterTextView.hxx"
      21             : #include "PresenterCanvasHelper.hxx"
      22             : #include "PresenterGeometryHelper.hxx"
      23             : #include "PresenterTimer.hxx"
      24             : 
      25             : #include <cmath>
      26             : 
      27             : #include <com/sun/star/accessibility/AccessibleTextType.hpp>
      28             : #include <com/sun/star/container/XEnumerationAccess.hpp>
      29             : #include <com/sun/star/i18n/BreakIterator.hpp>
      30             : #include <com/sun/star/i18n/CharType.hpp>
      31             : #include <com/sun/star/i18n/CharacterIteratorMode.hpp>
      32             : #include <com/sun/star/i18n/CTLScriptType.hpp>
      33             : #include <com/sun/star/i18n/ScriptDirection.hpp>
      34             : #include <com/sun/star/i18n/WordType.hpp>
      35             : #include <com/sun/star/rendering/CompositeOperation.hpp>
      36             : #include <com/sun/star/rendering/TextDirection.hpp>
      37             : #include <com/sun/star/text/WritingMode2.hpp>
      38             : #include <boost/bind.hpp>
      39             : 
      40             : using namespace ::com::sun::star;
      41             : using namespace ::com::sun::star::accessibility;
      42             : using namespace ::com::sun::star::uno;
      43             : 
      44             : const static sal_Int64 CaretBlinkIntervall = 500 * 1000 * 1000;
      45             : 
      46             : //#define SHOW_CHARACTER_BOXES
      47             : 
      48             : namespace {
      49           0 :     sal_Int32 Signum (const sal_Int32 nValue)
      50             :     {
      51           0 :         if (nValue < 0)
      52           0 :             return -1;
      53           0 :         else if (nValue > 0)
      54           0 :             return +1;
      55             :         else
      56           0 :             return 0;
      57             :     }
      58             : }
      59             : 
      60             : namespace sdext { namespace presenter {
      61             : 
      62             : //===== PresenterTextView =====================================================
      63             : 
      64           0 : PresenterTextView::PresenterTextView (
      65             :     const Reference<XComponentContext>& rxContext,
      66             :     const Reference<rendering::XCanvas>& rxCanvas,
      67             :     const ::boost::function<void(const css::awt::Rectangle&)>& rInvalidator)
      68             :     : mxCanvas(rxCanvas),
      69             :       mbDoOuput(true),
      70             :       mxBreakIterator(),
      71             :       mxScriptTypeDetector(),
      72             :       maLocation(0,0),
      73             :       maSize(0,0),
      74             :       mpFont(),
      75             :       maParagraphs(),
      76             :       mpCaret(new PresenterTextCaret(
      77             :           ::boost::bind(&PresenterTextView::GetCaretBounds, this, _1, _2),
      78           0 :           rInvalidator)),
      79             :       mnLeftOffset(0),
      80             :       mnTopOffset(0),
      81             :       maInvalidator(rInvalidator),
      82             :       mbIsFormatPending(false),
      83             :       mnCharacterCount(-1),
      84           0 :       maTextChangeBroadcaster()
      85             : {
      86             :     Reference<lang::XMultiComponentFactory> xFactory (
      87           0 :         rxContext->getServiceManager(), UNO_QUERY);
      88           0 :     if ( ! xFactory.is())
      89           0 :         return;
      90             : 
      91             :     // Create the break iterator that we use to break text into lines.
      92           0 :     mxBreakIterator = i18n::BreakIterator::create(rxContext);
      93             : 
      94             :     // Create the script type detector that is used to split paragraphs into
      95             :     // portions of the same text direction.
      96           0 :     mxScriptTypeDetector = Reference<i18n::XScriptTypeDetector>(
      97           0 :         xFactory->createInstanceWithContext(
      98             :             "com.sun.star.i18n.ScriptTypeDetector",
      99           0 :             rxContext),
     100           0 :         UNO_QUERY_THROW);
     101             : }
     102             : 
     103           0 : void PresenterTextView::SetText (const Reference<text::XText>& rxText)
     104             : {
     105           0 :     maParagraphs.clear();
     106           0 :     mnCharacterCount = -1;
     107             : 
     108           0 :     Reference<container::XEnumerationAccess> xParagraphAccess (rxText, UNO_QUERY);
     109           0 :     if ( ! xParagraphAccess.is())
     110           0 :         return;
     111             : 
     112             :     Reference<container::XEnumeration> xParagraphs (
     113           0 :         xParagraphAccess->createEnumeration() , UNO_QUERY);
     114           0 :     if ( ! xParagraphs.is())
     115           0 :         return;
     116             : 
     117           0 :     if ( ! mpFont || ! mpFont->PrepareFont(mxCanvas))
     118           0 :         return;
     119             : 
     120           0 :     sal_Int32 nCharacterCount (0);
     121           0 :     while (xParagraphs->hasMoreElements())
     122             :     {
     123             :         SharedPresenterTextParagraph pParagraph (new PresenterTextParagraph(
     124           0 :             maParagraphs.size(),
     125             :             mxBreakIterator,
     126             :             mxScriptTypeDetector,
     127           0 :             Reference<text::XTextRange>(xParagraphs->nextElement(), UNO_QUERY),
     128           0 :             mpCaret));
     129           0 :         pParagraph->SetupCellArray(mpFont);
     130           0 :         pParagraph->SetCharacterOffset(nCharacterCount);
     131           0 :         nCharacterCount += pParagraph->GetCharacterCount();
     132           0 :         maParagraphs.push_back(pParagraph);
     133           0 :     }
     134             : 
     135           0 :     if (mpCaret)
     136           0 :         mpCaret->HideCaret();
     137             : 
     138           0 :     RequestFormat();
     139             : }
     140             : 
     141           0 : void PresenterTextView::SetTextChangeBroadcaster (
     142             :     const ::boost::function<void(void)>& rBroadcaster)
     143             : {
     144           0 :     maTextChangeBroadcaster = rBroadcaster;
     145           0 : }
     146             : 
     147           0 : void PresenterTextView::SetLocation (const css::geometry::RealPoint2D& rLocation)
     148             : {
     149           0 :     maLocation = rLocation;
     150             : 
     151           0 :     for (::std::vector<SharedPresenterTextParagraph>::iterator
     152           0 :              iParagraph(maParagraphs.begin()),
     153           0 :              iEnd(maParagraphs.end());
     154             :          iParagraph!=iEnd;
     155             :          ++iParagraph)
     156             :     {
     157           0 :         (*iParagraph)->SetOrigin(
     158             :             maLocation.X - mnLeftOffset,
     159           0 :             maLocation.Y - mnTopOffset);
     160             :     }
     161           0 : }
     162             : 
     163           0 : void PresenterTextView::SetSize (const css::geometry::RealSize2D& rSize)
     164             : {
     165           0 :     maSize = rSize;
     166           0 :     RequestFormat();
     167           0 : }
     168             : 
     169           0 : double PresenterTextView::GetTotalTextHeight (void)
     170             : {
     171           0 :     double nTotalHeight (0);
     172             : 
     173           0 :     if (mbIsFormatPending)
     174             :     {
     175           0 :         if ( ! mpFont->PrepareFont(mxCanvas))
     176           0 :             return 0;
     177           0 :         Format();
     178             :     }
     179             : 
     180           0 :     for (::std::vector<SharedPresenterTextParagraph>::iterator
     181           0 :              iParagraph(maParagraphs.begin()),
     182           0 :              iEnd(maParagraphs.end());
     183             :          iParagraph!=iEnd;
     184             :          ++iParagraph)
     185             :     {
     186           0 :         nTotalHeight += (*iParagraph)->GetTotalTextHeight();
     187             :     }
     188             : 
     189           0 :     return nTotalHeight;
     190             : }
     191             : 
     192           0 : void PresenterTextView::SetFont (const PresenterTheme::SharedFontDescriptor& rpFont)
     193             : {
     194           0 :     mpFont = rpFont;
     195           0 :     RequestFormat();
     196           0 : }
     197             : 
     198           0 : void PresenterTextView::SetOffset(
     199             :     const double nLeft,
     200             :     const double nTop)
     201             : {
     202           0 :     mnLeftOffset = nLeft;
     203           0 :     mnTopOffset = nTop;
     204             : 
     205             :     // Trigger an update of the text origin stored at the individual paragraphs.
     206           0 :     SetLocation(maLocation);
     207           0 : }
     208             : 
     209           0 : void PresenterTextView::MoveCaret (
     210             :     const sal_Int32 nDistance,
     211             :     const sal_Int16 nTextType)
     212             : {
     213           0 :     if ( ! mpCaret)
     214           0 :         return;
     215             : 
     216             :     // When the caret has not been visible yet then move it to the beginning
     217             :     // of the text.
     218           0 :     if (mpCaret->GetParagraphIndex() < 0)
     219             :     {
     220           0 :         mpCaret->SetPosition(0,0);
     221           0 :         return;
     222             :     }
     223             : 
     224           0 :     sal_Int32 nParagraphIndex (mpCaret->GetParagraphIndex());
     225           0 :     sal_Int32 nCharacterIndex (mpCaret->GetCharacterIndex());
     226           0 :     switch (nTextType)
     227             :     {
     228             :         default:
     229             :         case AccessibleTextType::CHARACTER:
     230           0 :             nCharacterIndex += nDistance;
     231           0 :             break;
     232             : 
     233             :         case AccessibleTextType::WORD:
     234             :         {
     235           0 :             sal_Int32 nRemainingDistance (nDistance);
     236           0 :             while (nRemainingDistance != 0)
     237             :             {
     238           0 :                 SharedPresenterTextParagraph pParagraph (GetParagraph(nParagraphIndex));
     239           0 :                 if (pParagraph)
     240             :                 {
     241           0 :                     const sal_Int32 nDelta (Signum(nDistance));
     242           0 :                     nCharacterIndex = pParagraph->GetWordBoundary(nCharacterIndex, nDelta);
     243           0 :                     if (nCharacterIndex < 0)
     244             :                     {
     245             :                         // Go to previous or next paragraph.
     246           0 :                         nParagraphIndex += nDelta;
     247           0 :                         if (nParagraphIndex < 0)
     248             :                         {
     249           0 :                             nParagraphIndex = 0;
     250           0 :                             nCharacterIndex = 0;
     251           0 :                             nRemainingDistance = 0;
     252             :                         }
     253           0 :                         else if (sal_uInt32(nParagraphIndex) >= maParagraphs.size())
     254             :                         {
     255           0 :                             nParagraphIndex = maParagraphs.size()-1;
     256           0 :                             pParagraph = GetParagraph(nParagraphIndex);
     257           0 :                             if (pParagraph)
     258           0 :                                 nCharacterIndex = pParagraph->GetCharacterCount();
     259           0 :                             nRemainingDistance = 0;
     260             :                         }
     261             :                         else
     262             :                         {
     263           0 :                             nRemainingDistance -= nDelta;
     264             : 
     265             :                             // Move caret one character to the end of
     266             :                             // the previous or the start of the next paragraph.
     267           0 :                             pParagraph = GetParagraph(nParagraphIndex);
     268           0 :                             if (pParagraph)
     269             :                             {
     270           0 :                                 if (nDistance<0)
     271           0 :                                     nCharacterIndex = pParagraph->GetCharacterCount();
     272             :                                 else
     273           0 :                                     nCharacterIndex = 0;
     274             :                             }
     275             :                         }
     276             :                     }
     277             :                     else
     278           0 :                         nRemainingDistance -= nDelta;
     279             :                 }
     280             :                 else
     281           0 :                     break;
     282           0 :             }
     283           0 :             break;
     284             :         }
     285             :     }
     286             : 
     287             :     // Move the caret to the new position.
     288           0 :     mpCaret->SetPosition(nParagraphIndex, nCharacterIndex);
     289             : }
     290             : 
     291           0 : void PresenterTextView::Paint (
     292             :     const css::awt::Rectangle& rUpdateBox)
     293             : {
     294           0 :     if ( ! mbDoOuput)
     295           0 :         return;
     296           0 :     if ( ! mxCanvas.is())
     297           0 :         return;
     298           0 :     if ( ! mpFont->PrepareFont(mxCanvas))
     299           0 :         return;
     300             : 
     301           0 :     if (mbIsFormatPending)
     302           0 :         Format();
     303             : 
     304             :     // Setup the clipping rectangle.  Horizontally we make it a little
     305             :     // larger to allow characters (and the caret) to stick out of their
     306             :     // bounding boxes.  This can happen on some characters (like the
     307             :     // uppercase J) for typographical reasons.
     308           0 :     const sal_Int32 nAdditionalLeftBorder (10);
     309           0 :     const sal_Int32 nAdditionalRightBorder (5);
     310           0 :     double nX (maLocation.X - mnLeftOffset);
     311           0 :     double nY (maLocation.Y - mnTopOffset);
     312             :     const sal_Int32 nClipLeft (::std::max(
     313           0 :         PresenterGeometryHelper::Round(maLocation.X)-nAdditionalLeftBorder, rUpdateBox.X));
     314             :     const sal_Int32 nClipTop (::std::max(
     315           0 :         PresenterGeometryHelper::Round(maLocation.Y), rUpdateBox.Y));
     316             :     const sal_Int32 nClipRight (::std::min(
     317           0 :         PresenterGeometryHelper::Round(maLocation.X+maSize.Width)+nAdditionalRightBorder, rUpdateBox.X+rUpdateBox.Width));
     318             :     const sal_Int32 nClipBottom (::std::min(
     319           0 :         PresenterGeometryHelper::Round(maLocation.Y+maSize.Height), rUpdateBox.Y+rUpdateBox.Height));
     320           0 :     if (nClipLeft>=nClipRight || nClipTop>=nClipBottom)
     321           0 :         return;
     322             : 
     323             :     const awt::Rectangle aClipBox(
     324             :         nClipLeft,
     325             :         nClipTop,
     326           0 :         nClipRight - nClipLeft,
     327           0 :         nClipBottom - nClipTop);
     328             :     Reference<rendering::XPolyPolygon2D> xClipPolygon (
     329           0 :         PresenterGeometryHelper::CreatePolygon(aClipBox, mxCanvas->getDevice()));
     330             : 
     331             :     const rendering::ViewState aViewState(
     332             :         geometry::AffineMatrix2D(1,0,0, 0,1,0),
     333           0 :         xClipPolygon);
     334             : 
     335             :     rendering::RenderState aRenderState (
     336             :         geometry::AffineMatrix2D(1,0,nX, 0,1,nY),
     337             :         NULL,
     338             :         Sequence<double>(4),
     339           0 :         rendering::CompositeOperation::SOURCE);
     340           0 :     PresenterCanvasHelper::SetDeviceColor(aRenderState, mpFont->mnColor);
     341             : 
     342           0 :     for (::std::vector<SharedPresenterTextParagraph>::const_iterator
     343           0 :              iParagraph(maParagraphs.begin()),
     344           0 :              iEnd(maParagraphs.end());
     345             :          iParagraph!=iEnd;
     346             :          ++iParagraph)
     347             :     {
     348           0 :         (*iParagraph)->Paint(
     349             :             mxCanvas,
     350             :             maSize,
     351             :             mpFont,
     352             :             aViewState,
     353             :             aRenderState,
     354             :             mnTopOffset,
     355             :             nClipTop,
     356           0 :             nClipBottom);
     357             :     }
     358             : 
     359           0 :     aRenderState.AffineTransform.m02 = 0;
     360           0 :     aRenderState.AffineTransform.m12 = 0;
     361             : 
     362             : #ifdef SHOW_CHARACTER_BOXES
     363             :     PresenterCanvasHelper::SetDeviceColor(aRenderState, 0x00808080);
     364             :     for (sal_Int32 nParagraphIndex(0), nParagraphCount(GetParagraphCount());
     365             :          nParagraphIndex<nParagraphCount;
     366             :          ++nParagraphIndex)
     367             :     {
     368             :         const SharedPresenterTextParagraph pParagraph (GetParagraph(nParagraphIndex));
     369             :         if ( ! pParagraph)
     370             :             continue;
     371             :         for (sal_Int32 nCharacterIndex(0),nCharacterCount(pParagraph->GetCharacterCount());
     372             :              nCharacterIndex<nCharacterCount; ++nCharacterIndex)
     373             :         {
     374             :             const awt::Rectangle aBox (pParagraph->GetCharacterBounds(nCharacterIndex, false));
     375             :             mxCanvas->drawPolyPolygon (
     376             :                 PresenterGeometryHelper::CreatePolygon(
     377             :                     aBox,
     378             :                     mxCanvas->getDevice()),
     379             :                 aViewState,
     380             :                 aRenderState);
     381             :         }
     382             :     }
     383             :     PresenterCanvasHelper::SetDeviceColor(aRenderState, mpFont->mnColor);
     384             : #endif
     385             : 
     386           0 :     if (mpCaret && mpCaret->IsVisible())
     387             :     {
     388           0 :         mxCanvas->fillPolyPolygon (
     389             :             PresenterGeometryHelper::CreatePolygon(
     390           0 :                 mpCaret->GetBounds(),
     391           0 :                 mxCanvas->getDevice()),
     392             :             aViewState,
     393           0 :             aRenderState);
     394           0 :     }
     395             : }
     396             : 
     397           0 : SharedPresenterTextCaret PresenterTextView::GetCaret (void) const
     398             : {
     399           0 :     return mpCaret;
     400             : }
     401             : 
     402           0 : awt::Rectangle PresenterTextView::GetCaretBounds (
     403             :     sal_Int32 nParagraphIndex,
     404             :     const sal_Int32 nCharacterIndex) const
     405             : {
     406           0 :     SharedPresenterTextParagraph pParagraph (GetParagraph(nParagraphIndex));
     407             : 
     408           0 :     if (pParagraph)
     409           0 :         return pParagraph->GetCharacterBounds(nCharacterIndex, true);
     410             :     else
     411           0 :         return awt::Rectangle(0,0,0,0);
     412             : }
     413             : 
     414             : //----- private ---------------------------------------------------------------
     415             : 
     416           0 : void PresenterTextView::RequestFormat (void)
     417             : {
     418           0 :     mbIsFormatPending = true;
     419           0 : }
     420             : 
     421           0 : void PresenterTextView::Format (void)
     422             : {
     423           0 :     mbIsFormatPending = false;
     424             : 
     425           0 :     double nY (0);
     426           0 :     for (::std::vector<SharedPresenterTextParagraph>::const_iterator
     427           0 :              iParagraph(maParagraphs.begin()),
     428           0 :              iEnd(maParagraphs.end());
     429             :          iParagraph!=iEnd;
     430             :          ++iParagraph)
     431             :     {
     432           0 :         (*iParagraph)->Format(nY, maSize.Width, mpFont);
     433           0 :         nY += (*iParagraph)->GetTotalTextHeight();
     434             :     }
     435             : 
     436           0 :     if (maTextChangeBroadcaster)
     437           0 :         maTextChangeBroadcaster();
     438           0 : }
     439             : 
     440           0 : sal_Int32 PresenterTextView::GetParagraphCount (void) const
     441             : {
     442           0 :     return maParagraphs.size();
     443             : }
     444             : 
     445           0 : SharedPresenterTextParagraph PresenterTextView::GetParagraph (
     446             :     const sal_Int32 nParagraphIndex) const
     447             : {
     448           0 :     if (nParagraphIndex < 0)
     449           0 :         return SharedPresenterTextParagraph();
     450           0 :     else if (nParagraphIndex>=sal_Int32(maParagraphs.size()))
     451           0 :         return SharedPresenterTextParagraph();
     452             :     else
     453           0 :         return maParagraphs[nParagraphIndex];
     454             : }
     455             : 
     456             : //===== PresenterTextParagraph ================================================
     457             : 
     458           0 : PresenterTextParagraph::PresenterTextParagraph (
     459             :     const sal_Int32 nParagraphIndex,
     460             :     const Reference<i18n::XBreakIterator>& rxBreakIterator,
     461             :     const Reference<i18n::XScriptTypeDetector>& rxScriptTypeDetector,
     462             :     const Reference<text::XTextRange>& rxTextRange,
     463             :     const SharedPresenterTextCaret& rpCaret)
     464             :     : msParagraphText(),
     465             :       mnParagraphIndex(nParagraphIndex),
     466             :       mpCaret(rpCaret),
     467             :       mxBreakIterator(rxBreakIterator),
     468             :       mxScriptTypeDetector(rxScriptTypeDetector),
     469             :       maLines(),
     470             :       mnVerticalOffset(0),
     471             :       mnXOrigin(0),
     472             :       mnYOrigin(0),
     473             :       mnWidth(0),
     474             :       mnAscent(0),
     475             :       mnDescent(0),
     476             :       mnLineHeight(-1),
     477             :       meAdjust(style::ParagraphAdjust_LEFT),
     478             :       mnWritingMode (text::WritingMode2::LR_TB),
     479             :       mnCharacterOffset(0),
     480           0 :       maCells()
     481             : {
     482           0 :     if (rxTextRange.is())
     483             :     {
     484           0 :         Reference<beans::XPropertySet> xProperties (rxTextRange, UNO_QUERY);
     485           0 :         lang::Locale aLocale;
     486             :         try
     487             :         {
     488           0 :             xProperties->getPropertyValue("CharLocale") >>= aLocale;
     489             :         }
     490           0 :         catch(beans::UnknownPropertyException&)
     491             :         {
     492             :             // Ignore the exception.  Use the default value.
     493             :         }
     494             :         try
     495             :         {
     496           0 :             xProperties->getPropertyValue("ParaAdjust") >>= meAdjust;
     497             :         }
     498           0 :         catch(beans::UnknownPropertyException&)
     499             :         {
     500             :             // Ignore the exception.  Use the default value.
     501             :         }
     502             :         try
     503             :         {
     504           0 :             xProperties->getPropertyValue("WritingMode") >>= mnWritingMode;
     505             :         }
     506           0 :         catch(beans::UnknownPropertyException&)
     507             :         {
     508             :             // Ignore the exception.  Use the default value.
     509             :         }
     510             : 
     511           0 :         msParagraphText = rxTextRange->getString();
     512             :     }
     513           0 : }
     514             : 
     515           0 : void PresenterTextParagraph::Paint (
     516             :     const Reference<rendering::XCanvas>& rxCanvas,
     517             :     const geometry::RealSize2D& rSize,
     518             :     const PresenterTheme::SharedFontDescriptor& rpFont,
     519             :     const rendering::ViewState& rViewState,
     520             :     rendering::RenderState& rRenderState,
     521             :     const double nTopOffset,
     522             :     const double nClipTop,
     523             :     const double nClipBottom)
     524             : {
     525           0 :     if (mnLineHeight <= 0)
     526           0 :         return;
     527             : 
     528           0 :     sal_Int8 nTextDirection (GetTextDirection());
     529             : 
     530           0 :     const double nSavedM12 (rRenderState.AffineTransform.m12);
     531             : 
     532           0 :     if ( ! IsTextReferencePointLeft())
     533           0 :         rRenderState.AffineTransform.m02 += rSize.Width;
     534             : 
     535             : #ifdef SHOW_CHARACTER_BOXES
     536             :     for (sal_Int32 nIndex=0,nCount=maLines.size();
     537             :          nIndex<nCount;
     538             :          ++nIndex)
     539             :     {
     540             :         Line& rLine (maLines[nIndex]);
     541             :         rLine.ProvideLayoutedLine(msParagraphText, rpFont, nTextDirection);
     542             :     }
     543             : #endif
     544             : 
     545           0 :     for (sal_Int32 nIndex=0,nCount=maLines.size();
     546             :          nIndex<nCount;
     547             :          ++nIndex, rRenderState.AffineTransform.m12 += mnLineHeight)
     548             :     {
     549           0 :         Line& rLine (maLines[nIndex]);
     550             : 
     551             :         // Paint only visible lines.
     552           0 :         const double nLineTop = rLine.mnBaseLine - mnAscent - nTopOffset;
     553           0 :         if (nLineTop + mnLineHeight< nClipTop)
     554           0 :             continue;
     555           0 :         else if (nLineTop > nClipBottom)
     556           0 :             break;
     557           0 :         rLine.ProvideLayoutedLine(msParagraphText, rpFont, nTextDirection);
     558             : 
     559           0 :         rRenderState.AffineTransform.m12 = nSavedM12 + rLine.mnBaseLine;
     560             : 
     561           0 :         rxCanvas->drawTextLayout (
     562             :             rLine.mxLayoutedLine,
     563             :             rViewState,
     564           0 :             rRenderState);
     565             :     }
     566           0 :     rRenderState.AffineTransform.m12 = nSavedM12;
     567             : 
     568           0 :     if ( ! IsTextReferencePointLeft())
     569           0 :         rRenderState.AffineTransform.m02 -= rSize.Width;
     570             : }
     571             : 
     572           0 : void PresenterTextParagraph::Format (
     573             :     const double nY,
     574             :     const double nWidth,
     575             :     const PresenterTheme::SharedFontDescriptor& rpFont)
     576             : {
     577             :     // Make sure that the text view is in a valid and sane state.
     578           0 :     if ( ! mxBreakIterator.is() || ! mxScriptTypeDetector.is())
     579           0 :         return;
     580           0 :     if (nWidth<=0)
     581           0 :         return;
     582           0 :     if ( ! rpFont || ! rpFont->mxFont.is())
     583           0 :         return;
     584             : 
     585           0 :     sal_Int32 nPosition (0);
     586             : 
     587           0 :     mnWidth = nWidth;
     588           0 :     maLines.clear();
     589           0 :     mnLineHeight = 0;
     590           0 :     mnAscent = 0;
     591           0 :     mnDescent = 0;
     592           0 :     mnVerticalOffset = nY;
     593           0 :     maWordBoundaries.clear();
     594           0 :     maWordBoundaries.push_back(0);
     595             : 
     596           0 :     const rendering::FontMetrics aMetrics (rpFont->mxFont->getFontMetrics());
     597           0 :     mnAscent = aMetrics.Ascent;
     598           0 :     mnDescent = aMetrics.Descent;
     599           0 :     mnLineHeight = aMetrics.Ascent + aMetrics.Descent + aMetrics.ExternalLeading;
     600           0 :     nPosition = 0;
     601           0 :     i18n::Boundary aCurrentLine(0,0);
     602             :     while (true)
     603             :     {
     604           0 :         const i18n::Boundary aWordBoundary = mxBreakIterator->nextWord(
     605             :             msParagraphText,
     606             :             nPosition,
     607             :             lang::Locale(),
     608           0 :             i18n::WordType::ANYWORD_IGNOREWHITESPACES);
     609           0 :         AddWord(nWidth, aCurrentLine, aWordBoundary.startPos, rpFont);
     610             : 
     611             :         // Remember the new word boundary for caret travelling by words.
     612             :         // Prevent duplicates.
     613           0 :         if (aWordBoundary.startPos > maWordBoundaries.back())
     614           0 :             maWordBoundaries.push_back(aWordBoundary.startPos);
     615             : 
     616           0 :         if (aWordBoundary.endPos>aWordBoundary.startPos)
     617           0 :             AddWord(nWidth, aCurrentLine, aWordBoundary.endPos, rpFont);
     618             : 
     619           0 :         if (aWordBoundary.startPos<0 || aWordBoundary.endPos<0)
     620             :             break;
     621           0 :         if (nPosition >= aWordBoundary.endPos)
     622           0 :             break;
     623           0 :         nPosition = aWordBoundary.endPos;
     624             :     }
     625             : 
     626           0 :     if (aCurrentLine.endPos>aCurrentLine.startPos)
     627           0 :         AddLine(aCurrentLine);
     628             : 
     629             : }
     630             : 
     631           0 : sal_Int32 PresenterTextParagraph::GetWordBoundary(
     632             :     const sal_Int32 nLocalCharacterIndex,
     633             :     const sal_Int32 nDistance)
     634             : {
     635             :     OSL_ASSERT(nDistance==-1 || nDistance==+1);
     636             : 
     637           0 :     if (nLocalCharacterIndex < 0)
     638             :     {
     639             :         // The caller asked for the start or end position of the paragraph.
     640           0 :         if (nDistance < 0)
     641           0 :             return 0;
     642             :         else
     643           0 :             return GetCharacterCount();
     644             :     }
     645             : 
     646           0 :     sal_Int32 nIndex (0);
     647           0 :     for (sal_Int32 nCount (maWordBoundaries.size()); nIndex<nCount; ++nIndex)
     648             :     {
     649           0 :         if (maWordBoundaries[nIndex] >= nLocalCharacterIndex)
     650             :         {
     651             :             // When inside the word (not at its start or end) then
     652             :             // first move to the start or end before going the previous or
     653             :             // next word.
     654           0 :             if (maWordBoundaries[nIndex] > nLocalCharacterIndex)
     655           0 :                 if (nDistance > 0)
     656           0 :                     --nIndex;
     657           0 :             break;
     658             :         }
     659             :     }
     660             : 
     661           0 :     nIndex += nDistance;
     662             : 
     663           0 :     if (nIndex < 0)
     664           0 :         return -1;
     665           0 :     else if (sal_uInt32(nIndex)>=maWordBoundaries.size())
     666           0 :         return -1;
     667             :     else
     668           0 :         return maWordBoundaries[nIndex];
     669             : }
     670             : 
     671           0 : sal_Int32 PresenterTextParagraph::GetCaretPosition (void) const
     672             : {
     673           0 :     if (mpCaret && mpCaret->GetParagraphIndex()==mnParagraphIndex)
     674           0 :         return mpCaret->GetCharacterIndex();
     675             :     else
     676           0 :         return -1;
     677             : }
     678             : 
     679           0 : void PresenterTextParagraph::SetCaretPosition (const sal_Int32 nPosition) const
     680             : {
     681           0 :     if (mpCaret && mpCaret->GetParagraphIndex()==mnParagraphIndex)
     682           0 :         return mpCaret->SetPosition(mnParagraphIndex, nPosition);
     683             : }
     684             : 
     685           0 : void PresenterTextParagraph::SetOrigin (const double nXOrigin, const double nYOrigin)
     686             : {
     687           0 :     mnXOrigin = nXOrigin;
     688           0 :     mnYOrigin = nYOrigin;
     689           0 : }
     690             : 
     691           0 : awt::Point PresenterTextParagraph::GetRelativeLocation (void) const
     692             : {
     693             :     return awt::Point(
     694             :         sal_Int32(mnXOrigin),
     695           0 :         sal_Int32(mnYOrigin + mnVerticalOffset));
     696             : }
     697             : 
     698           0 : awt::Size PresenterTextParagraph::GetSize (void)
     699             : {
     700             :     return awt::Size(
     701             :         sal_Int32(mnWidth),
     702           0 :         sal_Int32(GetTotalTextHeight()));
     703             : }
     704             : 
     705           0 : void PresenterTextParagraph::AddWord (
     706             :     const double nWidth,
     707             :     i18n::Boundary& rCurrentLine,
     708             :     const sal_Int32 nWordBoundary,
     709             :     const PresenterTheme::SharedFontDescriptor& rpFont)
     710             : {
     711           0 :     sal_Int32 nLineStart (0);
     712           0 :     if ( ! maLines.empty())
     713           0 :         nLineStart = rCurrentLine.startPos;
     714             : 
     715             :     const OUString sLineCandidate (
     716           0 :         msParagraphText.copy(nLineStart, nWordBoundary-nLineStart));
     717             : 
     718             :     css::geometry::RealRectangle2D aLineBox (
     719             :         PresenterCanvasHelper::GetTextBoundingBox (
     720           0 :             rpFont->mxFont,
     721             :             sLineCandidate,
     722           0 :             mnWritingMode));
     723           0 :     const double nLineWidth (aLineBox.X2 - aLineBox.X1);
     724             : 
     725           0 :     if (nLineWidth >= nWidth)
     726             :     {
     727             :         // Add new line with a single word (so far).
     728           0 :         AddLine(rCurrentLine);
     729             :     }
     730           0 :     rCurrentLine.endPos = nWordBoundary;
     731           0 : }
     732             : 
     733           0 : void PresenterTextParagraph::AddLine (
     734             :     i18n::Boundary& rCurrentLine)
     735             : {
     736           0 :     Line aLine (rCurrentLine.startPos, rCurrentLine.endPos);
     737             : 
     738             :     // Find the start and end of the line with respect to cells.
     739           0 :     if (maLines.size() > 0)
     740             :     {
     741           0 :         aLine.mnLineStartCellIndex = maLines.back().mnLineEndCellIndex;
     742           0 :         aLine.mnBaseLine = maLines.back().mnBaseLine + mnLineHeight;
     743             :     }
     744             :     else
     745             :     {
     746           0 :         aLine.mnLineStartCellIndex = 0;
     747           0 :         aLine.mnBaseLine = mnVerticalOffset + mnAscent;
     748             :     }
     749           0 :     sal_Int32 nCellIndex (aLine.mnLineStartCellIndex);
     750           0 :     double nWidth (0);
     751           0 :     for ( ; nCellIndex<sal_Int32(maCells.size()); ++nCellIndex)
     752             :     {
     753           0 :         const Cell& rCell (maCells[nCellIndex]);
     754           0 :         if (rCell.mnCharacterIndex+rCell.mnCharacterCount > aLine.mnLineEndCharacterIndex)
     755           0 :             break;
     756           0 :         nWidth += rCell.mnCellWidth;
     757             :     }
     758           0 :     aLine.mnLineEndCellIndex = nCellIndex;
     759           0 :     aLine.mnWidth = nWidth;
     760             : 
     761           0 :     maLines.push_back(aLine);
     762             : 
     763           0 :     rCurrentLine.startPos = rCurrentLine.endPos;
     764           0 : }
     765             : 
     766           0 : double PresenterTextParagraph::GetTotalTextHeight (void)
     767             : {
     768           0 :     return maLines.size() * mnLineHeight;
     769             : }
     770             : 
     771           0 : void PresenterTextParagraph::SetCharacterOffset (const sal_Int32 nCharacterOffset)
     772             : {
     773           0 :     mnCharacterOffset = nCharacterOffset;
     774           0 : }
     775             : 
     776           0 : sal_Int32 PresenterTextParagraph::GetCharacterCount (void) const
     777             : {
     778           0 :     return msParagraphText.getLength();
     779             : }
     780             : 
     781           0 : sal_Unicode PresenterTextParagraph::GetCharacter (
     782             :     const sal_Int32 nGlobalCharacterIndex) const
     783             : {
     784           0 :     if (nGlobalCharacterIndex<mnCharacterOffset
     785           0 :         || nGlobalCharacterIndex>=mnCharacterOffset+msParagraphText.getLength())
     786             :     {
     787           0 :         return sal_Unicode();
     788             :     }
     789             :     else
     790             :     {
     791           0 :         return msParagraphText[nGlobalCharacterIndex - mnCharacterOffset];
     792             :     }
     793             : }
     794             : 
     795           0 : OUString PresenterTextParagraph::GetText (void) const
     796             : {
     797           0 :     return msParagraphText;
     798             : }
     799             : 
     800           0 : TextSegment PresenterTextParagraph::GetTextSegment (
     801             :     const sal_Int32 nOffset,
     802             :     const sal_Int32 nIndex,
     803             :     const sal_Int16 nTextType) const
     804             : {
     805           0 :     switch(nTextType)
     806             :     {
     807             :         case AccessibleTextType::PARAGRAPH:
     808             :             return TextSegment(
     809             :                 msParagraphText,
     810             :                 mnCharacterOffset,
     811           0 :                 mnCharacterOffset+msParagraphText.getLength());
     812             : 
     813             :         case AccessibleTextType::SENTENCE:
     814           0 :             if (mxBreakIterator.is())
     815             :             {
     816           0 :                 const sal_Int32 nStart (mxBreakIterator->beginOfSentence(
     817           0 :                     msParagraphText, nIndex-mnCharacterOffset, lang::Locale()));
     818           0 :                 const sal_Int32 nEnd (mxBreakIterator->endOfSentence(
     819           0 :                     msParagraphText, nIndex-mnCharacterOffset, lang::Locale()));
     820           0 :                 if (nStart < nEnd)
     821             :                     return TextSegment(
     822             :                         msParagraphText.copy(nStart, nEnd-nStart),
     823           0 :                         nStart+mnCharacterOffset,
     824           0 :                         nEnd+mnCharacterOffset);
     825             :             }
     826           0 :             break;
     827             : 
     828             :         case AccessibleTextType::WORD:
     829           0 :             if (mxBreakIterator.is())
     830           0 :                 return GetWordTextSegment(nOffset, nIndex);
     831           0 :             break;
     832             : 
     833             :         case AccessibleTextType::LINE:
     834             :         {
     835           0 :             for (::std::vector<Line>::const_iterator
     836           0 :                      iLine(maLines.begin()),
     837           0 :                      iEnd(maLines.end());
     838             :                  iLine!=iEnd;
     839             :                  ++iLine)
     840             :             {
     841           0 :                 if (nIndex < iLine->mnLineEndCharacterIndex)
     842             :                 {
     843             :                     return TextSegment(
     844             :                         msParagraphText.copy(
     845           0 :                             iLine->mnLineStartCharacterIndex,
     846           0 :                             iLine->mnLineEndCharacterIndex - iLine->mnLineStartCharacterIndex),
     847           0 :                         iLine->mnLineStartCharacterIndex,
     848           0 :                         iLine->mnLineEndCharacterIndex);
     849             :                 }
     850             :             }
     851             :         }
     852           0 :         break;
     853             : 
     854             :         // Handle GLYPH and ATTRIBUTE_RUN like CHARACTER because we can not
     855             :         // do better at the moment.
     856             :         case AccessibleTextType::CHARACTER:
     857             :         case AccessibleTextType::GLYPH:
     858             :         case AccessibleTextType::ATTRIBUTE_RUN:
     859           0 :             return CreateTextSegment(nIndex+nOffset, nIndex+nOffset+1);
     860             :     }
     861             : 
     862           0 :     return TextSegment(OUString(), 0,0);
     863             : }
     864             : 
     865           0 : TextSegment PresenterTextParagraph::GetWordTextSegment (
     866             :     const sal_Int32 nOffset,
     867             :     const sal_Int32 nIndex) const
     868             : {
     869           0 :     sal_Int32 nCurrentOffset (nOffset);
     870           0 :     sal_Int32 nCurrentIndex (nIndex);
     871             : 
     872           0 :     i18n::Boundary aWordBoundary;
     873           0 :     if (nCurrentOffset == 0)
     874           0 :         aWordBoundary = mxBreakIterator->getWordBoundary(
     875             :             msParagraphText,
     876             :             nIndex,
     877             :             lang::Locale(),
     878             :             i18n::WordType::ANYWORD_IGNOREWHITESPACES,
     879           0 :             sal_True);
     880           0 :     else if (nCurrentOffset < 0)
     881             :     {
     882           0 :         while (nCurrentOffset<0 && nCurrentIndex>0)
     883             :         {
     884           0 :             aWordBoundary = mxBreakIterator->previousWord(
     885             :                 msParagraphText,
     886             :                 nCurrentIndex,
     887             :                 lang::Locale(),
     888           0 :                 i18n::WordType::ANYWORD_IGNOREWHITESPACES);
     889           0 :             nCurrentIndex = aWordBoundary.startPos;
     890           0 :             ++nCurrentOffset;
     891             :         }
     892             :     }
     893             :     else
     894             :     {
     895           0 :         while (nCurrentOffset>0 && nCurrentIndex<=GetCharacterCount())
     896             :         {
     897           0 :             aWordBoundary = mxBreakIterator->nextWord(
     898             :                 msParagraphText,
     899             :                 nCurrentIndex,
     900             :                 lang::Locale(),
     901           0 :                 i18n::WordType::ANYWORD_IGNOREWHITESPACES);
     902           0 :             nCurrentIndex = aWordBoundary.endPos;
     903           0 :             --nCurrentOffset;
     904             :         }
     905             :     }
     906             : 
     907           0 :     return CreateTextSegment(aWordBoundary.startPos, aWordBoundary.endPos);
     908             : }
     909             : 
     910           0 : TextSegment PresenterTextParagraph::CreateTextSegment (
     911             :     sal_Int32 nStartIndex,
     912             :     sal_Int32 nEndIndex) const
     913             : {
     914           0 :     if (nEndIndex <= nStartIndex)
     915             :         return TextSegment(
     916             :             OUString(),
     917             :             nStartIndex,
     918           0 :             nEndIndex);
     919             :     else
     920             :         return TextSegment(
     921             :             msParagraphText.copy(nStartIndex, nEndIndex-nStartIndex),
     922             :             nStartIndex,
     923           0 :             nEndIndex);
     924             : }
     925             : 
     926           0 : awt::Rectangle PresenterTextParagraph::GetCharacterBounds (
     927             :     sal_Int32 nGlobalCharacterIndex,
     928             :     const bool bCaretBox)
     929             : {
     930             :     // Find the line that contains the requested character and accumulate
     931             :     // the previous line heights.
     932           0 :     double nX (mnXOrigin);
     933           0 :     double nY (mnYOrigin + mnVerticalOffset + mnAscent);
     934           0 :     const sal_Int8 nTextDirection (GetTextDirection());
     935           0 :     for (sal_Int32 nLineIndex=0,nLineCount=maLines.size();
     936             :          nLineIndex<nLineCount;
     937             :          ++nLineIndex, nY+=mnLineHeight)
     938             :     {
     939           0 :         Line& rLine (maLines[nLineIndex]);
     940             :         // Skip lines before the indexed character.
     941           0 :         if (nGlobalCharacterIndex >= rLine.mnLineEndCharacterIndex)
     942             :             // When in the last line then allow the index past the last char.
     943           0 :             if (nLineIndex<nLineCount-1)
     944           0 :                 continue;
     945             : 
     946           0 :         rLine.ProvideCellBoxes();
     947             : 
     948           0 :         const sal_Int32 nCellIndex (nGlobalCharacterIndex - rLine.mnLineStartCharacterIndex);
     949             : 
     950             :         // The cell bounding box is defined relative to the origin of
     951             :         // the current line.  Therefore we have to add the absolute
     952             :         // position of the line.
     953             :         geometry::RealRectangle2D rCellBox (rLine.maCellBoxes[
     954           0 :             ::std::min(nCellIndex, rLine.maCellBoxes.getLength()-1)]);
     955             : 
     956           0 :         double nLeft = nX + rCellBox.X1;
     957           0 :         double nRight = nX + rCellBox.X2;
     958           0 :         if (nTextDirection == rendering::TextDirection::WEAK_RIGHT_TO_LEFT)
     959             :         {
     960           0 :             const double nOldRight (nRight);
     961           0 :             nRight = rLine.mnWidth - nLeft;
     962           0 :             nLeft = rLine.mnWidth - nOldRight;
     963             :         }
     964           0 :         double nTop (nY + rCellBox.Y1);
     965           0 :         double nBottom (nY + rCellBox.Y2);
     966           0 :         if (bCaretBox)
     967             :         {
     968           0 :             nTop = nTop - rCellBox.Y1 - mnAscent;
     969           0 :             nBottom = nTop + mnLineHeight;
     970           0 :             if (nCellIndex >= rLine.maCellBoxes.getLength())
     971           0 :                 nLeft = nRight-2;
     972           0 :             if (nLeft < nX)
     973           0 :                 nLeft = nX;
     974           0 :             nRight = nLeft+2;
     975             :         }
     976             :         else
     977             :         {
     978           0 :             nTop = nTop - rCellBox.Y1 - mnAscent;
     979           0 :             nBottom = nTop + mnAscent + mnDescent;
     980             :         }
     981           0 :         const sal_Int32 nX1 = sal_Int32(floor(nLeft));
     982           0 :         const sal_Int32 nY1 = sal_Int32(floor(nTop));
     983           0 :         const sal_Int32 nX2 = sal_Int32(ceil(nRight));
     984           0 :         const sal_Int32 nY2 = sal_Int32(ceil(nBottom));
     985             : 
     986           0 :         return awt::Rectangle(nX1,nY1,nX2-nX1+1,nY2-nY1+1);
     987             :     }
     988             : 
     989             :     // We are still here.  That means that the given index lies past the
     990             :     // last character in the paragraph.
     991             :     // Return an empty box that lies past the last character.  Better than nothing.
     992           0 :     return awt::Rectangle(sal_Int32(nX+0.5), sal_Int32(nY+0.5), 0, 0);
     993             : }
     994             : 
     995           0 : sal_Int32 PresenterTextParagraph::GetIndexAtPoint (const awt::Point& rPoint) const
     996             : {
     997             :     (void)rPoint;
     998           0 :     return -1;
     999             : }
    1000             : 
    1001           0 : sal_Int8 PresenterTextParagraph::GetTextDirection (void) const
    1002             : {
    1003             :     // Find first portion that has a non-neutral text direction.
    1004           0 :     sal_Int32 nPosition (0);
    1005           0 :     sal_Int32 nTextLength (msParagraphText.getLength());
    1006           0 :     while (nPosition < nTextLength)
    1007             :     {
    1008             :         const sal_Int16 nScriptDirection (
    1009           0 :             mxScriptTypeDetector->getScriptDirection(
    1010           0 :                 msParagraphText, nPosition, i18n::ScriptDirection::NEUTRAL));
    1011           0 :         switch (nScriptDirection)
    1012             :         {
    1013             :             case i18n::ScriptDirection::NEUTRAL:
    1014             :                 // continue looping.
    1015           0 :                 break;
    1016             :             case i18n::ScriptDirection::LEFT_TO_RIGHT:
    1017           0 :                 return rendering::TextDirection::WEAK_LEFT_TO_RIGHT;
    1018             : 
    1019             :             case i18n::ScriptDirection::RIGHT_TO_LEFT:
    1020           0 :                 return rendering::TextDirection::WEAK_RIGHT_TO_LEFT;
    1021             :         }
    1022             : 
    1023           0 :         nPosition = mxScriptTypeDetector->endOfScriptDirection(
    1024           0 :             msParagraphText, nPosition, nScriptDirection);
    1025             :     }
    1026             : 
    1027             :     // All text in paragraph is neutral.  Fall back on writing mode taken
    1028             :     // from the XText (which may not be properly initialized.)
    1029           0 :     sal_Int8 nTextDirection(rendering::TextDirection::WEAK_LEFT_TO_RIGHT);
    1030           0 :     switch(mnWritingMode)
    1031             :     {
    1032             :         case text::WritingMode2::LR_TB:
    1033           0 :             nTextDirection = rendering::TextDirection::WEAK_LEFT_TO_RIGHT;
    1034           0 :             break;
    1035             : 
    1036             :         case text::WritingMode2::RL_TB:
    1037           0 :             nTextDirection = rendering::TextDirection::WEAK_RIGHT_TO_LEFT;
    1038           0 :             break;
    1039             : 
    1040             :         default:
    1041             :         case text::WritingMode2::TB_RL:
    1042             :         case text::WritingMode2::TB_LR:
    1043             :             // Can not handle this.  Use default and hope for the best.
    1044           0 :             break;
    1045             :     }
    1046           0 :     return nTextDirection;
    1047             : }
    1048             : 
    1049           0 : bool PresenterTextParagraph::IsTextReferencePointLeft (void) const
    1050             : {
    1051           0 :     return mnWritingMode != text::WritingMode2::RL_TB;
    1052             : }
    1053             : 
    1054           0 : void PresenterTextParagraph::SetupCellArray (
    1055             :     const PresenterTheme::SharedFontDescriptor& rpFont)
    1056             : {
    1057           0 :     maCells.clear();
    1058             : 
    1059           0 :     if ( ! rpFont || ! rpFont->mxFont.is())
    1060           0 :         return;
    1061             : 
    1062           0 :     sal_Int32 nPosition (0);
    1063           0 :     sal_Int32 nIndex (0);
    1064           0 :     const sal_Int32 nTextLength (msParagraphText.getLength());
    1065           0 :     const sal_Int8 nTextDirection (GetTextDirection());
    1066           0 :     while (nPosition < nTextLength)
    1067             :     {
    1068           0 :         const sal_Int32 nNewPosition (mxBreakIterator->nextCharacters(
    1069             :             msParagraphText,
    1070             :             nPosition,
    1071             :             lang::Locale(),
    1072             :             i18n::CharacterIteratorMode::SKIPCELL,
    1073             :             1,
    1074           0 :             nIndex));
    1075             : 
    1076           0 :         rendering::StringContext aContext (msParagraphText, nPosition, nNewPosition-nPosition);
    1077             :         Reference<rendering::XTextLayout> xLayout (
    1078           0 :             rpFont->mxFont->createTextLayout(aContext, nTextDirection, 0));
    1079           0 :         css::geometry::RealRectangle2D aCharacterBox (xLayout->queryTextBounds());
    1080             : 
    1081             :         maCells.push_back(Cell(
    1082             :             nPosition,
    1083             :             nNewPosition-nPosition,
    1084           0 :             aCharacterBox.X2-aCharacterBox.X1));
    1085             : 
    1086           0 :         nPosition = nNewPosition;
    1087           0 :     }
    1088             : }
    1089             : 
    1090             : //===== PresenterTextCaret ================================================----
    1091             : 
    1092           0 : PresenterTextCaret::PresenterTextCaret (
    1093             :     const ::boost::function<css::awt::Rectangle(const sal_Int32,const sal_Int32)>& rCharacterBoundsAccess,
    1094             :     const ::boost::function<void(const css::awt::Rectangle&)>& rInvalidator)
    1095             :     : mnParagraphIndex(-1),
    1096             :       mnCharacterIndex(-1),
    1097             :       mnCaretBlinkTaskId(0),
    1098             :       mbIsCaretVisible(false),
    1099             :       maCharacterBoundsAccess(rCharacterBoundsAccess),
    1100             :       maInvalidator(rInvalidator),
    1101             :       maBroadcaster(),
    1102           0 :       maCaretBounds()
    1103             : {
    1104           0 : }
    1105             : 
    1106           0 : PresenterTextCaret::~PresenterTextCaret (void)
    1107             : {
    1108           0 :     HideCaret();
    1109           0 : }
    1110             : 
    1111           0 : void PresenterTextCaret::ShowCaret (void)
    1112             : {
    1113           0 :     if (mnCaretBlinkTaskId == 0)
    1114             :     {
    1115             :         mnCaretBlinkTaskId = PresenterTimer::ScheduleRepeatedTask (
    1116             :             ::boost::bind(&PresenterTextCaret::InvertCaret, this),
    1117             :             CaretBlinkIntervall,
    1118           0 :             CaretBlinkIntervall);
    1119             :     }
    1120           0 :     mbIsCaretVisible = true;
    1121           0 : }
    1122             : 
    1123           0 : void PresenterTextCaret::HideCaret (void)
    1124             : {
    1125           0 :     if (mnCaretBlinkTaskId != 0)
    1126             :     {
    1127           0 :         PresenterTimer::CancelTask(mnCaretBlinkTaskId);
    1128           0 :         mnCaretBlinkTaskId = 0;
    1129             :     }
    1130           0 :     mbIsCaretVisible = false;
    1131             :     // Reset the caret position.
    1132           0 :     mnParagraphIndex = -1;
    1133           0 :     mnCharacterIndex = -1;
    1134           0 : }
    1135             : 
    1136           0 : sal_Int32 PresenterTextCaret::GetParagraphIndex (void) const
    1137             : {
    1138           0 :     return mnParagraphIndex;
    1139             : }
    1140             : 
    1141           0 : sal_Int32 PresenterTextCaret::GetCharacterIndex (void) const
    1142             : {
    1143           0 :     return mnCharacterIndex;
    1144             : }
    1145             : 
    1146           0 : void PresenterTextCaret::SetPosition (
    1147             :     const sal_Int32 nParagraphIndex,
    1148             :     const sal_Int32 nCharacterIndex)
    1149             : {
    1150           0 :     if (mnParagraphIndex != nParagraphIndex
    1151           0 :         || mnCharacterIndex != nCharacterIndex)
    1152             :     {
    1153           0 :         if (mnParagraphIndex >= 0)
    1154           0 :             maInvalidator(maCaretBounds);
    1155             : 
    1156           0 :         const sal_Int32 nOldParagraphIndex (mnParagraphIndex);
    1157           0 :         const sal_Int32 nOldCharacterIndex (mnCharacterIndex);
    1158           0 :         mnParagraphIndex = nParagraphIndex;
    1159           0 :         mnCharacterIndex = nCharacterIndex;
    1160           0 :         maCaretBounds = maCharacterBoundsAccess(mnParagraphIndex, mnCharacterIndex);
    1161           0 :         if (mnParagraphIndex >= 0)
    1162           0 :             ShowCaret();
    1163             :         else
    1164           0 :             HideCaret();
    1165             : 
    1166           0 :         if (mnParagraphIndex >= 0)
    1167           0 :             maInvalidator(maCaretBounds);
    1168             : 
    1169           0 :         if (maBroadcaster)
    1170             :             maBroadcaster(
    1171             :                 nOldParagraphIndex,
    1172             :                 nOldCharacterIndex,
    1173             :                 mnParagraphIndex,
    1174           0 :                 mnCharacterIndex);
    1175             : 
    1176             :     }
    1177           0 : }
    1178             : 
    1179           0 : bool PresenterTextCaret::IsVisible (void) const
    1180             : {
    1181           0 :     return mbIsCaretVisible;
    1182             : }
    1183             : 
    1184           0 : void PresenterTextCaret::SetCaretMotionBroadcaster (
    1185             :     const ::boost::function<void(sal_Int32,sal_Int32,sal_Int32,sal_Int32)>& rBroadcaster)
    1186             : {
    1187           0 :     maBroadcaster = rBroadcaster;
    1188           0 : }
    1189             : 
    1190           0 : css::awt::Rectangle PresenterTextCaret::GetBounds (void) const
    1191             : {
    1192           0 :     return maCaretBounds;
    1193             : }
    1194             : 
    1195           0 : void PresenterTextCaret::InvertCaret (void)
    1196             : {
    1197           0 :     mbIsCaretVisible = !mbIsCaretVisible;
    1198           0 :     if (mnParagraphIndex >= 0)
    1199           0 :         maInvalidator(maCaretBounds);
    1200           0 : }
    1201             : 
    1202             : //===== PresenterTextParagraph::Cell ==========================================
    1203             : 
    1204           0 : PresenterTextParagraph::Cell::Cell (
    1205             :     const sal_Int32 nCharacterIndex,
    1206             :     const sal_Int32 nCharacterCount,
    1207             :     const double nCellWidth)
    1208             :     : mnCharacterIndex(nCharacterIndex),
    1209             :       mnCharacterCount(nCharacterCount),
    1210           0 :       mnCellWidth(nCellWidth)
    1211             : {
    1212           0 : }
    1213             : 
    1214             : //===== PresenterTextParagraph::Line ==========================================
    1215             : 
    1216           0 : PresenterTextParagraph::Line::Line (
    1217             :     const sal_Int32 nLineStartCharacterIndex,
    1218             :     const sal_Int32 nLineEndCharacterIndex)
    1219             :     : mnLineStartCharacterIndex(nLineStartCharacterIndex),
    1220             :       mnLineEndCharacterIndex(nLineEndCharacterIndex),
    1221             :       mnLineStartCellIndex(-1), mnLineEndCellIndex(-1),
    1222             :       mxLayoutedLine(),
    1223             :       mnBaseLine(0), mnWidth(0),
    1224           0 :       maCellBoxes()
    1225             : {
    1226           0 : }
    1227             : 
    1228           0 : void PresenterTextParagraph::Line::ProvideCellBoxes (void)
    1229             : {
    1230           0 :     if ( ! IsEmpty() && maCellBoxes.getLength()==0)
    1231             :     {
    1232           0 :         if (mxLayoutedLine.is())
    1233           0 :             maCellBoxes = mxLayoutedLine->queryInkMeasures();
    1234             :         else
    1235             :         {
    1236             :             OSL_ASSERT(mxLayoutedLine.is());
    1237             :         }
    1238             :     }
    1239           0 : }
    1240             : 
    1241           0 : void PresenterTextParagraph::Line::ProvideLayoutedLine (
    1242             :     const OUString& rsParagraphText,
    1243             :     const PresenterTheme::SharedFontDescriptor& rpFont,
    1244             :     const sal_Int8 nTextDirection)
    1245             : {
    1246           0 :     if ( ! mxLayoutedLine.is())
    1247             :     {
    1248             :         const rendering::StringContext aContext (
    1249             :             rsParagraphText,
    1250             :             mnLineStartCharacterIndex,
    1251           0 :             mnLineEndCharacterIndex - mnLineStartCharacterIndex);
    1252             : 
    1253           0 :         mxLayoutedLine = rpFont->mxFont->createTextLayout(
    1254             :             aContext,
    1255             :             nTextDirection,
    1256           0 :             0);
    1257             :     }
    1258           0 : }
    1259             : 
    1260           0 : bool PresenterTextParagraph::Line::IsEmpty (void) const
    1261             : {
    1262           0 :     return mnLineStartCharacterIndex >= mnLineEndCharacterIndex;
    1263             : }
    1264             : 
    1265           0 : } } // end of namespace ::sdext::presenter
    1266             : 
    1267             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10