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