| File: | home/maarten/src/libreoffice/core/forms/source/richtext/richtextcontrol.cxx |
| Warning: | line 188, column 47 Use of memory after it is freed |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 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 "richtextcontrol.hxx" | |||
| 21 | #include <frm_strings.hxx> | |||
| 22 | #include <services.hxx> | |||
| 23 | ||||
| 24 | #include "richtextmodel.hxx" | |||
| 25 | #include "richtextvclcontrol.hxx" | |||
| 26 | #include "clipboarddispatcher.hxx" | |||
| 27 | #include "parametrizedattributedispatcher.hxx" | |||
| 28 | #include "specialdispatchers.hxx" | |||
| 29 | ||||
| 30 | #include <com/sun/star/awt/PosSize.hpp> | |||
| 31 | ||||
| 32 | #include <toolkit/helper/vclunohelper.hxx> | |||
| 33 | #include <tools/debug.hxx> | |||
| 34 | #include <tools/diagnose_ex.h> | |||
| 35 | #include <sal/log.hxx> | |||
| 36 | #include <vcl/svapp.hxx> | |||
| 37 | ||||
| 38 | #include <svx/svxids.hrc> | |||
| 39 | #include <editeng/editview.hxx> | |||
| 40 | #include <svl/itemset.hxx> | |||
| 41 | #include <svl/itempool.hxx> | |||
| 42 | #include <sfx2/msgpool.hxx> | |||
| 43 | #include <sfx2/msg.hxx> | |||
| 44 | ||||
| 45 | namespace frm | |||
| 46 | { | |||
| 47 | ||||
| 48 | ||||
| 49 | using namespace ::com::sun::star::uno; | |||
| 50 | using namespace ::com::sun::star::beans; | |||
| 51 | using namespace ::com::sun::star::awt; | |||
| 52 | using namespace ::com::sun::star::lang; | |||
| 53 | using namespace ::com::sun::star::frame; | |||
| 54 | ||||
| 55 | ORichTextControl::ORichTextControl() | |||
| 56 | :UnoEditControl() | |||
| 57 | { | |||
| 58 | } | |||
| 59 | ||||
| 60 | ||||
| 61 | ORichTextControl::~ORichTextControl() | |||
| 62 | { | |||
| 63 | } | |||
| 64 | ||||
| 65 | ||||
| 66 | IMPLEMENT_FORWARD_XTYPEPROVIDER2( ORichTextControl, UnoEditControl, ORichTextControl_Base )css::uno::Sequence< css::uno::Type > ORichTextControl:: getTypes( ) { return ::comphelper::concatSequences( UnoEditControl ::getTypes(), ORichTextControl_Base::getTypes() ); } css::uno ::Sequence< sal_Int8 > ORichTextControl::getImplementationId ( ) { return css::uno::Sequence<sal_Int8>(); } | |||
| 67 | ||||
| 68 | ||||
| 69 | Any SAL_CALL ORichTextControl::queryAggregation( const Type& _rType ) | |||
| 70 | { | |||
| 71 | Any aReturn = UnoEditControl::queryAggregation( _rType ); | |||
| 72 | ||||
| 73 | if ( !aReturn.hasValue() ) | |||
| 74 | aReturn = ORichTextControl_Base::queryInterface( _rType ); | |||
| 75 | ||||
| 76 | return aReturn; | |||
| 77 | } | |||
| 78 | ||||
| 79 | ||||
| 80 | namespace | |||
| 81 | { | |||
| 82 | ||||
| 83 | void implAdjustTriStateFlag( const Reference< XPropertySet >& _rxProps, const OUString& _rPropertyName, | |||
| 84 | WinBits& _rAllBits, WinBits _nPositiveFlag, WinBits nNegativeFlag ) | |||
| 85 | { | |||
| 86 | bool bFlagValue = false; | |||
| 87 | if ( _rxProps->getPropertyValue( _rPropertyName ) >>= bFlagValue ) | |||
| 88 | _rAllBits |= ( bFlagValue ? _nPositiveFlag : nNegativeFlag ); | |||
| 89 | } | |||
| 90 | ||||
| 91 | ||||
| 92 | void implAdjustTwoStateFlag( const Any& _rValue, WinBits& _rAllBits, WinBits _nFlag, bool _bInvert ) | |||
| 93 | { | |||
| 94 | bool bFlagValue = false; | |||
| 95 | if ( _rValue >>= bFlagValue ) | |||
| 96 | { | |||
| 97 | if ( _bInvert ) | |||
| 98 | bFlagValue = !bFlagValue; | |||
| 99 | if ( bFlagValue ) | |||
| 100 | _rAllBits |= _nFlag; | |||
| 101 | else | |||
| 102 | _rAllBits &= ~_nFlag; | |||
| 103 | } | |||
| 104 | } | |||
| 105 | ||||
| 106 | ||||
| 107 | void implAdjustTwoStateFlag( const Reference< XPropertySet >& _rxProps, const OUString& _rPropertyName, | |||
| 108 | WinBits& _rAllBits, WinBits _nFlag, bool _bInvert = false ) | |||
| 109 | { | |||
| 110 | implAdjustTwoStateFlag( _rxProps->getPropertyValue( _rPropertyName ), _rAllBits, _nFlag, _bInvert ); | |||
| 111 | } | |||
| 112 | ||||
| 113 | ||||
| 114 | void adjustTwoStateWinBit( vcl::Window* _pWindow, const Any& _rValue, WinBits _nFlag, bool _bInvert = false ) | |||
| 115 | { | |||
| 116 | WinBits nBits = _pWindow->GetStyle(); | |||
| 117 | implAdjustTwoStateFlag( _rValue, nBits, _nFlag, _bInvert ); | |||
| 118 | _pWindow->SetStyle( nBits ); | |||
| 119 | } | |||
| 120 | ||||
| 121 | ||||
| 122 | WinBits getWinBits( const Reference< XControlModel >& _rxModel ) | |||
| 123 | { | |||
| 124 | WinBits nBits = 0; | |||
| 125 | try | |||
| 126 | { | |||
| 127 | Reference< XPropertySet > xProps( _rxModel, UNO_QUERY ); | |||
| 128 | if ( xProps.is() ) | |||
| 129 | { | |||
| 130 | sal_Int16 nBorder = 0; | |||
| 131 | xProps->getPropertyValue( PROPERTY_BORDER"Border" ) >>= nBorder; | |||
| 132 | if ( nBorder ) | |||
| 133 | nBits |= WB_BORDER; | |||
| 134 | ||||
| 135 | implAdjustTriStateFlag( xProps, PROPERTY_TABSTOP"Tabstop", nBits, WB_TABSTOP, WB_NOTABSTOP ); | |||
| 136 | implAdjustTwoStateFlag( xProps, PROPERTY_HSCROLL"HScroll", nBits, WB_HSCROLL ); | |||
| 137 | implAdjustTwoStateFlag( xProps, PROPERTY_VSCROLL"VScroll", nBits, WB_VSCROLL ); | |||
| 138 | implAdjustTwoStateFlag( xProps, PROPERTY_HARDLINEBREAKS"HardLineBreaks", nBits, WB_WORDBREAK, true ); | |||
| 139 | } | |||
| 140 | } | |||
| 141 | catch( const Exception& ) | |||
| 142 | { | |||
| 143 | DBG_UNHANDLED_EXCEPTION("forms.richtext")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/forms/source/richtext/richtextcontrol.cxx" ":" "143" ": ", "forms.richtext" );; | |||
| 144 | } | |||
| 145 | return nBits; | |||
| 146 | } | |||
| 147 | } | |||
| 148 | ||||
| 149 | ||||
| 150 | void SAL_CALL ORichTextControl::createPeer( const Reference< XToolkit >& _rToolkit, const Reference< XWindowPeer >& _rParentPeer ) | |||
| 151 | { | |||
| 152 | bool bReallyActAsRichText = false; | |||
| 153 | try | |||
| 154 | { | |||
| 155 | Reference< XPropertySet > xModelProps( getModel(), UNO_QUERY_THROW ); | |||
| 156 | xModelProps->getPropertyValue( PROPERTY_RICH_TEXT"RichText" ) >>= bReallyActAsRichText; | |||
| 157 | } | |||
| 158 | catch( const Exception& ) | |||
| 159 | { | |||
| 160 | DBG_UNHANDLED_EXCEPTION("forms.richtext")DbgUnhandledException( DbgGetCaughtException(), __func__, "/home/maarten/src/libreoffice/core/forms/source/richtext/richtextcontrol.cxx" ":" "160" ": ", "forms.richtext" );; | |||
| 161 | } | |||
| 162 | ||||
| 163 | if ( !bReallyActAsRichText ) | |||
| ||||
| 164 | { | |||
| 165 | UnoEditControl::createPeer( _rToolkit, _rParentPeer ); | |||
| 166 | return; | |||
| 167 | } | |||
| 168 | ||||
| 169 | SolarMutexGuard aGuard; | |||
| 170 | ||||
| 171 | if (getPeer().is()) | |||
| 172 | return; | |||
| 173 | ||||
| 174 | mbCreatingPeer = true; | |||
| 175 | ||||
| 176 | // determine the VLC window for the parent | |||
| 177 | vcl::Window* pParentWin = nullptr; | |||
| 178 | if ( _rParentPeer.is() ) | |||
| 179 | { | |||
| 180 | VCLXWindow* pParentXWin = comphelper::getUnoTunnelImplementation<VCLXWindow>( _rParentPeer ); | |||
| 181 | if ( pParentXWin ) | |||
| 182 | pParentWin = pParentXWin->GetWindow().get(); | |||
| 183 | DBG_ASSERT( pParentWin, "ORichTextControl::createPeer: could not obtain the VCL-level parent window!" )do { if (true && (!(pParentWin))) { sal_detail_logFormat ((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/forms/source/richtext/richtextcontrol.cxx" ":" "183" ": "), "%s", "ORichTextControl::createPeer: could not obtain the VCL-level parent window!" ); } } while (false); | |||
| 184 | } | |||
| 185 | ||||
| 186 | // create the peer | |||
| 187 | Reference< XControlModel > xModel( getModel() ); | |||
| 188 | rtl::Reference<ORichTextPeer> pPeer = ORichTextPeer::Create( xModel, pParentWin, getWinBits( xModel ) ); | |||
| ||||
| 189 | DBG_ASSERT( pPeer, "ORichTextControl::createPeer: invalid peer returned!" )do { if (true && (!(pPeer))) { sal_detail_logFormat(( SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/forms/source/richtext/richtextcontrol.cxx" ":" "189" ": "), "%s", "ORichTextControl::createPeer: invalid peer returned!" ); } } while (false); | |||
| 190 | if ( pPeer ) | |||
| 191 | { | |||
| 192 | // announce the peer to the base class | |||
| 193 | setPeer( pPeer.get() ); | |||
| 194 | ||||
| 195 | // initialize ourself (and thus the peer) with the model properties | |||
| 196 | updateFromModel(); | |||
| 197 | ||||
| 198 | Reference< XView > xPeerView( getPeer(), UNO_QUERY ); | |||
| 199 | if ( xPeerView.is() ) | |||
| 200 | { | |||
| 201 | xPeerView->setZoom( maComponentInfos.nZoomX, maComponentInfos.nZoomY ); | |||
| 202 | xPeerView->setGraphics( mxGraphics ); | |||
| 203 | } | |||
| 204 | ||||
| 205 | // a lot of initial settings from our component infos | |||
| 206 | setPosSize( maComponentInfos.nX, maComponentInfos.nY, maComponentInfos.nWidth, maComponentInfos.nHeight, PosSize::POSSIZE ); | |||
| 207 | ||||
| 208 | pPeer->setVisible ( maComponentInfos.bVisible && !mbDesignMode ); | |||
| 209 | pPeer->setEnable ( maComponentInfos.bEnable ); | |||
| 210 | pPeer->setDesignMode( mbDesignMode ); | |||
| 211 | ||||
| 212 | peerCreated(); | |||
| 213 | } | |||
| 214 | ||||
| 215 | mbCreatingPeer = false; | |||
| 216 | } | |||
| 217 | ||||
| 218 | OUString SAL_CALL ORichTextControl::getImplementationName() | |||
| 219 | { | |||
| 220 | return "com.sun.star.comp.form.ORichTextControl"; | |||
| 221 | } | |||
| 222 | ||||
| 223 | Sequence< OUString > SAL_CALL ORichTextControl::getSupportedServiceNames() | |||
| 224 | { | |||
| 225 | return { "com.sun.star.awt.UnoControl", | |||
| 226 | "com.sun.star.awt.UnoControlEdit", | |||
| 227 | FRM_SUN_CONTROL_RICHTEXTCONTROL"com.sun.star.form.control.RichTextControl" }; | |||
| 228 | } | |||
| 229 | ||||
| 230 | Reference< XDispatch > SAL_CALL ORichTextControl::queryDispatch( const css::util::URL& _rURL, const OUString& _rTargetFrameName, sal_Int32 _nSearchFlags ) | |||
| 231 | { | |||
| 232 | Reference< XDispatch > aReturn; | |||
| 233 | Reference< XDispatchProvider > xTypedPeer( getPeer(), UNO_QUERY ); | |||
| 234 | if ( xTypedPeer.is() ) | |||
| 235 | { | |||
| 236 | aReturn = xTypedPeer->queryDispatch( _rURL, _rTargetFrameName, _nSearchFlags ); | |||
| 237 | } | |||
| 238 | return aReturn; | |||
| 239 | } | |||
| 240 | ||||
| 241 | Sequence< Reference< XDispatch > > SAL_CALL ORichTextControl::queryDispatches( const Sequence< DispatchDescriptor >& _rRequests ) | |||
| 242 | { | |||
| 243 | Sequence< Reference< XDispatch > > aReturn; | |||
| 244 | Reference< XDispatchProvider > xTypedPeer( getPeer(), UNO_QUERY ); | |||
| 245 | if ( xTypedPeer.is() ) | |||
| 246 | { | |||
| 247 | aReturn = xTypedPeer->queryDispatches( _rRequests ); | |||
| 248 | } | |||
| 249 | return aReturn; | |||
| 250 | } | |||
| 251 | ||||
| 252 | bool ORichTextControl::requiresNewPeer( const OUString& _rPropertyName ) const | |||
| 253 | { | |||
| 254 | return UnoControl::requiresNewPeer( _rPropertyName ) || _rPropertyName == PROPERTY_RICH_TEXT"RichText"; | |||
| 255 | } | |||
| 256 | ||||
| 257 | // ORichTextPeer | |||
| 258 | rtl::Reference<ORichTextPeer> ORichTextPeer::Create( const Reference< XControlModel >& _rxModel, vcl::Window* _pParentWindow, WinBits _nStyle ) | |||
| 259 | { | |||
| 260 | DBG_TESTSOLARMUTEX()do { DbgTestSolarMutex(); } while(false); | |||
| 261 | ||||
| 262 | // the EditEngine of the model | |||
| 263 | RichTextEngine* pEngine = ORichTextModel::getEditEngine( _rxModel ); | |||
| 264 | OSL_ENSURE( pEngine, "ORichTextPeer::Create: could not obtaine the edit engine from the model!" )do { if (true && (!(pEngine))) { sal_detail_logFormat ((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/forms/source/richtext/richtextcontrol.cxx" ":" "264" ": "), "%s", "ORichTextPeer::Create: could not obtaine the edit engine from the model!" ); } } while (false); | |||
| 265 | if ( !pEngine ) | |||
| 266 | return nullptr; | |||
| 267 | ||||
| 268 | // the peer itself | |||
| 269 | rtl::Reference<ORichTextPeer> pPeer(new ORichTextPeer); | |||
| 270 | ||||
| 271 | // the VCL control for the peer | |||
| 272 | VclPtrInstance<RichTextControl> pRichTextControl( pEngine, _pParentWindow, _nStyle, nullptr, pPeer.get() ); | |||
| 273 | ||||
| 274 | // some knittings | |||
| 275 | pRichTextControl->SetComponentInterface( pPeer.get() ); | |||
| 276 | ||||
| 277 | // outta here | |||
| 278 | return pPeer; | |||
| 279 | } | |||
| 280 | ||||
| 281 | ||||
| 282 | ORichTextPeer::ORichTextPeer() | |||
| 283 | { | |||
| 284 | } | |||
| 285 | ||||
| 286 | ||||
| 287 | ORichTextPeer::~ORichTextPeer() | |||
| 288 | { | |||
| 289 | } | |||
| 290 | ||||
| 291 | ||||
| 292 | void ORichTextPeer::dispose( ) | |||
| 293 | { | |||
| 294 | { | |||
| 295 | SolarMutexGuard aGuard; | |||
| 296 | VclPtr< RichTextControl > pRichTextControl = GetAs< RichTextControl >(); | |||
| 297 | ||||
| 298 | if ( pRichTextControl ) | |||
| 299 | { | |||
| 300 | for (auto const& dispatcher : m_aDispatchers) | |||
| 301 | { | |||
| 302 | pRichTextControl->disableAttributeNotification(dispatcher.first); | |||
| 303 | dispatcher.second->dispose(); | |||
| 304 | } | |||
| 305 | } | |||
| 306 | ||||
| 307 | AttributeDispatchers aEmpty; | |||
| 308 | m_aDispatchers.swap( aEmpty ); | |||
| 309 | } | |||
| 310 | ||||
| 311 | VCLXWindow::dispose(); | |||
| 312 | } | |||
| 313 | ||||
| 314 | ||||
| 315 | void SAL_CALL ORichTextPeer::draw( sal_Int32 _nX, sal_Int32 _nY ) | |||
| 316 | { | |||
| 317 | SolarMutexGuard aGuard; | |||
| 318 | ||||
| 319 | VclPtr< RichTextControl > pControl = GetAs< RichTextControl >(); | |||
| 320 | if ( !pControl ) | |||
| 321 | return; | |||
| 322 | ||||
| 323 | OutputDevice* pTargetDevice = VCLUnoHelper::GetOutputDevice( getGraphics() ); | |||
| 324 | OSL_ENSURE( pTargetDevice != nullptr, "ORichTextPeer::draw: no graphics -> no drawing!" )do { if (true && (!(pTargetDevice != nullptr))) { sal_detail_logFormat ((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/forms/source/richtext/richtextcontrol.cxx" ":" "324" ": "), "%s", "ORichTextPeer::draw: no graphics -> no drawing!" ); } } while (false); | |||
| 325 | if ( !pTargetDevice ) | |||
| 326 | return; | |||
| 327 | ||||
| 328 | const MapUnit eTargetUnit = pTargetDevice->GetMapMode().GetMapUnit(); | |||
| 329 | ::Point aPos( _nX, _nY ); | |||
| 330 | // the XView::draw API talks about pixels, always ... | |||
| 331 | if ( eTargetUnit != MapUnit::MapPixel ) | |||
| 332 | aPos = pTargetDevice->PixelToLogic( aPos ); | |||
| 333 | ||||
| 334 | pControl->Draw( pTargetDevice, aPos, DrawFlags::NoControls ); | |||
| 335 | } | |||
| 336 | ||||
| 337 | ||||
| 338 | void SAL_CALL ORichTextPeer::setProperty( const OUString& _rPropertyName, const Any& _rValue ) | |||
| 339 | { | |||
| 340 | SolarMutexGuard g; | |||
| 341 | ||||
| 342 | if ( !GetWindow() ) | |||
| 343 | { | |||
| 344 | VCLXWindow::setProperty( _rPropertyName, _rValue ); | |||
| 345 | return; | |||
| 346 | } | |||
| 347 | ||||
| 348 | if ( _rPropertyName == PROPERTY_BACKGROUNDCOLOR"BackgroundColor" ) | |||
| 349 | { | |||
| 350 | VclPtr< RichTextControl > pControl = GetAs< RichTextControl >(); | |||
| 351 | if ( !_rValue.hasValue() ) | |||
| 352 | { | |||
| 353 | pControl->SetBackgroundColor( ); | |||
| 354 | } | |||
| 355 | else | |||
| 356 | { | |||
| 357 | Color nColor = COL_TRANSPARENT; | |||
| 358 | _rValue >>= nColor; | |||
| 359 | pControl->SetBackgroundColor( nColor ); | |||
| 360 | } | |||
| 361 | } | |||
| 362 | else if ( _rPropertyName == PROPERTY_HSCROLL"HScroll" ) | |||
| 363 | { | |||
| 364 | adjustTwoStateWinBit( GetWindow(), _rValue, WB_HSCROLL ); | |||
| 365 | } | |||
| 366 | else if ( _rPropertyName == PROPERTY_VSCROLL"VScroll" ) | |||
| 367 | { | |||
| 368 | adjustTwoStateWinBit( GetWindow(), _rValue, WB_VSCROLL ); | |||
| 369 | } | |||
| 370 | else if ( _rPropertyName == PROPERTY_HARDLINEBREAKS"HardLineBreaks" ) | |||
| 371 | { | |||
| 372 | adjustTwoStateWinBit( GetWindow(), _rValue, WB_WORDBREAK, true ); | |||
| 373 | } | |||
| 374 | else if ( _rPropertyName == PROPERTY_READONLY"ReadOnly" ) | |||
| 375 | { | |||
| 376 | VclPtr< RichTextControl > pControl = GetAs< RichTextControl >(); | |||
| 377 | bool bReadOnly( pControl->IsReadOnly() ); | |||
| 378 | OSL_VERIFY( _rValue >>= bReadOnly )do { if (!(_rValue >>= bReadOnly)) do { if (true && (!(0))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ( "legacy.osl"), ("/home/maarten/src/libreoffice/core/forms/source/richtext/richtextcontrol.cxx" ":" "378" ": "), "OSL_ASSERT: %s", "0"); } } while (false); } while (0); | |||
| 379 | pControl->SetReadOnly( bReadOnly ); | |||
| 380 | ||||
| 381 | // update the dispatchers | |||
| 382 | for (auto const& dispatcher : m_aDispatchers) | |||
| 383 | { | |||
| 384 | dispatcher.second->invalidate(); | |||
| 385 | } | |||
| 386 | } | |||
| 387 | else if ( _rPropertyName == PROPERTY_HIDEINACTIVESELECTION"HideInactiveSelection" ) | |||
| 388 | { | |||
| 389 | VclPtr< RichTextControl > pRichTextControl = GetAs< RichTextControl >(); | |||
| 390 | bool bHide = pRichTextControl->GetHideInactiveSelection(); | |||
| 391 | OSL_VERIFY( _rValue >>= bHide )do { if (!(_rValue >>= bHide)) do { if (true && (!(0))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), ( "legacy.osl"), ("/home/maarten/src/libreoffice/core/forms/source/richtext/richtextcontrol.cxx" ":" "391" ": "), "OSL_ASSERT: %s", "0"); } } while (false); } while (0); | |||
| 392 | pRichTextControl->SetHideInactiveSelection( bHide ); | |||
| 393 | } | |||
| 394 | else | |||
| 395 | VCLXWindow::setProperty( _rPropertyName, _rValue ); | |||
| 396 | } | |||
| 397 | ||||
| 398 | ||||
| 399 | IMPLEMENT_FORWARD_XINTERFACE2( ORichTextPeer, VCLXWindow, ORichTextPeer_Base )void ORichTextPeer::acquire() throw() { VCLXWindow::acquire() ; } void ORichTextPeer::release() throw() { VCLXWindow::release (); } css::uno::Any ORichTextPeer::queryInterface( const css:: uno::Type& _rType ) { css::uno::Any aReturn = VCLXWindow:: queryInterface( _rType ); if ( !aReturn.hasValue() ) aReturn = ORichTextPeer_Base::queryInterface( _rType ); return aReturn ; } | |||
| 400 | ||||
| 401 | ||||
| 402 | IMPLEMENT_FORWARD_XTYPEPROVIDER2( ORichTextPeer, VCLXWindow, ORichTextPeer_Base )css::uno::Sequence< css::uno::Type > ORichTextPeer::getTypes ( ) { return ::comphelper::concatSequences( VCLXWindow::getTypes (), ORichTextPeer_Base::getTypes() ); } css::uno::Sequence< sal_Int8 > ORichTextPeer::getImplementationId( ) { return css::uno::Sequence<sal_Int8>(); } | |||
| 403 | ||||
| 404 | ||||
| 405 | namespace | |||
| 406 | { | |||
| 407 | SfxSlotId lcl_translateConflictingSlot( SfxSlotId _nIDFromPool ) | |||
| 408 | { | |||
| 409 | // HACK HACK HACK | |||
| 410 | // unfortunately, some of our applications have some conflicting slots, | |||
| 411 | // i.e. slots which have the same UNO name as an existing other (common) | |||
| 412 | // slot. | |||
| 413 | // For instance, both the slots SID_SET_SUPER_SCRIPT (from SVX) and FN_SET_SUPER_SCRIPT | |||
| 414 | // (from SW) have the UNO name "SuperScript". | |||
| 415 | // Now, if the controls lives in a text document, and asks the SfxSlotPool for | |||
| 416 | // the id belonging to "SuperScript", it gets the FN_SET_SUPER_SCRIPT - which | |||
| 417 | // is completely unknown to the EditEngine. | |||
| 418 | // So, we need to translate such conflicting ids. | |||
| 419 | ||||
| 420 | // Note that the real solution would be to fix the applications to | |||
| 421 | // *not* define conflicting slots. Alternatively, if SFX would provide a slot pool | |||
| 422 | // which is *static* (i.e. independent on the active application), then we | |||
| 423 | // would also never encounter such a conflict. | |||
| 424 | SfxSlotId nReturn( _nIDFromPool ); | |||
| 425 | switch ( _nIDFromPool ) | |||
| 426 | { | |||
| 427 | case 20411: /* FM_SET_SUPER_SCRIPT, originating in SW */ | |||
| 428 | nReturn = SID_SET_SUPER_SCRIPT( 10000 + 294 ); | |||
| 429 | break; | |||
| 430 | case 20412: /* FN_SET_SUB_SCRIPT, originating in SW */ | |||
| 431 | nReturn = SID_SET_SUB_SCRIPT( 10000 + 295 ); | |||
| 432 | break; | |||
| 433 | } | |||
| 434 | return nReturn; | |||
| 435 | } | |||
| 436 | } | |||
| 437 | ||||
| 438 | ||||
| 439 | ORichTextPeer::SingleAttributeDispatcher ORichTextPeer::implCreateDispatcher( SfxSlotId _nSlotId, const css::util::URL& _rURL ) | |||
| 440 | { | |||
| 441 | VclPtr< RichTextControl > pRichTextControl = GetAs< RichTextControl >(); | |||
| 442 | OSL_PRECOND( pRichTextControl, "ORichTextPeer::implCreateDispatcher: invalid window!" )do { if (true && (!(pRichTextControl))) { sal_detail_logFormat ((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/forms/source/richtext/richtextcontrol.cxx" ":" "442" ": "), "%s", "ORichTextPeer::implCreateDispatcher: invalid window!" ); } } while (false); | |||
| 443 | if ( !pRichTextControl ) | |||
| 444 | return SingleAttributeDispatcher( nullptr ); | |||
| 445 | ||||
| 446 | ORichTextFeatureDispatcher* pDispatcher = nullptr; | |||
| 447 | OAttributeDispatcher* pAttributeDispatcher = nullptr; | |||
| 448 | switch ( _nSlotId ) | |||
| 449 | { | |||
| 450 | case SID_CUT(5000 + 710): | |||
| 451 | pDispatcher = new OClipboardDispatcher( pRichTextControl->getView(), OClipboardDispatcher::eCut ); | |||
| 452 | break; | |||
| 453 | ||||
| 454 | case SID_COPY(5000 + 711): | |||
| 455 | pDispatcher = new OClipboardDispatcher( pRichTextControl->getView(), OClipboardDispatcher::eCopy ); | |||
| 456 | break; | |||
| 457 | ||||
| 458 | case SID_PASTE(5000 + 712): | |||
| 459 | pDispatcher = new OPasteClipboardDispatcher( pRichTextControl->getView() ); | |||
| 460 | break; | |||
| 461 | ||||
| 462 | case SID_SELECTALL(5000 + 723): | |||
| 463 | pDispatcher = new OSelectAllDispatcher( pRichTextControl->getView(), _rURL ); | |||
| 464 | break; | |||
| 465 | ||||
| 466 | case SID_ATTR_PARA_LEFT_TO_RIGHT( 10000 + 950 ): | |||
| 467 | case SID_ATTR_PARA_RIGHT_TO_LEFT( 10000 + 951 ): | |||
| 468 | pAttributeDispatcher = new OParagraphDirectionDispatcher( pRichTextControl->getView(), _nSlotId, _rURL, pRichTextControl ); | |||
| 469 | break; | |||
| 470 | ||||
| 471 | case SID_TEXTDIRECTION_TOP_TO_BOTTOM( 10000 + 908 ): | |||
| 472 | case SID_TEXTDIRECTION_LEFT_TO_RIGHT( 10000 + 907 ): | |||
| 473 | pDispatcher = new OTextDirectionDispatcher( pRichTextControl->getView(), _rURL ); | |||
| 474 | break; | |||
| 475 | ||||
| 476 | case SID_ATTR_PARA_HANGPUNCTUATION( 10000 + 902 ): | |||
| 477 | case SID_ATTR_PARA_FORBIDDEN_RULES( 10000 + 903 ): | |||
| 478 | case SID_ATTR_PARA_SCRIPTSPACE( 10000 + 901 ): | |||
| 479 | pAttributeDispatcher = new OAsianFontLayoutDispatcher( pRichTextControl->getView(), _nSlotId, _rURL, pRichTextControl ); | |||
| 480 | break; | |||
| 481 | ||||
| 482 | default: | |||
| 483 | { | |||
| 484 | const SfxItemPool& rPool = *pRichTextControl->getView().GetEmptyItemSet().GetPool(); | |||
| 485 | bool bSupportedSlot = rPool.IsInRange( rPool.GetWhich( _nSlotId ) ); | |||
| 486 | ||||
| 487 | if ( !bSupportedSlot ) | |||
| 488 | bSupportedSlot = RichTextControl::isMappableSlot( _nSlotId ); | |||
| 489 | ||||
| 490 | if ( bSupportedSlot ) | |||
| 491 | { // it's really a slot which is supported by the EditEngine | |||
| 492 | ||||
| 493 | bool bNeedParametrizedDispatcher = true; | |||
| 494 | if ( ( _nSlotId == SID_ATTR_CHAR_POSTURE( 10000 + 8 ) ) | |||
| 495 | || ( _nSlotId == SID_ATTR_CHAR_CJK_POSTURE( 10000 + 890 ) ) | |||
| 496 | || ( _nSlotId == SID_ATTR_CHAR_CTL_POSTURE( 10000 + 895 ) ) | |||
| 497 | || ( _nSlotId == SID_ATTR_CHAR_LATIN_POSTURE( 10000 + 997 ) ) | |||
| 498 | || ( _nSlotId == SID_ATTR_CHAR_WEIGHT( 10000 + 9 ) ) | |||
| 499 | || ( _nSlotId == SID_ATTR_CHAR_CJK_WEIGHT( 10000 + 891 ) ) | |||
| 500 | || ( _nSlotId == SID_ATTR_CHAR_CTL_WEIGHT( 10000 + 896 ) ) | |||
| 501 | || ( _nSlotId == SID_ATTR_CHAR_LATIN_WEIGHT( 10000 + 998 ) ) | |||
| 502 | || ( _nSlotId == SID_ATTR_CHAR_LANGUAGE( 10000 + 20 ) ) | |||
| 503 | || ( _nSlotId == SID_ATTR_CHAR_CJK_LANGUAGE( 10000 + 889 ) ) | |||
| 504 | || ( _nSlotId == SID_ATTR_CHAR_CTL_LANGUAGE( 10000 + 894 ) ) | |||
| 505 | || ( _nSlotId == SID_ATTR_CHAR_LATIN_LANGUAGE( 10000 + 996 ) ) | |||
| 506 | || ( _nSlotId == SID_ATTR_CHAR_CONTOUR( 10000 + 12 ) ) | |||
| 507 | || ( _nSlotId == SID_ATTR_CHAR_SHADOWED( 10000 + 10 ) ) | |||
| 508 | || ( _nSlotId == SID_ATTR_CHAR_WORDLINEMODE( 10000 + 11 ) ) | |||
| 509 | || ( _nSlotId == SID_ATTR_CHAR_COLOR( 10000 + 17 ) ) | |||
| 510 | || ( _nSlotId == SID_ATTR_CHAR_RELIEF( 10000 + 920 ) ) | |||
| 511 | || ( _nSlotId == SID_ATTR_CHAR_KERNING( 10000 + 18 ) ) | |||
| 512 | || ( _nSlotId == SID_ATTR_CHAR_AUTOKERN( 10000 + 67 ) ) | |||
| 513 | || ( _nSlotId == SID_ATTR_CHAR_SCALEWIDTH( 10000 + 911 ) ) | |||
| 514 | ) | |||
| 515 | { | |||
| 516 | bNeedParametrizedDispatcher = true; | |||
| 517 | } | |||
| 518 | else | |||
| 519 | { | |||
| 520 | SfxSlotPool& rSlotPool = SfxSlotPool::GetSlotPool(); | |||
| 521 | const SfxSlot* pSlot = rSlotPool.GetSlot( _nSlotId ); | |||
| 522 | const SfxType* pType = pSlot ? pSlot->GetType() : nullptr; | |||
| 523 | if ( pType ) | |||
| 524 | { | |||
| 525 | bNeedParametrizedDispatcher = ( pType->nAttribs > 0 ); | |||
| 526 | } | |||
| 527 | } | |||
| 528 | ||||
| 529 | if ( bNeedParametrizedDispatcher ) | |||
| 530 | { | |||
| 531 | pAttributeDispatcher = new OParametrizedAttributeDispatcher( pRichTextControl->getView(), _nSlotId, _rURL, pRichTextControl ); | |||
| 532 | } | |||
| 533 | else | |||
| 534 | { | |||
| 535 | pAttributeDispatcher = new OAttributeDispatcher( pRichTextControl->getView(), _nSlotId, _rURL, pRichTextControl ); | |||
| 536 | } | |||
| 537 | } | |||
| 538 | else | |||
| 539 | { | |||
| 540 | SAL_WARN("forms.richtext", "ORichTextPeer::implCreateDispatcher: not creating dispatcher (unsupported slot) for "do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN , "forms.richtext")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break ; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult ( ::sal::detail::StreamStart() << "ORichTextPeer::implCreateDispatcher: not creating dispatcher (unsupported slot) for " << _rURL.Complete) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN ), ("forms.richtext"), ("/home/maarten/src/libreoffice/core/forms/source/richtext/richtextcontrol.cxx" ":" "541" ": "), ::sal::detail::unwrapStream( ::sal::detail:: StreamStart() << "ORichTextPeer::implCreateDispatcher: not creating dispatcher (unsupported slot) for " << _rURL.Complete), 0); } else { ::std::ostringstream sal_detail_stream ; sal_detail_stream << "ORichTextPeer::implCreateDispatcher: not creating dispatcher (unsupported slot) for " << _rURL.Complete; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN ), ("forms.richtext"), ("/home/maarten/src/libreoffice/core/forms/source/richtext/richtextcontrol.cxx" ":" "541" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL : if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart () << "ORichTextPeer::implCreateDispatcher: not creating dispatcher (unsupported slot) for " << _rURL.Complete) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN ), ("forms.richtext"), ("/home/maarten/src/libreoffice/core/forms/source/richtext/richtextcontrol.cxx" ":" "541" ": "), ::sal::detail::unwrapStream( ::sal::detail:: StreamStart() << "ORichTextPeer::implCreateDispatcher: not creating dispatcher (unsupported slot) for " << _rURL.Complete), 0); } else { ::std::ostringstream sal_detail_stream ; sal_detail_stream << "ORichTextPeer::implCreateDispatcher: not creating dispatcher (unsupported slot) for " << _rURL.Complete; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN ), ("forms.richtext"), ("/home/maarten/src/libreoffice/core/forms/source/richtext/richtextcontrol.cxx" ":" "541" ": "), sal_detail_stream, 0); }; std::abort(); break ; } } } while (false) | |||
| 541 | << _rURL.Complete)do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_WARN , "forms.richtext")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break ; case SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult ( ::sal::detail::StreamStart() << "ORichTextPeer::implCreateDispatcher: not creating dispatcher (unsupported slot) for " << _rURL.Complete) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN ), ("forms.richtext"), ("/home/maarten/src/libreoffice/core/forms/source/richtext/richtextcontrol.cxx" ":" "541" ": "), ::sal::detail::unwrapStream( ::sal::detail:: StreamStart() << "ORichTextPeer::implCreateDispatcher: not creating dispatcher (unsupported slot) for " << _rURL.Complete), 0); } else { ::std::ostringstream sal_detail_stream ; sal_detail_stream << "ORichTextPeer::implCreateDispatcher: not creating dispatcher (unsupported slot) for " << _rURL.Complete; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN ), ("forms.richtext"), ("/home/maarten/src/libreoffice/core/forms/source/richtext/richtextcontrol.cxx" ":" "541" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL : if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart () << "ORichTextPeer::implCreateDispatcher: not creating dispatcher (unsupported slot) for " << _rURL.Complete) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_WARN ), ("forms.richtext"), ("/home/maarten/src/libreoffice/core/forms/source/richtext/richtextcontrol.cxx" ":" "541" ": "), ::sal::detail::unwrapStream( ::sal::detail:: StreamStart() << "ORichTextPeer::implCreateDispatcher: not creating dispatcher (unsupported slot) for " << _rURL.Complete), 0); } else { ::std::ostringstream sal_detail_stream ; sal_detail_stream << "ORichTextPeer::implCreateDispatcher: not creating dispatcher (unsupported slot) for " << _rURL.Complete; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_WARN ), ("forms.richtext"), ("/home/maarten/src/libreoffice/core/forms/source/richtext/richtextcontrol.cxx" ":" "541" ": "), sal_detail_stream, 0); }; std::abort(); break ; } } } while (false); | |||
| 542 | } | |||
| 543 | } | |||
| 544 | break; | |||
| 545 | } | |||
| 546 | ||||
| 547 | SingleAttributeDispatcher xDispatcher( pDispatcher ); | |||
| 548 | if ( pAttributeDispatcher ) | |||
| 549 | { | |||
| 550 | xDispatcher = SingleAttributeDispatcher( pAttributeDispatcher ); | |||
| 551 | pRichTextControl->enableAttributeNotification( _nSlotId, pAttributeDispatcher ); | |||
| 552 | } | |||
| 553 | ||||
| 554 | return xDispatcher; | |||
| 555 | } | |||
| 556 | ||||
| 557 | ||||
| 558 | namespace | |||
| 559 | { | |||
| 560 | SfxSlotId lcl_getSlotFromUnoName( SfxSlotPool const & _rSlotPool, const OUString& _rUnoSlotName ) | |||
| 561 | { | |||
| 562 | const SfxSlot* pSlot = _rSlotPool.GetUnoSlot( _rUnoSlotName ); | |||
| 563 | if ( pSlot ) | |||
| 564 | { | |||
| 565 | // okay, there's a slot with the given UNO name | |||
| 566 | return lcl_translateConflictingSlot( pSlot->GetSlotId() ); | |||
| 567 | } | |||
| 568 | ||||
| 569 | // some hard-coded slots, which do not have a UNO name at SFX level, but which | |||
| 570 | // we nevertheless need to transport via UNO mechanisms, so we need a name | |||
| 571 | if ( _rUnoSlotName == "AllowHangingPunctuation" ) | |||
| 572 | return SID_ATTR_PARA_HANGPUNCTUATION( 10000 + 902 ); | |||
| 573 | if ( _rUnoSlotName == "ApplyForbiddenCharacterRules" ) | |||
| 574 | return SID_ATTR_PARA_FORBIDDEN_RULES( 10000 + 903 ); | |||
| 575 | if ( _rUnoSlotName == "UseScriptSpacing" ) | |||
| 576 | return SID_ATTR_PARA_SCRIPTSPACE( 10000 + 901 ); | |||
| 577 | ||||
| 578 | OSL_ENSURE( pSlot, "lcl_getSlotFromUnoName: unknown UNO slot name!" )do { if (true && (!(pSlot))) { sal_detail_logFormat(( SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/forms/source/richtext/richtextcontrol.cxx" ":" "578" ": "), "%s", "lcl_getSlotFromUnoName: unknown UNO slot name!" ); } } while (false); | |||
| 579 | return 0; | |||
| 580 | } | |||
| 581 | } | |||
| 582 | ||||
| 583 | ||||
| 584 | Reference< XDispatch > SAL_CALL ORichTextPeer::queryDispatch( const css::util::URL& _rURL, const OUString& /*_rTargetFrameName*/, sal_Int32 /*_nSearchFlags*/ ) | |||
| 585 | { | |||
| 586 | Reference< XDispatch > xReturn; | |||
| 587 | if ( !GetWindow() ) | |||
| 588 | { | |||
| 589 | OSL_FAIL( "ORichTextPeer::queryDispatch: already disposed?" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat ((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/forms/source/richtext/richtextcontrol.cxx" ":" "589" ": "), "%s", "ORichTextPeer::queryDispatch: already disposed?" ); } } while (false); | |||
| 590 | return xReturn; | |||
| 591 | } | |||
| 592 | ||||
| 593 | // is it a UNO slot? | |||
| 594 | OUString sUnoProtocolPrefix( ".uno:" ); | |||
| 595 | if ( _rURL.Complete.startsWith( sUnoProtocolPrefix ) ) | |||
| 596 | { | |||
| 597 | OUString sUnoSlotName = _rURL.Complete.copy( sUnoProtocolPrefix.getLength() ); | |||
| 598 | SfxSlotId nSlotId = lcl_getSlotFromUnoName( SfxSlotPool::GetSlotPool(), sUnoSlotName ); | |||
| 599 | if ( nSlotId > 0 ) | |||
| 600 | { | |||
| 601 | // do we already have a dispatcher for this? | |||
| 602 | AttributeDispatchers::const_iterator aDispatcherPos = m_aDispatchers.find( nSlotId ); | |||
| 603 | if ( aDispatcherPos == m_aDispatchers.end() ) | |||
| 604 | { | |||
| 605 | SingleAttributeDispatcher pDispatcher = implCreateDispatcher( nSlotId, _rURL ); | |||
| 606 | if ( pDispatcher.is() ) | |||
| 607 | { | |||
| 608 | aDispatcherPos = m_aDispatchers.emplace( nSlotId, pDispatcher ).first; | |||
| 609 | } | |||
| 610 | } | |||
| 611 | ||||
| 612 | if ( aDispatcherPos != m_aDispatchers.end() ) | |||
| 613 | xReturn = aDispatcherPos->second.get(); | |||
| 614 | } | |||
| 615 | } | |||
| 616 | ||||
| 617 | return xReturn; | |||
| 618 | } | |||
| 619 | ||||
| 620 | ||||
| 621 | Sequence< Reference< XDispatch > > SAL_CALL ORichTextPeer::queryDispatches( const Sequence< DispatchDescriptor >& _rRequests ) | |||
| 622 | { | |||
| 623 | Sequence< Reference< XDispatch > > aReturn( _rRequests.getLength() ); | |||
| 624 | Reference< XDispatch >* pReturn = aReturn.getArray(); | |||
| 625 | ||||
| 626 | const DispatchDescriptor* pRequest = _rRequests.getConstArray(); | |||
| 627 | const DispatchDescriptor* pRequestEnd = pRequest + _rRequests.getLength(); | |||
| 628 | for ( ; pRequest != pRequestEnd; ++pRequest, ++pReturn ) | |||
| 629 | { | |||
| 630 | *pReturn = queryDispatch( pRequest->FeatureURL, pRequest->FrameName, pRequest->SearchFlags ); | |||
| 631 | } | |||
| 632 | return aReturn; | |||
| 633 | } | |||
| 634 | ||||
| 635 | ||||
| 636 | void ORichTextPeer::onSelectionChanged() | |||
| 637 | { | |||
| 638 | AttributeDispatchers::iterator aDispatcherPos = m_aDispatchers.find( SID_COPY(5000 + 711) ); | |||
| 639 | if ( aDispatcherPos != m_aDispatchers.end() ) | |||
| 640 | aDispatcherPos->second->invalidate(); | |||
| 641 | ||||
| 642 | aDispatcherPos = m_aDispatchers.find( SID_CUT(5000 + 710) ); | |||
| 643 | if ( aDispatcherPos != m_aDispatchers.end() ) | |||
| 644 | aDispatcherPos->second->invalidate(); | |||
| 645 | } | |||
| 646 | ||||
| 647 | ||||
| 648 | } // namespace frm | |||
| 649 | ||||
| 650 | extern "C" SAL_DLLPUBLIC_EXPORT__attribute__ ((visibility("default"))) css::uno::XInterface* | |||
| 651 | com_sun_star_comp_form_ORichTextControl_get_implementation(css::uno::XComponentContext*, | |||
| 652 | css::uno::Sequence<css::uno::Any> const &) | |||
| 653 | { | |||
| 654 | return cppu::acquire(new frm::ORichTextControl()); | |||
| 655 | } | |||
| 656 | ||||
| 657 | /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |
| 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_VCLXWINDOW_HXX |
| 21 | #define INCLUDED_TOOLKIT_AWT_VCLXWINDOW_HXX |
| 22 | |
| 23 | #include <toolkit/dllapi.h> |
| 24 | #include <toolkit/awt/vclxdevice.hxx> |
| 25 | #include <vcl/window.hxx> |
| 26 | |
| 27 | #include <com/sun/star/awt/XWindow2.hpp> |
| 28 | #include <com/sun/star/awt/XVclWindowPeer.hpp> |
| 29 | #include <com/sun/star/awt/XLayoutConstrains.hpp> |
| 30 | #include <com/sun/star/awt/XView.hpp> |
| 31 | #include <com/sun/star/beans/XPropertySetInfo.hpp> |
| 32 | #include <com/sun/star/accessibility/XAccessible.hpp> |
| 33 | #include <com/sun/star/awt/XDockableWindow.hpp> |
| 34 | #include <com/sun/star/awt/XStyleSettingsSupplier.hpp> |
| 35 | |
| 36 | #include <comphelper/servicehelper.hxx> |
| 37 | #include <cppuhelper/implbase.hxx> |
| 38 | |
| 39 | #include <tools/gen.hxx> |
| 40 | #include <tools/link.hxx> |
| 41 | |
| 42 | #include <memory> |
| 43 | #include <vector> |
| 44 | #include <functional> |
| 45 | |
| 46 | namespace comphelper { class OInterfaceContainerHelper2; } |
| 47 | namespace com::sun::star::accessibility { class XAccessibleContext; } |
| 48 | |
| 49 | class VclWindowEvent; |
| 50 | |
| 51 | namespace toolkit |
| 52 | { |
| 53 | class IAccessibleFactory; |
| 54 | } |
| 55 | |
| 56 | |
| 57 | class UnoPropertyArrayHelper; |
| 58 | class VCLXWindowImpl; |
| 59 | typedef cppu::ImplInheritanceHelper< VCLXDevice, |
| 60 | css::awt::XWindow2, |
| 61 | css::awt::XVclWindowPeer, |
| 62 | css::awt::XLayoutConstrains, |
| 63 | css::awt::XView, |
| 64 | css::awt::XDockableWindow, |
| 65 | css::accessibility::XAccessible, |
| 66 | css::lang::XEventListener, |
| 67 | css::beans::XPropertySetInfo, |
| 68 | css::awt::XStyleSettingsSupplier |
| 69 | > VCLXWindow_Base; |
| 70 | |
| 71 | class TOOLKIT_DLLPUBLIC__attribute__ ((visibility("default"))) VCLXWindow : public VCLXWindow_Base |
| 72 | { |
| 73 | private: |
| 74 | std::unique_ptr<VCLXWindowImpl> mpImpl; |
| 75 | |
| 76 | UnoPropertyArrayHelper *GetPropHelper(); |
| 77 | |
| 78 | protected: |
| 79 | Size ImplCalcWindowSize( const Size& rOutSz ) const; |
| 80 | DECL_LINK(WindowEventListener, VclWindowEvent&, void )static void LinkStubWindowEventListener(void *, VclWindowEvent &); void WindowEventListener(VclWindowEvent&); |
| 81 | |
| 82 | virtual void ProcessWindowEvent( const VclWindowEvent& rVclWindowEvent ); |
| 83 | virtual css::uno::Reference< css::accessibility::XAccessibleContext > |
| 84 | CreateAccessibleContext(); |
| 85 | |
| 86 | void SetSynthesizingVCLEvent( bool b ); |
| 87 | bool IsSynthesizingVCLEvent() const; |
| 88 | |
| 89 | void SetSystemParent_Impl( const css::uno::Any& rHandle ); |
| 90 | |
| 91 | ::toolkit::IAccessibleFactory& getAccessibleFactory(); |
| 92 | |
| 93 | // helper ... |
| 94 | static void PushPropertyIds( std::vector< sal_uInt16 > &aIds, int nFirstId, ...); |
| 95 | // for use in controls/ |
| 96 | static void ImplGetPropertyIds( std::vector< sal_uInt16 > &aIds, |
| 97 | bool bWithDefaults = false ); |
| 98 | virtual void GetPropertyIds( std::vector< sal_uInt16 > &aIds ); |
| 99 | |
| 100 | ::comphelper::OInterfaceContainerHelper2& GetContainerListeners(); |
| 101 | ::comphelper::OInterfaceContainerHelper2& GetTopWindowListeners(); |
| 102 | |
| 103 | public: |
| 104 | typedef ::std::function<void ()> Callback; |
| 105 | |
| 106 | protected: |
| 107 | /** executes the given callback asynchronously |
| 108 | |
| 109 | At the moment the callback is called, the Solar Mutex is not locked. In particular, this implies that |
| 110 | you cannot rely on |this| not being disposed. However, you *can* rely on |this| being still alive (i.e. |
| 111 | having a ref count > 0). |
| 112 | |
| 113 | As a consequence, this can be used for doing listener notifications, using event multiplexers. Those multiplexers |
| 114 | care for the disposed state themself, and are alive as long as |this| is alive. |
| 115 | */ |
| 116 | void ImplExecuteAsyncWithoutSolarLock( |
| 117 | const Callback& i_callback |
| 118 | ); |
| 119 | |
| 120 | public: |
| 121 | VCLXWindow( bool bWithDefaultProps = false ); |
| 122 | virtual ~VCLXWindow() override; |
| 123 | |
| 124 | virtual void SetWindow( const VclPtr< vcl::Window > &pWindow ); |
| 125 | template< class derived_type > VclPtr< derived_type > GetAs() const { |
| 126 | return VclPtr< derived_type >( static_cast< derived_type * >( GetOutputDevice().get() ) ); } |
| 127 | template< class derived_type > VclPtr< derived_type > GetAsDynamic() const { |
| 128 | return VclPtr< derived_type >( dynamic_cast< derived_type * >( GetOutputDevice().get() ) ); } |
| 129 | VclPtr<vcl::Window> GetWindow() const { return GetAs<vcl::Window>(); } |
| 130 | |
| 131 | void suspendVclEventListening( ); |
| 132 | void resumeVclEventListening( ); |
| 133 | |
| 134 | void notifyWindowRemoved( vcl::Window const & _rWindow ); |
| 135 | |
| 136 | // css::lang::XUnoTunnel |
| 137 | UNO3_GETIMPLEMENTATION_DECL(VCLXWindow)static const css::uno::Sequence< sal_Int8 > & getUnoTunnelId () throw(); virtual sal_Int64 getSomething( const css::uno::Sequence < sal_Int8 >& aIdentifier ) override; |
| 138 | |
| 139 | // css::lang::XEventListener |
| 140 | virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) override; |
| 141 | |
| 142 | // css::lang::XComponent |
| 143 | void SAL_CALL dispose( ) override; |
| 144 | void SAL_CALL addEventListener( const css::uno::Reference< css::lang::XEventListener >& rxListener ) override; |
| 145 | void SAL_CALL removeEventListener( const css::uno::Reference< css::lang::XEventListener >& rxListener ) override; |
| 146 | |
| 147 | // css::awt::XWindow |
| 148 | void SAL_CALL setPosSize( sal_Int32 X, sal_Int32 Y, sal_Int32 Width, sal_Int32 Height, sal_Int16 Flags ) override; |
| 149 | css::awt::Rectangle SAL_CALL getPosSize( ) override; |
| 150 | void SAL_CALL setVisible( sal_Bool Visible ) override; |
| 151 | void SAL_CALL setEnable( sal_Bool Enable ) override; |
| 152 | void SAL_CALL setFocus( ) override; |
| 153 | void SAL_CALL addWindowListener( const css::uno::Reference< css::awt::XWindowListener >& rrxListener ) override; |
| 154 | void SAL_CALL removeWindowListener( const css::uno::Reference< css::awt::XWindowListener >& rrxListener ) override; |
| 155 | void SAL_CALL addFocusListener( const css::uno::Reference< css::awt::XFocusListener >& rrxListener ) override; |
| 156 | void SAL_CALL removeFocusListener( const css::uno::Reference< css::awt::XFocusListener >& rrxListener ) override; |
| 157 | void SAL_CALL addKeyListener( const css::uno::Reference< css::awt::XKeyListener >& rrxListener ) override; |
| 158 | void SAL_CALL removeKeyListener( const css::uno::Reference< css::awt::XKeyListener >& rrxListener ) override; |
| 159 | void SAL_CALL addMouseListener( const css::uno::Reference< css::awt::XMouseListener >& rrxListener ) override; |
| 160 | void SAL_CALL removeMouseListener( const css::uno::Reference< css::awt::XMouseListener >& rrxListener ) override; |
| 161 | void SAL_CALL addMouseMotionListener( const css::uno::Reference< css::awt::XMouseMotionListener >& rrxListener ) override; |
| 162 | void SAL_CALL removeMouseMotionListener( const css::uno::Reference< css::awt::XMouseMotionListener >& rrxListener ) override; |
| 163 | void SAL_CALL addPaintListener( const css::uno::Reference< css::awt::XPaintListener >& rrxListener ) override; |
| 164 | void SAL_CALL removePaintListener( const css::uno::Reference< css::awt::XPaintListener >& rrxListener ) override; |
| 165 | |
| 166 | // css::awt::XWindowPeer |
| 167 | css::uno::Reference< css::awt::XToolkit > SAL_CALL getToolkit( ) override; |
| 168 | void SAL_CALL setPointer( const css::uno::Reference< css::awt::XPointer >& Pointer ) override; |
| 169 | void SAL_CALL setBackground( sal_Int32 Color ) override; |
| 170 | void SAL_CALL invalidate( sal_Int16 Flags ) override; |
| 171 | void SAL_CALL invalidateRect( const css::awt::Rectangle& Rect, sal_Int16 Flags ) override; |
| 172 | |
| 173 | // css::awt::XVclWindowPeer |
| 174 | sal_Bool SAL_CALL isChild( const css::uno::Reference< css::awt::XWindowPeer >& Peer ) override; |
| 175 | void SAL_CALL setDesignMode( sal_Bool bOn ) override; |
| 176 | sal_Bool SAL_CALL isDesignMode( ) override; |
| 177 | void SAL_CALL enableClipSiblings( sal_Bool bClip ) override; |
| 178 | void SAL_CALL setForeground( sal_Int32 Color ) override; |
| 179 | void SAL_CALL setControlFont( const css::awt::FontDescriptor& aFont ) override; |
| 180 | void SAL_CALL getStyles( sal_Int16 nType, css::awt::FontDescriptor& Font, sal_Int32& ForegroundColor, sal_Int32& BackgroundColor ) override; |
| 181 | void SAL_CALL setProperty( const OUString& PropertyName, const css::uno::Any& Value ) override; |
| 182 | css::uno::Any SAL_CALL getProperty( const OUString& PropertyName ) override; |
| 183 | |
| 184 | // css::awt::XLayoutConstrains |
| 185 | css::awt::Size SAL_CALL getMinimumSize( ) override; |
| 186 | css::awt::Size SAL_CALL getPreferredSize( ) override; |
| 187 | css::awt::Size SAL_CALL calcAdjustedSize( const css::awt::Size& aNewSize ) override; |
| 188 | |
| 189 | // css::awt::XView |
| 190 | sal_Bool SAL_CALL setGraphics( const css::uno::Reference< css::awt::XGraphics >& aDevice ) override; |
| 191 | css::uno::Reference< css::awt::XGraphics > SAL_CALL getGraphics( ) override; |
| 192 | css::awt::Size SAL_CALL getSize( ) override; |
| 193 | void SAL_CALL draw( sal_Int32 nX, sal_Int32 nY ) override; |
| 194 | void SAL_CALL setZoom( float fZoomX, float fZoomY ) override; |
| 195 | |
| 196 | // css::accessibility::XAccessible |
| 197 | css::uno::Reference< css::accessibility::XAccessibleContext > SAL_CALL getAccessibleContext( ) override; |
| 198 | |
| 199 | // css::awt::XDockableWindow |
| 200 | void SAL_CALL addDockableWindowListener( const css::uno::Reference< css::awt::XDockableWindowListener >& xListener ) override; |
| 201 | void SAL_CALL removeDockableWindowListener( const css::uno::Reference< css::awt::XDockableWindowListener >& xListener ) override; |
| 202 | void SAL_CALL enableDocking( sal_Bool bEnable ) override; |
| 203 | sal_Bool SAL_CALL isFloating( ) override; |
| 204 | void SAL_CALL setFloatingMode( sal_Bool bFloating ) override; |
| 205 | void SAL_CALL lock( ) override; |
| 206 | void SAL_CALL unlock( ) override; |
| 207 | sal_Bool SAL_CALL isLocked( ) override; |
| 208 | void SAL_CALL startPopupMode( const css::awt::Rectangle& WindowRect ) override; |
| 209 | sal_Bool SAL_CALL isInPopupMode( ) override; |
| 210 | |
| 211 | // css::awt::XWindow2 |
| 212 | void SAL_CALL setOutputSize( const css::awt::Size& aSize ) override; |
| 213 | css::awt::Size SAL_CALL getOutputSize( ) override; |
| 214 | sal_Bool SAL_CALL isVisible( ) override; |
| 215 | sal_Bool SAL_CALL isActive( ) override; |
| 216 | sal_Bool SAL_CALL isEnabled( ) override; |
| 217 | sal_Bool SAL_CALL hasFocus( ) override; |
| 218 | |
| 219 | // css::beans::XPropertySetInfo |
| 220 | css::uno::Sequence< css::beans::Property > SAL_CALL getProperties( ) override; |
| 221 | css::beans::Property SAL_CALL getPropertyByName( const OUString& aName ) override; |
| 222 | sal_Bool SAL_CALL hasPropertyByName( const OUString& Name ) override; |
| 223 | |
| 224 | // XStyleSettingsSupplier |
| 225 | virtual css::uno::Reference< css::awt::XStyleSettings > SAL_CALL getStyleSettings() override; |
| 226 | }; |
| 227 | |
| 228 | #endif // INCLUDED_TOOLKIT_AWT_VCLXWINDOW_HXX |
| 229 | |
| 230 | /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |
| 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 | |
| 36 | class VclReferenceBase; |
| 37 | |
| 38 | namespace vcl::detail { |
| 39 | |
| 40 | template<typename> |
| 41 | constexpr bool isIncompleteOrDerivedFromVclReferenceBase(...) { return true; } |
| 42 | |
| 43 | template<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 | */ |
| 56 | template <class reference_type> |
| 57 | class 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 | |
| 66 | public: |
| 67 | /** Constructor... |
| 68 | */ |
| 69 | VclPtr() |
| 70 | : m_rInnerRef() |
| 71 | {} |
| 72 | |
| 73 | /** Constructor... |
| 74 | */ |
| 75 | VclPtr (reference_type * pBody) |
| 76 | : m_rInnerRef(pBody) |
| 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; |
| 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 | |
| 218 | template<typename T1, typename T2> |
| 219 | inline bool operator ==(VclPtr<T1> const & p1, VclPtr<T2> const & p2) { |
| 220 | return p1.get() == p2.get(); |
| 221 | } |
| 222 | |
| 223 | template<typename T> inline bool operator ==(VclPtr<T> const & p1, T const * p2) |
| 224 | { |
| 225 | return p1.get() == p2; |
| 226 | } |
| 227 | |
| 228 | template<typename T> inline bool operator ==(VclPtr<T> const & p1, T * p2) { |
| 229 | return p1.get() == p2; |
| 230 | } |
| 231 | |
| 232 | template<typename T> inline bool operator ==(T const * p1, VclPtr<T> const & p2) |
| 233 | { |
| 234 | return p1 == p2.get(); |
| 235 | } |
| 236 | |
| 237 | template<typename T> inline bool operator ==(T * p1, VclPtr<T> const & p2) { |
| 238 | return p1 == p2.get(); |
| 239 | } |
| 240 | |
| 241 | template<typename T1, typename T2> |
| 242 | inline bool operator !=(VclPtr<T1> const & p1, VclPtr<T2> const & p2) { |
| 243 | return !(p1 == p2); |
| 244 | } |
| 245 | |
| 246 | template<typename T> inline bool operator !=(VclPtr<T> const & p1, T const * p2) |
| 247 | { |
| 248 | return !(p1 == p2); |
| 249 | } |
| 250 | |
| 251 | template<typename T> inline bool operator !=(VclPtr<T> const & p1, T * p2) { |
| 252 | return !(p1 == p2); |
| 253 | } |
| 254 | |
| 255 | template<typename T> inline bool operator !=(T const * p1, VclPtr<T> const & p2) |
| 256 | { |
| 257 | return !(p1 == p2); |
| 258 | } |
| 259 | |
| 260 | template<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 | */ |
| 274 | template <class reference_type> |
| 275 | class SAL_WARN_UNUSED__attribute__((warn_unused)) VclPtrInstance final : public VclPtr<reference_type> |
| 276 | { |
| 277 | public: |
| 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 | |
| 290 | template <class reference_type> |
| 291 | class ScopedVclPtr : public VclPtr<reference_type> |
| 292 | { |
| 293 | public: |
| 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 | |
| 378 | private: |
| 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 | |
| 387 | protected: |
| 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 |
| 406 | template <class reference_type> |
| 407 | class SAL_WARN_UNUSED__attribute__((warn_unused)) ScopedVclPtrInstance final : public ScopedVclPtr<reference_type> |
| 408 | { |
| 409 | public: |
| 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 | |
| 421 | private: |
| 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: */ |
| 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 | |||||||||||
| 34 | namespace rtl | ||||||||||
| 35 | { | ||||||||||
| 36 | |||||||||||
| 37 | /** Template reference class for reference type. | ||||||||||
| 38 | */ | ||||||||||
| 39 | template <class reference_type> | ||||||||||
| 40 | class Reference | ||||||||||
| 41 | { | ||||||||||
| 42 | /** The <b>reference_type</b> body pointer. | ||||||||||
| 43 | */ | ||||||||||
| 44 | reference_type * m_pBody; | ||||||||||
| 45 | |||||||||||
| 46 | |||||||||||
| 47 | public: | ||||||||||
| 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) | ||||||||||
| 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
| ||||||||||
| 113 | m_pBody->release(); | ||||||||||
| 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; | ||||||||||
| 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 | ||||||||||
| 277 | namespace 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 | */ | ||||||||||
| 286 | template<typename T> | ||||||||||
| 287 | struct 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: */ |
| 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 | |
| 25 | class VCL_DLLPUBLIC__attribute__ ((visibility("default"))) VclReferenceBase |
| 26 | { |
| 27 | mutable oslInterlockedCount mnRefCnt; |
| 28 | |
| 29 | template<typename T> friend class VclPtr; |
| 30 | |
| 31 | public: |
| 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) |
| 40 | delete this; |
| 41 | } |
| 42 | #ifdef DBG_UTIL |
| 43 | #ifndef _WIN32 |
| 44 | sal_Int32 getRefCount() const { return mnRefCnt; } |
| 45 | #endif |
| 46 | #endif |
| 47 | |
| 48 | |
| 49 | private: |
| 50 | VclReferenceBase(const VclReferenceBase&) = delete; |
| 51 | VclReferenceBase& operator=(const VclReferenceBase&) = delete; |
| 52 | |
| 53 | bool mbDisposed : 1; |
| 54 | |
| 55 | protected: |
| 56 | VclReferenceBase(); |
| 57 | protected: |
| 58 | virtual ~VclReferenceBase(); |
| 59 | |
| 60 | protected: |
| 61 | virtual void dispose(); |
| 62 | |
| 63 | public: |
| 64 | void disposeOnce(); |
| 65 | bool isDisposed() const { return mbDisposed; } |
| 66 | |
| 67 | }; |
| 68 | #endif |