sw/source/core/unocore/unocrsr.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 <unocrsr.hxx>
  21 #include <doc.hxx>
  22 #include <IDocumentLayoutAccess.hxx>
  23 #include <swtable.hxx>
  24 #include <rootfrm.hxx>
  25
  26 sw::UnoCursorHint::~UnoCursorHint() {}
  27
  28 SwUnoCursor::SwUnoCursor( const SwPosition &rPos )
  29     : SwCursor( rPos, nullptr )
  30     , m_bRemainInSection(true)
  31     , m_bSkipOverHiddenSections(false)
  32     , m_bSkipOverProtectSections(false)
  33 {}
  34
  35 SwUnoCursor::~SwUnoCursor()
  36 {
  37     SwDoc& rDoc = GetDoc();
  38     if( !rDoc.IsInDtor() )
  39     {
  40         assert(!m_aNotifier.HasListeners());
  41     }
  42
  43     // delete the whole ring
  44     while( GetNext() != this )
  45     {
  46         Ring* pNxt = GetNextInRing();
  47         // coverity[deref_arg] - the delete moves a new entry into GetNext()
  48         pNxt->MoveTo(nullptr); // remove from chain
  49         delete pNxt;       // and delete
  50     }
  51     // coverity[deref_arg] - GetNext() is not a use after free at this point
  52 }
  53
  54 bool SwUnoCursor::IsReadOnlyAvailable() const
  55 {
  56     return true;
  57 }
  58
  59 const SwContentFrame*
  60 SwUnoCursor::DoSetBidiLevelLeftRight( bool &, bool, bool )
  61 {
  62     return nullptr; // not for uno cursor
  63 }
  64
  65 void SwUnoCursor::DoSetBidiLevelUpDown()
  66 {
  67     // not for uno cursor
  68 }
  69
  70 bool SwUnoCursor::IsSelOvr( SwCursorSelOverFlags eFlags )
  71 {
  72     if (m_bRemainInSection)
  73     {
  74         SwDoc& rDoc = GetDoc();
  75         SwNodeIndex aOldIdx( *rDoc.GetNodes()[ GetSavePos()->nNode ] );
  76         SwPosition& rPtPos = *GetPoint();
  77         SwStartNode *pOldSttNd = aOldIdx.GetNode().StartOfSectionNode(),
  78                     *pNewSttNd = rPtPos.GetNode().StartOfSectionNode();
  79         if( pOldSttNd != pNewSttNd )
  80         {
  81             bool bMoveDown = GetSavePos()->nNode < rPtPos.GetNodeIndex();
  82             bool bValidPos = false;
  83
  84             // search the correct surrounded start node - which the index
  85             // can't leave.
  86             while( pOldSttNd->IsSectionNode() )
  87                 pOldSttNd = pOldSttNd->StartOfSectionNode();
  88
  89             // is the new index inside this surrounded section?
  90             if( rPtPos.GetNode() > *pOldSttNd &&
  91                 rPtPos.GetNode() < *pOldSttNd->EndOfSectionNode() )
  92             {
  93                 // check if it a valid move inside this section
  94                 // (only over SwSection's !)
  95                 const SwStartNode* pInvalidNode;
  96                 do {
  97                     pInvalidNode = nullptr;
  98                     pNewSttNd = rPtPos.GetNode().StartOfSectionNode();
  99
 100                     const SwStartNode *pSttNd = pNewSttNd, *pEndNd = pOldSttNd;
 101                     if( pSttNd->EndOfSectionIndex() >
 102                         pEndNd->EndOfSectionIndex() )
 103                     {
 104                         pEndNd = pNewSttNd;
 105                         pSttNd = pOldSttNd;
 106                     }
 107
 108                     while( pSttNd->GetIndex() > pEndNd->GetIndex() )
 109                     {
 110                         if( !pSttNd->IsSectionNode() )
 111                             pInvalidNode = pSttNd;
 112                         pSttNd = pSttNd->StartOfSectionNode();
 113                     }
 114                     if( pInvalidNode )
 115                     {
 116                         if( bMoveDown )
 117                         {
 118                             rPtPos.Assign( *pInvalidNode->EndOfSectionNode(), 1 );
 119
 120                             if( !rPtPos.GetNode().IsContentNode() &&
 121                                 ( !rDoc.GetNodes().GoNextSection( &rPtPos ) ||
 122                                   rPtPos.GetNode() > *pOldSttNd->EndOfSectionNode() ) )
 123                                 break;
 124                         }
 125                         else
 126                         {
 127                             rPtPos.Assign( *pInvalidNode, -1 );
 128
 129                             if( !rPtPos.GetNode().IsContentNode() &&
 130                                 ( !SwNodes::GoPrevSection( &rPtPos ) ||
 131                                   rPtPos.GetNode() < *pOldSttNd ) )
 132                                 break;
 133                         }
 134                     }
 135                     else
 136                         bValidPos = true;
 137                 } while ( pInvalidNode );
 138             }
 139
 140             if( bValidPos )
 141             {
 142                 SwContentNode* pCNd = GetPointContentNode();
 143                 GetPoint()->SetContent( (pCNd && !bMoveDown) ? pCNd->Len() : 0);
 144             }
 145             else
 146             {
 147                 rPtPos.Assign( GetSavePos()->nNode );
 148                 GetPoint()->SetContent( GetSavePos()->nContent );
 149                 return true;
 150             }
 151         }
 152     }
 153     return SwCursor::IsSelOvr( eFlags );
 154 }
 155
 156 SwUnoTableCursor::SwUnoTableCursor(const SwPosition& rPos)
 157     : SwCursor(rPos, nullptr)
 158     , SwUnoCursor(rPos)
 159     , SwTableCursor(rPos)
 160     , m_aTableSel(rPos, nullptr)
 161 {
 162     SetRemainInSection(false);
 163 }
 164
 165 SwUnoTableCursor::~SwUnoTableCursor()
 166 {
 167     while (m_aTableSel.GetNext() != &m_aTableSel)
 168         delete m_aTableSel.GetNext();
 169 }
 170
 171 bool SwUnoTableCursor::IsSelOvr( SwCursorSelOverFlags eFlags )
 172 {
 173     bool bRet = SwUnoCursor::IsSelOvr( eFlags );
 174     if( !bRet )
 175     {
 176         const SwTableNode* pTNd = GetPoint()->GetNode().FindTableNode();
 177         bRet = !(pTNd == GetDoc().GetNodes()[ GetSavePos()->nNode ]->
 178                 FindTableNode() && (!HasMark() ||
 179                 pTNd == GetMark()->GetNode().FindTableNode() ));
 180     }
 181     return bRet;
 182 }
 183
 184 void SwUnoTableCursor::MakeBoxSels()
 185 {
 186     const SwContentNode* pCNd;
 187     bool bMakeTableCursors = true;
 188     if( GetPoint()->GetNodeIndex() && GetMark()->GetNodeIndex() &&
 189             nullptr != ( pCNd = GetPointContentNode() ) && pCNd->getLayoutFrame( pCNd->GetDoc().getIDocumentLayoutAccess().GetCurrentLayout() ) &&
 190             nullptr != ( pCNd = GetMarkContentNode() ) && pCNd->getLayoutFrame( pCNd->GetDoc().getIDocumentLayoutAccess().GetCurrentLayout() ) )
 191         bMakeTableCursors = GetDoc().getIDocumentLayoutAccess().GetCurrentLayout()->MakeTableCursors( *this );
 192
 193     if ( !bMakeTableCursors )
 194     {
 195         SwSelBoxes const& rTmpBoxes = GetSelectedBoxes();
 196         while (!rTmpBoxes.empty())
 197         {
 198             DeleteBox(0);
 199         }
 200     }
 201
 202     if( IsChgd() )
 203     {
 204         SwTableCursor::MakeBoxSels( &m_aTableSel );
 205         if (!GetSelectedBoxesCount())
 206         {
 207             const SwTableBox* pBox;
 208             const SwNode* pBoxNd = GetPoint()->GetNode().FindTableBoxStartNode();
 209             const SwTableNode* pTableNd = pBoxNd ? pBoxNd->FindTableNode() : nullptr;
 210             if( pTableNd && nullptr != ( pBox = pTableNd->GetTable().GetTableBox( pBoxNd->GetIndex() )) )
 211                 InsertBox( *pBox );
 212         }
 213     }
 214 }
 215
 216 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */