/home/maarten/src/libreoffice/core/svtools/source/control/valueset.cxx

Bug Summary

File:	home/maarten/src/libreoffice/core/svtools/source/control/valueset.cxx
Warning:	line 395, column 40 Division by zero

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())
      xComponent->dispose();

  ImplDeleteItems();
139}

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;
3
←
Assuming the condition is true→
4
←
'?' condition is true→
5
←
Value assigned to field 'mnCols'→
6
←
Returning pointer, which participates in a condition later→
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() )
1
Assuming 'nLastItem' is not equal to 0→
2
←
Calling 'ValueSet::ImplGetFirstItem'→
7
←
Returning from 'ValueSet::ImplGetFirstItem'→
8
←
Assuming the condition is false→
9
←
Taking false branch→
      return CustomWidgetController::KeyInput(rKeyEvent);

  if (mbFormat)
10
←
Assuming field 'mbFormat' is false→
11
←
Taking false branch→
      Invalidate();

  --nLastItem;

  const size_t nCurPos
      = mnSelItemId ? GetItemPos(mnSelItemId) : (mpNoneItem ? VALUESET_ITEM_NONEITEM0xFFFE : 0);
12
←
Assuming field 'mnSelItemId' is not equal to 0→
13
←
'?' condition is true→
  size_t nItemPos = VALUESET_ITEM_NOTFOUND(size_t(-1));
  size_t nVStep = mnCols;

  switch (rKeyEvent.GetKeyCode().GetCode())
14
←
Control jumps to 'case 1025:'  at line 371→
  {
      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)
15
←
Assuming 'nCurPos' is not equal to VALUESET_ITEM_NONEITEM→
16
←
Taking true branch→
          {
              if (nCurPos == nLastItem)
17
←
Assuming 'nCurPos' is equal to 'nLastItem'→
18
←
Taking true branch→
              {
                  const size_t nCol = mnCols ? nLastItem % mnCols : 0;
19
←
Assuming field 'mnCols' is 0→
20
←
'?' condition is false→
                  if (nCol < mnCurCol)
21
←
Assuming 'nCol' is < field 'mnCurCol'→
22
←
Taking true branch→
                  {
                      // Move to previous row/page, keeping the old column
                      nVStep -= mnCurCol - nCol;
                  }
              }
              if (nCurPos >= nVStep)
23
←
Assuming 'nCurPos' is < 'nVStep'→
24
←
Taking false branch→
              {
                  // Go up of a whole page
                  nItemPos = nCurPos-nVStep;
              }
              else if (mpNoneItem)
25
←
Calling 'unique_ptr::operator bool'→
29
←
Returning from 'unique_ptr::operator bool'→
30
←
Taking false branch→
              {
                  nItemPos = VALUESET_ITEM_NONEITEM0xFFFE;
              }
              else if (nCurPos > mnCols)
31
←
Assuming 'nCurPos' is > field 'mnCols'→
32
←
Taking true branch→
              {
                  // Go to same column in first row
                  nItemPos = nCurPos % mnCols;
33
←
Division by zero
              }
          }
          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: */

←

/usr/bin/../lib/gcc/x86_64-redhat-linux/10/../../../../include/c++/10/bits/unique_ptr.h

1// unique_ptr implementation -*- C++ -*-

3// Copyright (C) 2008-2020 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/** @file bits/unique_ptr.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{memory}
*/

30#ifndef _UNIQUE_PTR_H1
31#define _UNIQUE_PTR_H1 1

33#include <bits/c++config.h>
34#include <debug/assertions.h>
35#include <type_traits>
36#include <utility>
37#include <tuple>
38#include <bits/stl_function.h>
39#include <bits/functional_hash.h>
40#if __cplusplus201703L > 201703L
41# include <compare>
42# include <ostream>
43#endif

45namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
46{
47_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup pointer_abstractions
 * @{
 */

54#if _GLIBCXX_USE_DEPRECATED1
55#pragma GCC diagnostic push
56#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
template<typename> class auto_ptr;
58#pragma GCC diagnostic pop
59#endif

/// Primary template of default_delete, used by unique_ptr for single objects
template<typename _Tp>
  struct default_delete
  {
    /// Default constructor
    constexpr default_delete() noexcept = default;

    /** @brief Converting constructor.
     *
     * Allows conversion from a deleter for objects of another type, `_Up`,
     * only if `_Up*` is convertible to `_Tp*`.
     */
    template<typename _Up,
      typename = _Require<is_convertible<_Up*, _Tp*>>>
      default_delete(const default_delete<_Up>&) noexcept { }

    /// Calls `delete __ptr`
    void
    operator()(_Tp* __ptr) const
    {
static_assert(!is_void<_Tp>::value,
      "can't delete pointer to incomplete type");
static_assert(sizeof(_Tp)>0,
      "can't delete pointer to incomplete type");
delete __ptr;
    }
  };

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 740 - omit specialization for array objects with a compile time length

/// Specialization of default_delete for arrays, used by `unique_ptr<T[]>`
template<typename _Tp>
  struct default_delete<_Tp[]>
  {
  public:
    /// Default constructor
    constexpr default_delete() noexcept = default;

    /** @brief Converting constructor.
     *
     * Allows conversion from a deleter for arrays of another type, such as
     * a const-qualified version of `_Tp`.
     *
     * Conversions from types derived from `_Tp` are not allowed because
     * it is undefined to `delete[]` an array of derived types through a
     * pointer to the base type.
     */
    template<typename _Up,
      typename = _Require<is_convertible<_Up(*)[], _Tp(*)[]>>>
      default_delete(const default_delete<_Up[]>&) noexcept { }

    /// Calls `delete[] __ptr`
    template<typename _Up>
typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
operator()(_Up* __ptr) const
{
 static_assert(sizeof(_Tp)>0,
	"can't delete pointer to incomplete type");
 delete [] __ptr;
}
  };

/// @cond undocumented

// Manages the pointer and deleter of a unique_ptr
template <typename _Tp, typename _Dp>
  class __uniq_ptr_impl
  {
    template <typename _Up, typename _Ep, typename = void>
struct _Ptr
{
 using type = _Up*;
};

    template <typename _Up, typename _Ep>
struct
_Ptr<_Up, _Ep, __void_t<typename remove_reference<_Ep>::type::pointer>>
{
 using type = typename remove_reference<_Ep>::type::pointer;
};

  public:
    using _DeleterConstraint = enable_if<
      __and_<__not_<is_pointer<_Dp>>,
      is_default_constructible<_Dp>>::value>;

    using pointer = typename _Ptr<_Tp, _Dp>::type;

    static_assert( !is_rvalue_reference<_Dp>::value,
     "unique_ptr's deleter type must be a function object type"
     " or an lvalue reference type" );

    __uniq_ptr_impl() = default;
    __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; }

    template<typename _Del>
    __uniq_ptr_impl(pointer __p, _Del&& __d)
: _M_t(__p, std::forward<_Del>(__d)) { }

    __uniq_ptr_impl(__uniq_ptr_impl&& __u) noexcept
    : _M_t(std::move(__u._M_t))
    { __u._M_ptr() = nullptr; }

    __uniq_ptr_impl& operator=(__uniq_ptr_impl&& __u) noexcept
    {
reset(__u.release());
_M_deleter() = std::forward<_Dp>(__u._M_deleter());
return *this;
    }

    pointer&   _M_ptr() { return std::get<0>(_M_t); }
    pointer    _M_ptr() const { return std::get<0>(_M_t); }
    _Dp&       _M_deleter() { return std::get<1>(_M_t); }
    const _Dp& _M_deleter() const { return std::get<1>(_M_t); }

    void reset(pointer __p) noexcept
    {
const pointer __old_p = _M_ptr();
_M_ptr() = __p;
if (__old_p)
 _M_deleter()(__old_p);
    }

    pointer release() noexcept
    {
pointer __p = _M_ptr();
_M_ptr() = nullptr;
return __p;
    }

    void
    swap(__uniq_ptr_impl& __rhs) noexcept
    {
using std::swap;
swap(this->_M_ptr(), __rhs._M_ptr());
swap(this->_M_deleter(), __rhs._M_deleter());
    }

  private:
    tuple<pointer, _Dp> _M_t;
  };

// Defines move construction + assignment as either defaulted or deleted.
template <typename _Tp, typename _Dp,
   bool = is_move_constructible<_Dp>::value,
   bool = is_move_assignable<_Dp>::value>
  struct __uniq_ptr_data : __uniq_ptr_impl<_Tp, _Dp>
  {
    using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
    __uniq_ptr_data(__uniq_ptr_data&&) = default;
    __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default;
  };

template <typename _Tp, typename _Dp>
  struct __uniq_ptr_data<_Tp, _Dp, true, false> : __uniq_ptr_impl<_Tp, _Dp>
  {
    using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
    __uniq_ptr_data(__uniq_ptr_data&&) = default;
    __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete;
  };

template <typename _Tp, typename _Dp>
  struct __uniq_ptr_data<_Tp, _Dp, false, true> : __uniq_ptr_impl<_Tp, _Dp>
  {
    using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
    __uniq_ptr_data(__uniq_ptr_data&&) = delete;
    __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default;
  };

template <typename _Tp, typename _Dp>
  struct __uniq_ptr_data<_Tp, _Dp, false, false> : __uniq_ptr_impl<_Tp, _Dp>
  {
    using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl;
    __uniq_ptr_data(__uniq_ptr_data&&) = delete;
    __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete;
  };
/// @endcond

/// 20.7.1.2 unique_ptr for single objects.
template <typename _Tp, typename _Dp = default_delete<_Tp>>
  class unique_ptr
  {
    template <typename _Up>
using _DeleterConstraint =
 typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;

    __uniq_ptr_data<_Tp, _Dp> _M_t;

  public:
    using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
    using element_type  = _Tp;
    using deleter_type  = _Dp;

  private:
    // helper template for detecting a safe conversion from another
    // unique_ptr
    template<typename _Up, typename _Ep>
using __safe_conversion_up = __and_<
 is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
 __not_<is_array<_Up>>
      >;

  public:
    // Constructors.

    /// Default constructor, creates a unique_ptr that owns nothing.
    template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
constexpr unique_ptr() noexcept
: _M_t()
{ }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     *
     * The deleter will be value-initialized.
     */
    template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p)
      { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p __d
     */
    template<typename _Del = deleter_type,
      typename = _Require<is_copy_constructible<_Del>>>
unique_ptr(pointer __p, const deleter_type& __d) noexcept
: _M_t(__p, __d) { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     * @param __d  An rvalue reference to a (non-reference) deleter.
     *
     * The deleter will be initialized with @p std::move(__d)
     */
    template<typename _Del = deleter_type,
      typename = _Require<is_move_constructible<_Del>>>
unique_ptr(pointer __p,
   __enable_if_t<!is_lvalue_reference<_Del>::value,
		 _Del&&> __d) noexcept
: _M_t(__p, std::move(__d))
{ }

    template<typename _Del = deleter_type,
      typename _DelUnref = typename remove_reference<_Del>::type>
unique_ptr(pointer,
   __enable_if_t<is_lvalue_reference<_Del>::value,
		 _DelUnref&&>) = delete;

    /// Creates a unique_ptr that owns nothing.
    template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
constexpr unique_ptr(nullptr_t) noexcept
: _M_t()
{ }

    // Move constructors.

    /// Move constructor.
    unique_ptr(unique_ptr&&) = default;

    /** @brief Converting constructor from another type
     *
     * Requires that the pointer owned by @p __u is convertible to the
     * type of pointer owned by this object, @p __u does not own an array,
     * and @p __u has a compatible deleter type.
     */
    template<typename _Up, typename _Ep, typename = _Require<
             __safe_conversion_up<_Up, _Ep>,
      typename conditional<is_reference<_Dp>::value,
		    is_same<_Ep, _Dp>,
		    is_convertible<_Ep, _Dp>>::type>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }

344#if _GLIBCXX_USE_DEPRECATED1
345#pragma GCC diagnostic push
346#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    /// Converting constructor from @c auto_ptr
    template<typename _Up, typename = _Require<
      is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
unique_ptr(auto_ptr<_Up>&& __u) noexcept;
351#pragma GCC diagnostic pop
352#endif

    /// Destructor, invokes the deleter if the stored pointer is not null.
    ~unique_ptr() noexcept
    {
static_assert(__is_invocable<deleter_type&, pointer>::value,
      "unique_ptr's deleter must be invocable with a pointer");
auto& __ptr = _M_t._M_ptr();
if (__ptr != nullptr)
 get_deleter()(std::move(__ptr));
__ptr = pointer();
    }

    // Assignment.

    /** @brief Move assignment operator.
     *
     * Invokes the deleter if this object owns a pointer.
     */
    unique_ptr& operator=(unique_ptr&&) = default;

    /** @brief Assignment from another type.
     *
     * @param __u  The object to transfer ownership from, which owns a
     *             convertible pointer to a non-array object.
     *
     * Invokes the deleter if this object owns a pointer.
     */
    template<typename _Up, typename _Ep>
      typename enable_if< __and_<
        __safe_conversion_up<_Up, _Ep>,
        is_assignable<deleter_type&, _Ep&&>
        >::value,
        unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
 reset(__u.release());
 get_deleter() = std::forward<_Ep>(__u.get_deleter());
 return *this;
}

    /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
    unique_ptr&
    operator=(nullptr_t) noexcept
    {
reset();
return *this;
    }

    // Observers.

    /// Dereference the stored pointer.
    typename add_lvalue_reference<element_type>::type
    operator*() const
    {
__glibcxx_assert(get() != pointer());
return *get();
    }

    /// Return the stored pointer.
    pointer
    operator->() const noexcept
    {
_GLIBCXX_DEBUG_PEDASSERT(get() != pointer());
return get();
    }

    /// Return the stored pointer.
    pointer
    get() const noexcept
    { return _M_t._M_ptr(); }

    /// Return a reference to the stored deleter.
    deleter_type&
    get_deleter() noexcept
    { return _M_t._M_deleter(); }

    /// Return a reference to the stored deleter.
    const deleter_type&
    get_deleter() const noexcept
    { return _M_t._M_deleter(); }

    /// Return @c true if the stored pointer is not null.
    explicit operator bool() const noexcept
    { return get() == pointer() ? false : true; }
26
←
Assuming the condition is true→
27
←
'?' condition is true→
28
←
Returning zero, which participates in a condition later→

    // Modifiers.

    /// Release ownership of any stored pointer.
    pointer
    release() noexcept
    { return _M_t.release(); }

    /** @brief Replace the stored pointer.
     *
     * @param __p  The new pointer to store.
     *
     * The deleter will be invoked if a pointer is already owned.
     */
    void
    reset(pointer __p = pointer()) noexcept
    {
static_assert(__is_invocable<deleter_type&, pointer>::value,
      "unique_ptr's deleter must be invocable with a pointer");
_M_t.reset(std::move(__p));
    }

    /// Exchange the pointer and deleter with another object.
    void
    swap(unique_ptr& __u) noexcept
    {
static_assert(__is_swappable<_Dp>::value, "deleter must be swappable");
_M_t.swap(__u._M_t);
    }

    // Disable copy from lvalue.
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
};

/// 20.7.1.3 unique_ptr for array objects with a runtime length
// [unique.ptr.runtime]
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 740 - omit specialization for array objects with a compile time length
template<typename _Tp, typename _Dp>
  class unique_ptr<_Tp[], _Dp>
  {
    template <typename _Up>
    using _DeleterConstraint =
typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;

    __uniq_ptr_data<_Tp, _Dp> _M_t;

    template<typename _Up>
using __remove_cv = typename remove_cv<_Up>::type;

    // like is_base_of<_Tp, _Up> but false if unqualified types are the same
    template<typename _Up>
using __is_derived_Tp
 = __and_< is_base_of<_Tp, _Up>,
    __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;

  public:
    using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
    using element_type  = _Tp;
    using deleter_type  = _Dp;

    // helper template for detecting a safe conversion from another
    // unique_ptr
    template<typename _Up, typename _Ep,
             typename _UPtr = unique_ptr<_Up, _Ep>,
      typename _UP_pointer = typename _UPtr::pointer,
      typename _UP_element_type = typename _UPtr::element_type>
using __safe_conversion_up = __and_<
        is_array<_Up>,
        is_same<pointer, element_type*>,
        is_same<_UP_pointer, _UP_element_type*>,
        is_convertible<_UP_element_type(*)[], element_type(*)[]>
      >;

    // helper template for detecting a safe conversion from a raw pointer
    template<typename _Up>
      using __safe_conversion_raw = __and_<
        __or_<__or_<is_same<_Up, pointer>,
                    is_same<_Up, nullptr_t>>,
              __and_<is_pointer<_Up>,
                     is_same<pointer, element_type*>,
                     is_convertible<
                       typename remove_pointer<_Up>::type(*)[],
                       element_type(*)[]>
              >
        >
      >;

    // Constructors.

    /// Default constructor, creates a unique_ptr that owns nothing.
    template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
constexpr unique_ptr() noexcept
: _M_t()
{ }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     *
     * The deleter will be value-initialized.
     */
    template<typename _Up,
      typename _Vp = _Dp,
      typename = _DeleterConstraint<_Vp>,
      typename = typename enable_if<
               __safe_conversion_raw<_Up>::value, bool>::type>
explicit
unique_ptr(_Up __p) noexcept
: _M_t(__p)
      { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p __d
     */
    template<typename _Up, typename _Del = deleter_type,
      typename = _Require<__safe_conversion_raw<_Up>,
		   is_copy_constructible<_Del>>>
    unique_ptr(_Up __p, const deleter_type& __d) noexcept
    : _M_t(__p, __d) { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p std::move(__d)
     */
    template<typename _Up, typename _Del = deleter_type,
      typename = _Require<__safe_conversion_raw<_Up>,
		   is_move_constructible<_Del>>>
unique_ptr(_Up __p,
   __enable_if_t<!is_lvalue_reference<_Del>::value,
		 _Del&&> __d) noexcept
: _M_t(std::move(__p), std::move(__d))
{ }

    template<typename _Up, typename _Del = deleter_type,
      typename _DelUnref = typename remove_reference<_Del>::type,
      typename = _Require<__safe_conversion_raw<_Up>>>
unique_ptr(_Up,
   __enable_if_t<is_lvalue_reference<_Del>::value,
		 _DelUnref&&>) = delete;

    /// Move constructor.
    unique_ptr(unique_ptr&&) = default;

    /// Creates a unique_ptr that owns nothing.
    template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
constexpr unique_ptr(nullptr_t) noexcept
: _M_t()
      { }

    template<typename _Up, typename _Ep, typename = _Require<
      __safe_conversion_up<_Up, _Ep>,
      typename conditional<is_reference<_Dp>::value,
		    is_same<_Ep, _Dp>,
		    is_convertible<_Ep, _Dp>>::type>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }

    /// Destructor, invokes the deleter if the stored pointer is not null.
    ~unique_ptr()
    {
auto& __ptr = _M_t._M_ptr();
if (__ptr != nullptr)
 get_deleter()(__ptr);
__ptr = pointer();
    }

    // Assignment.

    /** @brief Move assignment operator.
     *
     * Invokes the deleter if this object owns a pointer.
     */
    unique_ptr&
    operator=(unique_ptr&&) = default;

    /** @brief Assignment from another type.
     *
     * @param __u  The object to transfer ownership from, which owns a
     *             convertible pointer to an array object.
     *
     * Invokes the deleter if this object owns a pointer.
     */
    template<typename _Up, typename _Ep>
typename
enable_if<__and_<__safe_conversion_up<_Up, _Ep>,
                       is_assignable<deleter_type&, _Ep&&>
                >::value,
                unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
 reset(__u.release());
 get_deleter() = std::forward<_Ep>(__u.get_deleter());
 return *this;
}

    /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
    unique_ptr&
    operator=(nullptr_t) noexcept
    {
reset();
return *this;
    }

    // Observers.

    /// Access an element of owned array.
    typename std::add_lvalue_reference<element_type>::type
    operator[](size_t __i) const
    {
__glibcxx_assert(get() != pointer());
return get()[__i];
    }

    /// Return the stored pointer.
    pointer
    get() const noexcept
    { return _M_t._M_ptr(); }

    /// Return a reference to the stored deleter.
    deleter_type&
    get_deleter() noexcept
    { return _M_t._M_deleter(); }

    /// Return a reference to the stored deleter.
    const deleter_type&
    get_deleter() const noexcept
    { return _M_t._M_deleter(); }

    /// Return @c true if the stored pointer is not null.
    explicit operator bool() const noexcept
    { return get() == pointer() ? false : true; }

    // Modifiers.

    /// Release ownership of any stored pointer.
    pointer
    release() noexcept
    { return _M_t.release(); }

    /** @brief Replace the stored pointer.
     *
     * @param __p  The new pointer to store.
     *
     * The deleter will be invoked if a pointer is already owned.
     */
    template <typename _Up,
              typename = _Require<
                __or_<is_same<_Up, pointer>,
                      __and_<is_same<pointer, element_type*>,
                             is_pointer<_Up>,
                             is_convertible<
                               typename remove_pointer<_Up>::type(*)[],
                               element_type(*)[]
                             >
                      >
                >
             >>
    void
    reset(_Up __p) noexcept
    { _M_t.reset(std::move(__p)); }

    void reset(nullptr_t = nullptr) noexcept
    { reset(pointer()); }

    /// Exchange the pointer and deleter with another object.
    void
    swap(unique_ptr& __u) noexcept
    {
static_assert(__is_swappable<_Dp>::value, "deleter must be swappable");
_M_t.swap(__u._M_t);
    }

    // Disable copy from lvalue.
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
  };

/// @relates unique_ptr @{

/// Swap overload for unique_ptr
template<typename _Tp, typename _Dp>
  inline
732#if __cplusplus201703L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
  // Constrained free swap overload, see p0185r1
  typename enable_if<__is_swappable<_Dp>::value>::type
735#else
  void
737#endif
  swap(unique_ptr<_Tp, _Dp>& __x,
unique_ptr<_Tp, _Dp>& __y) noexcept
  { __x.swap(__y); }

742#if __cplusplus201703L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
template<typename _Tp, typename _Dp>
  typename enable_if<!__is_swappable<_Dp>::value>::type
  swap(unique_ptr<_Tp, _Dp>&,
unique_ptr<_Tp, _Dp>&) = delete;
747#endif

/// Equality operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator==(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return __x.get() == __y.get(); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
  { return !__x; }

763#ifndef __cpp_lib_three_way_comparison
/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
  { return !__x; }

/// Inequality operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator!=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return __x.get() != __y.get(); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
  { return (bool)__x; }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
  { return (bool)__x; }
789#endif // three way comparison

/// Relational operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<(const unique_ptr<_Tp, _Dp>& __x,
     const unique_ptr<_Up, _Ep>& __y)
  {
    typedef typename
std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
                typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
    return std::less<_CT>()(__x.get(), __y.get());
  }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  {
    return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
						 nullptr);
  }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  {
    return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
						 __x.get());
  }

/// Relational operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return !(__y < __x); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  { return !(nullptr < __x); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  { return !(__x < nullptr); }

/// Relational operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>(const unique_ptr<_Tp, _Dp>& __x,
     const unique_ptr<_Up, _Ep>& __y)
  { return (__y < __x); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  {
    return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
						 __x.get());
  }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  {
    return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
						 nullptr);
  }

/// Relational operator for unique_ptr objects, compares the owned pointers
template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return !(__x < __y); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  { return !(__x < nullptr); }

/// unique_ptr comparison with nullptr
template<typename _Tp, typename _Dp>
  _GLIBCXX_NODISCARD[[__nodiscard__]] inline bool
  operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  { return !(nullptr < __x); }

888#ifdef __cpp_lib_three_way_comparison
template<typename _Tp, typename _Dp, typename _Up, typename _Ep>
  requires three_way_comparable_with<typename unique_ptr<_Tp, _Dp>::pointer,
		       typename unique_ptr<_Up, _Ep>::pointer>
  inline
  compare_three_way_result_t<typename unique_ptr<_Tp, _Dp>::pointer,
	       typename unique_ptr<_Up, _Ep>::pointer>
  operator<=>(const unique_ptr<_Tp, _Dp>& __x,
const unique_ptr<_Up, _Ep>& __y)
  { return compare_three_way()(__x.get(), __y.get()); }

template<typename _Tp, typename _Dp>
  requires three_way_comparable<typename unique_ptr<_Tp, _Dp>::pointer>
  inline
  compare_three_way_result_t<typename unique_ptr<_Tp, _Dp>::pointer>
  operator<=>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  {
    using pointer = typename unique_ptr<_Tp, _Dp>::pointer;
    return compare_three_way()(__x.get(), static_cast<pointer>(nullptr));
  }
908#endif
// @} relates unique_ptr

/// @cond undocumented
template<typename _Up, typename _Ptr = typename _Up::pointer,
  bool = __poison_hash<_Ptr>::__enable_hash_call>
  struct __uniq_ptr_hash
915#if ! _GLIBCXX_INLINE_VERSION0
  : private __poison_hash<_Ptr>
917#endif
  {
    size_t
    operator()(const _Up& __u) const
    noexcept(noexcept(std::declval<hash<_Ptr>>()(std::declval<_Ptr>())))
    { return hash<_Ptr>()(__u.get()); }
  };

template<typename _Up, typename _Ptr>
  struct __uniq_ptr_hash<_Up, _Ptr, false>
  : private __poison_hash<_Ptr>
  { };
/// @endcond

/// std::hash specialization for unique_ptr.
template<typename _Tp, typename _Dp>
  struct hash<unique_ptr<_Tp, _Dp>>
  : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>,
    public __uniq_ptr_hash<unique_ptr<_Tp, _Dp>>
  { };

938#if __cplusplus201703L >= 201402L
/// @relates unique_ptr @{
940#define __cpp_lib_make_unique201304 201304

/// @cond undocumented

template<typename _Tp>
  struct _MakeUniq
  { typedef unique_ptr<_Tp> __single_object; };

template<typename _Tp>
  struct _MakeUniq<_Tp[]>
  { typedef unique_ptr<_Tp[]> __array; };

template<typename _Tp, size_t _Bound>
  struct _MakeUniq<_Tp[_Bound]>
  { struct __invalid_type { }; };

/// @endcond

/// std::make_unique for single objects
template<typename _Tp, typename... _Args>
  inline typename _MakeUniq<_Tp>::__single_object
  make_unique(_Args&&... __args)
  { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }

/// std::make_unique for arrays of unknown bound
template<typename _Tp>
  inline typename _MakeUniq<_Tp>::__array
  make_unique(size_t __num)
  { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }

/// Disable std::make_unique for arrays of known bound
template<typename _Tp, typename... _Args>
  inline typename _MakeUniq<_Tp>::__invalid_type
  make_unique(_Args&&...) = delete;
// @} relates unique_ptr
975#endif // C++14

977#if __cplusplus201703L > 201703L && __cpp_concepts
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// 2948. unique_ptr does not define operator<< for stream output
/// Stream output operator for unique_ptr
template<typename _CharT, typename _Traits, typename _Tp, typename _Dp>
  inline basic_ostream<_CharT, _Traits>&
  operator<<(basic_ostream<_CharT, _Traits>& __os,
      const unique_ptr<_Tp, _Dp>& __p)
  requires requires { __os << __p.get(); }
  {
    __os << __p.get();
    return __os;
  }
990#endif // C++20

// @} group pointer_abstractions

994#if __cplusplus201703L >= 201703L
namespace __detail::__variant
{
  template<typename> struct _Never_valueless_alt; // see <variant>

  // Provide the strong exception-safety guarantee when emplacing a
  // unique_ptr into a variant.
  template<typename _Tp, typename _Del>
    struct _Never_valueless_alt<std::unique_ptr<_Tp, _Del>>
    : std::true_type
    { };
}  // namespace __detail::__variant
1006#endif // C++17

1008_GLIBCXX_END_NAMESPACE_VERSION
1009} // namespace

1011#endif /* _UNIQUE_PTR_H */