/*
 * (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 CMathNaryPr(ctrPr)
{
	this.chr		= undefined;
	this.chrType	= undefined;
	this.grow		= false;
	this.limLoc		= undefined;
	this.subHide	= false;
	this.supHide	= false;
	this.ctrPr		= new CMathCtrlPr(ctrPr);
}

CMathNaryPr.prototype.GetRPr = function ()
{
	return this.ctrPr.GetRPr();
};

CMathNaryPr.prototype.Set_FromObject = function(Obj)
{
    this.chr     = Obj.chr;
    this.chrType = Obj.chrType;

    if(true === Obj.grow === true || 1 === Obj.grow)
        this.grow = true;

    if(NARY_UndOvr === Obj.limLoc || NARY_SubSup === Obj.limLoc)
        this.limLoc = Obj.limLoc;

    if(true === Obj.subHide === true || 1 === Obj.subHide)
        this.subHide = true;

    if(true === Obj.supHide === true || 1 === Obj.supHide)
        this.supHide = true;

	this.ctrPr.SetRPr(Obj.ctrPrp);
};

CMathNaryPr.prototype.Copy = function()
{
    var NewPr = new CMathNaryPr();

    NewPr.chr     = this.chr    ;
    NewPr.chrType = this.chrType;
    NewPr.grow    = this.grow   ;
    NewPr.limLoc  = this.limLoc ;
    NewPr.subHide = this.subHide;
    NewPr.supHide = this.supHide;
	NewPr.ctrPr = this.ctrPr;

    return NewPr;
};

CMathNaryPr.prototype.Write_ToBinary = function(Writer)
{
    // Long : flags

    // Long : chr
    // Long : chrType
    // Long : limLoc

    // Bool : grow
    // Bool : subHide
    // Bool : supHide

    var StartPos = Writer.GetCurPosition();
    Writer.Skip(4);
    var Flags = 0;

    if (undefined !== this.chr)
    {
        Writer.WriteLong(this.chr);
        Flags |= 1;
    }

    if (undefined !== this.chrType)
    {
        Writer.WriteLong(this.chrType);
        Flags |= 2;
    }

    if (undefined !== this.limLoc)
    {
        Writer.WriteLong(this.limLoc);
        Flags |= 4;
    }

    var EndPos = Writer.GetCurPosition();
    Writer.Seek(StartPos);
    Writer.WriteLong(Flags);
    Writer.Seek(EndPos);

    Writer.WriteBool(this.grow);
    Writer.WriteBool(this.subHide);
    Writer.WriteBool(this.supHide);

	Writer.WriteBool(true);
	this.ctrPr.Write_ToBinary(Writer);
};

CMathNaryPr.prototype.Read_FromBinary = function(Reader)
{
    // Long : flags

    // Long : chr
    // Long : chrType
    // Long : limLoc

    // Bool : grow
    // Bool : subHide
    // Bool : supHide

    var Flags = Reader.GetLong();

    if (Flags & 1)
        this.chr = Reader.GetLong();
    else
        this.chr = undefined;

    if (Flags & 2)
        this.chrType = Reader.GetLong();
    else
        this.chrType = undefined;

    if (Flags & 4)
        this.limLoc = Reader.GetLong();
    else
        this.limLoc = undefined;

    this.grow    = Reader.GetBool();
    this.subHide = Reader.GetBool();
    this.supHide = Reader.GetBool();

	if (Reader.GetBool())
	{
		this.ctrPr.Read_FromBinary(Reader);
	}
};

/**
 *
 * @param props
 * @constructor
 * @extends {CMathBase}
 */
function CNary(props)
{
	CMathBase.call(this);

	this.Id = AscCommon.g_oIdCounter.Get_NewId();

	this.Pr = new CMathNaryPr(this.CtrPrp);

	this.Base = null;
	this.Sign = null;
	this.LowerIterator = null;
	this.UpperIterator = null;
	this.Arg           = null;

	this.CurrentLimLoc = null;

	if(props !== null && props !== undefined)
		this.init(props);

	AscCommon.g_oTableId.Add( this, this.Id );
}
CNary.prototype = Object.create(CMathBase.prototype);
CNary.prototype.constructor = CNary;

CNary.prototype.ClassType = AscDFH.historyitem_type_nary;
CNary.prototype.kind      = MATH_NARY;
  
CNary.prototype.init = function(props)
{
    this.Fill_LogicalContent(3, props.content);

    this.setProperties(props);
    this.fillContent();
};
CNary.prototype.fillContent = function()
{
    this.NeedBreakContent(2);
    
    this.LowerIterator = this.Content[0];
    this.UpperIterator = this.Content[1];
    this.Arg           = this.Content[2];
};
CNary.prototype.fillBase = function(PropsInfo)
{
    this.setDimension(1, 2);

    var base;

    var Sign = PropsInfo.sign;
    var ctrPrp = this.CtrPrp.Copy();

    if(PropsInfo.limLoc === NARY_UndOvr)
    {
        if(PropsInfo.supHide && PropsInfo.subHide)
        {
            base = Sign;
        }
        else if( PropsInfo.supHide && !PropsInfo.subHide )
        {
            base = new CNaryOvr(true);
            base.setBase(Sign);
            base.setLowerIterator(this.LowerIterator);
        }
        else if( !PropsInfo.supHide && PropsInfo.subHide )
        {
            base = new CNaryUnd(true);
            base.setBase(Sign);
            base.setUpperIterator(this.UpperIterator);
        }
        else
        {
            base = new CNaryUndOvr(true);
            base.setBase(Sign);
            base.setUpperIterator(this.UpperIterator);
            base.setLowerIterator(this.LowerIterator);
        }
    }
    else
    {
        var prp;

        if( PropsInfo.supHide && !PropsInfo.subHide )
        {
            prp = {type: DEGREE_SUBSCRIPT, ctrPrp:  ctrPrp};
            base = new CDegreeBase(prp, true);
            base.setBase(Sign);
            base.setIterator(this.LowerIterator);
            base.fillContent();
        }
        else if( !PropsInfo.supHide && PropsInfo.subHide )
        {
            prp = {type: DEGREE_SUPERSCRIPT, ctrPrp: ctrPrp};
            base = new CDegreeBase(prp, true);
            base.setBase(Sign);
            base.setIterator(this.UpperIterator);

            base.fillContent();

        }
        else if(PropsInfo.supHide && PropsInfo.subHide)
        {
            base = Sign;
        }
        else
        {
            prp = {type: DEGREE_SubSup, ctrPrp: ctrPrp};
            base = new CDegreeSubSupBase(prp, true);
            base.setBase(Sign);
            base.setLowerIterator(this.LowerIterator);
            base.setUpperIterator(this.UpperIterator);

            base.fillContent();
        }
    }

    this.Base = base;

    this.addMCToContent( [base, this.Arg] );

};
CNary.prototype.ApplyProperties = function(RPI)
{
    var bSimpleNarySubSup = RPI.bInline == true || RPI.bDecreasedComp == true;
    var limLoc = bSimpleNarySubSup == true ? NARY_SubSup : this.private_GetLimLoc();

    if(this.RecalcInfo.bProps == true || RPI.bChangeInline == true || limLoc !== this.CurrentLimLoc)
    {
        var oSign = this.getSign(this.Pr.chr, this.Pr.chrType);

        if(bSimpleNarySubSup)
        {
			this.Sign = new CNaryInlineOperator(oSign.chrCode);
        }
        else
        {
            this.Sign = oSign.operator;
        }

        var PropsInfo =
        {
            limLoc :    limLoc,
            sign:       this.Sign,
            supHide:    this.Pr.supHide,
            subHide:    this.Pr.subHide
        };

        // пока оставим так, chrType сейчас нигде не используется
        this.Pr.chrType = oSign.chrType;

        this.fillBase(PropsInfo);

        this.RecalcInfo.bProps = false;
    }

    this.CurrentLimLoc = limLoc;
};
CNary.prototype.private_GetLimLoc = function()
{
    var limLoc         = this.Pr.limLoc;

    if(limLoc === null || limLoc === undefined)
    {
        var bIntegral = (this.Pr.chr > 0x222A && this.Pr.chr < 0x2231) || this.Pr.chr === null || this.Pr.chr === undefined;

        var oMathSettings = Get_WordDocumentDefaultMathSettings();
        if(bIntegral)
            limLoc = oMathSettings.Get_IntLim();
        else
            limLoc = oMathSettings.Get_NaryLim();
    }

    return limLoc;
};
CNary.prototype.PreRecalc = function(Parent, ParaMath, ArgSize, RPI, GapsInfo)
{
    var bNaryInline = RPI.bNaryInline;

    if(RPI.bInline || RPI.bDecreasedComp)
        RPI.bNaryInline = true;

    CMathBase.prototype.PreRecalc.call(this, Parent, ParaMath, ArgSize, RPI, GapsInfo);

    RPI.bNaryInline = bNaryInline;
};
CNary.prototype.getSign = function(chrCode, chrType)
{
    var result = 
    {
        chrCode:   null,
        chrType:   null,
        operator:  null
    };

    var bChr = chrCode !== null && chrCode == chrCode + 0;

    if(chrCode == 0x222B || chrType == NARY_INTEGRAL)
    {
        result.chrCode = 0x222B;
        result.chrType = NARY_INTEGRAL;
        result.operator = new CIntegral();
    }
    else if(chrCode == 0x222C || chrType == NARY_DOUBLE_INTEGRAL)
    {
        result.chrCode = 0x222C;
        result.chrType = NARY_DOUBLE_INTEGRAL;
        result.operator = new CDoubleIntegral();
    }
    else if(chrCode == 0x222D || chrType == NARY_TRIPLE_INTEGRAL)
    {
        result.chrCode = 0x222D;
        result.chrType = NARY_TRIPLE_INTEGRAL;
        result.operator = new CTripleIntegral();
    }
    else if(chrCode == 0x222E || chrType == NARY_CONTOUR_INTEGRAL )
    {
        result.chrCode = 0x222E;
        result.chrType = NARY_CONTOUR_INTEGRAL;
        result.operator = new CContourIntegral();
    }
    else if(chrCode == 0x222F || chrType == NARY_SURFACE_INTEGRAL )
    {
        result.chrCode = 0x222F;
        result.chrType = NARY_SURFACE_INTEGRAL;
        result.operator = new CSurfaceIntegral();
    }
    else if(chrCode == 0x2230 || chrType == NARY_VOLUME_INTEGRAL)
    {
        result.chrCode = 0x2230;
        result.chrType = NARY_VOLUME_INTEGRAL;
        result.operator = new CVolumeIntegral();
    }
    else if(chrCode == 0x2211 || chrType == NARY_SIGMA)
    {
        result.chrCode = 0x2211;
        result.chrType = NARY_SIGMA;
        result.operator = new CSigma();
    }
    else if(chrCode == 0x220F || chrType == NARY_PRODUCT)
    {
        result.chrCode = 0x220F;
        result.chrType = NARY_PRODUCT;
        result.operator = new CProduct();
    }
    else if(chrCode == 0x2210 || chrType == NARY_COPRODUCT)
    {
        result.chrCode = 0x2210;
        result.chrType = NARY_COPRODUCT;
        result.operator = new CProduct(-1);
    }
    else if(chrCode == 0x22C3 || chrType == NARY_UNION)
    {
        result.chrCode = 0x22C3;
        result.chrType = NARY_UNION;
        result.operator = new CUnion();
    }
    else if(chrCode == 0x22C2 || chrType == NARY_INTERSECTION)
    {
        result.chrCode = 0x22C2;
        result.chrType = NARY_INTERSECTION;
        result.operator = new CUnion(-1);
    }
    else if(chrCode == 0x22C1 || chrType == NARY_LOGICAL_OR)
    {
        result.chrCode = 0x22C1;
        result.chrType = NARY_LOGICAL_OR;
        result.operator  = new CLogicalOr();
    }
    else if(chrCode == 0x22C0 || chrType == NARY_LOGICAL_AND)
    {
        result.chrCode = 0x22C0;
        result.chrType = NARY_LOGICAL_AND;
        result.operator  = new CLogicalOr(-1);
    }
    else if(bChr)
    {
        result.chrCode = chrCode;
        result.chrType = NARY_TEXT_OPER;
        result.operator = new CMathText(true);
        result.operator.add(chrCode);

    }
    else
    {
        result.chrCode = 0x222B;
        result.chrType = NARY_INTEGRAL;
        result.operator = new CIntegral();
    }

    return result;
};
CNary.prototype.setCtrPrp = function(txtPrp)
{
    CMathBase.prototype.setCtrPrp.call(this, txtPrp);// only runPrp for paragraph
    //this.RunPrp.setTxtPrp(txtPrp);

    if(this.elements.length > 0 && !this.elements[0][0].IsJustDraw())
    {
        this.elements[0][0].setCtrPrp(this.CtrPrp);
    }
};
CNary.prototype.setDistance = function()
{
    this.dW = this.Get_TxtPrControlLetter().FontSize/36*2.45;
};
CNary.prototype.getBase = function()
{
    return this.Arg;
};
CNary.prototype.getUpperIterator = function()
{
	if (!this.Pr.supHide)
		return this.UpperIterator;
};
CNary.prototype.getLowerIterator = function()
{
	if (!this.Pr.subHide)
		return this.LowerIterator;
};
CNary.prototype.getBaseMathContent = function()
{
    return this.Arg;
};
CNary.prototype.getSupMathContent = function()
{
    return this.UpperIterator;
};
CNary.prototype.getSubMathContent = function()
{
    return this.LowerIterator;
};
CNary.prototype.Apply_MenuProps = function(Props)
{
	if (Props.Type == Asc.c_oAscMathInterfaceType.LargeOperator)
	{
		if (Props.LimLoc !== undefined && false == this.ParaMath.Is_Inline() && this.Pr.limLoc !== Props.LimLoc)
		{
			var LimLoc = Props.LimLoc == Asc.c_oAscMathInterfaceNaryLimitLocation.SubSup ? NARY_SubSup : NARY_UndOvr;
			AscCommon.History.Add(new CChangesMathNaryLimLoc(this, this.Pr.limLoc, LimLoc));
			this.raw_SetLimLoc(LimLoc);
		}

		if (Props.HideUpper !== undefined && Props.HideUpper !== this.Pr.supHide)
		{
			AscCommon.History.Add(new CChangesMathNaryUpperLimit(this, this.Pr.supHide, !this.Pr.supHide));
			this.raw_HideUpperIterator(!this.Pr.supHide);
		}

		if (Props.HideLower !== undefined && Props.HideLower !== this.Pr.subHide)
		{
			AscCommon.History.Add(new CChangesMathNaryLowerLimit(this, this.Pr.subHide, !this.Pr.subHide));
			this.raw_HideLowerIterator(!this.Pr.subHide);
		}
	}
};
CNary.prototype.Get_InterfaceProps = function()
{
    return new CMathMenuNary(this);
};
CNary.prototype.raw_SetLimLoc = function(Value)
{
    if(this.Pr.limLoc !== Value)
    {
        this.Pr.limLoc = Value;
        this.RecalcInfo.bProps = true;
    }
};
CNary.prototype.raw_HideUpperIterator = function(Value)
{
    if(this.Pr.supHide !== Value)
    {
        this.Pr.supHide = Value;
        this.RecalcInfo.bProps = true;

        this.CurPos = 2;
        this.Arg.MoveCursorToStartPos();
    }
};
CNary.prototype.raw_HideLowerIterator = function(Value)
{
    if(this.Pr.subHide !== Value)
    {
        this.Pr.subHide = Value;
        this.RecalcInfo.bProps = true;

        this.CurPos = 2;
        this.Arg.MoveCursorToStartPos();
    }
};
CNary.prototype.Is_ContentUse = function(MathContent)
{
    if (MathContent === this.getBaseMathContent())
        return true;

    if (true !== this.Pr.subHide && MathContent === this.getSubMathContent())
        return true;

    if (true !== this.Pr.supHide && MathContent === this.getSupMathContent())
        return true;

    return false;
};
CNary.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
{
    this.bOneLine = PRS.bMath_OneLine;

    if(this.bOneLine === true)
    {
        CMathBase.prototype.Recalculate_Range.call(this, PRS, ParaPr, Depth);
    }
    else
    {
        var CurLine  = PRS.Line - this.StartLine;
        var CurRange = ( 0 === CurLine ? PRS.Range - this.StartRange : PRS.Range );

        this.setDistance();

        var bContainCompareOper = PRS.bContainCompareOper;

        var RangeStartPos = this.protected_AddRange(CurLine, CurRange),
            RangeEndPos = 2;


        if(CurLine == 0 && CurRange == 0)
        {
            PRS.WordLen += this.BrGapLeft;
            var WordLen = PRS.WordLen;

            if(this.Base.IsJustDraw())
            {
                this.MeasureJustDraw(this.Base);
            }
            else
            {
                PRS.bMath_OneLine = true;
                this.Base.Recalculate_Reset(PRS.Range, PRS.Line, PRS);
                this.LowerIterator.Recalculate_Reset(PRS.Range, PRS.Line, PRS);
                this.UpperIterator.Recalculate_Reset(PRS.Range, PRS.Line, PRS);
                this.Base.Recalculate_Range(PRS, ParaPr, Depth);
            }

            PRS.WordLen = WordLen + this.Base.size.width;

            if(false === PRS.Word && false === PRS.FirstItemOnLine)
            {
                PRS.Word = true;
            }

            PRS.WordLen += this.dW;

            this.Arg.Recalculate_Reset(PRS.Range, PRS.Line, PRS); // обновим StartLine и StartRange
        }

        PRS.Update_CurPos(2, Depth); // this.Arg = this.Content[2]
        PRS.bMath_OneLine  = false;
        this.Arg.Recalculate_Range(PRS, ParaPr, Depth+1);


        if(PRS.NewRange == false)
        {
            PRS.WordLen += this.BrGapRight;
        }

        this.protected_FillRange(CurLine, CurRange, RangeStartPos, RangeEndPos);

        PRS.bMath_OneLine = false;
        PRS.bContainCompareOper = bContainCompareOper;
    }
};
CNary.prototype.Recalculate_Range_Width = function(PRSC, _CurLine, _CurRange)
{
    if(this.bOneLine == true)
    {
        CMathBase.prototype.Recalculate_Range_Width.call(this, PRSC, _CurLine, _CurRange);
    }
    else
    {
        var CurLine = _CurLine - this.StartLine;
        var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );

        var RangeW = PRSC.Range.W;

        if(CurLine == 0 && CurRange == 0)
        {
            PRSC.Range.W += this.BrGapLeft;
            var RangeW2 = PRSC.Range.W;

            if(this.Base.IsJustDraw() == false)
            {
                this.LowerIterator.Recalculate_Range_Width(PRSC, _CurLine, _CurRange);
                this.UpperIterator.Recalculate_Range_Width(PRSC, _CurLine, _CurRange);

                this.Base.Bounds.SetWidth(CurLine, CurRange, this.Base.size.width);
            }

            PRSC.Range.W = RangeW2 + this.Base.size.width + this.dW;

        }

        this.Arg.Recalculate_Range_Width( PRSC, _CurLine, _CurRange );

        if(this.Arg.Math_Is_End( _CurLine, _CurRange))
        {
            PRSC.Range.W += this.BrGapRight;
        }

        this.Bounds.SetWidth(CurLine, CurRange, PRSC.Range.W - RangeW);
    }
};
CNary.prototype.Draw_Elements = function(PDSE)
{
    var CurLine  = PDSE.Line - this.StartLine;
    var CurRange = ( 0 === CurLine ? PDSE.Range - this.StartRange : PDSE.Range );

    if(CurLine == 0 && CurRange == 0)
    {
        if(this.Base.IsJustDraw()) // для Just-Draw элементов надо выставить Font
        {
            var ctrPrp = this.Get_TxtPrControlLetter();

            var Font =
            {
                FontSize:   ctrPrp.FontSize,
                FontFamily: {Name : ctrPrp.FontFamily.Name, Index : ctrPrp.FontFamily.Index},
                Italic:     false,
                Bold:       false //ctrPrp.Bold
            };

            PDSE.Graphics.SetFont(Font);
        }
        this.Base.Draw_Elements(PDSE);
    }

    this.Arg.Draw_Elements(PDSE);
};
CNary.prototype.UpdateBoundsPosInfo = function(PRSA, _CurLine, _CurRange, _CurPage)
{
    if(this.bOneLine == false)
    {
        var CurLine  = _CurLine - this.StartLine;
        var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange);

        this.Bounds.SetGenPos(CurLine, CurRange, PRSA);
        this.Bounds.SetPage(CurLine, CurRange, _CurPage);

        if(false == this.Base.IsJustDraw())
        {
            this.Base.UpdateBoundsPosInfo(PRSA, _CurLine, _CurRange, _CurPage);
        }

        this.Arg.UpdateBoundsPosInfo(PRSA, _CurLine, _CurRange, _CurPage);

    }
    else
    {
        CMathBase.prototype.UpdateBoundsPosInfo.call(this, PRSA, _CurLine, _CurRange, _CurPage);
    }

};
CNary.prototype.Recalculate_LineMetrics = function(PRS, ParaPr, _CurLine, _CurRange, ContentMetrics)
{
    if(this.bOneLine)
    {
        CMathBase.prototype.Recalculate_LineMetrics.call(this, PRS, ParaPr, _CurLine, _CurRange, ContentMetrics);
    }
    else
    {
        var CurLine = _CurLine - this.StartLine;
        var CurRange = (0 === CurLine ? _CurRange - this.StartRange : _CurRange);

        if(PRS.bFastRecalculate === false)
        {
            this.Bounds.Reset(CurLine, CurRange);
        }

        // т.к. ParaNumbering привязывается к первому текстовому элементы, он может находится в аргументе
        // обновляем LineMetrics для Base после того, как обновим метрики для аргумента

        this.Arg.Recalculate_LineMetrics(PRS, ParaPr, _CurLine, _CurRange, ContentMetrics);

        var BoundArg = this.Arg.Get_LineBound(_CurLine, _CurRange);

        this.Bounds.UpdateMetrics(CurLine, CurRange, BoundArg);
        this.UpdatePRS(PRS, BoundArg);

        if(CurLine == 0 && CurRange == 0)
        {
            //this.Bounds.Reset();

            if(this.Base.IsJustDraw())
            {
                this.Bounds.UpdateMetrics(CurLine, CurRange, this.Base.size);
                ContentMetrics.UpdateMetrics(this.Base.size);
                this.UpdatePRS(PRS, this.Base.size);
            }
            else
            {
                // чтобы при вычислении метрик итераторов не были перебили метрики (например, у внутр мат объекта Asc может быть больше Asc текущего объекта)

                var NewContentMetrics = new CMathBoundsMeasures();

                this.LowerIterator.Recalculate_LineMetrics(PRS, ParaPr, _CurLine, _CurRange, NewContentMetrics);
                this.UpperIterator.Recalculate_LineMetrics(PRS, ParaPr, _CurLine, _CurRange, NewContentMetrics);

                this.Base.Recalculate_LineMetrics(PRS, ParaPr, _CurLine, _CurRange, ContentMetrics);

                this.Bounds.UpdateMetrics(CurLine, CurRange, this.Base.size);
                this.UpdatePRS(PRS, this.Base.size);
            }

        }
    }
};
CNary.prototype.setPosition = function(pos, PosInfo)
{
    if(this.bOneLine)
    {
        CMathBase.prototype.setPosition.call(this, pos, PosInfo);
    }
    else
    {
        var Line  = PosInfo.CurLine,
            Range = PosInfo.CurRange;
        var CurLine  = Line - this.StartLine;
        var CurRange = ( 0 === CurLine ? Range - this.StartRange : Range );

        this.UpdatePosBound(pos, PosInfo);

        if(CurLine == 0 && CurRange == 0)
        {
            pos.x += this.BrGapLeft;

            var PosBase = new CMathPosition();
            PosBase.x = pos.x;
            PosBase.y = pos.y - this.Base.size.ascent;

            this.Base.setPosition(PosBase, PosInfo);

            pos.x += this.Base.size.width + this.dW;
        }

        this.Arg.setPosition(pos, PosInfo);

        if(this.Arg.Math_Is_End(Line, Range))
        {
            pos.x += this.BrGapRight;
        }
    }
};
CNary.prototype.Can_ModifyArgSize = function()
{
    return this.CurPos !== 2 && false === this.Is_SelectInside();
};
/**
 *
 * @param {MathTextAndStyles} oMathText
 * @return {*}
 * @constructor
 */
CNary.prototype.GetTextOfElement = function(oMathText)
{
	oMathText = new AscMath.MathTextAndStyles(oMathText);

	let strStartCode;
	let oBase	= this.getBase();
	let oUpper	= this.getUpperIterator();
	let oLower	= this.getLowerIterator();

	if (oMathText.IsLaTeX())
	{
		strStartCode		= AscMath.MathLiterals.nary.Unicode[String.fromCharCode(this.Pr.chr)];
		if (undefined === strStartCode)
			strStartCode = '\\int';

		oMathText.AddText(new AscMath.MathText(strStartCode, this));

		if (oLower)
		{
			oMathText.SetGlobalStyle(oLower);
			let oLowerPos	= oMathText.Add(oLower, true,  2);
			oLowerPos		= oMathText.AddBefore(oLowerPos, new AscMath.MathText("_", oLower));
		}

		if (oUpper)
		{
			oMathText.SetNotGetStyleFromFirst();
			let oUpperPos = oMathText.AddText(new AscMath.MathText("^", oUpper));

			oMathText.SetGlobalStyle(oUpper);
			oMathText.Add(oUpper, true, 2);
		}

		if (oBase)
		{
			oMathText.SetGlobalStyle(this);
			oMathText.Add(oBase, true, 1);
		}
	}
	else
	{
		if (undefined === this.Pr.chr)
			strStartCode = '∫';
		else
			strStartCode = String.fromCharCode(this.Pr.chr);

		let startChar = new AscMath.MathText(strStartCode, this);
		if (this.Pr.limLoc === NARY_UndOvr)
		{
			let oAddData	= startChar.GetAdditionalData();
			let oMetaData	= oAddData.GetMathMetaData();
			oMetaData.setIsLimitNary(true);
		}

		let oLastPos = oMathText.AddText(startChar);

		if (oLower)
		{
			oMathText.SetGlobalStyle(this);
			oMathText.AddText(new AscMath.MathText("_", oLower));
			oLastPos = oMathText.Add(oLower, true);
		}

		if (oUpper)
		{
			oMathText.SetGlobalStyle(this);
			oMathText.AddText(new AscMath.MathText("^", oUpper));
			oLastPos = oMathText.Add(oUpper, true);
		}

		if (oBase)
		{
			let oPosBeforeBase	= oLastPos.Copy();
			oLastPos			= oMathText.Add(oBase, true, 1);
			let strBase			= oBase.GetTextOfElement().GetText();

			if (strBase.length > 0)
				oMathText.AddAfter(oPosBeforeBase, new AscMath.MathText("▒", oBase));
		}
	}

	return oMathText;
};

/**
 *
 * @param CMathMenuNary
 * @constructor
 * @extends {CMathMenuBase}
 */
function CMathMenuNary(Nary)
{
	CMathMenuBase.call(this, Nary);

    this.Type             = Asc.c_oAscMathInterfaceType.LargeOperator;

    if (undefined !== Nary)
    {
        var HideUpper = undefined, HideLower = undefined;
        if (true === Nary.UpperIterator.IsPlaceholder())
            HideUpper = Nary.Pr.supHide == true;

        if (true === Nary.LowerIterator.IsPlaceholder())
            HideLower = Nary.Pr.subHide == true;

        this.bCanChangeLimLoc = false == Nary.ParaMath.Is_Inline();
        this.LimLoc           = Nary.Pr.limLoc === NARY_SubSup ? Asc.c_oAscMathInterfaceNaryLimitLocation.SubSup : Asc.c_oAscMathInterfaceNaryLimitLocation.UndOvr;
        this.HideUpper        = HideUpper;
        this.HideLower        = HideLower;
    }
    else
    {
        this.LimLoc    			= undefined;
        this.HideUpper 			= undefined;
        this.HideLower 			= undefined;
        this.bCanChangeLimLoc 	= false;
    }
}
CMathMenuNary.prototype = Object.create(CMathMenuBase.prototype);
CMathMenuNary.prototype.constructor = CMathMenuNary;
CMathMenuNary.prototype.can_ChangeLimitLocation = function(){ return this.bCanChangeLimLoc;};
CMathMenuNary.prototype.get_LimitLocation       = function(){return this.LimLoc;};
CMathMenuNary.prototype.put_LimitLocation       = function(LimLoc){this.LimLoc = LimLoc;};
CMathMenuNary.prototype.get_HideUpper           = function(){return this.HideUpper;};
CMathMenuNary.prototype.put_HideUpper           = function(Hide){this.HideUpper = Hide;};
CMathMenuNary.prototype.get_HideLower           = function(){return this.HideLower;};
CMathMenuNary.prototype.put_HideLower           = function(Hide){this.HideLower = Hide;};

window["CMathMenuNary"] = CMathMenuNary;
CMathMenuNary.prototype["can_ChangeLimitLocation"] = CMathMenuNary.prototype.can_ChangeLimitLocation;
CMathMenuNary.prototype["get_LimitLocation"]       = CMathMenuNary.prototype.get_LimitLocation;
CMathMenuNary.prototype["put_LimitLocation"]       = CMathMenuNary.prototype.put_LimitLocation;
CMathMenuNary.prototype["get_HideUpper"]           = CMathMenuNary.prototype.get_HideUpper;
CMathMenuNary.prototype["put_HideUpper"]           = CMathMenuNary.prototype.put_HideUpper;
CMathMenuNary.prototype["get_HideLower"]           = CMathMenuNary.prototype.get_HideLower;
CMathMenuNary.prototype["put_HideLower"]           = CMathMenuNary.prototype.put_HideLower;

/**
 *
 * @param bInside
 * @constructor
 * @extends {CMathBase}
 */
function CNaryUnd(bInside)
{
    CMathBase.call(this, bInside);

    this.setDimension(2, 1);
    //this.init();
}
CNaryUnd.prototype = Object.create(CMathBase.prototype);
CNaryUnd.prototype.constructor = CNaryUnd;
CNaryUnd.prototype.setDistance = function()
{
    var zetta = this.Get_TxtPrControlLetter().FontSize*25.4/96;
    this.dH = zetta*0.25;
};
CNaryUnd.prototype.getAscent = function()
{
    return this.elements[0][0].size.height + this.dH + this.elements[1][0].size.ascent;
};
CNaryUnd.prototype.getUpperIterator = function()
{
    return this.elements[0][0];
};
CNaryUnd.prototype.PreRecalc = function(Parent, ParaMath, ArgSize, RPI)
{
    this.Parent = Parent;
    this.ParaMath = ParaMath;

    this.Set_CompiledCtrPrp(Parent, ParaMath, RPI);

    var ArgSzUnd = ArgSize.Copy();
    ArgSzUnd.Decrease();

    this.elements[1][0].PreRecalc(this, ParaMath, ArgSize,  RPI);

    var bDecreasedComp = RPI.bDecreasedComp;
    RPI.bDecreasedComp = true;

    this.elements[0][0].PreRecalc(this, ParaMath, ArgSzUnd, RPI);

    RPI.bDecreasedComp = bDecreasedComp;
};
CNaryUnd.prototype.setBase = function(base)
{
    this.elements[1][0] = base;
};
CNaryUnd.prototype.setUpperIterator = function(iterator)
{
    this.elements[0][0] = iterator;
};

/**
 *
 * @param bInside
 * @constructor
 * @extends {CMathBase}
 */
function CNaryOvr(bInside)
{
    CMathBase.call(this, bInside);

    this.setDimension(2, 1);
}
CNaryOvr.prototype = Object.create(CMathBase.prototype);
CNaryOvr.prototype.constructor = CNaryOvr;
CNaryOvr.prototype.PreRecalc = function(Parent, ParaMath, ArgSize, RPI)
{
    this.Parent = Parent;
    this.ParaMath = ParaMath;

    this.Set_CompiledCtrPrp(Parent, ParaMath, RPI);

    var ArgSzOvr = ArgSize.Copy();
    ArgSzOvr.Decrease();

    this.elements[0][0].PreRecalc(this, ParaMath, ArgSize,  RPI);

    var bDecreasedComp = RPI.bDecreasedComp;
    RPI.bDecreasedComp = true;

    this.elements[1][0].PreRecalc(this, ParaMath, ArgSzOvr, RPI);

    RPI.bDecreasedComp = bDecreasedComp;
};
CNaryOvr.prototype.recalculateSize = function()
{
    var FontSize = this.Get_TxtPrControlLetter().FontSize;
    var zetta = FontSize*25.4/96;

    var minGapBottom = zetta*0.1,
        DownBaseline = FontSize*0.23;

    var nOper = this.elements[0][0].size,
        iter = this.elements[1][0].size;

    this.dH = DownBaseline > iter.ascent + minGapBottom ? DownBaseline - iter.ascent : minGapBottom;

    var ascent = nOper.ascent;
    var width = nOper.width > iter.width ? nOper.width : iter.width;
    width += this.GapLeft + this.GapRight;

    var height = nOper.height + this.dH + iter.height;

    this.size.height = height;
    this.size.width  = width;
    this.size.ascent = ascent;
};
CNaryOvr.prototype.getLowerIterator = function()
{
    return this.elements[1][0];
};
CNaryOvr.prototype.setBase = function(base)
{
    this.elements[0][0] = base;
};
CNaryOvr.prototype.setLowerIterator = function(iterator)
{
    this.elements[1][0] = iterator;
};

/**
 *
 * @param bInside
 * @constructor
 * @extends {CMathBase}
 */
function CNaryUndOvr(bInside)
{
    this.gapTop = 0;
    this.gapBottom = 0;
    CMathBase.call(this, bInside);

    this.setDimension(3,1);
}
CNaryUndOvr.prototype = Object.create(CMathBase.prototype);
CNaryUndOvr.prototype.constructor = CNaryUndOvr;
CNaryUndOvr.prototype.PreRecalc = function(Parent, ParaMath, ArgSize, RPI)
{
    this.Parent = Parent;
    this.ParaMath = ParaMath;

    this.Set_CompiledCtrPrp(Parent, ParaMath, RPI);

    var ArgSzIter = ArgSize.Copy();
    ArgSzIter.Decrease();

    this.elements[1][0].PreRecalc(this, ParaMath, ArgSize,  RPI);

    var bDecreasedComp = RPI.bDecreasedComp;
    RPI.bDecreasedComp = true;

    this.elements[0][0].PreRecalc(this, ParaMath, ArgSzIter, RPI);

    this.elements[2][0].PreRecalc(this, ParaMath, ArgSzIter, RPI);

    RPI.bDecreasedComp = bDecreasedComp;
};
CNaryUndOvr.prototype.recalculateSize = function()
{
    var FontSize = this.Get_TxtPrControlLetter().FontSize;
    var zetta = FontSize*25.4/96;
    this.gapTop = zetta*0.25;

    var minGapBottom = zetta*0.1,
        DownBaseline = FontSize*0.23;

    var ascLIter = this.elements[2][0].size.ascent;
    this.gapBottom = DownBaseline > ascLIter + minGapBottom ? DownBaseline - ascLIter : minGapBottom;

    var ascent = this.elements[0][0].size.height + this.gapTop + this.elements[1][0].size.ascent;

    var width = 0, height = 0;
    for(var i = 0; i < 3; i++)
    {
        width = width > this.elements[i][0].size.width ? width : this.elements[i][0].size.width;
        height += this.elements[i][0].size.height;
    }

    width += this.GapLeft + this.GapRight;
    height += this.gapTop + this.gapBottom;

    this.size.height = height;
    this.size.width  = width;
    this.size.ascent = ascent;
};
CNaryUndOvr.prototype.setPosition = function(pos, PosInfo)
{
    this.pos.x = pos.x;
    this.pos.y = pos.y;

    var UpIter  = this.elements[0][0],
        Sign    = this.elements[1][0],
        LowIter = this.elements[2][0];

    var PosUpIter = new CMathPosition();

    PosUpIter.x = pos.x + this.GapLeft + this.align(0,0).x;
    PosUpIter.y = pos.y + UpIter.size.ascent;


    var PosSign = new CMathPosition();

    PosSign.x = pos.x + this.GapLeft + this.align(1,0).x;
    PosSign.y = pos.y + UpIter.size.height + this.gapTop;


    var PosLowIter = new CMathPosition();

    PosLowIter.x = pos.x + this.GapLeft + this.align(2,0).x;
    PosLowIter.y = PosSign.y + Sign.size.height + this.gapBottom + LowIter.size.ascent;

    // такой порядок нужен для выравнивания Box по операторам
    LowIter.setPosition(PosLowIter, PosInfo);
    Sign.setPosition(PosSign, PosInfo);
    UpIter.setPosition(PosUpIter, PosInfo);
};
CNaryUndOvr.prototype.setBase = function(base)
{
    this.elements[1][0] = base;
};
CNaryUndOvr.prototype.setUpperIterator = function(iterator)
{
    this.elements[0][0] = iterator;
};
CNaryUndOvr.prototype.setLowerIterator = function(iterator)
{
    this.elements[2][0] = iterator;
};
CNaryUndOvr.prototype.getLowerIterator = function()
{
    return this.elements[2][0];
};
CNaryUndOvr.prototype.getUpperIterator = function()
{
    return this.elements[0][0];
};

function CNaryInlineOperator(chrCode)
{
	this.Base		= new CMathText(true);
	this.size		= new CMathSize();
    this.pos		= new CMathPosition();
	this.Parent		= null;
	this.ParaMath	= null;
	
	this.Base.add(chrCode);
}
CNaryInlineOperator.prototype.Draw_Elements = function(PDSE)
{
	this.Parent.Make_ShdColor(PDSE, this.Parent.Get_CompiledCtrPrp());
    var PosLine = this.ParaMath.GetLinePosition(PDSE.Line, PDSE.Range);

    this.drawTextElem(PosLine.x, PosLine.y, PDSE.Graphics);
};
CNaryInlineOperator.prototype.PreRecalc = function(Parent, ParaMath, ArgSize, RPI)
{
    this.Parent		= Parent;
    this.ParaMath	= ParaMath;

	this.Base.PreRecalc(Parent, ParaMath);
};
CNaryInlineOperator.prototype.IsJustDraw = function()
{
    return true;
};
CNaryInlineOperator.prototype.Measure = function(oMeasure, RPI)
{
	this.Base.Measure(oMeasure, RPI);
	
	this.size.ascent	= this.Base.size.ascent;
	this.size.height	= this.Base.size.height;
	this.size.width		= this.Base.size.width;
};
CNaryInlineOperator.prototype.setPosition = function(pos)
{
    this.pos.x = pos.x;
    this.pos.y = pos.y;
};
CNaryInlineOperator.prototype.drawTextElem = function(x, y, pGraphics)
{
    var ctrPrp = this.Get_TxtPrControlLetter();

    var Font =
    {
        FontSize:   ctrPrp.FontSize,
        FontFamily: {Name : ctrPrp.FontFamily.Name, Index : ctrPrp.FontFamily.Index},
        Italic:     false,
        Bold:       false
    };

    pGraphics.SetFont(Font);
	pGraphics.FillTextCode(x + this.pos.x, y + this.pos.y + this.size.height - (this.size.height - this.size.ascent), this.Base.RecalcInfo.StyleCode);
};
CNaryInlineOperator.prototype.Get_TxtPrControlLetter = function()
{
    return this.Parent.Get_TxtPrControlLetter();
};

function CNaryOperator(flip)
{
    this.size		= new CMathSize();
    this.pos		= new CMathPosition();
    this.bFlip		= (flip == -1);
    this.Parent		= null;
    this.ParaMath	= null;
    this.sizeGlyph	= null;
}
CNaryOperator.prototype.Draw_Elements = function(PDSE)
{
    this.Parent.Make_ShdColor(PDSE, this.Parent.Get_CompiledCtrPrp());

    var PosLine = this.ParaMath.GetLinePosition(PDSE.Line, PDSE.Range);

    if(this.Type == para_Math_Text)
        this.drawTextElem(PosLine.x, PosLine.y, PDSE.Graphics);
    else
        this.drawGlyph(PosLine.x, PosLine.y, PDSE.Graphics, PDSE);
};
CNaryOperator.prototype.drawGlyph = function(x, y, pGraphics, PDSE)
{
    var coord = this.getCoord();

    var X = coord.X,
        Y = coord.Y;

    var XX = [],
        YY = [];

    var textScale = this.Get_TxtPrControlLetter().FontSize/850; // 1000 pt
    var alpha = textScale*25.4/96 /64; // коэффициент; используется для того чтобы перевести координаты в миллиметры
    // g_dKoef_px_to_mm = 25.4/96

    var a, b;
    if(this.bFlip)
    {
        a = -1;
        b = this.sizeGlyph.height;
    }
    else
    {
        a = 1;
        b = 0;
    }

    for(var i = 0 ; i < X.length; i++)
    {
        XX[i] = this.pos.x + x + X[i]*alpha;
        YY[i] = this.pos.y + y + (a*Y[i]*alpha + b);
    }

    var intGrid = pGraphics.GetIntegerGrid();
    pGraphics.SetIntegerGrid(false);

    pGraphics.p_width(0);

    pGraphics._s();

    this.drawPath(pGraphics, XX,YY);

    pGraphics.df();
    pGraphics._s();
    pGraphics.SetIntegerGrid(intGrid);
};
CNaryOperator.prototype.drawTextElem = function(x, y, pGraphics)
{
    //pGraphics.b_color1(0,0,0,255);

    var ctrPrp = this.Get_TxtPrControlLetter();

    var Font =
    {
        FontSize:   ctrPrp.FontSize,
        FontFamily: {Name : ctrPrp.FontFamily.Name, Index : ctrPrp.FontFamily.Index},
        Italic:     false,
        Bold:       false //ctrPrp.Bold
    };

    pGraphics.SetFont(Font);

    // ?????????????????????????????????????????????????????????
    // CNaryOperator.superclass.call.draw(this, x, y, pGraphics);
};
CNaryOperator.prototype.IsJustDraw = function()
{
    return true;
};
CNaryOperator.prototype.setPosition = function(pos)
{
    this.pos.x = pos.x;
    this.pos.y = pos.y;
};
CNaryOperator.prototype.recalculateSize = function()
{
    this.sizeGlyph = this.calculateSizeGlyph();

    var height = this.sizeGlyph.height,
        width =  this.sizeGlyph.width,
        ascent = this.sizeGlyph.height/2 + DIV_CENT*this.Get_TxtPrControlLetter().FontSize;

    this.size.height = height;
    this.size.width  = width;
    this.size.ascent = ascent;
};
CNaryOperator.prototype.PreRecalc = function(Parent, ParaMath, ArgSize, RPI)
{
    this.Parent = Parent;
    this.ParaMath = ParaMath;
};
CNaryOperator.prototype.Measure = function(oMeasure, RPI)
{
    this.recalculateSize(); //обычный пересчет, oMeasure не нужен
};
CNaryOperator.prototype.Get_TxtPrControlLetter = function()
{
    return this.Parent.Get_TxtPrControlLetter();
};

/**
 *
 * @constructor
 * @extends {CNaryOperator}
 */
function CSigma()
{
    CNaryOperator.call(this);
}
CSigma.prototype = Object.create(CNaryOperator.prototype);
CSigma.prototype.constructor = CSigma;
CSigma.prototype.drawPath = function(pGraphics, XX, YY)
{
    pGraphics._m(XX[0], YY[0]);
    pGraphics._l(XX[1], YY[1]);
    pGraphics._l(XX[2], YY[2]);
    pGraphics._l(XX[3], YY[3]);
    pGraphics._l(XX[4], YY[4]);
    pGraphics._c(XX[4], YY[4], XX[5], YY[5], XX[6], YY[6] );
    pGraphics._c(XX[6], YY[6], XX[7], YY[7], XX[8], YY[8] );
    pGraphics._c(XX[8], YY[8], XX[9], YY[9], XX[10], YY[10] );
    pGraphics._c(XX[10], YY[10], XX[11], YY[11], XX[12], YY[12] );
    pGraphics._c(XX[12], YY[12], XX[13], YY[13], XX[14], YY[14] );
    pGraphics._l(XX[15], YY[15]);
    pGraphics._l(XX[16], YY[16]);
    pGraphics._l(XX[17], YY[17]);
    pGraphics._l(XX[18], YY[18]);
    pGraphics._l(XX[19], YY[19]);
    pGraphics._l(XX[20], YY[20]);
    pGraphics._l(XX[21], YY[21]);
    pGraphics._l(XX[22], YY[22]);
    pGraphics._l(XX[23], YY[23]);
    pGraphics._l(XX[24], YY[24]);
    pGraphics._c(XX[24], YY[24], XX[25], YY[25], XX[26], YY[26] );
    pGraphics._c(XX[26], YY[26], XX[27], YY[27], XX[28], YY[28] );
    pGraphics._c(XX[28], YY[28], XX[29], YY[29], XX[30], YY[30] );
    pGraphics._c(XX[30], YY[30], XX[31], YY[31], XX[32], YY[32] );
    pGraphics._c(XX[32], YY[32], XX[33], YY[33], XX[34], YY[34] );
    pGraphics._l(XX[35], YY[35]);

};
CSigma.prototype.getCoord = function()
{
    var X = [],
        Y = [];

    /*X[0] = 13560; Y[0] = 4332;
     X[1] = 33847; Y[1] = 35130;
     X[2] = 33847; Y[2] = 38297;
     X[3] = 11103; Y[3] = 69548;
     X[4] = 38512; Y[4] = 69548;
     X[5] = 41095; Y[5] = 69548;
     X[6] = 42407; Y[6] = 69215;
     X[7] = 43719; Y[7] = 68882;
     X[8] = 44656; Y[8] = 68194;
     X[9] = 45594; Y[9] = 67507;
     X[10] = 46364; Y[10] = 66278;
     X[11] = 47135; Y[11] = 65049;
     X[12] = 47843; Y[12] = 62883;
     X[13] = 48552; Y[13] = 60717;
     X[14] = 49176; Y[14] = 57218;
     X[15] = 54028; Y[15] = 57218;
     X[16] = 52820; Y[16] = 77546;
     X[17] = 0; Y[17] = 77546;
     X[18] = 0; Y[18] = 75213;
     X[19] = 25766; Y[19] = 39839;
     X[20] = 1605; Y[20] = 2374;
     X[21] = 1605; Y[21] = 0;
     X[22] = 53050; Y[22] = 0;
     X[23] = 53050; Y[23] = 18543;
     X[24] = 48551; Y[24] = 18543;
     X[25] = 47509; Y[25] = 14584;
     X[26] = 46572; Y[26] = 12084;
     X[27] = 45635; Y[27] = 9583;
     X[28] = 44656; Y[28] = 8125;
     X[29] = 43677; Y[29] = 6666;
     X[30] = 42656; Y[30] = 5895;
     X[31] = 41636; Y[31] = 5124;
     X[32] = 40303; Y[32] = 4728;
     X[33] = 38970; Y[33] = 4332;
     X[34] = 36762; Y[34] = 4332;
     X[35] = 13560; Y[35] = 4332;*/

    X[0] = 16252; Y[0] = 5200;
    X[1] = 40602; Y[1] = 42154;
    X[2] = 40602; Y[2] = 45954;
    X[3] = 13302; Y[3] = 83456;
    X[4] = 46202; Y[4] = 83456;
    X[5] = 49302; Y[5] = 83456;
    X[6] = 50877; Y[6] = 83056;
    X[7] = 52452; Y[7] = 82656;
    X[8] = 53577; Y[8] = 81831;
    X[9] = 54702; Y[9] = 81006;
    X[10] = 55627; Y[10] = 79531;
    X[11] = 56552; Y[11] = 78056;
    X[12] = 57402; Y[12] = 75456;
    X[13] = 58252; Y[13] = 72856;
    X[14] = 59002; Y[14] = 68656;
    X[15] = 64850; Y[15] = 68656;
    X[16] = 63400; Y[16] = 93056;
    X[17] = 0; Y[17] = 93056;
    X[18] = 0; Y[18] = 90256;
    X[19] = 30902; Y[19] = 47804;
    X[20] = 1902; Y[20] = 2850;
    X[21] = 1902; Y[21] = 0;
    X[22] = 63652; Y[22] = 0;
    X[23] = 63652; Y[23] = 22252;
    X[24] = 58252; Y[24] = 22252;
    X[25] = 57002; Y[25] = 17501;
    X[26] = 55877; Y[26] = 14501;
    X[27] = 54752; Y[27] = 11501;
    X[28] = 53577; Y[28] = 9751;
    X[29] = 52402; Y[29] = 8000;
    X[30] = 51177; Y[30] = 7075;
    X[31] = 49952; Y[31] = 6150;
    X[32] = 48352; Y[32] = 5675;
    X[33] = 46752; Y[33] = 5200;
    X[34] = 44102; Y[34] = 5200;
    X[35] = 16252; Y[35] = 5200;


    //var textScale =  this.getTxtPrp().FontSize/850; // 1000 pt
    var textScale =  this.Get_TxtPrControlLetter().FontSize/850; // 1000 pt
    var alpha = textScale*25.4/96 /64;

    var h1 = Y[0] - Y[21],
        h2 = Y[17] - Y[3],
        h3 = Y[2] - Y[1],
        h4 = Y[20] - Y[21],
        h5 = Y[17] - Y[18];

    var H1 = this.sizeGlyph.height/alpha - h1 - h2 - h3;
    //H2 = this.size.height/alpha - h4 - h5;

    var h_middle1 = Y[3] - Y[0] - h3,
        coeff1 = (Y[1] - Y[0])/h_middle1,
        coeff2 = (Y[3] - Y[2])/h_middle1;


    var y3 = Y[3],
        y2 = Y[2];

    Y[1] = Y[0] + H1*coeff1;
    Y[2] = Y[1] + h3;
    Y[3] = Y[2] + H1*coeff2;

    Y[19] = Y[2] + Y[19] - y2;
    Y[18] = Y[3] + Y[18] - y3;

    for(var i = 4; i < 18; i++)
    {
        Y[i] = Y[3] + (Y[i] - y3);
    }

    // Width  -  X[15]

    var W = (this.sizeGlyph.width - this.gap)/alpha;

    var c1 = (X[21] - X[17])/X[15],
        c2 = (X[22] - X[21])/X[15];

    var x22 = X[22];

    X[21] = X[20] = X[17] + c1*W;
    X[22] = X[23] = X[21] + c2*W;

    for(var i = 24; i < 35; i++)
        X[i] = X[22] + X[i] - x22;

    var c3 = (X[4] - X[3])/X[15],
        c4 = (X[15] - X[16])/X[15],
        c5 = (X[15] - X[2])/X[15];

    var x15 = X[15],
        x2 = X[2];

    X[4] = X[3] + c3*W;
    X[15] = W;
    X[16] = X[15] - c4*W;

    X[2] = X[1] = X[15] - c5*W;

    X[19] = X[2] - (x2 - X[19]);

    for(var i = 5; i < 15 ; i++)
        X[i] = X[15] - (x15 - X[i]);

    return {X: X, Y: Y};
};
CSigma.prototype.calculateSizeGlyph = function()
{
    // пока размер не меняем в зависимости от высоты аргумента

    //var betta = this.getTxtPrp().FontSize/36;
    var betta = this.Get_TxtPrControlLetter().FontSize/36;

    var _width = 8.997900390624999*betta,
        _height = 11.994444444444444*betta;

    this.gap = 0.93*betta;

    var width = 1.76*_width + this.gap,
        height = 2*_height;

    return {width : width, height : height};
};

/**
 *
 * @param bFlip
 * @constructor
 * @extends {CNaryOperator}
 */
function CProduct(bFlip)
{
    CNaryOperator.call(this, bFlip);
}
CProduct.prototype = Object.create(CNaryOperator.prototype);
CProduct.prototype.constructor = CProduct;
CProduct.prototype.drawPath = function(pGraphics, XX, YY)
{
    pGraphics._m(XX[0], YY[0]);
    pGraphics._l(XX[1], YY[1]);
    pGraphics._c(XX[1], YY[1], XX[2], YY[2], XX[3], YY[3] );
    pGraphics._c(XX[3], YY[3], XX[4], YY[4], XX[5], YY[5] );
    pGraphics._c(XX[5], YY[5], XX[6], YY[6], XX[7], YY[7] );
    pGraphics._c(XX[7], YY[7], XX[8], YY[8], XX[9], YY[9] );
    pGraphics._l(XX[10], YY[10]);
    pGraphics._c(XX[10], YY[10], XX[11], YY[11], XX[12], YY[12] );
    pGraphics._c(XX[12], YY[12], XX[13], YY[13], XX[14], YY[14] );
    pGraphics._c(XX[14], YY[14], XX[15], YY[15], XX[16], YY[16] );
    pGraphics._c(XX[16], YY[16], XX[17], YY[17], XX[18], YY[18] );
    pGraphics._l(XX[19], YY[19]);
    pGraphics._l(XX[20], YY[20]);
    pGraphics._l(XX[21], YY[21]);
    pGraphics._c(XX[21], YY[21], XX[22], YY[22], XX[23], YY[23] );
    pGraphics._c(XX[23], YY[23], XX[24], YY[24], XX[25], YY[25] );
    pGraphics._c(XX[25], YY[25], XX[26], YY[26], XX[27], YY[27] );
    pGraphics._c(XX[27], YY[27], XX[28], YY[28], XX[29], YY[29] );
    pGraphics._l(XX[30], YY[30]);
    pGraphics._l(XX[31], YY[31]);
    pGraphics._l(XX[32], YY[32]);
    pGraphics._c(XX[32], YY[32], XX[33], YY[33], XX[34], YY[34] );
    pGraphics._c(XX[34], YY[34], XX[35], YY[35], XX[36], YY[36] );
    pGraphics._c(XX[36], YY[36], XX[37], YY[37], XX[38], YY[38] );
    pGraphics._c(XX[38], YY[38], XX[39], YY[39], XX[40], YY[40] );
    pGraphics._l(XX[41], YY[41]);
    pGraphics._l(XX[42], YY[42]);
    pGraphics._l(XX[43], YY[43]);
    pGraphics._c(XX[43], YY[43], XX[44], YY[44], XX[45], YY[45] );
    pGraphics._c(XX[45], YY[45], XX[46], YY[46], XX[47], YY[47] );
    pGraphics._c(XX[47], YY[47], XX[48], YY[48], XX[49], YY[49] );
    pGraphics._c(XX[49], YY[49], XX[50], YY[50], XX[51], YY[51] );
    pGraphics._l(XX[52], YY[52]);
    pGraphics._c(XX[52], YY[52], XX[53], YY[53], XX[54], YY[54] );
    pGraphics._c(XX[54], YY[54], XX[55], YY[55], XX[56], YY[56] );
    pGraphics._c(XX[56], YY[56], XX[57], YY[57], XX[58], YY[58] );
    pGraphics._c(XX[58], YY[58], XX[59], YY[59], XX[60], YY[60] );
    pGraphics._l(XX[61], YY[61]);
    pGraphics._l(XX[62], YY[62]);

};
CProduct.prototype.getCoord = function()
{
    var X = [],
        Y = [];

    X[0] = 67894; Y[0] = 0;
    X[1] = 67894; Y[1] = 2245;
    X[2] = 65100; Y[2] = 3024;
    X[3] = 63955; Y[3] = 3666;
    X[4] = 62810; Y[4] = 4307;
    X[5] = 62100; Y[5] = 5338;
    X[6] = 61390; Y[6] = 6368;
    X[7] = 61092; Y[7] = 8338;
    X[8] = 60794; Y[8] = 10308;
    X[9] = 60794; Y[9] = 14706;
    X[10] = 60794; Y[10] = 70551;
    X[11] = 60794; Y[11] = 74674;
    X[12] = 61069; Y[12] = 76666;
    X[13] = 61345; Y[13] = 78659;
    X[14] = 61987; Y[14] = 79736;
    X[15] = 62629; Y[15] = 80813;
    X[16] = 63798; Y[16] = 81523;
    X[17] = 64968; Y[17] = 82233;
    X[18] = 67904; Y[18] = 83012;
    X[19] = 67904; Y[19] = 85257;
    X[20] = 43623; Y[20] = 85257;
    X[21] = 43623; Y[21] = 83012;
    X[22] = 46368; Y[22] = 82279;
    X[23] = 47512; Y[23] = 81614;
    X[24] = 48657; Y[24] = 80950;
    X[25] = 49343; Y[25] = 79896;
    X[26] = 50029; Y[26] = 78843;
    X[27] = 50326; Y[27] = 76850;
    X[28] = 50624; Y[28] = 74857;
    X[29] = 50624; Y[29] = 70551;
    X[30] = 50624; Y[30] = 4856;
    X[31] = 17165; Y[31] = 4856;
    X[32] = 17165; Y[32] = 70551;
    X[33] = 17165; Y[33] = 74994;
    X[34] = 17463; Y[34] = 76918;
    X[35] = 17761; Y[35] = 78843;
    X[36] = 18450; Y[36] = 79873;
    X[37] = 19139; Y[37] = 80904;
    X[38] = 20332; Y[38] = 81591;
    X[39] = 21526; Y[39] = 82279;
    X[40] = 24326; Y[40] = 83012;
    X[41] = 24326; Y[41] = 85257;
    X[42] = 0; Y[42] = 85257;
    X[43] = 0; Y[43] = 83012;
    X[44] = 2743; Y[44] = 82279;
    X[45] = 3931; Y[45] = 81614;
    X[46] = 5120; Y[46] = 80950;
    X[47] = 5783; Y[47] = 79873;
    X[48] = 6446; Y[48] = 78797;
    X[49] = 6743; Y[49] = 76827;
    X[50] = 7040; Y[50] = 74857;
    X[51] = 7040; Y[51] = 70551;
    X[52] = 7040; Y[52] = 14706;
    X[53] = 7040; Y[53] = 10400;
    X[54] = 6743; Y[54] = 8430;
    X[55] = 6446; Y[55] = 6460;
    X[56] = 5806; Y[56] = 5429;
    X[57] = 5166; Y[57] = 4398;
    X[58] = 4000; Y[58] = 3711;
    X[59] = 2834; Y[59] = 3024;
    X[60] = 0; Y[60] = 2245;
    X[61] = 0; Y[61] = 0;
    X[62] = 67894; Y[62] = 0;


    //var textScale = this.getTxtPrp().FontSize/850, // 1000 pt
    var textScale = this.Get_TxtPrControlLetter().FontSize/850, // 1000 pt
        alpha = textScale*25.4/96 /64;

    var h1 = Y[9],
        h2 = Y[19] - Y[10],
        w1 = X[31];

    var Height = this.sizeGlyph.height/alpha - h1 - h2,
        Width = (this.sizeGlyph.width - this.gap)/alpha - 2*w1;

    var hh = Height - (Y[10] - Y[9]),
        ww = Width - (X[30] - X[31]);

    for(var i = 0; i < 20; i++)
    {
        Y[10 + i] += hh;
        Y[32 + i] += hh;
    }

    for(var i = 0; i < 31; i++)
        X[i] += ww;

    X[62] += ww;


    return {X: X, Y: Y};

};
CProduct.prototype.calculateSizeGlyph = function()
{
    //var betta = this.getTxtPrp().FontSize/36;
    var betta = this.Get_TxtPrControlLetter().FontSize/36;

    var _width = 10.312548828125*betta,
        _height = 11.994444444444444*betta;

    this.gap = 0.93*betta;

    var width = 1.76*_width + this.gap,
        height = 2*_height;

    //this.size = {width : width, height : height, center: height/2 };

    return {width : width, height : height};
};

/**
 *
 * @param bFlip
 * @constructor
 * @extends {CNaryOperator}
 */
function CUnion(bFlip)
{
    CNaryOperator.call(this, bFlip);
}
CUnion.prototype = Object.create(CNaryOperator.prototype);
CUnion.prototype.constructor = CUnion;
CUnion.prototype.drawPath = function(pGraphics, XX, YY)
{
    pGraphics._m(XX[0], YY[0]);
    pGraphics._c(XX[0], YY[0], XX[1], YY[1], XX[2], YY[2]);
    pGraphics._c(XX[2], YY[2], XX[3], YY[3], XX[4], YY[4]);
    pGraphics._l(XX[5], YY[5]);
    pGraphics._l(XX[6], YY[6]);
    pGraphics._l(XX[7], YY[7]);
    pGraphics._c(XX[7], YY[7], XX[8], YY[8], XX[9], YY[9]);
    pGraphics._c(XX[9], YY[9], XX[10], YY[10], XX[11], YY[11]);
    pGraphics._c(XX[11], YY[11], XX[12], YY[12], XX[13], YY[13]);
    pGraphics._c(XX[13], YY[13], XX[14], YY[14], XX[15], YY[15]);
    pGraphics._l(XX[16], YY[16]);
    pGraphics._l(XX[17], YY[17]);
    pGraphics._l(XX[18], YY[18]);
    pGraphics._c(XX[18], YY[18], XX[19], YY[19], XX[20], YY[20]);
    pGraphics._c(XX[20], YY[20], XX[21], YY[21], XX[22], YY[22]);
};
CUnion.prototype.getCoord = function()
{
    var X = [],
        Y = [];

    X[0] = 49526.184566929136; Y[0] = 127087.84;
    X[1] = 33974.37429971653; Y[1] = 127877.20000000001;
    X[2] = 25226.481024409448; Y[2] = 120034.20000000001;
    X[3] = 15996.016171708661; Y[3] = 113190.09;
    X[4] = 15301.25; Y[4] = 95025.84;
    X[5] = 15301.25; Y[5] = 0;
    X[6] = 7100; Y[6] = 0;
    X[7] = 7100; Y[7] = 94775.84;
    X[8] = 7100; Y[8] = 117815.09;
    X[9] = 21524.90275275591; Y[9] = 127165.84;
    X[10] = 31605.36420585827; Y[10] = 135801.88;
    X[11] = 49526.184566929136; Y[11] = 135775.84;
    X[12] = 67447.00492800001; Y[12] = 135801.88;
    X[13] = 77527.46638110236; Y[13] = 127165.84;
    X[14] = 91952.36913385827; Y[14] = 117815.09;
    X[15] = 91952.36913385827; Y[15] = 94775.84;
    X[16] = 91952.36913385827; Y[16] = 0;
    X[17] = 83751.11913385827; Y[17] = 0;
    X[18] = 83751.11913385827; Y[18] = 95025.84;
    X[19] = 83056.35296214961; Y[19] = 113190.09;
    X[20] = 73825.88810944883; Y[20] = 120034.20000000001;
    X[21] = 65077.99483414174; Y[21] = 127877.20000000001;
    X[22] = 49526.184566929136; Y[22] = 127087.84;

    return {X: X, Y: Y};
};
CUnion.prototype.calculateSizeGlyph = function()
{
    //var betta = this.getTxtPrp().FontSize/36;
    var betta = this.Get_TxtPrControlLetter().FontSize/36;
    this.gap = 0.93*betta;

    var _width = 9.38*betta,
        _height = 11.994444444444444*betta;

    var width = 1.76*_width + this.gap,
        height = 2*_height;

    return {width : width, height : height};
};

/**
 *
 * @param bFlip
 * @constructor
 * @extends {CNaryOperator}
 */
function CLogicalOr(bFlip)
{
    CNaryOperator.call(this, bFlip);
}
CLogicalOr.prototype = Object.create(CNaryOperator.prototype);
CLogicalOr.prototype.constructor = CLogicalOr;
CLogicalOr.prototype.drawPath = function(pGraphics, XX, YY)
{
    pGraphics._m(XX[0], YY[0]);
    pGraphics._l(XX[1], YY[1]);
    pGraphics._l(XX[2], YY[2]);
    pGraphics._l(XX[3], YY[3]);
    pGraphics._l(XX[4], YY[4]);
    pGraphics._l(XX[5], YY[5]);
    pGraphics._l(XX[6], YY[6]);
    pGraphics._l(XX[7], YY[7]);

};
CLogicalOr.prototype.getCoord = function()
{
    var X = [],
        Y = [];

    X[0] = 0; Y[0] = 0;
    X[1] = 34812; Y[1] = 89801;
    X[2] = 43792; Y[2] = 89801;
    X[3] = 73240; Y[3] = 0;
    X[4] = 63269; Y[4] = 0;
    X[5] = 38719; Y[5] = 77322;
    X[6] = 10613; Y[6] = 0;
    X[7] = 0; Y[7] = 0;

    //var textScale = this.getTxtPrp().FontSize/850, // 1000 pt
    var textScale = this.Get_TxtPrControlLetter().FontSize/850, // 1000 pt
        alpha = textScale*25.4/96 /64;

    var w1 = X[1],
        w2 = X[2] - X[1],
        w4 = X[5] - X[1],
        w5 = X[3] - X[4];

    var Height = this.sizeGlyph.height/alpha,
        Width = (this.sizeGlyph.width - this.gap)/alpha - w2;

    var _W = X[3] - w2,
        k1 = w1/_W;

    X[1] = k1*Width;
    X[2] = X[1] + w2;
    X[5] = X[1] + w4;

    X[3] = Width + w2;
    X[4] = Width + w2 - w5;

    var hh = Height - Y[2];

    Y[1] += hh;
    Y[2] += hh;
    Y[5] += hh;

    return {X: X, Y: Y};
};
CLogicalOr.prototype.calculateSizeGlyph = function()
{
    //var betta = this.getTxtPrp().FontSize/36;
    var betta = this.Get_TxtPrControlLetter().FontSize/36;

    var _width = 9.6159*betta,
        _height = 11.994444444444444*betta;

    this.gap = 0.55*betta;

    var width = 1.76*_width + this.gap,
        height = 2*_height;

    return {width : width, height : height};
};

/**
 *
 * @constructor
 * @extends {CNaryOperator}
 */
function CIntegral()
{
    CNaryOperator.call(this);
}
CIntegral.prototype = Object.create(CNaryOperator.prototype);
CIntegral.prototype.constructor = CIntegral;
CIntegral.prototype.getCoord = function()
{
    var X = [],
        Y = [];

    //top
    X[0] = 20407; Y[0] = 65723;
    X[1] = 20407; Y[1] = 60840;
    X[2] = 20407; Y[2] = 37013;
    X[3] = 24333; Y[3] = 18507;
    X[4] = 28260; Y[4] = 0;
    X[5] = 40590; Y[5] = 0;
    X[6] = 42142; Y[6] = 0;
    X[7] = 43604; Y[7] = 383;
    X[8] = 45067; Y[8] = 765;
    X[9] = 46215; Y[9] = 1305;
    X[10] = 45180; Y[10] = 9225;
    X[11] = 41760; Y[11] = 9225;
    X[12] = 41512; Y[12] = 7335;
    X[13] = 40724; Y[13] = 6064;
    X[14] = 39937; Y[14] = 4793;
    X[15] = 37935; Y[15] = 4793;
    X[16] = 30465; Y[16] = 4793;
    X[17] = 28406; Y[17] = 23086;
    X[18] = 26347; Y[18] = 41378;
    X[19] = 26347; Y[19] = 60840;
    X[20] = 26347; Y[20] = 65723;

    //botton
    X[22] = 26347; Y[22] = 0;
    X[23] = 26347; Y[23] = 4883;
    X[24] = 26325; Y[24] = 33368;
    X[25] = 21622; Y[25] = 49681;
    X[26] = 16920; Y[26] = 65993;
    X[27] = 5467; Y[27] = 65993;
    X[28] = 4387; Y[28] = 65993;
    X[29] = 2947; Y[29] = 65633;
    X[30] = 1507; Y[30] = 65273;
    X[31] = 0; Y[31] = 64553;
    X[32] = 1147; Y[32] = 55665;
    X[33] = 4770; Y[33] = 55665;
    X[34] = 4927; Y[34] = 58050;
    X[35] = 5782; Y[35] = 59412;
    X[36] = 6637; Y[36] = 60773;
    X[37] = 8775; Y[37] = 60773;
    X[38] = 13365; Y[38] = 60773;
    X[39] = 16886; Y[39] = 50783;
    X[40] = 20407; Y[40] = 40793;
    X[41] = 20407; Y[41] = 4883;
    X[42] = 20407; Y[42] = 0;


    var shX = X[9]*0.025;
    for(var i = 0; i < 21; i++)
    {
        X[i] +=shX;
    }

    var shY = Y[26]*0.3377;
    for(var i = 0; i < 21; i++)
    {
        Y[22+i] += shY + Y[20];
    }


    X[21] = (X[20] + X[22])/2; Y[21] = (Y[20] + Y[22])/2;
    X[44] = X[0]; Y[44] = Y[0];
    X[43] = (X[42] + X[44])/2; Y[43] = (Y[44] + Y[42])/2;

    var W = X[9],
        H = Y[27];

    return {X: X, Y: Y, W : W, H: H};
};
CIntegral.prototype.drawPath = function(pGraphics, XX, YY)
{
    pGraphics._m(XX[0], YY[0]);
    pGraphics._l(XX[1], YY[1]);
    pGraphics._c(XX[1], YY[1], XX[2], YY[2], XX[3], YY[3] );
    pGraphics._c(XX[3], YY[3], XX[4], YY[4], XX[5], YY[5] );
    pGraphics._c(XX[5], YY[5], XX[6], YY[6], XX[7], YY[7] );
    pGraphics._c(XX[7], YY[7], XX[8], YY[8], XX[9], YY[9] );
    pGraphics._l(XX[10], YY[10]);
    pGraphics._l(XX[11], YY[11]);
    pGraphics._c(XX[11], YY[11], XX[12], YY[12], XX[13], YY[13] );
    pGraphics._c(XX[13], YY[13], XX[14], YY[14], XX[15], YY[15] );
    pGraphics._c(XX[15], YY[15], XX[16], YY[16], XX[17], YY[17] );
    pGraphics._c(XX[17], YY[17], XX[18], YY[18], XX[19], YY[19] );
    pGraphics._l(XX[20], YY[20]);

    pGraphics._c(XX[20], YY[20], XX[21], YY[21], XX[22], YY[22] );

    pGraphics._l(XX[22], YY[22]);
    pGraphics._l(XX[23], YY[23]);
    pGraphics._c(XX[23], YY[23], XX[24], YY[24], XX[25], YY[25] );
    pGraphics._c(XX[25], YY[25], XX[26], YY[26], XX[27], YY[27] );
    pGraphics._c(XX[27], YY[27], XX[28], YY[28], XX[29], YY[29] );
    pGraphics._c(XX[29], YY[29], XX[30], YY[30], XX[31], YY[31] );
    pGraphics._l(XX[32], YY[32]);
    pGraphics._l(XX[33], YY[33]);
    pGraphics._c(XX[33], YY[33], XX[34], YY[34], XX[35], YY[35] );
    pGraphics._c(XX[35], YY[35], XX[36], YY[36], XX[37], YY[37] );
    pGraphics._c(XX[37], YY[37], XX[38], YY[38], XX[39], YY[39] );
    pGraphics._c(XX[39], YY[39], XX[40], YY[40], XX[41], YY[41] );
    pGraphics._l(XX[42], YY[42]);

    pGraphics._c(XX[42], YY[42], XX[43], YY[43], XX[44], YY[44] );

};
CIntegral.prototype.calculateSizeGlyph = function()
{
    //var betta = this.getTxtPrp().FontSize/36;
    var betta = this.Get_TxtPrControlLetter().FontSize/36;

    var _width =  8.624*betta,
        _height = 13.7*betta;

    this.gap = 0.93*betta;

    var width = _width + this.gap,
        height = 2*_height;

    return {width : width, height : height};
};

/**
 *
 * @constructor
 * @extends {CIntegral}
 */
function CDoubleIntegral()
{
    CIntegral.call(this);
}
CDoubleIntegral.prototype = Object.create(CIntegral.prototype);
CDoubleIntegral.prototype.constructor = CDoubleIntegral;
CDoubleIntegral.prototype.drawPath = function(pGraphics, XX, YY, Width)
{
    var XX2 = [],
        YY2 = [];

    // Width прийдрийдет для TextArt, смещение второго интеграла и для обводки, и для заливки должно быть одинаковым, чтобы корректно отрисовалась обводка
    var w = Width == undefined ? (XX[9] - XX[29])*0.6 : Width*0.36;

    for(var i = 0; i < XX.length; i++)
    {
        XX2[i] = XX[i] + w;
        YY2[i] = YY[i];
    }

	CIntegral.prototype.drawPath.call(this, pGraphics, XX, YY);
    pGraphics.df();

    pGraphics._s();
	CIntegral.prototype.drawPath.call(this, pGraphics, XX2, YY2);
};
CDoubleIntegral.prototype.calculateSizeGlyph = function()
{
    //var betta = this.getTxtPrp().FontSize/36;
    var betta = this.Get_TxtPrControlLetter().FontSize/36;

    var _width = 14.2296*betta,
        _height = 13.7*betta;

    this.gap = 0.93*betta;

    var width = _width + this.gap,
        height = 2*_height;

    return {width : width, height : height};
};

/**
 *
 * @constructor
 * @extends {CIntegral}
 */
function CTripleIntegral()
{
    CIntegral.call(this);
}
CTripleIntegral.prototype = Object.create(CIntegral.prototype);
CTripleIntegral.prototype.constructor = CTripleIntegral;
CTripleIntegral.prototype.drawPath = function(pGraphics, XX, YY, Width)
{
    var XX2 = [],
        YY2 = [];

    // Width прийдрийдет для TextArt, смещения второго и третьего интегралов и для обводки, и для заливки должны быть одинаковыми, чтобы корректно отрисовалась обводка
    var w = Width == undefined ? (XX[9] - XX[29])*0.6 : Width*0.26;

    var XX3 = [],
        YY3 = [];

    for(var i = 0; i < XX.length; i++)
    {
        XX2[i] = XX[i] + w;
        YY2[i] = YY[i];

        XX3[i] = XX[i] + 2*w;
        YY3[i] = YY[i];
    }

	CIntegral.prototype.drawPath.call(this, pGraphics, XX, YY);
    pGraphics.df();

    pGraphics._s();
	CIntegral.prototype.drawPath.call(this, pGraphics, XX2, YY2);
    pGraphics.df();

    pGraphics._s();
	CIntegral.prototype.drawPath.call(this, pGraphics, XX3, YY3);
};
CTripleIntegral.prototype.calculateSizeGlyph = function()
{
    //var betta = this.getTxtPrp().FontSize/36;
    var betta = this.Get_TxtPrControlLetter().FontSize/36;

    var _width = 18.925368*betta,
        _height = 13.7*betta;

    this.gap = 0.93*betta;

    var width = _width + this.gap,
        height = 2*_height;

    return {width : width, height : height};
};


function CCircle()
{

}
CCircle.prototype.getCoord = function()
{
    var X = [],
        Y = [];

    X[0] = 18345.98; Y[0] = 0;
    X[1] = 25288.35; Y[1] = 1008.1;
    X[2] = 27622.45; Y[2] = 2601.85;
    X[3] = 29991.4; Y[3] = 4194.75;
    X[4] = 31723.7; Y[4] = 6460.85;
    X[5] = 33456.85; Y[5] = 8726.95;
    X[6] = 34411.4; Y[6] = 11542.15;
    X[7] = 35366.8; Y[7] = 14357.35;
    X[8] = 35366.8; Y[8] = 17472.6;
    X[9] = 35366.8; Y[9] = 21155.65;
    X[10] = 34180.2; Y[10] = 24201.2;
    X[11] = 32994.45; Y[11] = 27245.9;
    X[12] = 30905.15; Y[12] = 29495;
    X[13] = 28816.7; Y[13] = 31743.25;
    X[14] = 25949.65; Y[14] = 33159.35;
    X[15] = 23294.25; Y[15] = 34469.2;
    X[16] = 17035.7; Y[16] = 34770.53;
    X[17] = 17035.7; Y[17] = 34770.53;
    X[18] = 10029.15; Y[18] = 33832.55;
    X[19] = 7655.1; Y[19] = 32203.1;
    X[20] = 5209.65; Y[20] = 30539.65;
    X[21] = 3525.8; Y[21] = 28309.25;
    X[22] = 1842.8; Y[22] = 26078;
    X[23] = 921.4; Y[23] = 23334.2;
    X[24] = 0; Y[24] = 20589.55;
    X[25] = 0; Y[25] = 17509.15;
    X[26] = 0; Y[26] = 14003.75;
    X[27] = 1133.05; Y[27] = 10959.05;
    X[28] = 2266.1; Y[28] = 7913.5;
    X[29] = 4318.85; Y[29] = 5576.85;
    X[30] = 6372.45; Y[30] = 3240.2;
    X[31] = 9275.2; Y[31] = 1752.7;
    X[32] = 11930.6; Y[32] = 407.15;
    X[33] = 18345.98; Y[33] = 0;

    var W = X[7],
        H = Y[16];

    return {X: X, Y: Y, W: W, H: H};

};
CCircle.prototype.drawPath = function(pGraphics, XX, YY)
{
    pGraphics._m(XX[0], YY[0]);
    pGraphics._c(XX[0], YY[0], XX[1], YY[1], XX[2], YY[2]);
    pGraphics._c(XX[2], YY[2], XX[3], YY[3], XX[4], YY[4]);
    pGraphics._c(XX[4], YY[4], XX[5], YY[5], XX[6], YY[6]);
    pGraphics._c(XX[6], YY[6], XX[7], YY[7], XX[8], YY[8]);
    pGraphics._c(XX[8], YY[8], XX[9], YY[9], XX[10], YY[10]);
    pGraphics._c(XX[10], YY[10], XX[11], YY[11], XX[12], YY[12]);
    pGraphics._c(XX[12], YY[12], XX[13], YY[13], XX[14], YY[14]);
    pGraphics._c(XX[14], YY[14], XX[15], YY[15], XX[16], YY[16]);

    pGraphics._c(XX[17], YY[17], XX[18], YY[18], XX[19], YY[19]);
    pGraphics._c(XX[19], YY[19], XX[20], YY[20], XX[21], YY[21]);
    pGraphics._c(XX[21], YY[21], XX[22], YY[22], XX[23], YY[23]);
    pGraphics._c(XX[23], YY[23], XX[24], YY[24], XX[25], YY[25]);
    pGraphics._c(XX[25], YY[25], XX[26], YY[26], XX[27], YY[27]);
    pGraphics._c(XX[27], YY[27], XX[28], YY[28], XX[29], YY[29]);
    pGraphics._c(XX[29], YY[29], XX[30], YY[30], XX[31], YY[31]);
    pGraphics._c(XX[31], YY[31], XX[32], YY[32], XX[33], YY[33]);
};


function CSurface()
{

}
CSurface.prototype.getCoord = function()
{
    var X = [],
        Y = [];

    X[0] = 24855.55; Y[0] = 312.82;
    X[1] = 27995.71; Y[1] = 0;
    X[2] = 31359.09; Y[2] = 0;
    X[3] = 36162.79; Y[3] = 0;
    X[4] = 40559.9; Y[4] = 694.89;
    X[5] = 43954.72; Y[5] = 1285.5;
    X[6] = 47349.55; Y[6] = 1876.11;
    X[7] = 50600.44; Y[7] = 2814.59;
    X[8] = 54054.17; Y[8] = 4639.82;
    X[9] = 57507.91; Y[9] = 6464.21;
    X[10] = 59945.63; Y[10] = 10061.28;
    X[11] = 62383.35; Y[11] = 13658.35;
    X[12] = 62383.35; Y[12] = 18871.27;
    X[13] = 62383.35; Y[13] = 24154.26;
    X[14] = 59945.63; Y[14] = 27752.16;
    X[15] = 57507.91; Y[15] = 31349.23;
    X[16] = 53481.95; Y[16] = 33468.93;
    X[17] = 49936.09; Y[17] = 35345.88;
    X[18] = 45688.68; Y[18] = 36318.56;
    X[19] = 42330.61; Y[19] = 36884.98;
    X[20] = 38972.54; Y[20] = 37451.41;
    X[21] = 34242.37; Y[21] = 37799.27;
    X[22] = 31359.98; Y[22] = 37799.27;
    X[23] = 27369.45; Y[23] = 37799.27;
    X[24] = 22565.76; Y[24] = 37347.13;
    X[25] = 19337.9; Y[25] = 36774.04;
    X[26] = 16110.04; Y[26] = 36200.94;
    X[27] = 11723.56; Y[27] = 35018.88;
    X[28] = 9068.82; Y[28] = 33663.3;
    X[29] = 6377.76; Y[29] = 32273.53;
    X[30] = 4312.96; Y[30] = 30188.03;
    X[31] = 2249.05; Y[31] = 28101.69;
    X[32] = 1124.08; Y[32] = 25286.27;
    X[33] = 0; Y[33] = 22470.84;
    X[34] = 0; Y[34] = 18959.69;
    X[35] = 0; Y[35] = 13745.94;
    X[36] = 2490.87; Y[36] = 10130.52;
    X[37] = 4982.63; Y[37] = 6515.1;
    X[38] = 8967.84; Y[38] = 4394.56;
    X[39] = 12806.01; Y[39] = 2378.3;
    X[40] = 17529.98; Y[40] = 1370.59;
    X[41] = 21192.77; Y[41] = 841.7;
    X[42] = 24855.55; Y[42] = 312.82;

    var W = X[11],
        H = Y[21];



    return {X: X, Y: Y, W: W, H: H};
};
CSurface.prototype.drawPath = function(pGraphics, XX, YY)
{
    pGraphics._m(XX[0], YY[0]);
    pGraphics._l(XX[0], YY[0]);
    pGraphics._c(XX[0], YY[0], XX[1], YY[1], XX[2], YY[2] );
    pGraphics._c(XX[2], YY[2], XX[3], YY[3], XX[4], YY[4] );
    pGraphics._c(XX[4], YY[4], XX[5], YY[5], XX[6], YY[6] );
    pGraphics._c(XX[6], YY[6], XX[7], YY[7], XX[8], YY[8] );
    pGraphics._c(XX[8], YY[8], XX[9], YY[9], XX[10], YY[10] );
    pGraphics._c(XX[10], YY[10], XX[11], YY[11], XX[12], YY[12] );
    pGraphics._c(XX[12], YY[12], XX[13], YY[13], XX[14], YY[14] );
    pGraphics._c(XX[14], YY[14], XX[15], YY[15], XX[16], YY[16] );
    pGraphics._c(XX[16], YY[16], XX[17], YY[17], XX[18], YY[18] );
    pGraphics._c(XX[18], YY[18], XX[19], YY[19], XX[20], YY[20] );
    pGraphics._c(XX[20], YY[20], XX[21], YY[21], XX[22], YY[22] );
    pGraphics._c(XX[22], YY[22], XX[23], YY[23], XX[24], YY[24] );
    pGraphics._c(XX[24], YY[24], XX[25], YY[25], XX[26], YY[26] );
    pGraphics._c(XX[26], YY[26], XX[27], YY[27], XX[28], YY[28] );
    pGraphics._c(XX[28], YY[28], XX[29], YY[29], XX[30], YY[30] );
    pGraphics._c(XX[30], YY[30], XX[31], YY[31], XX[32], YY[32] );
    pGraphics._c(XX[32], YY[32], XX[33], YY[33], XX[34], YY[34] );
    pGraphics._c(XX[34], YY[34], XX[35], YY[35], XX[36], YY[36] );
    pGraphics._c(XX[36], YY[36], XX[37], YY[37], XX[38], YY[38] );
    pGraphics._c(XX[38], YY[38], XX[39], YY[39], XX[40], YY[40] );
    pGraphics._c(XX[40], YY[40], XX[41], YY[41], XX[42], YY[42] );
};

function CVolume()
{

}
CVolume.prototype.getCoord = function()
{
    var X = [],
        Y = [];

    X[0] = 24086.6; Y[0] = 1584.99;
    X[1] = 25878.03; Y[1] = 1268.19;
    X[2] = 30642.29; Y[2] = 669.24;
    X[3] = 35139.13; Y[3] = 104.94;
    X[4] = 43028.74; Y[4] = 0;
    X[5] = 46945.61; Y[5] = 59.9;
    X[6] = 50862.49; Y[6] = 119.79;
    X[7] = 57135.73; Y[7] = 330.66;
    X[8] = 61811.92; Y[8] = 923.67;
    X[9] = 65955.41; Y[9] = 1411.74;
    X[10] = 68883.14; Y[10] = 2040.39;
    X[11] = 72891.84; Y[11] = 3159.09;
    X[12] = 76900.55; Y[12] = 4277.79;
    X[13] = 82700.15; Y[13] = 6485.49;
    X[14] = 86547.22; Y[14] = 10342.53;
    X[15] = 90394.28; Y[15] = 14199.57;
    X[16] = 90394.28; Y[16] = 19211.94;
    X[17] = 90394.28; Y[17] = 24750.99;
    X[18] = 86653.54; Y[18] = 28554.57;
    X[19] = 82913.87; Y[19] = 32358.15;
    X[20] = 79268.72; Y[20] = 33795.63;
    X[21] = 76154.12; Y[21] = 35057.88;
    X[22] = 74484.05; Y[22] = 35583.57;
    X[23] = 70409.29; Y[23] = 36523.08;
    X[24] = 66334.54; Y[24] = 37462.59;
    X[25] = 64662.32; Y[25] = 37742.76;
    X[26] = 60137.56; Y[26] = 38336.76;
    X[27] = 55689.05; Y[27] = 38896.11;
    X[28] = 47782.26; Y[28] = 39001.05;
    X[29] = 44054.41; Y[29] = 38969.37;
    X[30] = 40326.55; Y[30] = 38937.69;
    X[31] = 36744.76; Y[31] = 38832.75;
    X[32] = 32133.01; Y[32] = 38481.3;
    X[33] = 27597.5; Y[33] = 38130.84;
    X[34] = 21918.19; Y[34] = 37007.19;
    X[35] = 17870.29; Y[35] = 35901.36;
    X[36] = 13822.38; Y[36] = 34795.53;
    X[37] = 13593.62; Y[37] = 34726.23;
    X[38] = 13365.93; Y[38] = 34620.3;
    X[39] = 9226.73; Y[39] = 33113.52;
    X[40] = 6246.38; Y[40] = 30888;
    X[41] = 3266.03; Y[41] = 28662.48;
    X[42] = 1632.48; Y[42] = 25789.5;
    X[43] = 0; Y[43] = 22915.53;
    X[44] = 0; Y[44] = 19201.05;
    X[45] = 0; Y[45] = 14329.26;
    X[46] = 3746.11; Y[46] = 10456.38;
    X[47] = 7493.3; Y[47] = 6583.5;
    X[48] = 13503.4; Y[48] = 4341.15;
    X[49] = 18795; Y[49] = 2963.07;
    X[50] = 24086.6; Y[50] = 1584.99;

    var W = X[15],
        H = Y[28];


    return {X: X, Y: Y, W : W, H : H};
};
CVolume.prototype.drawPath = function(pGraphics, XX, YY)
{
    pGraphics._m(XX[0], YY[0]);
    pGraphics._c(XX[0], YY[0], XX[1], YY[1], XX[2], YY[2] );
    pGraphics._c(XX[2], YY[2], XX[3], YY[3], XX[4], YY[4] );
    pGraphics._c(XX[4], YY[4], XX[5], YY[5], XX[6], YY[6] );
    pGraphics._c(XX[6], YY[6], XX[7], YY[7], XX[8], YY[8] );
    pGraphics._c(XX[8], YY[8], XX[9], YY[9], XX[10], YY[10] );
    pGraphics._c(XX[10], YY[10], XX[11], YY[11], XX[12], YY[12] );
    pGraphics._c(XX[12], YY[12], XX[13], YY[13], XX[14], YY[14] );
    pGraphics._c(XX[14], YY[14], XX[15], YY[15], XX[16], YY[16] );
    pGraphics._c(XX[16], YY[16], XX[17], YY[17], XX[18], YY[18] );
    pGraphics._c(XX[18], YY[18], XX[19], YY[19], XX[20], YY[20] );
    pGraphics._c(XX[20], YY[20], XX[21], YY[21], XX[22], YY[22] );
    pGraphics._c(XX[22], YY[22], XX[23], YY[23], XX[24], YY[24] );
    pGraphics._c(XX[24], YY[24], XX[25], YY[25], XX[26], YY[26] );
    pGraphics._c(XX[26], YY[26], XX[27], YY[27], XX[28], YY[28] );
    pGraphics._c(XX[28], YY[28], XX[29], YY[29], XX[30], YY[30] );
    pGraphics._c(XX[30], YY[30], XX[31], YY[31], XX[32], YY[32] );
    pGraphics._c(XX[32], YY[32], XX[33], YY[33], XX[34], YY[34] );
    pGraphics._c(XX[34], YY[34], XX[35], YY[35], XX[36], YY[36] );
    pGraphics._c(XX[36], YY[36], XX[37], YY[37], XX[38], YY[38] );
    pGraphics._c(XX[38], YY[38], XX[39], YY[39], XX[40], YY[40] );
    pGraphics._c(XX[40], YY[40], XX[41], YY[41], XX[42], YY[42] );
    pGraphics._c(XX[42], YY[42], XX[43], YY[43], XX[44], YY[44] );
    pGraphics._c(XX[44], YY[44], XX[45], YY[45], XX[46], YY[46] );
    pGraphics._c(XX[46], YY[46], XX[47], YY[47], XX[48], YY[48] );
    pGraphics._c(XX[48], YY[48], XX[49], YY[49], XX[50], YY[50] );
};

/**
 *
 * @constructor
 * @extends {CNaryOperator}
 */
function CClosedPathIntegral()
{
    CNaryOperator.call(this);
}
CClosedPathIntegral.prototype = Object.create(CNaryOperator.prototype);
CClosedPathIntegral.prototype.constructor = CClosedPathIntegral;
CClosedPathIntegral.prototype.drawGlyph = function(parameters)
{
    var x           = parameters.x,
        y           = parameters.y,
        Integral    = parameters.Integral,
        Circle      = parameters.Circle,
        CoeffWidth  = parameters.CoeffWidth,
        PDSE        = parameters.PDSE;

    var pGraphics   = parameters.PDSE.Graphics;


    var oCompiledPr = this.Parent.Get_CompiledCtrPrp();

    if(CoeffWidth == undefined)
        CoeffWidth = 1;

    var CoordCircle     = Circle.getCoord(),
        CoordIntegral   = Integral.getCoord();

    var CircleX = CoordCircle.X,
        CircleY = CoordCircle.Y,
        CircleW = CoordCircle.W,
        CircleH = CoordCircle.H;

    var IntegralX = CoordIntegral.X,
        IntegralY = CoordIntegral.Y,
        IntegralW = CoeffWidth*CoordIntegral.W,
        IntegralH = CoordIntegral.H;

    var FontSize  = this.Get_TxtPrControlLetter().FontSize;
    var textScale = FontSize/850;// 1000 pt
    var alpha     = textScale*0.00413; // 25.4/96 /64;

    var shX = (IntegralW - CircleW)*alpha*0.5,
        shY = (IntegralH - CircleH)*alpha*0.48;

    var ExtX    = [],  ExtY    = [],
        InsideX = [],  InsideY = [];

    for(var j = 0; j < IntegralX.length; j++)
    {
        IntegralX[j] = this.pos.x + x + IntegralX[j]*alpha;
        IntegralY[j] = this.pos.y + y + IntegralY[j]*alpha;
    }

    var CircleLng = CircleX.length;

    var intGrid = pGraphics.GetIntegerGrid();
    pGraphics.SetIntegerGrid(false);

    this.Parent.Make_ShdColor(PDSE, this.Parent.Get_CompiledCtrPrp());

    if(pGraphics.isSupportTextOutline())
    {
        for(var i = 0; i < CircleLng; i++)
        {
            ExtX[i]     = this.pos.x + x + shX + CircleX[i]*alpha*1.1 - CircleW*alpha*0.04;
            ExtY[i]     = this.pos.y + y + shY + CircleY[i]*alpha*1.1;

            InsideX[i]  = this.pos.x + x + shX + CircleX[CircleLng - i - 1]*alpha*0.9 + CircleW*alpha*0.06;
            InsideY[i]  = this.pos.y + y + shY + CircleY[CircleLng - i - 1]*alpha*0.9 + CircleH*alpha*0.1;
        }

        var oTextOutline = oCompiledPr.TextOutline;

        var oCompiledPr2 = oCompiledPr.Copy();
        oCompiledPr2.TextFill = AscFormat.CreateNoFillUniFill();
        oCompiledPr2.Unifill  = null;
        oCompiledPr2.Color    = null;
        pGraphics.SetTextPr(oCompiledPr2, PDSE.Theme);
        pGraphics._s();
        Circle.drawPath(pGraphics, ExtX, ExtY);
        pGraphics._z();
        Circle.drawPath(pGraphics, InsideX, InsideY);
        pGraphics._z();
        pGraphics.ds();
        pGraphics.df();
        pGraphics._s();
        Integral.drawPath(pGraphics, IntegralX, IntegralY, IntegralW*alpha);
        pGraphics.ds();
        pGraphics.df();

        // делаем заливку уже обводки
		var WidthLine = 0;
		if (oTextOutline && AscFormat.isRealNumber(oTextOutline.w))
			WidthLine = (oTextOutline.w / 36000) * 0.6; // сместим заливку на половину толщины линии , чтобы не было зазоров м/ду обводкой и заливкой

        // последняя точка совпадает в пути с первой, поэтому берем предпоследнюю

        var PrevX = ExtX[CircleLng - 2],
            PrevY = ExtY[CircleLng - 2];

        for(var i = 1; i < CircleLng; i++)
        {
            if(PrevY > ExtY[i])
            {
                ExtX[i]                     += WidthLine;
                InsideX[CircleLng - i - 1]  -= WidthLine;
            }
            else if(PrevY < ExtY[i])
            {
                ExtX[i]                     -= WidthLine;
                InsideX[CircleLng - i - 1]  += WidthLine;
            }

            if(PrevX > ExtX[i])
            {
                ExtY[i]                     -= WidthLine;
                InsideY[CircleLng - i - 1]  += WidthLine;
            }
            else if(PrevX < ExtX[i])
            {
                ExtY[i]                    += WidthLine;
                InsideY[CircleLng - i - 1] -= WidthLine;
            }

            PrevX = ExtX[i];
            PrevY = ExtY[i];
        }

        ExtX[0] = ExtX[CircleX.length - 1];
        ExtY[0] = ExtY[CircleX.length - 1];

        InsideY[CircleX.length - 1] = InsideY[0];
        InsideY[CircleX.length - 1] = InsideY[0];

        var IntegralLng = IntegralX.length;
        PrevX = IntegralX[IntegralLng - 2];
        PrevY = IntegralY[IntegralLng - 2];

        for(var j = 0; j < IntegralLng; j++)
        {
            var CurrentX = IntegralX[j],
                CurrentY = IntegralY[j];

            if(PrevY > IntegralY[j])
                IntegralX[j] += WidthLine;
            else if(PrevY < IntegralY[j])
                IntegralX[j] -= WidthLine;

            if(PrevX > IntegralX[j])
                IntegralY[j] -= WidthLine;
            else if(PrevX < IntegralX[j])
                IntegralY[j] += WidthLine;


            PrevX = CurrentX;
            PrevY = CurrentY;
        }


        IntegralX[0] = IntegralX[IntegralLng - 1];
        IntegralY[0] = IntegralY[IntegralLng - 1];

		let _compiledPr = oCompiledPr.Copy();
		_compiledPr.TextOutline  = null;
        pGraphics.SetTextPr(_compiledPr, PDSE.Theme);

        pGraphics._s();
        Circle.drawPath(pGraphics, ExtX, ExtY);
        pGraphics._z();
        Circle.drawPath(pGraphics, InsideX, InsideY);
        pGraphics._z();
        pGraphics.ds();
        pGraphics.df();

        pGraphics._s();
        Integral.drawPath(pGraphics, IntegralX, IntegralY, IntegralW*alpha);
        pGraphics.ds();
        pGraphics.df();
    }
    else
    {
        for(var i = 0; i < CircleLng; i++)
        {
            CircleX[i] = this.pos.x + x + shX + CircleX[i]*alpha;
            CircleY[i] = this.pos.y + y + shY + CircleY[i]*alpha;
        }

        var penCircle = 750*FontSize/32;
        pGraphics.p_width(penCircle);

        pGraphics._s();
        Circle.drawPath(pGraphics, CircleX, CircleY);
        pGraphics.ds();

        pGraphics.p_width(0);

        pGraphics._s();

        Integral.drawPath(pGraphics, IntegralX, IntegralY);
        pGraphics.df();
    }

    pGraphics._s();

    pGraphics.SetIntegerGrid(intGrid);
};


/**
 *
 * @constructor
 * @extends {CClosedPathIntegral}
 */
function CContourIntegral()
{
    CClosedPathIntegral.call(this);
}
CContourIntegral.prototype = Object.create(CClosedPathIntegral.prototype);
CContourIntegral.prototype.constructor = CContourIntegral;
CContourIntegral.prototype.drawGlyph = function(x, y, pGraphics, PDSE)
{
    var parameters =
    {
        x:              x,
        y:              y,
        CoeffWidth:     1.0,
        PDSE:           PDSE,
        Integral:       new CIntegral(),
        Circle:         new CCircle()
    };

	CClosedPathIntegral.prototype.drawGlyph.call(this, parameters);
};
CContourIntegral.prototype.calculateSizeGlyph = function()
{
    var betta = this.Get_TxtPrControlLetter().FontSize/36;

    var _width =  8.624*betta,
        _height = 13.7*betta;

    this.gap = 0.93*betta;

    var width = _width + this.gap,
        height = 2*_height;

    return {width : width, height : height};
};

/**
 *
 * @constructor
 * @extends {CClosedPathIntegral}
 */
function CSurfaceIntegral()
{
    CClosedPathIntegral.call(this);
}
CSurfaceIntegral.prototype = Object.create(CClosedPathIntegral.prototype);
CSurfaceIntegral.prototype.constructor = CSurfaceIntegral;
CSurfaceIntegral.prototype.drawGlyph = function(x, y, pGraphics, PDSE)
{
    var parameters =
    {
        x:              x,
        y:              y,
        CoeffWidth:     1.6,
        PDSE:           PDSE,
        Integral:       new CDoubleIntegral(),
        Circle:         new CSurface()
    };

	CClosedPathIntegral.prototype.drawGlyph.call(this, parameters);
};
CSurfaceIntegral.prototype.calculateSizeGlyph = function()
{
    var betta = this.Get_TxtPrControlLetter().FontSize/36;

    var _width =  14.2296*betta,
        _height = 13.7*betta;

    this.gap = 0.93*betta;

    var width = _width + this.gap,
        height = 2*_height;

    return {width : width, height : height};
};

/**
 *
 * @constructor
 * @extends {CClosedPathIntegral}
 */
function CVolumeIntegral()
{
    CClosedPathIntegral.call(this);
}
CVolumeIntegral.prototype = Object.create(CClosedPathIntegral.prototype);
CVolumeIntegral.prototype.constructor = CVolumeIntegral;
CVolumeIntegral.prototype.drawGlyph = function(x, y, pGraphics, PDSE)
{
    var parameters =
    {
        x:              x,
        y:              y,
        CoeffWidth:     2.1,
        PDSE:           PDSE,
        Integral:       new CTripleIntegral(),
        Circle:         new CVolume()
    };

	CClosedPathIntegral.prototype.drawGlyph.call(this, parameters);
};
CVolumeIntegral.prototype.calculateSizeGlyph = function()
{
    var betta = this.Get_TxtPrControlLetter().FontSize/36;

    var _width =  18.925368*betta,
        _height = 13.7*betta;

    this.gap = 0.93*betta;

    var width = _width + this.gap,
        height = 2*_height;

    return {width : width, height : height};
};

//--------------------------------------------------------export----------------------------------------------------
window['AscCommonWord'] = window['AscCommonWord'] || {};
window['AscCommonWord'].CNary = CNary;

AscMath.Nary = CNary;