2919 lines
108 KiB
JavaScript
2919 lines
108 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() {
|
|
|
|
AscDFH.drawingsChangesMap[AscDFH.historyitem_SlicerViewName] = function(oClass, value){
|
|
oClass.name = value;
|
|
oClass.data.clear();
|
|
oClass.removeAllButtonsTmpState();
|
|
oClass.handleUpdateExtents();
|
|
};
|
|
AscDFH.changesFactory[AscDFH.historyitem_SlicerViewName] = window['AscDFH'].CChangesDrawingsString;
|
|
|
|
var LEFT_PADDING = 2.54;
|
|
var RIGHT_PADDING = LEFT_PADDING;
|
|
var BOTTOM_PADDING = LEFT_PADDING;
|
|
var TOP_PADDING = LEFT_PADDING / 2;
|
|
var SPACE_BETWEEN = LEFT_PADDING * 14 / 37;
|
|
var HEADER_BUTTON_WIDTH = 20 * AscCommon.g_dKoef_pix_to_mm;
|
|
var HEADER_TOP_PADDING = LEFT_PADDING / 4;
|
|
var HEADER_BOTTOM_PADDING = HEADER_TOP_PADDING;
|
|
var HEADER_LEFT_PADDING = LEFT_PADDING;
|
|
var HEADER_RIGHT_PADDING = HEADER_TOP_PADDING + RIGHT_PADDING + 2*HEADER_BUTTON_WIDTH;
|
|
var SCROLL_WIDTH = 15 * 25.4 / 96;
|
|
var SCROLLER_WIDTH = 13 * 25.4 / 96;
|
|
|
|
var STATE_FLAG_WHOLE = 1;
|
|
var STATE_FLAG_HEADER = 2;
|
|
var STATE_FLAG_SELECTED = 4;
|
|
var STATE_FLAG_DATA = 8;
|
|
var STATE_FLAG_HOVERED = 16;
|
|
|
|
var SCROLL_TIMER_INTERVAL = 200;
|
|
|
|
var LOCKED_ALPHA = 51;
|
|
|
|
var STYLE_TYPE = {};
|
|
STYLE_TYPE.WHOLE = STATE_FLAG_WHOLE;
|
|
STYLE_TYPE.HEADER = STATE_FLAG_HEADER;
|
|
STYLE_TYPE.SELECTED_DATA = STATE_FLAG_SELECTED | STATE_FLAG_DATA | 0;
|
|
STYLE_TYPE.SELECTED_NO_DATA = STATE_FLAG_SELECTED | 0 | 0;
|
|
STYLE_TYPE.UNSELECTED_DATA = 0 | STATE_FLAG_DATA | 0;
|
|
STYLE_TYPE.UNSELECTED_NO_DATA = 0 | 0 | 0;
|
|
STYLE_TYPE.HOVERED_SELECTED_DATA = STATE_FLAG_SELECTED | STATE_FLAG_DATA | STATE_FLAG_HOVERED;
|
|
STYLE_TYPE.HOVERED_SELECTED_NO_DATA = STATE_FLAG_SELECTED | 0 | STATE_FLAG_HOVERED;
|
|
STYLE_TYPE.HOVERED_UNSELECTED_DATA = 0 | STATE_FLAG_DATA | STATE_FLAG_HOVERED;
|
|
STYLE_TYPE.HOVERED_UNSELECTED_NO_DATA = 0 | 0 | STATE_FLAG_HOVERED;
|
|
|
|
var SCROLL_COLORS = {};
|
|
SCROLL_COLORS[STYLE_TYPE.WHOLE] = 0xF1F1F1;
|
|
SCROLL_COLORS[STYLE_TYPE.HEADER] = 0xF1F1F1;
|
|
SCROLL_COLORS[STYLE_TYPE.SELECTED_DATA] = 0xADADAD;
|
|
SCROLL_COLORS[STYLE_TYPE.SELECTED_NO_DATA] = 0xADADAD;
|
|
SCROLL_COLORS[STYLE_TYPE.UNSELECTED_DATA] = 0xF1F1F1;
|
|
SCROLL_COLORS[STYLE_TYPE.UNSELECTED_NO_DATA] = 0xF1F1F1;
|
|
SCROLL_COLORS[STYLE_TYPE.HOVERED_SELECTED_DATA] = 0xADADAD;
|
|
SCROLL_COLORS[STYLE_TYPE.HOVERED_SELECTED_NO_DATA] = 0xADADAD;
|
|
SCROLL_COLORS[STYLE_TYPE.HOVERED_UNSELECTED_DATA] = 0xCFCFCF;
|
|
SCROLL_COLORS[STYLE_TYPE.HOVERED_UNSELECTED_NO_DATA] = 0xCFCFCF;
|
|
|
|
var SCROLL_BUTTON_TYPE_LEFT = 0;
|
|
var SCROLL_BUTTON_TYPE_TOP = 1;
|
|
var SCROLL_BUTTON_TYPE_RIGHT = 2;
|
|
var SCROLL_BUTTON_TYPE_BOTTOM = 3;
|
|
|
|
var SCROLL_ARROW_COLORS = {};
|
|
SCROLL_ARROW_COLORS[STYLE_TYPE.WHOLE] = 0xF1F1F1;
|
|
SCROLL_ARROW_COLORS[STYLE_TYPE.HEADER] = 0xF1F1F1;
|
|
SCROLL_ARROW_COLORS[STYLE_TYPE.SELECTED_DATA] = 0xFFFFFF;
|
|
SCROLL_ARROW_COLORS[STYLE_TYPE.SELECTED_NO_DATA] = 0xFFFFFF;
|
|
SCROLL_ARROW_COLORS[STYLE_TYPE.UNSELECTED_DATA] = 0xADADAD;
|
|
SCROLL_ARROW_COLORS[STYLE_TYPE.UNSELECTED_NO_DATA] = 0xADADAD;
|
|
SCROLL_ARROW_COLORS[STYLE_TYPE.HOVERED_SELECTED_DATA] = 0xFFFFFF;
|
|
SCROLL_ARROW_COLORS[STYLE_TYPE.HOVERED_SELECTED_NO_DATA] = 0xFFFFFF;
|
|
SCROLL_ARROW_COLORS[STYLE_TYPE.HOVERED_UNSELECTED_DATA] = 0xFFFFFF;
|
|
SCROLL_ARROW_COLORS[STYLE_TYPE.HOVERED_UNSELECTED_NO_DATA] = 0xFFFFFF;
|
|
|
|
var HEADER_BUTTON_COLORS = {};
|
|
HEADER_BUTTON_COLORS[STYLE_TYPE.WHOLE] = null;
|
|
HEADER_BUTTON_COLORS[STYLE_TYPE.HEADER] = null;
|
|
HEADER_BUTTON_COLORS[STYLE_TYPE.SELECTED_DATA] = 0x7D858C;
|
|
HEADER_BUTTON_COLORS[STYLE_TYPE.SELECTED_NO_DATA] = 0x7D858C;
|
|
HEADER_BUTTON_COLORS[STYLE_TYPE.UNSELECTED_DATA] = null;
|
|
HEADER_BUTTON_COLORS[STYLE_TYPE.UNSELECTED_NO_DATA] = null;
|
|
HEADER_BUTTON_COLORS[STYLE_TYPE.HOVERED_SELECTED_DATA] = 0x7D858C;
|
|
HEADER_BUTTON_COLORS[STYLE_TYPE.HOVERED_SELECTED_NO_DATA] = 0x7D858C;
|
|
HEADER_BUTTON_COLORS[STYLE_TYPE.HOVERED_UNSELECTED_DATA] = 0xD8DADC;
|
|
HEADER_BUTTON_COLORS[STYLE_TYPE.HOVERED_UNSELECTED_NO_DATA] = 0xD8DADC;
|
|
|
|
var ICON_MULTISELECT = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjAiIGhlaWdodD0iMjAiIHZpZXdCb3g9IjAgMCAyMCAyMCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4NCjxwYXRoIGZpbGwtcnVsZT0iZXZlbm9kZCIgY2xpcC1ydWxlPSJldmVub2RkIiBkPSJNNCA1QzQgNC40NDc3MiA0LjQ0NzcyIDQgNSA0SDE1QzE1LjU1MjMgNCAxNiA0LjQ0NzcyIDE2IDVWNkMxNiA2LjU1MjI4IDE1LjU1MjMgNyAxNSA3SDVDNC40NDc3MiA3IDQgNi41NTIyOCA0IDZWNVpNMTUgMTNINUw1IDE0SDE1VjEzWk01IDEyQzQuNDQ3NzIgMTIgNCAxMi40NDc3IDQgMTNWMTRDNCAxNC41NTIzIDQuNDQ3NzIgMTUgNSAxNUgxNUMxNS41NTIzIDE1IDE2IDE0LjU1MjMgMTYgMTRWMTNDMTYgMTIuNDQ3NyAxNS41NTIzIDEyIDE1IDEySDVaTTUgOEM0LjQ0NzcyIDggNCA4LjQ0NzcyIDQgOVYxMEM0IDEwLjU1MjMgNC40NDc3MiAxMSA1IDExSDE1QzE1LjU1MjMgMTEgMTYgMTAuNTUyMyAxNiAxMFY5QzE2IDguNDQ3NzIgMTUuNTUyMyA4IDE1IDhINVoiIGZpbGw9IiM0NDQ0NDQiLz4NCjwvc3ZnPg0K";
|
|
var ICON_MULTISELECT_INVERTED = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjAiIGhlaWdodD0iMjAiIHZpZXdCb3g9IjAgMCAyMCAyMCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4NCjxwYXRoIGZpbGwtcnVsZT0iZXZlbm9kZCIgY2xpcC1ydWxlPSJldmVub2RkIiBkPSJNNCA1QzQgNC40NDc3MiA0LjQ0NzcyIDQgNSA0SDE1QzE1LjU1MjMgNCAxNiA0LjQ0NzcyIDE2IDVWNkMxNiA2LjU1MjI4IDE1LjU1MjMgNyAxNSA3SDVDNC40NDc3MiA3IDQgNi41NTIyOCA0IDZWNVpNMTUgMTNINUw1IDE0SDE1VjEzWk01IDEyQzQuNDQ3NzIgMTIgNCAxMi40NDc3IDQgMTNWMTRDNCAxNC41NTIzIDQuNDQ3NzIgMTUgNSAxNUgxNUMxNS41NTIzIDE1IDE2IDE0LjU1MjMgMTYgMTRWMTNDMTYgMTIuNDQ3NyAxNS41NTIzIDEyIDE1IDEySDVaTTUgOEM0LjQ0NzcyIDggNCA4LjQ0NzcyIDQgOVYxMEM0IDEwLjU1MjMgNC40NDc3MiAxMSA1IDExSDE1QzE1LjU1MjMgMTEgMTYgMTAuNTUyMyAxNiAxMFY5QzE2IDguNDQ3NzIgMTUuNTUyMyA4IDE1IDhINVoiIGZpbGw9IndoaXRlIi8+DQo8L3N2Zz4NCg==";
|
|
var ICON_CLEAR_FILTER = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjAiIGhlaWdodD0iMjAiIHZpZXdCb3g9IjAgMCAyMCAyMCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4NCjxwYXRoIGZpbGwtcnVsZT0iZXZlbm9kZCIgY2xpcC1ydWxlPSJldmVub2RkIiBkPSJNMTAgMTZMOCAxNFYxMEwzIDVIMTVMMTAgMTBWMTZaTTE2LjE0NjQgMTYuODUzNkwxNC41IDE1LjIwNzFMMTIuODUzNiAxNi44NTM2TDEyLjE0NjQgMTYuMTQ2NUwxMy43OTI5IDE0LjVMMTIuMTQ2NCAxMi44NTM2TDEyLjg1MzYgMTIuMTQ2NUwxNC41IDEzLjc5MjlMMTYuMTQ2NCAxMi4xNDY1TDE2Ljg1MzYgMTIuODUzNkwxNS4yMDcxIDE0LjVMMTYuODUzNiAxNi4xNDY1TDE2LjE0NjQgMTYuODUzNloiIGZpbGw9IiM0NDQ0NDQiLz4NCjwvc3ZnPg0K";
|
|
var ICON_CLEAR_FILTER_DISABLED = "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjAiIGhlaWdodD0iMjAiIHZpZXdCb3g9IjAgMCAyMCAyMCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4NCjxnIG9wYWNpdHk9IjAuNCI+DQo8cGF0aCBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGNsaXAtcnVsZT0iZXZlbm9kZCIgZD0iTTEwIDE2TDggMTRWMTBMMyA1SDE1TDEwIDEwVjE2Wk0xNi4xNDY0IDE2Ljg1MzZMMTQuNSAxNS4yMDcxTDEyLjg1MzYgMTYuODUzNkwxMi4xNDY0IDE2LjE0NjVMMTMuNzkyOSAxNC41TDEyLjE0NjQgMTIuODUzNkwxMi44NTM2IDEyLjE0NjVMMTQuNSAxMy43OTI5TDE2LjE0NjQgMTIuMTQ2NUwxNi44NTM2IDEyLjg1MzZMMTUuMjA3MSAxNC41TDE2Ljg1MzYgMTYuMTQ2NUwxNi4xNDY0IDE2Ljg1MzZaIiBmaWxsPSIjNDQ0NDQ0Ii8+DQo8L2c+DQo8L3N2Zz4NCg==";
|
|
|
|
var oDefaultWrapObject = {oTxWarpStruct: null, oTxWarpStructParamarks: null, oTxWarpStructNoTransform: null, oTxWarpStructParamarksNoTransform: null};
|
|
|
|
|
|
function getSlicerIconsForLoad() {
|
|
return [ICON_MULTISELECT, ICON_MULTISELECT_INVERTED, ICON_CLEAR_FILTER, ICON_CLEAR_FILTER_DISABLED];
|
|
}
|
|
|
|
function getGraphicsScale(graphics) {
|
|
var vector_koef;
|
|
if(graphics.m_oCoordTransform) {
|
|
vector_koef = 1.0 / graphics.m_oCoordTransform.sx;
|
|
}
|
|
else {
|
|
var zoom = 1, ppiX = 96;
|
|
if (window.Asc && window.Asc.editor) {
|
|
zoom = window.Asc.editor.asc_getZoom();
|
|
}
|
|
vector_koef = 25.4 / (ppiX * zoom);
|
|
vector_koef /= AscCommon.AscBrowser.retinaPixelRatio;
|
|
}
|
|
return vector_koef;
|
|
}
|
|
function setGraphicsSettings(graphics, oBorderPr, oLastBorderPr) {
|
|
var oColor = oBorderPr.c || new AscCommonExcel.RgbColor(0);
|
|
var oLastColor = null;
|
|
if(oLastBorderPr) {
|
|
oLastColor = oLastBorderPr.c || new AscCommonExcel.RgbColor(0);
|
|
}
|
|
if(!oColor.isEqual(oLastColor)) {
|
|
graphics.p_color(oColor.getR(), oColor.getG(), oColor.getB(), 255);
|
|
}
|
|
var nW = oBorderPr.w, dW;
|
|
if(!AscFormat.isRealNumber(nW)) {
|
|
nW = 1;
|
|
}
|
|
var vector_koef;
|
|
vector_koef = getGraphicsScale(graphics);
|
|
dW = nW * vector_koef;
|
|
if(!oLastBorderPr || oBorderPr.s !== oLastBorderPr.s) {
|
|
var aDash = oBorderPr.getDashSegments();
|
|
if(!graphics.m_oCoordTransform) {
|
|
if(!AscFormat.isRealNumber(vector_koef)) {
|
|
vector_koef = getGraphicsScale(graphics);
|
|
}
|
|
for(var nSegment = 0; nSegment < aDash.length; ++nSegment) {
|
|
aDash[nSegment] *= vector_koef;
|
|
}
|
|
}
|
|
graphics.p_dash(aDash);
|
|
}
|
|
return dW;
|
|
}
|
|
function drawHorBorder(graphics, oBorderPr, oPrevBorderPr, align, y, x, r) {
|
|
var oLastBorderPr = null;
|
|
if(oBorderPr && oBorderPr.s !== Asc.c_oAscBorderStyles.None) {
|
|
graphics.drawHorLine(align, y, x, r, setGraphicsSettings(graphics, oBorderPr, oPrevBorderPr));
|
|
oLastBorderPr = oBorderPr;
|
|
}
|
|
return oLastBorderPr;
|
|
}
|
|
function drawVerBorder(graphics, oBorderPr, oPrevBorderPr, align, x, y, b) {
|
|
var oLastBorderPr = null;
|
|
if(oBorderPr && oBorderPr.s !== Asc.c_oAscBorderStyles.None) {
|
|
graphics.drawVerLine(align, x, y, b, setGraphicsSettings(graphics, oBorderPr, oPrevBorderPr));
|
|
oLastBorderPr = oBorderPr;
|
|
}
|
|
return oLastBorderPr;
|
|
}
|
|
|
|
function CSlicerCache() {
|
|
this.view = null;
|
|
this.values = null;
|
|
this.locked = false;
|
|
this.styleName = null;
|
|
}
|
|
CSlicerCache.prototype.setView = function(oView) {
|
|
this.view = oView;
|
|
};
|
|
CSlicerCache.prototype.setValues = function(oValues) {
|
|
this.values = oValues;
|
|
};
|
|
CSlicerCache.prototype.setLocked = function(bVal) {
|
|
this.locked = bVal;
|
|
};
|
|
CSlicerCache.prototype.setStyleName = function(sVal) {
|
|
this.styleName = sVal;
|
|
};
|
|
CSlicerCache.prototype.getView = function() {
|
|
return this.view;
|
|
};
|
|
CSlicerCache.prototype.getValues = function() {
|
|
if(Array.isArray(this.values)) {
|
|
return this.values;
|
|
}
|
|
return [];
|
|
};
|
|
CSlicerCache.prototype.getLocked = function() {
|
|
return this.locked;
|
|
};
|
|
CSlicerCache.prototype.getStyleName = function() {
|
|
return this.styleName;
|
|
};
|
|
CSlicerCache.prototype.clear = function() {
|
|
this.values = null;
|
|
this.view = null;
|
|
this.styleName = null;
|
|
};
|
|
CSlicerCache.prototype.hasData = function() {
|
|
return this.values !== null && this.view !== null;
|
|
};
|
|
CSlicerCache.prototype.save = function() {
|
|
var oRet = new CSlicerCache();
|
|
if(this.values) {
|
|
oRet.values = this.values;
|
|
}
|
|
if(this.view) {
|
|
oRet.view = this.view;
|
|
}
|
|
if(this.styleName) {
|
|
oRet.styleName = this.styleName;
|
|
}
|
|
return oRet;
|
|
};
|
|
CSlicerCache.prototype.getValues = function() {
|
|
if(Array.isArray(this.values)) {
|
|
return this.values;
|
|
}
|
|
return [];
|
|
};
|
|
CSlicerCache.prototype.getValuesCount = function () {
|
|
return this.getValues().length;
|
|
};
|
|
CSlicerCache.prototype.getCaption = function() {
|
|
if(this.view && typeof this.view.caption === "string") {
|
|
return this.view.caption;
|
|
}
|
|
return "";
|
|
};
|
|
CSlicerCache.prototype.getShowCaption = function() {
|
|
if(this.view) {
|
|
return this.view.showCaption !== false;
|
|
}
|
|
return false;
|
|
};
|
|
CSlicerCache.prototype.getColumnsCount = function() {
|
|
if(this.view && AscFormat.isRealNumber(this.view.columnCount)) {
|
|
return this.view.columnCount;
|
|
}
|
|
return 1;
|
|
};
|
|
CSlicerCache.prototype.getButtonHeight = function() {
|
|
if(this.view && AscFormat.isRealNumber(this.view.rowHeight)) {
|
|
return this.view.rowHeight * g_dKoef_emu_to_mm;
|
|
}
|
|
return 0.26 * 25.4;
|
|
};
|
|
CSlicerCache.prototype.getValue = function (nIndex) {
|
|
if(nIndex > -1 && nIndex < this.getValuesCount()) {
|
|
return this.getValues()[nIndex];
|
|
}
|
|
return null;
|
|
};
|
|
CSlicerCache.prototype.getVal = function(oValue) {
|
|
if(!oValue) {
|
|
return null;
|
|
}
|
|
return oValue.val;
|
|
};
|
|
CSlicerCache.prototype.getHiddenByOther = function(oValue) {
|
|
if(!oValue) {
|
|
return false;
|
|
}
|
|
return oValue.hiddenByOtherColumns === true;
|
|
};
|
|
CSlicerCache.prototype.getVisible = function(oValue) {
|
|
if(!oValue) {
|
|
return null;
|
|
}
|
|
return oValue.visible !== false;
|
|
};
|
|
CSlicerCache.prototype.getString = function (nIndex) {
|
|
var oValue = this.getValue(nIndex);
|
|
if(oValue && typeof oValue.text === "string" && oValue.text.length > 0) {
|
|
return oValue.text;
|
|
}
|
|
return AscCommon.translateManager.getValue("(blank)");
|
|
};
|
|
|
|
function CSlicerData(slicer) {
|
|
CSlicerCache.call(this);
|
|
this.slicer = slicer;
|
|
}
|
|
CSlicerData.prototype = Object.create(CSlicerCache.prototype);
|
|
CSlicerData.prototype.constructor = CSlicerData;
|
|
CSlicerData.prototype.updateData = function() {
|
|
this.clear();
|
|
var oData = this.retrieveData();
|
|
this.values = oData.getValues();
|
|
this.view = oData.getView();
|
|
this.styleName = oData.getStyleName();
|
|
};
|
|
CSlicerData.prototype.retrieveData = function() {
|
|
var oData = new CSlicerCache();
|
|
var oWorkbook = this.slicer.getWorkbook();
|
|
if(!oWorkbook) {
|
|
return oData;
|
|
}
|
|
var sName = this.slicer.getName();
|
|
var oView = oWorkbook.getSlicerByName(sName);
|
|
if(!oView) {
|
|
return oData;
|
|
}
|
|
var oCache = oView.getCacheDefinition();
|
|
if(!oCache) {
|
|
return oData;
|
|
}
|
|
var oValues = oCache.getFilterValues();
|
|
if(!oValues || !Array.isArray(oValues.values)) {
|
|
return oData
|
|
}
|
|
oData.setValues(oValues.values);
|
|
oData.setView(oView.clone());
|
|
oData.setStyleName(this.slicer.getStyleName());
|
|
return oData;
|
|
};
|
|
CSlicerData.prototype.checkData = function() {
|
|
if(!this.hasData()) {
|
|
this.updateData();
|
|
}
|
|
};
|
|
CSlicerData.prototype.getValues = function() {
|
|
this.checkData();
|
|
return CSlicerCache.prototype.getValues.call(this);
|
|
};
|
|
CSlicerData.prototype.getCaption = function() {
|
|
this.checkData();
|
|
return CSlicerCache.prototype.getCaption.call(this);
|
|
};
|
|
CSlicerData.prototype.getShowCaption = function() {
|
|
this.checkData();
|
|
return CSlicerCache.prototype.getShowCaption.call(this);
|
|
};
|
|
CSlicerData.prototype.getColumnsCount = function() {
|
|
this.checkData();
|
|
return CSlicerCache.prototype.getColumnsCount.call(this);
|
|
};
|
|
CSlicerData.prototype.getButtonHeight = function() {
|
|
this.checkData();
|
|
return CSlicerCache.prototype.getButtonHeight.call(this);
|
|
};
|
|
CSlicerData.prototype.getButtonState = function (nIndex) {
|
|
var oValue = this.getValue(nIndex);
|
|
if(oValue) {
|
|
var nState = 0;
|
|
if(this.getHiddenByOther(oValue) === false) {
|
|
nState |= STATE_FLAG_DATA;
|
|
}
|
|
if(this.getVisible(oValue) !== false) {
|
|
nState |=STATE_FLAG_SELECTED;
|
|
}
|
|
|
|
return nState;
|
|
}
|
|
return STYLE_TYPE.WHOLE;
|
|
};
|
|
CSlicerData.prototype.isAllValuesSelected = function () {
|
|
var nCount = this.getValuesCount();
|
|
for(var nValue = 0; nValue < nCount; ++nValue) {
|
|
var oValue = this.getValue(nValue);
|
|
if(oValue && oValue.visible === false) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
CSlicerData.prototype.onViewUpdate = function () {
|
|
var oWorksheet = this.slicer.getWorksheet();
|
|
if(!oWorksheet) {
|
|
this.slicer.removeAllButtonsTmpState();
|
|
return;
|
|
}
|
|
if(this.slicer.getLocked()) {
|
|
this.slicer.removeAllButtonsTmpState();
|
|
return;
|
|
}
|
|
var oData = this.retrieveData();
|
|
var aValues = oData.getValues();
|
|
var nValuesCount = aValues.length, nValue, oValue, oApplyValue, nButtonState;
|
|
var aValuesToApply = [];
|
|
var bNeedUpdate = false, bVisible;
|
|
for(nValue = 0; nValue < nValuesCount; ++nValue) {
|
|
oValue = aValues[nValue];
|
|
if(!oValue) {
|
|
break;
|
|
}
|
|
nButtonState = this.slicer.getViewButtonState(nValue);
|
|
if(nButtonState === null) {
|
|
break;
|
|
}
|
|
oApplyValue = oValue.clone();
|
|
bVisible = (nButtonState & STATE_FLAG_SELECTED) !== 0;
|
|
if(this.getVisible(oValue) !== bVisible) {
|
|
oApplyValue.asc_setVisible(bVisible);
|
|
bNeedUpdate = true;
|
|
}
|
|
aValuesToApply.push(oApplyValue);
|
|
}
|
|
if(bNeedUpdate) {
|
|
if(this.slicer.isSubscribed()) {
|
|
this.values = aValuesToApply;
|
|
}
|
|
else {
|
|
Asc.editor.wb.setFilterValuesFromSlicer(this.slicer.getName(), aValuesToApply);
|
|
}
|
|
}
|
|
else {
|
|
this.slicer.removeAllButtonsTmpState();
|
|
}
|
|
};
|
|
CSlicerData.prototype.onDataUpdate = function() {
|
|
if(AscCommon.isFileBuild()) {
|
|
return;
|
|
}
|
|
var oOldCache = this.save();
|
|
this.clear();
|
|
if(this.needUpdateValues(oOldCache)) {
|
|
this.slicer.handleUpdateExtents();
|
|
this.slicer.handleUpdateFill();
|
|
this.slicer.handleUpdateLn();
|
|
this.slicer.recalculate();
|
|
}
|
|
else {
|
|
this.slicer.removeAllButtonsTmpState();
|
|
}
|
|
this.slicer.unsubscribeFromEvents();
|
|
this.slicer.onUpdate(this.slicer.bounds);
|
|
};
|
|
CSlicerData.prototype.needUpdateValues = function(oOldCache) {
|
|
var nCount = this.getValuesCount();
|
|
if(nCount !== oOldCache.getValuesCount()) {
|
|
return true;
|
|
}
|
|
for(var nValue = 0; nValue < nCount; ++nValue) {
|
|
if(this.getString(nValue) !== oOldCache.getString(nValue)) {
|
|
return true;
|
|
}
|
|
}
|
|
if(!AscFormat.fApproxEqual(this.getButtonHeight(), oOldCache.getButtonHeight())) {
|
|
return true;
|
|
}
|
|
if(this.getColumnsCount() !== oOldCache.getColumnsCount()) {
|
|
return true;
|
|
}
|
|
if(this.getShowCaption() !== oOldCache.getShowCaption()) {
|
|
return true;
|
|
}
|
|
if(this.getCaption() !== oOldCache.getCaption()) {
|
|
return true;
|
|
}
|
|
if(this.getStyleName() !== oOldCache.getStyleName()) {
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
|
|
function CSlicer() {
|
|
AscFormat.CShape.call(this);
|
|
this.name = null;
|
|
|
|
this.recalcInfo.recalculateHeader = true;
|
|
this.recalcInfo.recalculateButtons = true;
|
|
this.header = null;
|
|
|
|
this.data = new CSlicerData(this);
|
|
|
|
AscFormat.ExecuteNoHistory(function() {
|
|
this.txStyles = new CStyles(false);
|
|
}, this, []);
|
|
|
|
this.buttonsContainer = null;
|
|
|
|
this.eventListener = null;
|
|
}
|
|
CSlicer.prototype = Object.create(AscFormat.CShape.prototype);
|
|
CSlicer.prototype.constructor = CSlicer;
|
|
CSlicer.prototype.getObjectType = function () {
|
|
return AscDFH.historyitem_type_SlicerView;
|
|
};
|
|
CSlicer.prototype.toStream = function (s) {
|
|
s.WriteUChar(AscCommon.g_nodeAttributeStart);
|
|
s._WriteString2(0, this.name);
|
|
s.WriteUChar(AscCommon.g_nodeAttributeEnd);
|
|
};
|
|
CSlicer.prototype.fromStream = function (s) {
|
|
var _len = s.GetULong();
|
|
var _start_pos = s.cur;
|
|
var _end_pos = _len + _start_pos;
|
|
var _at;
|
|
// attributes
|
|
s.GetUChar();
|
|
while (true) {
|
|
_at = s.GetUChar();
|
|
if (_at === AscCommon.g_nodeAttributeEnd)
|
|
break;
|
|
switch (_at) {
|
|
case 0: {
|
|
this.setName(s.GetString2());
|
|
break;
|
|
}
|
|
default: {
|
|
s.Seek2(_end_pos);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
s.Seek2(_end_pos);
|
|
};
|
|
CSlicer.prototype.setName = function(val) {
|
|
History.Add(new AscDFH.CChangesDrawingsString(this, AscDFH.historyitem_SlicerViewName, this.name, val));
|
|
this.name = val;
|
|
};
|
|
CSlicer.prototype.getName = function() {
|
|
return this.name;
|
|
};
|
|
CSlicer.prototype.getViewButtonsCount = function () {
|
|
if(!this.buttonsContainer) {
|
|
return 0;
|
|
}
|
|
return this.buttonsContainer.getViewButtonsCount();
|
|
};
|
|
CSlicer.prototype.getViewButtonState = function(nIndex) {
|
|
if(!this.buttonsContainer) {
|
|
return null;
|
|
}
|
|
return this.buttonsContainer.getViewButtonState(nIndex);
|
|
};
|
|
CSlicer.prototype.getStyleName = function() {
|
|
var oWorkbook = this.getWorkbook();
|
|
if(!oWorkbook) {
|
|
return null;
|
|
}
|
|
var oSlicerStyles = oWorkbook.SlicerStyles;
|
|
var sStyleName = oWorkbook.getSlicerStyle(this.name);
|
|
if(!sStyleName) {
|
|
sStyleName = oSlicerStyles.DefaultStyle;
|
|
}
|
|
return sStyleName;
|
|
};
|
|
CSlicer.prototype.getDXF = function(nType) {
|
|
var oWorkbook = this.getWorkbook();
|
|
if(!oWorkbook) {
|
|
return null;
|
|
}
|
|
var sStyleName = this.getStyleName();
|
|
if(!sStyleName) {
|
|
return null;
|
|
}
|
|
var oSlicerStyles = oWorkbook.SlicerStyles;
|
|
var oTableStyles = oWorkbook.TableStyles;
|
|
var oStyle;
|
|
var oDXF = null;
|
|
if(nType === STYLE_TYPE.WHOLE || nType === STYLE_TYPE.HEADER) {
|
|
oStyle = oTableStyles.AllStyles[sStyleName];
|
|
if(!oStyle) {
|
|
oStyle = oTableStyles.AllStyles[oTableStyles.DefaultTableStyle];
|
|
}
|
|
if(oStyle) {
|
|
if(nType === STYLE_TYPE.WHOLE) {
|
|
if(oStyle.wholeTable) {
|
|
oDXF = oStyle.wholeTable.dxf;
|
|
}
|
|
}
|
|
else {
|
|
if(oStyle.headerRow) {
|
|
oDXF = oStyle.headerRow.dxf;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
oStyle = oSlicerStyles.AllStyles[sStyleName];
|
|
if(!oStyle) {
|
|
oStyle = oSlicerStyles.AllStyles[oSlicerStyles.DefaultStyle];
|
|
}
|
|
if(oStyle) {
|
|
switch (nType) {
|
|
case STYLE_TYPE.HOVERED_SELECTED_NO_DATA: {
|
|
oDXF = oStyle[Asc.ST_slicerStyleType.hoveredSelectedItemWithNoData];
|
|
break;
|
|
}
|
|
case STYLE_TYPE.HOVERED_UNSELECTED_NO_DATA: {
|
|
oDXF = oStyle[Asc.ST_slicerStyleType.hoveredUnselectedItemWithNoData];
|
|
break;
|
|
}
|
|
case STYLE_TYPE.HOVERED_SELECTED_DATA: {
|
|
oDXF = oStyle[Asc.ST_slicerStyleType.hoveredSelectedItemWithData];
|
|
break;
|
|
}
|
|
case STYLE_TYPE.HOVERED_UNSELECTED_DATA: {
|
|
oDXF = oStyle[Asc.ST_slicerStyleType.hoveredUnselectedItemWithData];
|
|
break;
|
|
}
|
|
case STYLE_TYPE.SELECTED_NO_DATA: {
|
|
oDXF = oStyle[Asc.ST_slicerStyleType.selectedItemWithNoData];
|
|
break;
|
|
}
|
|
case STYLE_TYPE.SELECTED_DATA: {
|
|
oDXF = oStyle[Asc.ST_slicerStyleType.selectedItemWithData];
|
|
break;
|
|
}
|
|
case STYLE_TYPE.UNSELECTED_NO_DATA: {
|
|
oDXF = oStyle[Asc.ST_slicerStyleType.unselectedItemWithNoData];
|
|
break;
|
|
}
|
|
case STYLE_TYPE.UNSELECTED_DATA: {
|
|
oDXF = oStyle[Asc.ST_slicerStyleType.unselectedItemWithData];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return oDXF;
|
|
};
|
|
CSlicer.prototype.getFont = function(nType) {
|
|
var oFont = null;
|
|
var oDXF = this.getDXF(nType);
|
|
if(oDXF) {
|
|
oFont = oDXF.getFont();
|
|
if(oFont) {
|
|
return oFont;
|
|
}
|
|
}
|
|
oDXF = this.getDXF(STYLE_TYPE.WHOLE);
|
|
if(oDXF) {
|
|
return oDXF.getFont2();
|
|
}
|
|
return AscCommonExcel.g_oDefaultFormat.Font;
|
|
};
|
|
CSlicer.prototype.getFill = function(nType) {
|
|
var oFill;
|
|
var oDXF = this.getDXF(nType);
|
|
if(oDXF) {
|
|
oFill = oDXF.getFill();
|
|
if(oFill) {
|
|
return oFill;
|
|
}
|
|
}
|
|
if(nType !== STYLE_TYPE.WHOLE) {
|
|
return null;
|
|
}
|
|
oFill = new AscCommonExcel.Fill();
|
|
oFill.fromColor(new AscCommonExcel.RgbColor(0xFFFFFF));
|
|
return oFill;
|
|
};
|
|
CSlicer.prototype.getBorder = function(nType) {
|
|
var oBorder;
|
|
var oDXF = this.getDXF(nType);
|
|
if(oDXF) {
|
|
return oDXF.getBorder();
|
|
}
|
|
|
|
oDXF = this.getDXF(STYLE_TYPE.WHOLE);
|
|
if(oDXF) {
|
|
return oDXF.getBorder();
|
|
}
|
|
var r = 91, g = 155, b = 213;
|
|
if(nType !== STYLE_TYPE.HEADER && nType !== STYLE_TYPE.WHOLE) {
|
|
r = 204;
|
|
g = 204;
|
|
b = 204;
|
|
}
|
|
oBorder = new AscCommonExcel.Border();
|
|
oBorder.initDefault();
|
|
if(nType !== STYLE_TYPE.HEADER) {
|
|
oBorder.l = new AscCommonExcel.BorderProp();
|
|
oBorder.l.setStyle(Asc.c_oAscBorderStyles.Thin);
|
|
oBorder.l.c = AscCommonExcel.createRgbColor(r, g, b);
|
|
oBorder.t = new AscCommonExcel.BorderProp();
|
|
oBorder.t.setStyle(Asc.c_oAscBorderStyles.Thin);
|
|
oBorder.t.c = AscCommonExcel.createRgbColor(r, g, b);
|
|
oBorder.r = new AscCommonExcel.BorderProp();
|
|
oBorder.r.setStyle(Asc.c_oAscBorderStyles.Thin);
|
|
oBorder.r.c = AscCommonExcel.createRgbColor(r, g, b);
|
|
}
|
|
oBorder.b = new AscCommonExcel.BorderProp();
|
|
oBorder.b.setStyle(Asc.c_oAscBorderStyles.Thin);
|
|
oBorder.b.c = AscCommonExcel.createRgbColor(r, g, b);
|
|
return oBorder;
|
|
};
|
|
CSlicer.prototype.recalculateBrush = function() {
|
|
var oFill = this.getFill(STYLE_TYPE.WHOLE);
|
|
var oParents = this.getParentObjects();
|
|
this.brush = AscCommonExcel.convertFillToUnifill(oFill);
|
|
this.brush.calculate(oParents.theme, oParents.slide, oParents.layout, oParents.master, {R:0, G:0, B:0, A: 255});
|
|
};
|
|
CSlicer.prototype.recalculatePen = function() {
|
|
this.pen = null;
|
|
};
|
|
CSlicer.prototype.recalculateGeometry = function() {
|
|
this.calcGeometry = AscFormat.CreateGeometry("rect");
|
|
this.calcGeometry.Recalculate(this.extX, this.extY);
|
|
};
|
|
CSlicer.prototype.canRotate = function() {
|
|
return false;
|
|
};
|
|
CSlicer.prototype.recalculate = function () {
|
|
if(AscCommon.isFileBuild()) {
|
|
return;
|
|
}
|
|
|
|
//--------------For bug 46500--------------------
|
|
var bCollaborativeChanges = false;
|
|
var oWorkbook = this.getWorkbook();
|
|
if(oWorkbook) {
|
|
bCollaborativeChanges = oWorkbook.bCollaborativeChanges;
|
|
}
|
|
if(AscFonts.IsCheckSymbols && bCollaborativeChanges) {
|
|
return;
|
|
}
|
|
//-------------------------------------------------
|
|
|
|
AscFormat.ExecuteNoHistory(function () {
|
|
AscFormat.CShape.prototype.recalculate.call(this);
|
|
if(this.recalcInfo.recalculateHeader) {
|
|
this.recalculateHeader();
|
|
this.recalcInfo.recalculateHeader = false;
|
|
}
|
|
if(this.recalcInfo.recalculateButtons) {
|
|
this.recalculateButtons();
|
|
this.recalcInfo.recalculateButtons = false;
|
|
}
|
|
|
|
}, this, []);
|
|
};
|
|
CSlicer.prototype.recalculateHeader = function() {
|
|
var bShowHeader = this.getShowCaption();
|
|
if(!bShowHeader) {
|
|
this.header = null;
|
|
return;
|
|
}
|
|
if(!this.header) {
|
|
this.header = new CHeader(this);
|
|
}
|
|
this.header.worksheet = this.worksheet;
|
|
this.header.setRecalculateInfo();
|
|
this.header.recalculate();
|
|
};
|
|
CSlicer.prototype.getButtonsContainerWidth = function() {
|
|
return Math.max(this.extX - LEFT_PADDING - RIGHT_PADDING, 0);
|
|
};
|
|
CSlicer.prototype.getButtonsContainerHeight = function() {
|
|
var nHeight = this.extY;
|
|
if(this.header) {
|
|
nHeight -= this.header.extY;
|
|
}
|
|
return Math.max(nHeight - TOP_PADDING - BOTTOM_PADDING, 0);
|
|
};
|
|
CSlicer.prototype.getWidthByButton = function(dBWidth) {
|
|
if(this.buttonsContainer) {
|
|
var dBContainerW = this.buttonsContainer.getWidthByButton(dBWidth);
|
|
return dBContainerW + LEFT_PADDING + RIGHT_PADDING;
|
|
}
|
|
else {
|
|
return this.extX;
|
|
}
|
|
};
|
|
CSlicer.prototype.recalculateButtons = function() {
|
|
if(!this.buttonsContainer) {
|
|
this.buttonsContainer = new CButtonsContainer(this);
|
|
}
|
|
this.buttonsContainer.clear();
|
|
var nValuesCount = this.getValuesCount();
|
|
for(var nValue = 0; nValue < nValuesCount; ++nValue) {
|
|
this.buttonsContainer.addButton(new CButton(this.buttonsContainer));
|
|
}
|
|
this.buttonsContainer.x = LEFT_PADDING;
|
|
this.buttonsContainer.y = TOP_PADDING;
|
|
if(this.header) {
|
|
this.buttonsContainer.y += this.header.extY;
|
|
}
|
|
this.buttonsContainer.extX = this.getButtonsContainerWidth();
|
|
this.buttonsContainer.extY = this.getButtonsContainerHeight();
|
|
this.buttonsContainer.recalculate();
|
|
};
|
|
CSlicer.prototype.getColumnsCount = function() {
|
|
return this.data.getColumnsCount();
|
|
};
|
|
CSlicer.prototype.getCaption = function() {
|
|
return this.data.getCaption();
|
|
};
|
|
CSlicer.prototype.getButtonHeight = function() {
|
|
return this.data.getButtonHeight();
|
|
};
|
|
CSlicer.prototype.getShowCaption = function() {
|
|
return this.data.getShowCaption();
|
|
};
|
|
CSlicer.prototype.getTxStyles = function (nType) {
|
|
var oFont = this.getFont(nType);
|
|
if(!oFont) {
|
|
oFont = this.getFont(STYLE_TYPE.WHOLE);
|
|
}
|
|
var oTextPr = this.txStyles.Default.TextPr;
|
|
oTextPr.InitDefault();
|
|
oTextPr.FillFromExcelFont(oFont);
|
|
var oParaPr = this.txStyles.Default.ParaPr;
|
|
oParaPr.SetSpacing(1, undefined, 0, 0, undefined, undefined);
|
|
return {styles: this.txStyles, lastId: undefined};
|
|
};
|
|
CSlicer.prototype.isMultiSelect = function() {
|
|
if(this.header) {
|
|
return this.header.isMultiSelect();
|
|
}
|
|
return false;
|
|
};
|
|
CSlicer.prototype.internalDraw = function(graphics, transform, transformText, pageIndex) {
|
|
var oUR = graphics.updatedRect;
|
|
if(oUR && this.bounds) {
|
|
if(!oUR.isIntersectOther(this.bounds)) {
|
|
return;
|
|
}
|
|
}
|
|
AscFormat.CShape.prototype.draw.call(this, graphics, transform, transformText, pageIndex);
|
|
if(graphics.isBoundsChecker()) {
|
|
return;
|
|
}
|
|
graphics.SaveGrState();
|
|
graphics.transform3(this.transform, false);
|
|
if(this.header) {
|
|
this.header.draw(graphics, transform, transformText, pageIndex);
|
|
}
|
|
if(this.buttonsContainer) {
|
|
this.buttonsContainer.draw(graphics, transform, transformText, pageIndex);
|
|
}
|
|
graphics.RestoreGrState();
|
|
var oBorder = this.getBorder(STYLE_TYPE.WHOLE);
|
|
if(oBorder) {
|
|
var oTransform = transform || this.transform;
|
|
graphics.transform3(oTransform);
|
|
var oSide, oLastDrawn;
|
|
oSide = oBorder.l;
|
|
oLastDrawn = drawVerBorder(graphics, oSide, oLastDrawn, 1, 0, 0, this.extY) || oLastDrawn;
|
|
oSide = oBorder.t;
|
|
oLastDrawn = drawHorBorder(graphics, oSide, oLastDrawn, 1, 0, 0, this.extX) || oLastDrawn;
|
|
oSide = oBorder.r;
|
|
oLastDrawn = drawVerBorder(graphics, oSide, oLastDrawn, 1, this.extX, 0, this.extY) || oLastDrawn;
|
|
oSide = oBorder.b;
|
|
oLastDrawn = drawHorBorder(graphics, oSide, oLastDrawn, 1, this.extY, 0, this.extX) || oLastDrawn;
|
|
graphics.reset();
|
|
}
|
|
if(!AscCommon.IsShapeToImageConverter && !graphics.isPdf()) {
|
|
if(this.getLocked()) {
|
|
var oOldBrush = this.brush;
|
|
this.brush = AscFormat.CreateSolidFillRGBA(0, 0, 0, LOCKED_ALPHA);
|
|
AscFormat.CShape.prototype.draw.call(this, graphics);
|
|
this.brush = oOldBrush;
|
|
}
|
|
}
|
|
};
|
|
CSlicer.prototype.draw = function (graphics, transform, transformText, pageIndex) {
|
|
AscFormat.ExecuteNoHistory(this.internalDraw, this, [graphics, transform, transformText, pageIndex]);
|
|
};
|
|
CSlicer.prototype.handleUpdateExtents = function () {
|
|
this.recalcInfo.recalculateHeader = true;
|
|
this.recalcInfo.recalculateButtons = true;
|
|
AscFormat.CShape.prototype.handleUpdateExtents.call(this);
|
|
};
|
|
CSlicer.prototype.isEventListener = function (child) {
|
|
return this.eventListener === child;
|
|
};
|
|
CSlicer.prototype.setEventListener = function (child) {
|
|
this.eventListener = child;
|
|
};
|
|
CSlicer.prototype.handleClearButtonClick = function () {
|
|
if(!this.buttonsContainer) {
|
|
return;
|
|
}
|
|
this.buttonsContainer.selectAllButtons();
|
|
this.onViewUpdate();
|
|
};
|
|
CSlicer.prototype.onDataUpdate = function() {
|
|
this.data.onDataUpdate();
|
|
};
|
|
CSlicer.prototype.removeAllButtonsTmpState = function() {
|
|
if(this.buttonsContainer) {
|
|
this.buttonsContainer.removeAllButtonsTmpState();
|
|
}
|
|
};
|
|
CSlicer.prototype.onViewUpdate = function() {
|
|
this.data.onViewUpdate();
|
|
};
|
|
CSlicer.prototype.onMouseMove = function (e, x, y) {
|
|
var bRet = false;
|
|
if(this.eventListener) {
|
|
if(!e.IsLocked) {
|
|
return this.onMouseUp(e, x, y);
|
|
}
|
|
if(this.getLocked()) {
|
|
return this.onMouseUp(e, x, y);
|
|
}
|
|
if(e.CtrlKey) {
|
|
if(!this.isSubscribed()) {
|
|
this.subscribeToEvents();
|
|
}
|
|
}
|
|
else {
|
|
if(this.isSubscribed()) {
|
|
this.unsubscribeFromEvents();
|
|
}
|
|
}
|
|
this.eventListener.onMouseMove(e, x, y);
|
|
return true;
|
|
}
|
|
if(this.getLocked()) {
|
|
return false;
|
|
}
|
|
if(!this.data.hasData()) {
|
|
return false;
|
|
}
|
|
if(this.header) {
|
|
bRet = bRet || this.header.onMouseMove(e, x, y);
|
|
}
|
|
if(this.buttonsContainer) {
|
|
bRet = bRet || this.buttonsContainer.onMouseMove(e, x, y);
|
|
}
|
|
if(this.hitInInnerArea(x, y)) {
|
|
bRet = true;
|
|
}
|
|
return bRet;
|
|
};
|
|
CSlicer.prototype.onMouseDown = function (e, x, y) {
|
|
if(this.getLocked()) {
|
|
return false;
|
|
}
|
|
if(!this.data.hasData()) {
|
|
return false;
|
|
}
|
|
if(e.button !== 0) {
|
|
return false;
|
|
}
|
|
var bRet = false, bRes;
|
|
e.IsLocked = true;
|
|
if(this.eventListener) {
|
|
this.eventListener.onMouseUp(e, x, y);
|
|
}
|
|
if(this.header) {
|
|
bRes = this.header.onMouseDown(e, x, y);
|
|
bRet = bRet || bRes;
|
|
}
|
|
if(this.buttonsContainer) {
|
|
bRes = this.buttonsContainer.onMouseDown(e, x, y);
|
|
bRet = bRet || bRes;
|
|
if(bRes && e.CtrlKey) {
|
|
this.subscribeToEvents();
|
|
}
|
|
}
|
|
return bRet;
|
|
};
|
|
CSlicer.prototype.getCursorInfo = function (e, x, y) {
|
|
if(this.getLocked() || !this.hit(x, y) || !this.data.hasData()) {
|
|
return null;
|
|
}
|
|
var oRet = (this.header && this.header.getCursorInfo(e, x, y)) || (this.buttonsContainer && this.buttonsContainer.getCursorInfo(e, x, y));
|
|
if(oRet) {
|
|
oRet.objectId = this.Get_Id();
|
|
oRet.bMarker = false;
|
|
return oRet;
|
|
}
|
|
return oRet;
|
|
};
|
|
CSlicer.prototype.onMouseUp = function (e, x, y) {
|
|
var bRet = false;
|
|
if(this.eventListener) {
|
|
bRet = this.eventListener.onMouseUp(e, x, y);
|
|
this.setEventListener(null);
|
|
this.onUpdate(this.bounds);
|
|
this.onViewUpdate();
|
|
return bRet;
|
|
}
|
|
return bRet;
|
|
};
|
|
CSlicer.prototype.getValues = function () {
|
|
return this.data.getValues();
|
|
};
|
|
CSlicer.prototype.getButtonState = function (nIndex) {
|
|
return this.data.getButtonState(nIndex);
|
|
};
|
|
CSlicer.prototype.getValuesCount = function () {
|
|
return this.data.getValuesCount();
|
|
};
|
|
CSlicer.prototype.getString = function (nIndex) {
|
|
return this.data.getString(nIndex);
|
|
};
|
|
CSlicer.prototype.isAllValuesSelected = function () {
|
|
return this.data.isAllValuesSelected();
|
|
};
|
|
CSlicer.prototype.getInvFullTransformMatrix = function () {
|
|
return this.invertTransform;
|
|
};
|
|
CSlicer.prototype.onWheel = function (deltaX, deltaY) {
|
|
if(this.getLocked() || !this.data.hasData()) {
|
|
return false;
|
|
}
|
|
return this.buttonsContainer.onWheel(deltaX, deltaY);
|
|
};
|
|
CSlicer.prototype.onSlicerUpdate = function (sName) {
|
|
if(AscCommon.isFileBuild()) {
|
|
return;
|
|
}
|
|
if(this.name === sName) {
|
|
this.onDataUpdate();
|
|
}
|
|
};
|
|
CSlicer.prototype.onSlicerLock = function (sName, bLock) {
|
|
if(AscCommon.isFileBuild()) {
|
|
return;
|
|
}
|
|
if(this.name === sName) {
|
|
this.data.setLocked(bLock);
|
|
this.onUpdate(this.bounds);
|
|
this.unsubscribeFromEvents();
|
|
}
|
|
};
|
|
CSlicer.prototype.onSlicerChangeName = function (sName, sNewName) {
|
|
if(AscCommon.isFileBuild()) {
|
|
return;
|
|
}
|
|
if(this.name === sName) {
|
|
this.setName(sNewName);
|
|
this.onDataUpdate();
|
|
}
|
|
};
|
|
CSlicer.prototype.onSlicerDelete = function (sName) {
|
|
if(AscCommon.isFileBuild()) {
|
|
return false;
|
|
}
|
|
var bRet = false;
|
|
var oMainGroup, oCurGroup;
|
|
if(this.name === sName) {
|
|
if(this.group) {
|
|
this.group.removeFromSpTree(this.Id);
|
|
oCurGroup = this.group;
|
|
while (oCurGroup.spTree.length === 0 && oCurGroup.group) {
|
|
oCurGroup.group.removeFromSpTree(oCurGroup.Get_Id());
|
|
oCurGroup = oCurGroup.group;
|
|
}
|
|
if(oCurGroup.spTree.length === 0) {
|
|
if(oCurGroup.drawingBase) {
|
|
oCurGroup.deleteDrawingBase();
|
|
}
|
|
}
|
|
else {
|
|
oMainGroup = this.group.getMainGroup();
|
|
if(oMainGroup) {
|
|
oMainGroup.updateCoordinatesAfterInternalResize();
|
|
}
|
|
}
|
|
bRet = true;
|
|
}
|
|
else {
|
|
if(this.drawingBase) {
|
|
this.deleteDrawingBase();
|
|
bRet = true;
|
|
}
|
|
}
|
|
}
|
|
if(bRet) {
|
|
this.onUpdate(this.bounds);
|
|
var oController = this.getDrawingObjectsController();
|
|
if(oController) {
|
|
this.deselect(oController);
|
|
}
|
|
}
|
|
return bRet;
|
|
};
|
|
CSlicer.prototype.deleteSlicer = function () {
|
|
Asc.editor.wb.deleteSlicer(this.name);
|
|
};
|
|
CSlicer.prototype.subscribeToEvents = function () {
|
|
var drawingObjects = this.getDrawingObjectsController();
|
|
if(drawingObjects) {
|
|
drawingObjects.addEventListener(this);
|
|
}
|
|
};
|
|
CSlicer.prototype.unsubscribeFromEvents = function () {
|
|
var drawingObjects = this.getDrawingObjectsController();
|
|
if(drawingObjects) {
|
|
drawingObjects.removeEventListener(this);
|
|
}
|
|
};
|
|
CSlicer.prototype.isSubscribed = function () {
|
|
var drawingObjects = this.getDrawingObjectsController();
|
|
if(drawingObjects) {
|
|
return drawingObjects.isEventListener(this);
|
|
}
|
|
return false;
|
|
};
|
|
CSlicer.prototype.onKeyUp = function (e) {
|
|
if(e.KeyCode === 91 /*meta*/|| e.KeyCode === 17/*ctrl*/) {
|
|
if(this.isSubscribed()) {
|
|
this.unsubscribeFromEvents();
|
|
if(!this.eventListener) {
|
|
this.onViewUpdate();
|
|
}
|
|
}
|
|
}
|
|
};
|
|
CSlicer.prototype.getLocked = function () {
|
|
return this.data.getLocked() || (this.lockType !== AscCommon.c_oAscLockTypes.kLockTypeNone && this.lockType !== AscCommon.c_oAscLockTypes.kLockTypeMine);
|
|
};
|
|
CSlicer.prototype.copy = function (oPr) {
|
|
var copy = new CSlicer();
|
|
this.fillObject(copy, oPr);
|
|
if(this.name !== null) {
|
|
copy.setName(this.name);
|
|
}
|
|
if(this.macro !== null) {
|
|
copy.setMacro(this.macro);
|
|
}
|
|
if(this.textLink !== null) {
|
|
copy.setTextLink(this.textLink);
|
|
}
|
|
return copy;
|
|
};
|
|
CSlicer.prototype.invertMultiSelect = function () {
|
|
if(this.header) {
|
|
return this.header.invertMultiSelect();
|
|
}
|
|
return false;
|
|
};
|
|
CSlicer.prototype.getSlicer = function() {
|
|
var oWorkbook = this.getWorkbook();
|
|
if(!oWorkbook) {
|
|
return oWorkbook;
|
|
}
|
|
return oWorkbook.getSlicerByName(this.name);
|
|
};
|
|
CSlicer.prototype.getButtonWidth = function() {
|
|
if(!this.buttonsContainer) {
|
|
return 0;
|
|
}
|
|
return this.buttonsContainer.getButtonWidth() * g_dKoef_mm_to_emu + 0.5 >> 0;
|
|
};
|
|
CSlicer.prototype.setButtonWidth = function(dWidth) {
|
|
var bChange = false;
|
|
if(AscFormat.isRealNumber(dWidth) && dWidth > 0) {
|
|
var dCurWidth = this.getButtonWidth();
|
|
if(!AscFormat.fApproxEqual(dCurWidth, dWidth)) {
|
|
var mmWidth = dWidth * g_dKoef_emu_to_mm;
|
|
var dNewWidth = this.getWidthByButton(mmWidth);
|
|
if(!AscFormat.fApproxEqual(dNewWidth, this.extX)) {
|
|
AscFormat.CheckSpPrXfrm(this);
|
|
this.spPr.xfrm.setExtX(dNewWidth);
|
|
this.checkDrawingBaseCoords();
|
|
bChange = true;
|
|
}
|
|
}
|
|
}
|
|
return bChange;
|
|
};
|
|
CSlicer.prototype.checkAutofit = function (bIgnoreWordShape) {
|
|
return false;
|
|
};
|
|
CSlicer.prototype.checkTextWarp = function(oContent, oBodyPr, dWidth, dHeight, bNeedNoTransform, bNeedWarp) {
|
|
return oDefaultWrapObject;
|
|
};
|
|
CSlicer.prototype.getSlicerViewByName = function (name) {
|
|
if(this.name === name) {
|
|
return this;
|
|
}
|
|
return null;
|
|
};
|
|
CSlicer.prototype.getAllSlicerViews = function(aSlicerView) {
|
|
aSlicerView.push(this);
|
|
};
|
|
|
|
function CHeader(slicer) {
|
|
AscFormat.CShape.call(this);
|
|
this.slicer = slicer;
|
|
this.worksheet = slicer.worksheet;
|
|
this.txBody = null;
|
|
this.buttons = [];
|
|
this.buttons.push(new CInterfaceButton(this));
|
|
this.buttons.push(new CInterfaceButton(this));
|
|
this.buttons[1].removeTmpState();
|
|
this.setBDeleted(false);
|
|
this.setTransformParams(0, 0, 0, 0, 0, false, false);
|
|
this.createTextBody();
|
|
this.bodyPr = new AscFormat.CBodyPr();
|
|
this.bodyPr.setDefault();
|
|
this.bodyPr.anchor = 1;//vertical align ctr
|
|
this.bodyPr.lIns = HEADER_LEFT_PADDING;
|
|
this.bodyPr.rIns = HEADER_RIGHT_PADDING;
|
|
this.bodyPr.tIns = HEADER_TOP_PADDING;
|
|
this.bodyPr.bIns = HEADER_BOTTOM_PADDING;
|
|
this.bodyPr.horzOverflow = AscFormat.nHOTClip;
|
|
this.bodyPr.vertOverflow = AscFormat.nVOTClip;
|
|
|
|
this.eventListener = null;
|
|
this.startButton = null;
|
|
}
|
|
CHeader.prototype = Object.create(AscFormat.CShape.prototype);
|
|
CHeader.prototype.getString = function() {
|
|
return this.slicer.getCaption();
|
|
};
|
|
CHeader.prototype.Get_Styles = function() {
|
|
return this.slicer.getTxStyles(STYLE_TYPE.HEADER);
|
|
};
|
|
CHeader.prototype.getParentObjects = function() {
|
|
return this.slicer.getParentObjects();
|
|
};
|
|
CHeader.prototype.isMultiSelect = function() {
|
|
return this.buttons[0].isSelected();
|
|
};
|
|
CHeader.prototype.invertMultiSelect = function () {
|
|
this.buttons[0].setInvertSelectTmpState();
|
|
return true;
|
|
};
|
|
CHeader.prototype.recalculateBrush = function () {
|
|
var oFill = this.slicer.getFill(STYLE_TYPE.HEADER);
|
|
var oParents = this.slicer.getParentObjects();
|
|
this.brush = AscCommonExcel.convertFillToUnifill(oFill);
|
|
this.brush.calculate(oParents.theme, oParents.slide, oParents.layout, oParents.master, {R:0, G:0, B:0, A: 255});
|
|
};
|
|
CHeader.prototype.recalculatePen = function () {
|
|
this.pen = null;
|
|
};
|
|
CHeader.prototype.recalculateContent = function () {
|
|
if(this.bRecalcContent) {
|
|
return;
|
|
}
|
|
this.setTransformParams(0, 0, this.slicer.extX, HEADER_BUTTON_WIDTH, 0, false, false);
|
|
this.recalculateGeometry();
|
|
this.recalculateTransform();
|
|
this.txBody.content.Recalc_AllParagraphs_CompiledPr();
|
|
this.txBody.recalculateOneString(this.getString());
|
|
var dHeight = this.contentHeight + HEADER_TOP_PADDING + HEADER_BOTTOM_PADDING;
|
|
dHeight = Math.max(dHeight, HEADER_BUTTON_WIDTH + 1);
|
|
this.setTransformParams(0, 0, this.slicer.extX, dHeight, 0, false, false);
|
|
this.recalcInfo.recalculateContent = false;
|
|
this.bRecalcContent = true;
|
|
this.recalculate();
|
|
this.recalculateButtons();
|
|
this.bRecalcContent = false;
|
|
};
|
|
CHeader.prototype.getBodyPr = function () {
|
|
return this.bodyPr;
|
|
};
|
|
CHeader.prototype.recalculateGeometry = function() {
|
|
this.calcGeometry = AscFormat.CreateGeometry("rect");
|
|
this.calcGeometry.Recalculate(this.extX, this.extY);
|
|
};
|
|
CHeader.prototype.recalculateButtons = function() {
|
|
var oButton = this.buttons[1];
|
|
var x, y;
|
|
x = this.extX - RIGHT_PADDING - HEADER_BUTTON_WIDTH;
|
|
y = this.extY / 2 - HEADER_BUTTON_WIDTH / 2;
|
|
oButton.setTransformParams(x, y, HEADER_BUTTON_WIDTH, HEADER_BUTTON_WIDTH, 0, false, false);
|
|
oButton.recalculate();
|
|
oButton = this.buttons[0];
|
|
x = this.extX - HEADER_RIGHT_PADDING;
|
|
oButton.setTransformParams(x, y, HEADER_BUTTON_WIDTH, HEADER_BUTTON_WIDTH, 0, false, false);
|
|
oButton.recalculate();
|
|
};
|
|
CHeader.prototype.draw = function (graphics) {
|
|
var oUR = graphics.updatedRect;
|
|
if(oUR && this.bounds) {
|
|
if(!oUR.isIntersectOther(this.bounds)) {
|
|
return;
|
|
}
|
|
}
|
|
AscFormat.CShape.prototype.draw.call(this, graphics);
|
|
if(graphics.isBoundsChecker()) {
|
|
return;
|
|
}
|
|
|
|
graphics.SaveGrState();
|
|
graphics.transform3(this.transform);
|
|
graphics.SaveGrState();
|
|
graphics.AddClipRect(0, 0, this.extX, this.extY);
|
|
this.buttons[0].draw(graphics);
|
|
this.buttons[1].draw(graphics);
|
|
graphics.RestoreGrState();
|
|
var oLastDrawn;
|
|
var oDXF = this.slicer.getDXF(STYLE_TYPE.HEADER);
|
|
var oBorder = oDXF && oDXF.getBorder();
|
|
if(oBorder) {
|
|
oLastDrawn = drawVerBorder(graphics, oBorder.l, oLastDrawn, 1, 0, 0, this.extY) || oLastDrawn;
|
|
oLastDrawn = drawHorBorder(graphics, oBorder.t, oLastDrawn, 1, 0, 0, this.extX) || oLastDrawn;
|
|
oLastDrawn = drawVerBorder(graphics, oBorder.r, oLastDrawn, 1, this.extX, 0, this.extY) || oLastDrawn;
|
|
var bFull = false;
|
|
if(oLastDrawn) {
|
|
bFull = true;
|
|
}
|
|
else {
|
|
var oFill = this.slicer.getFill(STYLE_TYPE.HEADER);
|
|
if(oFill) {
|
|
var oWholeFill = this.slicer.getFill(STYLE_TYPE.WHOLE);
|
|
if(!oWholeFill || !oFill.isEqual(oWholeFill)) {
|
|
bFull = true;
|
|
}
|
|
}
|
|
}
|
|
if(bFull) {
|
|
oLastDrawn = drawHorBorder(graphics, oBorder.b, oLastDrawn, 1, this.extY, 0, this.extX) || oLastDrawn;
|
|
}
|
|
else {
|
|
oLastDrawn = drawHorBorder(graphics, oBorder.b, oLastDrawn, 1, this.extY, LEFT_PADDING, this.slicer.extX - RIGHT_PADDING) || oLastDrawn;
|
|
}
|
|
}
|
|
else {
|
|
oBorder = this.slicer.getBorder(STYLE_TYPE.HEADER);
|
|
if(oBorder) {
|
|
oLastDrawn = drawHorBorder(graphics, oBorder.b, oLastDrawn, 1, this.extY, LEFT_PADDING, this.slicer.extX - RIGHT_PADDING) || oLastDrawn;
|
|
}
|
|
}
|
|
graphics.RestoreGrState();
|
|
};
|
|
CHeader.prototype.getTxStyles = function (nType) {
|
|
return this.slicer.getTxStyles(nType);
|
|
};
|
|
CHeader.prototype.getBorder = function (nType) {
|
|
return null;
|
|
};
|
|
CHeader.prototype.getFill = function (nType) {
|
|
var nColor = HEADER_BUTTON_COLORS[nType];
|
|
var oFill = null;
|
|
if(nColor !== null) {
|
|
oFill = new AscCommonExcel.Fill();
|
|
oFill.fromColor(new AscCommonExcel.RgbColor(nColor));
|
|
}
|
|
return oFill;
|
|
};
|
|
CHeader.prototype.getIcon = function(nIndex, nType) {
|
|
var sRet;
|
|
if(nIndex === 0) {
|
|
if(nType & STATE_FLAG_SELECTED) {
|
|
sRet = ICON_MULTISELECT_INVERTED;
|
|
}
|
|
else {
|
|
sRet = ICON_MULTISELECT;
|
|
}
|
|
}
|
|
else {
|
|
if(nType & STATE_FLAG_WHOLE) {
|
|
sRet = ICON_CLEAR_FILTER_DISABLED;
|
|
}
|
|
else {
|
|
sRet = ICON_CLEAR_FILTER;
|
|
}
|
|
}
|
|
return sRet;
|
|
};
|
|
CHeader.prototype.getFullTransformMatrix = function () {
|
|
return this.transform;
|
|
};
|
|
CHeader.prototype.getInvFullTransformMatrix = function () {
|
|
return this.invertTransform;
|
|
};
|
|
CHeader.prototype.recalculateTransform = function() {
|
|
AscFormat.CShape.prototype.recalculateTransform.call(this);
|
|
var oMT = AscCommon.global_MatrixTransformer;
|
|
this.transform = this.getFullTransform();
|
|
this.invertTransform = oMT.Invert(this.transform);
|
|
};
|
|
CHeader.prototype.recalculateTransformText = function() {
|
|
AscFormat.CShape.prototype.recalculateTransformText.call(this);
|
|
var oMT = AscCommon.global_MatrixTransformer;
|
|
this.transformText = this.getFullTextTransform();
|
|
this.invertTransformText = oMT.Invert(this.transformText);
|
|
};
|
|
CHeader.prototype.recalculateSnapArrays = function() {
|
|
};
|
|
CHeader.prototype.getFullTransform = function() {
|
|
var oMT = AscCommon.global_MatrixTransformer;
|
|
var oTransform = oMT.CreateDublicateM(this.localTransform);
|
|
|
|
var oParentTransform = this.slicer.transform;
|
|
oParentTransform && oMT.MultiplyAppend(oTransform, oParentTransform);
|
|
return oTransform;
|
|
};
|
|
CHeader.prototype.getFullTextTransform = function() {
|
|
var oMT = AscCommon.global_MatrixTransformer;
|
|
var oParentTransform = this.slicer.transform;
|
|
var oTransformText = oMT.CreateDublicateM(this.localTransformText);
|
|
oParentTransform && oMT.MultiplyAppend(oTransformText, oParentTransform);
|
|
return oTransformText;
|
|
};
|
|
CHeader.prototype.getInvFullTransformMatrix = function() {
|
|
var oMT = AscCommon.global_MatrixTransformer;
|
|
return oMT.Invert(this.getFullTransform());
|
|
};
|
|
CHeader.prototype.isEventListener = function (child) {
|
|
return this.eventListener === child;
|
|
};
|
|
CHeader.prototype.onMouseMove = function (e, x, y) {
|
|
if(this.eventListener) {
|
|
return this.eventListener.onMouseMove(e, x, y);
|
|
}
|
|
var bRet = false;
|
|
bRet |= this.buttons[0].onMouseMove(e, x, y);
|
|
bRet |= this.buttons[1].onMouseMove(e, x, y);
|
|
return bRet;
|
|
};
|
|
CHeader.prototype.onMouseDown = function (e, x, y) {
|
|
var bRet = false;
|
|
bRet |= this.buttons[0].onMouseDown(e, x, y);
|
|
bRet |= this.buttons[1].onMouseDown(e, x, y);
|
|
return bRet;
|
|
};
|
|
CHeader.prototype.getCursorInfo = function (e, x, y) {
|
|
if(!this.hit(x, y)) {
|
|
return null;
|
|
}
|
|
var oRet = this.buttons[0].getCursorInfo(e, x, y);
|
|
if(oRet) {
|
|
return oRet;
|
|
}
|
|
oRet = this.buttons[1].getCursorInfo(e, x, y);
|
|
if(!oRet) {
|
|
oRet = {
|
|
cursorType: "move",
|
|
tooltip: !this.txBody.bFit ? this.getString() : null
|
|
}
|
|
}
|
|
return oRet;
|
|
};
|
|
CHeader.prototype.onMouseUp = function (e, x, y) {
|
|
var bRet = false;
|
|
if(this.eventListener) {
|
|
bRet = this.eventListener.onMouseUp(e, x, y);
|
|
this.eventListener = null;
|
|
return bRet;
|
|
}
|
|
bRet |= this.buttons[0].onMouseUp(e, x, y);
|
|
bRet |= this.buttons[1].onMouseUp(e, x, y);
|
|
this.setEventListener(null);
|
|
return bRet;
|
|
};
|
|
CHeader.prototype.getButtonIndex = function (oButton) {
|
|
for(var nButton = 0; nButton < this.buttons.length; ++nButton) {
|
|
if(this.buttons[nButton] === oButton) {
|
|
return nButton;
|
|
}
|
|
}
|
|
return -1;
|
|
};
|
|
CHeader.prototype.setEventListener = function (child) {
|
|
this.eventListener = child;
|
|
if(child) {
|
|
this.slicer.setEventListener(this);
|
|
}
|
|
else {
|
|
if(this.slicer.isEventListener(this)) {
|
|
this.slicer.setEventListener(null);
|
|
}
|
|
}
|
|
};
|
|
CHeader.prototype.handleMouseUp = function (nIndex) {
|
|
var oButton = this.buttons[nIndex];
|
|
if(!oButton) {
|
|
return;
|
|
}
|
|
if(nIndex === 1) {
|
|
this.slicer.handleClearButtonClick();
|
|
}
|
|
};
|
|
CHeader.prototype.handleMouseDown = function (nIndex) {
|
|
var oButton = this.buttons[nIndex];
|
|
if(!oButton) {
|
|
return;
|
|
}
|
|
if(nIndex === 0) {
|
|
oButton.setInvertSelectTmpState();
|
|
this.slicer.onUpdate(oButton.bounds);
|
|
}
|
|
};
|
|
CHeader.prototype.isButtonDisabled = function (nIndex) {
|
|
if(nIndex === 1) {
|
|
return this.slicer.isAllValuesSelected();
|
|
}
|
|
else {
|
|
return false;
|
|
}
|
|
};
|
|
CHeader.prototype.getButtonState = function (nIndex) {
|
|
var oButton = this.buttons[nIndex];
|
|
var nRet = STYLE_TYPE.WHOLE;
|
|
if(!oButton) {
|
|
return nRet
|
|
}
|
|
if(nIndex === 0) {
|
|
if(oButton.haveTmpState()) {
|
|
nRet = oButton.tmpState;
|
|
}
|
|
else {
|
|
nRet = STYLE_TYPE.WHOLE;
|
|
}
|
|
}
|
|
else {
|
|
if(this.slicer.isAllValuesSelected()) {
|
|
nRet = STYLE_TYPE.WHOLE;
|
|
}
|
|
else {
|
|
nRet = STYLE_TYPE.UNSELECTED_DATA;
|
|
}
|
|
}
|
|
return nRet;
|
|
};
|
|
CHeader.prototype.getParentObjects = function () {
|
|
return this.slicer.getParentObjects();
|
|
};
|
|
CHeader.prototype.getScrollOffsetX = function () {
|
|
return 0;
|
|
};
|
|
CHeader.prototype.getScrollOffsetY = function () {
|
|
return 0;
|
|
};
|
|
CHeader.prototype.clipTextRect = function(graphics, transform, transformText, pageIndex) {
|
|
};
|
|
CHeader.prototype.onUpdate = function(oBounds) {
|
|
var oClipBounds = oBounds;
|
|
if(!oClipBounds) {
|
|
oClipBounds = this.bounds;
|
|
}
|
|
this.slicer.onUpdate(oClipBounds);
|
|
};
|
|
CHeader.prototype.getTooltipText = function (nIndex) {
|
|
var sText = null;
|
|
if(nIndex === 0) {
|
|
sText = AscCommon.translateManager.getValue("Multi-Select (Alt+S)");
|
|
}
|
|
else if(nIndex === 1) {
|
|
sText = AscCommon.translateManager.getValue("Clear Filter (Alt+C)");
|
|
}
|
|
return sText;
|
|
};
|
|
CHeader.prototype.checkAutofit = function (bIgnoreWordShape) {
|
|
return false;
|
|
};
|
|
CHeader.prototype.checkTextWarp = function(oContent, oBodyPr, dWidth, dHeight, bNeedNoTransform, bNeedWarp) {
|
|
return oDefaultWrapObject;
|
|
};
|
|
CHeader.prototype.isForm = function() {
|
|
return false;
|
|
};
|
|
|
|
function CButtonBase(parent) {
|
|
AscFormat.CShape.call(this);
|
|
this.parent = parent;
|
|
this.tmpState = null;
|
|
this.worksheet = parent.worksheet;
|
|
this.setBDeleted(false);
|
|
AscFormat.CheckSpPrXfrm3(this);
|
|
this.isHovered = false;
|
|
}
|
|
CButtonBase.prototype = Object.create(AscFormat.CShape.prototype);
|
|
CButtonBase.prototype.getTxBodyType = function () {
|
|
var nRet = null;
|
|
return nRet;
|
|
};
|
|
CButtonBase.prototype.getString = function() {
|
|
return "";
|
|
};
|
|
CButtonBase.prototype.haveTmpState = function() {
|
|
return this.tmpState !== null;
|
|
};
|
|
CButtonBase.prototype.Get_Styles = function() {
|
|
return this.parent.getTxStyles(this.getTxBodyType());
|
|
};
|
|
CButtonBase.prototype.getBodyPr = function () {
|
|
return this.bodyPr;
|
|
};
|
|
CButtonBase.prototype.getFullTransform = function() {
|
|
var oMT = AscCommon.global_MatrixTransformer;
|
|
var oTransform = oMT.CreateDublicateM(this.localTransform);
|
|
|
|
var oScrollMatrix = new AscCommon.CMatrix();
|
|
oScrollMatrix.tx = this.parent.getScrollOffsetX();
|
|
oScrollMatrix.ty = this.parent.getScrollOffsetY();
|
|
oMT.MultiplyAppend(oTransform, oScrollMatrix);
|
|
var oParentTransform = this.parent.getFullTransformMatrix();
|
|
oParentTransform && oMT.MultiplyAppend(oTransform, oParentTransform);
|
|
return oTransform;
|
|
};
|
|
CButtonBase.prototype.getFullTextTransform = function() {
|
|
var oMT = AscCommon.global_MatrixTransformer;
|
|
var oParentTransform = this.parent.getFullTransformMatrix();
|
|
var oTransformText = oMT.CreateDublicateM(this.localTransformText);
|
|
var oScrollMatrix = new AscCommon.CMatrix();
|
|
oScrollMatrix.tx = this.parent.getScrollOffsetX();
|
|
oScrollMatrix.ty = this.parent.getScrollOffsetY();
|
|
oMT.MultiplyAppend(oTransformText, oScrollMatrix);
|
|
oParentTransform && oMT.MultiplyAppend(oTransformText, oParentTransform);
|
|
return oTransformText;
|
|
};
|
|
CButtonBase.prototype.getInvFullTransformMatrix = function() {
|
|
var oMT = AscCommon.global_MatrixTransformer;
|
|
return oMT.Invert(this.getFullTransform());
|
|
};
|
|
CButtonBase.prototype.getOwnState = function() {
|
|
return this.parent.getButtonState(this.parent.getButtonIndex(this));
|
|
};
|
|
CButtonBase.prototype.getState = function() {
|
|
var nState = 0;
|
|
if(this.haveTmpState()) {
|
|
nState = this.tmpState;
|
|
}
|
|
else {
|
|
nState = this.getOwnState();
|
|
}
|
|
if(nState !== STYLE_TYPE.WHOLE && nState !== STYLE_TYPE.HEADER) {
|
|
if(this.isHovered) {
|
|
nState |= STATE_FLAG_HOVERED;
|
|
}
|
|
else {
|
|
nState &= (~STATE_FLAG_HOVERED);
|
|
}
|
|
}
|
|
return nState;
|
|
};
|
|
CButtonBase.prototype.setUnselectTmpState = function() {
|
|
this.setTmpState(this.getOwnState() & (~STATE_FLAG_SELECTED));
|
|
};
|
|
CButtonBase.prototype.setSelectTmpState = function() {
|
|
this.setTmpState(this.getOwnState() | STATE_FLAG_SELECTED);
|
|
};
|
|
CButtonBase.prototype.setHoverState = function() {
|
|
var bOld = this.isHovered;
|
|
this.isHovered = true;
|
|
if(bOld !== this.isHovered) {
|
|
this.onUpdate(this.bounds);
|
|
}
|
|
};
|
|
CButtonBase.prototype.getTooltipText = function() {
|
|
return null;
|
|
};
|
|
CButtonBase.prototype.setNotHoverState = function() {
|
|
var bOld = this.isHovered;
|
|
this.isHovered = false;
|
|
if(bOld !== this.isHovered) {
|
|
this.onUpdate(this.bounds);
|
|
}
|
|
};
|
|
CButtonBase.prototype.setInvertSelectTmpState = function() {
|
|
var nOwnState = this.getOwnState();
|
|
if(nOwnState & STATE_FLAG_SELECTED) {
|
|
this.setTmpState(nOwnState & (~STATE_FLAG_SELECTED));
|
|
}
|
|
else {
|
|
this.setTmpState(nOwnState | STATE_FLAG_SELECTED);
|
|
}
|
|
};
|
|
CButtonBase.prototype.setTmpState = function(state) {
|
|
var nOld = this.tmpState;
|
|
this.tmpState = state;
|
|
if(nOld !== this.tmpState) {
|
|
this.onUpdate(this.bounds);
|
|
}
|
|
};
|
|
CButtonBase.prototype.removeTmpState = function() {
|
|
this.setTmpState(null);
|
|
};
|
|
CButtonBase.prototype.isSelected = function() {
|
|
return (this.getState() & STATE_FLAG_SELECTED) !== 0;
|
|
};
|
|
CButtonBase.prototype.recalculate = function() {
|
|
AscFormat.CShape.prototype.recalculate.call(this);
|
|
};
|
|
CButtonBase.prototype.recalculateBrush = function () {
|
|
//Empty procedure. Set of brushes for all states will be recalculated in CSlicer
|
|
};
|
|
CButtonBase.prototype.recalculatePen = function () {
|
|
this.pen = null;
|
|
};
|
|
CButtonBase.prototype.recalculateContent = function () {
|
|
};
|
|
CButtonBase.prototype.recalculateGeometry = function() {
|
|
this.calcGeometry = AscFormat.CreateGeometry("rect");
|
|
this.calcGeometry.Recalculate(this.extX, this.extY);
|
|
};
|
|
CButtonBase.prototype.recalculateTransform = function() {
|
|
AscFormat.CShape.prototype.recalculateTransform.call(this);
|
|
var oMT = AscCommon.global_MatrixTransformer;
|
|
this.transform = this.getFullTransform();
|
|
this.invertTransform = oMT.Invert(this.transform);
|
|
};
|
|
CButtonBase.prototype.recalculateTransformText = function() {
|
|
AscFormat.CShape.prototype.recalculateTransformText.call(this);
|
|
var oMT = AscCommon.global_MatrixTransformer;
|
|
this.transformText = this.getFullTextTransform();
|
|
this.invertTransformText = oMT.Invert(this.transformText);
|
|
};
|
|
CButtonBase.prototype.recalculateBounds = function() {
|
|
this.bounds.x = this.transform.tx;
|
|
this.bounds.y = this.transform.ty;
|
|
this.bounds.l = this.bounds.x;
|
|
this.bounds.t = this.bounds.y;
|
|
this.bounds.r = this.bounds.x + this.extX;
|
|
this.bounds.b = this.bounds.y + this.extY;
|
|
this.bounds.w = this.bounds.r - this.bounds.l;
|
|
this.bounds.h = this.bounds.b - this.bounds.t;
|
|
};
|
|
CButtonBase.prototype.recalculateSnapArrays = function() {
|
|
};
|
|
CButtonBase.prototype.checkAutofit = function (bIgnoreWordShape) {
|
|
return false;
|
|
};
|
|
CButtonBase.prototype.checkTextWarp = function(oContent, oBodyPr, dWidth, dHeight, bNeedNoTransform, bNeedWarp) {
|
|
return oDefaultWrapObject;
|
|
};
|
|
CButtonBase.prototype.addToRecalculate = function() {
|
|
};
|
|
CButtonBase.prototype.draw = function (graphics) {
|
|
var oUR = graphics.updatedRect;
|
|
if(oUR && this.bounds) {
|
|
if(!oUR.isIntersectOther(this.bounds)) {
|
|
return;
|
|
}
|
|
}
|
|
var parents = this.getParentObjects();
|
|
this.brush = AscCommonExcel.convertFillToUnifill(this.parent.getFill(this.getState()));
|
|
this.brush.calculate(parents.theme, parents.slide, parents.layout, parents.master, {R: 0, G: 0, B: 0, A: 255});
|
|
this.recalculateTransform();
|
|
this.recalculateTransformText();
|
|
if(!graphics.isBoundsChecker()) {
|
|
this.recalculateBounds();
|
|
}
|
|
AscFormat.CShape.prototype.draw.call(this, graphics);
|
|
if(graphics.isBoundsChecker()) {
|
|
return;
|
|
}
|
|
var oBorder = this.parent.getBorder(this.getState());
|
|
if(oBorder) {
|
|
graphics.transform3(this.transform);
|
|
var oLastDrawn = null;
|
|
oLastDrawn = drawVerBorder(graphics, oBorder.l, oLastDrawn, 0, 0, 0, this.extY) || oLastDrawn;
|
|
oLastDrawn = drawHorBorder(graphics, oBorder.t, oLastDrawn, 0, 0, 0, this.extX) || oLastDrawn;
|
|
oLastDrawn = drawVerBorder(graphics, oBorder.r, oLastDrawn, 2, this.extX, 0, this.extY) || oLastDrawn;
|
|
oLastDrawn = drawHorBorder(graphics, oBorder.b, oLastDrawn, 2, this.extY, 0, this.extX) || oLastDrawn;
|
|
}
|
|
};
|
|
CButtonBase.prototype.hit = function(x, y) {
|
|
if(!this.parent.hit(x, y)) {
|
|
return false;
|
|
}
|
|
var oInv = this.invertTransform;
|
|
var tx = oInv.TransformPointX(x, y);
|
|
var ty = oInv.TransformPointY(x, y);
|
|
return tx >= 0 && tx <= this.extX && ty >= 0 && ty <= this.extY;
|
|
};
|
|
CButtonBase.prototype.onMouseMove = function (e, x, y) {
|
|
if(e.IsLocked) {
|
|
return false;
|
|
}
|
|
var bHover = this.hit(x, y);
|
|
var bRet = bHover !== this.isHovered;
|
|
if(bHover) {
|
|
this.setHoverState();
|
|
}
|
|
else {
|
|
this.setNotHoverState();
|
|
}
|
|
return bRet;
|
|
};
|
|
CButtonBase.prototype.onMouseDown = function (e, x, y) {
|
|
if(this.hit(x, y)) {
|
|
this.parent.setEventListener(this);
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
CButtonBase.prototype.onMouseUp = function (e, x, y) {
|
|
this.parent.setEventListener(null);
|
|
return false;
|
|
};
|
|
CButtonBase.prototype.onUpdate = function(oBounds) {
|
|
this.parent.onUpdate(oBounds);
|
|
};
|
|
CButtonBase.prototype.getCursorInfo = function(e, x, y) {
|
|
if(!this.hit(x, y)) {
|
|
return null;
|
|
}
|
|
else {
|
|
return {
|
|
cursorType: "default",
|
|
tooltip: this.getTooltipText()
|
|
}
|
|
}
|
|
};
|
|
|
|
function CButton(parent) {
|
|
CButtonBase.call(this, parent);
|
|
this.textBoxes = {};
|
|
this.bodyPr = new AscFormat.CBodyPr();
|
|
this.bodyPr.setDefault();
|
|
this.bodyPr.anchor = 1;//vertical align ctr
|
|
this.bodyPr.lIns = LEFT_PADDING;
|
|
this.bodyPr.rIns = RIGHT_PADDING;
|
|
this.bodyPr.tIns = 0;
|
|
this.bodyPr.bIns = 0;
|
|
this.bodyPr.bIns = 0;
|
|
this.bodyPr.horzOverflow = AscFormat.nHOTClip;
|
|
this.bodyPr.vertOverflow = AscFormat.nVOTClip;
|
|
}
|
|
CButton.prototype = Object.create(CButtonBase.prototype);
|
|
CButton.prototype.getTxBodyType = function () {
|
|
var nRet = null;
|
|
for(var key in this.textBoxes) {
|
|
if(this.textBoxes.hasOwnProperty(key)) {
|
|
if(this.textBoxes[key] === this.txBody) {
|
|
nRet = parseInt(key);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return nRet;
|
|
};
|
|
CButton.prototype.getString = function() {
|
|
return this.parent.getString(this.parent.getButtonIndex(this));
|
|
};
|
|
CButton.prototype.recalculateContent = function () {
|
|
var sText = this.getString();
|
|
var oFontMap = {};
|
|
var oFont, oFoundFont, oMapFont;
|
|
|
|
var oFirstButton = this.parent.buttons[0];
|
|
var bUseFirstButton = (oFirstButton !== this);
|
|
var nType;
|
|
for(var key in STYLE_TYPE) {
|
|
if(STYLE_TYPE.hasOwnProperty(key)) {
|
|
nType = STYLE_TYPE[key];
|
|
if(nType !== STYLE_TYPE.WHOLE && nType !== STYLE_TYPE.HEADER) {
|
|
oFont = this.parent.getFont(nType);
|
|
oFoundFont = null;
|
|
if(oFont) {
|
|
for(var fontKey in oFontMap) {
|
|
if(oFontMap.hasOwnProperty(fontKey)) {
|
|
oMapFont = oFontMap[fontKey];
|
|
if(oMapFont && oMapFont.isEqual(oFont)) {
|
|
oFoundFont = oMapFont;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(!oFoundFont) {
|
|
this.createTextBody();
|
|
this.textBoxes[nType] = this.txBody;
|
|
if(bUseFirstButton) {
|
|
this.txBody.content.Content[0].CompiledPr = oFirstButton.textBoxes[nType].content.Content[0].CompiledPr;
|
|
}
|
|
this.txBody.recalculateOneString(sText);
|
|
oFontMap[key] = oFont;
|
|
}
|
|
else {
|
|
this.textBoxes[nType] = this.textBoxes[STYLE_TYPE[fontKey]];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
CButton.prototype.clipTextRect = function (graphics, transform, transformText, pageIndex) {
|
|
};
|
|
CButton.prototype.draw = function (graphics) {
|
|
this.txBody = this.textBoxes[this.getState()];
|
|
if(!this.txBody) {
|
|
this.txBody = null;
|
|
}
|
|
CButtonBase.prototype.draw.call(this, graphics);
|
|
};
|
|
CButton.prototype.getTooltipText = function() {
|
|
if(!this.txBody || this.txBody.bFit) {
|
|
return null;
|
|
}
|
|
return this.getString();
|
|
};
|
|
CButton.prototype.isForm = function() {
|
|
return false;
|
|
};
|
|
|
|
function CInterfaceButton(parent) {
|
|
CButtonBase.call(this, parent);
|
|
this.setTmpState(STYLE_TYPE.UNSELECTED_DATA);
|
|
}
|
|
CInterfaceButton.prototype = Object.create(CButtonBase.prototype);
|
|
CInterfaceButton.prototype.isDisabled = function () {
|
|
return this.parent.isButtonDisabled(this.parent.getButtonIndex(this));
|
|
};
|
|
CInterfaceButton.prototype.hit = function (x, y) {
|
|
if(this.isDisabled()) {
|
|
return false;
|
|
}
|
|
return CButtonBase.prototype.hit.call(this, x, y);
|
|
};
|
|
CInterfaceButton.prototype.onMouseDown = function (e, x, y) {
|
|
if(this.isDisabled()) {
|
|
return false;
|
|
}
|
|
var bRet = CButtonBase.prototype.onMouseDown.call(this, e, x, y);
|
|
if(bRet) {
|
|
this.parent.handleMouseDown(this.parent.getButtonIndex(this));
|
|
}
|
|
return bRet;
|
|
};
|
|
CInterfaceButton.prototype.onMouseUp = function (e, x, y) {
|
|
var bEventListener = this.parent.isEventListener(this);
|
|
var bRet = CButtonBase.prototype.onMouseUp.call(this, e, x, y);
|
|
if(bEventListener) {
|
|
this.parent.handleMouseUp(this.parent.getButtonIndex(this));
|
|
}
|
|
return bRet;
|
|
};
|
|
CInterfaceButton.prototype.draw = function(graphics) {
|
|
var oUR = graphics.updatedRect;
|
|
if(oUR && this.bounds) {
|
|
if(!oUR.isIntersectOther(this.bounds)) {
|
|
return;
|
|
}
|
|
}
|
|
CButtonBase.prototype.draw.call(this, graphics);
|
|
if(graphics.isBoundsChecker()) {
|
|
return;
|
|
}
|
|
var sIcon = this.parent.getIcon(this.parent.getButtonIndex(this), this.getState());
|
|
if(null !== sIcon) {
|
|
graphics.SaveGrState();
|
|
graphics.transform3(this.transform);
|
|
|
|
graphics.SetIntegerGrid(true);
|
|
graphics.drawImage(sIcon, 0, 0, this.extX, this.extY, 255, null, null);
|
|
graphics.RestoreGrState();
|
|
}
|
|
};
|
|
CInterfaceButton.prototype.getTooltipText = function() {
|
|
return this.parent.getTooltipText(this.parent.getButtonIndex(this));
|
|
};
|
|
|
|
function CButtonsContainer(slicer) {
|
|
this.slicer = slicer;
|
|
this.worksheet = slicer.worksheet;
|
|
this.buttons = [];
|
|
this.x = 0;
|
|
this.y = 0;
|
|
this.extX = 0;
|
|
this.extY = 0;
|
|
this.contentW = 0;
|
|
this.contentH = 0;
|
|
this.scrollTop = 0;
|
|
this.scrollLeft = 0;
|
|
this.scroll = new CScroll(this);
|
|
|
|
this.eventListener = null;
|
|
this.startX = 0;
|
|
this.startY = 0;
|
|
this.startButton = -1;
|
|
}
|
|
CButtonsContainer.prototype.getParentObjects = function() {
|
|
return this.slicer.getParentObjects();
|
|
};
|
|
CButtonsContainer.prototype.clear = function() {
|
|
this.buttons.length = 0;
|
|
};
|
|
CButtonsContainer.prototype.addButton = function (oButton) {
|
|
this.buttons.push(oButton);
|
|
};
|
|
CButtonsContainer.prototype.getButtonIndex = function (oButton) {
|
|
for(var nButton = 0; nButton < this.buttons.length; ++nButton) {
|
|
if(this.buttons[nButton] === oButton) {
|
|
return nButton;
|
|
}
|
|
}
|
|
return -1;
|
|
};
|
|
CButtonsContainer.prototype.getViewButtonsCount = function () {
|
|
return this.buttons.length;
|
|
};
|
|
CButtonsContainer.prototype.getViewButtonState = function(nIndex) {
|
|
var oButton = this.getButton(nIndex);
|
|
if(!oButton) {
|
|
return null;
|
|
}
|
|
return oButton.getState();
|
|
};
|
|
CButtonsContainer.prototype.getButton = function (nIndex) {
|
|
if(nIndex > -1 && nIndex < this.buttons.length) {
|
|
return this.buttons[nIndex];
|
|
}
|
|
return null;
|
|
};
|
|
CButtonsContainer.prototype.findButtonIndex = function (x, y) {
|
|
var oInv = this.getInvFullTransformMatrix();
|
|
var tx = oInv.TransformPointX(x, y);
|
|
var ty = oInv.TransformPointY(x, y);
|
|
ty -= this.getScrollOffsetY();
|
|
var nRow, nRowsCount = this.getRowsCount();
|
|
for(nRow = 0;nRow < nRowsCount; ++nRow) {
|
|
if(ty < this.getRowStart(nRow)) {
|
|
break;
|
|
}
|
|
}
|
|
--nRow;
|
|
if(nRow === -1) {
|
|
return -1
|
|
}
|
|
var nCol, nColsCount = this.getColumnsCount();
|
|
for(nCol = 0; nCol < nColsCount; ++nCol) {
|
|
if(tx < this.getColumnStart(nCol)) {
|
|
break;
|
|
}
|
|
}
|
|
--nCol;
|
|
if(nCol === -1) {
|
|
--nRow;
|
|
if(nRow === -1) {
|
|
return - 1;
|
|
}
|
|
nCol = nColsCount - 1
|
|
}
|
|
var nIndex = nRow * nColsCount;
|
|
if(nRow < nRowsCount - 1) {
|
|
nIndex += nCol;
|
|
}
|
|
else {
|
|
nIndex += Math.min(nCol, this.buttons.length - (nRowsCount - 1)*nColsCount);
|
|
}
|
|
return nIndex;
|
|
|
|
};
|
|
CButtonsContainer.prototype.getTxStyles = function (nType) {
|
|
return this.slicer.getTxStyles(nType);
|
|
};
|
|
CButtonsContainer.prototype.getBorder = function (nType) {
|
|
return this.slicer.getBorder(nType);
|
|
};
|
|
CButtonsContainer.prototype.getFill = function (nType) {
|
|
return this.slicer.getFill(nType);
|
|
};
|
|
CButtonsContainer.prototype.getFont = function (nType) {
|
|
return this.slicer.getFont(nType);
|
|
};
|
|
CButtonsContainer.prototype.getButtonHeight = function () {
|
|
return this.slicer.getButtonHeight();
|
|
};
|
|
CButtonsContainer.prototype.getButtonWidth = function () {
|
|
var nColumnCount = this.getColumnsCount();
|
|
var nSpaceCount = nColumnCount - 1;
|
|
var dTotalHeight = this.getTotalHeight();
|
|
var dButtonWidth;
|
|
if(dTotalHeight <= this.extY) {
|
|
dButtonWidth = Math.max(0, this.slicer.getButtonsContainerWidth() - nSpaceCount * SPACE_BETWEEN) / nColumnCount;
|
|
}
|
|
else {
|
|
dButtonWidth = Math.max(0, this.slicer.getButtonsContainerWidth() - this.scroll.getWidth() - SPACE_BETWEEN - nSpaceCount * SPACE_BETWEEN) / nColumnCount;
|
|
}
|
|
return dButtonWidth;
|
|
};
|
|
CButtonsContainer.prototype.getWidthByButton = function (dBWidth) {
|
|
var nColumnCount = this.getColumnsCount();
|
|
var nSpaceCount = nColumnCount - 1;
|
|
var dTotalHeight = this.getTotalHeight();
|
|
var dWidth;
|
|
if(dTotalHeight <= this.extY) {
|
|
dWidth = dBWidth * nColumnCount + nSpaceCount * SPACE_BETWEEN;
|
|
}
|
|
else {
|
|
dWidth = dBWidth * nColumnCount + this.scroll.getWidth() + SPACE_BETWEEN + nSpaceCount * SPACE_BETWEEN;
|
|
}
|
|
return dWidth;
|
|
};
|
|
CButtonsContainer.prototype.getColumnsCount = function () {
|
|
return this.slicer.getColumnsCount();
|
|
};
|
|
CButtonsContainer.prototype.getRowsCount = function () {
|
|
return ((this.buttons.length - 1) / this.getColumnsCount() >> 0) + 1;
|
|
};
|
|
CButtonsContainer.prototype.getRowsInFrame = function () {
|
|
if(this.buttons.length === 0) {
|
|
return 0;
|
|
}
|
|
var dCount = (this.extY) / (this.getButtonHeight() + SPACE_BETWEEN);
|
|
var nCeil = (dCount >> 0);
|
|
if(dCount - nCeil > 0) {
|
|
++nCeil;
|
|
}
|
|
return Math.min(this.buttons.length, nCeil);
|
|
};
|
|
CButtonsContainer.prototype.getRowsInFrameFull = function () {
|
|
if(this.buttons.length === 0) {
|
|
return 0;
|
|
}
|
|
var dCount = (this.extY + SPACE_BETWEEN) / (this.getButtonHeight() + SPACE_BETWEEN);
|
|
if(dCount <= 0) {
|
|
return 0;
|
|
}
|
|
return (dCount >> 0);
|
|
};
|
|
CButtonsContainer.prototype.getScrolledRows = function () {
|
|
return this.getRowsCount() - this.getRowsInFrameFull();
|
|
};
|
|
CButtonsContainer.prototype.getTotalHeight = function () {
|
|
var nRowsCount = this.getRowsCount();
|
|
return this.getButtonHeight() * nRowsCount + SPACE_BETWEEN * (nRowsCount - 1);
|
|
};
|
|
CButtonsContainer.prototype.getColumnStart = function (nColumn) {
|
|
return this.x + (this.getButtonWidth() + SPACE_BETWEEN) * nColumn;
|
|
};
|
|
CButtonsContainer.prototype.getRowStart = function (nRow) {
|
|
return this.y + (this.getButtonHeight() + SPACE_BETWEEN) * nRow;
|
|
};
|
|
CButtonsContainer.prototype.checkScrollTop = function() {
|
|
this.scrollTop = Math.max(0, Math.min(this.scrollTop, this.getScrolledRows()));
|
|
};
|
|
CButtonsContainer.prototype.recalculate = function() {
|
|
var nColumnCount = this.getColumnsCount();
|
|
var dButtonWidth, dButtonHeight;
|
|
dButtonHeight = this.getButtonHeight();
|
|
dButtonWidth = this.getButtonWidth();
|
|
this.checkScrollTop();
|
|
var nColumn, nRow, nButtonIndex, oButton, x ,y;
|
|
for(nButtonIndex = 0; nButtonIndex < this.buttons.length; ++nButtonIndex) {
|
|
nColumn = nButtonIndex % nColumnCount;
|
|
nRow = nButtonIndex / nColumnCount >> 0;
|
|
oButton = this.buttons[nButtonIndex];
|
|
x = this.getColumnStart(nColumn);
|
|
y = this.getRowStart(nRow);
|
|
oButton.setTransformParams(x, y, dButtonWidth, dButtonHeight, 0, false, false);
|
|
oButton.recalculate();
|
|
}
|
|
this.scroll.bVisible = this.getTotalHeight() > this.extY;
|
|
this.scroll.recalculate();
|
|
};
|
|
CButtonsContainer.prototype.draw = function (graphics) {
|
|
if(this.buttons.length > 0) {
|
|
graphics.SaveGrState();
|
|
graphics.transform3(this.slicer.transform);
|
|
graphics.AddClipRect(0, this.y - SPACE_BETWEEN / 2, this.slicer.extX, this.extY + SPACE_BETWEEN / 2);
|
|
this.checkScrollTop();
|
|
var nColumns = this.getColumnsCount();
|
|
var nStart = this.scrollTop * nColumns;
|
|
var nEnd = Math.min(this.buttons.length - 1, nStart + this.getRowsInFrame() * nColumns - 1);
|
|
for(var nButton = nStart; nButton <= nEnd; ++nButton) {
|
|
this.buttons[nButton].draw(graphics);
|
|
}
|
|
graphics.RestoreGrState();
|
|
this.scroll.draw(graphics);
|
|
}
|
|
};
|
|
CButtonsContainer.prototype.getFullTransformMatrix = function () {
|
|
return AscCommon.global_MatrixTransformer.CreateDublicateM(this.slicer.transform);
|
|
};
|
|
CButtonsContainer.prototype.getInvFullTransformMatrix = function () {
|
|
var oM = this.getFullTransformMatrix();
|
|
return AscCommon.global_MatrixTransformer.Invert(oM);
|
|
};
|
|
CButtonsContainer.prototype.hit = function (x, y) {
|
|
var oInv = this.getInvFullTransformMatrix();
|
|
var tx = oInv.TransformPointX(x, y);
|
|
var ty = oInv.TransformPointY(x, y);
|
|
var bottom = Math.min(this.y + this.extY, this.getRowStart(this.getRowsCount() - 1) + this.getButtonHeight());
|
|
return tx >= this.x && ty >= this.y &&
|
|
tx <= this.x + this.extX && ty <= bottom;
|
|
};
|
|
CButtonsContainer.prototype.isEventListener = function (child) {
|
|
return this.eventListener === child;
|
|
};
|
|
CButtonsContainer.prototype.onScroll = function () {
|
|
var nOldScroll = this.scrollTop;
|
|
this.scrollTop = Math.max(0, Math.min(this.scroll.getScrollTop(), this.getScrolledRows()));
|
|
this.checkScrollTop();
|
|
if(this.scrollTop !== nOldScroll) {
|
|
for(var nButton = 0; nButton < this.buttons.length; ++nButton) {
|
|
var oButton = this.buttons[nButton];
|
|
oButton.recalculateTransform();
|
|
oButton.recalculateTransformText();
|
|
oButton.recalculateBounds();
|
|
}
|
|
this.onUpdate(this.getBounds());
|
|
}
|
|
};
|
|
CButtonsContainer.prototype.getBounds = function () {
|
|
var l, t, r, b;
|
|
var oTransform = this.slicer.transform;
|
|
l = oTransform.TransformPointX(this.x, this.y) - 0.5;
|
|
t = oTransform.TransformPointY(this.x, this.y) - 0.5;
|
|
r = oTransform.TransformPointX(this.x + this.extX, this.y + this.extY) + 0.5;
|
|
b = oTransform.TransformPointY(this.x + this.extX, this.y + this.extY) + 0.5;
|
|
return new AscFormat.CGraphicBounds(l, t, r, b);
|
|
};
|
|
CButtonsContainer.prototype.onUpdate = function (oBounds) {
|
|
this.slicer.onUpdate(oBounds);
|
|
};
|
|
CButtonsContainer.prototype.onMouseMove = function (e, x, y) {
|
|
if(this.eventListener) {
|
|
return this.eventListener.onMouseMove(e, x, y);
|
|
}
|
|
var bRet = false, nButton, nFindButton, nLast;
|
|
if(e.IsLocked) {
|
|
if(this.slicer.isEventListener(this)) {
|
|
bRet = true;
|
|
if(this.startButton > -1) {
|
|
var oButton = this.getButton(this.startButton);
|
|
if(oButton) {
|
|
nFindButton = this.findButtonIndex(x, y);
|
|
if(this.slicer.isMultiSelect() || e.CtrlKey) {
|
|
|
|
this.removeAllButtonsTmpState();
|
|
oButton.setHoverState();
|
|
if(nFindButton < this.startButton) {
|
|
for(nButton = Math.max(0, nFindButton); nButton <= this.startButton; ++nButton) {
|
|
this.buttons[nButton].setInvertSelectTmpState();
|
|
}
|
|
}
|
|
else {
|
|
nLast = Math.min(nFindButton, this.buttons.length - 1);
|
|
for(nButton = this.startButton; nButton <= nLast; ++nButton) {
|
|
this.buttons[nButton].setInvertSelectTmpState();
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
for(nButton = 0; nButton < this.buttons.length; ++nButton) {
|
|
this.buttons[nButton].setUnselectTmpState();
|
|
}
|
|
oButton.setHoverState();
|
|
if(nFindButton < this.startButton) {
|
|
for(nButton = Math.max(0, nFindButton); nButton <= this.startButton; ++nButton) {
|
|
this.buttons[nButton].setSelectTmpState();
|
|
}
|
|
}
|
|
else {
|
|
nLast = Math.min(nFindButton, this.buttons.length - 1);
|
|
for(nButton = this.startButton; nButton <= nLast; ++nButton) {
|
|
this.buttons[nButton].setSelectTmpState();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
bRet = false;
|
|
}
|
|
}
|
|
else {
|
|
if(this.slicer.isEventListener(this)) {
|
|
bRet = this.slicer.onMouseUp(e, x, y);
|
|
}
|
|
else {
|
|
for(nButton = 0; nButton < this.buttons.length; ++nButton) {
|
|
bRet |= this.buttons[nButton].onMouseMove(e, x, y);
|
|
}
|
|
bRet |= this.scroll.onMouseMove(e, x, y);
|
|
}
|
|
}
|
|
return bRet;
|
|
};
|
|
CButtonsContainer.prototype.onMouseDown = function (e, x, y) {
|
|
if(this.eventListener) {
|
|
this.onMouseUp(e, x, y);
|
|
if(!this.eventListener) {
|
|
return this.onMouseDown(e, x, y);
|
|
}
|
|
}
|
|
if(this.scroll.onMouseDown(e, x, y)) {
|
|
return true;
|
|
}
|
|
if(this.hit(x, y)) {
|
|
this.slicer.setEventListener(this);
|
|
var oInv = this.getInvFullTransformMatrix();
|
|
this.startX = oInv.TransformPointX(x, y);
|
|
this.startY = oInv.TransformPointY(x, y);
|
|
this.startButton = -1;
|
|
for(var nButton = 0; nButton < this.buttons.length; ++nButton) {
|
|
if(this.buttons[nButton].hit(x, y)) {
|
|
this.startButton = nButton;
|
|
break;
|
|
}
|
|
}
|
|
this.onMouseMove(e, x, y);
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
CButtonsContainer.prototype.onMouseUp = function (e, x, y) {
|
|
var bRet = false;
|
|
if(this.eventListener) {
|
|
bRet = this.eventListener.onMouseUp(e, x, y);
|
|
this.setEventListener(null);
|
|
return bRet;
|
|
}
|
|
if(!this.slicer.isEventListener(this)) {
|
|
for(var nButton = 0; nButton < this.buttons.length; ++nButton) {
|
|
bRet |= this.buttons[nButton].onMouseUp(e, x, y);
|
|
}
|
|
bRet |= this.scroll.onMouseUp(e, x, y);
|
|
this.setEventListener(null);
|
|
}
|
|
return bRet;
|
|
};
|
|
CButtonsContainer.prototype.onWheel = function (deltaX, deltaY) {
|
|
return this.scroll.onWheel(deltaX, deltaY);
|
|
};
|
|
CButtonsContainer.prototype.setEventListener = function (child) {
|
|
this.eventListener = child;
|
|
if(child) {
|
|
this.slicer.setEventListener(this);
|
|
}
|
|
else {
|
|
if(this.slicer.isEventListener(this)) {
|
|
this.slicer.setEventListener(null);
|
|
this.removeAllButtonsTmpState();
|
|
}
|
|
}
|
|
};
|
|
CButtonsContainer.prototype.getButtonState = function(nIndex) {
|
|
return this.slicer.getButtonState(nIndex);
|
|
};
|
|
CButtonsContainer.prototype.getString = function(nIndex) {
|
|
return this.slicer.getString(nIndex);
|
|
};
|
|
CButtonsContainer.prototype.getScrollOffsetX = function () {
|
|
return 0;
|
|
};
|
|
CButtonsContainer.prototype.getScrollOffsetY = function () {
|
|
return -(this.getRowStart(this.scrollTop) - this.y);
|
|
};
|
|
CButtonsContainer.prototype.selectAllButtons = function () {
|
|
for(var nButton = 0; nButton < this.buttons.length; ++nButton) {
|
|
this.buttons[nButton].setSelectTmpState();
|
|
}
|
|
};
|
|
CButtonsContainer.prototype.removeAllButtonsTmpState = function () {
|
|
for(var nButton = 0; nButton < this.buttons.length; ++nButton) {
|
|
this.buttons[nButton].removeTmpState();
|
|
}
|
|
};
|
|
CButtonsContainer.prototype.getIcon = function (nIndex, nType) {
|
|
return null;
|
|
};
|
|
CButtonsContainer.prototype.getCursorInfo = function (e, x, y) {
|
|
if(!this.hit(x, y)) {
|
|
return null;
|
|
}
|
|
var oRet;
|
|
for(var i = 0; i < this.buttons.length; ++i) {
|
|
oRet = this.buttons[i].getCursorInfo(e, x, y);
|
|
if(oRet) {
|
|
return oRet;
|
|
}
|
|
}
|
|
return {
|
|
cursorType: "default",
|
|
tooltip: null
|
|
}
|
|
};
|
|
CButtonsContainer.prototype.getTooltipText = function (nIndex) {
|
|
return this.getString(nIndex)
|
|
};
|
|
|
|
function CScrollButton(parent, type) {
|
|
CInterfaceButton.call(this, parent);
|
|
this.type = type;
|
|
}
|
|
CScrollButton.prototype = Object.create(CInterfaceButton.prototype);
|
|
CScrollButton.prototype.draw = function (graphics) {
|
|
CInterfaceButton.prototype.draw.call(this, graphics);
|
|
var dInd = this.extX / 4.0;
|
|
var dMid = this.extX / 2.0;
|
|
|
|
var nColor = SCROLL_ARROW_COLORS[this.getState()];
|
|
graphics.b_color1((nColor >> 16) & 0xFF, (nColor >> 8) & 0xFF, nColor & 0xFF, 0xFF);
|
|
if(this.type === SCROLL_BUTTON_TYPE_TOP) {
|
|
graphics.SaveGrState();
|
|
graphics.transform3(this.transform);
|
|
graphics._s();
|
|
graphics._m(dInd, dMid);
|
|
graphics._l(dMid, dInd);
|
|
graphics._l(this.extX - dInd, dMid);
|
|
graphics._z();
|
|
graphics.df();
|
|
graphics.RestoreGrState();
|
|
}
|
|
else if(this.type === SCROLL_BUTTON_TYPE_BOTTOM) {
|
|
graphics.SaveGrState();
|
|
graphics.transform3(this.transform);
|
|
graphics._s();
|
|
graphics._m(dInd, dMid);
|
|
graphics._l(dMid, this.extY - dInd);
|
|
graphics._l(this.extX - dInd, dMid);
|
|
graphics._z();
|
|
graphics.df();
|
|
graphics.RestoreGrState();
|
|
}
|
|
};
|
|
|
|
function CScroll(parent) {
|
|
this.parent = parent;
|
|
this.extX = 0;
|
|
this.extY = 0;
|
|
this.bVisible = false;
|
|
this.buttons = [];
|
|
this.buttons[0] = new CScrollButton(this, SCROLL_BUTTON_TYPE_TOP);
|
|
this.buttons[1] = new CScrollButton(this, SCROLL_BUTTON_TYPE_BOTTOM);
|
|
this.state = STYLE_TYPE.UNSELECTED_DATA;
|
|
this.timerId = null;
|
|
|
|
this.tmpScrollerPos = null;
|
|
this.startScrollerPos = null;
|
|
this.startScrollTop = null;
|
|
}
|
|
CScroll.prototype.getBounds = function() {
|
|
var oTransform = this.getFullTransformMatrix();
|
|
var x = this.getPosX();
|
|
var y = this.getPosY();
|
|
var extX = this.getWidth();
|
|
var extY = this.getHeight();
|
|
var l = oTransform.TransformPointX(x, y);
|
|
var t = oTransform.TransformPointY(x, y);
|
|
var r = oTransform.TransformPointX(x + extX, y + extY);
|
|
var b = oTransform.TransformPointY(x + extX, y + extY);
|
|
return new AscFormat.CGraphicBounds(l, t, r, b);
|
|
};
|
|
CScroll.prototype.getTxStyles = function () {
|
|
return this.parent.getTxStyles();
|
|
};
|
|
CScroll.prototype.getFullTransformMatrix = function () {
|
|
return this.parent.getFullTransformMatrix();
|
|
};
|
|
CScroll.prototype.getInvFullTransformMatrix = function () {
|
|
return this.parent.getInvFullTransformMatrix();
|
|
};
|
|
CScroll.prototype.getFill = function (nType) {
|
|
var oFill = new AscCommonExcel.Fill();
|
|
oFill.fromColor(new AscCommonExcel.RgbColor(SCROLL_COLORS[nType]));
|
|
return oFill;
|
|
};
|
|
CScroll.prototype.getBorder = function(nType) {
|
|
var r, g, b;
|
|
r = 0xCE;
|
|
g = 0xCE;
|
|
b = 0xCE;
|
|
var oBorder = new AscCommonExcel.Border();
|
|
oBorder.initDefault();
|
|
oBorder.l = new AscCommonExcel.BorderProp();
|
|
oBorder.l.setStyle(Asc.c_oAscBorderStyles.Thin);
|
|
oBorder.l.c = AscCommonExcel.createRgbColor(r, g, b);
|
|
oBorder.t = new AscCommonExcel.BorderProp();
|
|
oBorder.t.setStyle(Asc.c_oAscBorderStyles.Thin);
|
|
oBorder.t.c = AscCommonExcel.createRgbColor(r, g, b);
|
|
oBorder.r = new AscCommonExcel.BorderProp();
|
|
oBorder.r.setStyle(Asc.c_oAscBorderStyles.Thin);
|
|
oBorder.r.c = AscCommonExcel.createRgbColor(r, g, b);
|
|
oBorder.b = new AscCommonExcel.BorderProp();
|
|
oBorder.b.setStyle(Asc.c_oAscBorderStyles.Thin);
|
|
oBorder.b.c = AscCommonExcel.createRgbColor(r, g, b);
|
|
return oBorder;
|
|
};
|
|
CScroll.prototype.getPosX = function () {
|
|
return this.parent.x + this.parent.extX - this.getWidth();
|
|
};
|
|
CScroll.prototype.getPosY = function () {
|
|
return this.parent.y;
|
|
};
|
|
CScroll.prototype.getHeight = function() {
|
|
return this.parent.extY;
|
|
};
|
|
CScroll.prototype.getWidth = function() {
|
|
return SCROLL_WIDTH;
|
|
};
|
|
CScroll.prototype.getButtonContainerPosX = function(nIndex) {
|
|
return this.getPosX();
|
|
};
|
|
CScroll.prototype.getButtonContainerPosY = function(nIndex) {
|
|
var dRet = 0;
|
|
if(nIndex === 0) {
|
|
dRet = this.getPosY();
|
|
}
|
|
else {
|
|
dRet = this.getPosY() + this.getHeight() - this.getButtonContainerSize();
|
|
}
|
|
return dRet;
|
|
};
|
|
CScroll.prototype.getButtonContainerSize = function() {
|
|
return this.getWidth();
|
|
};
|
|
CScroll.prototype.getButtonPosX = function (nIndex) {
|
|
return this.getButtonContainerPosX(nIndex) + this.getButtonContainerSize() / 2 - this.getButtonSize() / 2;
|
|
};
|
|
CScroll.prototype.getButtonPosY = function (nIndex) {
|
|
return this.getButtonContainerPosY(nIndex) + this.getButtonContainerSize() / 2 - this.getButtonSize() / 2;
|
|
};
|
|
CScroll.prototype.getButtonSize = function () {
|
|
return this.getScrollerWidth();
|
|
};
|
|
CScroll.prototype.getRailPosX = function () {
|
|
return this.getPosX() + this.getWidth() / 2 - this.getRailWidth() / 2;
|
|
};
|
|
CScroll.prototype.getRailPosY = function () {
|
|
return this.getPosY() + this.getButtonContainerSize();
|
|
};
|
|
CScroll.prototype.getRailHeight = function() {
|
|
return this.getHeight() - 2 * this.getButtonContainerSize();
|
|
};
|
|
CScroll.prototype.getRailWidth = function() {
|
|
return SCROLLER_WIDTH;
|
|
};
|
|
CScroll.prototype.getScrollerX = function() {
|
|
return this.getRailPosX() + this.getRailWidth() / 2 - this.getScrollerWidth() / 2;
|
|
};
|
|
CScroll.prototype.internalGetRelScrollerY = function(nPos) {
|
|
return (this.getRailHeight() - this.getScrollerHeight()) * (nPos/ (this.parent.getScrolledRows()));
|
|
};
|
|
CScroll.prototype.getRelScrollerY = function() {
|
|
if(this.tmpScrollerPos !== null) {
|
|
return this.tmpScrollerPos;
|
|
}
|
|
return this.internalGetRelScrollerY(this.parent.scrollTop);
|
|
};
|
|
CScroll.prototype.getMaxRelScrollerY = function() {
|
|
return this.internalGetRelScrollerY(this.parent.getScrolledRows());
|
|
};
|
|
CScroll.prototype.getScrollerY = function() {
|
|
return this.getRailPosY() + this.getRelScrollerY();
|
|
};
|
|
CScroll.prototype.getScrollerWidth = function() {
|
|
return this.getRailWidth();
|
|
};
|
|
CScroll.prototype.getScrollTop = function() {
|
|
return this.parent.getScrolledRows() * (this.getScrollerY() - this.getRailPosY()) / (this.getRailHeight() - this.getScrollerHeight()) + 0.5 >> 0;
|
|
};
|
|
CScroll.prototype.getScrollerHeight = function() {
|
|
var dRailH = this.getRailHeight();
|
|
var dMinRailH = dRailH / 4;
|
|
return Math.max(dMinRailH, dRailH * (dRailH / this.parent.getTotalHeight()));
|
|
};
|
|
CScroll.prototype.getState = function() {
|
|
return this.state;
|
|
};
|
|
CScroll.prototype.getString = function() {
|
|
return "";
|
|
};
|
|
CScroll.prototype.getButtonState = function(nIndex) {
|
|
return this.state;
|
|
};
|
|
CScroll.prototype.hit = function(x, y) {
|
|
if(!this.bVisible) {
|
|
return false;
|
|
}
|
|
var oInv = this.parent.getInvFullTransformMatrix();
|
|
var tx = oInv.TransformPointX(x, y);
|
|
var ty = oInv.TransformPointY(x, y);
|
|
var l = this.getPosX();
|
|
var t = this.getPosY();
|
|
var r = l + this.getWidth();
|
|
var b = t + this.getHeight();
|
|
return tx >= l && tx <= r && ty >= t && ty <= b;
|
|
};
|
|
CScroll.prototype.hitInScroller = function(x, y) {
|
|
if(!this.bVisible) {
|
|
return false;
|
|
}
|
|
var oInv = this.parent.getInvFullTransformMatrix();
|
|
var tx = oInv.TransformPointX(x, y);
|
|
var ty = oInv.TransformPointY(x, y);
|
|
var l = this.getScrollerX();
|
|
var t = this.getScrollerY();
|
|
var r = l + this.getScrollerWidth();
|
|
var b = t + this.getScrollerHeight();
|
|
return tx >= l && tx <= r && ty >= t && ty <= b;
|
|
};
|
|
CScroll.prototype.draw = function(graphics) {
|
|
if(!this.bVisible) {
|
|
return;
|
|
}
|
|
var oUR = graphics.updatedRect;
|
|
if(oUR) {
|
|
if(!oUR.isIntersectOther(this.getBounds())) {
|
|
return;
|
|
}
|
|
}
|
|
var x, y, extX, extY, oButton;
|
|
oButton = this.buttons[0];
|
|
x = this.getButtonPosX(0);
|
|
y = this.getButtonPosY(0);
|
|
extX = this.getButtonSize();
|
|
extY = this.getButtonSize();
|
|
oButton.setTransformParams(x, y, extX, extY, 0, false, false);
|
|
oButton.recalculate();
|
|
oButton.draw(graphics);
|
|
oButton = this.buttons[1];
|
|
x = this.getButtonPosX(1);
|
|
y = this.getButtonPosY(1);
|
|
oButton.setTransformParams(x, y, extX, extY, 0, false, false);
|
|
oButton.recalculate();
|
|
oButton.draw(graphics);
|
|
|
|
x = this.getScrollerX();
|
|
y = this.getScrollerY();
|
|
extX = this.getScrollerWidth();
|
|
extY = this.getScrollerHeight();
|
|
var nColor = SCROLL_COLORS[this.getState()];
|
|
|
|
graphics.SaveGrState();
|
|
graphics.transform3(this.parent.getFullTransformMatrix());
|
|
graphics.p_color(0xCE, 0xCE, 0xCE, 0xFF);
|
|
graphics.b_color1((nColor >> 16) & 0xFF, (nColor >> 8) & 0xFF, nColor & 0xFF, 0xFF);
|
|
graphics.rect(x, y, extX, extY);
|
|
graphics.df();
|
|
|
|
graphics.p_width(0);
|
|
graphics.drawHorLine(0, y, x, x + extX, 0);
|
|
graphics.drawHorLine(0, y + extY, x, x + extX, 0);
|
|
graphics.drawVerLine(2, x, y, y + extY, 0);
|
|
graphics.drawVerLine(2, x + extX, y, y + extY, 0);
|
|
graphics.RestoreGrState();
|
|
};
|
|
CScroll.prototype.onMouseMove = function (e, x, y) {
|
|
if(!this.bVisible) {
|
|
return false;
|
|
}
|
|
var bRet = false;
|
|
if(this.eventListener) {
|
|
this.eventListener.onMouseMove(e, x, y);
|
|
return true;
|
|
}
|
|
if(this.parent.isEventListener(this)){
|
|
if(this.startScrollerPos === null) {
|
|
this.startScrollerPos = y;
|
|
}
|
|
if(this.startScrollTop === null) {
|
|
this.startScrollTop = this.parent.scrollTop;
|
|
}
|
|
var dy = y - this.startScrollerPos;
|
|
this.setTmpScroll(dy + this.internalGetRelScrollerY(this.startScrollTop));
|
|
return true;
|
|
}
|
|
bRet |= this.buttons[0].onMouseMove(e, x, y);
|
|
bRet |= this.buttons[1].onMouseMove(e, x, y);
|
|
|
|
//TODO: Use object for scroller
|
|
var bHit = this.hitInScroller(x, y);
|
|
var nState = this.getState();
|
|
if(nState & STATE_FLAG_HOVERED) {
|
|
if(!bHit) {
|
|
this.setState(nState & (~STATE_FLAG_HOVERED));
|
|
bRet = true;
|
|
}
|
|
}
|
|
else {
|
|
if(bHit) {
|
|
this.setState(nState | STATE_FLAG_HOVERED);
|
|
bRet = true;
|
|
}
|
|
}
|
|
//-----------------------------
|
|
return bRet;
|
|
};
|
|
CScroll.prototype.onMouseDown = function (e, x, y) {
|
|
var bRet = false;
|
|
if(this.hit(x, y)) {
|
|
bRet |= this.buttons[0].onMouseDown(e, x, y);
|
|
bRet |= this.buttons[1].onMouseDown(e, x, y);
|
|
if(!bRet) {
|
|
if(this.hitInScroller(x, y)) {
|
|
//TODO: Use object for scroller
|
|
this.startScrollerPos = y;
|
|
this.startScrollTop = this.parent.scrollTop;
|
|
this.setState(this.state | STATE_FLAG_SELECTED);
|
|
this.parent.setEventListener(this);
|
|
this.parent.onScroll();
|
|
//-----------------------------
|
|
}
|
|
else {
|
|
this.parent.setEventListener(this);
|
|
var oInv = this.parent.getInvFullTransformMatrix();
|
|
var ty = oInv.TransformPointY(x, y);
|
|
if(ty < this.getScrollerY()) {
|
|
this.startScroll(-this.internalGetRelScrollerY(3));
|
|
}
|
|
else {
|
|
this.startScroll(this.internalGetRelScrollerY(3));
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
return bRet;
|
|
};
|
|
CScroll.prototype.onMouseUp = function (e, x, y) {
|
|
this.endScroll();
|
|
var bRet = false;
|
|
if(this.eventListener) {
|
|
bRet = this.eventListener.onMouseUp(e, x, y);
|
|
this.eventListener = null;
|
|
return bRet;
|
|
}
|
|
bRet |= this.buttons[0].onMouseUp(e, x, y);
|
|
bRet |= this.buttons[1].onMouseUp(e, x, y);
|
|
this.setEventListener(null);
|
|
return bRet;
|
|
};
|
|
CScroll.prototype.isButtonDisabled = function (nIndex) {
|
|
return !this.bVisible;
|
|
};
|
|
CScroll.prototype.isEventListener = function (child) {
|
|
return this.eventListener === child;
|
|
};
|
|
CScroll.prototype.getButtonIndex = function (oButton) {
|
|
for(var nButton = 0; nButton < this.buttons.length; ++nButton) {
|
|
if(this.buttons[nButton] === oButton) {
|
|
return nButton;
|
|
}
|
|
}
|
|
return -1;
|
|
};
|
|
CScroll.prototype.setEventListener = function (child) {
|
|
this.eventListener = child;
|
|
if(child) {
|
|
this.parent.setEventListener(this);
|
|
}
|
|
else {
|
|
if(this.parent.isEventListener(this)) {
|
|
this.parent.setEventListener(null);
|
|
}
|
|
}
|
|
};
|
|
CScroll.prototype.getParentObjects = function () {
|
|
return this.parent.getParentObjects();
|
|
};
|
|
CScroll.prototype.handleMouseUp = function (nIndex) {
|
|
var oButton = this.buttons[nIndex];
|
|
if(!oButton) {
|
|
return;
|
|
}
|
|
oButton.setUnselectTmpState();
|
|
};
|
|
CScroll.prototype.handleMouseDown = function (nIndex) {
|
|
var oButton = this.buttons[nIndex];
|
|
if(!oButton) {
|
|
return;
|
|
}
|
|
oButton.setSelectTmpState();
|
|
if(nIndex === 0) {
|
|
this.startScroll(-this.internalGetRelScrollerY(1));
|
|
}
|
|
else {
|
|
this.startScroll(this.internalGetRelScrollerY(1));
|
|
}
|
|
};
|
|
CScroll.prototype.startScroll = function (step) {
|
|
this.endScroll();
|
|
var oScroll = this;
|
|
oScroll.addScroll(step);
|
|
this.timerId = setInterval(function () {
|
|
oScroll.addScroll(step);
|
|
}, SCROLL_TIMER_INTERVAL);
|
|
};
|
|
CScroll.prototype.addScroll = function (step) {
|
|
this.setTmpScroll(this.getRelScrollerY() + step);
|
|
this.parent.onScroll();
|
|
};
|
|
CScroll.prototype.setTmpScroll = function (val) {
|
|
this.tmpScrollerPos = Math.max(0, Math.min(this.getMaxRelScrollerY(), val));
|
|
this.parent.onScroll();
|
|
this.onUpdate(this.getBounds());
|
|
};
|
|
CScroll.prototype.clearTmpScroll = function () {
|
|
if(this.tmpScrollerPos !== null) {
|
|
this.tmpScrollerPos = null;
|
|
this.parent.onScroll();
|
|
this.onUpdate(this.getBounds());
|
|
}
|
|
};
|
|
CScroll.prototype.endScroll = function () {
|
|
if(this.timerId !== null) {
|
|
clearInterval(this.timerId);
|
|
this.timerId = null;
|
|
}
|
|
this.clearTmpScroll();
|
|
this.setState(this.state & (~STATE_FLAG_SELECTED));
|
|
this.startScrollerPos = null;
|
|
this.startScrollTop = null;
|
|
};
|
|
CScroll.prototype.getScrollOffsetX = function () {
|
|
return 0;
|
|
};
|
|
CScroll.prototype.getScrollOffsetY = function () {
|
|
return 0;
|
|
};
|
|
CScroll.prototype.recalculate = function () {
|
|
this.buttons[0].recalculate();
|
|
this.buttons[1].recalculate();
|
|
};
|
|
CScroll.prototype.onWheel = function (deltaX, deltaY) {
|
|
if(!this.bVisible) {
|
|
return false;
|
|
}
|
|
var delta = deltaY;
|
|
if(Math.abs(deltaX) > Math.abs(deltaY)) {
|
|
delta = deltaX;
|
|
}
|
|
if(delta > 0) {
|
|
this.addScroll(this.internalGetRelScrollerY(3));
|
|
}
|
|
else if(delta < 0) {
|
|
this.addScroll(-this.internalGetRelScrollerY(3));
|
|
}
|
|
this.endScroll();
|
|
return true;
|
|
};
|
|
CScroll.prototype.getIcon = function(nIndex, nType) {
|
|
return null;
|
|
};
|
|
CScroll.prototype.onUpdate = function(oBounds) {
|
|
this.parent.onUpdate(oBounds);
|
|
};
|
|
CScroll.prototype.setState = function(nState) {
|
|
var nOld = this.state;
|
|
this.state = nState;
|
|
if(this.state !== nOld) {
|
|
this.onUpdate(this.getBounds());
|
|
}
|
|
};
|
|
|
|
|
|
AscDFH.changesFactory[AscDFH.historyitem_TimelineSlicerViewName] = AscDFH.CChangesDrawingsString;
|
|
AscDFH.drawingsChangesMap[AscDFH.historyitem_TimelineSlicerViewName] = function(oClass, value) {
|
|
oClass.tag = value;
|
|
};
|
|
|
|
function CTimeslicer() {
|
|
AscFormat.CShape.call(this);
|
|
this.name = null;
|
|
}
|
|
AscFormat.InitClass(CTimeslicer, AscFormat.CShape, AscDFH.historyitem_type_TimelineSlicerView);
|
|
CTimeslicer.prototype.setName = function (val) {
|
|
AscCommon.History.Add(new AscDFH.CChangesDrawingsString(this, AscDFH.historyitem_TimelineSlicerViewName, this.name, val));
|
|
this.name = val;
|
|
};
|
|
|
|
CTimeslicer.prototype.copy = function (oPr) {
|
|
const oCopy = new CTimeslicer();
|
|
oCopy.setTag(this.tag);
|
|
return oCopy;
|
|
};
|
|
CTimeslicer.prototype.fromStream = function (s) {
|
|
var _len = s.GetULong();
|
|
var _start_pos = s.cur;
|
|
var _end_pos = _len + _start_pos;
|
|
var _at;
|
|
// attributes
|
|
s.GetUChar();
|
|
while (true) {
|
|
_at = s.GetUChar();
|
|
if (_at === AscCommon.g_nodeAttributeEnd)
|
|
break;
|
|
switch (_at) {
|
|
case 0: {
|
|
this.setName(s.GetString2());
|
|
break;
|
|
}
|
|
default: {
|
|
s.Seek2(_end_pos);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
s.Seek2(_end_pos);
|
|
};
|
|
CTimeslicer.prototype.toStream = function (s) {
|
|
s.WriteUChar(AscCommon.g_nodeAttributeStart);
|
|
s._WriteString2(0, this.name);
|
|
s.WriteUChar(AscCommon.g_nodeAttributeEnd);
|
|
};
|
|
CTimeslicer.prototype.canSelect = function () {
|
|
return false;
|
|
};
|
|
CTimeslicer.prototype.hit = function () {
|
|
return false;
|
|
};
|
|
|
|
CTimeslicer.prototype.onTimeSlicerDelete = function (sName) {
|
|
return CSlicer.prototype.onSlicerDelete.call(this, sName);
|
|
};
|
|
window["AscFormat"] = window["AscFormat"] || {};
|
|
window["AscFormat"].CSlicer = CSlicer;
|
|
window["AscFormat"].CTimeslicer = CTimeslicer;
|
|
|
|
window["AscCommonExcel"] = window["AscCommonExcel"] || {};
|
|
window["AscCommonExcel"].getSlicerIconsForLoad = getSlicerIconsForLoad;
|
|
|
|
})();
|