Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 395 insertions, 0 deletions

diff --git a/sw/source/core/undo/unnum.cxx b/sw/source/core/undo/unnum.cxx
new file mode 100644
index 000000000..a4e4b39c0
--- /dev/null
+++ b/sw/source/core/undo/unnum.cxx
@@ -0,0 +1,395 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * 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 .
+ */
+
+#include <UndoNumbering.hxx>
+#include <doc.hxx>
+#include <swundo.hxx>
+#include <pam.hxx>
+#include <ndtxt.hxx>
+#include <UndoCore.hxx>
+#include <rolbck.hxx>
+#include <osl/diagnose.h>
+
+SwUndoInsNum::SwUndoInsNum( const SwNumRule& rOldRule,
+                            const SwNumRule& rNewRule,
+                            const SwDoc* pDoc,
+                            SwUndoId nUndoId)
+    : SwUndo( nUndoId, pDoc ),
+    m_aNumRule( rNewRule ),
+    m_pOldNumRule( new SwNumRule( rOldRule )), m_nLRSavePos( 0 )
+{
+}
+
+SwUndoInsNum::SwUndoInsNum( const SwPaM& rPam, const SwNumRule& rRule )
+    : SwUndo( SwUndoId::INSNUM, rPam.GetDoc() ), SwUndRng( rPam ),
+    m_aNumRule( rRule ),
+    m_nLRSavePos( 0 )
+{
+}
+
+SwUndoInsNum::SwUndoInsNum( const SwPosition& rPos, const SwNumRule& rRule,
+                            const OUString& rReplaceRule )
+    : SwUndo( SwUndoId::INSNUM, rPos.nNode.GetNode().GetDoc() ),
+    m_aNumRule( rRule ),
+    m_sReplaceRule( rReplaceRule ), m_nLRSavePos( 0 )
+{
+    // No selection!
+    m_nEndNode = 0;
+    m_nEndContent = COMPLETE_STRING;
+    m_nSttNode = rPos.nNode.GetIndex();
+    m_nSttContent = rPos.nContent.GetIndex();
+}
+
+SwUndoInsNum::~SwUndoInsNum()
+{
+    m_pHistory.reset();
+    m_pOldNumRule.reset();
+}
+
+SwRewriter SwUndoInsNum::GetRewriter() const
+{
+    SwRewriter aResult;
+    if( SwUndoId::INSFMTATTR == GetId() )
+        aResult.AddRule(UndoArg1, m_aNumRule.GetName());
+    return aResult;
+}
+
+void SwUndoInsNum::UndoImpl(::sw::UndoRedoContext & rContext)
+{
+    SwDoc & rDoc = rContext.GetDoc();
+
+    if( m_pOldNumRule )
+        rDoc.ChgNumRuleFormats( *m_pOldNumRule );
+
+    if( m_pHistory )
+    {
+        if( m_nLRSavePos )
+        {
+            // Update immediately so that potential "old" LRSpaces will be valid again.
+            m_pHistory->TmpRollback( &rDoc, m_nLRSavePos );
+
+        }
+        m_pHistory->TmpRollback( &rDoc, 0 );
+        m_pHistory->SetTmpEnd( m_pHistory->Count() );
+    }
+
+    if (m_nSttNode)
+    {
+        AddUndoRedoPaM(rContext);
+    }
+}
+
+void SwUndoInsNum::RedoImpl(::sw::UndoRedoContext & rContext)
+{
+    SwDoc & rDoc = rContext.GetDoc();
+
+    if ( m_pOldNumRule )
+        rDoc.ChgNumRuleFormats( m_aNumRule );
+    else if ( m_pHistory )
+    {
+        SwPaM & rPam( AddUndoRedoPaM(rContext) );
+        if( !m_sReplaceRule.isEmpty() )
+        {
+            rDoc.ReplaceNumRule( *rPam.GetPoint(), m_sReplaceRule, m_aNumRule.GetName() );
+        }
+        else
+        {
+            // #i42921# - adapt to changed signature
+            rDoc.SetNumRule(rPam, m_aNumRule, false);
+        }
+    }
+}
+
+void SwUndoInsNum::SetLRSpaceEndPos()
+{
+    if( m_pHistory )
+        m_nLRSavePos = m_pHistory->Count();
+}
+
+void SwUndoInsNum::RepeatImpl(::sw::RepeatContext & rContext)
+{
+    SwDoc & rDoc( rContext.GetDoc() );
+    if ( m_nSttNode )
+    {
+        if( m_sReplaceRule.isEmpty() )
+        {
+            // #i42921# - adapt to changed signature
+            rDoc.SetNumRule(rContext.GetRepeatPaM(), m_aNumRule, false);
+        }
+    }
+    else
+    {
+        rDoc.ChgNumRuleFormats( m_aNumRule );
+    }
+}
+
+SwHistory* SwUndoInsNum::GetHistory()
+{
+    if( !m_pHistory )
+        m_pHistory.reset(new SwHistory);
+    return m_pHistory.get();
+}
+
+void SwUndoInsNum::SaveOldNumRule( const SwNumRule& rOld )
+{
+    if( !m_pOldNumRule )
+        m_pOldNumRule.reset(new SwNumRule( rOld ));
+}
+
+SwUndoDelNum::SwUndoDelNum( const SwPaM& rPam )
+    : SwUndo( SwUndoId::DELNUM, rPam.GetDoc() ), SwUndRng( rPam )
+{
+    m_aNodes.reserve( std::min<sal_uLong>(m_nEndNode - m_nSttNode, 255) );
+    m_pHistory.reset( new SwHistory );
+}
+
+SwUndoDelNum::~SwUndoDelNum()
+{
+}
+
+void SwUndoDelNum::UndoImpl(::sw::UndoRedoContext & rContext)
+{
+    SwDoc & rDoc = rContext.GetDoc();
+
+    m_pHistory->TmpRollback( &rDoc, 0 );
+    m_pHistory->SetTmpEnd( m_pHistory->Count() );
+
+    for( const auto& rNode : m_aNodes )
+    {
+        SwTextNode* pNd = rDoc.GetNodes()[ rNode.index ]->GetTextNode();
+        OSL_ENSURE( pNd, "Where has the TextNode gone?" );
+        pNd->SetAttrListLevel( rNode.level );
+
+        if( pNd->GetCondFormatColl() )
+            pNd->ChkCondColl();
+    }
+
+    AddUndoRedoPaM(rContext);
+}
+
+void SwUndoDelNum::RedoImpl(::sw::UndoRedoContext & rContext)
+{
+    SwPaM & rPam( AddUndoRedoPaM(rContext) );
+    rContext.GetDoc().DelNumRules(rPam);
+}
+
+void SwUndoDelNum::RepeatImpl(::sw::RepeatContext & rContext)
+{
+    rContext.GetDoc().DelNumRules(rContext.GetRepeatPaM());
+}
+
+void SwUndoDelNum::AddNode( const SwTextNode& rNd )
+{
+    if( rNd.GetNumRule() )
+    {
+        m_aNodes.emplace_back( rNd.GetIndex(), rNd.GetActualListLevel() );
+    }
+}
+
+SwUndoMoveNum::SwUndoMoveNum( const SwPaM& rPam, long nOff, bool bIsOutlMv )
+    : SwUndo( bIsOutlMv ? SwUndoId::OUTLINE_UD : SwUndoId::MOVENUM, rPam.GetDoc() ),
+    SwUndRng( rPam ),
+    nNewStt( 0 ), nOffset( nOff )
+{
+    // nOffset: Down    =>  1
+    //          Up      => -1
+}
+
+void SwUndoMoveNum::UndoImpl(::sw::UndoRedoContext & rContext)
+{
+    sal_uLong nTmpStt = m_nSttNode, nTmpEnd = m_nEndNode;
+
+    if (m_nEndNode || m_nEndContent != COMPLETE_STRING)        // section?
+    {
+        if( nNewStt < m_nSttNode )        // moved forwards
+            m_nEndNode = m_nEndNode - ( m_nSttNode - nNewStt );
+        else
+            m_nEndNode = m_nEndNode + ( nNewStt - m_nSttNode );
+    }
+    m_nSttNode = nNewStt;
+
+    SwPaM & rPam( AddUndoRedoPaM(rContext) );
+    rContext.GetDoc().MoveParagraph( rPam, -nOffset,
+                                        SwUndoId::OUTLINE_UD == GetId() );
+    m_nSttNode = nTmpStt;
+    m_nEndNode = nTmpEnd;
+}
+
+void SwUndoMoveNum::RedoImpl(::sw::UndoRedoContext & rContext)
+{
+    SwPaM & rPam( AddUndoRedoPaM(rContext) );
+    rContext.GetDoc().MoveParagraph(rPam, nOffset, SwUndoId::OUTLINE_UD == GetId());
+}
+
+void SwUndoMoveNum::RepeatImpl(::sw::RepeatContext & rContext)
+{
+    SwDoc & rDoc = rContext.GetDoc();
+    if( SwUndoId::OUTLINE_UD == GetId() )
+    {
+        rDoc.MoveOutlinePara(rContext.GetRepeatPaM(),
+                                            0 < nOffset ? 1 : -1 );
+    }
+    else
+    {
+        rDoc.MoveParagraph(rContext.GetRepeatPaM(), nOffset);
+    }
+}
+
+SwUndoNumUpDown::SwUndoNumUpDown( const SwPaM& rPam, short nOff )
+    : SwUndo( nOff > 0 ? SwUndoId::NUMUP : SwUndoId::NUMDOWN, rPam.GetDoc() ),
+      SwUndRng( rPam ),
+      nOffset( nOff )
+{
+    // nOffset: Down    =>  1
+    //          Up      => -1
+}
+
+void SwUndoNumUpDown::UndoImpl(::sw::UndoRedoContext & rContext)
+{
+    SwPaM & rPam( AddUndoRedoPaM(rContext) );
+    rContext.GetDoc().NumUpDown(rPam, 1 != nOffset );
+}
+
+void SwUndoNumUpDown::RedoImpl(::sw::UndoRedoContext & rContext)
+{
+    SwPaM & rPam( AddUndoRedoPaM(rContext) );
+    rContext.GetDoc().NumUpDown(rPam, 1 == nOffset);
+}
+
+void SwUndoNumUpDown::RepeatImpl(::sw::RepeatContext & rContext)
+{
+    rContext.GetDoc().NumUpDown(rContext.GetRepeatPaM(), 1 == nOffset);
+}
+
+SwUndoNumOrNoNum::SwUndoNumOrNoNum( const SwNodeIndex& rIdx, bool bOldNum,
+                                    bool bNewNum)
+    : SwUndo( SwUndoId::NUMORNONUM, rIdx.GetNode().GetDoc() ),
+      nIdx( rIdx.GetIndex() ), mbNewNum(bNewNum),
+      mbOldNum(bOldNum)
+{
+}
+
+// #115901#, #i40034#
+void SwUndoNumOrNoNum::UndoImpl(::sw::UndoRedoContext & rContext)
+{
+    SwNodeIndex aIdx( rContext.GetDoc().GetNodes(), nIdx );
+    SwTextNode * pTextNd = aIdx.GetNode().GetTextNode();
+
+    if (nullptr != pTextNd)
+    {
+        pTextNd->SetCountedInList(mbOldNum);
+    }
+}
+
+// #115901#, #i40034#
+void SwUndoNumOrNoNum::RedoImpl(::sw::UndoRedoContext & rContext)
+{
+    SwNodeIndex aIdx( rContext.GetDoc().GetNodes(), nIdx );
+    SwTextNode * pTextNd = aIdx.GetNode().GetTextNode();
+
+    if (nullptr != pTextNd)
+    {
+        pTextNd->SetCountedInList(mbNewNum);
+    }
+}
+
+void SwUndoNumOrNoNum::RepeatImpl(::sw::RepeatContext & rContext)
+{
+    SwDoc & rDoc = rContext.GetDoc();
+    if (mbOldNum && ! mbNewNum)
+    {
+        rDoc.NumOrNoNum(rContext.GetRepeatPaM().GetPoint()->nNode);
+    }
+    else if ( ! mbOldNum && mbNewNum )
+    {
+        rDoc.NumOrNoNum(rContext.GetRepeatPaM().GetPoint()->nNode, true);
+    }
+}
+
+SwUndoNumRuleStart::SwUndoNumRuleStart( const SwPosition& rPos, bool bFlg )
+    : SwUndo( SwUndoId::SETNUMRULESTART, rPos.GetDoc() ),
+    nIdx( rPos.nNode.GetIndex() ), nOldStt( USHRT_MAX ),
+    nNewStt( USHRT_MAX ), bSetSttValue( false ), bFlag( bFlg )
+{
+}
+
+SwUndoNumRuleStart::SwUndoNumRuleStart( const SwPosition& rPos, sal_uInt16 nStt )
+    : SwUndo(SwUndoId::SETNUMRULESTART, rPos.GetDoc())
+    , nIdx(rPos.nNode.GetIndex())
+    , nOldStt(USHRT_MAX)
+    , nNewStt(nStt)
+    , bSetSttValue(true)
+    , bFlag(false)
+{
+    SwTextNode* pTextNd = rPos.nNode.GetNode().GetTextNode();
+    if ( pTextNd )
+    {
+        if ( pTextNd->HasAttrListRestartValue() )
+        {
+            nOldStt = static_cast<sal_uInt16>(pTextNd->GetAttrListRestartValue());
+        }
+        else
+        {
+            nOldStt = USHRT_MAX; // indicating, that the list restart value is not set
+        }
+    }
+}
+
+void SwUndoNumRuleStart::UndoImpl(::sw::UndoRedoContext & rContext)
+{
+    SwDoc & rDoc = rContext.GetDoc();
+    SwPosition const aPos( *rDoc.GetNodes()[ nIdx ] );
+    if( bSetSttValue )
+    {
+        rDoc.SetNodeNumStart( aPos, nOldStt );
+    }
+    else
+    {
+        rDoc.SetNumRuleStart( aPos, !bFlag );
+    }
+}
+
+void SwUndoNumRuleStart::RedoImpl(::sw::UndoRedoContext & rContext)
+{
+    SwDoc & rDoc = rContext.GetDoc();
+    SwPosition const aPos( *rDoc.GetNodes()[ nIdx ] );
+    if( bSetSttValue )
+    {
+        rDoc.SetNodeNumStart( aPos, nNewStt );
+    }
+    else
+    {
+        rDoc.SetNumRuleStart( aPos, bFlag );
+    }
+}
+
+void SwUndoNumRuleStart::RepeatImpl(::sw::RepeatContext & rContext)
+{
+    SwDoc & rDoc = rContext.GetDoc();
+    if( bSetSttValue )
+    {
+        rDoc.SetNodeNumStart(*rContext.GetRepeatPaM().GetPoint(), nNewStt);
+    }
+    else
+    {
+        rDoc.SetNumRuleStart(*rContext.GetRepeatPaM().GetPoint(), bFlag);
+    }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */