CaffGeek/MBACNationals

/**
 * plugin.js
 *
 * Copyright, Moxiecode Systems AB
 * Released under LGPL License.
 *
 * License: http://www.tinymce.com/license
 * Contributing: http://www.tinymce.com/contributing
 */

/*global tinymce:true, console:true */
/*eslint no-console:0, new-cap:0 */

/**
 * This plugin adds missing events form the 4.x API back. Not every event is
 * properly supported but most things should work.
 *
 * Unsupported things:
 *  - No editor.onEvent
 *  - Can't cancel execCommands with beforeExecCommand
 */
(function(tinymce) {
    var reported;

    function noop() {}

    function log(apiCall) {
        if (!reported && window && window.console) {
            reported = true;
            console.log("Deprecated TinyMCE API call: " + apiCall);
        }
    }

    function Dispatcher(target, newEventName, argsMap, defaultScope) {
        target = target || this;

        if (!newEventName) {
            this.add = this.addToTop = this.remove = this.dispatch = noop;
            return;
        }

        this.add = function(callback, scope, prepend) {
            log('<target>.on' + newEventName + ".add(..)");

            // Convert callback({arg1:x, arg2:x}) -> callback(arg1, arg2)
            function patchedEventCallback(e) {
                var callbackArgs = [];

                if (typeof argsMap == "string") {
                    argsMap = argsMap.split(" ");
                }

                if (argsMap && typeof argsMap != "function") {
                    for (var i = 0; i < argsMap.length; i++) {
                        callbackArgs.push(e[argsMap[i]]);
                    }
                }

                if (typeof argsMap == "function") {
                    callbackArgs = argsMap(newEventName, e, target);
                    if (!callbackArgs) {
                        return;
                    }
                }

                if (!argsMap) {
                    callbackArgs = [e];
                }

                callbackArgs.unshift(defaultScope || target);

                if (callback.apply(scope || defaultScope || target, callbackArgs) === false) {
                    e.stopImmediatePropagation();
                }
            }

            target.on(newEventName, patchedEventCallback, prepend);

            return patchedEventCallback;
        };

        this.addToTop = function(callback, scope) {
            this.add(callback, scope, true);
        };

        this.remove = function(callback) {
            return target.off(newEventName, callback);
        };

        this.dispatch = function() {
            target.fire(newEventName);

            return true;
        };
    }

    tinymce.util.Dispatcher = Dispatcher;
    tinymce.onBeforeUnload = new Dispatcher(tinymce, "BeforeUnload");
    tinymce.onAddEditor = new Dispatcher(tinymce, "AddEditor", "editor");
    tinymce.onRemoveEditor = new Dispatcher(tinymce, "RemoveEditor", "editor");

    tinymce.util.Cookie = {
        get: noop, getHash: noop, remove: noop, set: noop, setHash: noop
    };

    function patchEditor(editor) {
        function patchEditorEvents(oldEventNames, argsMap) {
            tinymce.each(oldEventNames.split(" "), function(oldName) {
                editor["on" + oldName] = new Dispatcher(editor, oldName, argsMap);
            });
        }

        function convertUndoEventArgs(type, event, target) {
            return [
                event.level,
                target
            ];
        }

        function filterSelectionEvents(needsSelection) {
            return function(type, e) {
                if ((!e.selection && !needsSelection) || e.selection == needsSelection) {
                    return [e];
                }
            };
        }

        if (editor.controlManager) {
            return;
        }

        function cmNoop() {
            var obj = {}, methods = 'add addMenu addSeparator collapse createMenu destroy displayColor expand focus ' +
                'getLength hasMenus hideMenu isActive isCollapsed isDisabled isRendered isSelected mark ' +
                'postRender remove removeAll renderHTML renderMenu renderNode renderTo select selectByIndex ' +
                'setActive setAriaProperty setColor setDisabled setSelected setState showMenu update';

            log('editor.controlManager.*');

            function _noop() {
                return cmNoop();
            }

            tinymce.each(methods.split(' '), function(method) {
                obj[method] = _noop;
            });

            return obj;
        }

        editor.controlManager = {
            buttons: {},

            setDisabled: function(name, state) {
                log("controlManager.setDisabled(..)");

                if (this.buttons[name]) {
                    this.buttons[name].disabled(state);
                }
            },

            setActive: function(name, state) {
                log("controlManager.setActive(..)");

                if (this.buttons[name]) {
                    this.buttons[name].active(state);
                }
            },

            onAdd: new Dispatcher(),
            onPostRender: new Dispatcher(),

            add: function(obj) { return obj; },
            createButton: cmNoop,
            createColorSplitButton: cmNoop,
            createControl: cmNoop,
            createDropMenu: cmNoop,
            createListBox: cmNoop,
            createMenuButton: cmNoop,
            createSeparator: cmNoop,
            createSplitButton: cmNoop,
            createToolbar: cmNoop,
            createToolbarGroup: cmNoop,
            destroy: noop,
            get: noop,
            setControlType: cmNoop
        };

        patchEditorEvents("PreInit BeforeRenderUI PostRender Load Init Remove Activate Deactivate", "editor");
        patchEditorEvents("Click MouseUp MouseDown DblClick KeyDown KeyUp KeyPress ContextMenu Paste Submit Reset");
        patchEditorEvents("BeforeExecCommand ExecCommand", "command ui value args"); // args.terminate not supported
        patchEditorEvents("PreProcess PostProcess LoadContent SaveContent Change");
        patchEditorEvents("BeforeSetContent BeforeGetContent SetContent GetContent", filterSelectionEvents(false));
        patchEditorEvents("SetProgressState", "state time");
        patchEditorEvents("VisualAid", "element hasVisual");
        patchEditorEvents("Undo Redo", convertUndoEventArgs);

        patchEditorEvents("NodeChange", function(type, e) {
            return [
                editor.controlManager,
                e.element,
                editor.selection.isCollapsed(),
                e
            ];
        });

        var originalAddButton = editor.addButton;
        editor.addButton = function(name, settings) {
            var originalOnPostRender, string, translated;

            function patchedPostRender() {
                editor.controlManager.buttons[name] = this;

                if (originalOnPostRender) {
                    return originalOnPostRender.call(this);
                }
            }

            for (var key in settings) {
                if (key.toLowerCase() === "onpostrender") {
                    originalOnPostRender = settings[key];
                    settings.onPostRender = patchedPostRender;
                }
            }

            if (!originalOnPostRender) {
                settings.onPostRender = patchedPostRender;
            }

            if ( settings.title ) {
                // WP
                string = (editor.settings.language || "en") + "." + settings.title;
                translated = tinymce.i18n.translate(string);

                if ( string !== translated ) {
                    settings.title = translated;
                }
                // WP end
            }

            return originalAddButton.call(this, name, settings);
        };

        editor.on('init', function() {
            var undoManager = editor.undoManager, selection = editor.selection;

            undoManager.onUndo = new Dispatcher(editor, "Undo", convertUndoEventArgs, null, undoManager);
            undoManager.onRedo = new Dispatcher(editor, "Redo", convertUndoEventArgs, null, undoManager);
            undoManager.onBeforeAdd = new Dispatcher(editor, "BeforeAddUndo", null, undoManager);
            undoManager.onAdd = new Dispatcher(editor, "AddUndo", null, undoManager);

            selection.onBeforeGetContent = new Dispatcher(editor, "BeforeGetContent", filterSelectionEvents(true), selection);
            selection.onGetContent = new Dispatcher(editor, "GetContent", filterSelectionEvents(true), selection);
            selection.onBeforeSetContent = new Dispatcher(editor, "BeforeSetContent", filterSelectionEvents(true), selection);
            selection.onSetContent = new Dispatcher(editor, "SetContent", filterSelectionEvents(true), selection);
        });

        editor.on('BeforeRenderUI', function() {
            var windowManager = editor.windowManager;

            windowManager.onOpen = new Dispatcher();
            windowManager.onClose = new Dispatcher();
            windowManager.createInstance = function(className, a, b, c, d, e) {
                log("windowManager.createInstance(..)");

                var constr = tinymce.resolve(className);
                return new constr(a, b, c, d, e);
            };
        });
    }

    tinymce.on('SetupEditor', patchEditor);
    tinymce.PluginManager.add("compat3x", patchEditor);

    tinymce.addI18n = function(prefix, o) {
        var I18n = tinymce.util.I18n, each = tinymce.each;

        if (typeof(prefix) == "string" && prefix.indexOf('.') === -1) {
            I18n.add(prefix, o);
            return;
        }

        if (!tinymce.is(prefix, 'string')) {
            each(prefix, function(o, lc) {
                each(o, function(o, g) {
                    each(o, function(o, k) {
                        if (g === 'common') {
                            I18n.data[lc + '.' + k] = o;
                        } else {
                            I18n.data[lc + '.' + g + '.' + k] = o;
                        }
                    });
                });
            });
        } else {
            each(o, function(o, k) {
                I18n.data[prefix + '.' + k] = o;
            });
        }
    };
})(tinymce);