diff options
96 files changed, 8040 insertions, 5640 deletions
diff --git a/basic/source/runtime/runtime.cxx b/basic/source/runtime/runtime.cxx index a8eff4d55d..a8eff4d55d 100644..100755 --- a/basic/source/runtime/runtime.cxx +++ b/basic/source/runtime/runtime.cxx diff --git a/desktop/source/deployment/gui/dp_gui_extlistbox.hxx b/desktop/source/deployment/gui/dp_gui_extlistbox.hxx index 08d1120ecb..08d1120ecb 100644..100755 --- a/desktop/source/deployment/gui/dp_gui_extlistbox.hxx +++ b/desktop/source/deployment/gui/dp_gui_extlistbox.hxx diff --git a/desktop/source/migration/services/oo3extensionmigration.cxx b/desktop/source/migration/services/oo3extensionmigration.cxx index a481857f91..a481857f91 100644..100755 --- a/desktop/source/migration/services/oo3extensionmigration.cxx +++ b/desktop/source/migration/services/oo3extensionmigration.cxx diff --git a/desktop/source/migration/services/oo3extensionmigration.hxx b/desktop/source/migration/services/oo3extensionmigration.hxx index 721a1bd704..721a1bd704 100644..100755 --- a/desktop/source/migration/services/oo3extensionmigration.hxx +++ b/desktop/source/migration/services/oo3extensionmigration.hxx diff --git a/editeng/inc/editeng/editeng.hxx b/editeng/inc/editeng/editeng.hxx index 3ba1e820aa..3ba1e820aa 100644..100755 --- a/editeng/inc/editeng/editeng.hxx +++ b/editeng/inc/editeng/editeng.hxx diff --git a/editeng/inc/editeng/splwrap.hxx b/editeng/inc/editeng/splwrap.hxx index 8d2926adcf..8d2926adcf 100644..100755 --- a/editeng/inc/editeng/splwrap.hxx +++ b/editeng/inc/editeng/splwrap.hxx diff --git a/editeng/source/editeng/impedit.cxx b/editeng/source/editeng/impedit.cxx index dd38c4c16b..dd38c4c16b 100644..100755 --- a/editeng/source/editeng/impedit.cxx +++ b/editeng/source/editeng/impedit.cxx diff --git a/editeng/source/outliner/outlvw.cxx b/editeng/source/outliner/outlvw.cxx index 4034b03d01..4034b03d01 100644..100755 --- a/editeng/source/outliner/outlvw.cxx +++ b/editeng/source/outliner/outlvw.cxx diff --git a/framework/inc/helper/ilayoutnotifications.hxx b/framework/inc/helper/ilayoutnotifications.hxx new file mode 100755 index 0000000000..2b5823ddc7 --- /dev/null +++ b/framework/inc/helper/ilayoutnotifications.hxx @@ -0,0 +1,52 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: layoutmanager.hxx,v $ + * $Revision: 1.34 $ + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef __FRAMEWORK_LAYOUTMANAGER_ILAYOUTNOTIFICATIONS_HXX_ +#define __FRAMEWORK_LAYOUTMANAGER_ILAYOUTNOTIFICATIONS_HXX_ + +namespace framework +{ + +class ILayoutNotifications +{ + public: + enum Hint + { + HINT_NOT_SPECIFIED, + HINT_TOOLBARSPACE_HAS_CHANGED, + HINT_COUNT + }; + + virtual void requestLayout( Hint eHint = HINT_NOT_SPECIFIED ) = 0; +}; + +} + +#endif // __FRAMEWORK_LAYOUTMANAGER_ILAYOUTNOTIFICATIONS_HXX_ diff --git a/framework/inc/helper/mischelper.hxx b/framework/inc/helper/mischelper.hxx index 8efbbac090..8efbbac090 100644..100755 --- a/framework/inc/helper/mischelper.hxx +++ b/framework/inc/helper/mischelper.hxx diff --git a/framework/inc/services.h b/framework/inc/services.h index a104dd2942..e80ca18d76 100644 --- a/framework/inc/services.h +++ b/framework/inc/services.h @@ -125,6 +125,8 @@ namespace framework{ #define SERVICENAME_TABWINDOWSERVICE DECLARE_ASCII("com.sun.star.ui.dialogs.TabContainerWindow" ) #define SERVICENAME_WINDOWCONTENTFACTORYMANAGER DECLARE_ASCII("com.sun.star.ui.WindowContentFactoryManager" ) #define SERVICENAME_DISPLAYACCESS DECLARE_ASCII("com.sun.star.awt.DisplayAccess" ) +#define SERVICENAME_PANELFACTORY DECLARE_ASCII("com.sun.star.ui.PanelFactory" ) +#define SERVICENAME_MODELWINSERVICE DECLARE_ASCII("com.sun.star.ui.ModelWinService" ) //_________________________________________________________________________________________________________________ // used implementationnames by framework @@ -211,6 +213,8 @@ namespace framework{ #define IMPLEMENTATIONNAME_IMAGEMANAGER DECLARE_ASCII("com.sun.star.comp.framework.ImageManager" ) #define IMPLEMENTATIONNAME_TABWINDOWSERVICE DECLARE_ASCII("com.sun.star.comp.framework.TabWindowService" ) #define IMPLEMENTATIONNAME_WINDOWCONTENTFACTORYMANAGER DECLARE_ASCII("com.sun.star.comp.framework.WindowContentFactoryManager" ) +#define IMPLEMENTATIONNAME_PANELFACTORY DECLARE_ASCII("com.sun.star.comp.framework.PanelFactory" ) +#define IMPLEMENTATIONNAME_MODELWINSERVICE DECLARE_ASCII("com.sun.star.comp.framework.ModelWinService" ) } // namespace framework diff --git a/framework/inc/services/layoutmanager.hxx b/framework/inc/services/layoutmanager.hxx index 680ee5303f..50ba7289f6 100644 --- a/framework/inc/services/layoutmanager.hxx +++ b/framework/inc/services/layoutmanager.hxx @@ -6,6 +6,9 @@ * * OpenOffice.org - a multi-platform office productivity suite * + * $RCSfile: layoutmanager.hxx,v $ + * $Revision: 1.34 $ + * * This file is part of OpenOffice.org. * * OpenOffice.org is free software: you can redistribute it and/or modify @@ -50,6 +53,9 @@ #include <uielement/menubarmanager.hxx> #include <uiconfiguration/windowstateconfiguration.hxx> #include <classes/addonsoptions.hxx> +#include <uielement/panelwindow.hxx> +#include <uielement/uielement.hxx> +#include <helper/ilayoutnotifications.hxx> //_________________________________________________________________________________________________________________ // interface includes @@ -76,7 +82,7 @@ // other includes //_________________________________________________________________________________________________________________ #include <cppuhelper/propshlp.hxx> -#include <cppuhelper/implbase9.hxx> +#include <cppuhelper/implbase8.hxx> #include <cppuhelper/interfacecontainer.hxx> #include <comphelper/propertycontainer.hxx> #include <vcl/wintypes.hxx> @@ -87,14 +93,15 @@ class MenuBar; namespace framework { + class ToolbarLayoutManager; + class PanelManager; class GlobalSettings; - typedef ::cppu::WeakImplHelper9 < ::com::sun::star::lang::XServiceInfo + typedef ::cppu::WeakImplHelper8 < ::com::sun::star::lang::XServiceInfo , ::com::sun::star::frame::XLayoutManager , ::com::sun::star::awt::XWindowListener , ::com::sun::star::frame::XFrameActionListener , ::com::sun::star::ui::XUIConfigurationListener , ::com::sun::star::frame::XInplaceLayout - , ::com::sun::star::awt::XDockableWindowListener , ::com::sun::star::frame::XMenuBarMergingAcceptor , ::com::sun::star::frame::XLayoutManagerEventBroadcaster > LayoutManager_Base; @@ -104,6 +111,7 @@ namespace framework // Order is neccessary for right initialization! private ThreadHelpBase , // Struct for right initalization of mutex member! Must be first of baseclasses. public ::cppu::OBroadcastHelper , + public ILayoutNotifications , public LayoutManager_PBase { public: @@ -121,7 +129,7 @@ namespace framework // XLayoutManager //--------------------------------------------------------------------------------------------------------- virtual void SAL_CALL attachFrame( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& Frame ) throw (::com::sun::star::uno::RuntimeException); - virtual void SAL_CALL reset( ) throw (::com::sun::star::uno::RuntimeException); + virtual void SAL_CALL reset() throw (::com::sun::star::uno::RuntimeException); virtual ::com::sun::star::awt::Rectangle SAL_CALL getCurrentDockingArea( ) throw (::com::sun::star::uno::RuntimeException); virtual ::com::sun::star::uno::Reference< ::com::sun::star::ui::XDockingAreaAcceptor > SAL_CALL getDockingAreaAcceptor() throw (::com::sun::star::uno::RuntimeException); virtual void SAL_CALL setDockingAreaAcceptor( const ::com::sun::star::uno::Reference< ::com::sun::star::ui::XDockingAreaAcceptor >& xDockingAreaAcceptor ) throw (::com::sun::star::uno::RuntimeException); @@ -192,17 +200,6 @@ namespace framework virtual void SAL_CALL elementReplaced( const ::com::sun::star::ui::ConfigurationEvent& Event ) throw (::com::sun::star::uno::RuntimeException); //--------------------------------------------------------------------------------------------------------- - // XDockableWindowListener - //--------------------------------------------------------------------------------------------------------- - virtual void SAL_CALL startDocking( const ::com::sun::star::awt::DockingEvent& e ) throw (::com::sun::star::uno::RuntimeException); - virtual ::com::sun::star::awt::DockingData SAL_CALL docking( const ::com::sun::star::awt::DockingEvent& e ) throw (::com::sun::star::uno::RuntimeException); - virtual void SAL_CALL endDocking( const ::com::sun::star::awt::EndDockingEvent& e ) throw (::com::sun::star::uno::RuntimeException); - virtual sal_Bool SAL_CALL prepareToggleFloatingMode( const ::com::sun::star::lang::EventObject& e ) throw (::com::sun::star::uno::RuntimeException); - virtual void SAL_CALL toggleFloatingMode( const ::com::sun::star::lang::EventObject& e ) throw (::com::sun::star::uno::RuntimeException); - virtual void SAL_CALL closed( const ::com::sun::star::lang::EventObject& e ) throw (::com::sun::star::uno::RuntimeException); - virtual void SAL_CALL endPopupMode( const ::com::sun::star::awt::EndPopupModeEvent& e ) throw (::com::sun::star::uno::RuntimeException); - - //--------------------------------------------------------------------------------------------------------- // XLayoutManagerEventBroadcaster //--------------------------------------------------------------------------------------------------------- virtual void SAL_CALL addLayoutManagerEventListener( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XLayoutManagerListener >& aLayoutManagerListener ) throw (::com::sun::star::uno::RuntimeException); @@ -211,196 +208,64 @@ namespace framework DECL_LINK( MenuBarClose, MenuBar * ); DECL_LINK( WindowEventListener, VclSimpleEvent* ); - struct DockedData - { - DockedData() : m_aPos( LONG_MAX, LONG_MAX ), - m_nDockedArea( ::com::sun::star::ui::DockingArea_DOCKINGAREA_TOP ), - m_bLocked( sal_False ) {} - - Point m_aPos; - Size m_aSize; - sal_Int16 m_nDockedArea; - sal_Bool m_bLocked; - }; - struct FloatingData - { - FloatingData() : m_aPos( LONG_MAX, LONG_MAX ), - m_nLines( 1 ), - m_bIsHorizontal( sal_True ) {} - - Point m_aPos; - Size m_aSize; - sal_Int16 m_nLines; - sal_Bool m_bIsHorizontal; - }; - struct SingleRowColumnWindowData - { - SingleRowColumnWindowData() : nVarSize( 0 ), nStaticSize( 0 ), nSpace( 0 ) {} - - std::vector< rtl::OUString > aUIElementNames; - std::vector< ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > > aRowColumnWindows; - std::vector< ::com::sun::star::awt::Rectangle > aRowColumnWindowSizes; - std::vector< sal_Int32 > aRowColumnSpace; - ::com::sun::star::awt::Rectangle aRowColumnRect; - sal_Int32 nVarSize; - sal_Int32 nStaticSize; - sal_Int32 nSpace; - sal_Int32 nRowColumn; - }; + //--------------------------------------------------------------------------------------------------------- + // ILayoutNotifications + //--------------------------------------------------------------------------------------------------------- + virtual void requestLayout( Hint eHint ); protected: DECL_LINK( AsyncLayoutHdl, Timer * ); private: - enum DockingOperation - { - DOCKOP_BEFORE_COLROW, - DOCKOP_ON_COLROW, - DOCKOP_AFTER_COLROW - }; - struct UIElement - { - UIElement() : m_bFloating( sal_False ), - m_bVisible( sal_True ), - m_bUserActive( sal_False ), - m_bCreateNewRowCol0( sal_False ), - m_bDeactiveHide( sal_False ), - m_bMasterHide( sal_False ), - m_bContextSensitive( sal_False ), - m_bContextActive( sal_True ), - m_bNoClose( sal_False ), - m_bSoftClose( sal_False ), - m_bStateRead( sal_False ), - m_nStyle( BUTTON_SYMBOL ) - {} - - UIElement( const rtl::OUString& rName, - const rtl::OUString& rType, - const com::sun::star::uno::Reference< ::com::sun::star::ui::XUIElement >& rUIElement, - sal_Bool bFloating = sal_False - ) : m_aType( rType ), - m_aName( rName ), - m_xUIElement( rUIElement ), - m_bFloating( bFloating ), - m_bVisible( sal_True ), - m_bUserActive( sal_False ), - m_bCreateNewRowCol0( sal_False ), - m_bDeactiveHide( sal_False ), - m_bMasterHide( sal_False ), - m_bContextSensitive( sal_False ), - m_bContextActive( sal_True ), - m_bNoClose( sal_False ), - m_bSoftClose( sal_False ), - m_bStateRead( sal_False ), - m_nStyle( BUTTON_SYMBOL ) {} - - bool operator< ( const UIElement& aUIElement ) const; - UIElement& operator=( const UIElement& rUIElement ); - - rtl::OUString m_aType; - rtl::OUString m_aName; - rtl::OUString m_aUIName; - com::sun::star::uno::Reference< ::com::sun::star::ui::XUIElement > m_xUIElement; - sal_Bool m_bFloating, - m_bVisible, - m_bUserActive, - m_bCreateNewRowCol0, - m_bDeactiveHide, - m_bMasterHide, - m_bContextSensitive, - m_bContextActive; - sal_Bool m_bNoClose, - m_bSoftClose, - m_bStateRead; - sal_Int16 m_nStyle; - DockedData m_aDockedData; - FloatingData m_aFloatingData; - }; - - typedef std::vector< UIElement > UIElementVector; - //--------------------------------------------------------------------------------------------------------- // helper //--------------------------------------------------------------------------------------------------------- - + //--------------------------------------------------------------------------------------------------------- - // helper + // menu bar //--------------------------------------------------------------------------------------------------------- void impl_clearUpMenuBar(); void implts_reset( sal_Bool bAttach ); + void implts_setMenuBarCloser(sal_Bool bCloserState); void implts_updateMenuBarClose(); sal_Bool implts_resetMenuBar(); + //--------------------------------------------------------------------------------------------------------- + // locking + //--------------------------------------------------------------------------------------------------------- void implts_lock(); sal_Bool implts_unlock(); - sal_Bool implts_findElement( const rtl::OUString& aName, rtl::OUString& aElementType, rtl::OUString& aElementName, ::com::sun::star::uno::Reference< ::com::sun::star::ui::XUIElement >& xSettings ); - sal_Bool implts_findElement( const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& xUIElement, UIElement& aElementData ); - sal_Bool implts_findElement( const rtl::OUString& aName, UIElement& aElementData ); + //--------------------------------------------------------------------------------------------------------- + // query + //--------------------------------------------------------------------------------------------------------- + ::com::sun::star::uno::Reference< ::com::sun::star::ui::XUIElement > implts_findElement( const rtl::OUString& aName ); UIElement& impl_findElement( const rtl::OUString& aName ); - sal_Bool implts_insertUIElement( const UIElement& rUIElement ); - void implts_refreshContextToolbarsVisibility(); void implts_writeNewStateData( const rtl::OUString aName, const ::com::sun::star::uno::Reference< com::sun::star::awt::XWindow >& xWindow ); sal_Bool implts_readWindowStateData( const rtl::OUString& rName, UIElement& rElementData ); void implts_writeWindowStateData( const rtl::OUString& rName, const UIElement& rElementData ); void implts_setElementData( UIElement& rUIElement, const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XDockableWindow >& rDockWindow ); void implts_sortUIElements(); void implts_destroyElements(); - void implts_destroyDockingAreaWindows(); - void implts_createAddonsToolBars(); - void implts_createCustomToolBars(); - void implts_createNonContextSensitiveToolBars(); - void implts_createCustomToolBars( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue > >& aCustomTbxSeq ); - void implts_createCustomToolBar( const rtl::OUString& aTbxResName, const rtl::OUString& aTitle ); void implts_toggleFloatingUIElementsVisibility( sal_Bool bActive ); void implts_reparentChildWindows(); + ::com::sun::star::uno::Reference< ::com::sun::star::ui::XUIElement > implts_createDockingWindow( const ::rtl::OUString& aElementName ); sal_Bool implts_isEmbeddedLayoutManager() const; sal_Int16 implts_getCurrentSymbolsSize(); sal_Int16 implts_getCurrentSymbolsStyle(); - ::com::sun::star::uno::Reference< com::sun::star::awt::XWindowPeer > implts_createToolkitWindow( const ::com::sun::star::uno::Reference< com::sun::star::awt::XWindowPeer >& rParent ); ::com::sun::star::uno::Reference< ::com::sun::star::ui::XUIElement > implts_createElement( const rtl::OUString& aName ); - rtl::OUString implts_generateGenericAddonToolbarTitle( sal_Int32 nNumber ) const; - - // docking methods - ::Rectangle implts_calcHotZoneRect( const ::Rectangle& rRect, sal_Int32 nHotZoneOffset ); - void implts_calcDockingPosSize( UIElement& aUIElement, DockingOperation& eDockOperation, ::Rectangle& rTrackingRect, const Point& rMousePos ); - DockingOperation implts_determineDockingOperation( ::com::sun::star::ui::DockingArea DockingArea, const ::Rectangle& rRowColRect, const Point& rMousePos ); - ::Rectangle implts_getWindowRectFromRowColumn( ::com::sun::star::ui::DockingArea DockingArea, const SingleRowColumnWindowData& rRowColumnWindowData, const ::Point& rMousePos, const rtl::OUString& rExcludeElementName ); - ::Rectangle implts_determineFrontDockingRect( ::com::sun::star::ui::DockingArea eDockingArea, - sal_Int32 nRowCol, - const ::Rectangle& rDockedElementRect, - const ::rtl::OUString& rMovedElementName, - const ::Rectangle& rMovedElementRect ); - void implts_calcWindowPosSizeOnSingleRowColumn( sal_Int32 nDockingArea, - sal_Int32 nOffset, - SingleRowColumnWindowData& rRowColumnWindowData, - const ::Size& rContainerSize ); - ::Rectangle implts_calcTrackingAndElementRect( ::com::sun::star::ui::DockingArea eDockingArea, - sal_Int32 nRowCol, - UIElement& rUIElement, - const ::Rectangle& rTrackingRect, - const ::Rectangle& rRowColumnRect, - const ::Size& rContainerWinSize ); - void implts_renumberRowColumnData( ::com::sun::star::ui::DockingArea eDockingArea, DockingOperation eDockingOperation, const UIElement& rUIElement ); // layouting methods - sal_Bool implts_compareRectangles( const ::com::sun::star::awt::Rectangle& rRect1, const ::com::sun::star::awt::Rectangle& rRect2 ); sal_Bool implts_resizeContainerWindow( const ::com::sun::star::awt::Size& rContainerSize, const ::com::sun::star::awt::Point& rComponentPos ); ::Size implts_getTopBottomDockingAreaSizes(); ::Size implts_getContainerWindowOutputSize(); - ::com::sun::star::awt::Rectangle implts_getDockingAreaWindowSizes(); - void implts_getDockingAreaElementInfos( ::com::sun::star::ui::DockingArea DockingArea, std::vector< SingleRowColumnWindowData >& rRowColumnsWindowData ); - void implts_getDockingAreaElementInfoOnSingleRowCol( ::com::sun::star::ui::DockingArea, - sal_Int32 nRowCol, - SingleRowColumnWindowData& rRowColumnWindowData ); - ::Point implts_findNextCascadeFloatingPos(); - void implts_findNextDockingPos( ::com::sun::star::ui::DockingArea DockingArea, const ::Size& aUIElementSize, ::Point& rVirtualPos, ::Point& rPixelPos ); + + void implts_setDockingAreaWindowSizes( const css::awt::Rectangle& rBorderSpace ); ::com::sun::star::awt::Rectangle implts_calcDockingAreaSizes(); - void implts_setDockingAreaWindowSizes( const com::sun::star::awt::Rectangle& rBorderSpace ); sal_Bool implts_doLayout( sal_Bool bForceRequestBorderSpace, sal_Bool bOuterResize ); - void implts_doLayout_notify( sal_Bool bOuterResize ); + void implts_doLayout_notify( sal_Bool bOuterResize ); // internal methods to control status/progress bar ::Size implts_getStatusBarSize(); @@ -415,6 +280,7 @@ namespace framework sal_Bool implts_showProgressBar(); sal_Bool implts_hideProgressBar(); void implts_backupProgressBarWrapper(); + void implts_setOffset( const sal_Int32 nBottomOffset ); void implts_setInplaceMenuBar( const ::com::sun::star::uno::Reference< ::com::sun::star::container::XIndexAccess >& xMergedMenuBar ) @@ -425,12 +291,7 @@ namespace framework void implts_setVisibleState( sal_Bool bShow ); void implts_updateUIElementsVisibleState( sal_Bool bShow ); void implts_setCurrentUIVisibility( sal_Bool bShow ); - sal_Bool impl_parseResourceURL( const rtl::OUString aResourceURL, rtl::OUString& aElementType, rtl::OUString& aElementName ); - void implts_notifyListeners( short nEvent, ::com::sun::star::uno::Any aInfoParam ); -#ifdef DBG_UTIL - void implts_checkElementContainer(); -#endif DECL_LINK( OptionsChanged, void* ); DECL_LINK( SettingsChanged, void* ); @@ -459,9 +320,7 @@ namespace framework css::uno::WeakReference< css::frame::XModel > m_xModel; css::uno::Reference< css::awt::XWindow > m_xContainerWindow; css::uno::Reference< css::awt::XTopWindow2 > m_xContainerTopWindow; - css::uno::Reference< css::awt::XWindow > m_xDockAreaWindows[DOCKINGAREAS_COUNT]; sal_Int32 m_nLockCount; - UIElementVector m_aUIElements; bool m_bActive; bool m_bInplaceMenuSet; bool m_bDockingInProgress; @@ -476,11 +335,9 @@ namespace framework bool m_bHideCurrentUI; bool m_bGlobalSettings; bool m_bPreserveContentSize; - DockingOperation m_eDockOperation; - UIElement m_aDockUIElement; + bool m_bMenuBarCloser; css::awt::Rectangle m_aDockingArea; css::uno::Reference< ::com::sun::star::ui::XDockingAreaAcceptor > m_xDockingAreaAcceptor; - Point m_aStartDockMousePos; css::uno::Reference< ::com::sun::star::lang::XComponent > m_xInplaceMenuBar; MenuBarManager* m_pInplaceMenuBar; css::uno::Reference< ::com::sun::star::ui::XUIElement > m_xMenuBar; @@ -489,14 +346,10 @@ namespace framework com::sun::star::uno::Reference< ::com::sun::star::ui::XUIElement > m_xProgressBarBackup; css::uno::Reference< ::com::sun::star::frame::XModuleManager > m_xModuleManager; css::uno::Reference< ::com::sun::star::ui::XUIElementFactory > m_xUIElementFactoryManager; - bool m_bMenuBarCloser; css::uno::Reference< ::com::sun::star::container::XNameAccess > m_xPersistentWindowState; css::uno::Reference< ::com::sun::star::container::XNameAccess > m_xPersistentWindowStateSupplier; GlobalSettings* m_pGlobalSettings; rtl::OUString m_aModuleIdentifier; - rtl::OUString m_aCustomTbxPrefix; - rtl::OUString m_aFullCustomTbxPrefix; - rtl::OUString m_aFullAddonTbxPrefix; rtl::OUString m_aStatusBarAlias; rtl::OUString m_aProgressBarAlias; rtl::OUString m_aPropDocked; @@ -509,12 +362,13 @@ namespace framework rtl::OUString m_aPropStyle; rtl::OUString m_aPropLocked; rtl::OUString m_aCustomizeCmd; - AddonsOptions* m_pAddonOptions; - SvtMiscOptions* m_pMiscOptions; sal_Int16 m_eSymbolsSize; sal_Int16 m_eSymbolsStyle; - Timer m_aAsyncLayoutTimer; + Timer m_aAsyncLayoutTimer; ::cppu::OMultiTypeInterfaceContainerHelper m_aListenerContainer; // container for ALL Listener + PanelManager* m_pPanelManager; + ToolbarLayoutManager* m_pToolbarManager; + css::uno::Reference< ::com::sun::star::ui::XUIConfigurationListener > m_xToolbarManager; }; } // namespace framework diff --git a/framework/inc/services/modelwinservice.hxx b/framework/inc/services/modelwinservice.hxx new file mode 100755 index 0000000000..8a334253ff --- /dev/null +++ b/framework/inc/services/modelwinservice.hxx @@ -0,0 +1,122 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2008 by Sun Microsystems, Inc. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: urltransformer.hxx,v $ + * $Revision: 1.8 $ + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef __FRAMEWORK_SERVICES_MODELWINSERVICE_HXX_ +#define __FRAMEWORK_SERVICES_MODELWINSERVICE_HXX_ + +//_________________________________________________________________________________________________________________ +// my own includes +//_________________________________________________________________________________________________________________ + +#include <threadhelp/threadhelpbase.hxx> +#include <macros/generic.hxx> +#include <macros/debug.hxx> +#include <macros/xinterface.hxx> +#include <macros/xtypeprovider.hxx> +#include <macros/xserviceinfo.hxx> +#include <general.h> +#include <stdtypes.h> + +//_________________________________________________________________________________________________________________ +// interface includes +//_________________________________________________________________________________________________________________ + +#include <com/sun/star/lang/XTypeProvider.hpp> +#include <com/sun/star/awt/XWindow.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/container/XNameAccess.hpp> +#include <com/sun/star/awt/XControlModel.hpp> + +//_________________________________________________________________________________________________________________ +// other includes +//_________________________________________________________________________________________________________________ + +#include <cppuhelper/weak.hxx> +#include <vcl/window.hxx> + +//_________________________________________________________________________________________________________________ +// namespace +//_________________________________________________________________________________________________________________ + +namespace framework{ + +class IModelWin +{ + public: + virtual void registerModelForXWindow( const css::uno::Reference< css::awt::XWindow >& rWindow, const css::uno::Reference< css::awt::XControlModel >& rModel ) = 0; + virtual void deregisterModelForXWindow( const css::uno::Reference< css::awt::XWindow >& rWindow ) = 0; +}; + +class ModelWinService : public css::lang::XTypeProvider + , public css::lang::XServiceInfo + , public css::container::XNameAccess + , public IModelWin + , public ::cppu::OWeakObject +{ + public: + ModelWinService(const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& rServiceManager ); + virtual ~ModelWinService(); + + //--------------------------------------------------------------------------------------------------------- + // XInterface, XTypeProvider, XServiceInfo + //--------------------------------------------------------------------------------------------------------- + + FWK_DECLARE_XINTERFACE + FWK_DECLARE_XTYPEPROVIDER + DECLARE_XSERVICEINFO + + //--------------------------------------------------------------------------------------------------------- + // IModelWin + //--------------------------------------------------------------------------------------------------------- + virtual void registerModelForXWindow( const css::uno::Reference< css::awt::XWindow >& rWindow, const css::uno::Reference< css::awt::XControlModel >& rModel ); + virtual void deregisterModelForXWindow( const css::uno::Reference< css::awt::XWindow >& rWindow ); + + //--------------------------------------------------------------------------------------------------------- + // XNameAccess + //--------------------------------------------------------------------------------------------------------- + virtual css::uno::Any SAL_CALL getByName( const ::rtl::OUString& sName ) throw( css::container::NoSuchElementException , + css::lang::WrappedTargetException , + css::uno::RuntimeException ); + virtual css::uno::Sequence< ::rtl::OUString > SAL_CALL getElementNames() throw( css::uno::RuntimeException ); + virtual sal_Bool SAL_CALL hasByName( const ::rtl::OUString& sName ) throw( css::uno::RuntimeException ); + + //--------------------------------------------------------------------------------------------------------- + // XElementAccess + //--------------------------------------------------------------------------------------------------------- + virtual css::uno::Type SAL_CALL getElementType() throw( css::uno::RuntimeException ); + virtual sal_Bool SAL_CALL hasElements() throw( css::uno::RuntimeException ); + + private: + css::uno::Reference< css::lang::XMultiServiceFactory > m_xServiceManager; +}; + +} + +#endif // __FRAMEWORK_SERVICES_MODELWINSERVICE_HXX_ diff --git a/framework/inc/uielement/panelwindow.hxx b/framework/inc/uielement/panelwindow.hxx new file mode 100755 index 0000000000..5ae692413c --- /dev/null +++ b/framework/inc/uielement/panelwindow.hxx @@ -0,0 +1,81 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2008 by Sun Microsystems, Inc. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: layoutmanager.hxx,v $ + * $Revision: 1.34 $ + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef __FRAMEWORK_LAYOUTMANAGER_PANELWINDOW_HXX_ +#define __FRAMEWORK_LAYOUTMANAGER_PANELWINDOW_HXX_ + +//_________________________________________________________________________________________________________________ +// my own includes +//_________________________________________________________________________________________________________________ + +#include <vcl/dockwin.hxx> + +//_________________________________________________________________________________________________________________ +// namespace +//_________________________________________________________________________________________________________________ + +namespace framework +{ + +class PanelWindow : public DockingWindow +{ + public: + PanelWindow( Window* pParent, WinBits nWinBits =0); + virtual ~PanelWindow(); + + const ::rtl::OUString& getResourceURL() const; + void setResourceURL(const ::rtl::OUString& rResourceURL); + Window* getContentWindow() const; + void setContentWindow( Window* pContentWindow ); + + virtual void Command ( const CommandEvent& rCEvt ); + virtual void StateChanged( StateChangedType nType ); + virtual void DataChanged( const DataChangedEvent& rDCEvt ); + virtual void Resize(); + + // Provide additional handlers to support external implementations + void SetCommandHdl( const Link& aLink ) { m_aCommandHandler = aLink; } + const Link& GetCommandHdl() const { return m_aCommandHandler; } + void SetStateChangedHdl( const Link& aLink ) { m_aStateChangedHandler = aLink; } + const Link& GetStateChangedHdl() const { return m_aStateChangedHandler; } + void SetDataChangedHdl( const Link& aLink ) { m_aDataChangedHandler = aLink; } + const Link& GetDataChangedHdl() { return m_aDataChangedHandler; } + + private: + ::rtl::OUString m_aResourceURL; + Link m_aCommandHandler; + Link m_aStateChangedHandler; + Link m_aDataChangedHandler; + Window* m_pContentWindow; +}; + +} + +#endif // __FRAMEWORK_UIELEMENT_PANELWINDOW_HXX_ diff --git a/framework/inc/uielement/panelwrapper.hxx b/framework/inc/uielement/panelwrapper.hxx new file mode 100755 index 0000000000..bd8fd63317 --- /dev/null +++ b/framework/inc/uielement/panelwrapper.hxx @@ -0,0 +1,68 @@ + + +#ifndef __FRAMEWORK_UIELEMENT_PANELWRAPPER_HXX_ +#define __FRAMEWORK_UIELEMENT_PANELWRAPPER_HXX_ + +//_________________________________________________________________________________________________________________ +// my own includes +//_________________________________________________________________________________________________________________ + +#include <helper/uielementwrapperbase.hxx> + +//_________________________________________________________________________________________________________________ +// interface includes +//_________________________________________________________________________________________________________________ + +#include <com/sun/star/frame/XFrame.hpp> +#include <com/sun/star/lang/XComponent.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> + +//_________________________________________________________________________________________________________________ +// other includes +//_________________________________________________________________________________________________________________ + +namespace framework +{ + +class PanelWrapper : public UIElementWrapperBase +{ + public: + PanelWrapper( const com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory >& xServiceManager ); + virtual ~PanelWrapper(); + + // XInterface + virtual void SAL_CALL acquire() throw(); + virtual void SAL_CALL release() throw(); + virtual ::com::sun::star::uno::Any SAL_CALL queryInterface( const ::com::sun::star::uno::Type & rType ) throw( ::com::sun::star::uno::RuntimeException ); + + // XComponent + virtual void SAL_CALL dispose() throw (::com::sun::star::uno::RuntimeException); + + // XInitialization + virtual void SAL_CALL initialize( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& aArguments ) throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException); + + // XUIElement + virtual ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > SAL_CALL getRealInterface() throw (::com::sun::star::uno::RuntimeException); + + // XUpdatable + virtual void SAL_CALL update() throw (::com::sun::star::uno::RuntimeException); + + // XEventListener + using cppu::OPropertySetHelper::disposing; + virtual void SAL_CALL disposing( const ::com::sun::star::lang::EventObject& aEvent ) throw (::com::sun::star::uno::RuntimeException); + + //------------------------------------------------------------------------------------------------------------- + // protected methods + //------------------------------------------------------------------------------------------------------------- + protected: + virtual void SAL_CALL setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const com::sun::star::uno::Any& aValue ) throw( com::sun::star::uno::Exception ); + + private: + com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory > m_xServiceManager; + com::sun::star::uno::Reference< com::sun::star::awt::XWindow > m_xPanelWindow; + bool m_bNoClose; +}; + +} + +#endif // __FRAMEWORK_UIELEMENT_PANELWRAPPER_HXX_ diff --git a/framework/inc/uielement/uielement.hxx b/framework/inc/uielement/uielement.hxx new file mode 100755 index 0000000000..6afa94b676 --- /dev/null +++ b/framework/inc/uielement/uielement.hxx @@ -0,0 +1,146 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2008 by Sun Microsystems, Inc. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: layoutmanager.hxx,v $ + * $Revision: 1.34 $ + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef __FRAMEWORK_LAYOUTMANAGER_UIELEMENT_HXX_ +#define __FRAMEWORK_LAYOUTMANAGER_UIELEMENT_HXX_ + +//_________________________________________________________________________________________________________________ +// my own includes +//_________________________________________________________________________________________________________________ + +//_________________________________________________________________________________________________________________ +// interface includes +//_________________________________________________________________________________________________________________ + +#include <com/sun/star/ui/XUIElement.hpp> +#include <com/sun/star/ui/DockingArea.hpp> + +//_________________________________________________________________________________________________________________ +// other includes +//_________________________________________________________________________________________________________________ + +#include <rtl/ustring.hxx> +#include <vcl/toolbox.hxx> + +//_________________________________________________________________________________________________________________ +// namespace +//_________________________________________________________________________________________________________________ + +namespace framework +{ + +struct DockedData +{ + DockedData() : m_aPos( LONG_MAX, LONG_MAX ), + m_nDockedArea( ::com::sun::star::ui::DockingArea_DOCKINGAREA_TOP ), + m_bLocked( false ) {} + + Point m_aPos; + Size m_aSize; + sal_Int16 m_nDockedArea; + bool m_bLocked; +}; + +struct FloatingData +{ + FloatingData() : m_aPos( LONG_MAX, LONG_MAX ), + m_nLines( 1 ), + m_bIsHorizontal( true ) {} + + Point m_aPos; + Size m_aSize; + sal_Int16 m_nLines; + bool m_bIsHorizontal; +}; + +struct UIElement +{ + UIElement() : m_bFloating( false ), + m_bVisible( true ), + m_bUserActive( false ), + m_bCreateNewRowCol0( false ), + m_bDeactiveHide( false ), + m_bMasterHide( false ), + m_bContextSensitive( false ), + m_bContextActive( true ), + m_bNoClose( false ), + m_bSoftClose( false ), + m_bStateRead( false ), + m_nStyle( BUTTON_SYMBOL ) + {} + + UIElement( const rtl::OUString& rName, + const rtl::OUString& rType, + const com::sun::star::uno::Reference< ::com::sun::star::ui::XUIElement >& rUIElement, + bool bFloating = false + ) : m_aType( rType ), + m_aName( rName ), + m_xUIElement( rUIElement ), + m_bFloating( bFloating ), + m_bVisible( true ), + m_bUserActive( false ), + m_bCreateNewRowCol0( false ), + m_bDeactiveHide( false ), + m_bMasterHide( false ), + m_bContextSensitive( false ), + m_bContextActive( true ), + m_bNoClose( false ), + m_bSoftClose( false ), + m_bStateRead( false ), + m_nStyle( BUTTON_SYMBOL ) {} + + bool operator< ( const UIElement& aUIElement ) const; + UIElement& operator=( const UIElement& rUIElement ); + + rtl::OUString m_aType; + rtl::OUString m_aName; + rtl::OUString m_aUIName; + com::sun::star::uno::Reference< ::com::sun::star::ui::XUIElement > m_xUIElement; + bool m_bFloating, + m_bVisible, + m_bUserActive, + m_bCreateNewRowCol0, + m_bDeactiveHide, + m_bMasterHide, + m_bContextSensitive, + m_bContextActive; + bool m_bNoClose, + m_bSoftClose, + m_bStateRead; + sal_Int16 m_nStyle; + DockedData m_aDockedData; + FloatingData m_aFloatingData; +}; + +typedef std::vector< UIElement > UIElementVector; + +} // namespace framework + +#endif // __FRAMEWORK_LAYOUTMANAGER_UIELEMENT_HXX_ diff --git a/framework/source/layoutmanager/helpers.cxx b/framework/source/layoutmanager/helpers.cxx new file mode 100755 index 0000000000..e1f07c7440 --- /dev/null +++ b/framework/source/layoutmanager/helpers.cxx @@ -0,0 +1,415 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2008 by Sun Microsystems, Inc. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: layoutmanager.hxx,v $ + * $Revision: 1.34 $ + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_framework.hxx" + +// my own includes +#include "helpers.hxx" +#include <threadhelp/resetableguard.hxx> +#include <services.h> + +// interface includes +#include <com/sun/star/ui/DockingArea.hpp> +#include <com/sun/star/awt/XTopWindow.hpp> +#include <com/sun/star/frame/XDispatchHelper.hpp> +#include <com/sun/star/awt/XDockableWindow.hpp> +#include <com/sun/star/awt/XDockableWindowListener.hpp> +#include <com/sun/star/awt/XWindowListener.hpp> +#include <com/sun/star/ui/XUIElement.hpp> + +// other includes +#include <comphelper/mediadescriptor.hxx> +#include <vcl/svapp.hxx> +#include <vos/mutex.hxx> +#include <toolkit/unohlp.hxx> + +// namespace +using namespace com::sun::star; + +namespace framework +{ + +bool hasEmptySize( const:: Size& aSize ) +{ + return ( aSize.Width() == 0 ) && ( aSize.Height() == 0 ); +} + +bool hasDefaultPosValue( const ::Point& aPos ) +{ + return (( aPos.X() == SAL_MAX_INT32 ) || ( aPos.Y() == SAL_MAX_INT32 )); +} + +bool isDefaultPos( const ::com::sun::star::awt::Point& aPos ) +{ + return (( aPos.X == SAL_MAX_INT32 ) && ( aPos.Y == SAL_MAX_INT32 )); +} + +bool isDefaultPos( const ::Point& aPos ) +{ + return (( aPos.X() == SAL_MAX_INT32 ) && ( aPos.Y() == SAL_MAX_INT32 )); +} + +bool isReverseOrderDockingArea( const sal_Int32 nDockArea ) +{ + ui::DockingArea eDockArea = static_cast< ui::DockingArea >( nDockArea ); + return (( eDockArea == ui::DockingArea_DOCKINGAREA_BOTTOM ) || + ( eDockArea == ui::DockingArea_DOCKINGAREA_RIGHT )); +} + +bool isToolboxHorizontalAligned( ToolBox* pToolBox ) +{ + if ( pToolBox ) + return (( pToolBox->GetAlign() == WINDOWALIGN_TOP ) || ( pToolBox->GetAlign() == WINDOWALIGN_BOTTOM )); + return false; +} + +bool isHorizontalDockingArea( const ui::DockingArea& nDockingArea ) +{ + return (( nDockingArea == ui::DockingArea_DOCKINGAREA_TOP ) || + ( nDockingArea == ui::DockingArea_DOCKINGAREA_BOTTOM )); +} + +bool isHorizontalDockingArea( const sal_Int32 nDockArea ) +{ + return isHorizontalDockingArea(static_cast< ui::DockingArea >( nDockArea )); +} + +::rtl::OUString retrieveToolbarNameFromHelpURL( Window* pWindow ) +{ + ::rtl::OUString aToolbarName; + + if ( pWindow->GetType() == WINDOW_TOOLBOX ) + { + ToolBox* pToolBox = dynamic_cast<ToolBox *>( pWindow ); + if ( pToolBox ) + { + aToolbarName = rtl::OStringToOUString( pToolBox->GetHelpId(), RTL_TEXTENCODING_UTF8 ); + sal_Int32 i = aToolbarName.lastIndexOf( ':' ); + if (( aToolbarName.getLength() > 0 ) && ( i > 0 ) && (( i+ 1 ) < aToolbarName.getLength() )) + aToolbarName = aToolbarName.copy( i+1 ); // Remove ".HelpId:" protocol from toolbar name + else + aToolbarName = ::rtl::OUString(); + } + } + return aToolbarName; +} + +ToolBox* getToolboxPtr( Window* pWindow ) +{ + ToolBox* pToolbox(NULL); + if ( pWindow->GetType() == WINDOW_TOOLBOX ) + pToolbox = dynamic_cast<ToolBox*>( pWindow ); + return pToolbox; +} + +Window* getWindowFromXUIElement( const uno::Reference< ui::XUIElement >& xUIElement ) +{ + vos::OGuard aGuard( Application::GetSolarMutex() ); + uno::Reference< awt::XWindow > xWindow; + if ( xUIElement.is() ) + xWindow = uno::Reference< awt::XWindow >( xUIElement->getRealInterface(), uno::UNO_QUERY ); + return VCLUnoHelper::GetWindow( xWindow ); +} + +SystemWindow* getTopSystemWindow( const uno::Reference< awt::XWindow >& xWindow ) +{ + Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); + while ( pWindow && !pWindow->IsSystemWindow() ) + pWindow = pWindow->GetParent(); + + if ( pWindow ) + return (SystemWindow *)pWindow; + else + return 0; +} + +void setZeroRectangle( ::Rectangle& rRect ) +{ + rRect.setX(0); + rRect.setY(0); + rRect.setWidth(0); + rRect.setHeight(0); +} + +// ATTENTION! +// This value is directly copied from the sfx2 project. +// You have to change BOTH values, see sfx2/inc/sfx2/sfxsids.hrc (SID_DOCKWIN_START) +static const sal_Int32 DOCKWIN_ID_BASE = 9800; + +bool lcl_checkUIElement(const uno::Reference< ui::XUIElement >& xUIElement, awt::Rectangle& _rPosSize, uno::Reference< awt::XWindow >& _xWindow) +{ + bool bRet = xUIElement.is(); + if ( bRet ) + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + _xWindow.set( xUIElement->getRealInterface(), uno::UNO_QUERY ); + _rPosSize = _xWindow->getPosSize(); + + Window* pWindow = VCLUnoHelper::GetWindow( _xWindow ); + if ( pWindow->GetType() == WINDOW_TOOLBOX ) + { + ::Size aSize = ((ToolBox*)pWindow)->CalcWindowSizePixel( 1 ); + _rPosSize.Width = aSize.Width(); + _rPosSize.Height = aSize.Height(); + } + } // if ( xUIElement.is() ) + return bRet; +} + +uno::Reference< awt::XWindowPeer > createToolkitWindow( const uno::Reference< lang::XMultiServiceFactory >& rFactory, const uno::Reference< awt::XWindowPeer >& rParent, const char* pService ) +{ + const rtl::OUString aAWTToolkit( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.awt.Toolkit" )); + + uno::Reference< awt::XWindowPeer > xPeer; + if ( rFactory.is() ) + { + uno::Reference< awt::XToolkit > xToolkit( rFactory->createInstance( aAWTToolkit ), uno::UNO_QUERY_THROW ); + if ( xToolkit.is() ) + { + // describe window properties. + css::awt::WindowDescriptor aDescriptor; + aDescriptor.Type = awt::WindowClass_SIMPLE; + aDescriptor.WindowServiceName = ::rtl::OUString::createFromAscii( pService ); + aDescriptor.ParentIndex = -1; + aDescriptor.Parent = uno::Reference< awt::XWindowPeer >( rParent, uno::UNO_QUERY ); + aDescriptor.Bounds = awt::Rectangle(0,0,0,0); + aDescriptor.WindowAttributes = 0; + + // create a awt window + xPeer = xToolkit->createWindow( aDescriptor ); + } + } + + return xPeer; +} + +// convert alignment constant to vcl's WindowAlign type +WindowAlign ImplConvertAlignment( sal_Int16 aAlignment ) +{ + if ( aAlignment == ui::DockingArea_DOCKINGAREA_LEFT ) + return WINDOWALIGN_LEFT; + else if ( aAlignment == ui::DockingArea_DOCKINGAREA_RIGHT ) + return WINDOWALIGN_RIGHT; + else if ( aAlignment == ui::DockingArea_DOCKINGAREA_TOP ) + return WINDOWALIGN_TOP; + else + return WINDOWALIGN_BOTTOM; +} + +::rtl::OUString getElementTypeFromResourceURL( const ::rtl::OUString& aResourceURL ) +{ + ::rtl::OUString aType; + + ::rtl::OUString aUIResourceURL( UIRESOURCE_URL ); + if ( aResourceURL.indexOf( aUIResourceURL ) == 0 ) + { + sal_Int32 nIndex = 0; + ::rtl::OUString aPathPart = aResourceURL.copy( aUIResourceURL.getLength() ); + ::rtl::OUString aUIResource = aPathPart.getToken( 0, (sal_Unicode)'/', nIndex ); + + return aPathPart.getToken( 0, (sal_Unicode)'/', nIndex ); + } + + return aType; +} + +void parseResourceURL( const rtl::OUString& aResourceURL, rtl::OUString& aElementType, rtl::OUString& aElementName ) +{ + ::rtl::OUString aUIResourceURL( UIRESOURCE_URL ); + if ( aResourceURL.indexOf( aUIResourceURL ) == 0 ) + { + sal_Int32 nIndex = 0; + ::rtl::OUString aPathPart = aResourceURL.copy( aUIResourceURL.getLength() ); + ::rtl::OUString aUIResource = aPathPart.getToken( 0, (sal_Unicode)'/', nIndex ); + + aElementType = aPathPart.getToken( 0, (sal_Unicode)'/', nIndex ); + aElementName = aPathPart.getToken( 0, (sal_Unicode)'/', nIndex ); + } +} + +::com::sun::star::awt::Rectangle putRectangleValueToAWT( const ::Rectangle& rRect ) +{ + css::awt::Rectangle aRect; + aRect.X = rRect.Left(); + aRect.Y = rRect.Top(); + aRect.Width = rRect.Right(); + aRect.Height = rRect.Bottom(); + + return aRect; +} + +::Rectangle putAWTToRectangle( const ::com::sun::star::awt::Rectangle& rRect ) +{ + ::Rectangle aRect; + aRect.Left() = rRect.X; + aRect.Top() = rRect.Y; + aRect.Right() = rRect.Width; + aRect.Bottom() = rRect.Height; + + return aRect; +} + +css::awt::Rectangle convertRectangleToAWT( const ::Rectangle& rRect ) +{ + css::awt::Rectangle aRect; + aRect.X = rRect.Left(); + aRect.Y = rRect.Top(); + aRect.Width = rRect.GetWidth(); + aRect.Height = rRect.GetHeight(); + return aRect; +} + +::Rectangle convertAWTToRectangle( const ::com::sun::star::awt::Rectangle& rRect ) +{ + ::Rectangle aRect; + aRect.Left() = rRect.X; + aRect.Top() = rRect.Y; + aRect.Right() = rRect.X + rRect.Width; + aRect.Bottom() = rRect.Y + rRect.Height; + + return aRect; +} + +bool equalRectangles( const css::awt::Rectangle& rRect1, + const css::awt::Rectangle& rRect2 ) +{ + return (( rRect1.X == rRect2.X ) && + ( rRect1.Y == rRect2.Y ) && + ( rRect1.Width == rRect2.Width ) && + ( rRect1.Height == rRect2.Height )); +} + +uno::Reference< frame::XModel > impl_getModelFromFrame( const uno::Reference< frame::XFrame >& rFrame ) +{ + // Query for the model to get check the context information + uno::Reference< frame::XModel > xModel; + if ( rFrame.is() ) + { + uno::Reference< frame::XController > xController( rFrame->getController(), uno::UNO_QUERY ); + if ( xController.is() ) + xModel = xController->getModel(); + } + + return xModel; +} + +sal_Bool implts_isPreviewModel( const uno::Reference< frame::XModel >& xModel ) +{ + if ( xModel.is() ) + { + ::comphelper::MediaDescriptor aDesc( xModel->getArgs() ); + return aDesc.getUnpackedValueOrDefault(::comphelper::MediaDescriptor::PROP_PREVIEW(), (sal_Bool)sal_False); + } + else + return sal_False; +} + +sal_Bool implts_isFrameOrWindowTop( const uno::Reference< frame::XFrame >& xFrame ) +{ + if (xFrame->isTop()) + return sal_True; + + uno::Reference< awt::XTopWindow > xWindowCheck(xFrame->getContainerWindow(), uno::UNO_QUERY); // dont use _THROW here ... its a check only + if (xWindowCheck.is()) + { + // --> PB 2007-06-18 #i76867# top and system window is required. + ::vos::OGuard aSolarLock(&Application::GetSolarMutex()); + uno::Reference< awt::XWindow > xWindow( xWindowCheck, uno::UNO_QUERY ); + Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); + return ( pWindow && pWindow->IsSystemWindow() ); + // <-- + } + + return sal_False; +} + +void impl_setDockingWindowVisibility( const css::uno::Reference< css::lang::XMultiServiceFactory>& rSMGR, const css::uno::Reference< css::frame::XFrame >& rFrame, const ::rtl::OUString& rDockingWindowName, bool bVisible ) +{ + const ::rtl::OUString aDockWinPrefixCommand( RTL_CONSTASCII_USTRINGPARAM( "DockingWindow" )); + css::uno::WeakReference< css::frame::XDispatchHelper > xDispatchHelper; + + sal_Int32 nID = rDockingWindowName.toInt32(); + sal_Int32 nIndex = nID - DOCKWIN_ID_BASE; + + css::uno::Reference< css::frame::XDispatchProvider > xProvider(rFrame, css::uno::UNO_QUERY); + if ( nIndex >= 0 && xProvider.is() ) + { + ::rtl::OUString aDockWinCommand( RTL_CONSTASCII_USTRINGPARAM( ".uno:" )); + ::rtl::OUString aDockWinArgName( aDockWinPrefixCommand ); + + aDockWinArgName += ::rtl::OUString::valueOf( nIndex ); + + css::uno::Sequence< css::beans::PropertyValue > aArgs(1); + aArgs[0].Name = aDockWinArgName; + aArgs[0].Value = css::uno::makeAny( bVisible ); + + css::uno::Reference< css::frame::XDispatchHelper > xDispatcher( xDispatchHelper ); + if ( !xDispatcher.is()) + { + xDispatcher = css::uno::Reference< css::frame::XDispatchHelper >( + rSMGR->createInstance(SERVICENAME_DISPATCHHELPER), css::uno::UNO_QUERY_THROW); + } + + aDockWinCommand = aDockWinCommand + aDockWinArgName; + xDispatcher->executeDispatch( + xProvider, + aDockWinCommand, + ::rtl::OUString::createFromAscii("_self"), + 0, + aArgs); + } +} + +void impl_addWindowListeners( + const css::uno::Reference< css::uno::XInterface >& xThis, + const css::uno::Reference< css::ui::XUIElement >& xUIElement ) +{ + css::uno::Reference< css::awt::XWindow > xWindow( xUIElement->getRealInterface(), css::uno::UNO_QUERY ); + css::uno::Reference< css::awt::XDockableWindow > xDockWindow( xUIElement->getRealInterface(), css::uno::UNO_QUERY ); + if ( xDockWindow.is() && xWindow.is() ) + { + try + { + xDockWindow->addDockableWindowListener( + css::uno::Reference< css::awt::XDockableWindowListener >( + xThis, css::uno::UNO_QUERY )); + xWindow->addWindowListener( + css::uno::Reference< css::awt::XWindowListener >( + xThis, css::uno::UNO_QUERY )); + xDockWindow->enableDocking( sal_True ); + } + catch ( css::uno::Exception& ) + { + } + } +} + +} // namespace framework diff --git a/framework/source/layoutmanager/helpers.hxx b/framework/source/layoutmanager/helpers.hxx new file mode 100755 index 0000000000..545abb2a1f --- /dev/null +++ b/framework/source/layoutmanager/helpers.hxx @@ -0,0 +1,95 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2008 by Sun Microsystems, Inc. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: layoutmanager.hxx,v $ + * $Revision: 1.34 $ + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef __FRAMEWORK_LAYOUTMANAGER_HELPERS_HXX_ +#define __FRAMEWORK_LAYOUTMANAGER_HELPERS_HXX_ + +// my own includes +#include <macros/generic.hxx> +#include <stdtypes.h> +#include <properties.h> + +// interface includes +#include <com/sun/star/awt/XWindowPeer.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> +#include <com/sun/star/frame/XFrame.hpp> +#include <com/sun/star/ui/XUIElement.hpp> +#include <com/sun/star/awt/Rectangle.hpp> +#include <com/sun/star/ui/DockingArea.hpp> +#include <com/sun/star/awt/Point.hpp> + +// other includes +#include <vcl/window.hxx> +#include <vcl/toolbox.hxx> + +#define UIRESOURCE_PROTOCO_ASCII "private:" +#define UIRESOURCE_RESOURCE_ASCII "resource" +#define UIRESOURCE_URL_ASCII "private:resource" +#define UIRESOURCE_URL rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( UIRESOURCE_URL_ASCII )) +#define UIRESOURCETYPE_TOOLBAR "toolbar" +#define UIRESOURCETYPE_STATUSBAR "statusbar" +#define UIRESOURCETYPE_MENUBAR "menubar" + +namespace framework +{ + +bool hasEmptySize( const:: Size& aSize ); +bool hasDefaultPosValue( const ::Point& aPos ); +bool isDefaultPos( const ::com::sun::star::awt::Point& aPos ); +bool isDefaultPos( const ::Point& aPos ); +bool isToolboxHorizontalAligned( ToolBox* pToolBox ); +bool isReverseOrderDockingArea( const sal_Int32 nDockArea ); +bool isHorizontalDockingArea( const sal_Int32 nDockArea ); +bool isHorizontalDockingArea( const ::com::sun::star::ui::DockingArea& nDockArea ); +::rtl::OUString retrieveToolbarNameFromHelpURL( Window* pWindow ); +ToolBox* getToolboxPtr( Window* pWindow ); +Window* getWindowFromXUIElement( const ::com::sun::star::uno::Reference< ::com::sun::star::ui::XUIElement >& xUIElement ); +SystemWindow* getTopSystemWindow( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow >& xWindow ); +bool equalRectangles( const css::awt::Rectangle& rRect1, const css::awt::Rectangle& rRect2 ); +void setZeroRectangle( ::Rectangle& rRect ); +bool lcl_checkUIElement(const ::com::sun::star::uno::Reference< ::com::sun::star::ui::XUIElement >& xUIElement,::com::sun::star::awt::Rectangle& _rPosSize, ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow >& _xWindow); +::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer > createToolkitWindow( const css::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& rFactory, const css::uno::Reference< ::com::sun::star::awt::XWindowPeer >& rParent, const char* pService ); +WindowAlign ImplConvertAlignment( sal_Int16 aAlignment ); +::rtl::OUString getElementTypeFromResourceURL( const ::rtl::OUString& aResourceURL ); +void parseResourceURL( const rtl::OUString& aResourceURL, rtl::OUString& aElementType, rtl::OUString& aElementName ); +::Rectangle putAWTToRectangle( const ::com::sun::star::awt::Rectangle& rRect ); +::com::sun::star::awt::Rectangle putRectangleValueToAWT( const ::Rectangle& rRect ); +::com::sun::star::awt::Rectangle convertRectangleToAWT( const ::Rectangle& rRect ); +::Rectangle convertAWTToRectangle( const ::com::sun::star::awt::Rectangle& rRect ); +::com::sun::star::uno::Reference< ::com::sun::star::frame::XModel > impl_getModelFromFrame( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame ); +sal_Bool implts_isPreviewModel( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XModel >& xModel ); +sal_Bool implts_isFrameOrWindowTop( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& xFrame ); +void impl_setDockingWindowVisibility( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory>& rSMGR, const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame, const ::rtl::OUString& rDockingWindowName, bool bVisible ); +void impl_addWindowListeners( const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& xThis, const ::com::sun::star::uno::Reference< css::ui::XUIElement >& xUIElement ); +::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer > implts_createToolkitWindow( const css::uno::Reference< ::com::sun::star::awt::XToolkit >& rToolkit, const css::uno::Reference< ::com::sun::star::awt::XWindowPeer >& rParent ); + +} + +#endif // __FRAMEWORK_LAYOUTMANAGER_HELPERS_HXX_ diff --git a/framework/source/layoutmanager/layoutmanager.cxx b/framework/source/layoutmanager/layoutmanager.cxx index 6a668cd12a..1cdd893559 100644..100755 --- a/framework/source/layoutmanager/layoutmanager.cxx +++ b/framework/source/layoutmanager/layoutmanager.cxx @@ -1,11 +1,14 @@ /************************************************************************* * * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * + * * Copyright 2000, 2010 Oracle and/or its affiliates. * * OpenOffice.org - a multi-platform office productivity suite * + * $RCSfile: layoutmanager.cxx,v $ + * $Revision: 1.72 $ + * * This file is part of OpenOffice.org. * * OpenOffice.org is free software: you can redistribute it and/or modify @@ -28,34 +31,23 @@ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_framework.hxx" -//_________________________________________________________________________________________________________________ -// my own includes -//_________________________________________________________________________________________________________________ - -// #include <math.h> - -#ifndef _FRAMEWORK_SERVICES_LAYOUTMANAGER_HXX_ +// my own includes #include <services/layoutmanager.hxx> -#endif +#include <helpers.hxx> +#include <panelmanager.hxx> #include <threadhelp/resetableguard.hxx> #include <services.h> - #include <classes/sfxhelperfunctions.hxx> #include <uielement/menubarwrapper.hxx> -#include <classes/addonsoptions.hxx> #include <uiconfiguration/windowstateconfiguration.hxx> #include <classes/fwkresid.hxx> - -#ifndef __FRAMEWORK_CLASSES_RESOURCE_HRC_ #include <classes/resource.hrc> -#endif #include <toolkit/helper/convert.hxx> #include <uielement/progressbarwrapper.hxx> #include <uiconfiguration/globalsettings.hxx> +#include <toolbarlayoutmanager.hxx> -//_________________________________________________________________________________________________________________ -// interface includes -//_________________________________________________________________________________________________________________ +// interface includes #include <com/sun/star/beans/XPropertySet.hpp> #include <com/sun/star/beans/PropertyAttribute.hpp> #include <com/sun/star/frame/XModel.hpp> @@ -69,21 +61,17 @@ #include <com/sun/star/awt/PosSize.hpp> #include <com/sun/star/awt/XDevice.hpp> #include <com/sun/star/awt/XSystemDependentWindowPeer.hpp> -#include <com/sun/star/awt/XTopWindow.hpp> #include <com/sun/star/ui/XModuleUIConfigurationManagerSupplier.hpp> #include <com/sun/star/ui/XUIConfigurationManagerSupplier.hpp> #include <com/sun/star/ui/UIElementType.hpp> #include <com/sun/star/container/XNameReplace.hpp> #include <com/sun/star/container/XNameContainer.hpp> -#include <com/sun/star/ui/XUIFunctionListener.hpp> #include <com/sun/star/frame/LayoutManagerEvents.hpp> #include <com/sun/star/frame/XDispatchProvider.hpp> #include <com/sun/star/frame/XDispatchHelper.hpp> #include <com/sun/star/lang/DisposedException.hpp> -//_________________________________________________________________________________________________________________ -// other includes -//_________________________________________________________________________________________________________________ +// other includes #include <svtools/imgdef.hxx> #include <tools/diagnose_ex.h> #include <vcl/window.hxx> @@ -102,348 +90,101 @@ #include <algorithm> #include <boost/bind.hpp> -// ______________________________________________ -// using namespace +// using namespace using namespace ::com::sun::star; -using namespace com::sun::star::uno; -using namespace com::sun::star::beans; -using namespace com::sun::star::util; -using namespace com::sun::star::lang; -using namespace com::sun::star::container; +using namespace ::com::sun::star::uno; +using namespace ::com::sun::star::beans; +using namespace ::com::sun::star::util; +using namespace ::com::sun::star::lang; +using namespace ::com::sun::star::container; using namespace ::com::sun::star::ui; -using namespace com::sun::star::frame; using namespace ::com::sun::star::frame; -#define UIRESOURCE_PROTOCO_ASCII "private:" -#define UIRESOURCE_RESOURCE_ASCII "resource" -#define UIRESOURCE_URL_ASCII "private:resource" -#define UIRESOURCE_URL rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( UIRESOURCE_URL_ASCII )) // ATTENTION! // This value is directly copied from the sfx2 project. // You have to change BOTH values, see sfx2/inc/sfx2/sfxsids.hrc (SID_DOCKWIN_START) static const sal_Int32 DOCKWIN_ID_BASE = 9800; -bool lcl_checkUIElement(const Reference< XUIElement >& xUIElement,css::awt::Rectangle& _rPosSize,Reference< css::awt::XWindow >& _xWindow) -{ - bool bRet = xUIElement.is(); - if ( bRet ) - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - _xWindow.set( xUIElement->getRealInterface(), UNO_QUERY ); - _rPosSize = _xWindow->getPosSize(); - - Window* pWindow = VCLUnoHelper::GetWindow( _xWindow ); - if ( pWindow->GetType() == WINDOW_TOOLBOX ) - { - ::Size aSize = ((ToolBox*)pWindow)->CalcWindowSizePixel( 1 ); - _rPosSize.Width = aSize.Width(); - _rPosSize.Height = aSize.Height(); - } - } // if ( xUIElement.is() ) - return bRet; -} - -// convert alignment constant to vcl's WindowAlign type -static WindowAlign ImplConvertAlignment( sal_Int16 aAlignment ) -{ - if ( aAlignment == DockingArea_DOCKINGAREA_LEFT ) - return WINDOWALIGN_LEFT; - else if ( aAlignment == DockingArea_DOCKINGAREA_RIGHT ) - return WINDOWALIGN_RIGHT; - else if ( aAlignment == DockingArea_DOCKINGAREA_TOP ) - return WINDOWALIGN_TOP; - else - return WINDOWALIGN_BOTTOM; -} - -//_________________________________________________________________________________________________________________ -// Namespace -//_________________________________________________________________________________________________________________ -// - namespace framework { -struct UIElementVisibility -{ - rtl::OUString aName; - bool bVisible; -}; - -bool LayoutManager::UIElement::operator< ( const LayoutManager::UIElement& aUIElement ) const -{ - if ( !m_xUIElement.is() && aUIElement.m_xUIElement.is() ) - return false; - else if ( m_xUIElement.is() && !aUIElement.m_xUIElement.is() ) - return true; - else if ( !m_bVisible && aUIElement.m_bVisible ) - return false; - else if ( m_bVisible && !aUIElement.m_bVisible ) - return true; - else if ( !m_bFloating && aUIElement.m_bFloating ) - return true; - else if ( m_bFloating && !aUIElement.m_bFloating ) - return false; - else - { - if ( m_bFloating ) - { - bool bEqual = ( m_aFloatingData.m_aPos.Y() == aUIElement.m_aFloatingData.m_aPos.Y() ); - if ( bEqual ) - return ( m_aFloatingData.m_aPos.X() < aUIElement.m_aFloatingData.m_aPos.X() ); - else - return ( m_aFloatingData.m_aPos.Y() < aUIElement.m_aFloatingData.m_aPos.Y() ); - } - else - { - if ( m_aDockedData.m_nDockedArea < aUIElement.m_aDockedData.m_nDockedArea ) - return true; - else if ( m_aDockedData.m_nDockedArea > aUIElement.m_aDockedData.m_nDockedArea ) - return false; - else - { - if ( m_aDockedData.m_nDockedArea == DockingArea_DOCKINGAREA_TOP || - m_aDockedData.m_nDockedArea == DockingArea_DOCKINGAREA_BOTTOM ) - { - if ( !( m_aDockedData.m_aPos.Y() == aUIElement.m_aDockedData.m_aPos.Y() ) ) - return ( m_aDockedData.m_aPos.Y() < aUIElement.m_aDockedData.m_aPos.Y() ); - else - { - bool bEqual = ( m_aDockedData.m_aPos.X() == aUIElement.m_aDockedData.m_aPos.X() ); - if ( bEqual ) - { - return m_bUserActive && !aUIElement.m_bUserActive; - } - else - return ( m_aDockedData.m_aPos.X() < aUIElement.m_aDockedData.m_aPos.X() ); - } - } - else - { - if ( !( m_aDockedData.m_aPos.X() == aUIElement.m_aDockedData.m_aPos.X() ) ) - return ( m_aDockedData.m_aPos.X() < aUIElement.m_aDockedData.m_aPos.X() ); - else - { - bool bEqual = ( m_aDockedData.m_aPos.Y() == aUIElement.m_aDockedData.m_aPos.Y() ); - if ( bEqual ) - { - return m_bUserActive && !aUIElement.m_bUserActive; - } - else - return ( m_aDockedData.m_aPos.Y() < aUIElement.m_aDockedData.m_aPos.Y() ); - } - } - } - } - } -} - -LayoutManager::UIElement& LayoutManager::UIElement::operator= ( const LayoutManager::UIElement& rUIElement ) -{ - if (this == &rUIElement) { return *this; } - m_aType = rUIElement.m_aType; - m_aName = rUIElement.m_aName; - m_aUIName = rUIElement.m_aUIName; - m_xUIElement = rUIElement.m_xUIElement; - m_bFloating = rUIElement.m_bFloating; - m_bVisible = rUIElement.m_bVisible; - m_bUserActive = rUIElement.m_bUserActive; - m_bCreateNewRowCol0 = rUIElement.m_bCreateNewRowCol0; - m_bDeactiveHide = rUIElement.m_bDeactiveHide; - m_bMasterHide = rUIElement.m_bMasterHide; - m_bContextSensitive = rUIElement.m_bContextSensitive; - m_bContextActive = rUIElement.m_bContextActive; - m_bNoClose = rUIElement.m_bNoClose; - m_bSoftClose = rUIElement.m_bSoftClose; - m_bStateRead = rUIElement.m_bStateRead; - m_nStyle = rUIElement.m_nStyle; - m_aDockedData = rUIElement.m_aDockedData; - m_aFloatingData = rUIElement.m_aFloatingData; - return *this; -} - -static Reference< XModel > impl_getModelFromFrame( const Reference< XFrame >& rFrame ) -{ - // Query for the model to get check the context information - Reference< XModel > xModel; - if ( rFrame.is() ) - { - Reference< XController > xController( rFrame->getController(), UNO_QUERY ); - if ( xController.is() ) - xModel = xController->getModel(); - } - - return xModel; -} - -static sal_Bool implts_isPreviewModel( const Reference< XModel >& xModel ) -{ - if ( xModel.is() ) - { - ::comphelper::MediaDescriptor aDesc( xModel->getArgs() ); - return aDesc.getUnpackedValueOrDefault(::comphelper::MediaDescriptor::PROP_PREVIEW(), (sal_Bool)sal_False); - } - else - return sal_False; -} - -static sal_Bool implts_isFrameOrWindowTop( const css::uno::Reference< css::frame::XFrame >& xFrame ) -{ - if (xFrame->isTop()) - return sal_True; - - css::uno::Reference< css::awt::XTopWindow > xWindowCheck(xFrame->getContainerWindow(), css::uno::UNO_QUERY); // dont use _THROW here ... its a check only - if (xWindowCheck.is()) - { - // --> PB 2007-06-18 #i76867# top and system window is required. - ::vos::OGuard aSolarLock(&Application::GetSolarMutex()); - css::uno::Reference< css::awt::XWindow > xWindow( xWindowCheck, UNO_QUERY ); - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - return ( pWindow && pWindow->IsSystemWindow() ); - // <-- - } - - return sal_False; -} - -static void impl_setDockingWindowVisibility( const css::uno::Reference< css::lang::XMultiServiceFactory>& rSMGR, const css::uno::Reference< css::frame::XFrame >& rFrame, const ::rtl::OUString& rDockingWindowName, bool bVisible ) -{ - const ::rtl::OUString aDockWinPrefixCommand( RTL_CONSTASCII_USTRINGPARAM( "DockingWindow" )); - css::uno::WeakReference< css::frame::XDispatchHelper > xDispatchHelper; - - sal_Int32 nID = rDockingWindowName.toInt32(); - sal_Int32 nIndex = nID - DOCKWIN_ID_BASE; - - css::uno::Reference< css::frame::XDispatchProvider > xProvider(rFrame, css::uno::UNO_QUERY); - if ( nIndex >= 0 && xProvider.is() ) - { - ::rtl::OUString aDockWinCommand( RTL_CONSTASCII_USTRINGPARAM( ".uno:" )); - ::rtl::OUString aDockWinArgName( aDockWinPrefixCommand ); - - aDockWinArgName += ::rtl::OUString::valueOf( nIndex ); - - css::uno::Sequence< css::beans::PropertyValue > aArgs(1); - aArgs[0].Name = aDockWinArgName; - aArgs[0].Value = css::uno::makeAny( bVisible ); - - css::uno::Reference< css::frame::XDispatchHelper > xDispatcher( xDispatchHelper ); - if ( !xDispatcher.is()) - { - xDispatcher = css::uno::Reference< css::frame::XDispatchHelper >( - rSMGR->createInstance(SERVICENAME_DISPATCHHELPER), css::uno::UNO_QUERY_THROW); - } - - aDockWinCommand = aDockWinCommand + aDockWinArgName; - xDispatcher->executeDispatch( - xProvider, - aDockWinCommand, - ::rtl::OUString::createFromAscii("_self"), - 0, - aArgs); - } -} - -//***************************************************************************************************************** -// XInterface, XTypeProvider, XServiceInfo -//***************************************************************************************************************** IMPLEMENT_FORWARD_XTYPEPROVIDER2( LayoutManager, LayoutManager_Base, LayoutManager_PBase ) IMPLEMENT_FORWARD_XINTERFACE2( LayoutManager, LayoutManager_Base, LayoutManager_PBase ) - -DEFINE_XSERVICEINFO_MULTISERVICE ( LayoutManager , - ::cppu::OWeakObject , - SERVICENAME_LAYOUTMANAGER , - IMPLEMENTATIONNAME_LAYOUTMANAGER - ) - -DEFINE_INIT_SERVICE ( LayoutManager, {} ) - - -LayoutManager::LayoutManager( const Reference< XMultiServiceFactory >& xServiceManager ) - : LayoutManager_Base ( ) - , ThreadHelpBase ( &Application::GetSolarMutex() ) - , ::cppu::OBroadcastHelperVar< ::cppu::OMultiTypeInterfaceContainerHelper, ::cppu::OMultiTypeInterfaceContainerHelper::keyType >( m_aLock.getShareableOslMutex() ) - , LayoutManager_PBase ( *(static_cast< ::cppu::OBroadcastHelper* >(this)) ) - , m_xSMGR( xServiceManager ) - , m_xURLTransformer( xServiceManager->createInstance( SERVICENAME_URLTRANSFORMER ), UNO_QUERY ) - , m_xDisplayAccess( xServiceManager->createInstance( SERVICENAME_DISPLAYACCESS ), UNO_QUERY ) - , m_nLockCount( 0 ) - , m_bActive( sal_False ) - , m_bInplaceMenuSet( sal_False ) - , m_bDockingInProgress( sal_False ) - , m_bMenuVisible( sal_True ) - , m_bComponentAttached( sal_False ) - , m_bDoLayout( sal_False ) - , m_bVisible( sal_True ) - , m_bParentWindowVisible( sal_False ) - , m_bMustDoLayout( sal_True ) - , m_bAutomaticToolbars( sal_True ) - , m_bStoreWindowState( sal_False ) - , m_bHideCurrentUI( false ) - , m_bGlobalSettings( sal_False ) - , m_bPreserveContentSize( false ) - , m_eDockOperation( DOCKOP_ON_COLROW ) - , m_pInplaceMenuBar( NULL ) - , m_xModuleManager( Reference< XModuleManager >( - xServiceManager->createInstance( SERVICENAME_MODULEMANAGER ), UNO_QUERY )) - , m_xUIElementFactoryManager( Reference< ::com::sun::star::ui::XUIElementFactory >( +DEFINE_XSERVICEINFO_MULTISERVICE( LayoutManager, ::cppu::OWeakObject, SERVICENAME_LAYOUTMANAGER, IMPLEMENTATIONNAME_LAYOUTMANAGER) +DEFINE_INIT_SERVICE( LayoutManager, {} ) + +LayoutManager::LayoutManager( const Reference< XMultiServiceFactory >& xServiceManager ) : LayoutManager_Base() + , ThreadHelpBase( &Application::GetSolarMutex()) + , ::cppu::OBroadcastHelperVar< ::cppu::OMultiTypeInterfaceContainerHelper, ::cppu::OMultiTypeInterfaceContainerHelper::keyType >( m_aLock.getShareableOslMutex()) + , LayoutManager_PBase( *(static_cast< ::cppu::OBroadcastHelper* >(this)) ) + , m_xSMGR( xServiceManager ) + , m_xURLTransformer( xServiceManager->createInstance( SERVICENAME_URLTRANSFORMER ), UNO_QUERY ) + , m_xDisplayAccess( xServiceManager->createInstance( SERVICENAME_DISPLAYACCESS ), UNO_QUERY ) + , m_nLockCount( 0 ) + , m_bActive( false ) + , m_bInplaceMenuSet( false ) + , m_bDockingInProgress( false ) + , m_bMenuVisible( true ) + , m_bComponentAttached( false ) + , m_bDoLayout( false ) + , m_bVisible( true ) + , m_bParentWindowVisible( false ) + , m_bMustDoLayout( true ) + , m_bAutomaticToolbars( true ) + , m_bStoreWindowState( false ) + , m_bHideCurrentUI( false ) + , m_bGlobalSettings( false ) + , m_bPreserveContentSize( false ) + , m_bMenuBarCloser( false ) + , m_pInplaceMenuBar( NULL ) + , m_xModuleManager( Reference< XModuleManager >( xServiceManager->createInstance( SERVICENAME_MODULEMANAGER ), UNO_QUERY )) + , m_xUIElementFactoryManager( Reference< ui::XUIElementFactory >( xServiceManager->createInstance( SERVICENAME_UIELEMENTFACTORYMANAGER ), UNO_QUERY )) - , m_bMenuBarCloser( sal_False ) - , m_xPersistentWindowStateSupplier( Reference< XNameAccess >( + , m_xPersistentWindowStateSupplier( Reference< XNameAccess >( xServiceManager->createInstance( SERVICENAME_WINDOWSTATECONFIGURATION ), UNO_QUERY )) - , m_pGlobalSettings( 0 ) - , m_aCustomTbxPrefix( RTL_CONSTASCII_USTRINGPARAM( "custom_" )) - , m_aFullCustomTbxPrefix( RTL_CONSTASCII_USTRINGPARAM( "private:resource/toolbar/custom_" )) - , m_aFullAddonTbxPrefix( RTL_CONSTASCII_USTRINGPARAM( "private:resource/toolbar/addon_" )) - , m_aStatusBarAlias( RTL_CONSTASCII_USTRINGPARAM( "private:resource/statusbar/statusbar" )) - , m_aProgressBarAlias( RTL_CONSTASCII_USTRINGPARAM( "private:resource/progressbar/progressbar" )) - , m_aPropDocked( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_DOCKED )) - , m_aPropVisible( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_VISIBLE )) - , m_aPropDockingArea( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_DOCKINGAREA )) - , m_aPropDockPos( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_DOCKPOS )) - , m_aPropPos( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_POS )) - , m_aPropSize( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_SIZE )) - , m_aPropUIName( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_UINAME )) - , m_aPropStyle( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_STYLE )) - , m_aPropLocked( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_LOCKED )) - , m_aCustomizeCmd( RTL_CONSTASCII_USTRINGPARAM( "ConfigureDialog" )) - , m_pAddonOptions( 0 ) - , m_aListenerContainer( m_aLock.getShareableOslMutex() ) + , m_pGlobalSettings( 0 ) + , m_aStatusBarAlias( RTL_CONSTASCII_USTRINGPARAM( "private:resource/statusbar/statusbar" )) + , m_aProgressBarAlias( RTL_CONSTASCII_USTRINGPARAM( "private:resource/progressbar/progressbar" )) + , m_aPropDocked( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_DOCKED )) + , m_aPropVisible( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_VISIBLE )) + , m_aPropDockingArea( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_DOCKINGAREA )) + , m_aPropDockPos( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_DOCKPOS )) + , m_aPropPos( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_POS )) + , m_aPropSize( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_SIZE )) + , m_aPropUIName( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_UINAME )) + , m_aPropStyle( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_STYLE )) + , m_aPropLocked( RTL_CONSTASCII_USTRINGPARAM( WINDOWSTATE_PROPERTY_LOCKED )) + , m_aCustomizeCmd( RTL_CONSTASCII_USTRINGPARAM( "ConfigureDialog" )) + , m_aListenerContainer( m_aLock.getShareableOslMutex() ) + , m_pPanelManager( 0 ) + , m_pToolbarManager( 0 ) { // Initialize statusbar member + const sal_Bool bRefreshVisibility = sal_False; m_aStatusBarElement.m_aType = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "statusbar" )); m_aStatusBarElement.m_aName = m_aStatusBarAlias; - m_pMiscOptions = new SvtMiscOptions(); + m_pToolbarManager = new ToolbarLayoutManager( xServiceManager, m_xUIElementFactoryManager, this ); + m_xToolbarManager = uno::Reference< ui::XUIConfigurationListener >( static_cast< OWeakObject* >( m_pToolbarManager ), uno::UNO_QUERY ); - m_pMiscOptions->AddListenerLink( LINK( this, LayoutManager, OptionsChanged ) ); Application::AddEventListener( LINK( this, LayoutManager, SettingsChanged ) ); - m_eSymbolsSize = m_pMiscOptions->GetSymbolsSize(); - m_eSymbolsStyle = m_pMiscOptions->GetCurrentSymbolsStyle(); m_aAsyncLayoutTimer.SetTimeout( 50 ); m_aAsyncLayoutTimer.SetTimeoutHdl( LINK( this, LayoutManager, AsyncLayoutHdl ) ); - registerProperty( LAYOUTMANAGER_PROPNAME_AUTOMATICTOOLBARS, LAYOUTMANAGER_PROPHANDLE_AUTOMATICTOOLBARS, css::beans::PropertyAttribute::TRANSIENT, &m_bAutomaticToolbars, ::getCppuType( &m_bAutomaticToolbars ) ); - registerProperty( LAYOUTMANAGER_PROPNAME_HIDECURRENTUI, LAYOUTMANAGER_PROPHANDLE_HIDECURRENTUI, css::beans::PropertyAttribute::TRANSIENT, &m_bHideCurrentUI, ::getCppuType( &m_bHideCurrentUI ) ); - registerProperty( LAYOUTMANAGER_PROPNAME_LOCKCOUNT, LAYOUTMANAGER_PROPHANDLE_LOCKCOUNT, css::beans::PropertyAttribute::TRANSIENT | css::beans::PropertyAttribute::READONLY, &m_nLockCount, getCppuType( &m_nLockCount ) ); - registerProperty( LAYOUTMANAGER_PROPNAME_MENUBARCLOSER, LAYOUTMANAGER_PROPHANDLE_MENUBARCLOSER, css::beans::PropertyAttribute::TRANSIENT, &m_bMenuBarCloser, ::getCppuType( &m_bMenuBarCloser ) ); - const sal_Bool bRefreshVisibility = sal_False; - registerPropertyNoMember( LAYOUTMANAGER_PROPNAME_REFRESHVISIBILITY, LAYOUTMANAGER_PROPHANDLE_REFRESHVISIBILITY, css::beans::PropertyAttribute::TRANSIENT, ::getCppuType( &bRefreshVisibility ), &bRefreshVisibility ); - registerProperty( LAYOUTMANAGER_PROPNAME_PRESERVE_CONTENT_SIZE, LAYOUTMANAGER_PROPHANDLE_PRESERVE_CONTENT_SIZE, css::beans::PropertyAttribute::TRANSIENT, &m_bPreserveContentSize, ::getCppuType( &m_bPreserveContentSize ) ); + registerProperty( LAYOUTMANAGER_PROPNAME_HIDECURRENTUI, LAYOUTMANAGER_PROPHANDLE_HIDECURRENTUI, beans::PropertyAttribute::TRANSIENT, &m_bHideCurrentUI, ::getCppuType( &m_bHideCurrentUI ) ); + registerProperty( LAYOUTMANAGER_PROPNAME_LOCKCOUNT, LAYOUTMANAGER_PROPHANDLE_LOCKCOUNT, beans::PropertyAttribute::TRANSIENT | beans::PropertyAttribute::READONLY, &m_nLockCount, getCppuType( &m_nLockCount ) ); + registerProperty( LAYOUTMANAGER_PROPNAME_MENUBARCLOSER, LAYOUTMANAGER_PROPHANDLE_MENUBARCLOSER, beans::PropertyAttribute::TRANSIENT, &m_bMenuBarCloser, ::getCppuType( &m_bMenuBarCloser ) ); + registerPropertyNoMember( LAYOUTMANAGER_PROPNAME_REFRESHVISIBILITY, LAYOUTMANAGER_PROPHANDLE_REFRESHVISIBILITY, beans::PropertyAttribute::TRANSIENT, ::getCppuType( &bRefreshVisibility ), &bRefreshVisibility ); + registerProperty( LAYOUTMANAGER_PROPNAME_PRESERVE_CONTENT_SIZE, LAYOUTMANAGER_PROPHANDLE_PRESERVE_CONTENT_SIZE, beans::PropertyAttribute::TRANSIENT, &m_bPreserveContentSize, ::getCppuType( &m_bPreserveContentSize ) ); } LayoutManager::~LayoutManager() { Application::RemoveEventListener( LINK( this, LayoutManager, SettingsChanged ) ); - if ( m_pMiscOptions ) - { - m_pMiscOptions->RemoveListenerLink( LINK( this, LayoutManager, OptionsChanged ) ); - delete m_pMiscOptions; - m_pMiscOptions = 0; - } m_aAsyncLayoutTimer.Stop(); } @@ -455,20 +196,17 @@ void LayoutManager::impl_clearUpMenuBar() // Clear up VCL menu bar to prepare shutdown if ( m_xContainerWindow.is() ) { - vos::OGuard aGuard( Application::GetSolarMutex() ); - - Window* pWindow = VCLUnoHelper::GetWindow( m_xContainerWindow ); - while ( pWindow && !pWindow->IsSystemWindow() ) - pWindow = pWindow->GetParent(); + vos::OGuard aGuard( Application::GetSolarMutex() ); - if ( pWindow ) + SystemWindow* pSysWindow = getTopSystemWindow( m_xContainerWindow ); + if ( pSysWindow ) { MenuBar* pSetMenuBar = 0; if ( m_xInplaceMenuBar.is() ) pSetMenuBar = (MenuBar *)m_pInplaceMenuBar->GetMenuBar(); else { - Reference< css::awt::XMenuBar > xMenuBar; + Reference< awt::XMenuBar > xMenuBar; Reference< XPropertySet > xPropSet( m_xMenuBar, UNO_QUERY ); if ( xPropSet.is() ) @@ -477,12 +215,8 @@ void LayoutManager::impl_clearUpMenuBar() { xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "XMenuBar" ))) >>= xMenuBar; } - catch ( com::sun::star::beans::UnknownPropertyException ) - { - } - catch ( com::sun::star::lang::WrappedTargetException ) - { - } + catch ( beans::UnknownPropertyException ) {} + catch ( lang::WrappedTargetException ) {} } VCLXMenu* pAwtMenuBar = VCLXMenu::GetImplementation( xMenuBar ); @@ -490,9 +224,9 @@ void LayoutManager::impl_clearUpMenuBar() pSetMenuBar = (MenuBar*)pAwtMenuBar->GetMenu(); } - MenuBar* pTopMenuBar = ((SystemWindow *)pWindow)->GetMenuBar(); + MenuBar* pTopMenuBar = pSysWindow->GetMenuBar(); if ( pSetMenuBar == pTopMenuBar ) - ((SystemWindow *)pWindow)->SetMenuBar( 0 ); + pSysWindow->SetMenuBar( 0 ); } } @@ -511,45 +245,17 @@ void LayoutManager::impl_clearUpMenuBar() implts_unlock(); } -sal_Bool LayoutManager::impl_parseResourceURL( const rtl::OUString aResourceURL, rtl::OUString& aElementType, rtl::OUString& aElementName ) -{ - URL aURL; - sal_Int32 nIndex = 0; - - aURL.Complete = aResourceURL; - m_xURLTransformer->parseStrict( aURL ); - - ::rtl::OUString aUIResource = aURL.Path.getToken( 0, (sal_Unicode)'/', nIndex ); - - if (( aURL.Protocol.equalsIgnoreAsciiCaseAscii( UIRESOURCE_PROTOCO_ASCII )) && - ( aUIResource.equalsIgnoreAsciiCaseAscii( UIRESOURCE_RESOURCE_ASCII ))) - { - aElementType = aURL.Path.getToken( 0, (sal_Unicode)'/', nIndex ); - aElementName = aURL.Path.getToken( 0, (sal_Unicode)'/', nIndex ); - return sal_True; - } - - return sal_False; -} - void LayoutManager::implts_lock() { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); ++m_nLockCount; - aWriteLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ } sal_Bool LayoutManager::implts_unlock() { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); - --m_nLockCount; - if ( m_nLockCount < 0 ) - m_nLockCount = 0; + m_nLockCount = std::max( --m_nLockCount, static_cast<sal_Int32>(0) ); return ( m_nLockCount == 0 ); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ } void LayoutManager::implts_reset( sal_Bool bAttached ) @@ -557,18 +263,16 @@ void LayoutManager::implts_reset( sal_Bool bAttached ) /* SAFE AREA ----------------------------------------------------------------------------------------------- */ ReadGuard aReadLock( m_aLock ); Reference< XFrame > xFrame = m_xFrame; - Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow ); - Reference< css::awt::XWindow > xTopDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP]; - Reference< css::awt::XWindow > xLeftDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT]; - Reference< css::awt::XWindow > xRightDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_RIGHT]; - Reference< css::awt::XWindow > xBottomDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM]; + Reference< awt::XWindow > xContainerWindow( m_xContainerWindow ); Reference< XUIConfiguration > xModuleCfgMgr( m_xModuleCfgMgr, UNO_QUERY ); Reference< XUIConfiguration > xDocCfgMgr( m_xDocCfgMgr, UNO_QUERY ); Reference< XNameAccess > xPersistentWindowState( m_xPersistentWindowState ); Reference< XMultiServiceFactory > xServiceManager( m_xSMGR ); Reference< XNameAccess > xPersistentWindowStateSupplier( m_xPersistentWindowStateSupplier ); + Reference< awt::XWindowListener > xToolbarManager( m_xToolbarManager, uno::UNO_QUERY ); + ToolbarLayoutManager* pToolbarManager( m_pToolbarManager ); ::rtl::OUString aModuleIdentifier( m_aModuleIdentifier ); - sal_Bool bAutomaticToolbars( m_bAutomaticToolbars ); + bool bAutomaticToolbars( m_bAutomaticToolbars ); aReadLock.unlock(); /* SAFE AREA ----------------------------------------------------------------------------------------------- */ @@ -584,9 +288,7 @@ void LayoutManager::implts_reset( sal_Bool bAttached ) { aModuleIdentifier = m_xModuleManager->identify( Reference< XInterface >( xFrame, UNO_QUERY ) ); } - catch( Exception& ) - { - } + catch( Exception& ) {} if ( aModuleIdentifier.getLength() && aOldModuleIdentifier != aModuleIdentifier ) { @@ -602,9 +304,7 @@ void LayoutManager::implts_reset( sal_Bool bAttached ) // Remove listener to old module ui configuration manager xModuleCfgMgr->removeConfigurationListener( Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY )); } - catch ( Exception& ) - { - } + catch ( Exception& ) {} } try @@ -614,9 +314,7 @@ void LayoutManager::implts_reset( sal_Bool bAttached ) if ( xModuleCfgMgr.is() ) xModuleCfgMgr->addConfigurationListener( Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY )); } - catch ( Exception& ) - { - } + catch ( Exception& ) {} try { @@ -624,12 +322,8 @@ void LayoutManager::implts_reset( sal_Bool bAttached ) if ( xPersistentWindowStateSupplier.is() ) xPersistentWindowStateSupplier->getByName( aModuleIdentifier ) >>= xPersistentWindowState; } - catch ( NoSuchElementException& ) - { - } - catch ( WrappedTargetException& ) - { - } + catch ( NoSuchElementException& ) {} + catch ( WrappedTargetException& ) {} } xModel = impl_getModelFromFrame( xFrame ); @@ -645,9 +339,7 @@ void LayoutManager::implts_reset( sal_Bool bAttached ) // Remove listener to old ui configuration manager xDocCfgMgr->removeConfigurationListener( Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY )); } - catch ( Exception& ) - { - } + catch ( Exception& ) {} } try @@ -656,9 +348,7 @@ void LayoutManager::implts_reset( sal_Bool bAttached ) if ( xDocCfgMgr.is() ) xDocCfgMgr->addConfigurationListener( Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY )); } - catch ( Exception& ) - { - } + catch ( Exception& ) {} } } } @@ -672,9 +362,7 @@ void LayoutManager::implts_reset( sal_Bool bAttached ) xModuleCfgMgr->removeConfigurationListener( Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY )); } - catch ( Exception& ) - { - } + catch ( Exception& ) {} } if ( xDocCfgMgr.is() ) @@ -684,9 +372,7 @@ void LayoutManager::implts_reset( sal_Bool bAttached ) xDocCfgMgr->removeConfigurationListener( Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY )); } - catch ( Exception& ) - { - } + catch ( Exception& ) {} } // Release references to our configuration managers as we currently don't have @@ -697,47 +383,39 @@ void LayoutManager::implts_reset( sal_Bool bAttached ) aModuleIdentifier = ::rtl::OUString(); } + Reference< XUIConfigurationManager > xModCfgMgr( xModuleCfgMgr, UNO_QUERY ); + Reference< XUIConfigurationManager > xDokCfgMgr( xDocCfgMgr, UNO_QUERY ); + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); m_xModel = xModel; - m_aDockingArea = css::awt::Rectangle(); + m_aDockingArea = awt::Rectangle(); m_bComponentAttached = bAttached; m_aModuleIdentifier = aModuleIdentifier; - m_xModuleCfgMgr = Reference< XUIConfigurationManager >( xModuleCfgMgr, UNO_QUERY ); - m_xDocCfgMgr = Reference< XUIConfigurationManager >( xDocCfgMgr, UNO_QUERY ); + m_xModuleCfgMgr = xModCfgMgr; + m_xDocCfgMgr = xDokCfgMgr; m_xPersistentWindowState = xPersistentWindowState; m_aStatusBarElement.m_bStateRead = sal_False; // reset state to read data again! aWriteLock.unlock(); /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - if ( bAttached ) + // reset/notify toolbar layout manager + if ( pToolbarManager ) { - // reset docking area windows back to zero size - try - { - if ( xTopDockingWindow.is() ) - xTopDockingWindow->setPosSize( 0, 0, 0, 0, css::awt::PosSize::POSSIZE ); - if ( xLeftDockingWindow.is() ) - xLeftDockingWindow->setPosSize( 0, 0, 0, 0, css::awt::PosSize::POSSIZE ); - if ( xRightDockingWindow.is() ) - xRightDockingWindow->setPosSize( 0, 0, 0, 0, css::awt::PosSize::POSSIZE ); - if ( xBottomDockingWindow.is() ) - xBottomDockingWindow->setPosSize( 0, 0, 0, 0, css::awt::PosSize::POSSIZE ); - } - catch ( Exception& ) + if ( bAttached ) { + pToolbarManager->attach( xFrame, xModCfgMgr, xDokCfgMgr, xPersistentWindowState ); + uno::Reference< awt::XWindowPeer > xParent( xContainerWindow, UNO_QUERY ); + pToolbarManager->setParentWindow( xParent ); + if ( bAutomaticToolbars ) + pToolbarManager->createStaticToolbars(); } - - if ( bAutomaticToolbars ) + else { - implts_createCustomToolBars(); - implts_createAddonsToolBars(); - implts_createNonContextSensitiveToolBars(); + pToolbarManager->reset(); + implts_destroyElements(); } - implts_sortUIElements(); } - else - implts_destroyElements(); } implts_unlock(); @@ -745,15 +423,12 @@ void LayoutManager::implts_reset( sal_Bool bAttached ) sal_Bool LayoutManager::implts_isEmbeddedLayoutManager() const { - // check if this layout manager is currently using the embedded feature - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ ReadGuard aReadLock( m_aLock ); Reference< XFrame > xFrame = m_xFrame; - Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow ); + Reference< awt::XWindow > xContainerWindow( m_xContainerWindow ); aReadLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - Reference< css::awt::XWindow > xFrameContainerWindow = xFrame->getContainerWindow(); + Reference< awt::XWindow > xFrameContainerWindow = xFrame->getContainerWindow(); if ( xFrameContainerWindow == xContainerWindow ) return sal_False; else @@ -762,20 +437,13 @@ sal_Bool LayoutManager::implts_isEmbeddedLayoutManager() const void LayoutManager::implts_destroyElements() { - UIElementVector aUIElementVector; - WriteGuard aWriteLock( m_aLock ); - aUIElementVector = m_aUIElements; - m_aUIElements.clear(); + uno::Reference< ui::XUIConfigurationListener > xThis( m_xToolbarManager ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; aWriteLock.unlock(); - UIElementVector::iterator pIter; - for ( pIter = aUIElementVector.begin(); pIter != aUIElementVector.end(); pIter++ ) - { - Reference< XComponent > xComponent( pIter->m_xUIElement, UNO_QUERY ); - if ( xComponent.is() ) - xComponent->dispose(); - } + if ( pToolbarManager ) + pToolbarManager->destroyToolbars(); implts_destroyStatusBar(); @@ -784,592 +452,49 @@ void LayoutManager::implts_destroyElements() aWriteLock.unlock(); } -void LayoutManager::implts_destroyDockingAreaWindows() -{ - std::vector< Reference< css::awt::XWindow > > oldDockingAreaWindows; - - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - WriteGuard aWriteLock( m_aLock ); - oldDockingAreaWindows.push_back( m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP] ); - oldDockingAreaWindows.push_back( m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM] ); - oldDockingAreaWindows.push_back( m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT] ); - oldDockingAreaWindows.push_back( m_xDockAreaWindows[DockingArea_DOCKINGAREA_RIGHT] ); - - m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP].clear(); - m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM].clear(); - m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT].clear(); - m_xDockAreaWindows[DockingArea_DOCKINGAREA_RIGHT].clear(); - aWriteLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - - const sal_uInt32 nCount = oldDockingAreaWindows.size(); - for ( sal_uInt32 i=0; i < nCount; i++ ) - { - if ( oldDockingAreaWindows[i].is() ) - { - try - { - oldDockingAreaWindows[i]->dispose(); - } - catch ( Exception& ) - { - } - } - } -} - -void LayoutManager::implts_createCustomToolBar( const rtl::OUString& aTbxResName, const rtl::OUString& aTitle ) -{ - if ( aTbxResName.getLength() > 0 ) - { - createElement( aTbxResName ); - if ( aTitle ) - { - Reference< XUIElement > xUIElement = getElement( aTbxResName ); - if ( xUIElement.is() ) - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - - Reference< css::awt::XWindow > xWindow( xUIElement->getRealInterface(), UNO_QUERY ); - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - if ( pWindow ) - pWindow->SetText( aTitle ); - } - } - } -} - -void LayoutManager::implts_createCustomToolBars( - const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue > >& aTbxSeqSeq ) -{ - const Sequence< PropertyValue >* pTbxSeq = aTbxSeqSeq.getConstArray(); - for ( sal_Int32 i = 0; i < aTbxSeqSeq.getLength(); i++ ) - { - const Sequence< PropertyValue >& rTbxSeq = pTbxSeq[i]; - ::rtl::OUString aTbxResName; - ::rtl::OUString aTbxTitle; - for ( sal_Int32 j = 0; j < rTbxSeq.getLength(); j++ ) - { - if ( rTbxSeq[j].Name.equalsAscii( "ResourceURL" )) - rTbxSeq[j].Value >>= aTbxResName; - else if ( rTbxSeq[j].Name.equalsAscii( "UIName" )) - rTbxSeq[j].Value >>= aTbxTitle; - } - - // Only create custom toolbars. Their name have to start with "custom_"! - if ( aTbxResName.getLength() > 0 && aTbxResName.indexOf( m_aCustomTbxPrefix ) != -1 ) - implts_createCustomToolBar( aTbxResName, aTbxTitle ); - } -} - -void LayoutManager::implts_createCustomToolBars() -{ - ReadGuard aReadLock( m_aLock ); - if ( !m_bComponentAttached ) - return; - - Reference< XUIElementFactory > xUIElementFactory( m_xUIElementFactoryManager ); - Reference< XFrame > xFrame( m_xFrame ); - Reference< XModel > xModel; - Reference< XUIConfigurationManager > xModuleCfgMgr( m_xModuleCfgMgr, UNO_QUERY ); - Reference< XUIConfigurationManager > xDocCfgMgr( m_xDocCfgMgr, UNO_QUERY ); - aReadLock.unlock(); - - if ( xFrame.is() ) - { - xModel = impl_getModelFromFrame( xFrame ); - if ( implts_isPreviewModel( xModel )) - return; // no custom toolbars for preview frame! - - Sequence< Sequence< PropertyValue > > aTbxSeq; - if ( xDocCfgMgr.is() ) - { - aTbxSeq = xDocCfgMgr->getUIElementsInfo( UIElementType::TOOLBAR ); - implts_createCustomToolBars( aTbxSeq ); // first create all document based toolbars - } - if ( xModuleCfgMgr.is() ) - { - aTbxSeq = xModuleCfgMgr->getUIElementsInfo( UIElementType::TOOLBAR ); - implts_createCustomToolBars( aTbxSeq ); // second create module based toolbars - } - } -} - -rtl::OUString LayoutManager::implts_generateGenericAddonToolbarTitle( sal_Int32 nNumber ) const -{ - String aAddonGenericTitle; - - aAddonGenericTitle = String( FwkResId( STR_TOOLBAR_TITLE_ADDON )); - const vcl::I18nHelper& rI18nHelper = Application::GetSettings().GetUILocaleI18nHelper(); - - String aNumStr = rI18nHelper.GetNum( nNumber, 0, FALSE, FALSE ); - aAddonGenericTitle.SearchAndReplaceAscii( "%num%", aNumStr ); - - return rtl::OUString( aAddonGenericTitle ); -} - -void LayoutManager::implts_createAddonsToolBars() -{ - WriteGuard aWriteLock( m_aLock ); - if ( !m_bComponentAttached ) - return; - - Reference< XModel > xModel; - Reference< XFrame > xFrame( m_xFrame ); - if ( !xFrame.is() ) - return; - - if ( !m_pAddonOptions ) - m_pAddonOptions = new AddonsOptions; - - Reference< XUIElementFactory > xUIElementFactory( m_xUIElementFactoryManager ); - aWriteLock.unlock(); - - xModel = impl_getModelFromFrame( xFrame ); - if ( implts_isPreviewModel( xModel )) - return; // no addon toolbars for preview frame! - - UIElementVector aUIElementVector; - Sequence< Sequence< PropertyValue > > aAddonToolBarData; - Reference< XUIElement > xUIElement; - - sal_uInt32 nCount = m_pAddonOptions->GetAddonsToolBarCount(); - ::rtl::OUString aAddonsToolBarStaticName( m_aFullAddonTbxPrefix ); - ::rtl::OUString aElementType( RTL_CONSTASCII_USTRINGPARAM( "toolbar" )); - - Sequence< PropertyValue > aPropSeq( 2 ); - aPropSeq[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Frame" )); - aPropSeq[0].Value <<= xFrame; - aPropSeq[1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ConfigurationData" )); - for ( sal_uInt32 i = 0; i < nCount; i++ ) - { - ::rtl::OUString aAddonToolBarName( aAddonsToolBarStaticName + m_pAddonOptions->GetAddonsToolbarResourceName(i) ); - aAddonToolBarData = m_pAddonOptions->GetAddonsToolBarPart( i ); - aPropSeq[1].Value <<= aAddonToolBarData; - - aWriteLock.lock(); - UIElement aElement = impl_findElement( aAddonToolBarName ); - aWriteLock.unlock(); - - // #i79828 - // It's now possible that we are called more than once. Be sure to not create - // add-on toolbars more than once! - if ( aElement.m_xUIElement.is() ) - continue; - - try - { - xUIElement = xUIElementFactory->createUIElement( aAddonToolBarName, aPropSeq ); - if ( xUIElement.is() ) - { - Reference< css::awt::XDockableWindow > xDockWindow( xUIElement->getRealInterface(), UNO_QUERY ); - if ( xDockWindow.is() ) - { - try - { - xDockWindow->addDockableWindowListener( Reference< css::awt::XDockableWindowListener >( static_cast< OWeakObject * >( this ), UNO_QUERY )); - xDockWindow->enableDocking( sal_True ); - Reference< css::awt::XWindow > xWindow( xDockWindow, UNO_QUERY ); - if ( xWindow.is() ) - xWindow->addWindowListener( Reference< css::awt::XWindowListener >( static_cast< OWeakObject * >( this ), UNO_QUERY )); - } - catch ( Exception& ) - { - } - } - - ::rtl::OUString aGenericAddonTitle = implts_generateGenericAddonToolbarTitle( i+1 ); - - if ( aElement.m_aName.getLength() > 0 ) - { - // Reuse a local entry so we are able to use the latest - // UI changes for this document. - implts_setElementData( aElement, xDockWindow ); - aElement.m_xUIElement = xUIElement; - if ( aElement.m_aUIName.getLength() == 0 ) - { - aElement.m_aUIName = aGenericAddonTitle; - implts_writeWindowStateData( aElement.m_aName, aElement ); - } - } - else - { - // Create new UI element and try to read its state data - UIElement aNewToolbar( aAddonToolBarName, aElementType, xUIElement ); - aNewToolbar.m_bFloating = sal_True; - implts_readWindowStateData( aAddonToolBarName, aNewToolbar ); - implts_setElementData( aNewToolbar, xDockWindow ); - if ( aNewToolbar.m_aUIName.getLength() == 0 ) - { - aNewToolbar.m_aUIName = aGenericAddonTitle; - implts_writeWindowStateData( aNewToolbar.m_aName, aNewToolbar ); - } - implts_insertUIElement( aNewToolbar ); - } - - Reference< css::awt::XWindow > xWindow( xDockWindow, UNO_QUERY ); - if ( xWindow.is() ) - { - // Set generic title for add-on toolbar - vos::OGuard aGuard( Application::GetSolarMutex() ); - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - if ( pWindow->GetText().Len() == 0 ) - pWindow->SetText( aGenericAddonTitle ); - if ( pWindow->GetType() == WINDOW_TOOLBOX ) - { - ToolBox* pToolbar = (ToolBox *)pWindow; - pToolbar->SetMenuType(); - } - } - } - } - catch ( NoSuchElementException& ) - { - } - catch ( IllegalArgumentException& ) - { - } - } -} - -void LayoutManager::implts_createNonContextSensitiveToolBars() -{ - ReadGuard aReadLock( m_aLock ); - - if ( !m_xPersistentWindowState.is() || - !m_xFrame.is() || - !m_bComponentAttached ) - return; - - Reference< XFrame > xFrame( m_xFrame ); - - Reference< XUIElementFactory > xUIElementFactory( m_xUIElementFactoryManager ); - Reference< XNameAccess > xPersistentWindowState( m_xPersistentWindowState ); - aReadLock.unlock(); - - if ( implts_isPreviewModel( impl_getModelFromFrame( xFrame ))) - return; - - std::vector< rtl::OUString > aMakeVisibleToolbars; - - try - { - Sequence< rtl::OUString > aToolbarNames = xPersistentWindowState->getElementNames(); - - if ( aToolbarNames.getLength() > 0 ) - { - rtl::OUString aElementType; - rtl::OUString aElementName; - rtl::OUString aName; - - Reference< ::com::sun::star::ui::XUIElement > xUIElement; - aMakeVisibleToolbars.reserve(aToolbarNames.getLength()); - WriteGuard aWriteLock( m_aLock ); - - const rtl::OUString* pTbNames = aToolbarNames.getConstArray(); - for ( sal_Int32 i = 0; i < aToolbarNames.getLength(); i++ ) - { - aName = pTbNames[i]; - if ( impl_parseResourceURL( aName, aElementType, aElementName )) - { - // Check that we only create: - // - Toolbars (the statusbar is also member of the persistent window state) - // - Not custom toolbars, there are created with their own method (implts_createCustomToolbars) - if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" ) && - aElementName.indexOf( m_aCustomTbxPrefix ) == -1 ) - { - UIElement aNewToolbar( aName, aElementType, xUIElement ); - bool bFound = implts_findElement( aName, aNewToolbar ); - if ( !bFound ) - implts_readWindowStateData( aName, aNewToolbar ); - - if ( aNewToolbar.m_bVisible && - !aNewToolbar.m_bContextSensitive ) - { - if ( !bFound ) - implts_insertUIElement( aNewToolbar ); - aMakeVisibleToolbars.push_back( aName ); - } - } - } - } - } - } - catch ( RuntimeException& e ) - { - throw e; - } - catch ( Exception& ) - { - } - - if ( !aMakeVisibleToolbars.empty() ) - { - implts_lock(); - ::std::for_each( aMakeVisibleToolbars.begin(), aMakeVisibleToolbars.end(),::boost::bind( &LayoutManager::requestElement, this,_1 )); - implts_unlock(); - } -} - void LayoutManager::implts_toggleFloatingUIElementsVisibility( sal_Bool bActive ) { - WriteGuard aWriteLock( m_aLock ); - UIElementVector::iterator pIter; - ReadGuard aReadLock( m_aLock ); - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - { - if ( pIter->m_xUIElement.is() ) - { - Reference< css::awt::XDockableWindow > xDockWindow( pIter->m_xUIElement->getRealInterface(), UNO_QUERY ); - Reference< css::awt::XWindow > xWindow( xDockWindow, UNO_QUERY ); - if ( xDockWindow.is() && xWindow.is() ) - { - sal_Bool bVisible( sal_True ); - vos::OGuard aGuard( Application::GetSolarMutex() ); - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - if ( pWindow ) - bVisible = pWindow->IsVisible(); - - if ( xDockWindow->isFloating() ) - { - if ( bActive ) - { - if ( !bVisible && pIter->m_bDeactiveHide ) - { - pIter->m_bDeactiveHide = sal_False; - // we need VCL here to pass special flags to Show() - if( pWindow ) - pWindow->Show( TRUE, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE ); - //xWindow->setVisible( sal_True ); - } - } - else - { - if ( bVisible ) - { - pIter->m_bDeactiveHide = sal_True; - xWindow->setVisible( sal_False ); - } - } - } - } - } - } -} - -sal_Bool LayoutManager::implts_findElement( const rtl::OUString& aName, rtl::OUString& aElementType, rtl::OUString& aElementName, Reference< XUIElement >& xUIElement ) -{ - if ( impl_parseResourceURL( aName, aElementType, aElementName )) - { - if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" ) && - aElementName.equalsIgnoreAsciiCaseAscii( "menubar" )) - { - ReadGuard aReadLock( m_aLock ); - xUIElement = m_xMenuBar; - return sal_True; - } - else if (( aElementType.equalsIgnoreAsciiCaseAscii( "statusbar" ) && - aElementName.equalsIgnoreAsciiCaseAscii( "statusbar" )) || - ( m_aStatusBarElement.m_aName == aName )) - { - ReadGuard aReadLock( m_aLock ); - xUIElement = m_aStatusBarElement.m_xUIElement; - return sal_True; - } - else if ( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) && - aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" )) - { - ReadGuard aReadLock( m_aLock ); - xUIElement = m_aProgressBarElement.m_xUIElement; - return sal_True; - } - else - { - UIElementVector::const_iterator pIter; - - ReadGuard aReadLock( m_aLock ); - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - { - if ( pIter->m_aName == aName ) - { - xUIElement = pIter->m_xUIElement; - return sal_True; - } - } - } - } - - return sal_False; -} - -sal_Bool LayoutManager::implts_findElement( const Reference< XInterface >& xUIElement, UIElement& aElementData ) -{ - UIElementVector::const_iterator pIter; - - ReadGuard aReadLock( m_aLock ); - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - { - if ( pIter->m_xUIElement.is() ) - { - Reference< XInterface > xIfac( pIter->m_xUIElement->getRealInterface(), UNO_QUERY ); - if ( xIfac == xUIElement ) - { - aElementData = *pIter; - return sal_True; - } - } - } + uno::Reference< ui::XUIConfigurationListener > xThis( m_xToolbarManager ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + aReadLock.unlock(); - return sal_False; + if ( pToolbarManager ) + pToolbarManager->setFloatingToolbarsVisibility( bActive ); } -sal_Bool LayoutManager::implts_findElement( const rtl::OUString& aName, UIElement& aElementData ) +uno::Reference< ui::XUIElement > LayoutManager::implts_findElement( const rtl::OUString& aName ) { - UIElementVector::const_iterator pIter; - - ReadGuard aReadLock( m_aLock ); - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - { - if ( pIter->m_aName == aName ) - { - aElementData = *pIter; - return sal_True; - } - } + ::rtl::OUString aElementType; + ::rtl::OUString aElementName; + + parseResourceURL( aName, aElementType, aElementName ); + if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "menubar" )) + return m_xMenuBar; + else if (( aElementType.equalsIgnoreAsciiCaseAscii( "statusbar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "statusbar" )) || ( m_aStatusBarElement.m_aName == aName )) + return m_aStatusBarElement.m_xUIElement; + else if ( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" )) + return m_aProgressBarElement.m_xUIElement; - return sal_False; + return uno::Reference< ui::XUIElement >(); } -LayoutManager::UIElement& LayoutManager::impl_findElement( const rtl::OUString& aName ) +UIElement& LayoutManager::impl_findElement( const rtl::OUString& aName ) { static UIElement aEmptyElement; - UIElementVector::iterator pIter; - - ReadGuard aReadLock( m_aLock ); - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - { - if ( pIter->m_aName == aName ) - return *pIter; - } + ::rtl::OUString aElementType; + ::rtl::OUString aElementName; + + parseResourceURL( aName, aElementType, aElementName ); + if (( aElementType.equalsIgnoreAsciiCaseAscii( "statusbar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "statusbar" )) || ( m_aStatusBarElement.m_aName == aName )) + return m_aStatusBarElement; + else if ( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" )) + return m_aProgressBarElement; return aEmptyElement; } -sal_Bool LayoutManager::implts_insertUIElement( const UIElement& rUIElement ) -{ - UIElement aTempData; - bool bFound = implts_findElement( rUIElement.m_aName, aTempData ); - -#ifdef DBG_UTIL - if ( bFound ) - { - char aBuffer[256]; - const sal_Int32 MAX_NAME_LENGTH = 128; - ::rtl::OString aName = ::rtl::OUStringToOString( rUIElement.m_aName, RTL_TEXTENCODING_ASCII_US ); - aName = aName.copy( ::std::min( MAX_NAME_LENGTH, aName.getLength() )); - sprintf( aBuffer, "Try to insert an already existing user interface element (%s) into the list\n", aName.getStr() ); - DBG_ASSERT( bFound, aBuffer ); - } -#endif - - bool bResult( false ); - if ( !bFound ) - { - WriteGuard aWriteLock( m_aLock ); - m_aUIElements.push_back( rUIElement ); - bResult = true; - } - return bResult; -} - -void LayoutManager::implts_writeNewStateData( const rtl::OUString aName, const Reference< css::awt::XWindow >& xWindow ) -{ - css::awt::Rectangle aPos; - css::awt::Size aSize; - sal_Bool bVisible( sal_False ); - sal_Bool bFloating( sal_True ); - - if ( xWindow.is() ) - { - Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY ); - if ( xDockWindow.is() ) - bFloating = xDockWindow->isFloating(); - - Reference< css::awt::XWindow2 > xWindow2( xWindow, UNO_QUERY ); - if( xWindow2.is() ) - { - aPos = xWindow2->getPosSize(); - aSize = xWindow2->getOutputSize(); // always use output size for consistency - bVisible = xWindow2->isVisible(); - } - } - - WriteGuard aWriteLock( m_aLock ); - UIElement& rUIElement = impl_findElement( aName ); - if ( rUIElement.m_xUIElement.is() && xWindow.is() ) - { - rUIElement.m_bVisible = bVisible; - rUIElement.m_bFloating = bFloating; - if ( bFloating ) - { - rUIElement.m_aFloatingData.m_aPos = ::Point( aPos.X, aPos.Y ); - rUIElement.m_aFloatingData.m_aSize = ::Size( aSize.Width, aSize.Height ); - } - } - - implts_writeWindowStateData( aName, rUIElement ); - - aWriteLock.unlock(); -} - -void LayoutManager::implts_refreshContextToolbarsVisibility() -{ - std::vector< UIElementVisibility > aToolbarVisibleVector; - - ReadGuard aReadLock( m_aLock ); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - if ( !m_bVisible || !m_bAutomaticToolbars ) - return; - - UIElementVisibility aUIElementVisible; - - UIElementVector::iterator pIter; - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - { - if ( pIter->m_aType.equalsAsciiL( "toolbar", 7 )) - { - aUIElementVisible.aName = pIter->m_aName; - aUIElementVisible.bVisible = pIter->m_bVisible; - aToolbarVisibleVector.push_back( aUIElementVisible ); - } - } - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - aReadLock.unlock(); - - UIElement aUIElement; - const sal_uInt32 nCount = aToolbarVisibleVector.size(); - for ( sal_uInt32 i = 0; i < nCount; i++ ) - { - UIElementVisibility& rToolbar = aToolbarVisibleVector[i]; - - sal_Bool bVisible = rToolbar.bVisible; - if ( implts_readWindowStateData( rToolbar.aName, aUIElement ) && - aUIElement.m_bVisible != bVisible ) - { - WriteGuard aWriteLock( m_aLock ); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - UIElement& rUIElement = impl_findElement( rToolbar.aName ); - - if ( rUIElement.m_aName == rToolbar.aName ) - rUIElement.m_bVisible = aUIElement.m_bVisible; - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - aWriteLock.unlock(); - } - } -} - sal_Bool LayoutManager::implts_readWindowStateData( const rtl::OUString& aName, UIElement& rElementData ) { sal_Bool bGetSettingsState( sal_False ); @@ -1411,13 +536,13 @@ sal_Bool LayoutManager::implts_readWindowStateData( const rtl::OUString& aName, } else if ( aWindowState[n].Name == m_aPropDockingArea ) { - ::com::sun::star::ui::DockingArea eDockingArea; + ui::DockingArea eDockingArea; if ( aWindowState[n].Value >>= eDockingArea ) rElementData.m_aDockedData.m_nDockedArea = sal_Int16( eDockingArea ); } else if ( aWindowState[n].Name == m_aPropDockPos ) { - css::awt::Point aPoint; + awt::Point aPoint; if ( aWindowState[n].Value >>= aPoint ) { rElementData.m_aDockedData.m_aPos.X() = aPoint.X; @@ -1426,7 +551,7 @@ sal_Bool LayoutManager::implts_readWindowStateData( const rtl::OUString& aName, } else if ( aWindowState[n].Name == m_aPropPos ) { - css::awt::Point aPoint; + awt::Point aPoint; if ( aWindowState[n].Value >>= aPoint ) { rElementData.m_aFloatingData.m_aPos.X() = aPoint.X; @@ -1435,7 +560,7 @@ sal_Bool LayoutManager::implts_readWindowStateData( const rtl::OUString& aName, } else if ( aWindowState[n].Name == m_aPropSize ) { - css::awt::Size aSize; + awt::Size aSize; if ( aWindowState[n].Value >>= aSize ) { rElementData.m_aFloatingData.m_aSize.Width() = aSize.Width; @@ -1487,7 +612,7 @@ sal_Bool LayoutManager::implts_readWindowStateData( const rtl::OUString& aName, m_bGlobalSettings = sal_True; aWriteLock2.unlock(); - css::uno::Any aValue; + uno::Any aValue; sal_Bool bValue = sal_Bool(); if ( pGlobalSettings->GetStateInfo( GlobalSettings::UIELEMENT_TYPE_TOOLBAR, GlobalSettings::STATEINFO_LOCKED, @@ -1505,9 +630,7 @@ sal_Bool LayoutManager::implts_readWindowStateData( const rtl::OUString& aName, return sal_True; } - catch ( NoSuchElementException& ) - { - } + catch ( NoSuchElementException& ) {} } return sal_False; @@ -1531,14 +654,12 @@ void LayoutManager::implts_writeWindowStateData( const rtl::OUString& aName, con // Check persistent flag of the user interface element xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Persistent" ))) >>= bPersistent; } - catch ( com::sun::star::beans::UnknownPropertyException ) + catch ( beans::UnknownPropertyException ) { // Non-configurable elements should at least store their dimension/position bPersistent = sal_True; } - catch ( com::sun::star::lang::WrappedTargetException ) - { - } + catch ( lang::WrappedTargetException ) {} } if ( bPersistent && xPersistentWindowState.is() ) @@ -1547,49 +668,47 @@ void LayoutManager::implts_writeWindowStateData( const rtl::OUString& aName, con { Sequence< PropertyValue > aWindowState( 8 ); - aWindowState[0].Name = m_aPropDocked; - aWindowState[0].Value = makeAny( sal_Bool( !rElementData.m_bFloating )); - aWindowState[1].Name = m_aPropVisible; - aWindowState[1].Value = makeAny( sal_Bool( rElementData.m_bVisible )); + aWindowState[0].Name = m_aPropDocked; + aWindowState[0].Value = makeAny( sal_Bool( !rElementData.m_bFloating )); + aWindowState[1].Name = m_aPropVisible; + aWindowState[1].Value = makeAny( sal_Bool( rElementData.m_bVisible )); - aWindowState[2].Name = m_aPropDockingArea; - aWindowState[2].Value = makeAny( static_cast< DockingArea >( rElementData.m_aDockedData.m_nDockedArea ) ); + aWindowState[2].Name = m_aPropDockingArea; + aWindowState[2].Value = makeAny( static_cast< DockingArea >( rElementData.m_aDockedData.m_nDockedArea ) ); - css::awt::Point aPos; + awt::Point aPos; aPos.X = rElementData.m_aDockedData.m_aPos.X(); aPos.Y = rElementData.m_aDockedData.m_aPos.Y(); - aWindowState[3].Name = m_aPropDockPos; - aWindowState[3].Value <<= aPos; + aWindowState[3].Name = m_aPropDockPos; + aWindowState[3].Value <<= aPos; aPos.X = rElementData.m_aFloatingData.m_aPos.X(); aPos.Y = rElementData.m_aFloatingData.m_aPos.Y(); - aWindowState[4].Name = m_aPropPos; - aWindowState[4].Value <<= aPos; + aWindowState[4].Name = m_aPropPos; + aWindowState[4].Value <<= aPos; - css::awt::Size aSize; + awt::Size aSize; aSize.Width = rElementData.m_aFloatingData.m_aSize.Width(); aSize.Height = rElementData.m_aFloatingData.m_aSize.Height(); - aWindowState[5].Name = m_aPropSize; - aWindowState[5].Value <<= aSize; - aWindowState[6].Name = m_aPropUIName; - aWindowState[6].Value = makeAny( rElementData.m_aUIName ); - aWindowState[7].Name = m_aPropLocked; - aWindowState[7].Value = makeAny( rElementData.m_aDockedData.m_bLocked ); + aWindowState[5].Name = m_aPropSize; + aWindowState[5].Value <<= aSize; + aWindowState[6].Name = m_aPropUIName; + aWindowState[6].Value = makeAny( rElementData.m_aUIName ); + aWindowState[7].Name = m_aPropLocked; + aWindowState[7].Value = makeAny( rElementData.m_aDockedData.m_bLocked ); if ( xPersistentWindowState->hasByName( aName )) { - Reference< XNameReplace > xReplace( xPersistentWindowState, UNO_QUERY ); + Reference< XNameReplace > xReplace( xPersistentWindowState, uno::UNO_QUERY ); xReplace->replaceByName( aName, makeAny( aWindowState )); } else { - Reference< XNameContainer > xInsert( xPersistentWindowState, UNO_QUERY ); + Reference< XNameContainer > xInsert( xPersistentWindowState, uno::UNO_QUERY ); xInsert->insertByName( aName, makeAny( aWindowState )); } } - catch ( Exception& ) - { - } + catch ( Exception& ) {} } // Reset flag @@ -1598,1450 +717,23 @@ void LayoutManager::implts_writeWindowStateData( const rtl::OUString& aName, con aWriteLock.unlock(); } -void LayoutManager::implts_setElementData( UIElement& rElement, const Reference< css::awt::XDockableWindow >& rDockWindow ) -{ - ReadGuard aReadLock( m_aLock ); - sal_Bool bShowElement( rElement.m_bVisible && !rElement.m_bMasterHide && m_bParentWindowVisible ); - aReadLock.unlock(); - - Reference< css::awt::XDockableWindow > xDockWindow( rDockWindow ); - Reference< css::awt::XWindow2 > xWindow( xDockWindow, UNO_QUERY ); - - Window* pWindow( 0 ); - ToolBox* pToolBox( 0 ); - - if ( xDockWindow.is() && xWindow.is() ) - { - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - pWindow = VCLUnoHelper::GetWindow( xWindow ); - if ( pWindow ) - { - String aText = pWindow->GetText(); - if ( aText.Len() == 0 ) - pWindow->SetText( rElement.m_aUIName ); - if ( rElement.m_bNoClose ) - pWindow->SetStyle( pWindow->GetStyle() & ~WB_CLOSEABLE ); - if ( pWindow->GetType() == WINDOW_TOOLBOX ) - pToolBox = (ToolBox *)pWindow; - } - if ( pToolBox ) - { - if (( rElement.m_nStyle < 0 ) || - ( rElement.m_nStyle > BUTTON_SYMBOLTEXT )) - rElement.m_nStyle = BUTTON_SYMBOL; - pToolBox->SetButtonType( (ButtonType)rElement.m_nStyle ); - if ( rElement.m_bNoClose ) - pToolBox->SetFloatStyle( pToolBox->GetFloatStyle() & ~WB_CLOSEABLE ); - } - } - - if ( rElement.m_bFloating ) - { - if ( pWindow ) - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - String aText = pWindow->GetText(); - if ( aText.Len() == 0 ) - pWindow->SetText( rElement.m_aUIName ); - } - - ::Point aPos( rElement.m_aFloatingData.m_aPos.X(), - rElement.m_aFloatingData.m_aPos.Y() ); - sal_Bool bWriteData( sal_False ); - sal_Bool bUndefPos = ( rElement.m_aFloatingData.m_aPos.X() == SAL_MAX_INT32 || - rElement.m_aFloatingData.m_aPos.Y() == SAL_MAX_INT32 ); - sal_Bool bSetSize = ( rElement.m_aFloatingData.m_aSize.Width() != 0 && - rElement.m_aFloatingData.m_aSize.Height() != 0 ); - xDockWindow->setFloatingMode( sal_True ); - if ( bUndefPos ) - { - aPos = implts_findNextCascadeFloatingPos(); - rElement.m_aFloatingData.m_aPos = aPos; // set new cascaded position - bWriteData = sal_True; - } - - if( bSetSize ) - xWindow->setOutputSize( AWTSize( rElement.m_aFloatingData.m_aSize ) ); - else - { - if( pToolBox ) - { - // set an optimal initial floating size - vos::OGuard aGuard( Application::GetSolarMutex() ); - ::Size aSize( pToolBox->CalcFloatingWindowSizePixel() ); - pToolBox->SetOutputSizePixel( aSize ); - } - } - - // #i60882# IMPORTANT: Set position after size as it is - // possible that we position some part of the toolbar - // outside of the desktop. A default constructed toolbar - // always has one line. Now VCL automatically - // position the toolbar back into the desktop. Therefore - // we resize the toolbar with the new (wrong) position. - // To fix this problem we have to set the size BEFORE the - // position. - xWindow->setPosSize( aPos.X(), aPos.Y(), 0, 0, - css::awt::PosSize::POS ); - - if ( bWriteData ) - implts_writeWindowStateData( rElement.m_aName, rElement ); - if ( bShowElement && pWindow ) - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - pWindow->Show( sal_True, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE ); - } - } - else - { - ::Point aDockPos; - ::Point aPixelPos; - sal_Bool bSetSize( sal_False ); - ::Size aSize; - - if ( pToolBox ) - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - pToolBox->SetAlign( ImplConvertAlignment(rElement.m_aDockedData.m_nDockedArea ) ); - pToolBox->SetLineCount( 1 ); - if ( rElement.m_aDockedData.m_bLocked ) - xDockWindow->lock(); - aSize = pToolBox->CalcWindowSizePixel(); - bSetSize = sal_True; - - if (( rElement.m_aDockedData.m_aPos.X() == SAL_MAX_INT32 ) && - ( rElement.m_aDockedData.m_aPos.Y() == SAL_MAX_INT32 )) - { - implts_findNextDockingPos( (DockingArea)rElement.m_aDockedData.m_nDockedArea, - aSize, - aDockPos, - aPixelPos ); - rElement.m_aDockedData.m_aPos = aDockPos; - } - } - - xWindow->setPosSize( aPixelPos.X(), - aPixelPos.Y(), - 0, 0, - css::awt::PosSize::POS ); - if( bSetSize ) - xWindow->setOutputSize( AWTSize( aSize) ); - - if ( bShowElement && pWindow ) - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - pWindow->Show( sal_True ); - } - } - } -} - -::Point LayoutManager::implts_findNextCascadeFloatingPos() -{ - const sal_Int32 nHotZoneX = 50; - const sal_Int32 nHotZoneY = 50; - const sal_Int32 nCascadeIndentX = 15; - const sal_Int32 nCascadeIndentY = 15; - - ReadGuard aReadLock( m_aLock ); - Reference< css::awt::XWindow > xContainerWindow = m_xContainerWindow; - Reference< css::awt::XWindow > xTopDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP]; - Reference< css::awt::XWindow > xLeftDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT]; - aReadLock.unlock(); - - ::Point aStartPos( nCascadeIndentX, nCascadeIndentY ); - ::Point aCurrPos( aStartPos ); - css::awt::Rectangle aRect; - - Window* pContainerWindow( 0 ); - if ( xContainerWindow.is() ) - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - pContainerWindow = VCLUnoHelper::GetWindow( xContainerWindow ); - if ( pContainerWindow ) - aStartPos = pContainerWindow->OutputToScreenPixel( aStartPos ); - } - - // Determine size of top and left docking area - css::awt::Rectangle aTopRect = xTopDockingWindow->getPosSize(); - css::awt::Rectangle aLeftRect = xLeftDockingWindow->getPosSize(); - - aStartPos.X() += aLeftRect.Width + nCascadeIndentX; - aStartPos.Y() += aTopRect.Height + nCascadeIndentY; - aCurrPos = aStartPos; - - // Try to find a cascaded position for the new floating window - UIElementVector::const_iterator pIter; - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - { - if ( pIter->m_xUIElement.is() ) - { - Reference< css::awt::XDockableWindow > xDockWindow( pIter->m_xUIElement->getRealInterface(), UNO_QUERY ); - Reference< css::awt::XWindow > xWindow( xDockWindow, UNO_QUERY ); - if ( xDockWindow.is() && xDockWindow->isFloating() ) - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - if ( pWindow && pWindow->IsVisible() ) - { - css::awt::Rectangle aFloatRect = xWindow->getPosSize(); - if ((( aFloatRect.X - nHotZoneX ) <= aCurrPos.X() ) && - ( aFloatRect.X >= aCurrPos.X() ) && - (( aFloatRect.Y - nHotZoneY ) <= aCurrPos.Y() ) && - ( aFloatRect.Y >= aCurrPos.Y() )) - { - aCurrPos.X() = aFloatRect.X + nCascadeIndentX; - aCurrPos.Y() = aFloatRect.Y + nCascadeIndentY; - } - } - } - } - } - - return aCurrPos; -} - -void LayoutManager::implts_findNextDockingPos( DockingArea DockingArea, const ::Size& aUIElementSize, ::Point& rVirtualPos, ::Point& rPixelPos ) -{ - ReadGuard aReadLock( m_aLock ); - Reference< css::awt::XWindow > xDockingWindow = m_xDockAreaWindows[DockingArea]; - ::Size aDockingWinSize; - Window* pDockingWindow( 0 ); - aReadLock.unlock(); - - if (( DockingArea < DockingArea_DOCKINGAREA_TOP ) || - ( DockingArea > DockingArea_DOCKINGAREA_RIGHT )) - DockingArea = DockingArea_DOCKINGAREA_TOP; - - { - // Retrieve output size from container Window - vos::OGuard aGuard( Application::GetSolarMutex() ); - pDockingWindow = VCLUnoHelper::GetWindow( xDockingWindow ); - if ( pDockingWindow ) - aDockingWinSize = pDockingWindow->GetOutputSizePixel(); - } - - sal_Int32 nFreeRowColPixelPos( 0 ); - sal_Int32 nMaxSpace( 0 ); - sal_Int32 nNeededSpace( 0 ); - sal_Int32 nTopDockingAreaSize( 0 ); - - if (( DockingArea == DockingArea_DOCKINGAREA_TOP ) || - ( DockingArea == DockingArea_DOCKINGAREA_BOTTOM )) - { - nMaxSpace = aDockingWinSize.Width(); - nNeededSpace = aUIElementSize.Width(); - } - else - { - nMaxSpace = aDockingWinSize.Height(); - nNeededSpace = aUIElementSize.Height(); - nTopDockingAreaSize = implts_getTopBottomDockingAreaSizes().Width(); - } - - std::vector< SingleRowColumnWindowData > aRowColumnsWindowData; - - implts_getDockingAreaElementInfos( DockingArea, aRowColumnsWindowData ); - sal_Int32 nPixelPos( 0 ); - const sal_uInt32 nCount = aRowColumnsWindowData.size(); - for ( sal_uInt32 i = 0; i < nCount; i++ ) - { - SingleRowColumnWindowData& rRowColumnWindowData = aRowColumnsWindowData[i]; - - if (( DockingArea == DockingArea_DOCKINGAREA_BOTTOM ) || - ( DockingArea == DockingArea_DOCKINGAREA_RIGHT )) - nPixelPos += rRowColumnWindowData.nStaticSize; - - if ((( nMaxSpace - rRowColumnWindowData.nVarSize ) >= nNeededSpace ) || - ( rRowColumnWindowData.nSpace >= nNeededSpace )) - { - // Check current row where we can find the needed space - sal_Int32 nCurrPos( 0 ); - const sal_uInt32 nWindowSizesCount = rRowColumnWindowData.aRowColumnWindowSizes.size(); - for ( sal_uInt32 j = 0; j < nWindowSizesCount; j++ ) - { - css::awt::Rectangle rRect = rRowColumnWindowData.aRowColumnWindowSizes[j]; - sal_Int32& rSpace = rRowColumnWindowData.aRowColumnSpace[j]; - if (( DockingArea == DockingArea_DOCKINGAREA_TOP ) || - ( DockingArea == DockingArea_DOCKINGAREA_BOTTOM )) - { - if ( rSpace >= nNeededSpace ) - { - rVirtualPos = ::Point( nCurrPos, rRowColumnWindowData.nRowColumn ); - if ( DockingArea == DockingArea_DOCKINGAREA_TOP ) - rPixelPos = ::Point( nCurrPos, nPixelPos ); - else - rPixelPos = ::Point( nCurrPos, aDockingWinSize.Height() - nPixelPos ); - return; - } - nCurrPos = rRect.X + rRect.Width; - } - else - { - if ( rSpace >= nNeededSpace ) - { - rVirtualPos = ::Point( rRowColumnWindowData.nRowColumn, nCurrPos ); - if ( DockingArea == DockingArea_DOCKINGAREA_LEFT ) - rPixelPos = ::Point( nPixelPos, nTopDockingAreaSize + nCurrPos ); - else - rPixelPos = ::Point( aDockingWinSize.Width() - nPixelPos , nTopDockingAreaSize + nCurrPos ); - return; - } - nCurrPos = rRect.Y + rRect.Height; - } - } - - if (( nCurrPos + nNeededSpace ) <= nMaxSpace ) - { - if (( DockingArea == DockingArea_DOCKINGAREA_TOP ) || - ( DockingArea == DockingArea_DOCKINGAREA_BOTTOM )) - { - rVirtualPos = ::Point( nCurrPos, rRowColumnWindowData.nRowColumn ); - if ( DockingArea == DockingArea_DOCKINGAREA_TOP ) - rPixelPos = ::Point( nCurrPos, nPixelPos ); - else - rPixelPos = ::Point( nCurrPos, aDockingWinSize.Height() - nPixelPos ); - return; - } - else - { - rVirtualPos = ::Point( rRowColumnWindowData.nRowColumn, nCurrPos ); - if ( DockingArea == DockingArea_DOCKINGAREA_LEFT ) - rPixelPos = ::Point( nPixelPos, nTopDockingAreaSize + nCurrPos ); - else - rPixelPos = ::Point( aDockingWinSize.Width() - nPixelPos , nTopDockingAreaSize + nCurrPos ); - return; - } - } - } - - if (( DockingArea == DockingArea_DOCKINGAREA_TOP ) || - ( DockingArea == DockingArea_DOCKINGAREA_LEFT )) - nPixelPos += rRowColumnWindowData.nStaticSize; - } - - sal_Int32 nNextFreeRowCol( 0 ); - sal_Int32 nRowColumnsCount = aRowColumnsWindowData.size(); - if ( nRowColumnsCount > 0 ) - nNextFreeRowCol = aRowColumnsWindowData[nRowColumnsCount-1].nRowColumn+1; - else - nNextFreeRowCol = 0; - - if ( nNextFreeRowCol == 0 ) - { - if ( DockingArea == DockingArea_DOCKINGAREA_BOTTOM ) - nFreeRowColPixelPos = aDockingWinSize.Height() - aUIElementSize.Height(); - else if ( DockingArea == DockingArea_DOCKINGAREA_RIGHT ) - nFreeRowColPixelPos = aDockingWinSize.Width() - aUIElementSize.Width(); - } - - if (( DockingArea == DockingArea_DOCKINGAREA_TOP ) || - ( DockingArea == DockingArea_DOCKINGAREA_BOTTOM )) - { - rVirtualPos = ::Point( 0, nNextFreeRowCol ); - if ( DockingArea == DockingArea_DOCKINGAREA_TOP ) - rPixelPos = ::Point( 0, nFreeRowColPixelPos ); - else - rPixelPos = ::Point( 0, aDockingWinSize.Height() - nFreeRowColPixelPos ); - } - else - { - rVirtualPos = ::Point( nNextFreeRowCol, 0 ); - rPixelPos = ::Point( aDockingWinSize.Width() - nFreeRowColPixelPos, 0 ); - } -} - ::Size LayoutManager::implts_getContainerWindowOutputSize() { - ReadGuard aReadLock( m_aLock ); - Reference< css::awt::XWindow > xContainerWindow = m_xContainerWindow; - ::Size aContainerWinSize; + ::Size aContainerWinSize; Window* pContainerWindow( 0 ); - aReadLock.unlock(); // Retrieve output size from container Window - vos::OGuard aGuard( Application::GetSolarMutex() ); - pContainerWindow = VCLUnoHelper::GetWindow( xContainerWindow ); + vos::OGuard aGuard( Application::GetSolarMutex() ); + pContainerWindow = VCLUnoHelper::GetWindow( m_xContainerWindow ); if ( pContainerWindow ) - return pContainerWindow->GetOutputSizePixel(); - else - return ::Size(); -} - -void LayoutManager::implts_sortUIElements() -{ - WriteGuard aWriteLock( m_aLock ); - UIElementVector::iterator pIterStart = m_aUIElements.begin(); - UIElementVector::iterator pIterEnd = m_aUIElements.end(); - - std::stable_sort( pIterStart, pIterEnd ); // first created element should first - - // We have to reset our temporary flags. - UIElementVector::iterator pIter; - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - { - // why check, just set it to false - //if ( pIter->m_bUserActive ) - pIter->m_bUserActive = sal_False; - } - -#ifdef DBG_UTIL - implts_checkElementContainer(); -#endif - aWriteLock.unlock(); -} - -void LayoutManager::implts_getDockingAreaElementInfos( DockingArea eDockingArea, std::vector< SingleRowColumnWindowData >& rRowColumnsWindowData ) -{ - std::vector< UIElement > aWindowVector; - - if (( eDockingArea < DockingArea_DOCKINGAREA_TOP ) || - ( eDockingArea > DockingArea_DOCKINGAREA_RIGHT )) - eDockingArea = DockingArea_DOCKINGAREA_TOP; - - Reference< css::awt::XWindow > xDockAreaWindow; - - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - ReadGuard aReadLock( m_aLock ); - aWindowVector.reserve(m_aUIElements.size()); - xDockAreaWindow = m_xDockAreaWindows[eDockingArea]; - UIElementVector::iterator pIter; - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - { - if ( pIter->m_aDockedData.m_nDockedArea == eDockingArea && pIter->m_bVisible && !pIter->m_bFloating ) - { - Reference< XUIElement > xUIElement( pIter->m_xUIElement ); - if ( xUIElement.is() ) - { - Reference< css::awt::XWindow > xWindow( xUIElement->getRealInterface(), UNO_QUERY ); - Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY ); - if ( xDockWindow.is() ) - { - // docked windows - aWindowVector.push_back( *pIter ); - } - } - } - } - aReadLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - - rRowColumnsWindowData.clear(); - - // Collect data from windows that are on the same row/column - sal_Int32 j; - sal_Int32 nIndex( 0 ); - sal_Int32 nLastPos( 0 ); - sal_Int32 nCurrPos( -1 ); - sal_Int32 nLastRowColPixelPos( 0 ); - css::awt::Rectangle aDockAreaRect; - - if ( xDockAreaWindow.is() ) - aDockAreaRect = xDockAreaWindow->getPosSize(); - - if ( eDockingArea == DockingArea_DOCKINGAREA_TOP ) - nLastRowColPixelPos = 0; - else if ( eDockingArea == DockingArea_DOCKINGAREA_BOTTOM ) - nLastRowColPixelPos = aDockAreaRect.Height; - else if ( eDockingArea == DockingArea_DOCKINGAREA_LEFT ) - nLastRowColPixelPos = 0; - else - nLastRowColPixelPos = aDockAreaRect.Width; - - const sal_uInt32 nCount = aWindowVector.size(); - for ( j = 0; j < sal_Int32( nCount); j++ ) - { - const UIElement& rElement = aWindowVector[j]; - Reference< css::awt::XWindow > xWindow; - Reference< XUIElement > xUIElement( rElement.m_xUIElement ); - css::awt::Rectangle aPosSize; - if ( !lcl_checkUIElement(xUIElement,aPosSize,xWindow) ) - continue; - if (( eDockingArea == DockingArea_DOCKINGAREA_TOP ) || - ( eDockingArea == DockingArea_DOCKINGAREA_BOTTOM )) - { - if ( nCurrPos == -1 ) - { - nCurrPos = rElement.m_aDockedData.m_aPos.Y(); - nLastPos = 0; - - SingleRowColumnWindowData aRowColumnWindowData; - aRowColumnWindowData.nRowColumn = nCurrPos; - rRowColumnsWindowData.push_back( aRowColumnWindowData ); - } - - sal_Int32 nSpace( 0 ); - if ( rElement.m_aDockedData.m_aPos.Y() != nCurrPos ) - { - if ( eDockingArea == DockingArea_DOCKINGAREA_TOP ) - nLastRowColPixelPos += rRowColumnsWindowData[nIndex].nStaticSize; - else - nLastRowColPixelPos -= rRowColumnsWindowData[nIndex].nStaticSize; - ++nIndex; - nLastPos = 0; - nCurrPos = rElement.m_aDockedData.m_aPos.Y(); - SingleRowColumnWindowData aRowColumnWindowData; - aRowColumnWindowData.nRowColumn = nCurrPos; - rRowColumnsWindowData.push_back( aRowColumnWindowData ); - } - - // Calc space before an element and store it - nSpace = ( rElement.m_aDockedData.m_aPos.X() - nLastPos ); - if ( rElement.m_aDockedData.m_aPos.X() >= nLastPos ) - { - rRowColumnsWindowData[nIndex].nSpace += nSpace; - nLastPos = rElement.m_aDockedData.m_aPos.X() + aPosSize.Width; - } - else - { - nSpace = 0; - nLastPos += aPosSize.Width; - } - rRowColumnsWindowData[nIndex].aRowColumnSpace.push_back( nSpace ); - - rRowColumnsWindowData[nIndex].aRowColumnWindows.push_back( xWindow ); - rRowColumnsWindowData[nIndex].aUIElementNames.push_back( rElement.m_aName ); - rRowColumnsWindowData[nIndex].aRowColumnWindowSizes.push_back( - css::awt::Rectangle( rElement.m_aDockedData.m_aPos.X(), - rElement.m_aDockedData.m_aPos.Y(), - aPosSize.Width, - aPosSize.Height )); - if ( rRowColumnsWindowData[nIndex].nStaticSize < aPosSize.Height ) - rRowColumnsWindowData[nIndex].nStaticSize = aPosSize.Height; - if ( eDockingArea == DockingArea_DOCKINGAREA_TOP ) - rRowColumnsWindowData[nIndex].aRowColumnRect = css::awt::Rectangle( 0, nLastRowColPixelPos, - aDockAreaRect.Width, aPosSize.Height ); - else - rRowColumnsWindowData[nIndex].aRowColumnRect = css::awt::Rectangle( 0, ( nLastRowColPixelPos - aPosSize.Height ), - aDockAreaRect.Width, aPosSize.Height ); - rRowColumnsWindowData[nIndex].nVarSize += aPosSize.Width + nSpace; - } - else - { - if ( nCurrPos == -1 ) - { - nCurrPos = rElement.m_aDockedData.m_aPos.X(); - nLastPos = 0; - - SingleRowColumnWindowData aRowColumnWindowData; - aRowColumnWindowData.nRowColumn = nCurrPos; - rRowColumnsWindowData.push_back( aRowColumnWindowData ); - } - - sal_Int32 nSpace( 0 ); - if ( rElement.m_aDockedData.m_aPos.X() != nCurrPos ) - { - if ( eDockingArea == DockingArea_DOCKINGAREA_LEFT ) - nLastRowColPixelPos += rRowColumnsWindowData[nIndex].nStaticSize; - else - nLastRowColPixelPos -= rRowColumnsWindowData[nIndex].nStaticSize; - ++nIndex; - nLastPos = 0; - nCurrPos = rElement.m_aDockedData.m_aPos.X(); - SingleRowColumnWindowData aRowColumnWindowData; - aRowColumnWindowData.nRowColumn = nCurrPos; - rRowColumnsWindowData.push_back( aRowColumnWindowData ); - } - - // Calc space before an element and store it - nSpace = ( rElement.m_aDockedData.m_aPos.Y() - nLastPos ); - if ( rElement.m_aDockedData.m_aPos.Y() > nLastPos ) - { - rRowColumnsWindowData[nIndex].nSpace += nSpace; - nLastPos = rElement.m_aDockedData.m_aPos.Y() + aPosSize.Height; - } - else - { - nSpace = 0; - nLastPos += aPosSize.Height; - } - rRowColumnsWindowData[nIndex].aRowColumnSpace.push_back( nSpace ); - - rRowColumnsWindowData[nIndex].aRowColumnWindows.push_back( xWindow ); - rRowColumnsWindowData[nIndex].aUIElementNames.push_back( rElement.m_aName ); - rRowColumnsWindowData[nIndex].aRowColumnWindowSizes.push_back( - css::awt::Rectangle( rElement.m_aDockedData.m_aPos.X(), - rElement.m_aDockedData.m_aPos.Y(), - aPosSize.Width, - aPosSize.Height )); - if ( rRowColumnsWindowData[nIndex].nStaticSize < aPosSize.Width ) - rRowColumnsWindowData[nIndex].nStaticSize = aPosSize.Width; - if ( eDockingArea == DockingArea_DOCKINGAREA_LEFT ) - rRowColumnsWindowData[nIndex].aRowColumnRect = css::awt::Rectangle( nLastRowColPixelPos, 0, - aPosSize.Width, aDockAreaRect.Height ); - else - rRowColumnsWindowData[nIndex].aRowColumnRect = css::awt::Rectangle( ( nLastRowColPixelPos - aPosSize.Width ), 0, - aPosSize.Width, aDockAreaRect.Height ); - rRowColumnsWindowData[nIndex].nVarSize += aPosSize.Height + nSpace; - } - } -} - -void LayoutManager::implts_getDockingAreaElementInfoOnSingleRowCol( DockingArea eDockingArea, sal_Int32 nRowCol, SingleRowColumnWindowData& rRowColumnWindowData ) -{ - std::vector< UIElement > aWindowVector; - - if (( eDockingArea < DockingArea_DOCKINGAREA_TOP ) || - ( eDockingArea > DockingArea_DOCKINGAREA_RIGHT )) - eDockingArea = DockingArea_DOCKINGAREA_TOP; - - sal_Bool bHorzDockArea = (( eDockingArea == DockingArea_DOCKINGAREA_TOP ) || - ( eDockingArea == DockingArea_DOCKINGAREA_BOTTOM )); - - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - ReadGuard aReadLock( m_aLock ); - UIElementVector::iterator pIter; - UIElementVector::iterator pEnd = m_aUIElements.end(); - for ( pIter = m_aUIElements.begin(); pIter != pEnd; pIter++ ) - { - if ( pIter->m_aDockedData.m_nDockedArea == eDockingArea ) - { - sal_Bool bSameRowCol = bHorzDockArea ? - ( pIter->m_aDockedData.m_aPos.Y() == nRowCol ) : - ( pIter->m_aDockedData.m_aPos.X() == nRowCol ); - Reference< XUIElement > xUIElement( pIter->m_xUIElement ); - - if ( bSameRowCol && xUIElement.is() ) - { - Reference< css::awt::XWindow > xWindow( xUIElement->getRealInterface(), UNO_QUERY ); - if ( xWindow.is() ) - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY ); - if ( pWindow && pIter->m_bVisible && xDockWindow.is() && !pIter->m_bFloating ) - { - // docked windows - aWindowVector.push_back( *pIter ); - } - } - } - } - } - aReadLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - - // Initialize structure - rRowColumnWindowData.aUIElementNames.clear(); - rRowColumnWindowData.aRowColumnWindows.clear(); - rRowColumnWindowData.aRowColumnWindowSizes.clear(); - rRowColumnWindowData.aRowColumnSpace.clear(); - rRowColumnWindowData.nVarSize = 0; - rRowColumnWindowData.nStaticSize = 0; - rRowColumnWindowData.nSpace = 0; - rRowColumnWindowData.nRowColumn = nRowCol; - - // Collect data from windows that are on the same row/column - sal_Int32 j; - sal_Int32 nLastPos( 0 ); - - const sal_uInt32 nCount = aWindowVector.size(); - for ( j = 0; j < sal_Int32( nCount); j++ ) - { - const UIElement& rElement = aWindowVector[j]; - Reference< css::awt::XWindow > xWindow; - Reference< XUIElement > xUIElement( rElement.m_xUIElement ); - css::awt::Rectangle aPosSize; - if ( !lcl_checkUIElement(xUIElement,aPosSize,xWindow) ) - continue; - - sal_Int32 nSpace; - if (( eDockingArea == DockingArea_DOCKINGAREA_TOP ) || - ( eDockingArea == DockingArea_DOCKINGAREA_BOTTOM )) - { - nSpace = ( rElement.m_aDockedData.m_aPos.X() - nLastPos ); - - // Calc space before an element and store it - if ( rElement.m_aDockedData.m_aPos.X() > nLastPos ) - rRowColumnWindowData.nSpace += nSpace; - else - nSpace = 0; - - nLastPos = rElement.m_aDockedData.m_aPos.X() + aPosSize.Width; - - - rRowColumnWindowData.aRowColumnWindowSizes.push_back( - css::awt::Rectangle( rElement.m_aDockedData.m_aPos.X(), - rElement.m_aDockedData.m_aPos.Y(), - aPosSize.Width, - aPosSize.Height )); - if ( rRowColumnWindowData.nStaticSize < aPosSize.Height ) - rRowColumnWindowData.nStaticSize = aPosSize.Height; - rRowColumnWindowData.nVarSize += aPosSize.Width; - } - else - { - // Calc space before an element and store it - nSpace = ( rElement.m_aDockedData.m_aPos.Y() - nLastPos ); - if ( rElement.m_aDockedData.m_aPos.Y() > nLastPos ) - rRowColumnWindowData.nSpace += nSpace; - else - nSpace = 0; - - nLastPos = rElement.m_aDockedData.m_aPos.Y() + aPosSize.Height; - - rRowColumnWindowData.aRowColumnWindowSizes.push_back( - css::awt::Rectangle( rElement.m_aDockedData.m_aPos.X(), - rElement.m_aDockedData.m_aPos.Y(), - aPosSize.Width, - aPosSize.Height )); - if ( rRowColumnWindowData.nStaticSize < aPosSize.Width ) - rRowColumnWindowData.nStaticSize = aPosSize.Width; - rRowColumnWindowData.nVarSize += aPosSize.Height; - } - - rRowColumnWindowData.aUIElementNames.push_back( rElement.m_aName ); - rRowColumnWindowData.aRowColumnWindows.push_back( xWindow ); - rRowColumnWindowData.aRowColumnSpace.push_back( nSpace ); - rRowColumnWindowData.nVarSize += nSpace; - } -} - -::Rectangle LayoutManager::implts_determineFrontDockingRect( - DockingArea eDockingArea, - sal_Int32 nRowCol, - const ::Rectangle& rDockedElementRect, - const ::rtl::OUString& rMovedElementName, - const ::Rectangle& rMovedElementRect ) -{ - SingleRowColumnWindowData aRowColumnWindowData; - - sal_Bool bHorzDockArea = (( eDockingArea == DockingArea_DOCKINGAREA_TOP ) || - ( eDockingArea == DockingArea_DOCKINGAREA_BOTTOM )); - - implts_getDockingAreaElementInfoOnSingleRowCol( eDockingArea, nRowCol, aRowColumnWindowData ); - if ( aRowColumnWindowData.aRowColumnWindows.empty() ) - return rMovedElementRect; - else - { - sal_Int32 nSpace( 0 ); - ::Rectangle aFrontDockingRect( rMovedElementRect ); - const sal_uInt32 nCount = aRowColumnWindowData.aRowColumnWindows.size(); - for ( sal_uInt32 i = 0; i < nCount; i++ ) - { - if ( bHorzDockArea ) - { - if ( aRowColumnWindowData.aRowColumnWindowSizes[i].X >= rDockedElementRect.Left() ) - { - nSpace += aRowColumnWindowData.aRowColumnSpace[i]; - break; - } - else if ( aRowColumnWindowData.aUIElementNames[i] == rMovedElementName ) - nSpace += aRowColumnWindowData.aRowColumnWindowSizes[i].Width + - aRowColumnWindowData.aRowColumnSpace[i]; - else - nSpace = 0; - } - else - { - if ( aRowColumnWindowData.aRowColumnWindowSizes[i].Y >= rDockedElementRect.Top() ) - { - nSpace += aRowColumnWindowData.aRowColumnSpace[i]; - break; - } - else if ( aRowColumnWindowData.aUIElementNames[i] == rMovedElementName ) - nSpace += aRowColumnWindowData.aRowColumnWindowSizes[i].Height + - aRowColumnWindowData.aRowColumnSpace[i]; - else - nSpace = 0; - } - } - - if ( nSpace > 0 ) - { - sal_Int32 nMove = std::min( nSpace, static_cast<sal_Int32>(aFrontDockingRect.getWidth()) ); - if ( bHorzDockArea ) - aFrontDockingRect.Move( -nMove, 0 ); - else - aFrontDockingRect.Move( 0, -nMove ); - } - - return aFrontDockingRect; - } -} - -::Rectangle LayoutManager::implts_getWindowRectFromRowColumn( - ::com::sun::star::ui::DockingArea DockingArea, - const SingleRowColumnWindowData& rRowColumnWindowData, - const ::Point& rMousePos, - const rtl::OUString& rExcludeElementName ) -{ - ::Rectangle aWinRect; - - if (( DockingArea < DockingArea_DOCKINGAREA_TOP ) || - ( DockingArea > DockingArea_DOCKINGAREA_RIGHT )) - DockingArea = DockingArea_DOCKINGAREA_TOP; - - if ( rRowColumnWindowData.aRowColumnWindows.empty() ) - return aWinRect; - else - { - ReadGuard aReadLock( m_aLock ); - Reference< css::awt::XWindow > xContainerWindow = m_xContainerWindow; - Reference< css::awt::XWindow > xDockingAreaWindow = m_xDockAreaWindows[DockingArea]; - aReadLock.unlock(); - - // Calc correct position of the column/row rectangle to be able to compare it with mouse pos/tracking rect - vos::OGuard aGuard( Application::GetSolarMutex() ); - - // Retrieve output size from container Window - Window* pContainerWindow( VCLUnoHelper::GetWindow( xContainerWindow )); - Window* pDockingAreaWindow( VCLUnoHelper::GetWindow( xDockingAreaWindow )); - if ( pDockingAreaWindow && pContainerWindow ) - { - const sal_uInt32 nCount = rRowColumnWindowData.aRowColumnWindows.size(); - for ( sal_uInt32 i = 0; i < nCount; i++ ) - { - css::awt::Rectangle aWindowRect = rRowColumnWindowData.aRowColumnWindows[i]->getPosSize(); - ::Rectangle aRect( aWindowRect.X, aWindowRect.Y, aWindowRect.X+aWindowRect.Width, aWindowRect.Y+aWindowRect.Height ); - aRect.SetPos( pContainerWindow->ScreenToOutputPixel( pDockingAreaWindow->OutputToScreenPixel( aRect.TopLeft() ))); - if ( aRect.IsInside( rMousePos )) - { - // Check if we have found the excluded element. If yes, we have to provide an empty rectangle. - // We prevent that a toolbar cannot be moved when the mouse pointer is inside its own rectangle! - if ( rExcludeElementName != rRowColumnWindowData.aUIElementNames[i] ) - return aRect; - else - break; - } - } - } - } - - return aWinRect; -} - -framework::LayoutManager::DockingOperation -LayoutManager::implts_determineDockingOperation( - ::com::sun::star::ui::DockingArea DockingArea, - const ::Rectangle& rRowColRect, - const Point& rMousePos ) -{ - const sal_Int32 nHorzVerticalRegionSize = 6; - const sal_Int32 nHorzVerticalMoveRegion = 4; - - if ( rRowColRect.IsInside( rMousePos )) - { - if (( DockingArea == DockingArea_DOCKINGAREA_TOP ) || - ( DockingArea == DockingArea_DOCKINGAREA_BOTTOM )) - { - sal_Int32 nRegion = rRowColRect.getHeight() / nHorzVerticalRegionSize; - sal_Int32 nPosY = rRowColRect.Top() + nRegion; - - if ( rMousePos.Y() < nPosY ) - return ( DockingArea == DockingArea_DOCKINGAREA_TOP ) ? DOCKOP_BEFORE_COLROW : DOCKOP_AFTER_COLROW; - else if ( rMousePos.Y() < ( nPosY + nRegion*nHorzVerticalMoveRegion )) - return DOCKOP_ON_COLROW; - else - return ( DockingArea == DockingArea_DOCKINGAREA_TOP ) ? DOCKOP_AFTER_COLROW : DOCKOP_BEFORE_COLROW; - } - else - { - sal_Int32 nRegion = rRowColRect.getWidth() / nHorzVerticalRegionSize; - sal_Int32 nPosX = rRowColRect.Left() + nRegion; - - if ( rMousePos.X() < nPosX ) - return ( DockingArea == DockingArea_DOCKINGAREA_LEFT ) ? DOCKOP_BEFORE_COLROW : DOCKOP_AFTER_COLROW; - else if ( rMousePos.X() < ( nPosX + nRegion*nHorzVerticalMoveRegion )) - return DOCKOP_ON_COLROW; - else - return ( DockingArea == DockingArea_DOCKINGAREA_LEFT ) ? DOCKOP_AFTER_COLROW : DOCKOP_BEFORE_COLROW; - } - } - else - return DOCKOP_ON_COLROW; -} - -::Rectangle LayoutManager::implts_calcTrackingAndElementRect( - ::com::sun::star::ui::DockingArea eDockingArea, - sal_Int32 nRowCol, - UIElement& rUIElement, - const ::Rectangle& rTrackingRect, - const ::Rectangle& rRowColumnRect, - const ::Size& rContainerWinSize ) -{ - sal_Bool bHorizontalDockArea( ( eDockingArea == DockingArea_DOCKINGAREA_TOP ) || - ( eDockingArea == DockingArea_DOCKINGAREA_BOTTOM )); - - sal_Int32 nTopDockingAreaSize( implts_getTopBottomDockingAreaSizes().Width() ); - sal_Int32 nBottomDockingAreaSize( implts_getTopBottomDockingAreaSizes().Height() ); - - ::Size aStatusBarSize( implts_getStatusBarSize() ); - sal_Int32 nMaxLeftRightDockAreaSize = rContainerWinSize.Height() - - nTopDockingAreaSize - - nBottomDockingAreaSize - - aStatusBarSize.Height(); - - ::Rectangle aTrackingRect( rTrackingRect ); - if ( bHorizontalDockArea ) - { - sal_Int32 nPosX( std::max( sal_Int32( rTrackingRect.Left()), sal_Int32( 0 ))); - if (( nPosX + rTrackingRect.getWidth()) > rContainerWinSize.Width() ) - nPosX = std::min( nPosX, - std::max( sal_Int32( rContainerWinSize.Width() - rTrackingRect.getWidth() ), - sal_Int32( 0 ))); - - sal_Int32 nSize = std::min( rContainerWinSize.Width(), rTrackingRect.getWidth() ); - - aTrackingRect.SetPos( ::Point( nPosX, rRowColumnRect.Top() )); - aTrackingRect.setWidth( nSize ); - aTrackingRect.setHeight( rRowColumnRect.getHeight() ); - - // Set virtual position - rUIElement.m_aDockedData.m_aPos.X() = nPosX; - rUIElement.m_aDockedData.m_aPos.Y() = nRowCol; - } - else - { - sal_Int32 nMaxDockingAreaHeight = std::max( sal_Int32( 0 ), - sal_Int32( nMaxLeftRightDockAreaSize )); - - sal_Int32 nPosY( std::max( sal_Int32( aTrackingRect.Top()), sal_Int32( nTopDockingAreaSize ))); - if (( nPosY + aTrackingRect.getHeight()) > ( nTopDockingAreaSize + nMaxDockingAreaHeight )) - nPosY = std::min( nPosY, - std::max( sal_Int32( nTopDockingAreaSize + ( nMaxDockingAreaHeight - aTrackingRect.getHeight() )), - sal_Int32( nTopDockingAreaSize ))); - - sal_Int32 nSize = std::min( nMaxDockingAreaHeight, static_cast<sal_Int32>(aTrackingRect.getHeight()) ); - - aTrackingRect.SetPos( ::Point( rRowColumnRect.Left(), nPosY )); - aTrackingRect.setWidth( rRowColumnRect.getWidth() ); - aTrackingRect.setHeight( nSize ); - - ReadGuard aReadLock( m_aLock ); - Reference< css::awt::XWindow > xDockingAreaWindow = m_xDockAreaWindows[eDockingArea]; - Reference< css::awt::XWindow > xContainerWindow = m_xContainerWindow; - aReadLock.unlock(); - - sal_Int32 nDockPosY( 0 ); - Window* pDockingAreaWindow( 0 ); - Window* pContainerWindow( 0 ); - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - pDockingAreaWindow = VCLUnoHelper::GetWindow( xDockingAreaWindow ); - pContainerWindow = VCLUnoHelper::GetWindow( xContainerWindow ); - nDockPosY = pDockingAreaWindow->ScreenToOutputPixel( - pContainerWindow->OutputToScreenPixel( ::Point( 0, nPosY ))).Y(); - } - - // Set virtual position - rUIElement.m_aDockedData.m_aPos.X() = nRowCol; - rUIElement.m_aDockedData.m_aPos.Y() = nDockPosY; - } - - return aTrackingRect; -} - -void implts_setTrackingRect( DockingArea eDockingArea, const Point& rMousePos, ::Rectangle& rTrackingRect ) -{ - sal_Bool bHorizontalDockArea( ( eDockingArea == DockingArea_DOCKINGAREA_TOP ) || - ( eDockingArea == DockingArea_DOCKINGAREA_BOTTOM )); - - ::Point aPoint = rTrackingRect.TopLeft(); - if ( bHorizontalDockArea ) - aPoint.X() = rMousePos.X(); - else - aPoint.Y() = rMousePos.Y(); - rTrackingRect.SetPos( aPoint ); -} - -void LayoutManager::implts_calcDockingPosSize( - UIElement& rUIElement, - DockingOperation& rDockingOperation, - ::Rectangle& rTrackingRect, - const Point& rMousePos ) -{ - ReadGuard aReadLock( m_aLock ); - Reference< css::awt::XWindow > xContainerWindow = m_xContainerWindow; - ::Size aContainerWinSize; - Window* pContainerWindow( 0 ); - aReadLock.unlock(); - - { - // Retrieve output size from container Window - vos::OGuard aGuard( Application::GetSolarMutex() ); - pContainerWindow = VCLUnoHelper::GetWindow( xContainerWindow ); aContainerWinSize = pContainerWindow->GetOutputSizePixel(); - } - - if ( !rUIElement.m_xUIElement.is() ) - { - rTrackingRect = ::Rectangle(); - return; - } - - Window* pDockWindow( 0 ); - Window* pDockingAreaWindow( 0 ); - ToolBox* pToolBox( 0 ); - Reference< css::awt::XWindow > xWindow( rUIElement.m_xUIElement->getRealInterface(), UNO_QUERY ); - Reference< css::awt::XWindow > xDockingAreaWindow; - ::Rectangle aTrackingRect( rTrackingRect ); - ::com::sun::star::ui::DockingArea eDockedArea( (::com::sun::star::ui::DockingArea)rUIElement.m_aDockedData.m_nDockedArea ); - sal_Int32 nTopDockingAreaSize( implts_getTopBottomDockingAreaSizes().Width() ); - sal_Int32 nBottomDockingAreaSize( implts_getTopBottomDockingAreaSizes().Height() ); - sal_Bool bHorizontalDockArea( ( eDockedArea == DockingArea_DOCKINGAREA_TOP ) || - ( eDockedArea == DockingArea_DOCKINGAREA_BOTTOM )); - ::Size aStatusBarSize( implts_getStatusBarSize() ); - sal_Int32 nMaxLeftRightDockAreaSize = aContainerWinSize.Height() - - nTopDockingAreaSize - - nBottomDockingAreaSize - - aStatusBarSize.Height(); - ::Rectangle aDockingAreaRect; - - aReadLock.lock(); - xDockingAreaWindow = m_xDockAreaWindows[eDockedArea]; - aReadLock.unlock(); - - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - pDockingAreaWindow = VCLUnoHelper::GetWindow( xDockingAreaWindow ); - pDockWindow = VCLUnoHelper::GetWindow( xWindow ); - if ( pDockWindow && pDockWindow->GetType() == WINDOW_TOOLBOX ) - pToolBox = (ToolBox *)pDockWindow; - - aDockingAreaRect = ::Rectangle( pDockingAreaWindow->GetPosPixel(), pDockingAreaWindow->GetSizePixel() ); - if ( pToolBox ) - { - // docked toolbars always have one line - ::Size aSize = pToolBox->CalcWindowSizePixel( 1, ImplConvertAlignment( sal_Int16( eDockedArea )) ); - aTrackingRect.SetSize( ::Size( aSize.Width(), aSize.Height() )); - } - } - - // default docking operation, dock on the given row/column - sal_Bool bOpOutsideOfDockingArea( !aDockingAreaRect.IsInside( rMousePos )); - std::vector< SingleRowColumnWindowData > aRowColumnsWindowData; - - rDockingOperation = DOCKOP_ON_COLROW; - implts_getDockingAreaElementInfos( eDockedArea, aRowColumnsWindowData ); - - // determine current first row/column and last row/column - sal_Int32 nMaxRowCol( -1 ); - sal_Int32 nMinRowCol( SAL_MAX_INT32 ); - const sal_uInt32 nCount = aRowColumnsWindowData.size(); - for ( sal_uInt32 i = 0; i < nCount; i++ ) - { - if ( aRowColumnsWindowData[i].nRowColumn > nMaxRowCol ) - nMaxRowCol = aRowColumnsWindowData[i].nRowColumn; - if ( aRowColumnsWindowData[i].nRowColumn < nMinRowCol ) - nMinRowCol = aRowColumnsWindowData[i].nRowColumn; - } - - if ( !bOpOutsideOfDockingArea ) - { - // docking inside our docking area - sal_Int32 nIndex( -1 ); - sal_Int32 nRowCol( -1 ); - ::Rectangle aWindowRect; - ::Rectangle aRowColumnRect; - - const sal_uInt32 nWindowDataCount = aRowColumnsWindowData.size(); - for ( sal_uInt32 i = 0; i < nWindowDataCount; i++ ) - { - ::Rectangle aRect( aRowColumnsWindowData[i].aRowColumnRect.X, - aRowColumnsWindowData[i].aRowColumnRect.Y, - aRowColumnsWindowData[i].aRowColumnRect.X + aRowColumnsWindowData[i].aRowColumnRect.Width, - aRowColumnsWindowData[i].aRowColumnRect.Y + aRowColumnsWindowData[i].aRowColumnRect.Height ); - - { - // Calc correct position of the column/row rectangle to be able to compare it with mouse pos/tracking rect - vos::OGuard aGuard( Application::GetSolarMutex() ); - aRect.SetPos( pContainerWindow->ScreenToOutputPixel( pDockingAreaWindow->OutputToScreenPixel( aRect.TopLeft() ))); - } - - sal_Bool bIsInsideRowCol( aRect.IsInside( rMousePos ) ); - if ( bIsInsideRowCol ) - { - nIndex = i; - nRowCol = aRowColumnsWindowData[i].nRowColumn; - rDockingOperation = implts_determineDockingOperation( eDockedArea, aRect, rMousePos ); - aWindowRect = implts_getWindowRectFromRowColumn( eDockedArea, aRowColumnsWindowData[i], rMousePos, rUIElement.m_aName ); - aRowColumnRect = aRect; - break; - } - } - - OSL_ENSURE( ( nIndex >= 0 ) && ( nRowCol >= 0 ), "Impossible case - no row/column found but mouse pointer is inside our docking area" ); - if (( nIndex >= 0 ) && ( nRowCol >= 0 )) - { - if ( rDockingOperation == DOCKOP_ON_COLROW ) - { - if ( !aWindowRect.IsEmpty()) - { - // Tracking rect is on a row/column and mouse is over a docked toolbar. - // Determine if the tracking rect must be located before/after the docked toolbar. - - ::Rectangle aUIElementRect( aWindowRect ); - sal_Int32 nMiddle( bHorizontalDockArea ? ( aWindowRect.Left() + aWindowRect.getWidth() / 2 ) : - ( aWindowRect.Top() + aWindowRect.getHeight() / 2 )); - sal_Bool bInsertBefore( bHorizontalDockArea ? ( rMousePos.X() < nMiddle ) : ( rMousePos.Y() < nMiddle )); - if ( bInsertBefore ) - { - if ( bHorizontalDockArea ) - { - sal_Int32 nSize = ::std::max( sal_Int32( 0 ), std::min( sal_Int32( aContainerWinSize.Width() - aWindowRect.Left() ), - sal_Int32( aTrackingRect.getWidth() ))); - if ( nSize == 0 ) - nSize = aWindowRect.getWidth(); - - aUIElementRect.SetSize( ::Size( nSize, aWindowRect.getHeight() )); - aWindowRect = implts_determineFrontDockingRect( eDockedArea, nRowCol, aWindowRect,rUIElement.m_aName, aUIElementRect ); - - // Set virtual position - rUIElement.m_aDockedData.m_aPos.X() = aWindowRect.Left(); - rUIElement.m_aDockedData.m_aPos.Y() = nRowCol; - } - else - { - sal_Int32 nSize = ::std::max( sal_Int32( 0 ), std::min( sal_Int32( - nTopDockingAreaSize + nMaxLeftRightDockAreaSize - aWindowRect.Top() ), - sal_Int32( aTrackingRect.getHeight() ))); - if ( nSize == 0 ) - nSize = aWindowRect.getHeight(); - - aUIElementRect.SetSize( ::Size( aWindowRect.getWidth(), nSize )); - aWindowRect = implts_determineFrontDockingRect( eDockedArea, nRowCol, aWindowRect, rUIElement.m_aName, aUIElementRect ); - - // Set virtual position - sal_Int32 nPosY = pDockingAreaWindow->ScreenToOutputPixel( - pContainerWindow->OutputToScreenPixel( aWindowRect.TopLeft() )).Y(); - rUIElement.m_aDockedData.m_aPos.X() = nRowCol; - rUIElement.m_aDockedData.m_aPos.Y() = nPosY; - } - - rTrackingRect = aWindowRect; - return; - } - else - { - if ( bHorizontalDockArea ) - { - sal_Int32 nSize = ::std::max( sal_Int32( 0 ), std::min( sal_Int32(( aContainerWinSize.Width() ) - aWindowRect.Right() ), - sal_Int32( aTrackingRect.getWidth() ))); - if ( nSize == 0 ) - { - aUIElementRect.SetPos( ::Point( aContainerWinSize.Width() - aTrackingRect.getWidth(), aWindowRect.Top() )); - aUIElementRect.SetSize( ::Size( aTrackingRect.getWidth(), aWindowRect.getHeight() )); - rUIElement.m_aDockedData.m_aPos.X() = aUIElementRect.Left(); - } - else - { - aUIElementRect.SetPos( ::Point( aWindowRect.Right(), aWindowRect.Top() )); - aUIElementRect.SetSize( ::Size( nSize, aWindowRect.getHeight() )); - rUIElement.m_aDockedData.m_aPos.X() = aWindowRect.Right(); - } - - // Set virtual position - rUIElement.m_aDockedData.m_aPos.Y() = nRowCol; - } - else - { - sal_Int32 nSize = ::std::max( sal_Int32( 0 ), std::min( sal_Int32( nTopDockingAreaSize + nMaxLeftRightDockAreaSize - aWindowRect.Bottom() ), - sal_Int32( aTrackingRect.getHeight() ))); - aUIElementRect.SetPos( ::Point( aWindowRect.Left(), aWindowRect.Bottom() )); - aUIElementRect.SetSize( ::Size( aWindowRect.getWidth(), nSize )); - - // Set virtual position - sal_Int32 nPosY( 0 ); - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - nPosY = pDockingAreaWindow->ScreenToOutputPixel( - pContainerWindow->OutputToScreenPixel( aWindowRect.BottomRight() )).Y(); - } - rUIElement.m_aDockedData.m_aPos.X() = nRowCol; - rUIElement.m_aDockedData.m_aPos.Y() = nPosY; - } - - rTrackingRect = aUIElementRect; - return; - } - } - else - { - implts_setTrackingRect( eDockedArea, rMousePos, aTrackingRect ); - rTrackingRect = implts_calcTrackingAndElementRect( - eDockedArea, nRowCol, rUIElement, - aTrackingRect, aRowColumnRect, aContainerWinSize ); - return; - } - } - else - { - if ((( nRowCol == nMinRowCol ) && ( rDockingOperation == DOCKOP_BEFORE_COLROW )) || - (( nRowCol == nMaxRowCol ) && ( rDockingOperation == DOCKOP_AFTER_COLROW ))) - bOpOutsideOfDockingArea = sal_True; - else - { - // handle docking before/after a row - implts_setTrackingRect( eDockedArea, rMousePos, aTrackingRect ); - rTrackingRect = implts_calcTrackingAndElementRect( - eDockedArea, nRowCol, rUIElement, - aTrackingRect, aRowColumnRect, aContainerWinSize ); - - sal_Int32 nOffsetX( 0 ); - sal_Int32 nOffsetY( 0 ); - if ( bHorizontalDockArea ) - nOffsetY = sal_Int32( floor( aRowColumnRect.getHeight() / 2 + 0.5 )); - else - nOffsetX = sal_Int32( floor( aRowColumnRect.getWidth() / 2 + 0.5 )); - - if ( rDockingOperation == DOCKOP_BEFORE_COLROW ) - { - if (( eDockedArea == DockingArea_DOCKINGAREA_TOP ) || - ( eDockedArea == DockingArea_DOCKINGAREA_LEFT )) - { - // Docking before/after means move track rectangle half column/row. - // As left and top are ordered 0...n instead of right and bottom - // which uses n...0, we have to use negative values for top/left. - nOffsetX *= -1; - nOffsetY *= -1; - } - } - else - { - if (( eDockedArea == DockingArea_DOCKINGAREA_BOTTOM ) || - ( eDockedArea == DockingArea_DOCKINGAREA_RIGHT )) - { - // Docking before/after means move track rectangle half column/row. - // As left and top are ordered 0...n instead of right and bottom - // which uses n...0, we have to use negative values for top/left. - nOffsetX *= -1; - nOffsetY *= -1; - } - nRowCol++; - } - - if ( bHorizontalDockArea ) - rUIElement.m_aDockedData.m_aPos.Y() = nRowCol; - else - rUIElement.m_aDockedData.m_aPos.X() = nRowCol; - - rTrackingRect.Move( nOffsetX, nOffsetY ); - rTrackingRect.SetSize( aTrackingRect.GetSize() ); - } - } - } - } - - // Docking outside of our docking window area => - // Users want to dock before/after first/last docked element or to an empty docking area - if ( bOpOutsideOfDockingArea ) - { - // set correct size for docking - implts_setTrackingRect( eDockedArea, rMousePos, aTrackingRect ); - rTrackingRect = aTrackingRect; - - if ( bHorizontalDockArea ) - { - sal_Int32 nPosX( std::max( sal_Int32( rTrackingRect.Left()), sal_Int32( 0 ))); - if (( nPosX + rTrackingRect.getWidth()) > aContainerWinSize.Width() ) - nPosX = std::min( nPosX, - std::max( sal_Int32( aContainerWinSize.Width() - rTrackingRect.getWidth() ), - sal_Int32( 0 ))); - - sal_Int32 nSize = std::min( aContainerWinSize.Width(), rTrackingRect.getWidth() ); - sal_Int32 nDockHeight = std::max( static_cast<sal_Int32>(aDockingAreaRect.getHeight()), sal_Int32( 0 )); - if ( nDockHeight == 0 ) - { - sal_Int32 nPosY( std::max( aDockingAreaRect.Top(), aDockingAreaRect.Bottom() )); - if ( eDockedArea == DockingArea_DOCKINGAREA_BOTTOM ) - nPosY -= rTrackingRect.getHeight(); - rTrackingRect.SetPos( Point( nPosX, nPosY )); - rUIElement.m_aDockedData.m_aPos.Y() = 0; - } - else if ( rMousePos.Y() < ( aDockingAreaRect.Top() + ( nDockHeight / 2 ))) - { - rTrackingRect.SetPos( Point( nPosX, aDockingAreaRect.Top() - rTrackingRect.getHeight() )); - if ( eDockedArea == DockingArea_DOCKINGAREA_TOP ) - rUIElement.m_aDockedData.m_aPos.Y() = 0; - else - rUIElement.m_aDockedData.m_aPos.Y() = ( nMaxRowCol >= 0 ) ? nMaxRowCol+1 : 0; - rDockingOperation = DOCKOP_BEFORE_COLROW; - } - else - { - rTrackingRect.SetPos( Point( nPosX, aDockingAreaRect.Bottom() )); - if ( eDockedArea == DockingArea_DOCKINGAREA_TOP ) - rUIElement.m_aDockedData.m_aPos.Y() = ( nMaxRowCol >= 0 ) ? nMaxRowCol+1 : 0; - else - rUIElement.m_aDockedData.m_aPos.Y() = 0; - rDockingOperation = DOCKOP_AFTER_COLROW; - } - rTrackingRect.setWidth( nSize ); - - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - nPosX = pDockingAreaWindow->ScreenToOutputPixel( - pContainerWindow->OutputToScreenPixel( rTrackingRect.TopLeft() )).X(); - } - rUIElement.m_aDockedData.m_aPos.X() = nPosX; - } - else - { - sal_Int32 nMaxDockingAreaHeight = std::max( sal_Int32( 0 ), - sal_Int32( nMaxLeftRightDockAreaSize )); - - sal_Int32 nPosY( std::max( sal_Int32( aTrackingRect.Top()), sal_Int32( nTopDockingAreaSize ))); - if (( nPosY + aTrackingRect.getHeight()) > ( nTopDockingAreaSize + nMaxDockingAreaHeight )) - nPosY = std::min( nPosY, - std::max( sal_Int32( nTopDockingAreaSize + ( nMaxDockingAreaHeight - aTrackingRect.getHeight() )), - sal_Int32( nTopDockingAreaSize ))); - - sal_Int32 nSize = std::min( nMaxDockingAreaHeight, static_cast<sal_Int32>(aTrackingRect.getHeight()) ); - sal_Int32 nDockWidth = std::max( static_cast<sal_Int32>(aDockingAreaRect.getWidth()), sal_Int32( 0 )); - if ( nDockWidth == 0 ) - { - sal_Int32 nPosX( std::max( aDockingAreaRect.Left(), aDockingAreaRect.Right() )); - if ( eDockedArea == DockingArea_DOCKINGAREA_RIGHT ) - nPosX -= rTrackingRect.getWidth(); - rTrackingRect.SetPos( Point( nPosX, nPosY )); - rUIElement.m_aDockedData.m_aPos.X() = 0; - } - else if ( rMousePos.X() < ( aDockingAreaRect.Left() + ( nDockWidth / 2 ))) - { - rTrackingRect.SetPos( Point( aDockingAreaRect.Left() - rTrackingRect.getWidth(), nPosY )); - if ( eDockedArea == DockingArea_DOCKINGAREA_LEFT ) - rUIElement.m_aDockedData.m_aPos.X() = 0; - else - rUIElement.m_aDockedData.m_aPos.X() = ( nMaxRowCol >= 0 ) ? nMaxRowCol+1 : 0; - rDockingOperation = DOCKOP_BEFORE_COLROW; - } - else - { - rTrackingRect.SetPos( Point( aDockingAreaRect.Right(), nPosY )); - if ( eDockedArea == DockingArea_DOCKINGAREA_LEFT ) - rUIElement.m_aDockedData.m_aPos.X() = ( nMaxRowCol >= 0 ) ? nMaxRowCol+1 : 0; - else - rUIElement.m_aDockedData.m_aPos.X() = 0; - rDockingOperation = DOCKOP_AFTER_COLROW; - } - rTrackingRect.setHeight( nSize ); - - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - nPosY = pDockingAreaWindow->ScreenToOutputPixel( - pContainerWindow->OutputToScreenPixel( rTrackingRect.TopLeft() )).Y(); - } - rUIElement.m_aDockedData.m_aPos.Y() = nPosY; - } - } -} - -void LayoutManager::implts_renumberRowColumnData( - ::com::sun::star::ui::DockingArea eDockingArea, - DockingOperation /*eDockingOperation*/, - const UIElement& rUIElement ) -{ - ReadGuard aReadLock( m_aLock ); - Reference< XNameAccess > xPersistentWindowState( m_xPersistentWindowState ); - aReadLock.unlock(); - - sal_Bool bHorzDockingArea(( eDockingArea == DockingArea_DOCKINGAREA_TOP ) || - ( eDockingArea == DockingArea_DOCKINGAREA_BOTTOM )); - sal_Int32 nRowCol( bHorzDockingArea ? rUIElement.m_aDockedData.m_aPos.Y() : - rUIElement.m_aDockedData.m_aPos.X() ); - - WriteGuard aWriteLock( m_aLock ); - UIElementVector::iterator pIter; - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - { - if (( pIter->m_aDockedData.m_nDockedArea == sal_Int16( eDockingArea )) && - ( pIter->m_aName != rUIElement.m_aName )) - { - // Don't change toolbars without a valid docking position! - if (( pIter->m_aDockedData.m_aPos.X() == SAL_MAX_INT32 ) && - ( pIter->m_aDockedData.m_aPos.Y() == SAL_MAX_INT32 )) - continue; - - sal_Int32 nWindowRowCol = ( bHorzDockingArea ) ? - pIter->m_aDockedData.m_aPos.Y() : pIter->m_aDockedData.m_aPos.X(); - if ( nWindowRowCol >= nRowCol ) - { - if ( bHorzDockingArea ) - pIter->m_aDockedData.m_aPos.Y() += 1; - else - pIter->m_aDockedData.m_aPos.X() += 1; - } - } - } - aWriteLock.unlock(); - - // We have to change the persistent window state part - if ( xPersistentWindowState.is() ) - { - try - { - Sequence< rtl::OUString > aWindowElements = xPersistentWindowState->getElementNames(); - for ( sal_Int32 i = 0; i < aWindowElements.getLength(); i++ ) - { - if ( rUIElement.m_aName != aWindowElements[i] ) - { - try - { - Sequence< PropertyValue > aPropValueSeq; - css::awt::Point aDockedPos; - DockingArea nDockedArea( DockingArea_DOCKINGAREA_DEFAULT ); - - xPersistentWindowState->getByName( aWindowElements[i] ) >>= aPropValueSeq; - for ( sal_Int32 j = 0; j < aPropValueSeq.getLength(); j++ ) - { - if ( aPropValueSeq[j].Name == m_aPropDockingArea ) - aPropValueSeq[j].Value >>= nDockedArea; - else if ( aPropValueSeq[j].Name == m_aPropDockPos ) - aPropValueSeq[j].Value >>= aDockedPos; - } - - // Don't change toolbars without a valid docking position! - if (( aDockedPos.X == SAL_MAX_INT32 ) && ( aDockedPos.Y == SAL_MAX_INT32 )) - continue; - - sal_Int32 nWindowRowCol = ( bHorzDockingArea ) ? aDockedPos.Y : aDockedPos.X; - if (( nDockedArea == eDockingArea ) && ( nWindowRowCol >= nRowCol )) - { - if ( bHorzDockingArea ) - aDockedPos.Y += 1; - else - aDockedPos.X += 1; - - Reference< XNameReplace > xReplace( xPersistentWindowState, UNO_QUERY ); - xReplace->replaceByName( aWindowElements[i], makeAny( aPropValueSeq )); - } - } - catch ( Exception& ) - { - } - } - } - } - catch ( Exception& ) - { - } - } -} - -::Size LayoutManager::implts_getTopBottomDockingAreaSizes() -{ - ::Size aSize; - Reference< css::awt::XWindow > xTopDockingAreaWindow; - Reference< css::awt::XWindow > xBottomDockingAreaWindow; - - ReadGuard aReadLock( m_aLock ); - xTopDockingAreaWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP]; - xBottomDockingAreaWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM]; - aReadLock.unlock(); - - if ( xTopDockingAreaWindow.is() ) - aSize.Width() = xTopDockingAreaWindow->getPosSize().Height; - if ( xBottomDockingAreaWindow.is() ) - aSize.Height() = xBottomDockingAreaWindow->getPosSize().Height; - - return aSize; + + return aContainerWinSize; } Reference< XUIElement > LayoutManager::implts_createElement( const rtl::OUString& aName ) { - Reference< ::com::sun::star::ui::XUIElement > xUIElement; + Reference< ui::XUIElement > xUIElement; ReadGuard aReadLock( m_aLock ); Sequence< PropertyValue > aPropSeq( 2 ); @@ -3054,124 +746,42 @@ Reference< XUIElement > LayoutManager::implts_createElement( const rtl::OUString { xUIElement = m_xUIElementFactoryManager->createUIElement( aName, aPropSeq ); } - catch ( NoSuchElementException& ) - { - } - catch ( IllegalArgumentException& ) - { - } + catch ( NoSuchElementException& ) {} + catch ( IllegalArgumentException& ) {} return xUIElement; } -Reference< css::awt::XWindowPeer > LayoutManager::implts_createToolkitWindow( const Reference< css::awt::XWindowPeer >& rParent ) -{ - Reference< css::awt::XWindowPeer > xPeer; - css::uno::Reference< css::awt::XToolkit > xToolkit( m_xSMGR->createInstance( SERVICENAME_VCLTOOLKIT ), css::uno::UNO_QUERY ); - if ( xToolkit.is() ) - { - // describe window properties. - css::awt::WindowDescriptor aDescriptor; - aDescriptor.Type = css::awt::WindowClass_SIMPLE ; - aDescriptor.WindowServiceName = DECLARE_ASCII("dockingarea") ; - aDescriptor.ParentIndex = -1 ; - aDescriptor.Parent = css::uno::Reference< css::awt::XWindowPeer >( rParent, UNO_QUERY ) ; - aDescriptor.Bounds = css::awt::Rectangle(0,0,0,0) ; - aDescriptor.WindowAttributes = 0 ; - - // create a docking area window - xPeer = xToolkit->createWindow( aDescriptor ); - } - - return xPeer; -} - void LayoutManager::implts_setVisibleState( sal_Bool bShow ) { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); - UIElementVector::iterator pIter; - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - pIter->m_bMasterHide = !bShow; m_aStatusBarElement.m_bMasterHide = !bShow; aWriteLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ implts_updateUIElementsVisibleState( bShow ); - //implts_doLayout( sal_False ); } void LayoutManager::implts_updateUIElementsVisibleState( sal_Bool bSetVisible ) { // notify listeners - css::uno::Any a; + uno::Any a; if ( bSetVisible ) - implts_notifyListeners( css::frame::LayoutManagerEvents::VISIBLE, a ); + implts_notifyListeners( frame::LayoutManagerEvents::VISIBLE, a ); else - implts_notifyListeners( css::frame::LayoutManagerEvents::INVISIBLE, a ); - std::vector< Reference< css::awt::XWindow > > aWinVector; - sal_Bool bOld; + implts_notifyListeners( frame::LayoutManagerEvents::INVISIBLE, a ); + std::vector< Reference< awt::XWindow > > aWinVector; - { - WriteGuard aWriteLock( m_aLock ); - m_bDoLayout = sal_True; - bOld = m_bDoLayout; - } - - ReadGuard aReadLock( m_aLock ); - aWinVector.reserve(m_aUIElements.size()); - UIElementVector::iterator pIter; - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - { - if ( pIter->m_xUIElement.is() ) - { - Reference< css::awt::XWindow > xWindow( pIter->m_xUIElement->getRealInterface(), UNO_QUERY ); - if ( xWindow.is() ) - { - if ( bSetVisible ) - { - if ( pIter->m_bVisible && !pIter->m_bMasterHide ) - aWinVector.push_back( xWindow ); - } - else - aWinVector.push_back( xWindow ); - } - } - } - - aReadLock.unlock(); - - try - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - const sal_uInt32 nCount = aWinVector.size(); - for ( sal_uInt32 i = 0; i < nCount; i++ ) - { - Reference< css::awt::XWindow > xWindow( aWinVector[i] ); - if ( xWindow.is() ) - { - // we need VCL here to pass special flags to Show() - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - if( pWindow ) - pWindow->Show( bSetVisible, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE ); - } - } - } - catch ( DisposedException& ) - { - } - - // Hide/show menubar according to bSetVisible - aReadLock.lock(); - Reference< XUIElement > xMenuBar( m_xMenuBar, UNO_QUERY ); - Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow ); - Reference< XComponent > xInplaceMenuBar( m_xInplaceMenuBar ); - MenuBarManager* pInplaceMenuBar( m_pInplaceMenuBar ); - aReadLock.unlock(); + WriteGuard aWriteLock( m_aLock ); + Reference< XUIElement > xMenuBar( m_xMenuBar, UNO_QUERY ); + Reference< awt::XWindow > xContainerWindow( m_xContainerWindow ); + Reference< XComponent > xInplaceMenuBar( m_xInplaceMenuBar ); + MenuBarManager* pInplaceMenuBar( m_pInplaceMenuBar ); + aWriteLock.unlock(); + bool bMustDoLayout(false); if (( xMenuBar.is() || xInplaceMenuBar.is() ) && xContainerWindow.is() ) { - vos::OGuard aGuard( Application::GetSolarMutex() ); + vos::OGuard aGuard( Application::GetSolarMutex() ); MenuBar* pMenuBar( 0 ); if ( xInplaceMenuBar.is() ) @@ -3182,103 +792,59 @@ void LayoutManager::implts_updateUIElementsVisibleState( sal_Bool bSetVisible ) pMenuBar = (MenuBar *)pMenuBarWrapper->GetMenuBarManager()->GetMenuBar(); } - Window* pWindow = VCLUnoHelper::GetWindow( xContainerWindow ); - while ( pWindow && !pWindow->IsSystemWindow() ) - pWindow = pWindow->GetParent(); - - if ( pWindow ) + SystemWindow* pSysWindow = getTopSystemWindow( xContainerWindow ); + if ( pSysWindow ) { - SystemWindow* pSysWindow = (SystemWindow *)pWindow; if ( bSetVisible ) pSysWindow->SetMenuBar( pMenuBar ); else pSysWindow->SetMenuBar( 0 ); + bMustDoLayout = true; } } // Hide/show the statusbar according to bSetVisible if ( bSetVisible ) - implts_showStatusBar(); + bMustDoLayout = !implts_showStatusBar(); else - implts_hideStatusBar(); + bMustDoLayout = !implts_hideStatusBar(); - if ( !bOld ) - { - WriteGuard aWriteLock( m_aLock ); - m_bDoLayout = sal_False; - } + aWriteLock.lock(); + uno::Reference< ui::XUIConfigurationListener > xThis( m_xToolbarManager ); + ToolbarLayoutManager* pToolbarManager( m_pToolbarManager ); + aWriteLock.unlock(); - if ( bSetVisible ) - { - implts_createNonContextSensitiveToolBars(); - implts_doLayout_notify( sal_False ); - } - else + if ( pToolbarManager ) { - // Set docking area window size to zero - ReadGuard aReadLock2( m_aLock ); - Reference< css::awt::XWindow > xTopDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP]; - Reference< css::awt::XWindow > xLeftDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT]; - Reference< css::awt::XWindow > xRightDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_RIGHT]; - Reference< css::awt::XWindow > xBottomDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM]; - aReadLock2.unlock(); - - try - { - if ( xTopDockingWindow.is() ) - xTopDockingWindow->setPosSize( 0, 0, 0, 0, css::awt::PosSize::POSSIZE ); - if ( xLeftDockingWindow.is() ) - xLeftDockingWindow->setPosSize( 0, 0, 0, 0, css::awt::PosSize::POSSIZE ); - if ( xRightDockingWindow.is() ) - xRightDockingWindow->setPosSize( 0, 0, 0, 0, css::awt::PosSize::POSSIZE ); - if ( xBottomDockingWindow.is() ) - xBottomDockingWindow->setPosSize( 0, 0, 0, 0, css::awt::PosSize::POSSIZE ); - - WriteGuard aWriteLock( m_aLock ); - m_aDockingArea = css::awt::Rectangle(); - m_bMustDoLayout = sal_True; - aWriteLock.unlock(); - } - catch ( Exception& ) - { - } + pToolbarManager->setVisible( bSetVisible ); + bMustDoLayout = pToolbarManager->isLayoutDirty(); } + + if ( bMustDoLayout ) + implts_doLayout_notify( sal_False ); } void LayoutManager::implts_setCurrentUIVisibility( sal_Bool bShow ) { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); - UIElementVector::iterator pIter; - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - { - if ( !bShow && pIter->m_bVisible && pIter->m_xUIElement.is() ) - pIter->m_bMasterHide = true; - else if ( bShow && pIter->m_bMasterHide ) - pIter->m_bMasterHide = false; - } - if ( !bShow && m_aStatusBarElement.m_bVisible && m_aStatusBarElement.m_xUIElement.is() ) m_aStatusBarElement.m_bMasterHide = true; else if ( bShow && m_aStatusBarElement.m_bVisible ) m_aStatusBarElement.m_bMasterHide = false; aWriteLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ implts_updateUIElementsVisibleState( bShow ); } void LayoutManager::implts_destroyStatusBar() { - Reference< XComponent > xCompStatusBar; + Reference< XComponent > xCompStatusBar; - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); m_aStatusBarElement.m_aName = rtl::OUString(); xCompStatusBar = Reference< XComponent >( m_aStatusBarElement.m_xUIElement, UNO_QUERY ); m_aStatusBarElement.m_xUIElement.clear(); aWriteLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ if ( xCompStatusBar.is() ) xCompStatusBar->dispose(); @@ -3288,7 +854,6 @@ void LayoutManager::implts_destroyStatusBar() void LayoutManager::implts_createStatusBar( const rtl::OUString& aStatusBarName ) { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); if ( !m_aStatusBarElement.m_xUIElement.is() ) { @@ -3296,14 +861,13 @@ void LayoutManager::implts_createStatusBar( const rtl::OUString& aStatusBarName m_aStatusBarElement.m_aName = aStatusBarName; m_aStatusBarElement.m_xUIElement = implts_createElement( aStatusBarName ); } + aWriteLock.unlock(); implts_createProgressBar(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ } void LayoutManager::implts_readStatusBarState( const rtl::OUString& rStatusBarName ) { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); if ( !m_aStatusBarElement.m_bStateRead ) { @@ -3311,17 +875,15 @@ void LayoutManager::implts_readStatusBarState( const rtl::OUString& rStatusBarNa if ( implts_readWindowStateData( rStatusBarName, m_aStatusBarElement )) m_aStatusBarElement.m_bStateRead = sal_True; } - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ } void LayoutManager::implts_createProgressBar() { - Reference< XUIElement > xStatusBar; + Reference< XUIElement > xStatusBar; Reference< XUIElement > xProgressBar; Reference< XUIElement > xProgressBarBackup; - Reference< css::awt::XWindow > xContainerWindow; + Reference< awt::XWindow > xContainerWindow; - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); xStatusBar = Reference< XUIElement >( m_aStatusBarElement.m_xUIElement, UNO_QUERY ); xProgressBar = Reference< XUIElement >( m_aProgressBarElement.m_xUIElement, UNO_QUERY ); @@ -3329,7 +891,6 @@ void LayoutManager::implts_createProgressBar() m_xProgressBarBackup.clear(); xContainerWindow = m_xContainerWindow; aWriteLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ sal_Bool bRecycled = xProgressBarBackup.is(); ProgressBarWrapper* pWrapper = 0; @@ -3342,14 +903,14 @@ void LayoutManager::implts_createProgressBar() if ( xStatusBar.is() ) { - Reference< css::awt::XWindow > xWindow( xStatusBar->getRealInterface(), UNO_QUERY ); + Reference< awt::XWindow > xWindow( xStatusBar->getRealInterface(), UNO_QUERY ); pWrapper->setStatusBar( xWindow ); } else { - Reference< css::awt::XWindow > xStatusBarWindow = pWrapper->getStatusBar(); + Reference< awt::XWindow > xStatusBarWindow = pWrapper->getStatusBar(); - vos::OGuard aGuard( Application::GetSolarMutex() ); + vos::OGuard aGuard( Application::GetSolarMutex() ); Window* pStatusBarWnd = VCLUnoHelper::GetWindow( xStatusBarWindow ); if ( !pStatusBarWnd ) { @@ -3357,7 +918,7 @@ void LayoutManager::implts_createProgressBar() if ( pWindow ) { StatusBar* pStatusBar = new StatusBar( pWindow, WinBits( WB_LEFT | WB_3DLOOK ) ); - Reference< css::awt::XWindow > xStatusBarWindow2( VCLUnoHelper::GetInterface( pStatusBar )); + Reference< awt::XWindow > xStatusBarWindow2( VCLUnoHelper::GetInterface( pStatusBar )); pWrapper->setStatusBar( xStatusBarWindow2, sal_True ); } } @@ -3394,7 +955,7 @@ void LayoutManager::implts_backupProgressBarWrapper() { ProgressBarWrapper* pWrapper = (ProgressBarWrapper*)m_xProgressBarBackup.get(); if ( pWrapper ) - pWrapper->setStatusBar( Reference< css::awt::XWindow >(), sal_False ); + pWrapper->setStatusBar( Reference< awt::XWindow >(), sal_False ); } // prevent us from dispose() the m_aProgressBarElement.m_xUIElement inside implts_reset() @@ -3415,9 +976,9 @@ void LayoutManager::implts_destroyProgressBar() void LayoutManager::implts_setStatusBarPosSize( const ::Point& rPos, const ::Size& rSize ) { - Reference< XUIElement > xStatusBar; + Reference< XUIElement > xStatusBar; Reference< XUIElement > xProgressBar; - Reference< css::awt::XWindow > xContainerWindow; + Reference< awt::XWindow > xContainerWindow; /* SAFE AREA ----------------------------------------------------------------------------------------------- */ ReadGuard aReadLock( m_aLock ); @@ -3425,9 +986,9 @@ void LayoutManager::implts_setStatusBarPosSize( const ::Point& rPos, const ::Siz xProgressBar = Reference< XUIElement >( m_aProgressBarElement.m_xUIElement, UNO_QUERY ); xContainerWindow = m_xContainerWindow; - Reference< css::awt::XWindow > xWindow; + Reference< awt::XWindow > xWindow; if ( xStatusBar.is() ) - xWindow = Reference< css::awt::XWindow >( xStatusBar->getRealInterface(), UNO_QUERY ); + xWindow = Reference< awt::XWindow >( xStatusBar->getRealInterface(), UNO_QUERY ); else if ( xProgressBar.is() ) { ProgressBarWrapper* pWrapper = (ProgressBarWrapper*)xProgressBar.get(); @@ -3439,7 +1000,7 @@ void LayoutManager::implts_setStatusBarPosSize( const ::Point& rPos, const ::Siz if ( xWindow.is() ) { - vos::OGuard aGuard( Application::GetSolarMutex() ); + vos::OGuard aGuard( Application::GetSolarMutex() ); Window* pParentWindow = VCLUnoHelper::GetWindow( xContainerWindow ); Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); if ( pParentWindow && ( pWindow && pWindow->GetType() == WINDOW_STATUSBAR )) @@ -3454,9 +1015,9 @@ void LayoutManager::implts_setStatusBarPosSize( const ::Point& rPos, const ::Siz sal_Bool LayoutManager::implts_showProgressBar() { - Reference< XUIElement > xStatusBar; + Reference< XUIElement > xStatusBar; Reference< XUIElement > xProgressBar; - Reference< css::awt::XWindow > xWindow; + Reference< awt::XWindow > xWindow; /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); @@ -3469,7 +1030,7 @@ sal_Bool LayoutManager::implts_showProgressBar() { if ( xStatusBar.is() && !m_aStatusBarElement.m_bMasterHide ) { - xWindow = Reference< css::awt::XWindow >( xStatusBar->getRealInterface(), UNO_QUERY ); + xWindow = Reference< awt::XWindow >( xStatusBar->getRealInterface(), UNO_QUERY ); } else if ( xProgressBar.is() ) { @@ -3479,13 +1040,15 @@ sal_Bool LayoutManager::implts_showProgressBar() } } aWriteLock.unlock(); + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - vos::OGuard aGuard( Application::GetSolarMutex() ); + vos::OGuard aGuard( Application::GetSolarMutex() ); Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); if ( pWindow ) { if ( !pWindow->IsVisible() ) { + implts_setOffset( pWindow->GetSizePixel().Height() ); pWindow->Show(); implts_doLayout_notify( sal_False ); } @@ -3498,7 +1061,7 @@ sal_Bool LayoutManager::implts_showProgressBar() sal_Bool LayoutManager::implts_hideProgressBar() { Reference< XUIElement > xProgressBar; - Reference< css::awt::XWindow > xWindow; + Reference< awt::XWindow > xWindow; sal_Bool bHideStatusBar( sal_False ); /* SAFE AREA ----------------------------------------------------------------------------------------------- */ @@ -3508,25 +1071,26 @@ sal_Bool LayoutManager::implts_hideProgressBar() sal_Bool bInternalStatusBar( sal_False ); if ( xProgressBar.is() ) { - Reference< css::awt::XWindow > xStatusBar; + Reference< awt::XWindow > xStatusBar; ProgressBarWrapper* pWrapper = (ProgressBarWrapper*)xProgressBar.get(); if ( pWrapper ) xWindow = pWrapper->getStatusBar(); - Reference< css::ui::XUIElement > xStatusBarElement = m_aStatusBarElement.m_xUIElement; + Reference< ui::XUIElement > xStatusBarElement = m_aStatusBarElement.m_xUIElement; if ( xStatusBarElement.is() ) - xStatusBar = Reference< css::awt::XWindow >( xStatusBarElement->getRealInterface(), UNO_QUERY ); + xStatusBar = Reference< awt::XWindow >( xStatusBarElement->getRealInterface(), UNO_QUERY ); bInternalStatusBar = xStatusBar != xWindow; } m_aProgressBarElement.m_bVisible = sal_False; implts_readStatusBarState( m_aStatusBarAlias ); bHideStatusBar = !m_aStatusBarElement.m_bVisible; aWriteLock.unlock(); + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - vos::OGuard aGuard( Application::GetSolarMutex() ); + vos::OGuard aGuard( Application::GetSolarMutex() ); Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - if ( pWindow && pWindow->IsVisible() && - ( bHideStatusBar || bInternalStatusBar )) + if ( pWindow && pWindow->IsVisible() && ( bHideStatusBar || bInternalStatusBar )) { + implts_setOffset( 0 ); pWindow->Hide(); implts_doLayout_notify( sal_False ); return sal_True; @@ -3537,23 +1101,23 @@ sal_Bool LayoutManager::implts_hideProgressBar() sal_Bool LayoutManager::implts_showStatusBar( sal_Bool bStoreState ) { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); - Reference< css::ui::XUIElement > xStatusBar = m_aStatusBarElement.m_xUIElement; + Reference< ui::XUIElement > xStatusBar = m_aStatusBarElement.m_xUIElement; if ( bStoreState ) m_aStatusBarElement.m_bVisible = sal_True; aWriteLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ if ( xStatusBar.is() ) { - Reference< css::awt::XWindow > xWindow( xStatusBar->getRealInterface(), UNO_QUERY ); + Reference< awt::XWindow > xWindow( xStatusBar->getRealInterface(), UNO_QUERY ); - vos::OGuard aGuard( Application::GetSolarMutex() ); + vos::OGuard aGuard( Application::GetSolarMutex() ); Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); if ( pWindow && !pWindow->IsVisible() ) { + implts_setOffset( pWindow->GetSizePixel().Height() ); pWindow->Show(); + implts_doLayout_notify( sal_False ); return sal_True; } } @@ -3563,23 +1127,23 @@ sal_Bool LayoutManager::implts_showStatusBar( sal_Bool bStoreState ) sal_Bool LayoutManager::implts_hideStatusBar( sal_Bool bStoreState ) { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); - Reference< css::ui::XUIElement > xStatusBar = m_aStatusBarElement.m_xUIElement; + Reference< ui::XUIElement > xStatusBar = m_aStatusBarElement.m_xUIElement; if ( bStoreState ) m_aStatusBarElement.m_bVisible = sal_False; aWriteLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ if ( xStatusBar.is() ) { - Reference< css::awt::XWindow > xWindow( xStatusBar->getRealInterface(), UNO_QUERY ); + Reference< awt::XWindow > xWindow( xStatusBar->getRealInterface(), UNO_QUERY ); - vos::OGuard aGuard( Application::GetSolarMutex() ); + vos::OGuard aGuard( Application::GetSolarMutex() ); Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); if ( pWindow && pWindow->IsVisible() ) { + implts_setOffset( 0 ); pWindow->Hide(); + implts_doLayout_notify( sal_False ); return sal_True; } } @@ -3587,15 +1151,27 @@ sal_Bool LayoutManager::implts_hideStatusBar( sal_Bool bStoreState ) return sal_False; } +void LayoutManager::implts_setOffset( const sal_Int32 nBottomOffset ) +{ + ::Rectangle aOffsetRect; + setZeroRectangle( aOffsetRect ); + aOffsetRect.setHeight( nBottomOffset ); + + // make sure that the toolbar manager refernence/pointer is valid + uno::Reference< ui::XUIConfigurationListener > xThis( m_xToolbarManager ); + if ( xThis.is() ) + m_pToolbarManager->setDockingAreaOffsets( aOffsetRect ); +} + void LayoutManager::implts_setInplaceMenuBar( const Reference< XIndexAccess >& xMergedMenuBar ) -throw (::com::sun::star::uno::RuntimeException) +throw (uno::RuntimeException) { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); - if ( !m_bInplaceMenuSet ) - { - vos::OGuard aGuard( Application::GetSolarMutex() ); + if ( !m_bInplaceMenuSet ) + { + vos::OGuard aGuard( Application::GetSolarMutex() ); // Reset old inplace menubar! m_pInplaceMenuBar = 0; @@ -3604,8 +1180,7 @@ throw (::com::sun::star::uno::RuntimeException) m_xInplaceMenuBar.clear(); m_bInplaceMenuSet = sal_False; - if ( m_xFrame.is() && - m_xContainerWindow.is() ) + if ( m_xFrame.is() && m_xContainerWindow.is() ) { rtl::OUString aModuleIdentifier; Reference< XDispatchProvider > xDispatchProvider; @@ -3614,50 +1189,40 @@ throw (::com::sun::star::uno::RuntimeException) m_pInplaceMenuBar = new MenuBarManager( m_xSMGR, m_xFrame, m_xURLTransformer,xDispatchProvider, aModuleIdentifier, pMenuBar, sal_True, sal_True ); m_pInplaceMenuBar->SetItemContainer( xMergedMenuBar ); - Window* pWindow = VCLUnoHelper::GetWindow( m_xContainerWindow ); - while ( pWindow && !pWindow->IsSystemWindow() ) - pWindow = pWindow->GetParent(); + SystemWindow* pSysWindow = getTopSystemWindow( m_xContainerWindow ); + if ( pSysWindow ) + pSysWindow->SetMenuBar( pMenuBar ); - if ( pWindow ) - { - SystemWindow* pSysWindow = (SystemWindow *)pWindow; - pSysWindow->SetMenuBar( pMenuBar ); - } - - m_bInplaceMenuSet = sal_True; + m_bInplaceMenuSet = sal_True; m_xInplaceMenuBar = Reference< XComponent >( (OWeakObject *)m_pInplaceMenuBar, UNO_QUERY ); } aWriteLock.unlock(); /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + implts_updateMenuBarClose(); } - } void LayoutManager::implts_resetInplaceMenuBar() -throw (::com::sun::star::uno::RuntimeException) +throw (uno::RuntimeException) { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); m_bInplaceMenuSet = sal_False; // if ( m_xMenuBar.is() && if ( m_xContainerWindow.is() ) { - vos::OGuard aGuard( Application::GetSolarMutex() ); + vos::OGuard aGuard( Application::GetSolarMutex() ); MenuBarWrapper* pMenuBarWrapper = SAL_STATIC_CAST( MenuBarWrapper*, m_xMenuBar.get() ); - Window* pWindow = VCLUnoHelper::GetWindow( m_xContainerWindow ); - while ( pWindow && !pWindow->IsSystemWindow() ) - pWindow = pWindow->GetParent(); - - if ( pWindow ) + SystemWindow* pSysWindow = getTopSystemWindow( m_xContainerWindow ); + if ( pSysWindow ) { - SystemWindow* pSysWindow = (SystemWindow *)pWindow; if ( pMenuBarWrapper ) - pSysWindow->SetMenuBar( (MenuBar *)pMenuBarWrapper->GetMenuBarManager()->GetMenuBar() ); - else - pSysWindow->SetMenuBar( 0 ); + pSysWindow->SetMenuBar( (MenuBar *)pMenuBarWrapper->GetMenuBarManager()->GetMenuBar() ); + else + pSysWindow->SetMenuBar( 0 ); } } @@ -3666,21 +1231,14 @@ throw (::com::sun::star::uno::RuntimeException) if ( m_xInplaceMenuBar.is() ) m_xInplaceMenuBar->dispose(); m_xInplaceMenuBar.clear(); - - aWriteLock.unlock(); /* SAFE AREA ----------------------------------------------------------------------------------------------- */ } void SAL_CALL LayoutManager::attachFrame( const Reference< XFrame >& xFrame ) -throw (::com::sun::star::uno::RuntimeException) +throw (uno::RuntimeException) { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); m_xFrame = xFrame; - aWriteLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - // if ( xFrame.is() ) - // xFrame->getContainerWindow()->addWindowListener( Reference< css::awt::XWindowListener >( static_cast< OWeakObject* >( this ), UNO_QUERY )); } void SAL_CALL LayoutManager::reset() @@ -3688,7 +1246,6 @@ throw (RuntimeException) { sal_Bool bComponentAttached( sal_False ); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ ReadGuard aReadLock( m_aLock ); bComponentAttached = m_bComponentAttached; aReadLock.unlock(); @@ -3697,13 +1254,13 @@ throw (RuntimeException) } void SAL_CALL LayoutManager::setInplaceMenuBar( sal_Int64 ) -throw (::com::sun::star::uno::RuntimeException) +throw (uno::RuntimeException) { OSL_ENSURE( sal_False, "This method is obsolete and should not be used!\n" ); } void SAL_CALL LayoutManager::resetInplaceMenuBar() -throw (::com::sun::star::uno::RuntimeException) +throw (uno::RuntimeException) { OSL_ENSURE( sal_False, "This method is obsolete and should not be used!\n" ); } @@ -3713,45 +1270,42 @@ throw (::com::sun::star::uno::RuntimeException) //--------------------------------------------------------------------------------------------------------- sal_Bool SAL_CALL LayoutManager::setMergedMenuBar( const Reference< XIndexAccess >& xMergedMenuBar ) -throw (::com::sun::star::uno::RuntimeException) +throw (uno::RuntimeException) { implts_setInplaceMenuBar( xMergedMenuBar ); - css::uno::Any a; - implts_notifyListeners( css::frame::LayoutManagerEvents::MERGEDMENUBAR, a ); + uno::Any a; + implts_notifyListeners( frame::LayoutManagerEvents::MERGEDMENUBAR, a ); return sal_True; } void SAL_CALL LayoutManager::removeMergedMenuBar() -throw (::com::sun::star::uno::RuntimeException) +throw (uno::RuntimeException) { implts_resetInplaceMenuBar(); } -::com::sun::star::awt::Rectangle SAL_CALL LayoutManager::getCurrentDockingArea() +awt::Rectangle SAL_CALL LayoutManager::getCurrentDockingArea() throw ( RuntimeException ) { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ ReadGuard aReadLock( m_aLock ); return m_aDockingArea; } Reference< XDockingAreaAcceptor > SAL_CALL LayoutManager::getDockingAreaAcceptor() -throw (::com::sun::star::uno::RuntimeException) +throw (uno::RuntimeException) { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ ReadGuard aReadLock( m_aLock ); return m_xDockingAreaAcceptor; } -void SAL_CALL LayoutManager::setDockingAreaAcceptor( const Reference< ::com::sun::star::ui::XDockingAreaAcceptor >& xDockingAreaAcceptor ) +void SAL_CALL LayoutManager::setDockingAreaAcceptor( const Reference< ui::XDockingAreaAcceptor >& xDockingAreaAcceptor ) throw ( RuntimeException ) { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); - if (( m_xDockingAreaAcceptor == xDockingAreaAcceptor ) || - !m_xFrame.is() ) + if (( m_xDockingAreaAcceptor == xDockingAreaAcceptor ) || !m_xFrame.is() ) return; // IMPORTANT: Be sure to stop layout timer if don't have a docking area acceptor! @@ -3759,7 +1313,10 @@ throw ( RuntimeException ) m_aAsyncLayoutTimer.Stop(); sal_Bool bAutomaticToolbars( m_bAutomaticToolbars ); - std::vector< Reference< css::awt::XWindow > > oldDockingAreaWindows; + std::vector< Reference< awt::XWindow > > oldDockingAreaWindows; + + uno::Reference< ui::XUIConfigurationListener > xToolbarManager( m_xToolbarManager ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; if ( !xDockingAreaAcceptor.is() ) m_aAsyncLayoutTimer.Stop(); @@ -3767,45 +1324,31 @@ throw ( RuntimeException ) // Remove listener from old docking area acceptor if ( m_xDockingAreaAcceptor.is() ) { - Reference< css::awt::XWindow > xWindow( m_xDockingAreaAcceptor->getContainerWindow() ); + Reference< awt::XWindow > xWindow( m_xDockingAreaAcceptor->getContainerWindow() ); if ( xWindow.is() && ( m_xFrame->getContainerWindow() != m_xContainerWindow || !xDockingAreaAcceptor.is() ) ) - xWindow->removeWindowListener( Reference< css::awt::XWindowListener >( static_cast< OWeakObject * >( this ), UNO_QUERY )); - - oldDockingAreaWindows.push_back( m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP] ); - oldDockingAreaWindows.push_back( m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM] ); - oldDockingAreaWindows.push_back( m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT] ); - oldDockingAreaWindows.push_back( m_xDockAreaWindows[DockingArea_DOCKINGAREA_RIGHT] ); + xWindow->removeWindowListener( Reference< awt::XWindowListener >( static_cast< OWeakObject * >( this ), UNO_QUERY )); - m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP].clear(); - m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM].clear(); - m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT].clear(); - m_xDockAreaWindows[DockingArea_DOCKINGAREA_RIGHT].clear(); - m_aDockingArea = css::awt::Rectangle(); + m_aDockingArea = awt::Rectangle(); + if ( pToolbarManager ) + pToolbarManager->resetDockingArea(); Window* pContainerWindow = VCLUnoHelper::GetWindow( xWindow ); if ( pContainerWindow ) pContainerWindow->RemoveChildEventListener( LINK( this, LayoutManager, WindowEventListener ) ); } - // Set new docking area acceptor and add ourself as window listener on the container window. - // Create our docking area windows which are parents for all docked windows. - css::uno::Reference< css::awt::XWindow > xTopDockWindow; - css::uno::Reference< css::awt::XWindow > xBottomDockWindow; - css::uno::Reference< css::awt::XWindow > xLeftDockWindow; - css::uno::Reference< css::awt::XWindow > xRightDockWindow; - - Reference< ::com::sun::star::ui::XDockingAreaAcceptor > xOldDockingAreaAcceptor( m_xDockingAreaAcceptor ); + Reference< ui::XDockingAreaAcceptor > xOldDockingAreaAcceptor( m_xDockingAreaAcceptor ); m_xDockingAreaAcceptor = xDockingAreaAcceptor; if ( m_xDockingAreaAcceptor.is() ) { - m_aDockingArea = css::awt::Rectangle(); + m_aDockingArea = awt::Rectangle(); m_xContainerWindow = m_xDockingAreaAcceptor->getContainerWindow(); m_xContainerTopWindow.set( m_xContainerWindow, UNO_QUERY ); - m_xContainerWindow->addWindowListener( Reference< css::awt::XWindowListener >( static_cast< OWeakObject* >( this ), UNO_QUERY )); + m_xContainerWindow->addWindowListener( Reference< awt::XWindowListener >( static_cast< OWeakObject* >( this ), UNO_QUERY )); // we always must keep a connection to the window of our frame for resize events if ( m_xContainerWindow != m_xFrame->getContainerWindow() ) - m_xFrame->getContainerWindow()->addWindowListener( Reference< css::awt::XWindowListener >( static_cast< OWeakObject* >( this ), UNO_QUERY )); + m_xFrame->getContainerWindow()->addWindowListener( Reference< awt::XWindowListener >( static_cast< OWeakObject* >( this ), UNO_QUERY )); // #i37884# set initial visibility state - in the plugin case the container window is already shown // and we get no notification anymore @@ -3816,32 +1359,15 @@ throw ( RuntimeException ) m_bParentWindowVisible = pContainerWindow->IsVisible(); } - css::uno::Reference< css::awt::XWindowPeer > xParent( m_xContainerWindow, UNO_QUERY ); - xTopDockWindow = Reference< css::awt::XWindow >( implts_createToolkitWindow( xParent ), UNO_QUERY ); - xBottomDockWindow = Reference< css::awt::XWindow >( implts_createToolkitWindow( xParent ), UNO_QUERY ); - xLeftDockWindow = Reference< css::awt::XWindow >( implts_createToolkitWindow( xParent ), UNO_QUERY ); - xRightDockWindow = Reference< css::awt::XWindow >( implts_createToolkitWindow( xParent ), UNO_QUERY ); - m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP] = xTopDockWindow; - m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM] = xBottomDockWindow; - m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT] = xLeftDockWindow; - m_xDockAreaWindows[DockingArea_DOCKINGAREA_RIGHT] = xRightDockWindow; + uno::Reference< awt::XWindowPeer > xParent( m_xContainerWindow, UNO_QUERY ); } aWriteLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ if ( xDockingAreaAcceptor.is() ) { - vos::OGuard aGuard( Application::GetSolarMutex() ); - ::DockingAreaWindow* pWindow; - pWindow = dynamic_cast< ::DockingAreaWindow* >(VCLUnoHelper::GetWindow( xTopDockWindow ) ); - if( pWindow ) pWindow->SetAlign( WINDOWALIGN_TOP ); - pWindow = dynamic_cast< ::DockingAreaWindow* >(VCLUnoHelper::GetWindow( xBottomDockWindow ) ); - if( pWindow ) pWindow->SetAlign( WINDOWALIGN_BOTTOM ); - pWindow = dynamic_cast< ::DockingAreaWindow* >(VCLUnoHelper::GetWindow( xLeftDockWindow ) ); - if( pWindow ) pWindow->SetAlign( WINDOWALIGN_LEFT ); - pWindow = dynamic_cast< ::DockingAreaWindow* >(VCLUnoHelper::GetWindow( xRightDockWindow ) ); - if( pWindow ) pWindow->SetAlign( WINDOWALIGN_RIGHT ); + vos::OGuard aGuard( Application::GetSolarMutex() ); // Add layout manager as listener to get notifications about toolbar button activties Window* pContainerWindow = VCLUnoHelper::GetWindow( m_xContainerWindow ); @@ -3856,23 +1382,8 @@ throw ( RuntimeException ) if ( !oldDockingAreaWindows.empty() ) { - const sal_uInt32 nCount = oldDockingAreaWindows.size(); - for ( sal_uInt32 i = 0; i < nCount; ++i ) - { - if ( oldDockingAreaWindows[i].is() ) - { - try - { - oldDockingAreaWindows[i]->dispose(); - } - catch ( Exception& ) - { - } - } - } - // Reset docking area size for our old docking area acceptor - css::awt::Rectangle aEmptyRect; + awt::Rectangle aEmptyRect; xOldDockingAreaAcceptor->setDockingAreaSpace( aEmptyRect ); } @@ -3880,201 +1391,77 @@ throw ( RuntimeException ) { if ( bAutomaticToolbars ) { - implts_createAddonsToolBars(); // create addon toolbars - implts_createCustomToolBars(); // create custom toolbars - implts_createNonContextSensitiveToolBars(); + lock(); + pToolbarManager->createStaticToolbars(); + unlock(); } - implts_sortUIElements(); implts_doLayout( sal_True, sal_False ); } } void LayoutManager::implts_reparentChildWindows() { - UIElementVector aUIElementVector; - UIElement aStatusBarElement; - css::uno::Reference< css::awt::XWindow > xTopDockWindow; - css::uno::Reference< css::awt::XWindow > xBottomDockWindow; - css::uno::Reference< css::awt::XWindow > xLeftDockWindow; - css::uno::Reference< css::awt::XWindow > xRightDockWindow; - css::uno::Reference< css::awt::XWindow > xContainerWindow; - css::uno::Reference< css::awt::XWindow > xStatusBarWindow; - WriteGuard aWriteLock( m_aLock ); - aUIElementVector = m_aUIElements; - xTopDockWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP]; - xBottomDockWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM]; - xLeftDockWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT]; - xRightDockWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_RIGHT]; - xContainerWindow = m_xContainerWindow; - aStatusBarElement = m_aStatusBarElement; + UIElement aStatusBarElement = m_aStatusBarElement; + uno::Reference< awt::XWindow > xContainerWindow = m_xContainerWindow; aWriteLock.unlock(); + uno::Reference< awt::XWindow > xStatusBarWindow; if ( aStatusBarElement.m_xUIElement.is() ) { try { - xStatusBarWindow = Reference< css::awt::XWindow >( - aStatusBarElement.m_xUIElement->getRealInterface(), - UNO_QUERY ); - } - catch ( RuntimeException& ) - { - throw; - } - catch ( Exception& ) - { + xStatusBarWindow = Reference< awt::XWindow >( aStatusBarElement.m_xUIElement->getRealInterface(), UNO_QUERY ); } + catch ( RuntimeException& ) { throw; } + catch ( Exception& ) {} } - - vos::OGuard aGuard( Application::GetSolarMutex() ); - Window* pContainerWindow = VCLUnoHelper::GetWindow( xContainerWindow ); - Window* pTopDockWindow = VCLUnoHelper::GetWindow( xTopDockWindow ); - Window* pBottomDockWindow = VCLUnoHelper::GetWindow( xBottomDockWindow ); - Window* pLeftDockWindow = VCLUnoHelper::GetWindow( xLeftDockWindow ); - Window* pRightDockWindow = VCLUnoHelper::GetWindow( xRightDockWindow ); - if ( pContainerWindow ) + + if ( xStatusBarWindow.is() ) { - UIElementVector::iterator pIter; - for ( pIter = aUIElementVector.begin(); pIter != aUIElementVector.end(); pIter++ ) - { - Reference< XUIElement > xUIElement( pIter->m_xUIElement ); - if ( xUIElement.is() ) - { - Reference< css::awt::XWindow > xWindow; - try - { - // We have to retreive the window reference with try/catch as it is - // possible that all elements has been disposed! - xWindow = Reference< css::awt::XWindow >( xUIElement->getRealInterface(), UNO_QUERY ); - } - catch ( RuntimeException& ) - { - throw; - } - catch ( Exception& ) - { - } - - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - if ( pWindow ) - { - // Reparent our child windows acording to their current state. - if ( pIter->m_bFloating ) - pWindow->SetParent( pContainerWindow ); - else - { - if ( pIter->m_aDockedData.m_nDockedArea == DockingArea_DOCKINGAREA_TOP ) - pWindow->SetParent( pTopDockWindow ); - else if ( pIter->m_aDockedData.m_nDockedArea == DockingArea_DOCKINGAREA_BOTTOM ) - pWindow->SetParent( pBottomDockWindow ); - else if ( pIter->m_aDockedData.m_nDockedArea == DockingArea_DOCKINGAREA_LEFT ) - pWindow->SetParent( pLeftDockWindow ); - else - pWindow->SetParent( pRightDockWindow ); - } - } - } - } + vos::OGuard aGuard( Application::GetSolarMutex() ); + Window* pContainerWindow = VCLUnoHelper::GetWindow( xContainerWindow ); + Window* pWindow = VCLUnoHelper::GetWindow( xStatusBarWindow ); + if ( pWindow && pContainerWindow ) + pWindow->SetParent( pContainerWindow ); + } - if ( xStatusBarWindow.is() ) - { - Window* pWindow = VCLUnoHelper::GetWindow( xStatusBarWindow ); - if ( pWindow ) - pWindow->SetParent( pContainerWindow ); - } + implts_resetMenuBar(); + + aWriteLock.lock(); + uno::Reference< ui::XUIConfigurationListener > xToolbarManager( m_xToolbarManager ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + if ( pToolbarManager ) + pToolbarManager->setParentWindow( uno::Reference< awt::XWindowPeer >( xContainerWindow, uno::UNO_QUERY )); + aWriteLock.unlock(); +} - implts_resetMenuBar(); - } +uno::Reference< ui::XUIElement > LayoutManager::implts_createDockingWindow( const ::rtl::OUString& aElementName ) +{ + Reference< XUIElement > xUIElement = implts_createElement( aElementName ); + return xUIElement; } IMPL_LINK( LayoutManager, WindowEventListener, VclSimpleEvent*, pEvent ) { - // To enable toolbar controllers to change their image when a sub-toolbar function - // is activated, we need this mechanism. We have NO connection between these toolbars - // anymore! + long nResult( 1 ); + if ( pEvent && pEvent->ISA( VclWindowEvent )) { - if ( pEvent->GetId() == VCLEVENT_TOOLBOX_SELECT ) - { - Window* pWindow( ((VclWindowEvent*)pEvent)->GetWindow() ); - ToolBox* pToolBox( 0 ); - rtl::OUString aToolbarName; - rtl::OUString aCommand; - - if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX ) - { - pToolBox = (ToolBox *)pWindow; - aToolbarName = rtl::OStringToOUString( pToolBox->GetHelpId(), RTL_TEXTENCODING_UTF8 ); - sal_Int32 i = aToolbarName.lastIndexOf( ':' ); - if (( aToolbarName.getLength() > 0 ) && - ( i > 0 ) && (( i+ 1 ) < aToolbarName.getLength() )) - { - // Remove ".HelpId:" protocol from toolbar name - aToolbarName = aToolbarName.copy( i+1 ); - - USHORT nId = pToolBox->GetCurItemId(); - if ( nId > 0 ) - aCommand = pToolBox->GetItemCommand( nId ); - } - } - - if (( aToolbarName.getLength() > 0 ) && ( aCommand.getLength() > 0 )) - { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - ReadGuard aReadLock( m_aLock ); - std::vector< css::uno::Reference< css::ui::XUIFunctionListener > > aListenerArray; - UIElementVector::iterator pIter; - - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - { - if ( pIter->m_aType.equalsAscii( "toolbar" ) && - pIter->m_xUIElement.is() ) - { - css::uno::Reference< css::ui::XUIFunctionListener > xListener( pIter->m_xUIElement, UNO_QUERY ); - if ( xListener.is() ) - aListenerArray.push_back( xListener ); - } - } - aReadLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - - const sal_uInt32 nCount = aListenerArray.size(); - for ( sal_uInt32 i = 0; i < nCount; ++i ) - { - try - { - aListenerArray[i]->functionExecute( aToolbarName, aCommand ); - } - catch ( RuntimeException& e ) - { - throw e; - } - catch ( Exception& ) {} - } - } - } - else if ( pEvent->GetId() == VCLEVENT_TOOLBOX_FORMATCHANGED ) + Window* pWindow = static_cast< VclWindowEvent* >(pEvent)->GetWindow(); + if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX ) { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ ReadGuard aReadLock( m_aLock ); + uno::Reference< ui::XUIConfigurationListener > xThis( m_xToolbarManager ); + ToolbarLayoutManager* pToolbarManager( m_pToolbarManager ); + aReadLock.unlock(); - Window* pWindow( ((VclWindowEvent*)pEvent)->GetWindow() ); - ToolBox* pToolBox( 0 ); - rtl::OUString aToolbarName; - - if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX ) - { - pToolBox = (ToolBox *)pWindow; - aToolbarName = rtl::OStringToOUString( pToolBox->GetHelpId(), RTL_TEXTENCODING_UTF8 ); - if (( aToolbarName.getLength() > 0 ) && ( m_nLockCount == 0 )) - m_aAsyncLayoutTimer.Start(); - } - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + if ( pToolbarManager ) + nResult = pToolbarManager->childWindowEvent( pEvent ); } } - return 1; + return nResult; } void SAL_CALL LayoutManager::createElement( const ::rtl::OUString& aName ) @@ -4082,13 +1469,11 @@ throw (RuntimeException) { RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::LayoutManager::createElement" ); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ ReadGuard aReadLock( m_aLock ); Reference< XFrame > xFrame = m_xFrame; Reference< XURLTransformer > xURLTransformer = m_xURLTransformer; sal_Bool bInPlaceMenu = m_bInplaceMenuSet; aReadLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ if ( !xFrame.is() ) return; @@ -4098,105 +1483,35 @@ throw (RuntimeException) /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); - sal_Bool bFound( sal_False ); - sal_Bool bNotify( sal_False ); - ::rtl::OUString aElementType; - ::rtl::OUString aElementName; - Reference< ::com::sun::star::ui::XUIElement > xUIElement; - - implts_findElement( aName, aElementType, aElementName, xUIElement ); - bFound = xUIElement.is(); - - if ( /*xFrame.is() && */m_xContainerWindow.is() && !implts_isPreviewModel( xModel ) ) // no bars on preview mode + bool bMustBeLayouted( false ); + bool bNotify( false ); + + if ( m_xContainerWindow.is() && !implts_isPreviewModel( xModel ) ) // no UI elements on preview frames { - if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" )) - { - if ( !bFound ) - { - SvtCommandOptions aCmdOptions; - - xUIElement = implts_createElement( aName ); - sal_Bool bVisible( sal_False ); - if ( xUIElement.is() ) - { - Reference< css::awt::XWindow > xWindow( xUIElement->getRealInterface(), UNO_QUERY ); - Reference< css::awt::XDockableWindow > xDockWindow( xUIElement->getRealInterface(), UNO_QUERY ); - if ( xDockWindow.is() && xWindow.is() ) - { - try - { - xDockWindow->addDockableWindowListener( Reference< css::awt::XDockableWindowListener >( - static_cast< OWeakObject * >( this ), UNO_QUERY )); - xWindow->addWindowListener( Reference< css::awt::XWindowListener >( - static_cast< OWeakObject * >( this ), UNO_QUERY )); - xDockWindow->enableDocking( sal_True ); - } - catch ( Exception& ) - { - } - } - - UIElement& rElement = impl_findElement( aName ); - if ( rElement.m_aName.getLength() > 0 ) - { - // Reuse a local entry so we are able to use the latest - // UI changes for this document. - implts_setElementData( rElement, xDockWindow ); - rElement.m_xUIElement = xUIElement; - bVisible = rElement.m_bVisible; - } - else - { - // Create new UI element and try to read its state data - UIElement aNewToolbar( aName, aElementType, xUIElement ); - implts_readWindowStateData( aName, aNewToolbar ); - implts_setElementData( aNewToolbar, xDockWindow ); - implts_insertUIElement( aNewToolbar ); - bVisible = aNewToolbar.m_bVisible; - } - - // set toolbar menu style according to customize command state - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX ) - { - ToolBox* pToolbar = (ToolBox *)pWindow; - USHORT nMenuType = pToolbar->GetMenuType(); - if ( aCmdOptions.Lookup( SvtCommandOptions::CMDOPTION_DISABLED, m_aCustomizeCmd )) - pToolbar->SetMenuType( nMenuType & ~TOOLBOX_MENUTYPE_CUSTOMIZE ); - else - pToolbar->SetMenuType( nMenuType | TOOLBOX_MENUTYPE_CUSTOMIZE ); - } - } - aWriteLock.unlock(); + ::rtl::OUString aElementType; + ::rtl::OUString aElementName; - implts_sortUIElements(); + parseResourceURL( aName, aElementType, aElementName ); - if ( bVisible ) - { - doLayout(); - bNotify = sal_True; - } - } + if ( aElementType.equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR ) && m_pToolbarManager != NULL ) + { + bNotify = m_pToolbarManager->createToolbar( aName ); + bMustBeLayouted = m_pToolbarManager->isLayoutDirty(); } - else if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" )) + else if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "menubar" )) { - if ( aElementName.equalsIgnoreAsciiCaseAscii( "menubar" ) && !bInPlaceMenu ) - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - // PB 2004-12-15 #i38743# don't create a menubar if frame isn't top - if ( !m_xMenuBar.is() && implts_isFrameOrWindowTop(xFrame) ) - m_xMenuBar = implts_createElement( aName ); - - if ( m_xMenuBar.is() && implts_isFrameOrWindowTop(xFrame) ) + // PB 2004-12-15 #i38743# don't create a menubar if frame isn't top + if ( !bInPlaceMenu && !m_xMenuBar.is() && implts_isFrameOrWindowTop( xFrame )) { - Window* pWindow = VCLUnoHelper::GetWindow( m_xContainerWindow ); - while ( pWindow && !pWindow->IsSystemWindow() ) - pWindow = pWindow->GetParent(); - - if ( pWindow ) + m_xMenuBar = implts_createElement( aName ); + if ( m_xMenuBar.is() ) + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + + SystemWindow* pSysWindow = getTopSystemWindow( m_xContainerWindow ); + if ( pSysWindow ) { - SystemWindow* pSysWindow = (SystemWindow *)pWindow; - Reference< css::awt::XMenuBar > xMenuBar; + Reference< awt::XMenuBar > xMenuBar; Reference< XPropertySet > xPropSet( m_xMenuBar, UNO_QUERY ); if ( xPropSet.is() ) @@ -4205,12 +1520,8 @@ throw (RuntimeException) { xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "XMenuBar" ))) >>= xMenuBar; } - catch ( com::sun::star::beans::UnknownPropertyException ) - { - } - catch ( com::sun::star::lang::WrappedTargetException ) - { - } + catch ( beans::UnknownPropertyException ) {} + catch ( lang::WrappedTargetException ) {} } if ( xMenuBar.is() ) @@ -4224,9 +1535,7 @@ throw (RuntimeException) pSysWindow->SetMenuBar( pMenuBar ); pMenuBar->SetDisplayable( m_bMenuVisible ); if ( m_bMenuVisible ) - { bNotify = sal_True; - } implts_updateMenuBarClose(); } } @@ -4241,27 +1550,35 @@ throw (RuntimeException) implts_createStatusBar( aName ); bNotify = sal_True; } - else if ( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) && - aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" ) && - implts_isFrameOrWindowTop(xFrame) ) + else if ( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" ) && implts_isFrameOrWindowTop(xFrame) ) { implts_createProgressBar(); bNotify = sal_True; } else if ( aElementType.equalsIgnoreAsciiCaseAscii( "dockingwindow" )) { - aWriteLock.unlock(); - + // Add layout manager as listener for docking and other window events + uno::Reference< uno::XInterface > xThis( static_cast< OWeakObject* >(this), uno::UNO_QUERY ); + uno::Reference< ui::XUIElement > xUIElement( implts_createDockingWindow( aName )); + + if ( xUIElement.is() ) + { + impl_addWindowListeners( xThis, xUIElement ); + m_pPanelManager->addDockingWindow( aName, xUIElement ); + } + // The docking window is created by a factory method located in the sfx2 library. - CreateDockingWindow( xFrame, aElementName ); +// CreateDockingWindow( xFrame, aElementName ); } } - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + if ( bMustBeLayouted ) + implts_doLayout_notify( sal_True ); + if ( bNotify ) { // UI element is invisible - provide information to listeners - implts_notifyListeners( css::frame::LayoutManagerEvents::UIELEMENT_VISIBLE, uno::makeAny( aName ) ); + implts_notifyListeners( frame::LayoutManagerEvents::UIELEMENT_VISIBLE, uno::makeAny( aName ) ); } } @@ -4273,112 +1590,54 @@ throw (RuntimeException) /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); - sal_Bool bMustLayouted( sal_False ); - sal_Bool bMustBeDestroyed( sal_False ); - sal_Bool bMustBeSorted( sal_False ); - sal_Bool bNotify( sal_False ); - ::rtl::OUString aElementType; - ::rtl::OUString aElementName; + bool bMustBeLayouted( sal_False ); + bool bMustBeDestroyed( sal_False ); + bool bNotify( sal_False ); + ::rtl::OUString aElementType; + ::rtl::OUString aElementName; Reference< XComponent > xComponent; - if ( impl_parseResourceURL( aName, aElementType, aElementName )) + parseResourceURL( aName, aElementType, aElementName ); + + if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "menubar" )) { - if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" ) && - aElementName.equalsIgnoreAsciiCaseAscii( "menubar" )) + if ( !m_bInplaceMenuSet ) { - if ( !m_bInplaceMenuSet ) - { - impl_clearUpMenuBar(); - m_xMenuBar.clear(); - bNotify = sal_True; - } + impl_clearUpMenuBar(); + m_xMenuBar.clear(); + bNotify = true; } - else if (( aElementType.equalsIgnoreAsciiCaseAscii( "statusbar" ) && - aElementName.equalsIgnoreAsciiCaseAscii( "statusbar" )) || - ( m_aStatusBarElement.m_aName == aName )) - { - aWriteLock.unlock(); - implts_destroyStatusBar(); - bMustLayouted = sal_True; - bNotify = sal_True; - } - else if ( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) && - aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" ) ) - { - aWriteLock.unlock(); - implts_createProgressBar(); - bMustLayouted = sal_True; - bNotify = sal_True; - } - else if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" )) - { - UIElementVector::iterator pIter; - - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - { - if ( pIter->m_aName == aName ) - { - xComponent.set( pIter->m_xUIElement, UNO_QUERY ); - Reference< XUIElement > xUIElement( pIter->m_xUIElement ); - if ( xUIElement.is() ) - { - Reference< css::awt::XWindow > xWindow( xUIElement->getRealInterface(), UNO_QUERY ); - Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY ); - - rtl::OUString aAddonTbResourceName( RTL_CONSTASCII_USTRINGPARAM( "private:resource/toolbar/addon_" )); - if ( aName.indexOf( aAddonTbResourceName ) != 0 ) - { - try - { - if ( xWindow.is() ) - xWindow->removeWindowListener( Reference< css::awt::XWindowListener >( - static_cast< OWeakObject * >( this ), UNO_QUERY )); - } - catch( Exception& ) - { - } - - try - { - if ( xDockWindow.is() ) - xDockWindow->removeDockableWindowListener( Reference< css::awt::XDockableWindowListener >( - static_cast< OWeakObject * >( this ), UNO_QUERY )); - } - catch ( Exception& ) - { - } - - bMustBeDestroyed = sal_True; - } - else - { - pIter->m_bVisible = sal_False; - xWindow->setVisible( sal_False ); - bNotify = sal_True; - } - - if ( !xDockWindow->isFloating() ) - bMustLayouted = sal_True; - if ( bMustBeDestroyed ) - pIter->m_xUIElement.clear(); - - bMustBeSorted = sal_True; - } - - break; - } - } - } - else if ( aElementType.equalsIgnoreAsciiCaseAscii( "dockingwindow" )) - { - css::uno::Reference< css::frame::XFrame > xFrame( m_xFrame ); - css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR( m_xSMGR ); - aWriteLock.unlock(); + } + else if (( aElementType.equalsIgnoreAsciiCaseAscii( "statusbar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "statusbar" )) || + ( m_aStatusBarElement.m_aName == aName )) + { + aWriteLock.unlock(); + implts_destroyStatusBar(); + bMustBeLayouted = true; + bNotify = true; + } + else if ( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" )) + { + aWriteLock.unlock(); + implts_createProgressBar(); + bMustBeLayouted = true; + bNotify = sal_True; + } + else if ( aElementType.equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR ) && m_pToolbarManager != NULL ) + { + aWriteLock.unlock(); + bNotify = m_pToolbarManager->destroyToolbar( aName ); + bMustBeLayouted = m_pToolbarManager->isLayoutDirty(); + } + else if ( aElementType.equalsIgnoreAsciiCaseAscii( "dockingwindow" )) + { + uno::Reference< frame::XFrame > xFrame( m_xFrame ); + uno::Reference< lang::XMultiServiceFactory > xSMGR( m_xSMGR ); + aWriteLock.unlock(); - impl_setDockingWindowVisibility( xSMGR, xFrame, aElementName, false ); - bMustLayouted = sal_False; - bNotify = sal_False; - } + impl_setDockingWindowVisibility( xSMGR, xFrame, aElementName, false ); + bMustBeLayouted = false; + bNotify = false; } aWriteLock.unlock(); /* SAFE AREA ----------------------------------------------------------------------------------------------- */ @@ -4387,173 +1646,91 @@ throw (RuntimeException) { if ( xComponent.is() ) xComponent->dispose(); - bNotify = sal_True; + bNotify = true; } - if ( bMustBeSorted ) - { - implts_sortUIElements(); - if ( bMustLayouted ) - doLayout(); - } + if ( bMustBeLayouted ) + doLayout(); if ( bNotify ) - { - // UI element is invisible - provide information to listeners - implts_notifyListeners( css::frame::LayoutManagerEvents::UIELEMENT_INVISIBLE, uno::makeAny( aName ) ); - } + implts_notifyListeners( frame::LayoutManagerEvents::UIELEMENT_INVISIBLE, uno::makeAny( aName ) ); } -::sal_Bool SAL_CALL LayoutManager::requestElement( const ::rtl::OUString& ResourceURL ) -throw (::com::sun::star::uno::RuntimeException) +::sal_Bool SAL_CALL LayoutManager::requestElement( const ::rtl::OUString& rResourceURL ) +throw (uno::RuntimeException) { - RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::LayoutManager::requestElement" ); + bool bResult( false ); + bool bNotify( false ); + bool bDoLayout( false ); + ::rtl::OUString aElementType; + ::rtl::OUString aElementName; - ::rtl::OUString aElementType; - ::rtl::OUString aElementName; - UIElementVector::iterator pIter; - sal_Bool bResult( sal_False ); - sal_Bool bNotify( sal_False ); + parseResourceURL( rResourceURL, aElementType, aElementName ); WriteGuard aWriteLock( m_aLock ); - if ( impl_parseResourceURL( ResourceURL, aElementType, aElementName )) - { - ::rtl::OString aResName = rtl::OUStringToOString( aElementName, RTL_TEXTENCODING_ASCII_US ); - RTL_LOGFILE_CONTEXT_TRACE1( aLog, "framework (cd100003) Element %s", aResName.getStr() ); + + ::rtl::OString aResName = rtl::OUStringToOString( aElementName, RTL_TEXTENCODING_ASCII_US ); + RTL_LOGFILE_CONTEXT_TRACE1( aLog, "framework (cd100003) Element %s requested.", aResName.getStr() ); - if (( aElementType.equalsIgnoreAsciiCaseAscii( "statusbar" ) && - aElementName.equalsIgnoreAsciiCaseAscii( "statusbar" )) || - ( m_aStatusBarElement.m_aName == ResourceURL )) - { - implts_readStatusBarState( ResourceURL ); - if ( m_aStatusBarElement.m_bVisible && !m_aStatusBarElement.m_bMasterHide ) - { - createElement( ResourceURL ); - - // There are some situation where we are not able to create an element. - // Therefore we have to check the reference before further action. - // See #i70019# - css::uno::Reference< css::ui::XUIElement > xUIElement( m_aStatusBarElement.m_xUIElement ); - if ( xUIElement.is() ) - { - // we need VCL here to pass special flags to Show() - vos::OGuard aGuard( Application::GetSolarMutex() ); - Reference< css::awt::XWindow > xWindow( xUIElement->getRealInterface(), UNO_QUERY ); - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - if ( pWindow ) - { - pWindow->Show( TRUE, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE ); - doLayout(); - bResult = sal_True; - bNotify = sal_True; - } - } - } - } - else if ( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) && - aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" ) ) + if (( aElementType.equalsIgnoreAsciiCaseAscii( "statusbar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "statusbar" )) || ( m_aStatusBarElement.m_aName == rResourceURL )) + { + implts_readStatusBarState( rResourceURL ); + if ( m_aStatusBarElement.m_bVisible && !m_aStatusBarElement.m_bMasterHide ) { aWriteLock.unlock(); - implts_showProgressBar(); - doLayout(); - bResult = sal_True; - bNotify = sal_True; - } - else if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" )) - { - if ( m_bVisible ) - { - bool bFound( false ); - bool bShowElement( false ); + createElement( rResourceURL ); - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) + // There are some situation where we are not able to create an element. + // Therefore we have to check the reference before further action. + // See #i70019# + uno::Reference< ui::XUIElement > xUIElement( m_aStatusBarElement.m_xUIElement ); + if ( xUIElement.is() ) + { + // we need VCL here to pass special flags to Show() + vos::OGuard aGuard( Application::GetSolarMutex() ); + Reference< awt::XWindow > xWindow( xUIElement->getRealInterface(), UNO_QUERY ); + Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); + if ( pWindow ) { - if ( pIter->m_aName == ResourceURL ) - { - bFound = sal_True; - bShowElement = ( pIter->m_bVisible && !pIter->m_bMasterHide && m_bParentWindowVisible ); - - Reference< css::awt::XWindow2 > xContainerWindow( m_xContainerWindow, UNO_QUERY ); - if ( xContainerWindow.is() && pIter->m_bFloating ) - bShowElement = ( bShowElement && xContainerWindow->isActive() ); - - if ( pIter->m_xUIElement.is() ) - { - Reference< css::awt::XWindow > xWindow( pIter->m_xUIElement->getRealInterface(), UNO_QUERY ); - Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY ); - - if ( xDockWindow.is() && xDockWindow->isFloating() ) - bShowElement = ( bShowElement && xContainerWindow->isActive() ); - - if ( xDockWindow.is() && bShowElement ) - { - pIter->m_bVisible = sal_True; - aWriteLock.unlock(); - - // we need VCL here to pass special flags to Show() - vos::OGuard aGuard( Application::GetSolarMutex() ); - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - if( pWindow && !pWindow->IsReallyVisible() ) - { - pWindow->Show( TRUE, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE ); - implts_writeNewStateData( ResourceURL, xWindow ); - - if ( xDockWindow.is() && !xDockWindow->isFloating() ) - doLayout(); - bResult = sal_True; - bNotify = sal_True; - } - - bResult = sal_False; - } - } // if ( pIter->m_xUIElement.is() ) - break; - } - } - - // Create toolbar on demand when it's visible - if ( !bResult ) - { - Reference< ::com::sun::star::ui::XUIElement > xUIElement; - if ( !bFound ) - { - UIElement aNewToolbar( aElementName, aElementType, xUIElement ); - aNewToolbar.m_aName = ResourceURL; - implts_readWindowStateData( ResourceURL, aNewToolbar ); - implts_insertUIElement( aNewToolbar ); - aWriteLock.unlock(); - - implts_sortUIElements(); - if ( aNewToolbar.m_bVisible ) - createElement( ResourceURL ); - bResult = sal_True; - bNotify = sal_True; - } - else if ( bShowElement ) - { - aWriteLock.unlock(); - - createElement( ResourceURL ); - bResult = sal_True; - bNotify = sal_True; - } + pWindow->Show( TRUE, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE ); + bResult = true; + bNotify = true; + bDoLayout = true; } } } - else if ( aElementType.equalsIgnoreAsciiCaseAscii( "dockingwindow" )) + } + else if ( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" ) ) + { + aWriteLock.unlock(); + implts_showProgressBar(); + bResult = true; + bNotify = true; + bDoLayout = true; + } + else if ( aElementType.equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR ) && m_bVisible ) + { + bool bComponentAttached( m_aModuleIdentifier.getLength() > 0 ); + uno::Reference< uno::XInterface > xThis( m_xToolbarManager, uno::UNO_QUERY ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + aWriteLock.unlock(); + + if ( pToolbarManager && bComponentAttached ) { - css::uno::Reference< css::frame::XFrame > xFrame( m_xFrame ); - aWriteLock.unlock(); + bNotify = pToolbarManager->requestToolbar( rResourceURL ); + bDoLayout = true; + } + } + else if ( aElementType.equalsIgnoreAsciiCaseAscii( "dockingwindow" )) + { + uno::Reference< frame::XFrame > xFrame( m_xFrame ); + aWriteLock.unlock(); - CreateDockingWindow( xFrame, aElementName ); - } + CreateDockingWindow( xFrame, aElementName ); } if ( bNotify ) - { - // UI element is visible - provide information to listeners - implts_notifyListeners( css::frame::LayoutManagerEvents::UIELEMENT_VISIBLE, uno::makeAny( ResourceURL ) ); - } + implts_notifyListeners( frame::LayoutManagerEvents::UIELEMENT_VISIBLE, uno::makeAny( rResourceURL ) ); return bResult; } @@ -4561,50 +1738,54 @@ throw (::com::sun::star::uno::RuntimeException) Reference< XUIElement > SAL_CALL LayoutManager::getElement( const ::rtl::OUString& aName ) throw (RuntimeException) { - ::rtl::OUString aElementType; - ::rtl::OUString aElementName; - Reference< XUIElement > xElement; + Reference< XUIElement > xUIElement = implts_findElement( aName ); + if ( !xUIElement.is() ) + { + ReadGuard aReadLock( m_aLock ); + uno::Reference< uno::XInterface > xThis( m_xToolbarManager ); + ToolbarLayoutManager* pToolbarManager( m_pToolbarManager ); + aReadLock.unlock(); - implts_findElement( aName, aElementType, aElementName, xElement ); - return xElement; + if ( pToolbarManager ) + xUIElement = pToolbarManager->getToolbar( aName ); + } + + return xUIElement; } -Sequence< Reference< ::com::sun::star::ui::XUIElement > > SAL_CALL LayoutManager::getElements() -throw (::com::sun::star::uno::RuntimeException) +Sequence< Reference< ui::XUIElement > > SAL_CALL LayoutManager::getElements() +throw (uno::RuntimeException) { - ReadGuard aReadLock( m_aLock ); + ReadGuard aReadLock( m_aLock ); + uno::Reference< ui::XUIElement > xMenuBar( m_xMenuBar ); + uno::Reference< ui::XUIElement > xStatusBar( m_aStatusBarElement.m_xUIElement ); + uno::Reference< uno::XInterface > xThis( m_xToolbarManager ); + ToolbarLayoutManager* pToolbarManager( m_pToolbarManager ); + aReadLock.unlock(); - sal_Bool bMenuBar( sal_False ); - sal_Bool bStatusBar( sal_False ); - sal_Int32 nSize = m_aUIElements.size(); + Sequence< Reference< ui::XUIElement > > aSeq; + if ( pToolbarManager ) + aSeq = pToolbarManager->getToolbars(); - if ( m_xMenuBar.is() ) + sal_Int32 nSize = aSeq.getLength(); + sal_Int32 nMenuBarIndex(-1); + sal_Int32 nStatusBarIndex(-1); + if ( xMenuBar.is() ) { + nMenuBarIndex = nSize; ++nSize; - bMenuBar = sal_True; } - if ( m_aStatusBarElement.m_xUIElement.is() ) + if ( xStatusBar.is() ) { + nStatusBarIndex = nSize; ++nSize; - bStatusBar = sal_True; - } - - Sequence< Reference< ::com::sun::star::ui::XUIElement > > aSeq( nSize ); - - sal_Int32 nIndex = 0; - UIElementVector::const_iterator pIter; - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - { - if ( pIter->m_xUIElement.is() ) - aSeq[nIndex++] = pIter->m_xUIElement; } - if ( bMenuBar ) - aSeq[nIndex++] = m_xMenuBar; - if ( bStatusBar ) - aSeq[nIndex++] = m_aStatusBarElement.m_xUIElement; - // Resize sequence as we now know our correct size - aSeq.realloc( nIndex ); + aSeq.realloc(nSize); + if ( nMenuBarIndex >= 0 ) + aSeq[nMenuBarIndex] = xMenuBar; + if ( nStatusBarIndex >= 0 ) + aSeq[nStatusBarIndex] = xStatusBar; return aSeq; } @@ -4614,115 +1795,80 @@ throw (RuntimeException) { RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::LayoutManager::showElement" ); - sal_Bool bResult( sal_False ); - sal_Bool bNotify( sal_False ); - ::rtl::OUString aElementType; - ::rtl::OUString aElementName; + bool bResult( false ); + bool bNotify( false ); + bool bMustLayout( false ); + ::rtl::OUString aElementType; + ::rtl::OUString aElementName; + + parseResourceURL( aName, aElementType, aElementName ); + + ::rtl::OString aResName = rtl::OUStringToOString( aElementName, RTL_TEXTENCODING_ASCII_US ); + RTL_LOGFILE_CONTEXT_TRACE1( aLog, "framework (cd100003) Element %s", aResName.getStr() ); - if ( impl_parseResourceURL( aName, aElementType, aElementName )) + if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "menubar" )) { - ::rtl::OString aResName = rtl::OUStringToOString( aElementName, RTL_TEXTENCODING_ASCII_US ); - RTL_LOGFILE_CONTEXT_TRACE1( aLog, "framework (cd100003) Element %s", aResName.getStr() ); + WriteGuard aWriteLock( m_aLock ); + m_bMenuVisible = sal_True; + aWriteLock.unlock(); - if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" ) && - aElementName.equalsIgnoreAsciiCaseAscii( "menubar" )) + bResult = implts_resetMenuBar(); + bNotify = bResult; + } + else if (( aElementType.equalsIgnoreAsciiCaseAscii( "statusbar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "statusbar" )) || ( m_aStatusBarElement.m_aName == aName )) + { + WriteGuard aWriteLock( m_aLock ); + if ( m_aStatusBarElement.m_xUIElement.is() && !m_aStatusBarElement.m_bMasterHide && + implts_showStatusBar( sal_True )) { - WriteGuard aWriteLock( m_aLock ); - m_bMenuVisible = sal_True; aWriteLock.unlock(); - bResult = implts_resetMenuBar(); - bNotify = bResult; - } - else if (( aElementType.equalsIgnoreAsciiCaseAscii( "statusbar" ) && - aElementName.equalsIgnoreAsciiCaseAscii( "statusbar" )) || - ( m_aStatusBarElement.m_aName == aName )) - { - WriteGuard aWriteLock( m_aLock ); - if ( m_aStatusBarElement.m_xUIElement.is() && - !m_aStatusBarElement.m_bMasterHide ) - { - if ( implts_showStatusBar( sal_True )) - { - implts_writeWindowStateData( m_aStatusBarAlias, m_aStatusBarElement ); - doLayout(); - bResult = sal_True; - bNotify = sal_True; - } - } - } - else if ( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) && - aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" )) - { - bNotify = bResult = implts_showProgressBar(); - } - else if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" )) - { - UIElementVector::iterator pIter; - - WriteGuard aWriteLock( m_aLock ); - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - { - if ( pIter->m_aName == aName && pIter->m_xUIElement.is() ) - { - UIElement aUIElement = *pIter; - Reference< css::awt::XWindow > xWindow( pIter->m_xUIElement->getRealInterface(), UNO_QUERY ); - Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY ); - - sal_Bool bShowElement( !pIter->m_bMasterHide && m_bParentWindowVisible ); - - pIter->m_bVisible = sal_True; - aWriteLock.unlock(); - - implts_writeWindowStateData( aUIElement.m_aName, aUIElement ); - implts_sortUIElements(); - - if ( xDockWindow.is() && bShowElement ) - { - // we need VCL here to pass special flags to Show() - vos::OGuard aGuard( Application::GetSolarMutex() ); - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - if( pWindow ) - { - pWindow->Show( TRUE, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE ); - bNotify = sal_True; - } - implts_writeNewStateData( aName, xWindow ); - - if ( xDockWindow.is() && !xDockWindow->isFloating() ) - doLayout(); - - bResult = sal_True; - } // if ( xDockWindow.is() && bShowElement ) - break; - } - } + implts_writeWindowStateData( m_aStatusBarAlias, m_aStatusBarElement ); + bMustLayout = true; + bResult = true; + bNotify = true; } - else if ( aElementType.equalsIgnoreAsciiCaseAscii( "dockingwindow" )) - { - ReadGuard aReadGuard( m_aLock ); - css::uno::Reference< css::frame::XFrame > xFrame( m_xFrame ); - css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR( m_xSMGR ); - aReadGuard.unlock(); - - impl_setDockingWindowVisibility( xSMGR, xFrame, aElementName, true ); - } - else if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolpanel" )) + } + else if ( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" )) + { + bNotify = bResult = implts_showProgressBar(); + } + else if ( aElementType.equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR )) + { + ReadGuard aReadLock( m_aLock ); + uno::Reference< awt::XWindowListener > xToolbarManager( m_xToolbarManager, uno::UNO_QUERY ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + aReadLock.unlock(); + + if ( pToolbarManager ) { - ReadGuard aReadGuard( m_aLock ); - css::uno::Reference< css::frame::XFrame > xFrame( m_xFrame ); - aReadGuard.unlock(); - - ActivateToolPanel( m_xFrame, aName ); + bNotify = pToolbarManager->showToolbar( aName ); + bMustLayout = pToolbarManager->isLayoutDirty(); } } + else if ( aElementType.equalsIgnoreAsciiCaseAscii( "dockingwindow" )) + { + ReadGuard aReadGuard( m_aLock ); + uno::Reference< frame::XFrame > xFrame( m_xFrame ); + uno::Reference< lang::XMultiServiceFactory > xSMGR( m_xSMGR ); + aReadGuard.unlock(); - if ( bNotify ) + impl_setDockingWindowVisibility( xSMGR, xFrame, aElementName, true ); + } + else if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolpanel" )) { - // UI element is visible - provide information to listeners - implts_notifyListeners( css::frame::LayoutManagerEvents::UIELEMENT_VISIBLE, uno::makeAny( aName ) ); + ReadGuard aReadGuard( m_aLock ); + uno::Reference< frame::XFrame > xFrame( m_xFrame ); + aReadGuard.unlock(); + ActivateToolPanel( m_xFrame, aName ); } + if ( bMustLayout ) + doLayout(); + + if ( bNotify ) + implts_notifyListeners( frame::LayoutManagerEvents::UIELEMENT_VISIBLE, uno::makeAny( aName ) ); + return bResult; } @@ -4731,479 +1877,240 @@ throw (RuntimeException) { RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::LayoutManager::hideElement" ); + bool bResult( false ); + bool bNotify( false ); + bool bMustLayout( false ); + ::rtl::OUString aElementType; + ::rtl::OUString aElementName; - sal_Bool bResult( sal_False ); - sal_Bool bNotify( sal_False ); - ::rtl::OUString aElementType; - ::rtl::OUString aElementName; + parseResourceURL( aName, aElementType, aElementName ); + ::rtl::OString aResName = rtl::OUStringToOString( aElementName, RTL_TEXTENCODING_ASCII_US ); + RTL_LOGFILE_CONTEXT_TRACE1( aLog, "framework (cd100003) Element %s", aResName.getStr() ); - if ( impl_parseResourceURL( aName, aElementType, aElementName )) + if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "menubar" )) { - ::rtl::OString aResName = rtl::OUStringToOString( aElementName, RTL_TEXTENCODING_ASCII_US ); - RTL_LOGFILE_CONTEXT_TRACE1( aLog, "framework (cd100003) Element %s", aResName.getStr() ); - - if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" ) && - aElementName.equalsIgnoreAsciiCaseAscii( "menubar" )) - { - WriteGuard aWriteLock( m_aLock ); - - if ( m_xContainerWindow.is() ) - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - Window* pWindow = VCLUnoHelper::GetWindow( m_xContainerWindow ); - while ( pWindow && !pWindow->IsSystemWindow() ) - pWindow = pWindow->GetParent(); + WriteGuard aWriteLock( m_aLock ); - m_bMenuVisible = sal_False; - if ( pWindow ) - { - MenuBar* pMenuBar = ((SystemWindow *)pWindow)->GetMenuBar(); - if ( pMenuBar ) - { - pMenuBar->SetDisplayable( sal_False ); - bResult = sal_True; - bNotify = sal_True; - } - } - } - } - else if (( aElementType.equalsIgnoreAsciiCaseAscii( "statusbar" ) && - aElementName.equalsIgnoreAsciiCaseAscii( "statusbar" )) || - ( m_aStatusBarElement.m_aName == aName )) + if ( m_xContainerWindow.is() ) { - WriteGuard aWriteLock( m_aLock ); - if ( m_aStatusBarElement.m_xUIElement.is() && - !m_aStatusBarElement.m_bMasterHide ) + m_bMenuVisible = sal_False; + + vos::OGuard aGuard( Application::GetSolarMutex() ); + SystemWindow* pSysWindow = getTopSystemWindow( m_xContainerWindow ); + if ( pSysWindow ) { - if ( implts_hideStatusBar( sal_True )) + MenuBar* pMenuBar = pSysWindow->GetMenuBar(); + if ( pMenuBar ) { - implts_writeWindowStateData( m_aStatusBarAlias, m_aStatusBarElement ); - doLayout(); - bNotify = sal_True; - bResult = sal_True; + pMenuBar->SetDisplayable( sal_False ); + bResult = true; + bNotify = true; } } } - else if ( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) && - aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" )) - { - bResult = bNotify = implts_hideProgressBar(); - } - else if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" )) + } + else if (( aElementType.equalsIgnoreAsciiCaseAscii( "statusbar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "statusbar" )) || ( m_aStatusBarElement.m_aName == aName )) + { + WriteGuard aWriteLock( m_aLock ); + if ( m_aStatusBarElement.m_xUIElement.is() && !m_aStatusBarElement.m_bMasterHide && + implts_hideStatusBar( sal_True )) { - UIElementVector::iterator pIter; - - WriteGuard aWriteLock( m_aLock ); - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - { - if ( pIter->m_aName == aName && pIter->m_xUIElement.is() ) - { - Reference< css::awt::XWindow > xWindow( pIter->m_xUIElement->getRealInterface(), UNO_QUERY ); - Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY ); - - if ( xDockWindow.is() ) - { - pIter->m_bVisible = sal_False; - aWriteLock.unlock(); - - xWindow->setVisible( sal_False ); - implts_writeNewStateData( aName, xWindow ); - - if ( xDockWindow.is() && !xDockWindow->isFloating() ) - doLayout(); - - bResult = sal_True; - bNotify = sal_True; - } // if ( xDockWindow.is() ) - break; - } - } + implts_writeWindowStateData( m_aStatusBarAlias, m_aStatusBarElement ); + bMustLayout = sal_True; + bNotify = sal_True; + bResult = sal_True; } - else if ( aElementType.equalsIgnoreAsciiCaseAscii( "dockingwindow" )) - { - ReadGuard aReadGuard( m_aLock ); - css::uno::Reference< css::frame::XFrame > xFrame( m_xFrame ); - css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR( m_xSMGR ); - aReadGuard.unlock(); + } + else if ( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" )) + { + bResult = bNotify = implts_hideProgressBar(); + } + else if ( aElementType.equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR )) + { + ReadGuard aReadLock( m_aLock ); + uno::Reference< uno::XInterface > xToolbarManager( m_xToolbarManager, uno::UNO_QUERY ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + aReadLock.unlock(); + + bNotify = pToolbarManager->hideToolbar( aName ); + bMustLayout = pToolbarManager->isLayoutDirty(); + } + else if ( aElementType.equalsIgnoreAsciiCaseAscii( "dockingwindow" )) + { + ReadGuard aReadGuard( m_aLock ); + uno::Reference< frame::XFrame > xFrame( m_xFrame ); + uno::Reference< lang::XMultiServiceFactory > xSMGR( m_xSMGR ); + aReadGuard.unlock(); - impl_setDockingWindowVisibility( xSMGR, xFrame, aElementName, false ); - } + impl_setDockingWindowVisibility( xSMGR, xFrame, aElementName, false ); } + if ( bMustLayout ) + doLayout(); + if ( bNotify ) - { - // UI element is visible - provide information to listeners - implts_notifyListeners( css::frame::LayoutManagerEvents::UIELEMENT_INVISIBLE, uno::makeAny( aName ) ); - } + implts_notifyListeners( frame::LayoutManagerEvents::UIELEMENT_INVISIBLE, uno::makeAny( aName ) ); return sal_False; } -sal_Bool SAL_CALL LayoutManager::dockWindow( const ::rtl::OUString& aName, DockingArea DockingArea, const css::awt::Point& Pos ) +sal_Bool SAL_CALL LayoutManager::dockWindow( const ::rtl::OUString& aName, DockingArea DockingArea, const awt::Point& Pos ) throw (RuntimeException) { - UIElement aUIElement; - - if ( implts_findElement( aName, aUIElement ) && aUIElement.m_xUIElement.is() ) + ::rtl::OUString aElementType; + ::rtl::OUString aElementName; + + parseResourceURL( aName, aElementType, aElementName ); + if ( aElementType.equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR )) { - try - { - Reference< css::awt::XWindow > xWindow( aUIElement.m_xUIElement->getRealInterface(), UNO_QUERY ); - Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY ); - if ( xDockWindow.is() ) - { - if ( DockingArea != DockingArea_DOCKINGAREA_DEFAULT ) - aUIElement.m_aDockedData.m_nDockedArea = sal_Int16( DockingArea ); - - if (( Pos.X != SAL_MAX_INT32 ) && ( Pos.Y != SAL_MAX_INT32 )) - aUIElement.m_aDockedData.m_aPos = ::Point( Pos.X, Pos.Y ); - - if ( !xDockWindow->isFloating() ) - { - Window* pWindow( 0 ); - ToolBox* pToolBox( 0 ); - - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - pWindow = VCLUnoHelper::GetWindow( xWindow ); - if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX ) - { - pToolBox = (ToolBox *)pWindow; - - // We have to set the alignment of the toolbox. It's possible that the toolbox is moved from a - // horizontal to a vertical docking area! - pToolBox->SetAlign( ImplConvertAlignment( aUIElement.m_aDockedData.m_nDockedArea )); - } - } - - if (( aUIElement.m_aDockedData.m_aPos.X() == SAL_MAX_INT32 ) || - ( aUIElement.m_aDockedData.m_aPos.Y() == SAL_MAX_INT32 )) - { - // Docking on its default position without a preset position - - // we have to find a good place for it. - ::Size aSize; - - vos::OGuard aGuard( Application::GetSolarMutex() ); - { - if ( pToolBox ) - aSize = pToolBox->CalcWindowSizePixel( 1, ImplConvertAlignment( aUIElement.m_aDockedData.m_nDockedArea ) ); - else - aSize = pWindow->GetSizePixel(); - } - - ::Point aPixelPos; - ::Point aDockPos; - implts_findNextDockingPos( (::com::sun::star::ui::DockingArea)aUIElement.m_aDockedData.m_nDockedArea, - aSize, - aDockPos, - aPixelPos ); - aUIElement.m_aDockedData.m_aPos = aDockPos; - } - } - - WriteGuard aWriteLock( m_aLock ); - UIElement& rUIElement = LayoutManager::impl_findElement( aUIElement.m_aName ); - if ( rUIElement.m_aName == aName ) - { - rUIElement.m_aDockedData.m_nDockedArea = aUIElement.m_aDockedData.m_nDockedArea; - rUIElement.m_aDockedData.m_aPos = aUIElement.m_aDockedData.m_aPos; - } - aWriteLock.unlock(); - - if ( xDockWindow->isFloating() ) - { - // Will call toggle floating mode which will do the rest! - xWindow->setVisible( sal_False ); - xDockWindow->setFloatingMode( sal_False ); - xWindow->setVisible( sal_True ); - } - else - { - implts_writeWindowStateData( aName, aUIElement ); - implts_sortUIElements(); - - if ( aUIElement.m_bVisible ) - doLayout(); - } - - return sal_True; - } - } - catch ( DisposedException& ) - { + ReadGuard aReadLock( m_aLock ); + uno::Reference< uno::XInterface > xThis( m_xToolbarManager ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + aReadLock.unlock(); + + if ( pToolbarManager ) + { + pToolbarManager->dockToolbar( aName, DockingArea, Pos ); + if ( pToolbarManager->isLayoutDirty() ) + doLayout(); } } - return sal_False; } -::sal_Bool SAL_CALL LayoutManager::dockAllWindows( ::sal_Int16 nElementType ) throw (::com::sun::star::uno::RuntimeException) +::sal_Bool SAL_CALL LayoutManager::dockAllWindows( ::sal_Int16 /*nElementType*/ ) throw (uno::RuntimeException) { - if ( nElementType == UIElementType::TOOLBAR ) - { - std::vector< rtl::OUString > aToolBarNameVector; - - ::rtl::OUString aElementType; - ::rtl::OUString aElementName; - - { - ReadGuard aReadLock( m_aLock ); - UIElementVector::iterator pIter; - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - { - if ( pIter->m_aType.equalsAscii( "toolbar" ) && - pIter->m_xUIElement.is() && - pIter->m_bFloating && - pIter->m_bVisible ) - aToolBarNameVector.push_back( pIter->m_aName ); - } - } + ReadGuard aReadLock( m_aLock ); + bool bResult( false ); + uno::Reference< uno::XInterface > xThis( m_xToolbarManager ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + aReadLock.unlock(); - const sal_uInt32 nCount = aToolBarNameVector.size(); - for ( sal_uInt32 i = 0; i < nCount; ++i ) - { - ::com::sun::star::awt::Point aPoint; - aPoint.X = aPoint.Y = SAL_MAX_INT32; - dockWindow( aToolBarNameVector[i], DockingArea_DOCKINGAREA_DEFAULT, aPoint ); - } + if ( pToolbarManager ) + { + bResult = pToolbarManager->dockAllToolbars(); + if ( pToolbarManager->isLayoutDirty() ) + doLayout(); } - - return sal_False; + return bResult; } sal_Bool SAL_CALL LayoutManager::floatWindow( const ::rtl::OUString& aName ) throw (RuntimeException) { - UIElement aUIElement; - - if ( implts_findElement( aName, aUIElement )) + bool bResult( false ); + if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR )) { - if ( aUIElement.m_xUIElement.is() ) + ReadGuard aReadLock( m_aLock ); + uno::Reference< uno::XInterface > xThis( m_xToolbarManager ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + aReadLock.unlock(); + + if ( pToolbarManager ) { - try - { - Reference< css::awt::XWindow > xWindow( aUIElement.m_xUIElement->getRealInterface(), UNO_QUERY ); - Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY ); - if ( xWindow.is() && xDockWindow.is() ) - { - if ( !xDockWindow->isFloating() ) - { - xDockWindow->setFloatingMode( sal_True ); - return sal_True; - } - } - } - catch ( DisposedException& ) - { - } + bResult = pToolbarManager->floatToolbar( aName ); + if ( pToolbarManager->isLayoutDirty() ) + doLayout(); } } - - return sal_False; + return bResult; } -::sal_Bool SAL_CALL LayoutManager::lockWindow( const ::rtl::OUString& ResourceURL ) -throw (::com::sun::star::uno::RuntimeException) +::sal_Bool SAL_CALL LayoutManager::lockWindow( const ::rtl::OUString& aName ) +throw (uno::RuntimeException) { - UIElement aUIElement; - - if ( implts_findElement( ResourceURL, aUIElement )) + bool bResult( false ); + if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR )) { - if ( aUIElement.m_xUIElement.is() ) - { - try - { - Reference< css::awt::XWindow > xWindow( aUIElement.m_xUIElement->getRealInterface(), UNO_QUERY ); - Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY ); - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - if ( pWindow && - pWindow->IsVisible() && - xDockWindow.is() && - !xDockWindow->isFloating() ) - { - aUIElement.m_aDockedData.m_bLocked = sal_True; - implts_writeWindowStateData( ResourceURL, aUIElement ); - xDockWindow->lock(); - - // Write back lock state - WriteGuard aWriteLock( m_aLock ); - UIElement& rUIElement = LayoutManager::impl_findElement( aUIElement.m_aName ); - if ( rUIElement.m_aName == aUIElement.m_aName ) - rUIElement.m_aDockedData.m_bLocked = aUIElement.m_aDockedData.m_bLocked; - aWriteLock.unlock(); - - doLayout(); - return sal_True; - } - } - catch ( DisposedException& ) - { - } + ReadGuard aReadLock( m_aLock ); + uno::Reference< uno::XInterface > xThis( m_xToolbarManager ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + aReadLock.unlock(); + + if ( pToolbarManager ) + { + bResult = pToolbarManager->lockToolbar( aName ); + if ( pToolbarManager->isLayoutDirty() ) + doLayout(); } } - - return sal_False; + return bResult; } -::sal_Bool SAL_CALL LayoutManager::unlockWindow( const ::rtl::OUString& ResourceURL ) -throw (::com::sun::star::uno::RuntimeException) +::sal_Bool SAL_CALL LayoutManager::unlockWindow( const ::rtl::OUString& aName ) +throw (uno::RuntimeException) { - UIElement aUIElement; - - if ( implts_findElement( ResourceURL, aUIElement )) + bool bResult( false ); + if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR )) { - if ( aUIElement.m_xUIElement.is() ) - { - try - { - Reference< css::awt::XWindow > xWindow( aUIElement.m_xUIElement->getRealInterface(), UNO_QUERY ); - Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY ); - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - if ( pWindow && - pWindow->IsVisible() && - xDockWindow.is() && - !xDockWindow->isFloating() ) - { - aUIElement.m_aDockedData.m_bLocked = sal_False; - implts_writeWindowStateData( ResourceURL, aUIElement ); - xDockWindow->unlock(); - - // Write back lock state - WriteGuard aWriteLock( m_aLock ); - UIElement& rUIElement = LayoutManager::impl_findElement( aUIElement.m_aName ); - if ( rUIElement.m_aName == aUIElement.m_aName ) - rUIElement.m_aDockedData.m_bLocked = aUIElement.m_aDockedData.m_bLocked; - aWriteLock.unlock(); - - doLayout(); - return sal_True; - } - } - catch ( DisposedException& ) - { - } + ReadGuard aReadLock( m_aLock ); + uno::Reference< uno::XInterface > xThis( m_xToolbarManager ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + aReadLock.unlock(); + + if ( pToolbarManager ) + { + bResult = pToolbarManager->unlockToolbar( aName ); + if ( pToolbarManager->isLayoutDirty() ) + doLayout(); } } - - return sal_False; + return bResult; } -void SAL_CALL LayoutManager::setElementSize( const ::rtl::OUString& aName, const css::awt::Size& aSize ) +void SAL_CALL LayoutManager::setElementSize( const ::rtl::OUString& aName, const awt::Size& aSize ) throw (RuntimeException) { - UIElement aUIElement; - - if ( implts_findElement( aName, aUIElement )) + if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR )) { - if ( aUIElement.m_xUIElement.is() ) - { - try - { - Reference< css::awt::XWindow > xWindow( aUIElement.m_xUIElement->getRealInterface(), UNO_QUERY ); - Reference< css::awt::XWindow2 > xWindow2( aUIElement.m_xUIElement->getRealInterface(), UNO_QUERY ); - Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY ); + ReadGuard aReadLock( m_aLock ); + uno::Reference< uno::XInterface > xThis( m_xToolbarManager ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + aReadLock.unlock(); - if ( xWindow.is() && xWindow2.is() && xDockWindow.is() ) - { - if ( aUIElement.m_bFloating ) - { - xWindow2->setOutputSize( aSize ); - implts_writeNewStateData( aName, xWindow ); - } - } - } - catch ( DisposedException& ) - { - } + if ( pToolbarManager ) + { + pToolbarManager->setToolbarSize( aName, aSize ); + if ( pToolbarManager->isLayoutDirty() ) + doLayout(); } } } -void SAL_CALL LayoutManager::setElementPos( const ::rtl::OUString& aName, const css::awt::Point& aPos ) +void SAL_CALL LayoutManager::setElementPos( const ::rtl::OUString& aName, const awt::Point& aPos ) throw (RuntimeException) { - UIElement aUIElement; - - if ( implts_findElement( aName, aUIElement ) && aUIElement.m_xUIElement.is() ) + if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR )) { - try - { - Reference< css::awt::XWindow > xWindow( aUIElement.m_xUIElement->getRealInterface(), UNO_QUERY ); - Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY ); + ReadGuard aReadLock( m_aLock ); + uno::Reference< ui::XUIConfigurationListener > xToolbarManager( m_xToolbarManager ); + ToolbarLayoutManager* pToolbarManager( m_pToolbarManager ); + aReadLock.unlock(); - if ( xWindow.is() && xDockWindow.is() ) - { - if ( aUIElement.m_bFloating ) - { - xWindow->setPosSize( aPos.X, aPos.Y, 0, 0, css::awt::PosSize::POS ); - implts_writeNewStateData( aName, xWindow ); - } - else - { - WriteGuard aWriteLock( m_aLock ); - UIElement& rUIElement = LayoutManager::impl_findElement( aUIElement.m_aName ); - if ( rUIElement.m_aName == aName ) - rUIElement.m_aDockedData.m_aPos = ::Point( aPos.X, aPos.Y ); - aWriteLock.unlock(); - - aUIElement.m_aDockedData.m_aPos = ::Point( aPos.X, aPos.Y ); - implts_writeWindowStateData( aName, aUIElement ); - implts_sortUIElements(); - - if ( aUIElement.m_bVisible ) - doLayout(); - } - } - } - catch ( DisposedException& ) + if ( pToolbarManager ) { + pToolbarManager->setToolbarPos( aName, aPos ); + if ( pToolbarManager->isLayoutDirty() ) + doLayout(); } } } -void SAL_CALL LayoutManager::setElementPosSize( const ::rtl::OUString& aName, const css::awt::Point& aPos, const css::awt::Size& aSize ) +void SAL_CALL LayoutManager::setElementPosSize( const ::rtl::OUString& aName, const awt::Point& aPos, const awt::Size& aSize ) throw (RuntimeException) { - UIElement aUIElement; - - if ( implts_findElement( aName, aUIElement )) + if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR )) { - if ( aUIElement.m_xUIElement.is() ) - { - try - { - Reference< css::awt::XWindow > xWindow( aUIElement.m_xUIElement->getRealInterface(), UNO_QUERY ); - Reference< css::awt::XWindow2 > xWindow2( aUIElement.m_xUIElement->getRealInterface(), UNO_QUERY ); - Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY ); + ReadGuard aReadLock( m_aLock ); + uno::Reference< ui::XUIConfigurationListener > xToolbarManager( m_xToolbarManager ); + ToolbarLayoutManager* pToolbarManager( m_pToolbarManager ); + aReadLock.unlock(); - if ( xWindow.is() && xWindow2.is() && xDockWindow.is() ) - { - if ( aUIElement.m_bFloating ) - { - xWindow2->setPosSize( aPos.X, aPos.Y, 0, 0, css::awt::PosSize::POS ); - xWindow2->setOutputSize( aSize ); - implts_writeNewStateData( aName, xWindow ); - } - else - { - WriteGuard aWriteLock( m_aLock ); - UIElement& rUIElement = LayoutManager::impl_findElement( aUIElement.m_aName ); - if ( rUIElement.m_aName == aName ) - rUIElement.m_aDockedData.m_aPos = ::Point( aPos.X, aPos.Y ); - aWriteLock.unlock(); - - aUIElement.m_aDockedData.m_aPos = ::Point( aPos.X, aPos.Y ); - implts_writeWindowStateData( aName, rUIElement ); - implts_sortUIElements(); - - if ( aUIElement.m_bVisible ) - doLayout(); - } - } - } - catch ( DisposedException& ) - { - } + if ( pToolbarManager ) + { + pToolbarManager->setToolbarPosSize( aName, aPos, aSize ); + if ( pToolbarManager->isLayoutDirty() ) + doLayout(); } } } @@ -5214,84 +2121,66 @@ throw (RuntimeException) ::rtl::OUString aElementType; ::rtl::OUString aElementName; - if ( impl_parseResourceURL( aName, aElementType, aElementName )) + parseResourceURL( aName, aElementType, aElementName ); + if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "menubar" )) { - if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" ) && - aElementName.equalsIgnoreAsciiCaseAscii( "menubar" )) + ReadGuard aReadLock( m_aLock ); + if ( m_xContainerWindow.is() ) { - ReadGuard aReadLock( m_aLock ); - if ( m_xContainerWindow.is() ) - { - aReadLock.unlock(); + aReadLock.unlock(); - vos::OGuard aGuard( Application::GetSolarMutex() ); - Window* pWindow = VCLUnoHelper::GetWindow( m_xContainerWindow ); - while ( pWindow && !pWindow->IsSystemWindow() ) - pWindow = pWindow->GetParent(); - - if ( pWindow ) - { - MenuBar* pMenuBar = ((SystemWindow *)pWindow)->GetMenuBar(); - if ( pMenuBar && pMenuBar->IsDisplayable() ) - return sal_True; - } - else - { - aReadLock.lock(); - return m_bMenuVisible; - } + vos::OGuard aGuard( Application::GetSolarMutex() ); + SystemWindow* pSysWindow = getTopSystemWindow( m_xContainerWindow ); + if ( pSysWindow ) + { + MenuBar* pMenuBar = pSysWindow->GetMenuBar(); + if ( pMenuBar && pMenuBar->IsDisplayable() ) + return sal_True; } - } - else if (( aElementType.equalsIgnoreAsciiCaseAscii( "statusbar" ) && - aElementName.equalsIgnoreAsciiCaseAscii( "statusbar" )) || - ( m_aStatusBarElement.m_aName == aName )) - { - if ( m_aStatusBarElement.m_xUIElement.is() ) + else { - Reference< css::awt::XWindow > xWindow( - m_aStatusBarElement.m_xUIElement->getRealInterface(), UNO_QUERY ); - if ( xWindow.is() ) - { - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - if ( pWindow && pWindow->IsVisible() ) - return sal_True; - else - return sal_False; - } + aReadLock.lock(); + return m_bMenuVisible; } } - else if (( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) && - aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" ))) - { - if ( m_aProgressBarElement.m_xUIElement.is() ) - return m_aProgressBarElement.m_bVisible; - } - else if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" )) + } + else if (( aElementType.equalsIgnoreAsciiCaseAscii( "statusbar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "statusbar" )) || ( m_aStatusBarElement.m_aName == aName )) + { + if ( m_aStatusBarElement.m_xUIElement.is() ) { - UIElementVector::const_iterator pIter; - - ReadGuard aReadLock( m_aLock ); - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) + Reference< awt::XWindow > xWindow( m_aStatusBarElement.m_xUIElement->getRealInterface(), UNO_QUERY ); + if ( xWindow.is() ) { - if ( pIter->m_aName == aName && pIter->m_xUIElement.is() ) - { - Reference< css::awt::XWindow > xWindow( pIter->m_xUIElement->getRealInterface(), UNO_QUERY ); - if ( xWindow.is() ) - { - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - return pWindow && pWindow->IsVisible(); - } - } + Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); + if ( pWindow && pWindow->IsVisible() ) + return sal_True; + else + return sal_False; } } - else if ( aElementType.equalsIgnoreAsciiCaseAscii( "dockingwindow" )) - { - ReadGuard aReadGuard( m_aLock ); - css::uno::Reference< css::frame::XFrame > xFrame( m_xFrame ); - aReadGuard.unlock(); + } + else if (( aElementType.equalsIgnoreAsciiCaseAscii( "progressbar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "progressbar" ))) + { + if ( m_aProgressBarElement.m_xUIElement.is() ) + return m_aProgressBarElement.m_bVisible; + } + else if ( aElementType.equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR )) + { + ReadGuard aReadLock( m_aLock ); + uno::Reference< frame::XLayoutManager > xToolbarManager( m_xToolbarManager, uno::UNO_QUERY ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + aReadLock.unlock(); - return IsDockingWindowVisible( xFrame, aElementName ); - } + if ( pToolbarManager ) + return pToolbarManager->isToolbarVisible( aName ); + } + else if ( aElementType.equalsIgnoreAsciiCaseAscii( "dockingwindow" )) + { + ReadGuard aReadGuard( m_aLock ); + uno::Reference< frame::XFrame > xFrame( m_xFrame ); + aReadGuard.unlock(); + + return IsDockingWindowVisible( xFrame, aElementName ); } return sal_False; @@ -5300,16 +2189,15 @@ throw (RuntimeException) sal_Bool SAL_CALL LayoutManager::isElementFloating( const ::rtl::OUString& aName ) throw (RuntimeException) { - UIElementVector::const_iterator pIter; - - ReadGuard aReadLock( m_aLock ); - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) + if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR )) { - if ( pIter->m_aName == aName && pIter->m_xUIElement.is() ) - { - Reference< css::awt::XDockableWindow > xDockWindow( pIter->m_xUIElement->getRealInterface(), UNO_QUERY ); - return xDockWindow.is() && xDockWindow->isFloating(); - } + ReadGuard aReadLock( m_aLock ); + uno::Reference< uno::XInterface > xToolbarManager( m_xToolbarManager, uno::UNO_QUERY ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + aReadLock.unlock(); + + if ( pToolbarManager ) + return pToolbarManager->isToolbarFloating( aName ); } return sal_False; @@ -5318,93 +2206,69 @@ throw (RuntimeException) sal_Bool SAL_CALL LayoutManager::isElementDocked( const ::rtl::OUString& aName ) throw (RuntimeException) { - UIElementVector::const_iterator pIter; - - ReadGuard aReadLock( m_aLock ); - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) + if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR )) { - if ( pIter->m_aName == aName && pIter->m_xUIElement.is() ) - { - Reference< css::awt::XDockableWindow > xDockWindow( pIter->m_xUIElement->getRealInterface(), UNO_QUERY ); - return xDockWindow.is() && !xDockWindow->isFloating(); - } - } + ReadGuard aReadLock( m_aLock ); + uno::Reference< uno::XInterface > xToolbarManager( m_xToolbarManager, uno::UNO_QUERY ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + aReadLock.unlock(); + if ( pToolbarManager ) + return pToolbarManager->isToolbarDocked( aName ); + } + return sal_False; } -::sal_Bool SAL_CALL LayoutManager::isElementLocked( const ::rtl::OUString& ResourceURL ) -throw (::com::sun::star::uno::RuntimeException) +::sal_Bool SAL_CALL LayoutManager::isElementLocked( const ::rtl::OUString& aName ) +throw (uno::RuntimeException) { - UIElementVector::const_iterator pIter; - - ReadGuard aReadLock( m_aLock ); - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) + if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR )) { - if (( pIter->m_aName == ResourceURL ) && ( pIter->m_xUIElement.is() )) - { - Reference< css::awt::XDockableWindow > xDockWindow( pIter->m_xUIElement->getRealInterface(), UNO_QUERY ); - return xDockWindow.is() && !xDockWindow->isLocked(); - } - } + ReadGuard aReadLock( m_aLock ); + uno::Reference< uno::XInterface > xToolbarManager( m_xToolbarManager, uno::UNO_QUERY ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + aReadLock.unlock(); + if ( pToolbarManager ) + return pToolbarManager->isToolbarLocked( aName ); + } + return sal_False; } -css::awt::Size SAL_CALL LayoutManager::getElementSize( const ::rtl::OUString& aName ) +awt::Size SAL_CALL LayoutManager::getElementSize( const ::rtl::OUString& aName ) throw (RuntimeException) { - ReadGuard aReadLock( m_aLock ); - UIElement aElementData; - if ( implts_findElement( aName,aElementData ) && aElementData.m_xUIElement.is() ) + if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR )) { - Reference< css::awt::XWindow > xWindow( aElementData.m_xUIElement->getRealInterface(), UNO_QUERY ); - if ( xWindow.is() ) - { - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - if ( pWindow ) - { - ::Size aSize = pWindow->GetSizePixel(); - css::awt::Size aElementSize; - aElementSize.Width = aSize.Width(); - aElementSize.Height = aSize.Height(); - return aElementSize; - } // if ( pWindow ) - } + ReadGuard aReadLock( m_aLock ); + uno::Reference< uno::XInterface > xToolbarManager( m_xToolbarManager, uno::UNO_QUERY ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + aReadLock.unlock(); + + if ( pToolbarManager ) + return pToolbarManager->getToolbarSize( aName ); } - return css::awt::Size(); + + return awt::Size(); } -css::awt::Point SAL_CALL LayoutManager::getElementPos( const ::rtl::OUString& aName ) +awt::Point SAL_CALL LayoutManager::getElementPos( const ::rtl::OUString& aName ) throw (RuntimeException) { - ReadGuard aReadLock( m_aLock ); - UIElement aElementData; - if ( implts_findElement( aName,aElementData ) && aElementData.m_xUIElement.is() ) + if ( getElementTypeFromResourceURL( aName ).equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR )) { - Reference< css::awt::XWindow > xWindow( aElementData.m_xUIElement->getRealInterface(), UNO_QUERY ); - Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY ); - if ( xDockWindow.is() ) - { - css::awt::Point aPos; - if ( aElementData.m_bFloating ) - { - css::awt::Rectangle aRect = xWindow->getPosSize(); - aPos.X = aRect.X; - aPos.Y = aRect.Y; - } - else - { - ::Point aVirtualPos = aElementData.m_aDockedData.m_aPos; - aPos.X = aVirtualPos.X(); - aPos.Y = aVirtualPos.Y(); - } + ReadGuard aReadLock( m_aLock ); + uno::Reference< uno::XInterface > xToolbarManager( m_xToolbarManager, uno::UNO_QUERY ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + aReadLock.unlock(); - return aPos; - } + if ( pToolbarManager ) + return pToolbarManager->getToolbarPos( aName ); } - - return css::awt::Point(); + + return awt::Point(); } void SAL_CALL LayoutManager::lock() @@ -5426,7 +2290,7 @@ throw (RuntimeException) #endif Any a( nLockCount ); - implts_notifyListeners( css::frame::LayoutManagerEvents::LOCK, a ); + implts_notifyListeners( frame::LayoutManagerEvents::LOCK, a ); } void SAL_CALL LayoutManager::unlock() @@ -5449,15 +2313,15 @@ throw (RuntimeException) // conform to documentation: unlock with lock count == 0 means force a layout WriteGuard aWriteLock( m_aLock ); - if ( bDoLayout ) - m_aAsyncLayoutTimer.Stop(); - aWriteLock.unlock(); + if ( bDoLayout ) + m_aAsyncLayoutTimer.Stop(); + aWriteLock.unlock(); Any a( nLockCount ); - implts_notifyListeners( css::frame::LayoutManagerEvents::UNLOCK, a ); + implts_notifyListeners( frame::LayoutManagerEvents::UNLOCK, a ); if ( bDoLayout ) - implts_doLayout_notify( sal_True ); + implts_doLayout_notify( sal_True ); } void SAL_CALL LayoutManager::doLayout() @@ -5466,62 +2330,61 @@ throw (RuntimeException) implts_doLayout_notify( sal_True ); } +//--------------------------------------------------------------------------------------------------------- +// ILayoutNotifications +//--------------------------------------------------------------------------------------------------------- +void LayoutManager::requestLayout( Hint eHint ) +{ + if ( eHint == HINT_TOOLBARSPACE_HAS_CHANGED ) + doLayout(); +} + void LayoutManager::implts_doLayout_notify( sal_Bool bOuterResize ) { - sal_Bool bLayouted = implts_doLayout( sal_False, bOuterResize ); + bool bLayouted = implts_doLayout( false, bOuterResize ); if ( bLayouted ) - implts_notifyListeners( css::frame::LayoutManagerEvents::LAYOUT, Any() ); + implts_notifyListeners( frame::LayoutManagerEvents::LAYOUT, Any() ); } sal_Bool LayoutManager::implts_doLayout( sal_Bool bForceRequestBorderSpace, sal_Bool bOuterResize ) { RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::LayoutManager::implts_doLayout" ); - sal_Bool bNoLock( sal_False ); - css::awt::Rectangle aCurrBorderSpace; - Reference< css::awt::XWindow > xContainerWindow; - Reference< css::awt::XTopWindow2 > xContainerTopWindow; - Reference< css::awt::XWindow > xComponentWindow; - Reference< XDockingAreaAcceptor > xDockingAreaAcceptor; - bool bPreserveContentSize( false ); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ ReadGuard aReadLock( m_aLock ); - sal_Bool bMustDoLayout( m_bMustDoLayout ); - if ( !m_bParentWindowVisible ) + if ( !m_xFrame.is() || !m_bParentWindowVisible ) return sal_False; - bNoLock = ( m_nLockCount == 0 ); - xContainerWindow = m_xContainerWindow; - xContainerTopWindow = m_xContainerTopWindow; - xComponentWindow = m_xFrame->getComponentWindow(); - xDockingAreaAcceptor = m_xDockingAreaAcceptor; - aCurrBorderSpace = m_aDockingArea; - bPreserveContentSize = m_bPreserveContentSize; + bool bPreserveContentSize( m_bPreserveContentSize ); + bool bMustDoLayout( m_bMustDoLayout ); + bool bNoLock = ( m_nLockCount == 0 ); + awt::Rectangle aCurrBorderSpace( m_aDockingArea ); + Reference< awt::XWindow > xContainerWindow( m_xContainerWindow ); + Reference< awt::XTopWindow2 > xContainerTopWindow( m_xContainerTopWindow ); + Reference< awt::XWindow > xComponentWindow( m_xFrame->getComponentWindow() ); + Reference< XDockingAreaAcceptor > xDockingAreaAcceptor( m_xDockingAreaAcceptor ); aReadLock.unlock(); /* SAFE AREA ----------------------------------------------------------------------------------------------- */ sal_Bool bLayouted( sal_False ); - if ( bNoLock && - xDockingAreaAcceptor.is() && - xContainerWindow.is() && - xComponentWindow.is() ) + if ( bNoLock && xDockingAreaAcceptor.is() && xContainerWindow.is() && xComponentWindow.is() ) { bLayouted = sal_True; - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteGuard( m_aLock ); m_bDoLayout = sal_True; aWriteGuard.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - - css::awt::Rectangle aBorderSpace = implts_calcDockingAreaSizes(); - sal_Bool bGotRequestedBorderSpace( sal_True ); - sal_Bool bEqual = implts_compareRectangles( aBorderSpace, aCurrBorderSpace ); - if ( !bEqual || bForceRequestBorderSpace || bMustDoLayout ) + awt::Rectangle aDockSpace( implts_calcDockingAreaSizes() ); + awt::Rectangle aBorderSpace( aDockSpace ); + sal_Bool bGotRequestedBorderSpace( sal_True ); + + // We have to add the height of a possible status bar + aBorderSpace.Height += implts_getStatusBarSize().Height(); + + if ( !equalRectangles( aBorderSpace, aCurrBorderSpace ) || bForceRequestBorderSpace || bMustDoLayout ) { // we always resize the content window (instead of the complete container window) if we're not set up // to (attempt to) preserve the content window's size @@ -5534,7 +2397,7 @@ sal_Bool LayoutManager::implts_doLayout( sal_Bool bForceRequestBorderSpace, sal_ // if the component window does not have a size (yet), then we can't use it to calc the container // window size - css::awt::Rectangle aComponentRect = xComponentWindow->getPosSize(); + awt::Rectangle aComponentRect = xComponentWindow->getPosSize(); if ( bOuterResize && ( aComponentRect.Width == 0 ) && ( aComponentRect.Height == 0 ) ) bOuterResize = sal_False; @@ -5553,52 +2416,34 @@ sal_Bool LayoutManager::implts_doLayout( sal_Bool bForceRequestBorderSpace, sal_ // if we did not do an container window resize, or it failed, then use the DockingAcceptor as usual if ( !bGotRequestedBorderSpace ) - { bGotRequestedBorderSpace = xDockingAreaAcceptor->requestDockingAreaSpace( aBorderSpace ); - if ( bGotRequestedBorderSpace ) - xDockingAreaAcceptor->setDockingAreaSpace( aBorderSpace ); - } if ( bGotRequestedBorderSpace ) { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ aWriteGuard.lock(); m_aDockingArea = aBorderSpace; m_bMustDoLayout = sal_False; aWriteGuard.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ } } if ( bGotRequestedBorderSpace ) { - ::Size aContainerSize; - ::Size aStatusBarSize; - - aStatusBarSize = implts_getStatusBarSize(); - aBorderSpace.Height -= aStatusBarSize.Height(); - implts_setDockingAreaWindowSizes( aBorderSpace ); + ::Size aContainerSize; + ::Size aStatusBarSize; + + // Interim solution to let the layout method within the + // toolbar layout manager. + implts_setOffset( implts_getStatusBarSize().Height() ); + m_pToolbarManager->setDockingArea( aDockSpace ); // Subtract status bar size from our container output size. Docking area windows // don't contain the status bar! + aStatusBarSize = implts_getStatusBarSize(); aContainerSize = implts_getContainerWindowOutputSize(); aContainerSize.Height() -= aStatusBarSize.Height(); - // Retrieve row/column dependent data from all docked user-interface elements - for ( sal_Int32 i = 0; i < DOCKINGAREAS_COUNT; i++ ) - { - std::vector< SingleRowColumnWindowData > aRowColumnsWindowData; - - implts_getDockingAreaElementInfos( (DockingArea)i, aRowColumnsWindowData ); - - sal_Int32 nOffset( 0 ); - const sal_uInt32 nCount = aRowColumnsWindowData.size(); - for ( sal_uInt32 j = 0; j < nCount; ++j ) - { - implts_calcWindowPosSizeOnSingleRowColumn( i, nOffset, aRowColumnsWindowData[j], aContainerSize ); - nOffset += aRowColumnsWindowData[j].nStaticSize; - } - } + m_pToolbarManager->doLayout(aContainerSize); // Position the status bar if ( aStatusBarSize.Height() > 0 ) @@ -5607,37 +2452,26 @@ sal_Bool LayoutManager::implts_doLayout( sal_Bool bForceRequestBorderSpace, sal_ ::Size( aContainerSize.Width(),aStatusBarSize.Height() )); } - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + xDockingAreaAcceptor->setDockingAreaSpace( aBorderSpace ); + aWriteGuard.lock(); m_bDoLayout = sal_False; aWriteGuard.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ } } return bLayouted; } -sal_Bool LayoutManager::implts_compareRectangles( const css::awt::Rectangle& rRect1, - const css::awt::Rectangle& rRect2 ) -{ - return (( rRect1.X == rRect2.X ) && - ( rRect1.Y == rRect2.Y ) && - ( rRect1.Width == rRect2.Width ) && - ( rRect1.Height == rRect2.Height )); -} - sal_Bool LayoutManager::implts_resizeContainerWindow( const awt::Size& rContainerSize, const awt::Point& rComponentPos ) { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ ReadGuard aReadLock( m_aLock ); Reference< awt::XWindow > xContainerWindow = m_xContainerWindow; Reference< awt::XTopWindow2 > xContainerTopWindow = m_xContainerTopWindow; Reference< awt::XWindow > xComponentWindow = m_xFrame->getComponentWindow(); Reference< container::XIndexAccess > xDisplayAccess = m_xDisplayAccess; aReadLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ // calculate the maximum size we have for the container window awt::Rectangle aWorkArea; @@ -5652,34 +2486,30 @@ sal_Bool LayoutManager::implts_resizeContainerWindow( const awt::Size& rContaine DBG_UNHANDLED_EXCEPTION(); } - if ( ( aWorkArea.Width > 0 ) && ( aWorkArea.Height > 0 ) ) + if (( aWorkArea.Width > 0 ) && ( aWorkArea.Height > 0 )) { - if ( ( rContainerSize.Width > aWorkArea.Width ) - || ( rContainerSize.Height > aWorkArea.Height ) - ) + if (( rContainerSize.Width > aWorkArea.Width ) || ( rContainerSize.Height > aWorkArea.Height )) return sal_False; // Strictly, this is not correct. If we have a multi-screen display (css.awt.DisplayAccess.MultiDisplay == true), // the the "effective work area" would be much larger than the work area of a single display, since we could in theory // position the container window across multiple screens. - // However, this should suffice as a heuristics here ... (nobody really wants to check whethere the different screens are + // However, this should suffice as a heuristics here ... (nobody really wants to check whether the different screens are // stacked horizontally or vertically, whether their work areas can really be combined, or are separated by non-work-areas, // and the like ... right?) } // resize our container window - xContainerWindow->setPosSize( 0, 0, rContainerSize.Width, rContainerSize.Height, css::awt::PosSize::SIZE ); + xContainerWindow->setPosSize( 0, 0, rContainerSize.Width, rContainerSize.Height, awt::PosSize::SIZE ); // position the component window - xComponentWindow->setPosSize( rComponentPos.X, rComponentPos.Y, 0, 0, css::awt::PosSize::POS ); + xComponentWindow->setPosSize( rComponentPos.X, rComponentPos.Y, 0, 0, awt::PosSize::POS ); return sal_True; } void SAL_CALL LayoutManager::setVisible( sal_Bool bVisible ) -throw (::com::sun::star::uno::RuntimeException) +throw (uno::RuntimeException) { - sal_Bool bWasVisible( sal_True ); - WriteGuard aWriteLock( m_aLock ); - bWasVisible = m_bVisible; + sal_Bool bWasVisible( m_bVisible ); m_bVisible = bVisible; aWriteLock.unlock(); @@ -5688,226 +2518,24 @@ throw (::com::sun::star::uno::RuntimeException) } sal_Bool SAL_CALL LayoutManager::isVisible() -throw (::com::sun::star::uno::RuntimeException) +throw (uno::RuntimeException) { ReadGuard aReadLock( m_aLock ); return m_bVisible; } -void LayoutManager::implts_calcWindowPosSizeOnSingleRowColumn( sal_Int32 nDockingArea, - sal_Int32 nOffset, - SingleRowColumnWindowData& rRowColumnWindowData, - const ::Size& rContainerSize ) -{ - sal_Int32 nDiff( 0 ); - sal_Int32 nRCSpace( rRowColumnWindowData.nSpace ); - sal_Int32 nTopDockingAreaSize; - sal_Int32 nBottomDockingAreaSize; - sal_Int32 nContainerClientSize; - - if ( rRowColumnWindowData.aRowColumnWindows.empty() ) - return; - - if (( nDockingArea == DockingArea_DOCKINGAREA_TOP ) || - ( nDockingArea == DockingArea_DOCKINGAREA_BOTTOM )) - { - nContainerClientSize = rContainerSize.Width(); - nDiff = nContainerClientSize - rRowColumnWindowData.nVarSize; - } - else - { - nTopDockingAreaSize = implts_getTopBottomDockingAreaSizes().Width(); - nBottomDockingAreaSize = implts_getTopBottomDockingAreaSizes().Height(); - nContainerClientSize = ( rContainerSize.Height() - nTopDockingAreaSize - nBottomDockingAreaSize ); - nDiff = nContainerClientSize - rRowColumnWindowData.nVarSize; - } - - const sal_uInt32 nCount = rRowColumnWindowData.aRowColumnWindowSizes.size(); - if (( nDiff < 0 ) && ( nRCSpace > 0 )) - { - // First we try to reduce the size of blank space before/behind docked windows - sal_Int32 i = nCount - 1; - while ( i >= 0 ) - { - sal_Int32 nSpace = rRowColumnWindowData.aRowColumnSpace[i]; - if ( nSpace >= -nDiff ) - { - - if (( nDockingArea == DockingArea_DOCKINGAREA_TOP ) || - ( nDockingArea == DockingArea_DOCKINGAREA_BOTTOM )) - { - // Try to move this and all user elements behind with the calculated difference - for ( sal_uInt32 j = i; j < nCount ; j++ ) - rRowColumnWindowData.aRowColumnWindowSizes[j].X += nDiff; - } - else - { - // Try to move this and all user elements behind with the calculated difference - for ( sal_uInt32 j = i; j < nCount ; j++ ) - rRowColumnWindowData.aRowColumnWindowSizes[j].Y += nDiff; - } - nDiff = 0; - - break; - } - else if ( nSpace > 0 ) - { - if (( nDockingArea == DockingArea_DOCKINGAREA_TOP ) || - ( nDockingArea == DockingArea_DOCKINGAREA_BOTTOM )) - { - // Try to move this and all user elements behind with the calculated difference - for ( sal_uInt32 j = i; j < nCount; j++ ) - rRowColumnWindowData.aRowColumnWindowSizes[j].X -= nSpace; - } - else - { - // Try to move this and all user elements behind with the calculated difference - for ( sal_uInt32 j = i; j < nCount; j++ ) - rRowColumnWindowData.aRowColumnWindowSizes[j].Y -= nSpace; - } - nDiff += nSpace; - } - --i; - } - } - - // Check if we have to reduce further - if ( nDiff < 0 ) - { - // Now we have to reduce the size of certain docked windows - sal_Int32 i = sal_Int32( nCount - 1 ); - while ( i >= 0 ) - { - css::awt::Rectangle& rWinRect = rRowColumnWindowData.aRowColumnWindowSizes[i]; - ::Size aMinSize; - - vos::OGuard aGuard( Application::GetSolarMutex() ); - { - Reference< css::awt::XWindow > xWindow = rRowColumnWindowData.aRowColumnWindows[i]; - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX ) - aMinSize = ((ToolBox *)pWindow)->CalcMinimumWindowSizePixel(); - } - - if (( aMinSize.Width() > 0 ) && ( aMinSize.Height() > 0 )) - { - if (( nDockingArea == DockingArea_DOCKINGAREA_TOP ) || - ( nDockingArea == DockingArea_DOCKINGAREA_BOTTOM )) - { - sal_Int32 nMaxReducation = ( rWinRect.Width - aMinSize.Width() ); - if ( nMaxReducation >= -nDiff ) - { - rWinRect.Width = rWinRect.Width + nDiff; - nDiff = 0; - } - else - { - rWinRect.Width = aMinSize.Width(); - nDiff += nMaxReducation; - } - - // Try to move this and all user elements behind with the calculated difference - for ( sal_uInt32 j = i; j < nCount; j++ ) - rRowColumnWindowData.aRowColumnWindowSizes[j].X += nDiff; - } - else - { - sal_Int32 nMaxReducation = ( rWinRect.Height - aMinSize.Height() ); - if ( nMaxReducation >= -nDiff ) - { - rWinRect.Height = rWinRect.Height + nDiff; - nDiff = 0; - } - else - { - rWinRect.Height = aMinSize.Height(); - nDiff += nMaxReducation; - } - - // Try to move this and all user elements behind with the calculated difference - for ( sal_uInt32 j = i; j < nCount; j++ ) - rRowColumnWindowData.aRowColumnWindowSizes[j].Y += nDiff; - } - } - - if ( nDiff >= 0 ) - break; - - --i; - } - } - - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - ReadGuard aReadLock( m_aLock ); - Window* pDockAreaWindow = VCLUnoHelper::GetWindow( m_xDockAreaWindows[nDockingArea] ); - aReadLock.unlock(); - - sal_Int32 nCurrPos( 0 ); - sal_Int32 nStartOffset( 0 ); - - if ( nDockingArea == DockingArea_DOCKINGAREA_RIGHT ) - nStartOffset = pDockAreaWindow->GetSizePixel().Width() - rRowColumnWindowData.nStaticSize; - else if ( nDockingArea == DockingArea_DOCKINGAREA_BOTTOM ) - nStartOffset = pDockAreaWindow->GetSizePixel().Height() - rRowColumnWindowData.nStaticSize; - - vos::OGuard aGuard( Application::GetSolarMutex() ); - for ( sal_uInt32 i = 0; i < nCount; i++ ) - { - Reference< css::awt::XWindow > xWindow = rRowColumnWindowData.aRowColumnWindows[i]; - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - Window* pOldParentWindow = pWindow->GetParent(); - - if ( pDockAreaWindow != pOldParentWindow ) - pWindow->SetParent( pDockAreaWindow ); - - css::awt::Rectangle aWinRect = rRowColumnWindowData.aRowColumnWindowSizes[i]; - if ( nDockingArea == DockingArea_DOCKINGAREA_TOP ) - { - if ( aWinRect.X < nCurrPos ) - aWinRect.X = nCurrPos; - pWindow->SetPosSizePixel( ::Point( aWinRect.X, nOffset ), - ::Size( aWinRect.Width, rRowColumnWindowData.nStaticSize )); - nCurrPos += ( aWinRect.X - nCurrPos ) + aWinRect.Width; - } - else if ( nDockingArea == DockingArea_DOCKINGAREA_BOTTOM ) - { - if ( aWinRect.X < nCurrPos ) - aWinRect.X = nCurrPos; - pWindow->SetPosSizePixel( ::Point( aWinRect.X, nStartOffset - nOffset ), - ::Size( aWinRect.Width, rRowColumnWindowData.nStaticSize )); - nCurrPos += ( aWinRect.X - nCurrPos ) + aWinRect.Width; - } - else if ( nDockingArea == DockingArea_DOCKINGAREA_LEFT ) - { - if ( aWinRect.Y < nCurrPos ) - aWinRect.Y = nCurrPos; - pWindow->SetPosSizePixel( ::Point( nOffset, aWinRect.Y ), - ::Size( rRowColumnWindowData.nStaticSize, aWinRect.Height )); - nCurrPos += ( aWinRect.Y - nCurrPos ) + aWinRect.Height; - } - else if ( nDockingArea == DockingArea_DOCKINGAREA_RIGHT ) - { - if ( aWinRect.Y < nCurrPos ) - aWinRect.Y = nCurrPos; - pWindow->SetPosSizePixel( ::Point( nStartOffset - nOffset, aWinRect.Y ), - ::Size( rRowColumnWindowData.nStaticSize, aWinRect.Height )); - nCurrPos += ( aWinRect.Y - nCurrPos ) + aWinRect.Height; - } - } -} - ::Size LayoutManager::implts_getStatusBarSize() { ReadGuard aReadLock( m_aLock ); - sal_Bool bStatusBarVisible( isElementVisible( m_aStatusBarAlias )); - sal_Bool bProgressBarVisible( isElementVisible( m_aProgressBarAlias )); - sal_Bool bVisible = m_bVisible; - Reference< XUIElement > xStatusBar = m_aStatusBarElement.m_xUIElement; - Reference< XUIElement > xProgressBar = m_aProgressBarElement.m_xUIElement; + bool bStatusBarVisible( isElementVisible( m_aStatusBarAlias )); + bool bProgressBarVisible( isElementVisible( m_aProgressBarAlias )); + bool bVisible( m_bVisible ); + Reference< XUIElement > xStatusBar( m_aStatusBarElement.m_xUIElement ); + Reference< XUIElement > xProgressBar( m_aProgressBarElement.m_xUIElement ); - Reference< css::awt::XWindow > xWindow; + Reference< awt::XWindow > xWindow; if ( bStatusBarVisible && bVisible && xStatusBar.is() ) - xWindow = Reference< css::awt::XWindow >( xStatusBar->getRealInterface(), UNO_QUERY ); + xWindow = Reference< awt::XWindow >( xStatusBar->getRealInterface(), UNO_QUERY ); else if ( xProgressBar.is() && !xStatusBar.is() && bProgressBarVisible ) { ProgressBarWrapper* pWrapper = (ProgressBarWrapper*)xProgressBar.get(); @@ -5918,194 +2546,40 @@ void LayoutManager::implts_calcWindowPosSizeOnSingleRowColumn( sal_Int32 nDockin if ( xWindow.is() ) { - css::awt::Rectangle aPosSize = xWindow->getPosSize(); + awt::Rectangle aPosSize = xWindow->getPosSize(); return ::Size( aPosSize.Width, aPosSize.Height ); } else return ::Size(); } -css::awt::Rectangle LayoutManager::implts_calcDockingAreaSizes() +awt::Rectangle LayoutManager::implts_calcDockingAreaSizes() { - Reference< css::awt::XWindow > xContainerWindow; - Reference< XDockingAreaAcceptor > xDockingAreaAcceptor; - ReadGuard aReadLock( m_aLock ); - xContainerWindow = m_xContainerWindow; - xDockingAreaAcceptor = m_xDockingAreaAcceptor; - UIElementVector aWindowVector( m_aUIElements ); + Reference< awt::XWindow > xContainerWindow( m_xContainerWindow ); + Reference< XDockingAreaAcceptor > xDockingAreaAcceptor( m_xDockingAreaAcceptor ); aReadLock.unlock(); - css::awt::Rectangle aBorderSpace; + awt::Rectangle aBorderSpace; if ( xDockingAreaAcceptor.is() && xContainerWindow.is() ) - { - sal_Int32 nCurrRowColumn( 0 ); - sal_Int32 nCurrPos( 0 ); - sal_Int32 nCurrDockingArea( DockingArea_DOCKINGAREA_TOP ); - std::vector< sal_Int32 > aRowColumnSizes[DOCKINGAREAS_COUNT]; - UIElementVector::const_iterator pConstIter; - - aRowColumnSizes[nCurrDockingArea].clear(); - aRowColumnSizes[nCurrDockingArea].push_back( 0 ); - - for ( pConstIter = aWindowVector.begin(); pConstIter != aWindowVector.end(); pConstIter++ ) - { - Reference< XUIElement > xUIElement( pConstIter->m_xUIElement, UNO_QUERY ); - if ( xUIElement.is() ) - { - Reference< css::awt::XWindow > xWindow( xUIElement->getRealInterface(), UNO_QUERY ); - Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY ); - if ( xWindow.is() && xDockWindow.is() ) - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - if ( pWindow && pWindow->IsVisible() && !xDockWindow->isFloating() ) - { - css::awt::Rectangle aPosSize = xWindow->getPosSize(); - if ( pConstIter->m_aDockedData.m_nDockedArea != nCurrDockingArea ) - { - nCurrDockingArea = pConstIter->m_aDockedData.m_nDockedArea; - nCurrRowColumn = 0; - nCurrPos = 0; - aRowColumnSizes[nCurrDockingArea].clear(); - aRowColumnSizes[nCurrDockingArea].push_back( 0 ); - } - - if ( pConstIter->m_aDockedData.m_nDockedArea == nCurrDockingArea ) - { - if (( pConstIter->m_aDockedData.m_nDockedArea == DockingArea_DOCKINGAREA_TOP ) || - ( pConstIter->m_aDockedData.m_nDockedArea == DockingArea_DOCKINGAREA_BOTTOM )) - { - if ( pConstIter->m_aDockedData.m_aPos.Y() > nCurrPos ) - { - ++nCurrRowColumn; - nCurrPos = pConstIter->m_aDockedData.m_aPos.Y(); - aRowColumnSizes[nCurrDockingArea].push_back( 0 ); - } - - if ( aPosSize.Height > aRowColumnSizes[nCurrDockingArea][nCurrRowColumn] ) - aRowColumnSizes[nCurrDockingArea][nCurrRowColumn] = aPosSize.Height; - } - else - { - if ( pConstIter->m_aDockedData.m_aPos.X() > nCurrPos ) - { - ++nCurrRowColumn; - nCurrPos = pConstIter->m_aDockedData.m_aPos.X(); - aRowColumnSizes[nCurrDockingArea].push_back( 0 ); - } - - if ( aPosSize.Width > aRowColumnSizes[nCurrDockingArea][nCurrRowColumn] ) - aRowColumnSizes[nCurrDockingArea][nCurrRowColumn] = aPosSize.Width; - } - } - } - } - } - } - - // Sum up max heights from every row/column - if ( !aWindowVector.empty() ) - { - for ( sal_Int32 i = 0; i <= DockingArea_DOCKINGAREA_RIGHT; i++ ) - { - sal_Int32 nSize( 0 ); - const sal_uInt32 nCount = aRowColumnSizes[i].size(); - for ( sal_uInt32 j = 0; j < nCount; j++ ) - nSize += aRowColumnSizes[i][j]; - - if ( i == DockingArea_DOCKINGAREA_TOP ) - aBorderSpace.Y = nSize; - else if ( i == DockingArea_DOCKINGAREA_BOTTOM ) - aBorderSpace.Height = nSize; - else if ( i == DockingArea_DOCKINGAREA_LEFT ) - aBorderSpace.X = nSize; - else - aBorderSpace.Width = nSize; - } - } - - // We have to add the height of a possible status bar - aBorderSpace.Height += implts_getStatusBarSize().Height(); - } - + aBorderSpace = m_pToolbarManager->getDockingArea(); + return aBorderSpace; } -void LayoutManager::implts_setDockingAreaWindowSizes( const css::awt::Rectangle& rBorderSpace ) +void LayoutManager::implts_setDockingAreaWindowSizes( const awt::Rectangle& /*rBorderSpace*/ ) { - Reference< css::awt::XWindow > xContainerWindow; - ReadGuard aReadLock( m_aLock ); - xContainerWindow = m_xContainerWindow; + Reference< awt::XWindow > xContainerWindow( m_xContainerWindow ); aReadLock.unlock(); - css::uno::Reference< css::awt::XDevice > xDevice( xContainerWindow, css::uno::UNO_QUERY ); + uno::Reference< awt::XDevice > xDevice( xContainerWindow, uno::UNO_QUERY ); // Convert relativ size to output size. - css::awt::Rectangle aRectangle = xContainerWindow->getPosSize(); - css::awt::DeviceInfo aInfo = xDevice->getInfo(); - css::awt::Size aContainerClientSize = css::awt::Size( aRectangle.Width - aInfo.LeftInset - aInfo.RightInset , - aRectangle.Height - aInfo.TopInset - aInfo.BottomInset ); - ::Size aStatusBarSize = implts_getStatusBarSize(); - - sal_Int32 nLeftRightDockingAreaHeight( aContainerClientSize.Height ); - if ( rBorderSpace.Y >= 0 ) - { - // Top docking area window - aReadLock.lock(); - Reference< css::awt::XWindow > xDockAreaWindow( m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP] ); - aReadLock.unlock(); - - xDockAreaWindow->setPosSize( 0, 0, aContainerClientSize.Width, rBorderSpace.Y, css::awt::PosSize::POSSIZE ); - xDockAreaWindow->setVisible( sal_True ); - nLeftRightDockingAreaHeight -= rBorderSpace.Y; - } - - if ( rBorderSpace.Height >= 0 ) - { - // Bottom docking area window - sal_Int32 nBottomPos = std::max( sal_Int32( aContainerClientSize.Height - rBorderSpace.Height - aStatusBarSize.Height() ), sal_Int32( 0 )); - sal_Int32 nHeight = ( nBottomPos == 0 ) ? 0 : rBorderSpace.Height; - - aReadLock.lock(); - Reference< css::awt::XWindow > xDockAreaWindow( m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM] ); - aReadLock.unlock(); - - xDockAreaWindow->setPosSize( 0, nBottomPos, aContainerClientSize.Width, nHeight, css::awt::PosSize::POSSIZE ); - xDockAreaWindow->setVisible( sal_True ); - nLeftRightDockingAreaHeight -= nHeight; - } - - nLeftRightDockingAreaHeight -= aStatusBarSize.Height(); - if ( rBorderSpace.X >= 0 || nLeftRightDockingAreaHeight > 0 ) - { - // Left docking area window - aReadLock.lock(); - Reference< css::awt::XWindow > xDockAreaWindow( m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT] ); - aReadLock.unlock(); - - // We also have to change our right docking area window if the top or bottom area has changed. They have a higher priority! - sal_Int32 nHeight = std::max( sal_Int32( 0 ), sal_Int32( nLeftRightDockingAreaHeight )); - - xDockAreaWindow->setPosSize( 0, rBorderSpace.Y, rBorderSpace.X, nHeight, css::awt::PosSize::POSSIZE ); - xDockAreaWindow->setVisible( sal_True ); - } - if ( rBorderSpace.Width >= 0 || nLeftRightDockingAreaHeight > 0 ) - { - // Right docking area window - aReadLock.lock(); - Reference< css::awt::XWindow > xDockAreaWindow( m_xDockAreaWindows[DockingArea_DOCKINGAREA_RIGHT] ); - aReadLock.unlock(); - - // We also have to change our right docking area window if the top or bottom area has changed. They have a higher priority! - sal_Int32 nLeftPos = std::max( sal_Int32( 0 ), sal_Int32( aContainerClientSize.Width - rBorderSpace.Width )); - sal_Int32 nHeight = std::max( sal_Int32( 0 ), sal_Int32( nLeftRightDockingAreaHeight )); - sal_Int32 nWidth = ( nLeftPos == 0 ) ? 0 : rBorderSpace.Width; - - xDockAreaWindow->setPosSize( nLeftPos, rBorderSpace.Y, nWidth, nHeight, css::awt::PosSize::POSSIZE ); - xDockAreaWindow->setVisible( sal_True ); - } + awt::Rectangle aRectangle = xContainerWindow->getPosSize(); + awt::DeviceInfo aInfo = xDevice->getInfo(); + awt::Size aContainerClientSize = awt::Size( aRectangle.Width - aInfo.LeftInset - aInfo.RightInset, + aRectangle.Height - aInfo.TopInset - aInfo.BottomInset ); + ::Size aStatusBarSize = implts_getStatusBarSize(); // Position the status bar if ( aStatusBarSize.Height() > 0 ) @@ -6116,41 +2590,28 @@ void LayoutManager::implts_setDockingAreaWindowSizes( const css::awt::Rectangle& } //--------------------------------------------------------------------------------------------------------- -// XMenuCloser +// XMenuCloser //--------------------------------------------------------------------------------------------------------- void LayoutManager::implts_updateMenuBarClose() { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); - sal_Bool bShowCloser = m_bMenuBarCloser; - Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow ); + bool bShowCloser( m_bMenuBarCloser ); + Reference< awt::XWindow > xContainerWindow( m_xContainerWindow ); aWriteLock.unlock(); if ( xContainerWindow.is() ) { - vos::OGuard aGuard( Application::GetSolarMutex() ); + vos::OGuard aGuard( Application::GetSolarMutex() ); - Window* pWindow = VCLUnoHelper::GetWindow( xContainerWindow ); - while ( pWindow && !pWindow->IsSystemWindow() ) - pWindow = pWindow->GetParent(); - - if ( pWindow ) + SystemWindow* pSysWindow = getTopSystemWindow( xContainerWindow ); + if ( pSysWindow ) { - SystemWindow* pSysWindow = (SystemWindow *)pWindow; MenuBar* pMenuBar = pSysWindow->GetMenuBar(); if ( pMenuBar ) { // TODO remove link on FALSE ?! - if ( bShowCloser ) - { - pMenuBar->ShowCloser( TRUE ); - pMenuBar->SetCloserHdl( LINK( this, LayoutManager, MenuBarClose )); - } - else - { - pMenuBar->ShowCloser( FALSE ); - pMenuBar->SetCloserHdl( LINK( this, LayoutManager, MenuBarClose )); - } + pMenuBar->ShowCloser( bShowCloser ); + pMenuBar->SetCloserHdl( LINK( this, LayoutManager, MenuBarClose )); } } } @@ -6161,28 +2622,25 @@ sal_Bool LayoutManager::implts_resetMenuBar() /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); sal_Bool bMenuVisible( m_bMenuVisible ); - Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow ); + Reference< awt::XWindow > xContainerWindow( m_xContainerWindow ); MenuBar* pSetMenuBar = 0; if ( m_xInplaceMenuBar.is() ) pSetMenuBar = (MenuBar *)m_pInplaceMenuBar->GetMenuBar(); else { - MenuBarWrapper* pMenuBarWrapper = SAL_STATIC_CAST( MenuBarWrapper*, m_xMenuBar.get() ); + MenuBarWrapper* pMenuBarWrapper = static_cast< MenuBarWrapper* >( m_xMenuBar.get() ); if ( pMenuBarWrapper ) pSetMenuBar = (MenuBar *)pMenuBarWrapper->GetMenuBarManager()->GetMenuBar(); } aWriteLock.unlock(); /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - vos::OGuard aGuard( Application::GetSolarMutex() ); - Window* pWindow = VCLUnoHelper::GetWindow( m_xContainerWindow ); - while ( pWindow && !pWindow->IsSystemWindow() ) - pWindow = pWindow->GetParent(); - - if ( pWindow && bMenuVisible && pSetMenuBar ) + vos::OGuard aGuard( Application::GetSolarMutex() ); + SystemWindow* pSysWindow = getTopSystemWindow( xContainerWindow ); + if ( pSysWindow && bMenuVisible && pSetMenuBar ) { - ((SystemWindow *)pWindow)->SetMenuBar( pSetMenuBar ); + pSysWindow->SetMenuBar( pSetMenuBar ); pSetMenuBar->SetDisplayable( sal_True ); return sal_True; } @@ -6190,726 +2648,62 @@ sal_Bool LayoutManager::implts_resetMenuBar() return sal_False; } -sal_Int16 LayoutManager::implts_getCurrentSymbolsSize() -{ - sal_Int16 eOptSymbolsSize( 0 ); - - { - ReadGuard aReadLock( m_aLock ); - vos::OGuard aGuard( Application::GetSolarMutex() ); - if ( m_pMiscOptions ) - eOptSymbolsSize = m_pMiscOptions->GetCurrentSymbolsSize(); - } - - return eOptSymbolsSize; -} - -sal_Int16 LayoutManager::implts_getCurrentSymbolsStyle() +void LayoutManager::implts_setMenuBarCloser(sal_Bool bCloserState) { - sal_Int16 eOptSymbolsStyle( 0 ); - - { - ReadGuard aReadLock( m_aLock ); - vos::OGuard aGuard( Application::GetSolarMutex() ); - if ( m_pMiscOptions ) - eOptSymbolsStyle = m_pMiscOptions->GetCurrentSymbolsStyle(); - } + WriteGuard aWriteLock( m_aLock ); + m_bMenuBarCloser = bCloserState; + aWriteLock.unlock(); - return eOptSymbolsStyle; + implts_updateMenuBarClose(); } IMPL_LINK( LayoutManager, MenuBarClose, MenuBar *, EMPTYARG ) { ReadGuard aReadLock( m_aLock ); - css::uno::Reference< css::frame::XDispatchProvider > xProvider(m_xFrame, css::uno::UNO_QUERY); - css::uno::Reference< css::lang::XMultiServiceFactory > xSMGR = m_xSMGR; + uno::Reference< frame::XDispatchProvider > xProvider(m_xFrame, uno::UNO_QUERY); + uno::Reference< lang::XMultiServiceFactory > xSMGR = m_xSMGR; aReadLock.unlock(); - if (! xProvider.is()) + if ( !xProvider.is()) return 0; - css::uno::Reference< css::frame::XDispatchHelper > xDispatcher( - xSMGR->createInstance(SERVICENAME_DISPATCHHELPER), css::uno::UNO_QUERY_THROW); + uno::Reference< frame::XDispatchHelper > xDispatcher( + xSMGR->createInstance(SERVICENAME_DISPATCHHELPER), uno::UNO_QUERY_THROW); xDispatcher->executeDispatch( xProvider, ::rtl::OUString::createFromAscii(".uno:CloseWin"), ::rtl::OUString::createFromAscii("_self"), 0, - css::uno::Sequence< css::beans::PropertyValue >()); + uno::Sequence< beans::PropertyValue >()); return 0; } -IMPL_LINK( LayoutManager, OptionsChanged, void*, EMPTYARG ) -{ - sal_Int16 eSymbolsSize( implts_getCurrentSymbolsSize() ); - sal_Int16 eSymbolsStyle( implts_getCurrentSymbolsStyle() ); - - ReadGuard aReadLock( m_aLock ); - sal_Int16 eOldSymbolsSize = m_eSymbolsSize; - sal_Int16 eOldSymbolsStyle = m_eSymbolsStyle; - aReadLock.unlock(); - - if ( eSymbolsSize != eOldSymbolsSize || eSymbolsStyle != eOldSymbolsStyle ) - { - WriteGuard aWriteLock( m_aLock ); - m_eSymbolsSize = eSymbolsSize; - m_eSymbolsStyle = eSymbolsStyle; - aWriteLock.unlock(); - - std::vector< Reference< XUpdatable > > aToolBarVector; - - aReadLock.lock(); - { - UIElementVector::iterator pIter; - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - { - if ( pIter->m_xUIElement.is() ) - aToolBarVector.push_back( Reference< XUpdatable >( pIter->m_xUIElement, UNO_QUERY )); - } - } - aReadLock.unlock(); - - lock(); - { - std::vector< Reference< XUpdatable > >::iterator pIter; - for ( pIter = aToolBarVector.begin(); pIter != aToolBarVector.end(); pIter++ ) - { - if ( (*pIter).is() ) - (*pIter)->update(); - } - } - unlock(); - doLayout(); - } - - return 1; -} - IMPL_LINK( LayoutManager, SettingsChanged, void*, EMPTYARG ) { return 1; } //--------------------------------------------------------------------------------------------------------- -// XDockableWindowListener -//--------------------------------------------------------------------------------------------------------- -void SAL_CALL LayoutManager::startDocking( const ::com::sun::star::awt::DockingEvent& e ) throw (::com::sun::star::uno::RuntimeException) -{ - sal_Bool bWinFound( sal_False ); - UIElement aUIElement; - - ReadGuard aReadGuard( m_aLock ); - Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow ); - Reference< css::awt::XWindow2 > xWindow( e.Source, UNO_QUERY ); - aReadGuard.unlock(); - - Window* pContainerWindow( 0 ); - Window* pWindow( 0 ); - ::Point aMousePos; - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - pContainerWindow = VCLUnoHelper::GetWindow( xContainerWindow ); - aMousePos = pContainerWindow->ScreenToOutputPixel( ::Point( e.MousePos.X, e.MousePos.Y )); - } - - bWinFound = implts_findElement( e.Source, aUIElement ); - - if ( bWinFound && xWindow.is() ) - { - css::awt::Rectangle aRect; - Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY ); - if ( xDockWindow->isFloating() ) - { - css::awt::Rectangle aPos = xWindow->getPosSize(); - css::awt::Size aSize = xWindow->getOutputSize(); - - aUIElement.m_aFloatingData.m_aPos = ::Point( aPos.X, aPos.Y ); - aUIElement.m_aFloatingData.m_aSize = ::Size( aSize.Width, aSize.Height ); - - vos::OGuard aGuard( Application::GetSolarMutex() ); - pWindow = VCLUnoHelper::GetWindow( xWindow ); - if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX ) - { - ToolBox* pToolBox = (ToolBox *)pWindow; - aUIElement.m_aFloatingData.m_nLines = pToolBox->GetFloatingLines(); - aUIElement.m_aFloatingData.m_bIsHorizontal = (( pToolBox->GetAlign() == WINDOWALIGN_TOP ) || - ( pToolBox->GetAlign() == WINDOWALIGN_BOTTOM )); - } - } - } - - WriteGuard aWriteLock( m_aLock ); - m_bDockingInProgress = bWinFound; - m_aDockUIElement = aUIElement; - m_aDockUIElement.m_bUserActive = sal_True; - m_aStartDockMousePos = aMousePos; - aWriteLock.unlock(); -} - -::Rectangle LayoutManager::implts_calcHotZoneRect( const ::Rectangle& rRect, sal_Int32 nHotZoneOffset ) -{ - ::Rectangle aRect( rRect ); - - aRect.Left() -= nHotZoneOffset; - aRect.Top() -= nHotZoneOffset; - aRect.Right() += nHotZoneOffset; - aRect.Bottom() += nHotZoneOffset; - return aRect; -} - -css::awt::DockingData SAL_CALL LayoutManager::docking( const ::com::sun::star::awt::DockingEvent& e ) -throw (::com::sun::star::uno::RuntimeException) -{ - const sal_Int32 MAGNETIC_DISTANCE_UNDOCK = 25; - const sal_Int32 MAGNETIC_DISTANCE_DOCK = 20; - - css::awt::DockingData aDockingData; - Reference< css::awt::XDockableWindow > xDockWindow( e.Source, UNO_QUERY ); - Reference< css::awt::XWindow > xWindow( e.Source, UNO_QUERY ); - Reference< css::awt::XWindow > xTopDockingWindow; - Reference< css::awt::XWindow > xLeftDockingWindow; - Reference< css::awt::XWindow > xRightDockingWindow; - Reference< css::awt::XWindow > xBottomDockingWindow; - Reference< css::awt::XWindow > xContainerWindow; - UIElement aUIDockingElement; - DockingOperation eDockingOperation( DOCKOP_ON_COLROW ); - ::Size aStatusBarSize; - - aDockingData.TrackingRectangle = e.TrackingRectangle; - sal_Bool bDockingInProgress; - - { - ReadGuard aReadLock( m_aLock ); - bDockingInProgress = m_bDockingInProgress; - if ( bDockingInProgress ) - { - xContainerWindow = m_xContainerWindow; - xTopDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_TOP]; - xLeftDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_LEFT]; - xRightDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_RIGHT]; - xBottomDockingWindow = m_xDockAreaWindows[DockingArea_DOCKINGAREA_BOTTOM]; - aUIDockingElement = m_aDockUIElement; - aStatusBarSize = implts_getStatusBarSize(); - } - } - - if ( bDockingInProgress && - xDockWindow.is() && - xWindow.is() ) - { - try - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - - sal_Int16 eDockingArea( -1 ); // none - sal_Int32 nMagneticZone( aUIDockingElement.m_bFloating ? MAGNETIC_DISTANCE_DOCK : MAGNETIC_DISTANCE_UNDOCK ); - css::awt::Rectangle aNewTrackingRect; - ::Rectangle aTrackingRect( e.TrackingRectangle.X, - e.TrackingRectangle.Y, - ( e.TrackingRectangle.X + e.TrackingRectangle.Width ), - ( e.TrackingRectangle.Y + e.TrackingRectangle.Height )); - - css::awt::Rectangle aTmpRect = xTopDockingWindow->getPosSize(); - ::Rectangle aTopDockRect( aTmpRect.X, aTmpRect.Y, aTmpRect.Width, aTmpRect.Height ); - ::Rectangle aHotZoneTopDockRect( implts_calcHotZoneRect( aTopDockRect, nMagneticZone )); - - aTmpRect = xBottomDockingWindow->getPosSize(); - ::Rectangle aBottomDockRect( aTmpRect.X, aTmpRect.Y, ( aTmpRect.X + aTmpRect.Width), ( aTmpRect.Y + aTmpRect.Height )); - ::Rectangle aHotZoneBottomDockRect( implts_calcHotZoneRect( aBottomDockRect, nMagneticZone )); - - aTmpRect = xLeftDockingWindow->getPosSize(); - ::Rectangle aLeftDockRect( aTmpRect.X, aTmpRect.Y, ( aTmpRect.X + aTmpRect.Width ), ( aTmpRect.Y + aTmpRect.Height )); - ::Rectangle aHotZoneLeftDockRect( implts_calcHotZoneRect( aLeftDockRect, nMagneticZone )); - - aTmpRect = xRightDockingWindow->getPosSize(); - ::Rectangle aRightDockRect( aTmpRect.X, aTmpRect.Y, ( aTmpRect.X + aTmpRect.Width ), ( aTmpRect.Y + aTmpRect.Height )); - ::Rectangle aHotZoneRightDockRect( implts_calcHotZoneRect( aRightDockRect, nMagneticZone )); - - Window* pContainerWindow( VCLUnoHelper::GetWindow( xContainerWindow ) ); - Window* pDockingAreaWindow( 0 ); - ::Point aMousePos( pContainerWindow->ScreenToOutputPixel( ::Point( e.MousePos.X, e.MousePos.Y ))); - - if ( aHotZoneTopDockRect.IsInside( aMousePos )) - eDockingArea = DockingArea_DOCKINGAREA_TOP; - else if ( aHotZoneBottomDockRect.IsInside( aMousePos )) - eDockingArea = DockingArea_DOCKINGAREA_BOTTOM; - else if ( aHotZoneLeftDockRect.IsInside( aMousePos )) - eDockingArea = DockingArea_DOCKINGAREA_LEFT; - else if ( aHotZoneRightDockRect.IsInside( aMousePos )) - eDockingArea = DockingArea_DOCKINGAREA_RIGHT; - - // Higher priority for movements inside the real docking area - if ( aTopDockRect.IsInside( aMousePos )) - eDockingArea = DockingArea_DOCKINGAREA_TOP; - else if ( aBottomDockRect.IsInside( aMousePos )) - eDockingArea = DockingArea_DOCKINGAREA_BOTTOM; - else if ( aLeftDockRect.IsInside( aMousePos )) - eDockingArea = DockingArea_DOCKINGAREA_LEFT; - else if ( aRightDockRect.IsInside( aMousePos )) - eDockingArea = DockingArea_DOCKINGAREA_RIGHT; - - // Determine if we have a toolbar and set alignment according to the docking area! - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - ToolBox* pToolBox = 0; - if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX ) - pToolBox = (ToolBox *)pWindow; - - if ( eDockingArea != -1 ) - { - if ( eDockingArea == DockingArea_DOCKINGAREA_TOP ) - { - aUIDockingElement.m_aDockedData.m_nDockedArea = DockingArea_DOCKINGAREA_TOP; - aUIDockingElement.m_bFloating = sal_False; - pDockingAreaWindow = VCLUnoHelper::GetWindow( xTopDockingWindow ); - } - else if ( eDockingArea == DockingArea_DOCKINGAREA_BOTTOM ) - { - aUIDockingElement.m_aDockedData.m_nDockedArea = DockingArea_DOCKINGAREA_BOTTOM; - aUIDockingElement.m_bFloating = sal_False; - pDockingAreaWindow = VCLUnoHelper::GetWindow( xBottomDockingWindow ); - } - else if ( eDockingArea == DockingArea_DOCKINGAREA_LEFT ) - { - aUIDockingElement.m_aDockedData.m_nDockedArea = DockingArea_DOCKINGAREA_LEFT; - aUIDockingElement.m_bFloating = sal_False; - pDockingAreaWindow = VCLUnoHelper::GetWindow( xLeftDockingWindow ); - } - else if ( eDockingArea == DockingArea_DOCKINGAREA_RIGHT ) - { - aUIDockingElement.m_aDockedData.m_nDockedArea = DockingArea_DOCKINGAREA_RIGHT; - aUIDockingElement.m_bFloating = sal_False; - pDockingAreaWindow = VCLUnoHelper::GetWindow( xRightDockingWindow ); - } - - ::Point aOutputPos = pContainerWindow->ScreenToOutputPixel( aTrackingRect.TopLeft() ); - aTrackingRect.SetPos( aOutputPos ); - - ::Rectangle aNewDockingRect( aTrackingRect ); - implts_calcDockingPosSize( aUIDockingElement, eDockingOperation, aNewDockingRect, aMousePos ); - - ::Point aScreenPos = pContainerWindow->OutputToScreenPixel( aNewDockingRect.TopLeft() ); - aNewTrackingRect = css::awt::Rectangle( aScreenPos.X(), - aScreenPos.Y(), - aNewDockingRect.getWidth(), - aNewDockingRect.getHeight() ); - aDockingData.TrackingRectangle = aNewTrackingRect; - } - else if ( pToolBox && bDockingInProgress ) - { - sal_Bool bIsHorizontal = (( pToolBox->GetAlign() == WINDOWALIGN_TOP ) || - ( pToolBox->GetAlign() == WINDOWALIGN_BOTTOM )); - ::Size aFloatSize = aUIDockingElement.m_aFloatingData.m_aSize; - if ( aFloatSize.Width() > 0 && aFloatSize.Height() > 0 ) - { - aUIDockingElement.m_aFloatingData.m_aPos = pContainerWindow->ScreenToOutputPixel( - ::Point( e.MousePos.X, e.MousePos.Y )); - aDockingData.TrackingRectangle.Height = aFloatSize.Height(); - aDockingData.TrackingRectangle.Width = aFloatSize.Width(); - } - else - { - aFloatSize = pToolBox->CalcWindowSizePixel(); - if ( !bIsHorizontal ) - { - // Floating toolbars are always horizontal aligned! We have to swap - // width/height if we have a vertical aligned toolbar. - sal_Int32 nTemp = aFloatSize.Height(); - aFloatSize.Height() = aFloatSize.Width(); - aFloatSize.Width() = nTemp; - } - - aDockingData.TrackingRectangle.Height = aFloatSize.Height(); - aDockingData.TrackingRectangle.Width = aFloatSize.Width(); - - // For the first time we don't have any data about the floating size of a toolbar. - // We calculate it and store it for later use. - aUIDockingElement.m_aFloatingData.m_aPos = pContainerWindow->ScreenToOutputPixel( - ::Point( e.MousePos.X, e.MousePos.Y )); - aUIDockingElement.m_aFloatingData.m_aSize = aFloatSize; - aUIDockingElement.m_aFloatingData.m_nLines = pToolBox->GetFloatingLines(); - aUIDockingElement.m_aFloatingData.m_bIsHorizontal = (( pToolBox->GetAlign() == WINDOWALIGN_TOP ) || - ( pToolBox->GetAlign() == WINDOWALIGN_BOTTOM )); - } - aDockingData.TrackingRectangle.X = e.MousePos.X; - aDockingData.TrackingRectangle.Y = e.MousePos.Y; - } - - aDockingData.bFloating = ( eDockingArea == -1 ); - - // Write current data to the member docking progress data - WriteGuard aWriteLock( m_aLock ); - m_aDockUIElement.m_bFloating = aDockingData.bFloating; - if ( !aDockingData.bFloating ) - { - m_aDockUIElement.m_aDockedData = aUIDockingElement.m_aDockedData; - m_eDockOperation = eDockingOperation; - } - else - m_aDockUIElement.m_aFloatingData = aUIDockingElement.m_aFloatingData; - aWriteLock.unlock(); - } - catch ( Exception& ) - { - } - } - - return aDockingData; -} - -void SAL_CALL LayoutManager::endDocking( const ::com::sun::star::awt::EndDockingEvent& e ) -throw (::com::sun::star::uno::RuntimeException) -{ - sal_Bool bDockingInProgress( sal_False ); - sal_Bool bStartDockFloated( sal_False ); - sal_Bool bFloating( sal_False ); - UIElement aUIDockingElement; - - WriteGuard aWriteLock( m_aLock ); - bDockingInProgress = m_bDockingInProgress; - aUIDockingElement = m_aDockUIElement; - bFloating = aUIDockingElement.m_bFloating; - - UIElement& rUIElement = impl_findElement( aUIDockingElement.m_aName ); - if ( rUIElement.m_aName == aUIDockingElement.m_aName ) - { - if ( aUIDockingElement.m_bFloating ) - { - // Write last position into position data - Reference< css::awt::XWindow > xWindow( aUIDockingElement.m_xUIElement->getRealInterface(), UNO_QUERY ); - rUIElement.m_aFloatingData = aUIDockingElement.m_aFloatingData; - css::awt::Rectangle aTmpRect = xWindow->getPosSize(); - rUIElement.m_aFloatingData.m_aPos = ::Point( aTmpRect.X, aTmpRect.Y ); - // make changes also for our local data as we use it to make data persistent - aUIDockingElement.m_aFloatingData = rUIElement.m_aFloatingData; - } - else - { - rUIElement.m_aDockedData = aUIDockingElement.m_aDockedData; - rUIElement.m_aFloatingData.m_aSize = aUIDockingElement.m_aFloatingData.m_aSize; - - if ( m_eDockOperation != DOCKOP_ON_COLROW ) - { - // we have to renumber our row/column data to insert a new row/column - implts_renumberRowColumnData( (::com::sun::star::ui::DockingArea)aUIDockingElement.m_aDockedData.m_nDockedArea, - m_eDockOperation, - aUIDockingElement ); - } - } - - bStartDockFloated = rUIElement.m_bFloating; - rUIElement.m_bFloating = m_aDockUIElement.m_bFloating; - rUIElement.m_bUserActive = sal_True; - } - - // reset member for next docking operation - m_aDockUIElement.m_xUIElement.clear(); - m_eDockOperation = DOCKOP_ON_COLROW; - aWriteLock.unlock(); - - implts_writeWindowStateData( aUIDockingElement.m_aName, aUIDockingElement ); - - if ( bDockingInProgress ) - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - Window* pWindow = VCLUnoHelper::GetWindow( Reference< css::awt::XWindow >( e.Source, UNO_QUERY )); - ToolBox* pToolBox = 0; - if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX ) - pToolBox = (ToolBox *)pWindow; - - if ( pToolBox ) - { - if( e.bFloating ) - { - if ( aUIDockingElement.m_aFloatingData.m_bIsHorizontal ) - pToolBox->SetAlign( WINDOWALIGN_TOP ); - else - pToolBox->SetAlign( WINDOWALIGN_LEFT ); - } - else - { - ::Size aSize; - - pToolBox->SetAlign( ImplConvertAlignment( aUIDockingElement.m_aDockedData.m_nDockedArea) ); - - // Docked toolbars have always one line - aSize = pToolBox->CalcWindowSizePixel( 1 ); - - // Lock layouting updates as our listener would be called due to SetSizePixel - pToolBox->SetOutputSizePixel( aSize ); - } - } - } - - aWriteLock.lock(); - m_bDockingInProgress = sal_False; - aWriteLock.unlock(); - - implts_sortUIElements(); - if ( !bStartDockFloated || !bFloating ) - { - // Optimization: Don't layout if we started floating and now floating again. - // This would not change anything for the docked user-interface elements. - doLayout(); - } -} - -sal_Bool SAL_CALL LayoutManager::prepareToggleFloatingMode( const ::com::sun::star::lang::EventObject& e ) -throw (::com::sun::star::uno::RuntimeException) -{ - sal_Bool bDockingInProgress( sal_False ); - - ReadGuard aReadLock( m_aLock ); - bDockingInProgress = m_bDockingInProgress; - aReadLock.unlock(); - - UIElement aUIDockingElement; - sal_Bool bWinFound( implts_findElement( e.Source, aUIDockingElement ) ); - Reference< css::awt::XWindow > xWindow( e.Source, UNO_QUERY ); - - if ( bWinFound && xWindow.is() ) - { - if ( !bDockingInProgress ) - { - css::awt::Rectangle aRect; - Reference< css::awt::XDockableWindow > xDockWindow( xWindow, UNO_QUERY ); - if ( xDockWindow->isFloating() ) - { - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - if ( pWindow ) - { - if ( pWindow->GetType() == WINDOW_TOOLBOX ) - { - ToolBox* pToolBox = (ToolBox *)pWindow; - aUIDockingElement.m_aFloatingData.m_aPos = pToolBox->GetPosPixel(); - aUIDockingElement.m_aFloatingData.m_aSize = pToolBox->GetOutputSizePixel(); - aUIDockingElement.m_aFloatingData.m_nLines = pToolBox->GetFloatingLines(); - aUIDockingElement.m_aFloatingData.m_bIsHorizontal = (( pToolBox->GetAlign() == WINDOWALIGN_TOP ) || - ( pToolBox->GetAlign() == WINDOWALIGN_BOTTOM )); - } - } - } - - WriteGuard aWriteLock( m_aLock ); - UIElement& rUIElement = LayoutManager::impl_findElement( aUIDockingElement.m_aName ); - if ( rUIElement.m_aName == aUIDockingElement.m_aName ) - rUIElement = aUIDockingElement; - aWriteLock.unlock(); - } - } - } - - return sal_True; -} - -void SAL_CALL LayoutManager::toggleFloatingMode( const ::com::sun::star::lang::EventObject& e ) -throw (::com::sun::star::uno::RuntimeException) -{ - sal_Bool bDockingInProgress( sal_False ); - UIElement aUIDockingElement; - - ReadGuard aReadLock( m_aLock ); - bDockingInProgress = m_bDockingInProgress; - if ( bDockingInProgress ) - aUIDockingElement = m_aDockUIElement; - aReadLock.unlock(); - - Window* pWindow( 0 ); - ToolBox* pToolBox( 0 ); - Reference< css::awt::XWindow2 > xWindow; - - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - xWindow = Reference< css::awt::XWindow2 >( e.Source, UNO_QUERY ); - pWindow = VCLUnoHelper::GetWindow( xWindow ); - - if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX ) - pToolBox = (ToolBox *)pWindow; - } - - if ( !bDockingInProgress ) - { - sal_Bool bWinFound( implts_findElement( e.Source, aUIDockingElement ) ); - if ( bWinFound && xWindow.is() ) - { - aUIDockingElement.m_bFloating = !aUIDockingElement.m_bFloating; - aUIDockingElement.m_bUserActive = sal_True; - - WriteGuard aWriteLock( m_aLock ); - m_bDoLayout = sal_True; - aWriteLock.unlock(); - - if ( aUIDockingElement.m_bFloating ) - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - if ( pToolBox ) - { - pToolBox->SetLineCount( aUIDockingElement.m_aFloatingData.m_nLines ); - if ( aUIDockingElement.m_aFloatingData.m_bIsHorizontal ) - pToolBox->SetAlign( WINDOWALIGN_TOP ); - else - pToolBox->SetAlign( WINDOWALIGN_LEFT ); - } - - sal_Bool bUndefPos = ( aUIDockingElement.m_aFloatingData.m_aPos.X() == SAL_MAX_INT32 || - aUIDockingElement.m_aFloatingData.m_aPos.Y() == SAL_MAX_INT32 ); - sal_Bool bSetSize = ( aUIDockingElement.m_aFloatingData.m_aSize.Width() != 0 && - aUIDockingElement.m_aFloatingData.m_aSize.Height() != 0 ); - - if ( bUndefPos ) - aUIDockingElement.m_aFloatingData.m_aPos = implts_findNextCascadeFloatingPos(); - - if ( !bSetSize ) - { - if ( pToolBox ) - aUIDockingElement.m_aFloatingData.m_aSize = pToolBox->CalcFloatingWindowSizePixel(); - else - aUIDockingElement.m_aFloatingData.m_aSize = pWindow->GetOutputSizePixel(); - } - - xWindow->setPosSize( aUIDockingElement.m_aFloatingData.m_aPos.X(), - aUIDockingElement.m_aFloatingData.m_aPos.Y(), - 0, 0, css::awt::PosSize::POS ); - xWindow->setOutputSize( AWTSize( aUIDockingElement.m_aFloatingData.m_aSize ) ); - } - else - { - if (( aUIDockingElement.m_aDockedData.m_aPos.X() == SAL_MAX_INT32 ) && - ( aUIDockingElement.m_aDockedData.m_aPos.Y() == SAL_MAX_INT32 )) - { - // Docking on its default position without a preset position - - // we have to find a good place for it. - ::Point aPixelPos; - ::Point aDockPos; - ::Size aSize; - - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - if ( pToolBox ) - aSize = pToolBox->CalcWindowSizePixel( 1, ImplConvertAlignment( aUIDockingElement.m_aDockedData.m_nDockedArea ) ); - else - aSize = pWindow->GetSizePixel(); - } - - implts_findNextDockingPos( (::com::sun::star::ui::DockingArea)aUIDockingElement.m_aDockedData.m_nDockedArea, - aSize, - aDockPos, - aPixelPos ); - aUIDockingElement.m_aDockedData.m_aPos = aDockPos; - } - - vos::OGuard aGuard( Application::GetSolarMutex() ); - if ( pToolBox ) - { - pToolBox->SetAlign( ImplConvertAlignment( aUIDockingElement.m_aDockedData.m_nDockedArea) ); - ::Size aSize = pToolBox->CalcWindowSizePixel( 1 ); - css::awt::Rectangle aRect = xWindow->getPosSize(); - xWindow->setPosSize( aRect.X, aRect.Y, 0, 0, css::awt::PosSize::POS ); - xWindow->setOutputSize( AWTSize( aSize ) ); - } - } - - aWriteLock.lock(); - m_bDoLayout = sal_False; - UIElement& rUIElement = LayoutManager::impl_findElement( aUIDockingElement.m_aName ); - if ( rUIElement.m_aName == aUIDockingElement.m_aName ) - rUIElement = aUIDockingElement; - aWriteLock.unlock(); - - implts_writeWindowStateData( aUIDockingElement.m_aName, aUIDockingElement ); - - implts_sortUIElements(); - doLayout(); - } - } - else - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - if ( pToolBox ) - { - if ( aUIDockingElement.m_bFloating ) - { - if ( aUIDockingElement.m_aFloatingData.m_bIsHorizontal ) - pToolBox->SetAlign( WINDOWALIGN_TOP ); - else - pToolBox->SetAlign( WINDOWALIGN_LEFT ); - } - else - { - pToolBox->SetAlign( ImplConvertAlignment( aUIDockingElement.m_aDockedData.m_nDockedArea) ); - } - } - } -} - -void SAL_CALL LayoutManager::closed( const ::com::sun::star::lang::EventObject& e ) -throw (::com::sun::star::uno::RuntimeException) -{ - rtl::OUString aName; - UIElement aUIElement; - UIElementVector::iterator pIter; - - WriteGuard aWriteLock( m_aLock ); - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - { - Reference< XUIElement > xUIElement( pIter->m_xUIElement ); - if ( xUIElement.is() ) - { - Reference< XInterface > xIfac( xUIElement->getRealInterface(), UNO_QUERY ); - if ( xIfac == e.Source ) - { - aName = pIter->m_aName; - - // user closes a toolbar => - // context sensitive toolbar: only destroy toolbar and store state. - // context sensitive toolbar: make it invisible, store state and destroy it. - if ( !pIter->m_bContextSensitive ) - pIter->m_bVisible = sal_False; - - aUIElement = *pIter; - break; - } - } - } - aWriteLock.unlock(); - - - // destroy element - if ( aName.getLength() > 0 ) - { - implts_writeWindowStateData( aName, aUIElement ); - destroyElement( aName ); - } -} - -void SAL_CALL LayoutManager::endPopupMode( const ::com::sun::star::awt::EndPopupModeEvent& ) -throw (::com::sun::star::uno::RuntimeException) -{ - -} - -//--------------------------------------------------------------------------------------------------------- // XLayoutManagerEventBroadcaster //--------------------------------------------------------------------------------------------------------- -void SAL_CALL LayoutManager::addLayoutManagerEventListener( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XLayoutManagerListener >& xListener ) -throw (::com::sun::star::uno::RuntimeException) +void SAL_CALL LayoutManager::addLayoutManagerEventListener( const uno::Reference< frame::XLayoutManagerListener >& xListener ) +throw (uno::RuntimeException) { - m_aListenerContainer.addInterface( ::getCppuType( (const css::uno::Reference< css::frame::XLayoutManagerListener >*)NULL ), xListener ); + m_aListenerContainer.addInterface( ::getCppuType( (const uno::Reference< frame::XLayoutManagerListener >*)NULL ), xListener ); } -void SAL_CALL LayoutManager::removeLayoutManagerEventListener( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XLayoutManagerListener >& xListener ) -throw (::com::sun::star::uno::RuntimeException) +void SAL_CALL LayoutManager::removeLayoutManagerEventListener( const uno::Reference< frame::XLayoutManagerListener >& xListener ) +throw (uno::RuntimeException) { - m_aListenerContainer.removeInterface( ::getCppuType( (const css::uno::Reference< css::frame::XLayoutManagerListener >*)NULL ), xListener ); + m_aListenerContainer.removeInterface( ::getCppuType( (const uno::Reference< frame::XLayoutManagerListener >*)NULL ), xListener ); } -void LayoutManager::implts_notifyListeners( short nEvent, ::com::sun::star::uno::Any aInfoParam ) +void LayoutManager::implts_notifyListeners( short nEvent, uno::Any aInfoParam ) { - css::lang::EventObject aSource (static_cast< ::cppu::OWeakObject*>(this)); - ::cppu::OInterfaceContainerHelper* pContainer = m_aListenerContainer.getContainer( ::getCppuType( ( const css::uno::Reference< css::frame::XLayoutManagerListener >*) NULL ) ); + lang::EventObject aSource( static_cast< ::cppu::OWeakObject*>(this) ); + ::cppu::OInterfaceContainerHelper* pContainer = m_aListenerContainer.getContainer( ::getCppuType( ( const uno::Reference< frame::XLayoutManagerListener >*) NULL ) ); if (pContainer!=NULL) { ::cppu::OInterfaceIteratorHelper pIterator(*pContainer); @@ -6917,9 +2711,9 @@ void LayoutManager::implts_notifyListeners( short nEvent, ::com::sun::star::uno: { try { - ((css::frame::XLayoutManagerListener*)pIterator.next())->layoutEvent( aSource, nEvent, aInfoParam ); + ((frame::XLayoutManagerListener*)pIterator.next())->layoutEvent( aSource, nEvent, aInfoParam ); } - catch( css::uno::RuntimeException& ) + catch( uno::RuntimeException& ) { pIterator.remove(); } @@ -6928,10 +2722,10 @@ void LayoutManager::implts_notifyListeners( short nEvent, ::com::sun::star::uno: } //--------------------------------------------------------------------------------------------------------- -// XWindowListener +// XWindowListener //--------------------------------------------------------------------------------------------------------- -void SAL_CALL LayoutManager::windowResized( const css::awt::WindowEvent& aEvent ) -throw( css::uno::RuntimeException ) +void SAL_CALL LayoutManager::windowResized( const awt::WindowEvent& aEvent ) +throw( uno::RuntimeException ) { /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); @@ -6940,9 +2734,9 @@ throw( css::uno::RuntimeException ) return; // Request to set docking area space again. - css::awt::Rectangle aDockingArea( m_aDockingArea ); + awt::Rectangle aDockingArea( m_aDockingArea ); Reference< XDockingAreaAcceptor > xDockingAreaAcceptor( m_xDockingAreaAcceptor ); - Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow ); + Reference< awt::XWindow > xContainerWindow( m_xContainerWindow ); Reference< XInterface > xIfac( xContainerWindow, UNO_QUERY ); if ( xIfac == aEvent.Source && m_bVisible ) @@ -6964,105 +2758,65 @@ throw( css::uno::RuntimeException ) { // the container window of my DockingAreaAcceptor is not the same as of my frame // I still have to resize my frames' window as nobody else will do it - Reference< css::awt::XWindow > xComponentWindow( m_xFrame->getComponentWindow() ); + Reference< awt::XWindow > xComponentWindow( m_xFrame->getComponentWindow() ); if( xComponentWindow.is() == sal_True ) { - css::uno::Reference< css::awt::XDevice > xDevice( m_xFrame->getContainerWindow(), css::uno::UNO_QUERY ); + uno::Reference< awt::XDevice > xDevice( m_xFrame->getContainerWindow(), uno::UNO_QUERY ); // Convert relativ size to output size. - css::awt::Rectangle aRectangle = m_xFrame->getContainerWindow()->getPosSize(); - css::awt::DeviceInfo aInfo = xDevice->getInfo(); - css::awt::Size aSize ( aRectangle.Width - aInfo.LeftInset - aInfo.RightInset , - aRectangle.Height - aInfo.TopInset - aInfo.BottomInset ); + awt::Rectangle aRectangle = m_xFrame->getContainerWindow()->getPosSize(); + awt::DeviceInfo aInfo = xDevice->getInfo(); + awt::Size aSize( aRectangle.Width - aInfo.LeftInset - aInfo.RightInset , + aRectangle.Height - aInfo.TopInset - aInfo.BottomInset ); // Resize our component window. - xComponentWindow->setPosSize( 0, 0, aSize.Width, aSize.Height, css::awt::PosSize::POSSIZE ); - } - } - else - { - // resize event for one of the UIElements - sal_Bool bLocked( m_bDockingInProgress ); - sal_Bool bDoLayout( m_bDoLayout ); - aWriteLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - - if ( !bLocked && !bDoLayout ) - { - // Do not do anything if we are in the middle of a docking process. This would interfere all other - // operations. We will store the new position and size in the docking handlers. - // Do not do anything if we are in the middle of our layouting process. We will adapt the position - // and size of the user interface elements. - UIElement aUIElement; - if ( implts_findElement( aEvent.Source, aUIElement )) - { - if ( aUIElement.m_bFloating ) - implts_writeNewStateData( aUIElement.m_aName, - Reference< css::awt::XWindow >( aEvent.Source, UNO_QUERY )); - else - doLayout(); - } + xComponentWindow->setPosSize( 0, 0, aSize.Width, aSize.Height, awt::PosSize::POSSIZE ); } } } -void SAL_CALL LayoutManager::windowMoved( const css::awt::WindowEvent& ) throw( css::uno::RuntimeException ) +void SAL_CALL LayoutManager::windowMoved( const awt::WindowEvent& ) throw( uno::RuntimeException ) { } -void SAL_CALL LayoutManager::windowShown( const css::lang::EventObject& aEvent ) throw( css::uno::RuntimeException ) +void SAL_CALL LayoutManager::windowShown( const lang::EventObject& aEvent ) throw( uno::RuntimeException ) { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ ReadGuard aReadLock( m_aLock ); - - // Request to set docking area space again. - Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow ); - bool bParentWindowVisible( m_bParentWindowVisible ); + Reference< awt::XWindow > xContainerWindow( m_xContainerWindow ); + bool bParentWindowVisible( m_bParentWindowVisible ); aReadLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ Reference< XInterface > xIfac( xContainerWindow, UNO_QUERY ); if ( xIfac == aEvent.Source ) { bool bSetVisible = false; - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); m_bParentWindowVisible = true; bSetVisible = ( m_bParentWindowVisible != bParentWindowVisible ); aWriteLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ if ( bSetVisible ) - { implts_updateUIElementsVisibleState( sal_True ); - //implts_doLayout( sal_False ); - } } } -void SAL_CALL LayoutManager::windowHidden( const css::lang::EventObject& aEvent ) throw( css::uno::RuntimeException ) +void SAL_CALL LayoutManager::windowHidden( const lang::EventObject& aEvent ) throw( uno::RuntimeException ) { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ ReadGuard aReadLock( m_aLock ); - - // Request to set docking area space again. - Reference< css::awt::XWindow > xContainerWindow( m_xContainerWindow ); - bool bParentWindowVisible( m_bParentWindowVisible ); + Reference< awt::XWindow > xContainerWindow( m_xContainerWindow ); + bool bParentWindowVisible( m_bParentWindowVisible ); aReadLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ Reference< XInterface > xIfac( xContainerWindow, UNO_QUERY ); if ( xIfac == aEvent.Source ) { bool bSetInvisible = false; - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); m_bParentWindowVisible = false; bSetInvisible = ( m_bParentWindowVisible != bParentWindowVisible ); aWriteLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ if ( bSetInvisible ) implts_updateUIElementsVisibleState( sal_False ); @@ -7071,17 +2825,14 @@ void SAL_CALL LayoutManager::windowHidden( const css::lang::EventObject& aEvent IMPL_LINK( LayoutManager, AsyncLayoutHdl, Timer *, EMPTYARG ) { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ ReadGuard aReadLock( m_aLock ); - - // Request to set docking area space again. m_aAsyncLayoutTimer.Stop(); if( !m_xContainerWindow.is() ) return 0; - css::awt::Rectangle aDockingArea( m_aDockingArea ); - ::Size aStatusBarSize( implts_getStatusBarSize() ); + awt::Rectangle aDockingArea( m_aDockingArea ); + ::Size aStatusBarSize( implts_getStatusBarSize() ); // Subtract status bar height aDockingArea.Height -= aStatusBarSize.Height(); @@ -7093,78 +2844,42 @@ IMPL_LINK( LayoutManager, AsyncLayoutHdl, Timer *, EMPTYARG ) return 0; } -#ifdef DBG_UTIL -void LayoutManager::implts_checkElementContainer() -{ -#ifdef DBG_UTIL - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - ReadGuard aReadLock( m_aLock ); - - BaseHash< sal_Int32 > aUIElementHash; - - UIElementVector::iterator pIter; - for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) - aUIElementHash[pIter->m_aName]++; - - - BaseHash< sal_Int32 >::const_iterator pCheckIter = aUIElementHash.begin(); - for ( ; pCheckIter != aUIElementHash.end(); pCheckIter++ ) - { - if ( pCheckIter->second > 1 ) - { - ::rtl::OString aName = ::rtl::OUStringToOString( pCheckIter->first, RTL_TEXTENCODING_ASCII_US ); - DBG_ASSERT( "More than one element (%s) with the same name found!", aName.getStr() ); - } - } // for ( ; pCheckIter != aUIElementHash.end(); pCheckIter++ ) -#endif -} -#endif - //--------------------------------------------------------------------------------------------------------- -// XFrameActionListener +// XFrameActionListener //--------------------------------------------------------------------------------------------------------- void SAL_CALL LayoutManager::frameAction( const FrameActionEvent& aEvent ) throw ( RuntimeException ) { - if (( aEvent.Action == FrameAction_COMPONENT_ATTACHED ) || - ( aEvent.Action == FrameAction_COMPONENT_REATTACHED )) + if (( aEvent.Action == FrameAction_COMPONENT_ATTACHED ) || ( aEvent.Action == FrameAction_COMPONENT_REATTACHED )) { RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::LayoutManager::frameAction (COMPONENT_ATTACHED|REATTACHED)" ); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); m_bComponentAttached = sal_True; m_bMustDoLayout = sal_True; aWriteLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ implts_reset( sal_True ); implts_doLayout( sal_True, sal_False ); implts_doLayout( sal_True, sal_True ); } - else if (( aEvent.Action == FrameAction_FRAME_UI_ACTIVATED ) || - ( aEvent.Action == FrameAction_FRAME_UI_DEACTIVATING )) + else if (( aEvent.Action == FrameAction_FRAME_UI_ACTIVATED ) || ( aEvent.Action == FrameAction_FRAME_UI_DEACTIVATING )) { RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::LayoutManager::frameAction (FRAME_UI_ACTIVATED|DEACTIVATING)" ); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ WriteGuard aWriteLock( m_aLock ); m_bActive = ( aEvent.Action == FrameAction_FRAME_UI_ACTIVATED ); aWriteLock.unlock(); - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ implts_toggleFloatingUIElementsVisibility( aEvent.Action == FrameAction_FRAME_UI_ACTIVATED ); -// doLayout(); } else if ( aEvent.Action == FrameAction_COMPONENT_DETACHING ) { RTL_LOGFILE_CONTEXT( aLog, "framework (cd100003) ::LayoutManager::frameAction (COMPONENT_DETACHING)" ); - // SAFE AREA ----------------------------------------------------------------------------------------------- WriteGuard aWriteLock( m_aLock ); m_bComponentAttached = sal_False; aWriteLock.unlock(); - // SAFE AREA ----------------------------------------------------------------------------------------------- implts_reset( sal_False ); } @@ -7172,7 +2887,7 @@ throw ( RuntimeException ) // ______________________________________________ -void SAL_CALL LayoutManager::disposing( const css::lang::EventObject& rEvent ) +void SAL_CALL LayoutManager::disposing( const lang::EventObject& rEvent ) throw( RuntimeException ) { sal_Bool bDisposeAndClear( sal_False ); @@ -7182,23 +2897,11 @@ throw( RuntimeException ) if ( rEvent.Source == Reference< XInterface >( m_xFrame, UNO_QUERY )) { - // Our frame gets disposed, release all our references that depends on a working - // frame reference. + // Our frame gets disposed, release all our references that depends on a working frame reference. Application::RemoveEventListener( LINK( this, LayoutManager, SettingsChanged ) ); - if ( m_pMiscOptions ) - { - m_pMiscOptions->RemoveListenerLink( LINK( this, LayoutManager, OptionsChanged ) ); - delete m_pMiscOptions; - m_pMiscOptions = 0; - } - - delete m_pAddonOptions; - m_pAddonOptions = 0; // destroy all elements, it's possible that dettaching is NOT called! implts_destroyElements(); - - m_aUIElements.clear(); impl_clearUpMenuBar(); m_xMenuBar.clear(); if ( m_xInplaceMenuBar.is() ) @@ -7209,7 +2912,10 @@ throw( RuntimeException ) m_xInplaceMenuBar.clear(); m_xContainerWindow.clear(); m_xContainerTopWindow.clear(); - implts_destroyDockingAreaWindows(); + + // forward disposing call to toolbar manager + if ( m_pToolbarManager != NULL ) + m_pToolbarManager->disposing(rEvent); if ( m_xModuleCfgMgr.is() ) { @@ -7219,9 +2925,7 @@ throw( RuntimeException ) xModuleCfgMgr->removeConfigurationListener( Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY )); } - catch ( Exception& ) - { - } + catch ( Exception& ) {} } if ( m_xDocCfgMgr.is() ) @@ -7232,9 +2936,7 @@ throw( RuntimeException ) xDocCfgMgr->removeConfigurationListener( Reference< XUIConfigurationListener >( static_cast< OWeakObject* >( this ), UNO_QUERY )); } - catch ( Exception& ) - { - } + catch ( Exception& ) {} } m_xDocCfgMgr.clear(); @@ -7242,14 +2944,20 @@ throw( RuntimeException ) m_xFrame.clear(); delete m_pGlobalSettings; m_pGlobalSettings = 0; - m_xDockingAreaAcceptor = Reference< ::com::sun::star::ui::XDockingAreaAcceptor >(); + m_xDockingAreaAcceptor = Reference< ui::XDockingAreaAcceptor >(); bDisposeAndClear = sal_True; } else if ( rEvent.Source == Reference< XInterface >( m_xContainerWindow, UNO_QUERY )) { // Our container window gets disposed. Remove all user interface elements. - m_aUIElements.clear(); + uno::Reference< ui::XUIConfigurationListener > xToolbarManager( m_xToolbarManager ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + if ( pToolbarManager ) + { + uno::Reference< awt::XWindowPeer > aEmptyWindowPeer; + pToolbarManager->setParentWindow( aEmptyWindowPeer ); + } impl_clearUpMenuBar(); m_xMenuBar.clear(); if ( m_xInplaceMenuBar.is() ) @@ -7262,13 +2970,9 @@ throw( RuntimeException ) m_xContainerTopWindow.clear(); } else if ( rEvent.Source == Reference< XInterface >( m_xDocCfgMgr, UNO_QUERY )) - { m_xDocCfgMgr.clear(); - } else if ( rEvent.Source == Reference< XInterface >( m_xModuleCfgMgr , UNO_QUERY )) - { m_xModuleCfgMgr.clear(); - } aWriteLock.unlock(); /* SAFE AREA ----------------------------------------------------------------------------------------------- */ @@ -7277,208 +2981,207 @@ throw( RuntimeException ) if ( bDisposeAndClear ) { // Send message to all listener and forget her references. - css::uno::Reference< css::frame::XLayoutManager > xThis( static_cast< ::cppu::OWeakObject* >(this), css::uno::UNO_QUERY ); - css::lang::EventObject aEvent( xThis ); + uno::Reference< frame::XLayoutManager > xThis( static_cast< ::cppu::OWeakObject* >(this), uno::UNO_QUERY ); + lang::EventObject aEvent( xThis ); m_aListenerContainer.disposeAndClear( aEvent ); } } -void SAL_CALL LayoutManager::elementInserted( const ::com::sun::star::ui::ConfigurationEvent& Event ) throw (::com::sun::star::uno::RuntimeException) +void SAL_CALL LayoutManager::elementInserted( const ui::ConfigurationEvent& Event ) throw (uno::RuntimeException) { ReadGuard aReadLock( m_aLock ); + Reference< XFrame > xFrame( m_xFrame ); + Reference< ui::XUIConfigurationListener > xUICfgListener( m_xToolbarManager ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + aReadLock.unlock(); - ::rtl::OUString aElementType; - ::rtl::OUString aElementName; - Reference< XUIElement > xElement; - Reference< XFrame > xFrame( m_xFrame ); - - if ( m_xFrame.is() ) + if ( xFrame.is() ) { - implts_findElement( Event.ResourceURL, aElementType, aElementName, xElement ); - - Reference< XUIElementSettings > xElementSettings( xElement, UNO_QUERY ); - if ( xElementSettings.is() ) + ::rtl::OUString aElementType; + ::rtl::OUString aElementName; + bool bRefreshLayout(false); + + parseResourceURL( Event.ResourceURL, aElementType, aElementName ); + if ( aElementType.equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR )) { - ::rtl::OUString aConfigSourcePropName( RTL_CONSTASCII_USTRINGPARAM( "ConfigurationSource" )); - Reference< XPropertySet > xPropSet( xElementSettings, UNO_QUERY ); - if ( xPropSet.is() ) + if ( xUICfgListener.is() ) { - if ( Event.Source == Reference< XInterface >( m_xDocCfgMgr, UNO_QUERY )) - xPropSet->setPropertyValue( aConfigSourcePropName, makeAny( m_xDocCfgMgr )); + xUICfgListener->elementInserted( Event ); + bRefreshLayout = pToolbarManager->isLayoutDirty(); } - xElementSettings->updateSettings(); } - else + else if ( aElementType.equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_MENUBAR )) { - if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" ) && - ( aElementName.indexOf( m_aCustomTbxPrefix ) != -1 )) + Reference< XUIElement > xUIElement = implts_findElement( Event.ResourceURL ); + Reference< XUIElementSettings > xElementSettings( xUIElement, UNO_QUERY ); + if ( xElementSettings.is() ) { - // custom toolbar must be directly created, shown and layouted! - createElement( Event.ResourceURL ); - Reference< XUIElement > xUIElement = getElement( Event.ResourceURL ); - if ( xUIElement.is() ) + ::rtl::OUString aConfigSourcePropName( RTL_CONSTASCII_USTRINGPARAM( "ConfigurationSource" )); + uno::Reference< XPropertySet > xPropSet( xElementSettings, uno::UNO_QUERY ); + if ( xPropSet.is() ) { - Reference< XUIConfigurationManager > xCfgMgr; - Reference< XPropertySet > xPropSet; - ::rtl::OUString aUIName; - - try - { - xCfgMgr = Reference< XUIConfigurationManager >( Event.Source, UNO_QUERY ); - xPropSet = Reference< XPropertySet >( xCfgMgr->getSettings( Event.ResourceURL, sal_False ), UNO_QUERY ); - - if ( xPropSet.is() ) - xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UIName" ))) >>= aUIName; - } - catch ( com::sun::star::container::NoSuchElementException& ) - { - } - catch ( com::sun::star::beans::UnknownPropertyException& ) - { - } - catch ( com::sun::star::lang::WrappedTargetException& ) - { - } - - { - vos::OGuard aGuard( Application::GetSolarMutex() ); - Reference< css::awt::XWindow > xWindow( xUIElement->getRealInterface(), UNO_QUERY ); - Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); - if ( pWindow ) - pWindow->SetText( aUIName ); - } - - showElement( Event.ResourceURL ); + if ( Event.Source == uno::Reference< uno::XInterface >( m_xDocCfgMgr, uno::UNO_QUERY )) + xPropSet->setPropertyValue( aConfigSourcePropName, makeAny( m_xDocCfgMgr )); } + xElementSettings->updateSettings(); } } - } + + if ( bRefreshLayout ) + doLayout(); + } } -void SAL_CALL LayoutManager::elementRemoved( const ::com::sun::star::ui::ConfigurationEvent& Event ) throw (::com::sun::star::uno::RuntimeException) +void SAL_CALL LayoutManager::elementRemoved( const ui::ConfigurationEvent& Event ) throw (uno::RuntimeException) { - /* SAFE AREA ----------------------------------------------------------------------------------------------- */ - WriteGuard aWriteLock( m_aLock ); - - ::rtl::OUString aElementType; - ::rtl::OUString aElementName; - Reference< XUIElement > xUIElement; - Reference< XFrame > xFrame( m_xFrame ); + ReadGuard aReadLock( m_aLock ); + Reference< frame::XFrame > xFrame( m_xFrame ); + Reference< ui::XUIConfigurationListener > xToolbarManager( m_xToolbarManager ); + Reference< awt::XWindow > xContainerWindow( m_xContainerWindow ); + Reference< ui::XUIElement > xMenuBar( m_xMenuBar ); + Reference< ui::XUIConfigurationManager > xModuleCfgMgr( m_xModuleCfgMgr ); + Reference< ui::XUIConfigurationManager > xDocCfgMgr( m_xDocCfgMgr ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + aReadLock.unlock(); - if ( m_xFrame.is() ) + if ( xFrame.is() ) { - implts_findElement( Event.ResourceURL, aElementType, aElementName, xUIElement ); - - Reference< XUIElementSettings > xElementSettings( xUIElement, UNO_QUERY ); - if ( xElementSettings.is() ) + ::rtl::OUString aElementType; + ::rtl::OUString aElementName; + bool bRefreshLayout(false); + + parseResourceURL( Event.ResourceURL, aElementType, aElementName ); + if ( aElementType.equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR )) + { + if ( xToolbarManager.is() ) + { + xToolbarManager->elementRemoved( Event ); + bRefreshLayout = pToolbarManager->isLayoutDirty(); + } + } + else { - bool bNoSettings( false ); - ::rtl::OUString aConfigSourcePropName( RTL_CONSTASCII_USTRINGPARAM( "ConfigurationSource" )); - Reference< XInterface > xElementCfgMgr; - Reference< XPropertySet > xPropSet( xElementSettings, UNO_QUERY ); + Reference< XUIElement > xUIElement = implts_findElement( Event.ResourceURL ); + Reference< XUIElementSettings > xElementSettings( xUIElement, UNO_QUERY ); + if ( xElementSettings.is() ) + { + bool bNoSettings( false ); + ::rtl::OUString aConfigSourcePropName( RTL_CONSTASCII_USTRINGPARAM( "ConfigurationSource" )); + Reference< XInterface > xElementCfgMgr; + Reference< XPropertySet > xPropSet( xElementSettings, UNO_QUERY ); - if ( xPropSet.is() ) - xPropSet->getPropertyValue( aConfigSourcePropName ) >>= xElementCfgMgr; + if ( xPropSet.is() ) + xPropSet->getPropertyValue( aConfigSourcePropName ) >>= xElementCfgMgr; - if ( !xElementCfgMgr.is() ) - return; + if ( !xElementCfgMgr.is() ) + return; - // Check if the same UI configuration manager has changed => check further - if ( Event.Source == xElementCfgMgr ) - { - // Same UI configuration manager where our element has its settings - if ( Event.Source == Reference< XInterface >( m_xDocCfgMgr, UNO_QUERY )) + // Check if the same UI configuration manager has changed => check further + if ( Event.Source == xElementCfgMgr ) { - // document settings removed - if ( m_xModuleCfgMgr->hasSettings( Event.ResourceURL )) + // Same UI configuration manager where our element has its settings + if ( Event.Source == Reference< XInterface >( xDocCfgMgr, UNO_QUERY )) { - xPropSet->setPropertyValue( aConfigSourcePropName, makeAny( m_xModuleCfgMgr )); - xElementSettings->updateSettings(); - return; + // document settings removed + if ( xModuleCfgMgr->hasSettings( Event.ResourceURL )) + { + xPropSet->setPropertyValue( aConfigSourcePropName, makeAny( m_xModuleCfgMgr )); + xElementSettings->updateSettings(); + return; + } } - } - - bNoSettings = true; - } - // No settings anymore, element must be destroyed - if ( m_xContainerWindow.is() && bNoSettings ) - { - if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" ) && - aElementName.equalsIgnoreAsciiCaseAscii( "menubar" )) - { - Window* pWindow = VCLUnoHelper::GetWindow( m_xContainerWindow ); - while ( pWindow && !pWindow->IsSystemWindow() ) - pWindow = pWindow->GetParent(); - - if ( pWindow && !m_bInplaceMenuSet ) - ((SystemWindow *)pWindow)->SetMenuBar( 0 ); - - Reference< XComponent > xComp( m_xMenuBar, UNO_QUERY ); - if ( xComp.is() ) - xComp->dispose(); - m_xMenuBar.clear(); + bNoSettings = true; } - else if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" )) + + // No settings anymore, element must be destroyed + if ( xContainerWindow.is() && bNoSettings ) { - destroyElement( Event.ResourceURL ); + if ( aElementType.equalsIgnoreAsciiCaseAscii( "menubar" ) && aElementName.equalsIgnoreAsciiCaseAscii( "menubar" )) + { + SystemWindow* pSysWindow = getTopSystemWindow( xContainerWindow ); + if ( pSysWindow && !m_bInplaceMenuSet ) + pSysWindow->SetMenuBar( 0 ); + + Reference< XComponent > xComp( xMenuBar, UNO_QUERY ); + if ( xComp.is() ) + xComp->dispose(); + + WriteGuard aWriteLock( m_aLock ); + m_xMenuBar.clear(); + } } } } + + if ( bRefreshLayout ) + doLayout(); } } -void SAL_CALL LayoutManager::elementReplaced( const ::com::sun::star::ui::ConfigurationEvent& Event ) throw (::com::sun::star::uno::RuntimeException) +void SAL_CALL LayoutManager::elementReplaced( const ui::ConfigurationEvent& Event ) throw (uno::RuntimeException) { ReadGuard aReadLock( m_aLock ); + Reference< XFrame > xFrame( m_xFrame ); + Reference< ui::XUIConfigurationListener > xToolbarManager( m_xToolbarManager ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + aReadLock.unlock(); - ::rtl::OUString aElementType; - ::rtl::OUString aElementName; - Reference< XUIElement > xUIElement; - Reference< XFrame > xFrame( m_xFrame ); - - if ( m_xFrame.is() ) + if ( xFrame.is() ) { - implts_findElement( Event.ResourceURL, aElementType, aElementName, xUIElement ); + ::rtl::OUString aElementType; + ::rtl::OUString aElementName; + bool bRefreshLayout(false); - Reference< XUIElementSettings > xElementSettings( xUIElement, UNO_QUERY ); - if ( xElementSettings.is() ) + parseResourceURL( Event.ResourceURL, aElementType, aElementName ); + if ( aElementType.equalsIgnoreAsciiCaseAscii( UIRESOURCETYPE_TOOLBAR )) + { + if ( xToolbarManager.is() ) + { + xToolbarManager->elementReplaced( Event ); + bRefreshLayout = pToolbarManager->isLayoutDirty(); + } + } + else { - ::rtl::OUString aConfigSourcePropName( RTL_CONSTASCII_USTRINGPARAM( "ConfigurationSource" )); - Reference< XInterface > xElementCfgMgr; - Reference< XPropertySet > xPropSet( xElementSettings, UNO_QUERY ); + Reference< XUIElement > xUIElement = implts_findElement( Event.ResourceURL ); + Reference< XUIElementSettings > xElementSettings( xUIElement, UNO_QUERY ); + if ( xElementSettings.is() ) + { + ::rtl::OUString aConfigSourcePropName( RTL_CONSTASCII_USTRINGPARAM( "ConfigurationSource" )); + Reference< XInterface > xElementCfgMgr; + Reference< XPropertySet > xPropSet( xElementSettings, UNO_QUERY ); - if ( xPropSet.is() ) - xPropSet->getPropertyValue( aConfigSourcePropName ) >>= xElementCfgMgr; + if ( xPropSet.is() ) + xPropSet->getPropertyValue( aConfigSourcePropName ) >>= xElementCfgMgr; - if ( !xElementCfgMgr.is() ) - return; + if ( !xElementCfgMgr.is() ) + return; - // Check if the same UI configuration manager has changed => update settings - if ( Event.Source == xElementCfgMgr ) - { - xElementSettings->updateSettings(); - if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" )) - doLayout(); + // Check if the same UI configuration manager has changed => update settings + if ( Event.Source == xElementCfgMgr ) + xElementSettings->updateSettings(); } } + + if ( bRefreshLayout ) + doLayout(); } } //--------------------------------------------------------------------------------------------------------- -// OPropertySetHelper +// OPropertySetHelper //--------------------------------------------------------------------------------------------------------- -// XPropertySet helper -sal_Bool SAL_CALL LayoutManager::convertFastPropertyValue( Any& aConvertedValue , - Any& aOldValue , - sal_Int32 nHandle , - const Any& aValue ) throw( com::sun::star::lang::IllegalArgumentException ) +sal_Bool SAL_CALL LayoutManager::convertFastPropertyValue( Any& aConvertedValue, + Any& aOldValue, + sal_Int32 nHandle, + const Any& aValue ) throw( lang::IllegalArgumentException ) { return LayoutManager_PBase::convertFastPropertyValue( aConvertedValue, aOldValue, nHandle, aValue ); } -void SAL_CALL LayoutManager::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle , - const com::sun::star::uno::Any& aValue ) throw( com::sun::star::uno::Exception ) +void SAL_CALL LayoutManager::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, + const uno::Any& aValue ) throw( uno::Exception ) { if ( nHandle != LAYOUTMANAGER_PROPHANDLE_REFRESHVISIBILITY ) LayoutManager_PBase::setFastPropertyValue_NoBroadcast( nHandle, aValue ); @@ -7491,40 +3194,42 @@ void SAL_CALL LayoutManager::setFastPropertyValue_NoBroadcast( sal_Int32 case LAYOUTMANAGER_PROPHANDLE_REFRESHVISIBILITY: { - sal_Bool bValue = sal_Bool(); + sal_Bool bValue(sal_False); if (( aValue >>= bValue ) && bValue ) - implts_refreshContextToolbarsVisibility(); + { + ReadGuard aReadLock( m_aLock ); + Reference< ui::XUIConfigurationListener > xToolbarManager( m_xToolbarManager ); + ToolbarLayoutManager* pToolbarManager = m_pToolbarManager; + aReadLock.unlock(); + + if ( pToolbarManager ) + pToolbarManager->refreshToolbarsVisibility(); + } break; } case LAYOUTMANAGER_PROPHANDLE_HIDECURRENTUI: implts_setCurrentUIVisibility( !m_bHideCurrentUI ); break; + default: break; } } -void SAL_CALL LayoutManager::getFastPropertyValue( com::sun::star::uno::Any& aValue , - sal_Int32 nHandle ) const +void SAL_CALL LayoutManager::getFastPropertyValue( uno::Any& aValue, sal_Int32 nHandle ) const { LayoutManager_PBase::getFastPropertyValue( aValue, nHandle ); } ::cppu::IPropertyArrayHelper& SAL_CALL LayoutManager::getInfoHelper() { - // Optimize this method ! - // We initialize a static variable only one time. And we don't must use a mutex at every call! - // For the first call; pInfoHelper is NULL - for the second call pInfoHelper is different from NULL! static ::cppu::OPropertyArrayHelper* pInfoHelper = NULL; if( pInfoHelper == NULL ) { - // Ready for multithreading osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ; - // Control this pointer again, another instance can be faster then these! if( pInfoHelper == NULL ) { - // Define static member to give structure of properties to baseclass "OPropertySetHelper". uno::Sequence< beans::Property > aProperties; describeProperties( aProperties ); static ::cppu::OPropertyArrayHelper aInfoHelper( aProperties, sal_True ); @@ -7535,23 +3240,17 @@ void SAL_CALL LayoutManager::getFastPropertyValue( com::sun::star::uno::Any& aVa return(*pInfoHelper); } -com::sun::star::uno::Reference< com::sun::star::beans::XPropertySetInfo > SAL_CALL LayoutManager::getPropertySetInfo() throw (::com::sun::star::uno::RuntimeException) +uno::Reference< beans::XPropertySetInfo > SAL_CALL LayoutManager::getPropertySetInfo() throw (uno::RuntimeException) { - // Optimize this method ! - // We initialize a static variable only one time. And we don't must use a mutex at every call! - // For the first call; pInfo is NULL - for the second call pInfo is different from NULL! - static com::sun::star::uno::Reference< com::sun::star::beans::XPropertySetInfo >* pInfo = NULL; + static uno::Reference< beans::XPropertySetInfo >* pInfo = NULL; if( pInfo == NULL ) { - // Ready for multithreading osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ; - // Control this pointer again, another instance can be faster then these! + if( pInfo == NULL ) { - // Create structure of propertysetinfo for baseclass "OPropertySetHelper". - // (Use method "getInfoHelper()".) - static com::sun::star::uno::Reference< com::sun::star::beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); + static uno::Reference< beans::XPropertySetInfo > xInfo( createPropertySetInfo( getInfoHelper() ) ); pInfo = &xInfo; } } @@ -7560,4 +3259,3 @@ com::sun::star::uno::Reference< com::sun::star::beans::XPropertySetInfo > SAL_CA } } // namespace framework - diff --git a/framework/source/layoutmanager/makefile.mk b/framework/source/layoutmanager/makefile.mk index 70215a3657..7ce19a71f2 100644 --- a/framework/source/layoutmanager/makefile.mk +++ b/framework/source/layoutmanager/makefile.mk @@ -2,10 +2,14 @@ # # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # -# Copyright 2000, 2010 Oracle and/or its affiliates. +# Copyright 2008 by Sun Microsystems, Inc. # # OpenOffice.org - a multi-platform office productivity suite # +# $RCSfile: makefile.mk,v $ +# +# $Revision: 1.5 $ +# # This file is part of OpenOffice.org. # # OpenOffice.org is free software: you can redistribute it and/or modify @@ -35,12 +39,15 @@ ENABLE_EXCEPTIONS= TRUE .INCLUDE : settings.mk -VISIBILITY_HIDDEN = TRUE - # --- Generate ----------------------------------------------------- SLOFILES= \ - $(SLO)$/layoutmanager.obj + $(SLO)$/panelmanager.obj \ + $(SLO)$/layoutmanager.obj \ + $(SLO)$/panel.obj \ + $(SLO)$/helpers.obj \ + $(SLO)$/uielement.obj \ + $(SLO)$/toolbarlayoutmanager.obj # --- Targets ------------------------------------------------------ diff --git a/framework/source/layoutmanager/panel.cxx b/framework/source/layoutmanager/panel.cxx new file mode 100755 index 0000000000..1e208e1f8c --- /dev/null +++ b/framework/source/layoutmanager/panel.cxx @@ -0,0 +1,88 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2008 by Sun Microsystems, Inc. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: layoutmanager.hxx,v $ + * $Revision: 1.34 $ + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_framework.hxx" + +//_________________________________________________________________________________________________________________ +// my own includes +//_________________________________________________________________________________________________________________ + +#include "panel.hxx" +#include "helpers.hxx" + +//_________________________________________________________________________________________________________________ +// other includes +//_________________________________________________________________________________________________________________ + +#include <vos/mutex.hxx> +#include <vcl/svapp.hxx> +#include <toolkit/unohlp.hxx> + +//_________________________________________________________________________________________________________________ +// namespace +//_________________________________________________________________________________________________________________ + +using namespace ::com::sun::star; + +namespace framework +{ + +Panel::Panel( + const uno::Reference< lang::XMultiServiceFactory >& rSMGR, + const uno::Reference< awt::XWindow >& rParent, + PanelPosition nPanel ) : + m_xSMGR(rSMGR), m_nPanelPosition(nPanel) +{ + uno::Reference< awt::XWindowPeer > xWindowPeer( rParent, uno::UNO_QUERY ); + m_xPanelWindow = uno::Reference< awt::XWindow >( createToolkitWindow( rSMGR, xWindowPeer, "splitwindow" ), uno::UNO_QUERY ); + + vos::OGuard aGuard( Application::GetSolarMutex() ); + SplitWindow* pSplitWindow = dynamic_cast< SplitWindow* >( VCLUnoHelper::GetWindow( m_xPanelWindow )); + + if ( pSplitWindow ) + { + // Set alignment + if (nPanel == PANEL_TOP) + pSplitWindow->SetAlign( WINDOWALIGN_TOP ); + else if (nPanel == PANEL_BOTTOM) + pSplitWindow->SetAlign( WINDOWALIGN_BOTTOM ); + else if (nPanel == PANEL_LEFT) + pSplitWindow->SetAlign( WINDOWALIGN_LEFT ); + else + pSplitWindow->SetAlign( WINDOWALIGN_RIGHT ); + } +} + +Panel::~Panel() +{ +} + +} // namespace framework diff --git a/framework/source/layoutmanager/panel.hxx b/framework/source/layoutmanager/panel.hxx new file mode 100755 index 0000000000..ccd9f72abe --- /dev/null +++ b/framework/source/layoutmanager/panel.hxx @@ -0,0 +1,88 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2008 by Sun Microsystems, Inc. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: layoutmanager.hxx,v $ + * $Revision: 1.34 $ + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef __FRAMEWORK_LAYOUTMANAGER_PANEL_HXX_ +#define __FRAMEWORK_LAYOUTMANAGER_PANEL_HXX_ + +//_________________________________________________________________________________________________________________ +// my own includes +//_________________________________________________________________________________________________________________ + +#include <macros/generic.hxx> +#include <stdtypes.h> +#include <properties.h> + +//_________________________________________________________________________________________________________________ +// interface includes +//_________________________________________________________________________________________________________________ + +#include <com/sun/star/awt/XWindow.hpp> +#include <com/sun/star/lang/XMultiServiceFactory.hpp> + +//_________________________________________________________________________________________________________________ +// other includes +//_________________________________________________________________________________________________________________ + +#include <vcl/window.hxx> +#include <vcl/splitwin.hxx> + +//_________________________________________________________________________________________________________________ +// namespace +//_________________________________________________________________________________________________________________ + +namespace framework +{ + +enum PanelPosition +{ + PANEL_TOP, + PANEL_LEFT, + PANEL_RIGHT, + PANEL_BOTTOM, + PANEL_COUNT +}; + +class Panel +{ + public: + Panel( const css::uno::Reference< css::lang::XMultiServiceFactory >& rSMGR, + const css::uno::Reference< css::awt::XWindow >& rParent, + PanelPosition nPanel ); + virtual ~Panel(); + + private: + css::uno::Reference< css::lang::XMultiServiceFactory > m_xSMGR; + css::uno::Reference< css::awt::XWindow > m_xPanelWindow; + PanelPosition m_nPanelPosition; +}; + +} + +#endif // __FRAMEWORK_LAYOUTMANAGER_PANEL_HXX_ diff --git a/framework/source/layoutmanager/panelmanager.cxx b/framework/source/layoutmanager/panelmanager.cxx new file mode 100755 index 0000000000..81428a62de --- /dev/null +++ b/framework/source/layoutmanager/panelmanager.cxx @@ -0,0 +1,183 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2008 by Sun Microsystems, Inc. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: layoutmanager.hxx,v $ + * $Revision: 1.34 $ + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_framework.hxx" + +//_________________________________________________________________________________________________________________ +// my own includes +//_________________________________________________________________________________________________________________ + +#include "panelmanager.hxx" +#include "services.h" +#include "services/modelwinservice.hxx" + +//_________________________________________________________________________________________________________________ +// interface includes +//_________________________________________________________________________________________________________________ + + +//_________________________________________________________________________________________________________________ +// other includes +//_________________________________________________________________________________________________________________ + +#include <vcl/svapp.hxx> +#include <toolkit/unohlp.hxx> + +//_________________________________________________________________________________________________________________ +// namespace +//_________________________________________________________________________________________________________________ + +using namespace ::com::sun::star; + +namespace framework +{ + +//_________________________________________________________________________________________________________________ +// non exported definitions +//_________________________________________________________________________________________________________________ + +//_________________________________________________________________________________________________________________ +// declarations +//_________________________________________________________________________________________________________________ + + +PanelManager::PanelManager( + const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& rSMGR, + const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame ) : + m_xSMGR( rSMGR ), + m_xFrame( rFrame ) +{ + m_aPanels[PANEL_TOP] = 0; + m_aPanels[PANEL_BOTTOM] = 0; + m_aPanels[PANEL_LEFT] = 0; + m_aPanels[PANEL_RIGHT] = 0; +} + +PanelManager::~PanelManager() +{ +} + +//--------------------------------------------------------------------------------------------------------- +// Creation and layouting +//--------------------------------------------------------------------------------------------------------- +bool PanelManager::createPanels() +{ + if ( m_xFrame.is() ) + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + uno::Reference< awt::XWindow > xWindow( m_xFrame->getContainerWindow(), uno::UNO_QUERY ); + if ( xWindow.is() ) + { + // destroy old panel windows + delete m_aPanels[PANEL_TOP ]; + delete m_aPanels[PANEL_BOTTOM]; + delete m_aPanels[PANEL_LEFT ]; + delete m_aPanels[PANEL_RIGHT ]; + + m_aPanels[PANEL_TOP ] = new Panel( m_xSMGR, xWindow, PANEL_TOP ); + m_aPanels[PANEL_BOTTOM] = new Panel( m_xSMGR, xWindow, PANEL_BOTTOM ); + m_aPanels[PANEL_LEFT ] = new Panel( m_xSMGR, xWindow, PANEL_LEFT ); + m_aPanels[PANEL_RIGHT ] = new Panel( m_xSMGR, xWindow, PANEL_RIGHT ); + return true; + } + } + + return false; +} + +awt::Rectangle PanelManager::getPreferredSize() const +{ + return awt::Rectangle(); +} + +void PanelManager::layoutPanels( const awt::Rectangle /*newSize*/ ) +{ +} + +//--------------------------------------------------------------------------------------------------------- +// Panel functions +//--------------------------------------------------------------------------------------------------------- +UIElement* PanelManager::findDockingWindow( const ::rtl::OUString& /*rResourceName*/ ) +{ + return NULL; +} + +bool PanelManager::addDockingWindow( const ::rtl::OUString& /*rResourceName*/, const ::com::sun::star::uno::Reference< ::com::sun::star::ui::XUIElement >& /*xUIElement*/ ) +{ + return false; +} + +bool PanelManager::destroyDockingWindow( const ::rtl::OUString& /*rResourceName*/ ) +{ + return false; +} + +//--------------------------------------------------------------------------------------------------------- +// XDockableWindowListener +//--------------------------------------------------------------------------------------------------------- +void SAL_CALL PanelManager::startDocking( const awt::DockingEvent& ) +throw (uno::RuntimeException) +{ +} + +awt::DockingData SAL_CALL PanelManager::docking( const awt::DockingEvent& ) +throw (uno::RuntimeException) +{ + return awt::DockingData(); +} + +void SAL_CALL PanelManager::endDocking( const awt::EndDockingEvent& ) +throw (uno::RuntimeException) +{ +} + +sal_Bool SAL_CALL PanelManager::prepareToggleFloatingMode( const lang::EventObject& ) +throw (uno::RuntimeException) +{ + return false; +} + +void SAL_CALL PanelManager::toggleFloatingMode( const lang::EventObject& ) +throw (uno::RuntimeException) +{ +} + +void SAL_CALL PanelManager::closed( const lang::EventObject& ) +throw (uno::RuntimeException) +{ +} + +void SAL_CALL PanelManager::endPopupMode( const awt::EndPopupModeEvent& ) +throw (uno::RuntimeException) +{ +} + +} // namespace framework diff --git a/framework/source/layoutmanager/panelmanager.hxx b/framework/source/layoutmanager/panelmanager.hxx new file mode 100755 index 0000000000..b89b474a7d --- /dev/null +++ b/framework/source/layoutmanager/panelmanager.hxx @@ -0,0 +1,109 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2008 by Sun Microsystems, Inc. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: layoutmanager.hxx,v $ + * $Revision: 1.34 $ + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef __FRAMEWORK_LAYOUTMANAGER_PANELMANAGER_HXX_ +#define __FRAMEWORK_LAYOUTMANAGER_PANELMANAGER_HXX_ + +//_________________________________________________________________________________________________________________ +// my own includes +//_________________________________________________________________________________________________________________ + +#include <threadhelp/threadhelpbase.hxx> +#include <macros/generic.hxx> +#include <macros/debug.hxx> +#include <macros/xinterface.hxx> +#include <macros/xtypeprovider.hxx> +#include <macros/xserviceinfo.hxx> +#include <general.h> +#include <stdtypes.h> +#include "panel.hxx" +#include <uielement/uielement.hxx> + +//_________________________________________________________________________________________________________________ +// interface includes +//_________________________________________________________________________________________________________________ + +#include <com/sun/star/lang/XTypeProvider.hpp> +#include <com/sun/star/awt/XWindow.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/container/XNameAccess.hpp> +#include <com/sun/star/awt/XDockableWindowListener.hpp> +#include <com/sun/star/frame/XFrame.hpp> + +//_________________________________________________________________________________________________________________ +// other includes +//_________________________________________________________________________________________________________________ + +#include <cppuhelper/weak.hxx> +#include <vcl/window.hxx> + +//_________________________________________________________________________________________________________________ +// namespace +//_________________________________________________________________________________________________________________ + +namespace framework +{ + +class PanelManager : private ThreadHelpBase // Struct for right initalization of mutex member! Must be first of baseclasses. +{ + public: + PanelManager( + const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& rSMGR, + const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame ); + virtual ~PanelManager(); + + bool createPanels(); + ::com::sun::star::awt::Rectangle getPreferredSize() const; + void layoutPanels( const ::com::sun::star::awt::Rectangle newSize ); + + UIElement* findDockingWindow( const ::rtl::OUString& rResourceName ); + bool addDockingWindow( const ::rtl::OUString& rResourceName, const ::com::sun::star::uno::Reference< ::com::sun::star::ui::XUIElement >& xUIElement ); + bool destroyDockingWindow( const ::rtl::OUString& rResourceName ); + + //--------------------------------------------------------------------------------------------------------- + // XDockableWindowListener + //--------------------------------------------------------------------------------------------------------- + virtual void SAL_CALL startDocking( const ::com::sun::star::awt::DockingEvent& e ) throw (::com::sun::star::uno::RuntimeException); + virtual ::com::sun::star::awt::DockingData SAL_CALL docking( const ::com::sun::star::awt::DockingEvent& e ) throw (::com::sun::star::uno::RuntimeException); + virtual void SAL_CALL endDocking( const ::com::sun::star::awt::EndDockingEvent& e ) throw (::com::sun::star::uno::RuntimeException); + virtual sal_Bool SAL_CALL prepareToggleFloatingMode( const ::com::sun::star::lang::EventObject& e ) throw (::com::sun::star::uno::RuntimeException); + virtual void SAL_CALL toggleFloatingMode( const ::com::sun::star::lang::EventObject& e ) throw (::com::sun::star::uno::RuntimeException); + virtual void SAL_CALL closed( const ::com::sun::star::lang::EventObject& e ) throw (::com::sun::star::uno::RuntimeException); + virtual void SAL_CALL endPopupMode( const ::com::sun::star::awt::EndPopupModeEvent& e ) throw (::com::sun::star::uno::RuntimeException); + + private: + Panel* m_aPanels[PANEL_COUNT]; + css::uno::Reference< css::lang::XMultiServiceFactory > m_xSMGR; + css::uno::Reference< css::frame::XFrame > m_xFrame; +}; + +} // namespace framework + +#endif // __FRAMEWORK_LAYOUTMANAGER_PANELMANAGER_HXX_ diff --git a/framework/source/layoutmanager/toolbarlayoutmanager.cxx b/framework/source/layoutmanager/toolbarlayoutmanager.cxx new file mode 100755 index 0000000000..16568834ef --- /dev/null +++ b/framework/source/layoutmanager/toolbarlayoutmanager.cxx @@ -0,0 +1,4298 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2008 by Sun Microsystems, Inc. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: layoutmanager.cxx,v $ + * $Revision: 1.72 $ + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_framework.hxx" + +// my own includes +#include <toolbarlayoutmanager.hxx> +#include <helpers.hxx> +#include <services.h> +#include <classes/resource.hrc> +#include <classes/fwkresid.hxx> +#include <uiconfiguration/windowstateconfiguration.hxx> + +// interface includes +#include <com/sun/star/awt/PosSize.hpp> +#include <com/sun/star/ui/UIElementType.hpp> +#include <com/sun/star/container/XNameReplace.hpp> +#include <com/sun/star/container/XNameContainer.hpp> +#include <com/sun/star/ui/XUIElementSettings.hpp> +#include <com/sun/star/ui/XUIFunctionListener.hpp> + +// other includes +#include <unotools/cmdoptions.hxx> +#include <toolkit/unohlp.hxx> +#include <toolkit/helper/convert.hxx> +#include <toolkit/awt/vclxwindow.hxx> +#include <vcl/i18nhelp.hxx> +#include <vcl/dockingarea.hxx> +#include <boost/bind.hpp> + +using namespace ::com::sun::star; + +namespace framework +{ + +ToolbarLayoutManager::ToolbarLayoutManager( + const uno::Reference< lang::XMultiServiceFactory >& xSMGR, + const uno::Reference< ui::XUIElementFactory >& xUIElementFactory, + ILayoutNotifications* pParentLayouter ) + : ThreadHelpBase( &Application::GetSolarMutex() ), + m_xSMGR( xSMGR ), + m_xUIElementFactoryManager( xUIElementFactory ), + m_pParentLayouter( pParentLayouter ), + m_eDockOperation( DOCKOP_ON_COLROW ), + m_pAddonOptions( 0 ), + m_pGlobalSettings( 0 ), + m_bComponentAttached( false ), + m_bMustLayout( false ), + m_bLayoutDirty( false ), + m_bStoreWindowState( false ), + m_bGlobalSettings( false ), + m_bDockingInProgress( false ), + m_bVisible( true ), + m_bLayoutInProgress( false ), + m_bToolbarCreation( false ), + m_aFullAddonTbxPrefix( RTL_CONSTASCII_USTRINGPARAM( "private:resource/toolbar/addon_" )), + m_aCustomTbxPrefix( RTL_CONSTASCII_USTRINGPARAM( "custom_" )), + m_aCustomizeCmd( RTL_CONSTASCII_USTRINGPARAM( "ConfigureDialog" )), + m_aToolbarTypeString( RTL_CONSTASCII_USTRINGPARAM( UIRESOURCETYPE_TOOLBAR )) +{ + // initialize rectangles to zero values + setZeroRectangle( m_aDockingAreaOffsets ); + setZeroRectangle( m_aDockingArea ); + + // create toolkit object + m_xToolkit = uno::Reference< awt::XToolkit >( m_xSMGR->createInstance( SERVICENAME_VCLTOOLKIT ), uno::UNO_QUERY ); +} + +ToolbarLayoutManager::~ToolbarLayoutManager() +{ +} + +//--------------------------------------------------------------------------------------------------------- +// XInterface +//--------------------------------------------------------------------------------------------------------- +void SAL_CALL ToolbarLayoutManager::acquire() throw() +{ + OWeakObject::acquire(); +} + +void SAL_CALL ToolbarLayoutManager::release() throw() +{ + OWeakObject::release(); +} + +uno::Any SAL_CALL ToolbarLayoutManager::queryInterface( const uno::Type & rType ) throw( uno::RuntimeException ) +{ + uno::Any a = ::cppu::queryInterface( rType, + SAL_STATIC_CAST( awt::XDockableWindowListener*, this ), + SAL_STATIC_CAST( ui::XUIConfigurationListener*, this ), + SAL_STATIC_CAST( awt::XWindowListener*, this )); + + if ( a.hasValue() ) + return a; + + return OWeakObject::queryInterface( rType ); +} + +void SAL_CALL ToolbarLayoutManager::disposing( const lang::EventObject& aEvent ) throw( uno::RuntimeException ) +{ + if ( aEvent.Source == m_xFrame ) + { + // Reset all internal references + reset(); + implts_destroyDockingAreaWindows(); + } +} + +awt::Rectangle ToolbarLayoutManager::getDockingArea() +{ + WriteGuard aWriteLock( m_aLock ); + Rectangle aNewDockingArea( m_aDockingArea ); + aWriteLock.unlock(); + + if ( isLayoutDirty() ) + aNewDockingArea = implts_calcDockingArea(); + + aWriteLock.lock(); + m_aDockingArea = aNewDockingArea; + aWriteLock.unlock(); + + return putRectangleValueToAWT(aNewDockingArea); +} + +void ToolbarLayoutManager::setDockingArea( const awt::Rectangle& rDockingArea ) +{ + WriteGuard aWriteLock( m_aLock ); + m_aDockingArea = putAWTToRectangle( rDockingArea ); + m_bLayoutDirty = true; + aWriteLock.unlock(); +} + +void ToolbarLayoutManager::implts_setDockingAreaWindowSizes( const awt::Rectangle& rBorderSpace ) +{ + ReadGuard aReadLock( m_aLock ); + Rectangle aDockOffsets = m_aDockingAreaOffsets; + uno::Reference< awt::XWindow2 > xContainerWindow( m_xContainerWindow ); + uno::Reference< awt::XWindow > xTopDockAreaWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_TOP] ); + uno::Reference< awt::XWindow > xBottomDockAreaWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_BOTTOM] ); + uno::Reference< awt::XWindow > xLeftDockAreaWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_LEFT] ); + uno::Reference< awt::XWindow > xRightDockAreaWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_RIGHT] ); + aReadLock.unlock(); + + uno::Reference< awt::XDevice > xDevice( xContainerWindow, uno::UNO_QUERY ); + + // Convert relativ size to output size. + awt::Rectangle aRectangle = xContainerWindow->getPosSize(); + awt::DeviceInfo aInfo = xDevice->getInfo(); + awt::Size aContainerClientSize = awt::Size( aRectangle.Width - aInfo.LeftInset - aInfo.RightInset , + aRectangle.Height - aInfo.TopInset - aInfo.BottomInset ); + long aStatusBarHeight = aDockOffsets.GetHeight(); + + sal_Int32 nLeftRightDockingAreaHeight( aContainerClientSize.Height ); + if ( rBorderSpace.Y >= 0 ) + { + // Top docking area window + xTopDockAreaWindow->setPosSize( 0, 0, aContainerClientSize.Width, rBorderSpace.Y, awt::PosSize::POSSIZE ); + xTopDockAreaWindow->setVisible( sal_True ); + nLeftRightDockingAreaHeight -= rBorderSpace.Y; + } + + if ( rBorderSpace.Height >= 0 ) + { + // Bottom docking area window + sal_Int32 nBottomPos = std::max( sal_Int32( aContainerClientSize.Height - rBorderSpace.Height - aStatusBarHeight ), sal_Int32( 0 )); + sal_Int32 nHeight = ( nBottomPos == 0 ) ? 0 : rBorderSpace.Height; + + xBottomDockAreaWindow->setPosSize( 0, nBottomPos, aContainerClientSize.Width, nHeight, awt::PosSize::POSSIZE ); + xBottomDockAreaWindow->setVisible( sal_True ); + nLeftRightDockingAreaHeight -= nHeight; + } + + nLeftRightDockingAreaHeight -= aStatusBarHeight; + if ( rBorderSpace.X >= 0 || nLeftRightDockingAreaHeight > 0 ) + { + // Left docking area window + // We also have to change our right docking area window if the top or bottom area has changed. They have a higher priority! + sal_Int32 nHeight = std::max( sal_Int32( 0 ), sal_Int32( nLeftRightDockingAreaHeight )); + + xLeftDockAreaWindow->setPosSize( 0, rBorderSpace.Y, rBorderSpace.X, nHeight, awt::PosSize::POSSIZE ); + xLeftDockAreaWindow->setVisible( sal_True ); + } + if ( rBorderSpace.Width >= 0 || nLeftRightDockingAreaHeight > 0 ) + { + // Right docking area window + // We also have to change our right docking area window if the top or bottom area has changed. They have a higher priority! + sal_Int32 nLeftPos = std::max( sal_Int32( 0 ), sal_Int32( aContainerClientSize.Width - rBorderSpace.Width )); + sal_Int32 nHeight = std::max( sal_Int32( 0 ), sal_Int32( nLeftRightDockingAreaHeight )); + sal_Int32 nWidth = ( nLeftPos == 0 ) ? 0 : rBorderSpace.Width; + + xRightDockAreaWindow->setPosSize( nLeftPos, rBorderSpace.Y, nWidth, nHeight, awt::PosSize::POSSIZE ); + xRightDockAreaWindow->setVisible( sal_True ); + } +} + +bool ToolbarLayoutManager::isLayoutDirty() +{ + return m_bLayoutDirty; +} + +void ToolbarLayoutManager::doLayout(const ::Size& aContainerSize) +{ + WriteGuard aWriteLock( m_aLock ); + bool bLayoutInProgress( m_bLayoutInProgress ); + m_bLayoutInProgress = true; + awt::Rectangle aDockingArea = putRectangleValueToAWT( m_aDockingArea ); + aWriteLock.unlock(); + + if ( bLayoutInProgress ) + return; + + // Retrieve row/column dependent data from all docked user-interface elements + for ( sal_Int32 i = 0; i < DOCKINGAREAS_COUNT; i++ ) + { + bool bReverse( isReverseOrderDockingArea( i )); + std::vector< SingleRowColumnWindowData > aRowColumnsWindowData; + + implts_getDockingAreaElementInfos( (ui::DockingArea)i, aRowColumnsWindowData ); + + sal_Int32 nOffset( 0 ); + const sal_uInt32 nCount = aRowColumnsWindowData.size(); + for ( sal_uInt32 j = 0; j < nCount; ++j ) + { + sal_uInt32 nIndex = bReverse ? nCount-j-1 : j; + implts_calcWindowPosSizeOnSingleRowColumn( i, nOffset, aRowColumnsWindowData[nIndex], aContainerSize ); + nOffset += aRowColumnsWindowData[j].nStaticSize; + } + } + + implts_setDockingAreaWindowSizes( aDockingArea ); + + aWriteLock.lock(); + m_bLayoutDirty = false; + m_bLayoutInProgress = false; + aWriteLock.unlock(); +} + +bool ToolbarLayoutManager::implts_isParentWindowVisible() const +{ + ReadGuard aReadLock( m_aLock ); + bool bVisible( false ); + if ( m_xContainerWindow.is() ) + bVisible = m_xContainerWindow->isVisible(); + + return bVisible; +} + +Rectangle ToolbarLayoutManager::implts_calcDockingArea() +{ + ReadGuard aReadLock( m_aLock ); + UIElementVector aWindowVector( m_aUIElements ); + aReadLock.unlock(); + + Rectangle aBorderSpace; + sal_Int32 nCurrRowColumn( 0 ); + sal_Int32 nCurrPos( 0 ); + sal_Int32 nCurrDockingArea( ui::DockingArea_DOCKINGAREA_TOP ); + std::vector< sal_Int32 > aRowColumnSizes[DOCKINGAREAS_COUNT]; + UIElementVector::const_iterator pConstIter; + + // initialize rectangle with zero values! + aBorderSpace.setWidth(0); + aBorderSpace.setHeight(0); + + aRowColumnSizes[nCurrDockingArea].clear(); + aRowColumnSizes[nCurrDockingArea].push_back( 0 ); + + for ( pConstIter = aWindowVector.begin(); pConstIter != aWindowVector.end(); pConstIter++ ) + { + uno::Reference< ui::XUIElement > xUIElement( pConstIter->m_xUIElement, uno::UNO_QUERY ); + if ( xUIElement.is() ) + { + uno::Reference< awt::XWindow > xWindow( xUIElement->getRealInterface(), uno::UNO_QUERY ); + uno::Reference< awt::XDockableWindow > xDockWindow( xWindow, uno::UNO_QUERY ); + if ( xWindow.is() && xDockWindow.is() ) + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + + Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); + if ( pWindow && !xDockWindow->isFloating() && pConstIter->m_bVisible ) + { + awt::Rectangle aPosSize = xWindow->getPosSize(); + if ( pConstIter->m_aDockedData.m_nDockedArea != nCurrDockingArea ) + { + nCurrDockingArea = pConstIter->m_aDockedData.m_nDockedArea; + nCurrRowColumn = 0; + nCurrPos = 0; + aRowColumnSizes[nCurrDockingArea].clear(); + aRowColumnSizes[nCurrDockingArea].push_back( 0 ); + } + + if ( pConstIter->m_aDockedData.m_nDockedArea == nCurrDockingArea ) + { + if ( isHorizontalDockingArea( pConstIter->m_aDockedData.m_nDockedArea )) + { + if ( pConstIter->m_aDockedData.m_aPos.Y() > nCurrPos ) + { + ++nCurrRowColumn; + nCurrPos = pConstIter->m_aDockedData.m_aPos.Y(); + aRowColumnSizes[nCurrDockingArea].push_back( 0 ); + } + + if ( aPosSize.Height > aRowColumnSizes[nCurrDockingArea][nCurrRowColumn] ) + aRowColumnSizes[nCurrDockingArea][nCurrRowColumn] = aPosSize.Height; + } + else + { + if ( pConstIter->m_aDockedData.m_aPos.X() > nCurrPos ) + { + ++nCurrRowColumn; + nCurrPos = pConstIter->m_aDockedData.m_aPos.X(); + aRowColumnSizes[nCurrDockingArea].push_back( 0 ); + } + + if ( aPosSize.Width > aRowColumnSizes[nCurrDockingArea][nCurrRowColumn] ) + aRowColumnSizes[nCurrDockingArea][nCurrRowColumn] = aPosSize.Width; + } + } + } + } + } + } + + // Sum up max heights from every row/column + if ( !aWindowVector.empty() ) + { + for ( sal_Int32 i = 0; i <= ui::DockingArea_DOCKINGAREA_RIGHT; i++ ) + { + sal_Int32 nSize( 0 ); + const sal_uInt32 nCount = aRowColumnSizes[i].size(); + for ( sal_uInt32 j = 0; j < nCount; j++ ) + nSize += aRowColumnSizes[i][j]; + + if ( i == ui::DockingArea_DOCKINGAREA_TOP ) + aBorderSpace.Top() = nSize; + else if ( i == ui::DockingArea_DOCKINGAREA_BOTTOM ) + aBorderSpace.Bottom() = nSize; + else if ( i == ui::DockingArea_DOCKINGAREA_LEFT ) + aBorderSpace.Left() = nSize; + else + aBorderSpace.Right() = nSize; + } + } + + return aBorderSpace; +} + +void ToolbarLayoutManager::reset() +{ + WriteGuard aWriteLock( m_aLock ); + uno::Reference< ui::XUIConfigurationManager > xModuleCfgMgr( m_xModuleCfgMgr ); + uno::Reference< ui::XUIConfigurationManager > xDocCfgMgr( m_xDocCfgMgr ); + m_xModuleCfgMgr.clear(); + m_xDocCfgMgr.clear(); + m_bComponentAttached = false; + aWriteLock.unlock(); + + destroyToolbars(); + resetDockingArea(); +} + +void ToolbarLayoutManager::attach( + const uno::Reference< frame::XFrame >& xFrame, + const uno::Reference< ui::XUIConfigurationManager >& xModuleCfgMgr, + const uno::Reference< ui::XUIConfigurationManager >& xDocCfgMgr, + const uno::Reference< container::XNameAccess >& xPersistentWindowState ) +{ + // reset toolbar manager if we lose our current frame + if ( m_xFrame.is() && m_xFrame != xFrame ) + reset(); + + WriteGuard aWriteLock( m_aLock ); + m_xFrame = xFrame; + m_xModuleCfgMgr = xModuleCfgMgr; + m_xDocCfgMgr = xDocCfgMgr; + m_xPersistentWindowState = xPersistentWindowState; + m_bComponentAttached = true; +} + +void ToolbarLayoutManager::createStaticToolbars() +{ + resetDockingArea(); + implts_createCustomToolBars(); + implts_createAddonsToolBars(); + implts_createNonContextSensitiveToolBars(); + implts_sortUIElements(); +} + +bool ToolbarLayoutManager::requestToolbar( const ::rtl::OUString& rResourceURL ) +{ + bool bNotify( false ); + bool bMustCallCreate( false ); + uno::Reference< ui::XUIElement > xUIElement; + + UIElement aRequestedToolbar = impl_findToolbar( rResourceURL ); + if ( aRequestedToolbar.m_aName != rResourceURL ) + { + bMustCallCreate = true; + aRequestedToolbar.m_aName = rResourceURL; + aRequestedToolbar.m_aType = m_aToolbarTypeString; + aRequestedToolbar.m_xUIElement = xUIElement; + implts_readWindowStateData( rResourceURL, aRequestedToolbar ); + } + + xUIElement = aRequestedToolbar.m_xUIElement; + if ( !xUIElement.is() ) + bMustCallCreate = true; + + bool bCreateOrShowToolbar( aRequestedToolbar.m_bVisible & !aRequestedToolbar.m_bMasterHide ); + uno::Reference< awt::XWindow2 > xContainerWindow( m_xContainerWindow, uno::UNO_QUERY ); + if ( xContainerWindow.is() && aRequestedToolbar.m_bFloating ) + bCreateOrShowToolbar &= bool( xContainerWindow->isActive()); + + if ( bCreateOrShowToolbar ) + bNotify = ( bMustCallCreate ) ? createToolbar( rResourceURL ) : showToolbar( rResourceURL ); + + return bNotify; +} + +bool ToolbarLayoutManager::createToolbar( const ::rtl::OUString& rResourceURL ) +{ + bool bNotify( false ); + uno::Reference< ui::XUIElement > xUITempElement; + + implts_createToolBar( rResourceURL, bNotify, xUITempElement ); + return bNotify; +} + +bool ToolbarLayoutManager::destroyToolbar( const ::rtl::OUString& rResourceURL ) +{ + const rtl::OUString aAddonTbResourceName( RTL_CONSTASCII_USTRINGPARAM( "private:resource/toolbar/addon_" )); + + UIElementVector::iterator pIter; + uno::Reference< lang::XComponent > xComponent; + + bool bNotify( false ); + bool bMustBeSorted( false ); + bool bMustLayouted( false ); + bool bMustBeDestroyed( rResourceURL.indexOf( aAddonTbResourceName ) != 0 ); + + WriteGuard aWriteLock( m_aLock ); + for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) + { + if ( pIter->m_aName == rResourceURL ) + { + xComponent.set( pIter->m_xUIElement, uno::UNO_QUERY ); + if ( bMustBeDestroyed ) + pIter->m_xUIElement.clear(); + else + pIter->m_bVisible = false; + break; + } + } + aWriteLock.unlock(); + + uno::Reference< ui::XUIElement > xUIElement( xComponent, uno::UNO_QUERY ); + if ( xUIElement.is() ) + { + uno::Reference< awt::XWindow > xWindow( xUIElement->getRealInterface(), uno::UNO_QUERY ); + uno::Reference< awt::XDockableWindow > xDockWindow( xWindow, uno::UNO_QUERY ); + + if ( bMustBeDestroyed ) + { + try + { + if ( xWindow.is() ) + xWindow->removeWindowListener( uno::Reference< awt::XWindowListener >( + static_cast< OWeakObject * >( this ), uno::UNO_QUERY )); + } + catch( uno::Exception& ) {} + + try + { + if ( xDockWindow.is() ) + xDockWindow->removeDockableWindowListener( uno::Reference< awt::XDockableWindowListener >( + static_cast< OWeakObject * >( this ), uno::UNO_QUERY )); + } + catch ( uno::Exception& ) {} + } + else + { + if ( xWindow.is() ) + xWindow->setVisible( sal_False ); + bNotify = true; + } + + if ( !xDockWindow->isFloating() ) + bMustLayouted = true; + bMustBeSorted = true; + } + + if ( bMustBeDestroyed ) + { + if ( xComponent.is() ) + xComponent->dispose(); + bNotify = true; + } + + if ( bMustLayouted ) + implts_setLayoutDirty(); + + if ( bMustBeSorted ) + implts_sortUIElements(); + + return bNotify; +} + +void ToolbarLayoutManager::destroyToolbars() +{ + UIElementVector aUIElementVector; + implts_getUIElementVectorCopy( aUIElementVector ); + + WriteGuard aWriteLock( m_aLock ); + m_aUIElements.clear(); + m_bLayoutDirty = true; + aWriteLock.unlock(); + + UIElementVector::iterator pIter; + for ( pIter = aUIElementVector.begin(); pIter != aUIElementVector.end(); pIter++ ) + { + uno::Reference< lang::XComponent > xComponent( pIter->m_xUIElement, uno::UNO_QUERY ); + if ( xComponent.is() ) + xComponent->dispose(); + } +} + +bool ToolbarLayoutManager::showToolbar( const ::rtl::OUString& rResourceURL ) +{ + UIElement aUIElement = implts_findToolbar( rResourceURL ); + + vos::OGuard aGuard( Application::GetSolarMutex() ); + Window* pWindow = getWindowFromXUIElement( aUIElement.m_xUIElement ); + if ( pWindow ) + { + if ( !aUIElement.m_bFloating ) + implts_setLayoutDirty(); + else + pWindow->Show( TRUE, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE ); + + aUIElement.m_bVisible = true; + implts_writeWindowStateData( aUIElement ); + implts_setToolbar( aUIElement ); + return true; + } + + return false; +} + +bool ToolbarLayoutManager::hideToolbar( const ::rtl::OUString& rResourceURL ) +{ + UIElement aUIElement = implts_findToolbar( rResourceURL ); + + vos::OGuard aGuard( Application::GetSolarMutex() ); + Window* pWindow = getWindowFromXUIElement( aUIElement.m_xUIElement ); + if ( pWindow ) + { + pWindow->Show( FALSE ); + if ( !aUIElement.m_bFloating ) + implts_setLayoutDirty(); + + aUIElement.m_bVisible = false; + implts_writeWindowStateData( aUIElement ); + implts_setToolbar( aUIElement ); + return true; + } + + return false; +} + +void ToolbarLayoutManager::refreshToolbarsVisibility() +{ + UIElementVector aUIElementVector; + implts_getUIElementVectorCopy( aUIElementVector ); + + vos::OGuard aGuard( Application::GetSolarMutex() ); + UIElementVector::iterator pIter; + for ( pIter = aUIElementVector.begin(); pIter != aUIElementVector.end(); pIter++ ) + { + Window* pWindow = getWindowFromXUIElement( pIter->m_xUIElement ); + if ( pWindow ) + { + if ( pIter->m_bVisible && !pIter->m_bMasterHide ) + { + if ( pIter->m_bFloating ) + pWindow->Show( TRUE, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE ); + else + implts_setLayoutDirty(); + } + else + pWindow->Show( FALSE ); + } + } +} + +void ToolbarLayoutManager::setFloatingToolbarsVisibility( bool bVisible ) +{ + UIElementVector aUIElementVector; + implts_getUIElementVectorCopy( aUIElementVector ); + + vos::OGuard aGuard( Application::GetSolarMutex() ); + UIElementVector::iterator pIter; + for ( pIter = aUIElementVector.begin(); pIter != aUIElementVector.end(); pIter++ ) + { + Window* pWindow = getWindowFromXUIElement( pIter->m_xUIElement ); + if ( pWindow && pIter->m_bFloating ) + { + if ( bVisible ) + { + if ( pIter->m_bVisible && !pIter->m_bMasterHide ) + pWindow->Show( TRUE, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE ); + } + else + pWindow->Show( FALSE ); + } + } +} + +void ToolbarLayoutManager::setVisible( bool bVisible ) +{ + UIElementVector aUIElementVector; + implts_getUIElementVectorCopy( aUIElementVector ); + + vos::OGuard aGuard( Application::GetSolarMutex() ); + UIElementVector::iterator pIter; + for ( pIter = aUIElementVector.begin(); pIter != aUIElementVector.end(); pIter++ ) + { + pIter->m_bMasterHide = !bVisible; + Window* pWindow = getWindowFromXUIElement( pIter->m_xUIElement ); + if ( pWindow ) + { + bool bSetVisible( pIter->m_bVisible & bVisible ); + if ( !bSetVisible ) + pWindow->Hide(); + else + { + if ( pIter->m_bFloating ) + pWindow->Show(true, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE ); + else + implts_setLayoutDirty(); + } + } + } + + if ( !bVisible ) + resetDockingArea(); +} + +bool ToolbarLayoutManager::dockToolbar( const ::rtl::OUString& rResourceURL, ui::DockingArea eDockingArea, const awt::Point& aPos ) +{ + UIElement aUIElement = implts_findToolbar( rResourceURL ); + + if ( aUIElement.m_xUIElement.is() ) + { + try + { + uno::Reference< awt::XWindow > xWindow( aUIElement.m_xUIElement->getRealInterface(), uno::UNO_QUERY ); + uno::Reference< awt::XDockableWindow > xDockWindow( xWindow, uno::UNO_QUERY ); + if ( xDockWindow.is() ) + { + if ( eDockingArea != ui::DockingArea_DOCKINGAREA_DEFAULT ) + aUIElement.m_aDockedData.m_nDockedArea = sal_Int16( eDockingArea ); + + if ( !isDefaultPos( aPos )) + aUIElement.m_aDockedData.m_aPos = ::Point( aPos.X, aPos.Y ); + + if ( !xDockWindow->isFloating() ) + { + Window* pWindow( 0 ); + ToolBox* pToolBox( 0 ); + + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + pWindow = VCLUnoHelper::GetWindow( xWindow ); + if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX ) + { + pToolBox = (ToolBox *)pWindow; + + // We have to set the alignment of the toolbox. It's possible that the toolbox is moved from a + // horizontal to a vertical docking area! + pToolBox->SetAlign( ImplConvertAlignment( aUIElement.m_aDockedData.m_nDockedArea )); + } + } + + if ( hasDefaultPosValue( aUIElement.m_aDockedData.m_aPos )) + { + // Docking on its default position without a preset position - + // we have to find a good place for it. + ::Size aSize; + + vos::OGuard aGuard( Application::GetSolarMutex() ); + { + if ( pToolBox ) + aSize = pToolBox->CalcWindowSizePixel( 1, ImplConvertAlignment( aUIElement.m_aDockedData.m_nDockedArea ) ); + else + aSize = pWindow->GetSizePixel(); + } + + ::Point aPixelPos; + ::Point aDockPos; + implts_findNextDockingPos((ui::DockingArea)aUIElement.m_aDockedData.m_nDockedArea, aSize, aDockPos, aPixelPos ); + aUIElement.m_aDockedData.m_aPos = aDockPos; + } + } + + implts_setToolbar( aUIElement ); + + if ( xDockWindow->isFloating() ) + { + // ATTENTION: This will call toggleFloatingMode() via notifications which + // sets the floating member of the UIElement correctly! + xDockWindow->setFloatingMode( sal_False ); + } + else + { + implts_writeWindowStateData( aUIElement ); + implts_sortUIElements(); + + if ( aUIElement.m_bVisible ) + implts_setLayoutDirty(); + } + return true; + } + } + catch ( lang::DisposedException& ) {} + } + + return false; +} + +bool ToolbarLayoutManager::dockAllToolbars() +{ + std::vector< ::rtl::OUString > aToolBarNameVector; + + ::rtl::OUString aElementType; + ::rtl::OUString aElementName; + + ReadGuard aReadLock( m_aLock ); + UIElementVector::iterator pIter; + for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) + { + if ( pIter->m_aType.equalsAscii( "toolbar" ) && pIter->m_xUIElement.is() && + pIter->m_bFloating && pIter->m_bVisible ) + aToolBarNameVector.push_back( pIter->m_aName ); + } + aReadLock.unlock(); + + bool bResult(true); + const sal_uInt32 nCount = aToolBarNameVector.size(); + for ( sal_uInt32 i = 0; i < nCount; ++i ) + { + awt::Point aPoint; + aPoint.X = aPoint.Y = SAL_MAX_INT32; + bResult &= dockToolbar( aToolBarNameVector[i], ui::DockingArea_DOCKINGAREA_DEFAULT, aPoint ); + } + + return bResult; +} + +long ToolbarLayoutManager::childWindowEvent( VclSimpleEvent* pEvent ) +{ + // To enable toolbar controllers to change their image when a sub-toolbar function + // is activated, we need this mechanism. We have NO connection between these toolbars + // anymore! + if ( pEvent && pEvent->ISA( VclWindowEvent )) + { + if ( pEvent->GetId() == VCLEVENT_TOOLBOX_SELECT ) + { + ::rtl::OUString aToolbarName; + ::rtl::OUString aCommand; + ToolBox* pToolBox = getToolboxPtr( ((VclWindowEvent*)pEvent)->GetWindow() ); + + if ( pToolBox ) + { + aToolbarName = retrieveToolbarNameFromHelpURL( pToolBox ); + USHORT nId = pToolBox->GetCurItemId(); + if ( nId > 0 ) + aCommand = pToolBox->GetItemCommand( nId ); + } + + if (( aToolbarName.getLength() > 0 ) && ( aCommand.getLength() > 0 )) + { + ReadGuard aReadLock( m_aLock ); + ::std::vector< uno::Reference< ui::XUIFunctionListener > > aListenerArray; + UIElementVector::iterator pIter; + + for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) + { + if ( pIter->m_xUIElement.is() ) + { + uno::Reference< ui::XUIFunctionListener > xListener( pIter->m_xUIElement, uno::UNO_QUERY ); + if ( xListener.is() ) + aListenerArray.push_back( xListener ); + } + } + aReadLock.unlock(); + + const sal_uInt32 nCount = aListenerArray.size(); + for ( sal_uInt32 i = 0; i < nCount; ++i ) + { + try { aListenerArray[i]->functionExecute( aToolbarName, aCommand ); } + catch ( uno::RuntimeException& ) { throw; } + catch ( uno::Exception& ) {} + } + } + } + else if ( pEvent->GetId() == VCLEVENT_TOOLBOX_FORMATCHANGED ) + { + if ( !implts_isToolbarCreationActive() ) + { + ToolBox* pToolBox = getToolboxPtr( ((VclWindowEvent*)pEvent)->GetWindow() ); + if ( pToolBox ) + { + ::rtl::OUString aToolbarName = retrieveToolbarNameFromHelpURL( pToolBox ); + if ( aToolbarName.getLength() > 0 ) + { + ::rtl::OUStringBuffer aBuf(100); + aBuf.appendAscii( "private:resource/toolbar/" ); + aBuf.append( aToolbarName ); + + UIElement aToolbar = implts_findToolbar( aBuf.makeStringAndClear() ); + if ( aToolbar.m_xUIElement.is() && !aToolbar.m_bFloating ) + { + implts_setLayoutDirty(); + m_pParentLayouter->requestLayout( ILayoutNotifications::HINT_TOOLBARSPACE_HAS_CHANGED ); + } + } + } + } + } + } + + return 1; +} + +void ToolbarLayoutManager::resetDockingArea() +{ + ReadGuard aReadLock( m_aLock ); + uno::Reference< awt::XWindow > xTopDockingWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_TOP] ); + uno::Reference< awt::XWindow > xLeftDockingWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_LEFT] ); + uno::Reference< awt::XWindow > xRightDockingWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_RIGHT] ); + uno::Reference< awt::XWindow > xBottomDockingWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_BOTTOM] ); + aReadLock.unlock(); + + if ( xTopDockingWindow.is() ) + xTopDockingWindow->setPosSize( 0, 0, 0, 0, awt::PosSize::POSSIZE ); + if ( xLeftDockingWindow.is() ) + xLeftDockingWindow->setPosSize( 0, 0, 0, 0, awt::PosSize::POSSIZE ); + if ( xRightDockingWindow.is() ) + xRightDockingWindow->setPosSize( 0, 0, 0, 0, awt::PosSize::POSSIZE ); + if ( xBottomDockingWindow.is() ) + xBottomDockingWindow->setPosSize( 0, 0, 0, 0, awt::PosSize::POSSIZE ); +} + +void ToolbarLayoutManager::setParentWindow( + const uno::Reference< awt::XWindowPeer >& xParentWindow ) +{ + static const char DOCKINGAREASTRING[] = "dockingarea"; + + uno::Reference< awt::XWindow > xTopDockWindow = uno::Reference< awt::XWindow >( createToolkitWindow( m_xSMGR, xParentWindow, DOCKINGAREASTRING ), uno::UNO_QUERY ); + uno::Reference< awt::XWindow > xLeftDockWindow = uno::Reference< awt::XWindow >( createToolkitWindow( m_xSMGR, xParentWindow, DOCKINGAREASTRING ), uno::UNO_QUERY ); + uno::Reference< awt::XWindow > xRightDockWindow = uno::Reference< awt::XWindow >( createToolkitWindow( m_xSMGR, xParentWindow, DOCKINGAREASTRING ), uno::UNO_QUERY ); + uno::Reference< awt::XWindow > xBottomDockWindow = uno::Reference< awt::XWindow >( createToolkitWindow( m_xSMGR, xParentWindow, DOCKINGAREASTRING ), uno::UNO_QUERY ); + + WriteGuard aWriteLock( m_aLock ); + m_xContainerWindow = uno::Reference< awt::XWindow2 >( xParentWindow, uno::UNO_QUERY ); + m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_TOP] = xTopDockWindow; + m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_LEFT] = xLeftDockWindow; + m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_RIGHT] = xRightDockWindow; + m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_BOTTOM] = xBottomDockWindow; + aWriteLock.unlock(); + + if ( xParentWindow.is() ) + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + ::DockingAreaWindow* pWindow = dynamic_cast< ::DockingAreaWindow* >(VCLUnoHelper::GetWindow( xTopDockWindow ) ); + if( pWindow ) pWindow->SetAlign( WINDOWALIGN_TOP ); + pWindow = dynamic_cast< ::DockingAreaWindow* >(VCLUnoHelper::GetWindow( xBottomDockWindow ) ); + if( pWindow ) pWindow->SetAlign( WINDOWALIGN_BOTTOM ); + pWindow = dynamic_cast< ::DockingAreaWindow* >(VCLUnoHelper::GetWindow( xLeftDockWindow ) ); + if( pWindow ) pWindow->SetAlign( WINDOWALIGN_LEFT ); + pWindow = dynamic_cast< ::DockingAreaWindow* >(VCLUnoHelper::GetWindow( xRightDockWindow ) ); + if( pWindow ) pWindow->SetAlign( WINDOWALIGN_RIGHT ); + implts_reparentToolbars(); + } + else + { + destroyToolbars(); + resetDockingArea(); + } +} + +void ToolbarLayoutManager::setDockingAreaOffsets( const ::Rectangle aOffsets ) +{ + WriteGuard aWriteLock( m_aLock ); + m_aDockingAreaOffsets = aOffsets; + m_bLayoutDirty = true; +} + +rtl::OUString ToolbarLayoutManager::implts_generateGenericAddonToolbarTitle( sal_Int32 nNumber ) const +{ + String aAddonGenericTitle; + + aAddonGenericTitle = String( FwkResId( STR_TOOLBAR_TITLE_ADDON )); + const vcl::I18nHelper& rI18nHelper = Application::GetSettings().GetUILocaleI18nHelper(); + + String aNumStr = rI18nHelper.GetNum( nNumber, 0, FALSE, FALSE ); + aAddonGenericTitle.SearchAndReplaceAscii( "%num%", aNumStr ); + + return rtl::OUString( aAddonGenericTitle ); +} + +void ToolbarLayoutManager::implts_createAddonsToolBars() +{ + WriteGuard aWriteLock( m_aLock ); + if ( !m_pAddonOptions ) + m_pAddonOptions = new AddonsOptions; + + uno::Reference< ui::XUIElementFactory > xUIElementFactory( m_xUIElementFactoryManager ); + uno::Reference< frame::XFrame > xFrame( m_xFrame ); + aWriteLock.unlock(); + + uno::Reference< frame::XModel > xModel( impl_getModelFromFrame( xFrame )); + if ( implts_isPreviewModel( xModel )) + return; // no addon toolbars for preview frame! + + UIElementVector aUIElementVector; + uno::Sequence< uno::Sequence< beans::PropertyValue > > aAddonToolBarData; + uno::Reference< ui::XUIElement > xUIElement; + + sal_uInt32 nCount = m_pAddonOptions->GetAddonsToolBarCount(); + ::rtl::OUString aAddonsToolBarStaticName( m_aFullAddonTbxPrefix ); + ::rtl::OUString aElementType( RTL_CONSTASCII_USTRINGPARAM( "toolbar" )); + + uno::Sequence< beans::PropertyValue > aPropSeq( 2 ); + aPropSeq[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Frame" )); + aPropSeq[0].Value <<= xFrame; + aPropSeq[1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ConfigurationData" )); + for ( sal_uInt32 i = 0; i < nCount; i++ ) + { + ::rtl::OUString aAddonToolBarName( aAddonsToolBarStaticName + m_pAddonOptions->GetAddonsToolbarResourceName(i) ); + aAddonToolBarData = m_pAddonOptions->GetAddonsToolBarPart( i ); + aPropSeq[1].Value <<= aAddonToolBarData; + + UIElement aElement = implts_findToolbar( aAddonToolBarName ); + + // #i79828 + // It's now possible that we are called more than once. Be sure to not create + // add-on toolbars more than once! + if ( aElement.m_xUIElement.is() ) + continue; + + try + { + xUIElement = xUIElementFactory->createUIElement( aAddonToolBarName, aPropSeq ); + if ( xUIElement.is() ) + { + uno::Reference< awt::XDockableWindow > xDockWindow( xUIElement->getRealInterface(), uno::UNO_QUERY ); + if ( xDockWindow.is() ) + { + try + { + xDockWindow->addDockableWindowListener( uno::Reference< awt::XDockableWindowListener >( static_cast< OWeakObject * >( this ), uno::UNO_QUERY )); + xDockWindow->enableDocking( sal_True ); + uno::Reference< awt::XWindow > xWindow( xDockWindow, uno::UNO_QUERY ); + if ( xWindow.is() ) + xWindow->addWindowListener( uno::Reference< awt::XWindowListener >( static_cast< OWeakObject * >( this ), uno::UNO_QUERY )); + } + catch ( uno::Exception& ) {} + } + + ::rtl::OUString aGenericAddonTitle = implts_generateGenericAddonToolbarTitle( i+1 ); + + if ( aElement.m_aName.getLength() > 0 ) + { + // Reuse a local entry so we are able to use the latest + // UI changes for this document. + implts_setElementData( aElement, xDockWindow ); + aElement.m_xUIElement = xUIElement; + if ( aElement.m_aUIName.getLength() == 0 ) + { + aElement.m_aUIName = aGenericAddonTitle; + implts_writeWindowStateData( aElement ); + } + } + else + { + // Create new UI element and try to read its state data + UIElement aNewToolbar( aAddonToolBarName, aElementType, xUIElement ); + aNewToolbar.m_bFloating = true; + implts_readWindowStateData( aAddonToolBarName, aNewToolbar ); + implts_setElementData( aNewToolbar, xDockWindow ); + if ( aNewToolbar.m_aUIName.getLength() == 0 ) + { + aNewToolbar.m_aUIName = aGenericAddonTitle; + implts_writeWindowStateData( aNewToolbar ); + } + implts_insertToolbar( aNewToolbar ); + } + + uno::Reference< awt::XWindow > xWindow( xDockWindow, uno::UNO_QUERY ); + if ( xWindow.is() ) + { + // Set generic title for add-on toolbar + vos::OGuard aGuard( Application::GetSolarMutex() ); + Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); + if ( pWindow->GetText().Len() == 0 ) + pWindow->SetText( aGenericAddonTitle ); + if ( pWindow->GetType() == WINDOW_TOOLBOX ) + { + ToolBox* pToolbar = (ToolBox *)pWindow; + pToolbar->SetMenuType(); + } + } + } + } + catch ( container::NoSuchElementException& ) {} + catch ( lang::IllegalArgumentException& ) {} + } +} + +void ToolbarLayoutManager::implts_createCustomToolBars() +{ + ReadGuard aReadLock( m_aLock ); + if ( !m_bComponentAttached ) + return; + + uno::Reference< ui::XUIElementFactory > xUIElementFactory( m_xUIElementFactoryManager ); + uno::Reference< frame::XFrame > xFrame( m_xFrame ); + uno::Reference< frame::XModel > xModel; + uno::Reference< ui::XUIConfigurationManager > xModuleCfgMgr( m_xModuleCfgMgr, uno::UNO_QUERY ); + uno::Reference< ui::XUIConfigurationManager > xDocCfgMgr( m_xDocCfgMgr, uno::UNO_QUERY ); + aReadLock.unlock(); + + if ( xFrame.is() ) + { + xModel = impl_getModelFromFrame( xFrame ); + if ( implts_isPreviewModel( xModel )) + return; // no custom toolbars for preview frame! + + uno::Sequence< uno::Sequence< beans::PropertyValue > > aTbxSeq; + if ( xDocCfgMgr.is() ) + { + aTbxSeq = xDocCfgMgr->getUIElementsInfo( ui::UIElementType::TOOLBAR ); + implts_createCustomToolBars( aTbxSeq ); // first create all document based toolbars + } + if ( xModuleCfgMgr.is() ) + { + aTbxSeq = xModuleCfgMgr->getUIElementsInfo( ui::UIElementType::TOOLBAR ); + implts_createCustomToolBars( aTbxSeq ); // second create module based toolbars + } + } +} + +void ToolbarLayoutManager::implts_createNonContextSensitiveToolBars() +{ + ReadGuard aReadLock( m_aLock ); + + if ( !m_xPersistentWindowState.is() || !m_xFrame.is() || !m_bComponentAttached ) + return; + + uno::Reference< frame::XFrame > xFrame( m_xFrame ); + uno::Reference< ui::XUIElementFactory > xUIElementFactory( m_xUIElementFactoryManager ); + uno::Reference< container::XNameAccess > xPersistentWindowState( m_xPersistentWindowState ); + aReadLock.unlock(); + + if ( implts_isPreviewModel( impl_getModelFromFrame( xFrame ))) + return; + + std::vector< rtl::OUString > aMakeVisibleToolbars; + + try + { + uno::Sequence< ::rtl::OUString > aToolbarNames = xPersistentWindowState->getElementNames(); + + if ( aToolbarNames.getLength() > 0 ) + { + ::rtl::OUString aElementType; + ::rtl::OUString aElementName; + ::rtl::OUString aName; + + uno::Reference< ui::XUIElement > xUIElement; + aMakeVisibleToolbars.reserve(aToolbarNames.getLength()); + + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + WriteGuard aWriteLock( m_aLock ); + + const rtl::OUString* pTbNames = aToolbarNames.getConstArray(); + for ( sal_Int32 i = 0; i < aToolbarNames.getLength(); i++ ) + { + aName = pTbNames[i]; + parseResourceURL( aName, aElementType, aElementName ); + + // Check that we only create: + // - Toolbars (the statusbar is also member of the persistent window state) + // - Not custom toolbars, there are created with their own method (implts_createCustomToolbars) + if ( aElementType.equalsIgnoreAsciiCaseAscii( "toolbar" ) && aElementName.indexOf( m_aCustomTbxPrefix ) == -1 ) + { + UIElement aNewToolbar = implts_findToolbar( aName ); + bool bFound = ( aNewToolbar.m_aName == aName ); + if ( !bFound ) + implts_readWindowStateData( aName, aNewToolbar ); + + if ( aNewToolbar.m_bVisible && !aNewToolbar.m_bContextSensitive ) + { + if ( !bFound ) + implts_insertToolbar( aNewToolbar ); + aMakeVisibleToolbars.push_back( aName ); + } + } + } + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + } + } + catch ( uno::RuntimeException& ) { throw; } + catch ( uno::Exception& ) {} + + if ( !aMakeVisibleToolbars.empty() ) + ::std::for_each( aMakeVisibleToolbars.begin(), aMakeVisibleToolbars.end(),::boost::bind( &ToolbarLayoutManager::requestToolbar, this,_1 )); +} + +void ToolbarLayoutManager::implts_createCustomToolBars( const uno::Sequence< uno::Sequence< beans::PropertyValue > >& aTbxSeqSeq ) +{ + const uno::Sequence< beans::PropertyValue >* pTbxSeq = aTbxSeqSeq.getConstArray(); + for ( sal_Int32 i = 0; i < aTbxSeqSeq.getLength(); i++ ) + { + const uno::Sequence< beans::PropertyValue >& rTbxSeq = pTbxSeq[i]; + ::rtl::OUString aTbxResName; + ::rtl::OUString aTbxTitle; + for ( sal_Int32 j = 0; j < rTbxSeq.getLength(); j++ ) + { + if ( rTbxSeq[j].Name.equalsAscii( "ResourceURL" )) + rTbxSeq[j].Value >>= aTbxResName; + else if ( rTbxSeq[j].Name.equalsAscii( "UIName" )) + rTbxSeq[j].Value >>= aTbxTitle; + } + + // Only create custom toolbars. Their name have to start with "custom_"! + if ( aTbxResName.getLength() > 0 && aTbxResName.indexOf( m_aCustomTbxPrefix ) != -1 ) + implts_createCustomToolBar( aTbxResName, aTbxTitle ); + } +} + +void ToolbarLayoutManager::implts_createCustomToolBar( const rtl::OUString& aTbxResName, const rtl::OUString& aTitle ) +{ + if ( aTbxResName.getLength() > 0 ) + { + bool bNotify( false ); + uno::Reference< ui::XUIElement > xUIElement; + implts_createToolBar( aTbxResName, bNotify, xUIElement ); + + if ( aTitle && xUIElement.is() ) + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + + Window* pWindow = getWindowFromXUIElement( xUIElement ); + if ( pWindow ) + pWindow->SetText( aTitle ); + } + } +} + +void ToolbarLayoutManager::implts_reparentToolbars() +{ + WriteGuard aWriteLock( m_aLock ); + UIElementVector aUIElementVector = m_aUIElements; + Window* pContainerWindow = VCLUnoHelper::GetWindow( m_xContainerWindow ); + Window* pTopDockWindow = VCLUnoHelper::GetWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_TOP] ); + Window* pBottomDockWindow = VCLUnoHelper::GetWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_BOTTOM] ); + Window* pLeftDockWindow = VCLUnoHelper::GetWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_LEFT] ); + Window* pRightDockWindow = VCLUnoHelper::GetWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_RIGHT] ); + aWriteLock.unlock(); + + vos::OGuard aGuard( Application::GetSolarMutex() ); + if ( pContainerWindow ) + { + UIElementVector::iterator pIter; + for ( pIter = aUIElementVector.begin(); pIter != aUIElementVector.end(); pIter++ ) + { + uno::Reference< ui::XUIElement > xUIElement( pIter->m_xUIElement ); + if ( xUIElement.is() ) + { + uno::Reference< awt::XWindow > xWindow; + try + { + // We have to retreive the window reference with try/catch as it is + // possible that all elements have been disposed! + xWindow = uno::Reference< awt::XWindow >( xUIElement->getRealInterface(), uno::UNO_QUERY ); + } + catch ( uno::RuntimeException& ) { throw; } + catch ( uno::Exception& ) {} + + Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); + if ( pWindow ) + { + // Reparent our child windows acording to their current state. + if ( pIter->m_bFloating ) + pWindow->SetParent( pContainerWindow ); + else + { + if ( pIter->m_aDockedData.m_nDockedArea == ui::DockingArea_DOCKINGAREA_TOP ) + pWindow->SetParent( pTopDockWindow ); + else if ( pIter->m_aDockedData.m_nDockedArea == ui::DockingArea_DOCKINGAREA_BOTTOM ) + pWindow->SetParent( pBottomDockWindow ); + else if ( pIter->m_aDockedData.m_nDockedArea == ui::DockingArea_DOCKINGAREA_LEFT ) + pWindow->SetParent( pLeftDockWindow ); + else + pWindow->SetParent( pRightDockWindow ); + } + } + } + } + } +} + +void ToolbarLayoutManager::implts_setToolbarCreation( bool bStart ) +{ + WriteGuard aWriteLock( m_aLock ); + m_bToolbarCreation = bStart; +} + +bool ToolbarLayoutManager::implts_isToolbarCreationActive() +{ + ReadGuard aReadLock( m_aLock ); + return m_bToolbarCreation; +} + +void ToolbarLayoutManager::implts_createToolBar( const ::rtl::OUString& aName, bool& bNotify, uno::Reference< ui::XUIElement >& rUIElement ) +{ + ReadGuard aReadLock( m_aLock ); + uno::Reference< frame::XFrame > xFrame( m_xFrame ); + uno::Reference< awt::XWindow2 > xContainerWindow( m_xContainerWindow ); + aReadLock.unlock(); + + bNotify = false; + + if ( !xFrame.is() || !xContainerWindow.is() ) + return; + + UIElement aToolbarElement = implts_findToolbar( aName ); + if ( !aToolbarElement.m_xUIElement.is() ) + { + uno::Reference< ui::XUIElement > xUIElement = implts_createElement( aName ); + + bool bVisible( false ); + bool bFloating( false ); + if ( xUIElement.is() ) + { + rUIElement = xUIElement; + + uno::Reference< awt::XWindow > xWindow( xUIElement->getRealInterface(), uno::UNO_QUERY ); + uno::Reference< awt::XDockableWindow > xDockWindow( xWindow, uno::UNO_QUERY ); + if ( xDockWindow.is() && xWindow.is() ) + { + try + { + xDockWindow->addDockableWindowListener( uno::Reference< awt::XDockableWindowListener >( + static_cast< OWeakObject * >( this ), uno::UNO_QUERY )); + xWindow->addWindowListener( uno::Reference< awt::XWindowListener >( + static_cast< OWeakObject * >( this ), uno::UNO_QUERY )); + xDockWindow->enableDocking( sal_True ); + } + catch ( uno::Exception& ) {} + } + + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + WriteGuard aWriteLock( m_aLock ); + + UIElement& rElement = impl_findToolbar( aName ); + if ( rElement.m_aName.getLength() > 0 ) + { + // Reuse a local entry so we are able to use the latest + // UI changes for this document. + implts_setElementData( rElement, xDockWindow ); + rElement.m_xUIElement = xUIElement; + bVisible = rElement.m_bVisible; + bFloating = rElement.m_bFloating; + } + else + { + // Create new UI element and try to read its state data + UIElement aNewToolbar( aName, m_aToolbarTypeString, xUIElement ); + implts_readWindowStateData( aName, aNewToolbar ); + implts_setElementData( aNewToolbar, xDockWindow ); + implts_insertToolbar( aNewToolbar ); + bVisible = aNewToolbar.m_bVisible; + bFloating = rElement.m_bFloating; + } + aWriteLock.unlock(); + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + + // set toolbar menu style according to customize command state + SvtCommandOptions aCmdOptions; + + vos::OGuard aGuard( Application::GetSolarMutex() ); + Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); + if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX ) + { + ToolBox* pToolbar = (ToolBox *)pWindow; + USHORT nMenuType = pToolbar->GetMenuType(); + if ( aCmdOptions.Lookup( SvtCommandOptions::CMDOPTION_DISABLED, m_aCustomizeCmd )) + pToolbar->SetMenuType( nMenuType & ~TOOLBOX_MENUTYPE_CUSTOMIZE ); + else + pToolbar->SetMenuType( nMenuType | TOOLBOX_MENUTYPE_CUSTOMIZE ); + } + bNotify = true; + + implts_sortUIElements(); + + if ( bVisible && !bFloating ) + implts_setLayoutDirty(); + } + } +} + +uno::Reference< ui::XUIElement > ToolbarLayoutManager::implts_createElement( const ::rtl::OUString& aName ) +{ + uno::Reference< ui::XUIElement > xUIElement; + + ReadGuard aReadLock( m_aLock ); + uno::Sequence< beans::PropertyValue > aPropSeq( 2 ); + aPropSeq[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Frame" )); + aPropSeq[0].Value <<= m_xFrame; + aPropSeq[1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Persistent" )); + aPropSeq[1].Value <<= true; + uno::Reference< ui::XUIElementFactory > xUIElementFactory( m_xUIElementFactoryManager ); + aReadLock.unlock(); + + implts_setToolbarCreation( true ); + try + { + if ( xUIElementFactory.is() ) + xUIElement = xUIElementFactory->createUIElement( aName, aPropSeq ); + } + catch ( container::NoSuchElementException& ) {} + catch ( lang::IllegalArgumentException& ) {} + implts_setToolbarCreation( false ); + + return xUIElement; +} + +void ToolbarLayoutManager::implts_setElementData( UIElement& rElement, const uno::Reference< awt::XDockableWindow >& rDockWindow ) +{ + ReadGuard aReadLock( m_aLock ); + bool bShowElement( rElement.m_bVisible && !rElement.m_bMasterHide && implts_isParentWindowVisible() ); + aReadLock.unlock(); + + uno::Reference< awt::XDockableWindow > xDockWindow( rDockWindow ); + uno::Reference< awt::XWindow2 > xWindow( xDockWindow, uno::UNO_QUERY ); + + Window* pWindow( 0 ); + ToolBox* pToolBox( 0 ); + + if ( xDockWindow.is() && xWindow.is() ) + { + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + pWindow = VCLUnoHelper::GetWindow( xWindow ); + if ( pWindow ) + { + String aText = pWindow->GetText(); + if ( aText.Len() == 0 ) + pWindow->SetText( rElement.m_aUIName ); + if ( rElement.m_bNoClose ) + pWindow->SetStyle( pWindow->GetStyle() & ~WB_CLOSEABLE ); + if ( pWindow->GetType() == WINDOW_TOOLBOX ) + pToolBox = (ToolBox *)pWindow; + } + if ( pToolBox ) + { + if (( rElement.m_nStyle < 0 ) || ( rElement.m_nStyle > BUTTON_SYMBOLTEXT )) + rElement.m_nStyle = BUTTON_SYMBOL; + pToolBox->SetButtonType( (ButtonType)rElement.m_nStyle ); + if ( rElement.m_bNoClose ) + pToolBox->SetFloatStyle( pToolBox->GetFloatStyle() & ~WB_CLOSEABLE ); + } + } + + if ( rElement.m_bFloating ) + { + if ( pWindow ) + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + String aText = pWindow->GetText(); + if ( aText.Len() == 0 ) + pWindow->SetText( rElement.m_aUIName ); + } + + ::Point aPos( rElement.m_aFloatingData.m_aPos.X(), + rElement.m_aFloatingData.m_aPos.Y() ); + bool bWriteData( false ); + bool bUndefPos = hasDefaultPosValue( rElement.m_aFloatingData.m_aPos ); + bool bSetSize = ( rElement.m_aFloatingData.m_aSize.Width() != 0 && + rElement.m_aFloatingData.m_aSize.Height() != 0 ); + xDockWindow->setFloatingMode( sal_True ); + if ( bUndefPos ) + { + aPos = implts_findNextCascadeFloatingPos(); + rElement.m_aFloatingData.m_aPos = aPos; // set new cascaded position + bWriteData = true; + } + + if( bSetSize ) + xWindow->setOutputSize( AWTSize( rElement.m_aFloatingData.m_aSize ) ); + else + { + if( pToolBox ) + { + // set an optimal initial floating size + vos::OGuard aGuard( Application::GetSolarMutex() ); + ::Size aSize( pToolBox->CalcFloatingWindowSizePixel() ); + pToolBox->SetOutputSizePixel( aSize ); + } + } + + // #i60882# IMPORTANT: Set position after size as it is + // possible that we position some part of the toolbar + // outside of the desktop. A default constructed toolbar + // always has one line. Now VCL automatically + // position the toolbar back into the desktop. Therefore + // we resize the toolbar with the new (wrong) position. + // To fix this problem we have to set the size BEFORE the + // position. + xWindow->setPosSize( aPos.X(), aPos.Y(), 0, 0, awt::PosSize::POS ); + + if ( bWriteData ) + implts_writeWindowStateData( rElement ); + if ( bShowElement && pWindow ) + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + pWindow->Show( sal_True, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE ); + } + } + else + { + bool bSetSize( false ); + ::Point aDockPos; + ::Point aPixelPos; + ::Size aSize; + + if ( pToolBox ) + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + pToolBox->SetAlign( ImplConvertAlignment(rElement.m_aDockedData.m_nDockedArea ) ); + pToolBox->SetLineCount( 1 ); + xDockWindow->setFloatingMode( sal_False ); + if ( rElement.m_aDockedData.m_bLocked ) + xDockWindow->lock(); + aSize = pToolBox->CalcWindowSizePixel(); + bSetSize = true; + + if ( isDefaultPos( rElement.m_aDockedData.m_aPos )) + { + implts_findNextDockingPos( (ui::DockingArea)rElement.m_aDockedData.m_nDockedArea, aSize, aDockPos, aPixelPos ); + rElement.m_aDockedData.m_aPos = aDockPos; + } + } + + xWindow->setPosSize( aPixelPos.X(), aPixelPos.Y(), 0, 0, awt::PosSize::POS ); + if( bSetSize ) + xWindow->setOutputSize( AWTSize( aSize) ); + + if ( pWindow ) + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + if ( !bShowElement ) + pWindow->Hide(); + } + } + } +} + +void ToolbarLayoutManager::implts_destroyDockingAreaWindows() +{ + WriteGuard aWriteLock( m_aLock ); + uno::Reference< awt::XWindow > xTopDockingWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_TOP] ); + uno::Reference< awt::XWindow > xLeftDockingWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_LEFT] ); + uno::Reference< awt::XWindow > xRightDockingWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_RIGHT] ); + uno::Reference< awt::XWindow > xBottomDockingWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_BOTTOM] ); + m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_TOP].clear(); + m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_LEFT].clear(); + m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_RIGHT].clear(); + m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_BOTTOM].clear(); + aWriteLock.unlock(); + + // destroy windows + xTopDockingWindow->dispose(); + xLeftDockingWindow->dispose(); + xRightDockingWindow->dispose(); + xBottomDockingWindow->dispose(); +} + +//--------------------------------------------------------------------------------------------------------- +// persistence methods +//--------------------------------------------------------------------------------------------------------- + +sal_Bool ToolbarLayoutManager::implts_readWindowStateData( const rtl::OUString& aName, UIElement& rElementData ) +{ + WriteGuard aWriteLock( m_aLock ); + uno::Reference< container::XNameAccess > xPersistentWindowState( m_xPersistentWindowState ); + bool bGetSettingsState( false ); + aWriteLock.unlock(); + + if ( xPersistentWindowState.is() ) + { + aWriteLock.lock(); + bool bGlobalSettings( m_bGlobalSettings ); + GlobalSettings* pGlobalSettings( 0 ); + if ( m_pGlobalSettings == 0 ) + { + m_pGlobalSettings = new GlobalSettings( m_xSMGR ); + bGetSettingsState = true; + } + pGlobalSettings = m_pGlobalSettings; + aWriteLock.unlock(); + + try + { + uno::Sequence< beans::PropertyValue > aWindowState; + if ( xPersistentWindowState->getByName( aName ) >>= aWindowState ) + { + sal_Bool bValue( sal_False ); + for ( sal_Int32 n = 0; n < aWindowState.getLength(); n++ ) + { + if ( aWindowState[n].Name.equalsAscii( WINDOWSTATE_PROPERTY_DOCKED )) + { + if ( aWindowState[n].Value >>= bValue ) + rElementData.m_bFloating = !bValue; + } + else if ( aWindowState[n].Name.equalsAscii( WINDOWSTATE_PROPERTY_VISIBLE )) + { + if ( aWindowState[n].Value >>= bValue ) + rElementData.m_bVisible = bValue; + } + else if ( aWindowState[n].Name.equalsAscii( WINDOWSTATE_PROPERTY_DOCKINGAREA )) + { + ui::DockingArea eDockingArea; + if ( aWindowState[n].Value >>= eDockingArea ) + rElementData.m_aDockedData.m_nDockedArea = sal_Int16( eDockingArea ); + } + else if ( aWindowState[n].Name.equalsAscii( WINDOWSTATE_PROPERTY_DOCKPOS )) + { + awt::Point aPoint; + if ( aWindowState[n].Value >>= aPoint ) + { + rElementData.m_aDockedData.m_aPos.X() = aPoint.X; + rElementData.m_aDockedData.m_aPos.Y() = aPoint.Y; + } + } + else if ( aWindowState[n].Name.equalsAscii( WINDOWSTATE_PROPERTY_POS )) + { + awt::Point aPoint; + if ( aWindowState[n].Value >>= aPoint ) + { + rElementData.m_aFloatingData.m_aPos.X() = aPoint.X; + rElementData.m_aFloatingData.m_aPos.Y() = aPoint.Y; + } + } + else if ( aWindowState[n].Name.equalsAscii( WINDOWSTATE_PROPERTY_SIZE )) + { + awt::Size aSize; + if ( aWindowState[n].Value >>= aSize ) + { + rElementData.m_aFloatingData.m_aSize.Width() = aSize.Width; + rElementData.m_aFloatingData.m_aSize.Height() = aSize.Height; + } + } + else if ( aWindowState[n].Name.equalsAscii( WINDOWSTATE_PROPERTY_UINAME )) + aWindowState[n].Value >>= rElementData.m_aUIName; + else if ( aWindowState[n].Name.equalsAscii( WINDOWSTATE_PROPERTY_STYLE )) + { + sal_Int32 nStyle = 0; + if ( aWindowState[n].Value >>= nStyle ) + rElementData.m_nStyle = sal_Int16( nStyle ); + } + else if ( aWindowState[n].Name.equalsAscii( WINDOWSTATE_PROPERTY_LOCKED )) + { + if ( aWindowState[n].Value >>= bValue ) + rElementData.m_aDockedData.m_bLocked = bValue; + } + else if ( aWindowState[n].Name.equalsAscii( WINDOWSTATE_PROPERTY_CONTEXT )) + { + if ( aWindowState[n].Value >>= bValue ) + rElementData.m_bContextSensitive = bValue; + } + else if ( aWindowState[n].Name.equalsAscii( WINDOWSTATE_PROPERTY_NOCLOSE )) + { + if ( aWindowState[n].Value >>= bValue ) + rElementData.m_bNoClose = bValue; + } + else if ( aWindowState[n].Name.equalsAscii( WINDOWSTATE_PROPERTY_CONTEXTACTIVE )) + { + if ( aWindowState[n].Value >>= bValue ) + rElementData.m_bContextActive = bValue; + } + else if ( aWindowState[n].Name.equalsAscii( WINDOWSTATE_PROPERTY_SOFTCLOSE )) + { + if ( aWindowState[n].Value >>= bValue ) + rElementData.m_bSoftClose = bValue; + } + } + } + + // oversteer values with global settings + if ( pGlobalSettings && ( bGetSettingsState || bGlobalSettings )) + { + if ( pGlobalSettings->HasStatesInfo( GlobalSettings::UIELEMENT_TYPE_TOOLBAR )) + { + WriteGuard aWriteLock2( m_aLock ); + m_bGlobalSettings = true; + aWriteLock2.unlock(); + + uno::Any aValue; + sal_Bool bValue = sal_Bool(); + if ( pGlobalSettings->GetStateInfo( GlobalSettings::UIELEMENT_TYPE_TOOLBAR, + GlobalSettings::STATEINFO_LOCKED, + aValue )) + aValue >>= rElementData.m_aDockedData.m_bLocked; + if ( pGlobalSettings->GetStateInfo( GlobalSettings::UIELEMENT_TYPE_TOOLBAR, + GlobalSettings::STATEINFO_DOCKED, + aValue )) + { + if ( aValue >>= bValue ) + rElementData.m_bFloating = !bValue; + } + } + } + + return sal_True; + } + catch ( container::NoSuchElementException& ) {} + } + + return sal_False; +} + +void ToolbarLayoutManager::implts_writeWindowStateData( const UIElement& rElementData ) +{ + WriteGuard aWriteLock( m_aLock ); + uno::Reference< container::XNameAccess > xPersistentWindowState( m_xPersistentWindowState ); + m_bStoreWindowState = true; // set flag to determine that we triggered the notification + aWriteLock.unlock(); + + bool bPersistent( sal_False ); + uno::Reference< beans::XPropertySet > xPropSet( rElementData.m_xUIElement, uno::UNO_QUERY ); + if ( xPropSet.is() ) + { + try + { + // Check persistent flag of the user interface element + xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Persistent" ))) >>= bPersistent; + } + catch ( beans::UnknownPropertyException ) + { + bPersistent = true; // Non-configurable elements should at least store their dimension/position + } + catch ( lang::WrappedTargetException ) {} + } + + if ( bPersistent && xPersistentWindowState.is() ) + { + try + { + uno::Sequence< beans::PropertyValue > aWindowState( 8 ); + + aWindowState[0].Name = ::rtl::OUString::createFromAscii( WINDOWSTATE_PROPERTY_DOCKED ); + aWindowState[0].Value = ::uno::makeAny( sal_Bool( !rElementData.m_bFloating )); + aWindowState[1].Name = ::rtl::OUString::createFromAscii( WINDOWSTATE_PROPERTY_VISIBLE ); + aWindowState[1].Value = uno::makeAny( sal_Bool( rElementData.m_bVisible )); + aWindowState[2].Name = ::rtl::OUString::createFromAscii( WINDOWSTATE_PROPERTY_DOCKINGAREA ); + aWindowState[2].Value = uno::makeAny( static_cast< ui::DockingArea >( rElementData.m_aDockedData.m_nDockedArea ) ); + + awt::Point aPos; + aPos.X = rElementData.m_aDockedData.m_aPos.X(); + aPos.Y = rElementData.m_aDockedData.m_aPos.Y(); + aWindowState[3].Name = ::rtl::OUString::createFromAscii( WINDOWSTATE_PROPERTY_DOCKPOS ); + aWindowState[3].Value <<= aPos; + + aPos.X = rElementData.m_aFloatingData.m_aPos.X(); + aPos.Y = rElementData.m_aFloatingData.m_aPos.Y(); + aWindowState[4].Name = ::rtl::OUString::createFromAscii( WINDOWSTATE_PROPERTY_POS ); + aWindowState[4].Value <<= aPos; + + awt::Size aSize; + aSize.Width = rElementData.m_aFloatingData.m_aSize.Width(); + aSize.Height = rElementData.m_aFloatingData.m_aSize.Height(); + aWindowState[5].Name = ::rtl::OUString::createFromAscii( WINDOWSTATE_PROPERTY_SIZE ); + aWindowState[5].Value <<= aSize; + aWindowState[6].Name = ::rtl::OUString::createFromAscii( WINDOWSTATE_PROPERTY_UINAME ); + aWindowState[6].Value = uno::makeAny( rElementData.m_aUIName ); + aWindowState[7].Name = ::rtl::OUString::createFromAscii( WINDOWSTATE_PROPERTY_LOCKED ); + aWindowState[7].Value = uno::makeAny( rElementData.m_aDockedData.m_bLocked ); + + ::rtl::OUString aName = rElementData.m_aName; + if ( xPersistentWindowState->hasByName( aName )) + { + uno::Reference< container::XNameReplace > xReplace( xPersistentWindowState, uno::UNO_QUERY ); + xReplace->replaceByName( aName, uno::makeAny( aWindowState )); + } + else + { + uno::Reference< container::XNameContainer > xInsert( xPersistentWindowState, uno::UNO_QUERY ); + xInsert->insertByName( aName, uno::makeAny( aWindowState )); + } + } + catch ( uno::Exception& ) {} + } + + // Reset flag + aWriteLock.lock(); + m_bStoreWindowState = false; + aWriteLock.unlock(); +} + +void ToolbarLayoutManager::implts_writeNewWindowStateData( const rtl::OUString aName, const uno::Reference< awt::XWindow >& xWindow ) +{ + bool bVisible( false ); + bool bFloating( true ); + awt::Rectangle aPos; + awt::Size aSize; + + if ( xWindow.is() ) + { + uno::Reference< awt::XDockableWindow > xDockWindow( xWindow, uno::UNO_QUERY ); + if ( xDockWindow.is() ) + bFloating = xDockWindow->isFloating(); + + uno::Reference< awt::XWindow2 > xWindow2( xWindow, uno::UNO_QUERY ); + if( xWindow2.is() ) + { + aPos = xWindow2->getPosSize(); + aSize = xWindow2->getOutputSize(); // always use output size for consistency + bVisible = xWindow2->isVisible(); + } + + WriteGuard aWriteLock( m_aLock ); + UIElement& rUIElement = impl_findToolbar( aName ); + if ( rUIElement.m_xUIElement.is() ) + { + rUIElement.m_bVisible = bVisible; + rUIElement.m_bFloating = bFloating; + if ( bFloating ) + { + rUIElement.m_aFloatingData.m_aPos = ::Point( aPos.X, aPos.Y ); + rUIElement.m_aFloatingData.m_aSize = ::Size( aSize.Width, aSize.Height ); + } + } + implts_writeWindowStateData( rUIElement ); + aWriteLock.unlock(); + } +} + +/****************************************************************************** + LOOKUP PART FOR TOOLBARS +******************************************************************************/ + +UIElement& ToolbarLayoutManager::impl_findToolbar( const rtl::OUString& aName ) +{ + static UIElement aEmptyElement; + UIElementVector::iterator pIter; + + ReadGuard aReadLock( m_aLock ); + for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) + { + if ( pIter->m_aName == aName ) + return *pIter; + } + + return aEmptyElement; +} + +UIElement ToolbarLayoutManager::implts_findToolbar( const rtl::OUString& aName ) +{ + ReadGuard aReadLock( m_aLock ); + UIElement aElement = impl_findToolbar( aName ); + aReadLock.unlock(); + + return aElement; +} + +UIElement ToolbarLayoutManager::implts_findToolbar( const uno::Reference< uno::XInterface >& xToolbar ) +{ + UIElement aToolbar; + UIElementVector::const_iterator pIter; + + ReadGuard aReadLock( m_aLock ); + for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) + { + if ( pIter->m_xUIElement.is() ) + { + uno::Reference< uno::XInterface > xIfac( pIter->m_xUIElement->getRealInterface(), uno::UNO_QUERY ); + if ( xIfac == xToolbar ) + { + aToolbar = *pIter; + break; + } + } + } + + return aToolbar; +} + +uno::Reference< awt::XWindow > ToolbarLayoutManager::implts_getXWindow( const ::rtl::OUString& aName ) +{ + UIElementVector::iterator pIter; + uno::Reference< awt::XWindow > xWindow; + + ReadGuard aReadLock( m_aLock ); + for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) + { + if ( pIter->m_aName == aName && pIter->m_xUIElement.is() ) + { + xWindow = uno::Reference< awt::XWindow >( pIter->m_xUIElement->getRealInterface(), uno::UNO_QUERY ); + break; + } + } + + return xWindow; +} + +Window* ToolbarLayoutManager::implts_getWindow( const ::rtl::OUString& aName ) +{ + uno::Reference< awt::XWindow > xWindow = implts_getXWindow( aName ); + Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); + + return pWindow; +} + +bool ToolbarLayoutManager::implts_insertToolbar( const UIElement& rUIElement ) +{ + UIElement aTempData; + bool bFound( false ); + bool bResult( false ); + + aTempData = implts_findToolbar( rUIElement.m_aName ); + if ( aTempData.m_aName == rUIElement.m_aName ) + bFound = true; + + if ( !bFound ) + { + WriteGuard aWriteLock( m_aLock ); + m_aUIElements.push_back( rUIElement ); + bResult = true; + } + + return bResult; +} + +void ToolbarLayoutManager::implts_setToolbar( const UIElement& rUIElement ) +{ + WriteGuard aWriteLock( m_aLock ); + UIElement& rData = impl_findToolbar( rUIElement.m_aName ); + if ( rData.m_aName == rUIElement.m_aName ) + rData = rUIElement; + else + m_aUIElements.push_back( rUIElement ); +} + +/****************************************************************************** + LAYOUT CODE PART FOR TOOLBARS +******************************************************************************/ + +::Point ToolbarLayoutManager::implts_findNextCascadeFloatingPos() +{ + const sal_Int32 nHotZoneX = 50; + const sal_Int32 nHotZoneY = 50; + const sal_Int32 nCascadeIndentX = 15; + const sal_Int32 nCascadeIndentY = 15; + + ReadGuard aReadLock( m_aLock ); + uno::Reference< awt::XWindow2 > xContainerWindow( m_xContainerWindow ); + uno::Reference< awt::XWindow > xTopDockingWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_TOP] ); + uno::Reference< awt::XWindow > xLeftDockingWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_LEFT] ); + aReadLock.unlock(); + + ::Point aStartPos( nCascadeIndentX, nCascadeIndentY ); + ::Point aCurrPos( aStartPos ); + awt::Rectangle aRect; + + Window* pContainerWindow( 0 ); + if ( xContainerWindow.is() ) + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + pContainerWindow = VCLUnoHelper::GetWindow( xContainerWindow ); + if ( pContainerWindow ) + aStartPos = pContainerWindow->OutputToScreenPixel( aStartPos ); + } + + // Determine size of top and left docking area + awt::Rectangle aTopRect( xTopDockingWindow->getPosSize() ); + awt::Rectangle aLeftRect( xLeftDockingWindow->getPosSize() ); + + aStartPos.X() += aLeftRect.Width + nCascadeIndentX; + aStartPos.Y() += aTopRect.Height + nCascadeIndentY; + aCurrPos = aStartPos; + + // Try to find a cascaded position for the new floating window + UIElementVector::const_iterator pIter; + for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) + { + if ( pIter->m_xUIElement.is() ) + { + uno::Reference< awt::XDockableWindow > xDockWindow( pIter->m_xUIElement->getRealInterface(), uno::UNO_QUERY ); + uno::Reference< awt::XWindow > xWindow( xDockWindow, uno::UNO_QUERY ); + if ( xDockWindow.is() && xDockWindow->isFloating() ) + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); + if ( pWindow && pWindow->IsVisible() ) + { + awt::Rectangle aFloatRect = xWindow->getPosSize(); + if ((( aFloatRect.X - nHotZoneX ) <= aCurrPos.X() ) && + ( aFloatRect.X >= aCurrPos.X() ) && + (( aFloatRect.Y - nHotZoneY ) <= aCurrPos.Y() ) && + ( aFloatRect.Y >= aCurrPos.Y() )) + { + aCurrPos.X() = aFloatRect.X + nCascadeIndentX; + aCurrPos.Y() = aFloatRect.Y + nCascadeIndentY; + } + } + } + } + } + + return aCurrPos; +} + +void ToolbarLayoutManager::implts_sortUIElements() +{ + WriteGuard aWriteLock( m_aLock ); + UIElementVector::iterator pIterStart = m_aUIElements.begin(); + UIElementVector::iterator pIterEnd = m_aUIElements.end(); + + std::stable_sort( pIterStart, pIterEnd ); // first created element should first + + // We have to reset our temporary flags. + UIElementVector::iterator pIter; + for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) + pIter->m_bUserActive = sal_False; + aWriteLock.unlock(); +} + +void ToolbarLayoutManager::implts_getUIElementVectorCopy( UIElementVector& rCopy ) +{ + ReadGuard aReadLock( m_aLock ); + rCopy = m_aUIElements; +} + +::Size ToolbarLayoutManager::implts_getTopBottomDockingAreaSizes() +{ + ::Size aSize; + uno::Reference< awt::XWindow > xTopDockingAreaWindow; + uno::Reference< awt::XWindow > xBottomDockingAreaWindow; + + ReadGuard aReadLock( m_aLock ); + xTopDockingAreaWindow = m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_TOP]; + xBottomDockingAreaWindow = m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_BOTTOM]; + aReadLock.unlock(); + + if ( xTopDockingAreaWindow.is() ) + aSize.Width() = xTopDockingAreaWindow->getPosSize().Height; + if ( xBottomDockingAreaWindow.is() ) + aSize.Height() = xBottomDockingAreaWindow->getPosSize().Height; + + return aSize; +} + +void ToolbarLayoutManager::implts_getDockingAreaElementInfos( ui::DockingArea eDockingArea, std::vector< SingleRowColumnWindowData >& rRowColumnsWindowData ) +{ + std::vector< UIElement > aWindowVector; + + if (( eDockingArea < ui::DockingArea_DOCKINGAREA_TOP ) || ( eDockingArea > ui::DockingArea_DOCKINGAREA_RIGHT )) + eDockingArea = ui::DockingArea_DOCKINGAREA_TOP; + + uno::Reference< awt::XWindow > xDockAreaWindow; + + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + ReadGuard aReadLock( m_aLock ); + aWindowVector.reserve(m_aUIElements.size()); + xDockAreaWindow = m_xDockAreaWindows[eDockingArea]; + UIElementVector::iterator pIter; + for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) + { + if ( pIter->m_aDockedData.m_nDockedArea == eDockingArea && pIter->m_bVisible && !pIter->m_bFloating ) + { + uno::Reference< ui::XUIElement > xUIElement( pIter->m_xUIElement ); + if ( xUIElement.is() ) + { + uno::Reference< awt::XWindow > xWindow( xUIElement->getRealInterface(), uno::UNO_QUERY ); + uno::Reference< awt::XDockableWindow > xDockWindow( xWindow, uno::UNO_QUERY ); + if ( xDockWindow.is() ) + { + // docked windows + aWindowVector.push_back( *pIter ); + } + } + } + } + aReadLock.unlock(); + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + + rRowColumnsWindowData.clear(); + + // Collect data from windows that are on the same row/column + sal_Int32 j; + sal_Int32 nIndex( 0 ); + sal_Int32 nLastPos( 0 ); + sal_Int32 nCurrPos( -1 ); + sal_Int32 nLastRowColPixelPos( 0 ); + awt::Rectangle aDockAreaRect; + + if ( xDockAreaWindow.is() ) + aDockAreaRect = xDockAreaWindow->getPosSize(); + + if ( eDockingArea == ui::DockingArea_DOCKINGAREA_TOP ) + nLastRowColPixelPos = 0; + else if ( eDockingArea == ui::DockingArea_DOCKINGAREA_BOTTOM ) + nLastRowColPixelPos = aDockAreaRect.Height; + else if ( eDockingArea == ui::DockingArea_DOCKINGAREA_LEFT ) + nLastRowColPixelPos = 0; + else + nLastRowColPixelPos = aDockAreaRect.Width; + + const sal_uInt32 nCount = aWindowVector.size(); + for ( j = 0; j < sal_Int32( nCount); j++ ) + { + const UIElement& rElement = aWindowVector[j]; + uno::Reference< awt::XWindow > xWindow; + uno::Reference< ui::XUIElement > xUIElement( rElement.m_xUIElement ); + awt::Rectangle aPosSize; + + if ( !lcl_checkUIElement(xUIElement,aPosSize,xWindow) ) + continue; + if ( isHorizontalDockingArea( eDockingArea )) + { + if ( nCurrPos == -1 ) + { + nCurrPos = rElement.m_aDockedData.m_aPos.Y(); + nLastPos = 0; + + SingleRowColumnWindowData aRowColumnWindowData; + aRowColumnWindowData.nRowColumn = nCurrPos; + rRowColumnsWindowData.push_back( aRowColumnWindowData ); + } + + sal_Int32 nSpace( 0 ); + if ( rElement.m_aDockedData.m_aPos.Y() != nCurrPos ) + { + if ( eDockingArea == ui::DockingArea_DOCKINGAREA_TOP ) + nLastRowColPixelPos += rRowColumnsWindowData[nIndex].nStaticSize; + else + nLastRowColPixelPos -= rRowColumnsWindowData[nIndex].nStaticSize; + ++nIndex; + nLastPos = 0; + nCurrPos = rElement.m_aDockedData.m_aPos.Y(); + SingleRowColumnWindowData aRowColumnWindowData; + aRowColumnWindowData.nRowColumn = nCurrPos; + rRowColumnsWindowData.push_back( aRowColumnWindowData ); + } + + // Calc space before an element and store it + nSpace = ( rElement.m_aDockedData.m_aPos.X() - nLastPos ); + if ( rElement.m_aDockedData.m_aPos.X() >= nLastPos ) + { + rRowColumnsWindowData[nIndex].nSpace += nSpace; + nLastPos = rElement.m_aDockedData.m_aPos.X() + aPosSize.Width; + } + else + { + nSpace = 0; + nLastPos += aPosSize.Width; + } + rRowColumnsWindowData[nIndex].aRowColumnSpace.push_back( nSpace ); + + rRowColumnsWindowData[nIndex].aRowColumnWindows.push_back( xWindow ); + rRowColumnsWindowData[nIndex].aUIElementNames.push_back( rElement.m_aName ); + rRowColumnsWindowData[nIndex].aRowColumnWindowSizes.push_back( + awt::Rectangle( rElement.m_aDockedData.m_aPos.X(), + rElement.m_aDockedData.m_aPos.Y(), + aPosSize.Width, + aPosSize.Height )); + if ( rRowColumnsWindowData[nIndex].nStaticSize < aPosSize.Height ) + rRowColumnsWindowData[nIndex].nStaticSize = aPosSize.Height; + if ( eDockingArea == ui::DockingArea_DOCKINGAREA_TOP ) + rRowColumnsWindowData[nIndex].aRowColumnRect = awt::Rectangle( 0, nLastRowColPixelPos, + aDockAreaRect.Width, aPosSize.Height ); + else + rRowColumnsWindowData[nIndex].aRowColumnRect = awt::Rectangle( 0, ( nLastRowColPixelPos - aPosSize.Height ), + aDockAreaRect.Width, aPosSize.Height ); + rRowColumnsWindowData[nIndex].nVarSize += aPosSize.Width + nSpace; + } + else + { + if ( nCurrPos == -1 ) + { + nCurrPos = rElement.m_aDockedData.m_aPos.X(); + nLastPos = 0; + + SingleRowColumnWindowData aRowColumnWindowData; + aRowColumnWindowData.nRowColumn = nCurrPos; + rRowColumnsWindowData.push_back( aRowColumnWindowData ); + } + + sal_Int32 nSpace( 0 ); + if ( rElement.m_aDockedData.m_aPos.X() != nCurrPos ) + { + if ( eDockingArea == ui::DockingArea_DOCKINGAREA_LEFT ) + nLastRowColPixelPos += rRowColumnsWindowData[nIndex].nStaticSize; + else + nLastRowColPixelPos -= rRowColumnsWindowData[nIndex].nStaticSize; + ++nIndex; + nLastPos = 0; + nCurrPos = rElement.m_aDockedData.m_aPos.X(); + SingleRowColumnWindowData aRowColumnWindowData; + aRowColumnWindowData.nRowColumn = nCurrPos; + rRowColumnsWindowData.push_back( aRowColumnWindowData ); + } + + // Calc space before an element and store it + nSpace = ( rElement.m_aDockedData.m_aPos.Y() - nLastPos ); + if ( rElement.m_aDockedData.m_aPos.Y() > nLastPos ) + { + rRowColumnsWindowData[nIndex].nSpace += nSpace; + nLastPos = rElement.m_aDockedData.m_aPos.Y() + aPosSize.Height; + } + else + { + nSpace = 0; + nLastPos += aPosSize.Height; + } + rRowColumnsWindowData[nIndex].aRowColumnSpace.push_back( nSpace ); + + rRowColumnsWindowData[nIndex].aRowColumnWindows.push_back( xWindow ); + rRowColumnsWindowData[nIndex].aUIElementNames.push_back( rElement.m_aName ); + rRowColumnsWindowData[nIndex].aRowColumnWindowSizes.push_back( + awt::Rectangle( rElement.m_aDockedData.m_aPos.X(), + rElement.m_aDockedData.m_aPos.Y(), + aPosSize.Width, + aPosSize.Height )); + if ( rRowColumnsWindowData[nIndex].nStaticSize < aPosSize.Width ) + rRowColumnsWindowData[nIndex].nStaticSize = aPosSize.Width; + if ( eDockingArea == ui::DockingArea_DOCKINGAREA_LEFT ) + rRowColumnsWindowData[nIndex].aRowColumnRect = awt::Rectangle( nLastRowColPixelPos, 0, + aPosSize.Width, aDockAreaRect.Height ); + else + rRowColumnsWindowData[nIndex].aRowColumnRect = awt::Rectangle( ( nLastRowColPixelPos - aPosSize.Width ), 0, + aPosSize.Width, aDockAreaRect.Height ); + rRowColumnsWindowData[nIndex].nVarSize += aPosSize.Height + nSpace; + } + } +} + +void ToolbarLayoutManager::implts_getDockingAreaElementInfoOnSingleRowCol( ui::DockingArea eDockingArea, sal_Int32 nRowCol, SingleRowColumnWindowData& rRowColumnWindowData ) +{ + std::vector< UIElement > aWindowVector; + + if (( eDockingArea < ui::DockingArea_DOCKINGAREA_TOP ) || ( eDockingArea > ui::DockingArea_DOCKINGAREA_RIGHT )) + eDockingArea = ui::DockingArea_DOCKINGAREA_TOP; + + bool bHorzDockArea = isHorizontalDockingArea( eDockingArea ); + + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + ReadGuard aReadLock( m_aLock ); + UIElementVector::iterator pIter; + UIElementVector::iterator pEnd = m_aUIElements.end(); + for ( pIter = m_aUIElements.begin(); pIter != pEnd; pIter++ ) + { + if ( pIter->m_aDockedData.m_nDockedArea == eDockingArea ) + { + bool bSameRowCol = bHorzDockArea ? ( pIter->m_aDockedData.m_aPos.Y() == nRowCol ) : ( pIter->m_aDockedData.m_aPos.X() == nRowCol ); + uno::Reference< ui::XUIElement > xUIElement( pIter->m_xUIElement ); + + if ( bSameRowCol && xUIElement.is() ) + { + uno::Reference< awt::XWindow > xWindow( xUIElement->getRealInterface(), uno::UNO_QUERY ); + if ( xWindow.is() ) + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); + uno::Reference< awt::XDockableWindow > xDockWindow( xWindow, uno::UNO_QUERY ); + if ( pWindow && pIter->m_bVisible && xDockWindow.is() && !pIter->m_bFloating ) + aWindowVector.push_back( *pIter ); // docked windows + } + } + } + } + aReadLock.unlock(); + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + + // Initialize structure + rRowColumnWindowData.aUIElementNames.clear(); + rRowColumnWindowData.aRowColumnWindows.clear(); + rRowColumnWindowData.aRowColumnWindowSizes.clear(); + rRowColumnWindowData.aRowColumnSpace.clear(); + rRowColumnWindowData.nVarSize = 0; + rRowColumnWindowData.nStaticSize = 0; + rRowColumnWindowData.nSpace = 0; + rRowColumnWindowData.nRowColumn = nRowCol; + + // Collect data from windows that are on the same row/column + sal_Int32 j; + sal_Int32 nLastPos( 0 ); + + const sal_uInt32 nCount = aWindowVector.size(); + for ( j = 0; j < sal_Int32( nCount); j++ ) + { + const UIElement& rElement = aWindowVector[j]; + uno::Reference< awt::XWindow > xWindow; + uno::Reference< ui::XUIElement > xUIElement( rElement.m_xUIElement ); + awt::Rectangle aPosSize; + if ( !lcl_checkUIElement(xUIElement,aPosSize,xWindow) ) + continue; + + sal_Int32 nSpace; + if ( isHorizontalDockingArea( eDockingArea )) + { + nSpace = ( rElement.m_aDockedData.m_aPos.X() - nLastPos ); + + // Calc space before an element and store it + if ( rElement.m_aDockedData.m_aPos.X() > nLastPos ) + rRowColumnWindowData.nSpace += nSpace; + else + nSpace = 0; + + nLastPos = rElement.m_aDockedData.m_aPos.X() + aPosSize.Width; + + + rRowColumnWindowData.aRowColumnWindowSizes.push_back( + awt::Rectangle( rElement.m_aDockedData.m_aPos.X(), rElement.m_aDockedData.m_aPos.Y(), + aPosSize.Width, aPosSize.Height )); + if ( rRowColumnWindowData.nStaticSize < aPosSize.Height ) + rRowColumnWindowData.nStaticSize = aPosSize.Height; + rRowColumnWindowData.nVarSize += aPosSize.Width; + } + else + { + // Calc space before an element and store it + nSpace = ( rElement.m_aDockedData.m_aPos.Y() - nLastPos ); + if ( rElement.m_aDockedData.m_aPos.Y() > nLastPos ) + rRowColumnWindowData.nSpace += nSpace; + else + nSpace = 0; + + nLastPos = rElement.m_aDockedData.m_aPos.Y() + aPosSize.Height; + + rRowColumnWindowData.aRowColumnWindowSizes.push_back( + awt::Rectangle( rElement.m_aDockedData.m_aPos.X(), rElement.m_aDockedData.m_aPos.Y(), + aPosSize.Width, aPosSize.Height )); + if ( rRowColumnWindowData.nStaticSize < aPosSize.Width ) + rRowColumnWindowData.nStaticSize = aPosSize.Width; + rRowColumnWindowData.nVarSize += aPosSize.Height; + } + + rRowColumnWindowData.aUIElementNames.push_back( rElement.m_aName ); + rRowColumnWindowData.aRowColumnWindows.push_back( xWindow ); + rRowColumnWindowData.aRowColumnSpace.push_back( nSpace ); + rRowColumnWindowData.nVarSize += nSpace; + } +} + +::Rectangle ToolbarLayoutManager::implts_getWindowRectFromRowColumn( + ui::DockingArea DockingArea, + const SingleRowColumnWindowData& rRowColumnWindowData, + const ::Point& rMousePos, + const rtl::OUString& rExcludeElementName ) +{ + ::Rectangle aWinRect; + + if (( DockingArea < ui::DockingArea_DOCKINGAREA_TOP ) || ( DockingArea > ui::DockingArea_DOCKINGAREA_RIGHT )) + DockingArea = ui::DockingArea_DOCKINGAREA_TOP; + + if ( rRowColumnWindowData.aRowColumnWindows.empty() ) + return aWinRect; + else + { + ReadGuard aReadLock( m_aLock ); + Window* pContainerWindow( VCLUnoHelper::GetWindow( m_xContainerWindow )); + Window* pDockingAreaWindow( VCLUnoHelper::GetWindow( m_xDockAreaWindows[DockingArea] )); + aReadLock.unlock(); + + // Calc correct position of the column/row rectangle to be able to compare it with mouse pos/tracking rect + vos::OGuard aGuard( Application::GetSolarMutex() ); + + // Retrieve output size from container Window + if ( pDockingAreaWindow && pContainerWindow ) + { + const sal_uInt32 nCount = rRowColumnWindowData.aRowColumnWindows.size(); + for ( sal_uInt32 i = 0; i < nCount; i++ ) + { + awt::Rectangle aWindowRect = rRowColumnWindowData.aRowColumnWindows[i]->getPosSize(); + ::Rectangle aRect( aWindowRect.X, aWindowRect.Y, aWindowRect.X+aWindowRect.Width, aWindowRect.Y+aWindowRect.Height ); + aRect.SetPos( pContainerWindow->ScreenToOutputPixel( pDockingAreaWindow->OutputToScreenPixel( aRect.TopLeft() ))); + if ( aRect.IsInside( rMousePos )) + { + // Check if we have found the excluded element. If yes, we have to provide an empty rectangle. + // We prevent that a toolbar cannot be moved when the mouse pointer is inside its own rectangle! + if ( rExcludeElementName != rRowColumnWindowData.aUIElementNames[i] ) + return aRect; + else + break; + } + } + } + } + + return aWinRect; +} + +::Rectangle ToolbarLayoutManager::implts_determineFrontDockingRect( + ui::DockingArea eDockingArea, + sal_Int32 nRowCol, + const ::Rectangle& rDockedElementRect, + const ::rtl::OUString& rMovedElementName, + const ::Rectangle& rMovedElementRect ) +{ + SingleRowColumnWindowData aRowColumnWindowData; + + sal_Bool bHorzDockArea( isHorizontalDockingArea( eDockingArea )); + implts_getDockingAreaElementInfoOnSingleRowCol( eDockingArea, nRowCol, aRowColumnWindowData ); + if ( aRowColumnWindowData.aRowColumnWindows.empty() ) + return rMovedElementRect; + else + { + sal_Int32 nSpace( 0 ); + ::Rectangle aFrontDockingRect( rMovedElementRect ); + const sal_uInt32 nCount = aRowColumnWindowData.aRowColumnWindows.size(); + for ( sal_uInt32 i = 0; i < nCount; i++ ) + { + if ( bHorzDockArea ) + { + if ( aRowColumnWindowData.aRowColumnWindowSizes[i].X >= rDockedElementRect.Left() ) + { + nSpace += aRowColumnWindowData.aRowColumnSpace[i]; + break; + } + else if ( aRowColumnWindowData.aUIElementNames[i] == rMovedElementName ) + nSpace += aRowColumnWindowData.aRowColumnWindowSizes[i].Width + + aRowColumnWindowData.aRowColumnSpace[i]; + else + nSpace = 0; + } + else + { + if ( aRowColumnWindowData.aRowColumnWindowSizes[i].Y >= rDockedElementRect.Top() ) + { + nSpace += aRowColumnWindowData.aRowColumnSpace[i]; + break; + } + else if ( aRowColumnWindowData.aUIElementNames[i] == rMovedElementName ) + nSpace += aRowColumnWindowData.aRowColumnWindowSizes[i].Height + + aRowColumnWindowData.aRowColumnSpace[i]; + else + nSpace = 0; + } + } + + if ( nSpace > 0 ) + { + sal_Int32 nMove = std::min( nSpace, static_cast<sal_Int32>(aFrontDockingRect.getWidth()) ); + if ( bHorzDockArea ) + aFrontDockingRect.Move( -nMove, 0 ); + else + aFrontDockingRect.Move( 0, -nMove ); + } + + return aFrontDockingRect; + } +} + +void ToolbarLayoutManager::implts_findNextDockingPos( ui::DockingArea DockingArea, const ::Size& aUIElementSize, ::Point& rVirtualPos, ::Point& rPixelPos ) +{ + ReadGuard aReadLock( m_aLock ); + uno::Reference< awt::XWindow > xDockingWindow( m_xDockAreaWindows[DockingArea] ); + ::Size aDockingWinSize; + Window* pDockingWindow( 0 ); + aReadLock.unlock(); + + if (( DockingArea < ui::DockingArea_DOCKINGAREA_TOP ) || ( DockingArea > ui::DockingArea_DOCKINGAREA_RIGHT )) + DockingArea = ui::DockingArea_DOCKINGAREA_TOP; + + { + // Retrieve output size from container Window + vos::OGuard aGuard( Application::GetSolarMutex() ); + pDockingWindow = VCLUnoHelper::GetWindow( xDockingWindow ); + if ( pDockingWindow ) + aDockingWinSize = pDockingWindow->GetOutputSizePixel(); + } + + sal_Int32 nFreeRowColPixelPos( 0 ); + sal_Int32 nMaxSpace( 0 ); + sal_Int32 nNeededSpace( 0 ); + sal_Int32 nTopDockingAreaSize( 0 ); + + if ( isHorizontalDockingArea( DockingArea )) + { + nMaxSpace = aDockingWinSize.Width(); + nNeededSpace = aUIElementSize.Width(); + } + else + { + nMaxSpace = aDockingWinSize.Height(); + nNeededSpace = aUIElementSize.Height(); + nTopDockingAreaSize = implts_getTopBottomDockingAreaSizes().Width(); + } + + std::vector< SingleRowColumnWindowData > aRowColumnsWindowData; + + implts_getDockingAreaElementInfos( DockingArea, aRowColumnsWindowData ); + sal_Int32 nPixelPos( 0 ); + const sal_uInt32 nCount = aRowColumnsWindowData.size(); + for ( sal_uInt32 i = 0; i < nCount; i++ ) + { + SingleRowColumnWindowData& rRowColumnWindowData = aRowColumnsWindowData[i]; + + if (( DockingArea == ui::DockingArea_DOCKINGAREA_BOTTOM ) || + ( DockingArea == ui::DockingArea_DOCKINGAREA_RIGHT )) + nPixelPos += rRowColumnWindowData.nStaticSize; + + if ((( nMaxSpace - rRowColumnWindowData.nVarSize ) >= nNeededSpace ) || + ( rRowColumnWindowData.nSpace >= nNeededSpace )) + { + // Check current row where we can find the needed space + sal_Int32 nCurrPos( 0 ); + const sal_uInt32 nWindowSizesCount = rRowColumnWindowData.aRowColumnWindowSizes.size(); + for ( sal_uInt32 j = 0; j < nWindowSizesCount; j++ ) + { + awt::Rectangle rRect = rRowColumnWindowData.aRowColumnWindowSizes[j]; + sal_Int32& rSpace = rRowColumnWindowData.aRowColumnSpace[j]; + if ( isHorizontalDockingArea( DockingArea )) + { + if ( rSpace >= nNeededSpace ) + { + rVirtualPos = ::Point( nCurrPos, rRowColumnWindowData.nRowColumn ); + if ( DockingArea == ui::DockingArea_DOCKINGAREA_TOP ) + rPixelPos = ::Point( nCurrPos, nPixelPos ); + else + rPixelPos = ::Point( nCurrPos, aDockingWinSize.Height() - nPixelPos ); + return; + } + nCurrPos = rRect.X + rRect.Width; + } + else + { + if ( rSpace >= nNeededSpace ) + { + rVirtualPos = ::Point( rRowColumnWindowData.nRowColumn, nCurrPos ); + if ( DockingArea == ui::DockingArea_DOCKINGAREA_LEFT ) + rPixelPos = ::Point( nPixelPos, nTopDockingAreaSize + nCurrPos ); + else + rPixelPos = ::Point( aDockingWinSize.Width() - nPixelPos , nTopDockingAreaSize + nCurrPos ); + return; + } + nCurrPos = rRect.Y + rRect.Height; + } + } + + if (( nCurrPos + nNeededSpace ) <= nMaxSpace ) + { + if ( isHorizontalDockingArea( DockingArea )) + { + rVirtualPos = ::Point( nCurrPos, rRowColumnWindowData.nRowColumn ); + if ( DockingArea == ui::DockingArea_DOCKINGAREA_TOP ) + rPixelPos = ::Point( nCurrPos, nPixelPos ); + else + rPixelPos = ::Point( nCurrPos, aDockingWinSize.Height() - nPixelPos ); + return; + } + else + { + rVirtualPos = ::Point( rRowColumnWindowData.nRowColumn, nCurrPos ); + if ( DockingArea == ui::DockingArea_DOCKINGAREA_LEFT ) + rPixelPos = ::Point( nPixelPos, nTopDockingAreaSize + nCurrPos ); + else + rPixelPos = ::Point( aDockingWinSize.Width() - nPixelPos , nTopDockingAreaSize + nCurrPos ); + return; + } + } + } + + if (( DockingArea == ui::DockingArea_DOCKINGAREA_TOP ) || ( DockingArea == ui::DockingArea_DOCKINGAREA_LEFT )) + nPixelPos += rRowColumnWindowData.nStaticSize; + } + + sal_Int32 nNextFreeRowCol( 0 ); + sal_Int32 nRowColumnsCount = aRowColumnsWindowData.size(); + if ( nRowColumnsCount > 0 ) + nNextFreeRowCol = aRowColumnsWindowData[nRowColumnsCount-1].nRowColumn+1; + else + nNextFreeRowCol = 0; + + if ( nNextFreeRowCol == 0 ) + { + if ( DockingArea == ui::DockingArea_DOCKINGAREA_BOTTOM ) + nFreeRowColPixelPos = aDockingWinSize.Height() - aUIElementSize.Height(); + else if ( DockingArea == ui::DockingArea_DOCKINGAREA_RIGHT ) + nFreeRowColPixelPos = aDockingWinSize.Width() - aUIElementSize.Width(); + } + + if ( isHorizontalDockingArea( DockingArea )) + { + rVirtualPos = ::Point( 0, nNextFreeRowCol ); + if ( DockingArea == ui::DockingArea_DOCKINGAREA_TOP ) + rPixelPos = ::Point( 0, nFreeRowColPixelPos ); + else + rPixelPos = ::Point( 0, aDockingWinSize.Height() - nFreeRowColPixelPos ); + } + else + { + rVirtualPos = ::Point( nNextFreeRowCol, 0 ); + rPixelPos = ::Point( aDockingWinSize.Width() - nFreeRowColPixelPos, 0 ); + } +} + +void ToolbarLayoutManager::implts_calcWindowPosSizeOnSingleRowColumn( + sal_Int32 nDockingArea, + sal_Int32 nOffset, + SingleRowColumnWindowData& rRowColumnWindowData, + const ::Size& rContainerSize ) +{ + sal_Int32 nDiff(0); + sal_Int32 nRCSpace( rRowColumnWindowData.nSpace ); + sal_Int32 nTopDockingAreaSize(0); + sal_Int32 nBottomDockingAreaSize(0); + sal_Int32 nContainerClientSize(0); + + if ( rRowColumnWindowData.aRowColumnWindows.empty() ) + return; + + if ( isHorizontalDockingArea( nDockingArea )) + { + nContainerClientSize = rContainerSize.Width(); + nDiff = nContainerClientSize - rRowColumnWindowData.nVarSize; + } + else + { + nTopDockingAreaSize = implts_getTopBottomDockingAreaSizes().Width(); + nBottomDockingAreaSize = implts_getTopBottomDockingAreaSizes().Height(); + nContainerClientSize = ( rContainerSize.Height() - nTopDockingAreaSize - nBottomDockingAreaSize ); + nDiff = nContainerClientSize - rRowColumnWindowData.nVarSize; + } + + const sal_uInt32 nCount = rRowColumnWindowData.aRowColumnWindowSizes.size(); + if (( nDiff < 0 ) && ( nRCSpace > 0 )) + { + // First we try to reduce the size of blank space before/behind docked windows + sal_Int32 i = nCount - 1; + while ( i >= 0 ) + { + sal_Int32 nSpace = rRowColumnWindowData.aRowColumnSpace[i]; + if ( nSpace >= -nDiff ) + { + if ( isHorizontalDockingArea( nDockingArea )) + { + // Try to move this and all user elements behind with the calculated difference + for ( sal_uInt32 j = i; j < nCount ; j++ ) + rRowColumnWindowData.aRowColumnWindowSizes[j].X += nDiff; + } + else + { + // Try to move this and all user elements behind with the calculated difference + for ( sal_uInt32 j = i; j < nCount ; j++ ) + rRowColumnWindowData.aRowColumnWindowSizes[j].Y += nDiff; + } + nDiff = 0; + + break; + } + else if ( nSpace > 0 ) + { + if ( isHorizontalDockingArea( nDockingArea )) + { + // Try to move this and all user elements behind with the calculated difference + for ( sal_uInt32 j = i; j < nCount; j++ ) + rRowColumnWindowData.aRowColumnWindowSizes[j].X -= nSpace; + } + else + { + // Try to move this and all user elements behind with the calculated difference + for ( sal_uInt32 j = i; j < nCount; j++ ) + rRowColumnWindowData.aRowColumnWindowSizes[j].Y -= nSpace; + } + nDiff += nSpace; + } + --i; + } + } + + // Check if we have to reduce further + if ( nDiff < 0 ) + { + // Now we have to reduce the size of certain docked windows + sal_Int32 i = sal_Int32( nCount - 1 ); + while ( i >= 0 ) + { + awt::Rectangle& rWinRect = rRowColumnWindowData.aRowColumnWindowSizes[i]; + ::Size aMinSize; + + vos::OGuard aGuard( Application::GetSolarMutex() ); + { + uno::Reference< awt::XWindow > xWindow = rRowColumnWindowData.aRowColumnWindows[i]; + Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); + if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX ) + aMinSize = ((ToolBox *)pWindow)->CalcMinimumWindowSizePixel(); + } + + if (( aMinSize.Width() > 0 ) && ( aMinSize.Height() > 0 )) + { + if ( isHorizontalDockingArea( nDockingArea )) + { + sal_Int32 nMaxReducation = ( rWinRect.Width - aMinSize.Width() ); + if ( nMaxReducation >= -nDiff ) + { + rWinRect.Width = rWinRect.Width + nDiff; + nDiff = 0; + } + else + { + rWinRect.Width = aMinSize.Width(); + nDiff += nMaxReducation; + } + + // Try to move this and all user elements behind with the calculated difference + for ( sal_uInt32 j = i; j < nCount; j++ ) + rRowColumnWindowData.aRowColumnWindowSizes[j].X += nDiff; + } + else + { + sal_Int32 nMaxReducation = ( rWinRect.Height - aMinSize.Height() ); + if ( nMaxReducation >= -nDiff ) + { + rWinRect.Height = rWinRect.Height + nDiff; + nDiff = 0; + } + else + { + rWinRect.Height = aMinSize.Height(); + nDiff += nMaxReducation; + } + + // Try to move this and all user elements behind with the calculated difference + for ( sal_uInt32 j = i; j < nCount; j++ ) + rRowColumnWindowData.aRowColumnWindowSizes[j].Y += nDiff; + } + } + + if ( nDiff >= 0 ) + break; + + --i; + } + } + + ReadGuard aReadLock( m_aLock ); + Window* pDockAreaWindow = VCLUnoHelper::GetWindow( m_xDockAreaWindows[nDockingArea] ); + aReadLock.unlock(); + + sal_Int32 nCurrPos( 0 ); + + vos::OGuard aGuard( Application::GetSolarMutex() ); + for ( sal_uInt32 i = 0; i < nCount; i++ ) + { + uno::Reference< awt::XWindow > xWindow = rRowColumnWindowData.aRowColumnWindows[i]; + Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); + Window* pOldParentWindow = pWindow->GetParent(); + + if ( pDockAreaWindow != pOldParentWindow ) + pWindow->SetParent( pDockAreaWindow ); + + awt::Rectangle aWinRect = rRowColumnWindowData.aRowColumnWindowSizes[i]; + if ( isHorizontalDockingArea( nDockingArea )) + { + if ( aWinRect.X < nCurrPos ) + aWinRect.X = nCurrPos; + pWindow->SetPosSizePixel( ::Point( aWinRect.X, nOffset ), ::Size( aWinRect.Width, rRowColumnWindowData.nStaticSize )); + pWindow->Show( TRUE, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE ); + nCurrPos += ( aWinRect.X - nCurrPos ) + aWinRect.Width; + } + else + { + if ( aWinRect.Y < nCurrPos ) + aWinRect.Y = nCurrPos; + pWindow->SetPosSizePixel( ::Point( nOffset, aWinRect.Y ), ::Size( rRowColumnWindowData.nStaticSize, aWinRect.Height )); + pWindow->Show( TRUE, SHOW_NOFOCUSCHANGE | SHOW_NOACTIVATE ); + nCurrPos += ( aWinRect.Y - nCurrPos ) + aWinRect.Height; + } + } +} + +void ToolbarLayoutManager::implts_setLayoutDirty() +{ + WriteGuard aWriteLock( m_aLock ); + m_bLayoutDirty = true; +} + +void ToolbarLayoutManager::implts_setLayoutInProgress( bool bInProgress ) +{ + WriteGuard aWriteLock( m_aLock ); + m_bLayoutInProgress = bInProgress; +} + +::Rectangle ToolbarLayoutManager::implts_calcHotZoneRect( const ::Rectangle& rRect, sal_Int32 nHotZoneOffset ) +{ + ::Rectangle aRect( rRect ); + + aRect.Left() -= nHotZoneOffset; + aRect.Top() -= nHotZoneOffset; + aRect.Right() += nHotZoneOffset; + aRect.Bottom() += nHotZoneOffset; + + return aRect; +} + +void ToolbarLayoutManager::implts_calcDockingPosSize( + UIElement& rUIElement, + DockingOperation& rDockingOperation, + ::Rectangle& rTrackingRect, + const Point& rMousePos ) +{ + ReadGuard aReadLock( m_aLock ); + uno::Reference< awt::XWindow2 > xContainerWindow( m_xContainerWindow ); + ::Size aContainerWinSize; + Window* pContainerWindow( 0 ); + ::Rectangle aDockingAreaOffsets( m_aDockingAreaOffsets ); + aReadLock.unlock(); + + if ( !rUIElement.m_xUIElement.is() ) + { + rTrackingRect = ::Rectangle(); + return; + } + + { + // Retrieve output size from container Window + vos::OGuard aGuard( Application::GetSolarMutex() ); + pContainerWindow = VCLUnoHelper::GetWindow( xContainerWindow ); + aContainerWinSize = pContainerWindow->GetOutputSizePixel(); + } + + Window* pDockWindow( 0 ); + Window* pDockingAreaWindow( 0 ); + ToolBox* pToolBox( 0 ); + uno::Reference< awt::XWindow > xWindow( rUIElement.m_xUIElement->getRealInterface(), uno::UNO_QUERY ); + uno::Reference< awt::XWindow > xDockingAreaWindow; + ::Rectangle aTrackingRect( rTrackingRect ); + ui::DockingArea eDockedArea( (ui::DockingArea)rUIElement.m_aDockedData.m_nDockedArea ); + sal_Int32 nTopDockingAreaSize( implts_getTopBottomDockingAreaSizes().Width() ); + sal_Int32 nBottomDockingAreaSize( implts_getTopBottomDockingAreaSizes().Height() ); + bool bHorizontalDockArea(( eDockedArea == ui::DockingArea_DOCKINGAREA_TOP ) || + ( eDockedArea == ui::DockingArea_DOCKINGAREA_BOTTOM )); + sal_Int32 nMaxLeftRightDockAreaSize = aContainerWinSize.Height() - + nTopDockingAreaSize - + nBottomDockingAreaSize - + aDockingAreaOffsets.Top() - + aDockingAreaOffsets.Bottom(); + ::Rectangle aDockingAreaRect; + + aReadLock.lock(); + xDockingAreaWindow = m_xDockAreaWindows[eDockedArea]; + aReadLock.unlock(); + + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + pDockingAreaWindow = VCLUnoHelper::GetWindow( xDockingAreaWindow ); + pDockWindow = VCLUnoHelper::GetWindow( xWindow ); + if ( pDockWindow && pDockWindow->GetType() == WINDOW_TOOLBOX ) + pToolBox = (ToolBox *)pDockWindow; + + aDockingAreaRect = ::Rectangle( pDockingAreaWindow->GetPosPixel(), pDockingAreaWindow->GetSizePixel() ); + if ( pToolBox ) + { + // docked toolbars always have one line + ::Size aSize = pToolBox->CalcWindowSizePixel( 1, ImplConvertAlignment( sal_Int16( eDockedArea )) ); + aTrackingRect.SetSize( ::Size( aSize.Width(), aSize.Height() )); + } + } + + // default docking operation, dock on the given row/column + bool bOpOutsideOfDockingArea( !aDockingAreaRect.IsInside( rMousePos )); + std::vector< SingleRowColumnWindowData > aRowColumnsWindowData; + + rDockingOperation = DOCKOP_ON_COLROW; + implts_getDockingAreaElementInfos( eDockedArea, aRowColumnsWindowData ); + + // determine current first row/column and last row/column + sal_Int32 nMaxRowCol( -1 ); + sal_Int32 nMinRowCol( SAL_MAX_INT32 ); + const sal_uInt32 nCount = aRowColumnsWindowData.size(); + for ( sal_uInt32 i = 0; i < nCount; i++ ) + { + if ( aRowColumnsWindowData[i].nRowColumn > nMaxRowCol ) + nMaxRowCol = aRowColumnsWindowData[i].nRowColumn; + if ( aRowColumnsWindowData[i].nRowColumn < nMinRowCol ) + nMinRowCol = aRowColumnsWindowData[i].nRowColumn; + } + + if ( !bOpOutsideOfDockingArea ) + { + // docking inside our docking area + sal_Int32 nIndex( -1 ); + sal_Int32 nRowCol( -1 ); + ::Rectangle aWindowRect; + ::Rectangle aRowColumnRect; + + const sal_uInt32 nWindowDataCount = aRowColumnsWindowData.size(); + for ( sal_uInt32 i = 0; i < nWindowDataCount; i++ ) + { + ::Rectangle aRect( aRowColumnsWindowData[i].aRowColumnRect.X, + aRowColumnsWindowData[i].aRowColumnRect.Y, + aRowColumnsWindowData[i].aRowColumnRect.X + aRowColumnsWindowData[i].aRowColumnRect.Width, + aRowColumnsWindowData[i].aRowColumnRect.Y + aRowColumnsWindowData[i].aRowColumnRect.Height ); + + { + // Calc correct position of the column/row rectangle to be able to compare it with mouse pos/tracking rect + vos::OGuard aGuard( Application::GetSolarMutex() ); + aRect.SetPos( pContainerWindow->ScreenToOutputPixel( pDockingAreaWindow->OutputToScreenPixel( aRect.TopLeft() ))); + } + + bool bIsInsideRowCol( aRect.IsInside( rMousePos ) ); + if ( bIsInsideRowCol ) + { + nIndex = i; + nRowCol = aRowColumnsWindowData[i].nRowColumn; + rDockingOperation = implts_determineDockingOperation( eDockedArea, aRect, rMousePos ); + aWindowRect = implts_getWindowRectFromRowColumn( eDockedArea, aRowColumnsWindowData[i], rMousePos, rUIElement.m_aName ); + aRowColumnRect = aRect; + break; + } + } + + OSL_ENSURE( ( nIndex >= 0 ) && ( nRowCol >= 0 ), "Impossible case - no row/column found but mouse pointer is inside our docking area" ); + if (( nIndex >= 0 ) && ( nRowCol >= 0 )) + { + if ( rDockingOperation == DOCKOP_ON_COLROW ) + { + if ( !aWindowRect.IsEmpty()) + { + // Tracking rect is on a row/column and mouse is over a docked toolbar. + // Determine if the tracking rect must be located before/after the docked toolbar. + + ::Rectangle aUIElementRect( aWindowRect ); + sal_Int32 nMiddle( bHorizontalDockArea ? ( aWindowRect.Left() + aWindowRect.getWidth() / 2 ) : + ( aWindowRect.Top() + aWindowRect.getHeight() / 2 )); + sal_Bool bInsertBefore( bHorizontalDockArea ? ( rMousePos.X() < nMiddle ) : ( rMousePos.Y() < nMiddle )); + if ( bInsertBefore ) + { + if ( bHorizontalDockArea ) + { + sal_Int32 nSize = ::std::max( sal_Int32( 0 ), std::min( sal_Int32( aContainerWinSize.Width() - aWindowRect.Left() ), + sal_Int32( aTrackingRect.getWidth() ))); + if ( nSize == 0 ) + nSize = aWindowRect.getWidth(); + + aUIElementRect.SetSize( ::Size( nSize, aWindowRect.getHeight() )); + aWindowRect = implts_determineFrontDockingRect( eDockedArea, nRowCol, aWindowRect,rUIElement.m_aName, aUIElementRect ); + + // Set virtual position + rUIElement.m_aDockedData.m_aPos.X() = aWindowRect.Left(); + rUIElement.m_aDockedData.m_aPos.Y() = nRowCol; + } + else + { + sal_Int32 nSize = ::std::max( sal_Int32( 0 ), std::min( sal_Int32( + nTopDockingAreaSize + nMaxLeftRightDockAreaSize - aWindowRect.Top() ), + sal_Int32( aTrackingRect.getHeight() ))); + if ( nSize == 0 ) + nSize = aWindowRect.getHeight(); + + aUIElementRect.SetSize( ::Size( aWindowRect.getWidth(), nSize )); + aWindowRect = implts_determineFrontDockingRect( eDockedArea, nRowCol, aWindowRect, rUIElement.m_aName, aUIElementRect ); + + // Set virtual position + sal_Int32 nPosY = pDockingAreaWindow->ScreenToOutputPixel( + pContainerWindow->OutputToScreenPixel( aWindowRect.TopLeft() )).Y(); + rUIElement.m_aDockedData.m_aPos.X() = nRowCol; + rUIElement.m_aDockedData.m_aPos.Y() = nPosY; + } + + rTrackingRect = aWindowRect; + return; + } + else + { + if ( bHorizontalDockArea ) + { + sal_Int32 nSize = ::std::max( sal_Int32( 0 ), std::min( sal_Int32(( aContainerWinSize.Width() ) - aWindowRect.Right() ), + sal_Int32( aTrackingRect.getWidth() ))); + if ( nSize == 0 ) + { + aUIElementRect.SetPos( ::Point( aContainerWinSize.Width() - aTrackingRect.getWidth(), aWindowRect.Top() )); + aUIElementRect.SetSize( ::Size( aTrackingRect.getWidth(), aWindowRect.getHeight() )); + rUIElement.m_aDockedData.m_aPos.X() = aUIElementRect.Left(); + } + else + { + aUIElementRect.SetPos( ::Point( aWindowRect.Right(), aWindowRect.Top() )); + aUIElementRect.SetSize( ::Size( nSize, aWindowRect.getHeight() )); + rUIElement.m_aDockedData.m_aPos.X() = aWindowRect.Right(); + } + + // Set virtual position + rUIElement.m_aDockedData.m_aPos.Y() = nRowCol; + } + else + { + sal_Int32 nSize = ::std::max( sal_Int32( 0 ), std::min( sal_Int32( nTopDockingAreaSize + nMaxLeftRightDockAreaSize - aWindowRect.Bottom() ), + sal_Int32( aTrackingRect.getHeight() ))); + aUIElementRect.SetPos( ::Point( aWindowRect.Left(), aWindowRect.Bottom() )); + aUIElementRect.SetSize( ::Size( aWindowRect.getWidth(), nSize )); + + // Set virtual position + sal_Int32 nPosY( 0 ); + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + nPosY = pDockingAreaWindow->ScreenToOutputPixel( + pContainerWindow->OutputToScreenPixel( aWindowRect.BottomRight() )).Y(); + } + rUIElement.m_aDockedData.m_aPos.X() = nRowCol; + rUIElement.m_aDockedData.m_aPos.Y() = nPosY; + } + + rTrackingRect = aUIElementRect; + return; + } + } + else + { + implts_setTrackingRect( eDockedArea, rMousePos, aTrackingRect ); + rTrackingRect = implts_calcTrackingAndElementRect( + eDockedArea, nRowCol, rUIElement, + aTrackingRect, aRowColumnRect, aContainerWinSize ); + return; + } + } + else + { + if ((( nRowCol == nMinRowCol ) && ( rDockingOperation == DOCKOP_BEFORE_COLROW )) || + (( nRowCol == nMaxRowCol ) && ( rDockingOperation == DOCKOP_AFTER_COLROW ))) + bOpOutsideOfDockingArea = true; + else + { + // handle docking before/after a row + implts_setTrackingRect( eDockedArea, rMousePos, aTrackingRect ); + rTrackingRect = implts_calcTrackingAndElementRect( + eDockedArea, nRowCol, rUIElement, + aTrackingRect, aRowColumnRect, aContainerWinSize ); + + sal_Int32 nOffsetX( 0 ); + sal_Int32 nOffsetY( 0 ); + if ( bHorizontalDockArea ) + nOffsetY = sal_Int32( floor( aRowColumnRect.getHeight() / 2 + 0.5 )); + else + nOffsetX = sal_Int32( floor( aRowColumnRect.getWidth() / 2 + 0.5 )); + + if ( rDockingOperation == DOCKOP_BEFORE_COLROW ) + { + if (( eDockedArea == ui::DockingArea_DOCKINGAREA_TOP ) || ( eDockedArea == ui::DockingArea_DOCKINGAREA_LEFT )) + { + // Docking before/after means move track rectangle half column/row. + // As left and top are ordered 0...n instead of right and bottom + // which uses n...0, we have to use negative values for top/left. + nOffsetX *= -1; + nOffsetY *= -1; + } + } + else + { + if (( eDockedArea == ui::DockingArea_DOCKINGAREA_BOTTOM ) || ( eDockedArea == ui::DockingArea_DOCKINGAREA_RIGHT )) + { + // Docking before/after means move track rectangle half column/row. + // As left and top are ordered 0...n instead of right and bottom + // which uses n...0, we have to use negative values for top/left. + nOffsetX *= -1; + nOffsetY *= -1; + } + nRowCol++; + } + + if ( bHorizontalDockArea ) + rUIElement.m_aDockedData.m_aPos.Y() = nRowCol; + else + rUIElement.m_aDockedData.m_aPos.X() = nRowCol; + + rTrackingRect.Move( nOffsetX, nOffsetY ); + rTrackingRect.SetSize( aTrackingRect.GetSize() ); + } + } + } + } + + // Docking outside of our docking window area => + // Users want to dock before/after first/last docked element or to an empty docking area + if ( bOpOutsideOfDockingArea ) + { + // set correct size for docking + implts_setTrackingRect( eDockedArea, rMousePos, aTrackingRect ); + rTrackingRect = aTrackingRect; + + if ( bHorizontalDockArea ) + { + sal_Int32 nPosX( std::max( sal_Int32( rTrackingRect.Left()), sal_Int32( 0 ))); + if (( nPosX + rTrackingRect.getWidth()) > aContainerWinSize.Width() ) + nPosX = std::min( nPosX, + std::max( sal_Int32( aContainerWinSize.Width() - rTrackingRect.getWidth() ), + sal_Int32( 0 ))); + + sal_Int32 nSize = std::min( aContainerWinSize.Width(), rTrackingRect.getWidth() ); + sal_Int32 nDockHeight = std::max( static_cast<sal_Int32>(aDockingAreaRect.getHeight()), sal_Int32( 0 )); + if ( nDockHeight == 0 ) + { + sal_Int32 nPosY( std::max( aDockingAreaRect.Top(), aDockingAreaRect.Bottom() )); + if ( eDockedArea == ui::DockingArea_DOCKINGAREA_BOTTOM ) + nPosY -= rTrackingRect.getHeight(); + rTrackingRect.SetPos( Point( nPosX, nPosY )); + rUIElement.m_aDockedData.m_aPos.Y() = 0; + } + else if ( rMousePos.Y() < ( aDockingAreaRect.Top() + ( nDockHeight / 2 ))) + { + rTrackingRect.SetPos( Point( nPosX, aDockingAreaRect.Top() - rTrackingRect.getHeight() )); + if ( eDockedArea == ui::DockingArea_DOCKINGAREA_TOP ) + rUIElement.m_aDockedData.m_aPos.Y() = 0; + else + rUIElement.m_aDockedData.m_aPos.Y() = ( nMaxRowCol >= 0 ) ? nMaxRowCol+1 : 0; + rDockingOperation = DOCKOP_BEFORE_COLROW; + } + else + { + rTrackingRect.SetPos( Point( nPosX, aDockingAreaRect.Bottom() )); + if ( eDockedArea == ui::DockingArea_DOCKINGAREA_TOP ) + rUIElement.m_aDockedData.m_aPos.Y() = ( nMaxRowCol >= 0 ) ? nMaxRowCol+1 : 0; + else + rUIElement.m_aDockedData.m_aPos.Y() = 0; + rDockingOperation = DOCKOP_AFTER_COLROW; + } + rTrackingRect.setWidth( nSize ); + + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + nPosX = pDockingAreaWindow->ScreenToOutputPixel( + pContainerWindow->OutputToScreenPixel( rTrackingRect.TopLeft() )).X(); + } + rUIElement.m_aDockedData.m_aPos.X() = nPosX; + } + else + { + sal_Int32 nMaxDockingAreaHeight = std::max( sal_Int32( 0 ), sal_Int32( nMaxLeftRightDockAreaSize )); + sal_Int32 nPosY( std::max( sal_Int32( aTrackingRect.Top()), sal_Int32( nTopDockingAreaSize ))); + if (( nPosY + aTrackingRect.getHeight()) > ( nTopDockingAreaSize + nMaxDockingAreaHeight )) + nPosY = std::min( nPosY, + std::max( sal_Int32( nTopDockingAreaSize + ( nMaxDockingAreaHeight - aTrackingRect.getHeight() )), + sal_Int32( nTopDockingAreaSize ))); + + sal_Int32 nSize = std::min( nMaxDockingAreaHeight, static_cast<sal_Int32>(aTrackingRect.getHeight()) ); + sal_Int32 nDockWidth = std::max( static_cast<sal_Int32>(aDockingAreaRect.getWidth()), sal_Int32( 0 )); + if ( nDockWidth == 0 ) + { + sal_Int32 nPosX( std::max( aDockingAreaRect.Left(), aDockingAreaRect.Right() )); + if ( eDockedArea == ui::DockingArea_DOCKINGAREA_RIGHT ) + nPosX -= rTrackingRect.getWidth(); + rTrackingRect.SetPos( Point( nPosX, nPosY )); + rUIElement.m_aDockedData.m_aPos.X() = 0; + } + else if ( rMousePos.X() < ( aDockingAreaRect.Left() + ( nDockWidth / 2 ))) + { + rTrackingRect.SetPos( Point( aDockingAreaRect.Left() - rTrackingRect.getWidth(), nPosY )); + if ( eDockedArea == ui::DockingArea_DOCKINGAREA_LEFT ) + rUIElement.m_aDockedData.m_aPos.X() = 0; + else + rUIElement.m_aDockedData.m_aPos.X() = ( nMaxRowCol >= 0 ) ? nMaxRowCol+1 : 0; + rDockingOperation = DOCKOP_BEFORE_COLROW; + } + else + { + rTrackingRect.SetPos( Point( aDockingAreaRect.Right(), nPosY )); + if ( eDockedArea == ui::DockingArea_DOCKINGAREA_LEFT ) + rUIElement.m_aDockedData.m_aPos.X() = ( nMaxRowCol >= 0 ) ? nMaxRowCol+1 : 0; + else + rUIElement.m_aDockedData.m_aPos.X() = 0; + rDockingOperation = DOCKOP_AFTER_COLROW; + } + rTrackingRect.setHeight( nSize ); + + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + nPosY = pDockingAreaWindow->ScreenToOutputPixel( + pContainerWindow->OutputToScreenPixel( rTrackingRect.TopLeft() )).Y(); + } + rUIElement.m_aDockedData.m_aPos.Y() = nPosY; + } + } +} + +framework::ToolbarLayoutManager::DockingOperation ToolbarLayoutManager::implts_determineDockingOperation( + ui::DockingArea DockingArea, + const ::Rectangle& rRowColRect, + const Point& rMousePos ) +{ + const sal_Int32 nHorzVerticalRegionSize = 6; + const sal_Int32 nHorzVerticalMoveRegion = 4; + + if ( rRowColRect.IsInside( rMousePos )) + { + if ( isHorizontalDockingArea( DockingArea )) + { + sal_Int32 nRegion = rRowColRect.getHeight() / nHorzVerticalRegionSize; + sal_Int32 nPosY = rRowColRect.Top() + nRegion; + + if ( rMousePos.Y() < nPosY ) + return ( DockingArea == ui::DockingArea_DOCKINGAREA_TOP ) ? DOCKOP_BEFORE_COLROW : DOCKOP_AFTER_COLROW; + else if ( rMousePos.Y() < ( nPosY + nRegion*nHorzVerticalMoveRegion )) + return DOCKOP_ON_COLROW; + else + return ( DockingArea == ui::DockingArea_DOCKINGAREA_TOP ) ? DOCKOP_AFTER_COLROW : DOCKOP_BEFORE_COLROW; + } + else + { + sal_Int32 nRegion = rRowColRect.getWidth() / nHorzVerticalRegionSize; + sal_Int32 nPosX = rRowColRect.Left() + nRegion; + + if ( rMousePos.X() < nPosX ) + return ( DockingArea == ui::DockingArea_DOCKINGAREA_LEFT ) ? DOCKOP_BEFORE_COLROW : DOCKOP_AFTER_COLROW; + else if ( rMousePos.X() < ( nPosX + nRegion*nHorzVerticalMoveRegion )) + return DOCKOP_ON_COLROW; + else + return ( DockingArea == ui::DockingArea_DOCKINGAREA_LEFT ) ? DOCKOP_AFTER_COLROW : DOCKOP_BEFORE_COLROW; + } + } + else + return DOCKOP_ON_COLROW; +} + +::Rectangle ToolbarLayoutManager::implts_calcTrackingAndElementRect( + ui::DockingArea eDockingArea, + sal_Int32 nRowCol, + UIElement& rUIElement, + const ::Rectangle& rTrackingRect, + const ::Rectangle& rRowColumnRect, + const ::Size& rContainerWinSize ) +{ + ReadGuard aReadGuard( m_aLock ); + ::Rectangle aDockingAreaOffsets( m_aDockingAreaOffsets ); + aReadGuard.unlock(); + + bool bHorizontalDockArea( isHorizontalDockingArea( eDockingArea )); + sal_Int32 nTopDockingAreaSize( implts_getTopBottomDockingAreaSizes().Width() ); + sal_Int32 nBottomDockingAreaSize( implts_getTopBottomDockingAreaSizes().Height() ); + + sal_Int32 nMaxLeftRightDockAreaSize = rContainerWinSize.Height() - + nTopDockingAreaSize - + nBottomDockingAreaSize - + aDockingAreaOffsets.Top() - + aDockingAreaOffsets.Bottom(); + + ::Rectangle aTrackingRect( rTrackingRect ); + if ( bHorizontalDockArea ) + { + sal_Int32 nPosX( std::max( sal_Int32( rTrackingRect.Left()), sal_Int32( 0 ))); + if (( nPosX + rTrackingRect.getWidth()) > rContainerWinSize.Width() ) + nPosX = std::min( nPosX, + std::max( sal_Int32( rContainerWinSize.Width() - rTrackingRect.getWidth() ), + sal_Int32( 0 ))); + + sal_Int32 nSize = std::min( rContainerWinSize.Width(), rTrackingRect.getWidth() ); + + aTrackingRect.SetPos( ::Point( nPosX, rRowColumnRect.Top() )); + aTrackingRect.setWidth( nSize ); + aTrackingRect.setHeight( rRowColumnRect.getHeight() ); + + // Set virtual position + rUIElement.m_aDockedData.m_aPos.X() = nPosX; + rUIElement.m_aDockedData.m_aPos.Y() = nRowCol; + } + else + { + sal_Int32 nMaxDockingAreaHeight = std::max( sal_Int32( 0 ), + sal_Int32( nMaxLeftRightDockAreaSize )); + + sal_Int32 nPosY( std::max( sal_Int32( aTrackingRect.Top()), sal_Int32( nTopDockingAreaSize ))); + if (( nPosY + aTrackingRect.getHeight()) > ( nTopDockingAreaSize + nMaxDockingAreaHeight )) + nPosY = std::min( nPosY, + std::max( sal_Int32( nTopDockingAreaSize + ( nMaxDockingAreaHeight - aTrackingRect.getHeight() )), + sal_Int32( nTopDockingAreaSize ))); + + sal_Int32 nSize = std::min( nMaxDockingAreaHeight, static_cast<sal_Int32>(aTrackingRect.getHeight()) ); + + aTrackingRect.SetPos( ::Point( rRowColumnRect.Left(), nPosY )); + aTrackingRect.setWidth( rRowColumnRect.getWidth() ); + aTrackingRect.setHeight( nSize ); + + aReadGuard.lock(); + uno::Reference< awt::XWindow > xDockingAreaWindow( m_xDockAreaWindows[eDockingArea] ); + uno::Reference< awt::XWindow2 > xContainerWindow( m_xContainerWindow ); + aReadGuard.unlock(); + + sal_Int32 nDockPosY( 0 ); + Window* pDockingAreaWindow( 0 ); + Window* pContainerWindow( 0 ); + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + pDockingAreaWindow = VCLUnoHelper::GetWindow( xDockingAreaWindow ); + pContainerWindow = VCLUnoHelper::GetWindow( xContainerWindow ); + nDockPosY = pDockingAreaWindow->ScreenToOutputPixel( pContainerWindow->OutputToScreenPixel( ::Point( 0, nPosY ))).Y(); + } + + // Set virtual position + rUIElement.m_aDockedData.m_aPos.X() = nRowCol; + rUIElement.m_aDockedData.m_aPos.Y() = nDockPosY; + } + + return aTrackingRect; +} + +void ToolbarLayoutManager::implts_setTrackingRect( ui::DockingArea eDockingArea, const ::Point& rMousePos, ::Rectangle& rTrackingRect ) +{ + ::Point aPoint( rTrackingRect.TopLeft()); + if ( isHorizontalDockingArea( eDockingArea )) + aPoint.X() = rMousePos.X(); + else + aPoint.Y() = rMousePos.Y(); + rTrackingRect.SetPos( aPoint ); +} + +void ToolbarLayoutManager::implts_renumberRowColumnData( + ui::DockingArea eDockingArea, + DockingOperation /*eDockingOperation*/, + const UIElement& rUIElement ) +{ + ReadGuard aReadLock( m_aLock ); + uno::Reference< container::XNameAccess > xPersistentWindowState( m_xPersistentWindowState ); + aReadLock.unlock(); + + bool bHorzDockingArea( isHorizontalDockingArea( eDockingArea )); + sal_Int32 nRowCol( bHorzDockingArea ? rUIElement.m_aDockedData.m_aPos.Y() : rUIElement.m_aDockedData.m_aPos.X() ); + + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + WriteGuard aWriteLock( m_aLock ); + UIElementVector::iterator pIter; + for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) + { + if (( pIter->m_aDockedData.m_nDockedArea == sal_Int16( eDockingArea )) && ( pIter->m_aName != rUIElement.m_aName )) + { + // Don't change toolbars without a valid docking position! + if ( isDefaultPos( pIter->m_aDockedData.m_aPos )) + continue; + + sal_Int32 nWindowRowCol = ( bHorzDockingArea ) ? pIter->m_aDockedData.m_aPos.Y() : pIter->m_aDockedData.m_aPos.X(); + if ( nWindowRowCol >= nRowCol ) + { + if ( bHorzDockingArea ) + pIter->m_aDockedData.m_aPos.Y() += 1; + else + pIter->m_aDockedData.m_aPos.X() += 1; + } + } + } + aWriteLock.unlock(); + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + + // We have to change the persistent window state part + if ( xPersistentWindowState.is() ) + { + try + { + uno::Sequence< ::rtl::OUString > aWindowElements = xPersistentWindowState->getElementNames(); + for ( sal_Int32 i = 0; i < aWindowElements.getLength(); i++ ) + { + if ( rUIElement.m_aName != aWindowElements[i] ) + { + try + { + uno::Sequence< beans::PropertyValue > aPropValueSeq; + awt::Point aDockedPos; + ui::DockingArea nDockedArea( ui::DockingArea_DOCKINGAREA_DEFAULT ); + + xPersistentWindowState->getByName( aWindowElements[i] ) >>= aPropValueSeq; + for ( sal_Int32 j = 0; j < aPropValueSeq.getLength(); j++ ) + { + if ( aPropValueSeq[j].Name.equalsAscii( WINDOWSTATE_PROPERTY_DOCKINGAREA )) + aPropValueSeq[j].Value >>= nDockedArea; + else if ( aPropValueSeq[j].Name.equalsAscii( WINDOWSTATE_PROPERTY_DOCKPOS )) + aPropValueSeq[j].Value >>= aDockedPos; + } + + // Don't change toolbars without a valid docking position! + if ( isDefaultPos( aDockedPos )) + continue; + + sal_Int32 nWindowRowCol = ( bHorzDockingArea ) ? aDockedPos.Y : aDockedPos.X; + if (( nDockedArea == eDockingArea ) && ( nWindowRowCol >= nRowCol )) + { + if ( bHorzDockingArea ) + aDockedPos.Y += 1; + else + aDockedPos.X += 1; + + uno::Reference< container::XNameReplace > xReplace( xPersistentWindowState, uno::UNO_QUERY ); + xReplace->replaceByName( aWindowElements[i], makeAny( aPropValueSeq )); + } + } + catch ( uno::Exception& ) {} + } + } + } + catch ( uno::Exception& ) {} + } +} + +//--------------------------------------------------------------------------------------------------------- +// XWindowListener +//--------------------------------------------------------------------------------------------------------- +void SAL_CALL ToolbarLayoutManager::windowResized( const awt::WindowEvent& aEvent ) +throw( uno::RuntimeException ) +{ + WriteGuard aWriteLock( m_aLock ); + bool bLocked( m_bDockingInProgress ); + bool bLayoutInProgress( m_bLayoutInProgress ); + aWriteLock.unlock(); + + // Do not do anything if we are in the middle of a docking process. This would interfere all other + // operations. We will store the new position and size in the docking handlers. + // Do not do anything if we are in the middle of our layouting process. We will adapt the position + // and size of the user interface elements. + if ( !bLocked && !bLayoutInProgress ) + { + bool bNotify( false ); + uno::Reference< awt::XWindow > xWindow( aEvent.Source, uno::UNO_QUERY ); + + UIElement aUIElement = implts_findToolbar( aEvent.Source ); + if ( aUIElement.m_xUIElement.is() ) + { + if ( aUIElement.m_bFloating ) + { + uno::Reference< awt::XWindow2 > xWindow2( xWindow, uno::UNO_QUERY ); + + if( xWindow2.is() ) + { + awt::Rectangle aPos = xWindow2->getPosSize(); + awt::Size aSize = xWindow2->getOutputSize(); // always use output size for consistency + bool bVisible = xWindow2->isVisible(); + + // update element data + aUIElement.m_aFloatingData.m_aPos = ::Point( aPos.X, aPos.Y ); + aUIElement.m_aFloatingData.m_aSize = ::Size( aSize.Width, aSize.Height ); + aUIElement.m_bVisible = bVisible; + } + + implts_writeWindowStateData( aUIElement ); + } + else + { + implts_setLayoutDirty(); + bNotify = true; + } + } + + if ( bNotify ) + m_pParentLayouter->requestLayout( ILayoutNotifications::HINT_TOOLBARSPACE_HAS_CHANGED ); + } +} + +void SAL_CALL ToolbarLayoutManager::windowMoved( const awt::WindowEvent& /*aEvent*/ ) +throw( uno::RuntimeException ) +{ +} + +void SAL_CALL ToolbarLayoutManager::windowShown( const lang::EventObject& /*aEvent*/ ) +throw( uno::RuntimeException ) +{ +} + +void SAL_CALL ToolbarLayoutManager::windowHidden( const lang::EventObject& /*aEvent*/ ) +throw( uno::RuntimeException ) +{ +} + +//--------------------------------------------------------------------------------------------------------- +// XDockableWindowListener +//--------------------------------------------------------------------------------------------------------- +void SAL_CALL ToolbarLayoutManager::startDocking( const awt::DockingEvent& e ) +throw (uno::RuntimeException) +{ + bool bWinFound( false ); + + ReadGuard aReadGuard( m_aLock ); + uno::Reference< awt::XWindow2 > xContainerWindow( m_xContainerWindow ); + uno::Reference< awt::XWindow2 > xWindow( e.Source, uno::UNO_QUERY ); + aReadGuard.unlock(); + + Window* pContainerWindow( 0 ); + Window* pWindow( 0 ); + ::Point aMousePos; + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + pContainerWindow = VCLUnoHelper::GetWindow( xContainerWindow ); + aMousePos = pContainerWindow->ScreenToOutputPixel( ::Point( e.MousePos.X, e.MousePos.Y )); + } + + UIElement aUIElement = implts_findToolbar( e.Source ); + + if ( aUIElement.m_xUIElement.is() && xWindow.is() ) + { + awt::Rectangle aRect; + + bWinFound = true; + uno::Reference< awt::XDockableWindow > xDockWindow( xWindow, uno::UNO_QUERY ); + if ( xDockWindow->isFloating() ) + { + awt::Rectangle aPos = xWindow->getPosSize(); + awt::Size aSize = xWindow->getOutputSize(); + + aUIElement.m_aFloatingData.m_aPos = ::Point( aPos.X, aPos.Y ); + aUIElement.m_aFloatingData.m_aSize = ::Size( aSize.Width, aSize.Height ); + + vos::OGuard aGuard( Application::GetSolarMutex() ); + pWindow = VCLUnoHelper::GetWindow( xWindow ); + if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX ) + { + ToolBox* pToolBox = (ToolBox *)pWindow; + aUIElement.m_aFloatingData.m_nLines = pToolBox->GetFloatingLines(); + aUIElement.m_aFloatingData.m_bIsHorizontal = isToolboxHorizontalAligned( pToolBox ); + } + } + } + + WriteGuard aWriteLock( m_aLock ); + m_bDockingInProgress = bWinFound; + m_aDockUIElement = aUIElement; + m_aDockUIElement.m_bUserActive = true; + m_aStartDockMousePos = aMousePos; + aWriteLock.unlock(); +} + +awt::DockingData SAL_CALL ToolbarLayoutManager::docking( const awt::DockingEvent& e ) +throw (uno::RuntimeException) +{ + const sal_Int32 MAGNETIC_DISTANCE_UNDOCK = 25; + const sal_Int32 MAGNETIC_DISTANCE_DOCK = 20; + + ReadGuard aReadLock( m_aLock ); + awt::DockingData aDockingData; + uno::Reference< awt::XDockableWindow > xDockWindow( e.Source, uno::UNO_QUERY ); + uno::Reference< awt::XWindow > xWindow( e.Source, uno::UNO_QUERY ); + uno::Reference< awt::XWindow > xTopDockingWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_TOP] ); + uno::Reference< awt::XWindow > xLeftDockingWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_LEFT] ); + uno::Reference< awt::XWindow > xRightDockingWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_RIGHT] ); + uno::Reference< awt::XWindow > xBottomDockingWindow( m_xDockAreaWindows[ui::DockingArea_DOCKINGAREA_BOTTOM] ); + uno::Reference< awt::XWindow2 > xContainerWindow( m_xContainerWindow ); + UIElement aUIDockingElement( m_aDockUIElement ); + DockingOperation eDockingOperation( DOCKOP_ON_COLROW ); + bool bDockingInProgress( m_bDockingInProgress ); + aReadLock.unlock(); + + if ( bDockingInProgress ) + aDockingData.TrackingRectangle = e.TrackingRectangle; + + if ( bDockingInProgress && xDockWindow.is() && xWindow.is() ) + { + try + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + + sal_Int16 eDockingArea( -1 ); // none + sal_Int32 nMagneticZone( aUIDockingElement.m_bFloating ? MAGNETIC_DISTANCE_DOCK : MAGNETIC_DISTANCE_UNDOCK ); + awt::Rectangle aNewTrackingRect; + ::Rectangle aTrackingRect( e.TrackingRectangle.X, e.TrackingRectangle.Y, + ( e.TrackingRectangle.X + e.TrackingRectangle.Width ), + ( e.TrackingRectangle.Y + e.TrackingRectangle.Height )); + + awt::Rectangle aTmpRect = xTopDockingWindow->getPosSize(); + ::Rectangle aTopDockRect( aTmpRect.X, aTmpRect.Y, aTmpRect.Width, aTmpRect.Height ); + ::Rectangle aHotZoneTopDockRect( implts_calcHotZoneRect( aTopDockRect, nMagneticZone )); + + aTmpRect = xBottomDockingWindow->getPosSize(); + ::Rectangle aBottomDockRect( aTmpRect.X, aTmpRect.Y, ( aTmpRect.X + aTmpRect.Width), ( aTmpRect.Y + aTmpRect.Height )); + ::Rectangle aHotZoneBottomDockRect( implts_calcHotZoneRect( aBottomDockRect, nMagneticZone )); + + aTmpRect = xLeftDockingWindow->getPosSize(); + ::Rectangle aLeftDockRect( aTmpRect.X, aTmpRect.Y, ( aTmpRect.X + aTmpRect.Width ), ( aTmpRect.Y + aTmpRect.Height )); + ::Rectangle aHotZoneLeftDockRect( implts_calcHotZoneRect( aLeftDockRect, nMagneticZone )); + + aTmpRect = xRightDockingWindow->getPosSize(); + ::Rectangle aRightDockRect( aTmpRect.X, aTmpRect.Y, ( aTmpRect.X + aTmpRect.Width ), ( aTmpRect.Y + aTmpRect.Height )); + ::Rectangle aHotZoneRightDockRect( implts_calcHotZoneRect( aRightDockRect, nMagneticZone )); + + Window* pContainerWindow( VCLUnoHelper::GetWindow( xContainerWindow ) ); + Window* pDockingAreaWindow( 0 ); + ::Point aMousePos( pContainerWindow->ScreenToOutputPixel( ::Point( e.MousePos.X, e.MousePos.Y ))); + + if ( aHotZoneTopDockRect.IsInside( aMousePos )) + eDockingArea = ui::DockingArea_DOCKINGAREA_TOP; + else if ( aHotZoneBottomDockRect.IsInside( aMousePos )) + eDockingArea = ui::DockingArea_DOCKINGAREA_BOTTOM; + else if ( aHotZoneLeftDockRect.IsInside( aMousePos )) + eDockingArea = ui::DockingArea_DOCKINGAREA_LEFT; + else if ( aHotZoneRightDockRect.IsInside( aMousePos )) + eDockingArea = ui::DockingArea_DOCKINGAREA_RIGHT; + + // Higher priority for movements inside the real docking area + if ( aTopDockRect.IsInside( aMousePos )) + eDockingArea = ui::DockingArea_DOCKINGAREA_TOP; + else if ( aBottomDockRect.IsInside( aMousePos )) + eDockingArea = ui::DockingArea_DOCKINGAREA_BOTTOM; + else if ( aLeftDockRect.IsInside( aMousePos )) + eDockingArea = ui::DockingArea_DOCKINGAREA_LEFT; + else if ( aRightDockRect.IsInside( aMousePos )) + eDockingArea = ui::DockingArea_DOCKINGAREA_RIGHT; + + // Determine if we have a toolbar and set alignment according to the docking area! + Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); + ToolBox* pToolBox = 0; + if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX ) + pToolBox = (ToolBox *)pWindow; + + if ( eDockingArea != -1 ) + { + if ( eDockingArea == ui::DockingArea_DOCKINGAREA_TOP ) + { + aUIDockingElement.m_aDockedData.m_nDockedArea = ui::DockingArea_DOCKINGAREA_TOP; + aUIDockingElement.m_bFloating = false; + pDockingAreaWindow = VCLUnoHelper::GetWindow( xTopDockingWindow ); + } + else if ( eDockingArea == ui::DockingArea_DOCKINGAREA_BOTTOM ) + { + aUIDockingElement.m_aDockedData.m_nDockedArea = ui::DockingArea_DOCKINGAREA_BOTTOM; + aUIDockingElement.m_bFloating = false; + pDockingAreaWindow = VCLUnoHelper::GetWindow( xBottomDockingWindow ); + } + else if ( eDockingArea == ui::DockingArea_DOCKINGAREA_LEFT ) + { + aUIDockingElement.m_aDockedData.m_nDockedArea = ui::DockingArea_DOCKINGAREA_LEFT; + aUIDockingElement.m_bFloating = false; + pDockingAreaWindow = VCLUnoHelper::GetWindow( xLeftDockingWindow ); + } + else if ( eDockingArea == ui::DockingArea_DOCKINGAREA_RIGHT ) + { + aUIDockingElement.m_aDockedData.m_nDockedArea = ui::DockingArea_DOCKINGAREA_RIGHT; + aUIDockingElement.m_bFloating = false; + pDockingAreaWindow = VCLUnoHelper::GetWindow( xRightDockingWindow ); + } + + ::Point aOutputPos = pContainerWindow->ScreenToOutputPixel( aTrackingRect.TopLeft() ); + aTrackingRect.SetPos( aOutputPos ); + + ::Rectangle aNewDockingRect( aTrackingRect ); + implts_calcDockingPosSize( aUIDockingElement, eDockingOperation, aNewDockingRect, aMousePos ); + + ::Point aScreenPos = pContainerWindow->OutputToScreenPixel( aNewDockingRect.TopLeft() ); + aNewTrackingRect = awt::Rectangle( aScreenPos.X(), aScreenPos.Y(), + aNewDockingRect.getWidth(), aNewDockingRect.getHeight() ); + aDockingData.TrackingRectangle = aNewTrackingRect; + } + else if ( pToolBox && bDockingInProgress ) + { + bool bIsHorizontal = isToolboxHorizontalAligned( pToolBox ); + ::Size aFloatSize = aUIDockingElement.m_aFloatingData.m_aSize; + if ( aFloatSize.Width() > 0 && aFloatSize.Height() > 0 ) + { + aUIDockingElement.m_aFloatingData.m_aPos = pContainerWindow->ScreenToOutputPixel( + ::Point( e.MousePos.X, e.MousePos.Y )); + aDockingData.TrackingRectangle.Height = aFloatSize.Height(); + aDockingData.TrackingRectangle.Width = aFloatSize.Width(); + } + else + { + aFloatSize = pToolBox->CalcWindowSizePixel(); + if ( !bIsHorizontal ) + { + // Floating toolbars are always horizontal aligned! We have to swap + // width/height if we have a vertical aligned toolbar. + sal_Int32 nTemp = aFloatSize.Height(); + aFloatSize.Height() = aFloatSize.Width(); + aFloatSize.Width() = nTemp; + } + + aDockingData.TrackingRectangle.Height = aFloatSize.Height(); + aDockingData.TrackingRectangle.Width = aFloatSize.Width(); + + // For the first time we don't have any data about the floating size of a toolbar. + // We calculate it and store it for later use. + aUIDockingElement.m_aFloatingData.m_aPos = pContainerWindow->ScreenToOutputPixel(::Point( e.MousePos.X, e.MousePos.Y )); + aUIDockingElement.m_aFloatingData.m_aSize = aFloatSize; + aUIDockingElement.m_aFloatingData.m_nLines = pToolBox->GetFloatingLines(); + aUIDockingElement.m_aFloatingData.m_bIsHorizontal = isToolboxHorizontalAligned( pToolBox ); + } + aDockingData.TrackingRectangle.X = e.MousePos.X; + aDockingData.TrackingRectangle.Y = e.MousePos.Y; + } + + aDockingData.bFloating = ( eDockingArea == -1 ); + + // Write current data to the member docking progress data + WriteGuard aWriteLock( m_aLock ); + m_aDockUIElement.m_bFloating = aDockingData.bFloating; + if ( !aDockingData.bFloating ) + { + m_aDockUIElement.m_aDockedData = aUIDockingElement.m_aDockedData; + m_eDockOperation = eDockingOperation; + } + else + m_aDockUIElement.m_aFloatingData = aUIDockingElement.m_aFloatingData; + aWriteLock.unlock(); + } + catch ( uno::Exception& ) {} + } + + return aDockingData; +} + +void SAL_CALL ToolbarLayoutManager::endDocking( const awt::EndDockingEvent& e ) +throw (uno::RuntimeException) +{ + bool bDockingInProgress( false ); + bool bStartDockFloated( false ); + bool bFloating( false ); + UIElement aUIDockingElement; + + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + WriteGuard aWriteLock( m_aLock ); + bDockingInProgress = m_bDockingInProgress; + aUIDockingElement = m_aDockUIElement; + bFloating = aUIDockingElement.m_bFloating; + + UIElement& rUIElement = impl_findToolbar( aUIDockingElement.m_aName ); + if ( rUIElement.m_aName == aUIDockingElement.m_aName ) + { + if ( aUIDockingElement.m_bFloating ) + { + // Write last position into position data + uno::Reference< awt::XWindow > xWindow( aUIDockingElement.m_xUIElement->getRealInterface(), uno::UNO_QUERY ); + rUIElement.m_aFloatingData = aUIDockingElement.m_aFloatingData; + awt::Rectangle aTmpRect = xWindow->getPosSize(); + rUIElement.m_aFloatingData.m_aPos = ::Point( aTmpRect.X, aTmpRect.Y ); + // make changes also for our local data as we use it to make data persistent + aUIDockingElement.m_aFloatingData = rUIElement.m_aFloatingData; + } + else + { + rUIElement.m_aDockedData = aUIDockingElement.m_aDockedData; + rUIElement.m_aFloatingData.m_aSize = aUIDockingElement.m_aFloatingData.m_aSize; + + if ( m_eDockOperation != DOCKOP_ON_COLROW ) + { + // we have to renumber our row/column data to insert a new row/column + implts_renumberRowColumnData((ui::DockingArea)aUIDockingElement.m_aDockedData.m_nDockedArea, m_eDockOperation, aUIDockingElement ); + } + } + + bStartDockFloated = rUIElement.m_bFloating; + rUIElement.m_bFloating = m_aDockUIElement.m_bFloating; + rUIElement.m_bUserActive = true; + } + + // reset member for next docking operation + m_aDockUIElement.m_xUIElement.clear(); + m_eDockOperation = DOCKOP_ON_COLROW; + aWriteLock.unlock(); + /* SAFE AREA ----------------------------------------------------------------------------------------------- */ + + implts_writeWindowStateData( aUIDockingElement ); + + if ( bDockingInProgress ) + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + Window* pWindow = VCLUnoHelper::GetWindow( uno::Reference< awt::XWindow >( e.Source, uno::UNO_QUERY )); + ToolBox* pToolBox = 0; + if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX ) + pToolBox = (ToolBox *)pWindow; + + if ( pToolBox ) + { + if( e.bFloating ) + { + if ( aUIDockingElement.m_aFloatingData.m_bIsHorizontal ) + pToolBox->SetAlign( WINDOWALIGN_TOP ); + else + pToolBox->SetAlign( WINDOWALIGN_LEFT ); + } + else + { + ::Size aSize; + + pToolBox->SetAlign( ImplConvertAlignment( aUIDockingElement.m_aDockedData.m_nDockedArea) ); + + // Docked toolbars have always one line + aSize = pToolBox->CalcWindowSizePixel( 1 ); + + // Lock layouting updates as our listener would be called due to SetSizePixel + pToolBox->SetOutputSizePixel( aSize ); + } + } + } + + implts_sortUIElements(); + + aWriteLock.lock(); + m_bDockingInProgress = sal_False; + m_bLayoutDirty = !bStartDockFloated || !bFloating; + bool bNotify = m_bLayoutDirty; + aWriteLock.unlock(); + + if ( bNotify ) + m_pParentLayouter->requestLayout( ILayoutNotifications::HINT_TOOLBARSPACE_HAS_CHANGED ); +} + +sal_Bool SAL_CALL ToolbarLayoutManager::prepareToggleFloatingMode( const lang::EventObject& e ) +throw (uno::RuntimeException) +{ + ReadGuard aReadLock( m_aLock ); + bool bDockingInProgress = m_bDockingInProgress; + aReadLock.unlock(); + + UIElement aUIDockingElement = implts_findToolbar( e.Source ); + bool bWinFound( aUIDockingElement.m_aName.getLength() > 0 ); + uno::Reference< awt::XWindow > xWindow( e.Source, uno::UNO_QUERY ); + + if ( bWinFound && xWindow.is() ) + { + if ( !bDockingInProgress ) + { + awt::Rectangle aRect; + uno::Reference< awt::XDockableWindow > xDockWindow( xWindow, uno::UNO_QUERY ); + if ( xDockWindow->isFloating() ) + { + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + Window* pWindow = VCLUnoHelper::GetWindow( xWindow ); + if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX ) + { + ToolBox* pToolBox = static_cast< ToolBox *>( pWindow ); + aUIDockingElement.m_aFloatingData.m_aPos = pToolBox->GetPosPixel(); + aUIDockingElement.m_aFloatingData.m_aSize = pToolBox->GetOutputSizePixel(); + aUIDockingElement.m_aFloatingData.m_nLines = pToolBox->GetFloatingLines(); + aUIDockingElement.m_aFloatingData.m_bIsHorizontal = isToolboxHorizontalAligned( pToolBox ); + } + } + + UIElement aUIElement = implts_findToolbar( aUIDockingElement.m_aName ); + if ( aUIElement.m_aName == aUIDockingElement.m_aName ) + implts_setToolbar( aUIDockingElement ); + } + } + } + + return sal_True; +} + +void SAL_CALL ToolbarLayoutManager::toggleFloatingMode( const lang::EventObject& e ) +throw (uno::RuntimeException) +{ + UIElement aUIDockingElement; + + ReadGuard aReadLock( m_aLock ); + bool bDockingInProgress( m_bDockingInProgress ); + if ( bDockingInProgress ) + aUIDockingElement = m_aDockUIElement; + aReadLock.unlock(); + + Window* pWindow( 0 ); + ToolBox* pToolBox( 0 ); + uno::Reference< awt::XWindow2 > xWindow; + + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + xWindow = uno::Reference< awt::XWindow2 >( e.Source, uno::UNO_QUERY ); + pWindow = VCLUnoHelper::GetWindow( xWindow ); + + if ( pWindow && pWindow->GetType() == WINDOW_TOOLBOX ) + pToolBox = (ToolBox *)pWindow; + } + + if ( !bDockingInProgress ) + { + aUIDockingElement = implts_findToolbar( e.Source ); + bool bWinFound = ( aUIDockingElement.m_aName.getLength() > 0 ); + + if ( bWinFound && xWindow.is() ) + { + aUIDockingElement.m_bFloating = !aUIDockingElement.m_bFloating; + aUIDockingElement.m_bUserActive = true; + + implts_setLayoutInProgress( true ); + if ( aUIDockingElement.m_bFloating ) + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + if ( pToolBox ) + { + pToolBox->SetLineCount( aUIDockingElement.m_aFloatingData.m_nLines ); + if ( aUIDockingElement.m_aFloatingData.m_bIsHorizontal ) + pToolBox->SetAlign( WINDOWALIGN_TOP ); + else + pToolBox->SetAlign( WINDOWALIGN_LEFT ); + } + + bool bUndefPos = hasDefaultPosValue( aUIDockingElement.m_aFloatingData.m_aPos ); + bool bSetSize = !hasEmptySize( aUIDockingElement.m_aFloatingData.m_aSize ); + + if ( bUndefPos ) + aUIDockingElement.m_aFloatingData.m_aPos = implts_findNextCascadeFloatingPos(); + + if ( !bSetSize ) + { + if ( pToolBox ) + aUIDockingElement.m_aFloatingData.m_aSize = pToolBox->CalcFloatingWindowSizePixel(); + else + aUIDockingElement.m_aFloatingData.m_aSize = pWindow->GetOutputSizePixel(); + } + + xWindow->setPosSize( aUIDockingElement.m_aFloatingData.m_aPos.X(), + aUIDockingElement.m_aFloatingData.m_aPos.Y(), + 0, 0, awt::PosSize::POS ); + xWindow->setOutputSize( AWTSize( aUIDockingElement.m_aFloatingData.m_aSize ) ); + } + else + { + if ( isDefaultPos( aUIDockingElement.m_aDockedData.m_aPos )) + { + // Docking on its default position without a preset position - + // we have to find a good place for it. + ::Point aPixelPos; + ::Point aDockPos; + ::Size aSize; + + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + if ( pToolBox ) + aSize = pToolBox->CalcWindowSizePixel( 1, ImplConvertAlignment( aUIDockingElement.m_aDockedData.m_nDockedArea ) ); + else + aSize = pWindow->GetSizePixel(); + } + + implts_findNextDockingPos((ui::DockingArea)aUIDockingElement.m_aDockedData.m_nDockedArea, aSize, aDockPos, aPixelPos ); + aUIDockingElement.m_aDockedData.m_aPos = aDockPos; + } + + vos::OGuard aGuard( Application::GetSolarMutex() ); + if ( pToolBox ) + { + pToolBox->SetAlign( ImplConvertAlignment( aUIDockingElement.m_aDockedData.m_nDockedArea) ); + ::Size aSize = pToolBox->CalcWindowSizePixel( 1 ); + awt::Rectangle aRect = xWindow->getPosSize(); + xWindow->setPosSize( aRect.X, aRect.Y, 0, 0, awt::PosSize::POS ); + xWindow->setOutputSize( AWTSize( aSize ) ); + } + } + + implts_setLayoutInProgress( false ); + implts_setToolbar( aUIDockingElement ); + implts_writeWindowStateData( aUIDockingElement ); + implts_sortUIElements(); + implts_setLayoutDirty(); + + aReadLock.lock(); + ILayoutNotifications* pParentLayouter( m_pParentLayouter ); + aReadLock.unlock(); + + if ( pParentLayouter ) + pParentLayouter->requestLayout( ILayoutNotifications::HINT_TOOLBARSPACE_HAS_CHANGED ); + } + } + else + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + if ( pToolBox ) + { + if ( aUIDockingElement.m_bFloating ) + { + if ( aUIDockingElement.m_aFloatingData.m_bIsHorizontal ) + pToolBox->SetAlign( WINDOWALIGN_TOP ); + else + pToolBox->SetAlign( WINDOWALIGN_LEFT ); + } + else + pToolBox->SetAlign( ImplConvertAlignment( aUIDockingElement.m_aDockedData.m_nDockedArea) ); + } + } +} + +void SAL_CALL ToolbarLayoutManager::closed( const lang::EventObject& e ) +throw (uno::RuntimeException) +{ + rtl::OUString aName; + UIElement aUIElement; + UIElementVector::iterator pIter; + + WriteGuard aWriteLock( m_aLock ); + for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) + { + uno::Reference< ui::XUIElement > xUIElement( pIter->m_xUIElement ); + if ( xUIElement.is() ) + { + uno::Reference< uno::XInterface > xIfac( xUIElement->getRealInterface(), uno::UNO_QUERY ); + if ( xIfac == e.Source ) + { + aName = pIter->m_aName; + + // user closes a toolbar => + // context sensitive toolbar: only destroy toolbar and store state. + // context sensitive toolbar: make it invisible, store state and destroy it. + if ( !pIter->m_bContextSensitive ) + pIter->m_bVisible = sal_False; + + aUIElement = *pIter; + break; + } + } + } + aWriteLock.unlock(); + + // destroy element + if ( aName.getLength() > 0 ) + { + implts_writeWindowStateData( aUIElement ); + destroyToolbar( aName ); + } +} + +void SAL_CALL ToolbarLayoutManager::endPopupMode( const awt::EndPopupModeEvent& /*e*/ ) +throw (uno::RuntimeException) +{ +} + +//--------------------------------------------------------------------------------------------------------- +// XUIConfigurationListener +//--------------------------------------------------------------------------------------------------------- +void SAL_CALL ToolbarLayoutManager::elementInserted( const ui::ConfigurationEvent& rEvent ) +throw (uno::RuntimeException) +{ + UIElement aUIElement = implts_findToolbar( rEvent.ResourceURL ); + + uno::Reference< ui::XUIElementSettings > xElementSettings( aUIElement.m_xUIElement, uno::UNO_QUERY ); + if ( xElementSettings.is() ) + { + ::rtl::OUString aConfigSourcePropName( RTL_CONSTASCII_USTRINGPARAM( "ConfigurationSource" )); + uno::Reference< beans::XPropertySet > xPropSet( xElementSettings, uno::UNO_QUERY ); + if ( xPropSet.is() ) + { + if ( rEvent.Source == uno::Reference< uno::XInterface >( m_xDocCfgMgr, uno::UNO_QUERY )) + xPropSet->setPropertyValue( aConfigSourcePropName, makeAny( m_xDocCfgMgr )); + } + xElementSettings->updateSettings(); + } + else + { + ::rtl::OUString aElementType; + ::rtl::OUString aElementName; + parseResourceURL( rEvent.ResourceURL, aElementType, aElementName ); + if ( aElementName.indexOf( m_aCustomTbxPrefix ) != -1 ) + { + // custom toolbar must be directly created, shown and layouted! + createToolbar( rEvent.ResourceURL ); + uno::Reference< ui::XUIElement > xUIElement = getToolbar( rEvent.ResourceURL ); + if ( xUIElement.is() ) + { + ::rtl::OUString aUIName; + uno::Reference< ui::XUIConfigurationManager > xCfgMgr; + uno::Reference< beans::XPropertySet > xPropSet; + + try + { + xCfgMgr = uno::Reference< ui::XUIConfigurationManager >( rEvent.Source, uno::UNO_QUERY ); + xPropSet = uno::Reference< beans::XPropertySet >( xCfgMgr->getSettings( rEvent.ResourceURL, sal_False ), uno::UNO_QUERY ); + + if ( xPropSet.is() ) + xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UIName" ))) >>= aUIName; + } + catch ( container::NoSuchElementException& ) {} + catch ( beans::UnknownPropertyException& ) {} + catch ( lang::WrappedTargetException& ) {} + + { + vos::OGuard aGuard( Application::GetSolarMutex() ); + Window* pWindow = getWindowFromXUIElement( xUIElement ); + if ( pWindow ) + pWindow->SetText( aUIName ); + } + + showToolbar( rEvent.ResourceURL ); + } + } + } +} + +void SAL_CALL ToolbarLayoutManager::elementRemoved( const ui::ConfigurationEvent& rEvent ) +throw (uno::RuntimeException) +{ + ReadGuard aReadLock( m_aLock ); + uno::Reference< awt::XWindow > xContainerWindow( m_xContainerWindow, uno::UNO_QUERY ); + uno::Reference< ui::XUIConfigurationManager > xModuleCfgMgr( m_xModuleCfgMgr ); + uno::Reference< ui::XUIConfigurationManager > xDocCfgMgr( m_xDocCfgMgr ); + aReadLock.unlock(); + + UIElement aUIElement = implts_findToolbar( rEvent.ResourceURL ); + uno::Reference< ui::XUIElementSettings > xElementSettings( aUIElement.m_xUIElement, uno::UNO_QUERY ); + if ( xElementSettings.is() ) + { + bool bNoSettings( false ); + ::rtl::OUString aConfigSourcePropName( RTL_CONSTASCII_USTRINGPARAM( "ConfigurationSource" )); + uno::Reference< uno::XInterface > xElementCfgMgr; + uno::Reference< beans::XPropertySet > xPropSet( xElementSettings, uno::UNO_QUERY ); + + if ( xPropSet.is() ) + xPropSet->getPropertyValue( aConfigSourcePropName ) >>= xElementCfgMgr; + + if ( !xElementCfgMgr.is() ) + return; + + // Check if the same UI configuration manager has changed => check further + if ( rEvent.Source == xElementCfgMgr ) + { + // Same UI configuration manager where our element has its settings + if ( rEvent.Source == uno::Reference< uno::XInterface >( xDocCfgMgr, uno::UNO_QUERY )) + { + // document settings removed + if ( xModuleCfgMgr->hasSettings( rEvent.ResourceURL )) + { + xPropSet->setPropertyValue( aConfigSourcePropName, makeAny( xModuleCfgMgr )); + xElementSettings->updateSettings(); + return; + } + } + + bNoSettings = true; + } + + // No settings anymore, element must be destroyed + if ( xContainerWindow.is() && bNoSettings ) + destroyToolbar( rEvent.ResourceURL ); + } +} + +void SAL_CALL ToolbarLayoutManager::elementReplaced( const ui::ConfigurationEvent& rEvent ) +throw (uno::RuntimeException) +{ + UIElement aUIElement = implts_findToolbar( rEvent.ResourceURL ); + + uno::Reference< ui::XUIElementSettings > xElementSettings( aUIElement.m_xUIElement, uno::UNO_QUERY ); + if ( xElementSettings.is() ) + { + ::rtl::OUString aConfigSourcePropName( RTL_CONSTASCII_USTRINGPARAM( "ConfigurationSource" )); + uno::Reference< uno::XInterface > xElementCfgMgr; + uno::Reference< beans::XPropertySet > xPropSet( xElementSettings, uno::UNO_QUERY ); + + if ( xPropSet.is() ) + xPropSet->getPropertyValue( aConfigSourcePropName ) >>= xElementCfgMgr; + + if ( !xElementCfgMgr.is() ) + return; + + // Check if the same UI configuration manager has changed => update settings + if ( rEvent.Source == xElementCfgMgr ) + { + xElementSettings->updateSettings(); + + WriteGuard aWriteLock( m_aLock ); + bool bNotify = !aUIElement.m_bFloating; + m_bLayoutDirty = bNotify; + ILayoutNotifications* pParentLayouter( m_pParentLayouter ); + aWriteLock.unlock(); + + if ( bNotify && pParentLayouter ) + pParentLayouter->requestLayout( ILayoutNotifications::HINT_TOOLBARSPACE_HAS_CHANGED ); + } + } +} + +uno::Reference< ui::XUIElement > ToolbarLayoutManager::getToolbar( const ::rtl::OUString& aName ) +{ + return implts_findToolbar( aName ).m_xUIElement; +} + +uno::Sequence< uno::Reference< ui::XUIElement > > ToolbarLayoutManager::getToolbars() +{ + uno::Sequence< uno::Reference< ui::XUIElement > > aSeq; + + ReadGuard aReadLock( m_aLock ); + if ( m_aUIElements.size() > 0 ) + { + sal_uInt32 nCount(0); + UIElementVector::iterator pIter; + for ( pIter = m_aUIElements.begin(); pIter != m_aUIElements.end(); pIter++ ) + { + if ( pIter->m_xUIElement.is() ) + { + ++nCount; + aSeq.realloc( nCount ); + aSeq[nCount-1] = pIter->m_xUIElement; + } + } + } + + return aSeq; +} + +bool ToolbarLayoutManager::floatToolbar( const ::rtl::OUString& rResourceURL ) +{ + UIElement aUIElement = implts_findToolbar( rResourceURL ); + if ( aUIElement.m_xUIElement.is() ) + { + try + { + uno::Reference< awt::XDockableWindow > xDockWindow( aUIElement.m_xUIElement->getRealInterface(), uno::UNO_QUERY ); + if ( xDockWindow.is() && !xDockWindow->isFloating() ) + { + aUIElement.m_bFloating = true; + implts_writeWindowStateData( aUIElement ); + xDockWindow->setFloatingMode( true ); + + implts_setLayoutDirty(); + implts_setToolbar( aUIElement ); + return true; + } + } + catch ( lang::DisposedException& ) {} + } + + return false; +} + +bool ToolbarLayoutManager::lockToolbar( const ::rtl::OUString& rResourceURL ) +{ + UIElement aUIElement = implts_findToolbar( rResourceURL ); + if ( aUIElement.m_xUIElement.is() ) + { + try + { + uno::Reference< awt::XDockableWindow > xDockWindow( aUIElement.m_xUIElement->getRealInterface(), uno::UNO_QUERY ); + if ( xDockWindow.is() && !xDockWindow->isFloating() && !xDockWindow->isLocked() ) + { + aUIElement.m_aDockedData.m_bLocked = true; + implts_writeWindowStateData( aUIElement ); + xDockWindow->lock(); + + implts_setLayoutDirty(); + implts_setToolbar( aUIElement ); + return true; + } + } + catch ( lang::DisposedException& ) {} + } + + return false; +} + +bool ToolbarLayoutManager::unlockToolbar( const ::rtl::OUString& rResourceURL ) +{ + UIElement aUIElement = implts_findToolbar( rResourceURL ); + if ( aUIElement.m_xUIElement.is() ) + { + try + { + uno::Reference< awt::XDockableWindow > xDockWindow( aUIElement.m_xUIElement->getRealInterface(), uno::UNO_QUERY ); + if ( xDockWindow.is() && !xDockWindow->isFloating() && xDockWindow->isLocked() ) + { + aUIElement.m_aDockedData.m_bLocked = false; + implts_writeWindowStateData( aUIElement ); + xDockWindow->unlock(); + + implts_setLayoutDirty(); + implts_setToolbar( aUIElement ); + return true; + } + } + catch ( lang::DisposedException& ) {} + } + + return false; +} + +bool ToolbarLayoutManager::isToolbarVisible( const ::rtl::OUString& rResourceURL ) +{ + uno::Reference< awt::XWindow2 > xWindow2( implts_getXWindow( rResourceURL ), uno::UNO_QUERY ); + return ( xWindow2.is() && xWindow2->isVisible() ); +} + +bool ToolbarLayoutManager::isToolbarFloating( const ::rtl::OUString& rResourceURL ) +{ + uno::Reference< awt::XDockableWindow > xDockWindow( implts_getXWindow( rResourceURL ), uno::UNO_QUERY ); + return ( xDockWindow.is() && xDockWindow->isFloating() ); +} + +bool ToolbarLayoutManager::isToolbarDocked( const ::rtl::OUString& rResourceURL ) +{ + return !isToolbarFloating( rResourceURL ); +} + +bool ToolbarLayoutManager::isToolbarLocked( const ::rtl::OUString& rResourceURL ) +{ + uno::Reference< awt::XDockableWindow > xDockWindow( implts_getXWindow( rResourceURL ), uno::UNO_QUERY ); + return ( xDockWindow.is() && xDockWindow->isLocked() ); +} + +awt::Size ToolbarLayoutManager::getToolbarSize( const ::rtl::OUString& rResourceURL ) +{ + Window* pWindow = implts_getWindow( rResourceURL ); + + vos::OGuard aGuard( Application::GetSolarMutex() ); + if ( pWindow ) + { + ::Size aSize = pWindow->GetSizePixel(); + awt::Size aWinSize; + aWinSize.Width = aSize.Width(); + aWinSize.Height = aSize.Height(); + return aWinSize; + } + + return awt::Size(); +} + +awt::Point ToolbarLayoutManager::getToolbarPos( const ::rtl::OUString& rResourceURL ) +{ + awt::Point aPos; + UIElement aUIElement = implts_findToolbar( rResourceURL ); + + uno::Reference< awt::XWindow > xWindow( implts_getXWindow( rResourceURL )); + if ( xWindow.is() ) + { + if ( aUIElement.m_bFloating ) + { + awt::Rectangle aRect = xWindow->getPosSize(); + aPos.X = aRect.X; + aPos.Y = aRect.Y; + } + else + { + ::Point aVirtualPos = aUIElement.m_aDockedData.m_aPos; + aPos.X = aVirtualPos.X(); + aPos.Y = aVirtualPos.Y(); + } + } + + return aPos; +} + +void ToolbarLayoutManager::setToolbarSize( const ::rtl::OUString& rResourceURL, const awt::Size& aSize ) +{ + uno::Reference< awt::XWindow2 > xWindow( implts_getXWindow( rResourceURL ), uno::UNO_QUERY ); + uno::Reference< awt::XDockableWindow > xDockWindow( xWindow, uno::UNO_QUERY ); + UIElement aUIElement = implts_findToolbar( rResourceURL ); + + if ( xWindow.is() && xDockWindow.is() && xDockWindow->isFloating() ) + { + xWindow->setOutputSize( aSize ); + aUIElement.m_aFloatingData.m_aSize = ::Size( aSize.Width, aSize.Height ); + implts_setToolbar( aUIElement ); + implts_writeWindowStateData( aUIElement ); + implts_sortUIElements(); + } +} + +void ToolbarLayoutManager::setToolbarPos( const ::rtl::OUString& rResourceURL, const awt::Point& aPos ) +{ + uno::Reference< awt::XWindow > xWindow( implts_getXWindow( rResourceURL )); + uno::Reference< awt::XDockableWindow > xDockWindow( xWindow, uno::UNO_QUERY ); + UIElement aUIElement = implts_findToolbar( rResourceURL ); + + if ( xWindow.is() && xDockWindow.is() && xDockWindow->isFloating() ) + { + xWindow->setPosSize( aPos.X, aPos.Y, 0, 0, awt::PosSize::POS ); + aUIElement.m_aFloatingData.m_aPos = ::Point( aPos.X, aPos.Y ); + implts_setToolbar( aUIElement ); + implts_writeWindowStateData( aUIElement ); + implts_sortUIElements(); + } +} + +void ToolbarLayoutManager::setToolbarPosSize( const ::rtl::OUString& rResourceURL, const awt::Point& aPos, const awt::Size& aSize ) +{ + setToolbarPos( rResourceURL, aPos ); + setToolbarSize( rResourceURL, aSize ); +} + +} // namespace framework diff --git a/framework/source/layoutmanager/toolbarlayoutmanager.hxx b/framework/source/layoutmanager/toolbarlayoutmanager.hxx new file mode 100755 index 0000000000..5b3f62d8a7 --- /dev/null +++ b/framework/source/layoutmanager/toolbarlayoutmanager.hxx @@ -0,0 +1,344 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2008 by Sun Microsystems, Inc. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: layoutmanager.hxx,v $ + * $Revision: 1.34 $ + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#ifndef __FRAMEWORK_LAYOUTMANAGER_TOOLBARLAYOUTMANAGER_HXX_ +#define __FRAMEWORK_LAYOUTMANAGER_TOOLBARLAYOUTMANAGER_HXX_ + +/** Attention: stl headers must(!) be included at first. Otherwhise it can make trouble + with solaris headers ... +*/ +#include <vector> + +//_________________________________________________________________________________________________________________ +// my own includes +//_________________________________________________________________________________________________________________ +#include <threadhelp/threadhelpbase.hxx> +#include <threadhelp/resetableguard.hxx> +#include <threadhelp/writeguard.hxx> +#include <threadhelp/readguard.hxx> +#include <macros/generic.hxx> +#include <macros/xinterface.hxx> +#include <macros/xtypeprovider.hxx> +#include <macros/xserviceinfo.hxx> +#include <stdtypes.h> +#include <properties.h> +#include <stdtypes.h> +#include <uiconfiguration/globalsettings.hxx> +#include <uiconfiguration/windowstateconfiguration.hxx> +#include <classes/addonsoptions.hxx> +#include <uielement/uielement.hxx> +#include <helper/ilayoutnotifications.hxx> + +//_________________________________________________________________________________________________________________ +// interface includes +//_________________________________________________________________________________________________________________ +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/lang/XTypeProvider.hpp> +#include <com/sun/star/frame/XLayoutManager.hpp> +#include <com/sun/star/ui/XUIConfigurationManager.hpp> +#include <com/sun/star/ui/XUIConfiguration.hpp> +#include <com/sun/star/frame/XModuleManager.hpp> +#include <com/sun/star/frame/XFrameActionListener.hpp> +#include <com/sun/star/awt/XWindowListener.hpp> +#include <com/sun/star/util/XURLTransformer.hpp> +#include <com/sun/star/ui/XUIElementFactory.hpp> +#include <com/sun/star/ui/DockingArea.hpp> +#include <com/sun/star/awt/XTopWindow2.hpp> +#include <com/sun/star/awt/XWindow2.hpp> +#include <com/sun/star/awt/XDockableWindow.hpp> +#include <com/sun/star/awt/XDockableWindowListener.hpp> + +//_________________________________________________________________________________________________________________ +// other includes +//_________________________________________________________________________________________________________________ + +#include <cppuhelper/implbase3.hxx> + + +namespace framework +{ + +class ToolbarLayoutManager : public ::cppu::WeakImplHelper3< ::com::sun::star::awt::XDockableWindowListener, + ::com::sun::star::ui::XUIConfigurationListener, + ::com::sun::star::awt::XWindowListener >, + private ThreadHelpBase // Struct for right initalization of mutex member! Must be first of baseclasses. +{ + public: + enum { DOCKINGAREAS_COUNT = 4 }; + + ToolbarLayoutManager( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& xSMGR, + const ::com::sun::star::uno::Reference< ::com::sun::star::ui::XUIElementFactory >& xUIElementFactory, + ILayoutNotifications* pParentLayouter ); + virtual ~ToolbarLayoutManager(); + + void reset(); + void attach( const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& xFrame, + const ::com::sun::star::uno::Reference< ::com::sun::star::ui::XUIConfigurationManager >& xModuleCfgMgr, + const ::com::sun::star::uno::Reference< ::com::sun::star::ui::XUIConfigurationManager >& xDocCfgMgr, + const ::com::sun::star::uno::Reference< ::com::sun::star::container::XNameAccess >& xPersistentWindowState ); + + void setParentWindow( const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindowPeer >& xParentWindow ); + void setDockingAreaOffsets( const ::Rectangle aOffsets ); + + void resetDockingArea(); + + ::com::sun::star::awt::Rectangle getDockingArea(); + void setDockingArea( const ::com::sun::star::awt::Rectangle& rDockingArea ); + + // layouting + bool isLayoutDirty(); + void doLayout(const ::Size& aContainerSize); + + // creation/destruction + void createStaticToolbars(); + void destroyToolbars(); + + bool requestToolbar( const ::rtl::OUString& rResourceURL ); + bool createToolbar( const ::rtl::OUString& rResourceURL ); + bool destroyToolbar( const ::rtl::OUString& rResourceURL ); + + // visibility + bool showToolbar( const ::rtl::OUString& rResourceURL ); + bool hideToolbar( const ::rtl::OUString& rResourceURL ); + + void refreshToolbarsVisibility(); + void setFloatingToolbarsVisibility( bool bVisible ); + void setVisible(bool bVisible); + bool isVisible() { return m_bVisible; } + + // docking and further functions + bool dockToolbar( const ::rtl::OUString& rResourceURL, ::com::sun::star::ui::DockingArea eDockingArea, const ::com::sun::star::awt::Point& aPos ); + bool dockAllToolbars(); + bool floatToolbar( const ::rtl::OUString& rResoureURL ); + bool lockToolbar( const ::rtl::OUString& rResourceURL ); + bool unlockToolbar( const ::rtl::OUString& rResourceURL ); + void setToolbarPos( const ::rtl::OUString& rResourceURL, const ::com::sun::star::awt::Point& aPos ); + void setToolbarSize( const ::rtl::OUString& rResourceURL, const ::com::sun::star::awt::Size& aSize ); + void setToolbarPosSize( const ::rtl::OUString& rResourceURL, const ::com::sun::star::awt::Point& aPos, const ::com::sun::star::awt::Size& aSize ); + bool isToolbarVisible( const ::rtl::OUString& rResourceURL ); + bool isToolbarFloating( const ::rtl::OUString& rResourceURL ); + bool isToolbarDocked( const ::rtl::OUString& rResourceURL ); + bool isToolbarLocked( const ::rtl::OUString& rResourceURL ); + ::com::sun::star::awt::Point getToolbarPos( const ::rtl::OUString& rResourceURL ); + ::com::sun::star::awt::Size getToolbarSize( const ::rtl::OUString& rResourceURL ); + ::com::sun::star::uno::Reference< ::com::sun::star::ui::XUIElement > getToolbar( const ::rtl::OUString& aName ); + ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Reference< ::com::sun::star::ui::XUIElement > > getToolbars(); + + // child window notifications + long childWindowEvent( VclSimpleEvent* pEvent ); + + //--------------------------------------------------------------------------------------------------------- + // XInterface + //--------------------------------------------------------------------------------------------------------- + virtual void SAL_CALL acquire() throw(); + virtual void SAL_CALL release() throw(); + virtual ::com::sun::star::uno::Any SAL_CALL queryInterface( const ::com::sun::star::uno::Type & rType ) throw( ::com::sun::star::uno::RuntimeException ); + + //--------------------------------------------------------------------------------------------------------- + // XEventListener + //--------------------------------------------------------------------------------------------------------- + virtual void SAL_CALL disposing( const css::lang::EventObject& aEvent ) throw( css::uno::RuntimeException ); + + //--------------------------------------------------------------------------------------------------------- + // XWindowListener + //--------------------------------------------------------------------------------------------------------- + virtual void SAL_CALL windowResized( const css::awt::WindowEvent& aEvent ) throw( css::uno::RuntimeException ); + virtual void SAL_CALL windowMoved( const css::awt::WindowEvent& aEvent ) throw( css::uno::RuntimeException ); + virtual void SAL_CALL windowShown( const css::lang::EventObject& aEvent ) throw( css::uno::RuntimeException ); + virtual void SAL_CALL windowHidden( const css::lang::EventObject& aEvent ) throw( css::uno::RuntimeException ); + + //--------------------------------------------------------------------------------------------------------- + // XDockableWindowListener + //--------------------------------------------------------------------------------------------------------- + virtual void SAL_CALL startDocking( const ::com::sun::star::awt::DockingEvent& e ) throw (::com::sun::star::uno::RuntimeException); + virtual ::com::sun::star::awt::DockingData SAL_CALL docking( const ::com::sun::star::awt::DockingEvent& e ) throw (::com::sun::star::uno::RuntimeException); + virtual void SAL_CALL endDocking( const ::com::sun::star::awt::EndDockingEvent& e ) throw (::com::sun::star::uno::RuntimeException); + virtual sal_Bool SAL_CALL prepareToggleFloatingMode( const ::com::sun::star::lang::EventObject& e ) throw (::com::sun::star::uno::RuntimeException); + virtual void SAL_CALL toggleFloatingMode( const ::com::sun::star::lang::EventObject& e ) throw (::com::sun::star::uno::RuntimeException); + virtual void SAL_CALL closed( const ::com::sun::star::lang::EventObject& e ) throw (::com::sun::star::uno::RuntimeException); + virtual void SAL_CALL endPopupMode( const ::com::sun::star::awt::EndPopupModeEvent& e ) throw (::com::sun::star::uno::RuntimeException); + + //--------------------------------------------------------------------------------------------------------- + // XUIConfigurationListener + //--------------------------------------------------------------------------------------------------------- + virtual void SAL_CALL elementInserted( const ::com::sun::star::ui::ConfigurationEvent& Event ) throw (::com::sun::star::uno::RuntimeException); + virtual void SAL_CALL elementRemoved( const ::com::sun::star::ui::ConfigurationEvent& Event ) throw (::com::sun::star::uno::RuntimeException); + virtual void SAL_CALL elementReplaced( const ::com::sun::star::ui::ConfigurationEvent& Event ) throw (::com::sun::star::uno::RuntimeException); + + private: + enum DockingOperation + { + DOCKOP_BEFORE_COLROW, + DOCKOP_ON_COLROW, + DOCKOP_AFTER_COLROW + }; + + typedef std::vector< UIElement > UIElementVector; + struct SingleRowColumnWindowData + { + SingleRowColumnWindowData() : nVarSize( 0 ), nStaticSize( 0 ), nSpace( 0 ) {} + + std::vector< rtl::OUString > aUIElementNames; + std::vector< ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > > aRowColumnWindows; + std::vector< ::com::sun::star::awt::Rectangle > aRowColumnWindowSizes; + std::vector< sal_Int32 > aRowColumnSpace; + ::com::sun::star::awt::Rectangle aRowColumnRect; + sal_Int32 nVarSize; + sal_Int32 nStaticSize; + sal_Int32 nSpace; + sal_Int32 nRowColumn; + }; + + //--------------------------------------------------------------------------------------------------------- + // internal helper methods + //--------------------------------------------------------------------------------------------------------- + bool implts_isParentWindowVisible() const; + ::Rectangle implts_calcDockingArea(); + void implts_sortUIElements(); + void implts_reparentToolbars(); + rtl::OUString implts_generateGenericAddonToolbarTitle( sal_Int32 nNumber ) const; + void implts_setElementData( UIElement& rUIElement, const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XDockableWindow >& rDockWindow ); + void implts_destroyDockingAreaWindows(); + + //--------------------------------------------------------------------------------------------------------- + // layout methods + //--------------------------------------------------------------------------------------------------------- + void implts_setDockingAreaWindowSizes( const ::com::sun::star::awt::Rectangle& rBorderSpace ); + ::Point implts_findNextCascadeFloatingPos(); + void implts_renumberRowColumnData( ::com::sun::star::ui::DockingArea eDockingArea, DockingOperation eDockingOperation, const UIElement& rUIElement ); + void implts_calcWindowPosSizeOnSingleRowColumn( sal_Int32 nDockingArea, + sal_Int32 nOffset, + SingleRowColumnWindowData& rRowColumnWindowData, + const ::Size& rContainerSize ); + void implts_setLayoutDirty(); + void implts_setLayoutInProgress( bool bInProgress = true ); + bool implts_isLayoutInProgress() const { return m_bLayoutInProgress; } + + //--------------------------------------------------------------------------------------------------------- + // lookup/container methods + //--------------------------------------------------------------------------------------------------------- + UIElement implts_findToolbar( const rtl::OUString& aName ); + UIElement implts_findToolbar( const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >& xToolbar ); + UIElement& impl_findToolbar( const rtl::OUString& aName ); + ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow > implts_getXWindow( const ::rtl::OUString& aName ); + Window* implts_getWindow( const ::rtl::OUString& aName ); + bool implts_insertToolbar( const UIElement& rUIElement ); + void implts_setToolbar( const UIElement& rUIElement ); + ::Size implts_getTopBottomDockingAreaSizes(); + void implts_getUIElementVectorCopy( UIElementVector& rCopy ); + + //--------------------------------------------------------------------------------------------------------- + // internal docking methods + //--------------------------------------------------------------------------------------------------------- + ::Rectangle implts_calcHotZoneRect( const ::Rectangle& rRect, sal_Int32 nHotZoneOffset ); + void implts_calcDockingPosSize( UIElement& aUIElement, DockingOperation& eDockOperation, ::Rectangle& rTrackingRect, const Point& rMousePos ); + DockingOperation implts_determineDockingOperation( ::com::sun::star::ui::DockingArea DockingArea, const ::Rectangle& rRowColRect, const Point& rMousePos ); + ::Rectangle implts_getWindowRectFromRowColumn( ::com::sun::star::ui::DockingArea DockingArea, const SingleRowColumnWindowData& rRowColumnWindowData, const ::Point& rMousePos, const rtl::OUString& rExcludeElementName ); + ::Rectangle implts_determineFrontDockingRect( ::com::sun::star::ui::DockingArea eDockingArea, + sal_Int32 nRowCol, + const ::Rectangle& rDockedElementRect, + const ::rtl::OUString& rMovedElementName, + const ::Rectangle& rMovedElementRect ); + ::Rectangle implts_calcTrackingAndElementRect( ::com::sun::star::ui::DockingArea eDockingArea, + sal_Int32 nRowCol, + UIElement& rUIElement, + const ::Rectangle& rTrackingRect, + const ::Rectangle& rRowColumnRect, + const ::Size& rContainerWinSize ); + + void implts_getDockingAreaElementInfos( ::com::sun::star::ui::DockingArea DockingArea, std::vector< SingleRowColumnWindowData >& rRowColumnsWindowData ); + void implts_getDockingAreaElementInfoOnSingleRowCol( ::com::sun::star::ui::DockingArea, sal_Int32 nRowCol, SingleRowColumnWindowData& rRowColumnWindowData ); + void implts_findNextDockingPos( ::com::sun::star::ui::DockingArea DockingArea, const ::Size& aUIElementSize, ::Point& rVirtualPos, ::Point& rPixelPos ); + void implts_setTrackingRect( ::com::sun::star::ui::DockingArea eDockingArea, const ::Point& rMousePos, ::Rectangle& rTrackingRect ); + + //--------------------------------------------------------------------------------------------------------- + // creation methods + //--------------------------------------------------------------------------------------------------------- + void implts_createAddonsToolBars(); + void implts_createCustomToolBars(); + void implts_createNonContextSensitiveToolBars(); + void implts_createCustomToolBars( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< ::com::sun::star::beans::PropertyValue > >& aCustomTbxSeq ); + void implts_createCustomToolBar( const rtl::OUString& aTbxResName, const rtl::OUString& aTitle ); + void implts_createToolBar( const ::rtl::OUString& aName, bool& bNotify, ::com::sun::star::uno::Reference< ::com::sun::star::ui::XUIElement >& rUIElement ); + css::uno::Reference< css::ui::XUIElement > implts_createElement( const ::rtl::OUString& aName ); + void implts_setToolbarCreation( bool bStart = true ); + bool implts_isToolbarCreationActive(); + + //--------------------------------------------------------------------------------------------------------- + // persistence methods + //--------------------------------------------------------------------------------------------------------- + sal_Bool implts_readWindowStateData( const rtl::OUString& aName, UIElement& rElementData ); + void implts_writeWindowStateData( const UIElement& rElementData ); + void implts_writeNewWindowStateData( const rtl::OUString aName, const ::com::sun::star::uno::Reference< ::com::sun::star::awt::XWindow >& xWindow ); + + //--------------------------------------------------------------------------------------------------------- + // members + //--------------------------------------------------------------------------------------------------------- + css::uno::Reference< css::lang::XMultiServiceFactory > m_xSMGR; + css::uno::Reference< css::frame::XFrame > m_xFrame; + css::uno::Reference< css::awt::XWindow2 > m_xContainerWindow; + css::uno::Reference< css::awt::XWindow > m_xDockAreaWindows[DOCKINGAREAS_COUNT]; + css::uno::Reference< ::com::sun::star::ui::XUIElementFactory > m_xUIElementFactoryManager; + css::uno::Reference< ::com::sun::star::ui::XUIConfigurationManager > m_xModuleCfgMgr; + css::uno::Reference< ::com::sun::star::ui::XUIConfigurationManager > m_xDocCfgMgr; + css::uno::Reference< ::com::sun::star::awt::XToolkit > m_xToolkit; + css::uno::Reference< ::com::sun::star::container::XNameAccess > m_xPersistentWindowState; + ILayoutNotifications* m_pParentLayouter; + + UIElementVector m_aUIElements; + UIElement m_aDockUIElement; + Point m_aStartDockMousePos; + Rectangle m_aDockingArea; + Rectangle m_aDockingAreaOffsets; + DockingOperation m_eDockOperation; + + AddonsOptions* m_pAddonOptions; + GlobalSettings* m_pGlobalSettings; + + bool m_bComponentAttached; + bool m_bMustLayout; + bool m_bLayoutDirty; + bool m_bStoreWindowState; + bool m_bGlobalSettings; + bool m_bDockingInProgress; + bool m_bVisible; + bool m_bLayoutInProgress; + bool m_bToolbarCreation; + + ::rtl::OUString m_aFullAddonTbxPrefix; + ::rtl::OUString m_aCustomTbxPrefix; + ::rtl::OUString m_aCustomizeCmd; + ::rtl::OUString m_aToolbarTypeString; + ::rtl::OUString m_aModuleIdentifier; +}; + +} // namespace framework + +#endif // __FRAMEWORK_LAYOUTMANAGER_TOOLBARLAYOUTMANAGER_HXX_ diff --git a/framework/source/layoutmanager/uielement.cxx b/framework/source/layoutmanager/uielement.cxx new file mode 100755 index 0000000000..df635c37fd --- /dev/null +++ b/framework/source/layoutmanager/uielement.cxx @@ -0,0 +1,156 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2008 by Sun Microsystems, Inc. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: layoutmanager.hxx,v $ + * $Revision: 1.34 $ + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_framework.hxx" + +//_________________________________________________________________________________________________________________ +// my own includes +//_________________________________________________________________________________________________________________ + +#include <uielement/uielement.hxx> + +//_________________________________________________________________________________________________________________ +// interface includes +//_________________________________________________________________________________________________________________ + +#include <com/sun/star/ui/DockingArea.hpp> + +//_________________________________________________________________________________________________________________ +// namespace +//_________________________________________________________________________________________________________________ + +using namespace ::com::sun::star; + +namespace framework +{ + + bool UIElement::operator< ( const ::framework::UIElement& aUIElement ) const +{ + if ( !m_xUIElement.is() && aUIElement.m_xUIElement.is() ) + return false; + else if ( m_xUIElement.is() && !aUIElement.m_xUIElement.is() ) + return true; + else if ( !m_bVisible && aUIElement.m_bVisible ) + return false; + else if ( m_bVisible && !aUIElement.m_bVisible ) + return true; + else if ( !m_bFloating && aUIElement.m_bFloating ) + return true; + else if ( m_bFloating && !aUIElement.m_bFloating ) + return false; + else + { + if ( m_bFloating ) + { + bool bEqual = ( m_aFloatingData.m_aPos.Y() == aUIElement.m_aFloatingData.m_aPos.Y() ); + if ( bEqual ) + return ( m_aFloatingData.m_aPos.X() < aUIElement.m_aFloatingData.m_aPos.X() ); + else + return ( m_aFloatingData.m_aPos.Y() < aUIElement.m_aFloatingData.m_aPos.Y() ); + } + else + { + if ( m_aDockedData.m_nDockedArea < aUIElement.m_aDockedData.m_nDockedArea ) + return true; + else if ( m_aDockedData.m_nDockedArea > aUIElement.m_aDockedData.m_nDockedArea ) + return false; + else + { + if ( m_aDockedData.m_nDockedArea == ui::DockingArea_DOCKINGAREA_TOP || + m_aDockedData.m_nDockedArea == ui::DockingArea_DOCKINGAREA_BOTTOM ) + { + if ( !( m_aDockedData.m_aPos.Y() == aUIElement.m_aDockedData.m_aPos.Y() ) ) + return ( m_aDockedData.m_aPos.Y() < aUIElement.m_aDockedData.m_aPos.Y() ); + else + { + bool bEqual = ( m_aDockedData.m_aPos.X() == aUIElement.m_aDockedData.m_aPos.X() ); + if ( bEqual ) + { + if ( m_bUserActive && !aUIElement.m_bUserActive ) + return sal_True; + else if ( !m_bUserActive && aUIElement.m_bUserActive ) + return sal_False; + else + return sal_False; + } + else + return ( m_aDockedData.m_aPos.X() <= aUIElement.m_aDockedData.m_aPos.X() ); + } + } + else + { + if ( !( m_aDockedData.m_aPos.X() == aUIElement.m_aDockedData.m_aPos.X() ) ) + return ( m_aDockedData.m_aPos.X() < aUIElement.m_aDockedData.m_aPos.X() ); + else + { + bool bEqual = ( m_aDockedData.m_aPos.Y() == aUIElement.m_aDockedData.m_aPos.Y() ); + if ( bEqual ) + { + if ( m_bUserActive && !aUIElement.m_bUserActive ) + return sal_True; + else if ( !m_bUserActive && aUIElement.m_bUserActive ) + return sal_False; + else + return sal_False; + } + else + return ( m_aDockedData.m_aPos.Y() <= aUIElement.m_aDockedData.m_aPos.Y() ); + } + } + } + } + } +} + +UIElement& UIElement::operator= ( const UIElement& rUIElement ) +{ + m_aType = rUIElement.m_aType; + m_aName = rUIElement.m_aName; + m_aUIName = rUIElement.m_aUIName; + m_xUIElement = rUIElement.m_xUIElement; + m_bFloating = rUIElement.m_bFloating; + m_bVisible = rUIElement.m_bVisible; + m_bUserActive = rUIElement.m_bUserActive; + m_bCreateNewRowCol0 = rUIElement.m_bCreateNewRowCol0; + m_bDeactiveHide = rUIElement.m_bDeactiveHide; + m_bMasterHide = rUIElement.m_bMasterHide; + m_bContextSensitive = rUIElement.m_bContextSensitive; + m_bContextActive = rUIElement.m_bContextActive; + m_bNoClose = rUIElement.m_bNoClose; + m_bSoftClose = rUIElement.m_bSoftClose; + m_bStateRead = rUIElement.m_bStateRead; + m_nStyle = rUIElement.m_nStyle; + m_aDockedData = rUIElement.m_aDockedData; + m_aFloatingData = rUIElement.m_aFloatingData; + return *this; +} + +} // namespace framework diff --git a/framework/source/services/makefile.mk b/framework/source/services/makefile.mk index 2978d9aacf..eaeaae1f8a 100644 --- a/framework/source/services/makefile.mk +++ b/framework/source/services/makefile.mk @@ -53,7 +53,8 @@ SLOFILES=\ $(SLO)$/sessionlistener.obj \ $(SLO)$/taskcreatorsrv.obj \ $(SLO)$/uriabbreviation.obj \ - $(SLO)$/tabwindowservice.obj + $(SLO)$/tabwindowservice.obj \ + $(SLO)$/modelwinservice.obj SRS1NAME=$(TARGET) SRC1FILES= fwk_services.src diff --git a/framework/source/services/modelwinservice.cxx b/framework/source/services/modelwinservice.cxx new file mode 100755 index 0000000000..8c422db2aa --- /dev/null +++ b/framework/source/services/modelwinservice.cxx @@ -0,0 +1,279 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2008 by Sun Microsystems, Inc. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * $RCSfile: urltransformer.cxx,v $ + * $Revision: 1.17 $ + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_framework.hxx" + +//_________________________________________________________________________________________________________________ +// my own includes +//_________________________________________________________________________________________________________________ + +#include "services.h" +#include "services/modelwinservice.hxx" + +//_________________________________________________________________________________________________________________ +// interface includes +//_________________________________________________________________________________________________________________ + +#include <com/sun/star/awt/XControlModel.hpp> + +using namespace ::com::sun::star; + +//_________________________________________________________________________________________________________________ +// namespace +//_________________________________________________________________________________________________________________ + +namespace framework{ + +//_________________________________________________________________________________________________________________ +// non exported definitions +//_________________________________________________________________________________________________________________ + +//_________________________________________________________________________________________________________________ +// declarations +//_________________________________________________________________________________________________________________ + +class Impl_ModelWinService +{ + public: + ~Impl_ModelWinService(); + + static Impl_ModelWinService* getSingleInstance( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& rServiceManager ); + + uno::Any getByName( const ::rtl::OUString& sName ) + throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException ); + + uno::Sequence< ::rtl::OUString > getElementNames() + throw( uno::RuntimeException ); + + sal_Bool hasByName( const ::rtl::OUString& sName ) + throw( uno::RuntimeException ); + + uno::Type getElementType() + throw( css::uno::RuntimeException ); + + sal_Bool hasElements() + throw( css::uno::RuntimeException ); + + void registerModelForXWindow( const uno::Reference< awt::XWindow >& rWindow, const uno::Reference< awt::XControlModel >& rModel ); + + void deregisterModelForXWindow( const uno::Reference< awt::XWindow >& rWindow ); + + private: + typedef BaseHash< uno::WeakReference< awt::XControlModel > > ModelWinMap; + + Impl_ModelWinService(); + Impl_ModelWinService( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& rServiceManager ); + + static Impl_ModelWinService* m_pModelWinService; + + ::com::sun::star::uno::WeakReference< ::com::sun::star::lang::XMultiServiceFactory > m_xServiceManager; + ModelWinMap m_aModelMap; +}; + +Impl_ModelWinService* Impl_ModelWinService::m_pModelWinService = 0; + +Impl_ModelWinService* Impl_ModelWinService::getSingleInstance( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& rServiceManager ) +{ + osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ; + if ( !m_pModelWinService ) + m_pModelWinService = new Impl_ModelWinService( rServiceManager ); + return m_pModelWinService; +} + +Impl_ModelWinService::Impl_ModelWinService( const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& rServiceManager ) : + m_xServiceManager( rServiceManager ) +{ +} + +Impl_ModelWinService::Impl_ModelWinService() +{ +} + +Impl_ModelWinService::~Impl_ModelWinService() +{ +} + +void Impl_ModelWinService::registerModelForXWindow( const uno::Reference< awt::XWindow >& rWindow, const uno::Reference< awt::XControlModel >& rModel ) +{ + osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ; + + ::rtl::OUString sName = rtl::OUString::valueOf( reinterpret_cast< sal_Int64 >((void*)rWindow.get())); + ModelWinMap::iterator pIter = m_aModelMap.find( sName ); + if ( pIter != m_aModelMap.end() ) + pIter->second = rModel; + else + m_aModelMap[sName] = rModel; +} + +void Impl_ModelWinService::deregisterModelForXWindow( const uno::Reference< awt::XWindow >& /*rWindow*/ ) +{ +} + +uno::Any Impl_ModelWinService::getByName( const ::rtl::OUString& sName ) +throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException ) +{ + uno::Any aAny; + + osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ; + ModelWinMap::iterator pIter = m_aModelMap.find( sName ); + if ( pIter != m_aModelMap.end()) + { + uno::Reference< awt::XControlModel > xModel( pIter->second ); + aAny = uno::makeAny(xModel); + } + + return aAny; +} + +uno::Sequence< ::rtl::OUString > Impl_ModelWinService::getElementNames() +throw( uno::RuntimeException ) +{ + osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ; + uno::Sequence< ::rtl::OUString > aResult( m_aModelMap.size() ); + + sal_Int32 i = 0; + ModelWinMap::const_iterator pIter = m_aModelMap.begin(); + while ( pIter != m_aModelMap.end()) + aResult[i++] = pIter->first; + + return aResult; +} + +sal_Bool Impl_ModelWinService::hasByName( const ::rtl::OUString& sName ) +throw( uno::RuntimeException ) +{ + osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ; + ModelWinMap::iterator pIter = m_aModelMap.find( sName ); + if ( pIter != m_aModelMap.end()) + return true; + else + return false; +} + +uno::Type Impl_ModelWinService::getElementType() +throw( css::uno::RuntimeException ) +{ + return ::getCppuType(( const uno::Reference< awt::XControlModel >*)NULL ); +} + +sal_Bool Impl_ModelWinService::hasElements() +throw( css::uno::RuntimeException ) +{ + osl::MutexGuard aGuard( osl::Mutex::getGlobalMutex() ) ; + return (m_aModelMap.size() > 0); +} + +//***************************************************************************************************************** +// css::uno::XInterface, XTypeProvider, XServiceInfo +//***************************************************************************************************************** + +DEFINE_XINTERFACE_4 ( ModelWinService , + OWeakObject , + DIRECT_INTERFACE(css::lang::XTypeProvider ), + DIRECT_INTERFACE(css::lang::XServiceInfo ), + DIRECT_INTERFACE(css::container::XNameAccess ), + DIRECT_INTERFACE(css::container::XElementAccess ) + ) + +DEFINE_XTYPEPROVIDER_4 ( ModelWinService , + css::lang::XTypeProvider , + css::lang::XServiceInfo , + css::container::XNameAccess , + css::container::XElementAccess + ) + +DEFINE_XSERVICEINFO_MULTISERVICE ( ModelWinService , + OWeakObject , + SERVICENAME_MODELWINSERVICE , + IMPLEMENTATIONNAME_MODELWINSERVICE + ) + +DEFINE_INIT_SERVICE ( ModelWinService, + { + } + ) + +//***************************************************************************************************************** +// constructor +//***************************************************************************************************************** +ModelWinService::ModelWinService(const uno::Reference< lang::XMultiServiceFactory >& rServiceManager ) : + m_xServiceManager( rServiceManager ) +{ +} + +ModelWinService::~ModelWinService() +{ +} + +void ModelWinService::registerModelForXWindow( const uno::Reference< awt::XWindow >& rWindow, const uno::Reference< awt::XControlModel >& rModel ) +{ + Impl_ModelWinService::getSingleInstance(m_xServiceManager)->registerModelForXWindow( rWindow, rModel ); +} + +void ModelWinService::deregisterModelForXWindow( const uno::Reference< awt::XWindow >& rWindow ) +{ + Impl_ModelWinService::getSingleInstance(m_xServiceManager)->deregisterModelForXWindow( rWindow ); +} + +uno::Any SAL_CALL ModelWinService::getByName( const ::rtl::OUString& sName ) +throw( container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException ) +{ + return Impl_ModelWinService::getSingleInstance(m_xServiceManager)->getByName( sName ); +} + +uno::Sequence< ::rtl::OUString > SAL_CALL ModelWinService::getElementNames() +throw( uno::RuntimeException ) +{ + return Impl_ModelWinService::getSingleInstance(m_xServiceManager)->getElementNames( ); +} + +sal_Bool SAL_CALL ModelWinService::hasByName( const ::rtl::OUString& sName ) +throw( uno::RuntimeException ) +{ + return Impl_ModelWinService::getSingleInstance(m_xServiceManager)->hasByName( sName ); +} + +//--------------------------------------------------------------------------------------------------------- +// XElementAccess +//--------------------------------------------------------------------------------------------------------- +uno::Type SAL_CALL ModelWinService::getElementType() +throw( uno::RuntimeException ) +{ + return ::getCppuType( (const uno::Reference< awt::XControlModel > *)NULL ); +} + +sal_Bool SAL_CALL ModelWinService::hasElements() +throw( uno::RuntimeException ) +{ + return Impl_ModelWinService::getSingleInstance(m_xServiceManager)->hasElements(); +} + +} diff --git a/framework/source/uielement/makefile.mk b/framework/source/uielement/makefile.mk index b74adb1e17..0acfa6b662 100644 --- a/framework/source/uielement/makefile.mk +++ b/framework/source/uielement/makefile.mk @@ -81,6 +81,8 @@ SLOFILES= \ $(SLO)$/toolbarwrapper.obj \ $(SLO)$/popupmenucontroller.obj \ $(SLO)$/uicommanddescription.obj \ + $(SLO)$/panelwrapper.obj \ + $(SLO)$/panelwindow.obj # --- Targets ------------------------------------------------------ diff --git a/framework/source/uielement/panelwindow.cxx b/framework/source/uielement/panelwindow.cxx new file mode 100755 index 0000000000..d008ee550d --- /dev/null +++ b/framework/source/uielement/panelwindow.cxx @@ -0,0 +1,77 @@ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_framework.hxx" + +//_________________________________________________________________________________________________________________ +// my own includes +//_________________________________________________________________________________________________________________ + +#include <uielement/panelwindow.hxx> + +namespace framework +{ + +PanelWindow::PanelWindow( Window* pParent, WinBits nWinBits ) : + DockingWindow( pParent, nWinBits ) +{ +} + +PanelWindow::~PanelWindow() +{ +} + +const ::rtl::OUString& PanelWindow::getResourceURL() const +{ + return m_aResourceURL; +} + +void PanelWindow::setResourceURL(const ::rtl::OUString& rResourceURL) +{ + m_aResourceURL = rResourceURL; +} + +Window* PanelWindow::getContentWindow() const +{ + return m_pContentWindow; +} + +void PanelWindow::setContentWindow( Window* pContentWindow ) +{ + m_pContentWindow = pContentWindow; + if ( m_pContentWindow != NULL ) + { + m_pContentWindow->SetParent(this); + m_pContentWindow->SetSizePixel( GetOutputSizePixel() ); + m_pContentWindow->Show(); + } +} + +void PanelWindow::Command( const CommandEvent& rCEvt ) +{ + if ( m_aCommandHandler.IsSet() ) + m_aCommandHandler.Call( (void *)( &rCEvt )); + DockingWindow::Command( rCEvt ); +} + +void PanelWindow::StateChanged( StateChangedType nType ) +{ + DockingWindow::StateChanged( nType ); + if ( m_aStateChangedHandler.IsSet() ) + m_aStateChangedHandler.Call( &nType ); +} + +void PanelWindow::DataChanged( const DataChangedEvent& rDCEvt ) +{ + DockingWindow::DataChanged( rDCEvt ); + if ( m_aDataChangedHandler.IsSet() ) + m_aDataChangedHandler.Call( (void*)&rDCEvt ); +} + +void PanelWindow::Resize() +{ + DockingWindow::Resize(); + if ( m_pContentWindow ) + m_pContentWindow->SetSizePixel( GetOutputSizePixel() ); +} + +} diff --git a/framework/source/uielement/panelwrapper.cxx b/framework/source/uielement/panelwrapper.cxx new file mode 100755 index 0000000000..92cb0da251 --- /dev/null +++ b/framework/source/uielement/panelwrapper.cxx @@ -0,0 +1,227 @@ + +// MARKER(update_precomp.py): autogen include statement, do not remove +#include "precompiled_framework.hxx" +//_________________________________________________________________________________________________________________ +// my own includes +//_________________________________________________________________________________________________________________ + +#include <services.h> +#include <uielement/panelwrapper.hxx> +#include <threadhelp/resetableguard.hxx> +#include <helper/actiontriggerhelper.hxx> +#include <uielement/constitemcontainer.hxx> +#include <uielement/rootitemcontainer.hxx> +#include <uielement/panelwindow.hxx> +#include <services/modelwinservice.hxx> + +//_________________________________________________________________________________________________________________ +// interface includes +//_________________________________________________________________________________________________________________ + +#include <com/sun/star/lang/XServiceInfo.hpp> +#include <com/sun/star/beans/XPropertySet.hpp> +#include <com/sun/star/awt/XSystemDependentMenuPeer.hpp> +#include <com/sun/star/awt/XMenuBar.hpp> +#include <com/sun/star/container/XIndexContainer.hpp> +#include <com/sun/star/container/XNameAccess.hpp> +#include <com/sun/star/ui/UIElementType.hpp> + +//_________________________________________________________________________________________________________________ +// other includes +//_________________________________________________________________________________________________________________ + +#include <toolkit/unohlp.hxx> +#include <toolkit/awt/vclxwindow.hxx> +#include <comphelper/processfactory.hxx> +#include <svtools/miscopt.hxx> +#include <vcl/svapp.hxx> +#include <rtl/logfile.hxx> + +using namespace com::sun::star; +using namespace com::sun::star::uno; +using namespace com::sun::star::beans; +using namespace com::sun::star::frame; +using namespace com::sun::star::lang; +using namespace com::sun::star::container; +using namespace com::sun::star::awt; +using namespace ::com::sun::star::ui; + +namespace framework +{ + +PanelWrapper::PanelWrapper( const Reference< XMultiServiceFactory >& xServiceManager ) : + UIElementWrapperBase( UIElementType::DOCKINGWINDOW ), + m_xServiceManager( xServiceManager ), + m_bNoClose(false) +{ +} + +PanelWrapper::~PanelWrapper() +{ +} + +// XInterface +void SAL_CALL PanelWrapper::acquire() throw() +{ + UIElementWrapperBase::acquire(); +} + +void SAL_CALL PanelWrapper::release() throw() +{ + UIElementWrapperBase::release(); +} + +uno::Any SAL_CALL PanelWrapper::queryInterface( const uno::Type & rType ) +throw( ::com::sun::star::uno::RuntimeException ) +{ + return UIElementWrapperBase::queryInterface( rType ); +} + +// XComponent +void SAL_CALL PanelWrapper::dispose() throw ( RuntimeException ) +{ + Reference< XComponent > xThis( static_cast< OWeakObject* >(this), UNO_QUERY ); + Reference< XMultiServiceFactory > xSMGR( m_xServiceManager ); + Reference< XWindow > xWindow; + + { + ResetableGuard aLock( m_aLock ); + if ( m_bDisposed ) + return; + xSMGR = m_xServiceManager; + } + + com::sun::star::lang::EventObject aEvent( xThis ); + m_aListenerContainer.disposeAndClear( aEvent ); + + rtl::OUString aModelWinService( SERVICENAME_MODELWINSERVICE ); + Reference< XNameAccess > xNameAccess( xSMGR->createInstance( aModelWinService ), UNO_QUERY ); + if ( xNameAccess.is() ) + { + ModelWinService* pService = dynamic_cast< ModelWinService* >( xNameAccess.get() ); + if ( pService != 0 ) + { + vos::OGuard aSolarMutexGuard( Application::GetSolarMutex() ); + PanelWindow* pPanelWindow = dynamic_cast< PanelWindow* >( m_xPanelWindow.get() ); + if ( pPanelWindow != NULL ) + { + xWindow = VCLUnoHelper::GetInterface( pPanelWindow->getContentWindow() ); + pService->deregisterModelForXWindow( xWindow ); + } + } + } + + ResetableGuard aLock( m_aLock ); + m_xPanelWindow.clear(); + m_bDisposed = sal_True; +} + +// XInitialization +void SAL_CALL PanelWrapper::initialize( const Sequence< Any >& aArguments ) throw ( Exception, RuntimeException ) +{ + ResetableGuard aLock( m_aLock ); + + if ( m_bDisposed ) + throw DisposedException(); + + if ( !m_bInitialized ) + { + UIElementWrapperBase::initialize( aArguments ); + + sal_Bool bPopupMode( sal_False ); + Reference< XWindow > xContentWindow; + for ( sal_Int32 i = 0; i < aArguments.getLength(); i++ ) + { + PropertyValue aPropValue; + if ( aArguments[i] >>= aPropValue ) + { + if ( aPropValue.Name.equalsAsciiL( "PopupMode", 9 )) + aPropValue.Value >>= bPopupMode; + else if ( aPropValue.Name.equalsAsciiL( "ContentWindow", 13 )) + aPropValue.Value >>= xContentWindow; + } + } + + Reference< XFrame > xFrame( m_xWeakFrame ); + if ( xFrame.is() ) + { + PanelWindow* pPanelWindow(0); + Window* pContentWindow(0); + { + vos::OGuard aSolarMutexGuard( Application::GetSolarMutex() ); + Window* pWindow = VCLUnoHelper::GetWindow( xFrame->getContainerWindow() ); + pContentWindow = VCLUnoHelper::GetWindow( xContentWindow ); + if ( pWindow ) + { + ULONG nStyles = WB_LINESPACING | WB_BORDER | WB_SCROLL | WB_MOVEABLE | WB_3DLOOK | WB_DOCKABLE | WB_SIZEABLE | WB_CLOSEABLE; + + pPanelWindow = new PanelWindow( pWindow, nStyles ); + m_xPanelWindow = VCLUnoHelper::GetInterface( pPanelWindow ); + pPanelWindow->setResourceURL( m_aResourceURL ); + pPanelWindow->setContentWindow( pContentWindow ); + } + } + + try + { + } + catch ( NoSuchElementException& ) + { + } + } + } +} + +// XEventListener +void SAL_CALL PanelWrapper::disposing( const ::com::sun::star::lang::EventObject& ) throw (::com::sun::star::uno::RuntimeException) +{ + // nothing todo +} + +// XUpdatable +void SAL_CALL PanelWrapper::update() throw (::com::sun::star::uno::RuntimeException) +{ + ResetableGuard aLock( m_aLock ); + + if ( m_bDisposed ) + throw DisposedException(); +} + +// XUIElement interface +Reference< XInterface > SAL_CALL PanelWrapper::getRealInterface( ) throw (::com::sun::star::uno::RuntimeException) +{ + ResetableGuard aLock( m_aLock ); + return m_xPanelWindow; +} + +void SAL_CALL PanelWrapper::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const com::sun::star::uno::Any& aValue ) throw( com::sun::star::uno::Exception ) +{ + ResetableGuard aLock( m_aLock ); + sal_Bool bNoClose( m_bNoClose ); + aLock.unlock(); + + UIElementWrapperBase::setFastPropertyValue_NoBroadcast( nHandle, aValue ); + + aLock.lock(); + + sal_Bool bNewNoClose( m_bNoClose ); + if ( m_xPanelWindow.is() && !m_bDisposed && ( bNewNoClose != bNoClose )) + { + PanelWindow* pPanelWindow = dynamic_cast< PanelWindow* >( VCLUnoHelper::GetWindow( m_xPanelWindow ) ); + if ( pPanelWindow ) + { + if ( bNewNoClose ) + { + pPanelWindow->SetStyle( pPanelWindow->GetStyle() & ~WB_CLOSEABLE ); + pPanelWindow->SetFloatStyle( pPanelWindow->GetFloatStyle() & ~WB_CLOSEABLE ); + } + else + { + pPanelWindow->SetStyle( pPanelWindow->GetStyle() | WB_CLOSEABLE ); + pPanelWindow->SetFloatStyle( pPanelWindow->GetFloatStyle() | WB_CLOSEABLE ); + } + } + } +} + +} // namespace framework diff --git a/framework/util/makefile.mk b/framework/util/makefile.mk index a3f14341d3..698ba37d5d 100644 --- a/framework/util/makefile.mk +++ b/framework/util/makefile.mk @@ -336,8 +336,14 @@ SHL4OBJS= \ $(SLO)$/windowcommanddispatch.obj \ $(SLO)$/windowstateconfiguration.obj \ $(SLO)$/windowcontentfactorymanager.obj \ - $(SLO)$/startmoduledispatcher.obj - + $(SLO)$/startmoduledispatcher.obj \ + $(SLO)$/modelwinservice.obj \ + $(SLO)$/panelmanager.obj \ + $(SLO)$/panel.obj \ + $(SLO)$/helpers.obj \ + $(SLO)$/uielement.obj \ + $(SLO)$/toolbarlayoutmanager.obj + SHL4STDLIBS= \ $(FWILIB) \ $(FWELIB) \ diff --git a/officecfg/registry/data/org/openoffice/Setup.xcu b/officecfg/registry/data/org/openoffice/Setup.xcu index 8e18ca575c..8e18ca575c 100755..100644 --- a/officecfg/registry/data/org/openoffice/Setup.xcu +++ b/officecfg/registry/data/org/openoffice/Setup.xcu diff --git a/sfx2/sdi/sfx.sdi b/sfx2/sdi/sfx.sdi index 53ad04a78a..53ad04a78a 100755..100644 --- a/sfx2/sdi/sfx.sdi +++ b/sfx2/sdi/sfx.sdi diff --git a/sfx2/source/control/dispatch.cxx b/sfx2/source/control/dispatch.cxx index fa3025acab..fa3025acab 100644..100755 --- a/sfx2/source/control/dispatch.cxx +++ b/sfx2/source/control/dispatch.cxx diff --git a/sfx2/source/dialog/securitypage.src b/sfx2/source/dialog/securitypage.src index 4818068990..4818068990 100755..100644 --- a/sfx2/source/dialog/securitypage.src +++ b/sfx2/source/dialog/securitypage.src diff --git a/sfx2/source/doc/syspath.cxx b/sfx2/source/doc/syspath.cxx index f12f5abf46..f12f5abf46 100644..100755 --- a/sfx2/source/doc/syspath.cxx +++ b/sfx2/source/doc/syspath.cxx diff --git a/sfx2/source/inc/helpid.hrc b/sfx2/source/inc/helpid.hrc index 0e96396065..0e96396065 100755..100644 --- a/sfx2/source/inc/helpid.hrc +++ b/sfx2/source/inc/helpid.hrc diff --git a/svx/source/sdr/contact/viewobjectcontactofsdrobj.cxx b/svx/source/sdr/contact/viewobjectcontactofsdrobj.cxx index 6e658af973..6e658af973 100755..100644 --- a/svx/source/sdr/contact/viewobjectcontactofsdrobj.cxx +++ b/svx/source/sdr/contact/viewobjectcontactofsdrobj.cxx diff --git a/sysui/desktop/icons/so7-base-doc.ico b/sysui/desktop/icons/so7-base-doc.ico Binary files differindex e4beab7270..e4beab7270 100755..100644 --- a/sysui/desktop/icons/so7-base-doc.ico +++ b/sysui/desktop/icons/so7-base-doc.ico diff --git a/sysui/desktop/icons/so7-calc-doc.ico b/sysui/desktop/icons/so7-calc-doc.ico Binary files differindex 8b34fc606c..8b34fc606c 100755..100644 --- a/sysui/desktop/icons/so7-calc-doc.ico +++ b/sysui/desktop/icons/so7-calc-doc.ico diff --git a/sysui/desktop/icons/so7-calc-tem.ico b/sysui/desktop/icons/so7-calc-tem.ico Binary files differindex d074a214a9..d074a214a9 100755..100644 --- a/sysui/desktop/icons/so7-calc-tem.ico +++ b/sysui/desktop/icons/so7-calc-tem.ico diff --git a/sysui/desktop/icons/so7-chart-doc.ico b/sysui/desktop/icons/so7-chart-doc.ico Binary files differindex bdc613fb30..bdc613fb30 100755..100644 --- a/sysui/desktop/icons/so7-chart-doc.ico +++ b/sysui/desktop/icons/so7-chart-doc.ico diff --git a/sysui/desktop/icons/so7-draw-doc.ico b/sysui/desktop/icons/so7-draw-doc.ico Binary files differindex c288186205..c288186205 100755..100644 --- a/sysui/desktop/icons/so7-draw-doc.ico +++ b/sysui/desktop/icons/so7-draw-doc.ico diff --git a/sysui/desktop/icons/so7-draw-tem.ico b/sysui/desktop/icons/so7-draw-tem.ico Binary files differindex 8d713d0f47..8d713d0f47 100755..100644 --- a/sysui/desktop/icons/so7-draw-tem.ico +++ b/sysui/desktop/icons/so7-draw-tem.ico diff --git a/sysui/desktop/icons/so7-impress-doc.ico b/sysui/desktop/icons/so7-impress-doc.ico Binary files differindex a8f9518e62..a8f9518e62 100755..100644 --- a/sysui/desktop/icons/so7-impress-doc.ico +++ b/sysui/desktop/icons/so7-impress-doc.ico diff --git a/sysui/desktop/icons/so7-impress-tem.ico b/sysui/desktop/icons/so7-impress-tem.ico Binary files differindex ac140b2692..ac140b2692 100755..100644 --- a/sysui/desktop/icons/so7-impress-tem.ico +++ b/sysui/desktop/icons/so7-impress-tem.ico diff --git a/sysui/desktop/icons/so7-master-doc.ico b/sysui/desktop/icons/so7-master-doc.ico Binary files differindex 1c30687159..1c30687159 100755..100644 --- a/sysui/desktop/icons/so7-master-doc.ico +++ b/sysui/desktop/icons/so7-master-doc.ico diff --git a/sysui/desktop/icons/so7-math-doc.ico b/sysui/desktop/icons/so7-math-doc.ico Binary files differindex d1cd9bd4c6..d1cd9bd4c6 100755..100644 --- a/sysui/desktop/icons/so7-math-doc.ico +++ b/sysui/desktop/icons/so7-math-doc.ico diff --git a/sysui/desktop/icons/so7-writer-doc.ico b/sysui/desktop/icons/so7-writer-doc.ico Binary files differindex b8eb3df205..b8eb3df205 100755..100644 --- a/sysui/desktop/icons/so7-writer-doc.ico +++ b/sysui/desktop/icons/so7-writer-doc.ico diff --git a/sysui/desktop/icons/so7-writer-tem.ico b/sysui/desktop/icons/so7-writer-tem.ico Binary files differindex 318cce4bc9..318cce4bc9 100755..100644 --- a/sysui/desktop/icons/so7-writer-tem.ico +++ b/sysui/desktop/icons/so7-writer-tem.ico diff --git a/sysui/desktop/icons/so8-base-app.ico b/sysui/desktop/icons/so8-base-app.ico Binary files differindex 4a22d35296..4a22d35296 100755..100644 --- a/sysui/desktop/icons/so8-base-app.ico +++ b/sysui/desktop/icons/so8-base-app.ico diff --git a/sysui/desktop/icons/so8-base-doc.ico b/sysui/desktop/icons/so8-base-doc.ico Binary files differindex bcddbf9576..bcddbf9576 100755..100644 --- a/sysui/desktop/icons/so8-base-doc.ico +++ b/sysui/desktop/icons/so8-base-doc.ico diff --git a/sysui/desktop/icons/so8-calc-app.ico b/sysui/desktop/icons/so8-calc-app.ico Binary files differindex a28cab5615..a28cab5615 100755..100644 --- a/sysui/desktop/icons/so8-calc-app.ico +++ b/sysui/desktop/icons/so8-calc-app.ico diff --git a/sysui/desktop/icons/so8-calc-doc.ico b/sysui/desktop/icons/so8-calc-doc.ico Binary files differindex 5f293dd82c..5f293dd82c 100755..100644 --- a/sysui/desktop/icons/so8-calc-doc.ico +++ b/sysui/desktop/icons/so8-calc-doc.ico diff --git a/sysui/desktop/icons/so8-calc-tem.ico b/sysui/desktop/icons/so8-calc-tem.ico Binary files differindex 98bf906785..98bf906785 100755..100644 --- a/sysui/desktop/icons/so8-calc-tem.ico +++ b/sysui/desktop/icons/so8-calc-tem.ico diff --git a/sysui/desktop/icons/so8-chart-doc.ico b/sysui/desktop/icons/so8-chart-doc.ico Binary files differindex 01ff836543..01ff836543 100755..100644 --- a/sysui/desktop/icons/so8-chart-doc.ico +++ b/sysui/desktop/icons/so8-chart-doc.ico diff --git a/sysui/desktop/icons/so8-configuration.ico b/sysui/desktop/icons/so8-configuration.ico Binary files differindex 57f3b6701b..57f3b6701b 100755..100644 --- a/sysui/desktop/icons/so8-configuration.ico +++ b/sysui/desktop/icons/so8-configuration.ico diff --git a/sysui/desktop/icons/so8-draw-app.ico b/sysui/desktop/icons/so8-draw-app.ico Binary files differindex 6003ccb3d7..6003ccb3d7 100755..100644 --- a/sysui/desktop/icons/so8-draw-app.ico +++ b/sysui/desktop/icons/so8-draw-app.ico diff --git a/sysui/desktop/icons/so8-draw-doc.ico b/sysui/desktop/icons/so8-draw-doc.ico Binary files differindex f4f169bd6f..f4f169bd6f 100755..100644 --- a/sysui/desktop/icons/so8-draw-doc.ico +++ b/sysui/desktop/icons/so8-draw-doc.ico diff --git a/sysui/desktop/icons/so8-draw-tem.ico b/sysui/desktop/icons/so8-draw-tem.ico Binary files differindex d3f63c38db..d3f63c38db 100755..100644 --- a/sysui/desktop/icons/so8-draw-tem.ico +++ b/sysui/desktop/icons/so8-draw-tem.ico diff --git a/sysui/desktop/icons/so8-empty-doc.ico b/sysui/desktop/icons/so8-empty-doc.ico Binary files differindex b71d2b939c..b71d2b939c 100755..100644 --- a/sysui/desktop/icons/so8-empty-doc.ico +++ b/sysui/desktop/icons/so8-empty-doc.ico diff --git a/sysui/desktop/icons/so8-empty-tem.ico b/sysui/desktop/icons/so8-empty-tem.ico Binary files differindex 9368b0a81a..9368b0a81a 100755..100644 --- a/sysui/desktop/icons/so8-empty-tem.ico +++ b/sysui/desktop/icons/so8-empty-tem.ico diff --git a/sysui/desktop/icons/so8-image-doc.ico b/sysui/desktop/icons/so8-image-doc.ico Binary files differindex 11b4f0f6c7..11b4f0f6c7 100755..100644 --- a/sysui/desktop/icons/so8-image-doc.ico +++ b/sysui/desktop/icons/so8-image-doc.ico diff --git a/sysui/desktop/icons/so8-impress-app.ico b/sysui/desktop/icons/so8-impress-app.ico Binary files differindex 8fae43dab2..8fae43dab2 100755..100644 --- a/sysui/desktop/icons/so8-impress-app.ico +++ b/sysui/desktop/icons/so8-impress-app.ico diff --git a/sysui/desktop/icons/so8-impress-doc.ico b/sysui/desktop/icons/so8-impress-doc.ico Binary files differindex 9a91f89f29..9a91f89f29 100755..100644 --- a/sysui/desktop/icons/so8-impress-doc.ico +++ b/sysui/desktop/icons/so8-impress-doc.ico diff --git a/sysui/desktop/icons/so8-impress-tem.ico b/sysui/desktop/icons/so8-impress-tem.ico Binary files differindex f84f813f99..f84f813f99 100755..100644 --- a/sysui/desktop/icons/so8-impress-tem.ico +++ b/sysui/desktop/icons/so8-impress-tem.ico diff --git a/sysui/desktop/icons/so8-macro-doc.ico b/sysui/desktop/icons/so8-macro-doc.ico Binary files differindex f3742e1274..f3742e1274 100755..100644 --- a/sysui/desktop/icons/so8-macro-doc.ico +++ b/sysui/desktop/icons/so8-macro-doc.ico diff --git a/sysui/desktop/icons/so8-main-app.ico b/sysui/desktop/icons/so8-main-app.ico Binary files differindex aa044ad9c7..aa044ad9c7 100755..100644 --- a/sysui/desktop/icons/so8-main-app.ico +++ b/sysui/desktop/icons/so8-main-app.ico diff --git a/sysui/desktop/icons/so8-master-doc.ico b/sysui/desktop/icons/so8-master-doc.ico Binary files differindex 27a1d2f61c..27a1d2f61c 100755..100644 --- a/sysui/desktop/icons/so8-master-doc.ico +++ b/sysui/desktop/icons/so8-master-doc.ico diff --git a/sysui/desktop/icons/so8-math-app.ico b/sysui/desktop/icons/so8-math-app.ico Binary files differindex 956c259c75..956c259c75 100755..100644 --- a/sysui/desktop/icons/so8-math-app.ico +++ b/sysui/desktop/icons/so8-math-app.ico diff --git a/sysui/desktop/icons/so8-math-doc.ico b/sysui/desktop/icons/so8-math-doc.ico Binary files differindex e7b8844999..e7b8844999 100755..100644 --- a/sysui/desktop/icons/so8-math-doc.ico +++ b/sysui/desktop/icons/so8-math-doc.ico diff --git a/sysui/desktop/icons/so8-open.ico b/sysui/desktop/icons/so8-open.ico Binary files differindex b77a741b33..b77a741b33 100755..100644 --- a/sysui/desktop/icons/so8-open.ico +++ b/sysui/desktop/icons/so8-open.ico diff --git a/sysui/desktop/icons/so8-printer.ico b/sysui/desktop/icons/so8-printer.ico Binary files differindex 25e61f8de5..25e61f8de5 100755..100644 --- a/sysui/desktop/icons/so8-printer.ico +++ b/sysui/desktop/icons/so8-printer.ico diff --git a/sysui/desktop/icons/so8-web-doc.ico b/sysui/desktop/icons/so8-web-doc.ico Binary files differindex 12eeb63cff..12eeb63cff 100755..100644 --- a/sysui/desktop/icons/so8-web-doc.ico +++ b/sysui/desktop/icons/so8-web-doc.ico diff --git a/sysui/desktop/icons/so8-writer-app.ico b/sysui/desktop/icons/so8-writer-app.ico Binary files differindex 15f7f92d4b..15f7f92d4b 100755..100644 --- a/sysui/desktop/icons/so8-writer-app.ico +++ b/sysui/desktop/icons/so8-writer-app.ico diff --git a/sysui/desktop/icons/so8-writer-doc.ico b/sysui/desktop/icons/so8-writer-doc.ico Binary files differindex da774be1d3..da774be1d3 100755..100644 --- a/sysui/desktop/icons/so8-writer-doc.ico +++ b/sysui/desktop/icons/so8-writer-doc.ico diff --git a/sysui/desktop/icons/so8-writer-tem.ico b/sysui/desktop/icons/so8-writer-tem.ico Binary files differindex 1bdb86c809..1bdb86c809 100755..100644 --- a/sysui/desktop/icons/so8-writer-tem.ico +++ b/sysui/desktop/icons/so8-writer-tem.ico diff --git a/sysui/desktop/icons/so9_base_doc.ico b/sysui/desktop/icons/so9_base_doc.ico Binary files differindex 8cc1d4433c..8cc1d4433c 100755..100644 --- a/sysui/desktop/icons/so9_base_doc.ico +++ b/sysui/desktop/icons/so9_base_doc.ico diff --git a/sysui/desktop/icons/so9_calc_doc.ico b/sysui/desktop/icons/so9_calc_doc.ico Binary files differindex 2b9e514cb9..2b9e514cb9 100755..100644 --- a/sysui/desktop/icons/so9_calc_doc.ico +++ b/sysui/desktop/icons/so9_calc_doc.ico diff --git a/sysui/desktop/icons/so9_calc_tem.ico b/sysui/desktop/icons/so9_calc_tem.ico Binary files differindex 17f4823c43..17f4823c43 100755..100644 --- a/sysui/desktop/icons/so9_calc_tem.ico +++ b/sysui/desktop/icons/so9_calc_tem.ico diff --git a/sysui/desktop/icons/so9_chart_doc.ico b/sysui/desktop/icons/so9_chart_doc.ico Binary files differindex b116c81903..b116c81903 100755..100644 --- a/sysui/desktop/icons/so9_chart_doc.ico +++ b/sysui/desktop/icons/so9_chart_doc.ico diff --git a/sysui/desktop/icons/so9_draw_doc.ico b/sysui/desktop/icons/so9_draw_doc.ico Binary files differindex 51f9504670..51f9504670 100755..100644 --- a/sysui/desktop/icons/so9_draw_doc.ico +++ b/sysui/desktop/icons/so9_draw_doc.ico diff --git a/sysui/desktop/icons/so9_draw_tem.ico b/sysui/desktop/icons/so9_draw_tem.ico Binary files differindex e4b341175b..e4b341175b 100755..100644 --- a/sysui/desktop/icons/so9_draw_tem.ico +++ b/sysui/desktop/icons/so9_draw_tem.ico diff --git a/sysui/desktop/icons/so9_empty_doc.ico b/sysui/desktop/icons/so9_empty_doc.ico Binary files differindex a3970775e3..a3970775e3 100755..100644 --- a/sysui/desktop/icons/so9_empty_doc.ico +++ b/sysui/desktop/icons/so9_empty_doc.ico diff --git a/sysui/desktop/icons/so9_empty_tem.ico b/sysui/desktop/icons/so9_empty_tem.ico Binary files differindex 1b0088b802..1b0088b802 100755..100644 --- a/sysui/desktop/icons/so9_empty_tem.ico +++ b/sysui/desktop/icons/so9_empty_tem.ico diff --git a/sysui/desktop/icons/so9_global_doc.ico b/sysui/desktop/icons/so9_global_doc.ico Binary files differindex ea4ccb3839..ea4ccb3839 100755..100644 --- a/sysui/desktop/icons/so9_global_doc.ico +++ b/sysui/desktop/icons/so9_global_doc.ico diff --git a/sysui/desktop/icons/so9_html_doc.ico b/sysui/desktop/icons/so9_html_doc.ico Binary files differindex 4e5b8bc99c..4e5b8bc99c 100755..100644 --- a/sysui/desktop/icons/so9_html_doc.ico +++ b/sysui/desktop/icons/so9_html_doc.ico diff --git a/sysui/desktop/icons/so9_impress_doc.ico b/sysui/desktop/icons/so9_impress_doc.ico Binary files differindex 5258a8b6aa..5258a8b6aa 100755..100644 --- a/sysui/desktop/icons/so9_impress_doc.ico +++ b/sysui/desktop/icons/so9_impress_doc.ico diff --git a/sysui/desktop/icons/so9_impress_tem.ico b/sysui/desktop/icons/so9_impress_tem.ico Binary files differindex dcdbddb3b6..dcdbddb3b6 100755..100644 --- a/sysui/desktop/icons/so9_impress_tem.ico +++ b/sysui/desktop/icons/so9_impress_tem.ico diff --git a/sysui/desktop/icons/so9_macro_doc.ico b/sysui/desktop/icons/so9_macro_doc.ico Binary files differindex cd004015e6..cd004015e6 100755..100644 --- a/sysui/desktop/icons/so9_macro_doc.ico +++ b/sysui/desktop/icons/so9_macro_doc.ico diff --git a/sysui/desktop/icons/so9_math_doc.ico b/sysui/desktop/icons/so9_math_doc.ico Binary files differindex 622ae939d2..622ae939d2 100755..100644 --- a/sysui/desktop/icons/so9_math_doc.ico +++ b/sysui/desktop/icons/so9_math_doc.ico diff --git a/sysui/desktop/icons/so9_writer_doc.ico b/sysui/desktop/icons/so9_writer_doc.ico Binary files differindex b0cf11a993..b0cf11a993 100755..100644 --- a/sysui/desktop/icons/so9_writer_doc.ico +++ b/sysui/desktop/icons/so9_writer_doc.ico diff --git a/sysui/desktop/icons/so9_writer_tem.ico b/sysui/desktop/icons/so9_writer_tem.ico Binary files differindex 2e62a19346..2e62a19346 100755..100644 --- a/sysui/desktop/icons/so9_writer_tem.ico +++ b/sysui/desktop/icons/so9_writer_tem.ico diff --git a/uui/source/ids.hrc b/uui/source/ids.hrc index 23e377f4dd..23e377f4dd 100755..100644 --- a/uui/source/ids.hrc +++ b/uui/source/ids.hrc |