sw/source/core/undo/unsort.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: unsort.cxx,v $
  10  * $Revision: 1.9 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sw.hxx"
  33 #include <doc.hxx>
  34 #include <swundo.hxx>                   // fuer die UndoIds
  35 #include <pam.hxx>
  36 #include <swtable.hxx>
  37 #include <ndtxt.hxx>
  38 #include <undobj.hxx>
  39 #include <sortopt.hxx>
  40 #ifndef _DOCSORT_HXX
  41 #include <docsort.hxx>
  42 #endif
  43 #include <redline.hxx>
  44 #include <node2lay.hxx>
  45
  46 inline SwDoc& SwUndoIter::GetDoc() const { return *pAktPam->GetDoc(); }
  47
  48 /*--------------------------------------------------------------------
  49     Beschreibung:  Undo fuers Sorting
  50  --------------------------------------------------------------------*/
  51
  52
  53 SV_IMPL_PTRARR(SwSortList, SwSortUndoElement*)
  54 SV_IMPL_PTRARR(SwUndoSortList, SwNodeIndex*)
  55
  56
  57 SwSortUndoElement::~SwSortUndoElement()
  58 {
  59     // sind String Pointer gespeichert ??
  60     if( 0xffffffff != SORT_TXT_TBL.TXT.nKenn )
  61     {
  62         delete SORT_TXT_TBL.TBL.pSource;
  63         delete SORT_TXT_TBL.TBL.pTarget;
  64     }
  65 }
  66
  67
  68 SwUndoSort::SwUndoSort(const SwPaM& rRg, const SwSortOptions& rOpt)
  69     : SwUndo(UNDO_SORT_TXT), SwUndRng(rRg), pUndoTblAttr( 0 ),
  70     pRedlData( 0 )
  71 {
  72     pSortOpt = new SwSortOptions(rOpt);
  73 }
  74
  75
  76 SwUndoSort::SwUndoSort( ULONG nStt, ULONG nEnd, const SwTableNode& rTblNd,
  77                         const SwSortOptions& rOpt, BOOL bSaveTable )
  78     : SwUndo(UNDO_SORT_TBL), pUndoTblAttr( 0 ), pRedlData( 0 )
  79 {
  80     nSttNode = nStt;
  81     nEndNode = nEnd;
  82     nTblNd   = rTblNd.GetIndex();
  83
  84     pSortOpt = new SwSortOptions(rOpt);
  85     if( bSaveTable )
  86         pUndoTblAttr = new SwUndoAttrTbl( rTblNd );
  87 }
  88
  89
  90
  91 SwUndoSort::~SwUndoSort()
  92 {
  93     delete pSortOpt;
  94     delete pUndoTblAttr;
  95     delete pRedlData;
  96 }
  97
  98
  99
 100 void SwUndoSort::Undo( SwUndoIter& rIter)
 101 {
 102     SwDoc&      rDoc = rIter.GetDoc();
 103     if(pSortOpt->bTable)
 104     {
 105         // Undo Tabelle
 106         RemoveIdxFromSection( rDoc, nSttNode, &nEndNode );
 107
 108         if( pUndoTblAttr )
 109             pUndoTblAttr->Undo( rIter );
 110
 111         SwTableNode* pTblNd = rDoc.GetNodes()[ nTblNd ]->GetTableNode();
 112
 113         // --> FME 2004-11-26 #i37739# A simple 'MakeFrms' after the node sorting
 114         // does not work if the table is inside a frame and has no prev/next.
 115         SwNode2Layout aNode2Layout( *pTblNd );
 116         // <--
 117
 118         pTblNd->DelFrms();
 119         const SwTable& rTbl = pTblNd->GetTable();
 120
 121         SwMovedBoxes aMovedList;
 122         for( USHORT i=0; i < aSortList.Count(); i++)
 123         {
 124             const SwTableBox* pSource = rTbl.GetTblBox(
 125                     *aSortList[i]->SORT_TXT_TBL.TBL.pSource );
 126             const SwTableBox* pTarget = rTbl.GetTblBox(
 127                     *aSortList[i]->SORT_TXT_TBL.TBL.pTarget );
 128
 129             // zurueckverschieben
 130             MoveCell(&rDoc, pTarget, pSource,
 131                      USHRT_MAX != aMovedList.GetPos(pSource) );
 132
 133             // schon Verschobenen in der Liste merken
 134             aMovedList.Insert(pTarget, aMovedList.Count() );
 135         }
 136
 137         // Restore table frames:
 138         // --> FME 2004-11-26 #i37739# A simple 'MakeFrms' after the node sorting
 139         // does not work if the table is inside a frame and has no prev/next.
 140         const ULONG nIdx = pTblNd->GetIndex();
 141         aNode2Layout.RestoreUpperFrms( rDoc.GetNodes(), nIdx, nIdx + 1 );
 142         // <--
 143     }
 144     else
 145     {
 146         // Undo Text
 147         RemoveIdx( *rIter.pAktPam );
 148
 149         // fuer die sorted Positions einen Index anlegen.
 150         // JP 25.11.97: Die IndexList muss aber nach SourcePosition
 151         //                              aufsteigend sortiert aufgebaut werden
 152         SwUndoSortList aIdxList( (BYTE)aSortList.Count() );
 153         USHORT i;
 154
 155         for( i = 0; i < aSortList.Count(); ++i)
 156             for( USHORT ii=0; ii < aSortList.Count(); ++ii )
 157                 if( aSortList[ii]->SORT_TXT_TBL.TXT.nSource == nSttNode + i )
 158                 {
 159                     SwNodeIndex* pIdx = new SwNodeIndex( rDoc.GetNodes(),
 160                         aSortList[ii]->SORT_TXT_TBL.TXT.nTarget );
 161                     aIdxList.C40_INSERT(SwNodeIndex, pIdx, i );
 162                     break;
 163                 }
 164
 165         for(i=0; i < aSortList.Count(); ++i)
 166         {
 167             SwNodeIndex aIdx( rDoc.GetNodes(), nSttNode + i );
 168             SwNodeRange aRg( *aIdxList[i], 0, *aIdxList[i], 1 );
 169             rDoc.Move(aRg, aIdx, IDocumentContentOperations::DOC_MOVEDEFAULT);
 170         }
 171         // Indixes loeschen
 172         aIdxList.DeleteAndDestroy(0, aIdxList.Count());
 173         SetPaM( rIter, TRUE );
 174     }
 175 }
 176
 177
 178 void SwUndoSort::Redo( SwUndoIter& rIter)
 179 {
 180     SwDoc& rDoc = rIter.GetDoc();
 181
 182     if(pSortOpt->bTable)
 183     {
 184         // Redo bei Tabelle
 185         RemoveIdxFromSection( rDoc, nSttNode, &nEndNode );
 186
 187         SwTableNode* pTblNd = rDoc.GetNodes()[ nTblNd ]->GetTableNode();
 188
 189         // --> FME 2004-11-26 #i37739# A simple 'MakeFrms' after the node sorting
 190         // does not work if the table is inside a frame and has no prev/next.
 191         SwNode2Layout aNode2Layout( *pTblNd );
 192         // <--
 193
 194         pTblNd->DelFrms();
 195         const SwTable& rTbl = pTblNd->GetTable();
 196
 197         SwMovedBoxes aMovedList;
 198         for(USHORT i=0; i < aSortList.Count(); ++i)
 199         {
 200             const SwTableBox* pSource = rTbl.GetTblBox(
 201                     (const String&) *aSortList[i]->SORT_TXT_TBL.TBL.pSource );
 202             const SwTableBox* pTarget = rTbl.GetTblBox(
 203                     (const String&) *aSortList[i]->SORT_TXT_TBL.TBL.pTarget );
 204
 205             // zurueckverschieben
 206             MoveCell(&rDoc, pSource, pTarget,
 207                      USHRT_MAX != aMovedList.GetPos( pTarget ) );
 208             // schon Verschobenen in der Liste merken
 209             aMovedList.Insert( pSource, aMovedList.Count() );
 210         }
 211
 212         if( pUndoTblAttr )
 213             pUndoTblAttr->Redo( rIter );
 214
 215         // Restore table frames:
 216         // --> FME 2004-11-26 #i37739# A simple 'MakeFrms' after the node sorting
 217         // does not work if the table is inside a frame and has no prev/next.
 218         const ULONG nIdx = pTblNd->GetIndex();
 219         aNode2Layout.RestoreUpperFrms( rDoc.GetNodes(), nIdx, nIdx + 1 );
 220         // <--
 221     }
 222     else
 223     {
 224         // Redo bei Text
 225         RemoveIdx( *rIter.pAktPam );
 226
 227         SwUndoSortList aIdxList( (BYTE)aSortList.Count() );
 228         USHORT i;
 229
 230         for( i = 0; i < aSortList.Count(); ++i)
 231         {       // aktuelle Pos ist die Ausgangslage
 232             SwNodeIndex* pIdx = new SwNodeIndex( rDoc.GetNodes(),
 233                     aSortList[i]->SORT_TXT_TBL.TXT.nSource);
 234             aIdxList.C40_INSERT( SwNodeIndex, pIdx, i );
 235         }
 236
 237         for(i=0; i < aSortList.Count(); ++i)
 238         {
 239             SwNodeIndex aIdx( rDoc.GetNodes(), nSttNode + i);
 240             SwNodeRange aRg( *aIdxList[i], 0, *aIdxList[i], 1 );
 241             rDoc.Move(aRg, aIdx, IDocumentContentOperations::DOC_MOVEDEFAULT);
 242         }
 243         // Indixes loeschen
 244         aIdxList.DeleteAndDestroy(0, aIdxList.Count());
 245         SetPaM( rIter, TRUE );
 246         const SwTxtNode* pTNd = rIter.pAktPam->GetNode()->GetTxtNode();
 247         if( pTNd )
 248             rIter.pAktPam->GetPoint()->nContent = pTNd->GetTxt().Len();
 249     }
 250 }
 251
 252
 253 void SwUndoSort::Repeat(SwUndoIter& rIter)
 254 {
 255     if(!pSortOpt->bTable)
 256     {
 257         SwPaM* pPam = rIter.pAktPam;
 258         SwDoc& rDoc = *pPam->GetDoc();
 259
 260         if( !rDoc.IsIdxInTbl( pPam->Start()->nNode ) )
 261             rDoc.SortText(*pPam, *pSortOpt);
 262     }
 263     // Tabelle ist nicht Repeat-Faehig
 264     rIter.pLastUndoObj = this;
 265 }
 266
 267
 268 void SwUndoSort::RemoveIdx( SwPaM& rPam )
 269 {
 270     rPam.DeleteMark();
 271     rPam.GetPoint()->nNode = nSttNode;
 272
 273     SwCntntNode* pCNd = rPam.GetCntntNode();
 274     xub_StrLen nLen = pCNd->Len();
 275     if( nLen >= nSttCntnt )
 276         nLen = nSttCntnt;
 277     rPam.GetPoint()->nContent.Assign(pCNd, nLen );
 278     rPam.SetMark();
 279
 280     rPam.GetPoint()->nNode = nEndNode;
 281     pCNd = rPam.GetCntntNode();
 282     nLen = pCNd->Len();
 283     if( nLen >= nEndCntnt )
 284         nLen = nEndCntnt;
 285     rPam.GetPoint()->nContent.Assign(pCNd, nLen );
 286     RemoveIdxFromRange( rPam, TRUE );
 287 }
 288
 289
 290 void SwUndoSort::Insert( const String& rOrgPos, const String& rNewPos)
 291 {
 292     SwSortUndoElement* pEle = new SwSortUndoElement(rOrgPos, rNewPos);
 293     aSortList.C40_INSERT( SwSortUndoElement, pEle, aSortList.Count() );
 294 }
 295
 296
 297 void SwUndoSort::Insert( ULONG nOrgPos, ULONG nNewPos)
 298 {
 299     SwSortUndoElement* pEle = new SwSortUndoElement(nOrgPos, nNewPos);
 300     aSortList.C40_INSERT( SwSortUndoElement, pEle, aSortList.Count() );
 301 }
 302
 303