1 | /* |
---|
2 | * FCKeditor - The text editor for Internet - http://www.fckeditor.net |
---|
3 | * Copyright (C) 2003-2007 Frederico Caldeira Knabben |
---|
4 | * |
---|
5 | * == BEGIN LICENSE == |
---|
6 | * |
---|
7 | * Licensed under the terms of any of the following licenses at your |
---|
8 | * choice: |
---|
9 | * |
---|
10 | * - GNU General Public License Version 2 or later (the "GPL") |
---|
11 | * http://www.gnu.org/licenses/gpl.html |
---|
12 | * |
---|
13 | * - GNU Lesser General Public License Version 2.1 or later (the "LGPL") |
---|
14 | * http://www.gnu.org/licenses/lgpl.html |
---|
15 | * |
---|
16 | * - Mozilla Public License Version 1.1 or later (the "MPL") |
---|
17 | * http://www.mozilla.org/MPL/MPL-1.1.html |
---|
18 | * |
---|
19 | * == END LICENSE == |
---|
20 | * |
---|
21 | * Creation and initialization of the "FCK" object. This is the main object |
---|
22 | * that represents an editor instance. |
---|
23 | */ |
---|
24 | |
---|
25 | // FCK represents the active editor instance. |
---|
26 | var FCK = |
---|
27 | { |
---|
28 | Name : FCKURLParams[ 'InstanceName' ], |
---|
29 | Status : FCK_STATUS_NOTLOADED, |
---|
30 | EditMode : FCK_EDITMODE_WYSIWYG, |
---|
31 | Toolbar : null, |
---|
32 | HasFocus : false, |
---|
33 | |
---|
34 | GetLinkedFieldValue : function() |
---|
35 | { |
---|
36 | return this.LinkedField.value ; |
---|
37 | }, |
---|
38 | |
---|
39 | GetParentForm : function() |
---|
40 | { |
---|
41 | return this.LinkedField.form ; |
---|
42 | } , |
---|
43 | |
---|
44 | // # START : IsDirty implementation |
---|
45 | |
---|
46 | StartupValue : '', |
---|
47 | |
---|
48 | IsDirty : function() |
---|
49 | { |
---|
50 | if ( this.EditMode == FCK_EDITMODE_SOURCE ) |
---|
51 | return ( this.StartupValue != this.EditingArea.Textarea.value ) ; |
---|
52 | else |
---|
53 | return ( this.StartupValue != this.EditorDocument.body.innerHTML ) ; |
---|
54 | }, |
---|
55 | |
---|
56 | ResetIsDirty : function() |
---|
57 | { |
---|
58 | if ( this.EditMode == FCK_EDITMODE_SOURCE ) |
---|
59 | this.StartupValue = this.EditingArea.Textarea.value ; |
---|
60 | else if ( this.EditorDocument.body ) |
---|
61 | this.StartupValue = this.EditorDocument.body.innerHTML ; |
---|
62 | }, |
---|
63 | |
---|
64 | // # END : IsDirty implementation |
---|
65 | |
---|
66 | StartEditor : function() |
---|
67 | { |
---|
68 | this.TempBaseTag = FCKConfig.BaseHref.length > 0 ? '<base href="' + FCKConfig.BaseHref + '" _fcktemp="true"></base>' : '' ; |
---|
69 | |
---|
70 | // Setup the keystroke handler. |
---|
71 | var oKeystrokeHandler = FCK.KeystrokeHandler = new FCKKeystrokeHandler() ; |
---|
72 | oKeystrokeHandler.OnKeystroke = _FCK_KeystrokeHandler_OnKeystroke ; |
---|
73 | |
---|
74 | oKeystrokeHandler.SetKeystrokes( FCKConfig.Keystrokes ) ; |
---|
75 | |
---|
76 | // In IE7, if the editor tries to access the clipboard by code, a dialog is |
---|
77 | // shown to the user asking if the application is allowed to access or not. |
---|
78 | // Due to the IE implementation of it, the KeystrokeHandler will not work |
---|
79 | //well in this case, so we must leave the pasting keys to have their default behavior. |
---|
80 | if ( FCKBrowserInfo.IsIE7 ) |
---|
81 | { |
---|
82 | if ( ( CTRL + 86 /*V*/ ) in oKeystrokeHandler.Keystrokes ) |
---|
83 | oKeystrokeHandler.SetKeystrokes( [ CTRL + 86, true ] ) ; |
---|
84 | |
---|
85 | if ( ( SHIFT + 45 /*INS*/ ) in oKeystrokeHandler.Keystrokes ) |
---|
86 | oKeystrokeHandler.SetKeystrokes( [ SHIFT + 45, true ] ) ; |
---|
87 | } |
---|
88 | |
---|
89 | this.EditingArea = new FCKEditingArea( document.getElementById( 'xEditingArea' ) ) ; |
---|
90 | this.EditingArea.FFSpellChecker = false ; |
---|
91 | |
---|
92 | // Final setup of the lists lib. |
---|
93 | FCKListsLib.Setup() ; |
---|
94 | |
---|
95 | // Set the editor's startup contents |
---|
96 | this.SetHTML( this.GetLinkedFieldValue(), true ) ; |
---|
97 | }, |
---|
98 | |
---|
99 | Focus : function() |
---|
100 | { |
---|
101 | FCK.EditingArea.Focus() ; |
---|
102 | }, |
---|
103 | |
---|
104 | SetStatus : function( newStatus ) |
---|
105 | { |
---|
106 | this.Status = newStatus ; |
---|
107 | |
---|
108 | if ( newStatus == FCK_STATUS_ACTIVE ) |
---|
109 | { |
---|
110 | FCKFocusManager.AddWindow( window, true ) ; |
---|
111 | |
---|
112 | if ( FCKBrowserInfo.IsIE ) |
---|
113 | FCKFocusManager.AddWindow( window.frameElement, true ) ; |
---|
114 | |
---|
115 | // Force the focus in the editor. |
---|
116 | if ( FCKConfig.StartupFocus ) |
---|
117 | FCK.Focus() ; |
---|
118 | } |
---|
119 | |
---|
120 | this.Events.FireEvent( 'OnStatusChange', newStatus ) ; |
---|
121 | }, |
---|
122 | |
---|
123 | // Fixes the body by moving all inline and text nodes to appropriate block |
---|
124 | // elements. |
---|
125 | FixBody : function() |
---|
126 | { |
---|
127 | var sBlockTag = FCKConfig.EnterMode ; |
---|
128 | |
---|
129 | // In 'br' mode, no fix must be done. |
---|
130 | if ( sBlockTag != 'p' && sBlockTag != 'div' ) |
---|
131 | return ; |
---|
132 | |
---|
133 | var oDocument = this.EditorDocument ; |
---|
134 | |
---|
135 | if ( !oDocument ) |
---|
136 | return ; |
---|
137 | |
---|
138 | var oBody = oDocument.body ; |
---|
139 | |
---|
140 | if ( !oBody ) |
---|
141 | return ; |
---|
142 | |
---|
143 | FCKDomTools.TrimNode( oBody ) ; |
---|
144 | |
---|
145 | var oNode = oBody.firstChild ; |
---|
146 | var oNewBlock ; |
---|
147 | |
---|
148 | while ( oNode ) |
---|
149 | { |
---|
150 | var bMoveNode = false ; |
---|
151 | |
---|
152 | switch ( oNode.nodeType ) |
---|
153 | { |
---|
154 | // Element Node. |
---|
155 | case 1 : |
---|
156 | if ( !FCKListsLib.BlockElements[ oNode.nodeName.toLowerCase() ] ) |
---|
157 | bMoveNode = true ; |
---|
158 | break ; |
---|
159 | |
---|
160 | // Text Node. |
---|
161 | case 3 : |
---|
162 | // Ignore space only or empty text. |
---|
163 | if ( oNewBlock || oNode.nodeValue.Trim().length > 0 ) |
---|
164 | bMoveNode = true ; |
---|
165 | } |
---|
166 | |
---|
167 | if ( bMoveNode ) |
---|
168 | { |
---|
169 | var oParent = oNode.parentNode ; |
---|
170 | |
---|
171 | if ( !oNewBlock ) |
---|
172 | oNewBlock = oParent.insertBefore( oDocument.createElement( sBlockTag ), oNode ) ; |
---|
173 | |
---|
174 | oNewBlock.appendChild( oParent.removeChild( oNode ) ) ; |
---|
175 | |
---|
176 | oNode = oNewBlock.nextSibling ; |
---|
177 | } |
---|
178 | else |
---|
179 | { |
---|
180 | if ( oNewBlock ) |
---|
181 | { |
---|
182 | FCKDomTools.TrimNode( oNewBlock ) ; |
---|
183 | oNewBlock = null ; |
---|
184 | } |
---|
185 | oNode = oNode.nextSibling ; |
---|
186 | } |
---|
187 | } |
---|
188 | |
---|
189 | if ( oNewBlock ) |
---|
190 | FCKDomTools.TrimNode( oNewBlock ) ; |
---|
191 | }, |
---|
192 | |
---|
193 | GetXHTML : function( format ) |
---|
194 | { |
---|
195 | // We assume that if the user is in source editing, the editor value must |
---|
196 | // represent the exact contents of the source, as the user wanted it to be. |
---|
197 | if ( FCK.EditMode == FCK_EDITMODE_SOURCE ) |
---|
198 | return FCK.EditingArea.Textarea.value ; |
---|
199 | |
---|
200 | this.FixBody() ; |
---|
201 | |
---|
202 | var sXHTML ; |
---|
203 | var oDoc = FCK.EditorDocument ; |
---|
204 | |
---|
205 | if ( !oDoc ) |
---|
206 | return null ; |
---|
207 | |
---|
208 | if ( FCKConfig.FullPage ) |
---|
209 | { |
---|
210 | sXHTML = FCKXHtml.GetXHTML( oDoc.getElementsByTagName( 'html' )[0], true, format ) ; |
---|
211 | |
---|
212 | if ( FCK.DocTypeDeclaration && FCK.DocTypeDeclaration.length > 0 ) |
---|
213 | sXHTML = FCK.DocTypeDeclaration + '\n' + sXHTML ; |
---|
214 | |
---|
215 | if ( FCK.XmlDeclaration && FCK.XmlDeclaration.length > 0 ) |
---|
216 | sXHTML = FCK.XmlDeclaration + '\n' + sXHTML ; |
---|
217 | } |
---|
218 | else |
---|
219 | { |
---|
220 | sXHTML = FCKXHtml.GetXHTML( oDoc.body, false, format ) ; |
---|
221 | |
---|
222 | if ( FCKConfig.IgnoreEmptyParagraphValue && FCKRegexLib.EmptyOutParagraph.test( sXHTML ) ) |
---|
223 | sXHTML = '' ; |
---|
224 | } |
---|
225 | |
---|
226 | // Restore protected attributes. |
---|
227 | sXHTML = FCK.ProtectEventsRestore( sXHTML ) ; |
---|
228 | |
---|
229 | if ( FCKBrowserInfo.IsIE ) |
---|
230 | sXHTML = sXHTML.replace( FCKRegexLib.ToReplace, '$1' ) ; |
---|
231 | |
---|
232 | return FCKConfig.ProtectedSource.Revert( sXHTML ) ; |
---|
233 | }, |
---|
234 | |
---|
235 | UpdateLinkedField : function() |
---|
236 | { |
---|
237 | FCK.LinkedField.value = FCK.GetXHTML( FCKConfig.FormatOutput ) ; |
---|
238 | FCK.Events.FireEvent( 'OnAfterLinkedFieldUpdate' ) ; |
---|
239 | }, |
---|
240 | |
---|
241 | RegisteredDoubleClickHandlers : new Object(), |
---|
242 | |
---|
243 | OnDoubleClick : function( element ) |
---|
244 | { |
---|
245 | var oHandler = FCK.RegisteredDoubleClickHandlers[ element.tagName ] ; |
---|
246 | if ( oHandler ) |
---|
247 | oHandler( element ) ; |
---|
248 | }, |
---|
249 | |
---|
250 | // Register objects that can handle double click operations. |
---|
251 | RegisterDoubleClickHandler : function( handlerFunction, tag ) |
---|
252 | { |
---|
253 | FCK.RegisteredDoubleClickHandlers[ tag.toUpperCase() ] = handlerFunction ; |
---|
254 | }, |
---|
255 | |
---|
256 | OnAfterSetHTML : function() |
---|
257 | { |
---|
258 | FCKDocumentProcessor.Process( FCK.EditorDocument ) ; |
---|
259 | FCKUndo.SaveUndoStep() ; |
---|
260 | |
---|
261 | FCK.Events.FireEvent( 'OnSelectionChange' ) ; |
---|
262 | FCK.Events.FireEvent( 'OnAfterSetHTML' ) ; |
---|
263 | }, |
---|
264 | |
---|
265 | // Saves URLs on links and images on special attributes, so they don't change when |
---|
266 | // moving around. |
---|
267 | ProtectUrls : function( html ) |
---|
268 | { |
---|
269 | // <A> href |
---|
270 | html = html.replace( FCKRegexLib.ProtectUrlsA , '$& _fcksavedurl=$1' ) ; |
---|
271 | |
---|
272 | // <IMG> src |
---|
273 | html = html.replace( FCKRegexLib.ProtectUrlsImg , '$& _fcksavedurl=$1' ) ; |
---|
274 | |
---|
275 | return html ; |
---|
276 | }, |
---|
277 | |
---|
278 | // Saves event attributes (like onclick) so they don't get executed while |
---|
279 | // editing. |
---|
280 | ProtectEvents : function( html ) |
---|
281 | { |
---|
282 | return html.replace( FCKRegexLib.TagsWithEvent, _FCK_ProtectEvents_ReplaceTags ) ; |
---|
283 | }, |
---|
284 | |
---|
285 | ProtectEventsRestore : function( html ) |
---|
286 | { |
---|
287 | return html.replace( FCKRegexLib.ProtectedEvents, _FCK_ProtectEvents_RestoreEvents ) ; |
---|
288 | }, |
---|
289 | |
---|
290 | ProtectTags : function( html ) |
---|
291 | { |
---|
292 | var sTags = FCKConfig.ProtectedTags ; |
---|
293 | |
---|
294 | // IE doesn't support <abbr> and it breaks it. Let's protect it. |
---|
295 | if ( FCKBrowserInfo.IsIE ) |
---|
296 | sTags += sTags.length > 0 ? '|ABBR' : 'ABBR' ; |
---|
297 | |
---|
298 | var oRegex ; |
---|
299 | if ( sTags.length > 0 ) |
---|
300 | { |
---|
301 | oRegex = new RegExp( '<(' + sTags + ')(?!\w|:)', 'gi' ) ; |
---|
302 | html = html.replace( oRegex, '<FCK:$1' ) ; |
---|
303 | |
---|
304 | oRegex = new RegExp( '<\/(' + sTags + ')>', 'gi' ) ; |
---|
305 | html = html.replace( oRegex, '<\/FCK:$1>' ) ; |
---|
306 | } |
---|
307 | |
---|
308 | // Protect some empty elements. We must do it separately becase the |
---|
309 | // original tag may not contain the closing slash, like <hr>: |
---|
310 | // - <meta> tags get executed, so if you have a redirect meta, the |
---|
311 | // content will move to the target page. |
---|
312 | // - <hr> may destroy the document structure if not well |
---|
313 | // positioned. The trick is protect it here and restore them in |
---|
314 | // the FCKDocumentProcessor. |
---|
315 | sTags = 'META' ; |
---|
316 | if ( FCKBrowserInfo.IsIE ) |
---|
317 | sTags += '|HR' ; |
---|
318 | |
---|
319 | oRegex = new RegExp( '<((' + sTags + ')(?=\s|>)[\s\S]*?)/?>', 'gi' ) ; |
---|
320 | html = html.replace( oRegex, '<FCK:$1 />' ) ; |
---|
321 | |
---|
322 | return html ; |
---|
323 | }, |
---|
324 | |
---|
325 | SetHTML : function( html, resetIsDirty ) |
---|
326 | { |
---|
327 | this.EditingArea.Mode = FCK.EditMode ; |
---|
328 | |
---|
329 | if ( FCK.EditMode == FCK_EDITMODE_WYSIWYG ) |
---|
330 | { |
---|
331 | html = FCKConfig.ProtectedSource.Protect( html ) ; |
---|
332 | |
---|
333 | // Fix for invalid self-closing tags (see #152). |
---|
334 | html = html.replace( FCKRegexLib.InvalidSelfCloseTags, '$1></$2>' ) ; |
---|
335 | |
---|
336 | html = FCK.ProtectEvents( html ) ; |
---|
337 | html = FCK.ProtectUrls( html ) ; |
---|
338 | html = FCK.ProtectTags( html ) ; |
---|
339 | |
---|
340 | // Firefox can't handle correctly the editing of the STRONG and EM tags. |
---|
341 | // We must replace them with B and I. |
---|
342 | if ( FCKBrowserInfo.IsGecko ) |
---|
343 | { |
---|
344 | html = html.replace( FCKRegexLib.StrongOpener, '<b$1' ) ; |
---|
345 | html = html.replace( FCKRegexLib.StrongCloser, '<\/b>' ) ; |
---|
346 | html = html.replace( FCKRegexLib.EmOpener, '<i$1' ) ; |
---|
347 | html = html.replace( FCKRegexLib.EmCloser, '<\/i>' ) ; |
---|
348 | } |
---|
349 | |
---|
350 | this._ForceResetIsDirty = ( resetIsDirty === true ) ; |
---|
351 | |
---|
352 | var sHtml = '' ; |
---|
353 | |
---|
354 | if ( FCKConfig.FullPage ) |
---|
355 | { |
---|
356 | // The HTML must be fixed if the <head> is not available. |
---|
357 | if ( !FCKRegexLib.HeadOpener.test( html ) ) |
---|
358 | { |
---|
359 | // Check if the <html> is available. |
---|
360 | if ( !FCKRegexLib.HtmlOpener.test( html ) ) |
---|
361 | html = '<html dir="' + FCKConfig.ContentLangDirection + '">' + html + '</html>' ; |
---|
362 | |
---|
363 | // Add the <head>. |
---|
364 | html = html.replace( FCKRegexLib.HtmlOpener, '$&<head></head>' ) ; |
---|
365 | } |
---|
366 | |
---|
367 | // Save the DOCTYPE. |
---|
368 | FCK.DocTypeDeclaration = html.match( FCKRegexLib.DocTypeTag ) ; |
---|
369 | |
---|
370 | if ( FCKBrowserInfo.IsIE ) |
---|
371 | sHtml = FCK._GetBehaviorsStyle() ; |
---|
372 | else if ( FCKConfig.ShowBorders ) |
---|
373 | sHtml = '<link href="' + FCKConfig.FullBasePath + 'css/fck_showtableborders_gecko.css" rel="stylesheet" type="text/css" _fcktemp="true" />' ; |
---|
374 | |
---|
375 | sHtml += '<link href="' + FCKConfig.FullBasePath + 'css/fck_internal.css' + '" rel="stylesheet" type="text/css" _fcktemp="true" />' ; |
---|
376 | |
---|
377 | // Attention: do not change it before testing it well (sample07)! |
---|
378 | // This is tricky... if the head ends with <meta ... content type>, |
---|
379 | // Firefox will break. But, it works if we include the temporary |
---|
380 | // links as the last elements in the HEAD. |
---|
381 | sHtml = html.replace( FCKRegexLib.HeadCloser, sHtml + '$&' ) ; |
---|
382 | |
---|
383 | // Insert the base tag (FCKConfig.BaseHref), if not exists in the source. |
---|
384 | // The base must be the first tag in the HEAD, to get relative |
---|
385 | // links on styles, for example. |
---|
386 | if ( FCK.TempBaseTag.length > 0 && !FCKRegexLib.HasBaseTag.test( html ) ) |
---|
387 | sHtml = sHtml.replace( FCKRegexLib.HeadOpener, '$&' + FCK.TempBaseTag ) ; |
---|
388 | } |
---|
389 | else |
---|
390 | { |
---|
391 | sHtml = |
---|
392 | FCKConfig.DocType + |
---|
393 | '<html dir="' + FCKConfig.ContentLangDirection + '"' ; |
---|
394 | |
---|
395 | // On IE, if you are use a DOCTYPE differenft of HTML 4 (like |
---|
396 | // XHTML), you must force the vertical scroll to show, otherwise |
---|
397 | // the horizontal one may appear when the page needs vertical scrolling. |
---|
398 | if ( FCKBrowserInfo.IsIE && !FCKRegexLib.Html4DocType.test( FCKConfig.DocType ) ) |
---|
399 | sHtml += ' style="overflow-y: scroll"' ; |
---|
400 | |
---|
401 | sHtml += |
---|
402 | '><head><title></title>' + |
---|
403 | _FCK_GetEditorAreaStyleTags() + |
---|
404 | '<link href="' + FCKConfig.FullBasePath + 'css/fck_internal.css' + '" rel="stylesheet" type="text/css" _fcktemp="true" />' ; |
---|
405 | |
---|
406 | if ( FCKBrowserInfo.IsIE ) |
---|
407 | sHtml += FCK._GetBehaviorsStyle() ; |
---|
408 | else if ( FCKConfig.ShowBorders ) |
---|
409 | sHtml += '<link href="' + FCKConfig.FullBasePath + 'css/fck_showtableborders_gecko.css" rel="stylesheet" type="text/css" _fcktemp="true" />' ; |
---|
410 | |
---|
411 | sHtml += FCK.TempBaseTag ; |
---|
412 | |
---|
413 | // Add ID and Class to the body |
---|
414 | var sBodyTag = '<body' ; |
---|
415 | if ( FCKConfig.BodyId && FCKConfig.BodyId.length > 0 ) |
---|
416 | sBodyTag += ' id="' + FCKConfig.BodyId + '"' ; |
---|
417 | if ( FCKConfig.BodyClass && FCKConfig.BodyClass.length > 0 ) |
---|
418 | sBodyTag += ' class="' + FCKConfig.BodyClass + '"' ; |
---|
419 | sHtml += '</head>' + sBodyTag + '>' ; |
---|
420 | |
---|
421 | if ( FCKBrowserInfo.IsGecko && ( html.length == 0 || FCKRegexLib.EmptyParagraph.test( html ) ) ) |
---|
422 | sHtml += GECKO_BOGUS ; |
---|
423 | else |
---|
424 | sHtml += html ; |
---|
425 | |
---|
426 | sHtml += '</body></html>' ; |
---|
427 | } |
---|
428 | |
---|
429 | this.EditingArea.OnLoad = _FCK_EditingArea_OnLoad ; |
---|
430 | this.EditingArea.Start( sHtml ) ; |
---|
431 | } |
---|
432 | else |
---|
433 | { |
---|
434 | // Remove the references to the following elements, as the editing area |
---|
435 | // IFRAME will be removed. |
---|
436 | FCK.EditorWindow = null ; |
---|
437 | FCK.EditorDocument = null ; |
---|
438 | |
---|
439 | this.EditingArea.OnLoad = null ; |
---|
440 | this.EditingArea.Start( html ) ; |
---|
441 | |
---|
442 | // Enables the context menu in the textarea. |
---|
443 | this.EditingArea.Textarea._FCKShowContextMenu = true ; |
---|
444 | |
---|
445 | // Removes the enter key handler. |
---|
446 | FCK.EnterKeyHandler = null ; |
---|
447 | |
---|
448 | if ( resetIsDirty ) |
---|
449 | this.ResetIsDirty() ; |
---|
450 | |
---|
451 | // Listen for keystroke events. |
---|
452 | FCK.KeystrokeHandler.AttachToElement( this.EditingArea.Textarea ) ; |
---|
453 | |
---|
454 | this.EditingArea.Textarea.focus() ; |
---|
455 | |
---|
456 | FCK.Events.FireEvent( 'OnAfterSetHTML' ) ; |
---|
457 | } |
---|
458 | |
---|
459 | if ( FCKBrowserInfo.IsGecko ) |
---|
460 | window.onresize() ; |
---|
461 | }, |
---|
462 | |
---|
463 | // For the FocusManager |
---|
464 | HasFocus : false, |
---|
465 | |
---|
466 | |
---|
467 | // This collection is used by the browser specific implementations to tell |
---|
468 | // wich named commands must be handled separately. |
---|
469 | RedirectNamedCommands : new Object(), |
---|
470 | |
---|
471 | ExecuteNamedCommand : function( commandName, commandParameter, noRedirect ) |
---|
472 | { |
---|
473 | FCKUndo.SaveUndoStep() ; |
---|
474 | |
---|
475 | if ( !noRedirect && FCK.RedirectNamedCommands[ commandName ] != null ) |
---|
476 | FCK.ExecuteRedirectedNamedCommand( commandName, commandParameter ) ; |
---|
477 | else |
---|
478 | { |
---|
479 | FCK.Focus() ; |
---|
480 | FCK.EditorDocument.execCommand( commandName, false, commandParameter ) ; |
---|
481 | FCK.Events.FireEvent( 'OnSelectionChange' ) ; |
---|
482 | } |
---|
483 | |
---|
484 | FCKUndo.SaveUndoStep() ; |
---|
485 | }, |
---|
486 | |
---|
487 | GetNamedCommandState : function( commandName ) |
---|
488 | { |
---|
489 | try |
---|
490 | { |
---|
491 | |
---|
492 | if ( !FCK.EditorDocument.queryCommandEnabled( commandName ) ) |
---|
493 | return FCK_TRISTATE_DISABLED ; |
---|
494 | else |
---|
495 | return FCK.EditorDocument.queryCommandState( commandName ) ? FCK_TRISTATE_ON : FCK_TRISTATE_OFF ; |
---|
496 | } |
---|
497 | catch ( e ) |
---|
498 | { |
---|
499 | return FCK_TRISTATE_OFF ; |
---|
500 | } |
---|
501 | }, |
---|
502 | |
---|
503 | GetNamedCommandValue : function( commandName ) |
---|
504 | { |
---|
505 | var sValue = '' ; |
---|
506 | var eState = FCK.GetNamedCommandState( commandName ) ; |
---|
507 | |
---|
508 | if ( eState == FCK_TRISTATE_DISABLED ) |
---|
509 | return null ; |
---|
510 | |
---|
511 | try |
---|
512 | { |
---|
513 | sValue = this.EditorDocument.queryCommandValue( commandName ) ; |
---|
514 | } |
---|
515 | catch(e) {} |
---|
516 | |
---|
517 | return sValue ? sValue : '' ; |
---|
518 | }, |
---|
519 | |
---|
520 | PasteFromWord : function() |
---|
521 | { |
---|
522 | FCKDialog.OpenDialog( 'FCKDialog_Paste', FCKLang.PasteFromWord, 'dialog/fck_paste.html', 400, 330, 'Word' ) ; |
---|
523 | }, |
---|
524 | |
---|
525 | Preview : function() |
---|
526 | { |
---|
527 | var iWidth = FCKConfig.ScreenWidth * 0.8 ; |
---|
528 | var iHeight = FCKConfig.ScreenHeight * 0.7 ; |
---|
529 | var iLeft = ( FCKConfig.ScreenWidth - iWidth ) / 2 ; |
---|
530 | var oWindow = window.open( '', null, 'toolbar=yes,location=no,status=yes,menubar=yes,scrollbars=yes,resizable=yes,width=' + iWidth + ',height=' + iHeight + ',left=' + iLeft ) ; |
---|
531 | |
---|
532 | var sHTML ; |
---|
533 | |
---|
534 | if ( FCKConfig.FullPage ) |
---|
535 | { |
---|
536 | if ( FCK.TempBaseTag.length > 0 ) |
---|
537 | sHTML = FCK.TempBaseTag + FCK.GetXHTML() ; |
---|
538 | else |
---|
539 | sHTML = FCK.GetXHTML() ; |
---|
540 | } |
---|
541 | else |
---|
542 | { |
---|
543 | sHTML = |
---|
544 | FCKConfig.DocType + |
---|
545 | '<html dir="' + FCKConfig.ContentLangDirection + '">' + |
---|
546 | '<head>' + |
---|
547 | FCK.TempBaseTag + |
---|
548 | '<title>' + FCKLang.Preview + '</title>' + |
---|
549 | _FCK_GetEditorAreaStyleTags() + |
---|
550 | '</head><body>' + |
---|
551 | FCK.GetXHTML() + |
---|
552 | '</body></html>' ; |
---|
553 | } |
---|
554 | |
---|
555 | oWindow.document.write( sHTML ); |
---|
556 | oWindow.document.close(); |
---|
557 | }, |
---|
558 | |
---|
559 | SwitchEditMode : function( noUndo ) |
---|
560 | { |
---|
561 | var bIsWysiwyg = ( FCK.EditMode == FCK_EDITMODE_WYSIWYG ) ; |
---|
562 | |
---|
563 | // Save the current IsDirty state, so we may restore it after the switch. |
---|
564 | var bIsDirty = FCK.IsDirty() ; |
---|
565 | |
---|
566 | var sHtml ; |
---|
567 | |
---|
568 | // Update the HTML in the view output to show. |
---|
569 | if ( bIsWysiwyg ) |
---|
570 | { |
---|
571 | if ( !noUndo && FCKBrowserInfo.IsIE ) |
---|
572 | FCKUndo.SaveUndoStep() ; |
---|
573 | |
---|
574 | sHtml = FCK.GetXHTML( FCKConfig.FormatSource ) ; |
---|
575 | |
---|
576 | if ( sHtml == null ) |
---|
577 | return false ; |
---|
578 | } |
---|
579 | else |
---|
580 | sHtml = this.EditingArea.Textarea.value ; |
---|
581 | |
---|
582 | FCK.EditMode = bIsWysiwyg ? FCK_EDITMODE_SOURCE : FCK_EDITMODE_WYSIWYG ; |
---|
583 | |
---|
584 | FCK.SetHTML( sHtml, !bIsDirty ) ; |
---|
585 | |
---|
586 | // Set the Focus. |
---|
587 | FCK.Focus() ; |
---|
588 | |
---|
589 | // Update the toolbar (Running it directly causes IE to fail). |
---|
590 | FCKTools.RunFunction( FCK.ToolbarSet.RefreshModeState, FCK.ToolbarSet ) ; |
---|
591 | |
---|
592 | return true ; |
---|
593 | }, |
---|
594 | |
---|
595 | CreateElement : function( tag ) |
---|
596 | { |
---|
597 | var e = FCK.EditorDocument.createElement( tag ) ; |
---|
598 | return FCK.InsertElementAndGetIt( e ) ; |
---|
599 | }, |
---|
600 | |
---|
601 | InsertElementAndGetIt : function( e ) |
---|
602 | { |
---|
603 | e.setAttribute( 'FCKTempLabel', 'true' ) ; |
---|
604 | |
---|
605 | this.InsertElement( e ) ; |
---|
606 | |
---|
607 | var aEls = FCK.EditorDocument.getElementsByTagName( e.tagName ) ; |
---|
608 | |
---|
609 | for ( var i = 0 ; i < aEls.length ; i++ ) |
---|
610 | { |
---|
611 | if ( aEls[i].getAttribute( 'FCKTempLabel' ) ) |
---|
612 | { |
---|
613 | aEls[i].removeAttribute( 'FCKTempLabel' ) ; |
---|
614 | return aEls[i] ; |
---|
615 | } |
---|
616 | } |
---|
617 | return null ; |
---|
618 | } |
---|
619 | |
---|
620 | } ; |
---|
621 | |
---|
622 | FCK.Events = new FCKEvents( FCK ) ; |
---|
623 | // GetHTML is Deprecated : returns the same value as GetXHTML. |
---|
624 | FCK.GetHTML = FCK.GetXHTML ; |
---|
625 | |
---|
626 | // Replace all events attributes (like onclick). |
---|
627 | function _FCK_ProtectEvents_ReplaceTags( tagMatch ) |
---|
628 | { |
---|
629 | return tagMatch.replace( FCKRegexLib.EventAttributes, _FCK_ProtectEvents_ReplaceEvents ) ; |
---|
630 | } |
---|
631 | |
---|
632 | // Replace an event attribute with its respective __fckprotectedatt attribute. |
---|
633 | // The original event markup will be encoded and saved as the value of the new |
---|
634 | // attribute. |
---|
635 | function _FCK_ProtectEvents_ReplaceEvents( eventMatch, attName ) |
---|
636 | { |
---|
637 | return ' ' + attName + '_fckprotectedatt="' + eventMatch.ReplaceAll( [/&/g,/'/g,/"/g,/=/g,/</g,/>/g,/\r/g,/\n/g], [''',''','"','=','<','>',' ',' '] ) + '"' ; |
---|
638 | } |
---|
639 | |
---|
640 | function _FCK_ProtectEvents_RestoreEvents( match, encodedOriginal ) |
---|
641 | { |
---|
642 | return encodedOriginal.ReplaceAll( [/'/g,/"/g,/=/g,/</g,/>/g,/ /g,/ /g,/'/g], ["'",'"','=','<','>','\r','\n','&'] ) ; |
---|
643 | } |
---|
644 | |
---|
645 | function _FCK_EditingArea_OnLoad() |
---|
646 | { |
---|
647 | // Get the editor's window and document (DOM) |
---|
648 | FCK.EditorWindow = FCK.EditingArea.Window ; |
---|
649 | FCK.EditorDocument = FCK.EditingArea.Document ; |
---|
650 | |
---|
651 | FCK.InitializeBehaviors() ; |
---|
652 | |
---|
653 | // Create the enter key handler |
---|
654 | if ( !FCKConfig.DisableEnterKeyHandler ) |
---|
655 | FCK.EnterKeyHandler = new FCKEnterKey( FCK.EditorWindow, FCKConfig.EnterMode, FCKConfig.ShiftEnterMode ) ; |
---|
656 | |
---|
657 | // Listen for keystroke events. |
---|
658 | FCK.KeystrokeHandler.AttachToElement( FCK.EditorDocument ) ; |
---|
659 | |
---|
660 | if ( FCK._ForceResetIsDirty ) |
---|
661 | FCK.ResetIsDirty() ; |
---|
662 | |
---|
663 | // This is a tricky thing for IE. In some cases, even if the cursor is |
---|
664 | // blinking in the editing, the keystroke handler doesn't catch keyboard |
---|
665 | // events. We must activate the editing area to make it work. (#142). |
---|
666 | if ( FCKBrowserInfo.IsIE && FCK.HasFocus ) |
---|
667 | FCK.EditorDocument.body.setActive() ; |
---|
668 | |
---|
669 | FCK.OnAfterSetHTML() ; |
---|
670 | |
---|
671 | // Check if it is not a startup call, otherwise complete the startup. |
---|
672 | if ( FCK.Status != FCK_STATUS_NOTLOADED ) |
---|
673 | return ; |
---|
674 | |
---|
675 | FCK.SetStatus( FCK_STATUS_ACTIVE ) ; |
---|
676 | } |
---|
677 | |
---|
678 | function _FCK_GetEditorAreaStyleTags() |
---|
679 | { |
---|
680 | var sTags = '' ; |
---|
681 | var aCSSs = FCKConfig.EditorAreaCSS ; |
---|
682 | |
---|
683 | for ( var i = 0 ; i < aCSSs.length ; i++ ) |
---|
684 | sTags += '<link href="' + aCSSs[i] + '" rel="stylesheet" type="text/css" />' ; |
---|
685 | |
---|
686 | return sTags ; |
---|
687 | } |
---|
688 | |
---|
689 | function _FCK_KeystrokeHandler_OnKeystroke( keystroke, keystrokeValue ) |
---|
690 | { |
---|
691 | if ( FCK.Status != FCK_STATUS_COMPLETE ) |
---|
692 | return false ; |
---|
693 | |
---|
694 | if ( FCK.EditMode == FCK_EDITMODE_WYSIWYG ) |
---|
695 | { |
---|
696 | if ( keystrokeValue == 'Paste' ) |
---|
697 | return !FCK.Events.FireEvent( 'OnPaste' ) ; |
---|
698 | } |
---|
699 | else |
---|
700 | { |
---|
701 | // In source mode, some actions must have their default behavior. |
---|
702 | if ( keystrokeValue.Equals( 'Paste', 'Undo', 'Redo', 'SelectAll' ) ) |
---|
703 | return false ; |
---|
704 | } |
---|
705 | |
---|
706 | // The return value indicates if the default behavior of the keystroke must |
---|
707 | // be cancelled. Let's do that only if the Execute() call explicitelly returns "false". |
---|
708 | var oCommand = FCK.Commands.GetCommand( keystrokeValue ) ; |
---|
709 | return ( oCommand.Execute.apply( oCommand, FCKTools.ArgumentsToArray( arguments, 2 ) ) !== false ) ; |
---|
710 | } |
---|
711 | |
---|
712 | // Set the FCK.LinkedField reference to the field that will be used to post the |
---|
713 | // editor data. |
---|
714 | (function() |
---|
715 | { |
---|
716 | // There is a bug on IE... getElementById returns any META tag that has the |
---|
717 | // name set to the ID you are looking for. So the best way in to get the array |
---|
718 | // by names and look for the correct one. |
---|
719 | // As ASP.Net generates a ID that is different from the Name, we must also |
---|
720 | // look for the field based on the ID (the first one is the ID). |
---|
721 | |
---|
722 | var oDocument = window.parent.document ; |
---|
723 | |
---|
724 | // Try to get the field using the ID. |
---|
725 | var eLinkedField = oDocument.getElementById( FCK.Name ) ; |
---|
726 | |
---|
727 | var i = 0; |
---|
728 | while ( eLinkedField || i == 0 ) |
---|
729 | { |
---|
730 | if ( eLinkedField && eLinkedField.tagName.toLowerCase().Equals( 'input', 'textarea' ) ) |
---|
731 | { |
---|
732 | FCK.LinkedField = eLinkedField ; |
---|
733 | break ; |
---|
734 | } |
---|
735 | |
---|
736 | eLinkedField = oDocument.getElementsByName( FCK.Name )[i++] ; |
---|
737 | } |
---|
738 | })() ; |
---|
739 | |
---|
740 | var FCKTempBin = |
---|
741 | { |
---|
742 | Elements : new Array(), |
---|
743 | |
---|
744 | AddElement : function( element ) |
---|
745 | { |
---|
746 | var iIndex = this.Elements.length ; |
---|
747 | this.Elements[ iIndex ] = element ; |
---|
748 | return iIndex ; |
---|
749 | }, |
---|
750 | |
---|
751 | RemoveElement : function( index ) |
---|
752 | { |
---|
753 | var e = this.Elements[ index ] ; |
---|
754 | this.Elements[ index ] = null ; |
---|
755 | return e ; |
---|
756 | }, |
---|
757 | |
---|
758 | Reset : function() |
---|
759 | { |
---|
760 | var i = 0 ; |
---|
761 | while ( i < this.Elements.length ) |
---|
762 | this.Elements[ i++ ] == null ; |
---|
763 | this.Elements.length = 0 ; |
---|
764 | } |
---|
765 | } ; |
---|
766 | |
---|
767 | |
---|
768 | |
---|
769 | // # Focus Manager: Manages the focus in the editor. |
---|
770 | var FCKFocusManager = FCK.FocusManager = |
---|
771 | { |
---|
772 | IsLocked : false, |
---|
773 | |
---|
774 | AddWindow : function( win, sendToEditingArea ) |
---|
775 | { |
---|
776 | var oTarget ; |
---|
777 | |
---|
778 | if ( FCKBrowserInfo.IsIE ) |
---|
779 | oTarget = win.nodeType == 1 ? win : win.frameElement ? win.frameElement : win.document ; |
---|
780 | else |
---|
781 | oTarget = win.document ; |
---|
782 | |
---|
783 | FCKTools.AddEventListener( oTarget, 'blur', FCKFocusManager_Win_OnBlur ) ; |
---|
784 | FCKTools.AddEventListener( oTarget, 'focus', sendToEditingArea ? FCKFocusManager_Win_OnFocus_Area : FCKFocusManager_Win_OnFocus ) ; |
---|
785 | }, |
---|
786 | |
---|
787 | RemoveWindow : function( win ) |
---|
788 | { |
---|
789 | if ( FCKBrowserInfo.IsIE ) |
---|
790 | oTarget = win.nodeType == 1 ? win : win.frameElement ? win.frameElement : win.document ; |
---|
791 | else |
---|
792 | oTarget = win.document ; |
---|
793 | |
---|
794 | FCKTools.RemoveEventListener( oTarget, 'blur', FCKFocusManager_Win_OnBlur ) ; |
---|
795 | FCKTools.RemoveEventListener( oTarget, 'focus', FCKFocusManager_Win_OnFocus_Area ) ; |
---|
796 | FCKTools.RemoveEventListener( oTarget, 'focus', FCKFocusManager_Win_OnFocus ) ; |
---|
797 | }, |
---|
798 | |
---|
799 | Lock : function() |
---|
800 | { |
---|
801 | this.IsLocked = true ; |
---|
802 | }, |
---|
803 | |
---|
804 | Unlock : function() |
---|
805 | { |
---|
806 | if ( this._HasPendingBlur ) |
---|
807 | FCKFocusManager._Timer = window.setTimeout( FCKFocusManager_FireOnBlur, 100 ) ; |
---|
808 | |
---|
809 | this.IsLocked = false ; |
---|
810 | }, |
---|
811 | |
---|
812 | _ResetTimer : function() |
---|
813 | { |
---|
814 | this._HasPendingBlur = false ; |
---|
815 | |
---|
816 | if ( this._Timer ) |
---|
817 | { |
---|
818 | window.clearTimeout( this._Timer ) ; |
---|
819 | delete this._Timer ; |
---|
820 | } |
---|
821 | } |
---|
822 | } ; |
---|
823 | |
---|
824 | function FCKFocusManager_Win_OnBlur() |
---|
825 | { |
---|
826 | if ( typeof(FCK) != 'undefined' && FCK.HasFocus ) |
---|
827 | { |
---|
828 | FCKFocusManager._ResetTimer() ; |
---|
829 | FCKFocusManager._Timer = window.setTimeout( FCKFocusManager_FireOnBlur, 100 ) ; |
---|
830 | } |
---|
831 | } |
---|
832 | |
---|
833 | function FCKFocusManager_FireOnBlur() |
---|
834 | { |
---|
835 | if ( FCKFocusManager.IsLocked ) |
---|
836 | FCKFocusManager._HasPendingBlur = true ; |
---|
837 | else |
---|
838 | { |
---|
839 | FCK.HasFocus = false ; |
---|
840 | FCK.Events.FireEvent( "OnBlur" ) ; |
---|
841 | } |
---|
842 | } |
---|
843 | |
---|
844 | function FCKFocusManager_Win_OnFocus_Area() |
---|
845 | { |
---|
846 | FCK.Focus() ; |
---|
847 | FCKFocusManager_Win_OnFocus() ; |
---|
848 | } |
---|
849 | |
---|
850 | function FCKFocusManager_Win_OnFocus() |
---|
851 | { |
---|
852 | FCKFocusManager._ResetTimer() ; |
---|
853 | |
---|
854 | if ( !FCK.HasFocus && !FCKFocusManager.IsLocked ) |
---|
855 | { |
---|
856 | FCK.HasFocus = true ; |
---|
857 | FCK.Events.FireEvent( "OnFocus" ) ; |
---|
858 | } |
---|
859 | } |
---|