sw/source/core/doc/docsort.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: docsort.cxx,v $
  10  * $Revision: 1.20 $
  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 <hintids.hxx>
  34 #include <rtl/math.hxx>
  35 #include <unotools/collatorwrapper.hxx>
  36 #include <unotools/localedatawrapper.hxx>
  37 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  38 #include <com/sun/star/i18n/CollatorOptions.hpp>
  39 #include <comphelper/processfactory.hxx>
  40 #include <svx/unolingu.hxx>
  41 #include <docary.hxx>
  42 #include <fmtanchr.hxx>
  43 #include <frmfmt.hxx>
  44 #include <doc.hxx>
  45 #include <node.hxx>
  46 #include <pam.hxx>
  47 #include <ndtxt.hxx>
  48 #include <swtable.hxx>
  49 #include <swundo.hxx>
  50 #include <sortopt.hxx>
  51 #ifndef _DOCSORT_HXX
  52 #include <docsort.hxx>
  53 #endif
  54 #include <undobj.hxx>
  55 #include <tblsel.hxx>
  56 #include <cellatr.hxx>
  57 #include <redline.hxx>
  58 #include <node2lay.hxx>
  59 #include <unochart.hxx>
  60
  61 #if OSL_DEBUG_LEVEL > 1
  62 //nur zum debugen
  63 #include <cellatr.hxx>
  64 #endif
  65
  66 using namespace ::com::sun::star::lang;
  67
  68 SwSortOptions*          SwSortElement::pOptions = 0;
  69 SwDoc*                          SwSortElement::pDoc = 0;
  70 const FlatFndBox*       SwSortElement::pBox = 0;
  71 CollatorWrapper*        SwSortElement::pSortCollator = 0;
  72 Locale*                         SwSortElement::pLocale = 0;
  73 String*                         SwSortElement::pLastAlgorithm = 0;
  74 LocaleDataWrapper*      SwSortElement::pLclData = 0;
  75
  76 SV_IMPL_OP_PTRARR_SORT( SwSortElements, SwSortElementPtr );
  77
  78
  79 /*--------------------------------------------------------------------
  80     Beschreibung: Ein Sortierelement fuers Sort konstruieren
  81  --------------------------------------------------------------------*/
  82
  83
  84 void SwSortElement::Init( SwDoc* pD, const SwSortOptions& rOpt,
  85                             FlatFndBox* pFltBx )
  86 {
  87     ASSERT( !pDoc && !pOptions && !pBox, "wer hat das Finit vergessen?" );
  88     pDoc = pD;
  89     pOptions = new SwSortOptions( rOpt );
  90     pBox = pFltBx;
  91
  92     LanguageType nLang = rOpt.nLanguage;
  93     switch ( nLang )
  94     {
  95     case LANGUAGE_NONE:
  96     case LANGUAGE_DONTKNOW:
  97         nLang = (LanguageType)GetAppLanguage();
  98         break;
  99     }
 100     pLocale = new Locale( SvxCreateLocale( nLang ) );
 101
 102     pSortCollator = new CollatorWrapper(
 103                                 ::comphelper::getProcessServiceFactory() );
 104 //      pSortCollator->loadCollatorAlgorithm( sAlgorithm, aLocale,
 105 //                                              rOpt.bIgnoreCase ? SW_COLLATOR_IGNORES : 0 );
 106 }
 107
 108
 109 void SwSortElement::Finit()
 110 {
 111     delete pOptions, pOptions = 0;
 112     delete pLocale, pLocale = 0;
 113     delete pLastAlgorithm, pLastAlgorithm = 0;
 114     delete pSortCollator, pSortCollator = 0;
 115     delete pLclData, pLclData = 0;
 116     pDoc = 0;
 117     pBox = 0;
 118 }
 119
 120
 121 SwSortElement::~SwSortElement()
 122 {
 123 }
 124
 125
 126 double SwSortElement::StrToDouble( const String& rStr ) const
 127 {
 128     if( !pLclData )
 129         pLclData = new LocaleDataWrapper(
 130                     ::comphelper::getProcessServiceFactory(), *pLocale );
 131
 132     rtl_math_ConversionStatus eStatus;
 133     sal_Int32 nEnd;
 134     double nRet = ::rtl::math::stringToDouble( rStr,
 135                                     pLclData->getNumDecimalSep().GetChar(0),
 136                                     pLclData->getNumThousandSep().GetChar(0),
 137                                     &eStatus, &nEnd );
 138
 139     if( rtl_math_ConversionStatus_Ok != eStatus || nEnd == 0 )
 140         nRet = 0.0;
 141     return nRet;
 142 }
 143
 144 /*--------------------------------------------------------------------
 145     Beschreibung: Operatoren zum Vergleichen
 146  --------------------------------------------------------------------*/
 147
 148
 149 BOOL SwSortElement::operator==(const SwSortElement& )
 150 {
 151     return FALSE;
 152 }
 153
 154 /*--------------------------------------------------------------------
 155     Beschreibung: Kleiner-Operator fuers sortieren
 156  --------------------------------------------------------------------*/
 157
 158 BOOL SwSortElement::operator<(const SwSortElement& rCmp)
 159 {
 160
 161     // der eigentliche Vergleich
 162     //
 163     for(USHORT nKey = 0; nKey < pOptions->aKeys.Count(); ++nKey)
 164     {
 165         const SwSortElement *pOrig, *pCmp;
 166
 167         const SwSortKey* pSrtKey = pOptions->aKeys[ nKey ];
 168         if( pSrtKey->eSortOrder == SRT_ASCENDING )
 169             pOrig = this, pCmp = &rCmp;
 170         else
 171             pOrig = &rCmp, pCmp = this;
 172
 173         if( pSrtKey->bIsNumeric )
 174         {
 175             double n1 = pOrig->GetValue( nKey );
 176             double n2 = pCmp->GetValue( nKey );
 177
 178             if( n1 == n2 )
 179                 continue;
 180
 181             return n1 < n2;
 182         }
 183         else
 184         {
 185             if( !pLastAlgorithm || *pLastAlgorithm != pSrtKey->sSortType )
 186             {
 187                 if( pLastAlgorithm )
 188                     *pLastAlgorithm = pSrtKey->sSortType;
 189                 else
 190                     pLastAlgorithm = new String( pSrtKey->sSortType );
 191                 pSortCollator->loadCollatorAlgorithm( *pLastAlgorithm,
 192                         *pLocale,
 193                         pOptions->bIgnoreCase ? SW_COLLATOR_IGNORES : 0 );
 194             }
 195
 196             sal_Int32 nCmp = pSortCollator->compareString(
 197                         pOrig->GetKey( nKey ), pCmp->GetKey( nKey ));
 198             if( 0 == nCmp )
 199                 continue;
 200
 201             return -1 == nCmp;
 202         }
 203     }
 204     return FALSE;
 205 }
 206
 207 double SwSortElement::GetValue( USHORT nKey ) const
 208 {
 209     return StrToDouble( GetKey( nKey ));
 210 }
 211
 212 /*--------------------------------------------------------------------
 213     Beschreibung: SortierElemente fuer Text
 214  --------------------------------------------------------------------*/
 215
 216
 217 SwSortTxtElement::SwSortTxtElement(const SwNodeIndex& rPos)
 218     : nOrg(rPos.GetIndex()), aPos(rPos)
 219 {
 220 }
 221
 222
 223 SwSortTxtElement::~SwSortTxtElement()
 224 {
 225 }
 226
 227
 228 /*--------------------------------------------------------------------
 229     Beschreibung: Key ermitteln
 230  --------------------------------------------------------------------*/
 231
 232
 233 String SwSortTxtElement::GetKey(USHORT nId) const
 234 {
 235     SwTxtNode* pTxtNd = aPos.GetNode().GetTxtNode();
 236     if( !pTxtNd )
 237         return aEmptyStr;
 238
 239     // fuer TextNodes
 240     const String& rStr = pTxtNd->GetTxt();
 241
 242     sal_Unicode nDeli = pOptions->cDeli;
 243     USHORT nDCount = pOptions->aKeys[nId]->nColumnId, i = 1;
 244     xub_StrLen nStart = 0;
 245
 246     // Den Delimitter suchen
 247     while( nStart != STRING_NOTFOUND && i < nDCount)
 248         if( STRING_NOTFOUND != ( nStart = rStr.Search( nDeli, nStart ) ) )
 249         {
 250             nStart++;
 251             i++;
 252         }
 253
 254     // naechsten Delimitter gefunden oder Ende des Strings und Kopieren
 255     xub_StrLen nEnd = rStr.Search( nDeli, nStart+1 );
 256     return rStr.Copy( nStart, nEnd-nStart );
 257 }
 258
 259
 260 /*--------------------------------------------------------------------
 261     Beschreibung: Sortier-Elemente fuer Tabellen
 262  --------------------------------------------------------------------*/
 263
 264 SwSortBoxElement::SwSortBoxElement( USHORT nRC )
 265     : nRow( nRC )
 266 {
 267 }
 268
 269
 270 SwSortBoxElement::~SwSortBoxElement()
 271 {
 272 }
 273
 274 /*--------------------------------------------------------------------
 275     Beschreibung: Schluessel zu einer Zelle ermitteln
 276  --------------------------------------------------------------------*/
 277
 278
 279 String SwSortBoxElement::GetKey(USHORT nKey) const
 280 {
 281     const _FndBox* pFndBox;
 282     USHORT nCol = pOptions->aKeys[nKey]->nColumnId-1;
 283
 284     if( SRT_ROWS == pOptions->eDirection )
 285         pFndBox = pBox->GetBox(nCol, nRow);                     // Zeilen sortieren
 286     else
 287         pFndBox = pBox->GetBox(nRow, nCol);                     // Spalten sortieren
 288
 289     // Den Text rausfieseln
 290     String aRetStr;
 291     if( pFndBox )
 292     {   // StartNode holen und ueberlesen
 293         const SwTableBox* pMyBox = pFndBox->GetBox();
 294         ASSERT(pMyBox, "Keine atomare Box");
 295
 296         if( pMyBox->GetSttNd() )
 297         {
 298             // ueber alle TextNodes der Box
 299             const SwNode *pNd = 0, *pEndNd = pMyBox->GetSttNd()->EndOfSectionNode();
 300             for( ULONG nIdx = pMyBox->GetSttIdx() + 1; pNd != pEndNd; ++nIdx )
 301                 if( ( pNd = pDoc->GetNodes()[ nIdx ])->IsTxtNode() )
 302                     aRetStr += ((SwTxtNode*)pNd)->GetTxt();
 303         }
 304     }
 305     return aRetStr;
 306 }
 307
 308 double SwSortBoxElement::GetValue( USHORT nKey ) const
 309 {
 310     const _FndBox* pFndBox;
 311     USHORT nCol = pOptions->aKeys[nKey]->nColumnId-1;
 312
 313     if( SRT_ROWS == pOptions->eDirection )
 314         pFndBox = pBox->GetBox(nCol, nRow);                     // Zeilen sortieren
 315     else
 316         pFndBox = pBox->GetBox(nRow, nCol);                     // Spalten sortieren
 317
 318     double nVal;
 319     if( pFndBox )
 320     {
 321         const SwFmt *pFmt = pFndBox->GetBox()->GetFrmFmt();
 322         if (pFmt->GetTblBoxNumFmt().GetValue() & NUMBERFORMAT_TEXT)
 323             nVal = SwSortElement::GetValue( nKey );
 324         else
 325             nVal = pFmt->GetTblBoxValue().GetValue();
 326     }
 327     else
 328         nVal = 0;
 329
 330     return nVal;
 331 }
 332
 333 /*--------------------------------------------------------------------
 334     Beschreibung: Text sortieren im Document
 335  --------------------------------------------------------------------*/
 336
 337
 338 BOOL SwDoc::SortText(const SwPaM& rPaM, const SwSortOptions& rOpt)
 339 {
 340     // pruefen ob Rahmen im Text
 341     const SwPosition *pStart = rPaM.Start(), *pEnd = rPaM.End();
 342     // Index auf den Start der Selektion
 343
 344     SwFrmFmt* pFmt;
 345     const SwFmtAnchor* pAnchor;
 346     const SwPosition* pAPos;
 347     USHORT n;
 348
 349     for( n = 0; n < GetSpzFrmFmts()->Count(); ++n )
 350     {
 351         pFmt = (SwFrmFmt*)(*GetSpzFrmFmts())[n];
 352         pAnchor = &pFmt->GetAnchor();
 353
 354         if( FLY_AT_CNTNT == pAnchor->GetAnchorId() &&
 355             0 != (pAPos = pAnchor->GetCntntAnchor() ) &&
 356             pStart->nNode <= pAPos->nNode && pAPos->nNode <= pEnd->nNode )
 357             return FALSE;
 358     }
 359
 360     // pruefe ob nur TextNodes in der Selection liegen
 361     {
 362         ULONG nStart = pStart->nNode.GetIndex(),
 363                         nEnd = pEnd->nNode.GetIndex();
 364         while( nStart <= nEnd )
 365             // Iterieren ueber einen selektierten Bereich
 366             if( !GetNodes()[ nStart++ ]->IsTxtNode() )
 367                 return FALSE;
 368     }
 369
 370     BOOL bUndo = DoesUndo();
 371     if( bUndo )
 372         StartUndo( UNDO_START, NULL );
 373
 374     SwPaM* pRedlPam = 0;
 375     SwUndoRedlineSort* pRedlUndo = 0;
 376     SwUndoSort* pUndoSort = 0;
 377
 378     if( IsRedlineOn() || (!IsIgnoreRedline() && pRedlineTbl->Count() ))
 379     {
 380         pRedlPam = new SwPaM( pStart->nNode, pEnd->nNode, -1, 1 );
 381         SwCntntNode* pCNd = pRedlPam->GetCntntNode( FALSE );
 382         if( pCNd )
 383             pRedlPam->GetMark()->nContent = pCNd->Len();
 384
 385         if( IsRedlineOn() && !IsShowOriginal( GetRedlineMode() ) )
 386         {
 387             if( bUndo )
 388             {
 389                 pRedlUndo = new SwUndoRedlineSort( rPaM, rOpt );
 390                 DoUndo( FALSE );
 391             }
 392             // erst den Bereich kopieren, dann
 393             SwNodeIndex aEndIdx( pEnd->nNode, 1 );
 394             SwNodeRange aRg( pStart->nNode, aEndIdx );
 395             GetNodes()._Copy( aRg, aEndIdx );
 396
 397             // Bereich neu ist von pEnd->nNode+1 bis aEndIdx
 398             DeleteRedline( *pRedlPam, true, USHRT_MAX );
 399
 400             pRedlPam->GetMark()->nNode.Assign( pEnd->nNode.GetNode(), 1 );
 401             pCNd = pRedlPam->GetCntntNode( FALSE );
 402             pRedlPam->GetMark()->nContent.Assign( pCNd, 0 );
 403
 404             pRedlPam->GetPoint()->nNode.Assign( aEndIdx.GetNode() );
 405             pCNd = pRedlPam->GetCntntNode( TRUE );
 406             xub_StrLen nCLen = 0;
 407             if( !pCNd &&
 408                 0 != (pCNd = GetNodes()[ aEndIdx.GetIndex()-1 ]->GetCntntNode()))
 409             {
 410                 nCLen = pCNd->Len();
 411                 pRedlPam->GetPoint()->nNode.Assign( *pCNd );
 412             }
 413             pRedlPam->GetPoint()->nContent.Assign( pCNd, nCLen );
 414
 415             if( pRedlUndo )
 416                 pRedlUndo->SetValues( rPaM );
 417         }
 418         else
 419         {
 420             DeleteRedline( *pRedlPam, true, USHRT_MAX );
 421             delete pRedlPam, pRedlPam = 0;
 422         }
 423     }
 424
 425     SwNodeIndex aStart(pStart->nNode);
 426     SwSortElement::Init( this, rOpt );
 427     SwSortElements aSortArr;
 428     while( aStart <= pEnd->nNode )
 429     {
 430         // Iterieren ueber einen selektierten Bereich
 431         SwSortTxtElement* pSE = new SwSortTxtElement( aStart );
 432         aSortArr.Insert(pSE);
 433         aStart++;
 434     }
 435
 436     // Und jetzt der Akt: Verschieben von Nodes und immer schoen auf UNDO
 437     // achten
 438     //
 439     ULONG nBeg = pStart->nNode.GetIndex();
 440     SwNodeRange aRg( aStart, aStart );
 441
 442     if( bUndo && !pRedlUndo )
 443         AppendUndo( pUndoSort = new SwUndoSort( rPaM, rOpt ) );
 444
 445     DoUndo( FALSE );
 446
 447     for( n = 0; n < aSortArr.Count(); ++n )
 448     {
 449         SwSortTxtElement* pBox = (SwSortTxtElement*)aSortArr[n];
 450         aStart          = nBeg + n;
 451         aRg.aStart      = pBox->aPos.GetIndex();
 452         aRg.aEnd        = aRg.aStart.GetIndex() + 1;
 453
 454         // Nodes verschieben
 455         MoveNodeRange( aRg, aStart,
 456             IDocumentContentOperations::DOC_MOVEDEFAULT );
 457
 458         // Undo Verschiebungen einpflegen
 459         if(pUndoSort)
 460             pUndoSort->Insert(pBox->nOrg, nBeg + n);
 461     }
 462     // Alle Elemente aus dem SortArray loeschen
 463     aSortArr.DeleteAndDestroy(0, aSortArr.Count());
 464     SwSortElement::Finit();
 465
 466     if( pRedlPam )
 467     {
 468         if( pRedlUndo )
 469         {
 470             pRedlUndo->SetSaveRange( *pRedlPam );
 471             AppendUndo( pRedlUndo );
 472         }
 473
 474         // nBeg ist der Start vom sortierten Bereich
 475         SwNodeIndex aSttIdx( GetNodes(), nBeg );
 476
 477         // der Kopierte Bereich ist das Geloeschte
 478         AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_DELETE, *pRedlPam ), true);
 479
 480         // das sortierte ist das Eingefuegte
 481         pRedlPam->GetPoint()->nNode = aSttIdx;
 482         SwCntntNode* pCNd = aSttIdx.GetNode().GetCntntNode();
 483         pRedlPam->GetPoint()->nContent.Assign( pCNd, 0 );
 484
 485         AppendRedline( new SwRedline( nsRedlineType_t::REDLINE_INSERT, *pRedlPam ), true);
 486
 487         if( pRedlUndo )
 488             pRedlUndo->SetOffset( aSttIdx );
 489
 490         delete pRedlPam, pRedlPam = 0;
 491     }
 492     DoUndo( bUndo );
 493     if( bUndo )
 494         EndUndo( UNDO_END, NULL );
 495
 496     return TRUE;
 497 }
 498
 499 /*--------------------------------------------------------------------
 500     Beschreibung: Tabelle sortieren im Document
 501  --------------------------------------------------------------------*/
 502
 503 BOOL SwDoc::SortTbl(const SwSelBoxes& rBoxes, const SwSortOptions& rOpt)
 504 {
 505     // uebers SwDoc fuer Undo !!
 506     ASSERT( rBoxes.Count(), "keine gueltige Box-Liste" );
 507     SwTableNode* pTblNd = (SwTableNode*)rBoxes[0]->GetSttNd()->FindTableNode();
 508     if( !pTblNd )
 509         return FALSE;
 510
 511     // Auf gehts sortieren
 512     // suche alle Boxen / Lines
 513     _FndBox aFndBox( 0, 0 );
 514     {
 515         _FndPara aPara( rBoxes, &aFndBox );
 516         pTblNd->GetTable().GetTabLines().ForEach( &_FndLineCopyCol, &aPara );;
 517     }
 518
 519     if(!aFndBox.GetLines().Count())
 520         return FALSE;
 521
 522     if( !IsIgnoreRedline() && GetRedlineTbl().Count() )
 523         DeleteRedline( *pTblNd, true, USHRT_MAX );
 524
 525     USHORT nStart = 0;
 526     if( pTblNd->GetTable().GetRowsToRepeat() > 0 && rOpt.eDirection == SRT_ROWS )
 527     {
 528         // Oberste seleketierte Zeile
 529         _FndLines& rLines = aFndBox.GetLines();
 530
 531         while( nStart < rLines.Count() )
 532         {
 533             // Verschachtelung durch Split Merge beachten,
 534             // die oberste rausholen
 535             SwTableLine* pLine = rLines[nStart]->GetLine();
 536             while ( pLine->GetUpper() )
 537                 pLine = pLine->GetUpper()->GetUpper();
 538
 539             if( pTblNd->GetTable().IsHeadline( *pLine ) )
 540                 nStart++;
 541             else
 542                 break;
 543         }
 544         // Alle selektierten in der HeaderLine ?  -> kein Offset
 545         if( nStart == rLines.Count() )
 546             nStart = 0;
 547     }
 548
 549     // umschalten auf relative Formeln
 550     SwTableFmlUpdate aMsgHnt( &pTblNd->GetTable() );
 551     aMsgHnt.eFlags = TBL_RELBOXNAME;
 552     UpdateTblFlds( &aMsgHnt );
 553
 554     // Tabelle als flache Array-Struktur
 555     FlatFndBox aFlatBox(this, aFndBox);
 556
 557     if(!aFlatBox.IsSymmetric())
 558         return FALSE;
 559
 560     // MIB 9.7.97: HTML-Layout loeschen
 561     pTblNd->GetTable().SetHTMLTableLayout( 0 );
 562
 563     // --> FME 2004-11-26 #i37739# A simple 'MakeFrms' after the node sorting
 564     // does not work if the table is inside a frame and has no prev/next.
 565     SwNode2Layout aNode2Layout( *pTblNd );
 566     // <--
 567
 568     // loesche die Frames der Tabelle
 569     pTblNd->DelFrms();
 570     // ? TL_CHART2: ?
 571
 572     // Redo loeschen bevor Undo
 573     BOOL bUndo = DoesUndo();
 574     SwUndoSort* pUndoSort = 0;
 575     if(bUndo)
 576     {
 577         ClearRedo();
 578         pUndoSort =     new SwUndoSort( rBoxes[0]->GetSttIdx(),
 579                                     rBoxes[rBoxes.Count()-1]->GetSttIdx(),
 580                                    *pTblNd, rOpt, aFlatBox.HasItemSets() );
 581         AppendUndo(pUndoSort);
 582         DoUndo(FALSE);
 583     }
 584
 585     // SchluesselElemente einsortieren
 586     USHORT nCount = (rOpt.eDirection == SRT_ROWS) ?
 587                     aFlatBox.GetRows() : aFlatBox.GetCols();
 588
 589     // SortList nach Schluessel sortieren
 590     SwSortElement::Init( this, rOpt, &aFlatBox );
 591     SwSortElements aSortList;
 592
 593     // wenn die HeaderLine wiederholt wird und die
 594     // Zeilen sortiert werden 1.Zeile nicht mitsortieren
 595     USHORT i;
 596
 597     for( i = nStart; i < nCount; ++i)
 598     {
 599         SwSortBoxElement* pEle = new SwSortBoxElement( i );
 600         aSortList.Insert(pEle);
 601     }
 602
 603     // nach Sortierung verschieben
 604     SwMovedBoxes aMovedList;
 605     for(i=0; i < aSortList.Count(); ++i)
 606     {
 607         SwSortBoxElement* pBox = (SwSortBoxElement*)aSortList[i];
 608         if(rOpt.eDirection == SRT_ROWS)
 609             MoveRow(this, aFlatBox, pBox->nRow, i + nStart, aMovedList, pUndoSort);
 610         else
 611             MoveCol(this, aFlatBox, pBox->nRow, i + nStart, aMovedList, pUndoSort);
 612     }
 613
 614     // Restore table frames:
 615     // --> FME 2004-11-26 #i37739# A simple 'MakeFrms' after the node sorting
 616     // does not work if the table is inside a frame and has no prev/next.
 617     const ULONG nIdx = pTblNd->GetIndex();
 618     aNode2Layout.RestoreUpperFrms( GetNodes(), nIdx, nIdx + 1 );
 619     // <--
 620
 621     // TL_CHART2: need to inform chart of probably changed cell names
 622     UpdateCharts( pTblNd->GetTable().GetFrmFmt()->GetName() );
 623
 624     // Alle Elemente aus dem SortArray loeschen
 625     aSortList.DeleteAndDestroy( 0, aSortList.Count() );
 626     SwSortElement::Finit();
 627
 628     // Undo wieder aktivieren
 629     DoUndo(bUndo);
 630
 631     SetModified();
 632     return TRUE;
 633 }
 634
 635 /*--------------------------------------------------------------------
 636     Beschreibung: Zeilenweise verschieben
 637  --------------------------------------------------------------------*/
 638
 639
 640 void MoveRow(SwDoc* pDoc, const FlatFndBox& rBox, USHORT nS, USHORT nT,
 641              SwMovedBoxes& rMovedList, SwUndoSort* pUD)
 642 {
 643     for( USHORT i=0; i < rBox.GetCols(); ++i )
 644     {   // Alte Zellen-Pos bestimmen und merken
 645         const _FndBox* pSource = rBox.GetBox(i, nS);
 646
 647         // neue Zellen-Pos
 648         const _FndBox* pTarget = rBox.GetBox(i, nT);
 649
 650         const SwTableBox* pT = pTarget->GetBox();
 651         const SwTableBox* pS = pSource->GetBox();
 652
 653         BOOL bMoved = rMovedList.GetPos(pT) != USHRT_MAX;
 654
 655         // und verschieben
 656         MoveCell(pDoc, pS, pT, bMoved, pUD);
 657
 658         rMovedList.Insert(pS, rMovedList.Count() );
 659
 660         if( pS != pT )
 661         {
 662             SwFrmFmt* pTFmt = (SwFrmFmt*)pT->GetFrmFmt();
 663             const SfxItemSet* pSSet = rBox.GetItemSet( i, nS );
 664
 665             if( pSSet ||
 666                 SFX_ITEM_SET == pTFmt->GetItemState( RES_BOXATR_FORMAT ) ||
 667                 SFX_ITEM_SET == pTFmt->GetItemState( RES_BOXATR_FORMULA ) ||
 668                 SFX_ITEM_SET == pTFmt->GetItemState( RES_BOXATR_VALUE ) )
 669             {
 670                 pTFmt = ((SwTableBox*)pT)->ClaimFrmFmt();
 671                 pTFmt->LockModify();
 672                 if( pTFmt->ResetFmtAttr( RES_BOXATR_FORMAT, RES_BOXATR_VALUE ) )
 673                     pTFmt->ResetFmtAttr( RES_VERT_ORIENT );
 674
 675                 if( pSSet )
 676                     pTFmt->SetFmtAttr( *pSSet );
 677                 pTFmt->UnlockModify();
 678             }
 679         }
 680     }
 681 }
 682
 683 /*--------------------------------------------------------------------
 684     Beschreibung: Spaltenweise verschieben
 685  --------------------------------------------------------------------*/
 686
 687
 688 void MoveCol(SwDoc* pDoc, const FlatFndBox& rBox, USHORT nS, USHORT nT,
 689              SwMovedBoxes& rMovedList, SwUndoSort* pUD)
 690 {
 691     for(USHORT i=0; i < rBox.GetRows(); ++i)
 692     {   // Alte Zellen-Pos bestimmen und merken
 693         const _FndBox* pSource = rBox.GetBox(nS, i);
 694
 695         // neue Zellen-Pos
 696         const _FndBox* pTarget = rBox.GetBox(nT, i);
 697
 698         // und verschieben
 699         const SwTableBox* pT = pTarget->GetBox();
 700         const SwTableBox* pS = pSource->GetBox();
 701
 702         // und verschieben
 703         BOOL bMoved = rMovedList.GetPos(pT) != USHRT_MAX;
 704         MoveCell(pDoc, pS, pT, bMoved, pUD);
 705
 706         rMovedList.Insert(pS, rMovedList.Count() );
 707
 708         if( pS != pT )
 709         {
 710             SwFrmFmt* pTFmt = (SwFrmFmt*)pT->GetFrmFmt();
 711             const SfxItemSet* pSSet = rBox.GetItemSet( nS, i );
 712
 713             if( pSSet ||
 714                 SFX_ITEM_SET == pTFmt->GetItemState( RES_BOXATR_FORMAT ) ||
 715                 SFX_ITEM_SET == pTFmt->GetItemState( RES_BOXATR_FORMULA ) ||
 716                 SFX_ITEM_SET == pTFmt->GetItemState( RES_BOXATR_VALUE ) )
 717             {
 718                 pTFmt = ((SwTableBox*)pT)->ClaimFrmFmt();
 719                 pTFmt->LockModify();
 720                 if( pTFmt->ResetFmtAttr( RES_BOXATR_FORMAT, RES_BOXATR_VALUE ) )
 721                     pTFmt->ResetFmtAttr( RES_VERT_ORIENT );
 722
 723                 if( pSSet )
 724                     pTFmt->SetFmtAttr( *pSSet );
 725                 pTFmt->UnlockModify();
 726             }
 727         }
 728     }
 729 }
 730
 731 /*--------------------------------------------------------------------
 732     Beschreibung: Eine einzelne Zelle verschieben
 733  --------------------------------------------------------------------*/
 734
 735
 736 void MoveCell(SwDoc* pDoc, const SwTableBox* pSource, const SwTableBox* pTar,
 737               BOOL bMovedBefore, SwUndoSort* pUD)
 738 {
 739     ASSERT(pSource && pTar,"Fehlende Quelle oder Ziel");
 740
 741     if(pSource == pTar)
 742         return;
 743
 744     if(pUD)
 745         pUD->Insert( pSource->GetName(), pTar->GetName() );
 746
 747     // Pam Quelle auf den ersten ContentNode setzen
 748     SwNodeRange aRg( *pSource->GetSttNd(), 0, *pSource->GetSttNd() );
 749     SwNode* pNd = pDoc->GetNodes().GoNext( &aRg.aStart );
 750
 751     // wurde die Zelle (Source) nicht verschoben
 752     // -> einen Leer-Node einfuegen und den Rest verschieben
 753     // ansonsten steht der Mark auf dem ersten Content-Node
 754     if( pNd->StartOfSectionNode() == pSource->GetSttNd() )
 755         pNd = pDoc->GetNodes().MakeTxtNode( aRg.aStart,
 756                 (SwTxtFmtColl*)pDoc->GetDfltTxtFmtColl() );
 757     aRg.aEnd = *pNd->EndOfSectionNode();
 758
 759     // Ist das Ziel leer(1 leerer Node vorhanden)
 760     // -> diesen loeschen und move
 761     // Ziel
 762     SwNodeIndex aTar( *pTar->GetSttNd() );
 763     pNd = pDoc->GetNodes().GoNext( &aTar );     // naechsten ContentNode
 764     ULONG nCount = pNd->EndOfSectionIndex() - pNd->StartOfSectionIndex();
 765
 766     BOOL bDelFirst = FALSE;
 767     if( nCount == 2 )
 768     {
 769         ASSERT( pNd->GetCntntNode(), "Kein ContentNode");
 770         bDelFirst = !pNd->GetCntntNode()->Len() && bMovedBefore;
 771     }
 772
 773     if(!bDelFirst)
 774     {   // Es besteht schon Inhalt -> alter I n h a l t  Section Down
 775         SwNodeRange aRgTar( aTar.GetNode(), 0, *pNd->EndOfSectionNode() );
 776         pDoc->GetNodes().SectionDown( &aRgTar );
 777     }
 778
 779     // Einfuegen der Source
 780     SwNodeIndex aIns( *pTar->GetSttNd()->EndOfSectionNode() );
 781     pDoc->MoveNodeRange( aRg, aIns,
 782         IDocumentContentOperations::DOC_MOVEDEFAULT );
 783
 784     // Falls erster Node leer -> weg damit
 785     if(bDelFirst)
 786         pDoc->GetNodes().Delete( aTar, 1 );
 787 }
 788
 789 /*--------------------------------------------------------------------
 790     Beschreibung: Zweidimensionales Array aus FndBoxes generieren
 791  --------------------------------------------------------------------*/
 792
 793
 794 FlatFndBox::FlatFndBox(SwDoc* pDocPtr, const _FndBox& rBox) :
 795     pDoc(pDocPtr),
 796     rBoxRef(rBox),
 797     pArr(0),
 798     ppItemSets(0),
 799     nRow(0),
 800     nCol(0)
 801 { // Ist das Array symmetrisch
 802     if((bSym = CheckLineSymmetry(rBoxRef)) != 0)
 803     {
 804         // Spalten/Reihen-Anzahl ermitteln
 805         nCols = GetColCount(rBoxRef);
 806         nRows = GetRowCount(rBoxRef);
 807
 808         // lineares Array anlegen
 809         pArr = new _FndBoxPtr[ nRows * nCols ];
 810         _FndBox** ppTmp = (_FndBox**)pArr;
 811         memset( ppTmp, 0, sizeof(_FndBoxPtr) * nRows * nCols );
 812
 813
 814         FillFlat( rBoxRef );
 815     }
 816 }
 817
 818
 819 FlatFndBox::~FlatFndBox()
 820 {
 821     _FndBox** ppTmp = (_FndBox**)pArr;
 822     delete [] ppTmp;
 823
 824     if( ppItemSets )
 825         delete [] ppItemSets;
 826 }
 827
 828 /*--------------------------------------------------------------------
 829     Beschreibung:       Alle Lines einer Box muessen gleichviel Boxen haben
 830  --------------------------------------------------------------------*/
 831
 832
 833 BOOL FlatFndBox::CheckLineSymmetry(const _FndBox& rBox)
 834 {
 835     const _FndLines &rLines = rBox.GetLines();
 836     USHORT nBoxes(0);
 837
 838     // UeberLines iterieren
 839     for(USHORT i=0; i < rLines.Count(); ++i)
 840     {   // Die Boxen einer Line
 841         _FndLine* pLn = rLines[i];
 842         const _FndBoxes& rBoxes = pLn->GetBoxes();
 843
 844         // Anzahl der Boxen aller Lines ungleich -> keine Symmetrie
 845         if( i  && nBoxes != rBoxes.Count())
 846             return FALSE;
 847
 848         nBoxes = rBoxes.Count();
 849         if( !CheckBoxSymmetry( *pLn ) )
 850             return FALSE;
 851     }
 852     return TRUE;
 853 }
 854
 855 /*--------------------------------------------------------------------
 856     Beschreibung:       Box auf Symmetrie pruefen
 857                     Alle Boxen einer Line muessen gleichviele Lines haben
 858  --------------------------------------------------------------------*/
 859
 860
 861 BOOL FlatFndBox::CheckBoxSymmetry(const _FndLine& rLn)
 862 {
 863     const _FndBoxes &rBoxes = rLn.GetBoxes();
 864     USHORT nLines(0);
 865
 866     // Ueber Boxes iterieren
 867     for(USHORT i=0; i < rBoxes.Count(); ++i)
 868     {   // Die Boxen einer Line
 869         _FndBox* pBox = rBoxes[i];
 870         const _FndLines& rLines = pBox->GetLines();
 871
 872         // Anzahl der Boxen aller Lines ungleich -> keine Symmetrie
 873         if( i && nLines != rLines.Count() )
 874             return FALSE;
 875
 876         nLines = rLines.Count();
 877         if( nLines && !CheckLineSymmetry( *pBox ) )
 878             return FALSE;
 879     }
 880     return TRUE;
 881 }
 882
 883 /*--------------------------------------------------------------------
 884     Beschreibung: max Anzahl der Spalten (Boxes)
 885  --------------------------------------------------------------------*/
 886
 887
 888 USHORT FlatFndBox::GetColCount(const _FndBox& rBox)
 889 {
 890     const _FndLines& rLines = rBox.GetLines();
 891     // Ueber Lines iterieren
 892     if( !rLines.Count() )
 893         return 1;
 894
 895     USHORT nSum = 0;
 896     for( USHORT i=0; i < rLines.Count(); ++i )
 897     {
 898         // Die Boxen einer Line
 899         USHORT nCount = 0;
 900         const _FndBoxes& rBoxes = rLines[i]->GetBoxes();
 901         for( USHORT j=0; j < rBoxes.Count(); ++j )
 902                 //      Rekursiv wirder ueber die Lines Iterieren
 903             nCount += rBoxes[j]->GetLines().Count()
 904                         ? GetColCount(*rBoxes[j]) : 1;
 905
 906         if( nSum < nCount )
 907             nSum = nCount;
 908     }
 909     return nSum;
 910 }
 911
 912 /*--------------------------------------------------------------------
 913     Beschreibung: max Anzahl der Zeilen (Lines)
 914  --------------------------------------------------------------------*/
 915
 916
 917 USHORT FlatFndBox::GetRowCount(const _FndBox& rBox)
 918 {
 919     const _FndLines& rLines = rBox.GetLines();
 920     if( !rLines.Count() )
 921         return 1;
 922
 923     USHORT nLines = 0;
 924     for(USHORT i=0; i < rLines.Count(); ++i)
 925     {   // Die Boxen einer Line
 926         const _FndBoxes& rBoxes = rLines[i]->GetBoxes();
 927         USHORT nLn = 1;
 928         for(USHORT j=0; j < rBoxes.Count(); ++j)
 929             if( rBoxes[j]->GetLines().Count() )
 930                 //      Rekursiv ueber die Lines Iterieren
 931                 nLn = Max(GetRowCount(*rBoxes[j]), nLn);
 932
 933         nLines = nLines + nLn;
 934     }
 935     return nLines;
 936 }
 937
 938 /*--------------------------------------------------------------------
 939     Beschreibung: lineares Array aus atomaren FndBoxes erzeugen
 940  --------------------------------------------------------------------*/
 941
 942
 943 void FlatFndBox::FillFlat(const _FndBox& rBox, BOOL bLastBox)
 944 {
 945     BOOL bModRow = FALSE;
 946     const _FndLines& rLines = rBox.GetLines();
 947
 948     // Ueber Lines iterieren
 949     USHORT nOldRow = nRow;
 950     for( USHORT i=0; i < rLines.Count(); ++i )
 951     {
 952         // Die Boxen einer Line
 953         const _FndBoxes& rBoxes = rLines[i]->GetBoxes();
 954         USHORT nOldCol = nCol;
 955         for( USHORT j = 0; j < rBoxes.Count(); ++j )
 956         {
 957             // Die Box pruefen ob es eine atomare Box ist
 958             const _FndBox*       pBox   = rBoxes[ j ];
 959
 960             if( !pBox->GetLines().Count() )
 961             {
 962                 // peichern
 963                 USHORT nOff = nRow * nCols + nCol;
 964                 *(pArr + nOff) = pBox;
 965
 966                 // sicher die Formel/Format/Value Werte
 967                 const SwFrmFmt* pFmt = pBox->GetBox()->GetFrmFmt();
 968                 if( SFX_ITEM_SET == pFmt->GetItemState( RES_BOXATR_FORMAT ) ||
 969                     SFX_ITEM_SET == pFmt->GetItemState( RES_BOXATR_FORMULA ) ||
 970                     SFX_ITEM_SET == pFmt->GetItemState( RES_BOXATR_VALUE ) )
 971                 {
 972                     SfxItemSet* pSet = new SfxItemSet( pDoc->GetAttrPool(),
 973                                     RES_BOXATR_FORMAT, RES_BOXATR_VALUE,
 974                                     RES_VERT_ORIENT, RES_VERT_ORIENT, 0 );
 975                     pSet->Put( pFmt->GetAttrSet() );
 976                     if( !ppItemSets )
 977                     {
 978                         ppItemSets = new SfxItemSet*[ nRows * nCols ];
 979                         memset( ppItemSets, 0, sizeof(SfxItemSet*) * nRows * nCols );
 980                     }
 981                     *(ppItemSets + nOff ) = pSet;
 982                 }
 983
 984                 bModRow = TRUE;
 985             }
 986             else
 987             {
 988                 // Rekursiv wieder ueber die Lines einer Box Iterieren
 989                 FillFlat( *pBox, ( j == rBoxes.Count()-1 ) );
 990             }
 991             nCol++;
 992         }
 993         if(bModRow)
 994             nRow++;
 995         nCol = nOldCol;
 996     }
 997     if(!bLastBox)
 998         nRow = nOldRow;
 999 }
1000
1001 /*--------------------------------------------------------------------
1002     Beschreibung: Zugriff auf eine bestimmte Zelle
1003  --------------------------------------------------------------------*/
1004
1005
1006 const _FndBox* FlatFndBox::GetBox(USHORT n_Col, USHORT n_Row) const
1007 {
1008     USHORT nOff = n_Row * nCols + n_Col;
1009     const _FndBox* pTmp = *(pArr + nOff);
1010
1011     ASSERT(n_Col < nCols && n_Row < nRows && pTmp, "unzulaessiger Array-Zugriff");
1012     return pTmp;
1013 }
1014
1015 const SfxItemSet* FlatFndBox::GetItemSet(USHORT n_Col, USHORT n_Row) const
1016 {
1017     ASSERT( !ppItemSets || ( n_Col < nCols && n_Row < nRows), "unzulaessiger Array-Zugriff");
1018
1019     return ppItemSets ? *(ppItemSets + (n_Row * nCols + n_Col )) : 0;
1020 }
1021
1022