Branch data 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 "basecontainercontrol.hxx"
21 : :
22 : : #include <cppuhelper/typeprovider.hxx>
23 : :
24 : : //____________________________________________________________________________________________________________
25 : : // namespaces
26 : : //____________________________________________________________________________________________________________
27 : :
28 : : using namespace ::cppu ;
29 : : using namespace ::osl ;
30 : : using namespace ::rtl ;
31 : : using namespace ::com::sun::star::uno ;
32 : : using namespace ::com::sun::star::lang ;
33 : : using namespace ::com::sun::star::awt ;
34 : : using namespace ::com::sun::star::container ;
35 : :
36 : : namespace unocontrols{
37 : :
38 : : //____________________________________________________________________________________________________________
39 : : // construct/destruct
40 : : //____________________________________________________________________________________________________________
41 : :
42 : 0 : BaseContainerControl::BaseContainerControl( const Reference< XMultiServiceFactory >& xFactory )
43 : : : BaseControl ( xFactory )
44 : 0 : , m_aListeners ( m_aMutex )
45 : : {
46 : 0 : }
47 : :
48 : 0 : BaseContainerControl::~BaseContainerControl()
49 : : {
50 : 0 : impl_cleanMemory();
51 : 0 : }
52 : :
53 : : //____________________________________________________________________________________________________________
54 : : // XInterface
55 : : //____________________________________________________________________________________________________________
56 : :
57 : 0 : Any SAL_CALL BaseContainerControl::queryInterface( const Type& rType ) throw( RuntimeException )
58 : : {
59 : : // Attention:
60 : : // Don't use mutex or guard in this method!!! Is a method of XInterface.
61 : 0 : Any aReturn ;
62 : 0 : Reference< XInterface > xDel = BaseControl::impl_getDelegator();
63 : 0 : if ( xDel.is() == sal_True )
64 : : {
65 : : // If an delegator exist, forward question to his queryInterface.
66 : : // Delegator will ask his own queryAggregation!
67 : 0 : aReturn = xDel->queryInterface( rType );
68 : : }
69 : : else
70 : : {
71 : : // If an delegator unknown, forward question to own queryAggregation.
72 : 0 : aReturn = queryAggregation( rType );
73 : : }
74 : :
75 : 0 : return aReturn ;
76 : : }
77 : :
78 : : //____________________________________________________________________________________________________________
79 : : // XTypeProvider
80 : : //____________________________________________________________________________________________________________
81 : :
82 : 0 : Sequence< Type > SAL_CALL BaseContainerControl::getTypes() throw( RuntimeException )
83 : : {
84 : : // Optimize this method !
85 : : // We initialize a static variable only one time. And we don't must use a mutex at every call!
86 : : // For the first call; pTypeCollection is NULL - for the second call pTypeCollection is different from NULL!
87 : : static OTypeCollection* pTypeCollection = NULL ;
88 : :
89 : 0 : if ( pTypeCollection == NULL )
90 : : {
91 : : // Ready for multithreading; get global mutex for first call of this method only! see before
92 : 0 : MutexGuard aGuard( Mutex::getGlobalMutex() );
93 : :
94 : : // Control these pointer again ... it can be, that another instance will be faster then these!
95 : 0 : if ( pTypeCollection == NULL )
96 : : {
97 : : // Create a static typecollection ...
98 : 0 : static OTypeCollection aTypeCollection ( ::getCppuType(( const Reference< XControlModel >*)NULL ) ,
99 : 0 : ::getCppuType(( const Reference< XControlContainer >*)NULL ) ,
100 : : BaseControl::getTypes()
101 : 0 : );
102 : : // ... and set his address to static pointer!
103 : 0 : pTypeCollection = &aTypeCollection ;
104 : 0 : }
105 : : }
106 : :
107 : 0 : return pTypeCollection->getTypes();
108 : : }
109 : :
110 : : //____________________________________________________________________________________________________________
111 : : // XAggregation
112 : : //____________________________________________________________________________________________________________
113 : :
114 : 0 : Any SAL_CALL BaseContainerControl::queryAggregation( const Type& aType ) throw( RuntimeException )
115 : : {
116 : : // Ask for my own supported interfaces ...
117 : : // Attention: XTypeProvider and XInterface are supported by OComponentHelper!
118 : : Any aReturn ( ::cppu::queryInterface( aType ,
119 : : static_cast< XControlModel* > ( this ) ,
120 : : static_cast< XControlContainer* > ( this )
121 : : )
122 : 0 : );
123 : :
124 : : // If searched interface supported by this class ...
125 : 0 : if ( aReturn.hasValue() == sal_True )
126 : : {
127 : : // ... return this information.
128 : 0 : return aReturn ;
129 : : }
130 : : else
131 : : {
132 : : // Else; ... ask baseclass for interfaces!
133 : 0 : return BaseControl::queryAggregation( aType );
134 : 0 : }
135 : : }
136 : :
137 : : //____________________________________________________________________________________________________________
138 : : // XControl
139 : : //____________________________________________________________________________________________________________
140 : :
141 : 0 : void SAL_CALL BaseContainerControl::createPeer( const Reference< XToolkit >& xToolkit ,
142 : : const Reference< XWindowPeer >& xParent ) throw( RuntimeException )
143 : : {
144 : 0 : if ( getPeer().is() == sal_False )
145 : : {
146 : : // create own peer
147 : 0 : BaseControl::createPeer( xToolkit, xParent );
148 : :
149 : : // create peers at all children
150 : 0 : Sequence< Reference< XControl > > seqControlList = getControls();
151 : 0 : sal_uInt32 nControls = seqControlList.getLength();
152 : :
153 : 0 : for ( sal_uInt32 n=0; n<nControls; n++ )
154 : : {
155 : 0 : seqControlList.getArray()[n]->createPeer( xToolkit, getPeer() );
156 : : }
157 : :
158 : : // activate new tab order
159 : 0 : impl_activateTabControllers();
160 : :
161 : : }
162 : 0 : }
163 : :
164 : : //____________________________________________________________________________________________________________
165 : : // XControl
166 : : //____________________________________________________________________________________________________________
167 : :
168 : 0 : sal_Bool SAL_CALL BaseContainerControl::setModel( const Reference< XControlModel >& ) throw( RuntimeException )
169 : : {
170 : : // This object has NO model.
171 : 0 : return sal_False ;
172 : : }
173 : :
174 : : //____________________________________________________________________________________________________________
175 : : // XControl
176 : : //____________________________________________________________________________________________________________
177 : :
178 : 0 : Reference< XControlModel > SAL_CALL BaseContainerControl::getModel() throw( RuntimeException )
179 : : {
180 : : // This object has NO model.
181 : : // return (XControlModel*)this ;
182 : 0 : return Reference< XControlModel >();
183 : : }
184 : :
185 : : //____________________________________________________________________________________________________________
186 : : // XComponent
187 : : //____________________________________________________________________________________________________________
188 : :
189 : 0 : void SAL_CALL BaseContainerControl::dispose() throw( RuntimeException )
190 : : {
191 : : // Tell everything that this container is now gone.
192 : : // It's faster if you listen to both the control and the container.
193 : :
194 : : // Ready for multithreading
195 : 0 : MutexGuard aGuard( m_aMutex );
196 : :
197 : : // remove listeners
198 : 0 : EventObject aObject ;
199 : :
200 : 0 : aObject.Source = Reference< XComponent > ( (XControlContainer*)this, UNO_QUERY );
201 : 0 : m_aListeners.disposeAndClear( aObject );
202 : :
203 : : // remove controls
204 : 0 : Sequence< Reference< XControl > > seqCtrls = getControls();
205 : 0 : Reference< XControl > * pCtrls = seqCtrls.getArray();
206 : 0 : sal_uInt32 nCtrls = seqCtrls.getLength();
207 : 0 : size_t nMaxCount = maControlInfoList.size();
208 : 0 : size_t nCount = 0;
209 : :
210 : 0 : for ( nCount = 0; nCount < nMaxCount; ++nCount )
211 : : {
212 : 0 : delete maControlInfoList[ nCount ];
213 : : }
214 : 0 : maControlInfoList.clear();
215 : :
216 : 0 : for ( nCount = 0; nCount < nCtrls; ++nCount )
217 : : {
218 : 0 : pCtrls [ nCount ] -> removeEventListener ( static_cast< XEventListener* >( static_cast< XWindowListener* >( this ) ) ) ;
219 : 0 : pCtrls [ nCount ] -> dispose ( ) ;
220 : : }
221 : :
222 : : // call baseclass
223 : 0 : BaseControl::dispose();
224 : 0 : }
225 : :
226 : : //____________________________________________________________________________________________________________
227 : : // XEventListener
228 : : //____________________________________________________________________________________________________________
229 : :
230 : 0 : void SAL_CALL BaseContainerControl::disposing( const EventObject& rEvent ) throw( RuntimeException )
231 : : {
232 : 0 : Reference< XControl > xControl( rEvent.Source, UNO_QUERY );
233 : :
234 : : // "removeControl" remove only, when control is an active control
235 : 0 : removeControl( xControl );
236 : 0 : }
237 : :
238 : : //____________________________________________________________________________________________________________
239 : : // XControlContainer
240 : : //____________________________________________________________________________________________________________
241 : :
242 : 0 : void SAL_CALL BaseContainerControl::addControl ( const OUString& rName, const Reference< XControl > & rControl ) throw( RuntimeException )
243 : : {
244 : 0 : if ( !rControl.is () )
245 : 0 : return;
246 : :
247 : : // take memory for new item
248 : 0 : IMPL_ControlInfo* pNewControl = new IMPL_ControlInfo ;
249 : :
250 : 0 : if (pNewControl!=(IMPL_ControlInfo*)0)
251 : : {
252 : : // Ready for multithreading
253 : 0 : MutexGuard aGuard (m_aMutex) ;
254 : :
255 : : // set control
256 : 0 : pNewControl->sName = rName ;
257 : 0 : pNewControl->xControl = rControl ;
258 : :
259 : : // and insert in list
260 : 0 : maControlInfoList.push_back( pNewControl ) ;
261 : :
262 : : // initialize new control
263 : 0 : pNewControl->xControl->setContext ( (OWeakObject*)this ) ;
264 : 0 : pNewControl->xControl->addEventListener ( static_cast< XEventListener* >( static_cast< XWindowListener* >( this ) ) ) ;
265 : :
266 : : // when container has a peer ...
267 : 0 : if (getPeer().is())
268 : : {
269 : : // .. then create a peer on child
270 : 0 : pNewControl->xControl->createPeer ( getPeer()->getToolkit(), getPeer() ) ;
271 : 0 : impl_activateTabControllers () ;
272 : : }
273 : :
274 : : // Send message to all listener
275 : 0 : OInterfaceContainerHelper* pInterfaceContainer = m_aListeners.getContainer( ::getCppuType((const Reference< XContainerListener >*)0) ) ;
276 : :
277 : 0 : if (pInterfaceContainer)
278 : : {
279 : : // Build event
280 : 0 : ContainerEvent aEvent ;
281 : :
282 : 0 : aEvent.Source = *this ;
283 : 0 : aEvent.Element <<= rControl ;
284 : :
285 : : // Get all listener
286 : 0 : OInterfaceIteratorHelper aIterator (*pInterfaceContainer) ;
287 : :
288 : : // Send event
289 : 0 : while ( aIterator.hasMoreElements() )
290 : : {
291 : 0 : ((XContainerListener*)aIterator.next())->elementInserted (aEvent) ;
292 : 0 : }
293 : 0 : }
294 : : }
295 : : }
296 : :
297 : : //____________________________________________________________________________________________________________
298 : : // XControlContainer
299 : : //____________________________________________________________________________________________________________
300 : :
301 : 0 : void SAL_CALL BaseContainerControl::addContainerListener ( const Reference< XContainerListener > & rListener ) throw( RuntimeException )
302 : : {
303 : : // Ready for multithreading
304 : 0 : MutexGuard aGuard ( m_aMutex ) ;
305 : :
306 : 0 : m_aListeners.addInterface ( ::getCppuType((const Reference< XContainerListener >*)0), rListener ) ;
307 : 0 : }
308 : :
309 : : //____________________________________________________________________________________________________________
310 : : // XControlContainer
311 : : //____________________________________________________________________________________________________________
312 : :
313 : 0 : void SAL_CALL BaseContainerControl::removeControl ( const Reference< XControl > & rControl ) throw( RuntimeException )
314 : : {
315 : 0 : if ( rControl.is() )
316 : : {
317 : : // Ready for multithreading
318 : 0 : MutexGuard aGuard (m_aMutex) ;
319 : :
320 : 0 : size_t nControls = maControlInfoList.size();
321 : :
322 : 0 : for ( size_t n = 0; n < nControls; n++ )
323 : : {
324 : : // Search for right control
325 : 0 : IMPL_ControlInfo* pControl = maControlInfoList[ n ] ;
326 : 0 : if ( rControl == pControl->xControl )
327 : : {
328 : : //.is it found ... remove listener from control
329 : 0 : pControl->xControl->removeEventListener (static_cast< XEventListener* >( static_cast< XWindowListener* >( this ) )) ;
330 : 0 : pControl->xControl->setContext ( Reference< XInterface > () ) ;
331 : :
332 : : // ... free memory
333 : 0 : delete pControl ;
334 : 0 : ::std::vector<IMPL_ControlInfo*>::iterator itr = maControlInfoList.begin();
335 : 0 : ::std::advance(itr, n);
336 : 0 : maControlInfoList.erase(itr);
337 : :
338 : : // Send message to all other listener
339 : 0 : OInterfaceContainerHelper * pInterfaceContainer = m_aListeners.getContainer( ::getCppuType((const Reference< XContainerListener >*)0) ) ;
340 : :
341 : 0 : if (pInterfaceContainer)
342 : : {
343 : 0 : ContainerEvent aEvent ;
344 : :
345 : 0 : aEvent.Source = *this ;
346 : 0 : aEvent.Element <<= rControl ;
347 : :
348 : 0 : OInterfaceIteratorHelper aIterator (*pInterfaceContainer) ;
349 : :
350 : 0 : while ( aIterator.hasMoreElements() )
351 : : {
352 : 0 : ((XContainerListener*)aIterator.next())->elementRemoved (aEvent) ;
353 : 0 : }
354 : : }
355 : : // Break "for" !
356 : : break ;
357 : : }
358 : 0 : }
359 : : }
360 : 0 : }
361 : :
362 : : //____________________________________________________________________________________________________________
363 : : // XControlContainer
364 : : //____________________________________________________________________________________________________________
365 : :
366 : 0 : void SAL_CALL BaseContainerControl::removeContainerListener ( const Reference< XContainerListener > & rListener ) throw( RuntimeException )
367 : : {
368 : : // Ready for multithreading
369 : 0 : MutexGuard aGuard ( m_aMutex ) ;
370 : :
371 : 0 : m_aListeners.removeInterface ( ::getCppuType((const Reference< XContainerListener >*)0), rListener ) ;
372 : 0 : }
373 : :
374 : : //____________________________________________________________________________________________________________
375 : : // XControlContainer
376 : : //____________________________________________________________________________________________________________
377 : :
378 : 0 : void SAL_CALL BaseContainerControl::setStatusText ( const OUString& rStatusText ) throw( RuntimeException )
379 : : {
380 : : // go down to each parent
381 : 0 : Reference< XControlContainer > xContainer ( getContext(), UNO_QUERY ) ;
382 : :
383 : 0 : if ( xContainer.is () )
384 : : {
385 : 0 : xContainer->setStatusText ( rStatusText ) ;
386 : 0 : }
387 : 0 : }
388 : :
389 : : //____________________________________________________________________________________________________________
390 : : // XControlContainer
391 : : //____________________________________________________________________________________________________________
392 : :
393 : 0 : Reference< XControl > SAL_CALL BaseContainerControl::getControl ( const OUString& rName ) throw( RuntimeException )
394 : : {
395 : : // Ready for multithreading
396 : 0 : MutexGuard aGuard ( Mutex::getGlobalMutex() ) ;
397 : :
398 : 0 : Reference< XControl > xRetControl = Reference< XControl > ();
399 : 0 : size_t nControls = maControlInfoList.size();
400 : :
401 : : // Search for right control
402 : 0 : for( size_t nCount = 0; nCount < nControls; ++nCount )
403 : : {
404 : 0 : IMPL_ControlInfo* pSearchControl = maControlInfoList[ nCount ];
405 : :
406 : 0 : if ( pSearchControl->sName == rName )
407 : : {
408 : : // We have found it ...
409 : : // Break operation and return.
410 : 0 : return pSearchControl->xControl ;
411 : : }
412 : : }
413 : :
414 : : // We have not found it ... return NULL.
415 : 0 : return Reference< XControl > () ;
416 : : }
417 : :
418 : : //____________________________________________________________________________________________________________
419 : : // XControlContainer
420 : : //____________________________________________________________________________________________________________
421 : :
422 : 0 : Sequence< Reference< XControl > > SAL_CALL BaseContainerControl::getControls () throw( RuntimeException )
423 : : {
424 : : // Ready for multithreading
425 : 0 : MutexGuard aGuard ( Mutex::getGlobalMutex() ) ;
426 : :
427 : 0 : size_t nControls = maControlInfoList.size();
428 : 0 : size_t nCount = 0;
429 : 0 : Sequence< Reference< XControl > > aDescriptor ( nControls ) ;
430 : 0 : Reference< XControl > * pDestination = aDescriptor.getArray () ;
431 : :
432 : : // Copy controls to sequence
433 : 0 : for( nCount = 0; nCount < nControls; ++nCount )
434 : : {
435 : 0 : IMPL_ControlInfo* pCopyControl = maControlInfoList[ nCount ];
436 : 0 : pDestination [ nCount ] = pCopyControl->xControl ;
437 : : }
438 : :
439 : : // Return sequence
440 : 0 : return aDescriptor ;
441 : : }
442 : :
443 : : //____________________________________________________________________________________________________________
444 : : // XUnoControlContainer
445 : : //____________________________________________________________________________________________________________
446 : :
447 : 0 : void SAL_CALL BaseContainerControl::addTabController ( const Reference< XTabController > & rTabController ) throw( RuntimeException )
448 : : {
449 : : // Ready for multithreading
450 : 0 : MutexGuard aGuard (m_aMutex) ;
451 : :
452 : 0 : sal_uInt32 nOldCount = m_xTabControllerList.getLength () ;
453 : 0 : Sequence< Reference< XTabController > > aNewList ( nOldCount + 1 ) ;
454 : 0 : sal_uInt32 nCount = 0 ;
455 : :
456 : : // Copy old elements of sequence to new list.
457 : 0 : for ( nCount = 0; nCount < nOldCount; ++nCount )
458 : : {
459 : 0 : aNewList.getArray () [nCount] = m_xTabControllerList.getConstArray () [nCount] ;
460 : : }
461 : :
462 : : // Add new controller
463 : 0 : aNewList.getArray () [nOldCount] = rTabController ;
464 : :
465 : : // change old and new list
466 : 0 : m_xTabControllerList = aNewList ;
467 : 0 : }
468 : :
469 : : //____________________________________________________________________________________________________________
470 : : // XUnoControlContainer
471 : : //____________________________________________________________________________________________________________
472 : :
473 : 0 : void SAL_CALL BaseContainerControl::removeTabController ( const Reference< XTabController > & rTabController ) throw( RuntimeException )
474 : : {
475 : : // Ready for multithreading
476 : 0 : MutexGuard aGuard (m_aMutex) ;
477 : :
478 : 0 : sal_uInt32 nMaxCount = m_xTabControllerList.getLength () ;
479 : 0 : sal_uInt32 nCount = 0 ;
480 : :
481 : : // Search right tabcontroller ...
482 : 0 : for ( nCount = 0; nCount < nMaxCount; ++nCount )
483 : : {
484 : 0 : if ( m_xTabControllerList.getConstArray () [nCount] == rTabController )
485 : : {
486 : : // ... if is it found ... remove it from list.
487 : 0 : m_xTabControllerList.getArray()[ nCount ] = Reference< XTabController >() ;
488 : 0 : break ;
489 : : }
490 : 0 : }
491 : 0 : }
492 : :
493 : : //____________________________________________________________________________________________________________
494 : : // XUnoControlContainer
495 : : //____________________________________________________________________________________________________________
496 : :
497 : 0 : void SAL_CALL BaseContainerControl::setTabControllers ( const Sequence< Reference< XTabController > >& rTabControllers ) throw( RuntimeException )
498 : : {
499 : : // Ready for multithreading
500 : 0 : MutexGuard aGuard (m_aMutex) ;
501 : :
502 : 0 : m_xTabControllerList = rTabControllers ;
503 : 0 : }
504 : :
505 : 0 : Sequence<Reference< XTabController > > SAL_CALL BaseContainerControl::getTabControllers () throw( RuntimeException )
506 : : {
507 : : // Ready for multithreading
508 : 0 : MutexGuard aGuard (m_aMutex) ;
509 : :
510 : 0 : return m_xTabControllerList ;
511 : : }
512 : :
513 : : //____________________________________________________________________________________________________________
514 : : // XWindow
515 : : //____________________________________________________________________________________________________________
516 : :
517 : 0 : void SAL_CALL BaseContainerControl::setVisible ( sal_Bool bVisible ) throw( RuntimeException )
518 : : {
519 : : // override baseclass definition
520 : 0 : BaseControl::setVisible ( bVisible ) ;
521 : :
522 : : // is it a top window ?
523 : 0 : if ( !getContext().is() && bVisible )
524 : : {
525 : : // then show it automaticly
526 : 0 : createPeer ( Reference< XToolkit > (), Reference< XWindowPeer > () ) ;
527 : : }
528 : 0 : }
529 : :
530 : : //____________________________________________________________________________________________________________
531 : : // protected method
532 : : //____________________________________________________________________________________________________________
533 : :
534 : 0 : WindowDescriptor* BaseContainerControl::impl_getWindowDescriptor ( const Reference< XWindowPeer > & rParentPeer )
535 : : {
536 : : // - used from "createPeer()" to set the values of an WindowDescriptor !!!
537 : : // - if you will change the descriptor-values, you must override thid virtuell function
538 : : // - the caller must release the memory for this dynamical descriptor !!!
539 : :
540 : 0 : WindowDescriptor * aDescriptor = new WindowDescriptor ;
541 : :
542 : 0 : aDescriptor->Type = WindowClass_CONTAINER ;
543 : 0 : aDescriptor->WindowServiceName = "window" ;
544 : 0 : aDescriptor->ParentIndex = -1 ;
545 : 0 : aDescriptor->Parent = rParentPeer ;
546 : 0 : aDescriptor->Bounds = getPosSize () ;
547 : 0 : aDescriptor->WindowAttributes = 0 ;
548 : :
549 : 0 : return aDescriptor ;
550 : : }
551 : :
552 : : //____________________________________________________________________________________________________________
553 : : // protected method
554 : : //____________________________________________________________________________________________________________
555 : :
556 : 0 : void BaseContainerControl::impl_paint ( sal_Int32 /*nX*/, sal_Int32 /*nY*/, const Reference< XGraphics > & /*rGraphics*/ )
557 : : {
558 : 0 : }
559 : :
560 : : //____________________________________________________________________________________________________________
561 : : // private method
562 : : //____________________________________________________________________________________________________________
563 : :
564 : 0 : void BaseContainerControl::impl_activateTabControllers ()
565 : : {
566 : : // Ready for multithreading
567 : 0 : MutexGuard aGuard (m_aMutex) ;
568 : :
569 : 0 : sal_uInt32 nMaxCount = m_xTabControllerList.getLength () ;
570 : 0 : sal_uInt32 nCount = 0 ;
571 : :
572 : 0 : for ( nCount = 0; nCount < nMaxCount; ++nCount )
573 : : {
574 : 0 : m_xTabControllerList.getArray () [nCount]->setContainer ( this ) ;
575 : 0 : m_xTabControllerList.getArray () [nCount]->activateTabOrder ( ) ;
576 : 0 : }
577 : 0 : }
578 : :
579 : : //____________________________________________________________________________________________________________
580 : : // private method
581 : : //____________________________________________________________________________________________________________
582 : :
583 : 0 : void BaseContainerControl::impl_cleanMemory ()
584 : : {
585 : : // Get count of listitems.
586 : 0 : size_t nMaxCount = maControlInfoList.size();
587 : 0 : size_t nCount = 0;
588 : :
589 : : // Delete all items.
590 : 0 : for ( nCount = 0; nCount < nMaxCount; ++nCount )
591 : : {
592 : : // Delete everytime first element of list!
593 : : // We count from 0 to MAX, where "MAX=count of items" BEFORE we delete some elements!
594 : : // If we use "GetObject ( nCount )" ... it can be, that we have an index greater then count of current elements!
595 : :
596 : 0 : IMPL_ControlInfo* pSearchControl = maControlInfoList[ nCount ];
597 : 0 : delete pSearchControl;
598 : : }
599 : :
600 : : // Delete list himself.
601 : 0 : maControlInfoList.clear ();
602 : 0 : }
603 : :
604 : : } // namespace unocontrols
605 : :
606 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
