editeng/source/outliner/outlvw.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 <memory>
  21 #include <com/sun/star/i18n/WordType.hpp>
  22
  23 #include <svl/itempool.hxx>
  24 #include <editeng/editeng.hxx>
  25 #include <editeng/editview.hxx>
  26 #include <editeng/editdata.hxx>
  27
  28 #include <svl/style.hxx>
  29 #include <svl/languageoptions.hxx>
  30 #include <i18nlangtag/languagetag.hxx>
  31
  32 #include <editeng/outliner.hxx>
  33 #include <outleeng.hxx>
  34 #include "paralist.hxx"
  35 #include "outlundo.hxx"
  36 #include <editeng/outlobj.hxx>
  37 #include <editeng/flditem.hxx>
  38 #include <editeng/eeitem.hxx>
  39 #include <editeng/numitem.hxx>
  40 #include <vcl/window.hxx>
  41 #include <vcl/event.hxx>
  42 #include <vcl/ptrstyle.hxx>
  43 #include <svl/itemset.hxx>
  44 #include <svl/eitem.hxx>
  45 #include <editeng/editstat.hxx>
  46 #include <sal/log.hxx>
  47 #include <osl/diagnose.h>
  48 #include <tools/debug.hxx>
  49
  50 using namespace ::com::sun::star;
  51
  52
  53 OutlinerView::OutlinerView( Outliner* pOut, vcl::Window* pWin )
  54 {
  55     pOwner                      = pOut;
  56     pEditView.reset( new EditView( pOut->pEditEngine.get(), pWin ) );
  57 }
  58
  59 OutlinerView::~OutlinerView()
  60 {
  61 }
  62
  63 void OutlinerView::Paint( const tools::Rectangle& rRect, OutputDevice* pTargetDevice )
  64 {
  65     // For the first Paint/KeyInput/Drop an empty Outliner is turned into
  66     // an Outliner with exactly one paragraph.
  67     if( pOwner->bFirstParaIsEmpty )
  68         pOwner->Insert( OUString() );
  69
  70     pEditView->Paint( rRect, pTargetDevice );
  71 }
  72
  73 bool OutlinerView::PostKeyEvent( const KeyEvent& rKEvt, vcl::Window const * pFrameWin )
  74 {
  75     // For the first Paint/KeyInput/Drop an empty Outliner is turned into
  76     // an Outliner with exactly one paragraph.
  77     if( pOwner->bFirstParaIsEmpty )
  78         pOwner->Insert( OUString() );
  79
  80     bool bKeyProcessed = false;
  81     ESelection aSel( pEditView->GetSelection() );
  82     bool bSelection = aSel.HasRange();
  83     vcl::KeyCode aKeyCode = rKEvt.GetKeyCode();
  84     KeyFuncType eFunc = aKeyCode.GetFunction();
  85     sal_uInt16 nCode = aKeyCode.GetCode();
  86     bool bReadOnly = IsReadOnly();
  87
  88     if( bSelection && ( nCode != KEY_TAB ) && EditEngine::DoesKeyChangeText( rKEvt ) )
  89     {
  90         if ( ImpCalcSelectedPages( false ) && !pOwner->ImpCanDeleteSelectedPages( this ) )
  91             return true;
  92     }
  93
  94     if ( eFunc != KeyFuncType::DONTKNOW )
  95     {
  96         switch ( eFunc )
  97         {
  98             case KeyFuncType::CUT:
  99             {
 100                 if ( !bReadOnly )
 101                 {
 102                     Cut();
 103                     bKeyProcessed = true;
 104                 }
 105             }
 106             break;
 107             case KeyFuncType::COPY:
 108             {
 109                 Copy();
 110                 bKeyProcessed = true;
 111             }
 112             break;
 113             case KeyFuncType::PASTE:
 114             {
 115                 if ( !bReadOnly )
 116                 {
 117                     PasteSpecial();
 118                     bKeyProcessed = true;
 119                 }
 120             }
 121             break;
 122             case KeyFuncType::DELETE:
 123             {
 124                 if( !bReadOnly && !bSelection && ( pOwner->GetOutlinerMode() != OutlinerMode::TextObject ) )
 125                 {
 126                     if( aSel.nEndPos == pOwner->pEditEngine->GetTextLen( aSel.nEndPara ) )
 127                     {
 128                         Paragraph* pNext = pOwner->pParaList->GetParagraph( aSel.nEndPara+1 );
 129                         if( pNext && pNext->HasFlag(ParaFlag::ISPAGE) )
 130                         {
 131                             if( !pOwner->ImpCanDeleteSelectedPages( this, aSel.nEndPara, 1 ) )
 132                                 return false;
 133                         }
 134                     }
 135                 }
 136             }
 137             break;
 138             default:    // is then possibly edited below.
 139                         eFunc = KeyFuncType::DONTKNOW;
 140         }
 141     }
 142     if ( eFunc == KeyFuncType::DONTKNOW )
 143     {
 144         switch ( nCode )
 145         {
 146             case KEY_TAB:
 147             {
 148                 if ( !bReadOnly && !aKeyCode.IsMod1() && !aKeyCode.IsMod2() )
 149                 {
 150                     if ( ( pOwner->GetOutlinerMode() != OutlinerMode::TextObject ) &&
 151                          ( pOwner->GetOutlinerMode() != OutlinerMode::TitleObject ) &&
 152                          ( bSelection || !aSel.nStartPos ) )
 153                     {
 154                         Indent( aKeyCode.IsShift() ? -1 : +1 );
 155                         bKeyProcessed = true;
 156                     }
 157                     else if ( ( pOwner->GetOutlinerMode() == OutlinerMode::TextObject ) &&
 158                               !bSelection && !aSel.nEndPos && pOwner->ImplHasNumberFormat( aSel.nEndPara ) )
 159                     {
 160                         Indent( aKeyCode.IsShift() ? -1 : +1 );
 161                         bKeyProcessed = true;
 162                     }
 163                 }
 164             }
 165             break;
 166             case KEY_BACKSPACE:
 167             {
 168                 if( !bReadOnly && !bSelection && aSel.nEndPara && !aSel.nEndPos )
 169                 {
 170                     Paragraph* pPara = pOwner->pParaList->GetParagraph( aSel.nEndPara );
 171                     Paragraph* pPrev = pOwner->pParaList->GetParagraph( aSel.nEndPara-1 );
 172                     if( !pPrev->IsVisible()  )
 173                         return true;
 174                     if( !pPara->GetDepth() )
 175                     {
 176                         if(!pOwner->ImpCanDeleteSelectedPages(this, aSel.nEndPara , 1 ) )
 177                             return true;
 178                     }
 179                 }
 180             }
 181             break;
 182             case KEY_RETURN:
 183             {
 184                 if ( !bReadOnly )
 185                 {
 186                     // Special treatment: hard return at the end of a paragraph,
 187                     // which has collapsed subparagraphs.
 188                     Paragraph* pPara = pOwner->pParaList->GetParagraph( aSel.nEndPara );
 189
 190                     if( !aKeyCode.IsShift() )
 191                     {
 192                         // ImpGetCursor again???
 193                         if( !bSelection &&
 194                                 aSel.nEndPos == pOwner->pEditEngine->GetTextLen( aSel.nEndPara ) )
 195                         {
 196                             sal_Int32 nChildren = pOwner->pParaList->GetChildCount(pPara);
 197                             if( nChildren && !pOwner->pParaList->HasVisibleChildren(pPara))
 198                             {
 199                                 pOwner->UndoActionStart( OLUNDO_INSERT );
 200                                 sal_Int32 nTemp = aSel.nEndPara;
 201                                 nTemp += nChildren;
 202                                 nTemp++; // insert above next Non-Child
 203                                 SAL_WARN_IF( nTemp < 0, "editeng", "OutlinerView::PostKeyEvent - overflow");
 204                                 if (nTemp >= 0)
 205                                 {
 206                                     pOwner->Insert( OUString(),nTemp,pPara->GetDepth());
 207                                     // Position the cursor
 208                                     ESelection aTmpSel(nTemp,0,nTemp,0);
 209                                     pEditView->SetSelection( aTmpSel );
 210                                 }
 211                                 pEditView->ShowCursor();
 212                                 pOwner->UndoActionEnd();
 213                                 bKeyProcessed = true;
 214                             }
 215                         }
 216                     }
 217                     if( !bKeyProcessed && !bSelection &&
 218                                 !aKeyCode.IsShift() && aKeyCode.IsMod1() &&
 219                             ( aSel.nEndPos == pOwner->pEditEngine->GetTextLen(aSel.nEndPara) ) )
 220                     {
 221                         pOwner->UndoActionStart( OLUNDO_INSERT );
 222                         sal_Int32 nTemp = aSel.nEndPara;
 223                         nTemp++;
 224                         pOwner->Insert( OUString(), nTemp, pPara->GetDepth()+1 );
 225
 226                         // Position the cursor
 227                         ESelection aTmpSel(nTemp,0,nTemp,0);
 228                         pEditView->SetSelection( aTmpSel );
 229                         pEditView->ShowCursor();
 230                         pOwner->UndoActionEnd();
 231                         bKeyProcessed = true;
 232                     }
 233                 }
 234             }
 235             break;
 236         }
 237     }
 238
 239     return bKeyProcessed || pEditView->PostKeyEvent( rKEvt, pFrameWin );
 240 }
 241
 242 sal_Int32 OutlinerView::ImpCheckMousePos(const Point& rPosPix, MouseTarget& reTarget)
 243 {
 244     sal_Int32 nPara = EE_PARA_NOT_FOUND;
 245
 246     Point aMousePosWin = pEditView->GetOutputDevice().PixelToLogic( rPosPix );
 247     if( !pEditView->GetOutputArea().Contains( aMousePosWin ) )
 248     {
 249         reTarget = MouseTarget::Outside;
 250     }
 251     else
 252     {
 253         reTarget = MouseTarget::Text;
 254
 255         Point aPaperPos( aMousePosWin );
 256         tools::Rectangle aOutArea = pEditView->GetOutputArea();
 257         tools::Rectangle aVisArea = pEditView->GetVisArea();
 258         aPaperPos.AdjustX( -(aOutArea.Left()) );
 259         aPaperPos.AdjustX(aVisArea.Left() );
 260         aPaperPos.AdjustY( -(aOutArea.Top()) );
 261         aPaperPos.AdjustY(aVisArea.Top() );
 262
 263         bool bBullet;
 264         if ( pOwner->IsTextPos( aPaperPos, 0, &bBullet ) )
 265         {
 266             Point aDocPos = pOwner->GetDocPos( aPaperPos );
 267             nPara = pOwner->pEditEngine->FindParagraph( aDocPos.Y() );
 268
 269             if ( bBullet )
 270             {
 271                 reTarget = MouseTarget::Bullet;
 272             }
 273             else
 274             {
 275                 // Check for hyperlink
 276                 const SvxFieldItem* pFieldItem = pEditView->GetField( aMousePosWin );
 277                 if ( pFieldItem && pFieldItem->GetField() && dynamic_cast< const SvxURLField* >(pFieldItem->GetField()) != nullptr )
 278                     reTarget = MouseTarget::Hypertext;
 279             }
 280         }
 281     }
 282     return nPara;
 283 }
 284
 285 bool OutlinerView::MouseMove( const MouseEvent& rMEvt )
 286 {
 287     if( ( pOwner->GetOutlinerMode() == OutlinerMode::TextObject ) || pEditView->GetEditEngine()->IsInSelectionMode())
 288         return pEditView->MouseMove( rMEvt );
 289
 290     Point aMousePosWin( pEditView->GetOutputDevice().PixelToLogic( rMEvt.GetPosPixel() ) );
 291     if( !pEditView->GetOutputArea().Contains( aMousePosWin ) )
 292         return false;
 293
 294     PointerStyle aPointer = GetPointer( rMEvt.GetPosPixel() );
 295     pEditView->GetWindow()->SetPointer( aPointer );
 296     return pEditView->MouseMove( rMEvt );
 297 }
 298
 299
 300 bool OutlinerView::MouseButtonDown( const MouseEvent& rMEvt )
 301 {
 302     if ( ( pOwner->GetOutlinerMode() == OutlinerMode::TextObject ) || pEditView->GetEditEngine()->IsInSelectionMode() )
 303         return pEditView->MouseButtonDown( rMEvt );
 304
 305     Point aMousePosWin( pEditView->GetOutputDevice().PixelToLogic( rMEvt.GetPosPixel() ) );
 306     if( !pEditView->GetOutputArea().Contains( aMousePosWin ) )
 307         return false;
 308
 309     PointerStyle aPointer = GetPointer( rMEvt.GetPosPixel() );
 310     pEditView->GetWindow()->SetPointer( aPointer );
 311
 312     MouseTarget eTarget;
 313     sal_Int32 nPara = ImpCheckMousePos( rMEvt.GetPosPixel(), eTarget );
 314     if ( eTarget == MouseTarget::Bullet )
 315     {
 316         Paragraph* pPara = pOwner->pParaList->GetParagraph( nPara );
 317         bool bHasChildren = (pPara && pOwner->pParaList->HasChildren(pPara));
 318         if( rMEvt.GetClicks() == 1 )
 319         {
 320             sal_Int32 nEndPara = nPara;
 321             if ( bHasChildren && pOwner->pParaList->HasVisibleChildren(pPara) )
 322                 nEndPara += pOwner->pParaList->GetChildCount( pPara );
 323             // The selection is inverted, so that EditEngine does not scroll
 324             ESelection aSel(nEndPara, EE_TEXTPOS_ALL, nPara, 0 );
 325             pEditView->SetSelection( aSel );
 326         }
 327         else if( rMEvt.GetClicks() == 2 && bHasChildren )
 328             ImpToggleExpand( pPara );
 329
 330         return true;
 331     }
 332
 333     // special case for outliner view in impress, check if double click hits the page icon for toggle
 334     if( (nPara == EE_PARA_NOT_FOUND) && (pOwner->GetOutlinerMode() == OutlinerMode::OutlineView) && (eTarget == MouseTarget::Text) && (rMEvt.GetClicks() == 2) )
 335     {
 336         ESelection aSel( pEditView->GetSelection() );
 337         nPara = aSel.nStartPara;
 338         Paragraph* pPara = pOwner->pParaList->GetParagraph( nPara );
 339         if( (pPara && pOwner->pParaList->HasChildren(pPara)) && pPara->HasFlag(ParaFlag::ISPAGE) )
 340         {
 341             ImpToggleExpand( pPara );
 342         }
 343     }
 344     return pEditView->MouseButtonDown( rMEvt );
 345 }
 346
 347
 348 bool OutlinerView::MouseButtonUp( const MouseEvent& rMEvt )
 349 {
 350     if ( ( pOwner->GetOutlinerMode() == OutlinerMode::TextObject ) || pEditView->GetEditEngine()->IsInSelectionMode() )
 351         return pEditView->MouseButtonUp( rMEvt );
 352
 353     Point aMousePosWin( pEditView->GetOutputDevice().PixelToLogic( rMEvt.GetPosPixel() ) );
 354     if( !pEditView->GetOutputArea().Contains( aMousePosWin ) )
 355         return false;
 356
 357     PointerStyle aPointer = GetPointer( rMEvt.GetPosPixel() );
 358     pEditView->GetWindow()->SetPointer( aPointer );
 359
 360     return pEditView->MouseButtonUp( rMEvt );
 361 }
 362
 363 void OutlinerView::ReleaseMouse()
 364 {
 365     pEditView->ReleaseMouse();
 366 }
 367
 368 void OutlinerView::ImpToggleExpand( Paragraph const * pPara )
 369 {
 370     sal_Int32 nPara = pOwner->pParaList->GetAbsPos( pPara );
 371     pEditView->SetSelection( ESelection( nPara, 0, nPara, 0 ) );
 372     ImplExpandOrCollaps( nPara, nPara, !pOwner->pParaList->HasVisibleChildren( pPara ) );
 373     pEditView->ShowCursor();
 374 }
 375
 376 void OutlinerView::Select( Paragraph const * pParagraph, bool bSelect )
 377 {
 378     sal_Int32 nPara = pOwner->pParaList->GetAbsPos( pParagraph );
 379     sal_Int32 nEnd = 0;
 380     if ( bSelect )
 381         nEnd = SAL_MAX_INT32;
 382
 383     ESelection aSel( nPara, 0, nPara, nEnd );
 384     pEditView->SetSelection( aSel );
 385 }
 386
 387
 388 void OutlinerView::SetAttribs( const SfxItemSet& rAttrs )
 389 {
 390     bool bUpdate = pOwner->pEditEngine->SetUpdateLayout( false );
 391
 392     if( !pOwner->IsInUndo() && pOwner->IsUndoEnabled() )
 393         pOwner->UndoActionStart( OLUNDO_ATTR );
 394
 395     ParaRange aSel = ImpGetSelectedParagraphs( false );
 396
 397     pEditView->SetAttribs( rAttrs );
 398
 399     // Update Bullet text
 400     for( sal_Int32 nPara= aSel.nStartPara; nPara <= aSel.nEndPara; nPara++ )
 401     {
 402         pOwner->ImplCheckNumBulletItem( nPara );
 403         pOwner->ImplCalcBulletText( nPara, false, false );
 404
 405         if( !pOwner->IsInUndo() && pOwner->IsUndoEnabled() )
 406             pOwner->InsertUndo( std::make_unique<OutlinerUndoCheckPara>( pOwner, nPara ) );
 407     }
 408
 409     if( !pOwner->IsInUndo() && pOwner->IsUndoEnabled() )
 410         pOwner->UndoActionEnd();
 411
 412     pEditView->SetEditEngineUpdateLayout( bUpdate );
 413 }
 414
 415 ParaRange OutlinerView::ImpGetSelectedParagraphs( bool bIncludeHiddenChildren )
 416 {
 417     ESelection aSel = pEditView->GetSelection();
 418     ParaRange aParas( aSel.nStartPara, aSel.nEndPara );
 419     aParas.Adjust();
 420
 421     // Record the  invisible Children of the last Parents in the selection
 422     if ( bIncludeHiddenChildren )
 423     {
 424         Paragraph* pLast = pOwner->pParaList->GetParagraph( aParas.nEndPara );
 425         if ( pOwner->pParaList->HasHiddenChildren( pLast ) )
 426             aParas.nEndPara = aParas.nEndPara + pOwner->pParaList->GetChildCount( pLast );
 427     }
 428     return aParas;
 429 }
 430
 431 // TODO: Name should be changed!
 432 void OutlinerView::AdjustDepth( short nDX )
 433 {
 434     Indent( nDX );
 435 }
 436
 437 void OutlinerView::Indent( short nDiff )
 438 {
 439     if( !nDiff || ( ( nDiff > 0 ) && ImpCalcSelectedPages( true ) && !pOwner->ImpCanIndentSelectedPages( this ) ) )
 440         return;
 441
 442     const bool bOutlinerView = bool(pOwner->pEditEngine->GetControlWord() & EEControlBits::OUTLINER);
 443     bool bUpdate = pOwner->pEditEngine->SetUpdateLayout( false );
 444
 445     bool bUndo = !pOwner->IsInUndo() && pOwner->IsUndoEnabled();
 446
 447     if( bUndo )
 448         pOwner->UndoActionStart( OLUNDO_DEPTH );
 449
 450     sal_Int16 nMinDepth = -1;   // Optimization: avoid recalculate too many paragraphs if not really needed.
 451
 452     ParaRange aSel = ImpGetSelectedParagraphs( true );
 453     for ( sal_Int32 nPara = aSel.nStartPara; nPara <= aSel.nEndPara; nPara++ )
 454     {
 455         Paragraph* pPara = pOwner->pParaList->GetParagraph( nPara );
 456
 457         sal_Int16 nOldDepth = pPara->GetDepth();
 458         sal_Int16 nNewDepth = nOldDepth + nDiff;
 459
 460         if( bOutlinerView && nPara )
 461         {
 462             const bool bPage = pPara->HasFlag(ParaFlag::ISPAGE);
 463             if( (bPage && (nDiff == +1)) || (!bPage && (nDiff == -1) && (nOldDepth <= 0))  )
 464             {
 465                             // Notify App
 466                 pOwner->nDepthChangedHdlPrevDepth = nOldDepth;
 467                 ParaFlag nPrevFlags = pPara->nFlags;
 468
 469                 if( bPage )
 470                     pPara->RemoveFlag( ParaFlag::ISPAGE );
 471                 else
 472                     pPara->SetFlag( ParaFlag::ISPAGE );
 473
 474                 pOwner->DepthChangedHdl(pPara, nPrevFlags);
 475                 pOwner->pEditEngine->QuickMarkInvalid( ESelection( nPara, 0, nPara, 0 ) );
 476
 477                 if( bUndo )
 478                     pOwner->InsertUndo( std::make_unique<OutlinerUndoChangeParaFlags>( pOwner, nPara, nPrevFlags, pPara->nFlags ) );
 479
 480                 continue;
 481             }
 482         }
 483
 484         // do not switch off numeration with tab
 485         if( (nOldDepth == 0) && (nNewDepth == -1) )
 486             continue;
 487
 488         // do not indent if there is no numeration enabled
 489         if( nOldDepth == -1 )
 490             continue;
 491
 492         if ( nNewDepth < Outliner::gnMinDepth )
 493             nNewDepth = Outliner::gnMinDepth;
 494         if ( nNewDepth > pOwner->nMaxDepth )
 495             nNewDepth = pOwner->nMaxDepth;
 496
 497         if( nOldDepth < nMinDepth )
 498             nMinDepth = nOldDepth;
 499         if( nNewDepth < nMinDepth )
 500             nMinDepth = nNewDepth;
 501
 502         if( nOldDepth != nNewDepth )
 503         {
 504             if ( ( nPara == aSel.nStartPara ) && aSel.nStartPara && ( pOwner->GetOutlinerMode() != OutlinerMode::TextObject ))
 505             {
 506                 // Special case: the predecessor of an indented paragraph is
 507                 // invisible and is now on the same level as the visible
 508                 // paragraph. In this case, the next visible paragraph is
 509                 // searched for and fluffed.
 510 #ifdef DBG_UTIL
 511                 Paragraph* _pPara = pOwner->pParaList->GetParagraph( aSel.nStartPara );
 512                 DBG_ASSERT(_pPara->IsVisible(),"Selected Paragraph invisible ?!");
 513 #endif
 514                 Paragraph* pPrev= pOwner->pParaList->GetParagraph( aSel.nStartPara-1 );
 515
 516                 if( !pPrev->IsVisible() && ( pPrev->GetDepth() == nNewDepth ) )
 517                 {
 518                     // Predecessor is collapsed and is on the same level
 519                     // => find next visible paragraph and expand it
 520                     pPrev = pOwner->pParaList->GetParent( pPrev );
 521                     while( !pPrev->IsVisible() )
 522                         pPrev = pOwner->pParaList->GetParent( pPrev );
 523
 524                     pOwner->Expand( pPrev );
 525                     pOwner->InvalidateBullet(pOwner->pParaList->GetAbsPos(pPrev));
 526                 }
 527             }
 528
 529             pOwner->nDepthChangedHdlPrevDepth = nOldDepth;
 530             ParaFlag nPrevFlags = pPara->nFlags;
 531
 532             pOwner->ImplInitDepth( nPara, nNewDepth, true );
 533             pOwner->ImplCalcBulletText( nPara, false, false );
 534
 535             if ( pOwner->GetOutlinerMode() == OutlinerMode::OutlineObject )
 536                 pOwner->ImplSetLevelDependentStyleSheet( nPara );
 537
 538             // Notify App
 539             pOwner->DepthChangedHdl(pPara, nPrevFlags);
 540         }
 541         else
 542         {
 543             // Needs at least a repaint...
 544             pOwner->pEditEngine->QuickMarkInvalid( ESelection( nPara, 0, nPara, 0 ) );
 545         }
 546     }
 547
 548     sal_Int32 nParas = pOwner->pParaList->GetParagraphCount();
 549     for ( sal_Int32 n = aSel.nEndPara+1; n < nParas; n++ )
 550     {
 551         Paragraph* pPara = pOwner->pParaList->GetParagraph( n );
 552         if ( pPara->GetDepth() < nMinDepth )
 553             break;
 554         pOwner->ImplCalcBulletText( n, false, false );
 555     }
 556
 557     if ( bUpdate )
 558     {
 559         pEditView->SetEditEngineUpdateLayout( true );
 560         pEditView->ShowCursor();
 561     }
 562
 563     if( bUndo )
 564         pOwner->UndoActionEnd();
 565 }
 566
 567 void OutlinerView::AdjustHeight( tools::Long nDY )
 568 {
 569     pEditView->MoveParagraphs( nDY );
 570 }
 571
 572 tools::Rectangle OutlinerView::GetVisArea() const
 573 {
 574     return pEditView->GetVisArea();
 575 }
 576
 577 void OutlinerView::Expand()
 578 {
 579     ParaRange aParas = ImpGetSelectedParagraphs( false );
 580     ImplExpandOrCollaps( aParas.nStartPara, aParas.nEndPara, true );
 581 }
 582
 583
 584 void OutlinerView::Collapse()
 585 {
 586     ParaRange aParas = ImpGetSelectedParagraphs( false );
 587     ImplExpandOrCollaps( aParas.nStartPara, aParas.nEndPara, false );
 588 }
 589
 590
 591 void OutlinerView::ExpandAll()
 592 {
 593     ImplExpandOrCollaps( 0, pOwner->pParaList->GetParagraphCount()-1, true );
 594 }
 595
 596
 597 void OutlinerView::CollapseAll()
 598 {
 599     ImplExpandOrCollaps( 0, pOwner->pParaList->GetParagraphCount()-1, false );
 600 }
 601
 602 void OutlinerView::ImplExpandOrCollaps( sal_Int32 nStartPara, sal_Int32 nEndPara, bool bExpand )
 603 {
 604     bool bUpdate = pOwner->SetUpdateLayout( false );
 605
 606     bool bUndo = !pOwner->IsInUndo() && pOwner->IsUndoEnabled();
 607     if( bUndo )
 608         pOwner->UndoActionStart( bExpand ? OLUNDO_EXPAND : OLUNDO_COLLAPSE );
 609
 610     for ( sal_Int32 nPara = nStartPara; nPara <= nEndPara; nPara++ )
 611     {
 612         Paragraph* pPara = pOwner->pParaList->GetParagraph( nPara );
 613         bool bDone = bExpand ? pOwner->Expand( pPara ) : pOwner->Collapse( pPara );
 614         if( bDone )
 615         {
 616             // The line under the paragraph should disappear ...
 617             pOwner->pEditEngine->QuickMarkToBeRepainted( nPara );
 618         }
 619     }
 620
 621     if( bUndo )
 622         pOwner->UndoActionEnd();
 623
 624     if ( bUpdate )
 625     {
 626         pOwner->SetUpdateLayout( true );
 627         pEditView->ShowCursor();
 628     }
 629 }
 630
 631 void OutlinerView::InsertText( const OutlinerParaObject& rParaObj )
 632 {
 633     // Like Paste, only EditView::Insert, instead of EditView::Paste.
 634     // Actually not quite true that possible indentations must be corrected,
 635     // but that comes later by a universal import. The indentation level is
 636     // then determined right in the Inserted method.
 637     // Possible structure:
 638     // pImportInfo with DestPara, DestPos, nFormat, pParaObj...
 639     // Possibly problematic:
 640     // EditEngine, RTF => Splitting the area, later join together.
 641
 642     if ( ImpCalcSelectedPages( false ) && !pOwner->ImpCanDeleteSelectedPages( this ) )
 643         return;
 644
 645     pOwner->UndoActionStart( OLUNDO_INSERT );
 646
 647     const bool bPrevUpdateLayout = pOwner->pEditEngine->SetUpdateLayout( false );
 648     sal_Int32 nStart, nParaCount;
 649     nParaCount = pOwner->pEditEngine->GetParagraphCount();
 650     sal_uInt16 nSize = ImpInitPaste( nStart );
 651     pEditView->InsertText( rParaObj.GetTextObject() );
 652     ImpPasted( nStart, nParaCount, nSize);
 653     pEditView->SetEditEngineUpdateLayout( bPrevUpdateLayout );
 654
 655     pOwner->UndoActionEnd();
 656
 657     pEditView->ShowCursor();
 658 }
 659
 660
 661 void OutlinerView::Cut()
 662 {
 663     if ( !ImpCalcSelectedPages( false ) || pOwner->ImpCanDeleteSelectedPages( this ) ) {
 664         pEditView->Cut();
 665         // Chaining handling
 666         aEndCutPasteLink.Call(nullptr);
 667     }
 668 }
 669
 670 void OutlinerView::PasteSpecial()
 671 {
 672     Paste( true );
 673 }
 674
 675 void OutlinerView::Paste( bool bUseSpecial )
 676 {
 677     if ( ImpCalcSelectedPages( false ) && !pOwner->ImpCanDeleteSelectedPages( this ) )
 678         return;
 679
 680     pOwner->UndoActionStart( OLUNDO_INSERT );
 681
 682     const bool bPrevUpdateLayout = pOwner->pEditEngine->SetUpdateLayout( false );
 683     pOwner->bPasting = true;
 684
 685     if ( bUseSpecial )
 686         pEditView->PasteSpecial();
 687     else
 688         pEditView->Paste();
 689
 690     if ( pOwner->GetOutlinerMode() == OutlinerMode::OutlineObject )
 691     {
 692         const sal_Int32 nParaCount = pOwner->pEditEngine->GetParagraphCount();
 693
 694         for( sal_Int32 nPara = 0; nPara < nParaCount; nPara++ )
 695             pOwner->ImplSetLevelDependentStyleSheet( nPara );
 696     }
 697
 698     pEditView->SetEditEngineUpdateLayout( bPrevUpdateLayout );
 699     pOwner->UndoActionEnd();
 700     pEditView->ShowCursor();
 701
 702     // Chaining handling
 703     // NOTE: We need to do this last because it pEditView may be deleted if a switch of box occurs
 704     aEndCutPasteLink.Call(nullptr);
 705 }
 706
 707 void OutlinerView::CreateSelectionList (std::vector<Paragraph*> &aSelList)
 708 {
 709     ParaRange aParas = ImpGetSelectedParagraphs( true );
 710
 711     for ( sal_Int32 nPara = aParas.nStartPara; nPara <= aParas.nEndPara; nPara++ )
 712     {
 713         Paragraph* pPara = pOwner->pParaList->GetParagraph( nPara );
 714         aSelList.push_back(pPara);
 715     }
 716 }
 717
 718 const SfxStyleSheet* OutlinerView::GetStyleSheet() const
 719 {
 720     return pEditView->GetStyleSheet();
 721 }
 722
 723 SfxStyleSheet* OutlinerView::GetStyleSheet()
 724 {
 725     return pEditView->GetStyleSheet();
 726 }
 727
 728 PointerStyle OutlinerView::GetPointer( const Point& rPosPixel )
 729 {
 730     MouseTarget eTarget;
 731     ImpCheckMousePos( rPosPixel, eTarget );
 732
 733     PointerStyle ePointerStyle = PointerStyle::Arrow;
 734     if ( eTarget == MouseTarget::Text )
 735     {
 736         ePointerStyle = GetOutliner()->IsVertical() ? PointerStyle::TextVertical : PointerStyle::Text;
 737     }
 738     else if ( eTarget == MouseTarget::Hypertext )
 739     {
 740         ePointerStyle = PointerStyle::RefHand;
 741     }
 742     else if ( eTarget == MouseTarget::Bullet )
 743     {
 744         ePointerStyle = PointerStyle::Move;
 745     }
 746
 747     return ePointerStyle;
 748 }
 749
 750
 751 sal_Int32 OutlinerView::ImpInitPaste( sal_Int32& rStart )
 752 {
 753     pOwner->bPasting = true;
 754     ESelection aSelection( pEditView->GetSelection() );
 755     aSelection.Adjust();
 756     rStart = aSelection.nStartPara;
 757     sal_Int32 nSize = aSelection.nEndPara - aSelection.nStartPara + 1;
 758     return nSize;
 759 }
 760
 761
 762 void OutlinerView::ImpPasted( sal_Int32 nStart, sal_Int32 nPrevParaCount, sal_Int32 nSize)
 763 {
 764     pOwner->bPasting = false;
 765     sal_Int32 nCurParaCount = pOwner->pEditEngine->GetParagraphCount();
 766     if( nCurParaCount < nPrevParaCount )
 767         nSize = nSize - ( nPrevParaCount - nCurParaCount );
 768     else
 769         nSize = nSize + ( nCurParaCount - nPrevParaCount );
 770     pOwner->ImpTextPasted( nStart, nSize );
 771 }
 772
 773 bool OutlinerView::Command(const CommandEvent& rCEvt)
 774 {
 775     return pEditView->Command(rCEvt);
 776 }
 777
 778 void OutlinerView::SelectRange( sal_Int32 nFirst, sal_Int32 nCount )
 779 {
 780     sal_Int32 nLast = nFirst+nCount;
 781     nCount = pOwner->pParaList->GetParagraphCount();
 782     if( nLast <= nCount )
 783         nLast = nCount - 1;
 784     ESelection aSel( nFirst, 0, nLast, EE_TEXTPOS_ALL );
 785     pEditView->SetSelection( aSel );
 786 }
 787
 788
 789 sal_Int32 OutlinerView::ImpCalcSelectedPages( bool bIncludeFirstSelected )
 790 {
 791     ESelection aSel( pEditView->GetSelection() );
 792     aSel.Adjust();
 793
 794     sal_Int32 nPages = 0;
 795     sal_Int32 nFirstPage = EE_PARA_MAX_COUNT;
 796     sal_Int32 nStartPara = aSel.nStartPara;
 797     if ( !bIncludeFirstSelected )
 798         nStartPara++;   // All paragraphs after StartPara will be deleted
 799     for ( sal_Int32 nPara = nStartPara; nPara <= aSel.nEndPara; nPara++ )
 800     {
 801         Paragraph* pPara = pOwner->pParaList->GetParagraph( nPara );
 802         DBG_ASSERT(pPara, "ImpCalcSelectedPages: invalid Selection? ");
 803         if( pPara->HasFlag(ParaFlag::ISPAGE) )
 804         {
 805             nPages++;
 806             if( nFirstPage == EE_PARA_MAX_COUNT )
 807                 nFirstPage = nPara;
 808         }
 809     }
 810
 811     if( nPages )
 812     {
 813         pOwner->nDepthChangedHdlPrevDepth = nPages;
 814         pOwner->mnFirstSelPage = nFirstPage;
 815     }
 816
 817     return nPages;
 818 }
 819
 820
 821 void OutlinerView::ToggleBullets()
 822 {
 823     pOwner->UndoActionStart( OLUNDO_DEPTH );
 824
 825     ESelection aSel( pEditView->GetSelection() );
 826     aSel.Adjust();
 827
 828     const bool bUpdate = pOwner->pEditEngine->SetUpdateLayout( false );
 829
 830     sal_Int16 nNewDepth = -2;
 831     const SvxNumRule* pDefaultBulletNumRule = nullptr;
 832
 833     for ( sal_Int32 nPara = aSel.nStartPara; nPara <= aSel.nEndPara; nPara++ )
 834     {
 835         Paragraph* pPara = pOwner->pParaList->GetParagraph( nPara );
 836         DBG_ASSERT(pPara, "OutlinerView::ToggleBullets(), illegal selection?");
 837
 838         if( pPara )
 839         {
 840             if( nNewDepth == -2 )
 841             {
 842                 nNewDepth = (pOwner->GetDepth(nPara) == -1) ? 0 : -1;
 843                 if ( nNewDepth == 0 )
 844                 {
 845                     // determine default numbering rule for bullets
 846                     const ESelection aSelection(nPara, 0);
 847                     const SfxItemSet aTmpSet(pOwner->pEditEngine->GetAttribs(aSelection));
 848                     const SfxPoolItem& rPoolItem = aTmpSet.GetPool()->GetDefaultItem( EE_PARA_NUMBULLET );
 849                     const SvxNumBulletItem* pNumBulletItem = dynamic_cast< const SvxNumBulletItem* >(&rPoolItem);
 850                     pDefaultBulletNumRule =  pNumBulletItem ? &pNumBulletItem->GetNumRule() : nullptr;
 851                 }
 852             }
 853
 854             pOwner->SetDepth( pPara, nNewDepth );
 855
 856             if( nNewDepth == -1 )
 857             {
 858                 const SfxItemSet& rAttrs = pOwner->GetParaAttribs( nPara );
 859                 if ( rAttrs.GetItemState( EE_PARA_BULLETSTATE ) == SfxItemState::SET )
 860                 {
 861                     SfxItemSet aAttrs(rAttrs);
 862                     aAttrs.ClearItem( EE_PARA_BULLETSTATE );
 863                     pOwner->SetParaAttribs( nPara, aAttrs );
 864                 }
 865             }
 866             else
 867             {
 868                 if ( pDefaultBulletNumRule )
 869                 {
 870                     const SvxNumberFormat* pFmt = pOwner ->GetNumberFormat( nPara );
 871                     if ( !pFmt
 872                          || ( pFmt->GetNumberingType() != SVX_NUM_BITMAP
 873                               && pFmt->GetNumberingType() != SVX_NUM_CHAR_SPECIAL ) )
 874                     {
 875                         SfxItemSet aAttrs( pOwner->GetParaAttribs( nPara ) );
 876                         SvxNumRule aNewNumRule( *pDefaultBulletNumRule );
 877                         aAttrs.Put( SvxNumBulletItem( std::move(aNewNumRule), EE_PARA_NUMBULLET ) );
 878                         pOwner->SetParaAttribs( nPara, aAttrs );
 879                     }
 880                 }
 881             }
 882         }
 883     }
 884
 885     const sal_Int32 nParaCount = pOwner->pParaList->GetParagraphCount();
 886     pOwner->ImplCheckParagraphs( aSel.nStartPara, nParaCount );
 887
 888     sal_Int32 nEndPara = (nParaCount > 0) ? nParaCount-1 : nParaCount;
 889     pOwner->pEditEngine->QuickMarkInvalid( ESelection( aSel.nStartPara, 0, nEndPara, 0 ) );
 890
 891     pOwner->pEditEngine->SetUpdateLayout( bUpdate );
 892
 893     pOwner->UndoActionEnd();
 894 }
 895
 896
 897 void OutlinerView::ToggleBulletsNumbering(
 898     const bool bToggle,
 899     const bool bHandleBullets,
 900     const SvxNumRule* pNumRule )
 901 {
 902     ESelection aSel( pEditView->GetSelection() );
 903     aSel.Adjust();
 904
 905     bool bToggleOn = true;
 906     if ( bToggle )
 907     {
 908         bToggleOn = false;
 909         const sal_Int16 nBulletNumberingStatus( pOwner->GetBulletsNumberingStatus( aSel.nStartPara, aSel.nEndPara ) );
 910         if ( nBulletNumberingStatus != 0 && bHandleBullets )
 911         {
 912             // not all paragraphs have bullets and method called to toggle bullets --> bullets on
 913             bToggleOn = true;
 914         }
 915         else if ( nBulletNumberingStatus != 1 && !bHandleBullets )
 916         {
 917             // not all paragraphs have numbering and method called to toggle numberings --> numberings on
 918             bToggleOn = true;
 919         }
 920     }
 921     if ( bToggleOn )
 922     {
 923         // apply bullets/numbering for selected paragraphs
 924         ApplyBulletsNumbering( bHandleBullets, pNumRule, bToggle, true );
 925     }
 926     else
 927     {
 928         // switch off bullets/numbering for selected paragraphs
 929         SwitchOffBulletsNumbering( true );
 930     }
 931 }
 932
 933 void OutlinerView::EnsureNumberingIsOn()
 934 {
 935     pOwner->UndoActionStart(OLUNDO_DEPTH);
 936
 937     ESelection aSel(pEditView->GetSelection());
 938     aSel.Adjust();
 939
 940     const bool bUpdate = pOwner->pEditEngine->IsUpdateLayout();
 941     pOwner->pEditEngine->SetUpdateLayout(false);
 942
 943     for (sal_Int32 nPara = aSel.nStartPara; nPara <= aSel.nEndPara; nPara++)
 944     {
 945         Paragraph* pPara = pOwner->pParaList->GetParagraph(nPara);
 946         DBG_ASSERT(pPara, "OutlinerView::EnableBullets(), illegal selection?");
 947
 948         if (pPara && pOwner->GetDepth(nPara) == -1)
 949             pOwner->SetDepth(pPara, 0);
 950     }
 951
 952     sal_Int32 nParaCount = pOwner->pParaList->GetParagraphCount();
 953     pOwner->ImplCheckParagraphs(aSel.nStartPara, nParaCount);
 954
 955     const sal_Int32 nEndPara = (nParaCount > 0) ? nParaCount-1 : nParaCount;
 956     pOwner->pEditEngine->QuickMarkInvalid(ESelection(aSel.nStartPara, 0, nEndPara, 0));
 957
 958     pOwner->pEditEngine->SetUpdateLayout(bUpdate);
 959
 960     pOwner->UndoActionEnd();
 961 }
 962
 963 void OutlinerView::ApplyBulletsNumbering(
 964     const bool bHandleBullets,
 965     const SvxNumRule* pNewNumRule,
 966     const bool bCheckCurrentNumRuleBeforeApplyingNewNumRule,
 967     const bool bAtSelection )
 968 {
 969     if (!pOwner || !pOwner->pEditEngine || !pOwner->pParaList)
 970     {
 971         return;
 972     }
 973
 974     pOwner->UndoActionStart(OLUNDO_DEPTH);
 975     const bool bUpdate = pOwner->pEditEngine->SetUpdateLayout(false);
 976
 977     sal_Int32 nStartPara = 0;
 978     sal_Int32 nEndPara = 0;
 979     if ( bAtSelection )
 980     {
 981         ESelection aSel( pEditView->GetSelection() );
 982         aSel.Adjust();
 983         nStartPara = aSel.nStartPara;
 984         nEndPara = aSel.nEndPara;
 985     }
 986     else
 987     {
 988         nStartPara = 0;
 989         nEndPara = pOwner->pParaList->GetParagraphCount() - 1;
 990     }
 991
 992     for (sal_Int32 nPara = nStartPara; nPara <= nEndPara; ++nPara)
 993     {
 994         Paragraph* pPara = pOwner->pParaList->GetParagraph(nPara);
 995         DBG_ASSERT(pPara, "OutlinerView::ApplyBulletsNumbering(..), illegal selection?");
 996
 997         if (pPara)
 998         {
 999             const sal_Int16 nDepth = pOwner->GetDepth(nPara);
1000             if ( nDepth == -1 )
1001             {
1002                 pOwner->SetDepth( pPara, 0 );
1003             }
1004
1005             const SfxItemSet& rAttrs = pOwner->GetParaAttribs(nPara);
1006             SfxItemSet aAttrs(rAttrs);
1007             aAttrs.Put(SfxBoolItem(EE_PARA_BULLETSTATE, true));
1008
1009             // apply new numbering rule
1010             if ( pNewNumRule )
1011             {
1012                 bool bApplyNumRule = false;
1013                 if ( !bCheckCurrentNumRuleBeforeApplyingNewNumRule )
1014                 {
1015                     bApplyNumRule = true;
1016                 }
1017                 else
1018                 {
1019                     const SvxNumberFormat* pFmt = pOwner ->GetNumberFormat(nPara);
1020                     if (!pFmt)
1021                     {
1022                         bApplyNumRule = true;
1023                     }
1024                     else
1025                     {
1026                         sal_Int16 nNumType = pFmt->GetNumberingType();
1027                         if ( bHandleBullets
1028                              && nNumType != SVX_NUM_BITMAP && nNumType != SVX_NUM_CHAR_SPECIAL)
1029                         {
1030                             // Set to Normal bullet, old bullet type is Numbering bullet.
1031                             bApplyNumRule = true;
1032                         }
1033                         else if ( !bHandleBullets
1034                                   && (nNumType == SVX_NUM_BITMAP || nNumType == SVX_NUM_CHAR_SPECIAL))
1035                         {
1036                             // Set to Numbering bullet, old bullet type is Normal bullet.
1037                             bApplyNumRule = true;
1038                         }
1039                     }
1040                 }
1041
1042                 if ( bApplyNumRule )
1043                 {
1044                     SvxNumRule aNewRule(*pNewNumRule);
1045
1046                     // Get old bullet space.
1047                     {
1048                         const SvxNumBulletItem* pNumBulletItem = rAttrs.GetItemIfSet(EE_PARA_NUMBULLET, false);
1049                         if (pNumBulletItem)
1050                         {
1051                             // Use default value when has not contain bullet item.
1052                             ESelection aSelection(nPara, 0);
1053                             SfxItemSet aTmpSet(pOwner->pEditEngine->GetAttribs(aSelection));
1054                             pNumBulletItem = aTmpSet.GetItem(EE_PARA_NUMBULLET);
1055                         }
1056
1057                         if (pNumBulletItem)
1058                         {
1059                             const sal_uInt16 nLevelCnt = std::min(pNumBulletItem->GetNumRule().GetLevelCount(), aNewRule.GetLevelCount());
1060                             for ( sal_uInt16 nLevel = 0; nLevel < nLevelCnt; ++nLevel )
1061                             {
1062                                 const SvxNumberFormat* pOldFmt = pNumBulletItem->GetNumRule().Get(nLevel);
1063                                 const SvxNumberFormat* pNewFmt = aNewRule.Get(nLevel);
1064                                 if (pOldFmt && pNewFmt && (pOldFmt->GetFirstLineOffset() != pNewFmt->GetFirstLineOffset() || pOldFmt->GetAbsLSpace() != pNewFmt->GetAbsLSpace()))
1065                                 {
1066                                     SvxNumberFormat aNewFmtClone(*pNewFmt);
1067                                     aNewFmtClone.SetFirstLineOffset(pOldFmt->GetFirstLineOffset());
1068                                     aNewFmtClone.SetAbsLSpace(pOldFmt->GetAbsLSpace());
1069                                     aNewRule.SetLevel(nLevel, &aNewFmtClone);
1070                                 }
1071                             }
1072                         }
1073                     }
1074
1075                     aAttrs.Put(SvxNumBulletItem(std::move(aNewRule), EE_PARA_NUMBULLET));
1076                 }
1077             }
1078             pOwner->SetParaAttribs(nPara, aAttrs);
1079         }
1080     }
1081
1082     const sal_uInt16 nParaCount = static_cast<sal_uInt16>(pOwner->pParaList->GetParagraphCount());
1083     pOwner->ImplCheckParagraphs( nStartPara, nParaCount );
1084     pOwner->pEditEngine->QuickMarkInvalid( ESelection( nStartPara, 0, nParaCount, 0 ) );
1085
1086     pOwner->pEditEngine->SetUpdateLayout( bUpdate );
1087
1088     pOwner->UndoActionEnd();
1089 }
1090
1091
1092 void OutlinerView::SwitchOffBulletsNumbering(
1093     const bool bAtSelection )
1094 {
1095     sal_Int32 nStartPara = 0;
1096     sal_Int32 nEndPara = 0;
1097     if ( bAtSelection )
1098     {
1099         ESelection aSel( pEditView->GetSelection() );
1100         aSel.Adjust();
1101         nStartPara = aSel.nStartPara;
1102         nEndPara = aSel.nEndPara;
1103     }
1104     else
1105     {
1106         nStartPara = 0;
1107         nEndPara = pOwner->pParaList->GetParagraphCount() - 1;
1108     }
1109
1110     pOwner->UndoActionStart( OLUNDO_DEPTH );
1111     const bool bUpdate = pOwner->pEditEngine->SetUpdateLayout( false );
1112
1113     for ( sal_Int32 nPara = nStartPara; nPara <= nEndPara; ++nPara )
1114     {
1115         Paragraph* pPara = pOwner->pParaList->GetParagraph( nPara );
1116         DBG_ASSERT(pPara, "OutlinerView::SwitchOffBulletsNumbering(...), illegal paragraph index?");
1117
1118         if( pPara )
1119         {
1120             pOwner->SetDepth( pPara, -1 );
1121
1122             const SfxItemSet& rAttrs = pOwner->GetParaAttribs( nPara );
1123             if (rAttrs.GetItemState( EE_PARA_BULLETSTATE ) == SfxItemState::SET)
1124             {
1125                 SfxItemSet aAttrs(rAttrs);
1126                 aAttrs.ClearItem( EE_PARA_BULLETSTATE );
1127                 pOwner->SetParaAttribs( nPara, aAttrs );
1128             }
1129         }
1130     }
1131
1132     const sal_uInt16 nParaCount = static_cast<sal_uInt16>(pOwner->pParaList->GetParagraphCount());
1133     pOwner->ImplCheckParagraphs( nStartPara, nParaCount );
1134     pOwner->pEditEngine->QuickMarkInvalid( ESelection( nStartPara, 0, nParaCount, 0 ) );
1135
1136     pOwner->pEditEngine->SetUpdateLayout( bUpdate );
1137     pOwner->UndoActionEnd();
1138 }
1139
1140
1141 void OutlinerView::RemoveAttribsKeepLanguages( bool bRemoveParaAttribs )
1142 {
1143     RemoveAttribs( bRemoveParaAttribs, true /*keep language attribs*/ );
1144 }
1145
1146 void OutlinerView::RemoveAttribs( bool bRemoveParaAttribs, bool bKeepLanguages )
1147 {
1148     bool bUpdate = pOwner->SetUpdateLayout( false );
1149     pOwner->UndoActionStart( OLUNDO_ATTR );
1150     if (bKeepLanguages)
1151         pEditView->RemoveAttribsKeepLanguages( bRemoveParaAttribs );
1152     else
1153         pEditView->RemoveAttribs( bRemoveParaAttribs );
1154     if ( bRemoveParaAttribs )
1155     {
1156         // Loop through all paragraphs and set indentation and level
1157         ESelection aSel = pEditView->GetSelection();
1158         aSel.Adjust();
1159         for ( sal_Int32 nPara = aSel.nStartPara; nPara <= aSel.nEndPara; nPara++ )
1160         {
1161             Paragraph* pPara = pOwner->pParaList->GetParagraph( nPara );
1162             pOwner->ImplInitDepth( nPara, pPara->GetDepth(), false );
1163         }
1164     }
1165     pOwner->UndoActionEnd();
1166     pOwner->SetUpdateLayout( bUpdate );
1167 }
1168
1169
1170 // ======================   Simple pass-through   =======================
1171
1172
1173 void OutlinerView::InsertText( const OUString& rNew, bool bSelect )
1174 {
1175     if( pOwner->bFirstParaIsEmpty )
1176         pOwner->Insert( OUString() );
1177     pEditView->InsertText( rNew, bSelect );
1178 }
1179
1180 void OutlinerView::SetVisArea( const tools::Rectangle& rRect )
1181 {
1182     pEditView->SetVisArea( rRect );
1183 }
1184
1185
1186 void OutlinerView::SetSelection( const ESelection& rSel )
1187 {
1188     pEditView->SetSelection( rSel );
1189 }
1190
1191 void OutlinerView::GetSelectionRectangles(std::vector<tools::Rectangle>& rLogicRects) const
1192 {
1193     pEditView->GetSelectionRectangles(rLogicRects);
1194 }
1195
1196 void OutlinerView::SetReadOnly( bool bReadOnly )
1197 {
1198     pEditView->SetReadOnly( bReadOnly );
1199 }
1200
1201 bool OutlinerView::IsReadOnly() const
1202 {
1203     return pEditView->IsReadOnly();
1204 }
1205
1206 bool OutlinerView::HasSelection() const
1207 {
1208     return pEditView->HasSelection();
1209 }
1210
1211 void OutlinerView::ShowCursor( bool bGotoCursor, bool bActivate )
1212 {
1213     pEditView->ShowCursor( bGotoCursor, /*bForceVisCursor=*/true, bActivate );
1214 }
1215
1216 void OutlinerView::HideCursor(bool bDeactivate)
1217 {
1218     pEditView->HideCursor(bDeactivate);
1219 }
1220
1221 void OutlinerView::SetWindow( vcl::Window* pWin )
1222 {
1223     pEditView->SetWindow( pWin );
1224 }
1225
1226 vcl::Window* OutlinerView::GetWindow() const
1227 {
1228     return pEditView->GetWindow();
1229 }
1230
1231 void OutlinerView::SetOutputArea( const tools::Rectangle& rRect )
1232 {
1233     pEditView->SetOutputArea( rRect );
1234 }
1235
1236 tools::Rectangle const & OutlinerView::GetOutputArea() const
1237 {
1238     return pEditView->GetOutputArea();
1239 }
1240
1241 OUString OutlinerView::GetSelected() const
1242 {
1243     return pEditView->GetSelected();
1244 }
1245
1246 void OutlinerView::StartSpeller(weld::Widget* pDialogParent)
1247 {
1248     pEditView->StartSpeller(pDialogParent);
1249 }
1250
1251 EESpellState OutlinerView::StartThesaurus(weld::Widget* pDialogParent)
1252 {
1253     return pEditView->StartThesaurus(pDialogParent);
1254 }
1255
1256 void OutlinerView::StartTextConversion(weld::Widget* pDialogParent,
1257     LanguageType nSrcLang, LanguageType nDestLang, const vcl::Font *pDestFont,
1258     sal_Int32 nOptions, bool bIsInteractive, bool bMultipleDoc )
1259 {
1260     if (
1261         (LANGUAGE_KOREAN == nSrcLang && LANGUAGE_KOREAN == nDestLang) ||
1262         (LANGUAGE_CHINESE_SIMPLIFIED  == nSrcLang && LANGUAGE_CHINESE_TRADITIONAL == nDestLang) ||
1263         (LANGUAGE_CHINESE_TRADITIONAL == nSrcLang && LANGUAGE_CHINESE_SIMPLIFIED  == nDestLang)
1264        )
1265     {
1266         pEditView->StartTextConversion(pDialogParent, nSrcLang, nDestLang, pDestFont, nOptions, bIsInteractive, bMultipleDoc);
1267     }
1268     else
1269     {
1270         OSL_FAIL( "unexpected language" );
1271     }
1272 }
1273
1274
1275 sal_Int32 OutlinerView::StartSearchAndReplace( const SvxSearchItem& rSearchItem )
1276 {
1277     return pEditView->StartSearchAndReplace( rSearchItem );
1278 }
1279
1280 void OutlinerView::TransliterateText( TransliterationFlags nTransliterationMode )
1281 {
1282     pEditView->TransliterateText( nTransliterationMode );
1283 }
1284
1285 ESelection OutlinerView::GetSelection() const
1286 {
1287     return pEditView->GetSelection();
1288 }
1289
1290
1291 void OutlinerView::Scroll( tools::Long nHorzScroll, tools::Long nVertScroll )
1292 {
1293     pEditView->Scroll( nHorzScroll, nVertScroll );
1294 }
1295
1296 void OutlinerView::SetControlWord( EVControlBits nWord )
1297 {
1298     pEditView->SetControlWord( nWord );
1299 }
1300
1301 EVControlBits OutlinerView::GetControlWord() const
1302 {
1303     return pEditView->GetControlWord();
1304 }
1305
1306 void OutlinerView::SetAnchorMode( EEAnchorMode eMode )
1307 {
1308     pEditView->SetAnchorMode( eMode );
1309 }
1310
1311 EEAnchorMode OutlinerView::GetAnchorMode() const
1312 {
1313     return pEditView->GetAnchorMode();
1314 }
1315
1316 void OutlinerView::Copy()
1317 {
1318     pEditView->Copy();
1319 }
1320
1321 void OutlinerView::InsertField( const SvxFieldItem& rFld )
1322 {
1323     pEditView->InsertField( rFld );
1324 }
1325
1326 const SvxFieldItem* OutlinerView::GetFieldUnderMousePointer() const
1327 {
1328     return pEditView->GetFieldUnderMousePointer();
1329 }
1330
1331 const SvxFieldItem* OutlinerView::GetFieldAtSelection() const
1332 {
1333     return pEditView->GetFieldAtSelection();
1334 }
1335
1336 const SvxFieldData* OutlinerView::GetFieldAtCursor() const
1337 {
1338     return pEditView->GetFieldAtCursor();
1339 }
1340
1341 void OutlinerView::SelectFieldAtCursor()
1342 {
1343     pEditView->SelectFieldAtCursor();
1344 }
1345
1346 void OutlinerView::SetInvalidateMore( sal_uInt16 nPixel )
1347 {
1348     pEditView->SetInvalidateMore( nPixel );
1349 }
1350
1351
1352 sal_uInt16 OutlinerView::GetInvalidateMore() const
1353 {
1354     return pEditView->GetInvalidateMore();
1355 }
1356
1357
1358 bool OutlinerView::IsCursorAtWrongSpelledWord()
1359 {
1360     return pEditView->IsCursorAtWrongSpelledWord();
1361 }
1362
1363
1364 bool OutlinerView::IsWrongSpelledWordAtPos( const Point& rPosPixel )
1365 {
1366     return pEditView->IsWrongSpelledWordAtPos( rPosPixel, /*bMarkIfWrong*/false );
1367 }
1368
1369 void OutlinerView::ExecuteSpellPopup(const Point& rPosPixel, const Link<SpellCallbackInfo&,void>& rStartDlg)
1370 {
1371     pEditView->ExecuteSpellPopup(rPosPixel, rStartDlg);
1372 }
1373
1374 void OutlinerView::Read( SvStream& rInput, EETextFormat eFormat, SvKeyValueIterator* pHTTPHeaderAttrs )
1375 {
1376     sal_Int32 nOldParaCount = pEditView->GetEditEngine()->GetParagraphCount();
1377     ESelection aOldSel = pEditView->GetSelection();
1378     aOldSel.Adjust();
1379
1380     pEditView->Read( rInput, eFormat, pHTTPHeaderAttrs );
1381
1382     tools::Long nParaDiff = pEditView->GetEditEngine()->GetParagraphCount() - nOldParaCount;
1383     sal_Int32 nChangesStart = aOldSel.nStartPara;
1384     sal_Int32 nChangesEnd = nChangesStart + nParaDiff + (aOldSel.nEndPara-aOldSel.nStartPara);
1385
1386     for ( sal_Int32 n = nChangesStart; n <= nChangesEnd; n++ )
1387     {
1388         if ( pOwner->GetOutlinerMode() == OutlinerMode::OutlineObject )
1389             pOwner->ImplSetLevelDependentStyleSheet( n );
1390     }
1391
1392     pOwner->ImpFilterIndents( nChangesStart, nChangesEnd );
1393 }
1394
1395 void OutlinerView::SetBackgroundColor( const Color& rColor )
1396 {
1397     pEditView->SetBackgroundColor( rColor );
1398 }
1399
1400 void OutlinerView::RegisterViewShell(OutlinerViewShell* pViewShell)
1401 {
1402     pEditView->RegisterViewShell(pViewShell);
1403 }
1404
1405 Color const & OutlinerView::GetBackgroundColor() const
1406 {
1407     return pEditView->GetBackgroundColor();
1408 }
1409
1410 SfxItemSet OutlinerView::GetAttribs()
1411 {
1412     return pEditView->GetAttribs();
1413 }
1414
1415 SvtScriptType OutlinerView::GetSelectedScriptType() const
1416 {
1417     return pEditView->GetSelectedScriptType();
1418 }
1419
1420 OUString OutlinerView::GetSurroundingText() const
1421 {
1422     return pEditView->GetSurroundingText();
1423 }
1424
1425 Selection OutlinerView::GetSurroundingTextSelection() const
1426 {
1427     return pEditView->GetSurroundingTextSelection();
1428 }
1429
1430 bool OutlinerView::DeleteSurroundingText(const Selection& rSelection)
1431 {
1432     return pEditView->DeleteSurroundingText(rSelection);
1433 }
1434
1435 // ===== some code for thesaurus sub menu within context menu
1436
1437 namespace {
1438
1439 bool isSingleScriptType( SvtScriptType nScriptType )
1440 {
1441     sal_uInt8 nScriptCount = 0;
1442
1443     if (nScriptType & SvtScriptType::LATIN)
1444         ++nScriptCount;
1445     if (nScriptType & SvtScriptType::ASIAN)
1446         ++nScriptCount;
1447     if (nScriptType & SvtScriptType::COMPLEX)
1448         ++nScriptCount;
1449
1450     return nScriptCount == 1;
1451 }
1452
1453 }
1454
1455 // returns: true if a word for thesaurus look-up was found at the current cursor position.
1456 // The status string will be word + iso language string (e.g. "light#en-US")
1457 bool GetStatusValueForThesaurusFromContext(
1458     OUString &rStatusVal,
1459     LanguageType &rLang,
1460     const EditView &rEditView )
1461 {
1462     // get text and locale for thesaurus look up
1463     OUString aText;
1464     EditEngine *pEditEngine = rEditView.GetEditEngine();
1465     ESelection aTextSel( rEditView.GetSelection() );
1466     if (!aTextSel.HasRange())
1467         aTextSel = pEditEngine->GetWord( aTextSel, i18n::WordType::DICTIONARY_WORD );
1468     aText = pEditEngine->GetText( aTextSel );
1469     aTextSel.Adjust();
1470
1471     if (!isSingleScriptType(pEditEngine->GetScriptType(aTextSel)))
1472         return false;
1473
1474     LanguageType nLang = pEditEngine->GetLanguage( aTextSel.nStartPara, aTextSel.nStartPos ).nLang;
1475     OUString aLangText( LanguageTag::convertToBcp47( nLang ) );
1476
1477     // set word and locale to look up as status value
1478     rStatusVal  = aText + "#" + aLangText;
1479     rLang       = nLang;
1480
1481     return aText.getLength() > 0;
1482 }
1483
1484
1485 void ReplaceTextWithSynonym( EditView &rEditView, const OUString &rSynonmText )
1486 {
1487     // get selection to use
1488     ESelection aCurSel( rEditView.GetSelection() );
1489     if (!rEditView.HasSelection())
1490     {
1491         // select the same word that was used in GetStatusValueForThesaurusFromContext by calling GetWord.
1492         // (In the end both functions will call ImpEditEngine::SelectWord)
1493         rEditView.SelectCurrentWord( i18n::WordType::DICTIONARY_WORD );
1494         aCurSel = rEditView.GetSelection();
1495     }
1496
1497     // replace word ...
1498     rEditView.InsertText( rSynonmText );
1499     rEditView.ShowCursor( true, false );
1500 }
1501
1502
1503 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */