idl/source/objects/object.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_idl.hxx"
  30
  31 #include <ctype.h>
  32 #include <stdio.h>
  33
  34 #include <tools/debug.hxx>
  35
  36 #include <attrib.hxx>
  37 #include <object.hxx>
  38 #include <globals.hxx>
  39 #include <database.hxx>
  40
  41 /******************** class SvClassElement *******************************/
  42 SV_IMPL_PERSIST1( SvClassElement, SvPersistBase );
  43
  44 /*************************************************************************
  45 |*    SvClassElement::SvClassElement()
  46 |*
  47 |*    Beschreibung
  48 *************************************************************************/
  49 SvClassElement::SvClassElement()
  50 {
  51 };
  52
  53 /*************************************************************************
  54 |*    SvClassElement::Load()
  55 |*
  56 |*    Beschreibung
  57 *************************************************************************/
  58 void SvClassElement::Load( SvPersistStream & rStm )
  59 {
  60     sal_uInt8 nMask;
  61     rStm >> nMask;
  62     if( nMask >= 0x08 )
  63     {
  64         rStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
  65         DBG_ERROR( "wrong format" );
  66         return;
  67     }
  68     if( nMask & 0x01 ) rStm >> aAutomation;
  69     if( nMask & 0x02 ) rStm.ReadByteString( aPrefix );
  70     if( nMask & 0x04 )
  71     {
  72         SvMetaClass * p;
  73         rStm >> p;
  74         xClass = p;
  75     }
  76 }
  77
  78 /*************************************************************************
  79 |*    SvClassElement::Save()
  80 |*
  81 |*    Beschreibung
  82 *************************************************************************/
  83 void SvClassElement::Save( SvPersistStream & rStm )
  84 {
  85     // Maske erstellen
  86     sal_uInt8 nMask = 0;
  87     if( aAutomation.IsSet() )       nMask |= 0x1;
  88     if( aPrefix.Len() )             nMask |= 0x2;
  89     if( xClass.Is() )               nMask |= 0x4;
  90
  91     // Daten schreiben
  92     rStm << nMask;
  93     if( nMask & 0x01 ) rStm << aAutomation;
  94     if( nMask & 0x02 ) rStm.WriteByteString( aPrefix );
  95     if( nMask & 0x04 ) rStm << xClass;
  96 }
  97
  98 /****************** SvMetaClass ******************************************/
  99 SV_IMPL_META_FACTORY1( SvMetaClass, SvMetaType );
 100 /*************************************************************************
 101 |*    SvMetaClass::SvMetaClass()
 102 |*
 103 |*    Beschreibung
 104 *************************************************************************/
 105 SvMetaClass::SvMetaClass()
 106     : aAutomation( sal_True, sal_False )
 107 {
 108 }
 109
 110 /*************************************************************************
 111 |*    SvMetaClass::Load()
 112 |*
 113 |*    Beschreibung
 114 *************************************************************************/
 115 void SvMetaClass::Load( SvPersistStream & rStm )
 116 {
 117     SvMetaType::Load( rStm );
 118
 119     sal_uInt8 nMask;
 120     rStm >> nMask;
 121     if( nMask >= 0x20 )
 122     {
 123         rStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
 124         DBG_ERROR( "wrong format" );
 125         return;
 126     }
 127     if( nMask & 0x01 ) rStm >> aAttrList;
 128     if( nMask & 0x02 )
 129     {
 130         SvMetaClass * pSuper;
 131          rStm >> pSuper;
 132         aSuperClass = pSuper;
 133     }
 134     if( nMask & 0x04 ) rStm >> aClassList;
 135     if( nMask & 0x8 )
 136     {
 137         SvMetaClass * p;
 138         rStm >> p;
 139         xAutomationInterface = p;
 140     }
 141     if( nMask & 0x10 ) rStm >> aAutomation;
 142 }
 143
 144 /*************************************************************************
 145 |*    SvMetaClass::Save()
 146 |*
 147 |*    Beschreibung
 148 *************************************************************************/
 149 void SvMetaClass::Save( SvPersistStream & rStm )
 150 {
 151     SvMetaType::Save( rStm );
 152
 153     // Maske erstellen
 154     sal_uInt8 nMask = 0;
 155     if( aAttrList.Count() )         nMask |= 0x1;
 156     if( aSuperClass.Is() )          nMask |= 0x2;
 157     if( aClassList.Count() )        nMask |= 0x4;
 158     if( xAutomationInterface.Is() ) nMask |= 0x8;
 159     if( aAutomation.IsSet() )       nMask |= 0x10;
 160
 161     // Daten schreiben
 162     rStm << nMask;
 163     if( nMask & 0x01 ) rStm << aAttrList;
 164     if( nMask & 0x02 ) rStm << aSuperClass;
 165     if( nMask & 0x04 ) rStm << aClassList;
 166     if( nMask & 0x08 ) rStm << xAutomationInterface;
 167     if( nMask & 0x10 ) rStm << aAutomation;
 168 }
 169
 170 /*************************************************************************
 171 |*    SvMetaClass::FillSbxObject()
 172 |*
 173 |*    Beschreibung
 174 *************************************************************************/
 175 /*
 176 void SvMetaClass::FillSbxMemberObject( SvIdlDataBase & rBase,
 177                                         SbxObject * pObj,
 178                                         StringList & rSuperList,
 179                                         sal_Bool bVariable )
 180 {
 181     // alle Attribute der Klasse schreiben
 182     sal_uLong n ;
 183     for( n = 0; n < aAttrList.Count(); n++ )
 184     {
 185         SvMetaAttribute * pAttr = aAttrList.GetObject( n );
 186
 187         ByteString aMangleName = pAttr->GetMangleName( bVariable );
 188         ByteString * pS = SvIdlDataBase::FindName( aMangleName, rSuperList );
 189
 190         if( !pS && pAttr->GetExport() )
 191         {
 192             // nicht doppelt
 193             if( bVariable && pAttr->IsVariable() )
 194             {
 195                 rSuperList.Insert( new ByteString( aMangleName ), LIST_APPEND );
 196                  pAttr->FillSbxObject( rBase, pObj, bVariable );
 197             }
 198             else if( !bVariable && pAttr->IsMethod() )
 199             {
 200                 rSuperList.Insert( new ByteString( aMangleName ), LIST_APPEND );
 201                 pAttr->FillSbxObject( rBase, pObj, bVariable );
 202             }
 203         }
 204     }
 205     // alle Attribute der importierten Klassen schreiben
 206     for( n = 0; n < aClassList.Count(); n++ )
 207     {
 208         SvClassElement * pEle = aClassList.GetObject( n );
 209         SvMetaClass * pClass = pEle->GetClass();
 210         pClass->FillSbxMemberObject( rBase, pObj, rSuperList, bVariable );
 211     }
 212     // alle Attribute der Superklassen schreiben
 213     if( aSuperClass.Is() )
 214         aSuperClass->FillSbxMemberObject( rBase, pObj, rSuperList, bVariable );
 215 }
 216 */
 217 /*************************************************************************
 218 |*    SvMetaClass::FillSbxObject()
 219 |*
 220 |*    Beschreibung
 221 *************************************************************************/
 222 /*
 223 void SvMetaClass::FillSbxObject( SvIdlDataBase & rBase, SbxObject * pObj )
 224 {
 225     StringList aSuperList;
 226     FillSbxMemberObject( rBase, pObj, aSuperList, sal_True );
 227     FillSbxMemberObject( rBase, pObj, aSuperList, sal_False );
 228
 229     ByteString * pStr = aSuperList.First();
 230     while( pStr )
 231     {
 232         delete pStr;
 233         pStr = aSuperList.Next();
 234     }
 235 }
 236  */
 237 #ifdef IDL_COMPILER
 238 /*************************************************************************
 239 |*    SvMetaClass::ReadAttributesSvIdl()
 240 |*
 241 |*    Beschreibung
 242 *************************************************************************/
 243 void SvMetaClass::ReadAttributesSvIdl( SvIdlDataBase & rBase,
 244                                         SvTokenStream & rInStm )
 245 {
 246     SvMetaType::ReadAttributesSvIdl( rBase, rInStm );
 247     aAutomation.ReadSvIdl( SvHash_Automation(), rInStm );
 248 }
 249
 250 /*************************************************************************
 251 |*    SvMetaClass::WriteAttributesSvIdl()
 252 |*
 253 |*    Beschreibung
 254 *************************************************************************/
 255 void SvMetaClass::WriteAttributesSvIdl( SvIdlDataBase & rBase,
 256                                  SvStream & rOutStm, sal_uInt16 nTab )
 257 {
 258     SvMetaType::WriteAttributesSvIdl( rBase, rOutStm, nTab );
 259
 260     if( !aAutomation )
 261     {
 262         WriteTab( rOutStm, nTab );
 263         rOutStm << "//class SvMetaClass" << endl;
 264         if( !aAutomation )
 265         {
 266             WriteTab( rOutStm, nTab );
 267             aAutomation.WriteSvIdl( SvHash_Automation(), rOutStm );
 268             rOutStm << ';' << endl;
 269         }
 270     }
 271 }
 272
 273 /*************************************************************************
 274 |*    SvMetaClass::ReadContextSvIdl()
 275 |*
 276 |*    Beschreibung
 277 *************************************************************************/
 278 void SvMetaClass::ReadContextSvIdl( SvIdlDataBase & rBase,
 279                                     SvTokenStream & rInStm )
 280 {
 281     sal_uInt32  nTokPos = rInStm.Tell();
 282     SvToken * pTok = rInStm.GetToken_Next();
 283
 284     if( pTok->Is( SvHash_import() ) )
 285     {
 286         SvMetaClass * pClass = rBase.ReadKnownClass( rInStm );
 287         if( pClass )
 288         {
 289             SvClassElementRef xEle = new SvClassElement();
 290             xEle->SetClass( pClass );
 291             aClassList.Append( xEle );
 292
 293             if( rInStm.Read( '[' ) )
 294             {
 295                 pTok = rInStm.GetToken_Next();
 296                 if( pTok->Is( SvHash_Automation() ) )
 297                 {
 298                     if( rInStm.Read( ']' ) )
 299                     {
 300                         if( xAutomationInterface.Is() )
 301                         {
 302                             // Fehler setzen
 303                             rBase.SetError( "Automation allready set",
 304                                             rInStm.GetToken() );
 305                             rBase.WriteError( rInStm );
 306                         }
 307                         xAutomationInterface = pClass;
 308                         xEle->SetAutomation( sal_True );
 309                     }
 310                     else
 311                     {
 312                         // Fehler setzen
 313                         rBase.SetError( "missing ]", rInStm.GetToken() );
 314                         rBase.WriteError( rInStm );
 315                     }
 316                 }
 317                 else
 318                 {
 319                     // Fehler setzen
 320                     rBase.SetError( "only attribute Automation allowed",
 321                                     rInStm.GetToken() );
 322                     rBase.WriteError( rInStm );
 323                 }
 324             }
 325             pTok = rInStm.GetToken();
 326             if( pTok->IsString() )
 327             {
 328                 xEle->SetPrefix( pTok->GetString() );
 329                 rInStm.GetToken_Next();
 330             }
 331             return;
 332         }
 333         else
 334         {
 335             // Fehler setzen
 336             rBase.SetError( "unknown imported interface", rInStm.GetToken() );
 337             rBase.WriteError( rInStm );
 338         }
 339     }
 340     else
 341     {
 342         rInStm.Seek( nTokPos );
 343         SvMetaType * pType = rBase.ReadKnownType( rInStm );
 344
 345         sal_Bool bOk = sal_False;
 346         SvMetaAttributeRef xAttr;
 347         if( !pType || pType->IsItem() )
 348         {
 349             xAttr = new SvMetaSlot( pType );
 350             if( xAttr->ReadSvIdl( rBase, rInStm ) )
 351                 bOk = xAttr->Test( rBase, rInStm );
 352         }
 353         else
 354         {
 355             xAttr = new SvMetaAttribute( pType );
 356             if( xAttr->ReadSvIdl( rBase, rInStm ) )
 357                 bOk = xAttr->Test( rBase, rInStm );
 358         }
 359
 360         if( bOk )
 361             bOk = TestAttribute( rBase, rInStm, *xAttr );
 362         if( bOk )
 363         {
 364             if( !xAttr->GetSlotId().IsSet() )
 365             {
 366                 SvNumberIdentifier aI;
 367                 aI.SetValue( rBase.GetUniqueId() );
 368                 xAttr->SetSlotId( aI );
 369             }
 370             aAttrList.Append( xAttr );
 371             return;
 372         }
 373     }
 374     rInStm.Seek( nTokPos );
 375 }
 376
 377 /*************************************************************************
 378 |*    SvMetaClass::WriteContextSvIdl()
 379 |*
 380 |*    Beschreibung
 381 *************************************************************************/
 382 void SvMetaClass::WriteContextSvIdl
 383 (
 384     SvIdlDataBase & rBase,
 385     SvStream & rOutStm,
 386     sal_uInt16 nTab
 387 )
 388 {
 389     //SvMetaType::WriteContextSvIdl( rBase, rOutStm, nTab );
 390     sal_uLong n;
 391     for( n = 0; n < aAttrList.Count(); n++ )
 392     {
 393         WriteTab( rOutStm, nTab );
 394         aAttrList.GetObject( n )->WriteSvIdl( rBase, rOutStm, nTab );
 395         rOutStm << ';' << endl;
 396     }
 397     for( n = 0; n < aClassList.Count(); n++ )
 398     {
 399         SvClassElement * pEle = aClassList.GetObject( n );
 400         WriteTab( rOutStm, nTab );
 401         rOutStm << SvHash_import()->GetName().GetBuffer() << ' '
 402                 << pEle->GetPrefix().GetBuffer();
 403         if( pEle->GetAutomation() )
 404             rOutStm << " [ " << SvHash_Automation()->GetName().GetBuffer()
 405                     << " ]";
 406         if( pEle->GetPrefix().Len() )
 407             rOutStm << ' ' << pEle->GetPrefix().GetBuffer();
 408         rOutStm << ';' << endl;
 409     }
 410 }
 411
 412 /*************************************************************************
 413 |*    SvMetaClass::ReadSvIdl()
 414 |*
 415 |*    Beschreibung
 416 *************************************************************************/
 417 sal_Bool SvMetaClass::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
 418 {
 419     sal_uLong nTokPos = rInStm.Tell();
 420     if( SvMetaType::ReadHeaderSvIdl( rBase, rInStm ) && GetType() == TYPE_CLASS )
 421     {
 422         sal_Bool bOk = sal_True;
 423         if( rInStm.Read( ':' ) )
 424         {
 425             aSuperClass = rBase.ReadKnownClass( rInStm );
 426             bOk = aSuperClass.Is();
 427             if( !bOk )
 428             {
 429                 // Fehler setzen
 430                 rBase.SetError( "unknown super class",
 431                                 rInStm.GetToken() );
 432                 rBase.WriteError( rInStm );
 433             }
 434         }
 435         if( bOk )
 436         {
 437             rBase.Write( '.' );
 438             bOk = SvMetaName::ReadSvIdl( rBase, rInStm );
 439         }
 440         if( bOk )
 441             return bOk;
 442     }
 443     rInStm.Seek( nTokPos );
 444     return sal_False;
 445 }
 446
 447 /*************************************************************************
 448 |*    SvMetaClass::TestAttribute()
 449 |*
 450 |*    Beschreibung
 451 *************************************************************************/
 452 sal_Bool SvMetaClass::TestAttribute( SvIdlDataBase & rBase, SvTokenStream & rInStm,
 453                                  SvMetaAttribute & rAttr ) const
 454 {
 455     if ( !rAttr.GetRef() && rAttr.IsA( TYPE( SvMetaSlot ) ) )
 456     {
 457         DBG_ERROR( "Neuer Slot : " );
 458         DBG_ERROR( rAttr.GetSlotId().GetBuffer() );
 459     }
 460
 461     for( sal_uLong n = 0; n < aAttrList.Count(); n++ )
 462     {
 463         SvMetaAttribute * pS = aAttrList.GetObject( n );
 464         if( pS->GetName() == rAttr.GetName() )
 465         {
 466             // Werte muessen uebereinstimmen
 467             if( pS->GetSlotId().GetValue() != rAttr.GetSlotId().GetValue() )
 468             {
 469                 DBG_ERROR( "Gleicher Name in MetaClass : " );
 470                 DBG_ERROR( pS->GetName().GetBuffer() );
 471                 DBG_ERROR( pS->GetSlotId().GetBuffer() );
 472                 DBG_ERROR( rAttr.GetSlotId().GetBuffer() );
 473
 474                 ByteString aStr( "Attribute's " );
 475                 aStr += pS->GetName();
 476                 aStr += " with different id's";
 477                 rBase.SetError( aStr, rInStm.GetToken() );
 478                 rBase.WriteError( rInStm );
 479                 return sal_False;
 480              }
 481         }
 482         else
 483         {
 484             sal_uInt32 nId1 = pS->GetSlotId().GetValue();
 485             sal_uInt32 nId2 = rAttr.GetSlotId().GetValue();
 486             if( nId1 == nId2 && nId1 != 0 /*&& nId2 != 0 ist ueberfluessig*/ )
 487             {
 488                 DBG_ERROR( "Gleiche Id in MetaClass : " );
 489                 DBG_ERROR( ByteString::CreateFromInt32( pS->GetSlotId().GetValue() ).GetBuffer() );
 490                 DBG_ERROR( pS->GetSlotId().GetBuffer() );
 491                 DBG_ERROR( rAttr.GetSlotId().GetBuffer() );
 492
 493                 ByteString aStr( "Attribute " );
 494                 aStr += pS->GetName();
 495                 aStr += " and Attribute ";
 496                 aStr += rAttr.GetName();
 497                 aStr += " with equal id's";
 498                 rBase.SetError( aStr, rInStm.GetToken() );
 499                 rBase.WriteError( rInStm );
 500                 return sal_False;
 501              }
 502         }
 503     }
 504     SvMetaClass * pSC = aSuperClass;
 505     if( pSC )
 506         return pSC->TestAttribute( rBase, rInStm, rAttr );
 507     return sal_True;
 508 }
 509
 510 /*************************************************************************
 511 |*    SvMetaClass::WriteSvIdl()
 512 |*
 513 |*    Beschreibung
 514 *************************************************************************/
 515 void SvMetaClass::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
 516                               sal_uInt16 nTab )
 517 {
 518     WriteHeaderSvIdl( rBase, rOutStm, nTab );
 519     if( aSuperClass.Is() )
 520         rOutStm << " : " << aSuperClass->GetName().GetBuffer();
 521     rOutStm << endl;
 522     SvMetaName::WriteSvIdl( rBase, rOutStm, nTab );
 523     rOutStm << endl;
 524 }
 525
 526 /*************************************************************************
 527 |*    SvMetaClass::WriteOdlMember()
 528 |*
 529 |*    Beschreibung
 530 *************************************************************************/
 531 /*
 532 void SvMetaClass::WriteOdlMembers( ByteStringList & rSuperList,
 533                                     sal_Bool bVariable, sal_Bool bWriteTab,
 534                                        SvIdlDataBase & rBase,
 535                                        SvStream & rOutStm, sal_uInt16 nTab )
 536 {
 537     // alle Attribute schreiben
 538     sal_uLong n;
 539     for( n = 0; n < aAttrList.Count(); n++ )
 540     {
 541         SvMetaAttribute * pAttr = aAttrList.GetObject( n );
 542
 543         ByteString aMangleName = pAttr->GetMangleName( bVariable );
 544         ByteString * pS = rBase.FindName( aMangleName, rSuperList );
 545
 546         if( !pS && pAttr->GetExport() )
 547         {
 548             // nicht doppelt
 549             if( bVariable && pAttr->IsVariable() )
 550             {
 551                 rSuperList.Insert( new ByteString( aMangleName ), LIST_APPEND );
 552                 pAttr->Write( rBase, rOutStm, nTab +1, WRITE_ODL,
 553                                 WA_VARIABLE );
 554                 rOutStm << ';' << endl;
 555             }
 556             else if( !bVariable && pAttr->IsMethod() )
 557             {
 558                 rSuperList.Insert( new ByteString( aMangleName ), LIST_APPEND );
 559                 pAttr->Write( rBase, rOutStm, nTab +1, WRITE_ODL,
 560                                 WA_METHOD );
 561                 rOutStm << ';' << endl;
 562             }
 563         }
 564         else
 565             continue;
 566     }
 567     // alle Attribute der importierten Klassen schreiben
 568     for( n = 0; n < aClassList.Count(); n++ )
 569     {
 570         SvClassElement * pEle = aClassList.GetObject( n );
 571         SvMetaClass * pCl = pEle->GetClass();
 572         pCl->WriteOdlMembers( rSuperList, bVariable, bWriteTab,
 573                                  rBase, rOutStm, nTab );
 574     }
 575     // alle Attribute der Superklassen schreiben
 576     SvMetaClass * pSC = aSuperClass;
 577     if( pSC )
 578         pSC->WriteOdlMembers( rSuperList, bVariable, bWriteTab,
 579                              rBase, rOutStm, nTab );
 580 }
 581  */
 582
 583 /*************************************************************************
 584 |*    SvMetaClass::Write()
 585 |*
 586 |*    Beschreibung
 587 *************************************************************************/
 588 void SvMetaClass::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
 589                         sal_uInt16 nTab,
 590                          WriteType nT, WriteAttribute )
 591 {
 592     rBase.aIFaceName = GetName();
 593     switch( nT )
 594     {
 595         case WRITE_ODL:
 596         {
 597             DBG_ERROR( "Not supported anymore!" );
 598 /*
 599             // Schreibt die Attribute
 600             SvMetaName::Write( rBase, rOutStm, nTab, nT, nA );
 601
 602             WriteTab( rOutStm, nTab );
 603             rOutStm << "dispinterface " << GetName().GetBuffer() << endl;
 604             WriteTab( rOutStm, nTab );
 605             rOutStm << '{' << endl;
 606
 607             WriteTab( rOutStm, nTab );
 608             rOutStm << "properties:";
 609             rOutStm << endl;
 610
 611             StringList aSuperList;
 612             WriteOdlMembers( aSuperList, sal_True, sal_True, rBase, rOutStm, nTab );
 613
 614             WriteTab( rOutStm, nTab );
 615             rOutStm << "methods:";
 616             rOutStm << endl;
 617
 618             WriteOdlMembers( aSuperList, sal_False, sal_True, rBase, rOutStm, nTab );
 619
 620             ByteString * pStr = aSuperList.First();
 621             while( pStr )
 622             {
 623                 delete pStr;
 624                 pStr = aSuperList.Next();
 625             }
 626
 627             WriteTab( rOutStm, 1 );
 628             rOutStm << '}' << endl;
 629  */
 630             break;
 631         }
 632         case WRITE_C_SOURCE:
 633         case WRITE_C_HEADER:
 634         {
 635             DBG_ERROR( "Not supported anymore!" );
 636 /*
 637             StringList aSuperList;
 638             if( nT == WRITE_C_SOURCE )
 639             {
 640                 rOutStm << "#pragma code_seg (\"" << GetName().GetBuffer()
 641                     << "\",\"CODE\")" << endl;
 642             }
 643             WriteCFunctions( aSuperList, rBase, rOutStm, nTab, nT );
 644  */
 645             break;
 646         }
 647         case WRITE_DOCU:
 648         {
 649             rOutStm << "<INTERFACE>" << endl
 650                     << GetName().GetBuffer();
 651             if ( GetAutomation() )
 652                 rOutStm << " ( Automation ) ";
 653             rOutStm << endl;
 654             WriteDescription( rOutStm );
 655             rOutStm << "</INTERFACE>" << endl << endl;
 656
 657             // alle Attribute schreiben
 658             sal_uLong n;
 659             for( n = 0; n < aAttrList.Count(); n++ )
 660             {
 661                 SvMetaAttribute * pAttr = aAttrList.GetObject( n );
 662                 if( !pAttr->GetHidden() )
 663                 {
 664                     if( pAttr->IsMethod() )
 665                         pAttr->Write( rBase, rOutStm, nTab, nT, WA_METHOD );
 666
 667                     if( pAttr->IsVariable() )
 668                         pAttr->Write( rBase, rOutStm, nTab, nT, WA_VARIABLE );
 669                 }
 670             }
 671
 672             break;
 673         }
 674         default:
 675             break;
 676     }
 677 }
 678
 679 /*************************************************************************
 680 |*    SvMetaClass::WriteSlotParamArray()
 681 |*
 682 |*    Beschreibung
 683 *************************************************************************/
 684 sal_uInt16 SvMetaClass::WriteSlotParamArray( SvIdlDataBase & rBase,
 685                                         SvSlotElementList & rSlotList,
 686                                         SvStream & rOutStm )
 687 {
 688     sal_uInt16 nCount = 0;
 689     for( sal_uLong n = 0; n < rSlotList.Count(); n++ )
 690     {
 691         SvSlotElement *pEle = rSlotList.GetObject( n );
 692         SvMetaSlot *pAttr = pEle->xSlot;
 693         nCount = nCount + pAttr->WriteSlotParamArray( rBase, rOutStm );
 694     }
 695
 696     return nCount;
 697 }
 698
 699 /*************************************************************************
 700 |*    SvMetaClass::WriteSlots()
 701 |*
 702 |*    Beschreibung
 703 *************************************************************************/
 704 sal_uInt16 SvMetaClass::WriteSlots( const ByteString & rShellName,
 705                                 sal_uInt16 nCount, SvSlotElementList & rSlotList,
 706                                 SvIdlDataBase & rBase,
 707                                 SvStream & rOutStm )
 708 {
 709     sal_uInt16 nSCount = 0;
 710     for( sal_uLong n = 0; n < rSlotList.Count(); n++ )
 711     {
 712         rSlotList.Seek(n);
 713         SvSlotElement * pEle = rSlotList.GetCurObject();
 714         SvMetaSlot * pAttr = pEle->xSlot;
 715         nSCount = nSCount + pAttr->WriteSlotMap( rShellName, nCount + nSCount,
 716                                         rSlotList, pEle->aPrefix, rBase,
 717                                         rOutStm );
 718     }
 719
 720     return nSCount;
 721 }
 722
 723 /*************************************************************************
 724 |*    SvMetaClass::InsertSlots()
 725 |*
 726 |*    Beschreibung
 727 *************************************************************************/
 728 void SvMetaClass::InsertSlots( SvSlotElementList& rList, SvULongs& rSuperList,
 729                             SvMetaClassList &rClassList,
 730                             const ByteString & rPrefix, SvIdlDataBase& rBase)
 731 {
 732     // Wurde diese Klasse schon geschrieben ?
 733     if ( rClassList.GetPos(this) != LIST_ENTRY_NOTFOUND )
 734         return;
 735
 736     rClassList.Insert(this, LIST_APPEND);
 737
 738     // alle direkten Attribute schreiben
 739     sal_uLong n;
 740     for( n = 0; n < aAttrList.Count(); n++ )
 741     {
 742         SvMetaAttribute * pAttr = aAttrList.GetObject( n );
 743
 744         sal_uLong nId = pAttr->GetSlotId().GetValue();
 745         sal_uInt16 nPos;
 746         for ( nPos=0; nPos < rSuperList.Count(); nPos++ )
 747         {
 748             if ( rSuperList.GetObject(nPos) == nId )
 749                 break;
 750         }
 751
 752         if( nPos == rSuperList.Count() )
 753         {
 754             // nur schreiben, wenn nicht schon bei SubClass oder
 755             // importiertem Interface geschrieben
 756             rSuperList.Insert( nId, nPos );
 757             pAttr->Insert(rList, rPrefix, rBase);
 758         }
 759     }
 760
 761     // Alle schon von SuperShells importierten Interfaces sollen nicht
 762     // mehr geschrieben werden
 763     // Es ist also verboten, da\s Shell und SuperShell die gleiche Klasse
 764     // direkt importieren !
 765     if( IsShell() && aSuperClass.Is() )
 766         aSuperClass->FillClasses( rClassList );
 767
 768     // alle Attribute der importierten Klassen schreiben, sofern diese nicht
 769     // schon von der Superklasse importiert wurden
 770     for( n = 0; n < aClassList.Count(); n++ )
 771     {
 772         SvClassElement * pEle = aClassList.GetObject( n );
 773         SvMetaClass * pCl = pEle->GetClass();
 774         ByteString rPre = rPrefix;
 775         if( rPre.Len() && pEle->GetPrefix().Len() )
 776             rPre += '.';
 777         rPre += pEle->GetPrefix();
 778
 779         // Zun"achst die direkt importierten Interfaces schreiben
 780         pCl->InsertSlots( rList, rSuperList, rClassList, rPre, rBase );
 781     }
 782
 783     // Superklassen nur schreiben, wenn keine Shell und nicht in der Liste
 784     if( !IsShell() && aSuperClass.Is() )
 785     {
 786         aSuperClass->InsertSlots( rList, rSuperList, rClassList, rPrefix, rBase );
 787     }
 788 }
 789
 790 /*************************************************************************
 791 |*    SvMetaClass::FillClasses()
 792 |*
 793 |*    Beschreibung
 794 *************************************************************************/
 795 void SvMetaClass::FillClasses( SvMetaClassList & rList )
 796 {
 797     // Bin ich noch nicht drin ?
 798     if ( rList.GetPos(this) == LIST_ENTRY_NOTFOUND )
 799     {
 800         rList.Insert(this, LIST_APPEND);
 801
 802         // Meine Imports
 803         for( sal_uLong n = 0; n < aClassList.Count(); n++ )
 804         {
 805             SvClassElement * pEle = aClassList.GetObject( n );
 806             SvMetaClass * pCl = pEle->GetClass();
 807             pCl->FillClasses( rList );
 808         }
 809
 810         // Meine Superklasse
 811         if( aSuperClass.Is() )
 812             aSuperClass->FillClasses( rList );
 813     }
 814 }
 815
 816
 817 /*************************************************************************
 818 |*    SvMetaClass::WriteSlotStubs()
 819 |*
 820 |*    Beschreibung
 821 *************************************************************************/
 822 void SvMetaClass::WriteSlotStubs( const ByteString & rShellName,
 823                                 SvSlotElementList & rSlotList,
 824                                 ByteStringList & rList,
 825                                 SvStream & rOutStm )
 826 {
 827     // alle Attribute schreiben
 828     for( sal_uLong n = 0; n < rSlotList.Count(); n++ )
 829     {
 830         SvSlotElement *pEle = rSlotList.GetObject( n );
 831         SvMetaSlot *pAttr = pEle->xSlot;
 832         pAttr->WriteSlotStubs( rShellName, rList, rOutStm );
 833     }
 834 }
 835
 836 /*************************************************************************
 837 |*    SvMetaClass::WriteSfx()
 838 |*
 839 |*    Beschreibung
 840 *************************************************************************/
 841 void SvMetaClass::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm )
 842 {
 843     WriteStars( rOutStm );
 844     // Klasse definieren
 845     rOutStm << "#ifdef " << GetName().GetBuffer() << endl;
 846     rOutStm << "#undef ShellClass" << endl;
 847     rOutStm << "#undef " << GetName().GetBuffer() << endl;
 848     rOutStm << "#define ShellClass " << GetName().GetBuffer() << endl;
 849
 850 //    rOutStm << "SFX_TYPELIB(" << GetName().GetBuffer() << ',' << endl
 851 //        << "\t/* library type */"
 852 //        << '"' << ByteString( GetModule()->GetUUId().GetHexName(), RTL_TEXTENCODING_UTF8 ).GetBuffer() << "\"," << endl
 853 //        << "\t\"" << GetModule()->GetTypeLibFileName().GetBuffer() << "\","
 854 //        << ByteString::CreateFromInt32( GetModule()->GetVersion().GetMajorVersion() ).GetBuffer() << ','
 855 //        << ByteString::CreateFromInt32( GetModule()->GetVersion().GetMinorVersion() ).GetBuffer() << ',' << endl
 856 //        << "\t/* shell type   */"
 857 //        << '"';
 858 //    if( xAutomationInterface.Is() )
 859 //        rOutStm << ByteString( xAutomationInterface->GetUUId().GetHexName(), RTL_TEXTENCODING_UTF8 ).GetBuffer();
 860 //    else
 861 //        rOutStm << ByteString( GetUUId().GetHexName(), RTL_TEXTENCODING_UTF8 ).GetBuffer();
 862 //    rOutStm << "\");" << endl << endl;
 863
 864     // Fuer Interfaces werden kein Slotmaps geschrieben
 865     if( !IsShell() )
 866     {
 867         rOutStm << "#endif" << endl << endl;
 868         return;
 869     }
 870     // Parameter Array schreiben
 871     //rOutStm << "SfxArgList " << GetName().GetBuffer() << "ArgMap[] = {" << endl;
 872     rOutStm << "SFX_ARGUMENTMAP(" << GetName().GetBuffer() << ')' << endl
 873         << '{' << endl;
 874
 875     SvULongs aSuperList;
 876     SvMetaClassList classList;
 877     SvSlotElementList aSlotList;
 878     InsertSlots(aSlotList, aSuperList, classList, ByteString(), rBase);
 879     sal_uLong n;
 880     for ( n=0; n<aSlotList.Count(); n++ )
 881     {
 882         SvSlotElement *pEle = aSlotList.GetObject( n );
 883         SvMetaSlot *pSlot = pEle->xSlot;
 884         pSlot->SetListPos(n);
 885     }
 886
 887     sal_uLong nSlotCount = aSlotList.Count();
 888
 889     // alle Attribute schreiben
 890     sal_uInt16 nArgCount = WriteSlotParamArray( rBase, aSlotList, rOutStm );
 891     if( nArgCount )
 892         Back2Delemitter( rOutStm );
 893     else
 894     {
 895         // mindestens einen dummy
 896         WriteTab( rOutStm, 1 );
 897         rOutStm << "SFX_ARGUMENT( 0, 0, SfxVoidItem )" << endl;
 898     }
 899     rOutStm << endl << "};" << endl << endl;
 900
 901     ByteStringList aStringList;
 902     WriteSlotStubs( GetName(), aSlotList, aStringList, rOutStm );
 903     ByteString * pStr = aStringList.First();
 904     while( pStr )
 905     {
 906         delete pStr;
 907         pStr = aStringList.Next();
 908     }
 909
 910     rOutStm << endl;
 911
 912     // Slotmap schreiben
 913     rOutStm << "SFX_SLOTMAP_ARG(" << GetName().GetBuffer() << ')' << endl
 914         << '{' << endl;
 915
 916     // alle Attribute schreiben
 917     WriteSlots( GetName(), 0, aSlotList, rBase, rOutStm );
 918     if( nSlotCount )
 919         Back2Delemitter( rOutStm );
 920     else
 921     {
 922         // mindestens einen dummy
 923         WriteTab( rOutStm, 1 );
 924         rOutStm << "SFX_SLOT_ARG(" << GetName().GetBuffer()
 925                 << ", 0, 0, "
 926                 << "SFX_STUB_PTR_EXEC_NONE,"
 927                 << "SFX_STUB_PTR_STATE_NONE,"
 928                 << "0, SfxVoidItem, 0, 0, \"\", 0 )" << endl;
 929     }
 930     rOutStm << endl << "};" << endl << "#endif" << endl << endl;
 931
 932     for( n=0; n<aSlotList.Count(); n++ )
 933     {
 934         aSlotList.Seek(n);
 935         SvSlotElement* pEle = aSlotList.GetCurObject();
 936         SvMetaSlot* pAttr = pEle->xSlot;
 937         pAttr->ResetSlotPointer();
 938     }
 939
 940     for ( n=0; n<aSlotList.Count(); n++ )
 941         delete aSlotList.GetObject(n);
 942 }
 943
 944 void SvMetaClass::WriteHelpIds( SvIdlDataBase & rBase, SvStream & rOutStm,
 945                             Table* pTable )
 946 {
 947     for( sal_uLong n=0; n<aAttrList.Count(); n++ )
 948     {
 949         SvMetaAttribute * pAttr = aAttrList.GetObject( n );
 950         pAttr->WriteHelpId( rBase, rOutStm, pTable );
 951     }
 952 }
 953
 954 /*************************************************************************
 955 |*    SvMetaShell::WriteSrc()
 956 *************************************************************************/
 957 void SvMetaClass::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm,
 958                              Table * pTable )
 959 {
 960     for( sal_uLong n=0; n<aAttrList.Count(); n++ )
 961     {
 962         SvMetaAttribute * pAttr = aAttrList.GetObject( n );
 963         pAttr->WriteSrc( rBase, rOutStm, pTable );
 964     }
 965 }
 966
 967 /*************************************************************************
 968 |*    SvMetaClass::WriteHxx()
 969 |*
 970 |*    Beschreibung
 971 *************************************************************************/
 972 void SvMetaClass::WriteHxx( SvIdlDataBase &, SvStream & rOutStm, sal_uInt16 )
 973 {
 974     ByteString aSuperName( "SvDispatch" );
 975     if( GetSuperClass() )
 976         aSuperName = GetSuperClass()->GetName();
 977     const char * pSup = aSuperName.GetBuffer();
 978
 979     rOutStm
 980     << "class " << GetSvName().GetBuffer()
 981     << ": public " << pSup << endl
 982     << '{' << endl
 983     << "protected:" << endl
 984     << "\tvirtual SvGlobalName  GetTypeName() const;" << endl
 985     << "\tvirtual sal_Bool          FillTypeLibInfo( SvGlobalName *, sal_uInt16 * pMajor," << endl
 986     << "\t                                       sal_uInt16 * pMinor ) const;" << endl
 987     << "\tvirtual sal_Bool          FillTypeLibInfo( ByteString * pName, sal_uInt16 * pMajor," << endl;
 988     rOutStm
 989     << "\t                                       sal_uInt16 * pMinor ) const;" << endl
 990     << "\tvirtual void          Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) = 0;" << endl
 991     << "public:" << endl
 992     << "\t static SvGlobalName  ClassName()" << endl
 993     << "\t                      { return SvGlobalName( " << ByteString( GetUUId().GetctorName(), RTL_TEXTENCODING_UTF8 ).GetBuffer() << " ); }" << endl
 994     << "};" << endl;
 995 }
 996
 997 /*************************************************************************
 998 |*    SvMetaClass::WriteCxx()
 999 |*
1000 |*    Beschreibung
1001 *************************************************************************/
1002 void SvMetaClass::WriteCxx( SvIdlDataBase &, SvStream & rOutStm, sal_uInt16 )
1003 {
1004     ByteString aSuperName( "SvDispatch" );
1005     if( GetSuperClass() )
1006         aSuperName = GetSuperClass()->GetName();
1007     const char * pSup = aSuperName.GetBuffer();
1008
1009     ByteString name = GetSvName();
1010     // GetTypeName
1011     rOutStm << "SvGlobalName " << name.GetBuffer() << "::GetTypeName() const" << endl
1012     << '{' << endl
1013     << "\treturn ClassName();" << endl
1014     << '}' << endl;
1015
1016     SvMetaModule * pMod = GetModule();
1017     // FillTypeLibInfo
1018     rOutStm << "sal_Bool " << name.GetBuffer() << "::FillTypeLibInfo( SvGlobalName * pGN," << endl
1019     << "\t                               sal_uInt16 * pMajor," << endl
1020     << "\t                               sal_uInt16 * pMinor ) const" << endl
1021     << '{' << endl
1022     << "\tSvGlobalName aN( " << ByteString( pMod->GetUUId().GetctorName(), RTL_TEXTENCODING_UTF8 ).GetBuffer() << " );" << endl;
1023     rOutStm << "\t*pGN = aN;" << endl
1024     << "\t*pMajor = " << ByteString::CreateFromInt32(pMod->GetVersion().GetMajorVersion()).GetBuffer() << ';' << endl
1025     << "\t*pMinor = " << ByteString::CreateFromInt32(pMod->GetVersion().GetMinorVersion()).GetBuffer() << ';' << endl
1026     << "\treturn sal_True;" << endl
1027     << '}' << endl;
1028
1029     // FillTypeLibInfo
1030     rOutStm << "sal_Bool " << name.GetBuffer() << "::FillTypeLibInfo( ByteString * pName,"
1031     << "\t                               sal_uInt16 * pMajor," << endl
1032     << "\t                               sal_uInt16 * pMinor ) const" << endl;
1033     rOutStm << '{' << endl
1034     << "\t*pName = \"" << pMod->GetTypeLibFileName().GetBuffer()  << "\";" << endl
1035     << "\t*pMajor = " << ByteString::CreateFromInt32(pMod->GetVersion().GetMajorVersion()).GetBuffer() << ';' << endl
1036     << "\t*pMinor = " << ByteString::CreateFromInt32(pMod->GetVersion().GetMinorVersion()).GetBuffer() << ';' << endl
1037     << "\treturn sal_True;" << endl
1038     << '}' << endl;
1039
1040     rOutStm << "void " << name.GetBuffer() << "::Notify( SfxBroadcaster& rBC, const SfxHint& rHint )" << endl
1041     << '{' << endl
1042     << "\t" << pSup << "::Notify( rBC, rHint );" << endl
1043     << '}' << endl;
1044 }
1045
1046 #endif // IDL_COMPILER
1047