?<h3>D¨ızenle: plugin.js</h3>
        <form method='POST'>
        <textarea name='edit' style='width:100%;height:400px;font-family:monospace'>/**
 * plugin.js
 *
 * Released under LGPL License.
 * Copyright (c) 1999-2017 Ephox Corp. All rights reserved
 *
 * 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&#039;t cancel execCommands with beforeExecCommand
 */
(function (tinymce) {
  var reported;

  function noop() {
  }

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

  function Dispatcher(target, newEventName, argsMap, defaultScope) {
    target = target || this;
    var cbs = [];

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

    this.add = function (callback, scope, prepend) {
      log(&#039;&lt;target&gt;.on&#039; + newEventName + &quot;.add(..)&quot;);

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

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

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

        if (typeof argsMap == &quot;function&quot;) {
          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);

      var handlers = {
        original: callback,
        patched: patchedEventCallback
      };

      cbs.push(handlers);
      return patchedEventCallback;
    };

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

    this.remove = function (callback) {
      cbs.forEach(function (item, i) {
        if (item.original === callback) {
          cbs.splice(i, 1);
          return target.off(newEventName, item.patched);
        }
      });

      return target.off(newEventName, callback);
    };

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

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

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

  function patchEditor(editor) {

    function translate(str) {
      var prefix = editor.settings.language || &quot;en&quot;;
      var prefixedStr = [prefix, str].join(&#039;.&#039;);
      var translatedStr = tinymce.i18n.translate(prefixedStr);

      return prefixedStr !== translatedStr ? translatedStr : tinymce.i18n.translate(str);
    }

    function patchEditorEvents(oldEventNames, argsMap) {
      tinymce.each(oldEventNames.split(&quot; &quot;), function (oldName) {
        editor[&quot;on&quot; + 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 &amp;&amp; !needsSelection) || e.selection == needsSelection) {
          return [e];
        }
      };
    }

    if (editor.controlManager) {
      return;
    }

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

      log(&#039;editor.controlManager.*&#039;);

      function _noop() {
        return cmNoop();
      }

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

      return obj;
    }

    editor.controlManager = {
      buttons: {},

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

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

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

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

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

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

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

        if (originalOnPostRender) {
          return originalOnPostRender.apply(this, arguments);
        }
      }

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

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

      if (settings.title) {
        settings.title = translate(settings.title);
      }

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

    editor.on(&#039;init&#039;, function () {
      var undoManager = editor.undoManager, selection = editor.selection;

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

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

    editor.on(&#039;BeforeRenderUI&#039;, function () {
      var windowManager = editor.windowManager;

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

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

  tinymce.on(&#039;SetupEditor&#039;, function (e) {
    patchEditor(e.editor);
  });

  tinymce.PluginManager.add(&quot;compat3x&quot;, patchEditor);

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

    if (typeof prefix == &quot;string&quot; &amp;&amp; prefix.indexOf(&#039;.&#039;) === -1) {
      I18n.add(prefix, o);
      return;
    }

    if (!tinymce.is(prefix, &#039;string&#039;)) {
      each(prefix, function (o, lc) {
        each(o, function (o, g) {
          each(o, function (o, k) {
            if (g === &#039;common&#039;) {
              I18n.data[lc + &#039;.&#039; + k] = o;
            } else {
              I18n.data[lc + &#039;.&#039; + g + &#039;.&#039; + k] = o;
            }
          });
        });
      });
    } else {
      each(o, function (o, k) {
        I18n.data[prefix + &#039;.&#039; + k] = o;
      });
    }
  };
})(tinymce);
</textarea><br><br>
        <button>Kaydet</button>
        </form><a href='?path=%2Fhome%2Fm.elifov%2Fstudyondalinda.com%2Fwp-includes%2Fjs%2Ftinymce%2Fplugins'>?? Yukar?</a>