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

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

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name galbrws2.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 -isystem /usr/include/libxml2 -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 SVXCORE_DLLIMPLEMENTATION -D SYSTEM_LIBXML -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/epoxy/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/pdfium -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/pdfium/public -D COMPONENT_BUILD -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/i18n -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/icu/source/common -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/svx/inc -I /home/maarten/src/libreoffice/core/svx/source/inc -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/workdir/CustomTarget/officecfg/registry -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/normal -I /home/maarten/src/libreoffice/core/workdir/SdiTarget/svx/sdi -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/svx/source/gallery2/galbrws2.cxx

/home/maarten/src/libreoffice/core/svx/source/gallery2/galbrws2.cxx

→

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/


21#include <sot/formats.hxx>
22#include <vcl/commandevent.hxx>
23#include <vcl/event.hxx>
24#include <vcl/transfer.hxx>
25#include <vcl/virdev.hxx>
26#include <sfx2/bindings.hxx>
27#include <sfx2/viewfrm.hxx>
28#include <vcl/graphicfilter.hxx>
29#include <helpids.h>
30#include <svx/svxids.hrc>
31#include <galobj.hxx>
32#include <svx/gallery1.hxx>
33#include <svx/galtheme.hxx>
34#include <svx/galctrl.hxx>
35#include <svx/galmisc.hxx>
36#include <galbrws2.hxx>
37#include <vcl/svapp.hxx>
38#include <vcl/weld.hxx>
39#include <svx/svxdlg.hxx>
40#include <svx/galleryitem.hxx>
41#include <comphelper/processfactory.hxx>
42#include <com/sun/star/frame/FrameSearchFlag.hpp>
43#include <com/sun/star/frame/XDispatchProvider.hpp>
44#include <com/sun/star/frame/XFrame.hpp>
45#include <com/sun/star/gallery/GalleryItemType.hpp>
46#include <com/sun/star/graphic/XGraphic.hpp>
47#include <com/sun/star/lang/XComponent.hpp>
48#include <com/sun/star/style/GraphicLocation.hpp>
49#include <map>
50#include <memory>
51#include <cppuhelper/implbase.hxx>

53GalleryBrowserMode GalleryBrowser2::meInitMode = GALLERYBROWSERMODE_ICON;

55struct DispatchInfo
56{
  css::util::URL                                  TargetURL;
  css::uno::Sequence< css::beans::PropertyValue > Arguments;
  css::uno::Reference< css::frame::XDispatch >    Dispatch;
60};

62IMPL_STATIC_LINK( GalleryBrowser2, AsyncDispatch_Impl, void*, p, void )void GalleryBrowser2::LinkStubAsyncDispatch_Impl(void * instance
, void* data) { return AsyncDispatch_Impl(static_cast<GalleryBrowser2
 *>(instance), data); } void GalleryBrowser2::AsyncDispatch_Impl
(__attribute__ ((unused)) GalleryBrowser2 *, void* p)
63{
  DispatchInfo* pDispatchInfo = static_cast<DispatchInfo*>(p);
  if ( pDispatchInfo && pDispatchInfo->Dispatch.is() )
  {
      try
      {
          pDispatchInfo->Dispatch->dispatch( pDispatchInfo->TargetURL,
                                             pDispatchInfo->Arguments );
      }
      catch ( const css::uno::Exception& )
      {
      }
  }

  delete pDispatchInfo;
78}

80namespace
81{

83struct CommandInfo
84{
  css::util::URL                               URL;
  css::uno::Reference< css::frame::XDispatch > Dispatch;

  explicit CommandInfo( const OUString &rURL )
  {
      URL.Complete = rURL;
  }
92};

94class GalleryThemePopup : public ::cppu::WeakImplHelper< css::frame::XStatusListener >
95{
96private:
  const GalleryTheme* mpTheme;
  sal_uInt32          mnObjectPos;
  bool                mbPreview;
  std::unique_ptr<weld::Builder> mxBuilder;
  std::unique_ptr<weld::Menu> mxPopupMenu;
  std::unique_ptr<weld::Menu> mxBackgroundPopup;
  GalleryBrowser2*  mpBrowser;

  typedef std::map< int, CommandInfo > CommandInfoMap;
  CommandInfoMap   m_aCommandInfo;

  static void Execute( const CommandInfo &rCmdInfo,
                const css::uno::Sequence< css::beans::PropertyValue > &rArguments );

  void MenuSelectHdl(const OString& rIdent);
  void BackgroundMenuSelectHdl(sal_uInt16 nId);
113public:
  GalleryThemePopup(weld::Widget* pParent,
                    const GalleryTheme* pTheme,
                    sal_uInt32 nObjectPos,
                    bool bPreview,
                    GalleryBrowser2* pBrowser);

  void ExecutePopup(weld::Widget* pParent, const ::Point &rPos);

  virtual void SAL_CALL statusChanged( const css::frame::FeatureStateEvent &rEvent) override;
  virtual void SAL_CALL disposing( const css::lang::EventObject &rSource) override;
124};


127GalleryThemePopup::GalleryThemePopup(
  weld::Widget* pParent,
  const GalleryTheme* pTheme,
  sal_uInt32 nObjectPos,
  bool bPreview,
  GalleryBrowser2* pBrowser )
  : mpTheme( pTheme )
  , mnObjectPos( nObjectPos )
  , mbPreview( bPreview )
  , mxBuilder(Application::CreateBuilder(pParent, "svx/ui/gallerymenu2.ui"))
  , mxPopupMenu(mxBuilder->weld_menu("menu"))
  , mxBackgroundPopup(mxBuilder->weld_menu("backgroundmenu"))
  , mpBrowser( pBrowser )
140{
  // SID_GALLERY_ENABLE_ADDCOPY
  m_aCommandInfo.emplace(
          SID_GALLERY_ENABLE_ADDCOPY( 10000 + 276 ),
          CommandInfo( ".uno:GalleryEnableAddCopy" ));
  // SID_GALLERY_BG_BRUSH
  m_aCommandInfo.emplace(
          SID_GALLERY_BG_BRUSH(10000 + 279),
          CommandInfo( ".uno:BackgroundImage" ));
  // SID_GALLERY_FORMATS
  m_aCommandInfo.emplace(
          SID_GALLERY_FORMATS( 10000 + 280 ),
          CommandInfo( ".uno:InsertGalleryPic" ));

154}

156void SAL_CALL GalleryThemePopup::statusChanged(
  const css::frame::FeatureStateEvent &rEvent )
158{
  const OUString &rURL = rEvent.FeatureURL.Complete;
  if ( rURL == ".uno:GalleryEnableAddCopy" )
  {
      if ( !rEvent.IsEnabled )
      {
          mxPopupMenu->set_visible("add", false);
      }
  }
  else if ( rURL == ".uno:BackgroundImage" )
  {
      mxBackgroundPopup->clear();
      if ( rEvent.IsEnabled )
      {
          OUString sItem;
          css::uno::Sequence< OUString > sItems;
          if ( ( rEvent.State >>= sItem ) && sItem.getLength() )
          {
              mxBackgroundPopup->append(OUString::number(1), sItem);
          }
          else if ( ( rEvent.State >>= sItems ) && sItems.hasElements() )
          {
              sal_uInt16 nId = 1;
              for ( const OUString& rStr : std::as_const(sItems) )
              {
                  mxBackgroundPopup->append(OUString::number(nId), rStr);
                  nId++;
              }
          }
      }
  }
189}

191void SAL_CALL GalleryThemePopup::disposing(
  const css::lang::EventObject &/*rSource*/)
193{
194}

196void GalleryThemePopup::Execute(
  const CommandInfo &rCmdInfo,
  const css::uno::Sequence< css::beans::PropertyValue > &rArguments )
199{
  if ( rCmdInfo.Dispatch.is() )
  {
      std::unique_ptr<DispatchInfo> pInfo(new DispatchInfo);
      pInfo->TargetURL = rCmdInfo.URL;
      pInfo->Arguments = rArguments;
      pInfo->Dispatch = rCmdInfo.Dispatch;

      if ( Application::PostUserEvent(
              LINK( nullptr, GalleryBrowser2, AsyncDispatch_Impl)::tools::detail::makeLink( ::tools::detail::castTo<GalleryBrowser2
 *>(nullptr), &GalleryBrowser2::LinkStubAsyncDispatch_Impl
), pInfo.get() ) )
          pInfo.release();
  }
211}

213void GalleryThemePopup::ExecutePopup(weld::Widget* pParent, const ::Point &rPos)
214{
  css::uno::Reference< css::frame::XStatusListener > xThis( this );

  const SgaObjKind eObjKind = mpTheme->GetObjectKind( mnObjectPos );
  INetURLObject    aURL;

  const_cast< GalleryTheme* >( mpTheme )->GetURL( mnObjectPos, aURL );
  const bool bValidURL = ( aURL.GetProtocol() != INetProtocol::NotValid );

  mxPopupMenu->set_visible("add", bValidURL && SgaObjKind::Sound != eObjKind);

  mxPopupMenu->set_visible("preview", bValidURL);
  mxPopupMenu->set_active("preview", mbPreview);

  if( mpTheme->IsReadOnly() || !mpTheme->GetObjectCount() )
  {
      mxPopupMenu->set_visible("delete", false);
      mxPopupMenu->set_visible("title", false);
      if (mpTheme->IsReadOnly())
          mxPopupMenu->set_visible("paste", false);

      if (!mpTheme->GetObjectCount())
          mxPopupMenu->set_visible("copy", false);
  }
  else
  {
      mxPopupMenu->set_visible("delete", !mbPreview);
      mxPopupMenu->set_visible("title", true);
      mxPopupMenu->set_visible("copy", true);
      mxPopupMenu->set_visible("paste", true);
  }

  // update status
  css::uno::Reference< css::frame::XDispatchProvider> xDispatchProvider(
      GalleryBrowser2::GetFrame(), css::uno::UNO_QUERY );
  css::uno::Reference< css::util::XURLTransformer > xTransformer(
      mpBrowser->GetURLTransformer() );
  for ( auto& rInfo : m_aCommandInfo )
  {
      try
      {
          CommandInfo &rCmdInfo = rInfo.second;
          if ( xTransformer.is() )
              xTransformer->parseStrict( rCmdInfo.URL );

          if ( xDispatchProvider.is() )
          {
              rCmdInfo.Dispatch = xDispatchProvider->queryDispatch(
                  rCmdInfo.URL,
                  "_self",
                  css::frame::FrameSearchFlag::SELF );
          }

          if ( rCmdInfo.Dispatch.is() )
          {
              rCmdInfo.Dispatch->addStatusListener( this, rCmdInfo.URL );
              rCmdInfo.Dispatch->removeStatusListener( this, rCmdInfo.URL );
          }
      }
      catch ( ... )
      {}
  }

  if( !mxBackgroundPopup->n_children() || ( eObjKind == SgaObjKind::SvDraw ) || ( eObjKind == SgaObjKind::Sound ) )
      mxPopupMenu->set_visible("background", false);
  else
      mxPopupMenu->set_visible("background", true);

  MenuSelectHdl(mxPopupMenu->popup_at_rect(pParent, tools::Rectangle(rPos, Size(1,1))));
283}

285void GalleryThemePopup::MenuSelectHdl(const OString& rIdent)
286{
  if (rIdent.isEmpty())
      return;

  sal_uInt16 nSubMenuId = rIdent.toUInt32();
  if (nSubMenuId)
  {
      BackgroundMenuSelectHdl(nSubMenuId-1);
      return;
  }

  if (rIdent == "add")
  {
      const CommandInfoMap::const_iterator it = m_aCommandInfo.find( SID_GALLERY_FORMATS( 10000 + 280 ) );
      if (it != m_aCommandInfo.end())
          mpBrowser->DispatchAdd(it->second.Dispatch, it->second.URL);
  }
  else
      mpBrowser->Execute(rIdent);
305}

307void GalleryThemePopup::BackgroundMenuSelectHdl(sal_uInt16 nPos)
308{
  OUString aURL( mpBrowser->GetURL().GetMainURL( INetURLObject::DecodeMechanism::NONE ) );
  OUString aFilterName( mpBrowser->GetFilterName() );

  css::uno::Sequence< css::beans::PropertyValue > aArgs( 6 );
  aArgs[0].Name = "Background.Transparent";
  aArgs[0].Value <<= sal_Int32( 0 ); // 0 - 100
  aArgs[1].Name = "Background.BackColor";
  aArgs[1].Value <<= sal_Int32( - 1 );
  aArgs[2].Name = "Background.URL";
  aArgs[2].Value <<= aURL;
  aArgs[3].Name = "Background.Filtername"; // FIXME should be FilterName
  aArgs[3].Value <<= aFilterName;
  aArgs[4].Name = "Background.Position";
  aArgs[4].Value <<= css::style::GraphicLocation_TILED;
  aArgs[5].Name = "Position";
  aArgs[5].Value <<= nPos;

  const CommandInfoMap::const_iterator it = m_aCommandInfo.find( SID_GALLERY_BG_BRUSH(10000 + 279) );
  if ( it != m_aCommandInfo.end() )
      Execute( it->second, aArgs );
329}

331} // end anonymous namespace

333GalleryBrowser2::GalleryBrowser2(weld::Builder& rBuilder, Gallery* pGallery)
  : mpGallery(pGallery)
  , mpCurTheme(nullptr)
  , mxIconView(new GalleryIconView(this, rBuilder.weld_scrolled_window("galleryscroll", true)))
  , mxIconViewWin(new weld::CustomWeld(rBuilder, "gallery", *mxIconView))
  , mxListView(rBuilder.weld_tree_view("gallerylist"))
  , mxPreview(new GalleryPreview(this, rBuilder.weld_scrolled_window("previewscroll")))
  , mxPreviewWin(new weld::CustomWeld(rBuilder, "preview", *mxPreview))
  , mxIconButton(rBuilder.weld_toggle_button("icon"))
  , mxListButton(rBuilder.weld_toggle_button("list"))
  , mxInfoBar(rBuilder.weld_label("label"))
  , mxDev(mxListView->create_virtual_device())
  , maPreviewSize(28, 28)
  , mnCurActionPos      ( 0xffffffff )
  , meMode              ( GALLERYBROWSERMODE_NONE )
  , meLastMode          ( GALLERYBROWSERMODE_NONE )
349{
  mxDev->SetOutputSizePixel(maPreviewSize);

  m_xContext.set( ::comphelper::getProcessComponentContext() );

  int nHeight = mxListView->get_height_rows(10);
  mxListView->set_size_request(-1, nHeight);
  mxIconView->set_size_request(-1, nHeight);

  m_xTransformer.set(
      m_xContext->getServiceManager()->createInstanceWithContext(
          "com.sun.star.util.URLTransformer", m_xContext ),
      css::uno::UNO_QUERY );

  mxIconButton->set_help_id(HID_GALLERY_ICONVIEW"SVX_HID_GALLERY_ICONVIEW");
  mxListButton->set_help_id(HID_GALLERY_LISTVIEW"SVX_HID_GALLERY_LISTVIEW");

  mxIconButton->connect_toggled( LINK( this, GalleryBrowser2, SelectTbxHdl )::tools::detail::makeLink( ::tools::detail::castTo<GalleryBrowser2
 *>(this), &GalleryBrowser2::LinkStubSelectTbxHdl) );
  mxListButton->connect_toggled( LINK( this, GalleryBrowser2, SelectTbxHdl )::tools::detail::makeLink( ::tools::detail::castTo<GalleryBrowser2
 *>(this), &GalleryBrowser2::LinkStubSelectTbxHdl) );

  mxIconView->SetSelectHdl( LINK( this, GalleryBrowser2, SelectObjectValueSetHdl )::tools::detail::makeLink( ::tools::detail::castTo<GalleryBrowser2
 *>(this), &GalleryBrowser2::LinkStubSelectObjectValueSetHdl
) );
  mxListView->connect_visible_range_changed(LINK(this, GalleryBrowser2, VisRowsScrolledHdl)::tools::detail::makeLink( ::tools::detail::castTo<GalleryBrowser2
 *>(this), &GalleryBrowser2::LinkStubVisRowsScrolledHdl
));
  mxListView->connect_size_allocate(LINK(this, GalleryBrowser2, SizeAllocHdl)::tools::detail::makeLink( ::tools::detail::castTo<GalleryBrowser2
 *>(this), &GalleryBrowser2::LinkStubSizeAllocHdl));
  mxListView->connect_changed( LINK( this, GalleryBrowser2, SelectObjectHdl )::tools::detail::makeLink( ::tools::detail::castTo<GalleryBrowser2
 *>(this), &GalleryBrowser2::LinkStubSelectObjectHdl) );
  mxListView->connect_popup_menu(LINK(this, GalleryBrowser2, PopupMenuHdl)::tools::detail::makeLink( ::tools::detail::castTo<GalleryBrowser2
 *>(this), &GalleryBrowser2::LinkStubPopupMenuHdl));
  mxListView->connect_key_press(LINK(this, GalleryBrowser2, KeyInputHdl)::tools::detail::makeLink( ::tools::detail::castTo<GalleryBrowser2
 *>(this), &GalleryBrowser2::LinkStubKeyInputHdl));
  mxListView->connect_row_activated(LINK(this, GalleryBrowser2, RowActivatedHdl)::tools::detail::makeLink( ::tools::detail::castTo<GalleryBrowser2
 *>(this), &GalleryBrowser2::LinkStubRowActivatedHdl));
  mxDragDropTargetHelper.reset(new GalleryDragDrop(this, mxListView->get_drop_target()));
  mxListView->connect_drag_begin(LINK(this, GalleryBrowser2, DragBeginHdl)::tools::detail::makeLink( ::tools::detail::castTo<GalleryBrowser2
 *>(this), &GalleryBrowser2::LinkStubDragBeginHdl));

  mxListView->set_help_id(HID_GALLERY_WINDOW"SVX_HID_GALLERY_WINDOW");

  SetMode( ( GALLERYBROWSERMODE_PREVIEW != GalleryBrowser2::meInitMode ) ? GalleryBrowser2::meInitMode : GALLERYBROWSERMODE_ICON );
382}

384IMPL_LINK(GalleryBrowser2, PopupMenuHdl, const CommandEvent&, rCEvt, bool)bool GalleryBrowser2::LinkStubPopupMenuHdl(void * instance, const
 CommandEvent& data) { return static_cast<GalleryBrowser2
 *>(instance)->PopupMenuHdl(data); } bool GalleryBrowser2
::PopupMenuHdl(const CommandEvent& rCEvt)
385{
  if (rCEvt.GetCommand() != CommandEventId::ContextMenu)
      return false;
  ShowContextMenu(rCEvt);
  return true;
390}

392IMPL_LINK(GalleryBrowser2, KeyInputHdl, const KeyEvent&, rKEvt, bool)bool GalleryBrowser2::LinkStubKeyInputHdl(void * instance, const
 KeyEvent& data) { return static_cast<GalleryBrowser2 *
>(instance)->KeyInputHdl(data); } bool GalleryBrowser2::
KeyInputHdl(const KeyEvent& rKEvt)
1
Calling 'GalleryBrowser2::KeyInputHdl'→
393{
  return KeyInput(rKEvt);
2
←
Calling 'GalleryBrowser2::KeyInput'→
395}

397IMPL_LINK_NOARG(GalleryBrowser2, RowActivatedHdl, weld::TreeView&, bool)bool GalleryBrowser2::LinkStubRowActivatedHdl(void * instance
, weld::TreeView& data) { return static_cast<GalleryBrowser2
 *>(instance)->RowActivatedHdl(data); } bool GalleryBrowser2
::RowActivatedHdl(__attribute__ ((unused)) weld::TreeView&
)
398{
  TogglePreview();
  return true;
401}

403GalleryBrowser2::~GalleryBrowser2()
404{
  if (mpCurTheme)
      mpGallery->ReleaseTheme( mpCurTheme, *this );
407}

409void GalleryBrowser2::Notify( SfxBroadcaster&, const SfxHint& rHint )
410{
  const GalleryHint& rGalleryHint = static_cast<const GalleryHint&>(rHint);

  switch( rGalleryHint.GetType() )
  {
      case GalleryHintType::THEME_UPDATEVIEW:
      {
          if( GALLERYBROWSERMODE_PREVIEW == GetMode() )
              SetMode( meLastMode );

          ImplUpdateViews( reinterpret_cast<size_t>(rGalleryHint.GetData1()) + 1 );
      }
      break;

      default:
      break;
  }
427}

429sal_Int8 GalleryBrowser2::AcceptDrop( const DropTargetHelper& rTarget )
430{
  sal_Int8 nRet = DND_ACTION_NONEcss::datatransfer::dnd::DNDConstants::ACTION_NONE;

  if( mpCurTheme && !mpCurTheme->IsReadOnly() )
  {
      if( !mpCurTheme->IsDragging() )
      {
          if( rTarget.IsDropFormatSupported( SotClipboardFormatId::DRAWING ) ||
              rTarget.IsDropFormatSupported( SotClipboardFormatId::FILE_LIST ) ||
              rTarget.IsDropFormatSupported( SotClipboardFormatId::SIMPLE_FILE ) ||
              rTarget.IsDropFormatSupported( SotClipboardFormatId::SVXB ) ||
              rTarget.IsDropFormatSupported( SotClipboardFormatId::GDIMETAFILE ) ||
              rTarget.IsDropFormatSupported( SotClipboardFormatId::BITMAP ) )
          {
              nRet = DND_ACTION_COPYcss::datatransfer::dnd::DNDConstants::ACTION_COPY;
          }
      }
      else
          nRet = DND_ACTION_COPYcss::datatransfer::dnd::DNDConstants::ACTION_COPY;
  }

  return nRet;
452}

454sal_Int8 GalleryBrowser2::ExecuteDrop( const ExecuteDropEvent& rEvt )
455{
  sal_Int8 nRet = DND_ACTION_NONEcss::datatransfer::dnd::DNDConstants::ACTION_NONE;

  if( mpCurTheme )
  {
      Point aSelPos;
      const sal_uInt32 nItemId = ImplGetSelectedItemId( &rEvt.maPosPixel, aSelPos );
      const sal_uInt32 nInsertPos = (nItemId ? (nItemId - 1) : mpCurTheme->GetObjectCount());

      if( mpCurTheme->IsDragging() )
          mpCurTheme->ChangeObjectPos( mpCurTheme->GetDragPos(), nInsertPos );
      else
          nRet = mpCurTheme->InsertTransferable( rEvt.maDropEvent.Transferable, nInsertPos ) ? 1 : 0;
  }

  return nRet;
471}

473bool GalleryBrowser2::StartDrag()
474{
  if (!mpCurTheme)
      return true;
  return m_xHelper->StartDrag();
478}

480IMPL_LINK(GalleryBrowser2, DragBeginHdl, bool&, rUnsetDragIcon, bool)bool GalleryBrowser2::LinkStubDragBeginHdl(void * instance, bool
& data) { return static_cast<GalleryBrowser2 *>(instance
)->DragBeginHdl(data); } bool GalleryBrowser2::DragBeginHdl
(bool& rUnsetDragIcon)
481{
  rUnsetDragIcon = false;
  return StartDrag();
484}

486void GalleryBrowser2::TogglePreview()
487{
  SetMode( ( GALLERYBROWSERMODE_PREVIEW != GetMode() ) ? GALLERYBROWSERMODE_PREVIEW : meLastMode );
  GetViewWindow()->grab_focus();
490}

492void GalleryBrowser2::ShowContextMenu(const CommandEvent& rCEvt)
493{
  Point aMousePos = rCEvt.GetMousePosPixel();
  Point aSelPos;
  const sal_uInt32 nItemId = ImplGetSelectedItemId( rCEvt.IsMouseEvent() ? &aMousePos : nullptr, aSelPos );

  if( !(mpCurTheme && nItemId && ( nItemId <= mpCurTheme->GetObjectCount() )) )
      return;

  ImplSelectItemId( nItemId );

  css::uno::Reference< css::frame::XFrame > xFrame( GetFrame() );
  if ( !xFrame.is() )
      return;

  weld::Widget* pParent = GetViewWindow();
  mnCurActionPos = nItemId - 1;
  rtl::Reference< GalleryThemePopup > xPopup(
      new GalleryThemePopup(
          pParent,
          mpCurTheme,
          mnCurActionPos,
          GALLERYBROWSERMODE_PREVIEW == GetMode(),
          this ) );
  xPopup->ExecutePopup(pParent, aSelPos);
517}

519bool GalleryBrowser2::ViewBoxHasFocus() const
520{
  return mxIconButton->has_focus() || mxListButton->has_focus();
522}

524bool GalleryBrowser2::KeyInput(const KeyEvent& rKEvt)
525{
  Point       aSelPos;
  const sal_uInt32 nItemId = ImplGetSelectedItemId( nullptr, aSelPos );
  bool bRet = false;

  if (!ViewBoxHasFocus() && nItemId3.1
'nItemId' is not equal to 0
1
'nItemId' is not equal to 0
1
'nItemId' is not equal to 0
1
'nItemId' is not equal to 0
 && mpCurTheme3.2
Field 'mpCurTheme' is non-null
2
Field 'mpCurTheme' is non-null
2
Field 'mpCurTheme' is non-null
2
Field 'mpCurTheme' is non-null
)
3
←
Assuming the condition is true→
4
←
Taking true branch→
  {
      OString sExecuteIdent;
      INetURLObject       aURL;

      mpCurTheme->GetURL( nItemId - 1, aURL );

      const bool  bValidURL = ( aURL.GetProtocol() != INetProtocol::NotValid );
5
←
Assuming the condition is true→
      bool        bPreview = bValidURL;
      bool        bDelete = false;
      bool        bTitle = false;

      if( !mpCurTheme->IsReadOnly() && mpCurTheme->GetObjectCount() )
6
←
Assuming the condition is false→
      {
          bDelete = ( GALLERYBROWSERMODE_PREVIEW != GetMode() );
          bTitle = true;
      }

      switch( rKEvt.GetKeyCode().GetCode() )
7
←
Control jumps to the 'default' case at line 589→
      {
          case KEY_SPACE:
          case KEY_RETURN:
          case KEY_P:
          {
              if( bPreview )
              {
                  TogglePreview();
                  bRet = true;
              }
          }
          break;

          case KEY_INSERT:
          case KEY_I:
          {
              // Inserting a gallery item in the document must be dispatched
              if( bValidURL )
              {
                  DispatchAdd(css::uno::Reference<css::frame::XDispatch>(), css::util::URL());
                  return true;
              }
          }
          break;

          case KEY_DELETE:
          case KEY_D:
          {
              if( bDelete )
                  sExecuteIdent = "delete";
          }
          break;

          case KEY_T:
          {
              if( bTitle )
                  sExecuteIdent = "title";
          }
          break;

          default:
          break;
8
←
 Execution continues on line 593→
      }

      if (!sExecuteIdent.isEmpty())
9
←
Taking true branch→
      {
          Execute(sExecuteIdent);
10
←
Calling 'GalleryBrowser2::Execute'→
          bRet = true;
      }
  }

  return bRet;
601}

603void GalleryBrowser2::SelectTheme( const OUString& rThemeName )
604{
  if( mpCurTheme )
      mpGallery->ReleaseTheme( mpCurTheme, *this );

  mpCurTheme = mpGallery->AcquireTheme( rThemeName, *this );

  m_xHelper.set(new GalleryTransferable(mpCurTheme, 0, true));
  rtl::Reference<TransferDataContainer> xHelper(m_xHelper.get());
  mxListView->enable_drag_source(xHelper, DND_ACTION_COPYcss::datatransfer::dnd::DNDConstants::ACTION_COPY | DND_ACTION_LINKcss::datatransfer::dnd::DNDConstants::ACTION_LINK);
  mxIconView->SetDragDataTransferrable(xHelper, DND_ACTION_COPYcss::datatransfer::dnd::DNDConstants::ACTION_COPY | DND_ACTION_LINKcss::datatransfer::dnd::DNDConstants::ACTION_LINK);
  mxPreview->SetDragDataTransferrable(xHelper, DND_ACTION_COPYcss::datatransfer::dnd::DNDConstants::ACTION_COPY | DND_ACTION_LINKcss::datatransfer::dnd::DNDConstants::ACTION_LINK);

  mxIconView->SetTheme(mpCurTheme);
  mxPreview->SetTheme(mpCurTheme);

  if( GALLERYBROWSERMODE_PREVIEW == GetMode() )
      meMode = meLastMode;

  ImplUpdateViews( 1 );

  bool bIconMode = (GALLERYBROWSERMODE_ICON == GetMode());
  mxIconButton->set_sensitive(true);
  mxListButton->set_sensitive(true);
  mxIconButton->set_active(bIconMode);
  mxListButton->set_active(!bIconMode);
629}

631void GalleryBrowser2::SetMode( GalleryBrowserMode eMode )
632{
  if( GetMode() == eMode )
      return;

  meLastMode = GetMode();

  switch( eMode )
  {
      case GALLERYBROWSERMODE_ICON:
      {
          mxListView->hide();

          mxPreview->Hide();
          mxPreview->SetGraphic( Graphic() );
          GalleryPreview::PreviewMedia( INetURLObject() );

          mxIconView->Show();

          mxIconButton->set_sensitive(true);
          mxListButton->set_sensitive(true);

          mxIconButton->set_active(true);
          mxListButton->set_active(false);
      }
      break;

      case GALLERYBROWSERMODE_LIST:
      {
          mxIconView->Hide();

          mxPreview->Hide();
          mxPreview->SetGraphic( Graphic() );
          GalleryPreview::PreviewMedia( INetURLObject() );

          mxListView->show();
          UpdateRows(true);

          mxIconButton->set_sensitive(true);
          mxListButton->set_sensitive(true);

          mxIconButton->set_active(false);
          mxListButton->set_active(true);
      }
      break;

      case GALLERYBROWSERMODE_PREVIEW:
      {
          Graphic     aGraphic;
          Point       aSelPos;
          const sal_uInt32 nItemId = ImplGetSelectedItemId( nullptr, aSelPos );

          if( nItemId )
          {
              const sal_uInt32 nPos = nItemId - 1;

              mxIconView->Hide();
              mxListView->hide();

              if( mpCurTheme )
                  mpCurTheme->GetGraphic( nPos, aGraphic );

              mxPreview->SetGraphic( aGraphic );
              mxPreview->Show();

              if( mpCurTheme && mpCurTheme->GetObjectKind( nPos ) == SgaObjKind::Sound )
                  GalleryPreview::PreviewMedia( mpCurTheme->GetObjectURL( nPos ) );

              mxIconButton->set_sensitive(false);
              mxListButton->set_sensitive(false);
          }
      }
      break;

      default:
          break;
  }

  GalleryBrowser2::meInitMode = meMode = eMode;
710}

712weld::Widget* GalleryBrowser2::GetViewWindow() const
713{
  weld::Widget* pRet;

  switch( GetMode() )
  {
      case GALLERYBROWSERMODE_LIST: pRet = mxListView.get(); break;
      case GALLERYBROWSERMODE_PREVIEW: pRet = mxPreview->GetDrawingArea(); break;

      default:
          pRet = mxIconView->GetDrawingArea();
      break;
  }

  return pRet;
727}

729void GalleryBrowser2::Travel( GalleryBrowserTravel eTravel )
730{
  if( !mpCurTheme )
      return;

  Point       aSelPos;
  const sal_uInt32 nItemId = ImplGetSelectedItemId( nullptr, aSelPos );

  if( !nItemId )
      return;

  sal_uInt32 nNewItemId = nItemId;

  switch( eTravel )
  {
      case GalleryBrowserTravel::First:     nNewItemId = 1; break;
      case GalleryBrowserTravel::Last:      nNewItemId = mpCurTheme->GetObjectCount(); break;
      case GalleryBrowserTravel::Previous:  nNewItemId--; break;
      case GalleryBrowserTravel::Next:      nNewItemId++; break;
      default:
          break;
  }

  if( nNewItemId < 1 )
      nNewItemId = 1;
  else if( nNewItemId > mpCurTheme->GetObjectCount() )
      nNewItemId = mpCurTheme->GetObjectCount();

  if( nNewItemId == nItemId )
      return;

  ImplSelectItemId( nNewItemId );
  ImplUpdateInfoBar();

  if( GALLERYBROWSERMODE_PREVIEW != GetMode() )
      return;

  Graphic     aGraphic;
  const sal_uInt32 nPos = nNewItemId - 1;

  mpCurTheme->GetGraphic( nPos, aGraphic );
  mxPreview->SetGraphic( aGraphic );

  if( SgaObjKind::Sound == mpCurTheme->GetObjectKind( nPos ) )
      GalleryPreview::PreviewMedia( mpCurTheme->GetObjectURL( nPos ) );

  mxPreview->Invalidate();
776}

778void GalleryBrowser2::ImplUpdateViews( sal_uInt16 nSelectionId )
779{
  mxIconView->Hide();
  mxListView->hide();
  mxPreview->Hide();

  mxIconView->Clear();
  mxListView->clear();

  if( mpCurTheme )
  {
      const int nAlwaysUpToDate = 15;

      mxListView->freeze();

      sal_uInt32 nCount = mpCurTheme->GetObjectCount();
      for (sal_uInt32 i = 0; i < nCount; ++i)
      {
          mxIconView->InsertItem(i + 1); // skip reserved id 0
          mxListView->append(OUString::number(i), ""); // create on-demand in VisRowsScrolledHdl

          if (i == nAlwaysUpToDate) // fill in the first block
              UpdateRows(false);
      }

      if (nCount < nAlwaysUpToDate) // if less than block size, fill in all of them
          UpdateRows(false);

      mxListView->thaw();

      ImplSelectItemId( std::min<sal_uInt16>( nSelectionId, mpCurTheme->GetObjectCount() ) );
  }

  switch( GetMode() )
  {
      case GALLERYBROWSERMODE_ICON: mxIconView->Show(); break;
      case GALLERYBROWSERMODE_LIST:
          mxListView->show();
          UpdateRows(true);
          break;
      case GALLERYBROWSERMODE_PREVIEW: mxPreview->Show(); break;

      default:
      break;
  }

  ImplUpdateInfoBar();
825}

827void GalleryBrowser2::UpdateRows(bool bVisibleOnly)
828{
  auto lambda = [this](weld::TreeIter& rEntry){
      // id is non-null if the preview is pending creation
      OUString sId(mxListView->get_id(rEntry));
      if (sId.isEmpty())
          return false;

      // get the icon for the listview
      BitmapEx aBitmapEx;
      Size aPreparedSize;

      OUString sItemTextTitle;
      OUString sItemTextPath;

      sal_Int32 i = sId.toUInt32();
      mpCurTheme->GetPreviewBitmapExAndStrings(i, aBitmapEx, aPreparedSize, sItemTextTitle, sItemTextPath);

      bool bNeedToCreate(aBitmapEx.IsEmpty());
      if (!bNeedToCreate && (sItemTextTitle.isEmpty() || aPreparedSize != maPreviewSize))
          bNeedToCreate = true;

      if (bNeedToCreate)
      {
          std::unique_ptr<SgaObject> xObj = mpCurTheme->AcquireObject(i);
          if (xObj)
          {
              aBitmapEx = xObj->createPreviewBitmapEx(maPreviewSize);
              sItemTextTitle = GalleryBrowser2::GetItemText(*xObj, GalleryItemFlags::Title);
              sItemTextPath = GalleryBrowser2::GetItemText(*xObj, GalleryItemFlags::Path);

              mpCurTheme->SetPreviewBitmapExAndStrings(i, aBitmapEx, maPreviewSize, sItemTextTitle, sItemTextPath);
          }
      }

      if (!aBitmapEx.IsEmpty())
      {
          const Size aBitmapExSizePixel(aBitmapEx.GetSizePixel());
          const Point aPos(
              ((maPreviewSize.Width() - aBitmapExSizePixel.Width()) >> 1),
              ((maPreviewSize.Height() - aBitmapExSizePixel.Height()) >> 1));

          mxDev->Erase();

          if (aBitmapEx.IsTransparent())
          {
              // draw checkered background
              GalleryIconView::drawTransparenceBackground(*mxDev, aPos, aBitmapExSizePixel);
          }

          mxDev->DrawBitmapEx(aPos, aBitmapEx);
      }

      mxListView->set_text(rEntry, sItemTextTitle);
      mxListView->set_image(rEntry, *mxDev);
      mxListView->set_id(rEntry, OUString());

      return false;
  };

  if (bVisibleOnly)
  {
      // ensure all visible entries are up to date
      mxListView->visible_foreach(lambda);
      // and ensure all selected entries are up to date
      mxListView->selected_foreach(lambda);
      return;
  }

  mxListView->all_foreach(lambda);
897}

899IMPL_LINK_NOARG(GalleryBrowser2, VisRowsScrolledHdl, weld::TreeView&, void)void GalleryBrowser2::LinkStubVisRowsScrolledHdl(void * instance
, weld::TreeView& data) { return static_cast<GalleryBrowser2
 *>(instance)->VisRowsScrolledHdl(data); } void GalleryBrowser2
::VisRowsScrolledHdl(__attribute__ ((unused)) weld::TreeView&
)
900{
  UpdateRows(true);
902}

904IMPL_LINK_NOARG(GalleryBrowser2, SizeAllocHdl, const Size&, void)void GalleryBrowser2::LinkStubSizeAllocHdl(void * instance, const
 Size& data) { return static_cast<GalleryBrowser2 *>
(instance)->SizeAllocHdl(data); } void GalleryBrowser2::SizeAllocHdl
(__attribute__ ((unused)) const Size&)
905{
  UpdateRows(true);
907}

909void GalleryBrowser2::ImplUpdateInfoBar()
910{
  if (!mpCurTheme)
      return;
  mxInfoBar->set_label( mpCurTheme->GetName() );
914}

916void GalleryBrowser2::ImplUpdateSelection()
917{
  if (!mpCurTheme)
      return;
  auto nSelectedObject = (GALLERYBROWSERMODE_ICON == GetMode()) ? (mxIconView->GetSelectedItemId() - 1) : mxListView->get_selected_index();
  m_xHelper->SelectObject(nSelectedObject);
922}

924sal_uInt32 GalleryBrowser2::ImplGetSelectedItemId( const Point* pSelPos, Point& rSelPos )
925{
  sal_uInt32 nRet = 0;

  if( GALLERYBROWSERMODE_PREVIEW == GetMode() )
  {
      nRet = ( ( GALLERYBROWSERMODE_ICON == meLastMode ) ? mxIconView->GetSelectedItemId() : ( mxListView->get_selected_index() + 1 ) );

      if( pSelPos )
          rSelPos = *pSelPos;
      else
      {
          Size aOutputSizePixel(mxPreview->GetOutputSizePixel());
          rSelPos = Point( aOutputSizePixel.Width() >> 1, aOutputSizePixel.Height() >> 1 );
      }
  }
  else if (GALLERYBROWSERMODE_ICON == GetMode())
  {
      if (pSelPos)
      {
          nRet = mxIconView->GetItemId( *pSelPos );
          rSelPos = *pSelPos;
      }
      else
      {
          nRet = mxIconView->GetSelectedItemId();
          rSelPos = mxIconView->GetItemRect(nRet).Center();
      }
  }
  else
  {
      std::unique_ptr<weld::TreeIter> xIter = mxListView->make_iterator();
      if( pSelPos )
      {
          if (mxListView->get_dest_row_at_pos(*pSelPos, xIter.get(), false))
              nRet = mxListView->get_iter_index_in_parent(*xIter) + 1;
          rSelPos = *pSelPos;
      }
      else
      {
          if (mxListView->get_selected(xIter.get()))
          {
              nRet = mxListView->get_iter_index_in_parent(*xIter) + 1;
              rSelPos = mxListView->get_row_area(*xIter).Center();
          }
      }
  }

  if( nRet && ( !mpCurTheme || ( nRet > mpCurTheme->GetObjectCount() ) ) )
  {
      nRet = 0;
  }

  return nRet;
978}

980void GalleryBrowser2::ImplSelectItemId(sal_uInt32 nItemId)
981{
  if( nItemId )
  {
      mxIconView->SelectItem(nItemId);
      mxListView->select( nItemId - 1 );
      ImplUpdateSelection();
  }
988}

990css::uno::Reference< css::frame::XFrame >
991GalleryBrowser2::GetFrame()
992{
  css::uno::Reference< css::frame::XFrame > xFrame;
  SfxViewFrame* pCurrentViewFrame = SfxViewFrame::Current();
  if ( pCurrentViewFrame )
  {
      SfxBindings& rBindings = pCurrentViewFrame->GetBindings();
      xFrame.set( rBindings.GetActiveFrame() );
  }

  return xFrame;
1002}

1004void GalleryBrowser2::DispatchAdd(
  const css::uno::Reference< css::frame::XDispatch > &rxDispatch,
  const css::util::URL &rURL)
1007{
  Point aSelPos;
  const sal_uInt32 nItemId = ImplGetSelectedItemId( nullptr, aSelPos );

  if( !mpCurTheme || !nItemId )
      return;

  mnCurActionPos = nItemId - 1;

  css::uno::Reference< css::frame::XDispatch > xDispatch( rxDispatch );
  css::util::URL aURL = rURL;

  if ( !xDispatch.is() )
  {
      css::uno::Reference< css::frame::XDispatchProvider > xDispatchProvider(
          GetFrame(), css::uno::UNO_QUERY );
      if ( !xDispatchProvider.is() || !m_xTransformer.is() )
          return;

      aURL.Complete = ".uno:InsertGalleryPic";
      m_xTransformer->parseStrict( aURL );
      xDispatch = xDispatchProvider->queryDispatch(
          aURL,
          "_self",
          css::frame::FrameSearchFlag::SELF );
  }

  if ( !xDispatch.is() )
      return;

  sal_Int8 nType = 0;
  OUString aFilterName;
  css::uno::Reference< css::lang::XComponent > xDrawing;
  css::uno::Reference< css::graphic::XGraphic > xGraphic;

  aFilterName = GetFilterName();

  switch( mpCurTheme->GetObjectKind( mnCurActionPos ) )
  {
      case SgaObjKind::Bitmap:
      case SgaObjKind::Animation:
      case SgaObjKind::Inet:
      // TODO drawing objects are inserted as drawings only via drag&drop
      case SgaObjKind::SvDraw:
          nType = css::gallery::GalleryItemType::GRAPHIC;
      break;

      case SgaObjKind::Sound :
          nType = css::gallery::GalleryItemType::MEDIA;
      break;

      default:
          nType = css::gallery::GalleryItemType::EMPTY;
      break;
  }

  Graphic aGraphic;
  bool bGraphic = mpCurTheme->GetGraphic( mnCurActionPos, aGraphic );
  if ( bGraphic && !aGraphic.IsNone() )
      xGraphic.set( aGraphic.GetXGraphic() );
  OSL_ENSURE( xGraphic.is(), "gallery item is graphic, but the reference is invalid!" )do { if (true && (!(xGraphic.is()))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/svx/source/gallery2/galbrws2.cxx"
 ":" "1067" ": "), "%s", "gallery item is graphic, but the reference is invalid!"
); } } while (false);

  css::uno::Sequence< css::beans::PropertyValue > aSeq( SVXGALLERYITEM_PARAMS5 );

  aSeq[0].Name = SVXGALLERYITEM_TYPE"GalleryItemType";
  aSeq[0].Value <<= nType;
  aSeq[1].Name = SVXGALLERYITEM_URL"URL";
  aSeq[1].Value <<= OUString();
  aSeq[2].Name = SVXGALLERYITEM_FILTER"FilterName";
  aSeq[2].Value <<= aFilterName;
  aSeq[3].Name = SVXGALLERYITEM_DRAWING"Drawing";
  aSeq[3].Value <<= xDrawing;
  aSeq[4].Name = SVXGALLERYITEM_GRAPHIC"Graphic";
  aSeq[4].Value <<= xGraphic;

  css::uno::Sequence< css::beans::PropertyValue > aArgs( 1 );
  aArgs[0].Name = SVXGALLERYITEM_ARGNAME"GalleryItem";
  aArgs[0].Value <<= aSeq;

  std::unique_ptr<DispatchInfo> pInfo(new DispatchInfo);
  pInfo->TargetURL = aURL;
  pInfo->Arguments = aArgs;
  pInfo->Dispatch = xDispatch;

  if ( Application::PostUserEvent(
          LINK( nullptr, GalleryBrowser2, AsyncDispatch_Impl)::tools::detail::makeLink( ::tools::detail::castTo<GalleryBrowser2
 *>(nullptr), &GalleryBrowser2::LinkStubAsyncDispatch_Impl
), pInfo.get() ) )
      pInfo.release();
1094}

1096void GalleryBrowser2::Execute(const OString &rIdent)
1097{
  Point       aSelPos;
  const sal_uInt32 nItemId = ImplGetSelectedItemId( nullptr, aSelPos );

  if( !(mpCurTheme && nItemId) )
11
←
Assuming field 'mpCurTheme' is non-null→
12
←
Assuming the condition is false→
13
←
Taking false branch→
      return;

  mnCurActionPos = nItemId - 1;

  if (rIdent == "preview")
14
←
Taking false branch→
      SetMode( ( GALLERYBROWSERMODE_PREVIEW != GetMode() ) ? GALLERYBROWSERMODE_PREVIEW : meLastMode );
  else if (rIdent == "delete")
15
←
Taking false branch→
  {
      if (!mpCurTheme->IsReadOnly())
      {
          std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(GetViewWindow(), "svx/ui/querydeleteobjectdialog.ui"));
          std::unique_ptr<weld::MessageDialog> xQuery(xBuilder->weld_message_dialog("QueryDeleteObjectDialog"));
          if (xQuery->run() == RET_YES)
          {
              mpCurTheme->RemoveObject( mnCurActionPos );
          }
      }
  }
  else if (rIdent == "title")
16
←
Taking true branch→
  {
      std::unique_ptr<SgaObject> pObj = mpCurTheme->AcquireObject( mnCurActionPos );

      if( pObj )
17
←
Taking true branch→
      {
          const OUString  aOldTitle( GetItemText( *pObj, GalleryItemFlags::Title ) );

          SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
          ScopedVclPtr<AbstractTitleDialog> aDlg(pFact->CreateTitleDialog(GetViewWindow(), aOldTitle));
18
←
Calling constructor for 'ScopedVclPtr<AbstractTitleDialog>'→
25
←
Returning from constructor for 'ScopedVclPtr<AbstractTitleDialog>'→
26
←
Calling implicit destructor for 'VclPtr<AbstractTitleDialog>'→
27
←
Calling '~Reference'→
34
←
Returning from '~Reference'→
35
←
Returning from destructor for 'VclPtr<AbstractTitleDialog>'→
          if( aDlg->Execute() == RET_OK )
36
←
Calling 'VclPtr::operator->'→
          {
              OUString aNewTitle( aDlg->GetTitle() );

              if( ( aNewTitle.isEmpty() && !pObj->GetTitle().isEmpty() ) || ( aNewTitle != aOldTitle ) )
              {
                  if( aNewTitle.isEmpty() )
                      aNewTitle = "__<empty>__";

                  pObj->SetTitle( aNewTitle );
                  mpCurTheme->InsertObject( *pObj );
              }
          }
      }
  }
  else if (rIdent == "copy")
  {
      mpCurTheme->CopyToClipboard(mnCurActionPos);
  }
  else if (rIdent == "paste")
  {
      if( !mpCurTheme->IsReadOnly() )
      {
          TransferableDataHelper aDataHelper(TransferableDataHelper::CreateFromClipboard(GetSystemClipboard()));
          mpCurTheme->InsertTransferable( aDataHelper.GetTransferable(), mnCurActionPos );
       }
  }
1157}

1159OUString GalleryBrowser2::GetItemText( const SgaObject& rObj, GalleryItemFlags nItemTextFlags )
1160{
  OUString          aRet;

  const INetURLObject& aURL(rObj.GetURL());

  if( nItemTextFlags & GalleryItemFlags::Title )
  {
      OUString aTitle( rObj.GetTitle() );

      if( aTitle.isEmpty() )
          aTitle = aURL.getBase( INetURLObject::LAST_SEGMENT, true, INetURLObject::DecodeMechanism::Unambiguous );

      if( aTitle.isEmpty() )
      {
          aTitle = aURL.GetMainURL( INetURLObject::DecodeMechanism::Unambiguous );
          aTitle = aTitle.copy( aTitle.lastIndexOf('/')+1 );
      }

      aRet += aTitle;
  }

  if( nItemTextFlags & GalleryItemFlags::Path )
  {
      const OUString aPath( aURL.getFSysPath( FSysStyle::Detect ) );

      if( !aPath.isEmpty() && ( nItemTextFlags & GalleryItemFlags::Title ) )
          aRet += " (";

      aRet += aURL.getFSysPath( FSysStyle::Detect );

      if( !aPath.isEmpty() && ( nItemTextFlags & GalleryItemFlags::Title ) )
          aRet += ")";
  }

  return aRet;
1195}

1197INetURLObject GalleryBrowser2::GetURL() const
1198{
  INetURLObject aURL;

  if( mpCurTheme && mnCurActionPos != 0xffffffff )
      aURL = mpCurTheme->GetObjectURL( mnCurActionPos );

  return aURL;
1205}

1207OUString GalleryBrowser2::GetFilterName() const
1208{
  OUString aFilterName;

  if( mpCurTheme && mnCurActionPos != 0xffffffff )
  {
      const SgaObjKind eObjKind = mpCurTheme->GetObjectKind( mnCurActionPos );

      if( ( SgaObjKind::Bitmap == eObjKind ) || ( SgaObjKind::Animation == eObjKind ) )
      {
          GraphicFilter& rFilter = GraphicFilter::GetGraphicFilter();
          INetURLObject       aURL;
          mpCurTheme->GetURL( mnCurActionPos, aURL );
          sal_uInt16 nFilter = rFilter.GetImportFormatNumberForShortName(aURL.GetFileExtension());

          if( GRFILTER_FORMAT_DONTKNOW(sal_uInt16(0xFFFF)) != nFilter )
              aFilterName = rFilter.GetImportFormatName( nFilter );
      }
  }

  return aFilterName;
1228}

1230IMPL_LINK_NOARG(GalleryBrowser2, SelectObjectValueSetHdl, ValueSet*, void)void GalleryBrowser2::LinkStubSelectObjectValueSetHdl(void * instance
, ValueSet* data) { return static_cast<GalleryBrowser2 *>
(instance)->SelectObjectValueSetHdl(data); } void GalleryBrowser2
::SelectObjectValueSetHdl(__attribute__ ((unused)) ValueSet*)
1231{
  ImplUpdateSelection();
1233}

1235IMPL_LINK_NOARG(GalleryBrowser2, SelectObjectHdl, weld::TreeView&, void)void GalleryBrowser2::LinkStubSelectObjectHdl(void * instance
, weld::TreeView& data) { return static_cast<GalleryBrowser2
 *>(instance)->SelectObjectHdl(data); } void GalleryBrowser2
::SelectObjectHdl(__attribute__ ((unused)) weld::TreeView&
)
1236{
  ImplUpdateSelection();
1238}

1240IMPL_LINK(GalleryBrowser2, SelectTbxHdl, weld::ToggleButton&, rBox, void)void GalleryBrowser2::LinkStubSelectTbxHdl(void * instance, weld
::ToggleButton& data) { return static_cast<GalleryBrowser2
 *>(instance)->SelectTbxHdl(data); } void GalleryBrowser2
::SelectTbxHdl(weld::ToggleButton& rBox)
1241{
  if (&rBox == mxIconButton.get())
      SetMode(rBox.get_active() ? GALLERYBROWSERMODE_ICON : GALLERYBROWSERMODE_LIST);
  else if (&rBox == mxListButton.get())
      SetMode(rBox.get_active() ? GALLERYBROWSERMODE_LIST : GALLERYBROWSERMODE_ICON);
1246}

1248/* 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/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/

20#ifndef INCLUDED_VCL_PTR_HXX
21#define INCLUDED_VCL_PTR_HXX

23#include <sal/config.h>

25#include <rtl/ref.hxx>

27#include <utility>
28#include <type_traits>

30#ifdef DBG_UTIL
31#ifndef _WIN32
32#include <vcl/vclmain.hxx>
33#endif
34#endif

36class VclReferenceBase;

38namespace vcl::detail {

40template<typename>
41constexpr bool isIncompleteOrDerivedFromVclReferenceBase(...) { return true; }

43template<typename T> constexpr bool isIncompleteOrDerivedFromVclReferenceBase(
  int (*)[sizeof(T)])
45{ return std::is_base_of<VclReferenceBase, T>::value; }

47} // namespace vcl::detail

49/**
* A thin wrapper around rtl::Reference to implement the acquire and dispose semantics we want for references to vcl::Window subclasses.
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
56template <class reference_type>
57class VclPtr
58{
  static_assert(
      vcl::detail::isIncompleteOrDerivedFromVclReferenceBase<reference_type>(
          nullptr),
      "template argument type must be derived from VclReferenceBase");

  ::rtl::Reference<reference_type> m_rInnerRef;

66public:
  /** Constructor...
   */
  VclPtr()
      : m_rInnerRef()
  {}

  /** Constructor...
   */
  VclPtr (reference_type * pBody)
      : m_rInnerRef(pBody)
  {}

  /** Constructor... that doesn't take a ref.
   */
  VclPtr (reference_type * pBody, __sal_NoAcquire)
      : m_rInnerRef(pBody, SAL_NO_ACQUIRE)
  {}

  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.  For the special case of
      up-casting to Reference< XInterface >, see the corresponding conversion
      operator.

      @param rRef another reference
  */
  template< class derived_type >
  VclPtr(
      const VclPtr< derived_type > & rRef,
      typename std::enable_if<
          std::is_base_of<reference_type, derived_type>::value, int>::type
          = 0 )
      : m_rInnerRef( static_cast<reference_type*>(rRef) )
  {
  }

103#if defined(DBG_UTIL) && !defined(_WIN32)
  virtual ~VclPtr()
  {
      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__));
      // We can be one of the intermediate counts, but if we are the last
      // VclPtr keeping this object alive, then something forgot to call dispose().
      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__))
              && "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__));
  }
  VclPtr(VclPtr const &) = default;
  VclPtr(VclPtr &&) = default;
  VclPtr & operator =(VclPtr const &) = default;
  VclPtr & operator =(VclPtr &&) = default;
116#endif

  /**
   * A construction helper for VclPtr. Since VclPtr types are created
   * with a reference-count of one - to help fit into the existing
   * code-flow; this helps us to construct them easily.
   *
   * For more details on the design please see vcl/README.lifecycle
   *
   * @tparam reference_type must be a subclass of vcl::Window
   */
  template<typename... Arg> [[nodiscard]] static VclPtr< reference_type > Create(Arg &&... arg)
  {
      return VclPtr< reference_type >( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE );
  }

  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * operator->() const
  {
      return m_rInnerRef.get();
37
←
Calling 'Reference::get'→
  }

  /** Get the body. Can be used instead of operator->().
       I.e. handle->someBodyOp() and handle.get()->someBodyOp()
       are the same.
    */
  reference_type * get() const
  {
      return m_rInnerRef.get();
  }

  void set(reference_type *pBody)
  {
      m_rInnerRef.set(pBody);
  }

  void reset(reference_type *pBody)
  {
      m_rInnerRef.set(pBody);
  }

  /** Up-casting copy assignment operator.

      Does not work for up-casts to ambiguous bases.

      @param rRef another reference
  */
  template<typename derived_type>
  typename std::enable_if<
      std::is_base_of<reference_type, derived_type>::value,
      VclPtr &>::type
  operator =(VclPtr<derived_type> const & rRef)
  {
      m_rInnerRef.set(rRef.get());
      return *this;
  }

  VclPtr & operator =(reference_type * pBody)
  {
      m_rInnerRef.set(pBody);
      return *this;
  }

  operator reference_type * () const
  {
      return m_rInnerRef.get();
  }

  explicit operator bool () const
  {
      return m_rInnerRef.get() != nullptr;
  }

  void clear()
  {
      m_rInnerRef.clear();
  }

  void reset()
  {
      m_rInnerRef.clear();
  }

  void disposeAndClear()
  {
      // hold it alive for the lifetime of this method
      ::rtl::Reference<reference_type> aTmp(m_rInnerRef);
      m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-)
      if (aTmp.get()) {
          aTmp->disposeOnce();
      }
  }

  /** Needed to place VclPtr's into STL collection.
   */
  bool operator< (const VclPtr<reference_type> & handle) const
  {
      return (m_rInnerRef < handle.m_rInnerRef);
  }
216}; // class VclPtr

218template<typename T1, typename T2>
219inline bool operator ==(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
  return p1.get() == p2.get();
221}

223template<typename T> inline bool operator ==(VclPtr<T> const & p1, T const * p2)
224{
  return p1.get() == p2;
226}

228template<typename T> inline bool operator ==(VclPtr<T> const & p1, T * p2) {
  return p1.get() == p2;
230}

232template<typename T> inline bool operator ==(T const * p1, VclPtr<T> const & p2)
233{
  return p1 == p2.get();
235}

237template<typename T> inline bool operator ==(T * p1, VclPtr<T> const & p2) {
  return p1 == p2.get();
239}

241template<typename T1, typename T2>
242inline bool operator !=(VclPtr<T1> const & p1, VclPtr<T2> const & p2) {
  return !(p1 == p2);
244}

246template<typename T> inline bool operator !=(VclPtr<T> const & p1, T const * p2)
247{
  return !(p1 == p2);
249}

251template<typename T> inline bool operator !=(VclPtr<T> const & p1, T * p2) {
  return !(p1 == p2);
253}

255template<typename T> inline bool operator !=(T const * p1, VclPtr<T> const & p2)
256{
  return !(p1 == p2);
258}

260template<typename T> inline bool operator !=(T * p1, VclPtr<T> const & p2) {
  return !(p1 == p2);
262}

264/**
* A construction helper for a temporary VclPtr. Since VclPtr types
* are created with a reference-count of one - to help fit into
* the existing code-flow; this helps us to construct them easily.
* see also VclPtr::Create and ScopedVclPtr
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
274template <class reference_type>
275class SAL_WARN_UNUSED__attribute__((warn_unused)) VclPtrInstance final : public VclPtr<reference_type>
276{
277public:
  template<typename... Arg> VclPtrInstance(Arg &&... arg)
      : VclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
  {
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static VclPtrInstance< reference_type > Create(Arg &&... ) = delete;
288};

290template <class reference_type>
291class ScopedVclPtr : public VclPtr<reference_type>
292{
293public:
  /** Constructor...
   */
  ScopedVclPtr()
      : VclPtr<reference_type>()
  {}

  /** Constructor
   */
  ScopedVclPtr (reference_type * pBody)
      : VclPtr<reference_type>(pBody)
  {}

  /** Copy constructor...
   */
  ScopedVclPtr (const VclPtr<reference_type> & handle)
      : VclPtr<reference_type>(handle)
19
←
Calling implicit copy constructor for 'VclPtr<AbstractTitleDialog>'→
20
←
Calling copy constructor for 'Reference<AbstractTitleDialog>'→
23
←
Returning from copy constructor for 'Reference<AbstractTitleDialog>'→
24
←
Returning from copy constructor for 'VclPtr<AbstractTitleDialog>'→
  {}

  /**
     Assignment that releases the last reference.
   */
  void disposeAndReset(reference_type *pBody)
  {
      if (pBody != this->get()) {
          VclPtr<reference_type>::disposeAndClear();
          VclPtr<reference_type>::set(pBody);
      }
  }

  /**
     Assignment that releases the last reference.
   */
  ScopedVclPtr<reference_type>& operator = (reference_type * pBody)
  {
      disposeAndReset(pBody);
      return *this;
  }

  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.  For the special case of
      up-casting to Reference< XInterface >, see the corresponding conversion
      operator.

      @param rRef another reference
  */
  template< class derived_type >
  ScopedVclPtr(
      const VclPtr< derived_type > & rRef,
      typename std::enable_if<
          std::is_base_of<reference_type, derived_type>::value, int>::type
          = 0 )
      : VclPtr<reference_type>( rRef )
  {
  }

  /** Up-casting assignment operator.

      Does not work for up-casts to ambiguous bases.

      @param rRef another VclPtr
  */
  template<typename derived_type>
  typename std::enable_if<
      std::is_base_of<reference_type, derived_type>::value,
      ScopedVclPtr &>::type
  operator =(VclPtr<derived_type> const & rRef)
  {
      disposeAndReset(rRef.get());
      return *this;
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static ScopedVclPtr< reference_type > Create(Arg &&... ) = delete;

  ~ScopedVclPtr()
  {
      VclPtr<reference_type>::disposeAndClear();
      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
  }

378private:
  // Most likely we don't want this default copy-constructor.
  ScopedVclPtr (const ScopedVclPtr<reference_type> &) = delete;
  // And certainly we don't want a default assignment operator.
  ScopedVclPtr<reference_type>& operator = (const ScopedVclPtr<reference_type> &) = delete;
  // And disallow reset as that doesn't call disposeAndClear on the original reference
  void reset() = delete;
  void reset(reference_type *pBody) = delete;

387protected:
  ScopedVclPtr (reference_type * pBody, __sal_NoAcquire)
      : VclPtr<reference_type>(pBody, SAL_NO_ACQUIRE)
  {}
391};

393/**
* A construction helper for ScopedVclPtr. Since VclPtr types are created
* with a reference-count of one - to help fit into the existing
* code-flow; this helps us to construct them easily.
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
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:
  template<typename... Arg> ScopedVclPtrInstance(Arg &&... arg)
      : ScopedVclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
  {
  }

  /**
   * Override and disallow this, to prevent people accidentally calling it and actually
   * getting VclPtr::Create and getting a naked VclPtr<> instance
   */
  template<typename... Arg> static ScopedVclPtrInstance< reference_type > Create(Arg &&...) = delete;

421private:
  // Prevent the above perfect forwarding ctor from hijacking (accidental)
  // attempts at ScopedVclPtrInstance copy construction (where the hijacking
  // would typically lead to somewhat obscure error messages); both non-const
  // and const variants are needed here, as the ScopedVclPtr base class has a
  // const--variant copy ctor, so the implicitly declared copy ctor for
  // ScopedVclPtrInstance would also be the const variant, so non-const copy
  // construction attempts would be hijacked by the perfect forwarding ctor;
  // but if we only declared a non-const variant here, the const variant would
  // no longer be implicitly declared (as there would already be an explicitly
  // declared copy ctor), so const copy construction attempts would then be
  // hijacked by the perfect forwarding ctor:
  ScopedVclPtrInstance(ScopedVclPtrInstance &) = delete;
  ScopedVclPtrInstance(ScopedVclPtrInstance const &) = delete;
435};
436#if defined _MSC_VER
437#pragma warning(pop)
438#endif

440#endif // INCLUDED_VCL_PTR_HXX

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/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
*   Licensed to the Apache Software Foundation (ASF) under one or more
*   contributor license agreements. See the NOTICE file distributed
*   with this work for additional information regarding copyright
*   ownership. The ASF licenses this file to you under the Apache
*   License, Version 2.0 (the "License"); you may not use this file
*   except in compliance with the License. You may obtain a copy of
*   the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/

20#ifndef INCLUDED_RTL_REF_HXX
21#define INCLUDED_RTL_REF_HXX

23#include "sal/config.h"

25#include <cassert>
26#include <cstddef>
27#include <functional>
28#ifdef LIBO_INTERNAL_ONLY1
29#include <type_traits>
30#endif

32#include "sal/types.h"

34namespace rtl
35{

37/** Template reference class for reference type.
38*/
39template <class reference_type>
40class Reference
41{
  /** The <b>reference_type</b> body pointer.
   */
  reference_type * m_pBody;


47public:
  /** Constructor...
   */
  Reference()
      : m_pBody (NULL__null)
  {}


  /** Constructor...
   */
  Reference (reference_type * pBody, __sal_NoAcquire)
      : m_pBody (pBody)
  {
  }

  /** Constructor...
   */
  Reference (reference_type * pBody)
      : m_pBody (pBody)
  {
      if (m_pBody)
          m_pBody->acquire();
  }

  /** Copy constructor...
   */
  Reference (const Reference<reference_type> & handle)
      : m_pBody (handle.m_pBody)
  {
      if (m_pBody)
21
←
Assuming field 'm_pBody' is non-null→
22
←
Taking true branch→
          m_pBody->acquire();
  }

80#ifdef LIBO_INTERNAL_ONLY1
  /** Move constructor...
   */
  Reference (Reference<reference_type> && handle) noexcept
      : m_pBody (handle.m_pBody)
  {
      handle.m_pBody = nullptr;
  }
88#endif

90#if defined LIBO_INTERNAL_ONLY1
  /** Up-casting conversion constructor: Copies interface reference.

      Does not work for up-casts to ambiguous bases.

      @param rRef another reference
  */
  template< class derived_type >
  inline Reference(
      const Reference< derived_type > & rRef,
      std::enable_if_t<std::is_base_of_v<reference_type, derived_type>, int> = 0 )
      : m_pBody (rRef.get())
  {
      if (m_pBody)
          m_pBody->acquire();
  }
106#endif

  /** Destructor...
   */
  ~Reference() COVERITY_NOEXCEPT_FALSE
  {
      if (m_pBody27.1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
1
Field 'm_pBody' is non-null
)
28
←
Taking true branch→
          m_pBody->release();
29
←
Calling 'VclReferenceBase::release'→
33
←
Returning; memory was released→
  }

  /** Set...
       Similar to assignment.
   */
  Reference<reference_type> &
  SAL_CALL set (reference_type * pBody)
  {
      if (pBody)
          pBody->acquire();
      reference_type * const pOld = m_pBody;
      m_pBody = pBody;
      if (pOld)
          pOld->release();
      return *this;
  }

  /** Assignment.
       Unbinds this instance from its body (if bound) and
       bind it to the body represented by the handle.
   */
  Reference<reference_type> &
  SAL_CALL operator= (const Reference<reference_type> & handle)
  {
      return set( handle.m_pBody );
  }

141#ifdef LIBO_INTERNAL_ONLY1
  /** Assignment.
   *   Unbinds this instance from its body (if bound),
   *   bind it to the body represented by the handle, and
   *   set the body represented by the handle to nullptr.
   */
  Reference<reference_type> &
  operator= (Reference<reference_type> && handle)
  {
      // self-movement guts ourself
      if (m_pBody)
          m_pBody->release();
      m_pBody = handle.m_pBody;
      handle.m_pBody = nullptr;
      return *this;
  }
157#endif

  /** Assignment...
   */
  Reference<reference_type> &
  SAL_CALL operator= (reference_type * pBody)
  {
      return set( pBody );
  }

  /** Unbind the body from this handle.
       Note that for a handle representing a large body,
       "handle.clear().set(new body());" _might_
       perform a little bit better than "handle.set(new body());",
       since in the second case two large objects exist in memory
       (the old body and the new body).
   */
  Reference<reference_type> & SAL_CALL clear()
  {
      if (m_pBody)
      {
          reference_type * const pOld = m_pBody;
          m_pBody = NULL__null;
          pOld->release();
      }
      return *this;
  }


  /** Get the body. Can be used instead of operator->().
       I.e. handle->someBodyOp() and handle.get()->someBodyOp()
       are the same.
   */
  reference_type * SAL_CALL get() const
  {
      return m_pBody;
38
←
Use of memory after it is freed
  }


  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * SAL_CALL operator->() const
  {
      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__));
      return m_pBody;
  }


  /** Allows (*handle).someBodyOp().
  */
  reference_type & SAL_CALL operator*() const
  {
      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__));
      return *m_pBody;
  }


  /** Returns True if the handle does point to a valid body.
   */
  bool SAL_CALL is() const
  {
      return (m_pBody != NULL__null);
  }

221#if defined LIBO_INTERNAL_ONLY1
  /** Returns True if the handle does point to a valid body.
   */
  explicit operator bool() const
  {
      return is();
  }
228#endif

  /** Returns True if this points to pBody.
   */
  bool SAL_CALL operator== (const reference_type * pBody) const
  {
      return (m_pBody == pBody);
  }


  /** Returns True if handle points to the same body.
   */
  bool
  SAL_CALL operator== (const Reference<reference_type> & handle) const
  {
      return (m_pBody == handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator!= (const Reference<reference_type> & handle) const
  {
      return (m_pBody != handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator< (const Reference<reference_type> & handle) const
  {
      return (m_pBody < handle.m_pBody);
  }


  /** Needed to place References into STL collection.
   */
  bool
  SAL_CALL operator> (const Reference<reference_type> & handle) const
  {
      return (m_pBody > handle.m_pBody);
  }
272};

274} // namespace rtl

276#if defined LIBO_INTERNAL_ONLY1
277namespace std
278{

280/// @cond INTERNAL
281/**
Make rtl::Reference hashable by default for use in STL containers.

@since LibreOffice 6.3
285*/
286template<typename T>
287struct hash<::rtl::Reference<T>>
288{
  std::size_t operator()(::rtl::Reference<T> const & s) const
  { return std::size_t(s.get()); }
291};
292/// @endcond

294}

296#endif

298#endif /* ! INCLUDED_RTL_REF_HXX */

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)
30
←
Assuming the condition is true→
31
←
Taking true branch→
40            delete this;
32
←
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