Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include <ctype.h>
22 : #include <stdio.h>
23 : #include <rtl/strbuf.hxx>
24 : #include <osl/diagnose.h>
25 : #include <tools/debug.hxx>
26 : #include <slot.hxx>
27 : #include <globals.hxx>
28 : #include <database.hxx>
29 :
30 16492 : TYPEINIT1( SvMetaSlot, SvMetaAttribute );
31 :
32 68 : SvMetaObject *SvMetaSlot::MakeClone() const
33 : {
34 68 : return new SvMetaSlot( *this );
35 : }
36 :
37 8296 : SvMetaSlot::SvMetaSlot()
38 : : aCachable( true, false )
39 : , aSynchron( true, false )
40 : , aRecordPerSet( true, false )
41 : , aRecordAbsolute( false, false )
42 : , pLinkedSlot(0)
43 : , pNextSlot(0)
44 : , nListPos(0)
45 8296 : , pEnumValue(0)
46 : {
47 8296 : }
48 :
49 4286 : SvMetaSlot::SvMetaSlot( SvMetaType * pType )
50 : : SvMetaAttribute( pType )
51 : , aCachable( true, false )
52 : , aSynchron( true, false )
53 : , aRecordPerSet( true, false )
54 : , aRecordAbsolute( false, false )
55 : , pLinkedSlot(0)
56 : , pNextSlot(0)
57 : , nListPos(0)
58 4286 : , pEnumValue(0)
59 : {
60 4286 : }
61 :
62 11283 : bool SvMetaSlot::IsVariable() const
63 : {
64 11283 : return SvMetaAttribute::IsVariable();
65 : }
66 :
67 23694 : bool SvMetaSlot::IsMethod() const
68 : {
69 23694 : bool b = SvMetaAttribute::IsMethod();
70 23694 : b |= NULL != GetMethod();
71 23694 : return b;
72 : }
73 :
74 5951 : OString SvMetaSlot::GetMangleName( bool bVariable ) const
75 : {
76 5951 : if( !bVariable )
77 : {
78 5951 : SvMetaAttribute * pMeth = GetMethod();
79 5951 : if( pMeth )
80 22 : return pMeth->GetName().getString();
81 : }
82 5929 : return GetName().getString();
83 : }
84 :
85 : /*************************************************************************
86 : |* reference
87 : |*
88 : |* description Second FALSE in the SvBOOL-Objects means
89 : |* IsSet() provides FALSE (default initialization).
90 : *************************************************************************/
91 : /** reference disbandment **/
92 11761 : SvMetaType * SvMetaSlot::GetSlotType() const
93 : {
94 11761 : if( aSlotType.Is() || !GetRef() ) return aSlotType;
95 5878 : return static_cast<SvMetaSlot *>(GetRef())->GetSlotType();
96 : }
97 84576 : SvMetaAttribute * SvMetaSlot::GetMethod() const
98 : {
99 84576 : if( aMethod.Is() || !GetRef() ) return aMethod;
100 42124 : return static_cast<SvMetaSlot *>(GetRef())->GetMethod();
101 : }
102 11834 : bool SvMetaSlot::GetHasCoreId() const
103 : {
104 11834 : if( aHasCoreId.IsSet() || !GetRef() ) return aHasCoreId;
105 5883 : return static_cast<SvMetaSlot *>(GetRef())->GetHasCoreId();
106 : }
107 23212 : const OString& SvMetaSlot::GetGroupId() const
108 : {
109 23212 : if( !aGroupId.getString().isEmpty() || !GetRef() ) return aGroupId.getString();
110 11394 : return static_cast<SvMetaSlot *>(GetRef())->GetGroupId();
111 : }
112 11834 : const OString& SvMetaSlot::GetDisableFlags() const
113 : {
114 11834 : if( !aDisableFlags.getString().isEmpty() || !GetRef() ) return aDisableFlags.getString();
115 4876 : return static_cast<SvMetaSlot *>(GetRef())->GetDisableFlags();
116 : }
117 0 : const OString& SvMetaSlot::GetConfigId() const
118 : {
119 0 : if( !aConfigId.getString().isEmpty() || !GetRef() ) return aConfigId.getString();
120 0 : return static_cast<SvMetaSlot *>(GetRef())->GetConfigId();
121 : }
122 23593 : const OString& SvMetaSlot::GetExecMethod() const
123 : {
124 23593 : if( !aExecMethod.getString().isEmpty() || !GetRef() ) return aExecMethod.getString();
125 708 : return static_cast<SvMetaSlot *>(GetRef())->GetExecMethod();
126 : }
127 164678 : const OString& SvMetaSlot::GetStateMethod() const
128 : {
129 164678 : if( !aStateMethod.getString().isEmpty() || !GetRef() ) return aStateMethod.getString();
130 9187 : return static_cast<SvMetaSlot *>(GetRef())->GetStateMethod();
131 : }
132 0 : const OString& SvMetaSlot::GetDefault() const
133 : {
134 0 : if( !aDefault.getString().isEmpty() || !GetRef() ) return aDefault.getString();
135 0 : return static_cast<SvMetaSlot *>(GetRef())->GetDefault();
136 : }
137 11829 : bool SvMetaSlot::GetPseudoSlots() const
138 : {
139 11829 : if( aPseudoSlots.IsSet() || !GetRef() ) return aPseudoSlots;
140 5878 : return static_cast<SvMetaSlot *>(GetRef())->GetPseudoSlots();
141 : }
142 11673 : bool SvMetaSlot::GetCachable() const
143 : {
144 : // Cachable and Volatile are exclusive
145 11673 : if( !GetRef() || aCachable.IsSet() || aVolatile.IsSet() )
146 5951 : return aCachable;
147 5722 : return static_cast<SvMetaSlot *>(GetRef())->GetCachable();
148 : }
149 11673 : bool SvMetaSlot::GetVolatile() const
150 : {
151 : // Cachable and Volatile are exclusive
152 11673 : if( !GetRef() || aVolatile.IsSet() || aCachable.IsSet() )
153 5951 : return aVolatile;
154 5722 : return static_cast<SvMetaSlot *>(GetRef())->GetVolatile();
155 : }
156 11833 : bool SvMetaSlot::GetToggle() const
157 : {
158 11833 : if( aToggle.IsSet() || !GetRef() ) return aToggle;
159 5882 : return static_cast<SvMetaSlot *>(GetRef())->GetToggle();
160 : }
161 11805 : bool SvMetaSlot::GetAutoUpdate() const
162 : {
163 11805 : if( aAutoUpdate.IsSet() || !GetRef() ) return aAutoUpdate;
164 5854 : return static_cast<SvMetaSlot *>(GetRef())->GetAutoUpdate();
165 : }
166 11804 : bool SvMetaSlot::GetSynchron() const
167 : {
168 : // Synchron and Asynchron are exclusive
169 11804 : if( !GetRef() || aSynchron.IsSet() || aAsynchron.IsSet() )
170 5951 : return aSynchron;
171 5853 : return static_cast<SvMetaSlot *>(GetRef())->GetSynchron();
172 : }
173 11804 : bool SvMetaSlot::GetAsynchron() const
174 : {
175 : // Synchron and Asynchron are exclusive
176 11804 : if( !GetRef() || aAsynchron.IsSet() || aSynchron.IsSet() )
177 5951 : return aAsynchron;
178 5853 : return static_cast<SvMetaSlot *>(GetRef())->GetAsynchron();
179 : }
180 11833 : bool SvMetaSlot::GetRecordPerItem() const
181 : {
182 : // Record- PerItem, No, PerSet and Manual are exclusive
183 29549 : if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
184 17715 : || aRecordPerSet.IsSet() || aRecordManual.IsSet() )
185 5951 : return aRecordPerItem;
186 5882 : return static_cast<SvMetaSlot *>(GetRef())->GetRecordPerItem();
187 : }
188 11833 : bool SvMetaSlot::GetRecordPerSet() const
189 : {
190 : // Record- PerItem, No, PerSet and Manual are exclusive
191 29549 : if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
192 17715 : || aRecordPerSet.IsSet() || aRecordManual.IsSet() )
193 5951 : return aRecordPerSet;
194 5882 : return static_cast<SvMetaSlot *>(GetRef())->GetRecordPerSet();
195 : }
196 11833 : bool SvMetaSlot::GetRecordManual() const
197 : {
198 : // Record- PerItem, No, PerSet and Manual are exclusive
199 29549 : if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
200 17715 : || aRecordPerSet.IsSet() || aRecordManual.IsSet() )
201 5951 : return aRecordManual;
202 5882 : return static_cast<SvMetaSlot *>(GetRef())->GetRecordManual();
203 : }
204 11833 : bool SvMetaSlot::GetNoRecord() const
205 : {
206 : // Record- PerItem, No, PerSet and Manual are exclusive
207 29549 : if( !GetRef() || aRecordPerItem.IsSet() || aNoRecord.IsSet()
208 17715 : || aRecordPerSet.IsSet() || aRecordManual.IsSet() )
209 5951 : return aNoRecord;
210 5882 : return static_cast<SvMetaSlot *>(GetRef())->GetNoRecord();
211 : }
212 11834 : bool SvMetaSlot::GetRecordAbsolute() const
213 : {
214 11834 : if( !GetRef() || aRecordAbsolute.IsSet() )
215 5951 : return aRecordAbsolute;
216 5883 : return static_cast<SvMetaSlot *>(GetRef())->GetRecordAbsolute();
217 : }
218 11819 : bool SvMetaSlot::GetHasDialog() const
219 : {
220 11819 : if( aHasDialog.IsSet() || !GetRef() ) return aHasDialog;
221 5868 : return static_cast<SvMetaSlot *>(GetRef())->GetHasDialog();
222 : }
223 272 : const OString& SvMetaSlot::GetPseudoPrefix() const
224 : {
225 272 : if( !aPseudoPrefix.getString().isEmpty() || !GetRef() ) return aPseudoPrefix.getString();
226 136 : return static_cast<SvMetaSlot *>(GetRef())->GetPseudoPrefix();
227 : }
228 11791 : bool SvMetaSlot::GetMenuConfig() const
229 : {
230 11791 : if( aMenuConfig.IsSet() || !GetRef() ) return aMenuConfig;
231 5840 : return static_cast<SvMetaSlot *>(GetRef())->GetMenuConfig();
232 : }
233 11799 : bool SvMetaSlot::GetToolBoxConfig() const
234 : {
235 11799 : if( aToolBoxConfig.IsSet() || !GetRef() ) return aToolBoxConfig;
236 5848 : return static_cast<SvMetaSlot *>(GetRef())->GetToolBoxConfig();
237 : }
238 11833 : bool SvMetaSlot::GetStatusBarConfig() const
239 : {
240 11833 : if( aStatusBarConfig.IsSet() || !GetRef() ) return aStatusBarConfig;
241 5882 : return static_cast<SvMetaSlot *>(GetRef())->GetStatusBarConfig();
242 : }
243 11803 : bool SvMetaSlot::GetAccelConfig() const
244 : {
245 11803 : if( aAccelConfig.IsSet() || !GetRef() ) return aAccelConfig;
246 5852 : return static_cast<SvMetaSlot *>(GetRef())->GetAccelConfig();
247 : }
248 11815 : bool SvMetaSlot::GetFastCall() const
249 : {
250 11815 : if( aFastCall.IsSet() || !GetRef() ) return aFastCall;
251 5864 : return static_cast<SvMetaSlot *>(GetRef())->GetFastCall();
252 : }
253 11832 : bool SvMetaSlot::GetContainer() const
254 : {
255 11832 : if( aContainer.IsSet() || !GetRef() ) return aContainer;
256 5881 : return static_cast<SvMetaSlot *>(GetRef())->GetContainer();
257 : }
258 :
259 11834 : bool SvMetaSlot::GetImageRotation() const
260 : {
261 11834 : if( aImageRotation.IsSet() || !GetRef() ) return aImageRotation;
262 5883 : return static_cast<SvMetaSlot *>(GetRef())->GetImageRotation();
263 : }
264 :
265 11834 : bool SvMetaSlot::GetImageReflection() const
266 : {
267 11834 : if( aImageReflection.IsSet() || !GetRef() ) return aImageReflection;
268 5883 : return static_cast<SvMetaSlot *>(GetRef())->GetImageReflection();
269 : }
270 :
271 0 : const OString& SvMetaSlot::GetUnoName() const
272 : {
273 0 : if( aUnoName.IsSet() || !GetRef() ) return aUnoName.getString();
274 0 : return static_cast<SvMetaSlot *>(GetRef())->GetUnoName();
275 : }
276 :
277 163550 : void SvMetaSlot::ReadAttributesSvIdl( SvIdlDataBase & rBase,
278 : SvTokenStream & rInStm )
279 : {
280 163550 : SvMetaAttribute::ReadAttributesSvIdl( rBase, rInStm );
281 :
282 163550 : bool bOk = false;
283 163550 : bOk |= aDefault.ReadSvIdl( SvHash_Default(), rInStm );
284 163550 : bOk |= aPseudoSlots.ReadSvIdl( SvHash_PseudoSlots(), rInStm );
285 163550 : bOk |= aHasCoreId.ReadSvIdl( SvHash_HasCoreId(), rInStm );
286 163550 : bOk |= aGroupId.ReadSvIdl( SvHash_GroupId(), rInStm );
287 163550 : bOk |= aExecMethod.ReadSvIdl( SvHash_ExecMethod(), rInStm );
288 163550 : bOk |= aStateMethod.ReadSvIdl( SvHash_StateMethod(), rInStm );
289 163550 : bOk |= aDisableFlags.ReadSvIdl( SvHash_DisableFlags(), rInStm );
290 163550 : if( aGet.ReadSvIdl( SvHash_Get(), rInStm ) )
291 : {
292 0 : SvIdlDataBase::WriteError( "warning", OUStringToOString(rInStm.GetFileName(), RTL_TEXTENCODING_UTF8),
293 : "<Get> old style, use Readonly",
294 : rInStm.GetToken()->GetLine(),
295 0 : rInStm.GetToken()->GetColumn() );
296 : }
297 163550 : if( aSet.ReadSvIdl( SvHash_Set(), rInStm ) )
298 : {
299 0 : SvIdlDataBase::WriteError( "warning", OUStringToOString(rInStm.GetFileName(), RTL_TEXTENCODING_UTF8),
300 : "<Set> old style, use method declaration",
301 : rInStm.GetToken()->GetLine(),
302 0 : rInStm.GetToken()->GetColumn() );
303 : }
304 :
305 163550 : if( aCachable.ReadSvIdl( SvHash_Cachable(), rInStm ) )
306 16373 : SetCachable( aCachable ), bOk = true;
307 163550 : if( aVolatile.ReadSvIdl( SvHash_Volatile(), rInStm ) )
308 0 : SetVolatile( aVolatile ), bOk = true;
309 163550 : if( aToggle.ReadSvIdl( SvHash_Toggle(), rInStm ) )
310 8130 : SetToggle( aToggle ), bOk = true;
311 163550 : if( aAutoUpdate.ReadSvIdl( SvHash_AutoUpdate(), rInStm ) )
312 8145 : SetAutoUpdate( aAutoUpdate ), bOk = true;
313 :
314 163550 : if( aSynchron.ReadSvIdl( SvHash_Synchron(), rInStm ) )
315 6560 : SetSynchron( aSynchron ), bOk = true;
316 163550 : if( aAsynchron.ReadSvIdl( SvHash_Asynchron(), rInStm ) )
317 1586 : SetAsynchron( aAsynchron ), bOk = true;
318 :
319 163550 : if( aRecordAbsolute.ReadSvIdl( SvHash_RecordAbsolute(), rInStm ) )
320 7940 : SetRecordAbsolute( aRecordAbsolute), bOk = true;
321 163550 : if( aRecordPerItem.ReadSvIdl( SvHash_RecordPerItem(), rInStm ) )
322 581 : SetRecordPerItem( aRecordPerItem ), bOk = true;
323 163550 : if( aRecordPerSet.ReadSvIdl( SvHash_RecordPerSet(), rInStm ) )
324 7082 : SetRecordPerSet( aRecordPerSet ), bOk = true;
325 163550 : if( aRecordManual.ReadSvIdl( SvHash_RecordManual(), rInStm ) )
326 181 : SetRecordManual( aRecordManual ), bOk = true;
327 163550 : if( aNoRecord.ReadSvIdl( SvHash_NoRecord(), rInStm ) )
328 97 : SetNoRecord( aNoRecord ), bOk = true;
329 :
330 163550 : bOk |= aHasDialog.ReadSvIdl( SvHash_HasDialog(), rInStm );
331 163550 : bOk |= aPseudoPrefix.ReadSvIdl( SvHash_PseudoPrefix(), rInStm );
332 163550 : bOk |= aMenuConfig.ReadSvIdl( SvHash_MenuConfig(), rInStm );
333 163550 : bOk |= aToolBoxConfig.ReadSvIdl( SvHash_ToolBoxConfig(), rInStm );
334 163550 : bOk |= aStatusBarConfig.ReadSvIdl( SvHash_StatusBarConfig(), rInStm );
335 163550 : bOk |= aAccelConfig.ReadSvIdl( SvHash_AccelConfig(), rInStm );
336 :
337 163550 : SvBOOL aAllConfig;
338 163550 : if( aAllConfig.ReadSvIdl( SvHash_AllConfig(), rInStm ) )
339 0 : SetAllConfig( aAllConfig ), bOk = true;
340 163550 : bOk |= aFastCall.ReadSvIdl( SvHash_FastCall(), rInStm );
341 163550 : bOk |= aContainer.ReadSvIdl( SvHash_Container(), rInStm );
342 163550 : bOk |= aImageRotation.ReadSvIdl( SvHash_ImageRotation(), rInStm );
343 163550 : bOk |= aImageReflection.ReadSvIdl( SvHash_ImageReflection(), rInStm );
344 163550 : bOk |= aUnoName.ReadSvIdl( SvHash_UnoName(), rInStm );
345 :
346 163550 : if( !bOk )
347 : {
348 25153 : if( !aSlotType.Is() )
349 : {
350 24332 : sal_uInt32 nTokPos = rInStm.Tell();
351 24332 : SvToken * pTok = rInStm.GetToken_Next();
352 24332 : if( pTok->Is( SvHash_SlotType() ) )
353 : {
354 798 : bool bBraket = rInStm.Read( '(' );
355 798 : if( bBraket || rInStm.Read( '=' ) )
356 : {
357 798 : aSlotType = rBase.ReadKnownType( rInStm );
358 798 : if( aSlotType.Is() )
359 : {
360 798 : if( aSlotType->IsItem() )
361 : {
362 798 : if( bBraket )
363 : {
364 0 : if( rInStm.Read( ')' ) )
365 824 : return;
366 : }
367 : else
368 798 : return;
369 : }
370 0 : rBase.SetError( "the SlotType is not a item", rInStm.GetToken() );
371 0 : rBase.WriteError( rInStm );
372 : }
373 0 : rBase.SetError( "SlotType with unknown item type", rInStm.GetToken() );
374 0 : rBase.WriteError( rInStm );
375 : }
376 : }
377 23534 : rInStm.Seek( nTokPos );
378 :
379 : }
380 24355 : if( !aMethod.Is() )
381 : {
382 24279 : SvToken * pTok = rInStm.GetToken();
383 24279 : if( pTok->IsIdentifier() )
384 : {
385 26 : aMethod = new SvMetaSlot();
386 26 : sal_uInt32 nTokPos = rInStm.Tell();
387 26 : if( aMethod->ReadSvIdl( rBase, rInStm ) )
388 : {
389 26 : if( aMethod->IsMethod() )
390 : {
391 26 : aMethod->SetSlotId( GetSlotId() );
392 26 : if( aMethod->Test( rBase, rInStm ) )
393 26 : return;
394 : }
395 0 : rInStm.Seek( nTokPos );
396 : }
397 0 : aMethod.Clear();
398 : }
399 : }
400 : }
401 : }
402 :
403 12251 : bool SvMetaSlot::Test( SvIdlDataBase & rBase, SvTokenStream & rInStm )
404 : {
405 12251 : bool bOk = SvMetaAttribute::Test( rBase, rInStm );
406 12251 : if( bOk )
407 : {
408 12251 : SvMetaType * pType = GetType();
409 12251 : if( pType->GetType() == TYPE_METHOD )
410 6771 : pType = pType->GetReturnType();
411 12251 : if( !pType->IsItem() )
412 : {
413 0 : rBase.SetError( "this attribute is not a slot", rInStm.GetToken() );
414 0 : rBase.WriteError( rInStm );
415 0 : bOk = false;
416 : }
417 : }
418 :
419 12251 : return bOk;
420 : }
421 :
422 12582 : bool SvMetaSlot::ReadSvIdl( SvIdlDataBase & rBase, SvTokenStream & rInStm )
423 : {
424 12582 : sal_uInt32 nTokPos = rInStm.Tell();
425 12582 : bool bOk = true;
426 :
427 12582 : SvMetaAttribute * pAttr = rBase.ReadKnownAttr( rInStm, GetType() );
428 12582 : if( pAttr )
429 : {
430 : // c
431 4070 : SvMetaSlot * pKnownSlot = PTR_CAST( SvMetaSlot, pAttr );
432 4070 : if( pKnownSlot )
433 : {
434 4070 : SetRef( pKnownSlot );
435 4070 : SetName( pKnownSlot->GetName().getString(), &rBase );
436 4070 : bOk = SvMetaName::ReadSvIdl( rBase, rInStm );
437 : }
438 : else
439 : {
440 0 : OStringBuffer aStr( "attribute " );
441 0 : aStr.append(pAttr->GetName().getString());
442 0 : aStr.append(" is method or variable but not a slot");
443 0 : rBase.SetError( aStr.makeStringAndClear(), rInStm.GetToken() );
444 0 : rBase.WriteError( rInStm );
445 0 : bOk = false;
446 : }
447 : }
448 : else
449 : {
450 8512 : bOk = SvMetaAttribute::ReadSvIdl( rBase, rInStm );
451 :
452 8512 : SvMetaAttribute *pAttr2 = rBase.SearchKnownAttr( GetSlotId() );
453 8512 : if( pAttr2 )
454 : {
455 : // for testing purposes: reference in case of complete definition
456 49 : SvMetaSlot * pKnownSlot = PTR_CAST( SvMetaSlot, pAttr2 );
457 49 : if( pKnownSlot )
458 : {
459 49 : SetRef( pKnownSlot );
460 :
461 : // names may differ, because explicitly given
462 49 : if ( pKnownSlot->GetName().getString() != GetName().getString() )
463 : {
464 : OSL_FAIL("Illegal definition!");
465 0 : rInStm.Seek( nTokPos );
466 0 : return false;
467 : }
468 :
469 49 : SetName( pKnownSlot->GetName().getString(), &rBase );
470 : }
471 : else
472 : {
473 0 : OStringBuffer aStr("attribute ");
474 0 : aStr.append(pAttr2->GetName().getString());
475 0 : aStr.append(" is method or variable but not a slot");
476 0 : rBase.SetError( aStr.makeStringAndClear(), rInStm.GetToken() );
477 0 : rBase.WriteError( rInStm );
478 0 : bOk = false;
479 : }
480 : }
481 : }
482 :
483 12582 : if( !bOk )
484 331 : rInStm.Seek( nTokPos );
485 :
486 12582 : return bOk;
487 : }
488 :
489 5951 : void SvMetaSlot::Insert( SvSlotElementList& rList, const OString& rPrefix,
490 : SvIdlDataBase& rBase)
491 : {
492 : // get insert position through binary search in slotlist
493 5951 : sal_uInt16 nId = (sal_uInt16) GetSlotId().GetValue();
494 5951 : sal_uInt16 nListCount = (sal_uInt16) rList.size();
495 : sal_uInt16 nPos;
496 : sal_uLong m; // for inner "for" loop
497 :
498 5951 : if ( !nListCount )
499 76 : nPos = 0;
500 5875 : else if ( nListCount == 1 )
501 69 : nPos = rList[ 0 ]->xSlot->GetSlotId().GetValue() >= nId ? 0 : 1;
502 : else
503 : {
504 5806 : sal_uInt16 nMid = 0, nLow = 0;
505 5806 : sal_uInt16 nHigh = nListCount - 1;
506 5806 : bool bFound = false;
507 48106 : while ( !bFound && nLow <= nHigh )
508 : {
509 36659 : nMid = (nLow + nHigh) >> 1;
510 : DBG_ASSERT( nMid < nListCount, "bsearch ist buggy" );
511 36659 : int nDiff = (int) nId - (int) rList[ nMid ]->xSlot->GetSlotId().GetValue();
512 36659 : if ( nDiff < 0)
513 : {
514 16295 : if ( nMid == 0 )
515 165 : break;
516 16130 : nHigh = nMid - 1;
517 : }
518 20364 : else if ( nDiff > 0 )
519 : {
520 20364 : nLow = nMid + 1;
521 20364 : if ( nLow == 0 )
522 0 : break;
523 : }
524 : else
525 0 : bFound = true;
526 : }
527 :
528 : DBG_ASSERT(!bFound, "Duplicate SlotId!");
529 5806 : nPos = bFound ? nMid : nLow;
530 : }
531 :
532 : DBG_ASSERT( nPos <= nListCount,
533 : "nPos too large" );
534 : DBG_ASSERT( nPos == nListCount || nId <=
535 : (sal_uInt16) rList[ nPos ]->xSlot->GetSlotId().GetValue(),
536 : "Successor has lower SlotId" );
537 : DBG_ASSERT( nPos == 0 || nId >
538 : (sal_uInt16) rList[ nPos-1 ]->xSlot->GetSlotId().GetValue(),
539 : "Predecessor has higher SlotId" );
540 : DBG_ASSERT( nPos+1 >= nListCount || nId <
541 : (sal_uInt16) rList[ nPos+1 ]->xSlot->GetSlotId().GetValue(),
542 : "Successor has lower SlotId" );
543 :
544 5951 : if ( nPos < rList.size() )
545 : {
546 5477 : SvSlotElementList::iterator it = rList.begin();
547 5477 : std::advance( it, nPos );
548 5477 : rList.insert( it, new SvSlotElement( this, rPrefix ) );
549 : }
550 : else
551 : {
552 474 : rList.push_back( new SvSlotElement( this, rPrefix ) );
553 : }
554 :
555 : // iron out EnumSlots
556 5951 : SvMetaTypeEnum * pEnum = NULL;
557 5951 : SvMetaType * pBType = GetType()->GetBaseType();
558 5951 : pEnum = PTR_CAST( SvMetaTypeEnum, pBType );
559 5951 : if( GetPseudoSlots() && pEnum && pEnum->Count() )
560 : {
561 : // clone the MasterSlot
562 5 : SvMetaSlotRef xEnumSlot;
563 5 : SvMetaSlot *pFirstEnumSlot = NULL;
564 73 : for( sal_uLong n = 0; n < pEnum->Count(); n++ )
565 : {
566 : // create SlotId
567 68 : SvMetaEnumValue *enumValue = pEnum->GetObject(n);
568 68 : OString aValName = enumValue->GetName().getString();
569 136 : OStringBuffer aBuf;
570 68 : if( !GetPseudoPrefix().isEmpty() )
571 68 : aBuf.append(GetPseudoPrefix());
572 : else
573 0 : aBuf.append(GetSlotId().getString());
574 68 : aBuf.append('_');
575 68 : aBuf.append(aValName.copy(pEnum->GetPrefix().getLength()));
576 :
577 136 : OString aSId = aBuf.makeStringAndClear();
578 :
579 68 : xEnumSlot = NULL;
580 34887 : for( m=0; m<rBase.GetAttrList().size(); m++ )
581 : {
582 34887 : SvMetaAttribute * pAttr = rBase.GetAttrList()[m];
583 34887 : if (aSId.equals(pAttr->GetSlotId().getString()))
584 : {
585 68 : SvMetaSlot& rSlot = dynamic_cast<SvMetaSlot&>(*pAttr);
586 68 : xEnumSlot = rSlot.Clone();
587 68 : break;
588 : }
589 : }
590 :
591 68 : if ( m == rBase.GetAttrList().size() )
592 : {
593 : OSL_FAIL("Invalid EnumSlot!");
594 0 : xEnumSlot = Clone();
595 : sal_uLong nValue;
596 0 : if ( rBase.FindId(aSId , &nValue) )
597 : {
598 0 : SvNumberIdentifier aId;
599 0 : aId.setString(aSId);
600 0 : aId.SetValue(nValue);
601 0 : xEnumSlot->SetSlotId(aId);
602 : }
603 : }
604 :
605 : // The slaves are no master!
606 68 : xEnumSlot->aPseudoSlots = false;
607 68 : xEnumSlot->SetEnumValue(enumValue);
608 :
609 68 : if ( !pFirstEnumSlot || xEnumSlot->GetSlotId().GetValue() < pFirstEnumSlot->GetSlotId().GetValue() )
610 7 : pFirstEnumSlot = xEnumSlot;
611 :
612 : // insert the created slave as well
613 68 : xEnumSlot->Insert( rList, rPrefix, rBase);
614 :
615 : // concatenate the EnumSlots with the master
616 68 : xEnumSlot->pLinkedSlot = this;
617 68 : }
618 :
619 : // master points to the first slave
620 5 : pLinkedSlot = pFirstEnumSlot;
621 :
622 : // concatenate slaves among themselves
623 5 : xEnumSlot = pFirstEnumSlot;
624 5 : size_t i = 0;
625 : SvSlotElement *pEle;
626 205 : do
627 : {
628 205 : pEle = ( ++i < rList.size() ) ? rList[ i ] : NULL;
629 205 : if ( pEle && pEle->xSlot->pLinkedSlot == this )
630 : {
631 67 : xEnumSlot->pNextSlot = pEle->xSlot;
632 67 : xEnumSlot = pEle->xSlot;
633 : }
634 : }
635 : while ( pEle );
636 5 : xEnumSlot->pNextSlot = pFirstEnumSlot;
637 : }
638 5951 : }
639 :
640 :
641 35682 : static OString MakeSlotName( SvStringHashEntry * pEntry )
642 : {
643 35682 : OStringBuffer aName("SfxSlotMode::");
644 35682 : aName.append(pEntry->GetName().toAsciiUpperCase());
645 35682 : return aName.makeStringAndClear();
646 : };
647 :
648 5951 : void SvMetaSlot::WriteSlotStubs( const OString& rShellName,
649 : ByteStringList & rList,
650 : SvStream & rOutStm )
651 : {
652 5951 : if ( !GetExport() && !GetHidden() )
653 5951 : return;
654 :
655 5951 : OString aMethodName( GetExecMethod() );
656 11480 : if ( !aMethodName.isEmpty() &&
657 5529 : aMethodName != "NoExec" )
658 : {
659 5522 : bool bIn = false;
660 33112 : for( size_t n = 0; n < rList.size(); n++ )
661 : {
662 32767 : if (rList[n]->equals(aMethodName))
663 : {
664 5177 : bIn = true;
665 5177 : break;
666 : }
667 : }
668 :
669 5522 : if ( !bIn )
670 : {
671 345 : rList.push_back( new OString(aMethodName) );
672 345 : rOutStm.WriteCharPtr( "SFX_EXEC_STUB(" )
673 690 : .WriteCharPtr( rShellName.getStr() )
674 345 : .WriteChar( ',' )
675 690 : .WriteCharPtr( aMethodName.getStr() )
676 345 : .WriteChar( ')' ) << endl;
677 : }
678 : }
679 :
680 5951 : aMethodName = GetStateMethod();
681 11479 : if (!aMethodName.isEmpty() &&
682 5528 : aMethodName != "NoState")
683 : {
684 5201 : bool bIn = false;
685 29188 : for ( size_t n=0; n < rList.size(); n++ )
686 : {
687 28895 : if (rList[n]->equals(aMethodName))
688 : {
689 4908 : bIn = true;
690 4908 : break;
691 : }
692 : }
693 :
694 5201 : if ( !bIn )
695 : {
696 293 : rList.push_back( new OString(aMethodName) );
697 293 : rOutStm.WriteCharPtr( "SFX_STATE_STUB(" )
698 586 : .WriteCharPtr( rShellName.getStr() )
699 293 : .WriteChar( ',' )
700 586 : .WriteCharPtr( aMethodName.getStr() )
701 293 : .WriteChar( ')' ) << endl;
702 : }
703 5951 : }
704 : }
705 :
706 5951 : void SvMetaSlot::WriteSlot( const OString& rShellName, sal_uInt16 nCount,
707 : const OString& rSlotId,
708 : SvSlotElementList& rSlotList,
709 : size_t nStart,
710 : SvIdlDataBase & rBase, SvStream & rOutStm )
711 : {
712 5951 : if ( !GetExport() && !GetHidden() )
713 5951 : return;
714 :
715 5951 : bool bIsEnumSlot = 0 != pEnumValue;
716 :
717 5951 : rOutStm.WriteCharPtr( "// Slot Nr. " )
718 17853 : .WriteCharPtr( OString::number(nListPos).getStr() )
719 5951 : .WriteCharPtr( " : " );
720 5951 : OString aSlotIdValue(OString::number(GetSlotId().GetValue()));
721 5951 : rOutStm.WriteCharPtr( aSlotIdValue.getStr() ) << endl;
722 5951 : WriteTab( rOutStm, 1 );
723 5951 : if( bIsEnumSlot )
724 68 : rOutStm.WriteCharPtr( "SFX_NEW_SLOT_ENUM( " );
725 : else
726 5883 : rOutStm.WriteCharPtr( "SFX_NEW_SLOT_ARG( " ).WriteCharPtr( rShellName.getStr() ).WriteChar( ',' ) ;
727 :
728 5951 : rOutStm.WriteCharPtr( rSlotId.getStr() ).WriteChar( ',' );
729 5951 : const SvHelpContext& rHlpCtx = GetHelpContext();
730 5951 : if( rHlpCtx.IsSet() )
731 0 : rOutStm.WriteCharPtr( rHlpCtx.getString().getStr() ).WriteChar( ',' );
732 : else
733 5951 : rOutStm.WriteCharPtr( rSlotId.getStr() ).WriteChar( ',' );
734 :
735 : // GroupId
736 5951 : if( !GetGroupId().isEmpty() )
737 5867 : rOutStm.WriteCharPtr( GetGroupId().getStr() );
738 : else
739 84 : rOutStm.WriteChar( '0' );
740 5951 : rOutStm.WriteChar( ',' ) << endl;
741 5951 : WriteTab( rOutStm, 4 );
742 :
743 5951 : if( bIsEnumSlot )
744 : {
745 68 : rOutStm.WriteCharPtr( "&a" ).WriteCharPtr( rShellName.getStr() ).WriteCharPtr( "Slots_Impl[" )
746 204 : .WriteCharPtr( OString::number(pLinkedSlot->GetListPos()).getStr() )
747 68 : .WriteCharPtr( "] /*Offset Master*/, " ) << endl;
748 68 : WriteTab( rOutStm, 4 );
749 68 : rOutStm.WriteCharPtr( "&a" ).WriteCharPtr( rShellName.getStr() ).WriteCharPtr( "Slots_Impl[" )
750 204 : .WriteCharPtr( OString::number(pNextSlot->GetListPos()).getStr() )
751 68 : .WriteCharPtr( "] /*Offset Next*/, " ) << endl;
752 :
753 68 : WriteTab( rOutStm, 4 );
754 :
755 : // SlotId
756 68 : if( !GetSlotId().getString().isEmpty() )
757 68 : rOutStm.WriteCharPtr( pLinkedSlot->GetSlotId().getString().getStr() );
758 : else
759 0 : rOutStm.WriteChar( '0' );
760 68 : rOutStm.WriteChar( ',' );
761 68 : rOutStm.WriteCharPtr( pEnumValue->GetName().getString().getStr() );
762 : }
763 : else
764 : {
765 : // look for the next slot with the same StateMethod like me
766 : // the slotlist is set to the current slot
767 5883 : size_t i = nStart;
768 5883 : SvSlotElement* pEle = ( ++i < rSlotList.size() ) ? rSlotList[ i ] : NULL;
769 5883 : pNextSlot = pEle ? &pEle->xSlot : NULL;
770 54080 : while ( pNextSlot )
771 : {
772 95405 : if ( !pNextSlot->pNextSlot &&
773 47565 : pNextSlot->GetStateMethod() == GetStateMethod()
774 : ) {
775 5526 : break;
776 : }
777 42314 : pEle = ( ++i < rSlotList.size() ) ? rSlotList[ i ] : NULL;
778 42314 : pNextSlot = pEle ? &pEle->xSlot : NULL;
779 : }
780 :
781 5883 : if ( !pNextSlot )
782 : {
783 : // There is no slot behind me that has the same ExecMethod.
784 : // So I search for the first slot with it (could be myself).
785 357 : i = 0;
786 357 : pEle = rSlotList.empty() ? NULL : rSlotList[ i ];
787 357 : pNextSlot = pEle ? &pEle->xSlot : NULL;
788 19447 : while ( pNextSlot != this )
789 : {
790 37929 : if ( !pNextSlot->pEnumValue &&
791 18899 : pNextSlot->GetStateMethod() == GetStateMethod() )
792 297 : break;
793 18733 : pEle = ( ++i < rSlotList.size() ) ? rSlotList[ i ] : NULL;
794 18733 : pNextSlot = pEle ? &pEle->xSlot : NULL;
795 : }
796 : }
797 :
798 5883 : if ( !pLinkedSlot )
799 : {
800 5878 : rOutStm.WriteCharPtr( "0 ," );
801 : }
802 : else
803 : {
804 5 : rOutStm.WriteCharPtr( "&a" ).WriteCharPtr( rShellName.getStr() ).WriteCharPtr( "Slots_Impl[" )
805 15 : .WriteCharPtr( OString::number(pLinkedSlot->GetListPos()).getStr() )
806 5 : .WriteCharPtr( "] /*Offset Linked*/, " ) << endl;
807 5 : WriteTab( rOutStm, 4 );
808 : }
809 :
810 5883 : rOutStm.WriteCharPtr( "&a" ).WriteCharPtr( rShellName.getStr() ).WriteCharPtr( "Slots_Impl[" )
811 17649 : .WriteCharPtr( OString::number(pNextSlot->GetListPos()).getStr() )
812 5883 : .WriteCharPtr( "] /*Offset Next*/, " ) << endl;
813 :
814 5883 : WriteTab( rOutStm, 4 );
815 :
816 : // write ExecMethod, with standard name if not specified
817 11412 : if( !GetExecMethod().isEmpty() &&
818 5529 : GetExecMethod() != "NoExec")
819 : {
820 5522 : rOutStm.WriteCharPtr( "SFX_STUB_PTR(" ).WriteCharPtr( rShellName.getStr() ).WriteChar( ',' )
821 11044 : .WriteCharPtr( GetExecMethod().getStr() ).WriteChar( ')' );
822 : }
823 : else
824 361 : rOutStm.WriteCharPtr( "SFX_STUB_PTR_EXEC_NONE" );
825 5883 : rOutStm.WriteChar( ',' );
826 :
827 : // write StateMethod, with standard name if not specified
828 11411 : if( !GetStateMethod().isEmpty() &&
829 5528 : GetStateMethod() != "NoState")
830 : {
831 5201 : rOutStm.WriteCharPtr( "SFX_STUB_PTR(" ).WriteCharPtr( rShellName.getStr() ).WriteChar( ',' )
832 10402 : .WriteCharPtr( GetStateMethod().getStr() ).WriteChar( ')' );
833 : }
834 : else
835 682 : rOutStm.WriteCharPtr( "SFX_STUB_PTR_STATE_NONE" );
836 : }
837 5951 : rOutStm.WriteChar( ',' ) << endl;
838 5951 : WriteTab( rOutStm, 4 );
839 :
840 : // write flags
841 5951 : if( GetHasCoreId() )
842 0 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_HasCoreId() ).getStr() ).WriteChar( '|' );
843 5951 : if( GetCachable() )
844 5951 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_Cachable() ).getStr() ).WriteChar( '|' );
845 5951 : if( GetVolatile() )
846 0 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_Volatile() ).getStr() ).WriteChar( '|' );
847 5951 : if( GetToggle() )
848 302 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_Toggle() ).getStr() ).WriteChar( '|' );
849 5951 : if( GetAutoUpdate() )
850 1768 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_AutoUpdate() ).getStr() ).WriteChar( '|' );
851 5951 : if( GetSynchron() )
852 4959 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_Synchron() ).getStr() ).WriteChar( '|' );
853 5951 : if( GetAsynchron() )
854 992 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_Asynchron() ).getStr() ).WriteChar( '|' );
855 5951 : if( GetRecordPerItem() )
856 354 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_RecordPerItem() ).getStr() ).WriteChar( '|' );
857 5951 : if( GetRecordPerSet() )
858 5442 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_RecordPerSet() ).getStr() ).WriteChar( '|' );
859 5951 : if( GetRecordManual() )
860 136 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_RecordManual() ).getStr() ).WriteChar( '|' );
861 5951 : if( GetNoRecord() )
862 19 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_NoRecord() ).getStr() ).WriteChar( '|' );
863 5951 : if( GetRecordAbsolute() )
864 4 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_RecordAbsolute() ).getStr() ).WriteChar( '|' );
865 5951 : if( GetHasDialog() )
866 930 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_HasDialog() ).getStr() ).WriteChar( '|' );
867 5951 : if( GetMenuConfig() )
868 3632 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_MenuConfig() ).getStr() ).WriteChar( '|' );
869 5951 : if( GetToolBoxConfig() )
870 3917 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_ToolBoxConfig() ).getStr() ).WriteChar( '|' );
871 5951 : if( GetStatusBarConfig() )
872 96 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_StatusBarConfig() ).getStr() ).WriteChar( '|' );
873 5951 : if( GetAccelConfig() )
874 3728 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_AccelConfig() ).getStr() ).WriteChar( '|' );
875 5951 : if( GetFastCall() )
876 1040 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_FastCall() ).getStr() ).WriteChar( '|' );
877 5951 : if( GetContainer() )
878 206 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_Container() ).getStr() ).WriteChar( '|' );
879 5951 : if ( GetReadOnlyDoc() )
880 1960 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_ReadOnlyDoc() ).getStr() ).WriteChar( '|' );
881 5951 : if( GetImageRotation() )
882 150 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_ImageRotation() ).getStr() ).WriteChar( '|' );
883 5951 : if( GetImageReflection() )
884 96 : rOutStm.WriteCharPtr( MakeSlotName( SvHash_ImageReflection() ).getStr() ).WriteChar( '|' );
885 5951 : rOutStm.WriteCharPtr( "SfxSlotMode::NONE" );
886 :
887 5951 : rOutStm.WriteChar( ',' ) << endl;
888 5951 : WriteTab( rOutStm, 4 );
889 5951 : if ( GetDisableFlags().isEmpty() )
890 4944 : rOutStm.WriteCharPtr( "0" );
891 : else
892 1007 : rOutStm.WriteCharPtr( GetDisableFlags().getStr() );
893 :
894 : // write attribute type
895 5951 : if( !bIsEnumSlot )
896 : {
897 5883 : rOutStm.WriteChar( ',' ) << endl;
898 5883 : WriteTab( rOutStm, 4 );
899 :
900 5883 : SvMetaType * pT = GetSlotType();
901 5883 : if( !pT )
902 : {
903 5400 : if( !IsVariable() )
904 2914 : pT = rBase.FindType( "SfxVoidItem" );
905 : else
906 2486 : pT = GetType();
907 : }
908 5883 : if( pT )
909 : {
910 5883 : rOutStm.WriteCharPtr( pT->GetName().getString().getStr() );
911 5883 : if( !SvIdlDataBase::FindType( pT, rBase.aUsedTypes ) )
912 312 : rBase.aUsedTypes.push_back( pT );
913 : }
914 : else
915 0 : rOutStm.WriteCharPtr( "SfxVoidItem not defined" );
916 : }
917 : else
918 : {
919 68 : SvMetaType *pT = rBase.FindType( "SfxBoolItem" );
920 68 : if ( pT && !SvIdlDataBase::FindType( pT, rBase.aUsedTypes ) )
921 0 : rBase.aUsedTypes.push_back( pT );
922 : }
923 :
924 5951 : if( !bIsEnumSlot )
925 : {
926 5883 : rOutStm.WriteChar( ',' ) << endl;
927 5883 : WriteTab( rOutStm, 4 );
928 : rOutStm
929 11766 : .WriteCharPtr( OString::number(nCount).getStr() )
930 5883 : .WriteCharPtr( "/*Offset*/, " );
931 :
932 5883 : if( IsMethod() )
933 : {
934 3417 : SvMetaAttribute * pMethod = GetMethod();
935 : SvMetaType * pType;
936 3417 : if( pMethod )
937 22 : pType = pMethod->GetType();
938 : else
939 3395 : pType = GetType();
940 3417 : sal_uLong nSCount = pType->GetAttrCount();
941 : rOutStm
942 6834 : .WriteCharPtr( OString::number(nSCount).getStr() )
943 3417 : .WriteCharPtr( "/*Count*/," );
944 : }
945 : else
946 2466 : rOutStm.WriteCharPtr( "0," );
947 :
948 5883 : rOutStm.WriteCharPtr( " " );
949 :
950 : // Method/Property flags
951 5883 : if( IsMethod() )
952 3417 : rOutStm.WriteCharPtr( "SfxSlotMode::METHOD|" );
953 5883 : if( IsVariable() )
954 : {
955 2488 : rOutStm.WriteCharPtr( "SfxSlotMode::PROPGET|" );
956 2488 : if( !GetReadonly() )
957 2347 : rOutStm.WriteCharPtr( "SfxSlotMode::PROPSET|" );
958 : }
959 :
960 5883 : rOutStm.WriteCharPtr( "SfxSlotMode::NONE" );
961 : }
962 :
963 : {
964 5951 : rOutStm.WriteCharPtr( ",\"" );
965 5951 : rOutStm.WriteCharPtr( GetMangleName( false ).getStr() );
966 5951 : rOutStm.WriteCharPtr( "\"" );
967 : }
968 :
969 5951 : rOutStm.WriteCharPtr( " )," ) << endl;
970 : }
971 :
972 5951 : sal_uInt16 SvMetaSlot::WriteSlotParamArray( SvIdlDataBase & rBase, SvStream & rOutStm )
973 : {
974 5951 : if ( !GetExport() && !GetHidden() )
975 0 : return 0;
976 :
977 5951 : SvMetaAttribute * pMethod = GetMethod();
978 5951 : if( IsMethod() )
979 : {
980 : SvMetaType * pType;
981 3439 : if( pMethod )
982 22 : pType = pMethod->GetType();
983 : else
984 3417 : pType = GetType();
985 :
986 3439 : if( !SvIdlDataBase::FindType( pType, rBase.aUsedTypes ) )
987 1915 : rBase.aUsedTypes.push_back( pType );
988 :
989 : const SvMetaAttributeMemberList & rList =
990 3439 : pType->GetAttrList();
991 5892 : for( sal_uLong n = 0; n < rList.size(); n++ )
992 : {
993 2453 : SvMetaAttribute * pPar = rList[n];
994 2453 : SvMetaType * pPType = pPar->GetType();
995 2453 : WriteTab( rOutStm, 1 );
996 2453 : rOutStm.WriteCharPtr("{ (const SfxType*) &a")
997 : // item type
998 4906 : .WriteCharPtr(pPType->GetName().getString().getStr()).WriteCharPtr("_Impl, ")
999 : // parameter name
1000 4906 : .WriteCharPtr("\"").WriteCharPtr(pPar->GetName().getString().getStr()).WriteCharPtr("\", ")
1001 : // slot id
1002 4906 : .WriteCharPtr(pPar->GetSlotId().getString().getStr()).WriteCharPtr(" },") << endl;
1003 2453 : if( !SvIdlDataBase::FindType( pPType, rBase.aUsedTypes ) )
1004 118 : rBase.aUsedTypes.push_back( pPType );
1005 : }
1006 3439 : return (sal_uInt16)rList.size();
1007 : }
1008 2512 : return 0;
1009 : }
1010 :
1011 5951 : sal_uInt16 SvMetaSlot::WriteSlotMap( const OString& rShellName, sal_uInt16 nCount,
1012 : SvSlotElementList& rSlotList,
1013 : size_t nStart,
1014 : SvIdlDataBase & rBase,
1015 : SvStream & rOutStm )
1016 : {
1017 : // SlotId, if not specified generate from name
1018 5951 : OString slotId = GetSlotId().getString();
1019 :
1020 5951 : sal_uInt16 nSCount = 0;
1021 5951 : if( IsMethod() )
1022 : {
1023 : SvMetaType * pType;
1024 3439 : SvMetaAttribute * pMethod = GetMethod();
1025 3439 : if( pMethod )
1026 22 : pType = pMethod->GetType();
1027 : else
1028 3417 : pType = GetType();
1029 :
1030 3439 : nSCount = (sal_uInt16)pType->GetAttrCount();
1031 : }
1032 :
1033 5951 : WriteSlot( rShellName, nCount, slotId, rSlotList, nStart, rBase, rOutStm );
1034 5951 : return nSCount;
1035 : }
1036 :
1037 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
