1 /************************************************************************* 2 * 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * Copyright 2000, 2010 Oracle and/or its affiliates. 6 * 7 * OpenOffice.org - a multi-platform office productivity suite 8 * 9 * This file is part of OpenOffice.org. 10 * 11 * OpenOffice.org is free software: you can redistribute it and/or modify 12 * it under the terms of the GNU Lesser General Public License version 3 13 * only, as published by the Free Software Foundation. 14 * 15 * OpenOffice.org is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU Lesser General Public License version 3 for more details 19 * (a copy is included in the LICENSE file that accompanied this code). 20 * 21 * You should have received a copy of the GNU Lesser General Public License 22 * version 3 along with OpenOffice.org. If not, see 23 * <http://www.openoffice.org/license.html> 24 * for a copy of the LGPLv3 License. 25 * 26 ************************************************************************/ 27 28 // MARKER(update_precomp.py): autogen include statement, do not remove 29 #include "precompiled_idl.hxx" 30 31 #include <ctype.h> 32 #include <stdio.h> 33 34 #include <tools/debug.hxx> 35 36 #include <attrib.hxx> 37 #include <basobj.hxx> 38 #include <module.hxx> 39 #include <globals.hxx> 40 #include <database.hxx> 41 42 /****************** SvMetaObject *****************************************/ 43 SV_IMPL_META_FACTORY1( SvMetaObject, SvRttiBase ) 44 /************************************************************************* 45 |* SvMetaObject::SvMetaObject() 46 |* 47 |* Beschreibung 48 *************************************************************************/ 49 SvMetaObject::SvMetaObject() 50 { 51 } 52 53 void SvMetaObject::Load( SvPersistStream & ) 54 { 55 } 56 57 void SvMetaObject::Save( SvPersistStream & ) 58 { 59 } 60 61 /************************************************************************* 62 |* SvMetaObject::WriteTab() 63 |* 64 |* Beschreibung 65 *************************************************************************/ 66 #ifdef IDL_COMPILER 67 void SvMetaObject::WriteTab( SvStream & rOutStm, sal_uInt16 nTab ) 68 { 69 while( nTab-- ) 70 rOutStm << " "; 71 // rOutStm << '\t'; 72 } 73 74 /************************************************************************* 75 |* SvMetaObject::WriteStart() 76 |* 77 |* Beschreibung 78 *************************************************************************/ 79 void SvMetaObject::WriteStars( SvStream & rOutStm ) 80 { 81 rOutStm << '/'; 82 for( int i = 6; i > 0; i-- ) 83 rOutStm << "**********"; 84 rOutStm << '/' << endl; 85 } 86 87 /************************************************************************* 88 |* SvMetaObject::TestAndSeekSpaceOnly() 89 |* 90 |* Beschreibung 91 *************************************************************************/ 92 sal_Bool SvMetaObject::TestAndSeekSpaceOnly( SvStream & rOutStm, sal_uLong nBegPos ) 93 { 94 // keine leeren Klammern schreiben 95 sal_uLong nPos = rOutStm.Tell(); 96 rOutStm.Seek( nBegPos ); 97 sal_Bool bOnlySpace = sal_True; 98 while( bOnlySpace && rOutStm.Tell() < nPos ) 99 { 100 char c; 101 rOutStm >> c; 102 if( !isspace( c ) ) 103 bOnlySpace = sal_False; 104 } 105 if( bOnlySpace ) 106 // nichts geschrieben 107 rOutStm.Seek( nBegPos ); 108 else 109 rOutStm.Seek( nPos ); 110 return bOnlySpace; 111 } 112 113 /************************************************************************* 114 |* SvMetaObject::Back2Delemitter() 115 |* 116 |* Beschreibung 117 *************************************************************************/ 118 void SvMetaObject::Back2Delemitter( SvStream & rOutStm ) 119 { 120 // keine leeren Klammern schreiben 121 sal_uLong nPos = rOutStm.Tell(); 122 rOutStm.SeekRel( -1 ); 123 char c = 0; 124 rOutStm >> c; 125 126 while( isspace( c ) && rOutStm.Tell() != 1 ) 127 { 128 rOutStm.SeekRel( -2 ); 129 rOutStm >> c; 130 } 131 132 if( c == ';' || c == ',' ) 133 rOutStm.SeekRel( -1 ); 134 else 135 rOutStm.Seek( nPos ); 136 } 137 138 /************************************************************************* 139 |* SvMetaObject::ReadSvIdl() 140 |* 141 |* Beschreibung 142 *************************************************************************/ 143 sal_Bool SvMetaObject::ReadSvIdl( SvIdlDataBase &, SvTokenStream & ) 144 { 145 return sal_False; 146 } 147 148 /************************************************************************* 149 |* SvMetaObject::WriteSvIdl() 150 |* 151 |* Beschreibung 152 *************************************************************************/ 153 void SvMetaObject::WriteSvIdl( SvIdlDataBase &, SvStream &, sal_uInt16 /*nTab */ ) 154 { 155 } 156 157 /************************************************************************* 158 |* SvMetaObject::Write() 159 |* 160 |* Beschreibung 161 *************************************************************************/ 162 void SvMetaObject::Write( SvIdlDataBase &, SvStream &, sal_uInt16 /*nTab */, 163 WriteType, WriteAttribute ) 164 { 165 } 166 167 /************************************************************************* 168 |* SvMetaObject::WriteCxx() 169 |* 170 |* Beschreibung 171 *************************************************************************/ 172 void SvMetaObject::WriteCxx( SvIdlDataBase &, SvStream &, sal_uInt16 /*nTab */ ) 173 { 174 } 175 176 /************************************************************************* 177 |* SvMetaObject::WriteHxx() 178 |* 179 |* Beschreibung 180 *************************************************************************/ 181 void SvMetaObject::WriteHxx( SvIdlDataBase &, SvStream &, sal_uInt16 /*nTab */ ) 182 { 183 } 184 185 #endif 186 187 /****************** SvMetaName *****************************************/ 188 SV_IMPL_META_FACTORY1( SvMetaName, SvMetaObject ); 189 /************************************************************************* 190 |* SvMetaName::SvMetaName() 191 |* 192 |* Beschreibung 193 *************************************************************************/ 194 SvMetaName::SvMetaName() 195 { 196 } 197 198 void SvMetaName::Load( SvPersistStream & rStm ) 199 { 200 SvMetaObject::Load( rStm ); 201 sal_uInt8 nMask; 202 rStm >> nMask; 203 204 if( nMask >= 0x20 ) 205 { 206 rStm.SetError( SVSTREAM_FILEFORMAT_ERROR ); 207 DBG_ERROR( "wrong format" ); 208 return; 209 } 210 if( nMask & 0x01 ) rStm >> aName; 211 if( nMask & 0x02 ) rStm >> aHelpContext; 212 if( nMask & 0x04 ) rStm >> aHelpText; 213 if( nMask & 0x08 ) rStm >> aConfigName; 214 if( nMask & 0x10 ) rStm >> aDescription; 215 } 216 217 void SvMetaName::Save( SvPersistStream & rStm ) 218 { 219 SvMetaObject::Save( rStm ); 220 sal_uInt8 nMask = 0; 221 if( aName.IsSet() ) nMask |= 0x01; 222 if( aHelpContext.IsSet() ) nMask |= 0x02; 223 if( aHelpText.IsSet() ) nMask |= 0x04; 224 if( aConfigName.IsSet() ) nMask |= 0x08; 225 if( aDescription.IsSet() ) nMask |= 0x10; 226 227 rStm << nMask; 228 if( nMask & 0x01 ) rStm << aName; 229 if( nMask & 0x02 ) rStm << aHelpContext; 230 if( nMask & 0x04 ) rStm << aHelpText; 231 if( nMask & 0x08 ) rStm << aConfigName; 232 if( nMask & 0x10 ) rStm << aDescription; 233 } 234 235 /************************************************************************* 236 |* 237 |* 238 |* Beschreibung 239 *************************************************************************/ 240 sal_Bool SvMetaName::SetName( const ByteString & rName, SvIdlDataBase * ) 241 { 242 aName = rName; 243 return sal_True; 244 } 245 246 #ifdef IDL_COMPILER 247 /************************************************************************* 248 |* SvMetaName::ReadNameSvIdl() 249 |* 250 |* Beschreibung 251 *************************************************************************/ 252 sal_Bool SvMetaName::ReadNameSvIdl( SvIdlDataBase & rBase, 253 SvTokenStream & rInStm ) 254 { 255 sal_uInt32 nTokPos = rInStm.Tell(); 256 SvToken * pTok = rInStm.GetToken_Next(); 257 258 // Modulnamen lesen 259 if( pTok->IsIdentifier() ) 260 if( SetName( pTok->GetString(), &rBase ) ) 261 return sal_True; 262 263 rInStm.Seek( nTokPos ); 264 return sal_False; 265 } 266 267 /************************************************************************* 268 |* SvMetaName::ReadSvIdl() 269 |* 270 |* Beschreibung 271 *************************************************************************/ 272 void SvMetaName::ReadAttributesSvIdl( SvIdlDataBase & rBase, 273 SvTokenStream & rInStm ) 274 { 275 sal_uInt32 nTokPos = rInStm.Tell(); 276 if( aName.ReadSvIdl( SvHash_Name(), rInStm ) ) 277 { 278 if( !SetName( aName, &rBase ) ) 279 rInStm.Seek( nTokPos ); 280 } 281 aHelpContext.ReadSvIdl( rBase, SvHash_HelpContext(), rInStm ); 282 aHelpText.ReadSvIdl( rBase, rInStm ); 283 aConfigName.ReadSvIdl( SvHash_ConfigName(), rInStm ); 284 aDescription.ReadSvIdl( SvHash_Description(), rInStm ); 285 /* 286 aHelpContext.ReadSvIdl( GetModule()->GetInfo()->GetHelpContextContainer(), 287 rInStm ); 288 */ 289 } 290 291 /************************************************************************* 292 |* SvMetaName::DoReadContextSvIdl() 293 |* 294 |* Beschreibung 295 *************************************************************************/ 296 void SvMetaName::DoReadContextSvIdl( SvIdlDataBase & rBase, 297 SvTokenStream & rInStm, char cDel ) 298 { 299 sal_uInt32 nBeginPos = 0; // kann mit Tell nicht vorkommen 300 while( nBeginPos != rInStm.Tell() ) 301 { 302 nBeginPos = rInStm.Tell(); 303 ReadContextSvIdl( rBase, rInStm ); 304 if( cDel == '\0' ) 305 rInStm.ReadDelemiter(); 306 else 307 rInStm.Read( cDel ); 308 } 309 } 310 311 /************************************************************************* 312 |* SvMetaName::ReadSvIdl() 313 |* 314 |* Beschreibung 315 *************************************************************************/ 316 void SvMetaName::ReadContextSvIdl( SvIdlDataBase &, SvTokenStream & ) 317 { 318 } 319 320 /************************************************************************* 321 |* SvMetaName::Test() 322 |* 323 |* Beschreibung 324 *************************************************************************/ 325 sal_Bool SvMetaName::Test( SvIdlDataBase &, SvTokenStream & ) 326 { 327 return sal_True; 328 } 329 330 /************************************************************************* 331 |* SvMetaName::WriteContextSvIdl() 332 |* 333 |* Beschreibung 334 *************************************************************************/ 335 void SvMetaName::WriteContextSvIdl( SvIdlDataBase &, SvStream &, sal_uInt16 ) 336 { 337 } 338 339 /************************************************************************* 340 |* SvMetaName::WriteDescription() 341 |* 342 |* Beschreibung 343 *************************************************************************/ 344 void SvMetaName::WriteDescription( SvStream & rOutStm ) 345 { 346 rOutStm << "<DESCRIPTION>" << endl; 347 348 ByteString aDesc( GetDescription() ); 349 sal_uInt16 nPos = aDesc.Search( '\n' ); 350 while ( nPos != STRING_NOTFOUND ) 351 { 352 rOutStm << aDesc.Copy( 0, nPos ).GetBuffer() << endl; 353 aDesc.Erase(0,nPos+1); 354 nPos = aDesc.Search( '\n' ); 355 } 356 357 rOutStm << aDesc.GetBuffer() << endl << "</DESCRIPTION>" << endl; 358 } 359 360 /************************************************************************* 361 |* SvMetaName::WriteAttributesIdl() 362 |* 363 |* Beschreibung 364 *************************************************************************/ 365 void SvMetaName::WriteAttributesSvIdl( SvIdlDataBase & rBase, 366 SvStream & rOutStm, 367 sal_uInt16 nTab ) 368 { 369 if( aHelpContext.IsSet() || aHelpText.IsSet() || aConfigName.IsSet() ) 370 { 371 WriteTab( rOutStm, nTab ); 372 rOutStm << "// class SvMetaName" << endl; 373 } 374 if( aHelpContext.IsSet() ) 375 { 376 WriteTab( rOutStm, nTab ); 377 aHelpContext.WriteSvIdl( SvHash_HelpContext(), rOutStm, nTab ); 378 rOutStm << ';' << endl; 379 } 380 if( aHelpText.IsSet() ) 381 { 382 WriteTab( rOutStm, nTab ); 383 aHelpText.WriteSvIdl( rBase, rOutStm, nTab ); 384 rOutStm << ';' << endl; 385 } 386 if( aConfigName.IsSet() ) 387 { 388 WriteTab( rOutStm, nTab ); 389 aConfigName.WriteSvIdl( SvHash_ConfigName(), rOutStm, nTab ); 390 rOutStm << ';' << endl; 391 } 392 } 393 394 /************************************************************************* 395 |* SvMetaName::ReadSvIdl() 396 |* 397 |* Beschreibung 398 *************************************************************************/ 399 sal_Bool SvMetaName::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm ) 400 { 401 sal_uInt32 nTokPos = rInStm.Tell(); 402 sal_Bool bOk = sal_True; 403 if( rInStm.Read( '[' ) ) 404 { 405 sal_uInt32 nBeginPos = 0; // kann mit Tell nicht vorkommen 406 while( nBeginPos != rInStm.Tell() ) 407 { 408 nBeginPos = rInStm.Tell(); 409 ReadAttributesSvIdl( rBase, rInStm ); 410 rInStm.ReadDelemiter(); 411 } 412 bOk = rInStm.Read( ']' ); 413 } 414 415 if( bOk ) 416 { 417 if( rInStm.Read( '{' ) ) 418 { 419 DoReadContextSvIdl( rBase, rInStm ); 420 bOk = rInStm.Read( '}' ); 421 } 422 } 423 424 if( !bOk ) 425 rInStm.Seek( nTokPos ); 426 return bOk; 427 } 428 429 /************************************************************************* 430 |* SvMetaName::WriteSvIdl() 431 |* 432 |* Beschreibung 433 *************************************************************************/ 434 void SvMetaName::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm, 435 sal_uInt16 nTab ) 436 { 437 sal_uLong nBeginPos = rOutStm.Tell(); 438 WriteTab( rOutStm, nTab ); 439 rOutStm << '[' << endl; 440 sal_uLong nOldPos = rOutStm.Tell(); 441 WriteAttributesSvIdl( rBase, rOutStm, nTab +1 ); 442 443 // keine leeren Klammern schreiben 444 if( TestAndSeekSpaceOnly( rOutStm, nOldPos ) ) 445 // nichts geschrieben 446 rOutStm.Seek( nBeginPos ); 447 else 448 { 449 WriteTab( rOutStm, nTab ); 450 rOutStm << ']'; 451 nBeginPos = rOutStm.Tell(); 452 rOutStm << endl; 453 } 454 455 WriteTab( rOutStm, nTab ); 456 rOutStm << '{' << endl; 457 nOldPos = rOutStm.Tell(); 458 WriteContextSvIdl( rBase, rOutStm, nTab +1 ); 459 460 // keine leeren Klammern schreiben 461 if( TestAndSeekSpaceOnly( rOutStm, nOldPos ) ) 462 // nichts geschrieben 463 rOutStm.Seek( nBeginPos ); 464 else 465 { 466 WriteTab( rOutStm, nTab ); 467 rOutStm << '}'; 468 } 469 } 470 471 /************************************************************************* 472 |* SvMetaName::Write() 473 |* 474 |* Beschreibung 475 *************************************************************************/ 476 void SvMetaName::Write( SvIdlDataBase & rBase, SvStream & rOutStm, 477 sal_uInt16 nTab, 478 WriteType nT, WriteAttribute nA ) 479 { 480 sal_uLong nBeginPos = rOutStm.Tell(); 481 WriteTab( rOutStm, nTab ); 482 rOutStm << '[' << endl; 483 sal_uLong nOldPos = rOutStm.Tell(); 484 WriteAttributes( rBase, rOutStm, nTab +1, nT, nA ); 485 486 // keine leeren Klammern schreiben 487 sal_uLong nPos = rOutStm.Tell(); 488 rOutStm.Seek( nOldPos ); 489 sal_Bool bOnlySpace = sal_True; 490 while( bOnlySpace && rOutStm.Tell() < nPos ) 491 { 492 char c; 493 rOutStm >> c; 494 if( !isspace( c ) ) 495 bOnlySpace = sal_False; 496 } 497 if( bOnlySpace ) 498 // nichts geschrieben 499 rOutStm.Seek( nBeginPos ); 500 else 501 { 502 rOutStm.Seek( nPos ); 503 WriteTab( rOutStm, nTab ); 504 rOutStm << ']' << endl; 505 } 506 } 507 508 /************************************************************************* 509 |* SvMetaName::WriteAttributes() 510 |* 511 |* Beschreibung 512 *************************************************************************/ 513 void SvMetaName::WriteAttributes( SvIdlDataBase &, SvStream & rOutStm, 514 sal_uInt16 nTab, 515 WriteType, WriteAttribute ) 516 { 517 if( GetHelpText().IsSet() || GetHelpContext().IsSet() ) 518 { 519 WriteTab( rOutStm, nTab ); 520 rOutStm << "// class SvMetaName" << endl; 521 } 522 if( GetHelpText().IsSet() ) 523 { 524 WriteTab( rOutStm, nTab ); 525 rOutStm << "helpstring(\"" << GetHelpText().GetBuffer() << "\")," << endl; 526 } 527 if( GetHelpContext().IsSet() ) 528 { 529 WriteTab( rOutStm, nTab ); 530 rOutStm << "helpcontext(" 531 << ByteString::CreateFromInt64( 532 GetHelpContext().GetValue() ).GetBuffer() 533 << ")," << endl; 534 } 535 } 536 537 /************************************************************************* 538 |* SvMetaName::WriteContext() 539 |* 540 |* Beschreibung 541 *************************************************************************/ 542 void SvMetaName::WriteContext( SvIdlDataBase &, SvStream &, 543 sal_uInt16, 544 WriteType, WriteAttribute ) 545 { 546 } 547 #endif // IDL_COMPILER 548 549 /****************** SvMetaReference *****************************************/ 550 SV_IMPL_META_FACTORY1( SvMetaReference, SvMetaName ); 551 552 /************************************************************************* 553 |* SvMetaReference::SvMetaReference() 554 |* 555 |* Beschreibung 556 *************************************************************************/ 557 SvMetaReference::SvMetaReference() 558 { 559 } 560 561 void SvMetaReference::Load( SvPersistStream & rStm ) 562 { 563 SvMetaName::Load( rStm ); 564 565 sal_uInt8 nMask; 566 rStm >> nMask; 567 if( nMask >= 0x2 ) 568 { 569 rStm.SetError( SVSTREAM_FILEFORMAT_ERROR ); 570 DBG_ERROR( "wrong format" ); 571 return; 572 } 573 if( nMask & 0x01 ) 574 { 575 SvMetaReference * pRef; 576 rStm >> pRef; 577 aRef = pRef; 578 } 579 } 580 581 void SvMetaReference::Save( SvPersistStream & rStm ) 582 { 583 SvMetaName::Save( rStm ); 584 585 // Maske erstellen 586 sal_uInt8 nMask = 0; 587 if( aRef.Is() ) 588 nMask |= 0x01; 589 590 // Daten schreiben 591 rStm << nMask; 592 if( nMask & 0x01 ) rStm << aRef; 593 } 594 595 /**************************************************************************/ 596 /****************** SvMetaExtern ******************************************/ 597 SV_IMPL_META_FACTORY1( SvMetaExtern, SvMetaReference ); 598 599 /************************************************************************* 600 |* SvMetaExtern::SvMetaExtern() 601 |* 602 |* Beschreibung 603 *************************************************************************/ 604 SvMetaExtern::SvMetaExtern() 605 : pModule( NULL ) 606 , bReadUUId( sal_False ) 607 , bReadVersion( sal_False ) 608 { 609 } 610 611 void SvMetaExtern::Load( SvPersistStream & rStm ) 612 { 613 SvMetaReference::Load( rStm ); 614 615 sal_uInt8 nMask; 616 rStm >> nMask; 617 if( nMask >= 0x20 ) 618 { 619 rStm.SetError( SVSTREAM_FILEFORMAT_ERROR ); 620 DBG_ERROR( "wrong format" ); 621 return; 622 } 623 if( nMask & 0x01 ) rStm >> pModule; 624 if( nMask & 0x02 ) rStm >> aUUId; 625 if( nMask & 0x04 ) rStm >> aVersion; 626 if( nMask & 0x08 ) bReadUUId = sal_True; 627 if( nMask & 0x10 ) bReadVersion = sal_True; 628 } 629 630 void SvMetaExtern::Save( SvPersistStream & rStm ) 631 { 632 SvMetaReference::Save( rStm ); 633 634 // Maske erstellen 635 sal_uInt8 nMask = 0; 636 if( pModule ) nMask |= 0x01; 637 if( aUUId != SvGlobalName() ) nMask |= 0x02; 638 if( aVersion != SvVersion() ) nMask |= 0x04; 639 if( bReadUUId ) nMask |= 0x08; 640 if( bReadVersion ) nMask |= 0x10; 641 642 // Daten schreiben 643 rStm << nMask; 644 if( nMask & 0x01 ) rStm << pModule; 645 if( nMask & 0x02 ) rStm << aUUId; 646 if( nMask & 0x04 ) rStm << aVersion; 647 } 648 649 /************************************************************************* 650 |* SvMetaExtern::GetModule() 651 |* 652 |* Beschreibung 653 *************************************************************************/ 654 SvMetaModule * SvMetaExtern::GetModule() const 655 { 656 DBG_ASSERT( pModule != NULL, "module not set" ); 657 return pModule; 658 } 659 660 /************************************************************************* 661 |* SvMetaExtern::GetUUId() 662 |* 663 |* Beschreibung 664 *************************************************************************/ 665 const SvGlobalName & SvMetaExtern::GetUUId() const 666 { 667 #ifdef IDL_COMPILER 668 if( aUUId == SvGlobalName() ) 669 GetModule()->FillNextName( &((SvMetaExtern *)this)->aUUId ); 670 #endif 671 return aUUId; 672 } 673 674 #ifdef IDL_COMPILER 675 /************************************************************************* 676 |* SvMetaExtern::SetModule() 677 |* 678 |* Beschreibung 679 *************************************************************************/ 680 void SvMetaExtern::SetModule( SvIdlDataBase & rBase ) 681 { 682 pModule = (SvMetaModule *)rBase.GetStack().Get( TYPE( SvMetaModule ) ); 683 } 684 685 /************************************************************************* 686 |* SvMetaExtern::ReadAttributesSvIdl() 687 |* 688 |* Beschreibung 689 *************************************************************************/ 690 void SvMetaExtern::ReadAttributesSvIdl( SvIdlDataBase & rBase, 691 SvTokenStream & rInStm ) 692 { 693 SvMetaReference::ReadAttributesSvIdl( rBase, rInStm ); 694 if( aUUId.ReadSvIdl( rBase, rInStm ) ) 695 bReadUUId = sal_True; 696 if( aVersion.ReadSvIdl( rInStm ) ) 697 bReadVersion = sal_True; 698 } 699 700 /************************************************************************* 701 |* SvMetaExtern::WriteAttributesSvIdl() 702 |* 703 |* Beschreibung 704 *************************************************************************/ 705 void SvMetaExtern::WriteAttributesSvIdl( SvIdlDataBase & rBase, 706 SvStream & rOutStm, sal_uInt16 nTab ) 707 { 708 SvMetaReference::WriteAttributesSvIdl( rBase, rOutStm, nTab ); 709 if( bReadUUId || bReadVersion ) 710 { 711 WriteTab( rOutStm, nTab ); 712 rOutStm << "// class SvMetaExtern" << endl; 713 714 if( bReadUUId ) 715 { 716 WriteTab( rOutStm, nTab ); 717 aUUId.WriteSvIdl( rOutStm ); 718 rOutStm << ';' << endl; 719 } 720 if( bReadVersion ) 721 { 722 WriteTab( rOutStm, nTab ); 723 aVersion.WriteSvIdl( rOutStm ); 724 rOutStm << ';' << endl; 725 } 726 } 727 } 728 729 /************************************************************************* 730 |* SvMetaExtern::ReadSvIdl() 731 |* 732 |* Beschreibung 733 *************************************************************************/ 734 sal_Bool SvMetaExtern::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm ) 735 { 736 SetModule( rBase ); 737 GetUUId(); // Id wird angelegt 738 return SvMetaReference::ReadSvIdl( rBase, rInStm ); 739 } 740 741 /************************************************************************* 742 |* SvMetaExtern::WriteSvIdl() 743 |* 744 |* Beschreibung 745 *************************************************************************/ 746 void SvMetaExtern::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm, 747 sal_uInt16 nTab ) 748 { 749 SvMetaReference::WriteSvIdl( rBase, rOutStm, nTab ); 750 } 751 752 /************************************************************************* 753 |* SvMetaExtern::Write() 754 |* 755 |* Beschreibung 756 *************************************************************************/ 757 void SvMetaExtern::Write( SvIdlDataBase & rBase, SvStream & rOutStm, 758 sal_uInt16 nTab, 759 WriteType nT, WriteAttribute nA ) 760 { 761 SvMetaReference::Write( rBase, rOutStm, nTab, nT, nA ); 762 } 763 764 /************************************************************************* 765 |* SvMetaExtern::WriteAttributes() 766 |* 767 |* Beschreibung 768 *************************************************************************/ 769 void SvMetaExtern::WriteAttributes( SvIdlDataBase & rBase, SvStream & rOutStm, 770 sal_uInt16 nTab, 771 WriteType nT, WriteAttribute nA ) 772 { 773 SvMetaReference::WriteAttributes( rBase, rOutStm, nTab, nT, nA ); 774 775 WriteTab( rOutStm, nTab ); 776 rOutStm << "// class SvMetaExtern" << endl; 777 WriteTab( rOutStm, nTab ); 778 rOutStm << "uuid(" << ByteString( GetUUId().GetHexName(), RTL_TEXTENCODING_UTF8 ).GetBuffer() << ")," << endl; 779 WriteTab( rOutStm, nTab ); 780 rOutStm << "version(" << ByteString::CreateFromInt32( aVersion.GetMajorVersion() ).GetBuffer() << '.' 781 << ByteString::CreateFromInt32( aVersion.GetMinorVersion() ).GetBuffer() << ")," << endl; 782 } 783 784 #endif // IDL_COMPILER 785 786 787