[795] | 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 | } |
---|