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 : #include <assert.h>
21 : #include <stdlib.h>
22 :
23 : #include <sal/log.hxx>
24 :
25 : #include <tools/rcid.h>
26 : #include <tools/stream.hxx>
27 : #include "tools/resmgr.hxx"
28 :
29 : #include <sfx2/module.hxx>
30 : #include <sfx2/objface.hxx>
31 : #include <sfx2/msg.hxx>
32 : #include <sfx2/app.hxx>
33 : #include <sfx2/msgpool.hxx>
34 : #include <sfx2/sfxresid.hxx>
35 : #include <sfx2/objsh.hxx>
36 : #include <rtl/strbuf.hxx>
37 :
38 : extern "C" {
39 :
40 : static int SAL_CALL
41 0 : SfxCompareSlots_qsort( const void* pSmaller, const void* pBigger )
42 : {
43 0 : return ( (int) ((SfxSlot*)pSmaller)->GetSlotId() ) -
44 0 : ( (int) ((SfxSlot*)pBigger)->GetSlotId() );
45 : }
46 :
47 : static int SAL_CALL
48 113508220 : SfxCompareSlots_bsearch( const void* pSmaller, const void* pBigger )
49 : {
50 227016440 : return ( (int) *((sal_uInt16*)pSmaller) ) -
51 227016440 : ( (int) ((SfxSlot*)pBigger)->GetSlotId() );
52 : }
53 :
54 : }
55 :
56 : struct SfxObjectUI_Impl
57 : {
58 : sal_uInt16 nPos;
59 : ResId aResId;
60 : bool bVisible;
61 : bool bContext;
62 : OUString* pName;
63 : sal_uInt32 nFeature;
64 :
65 16522 : SfxObjectUI_Impl(sal_uInt16 n, const ResId& rResId, bool bVis, sal_uInt32 nFeat) :
66 : nPos(n),
67 16522 : aResId(rResId.GetId(), *rResId.GetResMgr()),
68 : bVisible(bVis),
69 : bContext(false),
70 : pName(0),
71 33044 : nFeature(nFeat)
72 : {
73 16522 : aResId.SetRT(rResId.GetRT());
74 16522 : }
75 :
76 6932 : ~SfxObjectUI_Impl()
77 : {
78 6932 : delete pName;
79 6932 : }
80 : };
81 :
82 : typedef std::vector<SfxObjectUI_Impl*> SfxObjectUIArr_Impl;
83 :
84 : struct SfxInterface_Impl
85 : {
86 : SfxObjectUIArr_Impl aObjectBars; // registered ObjectBars
87 : SfxObjectUIArr_Impl aChildWindows; // registered ChildWindows
88 : ResId aPopupRes; // registered PopupMenu
89 : ResId aStatBarRes; // registered StatusBar
90 : SfxModule* pModule;
91 : bool bRegistered;
92 :
93 6651 : SfxInterface_Impl() :
94 6651 : aPopupRes(0,*SfxApplication::GetOrCreate()->GetSfxResManager()),
95 6651 : aStatBarRes(0,*SfxApplication::GetOrCreate()->GetSfxResManager())
96 : , pModule(NULL)
97 19953 : , bRegistered(false)
98 : {
99 6651 : }
100 :
101 2802 : ~SfxInterface_Impl()
102 2802 : {
103 4874 : for (SfxObjectUIArr_Impl::const_iterator it = aObjectBars.begin(); it != aObjectBars.end(); ++it)
104 2072 : delete *it;
105 :
106 7662 : for (SfxObjectUIArr_Impl::const_iterator it = aChildWindows.begin(); it != aChildWindows.end(); ++it)
107 4860 : delete *it;
108 2802 : }
109 : };
110 :
111 : static SfxObjectUI_Impl* CreateObjectBarUI_Impl( sal_uInt16 nPos, const ResId& rResId, sal_uInt32 nFeature, const OUString *pStr );
112 :
113 :
114 :
115 :
116 : // constuctor, registeres a new unit
117 :
118 6651 : SfxInterface::SfxInterface( const char *pClassName,
119 : const ResId& rNameResId,
120 : SfxInterfaceId nId,
121 : const SfxInterface* pParent,
122 : SfxSlot &rSlotMap, sal_uInt16 nSlotCount ):
123 : pName(pClassName),
124 : pGenoType(pParent),
125 : nClassId(nId),
126 6651 : aNameResId(rNameResId.GetId(),*rNameResId.GetResMgr()),
127 13302 : pImpData(0)
128 : {
129 6651 : pImpData = new SfxInterface_Impl;
130 6651 : SetSlotMap( rSlotMap, nSlotCount );
131 6651 : }
132 :
133 6621 : void SfxInterface::Register( SfxModule* pMod )
134 : {
135 6621 : pImpData->bRegistered = true;
136 6621 : pImpData->pModule = pMod;
137 6621 : if ( pMod )
138 4596 : pMod->GetSlotPool()->RegisterInterface(*this);
139 : else
140 2025 : SfxGetpApp()->GetAppSlotPool_Impl().RegisterInterface(*this);
141 6621 : }
142 :
143 6651 : void SfxInterface::SetSlotMap( SfxSlot& rSlotMap, sal_uInt16 nSlotCount )
144 : {
145 6651 : pSlots = &rSlotMap;
146 6651 : nCount = nSlotCount;
147 6651 : SfxSlot* pIter = pSlots;
148 6651 : if ( 1 == nCount && !pIter->pNextSlot )
149 1077 : pIter->pNextSlot = pIter;
150 :
151 6651 : if ( !pIter->pNextSlot )
152 : {
153 : // sort the SfxSlots by id
154 0 : qsort( pSlots, nCount, sizeof(SfxSlot), SfxCompareSlots_qsort );
155 :
156 : // link masters and slaves
157 0 : sal_uInt16 nIter = 1;
158 0 : for ( pIter = pSlots; nIter <= nCount; ++pIter, ++nIter )
159 : {
160 :
161 : assert( nIter == nCount ||
162 : pIter->GetSlotId() != (pIter+1)->GetSlotId() );
163 :
164 : // every master refers to his first slave (ENUM),
165 : // all slaves refer to their master.
166 : // Slaves refer in a circle to the other slaves with the same master
167 0 : if ( pIter->GetKind() == SFX_KIND_ENUM )
168 : {
169 0 : pIter->pLinkedSlot = GetSlot( pIter->nMasterSlotId );
170 : assert( pIter->pLinkedSlot );
171 0 : if ( !pIter->pLinkedSlot->pLinkedSlot )
172 0 : ( (SfxSlot*) pIter->pLinkedSlot)->pLinkedSlot = pIter;
173 :
174 0 : if ( 0 == pIter->GetNextSlot() )
175 : {
176 0 : SfxSlot *pLastSlot = pIter;
177 0 : for ( sal_uInt16 n = nIter; n < Count(); ++n )
178 : {
179 0 : SfxSlot *pCurSlot = (pSlots+n);
180 0 : if ( pCurSlot->nMasterSlotId == pIter->nMasterSlotId )
181 : {
182 0 : pLastSlot->pNextSlot = pCurSlot;
183 0 : pLastSlot = pCurSlot;
184 : }
185 : }
186 0 : pLastSlot->pNextSlot = pIter;
187 : }
188 : }
189 0 : else if ( 0 == pIter->GetNextSlot() )
190 : {
191 : // Slots referring in circle to the next with the same
192 : // Status method.
193 0 : SfxSlot *pLastSlot = pIter;
194 0 : for ( sal_uInt16 n = nIter; n < Count(); ++n )
195 : {
196 0 : SfxSlot *pCurSlot = (pSlots+n);
197 0 : if ( pCurSlot->GetStateFnc() == pIter->GetStateFnc() )
198 : {
199 0 : pLastSlot->pNextSlot = pCurSlot;
200 0 : pLastSlot = pCurSlot;
201 : }
202 : }
203 0 : pLastSlot->pNextSlot = pIter;
204 : }
205 : }
206 : }
207 : #ifdef DBG_UTIL
208 : else
209 : {
210 : sal_uInt16 nIter = 1;
211 : for ( SfxSlot *pNext = pIter+1; nIter < nCount; ++pNext, ++nIter )
212 : {
213 :
214 : if ( pNext->GetSlotId() <= pIter->GetSlotId() )
215 : SAL_WARN( "sfx.control", "Wrong order" );
216 :
217 : if ( pIter->GetKind() == SFX_KIND_ENUM )
218 : {
219 : const SfxSlot *pMasterSlot = GetSlot(pIter->nMasterSlotId);
220 : const SfxSlot *pFirstSlave = pMasterSlot->pLinkedSlot;
221 : const SfxSlot *pSlave = pFirstSlave;
222 : do
223 : {
224 : if ( pSlave->pLinkedSlot != pMasterSlot )
225 : {
226 : OStringBuffer aStr("Wrong Master/Slave- link: ");
227 : aStr.append(static_cast<sal_Int32>(
228 : pMasterSlot->GetSlotId()));
229 : aStr.append(" , ");
230 : aStr.append(static_cast<sal_Int32>(
231 : pSlave->GetSlotId()));
232 : SAL_WARN("sfx.control", aStr.getStr());
233 : }
234 :
235 : if ( pSlave->nMasterSlotId != pMasterSlot->GetSlotId() )
236 : {
237 : OStringBuffer aStr("Wrong Master/Slave-Ids: ");
238 : aStr.append(static_cast<sal_Int32>(
239 : pMasterSlot->GetSlotId()));
240 : aStr.append(" , ");
241 : aStr.append(static_cast<sal_Int32>(
242 : pSlave->GetSlotId()));
243 : SAL_WARN("sfx.control", aStr.getStr());
244 : }
245 :
246 : pSlave = pSlave->pNextSlot;
247 : }
248 : while ( pSlave != pFirstSlave );
249 : }
250 : else
251 : {
252 : if ( pIter->pLinkedSlot )
253 : {
254 : if ( pIter->pLinkedSlot->GetKind() != SFX_KIND_ENUM )
255 : {
256 : OStringBuffer aStr("Slave is no enum: ");
257 : aStr.append(static_cast<sal_Int32>(pIter->GetSlotId()));
258 : aStr.append(" , ");
259 : aStr.append(static_cast<sal_Int32>(
260 : pIter->pLinkedSlot->GetSlotId()));
261 : SAL_WARN("sfx.control", aStr.getStr());
262 : }
263 : }
264 :
265 : const SfxSlot *pCurSlot = pIter;
266 : do
267 : {
268 : pCurSlot = pCurSlot->pNextSlot;
269 : if ( pCurSlot->GetStateFnc() != pIter->GetStateFnc() )
270 : {
271 : OStringBuffer aStr("Linked Slots with different State Methods : ");
272 : aStr.append(static_cast<sal_Int32>(
273 : pCurSlot->GetSlotId()));
274 : aStr.append(" , ");
275 : aStr.append(static_cast<sal_Int32>(pIter->GetSlotId()));
276 : SAL_WARN("sfx.control", aStr.getStr());
277 : }
278 : }
279 : while ( pCurSlot != pIter );
280 : }
281 :
282 : pIter = pNext;
283 : }
284 : }
285 : #endif
286 6651 : }
287 :
288 :
289 :
290 5604 : SfxInterface::~SfxInterface()
291 : {
292 2802 : SfxModule *pMod = pImpData->pModule;
293 2802 : bool bRegistered = pImpData->bRegistered;
294 2802 : delete pImpData;
295 : assert( bRegistered );
296 2802 : if ( bRegistered )
297 : {
298 2802 : if ( pMod )
299 1776 : pMod->GetSlotPool()->ReleaseInterface(*this);
300 : else
301 1026 : SfxGetpApp()->GetAppSlotPool_Impl().ReleaseInterface(*this);
302 : }
303 5604 : }
304 :
305 :
306 :
307 : // searches for the specified func
308 :
309 23365142 : const SfxSlot* SfxInterface::GetSlot( sal_uInt16 nFuncId ) const
310 : {
311 :
312 : assert( pSlots );
313 : assert( nCount );
314 :
315 : // find the id using binary search
316 : void* p = bsearch( &nFuncId, pSlots, nCount, sizeof(SfxSlot),
317 23365142 : SfxCompareSlots_bsearch );
318 23365142 : if ( !p && pGenoType )
319 11859328 : return pGenoType->GetSlot( nFuncId );
320 :
321 11505814 : return p ? (const SfxSlot*)p : 0;
322 : }
323 :
324 9460050 : const SfxSlot* SfxInterface::GetSlot( const OUString& rCommand ) const
325 : {
326 : static const char UNO_COMMAND[] = ".uno:";
327 :
328 9460050 : OUString aCommand( rCommand );
329 9460050 : if ( aCommand.startsWith( UNO_COMMAND ) )
330 4619 : aCommand = aCommand.copy( sizeof( UNO_COMMAND )-1 );
331 :
332 421019131 : for ( sal_uInt16 n=0; n<nCount; n++ )
333 : {
334 824087626 : if ( (pSlots+n)->pUnoName &&
335 412033841 : aCommand.compareToIgnoreAsciiCaseAscii( (pSlots+n)->GetUnoName() ) == 0 )
336 494704 : return pSlots+n;
337 : }
338 :
339 8965346 : return pGenoType ? pGenoType->GetSlot( aCommand ) : NULL;
340 : }
341 :
342 :
343 :
344 0 : const SfxSlot* SfxInterface::GetRealSlot( const SfxSlot *pSlot ) const
345 : {
346 :
347 : assert( pSlots );
348 : assert( nCount );
349 :
350 0 : if ( !ContainsSlot_Impl(pSlot) )
351 : {
352 0 : if(pGenoType)
353 0 : return pGenoType->GetRealSlot(pSlot);
354 : SAL_WARN( "sfx.control", "unknown Slot" );
355 0 : return 0;
356 : }
357 :
358 0 : return pSlot->pLinkedSlot;
359 : }
360 :
361 :
362 :
363 0 : const SfxSlot* SfxInterface::GetRealSlot( sal_uInt16 nSlotId ) const
364 : {
365 :
366 : assert( pSlots );
367 : assert( nCount );
368 :
369 0 : const SfxSlot *pSlot = GetSlot(nSlotId);
370 0 : if ( !pSlot )
371 : {
372 0 : if(pGenoType)
373 0 : return pGenoType->GetRealSlot(nSlotId);
374 : SAL_WARN( "sfx.control", "unknown Slot" );
375 0 : return 0;
376 : }
377 :
378 0 : return pSlot->pLinkedSlot;
379 : }
380 :
381 :
382 :
383 2816 : void SfxInterface::RegisterPopupMenu( const ResId& rResId )
384 : {
385 :
386 2816 : pImpData->aPopupRes = rResId;
387 2816 : }
388 :
389 :
390 :
391 4210 : void SfxInterface::RegisterObjectBar( sal_uInt16 nPos, const ResId& rResId,
392 : const OUString *pStr )
393 : {
394 4210 : RegisterObjectBar( nPos, rResId, 0UL, pStr );
395 4210 : }
396 :
397 :
398 5230 : void SfxInterface::RegisterObjectBar( sal_uInt16 nPos, const ResId& rResId, sal_uInt32 nFeature, const OUString *pStr )
399 : {
400 5230 : SfxObjectUI_Impl* pUI = CreateObjectBarUI_Impl( nPos, rResId, nFeature, pStr );
401 5230 : if ( pUI )
402 5230 : pImpData->aObjectBars.push_back(pUI);
403 5230 : }
404 :
405 5230 : SfxObjectUI_Impl* CreateObjectBarUI_Impl( sal_uInt16 nPos, const ResId& rResId, sal_uInt32 nFeature, const OUString *pStr )
406 : {
407 5230 : if ((nPos & SFX_VISIBILITY_MASK) == 0)
408 2088 : nPos |= SFX_VISIBILITY_STANDARD;
409 :
410 5230 : SfxObjectUI_Impl* pUI = new SfxObjectUI_Impl(nPos, rResId, true, nFeature);
411 :
412 5230 : if (pStr == 0)
413 : {
414 5230 : ResId aResId(rResId);
415 5230 : aResId.SetRT(RSC_STRING);
416 5230 : aResId.SetResMgr(rResId.GetResMgr());
417 5230 : if( ! aResId.GetResMgr() )
418 0 : aResId.SetResMgr( SfxApplication::GetOrCreate()->GetOffResManager_Impl() );
419 5230 : if ( !aResId.GetResMgr() || !aResId.GetResMgr()->IsAvailable(aResId) )
420 620 : pUI->pName = new OUString ("NoName");
421 : else
422 4610 : pUI->pName = new OUString(aResId.toString());
423 : }
424 : else
425 0 : pUI->pName = new OUString(*pStr);
426 :
427 5230 : return pUI;
428 : }
429 :
430 64291 : const ResId& SfxInterface::GetObjectBarResId( sal_uInt16 nNo ) const
431 : {
432 64291 : bool bGenoType = (pGenoType != 0 && !pGenoType->HasName());
433 64291 : if ( bGenoType )
434 : {
435 : // Are there toolbars in the super class?
436 17646 : sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount();
437 17646 : if ( nNo < nBaseCount )
438 : // The Super class comes first
439 0 : return pGenoType->GetObjectBarResId( nNo );
440 : else
441 17646 : nNo = nNo - nBaseCount;
442 : }
443 :
444 : assert( nNo<pImpData->aObjectBars.size() );
445 :
446 64291 : return pImpData->aObjectBars[nNo]->aResId;
447 : }
448 :
449 :
450 :
451 :
452 97476 : sal_uInt16 SfxInterface::GetObjectBarPos( sal_uInt16 nNo ) const
453 : {
454 97476 : bool bGenoType = (pGenoType != 0 && !pGenoType->HasName());
455 97476 : if ( bGenoType )
456 : {
457 : // Are there toolbars in the super class?
458 27954 : sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount();
459 27954 : if ( nNo < nBaseCount )
460 : // The Super class comes first
461 0 : return pGenoType->GetObjectBarPos( nNo );
462 : else
463 27954 : nNo = nNo - nBaseCount;
464 : }
465 :
466 : assert( nNo<pImpData->aObjectBars.size() );
467 :
468 97476 : return pImpData->aObjectBars[nNo]->nPos;
469 : }
470 :
471 :
472 :
473 :
474 361582 : sal_uInt16 SfxInterface::GetObjectBarCount() const
475 : {
476 361582 : if (pGenoType && ! pGenoType->HasName())
477 74501 : return pImpData->aObjectBars.size() + pGenoType->GetObjectBarCount();
478 : else
479 287081 : return pImpData->aObjectBars.size();
480 : }
481 :
482 :
483 10266 : void SfxInterface::RegisterChildWindow(sal_uInt16 nId, bool bContext, const OUString* pChildWinName)
484 : {
485 10266 : RegisterChildWindow( nId, bContext, 0UL, pChildWinName );
486 10266 : }
487 :
488 11292 : void SfxInterface::RegisterChildWindow(sal_uInt16 nId, bool bContext, sal_uInt32 nFeature, const OUString*)
489 : {
490 11292 : SfxObjectUI_Impl* pUI = new SfxObjectUI_Impl(0, ResId(nId, *SfxApplication::GetOrCreate()->GetOffResManager_Impl()), true, nFeature);
491 11292 : pUI->bContext = bContext;
492 11292 : pImpData->aChildWindows.push_back(pUI);
493 11292 : }
494 :
495 527 : void SfxInterface::RegisterStatusBar(const ResId& rResId)
496 : {
497 527 : pImpData->aStatBarRes = rResId;
498 527 : }
499 :
500 :
501 433955 : sal_uInt32 SfxInterface::GetChildWindowId (sal_uInt16 nNo) const
502 : {
503 433955 : if ( pGenoType )
504 : {
505 : // Are there ChildWindows in der Superklasse?
506 224811 : sal_uInt16 nBaseCount = pGenoType->GetChildWindowCount();
507 224811 : if ( nNo < nBaseCount )
508 : // The Super class comes first
509 23944 : return pGenoType->GetChildWindowId( nNo );
510 : else
511 200867 : nNo = nNo - nBaseCount;
512 : }
513 :
514 : assert( nNo<pImpData->aChildWindows.size() );
515 :
516 410011 : sal_uInt32 nRet = pImpData->aChildWindows[nNo]->aResId.GetId();
517 410011 : if ( pImpData->aChildWindows[nNo]->bContext )
518 11833 : nRet += sal_uInt32( nClassId ) << 16;
519 410011 : return nRet;
520 : }
521 :
522 433735 : sal_uInt32 SfxInterface::GetChildWindowFeature (sal_uInt16 nNo) const
523 : {
524 433735 : if ( pGenoType )
525 : {
526 : // Are there ChildWindows in der Superklasse?
527 224661 : sal_uInt16 nBaseCount = pGenoType->GetChildWindowCount();
528 224661 : if ( nNo < nBaseCount )
529 : // The Super class comes first
530 23904 : return pGenoType->GetChildWindowFeature( nNo );
531 : else
532 200757 : nNo = nNo - nBaseCount;
533 : }
534 :
535 : assert( nNo<pImpData->aChildWindows.size() );
536 :
537 409831 : return pImpData->aChildWindows[nNo]->nFeature;
538 : }
539 :
540 :
541 :
542 :
543 1213032 : sal_uInt16 SfxInterface::GetChildWindowCount() const
544 : {
545 1213032 : if (pGenoType)
546 272768 : return pImpData->aChildWindows.size() + pGenoType->GetChildWindowCount();
547 : else
548 940264 : return pImpData->aChildWindows.size();
549 : }
550 :
551 :
552 0 : const ResId& SfxInterface::GetPopupMenuResId() const
553 : {
554 0 : return pImpData->aPopupRes;
555 : }
556 :
557 :
558 117627 : const ResId& SfxInterface::GetStatusBarResId() const
559 : {
560 117627 : if (pImpData->aStatBarRes.GetId() == 0 && pGenoType)
561 36846 : return pGenoType->GetStatusBarResId();
562 : else
563 80781 : return pImpData->aStatBarRes;
564 : }
565 :
566 :
567 :
568 64291 : const OUString* SfxInterface::GetObjectBarName ( sal_uInt16 nNo ) const
569 : {
570 64291 : bool bGenoType = (pGenoType != 0 && !pGenoType->HasName());
571 64291 : if ( bGenoType )
572 : {
573 : // Are there toolbars in the super class?
574 17646 : sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount();
575 17646 : if ( nNo < nBaseCount )
576 : // The Super class comes first
577 0 : return pGenoType->GetObjectBarName( nNo );
578 : else
579 17646 : nNo = nNo - nBaseCount;
580 : }
581 :
582 : assert( nNo<pImpData->aObjectBars.size() );
583 :
584 64291 : return pImpData->aObjectBars[nNo]->pName;
585 : }
586 :
587 97424 : sal_uInt32 SfxInterface::GetObjectBarFeature ( sal_uInt16 nNo ) const
588 : {
589 97424 : bool bGenoType = (pGenoType != 0 && !pGenoType->HasName());
590 97424 : if ( bGenoType )
591 : {
592 : // Are there toolbars in the super class?
593 27932 : sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount();
594 27932 : if ( nNo < nBaseCount )
595 : // The Super class comes first
596 0 : return pGenoType->GetObjectBarFeature( nNo );
597 : else
598 27932 : nNo = nNo - nBaseCount;
599 : }
600 :
601 : assert( nNo<pImpData->aObjectBars.size() );
602 :
603 97424 : return pImpData->aObjectBars[nNo]->nFeature;
604 : }
605 :
606 64291 : bool SfxInterface::IsObjectBarVisible(sal_uInt16 nNo) const
607 : {
608 64291 : bool bGenoType = (pGenoType != 0 && !pGenoType->HasName());
609 64291 : if ( bGenoType )
610 : {
611 : // Are there toolbars in the super class?
612 17646 : sal_uInt16 nBaseCount = pGenoType->GetObjectBarCount();
613 17646 : if ( nNo < nBaseCount )
614 : // The Super class comes first
615 0 : return pGenoType->IsObjectBarVisible( nNo );
616 : else
617 17646 : nNo = nNo - nBaseCount;
618 : }
619 :
620 : assert( nNo<pImpData->aObjectBars.size() );
621 :
622 64291 : return pImpData->aObjectBars[nNo]->bVisible;
623 951 : }
624 :
625 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
