?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ckeditor to version 3.2.1
[gopost.git] / ckeditor / _source / plugins / find / dialogs / find.js
blobdd7048cf76f9017f966a076a658bd529118236d7
1 /*
2 Copyright (c) 2003-2010, CKSource - Frederico Knabben. All rights reserved.
3 For licensing, see LICENSE.html or http://ckeditor.com/license
4 */
5
6 (function()
7 {
8 function nonEmptyText( node )
9 {
10 return ( node.type == CKEDITOR.NODE_TEXT && node.getLength() > 0 );
11 }
12
13 /**
14 * Elements which break characters been considered as sequence.
15 */
16 function nonCharactersBoundary ( node )
17 {
18 return !( node.type == CKEDITOR.NODE_ELEMENT && node.isBlockBoundary(
19 CKEDITOR.tools.extend( {}, CKEDITOR.dtd.$empty, CKEDITOR.dtd.$nonEditable ) ) );
20 }
21
22 /**
23 * Get the cursor object which represent both current character and it's dom
24 * position thing.
25 */
26 var cursorStep = function()
27 {
28 return {
29 textNode : this.textNode,
30 offset : this.offset,
31 character : this.textNode ?
32 this.textNode.getText().charAt( this.offset ) : null,
33 hitMatchBoundary : this._.matchBoundary
34 };
35 };
36
37 var pages = [ 'find', 'replace' ],
38 fieldsMapping = [
39 [ 'txtFindFind', 'txtFindReplace' ],
40 [ 'txtFindCaseChk', 'txtReplaceCaseChk' ],
41 [ 'txtFindWordChk', 'txtReplaceWordChk' ],
42 [ 'txtFindCyclic', 'txtReplaceCyclic' ] ];
43
44 /**
45 * Synchronize corresponding filed values between 'replace' and 'find' pages.
46 * @param {String} currentPageId The page id which receive values.
47 */
48 function syncFieldsBetweenTabs( currentPageId )
49 {
50 var sourceIndex, targetIndex,
51 sourceField, targetField;
52
53 sourceIndex = currentPageId === 'find' ? 1 : 0;
54 targetIndex = 1 - sourceIndex;
55 var i, l = fieldsMapping.length;
56 for ( i = 0 ; i < l ; i++ )
57 {
58 sourceField = this.getContentElement( pages[ sourceIndex ],
59 fieldsMapping[ i ][ sourceIndex ] );
60 targetField = this.getContentElement( pages[ targetIndex ],
61 fieldsMapping[ i ][ targetIndex ] );
62
63 targetField.setValue( sourceField.getValue() );
64 }
65 }
66
67 var findDialog = function( editor, startupPage )
68 {
69 // Style object for highlights: (#5018)
70 // 1. Defined as full match style to avoid compromising ordinary text color styles.
71 // 2. Must be apply onto inner-most text to avoid conflicting with ordinary text color styles visually.
72 var highlightStyle = new CKEDITOR.style( CKEDITOR.tools.extend( { fullMatch : true, childRule : function(){ return false; } },
73 editor.config.find_highlight ) );
74
75 /**
76 * Iterator which walk through the specified range char by char. By
77 * default the walking will not stop at the character boundaries, until
78 * the end of the range is encountered.
79 * @param { CKEDITOR.dom.range } range
80 * @param {Boolean} matchWord Whether the walking will stop at character boundary.
81 */
82 var characterWalker = function( range , matchWord )
83 {
84 var walker =
85 new CKEDITOR.dom.walker( range );
86 walker.guard = matchWord ? nonCharactersBoundary : null;
87 walker[ 'evaluator' ] = nonEmptyText;
88 walker.breakOnFalse = true;
89
90 this._ = {
91 matchWord : matchWord,
92 walker : walker,
93 matchBoundary : false
94 };
95 };
96
97 characterWalker.prototype = {
98 next : function()
99 {
100 return this.move();
101 },
102
103 back : function()
104 {
105 return this.move( true );
106 },
107
108 move : function( rtl )
109 {
110 var currentTextNode = this.textNode;
111 // Already at the end of document, no more character available.
112 if ( currentTextNode === null )
113 return cursorStep.call( this );
114
115 this._.matchBoundary = false;
116
117 // There are more characters in the text node, step forward.
118 if ( currentTextNode
119 && rtl
120 && this.offset > 0 )
121 {
122 this.offset--;
123 return cursorStep.call( this );
124 }
125 else if ( currentTextNode
126 && this.offset < currentTextNode.getLength() - 1 )
127 {
128 this.offset++;
129 return cursorStep.call( this );
130 }
131 else
132 {
133 currentTextNode = null;
134 // At the end of the text node, walking foward for the next.
135 while ( !currentTextNode )
136 {
137 currentTextNode =
138 this._.walker[ rtl ? 'previous' : 'next' ].call( this._.walker );
139
140 // Stop searching if we're need full word match OR
141 // already reach document end.
142 if ( this._.matchWord && !currentTextNode
143 ||this._.walker._.end )
144 break;
145
146 // Marking as match character boundaries.
147 if ( !currentTextNode
148 && !nonCharactersBoundary( this._.walker.current ) )
149 this._.matchBoundary = true;
150
151 }
152 // Found a fresh text node.
153 this.textNode = currentTextNode;
154 if ( currentTextNode )
155 this.offset = rtl ? currentTextNode.getLength() - 1 : 0;
156 else
157 this.offset = 0;
158 }
159
160 return cursorStep.call( this );
161 }
162
163 };
164
165 /**
166 * A range of cursors which represent a trunk of characters which try to
167 * match, it has the same length as the pattern string.
168 */
169 var characterRange = function( characterWalker, rangeLength )
170 {
171 this._ = {
172 walker : characterWalker,
173 cursors : [],
174 rangeLength : rangeLength,
175 highlightRange : null,
176 isMatched : false
177 };
178 };
179
180 characterRange.prototype = {
181 /**
182 * Translate this range to {@link CKEDITOR.dom.range}
183 */
184 toDomRange : function()
185 {
186 var range = new CKEDITOR.dom.range( editor.document );
187 var cursors = this._.cursors;
188 if ( cursors.length < 1 )
189 {
190 var textNode = this._.walker.textNode;
191 if ( textNode )
192 range.setStartAfter( textNode );
193 else
194 return null;
195 }
196 else
197 {
198 var first = cursors[0],
199 last = cursors[ cursors.length - 1 ];
200
201 range.setStart( first.textNode, first.offset );
202 range.setEnd( last.textNode, last.offset + 1 );
203 }
204
205 return range;
206 },
207 /**
208 * Reflect the latest changes from dom range.
209 */
210 updateFromDomRange : function( domRange )
211 {
212 var cursor,
213 walker = new characterWalker( domRange );
214 this._.cursors = [];
215 do
216 {
217 cursor = walker.next();
218 if ( cursor.character )
219 this._.cursors.push( cursor );
220 }
221 while ( cursor.character );
222 this._.rangeLength = this._.cursors.length;
223 },
224
225 setMatched : function()
226 {
227 this._.isMatched = true;
228 },
229
230 clearMatched : function()
231 {
232 this._.isMatched = false;
233 },
234
235 isMatched : function()
236 {
237 return this._.isMatched;
238 },
239
240 /**
241 * Hightlight the current matched chunk of text.
242 */
243 highlight : function()
244 {
245 // Do not apply if nothing is found.
246 if ( this._.cursors.length < 1 )
247 return;
248
249 // Remove the previous highlight if there's one.
250 if ( this._.highlightRange )
251 this.removeHighlight();
252
253 // Apply the highlight.
254 var range = this.toDomRange();
255 highlightStyle.applyToRange( range );
256 this._.highlightRange = range;
257
258 // Scroll the editor to the highlighted area.
259 var element = range.startContainer;
260 if ( element.type != CKEDITOR.NODE_ELEMENT )
261 element = element.getParent();
262 element.scrollIntoView();
263
264 // Update the character cursors.
265 this.updateFromDomRange( range );
266 },
267
268 /**
269 * Remove highlighted find result.
270 */
271 removeHighlight : function()
272 {
273 if ( !this._.highlightRange )
274 return;
275
276 highlightStyle.removeFromRange( this._.highlightRange );
277 this.updateFromDomRange( this._.highlightRange );
278 this._.highlightRange = null;
279 },
280
281 moveBack : function()
282 {
283 var retval = this._.walker.back(),
284 cursors = this._.cursors;
285
286 if ( retval.hitMatchBoundary )
287 this._.cursors = cursors = [];
288
289 cursors.unshift( retval );
290 if ( cursors.length > this._.rangeLength )
291 cursors.pop();
292
293 return retval;
294 },
295
296 moveNext : function()
297 {
298 var retval = this._.walker.next(),
299 cursors = this._.cursors;
300
301 // Clear the cursors queue if we've crossed a match boundary.
302 if ( retval.hitMatchBoundary )
303 this._.cursors = cursors = [];
304
305 cursors.push( retval );
306 if ( cursors.length > this._.rangeLength )
307 cursors.shift();
308
309 return retval;
310 },
311
312 getEndCharacter : function()
313 {
314 var cursors = this._.cursors;
315 if ( cursors.length < 1 )
316 return null;
317
318 return cursors[ cursors.length - 1 ].character;
319 },
320
321 getNextCharacterRange : function( maxLength )
322 {
323 var lastCursor,
324 nextRangeWalker,
325 cursors = this._.cursors;
326
327 if ( ( lastCursor = cursors[ cursors.length - 1 ] ) )
328 nextRangeWalker = new characterWalker( getRangeAfterCursor( lastCursor ) );
329 // In case it's an empty range (no cursors), figure out next range from walker (#4951).
330 else
331 nextRangeWalker = this._.walker;
332
333 return new characterRange( nextRangeWalker, maxLength );
334 },
335
336 getCursors : function()
337 {
338 return this._.cursors;
339 }
340 };
341
342
343 // The remaining document range after the character cursor.
344 function getRangeAfterCursor( cursor , inclusive )
345 {
346 var range = new CKEDITOR.dom.range();
347 range.setStart( cursor.textNode,
348 ( inclusive ? cursor.offset : cursor.offset + 1 ) );
349 range.setEndAt( editor.document.getBody(),
350 CKEDITOR.POSITION_BEFORE_END );
351 return range;
352 }
353
354 // The document range before the character cursor.
355 function getRangeBeforeCursor( cursor )
356 {
357 var range = new CKEDITOR.dom.range();
358 range.setStartAt( editor.document.getBody(),
359 CKEDITOR.POSITION_AFTER_START );
360 range.setEnd( cursor.textNode, cursor.offset );
361 return range;
362 }
363
364 var KMP_NOMATCH = 0,
365 KMP_ADVANCED = 1,
366 KMP_MATCHED = 2;
367 /**
368 * Examination the occurrence of a word which implement KMP algorithm.
369 */
370 var kmpMatcher = function( pattern, ignoreCase )
371 {
372 var overlap = [ -1 ];
373 if ( ignoreCase )
374 pattern = pattern.toLowerCase();
375 for ( var i = 0 ; i < pattern.length ; i++ )
376 {
377 overlap.push( overlap[i] + 1 );
378 while ( overlap[ i + 1 ] > 0
379 && pattern.charAt( i ) != pattern
380 .charAt( overlap[ i + 1 ] - 1 ) )
381 overlap[ i + 1 ] = overlap[ overlap[ i + 1 ] - 1 ] + 1;
382 }
383
384 this._ = {
385 overlap : overlap,
386 state : 0,
387 ignoreCase : !!ignoreCase,
388 pattern : pattern
389 };
390 };
391
392 kmpMatcher.prototype =
393 {
394 feedCharacter : function( c )
395 {
396 if ( this._.ignoreCase )
397 c = c.toLowerCase();
398
399 while ( true )
400 {
401 if ( c == this._.pattern.charAt( this._.state ) )
402 {
403 this._.state++;
404 if ( this._.state == this._.pattern.length )
405 {
406 this._.state = 0;
407 return KMP_MATCHED;
408 }
409 return KMP_ADVANCED;
410 }
411 else if ( !this._.state )
412 return KMP_NOMATCH;
413 else
414 this._.state = this._.overlap[ this._.state ];
415 }
416
417 return null;
418 },
419
420 reset : function()
421 {
422 this._.state = 0;
423 }
424 };
425
426 var wordSeparatorRegex =
427 /[.,"'?!;: \u0085\u00a0\u1680\u280e\u2028\u2029\u202f\u205f\u3000]/;
428
429 var isWordSeparator = function( c )
430 {
431 if ( !c )
432 return true;
433 var code = c.charCodeAt( 0 );
434 return ( code >= 9 && code <= 0xd )
435 || ( code >= 0x2000 && code <= 0x200a )
436 || wordSeparatorRegex.test( c );
437 };
438
439 var finder = {
440 searchRange : null,
441 matchRange : null,
442 find : function( pattern, matchCase, matchWord, matchCyclic, highlightMatched, cyclicRerun )
443 {
444 if ( !this.matchRange )
445 this.matchRange =
446 new characterRange(
447 new characterWalker( this.searchRange ),
448 pattern.length );
449 else
450 {
451 this.matchRange.removeHighlight();
452 this.matchRange = this.matchRange.getNextCharacterRange( pattern.length );
453 }
454
455 var matcher = new kmpMatcher( pattern, !matchCase ),
456 matchState = KMP_NOMATCH,
457 character = '%';
458
459 while ( character !== null )
460 {
461 this.matchRange.moveNext();
462 while ( ( character = this.matchRange.getEndCharacter() ) )
463 {
464 matchState = matcher.feedCharacter( character );
465 if ( matchState == KMP_MATCHED )
466 break;
467 if ( this.matchRange.moveNext().hitMatchBoundary )
468 matcher.reset();
469 }
470
471 if ( matchState == KMP_MATCHED )
472 {
473 if ( matchWord )
474 {
475 var cursors = this.matchRange.getCursors(),
476 tail = cursors[ cursors.length - 1 ],
477 head = cursors[ 0 ];
478
479 var headWalker = new characterWalker( getRangeBeforeCursor( head ), true ),
480 tailWalker = new characterWalker( getRangeAfterCursor( tail ), true );
481
482 if ( ! ( isWordSeparator( headWalker.back().character )
483 && isWordSeparator( tailWalker.next().character ) ) )
484 continue;
485 }
486 this.matchRange.setMatched();
487 if ( highlightMatched !== false )
488 this.matchRange.highlight();
489 return true;
490 }
491 }
492
493 this.matchRange.clearMatched();
494 this.matchRange.removeHighlight();
495 // Clear current session and restart with the default search
496 // range.
497 // Re-run the finding once for cyclic.(#3517)
498 if ( matchCyclic && !cyclicRerun )
499 {
500 this.searchRange = getSearchRange( true );
501 this.matchRange = null;
502 return arguments.callee.apply( this,
503 Array.prototype.slice.call( arguments ).concat( [ true ] ) );
504 }
505
506 return false;
507 },
508
509 /**
510 * Record how much replacement occurred toward one replacing.
511 */
512 replaceCounter : 0,
513
514 replace : function( dialog, pattern, newString, matchCase, matchWord,
515 matchCyclic , isReplaceAll )
516 {
517 // Successiveness of current replace/find.
518 var result = false;
519
520 // 1. Perform the replace when there's already a match here.
521 // 2. Otherwise perform the find but don't replace it immediately.
522 if ( this.matchRange && this.matchRange.isMatched()
523 && !this.matchRange._.isReplaced )
524 {
525 // Turn off highlight for a while when saving snapshots.
526 this.matchRange.removeHighlight();
527 var domRange = this.matchRange.toDomRange();
528 var text = editor.document.createText( newString );
529 if ( !isReplaceAll )
530 {
531 // Save undo snaps before and after the replacement.
532 var selection = editor.getSelection();
533 selection.selectRanges( [ domRange ] );
534 editor.fire( 'saveSnapshot' );
535 }
536 domRange.deleteContents();
537 domRange.insertNode( text );
538 if ( !isReplaceAll )
539 {
540 selection.selectRanges( [ domRange ] );
541 editor.fire( 'saveSnapshot' );
542 }
543 this.matchRange.updateFromDomRange( domRange );
544 if ( !isReplaceAll )
545 this.matchRange.highlight();
546 this.matchRange._.isReplaced = true;
547 this.replaceCounter++;
548 result = true;
549 }
550 else
551 result = this.find( pattern, matchCase, matchWord, matchCyclic, !isReplaceAll );
552
553 return result;
554 }
555 };
556
557 /**
558 * The range in which find/replace happened, receive from user
559 * selection prior.
560 */
561 function getSearchRange( isDefault )
562 {
563 var searchRange,
564 sel = editor.getSelection(),
565 body = editor.document.getBody();
566 if ( sel && !isDefault )
567 {
568 searchRange = sel.getRanges()[ 0 ].clone();
569 searchRange.collapse( true );
570 }
571 else
572 {
573 searchRange = new CKEDITOR.dom.range();
574 searchRange.setStartAt( body, CKEDITOR.POSITION_AFTER_START );
575 }
576 searchRange.setEndAt( body, CKEDITOR.POSITION_BEFORE_END );
577 return searchRange;
578 }
579
580 return {
581 title : editor.lang.findAndReplace.title,
582 resizable : CKEDITOR.DIALOG_RESIZE_NONE,
583 minWidth : 350,
584 minHeight : 165,
585 buttons : [ CKEDITOR.dialog.cancelButton ], //Cancel button only.
586 contents : [
587 {
588 id : 'find',
589 label : editor.lang.findAndReplace.find,
590 title : editor.lang.findAndReplace.find,
591 accessKey : '',
592 elements : [
593 {
594 type : 'hbox',
595 widths : [ '230px', '90px' ],
596 children :
597 [
598 {
599 type : 'text',
600 id : 'txtFindFind',
601 label : editor.lang.findAndReplace.findWhat,
602 isChanged : false,
603 labelLayout : 'horizontal',
604 accessKey : 'F'
605 },
606 {
607 type : 'button',
608 align : 'left',
609 style : 'width:100%',
610 label : editor.lang.findAndReplace.find,
611 onClick : function()
612 {
613 var dialog = this.getDialog();
614 if ( !finder.find( dialog.getValueOf( 'find', 'txtFindFind' ),
615 dialog.getValueOf( 'find', 'txtFindCaseChk' ),
616 dialog.getValueOf( 'find', 'txtFindWordChk' ),
617 dialog.getValueOf( 'find', 'txtFindCyclic' ) ) )
618 alert( editor.lang.findAndReplace
619 .notFoundMsg );
620 }
621 }
622 ]
623 },
624 {
625 type : 'vbox',
626 padding : 0,
627 children :
628 [
629 {
630 type : 'checkbox',
631 id : 'txtFindCaseChk',
632 isChanged : false,
633 style : 'margin-top:28px',
634 label : editor.lang.findAndReplace.matchCase
635 },
636 {
637 type : 'checkbox',
638 id : 'txtFindWordChk',
639 isChanged : false,
640 label : editor.lang.findAndReplace.matchWord
641 },
642 {
643 type : 'checkbox',
644 id : 'txtFindCyclic',
645 isChanged : false,
646 'default' : true,
647 label : editor.lang.findAndReplace.matchCyclic
648 }
649 ]
650 }
651 ]
652 },
653 {
654 id : 'replace',
655 label : editor.lang.findAndReplace.replace,
656 accessKey : 'M',
657 elements : [
658 {
659 type : 'hbox',
660 widths : [ '230px', '90px' ],
661 children :
662 [
663 {
664 type : 'text',
665 id : 'txtFindReplace',
666 label : editor.lang.findAndReplace.findWhat,
667 isChanged : false,
668 labelLayout : 'horizontal',
669 accessKey : 'F'
670 },
671 {
672 type : 'button',
673 align : 'left',
674 style : 'width:100%',
675 label : editor.lang.findAndReplace.replace,
676 onClick : function()
677 {
678 var dialog = this.getDialog();
679 if ( !finder.replace( dialog,
680 dialog.getValueOf( 'replace', 'txtFindReplace' ),
681 dialog.getValueOf( 'replace', 'txtReplace' ),
682 dialog.getValueOf( 'replace', 'txtReplaceCaseChk' ),
683 dialog.getValueOf( 'replace', 'txtReplaceWordChk' ),
684 dialog.getValueOf( 'replace', 'txtReplaceCyclic' ) ) )
685 alert( editor.lang.findAndReplace
686 .notFoundMsg );
687 }
688 }
689 ]
690 },
691 {
692 type : 'hbox',
693 widths : [ '230px', '90px' ],
694 children :
695 [
696 {
697 type : 'text',
698 id : 'txtReplace',
699 label : editor.lang.findAndReplace.replaceWith,
700 isChanged : false,
701 labelLayout : 'horizontal',
702 accessKey : 'R'
703 },
704 {
705 type : 'button',
706 align : 'left',
707 style : 'width:100%',
708 label : editor.lang.findAndReplace.replaceAll,
709 isChanged : false,
710 onClick : function()
711 {
712 var dialog = this.getDialog();
713 var replaceNums;
714
715 finder.replaceCounter = 0;
716
717 // Scope to full document.
718 finder.searchRange = getSearchRange( true );
719 if ( finder.matchRange )
720 {
721 finder.matchRange.removeHighlight();
722 finder.matchRange = null;
723 }
724 editor.fire( 'saveSnapshot' );
725 while ( finder.replace( dialog,
726 dialog.getValueOf( 'replace', 'txtFindReplace' ),
727 dialog.getValueOf( 'replace', 'txtReplace' ),
728 dialog.getValueOf( 'replace', 'txtReplaceCaseChk' ),
729 dialog.getValueOf( 'replace', 'txtReplaceWordChk' ),
730 false, true ) )
731 { /*jsl:pass*/ }
732
733 if ( finder.replaceCounter )
734 {
735 alert( editor.lang.findAndReplace.replaceSuccessMsg.replace( /%1/, finder.replaceCounter ) );
736 editor.fire( 'saveSnapshot' );
737 }
738 else
739 alert( editor.lang.findAndReplace.notFoundMsg );
740 }
741 }
742 ]
743 },
744 {
745 type : 'vbox',
746 padding : 0,
747 children :
748 [
749 {
750 type : 'checkbox',
751 id : 'txtReplaceCaseChk',
752 isChanged : false,
753 label : editor.lang.findAndReplace
754 .matchCase
755 },
756 {
757 type : 'checkbox',
758 id : 'txtReplaceWordChk',
759 isChanged : false,
760 label : editor.lang.findAndReplace
761 .matchWord
762 },
763 {
764 type : 'checkbox',
765 id : 'txtReplaceCyclic',
766 isChanged : false,
767 'default' : true,
768 label : editor.lang.findAndReplace
769 .matchCyclic
770 }
771 ]
772 }
773 ]
774 }
775 ],
776 onLoad : function()
777 {
778 var dialog = this;
779
780 //keep track of the current pattern field in use.
781 var patternField, wholeWordChkField;
782
783 //Ignore initial page select on dialog show
784 var isUserSelect = false;
785 this.on('hide', function()
786 {
787 isUserSelect = false;
788 } );
789 this.on('show', function()
790 {
791 isUserSelect = true;
792 } );
793
794 this.selectPage = CKEDITOR.tools.override( this.selectPage, function( originalFunc )
795 {
796 return function( pageId )
797 {
798 originalFunc.call( dialog, pageId );
799
800 var currPage = dialog._.tabs[ pageId ];
801 var patternFieldInput, patternFieldId, wholeWordChkFieldId;
802 patternFieldId = pageId === 'find' ? 'txtFindFind' : 'txtFindReplace';
803 wholeWordChkFieldId = pageId === 'find' ? 'txtFindWordChk' : 'txtReplaceWordChk';
804
805 patternField = dialog.getContentElement( pageId,
806 patternFieldId );
807 wholeWordChkField = dialog.getContentElement( pageId,
808 wholeWordChkFieldId );
809
810 // prepare for check pattern text filed 'keyup' event
811 if ( !currPage.initialized )
812 {
813 patternFieldInput = CKEDITOR.document
814 .getById( patternField._.inputId );
815 currPage.initialized = true;
816 }
817
818 if ( isUserSelect )
819 // synchronize fields on tab switch.
820 syncFieldsBetweenTabs.call( this, pageId );
821 };
822 } );
823
824 },
825 onShow : function()
826 {
827 // Establish initial searching start position.
828 finder.searchRange = getSearchRange();
829
830 this.selectPage( startupPage );
831 },
832 onHide : function()
833 {
834 var range;
835 if ( finder.matchRange && finder.matchRange.isMatched() )
836 {
837 finder.matchRange.removeHighlight();
838 editor.focus();
839
840 range = finder.matchRange.toDomRange();
841 if ( range )
842 editor.getSelection().selectRanges( [ range ] );
843 }
844
845 // Clear current session before dialog close
846 delete finder.matchRange;
847 },
848 onFocus : function()
849 {
850 if ( startupPage == 'replace' )
851 return this.getContentElement( 'replace', 'txtFindReplace' );
852 else
853 return this.getContentElement( 'find', 'txtFindFind' );
854 }
855 };
856 };
857
858 CKEDITOR.dialog.add( 'find', function( editor )
859 {
860 return findDialog( editor, 'find' );
861 });
862
863 CKEDITOR.dialog.add( 'replace', function( editor )
864 {
865 return findDialog( editor, 'replace' );
866 });
867 })();
spaceup