/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 pptx-text.cxx -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D EXCEPTIONS_ON -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/external/boost/include -I /home/maarten/src/libreoffice/core/workdir/UnpackedTarball/boost -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -I /home/maarten/src/libreoffice/core/sd/inc -I /home/maarten/src/libreoffice/core/sd/source/ui/inc -I /home/maarten/src/libreoffice/core/workdir/CustomTarget/oox/generated -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/udkapi/normal -I /home/maarten/src/libreoffice/core/workdir/UnoApiHeadersTarget/offapi/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/sd/source/filter/eppt/pptx-text.cxx

/home/maarten/src/libreoffice/core/sd/source/filter/eppt/pptx-text.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 "text.hxx"

23#include <com/sun/star/awt/CharSet.hpp>
24#include <com/sun/star/awt/FontWeight.hpp>
25#include <com/sun/star/awt/FontUnderline.hpp>
26#include <com/sun/star/awt/XBitmap.hpp>
27#include <com/sun/star/beans/XPropertyState.hpp>
28#include <com/sun/star/beans/XPropertySet.hpp>
29#include <com/sun/star/container/XEnumerationAccess.hpp>
30#include <com/sun/star/container/XIndexReplace.hpp>
31#include <com/sun/star/i18n/BreakIterator.hpp>
32#include <com/sun/star/i18n/ScriptDirection.hpp>
33#include <com/sun/star/i18n/ScriptType.hpp>
34#include <com/sun/star/text/FontRelief.hpp>
35#include <com/sun/star/text/XTextField.hpp>
36#include <com/sun/star/text/XTextRange.hpp>
37#include <com/sun/star/style/LineSpacing.hpp>
38#include <com/sun/star/style/LineSpacingMode.hpp>
39#include <com/sun/star/style/ParagraphAdjust.hpp>
40#include <com/sun/star/style/TabStop.hpp>
41#include <com/sun/star/graphic/XGraphic.hpp>

43#include <comphelper/processfactory.hxx>
44#include <editeng/svxenum.hxx>
45#include <editeng/frmdir.hxx>
46#include <filter/msfilter/util.hxx>
47#include <i18nutil/scripttypedetector.hxx>
48#include <o3tl/any.hxx>
49#include <svl/languageoptions.hxx>
50#include <osl/diagnose.h>
51#include <i18nlangtag/languagetag.hxx>

53#include <vcl/settings.hxx>
54#include <vcl/metric.hxx>
55#include <vcl/virdev.hxx>
56#include <vcl/svapp.hxx>

58using namespace css;

60static css::uno::Reference< css::i18n::XBreakIterator > xPPTBreakIter;

62PortionObj::PortionObj(const css::uno::Reference< css::beans::XPropertySet > & rXPropSet,
              FontCollection& rFontCollection)
  : meCharColor(css::beans::PropertyState_AMBIGUOUS_VALUE)
  , meCharHeight(css::beans::PropertyState_AMBIGUOUS_VALUE)
  , meFontName(css::beans::PropertyState_AMBIGUOUS_VALUE)
  , meAsianOrComplexFont(css::beans::PropertyState_AMBIGUOUS_VALUE)
  , meCharEscapement(css::beans::PropertyState_AMBIGUOUS_VALUE)
  , mnCharAttrHard(0)
  , mnCharAttr(0)
  , mnFont(0)
  , mnAsianOrComplexFont(0xffff)
  , mnTextSize(0)
  , mbLastPortion(true)
75{
  mXPropSet = rXPropSet;

  ImplGetPortionValues( rFontCollection, false );
79}

81PortionObj::PortionObj(css::uno::Reference< css::text::XTextRange > & rXTextRange,
                         bool bLast, FontCollection& rFontCollection)
  : meCharColor(css::beans::PropertyState_AMBIGUOUS_VALUE)
  , meCharHeight(css::beans::PropertyState_AMBIGUOUS_VALUE)
  , meFontName(css::beans::PropertyState_AMBIGUOUS_VALUE)
  , meAsianOrComplexFont(css::beans::PropertyState_AMBIGUOUS_VALUE)
  , meCharEscapement(css::beans::PropertyState_AMBIGUOUS_VALUE)
  , mnCharAttrHard(0)
  , mnCharColor(0)
  , mnCharAttr(0)
  , mnCharHeight(0)
  , mnFont(0)
  , mnAsianOrComplexFont(0xffff)
  , mnCharEscapement(0)
  , mbLastPortion(bLast)
96{
  OUString aString( rXTextRange->getString() );
  OUString aURL;

  mnTextSize = aString.getLength();
  if ( bLast )
      mnTextSize++;

  if ( !mnTextSize )
      return;

  bool bRTL_endingParen = false;
  mpFieldEntry = nullptr;
  sal_uInt32 nFieldType = 0;

  mXPropSet.set( rXTextRange, css::uno::UNO_QUERY );
  mXPropState.set( rXTextRange, css::uno::UNO_QUERY );

  bool bPropSetsValid = ( mXPropSet.is() && mXPropState.is() );
  if ( bPropSetsValid )
      nFieldType = ImplGetTextField( rXTextRange, mXPropSet, aURL );
  if ( nFieldType )
  {
      mpFieldEntry.reset( new FieldEntry( nFieldType, 0, mnTextSize ) );
      if ( nFieldType >> 28 == 4 )
      {
          mpFieldEntry->aRepresentation = aString;
          mpFieldEntry->aFieldUrl = aURL;
      }
  }
  bool bSymbol = false;

  if ( bPropSetsValid && ImplGetPropertyValue( "CharFontCharSet", false ) )
  {
      sal_Int16 nCharset = 0;
      mAny >>= nCharset;
      if ( nCharset == css::awt::CharSet::SYMBOL )
          bSymbol = true;
  }
  if ( mpFieldEntry && ( nFieldType & 0x800000 ) )    // placeholder ?
  {
      mnTextSize = 1;
      if ( bLast )
          mnTextSize++;
      mpText.reset( new sal_uInt16[ mnTextSize ] );
      mpText[ 0 ] = 0x2a;
  }
  else
  {
      // For i39516 - a closing parenthesis that ends an RTL string is displayed backwards by PPT
      // Solution: add a Unicode Right-to-Left Mark, following the method described in i18024
      if (bLast && !aString.isEmpty()
          && aString[aString.getLength() - 1] == ')'
          && FontCollection::GetScriptDirection(aString) == css::i18n::ScriptDirection::RIGHT_TO_LEFT)
      {
          mnTextSize++;
          bRTL_endingParen = true;
      }
      mpText.reset( new sal_uInt16[ mnTextSize ] );
      sal_uInt16 nChar;
      for ( sal_Int32 i = 0; i < aString.getLength(); i++ )
      {
          nChar = static_cast<sal_uInt16>(aString[ i ]);
          if ( nChar == 0xa )
              nChar++;
          else if ( !bSymbol )
          {
              switch ( nChar )
              {
                  // Currency
                  case 128:   nChar = 0x20AC; break;
                  // Punctuation and other
                  case 130:   nChar = 0x201A; break;// SINGLE LOW-9 QUOTATION MARK
                  case 131:   nChar = 0x0192; break;// LATIN SMALL LETTER F WITH HOOK
                  case 132:   nChar = 0x201E; break;// DOUBLE LOW-9 QUOTATION MARK
                                                        // LOW DOUBLE PRIME QUOTATION MARK
                  case 133:   nChar = 0x2026; break;// HORIZONTAL ELLIPSES
                  case 134:   nChar = 0x2020; break;// DAGGER
                  case 135:   nChar = 0x2021; break;// DOUBLE DAGGER
                  case 136:   nChar = 0x02C6; break;// MODIFIER LETTER CIRCUMFLEX ACCENT
                  case 137:   nChar = 0x2030; break;// PER MILLE SIGN
                  case 138:   nChar = 0x0160; break;// LATIN CAPITAL LETTER S WITH CARON
                  case 139:   nChar = 0x2039; break;// SINGLE LEFT-POINTING ANGLE QUOTATION MARK
                  case 140:   nChar = 0x0152; break;// LATIN CAPITAL LIGATURE OE
                  case 142:   nChar = 0x017D; break;// LATIN CAPITAL LETTER Z WITH CARON
                  case 145:   nChar = 0x2018; break;// LEFT SINGLE QUOTATION MARK
                                                        // MODIFIER LETTER TURNED COMMA
                  case 146:   nChar = 0x2019; break;// RIGHT SINGLE QUOTATION MARK
                                                        // MODIFIER LETTER APOSTROPHE
                  case 147:   nChar = 0x201C; break;// LEFT DOUBLE QUOTATION MARK
                                                        // REVERSED DOUBLE PRIME QUOTATION MARK
                  case 148:   nChar = 0x201D; break;// RIGHT DOUBLE QUOTATION MARK
                                                        // REVERSED DOUBLE PRIME QUOTATION MARK
                  case 149:   nChar = 0x2022; break;// BULLET
                  case 150:   nChar = 0x2013; break;// EN DASH
                  case 151:   nChar = 0x2014; break;// EM DASH
                  case 152:   nChar = 0x02DC; break;// SMALL TILDE
                  case 153:   nChar = 0x2122; break;// TRADE MARK SIGN
                  case 154:   nChar = 0x0161; break;// LATIN SMALL LETTER S WITH CARON
                  case 155:   nChar = 0x203A; break;// SINGLE RIGHT-POINTING ANGLE QUOTATION MARK
                  case 156:   nChar = 0x0153; break;// LATIN SMALL LIGATURE OE
                  case 158:   nChar = 0x017E; break;// LATIN SMALL LETTER Z WITH CARON
                  case 159:   nChar = 0x0178; break;// LATIN CAPITAL LETTER Y WITH DIAERESIS
              }
          }
          mpText[ i ] = nChar;
      }
  }
  if ( bRTL_endingParen )
      mpText[ mnTextSize - 2 ] = 0x200F; // Unicode Right-to-Left mark

  if ( bLast )
      mpText[ mnTextSize - 1 ] = 0xd;

  if ( bPropSetsValid )
      ImplGetPortionValues( rFontCollection, true );
212}

214PortionObj::PortionObj( const PortionObj& rPortionObj )
PropStateValue( rPortionObj )
216{
  ImplConstruct( rPortionObj );
218}

220PortionObj::~PortionObj()
221{
  ImplClear();
223}

225void PortionObj::Write( SvStream* pStrm, bool bLast )
226{
  sal_uInt32 nCount = mnTextSize;
  if ( bLast && mbLastPortion )
      nCount--;
  for ( sal_uInt32 i = 0; i < nCount; i++ )
      pStrm->WriteUInt16( mpText[ i ] );
232}

234void PortionObj::ImplGetPortionValues( FontCollection& rFontCollection, bool bGetPropStateValue )
235{

  bool bOk = ImplGetPropertyValue( "CharFontName", bGetPropStateValue );
  meFontName = ePropState;
  if ( bOk )
  {
      FontCollectionEntry aFontDesc( *o3tl::doAccess<OUString>(mAny) );
      sal_uInt32  nCount = rFontCollection.GetCount();
      mnFont = static_cast<sal_uInt16>(rFontCollection.GetId( aFontDesc ));
      if ( mnFont == nCount )
      {
          FontCollectionEntry& rFontDesc = rFontCollection.GetLast();
          if ( ImplGetPropertyValue( "CharFontCharSet", false ) )
              mAny >>= rFontDesc.CharSet;
          if ( ImplGetPropertyValue( "CharFontFamily", false ) )
              mAny >>= rFontDesc.Family;
          if ( ImplGetPropertyValue( "CharFontPitch", false ) )
              mAny >>= rFontDesc.Pitch;
      }
  }

  sal_Int16 nScriptType = SvtLanguageOptions::FromSvtScriptTypeToI18N( SvtLanguageOptions::GetScriptTypeOfLanguage( Application::GetSettings().GetLanguageTag().getLanguageType() ) );
  if ( mpText && mnTextSize && xPPTBreakIter.is() )
  {
      OUString sT( reinterpret_cast<sal_Unicode *>(mpText.get()), mnTextSize );
      nScriptType = xPPTBreakIter->getScriptType( sT, 0 );
  }
  if ( nScriptType != css::i18n::ScriptType::COMPLEX )
  {
      bOk = ImplGetPropertyValue( "CharFontNameAsian", bGetPropStateValue );
      meAsianOrComplexFont = ePropState;
      if ( bOk )
      {
          FontCollectionEntry aFontDesc( *o3tl::doAccess<OUString>(mAny) );
          sal_uInt32  nCount = rFontCollection.GetCount();
          mnAsianOrComplexFont = static_cast<sal_uInt16>(rFontCollection.GetId( aFontDesc ));
          if ( mnAsianOrComplexFont == nCount )
          {
              FontCollectionEntry& rFontDesc = rFontCollection.GetLast();
              if ( ImplGetPropertyValue( "CharFontCharSetAsian", false ) )
                  mAny >>= rFontDesc.CharSet;
              if ( ImplGetPropertyValue( "CharFontFamilyAsian", false ) )
                  mAny >>= rFontDesc.Family;
              if ( ImplGetPropertyValue( "CharFontPitchAsian", false ) )
                  mAny >>= rFontDesc.Pitch;
          }
      }
  }
  else
  {
      bOk = ImplGetPropertyValue( "CharFontNameComplex", bGetPropStateValue );
      meAsianOrComplexFont = ePropState;
      if ( bOk )
      {
          FontCollectionEntry aFontDesc( *o3tl::doAccess<OUString>(mAny) );
          sal_uInt32  nCount = rFontCollection.GetCount();
          mnAsianOrComplexFont = static_cast<sal_uInt16>(rFontCollection.GetId( aFontDesc ));
          if ( mnAsianOrComplexFont == nCount )
          {
              FontCollectionEntry& rFontDesc = rFontCollection.GetLast();
              if ( ImplGetPropertyValue( "CharFontCharSetComplex", false ) )
                  mAny >>= rFontDesc.CharSet;
              if ( ImplGetPropertyValue( "CharFontFamilyComplex", false ) )
                  mAny >>= rFontDesc.Family;
              if ( ImplGetPropertyValue( "CharFontPitchComplex", false ) )
                  mAny >>= rFontDesc.Pitch;
          }
      }
  }

  OUString aCharHeightName, aCharWeightName, aCharLocaleName, aCharPostureName;
  switch( nScriptType )
  {
      case css::i18n::ScriptType::ASIAN :
      {
          aCharHeightName  = "CharHeightAsian";
          aCharWeightName  = "CharWeightAsian";
          aCharLocaleName  = "CharLocaleAsian";
          aCharPostureName = "CharPostureAsian";
          break;
      }
      case css::i18n::ScriptType::COMPLEX :
      {
          aCharHeightName  = "CharHeightComplex";
          aCharWeightName  = "CharWeightComplex";
          aCharLocaleName  = "CharLocaleComplex";
          aCharPostureName = "CharPostureComplex";
          break;
      }
      default:
      {
          aCharHeightName  = "CharHeight";
          aCharWeightName  = "CharWeight";
          aCharLocaleName  = "CharLocale";
          aCharPostureName = "CharPosture";
          break;
      }
  }

  mnCharHeight = 24;
  if ( GetPropertyValue( mAny, mXPropSet, aCharHeightName ) )
  {
      float fVal(0.0);
      if ( mAny >>= fVal )
      {
          mnCharHeight = static_cast<sal_uInt16>( fVal + 0.5 );
          meCharHeight = GetPropertyState( mXPropSet, aCharHeightName );
      }
  }
  if ( GetPropertyValue( mAny, mXPropSet, aCharWeightName ) )
  {
      float fFloat(0.0);
      if ( mAny >>= fFloat )
      {
          if ( fFloat >= css::awt::FontWeight::SEMIBOLD )
              mnCharAttr |= 1;
          if ( GetPropertyState( mXPropSet, aCharWeightName ) == css::beans::PropertyState_DIRECT_VALUE )
              mnCharAttrHard |= 1;
      }
  }
  if ( GetPropertyValue( mAny, mXPropSet, aCharLocaleName ) )
  {
      css::lang::Locale eLocale;
      if ( mAny >>= eLocale )
          meCharLocale = eLocale;
  }
  if ( GetPropertyValue( mAny, mXPropSet, aCharPostureName ) )
  {
      css::awt::FontSlant aFS;
      if ( mAny >>= aFS )
      {
          switch( aFS )
          {
              case css::awt::FontSlant_OBLIQUE :
              case css::awt::FontSlant_ITALIC :
                  mnCharAttr |= 2;
                  break;
              default:
                  break;
          }
          if ( GetPropertyState( mXPropSet, aCharPostureName ) == css::beans::PropertyState_DIRECT_VALUE )
              mnCharAttrHard |= 2;
      }
  }

  if ( ImplGetPropertyValue( "CharUnderline", bGetPropStateValue ) )
  {
      sal_Int16 nVal(0);
      mAny >>= nVal;
      switch ( nVal )
      {
          case css::awt::FontUnderline::SINGLE :
          case css::awt::FontUnderline::DOUBLE :
          case css::awt::FontUnderline::DOTTED :
              mnCharAttr |= 4;
      }
  }
  if ( ePropState == css::beans::PropertyState_DIRECT_VALUE )
      mnCharAttrHard |= 4;

  if ( ImplGetPropertyValue( "CharShadowed", bGetPropStateValue ) )
  {
      bool bBool(false);
      mAny >>= bBool;
      if ( bBool )
          mnCharAttr |= 0x10;
  }
  if ( ePropState == css::beans::PropertyState_DIRECT_VALUE )
      mnCharAttrHard |= 16;

  if ( ImplGetPropertyValue( "CharRelief", bGetPropStateValue ) )
  {
      sal_Int16 nVal(0);
      mAny >>= nVal;
      if ( nVal != css::text::FontRelief::NONE )
          mnCharAttr |= 512;
  }
  if ( ePropState == css::beans::PropertyState_DIRECT_VALUE )
      mnCharAttrHard |= 512;

  if ( ImplGetPropertyValue( "CharColor", bGetPropStateValue ) )
  {
      sal_uInt32 nSOColor = *( o3tl::doAccess<sal_uInt32>(mAny) );
      mnCharColor = nSOColor & 0xff00ff00;                            // green and hibyte
      mnCharColor |= static_cast<sal_uInt8>(nSOColor) << 16;                   // red and blue is switched
      mnCharColor |= static_cast<sal_uInt8>( nSOColor >> 16 );
  }
  meCharColor = ePropState;

  mnCharEscapement = 0;
  if ( ImplGetPropertyValue( "CharEscapement", bGetPropStateValue ) )
  {
      mAny >>= mnCharEscapement;
      if ( mnCharEscapement > 100 )
          mnCharEscapement = 33;
      else if ( mnCharEscapement < -100 )
          mnCharEscapement = -33;
  }
  meCharEscapement = ePropState;
434}

436void PortionObj::ImplClear()
437{
  mpFieldEntry.reset();
  mpText.reset();
440}

442void PortionObj::ImplConstruct( const PortionObj& rPortionObj )
443{
  meCharColor = rPortionObj.meCharColor;
  meCharHeight = rPortionObj.meCharHeight;
  meFontName = rPortionObj.meFontName;
  meAsianOrComplexFont = rPortionObj.meAsianOrComplexFont;
  meCharEscapement = rPortionObj.meCharEscapement;
  meCharLocale = rPortionObj.meCharLocale;
  mnCharAttrHard = rPortionObj.mnCharAttrHard;

  mbLastPortion = rPortionObj.mbLastPortion;
  mnTextSize = rPortionObj.mnTextSize;
  mnCharColor = rPortionObj.mnCharColor;
  mnCharEscapement = rPortionObj.mnCharEscapement;
  mnCharAttr = rPortionObj.mnCharAttr;
  mnCharHeight = rPortionObj.mnCharHeight;
  mnFont = rPortionObj.mnFont;
  mnAsianOrComplexFont = rPortionObj.mnAsianOrComplexFont;

  if ( rPortionObj.mpText )
  {
      mpText.reset( new sal_uInt16[ mnTextSize ] );
      memcpy( mpText.get(), rPortionObj.mpText.get(), mnTextSize << 1 );
  }

  if ( rPortionObj.mpFieldEntry )
      mpFieldEntry.reset( new FieldEntry( *( rPortionObj.mpFieldEntry ) ) );
469}

471sal_uInt32 PortionObj::ImplCalculateTextPositions( sal_uInt32 nCurrentTextPosition )
472{
  if ( mpFieldEntry && ( !mpFieldEntry->nFieldStartPos ) )
  {
      mpFieldEntry->nFieldStartPos += nCurrentTextPosition;
      mpFieldEntry->nFieldEndPos += nCurrentTextPosition;
  }
  return mnTextSize;
479}

481// Return:                              0 = no TextField
482//  bit28->31   text field type :
483//                                      1 = Date
484//                                      2 = Time
485//                                      3 = SlideNumber
486//                                      4 = Url
487//                                      5 = DateTime
488//                                      6 = header
489//                                      7 = footer
490//  bit24->27   text field sub type (optional)
491//     23->     PPT Textfield needs a placeholder

493sal_uInt32 PortionObj::ImplGetTextField( css::uno::Reference< css::text::XTextRange > & ,
  const css::uno::Reference< css::beans::XPropertySet > & rXPropSet, OUString& rURL )
495{
  sal_uInt32 nRetValue = 0;
  sal_Int32 nFormat;
  css::uno::Any aAny;
  if ( GetPropertyValue( aAny, rXPropSet, "TextPortionType", true ) )
  {
      auto aTextFieldType = o3tl::doAccess<OUString>(aAny);
      if ( *aTextFieldType == "TextField" )
      {
          if ( GetPropertyValue( aAny, rXPropSet, *aTextFieldType, true ) )
          {
              css::uno::Reference< css::text::XTextField > aXTextField;
              if ( aAny >>= aXTextField )
              {
                  if ( aXTextField.is() )
                  {
                      css::uno::Reference< css::beans::XPropertySet > xFieldPropSet( aXTextField, css::uno::UNO_QUERY );
                      if ( xFieldPropSet.is() )
                      {
                          OUString aFieldKind( aXTextField->getPresentation( true ) );
                          if ( aFieldKind == "Date" )
                          {
                              if ( GetPropertyValue( aAny, xFieldPropSet, "IsFix", true ) )
                              {
                                  bool bBool = false;
                                  aAny >>= bBool;
                                  if ( !bBool )  // Fixed DateFields does not exist in PPT
                                  {
                                      if ( GetPropertyValue( aAny, xFieldPropSet, "Format", true ) )
                                      {
                                          nFormat = *o3tl::doAccess<sal_Int32>(aAny);
                                          switch ( nFormat )
                                          {
                                              default:
                                              case 5 :
                                              case 4 :
                                              case 2 : nFormat = 0; break;
                                              case 8 :
                                              case 9 :
                                              case 3 : nFormat = 1; break;
                                              case 7 :
                                              case 6 : nFormat = 2; break;
                                          }
                                          nRetValue |= ( ( ( 1 << 4 ) | nFormat ) << 24 ) | 0x800000;
                                      }
                                  }
                              }
                          }
                          else if ( aFieldKind == "URL" )
                          {
                              if ( GetPropertyValue( aAny, xFieldPropSet, "URL", true ) )
                                  rURL = *o3tl::doAccess<OUString>(aAny);
                              nRetValue = 4 << 28;
                          }
                          else if ( aFieldKind == "Page" )
                          {
                              nRetValue = 3 << 28 | 0x800000;
                          }
                          else if ( aFieldKind == "Pages" )
                          {

                          }
                          else if ( aFieldKind == "Time" )
                          {
                              if ( GetPropertyValue( aAny, xFieldPropSet, "IsFix", true ) )
                              {
                                  bool bBool = false;
                                  aAny >>= bBool;
                                  if ( !bBool )
                                  {
                                      if ( GetPropertyValue( aAny, xFieldPropSet, "IsFix", true ) )
                                      {
                                          nFormat = *o3tl::doAccess<sal_Int32>(aAny);
                                          nRetValue |= ( ( ( 2 << 4 ) | nFormat ) << 24 ) | 0x800000;
                                      }
                                  }
                              }
                          }
                          else if ( aFieldKind == "File" )
                          {

                          }
                          else if ( aFieldKind == "Table" )
                          {

                          }
                          else if ( aFieldKind == "ExtTime" )
                          {
                              if ( GetPropertyValue( aAny, xFieldPropSet, "IsFix", true ) )
                              {
                                  bool bBool = false;
                                  aAny >>= bBool;
                                  if ( !bBool )
                                  {
                                      if ( GetPropertyValue( aAny, xFieldPropSet, "Format", true ) )
                                      {
                                          nFormat = *o3tl::doAccess<sal_Int32>(aAny);
                                          switch ( nFormat )
                                          {
                                              default:
                                              case 6 :
                                              case 7 :
                                              case 8 :
                                              case 2 : nFormat = 12; break;
                                              case 3 : nFormat = 9; break;
                                              case 5 :
                                              case 4 : nFormat = 10; break;

                                          }
                                          nRetValue |= ( ( ( 2 << 4 ) | nFormat ) << 24 ) | 0x800000;
                                      }
                                  }
                              }
                          }
                          else if ( aFieldKind == "ExtFile" )
                          {

                          }
                          else if ( aFieldKind ==  "Author" )
                          {

                          }
                          else if ( aFieldKind == "DateTime" )
                          {
                              nRetValue = 5 << 28 | 0x800000;
                          }
                          else if ( aFieldKind == "Header" )
                          {
                              nRetValue = 6 << 28 | 0x800000;
                          }
                          else if ( aFieldKind == "Footer" )
                          {
                              nRetValue = 7 << 28 | 0x800000;
                          }
                      }
                  }
              }
          }
      }
  }
  return nRetValue;
636}

638PortionObj& PortionObj::operator=( const PortionObj& rPortionObj )
639{
  if ( this != &rPortionObj )
  {
      ImplClear();
      ImplConstruct( rPortionObj );
  }
  return *this;
646}

648ParagraphObj::ParagraphObj(const css::uno::Reference< css::beans::XPropertySet > & rXPropSet,
  PPTExBulletProvider* pProv)
  : PropStateValue()
  , SOParagraph()
  , mvPortions()
  , mnTextSize(0)
  , mbFirstParagraph(false)
  , mbLastParagraph(false)
  , mnTextAdjust(0)
  , mnLineSpacing(0)
  , mbFixedLineSpacing(false)
  , mnLineSpacingTop(0)
  , mnLineSpacingBottom(0)
  , mbForbiddenRules(false)
  , mbParagraphPunctation(false)
  , mnBiDi(0)
664{
  mXPropSet = rXPropSet;

  bExtendedParameters = false;

  nDepth = 0;
  nBulletFlags = 0;
  nParaFlags = 0;

  ImplGetParagraphValues( pProv, false );
674}

676ParagraphObj::ParagraphObj(css::uno::Reference< css::text::XTextContent > const & rXTextContent,
  ParaFlags aParaFlags, FontCollection& rFontCollection, PPTExBulletProvider& rProv )
  : PropStateValue()
  , SOParagraph()
  , mvPortions()
  , mnTextSize(0)
  , mbIsBullet(false)
  , mbFirstParagraph( aParaFlags.bFirstParagraph )
  , mbLastParagraph( aParaFlags.bLastParagraph )
  , meBullet(css::beans::PropertyState_AMBIGUOUS_VALUE)
  , meTextAdjust(css::beans::PropertyState_AMBIGUOUS_VALUE)
  , meLineSpacing(css::beans::PropertyState_AMBIGUOUS_VALUE)
  , meLineSpacingTop(css::beans::PropertyState_AMBIGUOUS_VALUE)
  , meLineSpacingBottom(css::beans::PropertyState_AMBIGUOUS_VALUE)
  , meForbiddenRules(css::beans::PropertyState_AMBIGUOUS_VALUE)
  , meParagraphPunctation(css::beans::PropertyState_AMBIGUOUS_VALUE)
  , meBiDi(css::beans::PropertyState_AMBIGUOUS_VALUE)
  , mnTextAdjust(0)
  , mnLineSpacing(0)
  , mbFixedLineSpacing(false)
  , mnLineSpacingTop(0)
  , mnLineSpacingBottom(0)
  , mbForbiddenRules(false)
  , mbParagraphPunctation(false)
  , mnBiDi(0)
701{
  bExtendedParameters = false;

  nDepth = 0;
  nBulletFlags = 0;
  nParaFlags = 0;

  mXPropSet.set( rXTextContent, css::uno::UNO_QUERY );

  mXPropState.set( rXTextContent, css::uno::UNO_QUERY );

  if ( !(mXPropSet.is() && mXPropState.is()) )
      return;

  css::uno::Reference< css::container::XEnumerationAccess > aXTextPortionEA( rXTextContent, css::uno::UNO_QUERY );
  if ( aXTextPortionEA.is() )
  {
      css::uno::Reference< css::container::XEnumeration > aXTextPortionE( aXTextPortionEA->createEnumeration() );
      if ( aXTextPortionE.is() )
      {
          while ( aXTextPortionE->hasMoreElements() )
          {
              css::uno::Reference< css::text::XTextRange > aXCursorText;
              css::uno::Any aAny( aXTextPortionE->nextElement() );
              if ( aAny >>= aXCursorText )
              {
                  std::unique_ptr<PortionObj> pPortionObj(new PortionObj( aXCursorText, !aXTextPortionE->hasMoreElements(), rFontCollection ));
                  if ( pPortionObj->Count() )
                      mvPortions.push_back( std::move(pPortionObj) );
              }
          }
      }
  }
  ImplGetParagraphValues( &rProv, true );
735}

737ParagraphObj::~ParagraphObj()
738{
  ImplClear();
740}

742void ParagraphObj::Write( SvStream* pStrm )
743{
  for ( std::vector<std::unique_ptr<PortionObj> >::iterator it = mvPortions.begin(); it != mvPortions.end(); ++it )
      (*it)->Write( pStrm, mbLastParagraph );
746}

748void ParagraphObj::ImplClear()
749{
  mvPortions.clear();
751}

753void ParagraphObj::CalculateGraphicBulletSize( sal_uInt16 nFontHeight )
754{
  if ( ( nNumberingType != SVX_NUM_BITMAP ) || ( nBulletId == 0xffff ) )
      return;

  // calculate the bullet real size for this graphic
  if ( aBuGraSize.Width() && aBuGraSize.Height() )
  {
      double fCharHeight = nFontHeight;
      double fLen = aBuGraSize.Height();
      fCharHeight = fCharHeight * 0.2540;
      double fQuo = fLen / fCharHeight;
      nBulletRealSize = static_cast<sal_Int16>( fQuo + 0.5 );
      if ( static_cast<sal_uInt16>(nBulletRealSize) > 400 )
          nBulletRealSize = 400;
  }
769}

771void ParagraphObj::ImplGetNumberingLevel( PPTExBulletProvider* pBuProv, sal_Int16 nNumberingDepth, bool bIsBullet, bool bGetPropStateValue )
772{
  css::uno::Any aAny;
  if ( GetPropertyValue( aAny, mXPropSet, "ParaLeftMargin" ) )
  {
      sal_Int32 nVal(0);
      if ( aAny >>= nVal )
          nTextOfs = static_cast< sal_Int16 >( nVal / ( 2540.0 / 576 ) + 0.5 ) ;
  }
  if ( GetPropertyValue( aAny, mXPropSet, "ParaFirstLineIndent" ) )
  {
      if ( aAny >>= nBulletOfs )
          nBulletOfs = static_cast< sal_Int32 >( nBulletOfs / ( 2540.0 / 576 ) + 0.5 );
  }
  if ( GetPropertyValue( aAny, mXPropSet, "NumberingIsNumber" ) )
      aAny >>= bNumberingIsNumber;

  css::uno::Reference< css::container::XIndexReplace > aXIndexReplace;

  if ( bIsBullet && ImplGetPropertyValue( "NumberingRules", bGetPropStateValue ) )
  {
      if ( ( mAny >>= aXIndexReplace ) && nNumberingDepth < aXIndexReplace->getCount() )
      {
          mAny = aXIndexReplace->getByIndex( nNumberingDepth );
          auto aPropertySequence = o3tl::doAccess<css::uno::Sequence<css::beans::PropertyValue>>(mAny);

          if ( aPropertySequence->hasElements() )
          {
              bExtendedParameters = true;
              nBulletRealSize = 100;
              nMappedNumType = 0;

              uno::Reference<graphic::XGraphic> xGraphic;
              for ( const css::beans::PropertyValue& rPropValue : *aPropertySequence )
              {
                  OUString aPropName( rPropValue.Name );
                  if ( aPropName == "NumberingType" )
                      nNumberingType = static_cast<SvxNumType>(*o3tl::doAccess<sal_Int16>(rPropValue.Value));
                  else if ( aPropName == "Adjust" )
                      nHorzAdjust = *o3tl::doAccess<sal_Int16>(rPropValue.Value);
                  else if ( aPropName == "BulletChar" )
                  {
                      OUString aString( *o3tl::doAccess<OUString>(rPropValue.Value) );
                      if ( !aString.isEmpty() )
                          cBulletId = aString[ 0 ];
                  }
                  else if ( aPropName == "BulletFont" )
                  {
                      aFontDesc = *o3tl::doAccess<css::awt::FontDescriptor>(rPropValue.Value);

                      // Our numbullet dialog has set the wrong textencoding for our "StarSymbol" font,
                      // instead of a Unicode encoding the encoding RTL_TEXTENCODING_SYMBOL was used.
                      // Because there might exist a lot of damaged documents I added this two lines
                      // which fixes the bullet problem for the export.
                      if ( aFontDesc.Name.equalsIgnoreAsciiCase("StarSymbol") )
                          aFontDesc.CharSet = RTL_TEXTENCODING_MS_1252(((rtl_TextEncoding) 1));

                  }
                  else if ( aPropName == "GraphicBitmap" )
                  {
                      auto xBitmap = rPropValue.Value.get<uno::Reference<awt::XBitmap>>();
                      xGraphic.set(xBitmap, uno::UNO_QUERY);
                  }
                  else if ( aPropName == "GraphicSize" )
                  {
                      if (auto aSize = o3tl::tryAccess<css::awt::Size>(rPropValue.Value))
                      {
                          // don't cast awt::Size to Size as on 64-bits they are not the same.
                          aBuGraSize.setWidth( aSize->Width );
                          aBuGraSize.setHeight( aSize->Height );
                      }
                  }
                  else if ( aPropName == "StartWith" )
                      nStartWith = *o3tl::doAccess<sal_Int16>(rPropValue.Value);
                  else if ( aPropName == "LeftMargin" )
                      nTextOfs = nTextOfs + static_cast< sal_Int16 >( *o3tl::doAccess<sal_Int32>(rPropValue.Value) / ( 2540.0 / 576 ) );
                  else if ( aPropName == "FirstLineOffset" )
                      nBulletOfs += static_cast<sal_Int16>( *o3tl::doAccess<sal_Int32>(rPropValue.Value) / ( 2540.0 / 576 ) );
                  else if ( aPropName == "BulletColor" )
                  {
                      sal_uInt32 nSOColor = *o3tl::doAccess<sal_uInt32>(rPropValue.Value);
                      nBulletColor = nSOColor & 0xff00ff00;                       // green and hibyte
                      nBulletColor |= static_cast<sal_uInt8>(nSOColor) << 16;              // red
                      nBulletColor |= static_cast<sal_uInt8>( nSOColor >> 16 ) | 0xfe000000; // blue
                  }
                  else if ( aPropName == "BulletRelSize" )
                  {
                      nBulletRealSize = *o3tl::doAccess<sal_Int16>(rPropValue.Value);
                      nParaFlags |= 0x40;
                      nBulletFlags |= 8;
                  }
                  else if ( aPropName == "Prefix" )
                      sPrefix = *o3tl::doAccess<OUString>(rPropValue.Value);
                  else if ( aPropName == "Suffix" )
                      sSuffix = *o3tl::doAccess<OUString>(rPropValue.Value);
866#ifdef DBG_UTIL
                  else if ( aPropName != "SymbolTextDistance" && aPropName != "GraphicBitmap" )
                  {
                      OSL_FAIL( "Unknown Property" )do { if (true && (((sal_Bool)1))) { sal_detail_logFormat
((SAL_DETAIL_LOG_LEVEL_WARN), ("legacy.osl"), ("/home/maarten/src/libreoffice/core/sd/source/filter/eppt/pptx-text.cxx"
 ":" "869" ": "), "%s", "Unknown Property"); } } while (false
);
                  }
871#endif
              }

              if (xGraphic.is())
              {
                  if ( aBuGraSize.Width() && aBuGraSize.Height() )
                  {
                      nBulletId = pBuProv->GetId(xGraphic, aBuGraSize );
                      if ( nBulletId != 0xffff )
                          bExtendedBulletsUsed = true;
                  }
                  else
                  {
                      nNumberingType = SVX_NUM_NUMBER_NONE;
                  }
              }

              CalculateGraphicBulletSize( ( mvPortions.empty() ) ? 24 : mvPortions.front()->mnCharHeight );

              switch( nNumberingType )
              {
                  case SVX_NUM_NUMBER_NONE : nParaFlags |= 0xf; break;

                  case SVX_NUM_CHAR_SPECIAL :                           // Bullet
                  {
                      if ( IsStarSymbol(aFontDesc.Name) )
                      {
                          rtl_TextEncoding eChrSet = aFontDesc.CharSet;
                          cBulletId = msfilter::util::bestFitOpenSymbolToMSFont(cBulletId, eChrSet, aFontDesc.Name);
                          aFontDesc.CharSet = eChrSet;
                      }

                      if ( !aFontDesc.Name.isEmpty() )
                      {
                          nParaFlags |= 0x90; // we define the font and charset
                      }

                      [[fallthrough]];
                  }
                  case SVX_NUM_CHARS_UPPER_LETTER :       // count from a-z, aa - az, ba - bz, ...
                  case SVX_NUM_CHARS_LOWER_LETTER :
                  case SVX_NUM_ROMAN_UPPER :
                  case SVX_NUM_ROMAN_LOWER :
                  case SVX_NUM_ARABIC :
                  case SVX_NUM_PAGEDESC :                 // numbering from the page template
                  case SVX_NUM_BITMAP :
                  case SVX_NUM_CHARS_UPPER_LETTER_N :     // count from a-z, aa-zz, aaa-zzz
                  case SVX_NUM_CHARS_LOWER_LETTER_N :
                  case SVX_NUM_NUMBER_UPPER_ZH:
                  case SVX_NUM_CIRCLE_NUMBER:
                  case SVX_NUM_NUMBER_UPPER_ZH_TW:
                  case SVX_NUM_NUMBER_LOWER_ZH:
                  case SVX_NUM_FULL_WIDTH_ARABIC:
                  {
                      if ( nNumberingType != SVX_NUM_CHAR_SPECIAL )
                      {
                          bExtendedBulletsUsed = true;
                          if ( nNumberingDepth & 1 )
                              cBulletId = 0x2013;         // defaulting bullet characters for ppt97
                          else if ( nNumberingDepth == 4 )
                              cBulletId = 0xbb;
                          else
                              cBulletId = 0x2022;

                          switch( nNumberingType )
                          {
                              case SVX_NUM_CHARS_UPPER_LETTER :
                              case SVX_NUM_CHARS_UPPER_LETTER_N :
                              {
                                  if ( sSuffix == ")" )
                                  {
                                      if ( sPrefix == "(" )
                                          nMappedNumType = 0xa0001;   // (A)
                                      else
                                          nMappedNumType = 0xb0001;   // A)
                                  }
                                  else
                                      nMappedNumType = 0x10001;       // A.
                              }
                              break;
                              case SVX_NUM_CHARS_LOWER_LETTER :
                              case SVX_NUM_CHARS_LOWER_LETTER_N :
                              {
                                  if ( sSuffix == ")" )
                                  {
                                      if ( sPrefix == "(" )
                                          nMappedNumType = 0x80001;   // (a)
                                      else
                                          nMappedNumType = 0x90001;   // a)
                                  }
                                  else
                                      nMappedNumType = 0x00001;       // a.
                              }
                              break;
                              case SVX_NUM_ROMAN_UPPER :
                              {
                                  if ( sSuffix == ")" )
                                  {
                                      if ( sPrefix == "(" )
                                          nMappedNumType = 0xe0001;   // (I)
                                      else
                                          nMappedNumType = 0xf0001;   // I)
                                  }
                                  else
                                      nMappedNumType = 0x70001;       // I.
                              }
                              break;
                              case SVX_NUM_ROMAN_LOWER :
                              {
                                  if ( sSuffix == ")" )
                                  {
                                      if ( sPrefix == "(" )
                                          nMappedNumType = 0x40001;   // (i)
                                      else
                                          nMappedNumType = 0x50001;   // i)
                                  }
                                  else
                                      nMappedNumType = 0x60001;       // i.
                              }
                              break;
                              case SVX_NUM_ARABIC :
                              {
                                  if ( sSuffix == ")" )
                                  {
                                      if ( sPrefix == "(" )
                                          nMappedNumType = 0xc0001;   // (1)
                                      else
                                          nMappedNumType = 0x20001;   // 1)
                                  }
                                  else
                                  {
                                      if ( sSuffix.isEmpty() && sPrefix.isEmpty() )
                                          nMappedNumType = 0xd0001;   // 1
                                      else
                                          nMappedNumType = 0x30001;   // 1.
                                  }
                              }
                              break;
                              case SVX_NUM_NUMBER_UPPER_ZH :
                              {
                                  if ( !sSuffix.isEmpty() )
                                      nMappedNumType = 0x110001;   // Simplified Chinese with single-byte period.
                                  else
                                      nMappedNumType = 0x100001;   // Simplified Chinese.
                              }
                              break;
                              case SVX_NUM_CIRCLE_NUMBER :
                              {
                                  nMappedNumType = 0x120001;   // Double byte circle numbers.
                              }
                              break;
                              case SVX_NUM_NUMBER_UPPER_ZH_TW :
                              {
                                  if ( !sSuffix.isEmpty() )
                                      nMappedNumType = 0x160001;   // Traditional Chinese with single-byte period.
                                  else
                                      nMappedNumType = 0x150001;   // Traditional Chinese.
                              }
                              break;
                              case SVX_NUM_NUMBER_LOWER_ZH :
                              {
                                  if ( sSuffix == u"\uff0e" )
                                      nMappedNumType = 0x260001;   // Japanese with double-byte period.
                                  else if ( !sSuffix.isEmpty() )
                                      nMappedNumType = 0x1B0001;   // Japanese/Korean with single-byte period.
                                  else
                                      nMappedNumType = 0x1A0001;   // Japanese/Korean.
                              }
                              break;
                              case SVX_NUM_FULL_WIDTH_ARABIC :
                              {
                                  if ( !sSuffix.isEmpty() )
                                      nMappedNumType = 0x1D0001;   // Double-byte Arabic numbers with double-byte period.
                                  else
                                      nMappedNumType = 0x1C0001;   // Double-byte Arabic numbers.
                              }
                              break;
                              default:
                                  break;
                          }
                      }
                      nParaFlags |= 0x2f;
                      nBulletFlags |= 6;
                      if ( mbIsBullet && bNumberingIsNumber )
                          nBulletFlags |= 1;
                      break;
                  }
                  default:
                      break;
              }
          }
      }
  }
  nBulletOfs = nTextOfs + nBulletOfs;
  if ( nBulletOfs < 0 )
      nBulletOfs = 0;
1067}

1069void ParagraphObj::ImplGetParagraphValues( PPTExBulletProvider* pBuProv, bool bGetPropStateValue )
1070{
  css::uno::Any aAny;
  if ( GetPropertyValue( aAny, mXPropSet, "NumberingLevel", true ) )
  {
      if ( bGetPropStateValue )
          meBullet = GetPropertyState( mXPropSet, "NumberingLevel" );
      nDepth = *o3tl::doAccess<sal_Int16>(aAny);

      if ( nDepth < 0 )
      {
          mbIsBullet = false;
          nDepth = 0;
      }
      else
      {
          if ( nDepth > 4 )
              nDepth = 4;
          mbIsBullet = true;
      }
  }
  else
  {
      nDepth = 0;
      mbIsBullet = false;
  }
  ImplGetNumberingLevel( pBuProv, nDepth, mbIsBullet, bGetPropStateValue );

  if ( ImplGetPropertyValue( "ParaTabStops", bGetPropStateValue ) )
      maTabStop = *o3tl::doAccess<css::uno::Sequence<css::style::TabStop>>(mAny);
  sal_Int16 eTextAdjust = sal_Int16(css::style::ParagraphAdjust_LEFT);
  if ( GetPropertyValue( aAny, mXPropSet, "ParaAdjust", bGetPropStateValue ) )
      aAny >>= eTextAdjust;
  switch ( static_cast<css::style::ParagraphAdjust>(eTextAdjust) )
  {
      case css::style::ParagraphAdjust_CENTER :
          mnTextAdjust = 1;
      break;
      case css::style::ParagraphAdjust_RIGHT :
          mnTextAdjust = 2;
      break;
      case css::style::ParagraphAdjust_BLOCK :
          mnTextAdjust = 3;
      break;
      default :
      case css::style::ParagraphAdjust_LEFT :
          mnTextAdjust = 0;
      break;
  }
  meTextAdjust = ePropState;

  if ( ImplGetPropertyValue( "ParaLineSpacing", bGetPropStateValue ) )
  {
      css::style::LineSpacing aLineSpacing
          = *o3tl::doAccess<css::style::LineSpacing>(mAny);
      switch ( aLineSpacing.Mode )
      {
          case css::style::LineSpacingMode::FIX :
              mnLineSpacing = static_cast<sal_Int16>(-( aLineSpacing.Height ) );
              mbFixedLineSpacing = true;
              break;
          case css::style::LineSpacingMode::MINIMUM :
          case css::style::LineSpacingMode::LEADING :
              mnLineSpacing = static_cast<sal_Int16>(-( aLineSpacing.Height ) );
              mbFixedLineSpacing = false;
         break;

          case css::style::LineSpacingMode::PROP :
          default:
              mnLineSpacing = aLineSpacing.Height;
          break;
      }
  }
  meLineSpacing = ePropState;

  if ( ImplGetPropertyValue( "ParaBottomMargin", bGetPropStateValue ) )
  {
      double fSpacing = *o3tl::doAccess<sal_uInt32>(mAny) + ( 2540.0 / 576.0 ) - 1;
      mnLineSpacingBottom = static_cast<sal_Int16>(-( fSpacing * 576.0 / 2540.0 ) );
  }
  meLineSpacingBottom = ePropState;

  if ( ImplGetPropertyValue( "ParaTopMargin", bGetPropStateValue ) )
  {
      double fSpacing = *o3tl::doAccess<sal_uInt32>(mAny) + ( 2540.0 / 576.0 ) - 1;
      mnLineSpacingTop = static_cast<sal_Int16>(-( fSpacing * 576.0 / 2540.0 ) );
  }
  meLineSpacingTop = ePropState;

  if ( ImplGetPropertyValue( "ParaIsForbiddenRules", bGetPropStateValue ) )
      mAny >>= mbForbiddenRules;
  meForbiddenRules = ePropState;

  if ( ImplGetPropertyValue( "ParaIsHangingPunctuation", bGetPropStateValue ) )
      mAny >>= mbParagraphPunctation;
  meParagraphPunctation = ePropState;

  mnBiDi = 0;
  if ( ImplGetPropertyValue( "WritingMode", bGetPropStateValue ) )
  {
      sal_Int16 nWritingMode = 0;
      mAny >>= nWritingMode;

      SvxFrameDirection eWritingMode = static_cast<SvxFrameDirection>(nWritingMode);
      if ( ( eWritingMode == SvxFrameDirection::Horizontal_RL_TB )
          || ( eWritingMode == SvxFrameDirection::Vertical_RL_TB ) )
      {
          mnBiDi = 1;
      }
  }
  meBiDi = ePropState;
1180}

1182void ParagraphObj::ImplConstruct( const ParagraphObj& rParagraphObj )
1183{
  mbIsBullet = rParagraphObj.mbIsBullet;
  meBullet = rParagraphObj.meBullet;
  meTextAdjust = rParagraphObj.meTextAdjust;
  meLineSpacing = rParagraphObj.meLineSpacing;
  meLineSpacingTop = rParagraphObj.meLineSpacingTop;
  meLineSpacingBottom = rParagraphObj.meLineSpacingBottom;
  meForbiddenRules = rParagraphObj.meForbiddenRules;
  meParagraphPunctation = rParagraphObj.meParagraphPunctation;
  meBiDi =rParagraphObj.meBiDi;
  mbFixedLineSpacing = rParagraphObj.mbFixedLineSpacing;
  mnTextSize = rParagraphObj.mnTextSize;
  mnTextAdjust = rParagraphObj.mnTextAdjust;
  mnLineSpacing = rParagraphObj.mnLineSpacing;
  mnLineSpacingTop = rParagraphObj.mnLineSpacingTop;
  mnLineSpacingBottom = rParagraphObj.mnLineSpacingBottom;
  mbFirstParagraph = rParagraphObj.mbFirstParagraph;
  mbLastParagraph = rParagraphObj.mbLastParagraph;
  mbParagraphPunctation = rParagraphObj.mbParagraphPunctation;
  mbForbiddenRules = rParagraphObj.mbForbiddenRules;
  mnBiDi = rParagraphObj.mnBiDi;

  for ( std::vector<std::unique_ptr<PortionObj> >::const_iterator it = rParagraphObj.begin(); it != rParagraphObj.end(); ++it )
      mvPortions.push_back( std::make_unique<PortionObj>( **it ) );

  maTabStop = rParagraphObj.maTabStop;
  bExtendedParameters = rParagraphObj.bExtendedParameters;
  nParaFlags = rParagraphObj.nParaFlags;
  nBulletFlags = rParagraphObj.nBulletFlags;
  sPrefix = rParagraphObj.sPrefix;
  sSuffix = rParagraphObj.sSuffix;
  sGraphicUrl = rParagraphObj.sGraphicUrl;            // String to a graphic
  aBuGraSize = rParagraphObj.aBuGraSize;
  nNumberingType = rParagraphObj.nNumberingType;      // this is actually a SvxEnum
  nHorzAdjust = rParagraphObj.nHorzAdjust;
  nBulletColor = rParagraphObj.nBulletColor;
  nBulletOfs = rParagraphObj.nBulletOfs;
  nStartWith = rParagraphObj.nStartWith;              // start of numbering
  nTextOfs = rParagraphObj.nTextOfs;
  nBulletRealSize = rParagraphObj.nBulletRealSize;    // scale in percent
  nDepth = rParagraphObj.nDepth;                      // actual depth
  cBulletId = rParagraphObj.cBulletId;                // if Numbering Type == CharSpecial
  aFontDesc = rParagraphObj.aFontDesc;

  bExtendedBulletsUsed = rParagraphObj.bExtendedBulletsUsed;
  nBulletId = rParagraphObj.nBulletId;
1229}

1231sal_uInt32 ParagraphObj::ImplCalculateTextPositions( sal_uInt32 nCurrentTextPosition )
1232{
  mnTextSize = 0;
  for ( std::vector<std::unique_ptr<PortionObj> >::iterator it = mvPortions.begin(); it != mvPortions.end(); ++it )
      mnTextSize += (*it)->ImplCalculateTextPositions( nCurrentTextPosition + mnTextSize );
  return mnTextSize;
1237}

1239ParagraphObj& ParagraphObj::operator=( const ParagraphObj& rParagraphObj )
1240{
  if ( this != &rParagraphObj )
  {
      ImplClear();
      ImplConstruct( rParagraphObj );
  }
  return *this;
1247}

1249struct ImplTextObj
1250{
  sal_uInt32      mnTextSize;
  int             mnInstance;
  std::vector<std::unique_ptr<ParagraphObj>> maList;
  bool        mbHasExtendedBullets;

  explicit ImplTextObj( int nInstance );
1257};

1259ImplTextObj::ImplTextObj( int nInstance )
: mnTextSize(0),
  mnInstance(nInstance),
  maList(),
  mbHasExtendedBullets(false)
1264{
1265}

1267TextObj::TextObj( css::uno::Reference< css::text::XSimpleText > const & rXTextRef,
          int nInstance, FontCollection& rFontCollection, PPTExBulletProvider& rProv ):
  mpImplTextObj(std::make_shared<ImplTextObj>(nInstance))
1270{
  css::uno::Reference< css::container::XEnumerationAccess > aXTextParagraphEA( rXTextRef, css::uno::UNO_QUERY );

  if ( aXTextParagraphEA.is()  )
  {
      css::uno::Reference< css::container::XEnumeration > aXTextParagraphE( aXTextParagraphEA->createEnumeration() );
      if ( aXTextParagraphE.is() )
      {
          ParaFlags aParaFlags;
          while ( aXTextParagraphE->hasMoreElements() )
          {
              css::uno::Reference< css::text::XTextContent > aXParagraph;
              css::uno::Any aAny( aXTextParagraphE->nextElement() );
              if ( aAny >>= aXParagraph )
              {
                  if ( !aXTextParagraphE->hasMoreElements() )
                      aParaFlags.bLastParagraph = true;
                  std::unique_ptr<ParagraphObj> pPara(new ParagraphObj( aXParagraph, aParaFlags, rFontCollection, rProv ));
                  mpImplTextObj->mbHasExtendedBullets |= pPara->bExtendedBulletsUsed;
                  mpImplTextObj->maList.push_back( std::move(pPara) );
                  aParaFlags.bFirstParagraph = false;
              }
          }
      }
  }
  ImplCalculateTextPositions();
1296}

1298void TextObj::ImplCalculateTextPositions()
1299{
  mpImplTextObj->mnTextSize = 0;
  for ( sal_uInt32 i = 0; i < ParagraphCount(); ++i )
      mpImplTextObj->mnTextSize += GetParagraph(i)->ImplCalculateTextPositions( mpImplTextObj->mnTextSize );
1303}

1305ParagraphObj* TextObj::GetParagraph(int idx)
1306{
  return mpImplTextObj->maList[idx].get();
1308}

1310sal_uInt32 TextObj::ParagraphCount() const
1311{
  return mpImplTextObj->maList.size();
1313}

1315sal_uInt32 TextObj::Count() const
1316{
  return mpImplTextObj->mnTextSize;
1318}

1320int TextObj::GetInstance() const
1321{
  return mpImplTextObj->mnInstance;
1323}

1325bool TextObj::HasExtendedBullets() const
1326{
  return mpImplTextObj->mbHasExtendedBullets;
1328}

1330void FontCollectionEntry::ImplInit( const OUString& rName )
1331{
  OUString aSubstName( GetSubsFontName( rName, SubsFontFlags::ONLYONE | SubsFontFlags::MS ) );
  if ( !aSubstName.isEmpty() )
  {
      Name = aSubstName;
  }
  else
  {
      Name = rName;
  }
1341}

1343FontCollection::~FontCollection()
1344{
  pVDev.disposeAndClear();
1
Calling 'VclPtr::disposeAndClear'→
  xPPTBreakIter = nullptr;
1347}

1349FontCollection::FontCollection() :
  pVDev ( nullptr )
1351{
  xPPTBreakIter = css::i18n::BreakIterator::create( ::comphelper::getProcessComponentContext() );
1353}

1355short FontCollection::GetScriptDirection( const OUString& rString )
1356{
  short nRet = ScriptTypeDetector::getScriptDirection( rString, 0, css::i18n::ScriptDirection::NEUTRAL );
  return nRet;
1359}

1361sal_uInt32 FontCollection::GetId( FontCollectionEntry& rEntry )
1362{
  if( !rEntry.Name.isEmpty() )
  {
      const sal_uInt32 nFonts = maFonts.size();

      for( sal_uInt32 i = 0; i < nFonts; i++ )
      {
          const FontCollectionEntry* pEntry = GetById( i );
          if( pEntry->Name == rEntry.Name )
              return i;
      }
      vcl::Font aFont;
      aFont.SetCharSet( rEntry.CharSet );
      aFont.SetFamilyName( rEntry.Original );
      aFont.SetFontHeight( 100 );

      if ( !pVDev )
          pVDev = VclPtr<VirtualDevice>::Create();

      pVDev->SetFont( aFont );
      FontMetric aMetric( pVDev->GetFontMetric() );

      sal_uInt16 nTxtHeight = static_cast<sal_uInt16>(aMetric.GetAscent()) + static_cast<sal_uInt16>(aMetric.GetDescent());

      if ( nTxtHeight )
      {
          double fScaling = static_cast<double>(nTxtHeight) / 120.0;
          if ( ( fScaling > 0.50 ) && ( fScaling < 1.5 ) )
              rEntry.Scaling = fScaling;
      }

      maFonts.push_back(rEntry);
      return nFonts;
  }
  return 0;
1397}

1399const FontCollectionEntry* FontCollection::GetById( sal_uInt32 nId )
1400{
  return nId < maFonts.size() ? &maFonts[nId] : nullptr;
1402}

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

←

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

→

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

20#ifndef INCLUDED_VCL_PTR_HXX
21#define INCLUDED_VCL_PTR_HXX

23#include <sal/config.h>

25#include <rtl/ref.hxx>

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

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

36class VclReferenceBase;

38namespace vcl::detail {

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

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

47} // namespace vcl::detail

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

  ::rtl::Reference<reference_type> m_rInnerRef;

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

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

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

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

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

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

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

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

  /** Probably most common used: handle->someBodyOp().
   */
  reference_type * operator->() const
  {
      return m_rInnerRef.get();
  }

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

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

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

  /** Up-casting copy assignment operator.

      Does not work for up-casts to ambiguous bases.

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

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

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

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

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

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

  void disposeAndClear()
  {
      // hold it alive for the lifetime of this method
      ::rtl::Reference<reference_type> aTmp(m_rInnerRef);
2
←
Calling copy constructor for 'Reference<VirtualDevice>'→
5
←
Returning from copy constructor for 'Reference<VirtualDevice>'→
      m_rInnerRef.clear(); // we should use some 'swap' method ideally ;-)
6
←
Calling 'Reference::clear'→
13
←
Returning; memory was released→
      if (aTmp.get()) {
14
←
Calling 'Reference::get'→
          aTmp->disposeOnce();
      }
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  /** Up-casting assignment operator.

      Does not work for up-casts to ambiguous bases.

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

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

  ~ScopedVclPtr()
  {
      VclPtr<reference_type>::disposeAndClear();
      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)
3
←
Assuming field 'm_pBody' is non-null→
4
←
Taking true branch→
          m_pBody->acquire();
  }

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

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

      Does not work for up-casts to ambiguous bases.

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

  /** Destructor...
   */
  ~Reference() COVERITY_NOEXCEPT_FALSE
  {
      if (m_pBody)
          m_pBody->release();
  }

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

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

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

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

  /** Unbind the body from this handle.
       Note that for a handle representing a large body,
       "handle.clear().set(new body());" _might_
       perform a little bit better than "handle.set(new body());",
       since in the second case two large objects exist in memory
       (the old body and the new body).
   */
  Reference<reference_type> & SAL_CALL clear()
  {
      if (m_pBody6.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
)
7
←
Taking true branch→
      {
          reference_type * const pOld = m_pBody;
          m_pBody = NULL__null;
          pOld->release();
8
←
Calling 'VclReferenceBase::release'→
12
←
Returning; memory was released→
      }
      return *this;
  }


  /** Get the body. Can be used instead of operator->().
       I.e. handle->someBodyOp() and handle.get()->someBodyOp()
       are the same.
   */
  reference_type * SAL_CALL get() const
  {
      return m_pBody;
15
←
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)
9
←
Assuming the condition is true→
10
←
Taking true branch→
40            delete this;
11
←
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