1011 lines
27 KiB
JavaScript
1011 lines
27 KiB
JavaScript
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2024
|
|
*
|
|
* This program is a free software product. You can redistribute it and/or
|
|
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
|
* version 3 as published by the Free Software Foundation. In accordance with
|
|
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
|
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
|
* of any third-party rights.
|
|
*
|
|
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
|
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
*
|
|
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
|
|
* street, Riga, Latvia, EU, LV-1050.
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions
|
|
* of the Program must display Appropriate Legal Notices, as required under
|
|
* Section 5 of the GNU AGPL version 3.
|
|
*
|
|
* Pursuant to Section 7(b) of the License you must retain the original Product
|
|
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
|
* grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
* All the Product's GUI elements, including illustrations and icon sets, as
|
|
* well as technical writing content are licensed under the terms of the
|
|
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
|
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
*
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
(function(window, undefined)
|
|
{
|
|
AscCommon.isTouch = false;
|
|
AscCommon.isTouchMove = false;
|
|
AscCommon.TouchStartTime = -1;
|
|
// Import
|
|
var AscBrowser = AscCommon.AscBrowser;
|
|
|
|
// константы для мыши
|
|
var g_mouse_event_type_down = 0;
|
|
var g_mouse_event_type_move = 1;
|
|
var g_mouse_event_type_up = 2;
|
|
var g_mouse_event_type_wheel = 3;
|
|
|
|
var g_mouse_button_left = 0;
|
|
var g_mouse_button_center = 1;
|
|
var g_mouse_button_right = 2;
|
|
|
|
var MouseUpLock = {
|
|
MouseUpLockedSend : false
|
|
};
|
|
|
|
AscCommon.stopEvent = function(e)
|
|
{
|
|
if (!e)
|
|
return;
|
|
if (e.preventDefault)
|
|
e.preventDefault();
|
|
if (e.stopPropagation)
|
|
e.stopPropagation();
|
|
};
|
|
|
|
var isUsePointerEvents = true;
|
|
if (AscBrowser.isChrome && (AscBrowser.chromeVersion <= 70)) // xp
|
|
isUsePointerEvents = false;
|
|
else if (AscBrowser.isSafari && (AscBrowser.safariVersion < 15000000))
|
|
isUsePointerEvents = false;
|
|
else if (AscBrowser.isIE)
|
|
isUsePointerEvents = false;
|
|
|
|
AscCommon.getPtrEvtName = function (sType)
|
|
{
|
|
return (isUsePointerEvents ? "pointer" : "mouse") + sType;
|
|
};
|
|
AscCommon.getPtrEvtType = function (sType)
|
|
{
|
|
return "on" + AscCommon.getPtrEvtName(sType);
|
|
};
|
|
|
|
AscCommon.addMouseEvent = function(elem, type, handler)
|
|
{
|
|
var _type = AscCommon.getPtrEvtType(type);
|
|
elem[_type] = handler;
|
|
};
|
|
AscCommon.removeMouseEvent = function(elem, type)
|
|
{
|
|
var _type = AscCommon.getPtrEvtType(type);
|
|
if (elem[_type])
|
|
delete elem[_type];
|
|
};
|
|
AscCommon.getMouseEvent = function(elem, type)
|
|
{
|
|
var _type = AscCommon.getPtrEvtType(type);
|
|
return elem[_type];
|
|
};
|
|
AscCommon.capturePointer = function(e, elem)
|
|
{
|
|
if (e.pointerType === "mouse" && elem.setPointerCapture)
|
|
{
|
|
try {
|
|
elem.setPointerCapture(e.pointerId);
|
|
} catch (e) {}
|
|
}
|
|
};
|
|
|
|
function CMouseEventHandler()
|
|
{
|
|
this.X = 0; // позиция курсора X
|
|
this.Y = 0; // позиция курсора Y
|
|
|
|
this.Button = g_mouse_button_left; // кнопка мыши
|
|
this.ButtonOverride = -1;
|
|
this.Type = g_mouse_event_type_move; // тип евента
|
|
|
|
this.AltKey = false; // нажата ли кнопка alt
|
|
this.CtrlKey = false; // нажата ли кнопка ctrl
|
|
this.ShiftKey = false; // нажата ли кнопка shift
|
|
|
|
this.Sender = null; // от какого html элемента пришел евент
|
|
|
|
this.LastClickTime = -1; // время последнего mousedown
|
|
this.ClickCount = 0; // количество кликов
|
|
|
|
this.WheelDelta = 0;
|
|
|
|
// координаты мышки при предыдущем mousedown (для mousemove)
|
|
this.IsPressed = false; // была ли зажата кнопка
|
|
this.LastX = 0;
|
|
this.LastY = 0;
|
|
|
|
this.KoefPixToMM = 1;
|
|
|
|
this.IsLocked = false;
|
|
this.IsLockedEvent = false;
|
|
|
|
this.buttonObject = null;
|
|
|
|
this.AscHitToHandlesEpsilon = 0;
|
|
|
|
this.LockMouse = function()
|
|
{
|
|
if (!this.IsLocked)
|
|
{
|
|
this.IsLocked = true;
|
|
|
|
if (window.captureEvents)
|
|
window.captureEvents(Event.MOUSEDOWN | Event.MOUSEUP);
|
|
|
|
if (window.g_asc_plugins)
|
|
window.g_asc_plugins.disablePointerEvents();
|
|
|
|
/*
|
|
var parent = window;
|
|
while (true)
|
|
{
|
|
if (!parent)
|
|
break;
|
|
|
|
if (parent.captureEvents)
|
|
parent.captureEvents(Event.MOUSEDOWN | Event.MOUSEUP);
|
|
|
|
if (parent == parent.parent)
|
|
break;
|
|
|
|
parent = parent.parent;
|
|
}
|
|
*/
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
this.UnLockMouse = function()
|
|
{
|
|
if (this.IsLocked)
|
|
{
|
|
this.IsLocked = false;
|
|
|
|
if (window.releaseEvents)
|
|
window.releaseEvents(Event.MOUSEMOVE);
|
|
|
|
if (window.g_asc_plugins)
|
|
window.g_asc_plugins.enablePointerEvents();
|
|
|
|
/*
|
|
var parent = window;
|
|
while (true)
|
|
{
|
|
if (!parent)
|
|
break;
|
|
|
|
if (parent.releaseEvents)
|
|
parent.releaseEvents(Event.MOUSEMOVE);
|
|
|
|
if (parent == parent.parent)
|
|
break;
|
|
|
|
parent = parent.parent;
|
|
}
|
|
*/
|
|
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
}
|
|
|
|
function CKeyboardEvent()
|
|
{
|
|
this.AltKey = false; // нажата ли кнопка alt
|
|
this.CtrlKey = false; // нажата ли кнопка ctrl
|
|
this.ShiftKey = false; // нажата ли кнопка shift
|
|
this.MacCmdKey = false;
|
|
this.AltGr = false;
|
|
|
|
this.Sender = null; // от какого html элемента пришел евент
|
|
|
|
this.CharCode = 0;
|
|
this.KeyCode = 0;
|
|
}
|
|
|
|
CKeyboardEvent.prototype.Up = function()
|
|
{
|
|
this.AltKey = false;
|
|
this.CtrlKey = false;
|
|
this.ShiftKey = false;
|
|
this.AltGr = false;
|
|
this.MacCmdKey = false;
|
|
};
|
|
CKeyboardEvent.prototype.IsCtrl = function()
|
|
{
|
|
return (this.CtrlKey || (this.AltKey && this.AltGr));
|
|
};
|
|
CKeyboardEvent.prototype.IsShortcutCtrl = function()
|
|
{
|
|
return (this.CtrlKey && !this.MacCmdKey || (this.AltKey && this.AltGr));
|
|
};
|
|
CKeyboardEvent.prototype.IsCmd = function()
|
|
{
|
|
return this.MacCmdKey;
|
|
};
|
|
CKeyboardEvent.prototype.IsShift = function()
|
|
{
|
|
return this.ShiftKey;
|
|
};
|
|
CKeyboardEvent.prototype.IsAlt = function()
|
|
{
|
|
return this.AltKey;
|
|
};
|
|
CKeyboardEvent.prototype.GetKeyCode = function()
|
|
{
|
|
return this.KeyCode;
|
|
};
|
|
|
|
|
|
var global_mouseEvent = new CMouseEventHandler();
|
|
var global_keyboardEvent = new CKeyboardEvent();
|
|
|
|
function check_KeyboardEvent(e)
|
|
{
|
|
global_keyboardEvent.AltKey = e.altKey;
|
|
global_keyboardEvent.AltGr = AscCommon.getAltGr(e);
|
|
global_keyboardEvent.CtrlKey = !global_keyboardEvent.AltGr && (e.metaKey || e.ctrlKey);
|
|
global_keyboardEvent.MacCmdKey = AscCommon.AscBrowser.isMacOs && e.metaKey;
|
|
|
|
global_keyboardEvent.ShiftKey = e.shiftKey;
|
|
|
|
global_keyboardEvent.Sender = (e.srcElement) ? e.srcElement : e.target;
|
|
|
|
global_keyboardEvent.CharCode = e.charCode;
|
|
global_keyboardEvent.KeyCode = e.keyCode;
|
|
global_keyboardEvent.Which = e.which;
|
|
}
|
|
|
|
function check_KeyboardEvent2(e)
|
|
{
|
|
global_keyboardEvent.AltKey = e.altKey;
|
|
|
|
if (e.metaKey !== undefined)
|
|
global_keyboardEvent.CtrlKey = e.ctrlKey || e.metaKey;
|
|
else
|
|
global_keyboardEvent.CtrlKey = e.ctrlKey;
|
|
|
|
global_keyboardEvent.MacCmdKey = AscCommon.AscBrowser.isMacOs && e.metaKey;
|
|
|
|
global_keyboardEvent.ShiftKey = e.shiftKey;
|
|
|
|
global_keyboardEvent.AltGr = (global_keyboardEvent.CtrlKey && global_keyboardEvent.AltKey) ? true : false;
|
|
|
|
if (global_keyboardEvent.CtrlKey && global_keyboardEvent.AltKey)
|
|
global_keyboardEvent.CtrlKey = false;
|
|
}
|
|
|
|
function check_MouseMoveEvent(e)
|
|
{
|
|
// если мышь залочена, то евент придет от окна.
|
|
if (e.IsLocked && !e.IsLockedEvent)
|
|
return;
|
|
|
|
if (e.pageX || e.pageY)
|
|
{
|
|
global_mouseEvent.X = e.pageX;
|
|
global_mouseEvent.Y = e.pageY;
|
|
}
|
|
else if (e.clientX || e.clientY)
|
|
{
|
|
global_mouseEvent.X = e.clientX;
|
|
global_mouseEvent.Y = e.clientY;
|
|
}
|
|
|
|
global_mouseEvent.X = (global_mouseEvent.X * AscBrowser.zoom) >> 0;
|
|
global_mouseEvent.Y = (global_mouseEvent.Y * AscBrowser.zoom) >> 0;
|
|
|
|
global_mouseEvent.AltKey = e.altKey;
|
|
global_mouseEvent.ShiftKey = e.shiftKey;
|
|
global_mouseEvent.CtrlKey = e.ctrlKey || e.metaKey;
|
|
|
|
global_mouseEvent.Type = g_mouse_event_type_move;
|
|
|
|
if (!global_mouseEvent.IsLocked)
|
|
{
|
|
global_mouseEvent.Sender = (e.srcElement) ? e.srcElement : e.target;
|
|
}
|
|
|
|
var _eps = 3 * global_mouseEvent.KoefPixToMM;
|
|
if ((Math.abs(global_mouseEvent.X - global_mouseEvent.LastX) > _eps) || (Math.abs(global_mouseEvent.Y - global_mouseEvent.LastY) > _eps))
|
|
{
|
|
global_mouseEvent.LastClickTime = -1;
|
|
global_mouseEvent.ClickCount = 0;
|
|
}
|
|
}
|
|
|
|
function CreateMouseUpEventObject(x, y)
|
|
{
|
|
var e = {};
|
|
e.PageX = x;
|
|
e.PageY = y;
|
|
|
|
e.altKey = global_mouseEvent.AltKey;
|
|
e.shiftKey = global_mouseEvent.ShiftKey;
|
|
e.ctrlKey = global_mouseEvent.CtrlKey;
|
|
|
|
e.srcElement = global_mouseEvent.Sender;
|
|
e.button = 0;
|
|
return e;
|
|
}
|
|
|
|
function getMouseButton(e)
|
|
{
|
|
if (-1 !== global_mouseEvent.ButtonOverride)
|
|
return global_mouseEvent.ButtonOverride;
|
|
var res = e.button;
|
|
return (res && -1 !== res) ? res : 0;
|
|
}
|
|
|
|
function check_MouseUpEvent(e)
|
|
{
|
|
if (e.pageX || e.pageY)
|
|
{
|
|
global_mouseEvent.X = e.pageX;
|
|
global_mouseEvent.Y = e.pageY;
|
|
}
|
|
else if (e.clientX || e.clientY)
|
|
{
|
|
global_mouseEvent.X = e.clientX;
|
|
global_mouseEvent.Y = e.clientY;
|
|
}
|
|
|
|
global_mouseEvent.X = (global_mouseEvent.X * AscBrowser.zoom) >> 0;
|
|
global_mouseEvent.Y = (global_mouseEvent.Y * AscBrowser.zoom) >> 0;
|
|
|
|
global_mouseEvent.AltKey = e.altKey;
|
|
global_mouseEvent.ShiftKey = e.shiftKey;
|
|
global_mouseEvent.CtrlKey = e.ctrlKey || e.metaKey;
|
|
|
|
global_keyboardEvent.AltKey = global_mouseEvent.AltKey;
|
|
global_keyboardEvent.ShiftKey = global_mouseEvent.ShiftKey;
|
|
global_keyboardEvent.CtrlKey = global_mouseEvent.CtrlKey;
|
|
|
|
global_mouseEvent.Type = g_mouse_event_type_up;
|
|
global_mouseEvent.Button = getMouseButton(e);
|
|
|
|
var lockedElement = null;
|
|
|
|
var newSender = (e.srcElement) ? e.srcElement : e.target;
|
|
if (!newSender)
|
|
newSender = { id : "emulation_oo_id" };
|
|
|
|
if (global_mouseEvent.Sender && global_mouseEvent.Sender.id == newSender.id)
|
|
{
|
|
lockedElement = global_mouseEvent.Sender;
|
|
}
|
|
|
|
if (global_mouseEvent.IsLocked == true && global_mouseEvent.Sender != newSender && false === MouseUpLock.MouseUpLockedSend)
|
|
{
|
|
Window_OnMouseUp(e);
|
|
}
|
|
MouseUpLock.MouseUpLockedSend = true;
|
|
global_mouseEvent.Sender = newSender;
|
|
|
|
global_mouseEvent.UnLockMouse();
|
|
|
|
global_mouseEvent.IsPressed = false;
|
|
|
|
return lockedElement;
|
|
}
|
|
|
|
function check_MouseClickOnUp()
|
|
{
|
|
// call after check mouseUp
|
|
if (0 == global_mouseEvent.ClickCount)
|
|
return false;
|
|
|
|
var _eps = 3 * global_mouseEvent.KoefPixToMM;
|
|
if ((Math.abs(global_mouseEvent.X - global_mouseEvent.LastX) > _eps) || (Math.abs(global_mouseEvent.Y - global_mouseEvent.LastY) > _eps))
|
|
return false;
|
|
|
|
var CurTime = new Date().getTime();
|
|
if (500 < (CurTime - global_mouseEvent.LastClickTime))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
function check_MouseDownEvent(e, isClicks)
|
|
{
|
|
if (e.pageX || e.pageY)
|
|
{
|
|
global_mouseEvent.X = e.pageX;
|
|
global_mouseEvent.Y = e.pageY;
|
|
}
|
|
else if (e.clientX || e.clientY)
|
|
{
|
|
global_mouseEvent.X = e.clientX;
|
|
global_mouseEvent.Y = e.clientY;
|
|
}
|
|
|
|
global_mouseEvent.X = (global_mouseEvent.X * AscBrowser.zoom) >> 0;
|
|
global_mouseEvent.Y = (global_mouseEvent.Y * AscBrowser.zoom) >> 0;
|
|
|
|
var _eps = 3 * global_mouseEvent.KoefPixToMM;
|
|
if ((Math.abs(global_mouseEvent.X - global_mouseEvent.LastX) > _eps) || (Math.abs(global_mouseEvent.Y - global_mouseEvent.LastY) > _eps))
|
|
{
|
|
// not only move!!! (touch - fast click in different places)
|
|
global_mouseEvent.LastClickTime = -1;
|
|
global_mouseEvent.ClickCount = 0;
|
|
}
|
|
|
|
global_mouseEvent.LastX = global_mouseEvent.X;
|
|
global_mouseEvent.LastY = global_mouseEvent.Y;
|
|
|
|
global_mouseEvent.AltKey = e.altKey;
|
|
global_mouseEvent.ShiftKey = e.shiftKey;
|
|
global_mouseEvent.CtrlKey = e.ctrlKey || e.metaKey;
|
|
|
|
global_keyboardEvent.AltKey = global_mouseEvent.AltKey;
|
|
global_keyboardEvent.ShiftKey = global_mouseEvent.ShiftKey;
|
|
global_keyboardEvent.CtrlKey = global_mouseEvent.CtrlKey;
|
|
|
|
global_mouseEvent.Type = g_mouse_event_type_down;
|
|
let oldButton = global_mouseEvent.Button;
|
|
global_mouseEvent.Button = getMouseButton(e);
|
|
|
|
if (!global_mouseEvent.IsLocked || !global_mouseEvent.Sender)
|
|
global_mouseEvent.Sender = (e.srcElement) ? e.srcElement : e.target;
|
|
|
|
AscCommon.capturePointer(e, global_mouseEvent.Sender);
|
|
|
|
if (isClicks)
|
|
{
|
|
var CurTime = new Date().getTime();
|
|
if (0 === global_mouseEvent.ClickCount)
|
|
{
|
|
global_mouseEvent.ClickCount = 1;
|
|
global_mouseEvent.LastClickTime = CurTime;
|
|
}
|
|
else
|
|
{
|
|
if ((500 > (CurTime - global_mouseEvent.LastClickTime)) && oldButton === global_mouseEvent.Button)
|
|
{
|
|
global_mouseEvent.LastClickTime = CurTime;
|
|
global_mouseEvent.ClickCount++;
|
|
}
|
|
else
|
|
{
|
|
global_mouseEvent.ClickCount = 1;
|
|
global_mouseEvent.LastClickTime = CurTime;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
global_mouseEvent.LastClickTime = -1;
|
|
global_mouseEvent.ClickCount = 1;
|
|
}
|
|
|
|
MouseUpLock.MouseUpLockedSend = false;
|
|
}
|
|
|
|
function check_MouseDownEvent2(x, y)
|
|
{
|
|
global_mouseEvent.X = x;
|
|
global_mouseEvent.Y = y;
|
|
|
|
global_mouseEvent.LastX = global_mouseEvent.X;
|
|
global_mouseEvent.LastY = global_mouseEvent.Y;
|
|
|
|
global_mouseEvent.Type = g_mouse_event_type_down;
|
|
|
|
global_mouseEvent.Sender = editor.WordControl.m_oEditor.HtmlElement;
|
|
|
|
global_mouseEvent.LastClickTime = -1;
|
|
global_mouseEvent.ClickCount = 1;
|
|
|
|
MouseUpLock.MouseUpLockedSend = false;
|
|
}
|
|
|
|
function global_OnMouseWheel(e)
|
|
{
|
|
global_mouseEvent.AltKey = e.altKey;
|
|
global_mouseEvent.ShiftKey = e.shiftKey;
|
|
global_mouseEvent.CtrlKey = e.ctrlKey || e.metaKey;
|
|
|
|
if (undefined != e.wheelDelta)
|
|
global_mouseEvent.WheelDelta = (e.wheelDelta > 0) ? -45 : 45;
|
|
else
|
|
global_mouseEvent.WheelDelta = (e.detail > 0) ? 45 : -45;
|
|
|
|
global_mouseEvent.type = g_mouse_event_type_wheel;
|
|
|
|
global_mouseEvent.Sender = (e.srcElement) ? e.srcElement : e.target;
|
|
|
|
global_mouseEvent.LastClickTime = -1;
|
|
global_mouseEvent.ClickCount = 0;
|
|
}
|
|
|
|
function InitCaptureEvents()
|
|
{
|
|
AscCommon.addMouseEvent(window, "move", Window_OnMouseMove);
|
|
AscCommon.addMouseEvent(window, "up", Window_OnMouseUp);
|
|
}
|
|
|
|
function Window_OnMouseMove(e)
|
|
{
|
|
if (!global_mouseEvent.IsLocked || !global_mouseEvent.Sender)
|
|
return;
|
|
|
|
var types = isUsePointerEvents ? ["onpointermove", "onmousemove"] : ["onmousemove", "onpointermove"];
|
|
for (var i = 0; i < 2; i++)
|
|
{
|
|
if (global_mouseEvent.Sender[types[i]])
|
|
{
|
|
global_mouseEvent.IsLockedEvent = true;
|
|
global_mouseEvent.Sender[types[i]](e);
|
|
global_mouseEvent.IsLockedEvent = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
function Window_OnMouseUp(e)
|
|
{
|
|
if (false === MouseUpLock.MouseUpLockedSend)
|
|
{
|
|
MouseUpLock.MouseUpLockedSend = true;
|
|
if (global_mouseEvent.IsLocked && global_mouseEvent.Sender)
|
|
{
|
|
var types = isUsePointerEvents ? ["onpointerup", "onmouseup"] : ["onmouseup", "onpointerup"];
|
|
for (var i = 0; i < 2; i++)
|
|
{
|
|
if (global_mouseEvent.Sender[types[i]])
|
|
{
|
|
global_mouseEvent.Sender[types[i]](e, true);
|
|
if (global_mouseEvent.IsLocked)
|
|
global_mouseEvent.UnLockMouse();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (window.g_asc_plugins)
|
|
window.g_asc_plugins.onExternalMouseUp();
|
|
}
|
|
|
|
InitCaptureEvents();
|
|
|
|
function button_eventHandlers(disable_pos, norm_pos, over_pos, down_pos, control, click_func_delegate)
|
|
{
|
|
this.state_normal = norm_pos;
|
|
this.state_over = over_pos;
|
|
this.state_down = down_pos;
|
|
|
|
this.Click_func = click_func_delegate;
|
|
this.Control = control;
|
|
this.IsPressed = false;
|
|
|
|
var oThis = this;
|
|
|
|
this.Control.HtmlElement.onmouseover = function(e)
|
|
{
|
|
check_MouseMoveEvent(e);
|
|
|
|
if (global_mouseEvent.IsLocked)
|
|
{
|
|
if (global_mouseEvent.Sender.id != oThis.Control.HtmlElement.id)
|
|
{
|
|
// это не залоченная кнопка
|
|
return;
|
|
}
|
|
// залоченная кнопка
|
|
oThis.Control.HtmlElement.style.backgroundPosition = oThis.state_down;
|
|
return;
|
|
}
|
|
oThis.Control.HtmlElement.style.backgroundPosition = oThis.state_over;
|
|
}
|
|
this.Control.HtmlElement.onmouseout = function(e)
|
|
{
|
|
check_MouseMoveEvent(e);
|
|
|
|
if (global_mouseEvent.IsLocked)
|
|
{
|
|
if (global_mouseEvent.Sender.id != oThis.Control.HtmlElement.id)
|
|
{
|
|
// это не залоченная кнопка
|
|
return;
|
|
}
|
|
// залоченная кнопка
|
|
oThis.Control.HtmlElement.style.backgroundPosition = oThis.state_over;
|
|
return;
|
|
}
|
|
oThis.Control.HtmlElement.style.backgroundPosition = oThis.state_normal;
|
|
}
|
|
this.Control.HtmlElement.onmousedown = function(e)
|
|
{
|
|
check_MouseDownEvent(e);
|
|
global_mouseEvent.LockMouse();
|
|
global_mouseEvent.buttonObject = oThis;
|
|
|
|
AscCommon.stopEvent(e);
|
|
|
|
if (global_mouseEvent.IsLocked)
|
|
{
|
|
if (global_mouseEvent.Sender.id != oThis.Control.HtmlElement.id)
|
|
{
|
|
// это не залоченная кнопка
|
|
return;
|
|
}
|
|
// залоченная кнопка
|
|
oThis.Control.HtmlElement.style.backgroundPosition = oThis.state_down;
|
|
return;
|
|
}
|
|
oThis.Control.HtmlElement.style.backgroundPosition = oThis.state_down;
|
|
}
|
|
this.Control.HtmlElement.onmouseup = function(e)
|
|
{
|
|
var lockedElement = check_MouseUpEvent(e);
|
|
|
|
if (e.preventDefault)
|
|
e.preventDefault();
|
|
else
|
|
e.returnValue = false;
|
|
|
|
if (null != lockedElement && global_mouseEvent.buttonObject != null)
|
|
{
|
|
oThis.Click_func();
|
|
}
|
|
|
|
if (null != lockedElement)
|
|
{
|
|
oThis.Control.HtmlElement.style.backgroundPosition = oThis.state_over;
|
|
}
|
|
else
|
|
{
|
|
if (null != global_mouseEvent.buttonObject)
|
|
global_mouseEvent.buttonObject.Control.HtmlElement.style.backgroundPosition = global_mouseEvent.buttonObject.state_normal;
|
|
|
|
if ((global_mouseEvent.buttonObject == null) || (oThis.Control.HtmlElement.id != global_mouseEvent.buttonObject.Control.HtmlElement.id))
|
|
oThis.Control.HtmlElement.style.backgroundPosition = oThis.state_over;
|
|
}
|
|
global_mouseEvent.buttonObject = null;
|
|
}
|
|
|
|
// теперь touch
|
|
this.Control.HtmlElement.ontouchstart = function(e)
|
|
{
|
|
oThis.Control.HtmlElement.onmousedown(e.touches[0]);
|
|
return false;
|
|
}
|
|
this.Control.HtmlElement.ontouchend = function(e)
|
|
{
|
|
var lockedElement = check_MouseUpEvent(e.changedTouches[0]);
|
|
|
|
if (null != lockedElement)
|
|
{
|
|
oThis.Click_func();
|
|
oThis.Control.HtmlElement.style.backgroundPosition = oThis.state_normal;
|
|
}
|
|
else
|
|
{
|
|
if (null != global_mouseEvent.buttonObject)
|
|
global_mouseEvent.buttonObject.Control.HtmlElement.style.backgroundPosition = global_mouseEvent.buttonObject.state_normal;
|
|
|
|
if (oThis.Control.HtmlElement.id != global_mouseEvent.buttonObject.Control.HtmlElement.id)
|
|
oThis.Control.HtmlElement.style.backgroundPosition = oThis.state_normal;
|
|
}
|
|
global_mouseEvent.buttonObject = null;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function emulateKeyDown(_code, _element)
|
|
{
|
|
var oEvent = document.createEvent('KeyboardEvent');
|
|
|
|
// Chromium Hack
|
|
Object.defineProperty(oEvent, 'keyCode', {
|
|
get : function()
|
|
{
|
|
return this.keyCodeVal;
|
|
}
|
|
});
|
|
Object.defineProperty(oEvent, 'which', {
|
|
get : function()
|
|
{
|
|
return this.keyCodeVal;
|
|
}
|
|
});
|
|
Object.defineProperty(oEvent, 'shiftKey', {
|
|
get : function()
|
|
{
|
|
return false;
|
|
}
|
|
});
|
|
Object.defineProperty(oEvent, 'altKey', {
|
|
get : function()
|
|
{
|
|
return false;
|
|
}
|
|
});
|
|
Object.defineProperty(oEvent, 'metaKey', {
|
|
get : function()
|
|
{
|
|
return false;
|
|
}
|
|
});
|
|
Object.defineProperty(oEvent, 'ctrlKey', {
|
|
get : function()
|
|
{
|
|
return false;
|
|
}
|
|
});
|
|
|
|
if (AscCommon.AscBrowser.isIE)
|
|
{
|
|
oEvent.preventDefault = function () {
|
|
Object.defineProperty(this, "defaultPrevented", {get: function () {return true;}});
|
|
};
|
|
}
|
|
|
|
if (oEvent.initKeyboardEvent)
|
|
{
|
|
oEvent.initKeyboardEvent("keydown", true, true, window, false, false, false, false, _code, _code);
|
|
}
|
|
else
|
|
{
|
|
oEvent.initKeyEvent("keydown", true, true, window, false, false, false, false, _code, 0);
|
|
}
|
|
|
|
oEvent.keyCodeVal = _code;
|
|
|
|
_element.dispatchEvent(oEvent);
|
|
return oEvent.defaultPrevented;
|
|
}
|
|
|
|
function PaintMessageLoop(interval, api)
|
|
{
|
|
this.isUseInterval = api.isMobileVersion !== true;
|
|
this.interval = interval || 40;
|
|
this.id = null;
|
|
|
|
this.requestAnimationFrame = window.requestAnimationFrame ||
|
|
window.webkitRequestAnimationFrame ||
|
|
window.mozRequestAnimationFrame ||
|
|
window.oRequestAnimationFrame ||
|
|
window.msRequestAnimationFrame || null;
|
|
this.cancelAnimationFrame = window.cancelRequestAnimationFrame ||
|
|
window.webkitCancelAnimationFrame ||
|
|
window.webkitCancelRequestAnimationFrame ||
|
|
window.mozCancelRequestAnimationFrame ||
|
|
window.oCancelRequestAnimationFrame ||
|
|
window.msCancelRequestAnimationFrame || null;
|
|
|
|
this.isUseRequestAnimationFrame = AscCommon.AscBrowser.isChrome || AscCommon.AscBrowser.isSafari;
|
|
if (this.isUseRequestAnimationFrame && !this.requestAnimationFrame)
|
|
this.isUseRequestAnimationFrame = false;
|
|
|
|
this.requestAnimationOldTime = -1;
|
|
|
|
this.engine = null;
|
|
this.step = null;
|
|
}
|
|
|
|
PaintMessageLoop.prototype.Start = function(engine)
|
|
{
|
|
this.engine = engine;
|
|
if (null !== this.id)
|
|
return;
|
|
|
|
if (this.isUseRequestAnimationFrame)
|
|
{
|
|
this.step = this._animation.bind(this);
|
|
}
|
|
else
|
|
{
|
|
this.step = this._timer.bind(this);
|
|
}
|
|
|
|
this.step();
|
|
};
|
|
PaintMessageLoop.prototype.Stop = function()
|
|
{
|
|
if (null === this.id)
|
|
return;
|
|
|
|
if (this.isUseRequestAnimationFrame)
|
|
{
|
|
this.cancelAnimationFrame.call(window, this.id);
|
|
}
|
|
else
|
|
{
|
|
this.clearTimeout(this.id);
|
|
}
|
|
|
|
this.id = null;
|
|
};
|
|
|
|
PaintMessageLoop.prototype._animation = function()
|
|
{
|
|
var now = Date.now();
|
|
if (!this.isUseInterval || -1 === this.requestAnimationOldTime || (now >= (this.requestAnimationOldTime + this.interval)) || (now < this.requestAnimationOldTime))
|
|
{
|
|
this.requestAnimationOldTime = now;
|
|
this.engine();
|
|
}
|
|
this.id = this.requestAnimationFrame.call(window, this.step);
|
|
};
|
|
|
|
PaintMessageLoop.prototype._timer = function()
|
|
{
|
|
this.engine();
|
|
this.id = setTimeout(this.step, this.interval);
|
|
};
|
|
|
|
PaintMessageLoop.prototype.delayRun = function(_this, _func)
|
|
{
|
|
if (window.requestAnimationFrame)
|
|
{
|
|
if (undefined !== _this._delayRunId)
|
|
window.cancelAnimationFrame(_this._delayRunId);
|
|
|
|
_this._delayRunId = window.requestAnimationFrame(function () {
|
|
_func.call(_this);
|
|
delete _this._delayRunId;
|
|
});
|
|
}
|
|
else
|
|
{
|
|
if (undefined !== _this._delayRunId)
|
|
clearTimeout(_this._delayRunId);
|
|
|
|
_this._delayRunId = setTimeout(function () {
|
|
_func.call(_this);
|
|
delete _this._delayRunId;
|
|
}, 40);
|
|
}
|
|
};
|
|
|
|
function isSupportDoublePx()
|
|
{
|
|
var isSupport = true;
|
|
|
|
var oTestSpan = document.createElement("span");
|
|
oTestSpan.setAttribute("style", "font-size:8pt");
|
|
document.body.appendChild(oTestSpan);
|
|
var defaultView = oTestSpan.ownerDocument.defaultView;
|
|
var computedStyle = defaultView.getComputedStyle(oTestSpan, null);
|
|
if (null != computedStyle)
|
|
{
|
|
var fontSize = computedStyle.getPropertyValue("font-size");
|
|
if (-1 !== fontSize.indexOf("px") && parseFloat(fontSize) === parseInt(fontSize))
|
|
isSupport = false;
|
|
}
|
|
document.body.removeChild(oTestSpan);
|
|
|
|
return isSupport;
|
|
}
|
|
|
|
function checkMouseWhell(e, options)
|
|
{
|
|
let isSupportBidirectional = false;
|
|
let isAllowHorizontal = false;
|
|
let isUseMaximumDelta = false;
|
|
|
|
if (options)
|
|
{
|
|
isSupportBidirectional = (true === options.isSupportBidirectional);
|
|
isAllowHorizontal = (true === options.isAllowHorizontal);
|
|
isUseMaximumDelta = (true === options.isUseMaximumDelta);
|
|
}
|
|
|
|
let delta = 0;
|
|
let deltaX = 0;
|
|
let deltaY = 0;
|
|
|
|
// delta
|
|
if (undefined !== e.wheelDelta && 0 !== e.wheelDelta)
|
|
{
|
|
delta = -45 * e.wheelDelta / 120;
|
|
}
|
|
else if (undefined !== e.detail && 0 !== e.detail)
|
|
{
|
|
delta = 45 * e.detail / 3;
|
|
}
|
|
|
|
// y
|
|
if (undefined !== e.wheelDeltaY)
|
|
{
|
|
deltaY = -45 * e.wheelDeltaY / 120;
|
|
}
|
|
else
|
|
deltaY = delta;
|
|
|
|
// x
|
|
if (isAllowHorizontal)
|
|
{
|
|
if (undefined !== e.wheelDeltaX)
|
|
{
|
|
deltaX = -45 * e.wheelDeltaX / 120;
|
|
}
|
|
|
|
if (e.axis !== undefined && e.axis === e.HORIZONTAL_AXIS)
|
|
{
|
|
deltaY = 0;
|
|
|
|
if (0 === deltaX)
|
|
deltaX = delta;
|
|
}
|
|
}
|
|
|
|
deltaX >>= 0;
|
|
deltaY >>= 0;
|
|
|
|
if (!isSupportBidirectional)
|
|
{
|
|
if (isUseMaximumDelta)
|
|
{
|
|
if (Math.abs(deltaY) >= Math.abs(deltaX))
|
|
deltaX = 0;
|
|
else
|
|
deltaY = 0;
|
|
}
|
|
else
|
|
{
|
|
if (0 !== deltaX)
|
|
deltaY = 0;
|
|
}
|
|
}
|
|
|
|
return {
|
|
x : deltaX,
|
|
y : deltaY
|
|
};
|
|
}
|
|
|
|
//--------------------------------------------------------export----------------------------------------------------
|
|
window['AscCommon'] = window['AscCommon'] || {};
|
|
window['AscCommon'].g_mouse_event_type_down = g_mouse_event_type_down;
|
|
window['AscCommon'].g_mouse_event_type_move = g_mouse_event_type_move;
|
|
window['AscCommon'].g_mouse_event_type_up = g_mouse_event_type_up;
|
|
window['AscCommon'].g_mouse_button_left = g_mouse_button_left;
|
|
window['AscCommon'].g_mouse_button_center = g_mouse_button_center;
|
|
window['AscCommon'].g_mouse_button_right = g_mouse_button_right;
|
|
window['AscCommon'].MouseUpLock = MouseUpLock;
|
|
window['AscCommon'].CMouseEventHandler = CMouseEventHandler;
|
|
window['AscCommon'].CKeyboardEvent = CKeyboardEvent;
|
|
window['AscCommon'].global_mouseEvent = global_mouseEvent;
|
|
window['AscCommon'].global_keyboardEvent = global_keyboardEvent;
|
|
window['AscCommon'].check_KeyboardEvent = check_KeyboardEvent;
|
|
window['AscCommon'].check_KeyboardEvent2 = check_KeyboardEvent2;
|
|
window['AscCommon'].check_MouseMoveEvent = check_MouseMoveEvent;
|
|
window['AscCommon'].CreateMouseUpEventObject = CreateMouseUpEventObject;
|
|
window['AscCommon'].getMouseButton = getMouseButton;
|
|
window['AscCommon'].check_MouseUpEvent = check_MouseUpEvent;
|
|
window['AscCommon'].check_MouseDownEvent = check_MouseDownEvent;
|
|
window['AscCommon'].Window_OnMouseUp = Window_OnMouseUp;
|
|
window['AscCommon'].button_eventHandlers = button_eventHandlers;
|
|
window['AscCommon'].emulateKeyDown = emulateKeyDown;
|
|
window['AscCommon'].check_MouseClickOnUp = check_MouseClickOnUp;
|
|
|
|
window['AscCommon'].PaintMessageLoop = PaintMessageLoop;
|
|
window['AscCommon'].isSupportDoublePx = isSupportDoublePx;
|
|
|
|
window['AscCommon'].checkMouseWhell = checkMouseWhell;
|
|
|
|
})(window);
|