sw/source/core/edit/edtab.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <fesh.hxx>
  21 #include <hintids.hxx>
  22 #include <hints.hxx>
  23
  24 #include <swwait.hxx>
  25 #include <editsh.hxx>
  26 #include <doc.hxx>
  27 #include <IDocumentUndoRedo.hxx>
  28 #include <IDocumentChartDataProviderAccess.hxx>
  29 #include <IDocumentFieldsAccess.hxx>
  30 #include <IDocumentState.hxx>
  31 #include <cntfrm.hxx>
  32 #include <pam.hxx>
  33 #include <ndtxt.hxx>
  34 #include <swtable.hxx>
  35 #include <swundo.hxx>
  36 #include <tblsel.hxx>
  37 #include <cellfrm.hxx>
  38 #include <cellatr.hxx>
  39 #include <swtblfmt.hxx>
  40 #include <swddetbl.hxx>
  41 #include <mdiexp.hxx>
  42 #include <itabenum.hxx>
  43 #include <vcl/uitest/logger.hxx>
  44 #include <vcl/uitest/eventdescription.hxx>
  45
  46 using namespace ::com::sun::star;
  47 using namespace ::com::sun::star::uno;
  48 namespace {
  49
  50 void collectUIInformation(const OUString& rAction, const OUString& aParameters)
  51 {
  52     EventDescription aDescription;
  53     aDescription.aAction = rAction;
  54     aDescription.aParameters = {{"parameters", aParameters}};
  55     aDescription.aID = "writer_edit";
  56     aDescription.aKeyWord = "SwEditWinUIObject";
  57     aDescription.aParent = "MainWindow";
  58     UITestLogger::getInstance().logEvent(aDescription);
  59 }
  60
  61 }
  62
  63 //Added for bug #i119954# Application crashed if undo/redo convert nest table to text
  64 static bool ConvertTableToText( const SwTableNode *pTableNode, sal_Unicode cCh );
  65
  66 static void    ConvertNestedTablesToText( const SwTableLines &rTableLines, sal_Unicode cCh )
  67 {
  68     for (size_t n = 0; n < rTableLines.size(); ++n)
  69     {
  70         SwTableLine* pTableLine = rTableLines[ n ];
  71         for (size_t i = 0; i < pTableLine->GetTabBoxes().size(); ++i)
  72         {
  73             SwTableBox* pTableBox = pTableLine->GetTabBoxes()[ i ];
  74             if (pTableBox->GetTabLines().empty())
  75             {
  76                 SwNodeIndex nodeIndex( *pTableBox->GetSttNd(), 1 );
  77                 SwNodeIndex endNodeIndex( *pTableBox->GetSttNd()->EndOfSectionNode() );
  78                 for( ; nodeIndex < endNodeIndex ; ++nodeIndex )
  79                 {
  80                     if ( SwTableNode* pTableNode = nodeIndex.GetNode().GetTableNode() )
  81                         ConvertTableToText( pTableNode, cCh );
  82                 }
  83             }
  84             else
  85             {
  86                 ConvertNestedTablesToText( pTableBox->GetTabLines(), cCh );
  87             }
  88         }
  89     }
  90 }
  91
  92 bool ConvertTableToText( const SwTableNode *pConstTableNode, sal_Unicode cCh )
  93 {
  94     SwTableNode *pTableNode = const_cast< SwTableNode* >( pConstTableNode );
  95     ConvertNestedTablesToText( pTableNode->GetTable().GetTabLines(), cCh );
  96     return pTableNode->GetDoc().TableToText( pTableNode, cCh );
  97 }
  98 //End for bug #i119954#
  99
 100 const SwTable& SwEditShell::InsertTable( const SwInsertTableOptions& rInsTableOpts,
 101                                          sal_uInt16 nRows, sal_uInt16 nCols,
 102                                          const SwTableAutoFormat* pTAFormat )
 103 {
 104     StartAllAction();
 105     SwPosition* pPos = GetCursor()->GetPoint();
 106
 107     bool bEndUndo = 0 != pPos->nContent.GetIndex();
 108     if( bEndUndo )
 109     {
 110         StartUndo( SwUndoId::START );
 111         GetDoc()->getIDocumentContentOperations().SplitNode( *pPos, false );
 112     }
 113
 114     // If called from a shell the adjust item is propagated
 115     // from pPos to the new content nodes in the table.
 116     const SwTable *pTable = GetDoc()->InsertTable( rInsTableOpts, *pPos,
 117                                                    nRows, nCols,
 118                                                    css::text::HoriOrientation::FULL, pTAFormat,
 119                                                    nullptr, true );
 120     if( bEndUndo )
 121         EndUndo( SwUndoId::END );
 122
 123     EndAllAction();
 124
 125     OUString parameter = " Columns : " + OUString::number( nCols ) + " , Rows : " + OUString::number( nRows ) + " ";
 126     collectUIInformation("CREATE_TABLE", parameter);
 127
 128     return *pTable;
 129 }
 130
 131 bool SwEditShell::TextToTable( const SwInsertTableOptions& rInsTableOpts,
 132                                sal_Unicode cCh,
 133                                const SwTableAutoFormat* pTAFormat )
 134 {
 135     SwWait aWait( *GetDoc()->GetDocShell(), true );
 136     bool bRet = false;
 137     StartAllAction();
 138     for(const SwPaM& rPaM : GetCursor()->GetRingContainer())
 139     {
 140         if( rPaM.HasMark() )
 141             bRet |= nullptr != GetDoc()->TextToTable( rInsTableOpts, rPaM, cCh,
 142                                                 css::text::HoriOrientation::FULL, pTAFormat );
 143     }
 144     EndAllAction();
 145     return bRet;
 146 }
 147
 148 bool SwEditShell::TableToText( sal_Unicode cCh )
 149 {
 150     SwWait aWait( *GetDoc()->GetDocShell(), true );
 151     SwPaM* pCursor = GetCursor();
 152     const SwTableNode* pTableNd =
 153             GetDoc()->IsIdxInTable( pCursor->GetPoint()->nNode );
 154     if (!pTableNd)
 155         return false;
 156
 157     if( IsTableMode() )
 158     {
 159         ClearMark();
 160         pCursor = GetCursor();
 161     }
 162     else if (pCursor->GetNext() != pCursor)
 163         return false;
 164
 165     // TL_CHART2:
 166     // tell the charts about the table to be deleted and have them use their own data
 167     GetDoc()->getIDocumentChartDataProviderAccess().CreateChartInternalDataProviders( &pTableNd->GetTable() );
 168
 169     StartAllAction();
 170
 171     // move current Cursor out of the listing area
 172     SwNodeIndex aTabIdx( *pTableNd );
 173     pCursor->DeleteMark();
 174     pCursor->GetPoint()->nNode = *pTableNd->EndOfSectionNode();
 175     pCursor->GetPoint()->nContent.Assign( nullptr, 0 );
 176     // move sPoint and Mark out of the area!
 177     pCursor->SetMark();
 178     pCursor->DeleteMark();
 179
 180     //Modified for bug #i119954# Application crashed if undo/redo convert nest table to text
 181     StartUndo();
 182     bool bRet = ConvertTableToText( pTableNd, cCh );
 183     EndUndo();
 184     //End  for bug #i119954#
 185     pCursor->GetPoint()->nNode = aTabIdx;
 186
 187     SwContentNode* pCNd = pCursor->GetContentNode();
 188     if( !pCNd )
 189         pCursor->Move( fnMoveForward, GoInContent );
 190     else
 191         pCursor->GetPoint()->nContent.Assign( pCNd, 0 );
 192
 193     EndAllAction();
 194     return bRet;
 195 }
 196
 197 bool SwEditShell::IsTextToTableAvailable() const
 198 {
 199     bool bOnlyText = false;
 200     for(SwPaM& rPaM : GetCursor()->GetRingContainer())
 201     {
 202         if( rPaM.HasMark() && *rPaM.GetPoint() != *rPaM.GetMark() )
 203         {
 204             bOnlyText = true;
 205
 206             // check if selection is in listing
 207             sal_uLong nStt = rPaM.GetMark()->nNode.GetIndex(),
 208                   nEnd = rPaM.GetPoint()->nNode.GetIndex();
 209             if( nStt > nEnd )   { sal_uLong n = nStt; nStt = nEnd; nEnd = n; }
 210
 211             for( ; nStt <= nEnd; ++nStt )
 212                 if( !GetDoc()->GetNodes()[ nStt ]->IsTextNode() )
 213                 {
 214                     bOnlyText = false;
 215                     break;
 216                 }
 217
 218             if( !bOnlyText )
 219                 break;
 220         }
 221     }
 222
 223     return bOnlyText;
 224 }
 225
 226 void SwEditShell::InsertDDETable( const SwInsertTableOptions& rInsTableOpts,
 227                                   SwDDEFieldType* pDDEType,
 228                                   sal_uInt16 nRows, sal_uInt16 nCols )
 229 {
 230     SwPosition* pPos = GetCursor()->GetPoint();
 231
 232     StartAllAction();
 233
 234     bool bEndUndo = 0 != pPos->nContent.GetIndex();
 235     if( bEndUndo )
 236     {
 237         StartUndo( SwUndoId::START );
 238         GetDoc()->getIDocumentContentOperations().SplitNode( *pPos, false );
 239     }
 240
 241     const SwInsertTableOptions aInsTableOpts( rInsTableOpts.mnInsMode | SwInsertTableFlags::DefaultBorder,
 242                                             rInsTableOpts.mnRowsToRepeat );
 243     SwTable* pTable = const_cast<SwTable*>(GetDoc()->InsertTable( aInsTableOpts, *pPos,
 244                                                      nRows, nCols, css::text::HoriOrientation::FULL ));
 245
 246     SwTableNode* pTableNode = const_cast<SwTableNode*>(pTable->GetTabSortBoxes()[ 0 ]->
 247                                                 GetSttNd()->FindTableNode());
 248     std::unique_ptr<SwDDETable> pDDETable(new SwDDETable( *pTable, pDDEType ));
 249     pTableNode->SetNewTable( std::move(pDDETable) );   // set the DDE table
 250
 251     if( bEndUndo )
 252         EndUndo( SwUndoId::END );
 253
 254     EndAllAction();
 255 }
 256
 257 /** update fields of a listing */
 258 void SwEditShell::UpdateTable()
 259 {
 260     const SwTableNode* pTableNd = IsCursorInTable();
 261
 262     if( pTableNd )
 263     {
 264         StartAllAction();
 265         if( DoesUndo() )
 266             StartUndo();
 267         EndAllTableBoxEdit();
 268         SwTableFormulaUpdate aTableUpdate( &pTableNd->GetTable() );
 269         GetDoc()->getIDocumentFieldsAccess().UpdateTableFields( &aTableUpdate );
 270         if( DoesUndo() )
 271             EndUndo();
 272         EndAllAction();
 273     }
 274 }
 275
 276 // get/set Change Mode
 277
 278 TableChgMode SwEditShell::GetTableChgMode() const
 279 {
 280     TableChgMode eMode;
 281     const SwTableNode* pTableNd = IsCursorInTable();
 282     if( pTableNd )
 283         eMode = pTableNd->GetTable().GetTableChgMode();
 284     else
 285         eMode = GetTableChgDefaultMode();
 286     return eMode;
 287 }
 288
 289 void SwEditShell::SetTableChgMode( TableChgMode eMode )
 290 {
 291     const SwTableNode* pTableNd = IsCursorInTable();
 292
 293     if( pTableNd )
 294     {
 295         const_cast<SwTable&>(pTableNd->GetTable()).SetTableChgMode( eMode );
 296         if( !GetDoc()->getIDocumentState().IsModified() )   // Bug 57028
 297         {
 298             GetDoc()->GetIDocumentUndoRedo().SetUndoNoResetModified();
 299         }
 300         GetDoc()->getIDocumentState().SetModified();
 301     }
 302 }
 303
 304 bool SwEditShell::GetTableBoxFormulaAttrs( SfxItemSet& rSet ) const
 305 {
 306     SwSelBoxes aBoxes;
 307     if( IsTableMode() )
 308         ::GetTableSelCrs( *this, aBoxes );
 309     else
 310     {
 311         do {
 312             SwFrame *pFrame = GetCurrFrame();
 313             do {
 314                 pFrame = pFrame->GetUpper();
 315             } while ( pFrame && !pFrame->IsCellFrame() );
 316             if ( pFrame )
 317             {
 318                 SwTableBox *pBox = const_cast<SwTableBox*>(static_cast<SwCellFrame*>(pFrame)->GetTabBox());
 319                 aBoxes.insert( pBox );
 320             }
 321         } while( false );
 322     }
 323
 324     for (size_t n = 0; n < aBoxes.size(); ++n)
 325     {
 326         const SwTableBox* pSelBox = aBoxes[ n ];
 327         const SwTableBoxFormat* pTableFormat = static_cast<SwTableBoxFormat*>(pSelBox->GetFrameFormat());
 328         if( !n )
 329         {
 330             // Convert formulae into external presentation
 331             const SwTable& rTable = pSelBox->GetSttNd()->FindTableNode()->GetTable();
 332
 333             SwTableFormulaUpdate aTableUpdate( &rTable );
 334             aTableUpdate.m_eFlags = TBL_BOXNAME;
 335             GetDoc()->getIDocumentFieldsAccess().UpdateTableFields( &aTableUpdate );
 336
 337             rSet.Put( pTableFormat->GetAttrSet() );
 338         }
 339         else
 340             rSet.MergeValues( pTableFormat->GetAttrSet() );
 341     }
 342     return 0 != rSet.Count();
 343 }
 344
 345 void SwEditShell::SetTableBoxFormulaAttrs( const SfxItemSet& rSet )
 346 {
 347     CurrShell aCurr( this );
 348     SwSelBoxes aBoxes;
 349     if( IsTableMode() )
 350         ::GetTableSelCrs( *this, aBoxes );
 351     else
 352     {
 353         do {
 354             SwFrame *pFrame = GetCurrFrame();
 355             do {
 356                 pFrame = pFrame->GetUpper();
 357             } while ( pFrame && !pFrame->IsCellFrame() );
 358             if ( pFrame )
 359             {
 360                 SwTableBox *pBox = const_cast<SwTableBox*>(static_cast<SwCellFrame*>(pFrame)->GetTabBox());
 361                 aBoxes.insert( pBox );
 362             }
 363         } while( false );
 364     }
 365
 366     // When setting a formula, do not check further!
 367     if( SfxItemState::SET == rSet.GetItemState( RES_BOXATR_FORMULA ))
 368         ClearTableBoxContent();
 369
 370     StartAllAction();
 371     GetDoc()->GetIDocumentUndoRedo().StartUndo( SwUndoId::START, nullptr );
 372     for (size_t n = 0; n < aBoxes.size(); ++n)
 373     {
 374         GetDoc()->SetTableBoxFormulaAttrs( *aBoxes[ n ], rSet );
 375     }
 376     GetDoc()->GetIDocumentUndoRedo().EndUndo( SwUndoId::END, nullptr );
 377     EndAllAction();
 378 }
 379
 380 bool SwEditShell::IsTableBoxTextFormat() const
 381 {
 382     if( IsTableMode() )
 383         return false;
 384
 385     const SwTableBox *pBox = nullptr;
 386     {
 387         SwFrame *pFrame = GetCurrFrame();
 388         do {
 389             pFrame = pFrame->GetUpper();
 390         } while ( pFrame && !pFrame->IsCellFrame() );
 391         if ( pFrame )
 392             pBox = static_cast<SwCellFrame*>(pFrame)->GetTabBox();
 393     }
 394
 395     if( !pBox )
 396         return false;
 397
 398     sal_uInt32 nFormat = 0;
 399     const SfxPoolItem* pItem;
 400     if( SfxItemState::SET == pBox->GetFrameFormat()->GetAttrSet().GetItemState(
 401         RES_BOXATR_FORMAT, true, &pItem ))
 402     {
 403         nFormat = static_cast<const SwTableBoxNumFormat*>(pItem)->GetValue();
 404         return GetDoc()->GetNumberFormatter()->IsTextFormat( nFormat );
 405     }
 406
 407     sal_uLong nNd = pBox->IsValidNumTextNd();
 408     if( ULONG_MAX == nNd )
 409         return true;
 410
 411     const OUString& rText = GetDoc()->GetNodes()[ nNd ]->GetTextNode()->GetText();
 412     if( rText.isEmpty() )
 413         return false;
 414
 415     double fVal;
 416     return !GetDoc()->IsNumberFormat( rText, nFormat, fVal );
 417 }
 418
 419 OUString SwEditShell::GetTableBoxText() const
 420 {
 421     OUString sRet;
 422     if( !IsTableMode() )
 423     {
 424         const SwTableBox *pBox = nullptr;
 425         {
 426             SwFrame *pFrame = GetCurrFrame();
 427             do {
 428                 pFrame = pFrame->GetUpper();
 429             } while ( pFrame && !pFrame->IsCellFrame() );
 430             if ( pFrame )
 431                 pBox = static_cast<SwCellFrame*>(pFrame)->GetTabBox();
 432         }
 433
 434         sal_uLong nNd;
 435         if( pBox && ULONG_MAX != ( nNd = pBox->IsValidNumTextNd() ) )
 436             sRet = GetDoc()->GetNodes()[ nNd ]->GetTextNode()->GetText();
 437     }
 438     return sRet;
 439 }
 440
 441 void SwEditShell::SplitTable( SplitTable_HeadlineOption eMode )
 442 {
 443     SwPaM *pCursor = GetCursor();
 444     if( pCursor->GetNode().FindTableNode() )
 445     {
 446         StartAllAction();
 447         GetDoc()->GetIDocumentUndoRedo().StartUndo(SwUndoId::EMPTY, nullptr);
 448
 449         GetDoc()->SplitTable( *pCursor->GetPoint(), eMode, true );
 450
 451         GetDoc()->GetIDocumentUndoRedo().EndUndo(SwUndoId::EMPTY, nullptr);
 452         ClearFEShellTabCols(*GetDoc(), nullptr);
 453         EndAllAction();
 454     }
 455 }
 456
 457 bool SwEditShell::MergeTable( bool bWithPrev )
 458 {
 459     bool bRet = false;
 460     SwPaM *pCursor = GetCursor();
 461     if( pCursor->GetNode().FindTableNode() )
 462     {
 463         StartAllAction();
 464         GetDoc()->GetIDocumentUndoRedo().StartUndo(SwUndoId::EMPTY, nullptr);
 465
 466         bRet = GetDoc()->MergeTable( *pCursor->GetPoint(), bWithPrev );
 467
 468         GetDoc()->GetIDocumentUndoRedo().EndUndo(SwUndoId::EMPTY, nullptr);
 469         ClearFEShellTabCols(*GetDoc(), nullptr);
 470         EndAllAction();
 471     }
 472     return bRet;
 473 }
 474
 475 bool SwEditShell::CanMergeTable( bool bWithPrev, bool* pChkNxtPrv ) const
 476 {
 477     bool bRet = false;
 478     const SwPaM *pCursor = GetCursor();
 479     const SwTableNode* pTableNd = pCursor->GetNode().FindTableNode();
 480     if( pTableNd && dynamic_cast< const SwDDETable* >(&pTableNd->GetTable()) ==  nullptr)
 481     {
 482         bool bNew = pTableNd->GetTable().IsNewModel();
 483         const SwNodes& rNds = GetDoc()->GetNodes();
 484         if( pChkNxtPrv )
 485         {
 486             const SwTableNode* pChkNd = rNds[ pTableNd->GetIndex() - 1 ]->FindTableNode();
 487             if( pChkNd && dynamic_cast< const SwDDETable* >(&pChkNd->GetTable()) ==  nullptr &&
 488                 bNew == pChkNd->GetTable().IsNewModel() &&
 489                 // Consider table in table case
 490                 pChkNd->EndOfSectionIndex() == pTableNd->GetIndex() - 1 )
 491             {
 492                 *pChkNxtPrv = true;
 493                 bRet = true;        // using Prev is possible
 494             }
 495             else
 496             {
 497                 pChkNd = rNds[ pTableNd->EndOfSectionIndex() + 1 ]->GetTableNode();
 498                 if( pChkNd && dynamic_cast< const SwDDETable* >(&pChkNd->GetTable()) ==  nullptr &&
 499                     bNew == pChkNd->GetTable().IsNewModel() )
 500                 {
 501                     *pChkNxtPrv = false;
 502                     bRet = true;   // using Next is possible
 503                 }
 504             }
 505         }
 506         else
 507         {
 508             const SwTableNode* pTmpTableNd = nullptr;
 509
 510             if( bWithPrev )
 511             {
 512                 pTmpTableNd = rNds[ pTableNd->GetIndex() - 1 ]->FindTableNode();
 513                 // Consider table in table case
 514                 if ( pTmpTableNd && pTmpTableNd->EndOfSectionIndex() != pTableNd->GetIndex() - 1 )
 515                     pTmpTableNd = nullptr;
 516             }
 517             else
 518                 pTmpTableNd = rNds[ pTableNd->EndOfSectionIndex() + 1 ]->GetTableNode();
 519
 520             bRet = pTmpTableNd && dynamic_cast< const SwDDETable* >(&pTmpTableNd->GetTable()) ==  nullptr &&
 521                    bNew == pTmpTableNd->GetTable().IsNewModel();
 522         }
 523     }
 524     return bRet;
 525 }
 526
 527 /** create InsertDB as table Undo */
 528 void SwEditShell::AppendUndoForInsertFromDB( bool bIsTable )
 529 {
 530     GetDoc()->AppendUndoForInsertFromDB( *GetCursor(), bIsTable );
 531 }
 532
 533 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */