first import

sites/all/modules/wysiwyg/editors/js/ckeditor-3.0.js

@@ -0,0 +1,217 @@
+(function($) {
+
+Drupal.wysiwyg.editor.init.ckeditor = function(settings) {
+  // Plugins must only be loaded once. Only the settings from the first format
+  // will be used but they're identical anyway.
+  var registeredPlugins = {};
+  for (var format in settings) {
+    if (Drupal.settings.wysiwyg.plugins[format]) {
+      // Register native external plugins.
+      // Array syntax required; 'native' is a predefined token in JavaScript.
+      for (var pluginName in Drupal.settings.wysiwyg.plugins[format]['native']) {
+        if (!registeredPlugins[pluginName]) {
+          var plugin = Drupal.settings.wysiwyg.plugins[format]['native'][pluginName];
+          CKEDITOR.plugins.addExternal(pluginName, plugin.path, plugin.fileName);
+          registeredPlugins[pluginName] = true;
+        }
+      }
+      // Register Drupal plugins.
+      for (var pluginName in Drupal.settings.wysiwyg.plugins[format].drupal) {
+        if (!registeredPlugins[pluginName]) {
+          Drupal.wysiwyg.editor.instance.ckeditor.addPlugin(pluginName, Drupal.settings.wysiwyg.plugins[format].drupal[pluginName], Drupal.settings.wysiwyg.plugins.drupal[pluginName]);
+          registeredPlugins[pluginName] = true;
+        }
+      }
+    }
+  }
+};
+
+
+/**
+ * Attach this editor to a target element.
+ */
+Drupal.wysiwyg.editor.attach.ckeditor = function(context, params, settings) {
+  // Apply editor instance settings.
+  CKEDITOR.config.customConfig = '';
+
+  settings.on = {
+    instanceReady: function(ev) {
+      var editor = ev.editor;
+      // Get a list of block, list and table tags from CKEditor's XHTML DTD.
+      // @see http://docs.cksource.com/CKEditor_3.x/Developers_Guide/Output_Formatting.
+      var dtd = CKEDITOR.dtd;
+      var tags = CKEDITOR.tools.extend({}, dtd.$block, dtd.$listItem, dtd.$tableContent);
+      // Set source formatting rules for each listed tag except <pre>.
+      // Linebreaks can be inserted before or after opening and closing tags.
+      if (settings.apply_source_formatting) {
+        // Mimic FCKeditor output, by breaking lines between tags.
+        for (var tag in tags) {
+          if (tag == 'pre') {
+            continue;
+          }
+          this.dataProcessor.writer.setRules(tag, {
+            indent: true,
+            breakBeforeOpen: true,
+            breakAfterOpen: false,
+            breakBeforeClose: false,
+            breakAfterClose: true
+          });
+        }
+      }
+      else {
+        // CKEditor adds default formatting to <br>, so we want to remove that
+        // here too.
+        tags.br = 1;
+        // No indents or linebreaks;
+        for (var tag in tags) {
+          if (tag == 'pre') {
+            continue;
+          }
+          this.dataProcessor.writer.setRules(tag, {
+            indent: false,
+            breakBeforeOpen: false,
+            breakAfterOpen: false,
+            breakBeforeClose: false,
+            breakAfterClose: false
+          });
+        }
+      }
+    },
+
+    pluginsLoaded: function(ev) {
+      // Override the conversion methods to let Drupal plugins modify the data.
+      var editor = ev.editor;
+      if (editor.dataProcessor && Drupal.settings.wysiwyg.plugins[params.format]) {
+        editor.dataProcessor.toHtml = CKEDITOR.tools.override(editor.dataProcessor.toHtml, function(originalToHtml) {
+          // Convert raw data for display in WYSIWYG mode.
+          return function(data, fixForBody) {
+            for (var plugin in Drupal.settings.wysiwyg.plugins[params.format].drupal) {
+              if (typeof Drupal.wysiwyg.plugins[plugin].attach == 'function') {
+                data = Drupal.wysiwyg.plugins[plugin].attach(data, Drupal.settings.wysiwyg.plugins.drupal[plugin], editor.name);
+                data = Drupal.wysiwyg.instances[params.field].prepareContent(data);
+              }
+            }
+            return originalToHtml.call(this, data, fixForBody);
+          };
+        });
+        editor.dataProcessor.toDataFormat = CKEDITOR.tools.override(editor.dataProcessor.toDataFormat, function(originalToDataFormat) {
+          // Convert WYSIWYG mode content to raw data.
+          return function(data, fixForBody) {
+            data = originalToDataFormat.call(this, data, fixForBody);
+            for (var plugin in Drupal.settings.wysiwyg.plugins[params.format].drupal) {
+              if (typeof Drupal.wysiwyg.plugins[plugin].detach == 'function') {
+                data = Drupal.wysiwyg.plugins[plugin].detach(data, Drupal.settings.wysiwyg.plugins.drupal[plugin], editor.name);
+              }
+            }
+            return data;
+          };
+        });
+      }
+    },
+
+    selectionChange: function (event) {
+      var pluginSettings = Drupal.settings.wysiwyg.plugins[params.format];
+      if (pluginSettings && pluginSettings.drupal) {
+        $.each(pluginSettings.drupal, function (name) {
+          var plugin = Drupal.wysiwyg.plugins[name];
+          if ($.isFunction(plugin.isNode)) {
+            var node = event.data.selection.getSelectedElement();
+            var state = plugin.isNode(node ? node.$ : null) ? CKEDITOR.TRISTATE_ON : CKEDITOR.TRISTATE_OFF;
+            event.editor.getCommand(name).setState(state);
+          }
+        });
+      }
+    },
+
+    focus: function(ev) {
+      Drupal.wysiwyg.activeId = ev.editor.name;
+    }
+  };
+
+  // Attach editor.
+  CKEDITOR.replace(params.field, settings);
+};
+
+/**
+ * Detach a single or all editors.
+ *
+ * @todo 3.x: editor.prototype.getInstances() should always return an array
+ *   containing all instances or the passed in params.field instance, but
+ *   always return an array to simplify all detach functions.
+ */
+Drupal.wysiwyg.editor.detach.ckeditor = function(context, params) {
+  if (typeof params != 'undefined') {
+    var instance = CKEDITOR.instances[params.field];
+    if (instance) {
+      instance.destroy();
+    }
+  }
+  else {
+    for (var instanceName in CKEDITOR.instances) {
+      CKEDITOR.instances[instanceName].destroy();
+    }
+  }
+};
+
+Drupal.wysiwyg.editor.instance.ckeditor = {
+  addPlugin: function(pluginName, settings, pluginSettings) {
+    CKEDITOR.plugins.add(pluginName, {
+      // Wrap Drupal plugin in a proxy pluygin.
+      init: function(editor) {
+        if (settings.css) {
+          editor.on('mode', function(ev) {
+            if (ev.editor.mode == 'wysiwyg') {
+              // Inject CSS files directly into the editing area head tag.
+              $('head', $('#cke_contents_' + ev.editor.name + ' iframe').eq(0).contents()).append('<link rel="stylesheet" href="' + settings.css + '" type="text/css" >');
+            }
+          });
+        }
+        if (typeof Drupal.wysiwyg.plugins[pluginName].invoke == 'function') {
+          var pluginCommand = {
+            exec: function (editor) {
+              var data = { format: 'html', node: null, content: '' };
+              var selection = editor.getSelection();
+              if (selection) {
+                data.node = selection.getSelectedElement();
+                if (data.node) {
+                  data.node = data.node.$;
+                }
+                if (selection.getType() == CKEDITOR.SELECTION_TEXT) {
+                  if (CKEDITOR.env.ie) {
+                    data.content = selection.getNative().createRange().text;
+                  }
+                  else {
+                    data.content = selection.getNative().toString();
+                  }
+                }
+                else if (data.node) {
+                  // content is supposed to contain the "outerHTML".
+                  data.content = data.node.parentNode.innerHTML;
+                }
+              }
+              Drupal.wysiwyg.plugins[pluginName].invoke(data, pluginSettings, editor.name);
+            }
+          };
+          editor.addCommand(pluginName, pluginCommand);
+        }
+        editor.ui.addButton(pluginName, {
+          label: settings.iconTitle,
+          command: pluginName,
+          icon: settings.icon
+        });
+
+        // @todo Add button state handling.
+      }
+    });
+  },
+  prepareContent: function(content) {
+    // @todo Don't know if we need this yet.
+    return content;
+  },
+  insert: function(content) {
+    content = this.prepareContent(content);
+    CKEDITOR.instances[this.field].insertHtml(content);
+  }
+};
+
+})(jQuery);

sites/all/modules/wysiwyg/editors/js/fckeditor-2.6.js

@@ -0,0 +1,181 @@
+(function($) {
+
+/**
+ * Attach this editor to a target element.
+ */
+Drupal.wysiwyg.editor.attach.fckeditor = function(context, params, settings) {
+  var FCKinstance = new FCKeditor(params.field, settings.Width, settings.Height, settings.ToolbarSet);
+  // Apply editor instance settings.
+  FCKinstance.BasePath = settings.EditorPath;
+  FCKinstance.Config.wysiwygFormat = params.format;
+  FCKinstance.Config.CustomConfigurationsPath = settings.CustomConfigurationsPath;
+
+  // Load Drupal plugins and apply format specific settings.
+  // @see fckeditor.config.js
+  // @see Drupal.wysiwyg.editor.instance.fckeditor.init()
+
+  // Attach editor.
+  FCKinstance.ReplaceTextarea();
+};
+
+/**
+ * Detach a single or all editors.
+ */
+Drupal.wysiwyg.editor.detach.fckeditor = function(context, params) {
+  var instances = [];
+  if (typeof params != 'undefined' && typeof FCKeditorAPI != 'undefined') {
+    var instance = FCKeditorAPI.GetInstance(params.field);
+    if (instance) {
+      instances[params.field] = instance;
+    }
+  }
+  else {
+    instances = FCKeditorAPI.__Instances;
+  }
+
+  for (var instanceName in instances) {
+    var instance = instances[instanceName];
+    instance.UpdateLinkedField();
+    // Since we already detach the editor and update the textarea, the submit
+    // event handler needs to be removed to prevent data loss (in IE).
+    // FCKeditor uses 2 nested iFrames; instance.EditingArea.Window is the
+    // deepest. Its parent is the iFrame containing the editor.
+    var instanceScope = instance.EditingArea.Window.parent;
+    instanceScope.FCKTools.RemoveEventListener(instance.GetParentForm(), 'submit', instance.UpdateLinkedField); 
+    // Run cleanups before forcing an unload of the iFrames or IE crashes.
+    // This also deletes the instance from the FCKeditorAPI.__Instances array.
+    instanceScope.FCKTools.RemoveEventListener(instanceScope, 'unload', instanceScope.FCKeditorAPI_Cleanup);
+    instanceScope.FCKTools.RemoveEventListener(instanceScope, 'beforeunload', instanceScope.FCKeditorAPI_ConfirmCleanup);
+    if (jQuery.isFunction(instanceScope.FCKIECleanup_Cleanup)) {
+      instanceScope.FCKIECleanup_Cleanup();
+    }
+    instanceScope.FCKeditorAPI_ConfirmCleanup();
+    instanceScope.FCKeditorAPI_Cleanup();
+    // Remove the editor elements.
+    $('#' + instanceName + '___Config').remove();
+    $('#' + instanceName + '___Frame').remove();
+    $('#' + instanceName).show();
+  }
+};
+
+Drupal.wysiwyg.editor.instance.fckeditor = {
+  init: function(instance) {
+    // Track which editor instance is active.
+    instance.FCK.Events.AttachEvent('OnFocus', function(editorInstance) {
+      Drupal.wysiwyg.activeId = editorInstance.Name;
+    });
+
+    // Create a custom data processor to wrap the default one and allow Drupal
+    // plugins modify the editor contents.
+    var wysiwygDataProcessor = function() {};
+    wysiwygDataProcessor.prototype = new instance.FCKDataProcessor();
+    // Attach: Convert text into HTML.
+    wysiwygDataProcessor.prototype.ConvertToHtml = function(data) {
+      // Called from SetData() with stripped comments/scripts, revert those
+      // manipulations and attach Drupal plugins.
+      var data = instance.FCKConfig.ProtectedSource.Revert(data);
+      if (Drupal.settings.wysiwyg.plugins[instance.wysiwygFormat] && Drupal.settings.wysiwyg.plugins[instance.wysiwygFormat].drupal) {
+        for (var plugin in Drupal.settings.wysiwyg.plugins[instance.wysiwygFormat].drupal) {
+          if (typeof Drupal.wysiwyg.plugins[plugin].attach == 'function') {
+            data = Drupal.wysiwyg.plugins[plugin].attach(data, Drupal.settings.wysiwyg.plugins.drupal[plugin], instance.FCK.Name);
+            data = Drupal.wysiwyg.editor.instance.fckeditor.prepareContent(data);
+          }
+        }
+      }
+      // Re-protect the source and use the original data processor to convert it
+      // into XHTML.
+      data = instance.FCKConfig.ProtectedSource.Protect(data);
+      return instance.FCKDataProcessor.prototype.ConvertToHtml.call(this, data);
+    };
+    // Detach: Convert HTML into text.
+    wysiwygDataProcessor.prototype.ConvertToDataFormat = function(rootNode, excludeRoot, ignoreIfEmptyParagraph, format) {
+      // Called from GetData(), convert the content's DOM into a XHTML string
+      // using the original data processor and detach Drupal plugins.
+      var data = instance.FCKDataProcessor.prototype.ConvertToDataFormat.call(this, rootNode, excludeRoot, ignoreIfEmptyParagraph, format);
+      if (Drupal.settings.wysiwyg.plugins[instance.wysiwygFormat] && Drupal.settings.wysiwyg.plugins[instance.wysiwygFormat].drupal) {
+        for (var plugin in Drupal.settings.wysiwyg.plugins[instance.wysiwygFormat].drupal) {
+          if (typeof Drupal.wysiwyg.plugins[plugin].detach == 'function') {
+            data = Drupal.wysiwyg.plugins[plugin].detach(data, Drupal.settings.wysiwyg.plugins.drupal[plugin], instance.FCK.Name);
+          }
+        }
+      }
+      return data;
+    };
+    instance.FCK.DataProcessor = new wysiwygDataProcessor();
+  },
+
+  addPlugin: function(plugin, settings, pluginSettings, instance) {
+    if (typeof Drupal.wysiwyg.plugins[plugin] != 'object') {
+      return;
+    }
+
+    if (Drupal.settings.wysiwyg.plugins[instance.wysiwygFormat].drupal[plugin].css) {
+      instance.FCKConfig.EditorAreaCSS += ',' + Drupal.settings.wysiwyg.plugins[instance.wysiwygFormat].drupal[plugin].css;
+    }
+
+    // @see fckcommands.js, fck_othercommands.js, fckpastewordcommand.js
+    instance.FCKCommands.RegisterCommand(plugin, {
+      // Invoke the plugin's button.
+      Execute: function () {
+        if (typeof Drupal.wysiwyg.plugins[plugin].invoke == 'function') {
+          var data = { format: 'html', node: instance.FCKSelection.GetParentElement() };
+          // @todo This is NOT the same as data.node.
+          data.content = data.node.innerHTML;
+          Drupal.wysiwyg.plugins[plugin].invoke(data, pluginSettings, instance.FCK.Name);
+        }
+      },
+
+      // isNode: Return whether the plugin button should be enabled for the
+      // current selection.
+      // @see FCKUnlinkCommand.prototype.GetState()
+      GetState: function () {
+        // Always disabled if not in WYSIWYG mode.
+        if (instance.FCK.EditMode != FCK_EDITMODE_WYSIWYG) {
+          return FCK_TRISTATE_DISABLED;
+        }
+        var state = instance.FCK.GetNamedCommandState(this.Name);
+        // FCKeditor sets the wrong state in WebKit browsers.
+        if (!$.support.queryCommandEnabled && state == FCK_TRISTATE_DISABLED) {
+          state = FCK_TRISTATE_OFF;
+        }
+        if (state == FCK_TRISTATE_OFF && instance.FCK.EditMode == FCK_EDITMODE_WYSIWYG) {
+          if (typeof Drupal.wysiwyg.plugins[plugin].isNode == 'function') {
+            var node = instance.FCKSelection.GetSelectedElement();
+            state = Drupal.wysiwyg.plugins[plugin].isNode(node) ? FCK_TRISTATE_ON : FCK_TRISTATE_OFF;
+          }
+        }
+        return state;
+      },
+
+      /**
+       * Return information about the plugin as a name/value array.
+       */
+      Name: plugin
+    });
+
+    // Register the plugin button.
+    // Arguments: commandName, label, tooltip, style, sourceView, contextSensitive, icon.
+    instance.FCKToolbarItems.RegisterItem(plugin, new instance.FCKToolbarButton(plugin, settings.iconTitle, settings.iconTitle, null, false, true, settings.icon));
+  },
+
+  openDialog: function(dialog, params) {
+    // @todo Implement open dialog.
+  },
+
+  closeDialog: function(dialog) {
+    // @todo Implement close dialog.
+  },
+
+  prepareContent: function(content) {
+    // @todo Not needed for FCKeditor?
+    return content;
+  },
+
+  insert: function(content) {
+    var instance = FCKeditorAPI.GetInstance(this.field);
+    // @see FCK.InsertHtml(), FCK.InsertElement()
+    instance.InsertHtml(content);
+  }
+};
+
+})(jQuery);

sites/all/modules/wysiwyg/editors/js/fckeditor.config.js

@@ -0,0 +1,73 @@
+
+Drupal = window.parent.Drupal;
+
+/**
+ * Fetch and provide original editor settings as local variable.
+ *
+ * FCKeditor does not support to pass complex variable types to the editor.
+ * Instance settings passed to FCKinstance.Config are temporarily stored in
+ * FCKConfig.PageConfig.
+ */
+var wysiwygFormat = FCKConfig.PageConfig.wysiwygFormat;
+var wysiwygSettings = Drupal.settings.wysiwyg.configs.fckeditor[wysiwygFormat];
+var pluginSettings = (Drupal.settings.wysiwyg.plugins[wysiwygFormat] ? Drupal.settings.wysiwyg.plugins[wysiwygFormat] : { 'native': {}, 'drupal': {} });
+
+/**
+ * Apply format-specific settings.
+ */
+for (var setting in wysiwygSettings) {
+  if (setting == 'buttons') {
+    // Apply custom Wysiwyg toolbar for this format.
+    // FCKConfig.ToolbarSets['Wysiwyg'] = wysiwygSettings.buttons;
+
+    // Temporarily stack buttons into multiple button groups and remove
+    // separators until #277954 is solved.
+    FCKConfig.ToolbarSets['Wysiwyg'] = [];
+    for (var i = 0; i < wysiwygSettings.buttons[0].length; i++) {
+      FCKConfig.ToolbarSets['Wysiwyg'].push([wysiwygSettings.buttons[0][i]]);
+    }
+    FCKTools.AppendStyleSheet(document, '#xToolbar .TB_Start { display:none; }');
+    // Set valid height of select element in silver and office2003 skins.
+    if (FCKConfig.SkinPath.match(/\/office2003\/$/)) {
+      FCKTools.AppendStyleSheet(document, '#xToolbar .SC_FieldCaption { height: 24px; } #xToolbar .TB_End { display: none; }');
+    }
+    else if (FCKConfig.SkinPath.match(/\/silver\/$/)) {
+      FCKTools.AppendStyleSheet(document, '#xToolbar .SC_FieldCaption { height: 27px; }');
+    }
+  }
+  else {
+    FCKConfig[setting] = wysiwygSettings[setting];
+  }
+}
+
+/**
+ * Initialize this editor instance.
+ */
+Drupal.wysiwyg.editor.instance.fckeditor.init(window);
+
+/**
+ * Register native plugins for this input format.
+ *
+ * Parameters to Plugins.Add are:
+ * - Plugin name.
+ * - Languages the plugin is available in.
+ * - Location of the plugin folder; <plugin_name>/fckplugin.js is appended.
+ */
+for (var plugin in pluginSettings['native']) {
+  // Languages and path may be undefined for internal plugins.
+  FCKConfig.Plugins.Add(plugin, pluginSettings['native'][plugin].languages, pluginSettings['native'][plugin].path);
+}
+
+/**
+ * Register Drupal plugins for this input format.
+ *
+ * Parameters to addPlugin() are:
+ * - Plugin name.
+ * - Format specific plugin settings.
+ * - General plugin settings.
+ * - A reference to this window so the plugin setup can access FCKConfig.
+ */
+for (var plugin in pluginSettings.drupal) {
+  Drupal.wysiwyg.editor.instance.fckeditor.addPlugin(plugin, pluginSettings.drupal[plugin], Drupal.settings.wysiwyg.plugins.drupal[plugin], window);
+}
+

sites/all/modules/wysiwyg/editors/js/jwysiwyg.js

@@ -0,0 +1,25 @@
+(function($) {
+
+/**
+ * Attach this editor to a target element.
+ */
+Drupal.wysiwyg.editor.attach.jwysiwyg = function(context, params, settings) {
+  // Attach editor.
+  $('#' + params.field).wysiwyg();
+};
+
+/**
+ * Detach a single or all editors.
+ */
+Drupal.wysiwyg.editor.detach.jwysiwyg = function(context, params) {
+  var $field = $('#' + params.field);
+  var editor = $field.data('wysiwyg');
+  if (typeof editor != 'undefined') {
+    editor.saveContent();
+    editor.element.remove();
+  }
+  $field.removeData('wysiwyg');
+  $field.show();
+};
+
+})(jQuery);

sites/all/modules/wysiwyg/editors/js/markitup.js

@@ -0,0 +1,29 @@
+(function($) {
+
+/**
+ * Attach this editor to a target element.
+ */
+Drupal.wysiwyg.editor.attach.markitup = function(context, params, settings) {
+  $('#' + params.field, context).markItUp(settings);
+
+  // Adjust CSS for editor buttons.
+  $.each(settings.markupSet, function (button) {
+    $('.' + settings.nameSpace + ' .' + this.className + ' a')
+      .css({ backgroundImage: 'url(' + settings.root + 'sets/default/images/' + button + '.png' + ')' })
+      .parents('li').css({ backgroundImage: 'none' });
+  });
+};
+
+/**
+ * Detach a single or all editors.
+ */
+Drupal.wysiwyg.editor.detach.markitup = function(context, params) {
+  if (typeof params != 'undefined') {
+    $('#' + params.field, context).markItUpRemove();
+  }
+  else {
+    $('.markItUpEditor', context).markItUpRemove();
+  }
+};
+
+})(jQuery);

sites/all/modules/wysiwyg/editors/js/nicedit.js

@@ -0,0 +1,95 @@
+(function($) {
+
+/**
+ * Attach this editor to a target element.
+ */
+Drupal.wysiwyg.editor.attach.nicedit = function(context, params, settings) {
+  // Intercept and ignore submit handlers or they will revert changes made
+  // since the instance was removed. The handlers are anonymous and hidden out
+  // of scope in a closure so we can't unbind them. The same operations are
+  // performed when the instance is detached anyway.
+  var oldAddEvent = bkLib.addEvent;
+  bkLib.addEvent = function(obj, type, fn) {
+    if (type != 'submit') {
+      oldAddEvent(obj, type, fn);
+    }
+  }
+  // Attach editor.
+  var editor = new nicEditor(settings);
+  editor.panelInstance(params.field);
+  // The old addEvent() must be restored after creating a new instance, as
+  // plugins with dialogs use it to bind submit handlers to their forms.
+  bkLib.addEvent = oldAddEvent;
+  editor.addEvent('focus', function () {
+    Drupal.wysiwyg.activeId = params.field;
+  });
+};
+
+/**
+ * Detach a single or all editors.
+ *
+ * See Drupal.wysiwyg.editor.detach.none() for a full description of this hook.
+ */
+Drupal.wysiwyg.editor.detach.nicedit = function(context, params) {
+  if (typeof params != 'undefined') {
+    var instance = nicEditors.findEditor(params.field);
+    if (instance) {
+      instance.ne.removeInstance(params.field);
+      instance.ne.removePanel();
+    }
+  }
+  else {
+    for (var e in nicEditors.editors) {
+      // Save contents of all editors back into textareas.
+      var instances = nicEditors.editors[e].nicInstances;
+      for (var i = 0; i < instances.length; i++) {
+        instances[i].remove();
+      }
+      // Remove all editor instances.
+      nicEditors.editors[e].nicInstances = [];
+    }
+  }
+};
+
+/**
+ * Instance methods for nicEdit.
+ */
+Drupal.wysiwyg.editor.instance.nicedit = {
+  insert: function (content) {
+    var instance = nicEditors.findEditor(this.field);
+    var editingArea = instance.getElm();
+    var sel = instance.getSel();
+    // IE.
+    if (document.selection) {
+      editingArea.focus();
+      sel.createRange().text = content;
+    }
+    else {
+      // Convert selection to a range.
+      var range;
+      // W3C compatible.
+      if (sel.getRangeAt) {
+        range = sel.getRangeAt(0);
+      }
+      // Safari.
+      else {
+        range = editingArea.ownerDocument.createRange();
+        range.setStart(sel.anchorNode, sel.anchorOffset);
+        range.setEnd(sel.focusNode, userSeletion.focusOffset);
+      }
+      // The code below doesn't work in IE, but it never gets here.
+      var fragment = editingArea.ownerDocument.createDocumentFragment();
+      // Fragments don't support innerHTML.
+      var wrapper = editingArea.ownerDocument.createElement('div');
+      wrapper.innerHTML = content;
+      while (wrapper.firstChild) {
+        fragment.appendChild(wrapper.firstChild);
+      }
+      range.deleteContents();
+      // Only fragment children are inserted.
+      range.insertNode(fragment);
+    }
+  }
+};
+
+})(jQuery);

sites/all/modules/wysiwyg/editors/js/none.js

@@ -0,0 +1,71 @@
+(function($) {
+
+/**
+ * Attach this editor to a target element.
+ *
+ * @param context
+ *   A DOM element, supplied by Drupal.attachBehaviors().
+ * @param params
+ *   An object containing input format parameters. Default parameters are:
+ *   - editor: The internal editor name.
+ *   - theme: The name/key of the editor theme/profile to use.
+ *   - field: The CSS id of the target element.
+ * @param settings
+ *   An object containing editor settings for all enabled editor themes.
+ */
+Drupal.wysiwyg.editor.attach.none = function(context, params, settings) {
+  if (params.resizable) {
+    var $wrapper = $('#' + params.field).parents('.form-textarea-wrapper:first');
+    $wrapper.addClass('resizable');
+    if (Drupal.behaviors.textarea.attach) {
+      Drupal.behaviors.textarea.attach();
+    }
+  }
+};
+
+/**
+ * Detach a single or all editors.
+ *
+ * @param context
+ *   A DOM element, supplied by Drupal.attachBehaviors().
+ * @param params
+ *   (optional) An object containing input format parameters. If defined,
+ *   only the editor instance in params.field should be detached. Otherwise,
+ *   all editors should be detached and saved, so they can be submitted in
+ *   AJAX/AHAH applications.
+ */
+Drupal.wysiwyg.editor.detach.none = function(context, params) {
+  if (typeof params != 'undefined') {
+    var $wrapper = $('#' + params.field).parents('.form-textarea-wrapper:first');
+    $wrapper.removeOnce('textarea').removeClass('.resizable-textarea')
+      .find('.grippie').remove();
+  }
+};
+
+/**
+ * Instance methods for plain text areas.
+ */
+Drupal.wysiwyg.editor.instance.none = {
+  insert: function(content) {
+    var editor = document.getElementById(this.field);
+
+    // IE support.
+    if (document.selection) {
+      editor.focus();
+      var sel = document.selection.createRange();
+      sel.text = content;
+    }
+    // Mozilla/Firefox/Netscape 7+ support.
+    else if (editor.selectionStart || editor.selectionStart == '0') {
+      var startPos = editor.selectionStart;
+      var endPos = editor.selectionEnd;
+      editor.value = editor.value.substring(0, startPos) + content + editor.value.substring(endPos, editor.value.length);
+    }
+    // Fallback, just add to the end of the content.
+    else {
+      editor.value += content;
+    }
+  }
+};
+
+})(jQuery);

sites/all/modules/wysiwyg/editors/js/openwysiwyg.js

@@ -0,0 +1,68 @@
+
+// Backup $ and reset it to jQuery.
+Drupal.wysiwyg._openwysiwyg = $;
+$ = jQuery;
+
+// Wrap openWYSIWYG's methods to temporarily use its version of $.
+jQuery.each(WYSIWYG, function (key, value) {
+  if (jQuery.isFunction(value)) {
+    WYSIWYG[key] = function () {
+      var old$ = $;
+      $ = Drupal.wysiwyg._openwysiwyg;
+      var result = value.apply(this, arguments);
+      $ = old$;
+      return result;
+    };
+  }
+});
+
+// Override editor functions.
+WYSIWYG.getEditor = function (n) {
+  return Drupal.wysiwyg._openwysiwyg("wysiwyg" + n);
+};
+
+(function($) {
+
+/**
+ * Attach this editor to a target element.
+ */
+Drupal.wysiwyg.editor.attach.openwysiwyg = function(context, params, settings) {
+  // Initialize settings.
+  settings.ImagesDir = settings.path + 'images/';
+  settings.PopupsDir = settings.path + 'popups/';
+  settings.CSSFile = settings.path + 'styles/wysiwyg.css';
+  //settings.DropDowns = [];
+  var config = new WYSIWYG.Settings();
+  for (var setting in settings) {
+    config[setting] = settings[setting];
+  }
+  // Attach editor.
+  WYSIWYG.setSettings(params.field, config);
+  WYSIWYG_Core.includeCSS(WYSIWYG.config[params.field].CSSFile);
+  WYSIWYG._generate(params.field, config);
+};
+
+/**
+ * Detach a single or all editors.
+ */
+Drupal.wysiwyg.editor.detach.openwysiwyg = function(context, params) {
+  if (typeof params != 'undefined') {
+    var instance = WYSIWYG.config[params.field];
+    if (typeof instance != 'undefined') {
+      WYSIWYG.updateTextArea(params.field);
+      jQuery('#wysiwyg_div_' + params.field).remove();
+      delete instance;
+    }
+    jQuery('#' + params.field).show();
+  }
+  else {
+    jQuery.each(WYSIWYG.config, function(field) {
+      WYSIWYG.updateTextArea(field);
+      jQuery('#wysiwyg_div_' + field).remove();
+      delete this;
+      jQuery('#' + field).show();
+    });
+  }
+};
+
+})(jQuery);

sites/all/modules/wysiwyg/editors/js/tinymce-2.js

@@ -0,0 +1,213 @@
+(function($) {
+
+/**
+ * Initialize editor instances.
+ *
+ * This function needs to be called before the page is fully loaded, as
+ * calling tinyMCE.init() after the page is loaded breaks IE6.
+ *
+ * @param editorSettings
+ *   An object containing editor settings for each input format.
+ */
+Drupal.wysiwyg.editor.init.tinymce = function(settings) {
+  // If JS compression is enabled, TinyMCE is unable to autodetect its global
+  // settinge, hence we need to define them manually.
+  // @todo Move global library settings somewhere else.
+  tinyMCE.baseURL = settings.global.editorBasePath;
+  tinyMCE.srcMode = (settings.global.execMode == 'src' ? '_src' : '');
+  tinyMCE.gzipMode = (settings.global.execMode == 'gzip');
+
+  // Initialize editor configurations.
+  for (var format in settings) {
+    if (format == 'global') {
+      continue;
+    }
+    tinyMCE.init(settings[format]);
+    if (Drupal.settings.wysiwyg.plugins[format]) {
+      // Load native external plugins.
+      // Array syntax required; 'native' is a predefined token in JavaScript.
+      for (var plugin in Drupal.settings.wysiwyg.plugins[format]['native']) {
+        tinyMCE.loadPlugin(plugin, Drupal.settings.wysiwyg.plugins[format]['native'][plugin]);
+      }
+      // Load Drupal plugins.
+      for (var plugin in Drupal.settings.wysiwyg.plugins[format].drupal) {
+        Drupal.wysiwyg.editor.instance.tinymce.addPlugin(plugin, Drupal.settings.wysiwyg.plugins[format].drupal[plugin], Drupal.settings.wysiwyg.plugins.drupal[plugin]);
+      }
+    }
+  }
+};
+
+/**
+ * Attach this editor to a target element.
+ *
+ * See Drupal.wysiwyg.editor.attach.none() for a full desciption of this hook.
+ */
+Drupal.wysiwyg.editor.attach.tinymce = function(context, params, settings) {
+  // Configure editor settings for this input format.
+  for (var setting in settings) {
+    tinyMCE.settings[setting] = settings[setting];
+  }
+
+  // Remove TinyMCE's internal mceItem class, which was incorrectly added to
+  // submitted content by Wysiwyg <2.1. TinyMCE only temporarily adds the class
+  // for placeholder elements. If preemptively set, the class prevents (native)
+  // editor plugins from gaining an active state, so we have to manually remove
+  // it prior to attaching the editor. This is done on the client-side instead
+  // of the server-side, as Wysiwyg has no way to figure out where content is
+  // stored, and the class only affects editing.
+  $field = $('#' + params.field);
+  $field.val($field.val().replace(/(<.+?\s+class=['"][\w\s]*?)\bmceItem\b([\w\s]*?['"].*?>)/ig, '$1$2'));
+
+  // Attach editor.
+  tinyMCE.execCommand('mceAddControl', true, params.field);
+};
+
+/**
+ * Detach a single or all editors.
+ *
+ * See Drupal.wysiwyg.editor.detach.none() for a full desciption of this hook.
+ */
+Drupal.wysiwyg.editor.detach.tinymce = function(context, params) {
+  if (typeof params != 'undefined') {
+    tinyMCE.removeMCEControl(tinyMCE.getEditorId(params.field));
+    $('#' + params.field).removeAttr('style');
+  }
+//  else if (tinyMCE.activeEditor) {
+//    tinyMCE.triggerSave();
+//    tinyMCE.activeEditor.remove();
+//  }
+};
+
+Drupal.wysiwyg.editor.instance.tinymce = {
+  addPlugin: function(plugin, settings, pluginSettings) {
+    if (typeof Drupal.wysiwyg.plugins[plugin] != 'object') {
+      return;
+    }
+    tinyMCE.addPlugin(plugin, {
+
+      // Register an editor command for this plugin, invoked by the plugin's button.
+      execCommand: function(editor_id, element, command, user_interface, value) {
+        switch (command) {
+          case plugin:
+            if (typeof Drupal.wysiwyg.plugins[plugin].invoke == 'function') {
+              var ed = tinyMCE.getInstanceById(editor_id);
+              var data = { format: 'html', node: ed.getFocusElement(), content: ed.getFocusElement() };
+              Drupal.wysiwyg.plugins[plugin].invoke(data, pluginSettings, ed.formTargetElementId);
+              return true;
+            }
+        }
+        // Pass to next handler in chain.
+        return false;
+      },
+
+      // Register the plugin button.
+      getControlHTML: function(control_name) {
+        switch (control_name) {
+          case plugin:
+            return tinyMCE.getButtonHTML(control_name, settings.iconTitle, settings.icon, plugin);
+        }
+        return '';
+      },
+
+      // Load custom CSS for editor contents on startup.
+      initInstance: function(ed) {
+        if (settings.css) {
+          tinyMCE.importCSS(ed.getDoc(), settings.css);
+        }
+      },
+
+      cleanup: function(type, content) {
+        switch (type) {
+          case 'insert_to_editor':
+            // Attach: Replace plain text with HTML representations.
+            if (typeof Drupal.wysiwyg.plugins[plugin].attach == 'function') {
+              content = Drupal.wysiwyg.plugins[plugin].attach(content, pluginSettings, tinyMCE.selectedInstance.editorId);
+              content = Drupal.wysiwyg.editor.instance.tinymce.prepareContent(content);
+            }
+            break;
+
+          case 'get_from_editor':
+            // Detach: Replace HTML representations with plain text.
+            if (typeof Drupal.wysiwyg.plugins[plugin].detach == 'function') {
+              content = Drupal.wysiwyg.plugins[plugin].detach(content, pluginSettings, tinyMCE.selectedInstance.editorId);
+            }
+            break;
+        }
+        // Pass through to next handler in chain
+        return content;
+      },
+
+      // isNode: Return whether the plugin button should be enabled for the
+      // current selection.
+      handleNodeChange: function(editor_id, node, undo_index, undo_levels, visual_aid, any_selection) {
+        if (node === null) {
+          return;
+        }
+        if (typeof Drupal.wysiwyg.plugins[plugin].isNode == 'function') {
+          if (Drupal.wysiwyg.plugins[plugin].isNode(node)) {
+            tinyMCE.switchClass(editor_id + '_' + plugin, 'mceButtonSelected');
+            return true;
+          }
+        }
+        tinyMCE.switchClass(editor_id + '_' + plugin, 'mceButtonNormal');
+        return true;
+      },
+
+      /**
+       * Return information about the plugin as a name/value array.
+       */
+      getInfo: function() {
+        return {
+          longname: settings.title
+        };
+      }
+    });
+  },
+
+  openDialog: function(dialog, params) {
+    var editor = tinyMCE.getInstanceById(this.field);
+    tinyMCE.openWindow({
+      file: dialog.url + '/' + this.field,
+      width: dialog.width,
+      height: dialog.height,
+      inline: 1
+    }, params);
+  },
+
+  closeDialog: function(dialog) {
+    var editor = tinyMCE.getInstanceById(this.field);
+    tinyMCEPopup.close();
+  },
+
+  prepareContent: function(content) {
+    // Certain content elements need to have additional DOM properties applied
+    // to prevent this editor from highlighting an internal button in addition
+    // to the button of a Drupal plugin.
+    var specialProperties = {
+      img: { 'name': 'mce_drupal' }
+    };
+    var $content = $('<div>' + content + '</div>'); // No .outerHTML() in jQuery :(
+    jQuery.each(specialProperties, function(element, properties) {
+      $content.find(element).each(function() {
+        for (var property in properties) {
+          if (property == 'class') {
+            $(this).addClass(properties[property]);
+          }
+          else {
+            $(this).attr(property, properties[property]);
+          }
+        }
+      });
+    });
+    return $content.html();
+  },
+
+  insert: function(content) {
+    content = this.prepareContent(content);
+    var editor = tinyMCE.getInstanceById(this.field);
+    editor.execCommand('mceInsertContent', false, content);
+    editor.repaint();
+  }
+};
+
+})(jQuery);

sites/all/modules/wysiwyg/editors/js/tinymce-3.js

@@ -0,0 +1,235 @@
+(function($) {
+
+/**
+ * Initialize editor instances.
+ *
+ * @todo Is the following note still valid for 3.x?
+ * This function needs to be called before the page is fully loaded, as
+ * calling tinyMCE.init() after the page is loaded breaks IE6.
+ *
+ * @param editorSettings
+ *   An object containing editor settings for each input format.
+ */
+Drupal.wysiwyg.editor.init.tinymce = function(settings) {
+  // If JS compression is enabled, TinyMCE is unable to autodetect its global
+  // settinge, hence we need to define them manually.
+  // @todo Move global library settings somewhere else.
+  tinyMCE.baseURL = settings.global.editorBasePath;
+  tinyMCE.srcMode = (settings.global.execMode == 'src' ? '_src' : '');
+  tinyMCE.gzipMode = (settings.global.execMode == 'gzip');
+
+  // Initialize editor configurations.
+  for (var format in settings) {
+    if (format == 'global') {
+      continue;
+    };
+    tinyMCE.init(settings[format]);
+    if (Drupal.settings.wysiwyg.plugins[format]) {
+      // Load native external plugins.
+      // Array syntax required; 'native' is a predefined token in JavaScript.
+      for (var plugin in Drupal.settings.wysiwyg.plugins[format]['native']) {
+        tinymce.PluginManager.load(plugin, Drupal.settings.wysiwyg.plugins[format]['native'][plugin]);
+      }
+      // Load Drupal plugins.
+      for (var plugin in Drupal.settings.wysiwyg.plugins[format].drupal) {
+        Drupal.wysiwyg.editor.instance.tinymce.addPlugin(plugin, Drupal.settings.wysiwyg.plugins[format].drupal[plugin], Drupal.settings.wysiwyg.plugins.drupal[plugin]);
+      }
+    }
+  }
+};
+
+/**
+ * Attach this editor to a target element.
+ *
+ * See Drupal.wysiwyg.editor.attach.none() for a full desciption of this hook.
+ */
+Drupal.wysiwyg.editor.attach.tinymce = function(context, params, settings) {
+  // Configure editor settings for this input format.
+  var ed = new tinymce.Editor(params.field, settings);
+  // Reset active instance id on any event.
+  ed.onEvent.add(function(ed, e) {
+    Drupal.wysiwyg.activeId = ed.id;
+  });
+  // Make toolbar buttons wrappable (required for IE).
+  ed.onPostRender.add(function (ed) {
+    var $toolbar = $('<div class="wysiwygToolbar"></div>');
+    $('#' + ed.editorContainer + ' table.mceToolbar > tbody > tr > td').each(function () {
+      $('<div></div>').addClass(this.className).append($(this).children()).appendTo($toolbar);
+    });
+    $('#' + ed.editorContainer + ' table.mceLayout td.mceToolbar').append($toolbar);
+    $('#' + ed.editorContainer + ' table.mceToolbar').remove();
+  });
+
+  // Remove TinyMCE's internal mceItem class, which was incorrectly added to
+  // submitted content by Wysiwyg <2.1. TinyMCE only temporarily adds the class
+  // for placeholder elements. If preemptively set, the class prevents (native)
+  // editor plugins from gaining an active state, so we have to manually remove
+  // it prior to attaching the editor. This is done on the client-side instead
+  // of the server-side, as Wysiwyg has no way to figure out where content is
+  // stored, and the class only affects editing.
+  $field = $('#' + params.field);
+  $field.val($field.val().replace(/(<.+?\s+class=['"][\w\s]*?)\bmceItem\b([\w\s]*?['"].*?>)/ig, '$1$2'));
+
+  // Attach editor.
+  ed.render();
+};
+
+/**
+ * Detach a single or all editors.
+ *
+ * See Drupal.wysiwyg.editor.detach.none() for a full desciption of this hook.
+ */
+Drupal.wysiwyg.editor.detach.tinymce = function(context, params) {
+  if (typeof params != 'undefined') {
+    var instance = tinyMCE.get(params.field);
+    if (instance) {
+      instance.save();
+      instance.remove();
+    }
+  }
+  else {
+    // Save contents of all editors back into textareas.
+    tinyMCE.triggerSave();
+    // Remove all editor instances.
+    for (var instance in tinyMCE.editors) {
+      tinyMCE.editors[instance].remove();
+    }
+  }
+};
+
+Drupal.wysiwyg.editor.instance.tinymce = {
+  addPlugin: function(plugin, settings, pluginSettings) {
+    if (typeof Drupal.wysiwyg.plugins[plugin] != 'object') {
+      return;
+    }
+    tinymce.create('tinymce.plugins.' + plugin, {
+      /**
+       * Initialize the plugin, executed after the plugin has been created.
+       *
+       * @param ed
+       *   The tinymce.Editor instance the plugin is initialized in.
+       * @param url
+       *   The absolute URL of the plugin location.
+       */
+      init: function(ed, url) {
+        // Register an editor command for this plugin, invoked by the plugin's button.
+        ed.addCommand(plugin, function() {
+          if (typeof Drupal.wysiwyg.plugins[plugin].invoke == 'function') {
+            var data = { format: 'html', node: ed.selection.getNode(), content: ed.selection.getContent() };
+            // TinyMCE creates a completely new instance for fullscreen mode.
+            var instanceId = ed.id == 'mce_fullscreen' ? ed.getParam('fullscreen_editor_id') : ed.id;
+            Drupal.wysiwyg.plugins[plugin].invoke(data, pluginSettings, instanceId);
+          }
+        });
+
+        // Register the plugin button.
+        ed.addButton(plugin, {
+          title : settings.iconTitle,
+          cmd : plugin,
+          image : settings.icon
+        });
+
+        // Load custom CSS for editor contents on startup.
+        ed.onInit.add(function() {
+          if (settings.css) {
+            ed.dom.loadCSS(settings.css);
+          }
+        });
+
+        // Attach: Replace plain text with HTML representations.
+        ed.onBeforeSetContent.add(function(ed, data) {
+          if (typeof Drupal.wysiwyg.plugins[plugin].attach == 'function') {
+            data.content = Drupal.wysiwyg.plugins[plugin].attach(data.content, pluginSettings, ed.id);
+            data.content = Drupal.wysiwyg.editor.instance.tinymce.prepareContent(data.content);
+          }
+        });
+
+        // Detach: Replace HTML representations with plain text.
+        ed.onGetContent.add(function(ed, data) {
+          if (typeof Drupal.wysiwyg.plugins[plugin].detach == 'function') {
+            data.content = Drupal.wysiwyg.plugins[plugin].detach(data.content, pluginSettings, ed.id);
+          }
+        });
+
+        // isNode: Return whether the plugin button should be enabled for the
+        // current selection.
+        ed.onNodeChange.add(function(ed, command, node) {
+          if (typeof Drupal.wysiwyg.plugins[plugin].isNode == 'function') {
+            command.setActive(plugin, Drupal.wysiwyg.plugins[plugin].isNode(node));
+          }
+        });
+      },
+
+      /**
+       * Return information about the plugin as a name/value array.
+       */
+      getInfo: function() {
+        return {
+          longname: settings.title
+        };
+      }
+    });
+
+    // Register plugin.
+    tinymce.PluginManager.add(plugin, tinymce.plugins[plugin]);
+  },
+
+  openDialog: function(dialog, params) {
+    var instanceId = this.isFullscreen() ? 'mce_fullscreen' : this.field;
+    var editor = tinyMCE.get(instanceId);
+    editor.windowManager.open({
+      file: dialog.url + '/' + instanceId,
+      width: dialog.width,
+      height: dialog.height,
+      inline: 1
+    }, params);
+  },
+
+  closeDialog: function(dialog) {
+    var instanceId = this.isFullscreen() ? 'mce_fullscreen' : this.field;
+    var editor = tinyMCE.get(instanceId);
+    editor.windowManager.close(dialog);
+  },
+
+  prepareContent: function(content) {
+    // Certain content elements need to have additional DOM properties applied
+    // to prevent this editor from highlighting an internal button in addition
+    // to the button of a Drupal plugin.
+    var specialProperties = {
+      img: { 'class': 'mceItem' }
+    };
+    var $content = $('<div>' + content + '</div>'); // No .outerHTML() in jQuery :(
+    // Find all placeholder/replacement content of Drupal plugins.
+    $content.find('.drupal-content').each(function() {
+      // Recursively process DOM elements below this element to apply special
+      // properties.
+      var $drupalContent = $(this);
+      $.each(specialProperties, function(element, properties) {
+        $drupalContent.find(element).andSelf().each(function() {
+          for (var property in properties) {
+            if (property == 'class') {
+              $(this).addClass(properties[property]);
+            }
+            else {
+              $(this).attr(property, properties[property]);
+            }
+          }
+        });
+      });
+    });
+    return $content.html();
+  },
+
+  insert: function(content) {
+    content = this.prepareContent(content);
+    var instanceId = this.isFullscreen() ? 'mce_fullscreen' : this.field;
+    tinyMCE.execInstanceCommand(instanceId, 'mceInsertContent', false, content);
+  },
+
+  isFullscreen: function() {
+    // TinyMCE creates a completely new instance for fullscreen mode.
+    return tinyMCE.activeEditor.id == 'mce_fullscreen' && tinyMCE.activeEditor.getParam('fullscreen_editor_id') == this.field;
+  }
+};
+
+})(jQuery);

sites/all/modules/wysiwyg/editors/js/whizzywig-56.js

@@ -0,0 +1,133 @@
+
+var wysiwygWhizzywig = { currentField: null, fields: {} };
+var buttonPath = null;
+
+/**
+ * Override Whizzywig's document.write() function.
+ *
+ * Whizzywig uses document.write() by default, which leads to a blank page when
+ * invoked in jQuery.ready().  Luckily, Whizzywig developers implemented a
+ * shorthand w() substitute function that we can override to redirect the output
+ * into the global wysiwygWhizzywig variable.
+ *
+ * @see o()
+ */
+var w = function (string) {
+  if (string) {
+    wysiwygWhizzywig.fields[wysiwygWhizzywig.currentField] += string;
+  }
+  return wysiwygWhizzywig.fields[wysiwygWhizzywig.currentField];
+};
+
+/**
+ * Override Whizzywig's document.getElementById() function.
+ *
+ * Since we redirect the output of w() into a temporary string upon attaching
+ * an editor, we also have to override the o() shorthand substitute function
+ * for document.getElementById() to search in the document or our container.
+ * This override function also inserts the editor instance when Whizzywig
+ * tries to access its IFRAME, so it has access to the full/regular window
+ * object.
+ *
+ * @see w()
+ */
+var o = function (id) {
+  // Upon first access to "whizzy" + id, Whizzywig tries to access its IFRAME,
+  // so we need to insert the editor into the DOM.
+  if (id == 'whizzy' + wysiwygWhizzywig.currentField && wysiwygWhizzywig.fields[wysiwygWhizzywig.currentField]) {
+    jQuery('#' + wysiwygWhizzywig.currentField).after('<div id="' + wysiwygWhizzywig.currentField + '-whizzywig"></div>');
+    // Iframe's .contentWindow becomes null in Webkit if inserted via .after().
+    jQuery('#' + wysiwygWhizzywig.currentField + '-whizzywig').html(w());
+    // Prevent subsequent invocations from inserting the editor multiple times.
+    wysiwygWhizzywig.fields[wysiwygWhizzywig.currentField] = '';
+  }
+  // If id exists in the regular window.document, return it.
+  if (jQuery('#' + id).size()) {
+    return jQuery('#' + id).get(0);
+  }
+  // Otherwise return id from our container.
+  return jQuery('#' + id, w()).get(0);
+};
+
+(function($) {
+
+/**
+ * Attach this editor to a target element.
+ */
+Drupal.wysiwyg.editor.attach.whizzywig = function(context, params, settings) {
+  // Previous versions used per-button images found in this location,
+  // now it is only used for custom buttons.
+  if (settings.buttonPath) {
+    window.buttonPath = settings.buttonPath;
+  }
+  // Assign the toolbar image path used for native buttons, if available.
+  if (settings.toolbarImagePath) {
+    btn._f = settings.toolbarImagePath;
+  }
+  // Fall back to text labels for all buttons.
+  else {
+    window.buttonPath = 'textbuttons';
+  }
+  // Create Whizzywig container.
+  wysiwygWhizzywig.currentField = params.field;
+  wysiwygWhizzywig.fields[wysiwygWhizzywig.currentField] = '';
+  // Whizzywig needs to have the width set 'inline'.
+  $field = $('#' + params.field);
+  var originalValues = Drupal.wysiwyg.instances[params.field];
+  originalValues.originalStyle = $field.attr('style');
+  $field.css('width', $field.width() + 'px');
+
+  // Attach editor.
+  makeWhizzyWig(params.field, (settings.buttons ? settings.buttons : 'all'));
+  // Whizzywig fails to detect and set initial textarea contents.
+  var instance = $('#whizzy' + params.field).get(0);
+  if (instance) {
+    instance.contentWindow.document.body.innerHTML = tidyD($field.val());
+  }
+};
+
+/**
+ * Detach a single or all editors.
+ */
+Drupal.wysiwyg.editor.detach.whizzywig = function(context, params) {
+  var detach = function (index) {
+    var id = whizzies[index];
+    var instance = $('#whizzy' + id).get(0);
+    if (!instance) {
+      return;
+    }
+    var editingArea = instance.contentWindow.document;
+    var $field = $('#' + id);
+    // Whizzywig shows the original textarea in source mode.
+    if ($field.css('display') == 'block') {
+      editingArea.body.innerHTML = $field.val();
+    }
+
+    // Save contents of editor back into textarea.
+    $field.val(tidyH(editingArea));
+    // Remove editor instance.
+    $('#' + id + '-whizzywig').remove();
+    whizzies.splice(index, 1);
+
+    // Restore original textarea styling.
+    var originalValues = Drupal.wysiwyg.instances[id];
+    $field.removeAttr('style');
+    $field.attr('style', originalValues.originalStyle);
+  };
+
+  if (typeof params != 'undefined') {
+    for (var i = 0; i < whizzies.length; i++) {
+      if (whizzies[i] == params.field) {
+        detach(i);
+        break;
+      }
+    }
+  }
+  else {
+    while (whizzies.length > 0) {
+      detach(0);
+    }
+  }
+};
+
+})(jQuery);

sites/all/modules/wysiwyg/editors/js/whizzywig-60.js

@@ -0,0 +1,85 @@
+
+var buttonPath = null;
+
+(function($) {
+
+/**
+ * Attach this editor to a target element.
+ */
+Drupal.wysiwyg.editor.attach.whizzywig = function(context, params, settings) {
+  // Previous versions used per-button images found in this location,
+  // now it is only used for custom buttons.
+  if (settings.buttonPath) {
+    window.buttonPath = settings.buttonPath;
+  }
+  // Assign the toolbar image path used for native buttons, if available.
+  if (settings.toolbarImagePath) {
+    btn._f = settings.toolbarImagePath;
+  }
+  // Fall back to text labels for all buttons.
+  else {
+    window.buttonPath = 'textbuttons';
+  }
+  // Whizzywig needs to have the width set 'inline'.
+  $field = $('#' + params.field);
+  var originalValues = Drupal.wysiwyg.instances[params.field];
+  originalValues.originalStyle = $field.attr('style');
+  $field.css('width', $field.width() + 'px');
+
+  // Attach editor.
+  makeWhizzyWig(params.field, (settings.buttons ? settings.buttons : 'all'));
+  // Whizzywig fails to detect and set initial textarea contents.
+  var instance = $('#whizzy' + params.field).get(0);
+  if (instance) {
+    instance.contentWindow.document.body.innerHTML = tidyD($field.val());
+  }
+};
+
+/**
+ * Detach a single or all editors.
+ */
+Drupal.wysiwyg.editor.detach.whizzywig = function(context, params) {
+  var detach = function (index) {
+    var id = whizzies[index];
+    var instance = $('#whizzy' + id).get(0);
+    if (!instance) {
+      return;
+    }
+    var editingArea = instance.contentWindow.document;
+    var $field = $('#' + id);
+    // Whizzywig shows the original textarea in source mode.
+    if ($field.css('display') == 'block') {
+      editingArea.body.innerHTML = $field.val();
+    }
+
+    // Save contents of editor back into textarea.
+    $field.val(tidyH(editingArea));
+    // Move original textarea back to its previous location.
+    $container = $('#CONTAINER' + id);
+    $field.insertBefore($container);
+    // Remove editor instance.
+    $container.remove();
+    whizzies.splice(index, 1);
+
+    // Restore original textarea styling.
+    var originalValues = Drupal.wysiwyg.instances[id];
+    $field.removeAttr('style');
+    $field.attr('style', originalValues.originalStyle);
+  }
+
+  if (typeof params != 'undefined') {
+    for (var i = 0; i < whizzies.length; i++) {
+      if (whizzies[i] == params.field) {
+        detach(i);
+        break;
+      }
+    }
+  }
+  else {
+    while (whizzies.length > 0) {
+      detach(0);
+    }
+  }
+};
+
+})(jQuery);

sites/all/modules/wysiwyg/editors/js/whizzywig.js

@@ -0,0 +1,126 @@
+
+var wysiwygWhizzywig = { currentField: null, fields: {} };
+var buttonPath = null;
+
+/**
+ * Override Whizzywig's document.write() function.
+ *
+ * Whizzywig uses document.write() by default, which leads to a blank page when
+ * invoked in jQuery.ready().  Luckily, Whizzywig developers implemented a
+ * shorthand w() substitute function that we can override to redirect the output
+ * into the global wysiwygWhizzywig variable.
+ *
+ * @see o()
+ */
+var w = function (string) {
+  if (string) {
+    wysiwygWhizzywig.fields[wysiwygWhizzywig.currentField] += string;
+  }
+  return wysiwygWhizzywig.fields[wysiwygWhizzywig.currentField];
+};
+
+/**
+ * Override Whizzywig's document.getElementById() function.
+ *
+ * Since we redirect the output of w() into a temporary string upon attaching
+ * an editor, we also have to override the o() shorthand substitute function
+ * for document.getElementById() to search in the document or our container.
+ * This override function also inserts the editor instance when Whizzywig
+ * tries to access its IFRAME, so it has access to the full/regular window
+ * object.
+ *
+ * @see w()
+ */
+var o = function (id) {
+  // Upon first access to "whizzy" + id, Whizzywig tries to access its IFRAME,
+  // so we need to insert the editor into the DOM.
+  if (id == 'whizzy' + wysiwygWhizzywig.currentField && wysiwygWhizzywig.fields[wysiwygWhizzywig.currentField]) {
+    jQuery('#' + wysiwygWhizzywig.currentField).after('<div id="' + wysiwygWhizzywig.currentField + '-whizzywig"></div>');
+    // Iframe's .contentWindow becomes null in Webkit if inserted via .after().
+    jQuery('#' + wysiwygWhizzywig.currentField + '-whizzywig').html(w());
+    // Prevent subsequent invocations from inserting the editor multiple times.
+    wysiwygWhizzywig.fields[wysiwygWhizzywig.currentField] = '';
+  }
+  // If id exists in the regular window.document, return it.
+  if (jQuery('#' + id).size()) {
+    return jQuery('#' + id).get(0);
+  }
+  // Otherwise return id from our container.
+  return jQuery('#' + id, w()).get(0);
+};
+
+(function($) {
+
+/**
+ * Attach this editor to a target element.
+ */
+Drupal.wysiwyg.editor.attach.whizzywig = function(context, params, settings) {
+  // Assign button images path, if available.
+  if (settings.buttonPath) {
+    window.buttonPath = settings.buttonPath;
+  }
+  // Create Whizzywig container.
+  wysiwygWhizzywig.currentField = params.field;
+  wysiwygWhizzywig.fields[wysiwygWhizzywig.currentField] = '';
+  // Whizzywig needs to have the width set 'inline'.
+  $field = $('#' + params.field);
+  var originalValues = Drupal.wysiwyg.instances[params.field];
+  originalValues.originalStyle = $field.attr('style');
+  $field.css('width', $field.width() + 'px');
+
+  // Attach editor.
+  makeWhizzyWig(params.field, (settings.buttons ? settings.buttons : 'all'));
+  // Whizzywig fails to detect and set initial textarea contents.
+  var instance = $('#whizzy' + params.field).get(0);
+  if (instance) {
+    instance.contentWindow.document.body.innerHTML = tidyD($field.val());
+  }
+};
+
+/**
+ * Detach a single or all editors.
+ */
+Drupal.wysiwyg.editor.detach.whizzywig = function(context, params) {
+  var detach = function (index) {
+    var id = whizzies[index];
+    var instance = $('#whizzy' + id).get(0);
+    if (!instance) {
+      return;
+    }
+    var body = instance.contentWindow.document.body;
+    var $field = $('#' + id);
+    // Whizzywig shows the original textarea in source mode.
+    if ($field.css('display') == 'block') {
+      body.innerHTML = $field.val();
+    }
+    body.innerHTML = tidyH(body.innerHTML);
+
+    // Save contents of editor back into textarea.
+    $field.val(window.get_xhtml ? get_xhtml(body) : body.innerHTML);
+    $field.val($field.val().replace(location.href + '#', '#'));
+    // Remove editor instance.
+    $('#' + id + '-whizzywig').remove();
+    whizzies.splice(index, 1);
+
+    // Restore original textarea styling.
+    var originalValues = Drupal.wysiwyg.instances[id];
+    $field.removeAttr('style');
+    $field.attr('style', originalValues.originalStyle);
+  };
+
+  if (typeof params != 'undefined') {
+    for (var i = 0; i < whizzies.length; i++) {
+      if (whizzies[i] == params.field) {
+        detach(i);
+        break;
+      }
+    }
+  }
+  else {
+    while (whizzies.length > 0) {
+      detach(0);
+    }
+  }
+};
+
+})(jQuery);

sites/all/modules/wysiwyg/editors/js/wymeditor.js

@@ -0,0 +1,56 @@
+(function($) {
+
+/**
+ * Attach this editor to a target element.
+ */
+Drupal.wysiwyg.editor.attach.wymeditor = function (context, params, settings) {
+  // Prepend basePath to wymPath.
+  settings.wymPath = settings.basePath + settings.wymPath;
+  // Update activeId on focus.
+  settings.postInit = function (instance) {
+    $(instance._doc).focus(function () {
+      Drupal.wysiwyg.activeId = params.field;
+    });
+  };
+  // Attach editor.
+  $('#' + params.field).wymeditor(settings);
+};
+
+/**
+ * Detach a single or all editors.
+ */
+Drupal.wysiwyg.editor.detach.wymeditor = function (context, params) {
+  if (typeof params != 'undefined') {
+    var $field = $('#' + params.field);
+    var index = $field.data(WYMeditor.WYM_INDEX);
+    if (typeof index != 'undefined') {
+      var instance = WYMeditor.INSTANCES[index];
+      instance.update();
+      $(instance._box).remove();
+      $(instance._element).show();
+      delete instance;
+    }
+    $field.show();
+  }
+  else {
+    jQuery.each(WYMeditor.INSTANCES, function () {
+      this.update();
+      $(this._box).remove();
+      $(this._element).show();
+      delete this;
+    });
+  }
+};
+
+Drupal.wysiwyg.editor.instance.wymeditor = {
+  insert: function (content) {
+    var $field = $('#' + this.field);
+    var index = $field.data(WYMeditor.WYM_INDEX);
+    if (typeof index != 'undefined') {
+      var instance = WYMeditor.INSTANCES[index];
+      instance.insert(content);
+    }
+  }
+};
+
+})(jQuery);

sites/all/modules/wysiwyg/editors/js/yui.js

@@ -0,0 +1,35 @@
+(function($) {
+
+/**
+ * Attach this editor to a target element.
+ */
+Drupal.wysiwyg.editor.attach.yui = function(context, params, settings) {
+  // Apply theme.
+  $('#' + params.field).parent().addClass('yui-skin-' + settings.theme);
+  // Attach editor.
+  var editor = new YAHOO.widget.Editor(params.field, settings);
+  editor.render();
+};
+
+/**
+ * Detach a single or all editors.
+ *
+ * See Drupal.wysiwyg.editor.detach.none() for a full desciption of this hook.
+ */
+Drupal.wysiwyg.editor.detach.yui = function(context, params) {
+  if (typeof params != 'undefined') {
+    var instance = YAHOO.widget.EditorInfo.getEditorById(params.field);
+    if (instance) {
+      instance.destroy();
+    }
+  }
+  else {
+    for (var e in YAHOO.widget.EditorInfo._instances) {
+      // Save contents of all editors back into textareas.
+      var instance = YAHOO.widget.EditorInfo._instances[e];
+      instance.destroy();
+    }
+  }
+};
+
+})(jQuery);