sdext/source/presenter/PresenterTextView.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: PresenterNotesView.hxx,v $
  10  *
  11  * $Revision: 1.5 $
  12  *
  13  * This file is part of OpenOffice.org.
  14  *
  15  * OpenOffice.org is free software: you can redistribute it and/or modify
  16  * it under the terms of the GNU Lesser General Public License version 3
  17  * only, as published by the Free Software Foundation.
  18  *
  19  * OpenOffice.org is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU Lesser General Public License version 3 for more details
  23  * (a copy is included in the LICENSE file that accompanied this code).
  24  *
  25  * You should have received a copy of the GNU Lesser General Public License
  26  * version 3 along with OpenOffice.org.  If not, see
  27  * <http://www.openoffice.org/license.html>
  28  * for a copy of the LGPLv3 License.
  29  *
  30  ************************************************************************/
  31
  32 #include "precompiled_sdext.hxx"
  33
  34 #include "PresenterTextView.hxx"
  35 #include "PresenterCanvasHelper.hxx"
  36 #include "PresenterGeometryHelper.hxx"
  37 #include "PresenterTimer.hxx"
  38
  39 #include <cmath>
  40
  41 #include <com/sun/star/accessibility/AccessibleTextType.hpp>
  42 #include <com/sun/star/container/XEnumerationAccess.hpp>
  43 #include <com/sun/star/i18n/CharType.hpp>
  44 #include <com/sun/star/i18n/CharacterIteratorMode.hpp>
  45 #include <com/sun/star/i18n/CTLScriptType.hpp>
  46 #include <com/sun/star/i18n/ScriptDirection.hpp>
  47 #include <com/sun/star/i18n/WordType.hpp>
  48 #include <com/sun/star/rendering/CompositeOperation.hpp>
  49 #include <com/sun/star/rendering/TextDirection.hpp>
  50 #include <com/sun/star/text/WritingMode2.hpp>
  51 #include <boost/bind.hpp>
  52
  53 using namespace ::com::sun::star;
  54 using namespace ::com::sun::star::accessibility;
  55 using namespace ::com::sun::star::uno;
  56
  57 #define A2S(pString) (::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(pString)))
  58
  59 const static sal_Int64 CaretBlinkIntervall = 500 * 1000 * 1000;
  60
  61 //#define SHOW_CHARACTER_BOXES
  62
  63 namespace {
  64     sal_Int32 Signum (const sal_Int32 nValue)
  65     {
  66         if (nValue < 0)
  67             return -1;
  68         else if (nValue > 0)
  69             return +1;
  70         else
  71             return 0;
  72     }
  73 }
  74
  75 namespace sdext { namespace presenter {
  76
  77
  78 //===== PresenterTextView =====================================================
  79
  80 PresenterTextView::PresenterTextView (
  81     const Reference<XComponentContext>& rxContext,
  82     const Reference<rendering::XCanvas>& rxCanvas,
  83     const ::boost::function<void(const ::css::awt::Rectangle&)>& rInvalidator)
  84     : mxCanvas(rxCanvas),
  85       mbDoOuput(true),
  86       mxBreakIterator(),
  87       mxScriptTypeDetector(),
  88       maLocation(0,0),
  89       maSize(0,0),
  90       mpFont(),
  91       maParagraphs(),
  92       mpCaret(new PresenterTextCaret(
  93           ::boost::bind(&PresenterTextView::GetCaretBounds, this, _1, _2),
  94           rInvalidator)),
  95       mnLeftOffset(0),
  96       mnTopOffset(0),
  97       maInvalidator(rInvalidator),
  98       mbIsFormatPending(false),
  99       mnCharacterCount(-1),
 100       maTextChangeBroadcaster()
 101 {
 102     Reference<lang::XMultiComponentFactory> xFactory (
 103         rxContext->getServiceManager(), UNO_QUERY);
 104     if ( ! xFactory.is())
 105         return;
 106
 107     // Create the break iterator that we use to break text into lines.
 108     mxBreakIterator = Reference<i18n::XBreakIterator>(
 109         xFactory->createInstanceWithContext(
 110             A2S("com.sun.star.i18n.BreakIterator"),
 111             rxContext),
 112         UNO_QUERY_THROW);
 113
 114     // Create the script type detector that is used to split paragraphs into
 115     // portions of the same text direction.
 116     mxScriptTypeDetector = Reference<i18n::XScriptTypeDetector>(
 117         xFactory->createInstanceWithContext(
 118             A2S("com.sun.star.i18n.ScriptTypeDetector"),
 119             rxContext),
 120         UNO_QUERY_THROW);
 121 }
 122
 123
 124
 125
 126 PresenterTextView::PresenterTextView (
 127     const Reference<XComponentContext>& rxContext,
 128     const Reference<rendering::XCanvas>& rxCanvas)
 129     : mxCanvas(rxCanvas),
 130       mbDoOuput(false),
 131       mxBreakIterator(),
 132       mxScriptTypeDetector(),
 133       maLocation(0,0),
 134       maSize(0,0),
 135       mpFont(),
 136       maParagraphs(),
 137       mpCaret(new PresenterTextCaret(
 138           ::boost::bind(&PresenterTextView::GetCaretBounds, this, _1, _2),
 139           ::boost::function<void(const css::awt::Rectangle&)>())),
 140       mnLeftOffset(0),
 141       mnTopOffset(0),
 142       maInvalidator(),
 143       mbIsFormatPending(false),
 144       mnCharacterCount(-1),
 145       maTextChangeBroadcaster()
 146 {
 147     Reference<lang::XMultiComponentFactory> xFactory (
 148         rxContext->getServiceManager(), UNO_QUERY);
 149     if ( ! xFactory.is())
 150         return;
 151
 152     // Create the break iterator that we use to break text into lines.
 153     mxBreakIterator = Reference<i18n::XBreakIterator>(
 154         xFactory->createInstanceWithContext(
 155             A2S("com.sun.star.i18n.BreakIterator"),
 156             rxContext),
 157         UNO_QUERY_THROW);
 158
 159     // Create the script type detector that is used to split paragraphs into
 160     // portions of the same text direction.
 161     mxScriptTypeDetector = Reference<i18n::XScriptTypeDetector>(
 162         xFactory->createInstanceWithContext(
 163             A2S("com.sun.star.i18n.ScriptTypeDetector"),
 164             rxContext),
 165         UNO_QUERY_THROW);
 166 }
 167
 168
 169
 170
 171 void PresenterTextView::SetText (const Reference<text::XText>& rxText)
 172 {
 173     maParagraphs.clear();
 174     mnCharacterCount = -1;
 175
 176     Reference<container::XEnumerationAccess> xParagraphAccess (rxText, UNO_QUERY);
 177     if ( ! xParagraphAccess.is())
 178         return;
 179
 180     Reference<container::XEnumeration> xParagraphs (
 181         xParagraphAccess->createEnumeration() , UNO_QUERY);
 182     if ( ! xParagraphs.is())
 183         return;
 184
 185     if ( ! mpFont || ! mpFont->PrepareFont(mxCanvas))
 186         return;
 187
 188     sal_Int32 nCharacterCount (0);
 189     while (xParagraphs->hasMoreElements())
 190     {
 191         SharedPresenterTextParagraph pParagraph (new PresenterTextParagraph(
 192             maParagraphs.size(),
 193             mxBreakIterator,
 194             mxScriptTypeDetector,
 195             Reference<text::XTextRange>(xParagraphs->nextElement(), UNO_QUERY),
 196             mpCaret));
 197         pParagraph->SetupCellArray(mpFont);
 198         pParagraph->SetCharacterOffset(nCharacterCount);
 199         nCharacterCount += pParagraph->GetCharacterCount();
 200         maParagraphs.push_back(pParagraph);
 201     }
 202
 203     if (mpCaret)
 204         mpCaret->HideCaret();
 205
 206     RequestFormat();
 207 }
 208
 209
 210
 211
 212 void PresenterTextView::SetText (const ::rtl::OUString& rsText)
 213 {
 214     maParagraphs.clear();
 215     mnCharacterCount = -1;
 216
 217     if ( ! mpFont || ! mpFont->PrepareFont(mxCanvas))
 218         return;
 219
 220     sal_Int32 nCharacterCount (0);
 221
 222     SharedPresenterTextParagraph pParagraph (new PresenterTextParagraph(
 223         0,
 224         mxBreakIterator,
 225         mxScriptTypeDetector,
 226         rsText,
 227         mpCaret));
 228     pParagraph->SetupCellArray(mpFont);
 229     pParagraph->SetCharacterOffset(nCharacterCount);
 230     nCharacterCount += pParagraph->GetCharacterCount();
 231     maParagraphs.push_back(pParagraph);
 232
 233     if (mpCaret)
 234         mpCaret->HideCaret();
 235
 236     RequestFormat();
 237 }
 238
 239
 240
 241
 242 void PresenterTextView::SetTextChangeBroadcaster (
 243     const ::boost::function<void(void)>& rBroadcaster)
 244 {
 245     maTextChangeBroadcaster = rBroadcaster;
 246 }
 247
 248
 249
 250
 251 void PresenterTextView::SetLocation (const css::geometry::RealPoint2D& rLocation)
 252 {
 253     maLocation = rLocation;
 254
 255     for (::std::vector<SharedPresenterTextParagraph>::iterator
 256              iParagraph(maParagraphs.begin()),
 257              iEnd(maParagraphs.end());
 258          iParagraph!=iEnd;
 259          ++iParagraph)
 260     {
 261         (*iParagraph)->SetOrigin(
 262             maLocation.X - mnLeftOffset,
 263             maLocation.Y - mnTopOffset);
 264     }
 265 }
 266
 267
 268
 269
 270 void PresenterTextView::SetSize (const css::geometry::RealSize2D& rSize)
 271 {
 272     maSize = rSize;
 273     RequestFormat();
 274 }
 275
 276
 277
 278
 279 double PresenterTextView::GetTotalTextHeight (void)
 280 {
 281     double nTotalHeight (0);
 282
 283     if (mbIsFormatPending)
 284     {
 285         if ( ! mpFont->PrepareFont(mxCanvas))
 286             return 0;
 287         Format();
 288     }
 289
 290     for (::std::vector<SharedPresenterTextParagraph>::iterator
 291              iParagraph(maParagraphs.begin()),
 292              iEnd(maParagraphs.end());
 293          iParagraph!=iEnd;
 294          ++iParagraph)
 295     {
 296         nTotalHeight += (*iParagraph)->GetTotalTextHeight();
 297     }
 298
 299     return nTotalHeight;
 300 }
 301
 302
 303
 304
 305 void PresenterTextView::SetFont (const PresenterTheme::SharedFontDescriptor& rpFont)
 306 {
 307     mpFont = rpFont;
 308     RequestFormat();
 309 }
 310
 311
 312
 313
 314 void PresenterTextView::SetOffset(
 315     const double nLeft,
 316     const double nTop)
 317 {
 318     mnLeftOffset = nLeft;
 319     mnTopOffset = nTop;
 320
 321     // Trigger an update of the text origin stored at the individual paragraphs.
 322     SetLocation(maLocation);
 323 }
 324
 325
 326
 327 void PresenterTextView::MoveCaret (
 328     const sal_Int32 nDistance,
 329     const sal_Int16 nTextType)
 330 {
 331     if ( ! mpCaret)
 332         return;
 333
 334     // When the caret has not been visible yet then move it to the beginning
 335     // of the text.
 336     if (mpCaret->GetParagraphIndex() < 0)
 337     {
 338         mpCaret->SetPosition(0,0);
 339         return;
 340     }
 341
 342     sal_Int32 nParagraphIndex (mpCaret->GetParagraphIndex());
 343     sal_Int32 nCharacterIndex (mpCaret->GetCharacterIndex());
 344     switch (nTextType)
 345     {
 346         default:
 347         case AccessibleTextType::CHARACTER:
 348             nCharacterIndex += nDistance;
 349             break;
 350
 351         case AccessibleTextType::WORD:
 352         {
 353             sal_Int32 nRemainingDistance (nDistance);
 354             while (nRemainingDistance != 0)
 355             {
 356                 SharedPresenterTextParagraph pParagraph (GetParagraph(nParagraphIndex));
 357                 if (pParagraph)
 358                 {
 359                     const sal_Int32 nDelta (Signum(nDistance));
 360                     nCharacterIndex = pParagraph->GetWordBoundary(nCharacterIndex, nDelta);
 361                     if (nCharacterIndex < 0)
 362                     {
 363                         // Go to previous or next paragraph.
 364                         nParagraphIndex += nDelta;
 365                         if (nParagraphIndex < 0)
 366                         {
 367                             nParagraphIndex = 0;
 368                             nCharacterIndex = 0;
 369                             nRemainingDistance = 0;
 370                         }
 371                         else if (sal_uInt32(nParagraphIndex) >= maParagraphs.size())
 372                         {
 373                             nParagraphIndex = maParagraphs.size()-1;
 374                             pParagraph = GetParagraph(nParagraphIndex);
 375                             if (pParagraph)
 376                                 nCharacterIndex = pParagraph->GetCharacterCount();
 377                             nRemainingDistance = 0;
 378                         }
 379                         else
 380                         {
 381                             nRemainingDistance -= nDelta;
 382
 383                             // Move caret one character to the end of
 384                             // the previous or the start of the next paragraph.
 385                             pParagraph = GetParagraph(nParagraphIndex);
 386                             if (pParagraph)
 387                                 if (nDistance<0)
 388                                     nCharacterIndex = pParagraph->GetCharacterCount();
 389                                 else
 390                                     nCharacterIndex = 0;
 391                         }
 392                     }
 393                     else
 394                         nRemainingDistance -= nDelta;
 395                 }
 396                 else
 397                     break;
 398             }
 399             break;
 400         }
 401     }
 402
 403     // Move the caret to the new position.
 404     mpCaret->SetPosition(nParagraphIndex, nCharacterIndex);
 405 }
 406
 407
 408
 409
 410 void PresenterTextView::Paint (
 411     const css::awt::Rectangle& rUpdateBox)
 412 {
 413     if ( ! mbDoOuput)
 414         return;
 415     if ( ! mxCanvas.is())
 416         return;
 417     if ( ! mpFont->PrepareFont(mxCanvas))
 418         return;
 419
 420     if (mbIsFormatPending)
 421         Format();
 422
 423     // Setup the clipping rectangle.  Horizontally we make it a little
 424     // larger to allow characters (and the caret) to stick out of their
 425     // bounding boxes.  This can happen on some characters (like the
 426     // uppercase J) for typographical reasons.
 427     const sal_Int32 nAdditionalLeftBorder (10);
 428     const sal_Int32 nAdditionalRightBorder (5);
 429     double nX (maLocation.X - mnLeftOffset);
 430     double nY (maLocation.Y - mnTopOffset);
 431     const sal_Int32 nClipLeft (::std::max(
 432         PresenterGeometryHelper::Round(maLocation.X)-nAdditionalLeftBorder, rUpdateBox.X));
 433     const sal_Int32 nClipTop (::std::max(
 434         PresenterGeometryHelper::Round(maLocation.Y), rUpdateBox.Y));
 435     const sal_Int32 nClipRight (::std::min(
 436         PresenterGeometryHelper::Round(maLocation.X+maSize.Width)+nAdditionalRightBorder, rUpdateBox.X+rUpdateBox.Width));
 437     const sal_Int32 nClipBottom (::std::min(
 438         PresenterGeometryHelper::Round(maLocation.Y+maSize.Height), rUpdateBox.Y+rUpdateBox.Height));
 439     if (nClipLeft>=nClipRight || nClipTop>=nClipBottom)
 440         return;
 441
 442     const awt::Rectangle aClipBox(
 443         nClipLeft,
 444         nClipTop,
 445         nClipRight - nClipLeft,
 446         nClipBottom - nClipTop);
 447     Reference<rendering::XPolyPolygon2D> xClipPolygon (
 448         PresenterGeometryHelper::CreatePolygon(aClipBox, mxCanvas->getDevice()));
 449
 450     const rendering::ViewState aViewState(
 451         geometry::AffineMatrix2D(1,0,0, 0,1,0),
 452         xClipPolygon);
 453
 454     rendering::RenderState aRenderState (
 455         geometry::AffineMatrix2D(1,0,nX, 0,1,nY),
 456         NULL,
 457         Sequence<double>(4),
 458         rendering::CompositeOperation::SOURCE);
 459     PresenterCanvasHelper::SetDeviceColor(aRenderState, mpFont->mnColor);
 460
 461     for (::std::vector<SharedPresenterTextParagraph>::const_iterator
 462              iParagraph(maParagraphs.begin()),
 463              iEnd(maParagraphs.end());
 464          iParagraph!=iEnd;
 465          ++iParagraph)
 466     {
 467         (*iParagraph)->Paint(
 468             mxCanvas,
 469             maSize,
 470             mpFont,
 471             aViewState,
 472             aRenderState,
 473             mnTopOffset,
 474             nClipTop,
 475             nClipBottom);
 476     }
 477
 478     aRenderState.AffineTransform.m02 = 0;
 479     aRenderState.AffineTransform.m12 = 0;
 480
 481 #ifdef SHOW_CHARACTER_BOXES
 482     PresenterCanvasHelper::SetDeviceColor(aRenderState, 0x00808080);
 483     for (sal_Int32 nParagraphIndex(0), nParagraphCount(GetParagraphCount());
 484          nParagraphIndex<nParagraphCount;
 485          ++nParagraphIndex)
 486     {
 487         const SharedPresenterTextParagraph pParagraph (GetParagraph(nParagraphIndex));
 488         if ( ! pParagraph)
 489             continue;
 490         for (sal_Int32 nCharacterIndex(0),nCharacterCount(pParagraph->GetCharacterCount());
 491              nCharacterIndex<nCharacterCount; ++nCharacterIndex)
 492         {
 493             const awt::Rectangle aBox (pParagraph->GetCharacterBounds(nCharacterIndex, false));
 494             mxCanvas->drawPolyPolygon (
 495                 PresenterGeometryHelper::CreatePolygon(
 496                     aBox,
 497                     mxCanvas->getDevice()),
 498                 aViewState,
 499                 aRenderState);
 500         }
 501     }
 502     PresenterCanvasHelper::SetDeviceColor(aRenderState, mpFont->mnColor);
 503 #endif
 504
 505     if (mpCaret && mpCaret->IsVisible())
 506     {
 507         mxCanvas->fillPolyPolygon (
 508             PresenterGeometryHelper::CreatePolygon(
 509                 mpCaret->GetBounds(),
 510                 mxCanvas->getDevice()),
 511             aViewState,
 512             aRenderState);
 513     }
 514 }
 515
 516
 517
 518
 519 SharedPresenterTextCaret PresenterTextView::GetCaret (void) const
 520 {
 521     return mpCaret;
 522 }
 523
 524
 525
 526
 527 sal_Int32 PresenterTextView::GetCharacterOffset (const sal_Int32 nParagraphIndex) const
 528 {
 529     sal_Int32 nCharacterOffset (0);
 530     for (sal_Int32 nIndex=0; nIndex<nParagraphIndex; ++nIndex)
 531         nCharacterOffset += maParagraphs[nIndex]->GetCharacterCount();
 532     return nCharacterOffset;
 533 }
 534
 535
 536
 537
 538 awt::Rectangle PresenterTextView::GetCaretBounds (
 539     sal_Int32 nParagraphIndex,
 540     const sal_Int32 nCharacterIndex) const
 541 {
 542     SharedPresenterTextParagraph pParagraph (GetParagraph(nParagraphIndex));
 543
 544     if (pParagraph)
 545         return pParagraph->GetCharacterBounds(nCharacterIndex, true);
 546     else
 547         return awt::Rectangle(0,0,0,0);
 548 }
 549
 550
 551
 552
 553 //----- private ---------------------------------------------------------------
 554
 555 void PresenterTextView::RequestFormat (void)
 556 {
 557     mbIsFormatPending = true;
 558 }
 559
 560
 561
 562
 563 void PresenterTextView::Format (void)
 564 {
 565     mbIsFormatPending = false;
 566
 567     double nY (0);
 568     for (::std::vector<SharedPresenterTextParagraph>::const_iterator
 569              iParagraph(maParagraphs.begin()),
 570              iEnd(maParagraphs.end());
 571          iParagraph!=iEnd;
 572          ++iParagraph)
 573     {
 574         (*iParagraph)->Format(nY, maSize.Width, mpFont);
 575         nY += (*iParagraph)->GetTotalTextHeight();
 576     }
 577
 578     if (maTextChangeBroadcaster)
 579         maTextChangeBroadcaster();
 580 }
 581
 582
 583
 584
 585 sal_Int32 PresenterTextView::GetParagraphCount (void) const
 586 {
 587     return maParagraphs.size();
 588 }
 589
 590
 591
 592
 593 SharedPresenterTextParagraph PresenterTextView::GetParagraph (
 594     const sal_Int32 nParagraphIndex) const
 595 {
 596     if (nParagraphIndex < 0)
 597         return SharedPresenterTextParagraph();
 598     else if (nParagraphIndex>=sal_Int32(maParagraphs.size()))
 599         return SharedPresenterTextParagraph();
 600     else
 601         return maParagraphs[nParagraphIndex];
 602 }
 603
 604
 605
 606
 607 //===== PresenterTextParagraph ================================================
 608
 609 PresenterTextParagraph::PresenterTextParagraph (
 610     const sal_Int32 nParagraphIndex,
 611     const Reference<i18n::XBreakIterator>& rxBreakIterator,
 612     const Reference<i18n::XScriptTypeDetector>& rxScriptTypeDetector,
 613     const Reference<text::XTextRange>& rxTextRange,
 614     const SharedPresenterTextCaret& rpCaret)
 615     : msParagraphText(),
 616       mnParagraphIndex(nParagraphIndex),
 617       mpCaret(rpCaret),
 618       mxBreakIterator(rxBreakIterator),
 619       mxScriptTypeDetector(rxScriptTypeDetector),
 620       maLines(),
 621       mnVerticalOffset(0),
 622       mnXOrigin(0),
 623       mnYOrigin(0),
 624       mnWidth(0),
 625       mnAscent(0),
 626       mnDescent(0),
 627       mnLineHeight(-1),
 628       meAdjust(style::ParagraphAdjust_LEFT),
 629       mnWritingMode (text::WritingMode2::LR_TB),
 630       mnCharacterOffset(0),
 631       maCells()
 632 {
 633     if (rxTextRange.is())
 634     {
 635         Reference<beans::XPropertySet> xProperties (rxTextRange, UNO_QUERY);
 636         lang::Locale aLocale;
 637         try
 638         {
 639             xProperties->getPropertyValue(A2S("CharLocale")) >>= aLocale;
 640         }
 641         catch(beans::UnknownPropertyException&)
 642         {
 643             // Ignore the exception.  Use the default value.
 644         }
 645         try
 646         {
 647             xProperties->getPropertyValue(A2S("ParaAdjust")) >>= meAdjust;
 648         }
 649         catch(beans::UnknownPropertyException&)
 650         {
 651             // Ignore the exception.  Use the default value.
 652         }
 653         try
 654         {
 655             xProperties->getPropertyValue(A2S("WritingMode")) >>= mnWritingMode;
 656         }
 657         catch(beans::UnknownPropertyException&)
 658         {
 659             // Ignore the exception.  Use the default value.
 660         }
 661
 662         msParagraphText = rxTextRange->getString();
 663     }
 664 }
 665
 666
 667
 668
 669 PresenterTextParagraph::PresenterTextParagraph (
 670     const sal_Int32 nParagraphIndex,
 671     const Reference<i18n::XBreakIterator>& rxBreakIterator,
 672     const Reference<i18n::XScriptTypeDetector>& rxScriptTypeDetector,
 673     const ::rtl::OUString& rsText,
 674     const SharedPresenterTextCaret& rpCaret)
 675     : msParagraphText(rsText),
 676       mnParagraphIndex(nParagraphIndex),
 677       mpCaret(rpCaret),
 678       mxBreakIterator(rxBreakIterator),
 679       mxScriptTypeDetector(rxScriptTypeDetector),
 680       maLines(),
 681       mnVerticalOffset(0),
 682       mnXOrigin(0),
 683       mnYOrigin(0),
 684       mnWidth(0),
 685       mnAscent(0),
 686       mnDescent(0),
 687       mnLineHeight(-1),
 688       meAdjust(style::ParagraphAdjust_LEFT),
 689       mnWritingMode (text::WritingMode2::LR_TB),
 690       mnCharacterOffset(0),
 691       maCells()
 692 {
 693 }
 694
 695
 696
 697
 698 void PresenterTextParagraph::Paint (
 699     const Reference<rendering::XCanvas>& rxCanvas,
 700     const geometry::RealSize2D& rSize,
 701     const PresenterTheme::SharedFontDescriptor& rpFont,
 702     const rendering::ViewState& rViewState,
 703     rendering::RenderState& rRenderState,
 704     const double nTopOffset,
 705     const double nClipTop,
 706     const double nClipBottom)
 707 {
 708     if (mnLineHeight <= 0)
 709         return;
 710
 711     sal_Int8 nTextDirection (GetTextDirection());
 712
 713     const double nSavedM12 (rRenderState.AffineTransform.m12);
 714
 715     if ( ! IsTextReferencePointLeft())
 716         rRenderState.AffineTransform.m02 += rSize.Width;
 717
 718
 719 #ifdef SHOW_CHARACTER_BOXES
 720     for (sal_Int32 nIndex=0,nCount=maLines.size();
 721          nIndex<nCount;
 722          ++nIndex)
 723     {
 724         Line& rLine (maLines[nIndex]);
 725         rLine.ProvideLayoutedLine(msParagraphText, rpFont, nTextDirection);
 726     }
 727 #endif
 728
 729     for (sal_Int32 nIndex=0,nCount=maLines.size();
 730          nIndex<nCount;
 731          ++nIndex, rRenderState.AffineTransform.m12 += mnLineHeight)
 732     {
 733         Line& rLine (maLines[nIndex]);
 734
 735         // Paint only visible lines.
 736         const double nLineTop = rLine.mnBaseLine - mnAscent - nTopOffset;
 737         if (nLineTop + mnLineHeight< nClipTop)
 738             continue;
 739         else if (nLineTop > nClipBottom)
 740             break;
 741         rLine.ProvideLayoutedLine(msParagraphText, rpFont, nTextDirection);
 742
 743         rRenderState.AffineTransform.m12 = nSavedM12 + rLine.mnBaseLine;
 744
 745         rxCanvas->drawTextLayout (
 746             rLine.mxLayoutedLine,
 747             rViewState,
 748             rRenderState);
 749     }
 750     rRenderState.AffineTransform.m12 = nSavedM12;
 751
 752     if ( ! IsTextReferencePointLeft())
 753         rRenderState.AffineTransform.m02 -= rSize.Width;
 754 }
 755
 756
 757
 758
 759 void PresenterTextParagraph::Format (
 760     const double nY,
 761     const double nWidth,
 762     const PresenterTheme::SharedFontDescriptor& rpFont)
 763 {
 764     // Make sure that the text view is in a valid and sane state.
 765     if ( ! mxBreakIterator.is() || ! mxScriptTypeDetector.is())
 766         return;
 767     if (nWidth<=0)
 768         return;
 769     if ( ! rpFont || ! rpFont->mxFont.is())
 770         return;
 771
 772     sal_Int32 nPosition (0);
 773
 774     mnWidth = nWidth;
 775     maLines.clear();
 776     mnLineHeight = 0;
 777     mnAscent = 0;
 778     mnDescent = 0;
 779     mnVerticalOffset = nY;
 780     maWordBoundaries.clear();
 781     maWordBoundaries.push_back(0);
 782
 783     const rendering::FontMetrics aMetrics (rpFont->mxFont->getFontMetrics());
 784     mnAscent = aMetrics.Ascent;
 785     mnDescent = aMetrics.Descent;
 786     mnLineHeight = aMetrics.Ascent + aMetrics.Descent + aMetrics.ExternalLeading;
 787     nPosition = 0;
 788     i18n::Boundary aCurrentLine(0,0);
 789     while (true)
 790     {
 791         const i18n::Boundary aWordBoundary = mxBreakIterator->nextWord(
 792             msParagraphText,
 793             nPosition,
 794             lang::Locale(),
 795             i18n::WordType::ANYWORD_IGNOREWHITESPACES);
 796         AddWord(nWidth, aCurrentLine, aWordBoundary.startPos, rpFont);
 797
 798         // Remember the new word boundary for caret travelling by words.
 799         // Prevent duplicates.
 800         if (aWordBoundary.startPos > maWordBoundaries.back())
 801             maWordBoundaries.push_back(aWordBoundary.startPos);
 802
 803         if (aWordBoundary.endPos>aWordBoundary.startPos)
 804             AddWord(nWidth, aCurrentLine, aWordBoundary.endPos, rpFont);
 805
 806         if (aWordBoundary.startPos<0 || aWordBoundary.endPos<0)
 807             break;
 808         if (nPosition >= aWordBoundary.endPos)
 809             break;
 810         nPosition = aWordBoundary.endPos;
 811     }
 812
 813     if (aCurrentLine.endPos>aCurrentLine.startPos)
 814         AddLine(aCurrentLine);
 815
 816 }
 817
 818
 819
 820
 821 sal_Int32 PresenterTextParagraph::GetWordBoundary(
 822     const sal_Int32 nLocalCharacterIndex,
 823     const sal_Int32 nDistance)
 824 {
 825     OSL_ASSERT(nDistance==-1 || nDistance==+1);
 826
 827     if (nLocalCharacterIndex < 0)
 828     {
 829         // The caller asked for the start or end position of the paragraph.
 830         if (nDistance < 0)
 831             return 0;
 832         else
 833             return GetCharacterCount();
 834     }
 835
 836     sal_Int32 nIndex (0);
 837     for (sal_Int32 nCount (maWordBoundaries.size()); nIndex<nCount; ++nIndex)
 838     {
 839         if (maWordBoundaries[nIndex] >= nLocalCharacterIndex)
 840         {
 841             // When inside the word (not at its start or end) then
 842             // first move to the start or end before going the previous or
 843             // next word.
 844             if (maWordBoundaries[nIndex] > nLocalCharacterIndex)
 845                 if (nDistance > 0)
 846                     --nIndex;
 847             break;
 848         }
 849     }
 850
 851     nIndex += nDistance;
 852
 853     if (nIndex < 0)
 854         return -1;
 855     else if (sal_uInt32(nIndex)>=maWordBoundaries.size())
 856         return -1;
 857     else
 858         return maWordBoundaries[nIndex];
 859 }
 860
 861
 862
 863
 864 sal_Int32 PresenterTextParagraph::GetCaretPosition (void) const
 865 {
 866     if (mpCaret && mpCaret->GetParagraphIndex()==mnParagraphIndex)
 867         return mpCaret->GetCharacterIndex();
 868     else
 869         return -1;
 870 }
 871
 872
 873
 874
 875 void PresenterTextParagraph::SetCaretPosition (const sal_Int32 nPosition) const
 876 {
 877     if (mpCaret && mpCaret->GetParagraphIndex()==mnParagraphIndex)
 878         return mpCaret->SetPosition(mnParagraphIndex, nPosition);
 879 }
 880
 881
 882
 883
 884 void PresenterTextParagraph::SetOrigin (const double nXOrigin, const double nYOrigin)
 885 {
 886     mnXOrigin = nXOrigin;
 887     mnYOrigin = nYOrigin;
 888 }
 889
 890
 891
 892
 893 awt::Point PresenterTextParagraph::GetRelativeLocation (void) const
 894 {
 895     return awt::Point(
 896         sal_Int32(mnXOrigin),
 897         sal_Int32(mnYOrigin + mnVerticalOffset));
 898 }
 899
 900
 901
 902
 903 awt::Size PresenterTextParagraph::GetSize (void)
 904 {
 905     return awt::Size(
 906         sal_Int32(mnWidth),
 907         sal_Int32(GetTotalTextHeight()));
 908 }
 909
 910
 911
 912
 913 void PresenterTextParagraph::AddWord (
 914     const double nWidth,
 915     i18n::Boundary& rCurrentLine,
 916     const sal_Int32 nWordBoundary,
 917     const PresenterTheme::SharedFontDescriptor& rpFont)
 918 {
 919     sal_Int32 nLineStart (0);
 920     sal_Int32 nLineEnd (0);
 921     if ( ! maLines.empty())
 922     {
 923         nLineStart = rCurrentLine.startPos;
 924         nLineEnd = rCurrentLine.endPos;
 925     }
 926
 927     const ::rtl::OUString sLineCandidate (
 928         msParagraphText.copy(nLineStart, nWordBoundary-nLineStart));
 929
 930     css::geometry::RealRectangle2D aLineBox (
 931         PresenterCanvasHelper::GetTextBoundingBox (
 932             rpFont->mxFont,
 933             sLineCandidate,
 934             mnWritingMode));
 935     const double nLineWidth (aLineBox.X2 - aLineBox.X1);
 936
 937     if (nLineWidth >= nWidth)
 938     {
 939         // Add new line with a single word (so far).
 940         AddLine(rCurrentLine);
 941     }
 942     rCurrentLine.endPos = nWordBoundary;
 943 }
 944
 945
 946
 947
 948 void PresenterTextParagraph::AddLine (
 949     i18n::Boundary& rCurrentLine)
 950 {
 951     Line aLine (rCurrentLine.startPos, rCurrentLine.endPos);
 952
 953     // Find the start and end of the line with respect to cells.
 954     if (maLines.size() > 0)
 955     {
 956         aLine.mnLineStartCellIndex = maLines.back().mnLineEndCellIndex;
 957         aLine.mnBaseLine = maLines.back().mnBaseLine + mnLineHeight;
 958     }
 959     else
 960     {
 961         aLine.mnLineStartCellIndex = 0;
 962         aLine.mnBaseLine = mnVerticalOffset + mnAscent;
 963     }
 964     sal_Int32 nCellIndex (aLine.mnLineStartCellIndex);
 965     double nWidth (0);
 966     for ( ; nCellIndex<sal_Int32(maCells.size()); ++nCellIndex)
 967     {
 968         const Cell& rCell (maCells[nCellIndex]);
 969         if (rCell.mnCharacterIndex+rCell.mnCharacterCount > aLine.mnLineEndCharacterIndex)
 970             break;
 971         nWidth += rCell.mnCellWidth;
 972     }
 973     aLine.mnLineEndCellIndex = nCellIndex;
 974     aLine.mnWidth = nWidth;
 975
 976     maLines.push_back(aLine);
 977
 978     rCurrentLine.startPos = rCurrentLine.endPos;
 979 }
 980
 981
 982
 983
 984 sal_Int32 PresenterTextParagraph::GetParagraphIndex (void) const
 985 {
 986     return mnParagraphIndex;
 987 }
 988
 989
 990
 991
 992 double PresenterTextParagraph::GetTotalTextHeight (void)
 993 {
 994     return maLines.size() * mnLineHeight;
 995 }
 996
 997
 998
 999
1000 sal_Int32 PresenterTextParagraph::GetCharacterOffset (void) const
1001 {
1002     return mnCharacterOffset;
1003 }
1004
1005
1006
1007
1008 void PresenterTextParagraph::SetCharacterOffset (const sal_Int32 nCharacterOffset)
1009 {
1010     mnCharacterOffset = nCharacterOffset;
1011 }
1012
1013
1014
1015
1016 sal_Int32 PresenterTextParagraph::GetCharacterCount (void) const
1017 {
1018     return msParagraphText.getLength();
1019 }
1020
1021
1022
1023
1024 sal_Unicode PresenterTextParagraph::GetCharacter (
1025     const sal_Int32 nGlobalCharacterIndex) const
1026 {
1027     if (nGlobalCharacterIndex<mnCharacterOffset
1028         || nGlobalCharacterIndex>=mnCharacterOffset+msParagraphText.getLength())
1029     {
1030         return sal_Unicode();
1031     }
1032     else
1033     {
1034         return msParagraphText.getStr()[nGlobalCharacterIndex - mnCharacterOffset];
1035     }
1036 }
1037
1038
1039
1040
1041 ::rtl::OUString PresenterTextParagraph::GetText (void) const
1042 {
1043     return msParagraphText;
1044 }
1045
1046
1047
1048
1049 TextSegment PresenterTextParagraph::GetTextSegment (
1050     const sal_Int32 nOffset,
1051     const sal_Int32 nIndex,
1052     const sal_Int16 nTextType) const
1053 {
1054     switch(nTextType)
1055     {
1056         case AccessibleTextType::PARAGRAPH:
1057             return TextSegment(
1058                 msParagraphText,
1059                 mnCharacterOffset,
1060                 mnCharacterOffset+msParagraphText.getLength());
1061
1062         case AccessibleTextType::SENTENCE:
1063             if (mxBreakIterator.is())
1064             {
1065                 const sal_Int32 nStart (mxBreakIterator->beginOfSentence(
1066                     msParagraphText, nIndex-mnCharacterOffset, lang::Locale()));
1067                 const sal_Int32 nEnd (mxBreakIterator->endOfSentence(
1068                     msParagraphText, nIndex-mnCharacterOffset, lang::Locale()));
1069                 if (nStart < nEnd)
1070                     return TextSegment(
1071                         msParagraphText.copy(nStart, nEnd-nStart),
1072                         nStart+mnCharacterOffset,
1073                         nEnd+mnCharacterOffset);
1074             }
1075             break;
1076
1077         case AccessibleTextType::WORD:
1078             if (mxBreakIterator.is())
1079                 return GetWordTextSegment(nOffset, nIndex);
1080             break;
1081
1082         case AccessibleTextType::LINE:
1083         {
1084             for (::std::vector<Line>::const_iterator
1085                      iLine(maLines.begin()),
1086                      iEnd(maLines.end());
1087                  iLine!=iEnd;
1088                  ++iLine)
1089             {
1090                 if (nIndex < iLine->mnLineEndCharacterIndex)
1091                 {
1092                     return TextSegment(
1093                         msParagraphText.copy(
1094                             iLine->mnLineStartCharacterIndex,
1095                             iLine->mnLineEndCharacterIndex - iLine->mnLineStartCharacterIndex),
1096                         iLine->mnLineStartCharacterIndex,
1097                         iLine->mnLineEndCharacterIndex);
1098                 }
1099             }
1100         }
1101         break;
1102
1103         // Handle GLYPH and ATTRIBUTE_RUN like CHARACTER because we can not
1104         // do better at the moment.
1105         case AccessibleTextType::CHARACTER:
1106         case AccessibleTextType::GLYPH:
1107         case AccessibleTextType::ATTRIBUTE_RUN:
1108             return CreateTextSegment(nIndex+nOffset, nIndex+nOffset+1);
1109     }
1110
1111     return TextSegment(::rtl::OUString(), 0,0);
1112 }
1113
1114
1115
1116
1117 TextSegment PresenterTextParagraph::GetWordTextSegment (
1118     const sal_Int32 nOffset,
1119     const sal_Int32 nIndex) const
1120 {
1121     sal_Int32 nCurrentOffset (nOffset);
1122     sal_Int32 nCurrentIndex (nIndex);
1123
1124     i18n::Boundary aWordBoundary;
1125     if (nCurrentOffset == 0)
1126         aWordBoundary = mxBreakIterator->getWordBoundary(
1127             msParagraphText,
1128             nIndex,
1129             lang::Locale(),
1130             i18n::WordType::ANYWORD_IGNOREWHITESPACES,
1131             sal_True);
1132     else if (nCurrentOffset < 0)
1133     {
1134         while (nCurrentOffset<0 && nCurrentIndex>0)
1135         {
1136             aWordBoundary = mxBreakIterator->previousWord(
1137                 msParagraphText,
1138                 nCurrentIndex,
1139                 lang::Locale(),
1140                 i18n::WordType::ANYWORD_IGNOREWHITESPACES);
1141             nCurrentIndex = aWordBoundary.startPos;
1142             ++nCurrentOffset;
1143         }
1144     }
1145     else
1146     {
1147         while (nCurrentOffset>0 && nCurrentIndex<=GetCharacterCount())
1148         {
1149             aWordBoundary = mxBreakIterator->nextWord(
1150                 msParagraphText,
1151                 nCurrentIndex,
1152                 lang::Locale(),
1153                 i18n::WordType::ANYWORD_IGNOREWHITESPACES);
1154             nCurrentIndex = aWordBoundary.endPos;
1155             --nCurrentOffset;
1156         }
1157     }
1158
1159     return CreateTextSegment(aWordBoundary.startPos, aWordBoundary.endPos);
1160 }
1161
1162
1163
1164
1165 TextSegment PresenterTextParagraph::CreateTextSegment (
1166     sal_Int32 nStartIndex,
1167     sal_Int32 nEndIndex) const
1168 {
1169     if (nEndIndex <= nStartIndex)
1170         return TextSegment(
1171             ::rtl::OUString(),
1172             nStartIndex,
1173             nEndIndex);
1174     else
1175         return TextSegment(
1176             msParagraphText.copy(nStartIndex, nEndIndex-nStartIndex),
1177             nStartIndex,
1178             nEndIndex);
1179 }
1180
1181
1182
1183
1184 awt::Rectangle PresenterTextParagraph::GetCharacterBounds (
1185     sal_Int32 nGlobalCharacterIndex,
1186     const bool bCaretBox)
1187 {
1188     // Find the line that contains the requested character and accumulate
1189     // the previous line heights.
1190     sal_Int32 nFirstCharacterIndex (0);
1191     sal_Int32 nEndCharacterIndex (0);
1192     double nX (mnXOrigin);
1193     double nY (mnYOrigin + mnVerticalOffset + mnAscent);
1194     const sal_Int8 nTextDirection (GetTextDirection());
1195     for (sal_Int32 nLineIndex=0,nLineCount=maLines.size();
1196          nLineIndex<nLineCount;
1197          ++nLineIndex, nFirstCharacterIndex=nEndCharacterIndex, nY+=mnLineHeight)
1198     {
1199         Line& rLine (maLines[nLineIndex]);
1200         // Skip lines before the indexed character.
1201         if (nGlobalCharacterIndex >= rLine.mnLineEndCharacterIndex)
1202             // When in the last line then allow the index past the last char.
1203             if (nLineIndex<nLineCount-1)
1204                 continue;
1205
1206         rLine.ProvideCellBoxes();
1207
1208         const sal_Int32 nCellIndex (nGlobalCharacterIndex - rLine.mnLineStartCharacterIndex);
1209
1210         // The cell bounding box is defined relative to the origin of
1211         // the current line.  Therefore we have to add the absolute
1212         // position of the line.
1213         geometry::RealRectangle2D rCellBox (rLine.maCellBoxes[
1214             ::std::min(nCellIndex, rLine.maCellBoxes.getLength()-1)]);
1215
1216         double nLeft = nX + rCellBox.X1;
1217         double nRight = nX + rCellBox.X2;
1218         if (nTextDirection == rendering::TextDirection::WEAK_RIGHT_TO_LEFT)
1219         {
1220             const double nOldRight (nRight);
1221             nRight = rLine.mnWidth - nLeft;
1222             nLeft = rLine.mnWidth - nOldRight;
1223         }
1224         double nTop (nY + rCellBox.Y1);
1225         double nBottom (nY + rCellBox.Y2);
1226         if (bCaretBox)
1227         {
1228             nTop = nTop - rCellBox.Y1 - mnAscent;
1229             nBottom = nTop + mnLineHeight;
1230             if (nCellIndex >= rLine.maCellBoxes.getLength())
1231                 nLeft = nRight-2;
1232             if (nLeft < nX)
1233                 nLeft = nX;
1234             nRight = nLeft+2;
1235         }
1236         else
1237         {
1238             nTop = nTop - rCellBox.Y1 - mnAscent;
1239             nBottom = nTop + mnAscent + mnDescent;
1240         }
1241         const sal_Int32 nX1 = sal_Int32(floor(nLeft));
1242         const sal_Int32 nY1 = sal_Int32(floor(nTop));
1243         const sal_Int32 nX2 = sal_Int32(ceil(nRight));
1244         const sal_Int32 nY2 = sal_Int32(ceil(nBottom));
1245
1246         return awt::Rectangle(nX1,nY1,nX2-nX1+1,nY2-nY1+1);
1247     }
1248
1249     // We are still here.  That means that the given index lies past the
1250     // last character in the paragraph.
1251     // Return an empty box that lies past the last character.  Better than nothing.
1252     return awt::Rectangle(sal_Int32(nX+0.5), sal_Int32(nY+0.5), 0, 0);
1253 }
1254
1255
1256
1257
1258 sal_Int32 PresenterTextParagraph::GetIndexAtPoint (const awt::Point& rPoint) const
1259 {
1260     (void)rPoint;
1261     return -1;
1262 }
1263
1264
1265
1266
1267 sal_Int8 PresenterTextParagraph::GetTextDirection (void) const
1268 {
1269     // Find first portion that has a non-neutral text direction.
1270     sal_Int32 nPosition (0);
1271     sal_Int32 nTextLength (msParagraphText.getLength());
1272     while (nPosition < nTextLength)
1273     {
1274         const sal_Int16 nScriptDirection (
1275             mxScriptTypeDetector->getScriptDirection(
1276                 msParagraphText, nPosition, i18n::ScriptDirection::NEUTRAL));
1277         switch (nScriptDirection)
1278         {
1279             case i18n::ScriptDirection::NEUTRAL:
1280                 // continue looping.
1281                 break;
1282             case i18n::ScriptDirection::LEFT_TO_RIGHT:
1283                 return rendering::TextDirection::WEAK_LEFT_TO_RIGHT;
1284
1285             case i18n::ScriptDirection::RIGHT_TO_LEFT:
1286                 return rendering::TextDirection::WEAK_RIGHT_TO_LEFT;
1287         }
1288
1289         nPosition = mxScriptTypeDetector->endOfScriptDirection(
1290             msParagraphText, nPosition, nScriptDirection);
1291     }
1292
1293     // All text in paragraph is neutral.  Fall back on writing mode taken
1294     // from the XText (which may not be properly initialized.)
1295     sal_Int8 nTextDirection(rendering::TextDirection::WEAK_LEFT_TO_RIGHT);
1296     switch(mnWritingMode)
1297     {
1298         case text::WritingMode2::LR_TB:
1299             nTextDirection = rendering::TextDirection::WEAK_LEFT_TO_RIGHT;
1300             break;
1301
1302         case text::WritingMode2::RL_TB:
1303             nTextDirection = rendering::TextDirection::WEAK_RIGHT_TO_LEFT;
1304             break;
1305
1306         default:
1307         case text::WritingMode2::TB_RL:
1308         case text::WritingMode2::TB_LR:
1309             // Can not handle this.  Use default and hope for the best.
1310             break;
1311     }
1312     return nTextDirection;
1313 }
1314
1315
1316
1317
1318 bool PresenterTextParagraph::IsTextReferencePointLeft (void) const
1319 {
1320     return mnWritingMode != text::WritingMode2::RL_TB;
1321 }
1322
1323
1324
1325
1326 void PresenterTextParagraph::SetupCellArray (
1327     const PresenterTheme::SharedFontDescriptor& rpFont)
1328 {
1329     maCells.clear();
1330
1331     if ( ! rpFont || ! rpFont->mxFont.is())
1332         return;
1333
1334     sal_Int32 nPosition (0);
1335     sal_Int32 nIndex (0);
1336     const sal_Int32 nTextLength (msParagraphText.getLength());
1337     const sal_Int8 nTextDirection (GetTextDirection());
1338     while (nPosition < nTextLength)
1339     {
1340         const sal_Int32 nNewPosition (mxBreakIterator->nextCharacters(
1341             msParagraphText,
1342             nPosition,
1343             lang::Locale(),
1344             i18n::CharacterIteratorMode::SKIPCELL,
1345             1,
1346             nIndex));
1347
1348         rendering::StringContext aContext (msParagraphText, nPosition, nNewPosition-nPosition);
1349         Reference<rendering::XTextLayout> xLayout (
1350             rpFont->mxFont->createTextLayout(aContext, nTextDirection, 0));
1351         css::geometry::RealRectangle2D aCharacterBox (xLayout->queryTextBounds());
1352
1353         maCells.push_back(Cell(
1354             nPosition,
1355             nNewPosition-nPosition,
1356             aCharacterBox.X2-aCharacterBox.X1));
1357
1358         nPosition = nNewPosition;
1359     }
1360 }
1361
1362
1363
1364
1365 //===== PresenterTextCaret ================================================----
1366
1367 PresenterTextCaret::PresenterTextCaret (
1368     const ::boost::function<css::awt::Rectangle(const sal_Int32,const sal_Int32)>& rCharacterBoundsAccess,
1369     const ::boost::function<void(const css::awt::Rectangle&)>& rInvalidator)
1370     : mnParagraphIndex(-1),
1371       mnCharacterIndex(-1),
1372       mnCaretBlinkTaskId(0),
1373       mbIsCaretVisible(false),
1374       maCharacterBoundsAccess(rCharacterBoundsAccess),
1375       maInvalidator(rInvalidator),
1376       maBroadcaster(),
1377       maCaretBounds()
1378 {
1379 }
1380
1381
1382
1383
1384 PresenterTextCaret::~PresenterTextCaret (void)
1385 {
1386     HideCaret();
1387 }
1388
1389
1390
1391
1392 void PresenterTextCaret::ShowCaret (void)
1393 {
1394     if (mnCaretBlinkTaskId == 0)
1395     {
1396         mnCaretBlinkTaskId = PresenterTimer::ScheduleRepeatedTask (
1397             ::boost::bind(&PresenterTextCaret::InvertCaret, this),
1398             CaretBlinkIntervall,
1399             CaretBlinkIntervall);
1400     }
1401     mbIsCaretVisible = true;
1402 }
1403
1404
1405
1406
1407 void PresenterTextCaret::HideCaret (void)
1408 {
1409     if (mnCaretBlinkTaskId != 0)
1410     {
1411         PresenterTimer::CancelTask(mnCaretBlinkTaskId);
1412         mnCaretBlinkTaskId = 0;
1413     }
1414     mbIsCaretVisible = false;
1415     // Reset the caret position.
1416     mnParagraphIndex = -1;
1417     mnCharacterIndex = -1;
1418 }
1419
1420
1421
1422
1423 sal_Int32 PresenterTextCaret::GetParagraphIndex (void) const
1424 {
1425     return mnParagraphIndex;
1426 }
1427
1428
1429
1430
1431 sal_Int32 PresenterTextCaret::GetCharacterIndex (void) const
1432 {
1433     return mnCharacterIndex;
1434 }
1435
1436
1437
1438
1439 void PresenterTextCaret::SetPosition (
1440     const sal_Int32 nParagraphIndex,
1441     const sal_Int32 nCharacterIndex)
1442 {
1443     if (mnParagraphIndex != nParagraphIndex
1444         || mnCharacterIndex != nCharacterIndex)
1445     {
1446         if (mnParagraphIndex >= 0)
1447             maInvalidator(maCaretBounds);
1448
1449         const sal_Int32 nOldParagraphIndex (mnParagraphIndex);
1450         const sal_Int32 nOldCharacterIndex (mnCharacterIndex);
1451         mnParagraphIndex = nParagraphIndex;
1452         mnCharacterIndex = nCharacterIndex;
1453         maCaretBounds = maCharacterBoundsAccess(mnParagraphIndex, mnCharacterIndex);
1454         if (mnParagraphIndex >= 0)
1455             ShowCaret();
1456         else
1457             HideCaret();
1458
1459         if (mnParagraphIndex >= 0)
1460             maInvalidator(maCaretBounds);
1461
1462         if (maBroadcaster)
1463             maBroadcaster(
1464                 nOldParagraphIndex,
1465                 nOldCharacterIndex,
1466                 mnParagraphIndex,
1467                 mnCharacterIndex);
1468
1469     }
1470 }
1471
1472
1473
1474
1475 bool PresenterTextCaret::IsVisible (void) const
1476 {
1477     return mbIsCaretVisible;
1478 }
1479
1480
1481
1482
1483 void PresenterTextCaret::SetCaretMotionBroadcaster (
1484     const ::boost::function<void(sal_Int32,sal_Int32,sal_Int32,sal_Int32)>& rBroadcaster)
1485 {
1486     maBroadcaster = rBroadcaster;
1487 }
1488
1489
1490
1491
1492 css::awt::Rectangle PresenterTextCaret::GetBounds (void) const
1493 {
1494     return maCaretBounds;
1495 }
1496
1497
1498
1499
1500 void PresenterTextCaret::InvertCaret (void)
1501 {
1502     mbIsCaretVisible = !mbIsCaretVisible;
1503     if (mnParagraphIndex >= 0)
1504         maInvalidator(maCaretBounds);
1505 }
1506
1507
1508
1509
1510
1511
1512
1513 //===== PresenterTextParagraph::Cell ==========================================
1514
1515 PresenterTextParagraph::Cell::Cell (
1516     const sal_Int32 nCharacterIndex,
1517     const sal_Int32 nCharacterCount,
1518     const double nCellWidth)
1519     : mnCharacterIndex(nCharacterIndex),
1520       mnCharacterCount(nCharacterCount),
1521       mnCellWidth(nCellWidth)
1522 {
1523 }
1524
1525
1526
1527
1528 //===== PresenterTextParagraph::Line ==========================================
1529
1530 PresenterTextParagraph::Line::Line (
1531     const sal_Int32 nLineStartCharacterIndex,
1532     const sal_Int32 nLineEndCharacterIndex)
1533     : mnLineStartCharacterIndex(nLineStartCharacterIndex),
1534       mnLineEndCharacterIndex(nLineEndCharacterIndex),
1535       mnLineStartCellIndex(-1), mnLineEndCellIndex(-1),
1536       mxLayoutedLine(),
1537       mnBaseLine(0), mnWidth(0),
1538       maCellBoxes()
1539 {
1540 }
1541
1542
1543
1544
1545 sal_Int32 PresenterTextParagraph::Line::GetLength (void) const
1546 {
1547     return mnLineEndCharacterIndex-mnLineStartCharacterIndex;
1548 }
1549
1550
1551
1552
1553 void PresenterTextParagraph::Line::ProvideCellBoxes (void)
1554 {
1555     if ( ! IsEmpty() && maCellBoxes.getLength()==0)
1556     {
1557         if (mxLayoutedLine.is())
1558             maCellBoxes = mxLayoutedLine->queryInkMeasures();
1559         else
1560         {
1561             OSL_ASSERT(mxLayoutedLine.is());
1562         }
1563     }
1564 }
1565
1566
1567
1568
1569 void PresenterTextParagraph::Line::ProvideLayoutedLine (
1570     const ::rtl::OUString& rsParagraphText,
1571     const PresenterTheme::SharedFontDescriptor& rpFont,
1572     const sal_Int8 nTextDirection)
1573 {
1574     if ( ! mxLayoutedLine.is())
1575     {
1576         const rendering::StringContext aContext (
1577             rsParagraphText,
1578             mnLineStartCharacterIndex,
1579             mnLineEndCharacterIndex - mnLineStartCharacterIndex);
1580
1581         mxLayoutedLine = rpFont->mxFont->createTextLayout(
1582             aContext,
1583             nTextDirection,
1584             0);
1585     }
1586 }
1587
1588
1589
1590
1591 bool PresenterTextParagraph::Line::IsEmpty (void) const
1592 {
1593     return mnLineStartCharacterIndex >= mnLineEndCharacterIndex;
1594 }
1595
1596
1597
1598
1599 } } // end of namespace ::sdext::presenter