[ Index ]

WordPress Cross Reference

title

Body

[close]

/wp-includes/js/tinymce/ -> wp-tinymce-schema.js (source)

   1  /**
   2   * TinyMCE Schema.js
   3   *
   4   * Duck-punched by WordPress core to support a sane schema superset.
   5   *
   6   * Copyright, Moxiecode Systems AB
   7   * Released under LGPL
   8   *
   9   * License: http://www.tinymce.com/license
  10   * Contributing: http://www.tinymce.com/contributing
  11   */
  12  
  13  (function(tinymce) {
  14      var mapCache = {}, makeMap = tinymce.makeMap, each = tinymce.each;
  15  
  16  	function split(str, delim) {
  17          return str.split(delim || ',');
  18      };
  19  
  20      /**
  21       * Unpacks the specified lookup and string data it will also parse it into an object
  22       * map with sub object for it's children. This will later also include the attributes.
  23       */
  24  	function unpack(lookup, data) {
  25          var key, elements = {};
  26  
  27  		function replace(value) {
  28              return value.replace(/[A-Z]+/g, function(key) {
  29                  return replace(lookup[key]);
  30              });
  31          };
  32  
  33          // Unpack lookup
  34          for (key in lookup) {
  35              if (lookup.hasOwnProperty(key))
  36                  lookup[key] = replace(lookup[key]);
  37          }
  38  
  39          // Unpack and parse data into object map
  40          replace(data).replace(/#/g, '#text').replace(/(\w+)\[([^\]]+)\]\[([^\]]*)\]/g, function(str, name, attributes, children) {
  41              attributes = split(attributes, '|');
  42  
  43              elements[name] = {
  44                  attributes : makeMap(attributes),
  45                  attributesOrder : attributes,
  46                  children : makeMap(children, '|', {'#comment' : {}})
  47              }
  48          });
  49  
  50          return elements;
  51      };
  52  
  53      /**
  54       * Returns the HTML5 schema and caches it in the mapCache.
  55       */
  56  	function getHTML5() {
  57          var html5 = mapCache.html5;
  58  
  59          if (!html5) {
  60              html5 = mapCache.html5 = unpack({
  61                      A : 'accesskey|class|contextmenu|dir|draggable|dropzone|hidden|id|inert|itemid|itemprop|itemref|itemscope|itemtype|lang|spellcheck|style|tabindex|title|translate|item|role|subject|onclick|ondblclick|onmousedown|onmouseup|onmouseover|onmousemove|onmouseout|onkeypress|onkeydown|onkeyup',
  62                      B : '#|a|abbr|area|audio|b|bdi|bdo|br|button|canvas|cite|code|command|data|datalist|del|dfn|em|embed|i|iframe|img|input|ins|kbd|keygen|label|link|map|mark|math|meta|meter|noscript|object|output|progress|q|ruby|s|samp|script|select|small|span|strong|sub|sup|svg|textarea|time|u|var|video|wbr',
  63                      C : '#|a|abbr|area|address|article|aside|audio|b|bdi|bdo|blockquote|br|button|canvas|cite|code|command|data|datalist|del|details|dfn|dialog|div|dl|em|embed|fieldset|figure|footer|form|h1|h2|h3|h4|h5|h6|header|hgroup|hr|i|iframe|img|input|ins|kbd|keygen|label|link|map|mark|math|menu|meta|meter|nav|noscript|ol|object|output|p|pre|progress|q|ruby|s|samp|script|section|select|small|span|strong|style|sub|sup|svg|table|textarea|time|u|ul|var|video|wbr'
  64                  }, 'html[A|manifest][body|head]' +
  65                      'head[A][base|command|link|meta|noscript|script|style|title]' +
  66                      'title[A][#]' +
  67                      'base[A|href|target][]' +
  68                      'link[A|href|rel|media|type|sizes|crossorigin|hreflang][]' +
  69                      'meta[A|http-equiv|name|content|charset][]' +
  70                      'style[A|type|media|scoped][#]' +
  71                      'script[A|charset|type|src|defer|async|crossorigin][#]' +
  72                      'noscript[A][C]' +
  73                      'body[A|onafterprint|onbeforeprint|onbeforeunload|onblur|onerror|onfocus|onfullscreenchange|onfullscreenerror|onhashchange|onload|onmessage|onoffline|ononline|onpagehide|onpageshow|onpopstate|onresize|onscroll|onstorage|onunload][C]' +
  74                      'section[A][C]' +
  75                      'nav[A][C]' +
  76                      'article[A][C]' +
  77                      'aside[A][C]' +
  78                      'h1[A][B]' +
  79                      'h2[A][B]' +
  80                      'h3[A][B]' +
  81                      'h4[A][B]' +
  82                      'h5[A][B]' +
  83                      'h6[A][B]' +
  84                      'hgroup[A][h1|h2|h3|h4|h5|h6]' +
  85                      'header[A][C]' +
  86                      'footer[A][C]' +
  87                      'address[A][C]' +
  88                      'p[A][B]' +
  89                      'br[A][]' +
  90                      'pre[A][B]' +
  91                      'dialog[A|open][C|dd|dt]' +
  92                      'blockquote[A|cite][C]' +
  93                      'ol[A|start|reversed][li]' +
  94                      'ul[A][li]' +
  95                      'li[A|value][C]' +
  96                      'dl[A][dd|dt]' +
  97                      'dt[A][C|B]' +
  98                      'dd[A][C]' +
  99                      'a[A|href|target|download|ping|rel|media|type][B]' +
 100                      'em[A][B]' +
 101                      'strong[A][B]' +
 102                      'small[A][B]' +
 103                      's[A][B]' +
 104                      'cite[A][B]' +
 105                      'q[A|cite][B]' +
 106                      'dfn[A][B]' +
 107                      'abbr[A][B]' +
 108                      'code[A][B]' +
 109                      'var[A][B]' +
 110                      'samp[A][B]' +
 111                      'kbd[A][B]' +
 112                      'sub[A][B]' +
 113                      'sup[A][B]' +
 114                      'i[A][B]' +
 115                      'b[A][B]' +
 116                      'u[A][B]' +
 117                      'mark[A][B]' +
 118                      'progress[A|value|max][B]' +
 119                      'meter[A|value|min|max|low|high|optimum][B]' +
 120                      'time[A|datetime][B]' +
 121                      'ruby[A][B|rt|rp]' +
 122                      'rt[A][B]' +
 123                      'rp[A][B]' +
 124                      'bdi[A][B]' +
 125                      'bdo[A][B]' +
 126                      'span[A][B]' +
 127                      'ins[A|cite|datetime][C|B]' +
 128                      'del[A|cite|datetime][C|B]' +
 129                      'figure[A][C|legend|figcaption]' +
 130                      'figcaption[A][C]' +
 131                      'img[A|alt|src|srcset|crossorigin|usemap|ismap|width|height][]' +
 132                      'iframe[A|name|src|srcdoc|height|width|sandbox|seamless|allowfullscreen][C|B]' +
 133                      'embed[A|src|height|width|type][]' +
 134                      'object[A|data|type|typemustmatch|name|usemap|form|width|height][C|B|param]' +
 135                      'param[A|name|value][]' +
 136                      'summary[A][B]' +
 137                      'details[A|open][C|legend|summary]' +
 138                      'command[A|type|label|icon|disabled|checked|radiogroup|command][]' +
 139                      'menu[A|type|label][C|li]' +
 140                      'legend[A][C|B]' +
 141                      'div[A][C]' +
 142                      'source[A|src|type|media][]' +
 143                      'track[A|kind|src|srclang|label|default][]' +
 144                      'audio[A|src|autobuffer|autoplay|loop|controls|crossorigin|preload|mediagroup|muted][C|source|track]' +
 145                      'video[A|src|autobuffer|autoplay|loop|controls|width|height|poster|crossorigin|preload|mediagroup|muted][C|source|track]' +
 146                      'hr[A][]' +
 147                      'form[A|accept-charset|action|autocomplete|enctype|method|name|novalidate|target][C]' +
 148                      'fieldset[A|disabled|form|name][C|legend]' +
 149                      'label[A|form|for][B]' +
 150                      'input[A|type|accept|alt|autocomplete|autofocus|checked|dirname|disabled|form|formaction|formenctype|formmethod|formnovalidate|formtarget|height|inputmode|list|max|maxlength|min|multiple|name|pattern|placeholder|readonly|required|size|src|step|value|width|files][]' +
 151                      'button[A|autofocus|disabled|form|formaction|formenctype|formmethod|formnovalidate|formtarget|name|type|value][B]' +
 152                      'select[A|autofocus|disabled|form|multiple|name|required|size][option|optgroup]' +
 153                      'data[A|value][B]' +
 154                      'datalist[A][B|option]' +
 155                      'optgroup[A|disabled|label][option]' +
 156                      'option[A|disabled|selected|label|value][#]' +
 157                      'textarea[A|autocomplete|autofocus|cols|dirname|disabled|form|inputmode|maxlength|name|placeholder|readonly|required|rows|wrap][#]' +
 158                      'keygen[A|autofocus|challenge|disabled|form|keytype|name][]' +
 159                      'output[A|for|form|name][B]' +
 160                      'canvas[A|width|height][a|button|input]' +
 161                      'map[A|name][C|B]' +
 162                      'area[A|alt|coords|shape|href|target|download|ping|rel|media|hreflang|type][]' +
 163                      'math[A][]' +
 164                      'svg[A][]' +
 165                      'table[A][caption|colgroup|thead|tfoot|tbody|tr]' +
 166                      'caption[A][C]' +
 167                      'colgroup[A|span][col]' +
 168                      'col[A|span][]' +
 169                      'thead[A][tr]' +
 170                      'tfoot[A][tr]' +
 171                      'tbody[A][tr]' +
 172                      'tr[A][th|td]' +
 173                      'th[A|headers|rowspan|colspan|scope][C]' +
 174                      'td[A|headers|rowspan|colspan][C]' +
 175                      'wbr[A][]'
 176              );
 177          }
 178  
 179          return html5;
 180      };
 181  
 182      /**
 183       * Returns the HTML4 schema and caches it in the mapCache.
 184       */
 185  	function getHTML4() {
 186          var html4 = mapCache.html4;
 187  
 188          if (!html4) {
 189              // This is the XHTML 1.0 transitional elements with it's attributes and children packed to reduce it's size
 190              html4 = mapCache.html4 = unpack({
 191                  Z : 'H|K|N|O|P',
 192                  Y : 'X|form|R|Q',
 193                  ZG : 'E|span|width|align|char|charoff|valign',
 194                  X : 'p|T|div|U|W|isindex|fieldset|table',
 195                  ZF : 'E|align|char|charoff|valign',
 196                  W : 'pre|hr|blockquote|address|center|noframes',
 197                  ZE : 'abbr|axis|headers|scope|rowspan|colspan|align|char|charoff|valign|nowrap|bgcolor|width|height',
 198                  ZD : '[E][S]',
 199                  U : 'ul|ol|dl|menu|dir',
 200                  ZC : 'p|Y|div|U|W|table|br|span|bdo|object|applet|img|map|K|N|Q',
 201                  T : 'h1|h2|h3|h4|h5|h6',
 202                  ZB : 'X|S|Q',
 203                  S : 'R|P',
 204                  ZA : 'a|G|J|M|O|P',
 205                  R : 'a|H|K|N|O',
 206                  Q : 'noscript|P',
 207                  P : 'ins|del|script',
 208                  O : 'input|select|textarea|label|button',
 209                  N : 'M|L',
 210                  M : 'em|strong|dfn|code|q|samp|kbd|var|cite|abbr|acronym',
 211                  L : 'sub|sup',
 212                  K : 'J|I',
 213                  J : 'tt|i|b|u|s|strike',
 214                  I : 'big|small|font|basefont',
 215                  H : 'G|F',
 216                  G : 'br|span|bdo',
 217                  F : 'object|applet|img|map|iframe',
 218                  E : 'A|B|C',
 219                  D : 'accesskey|tabindex|onfocus|onblur',
 220                  C : 'onclick|ondblclick|onmousedown|onmouseup|onmouseover|onmousemove|onmouseout|onkeypress|onkeydown|onkeyup',
 221                  B : 'lang|xml:lang|dir',
 222                  A : 'id|class|style|title'
 223              }, 'script[id|charset|type|language|src|defer|xml:space][]' +
 224                  'style[B|id|type|media|title|xml:space][]' +
 225                  'object[E|declare|classid|codebase|data|type|codetype|archive|standby|width|height|usemap|name|tabindex|align|border|hspace|vspace][#|param|Y]' +
 226                  'param[id|name|value|valuetype|type][]' +
 227                  'p[E|align][#|S]' +
 228                  'a[E|D|charset|type|name|href|hreflang|rel|rev|shape|coords|target][#|Z]' +
 229                  'br[A|clear][]' +
 230                  'span[E][#|S]' +
 231                  'bdo[A|C|B][#|S]' +
 232                  'applet[A|codebase|archive|code|object|alt|name|width|height|align|hspace|vspace][#|param|Y]' +
 233                  'h1[E|align][#|S]' +
 234                  'img[E|src|alt|name|longdesc|width|height|usemap|ismap|align|border|hspace|vspace][]' +
 235                  'map[B|C|A|name][X|form|Q|area]' +
 236                  'h2[E|align][#|S]' +
 237                  'iframe[A|longdesc|name|src|frameborder|marginwidth|marginheight|scrolling|align|width|height][#|Y]' +
 238                  'h3[E|align][#|S]' +
 239                  'tt[E][#|S]' +
 240                  'i[E][#|S]' +
 241                  'b[E][#|S]' +
 242                  'u[E][#|S]' +
 243                  's[E][#|S]' +
 244                  'strike[E][#|S]' +
 245                  'big[E][#|S]' +
 246                  'small[E][#|S]' +
 247                  'font[A|B|size|color|face][#|S]' +
 248                  'basefont[id|size|color|face][]' +
 249                  'em[E][#|S]' +
 250                  'strong[E][#|S]' +
 251                  'dfn[E][#|S]' +
 252                  'code[E][#|S]' +
 253                  'q[E|cite][#|S]' +
 254                  'samp[E][#|S]' +
 255                  'kbd[E][#|S]' +
 256                  'var[E][#|S]' +
 257                  'cite[E][#|S]' +
 258                  'abbr[E][#|S]' +
 259                  'acronym[E][#|S]' +
 260                  'sub[E][#|S]' +
 261                  'sup[E][#|S]' +
 262                  'input[E|D|type|name|value|checked|disabled|readonly|size|maxlength|src|alt|usemap|onselect|onchange|accept|align][]' +
 263                  'select[E|name|size|multiple|disabled|tabindex|onfocus|onblur|onchange][optgroup|option]' +
 264                  'optgroup[E|disabled|label][option]' +
 265                  'option[E|selected|disabled|label|value][]' +
 266                  'textarea[E|D|name|rows|cols|disabled|readonly|onselect|onchange][]' +
 267                  'label[E|for|accesskey|onfocus|onblur][#|S]' +
 268                  'button[E|D|name|value|type|disabled][#|p|T|div|U|W|table|G|object|applet|img|map|K|N|Q]' +
 269                  'h4[E|align][#|S]' +
 270                  'ins[E|cite|datetime][#|Y]' +
 271                  'h5[E|align][#|S]' +
 272                  'del[E|cite|datetime][#|Y]' +
 273                  'h6[E|align][#|S]' +
 274                  'div[E|align][#|Y]' +
 275                  'ul[E|type|compact][li]' +
 276                  'li[E|type|value][#|Y]' +
 277                  'ol[E|type|compact|start][li]' +
 278                  'dl[E|compact][dt|dd]' +
 279                  'dt[E][#|S]' +
 280                  'dd[E][#|Y]' +
 281                  'menu[E|compact][li]' +
 282                  'dir[E|compact][li]' +
 283                  'pre[E|width|xml:space][#|ZA]' +
 284                  'hr[E|align|noshade|size|width][]' +
 285                  'blockquote[E|cite][#|Y]' +
 286                  'address[E][#|S|p]' +
 287                  'center[E][#|Y]' +
 288                  'noframes[E][#|Y]' +
 289                  'isindex[A|B|prompt][]' +
 290                  'fieldset[E][#|legend|Y]' +
 291                  'legend[E|accesskey|align][#|S]' +
 292                  'table[E|summary|width|border|frame|rules|cellspacing|cellpadding|align|bgcolor][caption|col|colgroup|thead|tfoot|tbody|tr]' +
 293                  'caption[E|align][#|S]' +
 294                  'col[ZG][]' +
 295                  'colgroup[ZG][col]' +
 296                  'thead[ZF][tr]' +
 297                  'tr[ZF|bgcolor][th|td]' +
 298                  'th[E|ZE][#|Y]' +
 299                  'form[E|action|method|name|enctype|onsubmit|onreset|accept|accept-charset|target][#|X|R|Q]' +
 300                  'noscript[E][#|Y]' +
 301                  'td[E|ZE][#|Y]' +
 302                  'tfoot[ZF][tr]' +
 303                  'tbody[ZF][tr]' +
 304                  'area[E|D|shape|coords|href|nohref|alt|target][]' +
 305                  'base[id|href|target][]' +
 306                  'body[E|onload|onunload|background|bgcolor|text|link|vlink|alink][#|Y]'
 307              );
 308          }
 309  
 310          return html4;
 311      };
 312  
 313      /**
 314       * WordPress Core
 315       *
 316       * Returns a schema that is the result of a deep merge between the HTML5
 317       * and HTML4 schemas.
 318       */
 319  	function getSaneSchema() {
 320          var cachedMapCache = mapCache,
 321              html5, html4;
 322  
 323          if ( mapCache.sane )
 324              return mapCache.sane;
 325  
 326          // Bust the mapCache so we're not dealing with the other schema objects.
 327          mapCache = {};
 328          html5 = getHTML5();
 329          html4 = getHTML4();
 330          mapCache = cachedMapCache;
 331  
 332          each( html4, function( html4settings, tag ) {
 333              var html5settings = html5[ tag ],
 334                  difference = [];
 335  
 336              // Merge tags missing in HTML5 mode.
 337              if ( ! html5settings ) {
 338                  html5[ tag ] = html4settings;
 339                  return;
 340              }
 341  
 342              // Merge attributes missing from this HTML5 tag.
 343              each( html4settings.attributes, function( attribute, key ) {
 344                  if ( ! html5settings.attributes[ key ] )
 345                      html5settings.attributes[ key ] = attribute;
 346              });
 347  
 348              // Merge any missing attributes into the attributes order.
 349              each( html4settings.attributesOrder, function( key ) {
 350                  if ( -1 === tinymce.inArray( html5settings.attributesOrder, key ) )
 351                      difference.push( key );
 352              });
 353  
 354              html5settings.attributesOrder = html5settings.attributesOrder.concat( difference );
 355  
 356              // Merge children missing from this HTML5 tag.
 357              each( html4settings.children, function( child, key ) {
 358                  if ( ! html5settings.children[ key ] )
 359                      html5settings.children[ key ] = child;
 360              });
 361          });
 362  
 363          return mapCache.sane = html5;
 364      }
 365  
 366      /**
 367       * Schema validator class.
 368       *
 369       * @class tinymce.html.Schema
 370       * @example
 371       *  if (tinymce.activeEditor.schema.isValidChild('p', 'span'))
 372       *    alert('span is valid child of p.');
 373       *
 374       *  if (tinymce.activeEditor.schema.getElementRule('p'))
 375       *    alert('P is a valid element.');
 376       *
 377       * @class tinymce.html.Schema
 378       * @version 3.4
 379       */
 380  
 381      /**
 382       * Constructs a new Schema instance.
 383       *
 384       * @constructor
 385       * @method Schema
 386       * @param {Object} settings Name/value settings object.
 387       */
 388      tinymce.html.Schema = function(settings) {
 389          var self = this, elements = {}, children = {}, patternElements = [], validStyles, schemaItems;
 390          var whiteSpaceElementsMap, selfClosingElementsMap, shortEndedElementsMap, boolAttrMap, blockElementsMap, nonEmptyElementsMap, customElementsMap = {};
 391  
 392          // Creates an lookup table map object for the specified option or the default value
 393  		function createLookupTable(option, default_value, extend) {
 394              var value = settings[option];
 395  
 396              if (!value) {
 397                  // Get cached default map or make it if needed
 398                  value = mapCache[option];
 399  
 400                  if (!value) {
 401                      value = makeMap(default_value, ' ', makeMap(default_value.toUpperCase(), ' '));
 402                      value = tinymce.extend(value, extend);
 403  
 404                      mapCache[option] = value;
 405                  }
 406              } else {
 407                  // Create custom map
 408                  value = makeMap(value, ',', makeMap(value.toUpperCase(), ' '));
 409              }
 410  
 411              return value;
 412          };
 413  
 414          settings = settings || {};
 415  
 416          /**
 417           * WordPress core uses a sane schema in place of the default "HTML5" schema.
 418           */
 419          schemaItems = settings.schema == "html5" ? getSaneSchema() : getHTML4();
 420  
 421          // Allow all elements and attributes if verify_html is set to false
 422          if (settings.verify_html === false)
 423              settings.valid_elements = '*[*]';
 424  
 425          // Build styles list
 426          if (settings.valid_styles) {
 427              validStyles = {};
 428  
 429              // Convert styles into a rule list
 430              each(settings.valid_styles, function(value, key) {
 431                  validStyles[key] = tinymce.explode(value);
 432              });
 433          }
 434  
 435          // Setup map objects
 436          whiteSpaceElementsMap = createLookupTable('whitespace_elements', 'pre script noscript style textarea');
 437          selfClosingElementsMap = createLookupTable('self_closing_elements', 'colgroup dd dt li option p td tfoot th thead tr');
 438          shortEndedElementsMap = createLookupTable('short_ended_elements', 'area base basefont br col frame hr img input isindex link meta param embed source wbr');
 439          boolAttrMap = createLookupTable('boolean_attributes', 'checked compact declare defer disabled ismap multiple nohref noresize noshade nowrap readonly selected autoplay loop controls');
 440          nonEmptyElementsMap = createLookupTable('non_empty_elements', 'td th iframe video audio object', shortEndedElementsMap);
 441          textBlockElementsMap = createLookupTable('text_block_elements', 'h1 h2 h3 h4 h5 h6 p div address pre form ' +
 442                          'blockquote center dir fieldset header footer article section hgroup aside nav figure');
 443          blockElementsMap = createLookupTable('block_elements', 'hr table tbody thead tfoot ' +
 444                          'th tr td li ol ul caption dl dt dd noscript menu isindex option datalist select optgroup', textBlockElementsMap);
 445  
 446          // Converts a wildcard expression string to a regexp for example *a will become /.*a/.
 447  		function patternToRegExp(str) {
 448              return new RegExp('^' + str.replace(/([?+*])/g, '.$1') + '$');
 449          };
 450  
 451          // Parses the specified valid_elements string and adds to the current rules
 452          // This function is a bit hard to read since it's heavily optimized for speed
 453  		function addValidElements(valid_elements) {
 454              var ei, el, ai, al, yl, matches, element, attr, attrData, elementName, attrName, attrType, attributes, attributesOrder,
 455                  prefix, outputName, globalAttributes, globalAttributesOrder, transElement, key, childKey, value,
 456                  elementRuleRegExp = /^([#+\-])?([^\[\/]+)(?:\/([^\[]+))?(?:\[([^\]]+)\])?$/,
 457                  attrRuleRegExp = /^([!\-])?(\w+::\w+|[^=:<]+)?(?:([=:<])(.*))?$/,
 458                  hasPatternsRegExp = /[*?+]/;
 459  
 460              if (valid_elements) {
 461                  // Split valid elements into an array with rules
 462                  valid_elements = split(valid_elements);
 463  
 464                  if (elements['@']) {
 465                      globalAttributes = elements['@'].attributes;
 466                      globalAttributesOrder = elements['@'].attributesOrder;
 467                  }
 468  
 469                  // Loop all rules
 470                  for (ei = 0, el = valid_elements.length; ei < el; ei++) {
 471                      // Parse element rule
 472                      matches = elementRuleRegExp.exec(valid_elements[ei]);
 473                      if (matches) {
 474                          // Setup local names for matches
 475                          prefix = matches[1];
 476                          elementName = matches[2];
 477                          outputName = matches[3];
 478                          attrData = matches[4];
 479  
 480                          // Create new attributes and attributesOrder
 481                          attributes = {};
 482                          attributesOrder = [];
 483  
 484                          // Create the new element
 485                          element = {
 486                              attributes : attributes,
 487                              attributesOrder : attributesOrder
 488                          };
 489  
 490                          // Padd empty elements prefix
 491                          if (prefix === '#')
 492                              element.paddEmpty = true;
 493  
 494                          // Remove empty elements prefix
 495                          if (prefix === '-')
 496                              element.removeEmpty = true;
 497  
 498                          // Copy attributes from global rule into current rule
 499                          if (globalAttributes) {
 500                              for (key in globalAttributes)
 501                                  attributes[key] = globalAttributes[key];
 502  
 503                              attributesOrder.push.apply(attributesOrder, globalAttributesOrder);
 504                          }
 505  
 506                          // Attributes defined
 507                          if (attrData) {
 508                              attrData = split(attrData, '|');
 509                              for (ai = 0, al = attrData.length; ai < al; ai++) {
 510                                  matches = attrRuleRegExp.exec(attrData[ai]);
 511                                  if (matches) {
 512                                      attr = {};
 513                                      attrType = matches[1];
 514                                      attrName = matches[2].replace(/::/g, ':');
 515                                      prefix = matches[3];
 516                                      value = matches[4];
 517  
 518                                      // Required
 519                                      if (attrType === '!') {
 520                                          element.attributesRequired = element.attributesRequired || [];
 521                                          element.attributesRequired.push(attrName);
 522                                          attr.required = true;
 523                                      }
 524  
 525                                      // Denied from global
 526                                      if (attrType === '-') {
 527                                          delete attributes[attrName];
 528                                          attributesOrder.splice(tinymce.inArray(attributesOrder, attrName), 1);
 529                                          continue;
 530                                      }
 531  
 532                                      // Default value
 533                                      if (prefix) {
 534                                          // Default value
 535                                          if (prefix === '=') {
 536                                              element.attributesDefault = element.attributesDefault || [];
 537                                              element.attributesDefault.push({name: attrName, value: value});
 538                                              attr.defaultValue = value;
 539                                          }
 540  
 541                                          // Forced value
 542                                          if (prefix === ':') {
 543                                              element.attributesForced = element.attributesForced || [];
 544                                              element.attributesForced.push({name: attrName, value: value});
 545                                              attr.forcedValue = value;
 546                                          }
 547  
 548                                          // Required values
 549                                          if (prefix === '<')
 550                                              attr.validValues = makeMap(value, '?');
 551                                      }
 552  
 553                                      // Check for attribute patterns
 554                                      if (hasPatternsRegExp.test(attrName)) {
 555                                          element.attributePatterns = element.attributePatterns || [];
 556                                          attr.pattern = patternToRegExp(attrName);
 557                                          element.attributePatterns.push(attr);
 558                                      } else {
 559                                          // Add attribute to order list if it doesn't already exist
 560                                          if (!attributes[attrName])
 561                                              attributesOrder.push(attrName);
 562  
 563                                          attributes[attrName] = attr;
 564                                      }
 565                                  }
 566                              }
 567                          }
 568  
 569                          // Global rule, store away these for later usage
 570                          if (!globalAttributes && elementName == '@') {
 571                              globalAttributes = attributes;
 572                              globalAttributesOrder = attributesOrder;
 573                          }
 574  
 575                          // Handle substitute elements such as b/strong
 576                          if (outputName) {
 577                              element.outputName = elementName;
 578                              elements[outputName] = element;
 579                          }
 580  
 581                          // Add pattern or exact element
 582                          if (hasPatternsRegExp.test(elementName)) {
 583                              element.pattern = patternToRegExp(elementName);
 584                              patternElements.push(element);
 585                          } else
 586                              elements[elementName] = element;
 587                      }
 588                  }
 589              }
 590          };
 591  
 592  		function setValidElements(valid_elements) {
 593              elements = {};
 594              patternElements = [];
 595  
 596              addValidElements(valid_elements);
 597  
 598              each(schemaItems, function(element, name) {
 599                  children[name] = element.children;
 600              });
 601          };
 602  
 603          // Adds custom non HTML elements to the schema
 604  		function addCustomElements(custom_elements) {
 605              var customElementRegExp = /^(~)?(.+)$/;
 606  
 607              if (custom_elements) {
 608                  each(split(custom_elements), function(rule) {
 609                      var matches = customElementRegExp.exec(rule),
 610                          inline = matches[1] === '~',
 611                          cloneName = inline ? 'span' : 'div',
 612                          name = matches[2];
 613  
 614                      children[name] = children[cloneName];
 615                      customElementsMap[name] = cloneName;
 616  
 617                      // If it's not marked as inline then add it to valid block elements
 618                      if (!inline) {
 619                          blockElementsMap[name.toUpperCase()] = {};
 620                          blockElementsMap[name] = {};
 621                      }
 622  
 623                      // Add elements clone if needed
 624                      if (!elements[name]) {
 625                          elements[name] = elements[cloneName];
 626                      }
 627  
 628                      // Add custom elements at span/div positions
 629                      each(children, function(element, child) {
 630                          if (element[cloneName])
 631                              element[name] = element[cloneName];
 632                      });
 633                  });
 634              }
 635          };
 636  
 637          // Adds valid children to the schema object
 638  		function addValidChildren(valid_children) {
 639              var childRuleRegExp = /^([+\-]?)(\w+)\[([^\]]+)\]$/;
 640  
 641              if (valid_children) {
 642                  each(split(valid_children), function(rule) {
 643                      var matches = childRuleRegExp.exec(rule), parent, prefix;
 644  
 645                      if (matches) {
 646                          prefix = matches[1];
 647  
 648                          // Add/remove items from default
 649                          if (prefix)
 650                              parent = children[matches[2]];
 651                          else
 652                              parent = children[matches[2]] = {'#comment' : {}};
 653  
 654                          parent = children[matches[2]];
 655  
 656                          each(split(matches[3], '|'), function(child) {
 657                              if (prefix === '-')
 658                                  delete parent[child];
 659                              else
 660                                  parent[child] = {};
 661                          });
 662                      }
 663                  });
 664              }
 665          };
 666  
 667  		function getElementRule(name) {
 668              var element = elements[name], i;
 669  
 670              // Exact match found
 671              if (element)
 672                  return element;
 673  
 674              // No exact match then try the patterns
 675              i = patternElements.length;
 676              while (i--) {
 677                  element = patternElements[i];
 678  
 679                  if (element.pattern.test(name))
 680                      return element;
 681              }
 682          };
 683  
 684          if (!settings.valid_elements) {
 685              // No valid elements defined then clone the elements from the schema spec
 686              each(schemaItems, function(element, name) {
 687                  elements[name] = {
 688                      attributes : element.attributes,
 689                      attributesOrder : element.attributesOrder
 690                  };
 691  
 692                  children[name] = element.children;
 693              });
 694  
 695              // Switch these on HTML4
 696              if (settings.schema != "html5") {
 697                  each(split('strong/b,em/i'), function(item) {
 698                      item = split(item, '/');
 699                      elements[item[1]].outputName = item[0];
 700                  });
 701              }
 702  
 703              // Add default alt attribute for images
 704              elements.img.attributesDefault = [{name: 'alt', value: ''}];
 705  
 706              // Remove these if they are empty by default
 707              each(split('ol,ul,sub,sup,blockquote,span,font,a,table,tbody,tr'), function(name) {
 708                  if (elements[name]) {
 709                      elements[name].removeEmpty = true;
 710                  }
 711              });
 712  
 713              // Padd these by default
 714              each(split('p,h1,h2,h3,h4,h5,h6,th,td,pre,div,address,caption'), function(name) {
 715                  elements[name].paddEmpty = true;
 716              });
 717          } else
 718              setValidElements(settings.valid_elements);
 719  
 720          addCustomElements(settings.custom_elements);
 721          addValidChildren(settings.valid_children);
 722          addValidElements(settings.extended_valid_elements);
 723  
 724          // Todo: Remove this when we fix list handling to be valid
 725          addValidChildren('+ol[ul|ol],+ul[ul|ol]');
 726  
 727          // Delete invalid elements
 728          if (settings.invalid_elements) {
 729              tinymce.each(tinymce.explode(settings.invalid_elements), function(item) {
 730                  if (elements[item])
 731                      delete elements[item];
 732              });
 733          }
 734  
 735          // If the user didn't allow span only allow internal spans
 736          if (!getElementRule('span'))
 737              addValidElements('span[!data-mce-type|*]');
 738  
 739          /**
 740           * Name/value map object with valid parents and children to those parents.
 741           *
 742           * @example
 743           * children = {
 744           *    div:{p:{}, h1:{}}
 745           * };
 746           * @field children
 747           * @type {Object}
 748           */
 749          self.children = children;
 750  
 751          /**
 752           * Name/value map object with valid styles for each element.
 753           *
 754           * @field styles
 755           * @type {Object}
 756           */
 757          self.styles = validStyles;
 758  
 759          /**
 760           * Returns a map with boolean attributes.
 761           *
 762           * @method getBoolAttrs
 763           * @return {Object} Name/value lookup map for boolean attributes.
 764           */
 765          self.getBoolAttrs = function() {
 766              return boolAttrMap;
 767          };
 768  
 769          /**
 770           * Returns a map with block elements.
 771           *
 772           * @method getBlockElements
 773           * @return {Object} Name/value lookup map for block elements.
 774           */
 775          self.getBlockElements = function() {
 776              return blockElementsMap;
 777          };
 778  
 779          /**
 780           * Returns a map with text block elements. Such as: p,h1-h6,div,address
 781           *
 782           * @method getTextBlockElements
 783           * @return {Object} Name/value lookup map for block elements.
 784           */
 785          self.getTextBlockElements = function() {
 786              return textBlockElementsMap;
 787          };
 788  
 789          /**
 790           * Returns a map with short ended elements such as BR or IMG.
 791           *
 792           * @method getShortEndedElements
 793           * @return {Object} Name/value lookup map for short ended elements.
 794           */
 795          self.getShortEndedElements = function() {
 796              return shortEndedElementsMap;
 797          };
 798  
 799          /**
 800           * Returns a map with self closing tags such as <li>.
 801           *
 802           * @method getSelfClosingElements
 803           * @return {Object} Name/value lookup map for self closing tags elements.
 804           */
 805          self.getSelfClosingElements = function() {
 806              return selfClosingElementsMap;
 807          };
 808  
 809          /**
 810           * Returns a map with elements that should be treated as contents regardless if it has text
 811           * content in them or not such as TD, VIDEO or IMG.
 812           *
 813           * @method getNonEmptyElements
 814           * @return {Object} Name/value lookup map for non empty elements.
 815           */
 816          self.getNonEmptyElements = function() {
 817              return nonEmptyElementsMap;
 818          };
 819  
 820          /**
 821           * Returns a map with elements where white space is to be preserved like PRE or SCRIPT.
 822           *
 823           * @method getWhiteSpaceElements
 824           * @return {Object} Name/value lookup map for white space elements.
 825           */
 826          self.getWhiteSpaceElements = function() {
 827              return whiteSpaceElementsMap;
 828          };
 829  
 830          /**
 831           * Returns true/false if the specified element and it's child is valid or not
 832           * according to the schema.
 833           *
 834           * @method isValidChild
 835           * @param {String} name Element name to check for.
 836           * @param {String} child Element child to verify.
 837           * @return {Boolean} True/false if the element is a valid child of the specified parent.
 838           */
 839          self.isValidChild = function(name, child) {
 840              var parent = children[name];
 841  
 842              return !!(parent && parent[child]);
 843          };
 844  
 845          /**
 846           * Returns true/false if the specified element name and optional attribute is
 847           * valid according to the schema.
 848           *
 849           * @method isValid
 850           * @param {String} name Name of element to check.
 851           * @param {String} attr Optional attribute name to check for.
 852           * @return {Boolean} True/false if the element and attribute is valid.
 853           */
 854          self.isValid = function(name, attr) {
 855              var attrPatterns, i, rule = getElementRule(name);
 856  
 857              // Check if it's a valid element
 858              if (rule) {
 859                  if (attr) {
 860                      // Check if attribute name exists
 861                      if (rule.attributes[attr]) {
 862                          return true;
 863                      }
 864  
 865                      // Check if attribute matches a regexp pattern
 866                      attrPatterns = rule.attributePatterns;
 867                      if (attrPatterns) {
 868                          i = attrPatterns.length;
 869                          while (i--) {
 870                              if (attrPatterns[i].pattern.test(name)) {
 871                                  return true;
 872                              }
 873                          }
 874                      }
 875                  } else {
 876                      return true;
 877                  }
 878              }
 879  
 880              // No match
 881              return false;
 882          };
 883  
 884          /**
 885           * Returns true/false if the specified element is valid or not
 886           * according to the schema.
 887           *
 888           * @method getElementRule
 889           * @param {String} name Element name to check for.
 890           * @return {Object} Element object or undefined if the element isn't valid.
 891           */
 892          self.getElementRule = getElementRule;
 893  
 894          /**
 895           * Returns an map object of all custom elements.
 896           *
 897           * @method getCustomElements
 898           * @return {Object} Name/value map object of all custom elements.
 899           */
 900          self.getCustomElements = function() {
 901              return customElementsMap;
 902          };
 903  
 904          /**
 905           * Parses a valid elements string and adds it to the schema. The valid elements format is for example "element[attr=default|otherattr]".
 906           * Existing rules will be replaced with the ones specified, so this extends the schema.
 907           *
 908           * @method addValidElements
 909           * @param {String} valid_elements String in the valid elements format to be parsed.
 910           */
 911          self.addValidElements = addValidElements;
 912  
 913          /**
 914           * Parses a valid elements string and sets it to the schema. The valid elements format is for example "element[attr=default|otherattr]".
 915           * Existing rules will be replaced with the ones specified, so this extends the schema.
 916           *
 917           * @method setValidElements
 918           * @param {String} valid_elements String in the valid elements format to be parsed.
 919           */
 920          self.setValidElements = setValidElements;
 921  
 922          /**
 923           * Adds custom non HTML elements to the schema.
 924           *
 925           * @method addCustomElements
 926           * @param {String} custom_elements Comma separated list of custom elements to add.
 927           */
 928          self.addCustomElements = addCustomElements;
 929  
 930          /**
 931           * Parses a valid children string and adds them to the schema structure. The valid children format is for example: "element[child1|child2]".
 932           *
 933           * @method addValidChildren
 934           * @param {String} valid_children Valid children elements string to parse
 935           */
 936          self.addValidChildren = addValidChildren;
 937  
 938          self.elements = elements;
 939      };
 940  })(tinymce);


Generated: Tue Mar 25 01:41:18 2014 WordPress honlapkészítés: online1.hu