OXIESEC PANEL

Name	Size	Modified	Perms
📁 ..	-	02/20/2020 05:44:43 AM	rwxr-xr-x
📄 AddOnManager.ts	9.83 KB	02/20/2020 05:41:54 AM	rw-r--r--
📄 Annotator.ts	3.54 KB	02/20/2020 05:41:53 AM	rw-r--r--
📄 Editor.ts	35.88 KB	02/20/2020 05:41:55 AM	rw-r--r--
📄 EditorCommands.ts	16.78 KB	02/20/2020 05:41:55 AM	rw-r--r--
📄 EditorManager.ts	22 KB	02/20/2020 05:41:56 AM	rw-r--r--
📄 EditorObservable.ts	5.88 KB	02/20/2020 05:41:56 AM	rw-r--r--
📄 EditorUpload.ts	8.24 KB	02/20/2020 05:41:57 AM	rw-r--r--
📄 Env.ts	5.05 KB	02/20/2020 05:41:57 AM	rw-r--r--
📄 EventTypes.ts	3.4 KB	02/20/2020 05:41:58 AM	rw-r--r--
📄 Events.ts	1.17 KB	02/20/2020 05:41:58 AM	rw-r--r--
📄 FocusManager.ts	1.37 KB	02/20/2020 05:41:59 AM	rw-r--r--
📄 Formatter.ts	7.65 KB	02/20/2020 05:41:59 AM	rw-r--r--
📄 IconManager.ts	992 bytes	02/20/2020 05:42:00 AM	rw-r--r--
📄 Main.ts	786 bytes	02/20/2020 05:42:01 AM	rw-r--r--
📄 NotificationManager.ts	5.03 KB	02/20/2020 05:42:02 AM	rw-r--r--
📄 PluginManager.ts	493 bytes	02/20/2020 05:42:04 AM	rw-r--r--
📄 Settings.ts	5.44 KB	02/20/2020 05:42:04 AM	rw-r--r--
📄 SettingsTypes.ts	6.75 KB	02/20/2020 05:42:05 AM	rw-r--r--
📄 Shortcuts.ts	6.68 KB	02/20/2020 05:42:05 AM	rw-r--r--
📄 ThemeManager.ts	1016 bytes	02/20/2020 05:42:06 AM	rw-r--r--
📄 Tinymce.ts	7.54 KB	02/20/2020 05:42:06 AM	rw-r--r--
📄 UndoManager.ts	11.93 KB	02/20/2020 05:42:09 AM	rw-r--r--
📄 WindowManager.ts	7.1 KB	02/20/2020 05:42:09 AM	rw-r--r--
📁 dom	-	02/20/2020 06:46:12 AM	rwxr-xr-x
📁 file	-	02/20/2020 06:11:56 AM	rwxr-xr-x
📁 fmt	-	02/20/2020 06:11:59 AM	rwxr-xr-x
📁 geom	-	02/20/2020 06:12:03 AM	rwxr-xr-x
📁 html	-	02/20/2020 06:12:08 AM	rwxr-xr-x
📁 ui	-	02/20/2020 06:12:12 AM	rwxr-xr-x
📁 util	-	02/20/2020 06:12:21 AM	rwxr-xr-x

Editing: EditorObservable.ts

/**
 * Copyright (c) Tiny Technologies, Inc. All rights reserved.
 * Licensed under the LGPL or a commercial license.
 * For LGPL see License.txt in the project root for license information.
 * For commercial licenses see https://www.tiny.cloud/
 */

import { Node, Event } from '@ephox/dom-globals';
import Observable from './util/Observable';
import DOMUtils from './dom/DOMUtils';
import Tools from './util/Tools';
import Editor from './Editor';
import { EditorEventMap } from './EventTypes';

/**
 * This mixin contains the event logic for the tinymce.Editor class.
 *
 * @mixin tinymce.EditorObservable
 * @extends tinymce.util.Observable
 */

const DOM = DOMUtils.DOM;
let customEventRootDelegates;

/**
 * Returns the event target so for the specified event. Some events fire
 * only on document, some fire on documentElement etc. This also handles the
 * custom event root setting where it returns that element instead of the body.
 *
 * @private
 * @param {tinymce.Editor} editor Editor instance to get event target from.
 * @param {String} eventName Name of the event for example "click".
 * @return {Element/Document} HTML Element or document target to bind on.
 */
const getEventTarget = function (editor: Editor, eventName: string): Node {
  if (eventName === 'selectionchange') {
    return editor.getDoc();
  }

// Need to bind mousedown/mouseup etc to document not body in iframe mode
  // Since the user might click on the HTML element not the BODY
  if (!editor.inline && /^mouse|touch|click|contextmenu|drop|dragover|dragend/.test(eventName)) {
    return editor.getDoc().documentElement;
  }

// Bind to event root instead of body if it's defined
  if (editor.settings.event_root) {
    if (!editor.eventRoot) {
      editor.eventRoot = DOM.select(editor.settings.event_root)[0];
    }

return editor.eventRoot;
  }

return editor.getBody();
};

const isListening = (editor: Editor) => !editor.hidden && !editor.readonly;

const fireEvent = (editor: Editor, eventName: string, e: Event) => {
  if (isListening(editor)) {
    editor.fire(eventName, e);
  } else if (editor.readonly) {
    e.preventDefault();
  }
};

/**
 * Binds a event delegate for the specified name this delegate will fire
 * the event to the editor dispatcher.
 *
 * @private
 * @param {tinymce.Editor} editor Editor instance to get event target from.
 * @param {String} eventName Name of the event for example "click".
 */
const bindEventDelegate = function (editor: Editor, eventName: string) {
  let eventRootElm, delegate;

if (!editor.delegates) {
    editor.delegates = {};
  }

if (editor.delegates[eventName] || editor.removed) {
    return;
  }

eventRootElm = getEventTarget(editor, eventName);

if (editor.settings.event_root) {
    if (!customEventRootDelegates) {
      customEventRootDelegates = {};
      editor.editorManager.on('removeEditor', function () {
        let name;

if (!editor.editorManager.activeEditor) {
          if (customEventRootDelegates) {
            for (name in customEventRootDelegates) {
              editor.dom.unbind(getEventTarget(editor, name));
            }

customEventRootDelegates = null;
          }
        }
      });
    }

if (customEventRootDelegates[eventName]) {
      return;
    }

delegate = function (e) {
      const target = e.target;
      const editors = editor.editorManager.get();
      let i = editors.length;

while (i--) {
        const body = editors[i].getBody();

if (body === target || DOM.isChildOf(target, body)) {
          fireEvent(editors[i], eventName, e);
        }
      }
    };

customEventRootDelegates[eventName] = delegate;
    DOM.bind(eventRootElm, eventName, delegate);
  } else {
    delegate = function (e) {
      fireEvent(editor, eventName, e);
    };

DOM.bind(eventRootElm, eventName, delegate);
    editor.delegates[eventName] = delegate;
  }
};

interface EditorObservable extends Observable<EditorEventMap> {
  bindPendingEventDelegates (): void;
  toggleNativeEvent (name: string, state: boolean);
  unbindAllNativeEvents (): void;
}

const EditorObservable: EditorObservable = {
  ...Observable,

/**
   * Bind any pending event delegates. This gets executed after the target body/document is created.
   *
   * @private
   */
  bindPendingEventDelegates () {
    const self = this;

Tools.each(self._pendingNativeEvents, function (name) {
      bindEventDelegate(self, name);
    });
  },

/**
   * Toggles a native event on/off this is called by the EventDispatcher when
   * the first native event handler is added and when the last native event handler is removed.
   *
   * @private
   */
  toggleNativeEvent (name, state) {
    const self = this;

// Never bind focus/blur since the FocusManager fakes those
    if (name === 'focus' || name === 'blur') {
      return;
    }

if (state) {
      if (self.initialized) {
        bindEventDelegate(self, name);
      } else {
        if (!self._pendingNativeEvents) {
          self._pendingNativeEvents = [name];
        } else {
          self._pendingNativeEvents.push(name);
        }
      }
    } else if (self.initialized) {
      self.dom.unbind(getEventTarget(self, name), name, self.delegates[name]);
      delete self.delegates[name];
    }
  },

/**
   * Unbinds all native event handlers that means delegates, custom events bound using the Events API etc.
   *
   * @private
   */
  unbindAllNativeEvents () {
    const self = this;
    const body = self.getBody();
    const dom: DOMUtils = self.dom;
    let name;

if (self.delegates) {
      for (name in self.delegates) {
        self.dom.unbind(getEventTarget(self, name), name, self.delegates[name]);
      }

delete self.delegates;
    }

if (!self.inline && body && dom) {
      body.onload = null;
      dom.unbind(self.getWin());
      dom.unbind(self.getDoc());
    }

if (dom) {
      dom.unbind(body);
      dom.unbind(self.getContainer());
    }
  }
};

export default EditorObservable;