sw/source/core/crsr/trvlfnfl.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 <crsrsh.hxx>
  21 #include <doc.hxx>
  22 #include <pagefrm.hxx>
  23 #include <cntfrm.hxx>
  24 #include <ftnfrm.hxx>
  25 #include <swcrsr.hxx>
  26 #include <ndtxt.hxx>
  27 #include <txtfrm.hxx>
  28 #include <txtftn.hxx>
  29 #include <ftnidx.hxx>
  30 #include <viscrs.hxx>
  31 #include "callnk.hxx"
  32 #include <svx/srchdlg.hxx>
  33 #include <wrtsh.hxx>
  34
  35 bool SwCursorShell::CallCursorShellFN( FNCursorShell fnCursor )
  36 {
  37     if (SwWrtShell* pWrtSh = dynamic_cast<SwWrtShell*>(this))
  38         pWrtSh->addCurrentPosition();
  39
  40     SwCallLink aLk( *this ); // watch Cursor-Moves
  41     bool bRet = (this->*fnCursor)();
  42     if( bRet )
  43         UpdateCursor( SwCursorShell::SCROLLWIN | SwCursorShell::CHKRANGE |
  44                     SwCursorShell::READONLY );
  45     return bRet;
  46 }
  47
  48 bool SwCursorShell::CallCursorFN( FNCursor fnCursor )
  49 {
  50     if (SwWrtShell* pWrtSh = dynamic_cast<SwWrtShell*>(this))
  51         pWrtSh->addCurrentPosition();
  52
  53     SwCallLink aLk( *this ); // watch Cursor-Moves
  54     SwCursor* pCursor = getShellCursor( true );
  55     bool bRet = (pCursor->*fnCursor)();
  56     if( bRet )
  57         UpdateCursor( SwCursorShell::SCROLLWIN | SwCursorShell::CHKRANGE |
  58                     SwCursorShell::READONLY );
  59     return bRet;
  60 }
  61
  62 bool SwCursor::GotoFootnoteText()
  63 {
  64     // jump from content to footnote
  65     bool bRet = false;
  66     SwTextNode* pTextNd = GetPoint()->GetNode().GetTextNode();
  67
  68     SwTextAttr *const pFootnote( pTextNd
  69         ? pTextNd->GetTextAttrForCharAt(
  70             GetPoint()->GetContentIndex(), RES_TXTATR_FTN)
  71         : nullptr);
  72     if (pFootnote)
  73     {
  74         SwCursorSaveState aSaveState( *this );
  75         GetPoint()->Assign( *static_cast<SwTextFootnote*>(pFootnote)->GetStartNode() );
  76
  77         SwContentNode* pCNd = GetDoc().GetNodes().GoNextSection(
  78                                             GetPoint(),
  79                                             true, !IsReadOnlyAvailable() );
  80         if( pCNd )
  81         {
  82             bRet = !IsSelOvr( SwCursorSelOverFlags::CheckNodeSection |
  83                               SwCursorSelOverFlags::Toggle );
  84         }
  85     }
  86     return bRet;
  87 }
  88
  89 bool SwCursorShell::GotoFootnoteText()
  90 {
  91     bool bRet = CallCursorFN( &SwCursor::GotoFootnoteText );
  92     if( !bRet )
  93     {
  94         SwTextNode* pTextNd = GetCursor_() ?
  95                    GetCursor_()->GetPoint()->GetNode().GetTextNode() : nullptr;
  96         if( pTextNd )
  97         {
  98             std::pair<Point, bool> const tmp(GetCursor_()->GetSttPos(), true);
  99             const SwFrame *pFrame = pTextNd->getLayoutFrame( GetLayout(),
 100                                                  GetCursor_()->Start(), &tmp);
 101             const SwFootnoteBossFrame* pFootnoteBoss;
 102             bool bSkip = pFrame && pFrame->IsInFootnote();
 103             while( pFrame )
 104             {
 105                 pFootnoteBoss = pFrame->FindFootnoteBossFrame();
 106                 if (!pFootnoteBoss)
 107                     break;
 108                 pFrame = pFootnoteBoss->FindFootnoteCont();
 109                 if( pFrame )
 110                 {
 111                     if( bSkip )
 112                         bSkip = false;
 113                     else
 114                     {
 115                         const SwContentFrame* pCnt = static_cast<const SwLayoutFrame*>
 116                                                         (pFrame)->ContainsContent();
 117                         if( pCnt )
 118                         {
 119                             SwTextFrame const*const pTF(
 120                                     static_cast<const SwTextFrame*>(pCnt));
 121                             *GetCursor_()->GetPoint() =
 122                                     pTF->MapViewToModelPos(pTF->GetOffset());
 123                             UpdateCursor( SwCursorShell::SCROLLWIN |
 124                                 SwCursorShell::CHKRANGE | SwCursorShell::READONLY );
 125                             bRet = true;
 126                             break;
 127                         }
 128                     }
 129                 }
 130                 if( pFootnoteBoss->GetNext() && !pFootnoteBoss->IsPageFrame() )
 131                     pFrame = pFootnoteBoss->GetNext();
 132                 else
 133                     pFrame = pFootnoteBoss->GetUpper();
 134             }
 135         }
 136     }
 137     return bRet;
 138 }
 139
 140 bool SwCursor::GotoFootnoteAnchor()
 141 {
 142     // jump from footnote to anchor
 143     const SwNode* pSttNd = GetPointNode().FindFootnoteStartNode();
 144     if( pSttNd )
 145     {
 146         // search in all footnotes in document for this StartIndex
 147         const SwFootnoteIdxs& rFootnoteArr = pSttNd->GetDoc().GetFootnoteIdxs();
 148         for( size_t n = 0; n < rFootnoteArr.size(); ++n )
 149         {
 150             const SwTextFootnote* pTextFootnote = rFootnoteArr[ n ];
 151             if( nullptr != pTextFootnote->GetStartNode() &&
 152                 pSttNd == &pTextFootnote->GetStartNode()->GetNode() )
 153             {
 154                 SwCursorSaveState aSaveState( *this );
 155
 156                 SwTextNode& rTNd = const_cast<SwTextNode&>(pTextFootnote->GetTextNode());
 157                 GetPoint()->Assign( rTNd, pTextFootnote->GetStart() );
 158
 159                 return !IsSelOvr( SwCursorSelOverFlags::CheckNodeSection |
 160                                   SwCursorSelOverFlags::Toggle );
 161             }
 162         }
 163     }
 164     return false;
 165 }
 166
 167 bool SwCursorShell::GotoFootnoteAnchor()
 168 {
 169     if (SwWrtShell* pWrtSh = dynamic_cast<SwWrtShell*>(this))
 170         pWrtSh->addCurrentPosition();
 171
 172     // jump from footnote to anchor
 173     SwCallLink aLk( *this ); // watch Cursor-Moves
 174     bool bRet = m_pCurrentCursor->GotoFootnoteAnchor();
 175     if( bRet )
 176     {
 177         // special treatment for table header row
 178         m_pCurrentCursor->GetPtPos() = Point();
 179         UpdateCursor( SwCursorShell::SCROLLWIN | SwCursorShell::CHKRANGE |
 180                     SwCursorShell::READONLY );
 181     }
 182     return bRet;
 183 }
 184
 185 static bool CmpLE( const SwTextFootnote& rFootnote, SwNodeOffset nNd, sal_Int32 nCnt )
 186 {
 187     const SwNodeOffset nTNd = rFootnote.GetTextNode().GetIndex();
 188     return nTNd < nNd || ( nTNd == nNd && rFootnote.GetStart() <= nCnt );
 189 }
 190
 191 static bool CmpL( const SwTextFootnote& rFootnote, SwNodeOffset nNd, sal_Int32 nCnt )
 192 {
 193     const SwNodeOffset nTNd = rFootnote.GetTextNode().GetIndex();
 194     return nTNd < nNd || ( nTNd == nNd && rFootnote.GetStart() < nCnt );
 195 }
 196
 197 bool SwCursor::GotoNextFootnoteAnchor()
 198 {
 199     const SwFootnoteIdxs& rFootnoteArr = GetDoc().GetFootnoteIdxs();
 200     const SwTextFootnote* pTextFootnote = nullptr;
 201     size_t nPos = 0;
 202
 203     if( rFootnoteArr.empty() )
 204     {
 205         SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::NavElementNotFound );
 206         return false;
 207     }
 208
 209     if( rFootnoteArr.SeekEntry( GetPoint()->GetNode(), &nPos ))
 210     {
 211         // there is a footnote with this index, so search also for the next one
 212         if( nPos < rFootnoteArr.size() )
 213         {
 214             SwNodeOffset nNdPos = GetPoint()->GetNodeIndex();
 215             const sal_Int32 nCntPos = GetPoint()->GetContentIndex();
 216
 217             pTextFootnote = rFootnoteArr[ nPos ];
 218             // search forwards
 219             if( CmpLE( *pTextFootnote, nNdPos, nCntPos ) )
 220             {
 221                 pTextFootnote = nullptr;
 222                 for( ++nPos; nPos < rFootnoteArr.size(); ++nPos )
 223                 {
 224                     pTextFootnote = rFootnoteArr[ nPos ];
 225                     if( !CmpLE( *pTextFootnote, nNdPos, nCntPos ) )
 226                         break; // found
 227                     pTextFootnote = nullptr;
 228                 }
 229             }
 230             else if( nPos )
 231             {
 232                 // search backwards
 233                 pTextFootnote = nullptr;
 234                 while( nPos )
 235                 {
 236                     pTextFootnote = rFootnoteArr[ --nPos ];
 237                     if( CmpLE( *pTextFootnote, nNdPos, nCntPos ) )
 238                     {
 239                         pTextFootnote = rFootnoteArr[ ++nPos ];
 240                         break; // found
 241                     }
 242                 }
 243             }
 244         }
 245     }
 246     else if( nPos < rFootnoteArr.size() )
 247         pTextFootnote = rFootnoteArr[ nPos ];
 248
 249     if (pTextFootnote == nullptr)
 250     {
 251         pTextFootnote = rFootnoteArr[ 0 ];
 252         SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::EndWrapped );
 253     }
 254     else
 255         SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::Empty );
 256
 257     bool bRet = nullptr != pTextFootnote;
 258     if( bRet )
 259     {
 260         SwCursorSaveState aSaveState( *this );
 261
 262         SwTextNode& rTNd = const_cast<SwTextNode&>(pTextFootnote->GetTextNode());
 263         GetPoint()->Assign( rTNd, pTextFootnote->GetStart() );
 264         bRet = !IsSelOvr();
 265     }
 266     return bRet;
 267 }
 268
 269 bool SwCursor::GotoPrevFootnoteAnchor()
 270 {
 271     const SwFootnoteIdxs& rFootnoteArr = GetDoc().GetFootnoteIdxs();
 272     const SwTextFootnote* pTextFootnote = nullptr;
 273     size_t nPos = 0;
 274
 275     if( rFootnoteArr.empty() )
 276     {
 277         SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::NavElementNotFound );
 278         return false;
 279     }
 280
 281     if( rFootnoteArr.SeekEntry( GetPoint()->GetNode(), &nPos ) )
 282     {
 283         // there is a footnote with this index, so search also for the next one
 284         SwNodeOffset nNdPos = GetPoint()->GetNodeIndex();
 285         const sal_Int32 nCntPos = GetPoint()->GetContentIndex();
 286
 287         pTextFootnote = rFootnoteArr[ nPos ];
 288         // search forwards
 289         if( CmpL( *pTextFootnote, nNdPos, nCntPos ))
 290         {
 291             for( ++nPos; nPos < rFootnoteArr.size(); ++nPos )
 292             {
 293                 pTextFootnote = rFootnoteArr[ nPos ];
 294                 if( !CmpL( *pTextFootnote, nNdPos, nCntPos ) )
 295                 {
 296                     pTextFootnote = rFootnoteArr[ nPos-1 ];
 297                     break;
 298                 }
 299             }
 300         }
 301         else if( nPos )
 302         {
 303             // search backwards
 304             pTextFootnote = nullptr;
 305             while( nPos )
 306             {
 307                 pTextFootnote = rFootnoteArr[ --nPos ];
 308                 if( CmpL( *pTextFootnote, nNdPos, nCntPos ))
 309                     break; // found
 310                 pTextFootnote = nullptr;
 311             }
 312         }
 313         else
 314             pTextFootnote = nullptr;
 315     }
 316     else if( nPos )
 317         pTextFootnote = rFootnoteArr[ nPos-1 ];
 318
 319     if( pTextFootnote == nullptr )
 320     {
 321         pTextFootnote = rFootnoteArr[ rFootnoteArr.size() - 1 ];
 322         SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::StartWrapped );
 323     }
 324     else
 325         SvxSearchDialogWrapper::SetSearchLabel( SearchLabel::Empty );
 326
 327     bool bRet = nullptr != pTextFootnote;
 328     if( bRet )
 329     {
 330         SwCursorSaveState aSaveState( *this );
 331
 332         SwTextNode& rTNd = const_cast<SwTextNode&>(pTextFootnote->GetTextNode());
 333         GetPoint()->Assign( rTNd, pTextFootnote->GetStart() );
 334         bRet = !IsSelOvr();
 335     }
 336     return bRet;
 337 }
 338
 339 bool SwCursorShell::GotoNextFootnoteAnchor()
 340 {
 341     return CallCursorFN( &SwCursor::GotoNextFootnoteAnchor );
 342 }
 343
 344 bool SwCursorShell::GotoPrevFootnoteAnchor()
 345 {
 346     return CallCursorFN( &SwCursor::GotoPrevFootnoteAnchor );
 347 }
 348
 349 /// jump from border to anchor
 350 void SwCursorShell::GotoFlyAnchor()
 351 {
 352     CurrShell aCurr( this );
 353     const SwFrame* pFrame = GetCurrFrame();
 354     do {
 355         pFrame = pFrame->GetUpper();
 356     } while( pFrame && !pFrame->IsFlyFrame() );
 357
 358     if( !pFrame ) // no FlyFrame
 359         return;
 360
 361     SwCallLink aLk( *this ); // watch Cursor-Moves
 362     SwCursorSaveState aSaveState( *m_pCurrentCursor );
 363
 364     // jump in BodyFrame closest to FlyFrame
 365     SwRect aTmpRect( m_aCharRect );
 366     if( !pFrame->getFrameArea().Contains( aTmpRect ))
 367         aTmpRect = pFrame->getFrameArea();
 368     Point aPt( aTmpRect.Left(), aTmpRect.Top() +
 369                 ( aTmpRect.Bottom() - aTmpRect.Top() ) / 2 );
 370     aPt.setX(aPt.getX() > (pFrame->getFrameArea().Left() + (pFrame->getFrameArea().SSize().Width() / 2 ))
 371                 ? pFrame->getFrameArea().Right()
 372                 : pFrame->getFrameArea().Left());
 373
 374     const SwPageFrame* pPageFrame = pFrame->FindPageFrame();
 375     const SwContentFrame* pFndFrame = pPageFrame->GetContentPos( aPt, false, true );
 376     pFndFrame->GetModelPositionForViewPoint( m_pCurrentCursor->GetPoint(), aPt );
 377
 378     bool bRet = !m_pCurrentCursor->IsInProtectTable() && !m_pCurrentCursor->IsSelOvr();
 379     if( bRet )
 380         UpdateCursor( SwCursorShell::SCROLLWIN | SwCursorShell::CHKRANGE |
 381                     SwCursorShell::READONLY );
 382 }
 383
 384 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */