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