Bug Summary

File:home/maarten/src/libreoffice/core/include/rtl/ref.hxx
Warning:line 192, column 9
Use of memory after it is freed

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name accessiblelistbox.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D VCL_INTERNALS -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/accessibility/inc -I /home/maarten/src/libreoffice/core/accessibility/source/inc -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/x86_64-redhat-linux -internal-isystem /usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O0 -Wno-missing-braces -std=c++17 -fdeprecated-macro -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c++ /home/maarten/src/libreoffice/core/accessibility/source/extended/accessiblelistbox.cxx

/home/maarten/src/libreoffice/core/accessibility/source/extended/accessiblelistbox.cxx

→
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 <extended/accessiblelistbox.hxx>
21#include <extended/accessiblelistboxentry.hxx>
22#include <vcl/toolkit/treelistbox.hxx>
23#include <vcl/toolkit/treelistentry.hxx>
24#include <com/sun/star/accessibility/AccessibleEventId.hpp>
25#include <com/sun/star/accessibility/AccessibleRole.hpp>
26#include <com/sun/star/accessibility/AccessibleStateType.hpp>
27#include <com/sun/star/lang/IndexOutOfBoundsException.hpp>
28#include <cppuhelper/supportsservice.hxx>
29#include <unotools/accessiblestatesethelper.hxx>
30
31
32namespace accessibility
33{
34
35
36 // class AccessibleListBox -----------------------------------------------------
37
38 using namespace ::com::sun::star::accessibility;
39 using namespace ::com::sun::star::uno;
40 using namespace ::com::sun::star::lang;
41 using namespace ::com::sun::star;
42
43
44 // Ctor() and Dtor()
45
46 AccessibleListBox::AccessibleListBox( SvTreeListBox const & _rListBox, const Reference< XAccessible >& _xParent ) :
47
48 VCLXAccessibleComponent( _rListBox.GetWindowPeer() ),
49 m_xParent( _xParent )
50 {
51 }
52
53 AccessibleListBox::~AccessibleListBox()
54 {
55 if ( isAlive() )
56 {
57 // increment ref count to prevent double call of Dtor
58 osl_atomic_increment( &m_refCount )__sync_add_and_fetch((&m_refCount), 1);
59 dispose();
60 }
61 }
62 IMPLEMENT_FORWARD_XINTERFACE2(AccessibleListBox, VCLXAccessibleComponent, ImplHelper2)void AccessibleListBox::acquire() throw() { VCLXAccessibleComponent
::acquire(); } void AccessibleListBox::release() throw() { VCLXAccessibleComponent
::release(); } css::uno::Any AccessibleListBox::queryInterface
( const css::uno::Type& _rType ) { css::uno::Any aReturn =
VCLXAccessibleComponent::queryInterface( _rType ); if ( !aReturn
.hasValue() ) aReturn = ImplHelper2::queryInterface( _rType )
; return aReturn; }
63 IMPLEMENT_FORWARD_XTYPEPROVIDER2(AccessibleListBox, VCLXAccessibleComponent, ImplHelper2)css::uno::Sequence< css::uno::Type > AccessibleListBox::
getTypes( ) { return ::comphelper::concatSequences( VCLXAccessibleComponent
::getTypes(), ImplHelper2::getTypes() ); } css::uno::Sequence
< sal_Int8 > AccessibleListBox::getImplementationId( ) {
return css::uno::Sequence<sal_Int8>(); }
64
65 void AccessibleListBox::ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent )
66 {
67 if ( !isAlive() )
68 return;
69
70 switch ( rVclWindowEvent.GetId() )
71 {
72 case VclEventId::CheckboxToggle :
73 {
74 if ( !getListBox() || !getListBox()->HasFocus() )
75 {
76 return;
77 }
78 AccessibleListBoxEntry* pCurOpEntry = GetCurEventEntry(rVclWindowEvent);
79 if(!pCurOpEntry)
80 {
81 return ;
82 }
83 uno::Any aValue;
84 aValue <<= AccessibleStateType::CHECKED;
85
86 if ( getListBox()->GetCheckButtonState( pCurOpEntry->GetSvLBoxEntry() ) == SvButtonState::Checked )
87 {
88 pCurOpEntry->NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, uno::Any(), aValue );
89 }
90 else
91 {
92 pCurOpEntry->NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, aValue,uno::Any() );
93 }
94 break;
95 }
96
97 case VclEventId::ListboxSelect :
98 {
99 OSL_FAIL("Debug: Treelist shouldn't use VclEventId::ListboxSelect")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/accessibility/source/extended/accessiblelistbox.cxx"
":" "99" ": "), "%s", "Debug: Treelist shouldn't use VclEventId::ListboxSelect"
); } } while (false);
100 break;
101 }
102
103 case VclEventId::ListboxTreeSelect:
104 {
105 if ( getListBox() && getListBox()->HasFocus() )
106 {
107 AccessibleListBoxEntry* pEntry =static_cast< AccessibleListBoxEntry* >(m_xFocusedChild.get());
108 if (pEntry)
109 {
110 pEntry->NotifyAccessibleEvent( AccessibleEventId::SELECTION_CHANGED, Any(), Any() );
111 }
112 }
113 }
114 break;
115 case VclEventId::ListboxTreeFocus:
116 {
117 VclPtr<SvTreeListBox> pBox = getListBox();
118 if( pBox && pBox->HasFocus() )
119 {
120 uno::Any aNewValue;
121 SvTreeListEntry* pEntry = static_cast< SvTreeListEntry* >( rVclWindowEvent.GetData() );
122 if ( pEntry )
123 {
124 AccessibleListBoxEntry* pEntryFocus =static_cast< AccessibleListBoxEntry* >(m_xFocusedChild.get());
125 if (pEntryFocus && pEntryFocus->GetSvLBoxEntry() == pEntry)
126 {
127 aNewValue <<= m_xFocusedChild;
128 NotifyAccessibleEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, uno::Any(), aNewValue );
129 return ;
130 }
131
132 uno::Any aOldValue;
133 aOldValue <<= m_xFocusedChild;
134
135 m_xFocusedChild.set(implGetAccessible(*pEntry).get());
136
137 aNewValue <<= m_xFocusedChild;
138 NotifyAccessibleEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, aOldValue, aNewValue );
139 }
140 else
141 {
142 aNewValue <<= AccessibleStateType::FOCUSED;
143 NotifyAccessibleEvent( AccessibleEventId::STATE_CHANGED, uno::Any(), aNewValue );
144 }
145 }
146 }
147 break;
148 case VclEventId::ListboxItemRemoved:
149 {
150 SvTreeListEntry* pEntry = static_cast< SvTreeListEntry* >( rVclWindowEvent.GetData() );
151 if ( pEntry )
152 {
153 RemoveChildEntries(pEntry);
154 }
155 else
156 {
157 // NULL means Clear()
158 for (auto const& entry : m_mapEntry)
159 {
160 uno::Any aNewValue;
161 uno::Any aOldValue;
162 aOldValue <<= uno::Reference<XAccessible>(entry.second.get());
163 NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
164 }
165 for (auto const& entry : m_mapEntry)
166 { // release references ...
167 entry.second->dispose();
168 }
169 m_mapEntry.clear();
170 }
171 }
172 break;
173
174 // #i92103#
175 case VclEventId::ItemExpanded :
176 case VclEventId::ItemCollapsed :
177 {
178 SvTreeListEntry* pEntry = static_cast< SvTreeListEntry* >( rVclWindowEvent.GetData() );
179 if ( pEntry )
180 {
181 Reference<XAccessible> const xChild(implGetAccessible(*pEntry).get());
182 const short nAccEvent =
183 ( rVclWindowEvent.GetId() == VclEventId::ItemExpanded )
184 ? AccessibleEventId::LISTBOX_ENTRY_EXPANDED
185 : AccessibleEventId::LISTBOX_ENTRY_COLLAPSED;
186 uno::Any aListBoxEntry;
187 aListBoxEntry <<= xChild;
188 NotifyAccessibleEvent( nAccEvent, Any(), aListBoxEntry );
189 if ( getListBox() && getListBox()->HasFocus() )
190 {
191 NotifyAccessibleEvent( AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, Any(), aListBoxEntry );
192 }
193 }
194 }
195 break;
196 default:
197 VCLXAccessibleComponent::ProcessWindowEvent (rVclWindowEvent);
198 }
199 }
200
201 AccessibleListBoxEntry* AccessibleListBox::GetCurEventEntry( const VclWindowEvent& rVclWindowEvent )
202 {
203 SvTreeListEntry* pEntry = static_cast< SvTreeListEntry* >( rVclWindowEvent.GetData() );
204 if ( !pEntry )
205 pEntry = getListBox()->GetCurEntry();
206
207 AccessibleListBoxEntry* pEntryFocus =static_cast< AccessibleListBoxEntry* >(m_xFocusedChild.get());
208 if (pEntryFocus && pEntry && pEntry != pEntryFocus->GetSvLBoxEntry())
209 {
210 AccessibleListBoxEntry *const pAccCurOptionEntry = implGetAccessible(*pEntry).get();
211 uno::Any aNewValue;
212 aNewValue <<= uno::Reference<XAccessible>(pAccCurOptionEntry);
213 NotifyAccessibleEvent( AccessibleEventId::CHILD, uno::Any(), aNewValue );//Add
214
215 return pAccCurOptionEntry;
216 }
217 else
218 {
219 return pEntryFocus;
220 }
221 }
222
223 void AccessibleListBox::RemoveChildEntries(SvTreeListEntry* pEntry)
224 {
225 MAP_ENTRY::iterator mi = m_mapEntry.find(pEntry);
226 if ( mi != m_mapEntry.end() )
227 {
228 uno::Any aNewValue;
229 uno::Any aOldValue;
230 aOldValue <<= uno::Reference<XAccessible>(mi->second.get());
231 NotifyAccessibleEvent( AccessibleEventId::CHILD, aOldValue, aNewValue );
232
233 m_mapEntry.erase(mi);
234 }
235
236 VclPtr<SvTreeListBox> pBox = getListBox();
237 SvTreeListEntry* pEntryChild = pBox->FirstChild(pEntry);
238 while (pEntryChild)
239 {
240 RemoveChildEntries(pEntryChild);
241 pEntryChild = pEntryChild->NextSibling();
242 }
243 }
244
245
246 void AccessibleListBox::ProcessWindowChildEvent( const VclWindowEvent& rVclWindowEvent )
247 {
248 switch ( rVclWindowEvent.GetId() )
249 {
250 case VclEventId::WindowShow:
251 case VclEventId::WindowHide:
252 {
253 }
254 break;
255 default:
256 {
257 VCLXAccessibleComponent::ProcessWindowChildEvent( rVclWindowEvent );
258 }
259 break;
260 }
261 }
262
263
264 // XComponent
265
266 void SAL_CALL AccessibleListBox::disposing()
267 {
268 ::osl::MutexGuard aGuard( m_aMutex );
269
270 m_mapEntry.clear();
271 VCLXAccessibleComponent::disposing();
272 m_xParent = nullptr;
273 }
274
275 // XServiceInfo
276
277 OUString SAL_CALL AccessibleListBox::getImplementationName()
278 {
279 return "com.sun.star.comp.svtools.AccessibleTreeListBox";
280 }
281
282 Sequence< OUString > SAL_CALL AccessibleListBox::getSupportedServiceNames()
283 {
284 return {"com.sun.star.accessibility.AccessibleContext",
285 "com.sun.star.accessibility.AccessibleComponent",
286 "com.sun.star.awt.AccessibleTreeListBox"};
287 }
288
289 sal_Bool SAL_CALL AccessibleListBox::supportsService( const OUString& _rServiceName )
290 {
291 return cppu::supportsService(this, _rServiceName);
292 }
293
294 // XAccessible
295
296 Reference< XAccessibleContext > SAL_CALL AccessibleListBox::getAccessibleContext( )
297 {
298 ensureAlive();
299 return this;
300 }
301
302 // XAccessibleContext
303
304 sal_Int32 SAL_CALL AccessibleListBox::getAccessibleChildCount( )
305 {
306 ::comphelper::OExternalLockGuard aGuard( this );
307
308 sal_Int32 nCount = 0;
309 VclPtr<SvTreeListBox> pSvTreeListBox = getListBox();
310 if ( pSvTreeListBox )
311 nCount = pSvTreeListBox->GetLevelChildCount( nullptr );
312
313 return nCount;
314 }
315
316 Reference< XAccessible > SAL_CALL AccessibleListBox::getAccessibleChild( sal_Int32 i )
317 {
318 ::comphelper::OExternalLockGuard aGuard( this );
319
320 SvTreeListEntry* pEntry = getListBox()->GetEntry(i);
321 if ( !pEntry )
322 throw IndexOutOfBoundsException();
323
324 // Solution: Set the parameter of the parent to null to let entry determine the parent by itself
325 //return new AccessibleListBoxEntry( *getListBox(), pEntry, this );
326 //return new AccessibleListBoxEntry( *getListBox(), pEntry, nullptr );
327 return implGetAccessible(*pEntry).get();
328 }
329
330 Reference< XAccessible > SAL_CALL AccessibleListBox::getAccessibleParent( )
331 {
332 ::osl::MutexGuard aGuard( m_aMutex );
333
334 ensureAlive();
335 return m_xParent;
336 }
337
338 sal_Int32 AccessibleListBox::GetRoleType() const
339 {
340 sal_Int32 nCase = 0;
341 SvTreeListEntry* pEntry = getListBox()->GetEntry(0);
342 if ( pEntry )
343 {
344 if( pEntry->HasChildrenOnDemand() || getListBox()->GetChildCount(pEntry) > 0 )
345 {
346 nCase = 1;
347 return nCase;
348 }
349 }
350
351 bool bHasButtons = (getListBox()->GetStyle() & WB_HASBUTTONS)!=0;
352 if( !(getListBox()->GetTreeFlags() & SvTreeFlags::CHKBTN) )
353 {
354 if( bHasButtons )
355 nCase = 1;
356 }
357 else
358 {
359 if( bHasButtons )
360 nCase = 2;
361 else
362 nCase = 3;
363 }
364 return nCase;
365 }
366
367 sal_Int16 SAL_CALL AccessibleListBox::getAccessibleRole()
368 {
369 ::comphelper::OExternalLockGuard aGuard( this );
370
371 //o is: return AccessibleRole::TREE;
372 bool bHasButtons = (getListBox()->GetStyle() & WB_HASBUTTONS)!=0;
373 if(!bHasButtons && (getListBox()->GetTreeFlags() & SvTreeFlags::CHKBTN))
374 return AccessibleRole::LIST;
375 else
376 if (GetRoleType() == 0)
377 return AccessibleRole::LIST;
378 else
379 return AccessibleRole::TREE;
380 }
381
382 OUString SAL_CALL AccessibleListBox::getAccessibleDescription( )
383 {
384 ::comphelper::OExternalLockGuard aGuard( this );
385
386 return getListBox()->GetAccessibleDescription();
387 }
388
389 OUString SAL_CALL AccessibleListBox::getAccessibleName( )
390 {
391 ::comphelper::OExternalLockGuard aGuard( this );
392
393 return getListBox()->GetAccessibleName();
394 }
395
396 // XAccessibleSelection
397
398 void SAL_CALL AccessibleListBox::selectAccessibleChild( sal_Int32 nChildIndex )
399 {
400 ::comphelper::OExternalLockGuard aGuard( this );
401
402 SvTreeListEntry* pEntry = getListBox()->GetEntry( nChildIndex );
403 if ( !pEntry )
404 throw IndexOutOfBoundsException();
405
406 getListBox()->Select( pEntry );
407 }
408
409 sal_Bool SAL_CALL AccessibleListBox::isAccessibleChildSelected( sal_Int32 nChildIndex )
410 {
411 ::comphelper::OExternalLockGuard aGuard( this );
412
413 SvTreeListEntry* pEntry = getListBox()->GetEntry( nChildIndex );
414 if ( !pEntry )
415 throw IndexOutOfBoundsException();
416
417 return getListBox()->IsSelected( pEntry );
418 }
419
420 void SAL_CALL AccessibleListBox::clearAccessibleSelection( )
421 {
422 ::comphelper::OExternalLockGuard aGuard( this );
423
424 sal_Int32 nCount = getListBox()->GetLevelChildCount( nullptr );
425 for ( sal_Int32 i = 0; i < nCount; ++i )
426 {
427 SvTreeListEntry* pEntry = getListBox()->GetEntry( i );
428 if ( getListBox()->IsSelected( pEntry ) )
429 getListBox()->Select( pEntry, false );
430 }
431 }
432
433 void SAL_CALL AccessibleListBox::selectAllAccessibleChildren( )
434 {
435 ::comphelper::OExternalLockGuard aGuard( this );
436
437 sal_Int32 nCount = getListBox()->GetLevelChildCount( nullptr );
438 for ( sal_Int32 i = 0; i < nCount; ++i )
439 {
440 SvTreeListEntry* pEntry = getListBox()->GetEntry( i );
441 if ( !getListBox()->IsSelected( pEntry ) )
442 getListBox()->Select( pEntry );
443 }
444 }
445
446 sal_Int32 SAL_CALL AccessibleListBox::getSelectedAccessibleChildCount( )
447 {
448 ::comphelper::OExternalLockGuard aGuard( this );
449
450 return getListBox()->GetSelectionCount();
451 }
452
453 Reference< XAccessible > SAL_CALL AccessibleListBox::getSelectedAccessibleChild( sal_Int32 nSelectedChildIndex )
454 {
455 ::comphelper::OExternalLockGuard aGuard( this );
456
457 if ( nSelectedChildIndex < 0 || nSelectedChildIndex >= getSelectedAccessibleChildCount() )
458 throw IndexOutOfBoundsException();
459
460 Reference< XAccessible > xChild;
461 sal_Int32 nSelCount= 0;
462 sal_Int32 nCount = getListBox()->GetLevelChildCount( nullptr );
463 for ( sal_Int32 i = 0; i < nCount; ++i )
464 {
465 SvTreeListEntry* pEntry = getListBox()->GetEntry( i );
466 if ( getListBox()->IsSelected( pEntry ) )
467 ++nSelCount;
468
469 if ( nSelCount == ( nSelectedChildIndex + 1 ) )
470 {
471 // Solution: Set the parameter of the parent to null to let entry determine the parent by itself
472 //xChild = new AccessibleListBoxEntry( *getListBox(), pEntry, this );
473 //xChild = new AccessibleListBoxEntry( *getListBox(), pEntry, nullptr );
474 xChild = implGetAccessible(*pEntry).get();
475 break;
476 }
477 }
478
479 return xChild;
480 }
481
482 void SAL_CALL AccessibleListBox::deselectAccessibleChild( sal_Int32 nSelectedChildIndex )
483 {
484 ::comphelper::OExternalLockGuard aGuard( this );
485
486 SvTreeListEntry* pEntry = getListBox()->GetEntry( nSelectedChildIndex );
487 if ( !pEntry )
488 throw IndexOutOfBoundsException();
489
490 getListBox()->Select( pEntry, false );
491 }
492
493 void AccessibleListBox::FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet )
494 {
495 VCLXAccessibleComponent::FillAccessibleStateSet( rStateSet );
496 if ( getListBox() && isAlive() )
1
Calling 'AccessibleListBox::getListBox'
→
20
←
Returning; memory was released
→
21
←
Calling 'VclPtr::operator bool'
→
497 {
498 rStateSet.AddState( AccessibleStateType::FOCUSABLE );
499 rStateSet.AddState( AccessibleStateType::MANAGES_DESCENDANTS );
500 if ( getListBox()->GetSelectionMode() == SelectionMode::Multiple )
501 rStateSet.AddState( AccessibleStateType::MULTI_SELECTABLE );
502 }
503 }
504
505 rtl::Reference<AccessibleListBoxEntry> AccessibleListBox::implGetAccessible(SvTreeListEntry & rEntry)
506 {
507 rtl::Reference<AccessibleListBoxEntry> pAccessible;
508 auto const it = m_mapEntry.find(&rEntry);
509 if (it != m_mapEntry.end())
510 {
511 pAccessible = it->second;
512 }
513 else
514 {
515 AccessibleListBoxEntry *const pAccListBoxEntry =
516 new AccessibleListBoxEntry(*getListBox(), rEntry, *this);
517 pAccessible = pAccListBoxEntry;
518 m_mapEntry.emplace(&rEntry, pAccessible);
519 }
520 assert(pAccessible.is())(static_cast <bool> (pAccessible.is()) ? void (0) : __assert_fail
("pAccessible.is()", "/home/maarten/src/libreoffice/core/accessibility/source/extended/accessiblelistbox.cxx"
, 520, __extension__ __PRETTY_FUNCTION__));
521 return pAccessible;
522 }
523
524 VclPtr< SvTreeListBox > AccessibleListBox::getListBox() const
525 {
526 return GetAs< SvTreeListBox >();
2
←
Calling 'VCLXAccessibleComponent::GetAs'
→
19
←
Returning; memory was released
→
527 }
528
529}// namespace accessibility
530
531
532/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
←

/home/maarten/src/libreoffice/core/include/toolkit/awt/vclxaccessiblecomponent.hxx

→
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#ifndef INCLUDED_TOOLKIT_AWT_VCLXACCESSIBLECOMPONENT_HXX
21#define INCLUDED_TOOLKIT_AWT_VCLXACCESSIBLECOMPONENT_HXX
22
23#include <toolkit/dllapi.h>
24#include <com/sun/star/lang/XServiceInfo.hpp>
25#include <cppuhelper/implbase1.hxx>
26#include <comphelper/accimplaccess.hxx>
27#include <comphelper/accessiblecomponenthelper.hxx>
28
29
30#include <tools/link.hxx>
31#include <vcl/vclptr.hxx>
32
33namespace com::sun::star::accessibility { class XAccessible; }
34
35namespace vcl { class Window; }
36class VCLXWindow;
37class VclWindowEvent;
38
39namespace utl {
40class AccessibleRelationSetHelper;
41class AccessibleStateSetHelper;
42}
43
44
45
46typedef ::cppu::ImplHelper1<
47 css::lang::XServiceInfo > VCLXAccessibleComponent_BASE;
48
49class TOOLKIT_DLLPUBLIC__attribute__ ((visibility("default"))) VCLXAccessibleComponent
50 :public comphelper::OAccessibleExtendedComponentHelper
51 ,public ::comphelper::OAccessibleImplementationAccess
52 ,public VCLXAccessibleComponent_BASE
53{
54private:
55 rtl::Reference<VCLXWindow> m_xVCLXWindow;
56 VclPtr<vcl::Window> m_xEventSource;
57
58 DECL_LINK( WindowEventListener, VclWindowEvent&, void )static void LinkStubWindowEventListener(void *, VclWindowEvent
&); void WindowEventListener(VclWindowEvent&);
59 DECL_LINK( WindowChildEventListener, VclWindowEvent&, void )static void LinkStubWindowChildEventListener(void *, VclWindowEvent
&); void WindowChildEventListener(VclWindowEvent&);
60 void DisconnectEvents();
61
62protected:
63 virtual void ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent );
64 virtual void ProcessWindowChildEvent( const VclWindowEvent& rVclWindowEvent );
65 virtual void FillAccessibleRelationSet( utl::AccessibleRelationSetHelper& rRelationSet );
66 virtual void FillAccessibleStateSet( utl::AccessibleStateSetHelper& rStateSet );
67
68 virtual css::uno::Reference< css::accessibility::XAccessible > GetChildAccessible( const VclWindowEvent& rVclWindowEvent );
69
70public:
71 VCLXAccessibleComponent( VCLXWindow* pVCLXWindow );
72 virtual ~VCLXAccessibleComponent() override;
73
74 VCLXWindow* GetVCLXWindow() const;
75 VclPtr<vcl::Window> GetWindow() const;
76 template< class derived_type > VclPtr< derived_type > GetAs() const {
77 return VclPtr< derived_type >( static_cast< derived_type * >( GetWindow().get() ) ); }
3
←
Calling constructor for 'VclPtr<SvTreeListBox>'
→
8
←
Returning from constructor for 'VclPtr<SvTreeListBox>'
→
9
←
Calling implicit destructor for 'VclPtr<vcl::Window>'
→
10
←
Calling '~Reference'
→
17
←
Returning from '~Reference'
→
18
←
Returning from destructor for 'VclPtr<vcl::Window>'
→
78 template< class derived_type > VclPtr< derived_type > GetAsDynamic() const {
79 return VclPtr< derived_type >( dynamic_cast< derived_type * >( GetWindow().get() ) ); }
80
81 virtual void SAL_CALL disposing() override;
82
83 // css::uno::XInterface
84 DECLARE_XINTERFACE()virtual css::uno::Any queryInterface( const css::uno::Type&
aType ) override; virtual void acquire() throw() override; virtual
void release() throw() override;
85 // css::lang::XTypeProvider
86 DECLARE_XTYPEPROVIDER()virtual css::uno::Sequence< css::uno::Type > getTypes( )
override; virtual css::uno::Sequence< sal_Int8 > getImplementationId
( ) override;
87
88 // XServiceInfo
89 virtual OUString SAL_CALL getImplementationName() override;
90 virtual sal_Bool SAL_CALL supportsService( const OUString& rServiceName ) override;
91 virtual css::uno::Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
92
93 // css::accessibility::XAccessibleContext
94 sal_Int32 SAL_CALL getAccessibleChildCount( ) override;
95 css::uno::Reference< css::accessibility::XAccessible > SAL_CALL getAccessibleChild( sal_Int32 i ) override;
96 css::uno::Reference< css::accessibility::XAccessible > SAL_CALL getAccessibleParent( ) override;
97 sal_Int32 SAL_CALL getAccessibleIndexInParent( ) override;
98 sal_Int16 SAL_CALL getAccessibleRole( ) override;
99 OUString SAL_CALL getAccessibleDescription( ) override;
100 OUString SAL_CALL getAccessibleName( ) override;
101 OUString SAL_CALL getAccessibleId( ) override;
102 css::uno::Reference< css::accessibility::XAccessibleRelationSet > SAL_CALL getAccessibleRelationSet( ) override;
103 css::uno::Reference< css::accessibility::XAccessibleStateSet > SAL_CALL getAccessibleStateSet( ) override;
104 css::lang::Locale SAL_CALL getLocale( ) override;
105
106 // css::accessibility::XAccessibleComponent
107 css::uno::Reference< css::accessibility::XAccessible > SAL_CALL getAccessibleAtPoint( const css::awt::Point& aPoint ) override;
108 css::awt::Point SAL_CALL getLocationOnScreen( ) override;
109 void SAL_CALL grabFocus( ) override;
110 virtual sal_Int32 SAL_CALL getForeground( ) override;
111 virtual sal_Int32 SAL_CALL getBackground( ) override;
112
113 // css::accessibility::XAccessibleExtendedComponent
114 virtual css::uno::Reference< css::awt::XFont > SAL_CALL getFont( ) override;
115 virtual OUString SAL_CALL getTitledBorderText( ) override;
116 virtual OUString SAL_CALL getToolTipText( ) override;
117
118protected:
119 // base class overridables
120 css::awt::Rectangle implGetBounds( ) override;
121
122private:
123 /** we may be reparented (if external components use OAccessibleImplementationAccess base class),
124 so this method here returns the parent in the VCL world, in opposite to the parent
125 an external component gave us
126 @precond
127 the caller must ensure thread safety, i.e. our mutex must be locked
128 */
129 css::uno::Reference< css::accessibility::XAccessible >
130 getVclParent() const;
131};
132
133/* ----------------------------------------------------------
134 Accessibility only for the Window hierarchy!
135 Maybe derived classes must overwrite these Accessibility interfaces:
136
137 // XAccessibleContext:
138 sal_Int16 getAccessibleRole() => VCL Window::GetAccessibleRole()
139 OUString getAccessibleDescription() => VCL Window::GetAccessibleDescription
140 OUString getAccessibleName() => VCL Window::GetAccessibleText() => Most windows return Window::GetText()
141 OUString getAccessibleId() => VCL Window::get_id()
142 Reference< XAccessibleRelationSet > getAccessibleRelationSet()
143 Reference< XAccessibleStateSet > getAccessibleStateSet() => override FillAccessibleStateSet( ... )
144
145---------------------------------------------------------- */
146
147
148#endif // INCLUDED_TOOLKIT_AWT_VCLXACCESSIBLECOMPONENT_HXX
149
150/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
←

/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx

→
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#ifndef INCLUDED_VCL_PTR_HXX
21#define INCLUDED_VCL_PTR_HXX
22
23#include <sal/config.h>
24
25#include <rtl/ref.hxx>
26
27#include <utility>
28#include <type_traits>
29
30#ifdef DBG_UTIL
31#ifndef _WIN32
32#include <vcl/vclmain.hxx>
33#endif
34#endif
35
36class VclReferenceBase;
37
38namespace vcl::detail {
39
40template<typename>
41constexpr bool isIncompleteOrDerivedFromVclReferenceBase(...) { return true; }
42
43template<typename T> constexpr bool isIncompleteOrDerivedFromVclReferenceBase(
44 int (*)[sizeof(T)])
45{ return std::is_base_of<VclReferenceBase, T>::value; }
46
47} // namespace vcl::detail
48
49/**
50 * A thin wrapper around rtl::Reference to implement the acquire and dispose semantics we want for references to vcl::Window subclasses.
51 *
52 * For more details on the design please see vcl/README.lifecycle
53 *
54 * @param reference_type must be a subclass of vcl::Window
55 */
56template <class reference_type>
57class VclPtr
58{
59 static_assert(
60 vcl::detail::isIncompleteOrDerivedFromVclReferenceBase<reference_type>(
61 nullptr),
62 "template argument type must be derived from VclReferenceBase");
63
64 ::rtl::Reference<reference_type> m_rInnerRef;
65
66public:
67 /** Constructor...
68 */
69 VclPtr()
70 : m_rInnerRef()
71 {}
72
73 /** Constructor...
74 */
75 VclPtr (reference_type * pBody)
76 : m_rInnerRef(pBody)
4
←
Calling constructor for 'Reference<SvTreeListBox>'
→
7
←
Returning from constructor for 'Reference<SvTreeListBox>'
→
77 {}
78
79 /** Constructor... that doesn't take a ref.
80 */
81 VclPtr (reference_type * pBody, __sal_NoAcquire)
82 : m_rInnerRef(pBody, SAL_NO_ACQUIRE)
83 {}
84
85 /** Up-casting conversion constructor: Copies interface reference.
86
87 Does not work for up-casts to ambiguous bases. For the special case of
88 up-casting to Reference< XInterface >, see the corresponding conversion
89 operator.
90
91 @param rRef another reference
92 */
93 template< class derived_type >
94 VclPtr(
95 const VclPtr< derived_type > & rRef,
96 typename std::enable_if<
97 std::is_base_of<reference_type, derived_type>::value, int>::type
98 = 0 )
99 : m_rInnerRef( static_cast<reference_type*>(rRef) )
100 {
101 }
102
103#if defined(DBG_UTIL) && !defined(_WIN32)
104 virtual ~VclPtr()
105 {
106 assert(m_rInnerRef.get() == nullptr || vclmain::isAlive())(static_cast <bool> (m_rInnerRef.get() == nullptr || vclmain
::isAlive()) ? void (0) : __assert_fail ("m_rInnerRef.get() == nullptr || vclmain::isAlive()"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 106, __extension__ __PRETTY_FUNCTION__));
107 // We can be one of the intermediate counts, but if we are the last
108 // VclPtr keeping this object alive, then something forgot to call dispose().
109 assert((!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1)(static_cast <bool> ((!m_rInnerRef.get() || m_rInnerRef
->isDisposed() || m_rInnerRef->getRefCount() > 1) &&
"someone forgot to call dispose()") ? void (0) : __assert_fail
("(!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) && \"someone forgot to call dispose()\""
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 110, __extension__ __PRETTY_FUNCTION__))
110 && "someone forgot to call dispose()")(static_cast <bool> ((!m_rInnerRef.get() || m_rInnerRef
->isDisposed() || m_rInnerRef->getRefCount() > 1) &&
"someone forgot to call dispose()") ? void (0) : __assert_fail
("(!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) && \"someone forgot to call dispose()\""
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 110, __extension__ __PRETTY_FUNCTION__));
111 }
112 VclPtr(VclPtr const &) = default;
113 VclPtr(VclPtr &&) = default;
114 VclPtr & operator =(VclPtr const &) = default;
115 VclPtr & operator =(VclPtr &&) = default;
116#endif
117
118 /**
119 * A construction helper for VclPtr. Since VclPtr types are created
120 * with a reference-count of one - to help fit into the existing
121 * code-flow; this helps us to construct them easily.
122 *
123 * For more details on the design please see vcl/README.lifecycle
124 *
125 * @tparam reference_type must be a subclass of vcl::Window
126 */
127 template<typename... Arg> [[nodiscard]] static VclPtr< reference_type > Create(Arg &&... arg)
128 {
129 return VclPtr< reference_type >( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE );
130 }
131
132 /** Probably most common used: handle->someBodyOp().
133 */
134 reference_type * operator->() const
135 {
136 return m_rInnerRef.get();
137 }
138
139 /** Get the body. Can be used instead of operator->().
140 I.e. handle->someBodyOp() and handle.get()->someBodyOp()
141 are the same.
142 */
143 reference_type * get() const
144 {
145 return m_rInnerRef.get();
146 }
147
148 void set(reference_type *pBody)
149 {
150 m_rInnerRef.set(pBody);
151 }
152
153 void reset(reference_type *pBody)
154 {
155 m_rInnerRef.set(pBody);
156 }
157
158 /** Up-casting copy assignment operator.
159
160 Does not work for up-casts to ambiguous bases.
161
162 @param rRef another reference
163 */
164 template<typename derived_type>
165 typename std::enable_if<
166 std::is_base_of<reference_type, derived_type>::value,
167 VclPtr &>::type
168 operator =(VclPtr<derived_type> const & rRef)
169 {
170 m_rInnerRef.set(rRef.get());
171 return *this;
172 }
173
174 VclPtr & operator =(reference_type * pBody)
175 {
176 m_rInnerRef.set(pBody);
177 return *this;
178 }
179
180 operator reference_type * () const
181 {
182 return m_rInnerRef.get();
183 }
184
185 explicit operator bool () const
186 {
187 return m_rInnerRef.get() != nullptr;
22
←
Calling 'Reference::get'
→
188 }
189
190 void clear()
191 {
192 m_rInnerRef.clear();
193 }
194
195 void reset()
196 {
197 m_rInnerRef.clear();
198 }
199
200 void disposeAndClear()
201 {
202 // hold it alive for the lifetime of this method
203 ::rtl::Reference<reference_type> aTmp(m_rInnerRef);
204 m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-)
205 if (aTmp.get()) {
206 aTmp->disposeOnce();
207 }
208 }
209
210 /** Needed to place VclPtr's into STL collection.
211 */
212 bool operator< (const VclPtr<reference_type> & handle) const
213 {
214 return (m_rInnerRef < handle.m_rInnerRef);
215 }
216}; // class VclPtr
217
218template<typename T1, typename T2>
219inline bool operator ==(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
220 return p1.get() == p2.get();
221}
222
223template<typename T> inline bool operator ==(VclPtr<T> const & p1, T const * p2)
224{
225 return p1.get() == p2;
226}
227
228template<typename T> inline bool operator ==(VclPtr<T> const & p1, T * p2) {
229 return p1.get() == p2;
230}
231
232template<typename T> inline bool operator ==(T const * p1, VclPtr<T> const & p2)
233{
234 return p1 == p2.get();
235}
236
237template<typename T> inline bool operator ==(T * p1, VclPtr<T> const & p2) {
238 return p1 == p2.get();
239}
240
241template<typename T1, typename T2>
242inline bool operator !=(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
243 return !(p1 == p2);
244}
245
246template<typename T> inline bool operator !=(VclPtr<T> const & p1, T const * p2)
247{
248 return !(p1 == p2);
249}
250
251template<typename T> inline bool operator !=(VclPtr<T> const & p1, T * p2) {
252 return !(p1 == p2);
253}
254
255template<typename T> inline bool operator !=(T const * p1, VclPtr<T> const & p2)
256{
257 return !(p1 == p2);
258}
259
260template<typename T> inline bool operator !=(T * p1, VclPtr<T> const & p2) {
261 return !(p1 == p2);
262}
263
264/**
265 * A construction helper for a temporary VclPtr. Since VclPtr types
266 * are created with a reference-count of one - to help fit into
267 * the existing code-flow; this helps us to construct them easily.
268 * see also VclPtr::Create and ScopedVclPtr
269 *
270 * For more details on the design please see vcl/README.lifecycle
271 *
272 * @param reference_type must be a subclass of vcl::Window
273 */
274template <class reference_type>
275class SAL_WARN_UNUSED__attribute__((warn_unused)) VclPtrInstance final : public VclPtr<reference_type>
276{
277public:
278 template<typename... Arg> VclPtrInstance(Arg &&... arg)
279 : VclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
280 {
281 }
282
283 /**
284 * Override and disallow this, to prevent people accidentally calling it and actually
285 * getting VclPtr::Create and getting a naked VclPtr<> instance
286 */
287 template<typename... Arg> static VclPtrInstance< reference_type > Create(Arg &&... ) = delete;
288};
289
290template <class reference_type>
291class ScopedVclPtr : public VclPtr<reference_type>
292{
293public:
294 /** Constructor...
295 */
296 ScopedVclPtr()
297 : VclPtr<reference_type>()
298 {}
299
300 /** Constructor
301 */
302 ScopedVclPtr (reference_type * pBody)
303 : VclPtr<reference_type>(pBody)
304 {}
305
306 /** Copy constructor...
307 */
308 ScopedVclPtr (const VclPtr<reference_type> & handle)
309 : VclPtr<reference_type>(handle)
310 {}
311
312 /**
313 Assignment that releases the last reference.
314 */
315 void disposeAndReset(reference_type *pBody)
316 {
317 if (pBody != this->get()) {
318 VclPtr<reference_type>::disposeAndClear();
319 VclPtr<reference_type>::set(pBody);
320 }
321 }
322
323 /**
324 Assignment that releases the last reference.
325 */
326 ScopedVclPtr<reference_type>& operator = (reference_type * pBody)
327 {
328 disposeAndReset(pBody);
329 return *this;
330 }
331
332 /** Up-casting conversion constructor: Copies interface reference.
333
334 Does not work for up-casts to ambiguous bases. For the special case of
335 up-casting to Reference< XInterface >, see the corresponding conversion
336 operator.
337
338 @param rRef another reference
339 */
340 template< class derived_type >
341 ScopedVclPtr(
342 const VclPtr< derived_type > & rRef,
343 typename std::enable_if<
344 std::is_base_of<reference_type, derived_type>::value, int>::type
345 = 0 )
346 : VclPtr<reference_type>( rRef )
347 {
348 }
349
350 /** Up-casting assignment operator.
351
352 Does not work for up-casts to ambiguous bases.
353
354 @param rRef another VclPtr
355 */
356 template<typename derived_type>
357 typename std::enable_if<
358 std::is_base_of<reference_type, derived_type>::value,
359 ScopedVclPtr &>::type
360 operator =(VclPtr<derived_type> const & rRef)
361 {
362 disposeAndReset(rRef.get());
363 return *this;
364 }
365
366 /**
367 * Override and disallow this, to prevent people accidentally calling it and actually
368 * getting VclPtr::Create and getting a naked VclPtr<> instance
369 */
370 template<typename... Arg> static ScopedVclPtr< reference_type > Create(Arg &&... ) = delete;
371
372 ~ScopedVclPtr()
373 {
374 VclPtr<reference_type>::disposeAndClear();
375 assert(VclPtr<reference_type>::get() == nullptr)(static_cast <bool> (VclPtr<reference_type>::get(
) == nullptr) ? void (0) : __assert_fail ("VclPtr<reference_type>::get() == nullptr"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 375, __extension__ __PRETTY_FUNCTION__)); // make sure there are no lingering references
376 }
377
378private:
379 // Most likely we don't want this default copy-constructor.
380 ScopedVclPtr (const ScopedVclPtr<reference_type> &) = delete;
381 // And certainly we don't want a default assignment operator.
382 ScopedVclPtr<reference_type>& operator = (const ScopedVclPtr<reference_type> &) = delete;
383 // And disallow reset as that doesn't call disposeAndClear on the original reference
384 void reset() = delete;
385 void reset(reference_type *pBody) = delete;
386
387protected:
388 ScopedVclPtr (reference_type * pBody, __sal_NoAcquire)
389 : VclPtr<reference_type>(pBody, SAL_NO_ACQUIRE)
390 {}
391};
392
393/**
394 * A construction helper for ScopedVclPtr. Since VclPtr types are created
395 * with a reference-count of one - to help fit into the existing
396 * code-flow; this helps us to construct them easily.
397 *
398 * For more details on the design please see vcl/README.lifecycle
399 *
400 * @param reference_type must be a subclass of vcl::Window
401 */
402#if defined _MSC_VER
403#pragma warning(push)
404#pragma warning(disable: 4521) // " multiple copy constructors specified"
405#endif
406template <class reference_type>
407class SAL_WARN_UNUSED__attribute__((warn_unused)) ScopedVclPtrInstance final : public ScopedVclPtr<reference_type>
408{
409public:
410 template<typename... Arg> ScopedVclPtrInstance(Arg &&... arg)
411 : ScopedVclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
412 {
413 }
414
415 /**
416 * Override and disallow this, to prevent people accidentally calling it and actually
417 * getting VclPtr::Create and getting a naked VclPtr<> instance
418 */
419 template<typename... Arg> static ScopedVclPtrInstance< reference_type > Create(Arg &&...) = delete;
420
421private:
422 // Prevent the above perfect forwarding ctor from hijacking (accidental)
423 // attempts at ScopedVclPtrInstance copy construction (where the hijacking
424 // would typically lead to somewhat obscure error messages); both non-const
425 // and const variants are needed here, as the ScopedVclPtr base class has a
426 // const--variant copy ctor, so the implicitly declared copy ctor for
427 // ScopedVclPtrInstance would also be the const variant, so non-const copy
428 // construction attempts would be hijacked by the perfect forwarding ctor;
429 // but if we only declared a non-const variant here, the const variant would
430 // no longer be implicitly declared (as there would already be an explicitly
431 // declared copy ctor), so const copy construction attempts would then be
432 // hijacked by the perfect forwarding ctor:
433 ScopedVclPtrInstance(ScopedVclPtrInstance &) = delete;
434 ScopedVclPtrInstance(ScopedVclPtrInstance const &) = delete;
435};
436#if defined _MSC_VER
437#pragma warning(pop)
438#endif
439
440#endif // INCLUDED_VCL_PTR_HXX
441
442/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
←

/home/maarten/src/libreoffice/core/include/rtl/ref.hxx

→
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#ifndef INCLUDED_RTL_REF_HXX
21#define INCLUDED_RTL_REF_HXX
22
23#include "sal/config.h"
24
25#include <cassert>
26#include <cstddef>
27#include <functional>
28#ifdef LIBO_INTERNAL_ONLY1
29#include <type_traits>
30#endif
31
32#include "sal/types.h"
33
34namespace rtl
35{
36
37/** Template reference class for reference type.
38*/
39template <class reference_type>
40class Reference
41{
42 /** The <b>reference_type</b> body pointer.
43 */
44 reference_type * m_pBody;
45
46
47public:
48 /** Constructor...
49 */
50 Reference()
51 : m_pBody (NULL__null)
52 {}
53
54
55 /** Constructor...
56 */
57 Reference (reference_type * pBody, __sal_NoAcquire)
58 : m_pBody (pBody)
59 {
60 }
61
62 /** Constructor...
63 */
64 Reference (reference_type * pBody)
65 : m_pBody (pBody)
66 {
67 if (m_pBody)
5
←
Assuming field 'm_pBody' is non-null
→
6
←
Taking true branch
→
68 m_pBody->acquire();
69 }
70
71 /** Copy constructor...
72 */
73 Reference (const Reference<reference_type> & handle)
74 : m_pBody (handle.m_pBody)
75 {
76 if (m_pBody)
77 m_pBody->acquire();
78 }
79
80#ifdef LIBO_INTERNAL_ONLY1
81 /** Move constructor...
82 */
83 Reference (Reference<reference_type> && handle) noexcept
84 : m_pBody (handle.m_pBody)
85 {
86 handle.m_pBody = nullptr;
87 }
88#endif
89
90#if defined LIBO_INTERNAL_ONLY1
91 /** Up-casting conversion constructor: Copies interface reference.
92
93 Does not work for up-casts to ambiguous bases.
94
95 @param rRef another reference
96 */
97 template< class derived_type >
98 inline Reference(
99 const Reference< derived_type > & rRef,
100 std::enable_if_t<std::is_base_of_v<reference_type, derived_type>, int> = 0 )
101 : m_pBody (rRef.get())
102 {
103 if (m_pBody)
104 m_pBody->acquire();
105 }
106#endif
107
108 /** Destructor...
109 */
110 ~Reference() COVERITY_NOEXCEPT_FALSE
111 {
112 if (m_pBody
10.1
Field 'm_pBody' is non-null
10.1
Field 'm_pBody' is non-null
10.1
Field 'm_pBody' is non-null
10.1
Field 'm_pBody' is non-null
10.1
Field 'm_pBody' is non-null
)
11
←
Taking true branch
→
113 m_pBody->release();
12
←
Calling 'VclReferenceBase::release'
→
16
←
Returning; memory was released
→
114 }
115
116 /** Set...
117 Similar to assignment.
118 */
119 Reference<reference_type> &
120 SAL_CALL set (reference_type * pBody)
121 {
122 if (pBody)
123 pBody->acquire();
124 reference_type * const pOld = m_pBody;
125 m_pBody = pBody;
126 if (pOld)
127 pOld->release();
128 return *this;
129 }
130
131 /** Assignment.
132 Unbinds this instance from its body (if bound) and
133 bind it to the body represented by the handle.
134 */
135 Reference<reference_type> &
136 SAL_CALL operator= (const Reference<reference_type> & handle)
137 {
138 return set( handle.m_pBody );
139 }
140
141#ifdef LIBO_INTERNAL_ONLY1
142 /** Assignment.
143 * Unbinds this instance from its body (if bound),
144 * bind it to the body represented by the handle, and
145 * set the body represented by the handle to nullptr.
146 */
147 Reference<reference_type> &
148 operator= (Reference<reference_type> && handle)
149 {
150 // self-movement guts ourself
151 if (m_pBody)
152 m_pBody->release();
153 m_pBody = handle.m_pBody;
154 handle.m_pBody = nullptr;
155 return *this;
156 }
157#endif
158
159 /** Assignment...
160 */
161 Reference<reference_type> &
162 SAL_CALL operator= (reference_type * pBody)
163 {
164 return set( pBody );
165 }
166
167 /** Unbind the body from this handle.
168 Note that for a handle representing a large body,
169 "handle.clear().set(new body());" _might_
170 perform a little bit better than "handle.set(new body());",
171 since in the second case two large objects exist in memory
172 (the old body and the new body).
173 */
174 Reference<reference_type> & SAL_CALL clear()
175 {
176 if (m_pBody)
177 {
178 reference_type * const pOld = m_pBody;
179 m_pBody = NULL__null;
180 pOld->release();
181 }
182 return *this;
183 }
184
185
186 /** Get the body. Can be used instead of operator->().
187 I.e. handle->someBodyOp() and handle.get()->someBodyOp()
188 are the same.
189 */
190 reference_type * SAL_CALL get() const
191 {
192 return m_pBody;
23
←
Use of memory after it is freed
193 }
194
195
196 /** Probably most common used: handle->someBodyOp().
197 */
198 reference_type * SAL_CALL operator->() const
199 {
200 assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 200, __extension__ __PRETTY_FUNCTION__));
201 return m_pBody;
202 }
203
204
205 /** Allows (*handle).someBodyOp().
206 */
207 reference_type & SAL_CALL operator*() const
208 {
209 assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 209, __extension__ __PRETTY_FUNCTION__));
210 return *m_pBody;
211 }
212
213
214 /** Returns True if the handle does point to a valid body.
215 */
216 bool SAL_CALL is() const
217 {
218 return (m_pBody != NULL__null);
219 }
220
221#if defined LIBO_INTERNAL_ONLY1
222 /** Returns True if the handle does point to a valid body.
223 */
224 explicit operator bool() const
225 {
226 return is();
227 }
228#endif
229
230 /** Returns True if this points to pBody.
231 */
232 bool SAL_CALL operator== (const reference_type * pBody) const
233 {
234 return (m_pBody == pBody);
235 }
236
237
238 /** Returns True if handle points to the same body.
239 */
240 bool
241 SAL_CALL operator== (const Reference<reference_type> & handle) const
242 {
243 return (m_pBody == handle.m_pBody);
244 }
245
246
247 /** Needed to place References into STL collection.
248 */
249 bool
250 SAL_CALL operator!= (const Reference<reference_type> & handle) const
251 {
252 return (m_pBody != handle.m_pBody);
253 }
254
255
256 /** Needed to place References into STL collection.
257 */
258 bool
259 SAL_CALL operator< (const Reference<reference_type> & handle) const
260 {
261 return (m_pBody < handle.m_pBody);
262 }
263
264
265 /** Needed to place References into STL collection.
266 */
267 bool
268 SAL_CALL operator> (const Reference<reference_type> & handle) const
269 {
270 return (m_pBody > handle.m_pBody);
271 }
272};
273
274} // namespace rtl
275
276#if defined LIBO_INTERNAL_ONLY1
277namespace std
278{
279
280/// @cond INTERNAL
281/**
282 Make rtl::Reference hashable by default for use in STL containers.
283
284 @since LibreOffice 6.3
285*/
286template<typename T>
287struct hash<::rtl::Reference<T>>
288{
289 std::size_t operator()(::rtl::Reference<T> const & s) const
290 { return std::size_t(s.get()); }
291};
292/// @endcond
293
294}
295
296#endif
297
298#endif /* ! INCLUDED_RTL_REF_HXX */
299
300/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
←

/home/maarten/src/libreoffice/core/include/vcl/vclreferencebase.hxx

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#ifndef INCLUDED_VCL_Reference_HXX
20#define INCLUDED_VCL_Reference_HXX
21
22#include <vcl/dllapi.h>
23#include <osl/interlck.h>
24
25class VCL_DLLPUBLIC__attribute__ ((visibility("default"))) VclReferenceBase
26{
27 mutable oslInterlockedCount mnRefCnt;
28
29 template<typename T> friend class VclPtr;
30
31public:
32 void acquire() const
33 {
34 osl_atomic_increment(&mnRefCnt)__sync_add_and_fetch((&mnRefCnt), 1);
35 }
36
37 void release() const
38 {
39 if (osl_atomic_decrement(&mnRefCnt)__sync_sub_and_fetch((&mnRefCnt), 1) == 0)
13
←
Assuming the condition is true
→
14
←
Taking true branch
→
40 delete this;
15
←
Memory is released
→
41 }
42#ifdef DBG_UTIL
43#ifndef _WIN32
44 sal_Int32 getRefCount() const { return mnRefCnt; }
45#endif
46#endif
47
48
49private:
50 VclReferenceBase(const VclReferenceBase&) = delete;
51 VclReferenceBase& operator=(const VclReferenceBase&) = delete;
52
53 bool mbDisposed : 1;
54
55protected:
56 VclReferenceBase();
57protected:
58 virtual ~VclReferenceBase();
59
60protected:
61 virtual void dispose();
62
63public:
64 void disposeOnce();
65 bool isDisposed() const { return mbDisposed; }
66
67};
68#endif