/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 valueset.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D SVT_DLLIMPLEMENTATION -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -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/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/svtools/source/inc -I /home/maarten/src/libreoffice/core/svtools/inc -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/svtools/source/control/valueset.cxx

/home/maarten/src/libreoffice/core/svtools/source/control/valueset.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 .
*/

20#include <sal/config.h>

22#include <o3tl/safeint.hxx>
23#include <tools/debug.hxx>
24#include <tools/stream.hxx>
25#include <comphelper/base64.hxx>
26#include <vcl/decoview.hxx>
27#include <vcl/event.hxx>
28#include <vcl/graph.hxx>
29#include <vcl/svapp.hxx>
30#include <vcl/cvtgrf.hxx>
31#include <vcl/help.hxx>
32#include <vcl/settings.hxx>
33#include <vcl/commandevent.hxx>
34#include <vcl/virdev.hxx>

36#include <com/sun/star/accessibility/AccessibleEventId.hpp>
37#include <com/sun/star/lang/XComponent.hpp>
38#include <rtl/ustring.hxx>
39#include <sal/log.hxx>
40#include "valueimp.hxx"

42#include <svtools/valueset.hxx>
43#include <boost/property_tree/ptree.hpp>

45#include <uiobject.hxx>
46#include <vcl/uitest/logger.hxx>
47#include <vcl/uitest/eventdescription.hxx>

49using namespace css::uno;
50using namespace css::lang;
51using namespace css::accessibility;

53namespace
54{
55void collectUIInformation( const OUString& aID , const OUString& aParentID , const OUString& aPos )
56{
  EventDescription aDescription;
  aDescription.aID = aID ;
  aDescription.aParameters = {{"POS", aPos }};
  aDescription.aAction = "SELECT";
  aDescription.aKeyWord = "ValueSet";
  aDescription.aParent = aParentID;
  UITestLogger::getInstance().logEvent(aDescription);
64}

66enum
67{
  ITEM_OFFSET = 4,
  ITEM_OFFSET_DOUBLE = 6,
  NAME_LINE_OFF_X = 2,
  NAME_LINE_OFF_Y = 2,
  NAME_LINE_HEIGHT = 2,
  NAME_OFFSET = 2,
74};

76}

78ValueSet::ValueSet(std::unique_ptr<weld::ScrolledWindow> pScrolledWindow)
  : maVirDev( VclPtr<VirtualDevice>::Create())
  , mxScrolledWindow(std::move(pScrolledWindow))
  , mnHighItemId(0)
  , maColor(COL_TRANSPARENT)
  , mnStyle(0)
  , mbFormat(true)
  , mbHighlight(false)
86{
  maVirDev->SetBackground(Application::GetSettings().GetStyleSettings().GetFaceColor());

  mnItemWidth         = 0;
  mnItemHeight        = 0;
  mnTextOffset        = 0;
  mnVisLines          = 0;
  mnLines             = 0;
  mnUserItemWidth     = 0;
  mnUserItemHeight    = 0;
  mnFirstLine         = 0;
  mnSelItemId         = 0;
  mnSavedItemId       = -1;
  mnCols              = 0;
  mnCurCol            = 0;
  mnUserCols          = 0;
  mnUserVisLines      = 0;
  mnSpacing           = 0;
  mnFrameStyle        = DrawFrameStyle::NONE;
  mbNoSelection       = true;
  mbDrawSelection     = true;
  mbBlackSel          = false;
  mbDoubleSel         = false;
  mbScroll            = false;
  mbFullMode          = true;
  mbEdgeBlending      = false;
  mbHasVisibleItems   = false;

  if (mxScrolledWindow)
      mxScrolledWindow->connect_vadjustment_changed(LINK(this, ValueSet, ImplScrollHdl)::tools::detail::makeLink( ::tools::detail::castTo<ValueSet
 *>(this), &ValueSet::LinkStubImplScrollHdl));
116}

118void ValueSet::SetDrawingArea(weld::DrawingArea* pDrawingArea)
119{
  CustomWidgetController::SetDrawingArea(pDrawingArea);
  // #106446#, #106601# force mirroring of virtual device
  maVirDev->EnableRTL(pDrawingArea->get_direction());
123}

125Reference<XAccessible> ValueSet::CreateAccessible()
126{
  if (!mxAccessible)
      mxAccessible.set(new ValueSetAcc(this));
  return mxAccessible;
130}

132ValueSet::~ValueSet()
133{
  Reference<XComponent> xComponent(mxAccessible, UNO_QUERY);
  if (xComponent.is())
1
Taking false branch→
      xComponent->dispose();

  ImplDeleteItems();
139}
2
←
Calling '~ScopedVclPtr'→

141void ValueSet::ImplDeleteItems()
142{
  const size_t n = mItemList.size();

  for ( size_t i = 0; i < n; ++i )
  {
      ValueSetItem* pItem = mItemList[i].get();
      if ( pItem->mbVisible && ImplHasAccessibleListeners() )
      {
          Any aOldAny;
          Any aNewAny;

          aOldAny <<= pItem->GetAccessible( false/*bIsTransientChildrenDisabled*/ );
          ImplFireAccessibleEvent(AccessibleEventId::CHILD, aOldAny, aNewAny);
      }

      mItemList[i].reset();
  }

  mItemList.clear();
161}

163void ValueSet::Select()
164{
  collectUIInformation(OStringToOUString(GetDrawingArea()->get_buildable_name(),RTL_TEXTENCODING_UTF8(((rtl_TextEncoding) 76))) , OStringToOUString(GetDrawingArea()->get_help_id(),RTL_TEXTENCODING_UTF8(((rtl_TextEncoding) 76))) , OUString::number(GetSelectedItemId()));
  maSelectHdl.Call( this );
167}

169void ValueSet::UserDraw( const UserDrawEvent& )
170{
171}

173size_t ValueSet::ImplGetItem( const Point& rPos ) const
174{
  if (!mbHasVisibleItems)
  {
      return VALUESET_ITEM_NOTFOUND(size_t(-1));
  }

  if (mpNoneItem && maNoneItemRect.IsInside(rPos))
  {
      return VALUESET_ITEM_NONEITEM0xFFFE;
  }

  if (maItemListRect.IsInside(rPos))
  {
      const int xc = rPos.X() - maItemListRect.Left();
      const int yc = rPos.Y() - maItemListRect.Top();
      // The point is inside the area of item list,
      // let's find the containing item.
      const int col = xc / (mnItemWidth + mnSpacing);
      const int x = xc % (mnItemWidth + mnSpacing);
      const int row = yc / (mnItemHeight + mnSpacing);
      const int y = yc % (mnItemHeight + mnSpacing);

      if (x < mnItemWidth && y < mnItemHeight)
      {
          // the point is inside item rect and not inside spacing
          const size_t item = (mnFirstLine + row) * static_cast<size_t>(mnCols) + col;
          if (item < mItemList.size())
          {
              return item;
          }
      }
  }

  return VALUESET_ITEM_NOTFOUND(size_t(-1));
208}

210ValueSetItem* ValueSet::ImplGetItem( size_t nPos )
211{
  if (nPos == VALUESET_ITEM_NONEITEM0xFFFE)
      return mpNoneItem.get();
  else
      return (nPos < mItemList.size()) ? mItemList[nPos].get() : nullptr;
216}

218ValueSetItem* ValueSet::ImplGetFirstItem()
219{
  return !mItemList.empty() ? mItemList[0].get() : nullptr;
221}

223sal_uInt16 ValueSet::ImplGetVisibleItemCount() const
224{
  sal_uInt16 nRet = 0;
  const size_t nItemCount = mItemList.size();

  for ( size_t n = 0; n < nItemCount; ++n )
  {
      if ( mItemList[n]->mbVisible )
          ++nRet;
  }

  return nRet;
235}

237void ValueSet::ImplFireAccessibleEvent( short nEventId, const Any& rOldValue, const Any& rNewValue )
238{
  ValueSetAcc* pAcc = ValueSetAcc::getImplementation(mxAccessible);

  if( pAcc )
      pAcc->FireAccessibleEvent( nEventId, rOldValue, rNewValue );
243}

245bool ValueSet::ImplHasAccessibleListeners()
246{
  ValueSetAcc* pAcc = ValueSetAcc::getImplementation(mxAccessible);
  return( pAcc && pAcc->HasAccessibleListeners() );
249}

251IMPL_LINK(ValueSet, ImplScrollHdl, weld::ScrolledWindow&, rScrollWin, void)void ValueSet::LinkStubImplScrollHdl(void * instance, weld::ScrolledWindow
& data) { return static_cast<ValueSet *>(instance)->
ImplScrollHdl(data); } void ValueSet::ImplScrollHdl(weld::ScrolledWindow
& rScrollWin)
252{
  auto nNewFirstLine = rScrollWin.vadjustment_get_value();
  if ( nNewFirstLine != mnFirstLine )
  {
      mnFirstLine = nNewFirstLine;
      mbFormat = true;
      Invalidate();
  }
260}

262void ValueSet::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle&)
263{
  if (GetStyle() & WB_FLATVALUESET(WinBits(0x02000000)))
  {
      const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
      rRenderContext.SetLineColor();
      rRenderContext.SetFillColor(rStyleSettings.GetFaceColor());
      long nOffY = maVirDev->GetOutputSizePixel().Height();
      Size aWinSize(GetOutputSizePixel());
      rRenderContext.DrawRect(tools::Rectangle(Point(0, nOffY ), Point( aWinSize.Width(), aWinSize.Height())));
  }

  ImplDraw(rRenderContext);
275}

277void ValueSet::GetFocus()
278{
  SAL_INFO("svtools", "value set getting focus")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "svtools")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "value set getting focus"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("svtools"
), ("/home/maarten/src/libreoffice/core/svtools/source/control/valueset.cxx"
 ":" "279" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "value set getting focus"), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "value set getting focus"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("svtools"), ("/home/maarten/src/libreoffice/core/svtools/source/control/valueset.cxx"
 ":" "279" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "value set getting focus") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("svtools"), ("/home/maarten/src/libreoffice/core/svtools/source/control/valueset.cxx"
 ":" "279" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "value set getting focus"), 0); } else
 { ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "value set getting focus"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("svtools"), ("/home/maarten/src/libreoffice/core/svtools/source/control/valueset.cxx"
 ":" "279" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  Invalidate();
  CustomWidgetController::GetFocus();

  // Tell the accessible object that we got the focus.
  ValueSetAcc* pAcc = ValueSetAcc::getImplementation(mxAccessible);
  if (pAcc)
      pAcc->GetFocus();
287}

289void ValueSet::LoseFocus()
290{
  SAL_INFO("svtools", "value set losing focus")do { if (true) { switch (sal_detail_log_report(::SAL_DETAIL_LOG_LEVEL_INFO
, "svtools")) { case SAL_DETAIL_LOG_ACTION_IGNORE: break; case
 SAL_DETAIL_LOG_ACTION_LOG: if (sizeof ::sal::detail::getResult
( ::sal::detail::StreamStart() << "value set losing focus"
) == 1) { ::sal_detail_log( (::SAL_DETAIL_LOG_LEVEL_INFO), ("svtools"
), ("/home/maarten/src/libreoffice/core/svtools/source/control/valueset.cxx"
 ":" "291" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "value set losing focus"), 0); } else {
 ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "value set losing focus"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("svtools"), ("/home/maarten/src/libreoffice/core/svtools/source/control/valueset.cxx"
 ":" "291" ": "), sal_detail_stream, 0); }; break; case SAL_DETAIL_LOG_ACTION_FATAL
: if (sizeof ::sal::detail::getResult( ::sal::detail::StreamStart
() << "value set losing focus") == 1) { ::sal_detail_log
( (::SAL_DETAIL_LOG_LEVEL_INFO), ("svtools"), ("/home/maarten/src/libreoffice/core/svtools/source/control/valueset.cxx"
 ":" "291" ": "), ::sal::detail::unwrapStream( ::sal::detail::
StreamStart() << "value set losing focus"), 0); } else {
 ::std::ostringstream sal_detail_stream; sal_detail_stream <<
 "value set losing focus"; ::sal::detail::log( (::SAL_DETAIL_LOG_LEVEL_INFO
), ("svtools"), ("/home/maarten/src/libreoffice/core/svtools/source/control/valueset.cxx"
 ":" "291" ": "), sal_detail_stream, 0); }; std::abort(); break
; } } } while (false);
  Invalidate();
  CustomWidgetController::LoseFocus();

  // Tell the accessible object that we lost the focus.
  ValueSetAcc* pAcc = ValueSetAcc::getImplementation(mxAccessible);
  if( pAcc )
      pAcc->LoseFocus();
299}

301void ValueSet::Resize()
302{
  mbFormat = true;
  if ( IsReallyVisible() && IsUpdateMode() )
      Invalidate();
  CustomWidgetController::Resize();
307}

309bool ValueSet::KeyInput( const KeyEvent& rKeyEvent )
310{
  size_t nLastItem = mItemList.size();

  if ( !nLastItem || !ImplGetFirstItem() )
      return CustomWidgetController::KeyInput(rKeyEvent);

  if (mbFormat)
      Invalidate();

  --nLastItem;

  const size_t nCurPos
      = mnSelItemId ? GetItemPos(mnSelItemId) : (mpNoneItem ? VALUESET_ITEM_NONEITEM0xFFFE : 0);
  size_t nItemPos = VALUESET_ITEM_NOTFOUND(size_t(-1));
  size_t nVStep = mnCols;

  switch (rKeyEvent.GetKeyCode().GetCode())
  {
      case KEY_HOME:
          nItemPos = mpNoneItem ? VALUESET_ITEM_NONEITEM0xFFFE : 0;
          break;

      case KEY_END:
          nItemPos = nLastItem;
          break;

      case KEY_LEFT:
          if (nCurPos != VALUESET_ITEM_NONEITEM0xFFFE)
          {
              if (nCurPos)
              {
                  nItemPos = nCurPos-1;
              }
              else if (mpNoneItem)
              {
                  nItemPos = VALUESET_ITEM_NONEITEM0xFFFE;
              }
          }
          break;

      case KEY_RIGHT:
          if (nCurPos < nLastItem)
          {
              if (nCurPos == VALUESET_ITEM_NONEITEM0xFFFE)
              {
                  nItemPos = 0;
              }
              else
              {
                  nItemPos = nCurPos+1;
              }
          }
          break;

      case KEY_PAGEUP:
          if (rKeyEvent.GetKeyCode().IsShift() || rKeyEvent.GetKeyCode().IsMod1() || rKeyEvent.GetKeyCode().IsMod2())
          {
              return CustomWidgetController::KeyInput(rKeyEvent);
          }
          nVStep *= mnVisLines;
          [[fallthrough]];
      case KEY_UP:
          if (nCurPos != VALUESET_ITEM_NONEITEM0xFFFE)
          {
              if (nCurPos == nLastItem)
              {
                  const size_t nCol = mnCols ? nLastItem % mnCols : 0;
                  if (nCol < mnCurCol)
                  {
                      // Move to previous row/page, keeping the old column
                      nVStep -= mnCurCol - nCol;
                  }
              }
              if (nCurPos >= nVStep)
              {
                  // Go up of a whole page
                  nItemPos = nCurPos-nVStep;
              }
              else if (mpNoneItem)
              {
                  nItemPos = VALUESET_ITEM_NONEITEM0xFFFE;
              }
              else if (nCurPos > mnCols)
              {
                  // Go to same column in first row
                  nItemPos = nCurPos % mnCols;
              }
          }
          break;

      case KEY_PAGEDOWN:
          if (rKeyEvent.GetKeyCode().IsShift() || rKeyEvent.GetKeyCode().IsMod1() || rKeyEvent.GetKeyCode().IsMod2())
          {
              return CustomWidgetController::KeyInput(rKeyEvent);
          }
          nVStep *= mnVisLines;
          [[fallthrough]];
      case KEY_DOWN:
          if (nCurPos != nLastItem)
          {
              if (nCurPos == VALUESET_ITEM_NONEITEM0xFFFE)
              {
                  nItemPos = nVStep-mnCols+mnCurCol;
              }
              else
              {
                  nItemPos = nCurPos+nVStep;
              }
              if (nItemPos > nLastItem)
              {
                  nItemPos = nLastItem;
              }
          }
          break;

      case KEY_RETURN:
          if (GetStyle() & WB_NO_DIRECTSELECT(WinBits(0x04000000)))
          {
              Select();
              break;
          }
          [[fallthrough]];
      default:
          return CustomWidgetController::KeyInput(rKeyEvent);
  }

  if ( nItemPos == VALUESET_ITEM_NOTFOUND(size_t(-1)) )
      return true;

  if ( nItemPos!=VALUESET_ITEM_NONEITEM0xFFFE && nItemPos<nLastItem )
  {
      // update current column only in case of a new position
      // which is also not a "specially" handled one.
      mnCurCol = mnCols ? nItemPos % mnCols : 0;
  }
  const sal_uInt16 nItemId = (nItemPos != VALUESET_ITEM_NONEITEM0xFFFE) ? GetItemId( nItemPos ) : 0;
  if ( nItemId != mnSelItemId )
  {
      SelectItem( nItemId );
      if (!(GetStyle() & WB_NO_DIRECTSELECT(WinBits(0x04000000))))
      {
          // select only if WB_NO_DIRECTSELECT is not set
          Select();
      }
  }

  return true;
457}

459void ValueSet::ImplTracking(const Point& rPos)
460{
  ValueSetItem* pItem = ImplGetItem( ImplGetItem( rPos ) );
  if ( pItem )
  {
      if( GetStyle() & WB_MENUSTYLEVALUESET(WinBits(0x08000000)) || GetStyle() & WB_FLATVALUESET(WinBits(0x02000000)) )
          mbHighlight = true;

      ImplHighlightItem( pItem->mnId );
  }
  else
  {
      if( GetStyle() & WB_MENUSTYLEVALUESET(WinBits(0x08000000)) || GetStyle() & WB_FLATVALUESET(WinBits(0x02000000)) )
          mbHighlight = true;

      ImplHighlightItem( mnSelItemId, false );
  }
476}

478bool ValueSet::MouseButtonDown( const MouseEvent& rMouseEvent )
479{
  if ( rMouseEvent.IsLeft() )
  {
      ValueSetItem* pItem = ImplGetItem( ImplGetItem( rMouseEvent.GetPosPixel() ) );
      if (pItem && !rMouseEvent.IsMod2())
      {
          if (rMouseEvent.GetClicks() == 1)
          {
              SelectItem( pItem->mnId );
              if (!(GetStyle() & WB_NOPOINTERFOCUS))
                  GrabFocus();
          }
          else if ( rMouseEvent.GetClicks() == 2 )
              maDoubleClickHdl.Call( this );

          return true;
      }
  }

  return CustomWidgetController::MouseButtonDown( rMouseEvent );
499}

501bool ValueSet::MouseButtonUp( const MouseEvent& rMouseEvent )
502{
  if (rMouseEvent.IsLeft() && !rMouseEvent.IsMod2())
  {
      Select();
      return true;
  }

  return CustomWidgetController::MouseButtonUp( rMouseEvent );
510}

512bool ValueSet::MouseMove(const MouseEvent& rMouseEvent)
513{
  // because of SelectionMode
  if ((GetStyle() & WB_MENUSTYLEVALUESET(WinBits(0x08000000))) || (GetStyle() & WB_FLATVALUESET(WinBits(0x02000000))))
      ImplTracking(rMouseEvent.GetPosPixel());
  return CustomWidgetController::MouseMove(rMouseEvent);
518}

520void ValueSet::QueueReformat()
521{
  queue_resize();
  RecalcScrollBar();
  mbFormat = true;
  if ( IsReallyVisible() && IsUpdateMode() )
      Invalidate();
527}

529void ValueSet::RemoveItem( sal_uInt16 nItemId )
530{
  size_t nPos = GetItemPos( nItemId );

  if ( nPos == VALUESET_ITEM_NOTFOUND(size_t(-1)) )
      return;

  if ( nPos < mItemList.size() ) {
      mItemList.erase( mItemList.begin() + nPos );
  }

  // reset variables
  if (mnHighItemId == nItemId || mnSelItemId == nItemId)
  {
      mnCurCol        = 0;
      mnHighItemId    = 0;
      mnSelItemId     = 0;
      mbNoSelection   = true;
  }

  QueueReformat();
550}

552void ValueSet::TurnOffScrollBar()
553{
  if (mxScrolledWindow->get_vpolicy() == VclPolicyType::NEVER)
      return;
  mxScrolledWindow->set_vpolicy(VclPolicyType::NEVER);
  weld::DrawingArea* pDrawingArea = GetDrawingArea();
  Size aPrefSize(pDrawingArea->get_preferred_size());
  pDrawingArea->set_size_request(aPrefSize.Width() + GetScrollWidth(), aPrefSize.Height());
560}

562void ValueSet::TurnOnScrollBar()
563{
  if (mxScrolledWindow->get_vpolicy() == VclPolicyType::ALWAYS)
      return;
  mxScrolledWindow->set_vpolicy(VclPolicyType::ALWAYS);
  weld::DrawingArea* pDrawingArea = GetDrawingArea();
  Size aPrefSize(pDrawingArea->get_preferred_size());
  pDrawingArea->set_size_request(aPrefSize.Width() - GetScrollWidth(), aPrefSize.Height());
570}

572void ValueSet::RecalcScrollBar()
573{
  // reset scrolled window state to initial value
  // so it will get configured to the right adjustment
  WinBits nStyle = GetStyle();
  if (mxScrolledWindow && (nStyle & WB_VSCROLL))
      TurnOffScrollBar();
579}

581void ValueSet::Clear()
582{
  ImplDeleteItems();

  // reset variables
  mnFirstLine     = 0;
  mnCurCol        = 0;
  mnHighItemId    = 0;
  mnSelItemId     = 0;
  mbNoSelection   = true;

  RecalcScrollBar();

  mbFormat = true;
  if ( IsReallyVisible() && IsUpdateMode() )
      Invalidate();
597}

599size_t ValueSet::GetItemCount() const
600{
  return mItemList.size();
602}

604size_t ValueSet::GetItemPos( sal_uInt16 nItemId ) const
605{
  for ( size_t i = 0, n = mItemList.size(); i < n; ++i ) {
      if ( mItemList[i]->mnId == nItemId ) {
          return i;
      }
  }
  return VALUESET_ITEM_NOTFOUND(size_t(-1));
612}

614sal_uInt16 ValueSet::GetItemId( size_t nPos ) const
615{
  return ( nPos < mItemList.size() ) ? mItemList[nPos]->mnId : 0 ;
617}

619sal_uInt16 ValueSet::GetItemId( const Point& rPos ) const
620{
  size_t nItemPos = ImplGetItem( rPos );
  if ( nItemPos != VALUESET_ITEM_NOTFOUND(size_t(-1)) )
      return GetItemId( nItemPos );

  return 0;
626}

628tools::Rectangle ValueSet::GetItemRect( sal_uInt16 nItemId ) const
629{
  const size_t nPos = GetItemPos( nItemId );

  if ( nPos!=VALUESET_ITEM_NOTFOUND(size_t(-1)) && mItemList[nPos]->mbVisible )
      return ImplGetItemRect( nPos );

  return tools::Rectangle();
636}

638tools::Rectangle ValueSet::ImplGetItemRect( size_t nPos ) const
639{
  const size_t nVisibleBegin = static_cast<size_t>(mnFirstLine)*mnCols;
  const size_t nVisibleEnd = nVisibleBegin + static_cast<size_t>(mnVisLines)*mnCols;

  // Check if the item is inside the range of the displayed ones,
  // taking into account that last row could be incomplete
  if ( nPos<nVisibleBegin || nPos>=nVisibleEnd || nPos>=mItemList.size() )
      return tools::Rectangle();

  nPos -= nVisibleBegin;

  const size_t row = mnCols ? nPos/mnCols : 0;
  const size_t col = mnCols ? nPos%mnCols : 0;
  const long x = maItemListRect.Left()+col*(mnItemWidth+mnSpacing);
  const long y = maItemListRect.Top()+row*(mnItemHeight+mnSpacing);

  return tools::Rectangle( Point(x, y), Size(mnItemWidth, mnItemHeight) );
656}

658void ValueSet::ImplHighlightItem( sal_uInt16 nItemId, bool bIsSelection )
659{
  if ( mnHighItemId == nItemId )
      return;

  // remember the old item to delete the previous selection
  mnHighItemId = nItemId;

  // don't draw the selection if nothing is selected
  if ( !bIsSelection && mbNoSelection )
      mbDrawSelection = false;

  // remove the old selection and draw the new one
  Invalidate();
  mbDrawSelection = true;
673}

675void ValueSet::ImplDraw(vcl::RenderContext& rRenderContext)
676{
  if (mbFormat)
      Format(rRenderContext);

  Point aDefPos;
  Size aSize = maVirDev->GetOutputSizePixel();

  rRenderContext.DrawOutDev(aDefPos, aSize, aDefPos, aSize, *maVirDev);

  // draw parting line to the Namefield
  if (GetStyle() & WB_NAMEFIELD(WinBits(0x00040000)))
  {
      if (!(GetStyle() & WB_FLATVALUESET(WinBits(0x02000000))))
      {
          const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
          Size aWinSize(GetOutputSizePixel());
          Point aPos1(NAME_LINE_OFF_X, mnTextOffset + NAME_LINE_OFF_Y);
          Point aPos2(aWinSize.Width() - (NAME_LINE_OFF_X * 2), mnTextOffset + NAME_LINE_OFF_Y);
          if (!(rStyleSettings.GetOptions() & StyleSettingsOptions::Mono))
          {
              rRenderContext.SetLineColor(rStyleSettings.GetShadowColor());
              rRenderContext.DrawLine(aPos1, aPos2);
              aPos1.AdjustY( 1 );
              aPos2.AdjustY( 1 );
              rRenderContext.SetLineColor(rStyleSettings.GetLightColor());
          }
          else
              rRenderContext.SetLineColor(rStyleSettings.GetWindowTextColor());
          rRenderContext.DrawLine(aPos1, aPos2);
      }
  }

  ImplDrawSelect(rRenderContext);
709}

711/**
* An inelegant method; sets the item width & height such that
* all of the included items and their labels fit; if we can
* calculate that.
*/
716void ValueSet::RecalculateItemSizes()
717{
  Size aLargestItem = GetLargestItemSize();

  if ( mnUserItemWidth != aLargestItem.Width() ||
       mnUserItemHeight != aLargestItem.Height() )
  {
      mnUserItemWidth = aLargestItem.Width();
      mnUserItemHeight = aLargestItem.Height();
      QueueReformat();
  }
727}

729void ValueSet::SetFirstLine(sal_uInt16 nNewFirstLine)
730{
  if (nNewFirstLine != mnFirstLine)
  {
      mnFirstLine = nNewFirstLine;
      if (mxScrolledWindow)
          mxScrolledWindow->vadjustment_set_value(mnFirstLine);
  }
737}

739void ValueSet::SelectItem( sal_uInt16 nItemId )
740{
  size_t nItemPos = 0;

  if ( nItemId )
  {
      nItemPos = GetItemPos( nItemId );
      if ( nItemPos == VALUESET_ITEM_NOTFOUND(size_t(-1)) )
          return;
  }

  if ( !((mnSelItemId != nItemId) || mbNoSelection) )
      return;

  const sal_uInt16 nOldItem = mnSelItemId;
  mnSelItemId = nItemId;
  mbNoSelection = false;

  bool bNewOut = !mbFormat && IsReallyVisible() && IsUpdateMode();
  bool bNewLine = false;

  if (weld::DrawingArea* pNeedsFormatToScroll = !mnCols ? GetDrawingArea() : nullptr)
  {
      Format(pNeedsFormatToScroll->get_ref_device());
      // reset scrollbar so its set to the later calculated mnFirstLine on
      // the next Format
      RecalcScrollBar(); // reset scrollbar so its set to the later calculated
  }

  // if necessary scroll to the visible area
  if (mbScroll && nItemId && mnCols)
  {
      sal_uInt16 nNewLine = static_cast<sal_uInt16>(nItemPos / mnCols);
      if ( nNewLine < mnFirstLine )
      {
          SetFirstLine(nNewLine);
          bNewLine = true;
      }
      else if ( nNewLine > o3tl::make_unsigned(mnFirstLine+mnVisLines-1) )
      {
          SetFirstLine(static_cast<sal_uInt16>(nNewLine-mnVisLines+1));
          bNewLine = true;
      }
  }

  if ( bNewOut )
  {
      if ( bNewLine )
      {
          // redraw everything if the visible area has changed
          mbFormat = true;
      }
      Invalidate();
  }

  if( !ImplHasAccessibleListeners() )
      return;

  // focus event (deselect)
  if( nOldItem )
  {
      const size_t nPos = GetItemPos( nItemId );

      if( nPos != VALUESET_ITEM_NOTFOUND(size_t(-1)) )
      {
          ValueItemAcc* pItemAcc = ValueItemAcc::getImplementation(
              mItemList[nPos]->GetAccessible( false/*bIsTransientChildrenDisabled*/ ) );

          if( pItemAcc )
          {
              Any aOldAny;
              Any aNewAny;
              aOldAny <<= Reference<XInterface>(static_cast<cppu::OWeakObject*>(pItemAcc));
              ImplFireAccessibleEvent(AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, aOldAny, aNewAny );
          }
      }
  }

  // focus event (select)
  const size_t nPos = GetItemPos( mnSelItemId );

  ValueSetItem* pItem;
  if( nPos != VALUESET_ITEM_NOTFOUND(size_t(-1)) )
      pItem = mItemList[nPos].get();
  else
      pItem = mpNoneItem.get();

  ValueItemAcc* pItemAcc = nullptr;
  if (pItem != nullptr)
      pItemAcc = ValueItemAcc::getImplementation( pItem->GetAccessible( false/*bIsTransientChildrenDisabled*/ ) );

  if( pItemAcc )
  {
      Any aOldAny;
      Any aNewAny;
      aNewAny <<= Reference<XInterface>(static_cast<cppu::OWeakObject*>(pItemAcc));
      ImplFireAccessibleEvent(AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, aOldAny, aNewAny);
  }

  // selection event
  Any aOldAny;
  Any aNewAny;
  ImplFireAccessibleEvent(AccessibleEventId::SELECTION_CHANGED, aOldAny, aNewAny);
842}

844void ValueSet::SetNoSelection()
845{
  mbNoSelection   = true;
  mbHighlight     = false;

  if (IsReallyVisible() && IsUpdateMode())
      Invalidate();
851}

853void ValueSet::SetStyle(WinBits nStyle)
854{
  if (nStyle != mnStyle)
  {
      mnStyle = nStyle;
      mbFormat = true;
      Invalidate();
  }
861}

863void ValueSet::Format(vcl::RenderContext const & rRenderContext)
864{
  Size aWinSize(GetOutputSizePixel());
  size_t nItemCount = mItemList.size();
  WinBits nStyle = GetStyle();
  long nTxtHeight = rRenderContext.GetTextHeight();
  long nOff;
  long nNoneHeight;
  long nNoneSpace;

  if (mxScrolledWindow && !(nStyle & WB_VSCROLL) && mxScrolledWindow->get_vpolicy() != VclPolicyType::NEVER)
      TurnOffScrollBar();

  // calculate item offset
  if (nStyle & WB_ITEMBORDER(WinBits(0x00010000)))
  {
      if (nStyle & WB_DOUBLEBORDER(WinBits(0x00020000)))
          nOff = ITEM_OFFSET_DOUBLE;
      else
          nOff = ITEM_OFFSET;
  }
  else
      nOff = 0;

  // consider size, if NameField does exist
  if (nStyle & WB_NAMEFIELD(WinBits(0x00040000)))
  {
      mnTextOffset = aWinSize.Height() - nTxtHeight - NAME_OFFSET;
      aWinSize.AdjustHeight( -(nTxtHeight + NAME_OFFSET) );

      if (!(nStyle & WB_FLATVALUESET(WinBits(0x02000000))))
      {
          mnTextOffset -= NAME_LINE_HEIGHT + NAME_LINE_OFF_Y;
          aWinSize.AdjustHeight( -(NAME_LINE_HEIGHT + NAME_LINE_OFF_Y) );
      }
  }
  else
      mnTextOffset = 0;

  // consider offset and size, if NoneField does exist
  if (nStyle & WB_NONEFIELD(WinBits(0x00080000)))
  {
      nNoneHeight = nTxtHeight + nOff;
      nNoneSpace = mnSpacing;
  }
  else
  {
      nNoneHeight = 0;
      nNoneSpace = 0;
      mpNoneItem.reset();
  }

  // calculate number of columns
  if (!mnUserCols)
  {
      if (mnUserItemWidth)
      {
          mnCols = static_cast<sal_uInt16>((aWinSize.Width() - mnSpacing) / (mnUserItemWidth + mnSpacing));
          if (mnCols <= 0)
              mnCols = 1;
      }
      else
      {
          mnCols = 1;
      }
  }
  else
  {
      mnCols = mnUserCols;
  }

  // calculate number of rows
  mbScroll = false;

  auto nOldLines = mnLines;
  // Floor( (M+N-1)/N )==Ceiling( M/N )
  mnLines = (static_cast<long>(nItemCount) + mnCols - 1) / mnCols;
  if (mnLines <= 0)
      mnLines = 1;

  bool bAdjustmentOutOfDate = nOldLines != mnLines;

  auto nOldVisLines = mnVisLines;

  long nCalcHeight = aWinSize.Height() - nNoneHeight;
  if (mnUserVisLines)
  {
      mnVisLines = mnUserVisLines;
  }
  else if (mnUserItemHeight)
  {
      mnVisLines = (nCalcHeight - nNoneSpace + mnSpacing) / (mnUserItemHeight + mnSpacing);
      if (!mnVisLines)
          mnVisLines = 1;
  }
  else
  {
      mnVisLines = mnLines;
  }

  bAdjustmentOutOfDate |= nOldVisLines != mnVisLines;

  if (mnLines > mnVisLines)
      mbScroll = true;

  if (mnLines <= mnVisLines)
  {
      SetFirstLine(0);
  }
  else
  {
      if (mnFirstLine > o3tl::make_unsigned(mnLines - mnVisLines))
          SetFirstLine(static_cast<sal_uInt16>(mnLines - mnVisLines));
  }

  // calculate item size
  const long nColSpace  = (mnCols - 1) * static_cast<long>(mnSpacing);
  const long nLineSpace = ((mnVisLines - 1) * mnSpacing) + nNoneSpace;
  if (mnUserItemWidth && !mnUserCols)
  {
      mnItemWidth = mnUserItemWidth;
      if (mnItemWidth > aWinSize.Width() - nColSpace)
          mnItemWidth = aWinSize.Width() - nColSpace;
  }
  else
      mnItemWidth = (aWinSize.Width() - nColSpace) / mnCols;
  if (mnUserItemHeight && !mnUserVisLines)
  {
      mnItemHeight = mnUserItemHeight;
      if (mnItemHeight > nCalcHeight - nNoneSpace)
          mnItemHeight = nCalcHeight - nNoneSpace;
  }
  else
  {
      nCalcHeight -= nLineSpace;
      mnItemHeight = nCalcHeight / mnVisLines;
  }

  // Init VirDev
  maVirDev->SetSettings(rRenderContext.GetSettings());
  maVirDev->SetOutputSizePixel(aWinSize);

  // nothing is changed in case of too small items
  if ((mnItemWidth <= 0) ||
      (mnItemHeight <= ((nStyle & WB_ITEMBORDER(WinBits(0x00010000))) ? 4 : 2)) ||
      !nItemCount)
  {
      mbHasVisibleItems = false;

      if ((nStyle & WB_NONEFIELD(WinBits(0x00080000))) && mpNoneItem)
      {
          mpNoneItem->mbVisible = false;
          mpNoneItem->maText = GetText();
      }

      for (size_t i = 0; i < nItemCount; i++)
      {
          mItemList[i]->mbVisible = false;
      }

      if (mxScrolledWindow && mxScrolledWindow->get_vpolicy() != VclPolicyType::NEVER)
          TurnOffScrollBar();
  }
  else
  {
      mbHasVisibleItems = true;

      // determine Frame-Style
      if (nStyle & WB_DOUBLEBORDER(WinBits(0x00020000)))
          mnFrameStyle = DrawFrameStyle::DoubleIn;
      else
          mnFrameStyle = DrawFrameStyle::In;

      // determine selected color and width
      // if necessary change the colors, to make the selection
      // better detectable
      const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
      Color aHighColor(rStyleSettings.GetHighlightColor());
      if (((aHighColor.GetRed() > 0x80) || (aHighColor.GetGreen() > 0x80) ||
           (aHighColor.GetBlue() > 0x80)) ||
          ((aHighColor.GetRed() == 0x80) && (aHighColor.GetGreen() == 0x80) &&
           (aHighColor.GetBlue() == 0x80)))
      {
          mbBlackSel = true;
      }
      else
      {
          mbBlackSel = false;
      }
      // draw the selection with double width if the items are bigger
      if ((nStyle & WB_DOUBLEBORDER(WinBits(0x00020000))) &&
          ((mnItemWidth >= 25) && (mnItemHeight >= 20)))
      {
          mbDoubleSel = true;
      }
      else
      {
          mbDoubleSel = false;
      }

      // calculate offsets
      long nStartX;
      long nStartY;
      if (mbFullMode)
      {
          long nAllItemWidth = (mnItemWidth * mnCols) + nColSpace;
          long nAllItemHeight = (mnItemHeight * mnVisLines) + nNoneHeight + nLineSpace;
          nStartX = (aWinSize.Width() - nAllItemWidth) / 2;
          nStartY = (aWinSize.Height() - nAllItemHeight) / 2;
      }
      else
      {
          nStartX = 0;
          nStartY = 0;
      }

      // calculate and draw items
      maVirDev->SetLineColor();
      long x = nStartX;
      long y = nStartY;

      // create NoSelection field and show it
      if (nStyle & WB_NONEFIELD(WinBits(0x00080000)))
      {
          if (!mpNoneItem)
              mpNoneItem.reset(new ValueSetItem(*this));

          mpNoneItem->mnId = 0;
          mpNoneItem->meType = VALUESETITEM_NONE;
          mpNoneItem->mbVisible = true;
          maNoneItemRect.SetLeft( x );
          maNoneItemRect.SetTop( y );
          maNoneItemRect.SetRight( maNoneItemRect.Left() + aWinSize.Width() - x - 1 );
          maNoneItemRect.SetBottom( y + nNoneHeight - 1 );

          ImplFormatItem(rRenderContext, mpNoneItem.get(), maNoneItemRect);

          y += nNoneHeight + nNoneSpace;
      }

      // draw items
      sal_uLong nFirstItem = static_cast<sal_uLong>(mnFirstLine) * mnCols;
      sal_uLong nLastItem = nFirstItem + (mnVisLines * mnCols);

      maItemListRect.SetLeft( x );
      maItemListRect.SetTop( y );
      maItemListRect.SetRight( x + mnCols * (mnItemWidth + mnSpacing) - mnSpacing - 1 );
      maItemListRect.SetBottom( y + mnVisLines * (mnItemHeight + mnSpacing) - mnSpacing - 1 );

      if (!mbFullMode)
      {
          // If want also draw parts of items in the last line,
          // then we add one more line if parts of these line are
          // visible
          if (y + (mnVisLines * (mnItemHeight + mnSpacing)) < aWinSize.Height())
              nLastItem += mnCols;
          maItemListRect.SetBottom( aWinSize.Height() - y );
      }
      for (size_t i = 0; i < nItemCount; i++)
      {
          ValueSetItem* pItem = mItemList[i].get();

          if (i >= nFirstItem && i < nLastItem)
          {
              if (!pItem->mbVisible && ImplHasAccessibleListeners())
              {
                  Any aOldAny;
                  Any aNewAny;

                  aNewAny <<= pItem->GetAccessible(false/*bIsTransientChildrenDisabled*/);
                  ImplFireAccessibleEvent(AccessibleEventId::CHILD, aOldAny, aNewAny);
              }

              pItem->mbVisible = true;
              ImplFormatItem(rRenderContext, pItem, tools::Rectangle(Point(x, y), Size(mnItemWidth, mnItemHeight)));

              if (!((i + 1) % mnCols))
              {
                  x = nStartX;
                  y += mnItemHeight + mnSpacing;
              }
              else
                  x += mnItemWidth + mnSpacing;
          }
          else
          {
              if (pItem->mbVisible && ImplHasAccessibleListeners())
              {
                  Any aOldAny;
                  Any aNewAny;

                  aOldAny <<= pItem->GetAccessible(false/*bIsTransientChildrenDisabled*/);
                  ImplFireAccessibleEvent(AccessibleEventId::CHILD, aOldAny, aNewAny);
              }

              pItem->mbVisible = false;
          }
      }

      // arrange ScrollBar, set values and show it
      if (mxScrolledWindow && (nStyle & WB_VSCROLL))
      {
          bool bTurnScrollbarOn = mxScrolledWindow->get_vpolicy() != VclPolicyType::ALWAYS;
          if (bAdjustmentOutOfDate || bTurnScrollbarOn)
          {
              long nPageSize = mnVisLines;
              if (nPageSize < 1)
                  nPageSize = 1;
              mxScrolledWindow->vadjustment_configure(mnFirstLine, 0, mnLines, 1,
                                                      mnVisLines, nPageSize);
          }

          if (bTurnScrollbarOn)
              TurnOnScrollBar();
      }
  }

  // waiting for the next since the formatting is finished
  mbFormat = false;
1182}

1184void ValueSet::ImplDrawSelect(vcl::RenderContext& rRenderContext)
1185{
  if (!IsReallyVisible())
      return;

  const bool bFocus = HasFocus();
  const bool bDrawSel = !((mbNoSelection && !mbHighlight) || (!mbDrawSelection && mbHighlight));

  if (!bFocus && !bDrawSel)
  {
      ImplDrawItemText(rRenderContext, OUString());
      return;
  }

  ImplDrawSelect(rRenderContext, mnSelItemId, bFocus, bDrawSel);
  if (mbHighlight)
  {
      ImplDrawSelect(rRenderContext, mnHighItemId, bFocus, bDrawSel);
  }
1203}

1205void ValueSet::ImplDrawSelect(vcl::RenderContext& rRenderContext, sal_uInt16 nItemId, const bool bFocus, const bool bDrawSel )
1206{
  ValueSetItem* pItem;
  tools::Rectangle aRect;
  if (nItemId)
  {
      const size_t nPos = GetItemPos( nItemId );
      pItem = mItemList[ nPos ].get();
      aRect = ImplGetItemRect( nPos );
  }
  else if (mpNoneItem)
  {
      pItem = mpNoneItem.get();
      aRect = maNoneItemRect;
  }
  else if (bFocus && (pItem = ImplGetFirstItem()))
  {
      aRect = ImplGetItemRect(0);
  }
  else
  {
      return;
  }

  if (!pItem->mbVisible)
      return;

  // draw selection
  const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
  rRenderContext.SetFillColor();

  Color aDoubleColor(rStyleSettings.GetHighlightColor());
  Color aSingleColor(rStyleSettings.GetHighlightTextColor());
  if (!mbDoubleSel)
  {
      /*
      *  #99777# contrast enhancement for thin mode
      */
      const Wallpaper& rWall = maVirDev->GetBackground();
      if (!rWall.IsBitmap() && ! rWall.IsGradient())
      {
          const Color& rBack = rWall.GetColor();
          if (rBack.IsDark() && ! aDoubleColor.IsBright())
          {
              aDoubleColor = COL_WHITE;
              aSingleColor = COL_BLACK;
          }
          else if (rBack.IsBright() && !aDoubleColor.IsDark())
          {
              aDoubleColor = COL_BLACK;
              aSingleColor = COL_WHITE;
          }
      }
  }

  // specify selection output
  WinBits nStyle = GetStyle();
  if (nStyle & WB_MENUSTYLEVALUESET(WinBits(0x08000000)))
  {
      if (bFocus)
          DrawFocusRect(rRenderContext, aRect);
      if (bDrawSel)
      {
          rRenderContext.SetLineColor(mbBlackSel ? COL_BLACK : aDoubleColor);
          rRenderContext.DrawRect(aRect);
      }
  }
  else
  {
      if (bDrawSel)
      {
          rRenderContext.SetLineColor(mbBlackSel ? COL_BLACK : aDoubleColor);
          rRenderContext.DrawRect(aRect);
      }
      if (mbDoubleSel)
      {
          aRect.AdjustLeft( 1 );
          aRect.AdjustTop( 1 );
          aRect.AdjustRight( -1 );
          aRect.AdjustBottom( -1 );
          if (bDrawSel)
              rRenderContext.DrawRect(aRect);
      }
      aRect.AdjustLeft( 1 );
      aRect.AdjustTop( 1 );
      aRect.AdjustRight( -1 );
      aRect.AdjustBottom( -1 );
      tools::Rectangle aRect2 = aRect;
      aRect.AdjustLeft( 1 );
      aRect.AdjustTop( 1 );
      aRect.AdjustRight( -1 );
      aRect.AdjustBottom( -1 );
      if (bDrawSel)
          rRenderContext.DrawRect(aRect);
      if (mbDoubleSel)
      {
          aRect.AdjustLeft( 1 );
          aRect.AdjustTop( 1 );
          aRect.AdjustRight( -1 );
          aRect.AdjustBottom( -1 );
          if (bDrawSel)
              rRenderContext.DrawRect(aRect);
      }

      if (bDrawSel)
      {
          rRenderContext.SetLineColor(mbBlackSel ? COL_WHITE : aSingleColor);
      }
      else
      {
          rRenderContext.SetLineColor(COL_LIGHTGRAY);
      }
      rRenderContext.DrawRect(aRect2);
      if (bFocus)
          DrawFocusRect(rRenderContext, aRect2);
  }

  ImplDrawItemText(rRenderContext, pItem->maText);
1323}

1325void ValueSet::ImplFormatItem(vcl::RenderContext const & rRenderContext, ValueSetItem* pItem, tools::Rectangle aRect)
1326{
  WinBits nStyle = GetStyle();
  if (nStyle & WB_ITEMBORDER(WinBits(0x00010000)))
  {
      aRect.AdjustLeft(1 );
      aRect.AdjustTop(1 );
      aRect.AdjustRight( -1 );
      aRect.AdjustBottom( -1 );

      if (nStyle & WB_FLATVALUESET(WinBits(0x02000000)))
      {
          sal_Int32 nBorder = (nStyle & WB_DOUBLEBORDER(WinBits(0x00020000))) ? 2 : 1;

          aRect.AdjustLeft(nBorder );
          aRect.AdjustTop(nBorder );
          aRect.AdjustRight( -nBorder );
          aRect.AdjustBottom( -nBorder );
      }
      else
      {
          DecorationView aView(maVirDev.get());
          aRect = aView.DrawFrame(aRect, mnFrameStyle);
      }
  }

  if (pItem == mpNoneItem.get())
      pItem->maText = GetText();

  if ((aRect.GetHeight() <= 0) || (aRect.GetWidth() <= 0))
      return;

  const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();

  if (pItem == mpNoneItem.get())
  {
      maVirDev->SetFont(rRenderContext.GetFont());
      maVirDev->SetTextColor((nStyle & WB_MENUSTYLEVALUESET(WinBits(0x08000000))) ? rStyleSettings.GetMenuTextColor() : rStyleSettings.GetWindowTextColor());
      maVirDev->SetTextFillColor();
      maVirDev->SetFillColor((nStyle & WB_MENUSTYLEVALUESET(WinBits(0x08000000))) ? rStyleSettings.GetMenuColor() : rStyleSettings.GetWindowColor());
      maVirDev->DrawRect(aRect);
      Point aTxtPos(aRect.Left() + 2, aRect.Top());
      long nTxtWidth = rRenderContext.GetTextWidth(pItem->maText);
      if ((aTxtPos.X() + nTxtWidth) > aRect.Right())
      {
          maVirDev->SetClipRegion(vcl::Region(aRect));
          maVirDev->DrawText(aTxtPos, pItem->maText);
          maVirDev->SetClipRegion();
      }
      else
          maVirDev->DrawText(aTxtPos, pItem->maText);
  }
  else if (pItem->meType == VALUESETITEM_COLOR)
  {
      maVirDev->SetFillColor(pItem->maColor);
      maVirDev->DrawRect(aRect);
  }
  else
  {
      if (IsColor())
          maVirDev->SetFillColor(maColor);
      else if (nStyle & WB_MENUSTYLEVALUESET(WinBits(0x08000000)))
          maVirDev->SetFillColor(rStyleSettings.GetMenuColor());
      else if (IsEnabled())
          maVirDev->SetFillColor(rStyleSettings.GetWindowColor());
      else
          maVirDev->SetFillColor(rStyleSettings.GetFaceColor());
      maVirDev->DrawRect(aRect);

      if (pItem->meType == VALUESETITEM_USERDRAW)
      {
          UserDrawEvent aUDEvt(nullptr, maVirDev.get(), aRect, pItem->mnId);
          UserDraw(aUDEvt);
      }
      else
      {
          Size aImageSize = pItem->maImage.GetSizePixel();
          Size  aRectSize = aRect.GetSize();
          Point aPos(aRect.Left(), aRect.Top());
          aPos.AdjustX((aRectSize.Width() - aImageSize.Width()) / 2 );

          if (pItem->meType != VALUESETITEM_IMAGE_AND_TEXT)
              aPos.AdjustY((aRectSize.Height() - aImageSize.Height()) / 2 );

          DrawImageFlags  nImageStyle  = DrawImageFlags::NONE;
          if (!IsEnabled())
              nImageStyle  |= DrawImageFlags::Disable;

          if (aImageSize.Width()  > aRectSize.Width() ||
              aImageSize.Height() > aRectSize.Height())
          {
              maVirDev->SetClipRegion(vcl::Region(aRect));
              maVirDev->DrawImage(aPos, pItem->maImage, nImageStyle);
              maVirDev->SetClipRegion();
          }
          else
              maVirDev->DrawImage(aPos, pItem->maImage, nImageStyle);

          if (pItem->meType == VALUESETITEM_IMAGE_AND_TEXT)
          {
              maVirDev->SetFont(rRenderContext.GetFont());
              maVirDev->SetTextColor((nStyle & WB_MENUSTYLEVALUESET(WinBits(0x08000000))) ? rStyleSettings.GetMenuTextColor() : rStyleSettings.GetWindowTextColor());
              maVirDev->SetTextFillColor();

              long nTxtWidth = maVirDev->GetTextWidth(pItem->maText);

              if (nTxtWidth > aRect.GetWidth())
                  maVirDev->SetClipRegion(vcl::Region(aRect));

              maVirDev->DrawText(Point(aRect.Left() +
                                       (aRect.GetWidth() - nTxtWidth) / 2,
                                       aRect.Bottom() - maVirDev->GetTextHeight()),
                                 pItem->maText);

              if (nTxtWidth > aRect.GetWidth())
                  maVirDev->SetClipRegion();
          }
      }
  }

  const sal_uInt16 nEdgeBlendingPercent(GetEdgeBlending() ? rStyleSettings.GetEdgeBlending() : 0);

  if (nEdgeBlendingPercent)
  {
      const Color& rTopLeft(rStyleSettings.GetEdgeBlendingTopLeftColor());
      const Color& rBottomRight(rStyleSettings.GetEdgeBlendingBottomRightColor());
      const sal_uInt8 nAlpha((nEdgeBlendingPercent * 255) / 100);
      const BitmapEx aBlendFrame(createBlendFrame(aRect.GetSize(), nAlpha, rTopLeft, rBottomRight));

      if (!aBlendFrame.IsEmpty())
      {
          maVirDev->DrawBitmapEx(aRect.TopLeft(), aBlendFrame);
      }
  }
1459}

1461void ValueSet::ImplDrawItemText(vcl::RenderContext& rRenderContext, const OUString& rText)
1462{
  if (!(GetStyle() & WB_NAMEFIELD(WinBits(0x00040000))))
      return;

  Size aWinSize(GetOutputSizePixel());
  long nTxtWidth = rRenderContext.GetTextWidth(rText);
  long nTxtOffset = mnTextOffset;

  // delete rectangle and show text
  if (GetStyle() & WB_FLATVALUESET(WinBits(0x02000000)))
  {
      const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
      rRenderContext.SetLineColor();
      rRenderContext.SetFillColor(rStyleSettings.GetFaceColor());
      rRenderContext.DrawRect(tools::Rectangle(Point(0, nTxtOffset), Point(aWinSize.Width(), aWinSize.Height())));
      rRenderContext.SetTextColor(rStyleSettings.GetButtonTextColor());
  }
  else
  {
      nTxtOffset += NAME_LINE_HEIGHT+NAME_LINE_OFF_Y;
      rRenderContext.SetBackground(Application::GetSettings().GetStyleSettings().GetFaceColor());
      rRenderContext.Erase(tools::Rectangle(Point(0, nTxtOffset), Point(aWinSize.Width(), aWinSize.Height())));
  }
  rRenderContext.DrawText(Point((aWinSize.Width() - nTxtWidth) / 2, nTxtOffset + (NAME_OFFSET / 2)), rText);
1486}

1488void ValueSet::StyleUpdated()
1489{
  mbFormat = true;
  CustomWidgetController::StyleUpdated();
1492}

1494void ValueSet::EnableFullItemMode( bool bFullMode )
1495{
  mbFullMode = bFullMode;
1497}

1499void ValueSet::SetColCount( sal_uInt16 nNewCols )
1500{
  if ( mnUserCols != nNewCols )
  {
      mnUserCols = nNewCols;
      QueueReformat();
  }
1506}

1508void ValueSet::SetItemImage( sal_uInt16 nItemId, const Image& rImage )
1509{
  size_t nPos = GetItemPos( nItemId );

  if ( nPos == VALUESET_ITEM_NOTFOUND(size_t(-1)) )
      return;

  ValueSetItem* pItem = mItemList[nPos].get();
  pItem->meType  = VALUESETITEM_IMAGE;
  pItem->maImage = rImage;

  if ( !mbFormat && IsReallyVisible() && IsUpdateMode() )
  {
      const tools::Rectangle aRect = ImplGetItemRect(nPos);
      Invalidate(aRect);
  }
  else
      mbFormat = true;
1526}

1528void ValueSet::SetItemColor( sal_uInt16 nItemId, const Color& rColor )
1529{
  size_t nPos = GetItemPos( nItemId );

  if ( nPos == VALUESET_ITEM_NOTFOUND(size_t(-1)) )
      return;

  ValueSetItem* pItem = mItemList[nPos].get();
  pItem->meType  = VALUESETITEM_COLOR;
  pItem->maColor = rColor;

  if ( !mbFormat && IsReallyVisible() && IsUpdateMode() )
  {
      const tools::Rectangle aRect = ImplGetItemRect(nPos);
      Invalidate( aRect );
  }
  else
      mbFormat = true;
1546}

1548Color ValueSet::GetItemColor( sal_uInt16 nItemId ) const
1549{
  size_t nPos = GetItemPos( nItemId );

  if ( nPos != VALUESET_ITEM_NOTFOUND(size_t(-1)) )
      return mItemList[nPos]->maColor;
  else
      return Color();
1556}

1558Size ValueSet::CalcWindowSizePixel( const Size& rItemSize, sal_uInt16 nDesireCols,
                                  sal_uInt16 nDesireLines ) const
1560{
  size_t nCalcCols = nDesireCols;
  size_t nCalcLines = nDesireLines;

  if ( !nCalcCols )
  {
      if ( mnUserCols )
          nCalcCols = mnUserCols;
      else
          nCalcCols = 1;
  }

  if ( !nCalcLines )
  {
      nCalcLines = mnVisLines;

      if ( mbFormat )
      {
          if ( mnUserVisLines )
              nCalcLines = mnUserVisLines;
          else
          {
              // Floor( (M+N-1)/N )==Ceiling( M/N )
              nCalcLines = (mItemList.size()+nCalcCols-1) / nCalcCols;
              if ( !nCalcLines )
                  nCalcLines = 1;
          }
      }
  }

  Size        aSize( rItemSize.Width() * nCalcCols, rItemSize.Height() * nCalcLines );
  WinBits     nStyle = GetStyle();
  long        nTxtHeight = GetTextHeight();
  long        n;

  if ( nStyle & WB_ITEMBORDER(WinBits(0x00010000)) )
  {
      if ( nStyle & WB_DOUBLEBORDER(WinBits(0x00020000)) )
          n = ITEM_OFFSET_DOUBLE;
      else
          n = ITEM_OFFSET;

      aSize.AdjustWidth(n * nCalcCols );
      aSize.AdjustHeight(n * nCalcLines );
  }
  else
      n = 0;

  if ( mnSpacing )
  {
      aSize.AdjustWidth(mnSpacing * (nCalcCols - 1) );
      aSize.AdjustHeight(mnSpacing * (nCalcLines - 1) );
  }

  if ( nStyle & WB_NAMEFIELD(WinBits(0x00040000)) )
  {
      aSize.AdjustHeight(nTxtHeight + NAME_OFFSET );
      if ( !(nStyle & WB_FLATVALUESET(WinBits(0x02000000))) )
          aSize.AdjustHeight(NAME_LINE_HEIGHT + NAME_LINE_OFF_Y );
  }

  if ( nStyle & WB_NONEFIELD(WinBits(0x00080000)) )
  {
      aSize.AdjustHeight(nTxtHeight + n + mnSpacing );
  }

  return aSize;
1627}

1629void ValueSet::InsertItem( sal_uInt16 nItemId, const Image& rImage )
1630{
  std::unique_ptr<ValueSetItem> pItem(new ValueSetItem( *this ));
  pItem->mnId     = nItemId;
  pItem->meType   = VALUESETITEM_IMAGE;
  pItem->maImage  = rImage;
  ImplInsertItem( std::move(pItem), VALUESET_APPEND(size_t(-1)) );
1636}

1638void ValueSet::InsertItem( sal_uInt16 nItemId, const Image& rImage,
                         const OUString& rText, size_t nPos,
                         bool bShowLegend )
1641{
  std::unique_ptr<ValueSetItem> pItem(new ValueSetItem( *this ));
  pItem->mnId     = nItemId;
  pItem->meType   = bShowLegend ? VALUESETITEM_IMAGE_AND_TEXT : VALUESETITEM_IMAGE;
  pItem->maImage  = rImage;
  pItem->maText   = rText;
  ImplInsertItem( std::move(pItem), nPos );
1648}

1650void ValueSet::InsertItem( sal_uInt16 nItemId, size_t nPos )
1651{
  std::unique_ptr<ValueSetItem> pItem(new ValueSetItem( *this ));
  pItem->mnId     = nItemId;
  pItem->meType   = VALUESETITEM_USERDRAW;
  ImplInsertItem( std::move(pItem), nPos );
1656}

1658void ValueSet::InsertItem( sal_uInt16 nItemId, const Color& rColor,
                         const OUString& rText )
1660{
  std::unique_ptr<ValueSetItem> pItem(new ValueSetItem( *this ));
  pItem->mnId     = nItemId;
  pItem->meType   = VALUESETITEM_COLOR;
  pItem->maColor  = rColor;
  pItem->maText   = rText;
  ImplInsertItem( std::move(pItem), VALUESET_APPEND(size_t(-1)) );
1667}

1669void ValueSet::ImplInsertItem( std::unique_ptr<ValueSetItem> pItem, const size_t nPos )
1670{
  DBG_ASSERT( pItem->mnId, "ValueSet::InsertItem(): ItemId == 0" )do { if (true && (!(pItem->mnId))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svtools/source/control/valueset.cxx"
 ":" "1671" ": "), "%s", "ValueSet::InsertItem(): ItemId == 0"
); } } while (false);
  DBG_ASSERT( GetItemPos( pItem->mnId ) == VALUESET_ITEM_NOTFOUND,do { if (true && (!(GetItemPos( pItem->mnId ) == (
size_t(-1))))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svtools/source/control/valueset.cxx"
 ":" "1673" ": "), "%s", "ValueSet::InsertItem(): ItemId already exists"
); } } while (false)
              "ValueSet::InsertItem(): ItemId already exists" )do { if (true && (!(GetItemPos( pItem->mnId ) == (
size_t(-1))))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN
), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svtools/source/control/valueset.cxx"
 ":" "1673" ": "), "%s", "ValueSet::InsertItem(): ItemId already exists"
); } } while (false);

  if ( nPos < mItemList.size() ) {
      mItemList.insert( mItemList.begin() + nPos, std::move(pItem) );
  } else {
      mItemList.push_back( std::move(pItem) );
  }

  QueueReformat();
1682}

1684int ValueSet::GetScrollWidth() const
1685{
  if (mxScrolledWindow)
      return mxScrolledWindow->get_vscroll_width();
  return 0;
1689}

1691void ValueSet::SetEdgeBlending(bool bNew)
1692{
  if(mbEdgeBlending != bNew)
  {
      mbEdgeBlending = bNew;
      mbFormat = true;

      if (GetDrawingArea() && IsReallyVisible() && IsUpdateMode())
      {
          Invalidate();
      }
  }
1703}

1705Size ValueSet::CalcItemSizePixel( const Size& rItemSize) const
1706{
  Size aSize = rItemSize;

  WinBits nStyle = GetStyle();
  if ( nStyle & WB_ITEMBORDER(WinBits(0x00010000)) )
  {
      long n;

      if ( nStyle & WB_DOUBLEBORDER(WinBits(0x00020000)) )
          n = ITEM_OFFSET_DOUBLE;
      else
          n = ITEM_OFFSET;

      aSize.AdjustWidth(n );
      aSize.AdjustHeight(n );
  }

  return aSize;
1724}

1726void ValueSet::SetLineCount( sal_uInt16 nNewLines )
1727{
  if ( mnUserVisLines != nNewLines )
  {
      mnUserVisLines = nNewLines;
      QueueReformat();
  }
1733}

1735void ValueSet::SetItemWidth( long nNewItemWidth )
1736{
  if ( mnUserItemWidth != nNewItemWidth )
  {
      mnUserItemWidth = nNewItemWidth;
      QueueReformat();
  }
1742}

1744//method to set accessible when the style is user draw.
1745void ValueSet::InsertItem( sal_uInt16 nItemId, const OUString& rText, size_t nPos  )
1746{
  DBG_ASSERT( nItemId, "ValueSet::InsertItem(): ItemId == 0" )do { if (true && (!(nItemId))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.tools"), ("/home/maarten/src/libreoffice/core/svtools/source/control/valueset.cxx"
 ":" "1747" ": "), "%s", "ValueSet::InsertItem(): ItemId == 0"
); } } while (false);
  DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND,do { if (true && (!(GetItemPos( nItemId ) == (size_t(
-1))))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), (
"legacy.tools"), ("/home/maarten/src/libreoffice/core/svtools/source/control/valueset.cxx"
 ":" "1749" ": "), "%s", "ValueSet::InsertItem(): ItemId already exists"
); } } while (false)
              "ValueSet::InsertItem(): ItemId already exists" )do { if (true && (!(GetItemPos( nItemId ) == (size_t(
-1))))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), (
"legacy.tools"), ("/home/maarten/src/libreoffice/core/svtools/source/control/valueset.cxx"
 ":" "1749" ": "), "%s", "ValueSet::InsertItem(): ItemId already exists"
); } } while (false);
  std::unique_ptr<ValueSetItem> pItem(new ValueSetItem( *this ));
  pItem->mnId     = nItemId;
  pItem->meType   = VALUESETITEM_USERDRAW;
  pItem->maText   = rText;
  ImplInsertItem( std::move(pItem), nPos );
1755}

1757void ValueSet::SetItemHeight( long nNewItemHeight )
1758{
  if ( mnUserItemHeight != nNewItemHeight )
  {
      mnUserItemHeight = nNewItemHeight;
      QueueReformat();
  }
1764}

1766OUString ValueSet::RequestHelp(tools::Rectangle& rHelpRect)
1767{
  Point aPos = rHelpRect.TopLeft();
  const size_t nItemPos = ImplGetItem( aPos );
  OUString sRet;
  if (nItemPos != VALUESET_ITEM_NOTFOUND(size_t(-1)))
  {
      rHelpRect = ImplGetItemRect(nItemPos);
      sRet = GetItemText(ImplGetItem(nItemPos)->mnId);
  }
  return sRet;
1777}

1779OUString ValueSet::GetItemText(sal_uInt16 nItemId) const
1780{
  const size_t nPos = GetItemPos(nItemId);

  if ( nPos != VALUESET_ITEM_NOTFOUND(size_t(-1)) )
      return mItemList[nPos]->maText;

  return OUString();
1787}

1789void ValueSet::SetExtraSpacing( sal_uInt16 nNewSpacing )
1790{
  if ( GetStyle() & WB_ITEMBORDER(WinBits(0x00010000)) )
  {
      mnSpacing = nNewSpacing;
      QueueReformat();
  }
1796}

1798void ValueSet::SetFormat()
1799{
  mbFormat = true;
1801}

1803void ValueSet::SetItemData( sal_uInt16 nItemId, void* pData )
1804{
  size_t nPos = GetItemPos( nItemId );

  if ( nPos == VALUESET_ITEM_NOTFOUND(size_t(-1)) )
      return;

  ValueSetItem* pItem = mItemList[nPos].get();
  pItem->mpData = pData;

  if ( pItem->meType == VALUESETITEM_USERDRAW )
  {
      if ( !mbFormat && IsReallyVisible() && IsUpdateMode() )
      {
          const tools::Rectangle aRect = ImplGetItemRect(nPos);
          Invalidate(aRect);
      }
      else
          mbFormat = true;
  }
1823}

1825void* ValueSet::GetItemData( sal_uInt16 nItemId ) const
1826{
  size_t nPos = GetItemPos( nItemId );

  if ( nPos != VALUESET_ITEM_NOTFOUND(size_t(-1)) )
      return mItemList[nPos]->mpData;
  else
      return nullptr;
1833}

1835void ValueSet::SetItemText(sal_uInt16 nItemId, const OUString& rText)
1836{
  size_t nPos = GetItemPos( nItemId );

  if ( nPos == VALUESET_ITEM_NOTFOUND(size_t(-1)) )
      return;

  ValueSetItem* pItem = mItemList[nPos].get();

  // Remember old and new name for accessibility event.
  Any aOldName;
  Any aNewName;
  OUString sString (pItem->maText);
  aOldName <<= sString;
  sString = rText;
  aNewName <<= sString;

  pItem->maText = rText;

  if (!mbFormat && IsReallyVisible() && IsUpdateMode())
  {
      sal_uInt16 nTempId = mnSelItemId;

      if (mbHighlight)
          nTempId = mnHighItemId;

      if (nTempId == nItemId)
          Invalidate();
  }

  if (ImplHasAccessibleListeners())
  {
      Reference<XAccessible> xAccessible(pItem->GetAccessible( false/*bIsTransientChildrenDisabled*/));
      ValueItemAcc* pValueItemAcc = static_cast<ValueItemAcc*>(xAccessible.get());
      pValueItemAcc->FireAccessibleEvent(AccessibleEventId::NAME_CHANGED, aOldName, aNewName);
  }
1871}

1873Size ValueSet::GetLargestItemSize()
1874{
  Size aLargestItem;

  for (const std::unique_ptr<ValueSetItem>& pItem : mItemList)
  {
      if (!pItem->mbVisible)
          continue;

      if (pItem->meType != VALUESETITEM_IMAGE &&
          pItem->meType != VALUESETITEM_IMAGE_AND_TEXT)
      {
          // handle determining an optimal size for this case
          continue;
      }

      Size aSize = pItem->maImage.GetSizePixel();
      if (pItem->meType == VALUESETITEM_IMAGE_AND_TEXT)
      {
          aSize.AdjustHeight(3 * NAME_LINE_HEIGHT +
              maVirDev->GetTextHeight() );
          aSize.setWidth( std::max(aSize.Width(),
                                   maVirDev->GetTextWidth(pItem->maText) + NAME_OFFSET) );
      }

      aLargestItem.setWidth( std::max(aLargestItem.Width(), aSize.Width()) );
      aLargestItem.setHeight( std::max(aLargestItem.Height(), aSize.Height()) );
  }

  return aLargestItem;
1903}

1905void ValueSet::SetOptimalSize()
1906{
  Size aLargestSize(GetLargestItemSize());
  aLargestSize.setWidth(std::max(aLargestSize.Width(), mnUserItemWidth));
  aLargestSize.setHeight(std::max(aLargestSize.Height(), mnUserItemHeight));
  Size aPrefSize(CalcWindowSizePixel(aLargestSize));
  GetDrawingArea()->set_size_request(aPrefSize.Width(), aPrefSize.Height());
1912}

1914Image ValueSet::GetItemImage(sal_uInt16 nItemId) const
1915{
  size_t nPos = GetItemPos( nItemId );

  if ( nPos != VALUESET_ITEM_NOTFOUND(size_t(-1)) )
      return mItemList[nPos]->maImage;
  else
      return Image();
1922}

1924void ValueSet::SetColor(const Color& rColor)
1925{
  maColor  = rColor;
  mbFormat = true;
  if (IsReallyVisible() && IsUpdateMode())
      Invalidate();
1930}

1932void ValueSet::Show()
1933{
  if (mxScrolledWindow)
      mxScrolledWindow->show();
  CustomWidgetController::Show();
1937}

1939void ValueSet::Hide()
1940{
  CustomWidgetController::Hide();
  if (mxScrolledWindow)
      mxScrolledWindow->hide();
1944}

1946FactoryFunction ValueSet::GetUITestFactory() const
1947{
  return ValueSetUIObject::create;
1949}

1951/* 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();
  }

  /** 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);
4
←
Calling copy constructor for 'Reference<VirtualDevice>'→
7
←
Returning from copy constructor for 'Reference<VirtualDevice>'→
      m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-)
8
←
Calling 'Reference::clear'→
15
←
Returning; memory was released→
      if (aTmp.get()) {
16
←
Calling 'Reference::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)
  {}

  /**
     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();
3
←
Calling 'VclPtr::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)
5
←
Assuming field 'm_pBody' is non-null→
6
←
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_pBody)
          m_pBody->release();
  }

  /** 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_pBody8.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
)
9
←
Taking true branch→
      {
          reference_type * const pOld = m_pBody;
          m_pBody = NULL__null;
          pOld->release();
10
←
Calling 'VclReferenceBase::release'→
14
←
Returning; memory was released→
      }
      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;
17
←
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)
11
←
Assuming the condition is true→
12
←
Taking true branch→
40            delete this;
13
←
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