framework/source/uielement/toolbarwrapper.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <uielement/toolbarwrapper.hxx>
  21 #include <uielement/toolbarmanager.hxx>
  22
  23 #include <com/sun/star/ui/ContextChangeEventMultiplexer.hpp>
  24 #include <com/sun/star/ui/UIElementType.hpp>
  25 #include <com/sun/star/lang/DisposedException.hpp>
  26
  27 #include <toolkit/helper/vclunohelper.hxx>
  28
  29 #include <vcl/svapp.hxx>
  30 #include <vcl/toolbox.hxx>
  31 #include <vcl/weldutils.hxx>
  32 #include <vcl/wintypes.hxx>
  33
  34 using namespace com::sun::star;
  35 using namespace com::sun::star::uno;
  36 using namespace com::sun::star::beans;
  37 using namespace com::sun::star::frame;
  38 using namespace com::sun::star::lang;
  39 using namespace com::sun::star::container;
  40 using namespace com::sun::star::awt;
  41 using namespace ::com::sun::star::ui;
  42
  43 namespace framework
  44 {
  45
  46 ToolBarWrapper::ToolBarWrapper( const Reference< XComponentContext >& rxContext ) :
  47     ImplInheritanceHelper( UIElementType::TOOLBAR ),
  48     m_xContext( rxContext )
  49 {
  50 }
  51
  52 ToolBarWrapper::~ToolBarWrapper()
  53 {
  54     m_xWeldedToolbar.reset(nullptr);
  55     m_xTopLevel.reset(nullptr);
  56     m_xBuilder.reset(nullptr);
  57 }
  58
  59 // XComponent
  60 void SAL_CALL ToolBarWrapper::dispose()
  61 {
  62     Reference< XComponent > xThis(this);
  63
  64     {
  65         SolarMutexGuard g;
  66         if ( m_bDisposed )
  67             return;
  68     }
  69
  70     css::lang::EventObject aEvent( xThis );
  71     m_aListenerContainer.disposeAndClear( aEvent );
  72
  73     SolarMutexGuard g;
  74
  75     auto xMultiplexer( ContextChangeEventMultiplexer::get( m_xContext ) );
  76     xMultiplexer->removeAllContextChangeEventListeners( this );
  77
  78     Reference< XComponent > xComponent( m_xSubElement, UNO_QUERY );
  79     if ( xComponent.is() )
  80         xComponent->removeEventListener( Reference< XUIConfigurationListener >( this ));
  81     m_xSubElement.clear();
  82
  83     if ( m_xToolBarManager.is() )
  84         m_xToolBarManager->dispose();
  85     m_xToolBarManager.clear();
  86     m_xConfigSource.clear();
  87     m_xConfigData.clear();
  88
  89     m_bDisposed = true;
  90 }
  91
  92 // XInitialization
  93 void SAL_CALL ToolBarWrapper::initialize( const Sequence< Any >& aArguments )
  94 {
  95     SolarMutexGuard g;
  96
  97     if ( m_bDisposed )
  98         throw DisposedException();
  99
 100     if ( m_bInitialized )
 101         return;
 102
 103     UIConfigElementWrapperBase::initialize( aArguments );
 104
 105     bool bPopupMode( false );
 106     Reference< XWindow > xParentWindow;
 107     for ( Any const & arg : aArguments )
 108     {
 109         PropertyValue aPropValue;
 110         if ( arg >>= aPropValue )
 111         {
 112             if ( aPropValue.Name == "PopupMode" )
 113                 aPropValue.Value >>= bPopupMode;
 114             else if ( aPropValue.Name == "ParentWindow" )
 115                 xParentWindow.set( aPropValue.Value, UNO_QUERY );
 116         }
 117     }
 118
 119     Reference< XFrame > xFrame( m_xWeakFrame );
 120     if ( !(xFrame.is() && m_xConfigSource.is()) )
 121         return;
 122
 123     std::u16string_view aContextPart;
 124     if ( m_aResourceURL.startsWith( "private:resource/toolbar/singlemode", &aContextPart ) && aContextPart.empty() )
 125     {
 126         auto xMultiplexer( ContextChangeEventMultiplexer::get( m_xContext ) );
 127         try
 128         {
 129             xMultiplexer->addContextChangeEventListener( this, xFrame->getController() );
 130         }
 131         catch( const Exception& )
 132         {
 133         }
 134         // Avoid flickering on context change
 135         bPopupMode = true;
 136     }
 137
 138     // Create VCL based toolbar which will be filled with settings data
 139     VclPtr<ToolBox> pToolBar;
 140     rtl::Reference<ToolBarManager> pToolBarManager;
 141     if ( aContextPart.empty() )
 142     {
 143         SolarMutexGuard aSolarMutexGuard;
 144         if ( !xParentWindow.is() )
 145             xParentWindow.set( xFrame->getContainerWindow() );
 146         VclPtr<vcl::Window> pWindow = VCLUnoHelper::GetWindow( xParentWindow );
 147         if ( pWindow )
 148         {
 149             WinBits nStyles = WB_BORDER | WB_SCROLL | WB_MOVEABLE | WB_3DLOOK | WB_DOCKABLE | WB_SIZEABLE | WB_CLOSEABLE;
 150
 151             pToolBar = VclPtr<ToolBox>::Create( pWindow, nStyles );
 152             pToolBar->SetLineSpacing(true);
 153             pToolBarManager = new ToolBarManager( m_xContext, xFrame, m_aResourceURL, pToolBar );
 154             m_xToolBarManager = pToolBarManager;
 155             pToolBar->WillUsePopupMode( bPopupMode );
 156         }
 157         else if (weld::TransportAsXWindow* pTunnel = dynamic_cast<weld::TransportAsXWindow*>(xParentWindow.get()))
 158         {
 159             m_xBuilder = Application::CreateBuilder(pTunnel->getWidget(), u"svt/ui/managedtoolbar.ui"_ustr);
 160             m_xTopLevel = m_xBuilder->weld_container(u"toolbarcontainer"_ustr);
 161             m_xWeldedToolbar = m_xBuilder->weld_toolbar(u"managedtoolbar"_ustr);
 162             if ( m_xWeldedToolbar )
 163             {
 164                 pToolBarManager = new ToolBarManager( m_xContext, xFrame, m_aResourceURL, m_xWeldedToolbar.get(), m_xBuilder.get() );
 165                 m_xToolBarManager = pToolBarManager;
 166             }
 167         }
 168     }
 169
 170     try
 171     {
 172         m_xConfigData = m_xConfigSource->getSettings( m_aResourceURL, false );
 173         if ( m_xConfigData.is() && (pToolBar || m_xWeldedToolbar) && pToolBarManager )
 174         {
 175             // Fill toolbar with container contents
 176             impl_fillNewData();
 177             if (pToolBar)
 178             {
 179                 pToolBar->EnableCustomize();
 180                 ::Size aActSize( pToolBar->GetSizePixel() );
 181                 ::Size aSize( pToolBar->CalcWindowSizePixel() );
 182                 aSize.setWidth( aActSize.Width() );
 183                 pToolBar->SetOutputSizePixel( aSize );
 184             }
 185         }
 186     }
 187     catch ( const NoSuchElementException& )
 188     {
 189         // No settings in our configuration manager. This means we are
 190         // a transient toolbar which has no persistent settings.
 191         m_bPersistent = false;
 192         if ( pToolBar && pToolBarManager )
 193         {
 194             pToolBar->EnableCustomize();
 195             ::Size aActSize( pToolBar->GetSizePixel() );
 196             ::Size aSize( pToolBar->CalcWindowSizePixel() );
 197             aSize.setWidth( aActSize.Width() );
 198             pToolBar->SetOutputSizePixel( aSize );
 199         }
 200     }
 201 }
 202
 203 // XEventListener
 204 void SAL_CALL ToolBarWrapper::disposing( const css::lang::EventObject& aEvent )
 205 {
 206     if ( aEvent.Source == m_xSubElement )
 207         m_xSubElement.clear();
 208 }
 209
 210 // XUpdatable
 211 void SAL_CALL ToolBarWrapper::update()
 212 {
 213     SolarMutexGuard g;
 214
 215     if ( m_bDisposed )
 216         throw DisposedException();
 217
 218     if ( m_xToolBarManager )
 219         m_xToolBarManager->CheckAndUpdateImages();
 220 }
 221
 222 // XUIElementSettings
 223 void SAL_CALL ToolBarWrapper::updateSettings()
 224 {
 225     SolarMutexGuard g;
 226
 227     if ( m_bDisposed )
 228         throw DisposedException();
 229
 230     if ( m_xConfigSource.is() && m_bPersistent )
 231     {
 232         try
 233         {
 234             m_xConfigData = m_xConfigSource->getSettings( m_aResourceURL, false );
 235             if ( m_xConfigData.is() )
 236                 impl_fillNewData();
 237         }
 238         catch ( const NoSuchElementException& )
 239         {
 240         }
 241
 242         auto pContainer( m_aListenerContainer.getContainer( cppu::UnoType< XEventListener >::get() ) );
 243         if ( pContainer )
 244             pContainer->forEach< XUIElementSettings >([]( const Reference<XUIElementSettings>& xListener ){ xListener->updateSettings(); });
 245     }
 246     else if ( !m_bPersistent )
 247     {
 248         // Transient toolbar: do nothing
 249     }
 250 }
 251
 252 void ToolBarWrapper::impl_fillNewData()
 253 {
 254     if ( m_xToolBarManager )
 255     {
 256         Reference< XUIElementSettings > xUIElementSettings( m_xSubElement, UNO_QUERY );
 257         Reference< XIndexAccess > xContextData = xUIElementSettings.is() ? xUIElementSettings->getSettings( false ) : nullptr;
 258         OUString aContextToolbar = xContextData.is() ? m_xSubElement->getResourceURL() : OUString();
 259         m_xToolBarManager->FillToolbar( m_xConfigData, xContextData, aContextToolbar );
 260     }
 261 }
 262
 263 //XContextChangeEventListener
 264 void SAL_CALL ToolBarWrapper::notifyContextChangeEvent( const ContextChangeEventObject& aEvent )
 265 {
 266     SolarMutexGuard g;
 267
 268     if ( m_bDisposed )
 269         throw DisposedException();
 270
 271     if ( aEvent.ContextName.isEmpty() || aEvent.ContextName == "default" )
 272         return;
 273
 274     const OUString aContextToolbar( m_aResourceURL + "-" + aEvent.ContextName.toAsciiLowerCase() );
 275     if ( m_xSubElement.is() && m_xSubElement->getResourceURL() == aContextToolbar )
 276         return;
 277
 278     Reference< XComponent > xComponent( m_xSubElement, UNO_QUERY );
 279     if ( xComponent.is() )
 280         xComponent->removeEventListener( Reference< XUIConfigurationListener >( this ));
 281     m_xSubElement.clear();
 282
 283     Reference< XLayoutManager > xLayoutManager;
 284     Reference< XPropertySet > xPropSet( m_xWeakFrame.get(), UNO_QUERY );
 285     if ( xPropSet.is() )
 286         xPropSet->getPropertyValue(u"LayoutManager"_ustr) >>= xLayoutManager;
 287     if ( !xLayoutManager.is() )
 288         return;
 289
 290     xLayoutManager->createElement( aContextToolbar );
 291     m_xSubElement.set( xLayoutManager->getElement( aContextToolbar ) );
 292     xComponent.set( m_xSubElement, UNO_QUERY );
 293     if ( xComponent.is() )
 294         xComponent->addEventListener( Reference< XUIConfigurationListener >( this ));
 295
 296     if ( m_xConfigData.is() )
 297     {
 298         xLayoutManager->lock();
 299         impl_fillNewData();
 300         xLayoutManager->unlock();
 301     }
 302 }
 303
 304 // XUIElement interface
 305 Reference< XInterface > SAL_CALL ToolBarWrapper::getRealInterface(  )
 306 {
 307     SolarMutexGuard g;
 308
 309     if ( m_xToolBarManager )
 310     {
 311         vcl::Window* pWindow = m_xToolBarManager->GetToolBar();
 312         return Reference< XInterface >( VCLUnoHelper::GetInterface( pWindow ), UNO_QUERY );
 313     }
 314
 315     return Reference< XInterface >();
 316 }
 317
 318 //XUIFunctionExecute
 319 void SAL_CALL ToolBarWrapper::functionExecute(
 320     const OUString& aUIElementName,
 321     const OUString& aCommand )
 322 {
 323     SolarMutexGuard g;
 324
 325     if ( m_xToolBarManager )
 326         m_xToolBarManager->notifyRegisteredControllers( aUIElementName, aCommand );
 327 }
 328
 329 void SAL_CALL ToolBarWrapper::setFastPropertyValue_NoBroadcast( sal_Int32 nHandle, const css::uno::Any&  aValue )
 330 {
 331     SolarMutexResettableGuard aLock;
 332     bool bNoClose( m_bNoClose );
 333     aLock.clear();
 334
 335     UIConfigElementWrapperBase::setFastPropertyValue_NoBroadcast( nHandle, aValue );
 336
 337     aLock.reset();
 338
 339     bool bNewNoClose( m_bNoClose );
 340     if ( !(m_xToolBarManager.is() && !m_bDisposed && ( bNewNoClose != bNoClose )))
 341         return;
 342
 343     if ( !m_xToolBarManager )
 344         return;
 345
 346     ToolBox* pToolBox = m_xToolBarManager->GetToolBar();
 347     if ( !pToolBox )
 348         return;
 349
 350     if ( bNewNoClose )
 351     {
 352         pToolBox->SetStyle( pToolBox->GetStyle() & ~WB_CLOSEABLE );
 353         pToolBox->SetFloatStyle( pToolBox->GetFloatStyle() & ~WB_CLOSEABLE );
 354     }
 355     else
 356     {
 357         pToolBox->SetStyle( pToolBox->GetStyle() | WB_CLOSEABLE );
 358         pToolBox->SetFloatStyle( pToolBox->GetFloatStyle() | WB_CLOSEABLE );
 359     }
 360 }
 361
 362 } // namespace framework
 363
 364 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */