editeng/source/outliner/outlin2.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
  21 #include <editeng/editeng.hxx>
  22 #include <editeng/editview.hxx>
  23 #include <editeng/editdata.hxx>
  24 #include <editeng/editund2.hxx>
  25
  26 #include <svl/style.hxx>
  27 #include <vcl/mapmod.hxx>
  28
  29 #include <editeng/forbiddencharacterstable.hxx>
  30
  31 #include <editeng/outliner.hxx>
  32 #include "paralist.hxx"
  33 #include <outleeng.hxx>
  34 #include <editeng/editstat.hxx>
  35
  36
  37 using namespace ::com::sun::star::uno;
  38 using namespace ::com::sun::star::linguistic2;
  39
  40
  41 // ======================   Simple pass-through   =======================
  42
  43
  44 bool Outliner::SetUpdateLayout( bool bUpdate )
  45 {
  46     return pEditEngine->SetUpdateLayout( bUpdate );
  47 }
  48
  49
  50 bool Outliner::IsUpdateLayout() const
  51 {
  52     return pEditEngine->IsUpdateLayout();
  53 }
  54
  55 const SfxItemSet& Outliner::GetEmptyItemSet() const
  56 {
  57     return pEditEngine->GetEmptyItemSet();
  58 }
  59
  60 void Outliner::EnableUndo( bool bEnable )
  61 {
  62     pEditEngine->EnableUndo( bEnable );
  63 }
  64
  65 bool Outliner::IsUndoEnabled() const
  66 {
  67     return pEditEngine->IsUndoEnabled();
  68 }
  69
  70 MapMode const & Outliner::GetRefMapMode() const
  71 {
  72     return pEditEngine->GetRefMapMode();
  73 }
  74
  75 void Outliner::SetRefMapMode( const MapMode& rMMode )
  76 {
  77     pEditEngine->SetRefMapMode( rMMode );
  78 }
  79
  80 void Outliner::SetBackgroundColor( const Color& rColor )
  81 {
  82     pEditEngine->SetBackgroundColor( rColor );
  83 }
  84
  85 Color const & Outliner::GetBackgroundColor() const
  86 {
  87     return pEditEngine->GetBackgroundColor();
  88 }
  89
  90
  91 void Outliner::ClearModifyFlag()
  92 {
  93     pEditEngine->ClearModifyFlag();
  94 }
  95
  96 bool Outliner::IsModified() const
  97 {
  98     return pEditEngine->IsModified();
  99 }
 100
 101 sal_uInt32 Outliner::GetTextHeight() const
 102 {
 103     return pEditEngine->GetTextHeight();
 104 }
 105
 106 void Outliner::SetModifyHdl( const Link<LinkParamNone*,void>& rLink )
 107 {
 108     pEditEngine->SetModifyHdl( rLink );
 109 }
 110
 111 void Outliner::SetNotifyHdl( const Link<EENotify&,void>& rLink )
 112 {
 113     pEditEngine->aOutlinerNotifyHdl = rLink;
 114
 115     if ( rLink.IsSet() )
 116         pEditEngine->SetNotifyHdl( LINK( this, Outliner, EditEngineNotifyHdl ) );
 117     else
 118         pEditEngine->SetNotifyHdl( Link<EENotify&,void>() );
 119 }
 120
 121 void Outliner::SetStatusEventHdl( const Link<EditStatus&, void>& rLink )
 122 {
 123     pEditEngine->SetStatusEventHdl( rLink );
 124 }
 125
 126 Link<EditStatus&, void> const & Outliner::GetStatusEventHdl() const
 127 {
 128     return pEditEngine->GetStatusEventHdl();
 129 }
 130
 131 void Outliner::SetDefTab( sal_uInt16 nTab )
 132 {
 133     pEditEngine->SetDefTab( nTab );
 134 }
 135
 136 bool Outliner::IsFlatMode() const
 137 {
 138     return pEditEngine->IsFlatMode();
 139 }
 140
 141 bool Outliner::UpdateFields()
 142 {
 143     return pEditEngine->UpdateFields();
 144 }
 145
 146 void Outliner::RemoveFields( const std::function<bool ( const SvxFieldData* )>& isFieldData )
 147 {
 148     pEditEngine->RemoveFields( isFieldData );
 149 }
 150
 151 void Outliner::SetWordDelimiters( const OUString& rDelimiters )
 152 {
 153     pEditEngine->SetWordDelimiters( rDelimiters );
 154 }
 155
 156 OUString const & Outliner::GetWordDelimiters() const
 157 {
 158     return pEditEngine->GetWordDelimiters();
 159 }
 160
 161 OUString Outliner::GetWord( sal_Int32 nPara, sal_Int32 nIndex )
 162 {
 163     return pEditEngine->GetWord( nPara, nIndex );
 164 }
 165
 166 void Outliner::Draw( OutputDevice& rOutDev, const tools::Rectangle& rOutRect )
 167 {
 168     pEditEngine->Draw( rOutDev, rOutRect );
 169 }
 170
 171 void Outliner::Draw( OutputDevice& rOutDev, const Point& rStartPos )
 172 {
 173     pEditEngine->Draw( rOutDev, rStartPos );
 174 }
 175
 176 void Outliner::SetPaperSize( const Size& rSize )
 177 {
 178     pEditEngine->SetPaperSize( rSize );
 179 }
 180
 181 const Size& Outliner::GetPaperSize() const
 182 {
 183     return pEditEngine->GetPaperSize();
 184 }
 185
 186 void Outliner::SetPolygon( const basegfx::B2DPolyPolygon& rPolyPolygon )
 187 {
 188     pEditEngine->SetPolygon( rPolyPolygon );
 189 }
 190
 191 void Outliner::SetPolygon( const basegfx::B2DPolyPolygon& rPolyPolygon, const basegfx::B2DPolyPolygon* pLinePolyPolygon)
 192 {
 193     pEditEngine->SetPolygon( rPolyPolygon, pLinePolyPolygon);
 194 }
 195
 196 void Outliner::ClearPolygon()
 197 {
 198     pEditEngine->ClearPolygon();
 199 }
 200
 201 const Size& Outliner::GetMinAutoPaperSize() const
 202 {
 203     return pEditEngine->GetMinAutoPaperSize();
 204 }
 205
 206 void Outliner::SetMinAutoPaperSize( const Size& rSz )
 207 {
 208     pEditEngine->SetMinAutoPaperSize( rSz );
 209 }
 210
 211 const Size& Outliner::GetMaxAutoPaperSize() const
 212 {
 213     return pEditEngine->GetMaxAutoPaperSize();
 214 }
 215
 216 void Outliner::SetMaxAutoPaperSize( const Size& rSz )
 217 {
 218     pEditEngine->SetMaxAutoPaperSize( rSz );
 219 }
 220
 221 void Outliner::SetMinColumnWrapHeight(tools::Long nVal)
 222 {
 223     pEditEngine->SetMinColumnWrapHeight(nVal);
 224 }
 225
 226 bool Outliner::IsExpanded( Paragraph const * pPara ) const
 227 {
 228     return pParaList->HasVisibleChildren( pPara );
 229 }
 230
 231 Paragraph* Outliner::GetParent( Paragraph const * pParagraph ) const
 232 {
 233     return pParaList->GetParent( pParagraph );
 234 }
 235
 236 sal_Int32 Outliner::GetChildCount( Paragraph const * pParent ) const
 237 {
 238     return pParaList->GetChildCount( pParent );
 239 }
 240
 241 Size Outliner::CalcTextSize()
 242 {
 243     return Size(pEditEngine->CalcTextWidth(),pEditEngine->GetTextHeight());
 244 }
 245
 246 Size Outliner::CalcTextSizeNTP()
 247 {
 248     return Size(pEditEngine->CalcTextWidth(),pEditEngine->GetTextHeightNTP());
 249 }
 250
 251 void Outliner::SetStyleSheetPool( SfxStyleSheetPool* pSPool )
 252 {
 253     pEditEngine->SetStyleSheetPool( pSPool );
 254 }
 255
 256 SfxStyleSheetPool* Outliner::GetStyleSheetPool()
 257 {
 258     return pEditEngine->GetStyleSheetPool();
 259 }
 260
 261 SfxStyleSheet* Outliner::GetStyleSheet( sal_Int32 nPara )
 262 {
 263     return pEditEngine->GetStyleSheet( nPara );
 264 }
 265
 266 bool Outliner::IsInSelectionMode() const
 267 {
 268     return pEditEngine->IsInSelectionMode();
 269 }
 270
 271 void Outliner::SetControlWord( EEControlBits nWord )
 272 {
 273     pEditEngine->SetControlWord( nWord );
 274 }
 275
 276 EEControlBits Outliner::GetControlWord() const
 277 {
 278     return pEditEngine->GetControlWord();
 279 }
 280
 281 void Outliner::SetAsianCompressionMode( CharCompressType n )
 282 {
 283     pEditEngine->SetAsianCompressionMode( n );
 284 }
 285
 286 void Outliner::SetKernAsianPunctuation( bool b )
 287 {
 288     pEditEngine->SetKernAsianPunctuation( b );
 289 }
 290
 291 void Outliner::SetAddExtLeading( bool bExtLeading )
 292 {
 293     pEditEngine->SetAddExtLeading( bExtLeading );
 294 }
 295
 296 void Outliner::UndoActionStart( sal_uInt16 nId )
 297 {
 298     pEditEngine->UndoActionStart( nId );
 299 }
 300
 301 void Outliner::UndoActionEnd()
 302 {
 303     pEditEngine->UndoActionEnd();
 304 }
 305
 306 void Outliner::InsertUndo( std::unique_ptr<EditUndo> pUndo )
 307 {
 308     pEditEngine->GetUndoManager().AddUndoAction( std::move(pUndo) );
 309 }
 310
 311 bool Outliner::IsInUndo() const
 312 {
 313     return pEditEngine->IsInUndo();
 314 }
 315
 316 sal_uInt32 Outliner::GetLineCount( sal_Int32 nParagraph ) const
 317 {
 318     return pEditEngine->GetLineCount( nParagraph );
 319 }
 320
 321 sal_Int32 Outliner::GetLineLen( sal_Int32 nParagraph, sal_Int32 nLine ) const
 322 {
 323     return pEditEngine->GetLineLen( nParagraph, nLine );
 324 }
 325
 326 sal_uInt32 Outliner::GetLineHeight( sal_Int32 nParagraph )
 327 {
 328     return pEditEngine->GetLineHeight( nParagraph );
 329 }
 330
 331 void Outliner::RemoveCharAttribs( sal_Int32 nPara, sal_uInt16 nWhich )
 332 {
 333     pEditEngine->RemoveCharAttribs( nPara, nWhich );
 334 }
 335
 336 EESpellState Outliner::HasSpellErrors()
 337 {
 338     return pEditEngine->HasSpellErrors();
 339 }
 340
 341 bool Outliner::HasConvertibleTextPortion( LanguageType nLang )
 342 {
 343     return pEditEngine->HasConvertibleTextPortion( nLang );
 344 }
 345
 346 bool Outliner::ConvertNextDocument()
 347 {
 348     return false;
 349 }
 350
 351 void Outliner::SetDefaultLanguage( LanguageType eLang )
 352 {
 353     pEditEngine->SetDefaultLanguage( eLang );
 354 }
 355
 356 void Outliner::CompleteOnlineSpelling()
 357 {
 358     pEditEngine->CompleteOnlineSpelling();
 359 }
 360
 361 bool Outliner::HasText( const SvxSearchItem& rSearchItem )
 362 {
 363     return pEditEngine->HasText( rSearchItem );
 364 }
 365
 366 void Outliner::SetEditTextObjectPool( SfxItemPool* pPool )
 367 {
 368     pEditEngine->SetEditTextObjectPool( pPool );
 369 }
 370
 371 SfxItemPool* Outliner::GetEditTextObjectPool() const
 372 {
 373     return pEditEngine->GetEditTextObjectPool();
 374 }
 375
 376 bool Outliner::SpellNextDocument()
 377 {
 378     return false;
 379 }
 380
 381
 382 void Outliner::SetSpeller( Reference< XSpellChecker1 > const &xSpeller )
 383 {
 384     pEditEngine->SetSpeller( xSpeller );
 385 }
 386
 387 Reference< XSpellChecker1 > const & Outliner::GetSpeller()
 388 {
 389     return pEditEngine->GetSpeller();
 390 }
 391
 392 void Outliner::SetForbiddenCharsTable(const std::shared_ptr<SvxForbiddenCharactersTable>& xForbiddenChars)
 393 {
 394     EditEngine::SetForbiddenCharsTable(xForbiddenChars);
 395 }
 396
 397 void Outliner::SetHyphenator( Reference< XHyphenator > const & xHyph )
 398 {
 399     pEditEngine->SetHyphenator( xHyph );
 400 }
 401
 402 OutputDevice* Outliner::GetRefDevice() const
 403 {
 404     return pEditEngine->GetRefDevice();
 405 }
 406
 407 tools::Rectangle Outliner::GetParaBounds( sal_Int32 nParagraph ) const
 408 {
 409     return pEditEngine->GetParaBounds(nParagraph );
 410 }
 411
 412 Point Outliner::GetDocPos( const Point& rPaperPos ) const
 413 {
 414     return pEditEngine->GetDocPos( rPaperPos );
 415 }
 416
 417 bool Outliner::IsTextPos( const Point& rPaperPos, sal_uInt16 nBorder )
 418 {
 419     return IsTextPos( rPaperPos, nBorder, nullptr );
 420 }
 421
 422 bool Outliner::IsTextPos( const Point& rPaperPos, sal_uInt16 nBorder, bool* pbBullet )
 423 {
 424     if ( pbBullet)
 425         *pbBullet = false;
 426     bool bTextPos = pEditEngine->IsTextPos( rPaperPos, nBorder );
 427     if ( !bTextPos )
 428     {
 429         Point aDocPos = GetDocPos( rPaperPos );
 430         sal_Int32 nPara = pEditEngine->FindParagraph( aDocPos.Y() );
 431         if ( ( nPara != EE_PARA_NOT_FOUND ) && ImplHasNumberFormat( nPara ) )
 432         {
 433             tools::Rectangle aBulArea = ImpCalcBulletArea( nPara, true, true );
 434             if ( aBulArea.Contains( rPaperPos ) )
 435             {
 436                 bTextPos = true;
 437                 if ( pbBullet)
 438                     *pbBullet = true;
 439             }
 440         }
 441     }
 442
 443     return bTextPos;
 444 }
 445
 446 void Outliner::QuickSetAttribs( const SfxItemSet& rSet, const ESelection& rSel )
 447 {
 448     pEditEngine->QuickSetAttribs( rSet, rSel );
 449 }
 450
 451 void Outliner::QuickInsertText( const OUString& rText, const ESelection& rSel )
 452 {
 453     bFirstParaIsEmpty = false;
 454     pEditEngine->QuickInsertText( rText, rSel );
 455 }
 456
 457 void Outliner::QuickDelete( const ESelection& rSel )
 458 {
 459     bFirstParaIsEmpty = false;
 460     pEditEngine->QuickDelete( rSel );
 461 }
 462
 463 void Outliner::QuickInsertField( const SvxFieldItem& rFld, const ESelection& rSel )
 464 {
 465     bFirstParaIsEmpty = false;
 466     pEditEngine->QuickInsertField( rFld, rSel );
 467 }
 468
 469 void Outliner::QuickInsertLineBreak( const ESelection& rSel )
 470 {
 471     bFirstParaIsEmpty = false;
 472     pEditEngine->QuickInsertLineBreak( rSel );
 473 }
 474
 475 void Outliner::QuickFormatDoc()
 476 {
 477     pEditEngine->QuickFormatDoc();
 478 }
 479
 480 ScalingParameters Outliner::getScalingParameters() const
 481 {
 482     return pEditEngine->getScalingParameters();
 483 }
 484
 485 void Outliner::setScalingParameters(ScalingParameters const& rScalingParameters)
 486 {
 487     // reset bullet size
 488     sal_Int32 nParagraphs = pParaList->GetParagraphCount();
 489     for ( sal_Int32 nPara = 0; nPara < nParagraphs; nPara++ )
 490     {
 491         Paragraph* pPara = pParaList->GetParagraph( nPara );
 492         if ( pPara )
 493             pPara->aBulSize.setWidth( -1 );
 494     }
 495
 496     pEditEngine->setScalingParameters(rScalingParameters);
 497 }
 498
 499 void Outliner::setRoundFontSizeToPt(bool bRound) const
 500 {
 501     pEditEngine->setRoundFontSizeToPt(bRound);
 502 }
 503
 504 void Outliner::EraseVirtualDevice()
 505 {
 506     pEditEngine->EraseVirtualDevice();
 507 }
 508
 509 bool Outliner::ShouldCreateBigTextObject() const
 510 {
 511     return pEditEngine->ShouldCreateBigTextObject();
 512 }
 513
 514 const EditEngine& Outliner::GetEditEngine() const
 515 {
 516     return *pEditEngine;
 517 }
 518
 519 void Outliner::SetVertical(bool bVertical)
 520 {
 521     pEditEngine->SetVertical(bVertical);
 522 }
 523
 524 void Outliner::SetRotation(TextRotation nRotation)
 525 {
 526     pEditEngine->SetRotation(nRotation);
 527 }
 528
 529 bool Outliner::IsVertical() const
 530 {
 531     return pEditEngine->IsEffectivelyVertical();
 532 }
 533
 534 bool Outliner::IsTopToBottom() const
 535 {
 536     return pEditEngine->IsTopToBottom();
 537 }
 538
 539 void Outliner::SetTextColumns(sal_Int16 nColumns, sal_Int32 nSpacing)
 540 {
 541     pEditEngine->SetTextColumns(nColumns, nSpacing);
 542 }
 543
 544 void Outliner::SetFixedCellHeight( bool bUseFixedCellHeight )
 545 {
 546     pEditEngine->SetFixedCellHeight( bUseFixedCellHeight );
 547 }
 548
 549 void Outliner::SetDefaultHorizontalTextDirection( EEHorizontalTextDirection eHTextDir )
 550 {
 551     pEditEngine->SetDefaultHorizontalTextDirection( eHTextDir );
 552 }
 553
 554 EEHorizontalTextDirection Outliner::GetDefaultHorizontalTextDirection() const
 555 {
 556     return pEditEngine->GetDefaultHorizontalTextDirection();
 557 }
 558
 559 LanguageType Outliner::GetLanguage( sal_Int32 nPara, sal_Int32 nPos ) const
 560 {
 561     return pEditEngine->GetLanguage( nPara, nPos ).nLang;
 562 }
 563
 564 void Outliner::RemoveAttribs( const ESelection& rSelection, bool bRemoveParaAttribs, sal_uInt16 nWhich )
 565 {
 566     pEditEngine->RemoveAttribs( rSelection, bRemoveParaAttribs, nWhich );
 567 }
 568
 569 void Outliner::EnableAutoColor( bool b )
 570 {
 571     pEditEngine->EnableAutoColor( b );
 572 }
 573
 574 void Outliner::ForceAutoColor( bool b )
 575 {
 576     pEditEngine->ForceAutoColor( b );
 577 }
 578
 579 bool Outliner::IsForceAutoColor() const
 580 {
 581     return pEditEngine->IsForceAutoColor();
 582 }
 583
 584 bool Outliner::SpellSentence(EditView const & rEditView, svx::SpellPortions& rToFill )
 585 {
 586     return pEditEngine->SpellSentence(rEditView, rToFill );
 587 }
 588
 589 void Outliner::PutSpellingToSentenceStart( EditView const & rEditView )
 590 {
 591     pEditEngine->PutSpellingToSentenceStart( rEditView );
 592 }
 593
 594 void Outliner::ApplyChangedSentence(EditView const & rEditView, const svx::SpellPortions& rNewPortions, bool bRecheck )
 595 {
 596     pEditEngine->ApplyChangedSentence( rEditView, rNewPortions, bRecheck );
 597 }
 598
 599 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */