framework/source/uielement/fontsizemenucontroller.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 <sal/config.h>
  21
  22 #include <uielement/fontsizemenucontroller.hxx>
  23
  24 #include <services.h>
  25
  26 #include <com/sun/star/awt/MenuItemStyle.hpp>
  27 #include <com/sun/star/beans/PropertyValue.hpp>
  28 #include <com/sun/star/frame/XDispatchProvider.hpp>
  29 #include <com/sun/star/view/XPrintable.hpp>
  30 #include <com/sun/star/util/XURLTransformer.hpp>
  31
  32 #include <vcl/svapp.hxx>
  33 #include <vcl/i18nhelp.hxx>
  34 #include <vcl/print.hxx>
  35 #include <vcl/settings.hxx>
  36 #include <svtools/ctrltool.hxx>
  37 #include <osl/mutex.hxx>
  38 #include <memory>
  39 #include <cppuhelper/supportsservice.hxx>
  40
  41 //  Defines
  42
  43 using namespace com::sun::star::uno;
  44 using namespace com::sun::star::lang;
  45 using namespace com::sun::star::frame;
  46 using namespace com::sun::star::beans;
  47 using namespace com::sun::star::util;
  48 using namespace com::sun::star::view;
  49
  50 namespace framework
  51 {
  52
  53 OUString SAL_CALL FontSizeMenuController::getImplementationName()
  54 {
  55     return "com.sun.star.comp.framework.FontSizeMenuController";
  56 }
  57
  58 sal_Bool SAL_CALL FontSizeMenuController::supportsService( const OUString& sServiceName )
  59 {
  60     return cppu::supportsService(this, sServiceName);
  61 }
  62
  63 css::uno::Sequence< OUString > SAL_CALL FontSizeMenuController::getSupportedServiceNames()
  64 {
  65     return { SERVICENAME_POPUPMENUCONTROLLER };
  66 }
  67
  68 FontSizeMenuController::FontSizeMenuController( const css::uno::Reference< css::uno::XComponentContext >& xContext ) :
  69     svt::PopupMenuControllerBase( xContext )
  70 {
  71 }
  72
  73 FontSizeMenuController::~FontSizeMenuController()
  74 {
  75 }
  76
  77 // private function
  78 OUString FontSizeMenuController::retrievePrinterName( css::uno::Reference< css::frame::XFrame > const & rFrame )
  79 {
  80     OUString aPrinterName;
  81
  82     if ( rFrame.is() )
  83     {
  84         Reference< XController > xController = m_xFrame->getController();
  85         if ( xController.is() )
  86         {
  87             Reference< XPrintable > xPrintable( xController->getModel(), UNO_QUERY );
  88             if ( xPrintable.is() )
  89             {
  90                 const Sequence< PropertyValue > aPrinterSeq = xPrintable->getPrinter();
  91                 for ( PropertyValue const & prop : aPrinterSeq )
  92                 {
  93                     if ( prop.Name == "Name" )
  94                     {
  95                         prop.Value >>= aPrinterName;
  96                         break;
  97                     }
  98                 }
  99             }
 100         }
 101     }
 102
 103     return aPrinterName;
 104 }
 105
 106 // private function
 107 void FontSizeMenuController::setCurHeight( tools::Long nHeight, Reference< css::awt::XPopupMenu > const & rPopupMenu )
 108 {
 109     // check menu item
 110     sal_uInt16          nChecked    = 0;
 111     sal_uInt16          nItemCount  = rPopupMenu->getItemCount();
 112     for( sal_uInt16 i = 0; i < nItemCount; i++ )
 113     {
 114         sal_uInt16 nItemId = rPopupMenu->getItemId( i );
 115
 116         if ( m_aHeightArray[i] == nHeight )
 117         {
 118             rPopupMenu->checkItem( nItemId, true );
 119             return;
 120         }
 121
 122         if ( rPopupMenu->isItemChecked( nItemId ) )
 123             nChecked = nItemId;
 124     }
 125
 126     if ( nChecked )
 127         rPopupMenu->checkItem( nChecked, false );
 128 }
 129
 130 // private function
 131 void FontSizeMenuController::fillPopupMenu( Reference< css::awt::XPopupMenu > const & rPopupMenu )
 132 {
 133     resetPopupMenu( rPopupMenu );
 134
 135     std::unique_ptr<FontList> pFontList;
 136     ScopedVclPtr<Printer>  pInfoPrinter;
 137     OUString   aPrinterName;
 138
 139     SolarMutexGuard aSolarMutexGuard;
 140
 141     // try to retrieve printer name of document
 142     aPrinterName = retrievePrinterName( m_xFrame );
 143     if ( !aPrinterName.isEmpty() )
 144     {
 145         pInfoPrinter.disposeAndReset(VclPtr<Printer>::Create( aPrinterName ));
 146         if ( pInfoPrinter && pInfoPrinter->GetFontFaceCollectionCount() > 0 )
 147             pFontList.reset(new FontList( pInfoPrinter.get() ));
 148     }
 149
 150     if ( !pFontList )
 151         pFontList.reset(new FontList( Application::GetDefaultDevice() ));
 152
 153     // setup font size array
 154     m_aHeightArray.clear();
 155
 156     sal_uInt16 nPos = 0; // Id is nPos+1
 157     static const OUStringLiteral aFontHeightCommand( u".uno:FontHeight?FontHeight.Height:float=" );
 158
 159     // first insert font size names (for simplified/traditional chinese)
 160     FontSizeNames   aFontSizeNames( Application::GetSettings().GetUILanguageTag().getLanguageType() );
 161     OUString   aCommand;
 162
 163     if (!aFontSizeNames.IsEmpty())
 164     {
 165         // for scalable fonts all font size names
 166         sal_Int32 nCount = aFontSizeNames.Count();
 167         for( sal_Int32 i = 0; i < nCount; i++ )
 168         {
 169             OUString aSizeName = aFontSizeNames.GetIndexName( i );
 170             sal_Int32 nSize = aFontSizeNames.GetIndexSize( i );
 171             m_aHeightArray.push_back(nSize);
 172             rPopupMenu->insertItem(nPos + 1, aSizeName, css::awt::MenuItemStyle::RADIOCHECK | css::awt::MenuItemStyle::AUTOCHECK, nPos);
 173
 174             // Create dispatchable .uno command and set it
 175             float fPoint = float(nSize) / 10;
 176             aCommand = aFontHeightCommand + OUString::number( fPoint );
 177             rPopupMenu->setCommand(nPos + 1, aCommand);
 178
 179             ++nPos;
 180         }
 181     }
 182
 183     // then insert numerical font size values
 184     const vcl::I18nHelper& rI18nHelper = Application::GetSettings().GetUILocaleI18nHelper();
 185     const int* pAry = FontList::GetStdSizeAry();
 186     const int* pTempAry = pAry;
 187     while ( *pTempAry )
 188     {
 189         m_aHeightArray.push_back(*pTempAry);
 190         rPopupMenu->insertItem(nPos + 1, rI18nHelper.GetNum(*pTempAry, 1, true, false),
 191                                css::awt::MenuItemStyle::RADIOCHECK | css::awt::MenuItemStyle::AUTOCHECK, nPos);
 192
 193         // Create dispatchable .uno command and set it
 194         float fPoint = float(*pTempAry) / 10;
 195         aCommand = aFontHeightCommand + OUString::number( fPoint );
 196         rPopupMenu->setCommand(nPos + 1, aCommand);
 197
 198         ++nPos;
 199         pTempAry++;
 200     }
 201
 202     setCurHeight( tools::Long( m_aFontHeight.Height * 10), rPopupMenu );
 203 }
 204
 205 // XEventListener
 206 void SAL_CALL FontSizeMenuController::disposing( const EventObject& )
 207 {
 208     Reference< css::awt::XMenuListener > xHolder(this);
 209
 210     osl::MutexGuard aLock( m_aMutex );
 211     m_xFrame.clear();
 212     m_xDispatch.clear();
 213     m_xCurrentFontDispatch.clear();
 214     if ( m_xPopupMenu.is() )
 215         m_xPopupMenu->removeMenuListener( Reference< css::awt::XMenuListener >(this) );
 216     m_xPopupMenu.clear();
 217 }
 218
 219 // XStatusListener
 220 void SAL_CALL FontSizeMenuController::statusChanged( const FeatureStateEvent& Event )
 221 {
 222     css::awt::FontDescriptor                 aFontDescriptor;
 223     css::frame::status::FontHeight   aFontHeight;
 224
 225     if ( Event.State >>= aFontDescriptor )
 226     {
 227         osl::MutexGuard aLock( m_aMutex );
 228
 229         if ( m_xPopupMenu.is() )
 230             fillPopupMenu( m_xPopupMenu );
 231     }
 232     else if ( Event.State >>= aFontHeight )
 233     {
 234         osl::MutexGuard aLock( m_aMutex );
 235         m_aFontHeight = aFontHeight;
 236
 237         if ( m_xPopupMenu.is() )
 238         {
 239             SolarMutexGuard aSolarMutexGuard;
 240             setCurHeight( tools::Long( m_aFontHeight.Height * 10), m_xPopupMenu );
 241         }
 242     }
 243 }
 244
 245 // XPopupMenuController
 246 void FontSizeMenuController::impl_setPopupMenu()
 247 {
 248     Reference< XDispatchProvider > xDispatchProvider( m_xFrame, UNO_QUERY );
 249     css::util::URL aTargetURL;
 250     // Register for font name updates which gives us info about the current font!
 251     aTargetURL.Complete = ".uno:CharFontName";
 252     m_xURLTransformer->parseStrict( aTargetURL );
 253     m_xCurrentFontDispatch = xDispatchProvider->queryDispatch( aTargetURL, OUString(), 0 );
 254 }
 255
 256 void SAL_CALL FontSizeMenuController::updatePopupMenu()
 257 {
 258     osl::ClearableMutexGuard aLock( m_aMutex );
 259
 260     throwIfDisposed();
 261
 262     Reference< XDispatch > xDispatch( m_xCurrentFontDispatch );
 263     css::util::URL aTargetURL;
 264     aTargetURL.Complete = ".uno:CharFontName";
 265     m_xURLTransformer->parseStrict( aTargetURL );
 266     aLock.clear();
 267
 268     if ( xDispatch.is() )
 269     {
 270         xDispatch->addStatusListener( static_cast< XStatusListener* >(this), aTargetURL );
 271         xDispatch->removeStatusListener( static_cast< XStatusListener* >(this), aTargetURL );
 272     }
 273
 274     svt::PopupMenuControllerBase::updatePopupMenu();
 275 }
 276 }
 277
 278 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 279 framework_FontSizeMenuController_get_implementation(
 280     css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const& )
 281 {
 282     return cppu::acquire(new framework::FontSizeMenuController(context));
 283 }
 284
 285 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */