tdf#96099 Remove various smart pointer typedefs

Change-Id: I76843139e43ca1c158a977e24d210d5af93e4d0f
Reviewed-on: https://gerrit.libreoffice.org/26014
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Noel Grandin <noelgrandin@gmail.com>

35 files changed, 165 insertions, 187 deletions

diff --git a/connectivity/source/commontools/RowFunctionParser.cxx b/connectivity/source/commontools/RowFunctionParser.cxx
index 94c2e4fc285b..b12ba73ffb07 100644
--- a/connectivity/source/commontools/RowFunctionParser.cxx
+++ b/connectivity/source/commontools/RowFunctionParser.cxx
@@ -77,12 +77,12 @@ public:
 class BinaryFunctionExpression : public ExpressionNode
 {
     const ExpressionFunct   meFunct;
-    ExpressionNodeSharedPtr mpFirstArg;
-    ExpressionNodeSharedPtr mpSecondArg;
+    std::shared_ptr<ExpressionNode> mpFirstArg;
+    std::shared_ptr<ExpressionNode> mpSecondArg;
 
 public:
 
-    BinaryFunctionExpression( const ExpressionFunct eFunct, const ExpressionNodeSharedPtr& rFirstArg, const ExpressionNodeSharedPtr& rSecondArg ) :
+    BinaryFunctionExpression( const ExpressionFunct eFunct, const std::shared_ptr<ExpressionNode>& rFirstArg, const std::shared_ptr<ExpressionNode>& rSecondArg ) :
         meFunct( eFunct ),
         mpFirstArg( rFirstArg ),
         mpSecondArg( rSecondArg )
@@ -128,7 +128,7 @@ typedef const sal_Char* StringIteratorT;
 
 struct ParserContext
 {
-    typedef ::std::stack< ExpressionNodeSharedPtr > OperandStack;
+    typedef ::std::stack< std::shared_ptr<ExpressionNode> > OperandStack;
 
     // stores a stack of not-yet-evaluated operands. This is used
     // by the operators (i.e. '+', '*', 'sin' etc.) to pop their
@@ -156,7 +156,7 @@ public:
     void operator()( StringIteratorT rFirst,StringIteratorT rSecond) const
     {
         OUString sVal( rFirst, rSecond - rFirst, RTL_TEXTENCODING_UTF8 );
-        mpContext->maOperandStack.push( ExpressionNodeSharedPtr( new ConstantValueExpression( new ORowSetValueDecorator( sVal ) ) ) );
+        mpContext->maOperandStack.push( std::shared_ptr<ExpressionNode>( new ConstantValueExpression( new ORowSetValueDecorator( sVal ) ) ) );
     }
 };
 
@@ -173,7 +173,7 @@ public:
     }
     void operator()( sal_Int32 n ) const
     {
-        mpContext->maOperandStack.push( ExpressionNodeSharedPtr( new ConstantValueExpression( new ORowSetValueDecorator( n ) ) ) );
+        mpContext->maOperandStack.push( std::shared_ptr<ExpressionNode>( new ConstantValueExpression( new ORowSetValueDecorator( n ) ) ) );
     }
 };
 
@@ -205,13 +205,13 @@ public:
             throw ParseError( "Not enough arguments for binary operator" );
 
         // retrieve arguments
-        ExpressionNodeSharedPtr pSecondArg( rNodeStack.top() );
+        std::shared_ptr<ExpressionNode> pSecondArg( rNodeStack.top() );
         rNodeStack.pop();
-        ExpressionNodeSharedPtr pFirstArg( rNodeStack.top() );
+        std::shared_ptr<ExpressionNode> pFirstArg( rNodeStack.top() );
         rNodeStack.pop();
 
         // create combined ExpressionNode
-        ExpressionNodeSharedPtr pNode = ExpressionNodeSharedPtr( new BinaryFunctionExpression( meFunct, pFirstArg, pSecondArg ) );
+        std::shared_ptr<ExpressionNode> pNode = std::shared_ptr<ExpressionNode>( new BinaryFunctionExpression( meFunct, pFirstArg, pSecondArg ) );
         // check for constness
         rNodeStack.push( pNode );
     }
@@ -221,10 +221,10 @@ public:
     */
 class UnaryFunctionExpression : public ExpressionNode
 {
-    ExpressionNodeSharedPtr mpArg;
+    std::shared_ptr<ExpressionNode> mpArg;
 
 public:
-    explicit UnaryFunctionExpression( const ExpressionNodeSharedPtr& rArg ) :
+    explicit UnaryFunctionExpression( const std::shared_ptr<ExpressionNode>& rArg ) :
         mpArg( rArg )
     {
     }
@@ -256,10 +256,10 @@ public:
             throw ParseError( "Not enough arguments for unary operator" );
 
         // retrieve arguments
-        ExpressionNodeSharedPtr pArg( rNodeStack.top() );
+        std::shared_ptr<ExpressionNode> pArg( rNodeStack.top() );
         rNodeStack.pop();
 
-        rNodeStack.push( ExpressionNodeSharedPtr( new UnaryFunctionExpression( pArg ) ) );
+        rNodeStack.push( std::shared_ptr<ExpressionNode>( new UnaryFunctionExpression( pArg ) ) );
     }
 };
 
@@ -400,7 +400,7 @@ const ParserContextSharedPtr& getParserContext()
 #endif
 }
 
-ExpressionNodeSharedPtr FunctionParser::parseFunction( const OUString& _sFunction)
+std::shared_ptr<ExpressionNode> FunctionParser::parseFunction( const OUString& _sFunction)
 {
     // TODO(Q1): Check if a combination of the RTL_UNICODETOTEXT_FLAGS_*
     // gives better conversion robustness here (we might want to map space
diff --git a/connectivity/source/commontools/TDatabaseMetaDataBase.cxx b/connectivity/source/commontools/TDatabaseMetaDataBase.cxx
index b2a8671e9101..4d8b74d7a583 100644
--- a/connectivity/source/commontools/TDatabaseMetaDataBase.cxx
+++ b/connectivity/source/commontools/TDatabaseMetaDataBase.cxx
@@ -114,7 +114,7 @@ Reference< XResultSet > SAL_CALL ODatabaseMetaDataBase::getTypeInfo(  ) throw(SQ
                                         ,DataType::INTEGER
                                         ,DataType::INTEGER
                                     };
-            ::std::vector<ExpressionNodeSharedPtr> aConditions;
+            ::std::vector<std::shared_ptr<ExpressionNode>> aConditions;
             if ( aTypeInfoSettings.getLength() > 1 && ((aTypeInfoSettings.getLength() % 2) == 0) )
             {
                 const Any* pIter = aTypeInfoSettings.getConstArray();
@@ -145,8 +145,8 @@ Reference< XResultSet > SAL_CALL ODatabaseMetaDataBase::getTypeInfo(  ) throw(SQ
                     aRow.push_back(new ORowSetValueDecorator(aValue));
                 }
 
-                ::std::vector<ExpressionNodeSharedPtr>::iterator aIter = aConditions.begin();
-                ::std::vector<ExpressionNodeSharedPtr>::const_iterator aEnd = aConditions.end();
+                ::std::vector<std::shared_ptr<ExpressionNode>>::iterator aIter = aConditions.begin();
+                ::std::vector<std::shared_ptr<ExpressionNode>>::const_iterator aEnd = aConditions.end();
                 for (; aIter != aEnd; ++aIter)
                 {
                     if ( (*aIter)->evaluate(aRow)->getValue().getBool() )
diff --git a/connectivity/source/commontools/TKey.cxx b/connectivity/source/commontools/TKey.cxx
index 6f2c6b7d5378..057dce0e9df5 100644
--- a/connectivity/source/commontools/TKey.cxx
+++ b/connectivity/source/commontools/TKey.cxx
@@ -39,7 +39,7 @@ OTableKeyHelper::OTableKeyHelper(OTableHelper* _pTable) : connectivity::sdbcx::O
 
 OTableKeyHelper::OTableKeyHelper(   OTableHelper* _pTable
             ,const OUString& Name
-            ,const sdbcx::TKeyProperties& _rProps
+            ,const std::shared_ptr<sdbcx::KeyProperties>& _rProps
             ) : connectivity::sdbcx::OKey(Name,_rProps,true)
                 ,m_pTable(_pTable)
 {
diff --git a/connectivity/source/commontools/TTableHelper.cxx b/connectivity/source/commontools/TTableHelper.cxx
index 5db35247f267..6359f904b28b 100644
--- a/connectivity/source/commontools/TTableHelper.cxx
+++ b/connectivity/source/commontools/TTableHelper.cxx
@@ -329,7 +329,7 @@ void OTableHelper::refreshPrimaryKeys(TStringVector& _rNames)
 
     if ( xResult.is() )
     {
-        sdbcx::TKeyProperties pKeyProps(new sdbcx::KeyProperties(OUString(),KeyType::PRIMARY,0,0));
+        std::shared_ptr<sdbcx::KeyProperties> pKeyProps(new sdbcx::KeyProperties(OUString(),KeyType::PRIMARY,0,0));
         OUString aPkName;
         bool bAlreadyFetched = false;
         const Reference< XRow > xRow(xResult,UNO_QUERY);
@@ -366,7 +366,7 @@ void OTableHelper::refreshForeignKeys(TStringVector& _rNames)
 
     if ( xRow.is() )
     {
-        sdbcx::TKeyProperties pKeyProps;
+        std::shared_ptr<sdbcx::KeyProperties> pKeyProps;
         OUString aName,sCatalog,aSchema,sOldFKName;
         while( xResult->next() )
         {
@@ -577,9 +577,9 @@ void SAL_CALL OTableHelper::release() throw()
     OTable_TYPEDEF::release();
 }
 
-sdbcx::TKeyProperties OTableHelper::getKeyProperties(const OUString& _sName) const
+std::shared_ptr<sdbcx::KeyProperties> OTableHelper::getKeyProperties(const OUString& _sName) const
 {
-    sdbcx::TKeyProperties pKeyProps;
+    std::shared_ptr<sdbcx::KeyProperties> pKeyProps;
     TKeyMap::const_iterator aFind = m_pImpl->m_aKeys.find(_sName);
     if ( aFind != m_pImpl->m_aKeys.end() )
     {
@@ -594,7 +594,7 @@ sdbcx::TKeyProperties OTableHelper::getKeyProperties(const OUString& _sName) con
     return pKeyProps;
 }
 
-void OTableHelper::addKey(const OUString& _sName,const sdbcx::TKeyProperties& _aKeyProperties)
+void OTableHelper::addKey(const OUString& _sName,const std::shared_ptr<sdbcx::KeyProperties>& _aKeyProperties)
 {
     m_pImpl->m_aKeys.insert(TKeyMap::value_type(_sName,_aKeyProperties));
 }
diff --git a/connectivity/source/inc/RowFunctionParser.hxx b/connectivity/source/inc/RowFunctionParser.hxx
index a0a8849463a0..d74d880503eb 100644
--- a/connectivity/source/inc/RowFunctionParser.hxx
+++ b/connectivity/source/inc/RowFunctionParser.hxx
@@ -55,7 +55,6 @@ public:
 
     virtual void fill(const ODatabaseMetaDataResultSet::ORow& _aRow ) const = 0;
 };
-typedef std::shared_ptr< ExpressionNode > ExpressionNodeSharedPtr;
 
 /** This exception is thrown, when the arithmetic expression
     parser failed to parse a string.
@@ -102,7 +101,7 @@ public:
         @return the generated function object.
        */
 
-    static ExpressionNodeSharedPtr parseFunction( const OUString& _sFunction);
+    static std::shared_ptr<ExpressionNode> parseFunction( const OUString& _sFunction);
 
 private:
     // disabled constructor/destructor, since this is
diff --git a/connectivity/source/sdbcx/VKey.cxx b/connectivity/source/sdbcx/VKey.cxx
index bf8b0a92667d..ce448f78cd94 100644
--- a/connectivity/source/sdbcx/VKey.cxx
+++ b/connectivity/source/sdbcx/VKey.cxx
@@ -66,7 +66,7 @@ OKey::OKey(bool _bCase) :   ODescriptor_BASE(m_aMutex)
 {
 }
 
-OKey::OKey(const OUString& Name,const TKeyProperties& _rProps, bool _bCase)
+OKey::OKey(const OUString& Name,const std::shared_ptr<KeyProperties>& _rProps, bool _bCase)
 : ODescriptor_BASE(m_aMutex)
  ,ODescriptor(ODescriptor_BASE::rBHelper,_bCase)
  ,m_aProps(_rProps)
diff --git a/dbaccess/source/ui/dlg/admincontrols.cxx b/dbaccess/source/ui/dlg/admincontrols.cxx
index 9c3b8f9b615e..0e5df0670461 100644
--- a/dbaccess/source/ui/dlg/admincontrols.cxx
+++ b/dbaccess/source/ui/dlg/admincontrols.cxx
@@ -155,7 +155,7 @@ namespace dbaui
         m_aControlDependencies.enableOnRadioCheck( *m_pSocketRadio, *m_pSocket );
         m_aControlDependencies.enableOnRadioCheck( *m_pNamedPipeRadio, *m_pNamedPipe );
 
-        m_aControlDependencies.addController( ::svt::PDialogController(
+        m_aControlDependencies.addController( std::shared_ptr<svt::DialogController>(
             new TextResetOperatorController( *m_pHostName, OUString("localhost") )
         ) );
 
diff --git a/filter/source/msfilter/escherex.cxx b/filter/source/msfilter/escherex.cxx
index 3c85227f8f4d..a926899a8b9a 100644
--- a/filter/source/msfilter/escherex.cxx
+++ b/filter/source/msfilter/escherex.cxx
@@ -4954,7 +4954,7 @@ public:
     virtual ~SvNullStream() {}
 };
 
-EscherEx::EscherEx(const EscherExGlobalRef& rxGlobal, SvStream* pOutStrm, bool bOOXML)
+EscherEx::EscherEx(const std::shared_ptr<EscherExGlobal>& rxGlobal, SvStream* pOutStrm, bool bOOXML)
     : mxGlobal(rxGlobal)
     , mpOutStrm(pOutStrm)
     , mbOwnsStrm(false)
diff --git a/include/connectivity/TKey.hxx b/include/connectivity/TKey.hxx
index a7f067a9ede9..cfce73d09c6a 100644
--- a/include/connectivity/TKey.hxx
+++ b/include/connectivity/TKey.hxx
@@ -36,7 +36,7 @@ namespace connectivity
         OTableKeyHelper(    OTableHelper* _pTable);
         OTableKeyHelper(    OTableHelper* _pTable
                 ,const OUString& Name
-                ,const sdbcx::TKeyProperties& _rProps
+                ,const std::shared_ptr<sdbcx::KeyProperties>& _rProps
             );
         inline OTableHelper* getTable() const { return m_pTable; }
     };
diff --git a/include/connectivity/TTableHelper.hxx b/include/connectivity/TTableHelper.hxx
index 3e56f9c34c36..0953a7d150ea 100644
--- a/include/connectivity/TTableHelper.hxx
+++ b/include/connectivity/TTableHelper.hxx
@@ -72,7 +72,7 @@ namespace connectivity
     };
     typedef connectivity::sdbcx::OTable OTable_TYPEDEF;
 
-    typedef std::map<OUString, sdbcx::TKeyProperties> TKeyMap;
+    typedef std::map<OUString, std::shared_ptr<sdbcx::KeyProperties>> TKeyMap;
 
     struct OTableHelperImpl;
 
@@ -150,8 +150,8 @@ namespace connectivity
         virtual OUString SAL_CALL getName() throw(css::uno::RuntimeException, std::exception) override;
 
         // helper method to get key properties
-        sdbcx::TKeyProperties getKeyProperties(const OUString& _sName) const;
-        void addKey(const OUString& _sName,const sdbcx::TKeyProperties& _aKeyProperties);
+        std::shared_ptr<sdbcx::KeyProperties> getKeyProperties(const OUString& _sName) const;
+        void addKey(const OUString& _sName,const std::shared_ptr<sdbcx::KeyProperties>& _aKeyProperties);
 
         virtual OUString getTypeCreatePattern() const;
 
diff --git a/include/connectivity/sdbcx/VKey.hxx b/include/connectivity/sdbcx/VKey.hxx
index 80962175ff62..0d52f22d2ff8 100644
--- a/include/connectivity/sdbcx/VKey.hxx
+++ b/include/connectivity/sdbcx/VKey.hxx
@@ -56,7 +56,6 @@ namespace connectivity
             {}
             KeyProperties():m_Type(0),m_UpdateRule(0),m_DeleteRule(0){}
         };
-        typedef std::shared_ptr< KeyProperties > TKeyProperties;
         typedef ::cppu::ImplHelper1< css::sdbcx::XDataDescriptorFactory > OKey_BASE;
         class OCollection;
 
@@ -69,7 +68,7 @@ namespace connectivity
                                 public OKey_BASE
         {
         protected:
-            TKeyProperties   m_aProps;
+            std::shared_ptr<KeyProperties>   m_aProps;
             OCollection*    m_pColumns;
 
             using ODescriptor_BASE::rBHelper;
@@ -79,7 +78,7 @@ namespace connectivity
             virtual ::cppu::IPropertyArrayHelper & SAL_CALL getInfoHelper() override;
         public:
             OKey(bool _bCase);
-            OKey(const OUString& Name,const TKeyProperties& _rProps,bool _bCase);
+            OKey(const OUString& Name,const std::shared_ptr<KeyProperties>& _rProps,bool _bCase);
 
             virtual ~OKey( );
 
diff --git a/include/filter/msfilter/escherex.hxx b/include/filter/msfilter/escherex.hxx
index aa4cd5497a2c..5009c8ef7b88 100644
--- a/include/filter/msfilter/escherex.hxx
+++ b/include/filter/msfilter/escherex.hxx
@@ -1124,8 +1124,6 @@ private:
     bool                mbPicStrmQueried;   /// True = ImplQueryPictureStream() has been called.
 };
 
-typedef std::shared_ptr< EscherExGlobal > EscherExGlobalRef;
-
 class SdrObject;
 class SdrPage;
 class ImplEscherExSdr;
@@ -1133,7 +1131,7 @@ class ImplEscherExSdr;
 class MSFILTER_DLLPUBLIC EscherEx : public EscherPersistTable
 {
     protected:
-        EscherExGlobalRef           mxGlobal;
+        std::shared_ptr<EscherExGlobal>           mxGlobal;
         ::std::unique_ptr< ImplEscherExSdr > mpImplEscherExSdr;
         SvStream*                   mpOutStrm;
         bool                        mbOwnsStrm;
@@ -1156,7 +1154,7 @@ class MSFILTER_DLLPUBLIC EscherEx : public EscherPersistTable
         bool DoSeek( sal_uInt32 nKey );
 
 public:
-    explicit            EscherEx( const EscherExGlobalRef& rxGlobal, SvStream* pOutStrm, bool bOOXML = false );
+    explicit            EscherEx( const std::shared_ptr<EscherExGlobal>& rxGlobal, SvStream* pOutStrm, bool bOOXML = false );
     virtual             ~EscherEx();
 
     /** Creates and returns a new shape identifier, updates the internal shape
diff --git a/include/oox/vml/vmldrawing.hxx b/include/oox/vml/vmldrawing.hxx
index ad1462a812eb..9ef5fc28e02f 100644
--- a/include/oox/vml/vmldrawing.hxx
+++ b/include/oox/vml/vmldrawing.hxx
@@ -182,17 +182,15 @@ public:
 
 private:
     typedef ::std::vector< sal_Int32 >                      BlockIdVector;
-    typedef ::std::unique_ptr< ::oox::ole::EmbeddedForm >   EmbeddedFormPtr;
-    typedef ::std::unique_ptr< ShapeContainer >             ShapeContainerPtr;
     typedef ::std::map< OUString, OleObjectInfo >    OleObjectInfoMap;
     typedef ::std::map< OUString, ControlInfo >      ControlInfoMap;
 
     ::oox::core::XmlFilterBase& mrFilter;   ///< Filter object that imports/exports the VML drawing.
     css::uno::Reference< css::drawing::XDrawPage >
                         mxDrawPage;         ///< UNO draw page used to insert the shapes.
-    mutable EmbeddedFormPtr mxCtrlForm;     ///< The control form used to process embedded controls.
+    mutable std::unique_ptr<::oox::ole::EmbeddedForm> mxCtrlForm;     ///< The control form used to process embedded controls.
     mutable BlockIdVector maBlockIds;       ///< Block identifiers used by this drawing.
-    ShapeContainerPtr   mxShapes;           ///< All shapes and shape templates.
+    std::unique_ptr<ShapeContainer>   mxShapes;           ///< All shapes and shape templates.
     OleObjectInfoMap    maOleObjects;       ///< Info about all embedded OLE objects, mapped by shape id.
     ControlInfoMap      maControls;         ///< Info about all embedded form controls, mapped by control name.
     const DrawingType   meType;             ///< Application type containing the drawing.
diff --git a/include/oox/vml/vmlshape.hxx b/include/oox/vml/vmlshape.hxx
index 93f0943bcfe1..b7f3e19a87be 100644
--- a/include/oox/vml/vmlshape.hxx
+++ b/include/oox/vml/vmlshape.hxx
@@ -192,13 +192,11 @@ struct ClientData
 struct ShapeModel
 {
     typedef ::std::vector< css::awt::Point >   PointVector;
-    typedef ::std::unique_ptr< TextBox >                    TextBoxPtr;
-    typedef ::std::unique_ptr< ClientData >                 ClientDataPtr;
 
     OUString     maType;             ///< Shape template with default properties.
     PointVector         maPoints;           ///< Points for the polyline shape.
-    TextBoxPtr          mxTextBox;          ///< Text contents and properties.
-    ClientDataPtr       mxClientData;       ///< Excel specific client data.
+    std::unique_ptr<TextBox>          mxTextBox;          ///< Text contents and properties.
+    std::unique_ptr<ClientData>       mxClientData;       ///< Excel specific client data.
     OUString     maLegacyDiagramPath;///< Legacy Diagram Fragment Path
     OUString     maFrom;             ///< Start point for line shape.
     OUString     maTo;               ///< End point for line shape.
@@ -423,8 +421,7 @@ protected:
                             const css::awt::Rectangle& rShapeRect ) const override;
 
 private:
-    typedef ::std::unique_ptr< ShapeContainer > ShapeContainerPtr;
-    ShapeContainerPtr   mxChildren;         ///< Shapes and templates that are part of this group.
+    std::unique_ptr<ShapeContainer>   mxChildren;         ///< Shapes and templates that are part of this group.
 };
 
 
diff --git a/include/sfx2/itemconnect.hxx b/include/sfx2/itemconnect.hxx
index 21d663739fac..e9d5cae143b8 100644
--- a/include/sfx2/itemconnect.hxx
+++ b/include/sfx2/itemconnect.hxx
@@ -233,9 +233,6 @@ public:
     typedef typename ControlWrpT::ControlType               ControlType;
     typedef typename ControlWrpT::ControlValueType          ControlValueType;
 
-    typedef std::unique_ptr< ItemWrpT >                     ItemWrapperRef;
-    typedef std::unique_ptr< ControlWrpT >                  ControlWrapperRef;
-
     /** Receives pointer to a newly created control wrapper.
         @descr  Takes ownership of the control wrapper. */
     explicit            ItemControlConnection( sal_uInt16 nSlot, ControlWrpT* pNewCtrlWrp,
@@ -258,7 +255,7 @@ protected:
     virtual bool        FillItemSet( SfxItemSet& rDestSet, const SfxItemSet& rOldSet ) override;
 
     ItemWrapperType     maItemWrp;
-    ControlWrapperRef   mxCtrlWrp;
+    std::unique_ptr<ControlWrpT>   mxCtrlWrp;
 };
 
 
diff --git a/include/svtools/dialogcontrolling.hxx b/include/svtools/dialogcontrolling.hxx
index 5067dac0576d..a9c5b184629e 100644
--- a/include/svtools/dialogcontrolling.hxx
+++ b/include/svtools/dialogcontrolling.hxx
@@ -120,8 +120,6 @@ namespace svt
         DialogController( const DialogController& ) = delete;
         DialogController& operator=( const DialogController& ) = delete;
     };
-    typedef std::shared_ptr< DialogController > PDialogController;
-
 
     //= ControlDependencyManager
 
@@ -175,7 +173,7 @@ namespace svt
             @param _pController
                 the controller to add to the manager. Must not be <NULL/>.
         */
-        void    addController( const PDialogController& _pController );
+        void    addController( const std::shared_ptr<DialogController>& _pController );
 
     private:
         ControlDependencyManager( const ControlDependencyManager& ) = delete;
diff --git a/include/svx/EnhancedCustomShapeFunctionParser.hxx b/include/svx/EnhancedCustomShapeFunctionParser.hxx
index d503167653a4..e63872b7df4e 100644
--- a/include/svx/EnhancedCustomShapeFunctionParser.hxx
+++ b/include/svx/EnhancedCustomShapeFunctionParser.hxx
@@ -119,7 +119,6 @@ public:
     virtual css::drawing::EnhancedCustomShapeParameter fillNode(
         std::vector< EnhancedCustomShapeEquation >& rEquations, ExpressionNode* pOptionalArg, sal_uInt32 nFlags ) = 0;
 };
-typedef std::shared_ptr< ExpressionNode > ExpressionNodeSharedPtr;
 
 /** This exception is thrown, when the arithmetic expression
     parser failed to parse a string.
@@ -187,7 +186,7 @@ public:
         @return the generated function object.
        */
 
-    SVX_DLLPUBLIC static ExpressionNodeSharedPtr parseFunction( const OUString& rFunction, const EnhancedCustomShape2d& rCustoShape );
+    SVX_DLLPUBLIC static std::shared_ptr<ExpressionNode> parseFunction( const OUString& rFunction, const EnhancedCustomShape2d& rCustoShape );
 
     // this is a singleton
     FunctionParser() = delete;
diff --git a/include/svx/framelinkarray.hxx b/include/svx/framelinkarray.hxx
index 68a335d9503d..59edb8c3b99f 100644
--- a/include/svx/framelinkarray.hxx
+++ b/include/svx/framelinkarray.hxx
@@ -348,9 +348,7 @@ public:
 
 
 private:
-    typedef std::unique_ptr<ArrayImpl> ArrayImplPtr;
-
-    ArrayImplPtr        mxImpl;
+    std::unique_ptr<ArrayImpl>        mxImpl;
 };
 
 }
diff --git a/include/svx/shapepropertynotifier.hxx b/include/svx/shapepropertynotifier.hxx
index dd8a6488c6de..d44ba01e2a32 100644
--- a/include/svx/shapepropertynotifier.hxx
+++ b/include/svx/shapepropertynotifier.hxx
@@ -55,8 +55,6 @@ namespace svx
 
         virtual ~IPropertyValueProvider();
     };
-    typedef std::shared_ptr< IPropertyValueProvider >  PPropertyValueProvider;
-
 
     //= PropertyValueProvider
 
@@ -114,7 +112,7 @@ namespace svx
 
         /** registers a IPropertyValueProvider
         */
-        void    registerProvider( const ShapeProperty _eProperty, const PPropertyValueProvider& _rProvider );
+        void    registerProvider( const ShapeProperty _eProperty, const std::shared_ptr<IPropertyValueProvider>& _rProvider );
 
         /** notifies changes in the given property to all registered listeners
 
diff --git a/include/unotools/sharedunocomponent.hxx b/include/unotools/sharedunocomponent.hxx
index 9943ba88c0e8..bb94742ecb5a 100644
--- a/include/unotools/sharedunocomponent.hxx
+++ b/include/unotools/sharedunocomponent.hxx
@@ -137,10 +137,9 @@ namespace utl
     {
     private:
         typedef COMPONENT                           Component;
-        typedef std::shared_ptr<Component>          ComponentPointer;
 
     private:
-        ComponentPointer                            m_xComponent;
+        std::shared_ptr<Component>                            m_xComponent;
         css::uno::Reference< INTERFACE >            m_xTypedComponent;
 
     public:
diff --git a/sc/source/filter/xcl97/xcl97esc.cxx b/sc/source/filter/xcl97/xcl97esc.cxx
index dedab777b74e..bd845597a939 100644
--- a/sc/source/filter/xcl97/xcl97esc.cxx
+++ b/sc/source/filter/xcl97/xcl97esc.cxx
@@ -90,7 +90,7 @@ SvStream* XclEscherExGlobal::ImplQueryPictureStream()
 }
 
 XclEscherEx::XclEscherEx( const XclExpRoot& rRoot, XclExpObjectManager& rObjMgr, SvStream& rStrm, const XclEscherEx* pParent ) :
-    EscherEx( pParent ? pParent->mxGlobal : EscherExGlobalRef( new XclEscherExGlobal( rRoot ) ), &rStrm ),
+    EscherEx( pParent ? pParent->mxGlobal : std::shared_ptr<EscherExGlobal>( new XclEscherExGlobal( rRoot ) ), &rStrm ),
     XclExpRoot( rRoot ),
     mrObjMgr( rObjMgr ),
     pCurrXclObj( nullptr ),
diff --git a/sc/source/ui/unoobj/shapeuno.cxx b/sc/source/ui/unoobj/shapeuno.cxx
index d7d39282797f..d009bda949ce 100644
--- a/sc/source/ui/unoobj/shapeuno.cxx
+++ b/sc/source/ui/unoobj/shapeuno.cxx
@@ -84,7 +84,7 @@ namespace
 {
     void lcl_initializeNotifier( SdrObject& _rSdrObj, ::cppu::OWeakObject& _rShape )
     {
-        svx::PPropertyValueProvider pProvider( new svx::PropertyValueProvider( _rShape, "Anchor" ) );
+        std::shared_ptr<svx::IPropertyValueProvider> pProvider( new svx::PropertyValueProvider( _rShape, "Anchor" ) );
         _rSdrObj.getShapePropertyChangeNotifier().registerProvider( svx::eSpreadsheetAnchor, pProvider );
     }
 }
diff --git a/slideshow/source/engine/activities/activitiesfactory.cxx b/slideshow/source/engine/activities/activitiesfactory.cxx
index 17868c25761a..f7b3e8f57d0a 100644
--- a/slideshow/source/engine/activities/activitiesfactory.cxx
+++ b/slideshow/source/engine/activities/activitiesfactory.cxx
@@ -53,7 +53,7 @@ namespace {
 template<typename ValueType> struct FormulaTraits
 {
     static ValueType getPresentationValue(
-        const ValueType& rVal, const ExpressionNodeSharedPtr& )
+        const ValueType& rVal, const std::shared_ptr<ExpressionNode>& )
     {
         return rVal;
     }
@@ -63,7 +63,7 @@ template<typename ValueType> struct FormulaTraits
 template<> struct FormulaTraits<double>
 {
     static double getPresentationValue(
-        double const& rVal, ExpressionNodeSharedPtr const& rFormula )
+        double const& rVal, std::shared_ptr<ExpressionNode> const& rFormula )
     {
         return rFormula ? (*rFormula)(rVal) : rVal;
     }
@@ -352,7 +352,7 @@ private:
     const OptionalValueType                 maTo;
     const OptionalValueType                 maBy;
 
-    ExpressionNodeSharedPtr                 mpFormula;
+    std::shared_ptr<ExpressionNode>                 mpFormula;
 
     ValueType                               maStartValue;
     ValueType                               maEndValue;
@@ -589,7 +589,7 @@ public:
 private:
     ValueVectorType                         maValues;
 
-    ExpressionNodeSharedPtr                 mpFormula;
+    std::shared_ptr<ExpressionNode>                 mpFormula;
 
     std::shared_ptr<AnimationType>        mpAnim;
     Interpolator< ValueType >               maInterpolator;
diff --git a/slideshow/source/engine/activities/activityparameters.hxx b/slideshow/source/engine/activities/activityparameters.hxx
index 67b3a893a902..1faa1dd26d60 100644
--- a/slideshow/source/engine/activities/activityparameters.hxx
+++ b/slideshow/source/engine/activities/activityparameters.hxx
@@ -110,7 +110,7 @@ struct ActivityParameters
     ActivitiesQueue&                            mrActivitiesQueue;
 
     /// Optional formula
-    ExpressionNodeSharedPtr                     mpFormula;
+    std::shared_ptr<ExpressionNode>                     mpFormula;
 
     /// Key times, for discrete and key time activities
     ::std::vector< double >                     maDiscreteTimes;
diff --git a/slideshow/source/engine/expressionnodefactory.cxx b/slideshow/source/engine/expressionnodefactory.cxx
index 2c9dc9e1c8b8..5f185d378009 100644
--- a/slideshow/source/engine/expressionnodefactory.cxx
+++ b/slideshow/source/engine/expressionnodefactory.cxx
@@ -84,8 +84,8 @@ namespace slideshow
             class BinaryExpressionBase : public ExpressionNode
             {
             public:
-                BinaryExpressionBase( const ExpressionNodeSharedPtr&    rFirstArg,
-                                      const ExpressionNodeSharedPtr&    rSecondArg ) :
+                BinaryExpressionBase( const std::shared_ptr<ExpressionNode>&    rFirstArg,
+                                      const std::shared_ptr<ExpressionNode>&    rSecondArg ) :
                     mpFirstArg( rFirstArg ),
                     mpSecondArg( rSecondArg )
                 {
@@ -99,15 +99,15 @@ namespace slideshow
                 }
 
             protected:
-                ExpressionNodeSharedPtr mpFirstArg;
-                ExpressionNodeSharedPtr mpSecondArg;
+                std::shared_ptr<ExpressionNode> mpFirstArg;
+                std::shared_ptr<ExpressionNode> mpSecondArg;
             };
 
             class PlusExpression : public BinaryExpressionBase
             {
             public:
-                PlusExpression( const ExpressionNodeSharedPtr&  rFirstArg,
-                                const ExpressionNodeSharedPtr&  rSecondArg ) :
+                PlusExpression( const std::shared_ptr<ExpressionNode>&  rFirstArg,
+                                const std::shared_ptr<ExpressionNode>&  rSecondArg ) :
                     BinaryExpressionBase( rFirstArg, rSecondArg )
                 {
                 }
@@ -121,8 +121,8 @@ namespace slideshow
             class MinusExpression : public BinaryExpressionBase
             {
             public:
-                MinusExpression( const ExpressionNodeSharedPtr& rFirstArg,
-                                 const ExpressionNodeSharedPtr& rSecondArg ) :
+                MinusExpression( const std::shared_ptr<ExpressionNode>& rFirstArg,
+                                 const std::shared_ptr<ExpressionNode>& rSecondArg ) :
                     BinaryExpressionBase( rFirstArg, rSecondArg )
                 {
                 }
@@ -136,8 +136,8 @@ namespace slideshow
             class MultipliesExpression : public BinaryExpressionBase
             {
             public:
-                MultipliesExpression( const ExpressionNodeSharedPtr&    rFirstArg,
-                                      const ExpressionNodeSharedPtr&    rSecondArg ) :
+                MultipliesExpression( const std::shared_ptr<ExpressionNode>&    rFirstArg,
+                                      const std::shared_ptr<ExpressionNode>&    rSecondArg ) :
                     BinaryExpressionBase( rFirstArg, rSecondArg )
                 {
                 }
@@ -151,8 +151,8 @@ namespace slideshow
             class DividesExpression : public BinaryExpressionBase
             {
             public:
-                DividesExpression( const ExpressionNodeSharedPtr&   rFirstArg,
-                                   const ExpressionNodeSharedPtr&   rSecondArg ) :
+                DividesExpression( const std::shared_ptr<ExpressionNode>&   rFirstArg,
+                                   const std::shared_ptr<ExpressionNode>&   rSecondArg ) :
                     BinaryExpressionBase( rFirstArg, rSecondArg )
                 {
                 }
@@ -166,8 +166,8 @@ namespace slideshow
             class MinExpression : public BinaryExpressionBase
             {
             public:
-                MinExpression( const ExpressionNodeSharedPtr&   rFirstArg,
-                               const ExpressionNodeSharedPtr&   rSecondArg ) :
+                MinExpression( const std::shared_ptr<ExpressionNode>&   rFirstArg,
+                               const std::shared_ptr<ExpressionNode>&   rSecondArg ) :
                     BinaryExpressionBase( rFirstArg, rSecondArg )
                 {
                 }
@@ -181,8 +181,8 @@ namespace slideshow
             class MaxExpression : public BinaryExpressionBase
             {
             public:
-                MaxExpression( const ExpressionNodeSharedPtr&   rFirstArg,
-                               const ExpressionNodeSharedPtr&   rSecondArg ) :
+                MaxExpression( const std::shared_ptr<ExpressionNode>&   rFirstArg,
+                               const std::shared_ptr<ExpressionNode>&   rSecondArg ) :
                     BinaryExpressionBase( rFirstArg, rSecondArg )
                 {
                 }
@@ -194,50 +194,50 @@ namespace slideshow
             };
         }
 
-        ExpressionNodeSharedPtr ExpressionNodeFactory::createConstantValueExpression( double rConstantValue )
+        std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createConstantValueExpression( double rConstantValue )
         {
-            return ExpressionNodeSharedPtr( new ConstantValueExpression(rConstantValue) );
+            return std::shared_ptr<ExpressionNode>( new ConstantValueExpression(rConstantValue) );
         }
 
-        ExpressionNodeSharedPtr ExpressionNodeFactory::createValueTExpression()
+        std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createValueTExpression()
         {
-            return ExpressionNodeSharedPtr( new TValueExpression() );
+            return std::shared_ptr<ExpressionNode>( new TValueExpression() );
         }
 
-        ExpressionNodeSharedPtr ExpressionNodeFactory::createPlusExpression( const ExpressionNodeSharedPtr& rLHS,
-                                                                             const ExpressionNodeSharedPtr& rRHS )
+        std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createPlusExpression( const std::shared_ptr<ExpressionNode>& rLHS,
+                                                                             const std::shared_ptr<ExpressionNode>& rRHS )
         {
-            return ExpressionNodeSharedPtr( new PlusExpression(rLHS, rRHS) );
+            return std::shared_ptr<ExpressionNode>( new PlusExpression(rLHS, rRHS) );
         }
 
-        ExpressionNodeSharedPtr ExpressionNodeFactory::createMinusExpression( const ExpressionNodeSharedPtr&    rLHS,
-                                                                              const ExpressionNodeSharedPtr&    rRHS )
+        std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createMinusExpression( const std::shared_ptr<ExpressionNode>&    rLHS,
+                                                                              const std::shared_ptr<ExpressionNode>&    rRHS )
         {
-            return ExpressionNodeSharedPtr( new MinusExpression(rLHS, rRHS) );
+            return std::shared_ptr<ExpressionNode>( new MinusExpression(rLHS, rRHS) );
         }
 
-        ExpressionNodeSharedPtr ExpressionNodeFactory::createMultipliesExpression( const ExpressionNodeSharedPtr&   rLHS,
-                                                                                   const ExpressionNodeSharedPtr&   rRHS )
+        std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createMultipliesExpression( const std::shared_ptr<ExpressionNode>&   rLHS,
+                                                                                   const std::shared_ptr<ExpressionNode>&   rRHS )
         {
-            return ExpressionNodeSharedPtr( new MultipliesExpression(rLHS, rRHS) );
+            return std::shared_ptr<ExpressionNode>( new MultipliesExpression(rLHS, rRHS) );
         }
 
-        ExpressionNodeSharedPtr ExpressionNodeFactory::createDividesExpression( const ExpressionNodeSharedPtr&  rLHS,
-                                                                                const ExpressionNodeSharedPtr&  rRHS )
+        std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createDividesExpression( const std::shared_ptr<ExpressionNode>&  rLHS,
+                                                                                const std::shared_ptr<ExpressionNode>&  rRHS )
         {
-            return ExpressionNodeSharedPtr( new DividesExpression(rLHS, rRHS) );
+            return std::shared_ptr<ExpressionNode>( new DividesExpression(rLHS, rRHS) );
         }
 
-        ExpressionNodeSharedPtr ExpressionNodeFactory::createMinExpression   ( const ExpressionNodeSharedPtr&   rOuterFunction,
-                                                                               const ExpressionNodeSharedPtr&   rInnerFunction )
+        std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createMinExpression   ( const std::shared_ptr<ExpressionNode>&   rOuterFunction,
+                                                                               const std::shared_ptr<ExpressionNode>&   rInnerFunction )
         {
-            return ExpressionNodeSharedPtr( new MinExpression(rOuterFunction, rInnerFunction) );
+            return std::shared_ptr<ExpressionNode>( new MinExpression(rOuterFunction, rInnerFunction) );
         }
 
-        ExpressionNodeSharedPtr ExpressionNodeFactory::createMaxExpression   ( const ExpressionNodeSharedPtr&   rOuterFunction,
-                                                                               const ExpressionNodeSharedPtr&   rInnerFunction )
+        std::shared_ptr<ExpressionNode> ExpressionNodeFactory::createMaxExpression   ( const std::shared_ptr<ExpressionNode>&   rOuterFunction,
+                                                                               const std::shared_ptr<ExpressionNode>&   rInnerFunction )
         {
-            return ExpressionNodeSharedPtr( new MaxExpression(rOuterFunction, rInnerFunction) );
+            return std::shared_ptr<ExpressionNode>( new MaxExpression(rOuterFunction, rInnerFunction) );
         }
 
     }
diff --git a/slideshow/source/engine/smilfunctionparser.cxx b/slideshow/source/engine/smilfunctionparser.cxx
index dcc807a16b53..8cfea83efc17 100644
--- a/slideshow/source/engine/smilfunctionparser.cxx
+++ b/slideshow/source/engine/smilfunctionparser.cxx
@@ -59,7 +59,7 @@ namespace slideshow
 
             struct ParserContext
             {
-                typedef ::std::stack< ExpressionNodeSharedPtr > OperandStack;
+                typedef ::std::stack< std::shared_ptr<ExpressionNode> > OperandStack;
 
                 // stores a stack of not-yet-evaluated operands. This is used
                 // by the operators (i.e. '+', '*', 'sin' etc.) to pop their
@@ -197,7 +197,7 @@ namespace slideshow
                 {
                 public:
                     UnaryFunctionExpression( const Functor&                 rFunctor,
-                                             const ExpressionNodeSharedPtr& rArg ) :
+                                             const std::shared_ptr<ExpressionNode>& rArg ) :
                         maFunctor( rFunctor ),
                         mpArg( rArg )
                     {
@@ -215,7 +215,7 @@ namespace slideshow
 
                 private:
                     Functor                 maFunctor;
-                    ExpressionNodeSharedPtr mpArg;
+                    std::shared_ptr<ExpressionNode> mpArg;
                 };
 
             public:
@@ -236,7 +236,7 @@ namespace slideshow
                         throw ParseError( "Not enough arguments for unary operator" );
 
                     // retrieve arguments
-                    ExpressionNodeSharedPtr pArg( rNodeStack.top() );
+                    std::shared_ptr<ExpressionNode> pArg( rNodeStack.top() );
                     rNodeStack.pop();
 
                     // check for constness
@@ -250,7 +250,7 @@ namespace slideshow
                     {
                         // push complex node, that calcs the value on demand
                         rNodeStack.push(
-                            ExpressionNodeSharedPtr(
+                            std::shared_ptr<ExpressionNode>(
                                 new UnaryFunctionExpression(
                                     maFunctor,
                                     pArg ) ) );
@@ -311,13 +311,13 @@ namespace slideshow
                         throw ParseError( "Not enough arguments for binary operator" );
 
                     // retrieve arguments
-                    ExpressionNodeSharedPtr pSecondArg( rNodeStack.top() );
+                    std::shared_ptr<ExpressionNode> pSecondArg( rNodeStack.top() );
                     rNodeStack.pop();
-                    ExpressionNodeSharedPtr pFirstArg( rNodeStack.top() );
+                    std::shared_ptr<ExpressionNode> pFirstArg( rNodeStack.top() );
                     rNodeStack.pop();
 
                     // create combined ExpressionNode
-                    ExpressionNodeSharedPtr pNode( maGenerator( pFirstArg,
+                    std::shared_ptr<ExpressionNode> pNode( maGenerator( pFirstArg,
                                                                 pSecondArg ) );
                     // check for constness
                     if( pFirstArg->isConstant() &&
@@ -526,7 +526,7 @@ namespace slideshow
 #endif
         }
 
-        ExpressionNodeSharedPtr SmilFunctionParser::parseSmilValue( const OUString&          rSmilValue,
+        std::shared_ptr<ExpressionNode> SmilFunctionParser::parseSmilValue( const OUString&          rSmilValue,
                                                                     const ::basegfx::B2DRectangle&  rRelativeShapeBounds )
         {
             // TODO(Q1): Check if a combination of the RTL_UNICODETOTEXT_FLAGS_*
@@ -575,7 +575,7 @@ namespace slideshow
             return pContext->maOperandStack.top();
         }
 
-        ExpressionNodeSharedPtr SmilFunctionParser::parseSmilFunction( const OUString&           rSmilFunction,
+        std::shared_ptr<ExpressionNode> SmilFunctionParser::parseSmilFunction( const OUString&           rSmilFunction,
                                                                        const ::basegfx::B2DRectangle&   rRelativeShapeBounds )
         {
             // TODO(Q1): Check if a combination of the RTL_UNICODETOTEXT_FLAGS_*
diff --git a/slideshow/source/inc/expressionnode.hxx b/slideshow/source/inc/expressionnode.hxx
index 8bd0b14e2e85..bb6aff2cba7d 100644
--- a/slideshow/source/inc/expressionnode.hxx
+++ b/slideshow/source/inc/expressionnode.hxx
@@ -76,8 +76,6 @@ namespace slideshow
             */
             virtual bool isConstant() const = 0;
         };
-
-        typedef ::std::shared_ptr< ExpressionNode > ExpressionNodeSharedPtr;
     }
 }
 
diff --git a/slideshow/source/inc/expressionnodefactory.hxx b/slideshow/source/inc/expressionnodefactory.hxx
index 5c3d994034a6..d4a60b3c72c9 100644
--- a/slideshow/source/inc/expressionnodefactory.hxx
+++ b/slideshow/source/inc/expressionnodefactory.hxx
@@ -41,29 +41,29 @@ namespace slideshow
         class ExpressionNodeFactory
         {
         public:
-            static ExpressionNodeSharedPtr createConstantValueExpression( double rConstantValue );
+            static std::shared_ptr<ExpressionNode> createConstantValueExpression( double rConstantValue );
 
-            static ExpressionNodeSharedPtr createValueTExpression    ();
+            static std::shared_ptr<ExpressionNode> createValueTExpression    ();
 
-            static ExpressionNodeSharedPtr createPlusExpression      ( const ExpressionNodeSharedPtr&   rLHS,
-                                                                       const ExpressionNodeSharedPtr&   rRHS );
-            static ExpressionNodeSharedPtr createMinusExpression     ( const ExpressionNodeSharedPtr&   rLHS,
-                                                                       const ExpressionNodeSharedPtr&   rRHS );
-            static ExpressionNodeSharedPtr createMultipliesExpression( const ExpressionNodeSharedPtr&   rLHS,
-                                                                       const ExpressionNodeSharedPtr&   rRHS );
-            static ExpressionNodeSharedPtr createDividesExpression   ( const ExpressionNodeSharedPtr&   rLHS,
-                                                                       const ExpressionNodeSharedPtr&   rRHS );
+            static std::shared_ptr<ExpressionNode> createPlusExpression      ( const std::shared_ptr<ExpressionNode>&   rLHS,
+                                                                       const std::shared_ptr<ExpressionNode>&   rRHS );
+            static std::shared_ptr<ExpressionNode> createMinusExpression     ( const std::shared_ptr<ExpressionNode>&   rLHS,
+                                                                       const std::shared_ptr<ExpressionNode>&   rRHS );
+            static std::shared_ptr<ExpressionNode> createMultipliesExpression( const std::shared_ptr<ExpressionNode>&   rLHS,
+                                                                       const std::shared_ptr<ExpressionNode>&   rRHS );
+            static std::shared_ptr<ExpressionNode> createDividesExpression   ( const std::shared_ptr<ExpressionNode>&   rLHS,
+                                                                       const std::shared_ptr<ExpressionNode>&   rRHS );
 
             /** Composes two ExpressionNode function.
 
                 The resulting expression will calculate
                 rOuterFunction( rInnerFunction(t) ).
              */
-            static ExpressionNodeSharedPtr createMinExpression      ( const ExpressionNodeSharedPtr&    rOuterFunction,
-                                                                      const ExpressionNodeSharedPtr&    rInnerFunction );
+            static std::shared_ptr<ExpressionNode> createMinExpression      ( const std::shared_ptr<ExpressionNode>&    rOuterFunction,
+                                                                      const std::shared_ptr<ExpressionNode>&    rInnerFunction );
 
-            static ExpressionNodeSharedPtr createMaxExpression      ( const ExpressionNodeSharedPtr&    rOuterFunction,
-                                                                      const ExpressionNodeSharedPtr&    rInnerFunction );
+            static std::shared_ptr<ExpressionNode> createMaxExpression      ( const std::shared_ptr<ExpressionNode>&    rOuterFunction,
+                                                                      const std::shared_ptr<ExpressionNode>&    rInnerFunction );
         };
     }
 }
diff --git a/slideshow/source/inc/smilfunctionparser.hxx b/slideshow/source/inc/smilfunctionparser.hxx
index 42a07be7941c..236dce4fdfbd 100644
--- a/slideshow/source/inc/smilfunctionparser.hxx
+++ b/slideshow/source/inc/smilfunctionparser.hxx
@@ -95,7 +95,7 @@ namespace slideshow
 
                 @return the generated function object.
              */
-            static ExpressionNodeSharedPtr parseSmilValue( const OUString&           rSmilValue,
+            static std::shared_ptr<ExpressionNode> parseSmilValue( const OUString&           rSmilValue,
                                                            const ::basegfx::B2DRectangle&   rRelativeShapeBounds ); // throw ParseError
 
             /** Parse a string containing a SMIL function.
@@ -143,7 +143,7 @@ namespace slideshow
 
                 @return the generated function object.
              */
-            static ExpressionNodeSharedPtr parseSmilFunction( const OUString&            rSmilFunction,
+            static std::shared_ptr<ExpressionNode> parseSmilFunction( const OUString&            rSmilFunction,
                                                               const ::basegfx::B2DRectangle&    rRelativeShapeBounds ); // throw ParseError
 
         };
diff --git a/svtools/source/misc/dialogcontrolling.cxx b/svtools/source/misc/dialogcontrolling.cxx
index b630caae6ece..aa1f6043d94c 100644
--- a/svtools/source/misc/dialogcontrolling.cxx
+++ b/svtools/source/misc/dialogcontrolling.cxx
@@ -129,7 +129,7 @@ namespace svt
 
     struct ControlDependencyManager_Data
     {
-        ::std::vector< PDialogController >  aControllers;
+        ::std::vector< std::shared_ptr<DialogController> >  aControllers;
     };
 
 
@@ -149,9 +149,9 @@ namespace svt
 
     namespace
     {
-        struct ResetDialogController : public ::std::unary_function< const PDialogController&, void >
+        struct ResetDialogController : public ::std::unary_function< const std::shared_ptr<DialogController>&, void >
         {
-            void operator()( const PDialogController& _pController )
+            void operator()( const std::shared_ptr<DialogController>& _pController )
             {
                 _pController->reset();
             }
@@ -166,7 +166,7 @@ namespace svt
     }
 
 
-    void ControlDependencyManager::addController( const PDialogController& _pController )
+    void ControlDependencyManager::addController( const std::shared_ptr<DialogController>& _pController )
     {
         OSL_ENSURE( _pController.get() != nullptr, "ControlDependencyManager::addController: invalid controller, this will crash, sooner or later!" );
         m_pImpl->aControllers.push_back( _pController );
@@ -175,7 +175,7 @@ namespace svt
 
     void ControlDependencyManager::enableOnRadioCheck( RadioButton& _rRadio, vcl::Window& _rDependentWindow )
     {
-        PDialogController pController( new RadioDependentEnabler( _rRadio ) );
+        std::shared_ptr<DialogController> pController( new RadioDependentEnabler( _rRadio ) );
         pController->addDependentWindow( _rDependentWindow );
         m_pImpl->aControllers.push_back( pController );
     }
@@ -183,7 +183,7 @@ namespace svt
 
     void ControlDependencyManager::enableOnRadioCheck( RadioButton& _rRadio, vcl::Window& _rDependentWindow1, vcl::Window& _rDependentWindow2 )
     {
-        PDialogController pController( new RadioDependentEnabler( _rRadio ) );
+        std::shared_ptr<DialogController> pController( new RadioDependentEnabler( _rRadio ) );
         pController->addDependentWindow( _rDependentWindow1 );
         pController->addDependentWindow( _rDependentWindow2 );
         m_pImpl->aControllers.push_back( pController );
@@ -192,7 +192,7 @@ namespace svt
 
     void ControlDependencyManager::enableOnRadioCheck( RadioButton& _rRadio, vcl::Window& _rDependentWindow1, vcl::Window& _rDependentWindow2, vcl::Window& _rDependentWindow3 )
     {
-        PDialogController pController( new RadioDependentEnabler( _rRadio ) );
+        std::shared_ptr<DialogController> pController( new RadioDependentEnabler( _rRadio ) );
         pController->addDependentWindow( _rDependentWindow1 );
         pController->addDependentWindow( _rDependentWindow2 );
         pController->addDependentWindow( _rDependentWindow3 );
@@ -202,7 +202,7 @@ namespace svt
 
     void ControlDependencyManager::enableOnRadioCheck( RadioButton& _rRadio, vcl::Window& _rDependentWindow1, vcl::Window& _rDependentWindow2, vcl::Window& _rDependentWindow3, vcl::Window& _rDependentWindow4, vcl::Window& _rDependentWindow5 )
     {
-        PDialogController pController( new RadioDependentEnabler( _rRadio ) );
+        std::shared_ptr<DialogController> pController( new RadioDependentEnabler( _rRadio ) );
         pController->addDependentWindow( _rDependentWindow1 );
         pController->addDependentWindow( _rDependentWindow2 );
         pController->addDependentWindow( _rDependentWindow3 );
@@ -214,7 +214,7 @@ namespace svt
 
     void ControlDependencyManager::enableOnCheckMark( CheckBox& _rBox, vcl::Window& _rDependentWindow )
     {
-        PDialogController pController( new RadioDependentEnabler( _rBox ) );
+        std::shared_ptr<DialogController> pController( new RadioDependentEnabler( _rBox ) );
         pController->addDependentWindow( _rDependentWindow );
         m_pImpl->aControllers.push_back( pController );
     }
@@ -222,7 +222,7 @@ namespace svt
 
     void ControlDependencyManager::enableOnCheckMark( CheckBox& _rBox, vcl::Window& _rDependentWindow1, vcl::Window& _rDependentWindow2 )
     {
-        PDialogController pController( new RadioDependentEnabler( _rBox ) );
+        std::shared_ptr<DialogController> pController( new RadioDependentEnabler( _rBox ) );
         pController->addDependentWindow( _rDependentWindow1 );
         pController->addDependentWindow( _rDependentWindow2 );
         m_pImpl->aControllers.push_back( pController );
@@ -231,7 +231,7 @@ namespace svt
 
     void ControlDependencyManager::enableOnCheckMark( CheckBox& _rBox, vcl::Window& _rDependentWindow1, vcl::Window& _rDependentWindow2, vcl::Window& _rDependentWindow3, vcl::Window& _rDependentWindow4 )
     {
-        PDialogController pController( new RadioDependentEnabler( _rBox ) );
+        std::shared_ptr<DialogController> pController( new RadioDependentEnabler( _rBox ) );
         pController->addDependentWindow( _rDependentWindow1 );
         pController->addDependentWindow( _rDependentWindow2 );
         pController->addDependentWindow( _rDependentWindow3 );
diff --git a/svx/source/customshapes/EnhancedCustomShapeFunctionParser.cxx b/svx/source/customshapes/EnhancedCustomShapeFunctionParser.cxx
index 4c0312bc6d0c..1b62812dc91c 100644
--- a/svx/source/customshapes/EnhancedCustomShapeFunctionParser.cxx
+++ b/svx/source/customshapes/EnhancedCustomShapeFunctionParser.cxx
@@ -325,15 +325,15 @@ public:
 class UnaryFunctionExpression : public ExpressionNode
 {
     const ExpressionFunct   meFunct;
-    ExpressionNodeSharedPtr mpArg;
+    std::shared_ptr<ExpressionNode> mpArg;
 
 public:
-    UnaryFunctionExpression( const ExpressionFunct eFunct, const ExpressionNodeSharedPtr& rArg ) :
+    UnaryFunctionExpression( const ExpressionFunct eFunct, const std::shared_ptr<ExpressionNode>& rArg ) :
         meFunct( eFunct ),
         mpArg( rArg )
     {
     }
-    static double getValue( const ExpressionFunct eFunct, const ExpressionNodeSharedPtr& rArg )
+    static double getValue( const ExpressionFunct eFunct, const std::shared_ptr<ExpressionNode>& rArg )
     {
         double fRet = 0;
         switch( eFunct )
@@ -493,18 +493,18 @@ public:
 class BinaryFunctionExpression : public ExpressionNode
 {
     const ExpressionFunct   meFunct;
-    ExpressionNodeSharedPtr mpFirstArg;
-    ExpressionNodeSharedPtr mpSecondArg;
+    std::shared_ptr<ExpressionNode> mpFirstArg;
+    std::shared_ptr<ExpressionNode> mpSecondArg;
 
 public:
 
-    BinaryFunctionExpression( const ExpressionFunct eFunct, const ExpressionNodeSharedPtr& rFirstArg, const ExpressionNodeSharedPtr& rSecondArg ) :
+    BinaryFunctionExpression( const ExpressionFunct eFunct, const std::shared_ptr<ExpressionNode>& rFirstArg, const std::shared_ptr<ExpressionNode>& rSecondArg ) :
         meFunct( eFunct ),
         mpFirstArg( rFirstArg ),
         mpSecondArg( rSecondArg )
     {
     }
-    static double getValue( const ExpressionFunct eFunct, const ExpressionNodeSharedPtr& rFirstArg, const ExpressionNodeSharedPtr& rSecondArg )
+    static double getValue( const ExpressionFunct eFunct, const std::shared_ptr<ExpressionNode>& rFirstArg, const std::shared_ptr<ExpressionNode>& rSecondArg )
     {
         double fRet = 0;
         switch( eFunct )
@@ -714,15 +714,15 @@ public:
 
 class IfExpression : public ExpressionNode
 {
-    ExpressionNodeSharedPtr mpFirstArg;
-    ExpressionNodeSharedPtr mpSecondArg;
-    ExpressionNodeSharedPtr mpThirdArg;
+    std::shared_ptr<ExpressionNode> mpFirstArg;
+    std::shared_ptr<ExpressionNode> mpSecondArg;
+    std::shared_ptr<ExpressionNode> mpThirdArg;
 
 public:
 
-    IfExpression( const ExpressionNodeSharedPtr& rFirstArg,
-                  const ExpressionNodeSharedPtr& rSecondArg,
-                  const ExpressionNodeSharedPtr& rThirdArg ) :
+    IfExpression( const std::shared_ptr<ExpressionNode>& rFirstArg,
+                  const std::shared_ptr<ExpressionNode>& rSecondArg,
+                  const std::shared_ptr<ExpressionNode>& rThirdArg ) :
         mpFirstArg(  rFirstArg ),
         mpSecondArg( rSecondArg ),
         mpThirdArg(  rThirdArg )
@@ -768,7 +768,7 @@ typedef const sal_Char* StringIteratorT;
 
 struct ParserContext
 {
-    typedef ::std::stack< ExpressionNodeSharedPtr > OperandStack;
+    typedef ::std::stack< std::shared_ptr<ExpressionNode> > OperandStack;
 
     // stores a stack of not-yet-evaluated operands. This is used
     // by the operators (i.e. '+', '*', 'sin' etc.) to pop their
@@ -796,7 +796,7 @@ public:
     }
     void operator()( double n ) const
     {
-        mxContext->maOperandStack.push( ExpressionNodeSharedPtr( new ConstantValueExpression( n ) ) );
+        mxContext->maOperandStack.push( std::shared_ptr<ExpressionNode>( new ConstantValueExpression( n ) ) );
     }
 };
 
@@ -820,17 +820,17 @@ public:
             case ENUM_FUNC_ADJUSTMENT :
             {
                 OUString aVal( rFirst + 1, rSecond - rFirst, RTL_TEXTENCODING_UTF8 );
-                mxContext->maOperandStack.push( ExpressionNodeSharedPtr( new AdjustmentExpression( *mxContext->mpCustoShape, aVal.toInt32() ) ) );
+                mxContext->maOperandStack.push( std::shared_ptr<ExpressionNode>( new AdjustmentExpression( *mxContext->mpCustoShape, aVal.toInt32() ) ) );
             }
             break;
             case ENUM_FUNC_EQUATION :
                 {
                 OUString aVal( rFirst + 1, rSecond - rFirst, RTL_TEXTENCODING_UTF8 );
-                mxContext->maOperandStack.push( ExpressionNodeSharedPtr( new EquationExpression( *mxContext->mpCustoShape, aVal.toInt32() ) ) );
+                mxContext->maOperandStack.push( std::shared_ptr<ExpressionNode>( new EquationExpression( *mxContext->mpCustoShape, aVal.toInt32() ) ) );
             }
             break;
             default:
-                mxContext->maOperandStack.push( ExpressionNodeSharedPtr( new EnumValueExpression( *mxContext->mpCustoShape, meFunct ) ) );
+                mxContext->maOperandStack.push( std::shared_ptr<ExpressionNode>( new EnumValueExpression( *mxContext->mpCustoShape, meFunct ) ) );
         }
     }
 };
@@ -855,13 +855,13 @@ public:
             throw ParseError( "Not enough arguments for unary operator" );
 
         // retrieve arguments
-        ExpressionNodeSharedPtr pArg( rNodeStack.top() );
+        std::shared_ptr<ExpressionNode> pArg( rNodeStack.top() );
         rNodeStack.pop();
 
         if( pArg->isConstant() )    // check for constness
-            rNodeStack.push( ExpressionNodeSharedPtr( new ConstantValueExpression( UnaryFunctionExpression::getValue( meFunct, pArg ) ) ) );
+            rNodeStack.push( std::shared_ptr<ExpressionNode>( new ConstantValueExpression( UnaryFunctionExpression::getValue( meFunct, pArg ) ) ) );
         else                        // push complex node, that calcs the value on demand
-            rNodeStack.push( ExpressionNodeSharedPtr( new UnaryFunctionExpression( meFunct, pArg ) ) );
+            rNodeStack.push( std::shared_ptr<ExpressionNode>( new UnaryFunctionExpression( meFunct, pArg ) ) );
     }
 };
 
@@ -893,16 +893,16 @@ public:
             throw ParseError( "Not enough arguments for binary operator" );
 
         // retrieve arguments
-        ExpressionNodeSharedPtr pSecondArg( rNodeStack.top() );
+        std::shared_ptr<ExpressionNode> pSecondArg( rNodeStack.top() );
         rNodeStack.pop();
-        ExpressionNodeSharedPtr pFirstArg( rNodeStack.top() );
+        std::shared_ptr<ExpressionNode> pFirstArg( rNodeStack.top() );
         rNodeStack.pop();
 
         // create combined ExpressionNode
-        ExpressionNodeSharedPtr pNode = ExpressionNodeSharedPtr( new BinaryFunctionExpression( meFunct, pFirstArg, pSecondArg ) );
+        std::shared_ptr<ExpressionNode> pNode = std::shared_ptr<ExpressionNode>( new BinaryFunctionExpression( meFunct, pFirstArg, pSecondArg ) );
         // check for constness
         if( pFirstArg->isConstant() && pSecondArg->isConstant() )   // call the operator() at pNode, store result in constant value ExpressionNode.
-            rNodeStack.push( ExpressionNodeSharedPtr( new ConstantValueExpression( (*pNode)() ) ) );
+            rNodeStack.push( std::shared_ptr<ExpressionNode>( new ConstantValueExpression( (*pNode)() ) ) );
         else                                                        // push complex node, that calcs the value on demand
             rNodeStack.push( pNode );
     }
@@ -926,18 +926,18 @@ public:
             throw ParseError( "Not enough arguments for ternary operator" );
 
         // retrieve arguments
-        ExpressionNodeSharedPtr pThirdArg( rNodeStack.top() );
+        std::shared_ptr<ExpressionNode> pThirdArg( rNodeStack.top() );
         rNodeStack.pop();
-        ExpressionNodeSharedPtr pSecondArg( rNodeStack.top() );
+        std::shared_ptr<ExpressionNode> pSecondArg( rNodeStack.top() );
         rNodeStack.pop();
-        ExpressionNodeSharedPtr pFirstArg( rNodeStack.top() );
+        std::shared_ptr<ExpressionNode> pFirstArg( rNodeStack.top() );
         rNodeStack.pop();
 
         // create combined ExpressionNode
-        ExpressionNodeSharedPtr pNode( new IfExpression( pFirstArg, pSecondArg, pThirdArg ) );
+        std::shared_ptr<ExpressionNode> pNode( new IfExpression( pFirstArg, pSecondArg, pThirdArg ) );
         // check for constness
         if( pFirstArg->isConstant() && pSecondArg->isConstant() && pThirdArg->isConstant() )
-            rNodeStack.push( ExpressionNodeSharedPtr( new ConstantValueExpression( (*pNode)() ) ) );    // call the operator() at pNode, store result in constant value ExpressionNode.
+            rNodeStack.push( std::shared_ptr<ExpressionNode>( new ConstantValueExpression( (*pNode)() ) ) );    // call the operator() at pNode, store result in constant value ExpressionNode.
         else
             rNodeStack.push( pNode );                                       // push complex node, that calcs the value on demand
     }
@@ -1155,7 +1155,7 @@ const ParserContextSharedPtr& getParserContext()
 namespace EnhancedCustomShape  {
 
 
-ExpressionNodeSharedPtr FunctionParser::parseFunction( const OUString& rFunction, const EnhancedCustomShape2d& rCustoShape )
+std::shared_ptr<ExpressionNode> FunctionParser::parseFunction( const OUString& rFunction, const EnhancedCustomShape2d& rCustoShape )
 {
     // TODO(Q1): Check if a combination of the RTL_UNICODETOTEXT_FLAGS_*
     // gives better conversion robustness here (we might want to map space
diff --git a/svx/source/unodraw/shapepropertynotifier.cxx b/svx/source/unodraw/shapepropertynotifier.cxx
index 3e36e7080ac9..5d1ed99b4054 100644
--- a/svx/source/unodraw/shapepropertynotifier.cxx
+++ b/svx/source/unodraw/shapepropertynotifier.cxx
@@ -54,7 +54,7 @@ namespace svx
     using ::com::sun::star::lang::EventObject;
     using ::com::sun::star::beans::XPropertySet;
 
-    typedef std::unordered_map< ShapeProperty, PPropertyValueProvider, ShapePropertyHash  >    PropertyProviders;
+    typedef std::unordered_map< ShapeProperty, std::shared_ptr<IPropertyValueProvider>, ShapePropertyHash  >    PropertyProviders;
 
     typedef cppu::OMultiTypeInterfaceContainerHelperVar<OUString>
         PropertyChangeListenerContainer;
@@ -100,7 +100,7 @@ namespace svx
     {
     }
 
-    void PropertyChangeNotifier::registerProvider(const ShapeProperty _eProperty, const PPropertyValueProvider& _rProvider)
+    void PropertyChangeNotifier::registerProvider(const ShapeProperty _eProperty, const std::shared_ptr<IPropertyValueProvider>& _rProvider)
     {
         ENSURE_OR_THROW( _eProperty != eInvalidShapeProperty, "Illegal ShapeProperty value!" );
         ENSURE_OR_THROW( !!_rProvider, "NULL factory not allowed." );
diff --git a/svx/source/unodraw/unoshape.cxx b/svx/source/unodraw/unoshape.cxx
index 53173746007c..72a010dcd2ee 100644
--- a/svx/source/unodraw/unoshape.cxx
+++ b/svx/source/unodraw/unoshape.cxx
@@ -327,9 +327,9 @@ svx::PropertyChangeNotifier& SvxShape::getShapePropertyChangeNotifier()
 void SvxShape::impl_construct()
 {
     mpImpl->maPropertyNotifier.registerProvider( svx::eShapePosition,
-        svx::PPropertyValueProvider( new ShapePositionProvider( *mpImpl ) ) );
+        std::shared_ptr<svx::IPropertyValueProvider>( new ShapePositionProvider( *mpImpl ) ) );
     mpImpl->maPropertyNotifier.registerProvider( svx::eShapeSize,
-        svx::PPropertyValueProvider( new ShapeSizeProvider( *mpImpl ) ) );
+        std::shared_ptr<svx::IPropertyValueProvider>( new ShapeSizeProvider( *mpImpl ) ) );
 
     if ( mpObj.is() )
         impl_initFromSdrObject();
diff --git a/sw/source/core/unocore/unodraw.cxx b/sw/source/core/unocore/unodraw.cxx
index a12fa5dd1089..417dff8ff9d8 100644
--- a/sw/source/core/unocore/unodraw.cxx
+++ b/sw/source/core/unocore/unodraw.cxx
@@ -915,7 +915,7 @@ namespace
 {
     void lcl_addShapePropertyEventFactories( SdrObject& _rObj, SwXShape& _rShape )
     {
-        svx::PPropertyValueProvider pProvider( new svx::PropertyValueProvider( _rShape, "AnchorType" ) );
+        std::shared_ptr<svx::IPropertyValueProvider> pProvider( new svx::PropertyValueProvider( _rShape, "AnchorType" ) );
         _rObj.getShapePropertyChangeNotifier().registerProvider( svx::eTextShapeAnchorType, pProvider );
     }
 }
diff --git a/sw/source/filter/ww8/wrtw8esh.cxx b/sw/source/filter/ww8/wrtw8esh.cxx
index d1729a993c5e..8e0a8f73a2e5 100644
--- a/sw/source/filter/ww8/wrtw8esh.cxx
+++ b/sw/source/filter/ww8/wrtw8esh.cxx
@@ -1561,7 +1561,7 @@ SvStream* SwEscherExGlobal::ImplQueryPictureStream()
 }
 
 SwBasicEscherEx::SwBasicEscherEx(SvStream* pStrm, WW8Export& rWW8Wrt)
-    : EscherEx( EscherExGlobalRef( new SwEscherExGlobal ), pStrm), rWrt(rWW8Wrt), pEscherStrm(pStrm)
+    : EscherEx( std::shared_ptr<EscherExGlobal>( new SwEscherExGlobal ), pStrm), rWrt(rWW8Wrt), pEscherStrm(pStrm)
 {
     Init();
 }