mirror of
https://github.com/ONLYOFFICE/onlyoffice.github.io.git
synced 2026-02-10 18:05:06 +08:00
795 lines
18 KiB
JavaScript
795 lines
18 KiB
JavaScript
/**
|
|
*
|
|
* (c) Copyright Ascensio System SIA 2021
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*
|
|
*/
|
|
|
|
(function(window, undefined){
|
|
|
|
window.Asc = window.Asc || {};
|
|
window.Asc.plugin = {};
|
|
|
|
// ie channel
|
|
window.Asc.plugin.ie_channel = null;
|
|
window.Asc.plugin.ie_channel_check = function(e) {
|
|
var uagent = navigator.userAgent.toLowerCase();
|
|
if (uagent.indexOf("msie") > -1 || uagent.indexOf("trident") > -1)
|
|
{
|
|
if (e.ports && e.ports[0])
|
|
this.ie_channel = e.ports[0];
|
|
}
|
|
};
|
|
|
|
function _sendMessageToParent(data) {
|
|
if (window.Asc.plugin.ie_channel)
|
|
window.Asc.plugin.ie_channel.postMessage(data);
|
|
else
|
|
window.parent.postMessage(data, "*");
|
|
}
|
|
|
|
window.Asc.plugin.tr_init = false;
|
|
window.Asc.plugin.tr = function(val) { return val; }
|
|
|
|
window.Asc.scope = {};
|
|
window.Asc.scope.prototype = {
|
|
clear : function() {
|
|
for (var i in window.Asc.scope)
|
|
delete window.Asc.scope[i];
|
|
}
|
|
};
|
|
|
|
function extend(obj, plugin) {
|
|
if (!obj || !("object" == typeof(obj) || "array" == typeof(obj)))
|
|
return obj;
|
|
|
|
var dst = (plugin === undefined) ? {} : plugin;
|
|
for (var prop in obj) {
|
|
if (obj.hasOwnProperty(prop)) {
|
|
dst[prop] = (obj[prop] && "object" === typeof obj[prop]) ? extend(obj[prop]) : obj[prop];
|
|
}
|
|
}
|
|
return dst;
|
|
}
|
|
|
|
function getSearchParam(name) {
|
|
var _windowSearch = window.location.search;
|
|
var _nameSearch = name + "=";
|
|
var _pos1 = _windowSearch.indexOf(_nameSearch);
|
|
if (_pos1 >= 0)
|
|
{
|
|
_pos1 += _nameSearch.length;
|
|
var _pos2 = _windowSearch.indexOf("&", _pos1);
|
|
if (_pos2 < 0)
|
|
_pos2 = _windowSearch.length;
|
|
|
|
return _windowSearch.substring(_pos1, _pos2);
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
function checkPluginWindow() {
|
|
var windowID = getSearchParam("windowID");
|
|
if (windowID) {
|
|
window.Asc.plugin.windowID = windowID;
|
|
|
|
if (!window.Asc.plugin.guid)
|
|
window.Asc.plugin.guid = decodeURIComponent(getSearchParam("guid"));
|
|
}
|
|
|
|
return (undefined !== windowID) ? true : false;
|
|
}
|
|
|
|
window.onload = function()
|
|
{
|
|
if (!window.Asc || !window.Asc.plugin)
|
|
return;
|
|
|
|
var xhr = new XMLHttpRequest();
|
|
xhr.open("get", "./config.json", true);
|
|
xhr.responseType = "json";
|
|
xhr.onload = function() {
|
|
if (!window.Asc || !window.Asc.plugin)
|
|
return;
|
|
|
|
if (xhr.status === 404)
|
|
return xhr.onerror();
|
|
|
|
if (xhr.status == 200 || (xhr.status == 0 && xhr.readyState == 4)) {
|
|
var objConfig = xhr.response;
|
|
if ((typeof objConfig) == "string")
|
|
objConfig = JSON.parse(objConfig);
|
|
|
|
extend(objConfig, window.Asc.plugin);
|
|
|
|
var obj = {
|
|
type : "initialize",
|
|
guid : window.Asc.plugin.guid
|
|
};
|
|
|
|
if (checkPluginWindow()) {
|
|
obj.windowID = window.Asc.plugin.windowID;
|
|
}
|
|
|
|
var _body = document.body;
|
|
if (_body && true !== window.Asc.plugin.enableDrops) {
|
|
_body.ondrop = function(e) {
|
|
if (e && e.preventDefault)
|
|
e.preventDefault();
|
|
return false;
|
|
};
|
|
_body.ondragenter = function(e) {
|
|
if (e && e.preventDefault)
|
|
e.preventDefault();
|
|
return false;
|
|
};
|
|
_body.ondragover = function(e) {
|
|
if (e && e.preventDefault)
|
|
e.preventDefault();
|
|
if (e && e.dataTransfer)
|
|
e.dataTransfer.dropEffect = "none";
|
|
return false;
|
|
};
|
|
}
|
|
|
|
// ie11 not support message from another domain
|
|
window.Asc.plugin._initInternal = true;
|
|
window.parent.postMessage(JSON.stringify(obj), "*");
|
|
}
|
|
};
|
|
xhr.onerror = function() {
|
|
if (!window.Asc || !window.Asc.plugin)
|
|
return;
|
|
|
|
if (checkPluginWindow()) {
|
|
var obj = {
|
|
type : "initialize",
|
|
guid : window.Asc.plugin.guid
|
|
};
|
|
obj.windowID = window.Asc.plugin.windowID;
|
|
|
|
// ie11 not support message from another domain
|
|
window.Asc.plugin._initInternal = true;
|
|
window.parent.postMessage(JSON.stringify(obj), "*");
|
|
}
|
|
}
|
|
xhr.send();
|
|
};
|
|
|
|
window.Asc.supportOrigins = {};
|
|
window.Asc.supportOrigins[window.origin] = true;
|
|
|
|
function onMessage(event) {
|
|
if (!window.Asc || !window.Asc.plugin)
|
|
return;
|
|
|
|
if (window.plugin_onMessage) {
|
|
if (!window.Asc.supportOrigins[event.origin])
|
|
return;
|
|
window.plugin_onMessage(event);
|
|
return;
|
|
}
|
|
|
|
if (!window.Asc.plugin._initInternal)
|
|
return;
|
|
|
|
if (typeof(event.data) == "string") {
|
|
var pluginData = {};
|
|
try {
|
|
pluginData = JSON.parse(event.data);
|
|
}
|
|
catch(err) {
|
|
pluginData = {};
|
|
}
|
|
|
|
if (pluginData.type == "plugin_init") {
|
|
window.Asc.supportOrigins[event.origin] = true;
|
|
window.Asc.plugin.ie_channel_check(event);
|
|
eval(pluginData.data);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (window.addEventListener)
|
|
window.addEventListener("message", onMessage, false);
|
|
else
|
|
window.attachEvent("onmessage", onMessage);
|
|
|
|
window.Asc.plugin._attachCustomMenuClickEvent = function(type, id, action)
|
|
{
|
|
if (!this[type])
|
|
this[type] = {};
|
|
|
|
this[type][id] = action;
|
|
};
|
|
window.Asc.plugin._onCustomMenuClick = function(type, id)
|
|
{
|
|
// parse data from id: text from item.
|
|
var itemId = id;
|
|
var itemData = undefined;
|
|
var itemPos = itemId.indexOf("_oo_sep_");
|
|
if (-1 !== itemPos)
|
|
{
|
|
itemData = itemId.substring(itemPos + 8);
|
|
itemId = itemId.substring(0, itemPos);
|
|
}
|
|
|
|
if (this[type] && this[type][itemId])
|
|
this[type][itemId].call(this, itemData);
|
|
};
|
|
|
|
window.Asc.plugin.attachContextMenuClickEvent = function(id, action)
|
|
{
|
|
this._attachCustomMenuClickEvent("contextMenuEvents", id, action);
|
|
};
|
|
window.Asc.plugin.event_onContextMenuClick = function(id)
|
|
{
|
|
this._onCustomMenuClick("contextMenuEvents", id);
|
|
};
|
|
|
|
window.Asc.plugin.attachToolbarMenuClickEvent = function(id, action)
|
|
{
|
|
this._attachCustomMenuClickEvent("toolbarMenuEvents", id, action);
|
|
};
|
|
window.Asc.plugin.event_onToolbarMenuClick = function(id)
|
|
{
|
|
this._onCustomMenuClick("toolbarMenuEvents", id);
|
|
};
|
|
window.Asc.plugin.attachEvent = function(id, action)
|
|
{
|
|
var pluginObj = window.Asc.plugin;
|
|
if (!pluginObj._events)
|
|
pluginObj._events = {};
|
|
|
|
pluginObj._events[id] = action;
|
|
};
|
|
window.Asc.plugin.detachEvent = function(id)
|
|
{
|
|
var pluginObj = window.Asc.plugin;
|
|
if (pluginObj._events && pluginObj._events[id])
|
|
delete pluginObj._events[id];
|
|
};
|
|
window.Asc.plugin.onEvent = function(id, data)
|
|
{
|
|
var pluginObj = window.Asc.plugin;
|
|
if (pluginObj._events && pluginObj._events[id])
|
|
pluginObj._events[id].call(pluginObj, data);
|
|
};
|
|
|
|
window.Asc.plugin.attachEditorEvent = function(id, action)
|
|
{
|
|
window.Asc.plugin["event_" + id] = action.bind(window.Asc.plugin);
|
|
|
|
_sendMessageToParent(JSON.stringify({
|
|
"guid" : window.Asc.plugin.guid,
|
|
"type" : "attachEvent",
|
|
"name" : id
|
|
}));
|
|
};
|
|
window.Asc.plugin.detachEditorEvent = function(id)
|
|
{
|
|
if (window.Asc.plugin["event_" + id])
|
|
delete window.Asc.plugin["event_" + id];
|
|
|
|
_sendMessageToParent(JSON.stringify({
|
|
"guid" : window.Asc.plugin.guid,
|
|
"type" : "detachEvent",
|
|
"name" : id
|
|
}));
|
|
};
|
|
|
|
window.onunload = function() {
|
|
if (window.addEventListener)
|
|
window.removeEventListener("message", onMessage, false);
|
|
else
|
|
window.detachEvent("onmessage", onMessage);
|
|
};
|
|
|
|
})(window, undefined);
|
|
|
|
(function(window, undefined)
|
|
{
|
|
function generateGuid()
|
|
{
|
|
if (!window.crypto || !window.crypto.getRandomValues)
|
|
{
|
|
function s4() {
|
|
return Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);
|
|
}
|
|
return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
|
|
}
|
|
|
|
var array = new Uint16Array(8);
|
|
window.crypto.getRandomValues(array);
|
|
var index = 0;
|
|
function s4() {
|
|
var value = 0x10000 + array[index++];
|
|
return value.toString(16).substring(1);
|
|
}
|
|
return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();
|
|
}
|
|
|
|
function translateItem(text) {
|
|
return window.Asc.plugin.tr(text);
|
|
};
|
|
|
|
window.Asc = window.Asc || {};
|
|
var Asc = window.Asc;
|
|
|
|
Asc.Buttons = {};
|
|
Asc.Buttons.ButtonsContextMenu = [];
|
|
Asc.Buttons.ButtonsToolbar = [];
|
|
Asc.Buttons.ButtonsContentControl = [];
|
|
|
|
Asc.Buttons.registerContextMenu = function()
|
|
{
|
|
window.Asc.plugin.attachEvent("onContextMenuShow", function(options) {
|
|
if (!options)
|
|
return;
|
|
|
|
let items = {
|
|
guid: window.Asc.plugin.guid,
|
|
};
|
|
for (let i = 0, len = Asc.Buttons.ButtonsContextMenu.length; i < len; i++)
|
|
{
|
|
let button = Asc.Buttons.ButtonsContextMenu[i];
|
|
if (button.parent === null)
|
|
{
|
|
button.onContextMenuShow(options, items);
|
|
}
|
|
}
|
|
|
|
if (items.items)
|
|
window.Asc.plugin.executeMethod("AddContextMenuItem", [items]);
|
|
});
|
|
};
|
|
|
|
Asc.Buttons.registerToolbarMenu = function()
|
|
{
|
|
let items = {
|
|
guid : window.Asc.plugin.guid,
|
|
tabs : []
|
|
};
|
|
|
|
for (let i = 0, len = Asc.Buttons.ButtonsToolbar.length; i < len; i++)
|
|
{
|
|
let button = Asc.Buttons.ButtonsToolbar[i];
|
|
if (button.parent === null)
|
|
{
|
|
button.toToolbar(items);
|
|
}
|
|
|
|
if (!!button.menu) {
|
|
for (let indexItem in button.menu) {
|
|
let item = button.menu.hasOwnProperty(indexItem) ? button.menu[indexItem] : null;
|
|
if (item && !!item.onclick) {
|
|
window.Asc.plugin.attachToolbarMenuClickEvent(item.id, item.onclick);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (items.tabs.length > 0)
|
|
window.Asc.plugin.executeMethod("AddToolbarMenuItem", [items]);
|
|
};
|
|
|
|
Asc.Buttons.updateToolbarMenu = function(id, name, buttons)
|
|
{
|
|
let buttonMainToolbar = new Asc.ButtonToolbar(null, id);
|
|
buttonMainToolbar.text = name;
|
|
|
|
let items = {
|
|
guid : window.Asc.plugin.guid,
|
|
tabs : []
|
|
};
|
|
|
|
buttonMainToolbar.childs = buttons;
|
|
for (let i = 0, len = buttons.length; i < len; i++)
|
|
buttons[i].parent = buttonMainToolbar;
|
|
|
|
buttonMainToolbar.toToolbar(items);
|
|
|
|
for (let i = 0, len = buttons.length; i < len; i++)
|
|
{
|
|
let button = buttons[i];
|
|
if (!!button.menu) {
|
|
for (let indexItem in button.menu) {
|
|
let item = button.menu.hasOwnProperty(indexItem) ? button.menu[indexItem] : null;
|
|
if (item && !!item.onclick) {
|
|
window.Asc.plugin.attachToolbarMenuClickEvent(item.id, item.onclick);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (items.tabs.length > 0)
|
|
window.Asc.plugin.executeMethod("UpdateToolbarMenuItem", [items]);
|
|
};
|
|
|
|
Asc.Buttons.registerContentControl = function()
|
|
{
|
|
window.Asc.plugin.attachEditorEvent("onShowContentControlTrack", function(contentControls) {
|
|
|
|
let buttons = {
|
|
guid: window.Asc.plugin.guid,
|
|
items : {}
|
|
};
|
|
|
|
let promises = [];
|
|
|
|
for (let i = 0, len = Asc.Buttons.ButtonsContentControl.length; i < len; ++i)
|
|
{
|
|
promises.push(Asc.Buttons.ButtonsContentControl[i].onShowTrack(contentControls, buttons.items));
|
|
}
|
|
|
|
Promise.all(promises).then(function() {
|
|
for (let id in buttons.items)
|
|
{
|
|
window.Asc.plugin.executeMethod("AddContentControlButtons", [buttons]);
|
|
break;
|
|
}
|
|
});
|
|
});
|
|
|
|
window.Asc.plugin._attachContentControlButtonClickEvent = function(buttonId, action)
|
|
{
|
|
const eventName = "ContentControlButtonEvents";
|
|
|
|
if (!this[eventName])
|
|
this[eventName] = {};
|
|
|
|
this[eventName][buttonId] = action;
|
|
};
|
|
|
|
let _plugin = window.Asc.plugin;
|
|
window.Asc.plugin.attachEditorEvent("onContentControlButtonClick", function(data) {
|
|
const eventName = "ContentControlButtonEvents";
|
|
|
|
let buttonId = (data && data["buttonId"] ? data["buttonId"] : null);
|
|
let ccId = (data && data["contentControlId"] ? data["contentControlId"] : null);
|
|
|
|
if (!buttonId || !ccId)
|
|
return;
|
|
|
|
if (_plugin[eventName] && _plugin[eventName][buttonId])
|
|
_plugin[eventName][buttonId].call(_plugin, ccId);
|
|
});
|
|
};
|
|
|
|
var ToolbarButtonType = {
|
|
Button : "button",
|
|
BigButton : "big-button"
|
|
};
|
|
|
|
var ItemType = {
|
|
None : 0,
|
|
ContextMenu : 1,
|
|
Toolbar : 2,
|
|
ContentControl : 3
|
|
};
|
|
|
|
function Button(parent, id)
|
|
{
|
|
this.itemType = ItemType.None;
|
|
this.editors = ["word", "cell", "slide"];
|
|
|
|
this.id = (id === undefined) ? generateGuid() : id;
|
|
|
|
this.icons = null;
|
|
|
|
this.text = "";
|
|
this.hint = null;
|
|
this.data = "";
|
|
|
|
this.separator = false;
|
|
this.lockInViewMode = true;
|
|
this.enableToggle = false;
|
|
this.disabled = false;
|
|
this.removed = false;
|
|
|
|
this.parent = parent ? parent : null;
|
|
this.childs = null;
|
|
|
|
if (this.parent)
|
|
{
|
|
if (!this.parent.childs)
|
|
this.parent.childs = [];
|
|
this.parent.childs.push(this);
|
|
}
|
|
}
|
|
|
|
Button.prototype.toItem = function()
|
|
{
|
|
let item = {
|
|
id : this.id,
|
|
text : translateItem(this.text)
|
|
};
|
|
|
|
if (this.hint !== null)
|
|
item.hint = translateItem(this.hint === "" ? this.hint : this.text);
|
|
|
|
if (this.separator)
|
|
item.separator = true;
|
|
|
|
if (this.data)
|
|
item.data = this.data;
|
|
|
|
if (this.lockInViewMode)
|
|
item.lockInViewMode = true;
|
|
|
|
if (this.enableToggle)
|
|
item.enableToggle = true;
|
|
|
|
if (this.disabled)
|
|
item.disabled = true;
|
|
else
|
|
item.disabled = false;
|
|
|
|
if (this.removed)
|
|
item.removed = true;
|
|
|
|
if (this.icons)
|
|
item.icons = this.icons;
|
|
|
|
if (this.itemType === ItemType.Toolbar)
|
|
item.type = this.type;
|
|
|
|
if (this.menu)
|
|
item.items = this.menu.map(function(menuItem) {
|
|
menuItem.text = translateItem(menuItem.text);
|
|
return menuItem;
|
|
});
|
|
|
|
if (this.split)
|
|
item.split = true;
|
|
|
|
return item;
|
|
};
|
|
|
|
Button.prototype.attachOnClick = function(handler)
|
|
{
|
|
};
|
|
|
|
Button.prototype.onClick = function()
|
|
{
|
|
console.log("BUTTON: " + this.text);
|
|
};
|
|
|
|
function ButtonContextMenu(parent, id)
|
|
{
|
|
Button.call(this, parent, id);
|
|
|
|
this.itemType = ItemType.ContextMenu;
|
|
this.showOnOptionsType = [];
|
|
|
|
Asc.Buttons.ButtonsContextMenu.push(this);
|
|
}
|
|
|
|
ButtonContextMenu.prototype = Object.create(Button.prototype);
|
|
ButtonContextMenu.prototype.constructor = ButtonContextMenu;
|
|
|
|
ButtonContextMenu.prototype.copy = function()
|
|
{
|
|
let ret = new ButtonContextMenu(this.parent, this.id);
|
|
ret.editors = this.editors;
|
|
|
|
ret.separator = this.separator;
|
|
ret.lockInViewMode = this.lockInViewMode;
|
|
ret.enableToggle = this.enableToggle;
|
|
ret.disabled = this.disabled;
|
|
ret.showOnOptionsType = this.showOnOptionsType.slice();
|
|
|
|
return ret;
|
|
};
|
|
|
|
ButtonContextMenu.prototype.addCheckers = function()
|
|
{
|
|
let len = arguments.length;
|
|
this.showOnOptionsType = new Array(len);
|
|
for (let i = 0; i < len; i++)
|
|
this.showOnOptionsType[i] = arguments[i];
|
|
};
|
|
|
|
ButtonContextMenu.prototype.attachOnClick = function(handler)
|
|
{
|
|
window.Asc.plugin.attachContextMenuClickEvent(this.id, handler);
|
|
};
|
|
|
|
ButtonContextMenu.prototype.onContextMenuShowAnalyze = function(options, parent)
|
|
{
|
|
return false;
|
|
};
|
|
|
|
ButtonContextMenu.prototype.onContextMenuShowExtendItem = function(options, item)
|
|
{
|
|
};
|
|
|
|
ButtonContextMenu.prototype.onContextMenuShow = function(options, parent)
|
|
{
|
|
if (this.onContextMenuShowAnalyze(options, parent))
|
|
return;
|
|
|
|
let isSupport = false;
|
|
for (let i = 0, len = this.editors.length; i < len; i++)
|
|
{
|
|
if (Asc.plugin.info.editorType === this.editors[i])
|
|
{
|
|
isSupport = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!isSupport)
|
|
return;
|
|
|
|
for (let i = 0, len = this.showOnOptionsType.length; i < len; i++)
|
|
{
|
|
if (options.type === this.showOnOptionsType[i] || this.showOnOptionsType[i] === "All")
|
|
{
|
|
if (!parent.items)
|
|
parent.items = [];
|
|
|
|
let curItem = this.toItem();
|
|
this.onContextMenuShowExtendItem(options, curItem);
|
|
|
|
if (this.childs)
|
|
{
|
|
for (let j = 0, childsLen = this.childs.length; j < childsLen; j++)
|
|
{
|
|
this.childs[j].onContextMenuShow(options, curItem);
|
|
}
|
|
}
|
|
|
|
parent.items.push(curItem);
|
|
return;
|
|
}
|
|
}
|
|
};
|
|
|
|
function ButtonToolbar(parent, id)
|
|
{
|
|
Button.call(this, parent, id);
|
|
|
|
this.itemType = ItemType.Toolbar;
|
|
this.type = ToolbarButtonType.BigButton;
|
|
this.tab = "";
|
|
|
|
Asc.Buttons.ButtonsToolbar.push(this);
|
|
}
|
|
|
|
ButtonToolbar.prototype = Object.create(Button.prototype);
|
|
ButtonToolbar.prototype.constructor = ButtonToolbar;
|
|
|
|
ButtonToolbar.prototype.attachOnClick = function(handler)
|
|
{
|
|
window.Asc.plugin.attachToolbarMenuClickEvent(this.id, handler);
|
|
};
|
|
|
|
ButtonToolbar.prototype.toItem = function(items)
|
|
{
|
|
let item = Button.prototype.toItem.call(this);
|
|
item.type = this.type;
|
|
return item;
|
|
};
|
|
|
|
ButtonToolbar.prototype.toToolbar = function(items)
|
|
{
|
|
let currentItem = null;
|
|
if (this.parent === null)
|
|
{
|
|
let tab = {
|
|
id : this.id,
|
|
text : translateItem(this.text),
|
|
items : []
|
|
};
|
|
if (this.hint !== null)
|
|
tab.hint = translateItem(this.hint === "" ? this.hint : this.text);
|
|
|
|
items.tabs.push(tab);
|
|
|
|
currentItem = tab;
|
|
}
|
|
else
|
|
{
|
|
currentItem = this.toItem();
|
|
|
|
if (!items.items)
|
|
items.items = [];
|
|
|
|
items.items.push(currentItem);
|
|
}
|
|
|
|
if (this.childs)
|
|
{
|
|
for (let j = 0, childsLen = this.childs.length; j < childsLen; j++)
|
|
{
|
|
this.childs[j].toToolbar(currentItem);
|
|
}
|
|
}
|
|
};
|
|
|
|
function ButtonContentControl(parent, id)
|
|
{
|
|
Button.call(this, parent, id);
|
|
this.itemType = ItemType.ContentControl;
|
|
this.checker = null;
|
|
|
|
|
|
if (0 === Asc.Buttons.ButtonsContentControl.length)
|
|
Asc.Buttons.registerContentControl();
|
|
|
|
Asc.Buttons.ButtonsContentControl.push(this);
|
|
}
|
|
|
|
ButtonContentControl.prototype = Object.create(Button.prototype);
|
|
ButtonContentControl.prototype.constructor = ButtonContentControl;
|
|
|
|
ButtonContentControl.prototype.attachOnClick = function(handler)
|
|
{
|
|
window.Asc.plugin._attachContentControlButtonClickEvent(this.id, handler);
|
|
};
|
|
ButtonContentControl.prototype.addChecker = function(checker)
|
|
{
|
|
if (!checker || typeof checker !== 'function')
|
|
return;
|
|
|
|
this.checker = checker;
|
|
};
|
|
ButtonContentControl.prototype.onShowTrack = function(ccIds, items)
|
|
{
|
|
let fChecker = this.checker;
|
|
let promises = [];
|
|
let curItem = this.toItem();
|
|
for (let i = 0, len = ccIds.length; i < len; ++i)
|
|
{
|
|
let ccId = ccIds[i];
|
|
promises.push(new Promise(function(resolve) {
|
|
|
|
if (!fChecker)
|
|
{
|
|
resolve(true)
|
|
}
|
|
else
|
|
{
|
|
let result = fChecker(ccId);
|
|
if (result instanceof Promise)
|
|
{
|
|
result.then(function(result) {
|
|
resolve(result);
|
|
});
|
|
}
|
|
else
|
|
{
|
|
resolve(!!result)
|
|
}
|
|
}
|
|
}).then(function(result) {
|
|
if (!result)
|
|
return;
|
|
|
|
if (!items[ccId])
|
|
items[ccId] = [];
|
|
|
|
items[ccId].push(curItem);
|
|
}));
|
|
}
|
|
return Promise.all(promises);
|
|
};
|
|
|
|
Asc.ToolbarButtonType = ToolbarButtonType;
|
|
Asc.ButtonContextMenu = ButtonContextMenu;
|
|
Asc.ButtonToolbar = ButtonToolbar;
|
|
Asc.ButtonContentControl = ButtonContentControl;
|
|
})(window);
|