1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
|
/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2008 by Sun Microsystems, Inc.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* $RCSfile: Outliner.hxx,v $
* $Revision: 1.16.14.2 $
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
#ifndef SD_OUTLINER_HXX
#define SD_OUTLINER_HXX
#include <svx/svdobj.hxx>
#include <svx/svdoutl.hxx>
#include "pres.hxx"
#include "OutlinerIterator.hxx"
#include <svx/SpellPortions.hxx>
#include <memory>
class Dialog;
class SdPage;
class SdrObject;
class SdrTextObj;
class SdDrawDocument;
class SfxStyleSheetPool;
class SdrObjListIter;
namespace sd {
class DrawViewShell;
class View;
class ViewShell;
class Window;
/** The main purpose of this class is searching and replacing as well as
spelling of impress documents. The main part of both tasks lies in
iterating over the pages and view modes of a document and apply the
respective function to all objects containing text on those pages.
<p>Relevant objects: There are two sets of objects to search/spell
check. One is the set of all selected objects. The other consists of
all objects on all pages in draw-, notes-, and handout view as well as
slide- and background view (draw pages and master pages).</p>
<p>Iteration: Search/replace and spelling functions operate on shapes
containing text. To cover all relevant objects an order has to be
defined on the objects. For the set of all selected objects this order
is simply the order in which they can be retrieved from the selection
object.<br>
When there is no selection the order is nested. The three modes of the
draw view are on the outer level: draw mode, notes mode, handout mode.
The inner level switches between draw pages and master pages. This
leads to the following order:
<ol>
<li>draw pages of draw mode</li>
<li>master pages of draw mode</li>
<li>draw pages of notes mode</li>
<li>master pages of notes mode</li>
<li>draw pages of handout mode</li>
<li>master pages of handout mode</li>
</ol>
Iteration starts at the top of the current page. When reaching the end
of the document, i.e. the last master page of the handout mode, it jumps
to the first draw page of draw mode. In backward searches this order is
reversed. When doing a <em>replace all</em> then the whole document is
searched for matches starting at the first page of the draw/slide view
(or last page of handout/background view even though search
direction).</p>
<p>The start position is restored after finishing spell checking or
replacing all matches in a document.</p>
<p>Some related pieces of information:
The search dialog (<type>SvxSearchDialog</type>) can be controlled in
more than one way:
<ul><li>A set of option flags returned by the slot call
SID_SEARCH_OPTIONS handled by the
<member>SdDrawDocument::GetState()</member> method.</li>
<li>The contents of the search item of type
<type>SvxSearchItem</type>.</li>
<li>The <member>HasSelection()</member> view shell method that returns
whether or not a selection exists. However, it is called from the
search dialog with an argument so that only text selections are
queried. This is only sufficient for searching the outline view.
</p>
*/
class Outliner
: public SdrOutliner
{
public:
friend class ::sd::outliner::OutlinerContainer;
/** Create a new sd outliner object.
@param pDoc
The draw document from which to take the content.
@param nMode
The valid values <const>OUTLINERMODE_DONTKNOW</const>,
<const>OUTLINERMODE_TEXTOBJECT</const>,
<const>OUTLINERMODE_TITLEOBJECT</const>,
<const>OUTLINERMODE_OUTLINEOBJECT</const>, and
<const>OUTLINERMODE_OUTLINEVIEW</const> are defined in
svx/outliner.hxx.
*/
Outliner( SdDrawDocument* pDoc, USHORT nMode );
virtual ~Outliner();
/** Despite the name this method is called prior to spell cheking *and*
searching and replacing. The position of current view
mode/page/object/caret position is remembered and, depending on the
search mode, may be restored after finishing searching/spell
checking.
*/
void PrepareSpelling (void);
/** Initialize a spell check but do not start it yet. This method
is a better candiate for the name PrepareSpelling.
*/
void StartSpelling (void);
/** Proxy for method from base class to avoid compiler warning */
void StartSpelling(EditView&, unsigned char);
/** Initiate a find and/or replace on the next relevant text object.
@return
Returns </TRUE> when the search/replace is finished (as
indicated by user input to the search dialog). A </FALSE> value
indicates that another call to this method is required.
*/
bool StartSearchAndReplace (const SvxSearchItem* pSearchItem);
/** Iterate over the sentences in all text shapes and stop at the
next sentence with spelling errors. While doing so the view
mode may be changed and text shapes are set into edit mode.
*/
::svx::SpellPortions GetNextSpellSentence (void);
/** Release all resources that have been created during the find&replace
or spell check.
*/
void EndSpelling (void);
/** callback for textconversion */
sal_Bool ConvertNextDocument (void);
/** Starts the text conversion (hangul/hanja or Chinese simplified/traditional)
for the current viewshell */
void StartConversion( INT16 nSourceLanguage, INT16 nTargetLanguage,
const Font *pTargetFont, INT32 nOptions, BOOL bIsInteractive );
/** This is called internaly when text conversion is started.
The position of current view mode/page/object/caret position
is remembered and will be restored after conversion.
*/
void BeginConversion (void);
/** Release all resources that have been created during the conversion */
void EndConversion (void);
DECL_LINK( SpellError, void * );
enum ChangeHint { CH_VIEW_SHELL_INVALID, CH_VIEW_SHELL_VALID };
/** Handle a change outside the outliner which may affect the outliner.
At the moment this is restricted to changes of the main view shell
but later may include any changes that are detected now by
DetectChange().
*/
void HandleOutsideChange (ChangeHint eHint);
int GetIgnoreCurrentPageChangesLevel() const { return mnIgnoreCurrentPageChangesLevel; };
void IncreIgnoreCurrentPageChangesLevel() { mnIgnoreCurrentPageChangesLevel++; };
void DecreIgnoreCurrentPageChangesLevel() { mnIgnoreCurrentPageChangesLevel--; };
private:
class Implementation;
::std::auto_ptr<Implementation> mpImpl;
/// Specifies whether to search and replace, to spell check or to do a
/// text conversion.
enum mode {SEARCH, SPELL, TEXT_CONVERSION} meMode;
/// The view which displays the searched objects.
::sd::View* mpView;
/// The view shell containing the view.
ViewShell* mpViewShell;
/// This window contains the view.
::sd::Window* mpWindow;
/// The document on whose objects and pages this class operates.
SdDrawDocument* mpDrawDocument;
/** this is the language that is used for current text conversion.
Only valid if meMode is TEXT_CONVERSION.
*/
INT16 mnConversionLanguage;
/** While the value of this flag is greater than 0 changes of the current page
do not lead to selecting the corresponding text in the outliner.
*/
int mnIgnoreCurrentPageChangesLevel;
/// Specifies whether the search string has been found so far.
bool mbStringFound;
/** This flag indicates whether there may exist a match of the search
string before/after the current position in the document. It can be
set to </FALSE> only when starting from the beginning/end of the
document. When reaching the end/beginning with it still be set to
</FALSE> then there exists no match and the search can be terminated.
*/
bool mbMatchMayExist;
/// The number of pages in the current view.
USHORT mnPageCount;
/// Number of objects on the current page / in the current selection.
INT32 mnObjectCount;
/** A <TRUE/> value indicates that the end of the find&replace or spell
check has been reached.
*/
bool mbEndOfSearch;
/** Set to <TRUE/> when an object has been prepared successfully for
searching/spell checking. This flag directs the internal iteration
which stops when set to </TRUE>.
*/
bool mbFoundObject;
/** When set to <TRUE/> this flag indicates that an error has occured
that should terminate the iteration over the objects to search/spell
check.
*/
bool mbError;
/** This flag indicates whether to search forward or backwards.
*/
bool mbDirectionIsForward;
/** This flag indicates that only the selected objects are to be
searched.
*/
bool mbRestrictSearchToSelection;
/** When the search is restricted to the current selection then
this list contains pointers to all the objects of the
selection. This copy is necessary because during the search
process the mark list is modified.
*/
::std::vector<SdrObjectWeakRef> maMarkListCopy;
/** This flag inidcates that only the current view is to be used for
searching and spelling. Automatically switching to other view does
not take place when this flag is set.
*/
bool mbProcessCurrentViewOnly;
/** Current object that may be a text object. The object pointer to
corresponds to <member>mnObjIndex</member>. While iterating over the
objects on a page <member>mpObj</member> will point to every object
while <member>mpTextObj</member> will be set only to valid text
objects.
*/
SdrObject* mpObj;
/** this stores the first object that is used for text conversion.
Conversion automaticly wraps around the document and stops when it
finds this object again.
*/
SdrObject* mpFirstObj;
/// Candidate for being searched/spell checked.
SdrTextObj* mpTextObj;
/// Current text to be searched/spelled inside the current text object
sal_Int32 mnText;
/// Paragraph object of <member>mpTextObj</member>.
OutlinerParaObject* mpParaObj;
/// The view mode that was active when starting to search/spell check.
PageKind meStartViewMode;
/// The master page mode that was active when starting to search/spell check.
EditMode meStartEditMode;
/// The current page index on starting to search/spell check.
USHORT mnStartPageIndex;
/// The object in edit mode when searching /spell checking was started
/// (if any).
SdrObject* mpStartEditedObject;
/// The position of the caret when searching /spell checking was started.
ESelection maStartSelection;
/** The search item contains various attributes that define the type of
search. It is set every time the
<member>SearchAndReplaceAll</member> method is called.
*/
const SvxSearchItem* mpSearchItem;
/// The actual object iterator.
::sd::outliner::Iterator maObjectIterator;
/// The current position of the object iterator.
::sd::outliner::IteratorPosition maCurrentPosition;
/// The position when the search started. Corresponds largely to the
/// m?Start* members.
::sd::outliner::Iterator maSearchStartPosition;
/** The last valid position desribes where the last text object has been
found. This position is restored when some dialogs are shown. The
position is initially set to the where the search begins.
*/
::sd::outliner::IteratorPosition maLastValidPosition;
/** This flag remebers a selection change between a call to the
selection change listener callback and the next
<member>DetectChange()</member> method call.
*/
bool mbSelectionHasChanged;
/** This flag indicates whether a selection change event is expected due
to a programatical change of the selection.
*/
bool mbExpectingSelectionChangeEvent;
/** This flag is set to true when the whole document has been
processed once 'officially', i.e. a message box has been shown
that tells the user so.
*/
bool mbWholeDocumentProcessed;
/** When this flag is true then a PrepareSpelling() is executed when
StartSearchAndReplace() is called the next time.
*/
bool mbPrepareSpellingPending;
/** In this flag we store whether the view shell is valid and may be
accessed.
*/
bool mbViewShellValid;
/** Initialize the object iterator. Call this method after being
invoked from the search or spellcheck dialog. It creates a new
iterator pointing at the current object when this has not been done
before. It reverses the direction of iteration if the given flag
differs from the current direction.
@param bDirectionIsForward
This flag specifies in which direction to iterator over the
objects. If it differs from the current direction the iterator
is reversed.
*/
void Initialize (bool bDirectionIsForward);
/** Do search and replace for whole document.
*/
bool SearchAndReplaceAll (void);
/** Do search and replace for next match.
@return
The return value specifies whether the search ended (</TRUE>) or
another call to this method is required (</FALSE>).
*/
bool SearchAndReplaceOnce (void);
/** Detect changes of the document or view and react accordingly. Such
changes may occur because different calls to
<member>SearchAndReplace()</member> there usually is user
interaction. This is at least the press of the search or replace
button but may include any other action some of which affect the
search.
*/
void DetectChange (void);
/** Detect whether the selection has changed.
@return
Return <TRUE/> when the selection has been changed since the
last call to this method.
*/
bool DetectSelectionChange (void);
/** Remember the current edited object/caret position/page/view mode
when starting to search/spell check so that it can be restored on
termination.
*/
void RememberStartPosition (void);
/** Restore the position stored in the last call of
<member>RememberStartPositiony</member>.
*/
void RestoreStartPosition (void);
/** Provide next object to search or spell check as text object in edit
mode on the current page. This skips all objects that do not
match or are no text object.
*/
void ProvideNextTextObject (void);
/** Handle the situation that the iterator has reached the last object.
This may result in setting the <member>mbEndOfSearch</member> flag
back to </FALSE>. This method may show either the end-of-search
dialog or the wrap-arround dialog.
*/
void EndOfSearch (void);
/** Prepare to commence searching/spell checking on the specified page.
This also creates a proper page iterator.
@param nPageIndex
Index of the page to prepare for searching. The default value
of -1 is a flag for using the first/last page of the current
edit mode/view mode depending on the search direction.
*/
void InitPage (USHORT nPageIndex = (USHORT)-1);
/** Show a dialog that tells the user that the search has ended either
because there are no more matches after finding at least one or that
no match has been found at all.
*/
void ShowEndOfSearchDialog (void);
/** Show a dialog that asks the user whether to wrap arround to the
beginning/end of the document and continue with the search/spell
check.
*/
bool ShowWrapArroundDialog (void);
/** Check whether the object pointed to by the iterator is a valid text
object.
@param aPosition
The object for which to test whether it is a valid text object.
*/
bool IsValidTextObject (const ::sd::outliner::IteratorPosition& rPosition);
/** Put text of current text object into outliner so that the text can
be searched/spell checked.
*/
void PutTextIntoOutliner (void);
/** Prepare to do spell checking on the current text object. This
includes putting it into edit mode. Under certain conditions this
method sets <member>mbEndOfSearch</member> to <TRUE/>.
*/
void PrepareSpellCheck (void);
/** Prepare to search and replace on the current text object. This
includes putting it into edit mode.
*/
void PrepareSearchAndReplace (void);
/** Prepare to do a text conversion on the current text
object. This includes putting it into edit mode.
*/
void PrepareConversion (void);
/** Switch to a new view mode. Try to restore the original edit mode
before doing so.
@param ePageKind
Specifies the new view mode.
*/
void SetViewMode (PageKind ePageKind);
/** Switch to the page or master page specified by the
<member>mnPage</member> index. Master page mode is specified by
<member>meEditMode</member>.
@param eEditMode
The new edit mode.
@param nPageIndex
The new page index.
*/
void SetPage (EditMode eEditMode, USHORT nPageIndex);
/** Switch on edit mode for the currently selected text object.
*/
void EnterEditMode (BOOL bGrabFocus=TRUE);
/** Return the position at which a new search is started with respect to
the search direction as specified by the argument.
@return
The position mentioned above in form of a selection with start
equals end.
*/
ESelection GetSearchStartPosition (void);
/** Detect whether there exists a previous match. Note that only the
absence of such a match can be detected reliably. An existing match
is assumed when the search started not at the beginning/end of the
presentation. This does not have to be true. The user can have set
the cursor at the middle of the text without a prior search.
@return
Returns </True> when there is no previous match and </False>
when there may be one.
*/
bool HasNoPreviousMatch (void);
/** Handle a failed search (with or without replace) for the outline
mode. Show message boxes when the search failed completely,
i.e. there is no match in the whole presentation, or when no further
match exists.
@return
The returned value indicates whether another (wrapped arround)
search shall take place. If that is so, then it is the caller's
responsibility to set the cursor position accordingly.
*/
bool HandleFailedSearch (void);
/** Return a parent window for a dialog. The returned window depends on
the search mode.
*/
::Window* GetParentForDialog (void);
/** Take a position as returned by an object iterator and switch to the
view and page on which the object specified by this position is
located.
@param rPosition
This position points to a <type>SdrObject</type> object and
contains the view and page where it is located.
@return
Return a pointer to the <type>SdrObject</type>.
*/
SdrObject* SetObject (const ::sd::outliner::IteratorPosition& rPosition);
/** Use this method when the view shell in which to search has changed.
It handles i.e. registering at the associated view as selection
change listener.
*/
void SetViewShell (ViewShell* pViewShell);
/** Activate or deactivate the search in the current selection. Call
this method whenever the selection has changed. This method creates
a copy of the current selection and reassings the object iterator to
the current() iterator.
*/
void HandleChangedSelection (void);
/** Initiate the spell check of the next relevant text object.
When the outline view is active then this method is called
after a wrap arround to continue at the beginning of the document.
@return
Returns <TRUE/> to indicate that another call to this method is
required. When all text objects have been processed then
<FALSE/> is returned.
*/
virtual BOOL SpellNextDocument (void);
/** Show the given message box and make it modal. It is assumed that
the parent of the given dialog is NULL, i.e. the application
window. This function makes sure that the otherwise non-modal
search dialog, if visible, is locked, too.
*/
USHORT ShowModalMessageBox (Dialog& rMessageBox);
};
} // end of namespace sd
#endif
|