framework/source/uielement/headermenucontroller.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/headermenucontroller.hxx>
  21
  22 #include <services.h>
  23
  24 #include <strings.hrc>
  25 #include <classes/fwkresid.hxx>
  26
  27 #include <com/sun/star/awt/MenuItemStyle.hpp>
  28 #include <com/sun/star/style/XStyleFamiliesSupplier.hpp>
  29 #include <com/sun/star/container/XNameContainer.hpp>
  30 #include <com/sun/star/beans/XPropertySet.hpp>
  31
  32 #include <vcl/svapp.hxx>
  33 #include <rtl/ustrbuf.hxx>
  34 #include <osl/mutex.hxx>
  35 #include <cppuhelper/supportsservice.hxx>
  36 #include <toolkit/awt/vclxmenu.hxx>
  37
  38 //  Defines
  39
  40 using namespace com::sun::star::uno;
  41 using namespace com::sun::star::lang;
  42 using namespace com::sun::star::frame;
  43 using namespace com::sun::star::beans;
  44 using namespace com::sun::star::style;
  45 using namespace com::sun::star::container;
  46
  47 const sal_uInt16 ALL_MENUITEM_ID = 1;
  48
  49 namespace framework
  50 {
  51
  52 // XInterface, XTypeProvider, XServiceInfo
  53
  54 OUString SAL_CALL HeaderMenuController::getImplementationName()
  55 {
  56     return u"com.sun.star.comp.framework.HeaderMenuController"_ustr;
  57 }
  58
  59 sal_Bool SAL_CALL HeaderMenuController::supportsService( const OUString& sServiceName )
  60 {
  61     return cppu::supportsService(this, sServiceName);
  62 }
  63
  64 css::uno::Sequence< OUString > SAL_CALL HeaderMenuController::getSupportedServiceNames()
  65 {
  66     return { SERVICENAME_POPUPMENUCONTROLLER };
  67 }
  68
  69 HeaderMenuController::HeaderMenuController( const css::uno::Reference< css::uno::XComponentContext >& xContext, bool _bFooter ) :
  70     svt::PopupMenuControllerBase( xContext )
  71     ,m_bFooter(_bFooter)
  72 {
  73 }
  74
  75 HeaderMenuController::~HeaderMenuController()
  76 {
  77 }
  78
  79 // private function
  80 void HeaderMenuController::fillPopupMenu( const Reference< css::frame::XModel >& rModel, Reference< css::awt::XPopupMenu > const & rPopupMenu )
  81 {
  82     SolarMutexGuard aSolarMutexGuard;
  83
  84     resetPopupMenu( rPopupMenu );
  85
  86     Reference< XStyleFamiliesSupplier > xStyleFamiliesSupplier( rModel, UNO_QUERY );
  87     if (!xStyleFamiliesSupplier.is())
  88         return;
  89
  90     Reference< XNameAccess > xStyleFamilies = xStyleFamiliesSupplier->getStyleFamilies();
  91
  92     OUString aCmd( u".uno:InsertPageHeader"_ustr );
  93     OUString aHeaderFooterIsOnStr( u"HeaderIsOn"_ustr );
  94     if ( m_bFooter )
  95     {
  96         aCmd = ".uno:InsertPageFooter";
  97         aHeaderFooterIsOnStr = "FooterIsOn";
  98     }
  99     static constexpr OUStringLiteral aIsPhysicalStr( u"IsPhysical" );
 100     static constexpr OUStringLiteral aDisplayNameStr( u"DisplayName" );
 101
 102     try
 103     {
 104         Reference< XNameContainer > xNameContainer;
 105         if ( xStyleFamilies->getByName(u"PageStyles"_ustr) >>= xNameContainer )
 106         {
 107             Sequence< OUString > aSeqNames = xNameContainer->getElementNames();
 108
 109             sal_uInt16   nId = 2;
 110             sal_uInt16  nCount = 0;
 111             bool bAllOneState( true );
 112             bool bLastCheck( true );
 113             bool bFirstChecked( false );
 114             bool bFirstItemInserted( false );
 115             for ( sal_Int32 n = 0; n < aSeqNames.getLength(); n++ )
 116             {
 117                 const OUString& aName = aSeqNames[n];
 118                 Reference< XPropertySet > xPropSet( xNameContainer->getByName( aName ), UNO_QUERY );
 119                 if ( xPropSet.is() )
 120                 {
 121                     bool bIsPhysical( false );
 122                     if (( xPropSet->getPropertyValue( aIsPhysicalStr ) >>= bIsPhysical ) && bIsPhysical )
 123                     {
 124                         OUString aDisplayName;
 125                         bool      bHeaderIsOn( false );
 126                         xPropSet->getPropertyValue( aDisplayNameStr ) >>= aDisplayName;
 127                         xPropSet->getPropertyValue( aHeaderFooterIsOnStr ) >>= bHeaderIsOn;
 128
 129                         OUStringBuffer aStrBuf( aCmd
 130                             + "?PageStyle:string="
 131                             + aDisplayName
 132                             + "&On:bool=" );
 133                         if ( !bHeaderIsOn )
 134                             aStrBuf.append( "true" );
 135                         else
 136                             aStrBuf.append( "false" );
 137                         OUString aCommand( aStrBuf.makeStringAndClear() );
 138                         rPopupMenu->insertItem(nId, aDisplayName, css::awt::MenuItemStyle::CHECKABLE, nCount);
 139                         if ( !bFirstItemInserted )
 140                         {
 141                             bFirstItemInserted = true;
 142                             bFirstChecked      = bHeaderIsOn;
 143                         }
 144
 145                         rPopupMenu->setCommand(nId, aCommand);
 146                         rPopupMenu->checkItem(nId, bHeaderIsOn);
 147                         ++nId;
 148
 149                         // Check if all entries have the same state
 150                         if( bAllOneState && n && bHeaderIsOn != bLastCheck )
 151                             bAllOneState = false;
 152                         bLastCheck = bHeaderIsOn;
 153                         ++nCount;
 154                     }
 155                 }
 156             }
 157
 158             if ( bAllOneState && ( nCount > 1 ))
 159             {
 160                 // Insert special item for all command
 161                 rPopupMenu->insertItem(ALL_MENUITEM_ID, FwkResId(STR_MENU_HEADFOOTALL), 0, 0);
 162
 163                 OUStringBuffer aStrBuf( aCmd + "?On:bool=" );
 164
 165                 // Command depends on check state of first menu item entry
 166                 if ( !bFirstChecked )
 167                     aStrBuf.append( "true" );
 168                 else
 169                     aStrBuf.append( "false" );
 170
 171                 rPopupMenu->setCommand(1, aStrBuf.makeStringAndClear());
 172                 rPopupMenu->insertSeparator(1);
 173             }
 174         }
 175     }
 176     catch ( const css::container::NoSuchElementException& )
 177     {
 178     }
 179 }
 180
 181 // XEventListener
 182 void SAL_CALL HeaderMenuController::disposing( const EventObject& )
 183 {
 184     Reference< css::awt::XMenuListener > xHolder(this);
 185
 186     std::unique_lock aLock( m_aMutex );
 187     m_xFrame.clear();
 188     m_xDispatch.clear();
 189
 190     if ( m_xPopupMenu.is() )
 191         m_xPopupMenu->removeMenuListener( Reference< css::awt::XMenuListener >(this) );
 192     m_xPopupMenu.clear();
 193 }
 194
 195 // XStatusListener
 196 void SAL_CALL HeaderMenuController::statusChanged( const FeatureStateEvent& Event )
 197 {
 198     Reference< css::frame::XModel > xModel;
 199
 200     if ( Event.State >>= xModel )
 201     {
 202         std::unique_lock aLock( m_aMutex );
 203         m_xModel = xModel;
 204         if ( m_xPopupMenu.is() )
 205             fillPopupMenu( xModel, m_xPopupMenu );
 206     }
 207 }
 208
 209 // XMenuListener
 210 void SAL_CALL HeaderMenuController::updatePopupMenu()
 211 {
 212     std::unique_lock aLock( m_aMutex );
 213
 214     throwIfDisposed(aLock);
 215
 216     Reference< css::frame::XModel > xModel( m_xModel );
 217     aLock.unlock();
 218
 219     if ( !xModel.is() )
 220         svt::PopupMenuControllerBase::updatePopupMenu();
 221
 222     aLock.lock();
 223     if ( m_xPopupMenu.is() && m_xModel.is() )
 224         fillPopupMenu( m_xModel, m_xPopupMenu );
 225 }
 226
 227 }
 228
 229 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 230 framework_HeaderMenuController_get_implementation(
 231     css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const& )
 232 {
 233     return cppu::acquire(new framework::HeaderMenuController(context));
 234 }
 235
 236 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */