/*
 * (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";

// Import
var g_oTextMeasurer = AscCommon.g_oTextMeasurer;
var c_oAscRevisionsChangeType = Asc.c_oAscRevisionsChangeType;
/** @enum {number} */
var c_oAscMathInterfaceMatrixRowRule = {
    Single     : 0x00,
    OneAndHalf : 0x01,
    Double     : 0x02,
    Exactly    : 0x03,
    Multiple   : 0x04

};

/** @enum {number} */
var c_oAscMathInterfaceMatrixColumnRule = {
    Single     : 0x00,
    OneAndHalf : 0x01,
    Double     : 0x02,
    Exactly    : 0x03,
    Multiple   : 0x04
};



/** @enum {number} */
var c_oAscMathInterfaceEqArrayLineRule = {
    Single     : 0x00,
    OneAndHalf : 0x01,
    Double     : 0x02,
    Exactly    : 0x03,
    Multiple   : 0x04
};

/** @enum {number} */
var c_oAscMathInterfaceSettingsBrkBin = {
    BreakRepeat : 0x00,
    BreakBefore : 0x01,
    BreakAfter  : 0x02
};

/** @enum {number} */
var c_oAscMathInterfaceSettingsAlign = {
    Left    : 0,
    Center  : 1,
    Right   : 2,
    Justify : 3
};



/** @enum {number} */
var c_oAscMathMainType = {
    Symbol        : 0x00,
    Fraction      : 0x01,
    Script        : 0x02,
    Radical       : 0x03,
    Integral      : 0x04,
    LargeOperator : 0x05,
    Bracket       : 0x06,
    Function      : 0x07,
    Accent        : 0x08,
    LimitLog      : 0x09,
    Operator      : 0x0a,
    Matrix        : 0x0b,
    Empty_Content : 0x0c
};

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

    this.Type = para_Math_Composition;

    this.pos  = new CMathPosition();
    this.size = new CMathSize();

    //  Properties
    this.Parent 			 = null;
    this.ParaMath 			 = null; // ссылка на общую формулу

    this.CtrPrp 			 = new CTextPr();
    this.CompiledCtrPrp 	 = new CTextPr(); 
    this.TextPrControlLetter = new CTextPr();

    this.ArgSize             = new CMathArgSize();

    /////////////////
    this.nRow                = 0;
    this.nCol                = 0;

    this.bInside             = bInside === true;

    this.bOneLine            = true;
    this.bCanBreak           = false;
    this.NumBreakContent     = -1;

    this.elements            = [];

    this.Bounds = new CMathBounds();

    this.dW = 0; //column gap, gap width
    this.dH = 0; //row gap, gap height

    this.alignment =
    {
        hgt: null,
        wdt: null
    };

    this.GapLeft = 0;
    this.GapRight = 0;

    this.BrGapLeft  = 0;
    this.BrGapRight = 0;

    this.RecalcInfo =
    {
        bCtrPrp:     true,
        bProps:      true
    };

    this.Content = [];
    this.CurPos  = 0;

    this.Selection =
    {
        StartPos : 0,
        EndPos   : 0,
        Use      : false
    };

    this.NearPosArray = [];

    this.ReviewType = reviewtype_Common;
    this.ReviewInfo = new AscWord.ReviewInfo();

    var Api = editor;
    if (Api && !Api.isPresentationEditor && Api.WordControl && Api.WordControl.m_oLogicDocument && true === Api.WordControl.m_oLogicDocument.IsTrackRevisions())
    {
        this.ReviewType = reviewtype_Add;
        this.ReviewInfo.Update();
    }

	this.m_oContentChanges = new AscCommon.CContentChanges(); // список изменений(добавление/удаление элементов)

    return this;
}
CMathBase.prototype = Object.create(CParagraphContentWithParagraphLikeContent.prototype);
CMathBase.prototype.constructor = CMathBase;
CMathBase.prototype.setContent = function()
{
    for(var i=0; i < this.nRow; i++)
    {
        this.elements[i] = [];
        for(var j = 0; j < this.nCol; j++)
            this.elements[i][j] = new CMathContent();
    }
};
CMathBase.prototype.setDimension = function(countRow, countCol)
{
    this.nRow = countRow;
    this.nCol = countCol;

    this.alignment.hgt = [];
    this.alignment.wdt = [];

    for(var i = 0; i < this.nCol ; i++)
    {
        this.alignment.wdt[i] = MCJC_CENTER;
    }

    for(var j=0; j < this.nRow; j++)
    {
        this.elements[j] = [];
        this.alignment.hgt[j] = MCJC_CENTER;
    }

};
CMathBase.prototype.SetParent = function(parent)
{
	this.Parent = parent;
};
CMathBase.prototype.NeedBreakContent = function(Number)
{
    this.bCanBreak       = true;
    this.NumBreakContent = Number;
};
///////// RunPrp, CtrPrp
CMathBase.prototype.setCtrPrp = function(txtPrp) // выставляем ctrPrp на чтение
{
    if(txtPrp !== null && typeof(txtPrp) !== "undefined")
    {
        this.CtrPrp.Merge(txtPrp);
    }
};
CMathBase.prototype.Get_CtrPrp = function(bCopy)
{
    var CtrPrp;
    if(this.bInside === true)
        CtrPrp = this.Parent.Get_CtrPrp(bCopy);
    else
        CtrPrp = bCopy ? this.CtrPrp.Copy() : this.CtrPrp;

    return CtrPrp;
};
CMathBase.prototype.Get_CompiledCtrPrp = function(bAllowInline)
{
    this.Set_CompiledCtrPrp(this.Parent, this.ParaMath);

    var CompiledCtrPrp;

    if(this.bInside === true)
    {
        CompiledCtrPrp = this.Parent.Get_CompiledCtrPrp();
    }
    else
    {
        CompiledCtrPrp = this.Get_CompiledCtrPrp_2();

        if(bAllowInline !== false && this.ParaMath)
            CompiledCtrPrp.FontSize *= MatGetKoeffArgSize(CompiledCtrPrp.FontSize, this.Parent.Get_CompiledArgSize().value);
    }

    if(bAllowInline !== false && this.ParaMath)
        CompiledCtrPrp.FontSize *= MatGetKoeffArgSize(CompiledCtrPrp.FontSize, this.ArgSize.value);// для настроек inline формул

    return CompiledCtrPrp;
};
CMathBase.prototype.Get_CompiledCtrPrp_2 = function() // without arg Size
{
    this.Set_CompiledCtrPrp(this.Parent, this.ParaMath);

    var CompiledCtrPrp;

    if(this.bInside === true)
        CompiledCtrPrp = this.Parent.Get_CompiledCtrPrp_2();
    else
        CompiledCtrPrp = this.CompiledCtrPrp.Copy();

    return CompiledCtrPrp;
};
CMathBase.prototype.Get_CompiledArgSize = function()
{
    return this.Parent.Get_CompiledArgSize();
};
CMathBase.prototype.Get_TxtPrControlLetter = function(RPI) // TextPrControlLetter не копируются !
{
    this.Set_CompiledCtrPrp(this.Parent, this.ParaMath, RPI);

    return this.TextPrControlLetter;
};
CMathBase.prototype.SetPlaceholder = function()
{
	for (var i = 0; i < this.nRow; i++)
	{
		for (var j = 0; j < this.nCol; j++)
		{
			if (!this.elements[i][j].IsJustDraw())
				this.elements[i][j].SetPlaceholder();
		}
	}
};
CMathBase.prototype.CheckRunContent = function(fCheck)
{
    for(var i = 0; i < this.Content.length; ++i)
    {
        this.Content[i].CheckRunContent(fCheck);
    }
};
CMathBase.prototype.addMCToContent = function(elements)
{
    if(elements.length == this.nRow*this.nCol)
    {
        this.elements.length = 0;
        for(var i = 0; i < this.nRow; i++)
        {
            this.elements[i] = [];
            for(var j = 0; j < this.nCol; j++)
                this.elements[i][j] = elements[j + i*this.nCol];
        }
    }
    else
        this.setContent();
};
// эта функция здесь необходима для случая с n-арными операторами : когда передаем n-арный оператор с итераторами и аргумент
CMathBase.prototype.IsJustDraw = function()
{
    return false;
};
CMathBase.prototype.IsAccent = function()
{
    return false;
};
CMathBase.prototype.IsEqArray = function()
{
    return false;
};
CMathBase.prototype.getWidthsHeights = function()
{
    var Widths = [];
    for(var tt = 0; tt < this.nCol; tt++ )
        Widths[tt] = 0;

    var Ascents = [];
    var Descents = [];

    for(tt = 0; tt < this.nRow; tt++ )
    {
        Ascents[tt] = 0;
        Descents[tt] = 0;
    }

    for(var i=0; i < this.nRow; i++)
        for(var j = 0; j < this.nCol ; j++)
        {
            var size = this.elements[i][j].size;
            Widths[j] = ( Widths[j] > size.width ) ? Widths[j] : size.width;
            Ascents[i] = (Ascents[i] > size.ascent ) ? Ascents[i] : size.ascent;
            Descents[i] = (Descents[i] > size.height - size.ascent ) ? Descents[i] : size.height - size.ascent;
        }

    var Heights = [];
    for(tt = 0; tt < this.nRow; tt++ )
    {
        Heights[tt] = Ascents[tt] + Descents[tt];
    }

    return { widths: Widths, heights: Heights };
};
CMathBase.prototype.align = function(pos_x, pos_y)
{
    var PosAlign = new CMathPosition();

    if(this.alignment.hgt[pos_x] == MCJC_CENTER)
    {
        var maxAsc = 0;

        for(var j = 0; j < this.nCol; j++)
        {
            var _ascent = this.elements[pos_x][j].size.ascent;
            maxAsc = ( maxAsc > _ascent ) ? maxAsc : _ascent;
        }
        PosAlign.y = maxAsc - this.elements[pos_x][pos_y].size.ascent;
    }
    else if(this.alignment.hgt[pos_x] == MCJC_LEFT)
    {
        PosAlign.y = 0;
    }
    else // MCJC_RIGHT
    {
        var maxH = 0;

        for(var j = 0; j < this.nCol; j++)
        {
            var _h = this.elements[pos_x][j].size.height;
            maxH = ( maxH > _h ) ? maxH : _h;
        }

        PosAlign.y = maxH - this.elements[pos_x][pos_y].size.height;
    }

    var maxW  = 0;
    for(var i=0; i < this.nRow; i++)
    {
        var _w = this.elements[i][pos_y].size.width;
        maxW = ( maxW > _w ) ? maxW : _w;
    }

    if(this.alignment.wdt[pos_y] == MCJC_CENTER)
        PosAlign.x = (maxW - this.elements[pos_x][pos_y].size.width)*0.5;
    else if(this.alignment.wdt[pos_y] == MCJC_LEFT)
        PosAlign.x = 0;
    else // MCJC_RIGHT
        PosAlign.x = maxW - this.elements[pos_x][pos_y].size.width;

    return PosAlign;
};
CMathBase.prototype.setPosition = function(pos, PosInfo)
{
    this.UpdatePosBound(pos, PosInfo);

    if(this.bOneLine)
    {
        this.pos.x = pos.x;

        if(this.bInside === true)
            this.pos.y = pos.y;
        else
            this.pos.y = pos.y - this.size.ascent; ///!!!!

        var maxWH = this.getWidthsHeights();
        var Widths = maxWH.widths;
        var Heights = maxWH.heights;

        var h = 0, w = 0;

        for(var i=0; i < this.nRow; i++)
        {
            w = 0;
            for(var j = 0; j < this.nCol; j++)
            {
                var NewPos = new CMathPosition();
                var al = this.align(i, j);

                NewPos.x = this.pos.x + this.GapLeft + al.x + this.dW*j + w;
                NewPos.y = this.pos.y + al.y + this.dH*i + h;

                if(this.elements[i][j].Type == para_Math_Content) // прибавим ascent только для контентов, для вложенных мат объектов не добавляем !
                    NewPos.y += this.elements[i][j].size.ascent;

                this.elements[i][j].setPosition(NewPos, PosInfo);
                w += Widths[j];
            }
            h += Heights[i];
        }

        pos.x += this.size.width;
    }
    else
    {
        var Line  = PosInfo.CurLine,
            Range = PosInfo.CurRange;
        var CurLine  = Line - this.StartLine;
        var CurRange = ( 0 === CurLine ? Range - this.StartRange : Range );

        var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
        var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

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

        this.Content[StartPos].setPosition(pos, PosInfo);

        for(var Pos = StartPos + 1; Pos <= EndPos; Pos++)
        {
            pos.x += this.dW;
            this.Content[Pos].setPosition(pos, PosInfo);
        }

        var Len = this.Content.length;

        // Здесь проверяем не на то, что это последний Range (т.к. на данном этапе еще идет вычисление строк) а на конец контента !

        var EndBrContentEnd = this.NumBreakContent == EndPos && this.Content[EndPos].Math_Is_End(Line, Range),
            NotBrContent = this.NumBreakContent !== EndPos;

        var bEnd = EndBrContentEnd || NotBrContent;

        if(EndPos == Len - 1 && true === bEnd)
            pos.x += this.BrGapRight;

    }
};
CMathBase.prototype.ShiftPage = function(Dx)
{
    this.Bounds.ShiftPage(Dx);

    for(var i=0; i < this.nRow; i++)
    {
        for(var j = 0; j < this.nCol; j++)
        {
            var Item = this.elements[i][j];
            if(false == Item.IsJustDraw())
                Item.ShiftPage(Dx);
        }
    }
};
CMathBase.prototype.Shift_Range = function(Dx, Dy, _CurLine, _CurRange, _CurPage)
{
    var CurLine  = _CurLine - this.StartLine;
    var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );

    if(this.bOneLine)
    {
        this.Bounds.ShiftPos(CurLine, CurRange, Dx, Dy);

        for(var i=0; i < this.nRow; i++)
        {
            for(var j = 0; j < this.nCol; j++)
            {
                var Item = this.elements[i][j];
                if(false == Item.IsJustDraw())
                    Item.Shift_Range(Dx, Dy, _CurLine, _CurRange, _CurPage);
            }
        }
    }
    else
    {
        this.Bounds.ShiftPos(CurLine, CurRange, Dx, Dy);

		CParagraphContentWithParagraphLikeContent.prototype.Shift_Range.call(this, Dx, Dy, _CurLine, _CurRange, _CurPage);
    }
};
CMathBase.prototype.IsStartRange = function(_CurLine, _CurRange)
{
    var CurLine  = _CurLine - this.StartLine;
    var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );

    return CurLine == 0 && CurRange == 0;
};
CMathBase.prototype.IsLastRange = function(_CurLine, _CurRange)
{
    var CurLine  = _CurLine - this.StartLine;
    var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );

    var LinesCount = this.protected_GetLinesCount(),
        RangesCount = this.protected_GetRangesCount(CurLine);


    return CurLine == LinesCount - 1 && CurRange == RangesCount - 1;
};
CMathBase.prototype.UpdatePosBound = function(pos, PosInfo)
{
    var CurLine  = PosInfo.CurLine - this.StartLine;
    var CurRange = ( 0 === CurLine ? PosInfo.CurRange - this.StartRange : PosInfo.CurRange);

    this.Bounds.SetPos(CurLine, CurRange, pos);
};
CMathBase.prototype.UpdateBoundsPosInfo = function(PRSA, _CurLine, _CurRange, _CurPage)
{
    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(this.bOneLine == true)
    {
        for(var i=0; i < this.nRow; i++)
        {
            for(var j = 0; j < this.nCol; j++)
            {
                if(false == this.elements[i][j].IsJustDraw())
                    this.elements[i][j].UpdateBoundsPosInfo(PRSA, _CurLine, _CurRange, _CurPage);
            }
        }
    }
    else
    {
        var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
        var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

        for(var Pos = StartPos; Pos <= EndPos; Pos++)
        {
            this.Content[Pos].UpdateBoundsPosInfo(PRSA, _CurLine, _CurRange, _CurPage);
        }
    }

};
CMathBase.prototype.draw = function(x, y, pGraphics, PDSE)
{
    this.Make_ShdColor(PDSE, this.Get_CompiledCtrPrp()); // для Just-Draw элементов

    for(var i=0; i < this.nRow; i++)
        for(var j = 0; j < this.nCol; j++)
        {
            if(this.elements[i][j].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
                };

                pGraphics.SetFont(Font);
            }

            this.elements[i][j].draw(x, y, pGraphics, PDSE);
        }
};
CMathBase.prototype.Draw_Elements = function(PDSE)
{
    if(this.bOneLine)
    {
        var X = PDSE.X;

        this.Make_ShdColor(PDSE, this.Get_CompiledCtrPrp()); // для Just-Draw элементов

        for(var i=0; i < this.nRow; i++)
        {
            for(var j = 0; j < this.nCol; j++)
            {
                if(this.elements[i][j].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.elements[i][j].Draw_Elements(PDSE);
            }
        }

        PDSE.X = X + this.size.width;
    }
    else
    {
        var CurLine  = PDSE.Line - this.StartLine;
        var CurRange = ( 0 === CurLine ? PDSE.Range - this.StartRange : PDSE.Range );

        var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
        var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

        for (var CurPos = StartPos; CurPos <= EndPos; CurPos++ )
        {
			this.Content[CurPos].Draw_Elements(PDSE);
        }
    }
};
CMathBase.prototype.remove = function(order)
{
    return this.Parent.remove(order);
};
CMathBase.prototype.ApplyProperties = function(RPI)
{};
CMathBase.prototype.PreRecalc = function(Parent, ParaMath, ArgSize, RPI, GapsInfo)
{
    this.Parent = Parent;
    this.ParaMath = ParaMath;

    this.Set_CompiledCtrPrp(Parent, ParaMath, RPI);

    this.ApplyProperties(RPI);

    // setGaps обязательно после того как смержили CtrPrp (Set_CompiledCtrPrp)
    if(this.bInside == false)
        GapsInfo.setGaps(this, this.TextPrControlLetter.FontSize);

    for(var i=0; i < this.nRow; i++)
        for(var j = 0; j < this.nCol; j++)
            this.elements[i][j].PreRecalc(this, ParaMath, ArgSize, RPI);

};
CMathBase.prototype.Math_UpdateGaps = function(_CurLine, _CurRange, GapsInfo)
{
    GapsInfo.updateCurrentObject(this, this.TextPrControlLetter.FontSize);

    if(GapsInfo.bUpdate == true)
    {
        GapsInfo.updateGaps();
    }

    if(this.bOneLine == false)
    {
        var BrPos = this.NumBreakContent;
        this.Content[BrPos].Math_UpdateGaps(_CurLine, _CurRange);
    }
};
CMathBase.prototype.UpdLastElementForGaps = function(CurLine, CurRange, GapsInfo)
{
    GapsInfo.updateCurrentObject(this, this.TextPrControlLetter.FontSize);
};
CMathBase.prototype.recalculateSize = function(oMeasure, RPI)
{
    var width = 0;
    var height = 0;

    var maxWH = this.getWidthsHeights();

    this.setDistance();

    var Widths = maxWH.widths;
    var Heights = maxWH.heights;

    for( var j = 0 ; j < this.nRow; j++ )
        height += Heights[j];

    height += this.dH*(this.nRow - 1);

    for(var i=0; i < this.nCol ; i++)
        width += Widths[i];

    width += this.dW*(this.nCol - 1) + this.GapLeft + this.GapRight;

    var ascent = this.getAscent(oMeasure, height);

    this.size.width  = width;
    this.size.height = height;
    this.size.ascent = ascent;
};
CMathBase.prototype.ProcessingOldEquationConvert = function ()
{
	for (let i = 0; i < this.Content.length; i++)
	{
		this.Content[i].ProcessingOldEquationConvert();
	}
}
CMathBase.prototype.recalculateAllSize = function(textMeasurer)
{
	this.setDistance();
	
	for (let index = 0, count = this.Content.length; index < count; ++index)
	{
		this.Content[index].recalculateAllSize(textMeasurer);
	}
	
	for (let iRow = 0; iRow < this.nRow; ++iRow)
	{
		for (let iCol = 0; iCol < this.nCol; ++iCol)
		{
			let item = this.elements[iRow][iCol];
			if (item.IsJustDraw())
				this.MeasureJustDraw(item);
			else if (item.recalculateSize)
				item.recalculateSize(textMeasurer);
		}
	}
	
	this.recalculateSize(textMeasurer);
};
CMathBase.prototype.Resize = function(oMeasure, RPI)
{
    for(var i=0; i < this.nRow; i++)
        for(var j = 0; j < this.nCol; j++)
        {
            if(this.elements[i][j].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
                };

                g_oTextMeasurer.SetFont(Font);
            }

            this.elements[i][j].Resize(oMeasure, RPI);
        }


    this.recalculateSize(oMeasure, RPI);
};
CMathBase.prototype.Resize_2 = function(oMeasure, Parent, ParaMath, RPI, ArgSize)
{
    for(var i=0; i < this.nRow; i++)
        for(var j = 0; j < this.nCol; j++)
            if(!this.elements[i][j].IsJustDraw())
                this.elements[i][j].Resize_2(oMeasure, this, ParaMath, RPI, ArgSize);
};
CMathBase.prototype.Set_CompiledCtrPrp = function(Parent, ParaMath, RPI)
{
    if(this.RecalcInfo.bCtrPrp == true || (RPI !== null && RPI !== undefined && RPI.bRecalcCtrPrp == true))
    {
        if (undefined === ParaMath || null === ParaMath)
        {
            this.CompiledCtrPrp = new CTextPr();
            this.CompiledCtrPrp.InitDefault();
            return;
        }

        // Получим настройки текста, для данного параграфа
        this.CompiledCtrPrp = ParaMath.Paragraph.Get_CompiledPr2(false).TextPr.Copy();

        this.CompiledCtrPrp.Merge(ParaMath.Get_Default_TPrp());

        // Если в прямых настройках задан стиль, тогда смержим настройки стиля
        if ( undefined != this.CtrPrp.RStyle )
        {
            var Styles = ParaMath.Paragraph.Parent.Get_Styles();
            if (Styles instanceof AscWord.CStyles)
            {
                var StyleTextPr = Styles.Get_Pr( this.CtrPrp.RStyle, styletype_Character ).TextPr;
                this.CompiledCtrPrp.Merge(StyleTextPr);
            }
        }

        var defaultTxtPrp = ParaMath.Get_Default_TPrp();

        this.CompiledCtrPrp.FontFamily =
        {
            Name:       defaultTxtPrp.FontFamily.Name,
            Index:      defaultTxtPrp.FontFamily.Index
        };

        this.CompiledCtrPrp.Merge(this.CtrPrp);

        // for Control Letter

        var FontSize = ParaMath.GetFirstRPrp().FontSize;

        if(this.bInside == true)
        {
            var TxtPr = Parent.Get_TxtPrControlLetter(RPI); // чтобы применился ArgSize Parent

            FontSize = TxtPr.FontSize;
            FontSize *= MatGetKoeffArgSize(FontSize, this.ArgSize.value);
        }
        else
        {
            FontSize *= MatGetKoeffArgSize(FontSize, Parent.Get_CompiledArgSize().value);
            FontSize *= MatGetKoeffArgSize(FontSize, this.ArgSize.value);
        }

        this.TextPrControlLetter.FontSize = FontSize;
        this.TextPrControlLetter.FontFamily =
        {
            Name:       defaultTxtPrp.FontFamily.Name,
            Index:      defaultTxtPrp.FontFamily.Index
        }; // Cambria Math


        this.RecalcInfo.bCtrPrp = false;
    }
};
CMathBase.prototype.getAscent = function(oMeasure, _height)
{
    var Ascent = 0;
    if(this.nRow > 1)
    {
        Ascent = _height;
        Ascent /=2;
        var MergedCtrPrp = this.Get_CompiledCtrPrp();
        Ascent += this.ParaMath.GetShiftCenter(oMeasure, MergedCtrPrp);
    }
    else
        for(var i=0; i< this.nCol; i++)
            Ascent = (this.elements[0][i].size.ascent > Ascent) ?  this.elements[0][i].size.ascent : Ascent;

    return Ascent;
};
CMathBase.prototype.alignHor = function(pos, coeff)
{
    if(pos!=-1)
        this.alignment.wdt[pos] = coeff;
    else
        for(var j = 0; j< this.alignment.wdt.length; j++)
            this.alignment.wdt[j] = coeff;

}
CMathBase.prototype.alignVer = function(pos, coeff)
{
    if(pos!=-1)
        this.alignment.hgt[pos] = coeff;
    else
        for(var j = 0; j < this.alignment.hgt.length; j++)
            this.alignment.hgt[j] = coeff;
};
CMathBase.prototype.setDistance = function()
{

};
CMathBase.prototype.hidePlaceholder = function(flag)
{
    for(var i=0; i < this.nRow; i++)
        for(var j = 0; j < this.nCol; j++)
        {
            if( this.elements[i][j].IsJustDraw() == false )
                this.elements[i][j].hidePlaceholder(flag);
        }
};
CMathBase.prototype.getElement = function(x, y)
{
    return this.elements[x][y];
};
CMathBase.prototype.IsOneLineText = function() // for degree
{
    var bOneLineText = true;
    if(this.nRow == 1)
    {
        for(var j = 0; j < this.nCol; j++)
        {
            if(!this.elements[0][j].IsJustDraw() && !this.elements[0][j].IsOneLineText())
            {
                bOneLineText = false;
                break;
            }
        }
    }
    else
        bOneLineText = false;


    return bOneLineText;
};
////    For Edit   /////
CMathBase.prototype.getGapsInside = function(GapsInfo)
{
    var kind = this.kind;
    var gaps = {left: 0, right: 0};
    var checkBase = kind == MATH_DEGREE || kind == MATH_DEGREESubSup || kind == MATH_ACCENT || kind == MATH_RADICAL || kind == MATH_LIMIT || kind == MATH_BORDER_BOX;

    if(checkBase)
    {
        var base = this.getBase();
        gaps = base.getGapsInside(GapsInfo);
    }

    return gaps;
};
CMathBase.prototype.SetGaps = function(GapsInfo)
{
    //this.Parent   = GapsInfo.Parent;
    //this.ParaMath = GapsInfo.ParaMath;

    GapsInfo.Left       = GapsInfo.Current;
    GapsInfo.leftRunPrp = GapsInfo.currRunPrp;


    GapsInfo.Current    = this;
    GapsInfo.currRunPrp = this.Get_CompiledCtrPrp();

    GapsInfo.setGaps();

};
CMathBase.prototype.Is_EmptyGaps = function()
{
    return false;
};
//////////////////////////////////
CMathBase.prototype.IsPlaceholder = function()
{
    return false;
};
CMathBase.prototype.IsMathText = function()
{
    return false;
};
CMathBase.prototype.GetParent = function()
{
    return (this.Parent ? (this.Parent.Type !== para_Math_Composition ? this.Parent : this.Parent.GetParent()) : null);
};
CMathBase.prototype.Get_TextPr = function(ContentPos, Depth)
{
    var pos = ContentPos.Get(Depth);

    return this.Content[pos].Get_TextPr(ContentPos, Depth+1);
};
CMathBase.prototype.Get_CompiledTextPr  = function(Copy)
{
	var TextPr = null;

	var nStartPos = 0;
	var nCount = this.Content.length;
	while (null === TextPr && nStartPos < nCount)
	{
		if (this.Is_ContentUse(this.Content[nStartPos]))
			TextPr = this.Content[nStartPos].Get_CompiledTextPr(true, true);

		nStartPos++;
	}

	for (var nPos = nStartPos; nPos < nCount; ++nPos)
	{
		var CurTextPr = this.Content[nPos].Get_CompiledTextPr(false, true);

		if (null !== CurTextPr)
			TextPr = TextPr.Compare(CurTextPr);
	}

	return TextPr;
};
CMathBase.prototype.Get_CompiledPr = function(Copy)
{
    return this.Get_CompiledTextPr(Copy);
};
CMathBase.prototype.Apply_TextPr = function(TextPr, IncFontSize, ApplyToAll)
{
	this.Apply_TextPrToCtrPr(TextPr, IncFontSize, ApplyToAll);

	for (var nIndex = 0; nIndex < this.Content.length; ++nIndex)
	{
		this.Content[nIndex].Apply_TextPr(TextPr, IncFontSize, ApplyToAll);
	}
};
CMathBase.prototype.Apply_TextPrToCtrPr = function(TextPr, IncFontSize, ApplyToAll)
{
	if (true === ApplyToAll)
		this.RecalcInfo.bCtrPrp = true;

	if (!TextPr)
	{
		var CtrPrp = this.Get_CompiledCtrPrp_2();
		this.Set_FontSizeCtrPrp(CtrPrp.GetIncDecFontSize(IncFontSize));
	}
	else
	{
		if (undefined !== TextPr.Bold)
			this.SetBold(null === TextPr.Bold ? undefined : TextPr.Bold);

		if (undefined !== TextPr.Italic)
			this.SetItalic(null === TextPr.Italic ? undefined : TextPr.Italic);

		if (TextPr.AscFill || TextPr.AscLine || TextPr.AscUnifill)
		{
			var oCompiledPr = this.Get_CompiledCtrPrp();
			if (TextPr.AscFill)
			{
				this.Set_TextFill(AscFormat.CorrectUniFill(TextPr.AscFill, oCompiledPr.TextFill, 1));
			}
			if (TextPr.AscUnifill)
			{
				this.Set_Unifill(AscFormat.CorrectUniFill(TextPr.AscUnifill, oCompiledPr.Unifill, 0));
			}
			if (TextPr.AscLine)
			{
				this.Set_TextOutline(AscFormat.CorrectUniStroke(TextPr.AscLine, oCompiledPr.TextOutline, 0));
			}
			return;
		}

		if (undefined !== TextPr.FontSize)
			this.Set_FontSizeCtrPrp(null === TextPr.FontSize ? undefined : TextPr.FontSize);

		if (undefined !== TextPr.Shd)
			this.Set_Shd(null === TextPr.Shd ? undefined : TextPr.Shd);

		if (undefined !== TextPr.Color)
		{
			this.Set_Color(TextPr.Color);

			if(null !== TextPr.Color)
			{
				if (this.CtrPrp.Unifill)
					this.Set_Unifill(undefined);

				if (this.CtrPrp.TextFill)
					this.Set_TextFill(undefined);
			}
		}

		if (undefined !== TextPr.Unifill)
		{
			this.Set_Unifill(null === TextPr.Unifill ? undefined : TextPr.Unifill.createDuplicate());

			if (null !== TextPr.Unifill)
			{
				if (this.CtrPrp.Color)
					this.Set_Color(undefined);

				if (this.CtrPrp.TextFill)
					this.Set_TextFill(undefined);
			}
		}

		if (undefined !== TextPr.TextOutline)
			this.Set_TextOutline(null === TextPr.TextOutline ? undefined : TextPr.TextOutline);

		if (undefined !== TextPr.TextFill)
		{
			this.Set_TextFill(null === TextPr.TextFill ? undefined : TextPr.TextFill);

			if (null !== TextPr.TextFill)
			{
				if (this.CtrPrp.Color)
					this.Set_Color(undefined);

				if (this.CtrPrp.Unifill)
					this.Set_Unifill(undefined);
			}
		}

		if (undefined !== TextPr.HighLight)
			this.Set_HighLight(null === TextPr.HighLight ? undefined : TextPr.HighLight);
		if (undefined !== TextPr.HighlightColor)
			this.SetHighlightColor(null === TextPr.HighlightColor ? undefined : TextPr.HighlightColor);

		if (undefined !== TextPr.Underline)
			this.SetUnderline(null === TextPr.Underline ? undefined : TextPr.Underline);

		if (undefined !== TextPr.Strikeout)
			this.SetStrikeout(null === TextPr.Strikeout ? undefined : TextPr.Strikeout);

		if (undefined !== TextPr.DStrikeout)
			this.SetDoubleStrikeout(null === TextPr.DStrikeout ? undefined : TextPr.DStrikeout);

		if (undefined !== TextPr.RFonts)
		{
			var RFonts = new CRFonts();
			RFonts.SetAll("Cambria Math", -1);

			this.raw_SetRFonts(RFonts);
		}
	}
};
CMathBase.prototype.GetMathTextPrForMenu = function(ContentPos, Depth)
{
    var pos = ContentPos.Get(Depth);

    return this.Content[pos].GetMathTextPrForMenu(ContentPos, Depth+1);
};
CMathBase.prototype.Set_MathTextPr2 = function(TextPr, MathPr, bAll)
{
    this.Set_FontSizeCtrPrp(TextPr.FontSize);

    for(var i = 0; i < this.Content.length; i++)
        this.Content[i].Set_MathTextPr2(TextPr, MathPr, bAll);
};
CMathBase.prototype.Set_FontSizeCtrPrp = function(Value)
{
	if (null === Value)
		Value = undefined;

	if (Value !== this.CtrPrp.FontSize)
	{
		AscCommon.History.Add(new CChangesMathBaseFontSize(this, this.CtrPrp.FontSize, Value));
		this.raw_SetFontSize(Value);
	}
};
CMathBase.prototype.Set_Color = function(Value)
{
	if (null === Value)
		Value = undefined;

	if ((undefined === Value && undefined !== this.CtrPrp.Color) || (Value instanceof CDocumentColor && (undefined === this.CtrPrp.Color || false === Value.Compare(this.CtrPrp.Color))))
	{
		AscCommon.History.Add(new CChangesMathBaseColor(this, this.CtrPrp.Color, Value));
		this.raw_SetColor(Value);
	}
};
CMathBase.prototype.Set_Unifill = function(Value)
{
	if (null === Value)
		Value = undefined;

	if ((undefined === Value && undefined !== this.CtrPrp.Unifill) || (Value instanceof AscFormat.CUniFill && (undefined === this.CtrPrp.Unifill || false === AscFormat.CompareUnifillBool(this.CtrPrp.Unifill, Value))))
	{
		AscCommon.History.Add(new CChangesMathBaseUnifill(this, this.CtrPrp.Unifill, Value));
		this.raw_SetUnifill(Value);
	}
};
CMathBase.prototype.Set_TextFill = function(Value)
{
	if (null === Value)
		Value = undefined;

	if ((undefined === Value && undefined !== this.CtrPrp.TextFill) || (Value instanceof AscFormat.CUniFill && (undefined === this.CtrPrp.TextFill || false === AscFormat.CompareUnifillBool(this.CtrPrp.TextFill, Value))))
	{
		AscCommon.History.Add(new CChangesMathBaseTextFill(this, this.CtrPrp.TextFill, Value));
		this.raw_SetTextFill(Value);
	}
};
CMathBase.prototype.Set_TextOutline = function(Value)
{
	if (null === Value)
		Value = undefined;

	if ((undefined === Value && undefined !== this.CtrPrp.TextOutline) || (Value instanceof AscFormat.CLn && (undefined === this.CtrPrp.TextOutline || false === Value.IsIdentical(this.CtrPrp.TextOutline))))
	{
		AscCommon.History.Add(new CChangesMathBaseTextOutline(this, this.CtrPrp.TextOutline, Value));
		this.raw_SetTextOutline(Value);
	}
};
CMathBase.prototype.Set_HighLight = function(Value)
{
	if (null === Value)
		Value = undefined;

	var OldValue = this.CtrPrp.HighLight;
	if ((undefined === Value && undefined !== OldValue) || (highlight_None === Value && highlight_None !== OldValue) || (Value instanceof CDocumentColor && (undefined === OldValue || highlight_None === OldValue || false === Value.Compare(OldValue))))
	{
		AscCommon.History.Add(new CChangesMathBaseHighLight(this, this.CtrPrp.HighLight, Value));
		this.raw_SetHighLight(Value);
	}
};
CMathBase.prototype.SetHighlightColor = function(Value)
{
	if (null === Value)
		Value = undefined;

	var OldValue = this.CtrPrp.HighlightColor;
	if (OldValue && !OldValue.IsIdentical(Value) || Value && !Value.IsIdentical(OldValue))
	{
		AscCommon.History.Add(new CChangesMathBaseHighlightColor(this, OldValue, Value));
		this.raw_SetHighlightColor(Value);
	}
};
CMathBase.prototype.Set_Shd = function(Shd)
{
	if (null === Shd)
		Shd = undefined;

	if (!(undefined === this.CtrPrp.Shd && undefined === Shd) && !(undefined !== this.CtrPrp.Shd && undefined !== Shd && true === this.CtrPrp.Shd.Compare(Shd)))
	{
		AscCommon.History.Add(new CChangesMathBaseShd(this, this.CtrPrp.Shd, Shd));
		this.raw_SetShd(Shd);
	}
};
CMathBase.prototype.SetUnderline = function(Value)
{
	if (null === Value)
		Value = undefined;

	if (Value !== this.CtrPrp.Underline)
	{
		AscCommon.History.Add(new CChangesMathBaseUnderline(this, this.CtrPrp.Underline, Value));
		this.raw_SetUnderline(Value);
	}
};
CMathBase.prototype.SetStrikeout = function(Value)
{
	if (null === Value)
		Value = undefined;

	if (Value !== this.CtrPrp.Strikeout)
	{
		AscCommon.History.Add(new CChangesMathBaseStrikeout(this, this.CtrPrp.Strikeout, Value));
		this.raw_SetStrikeout(Value);
	}
};
CMathBase.prototype.SetDoubleStrikeout = function(Value)
{
	if (null === Value)
		Value = undefined;

	if (Value !== this.CtrPrp.DStrikeout)
	{
		AscCommon.History.Add(new CChangesMathBaseDoubleStrikeout(this, this.CtrPrp.DStrikeout, Value));
		this.raw_Set_DoubleStrikeout(Value);
	}
};
CMathBase.prototype.SetBold = function(Value)
{
	if (null === Value)
		Value = undefined;

	if (Value !== this.CtrPrp.Bold)
	{
		AscCommon.History.Add(new CChangesMathBaseBold(this, this.CtrPrp.Bold, Value));
		this.raw_SetBold(Value);
	}
};
CMathBase.prototype.SetItalic = function(Value)
{
	if (null === Value)
		Value = undefined;

	if (Value !== this.CtrPrp.Italic)
	{
		AscCommon.History.Add(new CChangesMathBaseItalic(this, this.CtrPrp.Italic, Value));
		this.raw_SetItalic(Value);
	}
};
CMathBase.prototype.SetRFontsAscii = function(Value)
{
	if (null === Value)
		Value = undefined;

	if (this.CtrPrp.RFonts.Ascii !== Value)
	{
		AscCommon.History.Add(new CChangesMathBaseRFontsAscii(this, this.CtrPrp.RFonts.Ascii, Value));
		this.raw_SetRFontsAscii(Value);
	}
};
CMathBase.prototype.SetRFontsHAnsi = function(Value)
{
	if (null === Value)
		Value = undefined;

	if (this.CtrPrp.RFonts.HAnsi !== Value)
	{
		AscCommon.History.Add(new CChangesMathBaseRFontsHAnsi(this, this.CtrPrp.RFonts.HAnsi, Value));
		this.raw_SetRFontsHAnsi(Value);
	}
};
CMathBase.prototype.SetRFontsCS = function(Value)
{
	if (null === Value)
		Value = undefined;

	if (this.CtrPrp.RFonts.CS !== Value)
	{
		AscCommon.History.Add(new CChangesMathBaseRFontsCS(this, this.CtrPrp.RFonts.CS, Value));
		this.raw_SetRFontsCS(Value);
	}
};
CMathBase.prototype.SetRFontsEastAsia = function(Value)
{
	if (null === Value)
		Value = undefined;

	if (this.CtrPrp.RFonts.EastAsia !== Value)
	{
		AscCommon.History.Add(new CChangesMathBaseRFontsEastAsia(this, this.CtrPrp.RFonts.EastAsia, Value));
		this.raw_SetRFontsEastAsia(Value);
	}
};
CMathBase.prototype.SetRFontsHint = function(Value)
{
	if (null === Value)
		Value = undefined;

	if (this.CtrPrp.RFonts.Hint !== Value)
	{
		AscCommon.History.Add(new CChangesMathBaseRFontsHint(this, this.CtrPrp.RFonts.Hint, Value));
		this.raw_SetRFontsHint(Value);
	}
};
CMathBase.prototype.raw_SetBold = function(Value)
{
    this.CtrPrp.Bold = Value;
    this.NeedUpdate_CtrPrp();
};
CMathBase.prototype.raw_SetItalic = function(Value)
{
    this.CtrPrp.Italic = Value;
    this.NeedUpdate_CtrPrp();
};
CMathBase.prototype.raw_SetUnderline  = function(Value)
{
    this.CtrPrp.Underline = Value;
    this.NeedUpdate_CtrPrp();

};
CMathBase.prototype.raw_SetStrikeout = function(Value)
{
    this.CtrPrp.Strikeout = Value;
    this.NeedUpdate_CtrPrp();
};
CMathBase.prototype.raw_Set_DoubleStrikeout = function(Value)
{
    this.CtrPrp.DStrikeout = Value;
    this.NeedUpdate_CtrPrp();

};
CMathBase.prototype.raw_SetFontSize  = function(Value)
{
    this.CtrPrp.FontSize    = Value;
    this.NeedUpdate_CtrPrp();
};
CMathBase.prototype.raw_SetShd = function(Shd)
{
    if ( undefined !== Shd )
    {
        this.CtrPrp.Shd = new CDocumentShd();
        this.CtrPrp.Shd.Set_FromObject( Shd );
    }
    else
        this.CtrPrp.Shd = undefined;

    this.NeedUpdate_CtrPrp();
};
CMathBase.prototype.raw_SetColor = function(Value)
{
    this.CtrPrp.Color = Value;
    this.NeedUpdate_CtrPrp();
};
CMathBase.prototype.raw_SetUnifill = function(Value)
{
    this.CtrPrp.Unifill = Value;
    this.NeedUpdate_CtrPrp();
};
CMathBase.prototype.raw_SetTextFill = function(Value)
{
    this.CtrPrp.TextFill = Value;
    this.NeedUpdate_CtrPrp();
};
CMathBase.prototype.raw_SetTextOutline = function(Value)
{
    this.CtrPrp.TextOutline = Value;
    this.NeedUpdate_CtrPrp();
};
CMathBase.prototype.raw_SetHighLight = function(Value)
{
    this.CtrPrp.HighLight = Value;
    this.NeedUpdate_CtrPrp();
};
CMathBase.prototype.raw_SetHighlightColor = function(Value)
{
    this.CtrPrp.HighlightColor = Value;
    this.NeedUpdate_CtrPrp();
};
CMathBase.prototype.raw_SetRFonts = function(RFonts)
{
	if (RFonts)
	{
		if (undefined !== RFonts.Ascii)
			this.SetRFontsAscii(RFonts.Ascii);

		if (undefined !== RFonts.HAnsi)
			this.SetRFontsHAnsi(RFonts.HAnsi);

		if (undefined !== RFonts.CS)
			this.SetRFontsCS(RFonts.CS);

		if (undefined !== RFonts.EastAsia)
			this.SetRFontsEastAsia(RFonts.EastAsia);

		if (undefined !== RFonts.Hint)
			this.SetRFontsHint(RFonts.Hint);
	}
	else
	{
		this.SetRFontsAscii(undefined);
		this.SetRFontsHAnsi(undefined);
		this.SetRFontsCS(undefined);
		this.SetRFontsEastAsia(undefined);
		this.SetRFontsHint(undefined);
	}
};
CMathBase.prototype.raw_SetRFontsAscii = function(Value)
{
    this.CtrPrp.RFonts.Ascii = Value;
    this.NeedUpdate_CtrPrp();
};
CMathBase.prototype.raw_SetRFontsHAnsi = function(Value)
{
    this.CtrPrp.RFonts.HAnsi = Value;
    this.NeedUpdate_CtrPrp();
};
CMathBase.prototype.raw_SetRFontsCS = function(Value)
{
    this.CtrPrp.RFonts.CS = Value;
    this.NeedUpdate_CtrPrp();
};
CMathBase.prototype.raw_SetRFontsEastAsia = function(Value)
{
    this.CtrPrp.RFonts.EastAsia = Value;
    this.NeedUpdate_CtrPrp();
};
CMathBase.prototype.raw_SetRFontsHint = function(Value)
{
    this.CtrPrp.RFonts.Hint = Value;
    this.NeedUpdate_CtrPrp();
};
CMathBase.prototype.NeedUpdate_CtrPrp = function()
{
    this.RecalcInfo.bCtrPrp = true;
};
CMathBase.prototype.SelectToParent = function(bCorrect)
{
    this.bSelectionUse = true;
    this.Parent.SelectToParent(bCorrect);
};
CMathBase.prototype.Get_StartRangePos = function(_CurLine, _CurRange, SearchPos, Depth, bStartPos)
{
    var Pos = bStartPos == true ? this.NumBreakContent : this.CurPos;

    var Result = this.Content[Pos].Get_StartRangePos(_CurLine, _CurRange, SearchPos, Depth+1, bStartPos);

    if ( true === Result )
        SearchPos.Pos.Update(Pos, Depth );

    return Result;

};
CMathBase.prototype.Get_EndRangePos = function(_CurLine, _CurRange, SearchPos, Depth, bEndPos)
{
    var Pos = bEndPos == true ? this.NumBreakContent : this.CurPos;

    var Result = this.Content[Pos].Get_EndRangePos(_CurLine, _CurRange, SearchPos, Depth+1, bEndPos);

    if ( true === Result )
        SearchPos.Pos.Update( Pos, Depth );

    return Result;

};
CMathBase.prototype.Recalculate_Range_Spaces = function(PRSA, _CurLine, _CurRange, _CurPage)
{
    var CurLine  = _CurLine - this.StartLine;
    var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );

    var WidthVisible;

    if ( 0 !== PRSA.LettersSkip )
    {
        WidthVisible = this.Bounds.GetWidth(CurLine, CurRange);
        PRSA.LettersSkip--;
    }
    else
    {
        WidthVisible = this.Bounds.GetWidth(CurLine, CurRange) + PRSA.JustifyWord;
    }

    PRSA.X    += WidthVisible;
    PRSA.LastW = WidthVisible;
};
CMathBase.prototype.GetWidth = function(_CurLine, _CurRange)
{
    var CurLine  = _CurLine - this.StartLine,
        CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );

    return this.Bounds.GetWidth(CurLine, CurRange);
};
CMathBase.prototype.SaveRecalculateObject = function(Copy)
{
    var RecalcObj;
    if(this.bOneLine)
    {
        RecalcObj = new CEmptyRunRecalculateObject(this.StartLine, this.StartRange);
    }
    else
    {

        var Num = this.NumBreakContent;

        RecalcObj = new CRunRecalculateObject(this.StartLine, this.StartRange);
        RecalcObj.Save_Lines( this, Copy );

        for(var Pos = 0; Pos < this.Content.length; Pos++)
        {
            if(Pos == Num)
            {
                RecalcObj.Content[Pos] = this.Content[Pos].SaveRecalculateObject(Copy);
            }
            else
            {
                RecalcObj.Content[Pos] = new CEmptyRunRecalculateObject(this.StartLine, this.StartRange);
            }
        }
    }

    return RecalcObj;
};
CMathBase.prototype.LoadRecalculateObject = function(RecalcObj)
{
	if (this.bOneLine == false)
		CParagraphContentWithParagraphLikeContent.prototype.LoadRecalculateObject.call(this, RecalcObj);

};
CMathBase.prototype.Fill_LogicalContent = function(nCount, opt_content)
{
    if (!opt_content) {
        opt_content = [];
    }
    for (var nIndex = 0; nIndex < nCount; nIndex++)
    {
        let elem = opt_content[nIndex];
        if (!elem) {
            elem = new CMathContent();
        }
        this.Content[nIndex] = elem;
        this.Content[nIndex].ParentElement = this;
        this.Content[nIndex].Parent        = this;
    }
};
CMathBase.prototype.Copy = function(Selected, oPr)
{
    var oProps = this.Pr.Copy();
    oProps.ctrPrp = this.CtrPrp.Copy();

    var NewElement = new this.constructor(oProps);

    for (var nIndex = 0, nCount = this.Content.length; nIndex < nCount; nIndex++)
    {
        this.Content[nIndex].CopyTo(NewElement.Content[nIndex], false, oPr);
    }
    if(oPr && oPr.Comparison)
    {
			oPr.Comparison.checkReviewInfoOfCopiedElements(NewElement, this);
    }
    return NewElement;
};
CMathBase.prototype.Refresh_RecalcData = function(Data)
{
    if(this.ParaMath !== null)
        this.ParaMath.Refresh_RecalcData(); // Refresh_RecalcData сообщает родительскому классу, что у него произошли изменения, нужно пересчитать
};
CMathBase.prototype.Write_ToBinary2 = function( Writer )
{
    Writer.WriteLong(this.ClassType);

    // String           : Id
    // Long             : Content.length
    // Array of Strings : Content[Index].Id
    // Variable         : Pr
    // Variable(CTextPr): CtrPrp
    // Long             : ReviewType
    // Bool             : undefined == ReviewInfo
    // if false         : ReviewInfo

    Writer.WriteString2(this.Id);

    var nCount = this.Content.length;
    Writer.WriteLong(nCount);
    for (var nIndex = 0; nIndex < nCount; nIndex++)
    {
        Writer.WriteString2(this.Content[nIndex].Id);
    }

    this.Pr.Write_ToBinary(Writer);
    this.CtrPrp.Write_ToBinary(Writer);
    Writer.WriteLong(this.ReviewType);

    if (undefined !== this.ReviewInfo)
    {
        Writer.WriteBool(false);
        this.ReviewInfo.Write_ToBinary(Writer);
    }
    else
    {
        Writer.WriteBool(true);
    }
};
CMathBase.prototype.Read_FromBinary2 = function( Reader )
{
    // String           : Id
    // Long             : Content.length
    // Array of Strings : Content[Index].Id
    // Variable         : Pr
    // Variable(CTextPr): CtrPrp
    // Long             : ReviewType
    // Bool             : undefined == ReviewInfo
    // if false         : ReviewInfo


    this.Id = Reader.GetString2();

    var nCount = Reader.GetLong();
    this.Content = [];
    for (var nIndex = 0; nIndex < nCount; nIndex++)
    {
        this.Content[nIndex] = AscCommon.g_oTableId.Get_ById(Reader.GetString2());
        this.Content[nIndex].ParentElement = this;
        this.Content[nIndex].Parent        = this;
    }

    this.Pr.Read_FromBinary(Reader);
    this.CtrPrp.Read_FromBinary(Reader);

    this.ReviewType = Reader.GetLong();
    if (true === Reader.GetBool())
    {
        this.ReviewInfo = undefined;
    }
    else
    {
        this.ReviewInfo = new AscWord.ReviewInfo();
        this.ReviewInfo.Read_FromBinary(Reader);
    }

    this.fillContent();
};
CMathBase.prototype.Get_Id = function()
{
    return this.Id;
};
CMathBase.prototype.getPropsForWrite = function()
{
    return this.Pr;
};
CMathBase.prototype.setProperties = function(oProps)
{
    this.Pr.Set_FromObject(oProps);
    this.setCtrPrp(oProps.ctrPrp);

    this.RecalcInfo.bProps = true;
}
CMathBase.prototype.Correct_Content = function(bInnerCorrection)
{
    var nCount = this.Content.length;
    for (var nIndex = 0; nIndex < nCount; nIndex++)
    {
        this.Content[nIndex].Correct_Content(bInnerCorrection);
    }

    if (this.CurPos >= this.Content.length)
    	this.CurPos = this.Content.length - 1;

    if (this.CurPos < 0)
    	this.CurPos = 0;
};
CMathBase.prototype.Undo = function(Data)
{
    Data.Undo(this);
};
CMathBase.prototype.Redo = function(Data)
{
    Data.Redo(this);
};
CMathBase.prototype.Get_AllFontNames = function(AllFonts)
{
    this.CtrPrp.Document_Get_AllFontNames(AllFonts);

    for (var nIndex = 0, nCount = this.Content.length; nIndex < nCount; nIndex++)
    {
        this.Content[nIndex].Get_AllFontNames(AllFonts);
    }
};
CMathBase.prototype.Create_FontMap = function(Map)
{
    if (null === this.ParaMath)
        return;

    var CtrPrp = this.Get_CompiledCtrPrp();
    CtrPrp.Document_CreateFontMap(Map, this.ParaMath.Paragraph.Get_Theme().themeElements.fontScheme);

    for (var nIndex = 0, nCount = this.Content.length; nIndex < nCount; nIndex++)
        this.Content[nIndex].Create_FontMap(Map);
};
CMathBase.prototype.recalculateCursorPosition = function(positionCalculator, isCurrent)
{
	if (isCurrent)
		this.Content[this.CurPos].recalculateCursorPosition(positionCalculator, true);
	else
		positionCalculator.handleMathElement(this);
};
CMathBase.prototype.getParagraphContentPosByXY = function(searchState)
{
	searchState.handleMathBase(this);
};
CMathBase.prototype.Get_ParaContentPos = function(bSelection, bStart, ContentPos, bUseCorrection)
{
    var nPos = (true !== bSelection ? this.CurPos : (false !== bStart ? this.Selection.StartPos : this.Selection.EndPos));
    ContentPos.Add(nPos);

    if (undefined !== this.Content[nPos])
        this.Content[nPos].Get_ParaContentPos(bSelection, bStart, ContentPos, bUseCorrection);
};
CMathBase.prototype.Set_ParaContentPos = function(ContentPos, Depth)
{
    var CurPos = ContentPos.Get(Depth);

    if (undefined === CurPos || this.CurPos < 0)
    {
        this.CurPos = 0;
        this.Content[this.CurPos].MoveCursorToStartPos();
    }
    else if (CurPos > this.Content.length - 1)
    {
        this.CurPos = this.Content.length - 1;
        this.Content[this.CurPos].MoveCursorToEndPos(false);
    }
    else
    {
        this.CurPos = CurPos;
        this.Content[this.CurPos].Set_ParaContentPos(ContentPos, Depth + 1);
    }
};
CMathBase.prototype.drawSelectionInRange = function(line, range, drawSelectionState)
{
	let selectionStart = this.Selection.StartPos;
	let selectionEnd   = this.Selection.EndPos;
	
	let isSelected = this.Selection.Use;
	if (isSelected && !this.bOneLine)
	{
		let rangeInfo  = this.getRangePos(line, range);
		let rangeStart = rangeInfo[0];
		let rangeEnd   = rangeInfo[1];
		
		isSelected = selectionStart >= rangeStart && selectionEnd <= rangeEnd;
	}
	
	if (isSelected && selectionStart === selectionEnd)
	{
		let item   = this.Content[this.Selection.StartPos];
		let bounds = item.Get_LineBound(line, range);
		
		drawSelectionState.x = bounds.X;
		item.drawSelectionInRange(line, range, drawSelectionState);
	}
	else
	{
		drawSelectionState.handleMathElement(this, isSelected);
	}
};
/**
 * Get first find parent typeof CMathContent or MathBase
 * @return {*}
 */
CMathBase.prototype.GetMathBaseFirst = function()
{
	return this;
};
CMathBase.prototype.IsSelectionEmpty = function()
{
    if (true !== this.Selection.Use)
        return true;

    if (this.Selection.StartPos === this.Selection.EndPos)
        return this.Content[this.Selection.StartPos].IsSelectionEmpty();

    return false;
};
CMathBase.prototype.GetSelectContent = function()
{
    var nPos = (true === this.Selection.Use ? this.Selection.StartPos : this.CurPos);
    return this.Content[nPos].GetSelectContent();
};
CMathBase.prototype.Is_InnerSelection = function()
{
    if (true === this.Selection.Use && this.Selection.StartPos === this.Selection.EndPos)
        return true;

    return false;
};
CMathBase.prototype.Select_WholeElement = function()
{
    if (null !== this.Parent)
        this.Parent.Select_Element(this, true);
};
CMathBase.prototype.Select_MathContent = function(MathContent)
{
    for (var nPos = 0, nCount = this.Content.length; nPos < nCount; nPos++)
    {
        if (this.Content[nPos] === MathContent)
        {
            if (null !== this.Parent)
            {
                this.Selection.Use      = true;
                this.Selection.StartPos = nPos;
                this.Selection.EndPos   = nPos;
                this.Parent.Select_Element(this, false);
            }
            break;
        }
    }
};
CMathBase.prototype.SetCurrentMathContent = function(oMathContent)
{
	for (let nPos = 0, nCount = this.Content.length; nPos < nCount; ++nPos)
	{
		if (this.Content[nPos] === oMathContent)
		{
			this.CurPos = nPos;

			if (null !== this.Parent)
				this.Parent.SetCurrentElement(this);

			break;
		}
	}
};
CMathBase.prototype.Draw_HighLights = function(drawState, bAll)
{
	drawState.handleMathBase(this);
};
CMathBase.prototype.Draw_Lines = function(PDSL)
{
	var CtrPrp		= this.Get_CompiledCtrPrp(false);

	var aStrikeout	= PDSL.Strikeout;
	var aDStrikeout	= PDSL.DStrikeout;

	var ReviewType	= this.GetReviewType();
	var bAddReview	= reviewtype_Add === ReviewType ? true : false;
	var bRemReview	= reviewtype_Remove === ReviewType ? true : false;
	var ReviewColor	= null;

	if (bAddReview || bRemReview)
		ReviewColor	= this.ReviewInfo.Get_Color();

	var ArgSize		= this.Get_CompiledArgSize();
	var fontCoeff	= MatGetKoeffArgSize(CtrPrp.FontSize, ArgSize.value);

	// вычисляем координату Y и LineW также как в Run
	var X			= PDSL.X;
	var Y			= PDSL.Baseline - CtrPrp.FontSize * fontCoeff * g_dKoef_pt_to_mm * 0.27;
	var LineW		= (CtrPrp.FontSize / 18) * g_dKoef_pt_to_mm;
	var Para		= PDSL.Paragraph;

	// set aStrikeout && aDStrikeout
	if (true === bRemReview || true === CtrPrp.Strikeout)
		aStrikeout.set(Y, LineW);
	else if (true === CtrPrp.DStrikeout)
		aDStrikeout.set(Y, LineW);

	var BgColor = PDSL.BgColor;
	if (CtrPrp.Shd && !CtrPrp.Shd.IsNil())
		BgColor = CtrPrp.Shd.GetSimpleColor(Para.GetTheme(), Para.GetColorMap());

	var AutoColor = ( undefined != BgColor && false === BgColor.Check_BlackAutoColor() )
		? new CDocumentColor( 255, 255, 255, false)
		: new CDocumentColor( 0, 0, 0, false );

	var CurColor,
		RGBA,
		Theme		= this.Paragraph.Get_Theme(),
		ColorMap	= this.Paragraph.Get_ColorMap();

	// Выставляем цвет обводки
	if ( true === PDSL.VisitedHyperlink && ( undefined === this.Pr.Color && undefined === this.Pr.Unifill ) )
		CurColor = new CDocumentColor( 128, 0, 151 );
	else if ( true === CtrPrp.Color.Auto && !CtrPrp.Unifill)
		CurColor = new CDocumentColor( AutoColor.r, AutoColor.g, AutoColor.b );
	else
	{
		if(CtrPrp.Unifill)
		{
			CtrPrp.Unifill.check(Theme, ColorMap);
			RGBA = CtrPrp.Unifill.getRGBAColor();
			CurColor = new CDocumentColor( RGBA.R, RGBA.G, RGBA.B );
		}
		else
		{
			CurColor = new CDocumentColor( CtrPrp.Color.r, CtrPrp.Color.g, CtrPrp.Color.b );
		}
	}

	var CurLine		= PDSL.Line - this.StartLine;
	var CurRange	= ( 0 === CurLine ? PDSL.Range - this.StartRange : PDSL.Range );
	var Bound		= this.Bounds.Get_LineBound(CurLine, CurRange);

	if ( true === bRemReview )
		aStrikeout.Add( X, X + Bound.W, CurColor );
	else if ( true === CtrPrp.DStrikeout )
		aDStrikeout.Add( X, X + Bound.W, CurColor );
	else if ( true === CtrPrp.Strikeout )
		aStrikeout.Add( X, X + Bound.W, CurColor );

	this.Draw_LinesForContent(PDSL);

	PDSL.X = Bound.X + Bound.W;
};
CMathBase.prototype.Draw_LinesForContent = function(PDSL)
{
    var CurLine  = PDSL.Line - this.StartLine;
    var CurRange = ( 0 === CurLine ? PDSL.Range - this.StartRange : PDSL.Range );
    
    var StartPos, EndPos;

    if(this.bOneLine)
    {
        StartPos = 0;
        EndPos   = this.Content.length - 1;
    }
    else
    {
        StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
        EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);
    }

    for ( var CurPos = StartPos; CurPos <= EndPos; CurPos++ )
        this.Content[CurPos].Draw_Lines(PDSL);
};
CMathBase.prototype.Make_ShdColor = function(PDSE, CurTextPr)
{
    var Para      = PDSE.Paragraph;
    var pGraphics = PDSE.Graphics;
    var BgColor   = PDSE.BgColor;

    if ( undefined !== CurTextPr.Shd && Asc.c_oAscShdNil !== CurTextPr.Shd.Value )
        BgColor = CurTextPr.Shd.Get_Color( Para );

    var AutoColor = ( undefined != BgColor && false === BgColor.Check_BlackAutoColor() ? new CDocumentColor( 255, 255, 255, false ) : new CDocumentColor( 0, 0, 0, false ) );

    var RGBA;

    if(CurTextPr.FontRef && CurTextPr.FontRef.Color)
    {
        CurTextPr.FontRef.Color.check(PDSE.Theme, PDSE.ColorMap);
        RGBA = CurTextPr.FontRef.Color.RGBA;
        AutoColor = new CDocumentColor( RGBA.R, RGBA.G, RGBA.B, RGBA.A );
    }

    if(CurTextPr.Unifill)
    {
        CurTextPr.Unifill.check(PDSE.Theme, PDSE.ColorMap);
        RGBA = CurTextPr.Unifill.getRGBAColor();

        if ( true === PDSE.VisitedHyperlink && ( undefined === this.CtrPrp.Color && undefined === this.CtrPrp.Unifill ) )
        {
            AscFormat.G_O_VISITED_HLINK_COLOR.check(PDSE.Theme, PDSE.ColorMap);
            RGBA = AscFormat.G_O_VISITED_HLINK_COLOR.getRGBAColor();
            pGraphics.p_color( RGBA.R, RGBA.G, RGBA.B, RGBA.A );
            pGraphics.b_color1( RGBA.R, RGBA.G, RGBA.B, RGBA.A );
        }
        else
        {
            pGraphics.p_color( RGBA.R, RGBA.G, RGBA.B, RGBA.A );
            pGraphics.b_color1( RGBA.R, RGBA.G, RGBA.B, RGBA.A);
        }
    }
    else
    {
        if ( true === PDSE.VisitedHyperlink && ( undefined === this.CtrPrp.Color && undefined === this.CtrPrp.Unifill ) )
        {
            AscFormat.G_O_VISITED_HLINK_COLOR.check(PDSE.Theme, PDSE.ColorMap);
            RGBA = AscFormat.G_O_VISITED_HLINK_COLOR.getRGBAColor();
            pGraphics.p_color( RGBA.R, RGBA.G, RGBA.B, RGBA.A );
            pGraphics.b_color1( RGBA.R, RGBA.G, RGBA.B, RGBA.A );
        }
        else
        {
            if(!pGraphics.m_bIsTextDrawer || !CurTextPr.TextFill)
            {
                if ( true === CurTextPr.Color.Auto )
                {
                    pGraphics.p_color( AutoColor.r, AutoColor.g, AutoColor.b, 255);
                    pGraphics.b_color1( AutoColor.r, AutoColor.g, AutoColor.b, 255);
                }
                else
                {
                    pGraphics.p_color( CurTextPr.Color.r, CurTextPr.Color.g, CurTextPr.Color.b, 255);
                    pGraphics.b_color1( CurTextPr.Color.r, CurTextPr.Color.g, CurTextPr.Color.b, 255);
                }
            }
			else if (pGraphics.m_bIsTextDrawer)
			{
				pGraphics.SetTextPr(CurTextPr, PDSE.Theme);
			}
        }
    }

    if (reviewtype_Common !== this.GetReviewType())
    {
        var ReviewColor = this.GetReviewColor();
        pGraphics.p_color(ReviewColor.r, ReviewColor.g, ReviewColor.b, 255);
        pGraphics.b_color1(ReviewColor.r, ReviewColor.g, ReviewColor.b, 255);
    }

    if(BgColor == undefined)
        BgColor = new CDocumentColor( 255, 255, 255, false );

    return BgColor;
};
CMathBase.prototype.protected_AddToContent = function(Pos, Items, bUpdatePosition)
{
	AscCommon.History.Add(new CChangesMathBaseAddItems(this, Pos, Items));
	this.raw_AddToContent(Pos, Items, bUpdatePosition);
	this.private_UpdatePosOnAdd(Pos, bUpdatePosition);
};
CMathBase.prototype.protected_RemoveItems = function(Pos, Items, bUpdatePosition)
{
	AscCommon.History.Add(new CChangesMathBaseRemoveItems(this, Pos, Items));

	var Count = Items.length;
	this.raw_RemoveFromContent(Pos, Count);

	// Обновим текущую позицию
	if (this.CurPos > Pos + Count)
		this.CurPos -= Count;
	else if (this.CurPos > Pos)
		this.CurPos = Pos;

	this.private_CorrectCurPos();
	this.private_UpdatePosOnRemove(Pos, Count);
};
CMathBase.prototype.raw_AddToContent = function(Pos, Items, bUpdatePosition)
{
	for (var Index = 0, Count = Items.length; Index < Count; Index++)
	{
		var Item = Items[Index];
		this.Content.splice(Pos + Index, 0, Item);

		if (Item.Set_ParaMath)
			Item.Set_ParaMath(this.ParaMath);

		if (Item.SetParagraph)
			Item.SetParagraph(this.Paragraph);

		Item.ParentElement = this;
	}

	this.fillContent();
};
CMathBase.prototype.raw_RemoveFromContent = function(Pos, Count)
{
    this.Content.splice(Pos, Count);

    this.fillContent();
};
CMathBase.prototype.raw_SetColumn = function(Value)
{
    if(Value > 0)
        this.Pr.Set_Column(Value);
};
CMathBase.prototype.Recalc_RunsCompiledPr = function()
{
    this.RecalcInfo.bCtrPrp = true;

    for(var i=0; i < this.nRow; i++)
        for(var j = 0; j < this.nCol; j++)
        {
            var Item = this.elements[i][j];
            if(!Item.IsJustDraw())
                Item.Recalc_RunsCompiledPr();
        }
};
CMathBase.prototype.GetLastElement = function()
{
    return this;
};
CMathBase.prototype.GetFirstElement = function()
{
    return this;
};
CMathBase.prototype.Recalculate_Range = function(PRS, ParaPr, Depth)
{
    var WordLen = PRS.WordLen; // запоминаем, чтобы внутр мат объекты не увеличили WordLen
    var bContainCompareOper = PRS.bContainCompareOper;

    var bOneLine = PRS.bMath_OneLine;

    this.bOneLine = this.bCanBreak == false || PRS.bMath_OneLine == true;

    if(this.kind !== MATH_DELIMITER)
    {
        this.BrGapLeft  = this.GapLeft;
        this.BrGapRight = this.GapRight;
    }

    if(this.bOneLine == true)
    {
        PRS.bMath_OneLine = this.bOneLine;

        for(var i=0; i < this.nRow; i++)
        {
            for(var j = 0; j < this.nCol; j++)
            {
                var Item = this.elements[i][j];

                if(Item.IsJustDraw()) // для Just-Draw элементов надо выставить Font
                {
                    this.MeasureJustDraw(Item);
                }
                else
                {
                    Item.Recalculate_Reset(PRS.Range, PRS.Line, PRS); // обновим StartLine и StartRange
                    Item.Recalculate_Range(PRS, ParaPr, Depth);
                }
            }
        }

        this.recalculateSize(g_oTextMeasurer);

        this.UpdatePRS_OneLine(PRS, WordLen, PRS.MathFirstItem);
        this.Bounds.SetWidth(0, 0, this.size.width);
        this.Bounds.UpdateMetrics(0, 0, this.size);
    }
    else
    {
        var CurLine  = PRS.Line - this.StartLine;
        var CurRange = ( 0 === CurLine ? PRS.Range - this.StartRange : PRS.Range );

        this.setDistance();

        var Numb = this.NumBreakContent;

        var Len = this.Content.length;
        var RangeStartPos = this.protected_AddRange(CurLine, CurRange),
            RangeEndPos = Len - 1;

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

        for(var Pos = RangeStartPos; Pos < Len; Pos++)
        {
            var Item = this.Content[Pos];

            var NeedSetReset = CurLine == 0 && CurRange == 0  || Pos !== RangeStartPos;
            if(Item.Type == para_Math_Content && NeedSetReset)
                Item.Recalculate_Reset(PRS.Range, PRS.Line, PRS); // обновим StartLine и StartRange

            if(Pos == Numb)
            {
                PRS.Update_CurPos(Pos, Depth);
                PRS.bMath_OneLine  = false;

                Item.Recalculate_Range(PRS, ParaPr, Depth+1);

                if(true === PRS.NewRange)
                {
                    RangeEndPos = Numb;
                    break;
                }
            }
            else
            {
                PRS.bMath_OneLine = true;

                var WWordLen = PRS.WordLen;

                Item.Recalculate_Range(PRS, ParaPr, Depth+1);

                PRS.WordLen = WWordLen + Item.size.width;
                PRS.Word    = true;

            }

            if(PRS.NewRange == false && Pos < Len - 1)
                PRS.WordLen += this.dW;
        }

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

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

    PRS.bMath_OneLine = bOneLine;
    PRS.bContainCompareOper = bContainCompareOper;
};
CMathBase.prototype.RecalculateMinMaxContentWidth = function(MinMax)
{
    if(this.kind !== MATH_DELIMITER)
    {
        this.BrGapLeft  = this.GapLeft;
        this.BrGapRight = this.GapRight;
    }
	
	let mathContent = this.Content[this.NumBreakContent];
	if (mathContent)
	{
		// Всю формулу воспринимаем как слово
		MinMax.addLetter(this.BrGapLeft);
		mathContent.RecalculateMinMaxContentWidth(MinMax);
		MinMax.addLetter(this.BrGapRight);
	}
	else
	{
		MinMax.addLetter(this.size.width);
	}
};
CMathBase.prototype.MeasureJustDraw = function(Item)
{
    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
    };

    g_oTextMeasurer.SetFont(Font);

    Item.Measure(g_oTextMeasurer);
};
CMathBase.prototype.UpdatePRS_OneLine = function(PRS, WordLen)
{
    if(this.bInside == false)
    {
        PRS.WordLen = WordLen + this.size.width;
        PRS.MathFirstItem = false;
    }
};
CMathBase.prototype.Recalculate_Range_OneLine = function(PRS, ParaPr, Depth)
{
    this.Recalculate_Range(PRS, ParaPr, Depth);
};
CMathBase.prototype.Recalculate_LineMetrics = function(PRS, ParaPr, _CurLine, _CurRange, ContentMetrics)
{
    var CurLine = _CurLine - this.StartLine;
    var CurRange = (0 === CurLine ? _CurRange - this.StartRange : _CurRange);

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

    var StartPos, EndPos;

    if(this.bOneLine)
    {
        var NewContentMetrics = new CMathBoundsMeasures();

        for (var CurPos = 0; CurPos < this.Content.length; CurPos++)
        {
            this.Content[CurPos].Recalculate_LineMetrics(PRS, ParaPr, _CurLine, _CurRange, NewContentMetrics);
        }

        //this.Bounds.UpdateMetrics(CurLine, CurRange, this.size);
        this.Bounds.UpdateMetrics(0, 0, this.size);

        // чтобы внутр объекты не перебили метрики (например, у внутр мат объекта Asc может быть больше Asc текущего объекта)

        ContentMetrics.UpdateMetrics(this.size);

        if(this.Parent.bRoot)
        {
            this.UpdatePRS(PRS, this.size);
        }
    }
    else
    {
        StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
        EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

        for (var CurPos = StartPos; CurPos <= EndPos; CurPos++)
        {
            var Item = this.Content[CurPos];
            Item.Recalculate_LineMetrics(PRS, ParaPr, _CurLine, _CurRange, ContentMetrics);

            var BoundItem = Item.Get_LineBound(_CurLine, _CurRange);

            this.Bounds.UpdateMetrics(CurLine, CurRange, BoundItem);
            //ContentMetrics.UpdateMetrics(BoundItem);

            this.UpdatePRS(PRS, BoundItem);
        }
    }
};
CMathBase.prototype.Math_UpdateLineMetrics = function(PRS, paraPr)
{
};
CMathBase.prototype.IsEmptyRange = function(nCurLine, nCurRange)
{
	if (!this.bOneLine)
		return this.Content[this.NumBreakContent].IsEmptyRange(nCurLine, nCurRange);

	return false;
};
CMathBase.prototype.Get_LineBound = function(_CurLine, _CurRange)
{
    var CurLine  = _CurLine - this.StartLine;
    var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );

    return this.Bounds.Get_LineBound(CurLine, CurRange);
};
CMathBase.prototype.UpdatePRS = function(PRS, Metric)
{
    var MetricAsc  = Metric.Type == MATH_SIZE ? Metric.ascent : Metric.Asc;
    var MetricDesc = Metric.Type == MATH_SIZE ? Metric.height - Metric.ascent : Metric.H - Metric.Asc;

    if(PRS.LineAscent < MetricAsc)
        PRS.LineAscent = MetricAsc;

    if(PRS.LineDescent < MetricDesc)
        PRS.LineDescent = MetricDesc;


};
CMathBase.prototype.UpdateMetrics = function(PRS, Size)
{
    if(PRS.LineAscent < Size.ascent)
        PRS.LineAscent = Size.ascent;

    if(PRS.LineDescent < Size.height - Size.ascent)
        PRS.LineDescent = Size.height - Size.ascent;
};
CMathBase.prototype.Recalculate_Range_Width = function(PRSC, _CurLine, _CurRange)
{
    var RangeW = PRSC.Range.W;

    var CurLine = _CurLine - this.StartLine;
    var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );

    if(this.bOneLine)
    {
        for (var Pos = 0; Pos <= this.Content.length - 1; Pos++)
        {
            this.Content[Pos].Recalculate_Range_Width( PRSC, _CurLine, _CurRange );
        }

        PRSC.Range.W = RangeW + this.size.width;
    }
    else
    {
        var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
        var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

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

        for (var CurPos = StartPos; CurPos <= EndPos; CurPos++)
        {
            this.Content[CurPos].Recalculate_Range_Width( PRSC, _CurLine, _CurRange );
        }

        PRSC.Range.W += this.dW*(EndPos - StartPos);

        // Здесь проверяем не на то, что это последний Range (т.к. на данном этапе еще идет вычисление строк) а на конец контента !

        var Len = this.Content.length;
        var EndBrContentEnd = this.NumBreakContent == EndPos && this.Content[EndPos].Math_Is_End( _CurLine, _CurRange),
            NotBrContent = this.NumBreakContent !== EndPos;

        var bEnd = EndBrContentEnd || NotBrContent;

        if(EndPos == Len - 1 && true === bEnd)
        {
            PRSC.Range.W += this.BrGapRight;
        }
    }

    this.Bounds.SetWidth(CurLine, CurRange, PRSC.Range.W - RangeW);
};
CMathBase.prototype.UpdateOperators = function(_CurLine, _CurRange, bEmptyGapLeft, bEmptyGapRight)
{
    if(this.bOneLine == false)
    {
         // Content[this.NumBreakContent] должен содержаться в каждой строке многострочного объекта
         this.Content[this.NumBreakContent].UpdateOperators(_CurLine, _CurRange, bEmptyGapLeft, bEmptyGapRight);
    }

};
CMathBase.prototype.IsShade = function()
{
    var oShd = this.Get_CompiledCtrPrp().Shd;
    return !(oShd === undefined || Asc.c_oAscShdNil === oShd.Value);
};
CMathBase.prototype.Get_Range_VisibleWidth = function(RangeW, _CurLine, _CurRange)
{
    if(this.bOneLine)
    {
        RangeW.W += this.size.width;
    }
    else
    {
        var CurLine  = _CurLine - this.StartLine;
        var CurRange = ( 0 === CurLine ? _CurRange - this.StartRange : _CurRange );

        var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
        var EndPos   = this.protected_GetRangeEndPos(CurLine, CurRange);

        for (var CurPos = StartPos; CurPos <= EndPos; CurPos++ )
        {
            this.Content[CurPos].Get_Range_VisibleWidth(RangeW, _CurLine, _CurRange);
        }
    }
};
CMathBase.prototype.Displace_BreakOperator = function(isForward, bBrkBefore, CountOperators)
{
	if (!this.Content[this.NumBreakContent])
		return;

    this.Content[this.NumBreakContent].Displace_BreakOperator(isForward, bBrkBefore, CountOperators);
};
CMathBase.prototype.Get_AlignBrk = function(_CurLine, bBrkBefore)
{
	if (!this.Content[this.NumBreakContent])
		return null;

	return this.Content[this.NumBreakContent].Get_AlignBrk(_CurLine, bBrkBefore);
};
CMathBase.prototype.raw_SetReviewInfo = function(reviewInfo)
{
	this.ReviewInfo = reviewInfo;
	this.updateTrackRevisions();
};
CMathBase.prototype.GetReviewType = function()
{
	let reviewInfo = this.GetReviewInfo();
	return reviewInfo ? reviewInfo.getType() : reviewtype_Common;
};
CMathBase.prototype.GetReviewInfo = function()
{
	if (this.Id)
		return this.ReviewInfo;
	else if (this.Parent && this.Parent.GetReviewInfo)
		return this.Parent.GetReviewInfo();

	return new AscWord.ReviewInfo();
};
CMathBase.prototype.GetReviewMoveType = function()
{
	return this.GetReviewInfo().MoveType;
};
CMathBase.prototype.GetReviewColor = function()
{
    if (this.Id)
    {
        if (this.ReviewInfo)
            return this.ReviewInfo.Get_Color();
        else
            return new CDocumentColor(255, 0, 0);
    }
    else if (this.Parent && this.Parent.GetReviewColor)
    {
        return this.Parent.GetReviewColor();
    }

    return REVIEW_COLOR;
};
CMathBase.prototype.SetReviewType = function(reviewType, isSetToContent)
{
	if (!this.Id)
		return;
	
	if (false !== isSetToContent)
		CParagraphContentWithParagraphLikeContent.prototype.SetReviewType.apply(this, arguments);
	
	if (reviewType === this.GetReviewType())
		return;
	
	let oldInfo = this.GetReviewInfo();
	let newInfo = undefined;
	
	if (reviewType !== reviewtype_Common)
	{
		newInfo = new AscWord.ReviewInfo();
		newInfo.setType(reviewType);
		newInfo.Update();
	}
	
	AscCommon.History.Add(new CChangesMathBaseReviewInfo(this, oldInfo ? oldInfo.Copy() : undefined, newInfo ? newInfo.Copy() : undefined));
	this.raw_SetReviewInfo(newInfo);
};
CMathBase.prototype.SetReviewTypeWithInfo = function(reviewType, reviewInfo)
{
	if (!this.Id)
		return;
	
	CParagraphContentWithParagraphLikeContent.prototype.SetReviewTypeWithInfo.apply(this, arguments);
	
	let oldInfo = this.GetReviewInfo();
	
	if (reviewType === reviewtype_Common)
		reviewInfo = undefined;
	else if (!reviewInfo)
		reviewInfo = new AscWord.ReviewInfo();
	
	if (reviewInfo)
		reviewInfo.setType(reviewType);
	
	AscCommon.History.Add(new CChangesMathBaseReviewInfo(this, oldInfo ? oldInfo.Copy() : undefined, reviewInfo ? reviewInfo.Copy() : undefined));
	this.raw_SetReviewInfo(reviewInfo);
};
CMathBase.prototype.CheckRevisionsChanges = function(Checker, ContentPos, Depth)
{
    var ReviewType = this.GetReviewType();

    if (true !== Checker.Is_CheckOnlyTextPr())
    {
		if (Checker.IsStopAddRemoveChange(ReviewType, this.GetReviewInfo()))
        {
            Checker.FlushAddRemoveChange();
            ContentPos.Update(0, Depth);

            if (reviewtype_Add === ReviewType || reviewtype_Remove === ReviewType)
            {
                this.Get_StartPos(ContentPos, Depth);
                Checker.StartAddRemove(ReviewType, ContentPos, this.GetReviewMoveType());
            }
        }

        if (reviewtype_Add === ReviewType || reviewtype_Remove === ReviewType)
        {
            Checker.Add_Math(this);
            Checker.Update_AddRemoveReviewInfo(this.ReviewInfo);
            this.Get_EndPos(false, ContentPos, Depth);
            Checker.Set_AddRemoveEndPos(ContentPos);

            // Нам нужно проставить конечную позицию в начало следующего рана, чтобы выделился данный элемент целиком
            if (this.Paragraph)
            {
                var TempContentPos = this.Paragraph.Get_PosByElement(this);
                if (TempContentPos)
                {
                    var InParentPos = TempContentPos.Get(TempContentPos.GetDepth());
                    TempContentPos.DecreaseDepth(1);
                    var Parent = this.Paragraph.Get_ElementByPos(TempContentPos);
                    if (Parent && Parent.Content && this === Parent.Content[InParentPos] && Parent.Content[InParentPos + 1] && para_Math_Run === Parent.Content[InParentPos + 1].Type)
                    {
                        ContentPos.Update(InParentPos + 1, Depth - 1);
                        Parent.Content[InParentPos + 1].Get_StartPos(ContentPos, Depth);
                        Checker.Set_AddRemoveEndPos(ContentPos);
                    }
                }
            }
        }
    }

    if (reviewtype_Common !== ReviewType)
        Checker.Begin_CheckOnlyTextPr();

    CParagraphContentWithParagraphLikeContent.prototype.CheckRevisionsChanges.apply(this, arguments);

    if (reviewtype_Common !== ReviewType)
        Checker.End_CheckOnlyTextPr();
};
CMathBase.prototype.AcceptRevisionChanges = function(Type, bAll)
{
    var ReviewType = this.ReviewType;
    if (reviewtype_Add === ReviewType && (undefined === Type || c_oAscRevisionsChangeType.TextAdd === Type))
    {
        this.SetReviewType(reviewtype_Common, false);
    }
    else if (reviewtype_Remove === ReviewType && (undefined === Type || c_oAscRevisionsChangeType.TextRem === Type))
    {
        var Parent = this.Get_Parent();
        var PosInParent = this.Get_PosInParent(Parent);

        if (!Parent || -1 === PosInParent)
        {
            this.SetReviewType(reviewtype_Common, false);
        }
        else
        {
            Parent.Remove_FromContent(PosInParent, 1);
            return;
        }
    }

    CParagraphContentWithParagraphLikeContent.prototype.AcceptRevisionChanges.apply(this, arguments);
};
CMathBase.prototype.RejectRevisionChanges = function(Type, bAll)
{
    var ReviewType = this.ReviewType;
    if (reviewtype_Remove === ReviewType && (undefined === Type || c_oAscRevisionsChangeType.TextRem === Type))
    {
        this.SetReviewType(reviewtype_Common, false);
    }
    else if (reviewtype_Add === ReviewType && (undefined === Type || c_oAscRevisionsChangeType.TextAdd === Type))
    {
        var Parent = this.Get_Parent();
        var PosInParent = this.Get_PosInParent(Parent);

        if (!Parent || -1 === PosInParent)
        {
            this.SetReviewType(reviewtype_Common, false);
        }
        else
        {
            Parent.Remove_FromContent(PosInParent, 1);
            return;
        }
    }

    CParagraphContentWithParagraphLikeContent.prototype.RejectRevisionChanges.apply(this, arguments);
};
CMathBase.prototype.Set_MenuProps = function(Props)
{
    this.Apply_ForcedBreak(Props);

    if(this.Selection.Use == false)
    {
        this.Content[this.CurPos].Set_MenuProps(Props);
    }
    else if(this.Selection.Use == true && this.Selection.StartPos == this.Selection.EndPos)
    {
        var Pos = this.Selection.StartPos;
        this.Content[Pos].Set_MenuProps(Props);
    }
};
CMathBase.prototype.Can_ApplyMenuPropsToObject = function()
{
    var bApplyToCurrent = false;

    if(this.Selection.Use == true && this.Selection.StartPos !== this.Selection.EndPos)
    {
        bApplyToCurrent = true;
    }
    else
    {
        var Pos = this.Selection.Use == false ? this.CurPos : this.Selection.StartPos;
        bApplyToCurrent = true === this.Content[Pos].Is_CurrentContent();
    }

    return bApplyToCurrent;
};
CMathBase.prototype.Get_MenuProps = function()
{
    var Pr = {};
    var Pos = null;

    if(this.Selection.Use == false)
    {
        Pos = this.CurPos;
    }
    else if(this.Selection.StartPos == this.Selection.EndPos)
    {
        Pos = this.Selection.StartPos;
    }

    var bOutsideComposition   = Pos !== null && true == this.Content[Pos].Check_Composition(),
        bSelectAllComposition = Pos == null;

    if(bOutsideComposition)
    {
        Pr = this.Content[Pos].Get_MenuProps();
        this.Can_ModifyForcedBreak(Pr);
    }
    else if(bSelectAllComposition == false)
    {
        Pr = this.Get_InterfaceProps();
        this.Content[Pos].Can_ModifyForcedBreak(Pr);
    }
    else
    {
        Pr = this.Get_InterfaceProps();
    }

    return Pr;
};
CMathBase.prototype.Apply_MenuProps = function()
{};
CMathBase.prototype.Can_ModifyForcedBreak = function(Pr)
{
};
CMathBase.prototype.Apply_ForcedBreak = function()
{
};
CMathBase.prototype.Get_DeletedItemsThroughInterface = function()
{
    var baseContent  = this.getBase();
    var DeletedItems =  baseContent !==  null ? baseContent.Content : null;

    return DeletedItems;
};
CMathBase.prototype.Can_DecreaseArgumentSize = function()
{
    var bDecreaseArgSize = false;

    if(true === this.Can_ModifyArgSize())
    {
        var CompiledArgSize = this.Content[this.CurPos].Get_CompiledArgSize();
        bDecreaseArgSize = CompiledArgSize.Can_Decrease();
    }

    return bDecreaseArgSize;
};
CMathBase.prototype.Can_IncreaseArgumentSize = function()
{
    var bIncreaseArgSize = false;

    if(true === this.Can_ModifyArgSize())
    {
        var CompiledArgSize = this.Content[this.CurPos].Get_CompiledArgSize();
        bIncreaseArgSize = CompiledArgSize.Can_Increase();
    }

    return bIncreaseArgSize;
};
CMathBase.prototype.Get_InterfaceProps = function()
{
    return new CMathMenuBase();
};
CMathBase.prototype.Can_ModifyArgSize = function()
{
    return false;
};
CMathBase.prototype.Is_SelectInside = function()
{
    return this.Selection.Use == true && this.Selection.StartPos !== this.Selection.EndPos;
};
CMathBase.prototype.Can_InsertForcedBreak = function()
{
    return false;
};
CMathBase.prototype.Can_DeleteForcedBreak = function()
{
    return false;
};
CMathBase.prototype.Correct_ContentCurPos = function()
{
    for(var Pos = 0; Pos < this.Content.length; Pos++)
    {
        this.Content[Pos].Correct_ContentCurPos();
    }
};
CMathBase.prototype.Math_Set_EmptyRange         = CMathContent.prototype.Math_Set_EmptyRange;
CMathBase.prototype.Set_ParaMath                = CMathContent.prototype.Set_ParaMath;
CMathBase.prototype.Recalculate_Reset           = CMathContent.prototype.Recalculate_Reset;
CMathBase.prototype.Set_ParaContentPos          = CMathContent.prototype.Set_ParaContentPos;
CMathBase.prototype.GetCurrentParaPos           = CMathContent.prototype.GetCurrentParaPos;
CMathBase.prototype.private_UpdatePosOnAdd      = CMathContent.prototype.private_UpdatePosOnAdd;
CMathBase.prototype.private_UpdatePosOnRemove   = CMathContent.prototype.private_UpdatePosOnRemove;
CMathBase.prototype.private_CorrectSelectionPos = CMathContent.prototype.private_CorrectSelectionPos;

CMathBase.prototype.private_CorrectCurPos = function()
{
    if (this.CurPos > this.Content.length - 1)
    {
        this.CurPos = this.Content.length - 1;
        this.Content[this.CurPos].MoveCursorToEndPos(false);
    }

    if (this.CurPos < 0)
    {
        this.CurPos = this.Content.length - 1;
        this.Content[this.CurPos].MoveCursorToStartPos();
    }
};
CMathBase.prototype.Selection_CheckParaContentPos = function(ContentPos, Depth, bStart, bEnd)
{
    if (true !== this.Selection.Use)
        return false;

    var CurPos = ContentPos.Get(Depth);

    if (this.Selection.StartPos === this.Selection.EndPos && this.Selection.StartPos === CurPos)
        return this.Content[CurPos].Selection_CheckParaContentPos(ContentPos, Depth + 1, bStart, bEnd);

    if (this.Selection.StartPos !== this.Selection.EndPos)
        return true;

    return false;
};

CMathBase.prototype.Is_ContentUse = function(MathContent)
{
    for (var Pos = 0, Count = this.Content.length; Pos < Count; Pos++)
    {
        if (MathContent === this.Content[Pos])
            return true;
    }

    return false;
};
CMathBase.prototype.Is_FromDocument = function()
{
	return (this.ParaMath && this.ParaMath.Paragraph && this.ParaMath.Paragraph.bFromDocument);
};
CMathBase.prototype.Clear_ContentChanges = function()
{
	this.m_oContentChanges.Clear();
};
CMathBase.prototype.Add_ContentChanges = function(Changes)
{
	this.m_oContentChanges.Add(Changes);
};
CMathBase.prototype.Refresh_ContentChanges = function()
{
	this.m_oContentChanges.Refresh();
};
CMathBase.prototype.ConvertStrToOperator= function(text)
{
    var aUnicode = AscCommon.convertUTF16toUnicode(text);
    return (aUnicode.length <= 0 ? OPERATOR_EMPTY : aUnicode[0]);
};
CMathBase.prototype.ConvertOperatorToStr = function(operator)
{
    if (null == operator) {
        return operator;
    }
    return OPERATOR_EMPTY === operator ? "" : AscCommon.convertUnicodeToUTF16([operator]);
};
CMathBase.prototype.GetTextOfElement = function(oMathText)
{
	oMathText = new AscMath.MathTextAndStyles(oMathText);
	return oMathText;
};
CMathBase.prototype.CheckRunContent = function (fCheck, oStartPos, oEndPos, nDepth, oCurrentPos, isForward)
{
	if (undefined === isForward)
		isForward = true;

	let nStartPos = oStartPos && oStartPos.GetDepth() >= nDepth ? oStartPos.Get(nDepth) : 0;
	let nEndPos   = oEndPos && oEndPos.GetDepth() >= nDepth ? oEndPos.Get(nDepth) : this.Content.length - 1;

	if (isForward)
	{
		for (var nPos = nStartPos; nPos <= nEndPos; ++nPos)
		{
			let _s = oStartPos && nPos === nStartPos ? oStartPos : null;
			let _e = oEndPos && nPos === nEndPos ? oEndPos : null;

			if (oCurrentPos)
				oCurrentPos.Update(nPos, nDepth);

			if (this.Content[nPos].CheckRunContent(fCheck, _s, _e, nDepth + 1, oCurrentPos, isForward))
				return true;
		}
	}
	else
	{
		for (var nPos = nEndPos; nPos >= nStartPos; --nPos)
		{
			let _s = oStartPos && nPos === nStartPos ? oStartPos : null;
			let _e = oEndPos && nPos === nEndPos ? oEndPos : null;

			if (oCurrentPos)
				oCurrentPos.Update(nPos, nDepth);

			if (this.Content[nPos].CheckRunContent(fCheck, _s, _e, nDepth + 1, oCurrentPos, isForward))
				return true;
		}
	}
};

function CMathBasePr()
{
}
CMathBasePr.prototype.Set_FromObject  = function(Obj){};
CMathBasePr.prototype.Copy            = function(){return new CMathBasePr();};
CMathBasePr.prototype.Write_ToBinary  = function(Writer){};
CMathBasePr.prototype.Read_FromBinary = function(Reader){};

function CMathBounds()
{
    this.Bounds = [];
}
CMathBounds.prototype.Reset = function(CurLine, CurRange)
{
    if(CurRange == 0)
        this.Bounds.length = CurLine;
};
CMathBounds.prototype.CheckLineBound = function(Line, Range)
{
    if(this.Bounds.length <= Line)
    {
        this.Bounds[Line] = [];
    }
    else if (undefined === this.Bounds[Line])
    {
        this.Bounds[Line] = [];
    }

    if(this.Bounds[Line].length <= Range)
    {
        this.Bounds[Line][Range] = new CMathBoundsMeasures();
    }
};
CMathBounds.prototype.UpdateMetrics = function(Line, Range, Metric)
{
    this.CheckLineBound(Line, Range);
    this.Bounds[Line][Range].UpdateMetrics(Metric);
};
CMathBounds.prototype.SetWidth = function(Line, Range, Width)
{
    this.CheckLineBound(Line, Range);
    this.Bounds[Line][Range].SetWidth(Width);
};
CMathBounds.prototype.SetPage = function(Line, Range, Page)
{
    this.CheckLineBound(Line);
    this.Bounds[Line][Range].SetPage(Page);
};
CMathBounds.prototype.GetWidth = function(Line, Range)
{
    this.CheckLineBound(Line);
    return this.Bounds[Line][Range].W;
};
CMathBounds.prototype.GetAscent = function(Line, Range)
{
    this.CheckLineBound(Line);
    return this.Bounds[Line][Range].Asc;
};
CMathBounds.prototype.GetDescent = function(Line, Range)
{
    this.CheckLineBound(Line);
    return this.Bounds[Line][Range].H - this.Bounds[Line][Range].Asc;
};
CMathBounds.prototype.ShiftPage = function(Dx)
{
    var CountLines = this.Bounds.length;

    for(var CurLine = 0; CurLine < CountLines; CurLine++)
    {
        var CountRanges = this.Bounds[CurLine].length;

        for(var CurRange = 0; CurRange < CountRanges; CurRange++)
        {
            this.Bounds[CurLine][CurRange].ShiftPage(Dx);
        }
    }
};
CMathBounds.prototype.Get_Bounds = function()
{
    return this.Bounds;
};
CMathBounds.prototype.Get_LineBound = function(CurLine, CurRange)
{
    var Bound;
    if(CurLine < this.Bounds.length && CurRange < this.Bounds[CurLine].length)
    {
        Bound = this.Bounds[CurLine][CurRange];
    }
    else // заглушка, если еще не пересчитали, а запрос Bonds пришел (например, на поиске)
    {
        Bound = new CMathBoundsMeasures();
    }

    return Bound;
};
CMathBounds.prototype.SetPos = function(Line, Range, Pos)
{
    this.CheckLineBound(Line, Range);
    this.Bounds[Line][Range].SetPos(Pos);
};
CMathBounds.prototype.SetGenPos = function(Line, Range, PRSA)
{
    this.CheckLineBound(Line, Range);
    this.Bounds[Line][Range].SetGenPos(PRSA);
};
CMathBounds.prototype.ShiftPos = function(Line, Range, Dx, Dy)
{
    this.CheckLineBound(Line, Range);
    this.Bounds[Line][Range].ShiftPos(Dx, Dy);
};
CMathBounds.prototype.GetPos = function(Line, Range)
{
    this.CheckLineBound(Line);

    var Pos = new CMathPosition();

    Pos.x = this.Bounds[Line][Range].GetX();
    Pos.y = this.Bounds[Line][Range].GetY();

    return Pos;
};
function CMathBoundsMeasures()
{
    this.Type = MATH_BOUNDS_MEASURES;

    // нужны ля расчета выравниваний относительно операторов
    this._X   = 0;
    this._Y   = 0;
    // необходимы для отрисовки рамки, подсветки
    this.X    = 0;
    this.Y    = 0;

    this.W    = 0;
    this.H    = 0;
    this.Asc  = 0;
    this.Page = 0;
}
CMathBoundsMeasures.prototype.UpdateMetrics = function(Metric)
{
    var MetricH   = Metric.Type == MATH_SIZE ? Metric.height : Metric.H;
    var MetricAsc = Metric.Type == MATH_SIZE ? Metric.ascent : Metric.Asc;

    var Descent = this.H - this.Asc;
    var MetricDescent = MetricH - MetricAsc;

    if(this.Asc < MetricAsc)
        this.Asc = MetricAsc;

    if(Descent < MetricDescent)
    {
        this.H = MetricDescent + this.Asc;
    }
    else
    {
        this.H = Descent + this.Asc;
    }
};
CMathBoundsMeasures.prototype.SetWidth = function(Width)
{
    this.W = Width;
};
CMathBoundsMeasures.prototype.SetGenPos = function(PRSA)
{
    this.X = PRSA.X + this._X;
    this.Y = PRSA.Y + this._Y;
};
CMathBoundsMeasures.prototype.SetPos = function(Pos)
{
    this._X = Pos.x;
    this._Y = Pos.y - this.Asc;
};
CMathBoundsMeasures.prototype.ShiftPos = function(Dx, Dy)
{
    this.X += Dx;
    this.Y += Dy;
};
CMathBoundsMeasures.prototype.GetX = function()
{
    return this.X;
};
CMathBoundsMeasures.prototype.GetY = function()
{
    return this.Y + this.Asc;
};
CMathBoundsMeasures.prototype.SetPage = function(Page)
{
    this.Page = Page;
};
CMathBoundsMeasures.prototype.ShiftPage = function(Dx)
{
    this.Page += Dx;
};

function CEmptyRunRecalculateObject(StartLine, StartRange)
{
    this.StartLine   = StartLine;
    this.StartRange  = StartRange;
    this.Lines       = [];
    this.Content     = [];

    this.WrapState   = ALIGN_EMPTY;
}
CEmptyRunRecalculateObject.prototype =
{
    Save_Lines : function(Obj, Copy)
    {

    },

    Save_Content : function(Obj, Copy)
    {

    },

    Save_WrapState: function(Obj, Copy)
    {

    },

    Load_Lines : function(Obj)
    {

    },

    Load_Content : function(Obj)
    {

    },

    Load_WrapState: function(Obj)
    {

    },

    SaveRunContent : function(Run, Copy)
    {

    },

    LoadRunContent : function(Run)
    {

    },

    Get_DrawingFlowPos : function(FlowPos)
    {

    },

    Compare : function(_CurLine, _CurRange, OtherLinesInfo)
    {
        return true;
    }

};

var c_oMathMenuAction = {
    None                    : 0x00000000,
    RemoveAccentCharacter   : 0x00000001,
    RemoveBar               : 0x00000002,
    InsertMatrixRow         : 0x00000004,
    InsertMatrixColumn      : 0x00000008,
    InsertBefore            : 0x00000010,
    DeleteMatrixRow         : 0x00000020,
    DeleteMatrixColumn      : 0x00000040,
    InsertEquation          : 0x00000080,
    DeleteEquation          : 0x00000100,
    InsertDelimiterArgument : 0x00000200,
    DeleteDelimiterArgument : 0x00000400,
    IncreaseArgumentSize    : 0x00000800,
    DecreaseArgumentSize    : 0x00001000,
    InsertForcedBreak       : 0x00002000,
    DeleteForcedBreak       : 0x00004000,
    AlignToCharacter        : 0x00008000,
    RemoveDelimiter         : 0x00010000,
    RemoveRadical           : 0x00020000

};

function CMathMenuBase(oMath)
{
    this.Type   = Asc.c_oAscMathInterfaceType.Common;
    this.Action = c_oMathMenuAction.None;

    if(oMath == undefined)
    {
        this.CanIncreaseArgumentSize = false;
        this.CanDecreaseArgumentSize = false;
        this.CanInsertForcedBreak    = false;
        this.CanDeleteForcedBreak    = false;
        this.CanAlignToCharacter     = false;
    }
    else
    {
        this.CanIncreaseArgumentSize = oMath.Can_IncreaseArgumentSize();
        this.CanDecreaseArgumentSize = oMath.Can_DecreaseArgumentSize();
        this.CanInsertForcedBreak    = oMath.Can_InsertForcedBreak();
        this.CanDeleteForcedBreak    = oMath.Can_DeleteForcedBreak();
        this.CanAlignToCharacter     = false;
    }
}
CMathMenuBase.prototype.get_Type = function()
{
    return this.Type;
};
CMathMenuBase.prototype.remove_AccentCharacter = function()
{
    this.Action |= c_oMathMenuAction.RemoveAccentCharacter;
};
CMathMenuBase.prototype.remove_Bar = function()
{
    this.Action |= c_oMathMenuAction.RemoveBar;
};
CMathMenuBase.prototype.insert_MatrixRow = function(bBefore)
{
    if (bBefore)
        this.Action |= c_oMathMenuAction.InsertBefore;

    this.Action |= c_oMathMenuAction.InsertMatrixRow;
};
CMathMenuBase.prototype.insert_MatrixColumn = function(bBefore)
{
    if (bBefore)
        this.Action |= c_oMathMenuAction.InsertBefore;

    this.Action |= c_oMathMenuAction.InsertMatrixColumn;
};
CMathMenuBase.prototype.delete_MatrixRow = function()
{
    this.Action |= c_oMathMenuAction.DeleteMatrixRow;
};
CMathMenuBase.prototype.delete_MatrixColumn = function()
{
    this.Action |= c_oMathMenuAction.DeleteMatrixColumn;
};
CMathMenuBase.prototype.insert_Equation = function(bBefore)
{
    if (bBefore)
        this.Action |= c_oMathMenuAction.InsertBefore;

    this.Action |= c_oMathMenuAction.InsertEquation;
};
CMathMenuBase.prototype.delete_Equation = function()
{
    this.Action |= c_oMathMenuAction.DeleteEquation;
};
CMathMenuBase.prototype.insert_DelimiterArgument = function(bBefore)
{
    if (bBefore)
        this.Action |= c_oMathMenuAction.InsertBefore;

    this.Action |= c_oMathMenuAction.InsertDelimiterArgument;
};
CMathMenuBase.prototype.delete_DelimiterArgument = function()
{
    this.Action |= c_oMathMenuAction.DeleteDelimiterArgument;
};
CMathMenuBase.prototype.can_IncreaseArgumentSize = function()
{
    return this.CanIncreaseArgumentSize;
};
CMathMenuBase.prototype.can_DecreaseArgumentSize = function()
{
    return this.CanDecreaseArgumentSize;
};
CMathMenuBase.prototype.increase_ArgumentSize = function()
{
    this.Action |= c_oMathMenuAction.IncreaseArgumentSize;
};
CMathMenuBase.prototype.decrease_ArgumentSize = function()
{
    this.Action |= c_oMathMenuAction.DecreaseArgumentSize;
};
CMathMenuBase.prototype.can_InsertManualBreak = function()
{
    return this.CanInsertForcedBreak;
};
CMathMenuBase.prototype.can_DeleteManualBreak = function()
{
    return this.CanDeleteForcedBreak;
};
CMathMenuBase.prototype.can_AlignToCharacter = function()
{
    return this.CanAlignToCharacter;
};
CMathMenuBase.prototype.insert_ManualBreak = function()
{
    this.Action |= c_oMathMenuAction.InsertForcedBreak;
};
CMathMenuBase.prototype.delete_ManualBreak = function()
{
    this.Action |= c_oMathMenuAction.DeleteForcedBreak;
};
CMathMenuBase.prototype.align_ToCharacter = function()
{
    this.Action |= c_oMathMenuAction.AlignToCharacter;
};
CMathMenuBase.prototype.remove_DelimiterCharacters = function()
{
    this.Action |= c_oMathMenuAction.RemoveDelimiter;
};
CMathMenuBase.prototype.remove_Radical = function()
{
    this.Action |= c_oMathMenuAction.RemoveRadical;
};
CMathMenuBase.prototype.Set_InsertForcedBreak = function()
{
    this.CanInsertForcedBreak = true;
    this.CanDeleteForcedBreak = false;
};
CMathMenuBase.prototype.Set_DeleteForcedBreak = function()
{
    this.CanInsertForcedBreak = false;
    this.CanDeleteForcedBreak = true;
};


/**
 * ctrlPr - Control Properties
 * @constructor
 */
function CMathCtrlPr(ctrPr)
{
	this.rPr = ctrPr || new CTextPr(); //по умолчанию должен наследоваться от текущего абзаца
	this.del = new CTextPr();
	this.ins = new CTextPr();
}

/**
 * Set Run Properties
 * rPr set properties of control characters that cannot be selected.
 * Examples of control characters are n-ary operators (excluding their limits and bases),
 * fraction bars (excluding the numerator and denominator), and grouping characters (excluding the base).
 * @param rPr {CTextPr}
 * @constructor
 */
CMathCtrlPr.prototype.SetRPr = function (rPr)
{
	if (!rPr)
		return;
	this.rPr = rPr;
}
/**
 * Get current rPr
 * @return {CTextPr}
 * @constructor
 */
CMathCtrlPr.prototype.GetRPr = function ()
{
	return this.rPr;
}
/**
 * Deleted Math Control Character
 *
 * This element specifies that the Office Open XML Math control character which contains this element was
 * deleted and tracked as a revision
 *
 * @param delPr {CTextPr}
 * @constructor
 */
CMathCtrlPr.prototype.SetDel = function (delPr)
{
	this.del = delPr
}
/**
 * Inserted Math Control Character
 *
 * This element specifies that the Office Open XML Math control character which contains this element was
 * inserted and tracked as a revision.
 * @param insPr {CTextPr}
 * @constructor
 */
CMathCtrlPr.prototype.SetIns = function (insPr)
{
	this.ins = insPr;
}
/**
 *
 * @param Obj {Object}
 * @param Obj.rPr {CTextPr | undefined}
 * @param Obj.delPr {CTextPr | undefined}
 * @param Obj.insPr {CTextPr | undefined}
 * @constructor
 */
CMathCtrlPr.prototype.SetFromObject = function (Obj)
{
	if (Obj.rPr !== undefined)
	{
		this.rPr = Obj.rPr;
	}

	if (Obj.delPr !== undefined)
	{
		this.delPr = Obj.delPr;
	}

	if (Obj.insPr !== undefined)
	{
		this.insPr = Obj.insPr;
	}
}

CMathCtrlPr.prototype.Write_ToBinary = function (Writer)
{
	if (this.rPr)
	{
		Writer.WriteBool(true);
		this.rPr.WriteToBinary(Writer);
	}
	else
	{
		Writer.WriteBool(false);
	}

	if (this.del)
	{
		Writer.WriteBool(true);
		this.del.WriteToBinary(Writer);
	}
	else
	{
		Writer.WriteBool(false);
	}

	if (this.ins)
	{
		Writer.WriteBool(true);
		this.ins.WriteToBinary(Writer);
	}
	else
	{
		Writer.WriteBool(false);
	}
}

CMathCtrlPr.prototype.Read_FromBinary = function (Reader)
{
	this.rPr = undefined;
	if (Reader.GetBool())
	{
		this.rPr = new CTextPr();
		this.rPr.ReadFromBinary(Reader);
	}

	this.del = undefined;
	if (Reader.GetBool())
	{
		this.del = new CTextPr();
		this.del.ReadFromBinary(Reader);
	}

	this.ins = undefined;
	if (Reader.GetBool())
	{
		this.ins = new CTextPr();
		this.ins.ReadFromBinary(Reader);
	}
};

window["CMathCtrlPr"]                                  = CMathCtrlPr;
window["CMathMenuBase"]                                = CMathMenuBase;
CMathMenuBase.prototype["get_Type"]                    = CMathMenuBase.prototype.get_Type;
CMathMenuBase.prototype["remove_AccentCharacter"]      = CMathMenuBase.prototype.remove_AccentCharacter;
CMathMenuBase.prototype["remove_Bar"]                  = CMathMenuBase.prototype.remove_Bar;
CMathMenuBase.prototype["insert_MatrixRow"]            = CMathMenuBase.prototype.insert_MatrixRow;
CMathMenuBase.prototype["insert_MatrixColumn"]         = CMathMenuBase.prototype.insert_MatrixColumn;
CMathMenuBase.prototype["delete_MatrixRow"]            = CMathMenuBase.prototype.delete_MatrixRow;
CMathMenuBase.prototype["delete_MatrixColumn"]         = CMathMenuBase.prototype.delete_MatrixColumn;
CMathMenuBase.prototype["insert_Equation"]             = CMathMenuBase.prototype.insert_Equation;
CMathMenuBase.prototype["delete_Equation"]             = CMathMenuBase.prototype.delete_Equation;
CMathMenuBase.prototype["insert_DelimiterArgument"]    = CMathMenuBase.prototype.insert_DelimiterArgument;
CMathMenuBase.prototype["delete_DelimiterArgument"]    = CMathMenuBase.prototype.delete_DelimiterArgument;
CMathMenuBase.prototype["can_IncreaseArgumentSize"]    = CMathMenuBase.prototype.can_IncreaseArgumentSize;
CMathMenuBase.prototype["can_DecreaseArgumentSize"]    = CMathMenuBase.prototype.can_DecreaseArgumentSize;
CMathMenuBase.prototype["increase_ArgumentSize"]       = CMathMenuBase.prototype.increase_ArgumentSize;
CMathMenuBase.prototype["decrease_ArgumentSize"]       = CMathMenuBase.prototype.decrease_ArgumentSize;
CMathMenuBase.prototype["can_InsertManualBreak"]       = CMathMenuBase.prototype.can_InsertManualBreak;
CMathMenuBase.prototype["insert_ManualBreak"]          = CMathMenuBase.prototype.insert_ManualBreak;
CMathMenuBase.prototype["can_DeleteManualBreak"]       = CMathMenuBase.prototype.can_DeleteManualBreak;
CMathMenuBase.prototype["delete_ManualBreak"]          = CMathMenuBase.prototype.delete_ManualBreak;
CMathMenuBase.prototype["can_AlignToCharacter"]        = CMathMenuBase.prototype.can_AlignToCharacter;
CMathMenuBase.prototype["align_ToCharacter"]           = CMathMenuBase.prototype.align_ToCharacter;
CMathMenuBase.prototype["remove_DelimiterCharacters"]  = CMathMenuBase.prototype.remove_DelimiterCharacters;
CMathMenuBase.prototype["remove_Radical"]              = CMathMenuBase.prototype.remove_Radical;