idl/source/objects/types.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29
  30 #include <ctype.h>
  31 #include <stdio.h>
  32
  33 #include <tools/debug.hxx>
  34
  35 #include <types.hxx>
  36 #include <globals.hxx>
  37 #include <database.hxx>
  38
  39 SV_IMPL_META_FACTORY1( SvMetaAttribute, SvMetaReference );
  40 SvMetaAttribute::SvMetaAttribute()
  41     : aAutomation( sal_True, sal_False )
  42     , aExport( sal_True, sal_False )
  43     , aIsCollection ( sal_False, sal_False )
  44     , aReadOnlyDoc ( sal_True, sal_False )
  45     , aHidden( sal_False, sal_False )
  46     , bNewAttr( sal_False )
  47 {
  48 }
  49
  50 SvMetaAttribute::SvMetaAttribute( SvMetaType * pType )
  51     : aType( pType )
  52     , aAutomation( sal_True, sal_False )
  53     , aExport( sal_True, sal_False )
  54     , aIsCollection ( sal_False, sal_False)
  55     , aReadOnlyDoc ( sal_True, sal_False)
  56     , aHidden( sal_False, sal_False )
  57     , bNewAttr( sal_False )
  58 {
  59 }
  60
  61 void SvMetaAttribute::Load( SvPersistStream & rStm )
  62 {
  63     SvMetaReference::Load( rStm );
  64
  65     sal_uInt8 nMask;
  66     rStm >> nMask;
  67     if( nMask & 0x01 )
  68     {
  69         SvMetaType * pType;
  70         rStm >> pType;
  71         aType = pType;
  72     }
  73     if( nMask & 0x02 )  rStm >> aSlotId;
  74     if( nMask & 0x04 )  rStm >> aExport;
  75     if( nMask & 0x08 )  rStm >> aReadonly;
  76     if( nMask & 0x10 )  rStm >> aAutomation;
  77     if( nMask & 0x20 )  rStm >> aIsCollection;
  78     if( nMask & 0x40 )  rStm >> aReadOnlyDoc;
  79     if( nMask & 0x80 )  rStm >> aHidden;
  80 }
  81
  82 void SvMetaAttribute::Save( SvPersistStream & rStm )
  83 {
  84     SvMetaReference::Save( rStm );
  85
  86     // create mask
  87     sal_uInt8 nMask = 0;
  88     if( aType.Is() )            nMask |= 0x1;
  89     if( aSlotId.IsSet() )       nMask |= 0x2;
  90     if( aExport.IsSet() )       nMask |= 0x4;
  91     if( aReadonly.IsSet() )     nMask |= 0x8;
  92     if( aAutomation.IsSet() )   nMask |= 0x10;
  93     if( aIsCollection.IsSet() ) nMask |= 0x20;
  94     if( aReadOnlyDoc.IsSet() )  nMask |= 0x40;
  95     if( aHidden.IsSet() )       nMask |= 0x80;
  96
  97     // write data
  98     rStm << nMask;
  99     if( nMask & 0x1 )   rStm << aType;
 100     if( nMask & 0x2 )   rStm << aSlotId;
 101     if( nMask & 0x4 )   rStm << aExport;
 102     if( nMask & 0x8 )   rStm << aReadonly;
 103     if( nMask & 0x10 )  rStm << aAutomation;
 104     if( nMask & 0x20 )  rStm << aIsCollection;
 105     if( nMask & 0x40 )  rStm << aReadOnlyDoc;
 106     if( nMask & 0x80 )  rStm << aHidden;
 107 }
 108
 109 SvMetaType * SvMetaAttribute::GetType() const
 110 {
 111     if( aType.Is() || !GetRef() ) return aType;
 112     return ((SvMetaAttribute *)GetRef())->GetType();
 113 }
 114
 115 const SvNumberIdentifier & SvMetaAttribute::GetSlotId() const
 116 {
 117     if( aSlotId.IsSet() || !GetRef() ) return aSlotId;
 118     return ((SvMetaAttribute *)GetRef())->GetSlotId();
 119 }
 120
 121 sal_Bool SvMetaAttribute::GetReadonly() const
 122 {
 123     if( aReadonly.IsSet() || !GetRef() ) return aReadonly;
 124     return ((SvMetaAttribute *)GetRef())->GetReadonly();
 125 }
 126
 127 sal_Bool SvMetaAttribute::GetExport() const
 128 {
 129     if( aExport.IsSet() || !GetRef() ) return aExport;
 130     return ((SvMetaAttribute *)GetRef())->GetExport();
 131 }
 132
 133 sal_Bool SvMetaAttribute::GetHidden() const
 134 {
 135     // when export is set, but hidden is not the default is used
 136     if ( aExport.IsSet() && !aHidden.IsSet() )
 137         return !aExport;
 138     else if( aHidden.IsSet() || !GetRef() )
 139         return aHidden;
 140     else
 141         return ((SvMetaAttribute *)GetRef())->GetHidden();
 142 }
 143
 144 sal_Bool SvMetaAttribute::GetAutomation() const
 145 {
 146     if( aAutomation.IsSet() || !GetRef() ) return aAutomation;
 147     return ((SvMetaAttribute *)GetRef())->GetAutomation();
 148 }
 149
 150 sal_Bool SvMetaAttribute::GetIsCollection() const
 151 {
 152     sal_Bool bRet;
 153     if( aIsCollection.IsSet() || !GetRef() )
 154     {
 155         if ( aIsCollection.IsSet() )
 156         {
 157             bRet = aIsCollection;
 158             return bRet;
 159         }
 160
 161         return aIsCollection;
 162     }
 163
 164     return ((SvMetaSlot *)GetRef())->GetIsCollection();
 165 }
 166
 167 sal_Bool SvMetaAttribute::GetReadOnlyDoc() const
 168 {
 169     if( aReadOnlyDoc.IsSet() || !GetRef() ) return aReadOnlyDoc;
 170     return ((SvMetaSlot *)GetRef())->GetReadOnlyDoc();
 171 }
 172
 173 sal_Bool SvMetaAttribute::IsMethod() const
 174 {
 175     SvMetaType * pType = GetType();
 176     DBG_ASSERT( pType, "no type for attribute" );
 177     return pType->GetType() == TYPE_METHOD;
 178 }
 179
 180 sal_Bool SvMetaAttribute::IsVariable() const
 181 {
 182     SvMetaType * pType = GetType();
 183     return pType->GetType() != TYPE_METHOD;
 184 }
 185
 186 rtl::OString SvMetaAttribute::GetMangleName( sal_Bool ) const
 187 {
 188     return GetName().getString();
 189 }
 190
 191 sal_Bool SvMetaAttribute::Test( SvIdlDataBase & rBase,
 192                             SvTokenStream & rInStm )
 193 {
 194     sal_Bool bOk = sal_True;
 195     if( GetType()->IsItem() && !GetSlotId().IsSet() )
 196     {
 197         rBase.SetError( "slot without id declared", rInStm.GetToken() );
 198         rBase.WriteError( rInStm );
 199         bOk = sal_False;
 200     }
 201     return bOk;
 202 }
 203
 204 sal_Bool SvMetaAttribute::ReadSvIdl( SvIdlDataBase & rBase,
 205                                      SvTokenStream & rInStm )
 206 {
 207     sal_uInt32  nTokPos     = rInStm.Tell();
 208     if( !GetType() )
 209         // no type in ctor passed on
 210         aType = rBase.ReadKnownType( rInStm );
 211     sal_Bool bOk = sal_False;
 212     if( GetType() )
 213     {
 214         ReadNameSvIdl( rBase, rInStm );
 215         aSlotId.ReadSvIdl( rBase, rInStm );
 216
 217         bOk = sal_True;
 218         SvToken * pTok  = rInStm.GetToken();
 219         if( bOk && pTok->IsChar() && pTok->GetChar() == '(' )
 220         {
 221             SvMetaTypeRef xT = new SvMetaType();
 222             xT->SetRef( GetType() );
 223             aType = xT;
 224             bOk = aType->ReadMethodArgs( rBase, rInStm );
 225         }
 226         if( bOk )
 227             bOk = SvMetaName::ReadSvIdl( rBase, rInStm );
 228     }
 229     else
 230         rBase.SetError( "unknown type", rInStm.GetToken() );
 231
 232     if( !bOk )
 233         rInStm.Seek( nTokPos );
 234     return bOk;
 235 }
 236
 237 void SvMetaAttribute::WriteSvIdl
 238 (
 239     SvIdlDataBase & rBase,
 240     SvStream & rOutStm,
 241     sal_uInt16 nTab
 242 )
 243 {
 244     SvMetaType * pType = GetType();
 245     pType->WriteTypePrefix( rBase, rOutStm, nTab, WRITE_IDL );
 246     rOutStm << ' ' << GetName().getString().getStr();
 247     if( aSlotId.IsSet() )
 248         rOutStm << ' ' << aSlotId.getString().getStr();
 249     if( pType->GetType() == TYPE_METHOD )
 250         pType->WriteMethodArgs( rBase, rOutStm, nTab, WRITE_IDL );
 251     sal_uLong nPos = rOutStm.Tell();
 252     rOutStm << endl;
 253     SvMetaName::WriteSvIdl( rBase, rOutStm, nTab );
 254     TestAndSeekSpaceOnly( rOutStm, nPos );
 255 }
 256
 257 void SvMetaAttribute::ReadAttributesSvIdl( SvIdlDataBase & rBase,
 258                                              SvTokenStream & rInStm )
 259 {
 260     SvMetaReference::ReadAttributesSvIdl( rBase, rInStm );
 261     aSlotId.ReadSvIdl( rBase, SvHash_SlotId(), rInStm );
 262     aExport.ReadSvIdl( SvHash_Export(), rInStm );
 263     aHidden.ReadSvIdl( SvHash_Hidden(), rInStm );
 264     aAutomation.ReadSvIdl( SvHash_Automation(), rInStm );
 265     aIsCollection.ReadSvIdl( SvHash_IsCollection(), rInStm );
 266     aReadOnlyDoc.ReadSvIdl( SvHash_ReadOnlyDoc(), rInStm );
 267     if( aReadonly.ReadSvIdl( SvHash_Readonly(), rInStm ) )
 268     {
 269         if( GetType()->GetType() == TYPE_METHOD )
 270         {
 271             // set error
 272             rBase.SetError( "Readonly in function attribute", rInStm.GetToken() );
 273             rBase.WriteError( rInStm );
 274         }
 275     }
 276 }
 277
 278 void SvMetaAttribute::WriteAttributesSvIdl
 279 (
 280     SvIdlDataBase & rBase,
 281     SvStream & rOutStm,
 282     sal_uInt16 nTab
 283 )
 284 {
 285     SvMetaReference::WriteAttributesSvIdl( rBase, rOutStm, nTab );
 286
 287     if( !aExport || !aAutomation || aReadonly )
 288     {
 289         WriteTab( rOutStm, nTab );
 290         rOutStm << "//class SvMetaAttribute" << endl;
 291         if( !aExport )
 292         {
 293             WriteTab( rOutStm, nTab );
 294             aExport.WriteSvIdl( SvHash_Export(), rOutStm );
 295             rOutStm << ';' << endl;
 296         }
 297         if ( aHidden != aExport )
 298         {
 299             WriteTab( rOutStm, nTab );
 300             aExport.WriteSvIdl( SvHash_Hidden(), rOutStm );
 301             rOutStm << ';' << endl;
 302         }
 303         if( aReadonly )
 304         {
 305             WriteTab( rOutStm, nTab );
 306             aReadonly.WriteSvIdl( SvHash_Readonly(), rOutStm );
 307             rOutStm << ';' << endl;
 308         }
 309         if( !aAutomation )
 310         {
 311             WriteTab( rOutStm, nTab );
 312             aAutomation.WriteSvIdl( SvHash_Automation(), rOutStm );
 313             rOutStm << ';' << endl;
 314         }
 315         if( aIsCollection )
 316         {
 317             WriteTab( rOutStm, nTab );
 318             aIsCollection.WriteSvIdl( SvHash_IsCollection(), rOutStm );
 319             rOutStm << ';' << endl;
 320         }
 321         if( !aReadOnlyDoc )
 322         {
 323             WriteTab( rOutStm, nTab );
 324             aReadOnlyDoc.WriteSvIdl( SvHash_ReadOnlyDoc(), rOutStm );
 325             rOutStm << ';' << endl;
 326         }
 327     }
 328 }
 329
 330 void SvMetaAttribute::WriteParam( SvIdlDataBase & rBase,
 331                                     SvStream & rOutStm,
 332                                     sal_uInt16 nTab,
 333                                     WriteType nT )
 334 {
 335     SvMetaType * pType = GetType();
 336     DBG_ASSERT( pType, "no type for attribute" );
 337     SvMetaType * pBaseType = pType->GetBaseType();
 338     DBG_ASSERT( pBaseType, "no base type for attribute" );
 339
 340     if( nT == WRITE_ODL || nT == WRITE_DOCU
 341        || nT == WRITE_C_HEADER || nT == WRITE_C_SOURCE )
 342     {
 343         if( pBaseType->GetType() == TYPE_STRUCT )
 344         {
 345             const SvMetaAttributeMemberList & rList = pBaseType->GetAttrList();
 346             sal_uLong nCount = rList.Count();
 347             for( sal_uLong i = 0; i < nCount; i++ )
 348             {
 349                 rList.GetObject( i )->WriteParam( rBase, rOutStm, nTab, nT );
 350                 if( i+1<nCount )
 351                 {
 352                         rOutStm << ',';
 353                 }
 354             }
 355         }
 356         else
 357         {
 358             if ( nT != WRITE_DOCU )
 359             {
 360                 WriteTab( rOutStm, nTab );
 361                 pBaseType->WriteTypePrefix( rBase, rOutStm, nTab, nT );
 362             }
 363
 364             if( !GetName().getString().isEmpty() )
 365             {
 366                 rOutStm << ' ';
 367                 rOutStm << GetName().getString().getStr();
 368             }
 369
 370             if ( nT == WRITE_DOCU )
 371             {
 372                 if( pBaseType->GetType() == TYPE_METHOD ||
 373                      pBaseType->GetType() == TYPE_STRUCT ||
 374                     pBaseType->GetType() == TYPE_ENUM )
 375                 {
 376                     OSL_FAIL( "Falscher Parametertyp!" );
 377                 }
 378                 else
 379                     rOutStm << pBaseType->GetBasicPostfix().getStr();
 380             }
 381         }
 382     }
 383 }
 384
 385 sal_uLong SvMetaAttribute::MakeSlotValue( SvIdlDataBase & rBase, sal_Bool bVar ) const
 386 {
 387     const SvNumberIdentifier & rId = GetSlotId();
 388     sal_uLong n = rId.GetValue();
 389     if( !rBase.aStructSlotId.getString().isEmpty() )
 390     {
 391         n = n << 20;
 392         n += rBase.aStructSlotId.GetValue();
 393     }
 394     if( PTR_CAST( SvMetaSlot, this ) )
 395         n |= 0x20000;
 396     if( !bVar )
 397         n += 0x10000;
 398     else if ( GetIsCollection() )
 399         n += 0x40000;
 400     return n;
 401 }
 402
 403 void SvMetaAttribute::WriteAttributes( SvIdlDataBase & rBase, SvStream & rOutStm,
 404                                       sal_uInt16 nTab,
 405                                       WriteType nT, WriteAttribute nA )
 406 {
 407     if( nT == WRITE_ODL  )
 408     {
 409         const SvNumberIdentifier & rId = GetSlotId();
 410         sal_Bool bReadonly = GetReadonly() || ( nA & WA_READONLY );
 411         if( (rId.IsSet() && !(nA & WA_STRUCT)) || bReadonly )
 412         {
 413             sal_Bool bVar = IsVariable();
 414             if( nA & WA_VARIABLE )
 415                 bVar = sal_True;
 416             else if( nA & WA_METHOD )
 417                 bVar = sal_False;
 418
 419             WriteTab( rOutStm, nTab );
 420             rOutStm << "//class SvMetaAttribute" << endl;
 421             if( rId.IsSet() && !(nA & WA_STRUCT) )
 422             {
 423                 WriteTab( rOutStm, nTab );
 424                 rOutStm << "id("
 425                     << rtl::OString::valueOf(static_cast<sal_Int32>(MakeSlotValue(rBase,bVar))).getStr()
 426                     << ")," << endl;
 427             }
 428             if( bVar && (bReadonly || IsMethod()) )
 429             {
 430                 WriteTab( rOutStm, nTab );
 431                 rOutStm << "readonly," << endl;
 432             }
 433         }
 434     }
 435 }
 436
 437 void SvMetaAttribute::WriteCSource( SvIdlDataBase & rBase, SvStream & rOutStm,
 438                                     sal_Bool bSet )
 439 {
 440     rOutStm << endl;
 441     SvMetaType * pType = GetType();
 442     SvMetaType * pBaseType = pType->GetBaseType();
 443
 444     // for Set the return is always void
 445     sal_Bool bVoid = bSet;
 446     if( pBaseType->GetType() == TYPE_METHOD )
 447         bVoid = pBaseType->GetReturnType()->GetBaseType()->GetName().getString() == "void";
 448
 449     // emit methods/functions body
 450     rOutStm << '{' << endl;
 451     WriteTab( rOutStm, 1 );
 452
 453     if( !bVoid )
 454     {
 455         if ( pBaseType->GetCName() == "double" )
 456         {
 457             rOutStm << "return *(double*)";
 458         }
 459         else
 460         {
 461             rOutStm << "return (";
 462             pType->WriteTypePrefix( rBase, rOutStm, 2, WRITE_C_SOURCE );
 463             rOutStm << ") ";
 464         }
 465     }
 466     rOutStm << "pODKCallFunction( "
 467         << rtl::OString::valueOf(static_cast<sal_Int32>(MakeSlotValue(rBase, IsVariable()))).getStr();
 468     rOutStm << ',' << endl;
 469     WriteTab( rOutStm, 3 );
 470     rOutStm << " h" << rBase.aIFaceName.getStr() << " , ";
 471
 472     rtl::OString aParserStr;
 473     if( pBaseType->GetType() == TYPE_METHOD || bSet )
 474         aParserStr = pBaseType->GetParserString();
 475     if( !aParserStr.isEmpty() )
 476     {
 477         rOutStm << '\"';
 478         rOutStm << aParserStr.getStr();
 479         rOutStm << "\", ";
 480     }
 481     else
 482         rOutStm << "NULL, ";
 483
 484     if( pBaseType->GetType() == TYPE_METHOD && !bVoid )
 485     {
 486         rOutStm << "'";
 487         rOutStm << pBaseType->GetReturnType()->GetBaseType()->GetParserChar();
 488         rOutStm << "'";
 489     }
 490     else if ( !bSet )
 491     {
 492         rOutStm << "'";
 493         rOutStm << pBaseType->GetParserChar();
 494         rOutStm << "'";
 495     }
 496     else
 497         rOutStm << '0';
 498
 499     if( !aParserStr.isEmpty() )
 500     {
 501         rOutStm << ", ";
 502         if( IsMethod() )
 503             pBaseType->WriteParamNames( rBase, rOutStm, rtl::OString() );
 504         else if( bSet )
 505             pBaseType->WriteParamNames( rBase, rOutStm, GetName().getString() );
 506     }
 507
 508     rOutStm << " );" << endl;
 509     rOutStm << '}' << endl;
 510 }
 511
 512 void SvMetaAttribute::WriteRecursiv_Impl( SvIdlDataBase & rBase,
 513                             SvStream & rOutStm, sal_uInt16 nTab,
 514                              WriteType nT, WriteAttribute nA )
 515 {
 516     const SvMetaAttributeMemberList & rList = GetType()->GetBaseType()->GetAttrList();
 517     sal_uLong nCount = rList.Count();
 518
 519     SvNumberIdentifier slotId = rBase.aStructSlotId;
 520     if ( !GetSlotId().getString().isEmpty() )
 521         rBase.aStructSlotId = GetSlotId();
 522
 523     // offial hack interface by MM: special controls get passed with the WriteAttribute
 524     if ( GetReadonly() )
 525         nA |= WA_READONLY;
 526
 527     for( sal_uLong i = 0; i < nCount; i++ )
 528     {
 529         SvMetaAttribute *pAttr = rList.GetObject( i );
 530         if ( nT == WRITE_DOCU )
 531             pAttr->SetDescription( GetDescription().getString() );
 532         pAttr->Write( rBase, rOutStm, nTab, nT, nA );
 533         if( nT == WRITE_ODL && i +1 < nCount )
 534             rOutStm << ';' << endl;
 535     }
 536
 537     rBase.aStructSlotId = slotId;
 538 }
 539
 540 void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
 541                             sal_uInt16 nTab,
 542                              WriteType nT, WriteAttribute nA )
 543 {
 544     // no attributes for automation
 545     if( nT == WRITE_DOCU )
 546     {
 547         if ( GetHidden() )
 548             return;
 549     }
 550     else if ( !GetAutomation() || !GetExport() )
 551         return;
 552
 553     sal_Bool bVariable;
 554     if( nA & WA_VARIABLE )
 555         bVariable = sal_True;
 556     else if( nA & WA_METHOD )
 557         bVariable = sal_False;
 558     else
 559         bVariable = IsVariable();
 560
 561     SvMetaType * pType = GetType();
 562     DBG_ASSERT( pType, "no type for attribute" );
 563     SvMetaType * pBaseType = pType->GetBaseType();
 564     DBG_ASSERT( pBaseType, "no base type for attribute" );
 565     int nBType = pBaseType->GetType();
 566
 567     if( nT == WRITE_ODL )
 568     {
 569         if( (bVariable && IsVariable()) || (!bVariable && IsMethod()) )
 570         {
 571             if( nBType == TYPE_STRUCT )
 572                 WriteRecursiv_Impl( rBase, rOutStm, nTab, nT, nA );
 573             else
 574             {
 575                 SvMetaReference::Write( rBase, rOutStm, nTab, nT, nA );
 576                 WriteTab( rOutStm, nTab );
 577                 pBaseType->WriteTypePrefix( rBase, rOutStm, nTab, nT );
 578
 579                 if( !GetName().getString().isEmpty() )
 580                 {
 581                     rOutStm << ' ';
 582                     rOutStm << GetName().getString().getStr();
 583                 }
 584                 if( pType->GetType() == TYPE_METHOD )
 585                     pType->WriteMethodArgs( rBase, rOutStm, nTab, nT );
 586             }
 587         }
 588     }
 589     else if( nT == WRITE_C_HEADER || nT == WRITE_C_SOURCE )
 590     {
 591         if( !bVariable && IsMethod() )
 592         {
 593             rtl::OString name = rBase.aIFaceName + GetName().getString();
 594             const char * pName = name.getStr();
 595             WriteTab( rOutStm, nTab );
 596             pBaseType->WriteTypePrefix( rBase, rOutStm, nTab, nT );
 597             rOutStm << ' ' << pName;
 598             pType->WriteMethodArgs( rBase, rOutStm, nTab, nT );
 599             if( nT == WRITE_C_HEADER )
 600                 rOutStm << ';' << endl << endl;
 601             else
 602                 WriteCSource( rBase, rOutStm, sal_False );
 603         }
 604         else if ( bVariable && IsVariable() )
 605         {
 606               if( nBType == TYPE_STRUCT )
 607             {
 608                 // for assistance emit the name of the property as acomment
 609                 rOutStm << "/* " << GetName().getString().getStr() << " */" << endl;
 610
 611                 WriteRecursiv_Impl( rBase, rOutStm, nTab, nT, nA );
 612             }
 613             else
 614             {
 615                 rtl::OString name = GetName().getString();
 616
 617                 sal_Bool bReadonly = GetReadonly() || ( nA & WA_READONLY );
 618                 if ( !bReadonly && !IsMethod() )
 619                 {
 620                     // allocation
 621                     WriteTab( rOutStm, nTab );
 622                     rOutStm << "void ";
 623                     rOutStm << rBase.aIFaceName.getStr()
 624                             << "Set" << name.getStr() << "( " << C_PREF
 625                             << "Object h" << rBase.aIFaceName.getStr() << ", " << endl;
 626                     WriteTab( rOutStm, nTab+1 );
 627                     pBaseType->WriteTypePrefix( rBase, rOutStm, nTab, nT );
 628                     rOutStm << ' ' << name.getStr() << " )";
 629                     if( nT == WRITE_C_HEADER )
 630                         rOutStm << ';' << endl << endl;
 631                     else
 632                         WriteCSource( rBase, rOutStm, sal_True );
 633                 }
 634
 635                 // access
 636                 WriteTab( rOutStm, nTab );
 637                 pBaseType->WriteTypePrefix( rBase, rOutStm, nTab, nT );
 638                 rOutStm << ' ';
 639                 rOutStm << rBase.aIFaceName.getStr()
 640                         << "Get" << name.getStr() << "( " << C_PREF
 641                         << "Object h" << rBase.aIFaceName.getStr() << " )";
 642                 if( nT == WRITE_C_HEADER )
 643                     rOutStm << ';' << endl << endl;
 644                 else
 645                     WriteCSource( rBase, rOutStm, sal_False );
 646             }
 647         }
 648     }
 649     else if ( nT == WRITE_DOCU )
 650     {
 651         if( !bVariable && IsMethod() )
 652         {
 653             rOutStm << "<METHOD>" << endl
 654                     << GetSlotId().getString().getStr() << endl
 655                     << GetName().getString().getStr() << endl
 656                     << endl;    // readonly
 657
 658             // return type
 659             SvMetaType* pType2 = GetType();
 660             SvMetaType* pBaseType2 = pType2->GetBaseType();
 661             rOutStm << pBaseType2->GetReturnType()->GetBaseType()->GetBasicName().getStr() << endl;
 662
 663             DBG_ASSERT( !pBaseType2->GetReturnType()->GetBaseType()->GetBasicName().isEmpty(),
 664                 "Leerer BasicName" );
 665
 666             // syntax
 667             rOutStm << GetName().getString().getStr();
 668             pType2->WriteMethodArgs( rBase, rOutStm, nTab, nT );
 669
 670             // C return type
 671             pBaseType2->WriteTypePrefix( rBase, rOutStm, 0, WRITE_C_HEADER );
 672             rOutStm << endl;
 673
 674             // for methods also C syntax
 675             rOutStm << "<C-SYNTAX>" << endl;
 676             Write( rBase, rOutStm, 0, WRITE_C_HEADER, nA );
 677             rOutStm << "</C-SYNTAX>" << endl;
 678
 679             // description
 680             WriteDescription( rOutStm );
 681             rOutStm << "</METHOD>" << endl << endl;
 682         }
 683         else if( bVariable && IsVariable() )
 684         {
 685             if( nBType == TYPE_STRUCT )
 686             {
 687                 WriteRecursiv_Impl( rBase, rOutStm, nTab, nT, nA );
 688             }
 689             else
 690             {
 691                 rOutStm << "<PROPERTY>" << endl
 692                         << GetSlotId().getString().getStr() << endl
 693                         << GetName().getString().getStr() << endl;
 694                 if ( GetReadonly() )
 695                     rOutStm << "(nur lesen)" << endl;
 696                 else
 697                     rOutStm << endl;
 698
 699                 // for properties type instead of the return value
 700                 rOutStm << pBaseType->GetBasicName().getStr() << endl;
 701
 702                 DBG_ASSERT( !pBaseType->GetBasicName().isEmpty(),
 703                     "Leerer BasicName" );
 704
 705                 // for properties no syntax
 706                 rOutStm << endl;
 707
 708                 // C return type
 709                 pBaseType->WriteTypePrefix( rBase, rOutStm, 0, WRITE_C_HEADER );
 710                 rOutStm << endl;
 711
 712                 // description
 713                 WriteDescription( rOutStm );
 714                 rOutStm << "</PROPERTY>" << endl << endl;
 715             }
 716         }
 717     }
 718 }
 719
 720 sal_uLong SvMetaAttribute::MakeSfx( rtl::OStringBuffer& rAttrArray )
 721 {
 722     SvMetaType * pType = GetType();
 723     DBG_ASSERT( pType, "no type for attribute" );
 724     SvMetaType * pBaseType = pType->GetBaseType();
 725     DBG_ASSERT( pBaseType, "no base type for attribute" );
 726     if( pBaseType->GetType() == TYPE_STRUCT )
 727         return pBaseType->MakeSfx( rAttrArray );
 728     else
 729     {
 730         rAttrArray.append('{');
 731         rAttrArray.append(GetSlotId().getString());
 732         rAttrArray.append(",\"");
 733         rAttrArray.append(GetName().getString());
 734         rAttrArray.append("\"}");
 735         return 1;
 736     }
 737 }
 738
 739 void SvMetaAttribute::Insert (SvSlotElementList&, const rtl::OString&, SvIdlDataBase&)
 740 {
 741 }
 742
 743 void SvMetaAttribute::WriteHelpId( SvIdlDataBase &, SvStream &, HelpIdTable& )
 744 {
 745 }
 746
 747 SV_IMPL_META_FACTORY1( SvMetaType, SvMetaExtern );
 748 #define CTOR                            \
 749     : aCall0( CALL_VALUE, sal_False )       \
 750     , aCall1( CALL_VALUE, sal_False )       \
 751     , aSbxDataType( 0, sal_False )          \
 752     , pAttrList( NULL )                 \
 753     , nType( TYPE_BASE )                \
 754     , bIsItem( sal_False )                  \
 755     , bIsShell( sal_False )                 \
 756     , cParserChar( 'h' )
 757
 758 SvMetaType::SvMetaType()
 759     CTOR
 760 {
 761 }
 762
 763 SvMetaType::SvMetaType( const rtl::OString& rName, char cPC,
 764                         const rtl::OString& rCName )
 765     CTOR
 766 {
 767     SetName( rName );
 768     cParserChar = cPC;
 769     aCName.setString(rCName);
 770 }
 771
 772 SvMetaType::SvMetaType( const rtl::OString& rName,
 773                         const rtl::OString& rSbxName,
 774                         const rtl::OString& rOdlName,
 775                         char cPc,
 776                         const rtl::OString& rCName,
 777                         const rtl::OString& rBasicName,
 778                         const rtl::OString& rBasicPostfix )
 779     CTOR
 780 {
 781     SetName( rName );
 782     aSbxName.setString(rSbxName);
 783     aOdlName.setString(rOdlName);
 784     cParserChar = cPc;
 785     aCName.setString(rCName);
 786     aBasicName.setString(rBasicName);
 787     aBasicPostfix.setString(rBasicPostfix);
 788 }
 789
 790 void SvMetaType::Load( SvPersistStream & rStm )
 791 {
 792     SvMetaExtern::Load( rStm );
 793
 794     sal_uInt16 nMask;
 795     rStm >> nMask;
 796     if( nMask & 0x0001 ) rStm >> aIn;
 797     if( nMask & 0x0002 ) rStm >> aOut;
 798     if( nMask & 0x0004 ) rStm >> aCall0;
 799     if( nMask & 0x0008 ) rStm >> aCall1;
 800     if( nMask & 0x0010 ) rStm >> aSbxDataType;
 801     if( nMask & 0x0020 ) rStm >> aSvName;
 802     if( nMask & 0x0040 ) rStm >> aSbxName;
 803     if( nMask & 0x0080 ) rStm >> aOdlName;
 804     if( nMask & 0x0100 ) rStm >> GetAttrList();
 805     if( nMask & 0x0200 ) bIsItem = sal_True;
 806     if( nMask & 0x0400 ) bIsShell = sal_True;
 807     if( nMask & 0x0800 )
 808     {
 809         sal_uInt16 nT;
 810         rStm >> nT;
 811         nType = nT;
 812     }
 813     if( nMask & 0x1000 ) rStm >> cParserChar;
 814     if( nMask & 0x2000 ) rStm >> aCName;
 815     if( nMask & 0x4000 ) rStm >> aBasicName;
 816     if( nMask & 0x8000 ) rStm >> aBasicPostfix;
 817 }
 818
 819 void SvMetaType::Save( SvPersistStream & rStm )
 820 {
 821     SvMetaExtern::Save( rStm );
 822
 823     // create mask
 824     sal_uInt16 nMask = 0;
 825     if( aIn.IsSet() )               nMask |= 0x0001;
 826     if( aOut.IsSet() )              nMask |= 0x0002;
 827     if( aCall0.IsSet() )            nMask |= 0x0004;
 828     if( aCall1.IsSet() )            nMask |= 0x0008;
 829     if( aSbxDataType.IsSet() )      nMask |= 0x0010;
 830     if( aSvName.IsSet() )           nMask |= 0x0020;
 831     if( aSbxName.IsSet() )          nMask |= 0x0040;
 832     if( aOdlName.IsSet() )          nMask |= 0x0080;
 833     if( GetAttrCount() )            nMask |= 0x0100;
 834     if( bIsItem )                   nMask |= 0x0200;
 835     if( bIsShell )                  nMask |= 0x0400;
 836     if( nType != TYPE_BASE )        nMask |= 0x0800;
 837     if( cParserChar != 'h' )        nMask |= 0x1000;
 838     if( aCName.IsSet() )            nMask |= 0x2000;
 839     if( aBasicName.IsSet() )        nMask |= 0x4000;
 840     if( aBasicPostfix.IsSet() )     nMask |= 0x8000;
 841
 842     // write data
 843     rStm << nMask;
 844     if( nMask & 0x0001 ) rStm << aIn;
 845     if( nMask & 0x0002 ) rStm << aOut;
 846     if( nMask & 0x0004 ) rStm << aCall0;
 847     if( nMask & 0x0008 ) rStm << aCall1;
 848     if( nMask & 0x0010 ) rStm << aSbxDataType;
 849     if( nMask & 0x0020 ) rStm << aSvName;
 850     if( nMask & 0x0040 ) rStm << aSbxName;
 851     if( nMask & 0x0080 ) rStm << aOdlName;
 852     if( nMask & 0x0100 ) rStm << *pAttrList;
 853     if( nMask & 0x0800 ) rStm << (sal_uInt16)nType;
 854     if( nMask & 0x1000 ) rStm << cParserChar;
 855     if( nMask & 0x2000 ) rStm << aCName;
 856     if( nMask & 0x4000 ) rStm << aBasicName;
 857     if( nMask & 0x8000 ) rStm << aBasicPostfix;
 858 }
 859
 860 SvMetaAttributeMemberList & SvMetaType::GetAttrList() const
 861 {
 862     if( !pAttrList )
 863         ((SvMetaType *)this)->pAttrList = new SvMetaAttributeMemberList();
 864     return *pAttrList;
 865 }
 866
 867 void SvMetaType::SetType( int nT )
 868 {
 869     nType = nT;
 870     if( nType == TYPE_ENUM )
 871     {
 872         aOdlName.setString("short");
 873     }
 874     else if( nType == TYPE_CLASS )
 875     {
 876         rtl::OStringBuffer aTmp(C_PREF);
 877         aTmp.append(RTL_CONSTASCII_STRINGPARAM("Object *"));
 878         aCName.setString(aTmp.makeStringAndClear());
 879     }
 880 }
 881
 882 SvMetaType * SvMetaType::GetBaseType() const
 883 {
 884     if( GetRef() && GetType() == TYPE_BASE )
 885         return ((SvMetaType *)GetRef())->GetBaseType();
 886     return (SvMetaType *)this;
 887 }
 888
 889 SvMetaType * SvMetaType::GetReturnType() const
 890 {
 891     DBG_ASSERT( GetType() == TYPE_METHOD, "no method" );
 892     DBG_ASSERT( GetRef(), "no return type" );
 893     return (SvMetaType *)GetRef();
 894 }
 895
 896 const rtl::OString& SvMetaType::GetBasicName() const
 897 {
 898     if( aBasicName.IsSet() || !GetRef() )
 899         return aBasicName.getString();
 900     else
 901         return ((SvMetaType*)GetRef())->GetBasicName();
 902 }
 903
 904 rtl::OString SvMetaType::GetBasicPostfix() const
 905 {
 906     // MBN and Co always want "As xxx"
 907     return rtl::OStringBuffer(RTL_CONSTASCII_STRINGPARAM(" As ")).
 908         append(GetBasicName()).
 909         makeStringAndClear();
 910 }
 911
 912 sal_Bool SvMetaType::GetIn() const
 913 {
 914     if( aIn.IsSet() || !GetRef() )
 915         return aIn;
 916     else
 917         return ((SvMetaType *)GetRef())->GetIn();
 918 }
 919
 920 sal_Bool SvMetaType::GetOut() const
 921 {
 922     if( aOut.IsSet() || !GetRef() )
 923         return aOut;
 924     else
 925         return ((SvMetaType *)GetRef())->GetOut();
 926 }
 927
 928 void SvMetaType::SetCall0( int e )
 929 {
 930     aCall0 = (int)e;
 931     if( aCall0 == CALL_VALUE && aCall1 == CALL_VALUE )
 932     {
 933           if( GetType() == TYPE_POINTER )
 934             SetType( TYPE_BASE );
 935     }
 936     else
 937     {
 938         DBG_ASSERT( nType == TYPE_POINTER || nType == TYPE_BASE,
 939                     "set no base type to pointer" );
 940         SetType( TYPE_POINTER );
 941     }
 942 }
 943
 944 int SvMetaType::GetCall0() const
 945 {
 946     if( aCall0.IsSet() || !GetRef() )
 947         return aCall0;
 948     else
 949         return ((SvMetaType *)GetRef())->GetCall0();
 950 }
 951
 952 void SvMetaType::SetCall1( int e )
 953 {
 954     aCall1 = (int)e;
 955     if( aCall0 == CALL_VALUE && aCall1 == CALL_VALUE )
 956     {
 957           if( GetType() == TYPE_POINTER )
 958             SetType( TYPE_BASE );
 959     }
 960     else
 961     {
 962         DBG_ASSERT( nType == TYPE_POINTER || nType == TYPE_BASE,
 963                     "set no base type to pointer" );
 964         SetType( TYPE_POINTER );
 965     }
 966 }
 967
 968 int SvMetaType::GetCall1() const
 969 {
 970     if( aCall1.IsSet() || !GetRef() )
 971         return aCall1;
 972     else
 973         return ((SvMetaType *)GetRef())->GetCall1();
 974 }
 975
 976 const rtl::OString& SvMetaType::GetSvName() const
 977 {
 978     if( aSvName.IsSet() || !GetRef() )
 979         return aSvName.getString();
 980     else
 981         return ((SvMetaType *)GetRef())->GetSvName();
 982 }
 983
 984 const rtl::OString& SvMetaType::GetSbxName() const
 985 {
 986     if( aSbxName.IsSet() || !GetRef() )
 987         return aSbxName.getString();
 988     else
 989         return ((SvMetaType *)GetRef())->GetSbxName();
 990 }
 991
 992 const rtl::OString& SvMetaType::GetOdlName() const
 993 {
 994     if( aOdlName.IsSet() || !GetRef() )
 995         return aOdlName.getString();
 996     else
 997         return ((SvMetaType *)GetRef())->GetOdlName();
 998 }
 999
1000 const rtl::OString& SvMetaType::GetCName() const
1001 {
1002     if( aCName.IsSet() || !GetRef() )
1003         return aCName.getString();
1004     else
1005         return ((SvMetaType *)GetRef())->GetCName();
1006 }
1007
1008 sal_Bool SvMetaType::SetName( const rtl::OString& rName, SvIdlDataBase * pBase )
1009 {
1010     aSvName.setString(rName);
1011     aSbxName.setString(rName);
1012     aCName.setString(rName);
1013     if( GetType() != TYPE_ENUM )
1014         aOdlName.setString(rName);
1015     return SvMetaReference::SetName( rName, pBase );
1016 }
1017
1018 rtl::OString SvMetaType::GetCString() const
1019 {
1020     rtl::OStringBuffer out( GetSvName() );
1021     if( aCall0 == (int)CALL_POINTER )
1022         out.append(" *");
1023     else if( aCall0 == (int)CALL_REFERENCE )
1024         out.append(" &");
1025     if( aCall1 == (int)CALL_POINTER )
1026         out.append('*');
1027     else if( aCall1 == (int)CALL_REFERENCE )
1028         out.append('&');
1029     return out.makeStringAndClear();
1030 }
1031
1032 sal_Bool SvMetaType::ReadHeaderSvIdl( SvIdlDataBase & rBase,
1033                                      SvTokenStream & rInStm )
1034 {
1035     sal_Bool bOk = sal_False;
1036     sal_uInt32  nTokPos = rInStm.Tell();
1037     SvToken * pTok = rInStm.GetToken_Next();
1038
1039     if( pTok->Is( SvHash_interface() )
1040       || pTok->Is( SvHash_shell() ) )
1041     {
1042         if( pTok->Is( SvHash_shell() ) )
1043             bIsShell = sal_True;
1044         SetType( TYPE_CLASS );
1045         bOk = ReadNamesSvIdl( rBase, rInStm );
1046
1047     }
1048     else if( pTok->Is( SvHash_struct() ) )
1049     {
1050         SetType( TYPE_STRUCT );
1051         bOk = ReadNamesSvIdl( rBase, rInStm );
1052     }
1053     else if( pTok->Is( SvHash_union() ) )
1054     {
1055         SetType( TYPE_UNION );
1056         if( ReadNameSvIdl( rBase, rInStm ) )
1057             return sal_True;
1058     }
1059     else if( pTok->Is( SvHash_enum() ) )
1060     {
1061         SetType( TYPE_ENUM );
1062         bOk = ReadNameSvIdl( rBase, rInStm );
1063     }
1064     else if( pTok->Is( SvHash_typedef() )
1065       || pTok->Is( SvHash_item() ) )
1066     {
1067           if( pTok->Is( SvHash_item() ) )
1068             bIsItem = sal_True;
1069
1070         SvMetaType * pType = rBase.ReadKnownType( rInStm );
1071         if( pType )
1072         {
1073             SetRef( pType );
1074             if( ReadNameSvIdl( rBase, rInStm ) )
1075             {
1076                 if( rInStm.Read( '(' ) )
1077                 {
1078                     DoReadContextSvIdl( rBase, rInStm );
1079                     if( rInStm.Read( ')' ) )
1080                     {
1081                         SetType( TYPE_METHOD );
1082                         bOk = sal_True;
1083                     }
1084                 }
1085                 else
1086                 {
1087                     bOk = sal_True;
1088                 }
1089             }
1090         }
1091         else
1092         {
1093             rtl::OString aStr("wrong typedef: ");
1094             rBase.SetError( aStr, rInStm.GetToken() );
1095             rBase.WriteError( rInStm );
1096         }
1097     }
1098     if( bOk )
1099         SetModule( rBase );
1100     else
1101         rInStm.Seek( nTokPos );
1102     return bOk;
1103 }
1104
1105 sal_Bool SvMetaType::ReadSvIdl( SvIdlDataBase & rBase,
1106                              SvTokenStream & rInStm )
1107 {
1108     if( ReadHeaderSvIdl( rBase, rInStm ) )
1109     {
1110         rBase.Write(rtl::OString('.'));
1111         return SvMetaExtern::ReadSvIdl( rBase, rInStm );
1112     }
1113     return sal_False;
1114 }
1115
1116 void SvMetaType::WriteSvIdl
1117 (
1118     SvIdlDataBase & rBase,
1119     SvStream & rOutStm,
1120     sal_uInt16 nTab
1121 )
1122 {
1123     WriteHeaderSvIdl( rBase, rOutStm, nTab );
1124     if( GetType() == TYPE_METHOD )
1125         WriteMethodArgs( rBase, rOutStm, nTab, WRITE_IDL );
1126
1127     sal_uLong nOldPos = rOutStm.Tell();
1128     rOutStm << endl;
1129     SvMetaExtern::WriteSvIdl( rBase, rOutStm, nTab );
1130     if( TestAndSeekSpaceOnly( rOutStm, nOldPos ) )
1131         // nothin written
1132         rOutStm.Seek( nOldPos );
1133     rOutStm << ';' << endl;
1134 }
1135
1136 void SvMetaType::WriteContext( SvIdlDataBase & rBase, SvStream & rOutStm,
1137                                  sal_uInt16 nTab,
1138                              WriteType nT, WriteAttribute nA )
1139 {
1140     if( GetAttrCount() )
1141     {
1142         SvMetaAttribute * pAttr = pAttrList->First();
1143         while( pAttr )
1144         {
1145             pAttr->Write( rBase, rOutStm, nTab, nT, nA );
1146             if( GetType() == TYPE_METHOD )
1147                 rOutStm << ',' << endl;
1148             else
1149                 rOutStm << ';' << endl;
1150             pAttr = pAttrList->Next();
1151         }
1152     }
1153 }
1154
1155 void SvMetaType::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
1156                           sal_uInt16 nTab,
1157                          WriteType nT, WriteAttribute nA )
1158 {
1159     if( nT == WRITE_C_HEADER && nType != TYPE_ENUM )
1160         // write only enum
1161         return;
1162
1163     rtl::OString name = GetName().getString();
1164     if( nT == WRITE_ODL || nT == WRITE_C_HEADER || nT == WRITE_CXX_HEADER )
1165     {
1166         switch( nType )
1167         {
1168         case TYPE_CLASS:
1169             {
1170             }
1171             break;
1172         case TYPE_STRUCT:
1173         case TYPE_UNION:
1174         case TYPE_ENUM:
1175         {
1176             WriteStars( rOutStm );
1177             if( nType == TYPE_STRUCT || nType == TYPE_UNION )
1178                 nA = WA_STRUCT;
1179
1180             if( nT == WRITE_ODL || nT == WRITE_C_HEADER)
1181             {
1182                 if ( nT == WRITE_C_HEADER )
1183                 {
1184                     rtl::OString aStr = name.toAsciiUpperCase();
1185                     rOutStm << "#ifndef " << C_PREF << aStr.getStr() << "_DEF " << endl;
1186                     rOutStm << "#define " << C_PREF << aStr.getStr() << "_DEF " << endl;
1187                 }
1188
1189                 WriteTab( rOutStm, nTab );
1190                 rOutStm << "typedef" << endl;
1191                 if ( nT == WRITE_ODL )
1192                     SvMetaName::Write( rBase, rOutStm, nTab, nT, nA );
1193             }
1194             WriteTab( rOutStm, nTab );
1195             if( nType == TYPE_STRUCT )
1196                 rOutStm << "struct";
1197             else if( nType == TYPE_UNION )
1198                 rOutStm << "union";
1199             else
1200                 rOutStm << "enum";
1201             if( nT != WRITE_ODL && nT != WRITE_C_HEADER)
1202                 rOutStm << ' ' << name.getStr();
1203
1204             rOutStm << endl;
1205             WriteTab( rOutStm, nTab );
1206             rOutStm << '{' << endl;
1207             WriteContext( rBase, rOutStm, nTab +1, nT, nA );
1208             WriteTab( rOutStm, nTab );
1209             rOutStm << '}';
1210             if( nT == WRITE_ODL || nT == WRITE_C_HEADER )
1211             {
1212                 rOutStm << ' ' << C_PREF << name.getStr();
1213             }
1214             rOutStm << ';' << endl;
1215
1216             if ( nT == WRITE_C_HEADER )
1217                 rOutStm << "#endif";
1218             rOutStm << endl;
1219         }
1220         break;
1221         case TYPE_POINTER:
1222         case TYPE_BASE:
1223         {
1224         }
1225         break;
1226         case TYPE_METHOD:
1227         {
1228         }
1229         break;
1230         }
1231     }
1232 }
1233
1234 sal_Bool SvMetaType::ReadNamesSvIdl( SvIdlDataBase & rBase,
1235                                      SvTokenStream & rInStm )
1236 {
1237     sal_Bool bOk = ReadNameSvIdl( rBase, rInStm );
1238
1239     return bOk;
1240 }
1241
1242 void SvMetaType::WriteHeaderSvIdl( SvIdlDataBase & rBase,
1243                                    SvStream & rOutStm,
1244                                    sal_uInt16 nTab )
1245 {
1246     switch( nType )
1247     {
1248         case TYPE_CLASS:
1249         {
1250             if( IsShell() )
1251                 rOutStm << SvHash_shell()->GetName().getStr();
1252             else
1253                 rOutStm << SvHash_interface()->GetName().getStr();
1254             rOutStm << ' ' << GetName().getString().getStr();
1255         }
1256         break;
1257         case TYPE_STRUCT:
1258         {
1259             rOutStm << SvHash_struct()->GetName().getStr()
1260                     << ' ' << GetName().getString().getStr();
1261         }
1262         break;
1263         case TYPE_UNION:
1264         {
1265             rOutStm << SvHash_union()->GetName().getStr()
1266                     << ' ' << GetName().getString().getStr();
1267         }
1268         break;
1269         case TYPE_ENUM:
1270         {
1271             rOutStm << SvHash_enum()->GetName().getStr()
1272                     << ' ' << GetName().getString().getStr();
1273         }
1274         break;
1275         case TYPE_POINTER:
1276         case TYPE_BASE:
1277         {
1278             if( IsItem() )
1279                 rOutStm << SvHash_item()->GetName().getStr() << ' ';
1280             else
1281                 rOutStm << SvHash_typedef()->GetName().getStr() << ' ';
1282             if( GetRef() )
1283             {
1284                 ((SvMetaType *)GetRef())->WriteTheType( rBase, rOutStm, nTab, WRITE_IDL );
1285                 rOutStm << ' ';
1286             }
1287             rOutStm << GetName().getString().getStr();
1288         }
1289         break;
1290         case TYPE_METHOD:
1291         {
1292             rOutStm << SvHash_typedef()->GetName().getStr() << ' ';
1293             ((SvMetaType *)GetRef())->WriteTheType( rBase, rOutStm, nTab, WRITE_IDL );
1294             rOutStm << ' ' << GetName().getString().getStr() << "( ";
1295             WriteContextSvIdl( rBase, rOutStm, nTab );
1296             rOutStm << " )";
1297         }
1298         break;
1299     }
1300 }
1301
1302 void SvMetaType::ReadAttributesSvIdl( SvIdlDataBase & rBase,
1303                                       SvTokenStream & rInStm )
1304 {
1305     SvMetaExtern::ReadAttributesSvIdl( rBase, rInStm );
1306     aSvName.ReadSvIdl( SvHash_SvName(), rInStm );
1307     aSbxName.ReadSvIdl( SvHash_SbxName(), rInStm );
1308     aOdlName.ReadSvIdl( SvHash_OdlName(), rInStm );
1309 }
1310
1311 void SvMetaType::WriteAttributesSvIdl( SvIdlDataBase & rBase,
1312                                        SvStream & rOutStm,
1313                                        sal_uInt16 nTab )
1314 {
1315     SvMetaExtern::WriteAttributesSvIdl( rBase, rOutStm, nTab );
1316     rtl::OString name = GetName().getString();
1317     if( aSvName.getString() != name || aSbxName.getString() != name || aOdlName.getString() != name )
1318     {
1319         WriteTab( rOutStm, nTab );
1320         rOutStm << "class SvMetaType" << endl;
1321         if( aSvName.getString() != name )
1322         {
1323             WriteTab( rOutStm, nTab );
1324             aSvName.WriteSvIdl( SvHash_SvName(), rOutStm, nTab );
1325             rOutStm << endl;
1326         }
1327         if( aSbxName.getString() != name )
1328         {
1329             WriteTab( rOutStm, nTab );
1330             aSbxName.WriteSvIdl( SvHash_SbxName(), rOutStm, nTab );
1331             rOutStm << endl;
1332         }
1333         if( aOdlName.getString() != name )
1334         {
1335             WriteTab( rOutStm, nTab );
1336             aOdlName.WriteSvIdl( SvHash_OdlName(), rOutStm, nTab );
1337             rOutStm << endl;
1338         }
1339     }
1340 }
1341
1342 void SvMetaType::ReadContextSvIdl( SvIdlDataBase & rBase,
1343                                       SvTokenStream & rInStm )
1344 {
1345     SvMetaAttributeRef xAttr = new SvMetaAttribute();
1346     if( xAttr->ReadSvIdl( rBase, rInStm ) )
1347     {
1348         if( xAttr->Test( rBase, rInStm ) )
1349             GetAttrList().Append( xAttr );
1350     }
1351 }
1352
1353 void SvMetaType::WriteContextSvIdl
1354 (
1355     SvIdlDataBase & rBase,
1356     SvStream & rOutStm,
1357     sal_uInt16 nTab
1358 )
1359 {
1360     if( GetAttrCount() )
1361     {
1362         SvMetaAttribute * pAttr = pAttrList->First();
1363         while( pAttr )
1364         {
1365             WriteTab( rOutStm, nTab );
1366             pAttr->WriteSvIdl( rBase, rOutStm, nTab );
1367             if( GetType() == TYPE_METHOD )
1368                 rOutStm << ',' << endl;
1369             else
1370                 rOutStm << ';' << endl;
1371             pAttr = pAttrList->Next();
1372         }
1373     }
1374 }
1375
1376 void SvMetaType::WriteAttributes( SvIdlDataBase & rBase, SvStream & rOutStm,
1377                                    sal_uInt16 nTab,
1378                                  WriteType nT, WriteAttribute nA )
1379 {
1380     SvMetaExtern::WriteAttributes( rBase, rOutStm, nTab, nT, nA );
1381 }
1382
1383 sal_uLong SvMetaType::MakeSfx( rtl::OStringBuffer& rAttrArray )
1384 {
1385     sal_uLong nC = 0;
1386
1387     if( GetBaseType()->GetType() == TYPE_STRUCT )
1388     {
1389         sal_uLong nAttrCount = GetAttrCount();
1390         // write the single attributes
1391         for( sal_uLong n = 0; n < nAttrCount; n++ )
1392         {
1393             nC += pAttrList->GetObject( n )->MakeSfx( rAttrArray );
1394             if( n +1 < nAttrCount )
1395                 rAttrArray.append(", ");
1396         }
1397     }
1398     return nC;
1399 }
1400
1401 void SvMetaType::WriteSfxItem(
1402     const rtl::OString& rItemName, SvIdlDataBase &, SvStream & rOutStm )
1403 {
1404     WriteStars( rOutStm );
1405     rtl::OStringBuffer aVarName(RTL_CONSTASCII_STRINGPARAM(" a"));
1406     aVarName.append(rItemName).append(RTL_CONSTASCII_STRINGPARAM("_Impl"));
1407
1408     rtl::OStringBuffer aTypeName(RTL_CONSTASCII_STRINGPARAM("SfxType"));
1409     rtl::OStringBuffer aAttrArray;
1410     sal_uLong   nAttrCount = MakeSfx( aAttrArray );
1411     rtl::OString aAttrCount(
1412         rtl::OString::valueOf(static_cast<sal_Int32>(nAttrCount)));
1413     aTypeName.append(aAttrCount);
1414
1415     rOutStm << "extern " << aTypeName.getStr()
1416             << aVarName.getStr() << ';' << endl;
1417
1418     // write the implementation part
1419     rOutStm << "#ifdef SFX_TYPEMAP" << endl
1420             << aTypeName.getStr() << aVarName.getStr()
1421             << " = " << endl;
1422     rOutStm << '{' << endl
1423             << "\tTYPE(" << rItemName.getStr() << "), "
1424             << aAttrCount.getStr();
1425     if( nAttrCount )
1426     {
1427         rOutStm << ", { ";
1428         // write the single attributes
1429         rOutStm << aAttrArray.getStr();
1430         rOutStm << " }";
1431     }
1432     rOutStm << endl << "};" << endl
1433             << "#endif" << endl << endl;
1434 }
1435
1436 void SvMetaType::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm )
1437 {
1438     if( IsItem() )
1439     {
1440         if( GetBaseType()->GetType() == TYPE_STRUCT )
1441             GetBaseType()->WriteSfxItem( GetName().getString(), rBase, rOutStm );
1442         else
1443             WriteSfxItem( GetName().getString(), rBase, rOutStm );
1444     }
1445 }
1446
1447 sal_Bool SvMetaType::ReadMethodArgs( SvIdlDataBase & rBase,
1448                                       SvTokenStream & rInStm )
1449 {
1450     sal_uInt32  nTokPos = rInStm.Tell();
1451     if( rInStm.Read( '(' ) )
1452     {
1453         DoReadContextSvIdl( rBase, rInStm );
1454         if( rInStm.Read( ')' ) )
1455         {
1456             SetType( TYPE_METHOD );
1457             return sal_True;
1458         }
1459     }
1460     rInStm.Seek( nTokPos );
1461     return sal_False;
1462 }
1463
1464 void SvMetaType::WriteMethodArgs
1465 (
1466     SvIdlDataBase & rBase,
1467     SvStream & rOutStm,
1468     sal_uInt16 nTab, WriteType nT
1469 )
1470 {
1471     if( nT == WRITE_IDL )
1472     {
1473         if( GetAttrCount() )
1474         {
1475             rOutStm << endl;
1476             WriteTab( rOutStm, nTab );
1477             rOutStm << '(' << endl;
1478
1479             SvMetaAttribute * pAttr = pAttrList->First();
1480             while( pAttr )
1481             {
1482                 WriteTab( rOutStm, nTab +1 );
1483                 pAttr->WriteSvIdl( rBase, rOutStm, nTab +1 );
1484                 pAttr = pAttrList->Next();
1485                 if( pAttr )
1486                        rOutStm << ',' << endl;
1487             }
1488             rOutStm << endl;
1489             WriteTab( rOutStm, nTab );
1490             rOutStm << ')';
1491         }
1492         else
1493             rOutStm << "()";
1494     }
1495     else if ( nT == WRITE_DOCU )
1496     {
1497
1498         rOutStm << '(';
1499         if( GetAttrCount() )
1500         {
1501             SvMetaAttribute * pAttr = pAttrList->First();
1502             while( pAttr )
1503             {
1504                 pAttr->WriteParam( rBase, rOutStm, nTab+1, nT );
1505                 pAttr = pAttrList->Next();
1506                 if( pAttr )
1507                     rOutStm << ',';
1508                 else
1509                     rOutStm << ' ';
1510             }
1511         }
1512         rOutStm << ')' << endl;
1513     }
1514     else
1515     {
1516         rOutStm << '(';
1517         if( nT == WRITE_C_HEADER || nT == WRITE_C_SOURCE )
1518         {
1519             rOutStm << ' ' << C_PREF << "Object h" << rBase.aIFaceName.getStr();
1520             if( GetAttrCount() )
1521                 rOutStm << ',';
1522             else
1523                 rOutStm << ' ';
1524         }
1525
1526         if( GetAttrCount() )
1527         {
1528             rOutStm << endl;
1529             SvMetaAttribute * pAttr = pAttrList->First();
1530             while( pAttr )
1531             {
1532                 switch( nT )
1533                 {
1534                     case WRITE_C_HEADER:
1535                     case WRITE_C_SOURCE:
1536                     case WRITE_ODL:
1537                     {
1538                         pAttr->WriteParam( rBase, rOutStm, nTab +1, nT );
1539                     }
1540                     break;
1541
1542                     default:
1543                     {
1544                         DBG_ASSERT( sal_False, "WriteType not implemented" );
1545                     }
1546                 }
1547                 pAttr = pAttrList->Next();
1548                 if( pAttr )
1549                        rOutStm << ',' << endl;
1550             }
1551             if( nT != WRITE_C_HEADER && nT != WRITE_C_SOURCE )
1552             {
1553                 rOutStm << endl;
1554                 WriteTab( rOutStm, nTab +1 );
1555             }
1556             rOutStm << ' ';
1557         }
1558         rOutStm << ')';
1559     }
1560 }
1561
1562 void SvMetaType::WriteTypePrefix( SvIdlDataBase & rBase, SvStream & rOutStm,
1563                                  sal_uInt16 nTab, WriteType nT )
1564 {
1565     switch( nT )
1566     {
1567         case WRITE_IDL:
1568         {
1569             if( GetIn() && GetOut() )
1570                 rOutStm << SvHash_inout()->GetName().getStr() << ' ';
1571             else if( GetIn() )
1572                 rOutStm << SvHash_in()->GetName().getStr() << ' ';
1573             else if( GetOut() )
1574                 rOutStm << SvHash_out()->GetName().getStr() << ' ';
1575             rOutStm << GetCString().getStr();
1576         }
1577         break;
1578
1579         case WRITE_ODL:
1580         {
1581             sal_Bool bIn = GetIn();
1582             sal_Bool bOut = GetOut();
1583             if( bIn || bOut )
1584             {
1585                 if( bIn && bOut )
1586                     rOutStm << "[in,out] ";
1587                 else if( bIn )
1588                     rOutStm << "[in] ";
1589                 else if( bOut )
1590                     rOutStm << "[out] ";
1591             }
1592
1593             rtl::OString out;
1594             if( GetType() == TYPE_METHOD )
1595                 out = GetReturnType()->GetBaseType()->GetOdlName();
1596             else
1597             {
1598                 SvMetaType * pBType = GetBaseType();
1599                 out = pBType->GetOdlName();
1600             }
1601             if( aCall0 == (int)CALL_POINTER
1602               || aCall0 == (int)CALL_REFERENCE )
1603                 rOutStm << " *";
1604             if( aCall1 == (int)CALL_POINTER
1605               || aCall1 == (int)CALL_REFERENCE )
1606                 rOutStm << " *";
1607             rOutStm << out.getStr();
1608         }
1609         break;
1610
1611         case WRITE_C_HEADER:
1612         case WRITE_C_SOURCE:
1613         case WRITE_CXX_HEADER:
1614         case WRITE_CXX_SOURCE:
1615         {
1616
1617             SvMetaType * pBaseType = GetBaseType();
1618             DBG_ASSERT( pBaseType, "no base type for attribute" );
1619
1620             if( pBaseType->GetType() == TYPE_METHOD )
1621                 pBaseType->GetReturnType()->WriteTypePrefix(
1622                     rBase, rOutStm, nTab, nT );
1623             else if( nT == WRITE_C_HEADER || nT == WRITE_C_SOURCE )
1624             {
1625                 if( TYPE_STRUCT == pBaseType->GetType() )
1626                     rOutStm << C_PREF << pBaseType->GetName().getString().getStr()
1627                             << " *";
1628                 else
1629                 {
1630                     if ( pBaseType->GetType() == TYPE_ENUM )
1631                         rOutStm << C_PREF;
1632                     rOutStm << pBaseType->GetCName().getStr();
1633                 }
1634             }
1635             else
1636             {
1637                 if( TYPE_STRUCT == pBaseType->GetType() )
1638                     rOutStm << pBaseType->GetName().getString().getStr() << " *";
1639                 else
1640                     rOutStm << pBaseType->GetName().getString().getStr();
1641             }
1642         }
1643         break;
1644
1645         case WRITE_DOCU:
1646         {
1647
1648             SvMetaType * pBaseType = GetBaseType();
1649             DBG_ASSERT( pBaseType, "no base type for attribute" );
1650
1651             if( pBaseType->GetType() == TYPE_METHOD )
1652             {
1653                 pBaseType->GetReturnType()->WriteTypePrefix(
1654                     rBase, rOutStm, nTab, nT );
1655             }
1656             else
1657             {
1658                 if( TYPE_STRUCT == pBaseType->GetType() )
1659                     rOutStm << "VARIANT" << pBaseType->GetName().getString().getStr();
1660                 else if ( pBaseType->GetType() == TYPE_ENUM )
1661                     rOutStm << "integer";
1662                 else
1663                     rOutStm << pBaseType->GetOdlName().getStr();
1664             }
1665         }
1666
1667         default:
1668         {
1669             DBG_ASSERT( sal_False, "WriteType not implemented" );
1670         }
1671     }
1672 }
1673
1674 void SvMetaType::WriteTheType( SvIdlDataBase & rBase, SvStream & rOutStm,
1675                              sal_uInt16 nTab, WriteType nT )
1676 {
1677     WriteTypePrefix( rBase, rOutStm, nTab, nT );
1678     if( GetType() == TYPE_METHOD )
1679         WriteMethodArgs( rBase, rOutStm, nTab +2, nT );
1680 }
1681
1682 rtl::OString SvMetaType::GetParserString() const
1683 {
1684     SvMetaType * pBT = GetBaseType();
1685     if( pBT != this )
1686         return pBT->GetParserString();
1687
1688     int type = GetType();
1689     rtl::OString aPStr;
1690
1691     if( TYPE_METHOD == type || TYPE_STRUCT == type )
1692     {
1693         sal_uLong nAttrCount = GetAttrCount();
1694         // write the single attributes
1695         for( sal_uLong n = 0; n < nAttrCount; n++ )
1696         {
1697             SvMetaAttribute * pT = pAttrList->GetObject( n );
1698             aPStr += pT->GetType()->GetParserString();
1699         }
1700     }
1701     else
1702         aPStr = rtl::OString(GetParserChar());
1703     return aPStr;
1704 }
1705
1706 void SvMetaType::WriteParamNames( SvIdlDataBase & rBase,
1707                                    SvStream & rOutStm,
1708                                    const rtl::OString& rChief )
1709 {
1710     SvMetaType * pBT = GetBaseType();
1711     if( pBT != this )
1712         pBT->WriteParamNames( rBase, rOutStm, rChief );
1713     else
1714     {
1715         int type = GetType();
1716
1717         if( TYPE_METHOD == type || TYPE_STRUCT == type )
1718         {
1719             sal_uLong nAttrCount = GetAttrCount();
1720             // write the single attributes
1721             for( sal_uLong n = 0; n < nAttrCount; n++ )
1722             {
1723                 SvMetaAttribute * pA = pAttrList->GetObject( n );
1724                 rtl::OString aStr = pA->GetName().getString();
1725                 pA->GetType()->WriteParamNames( rBase, rOutStm, aStr );
1726                 if( n +1 < nAttrCount )
1727                     rOutStm << ", ";
1728             }
1729         }
1730         else
1731             rOutStm << rChief.getStr();
1732     }
1733 }
1734
1735 SV_IMPL_META_FACTORY1( SvMetaTypeString, SvMetaType );
1736 SvMetaTypeString::SvMetaTypeString()
1737     : SvMetaType( "String", "SbxSTRING", "BSTR", 's', "char *", "String", "$" )
1738 {
1739 }
1740
1741 void SvMetaTypeString::Load( SvPersistStream & rStm )
1742 {
1743     SvMetaType::Load( rStm );
1744 }
1745
1746 void SvMetaTypeString::Save( SvPersistStream & rStm )
1747 {
1748     SvMetaType::Save( rStm );
1749 }
1750
1751 SV_IMPL_META_FACTORY1( SvMetaEnumValue, SvMetaName );
1752 SvMetaEnumValue::SvMetaEnumValue()
1753 {
1754 }
1755
1756 void SvMetaEnumValue::Load( SvPersistStream & rStm )
1757 {
1758     SvMetaName::Load( rStm );
1759
1760     sal_uInt8 nMask;
1761     rStm >> nMask;
1762     if( nMask >= 0x02 )
1763     {
1764         rStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
1765         OSL_FAIL( "wrong format" );
1766         return;
1767     }
1768     if( nMask & 0x01 ) aEnumValue = read_lenPrefixed_uInt8s_ToOString<sal_uInt16>(rStm);
1769 }
1770
1771 void SvMetaEnumValue::Save( SvPersistStream & rStm )
1772 {
1773     SvMetaName::Save( rStm );
1774
1775     // create mask
1776     sal_uInt8 nMask = 0;
1777     if( !aEnumValue.isEmpty() ) nMask |= 0x01;
1778
1779     // write data
1780     rStm << nMask;
1781     if( nMask & 0x01 ) write_lenPrefixed_uInt8s_FromOString<sal_uInt16>(rStm, aEnumValue);
1782 }
1783
1784 sal_Bool SvMetaEnumValue::ReadSvIdl( SvIdlDataBase & rBase,
1785                                  SvTokenStream & rInStm )
1786 {
1787     if( !ReadNameSvIdl( rBase, rInStm ) )
1788         return sal_False;
1789     return sal_True;
1790 }
1791
1792 void SvMetaEnumValue::WriteSvIdl( SvIdlDataBase &, SvStream & rOutStm, sal_uInt16 )
1793 {
1794     rOutStm << GetName().getString().getStr();
1795 }
1796
1797 void SvMetaEnumValue::Write( SvIdlDataBase &, SvStream & rOutStm, sal_uInt16,
1798                              WriteType nT, WriteAttribute )
1799 {
1800     if ( nT == WRITE_C_HEADER || nT == WRITE_C_SOURCE )
1801         rOutStm << C_PREF << GetName().getString().getStr();
1802     else
1803         rOutStm << GetName().getString().getStr();
1804 }
1805
1806 SV_IMPL_META_FACTORY1( SvMetaTypeEnum, SvMetaType );
1807 SvMetaTypeEnum::SvMetaTypeEnum()
1808 {
1809     SetBasicName("Integer");
1810 }
1811
1812 void SvMetaTypeEnum::Load( SvPersistStream & rStm )
1813 {
1814     SvMetaType::Load( rStm );
1815
1816     sal_uInt8 nMask;
1817     rStm >> nMask;
1818     if( nMask >= 0x04 )
1819     {
1820         rStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
1821         OSL_FAIL( "wrong format" );
1822         return;
1823     }
1824     if( nMask & 0x01 ) rStm >> aEnumValueList;
1825     if( nMask & 0x02 ) aPrefix = read_lenPrefixed_uInt8s_ToOString<sal_uInt16>(rStm);
1826 }
1827
1828 void SvMetaTypeEnum::Save( SvPersistStream & rStm )
1829 {
1830     SvMetaType::Save( rStm );
1831
1832     // create mask
1833     sal_uInt8 nMask = 0;
1834     if( aEnumValueList.Count() )    nMask |= 0x01;
1835     if( !aPrefix.isEmpty() )        nMask |= 0x02;
1836
1837     // write data
1838     rStm << nMask;
1839     if( nMask & 0x01 ) rStm << aEnumValueList;
1840     if( nMask & 0x02 ) write_lenPrefixed_uInt8s_FromOString<sal_uInt16>(rStm, aPrefix);
1841 }
1842
1843 namespace
1844 {
1845     rtl::OString getCommonSubPrefix(const rtl::OString &rA, const rtl::OString &rB)
1846     {
1847         sal_Int32 nMax = std::min(rA.getLength(), rB.getLength());
1848         sal_Int32 nI = 0;
1849         while (nI < nMax)
1850         {
1851             if (rA[nI] != rB[nI])
1852                 break;
1853             ++nI;
1854         }
1855         return rA.copy(0, nI);
1856     }
1857 }
1858
1859 void SvMetaTypeEnum::ReadContextSvIdl( SvIdlDataBase & rBase,
1860                                        SvTokenStream & rInStm )
1861 {
1862     sal_uInt32 nTokPos = rInStm.Tell();
1863
1864     SvMetaEnumValueRef aEnumVal = new SvMetaEnumValue();
1865     sal_Bool bOk = aEnumVal->ReadSvIdl( rBase, rInStm );
1866     if( bOk )
1867     {
1868         if( 0 == aEnumValueList.Count() )
1869         {
1870            // the first
1871            aPrefix = aEnumVal->GetName().getString();
1872         }
1873         else
1874         {
1875             aPrefix = getCommonSubPrefix(aPrefix, aEnumVal->GetName().getString());
1876         }
1877         aEnumValueList.Append( aEnumVal );
1878     }
1879     if( !bOk )
1880         rInStm.Seek( nTokPos );
1881 }
1882
1883 void SvMetaTypeEnum::WriteContextSvIdl( SvIdlDataBase & rBase,
1884                                         SvStream & rOutStm,
1885                                         sal_uInt16 nTab )
1886 {
1887     WriteTab( rOutStm, nTab +1 );
1888     for( sal_uLong n = 0; n < aEnumValueList.Count(); n++ )
1889     {
1890         aEnumValueList.GetObject( n )->WriteSvIdl( rBase, rOutStm, nTab );
1891         if( n +1 != aEnumValueList.Count() )
1892             rOutStm << ", ";
1893         else
1894             rOutStm << endl;
1895     }
1896 }
1897
1898 sal_Bool SvMetaTypeEnum::ReadSvIdl( SvIdlDataBase & rBase,
1899                                 SvTokenStream & rInStm )
1900 {
1901     sal_uInt32  nTokPos = rInStm.Tell();
1902     if( SvMetaType::ReadHeaderSvIdl( rBase, rInStm )
1903       && GetType() == TYPE_ENUM )
1904     {
1905         if( SvMetaName::ReadSvIdl( rBase, rInStm ) )
1906              return sal_True;
1907     }
1908     rInStm.Seek( nTokPos );
1909     return sal_False;
1910 }
1911
1912 void SvMetaTypeEnum::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
1913                                    sal_uInt16 nTab )
1914 {
1915     WriteHeaderSvIdl( rBase, rOutStm, nTab );
1916     rOutStm << endl;
1917     SvMetaName::WriteSvIdl( rBase, rOutStm, nTab );
1918     rOutStm << endl;
1919 }
1920
1921 void SvMetaTypeEnum::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
1922                             sal_uInt16 nTab,
1923                              WriteType nT, WriteAttribute nA )
1924 {
1925     SvMetaType::Write( rBase, rOutStm, nTab, nT, nA );
1926 }
1927
1928 void SvMetaTypeEnum::WriteContext( SvIdlDataBase & rBase, SvStream & rOutStm,
1929                                    sal_uInt16 nTab,
1930                                  WriteType nT, WriteAttribute nA )
1931 {
1932     WriteTab( rOutStm, nTab +1 );
1933     for( sal_uLong n = 0; n < aEnumValueList.Count(); n++ )
1934     {
1935         aEnumValueList.GetObject( n )->Write( rBase, rOutStm, nTab +1, nT, nA );
1936
1937         if( n +1 != aEnumValueList.Count() )
1938         {
1939             if( 2 == n % 3 )
1940             {
1941                 rOutStm << ',' << endl;
1942                 WriteTab( rOutStm, nTab +1 );
1943             }
1944             else
1945                 rOutStm << ",\t";
1946         }
1947         else
1948             rOutStm << endl;
1949     }
1950     rOutStm << endl;
1951 }
1952
1953 SV_IMPL_META_FACTORY1( SvMetaTypevoid, SvMetaType );
1954 SvMetaTypevoid::SvMetaTypevoid()
1955     : SvMetaType( "void", "SbxVOID", "void", 'v', "void", "", "" )
1956 {
1957 }
1958
1959 void SvMetaTypevoid::Load( SvPersistStream & rStm )
1960 {
1961     SvMetaType::Load( rStm );
1962 }
1963
1964 void SvMetaTypevoid::Save( SvPersistStream & rStm )
1965 {
1966     SvMetaType::Save( rStm );
1967 }
1968
1969 rtl::OString SvMetaAttribute::Compare( SvMetaAttribute* pAttr )
1970 {
1971     rtl::OStringBuffer aStr;
1972
1973     if ( aType.Is() )
1974     {
1975         if ( aType->GetType() == TYPE_METHOD )
1976         {
1977             // Test only when the attribute is a method not if it has one!
1978             if ( !pAttr->GetType()->GetType() == TYPE_METHOD )
1979                 aStr.append("    IsMethod\n");
1980             else if ( aType->GetReturnType() &&
1981                 aType->GetReturnType()->GetType() != pAttr->GetType()->GetReturnType()->GetType() )
1982             {
1983                 aStr.append("    ReturnType\n");
1984             }
1985
1986             if ( aType->GetAttrCount() )
1987             {
1988                 sal_uLong nCount = aType->GetAttrCount();
1989                 SvMetaAttributeMemberList& rList = aType->GetAttrList();
1990                 SvMetaAttributeMemberList& rOtherList = pAttr->GetType()->GetAttrList();
1991                 if ( pAttr->GetType()->GetAttrCount() != nCount )
1992                 {
1993                     aStr.append("    AttributeCount\n");
1994                 }
1995                 else
1996                 {
1997                     for ( sal_uInt16 n=0; n<nCount; n++ )
1998                     {
1999                         SvMetaAttribute *pAttr1 = rList.GetObject(n);
2000                         SvMetaAttribute *pAttr2 = rOtherList.GetObject(n);
2001                         pAttr1->Compare( pAttr2 );
2002                     }
2003                 }
2004             }
2005         }
2006
2007         if ( GetType()->GetType() != pAttr->GetType()->GetType() )
2008             aStr.append("    Type\n");
2009
2010         if ( !GetType()->GetSvName().equals( pAttr->GetType()->GetSvName() ) )
2011             aStr.append("    ItemType\n");
2012     }
2013
2014     if ( GetExport() != pAttr->GetExport() )
2015         aStr.append("    Export\n");
2016
2017     if ( GetAutomation() != pAttr->GetAutomation() )
2018         aStr.append("    Automation\n");
2019
2020     if ( GetIsCollection() != pAttr->GetIsCollection() )
2021         aStr.append("    IsCollection\n");
2022
2023     if ( GetReadOnlyDoc() != pAttr->GetReadOnlyDoc() )
2024         aStr.append("    ReadOnlyDoc\n");
2025
2026     if ( GetExport() && GetReadonly() != pAttr->GetReadonly() )
2027         aStr.append("    Readonly\n");
2028
2029     return aStr.makeStringAndClear();
2030 }
2031
2032 void SvMetaAttribute::WriteCSV( SvIdlDataBase&, SvStream& rStrm )
2033 {
2034     rStrm << GetType()->GetSvName().getStr() << ' ';
2035     rStrm << GetName().getString().getStr() << ' ';
2036     rStrm << GetSlotId().getString().getStr();
2037 }
2038
2039
2040 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */