开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > WEB源码(ASP,PHP,...) > 查看源码
fck.js
资源名称：52ccc55a371572d86a7d2c6992a2591b.rar　[点击查看]
上传用户：dbstep
上传日期：2022-08-06
资源大小：2803k
文件大小：34k
源码类别：

WEB源码(ASP,PHP,...)

开发平台：

ASP/ASPX

fck.js：源码内容
  1. /*
  2.  * FCKeditor - The text editor for Internet - http://www.fckeditor.net
  3.  * Copyright (C) 2003-2009 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.  */
  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. DataProcessor : new FCKDataProcessor(),
  35. GetInstanceObject : (function()
  36. {
  37. var w = window ;
  38. return function( name )
  39. {
  40. return w[name] ;
  41. }
  42. })(),
  44. AttachToOnSelectionChange : function( functionPointer )
  45. {
  46. this.Events.AttachEvent( 'OnSelectionChange', functionPointer ) ;
  47. },
  49. GetLinkedFieldValue : function()
  50. {
  51. return this.LinkedField.value ;
  52. },
  54. GetParentForm : function()
  55. {
  56. return this.LinkedField.form ;
  57. } ,
  59. // # START : IsDirty implementation
  61. StartupValue : '',
  63. IsDirty : function()
  64. {
  65. if ( this.EditMode == FCK_EDITMODE_SOURCE )
  66. return ( this.StartupValue != this.EditingArea.Textarea.value ) ;
  67. else
  68. {
  69. // It can happen switching between design and source mode in Gecko
  70. if ( ! this.EditorDocument )
  71. return false ;
  73. return ( this.StartupValue != this.EditorDocument.body.innerHTML ) ;
  74. }
  75. },
  77. ResetIsDirty : function()
  78. {
  79. if ( this.EditMode == FCK_EDITMODE_SOURCE )
  80. this.StartupValue = this.EditingArea.Textarea.value ;
  81. else if ( this.EditorDocument.body )
  82. this.StartupValue = this.EditorDocument.body.innerHTML ;
  83. },
  85. // # END : IsDirty implementation
  87. StartEditor : function()
  88. {
  89. this.TempBaseTag = FCKConfig.BaseHref.length > 0 ? '<base href="' + FCKConfig.BaseHref + '" _fcktemp="true"></base>' : '' ;
  91. // Setup the keystroke handler.
  92. var oKeystrokeHandler = FCK.KeystrokeHandler = new FCKKeystrokeHandler() ;
  93. oKeystrokeHandler.OnKeystroke = _FCK_KeystrokeHandler_OnKeystroke ;
  95. // Set the config keystrokes.
  96. oKeystrokeHandler.SetKeystrokes( FCKConfig.Keystrokes ) ;
  98. // In IE7, if the editor tries to access the clipboard by code, a dialog is
  99. // shown to the user asking if the application is allowed to access or not.
  100. // Due to the IE implementation of it, the KeystrokeHandler will not work
  101. //well in this case, so we must leave the pasting keys to have their default behavior.
  102. if ( FCKBrowserInfo.IsIE7 )
  103. {
  104. if ( ( CTRL + 86 /*V*/ ) in oKeystrokeHandler.Keystrokes )
  105. oKeystrokeHandler.SetKeystrokes( [ CTRL + 86, true ] ) ;
  107. if ( ( SHIFT + 45 /*INS*/ ) in oKeystrokeHandler.Keystrokes )
  108. oKeystrokeHandler.SetKeystrokes( [ SHIFT + 45, true ] ) ;
  109. }
  111. // Retain default behavior for Ctrl-Backspace. (Bug #362)
  112. oKeystrokeHandler.SetKeystrokes( [ CTRL + 8, true ] ) ;
  114. this.EditingArea = new FCKEditingArea( document.getElementById( 'xEditingArea' ) ) ;
  115. this.EditingArea.FFSpellChecker = FCKConfig.FirefoxSpellChecker ;
  117. // Set the editor's startup contents.
  118. this.SetData( this.GetLinkedFieldValue(), true ) ;
  120. // Tab key handling for source mode.
  121. FCKTools.AddEventListener( document, "keydown", this._TabKeyHandler ) ;
  123. // Add selection change listeners. They must be attached only once.
  124. this.AttachToOnSelectionChange( _FCK_PaddingNodeListener ) ;
  125. if ( FCKBrowserInfo.IsGecko )
  126. this.AttachToOnSelectionChange( this._ExecCheckEmptyBlock ) ;
  128. },
  130. Focus : function()
  131. {
  132. FCK.EditingArea.Focus() ;
  133. },
  135. SetStatus : function( newStatus )
  136. {
  137. this.Status = newStatus ;
  139. if ( newStatus == FCK_STATUS_ACTIVE )
  140. {
  141. FCKFocusManager.AddWindow( window, true ) ;
  143. if ( FCKBrowserInfo.IsIE )
  144. FCKFocusManager.AddWindow( window.frameElement, true ) ;
  146. // Force the focus in the editor.
  147. if ( FCKConfig.StartupFocus )
  148. FCK.Focus() ;
  149. }
  151. this.Events.FireEvent( 'OnStatusChange', newStatus ) ;
  153. },
  155. // Fixes the body by moving all inline and text nodes to appropriate block
  156. // elements.
  157. FixBody : function()
  158. {
  159. var sBlockTag = FCKConfig.EnterMode ;
  161. // In 'br' mode, no fix must be done.
  162. if ( sBlockTag != 'p' && sBlockTag != 'div' )
  163. return ;
  165. var oDocument = this.EditorDocument ;
  167. if ( !oDocument )
  168. return ;
  170. var oBody = oDocument.body ;
  172. if ( !oBody )
  173. return ;
  175. FCKDomTools.TrimNode( oBody ) ;
  177. var oNode = oBody.firstChild ;
  178. var oNewBlock ;
  180. while ( oNode )
  181. {
  182. var bMoveNode = false ;
  184. switch ( oNode.nodeType )
  185. {
  186. // Element Node.
  187. case 1 :
  188. var nodeName = oNode.nodeName.toLowerCase() ;
  189. if ( !FCKListsLib.BlockElements[ nodeName ] &&
  190. nodeName != 'li' &&
  191. !oNode.getAttribute('_fckfakelement') &&
  192. oNode.getAttribute('_moz_dirty') == null )
  193. bMoveNode = true ;
  194. break ;
  196. // Text Node.
  197. case 3 :
  198. // Ignore space only or empty text.
  199. if ( oNewBlock || oNode.nodeValue.Trim().length > 0 )
  200. bMoveNode = true ;
  201. break;
  203. // Comment Node
  204. case 8 :
  205. if ( oNewBlock )
  206. bMoveNode = true ;
  207. break;
  208. }
  210. if ( bMoveNode )
  211. {
  212. var oParent = oNode.parentNode ;
  214. if ( !oNewBlock )
  215. oNewBlock = oParent.insertBefore( oDocument.createElement( sBlockTag ), oNode ) ;
  217. oNewBlock.appendChild( oParent.removeChild( oNode ) ) ;
  219. oNode = oNewBlock.nextSibling ;
  220. }
  221. else
  222. {
  223. if ( oNewBlock )
  224. {
  225. FCKDomTools.TrimNode( oNewBlock ) ;
  226. oNewBlock = null ;
  227. }
  228. oNode = oNode.nextSibling ;
  229. }
  230. }
  232. if ( oNewBlock )
  233. FCKDomTools.TrimNode( oNewBlock ) ;
  234. },
  236. GetData : function( format )
  237. {
  238. // We assume that if the user is in source editing, the editor value must
  239. // represent the exact contents of the source, as the user wanted it to be.
  240. if ( FCK.EditMode == FCK_EDITMODE_SOURCE )
  241. return FCK.EditingArea.Textarea.value ;
  243. this.FixBody() ;
  245. var oDoc = FCK.EditorDocument ;
  246. if ( !oDoc )
  247. return null ;
  249. var isFullPage = FCKConfig.FullPage ;
  251. // Call the Data Processor to generate the output data.
  252. var data = FCK.DataProcessor.ConvertToDataFormat(
  253. isFullPage ? oDoc.documentElement : oDoc.body,
  254. !isFullPage,
  255. FCKConfig.IgnoreEmptyParagraphValue,
  256. format ) ;
  258. // Restore protected attributes.
  259. data = FCK.ProtectEventsRestore( data ) ;
  261. if ( FCKBrowserInfo.IsIE )
  262. data = data.replace( FCKRegexLib.ToReplace, '$1' ) ;
  264. if ( isFullPage )
  265. {
  266. if ( FCK.DocTypeDeclaration && FCK.DocTypeDeclaration.length > 0 )
  267. data = FCK.DocTypeDeclaration + 'n' + data ;
  269. if ( FCK.XmlDeclaration && FCK.XmlDeclaration.length > 0 )
  270. data = FCK.XmlDeclaration + 'n' + data ;
  271. }
  273. return FCKConfig.ProtectedSource.Revert( data ) ;
  274. },
  276. UpdateLinkedField : function()
  277. {
  278. var value = FCK.GetXHTML( FCKConfig.FormatOutput ) ;
  280. if ( FCKConfig.HtmlEncodeOutput )
  281. value = FCKTools.HTMLEncode( value ) ;
  283. FCK.LinkedField.value = value ;
  284. FCK.Events.FireEvent( 'OnAfterLinkedFieldUpdate' ) ;
  285. },
  287. RegisteredDoubleClickHandlers : new Object(),
  289. OnDoubleClick : function( element )
  290. {
  291. var oCalls = FCK.RegisteredDoubleClickHandlers[ element.tagName.toUpperCase() ] ;
  293. if ( oCalls )
  294. {
  295. for ( var i = 0 ; i < oCalls.length ; i++ )
  296. oCalls[ i ]( element ) ;
  297. }
  299. // Generic handler for any element
  300. oCalls = FCK.RegisteredDoubleClickHandlers[ '*' ] ;
  302. if ( oCalls )
  303. {
  304. for ( var i = 0 ; i < oCalls.length ; i++ )
  305. oCalls[ i ]( element ) ;
  306. }
  308. },
  310. // Register objects that can handle double click operations.
  311. RegisterDoubleClickHandler : function( handlerFunction, tag )
  312. {
  313. var nodeName = tag || '*' ;
  314. nodeName = nodeName.toUpperCase() ;
  316. var aTargets ;
  318. if ( !( aTargets = FCK.RegisteredDoubleClickHandlers[ nodeName ] ) )
  319. FCK.RegisteredDoubleClickHandlers[ nodeName ] = [ handlerFunction ] ;
  320. else
  321. {
  322. // Check that the event handler isn't already registered with the same listener
  323. // It doesn't detect function pointers belonging to an object (at least in Gecko)
  324. if ( aTargets.IndexOf( handlerFunction ) == -1 )
  325. aTargets.push( handlerFunction ) ;
  326. }
  328. },
  330. OnAfterSetHTML : function()
  331. {
  332. FCKDocumentProcessor.Process( FCK.EditorDocument ) ;
  333. FCKUndo.SaveUndoStep() ;
  335. FCK.Events.FireEvent( 'OnSelectionChange' ) ;
  336. FCK.Events.FireEvent( 'OnAfterSetHTML' ) ;
  337. },
  339. // Saves URLs on links and images on special attributes, so they don't change when
  340. // moving around.
  341. ProtectUrls : function( html )
  342. {
  343. // <A> href
  344. html = html.replace( FCKRegexLib.ProtectUrlsA , '$& _fcksavedurl=$1' ) ;
  346. // <IMG> src
  347. html = html.replace( FCKRegexLib.ProtectUrlsImg , '$& _fcksavedurl=$1' ) ;
  349. // <AREA> href
  350. html = html.replace( FCKRegexLib.ProtectUrlsArea , '$& _fcksavedurl=$1' ) ;
  352. return html ;
  353. },
  355. // Saves event attributes (like onclick) so they don't get executed while
  356. // editing.
  357. ProtectEvents : function( html )
  358. {
  359. return html.replace( FCKRegexLib.TagsWithEvent, _FCK_ProtectEvents_ReplaceTags ) ;
  360. },
  362. ProtectEventsRestore : function( html )
  363. {
  364. return html.replace( FCKRegexLib.ProtectedEvents, _FCK_ProtectEvents_RestoreEvents ) ;
  365. },
  367. ProtectTags : function( html )
  368. {
  369. var sTags = FCKConfig.ProtectedTags ;
  371. // IE doesn't support <abbr> and it breaks it. Let's protect it.
  372. if ( FCKBrowserInfo.IsIE )
  373. sTags += sTags.length > 0 ? '|ABBR|XML|EMBED|OBJECT' : 'ABBR|XML|EMBED|OBJECT' ;
  375. var oRegex ;
  376. if ( sTags.length > 0 )
  377. {
  378. oRegex = new RegExp( '<(' + sTags + ')(?!w|:)', 'gi' ) ;
  379. html = html.replace( oRegex, '<FCK:$1' ) ;
  381. oRegex = new RegExp( '</(' + sTags + ')>', 'gi' ) ;
  382. html = html.replace( oRegex, '</FCK:$1>' ) ;
  383. }
  385. // Protect some empty elements. We must do it separately because the
  386. // original tag may not contain the closing slash, like <hr>:
  387. // - <meta> tags get executed, so if you have a redirect meta, the
  388. //   content will move to the target page.
  389. // - <hr> may destroy the document structure if not well
  390. //   positioned. The trick is protect it here and restore them in
  391. //   the FCKDocumentProcessor.
  392. sTags = 'META' ;
  393. if ( FCKBrowserInfo.IsIE )
  394. sTags += '|HR' ;
  396. oRegex = new RegExp( '<((' + sTags + ')(?=\s|>|/)[\s\S]*?)/?>', 'gi' ) ;
  397. html = html.replace( oRegex, '<FCK:$1 />' ) ;
  399. return html ;
  400. },
  402. SetData : function( data, resetIsDirty )
  403. {
  404. this.EditingArea.Mode = FCK.EditMode ;
  406. // If there was an onSelectionChange listener in IE we must remove it to avoid crashes #1498
  407. if ( FCKBrowserInfo.IsIE && FCK.EditorDocument )
  408. {
  409. FCK.EditorDocument.detachEvent("onselectionchange", Doc_OnSelectionChange ) ;
  410. }
  412. FCKTempBin.Reset() ;
  414. // Bug #2469: SelectionData.createRange becomes undefined after the editor
  415. // iframe is changed by FCK.SetData().
  416. FCK.Selection.Release() ;
  418. if ( FCK.EditMode == FCK_EDITMODE_WYSIWYG )
  419. {
  420. // Save the resetIsDirty for later use (async)
  421. this._ForceResetIsDirty = ( resetIsDirty === true ) ;
  423. // Protect parts of the code that must remain untouched (and invisible)
  424. // during editing.
  425. data = FCKConfig.ProtectedSource.Protect( data ) ;
  427. // Call the Data Processor to transform the data.
  428. data = FCK.DataProcessor.ConvertToHtml( data ) ;
  430. // Fix for invalid self-closing tags (see #152).
  431. data = data.replace( FCKRegexLib.InvalidSelfCloseTags, '$1></$2>' ) ;
  433. // Protect event attributes (they could get fired in the editing area).
  434. data = FCK.ProtectEvents( data ) ;
  436. // Protect some things from the browser itself.
  437. data = FCK.ProtectUrls( data ) ;
  438. data = FCK.ProtectTags( data ) ;
  440. // Insert the base tag (FCKConfig.BaseHref), if not exists in the source.
  441. // The base must be the first tag in the HEAD, to get relative
  442. // links on styles, for example.
  443. if ( FCK.TempBaseTag.length > 0 && !FCKRegexLib.HasBaseTag.test( data ) )
  444. data = data.replace( FCKRegexLib.HeadOpener, '$&' + FCK.TempBaseTag ) ;
  446. // Build the HTML for the additional things we need on <head>.
  447. var sHeadExtra = '' ;
  449. if ( !FCKConfig.FullPage )
  450. sHeadExtra += _FCK_GetEditorAreaStyleTags() ;
  452. if ( FCKBrowserInfo.IsIE )
  453. sHeadExtra += FCK._GetBehaviorsStyle() ;
  454. else if ( FCKConfig.ShowBorders )
  455. sHeadExtra += FCKTools.GetStyleHtml( FCK_ShowTableBordersCSS, true ) ;
  457. sHeadExtra += FCKTools.GetStyleHtml( FCK_InternalCSS, true ) ;
  459. // Attention: do not change it before testing it well (sample07)!
  460. // This is tricky... if the head ends with <meta ... content type>,
  461. // Firefox will break. But, it works if we place our extra stuff as
  462. // the last elements in the HEAD.
  463. data = data.replace( FCKRegexLib.HeadCloser, sHeadExtra + '$&' ) ;
  465. // Load the HTML in the editing area.
  466. this.EditingArea.OnLoad = _FCK_EditingArea_OnLoad ;
  467. this.EditingArea.Start( data ) ;
  468. }
  469. else
  470. {
  471. // Remove the references to the following elements, as the editing area
  472. // IFRAME will be removed.
  473. FCK.EditorWindow = null ;
  474. FCK.EditorDocument = null ;
  475. FCKDomTools.PaddingNode = null ;
  477. this.EditingArea.OnLoad = null ;
  478. this.EditingArea.Start( data ) ;
  480. // Enables the context menu in the textarea.
  481. this.EditingArea.Textarea._FCKShowContextMenu = true ;
  483. // Removes the enter key handler.
  484. FCK.EnterKeyHandler = null ;
  486. if ( resetIsDirty )
  487. this.ResetIsDirty() ;
  489. // Listen for keystroke events.
  490. FCK.KeystrokeHandler.AttachToElement( this.EditingArea.Textarea ) ;
  492. this.EditingArea.Textarea.focus() ;
  494. FCK.Events.FireEvent( 'OnAfterSetHTML' ) ;
  495. }
  497. if ( FCKBrowserInfo.IsGecko )
  498. window.onresize() ;
  499. },
  501. // This collection is used by the browser specific implementations to tell
  502. // which named commands must be handled separately.
  503. RedirectNamedCommands : new Object(),
  505. ExecuteNamedCommand : function( commandName, commandParameter, noRedirect, noSaveUndo )
  506. {
  507. if ( !noSaveUndo )
  508. FCKUndo.SaveUndoStep() ;
  510. if ( !noRedirect && FCK.RedirectNamedCommands[ commandName ] != null )
  511. FCK.ExecuteRedirectedNamedCommand( commandName, commandParameter ) ;
  512. else
  513. {
  514. FCK.Focus() ;
  515. FCK.EditorDocument.execCommand( commandName, false, commandParameter ) ;
  516. FCK.Events.FireEvent( 'OnSelectionChange' ) ;
  517. }
  519. if ( !noSaveUndo )
  520. FCKUndo.SaveUndoStep() ;
  521. },
  523. GetNamedCommandState : function( commandName )
  524. {
  525. try
  526. {
  528. // Bug #50 : Safari never returns positive state for the Paste command, override that.
  529. if ( FCKBrowserInfo.IsSafari && FCK.EditorWindow && commandName.IEquals( 'Paste' ) )
  530. return FCK_TRISTATE_OFF ;
  532. if ( !FCK.EditorDocument.queryCommandEnabled( commandName ) )
  533. return FCK_TRISTATE_DISABLED ;
  534. else
  535. {
  536. return FCK.EditorDocument.queryCommandState( commandName ) ? FCK_TRISTATE_ON : FCK_TRISTATE_OFF ;
  537. }
  538. }
  539. catch ( e )
  540. {
  541. return FCK_TRISTATE_OFF ;
  542. }
  543. },
  545. GetNamedCommandValue : function( commandName )
  546. {
  547. var sValue = '' ;
  548. var eState = FCK.GetNamedCommandState( commandName ) ;
  550. if ( eState == FCK_TRISTATE_DISABLED )
  551. return null ;
  553. try
  554. {
  555. sValue = this.EditorDocument.queryCommandValue( commandName ) ;
  556. }
  557. catch(e) {}
  559. return sValue ? sValue : '' ;
  560. },
  562. Paste : function( _callListenersOnly )
  563. {
  564. // First call 'OnPaste' listeners.
  565. if ( FCK.Status != FCK_STATUS_COMPLETE || !FCK.Events.FireEvent( 'OnPaste' ) )
  566. return false ;
  568. // Then call the default implementation.
  569. return _callListenersOnly || FCK._ExecPaste() ;
  570. },
  572. PasteFromWord : function()
  573. {
  574. FCKDialog.OpenDialog( 'FCKDialog_Paste', FCKLang.PasteFromWord, 'dialog/fck_paste.html', 400, 330, 'Word' ) ;
  575. },
  577. Preview : function()
  578. {
  579. var sHTML ;
  581. if ( FCKConfig.FullPage )
  582. {
  583. if ( FCK.TempBaseTag.length > 0 )
  584. sHTML = FCK.TempBaseTag + FCK.GetXHTML() ;
  585. else
  586. sHTML = FCK.GetXHTML() ;
  587. }
  588. else
  589. {
  590. sHTML =
  591. FCKConfig.DocType +
  592. '<html dir="' + FCKConfig.ContentLangDirection + '">' +
  593. '<head>' +
  594. FCK.TempBaseTag +
  595. '<title>' + FCKLang.Preview + '</title>' +
  596. _FCK_GetEditorAreaStyleTags() +
  597. '</head><body' + FCKConfig.GetBodyAttributes() + '>' +
  598. FCK.GetXHTML() +
  599. '</body></html>' ;
  600. }
  602. var iWidth = FCKConfig.ScreenWidth * 0.8 ;
  603. var iHeight = FCKConfig.ScreenHeight * 0.7 ;
  604. var iLeft = ( FCKConfig.ScreenWidth - iWidth ) / 2 ;
  606. var sOpenUrl = '' ;
  607. if ( FCK_IS_CUSTOM_DOMAIN && FCKBrowserInfo.IsIE)
  608. {
  609. window._FCKHtmlToLoad = sHTML ;
  610. sOpenUrl = 'javascript:void( (function(){' +
  611. 'document.open() ;' +
  612. 'document.domain="' + document.domain + '" ;' +
  613. 'document.write( window.opener._FCKHtmlToLoad );' +
  614. 'document.close() ;' +
  615. 'window.opener._FCKHtmlToLoad = null ;' +
  616. '})() )' ;
  617. }
  619. var oWindow = window.open( sOpenUrl, null, 'toolbar=yes,location=no,status=yes,menubar=yes,scrollbars=yes,resizable=yes,width=' + iWidth + ',height=' + iHeight + ',left=' + iLeft ) ;
  621. if ( !FCK_IS_CUSTOM_DOMAIN || !FCKBrowserInfo.IsIE)
  622. {
  623. oWindow.document.write( sHTML );
  624. oWindow.document.close();
  625. }
  627. },
  629. SwitchEditMode : function( noUndo )
  630. {
  631. var bIsWysiwyg = ( FCK.EditMode == FCK_EDITMODE_WYSIWYG ) ;
  633. // Save the current IsDirty state, so we may restore it after the switch.
  634. var bIsDirty = FCK.IsDirty() ;
  636. var sHtml ;
  638. // Update the HTML in the view output to show, also update
  639. // FCKTempBin for IE to avoid #2263.
  640. if ( bIsWysiwyg )
  641. {
  642. FCKCommands.GetCommand( 'ShowBlocks' ).SaveState() ;
  643. if ( !noUndo && FCKBrowserInfo.IsIE )
  644. FCKUndo.SaveUndoStep() ;
  646. sHtml = FCK.GetXHTML( FCKConfig.FormatSource ) ;
  648. if ( FCKBrowserInfo.IsIE )
  649. FCKTempBin.ToHtml() ;
  651. if ( sHtml == null )
  652. return false ;
  653. }
  654. else
  655. sHtml = this.EditingArea.Textarea.value ;
  657. FCK.EditMode = bIsWysiwyg ? FCK_EDITMODE_SOURCE : FCK_EDITMODE_WYSIWYG ;
  659. FCK.SetData( sHtml, !bIsDirty ) ;
  661. // Set the Focus.
  662. FCK.Focus() ;
  664. // Update the toolbar (Running it directly causes IE to fail).
  665. FCKTools.RunFunction( FCK.ToolbarSet.RefreshModeState, FCK.ToolbarSet ) ;
  667. return true ;
  668. },
  670. InsertElement : function( element )
  671. {
  672. // The parameter may be a string (element name), so transform it in an element.
  673. if ( typeof element == 'string' )
  674. element = this.EditorDocument.createElement( element ) ;
  676. var elementName = element.nodeName.toLowerCase() ;
  678. FCKSelection.Restore() ;
  680. // Create a range for the selection. V3 will have a new selection
  681. // object that may internally supply this feature.
  682. var range = new FCKDomRange( this.EditorWindow ) ;
  684. // Move to the selection and delete it.
  685. range.MoveToSelection() ;
  686. range.DeleteContents() ;
  688. if ( FCKListsLib.BlockElements[ elementName ] != null )
  689. {
  690. if ( range.StartBlock )
  691. {
  692. if ( range.CheckStartOfBlock() )
  693. range.MoveToPosition( range.StartBlock, 3 ) ;
  694. else if ( range.CheckEndOfBlock() )
  695. range.MoveToPosition( range.StartBlock, 4 ) ;
  696. else
  697. range.SplitBlock() ;
  698. }
  700. range.InsertNode( element ) ;
  702. var next = FCKDomTools.GetNextSourceElement( element, false, null, [ 'hr','br','param','img','area','input' ], true ) ;
  704. // Be sure that we have something after the new element, so we can move the cursor there.
  705. if ( !next && FCKConfig.EnterMode != 'br')
  706. {
  707. next = this.EditorDocument.body.appendChild( this.EditorDocument.createElement( FCKConfig.EnterMode ) ) ;
  709. if ( FCKBrowserInfo.IsGeckoLike )
  710. FCKTools.AppendBogusBr( next ) ;
  711. }
  713. if ( FCKListsLib.EmptyElements[ elementName ] == null )
  714. range.MoveToElementEditStart( element ) ;
  715. else if ( next )
  716. range.MoveToElementEditStart( next ) ;
  717. else
  718. range.MoveToPosition( element, 4 ) ;
  720. if ( FCKBrowserInfo.IsGeckoLike )
  721. {
  722. if ( next )
  723. FCKDomTools.ScrollIntoView( next, false );
  724. FCKDomTools.ScrollIntoView( element, false );
  725. }
  726. }
  727. else
  728. {
  729. // Insert the node.
  730. range.InsertNode( element ) ;
  732. // Move the selection right after the new element.
  733. // DISCUSSION: Should we select the element instead?
  734. range.SetStart( element, 4 ) ;
  735. range.SetEnd( element, 4 ) ;
  736. }
  738. range.Select() ;
  739. range.Release() ;
  741. // REMOVE IT: The focus should not really be set here. It is up to the
  742. // calling code to reset the focus if needed.
  743. this.Focus() ;
  745. return element ;
  746. },
  748. _InsertBlockElement : function( blockElement )
  749. {
  750. },
  752. _IsFunctionKey : function( keyCode )
  753. {
  754. // keys that are captured but do not change editor contents
  755. if ( keyCode >= 16 && keyCode <= 20 )
  756. // shift, ctrl, alt, pause, capslock
  757. return true ;
  758. if ( keyCode == 27 || ( keyCode >= 33 && keyCode <= 40 ) )
  759. // esc, page up, page down, end, home, left, up, right, down
  760. return true ;
  761. if ( keyCode == 45 )
  762. // insert, no effect on FCKeditor, yet
  763. return true ;
  764. return false ;
  765. },
  767. _KeyDownListener : function( evt )
  768. {
  769. if (! evt)
  770. evt = FCK.EditorWindow.event ;
  771. if ( FCK.EditorWindow )
  772. {
  773. if ( !FCK._IsFunctionKey(evt.keyCode) // do not capture function key presses, like arrow keys or shift/alt/ctrl
  774. && !(evt.ctrlKey || evt.metaKey) // do not capture Ctrl hotkeys, as they have their snapshot capture logic
  775. && !(evt.keyCode == 46) ) // do not capture Del, it has its own capture logic in fckenterkey.js
  776. FCK._KeyDownUndo() ;
  777. }
  778. return true ;
  779. },
  781. _KeyDownUndo : function()
  782. {
  783. if ( !FCKUndo.Typing )
  784. {
  785. FCKUndo.SaveUndoStep() ;
  786. FCKUndo.Typing = true ;
  787. FCK.Events.FireEvent( "OnSelectionChange" ) ;
  788. }
  790. FCKUndo.TypesCount++ ;
  791. FCKUndo.Changed = 1 ;
  793. if ( FCKUndo.TypesCount > FCKUndo.MaxTypes )
  794. {
  795. FCKUndo.TypesCount = 0 ;
  796. FCKUndo.SaveUndoStep() ;
  797. }
  798. },
  800. _TabKeyHandler : function( evt )
  801. {
  802. if ( ! evt )
  803. evt = window.event ;
  805. var keystrokeValue = evt.keyCode ;
  807. // Pressing <Tab> in source mode should produce a tab space in the text area, not
  808. // changing the focus to something else.
  809. if ( keystrokeValue == 9 && FCK.EditMode != FCK_EDITMODE_WYSIWYG )
  810. {
  811. if ( FCKBrowserInfo.IsIE )
  812. {
  813. var range = document.selection.createRange() ;
  814. if ( range.parentElement() != FCK.EditingArea.Textarea )
  815. return true ;
  816. range.text = 't' ;
  817. range.select() ;
  818. }
  819. else
  820. {
  821. var a = [] ;
  822. var el = FCK.EditingArea.Textarea ;
  823. var selStart = el.selectionStart ;
  824. var selEnd = el.selectionEnd ;
  825. a.push( el.value.substr(0, selStart ) ) ;
  826. a.push( 't' ) ;
  827. a.push( el.value.substr( selEnd ) ) ;
  828. el.value = a.join( '' ) ;
  829. el.setSelectionRange( selStart + 1, selStart + 1 ) ;
  830. }
  832. if ( evt.preventDefault )
  833. return evt.preventDefault() ;
  835. return evt.returnValue = false ;
  836. }
  838. return true ;
  839. }
  840. } ;
  842. FCK.Events = new FCKEvents( FCK ) ;
  844. // DEPRECATED in favor or "GetData".
  845. FCK.GetHTML = FCK.GetXHTML = FCK.GetData ;
  847. // DEPRECATED in favor of "SetData".
  848. FCK.SetHTML = FCK.SetData ;
  850. // InsertElementAndGetIt and CreateElement are Deprecated : returns the same value as InsertElement.
  851. FCK.InsertElementAndGetIt = FCK.CreateElement = FCK.InsertElement ;
  853. // Replace all events attributes (like onclick).
  854. function _FCK_ProtectEvents_ReplaceTags( tagMatch )
  855. {
  856. return tagMatch.replace( FCKRegexLib.EventAttributes, _FCK_ProtectEvents_ReplaceEvents ) ;
  857. }
  859. // Replace an event attribute with its respective __fckprotectedatt attribute.
  860. // The original event markup will be encoded and saved as the value of the new
  861. // attribute.
  862. function _FCK_ProtectEvents_ReplaceEvents( eventMatch, attName )
  863. {
  864. return ' ' + attName + '_fckprotectedatt="' + encodeURIComponent( eventMatch ) + '"' ;
  865. }
  867. function _FCK_ProtectEvents_RestoreEvents( match, encodedOriginal )
  868. {
  869. return decodeURIComponent( encodedOriginal ) ;
  870. }
  872. function _FCK_MouseEventsListener( evt )
  873. {
  874. if ( ! evt )
  875. evt = window.event ;
  876. if ( evt.type == 'mousedown' )
  877. FCK.MouseDownFlag = true ;
  878. else if ( evt.type == 'mouseup' )
  879. FCK.MouseDownFlag = false ;
  880. else if ( evt.type == 'mousemove' )
  881. FCK.Events.FireEvent( 'OnMouseMove', evt ) ;
  882. }
  884. function _FCK_PaddingNodeListener()
  885. {
  886. if ( FCKConfig.EnterMode.IEquals( 'br' ) )
  887. return ;
  888. FCKDomTools.EnforcePaddingNode( FCK.EditorDocument, FCKConfig.EnterMode ) ;
  890. if ( ! FCKBrowserInfo.IsIE && FCKDomTools.PaddingNode )
  891. {
  892. // Prevent the caret from going between the body and the padding node in Firefox.
  893. // i.e. <body>|<p></p></body>
  894. var sel = FCKSelection.GetSelection() ;
  895. if ( sel && sel.rangeCount == 1 )
  896. {
  897. var range = sel.getRangeAt( 0 ) ;
  898. if ( range.collapsed && range.startContainer == FCK.EditorDocument.body && range.startOffset == 0 )
  899. {
  900. range.selectNodeContents( FCKDomTools.PaddingNode ) ;
  901. range.collapse( true ) ;
  902. sel.removeAllRanges() ;
  903. sel.addRange( range ) ;
  904. }
  905. }
  906. }
  907. else if ( FCKDomTools.PaddingNode )
  908. {
  909. // Prevent the caret from going into an empty body but not into the padding node in IE.
  910. // i.e. <body><p></p>|</body>
  911. var parentElement = FCKSelection.GetParentElement() ;
  912. var paddingNode = FCKDomTools.PaddingNode ;
  913. if ( parentElement && parentElement.nodeName.IEquals( 'body' ) )
  914. {
  915. if ( FCK.EditorDocument.body.childNodes.length == 1
  916. && FCK.EditorDocument.body.firstChild == paddingNode )
  917. {
  918. /*
  919.  * Bug #1764: Don't move the selection if the
  920.  * current selection isn't in the editor
  921.  * document.
  922.  */
  923. if ( FCKSelection._GetSelectionDocument( FCK.EditorDocument.selection ) != FCK.EditorDocument )
  924. return ;
  926. var range = FCK.EditorDocument.body.createTextRange() ;
  927. var clearContents = false ;
  928. if ( !paddingNode.childNodes.firstChild )
  929. {
  930. paddingNode.appendChild( FCKTools.GetElementDocument( paddingNode ).createTextNode( 'ufeff' ) ) ;
  931. clearContents = true ;
  932. }
  933. range.moveToElementText( paddingNode ) ;
  934. range.select() ;
  935. if ( clearContents )
  936. range.pasteHTML( '' ) ;
  937. }
  938. }
  939. }
  940. }
  942. function _FCK_EditingArea_OnLoad()
  943. {
  944. // Get the editor's window and document (DOM)
  945. FCK.EditorWindow = FCK.EditingArea.Window ;
  946. FCK.EditorDocument = FCK.EditingArea.Document ;
  948. if ( FCKBrowserInfo.IsIE )
  949. FCKTempBin.ToElements() ;
  951. FCK.InitializeBehaviors() ;
  953. // Listen for mousedown and mouseup events for tracking drag and drops.
  954. FCK.MouseDownFlag = false ;
  955. FCKTools.AddEventListener( FCK.EditorDocument, 'mousemove', _FCK_MouseEventsListener ) ;
  956. FCKTools.AddEventListener( FCK.EditorDocument, 'mousedown', _FCK_MouseEventsListener ) ;
  957. FCKTools.AddEventListener( FCK.EditorDocument, 'mouseup', _FCK_MouseEventsListener ) ;
  959. // Most of the CTRL key combos do not work under Safari for onkeydown and onkeypress (See #1119)
  960. // But we can use the keyup event to override some of these...
  961. if ( FCKBrowserInfo.IsSafari )
  962. {
  963. var undoFunc = function( evt )
  964. {
  965. if ( ! ( evt.ctrlKey || evt.metaKey ) )
  966. return ;
  967. if ( FCK.EditMode != FCK_EDITMODE_WYSIWYG )
  968. return ;
  969. switch ( evt.keyCode )
  970. {
  971. case 89:
  972. FCKUndo.Redo() ;
  973. break ;
  974. case 90:
  975. FCKUndo.Undo() ;
  976. break ;
  977. }
  978. }
  980. FCKTools.AddEventListener( FCK.EditorDocument, 'keyup', undoFunc ) ;
  981. }
  983. // Create the enter key handler
  984. FCK.EnterKeyHandler = new FCKEnterKey( FCK.EditorWindow, FCKConfig.EnterMode, FCKConfig.ShiftEnterMode, FCKConfig.TabSpaces ) ;
  986. // Listen for keystroke events.
  987. FCK.KeystrokeHandler.AttachToElement( FCK.EditorDocument ) ;
  989. if ( FCK._ForceResetIsDirty )
  990. FCK.ResetIsDirty() ;
  992. // This is a tricky thing for IE. In some cases, even if the cursor is
  993. // blinking in the editing, the keystroke handler doesn't catch keyboard
  994. // events. We must activate the editing area to make it work. (#142).
  995. if ( FCKBrowserInfo.IsIE && FCK.HasFocus )
  996. FCK.EditorDocument.body.setActive() ;
  998. FCK.OnAfterSetHTML() ;
  1000. // Restore show blocks status.
  1001. FCKCommands.GetCommand( 'ShowBlocks' ).RestoreState() ;
  1003. // Check if it is not a startup call, otherwise complete the startup.
  1004. if ( FCK.Status != FCK_STATUS_NOTLOADED )
  1005. return ;
  1007. FCK.SetStatus( FCK_STATUS_ACTIVE ) ;
  1008. }
  1010. function _FCK_GetEditorAreaStyleTags()
  1011. {
  1012. return FCKTools.GetStyleHtml( FCKConfig.EditorAreaCSS ) +
  1013. FCKTools.GetStyleHtml( FCKConfig.EditorAreaStyles ) ;
  1014. }
  1016. function _FCK_KeystrokeHandler_OnKeystroke( keystroke, keystrokeValue )
  1017. {
  1018. if ( FCK.Status != FCK_STATUS_COMPLETE )
  1019. return false ;
  1021. if ( FCK.EditMode == FCK_EDITMODE_WYSIWYG )
  1022. {
  1023. switch ( keystrokeValue )
  1024. {
  1025. case 'Paste' :
  1026. return !FCK.Paste() ;
  1028. case 'Cut' :
  1029. FCKUndo.SaveUndoStep() ;
  1030. return false ;
  1031. }
  1032. }
  1033. else
  1034. {
  1035. // In source mode, some actions must have their default behavior.
  1036. if ( keystrokeValue.Equals( 'Paste', 'Undo', 'Redo', 'SelectAll', 'Cut' ) )
  1037. return false ;
  1038. }
  1040. // The return value indicates if the default behavior of the keystroke must
  1041. // be cancelled. Let's do that only if the Execute() call explicitly returns "false".
  1042. var oCommand = FCK.Commands.GetCommand( keystrokeValue ) ;
  1044. // If the command is disabled then ignore the keystroke
  1045. if ( oCommand.GetState() == FCK_TRISTATE_DISABLED )
  1046. return false ;
  1048. return ( oCommand.Execute.apply( oCommand, FCKTools.ArgumentsToArray( arguments, 2 ) ) !== false ) ;
  1049. }
  1051. // Set the FCK.LinkedField reference to the field that will be used to post the
  1052. // editor data.
  1053. (function()
  1054. {
  1055. // There is a bug on IE... getElementById returns any META tag that has the
  1056. // name set to the ID you are looking for. So the best way in to get the array
  1057. // by names and look for the correct one.
  1058. // As ASP.Net generates a ID that is different from the Name, we must also
  1059. // look for the field based on the ID (the first one is the ID).
  1061. var oDocument = window.parent.document ;
  1063. // Try to get the field using the ID.
  1064. var eLinkedField = oDocument.getElementById( FCK.Name ) ;
  1066. var i = 0;
  1067. while ( eLinkedField || i == 0 )
  1068. {
  1069. if ( eLinkedField && eLinkedField.tagName.toLowerCase().Equals( 'input', 'textarea' ) )
  1070. {
  1071. FCK.LinkedField = eLinkedField ;
  1072. break ;
  1073. }
  1075. eLinkedField = oDocument.getElementsByName( FCK.Name )[i++] ;
  1076. }
  1077. })() ;
  1079. var FCKTempBin =
  1080. {
  1081. Elements : new Array(),
  1083. AddElement : function( element )
  1084. {
  1085. var iIndex = this.Elements.length ;
  1086. this.Elements[ iIndex ] = element ;
  1087. return iIndex ;
  1088. },
  1090. RemoveElement : function( index )
  1091. {
  1092. var e = this.Elements[ index ] ;
  1093. this.Elements[ index ] = null ;
  1094. return e ;
  1095. },
  1097. Reset : function()
  1098. {
  1099. var i = 0 ;
  1100. while ( i < this.Elements.length )
  1101. this.Elements[ i++ ] = null ;
  1102. this.Elements.length = 0 ;
  1103. },
  1105. ToHtml : function()
  1106. {
  1107. for ( var i = 0 ; i < this.Elements.length ; i++ )
  1108. {
  1109. this.Elements[i] = '<div>&nbsp;' + this.Elements[i].outerHTML + '</div>' ;
  1110. this.Elements[i].isHtml = true ;
  1111. }
  1112. },
  1114. ToElements : function()
  1115. {
  1116. var node = FCK.EditorDocument.createElement( 'div' ) ;
  1117. for ( var i = 0 ; i < this.Elements.length ; i++ )
  1118. {
  1119. if ( this.Elements[i].isHtml )
  1120. {
  1121. node.innerHTML = this.Elements[i] ;
  1122. this.Elements[i] = node.firstChild.removeChild( node.firstChild.lastChild ) ;
  1123. }
  1124. }
  1125. }
  1126. } ;
  1130. // # Focus Manager: Manages the focus in the editor.
  1131. var FCKFocusManager = FCK.FocusManager =
  1132. {
  1133. IsLocked : false,
  1135. AddWindow : function( win, sendToEditingArea )
  1136. {
  1137. var oTarget ;
  1139. if ( FCKBrowserInfo.IsIE )
  1140. oTarget = win.nodeType == 1 ? win : win.frameElement ? win.frameElement : win.document ;
  1141. else if ( FCKBrowserInfo.IsSafari )
  1142. oTarget = win ;
  1143. else
  1144. oTarget = win.document ;
  1146. FCKTools.AddEventListener( oTarget, 'blur', FCKFocusManager_Win_OnBlur ) ;
  1147. FCKTools.AddEventListener( oTarget, 'focus', sendToEditingArea ? FCKFocusManager_Win_OnFocus_Area : FCKFocusManager_Win_OnFocus ) ;
  1148. },
  1150. RemoveWindow : function( win )
  1151. {
  1152. if ( FCKBrowserInfo.IsIE )
  1153. oTarget = win.nodeType == 1 ? win : win.frameElement ? win.frameElement : win.document ;
  1154. else
  1155. oTarget = win.document ;
  1157. FCKTools.RemoveEventListener( oTarget, 'blur', FCKFocusManager_Win_OnBlur ) ;
  1158. FCKTools.RemoveEventListener( oTarget, 'focus', FCKFocusManager_Win_OnFocus_Area ) ;
  1159. FCKTools.RemoveEventListener( oTarget, 'focus', FCKFocusManager_Win_OnFocus ) ;
  1160. },
  1162. Lock : function()
  1163. {
  1164. this.IsLocked = true ;
  1165. },
  1167. Unlock : function()
  1168. {
  1169. if ( this._HasPendingBlur )
  1170. FCKFocusManager._Timer = window.setTimeout( FCKFocusManager_FireOnBlur, 100 ) ;
  1172. this.IsLocked = false ;
  1173. },
  1175. _ResetTimer : function()
  1176. {
  1177. this._HasPendingBlur = false ;
  1179. if ( this._Timer )
  1180. {
  1181. window.clearTimeout( this._Timer ) ;
  1182. delete this._Timer ;
  1183. }
  1184. }
  1185. } ;
  1187. function FCKFocusManager_Win_OnBlur()
  1188. {
  1189. if ( typeof(FCK) != 'undefined' && FCK.HasFocus )
  1190. {
  1191. FCKFocusManager._ResetTimer() ;
  1192. FCKFocusManager._Timer = window.setTimeout( FCKFocusManager_FireOnBlur, 100 ) ;
  1193. }
  1194. }
  1196. function FCKFocusManager_FireOnBlur()
  1197. {
  1198. if ( FCKFocusManager.IsLocked )
  1199. FCKFocusManager._HasPendingBlur = true ;
  1200. else
  1201. {
  1202. FCK.HasFocus = false ;
  1203. FCK.Events.FireEvent( "OnBlur" ) ;
  1204. }
  1205. }
  1207. function FCKFocusManager_Win_OnFocus_Area()
  1208. {
  1209. // Check if we are already focusing the editor (to avoid loops).
  1210. if ( FCKFocusManager._IsFocusing )
  1211. return ;
  1213. FCKFocusManager._IsFocusing = true ;
  1215. FCK.Focus() ;
  1216. FCKFocusManager_Win_OnFocus() ;
  1218. // The above FCK.Focus() call may trigger other focus related functions.
  1219. // So, to avoid a loop, we delay the focusing mark removal, so it get
  1220. // executed after all othre functions have been run.
  1221. FCKTools.RunFunction( function()
  1222. {
  1223. delete FCKFocusManager._IsFocusing ;
  1224. } ) ;
  1225. }
  1227. function FCKFocusManager_Win_OnFocus()
  1228. {
  1229. FCKFocusManager._ResetTimer() ;
  1231. if ( !FCK.HasFocus && !FCKFocusManager.IsLocked )
  1232. {
  1233. FCK.HasFocus = true ;
  1234. FCK.Events.FireEvent( "OnFocus" ) ;
  1235. }
  1236. }
  1238. /*
  1239.  * #1633 : Protect the editor iframe from external styles.
  1240.  * Notice that we can't use FCKTools.ResetStyles here since FCKTools isn't
  1241.  * loaded yet.
  1242.  */
  1243. (function()
  1244. {
  1245. var el = window.frameElement ;
  1246. var width = el.width ;
  1247. var height = el.height ;
  1248. if ( /^d+$/.test( width ) ) width += 'px' ;
  1249. if ( /^d+$/.test( height ) ) height += 'px' ;
  1250. var style = el.style ;
  1251. style.border = style.padding = style.margin = 0 ;
  1252. style.backgroundColor = 'transparent';
  1253. style.backgroundImage = 'none';
  1254. style.width = width ;
  1255. style.height = height ;
  1256. })() ;