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(const EPaM& rPos)
 162 {
 163     return pEditEngine->GetWord(rPos);
 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 void Outliner::SetStyleSheetPool( SfxStyleSheetPool* pSPool )
 247 {
 248     pEditEngine->SetStyleSheetPool( pSPool );
 249 }
 250
 251 SfxStyleSheetPool* Outliner::GetStyleSheetPool()
 252 {
 253     return pEditEngine->GetStyleSheetPool();
 254 }
 255
 256 SfxStyleSheet* Outliner::GetStyleSheet( sal_Int32 nPara )
 257 {
 258     return pEditEngine->GetStyleSheet( nPara );
 259 }
 260
 261 bool Outliner::IsInSelectionMode() const
 262 {
 263     return pEditEngine->IsInSelectionMode();
 264 }
 265
 266 void Outliner::SetControlWord( EEControlBits nWord )
 267 {
 268     pEditEngine->SetControlWord( nWord );
 269 }
 270
 271 EEControlBits Outliner::GetControlWord() const
 272 {
 273     return pEditEngine->GetControlWord();
 274 }
 275
 276 void Outliner::SetAsianCompressionMode( CharCompressType n )
 277 {
 278     pEditEngine->SetAsianCompressionMode( n );
 279 }
 280
 281 void Outliner::SetKernAsianPunctuation( bool b )
 282 {
 283     pEditEngine->SetKernAsianPunctuation( b );
 284 }
 285
 286 void Outliner::SetAddExtLeading( bool bExtLeading )
 287 {
 288     pEditEngine->SetAddExtLeading( bExtLeading );
 289 }
 290
 291 void Outliner::UndoActionStart( sal_uInt16 nId )
 292 {
 293     pEditEngine->UndoActionStart( nId );
 294 }
 295
 296 void Outliner::UndoActionEnd()
 297 {
 298     pEditEngine->UndoActionEnd();
 299 }
 300
 301 void Outliner::InsertUndo( std::unique_ptr<EditUndo> pUndo )
 302 {
 303     pEditEngine->GetUndoManager().AddUndoAction( std::move(pUndo) );
 304 }
 305
 306 bool Outliner::IsInUndo() const
 307 {
 308     return pEditEngine->IsInUndo();
 309 }
 310
 311 sal_Int32 Outliner::GetLineCount( sal_Int32 nParagraph ) const
 312 {
 313     return pEditEngine->GetLineCount( nParagraph );
 314 }
 315
 316 sal_Int32 Outliner::GetLineLen( sal_Int32 nParagraph, sal_Int32 nLine ) const
 317 {
 318     return pEditEngine->GetLineLen( nParagraph, nLine );
 319 }
 320
 321 sal_uInt32 Outliner::GetLineHeight( sal_Int32 nParagraph, sal_Int32 nLine )
 322 {
 323     return pEditEngine->GetLineHeight( nParagraph, nLine );
 324 }
 325
 326 void Outliner::RemoveCharAttribs( sal_Int32 nPara, sal_uInt16 nWhich )
 327 {
 328     pEditEngine->RemoveCharAttribs( nPara, nWhich );
 329 }
 330
 331 EESpellState Outliner::HasSpellErrors()
 332 {
 333     return pEditEngine->HasSpellErrors();
 334 }
 335
 336 bool Outliner::HasConvertibleTextPortion( LanguageType nLang )
 337 {
 338     return pEditEngine->HasConvertibleTextPortion( nLang );
 339 }
 340
 341 bool Outliner::ConvertNextDocument()
 342 {
 343     return false;
 344 }
 345
 346 void Outliner::SetDefaultLanguage( LanguageType eLang )
 347 {
 348     pEditEngine->SetDefaultLanguage( eLang );
 349 }
 350
 351 void Outliner::CompleteOnlineSpelling()
 352 {
 353     pEditEngine->CompleteOnlineSpelling();
 354 }
 355
 356 bool Outliner::HasText( const SvxSearchItem& rSearchItem )
 357 {
 358     return pEditEngine->HasText( rSearchItem );
 359 }
 360
 361 void Outliner::SetEditTextObjectPool( SfxItemPool* pPool )
 362 {
 363     pEditEngine->SetEditTextObjectPool( pPool );
 364 }
 365
 366 SfxItemPool* Outliner::GetEditTextObjectPool() const
 367 {
 368     return pEditEngine->GetEditTextObjectPool();
 369 }
 370
 371 bool Outliner::SpellNextDocument()
 372 {
 373     return false;
 374 }
 375
 376
 377 void Outliner::SetSpeller( Reference< XSpellChecker1 > const &xSpeller )
 378 {
 379     pEditEngine->SetSpeller( xSpeller );
 380 }
 381
 382 Reference< XSpellChecker1 > const & Outliner::GetSpeller()
 383 {
 384     return pEditEngine->GetSpeller();
 385 }
 386
 387 void Outliner::SetForbiddenCharsTable(const std::shared_ptr<SvxForbiddenCharactersTable>& xForbiddenChars)
 388 {
 389     EditEngine::SetForbiddenCharsTable(xForbiddenChars);
 390 }
 391
 392 void Outliner::SetHyphenator( Reference< XHyphenator > const & xHyph )
 393 {
 394     pEditEngine->SetHyphenator( xHyph );
 395 }
 396
 397 OutputDevice* Outliner::GetRefDevice() const
 398 {
 399     return pEditEngine->GetRefDevice();
 400 }
 401
 402 tools::Rectangle Outliner::GetParaBounds( sal_Int32 nParagraph ) const
 403 {
 404     return pEditEngine->GetParaBounds(nParagraph );
 405 }
 406
 407 Point Outliner::GetDocPos( const Point& rPaperPos ) const
 408 {
 409     return pEditEngine->GetDocPos( rPaperPos );
 410 }
 411
 412 bool Outliner::IsTextPos( const Point& rPaperPos, sal_uInt16 nBorder )
 413 {
 414     return IsTextPos( rPaperPos, nBorder, nullptr );
 415 }
 416
 417 bool Outliner::IsTextPos( const Point& rPaperPos, sal_uInt16 nBorder, bool* pbBullet )
 418 {
 419     if ( pbBullet)
 420         *pbBullet = false;
 421     bool bTextPos = pEditEngine->IsTextPos( rPaperPos, nBorder );
 422     if ( !bTextPos )
 423     {
 424         Point aDocPos = GetDocPos( rPaperPos );
 425         sal_Int32 nPara = pEditEngine->FindParagraph( aDocPos.Y() );
 426         if ((nPara != EE_PARA_MAX) && ImplHasNumberFormat(nPara))
 427         {
 428             tools::Rectangle aBulArea = ImpCalcBulletArea( nPara, true, true );
 429             if ( aBulArea.Contains( rPaperPos ) )
 430             {
 431                 bTextPos = true;
 432                 if ( pbBullet)
 433                     *pbBullet = true;
 434             }
 435         }
 436     }
 437
 438     return bTextPos;
 439 }
 440
 441 void Outliner::QuickSetAttribs( const SfxItemSet& rSet, const ESelection& rSel )
 442 {
 443     pEditEngine->QuickSetAttribs( rSet, rSel );
 444 }
 445
 446 void Outliner::QuickInsertText( const OUString& rText, const ESelection& rSel )
 447 {
 448     bFirstParaIsEmpty = false;
 449     pEditEngine->QuickInsertText( rText, rSel );
 450 }
 451
 452 void Outliner::QuickDelete( const ESelection& rSel )
 453 {
 454     bFirstParaIsEmpty = false;
 455     pEditEngine->QuickDelete( rSel );
 456 }
 457
 458 void Outliner::QuickInsertField( const SvxFieldItem& rFld, const ESelection& rSel )
 459 {
 460     bFirstParaIsEmpty = false;
 461     pEditEngine->QuickInsertField( rFld, rSel );
 462 }
 463
 464 void Outliner::QuickInsertLineBreak( const ESelection& rSel )
 465 {
 466     bFirstParaIsEmpty = false;
 467     pEditEngine->QuickInsertLineBreak( rSel );
 468 }
 469
 470 void Outliner::QuickFormatDoc()
 471 {
 472     pEditEngine->QuickFormatDoc();
 473 }
 474
 475 const ScalingParameters & Outliner::getScalingParameters() const
 476 {
 477     return pEditEngine->getScalingParameters();
 478 }
 479
 480 void Outliner::setScalingParameters(ScalingParameters const& rScalingParameters)
 481 {
 482     // reset bullet size
 483     sal_Int32 nParagraphs = pParaList->GetParagraphCount();
 484     for ( sal_Int32 nPara = 0; nPara < nParagraphs; nPara++ )
 485     {
 486         Paragraph* pPara = pParaList->GetParagraph( nPara );
 487         if ( pPara )
 488             pPara->aBulSize.setWidth( -1 );
 489     }
 490
 491     pEditEngine->setScalingParameters(rScalingParameters);
 492 }
 493
 494 void Outliner::setRoundFontSizeToPt(bool bRound) const
 495 {
 496     pEditEngine->setRoundFontSizeToPt(bRound);
 497 }
 498
 499 void Outliner::EraseVirtualDevice()
 500 {
 501     pEditEngine->EraseVirtualDevice();
 502 }
 503
 504 bool Outliner::ShouldCreateBigTextObject() const
 505 {
 506     return pEditEngine->ShouldCreateBigTextObject();
 507 }
 508
 509 const EditEngine& Outliner::GetEditEngine() const
 510 {
 511     return *pEditEngine;
 512 }
 513
 514 void Outliner::SetVertical(bool bVertical)
 515 {
 516     pEditEngine->SetVertical(bVertical);
 517 }
 518
 519 void Outliner::SetRotation(TextRotation nRotation)
 520 {
 521     pEditEngine->SetRotation(nRotation);
 522 }
 523
 524 bool Outliner::IsVertical() const
 525 {
 526     return pEditEngine->IsEffectivelyVertical();
 527 }
 528
 529 bool Outliner::IsTopToBottom() const
 530 {
 531     return pEditEngine->IsTopToBottom();
 532 }
 533
 534 void Outliner::SetTextColumns(sal_Int16 nColumns, sal_Int32 nSpacing)
 535 {
 536     pEditEngine->SetTextColumns(nColumns, nSpacing);
 537 }
 538
 539 void Outliner::SetFixedCellHeight( bool bUseFixedCellHeight )
 540 {
 541     pEditEngine->SetFixedCellHeight( bUseFixedCellHeight );
 542 }
 543
 544 void Outliner::SetDefaultHorizontalTextDirection( EEHorizontalTextDirection eHTextDir )
 545 {
 546     pEditEngine->SetDefaultHorizontalTextDirection( eHTextDir );
 547 }
 548
 549 EEHorizontalTextDirection Outliner::GetDefaultHorizontalTextDirection() const
 550 {
 551     return pEditEngine->GetDefaultHorizontalTextDirection();
 552 }
 553
 554 LanguageType Outliner::GetLanguage( sal_Int32 nPara, sal_Int32 nPos ) const
 555 {
 556     return pEditEngine->GetLanguage( nPara, nPos ).nLang;
 557 }
 558
 559 void Outliner::RemoveAttribs( const ESelection& rSelection, bool bRemoveParaAttribs, sal_uInt16 nWhich )
 560 {
 561     pEditEngine->RemoveAttribs( rSelection, bRemoveParaAttribs, nWhich );
 562 }
 563
 564 void Outliner::EnableAutoColor( bool b )
 565 {
 566     pEditEngine->EnableAutoColor( b );
 567 }
 568
 569 void Outliner::ForceAutoColor( bool b )
 570 {
 571     pEditEngine->ForceAutoColor( b );
 572 }
 573
 574 bool Outliner::IsForceAutoColor() const
 575 {
 576     return pEditEngine->IsForceAutoColor();
 577 }
 578
 579 bool Outliner::SpellSentence(EditView const & rEditView, svx::SpellPortions& rToFill )
 580 {
 581     return pEditEngine->SpellSentence(rEditView, rToFill );
 582 }
 583
 584 void Outliner::PutSpellingToSentenceStart( EditView const & rEditView )
 585 {
 586     pEditEngine->PutSpellingToSentenceStart( rEditView );
 587 }
 588
 589 void Outliner::ApplyChangedSentence(EditView const & rEditView, const svx::SpellPortions& rNewPortions, bool bRecheck )
 590 {
 591     pEditEngine->ApplyChangedSentence( rEditView, rNewPortions, bRecheck );
 592 }
 593
 594 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */