| /************************************************************** | |
| * | |
| * 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. | |
| * | |
| *************************************************************/ | |
| // MARKER(update_precomp.py): autogen include statement, do not remove | |
| #include "precompiled_sdext.hxx" | |
| #include "PresenterNotesView.hxx" | |
| #include "PresenterButton.hxx" | |
| #include "PresenterCanvasHelper.hxx" | |
| #include "PresenterGeometryHelper.hxx" | |
| #include "PresenterPaintManager.hxx" | |
| #include "PresenterScrollBar.hxx" | |
| #include "PresenterTextView.hxx" | |
| #include <com/sun/star/accessibility/AccessibleTextType.hpp> | |
| #include <com/sun/star/awt/Key.hpp> | |
| #include <com/sun/star/awt/KeyModifier.hpp> | |
| #include <com/sun/star/awt/PosSize.hpp> | |
| #include <com/sun/star/beans/XPropertySet.hpp> | |
| #include <com/sun/star/drawing/framework/XControllerManager.hpp> | |
| #include <com/sun/star/drawing/framework/XConfigurationController.hpp> | |
| #include <com/sun/star/drawing/framework/XPane.hpp> | |
| #include <com/sun/star/lang/XServiceName.hpp> | |
| #include <com/sun/star/presentation/XPresentationPage.hpp> | |
| #include <com/sun/star/rendering/CompositeOperation.hpp> | |
| #include <com/sun/star/rendering/XSpriteCanvas.hpp> | |
| #include <com/sun/star/text/XTextRange.hpp> | |
| #include <com/sun/star/util/XChangesBatch.hpp> | |
| #include <com/sun/star/container/XChild.hpp> | |
| #include <boost/bind.hpp> | |
| #include <set> | |
| using namespace ::com::sun::star; | |
| using namespace ::com::sun::star::uno; | |
| using namespace ::com::sun::star::drawing::framework; | |
| using ::rtl::OUString; | |
| #define A2S(pString) (::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(pString))) | |
| static const sal_Int32 gnSpaceBelowSeparator (10); | |
| static const sal_Int32 gnSpaceAboveSeparator (10); | |
| static const sal_Int32 gnPartHeight (128); | |
| /** Maximal size of memory used for bitmaps which show the notes text. | |
| */ | |
| static const sal_Int32 gnMaximalCacheSize (8*1024*1024); | |
| static const double gnLineScrollFactor (1.2); | |
| namespace sdext { namespace presenter { | |
| //===== PresenterNotesView ==================================================== | |
| PresenterNotesView::PresenterNotesView ( | |
| const Reference<XComponentContext>& rxComponentContext, | |
| const Reference<XResourceId>& rxViewId, | |
| const Reference<frame::XController>& rxController, | |
| const ::rtl::Reference<PresenterController>& rpPresenterController) | |
| : PresenterNotesViewInterfaceBase(m_aMutex), | |
| mxViewId(rxViewId), | |
| mpPresenterController(rpPresenterController), | |
| mxCanvas(), | |
| mxCurrentNotesPage(), | |
| mpScrollBar(), | |
| mxToolBarWindow(), | |
| mxToolBarCanvas(), | |
| mpToolBar(), | |
| mpCloseButton(), | |
| maSeparatorColor(0xffffff), | |
| mnSeparatorYLocation(0), | |
| maTextBoundingBox(), | |
| mpBackground(), | |
| mnTop(0), | |
| mpFont(), | |
| mpTextView() | |
| { | |
| try | |
| { | |
| Reference<XControllerManager> xCM (rxController, UNO_QUERY_THROW); | |
| Reference<XConfigurationController> xCC (xCM->getConfigurationController(), UNO_QUERY_THROW); | |
| Reference<XPane> xPane (xCC->getResource(rxViewId->getAnchor()), UNO_QUERY_THROW); | |
| mxParentWindow = xPane->getWindow(); | |
| mxCanvas = xPane->getCanvas(); | |
| mpTextView.reset(new PresenterTextView( | |
| rxComponentContext, | |
| mxCanvas, | |
| mpPresenterController->GetPaintManager()->GetInvalidator(mxParentWindow))); | |
| const OUString sResourceURL (mxViewId->getResourceURL()); | |
| mpFont.reset(new PresenterTheme::FontDescriptor( | |
| rpPresenterController->GetViewFont(sResourceURL))); | |
| maSeparatorColor = mpFont->mnColor; | |
| mpTextView->SetFont(mpFont); | |
| CreateToolBar(rxComponentContext, rpPresenterController); | |
| mpCloseButton = PresenterButton::Create( | |
| rxComponentContext, | |
| mpPresenterController, | |
| mpPresenterController->GetTheme(), | |
| mxParentWindow, | |
| mxCanvas, | |
| A2S("NotesViewCloser")); | |
| if (mxParentWindow.is()) | |
| { | |
| mxParentWindow->addWindowListener(this); | |
| mxParentWindow->addPaintListener(this); | |
| mxParentWindow->addKeyListener(this); | |
| mxParentWindow->setVisible(sal_True); | |
| } | |
| mpScrollBar = new PresenterVerticalScrollBar( | |
| rxComponentContext, | |
| mxParentWindow, | |
| mpPresenterController->GetPaintManager(), | |
| ::boost::bind(&PresenterNotesView::SetTop, this, _1)); | |
| mpScrollBar->SetBackground( | |
| mpPresenterController->GetViewBackground(mxViewId->getResourceURL())); | |
| mpScrollBar->SetCanvas(mxCanvas); | |
| Layout(); | |
| } | |
| catch (RuntimeException&) | |
| { | |
| PresenterNotesView::disposing(); | |
| throw; | |
| } | |
| } | |
| PresenterNotesView::~PresenterNotesView (void) | |
| { | |
| } | |
| void SAL_CALL PresenterNotesView::disposing (void) | |
| { | |
| if (mxParentWindow.is()) | |
| { | |
| mxParentWindow->removeWindowListener(this); | |
| mxParentWindow->removePaintListener(this); | |
| mxParentWindow->removeKeyListener(this); | |
| mxParentWindow = NULL; | |
| } | |
| // Dispose tool bar. | |
| { | |
| Reference<XComponent> xComponent (static_cast<XWeak*>(mpToolBar.get()), UNO_QUERY); | |
| mpToolBar = NULL; | |
| if (xComponent.is()) | |
| xComponent->dispose(); | |
| } | |
| { | |
| Reference<XComponent> xComponent (mxToolBarCanvas, UNO_QUERY); | |
| mxToolBarCanvas = NULL; | |
| if (xComponent.is()) | |
| xComponent->dispose(); | |
| } | |
| { | |
| Reference<XComponent> xComponent (mxToolBarWindow, UNO_QUERY); | |
| mxToolBarWindow = NULL; | |
| if (xComponent.is()) | |
| xComponent->dispose(); | |
| } | |
| // Dispose close button | |
| { | |
| Reference<XComponent> xComponent (static_cast<XWeak*>(mpCloseButton.get()), UNO_QUERY); | |
| mpCloseButton = NULL; | |
| if (xComponent.is()) | |
| xComponent->dispose(); | |
| } | |
| // Create the tool bar. | |
| mpScrollBar = NULL; | |
| mxViewId = NULL; | |
| } | |
| void PresenterNotesView::CreateToolBar ( | |
| const css::uno::Reference<css::uno::XComponentContext>& rxContext, | |
| const ::rtl::Reference<PresenterController>& rpPresenterController) | |
| { | |
| if (rpPresenterController.get() == NULL) | |
| return; | |
| Reference<drawing::XPresenterHelper> xPresenterHelper ( | |
| rpPresenterController->GetPresenterHelper()); | |
| if ( ! xPresenterHelper.is()) | |
| return; | |
| // Create a new window as container of the tool bar. | |
| mxToolBarWindow = xPresenterHelper->createWindow( | |
| mxParentWindow, | |
| sal_False, | |
| sal_True, | |
| sal_False, | |
| sal_False); | |
| mxToolBarCanvas = xPresenterHelper->createSharedCanvas ( | |
| Reference<rendering::XSpriteCanvas>(mxCanvas, UNO_QUERY), | |
| mxParentWindow, | |
| mxCanvas, | |
| mxParentWindow, | |
| mxToolBarWindow); | |
| // Create the tool bar. | |
| mpToolBar = new PresenterToolBar( | |
| rxContext, | |
| mxToolBarWindow, | |
| mxToolBarCanvas, | |
| rpPresenterController, | |
| PresenterToolBar::Left); | |
| mpToolBar->Initialize( | |
| A2S("PresenterScreenSettings/ToolBars/NotesToolBar")); | |
| } | |
| void PresenterNotesView::SetSlide (const Reference<drawing::XDrawPage>& rxNotesPage) | |
| { | |
| static const ::rtl::OUString sNotesShapeName ( | |
| A2S("com.sun.star.presentation.NotesShape")); | |
| static const ::rtl::OUString sTextShapeName ( | |
| A2S("com.sun.star.drawing.TextShape")); | |
| Reference<container::XIndexAccess> xIndexAccess (rxNotesPage, UNO_QUERY); | |
| if (xIndexAccess.is()) | |
| { | |
| ::rtl::OUString sText; | |
| // Iterate over all shapes and find the one that holds the text. | |
| sal_Int32 nCount (xIndexAccess->getCount()); | |
| for (sal_Int32 nIndex=0; nIndex<nCount; ++nIndex) | |
| { | |
| Reference<lang::XServiceName> xServiceName ( | |
| xIndexAccess->getByIndex(nIndex), UNO_QUERY); | |
| if (xServiceName.is() | |
| && xServiceName->getServiceName().equals(sNotesShapeName)) | |
| { | |
| Reference<text::XTextRange> xText (xServiceName, UNO_QUERY); | |
| if (xText.is()) | |
| { | |
| sText += xText->getString(); | |
| } | |
| } | |
| else | |
| { | |
| Reference<drawing::XShapeDescriptor> xShapeDescriptor ( | |
| xIndexAccess->getByIndex(nIndex), UNO_QUERY); | |
| if (xShapeDescriptor.is()) | |
| { | |
| ::rtl::OUString sType (xShapeDescriptor->getShapeType()); | |
| if (sType.equals(sNotesShapeName) || sType.equals(sTextShapeName)) | |
| { | |
| Reference<text::XTextRange> xText ( | |
| xIndexAccess->getByIndex(nIndex), UNO_QUERY); | |
| if (xText.is()) | |
| { | |
| sText += xText->getString(); | |
| mpTextView->SetText(Reference<text::XText>(xText, UNO_QUERY)); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| Layout(); | |
| if (mpScrollBar.get() != NULL) | |
| { | |
| mpScrollBar->SetThumbPosition(0, false); | |
| UpdateScrollBar(); | |
| } | |
| Invalidate(); | |
| } | |
| } | |
| //----- lang::XEventListener ------------------------------------------------- | |
| void SAL_CALL PresenterNotesView::disposing (const lang::EventObject& rEventObject) | |
| { | |
| if (rEventObject.Source == mxParentWindow) | |
| mxParentWindow = NULL; | |
| } | |
| //----- XWindowListener ------------------------------------------------------- | |
| void SAL_CALL PresenterNotesView::windowResized (const awt::WindowEvent& rEvent) | |
| { | |
| (void)rEvent; | |
| Layout(); | |
| } | |
| void SAL_CALL PresenterNotesView::windowMoved (const awt::WindowEvent& rEvent) | |
| { | |
| (void)rEvent; | |
| } | |
| void SAL_CALL PresenterNotesView::windowShown (const lang::EventObject& rEvent) | |
| { | |
| (void)rEvent; | |
| } | |
| void SAL_CALL PresenterNotesView::windowHidden (const lang::EventObject& rEvent) | |
| { | |
| (void)rEvent; | |
| } | |
| //----- XPaintListener -------------------------------------------------------- | |
| void SAL_CALL PresenterNotesView::windowPaint (const awt::PaintEvent& rEvent) | |
| { | |
| ThrowIfDisposed(); | |
| if ( ! mbIsPresenterViewActive) | |
| return; | |
| ::osl::MutexGuard aSolarGuard (::osl::Mutex::getGlobalMutex()); | |
| Paint(rEvent.UpdateRect); | |
| } | |
| //----- XResourceId ----------------------------------------------------------- | |
| Reference<XResourceId> SAL_CALL PresenterNotesView::getResourceId (void) | |
| { | |
| return mxViewId; | |
| } | |
| sal_Bool SAL_CALL PresenterNotesView::isAnchorOnly (void) | |
| { | |
| return false; | |
| } | |
| //----- XDrawView ------------------------------------------------------------- | |
| void SAL_CALL PresenterNotesView::setCurrentPage (const Reference<drawing::XDrawPage>& rxSlide) | |
| { | |
| // Get the associated notes page. | |
| mxCurrentNotesPage = NULL; | |
| try | |
| { | |
| Reference<presentation::XPresentationPage> xPresentationPage(rxSlide, UNO_QUERY); | |
| if (xPresentationPage.is()) | |
| mxCurrentNotesPage = xPresentationPage->getNotesPage(); | |
| } | |
| catch (RuntimeException&) | |
| { | |
| } | |
| SetSlide(mxCurrentNotesPage); | |
| } | |
| Reference<drawing::XDrawPage> SAL_CALL PresenterNotesView::getCurrentPage (void) | |
| { | |
| return NULL; | |
| } | |
| //----- XKeyListener ---------------------------------------------------------- | |
| void SAL_CALL PresenterNotesView::keyPressed (const awt::KeyEvent& rEvent) | |
| { | |
| switch (rEvent.KeyCode) | |
| { | |
| case awt::Key::A: | |
| Scroll(-gnLineScrollFactor * mpFont->mnSize); | |
| break; | |
| case awt::Key::Y: | |
| case awt::Key::Z: | |
| Scroll(+gnLineScrollFactor * mpFont->mnSize); | |
| break; | |
| case awt::Key::S: | |
| ChangeFontSize(-1); | |
| break; | |
| case awt::Key::G: | |
| ChangeFontSize(+1); | |
| break; | |
| case awt::Key::H: | |
| if (mpTextView) | |
| mpTextView->MoveCaret( | |
| -1, | |
| (rEvent.Modifiers == awt::KeyModifier::SHIFT) | |
| ? cssa::AccessibleTextType::CHARACTER | |
| : cssa::AccessibleTextType::WORD); | |
| break; | |
| case awt::Key::L: | |
| if (mpTextView) | |
| mpTextView->MoveCaret( | |
| +1, | |
| (rEvent.Modifiers == awt::KeyModifier::SHIFT) | |
| ? cssa::AccessibleTextType::CHARACTER | |
| : cssa::AccessibleTextType::WORD); | |
| break; | |
| } | |
| } | |
| void SAL_CALL PresenterNotesView::keyReleased (const awt::KeyEvent& rEvent) | |
| { | |
| (void)rEvent; | |
| } | |
| //----------------------------------------------------------------------------- | |
| void PresenterNotesView::Layout (void) | |
| { | |
| if ( ! mxParentWindow.is()) | |
| return; | |
| awt::Rectangle aWindowBox (mxParentWindow->getPosSize()); | |
| geometry::RealRectangle2D aNewTextBoundingBox (0,0,aWindowBox.Width, aWindowBox.Height); | |
| // Size the tool bar and the horizontal separator above it. | |
| if (mxToolBarWindow.is()) | |
| { | |
| const geometry::RealSize2D aToolBarSize (mpToolBar->GetMinimalSize()); | |
| const sal_Int32 nToolBarHeight = sal_Int32(aToolBarSize.Height + 0.5); | |
| mxToolBarWindow->setPosSize(0, aWindowBox.Height - nToolBarHeight, | |
| sal_Int32(aToolBarSize.Width + 0.5), nToolBarHeight, | |
| awt::PosSize::POSSIZE); | |
| aNewTextBoundingBox.Y2 -= nToolBarHeight; | |
| mnSeparatorYLocation = aWindowBox.Height - nToolBarHeight - gnSpaceBelowSeparator; | |
| aNewTextBoundingBox.Y2 = mnSeparatorYLocation - gnSpaceAboveSeparator; | |
| // Place the close button. | |
| if (mpCloseButton.get() != NULL) | |
| mpCloseButton->SetCenter(geometry::RealPoint2D( | |
| (aWindowBox.Width + aToolBarSize.Width) / 2, | |
| aWindowBox.Height - aToolBarSize.Height/2)); | |
| } | |
| // Check whether the vertical scroll bar is necessary. | |
| if (mpScrollBar.get() != NULL) | |
| { | |
| bool bShowVerticalScrollbar (false); | |
| try | |
| { | |
| const double nTextBoxHeight (aNewTextBoundingBox.Y2 - aNewTextBoundingBox.Y1); | |
| const double nHeight (mpTextView->GetTotalTextHeight()); | |
| if (nHeight > nTextBoxHeight) | |
| { | |
| bShowVerticalScrollbar = true; | |
| aNewTextBoundingBox.X2 -= mpScrollBar->GetSize(); | |
| } | |
| mpScrollBar->SetTotalSize(nHeight); | |
| } | |
| catch(beans::UnknownPropertyException&) | |
| { | |
| OSL_ASSERT(false); | |
| } | |
| mpScrollBar->SetVisible(bShowVerticalScrollbar); | |
| mpScrollBar->SetPosSize( | |
| geometry::RealRectangle2D( | |
| aNewTextBoundingBox.X2, | |
| aNewTextBoundingBox.X1, | |
| aNewTextBoundingBox.X2 + mpScrollBar->GetSize(), | |
| aNewTextBoundingBox.Y2)); | |
| if ( ! bShowVerticalScrollbar) | |
| mpScrollBar->SetThumbPosition(0, false); | |
| UpdateScrollBar(); | |
| } | |
| // Has the text area has changed it position or size? | |
| if (aNewTextBoundingBox.X1 != maTextBoundingBox.X1 | |
| || aNewTextBoundingBox.Y1 != maTextBoundingBox.Y1 | |
| || aNewTextBoundingBox.X2 != maTextBoundingBox.X2 | |
| || aNewTextBoundingBox.Y2 != maTextBoundingBox.Y2) | |
| { | |
| maTextBoundingBox = aNewTextBoundingBox; | |
| mpTextView->SetLocation( | |
| geometry::RealPoint2D( | |
| aNewTextBoundingBox.X1, | |
| aNewTextBoundingBox.Y1)); | |
| mpTextView->SetSize( | |
| geometry::RealSize2D( | |
| aNewTextBoundingBox.X2 - aNewTextBoundingBox.X1, | |
| aNewTextBoundingBox.Y2 - aNewTextBoundingBox.Y1)); | |
| } | |
| } | |
| void PresenterNotesView::Paint (const awt::Rectangle& rUpdateBox) | |
| { | |
| if ( ! mxParentWindow.is()) | |
| return; | |
| if ( ! mxCanvas.is()) | |
| return; | |
| if (mpBackground.get() == NULL) | |
| mpBackground = mpPresenterController->GetViewBackground(mxViewId->getResourceURL()); | |
| if (rUpdateBox.Y < maTextBoundingBox.Y2 | |
| && rUpdateBox.X < maTextBoundingBox.X2) | |
| { | |
| PaintText(rUpdateBox); | |
| } | |
| mpTextView->Paint(rUpdateBox); | |
| if (rUpdateBox.Y + rUpdateBox.Height > maTextBoundingBox.Y2) | |
| { | |
| PaintToolBar(rUpdateBox); | |
| } | |
| } | |
| void PresenterNotesView::PaintToolBar (const awt::Rectangle& rUpdateBox) | |
| { | |
| awt::Rectangle aWindowBox (mxParentWindow->getPosSize()); | |
| rendering::ViewState aViewState ( | |
| geometry::AffineMatrix2D(1,0,0, 0,1,0), | |
| NULL); | |
| rendering::RenderState aRenderState( | |
| geometry::AffineMatrix2D(1,0,0, 0,1,0), | |
| NULL, | |
| Sequence<double>(4), | |
| rendering::CompositeOperation::SOURCE); | |
| if (mpBackground.get() != NULL) | |
| { | |
| // Paint the background. | |
| mpPresenterController->GetCanvasHelper()->Paint( | |
| mpBackground, | |
| mxCanvas, | |
| rUpdateBox, | |
| awt::Rectangle(0,sal_Int32(maTextBoundingBox.Y2),aWindowBox.Width,aWindowBox.Height), | |
| awt::Rectangle()); | |
| } | |
| // Paint the horizontal separator. | |
| OSL_ASSERT(mxViewId.is()); | |
| PresenterCanvasHelper::SetDeviceColor(aRenderState, maSeparatorColor); | |
| mxCanvas->drawLine( | |
| geometry::RealPoint2D(0,mnSeparatorYLocation), | |
| geometry::RealPoint2D(aWindowBox.Width,mnSeparatorYLocation), | |
| aViewState, | |
| aRenderState); | |
| } | |
| void PresenterNotesView::PaintText (const awt::Rectangle& rUpdateBox) | |
| { | |
| const awt::Rectangle aBox (PresenterGeometryHelper::Intersection(rUpdateBox, | |
| PresenterGeometryHelper::ConvertRectangle(maTextBoundingBox))); | |
| if (aBox.Width <= 0 || aBox.Height <= 0) | |
| return; | |
| rendering::ViewState aViewState ( | |
| geometry::AffineMatrix2D(1,0,0, 0,1,0), | |
| PresenterGeometryHelper::CreatePolygon(aBox, mxCanvas->getDevice())); | |
| rendering::RenderState aRenderState( | |
| geometry::AffineMatrix2D(1,0,0, 0,1,0), | |
| NULL, | |
| Sequence<double>(3), | |
| rendering::CompositeOperation::SOURCE); | |
| if (mpBackground.get() != NULL) | |
| { | |
| // Paint the background. | |
| mpPresenterController->GetCanvasHelper()->Paint( | |
| mpBackground, | |
| mxCanvas, | |
| rUpdateBox, | |
| aBox, | |
| awt::Rectangle()); | |
| } | |
| Reference<rendering::XSpriteCanvas> xSpriteCanvas (mxCanvas, UNO_QUERY); | |
| if (xSpriteCanvas.is()) | |
| xSpriteCanvas->updateScreen(sal_False); | |
| } | |
| void PresenterNotesView::Invalidate (void) | |
| { | |
| mpPresenterController->GetPaintManager()->Invalidate( | |
| mxParentWindow, | |
| PresenterGeometryHelper::ConvertRectangle(maTextBoundingBox)); | |
| } | |
| void PresenterNotesView::Scroll (const double rnDistance) | |
| { | |
| try | |
| { | |
| mnTop += rnDistance; | |
| mpTextView->SetOffset(0, mnTop); | |
| UpdateScrollBar(); | |
| Invalidate(); | |
| } | |
| catch (beans::UnknownPropertyException&) | |
| {} | |
| } | |
| void PresenterNotesView::SetTop (const double nTop) | |
| { | |
| try | |
| { | |
| mnTop = nTop; | |
| mpTextView->SetOffset(0, mnTop); | |
| UpdateScrollBar(); | |
| Invalidate(); | |
| } | |
| catch (beans::UnknownPropertyException&) | |
| {} | |
| } | |
| void PresenterNotesView::ChangeFontSize (const sal_Int32 nSizeChange) | |
| { | |
| const sal_Int32 nNewSize (mpFont->mnSize + nSizeChange); | |
| if (nNewSize > 5) | |
| { | |
| mpFont->mnSize = nNewSize; | |
| mpFont->mxFont = NULL; | |
| mpTextView->SetFont(mpFont); | |
| Layout(); | |
| UpdateScrollBar(); | |
| Invalidate(); | |
| // Write the new font size to the configuration to make it persistent. | |
| try | |
| { | |
| const OUString sStyleName (mpPresenterController->GetTheme()->GetStyleName( | |
| mxViewId->getResourceURL())); | |
| ::boost::shared_ptr<PresenterConfigurationAccess> pConfiguration ( | |
| mpPresenterController->GetTheme()->GetNodeForViewStyle( | |
| sStyleName, | |
| PresenterConfigurationAccess::READ_WRITE)); | |
| if (pConfiguration.get()==NULL || ! pConfiguration->IsValid()) | |
| return; | |
| pConfiguration->GoToChild(A2S("Font")); | |
| pConfiguration->SetProperty(A2S("Size"), Any((sal_Int32)(nNewSize+0.5))); | |
| pConfiguration->CommitChanges(); | |
| } | |
| catch (Exception&) | |
| { | |
| OSL_ASSERT(false); | |
| } | |
| } | |
| } | |
| ::boost::shared_ptr<PresenterTextView> PresenterNotesView::GetTextView (void) const | |
| { | |
| return mpTextView; | |
| } | |
| void PresenterNotesView::UpdateScrollBar (void) | |
| { | |
| if (mpScrollBar.get() != NULL) | |
| { | |
| try | |
| { | |
| mpScrollBar->SetTotalSize(mpTextView->GetTotalTextHeight()); | |
| } | |
| catch(beans::UnknownPropertyException&) | |
| { | |
| OSL_ASSERT(false); | |
| } | |
| mpScrollBar->SetLineHeight(mpFont->mnSize*1.2); | |
| mpScrollBar->SetThumbPosition(mnTop, false); | |
| mpScrollBar->SetThumbSize(maTextBoundingBox.Y2 - maTextBoundingBox.Y1); | |
| mpScrollBar->CheckValues(); | |
| } | |
| } | |
| void PresenterNotesView::ThrowIfDisposed (void) | |
| { | |
| if (rBHelper.bDisposed || rBHelper.bInDispose) | |
| { | |
| throw lang::DisposedException ( | |
| A2S("PresenterNotesView object has already been disposed"), | |
| static_cast<uno::XWeak*>(this)); | |
| } | |
| } | |
| } } // end of namespace ::sdext::presenter |