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 #include <tools/debug.hxx> 30 #include <attrib.hxx> 31 #include <slot.hxx> 32 #include <globals.hxx> 33 #include <database.hxx> 34 35 /****************** SvMetaSlot *****************************************/ 36 SV_IMPL_META_FACTORY1( SvMetaSlot, SvMetaAttribute ); 37 38 SvMetaObject *SvMetaSlot::MakeClone() const 39 { 40 return new SvMetaSlot( *this ); 41 } 42 43 /************************************************************************* 44 |* SvMetaSlot::SvMetaSlot() 45 |* 46 |* Beschreibung Zweites sal_False bei den SvBOOL-Objekten bedeutet, 47 |* IsSet() liefert sal_False (Defaultinitialisierung). 48 *************************************************************************/ 49 SvMetaSlot::SvMetaSlot() 50 : aCachable( sal_True, sal_False ) 51 , aSynchron( sal_True, sal_False ) 52 , aRecordPerSet( sal_True, sal_False ) 53 , aRecordAbsolute( sal_False, sal_False ) 54 , pLinkedSlot(0) 55 , pNextSlot(0) 56 , pEnumValue(0) 57 { 58 } 59 60 SvMetaSlot::SvMetaSlot( SvMetaType * pType ) 61 : SvMetaAttribute( pType ) 62 , aCachable( sal_True, sal_False ) 63 , aSynchron( sal_True, sal_False ) 64 , aRecordPerSet( sal_True, sal_False ) 65 , aRecordAbsolute( sal_False, sal_False ) 66 , pLinkedSlot(0) 67 , pNextSlot(0) 68 , pEnumValue(0) 69 { 70 } 71 72 /* 73 #define TEST_READ \ 74 { \ 75 sal_uInt32 nPos; \ 76 rStm >> nPos; \ 77 DBG_ASSERT( nPos +4 == rStm.Tell(), "stream pos error" ); \ 78 } 79 80 #define TEST_WRITE \ 81 rStm << (sal_uInt32)rStm.Tell(); 82 */ 83 #define TEST_READ 84 #define TEST_WRITE 85 86 void SvMetaSlot::Load( SvPersistStream & rStm ) 87 { 88 SvMetaAttribute::Load( rStm ); 89 90 sal_uInt16 nMask; 91 rStm >> nMask; 92 93 TEST_READ 94 if( nMask & 0x0001 ) 95 { 96 SvMetaAttribute * pMeth; 97 rStm >> pMeth; 98 aMethod = pMeth; 99 } 100 101 TEST_READ 102 if( nMask & 0x0002 ) rStm >> aGroupId; 103 TEST_READ 104 if( nMask & 0x0004 ) rStm >> aHasCoreId; 105 TEST_READ 106 if( nMask & 0x0008 ) rStm >> aConfigId; 107 TEST_READ 108 if( nMask & 0x0010 ) rStm >> aExecMethod; 109 TEST_READ 110 if( nMask & 0x0020 ) rStm >> aStateMethod; 111 TEST_READ 112 if( nMask & 0x0040 ) rStm >> aDefault; 113 TEST_READ 114 if( nMask & 0x0080 ) rStm >> aPseudoSlots; 115 TEST_READ 116 if( nMask & 0x0100 ) rStm >> aGet; 117 TEST_READ 118 if( nMask & 0x0200 ) rStm >> aSet; 119 TEST_READ 120 if( nMask & 0x0400 ) rStm >> aCachable; 121 TEST_READ 122 if( nMask & 0x0800 ) rStm >> aVolatile; 123 TEST_READ 124 if( nMask & 0x1000 ) rStm >> aToggle; 125 TEST_READ 126 if( nMask & 0x2000 ) rStm >> aAutoUpdate; 127 TEST_READ 128 if( nMask & 0x4000 ) rStm >> aSynchron; 129 TEST_READ 130 if( nMask & 0x8000 ) rStm >> aAsynchron; 131 132 nMask = 0; 133 rStm >> nMask; 134 135 TEST_READ 136 if( nMask & 0x0001 ) rStm >> aRecordPerItem; 137 TEST_READ 138 if( nMask & 0x0002 ) rStm >> aRecordManual; 139 TEST_READ 140 if( nMask & 0x0004 ) rStm >> aNoRecord; 141 TEST_READ 142 if( nMask & 0x0008 ) rStm >> aHasDialog; 143 TEST_READ 144 if( nMask & 0x0010 ) rStm >> aDisableFlags; 145 TEST_READ 146 if( nMask & 0x0020 ) rStm >> aPseudoPrefix; 147 TEST_READ 148 if( nMask & 0x0040 ) rStm >> aRecordPerSet; 149 TEST_READ 150 if( nMask & 0x0080 ) rStm >> aMenuConfig; 151 TEST_READ 152 if( nMask & 0x0100 ) rStm >> aToolBoxConfig; 153 TEST_READ 154 if( nMask & 0x0200 ) rStm >> aStatusBarConfig; 155 TEST_READ 156 if( nMask & 0x0400 ) rStm >> aAccelConfig; 157 TEST_READ 158 if( nMask & 0x0800 ) rStm >> aFastCall; 159 TEST_READ 160 if( nMask & 0x1000 ) rStm >> aContainer; 161 TEST_READ 162 163 if( nMask & 0x2000 ) 164 { 165 SvMetaType * pT; 166 rStm >> pT; 167 aSlotType = pT; 168 } 169 170 TEST_READ 171 if( nMask & 0x4000 ) rStm >> aRecordAbsolute; 172 TEST_READ 173 if( nMask & 0x8000 ) rStm >> aImageRotation; 174 175 nMask = 0; 176 rStm >> nMask; 177 178 TEST_READ 179 if( nMask & 0x0001 ) rStm >> aUnoName; 180 if( nMask & 0x0002 ) rStm >> aImageReflection; 181 } 182 183 void SvMetaSlot::Save( SvPersistStream & rStm ) 184 { 185 SvMetaAttribute::Save( rStm ); 186 187 // Maske erstellen 188 sal_uInt16 nMask = 0; 189 if( aMethod.Is() ) nMask |= 0x0001; 190 if( aGroupId.Len() ) nMask |= 0x0002; 191 if( aHasCoreId.IsSet() ) nMask |= 0x0004; 192 if( aConfigId.Len() ) nMask |= 0x0008; 193 if( aExecMethod.Len() ) nMask |= 0x0010; 194 if( aStateMethod.Len() ) nMask |= 0x0020; 195 if( aDefault.Len() ) nMask |= 0x0040; 196 if( aPseudoSlots.IsSet() ) nMask |= 0x0080; 197 if( aGet.IsSet() ) nMask |= 0x0100; 198 if( aSet.IsSet() ) nMask |= 0x0200; 199 if( aCachable.IsSet() ) nMask |= 0x0400; 200 if( aVolatile.IsSet() ) nMask |= 0x0800; 201 if( aToggle.IsSet() ) nMask |= 0x1000; 202 if( aAutoUpdate.IsSet() ) nMask |= 0x2000; 203 if( aSynchron.IsSet() ) nMask |= 0x4000; 204 if( aAsynchron.IsSet() ) nMask |= 0x8000; 205 206 // Daten schreiben 207 rStm << nMask; 208 TEST_WRITE 209 if( nMask & 0x0001 ) rStm << aMethod; 210 TEST_WRITE 211 if( nMask & 0x0002 ) rStm << aGroupId; 212 TEST_WRITE 213 if( nMask & 0x0004 ) rStm << aHasCoreId; 214 TEST_WRITE 215 if( nMask & 0x0008 ) rStm << aConfigId; 216 TEST_WRITE 217 if( nMask & 0x0010 ) rStm << aExecMethod; 218 TEST_WRITE 219 if( nMask & 0x0020 ) rStm << aStateMethod; 220 TEST_WRITE 221 if( nMask & 0x0040 ) rStm << aDefault; 222 TEST_WRITE 223 if( nMask & 0x0080 ) rStm << aPseudoSlots; 224 TEST_WRITE 225 if( nMask & 0x0100 ) rStm << aGet; 226 TEST_WRITE 227 if( nMask & 0x0200 ) rStm << aSet; 228 TEST_WRITE 229 if( nMask & 0x0400 ) rStm << aCachable; 230 TEST_WRITE 231 if( nMask & 0x0800 ) rStm << aVolatile; 232 TEST_WRITE 233 if( nMask & 0x1000 ) rStm << aToggle; 234 TEST_WRITE 235 if( nMask & 0x2000 ) rStm << aAutoUpdate; 236 TEST_WRITE 237 if( nMask & 0x4000 ) rStm << aSynchron; 238 TEST_WRITE 239 if( nMask & 0x8000 ) rStm << aAsynchron; 240 241 // naechste Fuhre schreiben 242 // Maske erstellen 243 nMask = 0; 244 if( aRecordPerItem.IsSet() ) nMask |= 0x0001; 245 if( aRecordManual.IsSet() ) nMask |= 0x0002; 246 if( aNoRecord.IsSet() ) nMask |= 0x0004; 247 if( aHasDialog.IsSet() ) nMask |= 0x0008; 248 if ( aDisableFlags.IsSet() ) nMask |= 0x0010; 249 if( aPseudoPrefix.Len() ) nMask |= 0x0020; 250 if( aRecordPerSet.IsSet() ) nMask |= 0x0040; 251 if( aMenuConfig.IsSet() ) nMask |= 0x0080; 252 if( aToolBoxConfig.IsSet() ) nMask |= 0x0100; 253 if( aStatusBarConfig.IsSet() )nMask |= 0x0200; 254 if( aAccelConfig.IsSet() ) nMask |= 0x0400; 255 if( aFastCall.IsSet() ) nMask |= 0x0800; 256 if( aContainer.IsSet() ) nMask |= 0x1000; 257 if( aSlotType.Is() ) nMask |= 0x2000; 258 if( aRecordAbsolute.IsSet() ) nMask |= 0x4000; 259 if( aImageRotation.IsSet() ) nMask |= 0x8000; 260 261 // Daten schreiben 262 rStm << nMask; 263 TEST_WRITE 264 if( nMask & 0x0001 ) rStm << aRecordPerItem; 265 TEST_WRITE 266 if( nMask & 0x0002 ) rStm << aRecordManual; 267 TEST_WRITE 268 if( nMask & 0x0004 ) rStm << aNoRecord; 269 TEST_WRITE 270 if( nMask & 0x0008 ) rStm << aHasDialog; 271 TEST_WRITE 272 if( nMask & 0x0010 ) rStm << aDisableFlags; 273 TEST_WRITE 274 if( nMask & 0x0020 ) rStm << aPseudoPrefix; 275 TEST_WRITE 276 if( nMask & 0x0040 ) rStm << aRecordPerSet; 277 TEST_WRITE 278 if( nMask & 0x0080 ) rStm << aMenuConfig; 279 TEST_WRITE 280 if( nMask & 0x0100 ) rStm << aToolBoxConfig; 281 TEST_WRITE 282 if( nMask & 0x0200 ) rStm << aStatusBarConfig; 283 TEST_WRITE 284 if( nMask & 0x0400 ) rStm << aAccelConfig; 285 TEST_WRITE 286 if( nMask & 0x0800 ) rStm << aFastCall; 287 TEST_WRITE 288 if( nMask & 0x1000 ) rStm << aContainer; 289 TEST_WRITE 290 if( nMask & 0x2000 ) rStm << aSlotType; 291 TEST_WRITE 292 if( nMask & 0x4000 ) rStm << aRecordAbsolute; 293 TEST_WRITE 294 if( nMask & 0x8000 ) rStm << aImageRotation; 295 296 nMask = 0; 297 if( aUnoName.IsSet() ) nMask |= 0x0001; 298 if( aImageReflection.IsSet() ) nMask |= 0x0002; 299 rStm << nMask; 300 TEST_WRITE 301 if( nMask & 0x0001 ) rStm << aUnoName; 302 TEST_WRITE 303 if( nMask & 0x0002 ) rStm << aImageReflection; 304 } 305 306 /************************************************************************* 307 |* SvMetaSlot::IsVariable() 308 |* 309 |* Beschreibung 310 *************************************************************************/ 311 sal_Bool SvMetaSlot::IsVariable() const 312 { 313 return SvMetaAttribute::IsVariable(); 314 } 315 316 /************************************************************************* 317 |* SvMetaSlot::IsMethod() 318 |* 319 |* Beschreibung 320 *************************************************************************/ 321 sal_Bool SvMetaSlot::IsMethod() const 322 { 323 sal_Bool b = SvMetaAttribute::IsMethod(); 324 b |= NULL != GetMethod(); 325 return b; 326 } 327 328 /************************************************************************* 329 |* SvMetaSlot::HasMethods() 330 |* 331 |* Beschreibung 332 *************************************************************************/ 333 ByteString SvMetaSlot::GetMangleName( sal_Bool bVariable ) const 334 { 335 if( !bVariable ) 336 { 337 SvMetaAttribute * pMeth = GetMethod(); 338 if( pMeth ) 339 return pMeth->GetName(); 340 } 341 return GetName(); 342 } 343 344 /************************************************************************* 345 |* Referenz 346 |* 347 |* Beschreibung Zweites sal_False bei den SvBOOL-Objekten bedeutet, 348 |* IsSet() liefert sal_False (Defaultinitialisierung). 349 *************************************************************************/ 350 /** Referenz Aufloesung **/ 351 SvMetaType * SvMetaSlot::GetSlotType() const 352 { 353 if( aSlotType.Is() || !GetRef() ) return aSlotType; 354 return ((SvMetaSlot *)GetRef())->GetSlotType(); 355 } 356 SvMetaAttribute * SvMetaSlot::GetMethod() const 357 { 358 if( aMethod.Is() || !GetRef() ) return aMethod; 359 return ((SvMetaSlot *)GetRef())->GetMethod(); 360 } 361 sal_Bool SvMetaSlot::GetHasCoreId() const 362 { 363 if( aHasCoreId.IsSet() || !GetRef() ) return aHasCoreId; 364 return ((SvMetaSlot *)GetRef())->GetHasCoreId(); 365 } 366 const ByteString & SvMetaSlot::GetGroupId() const 367 { 368 if( aGroupId.Len() || !GetRef() ) return aGroupId; 369 return ((SvMetaSlot *)GetRef())->GetGroupId(); 370 } 371 const ByteString & SvMetaSlot::GetDisableFlags() const 372 { 373 if( aDisableFlags.Len() || !GetRef() ) return aDisableFlags; 374 return ((SvMetaSlot *)GetRef())->GetDisableFlags(); 375 } 376 const ByteString & SvMetaSlot::GetConfigId() const 377 { 378 if( aConfigId.Len() || !GetRef() ) return aConfigId; 379 return ((SvMetaSlot *)GetRef())->GetConfigId(); 380 } 381 const ByteString & SvMetaSlot::GetExecMethod() const 382 { 383 if( aExecMethod.Len() || !GetRef() ) return aExecMethod; 384 return ((SvMetaSlot *)GetRef())->GetExecMethod(); 385 } 386 const ByteString & SvMetaSlot::GetStateMethod() const 387 { 388 if( aStateMethod.Len() || !GetRef() ) return aStateMethod; 389 return ((SvMetaSlot *)GetRef())->GetStateMethod(); 390 } 391 const ByteString & SvMetaSlot::GetDefault() const 392 { 393 if( aDefault.Len() || !GetRef() ) return aDefault; 394 return ((SvMetaSlot *)GetRef())->GetDefault(); 395 } 396 sal_Bool SvMetaSlot::GetPseudoSlots() const 397 { 398 if( aPseudoSlots.IsSet() || !GetRef() ) return aPseudoSlots; 399 return ((SvMetaSlot *)GetRef())->GetPseudoSlots(); 400 } 401 /* 402 sal_Bool SvMetaSlot::GetGet() const 403 { 404 if( aGet.IsSet() || !GetRef() ) return aGet; 405 return ((SvMetaSlot *)GetRef())->GetGet(); 406 } 407 sal_Bool SvMetaSlot::GetSet() const 408 { 409 if( aSet.IsSet() || !GetRef() ) return aSet; 410 return ((SvMetaSlot *)GetRef())->GetSet(); 411 } 412 */ 413 sal_Bool SvMetaSlot::GetCachable() const 414 { 415 // Cachable und Volatile sind exclusiv 416 if( !GetRef() || aCachable.IsSet() || aVolatile.IsSet() ) 417 return aCachable; 418 return ((SvMetaSlot *)GetRef())->GetCachable(); 419 } 420 sal_Bool SvMetaSlot::GetVolatile() const 421 { 422 // Cachable und Volatile sind exclusiv 423 if( !GetRef() || aVolatile.IsSet() || aCachable.IsSet() ) 424 return aVolatile; 425 return ((SvMetaSlot *)GetRef())->GetVolatile(); 426 } 427 sal_Bool SvMetaSlot::GetToggle() const 428 { 429 if( aToggle.IsSet() || !GetRef() ) return aToggle; 430 return ((SvMetaSlot *)GetRef())->GetToggle(); 431 } 432 sal_Bool SvMetaSlot::GetAutoUpdate() const 433 { 434 if( aAutoUpdate.IsSet() || !GetRef() ) return aAutoUpdate; 435 return ((SvMetaSlot *)GetRef())->GetAutoUpdate(); 436 } 437 sal_Bool SvMetaSlot::GetSynchron() const 438 { 439 // Synchron und Asynchron sind exclusiv 440 if( !GetRef() || aSynchron.IsSet() || aAsynchron.IsSet() ) 441 return aSynchron; 442 return ((SvMetaSlot *)GetRef())->GetSynchron(); 443 } 444 sal_Bool SvMetaSlot::GetAsynchron() const 445 { 446 // Synchron und Asynchron sind exclusiv 447 if( !GetRef() || aAsynchron.IsSet() || aSynchron.IsSet() ) 448 return aAsynchron; 449 return ((SvMetaSlot *)GetRef())->GetAsynchron(); 450 } 451 sal_Bool SvMetaSlot::GetRecordPerItem() const 452 { 453 // Record- PerItem, No, PerSet und Manual sind exclusiv 454 if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet() 455 || aRecordPerSet.IsSet() || aRecordManual.IsSet() ) 456 return aRecordPerItem; 457 return ((SvMetaSlot *)GetRef())->GetRecordPerItem(); 458 } 459 sal_Bool SvMetaSlot::GetRecordPerSet() const 460 { 461 // Record- PerItem, No, PerSet und Manual sind exclusiv 462 if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet() 463 || aRecordPerSet.IsSet() || aRecordManual.IsSet() ) 464 return aRecordPerSet; 465 return ((SvMetaSlot *)GetRef())->GetRecordPerSet(); 466 } 467 sal_Bool SvMetaSlot::GetRecordManual() const 468 { 469 // Record- PerItem, No, PerSet und Manual sind exclusiv 470 if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet() 471 || aRecordPerSet.IsSet() || aRecordManual.IsSet() ) 472 return aRecordManual; 473 return ((SvMetaSlot *)GetRef())->GetRecordManual(); 474 } 475 sal_Bool SvMetaSlot::GetNoRecord() const 476 { 477 // Record- PerItem, No, PerSet und Manual sind exclusiv 478 if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet() 479 || aRecordPerSet.IsSet() || aRecordManual.IsSet() ) 480 return aNoRecord; 481 return ((SvMetaSlot *)GetRef())->GetNoRecord(); 482 } 483 sal_Bool SvMetaSlot::GetRecordAbsolute() const 484 { 485 if( !GetRef() || aRecordAbsolute.IsSet() ) 486 return aRecordAbsolute; 487 return ((SvMetaSlot *)GetRef())->GetRecordAbsolute(); 488 } 489 sal_Bool SvMetaSlot::GetHasDialog() const 490 { 491 if( aHasDialog.IsSet() || !GetRef() ) return aHasDialog; 492 return ((SvMetaSlot *)GetRef())->GetHasDialog(); 493 } 494 const ByteString & SvMetaSlot::GetPseudoPrefix() const 495 { 496 if( aPseudoPrefix.Len() || !GetRef() ) return aPseudoPrefix; 497 return ((SvMetaSlot *)GetRef())->GetPseudoPrefix(); 498 } 499 sal_Bool SvMetaSlot::GetMenuConfig() const 500 { 501 if( aMenuConfig.IsSet() || !GetRef() ) return aMenuConfig; 502 return ((SvMetaSlot *)GetRef())->GetMenuConfig(); 503 } 504 sal_Bool SvMetaSlot::GetToolBoxConfig() const 505 { 506 if( aToolBoxConfig.IsSet() || !GetRef() ) return aToolBoxConfig; 507 return ((SvMetaSlot *)GetRef())->GetToolBoxConfig(); 508 } 509 sal_Bool SvMetaSlot::GetStatusBarConfig() const 510 { 511 if( aStatusBarConfig.IsSet() || !GetRef() ) return aStatusBarConfig; 512 return ((SvMetaSlot *)GetRef())->GetStatusBarConfig(); 513 } 514 sal_Bool SvMetaSlot::GetAccelConfig() const 515 { 516 if( aAccelConfig.IsSet() || !GetRef() ) return aAccelConfig; 517 return ((SvMetaSlot *)GetRef())->GetAccelConfig(); 518 } 519 sal_Bool SvMetaSlot::GetFastCall() const 520 { 521 if( aFastCall.IsSet() || !GetRef() ) return aFastCall; 522 return ((SvMetaSlot *)GetRef())->GetFastCall(); 523 } 524 sal_Bool SvMetaSlot::GetContainer() const 525 { 526 if( aContainer.IsSet() || !GetRef() ) return aContainer; 527 return ((SvMetaSlot *)GetRef())->GetContainer(); 528 } 529 530 sal_Bool SvMetaSlot::GetImageRotation() const 531 { 532 if( aImageRotation.IsSet() || !GetRef() ) return aImageRotation; 533 return ((SvMetaSlot *)GetRef())->GetImageRotation(); 534 } 535 536 sal_Bool SvMetaSlot::GetImageReflection() const 537 { 538 if( aImageReflection.IsSet() || !GetRef() ) return aImageReflection; 539 return ((SvMetaSlot *)GetRef())->GetImageReflection(); 540 } 541 542 const ByteString& SvMetaSlot::GetUnoName() const 543 { 544 if( aUnoName.IsSet() || !GetRef() ) return aUnoName; 545 return ((SvMetaSlot *)GetRef())->GetUnoName(); 546 } 547 548 /************************************************************************* 549 |* SvMetaSlot::FillSbxObject() 550 |* 551 |* Beschreibung 552 *************************************************************************/ 553 /* 554 void SvMetaSlot::FillSbxObject( SvIdlDataBase & rBase, SbxObject * pObj, 555 sal_Bool bVariable ) 556 { 557 // keine Attribut fuer Automation 558 if( !GetAutomation() || !GetExport() ) 559 return; 560 561 if( !bVariable ) 562 { 563 SvMetaAttributeRef xM = GetMethod(); 564 if( xM.Is() ) 565 { 566 SvMetaType * pType = xM->GetType(); 567 SvMetaType * pRetBaseType = pType->GetReturnType()->GetBaseType(); 568 ByteString aName = xM->GetName(); 569 570 SbxMethodRef xMeth = new SbxMethod( aName, 571 pRetBaseType->GetSbxDataType() ); 572 pType->FillSbxObject( xMeth, bVariable ); 573 xMeth->SetUserData( MakeSlotValue(rBase, sal_False) ); 574 575 pObj->Insert( &xMeth ); 576 return; 577 } 578 } 579 580 SvMetaAttribute::FillSbxObject( rBase, pObj, bVariable ); 581 } 582 */ 583 584 #ifdef IDL_COMPILER 585 /************************************************************************* 586 |* SvMetaSlot::ReadAttributesSvIdl() 587 |* 588 |* Beschreibung 589 *************************************************************************/ 590 void SvMetaSlot::ReadAttributesSvIdl( SvIdlDataBase & rBase, 591 SvTokenStream & rInStm ) 592 { 593 SvMetaAttribute::ReadAttributesSvIdl( rBase, rInStm ); 594 595 sal_Bool bOk = sal_False; 596 bOk |= aDefault.ReadSvIdl( SvHash_Default(), rInStm ); 597 bOk |= aPseudoSlots.ReadSvIdl( SvHash_PseudoSlots(), rInStm ); 598 bOk |= aHasCoreId.ReadSvIdl( SvHash_HasCoreId(), rInStm ); 599 bOk |= aGroupId.ReadSvIdl( SvHash_GroupId(), rInStm ); 600 bOk |= aExecMethod.ReadSvIdl( SvHash_ExecMethod(), rInStm ); 601 bOk |= aStateMethod.ReadSvIdl( SvHash_StateMethod(), rInStm ); 602 bOk |= aDisableFlags.ReadSvIdl( SvHash_DisableFlags(), rInStm ); 603 if( aGet.ReadSvIdl( SvHash_Get(), rInStm ) ) 604 { 605 rBase.WriteError( "warning", ByteString( rInStm.GetFileName(), RTL_TEXTENCODING_UTF8 ), 606 "<Get> old style, use Readonly", 607 rInStm.GetToken()->GetLine(), 608 rInStm.GetToken()->GetColumn() ); 609 } 610 if( aSet.ReadSvIdl( SvHash_Set(), rInStm ) ) 611 { 612 rBase.WriteError( "warning", ByteString( rInStm.GetFileName(), RTL_TEXTENCODING_UTF8 ), 613 "<Set> old style, use method declaration", 614 rInStm.GetToken()->GetLine(), 615 rInStm.GetToken()->GetColumn() ); 616 } 617 618 if( aCachable.ReadSvIdl( SvHash_Cachable(), rInStm ) ) 619 SetCachable( aCachable ), bOk = sal_True; 620 if( aVolatile.ReadSvIdl( SvHash_Volatile(), rInStm ) ) 621 SetVolatile( aVolatile ), bOk = sal_True; 622 if( aToggle.ReadSvIdl( SvHash_Toggle(), rInStm ) ) 623 SetToggle( aToggle ), bOk = sal_True; 624 if( aAutoUpdate.ReadSvIdl( SvHash_AutoUpdate(), rInStm ) ) 625 SetAutoUpdate( aAutoUpdate ), bOk = sal_True; 626 627 if( aSynchron.ReadSvIdl( SvHash_Synchron(), rInStm ) ) 628 SetSynchron( aSynchron ), bOk = sal_True; 629 if( aAsynchron.ReadSvIdl( SvHash_Asynchron(), rInStm ) ) 630 SetAsynchron( aAsynchron ), bOk = sal_True; 631 632 if( aRecordAbsolute.ReadSvIdl( SvHash_RecordAbsolute(), rInStm ) ) 633 SetRecordAbsolute( aRecordAbsolute), bOk = sal_True; 634 if( aRecordPerItem.ReadSvIdl( SvHash_RecordPerItem(), rInStm ) ) 635 SetRecordPerItem( aRecordPerItem ), bOk = sal_True; 636 if( aRecordPerSet.ReadSvIdl( SvHash_RecordPerSet(), rInStm ) ) 637 SetRecordPerSet( aRecordPerSet ), bOk = sal_True; 638 if( aRecordManual.ReadSvIdl( SvHash_RecordManual(), rInStm ) ) 639 SetRecordManual( aRecordManual ), bOk = sal_True; 640 if( aNoRecord.ReadSvIdl( SvHash_NoRecord(), rInStm ) ) 641 SetNoRecord( aNoRecord ), bOk = sal_True; 642 643 bOk |= aHasDialog.ReadSvIdl( SvHash_HasDialog(), rInStm ); 644 bOk |= aPseudoPrefix.ReadSvIdl( SvHash_PseudoPrefix(), rInStm ); 645 bOk |= aMenuConfig.ReadSvIdl( SvHash_MenuConfig(), rInStm ); 646 bOk |= aToolBoxConfig.ReadSvIdl( SvHash_ToolBoxConfig(), rInStm ); 647 bOk |= aStatusBarConfig.ReadSvIdl( SvHash_StatusBarConfig(), rInStm ); 648 bOk |= aAccelConfig.ReadSvIdl( SvHash_AccelConfig(), rInStm ); 649 650 SvBOOL aAllConfig; 651 if( aAllConfig.ReadSvIdl( SvHash_AllConfig(), rInStm ) ) 652 SetAllConfig( aAllConfig ), bOk = sal_True; 653 bOk |= aFastCall.ReadSvIdl( SvHash_FastCall(), rInStm ); 654 bOk |= aContainer.ReadSvIdl( SvHash_Container(), rInStm ); 655 bOk |= aImageRotation.ReadSvIdl( SvHash_ImageRotation(), rInStm ); 656 bOk |= aImageReflection.ReadSvIdl( SvHash_ImageReflection(), rInStm ); 657 bOk |= aUnoName.ReadSvIdl( SvHash_UnoName(), rInStm ); 658 659 if( !bOk ) 660 { 661 if( !aSlotType.Is() ) 662 { 663 sal_uInt32 nTokPos = rInStm.Tell(); 664 SvToken * pTok = rInStm.GetToken_Next(); 665 if( pTok->Is( SvHash_SlotType() ) ) 666 { 667 sal_Bool bBraket = rInStm.Read( '(' ); 668 if( bBraket || rInStm.Read( '=' ) ) 669 { 670 aSlotType = rBase.ReadKnownType( rInStm ); 671 if( aSlotType.Is() ) 672 { 673 if( aSlotType->IsItem() ) 674 { 675 if( bBraket ) 676 { 677 if( rInStm.Read( ')' ) ) 678 return; 679 } 680 else 681 return; 682 } 683 rBase.SetError( "the SlotType is not a item", rInStm.GetToken() ); 684 rBase.WriteError( rInStm ); 685 } 686 rBase.SetError( "SlotType with unknown item type", rInStm.GetToken() ); 687 rBase.WriteError( rInStm ); 688 } 689 } 690 rInStm.Seek( nTokPos ); 691 692 } 693 if( !aMethod.Is() ) 694 { 695 SvToken * pTok = rInStm.GetToken(); 696 if( pTok->IsIdentifier() ) 697 { 698 aMethod = new SvMetaSlot(); 699 sal_uInt32 nTokPos = rInStm.Tell(); 700 if( aMethod->ReadSvIdl( rBase, rInStm ) ) 701 { 702 if( aMethod->IsMethod() ) 703 { 704 aMethod->SetSlotId( GetSlotId() ); 705 if( aMethod->Test( rBase, rInStm ) ) 706 return; 707 } 708 rInStm.Seek( nTokPos ); 709 } 710 aMethod.Clear(); 711 } 712 } 713 } 714 } 715 716 /************************************************************************* 717 |* SvMetaSlot::WriteAttributesSvIdl() 718 |* 719 |* Beschreibung 720 *************************************************************************/ 721 void SvMetaSlot::WriteAttributesSvIdl( SvIdlDataBase & rBase, 722 SvStream & rOutStm, 723 sal_uInt16 nTab ) 724 { 725 SvMetaAttribute::WriteAttributesSvIdl( rBase, rOutStm, nTab ); 726 727 if( aSlotType.Is() ) 728 { 729 WriteTab( rOutStm, nTab ); 730 rOutStm << SvHash_SlotType()->GetName().GetBuffer() << '('; 731 aSlotType->WriteTheType( rBase, rOutStm, nTab, WRITE_IDL ); 732 rOutStm << ");" << endl; 733 } 734 if( aMethod.Is() ) 735 { 736 WriteTab( rOutStm, nTab ); 737 aMethod->WriteSvIdl( rBase, rOutStm, nTab ); 738 rOutStm << ';' << endl; 739 } 740 if( aHasCoreId ) 741 { 742 aHasCoreId.WriteSvIdl( SvHash_HasCoreId(), rOutStm ); 743 rOutStm << ';' << endl; 744 } 745 if( aGroupId.Len() ) 746 { 747 WriteTab( rOutStm, nTab ); 748 aGroupId.WriteSvIdl( SvHash_GroupId(), rOutStm, nTab +1); 749 rOutStm << ';' << endl; 750 } 751 if( aExecMethod.Len() ) 752 { 753 WriteTab( rOutStm, nTab ); 754 aExecMethod.WriteSvIdl( SvHash_ExecMethod(), rOutStm, nTab +1); 755 rOutStm << ';' << endl; 756 } 757 if( aStateMethod.Len() ) 758 { 759 WriteTab( rOutStm, nTab ); 760 aStateMethod.WriteSvIdl( SvHash_StateMethod(), rOutStm, nTab +1); 761 rOutStm << ';' << endl; 762 } 763 764 if( aDisableFlags.Len() ) 765 { 766 WriteTab( rOutStm, nTab ); 767 aDisableFlags.WriteSvIdl( SvHash_DisableFlags(), rOutStm, nTab +1); 768 rOutStm << ';' << endl; 769 } 770 771 if( aSet || aGet || aPseudoSlots ) 772 { 773 WriteTab( rOutStm, nTab ); 774 char const * p = ""; 775 if( aPseudoSlots ) 776 { 777 aPseudoSlots.WriteSvIdl( SvHash_PseudoSlots(), rOutStm ); 778 p = ", "; 779 } 780 if( aGet ) 781 { 782 rOutStm << p; 783 aGet.WriteSvIdl( SvHash_Get(), rOutStm ); 784 p = ", "; 785 } 786 if( aSet ) 787 { 788 rOutStm << p; 789 aSet.WriteSvIdl( SvHash_Set(), rOutStm ); 790 } 791 rOutStm << ';' << endl; 792 } 793 794 ByteString aDel( ", " ); 795 ByteString aOut; 796 if( aVolatile ) 797 aOut += aVolatile.GetSvIdlString( SvHash_Volatile() ); 798 else if( !aCachable ) 799 // wegen Default == sal_True, nur wenn kein anderer gesetzt 800 aOut += aCachable.GetSvIdlString( SvHash_Cachable() ); 801 else 802 aDel.Erase(); 803 804 if( aToggle ) 805 { 806 ( aOut += aDel ) += aToggle.GetSvIdlString( SvHash_Toggle() ); 807 aDel = ", "; 808 } 809 if( aAutoUpdate ) 810 { 811 (aOut += aDel ) += aAutoUpdate.GetSvIdlString( SvHash_AutoUpdate() ); 812 aDel = ", "; 813 } 814 815 ByteString aDel1( ", " ); 816 if( aAsynchron ) 817 ( aOut += aDel ) += aAsynchron.GetSvIdlString( SvHash_Asynchron() ); 818 else if( !aSynchron ) 819 // wegen Default == sal_True, nur wenn kein anderer gesetzt 820 ( aOut += aDel ) += aSynchron.GetSvIdlString( SvHash_Synchron() ); 821 else 822 aDel1 = aDel; 823 824 aDel = ", "; 825 if( aRecordManual ) 826 ( aOut += aDel1 ) += aRecordManual.GetSvIdlString( SvHash_RecordManual() ); 827 else if( aNoRecord ) 828 ( aOut += aDel1 ) += aNoRecord.GetSvIdlString( SvHash_NoRecord() ); 829 else if( !aRecordPerSet ) 830 // wegen Default == sal_True, nur wenn kein anderer gesetzt 831 ( aOut += aDel1 ) += aRecordPerSet.GetSvIdlString( SvHash_RecordPerSet() ); 832 else if( aRecordPerItem ) 833 ( aOut += aDel1 ) += aRecordPerItem.GetSvIdlString( SvHash_RecordPerItem() ); 834 else 835 aDel = aDel1; 836 837 if( aRecordAbsolute ) 838 { 839 ( aOut += aDel ) += aRecordAbsolute.GetSvIdlString( SvHash_RecordAbsolute() ); 840 aDel = ", "; 841 } 842 if( aHasDialog ) 843 { 844 ( aOut += aDel ) += aHasDialog.GetSvIdlString( SvHash_HasDialog() ); 845 aDel = ", "; 846 } 847 if( aMenuConfig ) 848 { 849 ( aOut += aDel ) += aMenuConfig.GetSvIdlString( SvHash_MenuConfig() ); 850 aDel = ", "; 851 } 852 if( aToolBoxConfig ) 853 { 854 ( aOut += aDel ) += aToolBoxConfig.GetSvIdlString( SvHash_ToolBoxConfig() ); 855 aDel = ", "; 856 } 857 if( aStatusBarConfig ) 858 { 859 ( aOut += aDel ) += aStatusBarConfig.GetSvIdlString( SvHash_StatusBarConfig() ); 860 aDel = ", "; 861 } 862 if( aAccelConfig ) 863 { 864 ( aOut += aDel ) += aAccelConfig.GetSvIdlString( SvHash_AccelConfig() ); 865 aDel = ", "; 866 } 867 if( aFastCall ) 868 { 869 ( aOut += aDel ) += aFastCall.GetSvIdlString( SvHash_FastCall() ); 870 aDel = ", "; 871 } 872 if( aContainer ) 873 { 874 ( aOut += aDel ) += aContainer.GetSvIdlString( SvHash_Container() ); 875 aDel = ", "; 876 } 877 if( aImageRotation ) 878 { 879 ( aOut += aDel ) += aImageRotation.GetSvIdlString( SvHash_ImageRotation() ); 880 aDel = ", "; 881 } 882 883 if( aImageReflection ) 884 { 885 ( aOut += aDel ) += aImageReflection.GetSvIdlString( SvHash_ImageReflection() ); 886 aDel = ", "; 887 } 888 889 if( aOut.Len() ) 890 { 891 WriteTab( rOutStm, nTab ); 892 rOutStm << aOut.GetBuffer() << endl; 893 } 894 } 895 896 897 /************************************************************************* 898 |* SvMetaSlot::Test() 899 |* 900 |* Beschreibung 901 *************************************************************************/ 902 sal_Bool SvMetaSlot::Test( SvIdlDataBase & rBase, SvTokenStream & rInStm ) 903 { 904 sal_Bool bOk = SvMetaAttribute::Test( rBase, rInStm ); 905 if( bOk ) 906 { 907 SvMetaType * pType = GetType(); 908 if( pType->GetType() == TYPE_METHOD ) 909 pType = pType->GetReturnType(); 910 if( !pType->IsItem() ) 911 { 912 rBase.SetError( "this attribute is not a slot", rInStm.GetToken() ); 913 rBase.WriteError( rInStm ); 914 bOk = sal_False; 915 } 916 } 917 918 return bOk; 919 } 920 921 /************************************************************************* 922 |* SvMetaSlot::ReadSvIdl() 923 |* 924 |* Beschreibung 925 *************************************************************************/ 926 sal_Bool SvMetaSlot::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm ) 927 { 928 sal_uInt32 nTokPos = rInStm.Tell(); 929 sal_Bool bOk = sal_True; 930 931 SvMetaAttribute * pAttr = rBase.ReadKnownAttr( rInStm, GetType() ); 932 if( pAttr ) 933 { 934 // F"ur Testzwecke: Referenz bei Kurz-Syntax 935 SvMetaSlot * pKnownSlot = PTR_CAST( SvMetaSlot, pAttr ); 936 if( pKnownSlot ) 937 { 938 SetRef( pKnownSlot ); 939 SetName( pKnownSlot->GetName(), &rBase ); 940 bOk = SvMetaName::ReadSvIdl( rBase, rInStm ); 941 } 942 else 943 { 944 ByteString aStr( "attribute " ); 945 aStr += pAttr->GetName(); 946 aStr += " is method or variable but not a slot"; 947 rBase.SetError( aStr, rInStm.GetToken() ); 948 rBase.WriteError( rInStm ); 949 bOk = sal_False; 950 } 951 } 952 else 953 { 954 bOk = SvMetaAttribute::ReadSvIdl( rBase, rInStm ); 955 956 SvMetaAttribute *pAttr2 = rBase.SearchKnownAttr( GetSlotId() ); 957 if( pAttr2 ) 958 { 959 // F"ur Testzwecke: Referenz bei kompletter Definition 960 SvMetaSlot * pKnownSlot = PTR_CAST( SvMetaSlot, pAttr2 ); 961 if( pKnownSlot ) 962 { 963 SetRef( pKnownSlot ); 964 965 // Namen d"urfen abweichen, da mit angegeben 966 if ( pKnownSlot->GetName() != GetName() ) 967 { 968 DBG_ERROR("Illegal definition!"); 969 rInStm.Seek( nTokPos ); 970 return sal_False; 971 } 972 973 SetName( pKnownSlot->GetName(), &rBase ); 974 } 975 else 976 { 977 ByteString aStr( "attribute " ); 978 aStr += pAttr2->GetName(); 979 aStr += " is method or variable but not a slot"; 980 rBase.SetError( aStr, rInStm.GetToken() ); 981 rBase.WriteError( rInStm ); 982 bOk = sal_False; 983 } 984 } 985 } 986 987 if( !bOk ) 988 rInStm.Seek( nTokPos ); 989 990 return bOk; 991 } 992 993 /************************************************************************* 994 |* SvMetaSlot::WriteSvIdl() 995 |* 996 |* Beschreibung 997 *************************************************************************/ 998 void SvMetaSlot::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm, 999 sal_uInt16 nTab ) 1000 { 1001 SvMetaAttribute::WriteSvIdl( rBase, rOutStm, nTab ); 1002 } 1003 1004 /************************************************************************* 1005 |* SvMetaSlot::Write() 1006 |* 1007 |* Beschreibung 1008 *************************************************************************/ 1009 void SvMetaSlot::Write( SvIdlDataBase & rBase, 1010 SvStream & rOutStm, sal_uInt16 nTab, 1011 WriteType nT, WriteAttribute nA ) 1012 { 1013 if ( nT == WRITE_DOCU ) 1014 { 1015 if ( GetHidden() ) 1016 return; 1017 } 1018 else 1019 { 1020 // keine Attribut fuer Automation 1021 if( !GetAutomation() || !GetExport() ) 1022 return; 1023 } 1024 1025 if( !(nA & WA_VARIABLE) ) 1026 { 1027 SvMetaAttributeRef xM = GetMethod(); 1028 if( xM.Is() ) 1029 { 1030 xM->SetSlotId( GetSlotId() ); 1031 xM->SetDescription( GetDescription() ); 1032 xM->Write( rBase, rOutStm, nTab, nT, nA ); 1033 return; 1034 } 1035 } 1036 1037 SvMetaAttribute::Write( rBase, rOutStm, nTab, nT, nA ); 1038 } 1039 1040 1041 void SvMetaSlot::Insert( SvSlotElementList& rList, const ByteString & rPrefix, 1042 SvIdlDataBase& rBase) 1043 { 1044 // Einf"ugeposition durch bin"are Suche in der SlotListe ermitteln 1045 sal_uInt16 nId = (sal_uInt16) GetSlotId().GetValue(); 1046 sal_uInt16 nListCount = (sal_uInt16) rList.Count(); 1047 sal_uInt16 nPos; 1048 sal_uLong m; // for inner "for" loop 1049 1050 if ( !nListCount ) 1051 nPos = 0; 1052 else if ( nListCount == 1 ) 1053 nPos = rList.GetObject(0)->xSlot->GetSlotId().GetValue() >= nId ? 0 : 1; 1054 else 1055 { 1056 sal_uInt16 nMid = 0, nLow = 0; 1057 sal_uInt16 nHigh = nListCount - 1; 1058 sal_Bool bFound = sal_False; 1059 while ( !bFound && nLow <= nHigh ) 1060 { 1061 nMid = (nLow + nHigh) >> 1; 1062 DBG_ASSERT( nMid < nListCount, "bsearch ist buggy" ); 1063 int nDiff = (int) nId - (int) rList.GetObject(nMid)->xSlot->GetSlotId().GetValue(); 1064 if ( nDiff < 0) 1065 { 1066 if ( nMid == 0 ) 1067 break; 1068 nHigh = nMid - 1; 1069 } 1070 else if ( nDiff > 0 ) 1071 { 1072 nLow = nMid + 1; 1073 if ( nLow == 0 ) 1074 break; 1075 } 1076 else 1077 bFound = sal_True; 1078 } 1079 1080 DBG_ASSERT(!bFound, "Duplicate SlotId!"); 1081 nPos = bFound ? nMid : nLow; 1082 } 1083 1084 DBG_ASSERT( nPos <= nListCount, 1085 "nPos too large" ); 1086 DBG_ASSERT( nPos == nListCount || nId <= 1087 (sal_uInt16) rList.GetObject(nPos)->xSlot->GetSlotId().GetValue(), 1088 "Successor has lower SlotId" ); 1089 DBG_ASSERT( nPos == 0 || nId > 1090 (sal_uInt16) rList.GetObject(nPos-1)->xSlot->GetSlotId().GetValue(), 1091 "Predecessor has higher SlotId" ); 1092 DBG_ASSERT( nPos+1 >= nListCount || nId < 1093 (sal_uInt16) rList.GetObject(nPos+1)->xSlot->GetSlotId().GetValue(), 1094 "Successor has lower SlotId" ); 1095 1096 rList.Insert( new SvSlotElement( this, rPrefix ), nPos ); 1097 1098 // EnumSlots plattklopfen 1099 SvMetaTypeEnum * pEnum = NULL; 1100 SvMetaType * pBType = GetType()->GetBaseType(); 1101 pEnum = PTR_CAST( SvMetaTypeEnum, pBType ); 1102 if( GetPseudoSlots() && pEnum && pEnum->Count() ) 1103 { 1104 // Den MasterSlot clonen 1105 SvMetaSlotRef xEnumSlot; 1106 SvMetaSlot *pFirstEnumSlot = NULL; 1107 for( sal_uLong n = 0; n < pEnum->Count(); n++ ) 1108 { 1109 // Die SlotId erzeugen 1110 SvMetaEnumValue *enumValue = pEnum->GetObject(n); 1111 ByteString aValName = enumValue->GetName(); 1112 ByteString aSId( GetSlotId() ); 1113 if( GetPseudoPrefix().Len() ) 1114 aSId = GetPseudoPrefix(); 1115 aSId += '_'; 1116 aSId += aValName.Copy( pEnum->GetPrefix().Len() ); 1117 1118 xEnumSlot = NULL; 1119 for( m=0; m<rBase.GetAttrList().Count(); m++ ) 1120 { 1121 SvMetaAttribute * pAttr = rBase.GetAttrList().GetObject( m ); 1122 if( pAttr->GetSlotId() == aSId ) 1123 { 1124 SvMetaSlot* pSlot = PTR_CAST( SvMetaSlot, pAttr ); 1125 xEnumSlot = pSlot->Clone(); 1126 break; 1127 } 1128 } 1129 1130 if ( m == rBase.GetAttrList().Count() ) 1131 { 1132 DBG_ERROR("Invalid EnumSlot!"); 1133 xEnumSlot = Clone(); 1134 sal_uLong nValue; 1135 if ( rBase.FindId(aSId , &nValue) ) 1136 { 1137 SvNumberIdentifier aId; 1138 *((SvIdentifier*)&aId) = aSId; 1139 aId.SetValue(nValue); 1140 xEnumSlot->SetSlotId(aId); 1141 } 1142 } 1143 1144 // Die Slaves sind kein Master ! 1145 xEnumSlot->aPseudoSlots = sal_False; 1146 xEnumSlot->SetEnumValue(enumValue); 1147 1148 if ( !pFirstEnumSlot || xEnumSlot->GetSlotId().GetValue() < pFirstEnumSlot->GetSlotId().GetValue() ) 1149 pFirstEnumSlot = xEnumSlot; 1150 1151 // Den erzeugten Slave ebenfalls einf"ugen 1152 xEnumSlot->Insert( rList, rPrefix, rBase); 1153 1154 // Die EnumSlots mit dem Master verketten 1155 xEnumSlot->pLinkedSlot = this; 1156 } 1157 1158 // Master zeigt auf den ersten Slave 1159 pLinkedSlot = pFirstEnumSlot; 1160 1161 // Slaves untereinander verketten 1162 rList.Seek((sal_uLong)0); 1163 xEnumSlot = pFirstEnumSlot; 1164 SvSlotElement *pEle; 1165 do 1166 { 1167 pEle = rList.Next(); 1168 if ( pEle && pEle->xSlot->pLinkedSlot == this ) 1169 { 1170 xEnumSlot->pNextSlot = pEle->xSlot; 1171 xEnumSlot = pEle->xSlot; 1172 } 1173 } 1174 while ( pEle ); 1175 xEnumSlot->pNextSlot = pFirstEnumSlot; 1176 } 1177 } 1178 1179 1180 /************************************************************************* 1181 |* SvMetaSlot::WriteSlotMap() 1182 |* 1183 |* Beschreibung 1184 *************************************************************************/ 1185 static ByteString MakeSlotName( SvStringHashEntry * pEntry ) 1186 { 1187 ByteString aName( "SFX_SLOT_" ); 1188 aName += pEntry->GetName(); 1189 return aName.ToUpperAscii(); 1190 }; 1191 1192 void SvMetaSlot::WriteSlotStubs( const ByteString & rShellName, 1193 ByteStringList & rList, 1194 SvStream & rOutStm ) 1195 { 1196 /* 1197 ByteString aName = GetName(); 1198 SvMetaAttribute * pAttr = rAttrList.First(); 1199 while( pAttr ) 1200 { 1201 if( pAttr->GetName() == aName ) 1202 break; 1203 pAttr = rAttrList.Next(); 1204 } 1205 if( pAttr ) 1206 return; 1207 */ 1208 if ( !GetExport() && !GetHidden() ) 1209 return; 1210 1211 ByteString aMethodName( GetExecMethod() ); 1212 if ( aMethodName.Len() && aMethodName != "NoExec" ) 1213 { 1214 sal_Bool bIn = sal_False; 1215 for( sal_uInt16 n = 0; n < rList.Count(); n++ ) 1216 { 1217 if( *(rList.GetObject(n)) == aMethodName ) 1218 { 1219 bIn=sal_True; 1220 break; 1221 } 1222 } 1223 1224 if ( !bIn ) 1225 { 1226 rList.Insert( new ByteString(aMethodName), LIST_APPEND ); 1227 rOutStm << "SFX_EXEC_STUB(" 1228 << rShellName.GetBuffer() 1229 << ',' 1230 << aMethodName.GetBuffer() 1231 << ')' << endl; 1232 } 1233 } 1234 1235 aMethodName = GetStateMethod(); 1236 if ( aMethodName.Len() && aMethodName != "NoState" ) 1237 { 1238 sal_Bool bIn = sal_False; 1239 for ( sal_uInt16 n=0; n < rList.Count(); n++ ) 1240 { 1241 if ( *(rList.GetObject(n)) == aMethodName ) 1242 { 1243 bIn=sal_True; 1244 break; 1245 } 1246 } 1247 1248 if ( !bIn ) 1249 { 1250 rList.Insert( new ByteString(aMethodName), LIST_APPEND ); 1251 rOutStm << "SFX_STATE_STUB(" 1252 << rShellName.GetBuffer() 1253 << ',' 1254 << aMethodName.GetBuffer() 1255 << ')' << endl; 1256 } 1257 } 1258 } 1259 1260 void SvMetaSlot::WriteSlot( const ByteString & rShellName, sal_uInt16 nCount, 1261 const ByteString & rSlotId, 1262 SvSlotElementList& rSlotList, 1263 const ByteString & rPrefix, 1264 SvIdlDataBase & rBase, SvStream & rOutStm ) 1265 { 1266 if ( !GetExport() && !GetHidden() ) 1267 return; 1268 1269 // sal_Bool bIsEnumSlot = 0 != rValueName.Len(); 1270 sal_Bool bIsEnumSlot = 0 != pEnumValue; 1271 1272 rOutStm << "// Slot Nr. " << ByteString::CreateFromInt32(nListPos).GetBuffer() << " : "; 1273 ByteString aSlotIdValue( ByteString::CreateFromInt32( GetSlotId().GetValue() ) ); 1274 rOutStm << aSlotIdValue.GetBuffer() << endl; 1275 WriteTab( rOutStm, 1 ); 1276 if( bIsEnumSlot ) 1277 rOutStm << "SFX_NEW_SLOT_ENUM( "; 1278 else 1279 rOutStm << "SFX_NEW_SLOT_ARG( " << rShellName.GetBuffer() << ',' ; 1280 1281 rOutStm << rSlotId.GetBuffer() << ','; 1282 const SvHelpContext& rHlpCtx = GetHelpContext(); 1283 if( rHlpCtx.IsSet() ) 1284 rOutStm << rHlpCtx.GetBuffer() << ','; 1285 else 1286 rOutStm << rSlotId.GetBuffer() << ','; 1287 1288 // GroupId 1289 if( GetGroupId().Len() ) 1290 rOutStm << GetGroupId().GetBuffer(); 1291 else 1292 rOutStm << '0'; 1293 rOutStm << ',' << endl; 1294 WriteTab( rOutStm, 4 ); 1295 1296 if( bIsEnumSlot ) 1297 { 1298 rOutStm << "&a" << rShellName.GetBuffer() << "Slots_Impl[" 1299 << ByteString::CreateFromInt32(pLinkedSlot->GetListPos()).GetBuffer() 1300 << "] /*Offset Master*/, " << endl; 1301 WriteTab( rOutStm, 4 ); 1302 rOutStm << "&a" << rShellName.GetBuffer() << "Slots_Impl[" 1303 << ByteString::CreateFromInt32(pNextSlot->GetListPos()).GetBuffer() 1304 << "] /*Offset Next*/, " << endl; 1305 1306 WriteTab( rOutStm, 4 ); 1307 1308 // SlotId 1309 if( GetSlotId().Len() ) 1310 rOutStm << pLinkedSlot->GetSlotId().GetBuffer(); 1311 else 1312 rOutStm << '0'; 1313 rOutStm << ','; 1314 rOutStm << pEnumValue->GetName().GetBuffer(); 1315 } 1316 else 1317 { 1318 // Den n"achsten Slot suchen, der die gleiche StateMethod hat wie ich 1319 // Die SlotList ist auf den aktuellen Slot geseekt 1320 SvSlotElement * pEle = rSlotList.Next(); 1321 pNextSlot = pEle ? &pEle->xSlot : NULL; 1322 while ( pNextSlot ) 1323 { 1324 if ( !pNextSlot->pNextSlot && 1325 pNextSlot->GetStateMethod() == GetStateMethod() ) 1326 break; 1327 pEle = rSlotList.Next(); 1328 pNextSlot = pEle ? &pEle->xSlot : NULL; 1329 } 1330 1331 if ( !pNextSlot ) 1332 { 1333 // Es gibt nach mir keinen Slot mehr, der die gleiche ExecMethode 1334 // hat. Also suche ich den ersten Slot, der diese hatte (das 1335 // k"onnte auch ich selbst sein) 1336 pEle = rSlotList.First(); 1337 pNextSlot = pEle ? &pEle->xSlot : NULL; 1338 while ( pNextSlot != this ) 1339 { 1340 if ( !pNextSlot->pEnumValue && 1341 pNextSlot->GetStateMethod() == GetStateMethod() ) 1342 break; 1343 pEle = rSlotList.Next(); 1344 pNextSlot = pEle ? &pEle->xSlot : NULL; 1345 } 1346 } 1347 1348 if ( !pLinkedSlot ) 1349 { 1350 rOutStm << "0 ,"; 1351 } 1352 else 1353 { 1354 rOutStm << "&a" << rShellName.GetBuffer() << "Slots_Impl[" 1355 << ByteString::CreateFromInt32(pLinkedSlot->GetListPos()).GetBuffer() 1356 << "] /*Offset Linked*/, " << endl; 1357 WriteTab( rOutStm, 4 ); 1358 } 1359 1360 rOutStm << "&a" << rShellName.GetBuffer() << "Slots_Impl[" 1361 << ByteString::CreateFromInt32(pNextSlot->GetListPos()).GetBuffer() 1362 << "] /*Offset Next*/, " << endl; 1363 1364 WriteTab( rOutStm, 4 ); 1365 1366 // ExecMethod schreiben, wenn nicht angegeben, standard Namen 1367 if( GetExecMethod().Len() && GetExecMethod() != "NoExec") 1368 rOutStm << "SFX_STUB_PTR(" << rShellName.GetBuffer() << ',' 1369 << GetExecMethod().GetBuffer() << ')'; 1370 else 1371 rOutStm << "SFX_STUB_PTR_EXEC_NONE"; 1372 rOutStm << ','; 1373 1374 // StateMethod schreiben, wenn nicht angegeben, standard Namen 1375 if( GetStateMethod().Len() && GetStateMethod() != "NoState") 1376 rOutStm << "SFX_STUB_PTR(" << rShellName.GetBuffer() << ',' 1377 << GetStateMethod().GetBuffer() << ')'; 1378 else 1379 rOutStm << "SFX_STUB_PTR_STATE_NONE"; 1380 } 1381 rOutStm << ',' << endl; 1382 WriteTab( rOutStm, 4 ); 1383 1384 // Flags schreiben 1385 if( GetHasCoreId() ) 1386 rOutStm << MakeSlotName( SvHash_HasCoreId() ).GetBuffer() << '|'; 1387 if( GetCachable() ) 1388 rOutStm << MakeSlotName( SvHash_Cachable() ).GetBuffer() << '|'; 1389 if( GetVolatile() ) 1390 rOutStm << MakeSlotName( SvHash_Volatile() ).GetBuffer() << '|'; 1391 if( GetToggle() ) 1392 rOutStm << MakeSlotName( SvHash_Toggle() ).GetBuffer() << '|'; 1393 if( GetAutoUpdate() ) 1394 rOutStm << MakeSlotName( SvHash_AutoUpdate() ).GetBuffer() << '|'; 1395 if( GetSynchron() ) 1396 rOutStm << MakeSlotName( SvHash_Synchron() ).GetBuffer() << '|'; 1397 if( GetAsynchron() ) 1398 rOutStm << MakeSlotName( SvHash_Asynchron() ).GetBuffer() << '|'; 1399 if( GetRecordPerItem() ) 1400 rOutStm << MakeSlotName( SvHash_RecordPerItem() ).GetBuffer() << '|'; 1401 if( GetRecordPerSet() ) 1402 rOutStm << MakeSlotName( SvHash_RecordPerSet() ).GetBuffer() << '|'; 1403 if( GetRecordManual() ) 1404 rOutStm << MakeSlotName( SvHash_RecordManual() ).GetBuffer() << '|'; 1405 if( GetNoRecord() ) 1406 rOutStm << MakeSlotName( SvHash_NoRecord() ).GetBuffer() << '|'; 1407 if( GetRecordAbsolute() ) 1408 rOutStm << MakeSlotName( SvHash_RecordAbsolute() ).GetBuffer() << '|'; 1409 if( GetHasDialog() ) 1410 rOutStm << MakeSlotName( SvHash_HasDialog() ).GetBuffer() << '|'; 1411 if( GetMenuConfig() ) 1412 rOutStm << MakeSlotName( SvHash_MenuConfig() ).GetBuffer() << '|'; 1413 if( GetToolBoxConfig() ) 1414 rOutStm << MakeSlotName( SvHash_ToolBoxConfig() ).GetBuffer() << '|'; 1415 if( GetStatusBarConfig() ) 1416 rOutStm << MakeSlotName( SvHash_StatusBarConfig() ).GetBuffer() << '|'; 1417 if( GetAccelConfig() ) 1418 rOutStm << MakeSlotName( SvHash_AccelConfig() ).GetBuffer() << '|'; 1419 if( GetFastCall() ) 1420 rOutStm << MakeSlotName( SvHash_FastCall() ).GetBuffer() << '|'; 1421 if( GetContainer() ) 1422 rOutStm << MakeSlotName( SvHash_Container() ).GetBuffer() << '|'; 1423 if ( GetReadOnlyDoc() ) 1424 rOutStm << MakeSlotName( SvHash_ReadOnlyDoc() ).GetBuffer() << '|'; 1425 if( GetImageRotation() ) 1426 rOutStm << MakeSlotName( SvHash_ImageRotation() ).GetBuffer() << '|'; 1427 if( GetImageReflection() ) 1428 rOutStm << MakeSlotName( SvHash_ImageReflection() ).GetBuffer() << '|'; 1429 rOutStm << '0'; 1430 1431 rOutStm << ',' << endl; 1432 WriteTab( rOutStm, 4 ); 1433 if ( !GetDisableFlags().Len() ) 1434 rOutStm << "0"; 1435 else 1436 rOutStm << GetDisableFlags().GetBuffer(); 1437 1438 // Attribut Typ schreiben 1439 if( !bIsEnumSlot ) 1440 { 1441 rOutStm << ',' << endl; 1442 WriteTab( rOutStm, 4 ); 1443 1444 SvMetaType * pT = GetSlotType(); 1445 if( !pT ) 1446 { 1447 if( !IsVariable() ) 1448 pT = rBase.FindType( "SfxVoidItem" ); 1449 else 1450 pT = GetType(); 1451 } 1452 if( pT ) 1453 { 1454 rOutStm << pT->GetName().GetBuffer(); 1455 if( !rBase.FindType( pT, rBase.aUsedTypes ) ) 1456 rBase.aUsedTypes.Append( pT ); 1457 } 1458 else 1459 rOutStm << "SfxVoidItem not defined"; 1460 } 1461 else 1462 { 1463 SvMetaType *pT = rBase.FindType( "SfxBoolItem" ); 1464 if ( pT && !rBase.FindType( pT, rBase.aUsedTypes ) ) 1465 rBase.aUsedTypes.Append( pT ); 1466 } 1467 1468 if( !bIsEnumSlot ) 1469 { 1470 rOutStm << ',' << endl; 1471 WriteTab( rOutStm, 4 ); 1472 rOutStm << ByteString::CreateFromInt32( nCount ).GetBuffer() << "/*Offset*/, "; 1473 1474 if( IsMethod() ) 1475 { 1476 SvMetaAttribute * pMethod = GetMethod(); 1477 SvMetaType * pType; 1478 if( pMethod ) 1479 pType = pMethod->GetType(); 1480 else 1481 pType = GetType(); 1482 sal_uLong nSCount = pType->GetAttrCount(); 1483 rOutStm << ByteString::CreateFromInt32( nSCount ).GetBuffer() << "/*Count*/"; 1484 } 1485 else 1486 rOutStm << '0'; 1487 1488 // Name f"urs Recording 1489 if ( GetExport() ) 1490 { 1491 rOutStm << ",\""; 1492 if( rPrefix.Len() ) 1493 rOutStm << rPrefix.GetBuffer(); 1494 rOutStm << '.'; 1495 if ( !IsVariable() || !GetType() || 1496 GetType()->GetBaseType()->GetType() != TYPE_STRUCT ) 1497 rOutStm << GetMangleName( sal_False ).GetBuffer(); 1498 rOutStm << "\","; 1499 } 1500 else 1501 rOutStm << ", 0, "; 1502 1503 // Method/Property Flags 1504 if( IsMethod() ) 1505 rOutStm << "SFX_SLOT_METHOD|"; 1506 if( IsVariable() ) 1507 { 1508 rOutStm << "SFX_SLOT_PROPGET|"; 1509 if( !GetReadonly() ) 1510 rOutStm << "SFX_SLOT_PROPSET|"; 1511 } 1512 1513 rOutStm << '0'; 1514 } 1515 1516 // if ( GetUnoName().Len() ) 1517 { 1518 rOutStm << ",\""; 1519 rOutStm << GetMangleName( sal_False ).GetBuffer(); 1520 //rOutStm << GetUnoName().GetBuffer(); 1521 rOutStm << "\""; 1522 } 1523 // else 1524 // rOutStm << ", 0"; 1525 1526 rOutStm << " )," << endl; 1527 } 1528 1529 sal_uInt16 SvMetaSlot::WriteSlotParamArray( SvIdlDataBase & rBase, SvStream & rOutStm ) 1530 { 1531 if ( !GetExport() && !GetHidden() ) 1532 return 0; 1533 1534 SvMetaAttribute * pMethod = GetMethod(); 1535 if( IsMethod() ) 1536 { 1537 SvMetaType * pType; 1538 if( pMethod ) 1539 pType = pMethod->GetType(); 1540 else 1541 pType = GetType(); 1542 1543 if( !rBase.FindType( pType, rBase.aUsedTypes ) ) 1544 rBase.aUsedTypes.Append( pType ); 1545 1546 const SvMetaAttributeMemberList & rList = 1547 pType->GetAttrList(); 1548 for( sal_uLong n = 0; n < rList.Count(); n++ ) 1549 { 1550 SvMetaAttribute * pPar = rList.GetObject( n ); 1551 SvMetaType * pPType = pPar->GetType(); 1552 WriteTab( rOutStm, 1 ); 1553 rOutStm << "SFX_ARGUMENT(" 1554 << pPar->GetSlotId().GetBuffer() << ',' // SlodId 1555 // Parameter Name 1556 << "\"" << pPar->GetName().GetBuffer() << "\"," 1557 // Item Name 1558 << pPType->GetName().GetBuffer() << ")," << endl; 1559 if( !rBase.FindType( pPType, rBase.aUsedTypes ) ) 1560 rBase.aUsedTypes.Append( pPType ); 1561 } 1562 return (sal_uInt16)rList.Count(); 1563 } 1564 return 0; 1565 } 1566 1567 sal_uInt16 SvMetaSlot::WriteSlotMap( const ByteString & rShellName, sal_uInt16 nCount, 1568 SvSlotElementList& rSlotList, 1569 const ByteString & rPrefix, 1570 SvIdlDataBase & rBase, 1571 SvStream & rOutStm ) 1572 { 1573 // SlotId, wenn nicht angegeben, aus Namen generieren 1574 ByteString slotId = GetSlotId(); 1575 1576 sal_uInt16 nSCount = 0; 1577 if( IsMethod() ) 1578 { 1579 SvMetaType * pType; 1580 SvMetaAttribute * pMethod = GetMethod(); 1581 if( pMethod ) 1582 pType = pMethod->GetType(); 1583 else 1584 pType = GetType(); 1585 1586 nSCount = (sal_uInt16)pType->GetAttrCount(); 1587 } 1588 1589 WriteSlot( rShellName, nCount, slotId, rSlotList, rPrefix, rBase, rOutStm ); 1590 return nSCount; 1591 } 1592 1593 /************************************************************************* 1594 |* SvMetaSlot::WriteSrc() 1595 *************************************************************************/ 1596 void SvMetaSlot::WriteSrc( SvIdlDataBase & rBase, SvStream & rOutStm, 1597 Table * pTable ) 1598 { 1599 if (!GetToolBoxConfig() && !GetAccelConfig() && !GetMenuConfig() && !GetStatusBarConfig() ) 1600 return; 1601 1602 sal_uLong nSId = GetSlotId().GetValue(); 1603 if( !pTable->IsKeyValid( nSId ) ) 1604 { 1605 pTable->Insert( nSId, this ); 1606 rOutStm << "SfxSlotInfo " << ByteString::CreateFromInt32( nSId ).GetBuffer() 1607 << endl << '{' << endl; 1608 1609 WriteTab( rOutStm, 1 ); 1610 ByteString aStr = GetConfigName(); 1611 if( !aStr.Len() ) 1612 aStr = GetName(); 1613 1614 rOutStm << "SlotName = \"" << aStr.GetBuffer() << "\";" << endl; 1615 1616 aStr = GetHelpText(); 1617 if( aStr.Len() ) 1618 { 1619 WriteTab( rOutStm, 1 ); 1620 rOutStm << "HelpText = \"" << aStr.GetBuffer() << "\";" << endl; 1621 } 1622 1623 rOutStm << "};" << endl; 1624 } 1625 1626 SvMetaTypeEnum * pEnum = PTR_CAST( SvMetaTypeEnum, GetType() ); 1627 if( GetPseudoSlots() && pEnum ) 1628 { 1629 for( sal_uLong n = 0; n < pEnum->Count(); n++ ) 1630 { 1631 ByteString aValName = pEnum->GetObject( n )->GetName(); 1632 ByteString aSId( GetSlotId() ); 1633 if( GetPseudoPrefix().Len() ) 1634 aSId = GetPseudoPrefix(); 1635 aSId += '_'; 1636 aSId += aValName.Copy( pEnum->GetPrefix().Len() ); 1637 1638 sal_uLong nSId2; 1639 sal_Bool bIdOk = sal_False; 1640 if( rBase.FindId( aSId, &nSId2 ) ) 1641 { 1642 aSId = ByteString::CreateFromInt32( nSId2 ); 1643 bIdOk = sal_True; 1644 } 1645 1646 // wenn Id nicht gefunden, immer schreiben 1647 if( !bIdOk || !pTable->IsKeyValid( nSId2 ) ) 1648 { 1649 pTable->Insert( nSId2, this ); 1650 rOutStm << "SfxSlotInfo " << aSId.GetBuffer() 1651 << endl << '{' << endl; 1652 1653 WriteTab( rOutStm, 1 ); 1654 rOutStm << "SlotName = \"" << aValName.GetBuffer() << "\";" << endl; 1655 1656 ByteString aStr = GetHelpText(); 1657 if( aStr.Len() ) 1658 { 1659 WriteTab( rOutStm, 1 ); 1660 rOutStm << "HelpText = \"" << aStr.GetBuffer() << "\";" << endl; 1661 } 1662 rOutStm << "};" << endl; 1663 } 1664 } 1665 } 1666 } 1667 1668 void SvMetaSlot::WriteHelpId( SvIdlDataBase & rBase, SvStream & rOutStm, 1669 Table * pTable ) 1670 { 1671 sal_uLong nSId = GetSlotId().GetValue(); 1672 if( !pTable->IsKeyValid( nSId ) ) 1673 { 1674 pTable->Insert( nSId, this ); 1675 rOutStm << "#define " << GetSlotId().GetBuffer() << '\t' << ByteString::CreateFromInt32( nSId ).GetBuffer() << endl; 1676 } 1677 1678 SvMetaTypeEnum * pEnum = PTR_CAST( SvMetaTypeEnum, GetType() ); 1679 if( GetPseudoSlots() && pEnum ) 1680 { 1681 for( sal_uLong n = 0; n < pEnum->Count(); n++ ) 1682 { 1683 ByteString aValName = pEnum->GetObject( n )->GetName(); 1684 ByteString aSId( GetSlotId() ); 1685 if( GetPseudoPrefix().Len() ) 1686 aSId = GetPseudoPrefix(); 1687 aSId += '_'; 1688 aSId += aValName.Copy( pEnum->GetPrefix().Len() ); 1689 1690 sal_uLong nSId2; 1691 sal_Bool bIdOk = sal_False; 1692 if( rBase.FindId( aSId, &nSId2 ) ) 1693 { 1694 aSId = ByteString::CreateFromInt32( nSId2 ); 1695 bIdOk = sal_True; 1696 } 1697 1698 // wenn Id nicht gefunden, immer schreiben 1699 if( !bIdOk || !pTable->IsKeyValid( nSId2 ) ) 1700 { 1701 pTable->Insert( nSId2, this ); 1702 1703 rOutStm << "#define " << aSId.GetBuffer() << '\t' 1704 << ByteString::CreateFromInt32( nSId2 ).GetBuffer() << endl; 1705 } 1706 } 1707 } 1708 } 1709 1710 void WriteBool( sal_Bool bSet, SvStream& rStream ) 1711 { 1712 if ( bSet ) 1713 rStream << "sal_True" << ','; 1714 else 1715 rStream << "sal_False" << ','; 1716 } 1717 1718 void SvMetaSlot::WriteCSV( SvIdlDataBase& rBase, SvStream& rStrm ) 1719 { 1720 rStrm << "PROJECT,"; 1721 rStrm << GetSlotId().GetBuffer() << ','; 1722 rStrm << ByteString::CreateFromInt32( GetSlotId().GetValue() ).GetBuffer() << ','; 1723 1724 if ( GetPseudoPrefix().Len() ) 1725 rStrm << GetPseudoPrefix().GetBuffer() << ','; 1726 else 1727 rStrm << ','; 1728 1729 rStrm << GetGroupId().GetBuffer() << ','; 1730 1731 WriteBool( GetAccelConfig(), rStrm ); 1732 WriteBool( GetMenuConfig(), rStrm ); 1733 WriteBool( GetStatusBarConfig(), rStrm ); 1734 WriteBool( GetToolBoxConfig(), rStrm ); 1735 1736 if ( GetSlotType() ) 1737 rStrm << GetSlotType()->GetName().GetBuffer() << ','; 1738 else 1739 rStrm << ','; 1740 1741 WriteBool( GetAutoUpdate(), rStrm ); 1742 if ( GetCachable() ) 1743 rStrm << "Cachable" << ','; 1744 else 1745 rStrm << "Volatile" << ','; 1746 1747 WriteBool( GetContainer(), rStrm ); 1748 WriteBool( GetFastCall(), rStrm ); 1749 WriteBool( GetHasCoreId(), rStrm ); 1750 WriteBool( GetHasDialog(), rStrm ); 1751 WriteBool( GetReadOnlyDoc(), rStrm ); 1752 WriteBool( GetImageRotation(), rStrm ); 1753 WriteBool( GetImageReflection(), rStrm ); 1754 rStrm << GetDisableFlags().GetBuffer() << ','; 1755 1756 if( GetSynchron() ) 1757 rStrm << "Synchron" << ','; 1758 else 1759 rStrm << "Asynchron" << ','; 1760 1761 WriteBool( GetToggle(), rStrm ); 1762 WriteBool( GetReadonly(), rStrm ); 1763 WriteBool( GetExport(), rStrm ); 1764 if( GetRecordPerItem() ) 1765 rStrm << "RecordPerItem" << ','; 1766 else if ( GetNoRecord() ) 1767 rStrm << "NoRecord" << ','; 1768 else if ( GetRecordManual() ) 1769 rStrm << "RecordManual" << ','; 1770 else 1771 rStrm << "RecordPerSet" << ','; 1772 1773 WriteBool( GetRecordAbsolute(), rStrm ); 1774 1775 if ( GetType()->GetType() != TYPE_METHOD && GetMethod() ) 1776 { 1777 rStrm << GetMethod()->GetType()->GetReturnType()->GetName().GetBuffer() << ','; 1778 rStrm << GetMethod()->GetName().GetBuffer() << ','; 1779 } 1780 else 1781 { 1782 rStrm << ",,"; 1783 } 1784 1785 rStrm << GetType()->GetSvName().GetBuffer() << ','; 1786 rStrm << GetName().GetBuffer() << ','; 1787 1788 if ( GetType()->GetType() == TYPE_METHOD || GetMethod() ) 1789 { 1790 SvMetaAttributeMemberList *pList = &GetType()->GetAttrList(); 1791 if ( GetMethod() ) 1792 pList = &GetMethod()->GetType()->GetAttrList(); 1793 1794 if( pList && pList->Count() ) 1795 { 1796 rStrm << "\"("; 1797 SvMetaAttribute* pAttr = pList->First(); 1798 while( pAttr ) 1799 { 1800 pAttr->WriteCSV( rBase, rStrm ); 1801 pAttr = pList->Next(); 1802 if( pAttr ) 1803 rStrm << ','; 1804 } 1805 rStrm << ")\""; 1806 } 1807 else 1808 rStrm << "()"; 1809 } 1810 1811 rStrm << endl; 1812 } 1813 1814 #endif // IDL_COMPILER 1815 1816 1817