Mambo API

[Summary view] [Print] [Text view]

   1  /**

   2   * $Id: editor_plugin_src.js 264 2007-04-26 20:53:09Z spocke $

   3   *

   4   * @author Moxiecode

   5   * @copyright Copyright © 2004-2008, Moxiecode Systems AB, All rights reserved.

   6   */
   7  
   8  (function() {
   9      var DOM = tinymce.DOM, Event = tinymce.dom.Event, each = tinymce.each, is = tinymce.is;
  10  
  11      tinymce.create('tinymce.plugins.Compat2x', {
  12          getInfo : function() {
  13              return {
  14                  longname : 'Compat2x',
  15                  author : 'Moxiecode Systems AB',
  16                  authorurl : 'http://tinymce.moxiecode.com',
  17                  infourl : 'http://wiki.moxiecode.com/index.php/TinyMCE:Plugins/compat2x',
  18                  version : tinyMCE.majorVersion + "." + tinyMCE.minorVersion
  19              };
  20          }
  21      });
  22  
  23      (function() {
  24          // Extend tinyMCE/EditorManager

  25          tinymce.extend(tinyMCE, {
  26              addToLang : function(p, l) {
  27                  each(l, function(v, k) {
  28                      tinyMCE.i18n[(tinyMCE.settings.language || 'en') + '.' + (p ? p + '_' : '') + k] = v;
  29                  });
  30              },
  31  
  32              getInstanceById : function(n) {
  33                  return this.get(n);
  34              }
  35          });
  36      })();
  37  
  38      (function() {
  39          var EditorManager = tinymce.EditorManager;
  40  
  41          tinyMCE.instances = {};
  42          tinyMCE.plugins = {};
  43          tinymce.PluginManager.onAdd.add(function(pm, n, p) {
  44              tinyMCE.plugins[n] = p;
  45          });
  46  
  47          tinyMCE.majorVersion = tinymce.majorVersion;
  48          tinyMCE.minorVersion = tinymce.minorVersion;
  49          tinyMCE.releaseDate = tinymce.releaseDate;
  50          tinyMCE.baseURL = tinymce.baseURL;
  51          tinyMCE.isIE = tinyMCE.isMSIE = tinymce.isIE || tinymce.isOpera;
  52          tinyMCE.isMSIE5 = tinymce.isIE;
  53          tinyMCE.isMSIE5_0 = tinymce.isIE;
  54          tinyMCE.isMSIE7 = tinymce.isIE;
  55          tinyMCE.isGecko = tinymce.isGecko;
  56          tinyMCE.isSafari = tinymce.isWebKit;
  57          tinyMCE.isOpera = tinymce.isOpera;
  58          tinyMCE.isMac = false;
  59          tinyMCE.isNS7 = false;
  60          tinyMCE.isNS71 = false;
  61          tinyMCE.compat = true;
  62  
  63          // Extend tinyMCE class

  64          TinyMCE_Engine = tinyMCE;
  65          tinymce.extend(tinyMCE, {
  66              getParam : function(n, dv) {
  67                  return this.activeEditor.getParam(n, dv);
  68              },
  69  
  70              addEvent : function(e, na, f, sc) {
  71                  tinymce.dom.Event.add(e, na, f, sc || this);
  72              },
  73  
  74              getControlHTML : function(n) {
  75                  return EditorManager.activeEditor.controlManager.createControl(n);
  76              },
  77  
  78              loadCSS : function(u) {
  79                  tinymce.DOM.loadCSS(u);
  80              },
  81  
  82              importCSS : function(doc, u) {
  83                  if (doc == document)
  84                      this.loadCSS(u);
  85                  else
  86                      new tinymce.dom.DOMUtils(doc).loadCSS(u);
  87              },
  88  
  89              log : function() {
  90                  console.debug.apply(console, arguments);
  91              },
  92  
  93              getLang : function(n, dv) {
  94                  var v = EditorManager.activeEditor.getLang(n.replace(/^lang_/g, ''), dv);
  95  
  96                  // Is number

  97                  if (/^[0-9\-.]+$/g.test(v))
  98                      return parseInt(v);
  99  
 100                  return v;
 101              },
 102  
 103              isInstance : function(o) {
 104                  return o != null && typeof(o) == "object" && o.execCommand;
 105              },
 106  
 107              triggerNodeChange : function() {
 108                  EditorManager.activeEditor.nodeChanged();
 109              },
 110  
 111              regexpReplace : function(in_str, reg_exp, replace_str, opts) {
 112                  var re;
 113  
 114                  if (in_str == null)
 115                      return in_str;
 116  
 117                  if (typeof(opts) == "undefined")
 118                      opts = 'g';
 119  
 120                  re = new RegExp(reg_exp, opts);
 121  
 122                  return in_str.replace(re, replace_str);
 123              },
 124  
 125              trim : function(s) {
 126                  return tinymce.trim(s);
 127              },
 128  
 129              xmlEncode : function(s) {
 130                  return tinymce.DOM.encode(s);
 131              },
 132  
 133              explode : function(s, d) {
 134                  var o = [];
 135  
 136                  tinymce.each(s.split(d), function(v) {
 137                      if (v != '')
 138                          o.push(v);
 139                  });
 140  
 141                  return o;
 142              },
 143  
 144              switchClass : function(id, cls) {
 145                  var b;
 146  
 147                  if (/^mceButton/.test(cls)) {
 148                      b = EditorManager.activeEditor.controlManager.get(id);
 149  
 150                      if (!b)
 151                          return;
 152  
 153                      switch (cls) {
 154                          case "mceButtonNormal":
 155                              b.setDisabled(false);
 156                              b.setActive(false);
 157                              return;
 158  
 159                          case "mceButtonDisabled":
 160                              b.setDisabled(true);
 161                              return;
 162  
 163                          case "mceButtonSelected":
 164                              b.setActive(true);
 165                              b.setDisabled(false);
 166                              return;
 167                      }
 168                  }
 169              },
 170  
 171              addCSSClass : function(e, n, b) {
 172                  return tinymce.DOM.addClass(e, n, b);
 173              },
 174  
 175              hasCSSClass : function(e, n) {
 176                  return tinymce.DOM.hasClass(e, n);
 177              },
 178  
 179              removeCSSClass : function(e, n) {
 180                  return tinymce.DOM.removeClass(e, n);
 181              },
 182  
 183              getCSSClasses : function() {
 184                  var cl = EditorManager.activeEditor.dom.getClasses(), o = [];
 185  
 186                  each(cl, function(c) {
 187                      o.push(c['class']);
 188                  });
 189  
 190                  return o;
 191              },
 192  
 193              setWindowArg : function(n, v) {
 194                  EditorManager.activeEditor.windowManager.params[n] = v;
 195              },
 196  
 197              getWindowArg : function(n, dv) {
 198                  var wm = EditorManager.activeEditor.windowManager, v;
 199  
 200                  v = wm.getParam(n);
 201                  if (v === '')
 202                      return '';
 203  
 204                  return v || wm.getFeature(n) || dv;
 205              },
 206  
 207              getParentNode : function(n, f) {
 208                  return this._getDOM().getParent(n, f);
 209              },
 210  
 211              selectElements : function(n, na, f) {
 212                  var i, a = [], nl, x;
 213  
 214                  for (x=0, na = na.split(','); x<na.length; x++)
 215                      for (i=0, nl = n.getElementsByTagName(na[x]); i<nl.length; i++)
 216                          (!f || f(nl[i])) && a.push(nl[i]);
 217  
 218                  return a;
 219              },
 220  
 221              getNodeTree : function(n, na, t, nn) {
 222                  return this.selectNodes(n, function(n) {
 223                      return (!t || n.nodeType == t) && (!nn || n.nodeName == nn);
 224                  }, na ? na : []);
 225              },
 226  
 227              getAttrib : function(e, n, dv) {
 228                  return this._getDOM().getAttrib(e, n, dv);
 229              },
 230  
 231              setAttrib : function(e, n, v) {
 232                  return this._getDOM().setAttrib(e, n, v);
 233              },
 234  
 235              getElementsByAttributeValue : function(n, e, a, v) {
 236                  var i, nl = n.getElementsByTagName(e), o = [];
 237  
 238                  for (i=0; i<nl.length; i++) {
 239                      if (tinyMCE.getAttrib(nl[i], a).indexOf(v) != -1)
 240                          o[o.length] = nl[i];
 241                  }
 242  
 243                  return o;
 244              },
 245  
 246              selectNodes : function(n, f, a) {
 247                  var i;
 248  
 249                  if (!a)
 250                      a = [];
 251  
 252                  if (f(n))
 253                      a[a.length] = n;
 254  
 255                  if (n.hasChildNodes()) {
 256                      for (i=0; i<n.childNodes.length; i++)
 257                          tinyMCE.selectNodes(n.childNodes[i], f, a);
 258                  }
 259  
 260                  return a;
 261              },
 262  
 263              getContent : function() {
 264                  return EditorManager.activeEditor.getContent();
 265              },
 266  
 267              getParentElement : function(n, na, f) {
 268                  if (na)
 269                      na = new RegExp('^(' + na.toUpperCase().replace(/,/g, '|') + ')$', 'g');
 270  
 271                  return this._getDOM().getParent(n, function(n) {
 272                      return n.nodeType == 1 && (!na || na.test(n.nodeName)) && (!f || f(n));
 273                  }, this.activeEditor.getBody());
 274              },
 275  
 276              importPluginLanguagePack : function(n) {
 277                  tinymce.PluginManager.requireLangPack(n);
 278              },
 279  
 280              getButtonHTML : function(cn, lang, img, c, u, v) {
 281                  var ed = EditorManager.activeEditor;
 282  
 283                  img = img.replace(/\{\$pluginurl\}/g, tinyMCE.pluginURL);
 284                  img = img.replace(/\{\$themeurl\}/g, tinyMCE.themeURL);
 285                  lang = lang.replace(/^lang_/g, '');
 286  
 287                  return ed.controlManager.createButton(cn, {
 288                      title : lang,
 289                      command : c,
 290                      ui : u,
 291                      value : v,
 292                      scope : this,
 293                      'class' : 'compat',
 294                      image : img
 295                  });
 296              },
 297  
 298              addSelectAccessibility : function(e, s, w) {
 299                  // Add event handlers 

 300                  if (!s._isAccessible) {
 301                      s.onkeydown = tinyMCE.accessibleEventHandler;
 302                      s.onblur = tinyMCE.accessibleEventHandler;
 303                      s._isAccessible = true;
 304                      s._win = w;
 305                  }
 306  
 307                  return false;
 308              },
 309  
 310              accessibleEventHandler : function(e) {
 311                  var elm, win = this._win;
 312  
 313                  e = tinymce.isIE ? win.event : e;
 314                  elm = tinymce.isIE ? e.srcElement : e.target;
 315  
 316                  // Unpiggyback onchange on blur

 317                  if (e.type == "blur") {
 318                      if (elm.oldonchange) {
 319                          elm.onchange = elm.oldonchange;
 320                          elm.oldonchange = null;
 321                      }
 322  
 323                      return true;
 324                  }
 325  
 326                  // Piggyback onchange

 327                  if (elm.nodeName == "SELECT" && !elm.oldonchange) {
 328                      elm.oldonchange = elm.onchange;
 329                      elm.onchange = null;
 330                  }
 331  
 332                  // Execute onchange and remove piggyback

 333                  if (e.keyCode == 13 || e.keyCode == 32) {
 334                      elm.onchange = elm.oldonchange;
 335                      elm.onchange();
 336                      elm.oldonchange = null;
 337  
 338                      tinyMCE.cancelEvent(e);
 339                      return false;
 340                  }
 341  
 342                  return true;
 343              },
 344  
 345              cancelEvent : function(e) {
 346                  return tinymce.dom.Event.cancel(e);
 347              },
 348  
 349              handleVisualAid : function(e) {
 350                  EditorManager.activeEditor.addVisual(e);
 351              },
 352  
 353              getAbsPosition : function(n, r) {
 354                  return tinymce.DOM.getPos(n, r);
 355              },
 356  
 357              cleanupEventStr : function(s) {
 358                  s = "" + s;
 359                  s = s.replace('function anonymous()\n{\n', '');
 360                  s = s.replace('\n}', '');
 361                  s = s.replace(/^return true;/gi, ''); // Remove event blocker

 362  
 363                  return s;
 364              },
 365  
 366              getVisualAidClass : function(s) {
 367                  // TODO: Implement

 368                  return s;
 369              },
 370  
 371              parseStyle : function(s) {
 372                  return this._getDOM().parseStyle(s);
 373              },
 374  
 375              serializeStyle : function(s) {
 376                  return this._getDOM().serializeStyle(s);
 377              },
 378  
 379              openWindow : function(tpl, args) {
 380                  var ed = EditorManager.activeEditor, o = {}, n;
 381  
 382                  // Convert name/value array to object

 383                  for (n in tpl)
 384                      o[n] = tpl[n];
 385  
 386                  tpl = o;
 387  
 388                  args = args || {};
 389                  tpl.url = new tinymce.util.URI(tinymce.ThemeManager.themeURLs[ed.settings.theme]).toAbsolute(tpl.file);
 390                  tpl.inline = tpl.inline || args.inline;
 391  
 392                  ed.windowManager.open(tpl, args);
 393              },
 394  
 395              closeWindow : function(win) {
 396                  EditorManager.activeEditor.windowManager.close(win);
 397              },
 398  
 399              getOuterHTML : function(e) {
 400                  return tinymce.DOM.getOuterHTML(e);
 401              },
 402  
 403              setOuterHTML : function(e, h, d) {
 404                  return tinymce.DOM.setOuterHTML(e, h, d);
 405              },
 406  
 407              hasPlugin : function(n) {
 408                  return tinymce.PluginManager.get(n) != null;
 409              },
 410  
 411              _setEventsEnabled : function() {
 412                  // Ignore it!!

 413              },
 414  
 415              addPlugin : function(pn, f) {
 416                  var t = this;
 417  
 418  				function PluginWrapper(ed) {
 419                      tinyMCE.selectedInstance = ed;
 420  
 421                      ed.onInit.add(function() {
 422                          t.settings = ed.settings;
 423                          t.settings['base_href'] = tinyMCE.documentBasePath;
 424                          tinyMCE.settings = t.settings;
 425                          tinyMCE.documentBasePath = ed.documentBasePath;
 426                          //ed.formElement = DOM.get(ed.id);

 427  
 428                          if (f.initInstance)
 429                              f.initInstance(ed);
 430  
 431                          ed.contentDocument = ed.getDoc();
 432                          ed.contentWindow = ed.getWin();
 433                          ed.undoRedo = ed.undoManager;
 434                          ed.startContent = ed.getContent({format : 'raw'});
 435  
 436                          tinyMCE.instances[ed.id] = ed;
 437                          tinyMCE.loadedFiles = [];
 438                      });
 439  
 440                      ed.onActivate.add(function() {
 441                          tinyMCE.settings = ed.settings;
 442                          tinyMCE.selectedInstance = ed;
 443                      });
 444  
 445                  /*    if (f.removeInstance) {

 446                          ed.onDestroy.add(function() {

 447                              return f.removeInstance(ed.id);

 448                          });

 449                      }*/
 450  
 451                      if (f.handleNodeChange) {
 452                          ed.onNodeChange.add(function(ed, cm, n) {
 453                              f.handleNodeChange(ed.id, n, 0, 0, false, !ed.selection.isCollapsed());
 454                          });
 455                      }
 456  
 457                      if (f.onChange) {
 458                          ed.onChange.add(function(ed, n) {
 459                              return f.onChange(ed);
 460                          });
 461                      }
 462  
 463                      if (f.cleanup) {
 464                          ed.onGetContent.add(function() {
 465                              //f.cleanup(type, content, inst);

 466                          });
 467                      }
 468  
 469                      this.getInfo = function() {
 470                          return f.getInfo();
 471                      };
 472  
 473                      this.createControl = function(n) {
 474                          tinyMCE.pluginURL = tinymce.baseURL + '/plugins/' + pn;
 475                          tinyMCE.themeURL = tinymce.baseURL + '/themes/' + tinyMCE.activeEditor.settings.theme;
 476  
 477                          if (f.getControlHTML)
 478                              return f.getControlHTML(n);
 479  
 480                          return null;
 481                      };
 482  
 483                      this.execCommand = function(cmd, ui, val) {
 484                          if (f.execCommand)
 485                              return f.execCommand(ed.id, ed.getBody(), cmd, ui, val);
 486  
 487                          return false;
 488                      };
 489                  };
 490  
 491                  tinymce.PluginManager.add(pn, PluginWrapper);
 492              },
 493  
 494              _getDOM : function() {
 495                  return tinyMCE.activeEditor ? tinyMCE.activeEditor.dom : tinymce.DOM;
 496              },
 497  
 498              convertRelativeToAbsoluteURL : function(b, u) {
 499                  return new tinymce.util.URI(b).toAbsolute(u);
 500              },
 501  
 502              convertAbsoluteURLToRelativeURL : function(b, u) {
 503                  return new tinymce.util.URI(b).toRelative(u);
 504              }
 505          });
 506  
 507          // Extend Editor class

 508          tinymce.extend(tinymce.Editor.prototype, {
 509              getFocusElement : function() {
 510                  return this.selection.getNode();
 511              },
 512  
 513              getData : function(n) {
 514                  if (!this.data)
 515                      this.data = [];
 516  
 517                  if (!this.data[n])
 518                      this.data[n] = [];
 519  
 520                  return this.data[n];
 521              },
 522  
 523              hasPlugin : function(n) {
 524                  return this.plugins[n] != null;
 525              },
 526  
 527              getContainerWin : function() {
 528                  return window;
 529              },
 530  
 531              getHTML : function(raw) {
 532                  return this.getContent({ format : raw ? 'raw' : 'html'});
 533              },
 534  
 535              setHTML : function(h) {
 536                  this.setContent(h);
 537              },
 538  
 539              getSel : function() {
 540                  return this.selection.getSel();
 541              },
 542  
 543              getRng : function() {
 544                  return this.selection.getRng();
 545              },
 546  
 547              isHidden : function() {
 548                  var s;
 549  
 550                  if (!tinymce.isGecko)
 551                      return false;
 552  
 553                  s = this.getSel();
 554  
 555                  // Weird, wheres that cursor selection?

 556                  return (!s || !s.rangeCount || s.rangeCount == 0);
 557              },
 558  
 559              translate : function(s) {
 560                  var c = this.settings.language, o;
 561  
 562                  o = tinymce.EditorManager.i18n[c + '.' + s] || s.replace(/{\#([^}]+)\}/g, function(a, b) {
 563                      return tinymce.EditorManager.i18n[c + '.' + b] || '{#' + b + '}';
 564                  });
 565  
 566                  o = o.replace(/{\$lang_([^}]+)\}/g, function(a, b) {
 567                      return tinymce.EditorManager.i18n[c + '.' + b] || '{$lang_' + b + '}';
 568                  });
 569  
 570                  return o;
 571              },
 572  
 573              repaint : function() {
 574                  this.execCommand('mceRepaint');
 575              }
 576          });
 577  
 578          // Extend selection

 579          tinymce.extend(tinymce.dom.Selection.prototype, {
 580              getSelectedText : function() {
 581                  return this.getContent({format : 'text'});
 582              },
 583  
 584              getSelectedHTML : function() {
 585                  return this.getContent({format : 'html'});
 586              },
 587  
 588              getFocusElement : function() {
 589                  return this.getNode();
 590              },
 591  
 592              selectNode : function(node, collapse, select_text_node, to_start) {
 593                  var t = this;
 594  
 595                  t.select(node, select_text_node || 0);
 596  
 597                  if (!is(collapse))
 598                      collapse = true;
 599  
 600                  if (collapse) {
 601                      if (!is(to_start))
 602                          to_start = true;
 603  
 604                      t.collapse(to_start);
 605                  }
 606              }
 607          });
 608      }).call(this);
 609  
 610      // Register plugin

 611      tinymce.PluginManager.add('compat2x', tinymce.plugins.Compat2x);
 612  })();
 613