sw/source/core/crsr/trvltbl.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 <hintids.hxx>
  21 #include <crsrsh.hxx>
  22 #include <doc.hxx>
  23 #include <cntfrm.hxx>
  24 #include <editsh.hxx>
  25 #include <pam.hxx>
  26 #include <swtable.hxx>
  27 #include <frmfmt.hxx>
  28 #include <viscrs.hxx>
  29 #include "callnk.hxx"
  30 #include <tabfrm.hxx>
  31 #include <ndtxt.hxx>
  32 #include <shellres.hxx>
  33 #include <cellfrm.hxx>
  34 #include <IDocumentLayoutAccess.hxx>
  35 #include <osl/diagnose.h>
  36 #include <svx/srchdlg.hxx>
  37
  38 /// set cursor into next/previous cell
  39 bool SwCursorShell::GoNextCell( bool bAppendLine )
  40 {
  41     bool bRet = false;
  42     const SwTableNode* pTableNd = nullptr;
  43
  44     if( IsTableMode() || nullptr != ( pTableNd = IsCursorInTable() ))
  45     {
  46         SwCursor* pCursor = m_pTableCursor ? m_pTableCursor : m_pCurrentCursor;
  47         SwCallLink aLk( *this ); // watch Cursor-Moves
  48         bRet = true;
  49
  50         // Check if we have to move the cursor to a covered cell before
  51         // proceeding:
  52         const SwNode* pTableBoxStartNode = pCursor->GetPointNode().FindTableBoxStartNode();
  53         const SwTableBox* pTableBox = nullptr;
  54
  55         if ( pCursor->GetCursorRowSpanOffset() )
  56         {
  57             pTableBox = pTableBoxStartNode->GetTableBox();
  58             if (pTableBox && pTableBox->getRowSpan() > 1)
  59             {
  60                 if ( !pTableNd )
  61                     pTableNd = IsCursorInTable();
  62                 assert (pTableNd);
  63                 pTableBox = & pTableBox->FindEndOfRowSpan( pTableNd->GetTable(),
  64                                                            o3tl::narrowing<sal_uInt16>(pTableBox->getRowSpan() + pCursor->GetCursorRowSpanOffset() ) );
  65                 pTableBoxStartNode = pTableBox->GetSttNd();
  66             }
  67         }
  68
  69         SwNodeIndex  aCellStt( *pTableBoxStartNode->EndOfSectionNode(), 1 );
  70
  71         // if there is another StartNode after the EndNode of a cell then
  72         // there is another cell
  73         if( !aCellStt.GetNode().IsStartNode() )
  74         {
  75             if( pCursor->HasMark() || !bAppendLine )
  76                 bRet = false;
  77             else if (pTableNd)
  78             {
  79                 // if there is no list anymore then create new one
  80                 if ( !pTableBox )
  81                     pTableBox = pTableNd->GetTable().GetTableBox(
  82                                     pCursor->GetPoint()->GetNode().
  83                                     StartOfSectionIndex() );
  84
  85                 OSL_ENSURE( pTableBox, "Box is not in this table" );
  86                 SwSelBoxes aBoxes;
  87
  88                 // the document might change; w/o Action views would not be notified
  89                 static_cast<SwEditShell*>(this)->StartAllAction();
  90                 bRet = mxDoc->InsertRow( SwTable::SelLineFromBox( pTableBox, aBoxes, false ));
  91                 static_cast<SwEditShell*>(this)->EndAllAction();
  92             }
  93         }
  94         bRet = bRet && pCursor->GoNextCell();
  95         if( bRet )
  96             UpdateCursor();
  97     }
  98     return bRet;
  99 }
 100
 101 bool SwCursorShell::GoPrevCell()
 102 {
 103     bool bRet = false;
 104     if( IsTableMode() || IsCursorInTable() )
 105     {
 106         SwCursor* pCursor = m_pTableCursor ? m_pTableCursor : m_pCurrentCursor;
 107         SwCallLink aLk( *this ); // watch Cursor-Moves
 108         bRet = pCursor->GoPrevCell();
 109         if( bRet )
 110             UpdateCursor(); // update current cursor
 111     }
 112     return bRet;
 113 }
 114
 115 static const SwFrame* lcl_FindMostUpperCellFrame( const SwFrame* pFrame )
 116 {
 117     while ( pFrame &&
 118             ( !pFrame->IsCellFrame() ||
 119               !pFrame->GetUpper()->GetUpper()->IsTabFrame() ||
 120                pFrame->GetUpper()->GetUpper()->GetUpper()->IsInTab() ) )
 121     {
 122         pFrame = pFrame->GetUpper();
 123     }
 124     return pFrame;
 125 }
 126
 127 bool SwCursorShell::SelTableRowOrCol( bool bRow, bool bRowSimple )
 128 {
 129     // check if the current cursor's SPoint/Mark are in a table
 130     SwFrame *pFrame = GetCurrFrame();
 131     if( !pFrame || !pFrame->IsInTab() )
 132         return false;
 133
 134     const SwTabFrame* pTabFrame = pFrame->FindTabFrame();
 135     const SwTabFrame* pMasterTabFrame = pTabFrame->IsFollow() ? pTabFrame->FindMaster( true ) : pTabFrame;
 136     const SwTable* pTable = pTabFrame->GetTable();
 137
 138     CurrShell aCurr( this );
 139
 140     const SwTableBox* pStart = nullptr;
 141     const SwTableBox* pEnd = nullptr;
 142
 143     // search box based on layout
 144     SwSelBoxes aBoxes;
 145     SwTableSearchType eType = bRow ? SwTableSearchType::Row : SwTableSearchType::Col;
 146     const bool bCheckProtected = !IsReadOnlyAvailable();
 147
 148     if( bCheckProtected )
 149         eType = static_cast<SwTableSearchType>(eType | SwTableSearchType::Protect);
 150
 151     if ( !bRowSimple )
 152     {
 153         GetTableSel( *this, aBoxes, eType );
 154
 155         if( aBoxes.empty() )
 156             return false;
 157
 158         pStart = aBoxes[0];
 159         pEnd = aBoxes.back();
 160     }
 161     // #i32329# Enhanced table selection
 162     else if ( pTable->IsNewModel() )
 163     {
 164         const SwShellCursor *pCursor = GetCursor_();
 165         SwTable::SearchType eSearchType = bRow ? SwTable::SEARCH_ROW : SwTable::SEARCH_COL;
 166         pTable->CreateSelection( *pCursor, aBoxes, eSearchType, bCheckProtected );
 167         if( aBoxes.empty() )
 168             return false;
 169
 170         pStart = aBoxes[0];
 171         pEnd = aBoxes.back();
 172
 173         m_eEnhancedTableSel = eSearchType;
 174     }
 175     else
 176     {
 177         const SwShellCursor *pCursor = GetCursor_();
 178         const SwFrame* pStartFrame = pFrame;
 179         const SwContentNode *pCNd = pCursor->GetMarkContentNode();
 180         std::pair<Point, bool> const tmp(pCursor->GetMkPos(), true);
 181         const SwFrame* pEndFrame = pCNd
 182             ? pCNd->getLayoutFrame(GetLayout(), nullptr, &tmp)
 183             : nullptr;
 184
 185         if ( bRow )
 186         {
 187             pStartFrame = lcl_FindMostUpperCellFrame( pStartFrame );
 188             pEndFrame   = lcl_FindMostUpperCellFrame( pEndFrame   );
 189         }
 190
 191         if ( !pStartFrame || !pEndFrame )
 192             return false;
 193
 194         const bool bVert = pFrame->ImplFindTabFrame()->IsVertical();
 195
 196         // If we select upwards it is sufficient to set pStart and pEnd
 197         // to the first resp. last box of the selection obtained from
 198         // GetTableSel. However, selecting downwards requires the frames
 199         // located at the corners of the selection. This does not work
 200         // for column selections in vertical tables:
 201         const bool bSelectUp = ( bVert && !bRow ) ||
 202                                 *pCursor->GetPoint() <= *pCursor->GetMark();
 203         SwCellFrames aCells;
 204         GetTableSel( static_cast<const SwCellFrame*>(pStartFrame),
 205                    static_cast<const SwCellFrame*>(pEndFrame),
 206                    aBoxes, bSelectUp ? nullptr : &aCells, eType );
 207
 208         if( aBoxes.empty() || ( !bSelectUp && 4 != aCells.size() ) )
 209             return false;
 210
 211         if ( bSelectUp )
 212         {
 213             pStart = aBoxes[0];
 214             pEnd = aBoxes.back();
 215         }
 216         else
 217         {
 218             // will become point of table cursor
 219             pStart = aCells[bVert ? 0 : (bRow ? 2 : 1)]->GetTabBox();
 220             // will become mark of table cursor
 221             pEnd = aCells[bVert ? 3 : (bRow ? 1 : 2)]->GetTabBox();
 222         }
 223     }
 224
 225     // if no table cursor exists, create one
 226     if( !m_pTableCursor )
 227     {
 228         m_pTableCursor = new SwShellTableCursor( *this, *m_pCurrentCursor->GetPoint() );
 229         m_pCurrentCursor->DeleteMark();
 230         m_pCurrentCursor->SwSelPaintRects::Hide();
 231     }
 232
 233     m_pTableCursor->DeleteMark();
 234
 235     // set start and end of a column
 236     m_pTableCursor->GetPoint()->Assign( *pEnd->GetSttNd()->EndOfSectionNode() );
 237     m_pTableCursor->Move( fnMoveBackward, GoInContent );
 238     m_pTableCursor->SetMark();
 239     m_pTableCursor->GetPoint()->Assign( *pStart->GetSttNd()->EndOfSectionNode() );
 240     m_pTableCursor->Move( fnMoveBackward, GoInContent );
 241
 242     // set PtPos 'close' to the reference table, otherwise we might get problems
 243     // with the repeated headlines check in UpdateCursor():
 244     if ( !bRow )
 245         m_pTableCursor->GetPtPos() = pMasterTabFrame->IsVertical()
 246                                    ? pMasterTabFrame->getFrameArea().TopRight()
 247                                    : pMasterTabFrame->getFrameArea().TopLeft();
 248
 249     UpdateCursor();
 250     return true;
 251 }
 252
 253 bool SwCursorShell::SelTable()
 254 {
 255     // check if the current cursor's SPoint/Mark are in a table
 256     SwFrame *pFrame = GetCurrFrame();
 257     if( !pFrame->IsInTab() )
 258         return false;
 259
 260     const SwTabFrame *pTableFrame = pFrame->ImplFindTabFrame();
 261     const SwTabFrame* pMasterTabFrame = pTableFrame->IsFollow() ? pTableFrame->FindMaster( true ) : pTableFrame;
 262     const SwTableNode* pTableNd = pTableFrame->GetTable()->GetTableNode();
 263
 264     CurrShell aCurr( this );
 265
 266     if( !m_pTableCursor )
 267     {
 268         m_pTableCursor = new SwShellTableCursor( *this, *m_pCurrentCursor->GetPoint() );
 269         m_pCurrentCursor->DeleteMark();
 270         m_pCurrentCursor->SwSelPaintRects::Hide();
 271     }
 272
 273     m_pTableCursor->DeleteMark();
 274     m_pTableCursor->GetPoint()->Assign( *pTableNd );
 275     m_pTableCursor->Move( fnMoveForward, GoInContent );
 276     m_pTableCursor->SetMark();
 277     // set MkPos 'close' to the master table, otherwise we might get problems
 278     // with the repeated headlines check in UpdateCursor():
 279     m_pTableCursor->GetMkPos() = pMasterTabFrame->IsVertical() ? pMasterTabFrame->getFrameArea().TopRight() : pMasterTabFrame->getFrameArea().TopLeft();
 280     m_pTableCursor->GetPoint()->Assign( *pTableNd->EndOfSectionNode() );
 281     m_pTableCursor->Move( fnMoveBackward, GoInContent );
 282     UpdateCursor();
 283     return true;
 284 }
 285
 286 bool SwCursorShell::SelTableBox()
 287 {
 288     // if we're in a table, create a table cursor, and select the cell
 289     // that the current cursor's point resides in
 290
 291     // search for start node of our table box. If not found, exit really
 292     const SwStartNode* pStartNode =
 293         m_pCurrentCursor->GetPoint()->GetNode().FindTableBoxStartNode();
 294
 295 #if OSL_DEBUG_LEVEL > 0
 296     // the old code checks whether we're in a table by asking the
 297     // frame. This should yield the same result as searching for the
 298     // table box start node, right?
 299     SwFrame *pFrame = GetCurrFrame();
 300     OSL_ENSURE( !pFrame->IsInTab() == !(pStartNode != nullptr),
 301                 "Schroedinger's table: We're in a box, and also we aren't." );
 302 #endif
 303     if( pStartNode == nullptr )
 304         return false;
 305
 306     CurrShell aCurr( this );
 307
 308     // create a table cursor, if there isn't one already
 309     if( !m_pTableCursor )
 310     {
 311         m_pTableCursor = new SwShellTableCursor( *this, *m_pCurrentCursor->GetPoint() );
 312         m_pCurrentCursor->DeleteMark();
 313         m_pCurrentCursor->SwSelPaintRects::Hide();
 314     }
 315
 316     // select the complete box with our shiny new m_pTableCursor
 317     // 1. delete mark, and move point to first content node in box
 318     m_pTableCursor->DeleteMark();
 319     m_pTableCursor->GetPoint()->Assign( *pStartNode );
 320     m_pTableCursor->Move( fnMoveForward, GoInNode );
 321
 322     // 2. set mark, and move point to last content node in box
 323     m_pTableCursor->SetMark();
 324     m_pTableCursor->GetPoint()->Assign( *(pStartNode->EndOfSectionNode()) );
 325     m_pTableCursor->Move( fnMoveBackward, GoInNode );
 326
 327     // 3. exchange
 328     m_pTableCursor->Exchange();
 329
 330     // with some luck, UpdateCursor() will now update everything that
 331     // needs updating
 332     UpdateCursor();
 333
 334     return true;
 335 }
 336
 337 // TODO: provide documentation
 338 /** get the next non-protected cell inside a table
 339
 340     @param[in,out] rIdx is on a table node
 341     @param bInReadOnly  ???
 342
 343     @return <false> if no suitable cell could be found, otherwise <rIdx> points
 344             to content in a suitable cell and <true> is returned.
 345 */
 346 static bool lcl_FindNextCell( SwNodeIndex& rIdx, bool bInReadOnly )
 347 {
 348     // check protected cells
 349     SwNodeIndex aTmp( rIdx, 2 ); // TableNode + StartNode
 350
 351     // the resulting cell should be in that table:
 352     const SwTableNode* pTableNd = rIdx.GetNode().GetTableNode();
 353
 354     if ( !pTableNd )
 355     {
 356         OSL_FAIL( "lcl_FindNextCell not celled with table start node!" );
 357         return false;
 358     }
 359
 360     const SwNode* pTableEndNode = pTableNd->EndOfSectionNode();
 361
 362     SwContentNode* pCNd = aTmp.GetNode().GetContentNode();
 363
 364     // no content node => go to next content node
 365     if( !pCNd )
 366         pCNd = SwNodes::GoNext(&aTmp);
 367
 368     // robust
 369     if ( !pCNd )
 370         return false;
 371
 372     SwContentFrame* pFrame = pCNd->getLayoutFrame( pCNd->GetDoc().getIDocumentLayoutAccess().GetCurrentLayout() );
 373
 374     if ( nullptr == pFrame || pCNd->FindTableNode() != pTableNd ||
 375         (!bInReadOnly && pFrame->IsProtected() ) )
 376     {
 377         // we are not located inside a 'valid' cell. We have to continue searching...
 378
 379         // skip behind current section. This might be the end of the table cell
 380         // or behind an inner section or...
 381         aTmp.Assign( *pCNd->EndOfSectionNode(), 1 );
 382
 383         // loop to find a suitable cell...
 384         for( ;; )
 385         {
 386             SwNode* pNd = &aTmp.GetNode();
 387
 388             // we break this loop if we reached the end of the table.
 389             // to make this code even more robust, we also break if we are
 390             // already behind the table end node:
 391             if( pNd == pTableEndNode || /*robust: */ pNd->GetIndex() > pTableEndNode->GetIndex() )
 392                 return false;
 393
 394             // ok, get the next content node:
 395             pCNd = aTmp.GetNode().GetContentNode();
 396             if( nullptr == pCNd )
 397                 pCNd = SwNodes::GoNext(&aTmp);
 398
 399             // robust:
 400             if ( !pCNd )
 401                 return false;
 402
 403             // check if we have found a suitable table cell:
 404             pFrame = pCNd->getLayoutFrame( pCNd->GetDoc().getIDocumentLayoutAccess().GetCurrentLayout() );
 405
 406             if ( nullptr != pFrame && pCNd->FindTableNode() == pTableNd &&
 407                 (bInReadOnly || !pFrame->IsProtected() ) )
 408             {
 409                 // finally, we have found a suitable table cell => set index and return
 410                 rIdx = *pCNd;
 411                 return true;
 412             }
 413
 414             // continue behind the current section:
 415             aTmp.Assign( *pCNd->EndOfSectionNode(), +1 );
 416         }
 417     }
 418     rIdx = *pCNd;
 419     return true;
 420 }
 421
 422 /// see lcl_FindNextCell()
 423 static bool lcl_FindPrevCell( SwNodeIndex& rIdx, bool bInReadOnly  )
 424 {
 425     SwNodeIndex aTmp( rIdx, -2 ); // TableNode + EndNode
 426
 427     const SwNode* pTableEndNode = &rIdx.GetNode();
 428     const SwTableNode* pTableNd = pTableEndNode->StartOfSectionNode()->GetTableNode();
 429
 430     if ( !pTableNd )
 431     {
 432         OSL_FAIL( "lcl_FindPrevCell not celled with table start node!" );
 433         return false;
 434     }
 435
 436     SwContentNode* pCNd = aTmp.GetNode().GetContentNode();
 437
 438     if( !pCNd )
 439         pCNd = SwNodes::GoPrevious( &aTmp );
 440
 441     if ( !pCNd )
 442         return false;
 443
 444     SwContentFrame* pFrame = pCNd->getLayoutFrame( pCNd->GetDoc().getIDocumentLayoutAccess().GetCurrentLayout() );
 445
 446     if( nullptr == pFrame || pCNd->FindTableNode() != pTableNd ||
 447         (!bInReadOnly && pFrame->IsProtected() ))
 448     {
 449         // skip before current section
 450         aTmp.Assign( *pCNd->StartOfSectionNode(), -1 );
 451         for( ;; )
 452         {
 453             SwNode* pNd = &aTmp.GetNode();
 454
 455             if( pNd == pTableNd || pNd->GetIndex() < pTableNd->GetIndex() )
 456                 return false;
 457
 458             pCNd = aTmp.GetNode().GetContentNode();
 459             if( nullptr == pCNd )
 460                 pCNd = SwNodes::GoPrevious( &aTmp );
 461
 462             if ( !pCNd )
 463                 return false;
 464
 465             pFrame = pCNd->getLayoutFrame( pCNd->GetDoc().getIDocumentLayoutAccess().GetCurrentLayout() );
 466
 467             if( nullptr != pFrame && pCNd->FindTableNode() == pTableNd &&
 468                 (bInReadOnly || !pFrame->IsProtected() ) )
 469             {
 470                 rIdx = *pCNd;
 471                 return true; // ok, not protected
 472             }
 473             aTmp.Assign( *pCNd->StartOfSectionNode(), -1 );
 474         }
 475     }
 476     rIdx = *pCNd;
 477     return true;
 478 }
 479
 480 bool GotoPrevTable( SwPaM& rCurrentCursor, SwMoveFnCollection const & fnPosTable,
 481                     bool bInReadOnly )
 482 {
 483     SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::Empty );
 484
 485     SwNodeIndex aIdx( rCurrentCursor.GetPoint()->GetNode() );
 486
 487     SwTableNode* pTableNd = aIdx.GetNode().FindTableNode();
 488     if( pTableNd )
 489     {
 490         // #i26532#: If we are inside a table, we may not go backward to the
 491         // table start node, because we would miss any tables inside this table.
 492         SwTableNode* pInnerTableNd = nullptr;
 493         SwNodeIndex aTmpIdx( aIdx );
 494         while( aTmpIdx.GetIndex() &&
 495                 nullptr == ( pInnerTableNd = aTmpIdx.GetNode().StartOfSectionNode()->GetTableNode()) )
 496             --aTmpIdx;
 497
 498         if( pInnerTableNd == pTableNd )
 499             aIdx.Assign( *pTableNd, -1 );
 500     }
 501
 502     SwNodeIndex aOldIdx = aIdx;
 503     SwNodeOffset nLastNd(rCurrentCursor.GetDoc().GetNodes().Count() - 1);
 504     do {
 505         while( aIdx.GetIndex() &&
 506             nullptr == ( pTableNd = aIdx.GetNode().StartOfSectionNode()->GetTableNode()) )
 507         {
 508             --aIdx;
 509             if ( aIdx == aOldIdx )
 510             {
 511                 SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::NavElementNotFound );
 512                 return false;
 513             }
 514         }
 515
 516         if ( !aIdx.GetIndex() )
 517         {
 518             SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::StartWrapped );
 519             aIdx = nLastNd;
 520             continue;
 521         }
 522
 523         {
 524             if( &fnPosTable == &fnMoveForward ) // at the beginning?
 525             {
 526                 aIdx = *aIdx.GetNode().StartOfSectionNode();
 527                 if( !lcl_FindNextCell( aIdx, bInReadOnly ))
 528                 {
 529                     // skip table
 530                     aIdx.Assign( *pTableNd, -1 );
 531                     continue;
 532                 }
 533             }
 534             else
 535             {
 536                 // check protected cells
 537                 if( !lcl_FindNextCell( aIdx, bInReadOnly ))
 538                 {
 539                     // skip table
 540                     aIdx.Assign( *pTableNd, -1 );
 541                     continue;
 542                 }
 543             }
 544
 545             SwTextNode* pTextNode = aIdx.GetNode().GetTextNode();
 546             if ( pTextNode )
 547             {
 548                 rCurrentCursor.GetPoint()->Assign(*pTextNode, &fnPosTable == &fnMoveBackward ?
 549                                                       pTextNode->Len() :
 550                                                       0 );
 551             }
 552             return true;
 553         }
 554     } while( true );
 555
 556     return false;
 557 }
 558
 559 bool GotoNextTable( SwPaM& rCurrentCursor, SwMoveFnCollection const & fnPosTable,
 560                     bool bInReadOnly )
 561 {
 562     SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::Empty );
 563
 564     SwNodeIndex aIdx( rCurrentCursor.GetPoint()->GetNode() );
 565     SwTableNode* pTableNd = aIdx.GetNode().FindTableNode();
 566
 567     if( pTableNd )
 568         aIdx.Assign( *pTableNd->EndOfSectionNode(), 1 );
 569
 570     SwNodeIndex aOldIdx = aIdx;
 571     SwNodeOffset nLastNd(rCurrentCursor.GetDoc().GetNodes().Count() - 1);
 572     do {
 573         while( aIdx.GetIndex() < nLastNd &&
 574                 nullptr == ( pTableNd = aIdx.GetNode().GetTableNode()) )
 575         {
 576             ++aIdx;
 577             if ( aIdx == aOldIdx )
 578             {
 579                 SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::NavElementNotFound );
 580                 return false;
 581             }
 582         }
 583
 584         if ( aIdx.GetIndex() == nLastNd )
 585         {
 586             SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::EndWrapped );
 587             aIdx = SwNodeOffset(0);
 588             continue;
 589         }
 590
 591         assert( pTableNd );  // coverity, should never be nullptr
 592
 593         if( &fnPosTable == &fnMoveForward ) // at the beginning?
 594         {
 595             if( !lcl_FindNextCell( aIdx, bInReadOnly ))
 596             {
 597                 // skip table
 598                 aIdx.Assign( *pTableNd->EndOfSectionNode(), + 1 );
 599                 continue;
 600             }
 601         }
 602         else
 603         {
 604             aIdx = *aIdx.GetNode().EndOfSectionNode();
 605             // check protected cells
 606             if( !lcl_FindNextCell( aIdx, bInReadOnly ))
 607             {
 608                 // skip table
 609                 aIdx.Assign( *pTableNd->EndOfSectionNode(), + 1 );
 610                 continue;
 611             }
 612         }
 613
 614         SwTextNode* pTextNode = aIdx.GetNode().GetTextNode();
 615         if ( pTextNode )
 616         {
 617             rCurrentCursor.GetPoint()->Assign(*pTextNode, &fnPosTable == &fnMoveBackward ?
 618                                                   pTextNode->Len() :
 619                                                   0 );
 620         }
 621         return true;
 622
 623     } while( true );
 624
 625     // the flow is such that it is not possible to get there
 626
 627     return false;
 628 }
 629
 630 bool GotoCurrTable( SwPaM& rCurrentCursor, SwMoveFnCollection const & fnPosTable,
 631                     bool bInReadOnly )
 632 {
 633     SwTableNode* pTableNd = rCurrentCursor.GetPoint()->GetNode().FindTableNode();
 634     if( !pTableNd )
 635         return false;
 636
 637     SwTextNode* pTextNode = nullptr;
 638     if( &fnPosTable == &fnMoveBackward ) // to the end of the table
 639     {
 640         SwNodeIndex aIdx( *pTableNd->EndOfSectionNode() );
 641         if( !lcl_FindPrevCell( aIdx, bInReadOnly ))
 642             return false;
 643         pTextNode = aIdx.GetNode().GetTextNode();
 644     }
 645     else
 646     {
 647         SwNodeIndex aIdx( *pTableNd );
 648         if( !lcl_FindNextCell( aIdx, bInReadOnly ))
 649             return false;
 650         pTextNode = aIdx.GetNode().GetTextNode();
 651     }
 652
 653     if ( pTextNode )
 654     {
 655         rCurrentCursor.GetPoint()->Assign(*pTextNode, &fnPosTable == &fnMoveBackward ?
 656                                                         pTextNode->Len() :
 657                                                         0 );
 658     }
 659
 660     return true;
 661 }
 662
 663 bool SwCursor::MoveTable( SwWhichTable fnWhichTable, SwMoveFnCollection const & fnPosTable )
 664 {
 665     bool bRet = false;
 666     SwTableCursor* pTableCursor = dynamic_cast<SwTableCursor*>(this);
 667
 668     if( pTableCursor || !HasMark() )
 669     {
 670         SwCursorSaveState aSaveState( *this );
 671         bRet = (*fnWhichTable)( *this, fnPosTable, IsReadOnlyAvailable() ) &&
 672                 !IsSelOvr( SwCursorSelOverFlags::CheckNodeSection |
 673                            SwCursorSelOverFlags::Toggle );
 674     }
 675     return bRet;
 676 }
 677
 678 bool SwCursorShell::MoveTable( SwWhichTable fnWhichTable, SwMoveFnCollection const & fnPosTable )
 679 {
 680     SwCallLink aLk( *this ); // watch Cursor-Moves; call Link if needed
 681
 682     SwShellCursor* pCursor = m_pTableCursor ? m_pTableCursor : m_pCurrentCursor;
 683     bool bCheckPos;
 684     bool bRet;
 685     SwNodeOffset nPtNd(0);
 686     sal_Int32 nPtCnt = 0;
 687
 688     if ( !m_pTableCursor && m_pCurrentCursor->HasMark() )
 689     {
 690         // switch to table mode
 691         m_pTableCursor = new SwShellTableCursor( *this, *m_pCurrentCursor->GetPoint() );
 692         m_pCurrentCursor->DeleteMark();
 693         m_pCurrentCursor->SwSelPaintRects::Hide();
 694         m_pTableCursor->SetMark();
 695         pCursor = m_pTableCursor;
 696         bCheckPos = false;
 697     }
 698     else
 699     {
 700         bCheckPos = true;
 701         nPtNd = pCursor->GetPoint()->GetNodeIndex();
 702         nPtCnt = pCursor->GetPoint()->GetContentIndex();
 703     }
 704
 705     bRet = pCursor->MoveTable( fnWhichTable, fnPosTable );
 706
 707     if( bRet )
 708     {
 709         // #i45028# - set "top" position for repeated headline rows
 710         pCursor->GetPtPos() = Point();
 711
 712         UpdateCursor(SwCursorShell::SCROLLWIN|SwCursorShell::CHKRANGE|SwCursorShell::READONLY);
 713
 714         if( bCheckPos &&
 715             pCursor->GetPoint()->GetNodeIndex() == nPtNd &&
 716             pCursor->GetPoint()->GetContentIndex() == nPtCnt )
 717             bRet = false;
 718     }
 719     return bRet;
 720 }
 721
 722 bool SwCursorShell::IsTableComplexForChart()
 723 {
 724     bool bRet = false;
 725
 726     // Here we may trigger table formatting so we better do that inside an action
 727     StartAction();
 728     const SwTableNode* pTNd = m_pCurrentCursor->GetPoint()->GetNode().FindTableNode();
 729     if( pTNd )
 730     {
 731         // in a table; check if table or section is balanced
 732         OUString sSel;
 733         if( m_pTableCursor )
 734             sSel = GetBoxNms();
 735         bRet = pTNd->GetTable().IsTableComplexForChart( sSel );
 736     }
 737     EndAction();
 738
 739     return bRet;
 740 }
 741
 742 OUString SwCursorShell::GetBoxNms() const
 743 {
 744     OUString sNm;
 745     const SwPosition* pPos;
 746     SwFrame* pFrame;
 747
 748     if( IsTableMode() )
 749     {
 750         SwContentNode *pCNd = m_pTableCursor->Start()->GetNode().GetContentNode();
 751         pFrame = pCNd ? pCNd->getLayoutFrame( GetLayout() ) : nullptr;
 752         if( !pFrame )
 753             return sNm;
 754
 755         do {
 756             pFrame = pFrame->GetUpper();
 757         } while ( pFrame && !pFrame->IsCellFrame() );
 758
 759         OSL_ENSURE( pFrame, "no frame for this box" );
 760
 761         if( !pFrame )
 762             return sNm;
 763
 764         sNm = static_cast<SwCellFrame*>(pFrame)->GetTabBox()->GetName() + ":";
 765         pPos = m_pTableCursor->End();
 766     }
 767     else
 768     {
 769         const SwTableNode* pTableNd = IsCursorInTable();
 770         if( !pTableNd )
 771             return sNm;
 772         pPos = GetCursor()->GetPoint();
 773     }
 774
 775     SwContentNode* pCNd = pPos->GetNode().GetContentNode();
 776     pFrame = pCNd ? pCNd->getLayoutFrame( GetLayout() ) : nullptr;
 777
 778     if( pFrame )
 779     {
 780         do {
 781             pFrame = pFrame->GetUpper();
 782         } while ( pFrame && !pFrame->IsCellFrame() );
 783
 784         if( pFrame )
 785             sNm += static_cast<SwCellFrame*>(pFrame)->GetTabBox()->GetName();
 786     }
 787     return sNm;
 788 }
 789
 790 bool SwCursorShell::GotoTable( const OUString& rName )
 791 {
 792     SwCallLink aLk( *this ); // watch Cursor-Moves
 793     bool bRet = !m_pTableCursor && m_pCurrentCursor->GotoTable( rName );
 794     if( bRet )
 795     {
 796         m_pCurrentCursor->GetPtPos() = Point();
 797         UpdateCursor( SwCursorShell::SCROLLWIN | SwCursorShell::CHKRANGE |
 798                     SwCursorShell::READONLY );
 799     }
 800     return bRet;
 801 }
 802
 803 bool SwCursorShell::CheckTableBoxContent( const SwPosition* pPos )
 804 {
 805     if( !m_pBoxIdx || !m_pBoxPtr || IsSelTableCells() || !IsAutoUpdateCells() )
 806         return false;
 807
 808     // check if box content is consistent with given box format, reset if not
 809     SwTableBox* pChkBox = nullptr;
 810     SwStartNode* pSttNd = nullptr;
 811     if( !pPos )
 812     {
 813         // get stored position
 814         if (nullptr != (pSttNd = m_pBoxIdx->GetNode().GetStartNode()) &&
 815             SwTableBoxStartNode == pSttNd->GetStartNodeType() &&
 816             m_pBoxPtr == pSttNd->FindTableNode()->GetTable().
 817                         GetTableBox( m_pBoxIdx->GetIndex() ) )
 818             pChkBox = m_pBoxPtr;
 819     }
 820     else
 821     {
 822         pSttNd = pPos->GetNode().FindStartNodeByType( SwTableBoxStartNode );
 823         if( pSttNd)
 824             pChkBox = pSttNd->FindTableNode()->GetTable().GetTableBox( pSttNd->GetIndex() );
 825     }
 826
 827     // box has more than one paragraph
 828     if( pChkBox && pSttNd->GetIndex() + SwNodeOffset(2) != pSttNd->EndOfSectionIndex() )
 829         pChkBox = nullptr;
 830
 831     // destroy pointer before next action starts
 832     if( !pPos && !pChkBox )
 833         ClearTableBoxContent();
 834
 835     // cursor not anymore in this section?
 836     if( pChkBox && !pPos &&
 837         ( m_pCurrentCursor->HasMark() || m_pCurrentCursor->GetNext() != m_pCurrentCursor ||
 838           pSttNd->GetIndex() + 1 == m_pCurrentCursor->GetPoint()->GetNodeIndex() ))
 839         pChkBox = nullptr;
 840
 841     // Did the content of a box change at all? This is important if e.g. Undo
 842     // could not restore the content properly.
 843     if( pChkBox )
 844     {
 845         const SwTextNode* pNd = GetDoc()->GetNodes()[
 846                                     pSttNd->GetIndex() + 1 ]->GetTextNode();
 847         if( !pNd ||
 848             ( pNd->GetText() == SwViewShell::GetShellRes()->aCalc_Error &&
 849               SfxItemState::SET == pChkBox->GetFrameFormat()->
 850                             GetItemState( RES_BOXATR_FORMULA )) )
 851             pChkBox = nullptr;
 852     }
 853
 854     if( pChkBox )
 855     {
 856         // destroy pointer before next action starts
 857         ClearTableBoxContent();
 858         StartAction();
 859         GetDoc()->ChkBoxNumFormat( *pChkBox, true );
 860         EndAction();
 861     }
 862
 863     return nullptr != pChkBox;
 864 }
 865
 866 void SwCursorShell::SaveTableBoxContent( const SwPosition* pPos )
 867 {
 868     if( IsSelTableCells() || !IsAutoUpdateCells() )
 869         return ;
 870
 871     if( !pPos )
 872         pPos = m_pCurrentCursor->GetPoint();
 873
 874     SwStartNode* pSttNd = pPos->GetNode().FindStartNodeByType( SwTableBoxStartNode );
 875
 876     bool bCheckBox = false;
 877     if( pSttNd && m_pBoxIdx )
 878     {
 879         if( pSttNd == &m_pBoxIdx->GetNode() )
 880             pSttNd = nullptr;
 881         else
 882             bCheckBox = true;
 883     }
 884     else
 885         bCheckBox = nullptr != m_pBoxIdx;
 886
 887     if( bCheckBox )
 888     {
 889         // check m_pBoxIdx
 890         SwPosition aPos( *m_pBoxIdx );
 891         CheckTableBoxContent( &aPos );
 892     }
 893
 894     if( pSttNd )
 895     {
 896         m_pBoxPtr = pSttNd->FindTableNode()->GetTable().GetTableBox( pSttNd->GetIndex() );
 897
 898         if( m_pBoxIdx )
 899             *m_pBoxIdx = *pSttNd;
 900         else
 901             m_pBoxIdx = new SwNodeIndex( *pSttNd );
 902     }
 903 }
 904
 905 void SwCursorShell::ClearTableBoxContent()
 906 {
 907     delete m_pBoxIdx;
 908     m_pBoxIdx = nullptr;
 909     m_pBoxPtr = nullptr;
 910 }
 911
 912 bool SwCursorShell::EndAllTableBoxEdit()
 913 {
 914     bool bRet = false;
 915     for(SwViewShell& rSh : GetRingContainer())
 916     {
 917         if( auto pCursorShell = dynamic_cast<SwCursorShell *>(&rSh) )
 918             bRet |= pCursorShell->CheckTableBoxContent(
 919                         pCursorShell->m_pCurrentCursor->GetPoint() );
 920
 921     }
 922     return bRet;
 923 }
 924
 925 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */