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