| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #include "precompiled_sdext.hxx" |
| |
| #include "PresenterTextView.hxx" |
| #include "PresenterCanvasHelper.hxx" |
| #include "PresenterGeometryHelper.hxx" |
| #include "PresenterTimer.hxx" |
| |
| #include <cmath> |
| |
| #include <com/sun/star/accessibility/AccessibleTextType.hpp> |
| #include <com/sun/star/container/XEnumerationAccess.hpp> |
| #include <com/sun/star/i18n/CharType.hpp> |
| #include <com/sun/star/i18n/CharacterIteratorMode.hpp> |
| #include <com/sun/star/i18n/CTLScriptType.hpp> |
| #include <com/sun/star/i18n/ScriptDirection.hpp> |
| #include <com/sun/star/i18n/WordType.hpp> |
| #include <com/sun/star/rendering/CompositeOperation.hpp> |
| #include <com/sun/star/rendering/TextDirection.hpp> |
| #include <com/sun/star/text/WritingMode2.hpp> |
| #include <boost/bind.hpp> |
| |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::accessibility; |
| using namespace ::com::sun::star::uno; |
| |
| #define A2S(pString) (::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(pString))) |
| |
| const static sal_Int64 CaretBlinkIntervall = 500 * 1000 * 1000; |
| |
| //#define SHOW_CHARACTER_BOXES |
| |
| namespace { |
| sal_Int32 Signum (const sal_Int32 nValue) |
| { |
| if (nValue < 0) |
| return -1; |
| else if (nValue > 0) |
| return +1; |
| else |
| return 0; |
| } |
| } |
| |
| namespace sdext { namespace presenter { |
| |
| |
| //===== PresenterTextView ===================================================== |
| |
| PresenterTextView::PresenterTextView ( |
| const Reference<XComponentContext>& rxContext, |
| const Reference<rendering::XCanvas>& rxCanvas, |
| const ::boost::function<void(const ::css::awt::Rectangle&)>& rInvalidator) |
| : mxCanvas(rxCanvas), |
| mbDoOuput(true), |
| mxBreakIterator(), |
| mxScriptTypeDetector(), |
| maLocation(0,0), |
| maSize(0,0), |
| mpFont(), |
| maParagraphs(), |
| mpCaret(new PresenterTextCaret( |
| ::boost::bind(&PresenterTextView::GetCaretBounds, this, _1, _2), |
| rInvalidator)), |
| mnLeftOffset(0), |
| mnTopOffset(0), |
| maInvalidator(rInvalidator), |
| mbIsFormatPending(false), |
| mnCharacterCount(-1), |
| maTextChangeBroadcaster() |
| { |
| Reference<lang::XMultiComponentFactory> xFactory ( |
| rxContext->getServiceManager(), UNO_QUERY); |
| if ( ! xFactory.is()) |
| return; |
| |
| // Create the break iterator that we use to break text into lines. |
| mxBreakIterator = Reference<i18n::XBreakIterator>( |
| xFactory->createInstanceWithContext( |
| A2S("com.sun.star.i18n.BreakIterator"), |
| rxContext), |
| UNO_QUERY_THROW); |
| |
| // Create the script type detector that is used to split paragraphs into |
| // portions of the same text direction. |
| mxScriptTypeDetector = Reference<i18n::XScriptTypeDetector>( |
| xFactory->createInstanceWithContext( |
| A2S("com.sun.star.i18n.ScriptTypeDetector"), |
| rxContext), |
| UNO_QUERY_THROW); |
| } |
| |
| |
| |
| |
| PresenterTextView::PresenterTextView ( |
| const Reference<XComponentContext>& rxContext, |
| const Reference<rendering::XCanvas>& rxCanvas) |
| : mxCanvas(rxCanvas), |
| mbDoOuput(false), |
| mxBreakIterator(), |
| mxScriptTypeDetector(), |
| maLocation(0,0), |
| maSize(0,0), |
| mpFont(), |
| maParagraphs(), |
| mpCaret(new PresenterTextCaret( |
| ::boost::bind(&PresenterTextView::GetCaretBounds, this, _1, _2), |
| ::boost::function<void(const css::awt::Rectangle&)>())), |
| mnLeftOffset(0), |
| mnTopOffset(0), |
| maInvalidator(), |
| mbIsFormatPending(false), |
| mnCharacterCount(-1), |
| maTextChangeBroadcaster() |
| { |
| Reference<lang::XMultiComponentFactory> xFactory ( |
| rxContext->getServiceManager(), UNO_QUERY); |
| if ( ! xFactory.is()) |
| return; |
| |
| // Create the break iterator that we use to break text into lines. |
| mxBreakIterator = Reference<i18n::XBreakIterator>( |
| xFactory->createInstanceWithContext( |
| A2S("com.sun.star.i18n.BreakIterator"), |
| rxContext), |
| UNO_QUERY_THROW); |
| |
| // Create the script type detector that is used to split paragraphs into |
| // portions of the same text direction. |
| mxScriptTypeDetector = Reference<i18n::XScriptTypeDetector>( |
| xFactory->createInstanceWithContext( |
| A2S("com.sun.star.i18n.ScriptTypeDetector"), |
| rxContext), |
| UNO_QUERY_THROW); |
| } |
| |
| |
| |
| |
| void PresenterTextView::SetText (const Reference<text::XText>& rxText) |
| { |
| maParagraphs.clear(); |
| mnCharacterCount = -1; |
| |
| Reference<container::XEnumerationAccess> xParagraphAccess (rxText, UNO_QUERY); |
| if ( ! xParagraphAccess.is()) |
| return; |
| |
| Reference<container::XEnumeration> xParagraphs ( |
| xParagraphAccess->createEnumeration() , UNO_QUERY); |
| if ( ! xParagraphs.is()) |
| return; |
| |
| if ( ! mpFont || ! mpFont->PrepareFont(mxCanvas)) |
| return; |
| |
| sal_Int32 nCharacterCount (0); |
| while (xParagraphs->hasMoreElements()) |
| { |
| SharedPresenterTextParagraph pParagraph (new PresenterTextParagraph( |
| maParagraphs.size(), |
| mxBreakIterator, |
| mxScriptTypeDetector, |
| Reference<text::XTextRange>(xParagraphs->nextElement(), UNO_QUERY), |
| mpCaret)); |
| pParagraph->SetupCellArray(mpFont); |
| pParagraph->SetCharacterOffset(nCharacterCount); |
| nCharacterCount += pParagraph->GetCharacterCount(); |
| maParagraphs.push_back(pParagraph); |
| } |
| |
| if (mpCaret) |
| mpCaret->HideCaret(); |
| |
| RequestFormat(); |
| } |
| |
| |
| |
| |
| void PresenterTextView::SetText (const ::rtl::OUString& rsText) |
| { |
| maParagraphs.clear(); |
| mnCharacterCount = -1; |
| |
| if ( ! mpFont || ! mpFont->PrepareFont(mxCanvas)) |
| return; |
| |
| sal_Int32 nCharacterCount (0); |
| |
| SharedPresenterTextParagraph pParagraph (new PresenterTextParagraph( |
| 0, |
| mxBreakIterator, |
| mxScriptTypeDetector, |
| rsText, |
| mpCaret)); |
| pParagraph->SetupCellArray(mpFont); |
| pParagraph->SetCharacterOffset(nCharacterCount); |
| nCharacterCount += pParagraph->GetCharacterCount(); |
| maParagraphs.push_back(pParagraph); |
| |
| if (mpCaret) |
| mpCaret->HideCaret(); |
| |
| RequestFormat(); |
| } |
| |
| |
| |
| |
| void PresenterTextView::SetTextChangeBroadcaster ( |
| const ::boost::function<void(void)>& rBroadcaster) |
| { |
| maTextChangeBroadcaster = rBroadcaster; |
| } |
| |
| |
| |
| |
| void PresenterTextView::SetLocation (const css::geometry::RealPoint2D& rLocation) |
| { |
| maLocation = rLocation; |
| |
| for (::std::vector<SharedPresenterTextParagraph>::iterator |
| iParagraph(maParagraphs.begin()), |
| iEnd(maParagraphs.end()); |
| iParagraph!=iEnd; |
| ++iParagraph) |
| { |
| (*iParagraph)->SetOrigin( |
| maLocation.X - mnLeftOffset, |
| maLocation.Y - mnTopOffset); |
| } |
| } |
| |
| |
| |
| |
| void PresenterTextView::SetSize (const css::geometry::RealSize2D& rSize) |
| { |
| maSize = rSize; |
| RequestFormat(); |
| } |
| |
| |
| |
| |
| double PresenterTextView::GetTotalTextHeight (void) |
| { |
| double nTotalHeight (0); |
| |
| if (mbIsFormatPending) |
| { |
| if ( ! mpFont->PrepareFont(mxCanvas)) |
| return 0; |
| Format(); |
| } |
| |
| for (::std::vector<SharedPresenterTextParagraph>::iterator |
| iParagraph(maParagraphs.begin()), |
| iEnd(maParagraphs.end()); |
| iParagraph!=iEnd; |
| ++iParagraph) |
| { |
| nTotalHeight += (*iParagraph)->GetTotalTextHeight(); |
| } |
| |
| return nTotalHeight; |
| } |
| |
| |
| |
| |
| void PresenterTextView::SetFont (const PresenterTheme::SharedFontDescriptor& rpFont) |
| { |
| mpFont = rpFont; |
| RequestFormat(); |
| } |
| |
| |
| |
| |
| void PresenterTextView::SetOffset( |
| const double nLeft, |
| const double nTop) |
| { |
| mnLeftOffset = nLeft; |
| mnTopOffset = nTop; |
| |
| // Trigger an update of the text origin stored at the individual paragraphs. |
| SetLocation(maLocation); |
| } |
| |
| |
| |
| void PresenterTextView::MoveCaret ( |
| const sal_Int32 nDistance, |
| const sal_Int16 nTextType) |
| { |
| if ( ! mpCaret) |
| return; |
| |
| // When the caret has not been visible yet then move it to the beginning |
| // of the text. |
| if (mpCaret->GetParagraphIndex() < 0) |
| { |
| mpCaret->SetPosition(0,0); |
| return; |
| } |
| |
| sal_Int32 nParagraphIndex (mpCaret->GetParagraphIndex()); |
| sal_Int32 nCharacterIndex (mpCaret->GetCharacterIndex()); |
| switch (nTextType) |
| { |
| default: |
| case AccessibleTextType::CHARACTER: |
| nCharacterIndex += nDistance; |
| break; |
| |
| case AccessibleTextType::WORD: |
| { |
| sal_Int32 nRemainingDistance (nDistance); |
| while (nRemainingDistance != 0) |
| { |
| SharedPresenterTextParagraph pParagraph (GetParagraph(nParagraphIndex)); |
| if (pParagraph) |
| { |
| const sal_Int32 nDelta (Signum(nDistance)); |
| nCharacterIndex = pParagraph->GetWordBoundary(nCharacterIndex, nDelta); |
| if (nCharacterIndex < 0) |
| { |
| // Go to previous or next paragraph. |
| nParagraphIndex += nDelta; |
| if (nParagraphIndex < 0) |
| { |
| nParagraphIndex = 0; |
| nCharacterIndex = 0; |
| nRemainingDistance = 0; |
| } |
| else if (sal_uInt32(nParagraphIndex) >= maParagraphs.size()) |
| { |
| nParagraphIndex = maParagraphs.size()-1; |
| pParagraph = GetParagraph(nParagraphIndex); |
| if (pParagraph) |
| nCharacterIndex = pParagraph->GetCharacterCount(); |
| nRemainingDistance = 0; |
| } |
| else |
| { |
| nRemainingDistance -= nDelta; |
| |
| // Move caret one character to the end of |
| // the previous or the start of the next paragraph. |
| pParagraph = GetParagraph(nParagraphIndex); |
| if (pParagraph) |
| { |
| if (nDistance<0) |
| nCharacterIndex = pParagraph->GetCharacterCount(); |
| else |
| nCharacterIndex = 0; |
| } |
| } |
| } |
| else |
| nRemainingDistance -= nDelta; |
| } |
| else |
| break; |
| } |
| break; |
| } |
| } |
| |
| // Move the caret to the new position. |
| mpCaret->SetPosition(nParagraphIndex, nCharacterIndex); |
| } |
| |
| |
| |
| |
| void PresenterTextView::Paint ( |
| const css::awt::Rectangle& rUpdateBox) |
| { |
| if ( ! mbDoOuput) |
| return; |
| if ( ! mxCanvas.is()) |
| return; |
| if ( ! mpFont->PrepareFont(mxCanvas)) |
| return; |
| |
| if (mbIsFormatPending) |
| Format(); |
| |
| // Setup the clipping rectangle. Horizontally we make it a little |
| // larger to allow characters (and the caret) to stick out of their |
| // bounding boxes. This can happen on some characters (like the |
| // uppercase J) for typographical reasons. |
| const sal_Int32 nAdditionalLeftBorder (10); |
| const sal_Int32 nAdditionalRightBorder (5); |
| double nX (maLocation.X - mnLeftOffset); |
| double nY (maLocation.Y - mnTopOffset); |
| const sal_Int32 nClipLeft (::std::max( |
| PresenterGeometryHelper::Round(maLocation.X)-nAdditionalLeftBorder, rUpdateBox.X)); |
| const sal_Int32 nClipTop (::std::max( |
| PresenterGeometryHelper::Round(maLocation.Y), rUpdateBox.Y)); |
| const sal_Int32 nClipRight (::std::min( |
| PresenterGeometryHelper::Round(maLocation.X+maSize.Width)+nAdditionalRightBorder, rUpdateBox.X+rUpdateBox.Width)); |
| const sal_Int32 nClipBottom (::std::min( |
| PresenterGeometryHelper::Round(maLocation.Y+maSize.Height), rUpdateBox.Y+rUpdateBox.Height)); |
| if (nClipLeft>=nClipRight || nClipTop>=nClipBottom) |
| return; |
| |
| const awt::Rectangle aClipBox( |
| nClipLeft, |
| nClipTop, |
| nClipRight - nClipLeft, |
| nClipBottom - nClipTop); |
| Reference<rendering::XPolyPolygon2D> xClipPolygon ( |
| PresenterGeometryHelper::CreatePolygon(aClipBox, mxCanvas->getDevice())); |
| |
| const rendering::ViewState aViewState( |
| geometry::AffineMatrix2D(1,0,0, 0,1,0), |
| xClipPolygon); |
| |
| rendering::RenderState aRenderState ( |
| geometry::AffineMatrix2D(1,0,nX, 0,1,nY), |
| NULL, |
| Sequence<double>(4), |
| rendering::CompositeOperation::SOURCE); |
| PresenterCanvasHelper::SetDeviceColor(aRenderState, mpFont->mnColor); |
| |
| for (::std::vector<SharedPresenterTextParagraph>::const_iterator |
| iParagraph(maParagraphs.begin()), |
| iEnd(maParagraphs.end()); |
| iParagraph!=iEnd; |
| ++iParagraph) |
| { |
| (*iParagraph)->Paint( |
| mxCanvas, |
| maSize, |
| mpFont, |
| aViewState, |
| aRenderState, |
| mnTopOffset, |
| nClipTop, |
| nClipBottom); |
| } |
| |
| aRenderState.AffineTransform.m02 = 0; |
| aRenderState.AffineTransform.m12 = 0; |
| |
| #ifdef SHOW_CHARACTER_BOXES |
| PresenterCanvasHelper::SetDeviceColor(aRenderState, 0x00808080); |
| for (sal_Int32 nParagraphIndex(0), nParagraphCount(GetParagraphCount()); |
| nParagraphIndex<nParagraphCount; |
| ++nParagraphIndex) |
| { |
| const SharedPresenterTextParagraph pParagraph (GetParagraph(nParagraphIndex)); |
| if ( ! pParagraph) |
| continue; |
| for (sal_Int32 nCharacterIndex(0),nCharacterCount(pParagraph->GetCharacterCount()); |
| nCharacterIndex<nCharacterCount; ++nCharacterIndex) |
| { |
| const awt::Rectangle aBox (pParagraph->GetCharacterBounds(nCharacterIndex, false)); |
| mxCanvas->drawPolyPolygon ( |
| PresenterGeometryHelper::CreatePolygon( |
| aBox, |
| mxCanvas->getDevice()), |
| aViewState, |
| aRenderState); |
| } |
| } |
| PresenterCanvasHelper::SetDeviceColor(aRenderState, mpFont->mnColor); |
| #endif |
| |
| if (mpCaret && mpCaret->IsVisible()) |
| { |
| mxCanvas->fillPolyPolygon ( |
| PresenterGeometryHelper::CreatePolygon( |
| mpCaret->GetBounds(), |
| mxCanvas->getDevice()), |
| aViewState, |
| aRenderState); |
| } |
| } |
| |
| |
| |
| |
| SharedPresenterTextCaret PresenterTextView::GetCaret (void) const |
| { |
| return mpCaret; |
| } |
| |
| |
| |
| |
| sal_Int32 PresenterTextView::GetCharacterOffset (const sal_Int32 nParagraphIndex) const |
| { |
| sal_Int32 nCharacterOffset (0); |
| for (sal_Int32 nIndex=0; nIndex<nParagraphIndex; ++nIndex) |
| nCharacterOffset += maParagraphs[nIndex]->GetCharacterCount(); |
| return nCharacterOffset; |
| } |
| |
| |
| |
| |
| awt::Rectangle PresenterTextView::GetCaretBounds ( |
| sal_Int32 nParagraphIndex, |
| const sal_Int32 nCharacterIndex) const |
| { |
| SharedPresenterTextParagraph pParagraph (GetParagraph(nParagraphIndex)); |
| |
| if (pParagraph) |
| return pParagraph->GetCharacterBounds(nCharacterIndex, true); |
| else |
| return awt::Rectangle(0,0,0,0); |
| } |
| |
| |
| |
| |
| //----- private --------------------------------------------------------------- |
| |
| void PresenterTextView::RequestFormat (void) |
| { |
| mbIsFormatPending = true; |
| } |
| |
| |
| |
| |
| void PresenterTextView::Format (void) |
| { |
| mbIsFormatPending = false; |
| |
| double nY (0); |
| for (::std::vector<SharedPresenterTextParagraph>::const_iterator |
| iParagraph(maParagraphs.begin()), |
| iEnd(maParagraphs.end()); |
| iParagraph!=iEnd; |
| ++iParagraph) |
| { |
| (*iParagraph)->Format(nY, maSize.Width, mpFont); |
| nY += (*iParagraph)->GetTotalTextHeight(); |
| } |
| |
| if (maTextChangeBroadcaster) |
| maTextChangeBroadcaster(); |
| } |
| |
| |
| |
| |
| sal_Int32 PresenterTextView::GetParagraphCount (void) const |
| { |
| return maParagraphs.size(); |
| } |
| |
| |
| |
| |
| SharedPresenterTextParagraph PresenterTextView::GetParagraph ( |
| const sal_Int32 nParagraphIndex) const |
| { |
| if (nParagraphIndex < 0) |
| return SharedPresenterTextParagraph(); |
| else if (nParagraphIndex>=sal_Int32(maParagraphs.size())) |
| return SharedPresenterTextParagraph(); |
| else |
| return maParagraphs[nParagraphIndex]; |
| } |
| |
| |
| |
| |
| //===== PresenterTextParagraph ================================================ |
| |
| PresenterTextParagraph::PresenterTextParagraph ( |
| const sal_Int32 nParagraphIndex, |
| const Reference<i18n::XBreakIterator>& rxBreakIterator, |
| const Reference<i18n::XScriptTypeDetector>& rxScriptTypeDetector, |
| const Reference<text::XTextRange>& rxTextRange, |
| const SharedPresenterTextCaret& rpCaret) |
| : msParagraphText(), |
| mnParagraphIndex(nParagraphIndex), |
| mpCaret(rpCaret), |
| mxBreakIterator(rxBreakIterator), |
| mxScriptTypeDetector(rxScriptTypeDetector), |
| maLines(), |
| mnVerticalOffset(0), |
| mnXOrigin(0), |
| mnYOrigin(0), |
| mnWidth(0), |
| mnAscent(0), |
| mnDescent(0), |
| mnLineHeight(-1), |
| meAdjust(style::ParagraphAdjust_LEFT), |
| mnWritingMode (text::WritingMode2::LR_TB), |
| mnCharacterOffset(0), |
| maCells() |
| { |
| if (rxTextRange.is()) |
| { |
| Reference<beans::XPropertySet> xProperties (rxTextRange, UNO_QUERY); |
| lang::Locale aLocale; |
| try |
| { |
| xProperties->getPropertyValue(A2S("CharLocale")) >>= aLocale; |
| } |
| catch(beans::UnknownPropertyException&) |
| { |
| // Ignore the exception. Use the default value. |
| } |
| try |
| { |
| xProperties->getPropertyValue(A2S("ParaAdjust")) >>= meAdjust; |
| } |
| catch(beans::UnknownPropertyException&) |
| { |
| // Ignore the exception. Use the default value. |
| } |
| try |
| { |
| xProperties->getPropertyValue(A2S("WritingMode")) >>= mnWritingMode; |
| } |
| catch(beans::UnknownPropertyException&) |
| { |
| // Ignore the exception. Use the default value. |
| } |
| |
| msParagraphText = rxTextRange->getString(); |
| } |
| } |
| |
| |
| |
| |
| PresenterTextParagraph::PresenterTextParagraph ( |
| const sal_Int32 nParagraphIndex, |
| const Reference<i18n::XBreakIterator>& rxBreakIterator, |
| const Reference<i18n::XScriptTypeDetector>& rxScriptTypeDetector, |
| const ::rtl::OUString& rsText, |
| const SharedPresenterTextCaret& rpCaret) |
| : msParagraphText(rsText), |
| mnParagraphIndex(nParagraphIndex), |
| mpCaret(rpCaret), |
| mxBreakIterator(rxBreakIterator), |
| mxScriptTypeDetector(rxScriptTypeDetector), |
| maLines(), |
| mnVerticalOffset(0), |
| mnXOrigin(0), |
| mnYOrigin(0), |
| mnWidth(0), |
| mnAscent(0), |
| mnDescent(0), |
| mnLineHeight(-1), |
| meAdjust(style::ParagraphAdjust_LEFT), |
| mnWritingMode (text::WritingMode2::LR_TB), |
| mnCharacterOffset(0), |
| maCells() |
| { |
| } |
| |
| |
| |
| |
| void PresenterTextParagraph::Paint ( |
| const Reference<rendering::XCanvas>& rxCanvas, |
| const geometry::RealSize2D& rSize, |
| const PresenterTheme::SharedFontDescriptor& rpFont, |
| const rendering::ViewState& rViewState, |
| rendering::RenderState& rRenderState, |
| const double nTopOffset, |
| const double nClipTop, |
| const double nClipBottom) |
| { |
| if (mnLineHeight <= 0) |
| return; |
| |
| sal_Int8 nTextDirection (GetTextDirection()); |
| |
| const double nSavedM12 (rRenderState.AffineTransform.m12); |
| |
| if ( ! IsTextReferencePointLeft()) |
| rRenderState.AffineTransform.m02 += rSize.Width; |
| |
| |
| #ifdef SHOW_CHARACTER_BOXES |
| for (sal_Int32 nIndex=0,nCount=maLines.size(); |
| nIndex<nCount; |
| ++nIndex) |
| { |
| Line& rLine (maLines[nIndex]); |
| rLine.ProvideLayoutedLine(msParagraphText, rpFont, nTextDirection); |
| } |
| #endif |
| |
| for (sal_Int32 nIndex=0,nCount=maLines.size(); |
| nIndex<nCount; |
| ++nIndex, rRenderState.AffineTransform.m12 += mnLineHeight) |
| { |
| Line& rLine (maLines[nIndex]); |
| |
| // Paint only visible lines. |
| const double nLineTop = rLine.mnBaseLine - mnAscent - nTopOffset; |
| if (nLineTop + mnLineHeight< nClipTop) |
| continue; |
| else if (nLineTop > nClipBottom) |
| break; |
| rLine.ProvideLayoutedLine(msParagraphText, rpFont, nTextDirection); |
| |
| rRenderState.AffineTransform.m12 = nSavedM12 + rLine.mnBaseLine; |
| |
| rxCanvas->drawTextLayout ( |
| rLine.mxLayoutedLine, |
| rViewState, |
| rRenderState); |
| } |
| rRenderState.AffineTransform.m12 = nSavedM12; |
| |
| if ( ! IsTextReferencePointLeft()) |
| rRenderState.AffineTransform.m02 -= rSize.Width; |
| } |
| |
| |
| |
| |
| void PresenterTextParagraph::Format ( |
| const double nY, |
| const double nWidth, |
| const PresenterTheme::SharedFontDescriptor& rpFont) |
| { |
| // Make sure that the text view is in a valid and sane state. |
| if ( ! mxBreakIterator.is() || ! mxScriptTypeDetector.is()) |
| return; |
| if (nWidth<=0) |
| return; |
| if ( ! rpFont || ! rpFont->mxFont.is()) |
| return; |
| |
| sal_Int32 nPosition (0); |
| |
| mnWidth = nWidth; |
| maLines.clear(); |
| mnLineHeight = 0; |
| mnAscent = 0; |
| mnDescent = 0; |
| mnVerticalOffset = nY; |
| maWordBoundaries.clear(); |
| maWordBoundaries.push_back(0); |
| |
| const rendering::FontMetrics aMetrics (rpFont->mxFont->getFontMetrics()); |
| mnAscent = aMetrics.Ascent; |
| mnDescent = aMetrics.Descent; |
| mnLineHeight = aMetrics.Ascent + aMetrics.Descent + aMetrics.ExternalLeading; |
| nPosition = 0; |
| i18n::Boundary aCurrentLine(0,0); |
| while (true) |
| { |
| const i18n::Boundary aWordBoundary = mxBreakIterator->nextWord( |
| msParagraphText, |
| nPosition, |
| lang::Locale(), |
| i18n::WordType::ANYWORD_IGNOREWHITESPACES); |
| AddWord(nWidth, aCurrentLine, aWordBoundary.startPos, rpFont); |
| |
| // Remember the new word boundary for caret travelling by words. |
| // Prevent duplicates. |
| if (aWordBoundary.startPos > maWordBoundaries.back()) |
| maWordBoundaries.push_back(aWordBoundary.startPos); |
| |
| if (aWordBoundary.endPos>aWordBoundary.startPos) |
| AddWord(nWidth, aCurrentLine, aWordBoundary.endPos, rpFont); |
| |
| if (aWordBoundary.startPos<0 || aWordBoundary.endPos<0) |
| break; |
| if (nPosition >= aWordBoundary.endPos) |
| break; |
| nPosition = aWordBoundary.endPos; |
| } |
| |
| if (aCurrentLine.endPos>aCurrentLine.startPos) |
| AddLine(aCurrentLine); |
| |
| } |
| |
| |
| |
| |
| sal_Int32 PresenterTextParagraph::GetWordBoundary( |
| const sal_Int32 nLocalCharacterIndex, |
| const sal_Int32 nDistance) |
| { |
| OSL_ASSERT(nDistance==-1 || nDistance==+1); |
| |
| if (nLocalCharacterIndex < 0) |
| { |
| // The caller asked for the start or end position of the paragraph. |
| if (nDistance < 0) |
| return 0; |
| else |
| return GetCharacterCount(); |
| } |
| |
| sal_Int32 nIndex (0); |
| for (sal_Int32 nCount (maWordBoundaries.size()); nIndex<nCount; ++nIndex) |
| { |
| if (maWordBoundaries[nIndex] >= nLocalCharacterIndex) |
| { |
| // When inside the word (not at its start or end) then |
| // first move to the start or end before going the previous or |
| // next word. |
| if (maWordBoundaries[nIndex] > nLocalCharacterIndex) |
| if (nDistance > 0) |
| --nIndex; |
| break; |
| } |
| } |
| |
| nIndex += nDistance; |
| |
| if (nIndex < 0) |
| return -1; |
| else if (sal_uInt32(nIndex)>=maWordBoundaries.size()) |
| return -1; |
| else |
| return maWordBoundaries[nIndex]; |
| } |
| |
| |
| |
| |
| sal_Int32 PresenterTextParagraph::GetCaretPosition (void) const |
| { |
| if (mpCaret && mpCaret->GetParagraphIndex()==mnParagraphIndex) |
| return mpCaret->GetCharacterIndex(); |
| else |
| return -1; |
| } |
| |
| |
| |
| |
| void PresenterTextParagraph::SetCaretPosition (const sal_Int32 nPosition) const |
| { |
| if (mpCaret && mpCaret->GetParagraphIndex()==mnParagraphIndex) |
| return mpCaret->SetPosition(mnParagraphIndex, nPosition); |
| } |
| |
| |
| |
| |
| void PresenterTextParagraph::SetOrigin (const double nXOrigin, const double nYOrigin) |
| { |
| mnXOrigin = nXOrigin; |
| mnYOrigin = nYOrigin; |
| } |
| |
| |
| |
| |
| awt::Point PresenterTextParagraph::GetRelativeLocation (void) const |
| { |
| return awt::Point( |
| sal_Int32(mnXOrigin), |
| sal_Int32(mnYOrigin + mnVerticalOffset)); |
| } |
| |
| |
| |
| |
| awt::Size PresenterTextParagraph::GetSize (void) |
| { |
| return awt::Size( |
| sal_Int32(mnWidth), |
| sal_Int32(GetTotalTextHeight())); |
| } |
| |
| |
| |
| |
| void PresenterTextParagraph::AddWord ( |
| const double nWidth, |
| i18n::Boundary& rCurrentLine, |
| const sal_Int32 nWordBoundary, |
| const PresenterTheme::SharedFontDescriptor& rpFont) |
| { |
| sal_Int32 nLineStart (0); |
| sal_Int32 nLineEnd (0); |
| if ( ! maLines.empty()) |
| { |
| nLineStart = rCurrentLine.startPos; |
| nLineEnd = rCurrentLine.endPos; |
| } |
| |
| const ::rtl::OUString sLineCandidate ( |
| msParagraphText.copy(nLineStart, nWordBoundary-nLineStart)); |
| |
| css::geometry::RealRectangle2D aLineBox ( |
| PresenterCanvasHelper::GetTextBoundingBox ( |
| rpFont->mxFont, |
| sLineCandidate, |
| mnWritingMode)); |
| const double nLineWidth (aLineBox.X2 - aLineBox.X1); |
| |
| if (nLineWidth >= nWidth) |
| { |
| // Add new line with a single word (so far). |
| AddLine(rCurrentLine); |
| } |
| rCurrentLine.endPos = nWordBoundary; |
| } |
| |
| |
| |
| |
| void PresenterTextParagraph::AddLine ( |
| i18n::Boundary& rCurrentLine) |
| { |
| Line aLine (rCurrentLine.startPos, rCurrentLine.endPos); |
| |
| // Find the start and end of the line with respect to cells. |
| if (maLines.size() > 0) |
| { |
| aLine.mnLineStartCellIndex = maLines.back().mnLineEndCellIndex; |
| aLine.mnBaseLine = maLines.back().mnBaseLine + mnLineHeight; |
| } |
| else |
| { |
| aLine.mnLineStartCellIndex = 0; |
| aLine.mnBaseLine = mnVerticalOffset + mnAscent; |
| } |
| sal_Int32 nCellIndex (aLine.mnLineStartCellIndex); |
| double nWidth (0); |
| for ( ; nCellIndex<sal_Int32(maCells.size()); ++nCellIndex) |
| { |
| const Cell& rCell (maCells[nCellIndex]); |
| if (rCell.mnCharacterIndex+rCell.mnCharacterCount > aLine.mnLineEndCharacterIndex) |
| break; |
| nWidth += rCell.mnCellWidth; |
| } |
| aLine.mnLineEndCellIndex = nCellIndex; |
| aLine.mnWidth = nWidth; |
| |
| maLines.push_back(aLine); |
| |
| rCurrentLine.startPos = rCurrentLine.endPos; |
| } |
| |
| |
| |
| |
| sal_Int32 PresenterTextParagraph::GetParagraphIndex (void) const |
| { |
| return mnParagraphIndex; |
| } |
| |
| |
| |
| |
| double PresenterTextParagraph::GetTotalTextHeight (void) |
| { |
| return maLines.size() * mnLineHeight; |
| } |
| |
| |
| |
| |
| sal_Int32 PresenterTextParagraph::GetCharacterOffset (void) const |
| { |
| return mnCharacterOffset; |
| } |
| |
| |
| |
| |
| void PresenterTextParagraph::SetCharacterOffset (const sal_Int32 nCharacterOffset) |
| { |
| mnCharacterOffset = nCharacterOffset; |
| } |
| |
| |
| |
| |
| sal_Int32 PresenterTextParagraph::GetCharacterCount (void) const |
| { |
| return msParagraphText.getLength(); |
| } |
| |
| |
| |
| |
| sal_Unicode PresenterTextParagraph::GetCharacter ( |
| const sal_Int32 nGlobalCharacterIndex) const |
| { |
| if (nGlobalCharacterIndex<mnCharacterOffset |
| || nGlobalCharacterIndex>=mnCharacterOffset+msParagraphText.getLength()) |
| { |
| return sal_Unicode(); |
| } |
| else |
| { |
| return msParagraphText.getStr()[nGlobalCharacterIndex - mnCharacterOffset]; |
| } |
| } |
| |
| |
| |
| |
| ::rtl::OUString PresenterTextParagraph::GetText (void) const |
| { |
| return msParagraphText; |
| } |
| |
| |
| |
| |
| TextSegment PresenterTextParagraph::GetTextSegment ( |
| const sal_Int32 nOffset, |
| const sal_Int32 nIndex, |
| const sal_Int16 nTextType) const |
| { |
| switch(nTextType) |
| { |
| case AccessibleTextType::PARAGRAPH: |
| return TextSegment( |
| msParagraphText, |
| mnCharacterOffset, |
| mnCharacterOffset+msParagraphText.getLength()); |
| |
| case AccessibleTextType::SENTENCE: |
| if (mxBreakIterator.is()) |
| { |
| const sal_Int32 nStart (mxBreakIterator->beginOfSentence( |
| msParagraphText, nIndex-mnCharacterOffset, lang::Locale())); |
| const sal_Int32 nEnd (mxBreakIterator->endOfSentence( |
| msParagraphText, nIndex-mnCharacterOffset, lang::Locale())); |
| if (nStart < nEnd) |
| return TextSegment( |
| msParagraphText.copy(nStart, nEnd-nStart), |
| nStart+mnCharacterOffset, |
| nEnd+mnCharacterOffset); |
| } |
| break; |
| |
| case AccessibleTextType::WORD: |
| if (mxBreakIterator.is()) |
| return GetWordTextSegment(nOffset, nIndex); |
| break; |
| |
| case AccessibleTextType::LINE: |
| { |
| for (::std::vector<Line>::const_iterator |
| iLine(maLines.begin()), |
| iEnd(maLines.end()); |
| iLine!=iEnd; |
| ++iLine) |
| { |
| if (nIndex < iLine->mnLineEndCharacterIndex) |
| { |
| return TextSegment( |
| msParagraphText.copy( |
| iLine->mnLineStartCharacterIndex, |
| iLine->mnLineEndCharacterIndex - iLine->mnLineStartCharacterIndex), |
| iLine->mnLineStartCharacterIndex, |
| iLine->mnLineEndCharacterIndex); |
| } |
| } |
| } |
| break; |
| |
| // Handle GLYPH and ATTRIBUTE_RUN like CHARACTER because we can not |
| // do better at the moment. |
| case AccessibleTextType::CHARACTER: |
| case AccessibleTextType::GLYPH: |
| case AccessibleTextType::ATTRIBUTE_RUN: |
| return CreateTextSegment(nIndex+nOffset, nIndex+nOffset+1); |
| } |
| |
| return TextSegment(::rtl::OUString(), 0,0); |
| } |
| |
| |
| |
| |
| TextSegment PresenterTextParagraph::GetWordTextSegment ( |
| const sal_Int32 nOffset, |
| const sal_Int32 nIndex) const |
| { |
| sal_Int32 nCurrentOffset (nOffset); |
| sal_Int32 nCurrentIndex (nIndex); |
| |
| i18n::Boundary aWordBoundary; |
| if (nCurrentOffset == 0) |
| aWordBoundary = mxBreakIterator->getWordBoundary( |
| msParagraphText, |
| nIndex, |
| lang::Locale(), |
| i18n::WordType::ANYWORD_IGNOREWHITESPACES, |
| sal_True); |
| else if (nCurrentOffset < 0) |
| { |
| while (nCurrentOffset<0 && nCurrentIndex>0) |
| { |
| aWordBoundary = mxBreakIterator->previousWord( |
| msParagraphText, |
| nCurrentIndex, |
| lang::Locale(), |
| i18n::WordType::ANYWORD_IGNOREWHITESPACES); |
| nCurrentIndex = aWordBoundary.startPos; |
| ++nCurrentOffset; |
| } |
| } |
| else |
| { |
| while (nCurrentOffset>0 && nCurrentIndex<=GetCharacterCount()) |
| { |
| aWordBoundary = mxBreakIterator->nextWord( |
| msParagraphText, |
| nCurrentIndex, |
| lang::Locale(), |
| i18n::WordType::ANYWORD_IGNOREWHITESPACES); |
| nCurrentIndex = aWordBoundary.endPos; |
| --nCurrentOffset; |
| } |
| } |
| |
| return CreateTextSegment(aWordBoundary.startPos, aWordBoundary.endPos); |
| } |
| |
| |
| |
| |
| TextSegment PresenterTextParagraph::CreateTextSegment ( |
| sal_Int32 nStartIndex, |
| sal_Int32 nEndIndex) const |
| { |
| if (nEndIndex <= nStartIndex) |
| return TextSegment( |
| ::rtl::OUString(), |
| nStartIndex, |
| nEndIndex); |
| else |
| return TextSegment( |
| msParagraphText.copy(nStartIndex, nEndIndex-nStartIndex), |
| nStartIndex, |
| nEndIndex); |
| } |
| |
| |
| |
| |
| awt::Rectangle PresenterTextParagraph::GetCharacterBounds ( |
| sal_Int32 nGlobalCharacterIndex, |
| const bool bCaretBox) |
| { |
| // Find the line that contains the requested character and accumulate |
| // the previous line heights. |
| sal_Int32 nFirstCharacterIndex (0); |
| sal_Int32 nEndCharacterIndex (0); |
| double nX (mnXOrigin); |
| double nY (mnYOrigin + mnVerticalOffset + mnAscent); |
| const sal_Int8 nTextDirection (GetTextDirection()); |
| for (sal_Int32 nLineIndex=0,nLineCount=maLines.size(); |
| nLineIndex<nLineCount; |
| ++nLineIndex, nFirstCharacterIndex=nEndCharacterIndex, nY+=mnLineHeight) |
| { |
| Line& rLine (maLines[nLineIndex]); |
| // Skip lines before the indexed character. |
| if (nGlobalCharacterIndex >= rLine.mnLineEndCharacterIndex) |
| // When in the last line then allow the index past the last char. |
| if (nLineIndex<nLineCount-1) |
| continue; |
| |
| rLine.ProvideCellBoxes(); |
| |
| const sal_Int32 nCellIndex (nGlobalCharacterIndex - rLine.mnLineStartCharacterIndex); |
| |
| // The cell bounding box is defined relative to the origin of |
| // the current line. Therefore we have to add the absolute |
| // position of the line. |
| geometry::RealRectangle2D rCellBox (rLine.maCellBoxes[ |
| ::std::min(nCellIndex, rLine.maCellBoxes.getLength()-1)]); |
| |
| double nLeft = nX + rCellBox.X1; |
| double nRight = nX + rCellBox.X2; |
| if (nTextDirection == rendering::TextDirection::WEAK_RIGHT_TO_LEFT) |
| { |
| const double nOldRight (nRight); |
| nRight = rLine.mnWidth - nLeft; |
| nLeft = rLine.mnWidth - nOldRight; |
| } |
| double nTop (nY + rCellBox.Y1); |
| double nBottom (nY + rCellBox.Y2); |
| if (bCaretBox) |
| { |
| nTop = nTop - rCellBox.Y1 - mnAscent; |
| nBottom = nTop + mnLineHeight; |
| if (nCellIndex >= rLine.maCellBoxes.getLength()) |
| nLeft = nRight-2; |
| if (nLeft < nX) |
| nLeft = nX; |
| nRight = nLeft+2; |
| } |
| else |
| { |
| nTop = nTop - rCellBox.Y1 - mnAscent; |
| nBottom = nTop + mnAscent + mnDescent; |
| } |
| const sal_Int32 nX1 = sal_Int32(floor(nLeft)); |
| const sal_Int32 nY1 = sal_Int32(floor(nTop)); |
| const sal_Int32 nX2 = sal_Int32(ceil(nRight)); |
| const sal_Int32 nY2 = sal_Int32(ceil(nBottom)); |
| |
| return awt::Rectangle(nX1,nY1,nX2-nX1+1,nY2-nY1+1); |
| } |
| |
| // We are still here. That means that the given index lies past the |
| // last character in the paragraph. |
| // Return an empty box that lies past the last character. Better than nothing. |
| return awt::Rectangle(sal_Int32(nX+0.5), sal_Int32(nY+0.5), 0, 0); |
| } |
| |
| |
| |
| |
| sal_Int32 PresenterTextParagraph::GetIndexAtPoint (const awt::Point& rPoint) const |
| { |
| (void)rPoint; |
| return -1; |
| } |
| |
| |
| |
| |
| sal_Int8 PresenterTextParagraph::GetTextDirection (void) const |
| { |
| // Find first portion that has a non-neutral text direction. |
| sal_Int32 nPosition (0); |
| sal_Int32 nTextLength (msParagraphText.getLength()); |
| while (nPosition < nTextLength) |
| { |
| const sal_Int16 nScriptDirection ( |
| mxScriptTypeDetector->getScriptDirection( |
| msParagraphText, nPosition, i18n::ScriptDirection::NEUTRAL)); |
| switch (nScriptDirection) |
| { |
| case i18n::ScriptDirection::NEUTRAL: |
| // continue looping. |
| break; |
| case i18n::ScriptDirection::LEFT_TO_RIGHT: |
| return rendering::TextDirection::WEAK_LEFT_TO_RIGHT; |
| |
| case i18n::ScriptDirection::RIGHT_TO_LEFT: |
| return rendering::TextDirection::WEAK_RIGHT_TO_LEFT; |
| } |
| |
| nPosition = mxScriptTypeDetector->endOfScriptDirection( |
| msParagraphText, nPosition, nScriptDirection); |
| } |
| |
| // All text in paragraph is neutral. Fall back on writing mode taken |
| // from the XText (which may not be properly initialized.) |
| sal_Int8 nTextDirection(rendering::TextDirection::WEAK_LEFT_TO_RIGHT); |
| switch(mnWritingMode) |
| { |
| case text::WritingMode2::LR_TB: |
| nTextDirection = rendering::TextDirection::WEAK_LEFT_TO_RIGHT; |
| break; |
| |
| case text::WritingMode2::RL_TB: |
| nTextDirection = rendering::TextDirection::WEAK_RIGHT_TO_LEFT; |
| break; |
| |
| default: |
| case text::WritingMode2::TB_RL: |
| case text::WritingMode2::TB_LR: |
| // Can not handle this. Use default and hope for the best. |
| break; |
| } |
| return nTextDirection; |
| } |
| |
| |
| |
| |
| bool PresenterTextParagraph::IsTextReferencePointLeft (void) const |
| { |
| return mnWritingMode != text::WritingMode2::RL_TB; |
| } |
| |
| |
| |
| |
| void PresenterTextParagraph::SetupCellArray ( |
| const PresenterTheme::SharedFontDescriptor& rpFont) |
| { |
| maCells.clear(); |
| |
| if ( ! rpFont || ! rpFont->mxFont.is()) |
| return; |
| |
| sal_Int32 nPosition (0); |
| sal_Int32 nIndex (0); |
| const sal_Int32 nTextLength (msParagraphText.getLength()); |
| const sal_Int8 nTextDirection (GetTextDirection()); |
| while (nPosition < nTextLength) |
| { |
| const sal_Int32 nNewPosition (mxBreakIterator->nextCharacters( |
| msParagraphText, |
| nPosition, |
| lang::Locale(), |
| i18n::CharacterIteratorMode::SKIPCELL, |
| 1, |
| nIndex)); |
| |
| rendering::StringContext aContext (msParagraphText, nPosition, nNewPosition-nPosition); |
| Reference<rendering::XTextLayout> xLayout ( |
| rpFont->mxFont->createTextLayout(aContext, nTextDirection, 0)); |
| css::geometry::RealRectangle2D aCharacterBox (xLayout->queryTextBounds()); |
| |
| maCells.push_back(Cell( |
| nPosition, |
| nNewPosition-nPosition, |
| aCharacterBox.X2-aCharacterBox.X1)); |
| |
| nPosition = nNewPosition; |
| } |
| } |
| |
| |
| |
| |
| //===== PresenterTextCaret ================================================---- |
| |
| PresenterTextCaret::PresenterTextCaret ( |
| const ::boost::function<css::awt::Rectangle(const sal_Int32,const sal_Int32)>& rCharacterBoundsAccess, |
| const ::boost::function<void(const css::awt::Rectangle&)>& rInvalidator) |
| : mnParagraphIndex(-1), |
| mnCharacterIndex(-1), |
| mnCaretBlinkTaskId(0), |
| mbIsCaretVisible(false), |
| maCharacterBoundsAccess(rCharacterBoundsAccess), |
| maInvalidator(rInvalidator), |
| maBroadcaster(), |
| maCaretBounds() |
| { |
| } |
| |
| |
| |
| |
| PresenterTextCaret::~PresenterTextCaret (void) |
| { |
| HideCaret(); |
| } |
| |
| |
| |
| |
| void PresenterTextCaret::ShowCaret (void) |
| { |
| if (mnCaretBlinkTaskId == 0) |
| { |
| mnCaretBlinkTaskId = PresenterTimer::ScheduleRepeatedTask ( |
| ::boost::bind(&PresenterTextCaret::InvertCaret, this), |
| CaretBlinkIntervall, |
| CaretBlinkIntervall); |
| } |
| mbIsCaretVisible = true; |
| } |
| |
| |
| |
| |
| void PresenterTextCaret::HideCaret (void) |
| { |
| if (mnCaretBlinkTaskId != 0) |
| { |
| PresenterTimer::CancelTask(mnCaretBlinkTaskId); |
| mnCaretBlinkTaskId = 0; |
| } |
| mbIsCaretVisible = false; |
| // Reset the caret position. |
| mnParagraphIndex = -1; |
| mnCharacterIndex = -1; |
| } |
| |
| |
| |
| |
| sal_Int32 PresenterTextCaret::GetParagraphIndex (void) const |
| { |
| return mnParagraphIndex; |
| } |
| |
| |
| |
| |
| sal_Int32 PresenterTextCaret::GetCharacterIndex (void) const |
| { |
| return mnCharacterIndex; |
| } |
| |
| |
| |
| |
| void PresenterTextCaret::SetPosition ( |
| const sal_Int32 nParagraphIndex, |
| const sal_Int32 nCharacterIndex) |
| { |
| if (mnParagraphIndex != nParagraphIndex |
| || mnCharacterIndex != nCharacterIndex) |
| { |
| if (mnParagraphIndex >= 0) |
| maInvalidator(maCaretBounds); |
| |
| const sal_Int32 nOldParagraphIndex (mnParagraphIndex); |
| const sal_Int32 nOldCharacterIndex (mnCharacterIndex); |
| mnParagraphIndex = nParagraphIndex; |
| mnCharacterIndex = nCharacterIndex; |
| maCaretBounds = maCharacterBoundsAccess(mnParagraphIndex, mnCharacterIndex); |
| if (mnParagraphIndex >= 0) |
| ShowCaret(); |
| else |
| HideCaret(); |
| |
| if (mnParagraphIndex >= 0) |
| maInvalidator(maCaretBounds); |
| |
| if (maBroadcaster) |
| maBroadcaster( |
| nOldParagraphIndex, |
| nOldCharacterIndex, |
| mnParagraphIndex, |
| mnCharacterIndex); |
| |
| } |
| } |
| |
| |
| |
| |
| bool PresenterTextCaret::IsVisible (void) const |
| { |
| return mbIsCaretVisible; |
| } |
| |
| |
| |
| |
| void PresenterTextCaret::SetCaretMotionBroadcaster ( |
| const ::boost::function<void(sal_Int32,sal_Int32,sal_Int32,sal_Int32)>& rBroadcaster) |
| { |
| maBroadcaster = rBroadcaster; |
| } |
| |
| |
| |
| |
| css::awt::Rectangle PresenterTextCaret::GetBounds (void) const |
| { |
| return maCaretBounds; |
| } |
| |
| |
| |
| |
| void PresenterTextCaret::InvertCaret (void) |
| { |
| mbIsCaretVisible = !mbIsCaretVisible; |
| if (mnParagraphIndex >= 0) |
| maInvalidator(maCaretBounds); |
| } |
| |
| |
| |
| |
| |
| |
| |
| //===== PresenterTextParagraph::Cell ========================================== |
| |
| PresenterTextParagraph::Cell::Cell ( |
| const sal_Int32 nCharacterIndex, |
| const sal_Int32 nCharacterCount, |
| const double nCellWidth) |
| : mnCharacterIndex(nCharacterIndex), |
| mnCharacterCount(nCharacterCount), |
| mnCellWidth(nCellWidth) |
| { |
| } |
| |
| |
| |
| |
| //===== PresenterTextParagraph::Line ========================================== |
| |
| PresenterTextParagraph::Line::Line ( |
| const sal_Int32 nLineStartCharacterIndex, |
| const sal_Int32 nLineEndCharacterIndex) |
| : mnLineStartCharacterIndex(nLineStartCharacterIndex), |
| mnLineEndCharacterIndex(nLineEndCharacterIndex), |
| mnLineStartCellIndex(-1), mnLineEndCellIndex(-1), |
| mxLayoutedLine(), |
| mnBaseLine(0), mnWidth(0), |
| maCellBoxes() |
| { |
| } |
| |
| |
| |
| |
| sal_Int32 PresenterTextParagraph::Line::GetLength (void) const |
| { |
| return mnLineEndCharacterIndex-mnLineStartCharacterIndex; |
| } |
| |
| |
| |
| |
| void PresenterTextParagraph::Line::ProvideCellBoxes (void) |
| { |
| if ( ! IsEmpty() && maCellBoxes.getLength()==0) |
| { |
| if (mxLayoutedLine.is()) |
| maCellBoxes = mxLayoutedLine->queryInkMeasures(); |
| else |
| { |
| OSL_ASSERT(mxLayoutedLine.is()); |
| } |
| } |
| } |
| |
| |
| |
| |
| void PresenterTextParagraph::Line::ProvideLayoutedLine ( |
| const ::rtl::OUString& rsParagraphText, |
| const PresenterTheme::SharedFontDescriptor& rpFont, |
| const sal_Int8 nTextDirection) |
| { |
| if ( ! mxLayoutedLine.is()) |
| { |
| const rendering::StringContext aContext ( |
| rsParagraphText, |
| mnLineStartCharacterIndex, |
| mnLineEndCharacterIndex - mnLineStartCharacterIndex); |
| |
| mxLayoutedLine = rpFont->mxFont->createTextLayout( |
| aContext, |
| nTextDirection, |
| 0); |
| } |
| } |
| |
| |
| |
| |
| bool PresenterTextParagraph::Line::IsEmpty (void) const |
| { |
| return mnLineStartCharacterIndex >= mnLineEndCharacterIndex; |
| } |
| |
| |
| |
| |
| } } // end of namespace ::sdext::presenter |
