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

Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

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

/home/maarten/src/libreoffice/core/sc/source/ui/app/inputwin.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 <memory>
21#include <algorithm>

23#include <editeng/eeitem.hxx>

25#include <sfx2/app.hxx>
26#include <editeng/adjustitem.hxx>
27#include <editeng/editview.hxx>
28#include <editeng/editstat.hxx>
29#include <editeng/lspcitem.hxx>
30#include <editeng/fhgtitem.hxx>
31#include <editeng/wghtitem.hxx>
32#include <editeng/postitem.hxx>
33#include <editeng/langitem.hxx>
34#include <sfx2/bindings.hxx>
35#include <sfx2/lokhelper.hxx>
36#include <sfx2/viewfrm.hxx>
37#include <sfx2/dispatch.hxx>
38#include <sfx2/event.hxx>
39#include <editeng/scriptspaceitem.hxx>
40#include <vcl/commandevent.hxx>
41#include <vcl/cursor.hxx>
42#include <vcl/help.hxx>
43#include <vcl/settings.hxx>
44#include <svl/stritem.hxx>
45#include <vcl/svapp.hxx>
46#include <vcl/weldutils.hxx>
47#include <unotools/charclass.hxx>

49#include <inputwin.hxx>
50#include <scmod.hxx>
51#include <global.hxx>
52#include <scresid.hxx>
53#include <strings.hrc>
54#include <globstr.hrc>
55#include <bitmaps.hlst>
56#include <reffact.hxx>
57#include <editutil.hxx>
58#include <inputhdl.hxx>
59#include <tabvwsh.hxx>
60#include <document.hxx>
61#include <docsh.hxx>
62#include <appoptio.hxx>
63#include <rangenam.hxx>
64#include <rangeutl.hxx>
65#include <docfunc.hxx>
66#include <funcdesc.hxx>
67#include <editeng/fontitem.hxx>
68#include <AccessibleEditObject.hxx>
69#include <AccessibleText.hxx>
70#include <comphelper/lok.hxx>
71#include <comphelper/string.hxx>
72#include <com/sun/star/frame/XLayoutManager.hpp>
73#include <helpids.h>
74#include <output.hxx>

76namespace com::sun::star::accessibility { class XAccessible; }

78const long THESIZE = 1000000;            // Should be more than enough!
79const long INPUTLINE_INSET_MARGIN = 2;   // Space between border and interior widgets of input line
80const long LEFT_OFFSET = 5;              // Left offset of input line
81const long BUTTON_OFFSET = 2;            // Space between input line and button to expand/collapse
82const long MULTILINE_BUTTON_WIDTH = 20;  // Width of the button which opens multiline dropdown
83const long INPUTWIN_MULTILINES = 6;      // Initial number of lines within multiline dropdown
84const long TOOLBOX_WINDOW_HEIGHT = 22;   // Height of toolbox window in pixels - TODO: The same on all systems?
85const long POSITION_COMBOBOX_WIDTH = 18; // Width of position combobox in characters

87using com::sun::star::uno::Reference;
88using com::sun::star::uno::UNO_QUERY;

90using com::sun::star::frame::XLayoutManager;
91using com::sun::star::beans::XPropertySet;

93namespace {

95enum ScNameInputType
96{
  SC_NAME_INPUT_CELL,
  SC_NAME_INPUT_RANGE,
  SC_NAME_INPUT_NAMEDRANGE,
  SC_NAME_INPUT_DATABASE,
  SC_NAME_INPUT_ROW,
  SC_NAME_INPUT_SHEET,
  SC_NAME_INPUT_DEFINE,
  SC_NAME_INPUT_BAD_NAME,
  SC_NAME_INPUT_BAD_SELECTION,
  SC_MANAGE_NAMES
107};

109}

111ScTextWndBase::ScTextWndBase( vcl::Window* pParent,  WinBits nStyle )
  : Window ( pParent, nStyle )
113{
  if ( IsNativeControlSupported( ControlType::Editbox, ControlPart::Entire ) )
  {
      SetType( WindowType::CALCINPUTLINE );
      SetBorderStyle( WindowBorderStyle::NWF );
  }
119}


122SFX_IMPL_CHILDWINDOW_WITHID(ScInputWindowWrapper,FID_INPUTLINE_STATUS)std::unique_ptr<SfxChildWindow> ScInputWindowWrapper::CreateImpl
( vcl::Window *pParent, sal_uInt16 nId, SfxBindings *pBindings
, SfxChildWinInfo* pInfo ) { return std::make_unique<ScInputWindowWrapper
>(pParent, nId, pBindings, pInfo); } void ScInputWindowWrapper
::RegisterChildWindow (bool bVis, SfxModule *pMod, SfxChildWindowFlags
 nFlags) { auto pFact = std::make_unique<SfxChildWinFactory
>( ScInputWindowWrapper::CreateImpl, ((26000 + 100)), (32767
 *2 +1) ); pFact->aInfo.nFlags |= nFlags; pFact->aInfo.
bVisible = bVis; SfxChildWindow::RegisterChildWindow(pMod, std
::move(pFact)); } sal_uInt16 ScInputWindowWrapper::GetChildWindowId
 () { return ((26000 + 100)); }
1
Calling 'make_unique<ScInputWindowWrapper, vcl::Window *&, unsigned short &, SfxBindings *&, SfxChildWinInfo *&>'→

124ScInputWindowWrapper::ScInputWindowWrapper( vcl::Window*          pParentP,
                                          sal_uInt16           nId,
                                          SfxBindings*     pBindings,
                                          SfxChildWinInfo* /* pInfo */ )
  :   SfxChildWindow( pParentP, nId )
129{
  VclPtr<ScInputWindow> pWin = VclPtr<ScInputWindow>::Create( pParentP, pBindings );
3
←
Calling 'VclPtr::Create'→
5
←
Returned allocated memory→
  SetWindow( pWin );
6
←
Calling implicit destructor for 'VclPtr<vcl::Window>'→
7
←
Calling '~Reference'→
14
←
Returning from '~Reference'→
15
←
Returning from destructor for 'VclPtr<vcl::Window>'→

  pWin->Show();
16
←
Calling 'VclPtr::operator->'→

  pWin->SetSizePixel( pWin->CalcWindowSizePixel() );

  SetAlignment(SfxChildAlignment::LOWESTTOP);
  pBindings->Invalidate( FID_TOGGLEINPUTLINE((((((26000 + 200) + 20)) + 20)) + 1) );
139}

141/**
* GetInfo is disposed of if there's a SFX_IMPL_TOOLBOX!
*/
144SfxChildWinInfo ScInputWindowWrapper::GetInfo() const
145{
  SfxChildWinInfo aInfo = SfxChildWindow::GetInfo();
  return aInfo;
148}


151static VclPtr<ScInputBarGroup> lcl_chooseRuntimeImpl( vcl::Window* pParent, const SfxBindings* pBind )
152{
  ScTabViewShell* pViewSh = nullptr;
  SfxDispatcher* pDisp = pBind->GetDispatcher();
  if ( pDisp )
  {
      SfxViewFrame* pViewFrm = pDisp->GetFrame();
      if ( pViewFrm )
          pViewSh = dynamic_cast<ScTabViewShell*>( pViewFrm->GetViewShell()  );
  }

  return VclPtr<ScInputBarGroup>::Create( pParent, pViewSh );
163}

165ScInputWindow::ScInputWindow( vcl::Window* pParent, const SfxBindings* pBind ) :
      // With WB_CLIPCHILDREN otherwise we get flickering
      ToolBox         ( pParent, WinBits(WB_CLIPCHILDREN | WB_BORDER | WB_NOSHADOW) ),
      aWndPos         ( VclPtr<ScPosWnd>::Create(this) ),
      pRuntimeWindow  ( lcl_chooseRuntimeImpl( this, pBind ) ),
      aTextWindow     ( *pRuntimeWindow ),
      pInputHdl       ( nullptr ),
      mpViewShell     ( nullptr ),
      mnMaxY          (0),
      bIsOkCancelMode ( false ),
      bInResize       ( false )
176{
  // #i73615# don't rely on SfxViewShell::Current while constructing the input line
  // (also for GetInputHdl below)
  ScTabViewShell* pViewSh = nullptr;
  SfxDispatcher* pDisp = pBind->GetDispatcher();
  if ( pDisp )
  {
      SfxViewFrame* pViewFrm = pDisp->GetFrame();
      if ( pViewFrm )
          pViewSh = dynamic_cast<ScTabViewShell*>( pViewFrm->GetViewShell()  );
  }
  OSL_ENSURE( pViewSh, "no view shell for input window" )do { if (true && (!(pViewSh))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/ui/app/inputwin.cxx"
 ":" "187" ": "), "%s", "no view shell for input window"); } }
 while (false);

  mpViewShell = pViewSh;

  // Position window, 3 buttons, input window
  if (!comphelper::LibreOfficeKit::isActive())
  {
      InsertWindow    (1, aWndPos.get(), ToolBoxItemBits::NONE, 0);
      InsertSeparator (1);
      InsertItem      (SID_INPUT_FUNCTION((26000) + 47), Image(StockImage::Yes, RID_BMP_INPUT_FUNCTION"sc/res/sc26047.png"), ToolBoxItemBits::NONE, 2);
  }

  const bool bIsLOKMobilePhone = mpViewShell && mpViewShell->isLOKMobilePhone();

  // sigma and equal buttons
  if (!bIsLOKMobilePhone)
  {
      InsertItem      (SID_INPUT_SUM((26000) + 48),      Image(StockImage::Yes, RID_BMP_INPUT_SUM"sc/res/sc26048.png"), ToolBoxItemBits::DROPDOWNONLY, 3);
      InsertItem      (SID_INPUT_EQUAL((26000) + 49),    Image(StockImage::Yes, RID_BMP_INPUT_EQUAL"sc/res/sc26049.png"), ToolBoxItemBits::NONE, 4);
      InsertItem      (SID_INPUT_CANCEL((26000) + 50),   Image(StockImage::Yes, RID_BMP_INPUT_CANCEL"sc/res/sc26050.png"), ToolBoxItemBits::NONE, 5);
      InsertItem      (SID_INPUT_OK((26000) + 51),       Image(StockImage::Yes, RID_BMP_INPUT_OK"sc/res/sc26051.png"), ToolBoxItemBits::NONE, 6);
  }

  InsertWindow    (7, &aTextWindow, ToolBoxItemBits::NONE, 7);
  SetDropdownClickHdl( LINK( this, ScInputWindow, DropdownClickHdl )::tools::detail::makeLink( ::tools::detail::castTo<ScInputWindow
 *>(this), &ScInputWindow::LinkStubDropdownClickHdl));

  if (!comphelper::LibreOfficeKit::isActive())
  {
      aWndPos   ->SetQuickHelpText(ScResId(SCSTR_QHELP_POSWNDreinterpret_cast<char const *>("SCSTR_QHELP_POSWND" "\004"
 u8"Name Box")));
      aWndPos   ->SetHelpId       (HID_INSWIN_POS"SC_HID_INSWIN_POS");
  }
  aTextWindow.SetQuickHelpText(ScResId(SCSTR_QHELP_INPUTWNDreinterpret_cast<char const *>("SCSTR_QHELP_INPUTWND" "\004"
 u8"Input line")));
  aTextWindow.SetHelpId       (HID_INSWIN_INPUT"SC_HID_INSWIN_INPUT");

  if (!comphelper::LibreOfficeKit::isActive())
  {
      // No SetHelpText: the helptexts come from the Help
      SetItemText (SID_INPUT_FUNCTION((26000) + 47), ScResId(SCSTR_QHELP_BTNCALCreinterpret_cast<char const *>("SCSTR_QHELP_BTNCALC" "\004"
 u8"Function Wizard")));
      SetHelpId   (SID_INPUT_FUNCTION((26000) + 47), HID_INSWIN_CALC"SC_HID_INSWIN_CALC");
  }

  // sigma and equal buttons
  if (!bIsLOKMobilePhone)
  {
      SetItemText (SID_INPUT_SUM((26000) + 48), ScResId( SCSTR_QHELP_BTNSUMreinterpret_cast<char const *>("SCSTR_QHELP_BTNSUM" "\004"
 u8"Select Function") ) );
      SetHelpId   (SID_INPUT_SUM((26000) + 48), HID_INSWIN_SUMME"SC_HID_INSWIN_SUMME");

      SetItemText (SID_INPUT_EQUAL((26000) + 49), ScResId( SCSTR_QHELP_BTNEQUALreinterpret_cast<char const *>("SCSTR_QHELP_BTNEQUAL" "\004"
 u8"Formula") ) );
      SetHelpId   (SID_INPUT_EQUAL((26000) + 49), HID_INSWIN_FUNC"SC_HID_INSWIN_FUNC");

      SetItemText ( SID_INPUT_CANCEL((26000) + 50), ScResId( SCSTR_QHELP_BTNCANCELreinterpret_cast<char const *>("SCSTR_QHELP_BTNCANCEL" "\004"
 u8"Cancel") ) );
      SetHelpId   ( SID_INPUT_CANCEL((26000) + 50), HID_INSWIN_CANCEL"SC_HID_INSWIN_CANCEL" );

      SetItemText ( SID_INPUT_OK((26000) + 51), ScResId( SCSTR_QHELP_BTNOKreinterpret_cast<char const *>("SCSTR_QHELP_BTNOK" "\004"
 u8"Accept") ) );
      SetHelpId   ( SID_INPUT_OK((26000) + 51), HID_INSWIN_OK"SC_HID_INSWIN_OK" );

      EnableItem( SID_INPUT_CANCEL((26000) + 50), false );
      EnableItem( SID_INPUT_OK((26000) + 51), false );

      HideItem( SID_INPUT_CANCEL((26000) + 50) );
      HideItem( SID_INPUT_OK((26000) + 51) );
  }

  SetHelpId( HID_SC_INPUTWIN"SC_HID_SC_INPUTWIN" ); // For the whole input row

  if (!comphelper::LibreOfficeKit::isActive())
      aWndPos   ->Show();
  aTextWindow.Show();

  pInputHdl = SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) )->GetInputHdl( pViewSh, false ); // use own handler even if ref-handler is set
  if (pInputHdl)
      pInputHdl->SetInputWindow( this );

  if (pInputHdl && !pInputHdl->GetFormString().isEmpty())
  {
      // Switch over while the Function AutoPilot is active
      // -> show content of the Function AutoPilot again
      // Also show selection (remember at the InputHdl)
      aTextWindow.SetTextString( pInputHdl->GetFormString() );
  }
  else if (pInputHdl && pInputHdl->IsInputMode())
  {
      // If the input row was hidden while editing (e.g. when editing a formula
      // and then switching to another document or the help), display the text
      // we just edited from the InputHandler
      aTextWindow.SetTextString( pInputHdl->GetEditString() ); // Display text
      if ( pInputHdl->IsTopMode() )
          pInputHdl->SetMode( SC_INPUT_TABLE ); // Focus ends up at the bottom anyways
  }
  else if (pViewSh)
  {
      // Don't stop editing in LOK a remote user might be editing.
      const bool bStopEditing = !comphelper::LibreOfficeKit::isActive();
      pViewSh->UpdateInputHandler(true, bStopEditing); // Absolutely necessary update
  }

  SetToolbarLayoutMode( ToolBoxLayoutMode::Locked );

  SetAccessibleName(ScResId(STR_ACC_TOOLBAR_FORMULAreinterpret_cast<char const *>("STR_ACC_TOOLBAR_FORMULA"
 "\004" u8"Formula Tool Bar")));
286}

288ScInputWindow::~ScInputWindow()
289{
  disposeOnce();
291}

293void ScInputWindow::dispose()
294{
  bool bDown = !ScGlobal::xSysLocale; // after Clear?

  //  if any view's input handler has a pointer to this input window, reset it
  //  (may be several ones, #74522#)
  //  member pInputHdl is not used here

  if ( !bDown )
  {
      SfxViewShell* pSh = SfxViewShell::GetFirst( true, checkSfxViewShell<ScTabViewShell> );
      while ( pSh )
      {
          ScInputHandler* pHdl = static_cast<ScTabViewShell*>(pSh)->GetInputHandler();
          if ( pHdl && pHdl->GetInputWindow() == this )
          {
              pHdl->SetInputWindow( nullptr );
              pHdl->StopInputWinEngine( false );  // reset pTopView pointer
          }
          pSh = SfxViewShell::GetNext( *pSh, true, checkSfxViewShell<ScTabViewShell> );
      }
  }

  if (comphelper::LibreOfficeKit::isActive())
  {
      if(const vcl::ILibreOfficeKitNotifier* pNotifier = GetLOKNotifier())
      {
          pNotifier->notifyWindow(GetLOKWindowId(), "close");
          ReleaseLOKNotifier();
      }
  }

  pRuntimeWindow.disposeAndClear();
  aWndPos.disposeAndClear();

  ToolBox::dispose();
329}

331void ScInputWindow::SetInputHandler( ScInputHandler* pNew )
332{
  //  Is called in the Activate of the View ...
  if ( pNew != pInputHdl )
  {
      // On Reload (last version) the pInputHdl is the InputHandler of the old, deleted
      // ViewShell: so don't touch it here!
      pInputHdl = pNew;
      if (pInputHdl)
          pInputHdl->SetInputWindow( this );
  }
342}

344void ScInputWindow::Select()
345{
  ScModule* pScMod = SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) );
  ToolBox::Select();

  switch ( GetCurItemId() )
  {
      case SID_INPUT_FUNCTION((26000) + 47):
          {
              //! new method at ScModule to query if function autopilot is open
              SfxViewFrame* pViewFrm = SfxViewFrame::Current();
              if ( pViewFrm && ( comphelper::LibreOfficeKit::isActive() || !pViewFrm->GetChildWindow( SID_OPENDLG_FUNCTION((26000 + 100) + 52) ) ) )
              {
                  pViewFrm->GetDispatcher()->Execute( SID_OPENDLG_FUNCTION((26000 + 100) + 52),
                                            SfxCallMode::SYNCHRON | SfxCallMode::RECORD );

                  // The Toolbox will be disabled anyways, so we don't need to switch here,
                  // regardless whether it succeeded or not!
362//                  SetOkCancelMode();
              }
          }
          break;

      case SID_INPUT_CANCEL((26000) + 50):
          pScMod->InputCancelHandler();
          SetSumAssignMode();
          break;

      case SID_INPUT_OK((26000) + 51):
          pScMod->InputEnterHandler();
          SetSumAssignMode();
          aTextWindow.Invalidate(); // Or else the Selection remains
          break;

      case SID_INPUT_EQUAL((26000) + 49):
      {
          aTextWindow.StartEditEngine();
          if ( pScMod->IsEditMode() ) // Isn't if e.g. protected
          {
              aTextWindow.StartEditEngine();

              sal_Int32 nStartPos = 1;
              sal_Int32 nEndPos = 1;

              ScTabViewShell* pViewSh = dynamic_cast<ScTabViewShell*>( SfxViewShell::Current()  );
              if ( pViewSh )
              {
                  const OUString& rString = aTextWindow.GetTextString();
                  const sal_Int32 nLen = rString.getLength();

                  ScDocument& rDoc = pViewSh->GetViewData().GetDocument();
                  CellType eCellType = rDoc.GetCellType( pViewSh->GetViewData().GetCurPos() );
                  switch ( eCellType )
                  {
                      case CELLTYPE_VALUE:
                      {
                          nEndPos = nLen + 1;
                          aTextWindow.SetTextString("=" +  rString);
                          break;
                      }
                      case CELLTYPE_STRING:
                      case CELLTYPE_EDIT:
                          nStartPos = 0;
                          nEndPos = nLen;
                          break;
                      case CELLTYPE_FORMULA:
                          nEndPos = nLen;
                          break;
                      default:
                          aTextWindow.SetTextString("=");
                          break;
                  }
              }

              EditView* pView = aTextWindow.GetEditView();
              if (pView)
              {
                  if (comphelper::LibreOfficeKit::isActive())
                      TextGrabFocus();
                  pView->SetSelection( ESelection(0, nStartPos, 0, nEndPos) );
                  pScMod->InputChanged(pView);
                  SetOkCancelMode();
                  pView->SetEditEngineUpdateMode(true);
              }
          }
          break;
      }
  }
432}

434void ScInputWindow::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect)
435{
  if (comphelper::LibreOfficeKit::isActive() && !comphelper::LibreOfficeKit::isDialogPainting())
      return;

  ToolBox::Paint(rRenderContext, rRect);

  if (!comphelper::LibreOfficeKit::isActive())
  {
      // draw a line at the bottom to distinguish that from the grid
      // const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
      // rRenderContext.SetLineColor(rStyleSettings.GetShadowColor());
      // Size aSize = GetSizePixel();
      // rRenderContext.DrawLine(Point(0, aSize.Height() - 1),
      //                        Point(aSize.Width() - 1, aSize.Height() - 1));
  }
450}

452void ScInputWindow::PixelInvalidate(const tools::Rectangle* pRectangle)
453{
  if (comphelper::LibreOfficeKit::isDialogPainting() || !comphelper::LibreOfficeKit::isActive())
      return;

  if (pRectangle)
  {
      const Point aPos(pRectangle->getX() - GetOutOffXPixel(), pRectangle->getY() - GetOutOffYPixel());
      const tools::Rectangle aRect(aPos, pRectangle->GetSize());
      Window::PixelInvalidate(&aRect);
  }
  else
  {
      Window::PixelInvalidate(nullptr);
  }
467}

469void ScInputWindow::SetSizePixel( const Size& rNewSize )
470{
  const vcl::ILibreOfficeKitNotifier* pNotifier = GetLOKNotifier();
  if (pNotifier)
  {
      if (vcl::Window* pFrameWindowImpl = GetParent())
      {
          if (vcl::Window* pWorkWindow = pFrameWindowImpl->GetParent())
          {
              if (vcl::Window* pImplBorderWindow = pWorkWindow->GetParent())
              {
                  Size aSize = pImplBorderWindow->GetSizePixel();
                  aSize.setWidth(rNewSize.getWidth());
                  pImplBorderWindow->SetSizePixel(aSize);
              }
          }
      }
  }

  ToolBox::SetSizePixel(rNewSize);
489}

491void ScInputWindow::Resize()
492{
  ToolBox::Resize();
  aTextWindow.Resize();
  Size aSize = GetSizePixel();
  aSize.setHeight(CalcWindowSizePixel().Height() + 1);
  ScInputBarGroup* pGroupBar = pRuntimeWindow.get();
  if (pGroupBar)
  {
      // To ensure smooth display and prevent the items in the toolbar being
      // repositioned (vertically) we lock the vertical positioning of the toolbox
      // items when we are displaying > 1 line.
      // So, we need to adjust the height of the toolbox accordingly. If we don't
      // then the largest item (e.g. the GroupBar window) will actually be
      // positioned such that the toolbar will cut off the bottom of that item
      if (pGroupBar->GetNumLines() > 1)
      {
          Size aGroupBarSize = pGroupBar->GetSizePixel();
          aSize.setHeight(aGroupBarSize.Height() + 2 * (pGroupBar->GetVertOffset() + 1));
      }
  }
  SetSizePixel(aSize);

  if (const vcl::ILibreOfficeKitNotifier* pNotifier = GetLOKNotifier())
  {
      std::vector<vcl::LOKPayloadItem> aItems;
      aItems.emplace_back(std::make_pair("position", Point(GetOutOffXPixel(), GetOutOffYPixel()).toString()));
      aItems.emplace_back("size", GetSizePixel().toString());
      aItems.emplace_back("lines", OString::number(aTextWindow.GetNumLines()));
      pNotifier->notifyWindow(GetLOKWindowId(), "size_changed", aItems);
  }

  Invalidate();
524}

526void ScInputWindow::NotifyLOKClient()
527{
  if (comphelper::LibreOfficeKit::isActive() && !GetLOKNotifier() && mpViewShell)
      SetLOKNotifier(mpViewShell);

  const vcl::ILibreOfficeKitNotifier* pNotifier = GetLOKNotifier();
  if (!pNotifier)
      return;

  Size aSize = GetSizePixel();
  if (!aSize.IsEmpty())
  {
      std::vector<vcl::LOKPayloadItem> aItems;
      aItems.emplace_back("type", "calc-input-win");
      aItems.emplace_back(std::make_pair("position", Point(GetOutOffXPixel(), GetOutOffYPixel()).toString()));
      aItems.emplace_back(std::make_pair("size", aSize.toString()));
      aItems.emplace_back("lines", OString::number(aTextWindow.GetNumLines()));
      pNotifier->notifyWindow(GetLOKWindowId(), "created", aItems);
  }
545}

547void ScInputWindow::SetFuncString( const OUString& rString, bool bDoEdit )
548{
  //! new method at ScModule to query if function autopilot is open
  SfxViewFrame* pViewFrm = SfxViewFrame::Current();
  EnableButtons( pViewFrm && !pViewFrm->GetChildWindow( SID_OPENDLG_FUNCTION((26000 + 100) + 52) ) );
  aTextWindow.StartEditEngine();

  ScModule* pScMod = SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) );
  if ( !pScMod->IsEditMode() )
      return;

  if ( bDoEdit )
      aTextWindow.GrabFocus();
  aTextWindow.SetTextString( rString );
  EditView* pView = aTextWindow.GetEditView();
  if (!pView)
      return;

  sal_Int32 nLen = rString.getLength();

  if ( nLen > 0 )
  {
      nLen--;
      pView->SetSelection( ESelection( 0, nLen, 0, nLen ) );
  }

  pScMod->InputChanged(pView);
  if ( bDoEdit )
      SetOkCancelMode(); // Not the case if immediately followed by Enter/Cancel

  pView->SetEditEngineUpdateMode(true);
578}

580void ScInputWindow::SetPosString( const OUString& rStr )
581{
  aWndPos->SetPos( rStr );
583}

585void ScInputWindow::SetTextString( const OUString& rString )
586{
  if (rString.getLength() <= 32767)
      aTextWindow.SetTextString(rString);
  else
      aTextWindow.SetTextString(rString.copy(0, 32767));
591}

593void ScInputWindow::SetOkCancelMode()
594{
  //! new method at ScModule to query if function autopilot is open
  SfxViewFrame* pViewFrm = SfxViewFrame::Current();
  EnableButtons( pViewFrm && !pViewFrm->GetChildWindow( SID_OPENDLG_FUNCTION((26000 + 100) + 52) ) );

  if (bIsOkCancelMode)
      return;

  EnableItem  ( SID_INPUT_SUM((26000) + 48),   false );
  EnableItem  ( SID_INPUT_EQUAL((26000) + 49), false );
  HideItem    ( SID_INPUT_SUM((26000) + 48) );
  HideItem    ( SID_INPUT_EQUAL((26000) + 49) );

  ShowItem    ( SID_INPUT_CANCEL((26000) + 50), true );
  ShowItem    ( SID_INPUT_OK((26000) + 51),     true );
  EnableItem  ( SID_INPUT_CANCEL((26000) + 50), true );
  EnableItem  ( SID_INPUT_OK((26000) + 51),     true );

  bIsOkCancelMode = true;
613}

615void ScInputWindow::SetSumAssignMode()
616{
  //! new method at ScModule to query if function autopilot is open
  SfxViewFrame* pViewFrm = SfxViewFrame::Current();
  EnableButtons( pViewFrm && !pViewFrm->GetChildWindow( SID_OPENDLG_FUNCTION((26000 + 100) + 52) ) );

  if (!bIsOkCancelMode)
      return;

  EnableItem  ( SID_INPUT_CANCEL((26000) + 50), false );
  EnableItem  ( SID_INPUT_OK((26000) + 51),     false );
  HideItem    ( SID_INPUT_CANCEL((26000) + 50) );
  HideItem    ( SID_INPUT_OK((26000) + 51) );

  ShowItem    ( SID_INPUT_SUM((26000) + 48),    true );
  ShowItem    ( SID_INPUT_EQUAL((26000) + 49),  true );
  EnableItem  ( SID_INPUT_SUM((26000) + 48),    true );
  EnableItem  ( SID_INPUT_EQUAL((26000) + 49),  true );

  bIsOkCancelMode = false;

  SetFormulaMode(false); // No editing -> no formula
637}

639void ScInputWindow::SetFormulaMode( bool bSet )
640{
  aWndPos->SetFormulaMode(bSet);
  aTextWindow.SetFormulaMode(bSet);
643}

645bool ScInputWindow::IsInputActive()
646{
  return aTextWindow.IsInputActive();
648}

650EditView* ScInputWindow::GetEditView()
651{
  return aTextWindow.GetEditView();
653}

655void ScInputWindow::MakeDialogEditView()
656{
  aTextWindow.MakeDialogEditView();
658}

660void ScInputWindow::StopEditEngine( bool bAll )
661{
  aTextWindow.StopEditEngine( bAll );
663}

665void ScInputWindow::TextGrabFocus()
666{
  aTextWindow.TextGrabFocus();
668}

670void ScInputWindow::TextInvalidate()
671{
  aTextWindow.Invalidate();
673}

675void ScInputWindow::SwitchToTextWin()
676{
  // used for shift-ctrl-F2

  aTextWindow.StartEditEngine();
  if ( SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) )->IsEditMode() )
  {
      aTextWindow.TextGrabFocus();
      EditView* pView = aTextWindow.GetEditView();
      if (pView)
      {
          sal_Int32 nPara =  pView->GetEditEngine()->GetParagraphCount() ? ( pView->GetEditEngine()->GetParagraphCount() - 1 ) : 0;
          sal_Int32 nLen = pView->GetEditEngine()->GetTextLen( nPara );
          ESelection aSel( nPara, nLen, nPara, nLen );
          pView->SetSelection( aSel ); // set cursor to end of text
      }
  }
692}

694void ScInputWindow::PosGrabFocus()
695{
  aWndPos->GrabFocus();
697}

699void ScInputWindow::EnableButtons( bool bEnable )
700{
  //  when enabling buttons, always also enable the input window itself
  if ( bEnable && !IsEnabled() )
      Enable();

  EnableItem( SID_INPUT_FUNCTION((26000) + 47),                                   bEnable );
  EnableItem( bIsOkCancelMode ? SID_INPUT_CANCEL((26000) + 50) : SID_INPUT_SUM((26000) + 48),   bEnable );
  EnableItem( bIsOkCancelMode ? SID_INPUT_OK((26000) + 51)     : SID_INPUT_EQUAL((26000) + 49), bEnable );
708//  Invalidate();
709}

711void ScInputWindow::StateChanged( StateChangedType nType )
712{
  ToolBox::StateChanged( nType );

  if ( nType == StateChangedType::InitShow ) Resize();
716}

718void ScInputWindow::DataChanged( const DataChangedEvent& rDCEvt )
719{
  if ( rDCEvt.GetType() == DataChangedEventType::SETTINGS && (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
  {
      //  update item images
      SetItemImage(SID_INPUT_FUNCTION((26000) + 47), Image(StockImage::Yes, RID_BMP_INPUT_FUNCTION"sc/res/sc26047.png"));
      if ( bIsOkCancelMode )
      {
          SetItemImage(SID_INPUT_CANCEL((26000) + 50), Image(StockImage::Yes, RID_BMP_INPUT_CANCEL"sc/res/sc26050.png"));
          SetItemImage(SID_INPUT_OK((26000) + 51),     Image(StockImage::Yes, RID_BMP_INPUT_OK"sc/res/sc26051.png"));
      }
      else
      {
          SetItemImage(SID_INPUT_SUM((26000) + 48),   Image(StockImage::Yes, RID_BMP_INPUT_SUM"sc/res/sc26048.png"));
          SetItemImage(SID_INPUT_EQUAL((26000) + 49), Image(StockImage::Yes, RID_BMP_INPUT_EQUAL"sc/res/sc26049.png"));
      }
  }

  ToolBox::DataChanged( rDCEvt );
737}

739bool ScInputWindow::IsPointerAtResizePos()
740{
  return GetOutputSizePixel().Height() - GetPointerPosPixel().Y() <= 4;
742}

744void ScInputWindow::MouseMove( const MouseEvent& rMEvt )
745{
  Point aPosPixel = GetPointerPosPixel();

  ScInputBarGroup* pGroupBar = pRuntimeWindow.get();

  if (bInResize || IsPointerAtResizePos())
      SetPointer(PointerStyle::WindowSSize);
  else
      SetPointer(PointerStyle::Arrow);

  if (bInResize)
  {
      // detect direction
      long nResizeThreshold = long(TOOLBOX_WINDOW_HEIGHT * 0.7);
      bool bResetPointerPos = false;

      // Detect attempt to expand toolbar too much
      if (aPosPixel.Y() >= mnMaxY)
      {
          bResetPointerPos = true;
          aPosPixel.setY( mnMaxY );
      } // or expanding down
      else if (GetOutputSizePixel().Height() - aPosPixel.Y() < -nResizeThreshold)
      {
          pGroupBar->IncrementVerticalSize();
          bResetPointerPos = true;
      } // or shrinking up
      else if ((GetOutputSizePixel().Height() - aPosPixel.Y()) > nResizeThreshold)
      {
          bResetPointerPos = true;
          pGroupBar->DecrementVerticalSize();
      }

      if (bResetPointerPos)
      {
          aPosPixel.setY(  GetOutputSizePixel().Height() );
          SetPointerPosPixel(aPosPixel);
      }
  }

  ToolBox::MouseMove(rMEvt);
786}

788void ScInputWindow::MouseButtonDown( const MouseEvent& rMEvt )
789{
  if (rMEvt.IsLeft())
  {
      if (IsPointerAtResizePos())
      {
          // Don't leave the mouse pointer leave *this* window
          CaptureMouse();
          bInResize = true;

          // find the height of the gridwin, we don't want to be
          // able to expand the toolbar too far so we need to
          // calculate an upper limit
          // I'd prefer to leave at least a single column header and a
          // row but I don't know how to get that value in pixels.
          // Use TOOLBOX_WINDOW_HEIGHT for the moment
          ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell();
          mnMaxY = GetOutputSizePixel().Height() + (pViewSh->GetGridHeight(SC_SPLIT_TOP)
                 + pViewSh->GetGridHeight(SC_SPLIT_BOTTOM)) - TOOLBOX_WINDOW_HEIGHT;
      }
  }

  ToolBox::MouseButtonDown( rMEvt );
811}
812void ScInputWindow::MouseButtonUp( const MouseEvent& rMEvt )
813{
  ReleaseMouse();
  if ( rMEvt.IsLeft() )
  {
      bInResize = false;
      mnMaxY = 0;
  }

  ToolBox::MouseButtonUp( rMEvt );
822}

824void ScInputWindow::AutoSum( bool& bRangeFinder, bool& bSubTotal, OpCode eCode )
825{
  ScModule* pScMod = SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) );
  ScTabViewShell* pViewSh = dynamic_cast<ScTabViewShell*>( SfxViewShell::Current()  );
  if ( !pViewSh )
      return;

  const OUString aFormula = pViewSh->DoAutoSum(bRangeFinder, bSubTotal, eCode);
  if ( aFormula.isEmpty() )
      return;

  SetFuncString( aFormula );
  const sal_Int32 aOpen = aFormula.indexOf('(');
  const sal_Int32 aLen  = aFormula.getLength();
  if (!(bRangeFinder && pScMod->IsEditMode()))
      return;

  ScInputHandler* pHdl = pScMod->GetInputHdl( pViewSh );
  if ( !pHdl )
      return;

  pHdl->InitRangeFinder( aFormula );

  //! SetSelection at the InputHandler?
  //! Set bSelIsRef?
  if ( aOpen != -1 && aLen > aOpen )
  {
      ESelection aSel( 0, aOpen + (bSubTotal ? 3 : 1), 0, aLen-1 );
      EditView* pTableView = pHdl->GetTableView();
      if ( pTableView )
          pTableView->SetSelection( aSel );
      EditView* pTopView = pHdl->GetTopView();
      if ( pTopView )
          pTopView->SetSelection( aSel );
  }
859}

861ScInputBarGroup::ScInputBarGroup(vcl::Window* pParent, ScTabViewShell* pViewSh)
  : ScTextWndBase(pParent, WinBits(WB_HIDE | WB_TABSTOP)),
    maTextWndGroup(VclPtr<ScTextWndGroup>::Create(this, pViewSh)),
    maButton(VclPtr<PushButton>::Create(this, WB_TABSTOP | WB_FLATBUTTON | WB_SMALLSTYLE | WB_NOPOINTERFOCUS | WB_CENTER | WB_VCENTER)),
    mnVertOffset(0)
866{
  maTextWndGroup->Show();
  Size aSize(MULTILINE_BUTTON_WIDTH, maTextWndGroup->GetPixelHeightForLines(1));
  maButton->SetClickHdl(LINK(this, ScInputBarGroup, ClickHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScInputBarGroup
 *>(this), &ScInputBarGroup::LinkStubClickHdl));
  maButton->SetSizePixel(aSize);
  maButton->Enable();
  maButton->SetSymbol(SymbolType::SPIN_DOWN);
  maButton->SetQuickHelpText(ScResId(SCSTR_QHELP_EXPAND_FORMULAreinterpret_cast<char const *>("SCSTR_QHELP_EXPAND_FORMULA"
 "\004" u8"Expand Formula Bar")));
  // disable the multiline toggle on the mobile phones
  const SfxViewShell* pViewShell = SfxViewShell::Current();
  if (!comphelper::LibreOfficeKit::isActive() || !(pViewShell && pViewShell->isLOKMobilePhone()))
      maButton->Show();
878}

880ScInputBarGroup::~ScInputBarGroup()
881{
  disposeOnce();
883}

885void ScInputBarGroup::dispose()
886{
  maTextWndGroup.disposeAndClear();
  maButton.disposeAndClear();
  ScTextWndBase::dispose();
890}

892void ScInputBarGroup::InsertAccessibleTextData( ScAccessibleEditLineTextData& rTextData )
893{
  maTextWndGroup->InsertAccessibleTextData(rTextData);
895}

897void ScInputBarGroup::RemoveAccessibleTextData( ScAccessibleEditLineTextData& rTextData )
898{
  maTextWndGroup->RemoveAccessibleTextData(rTextData);
900}

902const OUString& ScInputBarGroup::GetTextString() const
903{
  return maTextWndGroup->GetTextString();
905}

907void ScInputBarGroup::SetTextString( const OUString& rString )
908{
  maTextWndGroup->SetTextString(rString);
910}

912void ScInputBarGroup::Resize()
913{
  vcl::Window* pWindow = GetParent();
  ScInputWindow *pParent;
  pParent = dynamic_cast<ScInputWindow*>(pWindow);
  if (pParent == nullptr)
  {
      OSL_FAIL("The parent window pointer pParent is null")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/ui/app/inputwin.cxx"
 ":" "919" ": "), "%s", "The parent window pointer pParent is null"
); } } while (false);
      return;
  }
  Size aSize = GetSizePixel();
  //(-10) to allow margin between sidebar and formulabar
  long margin = (comphelper::LibreOfficeKit::isActive()) ? 10 : 0;
  aSize.setWidth(pParent->GetSizePixel().Width() - GetPosPixel().X() - LEFT_OFFSET - margin);
  aSize.setHeight(maTextWndGroup->GetPixelHeightForLines(maTextWndGroup->GetNumLines()));
  SetSizePixel(aSize);

  long nButtonWidth = maButton->IsVisible()? maButton->GetSizePixel().Width() + BUTTON_OFFSET: 0;
  aSize.setWidth(aSize.Width() - nButtonWidth);
  maTextWndGroup->SetSizePixel(aSize);
  maTextWndGroup->Resize();

  if (maTextWndGroup->GetNumLines() > 1)
  {
      maButton->SetSymbol( SymbolType::SPIN_UP  );
      maButton->SetQuickHelpText(ScResId( SCSTR_QHELP_COLLAPSE_FORMULAreinterpret_cast<char const *>("SCSTR_QHELP_COLLAPSE_FORMULA"
 "\004" u8"Collapse Formula Bar")));
  }
  else
  {
      maButton->SetSymbol( SymbolType::SPIN_DOWN  );
      maButton->SetQuickHelpText(ScResId( SCSTR_QHELP_EXPAND_FORMULAreinterpret_cast<char const *>("SCSTR_QHELP_EXPAND_FORMULA"
 "\004" u8"Expand Formula Bar")));
  }

  maButton->SetPosPixel(Point(aSize.Width(), 0));
  Invalidate();
947}

949void ScInputBarGroup::StopEditEngine(bool bAll)
950{
  maTextWndGroup->StopEditEngine(bAll);
952}

954void ScInputBarGroup::StartEditEngine()
955{
  maTextWndGroup->StartEditEngine();
957}

959void ScInputBarGroup::MakeDialogEditView()
960{
  maTextWndGroup->MakeDialogEditView();
962}

964EditView* ScInputBarGroup::GetEditView()
965{
  return maTextWndGroup->GetEditView();
967}

969bool ScInputBarGroup::HasEditView() const
970{
  return maTextWndGroup->HasEditView();
972}

974bool ScInputBarGroup::IsInputActive()
975{
  return maTextWndGroup->IsInputActive();
977}

979void ScInputBarGroup::SetFormulaMode(bool bSet)
980{
  maTextWndGroup->SetFormulaMode(bSet);
982}

984void ScInputBarGroup::IncrementVerticalSize()
985{
  maTextWndGroup->SetNumLines(maTextWndGroup->GetNumLines() + 1);
  TriggerToolboxLayout();
988}

990void ScInputBarGroup::DecrementVerticalSize()
991{
  if (maTextWndGroup->GetNumLines() > 1)
  {
      maTextWndGroup->SetNumLines(maTextWndGroup->GetNumLines() - 1);
      TriggerToolboxLayout();
  }
997}

999IMPL_LINK( ScInputWindow, MenuHdl, Menu *, pMenu, bool )bool ScInputWindow::LinkStubMenuHdl(void * instance, Menu * data
) { return static_cast<ScInputWindow *>(instance)->MenuHdl
(data); } bool ScInputWindow::MenuHdl(Menu * pMenu)
1000{
  OString aCommand = pMenu->GetCurItemIdent();
  if (!aCommand.isEmpty())
  {
      bool bSubTotal = false;
      bool bRangeFinder = false;
      OpCode eCode = ocSum;
      if ( aCommand ==  "sum" )
      {
          eCode = ocSum;
      }
      else if ( aCommand == "average" )
      {
          eCode = ocAverage;
      }
      else if ( aCommand == "max" )
      {
          eCode = ocMax;
      }
      else if ( aCommand == "min" )
      {
          eCode = ocMin;
      }
      else if ( aCommand == "count" )
      {
          eCode = ocCount;
      }

      AutoSum( bRangeFinder, bSubTotal, eCode );
  }
  return false;
1031}

1033IMPL_LINK_NOARG(ScInputWindow, DropdownClickHdl, ToolBox *, void)void ScInputWindow::LinkStubDropdownClickHdl(void * instance,
 ToolBox * data) { return static_cast<ScInputWindow *>(
instance)->DropdownClickHdl(data); } void ScInputWindow::DropdownClickHdl
(__attribute__ ((unused)) ToolBox *)
1034{
  sal_uInt16 nCurID = GetCurItemId();
  EndSelection();
  if (nCurID == SID_INPUT_SUM((26000) + 48))
  {
      VclBuilder aBuilder(nullptr, AllSettings::GetUIRootDir(), "modules/scalc/ui/autosum.ui", "");
      VclPtr<PopupMenu> aPopMenu(aBuilder.get_menu("menu"));
      aPopMenu->SetSelectHdl(LINK(this, ScInputWindow, MenuHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScInputWindow
 *>(this), &ScInputWindow::LinkStubMenuHdl));
      aPopMenu->Execute(this, GetItemRect(SID_INPUT_SUM((26000) + 48)), PopupMenuFlags::NoMouseUpClose);
  }
1044}

1046IMPL_LINK_NOARG(ScInputBarGroup, ClickHdl, Button*, void)void ScInputBarGroup::LinkStubClickHdl(void * instance, Button
* data) { return static_cast<ScInputBarGroup *>(instance
)->ClickHdl(data); } void ScInputBarGroup::ClickHdl(__attribute__
 ((unused)) Button*)
1047{
  vcl::Window* w = GetParent();
  ScInputWindow* pParent;
  pParent = dynamic_cast<ScInputWindow*>(w);

  if (pParent == nullptr)
  {
      OSL_FAIL("The parent window pointer pParent is null")do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/ui/app/inputwin.cxx"
 ":" "1054" ": "), "%s", "The parent window pointer pParent is null"
); } } while (false);
      return;
  }
  if (maTextWndGroup->GetNumLines() > 1)
  {
      maTextWndGroup->SetNumLines(1);
  }
  else
  {
      maTextWndGroup->SetNumLines(maTextWndGroup->GetLastNumExpandedLines());
  }
  TriggerToolboxLayout();

  // Restore focus to input line(s) if necessary
  ScInputHandler* pHdl = SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) )->GetInputHdl();
  if ( pHdl && pHdl->IsTopMode() )
      maTextWndGroup->GrabFocus();
1071}

1073void ScInputBarGroup::TriggerToolboxLayout()
1074{
  vcl::Window *w=GetParent();
  ScInputWindow &rParent = dynamic_cast<ScInputWindow&>(*w);
  SfxViewFrame* pViewFrm = SfxViewFrame::Current();

  // Capture the vertical position of this window in the toolbar, when we increase
  // the size of the toolbar to accommodate expanded line input we need to take this
  // into account
  if ( !mnVertOffset )
      mnVertOffset = rParent.GetItemPosRect( rParent.GetItemCount() - 1 ).Top();

  if ( !pViewFrm )
      return;

  Reference< css::beans::XPropertySet > xPropSet( pViewFrm->GetFrame().GetFrameInterface(), UNO_QUERY );
  Reference< css::frame::XLayoutManager > xLayoutManager;

  if ( xPropSet.is() )
  {
      css::uno::Any aValue = xPropSet->getPropertyValue("LayoutManager");
      aValue >>= xLayoutManager;
  }

  if ( !xLayoutManager.is() )
      return;

  xLayoutManager->lock();
  DataChangedEvent aFakeUpdate( DataChangedEventType::SETTINGS, nullptr,  AllSettingsFlags::STYLE );

  // this basically will trigger the repositioning of the
  // items in the toolbar from ImplFormat ( which is controlled by
  // mnWinHeight ) which in turn is updated in ImplCalcItem which is
  // controlled by mbCalc. Additionally the ImplFormat above is
  // controlled via mbFormat. It seems the easiest way to get these
  // booleans set is to send in the fake event below.
  rParent.DataChanged( aFakeUpdate);

  // highest item in toolbar will have been calculated via the
  // event above. Call resize on InputBar to pick up the height
  // change
  rParent.Resize();

  // unlock relayouts the toolbars in the 4 quadrants
  xLayoutManager->unlock();
1118}

1120void ScInputBarGroup::TextGrabFocus()
1121{
  maTextWndGroup->TextGrabFocus();
1123}

1125constexpr long gnBorderWidth = INPUTLINE_INSET_MARGIN + 1;
1126constexpr long gnBorderHeight = INPUTLINE_INSET_MARGIN + 1;

1128ScTextWndGroup::ScTextWndGroup(vcl::Window* pParent, ScTabViewShell* pViewSh)
  : ScTextWndBase(pParent, WinBits(WB_TABSTOP)),
    maTextWnd(VclPtr<ScTextWnd>::Create(this, pViewSh)),
    maScrollBar(VclPtr<ScrollBar>::Create(this, WB_TABSTOP | WB_VERT | WB_DRAG))
1132{
  maTextWnd->SetPosPixel(Point(2 * gnBorderWidth, gnBorderHeight));
  Size aSize = GetSizePixel();
  maTextWnd->SetSizePixel(Size(aSize.Width() - 4 * gnBorderWidth, aSize.Height() - 2 * gnBorderHeight));
  maTextWnd->Show();
  maTextWnd->SetQuickHelpText(ScResId(SCSTR_QHELP_INPUTWNDreinterpret_cast<char const *>("SCSTR_QHELP_INPUTWND" "\004"
 u8"Input line")));
  maTextWnd->SetHelpId(HID_INSWIN_INPUT"SC_HID_INSWIN_INPUT");
  maScrollBar->SetScrollHdl(LINK(this, ScTextWndGroup, Impl_ScrollHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScTextWndGroup
 *>(this), &ScTextWndGroup::LinkStubImpl_ScrollHdl));
  const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
  Color aBackgroundColor = rStyleSettings.GetWindowColor();
  SetBackground(aBackgroundColor);
1143}

1145ScTextWndGroup::~ScTextWndGroup()
1146{
  disposeOnce();
1148}

1150void ScTextWndGroup::dispose()
1151{
  maTextWnd.disposeAndClear();
  maScrollBar.disposeAndClear();
  ScTextWndBase::dispose();
1155}

1157void ScTextWndGroup::InsertAccessibleTextData(ScAccessibleEditLineTextData& rTextData)
1158{
  maTextWnd->InsertAccessibleTextData(rTextData);
1160}

1162EditView* ScTextWndGroup::GetEditView()
1163{
  return maTextWnd->GetEditView();
1165}

1167long ScTextWndGroup::GetLastNumExpandedLines() const
1168{
  return maTextWnd->GetLastNumExpandedLines();
1170}

1172long ScTextWndGroup::GetNumLines() const
1173{
  return maTextWnd->GetNumLines();
1175}

1177long ScTextWndGroup::GetPixelHeightForLines(long nLines)
1178{
  return maTextWnd->GetPixelHeightForLines(nLines) + 2 * gnBorderHeight;
1180}

1182ScrollBar& ScTextWndGroup::GetScrollBar()
1183{
  return *maScrollBar;
1185}

1187const OUString& ScTextWndGroup::GetTextString() const
1188{
  return maTextWnd->GetTextString();
1190}

1192bool ScTextWndGroup::HasEditView() const
1193{
  return maTextWnd->HasEditView();
1195}

1197bool ScTextWndGroup::IsInputActive()
1198{
  return maTextWnd->IsInputActive();
1200}

1202void ScTextWndGroup::MakeDialogEditView()
1203{
  maTextWnd->MakeDialogEditView();
1205}

1207void ScTextWndGroup::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect)
1208{
  ScTextWndBase::Paint(rRenderContext, rRect);
  const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
  rRenderContext.SetLineColor(rStyleSettings.GetShadowColor());
  Size aSize = GetSizePixel();
  rRenderContext.DrawLine(Point(0, 0),
                          Point(aSize.Width() - 1, 0));
  rRenderContext.DrawLine(Point(aSize.Width() - 1, 0),
                          Point(aSize.Width() - 1, aSize.Height() - 1));
  rRenderContext.DrawLine(Point(aSize.Width() - 1, aSize.Height() - 1),
                          Point(0, aSize.Height() - 1));
  rRenderContext.DrawLine(Point(0, aSize.Height() - 1),
                          Point(0, 0));
1221}

1223void ScTextWndGroup::RemoveAccessibleTextData(ScAccessibleEditLineTextData& rTextData)
1224{
  maTextWnd->RemoveAccessibleTextData(rTextData);
1226}

1228void ScTextWndGroup::Resize()
1229{
  Size aSize = GetSizePixel();
  aSize.setHeight(GetPixelHeightForLines(GetNumLines()));
  SetSizePixel(aSize);
  if (maTextWnd->GetNumLines() > 1)
  {
      Size aScrollBarSize = maScrollBar->GetSizePixel();
      aScrollBarSize.setHeight(aSize.Height() - 2);
      maScrollBar->SetPosPixel(Point(aSize.Width() - aScrollBarSize.Width() - 1, 1));
      maScrollBar->SetSizePixel(aScrollBarSize);
      Size aOutputSize = maTextWnd->GetOutputSize();
      maScrollBar->SetVisibleSize(aOutputSize.Height());
      maScrollBar->SetPageSize(aOutputSize.Height());
      maScrollBar->SetLineSize(maTextWnd->GetTextHeight());
      maScrollBar->Resize();
      maScrollBar->Show();
      maTextWnd->SetSizePixel(Size(aSize.Width() - aScrollBarSize.Width() - 3 * gnBorderWidth - 1,
                                   aSize.Height() - 2 * gnBorderHeight));
  }
  else
  {
      maScrollBar->Hide();
      maTextWnd->SetSizePixel(Size(aSize.Width() - 4 * gnBorderWidth, aSize.Height() - 2 * gnBorderHeight));
  }
  maTextWnd->Resize();
  Invalidate();
1255}

1257void ScTextWndGroup::SetNumLines(long nLines)
1258{
  maTextWnd->SetNumLines(nLines);
1260}

1262void ScTextWndGroup::SetFormulaMode(bool bSet)
1263{
  maTextWnd->SetFormulaMode(bSet);
1265}

1267void ScTextWndGroup::SetTextString(const OUString& rString)
1268{
  maTextWnd->SetTextString(rString);
1270}

1272void ScTextWndGroup::StartEditEngine()
1273{
  maTextWnd->StartEditEngine();
1275}

1277void ScTextWndGroup::StopEditEngine(bool bAll)
1278{
  maTextWnd->StopEditEngine( bAll );
1280}

1282void ScTextWndGroup::TextGrabFocus()
1283{
  maTextWnd->TextGrabFocus();
1285}

1287IMPL_LINK_NOARG(ScTextWndGroup, Impl_ScrollHdl, ScrollBar*, void)void ScTextWndGroup::LinkStubImpl_ScrollHdl(void * instance, ScrollBar
* data) { return static_cast<ScTextWndGroup *>(instance
)->Impl_ScrollHdl(data); } void ScTextWndGroup::Impl_ScrollHdl
(__attribute__ ((unused)) ScrollBar*)
1288{
  maTextWnd->DoScroll();
1290}

1292void ScTextWnd::Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect )
1293{
  if (comphelper::LibreOfficeKit::isActive() && !comphelper::LibreOfficeKit::isDialogPainting())
      return;

  tools::Rectangle aRect = comphelper::LibreOfficeKit::isActive() ? this->PixelToLogic(rRect) : rRect;
  EditView* pView = GetEditView();
  if (pView)
  {
      if (mbInvalidate)
      {
          pView->Invalidate();
          mbInvalidate = false;
      }
      mpEditView->Paint(aRect, &rRenderContext);
  }
1308}

1310EditView* ScTextWnd::GetEditView()
1311{
  if ( !mpEditView )
      InitEditEngine();
  return mpEditView.get();
1315}

1317bool ScTextWnd::HasEditView() const { return mpEditView != nullptr; }

1319long ScTextWnd::GetPixelHeightForLines(long nLines)
1320{
  // add padding (for the borders of the window)
  return LogicToPixel(Size(0, nLines * GetTextHeight())).Height() + 1;
1323}

1325void ScTextWnd::SetNumLines(long nLines)
1326{
  mnLines = nLines;
  if ( nLines > 1 )
  {
      mnLastExpandedLines = nLines;
      Resize();
  }
1333}

1335void ScTextWnd::Resize()
1336{
  // Only Height is recalculated here, Width is applied from
  // parent/container window
  Size aTextBoxSize = GetSizePixel();

  aTextBoxSize.setHeight( GetPixelHeightForLines( mnLines ) );
  SetSizePixel( aTextBoxSize );

  if (mpEditView)
  {
      Size aOutputSize = GetOutputSizePixel();
      tools::Rectangle aOutputArea = PixelToLogic( tools::Rectangle( Point(), aOutputSize ));
      mpEditView->SetOutputArea( aOutputArea );

      // Don't leave an empty area at the bottom if we can move the text down.
      long nMaxVisAreaTop = mpEditEngine->GetTextHeight() - aOutputArea.GetHeight();
      if (mpEditView->GetVisArea().Top() > nMaxVisAreaTop)
      {
          mpEditView->Scroll(0, mpEditView->GetVisArea().Top() - nMaxVisAreaTop);
      }

      mpEditEngine->SetPaperSize( PixelToLogic( Size( aOutputSize.Width(), 10000 ) ) );
  }

  SetScrollBarRange();
1361}

1363long ScTextWnd::GetEditEngTxtHeight() const
1364{
  return mpEditView ? mpEditView->GetEditEngine()->GetTextHeight() : 0;
1366}

1368void ScTextWnd::SetScrollBarRange()
1369{
  if ( mpEditView )
  {
      ScrollBar& rVBar = mrGroupBar.GetScrollBar();
      rVBar.SetRange( Range( 0, GetEditEngTxtHeight() ) );
      long currentDocPos = mpEditView->GetVisArea().TopLeft().Y();
      rVBar.SetThumbPos( currentDocPos );
  }
1377}

1379void ScTextWnd::DoScroll()
1380{
  if ( mpEditView )
  {
      ScrollBar& rVBar = mrGroupBar.GetScrollBar();
      long currentDocPos = mpEditView->GetVisArea().TopLeft().Y();
      long nDiff = currentDocPos - rVBar.GetThumbPos();
      mpEditView->Scroll( 0, nDiff );
      currentDocPos = mpEditView->GetVisArea().TopLeft().Y();
      rVBar.SetThumbPos( currentDocPos );
  }
1390}

1392void ScTextWnd::StartEditEngine()
1393{
  // Don't activate if we're a modal dialog ourselves (Doc-modal dialog)
  SfxObjectShell* pObjSh = SfxObjectShell::Current();
  if ( pObjSh && pObjSh->IsInModalMode() )
      return;

  if ( !mpEditView || !mpEditEngine )
  {
      InitEditEngine();
  }

  ScInputHandler* pHdl = mpViewShell->GetInputHandler();
  if (pHdl)
      pHdl->SetMode(SC_INPUT_TOP, nullptr, mpEditEngine.get());

  SfxViewFrame* pViewFrm = SfxViewFrame::Current();
  if (pViewFrm)
      pViewFrm->GetBindings().Invalidate( SID_ATTR_INSERTTypedWhichId<SfxBoolItem>( 10000 + 221 ) );
1411}

1413static void lcl_ExtendEditFontAttribs( SfxItemSet& rSet )
1414{
  const SfxPoolItem& rFontItem = rSet.Get( EE_CHAR_FONTINFO );
  std::unique_ptr<SfxPoolItem> pNewItem(rFontItem.Clone());
  pNewItem->SetWhich(EE_CHAR_FONTINFO_CJK);
  rSet.Put( *pNewItem );
  pNewItem->SetWhich(EE_CHAR_FONTINFO_CTL);
  rSet.Put( *pNewItem );
  const SfxPoolItem& rHeightItem = rSet.Get( EE_CHAR_FONTHEIGHT );
  pNewItem.reset(rHeightItem.Clone());
  pNewItem->SetWhich(EE_CHAR_FONTHEIGHT_CJK);
  rSet.Put( *pNewItem );
  pNewItem->SetWhich(EE_CHAR_FONTHEIGHT_CTL);
  rSet.Put( *pNewItem );
  const SfxPoolItem& rWeightItem = rSet.Get( EE_CHAR_WEIGHT );
  pNewItem.reset(rWeightItem.Clone());
  pNewItem->SetWhich(EE_CHAR_WEIGHT_CJK);
  rSet.Put( *pNewItem );
  pNewItem->SetWhich(EE_CHAR_WEIGHT_CTL);
  rSet.Put( *pNewItem );
  const SfxPoolItem& rItalicItem = rSet.Get( EE_CHAR_ITALIC );
  pNewItem.reset(rItalicItem.Clone());
  pNewItem->SetWhich(EE_CHAR_ITALIC_CJK);
  rSet.Put( *pNewItem );
  pNewItem->SetWhich(EE_CHAR_ITALIC_CTL);
  rSet.Put( *pNewItem );
  const SfxPoolItem& rLangItem = rSet.Get( EE_CHAR_LANGUAGE );
  pNewItem.reset(rLangItem.Clone());
  pNewItem->SetWhich(EE_CHAR_LANGUAGE_CJK);
  rSet.Put( *pNewItem );
  pNewItem->SetWhich(EE_CHAR_LANGUAGE_CTL);
  rSet.Put( *pNewItem );
1445}

1447static void lcl_ModifyRTLDefaults( SfxItemSet& rSet )
1448{
  rSet.Put( SvxAdjustItem( SvxAdjust::Right, EE_PARA_JUST ) );

  // always using rtl writing direction would break formulas
  //rSet.Put( SvxFrameDirectionItem( SvxFrameDirection::Horizontal_RL_TB, EE_PARA_WRITINGDIR ) );

  // PaperSize width is limited to USHRT_MAX in RTL mode (because of EditEngine's
  // sal_uInt16 values in EditLine), so the text may be wrapped and line spacing must be
  // increased to not see the beginning of the next line.
  SvxLineSpacingItem aItem( LINE_SPACE_DEFAULT_HEIGHT200, EE_PARA_SBL );
  aItem.SetPropLineSpace( 200 );
  rSet.Put( aItem );
1460}

1462static void lcl_ModifyRTLVisArea( EditView* pEditView )
1463{
  tools::Rectangle aVisArea = pEditView->GetVisArea();
  Size aPaper = pEditView->GetEditEngine()->GetPaperSize();
  long nDiff = aPaper.Width() - aVisArea.Right();
  aVisArea.AdjustLeft(nDiff );
  aVisArea.AdjustRight(nDiff );
  pEditView->SetVisArea(aVisArea);
1470}

1472void ScTextWnd::InitEditEngine()
1473{
  std::unique_ptr<ScFieldEditEngine> pNew;
  ScDocShell* pDocSh = nullptr;
  if ( mpViewShell )
  {
      pDocSh = mpViewShell->GetViewData().GetDocShell();
      ScDocument& rDoc = mpViewShell->GetViewData().GetDocument();
      pNew = std::make_unique<ScFieldEditEngine>(&rDoc, rDoc.GetEnginePool(), rDoc.GetEditPool());
  }
  else
      pNew = std::make_unique<ScFieldEditEngine>(nullptr, EditEngine::CreatePool(), nullptr, true);
  pNew->SetExecuteURL( false );
  mpEditEngine = std::move(pNew);

  Size barSize=GetSizePixel();
  mpEditEngine->SetUpdateMode( false );
  mpEditEngine->SetPaperSize( PixelToLogic(Size(barSize.Width(),10000)) );
  mpEditEngine->SetWordDelimiters(
                  ScEditUtil::ModifyDelimiters( mpEditEngine->GetWordDelimiters() ) );
  mpEditEngine->SetReplaceLeadingSingleQuotationMark( false );

  UpdateAutoCorrFlag();

  {
      auto pSet = std::make_unique<SfxItemSet>( mpEditEngine->GetEmptyItemSet() );
      EditEngine::SetFontInfoInItemSet( *pSet, aTextFont );
      lcl_ExtendEditFontAttribs( *pSet );
      // turn off script spacing to match DrawText output
      pSet->Put( SvxScriptSpaceItem( false, EE_PARA_ASIANCJKSPACING ) );
      if ( bIsRTL )
          lcl_ModifyRTLDefaults( *pSet );
      mpEditEngine->SetDefaults( std::move(pSet) );
  }

  // If the Cell contains URLFields, they need to be taken over into the entry row,
  // or else the position is not correct anymore
  bool bFilled = false;
  ScInputHandler* pHdl = SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) )->GetInputHdl();
  if ( pHdl ) //! Test if it's the right InputHdl?
      bFilled = pHdl->GetTextAndFields( *mpEditEngine );

  mpEditEngine->SetUpdateMode( true );

  // aString is the truth ...
  if (bFilled && mpEditEngine->GetText() == aString)
      Invalidate(); // Repaint for (filled) Field
  else
      mpEditEngine->SetTextCurrentDefaults(aString); // At least the right text then

  mpEditView = std::make_unique<EditView>(mpEditEngine.get(), this);
  mpEditView->SetInsertMode(bIsInsertMode);

  if (comphelper::LibreOfficeKit::isActive())
      mpEditView->RegisterViewShell(mpViewShell);

  // Text from Clipboard is taken over as ASCII in a single row
  EVControlBits n = mpEditView->GetControlWord();
  mpEditView->SetControlWord( n | EVControlBits::SINGLELINEPASTE );

  mpEditEngine->InsertView( mpEditView.get(), EE_APPEND );

  Resize();

  if ( bIsRTL )
      lcl_ModifyRTLVisArea( mpEditView.get() );

  mpEditEngine->SetModifyHdl(LINK(this, ScTextWnd, ModifyHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScTextWnd
 *>(this), &ScTextWnd::LinkStubModifyHdl));
  mpEditEngine->SetNotifyHdl(LINK(this, ScTextWnd, NotifyHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScTextWnd
 *>(this), &ScTextWnd::LinkStubNotifyHdl));

  if (!maAccTextDatas.empty())
      maAccTextDatas.back()->StartEdit();

  // as long as EditEngine and DrawText sometimes differ for CTL text,
  // repaint now to have the EditEngine's version visible
  if (pDocSh)
  {
      ScDocument& rDoc = pDocSh->GetDocument(); // any document
      SvtScriptType nScript = rDoc.GetStringScriptType( aString );
      if ( nScript & SvtScriptType::COMPLEX )
          Invalidate();
  }
1554}

1556ScTextWnd::ScTextWnd(ScTextWndGroup* pParent, ScTabViewShell* pViewSh)
  :   ScTextWndBase(pParent, WinBits(WB_HIDE)),
      DragSourceHelper(this),
      bIsInsertMode(true),
      bFormulaMode (false),
      bInputMode   (false),
      mpViewShell(pViewSh),
      mrGroupBar(*pParent),
      mnLines(1),
      mnLastExpandedLines(INPUTWIN_MULTILINES),
      mbInvalidate(false)
1567{
  EnableRTL(false); // EditEngine can't be used with VCL EnableRTL

  bIsRTL = AllSettings::GetLayoutRTL();

  // always use application font, so a font with cjk chars can be installed
  vcl::Font aAppFont = GetFont();
  aTextFont = aAppFont;
  Size aFontSize = aAppFont.GetFontSize();
  aTextFont.SetFontSize(PixelToLogic(aFontSize, MapMode(MapUnit::MapTwip)));

  const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();

  Color aBgColor = rStyleSettings.GetWindowColor();
  Color aTxtColor = rStyleSettings.GetWindowTextColor();

  aTextFont.SetTransparent(true);
  aTextFont.SetFillColor(aBgColor);
  aTextFont.SetColor(aTxtColor);
  aTextFont.SetWeight(WEIGHT_NORMAL);

  Size aSize(1, GetPixelHeightForLines(1));
  auto nMinEditHeight = weld::GetMinimumEditHeight();
  if (nMinEditHeight > aSize.Height())
      aSize.setHeight(nMinEditHeight);

  SetSizePixel(aSize);
  SetBackground(aBgColor);
  SetLineColor(COL_BLACK);
  SetMapMode(MapMode(MapUnit::MapTwip));
  SetPointer(PointerStyle::Text);
  SetFont(aTextFont);

  set_id("sc_input_window");
1601}

1603ScTextWnd::~ScTextWnd()
1604{
  disposeOnce();
1606}

1608void ScTextWnd::dispose()
1609{
  while (!maAccTextDatas.empty()) {
      maAccTextDatas.back()->Dispose();
  }
  mpEditView.reset();
  mpEditEngine.reset();

  DragSourceHelper::dispose();
  ScTextWndBase::dispose();
1618}

1620void ScTextWnd::MouseMove( const MouseEvent& rMEvt )
1621{
  if (mpEditView)
      mpEditView->MouseMove( rMEvt );
1624}

1626void ScTextWnd::MouseButtonDown( const MouseEvent& rMEvt )
1627{
  if (!HasFocus())
  {
      StartEditEngine();
      if ( SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) )->IsEditMode() )
          GrabFocus();
  }

  if (mpEditView)
  {
      mpEditView->SetEditEngineUpdateMode( true );
      mpEditView->MouseButtonDown( rMEvt );
  }
1640}

1642void ScTextWnd::MouseButtonUp( const MouseEvent& rMEvt )
1643{
  if (mpEditView)
      if (mpEditView->MouseButtonUp( rMEvt ))
      {
          if ( rMEvt.IsMiddle() &&
                   GetSettings().GetMouseSettings().GetMiddleButtonAction() == MouseMiddleButtonAction::PasteSelection )
          {
              //  EditView may have pasted from selection
              SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) )->InputChanged( mpEditView.get() );
          }
          else
              SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) )->InputSelection( mpEditView.get() );
      }
1656}

1658void ScTextWnd::Command( const CommandEvent& rCEvt )
1659{
  bInputMode = true;
  CommandEventId nCommand = rCEvt.GetCommand();
  if ( mpEditView /* && nCommand == CommandEventId::StartDrag */ )
  {
      ScModule* pScMod = SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) );
      ScTabViewShell* pStartViewSh = ScTabViewShell::GetActiveViewShell();

      // don't modify the font defaults here - the right defaults are
      // already set in StartEditEngine when the EditEngine is created

      // Prevent that the EditView is lost when switching between Views
      pScMod->SetInEditCommand( true );
      mpEditView->Command( rCEvt );
      pScMod->SetInEditCommand( false );

      //  CommandEventId::StartDrag does not mean by far that the content was actually changed,
      //  so don't trigger an InputChanged.
      //! Detect if dragged with Move or forbid Drag&Move somehow

      if ( nCommand == CommandEventId::StartDrag )
      {
          // Is dragged onto another View?
          ScTabViewShell* pEndViewSh = ScTabViewShell::GetActiveViewShell();
          if ( pEndViewSh != pStartViewSh && pStartViewSh != nullptr )
          {
              ScViewData& rViewData = pStartViewSh->GetViewData();
              ScInputHandler* pHdl = pScMod->GetInputHdl( pStartViewSh );
              if ( pHdl && rViewData.HasEditView( rViewData.GetActivePart() ) )
              {
                  pHdl->CancelHandler();
                  rViewData.GetView()->ShowCursor(); // Missing for KillEditView, due to being inactive
              }
          }
      }
      else if ( nCommand == CommandEventId::EndExtTextInput )
      {
          if (bFormulaMode)
          {
              ScInputHandler* pHdl = SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) )->GetInputHdl();
              if (pHdl)
                  pHdl->InputCommand(rCEvt);
          }
      }
      else if ( nCommand == CommandEventId::CursorPos )
      {
          //  don't call InputChanged for CommandEventId::CursorPos
      }
      else if ( nCommand == CommandEventId::InputLanguageChange )
      {
          // #i55929# Font and font size state depends on input language if nothing is selected,
          // so the slots have to be invalidated when the input language is changed.

          SfxViewFrame* pViewFrm = SfxViewFrame::Current();
          if (pViewFrm)
          {
              SfxBindings& rBindings = pViewFrm->GetBindings();
              rBindings.Invalidate( SID_ATTR_CHAR_FONT( 10000 + 7 ) );
              rBindings.Invalidate( SID_ATTR_CHAR_FONTHEIGHT( 10000 + 15 ) );
          }
      }
      else if ( nCommand == CommandEventId::ContextMenu )
      {
          SfxViewFrame* pViewFrm = SfxViewFrame::Current();
          if (pViewFrm)
          {
              Point aPos = rCEvt.GetMousePosPixel();
              if (!rCEvt.IsMouseEvent())
              {
                  Size aSize = GetOutputSizePixel();
                  aPos = Point(aSize.Width() / 2, aSize.Height() / 2);
              }
              pViewFrm->GetDispatcher()->ExecutePopup("formulabar", this, &aPos);
          }
      }
      else if ( nCommand == CommandEventId::Wheel )
      {
          //don't call InputChanged for CommandEventId::Wheel
      }
      else if ( nCommand == CommandEventId::Swipe )
      {
          //don't call InputChanged for CommandEventId::Swipe
      }
      else if ( nCommand == CommandEventId::LongPress )
      {
          //don't call InputChanged for CommandEventId::LongPress
      }
      else if ( nCommand == CommandEventId::ModKeyChange )
      {
          //pass alt press/release to parent impl
          Window::Command(rCEvt);
      }
      else
          SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) )->InputChanged( mpEditView.get() );
  }
  else
      Window::Command(rCEvt); // Or else let the base class handle it...

  bInputMode = false;
1758}

1760void ScTextWnd::StartDrag( sal_Int8 /* nAction */, const Point& rPosPixel )
1761{
  if ( mpEditView )
  {
      CommandEvent aDragEvent( rPosPixel, CommandEventId::StartDrag, true );
      mpEditView->Command( aDragEvent );

      //  handling of d&d to different view (CancelHandler) can't be done here,
      //  because the call returns before d&d is complete.
  }
1770}

1772void ScTextWnd::KeyInput(const KeyEvent& rKEvt)
1773{
  bInputMode = true;
  if (!SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) )->InputKeyEvent( rKEvt ))
  {
      bool bUsed = false;
      ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell();
      if ( pViewSh )
          bUsed = pViewSh->SfxKeyInput(rKEvt); // Only accelerators, no input
      if (!bUsed)
          Window::KeyInput( rKEvt );
  }
  bInputMode = false;
1785}

1787void ScTextWnd::GetFocus()
1788{
  ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell();
  if ( pViewSh )
      pViewSh->SetFormShellAtTop( false ); // focus in input line -> FormShell no longer on top
1792}

1794void ScTextWnd::LoseFocus()
1795{
1796}

1798OUString ScTextWnd::GetText() const
1799{
  //  Override to get the text via the testtool
  if ( mpEditEngine )
      return mpEditEngine->GetText();
  else
      return GetTextString();
1805}

1807void ScTextWnd::SetFormulaMode( bool bSet )
1808{
  if ( bSet != bFormulaMode )
  {
      bFormulaMode = bSet;
      UpdateAutoCorrFlag();
  }
1814}

1816void ScTextWnd::UpdateAutoCorrFlag()
1817{
  if ( mpEditEngine )
  {
      EEControlBits nControl = mpEditEngine->GetControlWord();
      EEControlBits nOld = nControl;
      if ( bFormulaMode )
          nControl &= ~EEControlBits::AUTOCORRECT; // No AutoCorrect in Formulas
      else
          nControl |= EEControlBits::AUTOCORRECT; // Else do enable it

      if ( nControl != nOld )
          mpEditEngine->SetControlWord( nControl );
  }
1830}

1832IMPL_LINK(ScTextWnd, NotifyHdl, EENotify&, rNotify, void)void ScTextWnd::LinkStubNotifyHdl(void * instance, EENotify&
 data) { return static_cast<ScTextWnd *>(instance)->
NotifyHdl(data); } void ScTextWnd::NotifyHdl(EENotify& rNotify
)
1833{
  // need to process EE_NOTIFY_TEXTVIEWSCROLLED here
  // sometimes we don't seem to get EE_NOTIFY_TEXTVIEWSCROLLED e.g. when
  // we insert text at the beginning of the text so the cursor never moves
  // down to generate a scroll event

  if ( rNotify.eNotificationType == EE_NOTIFY_TEXTVIEWSCROLLED
       || rNotify.eNotificationType == EE_NOTIFY_TextHeightChanged )
      SetScrollBarRange();
1842}

1844IMPL_LINK_NOARG(ScTextWnd, ModifyHdl, LinkParamNone*, void)void ScTextWnd::LinkStubModifyHdl(void * instance, LinkParamNone
* data) { return static_cast<ScTextWnd *>(instance)->
ModifyHdl(data); } void ScTextWnd::ModifyHdl(__attribute__ ((
unused)) LinkParamNone*)
1845{
  if (mpEditView && !bInputMode)
  {
      ScInputHandler* pHdl = SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) )->GetInputHdl();

      //  Use the InputHandler's InOwnChange flag to prevent calling InputChanged
      //  while an InputHandler method is modifying the EditEngine content

      if ( pHdl && !pHdl->IsInOwnChange() )
          pHdl->InputChanged( mpEditView.get(), true );  // #i20282# InputChanged must know if called from modify handler
  }
1856}

1858void ScTextWnd::StopEditEngine( bool bAll )
1859{
  if (!mpEditEngine)
      return;

  mpEditEngine->SetNotifyHdl(Link<EENotify&, void>());

  if (mpEditView)
  {
      if (!maAccTextDatas.empty())
          maAccTextDatas.back()->EndEdit();

      ScModule* pScMod = SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) );

      if (!bAll)
          pScMod->InputSelection( mpEditView.get() );
      aString = mpEditEngine->GetText();
      bIsInsertMode = mpEditView->IsInsertMode();
      bool bSelection = mpEditView->HasSelection();
      mpEditEngine->SetModifyHdl(Link<LinkParamNone*,void>());
      mpEditView.reset();
      mpEditEngine.reset();

      ScInputHandler* pHdl = mpViewShell->GetInputHandler();

      if (pHdl && pHdl->IsEditMode() && !bAll)
          pHdl->SetMode(SC_INPUT_TABLE);

      SfxViewFrame* pViewFrm = SfxViewFrame::Current();
      if (pViewFrm)
          pViewFrm->GetBindings().Invalidate( SID_ATTR_INSERTTypedWhichId<SfxBoolItem>( 10000 + 221 ) );

      if (bSelection)
          Invalidate(); // So that the Selection is not left there
  }

  if (comphelper::LibreOfficeKit::isActive())
  {
      // Clear
      std::vector<ReferenceMark> aReferenceMarks;
      ScInputHandler::SendReferenceMarks( mpViewShell, aReferenceMarks );
  }
1900}

1902static sal_Int32 findFirstNonMatchingChar(const OUString& rStr1, const OUString& rStr2)
1903{
  // Search the string for unmatching chars
  const sal_Unicode*  pStr1 = rStr1.getStr();
  const sal_Unicode*  pStr2 = rStr2.getStr();
  sal_Int32      i = 0;
  while ( i < rStr1.getLength() )
  {
      // Abort on the first unmatching char
      if ( *pStr1 != *pStr2 )
          return i;
      ++pStr1;
      ++pStr2;
      ++i;
  }

  return i;
1919}

1921void ScTextWnd::SetTextString( const OUString& rNewString )
1922{
  // Ideally it would be best to create on demand the EditEngine/EditView here, but... for
  // the initialisation scenario where a cell is first clicked on we end up with the text in the
  // inputbar window scrolled to the bottom if we do that here ( because the tableview and topview
  // are synced I guess ).
  // should fix that I suppose :-/ need to look a bit further into that
  mbInvalidate = true; // ensure next Paint ( that uses editengine ) call will call Invalidate first

  if ( rNewString != aString )
  {
      bInputMode = true;

      // Find position of the change, only paint the rest
      if (!mpEditEngine)
      {
          bool bPaintAll = mnLines > 1 || bIsRTL;
          if (!bPaintAll)
          {
              //  test if CTL script type is involved
              SvtScriptType nOldScript = SvtScriptType::NONE;
              SvtScriptType nNewScript = SvtScriptType::NONE;
              SfxObjectShell* pObjSh = SfxObjectShell::Current();
              if ( auto pDocShell = dynamic_cast<ScDocShell*>( pObjSh) )
              {
                  //  any document can be used (used only for its break iterator)
                  ScDocument& rDoc = pDocShell->GetDocument();
                  nOldScript = rDoc.GetStringScriptType( aString );
                  nNewScript = rDoc.GetStringScriptType( rNewString );
              }
              bPaintAll = ( nOldScript & SvtScriptType::COMPLEX ) || ( nNewScript & SvtScriptType::COMPLEX );
          }

          if ( bPaintAll )
          {
              // In multiline mode, or if CTL is involved, the whole text has to be redrawn
              Invalidate();
          }
          else
          {
              long nTextSize = 0;
              sal_Int32 nDifPos;
              if (rNewString.getLength() > aString.getLength())
                  nDifPos = findFirstNonMatchingChar(rNewString, aString);
              else
                  nDifPos = findFirstNonMatchingChar(aString, rNewString);

              long nSize1 = GetTextWidth(aString);
              long nSize2 = GetTextWidth(rNewString);
              if ( nSize1>0 && nSize2>0 )
                  nTextSize = std::max( nSize1, nSize2 );
              else
                  nTextSize = GetOutputSize().Width(); // Overflow

              Point aLogicStart = PixelToLogic(Point(0,0));
              long nStartPos = aLogicStart.X();
              long nInvPos = nStartPos;
              if (nDifPos)
                  nInvPos += GetTextWidth(aString,0,nDifPos);

              InvalidateFlags nFlags = InvalidateFlags::NONE;
              if ( nDifPos == aString.getLength() ) // only new characters appended
                  nFlags = InvalidateFlags::NoErase;      // then background is already clear

              Invalidate( tools::Rectangle( nInvPos, 0, nStartPos+nTextSize, GetOutputSize().Height()-1 ), nFlags );
          }
      }
      else
      {
          mpEditEngine->SetTextCurrentDefaults(rNewString);
      }

      aString = rNewString;

      if (!maAccTextDatas.empty())
          maAccTextDatas.back()->TextChanged();

      bInputMode = false;
  }

  SetScrollBarRange();
  DoScroll();
2003}

2005const OUString& ScTextWnd::GetTextString() const
2006{
  return aString;
2008}

2010bool ScTextWnd::IsInputActive()
2011{
  return HasFocus();
2013}

2015void ScTextWnd::MakeDialogEditView()
2016{
  if ( mpEditView ) return;

  std::unique_ptr<ScFieldEditEngine> pNew;
  ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell();
  if ( pViewSh )
  {
      ScDocument& rDoc = pViewSh->GetViewData().GetDocument();
      pNew = std::make_unique<ScFieldEditEngine>(&rDoc, rDoc.GetEnginePool(), rDoc.GetEditPool());
  }
  else
      pNew = std::make_unique<ScFieldEditEngine>(nullptr, EditEngine::CreatePool(), nullptr, true);
  pNew->SetExecuteURL( false );
  mpEditEngine = std::move(pNew);

  mpEditEngine->SetUpdateMode( false );
  mpEditEngine->SetWordDelimiters( mpEditEngine->GetWordDelimiters() + "=" );
  mpEditEngine->SetPaperSize( Size( bIsRTL ? USHRT_MAX(32767 *2 +1) : THESIZE, 300 ) );

  auto pSet = std::make_unique<SfxItemSet>( mpEditEngine->GetEmptyItemSet() );
  EditEngine::SetFontInfoInItemSet( *pSet, aTextFont );
  lcl_ExtendEditFontAttribs( *pSet );
  if ( bIsRTL )
      lcl_ModifyRTLDefaults( *pSet );
  mpEditEngine->SetDefaults( std::move(pSet) );
  mpEditEngine->SetUpdateMode( true );

  mpEditView = std::make_unique<EditView>(mpEditEngine.get(), this);
  if (comphelper::LibreOfficeKit::isActive())
      mpEditView->RegisterViewShell(mpViewShell);
  mpEditEngine->InsertView( mpEditView.get(), EE_APPEND );

  Resize();

  if ( bIsRTL )
      lcl_ModifyRTLVisArea( mpEditView.get() );

  if (!maAccTextDatas.empty())
      maAccTextDatas.back()->StartEdit();
2055}

2057void ScTextWnd::ImplInitSettings()
2058{
  bIsRTL = AllSettings::GetLayoutRTL();

  const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();

  Color aBgColor= rStyleSettings.GetWindowColor();
  Color aTxtColor= rStyleSettings.GetWindowTextColor();

  aTextFont.SetFillColor   ( aBgColor );
  aTextFont.SetColor       (aTxtColor);
  SetBackground           ( aBgColor );
  Invalidate();
2070}

2072css::uno::Reference< css::accessibility::XAccessible > ScTextWnd::CreateAccessible()
2073{
  return new ScAccessibleEditObject(GetAccessibleParentWindow()->GetAccessible(), nullptr, this,
      ScResId(STR_ACC_EDITLINE_NAMEreinterpret_cast<char const *>("STR_ACC_EDITLINE_NAME" "\004"
 u8"Input line")),
      ScResId(STR_ACC_EDITLINE_DESCRreinterpret_cast<char const *>("STR_ACC_EDITLINE_DESCR"
 "\004" u8"This is where you enter or edit text, numbers and formulas."
)), ScAccessibleEditObject::EditLine);
2077}

2079void ScTextWnd::InsertAccessibleTextData( ScAccessibleEditLineTextData& rTextData )
2080{
  OSL_ENSURE( ::std::find( maAccTextDatas.begin(), maAccTextDatas.end(), &rTextData ) == maAccTextDatas.end(),do { if (true && (!(::std::find( maAccTextDatas.begin
(), maAccTextDatas.end(), &rTextData ) == maAccTextDatas.
end()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), (
"legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/ui/app/inputwin.cxx"
 ":" "2082" ": "), "%s", "ScTextWnd::InsertAccessibleTextData - passed object already registered"
); } } while (false)
      "ScTextWnd::InsertAccessibleTextData - passed object already registered" )do { if (true && (!(::std::find( maAccTextDatas.begin
(), maAccTextDatas.end(), &rTextData ) == maAccTextDatas.
end()))) { sal_detail_logFormat((SAL_DETAIL_LOG_LEVEL_WARN), (
"legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/ui/app/inputwin.cxx"
 ":" "2082" ": "), "%s", "ScTextWnd::InsertAccessibleTextData - passed object already registered"
); } } while (false);
  maAccTextDatas.push_back( &rTextData );
2084}

2086void ScTextWnd::RemoveAccessibleTextData( ScAccessibleEditLineTextData& rTextData )
2087{
  AccTextDataVector::iterator aEnd = maAccTextDatas.end();
  AccTextDataVector::iterator aIt = ::std::find( maAccTextDatas.begin(), aEnd, &rTextData );
  OSL_ENSURE( aIt != aEnd, "ScTextWnd::RemoveAccessibleTextData - passed object not registered" )do { if (true && (!(aIt != aEnd))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sc/source/ui/app/inputwin.cxx"
 ":" "2090" ": "), "%s", "ScTextWnd::RemoveAccessibleTextData - passed object not registered"
); } } while (false);
  if( aIt != aEnd )
      maAccTextDatas.erase( aIt );
2093}

2095void ScTextWnd::DataChanged( const DataChangedEvent& rDCEvt )
2096{
  if ( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
       (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
  {
      ImplInitSettings();
      Invalidate();
  }
  else
      Window::DataChanged( rDCEvt );
2105}

2107void ScTextWnd::TextGrabFocus()
2108{
  GrabFocus();
2110}

2112// Position window
2113ScPosWnd::ScPosWnd(vcl::Window* pParent)
  : InterimItemWindow(pParent, "modules/scalc/ui/posbox.ui", "PosBox")
  , m_xWidget(m_xBuilder->weld_combo_box("pos_window"))
  , m_nAsyncGetFocusId(nullptr)
  , nTipVisible(nullptr)
  , bFormulaMode(false)
2119{
  InitControlBase(m_xWidget.get());

  // Use calculation according to tdf#132338 to align combobox width to width of fontname combobox within formatting toolbar;
  // formatting toolbar is placed above formulabar when using multiple toolbars typically

  m_xWidget->set_entry_width_chars(1);
  Size aSize(LogicToPixel(Size(POSITION_COMBOBOX_WIDTH * 4, 0), MapMode(MapUnit::MapAppFont)));
  m_xWidget->set_size_request(aSize.Width(), -1);
  SetSizePixel(m_xContainer->get_preferred_size());

  FillRangeNames();

  StartListening( *SfxGetpApp() ); // For Navigator rangename updates

  m_xWidget->connect_key_press(LINK(this, ScPosWnd, KeyInputHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScPosWnd
 *>(this), &ScPosWnd::LinkStubKeyInputHdl));
  m_xWidget->connect_entry_activate(LINK(this, ScPosWnd, ActivateHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScPosWnd
 *>(this), &ScPosWnd::LinkStubActivateHdl));
  m_xWidget->connect_changed(LINK(this, ScPosWnd, ModifyHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScPosWnd
 *>(this), &ScPosWnd::LinkStubModifyHdl));
  m_xWidget->connect_focus_in(LINK(this, ScPosWnd, FocusInHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScPosWnd
 *>(this), &ScPosWnd::LinkStubFocusInHdl));
  m_xWidget->connect_focus_out(LINK(this, ScPosWnd, FocusOutHdl)::tools::detail::makeLink( ::tools::detail::castTo<ScPosWnd
 *>(this), &ScPosWnd::LinkStubFocusOutHdl));
2139}

2141ScPosWnd::~ScPosWnd()
2142{
  disposeOnce();
2144}

2146void ScPosWnd::dispose()
2147{
  EndListening( *SfxGetpApp() );

  HideTip();

  if (m_nAsyncGetFocusId)
  {
      Application::RemoveUserEvent(m_nAsyncGetFocusId);
      m_nAsyncGetFocusId = nullptr;
  }
  m_xWidget.reset();

  InterimItemWindow::dispose();
2160}

2162void ScPosWnd::SetFormulaMode( bool bSet )
2163{
  if ( bSet != bFormulaMode )
  {
      bFormulaMode = bSet;

      if ( bSet )
          FillFunctions();
      else
          FillRangeNames();

      HideTip();
  }
2175}

2177void ScPosWnd::SetPos( const OUString& rPosStr )
2178{
  if ( aPosStr != rPosStr )
  {
      aPosStr = rPosStr;
      m_xWidget->set_entry_text(aPosStr);
  }
2184}

2186namespace {

2188OUString createLocalRangeName(const OUString& rName, const OUString& rTableName)
2189{
  return rName + " (" + rTableName + ")";
2191}

2193}

2195void ScPosWnd::FillRangeNames()
2196{
  m_xWidget->clear();
  m_xWidget->freeze();

  SfxObjectShell* pObjSh = SfxObjectShell::Current();
  if ( auto pDocShell = dynamic_cast<ScDocShell*>( pObjSh) )
  {
      ScDocument& rDoc = pDocShell->GetDocument();

      m_xWidget->append_text(ScResId(STR_MANAGE_NAMESreinterpret_cast<char const *>("STR_MANAGE_NAMES" "\004"
 u8"Manage Names...")));
      m_xWidget->append_separator("separator");

      ScRange aDummy;
      std::set<OUString> aSet;
      ScRangeName* pRangeNames = rDoc.GetRangeName();
      for (const auto& rEntry : *pRangeNames)
      {
          if (rEntry.second->IsValidReference(aDummy))
              aSet.insert(rEntry.second->GetName());
      }
      for (SCTAB i = 0; i < rDoc.GetTableCount(); ++i)
      {
          ScRangeName* pLocalRangeName = rDoc.GetRangeName(i);
          if (pLocalRangeName && !pLocalRangeName->empty())
          {
              OUString aTableName;
              rDoc.GetName(i, aTableName);
              for (const auto& rEntry : *pLocalRangeName)
              {
                  if (rEntry.second->IsValidReference(aDummy))
                      aSet.insert(createLocalRangeName(rEntry.second->GetName(), aTableName));
              }
          }
      }

      for (const auto& rItem : aSet)
      {
          m_xWidget->append_text(rItem);
      }
  }
  m_xWidget->thaw();
  m_xWidget->set_entry_text(aPosStr);
2238}

2240void ScPosWnd::FillFunctions()
2241{
  m_xWidget->clear();
  m_xWidget->freeze();

  OUString aFirstName;
  const ScAppOptions& rOpt = SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) )->GetAppOptions();
  sal_uInt16 nMRUCount = rOpt.GetLRUFuncListCount();
  const sal_uInt16* pMRUList = rOpt.GetLRUFuncList();
  if (pMRUList)
  {
      const ScFunctionList* pFuncList = ScGlobal::GetStarCalcFunctionList();
      sal_uInt32 nListCount = pFuncList->GetCount();
      for (sal_uInt16 i=0; i<nMRUCount; i++)
      {
          sal_uInt16 nId = pMRUList[i];
          for (sal_uInt32 j=0; j<nListCount; j++)
          {
              const ScFuncDesc* pDesc = pFuncList->GetFunction( j );
              if ( pDesc->nFIndex == nId && pDesc->mxFuncName )
              {
                  m_xWidget->append_text(*pDesc->mxFuncName);
                  if (aFirstName.isEmpty())
                      aFirstName = *pDesc->mxFuncName;
                  break; // Stop searching
              }
          }
      }
  }

  //! Re-add entry "Other..." for Function AutoPilot if it can work with text that
  // has been entered so far

  //  m_xWidget->append_text(ScResId(STR_FUNCTIONLIST_MORE));

  m_xWidget->thaw();
  m_xWidget->set_entry_text(aFirstName);
2277}

2279void ScPosWnd::Notify( SfxBroadcaster&, const SfxHint& rHint )
2280{
  if ( bFormulaMode )
      return;

  // Does the list of range names need updating?
  if ( dynamic_cast<const SfxEventHint*>(&rHint) )
  {
      SfxEventHintId nEventId = static_cast<const SfxEventHint*>(&rHint)->GetEventId();
      if ( nEventId == SfxEventHintId::ActivateDoc )
          FillRangeNames();
  }
  else
  {
      const SfxHintId nHintId = rHint.GetId();
      if ( nHintId == SfxHintId::ScAreasChanged || nHintId == SfxHintId::ScNavigatorUpdateAll)
          FillRangeNames();
  }
2297}

2299void ScPosWnd::HideTip()
2300{
  if (nTipVisible)
  {
      Help::HidePopover(this, nTipVisible);
      nTipVisible = nullptr;
  }
2306}

2308static ScNameInputType lcl_GetInputType( const OUString& rText )
2309{
  ScNameInputType eRet = SC_NAME_INPUT_BAD_NAME;      // the more general error

  ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell();
  if ( pViewSh )
  {
      ScViewData& rViewData = pViewSh->GetViewData();
      ScDocument& rDoc = rViewData.GetDocument();
      SCTAB nTab = rViewData.GetTabNo();
      formula::FormulaGrammar::AddressConvention eConv = rDoc.GetAddressConvention();

      // test in same order as in SID_CURRENTCELL execute

      ScRange aRange;
      ScAddress aAddress;
      SCTAB nNameTab;
      sal_Int32 nNumeric;

      if (rText == ScResId(STR_MANAGE_NAMESreinterpret_cast<char const *>("STR_MANAGE_NAMES" "\004"
 u8"Manage Names...")))
          eRet = SC_MANAGE_NAMES;
      else if ( aRange.Parse( rText, rDoc, eConv ) & ScRefFlags::VALID )
          eRet = SC_NAME_INPUT_RANGE;
      else if ( aAddress.Parse( rText, rDoc, eConv ) & ScRefFlags::VALID )
          eRet = SC_NAME_INPUT_CELL;
      else if ( ScRangeUtil::MakeRangeFromName( rText, rDoc, nTab, aRange, RUTL_NAMES, eConv ) )
          eRet = SC_NAME_INPUT_NAMEDRANGE;
      else if ( ScRangeUtil::MakeRangeFromName( rText, rDoc, nTab, aRange, RUTL_DBASE, eConv ) )
          eRet = SC_NAME_INPUT_DATABASE;
      else if ( comphelper::string::isdigitAsciiString( rText ) &&
                ( nNumeric = rText.toInt32() ) > 0 && nNumeric <= rDoc.MaxRow()+1 )
          eRet = SC_NAME_INPUT_ROW;
      else if ( rDoc.GetTable( rText, nNameTab ) )
          eRet = SC_NAME_INPUT_SHEET;
      else if ( ScRangeData::IsNameValid( rText, rDoc ) == ScRangeData::NAME_VALID )     // nothing found, create new range?
      {
          if ( rViewData.GetSimpleArea( aRange ) == SC_MARK_SIMPLE )
              eRet = SC_NAME_INPUT_DEFINE;
          else
              eRet = SC_NAME_INPUT_BAD_SELECTION;
      }
      else
          eRet = SC_NAME_INPUT_BAD_NAME;
  }

  return eRet;
2354}

2356IMPL_LINK_NOARG(ScPosWnd, ModifyHdl, weld::ComboBox&, void)void ScPosWnd::LinkStubModifyHdl(void * instance, weld::ComboBox
& data) { return static_cast<ScPosWnd *>(instance)->
ModifyHdl(data); } void ScPosWnd::ModifyHdl(__attribute__ ((unused
)) weld::ComboBox&)
2357{
  HideTip();

  if (m_xWidget->changed_by_direct_pick())
  {
      DoEnter();
      return;
  }

  if (bFormulaMode)
      return;

  // determine the action that would be taken for the current input

  ScNameInputType eType = lcl_GetInputType(m_xWidget->get_active_text());      // uses current view
  const char* pStrId = nullptr;
  switch ( eType )
  {
      case SC_NAME_INPUT_CELL:
          pStrId = STR_NAME_INPUT_CELLreinterpret_cast<char const *>("STR_NAME_INPUT_CELL" "\004"
 u8"Select Cell");
          break;
      case SC_NAME_INPUT_RANGE:
      case SC_NAME_INPUT_NAMEDRANGE:
          pStrId = STR_NAME_INPUT_RANGEreinterpret_cast<char const *>("STR_NAME_INPUT_RANGE" "\004"
 u8"Select Range");      // named range or range reference
          break;
      case SC_NAME_INPUT_DATABASE:
          pStrId = STR_NAME_INPUT_DBRANGEreinterpret_cast<char const *>("STR_NAME_INPUT_DBRANGE"
 "\004" u8"Select Database Range");
          break;
      case SC_NAME_INPUT_ROW:
          pStrId = STR_NAME_INPUT_ROWreinterpret_cast<char const *>("STR_NAME_INPUT_ROW" "\004"
 u8"Go To Row");
          break;
      case SC_NAME_INPUT_SHEET:
          pStrId = STR_NAME_INPUT_SHEETreinterpret_cast<char const *>("STR_NAME_INPUT_SHEET" "\004"
 u8"Go To Sheet");
          break;
      case SC_NAME_INPUT_DEFINE:
          pStrId = STR_NAME_INPUT_DEFINEreinterpret_cast<char const *>("STR_NAME_INPUT_DEFINE" "\004"
 u8"Define Name for Range");
          break;
      default:
          // other cases (error): no tip help
          break;
  }

  if (!pStrId)
      return;

  // show the help tip at the text cursor position
  Point aPos;
  vcl::Cursor* pCur = GetCursor();
  if (pCur)
      aPos = LogicToPixel( pCur->GetPos() );
  aPos = OutputToScreenPixel( aPos );
  tools::Rectangle aRect( aPos, aPos );

  OUString aText = ScResId(pStrId);
  QuickHelpFlags const nAlign = QuickHelpFlags::Left|QuickHelpFlags::Bottom;
  nTipVisible = Help::ShowPopover(this, aRect, aText, nAlign);
2413}

2415void ScPosWnd::DoEnter()
2416{
  OUString aText = m_xWidget->get_active_text();
  if ( !aText.isEmpty() )
  {
      if ( bFormulaMode )
      {
          ScModule* pScMod = SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) );
          if ( aText == ScResId(STR_FUNCTIONLIST_MOREreinterpret_cast<char const *>("STR_FUNCTIONLIST_MORE" "\004"
 u8"More...")) )
          {
              // Function AutoPilot
              //! Continue working with the text entered so far

              //! new method at ScModule to query if function autopilot is open
              SfxViewFrame* pViewFrm = SfxViewFrame::Current();
              if ( pViewFrm && !pViewFrm->GetChildWindow( SID_OPENDLG_FUNCTION((26000 + 100) + 52) ) )
                  pViewFrm->GetDispatcher()->Execute( SID_OPENDLG_FUNCTION((26000 + 100) + 52),
                                            SfxCallMode::SYNCHRON | SfxCallMode::RECORD );
          }
          else
          {
              ScTabViewShell* pViewSh = dynamic_cast<ScTabViewShell*>( SfxViewShell::Current()  );
              ScInputHandler* pHdl = pScMod->GetInputHdl( pViewSh );
              if (pHdl)
                  pHdl->InsertFunction( aText );
          }
      }
      else
      {
          // depending on the input, select something or create a new named range

          ScTabViewShell* pViewSh = ScTabViewShell::GetActiveViewShell();
          if ( pViewSh )
          {
              ScViewData& rViewData = pViewSh->GetViewData();
              ScDocShell* pDocShell = rViewData.GetDocShell();
              ScDocument& rDoc = pDocShell->GetDocument();

              ScNameInputType eType = lcl_GetInputType( aText );
              if ( eType == SC_NAME_INPUT_BAD_NAME || eType == SC_NAME_INPUT_BAD_SELECTION )
              {
                  const char* pId = (eType == SC_NAME_INPUT_BAD_NAME) ? STR_NAME_ERROR_NAMEreinterpret_cast<char const *>("STR_NAME_ERROR_NAME" "\004"
 u8"You must enter a valid reference or type a valid name for the selected range."
) : STR_NAME_ERROR_SELECTIONreinterpret_cast<char const *>("STR_NAME_ERROR_SELECTION"
 "\004" u8"The selection needs to be rectangular in order to name it."
);
                  pViewSh->ErrorMessage(pId);
              }
              else if ( eType == SC_NAME_INPUT_DEFINE )
              {
                  ScRangeName* pNames = rDoc.GetRangeName();
                  ScRange aSelection;
                  if ( pNames && !pNames->findByUpperName(ScGlobal::getCharClassPtr()->uppercase(aText)) &&
                          (rViewData.GetSimpleArea( aSelection ) == SC_MARK_SIMPLE) )
                  {
                      ScRangeName aNewRanges( *pNames );
                      ScAddress aCursor( rViewData.GetCurX(), rViewData.GetCurY(), rViewData.GetTabNo() );
                      OUString aContent(aSelection.Format(rDoc, ScRefFlags::RANGE_ABS_3D, rDoc.GetAddressConvention()));
                      ScRangeData* pNew = new ScRangeData( rDoc, aText, aContent, aCursor );
                      if ( aNewRanges.insert(pNew) )
                      {
                          pDocShell->GetDocFunc().ModifyRangeNames( aNewRanges );
                          pViewSh->UpdateInputHandler(true);
                      }
                  }
              }
              else if (eType == SC_MANAGE_NAMES)
              {
                  sal_uInt16          nId  = ScNameDlgWrapper::GetChildWindowId();
                  SfxViewFrame* pViewFrm = pViewSh->GetViewFrame();
                  SfxChildWindow* pWnd = pViewFrm->GetChildWindow( nId );

                  SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) )->SetRefDialog( nId, pWnd == nullptr );
              }
              else
              {
                  // for all selection types, execute the SID_CURRENTCELL slot.
                  if (eType == SC_NAME_INPUT_CELL || eType == SC_NAME_INPUT_RANGE)
                  {
                      // Note that SID_CURRENTCELL always expects address to
                      // be in Calc A1 format.  Convert the text.
                      ScRange aRange(0,0, rViewData.GetTabNo());
                      aRange.ParseAny(aText, rDoc, rDoc.GetAddressConvention());
                      aText = aRange.Format(rDoc, ScRefFlags::RANGE_ABS_3D, ::formula::FormulaGrammar::CONV_OOO);
                  }

                  SfxStringItem aPosItem( SID_CURRENTCELL((26000) + 41), aText );
                  SfxBoolItem aUnmarkItem( FN_PARAM_1((20000 + 1100)+60), true );        // remove existing selection

                  pViewSh->GetViewData().GetDispatcher().ExecuteList( SID_CURRENTCELL((26000) + 41),
                                      SfxCallMode::SYNCHRON | SfxCallMode::RECORD,
                                      { &aPosItem, &aUnmarkItem });
              }
          }
      }
  }
  else
      m_xWidget->set_entry_text(aPosStr);

  ReleaseFocus_Impl();
2511}

2513IMPL_LINK_NOARG(ScPosWnd, ActivateHdl, weld::ComboBox&, bool)bool ScPosWnd::LinkStubActivateHdl(void * instance, weld::ComboBox
& data) { return static_cast<ScPosWnd *>(instance)->
ActivateHdl(data); } bool ScPosWnd::ActivateHdl(__attribute__
 ((unused)) weld::ComboBox&)
2514{
  DoEnter();
  return true;
2517}

2519IMPL_LINK(ScPosWnd, KeyInputHdl, const KeyEvent&, rKEvt, bool)bool ScPosWnd::LinkStubKeyInputHdl(void * instance, const KeyEvent
& data) { return static_cast<ScPosWnd *>(instance)->
KeyInputHdl(data); } bool ScPosWnd::KeyInputHdl(const KeyEvent
& rKEvt)
2520{
  bool bHandled = true;

  switch (rKEvt.GetKeyCode().GetCode())
  {
      case KEY_RETURN:
          bHandled = ActivateHdl(*m_xWidget);
          break;
      case KEY_ESCAPE:
          if (nTipVisible)
          {
              // escape when the tip help is shown: only hide the tip
              HideTip();
          }
          else
          {
              if (!bFormulaMode)
                  m_xWidget->set_entry_text(aPosStr);
              ReleaseFocus_Impl();
          }
          break;
      default:
          bHandled = false;
          break;
  }

  return bHandled || ChildKeyInput(rKEvt);
2547}

2549IMPL_LINK_NOARG(ScPosWnd, OnAsyncGetFocus, void*, void)void ScPosWnd::LinkStubOnAsyncGetFocus(void * instance, void*
 data) { return static_cast<ScPosWnd *>(instance)->OnAsyncGetFocus
(data); } void ScPosWnd::OnAsyncGetFocus(__attribute__ ((unused
)) void*)
2550{
  m_nAsyncGetFocusId = nullptr;
  m_xWidget->select_entry_region(0, -1);
2553}

2555IMPL_LINK_NOARG(ScPosWnd, FocusInHdl, weld::Widget&, void)void ScPosWnd::LinkStubFocusInHdl(void * instance, weld::Widget
& data) { return static_cast<ScPosWnd *>(instance)->
FocusInHdl(data); } void ScPosWnd::FocusInHdl(__attribute__ (
(unused)) weld::Widget&)
2556{
  if (m_nAsyncGetFocusId)
      return;
  // do it async to defeat entry in combobox having its own ideas about the focus
  m_nAsyncGetFocusId = Application::PostUserEvent(LINK(this, ScPosWnd, OnAsyncGetFocus)::tools::detail::makeLink( ::tools::detail::castTo<ScPosWnd
 *>(this), &ScPosWnd::LinkStubOnAsyncGetFocus));
2561}

2563IMPL_LINK_NOARG(ScPosWnd, FocusOutHdl, weld::Widget&, void)void ScPosWnd::LinkStubFocusOutHdl(void * instance, weld::Widget
& data) { return static_cast<ScPosWnd *>(instance)->
FocusOutHdl(data); } void ScPosWnd::FocusOutHdl(__attribute__
 ((unused)) weld::Widget&)
2564{
  if (m_nAsyncGetFocusId)
  {
      Application::RemoveUserEvent(m_nAsyncGetFocusId);
      m_nAsyncGetFocusId = nullptr;
  }

  HideTip();
2572}

2574void ScPosWnd::ReleaseFocus_Impl()
2575{
  HideTip();

  SfxViewShell* pCurSh = SfxViewShell::Current();
  ScInputHandler* pHdl = SC_MOD()( static_cast<ScModule*>(SfxApplication::GetModule(SfxToolsModule
::Calc)) )->GetInputHdl( dynamic_cast<ScTabViewShell*>( pCurSh )  );
  if ( pHdl && pHdl->IsTopMode() )
  {
      // Focus back in input row?
      ScInputWindow* pInputWin = pHdl->GetInputWindow();
      if (pInputWin)
      {
          pInputWin->TextGrabFocus();
          return;
      }
  }

  // Set focus to active View
  if ( pCurSh )
  {
      vcl::Window* pShellWnd = pCurSh->GetWindow();

      if ( pShellWnd )
          pShellWnd->GrabFocus();
  }
2599}

2601/* 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; }

    // 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)...)); }
2
←
Calling constructor for 'ScInputWindowWrapper'→

/// 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 */

←

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

→

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

20#ifndef INCLUDED_VCL_PTR_HXX
21#define INCLUDED_VCL_PTR_HXX

23#include <sal/config.h>

25#include <rtl/ref.hxx>

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

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

36class VclReferenceBase;

38namespace vcl::detail {

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

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

47} // namespace vcl::detail

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

  ::rtl::Reference<reference_type> m_rInnerRef;

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

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

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

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

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

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

103#if defined(DBG_UTIL) && !defined(_WIN32)
  virtual ~VclPtr()
  {
      assert(m_rInnerRef.get() == nullptr || vclmain::isAlive())(static_cast <bool> (m_rInnerRef.get() == nullptr || vclmain
::isAlive()) ? void (0) : __assert_fail ("m_rInnerRef.get() == nullptr || vclmain::isAlive()"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 106, __extension__ __PRETTY_FUNCTION__));
      // We can be one of the intermediate counts, but if we are the last
      // VclPtr keeping this object alive, then something forgot to call dispose().
      assert((!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1)(static_cast <bool> ((!m_rInnerRef.get() || m_rInnerRef
->isDisposed() || m_rInnerRef->getRefCount() > 1) &&
 "someone forgot to call dispose()") ? void (0) : __assert_fail
 ("(!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) && \"someone forgot to call dispose()\""
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 110, __extension__ __PRETTY_FUNCTION__))
              && "someone forgot to call dispose()")(static_cast <bool> ((!m_rInnerRef.get() || m_rInnerRef
->isDisposed() || m_rInnerRef->getRefCount() > 1) &&
 "someone forgot to call dispose()") ? void (0) : __assert_fail
 ("(!m_rInnerRef.get() || m_rInnerRef->isDisposed() || m_rInnerRef->getRefCount() > 1) && \"someone forgot to call dispose()\""
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 110, __extension__ __PRETTY_FUNCTION__));
  }
  VclPtr(VclPtr const &) = default;
  VclPtr(VclPtr &&) = default;
  VclPtr & operator =(VclPtr const &) = default;
  VclPtr & operator =(VclPtr &&) = default;
116#endif

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

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

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

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

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

  /** Up-casting copy assignment operator.

      Does not work for up-casts to ambiguous bases.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /** Copy constructor...
   */
  ScopedVclPtr (const VclPtr<reference_type> & handle)
      : VclPtr<reference_type>(handle)
  {}

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

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

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

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

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

  /** Up-casting assignment operator.

      Does not work for up-casts to ambiguous bases.

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

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

  ~ScopedVclPtr()
  {
      VclPtr<reference_type>::disposeAndClear();
      assert(VclPtr<reference_type>::get() == nullptr)(static_cast <bool> (VclPtr<reference_type>::get(
) == nullptr) ? void (0) : __assert_fail ("VclPtr<reference_type>::get() == nullptr"
, "/home/maarten/src/libreoffice/core/include/vcl/vclptr.hxx"
, 375, __extension__ __PRETTY_FUNCTION__)); // make sure there are no lingering references
  }

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

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

393/**
* A construction helper for ScopedVclPtr. Since VclPtr types are created
* with a reference-count of one - to help fit into the existing
* code-flow; this helps us to construct them easily.
*
* For more details on the design please see vcl/README.lifecycle
*
* @param reference_type must be a subclass of vcl::Window
*/
402#if defined _MSC_VER
403#pragma warning(push)
404#pragma warning(disable: 4521) // " multiple copy constructors specified"
405#endif
406template <class reference_type>
407class SAL_WARN_UNUSED__attribute__((warn_unused)) ScopedVclPtrInstance final : public ScopedVclPtr<reference_type>
408{
409public:
  template<typename... Arg> ScopedVclPtrInstance(Arg &&... arg)
      : ScopedVclPtr<reference_type>( new reference_type(std::forward<Arg>(arg)...), SAL_NO_ACQUIRE )
  {
  }

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

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

440#endif // INCLUDED_VCL_PTR_HXX

442/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

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

→

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

20#ifndef INCLUDED_RTL_REF_HXX
21#define INCLUDED_RTL_REF_HXX

23#include "sal/config.h"

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

32#include "sal/types.h"

34namespace rtl
35{

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


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


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

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

  /** Copy constructor...
   */
  Reference (const Reference<reference_type> & handle)
      : m_pBody (handle.m_pBody)
  {
      if (m_pBody)
          m_pBody->acquire();
  }

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

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

      Does not work for up-casts to ambiguous bases.

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

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

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

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

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

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

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


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


  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * SAL_CALL operator->() const
  {
      assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
 ("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 200, __extension__ __PRETTY_FUNCTION__));
      return m_pBody;
  }


  /** Allows (*handle).someBodyOp().
  */
  reference_type & SAL_CALL operator*() const
  {
      assert(m_pBody != NULL)(static_cast <bool> (m_pBody != __null) ? void (0) : __assert_fail
 ("m_pBody != NULL", "/home/maarten/src/libreoffice/core/include/rtl/ref.hxx"
, 209, __extension__ __PRETTY_FUNCTION__));
      return *m_pBody;
  }


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

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

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


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


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


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


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

274} // namespace rtl

276#if defined LIBO_INTERNAL_ONLY1
277namespace std
278{

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

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

294}

296#endif

298#endif /* ! INCLUDED_RTL_REF_HXX */

300/* vim:set shiftwidth=4 softtabstop=4 expandtab: */

←

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

1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 *   Licensed to the Apache Software Foundation (ASF) under one or more
12 *   contributor license agreements. See the NOTICE file distributed
13 *   with this work for additional information regarding copyright
14 *   ownership. The ASF licenses this file to you under the Apache
15 *   License, Version 2.0 (the "License"); you may not use this file
16 *   except in compliance with the License. You may obtain a copy of
17 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19#ifndef INCLUDED_VCL_Reference_HXX
20#define INCLUDED_VCL_Reference_HXX
21 
22#include <vcl/dllapi.h>
23#include <osl/interlck.h>
24 
25class VCL_DLLPUBLIC__attribute__ ((visibility("default"))) VclReferenceBase
26{
27    mutable oslInterlockedCount mnRefCnt;
28 
29    template<typename T> friend class VclPtr;
30 
31public:
32    void acquire() const
33    {
34        osl_atomic_increment(&mnRefCnt)__sync_add_and_fetch((&mnRefCnt), 1);
35    }
36 
37    void release() const
38    {
39        if (osl_atomic_decrement(&mnRefCnt)__sync_sub_and_fetch((&mnRefCnt), 1) == 0)
10
←
Assuming the condition is true→
11
←
Taking true branch→
40            delete this;
12
←
Memory is released→
41    }
42#ifdef DBG_UTIL
43#ifndef _WIN32
44    sal_Int32 getRefCount() const { return mnRefCnt; }
45#endif
46#endif
47 
48 
49private:
50    VclReferenceBase(const VclReferenceBase&) = delete;
51    VclReferenceBase& operator=(const VclReferenceBase&) = delete;
52 
53    bool                        mbDisposed : 1;
54 
55protected:
56                                VclReferenceBase();
57protected:
58    virtual                     ~VclReferenceBase();
59 
60protected:
61    virtual void                dispose();
62 
63public:
64    void                        disposeOnce();
65    bool                        isDisposed() const { return mbDisposed; }
66 
67};
68#endif