| /************************************************************** |
| * |
| * 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 "PresenterAccessibility.hxx" |
| #include "PresenterTextView.hxx" |
| #include "PresenterConfigurationAccess.hxx" |
| #include "PresenterNotesView.hxx" |
| #include "PresenterPaneBase.hxx" |
| #include "PresenterPaneContainer.hxx" |
| #include "PresenterPaneFactory.hxx" |
| #include "PresenterViewFactory.hxx" |
| |
| #include <com/sun/star/accessibility/AccessibleEventId.hpp> |
| #include <com/sun/star/accessibility/AccessibleRelationType.hpp> |
| #include <com/sun/star/accessibility/AccessibleRole.hpp> |
| #include <com/sun/star/accessibility/XAccessibleComponent.hpp> |
| #include <com/sun/star/accessibility/XAccessibleContext.hpp> |
| #include <com/sun/star/accessibility/XAccessibleEditableText.hpp> |
| #include <com/sun/star/accessibility/XAccessibleEventBroadcaster.hpp> |
| #include <com/sun/star/accessibility/XAccessibleText.hpp> |
| #include <com/sun/star/drawing/framework/ResourceId.hpp> |
| #include <com/sun/star/drawing/framework/XPane.hpp> |
| #include <com/sun/star/drawing/framework/XView.hpp> |
| #include <cppuhelper/compbase1.hxx> |
| #include <cppuhelper/compbase5.hxx> |
| #include <cppuhelper/implbase1.hxx> |
| #include <boost/bind.hpp> |
| |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::accessibility; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::drawing::framework; |
| using ::rtl::OUString; |
| |
| #define A2S(s) (::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(s))) |
| |
| #define VERBOSE |
| |
| //===== PresenterAccessibleObject ============================================= |
| |
| namespace sdext { namespace presenter { |
| |
| namespace { |
| typedef ::cppu::WeakComponentImplHelper5 < |
| cssa::XAccessible, |
| cssa::XAccessibleContext, |
| cssa::XAccessibleComponent, |
| cssa::XAccessibleEventBroadcaster, |
| css::awt::XWindowListener |
| > PresenterAccessibleObjectInterfaceBase; |
| } |
| |
| class PresenterAccessible::AccessibleObject |
| : public ::cppu::BaseMutex, |
| public PresenterAccessibleObjectInterfaceBase |
| { |
| public: |
| AccessibleObject ( |
| const css::lang::Locale aLocale, |
| const sal_Int16 nRole, |
| const ::rtl::OUString& rsName); |
| void LateInitialization (void); |
| |
| virtual ~AccessibleObject (void); |
| |
| virtual void SetWindow ( |
| const cssu::Reference<css::awt::XWindow>& rxContentWindow, |
| const cssu::Reference<css::awt::XWindow>& rxBorderWindow); |
| void SetAccessibleParent (const cssu::Reference<cssa::XAccessible>& rxAccessibleParent); |
| |
| virtual void SAL_CALL disposing (void); |
| |
| void NotifyCurrentSlideChange (const sal_Int32 nCurrentSlideIndex); |
| |
| void AddChild (const ::rtl::Reference<AccessibleObject>& rpChild); |
| void RemoveChild (const ::rtl::Reference<AccessibleObject>& rpChild); |
| |
| void SetIsFocused (const bool bIsFocused); |
| void SetAccessibleName (const ::rtl::OUString& rsName); |
| |
| void FireAccessibleEvent ( |
| const sal_Int16 nEventId, |
| const cssu::Any& rOldValue, |
| const cssu::Any& rNewValue); |
| |
| void UpdateStateSet (void); |
| |
| |
| //----- XAccessible ------------------------------------------------------- |
| |
| virtual cssu::Reference<cssa::XAccessibleContext> SAL_CALL |
| getAccessibleContext (void) |
| throw (cssu::RuntimeException); |
| |
| |
| //----- XAccessibleContext ---------------------------------------------- |
| |
| virtual sal_Int32 SAL_CALL getAccessibleChildCount (void) |
| throw (cssu::RuntimeException); |
| |
| virtual cssu::Reference< cssa::XAccessible> SAL_CALL |
| getAccessibleChild (sal_Int32 nIndex) |
| throw (css::lang::IndexOutOfBoundsException, cssu::RuntimeException); |
| |
| virtual cssu::Reference< cssa::XAccessible> SAL_CALL getAccessibleParent (void) |
| throw (cssu::RuntimeException); |
| |
| virtual sal_Int32 SAL_CALL getAccessibleIndexInParent (void) |
| throw (cssu::RuntimeException); |
| |
| virtual sal_Int16 SAL_CALL getAccessibleRole (void) |
| throw (cssu::RuntimeException); |
| |
| virtual ::rtl::OUString SAL_CALL getAccessibleDescription (void) |
| throw (cssu::RuntimeException); |
| |
| virtual ::rtl::OUString SAL_CALL getAccessibleName (void) |
| throw (cssu::RuntimeException); |
| |
| virtual cssu::Reference<cssa::XAccessibleRelationSet> SAL_CALL |
| getAccessibleRelationSet (void) |
| throw (cssu::RuntimeException); |
| |
| virtual cssu::Reference<cssa::XAccessibleStateSet> SAL_CALL |
| getAccessibleStateSet (void) |
| throw (cssu::RuntimeException); |
| |
| virtual css::lang::Locale SAL_CALL getLocale (void) |
| throw (cssu::RuntimeException, |
| cssa::IllegalAccessibleComponentStateException); |
| |
| |
| //----- XAccessibleComponent -------------------------------------------- |
| |
| virtual sal_Bool SAL_CALL containsPoint ( |
| const css::awt::Point& aPoint) |
| throw (cssu::RuntimeException); |
| |
| virtual cssu::Reference<cssa::XAccessible> SAL_CALL |
| getAccessibleAtPoint ( |
| const css::awt::Point& aPoint) |
| throw (cssu::RuntimeException); |
| |
| virtual css::awt::Rectangle SAL_CALL getBounds (void) |
| throw (cssu::RuntimeException); |
| |
| virtual css::awt::Point SAL_CALL getLocation (void) |
| throw (cssu::RuntimeException); |
| |
| virtual css::awt::Point SAL_CALL getLocationOnScreen (void) |
| throw (cssu::RuntimeException); |
| |
| virtual css::awt::Size SAL_CALL getSize (void) |
| throw (cssu::RuntimeException); |
| |
| virtual void SAL_CALL grabFocus (void) |
| throw (cssu::RuntimeException); |
| |
| virtual sal_Int32 SAL_CALL getForeground (void) |
| throw (cssu::RuntimeException); |
| |
| virtual sal_Int32 SAL_CALL getBackground (void) |
| throw (cssu::RuntimeException); |
| |
| |
| //----- XAccessibleEventBroadcaster -------------------------------------- |
| |
| virtual void SAL_CALL addEventListener ( |
| const cssu::Reference<cssa::XAccessibleEventListener>& rxListener) |
| throw (cssu::RuntimeException); |
| |
| virtual void SAL_CALL removeEventListener ( |
| const cssu::Reference<cssa::XAccessibleEventListener>& rxListener) |
| throw (cssu::RuntimeException); |
| |
| using PresenterAccessibleObjectInterfaceBase::addEventListener; |
| using PresenterAccessibleObjectInterfaceBase::removeEventListener; |
| |
| //----- XWindowListener --------------------------------------------------- |
| |
| virtual void SAL_CALL windowResized (const css::awt::WindowEvent& rEvent) |
| throw (cssu::RuntimeException); |
| |
| virtual void SAL_CALL windowMoved (const css::awt::WindowEvent& rEvent) |
| throw (cssu::RuntimeException); |
| |
| virtual void SAL_CALL windowShown (const css::lang::EventObject& rEvent) |
| throw (cssu::RuntimeException); |
| |
| virtual void SAL_CALL windowHidden (const css::lang::EventObject& rEvent) |
| throw (cssu::RuntimeException); |
| |
| |
| //----- XEventListener ---------------------------------------------------- |
| |
| virtual void SAL_CALL disposing (const css::lang::EventObject& rEvent) |
| throw (cssu::RuntimeException); |
| |
| |
| protected: |
| ::rtl::OUString msName; |
| cssu::Reference<css::awt::XWindow2> mxContentWindow; |
| cssu::Reference<css::awt::XWindow2> mxBorderWindow; |
| const css::lang::Locale maLocale; |
| const sal_Int16 mnRole; |
| sal_uInt32 mnStateSet; |
| bool mbIsFocused; |
| cssu::Reference<cssa::XAccessible> mxParentAccessible; |
| ::std::vector<rtl::Reference<AccessibleObject> > maChildren; |
| ::std::vector<Reference<XAccessibleEventListener> > maListeners; |
| |
| virtual awt::Point GetRelativeLocation (void); |
| virtual awt::Size GetSize (void); |
| virtual awt::Point GetAbsoluteParentLocation (void); |
| |
| virtual bool GetWindowState (const sal_Int16 nType) const; |
| |
| void UpdateState (const sal_Int16 aState, const bool bValue); |
| |
| sal_Bool IsDisposed (void) const; |
| |
| void ThrowIfDisposed (void) const |
| throw (css::lang::DisposedException); |
| |
| enum ExceptionType { ET_Runtime, ET_Disposed, ET_IndexOutOfBounds }; |
| void ThrowException (const sal_Char* pMessage, const ExceptionType eExceptionType) const; |
| }; |
| |
| |
| |
| |
| //===== AccessibleStateSet ==================================================== |
| |
| namespace { |
| typedef ::cppu::WeakComponentImplHelper1 < |
| cssa::XAccessibleStateSet |
| > AccessibleStateSetInterfaceBase; |
| } |
| |
| class AccessibleStateSet |
| : public ::cppu::BaseMutex, |
| public AccessibleStateSetInterfaceBase |
| { |
| public: |
| AccessibleStateSet (const sal_Int32 nStateSet); |
| virtual ~AccessibleStateSet (void); |
| |
| static sal_uInt32 GetStateMask (const sal_Int16 nType); |
| |
| //----- XAccessibleStateSet ----------------------------------------------- |
| |
| virtual sal_Bool SAL_CALL isEmpty (void) |
| throw (cssu::RuntimeException); |
| |
| virtual sal_Bool SAL_CALL contains (sal_Int16 nState) |
| throw (cssu::RuntimeException); |
| |
| virtual sal_Bool SAL_CALL containsAll (const cssu::Sequence<sal_Int16>& rStateSet) |
| throw (cssu::RuntimeException); |
| |
| virtual cssu::Sequence<sal_Int16> SAL_CALL getStates (void) |
| throw (cssu::RuntimeException); |
| |
| private: |
| const sal_Int32 mnStateSet; |
| }; |
| |
| |
| |
| |
| //===== AccessibleRelationSet ================================================= |
| |
| namespace { |
| typedef ::cppu::WeakComponentImplHelper1 < |
| cssa::XAccessibleRelationSet |
| > AccessibleRelationSetInterfaceBase; |
| } |
| |
| class AccessibleRelationSet |
| : public ::cppu::BaseMutex, |
| public AccessibleRelationSetInterfaceBase |
| { |
| public: |
| AccessibleRelationSet (void); |
| virtual ~AccessibleRelationSet (void); |
| |
| void AddRelation ( |
| const sal_Int16 nRelationType, |
| const Reference<XInterface>& rxObject); |
| |
| |
| //----- XAccessibleRelationSet -------------------------------------------- |
| |
| virtual sal_Int32 SAL_CALL getRelationCount (void) |
| throw (cssu::RuntimeException); |
| |
| virtual AccessibleRelation SAL_CALL getRelation (sal_Int32 nIndex) |
| throw (cssu::RuntimeException, css::lang::IndexOutOfBoundsException); |
| |
| virtual sal_Bool SAL_CALL containsRelation (sal_Int16 nRelationType) |
| throw (cssu::RuntimeException); |
| |
| virtual AccessibleRelation SAL_CALL getRelationByType (sal_Int16 nRelationType) |
| throw (cssu::RuntimeException); |
| |
| private: |
| ::std::vector<AccessibleRelation> maRelations; |
| }; |
| |
| |
| |
| |
| //===== PresenterAccessibleParagraph ========================================== |
| |
| namespace { |
| typedef ::cppu::ImplInheritanceHelper1 < |
| PresenterAccessible::AccessibleObject, |
| cssa::XAccessibleText |
| > PresenterAccessibleParagraphInterfaceBase; |
| } |
| |
| |
| |
| |
| class PresenterAccessible::AccessibleParagraph |
| : public PresenterAccessibleParagraphInterfaceBase |
| { |
| public: |
| AccessibleParagraph ( |
| const css::lang::Locale aLocale, |
| const sal_Int16 nRole, |
| const ::rtl::OUString& rsName, |
| const SharedPresenterTextParagraph& rpParagraph, |
| const sal_Int32 nParagraphIndex); |
| |
| virtual ~AccessibleParagraph (void); |
| |
| |
| //----- XAccessibleContext ------------------------------------------------ |
| |
| virtual cssu::Reference<cssa::XAccessibleRelationSet> SAL_CALL |
| getAccessibleRelationSet (void) |
| throw (cssu::RuntimeException); |
| |
| |
| //----- XAccessibleText --------------------------------------------------- |
| |
| virtual sal_Int32 SAL_CALL getCaretPosition (void) |
| throw (cssu::RuntimeException); |
| |
| virtual sal_Bool SAL_CALL setCaretPosition (sal_Int32 nIndex) |
| throw (::com::sun::star::lang::IndexOutOfBoundsException, cssu::RuntimeException); |
| |
| virtual sal_Unicode SAL_CALL getCharacter (sal_Int32 nIndex) |
| throw (::com::sun::star::lang::IndexOutOfBoundsException, cssu::RuntimeException); |
| |
| virtual cssu::Sequence<css::beans::PropertyValue> SAL_CALL |
| getCharacterAttributes ( |
| ::sal_Int32 nIndex, |
| const cssu::Sequence<rtl::OUString>& rRequestedAttributes) |
| throw (css::lang::IndexOutOfBoundsException, cssu::RuntimeException); |
| |
| virtual css::awt::Rectangle SAL_CALL getCharacterBounds (sal_Int32 nIndex) |
| throw (css::lang::IndexOutOfBoundsException, cssu::RuntimeException); |
| |
| virtual sal_Int32 SAL_CALL getCharacterCount (void) |
| throw (cssu::RuntimeException); |
| |
| virtual sal_Int32 SAL_CALL getIndexAtPoint (const css::awt::Point& rPoint) |
| throw (cssu::RuntimeException); |
| |
| virtual ::rtl::OUString SAL_CALL getSelectedText (void) |
| throw (cssu::RuntimeException); |
| |
| virtual sal_Int32 SAL_CALL getSelectionStart (void) |
| throw (cssu::RuntimeException); |
| |
| virtual sal_Int32 SAL_CALL getSelectionEnd (void) |
| throw (cssu::RuntimeException); |
| |
| virtual sal_Bool SAL_CALL setSelection (sal_Int32 nStartIndex, sal_Int32 nEndIndex) |
| throw (css::lang::IndexOutOfBoundsException, cssu::RuntimeException); |
| |
| virtual ::rtl::OUString SAL_CALL getText (void) |
| throw (cssu::RuntimeException); |
| |
| virtual ::rtl::OUString SAL_CALL getTextRange ( |
| sal_Int32 nStartIndex, |
| sal_Int32 nEndIndex) |
| throw (css::lang::IndexOutOfBoundsException, cssu::RuntimeException); |
| |
| virtual cssa::TextSegment SAL_CALL getTextAtIndex ( |
| sal_Int32 nIndex, |
| sal_Int16 nTextType) |
| throw (css::lang::IndexOutOfBoundsException, |
| css::lang::IllegalArgumentException, |
| cssu::RuntimeException); |
| |
| virtual cssa::TextSegment SAL_CALL getTextBeforeIndex ( |
| sal_Int32 nIndex, |
| sal_Int16 nTextType) |
| throw (css::lang::IndexOutOfBoundsException, |
| css::lang::IllegalArgumentException, |
| cssu::RuntimeException); |
| |
| virtual cssa::TextSegment SAL_CALL getTextBehindIndex ( |
| sal_Int32 nIndex, |
| sal_Int16 nTextType) |
| throw (css::lang::IndexOutOfBoundsException, |
| css::lang::IllegalArgumentException, |
| cssu::RuntimeException); |
| |
| virtual ::sal_Bool SAL_CALL copyText (sal_Int32 nStartIndex, sal_Int32 nEndIndex) |
| throw (css::lang::IndexOutOfBoundsException, cssu::RuntimeException); |
| |
| |
| protected: |
| virtual awt::Point GetRelativeLocation (void); |
| virtual awt::Size GetSize (void); |
| virtual awt::Point GetAbsoluteParentLocation (void); |
| virtual bool GetWindowState (const sal_Int16 nType) const; |
| |
| private: |
| SharedPresenterTextParagraph mpParagraph; |
| const sal_Int32 mnParagraphIndex; |
| }; |
| |
| |
| |
| |
| //===== AccessibleConsole ===================================================== |
| |
| class AccessibleConsole |
| { |
| public: |
| static rtl::Reference<PresenterAccessible::AccessibleObject> Create ( |
| const css::uno::Reference<css::uno::XComponentContext>& rxContext, |
| const lang::Locale aLocale) |
| { |
| OUString sName (A2S("Presenter Console")); |
| PresenterConfigurationAccess aConfiguration ( |
| rxContext, |
| OUString::createFromAscii("/org.openoffice.Office.PresenterScreen/"), |
| PresenterConfigurationAccess::READ_ONLY); |
| aConfiguration.GetConfigurationNode(A2S("Presenter/Accessibility/Console/String")) |
| >>= sName; |
| |
| rtl::Reference<PresenterAccessible::AccessibleObject> pObject ( |
| new PresenterAccessible::AccessibleObject( |
| aLocale, AccessibleRole::PANEL, sName)); |
| pObject->LateInitialization(); |
| pObject->UpdateStateSet(); |
| |
| return pObject; |
| } |
| }; |
| |
| |
| |
| |
| //===== AccessiblePreview ===================================================== |
| |
| class AccessiblePreview |
| { |
| public: |
| static rtl::Reference<PresenterAccessible::AccessibleObject> Create ( |
| const Reference<css::uno::XComponentContext>& rxContext, |
| const lang::Locale aLocale, |
| const Reference<awt::XWindow>& rxContentWindow, |
| const Reference<awt::XWindow>& rxBorderWindow) |
| { |
| OUString sName (A2S("Presenter Notes Window")); |
| { |
| PresenterConfigurationAccess aConfiguration ( |
| rxContext, |
| OUString::createFromAscii("/org.openoffice.Office.PresenterScreen/"), |
| PresenterConfigurationAccess::READ_ONLY); |
| aConfiguration.GetConfigurationNode(A2S("Presenter/Accessibility/Preview/String")) |
| >>= sName; |
| } |
| |
| rtl::Reference<PresenterAccessible::AccessibleObject> pObject ( |
| new PresenterAccessible::AccessibleObject( |
| aLocale, |
| AccessibleRole::LABEL, |
| sName)); |
| pObject->LateInitialization(); |
| pObject->UpdateStateSet(); |
| pObject->SetWindow(rxContentWindow, rxBorderWindow); |
| |
| return pObject; |
| } |
| }; |
| |
| |
| |
| |
| //===== AccessibleNotes ======================================================= |
| |
| class AccessibleNotes : public PresenterAccessible::AccessibleObject |
| { |
| public: |
| AccessibleNotes ( |
| const css::lang::Locale aLocale, |
| const sal_Int16 nRole, |
| const ::rtl::OUString& rsName); |
| |
| |
| static rtl::Reference<PresenterAccessible::AccessibleObject> Create ( |
| const css::uno::Reference<css::uno::XComponentContext>& rxContext, |
| const lang::Locale aLocale, |
| const Reference<awt::XWindow>& rxContentWindow, |
| const Reference<awt::XWindow>& rxBorderWindow, |
| const ::boost::shared_ptr<PresenterTextView>& rpTextView); |
| |
| void SetTextView (const ::boost::shared_ptr<PresenterTextView>& rpTextView); |
| |
| virtual void SetWindow ( |
| const cssu::Reference<css::awt::XWindow>& rxContentWindow, |
| const cssu::Reference<css::awt::XWindow>& rxBorderWindow); |
| |
| private: |
| ::boost::shared_ptr<PresenterTextView> mpTextView; |
| |
| void NotifyCaretChange ( |
| const sal_Int32 nOldParagraphIndex, |
| const sal_Int32 nOldCharacterIndex, |
| const sal_Int32 nNewParagraphIndex, |
| const sal_Int32 nNewCharacterIndex); |
| void HandleTextChange (void); |
| }; |
| |
| |
| |
| |
| //===== AccessibleFocusManager ================================================ |
| |
| /** A singleton class that makes sure that only one accessibility object in |
| the PresenterConsole hierarchy has the focus. |
| */ |
| class AccessibleFocusManager |
| { |
| public: |
| static ::boost::shared_ptr<AccessibleFocusManager> Instance (void); |
| |
| void AddFocusableObject (const ::rtl::Reference<PresenterAccessible::AccessibleObject>& rpObject); |
| void RemoveFocusableObject (const ::rtl::Reference<PresenterAccessible::AccessibleObject>& rpObject); |
| |
| void FocusObject (const ::rtl::Reference<PresenterAccessible::AccessibleObject>& rpObject); |
| |
| private: |
| static ::boost::shared_ptr<AccessibleFocusManager> mpInstance; |
| ::std::vector<rtl::Reference<PresenterAccessible::AccessibleObject> > maFocusableObjects; |
| |
| AccessibleFocusManager (void); |
| }; |
| |
| |
| |
| |
| //===== PresenterAccessible =================================================== |
| |
| PresenterAccessible::PresenterAccessible ( |
| const css::uno::Reference<css::uno::XComponentContext>& rxContext, |
| const ::rtl::Reference<PresenterController>& rpPresenterController, |
| const Reference<drawing::framework::XPane>& rxMainPane) |
| : PresenterAccessibleInterfaceBase(m_aMutex), |
| mxComponentContext(rxContext), |
| mpPresenterController(rpPresenterController), |
| mxMainPaneId(rxMainPane.is() ? rxMainPane->getResourceId() : Reference<XResourceId>()), |
| mxMainPane(rxMainPane, UNO_QUERY), |
| mxMainWindow(), |
| mxPreviewContentWindow(), |
| mxPreviewBorderWindow(), |
| mxNotesContentWindow(), |
| mxNotesBorderWindow(), |
| mpAccessibleConsole(), |
| mpAccessiblePreview(), |
| mpAccessibleNotes(), |
| mxAccessibleParent() |
| { |
| if (mxMainPane.is()) |
| mxMainPane->setAccessible(this); |
| } |
| |
| |
| |
| |
| PresenterAccessible::~PresenterAccessible (void) |
| { |
| } |
| |
| |
| |
| |
| PresenterPaneContainer::SharedPaneDescriptor PresenterAccessible::GetPreviewPane (void) const |
| { |
| PresenterPaneContainer::SharedPaneDescriptor pPreviewPane; |
| |
| if ( ! mpPresenterController.is()) |
| return pPreviewPane; |
| |
| rtl::Reference<PresenterPaneContainer> pContainer (mpPresenterController->GetPaneContainer()); |
| if ( ! pContainer.is()) |
| return pPreviewPane; |
| |
| pPreviewPane = pContainer->FindPaneURL(PresenterPaneFactory::msCurrentSlidePreviewPaneURL); |
| Reference<drawing::framework::XPane> xPreviewPane; |
| if (pPreviewPane) |
| xPreviewPane = pPreviewPane->mxPane.get(); |
| if ( ! xPreviewPane.is()) |
| { |
| pPreviewPane = pContainer->FindPaneURL(PresenterPaneFactory::msSlideSorterPaneURL); |
| } |
| return pPreviewPane; |
| } |
| |
| |
| |
| |
| void PresenterAccessible::UpdateAccessibilityHierarchy (void) |
| { |
| if ( ! mpPresenterController.is()) |
| return; |
| |
| Reference<drawing::framework::XConfigurationController> xConfigurationController( |
| mpPresenterController->GetConfigurationController()); |
| if ( ! xConfigurationController.is()) |
| return; |
| |
| rtl::Reference<PresenterPaneContainer> pPaneContainer ( |
| mpPresenterController->GetPaneContainer()); |
| if ( ! pPaneContainer.is()) |
| return; |
| |
| if ( ! mpAccessibleConsole.is()) |
| return; |
| |
| // Get the preview pane (standard or notes view) or the slide overview |
| // pane. |
| PresenterPaneContainer::SharedPaneDescriptor pPreviewPane(GetPreviewPane()); |
| Reference<drawing::framework::XPane> xPreviewPane; |
| if (pPreviewPane) |
| xPreviewPane = pPreviewPane->mxPane.get(); |
| |
| // Get the notes pane. |
| PresenterPaneContainer::SharedPaneDescriptor pNotesPane( |
| pPaneContainer->FindPaneURL(PresenterPaneFactory::msNotesPaneURL)); |
| Reference<drawing::framework::XPane> xNotesPane; |
| if (pNotesPane) |
| xNotesPane = pNotesPane->mxPane.get(); |
| |
| // Get the notes view. |
| Reference<drawing::framework::XView> xNotesView; |
| if (pNotesPane) |
| xNotesView = pNotesPane->mxView; |
| rtl::Reference<PresenterNotesView> pNotesView ( |
| dynamic_cast<PresenterNotesView*>(xNotesView.get())); |
| |
| UpdateAccessibilityHierarchy( |
| pPreviewPane ? pPreviewPane->mxContentWindow : Reference<awt::XWindow>(), |
| pPreviewPane ? pPreviewPane->mxBorderWindow : Reference<awt::XWindow>(), |
| (pPreviewPane&&pPreviewPane->mxPane.is()) ? pPreviewPane->mxPane->GetTitle() : OUString(), |
| pNotesPane ? pNotesPane->mxContentWindow : Reference<awt::XWindow>(), |
| pNotesPane ? pNotesPane->mxBorderWindow : Reference<awt::XWindow>(), |
| pNotesView.is() |
| ? pNotesView->GetTextView() |
| : ::boost::shared_ptr<PresenterTextView>()); |
| } |
| |
| |
| |
| |
| |
| void PresenterAccessible::UpdateAccessibilityHierarchy ( |
| const Reference<awt::XWindow>& rxPreviewContentWindow, |
| const Reference<awt::XWindow>& rxPreviewBorderWindow, |
| const ::rtl::OUString& rsTitle, |
| const Reference<awt::XWindow>& rxNotesContentWindow, |
| const Reference<awt::XWindow>& rxNotesBorderWindow, |
| const ::boost::shared_ptr<PresenterTextView>& rpNotesTextView) |
| { |
| if ( ! mpAccessibleConsole.is()) |
| return; |
| |
| if (mxPreviewContentWindow != rxPreviewContentWindow) |
| { |
| if (mpAccessiblePreview.is()) |
| { |
| mpAccessibleConsole->RemoveChild(mpAccessiblePreview); |
| mpAccessiblePreview = NULL; |
| } |
| |
| mxPreviewContentWindow = rxPreviewContentWindow; |
| mxPreviewBorderWindow = rxPreviewBorderWindow; |
| |
| if (mxPreviewContentWindow.is()) |
| { |
| mpAccessiblePreview = AccessiblePreview::Create( |
| mxComponentContext, |
| lang::Locale(), |
| mxPreviewContentWindow, |
| mxPreviewBorderWindow); |
| mpAccessibleConsole->AddChild(mpAccessiblePreview); |
| mpAccessiblePreview->SetAccessibleName(rsTitle); |
| } |
| } |
| |
| if (mxNotesContentWindow != rxNotesContentWindow) |
| { |
| if (mpAccessibleNotes.is()) |
| { |
| mpAccessibleConsole->RemoveChild(mpAccessibleConsole.get()); |
| mpAccessibleNotes = NULL; |
| } |
| |
| mxNotesContentWindow = rxNotesContentWindow; |
| mxNotesBorderWindow = rxNotesBorderWindow; |
| |
| if (mxNotesContentWindow.is()) |
| { |
| mpAccessibleNotes = AccessibleNotes::Create( |
| mxComponentContext, |
| lang::Locale(), |
| mxNotesContentWindow, |
| mxNotesBorderWindow, |
| rpNotesTextView); |
| mpAccessibleConsole->AddChild(mpAccessibleNotes.get()); |
| } |
| } |
| } |
| |
| |
| |
| |
| void PresenterAccessible::NotifyCurrentSlideChange ( |
| const sal_Int32 nCurrentSlideIndex, |
| const sal_Int32 nSlideCount) |
| { |
| (void)nCurrentSlideIndex; |
| (void)nSlideCount; |
| |
| if (mpAccessiblePreview.is()) |
| { |
| PresenterPaneContainer::SharedPaneDescriptor pPreviewPane (GetPreviewPane()); |
| mpAccessiblePreview->SetAccessibleName( |
| (pPreviewPane&&pPreviewPane->mxPane.is() |
| ? pPreviewPane->mxPane->GetTitle() |
| : rtl::OUString())); |
| } |
| |
| // Play some focus ping-pong to trigger AT tools. |
| //AccessibleFocusManager::Instance()->FocusObject(mpAccessibleConsole); |
| AccessibleFocusManager::Instance()->FocusObject(mpAccessiblePreview); |
| } |
| |
| |
| |
| |
| bool PresenterAccessible::IsAccessibilityActive (void) const |
| { |
| return mpAccessibleConsole.is(); |
| } |
| |
| |
| |
| |
| void SAL_CALL PresenterAccessible::disposing (void) |
| { |
| UpdateAccessibilityHierarchy( |
| NULL, |
| NULL, |
| OUString(), |
| NULL, |
| NULL, |
| ::boost::shared_ptr<PresenterTextView>()); |
| |
| if (mxMainWindow.is()) |
| { |
| mxMainWindow->removeFocusListener(this); |
| |
| if (mxMainPane.is()) |
| mxMainPane->setAccessible(NULL); |
| } |
| |
| mpAccessiblePreview = NULL; |
| mpAccessibleNotes = NULL; |
| mpAccessibleConsole = NULL; |
| } |
| |
| |
| |
| |
| //----- XAccessible ----------------------------------------------------------- |
| |
| Reference<XAccessibleContext> SAL_CALL PresenterAccessible::getAccessibleContext (void) |
| throw (cssu::RuntimeException) |
| { |
| if ( ! mpAccessibleConsole.is()) |
| { |
| Reference<XPane> xMainPane (mxMainPane, UNO_QUERY); |
| if (xMainPane.is()) |
| { |
| mxMainWindow = Reference<awt::XWindow>(xMainPane->getWindow(), UNO_QUERY); |
| mxMainWindow->addFocusListener(this); |
| } |
| mpAccessibleConsole = AccessibleConsole::Create( |
| mxComponentContext, css::lang::Locale()); |
| mpAccessibleConsole->SetWindow(mxMainWindow, NULL); |
| mpAccessibleConsole->SetAccessibleParent(mxAccessibleParent); |
| UpdateAccessibilityHierarchy(); |
| if (mpPresenterController.is()) |
| mpPresenterController->SetAccessibilityActiveState(true); |
| } |
| return mpAccessibleConsole->getAccessibleContext(); |
| } |
| |
| |
| |
| |
| |
| //----- XFocusListener ---------------------------------------------------- |
| |
| void SAL_CALL PresenterAccessible::focusGained (const css::awt::FocusEvent& rEvent) |
| throw (cssu::RuntimeException) |
| { |
| (void)rEvent; |
| |
| #ifdef VERBOSE |
| OSL_TRACE("PresenterAccessible::focusGained at %x and window %x\r", this, |
| mxMainWindow.get()); |
| #endif |
| |
| AccessibleFocusManager::Instance()->FocusObject(mpAccessibleConsole); |
| } |
| |
| |
| |
| |
| void SAL_CALL PresenterAccessible::focusLost (const css::awt::FocusEvent& rEvent) |
| throw (cssu::RuntimeException) |
| { |
| (void)rEvent; |
| |
| #ifdef VERBOSE |
| OSL_TRACE("PresenterAccessible::focusLost at %x\r", this); |
| #endif |
| |
| AccessibleFocusManager::Instance()->FocusObject(NULL); |
| } |
| |
| |
| |
| |
| //----- XEventListener ---------------------------------------------------- |
| |
| void SAL_CALL PresenterAccessible::disposing (const css::lang::EventObject& rEvent) |
| throw (cssu::RuntimeException) |
| { |
| if (rEvent.Source == mxMainWindow) |
| mxMainWindow = NULL; |
| } |
| |
| |
| |
| |
| //----- XInitialize ----------------------------------------------------------- |
| |
| void SAL_CALL PresenterAccessible::initialize (const cssu::Sequence<cssu::Any>& rArguments) |
| throw (cssu::RuntimeException) |
| { |
| if (rArguments.getLength() >= 1) |
| { |
| mxAccessibleParent = Reference<XAccessible>(rArguments[0], UNO_QUERY); |
| if (mpAccessibleConsole.is()) |
| mpAccessibleConsole->SetAccessibleParent(mxAccessibleParent); |
| } |
| } |
| |
| |
| |
| |
| //===== PresenterAccessible::AccessibleObject ========================================= |
| |
| PresenterAccessible::AccessibleObject::AccessibleObject ( |
| const lang::Locale aLocale, |
| const sal_Int16 nRole, |
| const OUString& rsName) |
| : PresenterAccessibleObjectInterfaceBase(m_aMutex), |
| msName(rsName), |
| mxContentWindow(), |
| mxBorderWindow(), |
| maLocale(aLocale), |
| mnRole(nRole), |
| mnStateSet(0), |
| mbIsFocused(false), |
| mxParentAccessible(), |
| maChildren(), |
| maListeners() |
| { |
| } |
| |
| |
| |
| |
| void PresenterAccessible::AccessibleObject::LateInitialization (void) |
| { |
| AccessibleFocusManager::Instance()->AddFocusableObject(this); |
| } |
| |
| |
| |
| |
| PresenterAccessible::AccessibleObject::~AccessibleObject (void) |
| { |
| } |
| |
| |
| |
| |
| void PresenterAccessible::AccessibleObject::SetWindow ( |
| const Reference<awt::XWindow>& rxContentWindow, |
| const Reference<awt::XWindow>& rxBorderWindow) |
| { |
| Reference<awt::XWindow2> xContentWindow (rxContentWindow, UNO_QUERY); |
| |
| if (mxContentWindow.get() != xContentWindow.get()) |
| { |
| if (mxContentWindow.is()) |
| { |
| mxContentWindow->removeWindowListener(this); |
| } |
| |
| mxContentWindow = xContentWindow; |
| mxBorderWindow = Reference<awt::XWindow2>(rxBorderWindow, UNO_QUERY); |
| |
| if (mxContentWindow.is()) |
| { |
| mxContentWindow->addWindowListener(this); |
| } |
| |
| UpdateStateSet(); |
| } |
| } |
| |
| |
| |
| |
| void PresenterAccessible::AccessibleObject::SetAccessibleParent ( |
| const Reference<XAccessible>& rxAccessibleParent) |
| { |
| mxParentAccessible = rxAccessibleParent; |
| } |
| |
| |
| |
| |
| void SAL_CALL PresenterAccessible::AccessibleObject::disposing (void) |
| { |
| AccessibleFocusManager::Instance()->RemoveFocusableObject(this); |
| SetWindow(NULL, NULL); |
| } |
| |
| |
| |
| |
| //----- XAccessible ------------------------------------------------------- |
| |
| Reference<XAccessibleContext> SAL_CALL |
| PresenterAccessible::AccessibleObject::getAccessibleContext (void) |
| throw (RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| return this; |
| } |
| |
| |
| |
| |
| //----- XAccessibleContext ---------------------------------------------- |
| |
| sal_Int32 SAL_CALL PresenterAccessible::AccessibleObject::getAccessibleChildCount (void) |
| throw (cssu::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| const sal_Int32 nChildCount (maChildren.size()); |
| |
| return nChildCount; |
| } |
| |
| |
| |
| |
| Reference<XAccessible> SAL_CALL |
| PresenterAccessible::AccessibleObject::getAccessibleChild (sal_Int32 nIndex) |
| throw (lang::IndexOutOfBoundsException, RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| if (nIndex<0 || nIndex>=sal_Int32(maChildren.size())) |
| ThrowException("invalid child index", ET_IndexOutOfBounds); |
| |
| return Reference<XAccessible>(maChildren[nIndex].get()); |
| } |
| |
| |
| |
| |
| Reference<XAccessible> SAL_CALL |
| PresenterAccessible::AccessibleObject::getAccessibleParent (void) |
| throw (RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| return mxParentAccessible; |
| } |
| |
| |
| |
| |
| sal_Int32 SAL_CALL |
| PresenterAccessible::AccessibleObject::getAccessibleIndexInParent (void) |
| throw (RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| const Reference<XAccessible> xThis (this); |
| if (mxParentAccessible.is()) |
| { |
| const Reference<XAccessibleContext> xContext (mxParentAccessible->getAccessibleContext()); |
| for (sal_Int32 nIndex=0,nCount=xContext->getAccessibleChildCount(); |
| nIndex<nCount; |
| ++nIndex) |
| { |
| if (xContext->getAccessibleChild(nIndex) == xThis) |
| return nIndex; |
| } |
| } |
| |
| return 0; |
| } |
| |
| |
| |
| |
| sal_Int16 SAL_CALL |
| PresenterAccessible::AccessibleObject::getAccessibleRole (void) |
| throw (RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| return mnRole; |
| } |
| |
| |
| |
| |
| OUString SAL_CALL |
| PresenterAccessible::AccessibleObject::getAccessibleDescription (void) |
| throw (RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| return msName; |
| } |
| |
| |
| |
| |
| OUString SAL_CALL |
| PresenterAccessible::AccessibleObject::getAccessibleName (void) |
| throw (cssu::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| return msName; |
| } |
| |
| |
| |
| |
| Reference<XAccessibleRelationSet> SAL_CALL |
| PresenterAccessible::AccessibleObject::getAccessibleRelationSet (void) |
| throw (RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| return NULL; |
| } |
| |
| |
| |
| |
| Reference<XAccessibleStateSet> SAL_CALL |
| PresenterAccessible::AccessibleObject::getAccessibleStateSet (void) |
| throw (RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| return Reference<XAccessibleStateSet>(new AccessibleStateSet(mnStateSet)); |
| } |
| |
| |
| |
| |
| lang::Locale SAL_CALL |
| PresenterAccessible::AccessibleObject::getLocale (void) |
| throw (RuntimeException, |
| IllegalAccessibleComponentStateException) |
| { |
| ThrowIfDisposed(); |
| |
| if (mxParentAccessible.is()) |
| { |
| Reference<XAccessibleContext> xParentContext (mxParentAccessible->getAccessibleContext()); |
| if (xParentContext.is()) |
| return xParentContext->getLocale(); |
| } |
| return maLocale; |
| } |
| |
| |
| |
| |
| //----- XAccessibleComponent ------------------------------------------------ |
| |
| sal_Bool SAL_CALL PresenterAccessible::AccessibleObject::containsPoint ( |
| const awt::Point& rPoint) |
| throw (RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| if (mxContentWindow.is()) |
| { |
| const awt::Rectangle aBox (getBounds()); |
| return rPoint.X>=aBox.X |
| && rPoint.Y>=aBox.Y |
| && rPoint.X<aBox.X+aBox.Width |
| && rPoint.Y<aBox.Y+aBox.Height; |
| } |
| else |
| return false; |
| } |
| |
| |
| |
| |
| Reference<XAccessible> SAL_CALL |
| PresenterAccessible::AccessibleObject::getAccessibleAtPoint (const awt::Point& rPoint) |
| throw (RuntimeException) |
| { |
| (void)rPoint; |
| ThrowIfDisposed(); |
| |
| return Reference<XAccessible>(); |
| } |
| |
| |
| |
| |
| awt::Rectangle SAL_CALL PresenterAccessible::AccessibleObject::getBounds (void) |
| throw (RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| awt::Rectangle aBox; |
| |
| const awt::Point aLocation (GetRelativeLocation()); |
| const awt::Size aSize (GetSize()); |
| |
| return awt::Rectangle (aLocation.X, aLocation.Y, aSize.Width, aSize.Height); |
| } |
| |
| |
| |
| |
| awt::Point SAL_CALL PresenterAccessible::AccessibleObject::getLocation (void) |
| throw (RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| const awt::Point aLocation (GetRelativeLocation()); |
| |
| return aLocation; |
| } |
| |
| |
| |
| |
| awt::Point SAL_CALL PresenterAccessible::AccessibleObject::getLocationOnScreen (void) |
| throw (RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| awt::Point aRelativeLocation (GetRelativeLocation()); |
| awt::Point aParentLocationOnScreen (GetAbsoluteParentLocation()); |
| |
| return awt::Point( |
| aRelativeLocation.X + aParentLocationOnScreen.X, |
| aRelativeLocation.Y + aParentLocationOnScreen.Y); |
| } |
| |
| |
| |
| |
| awt::Size SAL_CALL PresenterAccessible::AccessibleObject::getSize (void) |
| throw (RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| const awt::Size aSize (GetSize()); |
| |
| return aSize; |
| } |
| |
| |
| |
| |
| void SAL_CALL PresenterAccessible::AccessibleObject::grabFocus (void) |
| throw (RuntimeException) |
| { |
| ThrowIfDisposed(); |
| if (mxBorderWindow.is()) |
| mxBorderWindow->setFocus(); |
| else if (mxContentWindow.is()) |
| mxContentWindow->setFocus(); |
| } |
| |
| |
| |
| |
| sal_Int32 SAL_CALL PresenterAccessible::AccessibleObject::getForeground (void) |
| throw (RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| return 0x00ffffff; |
| } |
| |
| |
| |
| |
| sal_Int32 SAL_CALL PresenterAccessible::AccessibleObject::getBackground (void) |
| throw (RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| return 0x00000000; |
| } |
| |
| |
| |
| |
| //----- XAccessibleEventBroadcaster ------------------------------------------- |
| |
| void SAL_CALL PresenterAccessible::AccessibleObject::addEventListener ( |
| const Reference<XAccessibleEventListener>& rxListener) |
| throw (RuntimeException) |
| { |
| if (rxListener.is()) |
| { |
| const osl::MutexGuard aGuard(m_aMutex); |
| |
| if (IsDisposed()) |
| { |
| uno::Reference<uno::XInterface> xThis (static_cast<XWeak*>(this), UNO_QUERY); |
| rxListener->disposing (lang::EventObject(xThis)); |
| } |
| else |
| { |
| maListeners.push_back(rxListener); |
| } |
| } |
| } |
| |
| |
| |
| |
| void SAL_CALL PresenterAccessible::AccessibleObject::removeEventListener ( |
| const Reference<XAccessibleEventListener>& rxListener) |
| throw (RuntimeException) |
| { |
| ThrowIfDisposed(); |
| if (rxListener.is()) |
| { |
| const osl::MutexGuard aGuard(m_aMutex); |
| |
| maListeners.erase(std::remove(maListeners.begin(), maListeners.end(), rxListener)); |
| } |
| } |
| |
| |
| |
| |
| //----- XWindowListener --------------------------------------------------- |
| |
| void SAL_CALL PresenterAccessible::AccessibleObject::windowResized ( |
| const css::awt::WindowEvent& rEvent) |
| throw (cssu::RuntimeException) |
| { |
| (void)rEvent; |
| |
| FireAccessibleEvent(AccessibleEventId::BOUNDRECT_CHANGED, Any(), Any()); |
| } |
| |
| |
| |
| |
| void SAL_CALL PresenterAccessible::AccessibleObject::windowMoved ( |
| const css::awt::WindowEvent& rEvent) |
| throw (cssu::RuntimeException) |
| { |
| (void)rEvent; |
| |
| FireAccessibleEvent(AccessibleEventId::BOUNDRECT_CHANGED, Any(), Any()); |
| } |
| |
| |
| |
| |
| void SAL_CALL PresenterAccessible::AccessibleObject::windowShown ( |
| const css::lang::EventObject& rEvent) |
| throw (cssu::RuntimeException) |
| { |
| (void)rEvent; |
| UpdateStateSet(); |
| } |
| |
| |
| |
| |
| void SAL_CALL PresenterAccessible::AccessibleObject::windowHidden ( |
| const css::lang::EventObject& rEvent) |
| throw (cssu::RuntimeException) |
| { |
| (void)rEvent; |
| UpdateStateSet(); |
| } |
| |
| |
| |
| |
| //----- XEventListener -------------------------------------------------------- |
| |
| void SAL_CALL PresenterAccessible::AccessibleObject::disposing (const css::lang::EventObject& rEvent) |
| throw (cssu::RuntimeException) |
| { |
| if (rEvent.Source == mxContentWindow) |
| { |
| mxContentWindow = NULL; |
| mxBorderWindow = NULL; |
| } |
| else |
| { |
| SetWindow(NULL, NULL); |
| } |
| } |
| |
| |
| |
| |
| //----- private --------------------------------------------------------------- |
| |
| bool PresenterAccessible::AccessibleObject::GetWindowState (const sal_Int16 nType) const |
| { |
| switch (nType) |
| { |
| case AccessibleStateType::ENABLED: |
| return mxContentWindow.is() && mxContentWindow->isEnabled(); |
| |
| case AccessibleStateType::FOCUSABLE: |
| return true; |
| |
| case AccessibleStateType::FOCUSED: |
| return mbIsFocused; |
| |
| case AccessibleStateType::SHOWING: |
| return mxContentWindow.is() && mxContentWindow->isVisible(); |
| |
| default: |
| return false; |
| } |
| } |
| |
| |
| |
| |
| void PresenterAccessible::AccessibleObject::UpdateStateSet (void) |
| { |
| UpdateState(AccessibleStateType::FOCUSABLE, true); |
| UpdateState(AccessibleStateType::VISIBLE, true); |
| UpdateState(AccessibleStateType::ENABLED, true); |
| UpdateState(AccessibleStateType::MULTI_LINE, true); |
| UpdateState(AccessibleStateType::SENSITIVE, true); |
| |
| UpdateState(AccessibleStateType::ENABLED, GetWindowState(AccessibleStateType::ENABLED)); |
| UpdateState(AccessibleStateType::FOCUSED, GetWindowState(AccessibleStateType::FOCUSED)); |
| UpdateState(AccessibleStateType::SHOWING, GetWindowState(AccessibleStateType::SHOWING)); |
| // UpdateState(AccessibleStateType::ACTIVE, GetWindowState(AccessibleStateType::ACTIVE)); |
| } |
| |
| |
| |
| |
| void PresenterAccessible::AccessibleObject::UpdateState( |
| const sal_Int16 nState, |
| const bool bValue) |
| { |
| const sal_uInt32 nStateMask (AccessibleStateSet::GetStateMask(nState)); |
| if (((mnStateSet & nStateMask)!=0) != bValue) |
| { |
| if (bValue) |
| { |
| mnStateSet |= nStateMask; |
| FireAccessibleEvent(AccessibleEventId::STATE_CHANGED, Any(), Any(nState)); |
| } |
| else |
| { |
| mnStateSet &= ~nStateMask; |
| FireAccessibleEvent(AccessibleEventId::STATE_CHANGED, Any(nState), Any()); |
| } |
| } |
| } |
| |
| |
| |
| |
| void PresenterAccessible::AccessibleObject::AddChild ( |
| const ::rtl::Reference<AccessibleObject>& rpChild) |
| { |
| maChildren.push_back(rpChild); |
| rpChild->SetAccessibleParent(this); |
| FireAccessibleEvent(AccessibleEventId::INVALIDATE_ALL_CHILDREN, Any(), Any()); |
| } |
| |
| |
| |
| |
| void PresenterAccessible::AccessibleObject::RemoveChild ( |
| const ::rtl::Reference<AccessibleObject>& rpChild) |
| { |
| rpChild->SetAccessibleParent(Reference<XAccessible>()); |
| maChildren.erase(::std::find(maChildren.begin(), maChildren.end(), rpChild)); |
| FireAccessibleEvent(AccessibleEventId::INVALIDATE_ALL_CHILDREN, Any(), Any()); |
| } |
| |
| |
| |
| |
| void PresenterAccessible::AccessibleObject::SetIsFocused (const bool bIsFocused) |
| { |
| if (mbIsFocused != bIsFocused) |
| { |
| mbIsFocused = bIsFocused; |
| UpdateStateSet(); |
| } |
| } |
| |
| |
| |
| |
| void PresenterAccessible::AccessibleObject::SetAccessibleName (const ::rtl::OUString& rsName) |
| { |
| if (msName != rsName) |
| { |
| const OUString sOldName(msName); |
| msName = rsName; |
| FireAccessibleEvent(AccessibleEventId::NAME_CHANGED, Any(sOldName), Any(msName)); |
| } |
| } |
| |
| |
| |
| |
| void PresenterAccessible::AccessibleObject::FireAccessibleEvent ( |
| const sal_Int16 nEventId, |
| const uno::Any& rOldValue, |
| const uno::Any& rNewValue ) |
| { |
| AccessibleEventObject aEventObject; |
| |
| aEventObject.Source = Reference<XWeak>(this); |
| aEventObject.EventId = nEventId; |
| aEventObject.NewValue = rNewValue; |
| aEventObject.OldValue = rOldValue; |
| |
| ::std::vector<Reference<XAccessibleEventListener> > aListenerCopy(maListeners); |
| for (::std::vector<Reference<XAccessibleEventListener> >::const_iterator |
| iListener(aListenerCopy.begin()), |
| iEnd(aListenerCopy.end()); |
| iListener!=iEnd; |
| ++iListener) |
| { |
| try |
| { |
| (*iListener)->notifyEvent(aEventObject); |
| } |
| catch(lang::DisposedException&) |
| { |
| // Listener has been disposed and should have been removed |
| // already. |
| removeEventListener(*iListener); |
| } |
| catch(Exception&) |
| { |
| // Ignore all other exceptions and assume that they are |
| // caused by a temporary problem. |
| } |
| } |
| } |
| |
| |
| |
| awt::Point PresenterAccessible::AccessibleObject::GetRelativeLocation (void) |
| { |
| awt::Point aLocation; |
| if (mxContentWindow.is()) |
| { |
| const awt::Rectangle aContentBox (mxContentWindow->getPosSize()); |
| aLocation.X = aContentBox.X; |
| aLocation.Y = aContentBox.Y; |
| if (mxBorderWindow.is()) |
| { |
| const awt::Rectangle aBorderBox (mxBorderWindow->getPosSize()); |
| aLocation.X += aBorderBox.X; |
| aLocation.Y += aBorderBox.Y; |
| } |
| } |
| return aLocation; |
| } |
| |
| |
| |
| |
| awt::Size PresenterAccessible::AccessibleObject::GetSize (void) |
| { |
| if (mxContentWindow.is()) |
| { |
| const awt::Rectangle aBox (mxContentWindow->getPosSize()); |
| return awt::Size(aBox.Width, aBox.Height); |
| } |
| else |
| return awt::Size(); |
| } |
| |
| |
| |
| |
| awt::Point PresenterAccessible::AccessibleObject::GetAbsoluteParentLocation (void) |
| { |
| Reference<XAccessibleComponent> xParentComponent; |
| if (mxParentAccessible.is()) |
| xParentComponent = Reference<XAccessibleComponent>( |
| mxParentAccessible->getAccessibleContext(), UNO_QUERY); |
| if (xParentComponent.is()) |
| return xParentComponent->getLocationOnScreen(); |
| else |
| return awt::Point(); |
| } |
| |
| |
| |
| |
| sal_Bool PresenterAccessible::AccessibleObject::IsDisposed (void) const |
| { |
| return (rBHelper.bDisposed || rBHelper.bInDispose); |
| } |
| |
| |
| |
| |
| void PresenterAccessible::AccessibleObject::ThrowIfDisposed (void) const |
| throw (lang::DisposedException) |
| { |
| if (rBHelper.bDisposed || rBHelper.bInDispose) |
| ThrowException("object has already been disposed", ET_Disposed); |
| } |
| |
| |
| |
| |
| void PresenterAccessible::AccessibleObject::ThrowException ( |
| const sal_Char* pMessage, |
| const ExceptionType eExceptionType) const |
| { |
| const OUString sMessage (OUString(A2S("PresenterAccessible: ")) + OUString(A2S(pMessage))); |
| const Reference<XInterface> xObject ( |
| const_cast<uno::XWeak*>(static_cast<const uno::XWeak*>(this))); |
| switch (eExceptionType) |
| { |
| default: |
| case ET_Runtime: |
| throw RuntimeException(sMessage, xObject); |
| case ET_Disposed: |
| throw lang::DisposedException(sMessage, xObject); |
| case ET_IndexOutOfBounds: |
| throw lang::IndexOutOfBoundsException(sMessage, xObject); |
| } |
| } |
| |
| |
| |
| |
| |
| //===== AccessibleStateSet ==================================================== |
| |
| AccessibleStateSet::AccessibleStateSet (const sal_Int32 nStateSet) |
| : AccessibleStateSetInterfaceBase(m_aMutex), |
| mnStateSet (nStateSet) |
| { |
| } |
| |
| |
| |
| |
| AccessibleStateSet::~AccessibleStateSet (void) |
| { |
| } |
| |
| |
| |
| |
| sal_uInt32 AccessibleStateSet::GetStateMask (const sal_Int16 nState) |
| { |
| if (nState<0 || nState>=sal_Int16(sizeof(sal_uInt32)*8)) |
| { |
| throw RuntimeException(A2S("AccessibleStateSet::GetStateMask: invalid state"), NULL); |
| } |
| |
| return 1<<nState; |
| } |
| |
| |
| |
| |
| //----- XAccessibleStateSet --------------------------------------------------- |
| |
| sal_Bool SAL_CALL AccessibleStateSet::isEmpty (void) |
| throw (cssu::RuntimeException) |
| { |
| return mnStateSet==0; |
| } |
| |
| |
| |
| |
| sal_Bool SAL_CALL AccessibleStateSet::contains (sal_Int16 nState) |
| throw (cssu::RuntimeException) |
| { |
| return (mnStateSet & GetStateMask(nState)) != 0; |
| } |
| |
| |
| |
| |
| sal_Bool SAL_CALL AccessibleStateSet::containsAll (const cssu::Sequence<sal_Int16>& rStateSet) |
| throw (cssu::RuntimeException) |
| { |
| for (sal_Int32 nIndex=0,nCount=rStateSet.getLength(); nIndex<nCount; ++nIndex) |
| { |
| if ((mnStateSet & GetStateMask(rStateSet[nIndex])) == 0) |
| return sal_False; |
| } |
| return sal_True; |
| } |
| |
| |
| |
| |
| cssu::Sequence<sal_Int16> SAL_CALL AccessibleStateSet::getStates (void) |
| throw (cssu::RuntimeException) |
| { |
| ::std::vector<sal_Int16> aStates; |
| aStates.reserve(sizeof(mnStateSet)*8); |
| for (sal_uInt16 nIndex=0; nIndex<sizeof(mnStateSet)*8; ++nIndex) |
| if ((mnStateSet & GetStateMask(nIndex)) != 0) |
| aStates.push_back(nIndex); |
| return Sequence<sal_Int16>(&aStates.front(), aStates.size()); |
| } |
| |
| |
| |
| |
| //===== AccessibleRelationSet ================================================= |
| |
| AccessibleRelationSet::AccessibleRelationSet (void) |
| : AccessibleRelationSetInterfaceBase(m_aMutex), |
| maRelations() |
| { |
| } |
| |
| |
| |
| |
| AccessibleRelationSet::~AccessibleRelationSet (void) |
| { |
| } |
| |
| |
| |
| |
| void AccessibleRelationSet::AddRelation ( |
| const sal_Int16 nRelationType, |
| const Reference<XInterface>& rxObject) |
| { |
| maRelations.resize(maRelations.size()+1); |
| maRelations.back().RelationType = nRelationType; |
| maRelations.back().TargetSet.realloc(1); |
| maRelations.back().TargetSet[0] = rxObject; |
| } |
| |
| |
| |
| |
| //----- XAccessibleRelationSet ------------------------------------------------ |
| |
| sal_Int32 SAL_CALL AccessibleRelationSet::getRelationCount (void) |
| throw (cssu::RuntimeException) |
| { |
| return maRelations.size(); |
| } |
| |
| |
| |
| |
| AccessibleRelation SAL_CALL AccessibleRelationSet::getRelation (sal_Int32 nIndex) |
| throw (cssu::RuntimeException, css::lang::IndexOutOfBoundsException) |
| { |
| if (nIndex<0 && sal_uInt32(nIndex)>=maRelations.size()) |
| return AccessibleRelation(); |
| else |
| return maRelations[nIndex]; |
| } |
| |
| |
| |
| |
| sal_Bool SAL_CALL AccessibleRelationSet::containsRelation (sal_Int16 nRelationType) |
| throw (cssu::RuntimeException) |
| { |
| for (::std::vector<AccessibleRelation>::const_iterator iRelation(maRelations.begin()); |
| iRelation!=maRelations.end(); |
| ++iRelation) |
| { |
| if (iRelation->RelationType == nRelationType) |
| return sal_True; |
| } |
| return sal_False; |
| } |
| |
| |
| |
| |
| AccessibleRelation SAL_CALL AccessibleRelationSet::getRelationByType (sal_Int16 nRelationType) |
| throw (cssu::RuntimeException) |
| { |
| for (::std::vector<AccessibleRelation>::const_iterator iRelation(maRelations.begin()); |
| iRelation!=maRelations.end(); |
| ++iRelation) |
| { |
| if (iRelation->RelationType == nRelationType) |
| return *iRelation; |
| } |
| return AccessibleRelation(); |
| } |
| |
| |
| |
| |
| //===== PresenterAccessible::AccessibleParagraph ============================== |
| |
| PresenterAccessible::AccessibleParagraph::AccessibleParagraph ( |
| const lang::Locale aLocale, |
| const sal_Int16 nRole, |
| const OUString& rsName, |
| const SharedPresenterTextParagraph& rpParagraph, |
| const sal_Int32 nParagraphIndex) |
| : PresenterAccessibleParagraphInterfaceBase(aLocale, nRole, rsName), |
| mpParagraph(rpParagraph), |
| mnParagraphIndex(nParagraphIndex) |
| { |
| } |
| |
| |
| |
| |
| PresenterAccessible::AccessibleParagraph::~AccessibleParagraph (void) |
| { |
| } |
| |
| |
| |
| |
| //----- XAccessibleContext ---------------------------------------------------- |
| |
| Reference<XAccessibleRelationSet> SAL_CALL |
| PresenterAccessible::AccessibleParagraph::getAccessibleRelationSet (void) |
| throw (RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| rtl::Reference<AccessibleRelationSet> pSet (new AccessibleRelationSet); |
| |
| if (mxParentAccessible.is()) |
| { |
| Reference<XAccessibleContext> xParentContext (mxParentAccessible->getAccessibleContext()); |
| if (xParentContext.is()) |
| { |
| if (mnParagraphIndex>0) |
| pSet->AddRelation( |
| AccessibleRelationType::CONTENT_FLOWS_FROM, |
| xParentContext->getAccessibleChild(mnParagraphIndex-1)); |
| |
| if (mnParagraphIndex<xParentContext->getAccessibleChildCount()-1) |
| pSet->AddRelation( |
| AccessibleRelationType::CONTENT_FLOWS_TO, |
| xParentContext->getAccessibleChild(mnParagraphIndex+1)); |
| } |
| } |
| |
| return Reference<XAccessibleRelationSet>(pSet.get()); |
| } |
| |
| |
| |
| |
| |
| |
| //----- XAccessibleText ------------------------------------------------------- |
| |
| sal_Int32 SAL_CALL PresenterAccessible::AccessibleParagraph::getCaretPosition (void) |
| throw (cssu::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| sal_Int32 nPosition (-1); |
| if (mpParagraph) |
| nPosition = mpParagraph->GetCaretPosition(); |
| |
| return nPosition; |
| } |
| |
| |
| |
| |
| sal_Bool SAL_CALL PresenterAccessible::AccessibleParagraph::setCaretPosition (sal_Int32 nIndex) |
| throw (::com::sun::star::lang::IndexOutOfBoundsException, cssu::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| if (mpParagraph) |
| { |
| mpParagraph->SetCaretPosition(nIndex); |
| return sal_True; |
| } |
| else |
| return sal_False; |
| } |
| |
| |
| |
| |
| sal_Unicode SAL_CALL PresenterAccessible::AccessibleParagraph::getCharacter (sal_Int32 nIndex) |
| throw (::com::sun::star::lang::IndexOutOfBoundsException, cssu::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| if (mpParagraph) |
| return mpParagraph->GetCharacter(nIndex); |
| else |
| { |
| ThrowException("no text support in current mode", ET_IndexOutOfBounds); |
| // The method above throws an exception and the following line is |
| // never reached. But there is at least one compiler that can not |
| // detect this and we need the return to make it happy. |
| return sal_Unicode(); |
| } |
| } |
| |
| |
| |
| |
| Sequence<css::beans::PropertyValue> SAL_CALL |
| PresenterAccessible::AccessibleParagraph::getCharacterAttributes ( |
| ::sal_Int32 nIndex, |
| const cssu::Sequence<rtl::OUString>& rRequestedAttributes) |
| throw (css::lang::IndexOutOfBoundsException, cssu::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| #ifdef VERBOSE |
| OSL_TRACE("PresenterAccessible::AccessibleParagraph::getCharacterAttributes at %x,%d returns empty set\r", |
| this,nIndex); |
| for (sal_Int32 nAttributeIndex(0),nAttributeCount(rRequestedAttributes.getLength()); |
| nAttributeIndex<nAttributeCount; |
| ++nAttributeIndex) |
| { |
| OSL_TRACE(" requested attribute %d is %s\r", |
| nAttributeIndex, |
| OUStringToOString(rRequestedAttributes[nAttributeIndex], RTL_TEXTENCODING_UTF8).getStr()); |
| } |
| #endif |
| |
| // Character properties are not supported. |
| (void)nIndex; |
| (void)rRequestedAttributes; |
| return Sequence<css::beans::PropertyValue>(); |
| } |
| |
| |
| |
| |
| awt::Rectangle SAL_CALL PresenterAccessible::AccessibleParagraph::getCharacterBounds ( |
| sal_Int32 nIndex) |
| throw (css::lang::IndexOutOfBoundsException, cssu::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| awt::Rectangle aCharacterBox; |
| if (nIndex < 0) |
| { |
| ThrowException("invalid text index", ET_IndexOutOfBounds); |
| } |
| else if (mpParagraph) |
| { |
| aCharacterBox = mpParagraph->GetCharacterBounds(nIndex, false); |
| // Convert coordinates relative to the window origin into absolute |
| // screen coordinates. |
| const awt::Point aWindowLocationOnScreen (getLocationOnScreen()); |
| aCharacterBox.X += aWindowLocationOnScreen.X; |
| aCharacterBox.Y += aWindowLocationOnScreen.Y; |
| } |
| else |
| { |
| ThrowException("no text support in current mode", ET_IndexOutOfBounds); |
| } |
| |
| return aCharacterBox; |
| } |
| |
| |
| |
| |
| sal_Int32 SAL_CALL PresenterAccessible::AccessibleParagraph::getCharacterCount (void) |
| throw (cssu::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| sal_Int32 nCount (0); |
| if (mpParagraph) |
| nCount = mpParagraph->GetCharacterCount(); |
| |
| return nCount; |
| } |
| |
| |
| |
| |
| sal_Int32 SAL_CALL PresenterAccessible::AccessibleParagraph::getIndexAtPoint ( |
| const css::awt::Point& rPoint) |
| throw (cssu::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| sal_Int32 nIndex (-1); |
| if (mpParagraph) |
| nIndex = mpParagraph->GetIndexAtPoint(rPoint); |
| |
| return nIndex; |
| } |
| |
| |
| |
| |
| ::rtl::OUString SAL_CALL PresenterAccessible::AccessibleParagraph::getSelectedText (void) |
| throw (cssu::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| return getTextRange(getSelectionStart(), getSelectionEnd()); |
| } |
| |
| |
| |
| |
| sal_Int32 SAL_CALL PresenterAccessible::AccessibleParagraph::getSelectionStart (void) |
| throw (cssu::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| return getCaretPosition(); |
| } |
| |
| |
| |
| |
| sal_Int32 SAL_CALL PresenterAccessible::AccessibleParagraph::getSelectionEnd (void) |
| throw (cssu::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| return getCaretPosition(); |
| } |
| |
| |
| |
| |
| sal_Bool SAL_CALL PresenterAccessible::AccessibleParagraph::setSelection ( |
| sal_Int32 nStartIndex, |
| sal_Int32 nEndIndex) |
| throw (css::lang::IndexOutOfBoundsException, cssu::RuntimeException) |
| { |
| (void)nEndIndex; |
| ThrowIfDisposed(); |
| |
| return setCaretPosition(nStartIndex); |
| } |
| |
| |
| |
| |
| ::rtl::OUString SAL_CALL PresenterAccessible::AccessibleParagraph::getText (void) |
| throw (cssu::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| ::rtl::OUString sText; |
| if (mpParagraph) |
| sText = mpParagraph->GetText(); |
| |
| return sText; |
| } |
| |
| |
| |
| |
| ::rtl::OUString SAL_CALL PresenterAccessible::AccessibleParagraph::getTextRange ( |
| sal_Int32 nLocalStartIndex, |
| sal_Int32 nLocalEndIndex) |
| throw (css::lang::IndexOutOfBoundsException, cssu::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| ::rtl::OUString sText; |
| if (mpParagraph) |
| { |
| const TextSegment aSegment ( |
| mpParagraph->CreateTextSegment(nLocalStartIndex, nLocalEndIndex)); |
| sText = aSegment.SegmentText; |
| } |
| |
| return sText; |
| } |
| |
| |
| |
| |
| TextSegment SAL_CALL PresenterAccessible::AccessibleParagraph::getTextAtIndex ( |
| sal_Int32 nLocalCharacterIndex, |
| sal_Int16 nTextType) |
| throw (css::lang::IndexOutOfBoundsException, |
| css::lang::IllegalArgumentException, |
| cssu::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| TextSegment aSegment; |
| if (mpParagraph) |
| aSegment = mpParagraph->GetTextSegment(0, nLocalCharacterIndex, nTextType); |
| |
| return aSegment; |
| } |
| |
| |
| |
| |
| TextSegment SAL_CALL PresenterAccessible::AccessibleParagraph::getTextBeforeIndex ( |
| sal_Int32 nLocalCharacterIndex, |
| sal_Int16 nTextType) |
| throw (css::lang::IndexOutOfBoundsException, |
| css::lang::IllegalArgumentException, |
| cssu::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| TextSegment aSegment; |
| if (mpParagraph) |
| aSegment = mpParagraph->GetTextSegment(-1, nLocalCharacterIndex, nTextType); |
| |
| return aSegment; |
| } |
| |
| |
| |
| |
| TextSegment SAL_CALL PresenterAccessible::AccessibleParagraph::getTextBehindIndex ( |
| sal_Int32 nLocalCharacterIndex, |
| sal_Int16 nTextType) |
| throw (css::lang::IndexOutOfBoundsException, |
| css::lang::IllegalArgumentException, |
| cssu::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| TextSegment aSegment; |
| if (mpParagraph) |
| aSegment = mpParagraph->GetTextSegment(+1, nLocalCharacterIndex, nTextType); |
| |
| return aSegment; |
| } |
| |
| |
| |
| |
| sal_Bool SAL_CALL PresenterAccessible::AccessibleParagraph::copyText ( |
| sal_Int32 nStartIndex, |
| sal_Int32 nEndIndex) |
| throw (css::lang::IndexOutOfBoundsException, cssu::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| // Return false because copying to clipboard is not supported. |
| // It IS supported in the notes view. There is no need to duplicate |
| // this here. |
| (void)nStartIndex; |
| (void)nEndIndex; |
| return sal_False; |
| } |
| |
| |
| |
| |
| //----- protected ------------------------------------------------------------- |
| |
| awt::Point PresenterAccessible::AccessibleParagraph::GetRelativeLocation (void) |
| { |
| awt::Point aLocation (AccessibleObject::GetRelativeLocation()); |
| if (mpParagraph) |
| { |
| const awt::Point aParagraphLocation (mpParagraph->GetRelativeLocation()); |
| aLocation.X += aParagraphLocation.X; |
| aLocation.Y += aParagraphLocation.Y; |
| } |
| |
| return aLocation; |
| } |
| |
| |
| |
| |
| awt::Size PresenterAccessible::AccessibleParagraph::GetSize (void) |
| { |
| if (mpParagraph) |
| return mpParagraph->GetSize(); |
| else |
| return AccessibleObject::GetSize(); |
| } |
| |
| |
| |
| |
| awt::Point PresenterAccessible::AccessibleParagraph::GetAbsoluteParentLocation (void) |
| { |
| if (mxParentAccessible.is()) |
| { |
| Reference<XAccessibleContext> xParentContext( |
| mxParentAccessible->getAccessibleContext(), UNO_QUERY); |
| if (xParentContext.is()) |
| { |
| Reference<XAccessibleComponent> xGrandParentComponent( |
| xParentContext->getAccessibleParent(), UNO_QUERY); |
| if (xGrandParentComponent.is()) |
| return xGrandParentComponent->getLocationOnScreen(); |
| } |
| } |
| |
| return awt::Point(); |
| } |
| |
| |
| |
| |
| bool PresenterAccessible::AccessibleParagraph::GetWindowState (const sal_Int16 nType) const |
| { |
| switch (nType) |
| { |
| case AccessibleStateType::EDITABLE: |
| return mpParagraph.get()!=NULL; |
| |
| case AccessibleStateType::ACTIVE: |
| return true; |
| |
| default: |
| return AccessibleObject::GetWindowState(nType); |
| } |
| } |
| |
| |
| |
| |
| |
| |
| //===== AccessibleNotes ======================================================= |
| |
| AccessibleNotes::AccessibleNotes ( |
| const css::lang::Locale aLocale, |
| const sal_Int16 nRole, |
| const ::rtl::OUString& rsName) |
| : AccessibleObject(aLocale,nRole,rsName), |
| mpTextView() |
| { |
| } |
| |
| |
| |
| |
| rtl::Reference<PresenterAccessible::AccessibleObject> AccessibleNotes::Create ( |
| const css::uno::Reference<css::uno::XComponentContext>& rxContext, |
| const lang::Locale aLocale, |
| const Reference<awt::XWindow>& rxContentWindow, |
| const Reference<awt::XWindow>& rxBorderWindow, |
| const ::boost::shared_ptr<PresenterTextView>& rpTextView) |
| { |
| OUString sName (A2S("Presenter Notes Text")); |
| { |
| PresenterConfigurationAccess aConfiguration ( |
| rxContext, |
| OUString::createFromAscii("/org.openoffice.Office.PresenterScreen/"), |
| PresenterConfigurationAccess::READ_ONLY); |
| aConfiguration.GetConfigurationNode(A2S("Presenter/Accessibility/Notes/String")) |
| >>= sName; |
| } |
| |
| rtl::Reference<AccessibleNotes> pObject ( |
| new AccessibleNotes( |
| aLocale, |
| AccessibleRole::PANEL, |
| sName)); |
| pObject->LateInitialization(); |
| pObject->SetTextView(rpTextView); |
| pObject->UpdateStateSet(); |
| pObject->SetWindow(rxContentWindow, rxBorderWindow); |
| |
| return rtl::Reference<PresenterAccessible::AccessibleObject>(pObject.get()); |
| } |
| |
| |
| |
| |
| void AccessibleNotes::SetTextView ( |
| const ::boost::shared_ptr<PresenterTextView>& rpTextView) |
| { |
| ::std::vector<rtl::Reference<PresenterAccessible::AccessibleObject> > aChildren; |
| |
| // Release any listeners to the current text view. |
| if (mpTextView) |
| { |
| mpTextView->GetCaret()->SetCaretMotionBroadcaster( |
| ::boost::function<void(sal_Int32,sal_Int32,sal_Int32,sal_Int32)>()); |
| mpTextView->SetTextChangeBroadcaster( |
| ::boost::function<void(void)>()); |
| } |
| |
| mpTextView = rpTextView; |
| |
| if (mpTextView) |
| { |
| // Create a new set of children, one for each paragraph. |
| const sal_Int32 nParagraphCount (mpTextView->GetParagraphCount()); |
| for (sal_Int32 nIndex=0; nIndex<nParagraphCount; ++nIndex) |
| { |
| rtl::Reference<PresenterAccessible::AccessibleParagraph> pParagraph ( |
| new PresenterAccessible::AccessibleParagraph( |
| css::lang::Locale(), |
| AccessibleRole::PARAGRAPH, |
| A2S("Paragraph")+OUString::valueOf(nIndex), |
| rpTextView->GetParagraph(nIndex), |
| nIndex)); |
| pParagraph->LateInitialization(); |
| pParagraph->SetWindow( |
| Reference<awt::XWindow>(mxContentWindow, UNO_QUERY), |
| Reference<awt::XWindow>(mxBorderWindow, UNO_QUERY)); |
| pParagraph->SetAccessibleParent(this); |
| aChildren.push_back( |
| rtl::Reference<PresenterAccessible::AccessibleObject>(pParagraph.get())); |
| } |
| maChildren.swap(aChildren); |
| FireAccessibleEvent(AccessibleEventId::INVALIDATE_ALL_CHILDREN, Any(), Any()); |
| |
| // Dispose the old children. (This will remove them from the focus |
| // manager). |
| for (std::vector<rtl::Reference<AccessibleObject> >::const_iterator |
| iChild(aChildren.begin()), iEnd(aChildren.end()); |
| iChild!=iEnd; |
| ++iChild) |
| { |
| Reference<lang::XComponent> xComponent (static_cast<XWeak*>(iChild->get()), UNO_QUERY); |
| if (xComponent.is()) |
| xComponent->dispose(); |
| } |
| |
| // This class acts as a controller of who broadcasts caret motion |
| // events and handles text changes. Register the corresponding |
| // listeners here. |
| mpTextView->GetCaret()->SetCaretMotionBroadcaster( |
| ::boost::bind(&AccessibleNotes::NotifyCaretChange, this, _1, _2, _3, _4)); |
| mpTextView->SetTextChangeBroadcaster( |
| ::boost::bind(&AccessibleNotes::HandleTextChange, this)); |
| } |
| } |
| |
| |
| |
| |
| void AccessibleNotes::SetWindow ( |
| const cssu::Reference<css::awt::XWindow>& rxContentWindow, |
| const cssu::Reference<css::awt::XWindow>& rxBorderWindow) |
| { |
| AccessibleObject::SetWindow(rxContentWindow, rxBorderWindow); |
| |
| // Set the windows at the children as well, so that every paragraph can |
| // setup its geometry. |
| for (::std::vector<rtl::Reference<AccessibleObject> >::const_iterator |
| iChild(maChildren.begin()), |
| iEnd(maChildren.end()); |
| iChild!=iEnd; |
| ++iChild) |
| { |
| (*iChild)->SetWindow(rxContentWindow, rxBorderWindow); |
| } |
| } |
| |
| |
| |
| |
| void AccessibleNotes::NotifyCaretChange ( |
| const sal_Int32 nOldParagraphIndex, |
| const sal_Int32 nOldCharacterIndex, |
| const sal_Int32 nNewParagraphIndex, |
| const sal_Int32 nNewCharacterIndex) |
| { |
| AccessibleFocusManager::Instance()->FocusObject( |
| nNewParagraphIndex >= 0 |
| ? maChildren[nNewParagraphIndex] |
| : this); |
| |
| if (nOldParagraphIndex != nNewParagraphIndex) |
| { |
| // Moved caret from one paragraph to another (or showed or |
| // hid the caret). Move focuse from one accessible |
| // paragraph to another. |
| if (nOldParagraphIndex >= 0) |
| { |
| maChildren[nOldParagraphIndex]->FireAccessibleEvent( |
| AccessibleEventId::CARET_CHANGED, |
| Any(nOldCharacterIndex), |
| Any(sal_Int32(-1))); |
| } |
| if (nNewParagraphIndex >= 0) |
| { |
| maChildren[nNewParagraphIndex]->FireAccessibleEvent( |
| AccessibleEventId::CARET_CHANGED, |
| Any(sal_Int32(-1)), |
| Any(nNewCharacterIndex)); |
| } |
| } |
| else if (nNewParagraphIndex >= 0) |
| { |
| // Caret moved inside one paragraph. |
| maChildren[nNewParagraphIndex]->FireAccessibleEvent( |
| AccessibleEventId::CARET_CHANGED, |
| Any(nOldCharacterIndex), |
| Any(nNewCharacterIndex)); |
| } |
| } |
| |
| |
| |
| |
| void AccessibleNotes::HandleTextChange (void) |
| { |
| SetTextView(mpTextView); |
| } |
| |
| |
| |
| |
| //===== AccessibleFocusManager ================================================ |
| |
| ::boost::shared_ptr<AccessibleFocusManager> AccessibleFocusManager::mpInstance; |
| |
| ::boost::shared_ptr<AccessibleFocusManager> AccessibleFocusManager::Instance (void) |
| { |
| if ( ! mpInstance) |
| { |
| mpInstance.reset(new AccessibleFocusManager()); |
| } |
| return mpInstance; |
| } |
| |
| |
| |
| |
| AccessibleFocusManager::AccessibleFocusManager (void) |
| : maFocusableObjects() |
| { |
| } |
| |
| |
| |
| |
| void AccessibleFocusManager::AddFocusableObject ( |
| const ::rtl::Reference<PresenterAccessible::AccessibleObject>& rpObject) |
| { |
| OSL_ASSERT(rpObject.is()); |
| OSL_ASSERT(::std::find(maFocusableObjects.begin(),maFocusableObjects.end(), rpObject)==maFocusableObjects.end()); |
| |
| maFocusableObjects.push_back(rpObject); |
| } |
| |
| |
| |
| |
| void AccessibleFocusManager::RemoveFocusableObject ( |
| const ::rtl::Reference<PresenterAccessible::AccessibleObject>& rpObject) |
| { |
| ::std::vector<rtl::Reference<PresenterAccessible::AccessibleObject> >::iterator iObject ( |
| ::std::find(maFocusableObjects.begin(),maFocusableObjects.end(), rpObject)); |
| |
| if (iObject != maFocusableObjects.end()) |
| maFocusableObjects.erase(iObject); |
| else |
| { |
| OSL_ASSERT(iObject!=maFocusableObjects.end()); |
| } |
| } |
| |
| |
| |
| |
| void AccessibleFocusManager::FocusObject ( |
| const ::rtl::Reference<PresenterAccessible::AccessibleObject>& rpObject) |
| { |
| // Remove the focus of any of the other focusable objects. |
| for (::std::vector<rtl::Reference<PresenterAccessible::AccessibleObject> >::const_iterator |
| iObject (maFocusableObjects.begin()), |
| iEnd (maFocusableObjects.end()); |
| iObject != iEnd; |
| ++iObject) |
| { |
| if (*iObject!=rpObject) |
| (*iObject)->SetIsFocused(false); |
| } |
| |
| if (rpObject.is()) |
| rpObject->SetIsFocused(true); |
| } |
| |
| } } // end of namespace ::sd::presenter |