sw/source/core/edit/edglbldc.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: edglbldc.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
  34
  35 #include <doc.hxx>
  36 #include <editsh.hxx>
  37 #include <pam.hxx>
  38 #include <ndtxt.hxx>
  39 #include <docary.hxx>
  40 #include <swwait.hxx>
  41 #include <swundo.hxx>           // fuer die UndoIds
  42 #include <section.hxx>
  43 #include <doctxm.hxx>
  44 #include <edglbldc.hxx>
  45
  46
  47 SV_IMPL_OP_PTRARR_SORT( SwGlblDocContents, SwGlblDocContentPtr )
  48
  49 BOOL SwEditShell::IsGlobalDoc() const
  50 {
  51     return getIDocumentSettingAccess()->get(IDocumentSettingAccess::GLOBAL_DOCUMENT);
  52 }
  53
  54 void SwEditShell::SetGlblDocSaveLinks( BOOL bFlag )
  55 {
  56     getIDocumentSettingAccess()->set(IDocumentSettingAccess::GLOBAL_DOCUMENT_SAVE_LINKS, bFlag);
  57     if( !GetDoc()->IsModified() )       // Bug 57028
  58         GetDoc()->SetUndoNoResetModified();
  59     GetDoc()->SetModified();
  60 }
  61
  62 BOOL SwEditShell::IsGlblDocSaveLinks() const
  63 {
  64     return getIDocumentSettingAccess()->get(IDocumentSettingAccess::GLOBAL_DOCUMENT_SAVE_LINKS);
  65 }
  66
  67 USHORT SwEditShell::GetGlobalDocContent( SwGlblDocContents& rArr ) const
  68 {
  69     if( rArr.Count() )
  70         rArr.DeleteAndDestroy( 0, rArr.Count() );
  71
  72     if( !getIDocumentSettingAccess()->get(IDocumentSettingAccess::GLOBAL_DOCUMENT) )
  73         return 0;
  74
  75     // dann alle gelinkten Bereiche auf der obersten Ebene
  76     SwDoc* pMyDoc = GetDoc();
  77     const SwSectionFmts& rSectFmts = pMyDoc->GetSections();
  78     USHORT n;
  79
  80     for( n = rSectFmts.Count(); n; )
  81     {
  82         const SwSection* pSect = rSectFmts[ --n ]->GetGlobalDocSection();
  83         if( pSect )
  84         {
  85             SwGlblDocContentPtr pNew;
  86             switch( pSect->GetType() )
  87             {
  88             case TOX_HEADER_SECTION:    break;          // ignore
  89             case TOX_CONTENT_SECTION:
  90                 ASSERT( pSect->ISA( SwTOXBaseSection ), "keine TOXBaseSection!" );
  91                 pNew = new SwGlblDocContent( (SwTOXBaseSection*)pSect );
  92                 break;
  93
  94             default:
  95                 pNew = new SwGlblDocContent( pSect );
  96                 break;
  97             }
  98             if( !rArr.Insert( pNew ) )
  99                 delete pNew;
 100         }
 101     }
 102
 103     // und als letztes die Dummies (sonstiger Text) einfuegen
 104     SwNode* pNd;
 105     ULONG nSttIdx = pMyDoc->GetNodes().GetEndOfExtras().GetIndex() + 2;
 106     for( n = 0; n < rArr.Count(); ++n )
 107     {
 108         const SwGlblDocContent& rNew = *rArr[ n ];
 109         // suche von StartPos bis rNew.DocPos nach einem Content Node.
 110         // Existiert dieser, so muss ein DummyEintrag eingefuegt werden.
 111         for( ; nSttIdx < rNew.GetDocPos(); ++nSttIdx )
 112             if( ( pNd = pMyDoc->GetNodes()[ nSttIdx ])->IsCntntNode()
 113                 || pNd->IsSectionNode() || pNd->IsTableNode() )
 114             {
 115                 SwGlblDocContentPtr pNew = new SwGlblDocContent( nSttIdx );
 116                 if( !rArr.Insert( pNew ) )
 117                     delete pNew;
 118                 else
 119                     ++n;                // auf die naechste Position
 120                 break;
 121             }
 122
 123         // StartPosition aufs Ende setzen
 124         nSttIdx = pMyDoc->GetNodes()[ rNew.GetDocPos() ]->EndOfSectionIndex();
 125         ++nSttIdx;
 126     }
 127
 128     // sollte man das Ende auch noch setzen??
 129     if( rArr.Count() )
 130     {
 131         ULONG nNdEnd = pMyDoc->GetNodes().GetEndOfContent().GetIndex();
 132         for( ; nSttIdx < nNdEnd; ++nSttIdx )
 133             if( ( pNd = pMyDoc->GetNodes()[ nSttIdx ])->IsCntntNode()
 134                 || pNd->IsSectionNode() || pNd->IsTableNode() )
 135             {
 136                 SwGlblDocContentPtr pNew = new SwGlblDocContent( nSttIdx );
 137                 if( !rArr.Insert( pNew ) )
 138                     delete pNew;
 139                 break;
 140             }
 141     }
 142     else
 143     {
 144         SwGlblDocContentPtr pNew = new SwGlblDocContent(
 145                     pMyDoc->GetNodes().GetEndOfExtras().GetIndex() + 2 );
 146         rArr.Insert( pNew );
 147     }
 148     return rArr.Count();
 149 }
 150
 151 BOOL SwEditShell::InsertGlobalDocContent( const SwGlblDocContent& rInsPos,
 152                                             const SwSection& rNew )
 153 {
 154     if( !getIDocumentSettingAccess()->get(IDocumentSettingAccess::GLOBAL_DOCUMENT) )
 155         return FALSE;
 156
 157     SET_CURR_SHELL( this );
 158     StartAllAction();
 159
 160     SwPaM* pCrsr = GetCrsr();
 161     if( pCrsr->GetNext() != pCrsr || IsTableMode() )
 162         ClearMark();
 163
 164     SwPosition& rPos = *pCrsr->GetPoint();
 165     rPos.nNode = rInsPos.GetDocPos();
 166
 167     BOOL bEndUndo = FALSE;
 168     SwDoc* pMyDoc = GetDoc();
 169     SwTxtNode* pTxtNd = pMyDoc->GetNodes()[ rPos.nNode ]->GetTxtNode();
 170     if( pTxtNd )
 171         rPos.nContent.Assign( pTxtNd, 0 );
 172     else
 173     {
 174         bEndUndo = TRUE;
 175         pMyDoc->StartUndo( UNDO_START, NULL );
 176         rPos.nNode--;
 177         pMyDoc->AppendTxtNode( rPos );
 178         pCrsr->SetMark();
 179     }
 180
 181     InsertSection( rNew );
 182
 183     if( bEndUndo )
 184         pMyDoc->EndUndo( UNDO_END, NULL );
 185     EndAllAction();
 186
 187     return TRUE;
 188 }
 189
 190 BOOL SwEditShell::InsertGlobalDocContent( const SwGlblDocContent& rInsPos,
 191                                             const SwTOXBase& rTOX )
 192 {
 193     if( !getIDocumentSettingAccess()->get(IDocumentSettingAccess::GLOBAL_DOCUMENT) )
 194         return FALSE;
 195
 196     SET_CURR_SHELL( this );
 197     StartAllAction();
 198
 199     SwPaM* pCrsr = GetCrsr();
 200     if( pCrsr->GetNext() != pCrsr || IsTableMode() )
 201         ClearMark();
 202
 203     SwPosition& rPos = *pCrsr->GetPoint();
 204     rPos.nNode = rInsPos.GetDocPos();
 205
 206     BOOL bEndUndo = FALSE;
 207     SwDoc* pMyDoc = GetDoc();
 208     SwTxtNode* pTxtNd = rPos.nNode.GetNode().GetTxtNode();
 209     if( pTxtNd && pTxtNd->GetTxt().Len() && rPos.nNode.GetIndex() + 1 !=
 210         pMyDoc->GetNodes().GetEndOfContent().GetIndex() )
 211         rPos.nContent.Assign( pTxtNd, 0 );
 212     else
 213     {
 214         bEndUndo = TRUE;
 215         pMyDoc->StartUndo( UNDO_START, NULL );
 216         rPos.nNode--;
 217         pMyDoc->AppendTxtNode( rPos );
 218     }
 219
 220     InsertTableOf( rTOX );
 221
 222     if( bEndUndo )
 223         pMyDoc->EndUndo( UNDO_END, NULL );
 224     EndAllAction();
 225
 226     return TRUE;
 227 }
 228
 229 BOOL SwEditShell::InsertGlobalDocContent( const SwGlblDocContent& rInsPos )
 230 {
 231     if( !getIDocumentSettingAccess()->get(IDocumentSettingAccess::GLOBAL_DOCUMENT) )
 232         return FALSE;
 233
 234     SET_CURR_SHELL( this );
 235     StartAllAction();
 236
 237     SwPaM* pCrsr = GetCrsr();
 238     if( pCrsr->GetNext() != pCrsr || IsTableMode() )
 239         ClearMark();
 240
 241     SwPosition& rPos = *pCrsr->GetPoint();
 242     rPos.nNode = rInsPos.GetDocPos() - 1;
 243     rPos.nContent.Assign( 0, 0 );
 244
 245     SwDoc* pMyDoc = GetDoc();
 246     pMyDoc->AppendTxtNode( rPos );
 247     EndAllAction();
 248     return TRUE;
 249 }
 250
 251 BOOL SwEditShell::DeleteGlobalDocContent( const SwGlblDocContents& rArr ,
 252                                             USHORT nDelPos )
 253 {
 254     if( !getIDocumentSettingAccess()->get(IDocumentSettingAccess::GLOBAL_DOCUMENT) )
 255         return FALSE;
 256
 257     SET_CURR_SHELL( this );
 258     StartAllAction();
 259     StartUndo( UNDO_START );
 260
 261     SwPaM* pCrsr = GetCrsr();
 262     if( pCrsr->GetNext() != pCrsr || IsTableMode() )
 263         ClearMark();
 264
 265     SwPosition& rPos = *pCrsr->GetPoint();
 266
 267     SwDoc* pMyDoc = GetDoc();
 268     const SwGlblDocContent& rDelPos = *rArr[ nDelPos ];
 269     ULONG nDelIdx = rDelPos.GetDocPos();
 270     if( 1 == rArr.Count() )
 271     {
 272         // ein Node muss aber da bleiben!
 273         rPos.nNode = nDelIdx - 1;
 274         rPos.nContent.Assign( 0, 0 );
 275
 276         pMyDoc->AppendTxtNode( rPos );
 277         ++nDelIdx;
 278     }
 279
 280     switch( rDelPos.GetType() )
 281     {
 282     case GLBLDOC_UNKNOWN:
 283         {
 284             rPos.nNode = nDelIdx;
 285             pCrsr->SetMark();
 286             if( ++nDelPos < rArr.Count() )
 287                 rPos.nNode = rArr[ nDelPos ]->GetDocPos();
 288             else
 289                 rPos.nNode = pMyDoc->GetNodes().GetEndOfContent();
 290             rPos.nNode--;
 291             if( !pMyDoc->DelFullPara( *pCrsr ) )
 292                 Delete();
 293         }
 294         break;
 295
 296     case GLBLDOC_TOXBASE:
 297         {
 298             SwTOXBaseSection* pTOX = (SwTOXBaseSection*)rDelPos.GetTOX();
 299             pMyDoc->DeleteTOX( *pTOX, TRUE );
 300         }
 301         break;
 302
 303     case GLBLDOC_SECTION:
 304         {
 305             SwSectionFmt* pSectFmt = (SwSectionFmt*)rDelPos.GetSection()->GetFmt();
 306             pMyDoc->DelSectionFmt( pSectFmt, TRUE );
 307         }
 308         break;
 309     }
 310
 311     EndUndo( UNDO_END );
 312     EndAllAction();
 313     return TRUE;
 314 }
 315
 316 BOOL SwEditShell::MoveGlobalDocContent( const SwGlblDocContents& rArr ,
 317                                         USHORT nFromPos, USHORT nToPos,
 318                                         USHORT nInsPos )
 319 {
 320     if( !getIDocumentSettingAccess()->get(IDocumentSettingAccess::GLOBAL_DOCUMENT) ||
 321         nFromPos >= rArr.Count() || nToPos > rArr.Count() ||
 322         nInsPos > rArr.Count() || nFromPos >= nToPos ||
 323         ( nFromPos <= nInsPos && nInsPos <= nToPos ) )
 324         return FALSE;
 325
 326     SET_CURR_SHELL( this );
 327     StartAllAction();
 328
 329     SwPaM* pCrsr = GetCrsr();
 330     if( pCrsr->GetNext() != pCrsr || IsTableMode() )
 331         ClearMark();
 332
 333     SwDoc* pMyDoc = GetDoc();
 334     SwNodeRange aRg( pMyDoc->GetNodes(), rArr[ nFromPos ]->GetDocPos() );
 335     if( nToPos < rArr.Count() )
 336         aRg.aEnd = rArr[ nToPos ]->GetDocPos();
 337     else
 338         aRg.aEnd = pMyDoc->GetNodes().GetEndOfContent();
 339
 340     SwNodeIndex aInsPos( pMyDoc->GetNodes() );
 341     if( nInsPos < rArr.Count() )
 342         aInsPos = rArr[ nInsPos ]->GetDocPos();
 343     else
 344         aInsPos  = pMyDoc->GetNodes().GetEndOfContent();
 345
 346     bool bRet = pMyDoc->MoveNodeRange( aRg, aInsPos,
 347         static_cast<IDocumentContentOperations::SwMoveFlags>(
 348               IDocumentContentOperations::DOC_MOVEALLFLYS
 349             | IDocumentContentOperations::DOC_CREATEUNDOOBJ ));
 350
 351     EndAllAction();
 352     return bRet;
 353 }
 354
 355 BOOL SwEditShell::GotoGlobalDocContent( const SwGlblDocContent& rPos )
 356 {
 357     if( !getIDocumentSettingAccess()->get(IDocumentSettingAccess::GLOBAL_DOCUMENT) )
 358         return FALSE;
 359
 360     SET_CURR_SHELL( this );
 361     SttCrsrMove();
 362
 363     SwPaM* pCrsr = GetCrsr();
 364     if( pCrsr->GetNext() != pCrsr || IsTableMode() )
 365         ClearMark();
 366
 367     SwPosition& rCrsrPos = *pCrsr->GetPoint();
 368     rCrsrPos.nNode = rPos.GetDocPos();
 369
 370     SwDoc* pMyDoc = GetDoc();
 371     SwCntntNode* pCNd = pMyDoc->GetNodes()[ rCrsrPos.nNode ]->GetCntntNode();
 372     if( !pCNd )
 373         pCNd = pMyDoc->GetNodes().GoNext( &rCrsrPos.nNode );
 374
 375     rCrsrPos.nContent.Assign( pCNd, 0 );
 376
 377     EndCrsrMove();
 378     return TRUE;
 379 }
 380
 381 SwGlblDocContent::SwGlblDocContent( ULONG nPos )
 382 {
 383     eType = GLBLDOC_UNKNOWN;
 384     PTR.pTOX = 0;
 385     nDocPos = nPos;
 386 }
 387
 388 SwGlblDocContent::SwGlblDocContent( const SwTOXBaseSection* pTOX )
 389 {
 390     eType = GLBLDOC_TOXBASE;
 391     PTR.pTOX = pTOX;
 392
 393     const SwSectionNode* pSectNd = pTOX->GetFmt()->GetSectionNode();
 394     nDocPos = pSectNd ? pSectNd->GetIndex() : 0;
 395 }
 396
 397 SwGlblDocContent::SwGlblDocContent( const SwSection* pSect )
 398 {
 399     eType = GLBLDOC_SECTION;
 400     PTR.pSect = pSect;
 401
 402     const SwSectionNode* pSectNd = pSect->GetFmt()->GetSectionNode();
 403     nDocPos = pSectNd ? pSectNd->GetIndex() : 0;
 404 }
 405
 406
 407