1044 lines
31 KiB
JavaScript
1044 lines
31 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";
|
||
|
||
(/**
|
||
* @param {Window} window
|
||
* @param {undefined} undefined
|
||
*/
|
||
function (window, undefined) {
|
||
var cErrorType = AscCommonExcel.cErrorType;
|
||
var cNumber = AscCommonExcel.cNumber;
|
||
var cString = AscCommonExcel.cString;
|
||
var cBool = AscCommonExcel.cBool;
|
||
var cEmpty = AscCommonExcel.cEmpty;
|
||
var cError = AscCommonExcel.cError;
|
||
var cArea = AscCommonExcel.cArea;
|
||
var cArea3D = AscCommonExcel.cArea3D;
|
||
var cRef = AscCommonExcel.cRef;
|
||
var cRef3D = AscCommonExcel.cRef3D;
|
||
var cArray = AscCommonExcel.cArray;
|
||
var cBaseFunction = AscCommonExcel.cBaseFunction;
|
||
var cFormulaFunctionGroup = AscCommonExcel.cFormulaFunctionGroup;
|
||
var cElementType = AscCommonExcel.cElementType;
|
||
var argType = Asc.c_oAscFormulaArgumentType;
|
||
|
||
function getCellFormat(ws, row, col) {
|
||
let res = new cString("G");
|
||
let formatInfo, sFormat, numFormat;
|
||
ws.getCell3(row, col)._foreachNoEmpty(function (cell) {
|
||
numFormat = cell ? cell.getNumFormat() : null;
|
||
formatInfo = numFormat ? numFormat.getTypeInfo() : null;
|
||
sFormat = numFormat ? numFormat.sFormat : null;
|
||
});
|
||
//такие форматы как дата не поддерживаются
|
||
//TODO функция нуждается в доработке
|
||
if (formatInfo) {
|
||
let postfix = "";
|
||
if (numFormat && (numFormat.oNegativeFormat && numFormat.oNegativeFormat.Color !== -1)) {
|
||
postfix += "-";
|
||
}
|
||
if (numFormat && numFormat.oPositiveFormat && numFormat.oPositiveFormat.formatString.indexOf('(') != -1) {
|
||
postfix += "()";
|
||
}
|
||
|
||
let formatPart;
|
||
if (formatInfo.type === Asc.c_oAscNumFormatType.Number) {
|
||
formatPart = "F";
|
||
} else if (formatInfo.type === Asc.c_oAscNumFormatType.Currency || formatInfo.type === Asc.c_oAscNumFormatType.Accounting) {
|
||
formatPart = "С";
|
||
} else if (formatInfo.type === Asc.c_oAscNumFormatType.Percent) {
|
||
formatPart = "P";
|
||
} else if (formatInfo.type === Asc.c_oAscNumFormatType.Scientific) {
|
||
formatPart = "S";
|
||
} else if (formatInfo.type === Asc.c_oAscNumFormatType.Date || formatInfo.type === Asc.c_oAscNumFormatType.Time) {
|
||
formatPart = "D";
|
||
}
|
||
|
||
// ,0 and ,2 types
|
||
if (sFormat) {
|
||
if (sFormat === "#,##0") {
|
||
formatPart = ",0";
|
||
formatInfo.decimalPlaces = "";
|
||
} else if (sFormat === "#,##0.00") {
|
||
formatPart = ",2";
|
||
formatInfo.decimalPlaces = "";
|
||
}
|
||
}
|
||
|
||
if (formatPart) {
|
||
if (formatPart === "D") {
|
||
let regularD1 = /d+[\s\/-]m+[\s\/-]y+/gi, // d-mmm-yy || dd-mmm-yy
|
||
regularD2 = /d+(\s|-|\/)m+;/gi, // d-mmm || dd-mmm
|
||
regularD3 = /]m+(\s|-|\/)y+;/gi, // mmm-yy
|
||
regularD4 = /m+(\s|-|\/)d+(\s|-|\/)y+/gi, // m/d/yy || m/d/yy h:mm || mm/dd/yy
|
||
regularD5 = /^m+(\s|-|\/)d+;/gi, // mm/dd
|
||
regularD6 = /h+:m+:s+\sAM\/PM/gi, // h:mm:ss AM/PM
|
||
regularD7 = /h+:m+\sAM\/PM/gi, // h:mm AM/PM
|
||
regularD8 = /(((h|\[h\]):m+:ss;)|(\[\$-F400\]h:mm:ss))/gi, // h:mm:ss
|
||
regularD9 = /h+:m+;/gi; // h:mm
|
||
|
||
if (regularD1.test(sFormat)) {
|
||
formatInfo.decimalPlaces = 1;
|
||
} else if (regularD2.test(sFormat)) {
|
||
formatInfo.decimalPlaces = 2;
|
||
} else if (regularD3.test(sFormat)) {
|
||
formatInfo.decimalPlaces = 3;
|
||
} else if (regularD4.test(sFormat)) {
|
||
formatInfo.decimalPlaces = 4;
|
||
} else if (regularD5.test(sFormat)) {
|
||
formatInfo.decimalPlaces = 5;
|
||
} else if (regularD6.test(sFormat)) {
|
||
formatInfo.decimalPlaces = 6;
|
||
} else if (regularD7.test(sFormat)) {
|
||
formatInfo.decimalPlaces = 7;
|
||
} else if (regularD8.test(sFormat)) {
|
||
formatInfo.decimalPlaces = 8;
|
||
} else if (regularD9.test(sFormat)) {
|
||
formatInfo.decimalPlaces = 9;
|
||
} else {
|
||
formatPart = "G";
|
||
formatInfo.decimalPlaces = "";
|
||
}
|
||
}
|
||
res = new cString(formatPart + formatInfo.decimalPlaces + postfix);
|
||
}
|
||
}
|
||
|
||
return res;
|
||
}
|
||
|
||
function getNumFormat(ws, row, col) {
|
||
var numFormat = null;
|
||
|
||
ws.getCell3(row, col)._foreachNoEmpty(function (cell) {
|
||
numFormat = cell ? cell.getNumFormat() : null;
|
||
});
|
||
|
||
return numFormat;
|
||
}
|
||
|
||
cFormulaFunctionGroup['Information'] = cFormulaFunctionGroup['Information'] || [];
|
||
cFormulaFunctionGroup['Information'].push(cCell, cERROR_TYPE, cISBLANK, cISERR, cISERROR, cISEVEN, cISFORMULA, cISLOGICAL,
|
||
cISNA, cISNONTEXT, cISNUMBER, cISODD, cISREF, cISTEXT, cN, cNA, cSHEET, cSHEETS, cTYPE);
|
||
|
||
|
||
/**
|
||
* @constructor
|
||
* @extends {AscCommonExcel.cBaseFunction}
|
||
*/
|
||
function cCell() {
|
||
}
|
||
|
||
//***array-formula***
|
||
cCell.prototype = Object.create(cBaseFunction.prototype);
|
||
cCell.prototype.constructor = cCell;
|
||
cCell.prototype.name = 'CELL';
|
||
cCell.prototype.argumentsMin = 2;
|
||
cCell.prototype.argumentsMax = 2;
|
||
cCell.prototype.ca = true;
|
||
cCell.prototype.returnValueType = AscCommonExcel.cReturnFormulaType.area_to_ref;
|
||
cCell.prototype.argumentsType = [argType.text, argType.reference];
|
||
cCell.prototype.numFormat = AscCommonExcel.cNumFormatNone;
|
||
cCell.prototype.Calculate = function (arg, opt_bbox, opt_defName, ws) {
|
||
//специально ввожу ограничения - минимум 2 аргумента
|
||
//в случае одного аргумента необходимо следить всегда за последней измененной ячейкой
|
||
//так же при сборке необходимо записывать данные об последней измененной ячейке
|
||
//нужно дли это ?
|
||
let arg0 = arg[0];
|
||
let arg1 = arg[1];
|
||
arg0 = arg0.tocString();
|
||
|
||
if (cElementType.error === arg0.type) {
|
||
return arg0;
|
||
} else {
|
||
let str = arg0.toString().toLowerCase();
|
||
|
||
//если первый аргумент из набора тех, которые не требуют значения второго аргумента, то обрабатываем его частично
|
||
let needCheckVal2Arg = {"contents": 1, "type": 1};
|
||
|
||
let cell, bbox;
|
||
if (arg1) {
|
||
//TODO добавил заглушку, на случай если приходит массив.
|
||
// необходимо пересмотреть - сейчас мы рассматриваем как функции массива все дочерние элементы аргумента с типом .reference
|
||
if (cElementType.array === arg1.type) {
|
||
arg1 = arg1.getElementRowCol(0, 0);
|
||
}
|
||
if (str === "contents") {
|
||
// Save ref for recursion check
|
||
AscCommonExcel.g_cCalcRecursion.saveFunctionResult(this.name, arg1);
|
||
}
|
||
|
||
let isRangeArg1 = cElementType.cellsRange === arg1.type || cElementType.cellsRange3D === arg1.type;
|
||
if (isRangeArg1 || cElementType.cell === arg1.type || cElementType.cell3D === arg1.type) {
|
||
if (needCheckVal2Arg[str]) {
|
||
let _tempValue = isRangeArg1 ? arg1.getValueByRowCol(0, 0) : arg1.getValue();
|
||
if (_tempValue instanceof cError) {
|
||
return _tempValue;
|
||
}
|
||
}
|
||
bbox = arg1.getRange();
|
||
bbox = bbox && bbox.bbox;
|
||
} else {
|
||
return new cError(cErrorType.wrong_name);
|
||
}
|
||
}
|
||
|
||
let api = window["Asc"]["editor"];
|
||
let printOptionsJson = api && api.wb && api.wb.getPrintOptionsJson && api.wb.getPrintOptionsJson();
|
||
let spreadsheetLayout = printOptionsJson && printOptionsJson["spreadsheetLayout"];
|
||
let _cCellFunctionLocal;
|
||
if (spreadsheetLayout && spreadsheetLayout["formulaProps"] && spreadsheetLayout["formulaProps"]["cellFunctionTypeTranslate"]) {
|
||
_cCellFunctionLocal = spreadsheetLayout["formulaProps"]["cellFunctionTypeTranslate"];
|
||
} else {
|
||
_cCellFunctionLocal = window["AscCommon"].cCellFunctionLocal;
|
||
}
|
||
|
||
let res, numFormat;
|
||
switch (str) {
|
||
case "col":
|
||
case _cCellFunctionLocal["col"]: {
|
||
res = new cNumber(bbox.c1 + 1);
|
||
break;
|
||
}
|
||
case "row":
|
||
case _cCellFunctionLocal["row"]: {
|
||
res = new cNumber(bbox.r1 + 1);
|
||
break;
|
||
}
|
||
case "sheet":
|
||
case _cCellFunctionLocal["sheet"]: {
|
||
//нет в офф. документации
|
||
//ms excel returns 1?
|
||
res = new cNumber(1);
|
||
break;
|
||
}
|
||
case "address":
|
||
case _cCellFunctionLocal["address"]: {
|
||
res = new Asc.Range(bbox.c1, bbox.r1, bbox.c1, bbox.r1);
|
||
res = new cString(res.getAbsName());
|
||
break;
|
||
}
|
||
case "filename":
|
||
case _cCellFunctionLocal["filename"]: {
|
||
//TODO без пути
|
||
let fileName;
|
||
if (spreadsheetLayout && spreadsheetLayout["formulaProps"] && spreadsheetLayout["formulaProps"]["docTitle"]) {
|
||
fileName = spreadsheetLayout["formulaProps"]["docTitle"];
|
||
} else {
|
||
let docInfo = api.DocInfo;
|
||
fileName = docInfo ? docInfo.get_Title() : "";
|
||
}
|
||
|
||
let _ws = arg1.getWS();
|
||
let sheetName = _ws ? _ws.getName() : null;
|
||
if (sheetName) {
|
||
res = new cString("[" + fileName + "]" + sheetName);
|
||
} else {
|
||
res = new cEmpty();
|
||
}
|
||
break;
|
||
}
|
||
case "coord":
|
||
case _cCellFunctionLocal["coord"]: {
|
||
//нет в офф. документации
|
||
break;
|
||
}
|
||
case "contents":
|
||
case _cCellFunctionLocal["contents"]: {
|
||
if (cElementType.cell === arg1.type || cElementType.cell3D === arg1.type) {
|
||
res = arg1.getValue();
|
||
} else {
|
||
res = arg1.getValue()[0];
|
||
if (!res) {
|
||
res = new cNumber(0);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
case "type":
|
||
case _cCellFunctionLocal["type"]: {
|
||
// b = blank; l = string (label); v = otherwise (value)
|
||
res = arg1.getValue();
|
||
if (res.type === cElementType.empty) {
|
||
res = new cString("b");
|
||
} else if (res.type === cElementType.string) {
|
||
res = new cString("l");
|
||
} else {
|
||
res = new cString("v");
|
||
}
|
||
break;
|
||
}
|
||
case "width":
|
||
case _cCellFunctionLocal["width"]: {
|
||
//return array
|
||
//{width 1 column; is default}
|
||
let col = ws._getCol(bbox.c1);
|
||
let props = col ? col.getWidthProp() : null;
|
||
let isDefault = !props.CustomWidth;
|
||
let width, colWidthPx;
|
||
if (isDefault) {
|
||
let defaultColWidthChars = ws.charCountToModelColWidth(ws.getBaseColWidth());
|
||
colWidthPx = ws.modelColWidthToColWidth(defaultColWidthChars);
|
||
colWidthPx = Asc.ceil(colWidthPx / 8) * 8;
|
||
width = ws.colWidthToCharCount(colWidthPx);
|
||
} else {
|
||
colWidthPx = ws.modelColWidthToColWidth(props.width);
|
||
width = ws.colWidthToCharCount(colWidthPx);
|
||
}
|
||
|
||
if (props) {
|
||
res = new cArray();
|
||
res.addElement(new cNumber(Math.round(width)));
|
||
res.addElement(new cBool(isDefault));
|
||
}
|
||
|
||
break;
|
||
}
|
||
case "prefix":
|
||
case _cCellFunctionLocal["prefix"]: {
|
||
// ' = left; " = right; ^ = centered; \ =
|
||
cell = ws.getCell3(bbox.r1, bbox.c1);
|
||
let align = cell.getAlign();
|
||
let alignHorizontal = align.getAlignHorizontal();
|
||
if (cell.isNullTextString()) {
|
||
res = new cString('');
|
||
} else if (alignHorizontal === null || alignHorizontal === AscCommon.align_Left) {
|
||
res = new cString("'");
|
||
} else if (alignHorizontal === AscCommon.align_Right) {
|
||
res = new cString('"');
|
||
} else if (alignHorizontal === AscCommon.align_Center) {
|
||
res = new cString('^');
|
||
} /*else if(alignHorizontal === AscCommon.align_Fill) {
|
||
res = new cString("\/");
|
||
}*/ else {
|
||
res = new cString('');
|
||
}
|
||
|
||
break;
|
||
}
|
||
case "protect":
|
||
case _cCellFunctionLocal["protect"]: {
|
||
//default - protect, do not support on open
|
||
let isLocked = true;
|
||
cell = ws.getCell3(bbox.r1, bbox.c1);
|
||
cell._foreachNoEmpty(function (cell) {
|
||
if (cell) {
|
||
let xfs = cell.xfs ? cell.xfs : cell.getCompiledStyle();
|
||
if (xfs) {
|
||
isLocked = xfs.getLocked();
|
||
}
|
||
}
|
||
});
|
||
if (isLocked) {
|
||
res = new cNumber(1);
|
||
} else {
|
||
res = new cNumber(0);
|
||
}
|
||
break;
|
||
}
|
||
case "format":
|
||
case _cCellFunctionLocal["format"]: {
|
||
res = getCellFormat(ws, bbox.r1, bbox.c1);
|
||
break
|
||
}
|
||
case "color":
|
||
case _cCellFunctionLocal["color"]: {
|
||
numFormat = getNumFormat(ws, bbox.r1, bbox.c1);
|
||
if (numFormat && (numFormat.oNegativeFormat && numFormat.oNegativeFormat.Color !== -1)) {
|
||
res = new cNumber(1);
|
||
} else {
|
||
res = new cNumber(0);
|
||
}
|
||
break
|
||
}
|
||
case "parentheses":
|
||
case _cCellFunctionLocal["parentheses"]: {
|
||
numFormat = getNumFormat(ws, bbox.r1, bbox.c1);
|
||
if (numFormat && numFormat.oPositiveFormat && numFormat.oPositiveFormat.formatString.indexOf('(') != -1) {
|
||
res = new cNumber(1);
|
||
} else {
|
||
res = new cNumber(0);
|
||
}
|
||
break
|
||
}
|
||
default: {
|
||
return new cError(cErrorType.wrong_value_type);
|
||
}
|
||
}
|
||
|
||
return res ? res : new cError(cErrorType.wrong_value_type);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* @constructor
|
||
* @extends {AscCommonExcel.cBaseFunction}
|
||
*/
|
||
function cERROR_TYPE() {
|
||
}
|
||
|
||
//***array-formula***
|
||
cERROR_TYPE.prototype = Object.create(cBaseFunction.prototype);
|
||
cERROR_TYPE.prototype.constructor = cERROR_TYPE;
|
||
cERROR_TYPE.prototype.name = 'ERROR.TYPE';
|
||
cERROR_TYPE.prototype.argumentsMin = 1;
|
||
cERROR_TYPE.prototype.argumentsMax = 1;
|
||
cERROR_TYPE.prototype.argumentsType = [argType.any];
|
||
cERROR_TYPE.prototype.Calculate = function (arg) {
|
||
function typeError(elem) {
|
||
if (elem instanceof cError) {
|
||
switch (elem.errorType) {
|
||
case cErrorType.null_value:
|
||
return new cNumber(1);
|
||
case cErrorType.division_by_zero:
|
||
return new cNumber(2);
|
||
case cErrorType.wrong_value_type:
|
||
return new cNumber(3);
|
||
case cErrorType.bad_reference :
|
||
return new cNumber(4);
|
||
case cErrorType.wrong_name :
|
||
return new cNumber(5);
|
||
case cErrorType.not_numeric :
|
||
return new cNumber(6);
|
||
case cErrorType.not_available :
|
||
return new cNumber(7);
|
||
case cErrorType.getting_data :
|
||
return new cNumber(8);
|
||
default:
|
||
return new cError(cErrorType.not_available);
|
||
}
|
||
} else {
|
||
return new cError(cErrorType.not_available);
|
||
}
|
||
}
|
||
|
||
var arg0 = arg[0];
|
||
if (arg0 instanceof cRef || arg0 instanceof cRef3D) {
|
||
arg0 = arg0.getValue();
|
||
} else if (arg0 instanceof cArea || arg0 instanceof cArea3D) {
|
||
arg0 = arg0.cross(arguments[1]);
|
||
} else if (arg0 instanceof cArray) {
|
||
var ret = new cArray();
|
||
arg0.foreach(function (elem, r, c) {
|
||
if (!ret.array[r]) {
|
||
ret.addRow();
|
||
}
|
||
ret.addElement(typeError(elem));
|
||
});
|
||
return ret;
|
||
}
|
||
return typeError(arg0);
|
||
};
|
||
|
||
/**
|
||
* @constructor
|
||
* @extends {AscCommonExcel.cBaseFunction}
|
||
*/
|
||
function cISBLANK() {
|
||
}
|
||
|
||
//***array-formula***
|
||
cISBLANK.prototype = Object.create(cBaseFunction.prototype);
|
||
cISBLANK.prototype.constructor = cISBLANK;
|
||
cISBLANK.prototype.name = 'ISBLANK';
|
||
cISBLANK.prototype.argumentsMin = 1;
|
||
cISBLANK.prototype.argumentsMax = 1;
|
||
cISBLANK.prototype.argumentsType = [argType.any];
|
||
cISBLANK.prototype.Calculate = function (arg) {
|
||
var arg0 = arg[0];
|
||
if (arg0 instanceof cArea || arg0 instanceof cArea3D) {
|
||
arg0 = arg0.cross(arguments[1]);
|
||
} else if (arg0 instanceof cRef || arg0 instanceof cRef3D) {
|
||
arg0 = arg0.getValue();
|
||
}
|
||
if (arg0 instanceof AscCommonExcel.cEmpty) {
|
||
return new cBool(true);
|
||
} else {
|
||
return new cBool(false);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* @constructor
|
||
* @extends {AscCommonExcel.cBaseFunction}
|
||
*/
|
||
function cISERR() {
|
||
}
|
||
|
||
//***array-formula***
|
||
cISERR.prototype = Object.create(cBaseFunction.prototype);
|
||
cISERR.prototype.constructor = cISERR;
|
||
cISERR.prototype.name = 'ISERR';
|
||
cISERR.prototype.argumentsMin = 1;
|
||
cISERR.prototype.argumentsMax = 1;
|
||
cISERR.prototype.argumentsType = [argType.any];
|
||
cISERR.prototype.Calculate = function (arg) {
|
||
var arg0 = arg[0];
|
||
if (arg0 instanceof cArray) {
|
||
arg0 = arg0.getElement(0);
|
||
} else if (arg0 instanceof cArea || arg0 instanceof cArea3D) {
|
||
arg0 = arg0.cross(arguments[1]);
|
||
} else if (arg0 instanceof cRef || arg0 instanceof cRef3D) {
|
||
arg0 = arg0.getValue();
|
||
}
|
||
|
||
if (arg0 instanceof cError && arg0.errorType != cErrorType.not_available) {
|
||
return new cBool(true);
|
||
} else {
|
||
return new cBool(false);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* @constructor
|
||
* @extends {AscCommonExcel.cBaseFunction}
|
||
*/
|
||
|
||
function cISERROR() {
|
||
}
|
||
|
||
//***array-formula***
|
||
cISERROR.prototype = Object.create(cBaseFunction.prototype);
|
||
cISERROR.prototype.constructor = cISERROR;
|
||
cISERROR.prototype.name = 'ISERROR';
|
||
cISERROR.prototype.argumentsMin = 1;
|
||
cISERROR.prototype.argumentsMax = 1;
|
||
cISERROR.prototype.argumentsType = [argType.any];
|
||
cISERROR.prototype.Calculate = function (arg) {
|
||
var arg0 = arg[0];
|
||
if (arg0 instanceof cArray) {
|
||
arg0 = arg0.getElement(0);
|
||
} else if (arg0 instanceof cArea || arg0 instanceof cArea3D) {
|
||
arg0 = arg0.cross(arguments[1]);
|
||
} else if (arg0 instanceof cRef || arg0 instanceof cRef3D) {
|
||
arg0 = arg0.getValue();
|
||
}
|
||
|
||
if (arg0 instanceof cError) {
|
||
return new cBool(true);
|
||
} else {
|
||
return new cBool(false);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* @constructor
|
||
* @extends {AscCommonExcel.cBaseFunction}
|
||
*/
|
||
function cISEVEN() {
|
||
}
|
||
|
||
//***array-formula***
|
||
cISEVEN.prototype = Object.create(cBaseFunction.prototype);
|
||
cISEVEN.prototype.constructor = cISEVEN;
|
||
cISEVEN.prototype.name = 'ISEVEN';
|
||
cISEVEN.prototype.argumentsMin = 1;
|
||
cISEVEN.prototype.argumentsMax = 1;
|
||
cISEVEN.prototype.returnValueType = AscCommonExcel.cReturnFormulaType.value_replace_area;
|
||
cISEVEN.prototype.argumentsType = [argType.any];
|
||
cISEVEN.prototype.Calculate = function (arg) {
|
||
var arg0 = arg[0];
|
||
if (arg0 instanceof cArray) {
|
||
arg0 = arg0.getElement(0);
|
||
} else if (arg0 instanceof cArea || arg0 instanceof cArea3D) {
|
||
arg0 = arg0.cross(arguments[1]);
|
||
} else if (arg0 instanceof cRef || arg0 instanceof cRef3D) {
|
||
arg0 = arg0.getValue();
|
||
}
|
||
|
||
if (arg0 instanceof cError) {
|
||
return arg0;
|
||
}
|
||
|
||
arg0 = arg0.tocNumber();
|
||
if (arg0 instanceof cError) {
|
||
return arg0;
|
||
} else {
|
||
return new cBool((arg0.getValue() & 1) == 0);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* @constructor
|
||
* @extends {AscCommonExcel.cBaseFunction}
|
||
*/
|
||
function cISFORMULA() {
|
||
}
|
||
|
||
//***array-formula***
|
||
cISFORMULA.prototype = Object.create(cBaseFunction.prototype);
|
||
cISFORMULA.prototype.constructor = cISFORMULA;
|
||
cISFORMULA.prototype.name = 'ISFORMULA';
|
||
cISFORMULA.prototype.argumentsMin = 1;
|
||
cISFORMULA.prototype.argumentsMax = 1;
|
||
cISFORMULA.prototype.isXLFN = true;
|
||
cISFORMULA.prototype.returnValueType = AscCommonExcel.cReturnFormulaType.area_to_ref;
|
||
cISFORMULA.prototype.argumentsType = [argType.reference];
|
||
cISFORMULA.prototype.Calculate = function (arg) {
|
||
//есть различия в поведении этой формулы для ms и lo(для нескольких ячеек с данными)
|
||
var arg0 = arg[0];
|
||
var res = false;
|
||
if ((arg0 instanceof cArea || arg0 instanceof cArea3D) && arg0.range) {
|
||
let range = arg0.getRange && arg0.getRange();
|
||
if (range) {
|
||
res = range.isFormula()
|
||
}
|
||
} else if ((arg0 instanceof cRef || arg0 instanceof cRef3D) && arg0.range) {
|
||
res = arg0.range.isFormula();
|
||
}
|
||
|
||
if (arg0 instanceof cError) {
|
||
return arg0;
|
||
}
|
||
|
||
return new cBool(res);
|
||
};
|
||
|
||
/**
|
||
* @constructor
|
||
* @extends {AscCommonExcel.cBaseFunction}
|
||
*/
|
||
function cISLOGICAL() {
|
||
}
|
||
|
||
//***array-formula***
|
||
cISLOGICAL.prototype = Object.create(cBaseFunction.prototype);
|
||
cISLOGICAL.prototype.constructor = cISLOGICAL;
|
||
cISLOGICAL.prototype.name = 'ISLOGICAL';
|
||
cISLOGICAL.prototype.argumentsMin = 1;
|
||
cISLOGICAL.prototype.argumentsMax = 1;
|
||
cISLOGICAL.prototype.argumentsType = [argType.any];
|
||
cISLOGICAL.prototype.Calculate = function (arg) {
|
||
var arg0 = arg[0];
|
||
if (arg0 instanceof cArray) {
|
||
arg0 = arg0.getElement(0);
|
||
} else if (arg0 instanceof cArea || arg0 instanceof cArea3D) {
|
||
arg0 = arg0.cross(arguments[1]);
|
||
} else if (arg0 instanceof cRef || arg0 instanceof cRef3D) {
|
||
arg0 = arg0.getValue();
|
||
}
|
||
|
||
if (arg0 instanceof cBool) {
|
||
return new cBool(true);
|
||
} else {
|
||
return new cBool(false);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* @constructor
|
||
* @extends {AscCommonExcel.cBaseFunction}
|
||
*/
|
||
function cISNA() {
|
||
}
|
||
|
||
//***array-formula***
|
||
cISNA.prototype = Object.create(cBaseFunction.prototype);
|
||
cISNA.prototype.constructor = cISNA;
|
||
cISNA.prototype.name = 'ISNA';
|
||
cISNA.prototype.argumentsMin = 1;
|
||
cISNA.prototype.argumentsMax = 1;
|
||
cISNA.prototype.argumentsType = [argType.any];
|
||
cISNA.prototype.Calculate = function (arg) {
|
||
var arg0 = arg[0];
|
||
if (arg0 instanceof cArray) {
|
||
arg0 = arg0.getElement(0);
|
||
} else if (arg0 instanceof cArea || arg0 instanceof cArea3D) {
|
||
arg0 = arg0.cross(arguments[1]);
|
||
} else if (arg0 instanceof cRef || arg0 instanceof cRef3D) {
|
||
arg0 = arg0.getValue();
|
||
}
|
||
|
||
if (arg0 instanceof cError && arg0.errorType == cErrorType.not_available) {
|
||
return new cBool(true);
|
||
} else {
|
||
return new cBool(false);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* @constructor
|
||
* @extends {AscCommonExcel.cBaseFunction}
|
||
*/
|
||
function cISNONTEXT() {
|
||
}
|
||
|
||
//***array-formula***
|
||
cISNONTEXT.prototype = Object.create(cBaseFunction.prototype);
|
||
cISNONTEXT.prototype.constructor = cISNONTEXT;
|
||
cISNONTEXT.prototype.name = 'ISNONTEXT';
|
||
cISNONTEXT.prototype.argumentsMin = 1;
|
||
cISNONTEXT.prototype.argumentsMax = 1;
|
||
cISNONTEXT.prototype.argumentsType = [argType.any];
|
||
cISNONTEXT.prototype.Calculate = function (arg) {
|
||
var arg0 = arg[0];
|
||
if (arg0 instanceof cArray) {
|
||
arg0 = arg0.getElement(0);
|
||
} else if (arg0 instanceof cArea || arg0 instanceof cArea3D) {
|
||
arg0 = arg0.cross(arguments[1]);
|
||
} else if (arg0 instanceof cRef || arg0 instanceof cRef3D) {
|
||
arg0 = arg0.getValue();
|
||
}
|
||
if (!(arg0 instanceof cString)) {
|
||
return new cBool(true);
|
||
} else {
|
||
return new cBool(false);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* @constructor
|
||
* @extends {AscCommonExcel.cBaseFunction}
|
||
*/
|
||
function cISNUMBER() {
|
||
}
|
||
|
||
//***array-formula***
|
||
cISNUMBER.prototype = Object.create(cBaseFunction.prototype);
|
||
cISNUMBER.prototype.constructor = cISNUMBER;
|
||
cISNUMBER.prototype.name = 'ISNUMBER';
|
||
cISNUMBER.prototype.argumentsMin = 1;
|
||
cISNUMBER.prototype.argumentsMax = 1;
|
||
cISNUMBER.prototype.argumentsType = [argType.any];
|
||
cISNUMBER.prototype.Calculate = function (arg) {
|
||
var arg0 = arg[0];
|
||
if (arg0 instanceof cArray) {
|
||
arg0 = arg0.getElement(0);
|
||
} else if (arg0 instanceof cArea || arg0 instanceof cArea3D) {
|
||
arg0 = arg0.cross(arguments[1]);
|
||
} else if (arg0 instanceof cRef || arg0 instanceof cRef3D) {
|
||
arg0 = arg0.getValue();
|
||
}
|
||
|
||
if (arg0 instanceof cNumber) {
|
||
return new cBool(true);
|
||
} else {
|
||
return new cBool(false);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* @constructor
|
||
* @extends {AscCommonExcel.cBaseFunction}
|
||
*/
|
||
function cISODD() {
|
||
}
|
||
|
||
//***array-formula***
|
||
cISODD.prototype = Object.create(cBaseFunction.prototype);
|
||
cISODD.prototype.constructor = cISODD;
|
||
cISODD.prototype.name = 'ISODD';
|
||
cISODD.prototype.argumentsMin = 1;
|
||
cISODD.prototype.argumentsMax = 1;
|
||
cISODD.prototype.returnValueType = AscCommonExcel.cReturnFormulaType.value_replace_area;
|
||
cISODD.prototype.argumentsType = [argType.any];
|
||
cISODD.prototype.Calculate = function (arg) {
|
||
var arg0 = arg[0];
|
||
if (arg0 instanceof cArray) {
|
||
arg0 = arg0.getElement(0);
|
||
} else if (arg0 instanceof cArea || arg0 instanceof cArea3D) {
|
||
arg0 = arg0.cross(arguments[1]);
|
||
} else if (arg0 instanceof cRef || arg0 instanceof cRef3D) {
|
||
arg0 = arg0.getValue();
|
||
}
|
||
|
||
if (arg0 instanceof cError) {
|
||
return arg0;
|
||
}
|
||
|
||
arg0 = arg0.tocNumber();
|
||
if (arg0 instanceof cError) {
|
||
return arg0;
|
||
} else {
|
||
return new cBool((arg0.getValue() & 1) == 1);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* @constructor
|
||
* @extends {AscCommonExcel.cBaseFunction}
|
||
*/
|
||
function cISREF() {
|
||
}
|
||
|
||
//***array-formula***
|
||
cISREF.prototype = Object.create(cBaseFunction.prototype);
|
||
cISREF.prototype.constructor = cISREF;
|
||
cISREF.prototype.name = 'ISREF';
|
||
cISREF.prototype.argumentsMin = 1;
|
||
cISREF.prototype.argumentsMax = 1;
|
||
cISREF.prototype.arrayIndexes = {0: 1};
|
||
cISREF.prototype.argumentsType = [argType.any];
|
||
cISREF.prototype.Calculate = function (arg) {
|
||
if ((arg[0] instanceof cRef || arg[0] instanceof cArea || arg[0] instanceof cArea3D ||
|
||
arg[0] instanceof cRef3D) && arg[0].isValid && arg[0].isValid()) {
|
||
return new cBool(true);
|
||
} else {
|
||
return new cBool(false);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* @constructor
|
||
* @extends {AscCommonExcel.cBaseFunction}
|
||
*/
|
||
function cISTEXT() {
|
||
}
|
||
|
||
//***array-formula***
|
||
cISTEXT.prototype = Object.create(cBaseFunction.prototype);
|
||
cISTEXT.prototype.constructor = cISTEXT;
|
||
cISTEXT.prototype.name = 'ISTEXT';
|
||
cISTEXT.prototype.argumentsMin = 1;
|
||
cISTEXT.prototype.argumentsMax = 1;
|
||
cISTEXT.prototype.argumentsType = [argType.any];
|
||
cISTEXT.prototype.Calculate = function (arg) {
|
||
var arg0 = arg[0];
|
||
if (arg0 instanceof cArray) {
|
||
arg0 = arg0.getElement(0);
|
||
} else if (arg0 instanceof cArea || arg0 instanceof cArea3D) {
|
||
arg0 = arg0.cross(arguments[1]);
|
||
} else if (arg0 instanceof cRef || arg0 instanceof cRef3D) {
|
||
arg0 = arg0.getValue();
|
||
}
|
||
|
||
if (arg0 instanceof cString) {
|
||
return new cBool(true);
|
||
} else {
|
||
return new cBool(false);
|
||
}
|
||
};
|
||
|
||
/**
|
||
* @constructor
|
||
* @extends {AscCommonExcel.cBaseFunction}
|
||
*/
|
||
function cN() {
|
||
}
|
||
|
||
//***array-formula***
|
||
cN.prototype = Object.create(cBaseFunction.prototype);
|
||
cN.prototype.constructor = cN;
|
||
cN.prototype.name = 'N';
|
||
cN.prototype.argumentsMin = 1;
|
||
cN.prototype.argumentsMax = 1;
|
||
cN.prototype.numFormat = AscCommonExcel.cNumFormatNone;
|
||
cN.prototype.arrayIndexes = {0: 1};
|
||
cN.prototype.argumentsType = [argType.any];
|
||
cN.prototype.Calculate = function (arg) {
|
||
var arg0 = arg[0];
|
||
if (arg0 instanceof cArray) {
|
||
arg0.foreach(function (elem, r, c) {
|
||
if (elem instanceof cNumber || elem instanceof cError) {
|
||
this.array[r][c] = elem;
|
||
} else if (elem instanceof cBool) {
|
||
this.array[r][c] = elem.tocNumber();
|
||
} else {
|
||
this.array[r][c] = new cNumber(0);
|
||
}
|
||
});
|
||
return arg0;
|
||
} else if (arg0 instanceof cArea || arg0 instanceof cArea3D) {
|
||
arg0 = arg0.cross(arguments[1]);
|
||
} else if (arg0 instanceof cRef || arg0 instanceof cRef3D) {
|
||
arg0 = arg0.getValue();
|
||
}
|
||
|
||
if (arg0 instanceof cNumber || arg0 instanceof cError) {
|
||
return arg0;
|
||
} else if (arg0 instanceof cBool) {
|
||
return arg0.tocNumber();
|
||
} else {
|
||
return new cNumber(0);
|
||
}
|
||
|
||
};
|
||
|
||
/**
|
||
* @constructor
|
||
* @extends {AscCommonExcel.cBaseFunction}
|
||
*/
|
||
function cNA() {
|
||
}
|
||
|
||
//***array-formula***
|
||
cNA.prototype = Object.create(cBaseFunction.prototype);
|
||
cNA.prototype.constructor = cNA;
|
||
cNA.prototype.name = 'NA';
|
||
cNA.prototype.argumentsMax = 0;
|
||
cNA.prototype.argumentsType = null;
|
||
cNA.prototype.Calculate = function () {
|
||
return new cError(cErrorType.not_available);
|
||
};
|
||
|
||
/**
|
||
* @constructor
|
||
* @extends {AscCommonExcel.cBaseFunction}
|
||
*/
|
||
function cSHEET() {
|
||
}
|
||
|
||
//***array-formula***
|
||
cSHEET.prototype = Object.create(cBaseFunction.prototype);
|
||
cSHEET.prototype.constructor = cSHEET;
|
||
cSHEET.prototype.name = 'SHEET';
|
||
cSHEET.prototype.argumentsMin = 0;
|
||
cSHEET.prototype.argumentsMax = 1;
|
||
cSHEET.prototype.ca = true;
|
||
cSHEET.prototype.isXLFN = true;
|
||
cSHEET.prototype.returnValueType = AscCommonExcel.cReturnFormulaType.array;
|
||
cSHEET.prototype.argumentsType = [argType.text];
|
||
cSHEET.prototype.Calculate = function (arg, opt_bbox, opt_defName, ws) {
|
||
|
||
var res = null;
|
||
if (0 === arg.length) {
|
||
res = new cNumber(ws.index + 1);
|
||
} else {
|
||
var arg0 = arg[0];
|
||
if (cElementType.error === arg0.type) {
|
||
res = arg0;
|
||
} else {
|
||
if (arg0.ws) {
|
||
res = new cNumber(arg0.ws.index + 1);
|
||
} else if (arg0.wsFrom) {
|
||
var sheet1 = arg0.wsFrom.index + 1;
|
||
var sheet2 = arg0.wsTo.index + 1;
|
||
res = new cNumber(Math.min(sheet1, sheet2));
|
||
} else if (cElementType.string === arg0.type) {
|
||
var arg0Val = arg0.getValue();
|
||
var curWorksheet = ws.workbook.getWorksheetByName(arg0Val);
|
||
if (curWorksheet && undefined !== curWorksheet.index) {
|
||
res = new cNumber(curWorksheet.index + 1);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (null === res) {
|
||
res = new cError(cErrorType.wrong_value_type);
|
||
}
|
||
|
||
return res;
|
||
};
|
||
|
||
/**
|
||
* @constructor
|
||
* @extends {AscCommonExcel.cBaseFunction}
|
||
*/
|
||
function cSHEETS() {
|
||
}
|
||
|
||
//***array-formula***
|
||
cSHEETS.prototype = Object.create(cBaseFunction.prototype);
|
||
cSHEETS.prototype.constructor = cSHEETS;
|
||
cSHEETS.prototype.name = 'SHEETS';
|
||
cSHEETS.prototype.argumentsMin = 0;
|
||
cSHEETS.prototype.argumentsMax = 1;
|
||
cSHEETS.prototype.isXLFN = true;
|
||
cSHEETS.prototype.returnValueType = AscCommonExcel.cReturnFormulaType.array;
|
||
cSHEETS.prototype.argumentsType = [argType.reference];
|
||
cSHEETS.prototype.Calculate = function (arg, opt_bbox, opt_defName, ws) {
|
||
|
||
var res;
|
||
if (0 === arg.length) {
|
||
res = new cNumber(ws.workbook.aWorksheets.length);
|
||
} else {
|
||
var arg0 = arg[0];
|
||
if (cElementType.error === arg0.type) {
|
||
res = arg0;
|
||
} else if (cElementType.cellsRange === arg0.type || cElementType.cell === arg0.type ||
|
||
cElementType.cell3D === arg0.type) {
|
||
res = new cNumber(1);
|
||
} else if (cElementType.cellsRange3D === arg0.type) {
|
||
var sheet1 = arg0.wsFrom.index;
|
||
var sheet2 = arg0.wsTo.index;
|
||
if (sheet1 === sheet2) {
|
||
res = new cNumber(1);
|
||
} else {
|
||
res = new cNumber(Math.abs(sheet2 - sheet1) + 1);
|
||
}
|
||
|
||
} else {
|
||
res = new cError(cErrorType.not_available);
|
||
}
|
||
}
|
||
return res;
|
||
|
||
};
|
||
|
||
/**
|
||
* @constructor
|
||
* @extends {AscCommonExcel.cBaseFunction}
|
||
*/
|
||
function cTYPE() {
|
||
}
|
||
|
||
//***array-formula***
|
||
cTYPE.prototype = Object.create(cBaseFunction.prototype);
|
||
cTYPE.prototype.constructor = cTYPE;
|
||
cTYPE.prototype.name = 'TYPE';
|
||
cTYPE.prototype.argumentsMin = 1;
|
||
cTYPE.prototype.argumentsMax = 1;
|
||
cTYPE.prototype.returnValueType = AscCommonExcel.cReturnFormulaType.value_replace_area;
|
||
cTYPE.prototype.arrayIndexes = {0: 1};
|
||
cTYPE.prototype.argumentsType = [argType.any];
|
||
cTYPE.prototype.Calculate = function (arg) {
|
||
var arg0 = arg[0];
|
||
if (arg0 instanceof cArea || arg0 instanceof cArea3D) {
|
||
//todo пересмотреть!
|
||
//заглушка для формулы массива
|
||
//ms воспринимает данный аргумент как массив
|
||
if (this.bArrayFormula) {
|
||
arg0 = arg[0].getValue()
|
||
} else {
|
||
arg0 = arg0.cross(arguments[1]);
|
||
}
|
||
} else if (arg0 instanceof cRef || arg0 instanceof cRef3D) {
|
||
arg0 = arg0.getValue();
|
||
}
|
||
|
||
if (arg0 instanceof cNumber) {
|
||
return new cNumber(1);
|
||
} else if (arg0 instanceof cString) {
|
||
return new cNumber(2);
|
||
} else if (arg0 instanceof cBool) {
|
||
return new cNumber(4);
|
||
} else if (arg0 instanceof cError) {
|
||
return new cNumber(16);
|
||
} else {
|
||
return new cNumber(64);
|
||
}
|
||
};
|
||
})(window);
|