| /************************************************************** |
| * |
| * 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" |
| |
| // The body of this file is only used when PresenterWindowManager defines |
| // the preprocessor symbol ENABLE_PANE_RESIZING, which by default is not the |
| // case. |
| #ifdef ENABLE_PANE_RESIZING |
| |
| #include "PresenterPaneBorderManager.hxx" |
| #include "PresenterController.hxx" |
| #include "PresenterPaintManager.hxx" |
| #include <com/sun/star/awt/PosSize.hpp> |
| #include <com/sun/star/awt/SystemPointer.hpp> |
| #include <com/sun/star/awt/WindowAttribute.hpp> |
| #include <com/sun/star/awt/WindowDescriptor.hpp> |
| #include <com/sun/star/awt/WindowClass.hpp> |
| #include <com/sun/star/awt/XWindow2.hpp> |
| #include <com/sun/star/awt/XWindowPeer.hpp> |
| #include <com/sun/star/lang/XMultiComponentFactory.hpp> |
| #include <cppuhelper/compbase1.hxx> |
| #include <osl/mutex.hxx> |
| #include <boost/weak_ptr.hpp> |
| |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::uno; |
| using ::rtl::OUString; |
| |
| namespace sdext { namespace presenter { |
| |
| //===== Service =============================================================== |
| |
| |
| OUString PresenterPaneBorderManager::getImplementationName_static (void) |
| { |
| return OUString::createFromAscii("com.sun.star.comp.Draw.PresenterPaneBorderManager"); |
| } |
| |
| |
| |
| |
| Sequence<OUString> PresenterPaneBorderManager::getSupportedServiceNames_static (void) |
| { |
| static const ::rtl::OUString sServiceName( |
| ::rtl::OUString::createFromAscii("com.sun.star.drawing.PresenterPaneBorderManager")); |
| return Sequence<rtl::OUString>(&sServiceName, 1); |
| } |
| |
| |
| |
| |
| Reference<XInterface> PresenterPaneBorderManager::Create (const Reference<uno::XComponentContext>& rxContext) |
| SAL_THROW((css::uno::Exception)) |
| { |
| return Reference<XInterface>(static_cast<XWeak*>( |
| new PresenterPaneBorderManager(rxContext, NULL))); |
| } |
| |
| |
| |
| |
| //===== PresenterPaneBorderManager ============================================ |
| |
| PresenterPaneBorderManager::PresenterPaneBorderManager ( |
| const Reference<XComponentContext>& rxContext, |
| const ::rtl::Reference<PresenterController>& rpPresenterController) |
| : PresenterPaneBorderManagerInterfaceBase(m_aMutex), |
| mpPresenterController(rpPresenterController), |
| mxComponentContext(rxContext), |
| mxPresenterHelper(), |
| maWindowList(), |
| mnPointerType(), |
| maDragAnchor(), |
| meDragType(Outside), |
| mxOuterDragWindow(), |
| mxInnerDragWindow(), |
| mxPointer() |
| { |
| Reference<lang::XMultiComponentFactory> xFactory (rxContext->getServiceManager()); |
| if (xFactory.is()) |
| { |
| mxPointer = Reference<awt::XPointer>( |
| xFactory->createInstanceWithContext( |
| OUString::createFromAscii("com.sun.star.awt.Pointer"), |
| rxContext), |
| UNO_QUERY_THROW); |
| |
| mxPresenterHelper = Reference<drawing::XPresenterHelper>( |
| xFactory->createInstanceWithContext( |
| OUString::createFromAscii("com.sun.star.comp.Draw.PresenterHelper"), |
| rxContext), |
| UNO_QUERY_THROW); |
| } |
| } |
| |
| |
| |
| |
| PresenterPaneBorderManager::~PresenterPaneBorderManager (void) |
| { |
| } |
| |
| |
| |
| |
| void PresenterPaneBorderManager::disposing (void) |
| { |
| WindowList::const_iterator iDescriptor; |
| for (iDescriptor=maWindowList.begin(); iDescriptor!=maWindowList.end(); ++iDescriptor) |
| { |
| iDescriptor->first->removeMouseListener(this); |
| iDescriptor->first->removeMouseMotionListener(this); |
| } |
| maWindowList.clear(); |
| } |
| |
| |
| |
| |
| namespace { |
| const static sal_Int32 mnOutside = 0; |
| const static sal_Int32 mnLeft = 0x01; |
| const static sal_Int32 mnHorizontalCenter = 0x02; |
| const static sal_Int32 mnRight = 0x04; |
| const static sal_Int32 mnTop = 0x10; |
| const static sal_Int32 mnVerticalCenter = 0x20; |
| const static sal_Int32 mnBottom = 0x40; |
| } |
| |
| PresenterPaneBorderManager::BorderElement |
| PresenterPaneBorderManager::ClassifyBorderElementUnderMouse ( |
| const Reference<awt::XWindow>& rxOuterWindow, |
| const Reference<awt::XWindow>& rxInnerWindow, |
| const awt::Point aPosition) const |
| { |
| OSL_ASSERT(rxOuterWindow.is()); |
| OSL_ASSERT(rxInnerWindow.is()); |
| |
| awt::Rectangle aOuterBox (rxOuterWindow->getPosSize()); |
| const awt::Rectangle aInnerBox (rxInnerWindow->getPosSize()); |
| |
| // Coordinates of the pointer position are given in the window |
| // coordinate system. Therefore the upper left corner of the outer box |
| // is the origin. |
| aOuterBox.X = 0; |
| aOuterBox.Y = 0; |
| |
| sal_Int32 nCode = 0; |
| |
| // Add horizontal classification to nCode. |
| if (aPosition.X < aInnerBox.X) |
| if (aPosition.X < aOuterBox.X) |
| nCode = mnOutside; |
| else |
| nCode = mnLeft; |
| else if (aPosition.X >= aInnerBox.X+aInnerBox.Width) |
| if (aPosition.X >= aOuterBox.X+aOuterBox.Width) |
| nCode = mnOutside; |
| else |
| nCode = mnRight; |
| else |
| nCode = mnHorizontalCenter; |
| |
| // Add vertical classification to nCode. |
| if (aPosition.Y < aInnerBox.Y) |
| if (aPosition.Y < aOuterBox.Y) |
| nCode |= mnOutside; |
| else |
| nCode |= mnTop; |
| else if (aPosition.Y >= aInnerBox.Y+aInnerBox.Height) |
| if (aPosition.Y >= aOuterBox.Y+aOuterBox.Height) |
| nCode |= mnOutside; |
| else |
| nCode |= mnBottom; |
| else |
| nCode |= mnVerticalCenter; |
| |
| // Translate bits in nCode into BorderElement value. |
| switch (nCode) |
| { |
| case mnOutside | mnOutside: |
| case mnOutside | mnLeft: |
| case mnOutside | mnRight: |
| case mnOutside | mnHorizontalCenter: |
| case mnTop | mnOutside: |
| case mnBottom | mnOutside: |
| case mnVerticalCenter | mnOutside: |
| default: |
| return Outside; |
| |
| case mnVerticalCenter | mnHorizontalCenter: |
| return Content; |
| |
| case mnTop | mnLeft: |
| return TopLeft; |
| |
| case mnTop | mnRight: |
| return TopRight; |
| |
| case mnTop | mnHorizontalCenter: |
| return Top; |
| |
| case mnBottom | mnLeft: |
| return BottomLeft; |
| |
| case mnBottom | mnRight: |
| return BottomRight; |
| |
| case mnBottom | mnHorizontalCenter: |
| return Bottom; |
| |
| case mnVerticalCenter | mnLeft: |
| return Left; |
| |
| case mnVerticalCenter | mnRight: |
| return Right; |
| } |
| } |
| |
| |
| |
| |
| //----- XInitialization ------------------------------------------------------- |
| |
| void SAL_CALL PresenterPaneBorderManager::initialize (const Sequence<Any>& rArguments) |
| throw (Exception, RuntimeException) |
| { |
| ThrowIfDisposed(); |
| |
| if (rArguments.getLength()%2 == 1 && mxComponentContext.is()) |
| { |
| try |
| { |
| mxParentWindow = Reference<awt::XWindow>(rArguments[0], UNO_QUERY_THROW); |
| |
| // Get the outer and inner windows from the argument list and |
| // build a window list of it. |
| for (sal_Int32 nIndex=1; nIndex<rArguments.getLength(); nIndex+=2) |
| { |
| Reference<awt::XWindow> xOuterWindow (rArguments[nIndex], UNO_QUERY_THROW); |
| Reference<awt::XWindow> xInnerWindow (rArguments[nIndex+1], UNO_QUERY_THROW); |
| |
| maWindowList.push_back(WindowDescriptor(xOuterWindow,xInnerWindow)); |
| |
| xOuterWindow->addMouseListener(this); |
| xOuterWindow->addMouseMotionListener(this); |
| } |
| } |
| catch (RuntimeException&) |
| { |
| PresenterPaneBorderManager::disposing(); |
| throw; |
| } |
| } |
| else |
| { |
| throw RuntimeException( |
| OUString::createFromAscii("PresenterPane: invalid number of arguments"), |
| static_cast<XWeak*>(this)); |
| } |
| } |
| |
| |
| |
| |
| //----- XMouseListener -------------------------------------------------------- |
| |
| void SAL_CALL PresenterPaneBorderManager::mousePressed (const css::awt::MouseEvent& rEvent) |
| throw (css::uno::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| ::osl::MutexGuard aGuard (::osl::Mutex::getGlobalMutex()); |
| |
| // Find window descriptor of the window that has been clicked. |
| WindowList::const_iterator iDescriptor; |
| for (iDescriptor=maWindowList.begin(); iDescriptor!=maWindowList.end(); ++iDescriptor) |
| if (iDescriptor->first == rEvent.Source) |
| break; |
| |
| if (iDescriptor != maWindowList.end()) |
| { |
| // Prepare dragging. |
| mxOuterDragWindow = iDescriptor->first; |
| mxInnerDragWindow = iDescriptor->second; |
| OSL_ASSERT(mxOuterDragWindow.is() && mxInnerDragWindow.is()); |
| const awt::Rectangle aOuterBox (mxOuterDragWindow->getPosSize()); |
| maDragAnchor.X = rEvent.X + aOuterBox.X; |
| maDragAnchor.Y = rEvent.Y + aOuterBox.Y; |
| meDragType = ClassifyBorderElementUnderMouse( |
| mxOuterDragWindow, |
| mxInnerDragWindow, |
| awt::Point(rEvent.X, rEvent.Y)); |
| } |
| } |
| |
| |
| |
| |
| void SAL_CALL PresenterPaneBorderManager::mouseReleased (const css::awt::MouseEvent& rEvent) |
| throw (css::uno::RuntimeException) |
| { |
| (void)rEvent; |
| ThrowIfDisposed(); |
| ::osl::MutexGuard aGuard (::osl::Mutex::getGlobalMutex()); |
| |
| ReleaseMouse(mxOuterDragWindow); |
| meDragType = PresenterPaneBorderManager::Outside; |
| mxOuterDragWindow = NULL; |
| mxInnerDragWindow = NULL; |
| } |
| |
| |
| |
| |
| void SAL_CALL PresenterPaneBorderManager::mouseEntered (const css::awt::MouseEvent& rEvent) |
| throw (css::uno::RuntimeException) |
| { |
| (void)rEvent; |
| } |
| |
| |
| |
| |
| void SAL_CALL PresenterPaneBorderManager::mouseExited (const css::awt::MouseEvent& rEvent) |
| throw (css::uno::RuntimeException) |
| { |
| (void)rEvent; |
| ThrowIfDisposed(); |
| ::osl::MutexGuard aGuard (::osl::Mutex::getGlobalMutex()); |
| |
| ReleaseMouse(mxOuterDragWindow); |
| meDragType = PresenterPaneBorderManager::Outside; |
| mxOuterDragWindow = NULL; |
| mxInnerDragWindow = NULL; |
| } |
| |
| |
| |
| |
| //----- XMouseMotionListener -------------------------------------------------- |
| |
| void SAL_CALL PresenterPaneBorderManager::mouseMoved (const css::awt::MouseEvent& rEvent) |
| throw (css::uno::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| ::osl::MutexGuard aGuard (::osl::Mutex::getGlobalMutex()); |
| |
| WindowList::const_iterator iDescriptor; |
| for (iDescriptor=maWindowList.begin(); iDescriptor!=maWindowList.end(); ++iDescriptor) |
| if (iDescriptor->first == rEvent.Source) |
| break; |
| if (iDescriptor != maWindowList.end()) |
| { |
| // Choose pointer shape according to position in the window border. |
| switch (ClassifyBorderElementUnderMouse( |
| iDescriptor->first, |
| iDescriptor->second, |
| awt::Point(rEvent.X,rEvent.Y))) |
| { |
| case PresenterPaneBorderManager::Top: |
| mnPointerType = awt::SystemPointer::MOVE; |
| break; |
| case PresenterPaneBorderManager::TopLeft: |
| mnPointerType = awt::SystemPointer::WINDOW_NWSIZE; |
| break; |
| case PresenterPaneBorderManager::TopRight: |
| mnPointerType = awt::SystemPointer::WINDOW_NESIZE; |
| break; |
| case PresenterPaneBorderManager::Left: |
| mnPointerType = awt::SystemPointer::WINDOW_WSIZE; |
| break; |
| case PresenterPaneBorderManager::Right: |
| mnPointerType = awt::SystemPointer::WINDOW_ESIZE; |
| break; |
| case PresenterPaneBorderManager::BottomLeft: |
| mnPointerType = awt::SystemPointer::WINDOW_SWSIZE; |
| break; |
| case PresenterPaneBorderManager::BottomRight: |
| mnPointerType = awt::SystemPointer::WINDOW_SESIZE; |
| break; |
| case PresenterPaneBorderManager::Bottom: |
| mnPointerType = awt::SystemPointer::WINDOW_SSIZE; |
| break; |
| |
| case PresenterPaneBorderManager::Content: |
| case PresenterPaneBorderManager::Outside: |
| default: |
| mnPointerType = awt::SystemPointer::ARROW; |
| break; |
| } |
| |
| // Make the pointer shape visible. |
| Reference<awt::XWindowPeer> xPeer (iDescriptor->first, UNO_QUERY); |
| if (xPeer.is()) |
| { |
| if (mxPointer.is()) |
| mxPointer->setType(mnPointerType); |
| xPeer->setPointer(mxPointer); |
| } |
| } |
| } |
| |
| |
| |
| |
| void SAL_CALL PresenterPaneBorderManager::mouseDragged (const css::awt::MouseEvent& rEvent) |
| throw (css::uno::RuntimeException) |
| { |
| ThrowIfDisposed(); |
| ::osl::MutexGuard aGuard (::osl::Mutex::getGlobalMutex()); |
| |
| if ( ! mxOuterDragWindow.is()) |
| return; |
| |
| CaptureMouse(mxOuterDragWindow); |
| |
| const awt::Rectangle aOldBox (mxOuterDragWindow->getPosSize()); |
| const sal_Int32 nX = rEvent.X + aOldBox.X; |
| const sal_Int32 nY = rEvent.Y + aOldBox.Y; |
| const sal_Int32 nDiffX = nX - maDragAnchor.X; |
| const sal_Int32 nDiffY = nY - maDragAnchor.Y; |
| maDragAnchor.X = nX; |
| maDragAnchor.Y = nY; |
| |
| const sal_Int32 nOldRight = aOldBox.X + aOldBox.Width; |
| const sal_Int32 nOldBottom = aOldBox.Y + aOldBox.Height; |
| |
| awt::Rectangle aBox (aOldBox); |
| sal_Int32 nRight = aBox.X + aBox.Width; |
| sal_Int32 nBottom = aBox.Y + aBox.Height; |
| |
| // Update position and/or size according to initial pointer position |
| // inside the window border. |
| switch (meDragType) |
| { |
| case PresenterPaneBorderManager::Top: |
| aBox.X += nDiffX; aBox.Y += nDiffY; |
| nRight += nDiffX; nBottom += nDiffY; |
| break; |
| case PresenterPaneBorderManager::TopLeft: |
| aBox.X += nDiffX; aBox.Y += nDiffY; |
| break; |
| case PresenterPaneBorderManager::TopRight: |
| nRight += nDiffX; aBox.Y += nDiffY; |
| break; |
| case PresenterPaneBorderManager::Left: |
| aBox.X += nDiffX; |
| break; |
| case PresenterPaneBorderManager::Right: |
| nRight += nDiffX; |
| break; |
| case PresenterPaneBorderManager::BottomLeft: |
| aBox.X += nDiffX; nBottom += nDiffY; |
| break; |
| case PresenterPaneBorderManager::BottomRight: |
| nRight += nDiffX; nBottom += nDiffY; |
| break; |
| case PresenterPaneBorderManager::Bottom: |
| nBottom += nDiffY; |
| break; |
| default: break; |
| } |
| |
| aBox.Width = nRight - aBox.X; |
| aBox.Height = nBottom - aBox.Y; |
| if (aBox.Width > 20 |
| && aBox.Height > 20) |
| { |
| // Set position and/or size of the border window to the new values. |
| sal_Int16 nFlags (0); |
| if (aBox.X != aOldBox.X) |
| nFlags |= awt::PosSize::X; |
| if (aBox.Y != aOldBox.Y) |
| nFlags |= awt::PosSize::Y; |
| if (aBox.Width != aOldBox.Width) |
| nFlags |= awt::PosSize::WIDTH; |
| if (aBox.Height != aOldBox.Height) |
| nFlags |= awt::PosSize::HEIGHT; |
| mxOuterDragWindow->setPosSize(aBox.X, aBox.Y, aBox.Width, aBox.Height, nFlags); |
| |
| // Invalidate that is or was covered by the border window before and |
| // after the move/resize. |
| if (mpPresenterController.get() != NULL) |
| { |
| const sal_Int32 nLeft = ::std::min(aOldBox.X,aBox.X); |
| const sal_Int32 nTop = ::std::min(aOldBox.Y,aBox.Y); |
| const sal_Int32 nWidth = ::std::max(nOldRight,nRight) - nLeft; |
| const sal_Int32 nHeight = ::std::max(nOldBottom,nBottom) - nTop; |
| |
| OSL_ASSERT(mpPresenterController->GetPaintManager().get()!=NULL); |
| mpPresenterController->GetPaintManager()->Invalidate( |
| mxParentWindow, |
| ::awt::Rectangle(nLeft,nTop,nWidth-1,nHeight-1)); |
| } |
| } |
| } |
| |
| |
| |
| |
| //----- lang::XEventListener -------------------------------------------------- |
| |
| void SAL_CALL PresenterPaneBorderManager::disposing (const lang::EventObject& rEvent) |
| throw (RuntimeException) |
| { |
| WindowList::iterator iDescriptor; |
| for (iDescriptor=maWindowList.begin(); iDescriptor!=maWindowList.end(); ++iDescriptor) |
| if (iDescriptor->first == rEvent.Source) |
| { |
| maWindowList.erase(iDescriptor); |
| break; |
| } |
| } |
| |
| |
| |
| |
| //----------------------------------------------------------------------------- |
| |
| |
| void PresenterPaneBorderManager::CaptureMouse (const Reference<awt::XWindow>& rxWindow) |
| { |
| if (mxPresenterHelper.is()) |
| mxPresenterHelper->captureMouse(rxWindow); |
| } |
| |
| |
| |
| |
| void PresenterPaneBorderManager::ReleaseMouse (const Reference<awt::XWindow>& rxWindow) |
| { |
| if (mxPresenterHelper.is()) |
| mxPresenterHelper->releaseMouse(rxWindow); |
| } |
| |
| |
| |
| |
| void PresenterPaneBorderManager::ThrowIfDisposed (void) |
| throw (::com::sun::star::lang::DisposedException) |
| { |
| if (rBHelper.bDisposed || rBHelper.bInDispose) |
| { |
| throw lang::DisposedException ( |
| ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( |
| "PresenterPaneBorderManager object has already been disposed")), |
| static_cast<uno::XWeak*>(this)); |
| } |
| } |
| |
| |
| |
| |
| } } // end of namespace ::sd::presenter |
| |
| #endif // ENABLE_PANE_RESIZING |
