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