sc/source/filter/excel/xltoolbar.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 #include "xltoolbar.hxx"
  10 #include <sal/log.hxx>
  11 #include <o3tl/safeint.hxx>
  12 #include <com/sun/star/beans/XPropertySet.hpp>
  13 #include <com/sun/star/document/IndexedPropertyValues.hpp>
  14 #include <com/sun/star/ui/XUIConfigurationPersistence.hpp>
  15 #include <com/sun/star/ui/theModuleUIConfigurationManagerSupplier.hpp>
  16 #include <com/sun/star/ui/ItemType.hpp>
  17 #include <comphelper/processfactory.hxx>
  18 #include <comphelper/propertyvalue.hxx>
  19 #include <comphelper/sequence.hxx>
  20 #include <map>
  21
  22 using namespace com::sun::star;
  23
  24 typedef std::map< sal_Int16, OUString > IdToString;
  25
  26 namespace {
  27
  28 class MSOExcelCommandConvertor : public MSOCommandConvertor
  29 {
  30    IdToString msoToOOcmd;
  31    IdToString tcidToOOcmd;
  32 public:
  33     MSOExcelCommandConvertor();
  34     virtual OUString MSOCommandToOOCommand( sal_Int16 msoCmd ) override;
  35     virtual OUString MSOTCIDToOOCommand( sal_Int16 key ) override;
  36 };
  37
  38 }
  39
  40 MSOExcelCommandConvertor::MSOExcelCommandConvertor()
  41 {
  42 /*
  43     // mso command id to ooo command string
  44     // #FIXME and *HUNDREDS* of id's to added here
  45     msoToOOcmd[ 0x20b ] = ".uno:CloseDoc";
  46     msoToOOcmd[ 0x50 ] = ".uno:Open";
  47
  48    // mso tcid to ooo command string
  49     // #FIXME and *HUNDREDS* of id's to added here
  50    tcidToOOcmd[ 0x9d9 ] = ".uno:Print";
  51 */
  52 }
  53
  54 OUString MSOExcelCommandConvertor::MSOCommandToOOCommand( sal_Int16 key )
  55 {
  56     OUString sResult;
  57     IdToString::iterator it = msoToOOcmd.find( key );
  58     if ( it != msoToOOcmd.end() )
  59         sResult = it->second;
  60     return sResult;
  61 }
  62
  63 OUString MSOExcelCommandConvertor::MSOTCIDToOOCommand( sal_Int16 key )
  64 {
  65     OUString sResult;
  66     IdToString::iterator it = tcidToOOcmd.find( key );
  67     if ( it != tcidToOOcmd.end() )
  68         sResult = it->second;
  69     return sResult;
  70 }
  71
  72 CTBS::CTBS() : bSignature(0), bVersion(0), reserved1(0), reserved2(0), reserved3(0), ctb(0), ctbViews(0), ictbView(0)
  73 {
  74 }
  75
  76 ScCTB::ScCTB(sal_uInt16 nNum ) : nViews( nNum ), ectbid(0)
  77 {
  78 }
  79
  80 bool ScCTB::Read( SvStream &rS )
  81 {
  82     SAL_INFO("sc.filter", "stream pos " << rS.Tell());
  83     nOffSet = rS.Tell();
  84     tb.Read( rS );
  85
  86     {
  87         const size_t nMinRecordSize = 20; // TBVisualData reads 20 bytes
  88         const size_t nMaxPossibleRecords = rS.remainingSize() / nMinRecordSize;
  89         if (nViews > nMaxPossibleRecords)
  90         {
  91             SAL_WARN("sc.filter", "ScCTB::Read more entries claimed than stream could contain");
  92             return false;
  93         }
  94     }
  95
  96     for ( sal_uInt16 index = 0; index < nViews; ++index )
  97     {
  98         TBVisualData aVisData;
  99         aVisData.Read( rS );
 100         rVisualData.push_back( aVisData );
 101     }
 102     rS.ReadUInt32( ectbid );
 103
 104     sal_Int16 nCL = tb.getcCL();
 105     if (nCL > 0)
 106     {
 107         auto nIndexes = o3tl::make_unsigned(nCL);
 108
 109         const size_t nMinRecordSize = 11; // ScTBC's TBCHeader reads min 11 bytes
 110         const size_t nMaxPossibleRecords = rS.remainingSize() / nMinRecordSize;
 111         if (nIndexes > nMaxPossibleRecords)
 112         {
 113             SAL_WARN("sc.filter", "ScCTB::Read more entries claimed than stream could contain");
 114             return false;
 115         }
 116
 117         for (decltype(nIndexes) index = 0; index < nIndexes; ++index)
 118         {
 119             ScTBC aTBC;
 120             aTBC.Read( rS );
 121             rTBC.push_back( aTBC );
 122         }
 123     }
 124
 125     return true;
 126 }
 127
 128 #ifdef DEBUG_SC_EXCEL
 129 void ScCTB::Print( FILE* fp )
 130 {
 131     Indent a;
 132     indent_printf( fp, "[ 0x%x ] ScCTB -- dump\n", nOffSet );
 133     indent_printf( fp, "  nViews 0x%x\n", nViews);
 134     tb.Print( fp );
 135
 136     sal_Int32 counter = 0;
 137     for ( auto& rItem : rVisualData )
 138     {
 139         indent_printf( fp, "  TBVisualData [%d]\n", counter++ );
 140         Indent b;
 141         rItem.Print( fp );
 142     }
 143     indent_printf( fp, "  ectbid 0x%x\n", ectbid);
 144     counter = 0;
 145     for ( auto& rItem : rTBC )
 146     {
 147         indent_printf( fp, "  ScTBC [%d]\n", counter++);
 148         Indent c;
 149         rItem.Print( fp );
 150     }
 151 }
 152 #endif
 153
 154 bool ScCTB::IsMenuToolbar() const
 155 {
 156     return tb.IsMenuToolbar();
 157 }
 158
 159 bool ScCTB::ImportMenuTB( ScCTBWrapper& rWrapper, const css::uno::Reference< css::container::XIndexContainer >& xMenuDesc, CustomToolBarImportHelper& helper )
 160 {
 161     for ( auto& rItem : rTBC )
 162     {
 163         if ( !rItem.ImportToolBarControl( rWrapper, xMenuDesc, helper, IsMenuToolbar() ) )
 164             return false;
 165     }
 166     return true;
 167 }
 168
 169 bool ScCTB::ImportCustomToolBar( ScCTBWrapper& rWrapper, CustomToolBarImportHelper& helper )
 170 {
 171
 172     bool bRes = false;
 173     try
 174     {
 175         if ( !tb.IsEnabled() )
 176             return true;  // didn't fail, just ignoring
 177
 178         // Create default setting
 179         uno::Reference< container::XIndexContainer > xIndexContainer( helper.getCfgManager()->createSettings(), uno::UNO_SET_THROW );
 180         uno::Reference< container::XIndexAccess > xIndexAccess( xIndexContainer, uno::UNO_QUERY_THROW );
 181         uno::Reference< beans::XPropertySet > xProps( xIndexContainer, uno::UNO_QUERY_THROW );
 182         WString& name = tb.getName();
 183         // set UI name for toolbar
 184         xProps->setPropertyValue("UIName", uno::makeAny( name.getString() ) );
 185
 186         OUString sToolBarName = "private:resource/toolbar/custom_" + name.getString();
 187         for ( auto& rItem : rTBC )
 188         {
 189             if ( !rItem.ImportToolBarControl( rWrapper, xIndexContainer, helper, IsMenuToolbar() ) )
 190                 return false;
 191         }
 192
 193         helper.getCfgManager()->insertSettings( sToolBarName, xIndexAccess );
 194         helper.applyIcons();
 195
 196         uno::Reference< ui::XUIConfigurationPersistence > xPersistence( helper.getCfgManager()->getImageManager(), uno::UNO_QUERY_THROW );
 197         xPersistence->store();
 198
 199         xPersistence.set( helper.getCfgManager(), uno::UNO_QUERY_THROW );
 200         xPersistence->store();
 201
 202         bRes = true;
 203     }
 204     catch( uno::Exception& )
 205     {
 206        bRes = false;
 207     }
 208     return bRes;
 209 }
 210 bool CTBS::Read( SvStream &rS )
 211 {
 212     SAL_INFO("sc.filter", "stream pos " << rS.Tell());
 213     nOffSet = rS.Tell();
 214     rS.ReadUChar( bSignature ).ReadUChar( bVersion ).ReadUInt16( reserved1 ).ReadUInt16( reserved2 ).ReadUInt16( reserved3 ).ReadUInt16( ctb ).ReadUInt16( ctbViews ).ReadUInt16( ictbView );
 215     return true;
 216 }
 217
 218 #ifdef DEBUG_SC_EXCEL
 219 void CTBS::Print( FILE* fp )
 220 {
 221     Indent a;
 222     indent_printf( fp, "[ 0x%x ] CTBS -- dump\n", nOffSet );
 223
 224     indent_printf( fp, "  bSignature 0x%x\n", bSignature);
 225     indent_printf( fp, "  bVersion 0x%x\n", bVersion);
 226
 227     indent_printf( fp, "  reserved1 0x%x\n", reserved1 );
 228     indent_printf( fp, "  reserved2 0x%x\n", reserved2 );
 229     indent_printf( fp, "  reserved3 0x%x\n", reserved3 );
 230
 231     indent_printf( fp, "  ctb 0x%x\n", ctb );
 232     indent_printf( fp, "  ctbViews 0x%x\n", ctbViews );
 233     indent_printf( fp, "  ictbView 0x%x\n", ictbView );
 234 }
 235 #endif
 236
 237 ScTBC::ScTBC()
 238 {
 239 }
 240
 241 bool
 242 ScTBC::Read(SvStream &rS)
 243 {
 244     SAL_INFO("sc.filter", "stream pos " << rS.Tell());
 245     nOffSet = rS.Tell();
 246     if ( !tbch.Read( rS ) )
 247         return false;
 248     sal_uInt16 tcid = tbch.getTcID();
 249     sal_uInt8 tct = tbch.getTct();
 250     if (  ( tcid != 0x0001 && tcid != 0x06CC && tcid != 0x03D8 && tcid != 0x03EC && tcid != 0x1051 ) && ( ( tct > 0 && tct < 0x0B ) || ( ( tct > 0x0B && tct < 0x10 ) || tct == 0x15 ) ) )
 251     {
 252         tbcCmd = std::make_shared<TBCCmd>();
 253         if ( !  tbcCmd->Read( rS ) )
 254             return false;
 255     }
 256     if ( tct != 0x16 )
 257     {
 258         tbcd = std::make_shared<TBCData>( tbch );
 259         if ( !tbcd->Read( rS ) )
 260             return false;
 261     }
 262     return true;
 263 }
 264
 265 #ifdef DEBUG_SC_EXCEL
 266 void
 267 ScTBC::Print(FILE* fp)
 268 {
 269     Indent a;
 270     indent_printf( fp, "[ 0x%x ] ScTBC -- dump\n", nOffSet );
 271     tbch.Print( fp );
 272     if ( tbcCmd.get() )
 273         tbcCmd->Print( fp );
 274     if ( tbcd.get() )
 275         tbcd->Print( fp );
 276 }
 277 #endif
 278
 279 bool ScTBC::ImportToolBarControl( ScCTBWrapper& rWrapper, const css::uno::Reference< css::container::XIndexContainer >& toolbarcontainer, CustomToolBarImportHelper& helper, bool bIsMenuToolbar )
 280 {
 281     // how to identify built-in-command ?
 282 //    bool bBuiltin = false;
 283     if ( tbcd )
 284     {
 285         std::vector< css::beans::PropertyValue > props;
 286         bool bBeginGroup = false;
 287         tbcd->ImportToolBarControl( helper, props, bBeginGroup, bIsMenuToolbar );
 288         TBCMenuSpecific* pMenu = tbcd->getMenuSpecific();
 289         if ( pMenu )
 290         {
 291             // search for ScCTB with the appropriate name ( it contains the
 292             // menu items, although we cannot import ( or create ) a menu on
 293             // a custom toolbar we can import the menu items in a separate
 294             // toolbar ( better than nothing )
 295             ScCTB* pCustTB = rWrapper.GetCustomizationData( pMenu->Name() );
 296             if ( pCustTB )
 297             {
 298                  uno::Reference< container::XIndexContainer > xMenuDesc = document::IndexedPropertyValues::create( comphelper::getProcessComponentContext() );
 299                  if ( !pCustTB->ImportMenuTB( rWrapper, xMenuDesc, helper ) )
 300                      return false;
 301                  if ( !bIsMenuToolbar )
 302                  {
 303                      if ( !helper.createMenu( pMenu->Name(), xMenuDesc ) )
 304                          return false;
 305                  }
 306                  else
 307                  {
 308                      beans::PropertyValue aProp;
 309                      aProp.Name = "ItemDescriptorContainer";
 310                      aProp.Value <<= xMenuDesc;
 311                      props.push_back( aProp );
 312                  }
 313             }
 314         }
 315
 316         if ( bBeginGroup )
 317         {
 318             // insert spacer
 319             uno::Sequence sProps{ comphelper::makePropertyValue("Type",
 320                                                                 ui::ItemType::SEPARATOR_LINE) };
 321             toolbarcontainer->insertByIndex( toolbarcontainer->getCount(), uno::makeAny( sProps ) );
 322         }
 323         toolbarcontainer->insertByIndex( toolbarcontainer->getCount(), uno::makeAny( comphelper::containerToSequence(props) ) );
 324     }
 325     return true;
 326 }
 327
 328 #ifdef DEBUG_SC_EXCEL
 329 void
 330 TBCCmd::Print(FILE* fp)
 331 {
 332     Indent a;
 333     indent_printf( fp, " TBCCmd -- dump\n" );
 334     indent_printf( fp, "   cmdID 0x%x\n", cmdID );
 335     indent_printf( fp, "   A ( fHideDrawing ) %s\n", A ? "true" : "false" );
 336     indent_printf( fp, "   B ( reserved - ignored ) %s\n", A ? "true" : "false" );
 337     indent_printf( fp, "   cmdType 0x%x\n", cmdType );
 338     indent_printf( fp, "   C ( reserved - ignored ) %s\n", A ? "true" : "false" );
 339     indent_printf( fp, "   reserved3 0x%x\n", reserved3 );
 340 }
 341 #endif
 342
 343 bool TBCCmd::Read( SvStream &rS )
 344 {
 345     SAL_INFO("sc.filter", "stream pos " << rS.Tell());
 346     nOffSet = rS.Tell();
 347     rS.ReadUInt16( cmdID );
 348     sal_uInt16 temp;
 349     rS.ReadUInt16( temp );
 350     A = (temp & 0x8000 ) == 0x8000;
 351     B = (temp & 0x4000) == 0x4000;
 352     cmdType = ( temp & 0x3E00 ) >> 9;
 353     C = ( temp & 0x100 ) == 0x100;
 354     reserved3 = ( temp & 0xFF );
 355     return true;
 356 }
 357
 358 ScCTBWrapper::ScCTBWrapper()
 359 {
 360 }
 361
 362 ScCTBWrapper::~ScCTBWrapper()
 363 {
 364 }
 365
 366 bool
 367 ScCTBWrapper::Read( SvStream &rS)
 368 {
 369     SAL_INFO("sc.filter", "stream pos " << rS.Tell());
 370     nOffSet = rS.Tell();
 371     if (!ctbSet.Read(rS))
 372         return false;
 373
 374     //ScCTB is 1 TB which is min 15bytes, nViews TBVisualData which is min 20bytes
 375     //and one 32bit number (4 bytes)
 376     const size_t nMinRecordSize = 19 + o3tl::sanitizing_min(ctbSet.ctbViews * 20, 0);
 377     const size_t nMaxPossibleRecords = rS.remainingSize()/nMinRecordSize;
 378     if (ctbSet.ctb > nMaxPossibleRecords)
 379         return false;
 380
 381     for ( sal_uInt16 index = 0; index < ctbSet.ctb; ++index )
 382     {
 383         ScCTB aCTB( ctbSet.ctbViews );
 384         if ( !aCTB.Read( rS ) )
 385             return false;
 386         rCTB.push_back( aCTB );
 387     }
 388     return true;
 389 }
 390
 391 #ifdef DEBUG_SC_EXCEL
 392 void
 393 ScCTBWrapper::Print( FILE* fp )
 394 {
 395     Indent a;
 396     indent_printf( fp, "[ 0x%x ] ScCTBWrapper -- dump\n", nOffSet );
 397     ctbSet.Print( fp );
 398     for ( auto& rItem : rCTB )
 399     {
 400         Indent b;
 401         rItem.Print( fp );
 402     }
 403 }
 404 #endif
 405
 406 ScCTB* ScCTBWrapper::GetCustomizationData( const OUString& sTBName )
 407 {
 408     ScCTB* pCTB = nullptr;
 409     auto it = std::find_if(rCTB.begin(), rCTB.end(), [&sTBName](ScCTB& rItem) { return rItem.GetName() == sTBName; });
 410     if (it != rCTB.end())
 411         pCTB = &(*it);
 412     return pCTB;
 413 }
 414
 415 void ScCTBWrapper::ImportCustomToolBar( SfxObjectShell& rDocSh )
 416 {
 417     if(rCTB.empty())
 418         return;
 419
 420     uno::Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
 421     uno::Reference< ui::XModuleUIConfigurationManagerSupplier > xAppCfgSupp( ui::theModuleUIConfigurationManagerSupplier::get(xContext) );
 422
 423     for ( auto& rItem : rCTB )
 424     {
 425         // for each customtoolbar
 426         CustomToolBarImportHelper helper( rDocSh, xAppCfgSupp->getUIConfigurationManager( "com.sun.star.sheet.SpreadsheetDocument" ) );
 427         helper.setMSOCommandMap( new  MSOExcelCommandConvertor() );
 428         // Ignore menu toolbars, excel doesn't ( afaics ) store
 429         // menu customizations ( but you can have menus in a customtoolbar
 430         // such menus will be dealt with when they are encountered
 431         // as part of importing the appropriate MenuSpecific toolbar control )
 432
 433         if ( !rItem.IsMenuToolbar() && !rItem.ImportCustomToolBar( *this, helper ) )
 434             return;
 435     }
 436 }
 437
 438 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */