sd/inc/Outliner.hxx

   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 #ifndef INCLUDED_SD_INC_OUTLINER_HXX
  21 #define INCLUDED_SD_INC_OUTLINER_HXX
  22
  23 #include <svx/svdobj.hxx>
  24 #include <svx/svdoutl.hxx>
  25 #include "pres.hxx"
  26 #include "OutlinerIterator.hxx"
  27 #include <editeng/SpellPortions.hxx>
  28 #include <memory>
  29
  30 class Dialog;
  31 class SdrObject;
  32 class SdrTextObj;
  33 class SdDrawDocument;
  34
  35 namespace weld
  36 {
  37 class MessageDialog;
  38 }
  39
  40 namespace sd {
  41
  42 class View;
  43 class ViewShell;
  44 class Window;
  45
  46 /// Describes a single search hit: a set of rectangles on a given page.
  47 struct SearchSelection
  48 {
  49     /// 0-based index of the page that has the selection.
  50     int m_nPage;
  51     /**
  52      * List of selection rectangles in twips -- multiple rectangles only in
  53      * case the selection spans over more layout lines.
  54      */
  55     OString m_aRectangles;
  56
  57     SearchSelection(int nPage, const OString& rRectangles);
  58
  59     bool operator==(const SearchSelection& rOther) const
  60     {
  61         return m_nPage == rOther.m_nPage && m_aRectangles == rOther.m_aRectangles;
  62     }
  63 };
  64
  65 } // end of namespace sd
  66
  67
  68 /** The main purpose of this class is searching and replacing as well as
  69     spelling of impress documents.  The main part of both tasks lies in
  70     iterating over the pages and view modes of a document and apply the
  71     respective function to all objects containing text on those pages.
  72
  73     <p>Relevant objects: There are two sets of objects to search/spell
  74     check.  One is the set of all selected objects.  The other consists of
  75     all objects on all pages in draw-, notes-, and handout view as well as
  76     slide- and background view (draw pages and master pages).</p>
  77
  78     <p>Iteration: Search/replace and spelling functions operate on shapes
  79     containing text.  To cover all relevant objects an order has to be
  80     defined on the objects.  For the set of all selected objects this order
  81     is simply the order in which they can be retrieved from the selection
  82     object.<br>
  83     When there is no selection the order is nested.  The three modes of the
  84     draw view are on the outer level: draw mode, notes mode, handout mode.
  85     The inner level switches between draw pages and master pages.  This
  86     leads to the following order:
  87     <ol>
  88     <li>draw pages of draw mode</li>
  89     <li>master pages of draw mode</li>
  90     <li>draw pages of notes mode</li>
  91     <li>master pages of notes mode</li>
  92     <li>draw pages of handout mode</li>
  93     <li>master pages of handout mode</li>
  94     </ol>
  95     Iteration starts at the top of the current page.  When reaching the end
  96     of the document, i.e. the last master page of the handout mode, it jumps
  97     to the first draw page of draw mode.  In backward searches this order is
  98     reversed.  When doing a <em>replace all</em> then the whole document is
  99     searched for matches starting at the first page of the draw/slide view
 100     (or last page of handout/background view even though search
 101     direction).</p>
 102
 103     <p>The start position is restored after finishing spell checking or
 104     replacing all matches in a document.</p>
 105
 106     <p>Some related pieces of information:
 107     The search dialog (<type>SvxSearchDialog</type>) can be controlled in
 108     more than one way:
 109     <ul><li>A set of option flags returned by the slot call
 110     SID_SEARCH_OPTIONS handled by the
 111     <member>SdDrawDocument::GetState()</member> method.</li>
 112     <li>The contents of the search item of type
 113     <type>SvxSearchItem</type>.</li>
 114     <li>The <member>HasSelection()</member> view shell method that returns
 115     whether or not a selection exists.  However, it is called from the
 116     search dialog with an argument so that only text selections are
 117     queried.  This is only sufficient for searching the outline view.
 118     </p>
 119 */
 120 class SdOutliner
 121     : public SdrOutliner
 122 {
 123 public:
 124     friend class ::sd::outliner::OutlinerContainer;
 125
 126     /** Create a new sd outliner object.
 127         @param pDoc
 128             The draw document from which to take the content.
 129         @param nMode
 130             The valid values <const>OutlinerMode::DontKnow</const>,
 131             <const>OutlinerMode::TextObject</const>,
 132             <const>OutlinerMode::TitleObject</const>,
 133             <const>OutlinerMode::OutlineObject</const>, and
 134             <const>OutlinerMode::OutlineView</const> are defined in
 135             editeng/outliner.hxx.
 136     */
 137     SdOutliner( SdDrawDocument* pDoc, OutlinerMode nMode );
 138     virtual ~SdOutliner() override;
 139     /// Forbid copy construction and copy assignment
 140     SdOutliner(const Outliner&) = delete;
 141     SdOutliner& operator=(const Outliner&) = delete;
 142
 143     /** Despite the name this method is called prior to spell checking *and*
 144         searching and replacing.  The position of current view
 145         mode/page/object/caret position is remembered and, depending on the
 146         search mode, may be restored after finishing searching/spell
 147         checking.
 148     */
 149     void PrepareSpelling();
 150
 151     /** Initialize a spell check but do not start it yet.  This method
 152         is a better candidate for the name PrepareSpelling.
 153     */
 154     void StartSpelling();
 155
 156     /** Initiate a find and/or replace on the next relevant text object.
 157         @return
 158             Returns </sal_True> when the search/replace is finished (as
 159             indicated by user input to the search dialog).  A </sal_False> value
 160             indicates that another call to this method is required.
 161     */
 162     bool StartSearchAndReplace (const SvxSearchItem* pSearchItem);
 163
 164     /** Iterate over the sentences in all text shapes and stop at the
 165         next sentence with spelling errors. While doing so the view
 166         mode may be changed and text shapes are set into edit mode.
 167     */
 168     svx::SpellPortions GetNextSpellSentence();
 169
 170     /** Release all resources that have been created during the find&replace
 171         or spell check.
 172     */
 173     void EndSpelling();
 174
 175     /** callback for textconversion */
 176     bool ConvertNextDocument() override;
 177
 178     /** Starts the text conversion (hangul/hanja or Chinese simplified/traditional)
 179     for the current viewshell */
 180     void StartConversion( LanguageType nSourceLanguage,  LanguageType nTargetLanguage,
 181                 const vcl::Font *pTargetFont, sal_Int32 nOptions, bool bIsInteractive );
 182
 183     /** This is called internally when text conversion is started.
 184         The position of current view mode/page/object/caret position
 185         is remembered and will be restored after conversion.
 186     */
 187     void BeginConversion();
 188
 189     /** Release all resources that have been created during the conversion */
 190     void EndConversion();
 191
 192     enum ChangeHint { CH_VIEW_SHELL_INVALID, CH_VIEW_SHELL_VALID };
 193
 194     int         GetIgnoreCurrentPageChangesLevel() const     { return mnIgnoreCurrentPageChangesLevel; };
 195     void        IncreIgnoreCurrentPageChangesLevel()     { mnIgnoreCurrentPageChangesLevel++; };
 196     void        DecreIgnoreCurrentPageChangesLevel()     { mnIgnoreCurrentPageChangesLevel--; };
 197     SdDrawDocument* GetDoc() const { return mpDrawDocument; }
 198
 199 private:
 200     class Implementation;
 201     ::std::unique_ptr<Implementation> mpImpl;
 202
 203     /// Specifies whether to search and replace, to spell check or to do a
 204     /// text conversion.
 205     enum mode {SEARCH, SPELL, TEXT_CONVERSION} meMode;
 206
 207     /// The view which displays the searched objects.
 208     ::sd::View* mpView;
 209     /** The view shell containing the view.  It is held as weak
 210         pointer to avoid keeping it alive when the view is changed
 211         during searching.
 212     */
 213     std::weak_ptr<::sd::ViewShell> mpWeakViewShell;
 214     /// This window contains the view.
 215     VclPtr< ::sd::Window> mpWindow;
 216     /// The document on whose objects and pages this class operates.
 217     SdDrawDocument* mpDrawDocument;
 218
 219     /** this is the language that is used for current text conversion.
 220         Only valid if meMode is TEXT_CONVERSION.
 221     */
 222     LanguageType mnConversionLanguage;
 223
 224     /** While the value of this flag is greater than 0 changes of the current page
 225         do not lead to selecting the corresponding text in the outliner.
 226     */
 227     int mnIgnoreCurrentPageChangesLevel;
 228
 229     /// Specifies whether the search string has been found so far.
 230     bool mbStringFound;
 231
 232     /** This flag indicates whether there may exist a match of the search
 233         string before/after the current position in the document.  It can be
 234         set to </sal_False> only when starting from the beginning/end of the
 235         document.  When reaching the end/beginning with it still be set to
 236         </sal_False> then there exists no match and the search can be terminated.
 237     */
 238     bool mbMatchMayExist;
 239
 240     /// The number of pages in the current view.
 241     sal_uInt16 mnPageCount;
 242
 243     /** A <TRUE/> value indicates that the end of the find&replace or spell
 244         check has been reached.
 245     */
 246     bool mbEndOfSearch;
 247
 248     /** Set to <TRUE/> when an object has been prepared successfully for
 249         searching/spell checking.  This flag directs the internal iteration
 250         which stops when set to </sal_True>.
 251     */
 252     bool mbFoundObject;
 253
 254     /** This flag indicates whether to search forward or backwards.
 255     */
 256     bool mbDirectionIsForward;
 257
 258     /** This flag indicates that only the selected objects are to be
 259         searched.
 260     */
 261     bool mbRestrictSearchToSelection;
 262
 263     /** When the search is restricted to the current selection then
 264         this list contains pointers to all the objects of the
 265         selection.  This copy is necessary because during the search
 266         process the mark list is modified.
 267     */
 268     ::std::vector<tools::WeakReference<SdrObject>> maMarkListCopy;
 269
 270     /** Current object that may be a text object.  The object pointer to
 271         corresponds to <member>mnObjIndex</member>.  While iterating over the
 272         objects on a page <member>mpObj</member> will point to every object
 273         while <member>mpTextObj</member> will be set only to valid text
 274         objects.
 275     */
 276     SdrObject* mpObj;
 277
 278     /** this stores the first object that is used for text conversion.
 279         Conversion automatically wraps around the document and stops when it
 280         finds this object again.
 281     */
 282     SdrObject* mpFirstObj;
 283
 284     /// Candidate for being searched/spell checked.
 285     SdrTextObj* mpSearchSpellTextObj;
 286
 287     /// Current text to be searched/spelled inside the current text object
 288     sal_Int32 mnText;
 289
 290     /// Paragraph object of <member>mpTextObj</member>.
 291     OutlinerParaObject* mpParaObj;
 292
 293     /// The view mode that was active when starting to search/spell check.
 294     PageKind meStartViewMode;
 295
 296     /// The master page mode that was active when starting to search/spell check.
 297     EditMode meStartEditMode;
 298
 299     /// The current page index on starting to search/spell check.
 300     sal_uInt16 mnStartPageIndex;
 301
 302     /// The object in edit mode when searching /spell checking was started
 303     /// (if any).
 304     SdrObject* mpStartEditedObject;
 305
 306     /// The position of the caret when searching /spell checking was started.
 307     ESelection maStartSelection;
 308
 309     /** The search item contains various attributes that define the type of
 310         search.  It is set every time the
 311         <member>SearchAndReplaceAll</member> method is called.
 312     */
 313     const SvxSearchItem* mpSearchItem;
 314
 315     /// The actual object iterator.
 316     ::sd::outliner::Iterator maObjectIterator;
 317     /// The current position of the object iterator.
 318     ::sd::outliner::IteratorPosition maCurrentPosition;
 319     /// The position when the search started.  Corresponds largely to the
 320     /// m?Start* members.
 321     ::sd::outliner::Iterator maSearchStartPosition;
 322     /** The last valid position describes where the last text object has been
 323         found.  This position is restored when some dialogs are shown.  The
 324         position is initially set to the where the search begins.
 325     */
 326     ::sd::outliner::IteratorPosition maLastValidPosition;
 327
 328     /** When this flag is true then a PrepareSpelling() is executed when
 329         StartSearchAndReplace() is called the next time.
 330     */
 331     bool mbPrepareSpellingPending;
 332
 333     /** Initialize the object iterator.  Call this method after being
 334         invoked from the search or spellcheck dialog.  It creates a new
 335         iterator pointing at the current object when this has not been done
 336         before.  It reverses the direction of iteration if the given flag
 337         differs from the current direction.
 338         @param bDirectionIsForward
 339             This flag specifies in which direction to iterator over the
 340             objects.  If it differs from the current direction the iterator
 341             is reversed.
 342     */
 343     void Initialize (bool bDirectionIsForward);
 344
 345     /** Do search and replace for whole document.
 346     */
 347     bool SearchAndReplaceAll();
 348
 349     /** Do search and replace for next match.
 350         @param pSelections
 351             When tiled rendering and not 0, then don't emit LOK events, instead
 352             assume the caller will do so.
 353         @return
 354             The return value specifies whether the search ended (</sal_True>) or
 355             another call to this method is required (</sal_False>).
 356     */
 357     bool SearchAndReplaceOnce(std::vector<::sd::SearchSelection>* pSelections = nullptr);
 358
 359     /** Detect changes of the document or view and react accordingly.  Such
 360         changes may occur because different calls to
 361         <member>SearchAndReplace()</member> there usually is user
 362         interaction.  This is at least the press of the search or replace
 363         button but may include any other action some of which affect the
 364         search.
 365     */
 366     void DetectChange();
 367
 368     /** Detect whether the selection has changed.
 369         @return
 370             Return <TRUE/> when the selection has been changed since the
 371             last call to this method.
 372     */
 373     bool DetectSelectionChange();
 374
 375     /** Remember the current edited object/caret position/page/view mode
 376         when starting to search/spell check so that it can be restored on
 377         termination.
 378     */
 379     void RememberStartPosition();
 380
 381     /** Restore the position stored in the last call of
 382         <member>RememberStartPositiony</member>.
 383     */
 384     void RestoreStartPosition();
 385
 386     /** Provide next object to search or spell check as text object in edit
 387         mode on the current page.  This skips all objects that do not
 388         match or are no text object.
 389     */
 390     void ProvideNextTextObject();
 391
 392     /** Handle the situation that the iterator has reached the last object.
 393         This may result in setting the <member>mbEndOfSearch</member> flag
 394         back to </sal_False>.  This method may show either the end-of-search
 395         dialog or the wrap-around dialog.
 396     */
 397     void EndOfSearch();
 398
 399     /** Show a dialog that tells the user that the search has ended either
 400         because there are no more matches after finding at least one or that
 401         no match has been found at all.
 402     */
 403     void ShowEndOfSearchDialog();
 404
 405     /** Show a dialog that asks the user whether to wrap around to the
 406         beginning/end of the document and continue with the search/spell
 407         check.
 408     */
 409     bool ShowWrapArroundDialog();
 410
 411     /** Check whether the object pointed to by the iterator is a valid text
 412         object.
 413         @param aPosition
 414             The object for which to test whether it is a valid text object.
 415     */
 416     static bool IsValidTextObject (const ::sd::outliner::IteratorPosition& rPosition);
 417
 418     /** Put text of current text object into outliner so that the text can
 419         be searched/spell checked.
 420     */
 421     void PutTextIntoOutliner();
 422
 423     /** Prepare to do spell checking on the current text object.  This
 424         includes putting it into edit mode.  Under certain conditions this
 425         method sets <member>mbEndOfSearch</member> to <TRUE/>.
 426     */
 427     void PrepareSpellCheck();
 428
 429     /** Prepare to search and replace on the current text object.  This
 430         includes putting it into edit mode.
 431     */
 432     void PrepareSearchAndReplace();
 433
 434     /** Prepare to do a text conversion on the current text
 435         object. This includes putting it into edit mode.
 436     */
 437     void PrepareConversion();
 438
 439     /** Switch to a new view mode.  Try to restore the original edit mode
 440         before doing so.
 441         @param ePageKind
 442             Specifies the new view mode.
 443     */
 444     void SetViewMode (PageKind ePageKind);
 445
 446     /** Switch to the page or master page specified by the
 447         <member>mnPage</member> index.  Master page mode is specified by
 448         <member>meEditMode</member>.
 449         @param eEditMode
 450             The new edit mode.
 451         @param nPageIndex
 452             The new page index.
 453     */
 454     void SetPage (EditMode eEditMode, sal_uInt16 nPageIndex);
 455
 456     /** Switch on edit mode for the currently selected text object.
 457     */
 458     void EnterEditMode (bool bGrabFocus);
 459
 460     /** Return the position at which a new search is started with respect to
 461         the search direction as specified by the argument.
 462         @return
 463             The position mentioned above in form of a selection with start
 464             equals end.
 465     */
 466     ESelection GetSearchStartPosition();
 467
 468     /** Detect whether there exists a previous match.  Note that only the
 469         absence of such a match can be detected reliably.  An existing match
 470         is assumed when the search started not at the beginning/end of the
 471         presentation.  This does not have to be true.  The user can have set
 472         the cursor at the middle of the text without a prior search.
 473         @return
 474             Returns </True> when there is no previous match and </False>
 475             when there may be one.
 476     */
 477     bool HasNoPreviousMatch();
 478
 479     /** Handle a failed search (with or without replace) for the outline
 480         mode.  Show message boxes when the search failed completely,
 481         i.e. there is no match in the whole presentation, or when no further
 482         match exists.
 483         @return
 484             The returned value indicates whether another (wrapped around)
 485             search shall take place.  If that is so, then it is the caller's
 486             responsibility to set the cursor position accordingly.
 487     */
 488     bool HandleFailedSearch();
 489
 490     /** Take a position as returned by an object iterator and switch to the
 491         view and page on which the object specified by this position is
 492         located.
 493         @param rPosition
 494             This position points to a <type>SdrObject</type> object and
 495             contains the view and page where it is located.
 496         @return
 497             Return a pointer to the <type>SdrObject</type>.
 498     */
 499     SdrObject* SetObject (const ::sd::outliner::IteratorPosition& rPosition);
 500
 501     /** Use this method when the view shell in which to search has changed.
 502         It handles i.e. registering at the associated view as selection
 503         change listener.
 504     */
 505     void SetViewShell (const std::shared_ptr<::sd::ViewShell>& rpViewShell);
 506
 507     /** Activate or deactivate the search in the current selection.  Call
 508         this method whenever the selection has changed.  This method creates
 509         a copy of the current selection and reassigns the object iterator to
 510         the current() iterator.
 511     */
 512     void HandleChangedSelection();
 513
 514     /** Initiate the spell check of the next relevant text object.
 515         When the outline view is active then this method is called
 516         after a wrap around to continue at the beginning of the document.
 517         @return
 518             Returns <TRUE/> to indicate that another call to this method is
 519             required.  When all text objects have been processed then
 520             <FALSE/> is returned.
 521     */
 522     virtual bool SpellNextDocument() override;
 523
 524     /** Find the right parent to use for a message. This function makes sure
 525         that the otherwise non-modal search or spell dialogs, if visible, are
 526         locked, too.
 527     */
 528     VclPtr<vcl::Window> GetMessageBoxParent();
 529 };
 530
 531 #endif
 532
 533 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */