idl/source/objects/slot.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 <rtl/strbuf.hxx>
  21 #include <osl/diagnose.h>
  22 #include <tools/debug.hxx>
  23 #include <slot.hxx>
  24 #include <globals.hxx>
  25 #include <database.hxx>
  26
  27
  28 SvMetaSlot::SvMetaSlot()
  29     : aRecordPerSet( true )
  30     , aRecordAbsolute( false )
  31     , pNextSlot(nullptr)
  32     , nListPos(0)
  33     , aReadOnlyDoc ( true )
  34     , aExport( true )
  35 {
  36 }
  37
  38 SvMetaSlot::SvMetaSlot( SvMetaType * pType )
  39     : SvMetaAttribute( pType )
  40     , aRecordPerSet( true )
  41     , aRecordAbsolute( false )
  42     , pNextSlot(nullptr)
  43     , nListPos(0)
  44     , aReadOnlyDoc ( true )
  45     , aExport( true )
  46 {
  47 }
  48
  49 bool SvMetaSlot::GetReadOnlyDoc() const
  50 {
  51     if( aReadOnlyDoc.IsSet() || !GetRef() ) return aReadOnlyDoc;
  52     return static_cast<SvMetaSlot *>(GetRef())->GetReadOnlyDoc();
  53 }
  54
  55 bool SvMetaSlot::GetExport() const
  56 {
  57     if( aExport.IsSet() || !GetRef() ) return aExport;
  58     return static_cast<SvMetaSlot *>(GetRef())->GetExport();
  59 }
  60
  61 bool SvMetaSlot::GetHidden() const
  62 {
  63     // when export is set, but hidden is not the default is used
  64     if ( aExport.IsSet() )
  65         return !aExport;
  66     else if( !GetRef() )
  67         return false;
  68     else
  69         return static_cast<SvMetaSlot *>(GetRef())->GetHidden();
  70 }
  71
  72 bool SvMetaSlot::IsVariable() const
  73 {
  74     SvMetaType * pType = GetType();
  75     return pType->GetMetaTypeType() != MetaTypeType::Method;
  76 }
  77
  78 bool SvMetaSlot::IsMethod() const
  79 {
  80     SvMetaType * pType = GetType();
  81     return pType->GetMetaTypeType() == MetaTypeType::Method;
  82 }
  83
  84 /*************************************************************************
  85 |*    reference
  86 |*
  87 |*    description       Second FALSE in the SvBOOL-Objects means
  88 |*                      IsSet() provides FALSE (default initialization).
  89 *************************************************************************/
  90 /** reference disbandment **/
  91 const OString& SvMetaSlot::GetGroupId() const
  92 {
  93     if( !aGroupId.getString().isEmpty() || !GetRef() ) return aGroupId.getString();
  94     return static_cast<SvMetaSlot *>(GetRef())->GetGroupId();
  95 }
  96 const OString& SvMetaSlot::GetDisableFlags() const
  97 {
  98     if( !aDisableFlags.isEmpty() || !GetRef() ) return aDisableFlags;
  99     return static_cast<SvMetaSlot *>(GetRef())->GetDisableFlags();
 100 }
 101 const OString& SvMetaSlot::GetExecMethod() const
 102 {
 103     if( !aExecMethod.getString().isEmpty() || !GetRef() ) return aExecMethod.getString();
 104     return static_cast<SvMetaSlot *>(GetRef())->GetExecMethod();
 105 }
 106 const OString& SvMetaSlot::GetStateMethod() const
 107 {
 108     if( !aStateMethod.getString().isEmpty() || !GetRef() ) return aStateMethod.getString();
 109     return static_cast<SvMetaSlot *>(GetRef())->GetStateMethod();
 110 }
 111 bool SvMetaSlot::GetToggle() const
 112 {
 113     if( aToggle.IsSet() || !GetRef() ) return aToggle;
 114     return static_cast<SvMetaSlot *>(GetRef())->GetToggle();
 115 }
 116 bool SvMetaSlot::GetAutoUpdate() const
 117 {
 118     if( aAutoUpdate.IsSet() || !GetRef() ) return aAutoUpdate;
 119     return static_cast<SvMetaSlot *>(GetRef())->GetAutoUpdate();
 120 }
 121 bool SvMetaSlot::GetAsynchron() const
 122 {
 123     // Synchron and Asynchron are exclusive
 124     if( !GetRef() || aAsynchron.IsSet() )
 125         return aAsynchron;
 126     return static_cast<SvMetaSlot *>(GetRef())->GetAsynchron();
 127 }
 128 bool SvMetaSlot::GetRecordPerItem() const
 129 {
 130     // Record- PerItem, No, PerSet and Manual are exclusive
 131     if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
 132       || aRecordPerSet.IsSet() )
 133         return aRecordPerItem;
 134     return static_cast<SvMetaSlot *>(GetRef())->GetRecordPerItem();
 135 }
 136 bool SvMetaSlot::GetRecordPerSet() const
 137 {
 138     // Record- PerItem, No, PerSet and Manual are exclusive
 139     if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
 140       || aRecordPerSet.IsSet() )
 141         return aRecordPerSet;
 142     return static_cast<SvMetaSlot *>(GetRef())->GetRecordPerSet();
 143 }
 144 bool SvMetaSlot::GetNoRecord() const
 145 {
 146     // Record- PerItem, No, PerSet and Manual are exclusive
 147     if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
 148       || aRecordPerSet.IsSet()  )
 149         return aNoRecord;
 150     return static_cast<SvMetaSlot *>(GetRef())->GetNoRecord();
 151 }
 152 bool SvMetaSlot::GetRecordAbsolute() const
 153 {
 154     if( !GetRef() || aRecordAbsolute.IsSet() )
 155         return aRecordAbsolute;
 156     return static_cast<SvMetaSlot *>(GetRef())->GetRecordAbsolute();
 157 }
 158 bool SvMetaSlot::GetMenuConfig() const
 159 {
 160     if( aMenuConfig.IsSet() || !GetRef() ) return aMenuConfig;
 161     return static_cast<SvMetaSlot *>(GetRef())->GetMenuConfig();
 162 }
 163 bool SvMetaSlot::GetToolBoxConfig() const
 164 {
 165     if( aToolBoxConfig.IsSet() || !GetRef() ) return aToolBoxConfig;
 166     return static_cast<SvMetaSlot *>(GetRef())->GetToolBoxConfig();
 167 }
 168 bool SvMetaSlot::GetAccelConfig() const
 169 {
 170     if( aAccelConfig.IsSet() || !GetRef() ) return aAccelConfig;
 171     return static_cast<SvMetaSlot *>(GetRef())->GetAccelConfig();
 172 }
 173 bool SvMetaSlot::GetFastCall() const
 174 {
 175     if( aFastCall.IsSet() || !GetRef() ) return aFastCall;
 176     return static_cast<SvMetaSlot *>(GetRef())->GetFastCall();
 177 }
 178 bool SvMetaSlot::GetContainer() const
 179 {
 180     if( aContainer.IsSet() || !GetRef() ) return aContainer;
 181     return static_cast<SvMetaSlot *>(GetRef())->GetContainer();
 182 }
 183
 184 void SvMetaSlot::ReadAttributesSvIdl( SvIdlDataBase & rBase,
 185                                     SvTokenStream & rInStm )
 186 {
 187     SvMetaAttribute::ReadAttributesSvIdl( rBase, rInStm );
 188
 189     aGroupId.ReadSvIdl( SvHash_GroupId(), rInStm );
 190     aExecMethod.ReadSvIdl( SvHash_ExecMethod(), rInStm );
 191     aStateMethod.ReadSvIdl( SvHash_StateMethod(), rInStm );
 192     ReadStringSvIdl( SvHash_DisableFlags(), rInStm, aDisableFlags );
 193     aReadOnlyDoc.ReadSvIdl( SvHash_ReadOnlyDoc(), rInStm );
 194     aExport.ReadSvIdl( SvHash_Export(), rInStm );
 195     aToggle.ReadSvIdl( SvHash_Toggle(), rInStm );
 196     aAutoUpdate.ReadSvIdl( SvHash_AutoUpdate(), rInStm );
 197     aAsynchron.ReadSvIdl( SvHash_Asynchron(), rInStm );
 198     aRecordAbsolute.ReadSvIdl( SvHash_RecordAbsolute(), rInStm );
 199
 200     if( aRecordPerItem.ReadSvIdl( SvHash_RecordPerItem(), rInStm ) )
 201     {
 202         SetRecordPerItem( aRecordPerItem );
 203     }
 204     if( aRecordPerSet.ReadSvIdl( SvHash_RecordPerSet(), rInStm ) )
 205     {
 206         SetRecordPerSet( aRecordPerSet );
 207     }
 208     if( aNoRecord.ReadSvIdl( SvHash_NoRecord(), rInStm ) )
 209     {
 210         SetNoRecord( aNoRecord );
 211     }
 212
 213     aMenuConfig.ReadSvIdl( SvHash_MenuConfig(), rInStm );
 214     aToolBoxConfig.ReadSvIdl( SvHash_ToolBoxConfig(), rInStm );
 215     aAccelConfig.ReadSvIdl( SvHash_AccelConfig(), rInStm );
 216
 217     aFastCall.ReadSvIdl( SvHash_FastCall(), rInStm );
 218     aContainer.ReadSvIdl( SvHash_Container(), rInStm );
 219 }
 220
 221 bool SvMetaSlot::Test( SvTokenStream & rInStm )
 222 {
 223     bool bOk = SvMetaAttribute::Test( rInStm );
 224     if( bOk )
 225     {
 226         SvMetaType * pType = GetType();
 227         if( pType->GetMetaTypeType() == MetaTypeType::Method )
 228             pType = pType->GetReturnType();
 229         if( !pType->IsItem() )
 230         {
 231             throw SvParseException( rInStm, "this attribute is not a slot" );
 232         }
 233     }
 234
 235     return bOk;
 236 }
 237
 238 bool SvMetaSlot::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
 239 {
 240     sal_uInt32  nTokPos     = rInStm.Tell();
 241     bool bOk = true;
 242
 243     SvMetaAttribute * pAttr = rBase.ReadKnownAttr( rInStm, GetType() );
 244     if( pAttr )
 245     {
 246         // c
 247         SvMetaSlot * pKnownSlot = dynamic_cast<SvMetaSlot*>( pAttr  );
 248         if( !pKnownSlot )
 249             throw SvParseException( rInStm, "attribute " + pAttr->GetName() + " is method or variable but not a slot" );
 250         SetRef( pKnownSlot );
 251         SetName( pKnownSlot->GetName() );
 252         bOk = SvMetaObject::ReadSvIdl( rBase, rInStm );
 253     }
 254     else
 255     {
 256         bOk = SvMetaAttribute::ReadSvIdl( rBase, rInStm );
 257
 258         SvMetaAttribute *pAttr2 = rBase.FindKnownAttr( GetSlotId() );
 259         if( pAttr2 )
 260         {
 261             // for testing purposes: reference in case of complete definition
 262             SvMetaSlot * pKnownSlot = dynamic_cast<SvMetaSlot*>( pAttr2  );
 263             if( !pKnownSlot )
 264                 throw SvParseException( rInStm, "attribute " + pAttr2->GetName() + " is method or variable but not a slot" );
 265             SetRef( pKnownSlot );
 266
 267               // names may differ, because explicitly given
 268             if ( pKnownSlot->GetName() != GetName() )
 269             {
 270                 OSL_FAIL("Illegal definition!");
 271                 rInStm.Seek( nTokPos );
 272                 return false;
 273             }
 274
 275             SetName( pKnownSlot->GetName() );
 276         }
 277     }
 278
 279     if( !bOk )
 280         rInStm.Seek( nTokPos );
 281
 282     return bOk;
 283 }
 284
 285 void SvMetaSlot::Insert( SvSlotElementList& rList)
 286 {
 287     // get insert position through binary search in slotlist
 288     sal_uInt16 nId = static_cast<sal_uInt16>(GetSlotId().GetValue());
 289     sal_uInt16 nListCount = static_cast<sal_uInt16>(rList.size());
 290     sal_uInt16 nPos;
 291
 292     if ( !nListCount )
 293         nPos = 0;
 294     else if ( nListCount == 1 )
 295         nPos = rList[ 0 ]->GetSlotId().GetValue() >= nId ? 0 : 1;
 296     else
 297     {
 298         sal_uInt16 nMid = 0, nLow = 0;
 299         sal_uInt16 nHigh = nListCount - 1;
 300         bool bFound = false;
 301         while ( !bFound && nLow <= nHigh )
 302         {
 303             nMid = (nLow + nHigh) >> 1;
 304             DBG_ASSERT( nMid < nListCount, "bsearch is buggy" );
 305             int nDiff = static_cast<int>(nId) - static_cast<int>(rList[ nMid ]->GetSlotId().GetValue());
 306             if ( nDiff < 0)
 307             {
 308                 if ( nMid == 0 )
 309                     break;
 310                 nHigh = nMid - 1;
 311             }
 312             else if ( nDiff > 0 )
 313             {
 314                 nLow = nMid + 1;
 315                 if ( nLow == 0 )
 316                     break;
 317             }
 318             else
 319                 bFound = true;
 320         }
 321
 322         DBG_ASSERT(!bFound, "Duplicate SlotId!");
 323         nPos = bFound ? nMid : nLow;
 324     }
 325
 326     DBG_ASSERT( nPos <= nListCount,
 327         "nPos too large" );
 328     DBG_ASSERT( nPos == nListCount || nId <=
 329         static_cast<sal_uInt16>(rList[ nPos ]->GetSlotId().GetValue()),
 330         "Successor has lower SlotId" );
 331     DBG_ASSERT( nPos == 0 || nId >
 332         static_cast<sal_uInt16>(rList[ nPos-1 ]->GetSlotId().GetValue()),
 333         "Predecessor has higher SlotId" );
 334     DBG_ASSERT( nPos+1 >= nListCount || nId <
 335         static_cast<sal_uInt16>(rList[ nPos+1 ]->GetSlotId().GetValue()),
 336         "Successor has lower SlotId" );
 337
 338     if ( nPos < rList.size() )
 339     {
 340         SvSlotElementList::iterator it = rList.begin();
 341         std::advance( it, nPos );
 342         rList.insert( it, this );
 343     }
 344     else
 345     {
 346         rList.push_back( this );
 347     }
 348 }
 349
 350
 351 static OString MakeSlotName( SvStringHashEntry const * pEntry )
 352 {
 353     return "SfxSlotMode::" + pEntry->GetName().toAsciiUpperCase();
 354 };
 355
 356 void SvMetaSlot::WriteSlotStubs( const OString& rShellName,
 357                                 std::vector<OString> & rList,
 358                                 SvStream & rOutStm ) const
 359 {
 360     if ( !GetExport() && !GetHidden() )
 361         return;
 362
 363     OString aMethodName( GetExecMethod() );
 364     if ( !aMethodName.isEmpty() &&
 365          aMethodName != "NoExec" )
 366     {
 367         bool bIn = false;
 368         for( size_t n = 0; n < rList.size(); n++ )
 369         {
 370             if (rList[n] == aMethodName)
 371             {
 372                 bIn = true;
 373                 break;
 374             }
 375         }
 376
 377         if ( !bIn )
 378         {
 379             rList.push_back( aMethodName );
 380             rOutStm.WriteCharPtr( "SFX_EXEC_STUB(" )
 381                    .WriteOString( rShellName )
 382                    .WriteChar( ',' )
 383                    .WriteOString( aMethodName )
 384                    .WriteChar( ')' ) << endl;
 385         }
 386     }
 387
 388     aMethodName = GetStateMethod();
 389     if (!aMethodName.isEmpty() &&
 390         aMethodName != "NoState")
 391     {
 392         bool bIn = false;
 393         for ( size_t n=0; n < rList.size(); n++ )
 394         {
 395             if (rList[n] == aMethodName)
 396             {
 397                 bIn = true;
 398                 break;
 399             }
 400         }
 401
 402         if ( !bIn )
 403         {
 404             rList.push_back( aMethodName );
 405             rOutStm.WriteCharPtr( "SFX_STATE_STUB(" )
 406                    .WriteOString( rShellName )
 407                    .WriteChar( ',' )
 408                    .WriteOString( aMethodName )
 409                    .WriteChar( ')' ) << endl;
 410         }
 411     }
 412 }
 413
 414 void SvMetaSlot::WriteSlot( const OString& rShellName, sal_uInt16 nCount,
 415                             const OString& rSlotId,
 416                             SvSlotElementList& rSlotList,
 417                             size_t nStart,
 418                             SvIdlDataBase & rBase, SvStream & rOutStm )
 419 {
 420     if ( !GetExport() && !GetHidden() )
 421         return;
 422
 423     rOutStm.WriteCharPtr( "// Slot Nr. " )
 424        .WriteOString( OString::number(nListPos) )
 425        .WriteCharPtr( " : " );
 426     OString aSlotIdValue(OString::number(GetSlotId().GetValue()));
 427     rOutStm.WriteOString( aSlotIdValue ) << endl;
 428     WriteTab( rOutStm, 1 );
 429     rOutStm.WriteCharPtr( "SFX_NEW_SLOT_ARG( " ).WriteOString( rShellName ).WriteChar( ',' ) ;
 430
 431     rOutStm.WriteOString( rSlotId ).WriteChar( ',' );
 432
 433     // GroupId
 434     if( !GetGroupId().isEmpty() )
 435         rOutStm.WriteOString( GetGroupId() );
 436     else
 437         rOutStm.WriteCharPtr( "SfxGroupId::NONE" );
 438     rOutStm.WriteChar( ',' ) << endl;
 439     WriteTab( rOutStm, 4 );
 440
 441     // look for the next slot with the same StateMethod like me
 442     // the slotlist is set to the current slot
 443     size_t i = nStart;
 444     SvMetaSlot* pEle = ( ++i < rSlotList.size() ) ? rSlotList[ i ] : nullptr;
 445     pNextSlot = pEle;
 446     while ( pNextSlot )
 447     {
 448         if ( !pNextSlot->pNextSlot &&
 449             pNextSlot->GetStateMethod() == GetStateMethod()
 450         ) {
 451             break;
 452         }
 453         pEle = ( ++i < rSlotList.size() ) ? rSlotList[ i ] : nullptr;
 454         pNextSlot = pEle;
 455     }
 456
 457     if ( !pNextSlot )
 458     {
 459         // There is no slot behind me that has the same ExecMethod.
 460         // So I search for the first slot with it (could be myself).
 461         i = 0;
 462         pEle = rSlotList.empty() ? nullptr : rSlotList[ i ];
 463         pNextSlot = pEle;
 464         while (pNextSlot && pNextSlot != this)
 465         {
 466             if ( pNextSlot->GetStateMethod() == GetStateMethod() )
 467                 break;
 468             pEle = ( ++i < rSlotList.size() ) ? rSlotList[ i ] : nullptr;
 469             pNextSlot = pEle;
 470         }
 471     }
 472
 473     assert(pNextSlot);
 474
 475     rOutStm.WriteCharPtr( "&a" ).WriteOString( rShellName ).WriteCharPtr( "Slots_Impl[" )
 476        .WriteOString( OString::number(pNextSlot->GetListPos()) )
 477        .WriteCharPtr( "] /*Offset Next*/, " ) << endl;
 478
 479     WriteTab( rOutStm, 4 );
 480
 481     // write ExecMethod, with standard name if not specified
 482     if( !GetExecMethod().isEmpty() &&
 483         GetExecMethod() != "NoExec")
 484     {
 485         rOutStm.WriteCharPtr( "SFX_STUB_PTR(" ).WriteOString( rShellName ).WriteChar( ',' )
 486                .WriteOString( GetExecMethod() ).WriteChar( ')' );
 487     }
 488     else
 489         rOutStm.WriteCharPtr( "SFX_STUB_PTR_EXEC_NONE" );
 490     rOutStm.WriteChar( ',' );
 491
 492     // write StateMethod, with standard name if not specified
 493     if( !GetStateMethod().isEmpty() &&
 494         GetStateMethod() != "NoState")
 495     {
 496         rOutStm.WriteCharPtr( "SFX_STUB_PTR(" ).WriteOString( rShellName ).WriteChar( ',' )
 497                .WriteOString( GetStateMethod() ).WriteChar( ')' );
 498     }
 499     else
 500         rOutStm.WriteCharPtr( "SFX_STUB_PTR_STATE_NONE" );
 501
 502     rOutStm.WriteChar( ',' ) << endl;
 503     WriteTab( rOutStm, 4 );
 504
 505     // write flags
 506     if( GetToggle() )
 507         rOutStm.WriteOString( MakeSlotName( SvHash_Toggle() ) ).WriteChar( '|' );
 508     if( GetAutoUpdate() )
 509         rOutStm.WriteOString( MakeSlotName( SvHash_AutoUpdate() ) ).WriteChar( '|' );
 510     if( GetAsynchron() )
 511         rOutStm.WriteOString( MakeSlotName( SvHash_Asynchron() ) ).WriteChar( '|' );
 512     if( GetRecordPerItem() )
 513         rOutStm.WriteOString( MakeSlotName( SvHash_RecordPerItem() ) ).WriteChar( '|' );
 514     if( GetRecordPerSet() )
 515         rOutStm.WriteOString( MakeSlotName( SvHash_RecordPerSet() ) ).WriteChar( '|' );
 516     if( GetNoRecord() )
 517         rOutStm.WriteOString( MakeSlotName( SvHash_NoRecord() ) ).WriteChar( '|' );
 518     if( GetRecordAbsolute() )
 519         rOutStm.WriteOString( MakeSlotName( SvHash_RecordAbsolute() ) ).WriteChar( '|' );
 520     if( GetMenuConfig() )
 521         rOutStm.WriteOString( MakeSlotName( SvHash_MenuConfig() ) ).WriteChar( '|' );
 522     if( GetToolBoxConfig() )
 523         rOutStm.WriteOString( MakeSlotName( SvHash_ToolBoxConfig() ) ).WriteChar( '|' );
 524     if( GetAccelConfig() )
 525         rOutStm.WriteOString( MakeSlotName( SvHash_AccelConfig() ) ).WriteChar( '|' );
 526     if( GetFastCall() )
 527         rOutStm.WriteOString( MakeSlotName( SvHash_FastCall() ) ).WriteChar( '|' );
 528     if( GetContainer() )
 529         rOutStm.WriteOString( MakeSlotName( SvHash_Container() ) ).WriteChar( '|' );
 530     if ( GetReadOnlyDoc() )
 531         rOutStm.WriteOString( MakeSlotName( SvHash_ReadOnlyDoc() ) ).WriteChar( '|' );
 532     rOutStm.WriteCharPtr( "SfxSlotMode::NONE" );
 533
 534     rOutStm.WriteChar( ',' ) << endl;
 535     WriteTab( rOutStm, 4 );
 536     if ( GetDisableFlags().isEmpty() )
 537         rOutStm.WriteCharPtr( "SfxDisableFlags::NONE" );
 538     else
 539         rOutStm.WriteOString( GetDisableFlags() );
 540
 541     // write attribute type
 542     rOutStm.WriteChar( ',' ) << endl;
 543     WriteTab( rOutStm, 4 );
 544
 545     SvMetaType * pT = GetType();
 546     if( !IsVariable() )
 547     {
 548         SvMetaType * pRT = GetType()->GetReturnType();
 549         pT =  pRT ? pRT : rBase.FindType( "SfxVoidItem" );
 550     }
 551
 552     if( pT )
 553     {
 554         assert(pT->IsItem());
 555         rOutStm.WriteOString( pT->GetName() );
 556         if( !SvIdlDataBase::FindType( pT, rBase.aUsedTypes ) )
 557             rBase.aUsedTypes.push_back( pT );
 558     }
 559     else
 560         rOutStm.WriteCharPtr( "SfxVoidItem not defined" );
 561
 562     {
 563         rOutStm.WriteChar( ',' ) << endl;
 564         WriteTab( rOutStm, 4 );
 565         rOutStm
 566            .WriteOString( OString::number(nCount) )
 567            .WriteCharPtr( "/*Offset*/, " );
 568
 569         if( IsMethod() )
 570         {
 571             SvMetaType * pType = GetType();
 572             sal_uLong nSCount = pType->GetAttrCount();
 573             rOutStm
 574                .WriteOString( OString::number(nSCount) )
 575                .WriteCharPtr( "/*Count*/," );
 576         }
 577         else
 578             rOutStm.WriteCharPtr( "0," );
 579
 580         rOutStm.WriteCharPtr( " " );
 581
 582         // Method/Property flags
 583         if( IsMethod() )
 584             rOutStm.WriteCharPtr( "SfxSlotMode::METHOD|" );
 585
 586         rOutStm.WriteCharPtr( "SfxSlotMode::NONE" );
 587     }
 588
 589     {
 590         rOutStm.WriteCharPtr( ",\"" );
 591         rOutStm.WriteOString( GetName() );
 592         rOutStm.WriteCharPtr( "\"" );
 593     }
 594
 595     rOutStm.WriteCharPtr( " )," ) << endl;
 596 }
 597
 598 sal_uInt16 SvMetaSlot::WriteSlotParamArray( SvIdlDataBase & rBase, SvStream & rOutStm ) const
 599 {
 600     if ( !GetExport() && !GetHidden() )
 601         return 0;
 602
 603     if( IsMethod() )
 604     {
 605         SvMetaType * pType = GetType();
 606
 607         if( !SvIdlDataBase::FindType( pType, rBase.aUsedTypes ) )
 608             rBase.aUsedTypes.push_back( pType );
 609
 610         const SvRefMemberList<SvMetaAttribute *>& rList =
 611                     pType->GetAttrList();
 612         for( sal_uLong n = 0; n < rList.size(); n++ )
 613         {
 614             SvMetaAttribute * pPar  = rList[n];
 615             SvMetaType * pPType     = pPar->GetType();
 616             WriteTab( rOutStm, 1 );
 617             rOutStm.WriteCharPtr("{ (const SfxType*) &a")
 618                 // item type
 619                .WriteOString(pPType->GetName()).WriteCharPtr("_Impl, ")
 620                 // parameter name
 621                .WriteCharPtr("\"").WriteOString(pPar->GetName()).WriteCharPtr("\", ")
 622                 // slot id
 623                .WriteOString(pPar->GetSlotId().getString()).WriteCharPtr(" },") << endl;
 624             if( !SvIdlDataBase::FindType( pPType, rBase.aUsedTypes ) )
 625                 rBase.aUsedTypes.push_back( pPType );
 626         }
 627         return static_cast<sal_uInt16>(rList.size());
 628     }
 629     return 0;
 630 }
 631
 632 sal_uInt16 SvMetaSlot::WriteSlotMap( const OString& rShellName, sal_uInt16 nCount,
 633                                 SvSlotElementList& rSlotList,
 634                                 size_t nStart,
 635                                 SvIdlDataBase & rBase,
 636                                 SvStream & rOutStm )
 637 {
 638     // SlotId, if not specified generate from name
 639     OString slotId = GetSlotId().getString();
 640
 641     sal_uInt16 nSCount = 0;
 642     if( IsMethod() )
 643     {
 644         SvMetaType * pType = GetType();
 645         nSCount = static_cast<sal_uInt16>(pType->GetAttrCount());
 646     }
 647
 648     WriteSlot( rShellName, nCount, slotId, rSlotList, nStart, rBase, rOutStm );
 649     return nSCount;
 650 }
 651
 652 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */