sd/source/ui/view/Outliner.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: Outliner.cxx,v $
  10  * $Revision: 1.37.24.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sd.hxx"
  33
  34 #include "Outliner.hxx"
  35 #include <vcl/wrkwin.hxx>
  36 #include <sfx2/srchitem.hxx>
  37 #include <svx/colritem.hxx>
  38 #include <svx/eeitem.hxx>
  39 #include <svx/editstat.hxx>
  40 #include <vcl/outdev.hxx>
  41 #ifndef _DLGUTIL_HXX
  42 #include <svx/dlgutil.hxx>
  43 #endif
  44 #include <svx/xtable.hxx>
  45 #include <vcl/msgbox.hxx>
  46 #include <sfx2/dispatch.hxx>
  47 #include <sfx2/printer.hxx>
  48 #include <svx/svxerr.hxx>
  49 #include <svx/svdotext.hxx>
  50 #include <svx/unolingu.hxx>
  51 #include <svx/svditer.hxx>
  52 #include <comphelper/extract.hxx>
  53 #include <com/sun/star/linguistic2/XSpellChecker1.hpp>
  54 #include <com/sun/star/beans/XPropertySet.hpp>
  55 #include <comphelper/processfactory.hxx>
  56 #include <svx/eeitem.hxx>
  57 #include <svx/forbiddencharacterstable.hxx>
  58 #include <svx/srchdlg.hxx>
  59 #include <svtools/linguprops.hxx>
  60 #include <svtools/lingucfg.hxx>
  61 #include <svx/editeng.hxx>
  62 #include <vcl/metric.hxx>
  63 #include <sfx2/viewfrm.hxx>
  64
  65 #include "strings.hrc"
  66 #include "sdstring.hrc"
  67 #include "eetext.hxx"
  68 #include "sdpage.hxx"
  69 #include "app.hxx"
  70 #include "Window.hxx"
  71 #include "sdresid.hxx"
  72 #include "DrawViewShell.hxx"
  73 #include "OutlineViewShell.hxx"
  74 #include "drawdoc.hxx"
  75 #include "DrawDocShell.hxx"
  76 #include "FrameView.hxx"
  77 #include "optsitem.hxx"
  78 #include "drawview.hxx"
  79 #include "ViewShellBase.hxx"
  80 #include "SpellDialogChildWindow.hxx"
  81 #include "ToolBarManager.hxx"
  82 #include "framework/FrameworkHelper.hxx"
  83
  84 using ::rtl::OUString;
  85 using namespace ::com::sun::star;
  86 using namespace ::com::sun::star::uno;
  87 using namespace ::com::sun::star::lang;
  88 using namespace ::com::sun::star::linguistic2;
  89
  90 class SfxStyleSheetPool;
  91
  92 namespace sd {
  93
  94 class Outliner::Implementation
  95 {
  96 public:
  97     /** The original edit mode directly after switching to a different view
  98         mode.  Used for restoring the edit mode when leaving that view mode
  99         again.
 100     */
 101     EditMode meOriginalEditMode;
 102
 103     Implementation (void);
 104     ~Implementation (void);
 105
 106     /** Return the OutlinerView that was provided by the last call to
 107         ProvideOutlinerView() (or NULL when there was no such call.)
 108     */
 109     OutlinerView* GetOutlinerView (void);
 110
 111     /** Provide in the member mpOutlineView an instance of OutlinerView that
 112         is either taken from the ViewShell, when it is an OutlineViewShell,
 113         or is created.  When an OutlinerView already exists it is initialied.
 114     */
 115     void ProvideOutlinerView (
 116         Outliner& rOutliner,
 117         const ::boost::shared_ptr<ViewShell>& rpViewShell,
 118         ::Window* pWindow);
 119
 120     /** This method is called when the OutlinerView is no longer used.
 121     */
 122     void ReleaseOutlinerView (void);
 123
 124 private:
 125     /** Flag that specifies whether we own the outline view pointed to by
 126         <member>mpOutlineView</member> and thus have to
 127         delete it in <member>EndSpelling()</member>.
 128     */
 129     bool mbOwnOutlineView;
 130
 131     /** The outline view used for searching and spelling.  If searching or
 132         spell checking an outline view this data member points to that view.
 133         For all other views an instance is created.  The
 134         <member>mbOwnOutlineView</member> distinguishes between both cases.
 135     */
 136     OutlinerView* mpOutlineView;
 137 };
 138
 139
 140
 141
 142 /*************************************************************************
 143 |*
 144 |* Ctor
 145 |*
 146 \************************************************************************/
 147
 148 Outliner::Outliner( SdDrawDocument* pDoc, USHORT nMode )
 149     : SdrOutliner( &pDoc->GetItemPool(), nMode ),
 150       mpImpl(new Implementation()),
 151       meMode(SEARCH),
 152       mpView(NULL),
 153       mpViewShell(),
 154       mpWindow(NULL),
 155       mpDrawDocument(pDoc),
 156       mnConversionLanguage(LANGUAGE_NONE),
 157       mnIgnoreCurrentPageChangesLevel(0),
 158       mbStringFound(FALSE),
 159       mbMatchMayExist(false),
 160       mnPageCount(0),
 161       mnObjectCount(0),
 162       mbEndOfSearch(FALSE),
 163       mbFoundObject(FALSE),
 164       mbError(FALSE),
 165       mbDirectionIsForward(true),
 166       mbRestrictSearchToSelection(false),
 167       maMarkListCopy(),
 168       mbProcessCurrentViewOnly(false),
 169       mpObj(NULL),
 170       mpFirstObj(NULL),
 171       mpTextObj(NULL),
 172       mnText(0),
 173       mpParaObj(NULL),
 174       meStartViewMode(PK_STANDARD),
 175       meStartEditMode(EM_PAGE),
 176       mnStartPageIndex((USHORT)-1),
 177       mpStartEditedObject(NULL),
 178       maStartSelection(),
 179       mpSearchItem(NULL),
 180       maObjectIterator(),
 181       maCurrentPosition(),
 182       maSearchStartPosition(),
 183       maLastValidPosition(),
 184       mbSelectionHasChanged(false),
 185       mbExpectingSelectionChangeEvent(false),
 186       mbWholeDocumentProcessed(false),
 187       mbPrepareSpellingPending(true),
 188       mbViewShellValid(true)
 189 {
 190     SetStyleSheetPool((SfxStyleSheetPool*) mpDrawDocument->GetStyleSheetPool());
 191     SetEditTextObjectPool( &pDoc->GetItemPool() );
 192     SetCalcFieldValueHdl(LINK(SD_MOD(), SdModule, CalcFieldValueHdl));
 193     SetForbiddenCharsTable( pDoc->GetForbiddenCharsTable() );
 194
 195     ULONG nCntrl = GetControlWord();
 196     nCntrl |= EE_CNTRL_ALLOWBIGOBJS;
 197     nCntrl |= EE_CNTRL_URLSFXEXECUTE;
 198     nCntrl |= EE_CNTRL_MARKFIELDS;
 199     nCntrl |= EE_CNTRL_AUTOCORRECT;
 200
 201     BOOL bOnlineSpell = false;
 202
 203     DrawDocShell* pDocSh = mpDrawDocument->GetDocSh();
 204
 205     if (pDocSh)
 206     {
 207         bOnlineSpell = mpDrawDocument->GetOnlineSpell();
 208     }
 209     else
 210     {
 211         bOnlineSpell = false;
 212
 213         try
 214         {
 215             const SvtLinguConfig    aLinguConfig;
 216             Any                     aAny;
 217
 218             aAny = aLinguConfig.GetProperty(
 219                 rtl::OUString::createFromAscii( UPN_IS_SPELL_AUTO ) );
 220             aAny >>= bOnlineSpell;
 221         }
 222         catch( ... )
 223         {
 224             DBG_ERROR( "Ill. type in linguistic property" );
 225         }
 226     }
 227
 228     if (bOnlineSpell)
 229         nCntrl |= EE_CNTRL_ONLINESPELLING;
 230     else
 231         nCntrl &= ~EE_CNTRL_ONLINESPELLING;
 232
 233     SetControlWord(nCntrl);
 234
 235     Reference< XSpellChecker1 > xSpellChecker( LinguMgr::GetSpellChecker() );
 236     if ( xSpellChecker.is() )
 237         SetSpeller( xSpellChecker );
 238
 239     Reference< XHyphenator > xHyphenator( LinguMgr::GetHyphenator() );
 240     if( xHyphenator.is() )
 241         SetHyphenator( xHyphenator );
 242
 243     SetDefaultLanguage( Application::GetSettings().GetLanguage() );
 244 }
 245
 246
 247
 248
 249 /// Nothing spectecular in the destructor.
 250 Outliner::~Outliner (void)
 251 {
 252     mpImpl.reset();
 253 }
 254
 255
 256
 257
 258 /** Prepare find&replace or spellchecking.  This distinguishes between three
 259     cases:
 260     <ol>
 261     <li>The current shell is a <type>DrawViewShell</type>: Create a
 262     <type>OutlinerView</type> object and search all objects of (i) the
 263     current mark list, (ii) of the current view, or (iii) of all the view
 264     combinations:
 265     <ol>
 266     <li>Draw view, slide view</li>
 267     <li>Draw view, background view</li>
 268     <li>Notes view, slide view</li>
 269     <li>Notes view, background view</li>
 270     <li>Handout view, slide view</li>
 271     <li>Handout view, background view</li>
 272     </ol>
 273
 274     <li>When the current shell is a <type>SdOutlineViewShell</type> then
 275     directly operate on it.  No switching into other views takes place.</li>
 276
 277     <li>For a <type>SlideViewShell</type> no action is performed.</li>
 278     </ol>
 279 */
 280 void Outliner::PrepareSpelling (void)
 281 {
 282     if (mbViewShellValid)
 283     {
 284         mbPrepareSpellingPending = false;
 285
 286         ViewShellBase* pBase = PTR_CAST(ViewShellBase,SfxViewShell::Current());
 287         if (pBase != NULL)
 288             SetViewShell (pBase->GetMainViewShell());
 289         SetRefDevice( SD_MOD()->GetRefDevice( *mpDrawDocument->GetDocSh() ) );
 290
 291         if (mpViewShell.get() != NULL)
 292         {
 293             mbStringFound = FALSE;
 294
 295             mbWholeDocumentProcessed = false;
 296             // Supposed that we are not located at the very beginning/end of
 297             // the document then there may be a match in the document
 298             // prior/after the current position.
 299             mbMatchMayExist = TRUE;
 300
 301             maObjectIterator = ::sd::outliner::Iterator();
 302             maSearchStartPosition = ::sd::outliner::Iterator();
 303             RememberStartPosition();
 304
 305             mpImpl->ProvideOutlinerView(*this, mpViewShell, mpWindow);
 306
 307             HandleChangedSelection ();
 308         }
 309         ClearModifyFlag();
 310     }
 311 }
 312
 313
 314
 315
 316
 317 void Outliner::StartSpelling (void)
 318 {
 319     meMode = SPELL;
 320     mbDirectionIsForward = true;
 321     mpSearchItem = NULL;
 322 }
 323
 324 /** Proxy for method from base class to avoid compiler warning */
 325 void Outliner::StartSpelling(EditView& rView, unsigned char c)
 326 {
 327     SdrOutliner::StartSpelling( rView, c );
 328 }
 329
 330 /** Free all resources acquired during the search/spell check.  After a
 331     spell check the start position is restored here.
 332 */
 333 void Outliner::EndSpelling (void)
 334 {
 335     if (mbViewShellValid)
 336     {
 337         ViewShellBase* pBase = PTR_CAST(ViewShellBase,SfxViewShell::Current());
 338         if (pBase != NULL)
 339             mpViewShell = pBase->GetMainViewShell();
 340         else
 341             mpViewShell.reset();
 342
 343         // When in <member>PrepareSpelling()</member> a new outline view has
 344         // been created then delete it here.
 345         sal_Bool bViewIsDrawViewShell(mpViewShell.get()!=NULL
 346             && mpViewShell->ISA(DrawViewShell));
 347         if (bViewIsDrawViewShell)
 348         {
 349             SetStatusEventHdl(Link());
 350             mpView = mpViewShell->GetView();
 351             mpView->UnmarkAllObj (mpView->GetSdrPageView());
 352             mpView->SdrEndTextEdit();
 353             // Make FuSelection the current function.
 354             mpViewShell->GetDispatcher()->Execute(
 355                 SID_OBJECT_SELECT,
 356                 SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD);
 357
 358             // Remove and, if previously created by us, delete the outline
 359             // view.
 360             OutlinerView* pOutlinerView = mpImpl->GetOutlinerView();
 361             if (pOutlinerView != NULL)
 362             {
 363                 RemoveView(pOutlinerView);
 364                 mpImpl->ReleaseOutlinerView();
 365             }
 366
 367             SetUpdateMode(TRUE);
 368         }
 369
 370         // #95811# Before clearing the modify flag use it as a hint that
 371         // changes were done at SpellCheck
 372         if(IsModified())
 373         {
 374             if(mpView && mpView->ISA(OutlineView))
 375                 static_cast<OutlineView*>(mpView)->PrepareClose(FALSE);
 376             if(mpDrawDocument && !mpDrawDocument->IsChanged())
 377                 mpDrawDocument->SetChanged(TRUE);
 378         }
 379
 380         // #95811# now clear the modify flag to have a specified state of
 381         // Outliner
 382         ClearModifyFlag();
 383
 384         // When spell checking then restore the start position.
 385         if (meMode==SPELL || meMode==TEXT_CONVERSION)
 386             RestoreStartPosition ();
 387     }
 388
 389     mpViewShell.reset();
 390     mpView = NULL;
 391     mpWindow = NULL;
 392 }
 393
 394
 395
 396
 397 BOOL Outliner::SpellNextDocument (void)
 398 {
 399     if (mpViewShell->ISA(OutlineViewShell))
 400     {
 401         // When doing a spell check in the outline view then there is
 402         // only one document.
 403         mbEndOfSearch = true;
 404         EndOfSearch ();
 405     }
 406     else
 407     {
 408         if (mpView->ISA(OutlineView))
 409             ((OutlineView*)mpView)->PrepareClose(FALSE);
 410         mpDrawDocument->GetDocSh()->SetWaitCursor( TRUE );
 411
 412         Initialize (true);
 413
 414         mpWindow = mpViewShell->GetActiveWindow();
 415         OutlinerView* pOutlinerView = mpImpl->GetOutlinerView();
 416         if (pOutlinerView != NULL)
 417             pOutlinerView->SetWindow(mpWindow);
 418         ProvideNextTextObject ();
 419
 420         mpDrawDocument->GetDocSh()->SetWaitCursor( FALSE );
 421         ClearModifyFlag();
 422     }
 423
 424     return mbEndOfSearch ? FALSE : TRUE;
 425
 426 }
 427
 428 void Outliner::HandleOutsideChange (ChangeHint eHint)
 429 {
 430     switch (eHint)
 431     {
 432         case CH_VIEW_SHELL_INVALID:
 433             EndSpelling();
 434             mbPrepareSpellingPending = true;
 435             mbViewShellValid = false;
 436             break;
 437
 438         case CH_VIEW_SHELL_VALID:
 439             mbViewShellValid = true;
 440             break;
 441     }
 442 }
 443
 444
 445
 446 /*************************************************************************
 447 |*
 448 |* Spelling: naechstes TextObjekt pruefen
 449 |*
 450 \************************************************************************/
 451
 452 ::svx::SpellPortions Outliner::GetNextSpellSentence (void)
 453 {
 454     ::svx::SpellPortions aResult;
 455
 456     DetectChange();
 457     // Iterate over sentences and text shapes until a sentence with a
 458     // spelling error has been found.  If no such sentence can be
 459     // found the loop is left through a break.
 460     // It is the responsibility of the sd outliner object to correctly
 461     // iterate over all text shapes, i.e. switch between views, wrap
 462     // arround at the end of the document, stop when all text shapes
 463     // have been examined exactly once.
 464     bool bFoundNextSentence = false;
 465     while ( ! bFoundNextSentence)
 466     {
 467         OutlinerView* pOutlinerView = GetView(0);
 468         if (pOutlinerView != NULL)
 469         {
 470             ESelection aCurrentSelection (pOutlinerView->GetSelection());
 471             if ( ! mbMatchMayExist
 472                 && maStartSelection.IsLess(aCurrentSelection))
 473                 EndOfSearch();
 474
 475             // Advance to the next sentence.
 476             bFoundNextSentence = SpellSentence (
 477                 pOutlinerView->GetEditView(),
 478                 aResult, false);
 479         }
 480
 481         // When no sentence with spelling errors has been found in the
 482         // currently selected text shape or there is no selected text
 483         // shape then advance to the next text shape.
 484         if ( ! bFoundNextSentence)
 485             if ( ! SpellNextDocument())
 486                 // All text objects have been processed so exit the
 487                 // loop and return an empty portions list.
 488                 break;
 489     }
 490
 491     return aResult;
 492 }
 493
 494
 495
 496
 497 /** Go to next match.
 498 */
 499 bool Outliner::StartSearchAndReplace (const SvxSearchItem* pSearchItem)
 500 {
 501     BOOL bEndOfSearch = TRUE;
 502
 503     if (mbViewShellValid)
 504     {
 505         mpDrawDocument->GetDocSh()->SetWaitCursor( TRUE );
 506         if (mbPrepareSpellingPending)
 507             PrepareSpelling();
 508         ViewShellBase* pBase = PTR_CAST(ViewShellBase,SfxViewShell::Current());
 509         // Determine whether we have to abort the search.  This is necessary
 510         // when the main view shell does not support searching.
 511         bool bAbort = false;
 512         if (pBase != NULL)
 513         {
 514             ::boost::shared_ptr<ViewShell> pShell (pBase->GetMainViewShell());
 515             SetViewShell(pShell);
 516             if (pShell.get() == NULL)
 517                 bAbort = true;
 518             else
 519                 switch (pShell->GetShellType())
 520                 {
 521                     case ViewShell::ST_DRAW:
 522                     case ViewShell::ST_IMPRESS:
 523                     case ViewShell::ST_NOTES:
 524                     case ViewShell::ST_HANDOUT:
 525                     case ViewShell::ST_OUTLINE:
 526                         bAbort = false;
 527                         break;
 528                     default:
 529                         bAbort = true;
 530                         break;
 531                 }
 532         }
 533
 534         if ( ! bAbort)
 535         {
 536             meMode = SEARCH;
 537             mpSearchItem = pSearchItem;
 538
 539             mbFoundObject = FALSE;
 540
 541             Initialize ( ! mpSearchItem->GetBackward());
 542
 543             USHORT nCommand = mpSearchItem->GetCommand();
 544             if (nCommand == SVX_SEARCHCMD_REPLACE_ALL)
 545                 bEndOfSearch = SearchAndReplaceAll ();
 546             else
 547             {
 548                 RememberStartPosition ();
 549                 bEndOfSearch = SearchAndReplaceOnce ();
 550                 //#107233# restore start position if nothing was found
 551                 if(!mbStringFound)
 552                     RestoreStartPosition ();
 553                 else
 554                     mnStartPageIndex = (USHORT)-1;
 555             }
 556         }
 557         else
 558             mpDrawDocument->GetDocSh()->SetWaitCursor( FALSE );
 559     }
 560
 561     return bEndOfSearch;
 562 }
 563
 564
 565
 566
 567 void Outliner::Initialize (bool bDirectionIsForward)
 568 {
 569     bool bOldDirectionIsForward = mbDirectionIsForward;
 570     mbDirectionIsForward = bDirectionIsForward;
 571
 572     if (maObjectIterator == ::sd::outliner::Iterator())
 573     {
 574         // Initialize a new search.
 575         maObjectIterator = ::sd::outliner::OutlinerContainer(this).current();
 576         maCurrentPosition = *maObjectIterator;
 577
 578         // In case we are searching in an outline view then first remove the
 579         // current selection and place cursor at its start or end.
 580         if (mpViewShell->ISA(OutlineViewShell))
 581         {
 582             ESelection aSelection = mpImpl->GetOutlinerView()->GetSelection ();
 583             if (mbDirectionIsForward)
 584             {
 585                 aSelection.nEndPara = aSelection.nStartPara;
 586                 aSelection.nEndPos = aSelection.nStartPos;
 587             }
 588             else
 589             {
 590                 aSelection.nStartPara = aSelection.nEndPara;
 591                 aSelection.nStartPos = aSelection.nEndPos;
 592             }
 593             mpImpl->GetOutlinerView()->SetSelection (aSelection);
 594         }
 595
 596         // When not beginning the search at the beginning of the search area
 597         // then there may be matches before the current position.
 598         mbMatchMayExist = (maObjectIterator!=::sd::outliner::OutlinerContainer(this).begin());
 599     }
 600     else if (bOldDirectionIsForward != mbDirectionIsForward)
 601     {
 602         // Requested iteration direction has changed.  Turn arround the iterator.
 603         maObjectIterator.Reverse();
 604         // The iterator has pointed to the object one ahead/before the current
 605         // one.  Now move it to the one before/ahead the current one.
 606         ++maObjectIterator;
 607         ++maObjectIterator;
 608
 609         mbMatchMayExist = true;
 610     }
 611
 612     // Initialize the last valid position with where the search starts so
 613     // that it always points to a valid position.
 614     maLastValidPosition = *::sd::outliner::OutlinerContainer(this).current();
 615 }
 616
 617
 618
 619
 620 bool Outliner::SearchAndReplaceAll (void)
 621 {
 622     // Save the current position to be restored after having replaced all
 623     // matches.
 624     RememberStartPosition ();
 625
 626     if (mpViewShell->ISA(OutlineViewShell))
 627     {
 628         // Put the cursor to the beginning/end of the outliner.
 629         mpImpl->GetOutlinerView()->SetSelection (GetSearchStartPosition ());
 630
 631         // The outliner does all the work for us when we are in this mode.
 632         SearchAndReplaceOnce();
 633     }
 634     else if (mpViewShell->ISA(DrawViewShell))
 635     {
 636         // Go to beginning/end of document.
 637         maObjectIterator = ::sd::outliner::OutlinerContainer(this).begin();
 638         // Switch to the current object only if it is a valid text object.
 639         ::sd::outliner::IteratorPosition aNewPosition (*maObjectIterator);
 640         if (IsValidTextObject (aNewPosition))
 641         {
 642             maCurrentPosition = aNewPosition;
 643             SetObject (maCurrentPosition);
 644         }
 645
 646         // Search/replace until the end of the document is reached.
 647         bool bFoundMatch;
 648         do
 649         {
 650             bFoundMatch = ! SearchAndReplaceOnce();
 651         }
 652         while (bFoundMatch);
 653     }
 654
 655     RestoreStartPosition ();
 656
 657     return true;
 658 }
 659
 660
 661
 662
 663 bool Outliner::SearchAndReplaceOnce (void)
 664 {
 665     DetectChange ();
 666
 667     OutlinerView* pOutlinerView = mpImpl->GetOutlinerView();
 668     DBG_ASSERT(pOutlinerView!=NULL && GetEditEngine().HasView( &pOutlinerView->GetEditView() ),
 669         "SearchAndReplace without valid view!" );
 670
 671     if( NULL == pOutlinerView || !GetEditEngine().HasView( &pOutlinerView->GetEditView() ) )
 672         return true;
 673
 674     if (mpViewShell != NULL)
 675     {
 676         mpView = mpViewShell->GetView();
 677         mpWindow = mpViewShell->GetActiveWindow();
 678         pOutlinerView->SetWindow(mpWindow);
 679
 680         if (mpViewShell->ISA(DrawViewShell) )
 681         {
 682             // When replacing we first check if there is a selection
 683             // indicating a match.  If there is then replace it.  The
 684             // following call to StartSearchAndReplace will then search for
 685             // the next match.
 686             if (meMode == SEARCH
 687                 && mpSearchItem->GetCommand() == SVX_SEARCHCMD_REPLACE)
 688                 if (pOutlinerView->GetSelection().HasRange())
 689                     pOutlinerView->StartSearchAndReplace(*mpSearchItem);
 690
 691             // Search for the next match.
 692             ULONG nMatchCount = 0;
 693             if (mpSearchItem->GetCommand() != SVX_SEARCHCMD_REPLACE_ALL)
 694                 nMatchCount = pOutlinerView->StartSearchAndReplace(*mpSearchItem);
 695
 696             // Go to the next text object when there have been no matches in
 697             // the current object or the whole object has already been
 698             // processed.
 699             if (nMatchCount==0 || mpSearchItem->GetCommand()==SVX_SEARCHCMD_REPLACE_ALL)
 700             {
 701                 ProvideNextTextObject ();
 702
 703                 if ( ! mbEndOfSearch)
 704                 {
 705                     // Remember the current position as the last one with a
 706                     // text object.
 707                     maLastValidPosition = maCurrentPosition;
 708
 709                     // Now that the mbEndOfSearch flag guards this block the
 710                     // following assertion and return should not be
 711                     // necessary anymore.
 712                     DBG_ASSERT(GetEditEngine().HasView(&pOutlinerView->GetEditView() ),
 713                         "SearchAndReplace without valid view!" );
 714                     if ( ! GetEditEngine().HasView( &pOutlinerView->GetEditView() ) )
 715                     {
 716                         mpDrawDocument->GetDocSh()->SetWaitCursor( FALSE );
 717                         return true;
 718                     }
 719
 720                     if (meMode == SEARCH)
 721                         nMatchCount = pOutlinerView->StartSearchAndReplace(*mpSearchItem);
 722                 }
 723             }
 724         }
 725         else if (mpViewShell->ISA(OutlineViewShell))
 726         {
 727             mpDrawDocument->GetDocSh()->SetWaitCursor (FALSE);
 728             // The following loop is executed more then once only when a
 729             // wrap arround search is done.
 730             while (true)
 731             {
 732                 int nResult = pOutlinerView->StartSearchAndReplace(*mpSearchItem);
 733                 if (nResult == 0)
 734                 {
 735                     if (HandleFailedSearch ())
 736                     {
 737                         pOutlinerView->SetSelection (GetSearchStartPosition ());
 738                         continue;
 739                     }
 740                 }
 741                 else
 742                     mbStringFound = true;
 743                 break;
 744             }
 745         }
 746     }
 747
 748     mpDrawDocument->GetDocSh()->SetWaitCursor( FALSE );
 749
 750     return mbEndOfSearch;
 751 }
 752
 753
 754
 755
 756 /** Try to detect whether the document or the view (shell) has changed since
 757     the last time <member>StartSearchAndReplace()</member> has been called.
 758 */
 759 void Outliner::DetectChange (void)
 760 {
 761     ::sd::outliner::IteratorPosition aPosition (maCurrentPosition);
 762
 763     ::boost::shared_ptr<DrawViewShell> pDrawViewShell (
 764         ::boost::dynamic_pointer_cast<DrawViewShell>(mpViewShell));
 765
 766     // Detect whether the view has been switched from the outside.
 767     if (pDrawViewShell.get() != NULL
 768         && (aPosition.meEditMode != pDrawViewShell->GetEditMode()
 769             || aPosition.mePageKind != pDrawViewShell->GetPageKind()))
 770     {
 771         // Either the edit mode or the page kind has changed.
 772         SetStatusEventHdl(Link());
 773
 774         SdrPageView* pPageView = mpView->GetSdrPageView();
 775         if (pPageView != NULL)
 776             mpView->UnmarkAllObj (pPageView);
 777         mpView->SdrEndTextEdit();
 778         SetUpdateMode(FALSE);
 779         OutlinerView* pOutlinerView = mpImpl->GetOutlinerView();
 780         if (pOutlinerView != NULL)
 781             pOutlinerView->SetOutputArea( Rectangle( Point(), Size(1, 1) ) );
 782         if (meMode == SPELL)
 783             SetPaperSize( Size(1, 1) );
 784         SetText( String(), GetParagraph( 0 ) );
 785
 786         RememberStartPosition ();
 787
 788         mnPageCount = mpDrawDocument->GetSdPageCount(pDrawViewShell->GetPageKind());
 789         maObjectIterator = ::sd::outliner::OutlinerContainer(this).current();
 790     }
 791
 792     // Detect change of the set of selected objects.  If their number has
 793     // changed start again with the first selected object.
 794     else if (DetectSelectionChange())
 795     {
 796         HandleChangedSelection ();
 797         maObjectIterator = ::sd::outliner::OutlinerContainer(this).current();
 798     }
 799
 800     // Detect change of page count.  Restart search at first/last page in
 801     // that case.
 802     else if (aPosition.meEditMode == EM_PAGE
 803         && mpDrawDocument->GetSdPageCount(aPosition.mePageKind) != mnPageCount)
 804     {
 805         // The number of pages has changed.
 806         mnPageCount = mpDrawDocument->GetSdPageCount(aPosition.mePageKind);
 807         maObjectIterator = ::sd::outliner::OutlinerContainer(this).current();
 808     }
 809     else if (aPosition.meEditMode == EM_MASTERPAGE
 810         && mpDrawDocument->GetSdPageCount(aPosition.mePageKind) != mnPageCount)
 811     {
 812         // The number of master pages has changed.
 813         mnPageCount = mpDrawDocument->GetSdPageCount(aPosition.mePageKind);
 814         maObjectIterator = ::sd::outliner::OutlinerContainer(this).current();
 815     }
 816 }
 817
 818
 819
 820
 821 bool Outliner::DetectSelectionChange (void)
 822 {
 823     bool bSelectionHasChanged = false;
 824     ULONG nMarkCount = mpView->GetMarkedObjectList().GetMarkCount();
 825
 826     // If mpObj is NULL then we have not yet found our first match.
 827     // Detecting a change makes no sense.
 828     if (mpObj != NULL)
 829         switch (nMarkCount)
 830         {
 831             case 0:
 832                 // The selection has changed when previously there have been
 833                 // selected objects.
 834                 bSelectionHasChanged = mbRestrictSearchToSelection;
 835                 break;
 836             case 1:
 837                 // Check if the only selected object is not the one that we
 838                 // had selected.
 839                 if (mpView != NULL)
 840                 {
 841                     SdrMark* pMark = mpView->GetMarkedObjectList().GetMark(0);
 842                     if (pMark != NULL)
 843                         bSelectionHasChanged = (mpObj != pMark->GetMarkedSdrObj ());
 844                 }
 845                 break;
 846             default:
 847                 // We had selected exactly one object.
 848                 bSelectionHasChanged = true;
 849                 break;
 850         }
 851
 852     return bSelectionHasChanged;
 853 }
 854
 855
 856
 857
 858 void Outliner::RememberStartPosition (void)
 859 {
 860     if (mpViewShell->ISA(DrawViewShell))
 861     {
 862         ::boost::shared_ptr<DrawViewShell> pDrawViewShell (
 863             ::boost::dynamic_pointer_cast<DrawViewShell>(mpViewShell));
 864         if (pDrawViewShell.get() != NULL)
 865         {
 866             meStartViewMode = pDrawViewShell->GetPageKind();
 867             meStartEditMode = pDrawViewShell->GetEditMode();
 868             mnStartPageIndex = pDrawViewShell->GetCurPageId() - 1;
 869         }
 870
 871         if (mpView != NULL)
 872         {
 873             mpStartEditedObject = mpView->GetTextEditObject();
 874             if (mpStartEditedObject != NULL)
 875             {
 876                 // Try to retrieve current caret position only when there is an
 877                 // edited object.
 878                 ::Outliner* pOutliner =
 879                     static_cast<DrawView*>(mpView)->GetTextEditOutliner();
 880                 if (pOutliner!=NULL && pOutliner->GetViewCount()>0)
 881                 {
 882                     OutlinerView* pOutlinerView = pOutliner->GetView(0);
 883                     maStartSelection = pOutlinerView->GetSelection();
 884                 }
 885             }
 886         }
 887     }
 888     else if (mpViewShell->ISA(OutlineViewShell))
 889     {
 890         // Remember the current cursor position.
 891         OutlinerView* pView = GetView(0);
 892         if (pView != NULL)
 893             pView->GetSelection();
 894     }
 895     else
 896     {
 897         mnStartPageIndex = (USHORT)-1;
 898     }
 899 }
 900
 901
 902
 903
 904 void Outliner::RestoreStartPosition (void)
 905 {
 906     bool bRestore = true;
 907     // Take a negative start page index as inidicator that restoring the
 908     // start position is not requested.
 909     if (mnStartPageIndex == (USHORT)-1 )
 910         bRestore = false;
 911     // Dont't resore when the view shell is not valid.
 912     if (mpViewShell == NULL)
 913         bRestore = false;
 914     if ( ! mbViewShellValid)
 915         bRestore = false;
 916
 917     if (bRestore)
 918     {
 919         if (mpViewShell->ISA(DrawViewShell))
 920         {
 921             ::boost::shared_ptr<DrawViewShell> pDrawViewShell (
 922                 ::boost::dynamic_pointer_cast<DrawViewShell>(mpViewShell));
 923             SetViewMode (meStartViewMode);
 924             if (pDrawViewShell.get() != NULL)
 925                 SetPage (meStartEditMode, mnStartPageIndex);
 926
 927
 928             if (mpStartEditedObject != NULL)
 929             {
 930                 // Turn on the text toolbar as it is done in FuText so that
 931                 // undo manager setting/restoring in
 932                 // sd::View::{Beg,End}TextEdit() works on the same view shell.
 933                 mpViewShell->GetViewShellBase().GetToolBarManager()->SetToolBarShell(
 934                     ToolBarManager::TBG_FUNCTION,
 935                     RID_DRAW_TEXT_TOOLBOX);
 936
 937                 mpView->SdrBeginTextEdit(mpStartEditedObject);
 938                 ::Outliner* pOutliner =
 939                       static_cast<DrawView*>(mpView)->GetTextEditOutliner();
 940                 if (pOutliner!=NULL && pOutliner->GetViewCount()>0)
 941                 {
 942                     OutlinerView* pOutlinerView = pOutliner->GetView(0);
 943                     pOutlinerView->SetSelection(maStartSelection);
 944                 }
 945             }
 946         }
 947         else if (mpViewShell->ISA(OutlineViewShell))
 948         {
 949             // Set cursor to its old position.
 950             GetView(0)->SetSelection (maStartSelection);
 951         }
 952     }
 953 }
 954
 955
 956
 957
 958 /** The main purpose of this method is to iterate over all shape objects of
 959     the search area (current selection, current view, or whole document)
 960     until a text object has been found that contains at least one match or
 961     until no such object can be found anymore.   These two conditions are
 962     expressed by setting one of the flags <member>mbFoundObject</member> or
 963     <member>mbEndOfSearch</member> to <TRUE/>.
 964 */
 965 void Outliner::ProvideNextTextObject (void)
 966 {
 967     mbEndOfSearch = false;
 968     mbFoundObject = false;
 969
 970     mpView->UnmarkAllObj (mpView->GetSdrPageView());
 971     try
 972     {
 973         mpView->SdrEndTextEdit();
 974     }
 975     catch (::com::sun::star::uno::Exception e)
 976     {
 977         OSL_TRACE ("Outliner %p: caught exception while ending text edit mode", this);
 978     }
 979     SetUpdateMode(FALSE);
 980     OutlinerView* pOutlinerView = mpImpl->GetOutlinerView();
 981     if (pOutlinerView != NULL)
 982         pOutlinerView->SetOutputArea( Rectangle( Point(), Size(1, 1) ) );
 983     if (meMode == SPELL)
 984         SetPaperSize( Size(1, 1) );
 985     SetText( String(), GetParagraph( 0 ) );
 986
 987     mpTextObj = NULL;
 988
 989     // Iterate until a valid text object has been found or the search ends.
 990     do
 991     {
 992         mpObj = NULL;
 993         mpParaObj = NULL;
 994
 995         if (maObjectIterator != ::sd::outliner::OutlinerContainer(this).end())
 996         {
 997             maCurrentPosition = *maObjectIterator;
 998             // Switch to the current object only if it is a valid text object.
 999             if (IsValidTextObject (maCurrentPosition))
1000             {
1001                 mpObj = SetObject (maCurrentPosition);
1002             }
1003             ++maObjectIterator;
1004
1005             if (mpObj != NULL)
1006             {
1007                 PutTextIntoOutliner ();
1008
1009                 if (mpViewShell != NULL)
1010                     switch (meMode)
1011                     {
1012                         case SEARCH:
1013                             PrepareSearchAndReplace ();
1014                             break;
1015                         case SPELL:
1016                             PrepareSpellCheck ();
1017                             break;
1018                         case TEXT_CONVERSION:
1019                             PrepareConversion();
1020                             break;
1021                     }
1022             }
1023         }
1024         else
1025         {
1026             mbEndOfSearch = true;
1027             EndOfSearch ();
1028         }
1029     }
1030     while ( ! (mbFoundObject || mbEndOfSearch));
1031 }
1032
1033
1034
1035
1036 void Outliner::EndOfSearch (void)
1037 {
1038     // Before we display a dialog we first jump to where the last valid text
1039     // object was found.  All page and view mode switching since then was
1040     // temporary and should not be visible to the user.
1041     if ( ! mpViewShell->ISA(OutlineViewShell))
1042         SetObject (maLastValidPosition);
1043
1044     if (mbRestrictSearchToSelection)
1045         ShowEndOfSearchDialog ();
1046     else
1047     {
1048         // When no match has been found so far then terminate the search.
1049         if ( ! mbMatchMayExist)
1050         {
1051             ShowEndOfSearchDialog ();
1052             mbEndOfSearch = TRUE;
1053         }
1054         // Ask the user whether to wrap arround and continue the search or
1055         // to terminate.
1056         else if (meMode==TEXT_CONVERSION || ShowWrapArroundDialog ())
1057         {
1058             mbMatchMayExist = false;
1059             // Everything back to beginning (or end?) of the document.
1060             maObjectIterator = ::sd::outliner::OutlinerContainer(this).begin();
1061             if (mpViewShell->ISA(OutlineViewShell))
1062             {
1063                 // Set cursor to first character of the document.
1064                 OutlinerView* pOutlinerView = mpImpl->GetOutlinerView();
1065                 if (pOutlinerView != NULL)
1066                     pOutlinerView->SetSelection (GetSearchStartPosition ());
1067             }
1068
1069             mbEndOfSearch = false;
1070         }
1071         else
1072         {
1073             // No wrap arround.
1074             mbEndOfSearch = true;
1075         }
1076     }
1077 }
1078
1079
1080
1081
1082 void Outliner::InitPage (USHORT nPageIndex)
1083 {
1084     (void)nPageIndex;
1085
1086     ::sd::outliner::IteratorPosition aPosition (*maObjectIterator);
1087     if (aPosition.meEditMode == EM_PAGE)
1088         mnPageCount = mpDrawDocument->GetSdPageCount(aPosition.mePageKind);
1089     else
1090         mnPageCount = mpDrawDocument->GetMasterSdPageCount(aPosition.mePageKind);
1091 }
1092
1093
1094
1095
1096 void Outliner::ShowEndOfSearchDialog (void)
1097 {
1098     String aString;
1099     if (meMode == SEARCH)
1100     {
1101         if (mbStringFound)
1102             aString = String( SdResId(STR_END_SEARCHING) );
1103         else
1104             aString = String( SdResId(STR_STRING_NOTFOUND) );
1105     }
1106     else
1107     {
1108         if (mpView->AreObjectsMarked())
1109             aString = String(SdResId(STR_END_SPELLING_OBJ));
1110         else
1111             aString = String(SdResId(STR_END_SPELLING));
1112     }
1113
1114     // Show the message in an info box that is modal with respect to the
1115     // whole application.
1116     InfoBox aInfoBox (NULL, aString);
1117     ShowModalMessageBox (aInfoBox);
1118
1119     mbWholeDocumentProcessed = true;
1120 }
1121
1122
1123
1124
1125 bool Outliner::ShowWrapArroundDialog (void)
1126 {
1127     bool bDoWrapArround = false;
1128
1129     // Determine whether to show the dialog.
1130     bool bShowDialog = false;
1131     if (mpSearchItem != NULL)
1132     {
1133         // When searching display the dialog only for single find&replace.
1134         USHORT nCommand = mpSearchItem->GetCommand();
1135         bShowDialog = (nCommand==SVX_SEARCHCMD_REPLACE)
1136             || (nCommand==SVX_SEARCHCMD_FIND);
1137     }
1138     else
1139         // Spell checking needs the dialog, too.
1140         bShowDialog = (meMode == SPELL);
1141
1142     if (bShowDialog)
1143     {
1144         // The question text depends on the search direction.
1145         BOOL bImpress = mpDrawDocument!=NULL
1146             && mpDrawDocument->GetDocumentType() == DOCUMENT_TYPE_IMPRESS;
1147         USHORT nStringId;
1148         if (mbDirectionIsForward)
1149             nStringId = bImpress
1150                 ? STR_SAR_WRAP_FORWARD
1151                 : STR_SAR_WRAP_FORWARD_DRAW;
1152         else
1153             nStringId = bImpress
1154                 ? STR_SAR_WRAP_BACKWARD
1155                 : STR_SAR_WRAP_BACKWARD_DRAW;
1156
1157         // Pop up question box that asks the user whether to wrap arround.
1158         // The dialog is made modal with respect to the whole application.
1159         QueryBox aQuestionBox (
1160             NULL,
1161             WB_YES_NO | WB_DEF_YES,
1162             String(SdResId(nStringId)));
1163         aQuestionBox.SetImage (QueryBox::GetStandardImage());
1164         USHORT nBoxResult = ShowModalMessageBox(aQuestionBox);
1165         bDoWrapArround = (nBoxResult == BUTTONID_YES);
1166     }
1167
1168     return bDoWrapArround;
1169 }
1170
1171
1172
1173
1174 bool Outliner::IsValidTextObject (const ::sd::outliner::IteratorPosition& rPosition)
1175 {
1176     SdrTextObj* pObject = dynamic_cast< SdrTextObj* >( rPosition.mxObject.get() );
1177     return (pObject != NULL) && pObject->HasText() && ! pObject->IsEmptyPresObj();
1178 }
1179
1180
1181
1182
1183 void Outliner::PutTextIntoOutliner()
1184 {
1185     mpTextObj = dynamic_cast<SdrTextObj*>( mpObj );
1186     if ( mpTextObj && mpTextObj->HasText() && !mpTextObj->IsEmptyPresObj() )
1187     {
1188         SdrText* pText = mpTextObj->getText( mnText );
1189         mpParaObj = pText ? pText->GetOutlinerParaObject() : NULL;
1190
1191         if (mpParaObj != NULL)
1192         {
1193             SetText(*mpParaObj);
1194
1195             ClearModifyFlag();
1196         }
1197     }
1198     else
1199     {
1200         mpTextObj = NULL;
1201     }
1202 }
1203
1204
1205
1206
1207 void Outliner::PrepareSpellCheck (void)
1208 {
1209     EESpellState eState = HasSpellErrors();
1210     DBG_ASSERT(eState != EE_SPELL_NOSPELLER, "No SpellChecker");
1211
1212     if (eState == EE_SPELL_NOLANGUAGE)
1213     {
1214         mbError = TRUE;
1215         mbEndOfSearch = TRUE;
1216         ErrorBox aErrorBox (NULL,
1217             WB_OK,
1218             String(SdResId(STR_NOLANGUAGE)));
1219         ShowModalMessageBox (aErrorBox);
1220     }
1221     else if (eState != EE_SPELL_OK)
1222     {
1223         // When spell checking we have to test whether we have processed the
1224         // whole document and have reached the start page again.
1225         if (meMode == SPELL)
1226         {
1227             if (maSearchStartPosition == ::sd::outliner::Iterator())
1228                 // Remember the position of the first text object so that we
1229                 // know when we have processed the whole document.
1230                 maSearchStartPosition = maObjectIterator;
1231             else if (maSearchStartPosition == maObjectIterator)
1232             {
1233                 mbEndOfSearch = true;
1234             }
1235         }
1236
1237         EnterEditMode( FALSE );
1238     }
1239 }
1240
1241
1242
1243
1244 void Outliner::PrepareSearchAndReplace (void)
1245 {
1246     if (HasText( *mpSearchItem ))
1247     {
1248         mbStringFound = true;
1249         mbMatchMayExist = true;
1250
1251         EnterEditMode ();
1252
1253         mpDrawDocument->GetDocSh()->SetWaitCursor( FALSE );
1254         // Start seach at the right end of the current object's text
1255         // depending on the search direction.
1256         OutlinerView* pOutlinerView = mpImpl->GetOutlinerView();
1257         if (pOutlinerView != NULL)
1258             pOutlinerView->SetSelection (GetSearchStartPosition ());
1259     }
1260 }
1261
1262
1263
1264
1265 void Outliner::SetViewMode (PageKind ePageKind)
1266 {
1267     ::boost::shared_ptr<DrawViewShell> pDrawViewShell(
1268         ::boost::dynamic_pointer_cast<DrawViewShell>(mpViewShell));
1269     if (pDrawViewShell.get()!=NULL && ePageKind != pDrawViewShell->GetPageKind())
1270     {
1271         // Restore old edit mode.
1272         pDrawViewShell->ChangeEditMode(mpImpl->meOriginalEditMode, FALSE);
1273
1274         SetStatusEventHdl(Link());
1275         ::rtl::OUString sViewURL;
1276         switch (ePageKind)
1277         {
1278             case PK_STANDARD:
1279             default:
1280                 sViewURL = framework::FrameworkHelper::msImpressViewURL;
1281                 break;
1282             case PK_NOTES:
1283                 sViewURL = framework::FrameworkHelper::msNotesViewURL;
1284                 break;
1285             case PK_HANDOUT:
1286                 sViewURL = framework::FrameworkHelper::msHandoutViewURL;
1287                 break;
1288         }
1289         // The text object iterator is destroyed when the shells are
1290         // switched but we need it so save it and restore it afterwards.
1291         ::sd::outliner::Iterator aIterator (maObjectIterator);
1292         bool bMatchMayExist = mbMatchMayExist;
1293
1294         ViewShellBase& rBase = mpViewShell->GetViewShellBase();
1295         SetViewShell(::boost::shared_ptr<ViewShell>());
1296         framework::FrameworkHelper::Instance(rBase)->RequestView(
1297             sViewURL,
1298             framework::FrameworkHelper::msCenterPaneURL);
1299
1300         // Force (well, request) a synchronous update of the configuration.
1301         // In a better world we would handle the asynchronous view update
1302         // instead.  But that would involve major restucturing of the
1303         // Outliner code.
1304         framework::FrameworkHelper::Instance(rBase)->RequestSynchronousUpdate();
1305         SetViewShell(rBase.GetMainViewShell());
1306
1307         // Switching to another view shell has intermediatly called
1308         // EndSpelling().  A PrepareSpelling() is pending, so call that now.
1309         PrepareSpelling();
1310
1311         // Update the number of pages so that
1312         // <member>DetectChange()</member> has the correct value to compare
1313         // to.
1314         mnPageCount = mpDrawDocument->GetSdPageCount(ePageKind);
1315
1316         maObjectIterator = aIterator;
1317         mbMatchMayExist = bMatchMayExist;
1318
1319         // Save edit mode so that it can be restored when switching the view
1320         // shell again.
1321         pDrawViewShell = ::boost::dynamic_pointer_cast<DrawViewShell>(mpViewShell);
1322         OSL_ASSERT(pDrawViewShell.get()!=NULL);
1323         if (pDrawViewShell.get() != NULL)
1324             mpImpl->meOriginalEditMode = pDrawViewShell->GetEditMode();
1325     }
1326 }
1327
1328
1329
1330
1331 void Outliner::SetPage (EditMode eEditMode, USHORT nPageIndex)
1332 {
1333     if ( ! mbRestrictSearchToSelection)
1334     {
1335         ::boost::shared_ptr<DrawViewShell> pDrawViewShell(
1336             ::boost::dynamic_pointer_cast<DrawViewShell>(mpViewShell));
1337         OSL_ASSERT(pDrawViewShell.get()!=NULL);
1338         if (pDrawViewShell.get() != NULL)
1339         {
1340             pDrawViewShell->ChangeEditMode(eEditMode, FALSE);
1341             pDrawViewShell->SwitchPage(nPageIndex);
1342         }
1343     }
1344 }
1345
1346
1347
1348
1349 void Outliner::EnterEditMode (BOOL bGrabFocus)
1350 {
1351     OutlinerView* pOutlinerView = mpImpl->GetOutlinerView();
1352     if (mbViewShellValid && pOutlinerView != NULL)
1353     {
1354         pOutlinerView->SetOutputArea( Rectangle( Point(), Size(1, 1)));
1355         SetPaperSize( mpTextObj->GetLogicRect().GetSize() );
1356         SdrPageView* pPV = mpView->GetSdrPageView();
1357
1358         // Make FuText the current function.
1359         SfxUInt16Item aItem (SID_TEXTEDIT, 1);
1360         mpViewShell->GetDispatcher()->
1361             Execute(SID_TEXTEDIT, SFX_CALLMODE_SYNCHRON |
1362                 SFX_CALLMODE_RECORD, &aItem, 0L);
1363
1364         // To be consistent with the usual behaviour in the Office the text
1365         // object that is put into edit mode would have also to be selected.
1366         // Starting the text edit mode is not enough so we do it here by
1367         // hand.
1368         mbExpectingSelectionChangeEvent = true;
1369         mpView->UnmarkAllObj (pPV);
1370         mpView->MarkObj (mpTextObj, pPV);
1371
1372         if( mpTextObj )
1373             mpTextObj->setActiveText( mnText );
1374
1375         // Turn on the edit mode for the text object.
1376         mpView->SdrBeginTextEdit(mpTextObj, pPV, mpWindow, sal_True, this, pOutlinerView, sal_True, sal_True, bGrabFocus);
1377
1378         SetUpdateMode(TRUE);
1379         mbFoundObject = TRUE;
1380     }
1381 }
1382
1383
1384
1385
1386 /*************************************************************************
1387 |*
1388 |* SpellChecker: Error-LinkHdl
1389 |*
1390 \************************************************************************/
1391
1392 IMPL_LINK_INLINE_START( Outliner, SpellError, void *, nLang )
1393 {
1394     mbError = true;
1395     String aError( ::GetLanguageString( (LanguageType)(ULONG)nLang ) );
1396     ErrorHandler::HandleError(* new StringErrorInfo(
1397                                 ERRCODE_SVX_LINGU_LANGUAGENOTEXISTS, aError) );
1398     return 0;
1399 }
1400 IMPL_LINK_INLINE_END( Outliner, SpellError, void *, nLang )
1401
1402
1403
1404
1405 ESelection Outliner::GetSearchStartPosition (void)
1406 {
1407     ESelection aPosition;
1408     if (mbDirectionIsForward)
1409     {
1410         // The default constructor uses the beginning of the text as default.
1411         aPosition = ESelection ();
1412     }
1413     else
1414     {
1415         // Retrieve the position after the last character in the last
1416         // paragraph.
1417         USHORT nParagraphCount = static_cast<USHORT>(GetParagraphCount());
1418         if (nParagraphCount == 0)
1419             aPosition = ESelection();
1420         else
1421         {
1422             xub_StrLen nLastParagraphLength = GetEditEngine().GetTextLen (
1423                 nParagraphCount-1);
1424             aPosition = ESelection (nParagraphCount-1, nLastParagraphLength);
1425         }
1426     }
1427
1428     return aPosition;
1429 }
1430
1431
1432
1433
1434 bool Outliner::HasNoPreviousMatch (void)
1435 {
1436     OutlinerView* pOutlinerView = mpImpl->GetOutlinerView();
1437
1438     DBG_ASSERT (pOutlinerView!=NULL, "outline view in Outliner::HasNoPreviousMatch is NULL");
1439
1440     // Detect whether the cursor stands at the beginning
1441     // resp. at the end of the text.
1442     return pOutlinerView->GetSelection().IsEqual(GetSearchStartPosition ()) == TRUE;
1443 }
1444
1445
1446
1447
1448 bool Outliner::HandleFailedSearch (void)
1449 {
1450     bool bContinueSearch = false;
1451
1452     OutlinerView* pOutlinerView = mpImpl->GetOutlinerView();
1453     if (pOutlinerView != NULL && mpSearchItem != NULL)
1454     {
1455         // Detect whether there is/may be a prior match.  If there is then
1456         // ask the user whether to wrap arround.  Otherwise tell the user
1457         // that there is no match.
1458         if (HasNoPreviousMatch ())
1459         {
1460             // No match found in the whole presentation.  Tell the user.
1461             InfoBox aInfoBox (NULL,
1462                 String(SdResId(STR_SAR_NOT_FOUND)));
1463             ShowModalMessageBox (aInfoBox);
1464         }
1465
1466         else
1467         {
1468             // No further matches found.  Ask the user whether to wrap
1469             // arround and start again.
1470             bContinueSearch = ShowWrapArroundDialog ();
1471         }
1472     }
1473
1474     return bContinueSearch;
1475 }
1476
1477
1478 #if ENABLE_LAYOUT
1479 #define SvxSearchDialog Window
1480 #endif
1481
1482 /** See task #95227# for discussion about correct parent for dialogs/info boxes.
1483 */
1484 ::Window* Outliner::GetParentForDialog (void)
1485 {
1486     ::Window* pParent = NULL;
1487
1488     if (meMode == SEARCH)
1489         pParent = static_cast<SvxSearchDialog*>(
1490             SfxViewFrame::Current()->GetChildWindow(
1491                 SvxSearchDialogWrapper::GetChildWindowId())->GetWindow());
1492
1493     if (pParent == NULL)
1494         pParent = mpViewShell->GetActiveWindow();
1495
1496     if (pParent == NULL)
1497         pParent = Application::GetDefDialogParent();
1498     //1.30->1.31 of sdoutl.cxx        pParent = Application::GetDefModalDialogParent();
1499
1500     return pParent;
1501 }
1502
1503 #if ENABLE_LAYOUT
1504 #undef SvxSearchDialog
1505 #endif
1506
1507
1508 SdrObject* Outliner::SetObject (
1509     const ::sd::outliner::IteratorPosition& rPosition)
1510 {
1511     SetViewMode (rPosition.mePageKind);
1512     SetPage (rPosition.meEditMode, (USHORT)rPosition.mnPageIndex);
1513     mnText = rPosition.mnText;
1514     return rPosition.mxObject.get();
1515 }
1516
1517
1518
1519
1520 void Outliner::SetViewShell (const ::boost::shared_ptr<ViewShell>& rpViewShell)
1521 {
1522     if (mpViewShell != rpViewShell)
1523     {
1524         // Set the new view shell.
1525         mpViewShell = rpViewShell;
1526         // When the outline view is not owned by us then we have to clear
1527         // that pointer so that the current one for the new view shell will
1528         // be used (in ProvideOutlinerView).
1529         //        if ( ! mbOwnOutlineView)
1530         //            mpOutlineView = NULL;
1531         if (mpViewShell.get() != NULL)
1532         {
1533             mpView = mpViewShell->GetView();
1534
1535             mpWindow = mpViewShell->GetActiveWindow();
1536
1537             mpImpl->ProvideOutlinerView(*this, mpViewShell, mpWindow);
1538             OutlinerView* pOutlinerView = mpImpl->GetOutlinerView();
1539             if (pOutlinerView != NULL)
1540                 pOutlinerView->SetWindow(mpWindow);
1541         }
1542         else
1543         {
1544             mpView = NULL;
1545             mpWindow = NULL;
1546         }
1547     }
1548 }
1549
1550
1551
1552
1553 void Outliner::HandleChangedSelection (void)
1554 {
1555     maMarkListCopy.clear();
1556     mbRestrictSearchToSelection = (mpView->AreObjectsMarked()==TRUE);
1557     if (mbRestrictSearchToSelection)
1558     {
1559         // Make a copy of the current mark list.
1560         const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
1561         ULONG nCount = rMarkList.GetMarkCount();
1562         if (nCount > 0)
1563         {
1564             maMarkListCopy.clear();
1565             maMarkListCopy.reserve (nCount);
1566             for (ULONG i=0; i<nCount; i++)
1567                 maMarkListCopy.push_back (rMarkList.GetMark(i)->GetMarkedSdrObj ());
1568         }
1569         else
1570             // No marked object.  Is this case possible?
1571             mbRestrictSearchToSelection = false;
1572     }
1573 }
1574
1575
1576
1577
1578
1579 void Outliner::StartConversion( INT16 nSourceLanguage,  INT16 nTargetLanguage,
1580         const Font *pTargetFont, INT32 nOptions, BOOL bIsInteractive )
1581 {
1582     BOOL bMultiDoc = mpViewShell->ISA(DrawViewShell);
1583
1584     meMode = TEXT_CONVERSION;
1585     mbDirectionIsForward = true;
1586     mpSearchItem = NULL;
1587     mnConversionLanguage = nSourceLanguage;
1588
1589     BeginConversion();
1590
1591     OutlinerView* pOutlinerView = mpImpl->GetOutlinerView();
1592     if (pOutlinerView != NULL)
1593     {
1594         pOutlinerView->StartTextConversion(
1595             nSourceLanguage,
1596             nTargetLanguage,
1597             pTargetFont,
1598             nOptions,
1599             bIsInteractive,
1600             bMultiDoc);
1601     }
1602
1603     EndConversion();
1604 }
1605
1606
1607
1608
1609 /** Prepare to do a text conversion on the current text object. This
1610     includes putting it into edit mode.
1611 */
1612 void Outliner::PrepareConversion (void)
1613 {
1614     SetUpdateMode(sal_True);
1615     if( HasConvertibleTextPortion( mnConversionLanguage ) )
1616     {
1617         SetUpdateMode(sal_False);
1618         mbStringFound = TRUE;
1619         mbMatchMayExist = TRUE;
1620
1621         EnterEditMode ();
1622
1623         mpDrawDocument->GetDocSh()->SetWaitCursor( FALSE );
1624         // Start seach at the right end of the current object's text
1625         // depending on the search direction.
1626 //              mpOutlineView->SetSelection (GetSearchStartPosition ());
1627     }
1628     else
1629     {
1630         SetUpdateMode(sal_False);
1631     }
1632 }
1633
1634
1635
1636
1637 void Outliner::BeginConversion (void)
1638 {
1639     SetRefDevice( SD_MOD()->GetRefDevice( *mpDrawDocument->GetDocSh() ) );
1640
1641     ViewShellBase* pBase = PTR_CAST(ViewShellBase, SfxViewShell::Current());
1642     if (pBase != NULL)
1643         SetViewShell (pBase->GetMainViewShell());
1644
1645     if (mpViewShell != NULL)
1646     {
1647         mbStringFound = FALSE;
1648
1649         // Supposed that we are not located at the very beginning/end of the
1650         // document then there may be a match in the document prior/after
1651         // the current position.
1652         mbMatchMayExist = TRUE;
1653
1654         maObjectIterator = ::sd::outliner::Iterator();
1655         maSearchStartPosition = ::sd::outliner::Iterator();
1656         RememberStartPosition();
1657
1658         mpImpl->ProvideOutlinerView(*this, mpViewShell, mpWindow);
1659
1660         HandleChangedSelection ();
1661     }
1662     ClearModifyFlag();
1663 }
1664
1665
1666
1667
1668 void Outliner::EndConversion()
1669 {
1670     EndSpelling();
1671 }
1672
1673
1674
1675
1676 sal_Bool Outliner::ConvertNextDocument()
1677 {
1678     if( mpViewShell && mpViewShell->ISA(OutlineViewShell) )
1679         return false;
1680
1681     mpDrawDocument->GetDocSh()->SetWaitCursor( TRUE );
1682
1683     Initialize ( true );
1684
1685     OutlinerView* pOutlinerView = mpImpl->GetOutlinerView();
1686     if (pOutlinerView != NULL)
1687     {
1688         mpWindow = mpViewShell->GetActiveWindow();
1689         pOutlinerView->SetWindow(mpWindow);
1690     }
1691     ProvideNextTextObject ();
1692
1693     mpDrawDocument->GetDocSh()->SetWaitCursor( FALSE );
1694     ClearModifyFlag();
1695
1696     // for text conversion we automaticly wrap around one
1697     // time and stop at the start shape
1698     if( mpFirstObj )
1699     {
1700         if( (mnText == 0) && (mpFirstObj == mpObj) )
1701             return false;
1702     }
1703     else
1704     {
1705         mpFirstObj = mpObj;
1706     }
1707
1708     return !mbEndOfSearch;
1709 }
1710
1711
1712
1713
1714 USHORT Outliner::ShowModalMessageBox (Dialog& rMessageBox)
1715 {
1716     // We assume that the parent of the given messge box is NULL, i.e. it is
1717     // modal with respect to the top application window. However, this
1718     // does not affect the search dialog.  Therefore we have to lock it here
1719     // while the message box is being shown.  We also have to take into
1720     // account that we are called during a spell check and the search dialog
1721     // is not available.
1722     ::Window* pSearchDialog = NULL;
1723     SfxChildWindow* pChildWindow = NULL;
1724     switch (meMode)
1725     {
1726         case SEARCH:
1727             pChildWindow = SfxViewFrame::Current()->GetChildWindow(
1728                 SvxSearchDialogWrapper::GetChildWindowId());
1729             break;
1730
1731         case SPELL:
1732             pChildWindow = SfxViewFrame::Current()->GetChildWindow(
1733                 SpellDialogChildWindow::GetChildWindowId());
1734             break;
1735
1736         case TEXT_CONVERSION:
1737             // There should no messages boxes be displayed while doing the
1738             // hangul hanja conversion.
1739             break;
1740     }
1741
1742     if (pChildWindow != NULL)
1743         pSearchDialog = pChildWindow->GetWindow();
1744     if (pSearchDialog != NULL)
1745         pSearchDialog->EnableInput(FALSE,TRUE);
1746
1747     USHORT nResult = rMessageBox.Execute();
1748
1749     // Unlock the search dialog.
1750     if (pSearchDialog != NULL)
1751         pSearchDialog->EnableInput(TRUE,TRUE);
1752
1753     return nResult;
1754 }
1755
1756
1757
1758
1759 //===== Outliner::Implementation ==============================================
1760
1761 Outliner::Implementation::Implementation (void)
1762     : meOriginalEditMode(EM_PAGE),
1763       mbOwnOutlineView(false),
1764       mpOutlineView(NULL)
1765 {
1766 }
1767
1768
1769
1770
1771 Outliner::Implementation::~Implementation (void)
1772 {
1773     if (mbOwnOutlineView && mpOutlineView!=NULL)
1774     {
1775         mpOutlineView->SetWindow(NULL);
1776         delete mpOutlineView;
1777         mpOutlineView = NULL;
1778     }
1779 }
1780
1781
1782
1783
1784 OutlinerView* Outliner::Implementation::GetOutlinerView ()
1785 {
1786     return mpOutlineView;
1787 }
1788
1789
1790
1791
1792 /** We try to create a new OutlinerView only when there is none available,
1793     either from an OutlinerViewShell or a previous call to
1794     ProvideOutlinerView().  This is necessary to support the spell checker
1795     which can not cope with exchanging the OutlinerView.
1796 */
1797 void Outliner::Implementation::ProvideOutlinerView (
1798     Outliner& rOutliner,
1799     const ::boost::shared_ptr<ViewShell>& rpViewShell,
1800     ::Window* pWindow)
1801 {
1802     if (rpViewShell.get() != NULL)
1803     {
1804         switch (rpViewShell->GetShellType())
1805         {
1806             case ViewShell::ST_DRAW:
1807             case ViewShell::ST_IMPRESS:
1808             case ViewShell::ST_NOTES:
1809             case ViewShell::ST_HANDOUT:
1810             {
1811                 // Create a new outline view to do the search on.
1812                 bool bInsert = false;
1813                 if (mpOutlineView!=NULL && !mbOwnOutlineView)
1814                     mpOutlineView = NULL;
1815                 if (mpOutlineView == NULL)
1816                 {
1817                     mpOutlineView = new OutlinerView(&rOutliner, pWindow);
1818                     mbOwnOutlineView = true;
1819                     bInsert = true;
1820                 }
1821                 else
1822                     mpOutlineView->SetWindow(pWindow);
1823                 ULONG nStat = mpOutlineView->GetControlWord();
1824                 nStat &= ~EV_CNTRL_AUTOSCROLL;
1825                 mpOutlineView->SetControlWord(nStat);
1826                 if (bInsert)
1827                     rOutliner.InsertView( mpOutlineView );
1828                 rOutliner.SetUpdateMode(FALSE);
1829                 mpOutlineView->SetOutputArea (Rectangle (Point(), Size(1, 1)));
1830                 rOutliner.SetPaperSize( Size(1, 1) );
1831                 rOutliner.SetText( String(), rOutliner.GetParagraph( 0 ) );
1832
1833                 meOriginalEditMode =
1834                     ::boost::static_pointer_cast<DrawViewShell>(rpViewShell)->GetEditMode();
1835             }
1836             break;
1837
1838             case ViewShell::ST_OUTLINE:
1839             {
1840                 if (mpOutlineView!=NULL && mbOwnOutlineView)
1841                     delete mpOutlineView;
1842                 mpOutlineView = rOutliner.GetView(0);
1843                 mbOwnOutlineView = false;
1844             }
1845             break;
1846
1847             default:
1848             case ViewShell::ST_NONE:
1849             case ViewShell::ST_PRESENTATION:
1850                 // Ignored
1851                 break;
1852         }
1853     }
1854 }
1855
1856
1857
1858
1859 void Outliner::Implementation::ReleaseOutlinerView (void)
1860 {
1861     if (mbOwnOutlineView)
1862     {
1863         OutlinerView* pView = mpOutlineView;
1864         mpOutlineView = NULL;
1865         mbOwnOutlineView = false;
1866         if (pView != NULL)
1867         {
1868             pView->SetWindow(NULL);
1869             delete pView;
1870         }
1871     }
1872     else
1873     {
1874         mpOutlineView = NULL;
1875     }
1876 }
1877
1878 } // end of namespace sd