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