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