framework/source/helper/actiontriggerhelper.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: actiontriggerhelper.cxx,v $
  10  * $Revision: 1.9 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_framework.hxx"
  33 #include <helper/actiontriggerhelper.hxx>
  34 #include <classes/actiontriggerseparatorpropertyset.hxx>
  35 #include <classes/rootactiontriggercontainer.hxx>
  36 #include <classes/imagewrapper.hxx>
  37 #include <classes/addonsoptions.hxx>
  38 #include <com/sun/star/lang/XServiceInfo.hpp>
  39 #include <com/sun/star/beans/XPropertySet.hpp>
  40 #include <com/sun/star/awt/XBitmap.hpp>
  41 #include <vcl/svapp.hxx>
  42 #include <vos/mutex.hxx>
  43 #include <tools/stream.hxx>
  44 #include <cppuhelper/weak.hxx>
  45 #include <comphelper/processfactory.hxx>
  46
  47
  48 const USHORT START_ITEMID = 1000;
  49
  50 using namespace rtl;
  51 using namespace vos;
  52 using namespace com::sun::star::awt;
  53 using namespace com::sun::star::uno;
  54 using namespace com::sun::star::lang;
  55 using namespace com::sun::star::beans;
  56 using namespace com::sun::star::container;
  57
  58 namespace framework
  59 {
  60
  61 // ----------------------------------------------------------------------------
  62 // implementation helper ( menu => ActionTrigger )
  63 // ----------------------------------------------------------------------------
  64
  65 sal_Bool IsSeparator( Reference< XPropertySet > xPropertySet )
  66 {
  67     Reference< XServiceInfo > xServiceInfo( xPropertySet, UNO_QUERY );
  68     try
  69     {
  70         return xServiceInfo->supportsService( OUString( RTL_CONSTASCII_USTRINGPARAM( SERVICENAME_ACTIONTRIGGERSEPARATOR )) );
  71     }
  72     catch ( Exception& )
  73     {
  74     }
  75
  76     return sal_False;
  77 }
  78
  79 void GetMenuItemAttributes( Reference< XPropertySet > xActionTriggerPropertySet,
  80                             OUString& aMenuLabel,
  81                             OUString& aCommandURL,
  82                             OUString& aHelpURL,
  83                             Reference< XBitmap >& xBitmap,
  84                             Reference< XIndexContainer >& xSubContainer )
  85 {
  86     Any a;
  87
  88     try
  89     {
  90         // mandatory properties
  91         a = xActionTriggerPropertySet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "Text" )) );
  92         a >>= aMenuLabel;
  93         a = xActionTriggerPropertySet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "CommandURL" )) );
  94         a >>= aCommandURL;
  95         a = xActionTriggerPropertySet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "Image" )) );
  96         a >>= xBitmap;
  97         a = xActionTriggerPropertySet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "SubContainer" )) );
  98         a >>= xSubContainer;
  99     }
 100     catch ( Exception& )
 101     {
 102     }
 103
 104     // optional properties
 105     try
 106     {
 107         a = xActionTriggerPropertySet->getPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "HelpURL" )) );
 108         a >>= aHelpURL;
 109     }
 110     catch ( Exception& )
 111     {
 112     }
 113 }
 114
 115 void InsertSubMenuItems( Menu* pSubMenu, USHORT& nItemId, Reference< XIndexContainer > xActionTriggerContainer )
 116 {
 117     Reference< XIndexAccess > xIndexAccess( xActionTriggerContainer, UNO_QUERY );
 118     if ( xIndexAccess.is() )
 119     {
 120         AddonsOptions aAddonOptions;
 121         const StyleSettings& rSettings = Application::GetSettings().GetStyleSettings();
 122         sal_Bool bHiContrast = rSettings.GetMenuColor().IsDark();
 123
 124         OUString aSlotURL( RTL_CONSTASCII_USTRINGPARAM( "slot:" ));
 125
 126         for ( sal_Int32 i = 0; i < xIndexAccess->getCount(); i++ )
 127         {
 128             try
 129             {
 130                 Reference< XPropertySet > xPropSet;
 131                 if (( xIndexAccess->getByIndex( i ) >>= xPropSet ) && ( xPropSet.is() ))
 132                 {
 133                     if ( IsSeparator( xPropSet ))
 134                     {
 135                         // Separator
 136                         OGuard aGuard( Application::GetSolarMutex() );
 137                         pSubMenu->InsertSeparator();
 138                     }
 139                     else
 140                     {
 141                         // Menu item
 142                         OUString aLabel;
 143                         OUString aCommandURL;
 144                         OUString aHelpURL;
 145                         Reference< XBitmap > xBitmap;
 146                         Reference< XIndexContainer > xSubContainer;
 147                         sal_Bool bSpecialItemId = sal_False;
 148
 149                         USHORT nNewItemId = nItemId++;
 150                         GetMenuItemAttributes( xPropSet, aLabel, aCommandURL, aHelpURL, xBitmap, xSubContainer );
 151
 152                         OGuard aGuard( Application::GetSolarMutex() );
 153                         {
 154                             // insert new menu item
 155                             sal_Int32 nIndex = aCommandURL.indexOf( aSlotURL );
 156                             if ( nIndex >= 0 )
 157                             {
 158                                 // Special code for our menu implementation: some menu items don't have a
 159                                 // command url but uses the item id as a unqiue identifier. These entries
 160                                 // got a special url during conversion from menu=>actiontriggercontainer.
 161                                 // Now we have to extract this special url and set the correct item id!!!
 162                                 bSpecialItemId = sal_True;
 163                                 nNewItemId = (USHORT)aCommandURL.copy( nIndex+aSlotURL.getLength() ).toInt32();
 164                                 pSubMenu->InsertItem( nNewItemId, aLabel );
 165                             }
 166                             else
 167                             {
 168                                 pSubMenu->InsertItem( nNewItemId, aLabel );
 169                                 pSubMenu->SetItemCommand( nNewItemId, aCommandURL );
 170                             }
 171
 172                             // handle bitmap
 173                             if ( xBitmap.is() )
 174                             {
 175                                 sal_Bool bImageSet = sal_False;
 176
 177                                 Reference< XUnoTunnel > xUnoTunnel( xBitmap, UNO_QUERY );
 178                                 if ( xUnoTunnel.is() )
 179                                 {
 180                                     // Try to get implementation pointer through XUnoTunnel
 181                                     sal_Int64 nPointer = xUnoTunnel->getSomething( ImageWrapper::GetUnoTunnelId() );
 182                                     if ( nPointer )
 183                                     {
 184                                         // This is our own optimized implementation of menu images!
 185                                         ImageWrapper* pImageWrapper = reinterpret_cast< ImageWrapper * >( nPointer );
 186                                         Image aMenuImage = pImageWrapper->GetImage();
 187
 188                                         if ( !!aMenuImage )
 189                                             pSubMenu->SetItemImage( nNewItemId, aMenuImage );
 190
 191                                         bImageSet = sal_True;
 192                                     }
 193                                 }
 194
 195                                 if ( !bImageSet )
 196                                 {
 197                                     // This is an unknown implementation of a XBitmap interface. We have to
 198                                     // use a more time consuming way to build an Image!
 199                                     Image       aImage;
 200                                     Bitmap      aBitmap;
 201
 202                                     Sequence< sal_Int8 > aDIBSeq;
 203                                     {
 204                                         aDIBSeq = xBitmap->getDIB();
 205                                         SvMemoryStream aMem( (void *)aDIBSeq.getConstArray(), aDIBSeq.getLength(), STREAM_READ );
 206                                         aMem >> aBitmap;
 207                                     }
 208
 209                                     aDIBSeq = xBitmap->getMaskDIB();
 210                                     if ( aDIBSeq.getLength() > 0 )
 211                                     {
 212                                         Bitmap aMaskBitmap;
 213                                         SvMemoryStream aMem( (void *)aDIBSeq.getConstArray(), aDIBSeq.getLength(), STREAM_READ );
 214                                         aMem >> aMaskBitmap;
 215                                         aImage = Image( aBitmap, aMaskBitmap );
 216                                     }
 217                                     else
 218                                         aImage = Image( aBitmap );
 219
 220                                     if ( !!aImage )
 221                                         pSubMenu->SetItemImage( nNewItemId, aImage );
 222                                 }
 223                             }
 224                             else
 225                             {
 226                                 // Support add-on images for context menu interceptors
 227                                 Image aImage = aAddonOptions.GetImageFromURL( aCommandURL, sal_False, bHiContrast, sal_True );
 228                                 if ( !!aImage )
 229                                     pSubMenu->SetItemImage( nNewItemId, aImage );
 230                             }
 231
 232                             if ( xSubContainer.is() )
 233                             {
 234                                 PopupMenu* pNewSubMenu = new PopupMenu;
 235
 236                                 // Sub menu (recursive call CreateSubMenu )
 237                                 InsertSubMenuItems( pNewSubMenu, nItemId, xSubContainer );
 238                                 pSubMenu->SetPopupMenu( nNewItemId, pNewSubMenu );
 239                             }
 240                         }
 241                     }
 242                 }
 243             }
 244             catch ( IndexOutOfBoundsException )
 245             {
 246                 return;
 247             }
 248             catch ( WrappedTargetException )
 249             {
 250                 return;
 251             }
 252             catch ( RuntimeException )
 253             {
 254                 return;
 255             }
 256         }
 257     }
 258 }
 259
 260
 261 // ----------------------------------------------------------------------------
 262 // implementation helper ( ActionTrigger => menu )
 263 // ----------------------------------------------------------------------------
 264
 265 Reference< XPropertySet > CreateActionTrigger( USHORT nItemId, const Menu* pMenu, const Reference< XIndexContainer >& rActionTriggerContainer ) throw ( RuntimeException )
 266 {
 267     Reference< XPropertySet > xPropSet;
 268
 269     Reference< XMultiServiceFactory > xMultiServiceFactory( rActionTriggerContainer, UNO_QUERY );
 270     if ( xMultiServiceFactory.is() )
 271     {
 272         xPropSet = Reference< XPropertySet >(   xMultiServiceFactory->createInstance(
 273                                                     OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.ui.ActionTrigger" )) ),
 274                                                 UNO_QUERY );
 275
 276         Any a;
 277
 278         try
 279         {
 280             // Retrieve the menu attributes and set them in our PropertySet
 281             OUString aLabel = pMenu->GetItemText( nItemId );
 282             a <<= aLabel;
 283             xPropSet->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "Text" )), a );
 284
 285             OUString aCommandURL = pMenu->GetItemCommand( nItemId );
 286
 287             if ( aCommandURL.getLength() == 0 )
 288             {
 289                 aCommandURL = OUString( RTL_CONSTASCII_USTRINGPARAM( "slot:" ));
 290                 aCommandURL += OUString::valueOf( (sal_Int32)nItemId );
 291             }
 292
 293             a <<= aCommandURL;
 294             xPropSet->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "CommandURL" )), a );
 295
 296             Image aImage = pMenu->GetItemImage( nItemId );
 297             if ( !!aImage )
 298             {
 299                 // We use our own optimized XBitmap implementation
 300                 Reference< XBitmap > xBitmap( static_cast< cppu::OWeakObject* >( new ImageWrapper( aImage )), UNO_QUERY );
 301                 a <<= xBitmap;
 302                 xPropSet->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "Image" )), a );
 303             }
 304         }
 305         catch ( Exception& )
 306         {
 307         }
 308     }
 309
 310     return xPropSet;
 311 }
 312
 313 Reference< XPropertySet > CreateActionTriggerSeparator( const Reference< XIndexContainer >& rActionTriggerContainer ) throw ( RuntimeException )
 314 {
 315     Reference< XMultiServiceFactory > xMultiServiceFactory( rActionTriggerContainer, UNO_QUERY );
 316     if ( xMultiServiceFactory.is() )
 317     {
 318         return Reference< XPropertySet >(       xMultiServiceFactory->createInstance(
 319                                                 OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.ui.ActionTriggerSeparator" )) ),
 320                                             UNO_QUERY );
 321     }
 322
 323     return Reference< XPropertySet >();
 324 }
 325
 326 Reference< XIndexContainer > CreateActionTriggerContainer( const Reference< XIndexContainer >& rActionTriggerContainer ) throw ( RuntimeException )
 327 {
 328     Reference< XMultiServiceFactory > xMultiServiceFactory( rActionTriggerContainer, UNO_QUERY );
 329     if ( xMultiServiceFactory.is() )
 330     {
 331         return Reference< XIndexContainer >( xMultiServiceFactory->createInstance(
 332                                                 OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.ui.ActionTriggerContainer" )) ),
 333                                              UNO_QUERY );
 334     }
 335
 336     return Reference< XIndexContainer >();
 337 }
 338
 339 void FillActionTriggerContainerWithMenu( const Menu* pMenu, Reference< XIndexContainer >& rActionTriggerContainer )
 340 {
 341     OGuard aGuard( Application::GetSolarMutex() );
 342
 343     for ( USHORT nPos = 0; nPos < pMenu->GetItemCount(); nPos++ )
 344     {
 345         USHORT                  nItemId = pMenu->GetItemId( nPos );
 346         MenuItemType    nType   = pMenu->GetItemType( nPos );
 347
 348         try
 349         {
 350             Any a;
 351             Reference< XPropertySet > xPropSet;
 352
 353             if ( nType == MENUITEM_SEPARATOR )
 354             {
 355                 xPropSet = CreateActionTriggerSeparator( rActionTriggerContainer );
 356
 357                 a <<= xPropSet;
 358                 rActionTriggerContainer->insertByIndex( nPos, a );
 359             }
 360             else
 361             {
 362                 xPropSet = CreateActionTrigger( nItemId, pMenu, rActionTriggerContainer );
 363
 364                 a <<= xPropSet;
 365                 rActionTriggerContainer->insertByIndex( nPos, a );
 366
 367                 PopupMenu* pPopupMenu = pMenu->GetPopupMenu( nItemId );
 368                 if ( pPopupMenu )
 369                 {
 370                     // recursive call to build next sub menu
 371                     Reference< XIndexContainer > xSubContainer = CreateActionTriggerContainer( rActionTriggerContainer );
 372
 373                     a <<= xSubContainer;
 374                     xPropSet->setPropertyValue( OUString( RTL_CONSTASCII_USTRINGPARAM( "SubContainer" )), a );
 375                     FillActionTriggerContainerWithMenu( pPopupMenu, xSubContainer );
 376                 }
 377             }
 378         }
 379         catch ( Exception& )
 380         {
 381         }
 382     }
 383 }
 384
 385 void ActionTriggerHelper::CreateMenuFromActionTriggerContainer(
 386     Menu* pNewMenu,
 387     const Reference< XIndexContainer >& rActionTriggerContainer )
 388 {
 389     USHORT nItemId = START_ITEMID;
 390
 391     if ( rActionTriggerContainer.is() )
 392         InsertSubMenuItems( pNewMenu, nItemId, rActionTriggerContainer );
 393 }
 394
 395 void ActionTriggerHelper::FillActionTriggerContainerFromMenu(
 396     Reference< XIndexContainer >& xActionTriggerContainer,
 397     const Menu* pMenu )
 398 {
 399     FillActionTriggerContainerWithMenu( pMenu, xActionTriggerContainer );
 400 }
 401
 402 Reference< XIndexContainer > ActionTriggerHelper::CreateActionTriggerContainerFromMenu(
 403     // #110897#
 404     const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& xServiceFactory,
 405     const Menu* pMenu,
 406     const ::rtl::OUString* pMenuIdentifier )
 407 {
 408     return new RootActionTriggerContainer( pMenu, pMenuIdentifier, xServiceFactory );
 409 }
 410
 411 }