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 <types.hxx>
34 #include <globals.hxx>
35 #include <database.hxx>
36
37 /****************** SvMetaAttribute *************************************/
38 /************************************************************************/
39 SV_IMPL_META_FACTORY1( SvMetaAttribute, SvMetaReference );
40 /*************************************************************************
41 |* SvMetaAttribute::SvMetaAttribute()
42 |*
43 |* Beschreibung
44 *************************************************************************/
SvMetaAttribute()45 SvMetaAttribute::SvMetaAttribute()
46 : aAutomation( sal_True, sal_False )
47 , aExport( sal_True, sal_False )
48 , aIsCollection ( sal_False, sal_False )
49 , aReadOnlyDoc ( sal_True, sal_False )
50 , aHidden( sal_False, sal_False )
51 , bNewAttr( sal_False )
52 {
53 }
54
SvMetaAttribute(SvMetaType * pType)55 SvMetaAttribute::SvMetaAttribute( SvMetaType * pType )
56 : aType( pType )
57 , aAutomation( sal_True, sal_False )
58 , aExport( sal_True, sal_False )
59 , aIsCollection ( sal_False, sal_False)
60 , aReadOnlyDoc ( sal_True, sal_False)
61 , aHidden( sal_False, sal_False )
62 , bNewAttr( sal_False )
63 {
64 }
65
66 /*************************************************************************
67 |* SvMetaAttribute::Load()
68 |* SvMetaAttribute::Save()
69 |*
70 |* Beschreibung
71 *************************************************************************/
Load(SvPersistStream & rStm)72 void SvMetaAttribute::Load( SvPersistStream & rStm )
73 {
74 SvMetaReference::Load( rStm );
75
76 sal_uInt8 nMask;
77 rStm >> nMask;
78 if( nMask & 0x01 )
79 {
80 SvMetaType * pType;
81 rStm >> pType;
82 aType = pType;
83 }
84 if( nMask & 0x02 ) rStm >> aSlotId;
85 if( nMask & 0x04 ) rStm >> aExport;
86 if( nMask & 0x08 ) rStm >> aReadonly;
87 if( nMask & 0x10 ) rStm >> aAutomation;
88 if( nMask & 0x20 ) rStm >> aIsCollection;
89 if( nMask & 0x40 ) rStm >> aReadOnlyDoc;
90 if( nMask & 0x80 ) rStm >> aHidden;
91 }
92
Save(SvPersistStream & rStm)93 void SvMetaAttribute::Save( SvPersistStream & rStm )
94 {
95 SvMetaReference::Save( rStm );
96
97 // Maske erstellen
98 sal_uInt8 nMask = 0;
99 if( aType.Is() ) nMask |= 0x1;
100 if( aSlotId.IsSet() ) nMask |= 0x2;
101 if( aExport.IsSet() ) nMask |= 0x4;
102 if( aReadonly.IsSet() ) nMask |= 0x8;
103 if( aAutomation.IsSet() ) nMask |= 0x10;
104 if( aIsCollection.IsSet() ) nMask |= 0x20;
105 if( aReadOnlyDoc.IsSet() ) nMask |= 0x40;
106 if( aHidden.IsSet() ) nMask |= 0x80;
107
108 // Daten schreiben
109 rStm << nMask;
110 if( nMask & 0x1 ) rStm << aType;
111 if( nMask & 0x2 ) rStm << aSlotId;
112 if( nMask & 0x4 ) rStm << aExport;
113 if( nMask & 0x8 ) rStm << aReadonly;
114 if( nMask & 0x10 ) rStm << aAutomation;
115 if( nMask & 0x20 ) rStm << aIsCollection;
116 if( nMask & 0x40 ) rStm << aReadOnlyDoc;
117 if( nMask & 0x80 ) rStm << aHidden;
118 }
119
120 /*************************************************************************
121 |* SvMetaAttribute::GetType()
122 |*
123 |* Beschreibung
124 *************************************************************************/
GetType() const125 SvMetaType * SvMetaAttribute::GetType() const
126 {
127 if( aType.Is() || !GetRef() ) return aType;
128 return ((SvMetaAttribute *)GetRef())->GetType();
129 }
130
131 /*************************************************************************
132 |* SvMetaAttribute::GetSlotId()
133 |*
134 |* Beschreibung
135 *************************************************************************/
GetSlotId() const136 const SvNumberIdentifier & SvMetaAttribute::GetSlotId() const
137 {
138 if( aSlotId.IsSet() || !GetRef() ) return aSlotId;
139 return ((SvMetaAttribute *)GetRef())->GetSlotId();
140 }
141
142 /*************************************************************************
143 |* SvMetaAttribute::GetReadonly()
144 |*
145 |* Beschreibung
146 *************************************************************************/
GetReadonly() const147 sal_Bool SvMetaAttribute::GetReadonly() const
148 {
149 if( aReadonly.IsSet() || !GetRef() ) return aReadonly;
150 return ((SvMetaAttribute *)GetRef())->GetReadonly();
151 }
152
153 /*************************************************************************
154 |* SvMetaAttribute::GetExport()
155 |*
156 |* Beschreibung
157 *************************************************************************/
GetExport() const158 sal_Bool SvMetaAttribute::GetExport() const
159 {
160 if( aExport.IsSet() || !GetRef() ) return aExport;
161 return ((SvMetaAttribute *)GetRef())->GetExport();
162 }
163
164 /*************************************************************************
165 |* SvMetaAttribute::GetHidden()
166 |*
167 |* Beschreibung
168 *************************************************************************/
GetHidden() const169 sal_Bool SvMetaAttribute::GetHidden() const
170 {
171 // Wenn Export gesetzt wurde, aber Hidden nicht, gilt der Default
172 // aHidden = !aExport
173 if ( aExport.IsSet() && !aHidden.IsSet() )
174 return !aExport;
175 else if( aHidden.IsSet() || !GetRef() )
176 return aHidden;
177 else
178 return ((SvMetaAttribute *)GetRef())->GetHidden();
179 }
180
181 /*************************************************************************
182 |* SvMetaAttribute::GetAutomation()
183 |*
184 |* Beschreibung
185 *************************************************************************/
GetAutomation() const186 sal_Bool SvMetaAttribute::GetAutomation() const
187 {
188 if( aAutomation.IsSet() || !GetRef() ) return aAutomation;
189 return ((SvMetaAttribute *)GetRef())->GetAutomation();
190 }
191
GetIsCollection() const192 sal_Bool SvMetaAttribute::GetIsCollection() const
193 {
194 sal_Bool bRet;
195 if( aIsCollection.IsSet() || !GetRef() )
196 {
197 if ( aIsCollection.IsSet() )
198 {
199 bRet = aIsCollection;
200 return bRet;
201 }
202
203 return aIsCollection;
204 }
205
206 return ((SvMetaSlot *)GetRef())->GetIsCollection();
207 }
208
GetReadOnlyDoc() const209 sal_Bool SvMetaAttribute::GetReadOnlyDoc() const
210 {
211 if( aReadOnlyDoc.IsSet() || !GetRef() ) return aReadOnlyDoc;
212 return ((SvMetaSlot *)GetRef())->GetReadOnlyDoc();
213 }
214
215 /*************************************************************************
216 |* SvMetaAttribute::IsMethod()
217 |* SvMetaAttribute::IsVariable()
218 |* SvMetaAttribute::GetMangleName()
219 |*
220 |* Beschreibung
221 *************************************************************************/
IsMethod() const222 sal_Bool SvMetaAttribute::IsMethod() const
223 {
224 SvMetaType * pType = GetType();
225 DBG_ASSERT( pType, "no type for attribute" );
226 return pType->GetType() == TYPE_METHOD;
227 }
228
IsVariable() const229 sal_Bool SvMetaAttribute::IsVariable() const
230 {
231 SvMetaType * pType = GetType();
232 return pType->GetType() != TYPE_METHOD;
233 }
234
GetMangleName(sal_Bool) const235 ByteString SvMetaAttribute::GetMangleName( sal_Bool ) const
236 {
237 return GetName();
238 }
239
240 /*************************************************************************
241 |* SvMetaAttribute::FillSbxObject()
242 |*
243 |* Beschreibung
244 *************************************************************************/
245 /*
246 void SvMetaAttribute::FillSbxObject( SbxInfo * pInfo, sal_uInt16 nSbxFlags )
247 {
248 SvMetaType * pType = GetType();
249 DBG_ASSERT( pType, "no type for attribute" );
250 if( !nSbxFlags )
251 { // Flags koennen vom Aufrufer ueberschrieben werden
252 if( pType->GetOut() )
253 {
254 nSbxFlags |= SBX_WRITE;
255 if( pType->GetIn() )
256 nSbxFlags |= SBX_READ;
257 }
258 else
259 nSbxFlags |= SBX_READ;
260 }
261 SvMetaType * pBaseType = pType->GetBaseType();
262 DBG_ASSERT( pBaseType, "no base type for attribute" );
263 if( pBaseType->GetType() == TYPE_STRUCT )
264 {
265 const SvMetaAttributeMemberList & rList = pBaseType->GetAttrList();
266 sal_uLong nCount = rList.Count();
267 for( sal_uLong i = 0; i < nCount; i++ )
268 rList.GetObject( i )->FillSbxObject( pInfo, nSbxFlags );
269 }
270 else
271 //MI: pInfo->AddParam( GetName(), pBaseType->GetSbxDataType(), nSbxFlags );
272 pInfo->AddParam( GetName(), SbxVARIANT, nSbxFlags );
273 }
274 */
275
276 /*************************************************************************
277 |* SvMetaAttribute::FillSbxObject()
278 |*
279 |* Beschreibung
280 *************************************************************************/
281 /*
282 void SvMetaAttribute::FillSbxObject( SvIdlDataBase & rBase,
283 SbxObject * pObj, sal_Bool bVariable )
284 {
285 // keine Attribut fuer Automation
286 if( !GetAutomation() || !GetExport() )
287 return;
288
289 if( bVariable && IsVariable() )
290 {
291 SvMetaType * pType = GetType();
292 DBG_ASSERT( pType, "no type for attribute" );
293 SvMetaType * pBaseType = pType->GetBaseType();
294 DBG_ASSERT( pBaseType, "no base type for attribute" );
295
296 if( pBaseType->GetType() == TYPE_STRUCT )
297 {
298 SvNumberIdentifier aSlotId = rBase.aStructSlotId;
299 if ( GetSlotId().Len() )
300 rBase.aStructSlotId = GetSlotId();
301 const SvMetaAttributeMemberList & rList = pBaseType->GetAttrList();
302 sal_uLong nCount = rList.Count();
303 for( sal_uLong i = 0; i < nCount; i++ )
304 rList.GetObject( i )->FillSbxObject( rBase, pObj, bVariable );
305 rBase.aStructSlotId = aSlotId;
306 }
307 else
308 {
309 SbxPropertyRef xProp = new SbxProperty( GetName(), SbxVARIANT );
310 //MI: pBaseType->GetSbxDataType() );
311 if ( GetReadonly() || IsMethod() )
312 xProp->ResetFlag( SBX_WRITE );
313 xProp->SetUserData( MakeSlotValue( rBase, sal_True ) );
314 pType->FillSbxObject( xProp, bVariable );
315
316 pObj->Insert( &xProp );
317 }
318 }
319 else if( !bVariable && IsMethod() )
320 {
321 SvMetaType * pType = GetType();
322 SvMetaType * pRetBaseType = GetType()->GetReturnType()->GetBaseType();
323 SbxMethodRef xMeth = new SbxMethod( GetName(),
324 pRetBaseType->GetSbxDataType() );
325 xMeth->ResetFlag( SBX_WRITE );
326 xMeth->SetUserData( MakeSlotValue( rBase, sal_False ) );
327 pType->FillSbxObject( xMeth, bVariable );
328
329 pObj->Insert( &xMeth );
330 }
331 }
332 */
333 #ifdef IDL_COMPILER
334 /*************************************************************************
335 |* SvMetaAttribute::Test()
336 |*
337 |* Beschreibung
338 *************************************************************************/
Test(SvIdlDataBase & rBase,SvTokenStream & rInStm)339 sal_Bool SvMetaAttribute::Test( SvIdlDataBase & rBase,
340 SvTokenStream & rInStm )
341 {
342 sal_Bool bOk = sal_True;
343 if( GetType()->IsItem() && !GetSlotId().IsSet() )
344 {
345 rBase.SetError( "slot without id declared", rInStm.GetToken() );
346 rBase.WriteError( rInStm );
347 bOk = sal_False;
348 }
349 /*
350 if( !GetType()->IsItem() && GetSlotId().IsSet() )
351 {
352 rBase.SetError( "slot without item declared", rInStm.GetToken() );
353 rBase.WriteError( rInStm );
354 bOk = sal_False;
355 }
356 */
357 return bOk;
358 }
359
360 /*************************************************************************
361 |* SvMetaAttribute::ReadSvIdl()
362 |*
363 |* Beschreibung
364 *************************************************************************/
ReadSvIdl(SvIdlDataBase & rBase,SvTokenStream & rInStm)365 sal_Bool SvMetaAttribute::ReadSvIdl( SvIdlDataBase & rBase,
366 SvTokenStream & rInStm )
367 {
368 sal_uInt32 nTokPos = rInStm.Tell();
369 if( !GetType() )
370 // Es wurde kein Typ im ctor mitgegeben
371 aType = rBase.ReadKnownType( rInStm );
372 sal_Bool bOk = sal_False;
373 if( GetType() )
374 {
375 ReadNameSvIdl( rBase, rInStm );
376 aSlotId.ReadSvIdl( rBase, rInStm );
377
378 bOk = sal_True;
379 SvToken * pTok = rInStm.GetToken();
380 if( bOk && pTok->IsChar() && pTok->GetChar() == '(' )
381 {
382 SvMetaTypeRef xT = new SvMetaType();
383 xT->SetRef( GetType() );
384 aType = xT;
385 bOk = aType->ReadMethodArgs( rBase, rInStm );
386 }
387 if( bOk )
388 bOk = SvMetaName::ReadSvIdl( rBase, rInStm );
389 }
390 else
391 rBase.SetError( "unknown type", rInStm.GetToken() );
392
393 if( !bOk )
394 rInStm.Seek( nTokPos );
395 return bOk;
396 }
397
398 /*************************************************************************
399 |* SvMetaAttribute::WriteSvIdl()
400 |*
401 |* Beschreibung
402 *************************************************************************/
WriteSvIdl(SvIdlDataBase & rBase,SvStream & rOutStm,sal_uInt16 nTab)403 void SvMetaAttribute::WriteSvIdl
404 (
405 SvIdlDataBase & rBase,
406 SvStream & rOutStm,
407 sal_uInt16 nTab
408 )
409 {
410 SvMetaType * pType = GetType();
411 pType->WriteTypePrefix( rBase, rOutStm, nTab, WRITE_IDL );
412 rOutStm << ' ' << GetName().GetBuffer();
413 if( aSlotId.IsSet() )
414 rOutStm << ' ' << aSlotId.GetBuffer();
415 if( pType->GetType() == TYPE_METHOD )
416 pType->WriteMethodArgs( rBase, rOutStm, nTab, WRITE_IDL );
417 sal_uLong nPos = rOutStm.Tell();
418 rOutStm << endl;
419 SvMetaName::WriteSvIdl( rBase, rOutStm, nTab );
420 TestAndSeekSpaceOnly( rOutStm, nPos );
421 }
422
423 /*************************************************************************
424 |* SvMetaAttribute::ReadAttributesSvIdl()
425 |*
426 |* Beschreibung
427 *************************************************************************/
ReadAttributesSvIdl(SvIdlDataBase & rBase,SvTokenStream & rInStm)428 void SvMetaAttribute::ReadAttributesSvIdl( SvIdlDataBase & rBase,
429 SvTokenStream & rInStm )
430 {
431 SvMetaReference::ReadAttributesSvIdl( rBase, rInStm );
432 aSlotId.ReadSvIdl( rBase, SvHash_SlotId(), rInStm );
433 aExport.ReadSvIdl( SvHash_Export(), rInStm );
434 aHidden.ReadSvIdl( SvHash_Hidden(), rInStm );
435 aAutomation.ReadSvIdl( SvHash_Automation(), rInStm );
436 aIsCollection.ReadSvIdl( SvHash_IsCollection(), rInStm );
437 aReadOnlyDoc.ReadSvIdl( SvHash_ReadOnlyDoc(), rInStm );
438 if( aReadonly.ReadSvIdl( SvHash_Readonly(), rInStm ) )
439 {
440 if( GetType()->GetType() == TYPE_METHOD )
441 {
442 // Fehler setzen
443 rBase.SetError( "Readonly in function attribute", rInStm.GetToken() );
444 rBase.WriteError( rInStm );
445 }
446 }
447 }
448
449 /*************************************************************************
450 |* SvMetaAttribute::WriteAttributesSvIdl()
451 |*
452 |* Beschreibung
453 *************************************************************************/
WriteAttributesSvIdl(SvIdlDataBase & rBase,SvStream & rOutStm,sal_uInt16 nTab)454 void SvMetaAttribute::WriteAttributesSvIdl
455 (
456 SvIdlDataBase & rBase,
457 SvStream & rOutStm,
458 sal_uInt16 nTab
459 )
460 {
461 SvMetaReference::WriteAttributesSvIdl( rBase, rOutStm, nTab );
462
463 //aSlotId.WriteSvIdl( SvHash_SlotId(), rOutStm, nTab );
464 if( !aExport || !aAutomation || aReadonly )
465 {
466 WriteTab( rOutStm, nTab );
467 rOutStm << "//class SvMetaAttribute" << endl;
468 if( !aExport )
469 {
470 WriteTab( rOutStm, nTab );
471 aExport.WriteSvIdl( SvHash_Export(), rOutStm );
472 rOutStm << ';' << endl;
473 }
474 if ( aHidden != aExport )
475 {
476 WriteTab( rOutStm, nTab );
477 aExport.WriteSvIdl( SvHash_Hidden(), rOutStm );
478 rOutStm << ';' << endl;
479 }
480 if( aReadonly )
481 {
482 WriteTab( rOutStm, nTab );
483 aReadonly.WriteSvIdl( SvHash_Readonly(), rOutStm );
484 rOutStm << ';' << endl;
485 }
486 if( !aAutomation )
487 {
488 WriteTab( rOutStm, nTab );
489 aAutomation.WriteSvIdl( SvHash_Automation(), rOutStm );
490 rOutStm << ';' << endl;
491 }
492 if( aIsCollection )
493 {
494 WriteTab( rOutStm, nTab );
495 aIsCollection.WriteSvIdl( SvHash_IsCollection(), rOutStm );
496 rOutStm << ';' << endl;
497 }
498 if( !aReadOnlyDoc )
499 {
500 WriteTab( rOutStm, nTab );
501 aReadOnlyDoc.WriteSvIdl( SvHash_ReadOnlyDoc(), rOutStm );
502 rOutStm << ';' << endl;
503 }
504 }
505 }
506
507 /*************************************************************************
508 |* SvMetaAttribute::WriteParam()
509 |*
510 |* Beschreibung
511 *************************************************************************/
WriteParam(SvIdlDataBase & rBase,SvStream & rOutStm,sal_uInt16 nTab,WriteType nT)512 void SvMetaAttribute::WriteParam( SvIdlDataBase & rBase,
513 SvStream & rOutStm,
514 sal_uInt16 nTab,
515 WriteType nT )
516 {
517 SvMetaType * pType = GetType();
518 DBG_ASSERT( pType, "no type for attribute" );
519 SvMetaType * pBaseType = pType->GetBaseType();
520 DBG_ASSERT( pBaseType, "no base type for attribute" );
521
522 if( nT == WRITE_ODL || nT == WRITE_DOCU
523 || nT == WRITE_C_HEADER || nT == WRITE_C_SOURCE )
524 {
525 if( pBaseType->GetType() == TYPE_STRUCT )
526 {
527 const SvMetaAttributeMemberList & rList = pBaseType->GetAttrList();
528 sal_uLong nCount = rList.Count();
529 for( sal_uLong i = 0; i < nCount; i++ )
530 {
531 rList.GetObject( i )->WriteParam( rBase, rOutStm, nTab, nT );
532 if( i+1<nCount )
533 {
534 // if ( nT == WRITE_DOCU )
535 rOutStm << ',';
536 // else
537 // rOutStm << ',' << endl;
538 }
539 }
540 }
541 else
542 {
543 if ( nT != WRITE_DOCU )
544 {
545 WriteTab( rOutStm, nTab );
546 pBaseType->WriteTypePrefix( rBase, rOutStm, nTab, nT );
547 }
548
549 if( GetName().Len() )
550 {
551 rOutStm << ' ';
552 rOutStm << GetName().GetBuffer();
553 }
554
555 if ( nT == WRITE_DOCU )
556 {
557 if( pBaseType->GetType() == TYPE_METHOD ||
558 pBaseType->GetType() == TYPE_STRUCT ||
559 pBaseType->GetType() == TYPE_ENUM )
560 {
561 DBG_ERROR( "Falscher Parametertyp!" );
562 }
563 else
564 rOutStm << pBaseType->GetBasicPostfix().GetBuffer();
565 }
566 }
567 }
568 /*
569 else if( nT == WRITE_C_HEADER || nT == WRITE_C_SOURCE )
570 {
571 pBaseType->WriteTypePrefix( rBase, rOutStm, nTab, nT );
572 rOutStm << ' ';
573 rOutStm << GetName().GetBuffer();
574 }
575 */
576 }
577
578 /*************************************************************************
579 |* SvMetaSlot::WriteSlotId()
580 |*
581 |* Beschreibung
582 *************************************************************************/
MakeSlotValue(SvIdlDataBase & rBase,sal_Bool bVar) const583 sal_uLong SvMetaAttribute::MakeSlotValue( SvIdlDataBase & rBase, sal_Bool bVar ) const
584 {
585 const SvNumberIdentifier & rId = GetSlotId();
586 sal_uLong n = rId.GetValue();
587 if( rBase.aStructSlotId.Len() )
588 {
589 n = n << 20;
590 n += rBase.aStructSlotId.GetValue();
591 }
592 if( PTR_CAST( SvMetaSlot, this ) )
593 n |= 0x20000;
594 if( !bVar )
595 n += 0x10000;
596 else if ( GetIsCollection() )
597 n += 0x40000;
598 return n;
599 }
600
601 /*************************************************************************
602 |* SvMetaSlot::WriteAttributes()
603 |*
604 |* Beschreibung
605 *************************************************************************/
WriteAttributes(SvIdlDataBase & rBase,SvStream & rOutStm,sal_uInt16 nTab,WriteType nT,WriteAttribute nA)606 void SvMetaAttribute::WriteAttributes( SvIdlDataBase & rBase, SvStream & rOutStm,
607 sal_uInt16 nTab,
608 WriteType nT, WriteAttribute nA )
609 {
610 if( nT == WRITE_ODL )
611 {
612 const SvNumberIdentifier & rId = GetSlotId();
613 sal_Bool bReadonly = GetReadonly() || ( nA & WA_READONLY );
614 if( (rId.IsSet() && !(nA & WA_STRUCT)) || bReadonly )
615 {
616 sal_Bool bVar = IsVariable();
617 if( nA & WA_VARIABLE )
618 bVar = sal_True;
619 else if( nA & WA_METHOD )
620 bVar = sal_False;
621
622 WriteTab( rOutStm, nTab );
623 rOutStm << "//class SvMetaAttribute" << endl;
624 if( rId.IsSet() && !(nA & WA_STRUCT) )
625 {
626 WriteTab( rOutStm, nTab );
627 rOutStm << "id("
628 << ByteString::CreateFromInt32(MakeSlotValue( rBase, bVar )).GetBuffer()
629 << ")," << endl;
630 }
631 if( bVar && (bReadonly || IsMethod()) )
632 {
633 WriteTab( rOutStm, nTab );
634 rOutStm << "readonly," << endl;
635 }
636 }
637 }
638 }
639
640 /*************************************************************************
641 |* SvMetaAttribute::WriteCSource()
642 |*
643 |* Beschreibung
644 *************************************************************************/
WriteCSource(SvIdlDataBase & rBase,SvStream & rOutStm,sal_Bool bSet)645 void SvMetaAttribute::WriteCSource( SvIdlDataBase & rBase, SvStream & rOutStm,
646 sal_Bool bSet )
647 {
648 rOutStm << endl;
649 SvMetaType * pType = GetType();
650 SvMetaType * pBaseType = pType->GetBaseType();
651
652 // Bei Set ist der Return immer void
653 sal_Bool bVoid = bSet;
654 if( pBaseType->GetType() == TYPE_METHOD )
655 bVoid = pBaseType->GetReturnType()->GetBaseType()->GetName() == "void";
656
657 // Methoden/Funktions-Body ausgeben
658 rOutStm << '{' << endl;
659 WriteTab( rOutStm, 1 );
660 // rOutStm << "if( SvIPCIsConnected() )" << endl;
661 // WriteTab( rOutStm, 1 );
662 // rOutStm << '{' << endl;
663 // WriteTab( rOutStm, 2 );
664
665 if( !bVoid )
666 {
667 if ( pBaseType->GetCName() == "double" )
668 {
669 rOutStm << "return *(double*)";
670 }
671 else
672 {
673 rOutStm << "return (";
674 pType->WriteTypePrefix( rBase, rOutStm, 2, WRITE_C_SOURCE );
675 rOutStm << ") ";
676 }
677 }
678 rOutStm << "pODKCallFunction( "
679 << ByteString::CreateFromInt32(MakeSlotValue( rBase, IsVariable() )).GetBuffer();
680 rOutStm << ',' << endl;
681 WriteTab( rOutStm, 3 );
682 rOutStm << " h" << rBase.aIFaceName.GetBuffer() << " , ";
683
684 ByteString aParserStr;
685 if( pBaseType->GetType() == TYPE_METHOD || bSet )
686 aParserStr = pBaseType->GetParserString();
687 if( aParserStr.Len() )
688 {
689 rOutStm << '\"';
690 rOutStm << aParserStr.GetBuffer();
691 rOutStm << "\", ";
692 }
693 else
694 rOutStm << "NULL, ";
695
696 if( pBaseType->GetType() == TYPE_METHOD && !bVoid )
697 {
698 rOutStm << "'";
699 rOutStm << pBaseType->GetReturnType()->GetBaseType()->GetParserChar();
700 rOutStm << "'";
701 }
702 else if ( !bSet )
703 {
704 rOutStm << "'";
705 rOutStm << pBaseType->GetParserChar();
706 rOutStm << "'";
707 }
708 else
709 rOutStm << '0';
710
711 if( aParserStr.Len() )
712 {
713 rOutStm << ", ";
714 if( IsMethod() )
715 // void SetPosSize( C_Object *, C_Rectangle * pRect );
716 pBaseType->WriteParamNames( rBase, rOutStm, ByteString() );
717 else if( bSet )
718 pBaseType->WriteParamNames( rBase, rOutStm, GetName() );
719 }
720
721 rOutStm << " );" << endl;
722 // WriteTab( rOutStm, 1 );
723 // rOutStm << '}' << endl;
724 // if( !bVoid )
725 // {
726 // WriteTab( rOutStm, 1 );
727 // rOutStm << "return 0;" << endl;
728 // }
729 rOutStm << '}' << endl;
730 }
731
732 /*************************************************************************
733 |* SvMetaAttribute::WriteRecursiv_Impl()
734 |*
735 |* Beschreibung
736 *************************************************************************/
WriteRecursiv_Impl(SvIdlDataBase & rBase,SvStream & rOutStm,sal_uInt16 nTab,WriteType nT,WriteAttribute nA)737 void SvMetaAttribute::WriteRecursiv_Impl( SvIdlDataBase & rBase,
738 SvStream & rOutStm, sal_uInt16 nTab,
739 WriteType nT, WriteAttribute nA )
740 {
741 const SvMetaAttributeMemberList & rList = GetType()->GetBaseType()->GetAttrList();
742 sal_uLong nCount = rList.Count();
743
744 SvNumberIdentifier slotId = rBase.aStructSlotId;
745 if ( GetSlotId().Len() )
746 rBase.aStructSlotId = GetSlotId();
747
748 // Offizielle Hack-Schnittstelle von MM: spezielle Schalter werden "uber
749 // die WriteAttribute "ubergeben
750 if ( GetReadonly() )
751 nA |= WA_READONLY;
752
753 for( sal_uLong i = 0; i < nCount; i++ )
754 {
755 SvMetaAttribute *pAttr = rList.GetObject( i );
756 if ( nT == WRITE_DOCU )
757 pAttr->SetDescription( GetDescription() );
758 pAttr->Write( rBase, rOutStm, nTab, nT, nA );
759 if( nT == WRITE_ODL && i +1 < nCount )
760 rOutStm << ';' << endl;
761 }
762
763 rBase.aStructSlotId = slotId;
764 }
765
766 /*************************************************************************
767 |* SvMetaAttribute::Write()
768 |*
769 |* Beschreibung
770 *************************************************************************/
Write(SvIdlDataBase & rBase,SvStream & rOutStm,sal_uInt16 nTab,WriteType nT,WriteAttribute nA)771 void SvMetaAttribute::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
772 sal_uInt16 nTab,
773 WriteType nT, WriteAttribute nA )
774 {
775 // keine Attribut fuer Automation
776 if( nT == WRITE_DOCU )
777 {
778 if ( GetHidden() )
779 return;
780 }
781 else if ( !GetAutomation() || !GetExport() )
782 return;
783
784 sal_Bool bVariable;
785 if( nA & WA_VARIABLE )
786 bVariable = sal_True;
787 else if( nA & WA_METHOD )
788 bVariable = sal_False;
789 else
790 bVariable = IsVariable();
791
792 SvMetaType * pType = GetType();
793 DBG_ASSERT( pType, "no type for attribute" );
794 SvMetaType * pBaseType = pType->GetBaseType();
795 DBG_ASSERT( pBaseType, "no base type for attribute" );
796 int nBType = pBaseType->GetType();
797
798 if( nT == WRITE_ODL )
799 {
800 if( (bVariable && IsVariable()) || (!bVariable && IsMethod()) )
801 {
802 if( nBType == TYPE_STRUCT )
803 WriteRecursiv_Impl( rBase, rOutStm, nTab, nT, nA );
804 else
805 {
806 SvMetaReference::Write( rBase, rOutStm, nTab, nT, nA );
807 WriteTab( rOutStm, nTab );
808 pBaseType->WriteTypePrefix( rBase, rOutStm, nTab, nT );
809
810 if( GetName().Len() )
811 {
812 rOutStm << ' ';
813 rOutStm << GetName().GetBuffer();
814 }
815 if( pType->GetType() == TYPE_METHOD )
816 pType->WriteMethodArgs( rBase, rOutStm, nTab, nT );
817 }
818 }
819 }
820 else if( nT == WRITE_C_HEADER || nT == WRITE_C_SOURCE )
821 {
822 if( !bVariable && IsMethod() )
823 {
824 ByteString name; // (rBase.GetActModulePrefix());
825 name += rBase.aIFaceName;
826 name += GetName();
827 const char * pName = name.GetBuffer();
828 // Beispiel
829 // void SetPosSize( C_Object *, C_Rectangle * );
830 WriteTab( rOutStm, nTab );
831 pBaseType->WriteTypePrefix( rBase, rOutStm, nTab, nT );
832 // rOutStm << " SYSCALL";
833 rOutStm << ' ' << pName;
834 pType->WriteMethodArgs( rBase, rOutStm, nTab, nT );
835 if( nT == WRITE_C_HEADER )
836 rOutStm << ';' << endl << endl;
837 else
838 WriteCSource( rBase, rOutStm, sal_False );
839 }
840 else if ( bVariable && IsVariable() )
841 {
842 if( nBType == TYPE_STRUCT )
843 {
844 // Zur Hilfe den Namen des Properties als Kommentar ausgeben
845 rOutStm << "/* " << GetName().GetBuffer() << " */" << endl;
846
847 WriteRecursiv_Impl( rBase, rOutStm, nTab, nT, nA );
848 }
849 else
850 {
851 // Beispiel
852 // void SetValue( C_Object *, sal_uInt16 n );
853 ByteString name = GetName();
854
855 sal_Bool bReadonly = GetReadonly() || ( nA & WA_READONLY );
856 if ( !bReadonly && !IsMethod() )
857 {
858 // Zuweisung
859 WriteTab( rOutStm, nTab );
860 rOutStm << "void ";
861 // rOutStm << "SYSCALL ";
862 // if ( rBase.GetActModulePrefix().Len() )
863 // rOutStm << rBase.GetActModulePrefix().GetBuffer();
864 rOutStm << rBase.aIFaceName.GetBuffer()
865 << "Set" << name.GetBuffer() << "( " << C_PREF
866 << "Object h" << rBase.aIFaceName.GetBuffer() << ", " << endl;
867 WriteTab( rOutStm, nTab+1 );
868 pBaseType->WriteTypePrefix( rBase, rOutStm, nTab, nT );
869 rOutStm << ' ' << name.GetBuffer() << " )";
870 if( nT == WRITE_C_HEADER )
871 rOutStm << ';' << endl << endl;
872 else
873 WriteCSource( rBase, rOutStm, sal_True );
874 }
875
876 // Zugriff
877 WriteTab( rOutStm, nTab );
878 pBaseType->WriteTypePrefix( rBase, rOutStm, nTab, nT );
879 rOutStm << ' ';
880 // rOutStm << "SYSCALL ";
881 // if ( rBase.GetActModulePrefix().Len() )
882 // rOutStm << rBase.GetActModulePrefix().GetBuffer();
883 rOutStm << rBase.aIFaceName.GetBuffer()
884 << "Get" << name.GetBuffer() << "( " << C_PREF
885 << "Object h" << rBase.aIFaceName.GetBuffer() << " )";
886 if( nT == WRITE_C_HEADER )
887 rOutStm << ';' << endl << endl;
888 else
889 WriteCSource( rBase, rOutStm, sal_False );
890 }
891 }
892 }
893 else if ( nT == WRITE_DOCU )
894 {
895 if( !bVariable && IsMethod() )
896 {
897 rOutStm << "<METHOD>" << endl
898 << GetSlotId().GetBuffer() << endl
899 << GetName().GetBuffer() << endl
900 << endl; // readonly
901
902 // Returntype
903 SvMetaType* pType2 = GetType();
904 SvMetaType* pBaseType2 = pType2->GetBaseType();
905 rOutStm << pBaseType2->GetReturnType()->GetBaseType()->GetBasicName().GetBuffer() << endl;
906
907 DBG_ASSERT( pBaseType2->GetReturnType()->GetBaseType()->GetBasicName().Len(),
908 "Leerer BasicName" );
909
910 // Syntax
911 rOutStm << GetName().GetBuffer();
912 pType2->WriteMethodArgs( rBase, rOutStm, nTab, nT );
913
914 // C-Returntype
915 pBaseType2->WriteTypePrefix( rBase, rOutStm, 0, WRITE_C_HEADER );
916 rOutStm << endl;
917
918 // Bei Methoden auch C-Syntax
919 rOutStm << "<C-SYNTAX>" << endl;
920 Write( rBase, rOutStm, 0, WRITE_C_HEADER, nA );
921 rOutStm << "</C-SYNTAX>" << endl;
922
923 // Description
924 WriteDescription( rOutStm );
925 rOutStm << "</METHOD>" << endl << endl;
926 }
927 else if( bVariable && IsVariable() )
928 {
929 if( nBType == TYPE_STRUCT )
930 {
931 WriteRecursiv_Impl( rBase, rOutStm, nTab, nT, nA );
932 }
933 else
934 {
935 rOutStm << "<PROPERTY>" << endl
936 << GetSlotId().GetBuffer() << endl
937 << GetName().GetBuffer() << endl;
938 if ( GetReadonly() )
939 rOutStm << "(nur lesen)" << endl;
940 else
941 rOutStm << endl;
942
943 // Bei properties Type anstelle des return value
944 rOutStm << pBaseType->GetBasicName().GetBuffer() << endl;
945
946 DBG_ASSERT( pBaseType->GetBasicName().Len(),
947 "Leerer BasicName" );
948
949 // Bei properties keine Syntax
950 rOutStm << endl;
951
952 // C-Returntype
953 pBaseType->WriteTypePrefix( rBase, rOutStm, 0, WRITE_C_HEADER );
954 rOutStm << endl;
955
956 // Description
957 WriteDescription( rOutStm );
958 rOutStm << "</PROPERTY>" << endl << endl;
959 }
960 }
961 }
962 }
963
964 /*************************************************************************
965 |* SvMetaAttribute::MakeSfx()
966 |*
967 |* Beschreibung
968 *************************************************************************/
MakeSfx(ByteString * pAttrArray)969 sal_uLong SvMetaAttribute::MakeSfx( ByteString * pAttrArray )
970 {
971 SvMetaType * pType = GetType();
972 DBG_ASSERT( pType, "no type for attribute" );
973 SvMetaType * pBaseType = pType->GetBaseType();
974 DBG_ASSERT( pBaseType, "no base type for attribute" );
975 if( pBaseType->GetType() == TYPE_STRUCT )
976 return pBaseType->MakeSfx( pAttrArray );
977 else
978 {
979 *pAttrArray += '{';
980 *pAttrArray += GetSlotId();
981 *pAttrArray += ",\"";
982 *pAttrArray += GetName();
983 *pAttrArray += "\"}";
984 return 1;
985 }
986 }
987
Insert(SvSlotElementList &,const ByteString &,SvIdlDataBase &)988 void SvMetaAttribute::Insert (SvSlotElementList&, const ByteString &, SvIdlDataBase&)
989 {
990 }
991
992 /*************************************************************************
993 |* SvMetaAttribute::WriteSrc()
994 |*
995 |* Beschreibung
996 *************************************************************************/
WriteSrc(SvIdlDataBase &,SvStream &,Table *)997 void SvMetaAttribute::WriteSrc( SvIdlDataBase &, SvStream &, Table * )
998 {
999 }
1000
WriteHelpId(SvIdlDataBase &,SvStream &,Table *)1001 void SvMetaAttribute::WriteHelpId( SvIdlDataBase &, SvStream &, Table * )
1002 {
1003 }
1004
1005 #endif // IDL_COMPILER
1006
1007 /****************** SvMetaType *************************************/
1008 /************************************************************************/
1009 SV_IMPL_META_FACTORY1( SvMetaType, SvMetaExtern );
1010 /*************************************************************************
1011 |* SvMetaType::SvMetaType()
1012 |*
1013 |* Beschreibung
1014 *************************************************************************/
1015 #define CTOR \
1016 : aCall0( CALL_VALUE, sal_False ) \
1017 , aCall1( CALL_VALUE, sal_False ) \
1018 , aSbxDataType( 0, sal_False ) \
1019 , pAttrList( NULL ) \
1020 , nType( TYPE_BASE ) \
1021 , bIsItem( sal_False ) \
1022 , bIsShell( sal_False ) \
1023 , cParserChar( 'h' )
1024
SvMetaType()1025 SvMetaType::SvMetaType()
1026 CTOR
1027 {
1028 }
1029
SvMetaType(const ByteString & rName,char cPC,const ByteString & rCName)1030 SvMetaType::SvMetaType( const ByteString & rName, char cPC,
1031 const ByteString & rCName )
1032 CTOR
1033 {
1034 SetName( rName );
1035 cParserChar = cPC;
1036 aCName = rCName;
1037 }
1038
SvMetaType(const ByteString & rName,const ByteString & rSbxName,const ByteString & rOdlName,char cPc,const ByteString & rCName,const ByteString & rBasicName,const ByteString & rBasicPostfix)1039 SvMetaType::SvMetaType( const ByteString & rName,
1040 const ByteString & rSbxName,
1041 const ByteString & rOdlName,
1042 char cPc,
1043 const ByteString & rCName,
1044 const ByteString & rBasicName,
1045 const ByteString & rBasicPostfix )
1046 CTOR
1047 {
1048 // aSbxDataType = (int)nT;
1049 SetName( rName );
1050 aSbxName = rSbxName;
1051 aOdlName = rOdlName;
1052 cParserChar = cPc;
1053 aCName = rCName;
1054 aBasicName = rBasicName;
1055 aBasicPostfix = rBasicPostfix;
1056 }
1057
Load(SvPersistStream & rStm)1058 void SvMetaType::Load( SvPersistStream & rStm )
1059 {
1060 SvMetaExtern::Load( rStm );
1061
1062 sal_uInt16 nMask;
1063 rStm >> nMask;
1064 if( nMask & 0x0001 ) rStm >> aIn;
1065 if( nMask & 0x0002 ) rStm >> aOut;
1066 if( nMask & 0x0004 ) rStm >> aCall0;
1067 if( nMask & 0x0008 ) rStm >> aCall1;
1068 if( nMask & 0x0010 ) rStm >> aSbxDataType;
1069 if( nMask & 0x0020 ) rStm >> aSvName;
1070 if( nMask & 0x0040 ) rStm >> aSbxName;
1071 if( nMask & 0x0080 ) rStm >> aOdlName;
1072 if( nMask & 0x0100 ) rStm >> GetAttrList();
1073 if( nMask & 0x0200 ) bIsItem = sal_True;
1074 if( nMask & 0x0400 ) bIsShell = sal_True;
1075 if( nMask & 0x0800 )
1076 {
1077 sal_uInt16 nT;
1078 rStm >> nT;
1079 nType = nT;
1080 }
1081 if( nMask & 0x1000 ) rStm >> cParserChar;
1082 if( nMask & 0x2000 ) rStm >> aCName;
1083 if( nMask & 0x4000 ) rStm >> aBasicName;
1084 if( nMask & 0x8000 ) rStm >> aBasicPostfix;
1085 }
1086
Save(SvPersistStream & rStm)1087 void SvMetaType::Save( SvPersistStream & rStm )
1088 {
1089 SvMetaExtern::Save( rStm );
1090
1091 // Maske erstellen
1092 sal_uInt16 nMask = 0;
1093 if( aIn.IsSet() ) nMask |= 0x0001;
1094 if( aOut.IsSet() ) nMask |= 0x0002;
1095 if( aCall0.IsSet() ) nMask |= 0x0004;
1096 if( aCall1.IsSet() ) nMask |= 0x0008;
1097 if( aSbxDataType.IsSet() ) nMask |= 0x0010;
1098 if( aSvName.IsSet() ) nMask |= 0x0020;
1099 if( aSbxName.IsSet() ) nMask |= 0x0040;
1100 if( aOdlName.IsSet() ) nMask |= 0x0080;
1101 if( GetAttrCount() ) nMask |= 0x0100;
1102 if( bIsItem ) nMask |= 0x0200;
1103 if( bIsShell ) nMask |= 0x0400;
1104 if( nType != TYPE_BASE ) nMask |= 0x0800;
1105 if( cParserChar != 'h' ) nMask |= 0x1000;
1106 if( aCName.IsSet() ) nMask |= 0x2000;
1107 if( aBasicName.IsSet() ) nMask |= 0x4000;
1108 if( aBasicPostfix.IsSet() ) nMask |= 0x8000;
1109
1110 // Daten schreiben
1111 rStm << nMask;
1112 if( nMask & 0x0001 ) rStm << aIn;
1113 if( nMask & 0x0002 ) rStm << aOut;
1114 if( nMask & 0x0004 ) rStm << aCall0;
1115 if( nMask & 0x0008 ) rStm << aCall1;
1116 if( nMask & 0x0010 ) rStm << aSbxDataType;
1117 if( nMask & 0x0020 ) rStm << aSvName;
1118 if( nMask & 0x0040 ) rStm << aSbxName;
1119 if( nMask & 0x0080 ) rStm << aOdlName;
1120 if( nMask & 0x0100 ) rStm << *pAttrList;
1121 if( nMask & 0x0800 ) rStm << (sal_uInt16)nType;
1122 if( nMask & 0x1000 ) rStm << cParserChar;
1123 if( nMask & 0x2000 ) rStm << aCName;
1124 if( nMask & 0x4000 ) rStm << aBasicName;
1125 if( nMask & 0x8000 ) rStm << aBasicPostfix;
1126 }
1127
1128 /*************************************************************************
1129 |* SvMetaType::GetAttrList()
1130 |*
1131 |* Beschreibung
1132 *************************************************************************/
GetAttrList() const1133 SvMetaAttributeMemberList & SvMetaType::GetAttrList() const
1134 {
1135 if( !pAttrList )
1136 ((SvMetaType *)this)->pAttrList = new SvMetaAttributeMemberList();
1137 return *pAttrList;
1138 }
1139
1140 /*************************************************************************
1141 |* SvMetaType::SetType()
1142 |*
1143 |* Beschreibung
1144 *************************************************************************/
SetType(int nT)1145 void SvMetaType::SetType( int nT )
1146 {
1147 nType = nT;
1148 if( nType == TYPE_ENUM )
1149 {
1150 aOdlName = "short";
1151 // aSbxDataType = SbxINTEGER;
1152 }
1153 else if( nType == TYPE_CLASS )
1154 {
1155 aCName = C_PREF;
1156 aCName += "Object *";
1157 }
1158 }
1159
1160 /*************************************************************************
1161 |* SvMetaType::GetBaseType()
1162 |*
1163 |* Beschreibung
1164 *************************************************************************/
GetBaseType() const1165 SvMetaType * SvMetaType::GetBaseType() const
1166 {
1167 if( GetRef() && GetType() == TYPE_BASE )
1168 return ((SvMetaType *)GetRef())->GetBaseType();
1169 return (SvMetaType *)this;
1170 }
1171
1172 /*************************************************************************
1173 |* SvMetaType::GetReturnType()
1174 |*
1175 |* Beschreibung
1176 *************************************************************************/
GetReturnType() const1177 SvMetaType * SvMetaType::GetReturnType() const
1178 {
1179 DBG_ASSERT( GetType() == TYPE_METHOD, "no method" );
1180 DBG_ASSERT( GetRef(), "no return type" );
1181 return (SvMetaType *)GetRef();
1182 }
1183
1184 /*************************************************************************
1185 |* SvMetaType::GetSbxDataType()
1186 |*
1187 |* Beschreibung
1188 *************************************************************************/
1189 /*
1190 SbxDataType SvMetaType::GetSbxDataType() const
1191 {
1192 if( aSbxDataType.IsSet() || !GetRef() )
1193 return (SbxDataType)(int)aSbxDataType;
1194 else
1195 return ((SvMetaType *)GetRef())->GetSbxDataType();
1196 }
1197 */
1198 /*************************************************************************
1199 |* SvMetaType::GetBasicName()
1200 |*
1201 |* Beschreibung
1202 *************************************************************************/
GetBasicName() const1203 const ByteString& SvMetaType::GetBasicName() const
1204 {
1205 if( aBasicName.IsSet() || !GetRef() )
1206 return aBasicName;
1207 else
1208 return ((SvMetaType*)GetRef())->GetBasicName();
1209 }
1210
1211 /*************************************************************************
1212 |* SvMetaType::GetBasicPostfix()
1213 |*
1214 |* Beschreibung
1215 *************************************************************************/
GetBasicPostfix() const1216 ByteString SvMetaType::GetBasicPostfix() const
1217 {
1218
1219 ByteString aRet;
1220
1221 // MBN und Co wollen immer "As xxx"
1222 /*
1223 if( aBasicPostfix.IsSet() || !GetRef() )
1224 aRet = aBasicPostfix;
1225 else
1226 aRet = ((SvMetaType*)GetRef())->GetBasicPostfix();
1227
1228 if ( !aRet.Len() && GetBasicName().Len() )
1229 */
1230 {
1231
1232 aRet = " As ";
1233 aRet += GetBasicName();
1234 }
1235
1236 return aRet;
1237 }
1238
1239 /*************************************************************************
1240 |* SvMetaType::GetIn()
1241 |*
1242 |* Beschreibung
1243 *************************************************************************/
GetIn() const1244 sal_Bool SvMetaType::GetIn() const
1245 {
1246 if( aIn.IsSet() || !GetRef() )
1247 return aIn;
1248 else
1249 return ((SvMetaType *)GetRef())->GetIn();
1250 }
1251
1252 /*************************************************************************
1253 |* SvMetaType::GetOut()
1254 |*
1255 |* Beschreibung
1256 *************************************************************************/
GetOut() const1257 sal_Bool SvMetaType::GetOut() const
1258 {
1259 if( aOut.IsSet() || !GetRef() )
1260 return aOut;
1261 else
1262 return ((SvMetaType *)GetRef())->GetOut();
1263 }
1264
1265 /*************************************************************************
1266 |* SvMetaType::SetCall0()
1267 |*
1268 |* Beschreibung
1269 *************************************************************************/
SetCall0(int e)1270 void SvMetaType::SetCall0( int e )
1271 {
1272 aCall0 = (int)e;
1273 if( aCall0 == CALL_VALUE && aCall1 == CALL_VALUE )
1274 {
1275 if( GetType() == TYPE_POINTER )
1276 SetType( TYPE_BASE );
1277 }
1278 else
1279 {
1280 DBG_ASSERT( nType == TYPE_POINTER || nType == TYPE_BASE,
1281 "set no base type to pointer" );
1282 SetType( TYPE_POINTER );
1283 }
1284 }
1285
1286 /*************************************************************************
1287 |* SvMetaType::GetCall0()
1288 |*
1289 |* Beschreibung
1290 *************************************************************************/
GetCall0() const1291 int SvMetaType::GetCall0() const
1292 {
1293 if( aCall0.IsSet() || !GetRef() )
1294 return aCall0;
1295 else
1296 return ((SvMetaType *)GetRef())->GetCall0();
1297 }
1298
1299 /*************************************************************************
1300 |* SvMetaType::SetCall1()
1301 |*
1302 |* Beschreibung
1303 *************************************************************************/
SetCall1(int e)1304 void SvMetaType::SetCall1( int e )
1305 {
1306 aCall1 = (int)e;
1307 if( aCall0 == CALL_VALUE && aCall1 == CALL_VALUE )
1308 {
1309 if( GetType() == TYPE_POINTER )
1310 SetType( TYPE_BASE );
1311 }
1312 else
1313 {
1314 DBG_ASSERT( nType == TYPE_POINTER || nType == TYPE_BASE,
1315 "set no base type to pointer" );
1316 SetType( TYPE_POINTER );
1317 }
1318 }
1319
1320 /*************************************************************************
1321 |* SvMetaType::GetCall1()
1322 |*
1323 |* Beschreibung
1324 *************************************************************************/
GetCall1() const1325 int SvMetaType::GetCall1() const
1326 {
1327 if( aCall1.IsSet() || !GetRef() )
1328 return aCall1;
1329 else
1330 return ((SvMetaType *)GetRef())->GetCall1();
1331 }
1332
1333 /*************************************************************************
1334 |* SvMetaType::GetSvName()
1335 |*
1336 |* Beschreibung
1337 *************************************************************************/
GetSvName() const1338 const ByteString & SvMetaType::GetSvName() const
1339 {
1340 if( aSvName.IsSet() || !GetRef() )
1341 return aSvName;
1342 else
1343 return ((SvMetaType *)GetRef())->GetSvName();
1344 }
1345
1346 /*************************************************************************
1347 |* SvMetaType::GetSbxName()
1348 |*
1349 |* Beschreibung
1350 *************************************************************************/
GetSbxName() const1351 const ByteString & SvMetaType::GetSbxName() const
1352 {
1353 if( aSbxName.IsSet() || !GetRef() )
1354 return aSbxName;
1355 else
1356 return ((SvMetaType *)GetRef())->GetSbxName();
1357 }
1358
1359 /*************************************************************************
1360 |* SvMetaType::GetOdlName()
1361 |*
1362 |* Beschreibung
1363 *************************************************************************/
GetOdlName() const1364 const ByteString & SvMetaType::GetOdlName() const
1365 {
1366 if( aOdlName.IsSet() || !GetRef() )
1367 return aOdlName;
1368 else
1369 return ((SvMetaType *)GetRef())->GetOdlName();
1370 }
1371
1372 /*************************************************************************
1373 |* SvMetaType::GetCName()
1374 |*
1375 |* Beschreibung
1376 *************************************************************************/
GetCName() const1377 const ByteString & SvMetaType::GetCName() const
1378 {
1379 if( aCName.IsSet() || !GetRef() )
1380 return aCName;
1381 else
1382 return ((SvMetaType *)GetRef())->GetCName();
1383 }
1384
1385 /*************************************************************************
1386 |* SvMetaType::SetName()
1387 |*
1388 |* Beschreibung
1389 *************************************************************************/
SetName(const ByteString & rName,SvIdlDataBase * pBase)1390 sal_Bool SvMetaType::SetName( const ByteString & rName, SvIdlDataBase * pBase )
1391 {
1392 aSvName = rName;
1393 aSbxName = rName;
1394 aCName = rName;
1395 if( GetType() != TYPE_ENUM )
1396 aOdlName = rName;
1397 return SvMetaReference::SetName( rName, pBase );
1398 }
1399
1400 /*************************************************************************
1401 |* SvMetaType::FillSbxObject()
1402 |*
1403 |* Beschreibung
1404 *************************************************************************/
1405 /*
1406 void SvMetaType::FillSbxObject( SbxVariable * pObj, sal_Bool bVariable )
1407 {
1408 if( PTR_CAST( SbxMethod, pObj ) )
1409 {
1410 if( GetType() == TYPE_METHOD )
1411 {
1412 sal_uLong nCount = GetAttrCount();
1413 if( nCount )
1414 {
1415 SbxInfoRef xInfo = pObj->GetInfo();
1416 if( !xInfo.Is() )
1417 {
1418 xInfo = new SbxInfo();
1419 pObj->SetInfo( xInfo );
1420 }
1421 for( sal_uLong n = nCount; n > 0; n-- )
1422 pAttrList->GetObject( n -1 )->FillSbxObject( xInfo );
1423 }
1424 }
1425 }
1426 }
1427 */
1428 #ifdef IDL_COMPILER
1429 /*************************************************************************
1430 |* SvMetaType::GetString()
1431 |*
1432 |* Beschreibung
1433 *************************************************************************/
GetCString() const1434 ByteString SvMetaType::GetCString() const
1435 {
1436 ByteString out( GetSvName() );
1437 if( aCall0 == (int)CALL_POINTER )
1438 out += " *";
1439 else if( aCall0 == (int)CALL_REFERENCE )
1440 out += " &";
1441 if( aCall1 == (int)CALL_POINTER )
1442 out += '*';
1443 else if( aCall1 == (int)CALL_REFERENCE )
1444 out += '&';
1445 return out;
1446 }
1447
1448 /*************************************************************************
1449 |* SvMetaType::ReadHeaderSvIdl()
1450 |*
1451 |* Beschreibung
1452 *************************************************************************/
ReadHeaderSvIdl(SvIdlDataBase & rBase,SvTokenStream & rInStm)1453 sal_Bool SvMetaType::ReadHeaderSvIdl( SvIdlDataBase & rBase,
1454 SvTokenStream & rInStm )
1455 {
1456 sal_Bool bOk = sal_False;
1457 sal_uInt32 nTokPos = rInStm.Tell();
1458 SvToken * pTok = rInStm.GetToken_Next();
1459
1460 if( pTok->Is( SvHash_interface() )
1461 || pTok->Is( SvHash_shell() ) )
1462 {
1463 if( pTok->Is( SvHash_shell() ) )
1464 bIsShell = sal_True;
1465 SetType( TYPE_CLASS );
1466 bOk = ReadNamesSvIdl( rBase, rInStm );
1467
1468 }
1469 else if( pTok->Is( SvHash_struct() ) )
1470 {
1471 SetType( TYPE_STRUCT );
1472 bOk = ReadNamesSvIdl( rBase, rInStm );
1473 }
1474 else if( pTok->Is( SvHash_union() ) )
1475 {
1476 SetType( TYPE_UNION );
1477 if( ReadNameSvIdl( rBase, rInStm ) )
1478 return sal_True;
1479 }
1480 else if( pTok->Is( SvHash_enum() ) )
1481 {
1482 SetType( TYPE_ENUM );
1483 bOk = ReadNameSvIdl( rBase, rInStm );
1484 }
1485 else if( pTok->Is( SvHash_typedef() )
1486 || pTok->Is( SvHash_item() ) )
1487 {
1488 if( pTok->Is( SvHash_item() ) )
1489 bIsItem = sal_True;
1490
1491 SvMetaType * pType = rBase.ReadKnownType( rInStm );
1492 if( pType )
1493 {
1494 SetRef( pType );
1495 if( ReadNameSvIdl( rBase, rInStm ) )
1496 {
1497 /* // um aufwaertskompatibel zu bleiben
1498 aOdlName = pType->GetOdlName();
1499 */
1500 if( rInStm.Read( '(' ) )
1501 {
1502 //DoReadContextSvIdl( rBase, rInStm, ',' );
1503 DoReadContextSvIdl( rBase, rInStm );
1504 if( rInStm.Read( ')' ) )
1505 {
1506 SetType( TYPE_METHOD );
1507 bOk = sal_True;
1508 }
1509 }
1510 else
1511 {
1512 bOk = sal_True;
1513 }
1514 }
1515 }
1516 else
1517 {
1518 ByteString aStr = "wrong typedef: ";
1519 rBase.SetError( aStr, rInStm.GetToken() );
1520 rBase.WriteError( rInStm );
1521 }
1522 }
1523 if( bOk )
1524 SetModule( rBase );
1525 else
1526 rInStm.Seek( nTokPos );
1527 return bOk;
1528 }
1529
1530 /*************************************************************************
1531 |* SvMetaType::ReadSvIdl()
1532 |*
1533 |* Beschreibung
1534 *************************************************************************/
ReadSvIdl(SvIdlDataBase & rBase,SvTokenStream & rInStm)1535 sal_Bool SvMetaType::ReadSvIdl( SvIdlDataBase & rBase,
1536 SvTokenStream & rInStm )
1537 {
1538 if( ReadHeaderSvIdl( rBase, rInStm ) )
1539 {
1540 rBase.Write( '.' );
1541 return SvMetaExtern::ReadSvIdl( rBase, rInStm );
1542 }
1543 return sal_False;
1544 }
1545
1546 /*************************************************************************
1547 |* SvMetaType::WriteSvIdl()
1548 |*
1549 |* Beschreibung
1550 *************************************************************************/
WriteSvIdl(SvIdlDataBase & rBase,SvStream & rOutStm,sal_uInt16 nTab)1551 void SvMetaType::WriteSvIdl
1552 (
1553 SvIdlDataBase & rBase,
1554 SvStream & rOutStm,
1555 sal_uInt16 nTab
1556 )
1557 {
1558 WriteHeaderSvIdl( rBase, rOutStm, nTab );
1559 if( GetType() == TYPE_METHOD )
1560 WriteMethodArgs( rBase, rOutStm, nTab, WRITE_IDL );
1561
1562 sal_uLong nOldPos = rOutStm.Tell();
1563 rOutStm << endl;
1564 SvMetaExtern::WriteSvIdl( rBase, rOutStm, nTab );
1565 if( TestAndSeekSpaceOnly( rOutStm, nOldPos ) )
1566 // nichts geschrieben
1567 rOutStm.Seek( nOldPos );
1568 rOutStm << ';' << endl;
1569 }
1570
1571 /*************************************************************************
1572 |* SvMetaType::WriteContext()
1573 |*
1574 |* Beschreibung
1575 *************************************************************************/
WriteContext(SvIdlDataBase & rBase,SvStream & rOutStm,sal_uInt16 nTab,WriteType nT,WriteAttribute nA)1576 void SvMetaType::WriteContext( SvIdlDataBase & rBase, SvStream & rOutStm,
1577 sal_uInt16 nTab,
1578 WriteType nT, WriteAttribute nA )
1579 {
1580 if( GetAttrCount() )
1581 {
1582 SvMetaAttribute * pAttr = pAttrList->First();
1583 while( pAttr )
1584 {
1585 pAttr->Write( rBase, rOutStm, nTab, nT, nA );
1586 if( GetType() == TYPE_METHOD )
1587 rOutStm << ',' << endl;
1588 else
1589 rOutStm << ';' << endl;
1590 pAttr = pAttrList->Next();
1591 }
1592 }
1593 }
1594
1595 /*************************************************************************
1596 |* SvMetaType::Write()
1597 |*
1598 |* Beschreibung
1599 *************************************************************************/
Write(SvIdlDataBase & rBase,SvStream & rOutStm,sal_uInt16 nTab,WriteType nT,WriteAttribute nA)1600 void SvMetaType::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
1601 sal_uInt16 nTab,
1602 WriteType nT, WriteAttribute nA )
1603 {
1604 if( nT == WRITE_C_HEADER && nType != TYPE_ENUM )
1605 // nur enum schreiben
1606 return;
1607
1608 ByteString name = GetName();
1609 if( nT == WRITE_ODL || nT == WRITE_C_HEADER || nT == WRITE_CXX_HEADER )
1610 {
1611 switch( nType )
1612 {
1613 case TYPE_CLASS:
1614 {
1615 }
1616 break;
1617 case TYPE_STRUCT:
1618 case TYPE_UNION:
1619 case TYPE_ENUM:
1620 {
1621 WriteStars( rOutStm );
1622 if( nType == TYPE_STRUCT || nType == TYPE_UNION )
1623 nA = WA_STRUCT;
1624
1625 if( nT == WRITE_ODL || nT == WRITE_C_HEADER)
1626 {
1627 if ( nT == WRITE_C_HEADER )
1628 {
1629 ByteString aStr = name;
1630 aStr.ToUpperAscii();
1631 rOutStm << "#ifndef " << C_PREF << aStr.GetBuffer() << "_DEF " << endl;
1632 rOutStm << "#define " << C_PREF << aStr.GetBuffer() << "_DEF " << endl;
1633 }
1634
1635 WriteTab( rOutStm, nTab );
1636 rOutStm << "typedef" << endl;
1637 if ( nT == WRITE_ODL )
1638 SvMetaName::Write( rBase, rOutStm, nTab, nT, nA );
1639 }
1640 WriteTab( rOutStm, nTab );
1641 if( nType == TYPE_STRUCT )
1642 rOutStm << "struct";
1643 else if( nType == TYPE_UNION )
1644 rOutStm << "union";
1645 else
1646 rOutStm << "enum";
1647 if( nT != WRITE_ODL && nT != WRITE_C_HEADER)
1648 rOutStm << ' ' << name.GetBuffer();
1649
1650 rOutStm << endl;
1651 WriteTab( rOutStm, nTab );
1652 rOutStm << '{' << endl;
1653 WriteContext( rBase, rOutStm, nTab +1, nT, nA );
1654 WriteTab( rOutStm, nTab );
1655 rOutStm << '}';
1656 if( nT == WRITE_ODL || nT == WRITE_C_HEADER )
1657 {
1658 rOutStm << ' ' << C_PREF << name.GetBuffer();
1659 }
1660 rOutStm << ';' << endl;
1661
1662 if ( nT == WRITE_C_HEADER )
1663 rOutStm << "#endif";
1664 rOutStm << endl;
1665 }
1666 break;
1667 case TYPE_POINTER:
1668 case TYPE_BASE:
1669 {
1670 }
1671 break;
1672 case TYPE_METHOD:
1673 {
1674 }
1675 break;
1676 }
1677 }
1678 }
1679
1680 /*************************************************************************
1681 |* SvMetaType::ReadNamesSvIdl()
1682 |*
1683 |* Beschreibung
1684 *************************************************************************/
ReadNamesSvIdl(SvIdlDataBase & rBase,SvTokenStream & rInStm)1685 sal_Bool SvMetaType::ReadNamesSvIdl( SvIdlDataBase & rBase,
1686 SvTokenStream & rInStm )
1687 {
1688 sal_Bool bOk = ReadNameSvIdl( rBase, rInStm );
1689 /*
1690 if( bOk )
1691 {
1692 sal_uInt32 nTokPos = rInStm.Tell();
1693 SvToken * pTok = rInStm.GetToken_Next();
1694
1695 if( pTok->IsIdentifier() )
1696 {
1697 aSbxName = pTok->GetString();
1698
1699 nTokPos = rInStm.Tell();
1700 pTok = rInStm.GetToken_Next();
1701 if( pTok->IsIdentifier() )
1702 {
1703 aItemName = pTok->GetString();
1704 nTokPos = rInStm.Tell();
1705 }
1706 }
1707 rInStm.Seek( nTokPos );
1708 }
1709 */
1710 return bOk;
1711 }
1712
1713 /*************************************************************************
1714 |* SvMetaType::WriteHeaderSvIdl()
1715 |*
1716 |* Beschreibung
1717 *************************************************************************/
WriteHeaderSvIdl(SvIdlDataBase & rBase,SvStream & rOutStm,sal_uInt16 nTab)1718 void SvMetaType::WriteHeaderSvIdl( SvIdlDataBase & rBase,
1719 SvStream & rOutStm,
1720 sal_uInt16 nTab )
1721 {
1722 switch( nType )
1723 {
1724 case TYPE_CLASS:
1725 {
1726 if( IsShell() )
1727 rOutStm << SvHash_shell()->GetName().GetBuffer();
1728 else
1729 rOutStm << SvHash_interface()->GetName().GetBuffer();
1730 rOutStm << ' ' << GetName().GetBuffer();
1731 }
1732 break;
1733 case TYPE_STRUCT:
1734 {
1735 rOutStm << SvHash_struct()->GetName().GetBuffer()
1736 << ' ' << GetName().GetBuffer();
1737 }
1738 break;
1739 case TYPE_UNION:
1740 {
1741 rOutStm << SvHash_union()->GetName().GetBuffer()
1742 << ' ' << GetName().GetBuffer();
1743 }
1744 break;
1745 case TYPE_ENUM:
1746 {
1747 rOutStm << SvHash_enum()->GetName().GetBuffer()
1748 << ' ' << GetName().GetBuffer();
1749 }
1750 break;
1751 case TYPE_POINTER:
1752 case TYPE_BASE:
1753 {
1754 if( IsItem() )
1755 rOutStm << SvHash_item()->GetName().GetBuffer() << ' ';
1756 else
1757 rOutStm << SvHash_typedef()->GetName().GetBuffer() << ' ';
1758 if( GetRef() )
1759 {
1760 ((SvMetaType *)GetRef())->WriteTheType( rBase, rOutStm, nTab, WRITE_IDL );
1761 rOutStm << ' ';
1762 }
1763 rOutStm << GetName().GetBuffer();
1764 }
1765 break;
1766 case TYPE_METHOD:
1767 {
1768 rOutStm << SvHash_typedef()->GetName().GetBuffer() << ' ';
1769 ((SvMetaType *)GetRef())->WriteTheType( rBase, rOutStm, nTab, WRITE_IDL );
1770 rOutStm << ' ' << GetName().GetBuffer() << "( ";
1771 WriteContextSvIdl( rBase, rOutStm, nTab );
1772 rOutStm << " )";
1773 }
1774 break;
1775 }
1776 }
1777
1778 /*************************************************************************
1779 |* SvMetaType::ReadAttributesSvIdl()
1780 |*
1781 |* Beschreibung
1782 *************************************************************************/
ReadAttributesSvIdl(SvIdlDataBase & rBase,SvTokenStream & rInStm)1783 void SvMetaType::ReadAttributesSvIdl( SvIdlDataBase & rBase,
1784 SvTokenStream & rInStm )
1785 {
1786 SvMetaExtern::ReadAttributesSvIdl( rBase, rInStm );
1787 aSvName.ReadSvIdl( SvHash_SvName(), rInStm );
1788 aSbxName.ReadSvIdl( SvHash_SbxName(), rInStm );
1789 aOdlName.ReadSvIdl( SvHash_OdlName(), rInStm );
1790 }
1791
1792 /*************************************************************************
1793 |* SvMetaType::WriteAttributesSvIdl()
1794 |*
1795 |* Beschreibung
1796 *************************************************************************/
WriteAttributesSvIdl(SvIdlDataBase & rBase,SvStream & rOutStm,sal_uInt16 nTab)1797 void SvMetaType::WriteAttributesSvIdl( SvIdlDataBase & rBase,
1798 SvStream & rOutStm,
1799 sal_uInt16 nTab )
1800 {
1801 SvMetaExtern::WriteAttributesSvIdl( rBase, rOutStm, nTab );
1802 ByteString name = GetName();
1803 if( aSvName != name || aSbxName != name || aOdlName != name )
1804 {
1805 WriteTab( rOutStm, nTab );
1806 rOutStm << "class SvMetaType" << endl;
1807 if( aSvName != name )
1808 {
1809 WriteTab( rOutStm, nTab );
1810 aSvName.WriteSvIdl( SvHash_SvName(), rOutStm, nTab );
1811 rOutStm << endl;
1812 }
1813 if( aSbxName != name )
1814 {
1815 WriteTab( rOutStm, nTab );
1816 aSbxName.WriteSvIdl( SvHash_SbxName(), rOutStm, nTab );
1817 rOutStm << endl;
1818 }
1819 if( aOdlName != name )
1820 {
1821 WriteTab( rOutStm, nTab );
1822 aOdlName.WriteSvIdl( SvHash_OdlName(), rOutStm, nTab );
1823 rOutStm << endl;
1824 }
1825 }
1826 }
1827
1828 /*************************************************************************
1829 |* SvMetaType::ReadContextSvIdl()
1830 |*
1831 |* Beschreibung
1832 *************************************************************************/
ReadContextSvIdl(SvIdlDataBase & rBase,SvTokenStream & rInStm)1833 void SvMetaType::ReadContextSvIdl( SvIdlDataBase & rBase,
1834 SvTokenStream & rInStm )
1835 {
1836 SvMetaAttributeRef xAttr = new SvMetaAttribute();
1837 if( xAttr->ReadSvIdl( rBase, rInStm ) )
1838 {
1839 if( xAttr->Test( rBase, rInStm ) )
1840 GetAttrList().Append( xAttr );
1841 }
1842 }
1843
1844 /*************************************************************************
1845 |* SvMetaType::WriteContextSvIdl()
1846 |*
1847 |* Beschreibung
1848 *************************************************************************/
WriteContextSvIdl(SvIdlDataBase & rBase,SvStream & rOutStm,sal_uInt16 nTab)1849 void SvMetaType::WriteContextSvIdl
1850 (
1851 SvIdlDataBase & rBase,
1852 SvStream & rOutStm,
1853 sal_uInt16 nTab
1854 )
1855 {
1856 if( GetAttrCount() )
1857 {
1858 SvMetaAttribute * pAttr = pAttrList->First();
1859 while( pAttr )
1860 {
1861 WriteTab( rOutStm, nTab );
1862 pAttr->WriteSvIdl( rBase, rOutStm, nTab );
1863 if( GetType() == TYPE_METHOD )
1864 rOutStm << ',' << endl;
1865 else
1866 rOutStm << ';' << endl;
1867 pAttr = pAttrList->Next();
1868 }
1869 }
1870 }
1871
1872 /*************************************************************************
1873 |* SvMetaType::WriteAttributes()
1874 |*
1875 |* Beschreibung
1876 *************************************************************************/
WriteAttributes(SvIdlDataBase & rBase,SvStream & rOutStm,sal_uInt16 nTab,WriteType nT,WriteAttribute nA)1877 void SvMetaType::WriteAttributes( SvIdlDataBase & rBase, SvStream & rOutStm,
1878 sal_uInt16 nTab,
1879 WriteType nT, WriteAttribute nA )
1880 {
1881 SvMetaExtern::WriteAttributes( rBase, rOutStm, nTab, nT, nA );
1882 }
1883
1884 /*************************************************************************
1885 |* SvMetaType::MakeSfx()
1886 |*
1887 |* Beschreibung
1888 *************************************************************************/
MakeSfx(ByteString * pAttrArray)1889 sal_uLong SvMetaType::MakeSfx( ByteString * pAttrArray )
1890 {
1891 sal_uLong nC = 0;
1892
1893 if( GetBaseType()->GetType() == TYPE_STRUCT )
1894 {
1895 sal_uLong nAttrCount = GetAttrCount();
1896 // Die einzelnen Attribute schreiben
1897 for( sal_uLong n = 0; n < nAttrCount; n++ )
1898 {
1899 nC += pAttrList->GetObject( n )->MakeSfx( pAttrArray );
1900 if( n +1 < nAttrCount )
1901 *pAttrArray += ", ";
1902 }
1903 }
1904 return nC;
1905 }
1906
WriteSfxItem(const ByteString & rItemName,SvIdlDataBase &,SvStream & rOutStm)1907 void SvMetaType::WriteSfxItem(
1908 const ByteString & rItemName, SvIdlDataBase &, SvStream & rOutStm )
1909 {
1910 WriteStars( rOutStm );
1911 ByteString aVarName = " a";
1912 aVarName += rItemName;
1913 aVarName += "_Impl";
1914
1915 ByteString aTypeName = "SfxType";
1916 ByteString aAttrArray;
1917 sal_uLong nAttrCount = MakeSfx( &aAttrArray );
1918 //sal_uLong nAttrCount = GetAttrCount();
1919 ByteString aAttrCount( ByteString::CreateFromInt32( nAttrCount ) );
1920 aTypeName += aAttrCount;
1921
1922 rOutStm << "extern " << aTypeName.GetBuffer()
1923 << aVarName.GetBuffer() << ';' << endl;
1924
1925 // Den Implementationsteil schreiben
1926 rOutStm << "#ifdef SFX_TYPEMAP" << endl
1927 << aTypeName.GetBuffer() << aVarName.GetBuffer()
1928 << " = " << endl;
1929 rOutStm << '{' << endl
1930 << "\tTYPE(" << rItemName.GetBuffer() << "), "
1931 << aAttrCount.GetBuffer();
1932 if( nAttrCount )
1933 {
1934 rOutStm << ", { ";
1935 // Die einzelnen Attribute schreiben
1936 rOutStm << aAttrArray.GetBuffer();
1937 rOutStm << " }";
1938 }
1939 rOutStm << endl << "};" << endl
1940 << "#endif" << endl << endl;
1941 }
1942
1943 /*************************************************************************
1944 |* SvMetaType::WriteSfx()
1945 |*
1946 |* Beschreibung
1947 *************************************************************************/
WriteSfx(SvIdlDataBase & rBase,SvStream & rOutStm)1948 void SvMetaType::WriteSfx( SvIdlDataBase & rBase, SvStream & rOutStm )
1949 {
1950 if( IsItem() )
1951 {
1952 if( GetBaseType()->GetType() == TYPE_STRUCT )
1953 GetBaseType()->WriteSfxItem( GetName(), rBase, rOutStm );
1954 else
1955 WriteSfxItem( GetName(), rBase, rOutStm );
1956 }
1957 }
1958
1959 /*************************************************************************
1960 |* SvMetaType::ReadMethodArgs()
1961 |*
1962 |* Beschreibung
1963 *************************************************************************/
ReadMethodArgs(SvIdlDataBase & rBase,SvTokenStream & rInStm)1964 sal_Bool SvMetaType::ReadMethodArgs( SvIdlDataBase & rBase,
1965 SvTokenStream & rInStm )
1966 {
1967 sal_uInt32 nTokPos = rInStm.Tell();
1968 if( rInStm.Read( '(' ) )
1969 {
1970 //DoReadContextSvIdl( rBase, rInStm, ',' );
1971 DoReadContextSvIdl( rBase, rInStm );
1972 if( rInStm.Read( ')' ) )
1973 {
1974 SetType( TYPE_METHOD );
1975 return sal_True;
1976 }
1977 }
1978 rInStm.Seek( nTokPos );
1979 return sal_False;
1980 }
1981
1982 /*************************************************************************
1983 |* SvMetaType::WriteMethodArgs()
1984 |*
1985 |* Beschreibung
1986 *************************************************************************/
WriteMethodArgs(SvIdlDataBase & rBase,SvStream & rOutStm,sal_uInt16 nTab,WriteType nT)1987 void SvMetaType::WriteMethodArgs
1988 (
1989 SvIdlDataBase & rBase,
1990 SvStream & rOutStm,
1991 sal_uInt16 nTab, WriteType nT
1992 )
1993 {
1994 if( nT == WRITE_IDL )
1995 {
1996 if( GetAttrCount() )
1997 {
1998 rOutStm << endl;
1999 WriteTab( rOutStm, nTab );
2000 rOutStm << '(' << endl;
2001
2002 SvMetaAttribute * pAttr = pAttrList->First();
2003 while( pAttr )
2004 {
2005 WriteTab( rOutStm, nTab +1 );
2006 pAttr->WriteSvIdl( rBase, rOutStm, nTab +1 );
2007 pAttr = pAttrList->Next();
2008 if( pAttr )
2009 rOutStm << ',' << endl;
2010 }
2011 rOutStm << endl;
2012 WriteTab( rOutStm, nTab );
2013 rOutStm << ')';
2014 }
2015 else
2016 rOutStm << "()";
2017 }
2018 else if ( nT == WRITE_DOCU )
2019 {
2020
2021 rOutStm << '(';
2022 if( GetAttrCount() )
2023 {
2024 SvMetaAttribute * pAttr = pAttrList->First();
2025 while( pAttr )
2026 {
2027 pAttr->WriteParam( rBase, rOutStm, nTab+1, nT );
2028 pAttr = pAttrList->Next();
2029 if( pAttr )
2030 rOutStm << ',';
2031 else
2032 rOutStm << ' ';
2033 }
2034 }
2035 rOutStm << ')' << endl;
2036 }
2037 else
2038 {
2039 rOutStm << '(';
2040 if( nT == WRITE_C_HEADER || nT == WRITE_C_SOURCE )
2041 {
2042 rOutStm << ' ' << C_PREF << "Object h" << rBase.aIFaceName.GetBuffer();
2043 if( GetAttrCount() )
2044 rOutStm << ',';
2045 else
2046 rOutStm << ' ';
2047 }
2048
2049 if( GetAttrCount() )
2050 {
2051 rOutStm << endl;
2052 SvMetaAttribute * pAttr = pAttrList->First();
2053 while( pAttr )
2054 {
2055 switch( nT )
2056 {
2057 case WRITE_C_HEADER:
2058 case WRITE_C_SOURCE:
2059 case WRITE_ODL:
2060 {
2061 pAttr->WriteParam( rBase, rOutStm, nTab +1, nT );
2062 }
2063 break;
2064
2065 default:
2066 {
2067 DBG_ASSERT( sal_False, "WriteType not implemented" );
2068 }
2069 }
2070 pAttr = pAttrList->Next();
2071 if( pAttr )
2072 rOutStm << ',' << endl;
2073 }
2074 if( nT != WRITE_C_HEADER && nT != WRITE_C_SOURCE )
2075 {
2076 rOutStm << endl;
2077 WriteTab( rOutStm, nTab +1 );
2078 }
2079 rOutStm << ' ';
2080 }
2081 rOutStm << ')';
2082 }
2083 }
2084
2085 /*************************************************************************
2086 |* SvMetaType::WriteTypePrefix()
2087 |*
2088 |* Beschreibung
2089 *************************************************************************/
WriteTypePrefix(SvIdlDataBase & rBase,SvStream & rOutStm,sal_uInt16 nTab,WriteType nT)2090 void SvMetaType::WriteTypePrefix( SvIdlDataBase & rBase, SvStream & rOutStm,
2091 sal_uInt16 nTab, WriteType nT )
2092 {
2093 switch( nT )
2094 {
2095 case WRITE_IDL:
2096 {
2097 if( GetIn() && GetOut() )
2098 rOutStm << SvHash_inout()->GetName().GetBuffer() << ' ';
2099 else if( GetIn() )
2100 rOutStm << SvHash_in()->GetName().GetBuffer() << ' ';
2101 else if( GetOut() )
2102 rOutStm << SvHash_out()->GetName().GetBuffer() << ' ';
2103 rOutStm << GetCString().GetBuffer();
2104 }
2105 break;
2106
2107 case WRITE_ODL:
2108 {
2109 sal_Bool bIn = GetIn();
2110 sal_Bool bOut = GetOut();
2111 if( bIn || bOut )
2112 {
2113 if( bIn && bOut )
2114 rOutStm << "[in,out] ";
2115 else if( bIn )
2116 rOutStm << "[in] ";
2117 else if( bOut )
2118 rOutStm << "[out] ";
2119 }
2120
2121 ByteString out;
2122 if( GetType() == TYPE_METHOD )
2123 out = GetReturnType()->GetBaseType()->GetOdlName();
2124 else
2125 {
2126 SvMetaType * pBType = GetBaseType();
2127 out = pBType->GetOdlName();
2128 }
2129 if( aCall0 == (int)CALL_POINTER
2130 || aCall0 == (int)CALL_REFERENCE )
2131 rOutStm << " *";
2132 if( aCall1 == (int)CALL_POINTER
2133 || aCall1 == (int)CALL_REFERENCE )
2134 rOutStm << " *";
2135 rOutStm << out.GetBuffer();
2136 }
2137 break;
2138
2139 case WRITE_C_HEADER:
2140 case WRITE_C_SOURCE:
2141 case WRITE_CXX_HEADER:
2142 case WRITE_CXX_SOURCE:
2143 {
2144
2145 SvMetaType * pBaseType = GetBaseType();
2146 DBG_ASSERT( pBaseType, "no base type for attribute" );
2147
2148 if( pBaseType->GetType() == TYPE_METHOD )
2149 pBaseType->GetReturnType()->WriteTypePrefix(
2150 rBase, rOutStm, nTab, nT );
2151 else if( nT == WRITE_C_HEADER || nT == WRITE_C_SOURCE )
2152 {
2153 if( TYPE_STRUCT == pBaseType->GetType() )
2154 rOutStm << C_PREF << pBaseType->GetName().GetBuffer()
2155 << " *";
2156 else
2157 {
2158 if ( pBaseType->GetType() == TYPE_ENUM )
2159 rOutStm << C_PREF;
2160 rOutStm << pBaseType->GetCName().GetBuffer();
2161 }
2162 }
2163 else
2164 {
2165 if( TYPE_STRUCT == pBaseType->GetType() )
2166 rOutStm << pBaseType->GetName().GetBuffer() << " *";
2167 else
2168 rOutStm << pBaseType->GetName().GetBuffer();
2169 }
2170 }
2171 break;
2172
2173 case WRITE_DOCU:
2174 {
2175
2176 SvMetaType * pBaseType = GetBaseType();
2177 DBG_ASSERT( pBaseType, "no base type for attribute" );
2178
2179 if( pBaseType->GetType() == TYPE_METHOD )
2180 {
2181 pBaseType->GetReturnType()->WriteTypePrefix(
2182 rBase, rOutStm, nTab, nT );
2183 }
2184 else
2185 {
2186 if( TYPE_STRUCT == pBaseType->GetType() )
2187 rOutStm << "VARIANT" << pBaseType->GetName().GetBuffer();
2188 else if ( pBaseType->GetType() == TYPE_ENUM )
2189 rOutStm << "integer";
2190 else
2191 rOutStm << pBaseType->GetOdlName().GetBuffer();
2192 }
2193 }
2194
2195 default:
2196 {
2197 DBG_ASSERT( sal_False, "WriteType not implemented" );
2198 }
2199 }
2200 }
2201
2202 /*************************************************************************
2203 |* SvMetaType::WriteTheType()
2204 |*
2205 |* Beschreibung
2206 *************************************************************************/
WriteTheType(SvIdlDataBase & rBase,SvStream & rOutStm,sal_uInt16 nTab,WriteType nT)2207 void SvMetaType::WriteTheType( SvIdlDataBase & rBase, SvStream & rOutStm,
2208 sal_uInt16 nTab, WriteType nT )
2209 {
2210 WriteTypePrefix( rBase, rOutStm, nTab, nT );
2211 if( GetType() == TYPE_METHOD )
2212 WriteMethodArgs( rBase, rOutStm, nTab +2, nT );
2213 }
2214
2215 /*************************************************************************
2216 |* SvMetaType::GetParserString()
2217 |*
2218 |* Beschreibung
2219 *************************************************************************/
GetParserString() const2220 ByteString SvMetaType::GetParserString() const
2221 {
2222 SvMetaType * pBT = GetBaseType();
2223 if( pBT != this )
2224 return pBT->GetParserString();
2225
2226 int type = GetType();
2227 ByteString aPStr;
2228
2229 if( TYPE_METHOD == type || TYPE_STRUCT == type )
2230 {
2231 sal_uLong nAttrCount = GetAttrCount();
2232 // Die einzelnen Attribute schreiben
2233 for( sal_uLong n = 0; n < nAttrCount; n++ )
2234 {
2235 SvMetaAttribute * pT = pAttrList->GetObject( n );
2236 aPStr += pT->GetType()->GetParserString();
2237 }
2238 }
2239 else
2240 aPStr = GetParserChar();
2241 return aPStr;
2242 }
2243
2244 /*************************************************************************
2245 |* SvMetaType::WriteParamNames()
2246 |*
2247 |* Beschreibung
2248 *************************************************************************/
WriteParamNames(SvIdlDataBase & rBase,SvStream & rOutStm,const ByteString & rChief)2249 void SvMetaType::WriteParamNames( SvIdlDataBase & rBase,
2250 SvStream & rOutStm,
2251 const ByteString & rChief )
2252 {
2253 SvMetaType * pBT = GetBaseType();
2254 if( pBT != this )
2255 pBT->WriteParamNames( rBase, rOutStm, rChief );
2256 else
2257 {
2258 int type = GetType();
2259 ByteString aPStr;
2260
2261 if( TYPE_METHOD == type || TYPE_STRUCT == type )
2262 {
2263 sal_uLong nAttrCount = GetAttrCount();
2264 // Die einzelnen Attribute schreiben
2265 for( sal_uLong n = 0; n < nAttrCount; n++ )
2266 {
2267 SvMetaAttribute * pA = pAttrList->GetObject( n );
2268 // Fuer Methoden ist rChief immer ""
2269 ByteString aStr = /*rChief;
2270 if( aStr.Len() )
2271 aStr += "->";
2272 aStr += */pA->GetName();
2273 pA->GetType()->WriteParamNames( rBase, rOutStm, aStr );
2274 if( n +1 < nAttrCount )
2275 rOutStm << ", ";
2276 }
2277 }
2278 else
2279 rOutStm << rChief.GetBuffer();
2280 }
2281 }
2282
2283 #endif // IDL_COMPILER
2284
2285 /************************************************************************/
2286 /************************************************************************/
2287 SV_IMPL_META_FACTORY1( SvMetaTypeString, SvMetaType );
2288 /*************************************************************************
2289 |*
2290 |* SvMetaTypeString::SvMetaTypeString()
2291 |*
2292 |* Beschreibung
2293 |*
2294 *************************************************************************/
SvMetaTypeString()2295 SvMetaTypeString::SvMetaTypeString()
2296 : SvMetaType( "String", "SbxSTRING", "BSTR", 's', "char *", "String", "$" )
2297 {
2298 }
2299
Load(SvPersistStream & rStm)2300 void SvMetaTypeString::Load( SvPersistStream & rStm )
2301 {
2302 SvMetaType::Load( rStm );
2303 }
2304
Save(SvPersistStream & rStm)2305 void SvMetaTypeString::Save( SvPersistStream & rStm )
2306 {
2307 SvMetaType::Save( rStm );
2308 }
2309
2310 /************************************************************************/
2311 /************************************************************************/
2312 SV_IMPL_META_FACTORY1( SvMetaEnumValue, SvMetaName );
2313 /*************************************************************************
2314 |*
2315 |* SvMetaEnumValue::SvMetaEnumValue()
2316 |*
2317 |* Beschreibung
2318 |*
2319 *************************************************************************/
SvMetaEnumValue()2320 SvMetaEnumValue::SvMetaEnumValue()
2321 {
2322 }
2323
Load(SvPersistStream & rStm)2324 void SvMetaEnumValue::Load( SvPersistStream & rStm )
2325 {
2326 SvMetaName::Load( rStm );
2327
2328 sal_uInt8 nMask;
2329 rStm >> nMask;
2330 if( nMask >= 0x02 )
2331 {
2332 rStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
2333 DBG_ERROR( "wrong format" );
2334 return;
2335 }
2336 if( nMask & 0x01 ) rStm.ReadByteString( aEnumValue );
2337 }
2338
Save(SvPersistStream & rStm)2339 void SvMetaEnumValue::Save( SvPersistStream & rStm )
2340 {
2341 SvMetaName::Save( rStm );
2342
2343 // Maske erstellen
2344 sal_uInt8 nMask = 0;
2345 if( aEnumValue.Len() ) nMask |= 0x01;
2346
2347 // Daten schreiben
2348 rStm << nMask;
2349 if( nMask & 0x01 ) rStm.WriteByteString( aEnumValue );
2350 }
2351
2352 #ifdef IDL_COMPILER
2353 /*************************************************************************
2354 |*
2355 |* SvMetaEnumValue::ReadSvIdl()
2356 |*
2357 |* Beschreibung
2358 |*
2359 *************************************************************************/
ReadSvIdl(SvIdlDataBase & rBase,SvTokenStream & rInStm)2360 sal_Bool SvMetaEnumValue::ReadSvIdl( SvIdlDataBase & rBase,
2361 SvTokenStream & rInStm )
2362 {
2363 if( !ReadNameSvIdl( rBase, rInStm ) )
2364 return sal_False;
2365 return sal_True;
2366 }
2367
2368 /*************************************************************************
2369 |*
2370 |* SvMetaEnumValue::WriteSvIdl()
2371 |*
2372 |* Beschreibung
2373 |*
2374 *************************************************************************/
WriteSvIdl(SvIdlDataBase &,SvStream & rOutStm,sal_uInt16)2375 void SvMetaEnumValue::WriteSvIdl( SvIdlDataBase &, SvStream & rOutStm, sal_uInt16 )
2376 {
2377 rOutStm << GetName().GetBuffer();
2378 }
2379
2380 /*************************************************************************
2381 |*
2382 |* SvMetaEnumValue::Write()
2383 |*
2384 |* Beschreibung
2385 |*
2386 *************************************************************************/
Write(SvIdlDataBase &,SvStream & rOutStm,sal_uInt16,WriteType nT,WriteAttribute)2387 void SvMetaEnumValue::Write( SvIdlDataBase &, SvStream & rOutStm, sal_uInt16,
2388 WriteType nT, WriteAttribute )
2389 {
2390 if ( nT == WRITE_C_HEADER || nT == WRITE_C_SOURCE )
2391 rOutStm << C_PREF << GetName().GetBuffer();
2392 else
2393 rOutStm << GetName().GetBuffer();
2394 }
2395 #endif // IDL_COMPILER
2396
2397 /************************************************************************/
2398 /************************************************************************/
2399 SV_IMPL_META_FACTORY1( SvMetaTypeEnum, SvMetaType );
2400 /*************************************************************************
2401 |*
2402 |* SvMetaTypeEnum::SvMetaTypeEnum()
2403 |*
2404 |* Beschreibung
2405 |*
2406 *************************************************************************/
SvMetaTypeEnum()2407 SvMetaTypeEnum::SvMetaTypeEnum()
2408 {
2409 SetBasicName( "Integer" );
2410 }
2411
Load(SvPersistStream & rStm)2412 void SvMetaTypeEnum::Load( SvPersistStream & rStm )
2413 {
2414 SvMetaType::Load( rStm );
2415
2416 sal_uInt8 nMask;
2417 rStm >> nMask;
2418 if( nMask >= 0x04 )
2419 {
2420 rStm.SetError( SVSTREAM_FILEFORMAT_ERROR );
2421 DBG_ERROR( "wrong format" );
2422 return;
2423 }
2424 if( nMask & 0x01 ) rStm >> aEnumValueList;
2425 if( nMask & 0x02 ) rStm.ReadByteString( aPrefix );
2426 }
2427
Save(SvPersistStream & rStm)2428 void SvMetaTypeEnum::Save( SvPersistStream & rStm )
2429 {
2430 SvMetaType::Save( rStm );
2431
2432 // Maske erstellen
2433 sal_uInt8 nMask = 0;
2434 if( aEnumValueList.Count() ) nMask |= 0x01;
2435 if( aPrefix.Len() ) nMask |= 0x02;
2436
2437 // Daten schreiben
2438 rStm << nMask;
2439 if( nMask & 0x01 ) rStm << aEnumValueList;
2440 if( nMask & 0x02 ) rStm.WriteByteString( aPrefix );
2441 }
2442
2443 /*************************************************************************
2444 |*
2445 |* SvMetaTypeEnum::GetMaxValue()
2446 |*
2447 |* Beschreibung
2448 |*
2449 *************************************************************************/
2450 /*
2451 sal_uInt16 SvMetaTypeEnum::GetMaxValue() const
2452 {
2453 sal_uInt16 nMax = 0;
2454 for( sal_uLong n = 0; n < aEnumValueList.Count(); n++ )
2455 {
2456 SvMetaEnumValue * pObj = aEnumValueList.GetObject( n );
2457 if( nMax < pObj->GetValue() )
2458 nMax = pObj->GetValue();
2459 }
2460 return nMax;
2461 }
2462 */
2463
2464 #ifdef IDL_COMPILER
2465 /*************************************************************************
2466 |*
2467 |* SvMetaTypeEnum::ReadContextSvIdl()
2468 |*
2469 |* Beschreibung
2470 |*
2471 *************************************************************************/
ReadContextSvIdl(SvIdlDataBase & rBase,SvTokenStream & rInStm)2472 void SvMetaTypeEnum::ReadContextSvIdl( SvIdlDataBase & rBase,
2473 SvTokenStream & rInStm )
2474 {
2475 sal_uInt32 nTokPos = rInStm.Tell();
2476
2477 SvMetaEnumValueRef aEnumVal = new SvMetaEnumValue();
2478 sal_Bool bOk = aEnumVal->ReadSvIdl( rBase, rInStm );
2479 if( bOk )
2480 {
2481 if( 0 == aEnumValueList.Count() )
2482 // der Erste
2483 aPrefix = aEnumVal->GetName();
2484 else
2485 {
2486 sal_uInt16 nPos = aPrefix.Match( aEnumVal->GetName() );
2487 if( nPos != aPrefix.Len() && nPos != STRING_MATCH )
2488 aPrefix.Erase( nPos );
2489 }
2490 aEnumValueList.Append( aEnumVal );
2491 }
2492 if( !bOk )
2493 rInStm.Seek( nTokPos );
2494 }
2495
2496 /*************************************************************************
2497 |*
2498 |* SvMetaTypeEnum::WriteSvIdl()
2499 |*
2500 |* Beschreibung
2501 |*
2502 *************************************************************************/
WriteContextSvIdl(SvIdlDataBase & rBase,SvStream & rOutStm,sal_uInt16 nTab)2503 void SvMetaTypeEnum::WriteContextSvIdl( SvIdlDataBase & rBase,
2504 SvStream & rOutStm,
2505 sal_uInt16 nTab )
2506 {
2507 WriteTab( rOutStm, nTab +1 );
2508 for( sal_uLong n = 0; n < aEnumValueList.Count(); n++ )
2509 {
2510 aEnumValueList.GetObject( n )->WriteSvIdl( rBase, rOutStm, nTab );
2511 if( n +1 != aEnumValueList.Count() )
2512 rOutStm << ", ";
2513 else
2514 rOutStm << endl;
2515 }
2516 }
2517
2518 /*************************************************************************
2519 |*
2520 |* SvMetaTypeEnum::ReadSvIdl()
2521 |*
2522 |* Beschreibung
2523 |*
2524 *************************************************************************/
ReadSvIdl(SvIdlDataBase & rBase,SvTokenStream & rInStm)2525 sal_Bool SvMetaTypeEnum::ReadSvIdl( SvIdlDataBase & rBase,
2526 SvTokenStream & rInStm )
2527 {
2528 sal_uInt32 nTokPos = rInStm.Tell();
2529 if( SvMetaType::ReadHeaderSvIdl( rBase, rInStm )
2530 && GetType() == TYPE_ENUM )
2531 {
2532 if( SvMetaName::ReadSvIdl( rBase, rInStm ) )
2533 return sal_True;
2534 }
2535 rInStm.Seek( nTokPos );
2536 return sal_False;
2537 }
2538
2539 /*************************************************************************
2540 |*
2541 |* SvMetaTypeEnum::WriteSvIdl()
2542 |*
2543 |* Beschreibung
2544 |*
2545 *************************************************************************/
WriteSvIdl(SvIdlDataBase & rBase,SvStream & rOutStm,sal_uInt16 nTab)2546 void SvMetaTypeEnum::WriteSvIdl( SvIdlDataBase & rBase, SvStream & rOutStm,
2547 sal_uInt16 nTab )
2548 {
2549 WriteHeaderSvIdl( rBase, rOutStm, nTab );
2550 rOutStm << endl;
2551 SvMetaName::WriteSvIdl( rBase, rOutStm, nTab );
2552 rOutStm << endl;
2553 }
2554
2555 /*************************************************************************
2556 |*
2557 |* SvMetaTypeEnum::Write()
2558 |*
2559 |* Beschreibung
2560 |*
2561 *************************************************************************/
Write(SvIdlDataBase & rBase,SvStream & rOutStm,sal_uInt16 nTab,WriteType nT,WriteAttribute nA)2562 void SvMetaTypeEnum::Write( SvIdlDataBase & rBase, SvStream & rOutStm,
2563 sal_uInt16 nTab,
2564 WriteType nT, WriteAttribute nA )
2565 {
2566 SvMetaType::Write( rBase, rOutStm, nTab, nT, nA );
2567 }
2568
2569 /*************************************************************************
2570 |* SvMetaTypeEnum::WriteContext()
2571 |*
2572 |* Beschreibung
2573 *************************************************************************/
WriteContext(SvIdlDataBase & rBase,SvStream & rOutStm,sal_uInt16 nTab,WriteType nT,WriteAttribute nA)2574 void SvMetaTypeEnum::WriteContext( SvIdlDataBase & rBase, SvStream & rOutStm,
2575 sal_uInt16 nTab,
2576 WriteType nT, WriteAttribute nA )
2577 {
2578 WriteTab( rOutStm, nTab +1 );
2579 for( sal_uLong n = 0; n < aEnumValueList.Count(); n++ )
2580 {
2581 aEnumValueList.GetObject( n )->Write( rBase, rOutStm, nTab +1, nT, nA );
2582
2583 if( n +1 != aEnumValueList.Count() )
2584 {
2585 if( 2 == n % 3 )
2586 {
2587 rOutStm << ',' << endl;
2588 WriteTab( rOutStm, nTab +1 );
2589 }
2590 else
2591 rOutStm << ",\t";
2592 }
2593 else
2594 rOutStm << endl;
2595 }
2596 rOutStm << endl;
2597 }
2598
2599 #endif // IDL_COMPILER
2600
2601 /************************************************************************/
2602 /************************************************************************/
2603 SV_IMPL_META_FACTORY1( SvMetaTypevoid, SvMetaType );
2604 /*************************************************************************
2605 |*
2606 |* SvMetaTypevoid::SvMetaTypevoid()
2607 |*
2608 |* Beschreibung
2609 |*
2610 *************************************************************************/
SvMetaTypevoid()2611 SvMetaTypevoid::SvMetaTypevoid()
2612 : SvMetaType( "void", "SbxVOID", "void", 'v', "void", "", "" )
2613 {
2614 }
2615
Load(SvPersistStream & rStm)2616 void SvMetaTypevoid::Load( SvPersistStream & rStm )
2617 {
2618 SvMetaType::Load( rStm );
2619 }
2620
Save(SvPersistStream & rStm)2621 void SvMetaTypevoid::Save( SvPersistStream & rStm )
2622 {
2623 SvMetaType::Save( rStm );
2624 }
2625
Compare(SvMetaAttribute * pAttr)2626 ByteString SvMetaAttribute::Compare( SvMetaAttribute* pAttr )
2627 {
2628 ByteString aStr;
2629
2630 if ( aType.Is() )
2631 {
2632 if ( aType->GetType() == TYPE_METHOD )
2633 {
2634 // Nur testen, wenn das Attribut eine Methode ist, nicht wenn es
2635 // eine hat !!
2636 if ( !pAttr->GetType()->GetType() == TYPE_METHOD )
2637 aStr += " IsMethod\n";
2638 else if ( aType->GetReturnType() &&
2639 aType->GetReturnType()->GetType() != pAttr->GetType()->GetReturnType()->GetType() )
2640 aStr += " ReturnType\n";
2641
2642 if ( aType->GetAttrCount() )
2643 {
2644 sal_uLong nCount = aType->GetAttrCount();
2645 SvMetaAttributeMemberList& rList = aType->GetAttrList();
2646 SvMetaAttributeMemberList& rOtherList = pAttr->GetType()->GetAttrList();
2647 if ( pAttr->GetType()->GetAttrCount() != nCount )
2648 {
2649 aStr += " AttributeCount\n";
2650 }
2651 else
2652 {
2653 for ( sal_uInt16 n=0; n<nCount; n++ )
2654 {
2655 SvMetaAttribute *pAttr1 = rList.GetObject(n);
2656 SvMetaAttribute *pAttr2 = rOtherList.GetObject(n);
2657 pAttr1->Compare( pAttr2 );
2658 }
2659 }
2660 }
2661 }
2662
2663 if ( GetType()->GetType() != pAttr->GetType()->GetType() )
2664 aStr += " Type\n";
2665
2666 if ( !GetType()->GetSvName().Equals( pAttr->GetType()->GetSvName() ) )
2667 aStr += " ItemType\n";
2668 }
2669
2670 if ( GetExport() != pAttr->GetExport() )
2671 aStr += " Export\n";
2672
2673 if ( GetAutomation() != pAttr->GetAutomation() )
2674 aStr += " Automation\n";
2675
2676 if ( GetIsCollection() != pAttr->GetIsCollection() )
2677 aStr += " IsCollection\n";
2678
2679 if ( GetReadOnlyDoc() != pAttr->GetReadOnlyDoc() )
2680 aStr += " ReadOnlyDoc\n";
2681
2682 if ( GetExport() && GetReadonly() != pAttr->GetReadonly() )
2683 aStr += " Readonly\n";
2684
2685 return aStr;
2686 }
2687
WriteCSV(SvIdlDataBase &,SvStream & rStrm)2688 void SvMetaAttribute::WriteCSV( SvIdlDataBase&, SvStream& rStrm )
2689 {
2690 rStrm << GetType()->GetSvName().GetBuffer() << ' ';
2691 rStrm << GetName().GetBuffer() << ' ';
2692 rStrm << GetSlotId().GetBuffer();
2693 }
2694
2695
2696