fckstyles.js
上传用户:ah_jiwei
上传日期:2022-07-24
资源大小:54044k
文件大小:10k
源码类别:

数据库编程

开发平台:

Visual C++

  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.  * Handles styles in a give document.
  22.  */
  23. var FCKStyles = FCK.Styles =
  24. {
  25. _Callbacks : {},
  26. _ObjectStyles : {},
  27. ApplyStyle : function( style )
  28. {
  29. if ( typeof style == 'string' )
  30. style = this.GetStyles()[ style ] ;
  31. if ( style )
  32. {
  33. if ( style.GetType() == FCK_STYLE_OBJECT )
  34. style.ApplyToObject( FCKSelection.GetSelectedElement() ) ;
  35. else
  36. style.ApplyToSelection( FCK.EditorWindow ) ;
  37. FCK.Events.FireEvent( 'OnSelectionChange' ) ;
  38. }
  39. },
  40. RemoveStyle : function( style )
  41. {
  42. if ( typeof style == 'string' )
  43. style = this.GetStyles()[ style ] ;
  44. if ( style )
  45. {
  46. style.RemoveFromSelection( FCK.EditorWindow ) ;
  47. FCK.Events.FireEvent( 'OnSelectionChange' ) ;
  48. }
  49. },
  50. /**
  51.  * Defines a callback function to be called when the current state of a
  52.  * specific style changes.
  53.  */
  54. AttachStyleStateChange : function( styleName, callback, callbackOwner )
  55. {
  56. var callbacks = this._Callbacks[ styleName ] ;
  57. if ( !callbacks )
  58. callbacks = this._Callbacks[ styleName ] = [] ;
  59. callbacks.push( [ callback, callbackOwner ] ) ;
  60. },
  61. CheckSelectionChanges : function()
  62. {
  63. var startElement = FCKSelection.GetBoundaryParentElement( true ) ;
  64. if ( !startElement )
  65. return ;
  66. // Walks the start node parents path, checking all styles that are being listened.
  67. var path = new FCKElementPath( startElement ) ;
  68. var styles = this.GetStyles() ;
  69. for ( var styleName in styles )
  70. {
  71. var callbacks = this._Callbacks[ styleName ] ;
  72. if ( callbacks )
  73. {
  74. var style = styles[ styleName ] ;
  75. var state = style.CheckActive( path ) ;
  76. if ( style._LastState != state )
  77. {
  78. style._LastState = state ;
  79. for ( var i = 0 ; i < callbacks.length ; i++ )
  80. {
  81. var callback = callbacks[i][0] ;
  82. var callbackOwner = callbacks[i][1] ;
  83. callback.call( callbackOwner || window, styleName, state ) ;
  84. }
  85. }
  86. }
  87. }
  88. },
  89. CheckStyleInSelection : function( styleName )
  90. {
  91. return false ;
  92. },
  93. _GetRemoveFormatTagsRegex : function ()
  94. {
  95. var regex = new RegExp( '^(?:' + FCKConfig.RemoveFormatTags.replace( /,/g,'|' ) + ')$', 'i' ) ;
  96. return (this._GetRemoveFormatTagsRegex = function()
  97. {
  98. return regex ;
  99. })
  100. && regex  ;
  101. },
  102. /**
  103.  * Remove all styles from the current selection.
  104.  * TODO:
  105.  *  - This is almost a duplication of FCKStyle.RemoveFromRange. We should
  106.  *    try to merge things.
  107.  */
  108. RemoveAll : function()
  109. {
  110. var range = new FCKDomRange( FCK.EditorWindow ) ;
  111. range.MoveToSelection() ;
  112. if ( range.CheckIsCollapsed() )
  113. return ;
  114. // Expand the range, if inside inline element boundaries.
  115. range.Expand( 'inline_elements' ) ;
  116. // Get the bookmark nodes.
  117. // Bookmark the range so we can re-select it after processing.
  118. var bookmark = range.CreateBookmark( true ) ;
  119. // The style will be applied within the bookmark boundaries.
  120. var startNode = range.GetBookmarkNode( bookmark, true ) ;
  121. var endNode = range.GetBookmarkNode( bookmark, false ) ;
  122. range.Release( true ) ;
  123. var tagsRegex = this._GetRemoveFormatTagsRegex() ;
  124. // We need to check the selection boundaries (bookmark spans) to break
  125. // the code in a way that we can properly remove partially selected nodes.
  126. // For example, removing a <b> style from
  127. // <b>This is [some text</b> to show <b>the] problem</b>
  128. // ... where [ and ] represent the selection, must result:
  129. // <b>This is </b>[some text to show the]<b> problem</b>
  130. // The strategy is simple, we just break the partial nodes before the
  131. // removal logic, having something that could be represented this way:
  132. // <b>This is </b>[<b>some text</b> to show <b>the</b>]<b> problem</b>
  133. // Let's start checking the start boundary.
  134. var path = new FCKElementPath( startNode ) ;
  135. var pathElements = path.Elements ;
  136. var pathElement ;
  137. for ( var i = 1 ; i < pathElements.length ; i++ )
  138. {
  139. pathElement = pathElements[i] ;
  140. if ( pathElement == path.Block || pathElement == path.BlockLimit )
  141. break ;
  142. // If this element can be removed (even partially).
  143. if ( tagsRegex.test( pathElement.nodeName ) )
  144. FCKDomTools.BreakParent( startNode, pathElement, range ) ;
  145. }
  146. // Now the end boundary.
  147. path = new FCKElementPath( endNode ) ;
  148. pathElements = path.Elements ;
  149. for ( var i = 1 ; i < pathElements.length ; i++ )
  150. {
  151. pathElement = pathElements[i] ;
  152. if ( pathElement == path.Block || pathElement == path.BlockLimit )
  153. break ;
  154. elementName = pathElement.nodeName.toLowerCase() ;
  155. // If this element can be removed (even partially).
  156. if ( tagsRegex.test( pathElement.nodeName ) )
  157. FCKDomTools.BreakParent( endNode, pathElement, range ) ;
  158. }
  159. // Navigate through all nodes between the bookmarks.
  160. var currentNode = FCKDomTools.GetNextSourceNode( startNode, true, 1 ) ;
  161. while ( currentNode )
  162. {
  163. // If we have reached the end of the selection, stop looping.
  164. if ( currentNode == endNode )
  165. break ;
  166. // Cache the next node to be processed. Do it now, because
  167. // currentNode may be removed.
  168. var nextNode = FCKDomTools.GetNextSourceNode( currentNode, false, 1 ) ;
  169. // Remove elements nodes that match with this style rules.
  170. if ( tagsRegex.test( currentNode.nodeName ) )
  171. FCKDomTools.RemoveNode( currentNode, true ) ;
  172. currentNode = nextNode ;
  173. }
  174. range.SelectBookmark( bookmark ) ;
  175. FCK.Events.FireEvent( 'OnSelectionChange' ) ;
  176. },
  177. GetStyle : function( styleName )
  178. {
  179. return this.GetStyles()[ styleName ] ;
  180. },
  181. GetStyles : function()
  182. {
  183. var styles = this._GetStyles ;
  184. if ( !styles )
  185. {
  186. styles = this._GetStyles = FCKTools.Merge( 
  187. this._LoadStylesCore(),
  188. this._LoadStylesCustom(),
  189. this._LoadStylesXml() ) ;
  190. }
  191. return styles ;
  192. },
  193. CheckHasObjectStyle : function( elementName )
  194. {
  195. return !!this._ObjectStyles[ elementName ] ;
  196. },
  197. _LoadStylesCore : function()
  198. {
  199. var styles = {};
  200. var styleDefs = FCKConfig.CoreStyles ;
  201. for ( var styleName in styleDefs )
  202. {
  203. // Core styles are prefixed with _FCK_.
  204. var style = styles[ '_FCK_' + styleName ] = new FCKStyle( styleDefs[ styleName ] ) ;
  205. style.IsCore = true ;
  206. }
  207. return styles ;
  208. },
  209. _LoadStylesCustom : function()
  210. {
  211. var styles = {};
  212. var styleDefs = FCKConfig.CustomStyles ;
  213. if ( styleDefs )
  214. {
  215. for ( var styleName in styleDefs )
  216. styles[ styleName ] = new FCKStyle( styleDefs[ styleName ] ) ;
  217. }
  218. return styles ;
  219. },
  220. _LoadStylesXml : function()
  221. {
  222. var styles = {};
  223. var stylesXmlPath = FCKConfig.StylesXmlPath ;
  224. if ( !stylesXmlPath || stylesXmlPath.length == 0 )
  225. return styles ;
  226. // Load the XML file into a FCKXml object.
  227. var xml = new FCKXml() ;
  228. xml.LoadUrl( stylesXmlPath ) ;
  229. var stylesXmlObj = FCKXml.TransformToObject( xml.SelectSingleNode( 'Styles' ) ) ;
  230. // Get the "Style" nodes defined in the XML file.
  231. var styleNodes = stylesXmlObj.$Style ;
  232. // Add each style to our "Styles" collection.
  233. for ( var i = 0 ; i < styleNodes.length ; i++ )
  234. {
  235. var styleNode = styleNodes[i] ;
  236. var element = ( styleNode.element || '' ).toLowerCase() ;
  237. if ( element.length == 0 )
  238. throw( 'The element name is required. Error loading "' + stylesXmlPath + '"' ) ;
  239. var styleDef = {
  240. Element : element,
  241. Attributes : {},
  242. Styles : {},
  243. Overrides : []
  244. } ;
  245. // Get the attributes defined for the style (if any).
  246. var attNodes = styleNode.$Attribute || [] ;
  247. // Add the attributes to the style definition object.
  248. for ( var j = 0 ; j < attNodes.length ; j++ )
  249. {
  250. styleDef.Attributes[ attNodes[j].name ] = attNodes[j].value ;
  251. }
  252. // Get the styles defined for the style (if any).
  253. var cssStyleNodes = styleNode.$Style || [] ;
  254. // Add the attributes to the style definition object.
  255. for ( j = 0 ; j < cssStyleNodes.length ; j++ )
  256. {
  257. styleDef.Styles[ cssStyleNodes[j].name ] = cssStyleNodes[j].value ;
  258. }
  259. // Load override definitions.
  260. var cssStyleOverrideNodes = styleNode.$Override ;
  261. if ( cssStyleOverrideNodes ) 
  262. {
  263. for ( j = 0 ; j < cssStyleOverrideNodes.length ; j++ )
  264. {
  265. var overrideNode = cssStyleOverrideNodes[j] ;
  266. var overrideDef = 
  267. {
  268. Element : overrideNode.element
  269. } ;
  270. var overrideAttNode = overrideNode.$Attribute ;
  271. if ( overrideAttNode )
  272. {
  273. overrideDef.Attributes = {} ;
  274. for ( var k = 0 ; k < overrideAttNode.length ; k++ )
  275. {
  276. var overrideAttValue = overrideAttNode[k].value || null ;
  277. if ( overrideAttValue )
  278. {
  279. // Check if the override attribute value is a regular expression.
  280. var regexMatch = overrideAttValue && FCKRegexLib.RegExp.exec( overrideAttValue ) ;
  281. if ( regexMatch )
  282. overrideAttValue = new RegExp( regexMatch[1], regexMatch[2] || '' ) ;
  283. }
  284. overrideDef.Attributes[ overrideAttNode[k].name ] = overrideAttValue ;
  285. }
  286. }
  287. styleDef.Overrides.push( overrideDef ) ;
  288. }
  289. }
  290. var style = new FCKStyle( styleDef ) ;
  291. style.Name = styleNode.name || element ;
  292. if ( style.GetType() == FCK_STYLE_OBJECT )
  293. this._ObjectStyles[ element ] = true ;
  294. // Add the style to the "Styles" collection using it's name as the key.
  295. styles[ style.Name ] = style ;
  296. }
  297. return styles ;
  298. }
  299. } ;