/*
 * (c) Copyright Ascensio System SIA 2010-2015
 *
 * 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 Lubanas st. 125a-25, Riga, Latvia,
 * EU, LV-1021.
 *
 * The  interactive user interfaces in modified source and object code versions
 * of the Program must display Appropriate Legal Notices, as required under 
 * Section 5 of the GNU AGPL version 3.
 *
 * Pursuant to Section 7(b) of the License you must retain the original Product
 * logo when distributing the program. Pursuant to Section 7(e) we decline to
 * grant you any rights under trademark law for use of our trademarks.
 *
 * All the Product's GUI elements, including illustrations and icon sets, as
 * well as technical writing content are licensed under the terms of the
 * Creative Commons Attribution-ShareAlike 4.0 International. See the License
 * terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
 *
 */
 "use strict";
function ParaRun(Paragraph, bMathRun) {
    ParaRun.superclass.constructor.call(this);
    this.Id = g_oIdCounter.Get_NewId();
    this.Type = para_Run;
    this.Paragraph = Paragraph;
    this.Pr = new CTextPr();
    this.Content = [];
    this.State = new CParaRunState();
    this.Selection = this.State.Selection;
    this.CompiledPr = new CTextPr();
    this.RecalcInfo = new CParaRunRecalcInfo();
    this.TextAscent = 0;
    this.TextAscent = 0;
    this.TextDescent = 0;
    this.TextHeight = 0;
    this.TextAscent2 = 0;
    this.Ascent = 0;
    this.Descent = 0;
    this.YOffset = 0;
    this.CollaborativeMarks = new CRunCollaborativeMarks();
    this.m_oContentChanges = new CContentChanges();
    this.NearPosArray = [];
    this.SearchMarks = [];
    this.SpellingMarks = [];
    if (bMathRun) {
        this.Type = para_Math_Run;
        this.ParaMath = null;
        this.Parent = null;
        this.ArgSize = 0;
        this.bEqqArray = false;
        this.size = new CMathSize();
        this.MathPrp = new CMPrp();
    }
    this.StartState = null;
    g_oTableId.Add(this, this.Id);
    if (this.Paragraph && !this.Paragraph.bFromDocument) {
        this.Save_StartState();
    }
}
Asc.extendClass(ParaRun, CParagraphContentWithContentBase);
ParaRun.prototype.Get_Type = function () {
    return this.Type;
};
ParaRun.prototype.Set_Id = function (newId) {
    g_oTableId.Reset_Id(this, newId, this.Id);
    this.Id = newId;
};
ParaRun.prototype.Get_Id = function () {
    return this.Id;
};
ParaRun.prototype.Get_Paragraph = function () {
    return this.Paragraph;
};
ParaRun.prototype.Set_Paragraph = function (Paragraph) {
    this.Paragraph = Paragraph;
};
ParaRun.prototype.Set_ParaMath = function (ParaMath) {
    this.ParaMath = ParaMath;
};
ParaRun.prototype.Save_StartState = function () {
    this.StartState = new CParaRunStartState(this);
};
ParaRun.prototype.Copy = function (Selected) {
    var bMath = this.Type == para_Math_Run ? true : false;
    var NewRun = new ParaRun(this.Paragraph, bMath);
    NewRun.Set_Pr(this.Pr.Copy());
    if (true === bMath) {
        NewRun.MathPrp = this.MathPrp.Copy();
    }
    var StartPos = 0;
    var EndPos = this.Content.length;
    if (true === Selected && true === this.State.Selection.Use) {
        StartPos = this.State.Selection.StartPos;
        EndPos = this.State.Selection.EndPos;
        if (StartPos > EndPos) {
            StartPos = this.State.Selection.EndPos;
            EndPos = this.State.Selection.StartPos;
        }
    } else {
        if (true === Selected && true !== this.State.Selection.Use) {
            EndPos = -1;
        }
    }
    for (var CurPos = StartPos; CurPos < EndPos; CurPos++) {
        var Item = this.Content[CurPos];
        if (para_End !== Item.Type) {
            NewRun.Add_ToContent(CurPos - StartPos, Item.Copy(), false);
        }
    }
    return NewRun;
};
ParaRun.prototype.Copy2 = function () {
    var NewRun = new ParaRun(this.Paragraph);
    NewRun.Set_Pr(this.Pr.Copy());
    var StartPos = 0;
    var EndPos = this.Content.length;
    for (var CurPos = StartPos; CurPos < EndPos; CurPos++) {
        var Item = this.Content[CurPos];
        NewRun.Add_ToContent(CurPos - StartPos, Item.Copy(), false);
    }
    return NewRun;
};
ParaRun.prototype.Get_AllDrawingObjects = function (DrawingObjs) {
    var Count = this.Content.length;
    for (var Index = 0; Index < Count; Index++) {
        var Item = this.Content[Index];
        if (para_Drawing === Item.Type) {
            DrawingObjs.push(Item);
        }
    }
};
ParaRun.prototype.Clear_ContentChanges = function () {
    this.m_oContentChanges.Clear();
};
ParaRun.prototype.Add_ContentChanges = function (Changes) {
    this.m_oContentChanges.Add(Changes);
};
ParaRun.prototype.Refresh_ContentChanges = function () {
    this.m_oContentChanges.Refresh();
};
ParaRun.prototype.Get_Text = function (Text) {
    if (null === Text.Text) {
        return;
    }
    var ContentLen = this.Content.length;
    for (var CurPos = 0; CurPos < ContentLen; CurPos++) {
        var Item = this.Content[CurPos];
        var ItemType = Item.Type;
        var bBreak = false;
        switch (ItemType) {
        case para_Drawing:
            case para_End:
            case para_PageNum:
            Text.Text = null;
            bBreak = true;
            break;
        case para_Text:
            Text.Text += String.fromCharCode(Item.Value);
            break;
        case para_Space:
            case para_Tab:
            Text.Text += " ";
            break;
        }
        if (true === bBreak) {
            break;
        }
    }
};
ParaRun.prototype.Is_Empty = function (Props) {
    var SkipAnchor = (undefined !== Props ? Props.SkipAnchor : false);
    var SkipEnd = (undefined !== Props ? Props.SkipEnd : false);
    var SkipPlcHldr = (undefined !== Props ? Props.SkipPlcHldr : false);
    var SkipNewLine = (undefined !== Props ? Props.SkipNewLine : false);
    var Count = this.Content.length;
    if (true !== SkipAnchor && true !== SkipEnd && true !== SkipPlcHldr && true !== SkipNewLine) {
        if (Count > 0) {
            return false;
        } else {
            return true;
        }
    } else {
        for (var CurPos = 0; CurPos < this.Content.length; CurPos++) {
            var Item = this.Content[CurPos];
            var ItemType = Item.Type;
            if ((true !== SkipAnchor || para_Drawing !== ItemType || false !== Item.Is_Inline()) && (true !== SkipEnd || para_End !== ItemType) && (true !== SkipPlcHldr || true !== Item.IsPlaceholder()) && (true !== SkipNewLine || para_NewLine !== ItemType)) {
                return false;
            }
        }
        return true;
    }
};
ParaRun.prototype.Is_CheckingNearestPos = function () {
    if (this.NearPosArray.length > 0) {
        return true;
    }
    return false;
};
ParaRun.prototype.Is_StartFromNewLine = function () {
    if (this.protected_GetLinesCount() < 2 || 0 !== this.protected_GetRangeStartPos(1, 0)) {
        return false;
    }
    return true;
};
ParaRun.prototype.Add = function (Item, bMath) {
    this.Add_ToContent(this.State.ContentPos, Item, true, bMath);
};
ParaRun.prototype.Remove = function (Direction, bOnAddText) {
    var Selection = this.State.Selection;
    if (true === Selection.Use) {
        var StartPos = Selection.StartPos;
        var EndPos = Selection.EndPos;
        if (StartPos > EndPos) {
            var Temp = StartPos;
            StartPos = EndPos;
            EndPos = Temp;
        }
        if (true === this.Selection_CheckParaEnd()) {
            for (var CurPos = EndPos - 1; CurPos >= StartPos; CurPos--) {
                if (para_End !== this.Content[CurPos].Type) {
                    this.Remove_FromContent(CurPos, 1, true);
                }
            }
        } else {
            this.Remove_FromContent(StartPos, EndPos - StartPos, true);
        }
        this.Selection_Remove();
        this.State.ContentPos = StartPos;
    } else {
        var CurPos = this.State.ContentPos;
        if (Direction < 0) {
            while (CurPos > 0 && para_Drawing === this.Content[CurPos - 1].Type && false === this.Content[CurPos - 1].Is_Inline()) {
                CurPos--;
            }
            if (CurPos <= 0) {
                return false;
            }
            if (para_Drawing == this.Content[CurPos - 1].Type && true === this.Content[CurPos - 1].Is_Inline()) {
                return this.Paragraph.Parent.Select_DrawingObject(this.Content[CurPos - 1].Get_Id());
            }
            this.Remove_FromContent(CurPos - 1, 1, true);
            this.State.ContentPos = CurPos - 1;
        } else {
            if (CurPos >= this.Content.length || para_End === this.Content[CurPos].Type) {
                return false;
            }
            if (para_Drawing == this.Content[CurPos].Type && true === this.Content[CurPos].Is_Inline()) {
                return this.Paragraph.Parent.Select_DrawingObject(this.Content[CurPos].Get_Id());
            }
            this.Remove_FromContent(CurPos, 1, true);
            this.State.ContentPos = CurPos;
        }
    }
    return true;
};
ParaRun.prototype.Remove_ParaEnd = function () {
    var Pos = -1;
    var ContentLen = this.Content.length;
    for (var CurPos = 0; CurPos < ContentLen; CurPos++) {
        if (para_End === this.Content[CurPos].Type) {
            Pos = CurPos;
            break;
        }
    }
    if (-1 === Pos) {
        return false;
    }
    this.Remove_FromContent(Pos, ContentLen - Pos, true);
    return true;
};
ParaRun.prototype.Add_ToContent = function (Pos, Item, UpdatePosition, bMath) {
    History.Add(this, {
        Type: historyitem_ParaRun_AddItem,
        Pos: Pos,
        EndPos: Pos,
        Items: [Item]
    });
    this.Content.splice(Pos, 0, Item);
    if (true === UpdatePosition) {
        if (this.State.ContentPos >= Pos) {
            this.State.ContentPos++;
        }
        if (true === this.State.Selection.Use) {
            if (this.State.Selection.StartPos >= Pos) {
                this.State.Selection.StartPos++;
            }
            if (this.State.Selection.EndPos >= Pos) {
                this.State.Selection.EndPos++;
            }
        }
        var LinesCount = this.protected_GetLinesCount();
        for (var CurLine = 0; CurLine < LinesCount; CurLine++) {
            var RangesCount = this.protected_GetRangesCount(CurLine);
            for (var CurRange = 0; CurRange < RangesCount; CurRange++) {
                var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
                var EndPos = this.protected_GetRangeEndPos(CurLine, CurRange);
                if (StartPos > Pos) {
                    StartPos++;
                }
                if (EndPos > Pos) {
                    EndPos++;
                }
                this.protected_FillRange(CurLine, CurRange, StartPos, EndPos);
            }
            if (Pos === this.Content.length - 1 && LinesCount - 1 === CurLine && !bMath) {
                this.protected_FillRangeEndPos(CurLine, RangesCount - 1, this.protected_GetRangeEndPos(CurLine, RangesCount - 1) + 1);
            }
        }
    }
    var NearPosLen = this.NearPosArray.length;
    for (var Index = 0; Index < NearPosLen; Index++) {
        var RunNearPos = this.NearPosArray[Index];
        var ContentPos = RunNearPos.NearPos.ContentPos;
        var Depth = RunNearPos.Depth;
        if (ContentPos.Data[Depth] >= Pos) {
            ContentPos.Data[Depth]++;
        }
    }
    var SearchMarksCount = this.SearchMarks.length;
    for (var Index = 0; Index < SearchMarksCount; Index++) {
        var Mark = this.SearchMarks[Index];
        var ContentPos = (true === Mark.Start ? Mark.SearchResult.StartPos : Mark.SearchResult.EndPos);
        var Depth = Mark.Depth;
        if (ContentPos.Data[Depth] >= Pos) {
            ContentPos.Data[Depth]++;
        }
    }
    var SpellingMarksCount = this.SpellingMarks.length;
    for (var Index = 0; Index < SpellingMarksCount; Index++) {
        var Mark = this.SpellingMarks[Index];
        var ContentPos = (true === Mark.Start ? Mark.Element.StartPos : Mark.Element.EndPos);
        var Depth = Mark.Depth;
        if (ContentPos.Data[Depth] >= Pos) {
            ContentPos.Data[Depth]++;
        }
    }
    this.protected_UpdateSpellChecking();
    this.CollaborativeMarks.Update_OnAdd(Pos);
    this.RecalcInfo.Measure = true;
};
ParaRun.prototype.Remove_FromContent = function (Pos, Count, UpdatePosition) {
    var DeletedItems = this.Content.slice(Pos, Pos + Count);
    History.Add(this, {
        Type: historyitem_Paragraph_RemoveItem,
        Pos: Pos,
        EndPos: Pos + Count - 1,
        Items: DeletedItems
    });
    this.Content.splice(Pos, Count);
    if (true === UpdatePosition) {
        if (this.State.ContentPos > Pos + Count) {
            this.State.ContentPos -= Count;
        } else {
            if (this.State.ContentPos > Pos) {
                this.State.ContentPos = Pos;
            }
        }
        if (true === this.State.Selection.Use) {
            if (this.State.Selection.StartPos <= this.State.Selection.EndPos) {
                if (this.State.Selection.StartPos > Pos + Count) {
                    this.State.Selection.StartPos -= Count;
                } else {
                    if (this.State.Selection.StartPos > Pos) {
                        this.State.Selection.StartPos = Pos;
                    }
                }
                if (this.State.Selection.EndPos >= Pos + Count) {
                    this.State.Selection.EndPos -= Count;
                } else {
                    if (this.State.Selection.EndPos > Pos) {
                        this.State.Selection.EndPos = Math.max(0, Pos - 1);
                    }
                }
            } else {
                if (this.State.Selection.StartPos >= Pos + Count) {
                    this.State.Selection.StartPos -= Count;
                } else {
                    if (this.State.Selection.StartPos > Pos) {
                        this.State.Selection.StartPos = Math.max(0, Pos - 1);
                    }
                }
                if (this.State.Selection.EndPos > Pos + Count) {
                    this.State.Selection.EndPos -= Count;
                } else {
                    if (this.State.Selection.EndPos > Pos) {
                        this.State.Selection.EndPos = Pos;
                    }
                }
            }
        }
        var LinesCount = this.protected_GetLinesCount();
        for (var CurLine = 0; CurLine < LinesCount; CurLine++) {
            var RangesCount = this.protected_GetRangesCount(CurLine);
            for (var CurRange = 0; CurRange < RangesCount; CurRange++) {
                var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
                var EndPos = this.protected_GetRangeEndPos(CurLine, CurRange);
                if (StartPos > Pos + Count) {
                    StartPos -= Count;
                } else {
                    if (StartPos > Pos) {
                        StartPos = Math.max(0, Pos);
                    }
                }
                if (EndPos >= Pos + Count) {
                    EndPos -= Count;
                } else {
                    if (EndPos >= Pos) {
                        EndPos = Math.max(0, Pos);
                    }
                }
                this.protected_FillRange(CurLine, CurRange, StartPos, EndPos);
            }
        }
    }
    var NearPosLen = this.NearPosArray.length;
    for (var Index = 0; Index < NearPosLen; Index++) {
        var RunNearPos = this.NearPosArray[Index];
        var ContentPos = RunNearPos.NearPos.ContentPos;
        var Depth = RunNearPos.Depth;
        if (ContentPos.Data[Depth] > Pos + Count) {
            ContentPos.Data[Depth] -= Count;
        } else {
            if (ContentPos.Data[Depth] > Pos) {
                ContentPos.Data[Depth] = Math.max(0, Pos);
            }
        }
    }
    var SearchMarksCount = this.SearchMarks.length;
    for (var Index = 0; Index < SearchMarksCount; Index++) {
        var Mark = this.SearchMarks[Index];
        var ContentPos = (true === Mark.Start ? Mark.SearchResult.StartPos : Mark.SearchResult.EndPos);
        var Depth = Mark.Depth;
        if (ContentPos.Data[Depth] > Pos + Count) {
            ContentPos.Data[Depth] -= Count;
        } else {
            if (ContentPos.Data[Depth] > Pos) {
                ContentPos.Data[Depth] = Math.max(0, Pos);
            }
        }
    }
    var SpellingMarksCount = this.SpellingMarks.length;
    for (var Index = 0; Index < SpellingMarksCount; Index++) {
        var Mark = this.SpellingMarks[Index];
        var ContentPos = (true === Mark.Start ? Mark.Element.StartPos : Mark.Element.EndPos);
        var Depth = Mark.Depth;
        if (ContentPos.Data[Depth] > Pos + Count) {
            ContentPos.Data[Depth] -= Count;
        } else {
            if (ContentPos.Data[Depth] > Pos) {
                ContentPos.Data[Depth] = Math.max(0, Pos);
            }
        }
    }
    this.protected_UpdateSpellChecking();
    this.CollaborativeMarks.Update_OnRemove(Pos, Count);
    this.RecalcInfo.Measure = true;
};
ParaRun.prototype.Concat_ToContent = function (NewItems) {
    var StartPos = this.Content.length;
    this.Content = this.Content.concat(NewItems);
    History.Add(this, {
        Type: historyitem_ParaRun_AddItem,
        Pos: StartPos,
        EndPos: this.Content.length - 1,
        Items: NewItems,
        Color: false
    });
    this.RecalcInfo.Measure = true;
};
ParaRun.prototype.Get_CurrentParaPos = function () {
    var Pos = this.State.ContentPos;
    if (-1 === this.StartLine) {
        return new CParaPos(-1, -1, -1, -1);
    }
    var CurLine = 0;
    var CurRange = 0;
    var LinesCount = this.protected_GetLinesCount();
    for (; CurLine < LinesCount; CurLine++) {
        var RangesCount = this.protected_GetRangesCount(CurLine);
        for (CurRange = 0; CurRange < RangesCount; CurRange++) {
            var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
            var EndPos = this.protected_GetRangeEndPos(CurLine, CurRange);
            if (Pos < EndPos && Pos >= StartPos) {
                return new CParaPos((CurLine === 0 ? CurRange + this.StartRange : CurRange), CurLine + this.StartLine, 0, 0);
            }
        }
    }
    return new CParaPos((LinesCount <= 1 ? this.protected_GetRangesCount(0) - 1 + this.StartRange : this.protected_GetRangesCount(LinesCount - 1) - 1), LinesCount - 1 + this.StartLine, 0, 0);
};
ParaRun.prototype.Get_ParaPosByContentPos = function (ContentPos, Depth) {
    var Pos = ContentPos.Get(Depth);
    var CurLine = 0;
    var CurRange = 0;
    var LinesCount = this.protected_GetLinesCount();
    for (; CurLine < LinesCount; CurLine++) {
        var RangesCount = this.protected_GetRangesCount(CurLine);
        for (CurRange = 0; CurRange < RangesCount; CurRange++) {
            var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
            var EndPos = this.protected_GetRangeEndPos(CurLine, CurRange);
            if (Pos < EndPos && Pos >= StartPos) {
                return new CParaPos((CurLine === 0 ? CurRange + this.StartRange : CurRange), CurLine + this.StartLine, 0, 0);
            }
        }
    }
    return new CParaPos((LinesCount === 1 ? this.protected_GetRangesCount(0) - 1 + this.StartRange : this.protected_GetRangesCount(0) - 1), LinesCount - 1 + this.StartLine, 0, 0);
};
ParaRun.prototype.Recalculate_CurPos = function (X, Y, CurrentRun, _CurRange, _CurLine, CurPage, UpdateCurPos, UpdateTarget, ReturnTarget, PointsInfo) {
    var Para = this.Paragraph;
    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);
    var Pos = StartPos;
    var _EndPos = (true === CurrentRun ? Math.min(EndPos, this.State.ContentPos) : EndPos);
    for (; Pos < _EndPos; Pos++) {
        var Item = this.Content[Pos];
        var ItemType = Item.Type;
        switch (ItemType) {
        case para_Text:
            case para_Space:
            case para_Sym:
            case para_PageNum:
            case para_Tab:
            case para_End:
            case para_NewLine:
            case para_Math_Text:
            case para_Math_Placeholder:
            case para_Math_Ampersand:
            X += Item.Get_WidthVisible();
            break;
        case para_Drawing:
            if (drawing_Inline != Item.DrawingType) {
                break;
            }
            X += Item.Get_WidthVisible();
            break;
        }
    }
    if (true === CurrentRun && Pos === this.State.ContentPos) {
        if (true === UpdateCurPos) {
            Para.CurPos.X = X;
            Para.CurPos.Y = Y;
            Para.CurPos.PagesPos = CurPage;
            if (true === UpdateTarget) {
                var CurTextPr = this.Get_CompiledPr(false);
                g_oTextMeasurer.SetTextPr(CurTextPr, this.Paragraph.Get_Theme());
                g_oTextMeasurer.SetFontSlot(fontslot_ASCII, CurTextPr.Get_FontKoef());
                var Height = g_oTextMeasurer.GetHeight();
                var Descender = Math.abs(g_oTextMeasurer.GetDescender());
                var Ascender = Height - Descender;
                Para.DrawingDocument.SetTargetSize(Height);
                var RGBA;
                if (CurTextPr.Unifill) {
                    CurTextPr.Unifill.check(Para.Get_Theme(), Para.Get_ColorMap());
                    RGBA = CurTextPr.Unifill.getRGBAColor();
                    Para.DrawingDocument.SetTargetColor(RGBA.R, RGBA.G, RGBA.B);
                } else {
                    if (true === CurTextPr.Color.Auto) {
                        var Pr = Para.Get_CompiledPr();
                        var BgColor = undefined;
                        if (undefined !== Pr.ParaPr.Shd && shd_Nil !== Pr.ParaPr.Shd.Value) {
                            if (Pr.ParaPr.Shd.Unifill) {
                                Pr.ParaPr.Shd.Unifill.check(this.Paragraph.Get_Theme(), this.Paragraph.Get_ColorMap());
                                var RGBA = Pr.ParaPr.Shd.Unifill.getRGBAColor();
                                BgColor = new CDocumentColor(RGBA.R, RGBA.G, RGBA.B, false);
                            } else {
                                BgColor = Pr.ParaPr.Shd.Color;
                            }
                        } else {
                            BgColor = Para.Parent.Get_TextBackGroundColor();
                            if (undefined !== CurTextPr.Shd && shd_Nil !== CurTextPr.Shd.Value) {
                                BgColor = CurTextPr.Shd.Get_Color(this.Paragraph);
                            }
                        }
                        var AutoColor = (undefined != BgColor && false === BgColor.Check_BlackAutoColor() ? new CDocumentColor(255, 255, 255, false) : new CDocumentColor(0, 0, 0, false));
                        Para.DrawingDocument.SetTargetColor(AutoColor.r, AutoColor.g, AutoColor.b);
                    } else {
                        Para.DrawingDocument.SetTargetColor(CurTextPr.Color.r, CurTextPr.Color.g, CurTextPr.Color.b);
                    }
                }
                var TargetY = Y - Ascender - CurTextPr.Position;
                switch (CurTextPr.VertAlign) {
                case vertalign_SubScript:
                    TargetY -= CurTextPr.FontSize * g_dKoef_pt_to_mm * vertalign_Koef_Sub;
                    break;
                case vertalign_SuperScript:
                    TargetY -= CurTextPr.FontSize * g_dKoef_pt_to_mm * vertalign_Koef_Super;
                    break;
                }
                var Page_Abs = Para.Get_StartPage_Absolute() + CurPage;
                Para.DrawingDocument.UpdateTarget(X, TargetY, Page_Abs);
                if (undefined != Para.Get_FramePr()) {
                    var __Y0 = TargetY,
                    __Y1 = TargetY + Height;
                    var ___Y0 = Para.Pages[CurPage].Y + Para.Lines[CurLine].Top;
                    var ___Y1 = Para.Pages[CurPage].Y + Para.Lines[CurLine].Bottom;
                    __Y0 = Math.max(__Y0, ___Y0);
                    __Y1 = Math.min(__Y1, ___Y1);
                    Para.DrawingDocument.SetTargetSize(__Y1 - __Y0);
                    Para.DrawingDocument.UpdateTarget(X, __Y0, Page_Abs);
                }
                if (para_Math_Run === this.Type && null !== this.Parent && true !== this.Parent.bRoot) {
                    var oBounds = this.Parent.Get_Bounds();
                    var __Y0 = TargetY,
                    __Y1 = TargetY + Height;
                    var ___Y0 = oBounds.Y - 0.2 * oBounds.H;
                    var ___Y1 = oBounds.Y + 1.4 * oBounds.H;
                    __Y0 = Math.max(__Y0, ___Y0);
                    __Y1 = Math.min(__Y1, ___Y1);
                    Para.DrawingDocument.SetTargetSize(__Y1 - __Y0);
                    Para.DrawingDocument.UpdateTarget(X, __Y0, Page_Abs);
                }
            }
        }
        if (true === ReturnTarget) {
            var CurTextPr = this.Get_CompiledPr(false);
            g_oTextMeasurer.SetTextPr(CurTextPr, this.Paragraph.Get_Theme());
            g_oTextMeasurer.SetFontSlot(fontslot_ASCII, CurTextPr.Get_FontKoef());
            var Height = g_oTextMeasurer.GetHeight();
            var Descender = Math.abs(g_oTextMeasurer.GetDescender());
            var Ascender = Height - Descender;
            var TargetY = Y - Ascender - CurTextPr.Position;
            switch (CurTextPr.VertAlign) {
            case vertalign_SubScript:
                TargetY -= CurTextPr.FontSize * g_dKoef_pt_to_mm * vertalign_Koef_Sub;
                break;
            case vertalign_SuperScript:
                TargetY -= CurTextPr.FontSize * g_dKoef_pt_to_mm * vertalign_Koef_Super;
                break;
            }
            return {
                X: X,
                Y: TargetY,
                Height: Height,
                Internal: {
                    Line: CurLine,
                    Page: CurPage,
                    Range: CurRange
                }
            };
        } else {
            return {
                X: X,
                Y: Y,
                PageNum: CurPage + Para.Get_StartPage_Absolute(),
                Internal: {
                    Line: CurLine,
                    Page: CurPage,
                    Range: CurRange
                }
            };
        }
    }
    return {
        X: X,
        Y: Y,
        Internal: {
            Line: CurLine,
            Page: CurPage,
            Range: CurRange
        }
    };
};
ParaRun.prototype.Is_SimpleChanges = function (Changes) {
    if (para_Math_Run === this.Type) {
        return false;
    }
    var ParaPos = null;
    var Count = Changes.length;
    for (var Index = 0; Index < Count; Index++) {
        var Data = Changes[Index].Data;
        if (undefined === Data.Items || 1 !== Data.Items.length) {
            return false;
        }
        var Type = Data.Type;
        var Item = Data.Items[0];
        if (undefined === Item) {
            return false;
        }
        if (historyitem_ParaRun_AddItem !== Type && historyitem_ParaRun_RemoveItem !== Type) {
            return false;
        }
        var ItemType = Item.Type;
        if (para_Drawing === ItemType || para_NewLine === ItemType) {
            return false;
        }
        var CurParaPos = this.Get_SimpleChanges_ParaPos([Changes[Index]]);
        if (null === CurParaPos) {
            return false;
        }
        if (null === ParaPos) {
            ParaPos = CurParaPos;
        } else {
            if (ParaPos.Line !== CurParaPos.Line || ParaPos.Range !== CurParaPos.Range) {
                return false;
            }
        }
    }
    return true;
};
ParaRun.prototype.Get_SimpleChanges_ParaPos = function (Changes) {
    var Change = Changes[0].Data;
    var Type = Changes[0].Data.Type;
    var Pos = Change.Pos;
    var CurLine = 0;
    var CurRange = 0;
    var LinesCount = this.protected_GetLinesCount();
    for (; CurLine < LinesCount; CurLine++) {
        var RangesCount = this.protected_GetRangesCount(CurLine);
        for (CurRange = 0; CurRange < RangesCount; CurRange++) {
            var RangeStartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
            var RangeEndPos = this.protected_GetRangeEndPos(CurLine, CurRange);
            if ((historyitem_ParaRun_AddItem === Type && Pos < RangeEndPos && Pos >= RangeStartPos) || (historyitem_ParaRun_RemoveItem === Type && Pos < RangeEndPos && Pos >= RangeStartPos) || (historyitem_ParaRun_RemoveItem === Type && Pos >= RangeEndPos && CurLine === LinesCount - 1 && CurRange === RangesCount - 1)) {
                if (RangeStartPos === RangeEndPos) {
                    return null;
                }
                return new CParaPos((CurLine === 0 ? CurRange + this.StartRange : CurRange), CurLine + this.StartLine, 0, 0);
            }
        }
    }
    if (this.protected_GetRangeStartPos(0, 0) === this.protected_GetRangeEndPos(0, 0)) {
        return null;
    }
    return new CParaPos(this.StartRange, this.StartLine, 0, 0);
};
ParaRun.prototype.Split = function (ContentPos, Depth) {
    var CurPos = ContentPos.Get(Depth);
    return this.Split2(CurPos);
};
ParaRun.prototype.Split2 = function (CurPos) {
    var bMathRun = this.Type == para_Math_Run;
    var NewRun = new ParaRun(this.Paragraph, bMathRun);
    NewRun.Set_Pr(this.Pr.Copy());
    if (bMathRun) {
        NewRun.Set_MathPr(this.MathPrp.Copy());
    }
    var CheckEndPos = -1;
    var CheckEndPos2 = Math.min(CurPos, this.Content.length);
    for (var Pos = 0; Pos < CheckEndPos2; Pos++) {
        if (para_End === this.Content[Pos].Type) {
            CheckEndPos = Pos;
            break;
        }
    }
    if (-1 !== CheckEndPos) {
        CurPos = CheckEndPos;
    }
    NewRun.Concat_ToContent(this.Content.slice(CurPos));
    this.Remove_FromContent(CurPos, this.Content.length - CurPos, true);
    var SpellingMarksCount = this.SpellingMarks.length;
    for (var Index = 0; Index < SpellingMarksCount; Index++) {
        var Mark = this.SpellingMarks[Index];
        var MarkPos = (true === Mark.Start ? Mark.Element.StartPos.Get(Mark.Depth) : Mark.Element.EndPos.Get(Mark.Depth));
        if (MarkPos >= CurPos) {
            var MarkElement = Mark.Element;
            if (true === Mark.Start) {
                MarkElement.StartPos.Data[Mark.Depth] -= CurPos;
            } else {
                MarkElement.EndPos.Data[Mark.Depth] -= CurPos;
            }
            NewRun.SpellingMarks.push(Mark);
            this.SpellingMarks.splice(Index, 1);
            SpellingMarksCount--;
            Index--;
        }
    }
    return NewRun;
};
ParaRun.prototype.Check_NearestPos = function (ParaNearPos, Depth) {
    var RunNearPos = new CParagraphElementNearPos();
    RunNearPos.NearPos = ParaNearPos.NearPos;
    RunNearPos.Depth = Depth;
    this.NearPosArray.push(RunNearPos);
    ParaNearPos.Classes.push(this);
};
ParaRun.prototype.Get_DrawingObjectRun = function (Id) {
    var ContentLen = this.Content.length;
    for (var CurPos = 0; CurPos < ContentLen; CurPos++) {
        var Element = this.Content[CurPos];
        if (para_Drawing === Element.Type && Id === Element.Get_Id()) {
            return this;
        }
    }
    return null;
};
ParaRun.prototype.Get_DrawingObjectContentPos = function (Id, ContentPos, Depth) {
    var ContentLen = this.Content.length;
    for (var CurPos = 0; CurPos < ContentLen; CurPos++) {
        var Element = this.Content[CurPos];
        if (para_Drawing === Element.Type && Id === Element.Get_Id()) {
            ContentPos.Update(CurPos, Depth);
            return true;
        }
    }
    return false;
};
ParaRun.prototype.Remove_DrawingObject = function (Id) {
    var ContentLen = this.Content.length;
    for (var CurPos = 0; CurPos < ContentLen; CurPos++) {
        var Element = this.Content[CurPos];
        if (para_Drawing === Element.Type && Id === Element.Get_Id()) {
            this.Remove_FromContent(CurPos, 1, true);
            return;
        }
    }
};
ParaRun.prototype.Get_Layout = function (DrawingLayout, UseContentPos, ContentPos, Depth) {
    var CurLine = DrawingLayout.Line - this.StartLine;
    var CurRange = (0 === CurLine ? DrawingLayout.Range - this.StartRange : DrawingLayout.Range);
    var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
    var EndPos = this.protected_GetRangeEndPos(CurLine, CurRange);
    var CurContentPos = (true === UseContentPos ? ContentPos.Get(Depth) : -1);
    var CurPos = StartPos;
    for (; CurPos < EndPos; CurPos++) {
        if (CurContentPos === CurPos) {
            break;
        }
        var Item = this.Content[CurPos];
        var ItemType = Item.Type;
        var WidthVisible = Item.Get_WidthVisible();
        switch (ItemType) {
        case para_Text:
            case para_Space:
            case para_PageNum:
            DrawingLayout.LastW = WidthVisible;
            break;
        case para_Drawing:
            if (true === Item.Is_Inline() || true === DrawingLayout.Paragraph.Parent.Is_DrawingShape()) {
                DrawingLayout.LastW = WidthVisible;
            }
            break;
        }
        DrawingLayout.X += WidthVisible;
    }
    if (CurContentPos === CurPos) {
        DrawingLayout.Layout = true;
    }
};
ParaRun.prototype.Get_NextRunElements = function (RunElements, UseContentPos, Depth) {
    var StartPos = (true === UseContentPos ? RunElements.ContentPos.Get(Depth) : 0);
    var ContentLen = this.Content.length;
    for (var CurPos = StartPos; CurPos < ContentLen; CurPos++) {
        var Item = this.Content[CurPos];
        var ItemType = Item.Type;
        if (para_Text === ItemType || para_Space === ItemType || para_Tab === ItemType) {
            RunElements.Elements.push(Item);
            RunElements.Count--;
            if (RunElements.Count <= 0) {
                return;
            }
        }
    }
};
ParaRun.prototype.Get_PrevRunElements = function (RunElements, UseContentPos, Depth) {
    var StartPos = (true === UseContentPos ? RunElements.ContentPos.Get(Depth) - 1 : this.Content.length - 1);
    var ContentLen = this.Content.length;
    for (var CurPos = StartPos; CurPos >= 0; CurPos--) {
        var Item = this.Content[CurPos];
        var ItemType = Item.Type;
        if (para_Text === ItemType || para_Space === ItemType || para_Tab === ItemType) {
            RunElements.Elements.push(Item);
            RunElements.Count--;
            if (RunElements.Count <= 0) {
                return;
            }
        }
    }
};
ParaRun.prototype.Collect_DocumentStatistics = function (ParaStats) {
    var Count = this.Content.length;
    for (var Index = 0; Index < Count; Index++) {
        var Item = this.Content[Index];
        var ItemType = Item.Type;
        var bSymbol = false;
        var bSpace = false;
        var bNewWord = false;
        if ((para_Text === ItemType && false === Item.Is_NBSP()) || (para_PageNum === ItemType)) {
            if (false === ParaStats.Word) {
                bNewWord = true;
            }
            bSymbol = true;
            bSpace = false;
            ParaStats.Word = true;
            ParaStats.EmptyParagraph = false;
        } else {
            if ((para_Text === ItemType && true === Item.Is_NBSP()) || para_Space === ItemType || para_Tab === ItemType) {
                bSymbol = true;
                bSpace = true;
                ParaStats.Word = false;
            }
        }
        if (true === bSymbol) {
            ParaStats.Stats.Add_Symbol(bSpace);
        }
        if (true === bNewWord) {
            ParaStats.Stats.Add_Word();
        }
    }
};
ParaRun.prototype.Create_FontMap = function (Map, ArgSize) {
    if (undefined !== this.Paragraph && null !== this.Paragraph) {
        var TextPr;
        var FontSize, FontSizeCS;
        if (this.Type === para_Math_Run) {
            TextPr = this.Get_CompiledPr(false);
            FontSize = TextPr.FontSize;
            FontSizeCS = TextPr.FontSizeCS;
            if (null !== this.Parent && undefined !== this.Parent && null !== this.Parent.ParaMath && undefined !== this.Parent.ParaMath) {
                TextPr.FontSize *= MatGetKoeffArgSize(TextPr.FontSize, ArgSize.value);
                TextPr.FontSizeCS *= MatGetKoeffArgSize(TextPr.FontSizeCS, ArgSize.value);
            }
        } else {
            TextPr = this.Get_CompiledPr(false);
        }
        TextPr.Document_CreateFontMap(Map, this.Paragraph.Get_Theme().themeElements.fontScheme);
        var Count = this.Content.length;
        for (var Index = 0; Index < Count; Index++) {
            var Item = this.Content[Index];
            if (para_Drawing === Item.Type) {
                Item.documentCreateFontMap(Map);
            }
        }
        if (this.Type === para_Math_Run) {
            TextPr.FontSize = FontSize;
            TextPr.FontSizeCS = FontSizeCS;
        }
    }
};
ParaRun.prototype.Get_AllFontNames = function (AllFonts) {
    this.Pr.Document_Get_AllFontNames(AllFonts);
    var Count = this.Content.length;
    for (var Index = 0; Index < Count; Index++) {
        var Item = this.Content[Index];
        if (para_Drawing === Item.Type) {
            Item.documentGetAllFontNames(AllFonts);
        }
    }
};
ParaRun.prototype.Get_SelectedText = function (bAll, bClearText) {
    var StartPos = 0;
    var EndPos = 0;
    if (true === bAll) {
        StartPos = 0;
        EndPos = this.Content.length;
    } else {
        if (true === this.Selection.Use) {
            StartPos = this.State.Selection.StartPos;
            EndPos = this.State.Selection.EndPos;
            if (StartPos > EndPos) {
                var Temp = EndPos;
                EndPos = StartPos;
                StartPos = Temp;
            }
        }
    }
    var Str = "";
    for (var Pos = StartPos; Pos < EndPos; Pos++) {
        var Item = this.Content[Pos];
        var ItemType = Item.Type;
        switch (ItemType) {
        case para_Drawing:
            case para_Numbering:
            case para_PresentationNumbering:
            case para_PageNum:
            if (true === bClearText) {
                return null;
            }
            break;
        case para_Text:
            Str += String.fromCharCode(Item.Value);
            break;
        case para_Space:
            case para_Tab:
            Str += " ";
            break;
        }
    }
    return Str;
};
ParaRun.prototype.Get_SelectionDirection = function () {
    if (true !== this.Selection.Use) {
        return 0;
    }
    if (this.Selection.StartPos <= this.Selection.EndPos) {
        return 1;
    }
    return -1;
};
ParaRun.prototype.Can_AddDropCap = function () {
    var Count = this.Content.length;
    for (var Pos = 0; Pos < Count; Pos++) {
        var Item = this.Content[Pos];
        var ItemType = Item.Type;
        switch (ItemType) {
        case para_Text:
            return true;
        case para_Space:
            case para_Tab:
            case para_PageNum:
            return false;
        }
    }
    return null;
};
ParaRun.prototype.Get_TextForDropCap = function (DropCapText, UseContentPos, ContentPos, Depth) {
    var EndPos = (true === UseContentPos ? ContentPos.Get(Depth) : this.Content.length);
    for (var Pos = 0; Pos < EndPos; Pos++) {
        var Item = this.Content[Pos];
        var ItemType = Item.Type;
        if (true === DropCapText.Check) {
            if (para_Space === ItemType || para_Tab === ItemType || para_PageNum === ItemType || para_Drawing === ItemType) {
                DropCapText.Mixed = true;
                return;
            }
        } else {
            if (para_Text === ItemType) {
                DropCapText.Runs.push(this);
                DropCapText.Text.push(Item);
                this.Remove_FromContent(Pos, 1, true);
                Pos--;
                EndPos--;
                if (true === DropCapText.Mixed) {
                    return;
                }
            }
        }
    }
};
ParaRun.prototype.Get_StartTabsCount = function (TabsCounter) {
    var ContentLen = this.Content.length;
    for (var Pos = 0; Pos < ContentLen; Pos++) {
        var Item = this.Content[Pos];
        var ItemType = Item.Type;
        if (para_Tab === ItemType) {
            TabsCounter.Count++;
            TabsCounter.Pos.push(Pos);
        } else {
            if (para_Text === ItemType || para_Space === ItemType || (para_Drawing === ItemType && true === Item.Is_Inline()) || para_PageNum === ItemType || para_Math === ItemType) {
                return false;
            }
        }
    }
    return true;
};
ParaRun.prototype.Remove_StartTabs = function (TabsCounter) {
    var ContentLen = this.Content.length;
    for (var Pos = 0; Pos < ContentLen; Pos++) {
        var Item = this.Content[Pos];
        var ItemType = Item.Type;
        if (para_Tab === ItemType) {
            this.Remove_FromContent(Pos, 1, true);
            TabsCounter.Count--;
            Pos--;
            ContentLen--;
        } else {
            if (para_Text === ItemType || para_Space === ItemType || (para_Drawing === ItemType && true === Item.Is_Inline()) || para_PageNum === ItemType || para_Math === ItemType) {
                return false;
            }
        }
    }
    return true;
};
ParaRun.prototype.Recalculate_MeasureContent = function () {
    if (false === this.RecalcInfo.Measure) {
        return;
    }
    var Pr = this.Get_CompiledPr(false);
    var Theme = this.Paragraph.Get_Theme();
    g_oTextMeasurer.SetTextPr(Pr, Theme);
    g_oTextMeasurer.SetFontSlot(fontslot_ASCII);
    this.TextHeight = g_oTextMeasurer.GetHeight();
    this.TextDescent = Math.abs(g_oTextMeasurer.GetDescender());
    this.TextAscent = this.TextHeight - this.TextDescent;
    this.TextAscent2 = g_oTextMeasurer.GetAscender();
    this.YOffset = Pr.Position;
    var ContentLength = this.Content.length;
    for (var Pos = 0; Pos < ContentLength; Pos++) {
        var Item = this.Content[Pos];
        var ItemType = Item.Type;
        if (para_Drawing === ItemType) {
            Item.Parent = this.Paragraph;
            Item.DocumentContent = this.Paragraph.Parent;
            Item.DrawingDocument = this.Paragraph.Parent.DrawingDocument;
        }
        if (para_End === ItemType) {
            var EndTextPr = this.Paragraph.Get_CompiledPr2(false).TextPr.Copy();
            EndTextPr.Merge(this.Paragraph.TextPr.Value);
            g_oTextMeasurer.SetTextPr(EndTextPr, this.Paragraph.Get_Theme());
            Item.Measure(g_oTextMeasurer, EndTextPr);
            continue;
        }
        Item.Measure(g_oTextMeasurer, Pr);
        if (para_Drawing === Item.Type) {
            g_oTextMeasurer.SetTextPr(Pr, Theme);
            g_oTextMeasurer.SetFontSlot(fontslot_ASCII);
        }
    }
    this.RecalcInfo.Recalc = true;
    this.RecalcInfo.Measure = false;
};
ParaRun.prototype.Recalculate_Measure2 = function (Metrics) {
    var TAscent = Metrics.Ascent;
    var TDescent = Metrics.Descent;
    var Count = this.Content.length;
    for (var Index = 0; Index < Count; Index++) {
        var Item = this.Content[Index];
        var ItemType = Item.Type;
        if (para_Text === ItemType) {
            var Temp = g_oTextMeasurer.Measure2(String.fromCharCode(Item.Value));
            if (null === TAscent || TAscent < Temp.Ascent) {
                TAscent = Temp.Ascent;
            }
            if (null === TDescent || TDescent > Temp.Ascent - Temp.Height) {
                TDescent = Temp.Ascent - Temp.Height;
            }
        }
    }
    Metrics.Ascent = TAscent;
    Metrics.Descent = TDescent;
};
ParaRun.prototype.Recalculate_Range = function (PRS, ParaPr, Depth) {
    if (this.Paragraph !== PRS.Paragraph) {
        this.Paragraph = PRS.Paragraph;
        this.RecalcInfo.TextPr = true;
        this.RecalcInfo.Measure = true;
        this.protected_UpdateSpellChecking();
    }
    this.Recalculate_MeasureContent();
    var CurLine = PRS.Line - this.StartLine;
    var CurRange = (0 === CurLine ? PRS.Range - this.StartRange : PRS.Range);
    if (0 === CurRange && 0 === CurLine) {
        var PrevRecalcInfo = PRS.RunRecalcInfoLast;
        if (null === PrevRecalcInfo) {
            this.RecalcInfo.NumberingAdd = true;
        } else {
            this.RecalcInfo.NumberingAdd = PrevRecalcInfo.NumberingAdd;
        }
        this.RecalcInfo.NumberingUse = false;
        this.RecalcInfo.NumberingItem = null;
    }
    PRS.RunRecalcInfoLast = this.RecalcInfo;
    var RangeStartPos = this.protected_AddRange(CurLine, CurRange);
    var RangeEndPos = 0;
    var Para = PRS.Paragraph;
    var MoveToLBP = PRS.MoveToLBP;
    var NewRange = PRS.NewRange;
    var ForceNewPage = PRS.ForceNewPage;
    var NewPage = PRS.NewPage;
    var BreakPageLine = PRS.BreakPageLine;
    var End = PRS.End;
    var Word = PRS.Word;
    var StartWord = PRS.StartWord;
    var FirstItemOnLine = PRS.FirstItemOnLine;
    var EmptyLine = PRS.EmptyLine;
    var RangesCount = PRS.RangesCount;
    var SpaceLen = PRS.SpaceLen;
    var WordLen = PRS.WordLen;
    var X = PRS.X;
    var XEnd = PRS.XEnd;
    var ParaLine = PRS.Line;
    var ParaRange = PRS.Range;
    var LineRule = ParaPr.Spacing.LineRule;
    var Pos = RangeStartPos;
    var UpdateLineMetricsText = false;
    var ContentLen = this.Content.length;
    if (false === StartWord && true === FirstItemOnLine && XEnd - X < 0.001 && RangesCount > 0) {
        NewRange = true;
        RangeEndPos = Pos;
    } else {
        for (; Pos < ContentLen; Pos++) {
            var Item = this.Content[Pos];
            var ItemType = Item.Type;
            if (true === this.RecalcInfo.NumberingAdd && true === Item.Can_AddNumbering()) {
                var TempRes = this.Internal_Recalculate_Numbering(Item, PRS.Paragraph, ParaPr, X, PRS.LineAscent, PRS.Page, PRS.Line, PRS.Range);
                X = TempRes.X;
                PRS.LineAscent = TempRes.LineAscent;
            }
            switch (ItemType) {
            case para_Sym:
                case para_Text:
                StartWord = true;
                UpdateLineMetricsText = true;
                var LetterLen = Item.Width / TEXTWIDTH_DIVIDER;
                if (true !== Word) {
                    if (true !== FirstItemOnLine || false === Para.Internal_Check_Ranges(ParaLine, ParaRange)) {
                        if (X + SpaceLen + LetterLen > XEnd) {
                            NewRange = true;
                            RangeEndPos = Pos;
                        }
                    }
                    if (true !== NewRange) {
                        PRS.Set_LineBreakPos(Pos);
                        WordLen = LetterLen;
                        Word = true;
                    }
                } else {
                    if (X + SpaceLen + WordLen + LetterLen > XEnd) {
                        if (true === FirstItemOnLine) {
                            if (false === Para.Internal_Check_Ranges(ParaLine, ParaRange)) {
                                MoveToLBP = true;
                                NewRange = true;
                            } else {
                                EmptyLine = false;
                                X += WordLen;
                                NewRange = true;
                                RangeEndPos = Pos;
                            }
                        } else {
                            MoveToLBP = true;
                            NewRange = true;
                        }
                    }
                    if (true !== NewRange) {
                        WordLen += LetterLen;
                        if (Item.Flags & PARATEXT_FLAGS_SPACEAFTER) {
                            X += SpaceLen + WordLen;
                            Word = false;
                            FirstItemOnLine = false;
                            EmptyLine = false;
                            SpaceLen = 0;
                            WordLen = 0;
                        }
                    }
                }
                break;
            case para_Space:
                FirstItemOnLine = false;
                if (true === Word) {
                    X += SpaceLen + WordLen;
                    Word = false;
                    EmptyLine = false;
                    SpaceLen = 0;
                    WordLen = 0;
                }
                SpaceLen += Item.Width / TEXTWIDTH_DIVIDER;
                break;
            case para_Drawing:
                if (true === Item.Is_Inline() || true === Para.Parent.Is_DrawingShape()) {
                    if (true !== Item.Is_Inline()) {
                        Item.Set_DrawingType(drawing_Inline);
                    }
                    if (true === StartWord) {
                        FirstItemOnLine = false;
                    }
                    Item.YOffset = this.YOffset;
                    if (true === Word || WordLen > 0) {
                        X += SpaceLen + WordLen;
                        Word = false;
                        EmptyLine = false;
                        SpaceLen = 0;
                        WordLen = 0;
                    }
                    var DrawingWidth = Item.Get_Width();
                    if (X + SpaceLen + DrawingWidth > XEnd && (false === FirstItemOnLine || false === Para.Internal_Check_Ranges(ParaLine, ParaRange))) {
                        NewRange = true;
                        RangeEndPos = Pos;
                    } else {
                        if (linerule_Exact === LineRule) {
                            if (PRS.LineAscent < Item.Height) {
                                PRS.LineAscent = Item.Height;
                            }
                        } else {
                            if (PRS.LineAscent < Item.Height + this.YOffset) {
                                PRS.LineAscent = Item.Height + this.YOffset;
                            }
                            if (PRS.LineDescent < -this.YOffset) {
                                PRS.LineDescent = -this.YOffset;
                            }
                        }
                        X += SpaceLen + DrawingWidth;
                        FirstItemOnLine = false;
                        EmptyLine = false;
                    }
                    SpaceLen = 0;
                } else {
                    var LogicDocument = Para.Parent;
                    var LDRecalcInfo = LogicDocument.RecalcInfo;
                    var DrawingObjects = LogicDocument.DrawingObjects;
                    var CurPage = PRS.Page;
                    if (true === LDRecalcInfo.Check_FlowObject(Item) && true === LDRecalcInfo.Is_PageBreakBefore()) {
                        LDRecalcInfo.Reset();
                        if (null != Para.Get_DocumentPrev() && true != Para.Parent.Is_TableCellContent() && 0 === CurPage) {
                            Para.Recalculate_Drawing_AddPageBreak(0, 0, true);
                            PRS.RecalcResult = recalcresult_NextPage;
                            PRS.NewRange = true;
                            return;
                        } else {
                            if (ParaLine != Para.Pages[CurPage].FirstLine) {
                                Para.Recalculate_Drawing_AddPageBreak(CurLine, CurPage, false);
                                PRS.RecalcResult = recalcresult_NextPage;
                                PRS.NewRange = true;
                                return;
                            } else {
                                RangeEndPos = Pos;
                                NewRange = true;
                                ForceNewPage = true;
                            }
                        }
                        if (true === Word || WordLen > 0) {
                            X += SpaceLen + WordLen;
                            Word = false;
                            SpaceLen = 0;
                            WordLen = 0;
                        }
                    }
                }
                break;
            case para_PageNum:
                var LogicDocument = Para.LogicDocument;
                var SectionPage = LogicDocument.Get_SectionPageNumInfo2(PRS.Page + Para.Get_StartPage_Absolute()).CurPage;
                Item.Set_Page(SectionPage);
                if (true === Word || WordLen > 0) {
                    X += SpaceLen + WordLen;
                    Word = false;
                    EmptyLine = false;
                    SpaceLen = 0;
                    WordLen = 0;
                }
                if (true === StartWord) {
                    FirstItemOnLine = false;
                }
                UpdateLineMetricsText = true;
                var PageNumWidth = Item.Get_Width();
                if (X + SpaceLen + PageNumWidth > XEnd && (false === FirstItemOnLine || false === Para.Internal_Check_Ranges(ParaLine, ParaRange))) {
                    NewRange = true;
                    RangeEndPos = Pos;
                } else {
                    X += SpaceLen + PageNumWidth;
                    FirstItemOnLine = false;
                    EmptyLine = false;
                }
                SpaceLen = 0;
                break;
            case para_Tab:
                X = this.Internal_Recalculate_LastTab(PRS.LastTab, X, XEnd, Word, WordLen, SpaceLen);
                X += SpaceLen + WordLen;
                Word = false;
                SpaceLen = 0;
                WordLen = 0;
                var TabPos = Para.Internal_GetTabPos(X, ParaPr, PRS.Page);
                var NewX = TabPos.NewX;
                var TabValue = TabPos.TabValue;
                if (tab_Left !== TabValue) {
                    PRS.LastTab.TabPos = NewX;
                    PRS.LastTab.Value = TabValue;
                    PRS.LastTab.X = X;
                    PRS.LastTab.Item = Item;
                    Item.Width = 0;
                    Item.WidthVisible = 0;
                } else {
                    if (NewX > XEnd && (false === FirstItemOnLine || false === Para.Internal_Check_Ranges(ParaLine, ParaRange))) {
                        WordLen = NewX - X;
                        RangeEndPos = Pos;
                        NewRange = true;
                    } else {
                        Item.Width = NewX - X;
                        Item.WidthVisible = NewX - X;
                        X = NewX;
                    }
                }
                if (RangesCount === CurRange) {
                    if (true === StartWord) {
                        FirstItemOnLine = false;
                        EmptyLine = false;
                    }
                }
                PRS.Set_LineBreakPos(Pos);
                StartWord = true;
                Word = true;
                break;
            case para_NewLine:
                X = this.Internal_Recalculate_LastTab(PRS.LastTab, X, XEnd, Word, WordLen, SpaceLen);
                X += WordLen;
                if (true === Word) {
                    EmptyLine = false;
                    Word = false;
                    X += SpaceLen;
                    SpaceLen = 0;
                }
                if (break_Page === Item.BreakType) {
                    if (true === PRS.SkipPageBreak && Item === PRS.PageBreak) {
                        continue;
                    }
                    Item.Flags.NewLine = true;
                    if (! (Para.Parent instanceof CDocument) || true !== Para.Is_Inline()) {
                        Item.Flags.Use = false;
                        continue;
                    }
                    NewPage = true;
                    NewRange = true;
                    BreakPageLine = true;
                    PRS.PageBreak = Item;
                } else {
                    NewRange = true;
                    EmptyLine = false;
                }
                RangeEndPos = Pos + 1;
                break;
            case para_End:
                if (true === Word) {
                    FirstItemOnLine = false;
                    EmptyLine = false;
                }
                if (false === PRS.ExtendBoundToBottom) {
                    X += WordLen;
                    if (true === Word) {
                        X += SpaceLen;
                        SpaceLen = 0;
                        WordLen = 0;
                    }
                    X = this.Internal_Recalculate_LastTab(PRS.LastTab, X, XEnd, Word, WordLen, SpaceLen);
                }
                NewRange = true;
                End = true;
                RangeEndPos = Pos + 1;
                break;
            }
            if (true === NewRange) {
                break;
            }
        }
    }
    if (true === UpdateLineMetricsText) {
        if (PRS.LineTextAscent < this.TextAscent) {
            PRS.LineTextAscent = this.TextAscent;
        }
        if (PRS.LineTextAscent2 < this.TextAscent2) {
            PRS.LineTextAscent2 = this.TextAscent2;
        }
        if (PRS.LineTextDescent < this.TextDescent) {
            PRS.LineTextDescent = this.TextDescent;
        }
        if (linerule_Exact === LineRule) {
            if (PRS.LineAscent < this.TextAscent) {
                PRS.LineAscent = this.TextAscent;
            }
            if (PRS.LineDescent < this.TextDescent) {
                PRS.LineDescent = this.TextDescent;
            }
        } else {
            if (PRS.LineAscent < this.TextAscent + this.YOffset) {
                PRS.LineAscent = this.TextAscent + this.YOffset;
            }
            if (PRS.LineDescent < this.TextDescent - this.YOffset) {
                PRS.LineDescent = this.TextDescent - this.YOffset;
            }
        }
    }
    PRS.MoveToLBP = MoveToLBP;
    PRS.NewRange = NewRange;
    PRS.ForceNewPage = ForceNewPage;
    PRS.NewPage = NewPage;
    PRS.BreakPageLine = BreakPageLine;
    PRS.End = End;
    PRS.Word = Word;
    PRS.StartWord = StartWord;
    PRS.FirstItemOnLine = FirstItemOnLine;
    PRS.EmptyLine = EmptyLine;
    PRS.SpaceLen = SpaceLen;
    PRS.WordLen = WordLen;
    PRS.X = X;
    PRS.XEnd = XEnd;
    if (Pos >= ContentLen) {
        RangeEndPos = Pos;
    }
    this.protected_FillRange(CurLine, CurRange, RangeStartPos, RangeEndPos);
    this.RecalcInfo.Recalc = false;
};
ParaRun.prototype.Recalculate_Set_RangeEndPos = function (PRS, PRP, Depth) {
    var CurLine = PRS.Line - this.StartLine;
    var CurRange = (0 === CurLine ? PRS.Range - this.StartRange : PRS.Range);
    var CurPos = PRP.Get(Depth);
    this.protected_FillRangeEndPos(CurLine, CurRange, CurPos);
};
ParaRun.prototype.Recalculate_Range_Width = function (PRSC, _CurLine, _CurRange) {
    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 Pos = StartPos; Pos < EndPos; Pos++) {
        var Item = this.Content[Pos];
        var ItemType = Item.Type;
        switch (ItemType) {
        case para_Sym:
            case para_Text:
            PRSC.Letters++;
            if (true !== PRSC.Word) {
                PRSC.Word = true;
                PRSC.Words++;
            }
            PRSC.Range.W += Item.Width / TEXTWIDTH_DIVIDER;
            PRSC.Range.W += PRSC.SpaceLen;
            PRSC.SpaceLen = 0;
            if (PRSC.Words > 1) {
                PRSC.Spaces += PRSC.SpacesCount;
            } else {
                PRSC.SpacesSkip += PRSC.SpacesCount;
            }
            PRSC.SpacesCount = 0;
            if (Item.Flags & PARATEXT_FLAGS_SPACEAFTER) {
                PRSC.Word = false;
            }
            break;
        case para_Space:
            if (true === PRSC.Word) {
                PRSC.Word = false;
                PRSC.SpacesCount = 1;
                PRSC.SpaceLen = Item.Width / TEXTWIDTH_DIVIDER;
            } else {
                PRSC.SpacesCount++;
                PRSC.SpaceLen += Item.Width / TEXTWIDTH_DIVIDER;
            }
            break;
        case para_Drawing:
            PRSC.Words++;
            PRSC.Range.W += PRSC.SpaceLen;
            if (PRSC.Words > 1) {
                PRSC.Spaces += PRSC.SpacesCount;
            } else {
                PRSC.SpacesSkip += PRSC.SpacesCount;
            }
            PRSC.Word = false;
            PRSC.SpacesCount = 0;
            PRSC.SpaceLen = 0;
            if (true === Item.Is_Inline() || true === PRSC.Paragraph.Parent.Is_DrawingShape()) {
                PRSC.Range.W += Item.Get_Width();
            }
            break;
        case para_PageNum:
            PRSC.Words++;
            PRSC.Range.W += PRSC.SpaceLen;
            if (PRSC.Words > 1) {
                PRSC.Spaces += PRSC.SpacesCount;
            } else {
                PRSC.SpacesSkip += PRSC.SpacesCount;
            }
            PRSC.Word = false;
            PRSC.SpacesCount = 0;
            PRSC.SpaceLen = 0;
            PRSC.Range.W += Item.Get_Width();
            break;
        case para_Tab:
            PRSC.Range.W += Item.Get_Width();
            PRSC.Range.W += PRSC.SpaceLen;
            PRSC.LettersSkip += PRSC.Letters;
            PRSC.SpacesSkip += PRSC.Spaces;
            PRSC.Words = 0;
            PRSC.Spaces = 0;
            PRSC.Letters = 0;
            PRSC.SpaceLen = 0;
            PRSC.SpacesCount = 0;
            PRSC.Word = false;
            break;
        case para_NewLine:
            if (true === PRSC.Word && PRSC.Words > 1) {
                PRSC.Spaces += PRSC.SpacesCount;
            }
            PRSC.SpacesCount = 0;
            PRSC.Word = false;
            break;
        case para_End:
            if (true === PRSC.Word) {
                PRSC.Spaces += PRSC.SpacesCount;
            }
            break;
        }
    }
};
ParaRun.prototype.Recalculate_Range_Spaces = function (PRSA, _CurLine, _CurRange, CurPage) {
    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 Pos = StartPos; Pos < EndPos; Pos++) {
        var Item = this.Content[Pos];
        var ItemType = Item.Type;
        switch (ItemType) {
        case para_Sym:
            case para_Text:
            var WidthVisible = 0;
            if (0 !== PRSA.LettersSkip) {
                WidthVisible = Item.Width / TEXTWIDTH_DIVIDER;
                PRSA.LettersSkip--;
            } else {
                WidthVisible = Item.Width / TEXTWIDTH_DIVIDER + PRSA.JustifyWord;
            }
            Item.WidthVisible = (WidthVisible * TEXTWIDTH_DIVIDER) | 0;
            PRSA.X += WidthVisible;
            PRSA.LastW = WidthVisible;
            break;
        case para_Space:
            var WidthVisible = Item.Width / TEXTWIDTH_DIVIDER;
            if (0 !== PRSA.SpacesSkip) {
                PRSA.SpacesSkip--;
            } else {
                if (0 !== PRSA.SpacesCounter) {
                    WidthVisible += PRSA.JustifySpace;
                    PRSA.SpacesCounter--;
                }
            }
            Item.WidthVisible = (WidthVisible * TEXTWIDTH_DIVIDER) | 0;
            PRSA.X += WidthVisible;
            PRSA.LastW = WidthVisible;
            break;
        case para_Drawing:
            var Para = PRSA.Paragraph;
            var LogicDocument = this.Paragraph.LogicDocument;
            var LD_PageLimits = LogicDocument.Get_PageLimits(CurPage);
            var LD_PageFields = LogicDocument.Get_PageFields(CurPage);
            var Page_Width = LD_PageLimits.XLimit;
            var Page_Height = LD_PageLimits.YLimit;
            var X_Left_Field = LD_PageFields.X;
            var Y_Top_Field = LD_PageFields.Y;
            var X_Right_Field = LD_PageFields.XLimit;
            var Y_Bottom_Field = LD_PageFields.YLimit;
            var X_Left_Margin = X_Left_Field;
            var X_Right_Margin = Page_Width - X_Right_Field;
            var Y_Bottom_Margin = Page_Height - Y_Bottom_Field;
            var Y_Top_Margin = Y_Top_Field;
            var DrawingObjects = Para.Parent.DrawingObjects;
            var PageLimits = Para.Parent.Get_PageLimits(Para.PageNum + CurPage);
            var PageFields = Para.Parent.Get_PageFields(Para.PageNum + CurPage);
            var ColumnStartX = (0 === CurPage ? Para.X_ColumnStart : Para.Pages[CurPage].X);
            var ColumnEndX = (0 === CurPage ? Para.X_ColumnEnd : Para.Pages[CurPage].XLimit);
            var Top_Margin = Y_Top_Margin;
            var Bottom_Margin = Y_Bottom_Margin;
            var Page_H = Page_Height;
            if (true === Para.Parent.Is_TableCellContent() && true == Item.Use_TextWrap()) {
                Top_Margin = 0;
                Bottom_Margin = 0;
                Page_H = 0;
            }
            if (true != Item.Use_TextWrap()) {
                PageFields.X = X_Left_Field;
                PageFields.Y = Y_Top_Field;
                PageFields.XLimit = X_Right_Field;
                PageFields.YLimit = Y_Bottom_Field;
                PageLimits.X = 0;
                PageLimits.Y = 0;
                PageLimits.XLimit = Page_Width;
                PageLimits.YLimit = Page_Height;
            }
            var PageLimitsOrigin = Para.Parent.Get_PageLimits(Para.PageNum + CurPage);
            if (true === Item.Is_Inline() || true === Para.Parent.Is_DrawingShape()) {
                Item.Update_Position(PRSA.Paragraph, new CParagraphLayout(PRSA.X, PRSA.Y, Para.Get_StartPage_Absolute() + CurPage, PRSA.LastW, ColumnStartX, ColumnEndX, X_Left_Margin, X_Right_Margin, Page_Width, Top_Margin, Bottom_Margin, Page_H, PageFields.X, PageFields.Y, Para.Pages[CurPage].Y + Para.Lines[CurLine].Y - Para.Lines[CurLine].Metrics.Ascent, Para.Pages[CurPage].Y), PageLimits, PageLimitsOrigin);
                Item.Reset_SavedPosition();
                PRSA.X += Item.WidthVisible;
                PRSA.LastW = Item.WidthVisible;
            } else {
                Para.Pages[CurPage].Add_Drawing(Item);
                if (true === PRSA.RecalcFast) {
                    break;
                }
                if (true === PRSA.RecalcFast2) {
                    var oRecalcObj = Item.Save_RecalculateObject();
                    var Page_abs = Para.Get_StartPage_Absolute() + CurPage;
                    Item.Update_Position(PRSA.Paragraph, new CParagraphLayout(PRSA.X, PRSA.Y, Page_abs, PRSA.LastW, ColumnStartX, ColumnEndX, X_Left_Margin, X_Right_Margin, Page_Width, Top_Margin, Bottom_Margin, Page_H, PageFields.X, PageFields.Y, Para.Pages[CurPage].Y + Para.Lines[CurLine].Y - Para.Lines[CurLine].Metrics.Ascent, Para.Pages[CurPage].Y), PageLimits, PageLimitsOrigin);
                    if (Math.abs(Item.X - oRecalcObj.X) > 0.001 || Math.abs(Item.Y - oRecalcObj.Y) > 0.001 || Item.PageNum !== oRecalcObj.PageNum) {
                        PRSA.RecalcResult = recalcresult_CurPage;
                        return;
                    }
                    break;
                }
                if (true === Item.Use_TextWrap()) {
                    var LogicDocument = Para.Parent;
                    var LDRecalcInfo = Para.Parent.RecalcInfo;
                    var Page_abs = Para.Get_StartPage_Absolute() + CurPage;
                    if (true === LDRecalcInfo.Can_RecalcObject()) {
                        Item.Update_Position(PRSA.Paragraph, new CParagraphLayout(PRSA.X, PRSA.Y, Page_abs, PRSA.LastW, ColumnStartX, ColumnEndX, X_Left_Margin, X_Right_Margin, Page_Width, Top_Margin, Bottom_Margin, Page_H, PageFields.X, PageFields.Y, Para.Pages[CurPage].Y + Para.Lines[CurLine].Y - Para.Lines[CurLine].Metrics.Ascent, Para.Pages[CurPage].Y), PageLimits, PageLimitsOrigin);
                        LDRecalcInfo.Set_FlowObject(Item, 0, recalcresult_NextElement, -1);
                        if (0 === PRSA.CurPage && Item.wrappingPolygon.top > PRSA.PageY + 0.001) {
                            PRSA.RecalcResult = recalcresult_CurPagePara;
                        } else {
                            PRSA.RecalcResult = recalcresult_CurPage;
                        }
                        return;
                    } else {
                        if (true === LDRecalcInfo.Check_FlowObject(Item)) {
                            if (Item.PageNum === Page_abs) {
                                LDRecalcInfo.Reset();
                                Item.Reset_SavedPosition();
                            } else {
                                if (true === Para.Parent.Is_TableCellContent()) {
                                    Item.Update_Position(PRSA.Paragraph, new CParagraphLayout(PRSA.X, PRSA.Y, Page_abs, PRSA.LastW, ColumnStartX, ColumnEndX, X_Left_Margin, X_Right_Margin, Page_Width, Top_Margin, Bottom_Margin, Page_H, PageFields.X, PageFields.Y, Para.Pages[CurPage].Y + Para.Lines[CurLine].Y - Para.Lines[CurLine].Metrics.Ascent, Para.Pages[CurPage].Y), PageLimits, PageLimitsOrigin);
                                    LDRecalcInfo.Set_FlowObject(Item, 0, recalcresult_NextElement, -1);
                                    LDRecalcInfo.Set_PageBreakBefore(false);
                                    PRSA.RecalcResult = recalcresult_CurPage;
                                    return;
                                } else {
                                    LDRecalcInfo.Set_PageBreakBefore(true);
                                    DrawingObjects.removeById(Item.PageNum, Item.Get_Id());
                                    PRSA.RecalcResult = recalcresult_PrevPage;
                                    return;
                                }
                            }
                        } else {}
                    }
                    continue;
                } else {
                    Item.Update_Position(PRSA.Paragraph, new CParagraphLayout(PRSA.X, PRSA.Y, Para.Get_StartPage_Absolute() + CurPage, PRSA.LastW, ColumnStartX, ColumnEndX, X_Left_Margin, X_Right_Margin, Page_Width, Top_Margin, Bottom_Margin, Page_H, PageFields.X, PageFields.Y, Para.Pages[CurPage].Y + Para.Lines[CurLine].Y - Para.Lines[CurLine].Metrics.Ascent, Para.Pages[CurPage].Y), PageLimits, PageLimitsOrigin);
                    Item.Reset_SavedPosition();
                }
            }
            break;
        case para_PageNum:
            PRSA.X += Item.WidthVisible;
            PRSA.LastW = Item.WidthVisible;
            break;
        case para_Tab:
            PRSA.X += Item.WidthVisible;
            break;
        case para_End:
            var SectPr = PRSA.Paragraph.Get_SectionPr();
            if (undefined !== SectPr) {
                var LogicDocument = PRSA.Paragraph.LogicDocument;
                var NextSectPr = LogicDocument.SectionsInfo.Get_SectPr(PRSA.Paragraph.Index + 1).SectPr;
                Item.Update_SectionPr(NextSectPr, PRSA.XEnd - PRSA.X);
            } else {
                Item.Clear_SectionPr();
            }
            PRSA.X += Item.Get_Width();
            break;
        case para_NewLine:
            if (break_Page === Item.BreakType) {
                Item.Update_String(PRSA.XEnd - PRSA.X);
            }
            PRSA.X += Item.WidthVisible;
            break;
        }
    }
};
ParaRun.prototype.Recalculate_PageEndInfo = function (PRSI, _CurLine, _CurRange) {};
ParaRun.prototype.Internal_Recalculate_Numbering = function (Item, Para, ParaPr, _X, _LineAscent, CurPage, CurLine, CurRange) {
    var X = _X,
    LineAscent = _LineAscent;
    var NumberingItem = Para.Numbering;
    var NumberingType = Para.Numbering.Type;
    if (para_Numbering === NumberingType) {
        var NumPr = ParaPr.NumPr;
        if (undefined === NumPr || undefined === NumPr.NumId || 0 === NumPr.NumId || "0" === NumPr.NumId || (undefined !== Para.Get_SectionPr() && true === Para.IsEmpty())) {
            NumberingItem.Measure(g_oTextMeasurer, undefined);
        } else {
            var Numbering = Para.Parent.Get_Numbering();
            var NumLvl = Numbering.Get_AbstractNum(NumPr.NumId).Lvl[NumPr.Lvl];
            var NumSuff = NumLvl.Suff;
            var NumJc = NumLvl.Jc;
            var NumInfo = Para.Parent.Internal_GetNumInfo(Para.Id, NumPr);
            var NumTextPr = Para.Get_CompiledPr2(false).TextPr.Copy();
            NumTextPr.Merge(Para.TextPr.Value);
            NumTextPr.Merge(NumLvl.TextPr);
            NumberingItem.Measure(g_oTextMeasurer, Numbering, NumInfo, NumTextPr, NumPr, Para.Get_Theme());
            if (LineAscent < NumberingItem.Height) {
                LineAscent = NumberingItem.Height;
            }
            switch (NumJc) {
            case align_Right:
                NumberingItem.WidthVisible = 0;
                break;
            case align_Center:
                NumberingItem.WidthVisible = NumberingItem.WidthNum / 2;
                break;
            case align_Left:
                default:
                NumberingItem.WidthVisible = NumberingItem.WidthNum;
                break;
            }
            X += NumberingItem.WidthVisible;
            switch (NumSuff) {
            case numbering_suff_Nothing:
                break;
            case numbering_suff_Space:
                var OldTextPr = g_oTextMeasurer.GetTextPr();
                var Theme = Para.Get_Theme();
                g_oTextMeasurer.SetTextPr(NumTextPr, Theme);
                g_oTextMeasurer.SetFontSlot(fontslot_ASCII);
                NumberingItem.WidthSuff = g_oTextMeasurer.Measure(" ").Width;
                g_oTextMeasurer.SetTextPr(OldTextPr, Theme);
                break;
            case numbering_suff_Tab:
                var NewX = Para.Internal_GetTabPos(X, ParaPr, CurPage).NewX;
                NumberingItem.WidthSuff = NewX - X;
                break;
            }
            NumberingItem.Width = NumberingItem.WidthNum;
            NumberingItem.WidthVisible += NumberingItem.WidthSuff;
            X += NumberingItem.WidthSuff;
        }
    } else {
        if (para_PresentationNumbering === NumberingType) {
            var Level = Para.PresentationPr.Level;
            var Bullet = Para.PresentationPr.Bullet;
            var BulletNum = 0;
            if (Bullet.Get_Type() >= numbering_presentationnumfrmt_ArabicPeriod) {
                var Prev = Para.Prev;
                while (null != Prev && type_Paragraph === Prev.GetType()) {
                    var PrevLevel = Prev.PresentationPr.Level;
                    var PrevBullet = Prev.Get_PresentationNumbering();
                    if (Level < PrevLevel) {
                        Prev = Prev.Prev;
                        continue;
                    } else {
                        if (Level > PrevLevel) {
                            break;
                        } else {
                            if (PrevBullet.Get_Type() === Bullet.Get_Type() && PrevBullet.Get_StartAt() === PrevBullet.Get_StartAt()) {
                                if (true != Prev.IsEmpty()) {
                                    BulletNum++;
                                }
                                Prev = Prev.Prev;
                            } else {
                                break;
                            }
                        }
                    }
                }
            }
            var FirstTextPr = Para.Get_FirstTextPr();
            NumberingItem.Bullet = Bullet;
            NumberingItem.BulletNum = BulletNum + 1;
            NumberingItem.Measure(g_oTextMeasurer, FirstTextPr, Para.Get_Theme());
            if (numbering_presentationnumfrmt_None != Bullet.Get_Type()) {
                if (ParaPr.Ind.FirstLine < 0) {
                    NumberingItem.WidthVisible = Math.max(NumberingItem.Width, Para.X + ParaPr.Ind.Left + ParaPr.Ind.FirstLine - X, Para.X + ParaPr.Ind.Left - X);
                } else {
                    NumberingItem.WidthVisible = Math.max(Para.X + ParaPr.Ind.Left + NumberingItem.Width - X, Para.X + ParaPr.Ind.Left + ParaPr.Ind.FirstLine - X, Para.X + ParaPr.Ind.Left - X);
                }
            }
            X += NumberingItem.WidthVisible;
        }
    }
    this.RecalcInfo.NumberingAdd = false;
    this.RecalcInfo.NumberingUse = true;
    this.RecalcInfo.NumberingItem = NumberingItem;
    NumberingItem.Item = Item;
    NumberingItem.Run = this;
    NumberingItem.Line = CurLine;
    NumberingItem.Range = CurRange;
    return {
        X: X,
        LineAscent: LineAscent
    };
};
ParaRun.prototype.Internal_Recalculate_LineMetrics = function (PRS, SpacingLineRule) {
    if (PRS.LineTextAscent < this.TextAscent) {
        PRS.LineTextAscent = this.TextAscent;
    }
    if (PRS.LineTextAscent2 < this.TextAscent2) {
        PRS.LineTextAscent2 = this.TextAscent2;
    }
    if (PRS.LineTextDescent < this.TextDescent) {
        PRS.LineTextDescent = this.TextDescent;
    }
    if (linerule_Exact === SpacingLineRule) {
        if (PRS.LineAscent < this.TextAscent) {
            PRS.LineAscent = this.TextAscent;
        }
        if (PRS.LineDescent < this.TextDescent) {
            PRS.LineDescent = this.TextDescent;
        }
    } else {
        if (PRS.LineAscent < this.TextAscent + this.YOffset) {
            PRS.LineAscent = this.TextAscent + this.YOffset;
        }
        if (PRS.LineDescent < this.TextDescent - this.YOffset) {
            PRS.LineDescent = this.TextDescent - this.YOffset;
        }
    }
};
ParaRun.prototype.Internal_Recalculate_LastTab = function (LastTab, X, XEnd, Word, WordLen, SpaceLen) {
    if (-1 !== LastTab.Value) {
        var TempXPos = X;
        if (true === Word || WordLen > 0) {
            TempXPos += SpaceLen + WordLen;
        }
        var TabItem = LastTab.Item;
        var TabStartX = LastTab.X;
        var TabRangeW = TempXPos - TabStartX;
        var TabValue = LastTab.Value;
        var TabPos = LastTab.TabPos;
        var TabCalcW = 0;
        if (tab_Right === TabValue) {
            TabCalcW = Math.max(TabPos - (TabStartX + TabRangeW), 0);
        } else {
            if (tab_Center === TabValue) {
                TabCalcW = Math.max(TabPos - (TabStartX + TabRangeW / 2), 0);
            }
        }
        if (X + TabCalcW > XEnd) {
            TabCalcW = XEnd - X;
        }
        TabItem.Width = TabCalcW;
        TabItem.WidthVisible = TabCalcW;
        LastTab.Reset();
        return X + TabCalcW;
    }
    return X;
};
ParaRun.prototype.Refresh_RecalcData = function (Data) {
    var Para = this.Paragraph;
    if (this.Type == para_Math_Run) {
        if (this.Parent !== null && this.Parent !== undefined) {
            this.Parent.Refresh_RecalcData();
        }
    } else {
        if (-1 !== this.StartLine && undefined !== Para) {
            var CurLine = this.StartLine;
            var PagesCount = Para.Pages.length;
            for (var CurPage = 0; CurPage < PagesCount; CurPage++) {
                var Page = Para.Pages[CurPage];
                if (Page.StartLine <= CurLine && Page.EndLine >= CurLine) {
                    Para.Refresh_RecalcData2(CurPage);
                    return;
                }
            }
            Para.Refresh_RecalcData2(0);
        }
    }
};
ParaRun.prototype.Save_RecalculateObject = function (Copy) {
    var RecalcObj = new CRunRecalculateObject(this.StartLine, this.StartRange);
    RecalcObj.Save_Lines(this, Copy);
    RecalcObj.Save_RunContent(this, Copy);
    return RecalcObj;
};
ParaRun.prototype.Load_RecalculateObject = function (RecalcObj) {
    RecalcObj.Load_Lines(this);
    RecalcObj.Load_RunContent(this);
};
ParaRun.prototype.Prepare_RecalculateObject = function () {
    this.protected_ClearLines();
    var Count = this.Content.length;
    for (var Index = 0; Index < Count; Index++) {
        var Item = this.Content[Index];
        var ItemType = Item.Type;
        if (para_PageNum === ItemType || para_Drawing === ItemType) {
            Item.Prepare_RecalculateObject();
        }
    }
};
ParaRun.prototype.Is_EmptyRange = function (_CurLine, _CurRange) {
    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);
    if (EndPos <= StartPos) {
        return true;
    }
    return false;
};
ParaRun.prototype.Check_Range_OnlyMath = function (Checker, _CurRange, _CurLine) {
    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 Pos = StartPos; Pos < EndPos; Pos++) {
        var Item = this.Content[Pos];
        var ItemType = Item.Type;
        if (para_End === ItemType || para_NewLine === ItemType || (para_Drawing === ItemType && true !== Item.Is_Inline())) {
            continue;
        } else {
            Checker.Result = false;
            Checker.Math = null;
            break;
        }
    }
};
ParaRun.prototype.Check_MathPara = function (Checker) {
    var Count = this.Content.length;
    if (Count <= 0) {
        return;
    }
    var Item = (Checker.Direction > 0 ? this.Content[0] : this.Content[Count - 1]);
    var ItemType = Item.Type;
    if (para_End === ItemType || para_NewLine === ItemType) {
        Checker.Result = true;
        Checker.Found = true;
    } else {
        Checker.Result = false;
        Checker.Found = true;
    }
};
ParaRun.prototype.Check_PageBreak = function () {
    var Count = this.Content.length;
    for (var Pos = 0; Pos < Count; Pos++) {
        var Item = this.Content[Pos];
        if (para_NewLine === Item.Type && break_Page === Item.BreakType) {
            return true;
        }
    }
    return false;
};
ParaRun.prototype.Check_BreakPageEnd = function (PBChecker) {
    var ContentLen = this.Content.length;
    for (var CurPos = 0; CurPos < ContentLen; CurPos++) {
        var Item = this.Content[CurPos];
        if (true === PBChecker.FindPB) {
            if (Item === PBChecker.PageBreak) {
                PBChecker.FindPB = false;
                PBChecker.PageBreak.Flags.NewLine = true;
            }
        } else {
            var ItemType = Item.Type;
            if (para_End === ItemType) {
                return true;
            } else {
                if (para_Drawing !== ItemType || drawing_Anchor !== Item.Get_DrawingType()) {
                    return false;
                }
            }
        }
    }
    return true;
};
ParaRun.prototype.Recalculate_MinMaxContentWidth = function (MinMax) {
    this.Recalculate_MeasureContent();
    var bWord = MinMax.bWord;
    var nWordLen = MinMax.nWordLen;
    var nSpaceLen = MinMax.nSpaceLen;
    var nMinWidth = MinMax.nMinWidth;
    var nMaxWidth = MinMax.nMaxWidth;
    var nCurMaxWidth = MinMax.nCurMaxWidth;
    var Count = this.Content.length;
    for (var Pos = 0; Pos < Count; Pos++) {
        var Item = this.Content[Pos];
        var ItemType = Item.Type;
        switch (ItemType) {
        case para_Text:
            var ItemWidth = Item.Width / TEXTWIDTH_DIVIDER;
            if (false === bWord) {
                bWord = true;
                nWordLen = ItemWidth;
            } else {
                nWordLen += ItemWidth;
                if (Item.Flags & PARATEXT_FLAGS_SPACEAFTER) {
                    if (nMinWidth < nWordLen) {
                        nMinWidth = nWordLen;
                    }
                    bWord = false;
                    nWordLen = 0;
                }
            }
            if (nSpaceLen > 0) {
                nCurMaxWidth += nSpaceLen;
                nSpaceLen = 0;
            }
            nCurMaxWidth += ItemWidth;
            break;
        case para_Space:
            if (true === bWord) {
                if (nMinWidth < nWordLen) {
                    nMinWidth = nWordLen;
                }
                bWord = false;
                nWordLen = 0;
            }
            nSpaceLen += Item.Width / TEXTWIDTH_DIVIDER;
            break;
        case para_Drawing:
            if (true === bWord) {
                if (nMinWidth < nWordLen) {
                    nMinWidth = nWordLen;
                }
                bWord = false;
                nWordLen = 0;
            }
            if ((true === Item.Is_Inline() || true === this.Paragraph.Parent.Is_DrawingShape()) && Item.Width > nMinWidth) {
                nMinWidth = Item.Width;
            }
            if (nSpaceLen > 0) {
                nCurMaxWidth += nSpaceLen;
                nSpaceLen = 0;
            }
            if (true === Item.Is_Inline() || true === this.Paragraph.Parent.Is_DrawingShape()) {
                nCurMaxWidth += Item.Width;
            }
            break;
        case para_PageNum:
            if (true === bWord) {
                if (nMinWidth < nWordLen) {
                    nMinWidth = nWordLen;
                }
                bWord = false;
                nWordLen = 0;
            }
            if (Item.Width > nMinWidth) {
                nMinWidth = Item.Width;
            }
            if (nSpaceLen > 0) {
                nCurMaxWidth += nSpaceLen;
                nSpaceLen = 0;
            }
            nCurMaxWidth += Item.Width;
            break;
        case para_Tab:
            nWordLen += Item.Width;
            if (nMinWidth < nWordLen) {
                nMinWidth = nWordLen;
            }
            bWord = false;
            nWordLen = 0;
            if (nSpaceLen > 0) {
                nCurMaxWidth += nSpaceLen;
                nSpaceLen = 0;
            }
            nCurMaxWidth += Item.Width;
            break;
        case para_NewLine:
            if (nMinWidth < nWordLen) {
                nMinWidth = nWordLen;
            }
            bWord = false;
            nWordLen = 0;
            nSpaceLen = 0;
            if (nCurMaxWidth > nMaxWidth) {
                nMaxWidth = nCurMaxWidth;
            }
            nCurMaxWidth = 0;
            break;
        case para_End:
            if (nMinWidth < nWordLen) {
                nMinWidth = nWordLen;
            }
            if (nCurMaxWidth > nMaxWidth) {
                nMaxWidth = nCurMaxWidth;
            }
            break;
        }
    }
    MinMax.bWord = bWord;
    MinMax.nWordLen = nWordLen;
    MinMax.nSpaceLen = nSpaceLen;
    MinMax.nMinWidth = nMinWidth;
    MinMax.nMaxWidth = nMaxWidth;
    MinMax.nCurMaxWidth = nCurMaxWidth;
};
ParaRun.prototype.Get_Range_VisibleWidth = function (RangeW, _CurLine, _CurRange) {
    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 Pos = StartPos; Pos < EndPos; Pos++) {
        var Item = this.Content[Pos];
        var ItemType = Item.Type;
        switch (ItemType) {
        case para_Sym:
            case para_Text:
            case para_Space:
            RangeW.W += Item.Get_WidthVisible();
            break;
        case para_Drawing:
            if (true === Item.Is_Inline()) {
                RangeW.W += Item.Width;
            }
            break;
        case para_PageNum:
            case para_Tab:
            RangeW.W += Item.Width;
            break;
        case para_NewLine:
            RangeW.W += Item.WidthVisible;
            break;
        case para_End:
            RangeW.W += Item.Get_WidthVisible();
            RangeW.End = true;
            break;
        }
    }
};
ParaRun.prototype.Shift_Range = function (Dx, Dy, _CurLine, _CurRange) {
    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++) {
        var Item = this.Content[CurPos];
        if (para_Drawing === Item.Type) {
            Item.Shift(Dx, Dy);
        }
    }
};
ParaRun.prototype.Draw_HighLights = function (PDSH) {
    var pGraphics = PDSH.Graphics;
    var CurLine = PDSH.Line - this.StartLine;
    var CurRange = (0 === CurLine ? PDSH.Range - this.StartRange : PDSH.Range);
    var aHigh = PDSH.High;
    var aColl = PDSH.Coll;
    var aFind = PDSH.Find;
    var aComm = PDSH.Comm;
    var aShd = PDSH.Shd;
    var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
    var EndPos = this.protected_GetRangeEndPos(CurLine, CurRange);
    var Para = PDSH.Paragraph;
    var SearchResults = Para.SearchResults;
    var bDrawFind = PDSH.DrawFind;
    var bDrawColl = PDSH.DrawColl;
    var oShd = this.Get_CompiledPr(false).Shd;
    var bDrawShd = (oShd === undefined || shd_Nil === oShd.Value ? false : true);
    var ShdColor = (true === bDrawShd ? oShd.Get_Color(PDSH.Paragraph) : null);
    if (this.Type == para_Math_Run && this.IsPlaceholder()) {
        bDrawShd = false;
    }
    var X = PDSH.X;
    var Y0 = PDSH.Y0;
    var Y1 = PDSH.Y1;
    var CommentsCount = PDSH.Comments.length;
    var CommentId = (CommentsCount > 0 ? PDSH.Comments[CommentsCount - 1] : null);
    var CommentsFlag = PDSH.CommentsFlag;
    var HighLight = this.Get_CompiledPr(false).HighLight;
    var SearchMarksCount = this.SearchMarks.length;
    this.CollaborativeMarks.Init_Drawing();
    for (var Pos = StartPos; Pos < EndPos; Pos++) {
        var Item = this.Content[Pos];
        var ItemType = Item.Type;
        var ItemWidthVisible = Item.Get_WidthVisible();
        for (var SPos = 0; SPos < SearchMarksCount; SPos++) {
            var Mark = this.SearchMarks[SPos];
            var MarkPos = Mark.SearchResult.StartPos.Get(Mark.Depth);
            if (Pos === MarkPos && true === Mark.Start) {
                PDSH.SearchCounter++;
            }
        }
        var DrawSearch = (PDSH.SearchCounter > 0 && true === bDrawFind ? true : false);
        var DrawColl = this.CollaborativeMarks.Check(Pos);
        if (true === bDrawShd) {
            aShd.Add(Y0, Y1, X, X + ItemWidthVisible, 0, ShdColor.r, ShdColor.g, ShdColor.b);
        }
        switch (ItemType) {
        case para_PageNum:
            case para_Drawing:
            case para_Tab:
            case para_Text:
            case para_Math_Text:
            case para_Math_Ampersand:
            case para_Sym:
            if (para_Drawing === ItemType && drawing_Anchor === Item.DrawingType) {
                break;
            }
            if (CommentsFlag != comments_NoComment) {
                aComm.Add(Y0, Y1, X, X + ItemWidthVisible, 0, 0, 0, 0, {
                    Active: CommentsFlag === comments_ActiveComment ? true : false,
                    CommentId: CommentId
                });
            } else {
                if (highlight_None != HighLight) {
                    aHigh.Add(Y0, Y1, X, X + ItemWidthVisible, 0, HighLight.r, HighLight.g, HighLight.b);
                }
            }
            if (true === DrawSearch) {
                aFind.Add(Y0, Y1, X, X + ItemWidthVisible, 0, 0, 0, 0);
            } else {
                if (null !== DrawColl) {
                    aColl.Add(Y0, Y1, X, X + ItemWidthVisible, 0, DrawColl.r, DrawColl.g, DrawColl.b);
                }
            }
            if (para_Drawing != ItemType || drawing_Anchor != Item.DrawingType) {
                X += ItemWidthVisible;
            }
            break;
        case para_Space:
            if (PDSH.Spaces > 0) {
                if (CommentsFlag != comments_NoComment) {
                    aComm.Add(Y0, Y1, X, X + ItemWidthVisible, 0, 0, 0, 0, {
                        Active: CommentsFlag === comments_ActiveComment ? true : false,
                        CommentId: CommentId
                    });
                } else {
                    if (highlight_None != HighLight) {
                        aHigh.Add(Y0, Y1, X, X + ItemWidthVisible, 0, HighLight.r, HighLight.g, HighLight.b);
                    }
                }
                PDSH.Spaces--;
            }
            if (true === DrawSearch) {
                aFind.Add(Y0, Y1, X, X + ItemWidthVisible, 0, 0, 0, 0);
            } else {
                if (null !== DrawColl) {
                    aColl.Add(Y0, Y1, X, X + ItemWidthVisible, 0, DrawColl.r, DrawColl.g, DrawColl.b);
                }
            }
            X += ItemWidthVisible;
            break;
        case para_End:
            if (null !== DrawColl) {
                aColl.Add(Y0, Y1, X, X + ItemWidthVisible, 0, DrawColl.r, DrawColl.g, DrawColl.b);
            }
            X += Item.Get_Width();
            break;
        case para_NewLine:
            X += ItemWidthVisible;
            break;
        }
        for (var SPos = 0; SPos < SearchMarksCount; SPos++) {
            var Mark = this.SearchMarks[SPos];
            var MarkPos = Mark.SearchResult.EndPos.Get(Mark.Depth);
            if (Pos + 1 === MarkPos && true !== Mark.Start) {
                PDSH.SearchCounter--;
            }
        }
    }
    PDSH.X = X;
};
ParaRun.prototype.Draw_Elements = function (PDSE) {
    var CurLine = PDSE.Line - this.StartLine;
    var CurRange = (0 === CurLine ? PDSE.Range - this.StartRange : PDSE.Range);
    var CurPage = PDSE.Page;
    var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
    var EndPos = this.protected_GetRangeEndPos(CurLine, CurRange);
    var Para = PDSE.Paragraph;
    var pGraphics = PDSE.Graphics;
    var BgColor = PDSE.BgColor;
    var Theme = PDSE.Theme;
    var FontScheme = Theme.themeElements.fontScheme;
    var X = PDSE.X;
    var Y = PDSE.Y;
    var CurTextPr = this.Get_CompiledPr(false);
    pGraphics.SetTextPr(CurTextPr, Theme);
    var InfoMathText;
    if (this.Type == para_Math_Run) {
        Y += this.size.ascent;
        var ArgSize = this.Parent.Compiled_ArgSz.value,
        bNormalText = this.IsNormalText();
        InfoMathText = new CMathInfoTextPr_2(CurTextPr, ArgSize, bNormalText);
    }
    if (undefined !== CurTextPr.Shd && shd_Nil !== 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.Unifill) {
        CurTextPr.Unifill.check(PDSE.Theme, PDSE.ColorMap);
        RGBA = CurTextPr.Unifill.getRGBAColor();
        if (true === PDSE.VisitedHyperlink && (undefined === this.Pr.Color && undefined === this.Pr.Unifill)) {
            G_O_VISITED_HLINK_COLOR.check(PDSE.Theme, PDSE.ColorMap);
            RGBA = G_O_VISITED_HLINK_COLOR.getRGBAColor();
            pGraphics.b_color1(RGBA.R, RGBA.G, RGBA.B, RGBA.A);
        } else {
            pGraphics.b_color1(RGBA.R, RGBA.G, RGBA.B, RGBA.A);
        }
    } else {
        if (true === PDSE.VisitedHyperlink && (undefined === this.Pr.Color && undefined === this.Pr.Unifill)) {
            G_O_VISITED_HLINK_COLOR.check(PDSE.Theme, PDSE.ColorMap);
            RGBA = G_O_VISITED_HLINK_COLOR.getRGBAColor();
            pGraphics.b_color1(RGBA.R, RGBA.G, RGBA.B, RGBA.A);
        } else {
            if (true === CurTextPr.Color.Auto) {
                pGraphics.b_color1(AutoColor.r, AutoColor.g, AutoColor.b, 255);
            } else {
                pGraphics.b_color1(CurTextPr.Color.r, CurTextPr.Color.g, CurTextPr.Color.b, 255);
            }
        }
    }
    for (var Pos = StartPos; Pos < EndPos; Pos++) {
        var Item = this.Content[Pos];
        var ItemType = Item.Type;
        var TempY = Y;
        switch (CurTextPr.VertAlign) {
        case vertalign_SubScript:
            Y -= vertalign_Koef_Sub * CurTextPr.FontSize * g_dKoef_pt_to_mm;
            break;
        case vertalign_SuperScript:
            Y -= vertalign_Koef_Super * CurTextPr.FontSize * g_dKoef_pt_to_mm;
            break;
        }
        switch (ItemType) {
        case para_PageNum:
            case para_Drawing:
            case para_Tab:
            case para_Text:
            case para_Sym:
            if (para_Tab === ItemType) {
                pGraphics.p_color(0, 0, 0, 255);
                pGraphics.b_color1(0, 0, 0, 255);
            }
            if (para_Drawing != ItemType || drawing_Anchor != Item.DrawingType) {
                Item.Draw(X, Y - this.YOffset, pGraphics);
                X += Item.Get_WidthVisible();
            }
            if ((para_Drawing === ItemType && drawing_Inline === Item.DrawingType) || (para_Tab === ItemType)) {
                pGraphics.SetTextPr(CurTextPr, Theme);
                if (RGBA) {
                    pGraphics.b_color1(RGBA.R, RGBA.G, RGBA.B, 255);
                    pGraphics.p_color(RGBA.R, RGBA.G, RGBA.B, 255);
                } else {
                    if (true === CurTextPr.Color.Auto) {
                        pGraphics.b_color1(AutoColor.r, AutoColor.g, AutoColor.b, 255);
                        pGraphics.p_color(AutoColor.r, AutoColor.g, AutoColor.b, 255);
                    } else {
                        pGraphics.b_color1(CurTextPr.Color.r, CurTextPr.Color.g, CurTextPr.Color.b, 255);
                        pGraphics.p_color(CurTextPr.Color.r, CurTextPr.Color.g, CurTextPr.Color.b, 255);
                    }
                }
            }
            break;
        case para_Space:
            Item.Draw(X, Y - this.YOffset, pGraphics);
            X += Item.Get_WidthVisible();
            break;
        case para_End:
            var SectPr = Para.Get_SectionPr();
            if (undefined === SectPr) {
                var EndTextPr = Para.Get_CompiledPr2(false).TextPr.Copy();
                EndTextPr.Merge(Para.TextPr.Value);
                if (EndTextPr.Unifill) {
                    EndTextPr.Unifill.check(PDSE.Theme, PDSE.ColorMap);
                    var RGBAEnd = EndTextPr.Unifill.getRGBAColor();
                    pGraphics.SetTextPr(EndTextPr, PDSE.Theme);
                    pGraphics.b_color1(RGBAEnd.R, RGBAEnd.G, RGBAEnd.B, 255);
                } else {
                    pGraphics.SetTextPr(EndTextPr, PDSE.Theme);
                    if (true === EndTextPr.Color.Auto) {
                        pGraphics.b_color1(AutoColor.r, AutoColor.g, AutoColor.b, 255);
                    } else {
                        pGraphics.b_color1(EndTextPr.Color.r, EndTextPr.Color.g, EndTextPr.Color.b, 255);
                    }
                }
                var bEndCell = false;
                if (null === Para.Get_DocumentNext() && true === Para.Parent.Is_TableCellContent()) {
                    bEndCell = true;
                }
                Item.Draw(X, Y - this.YOffset, pGraphics, bEndCell);
            } else {
                Item.Draw(X, Y - this.YOffset, pGraphics, false);
            }
            X += Item.Get_Width();
            break;
        case para_NewLine:
            Item.Draw(X, Y - this.YOffset, pGraphics);
            X += Item.WidthVisible;
            break;
        case para_Math_Ampersand:
            case para_Math_Text:
            case para_Math_Placeholder:
            Item.draw(X, Y, pGraphics, InfoMathText);
            break;
        }
        Y = TempY;
    }
    PDSE.X = X;
};
ParaRun.prototype.Draw_Lines = function (PDSL) {
    var CurLine = PDSL.Line - this.StartLine;
    var CurRange = (0 === CurLine ? PDSL.Range - this.StartRange : PDSL.Range);
    var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
    var EndPos = this.protected_GetRangeEndPos(CurLine, CurRange);
    var X = PDSL.X;
    var Y = PDSL.Baseline;
    var UndOff = PDSL.UnderlineOffset;
    var Para = PDSL.Paragraph;
    var aStrikeout = PDSL.Strikeout;
    var aDStrikeout = PDSL.DStrikeout;
    var aUnderline = PDSL.Underline;
    var aSpelling = PDSL.Spelling;
    var CurTextPr = this.Get_CompiledPr(false);
    var StrikeoutY = Y - this.YOffset;
    switch (CurTextPr.VertAlign) {
    case vertalign_Baseline:
        StrikeoutY += -CurTextPr.FontSize * g_dKoef_pt_to_mm * 0.27;
        break;
    case vertalign_SubScript:
        StrikeoutY += -CurTextPr.FontSize * vertalign_Koef_Size * g_dKoef_pt_to_mm * 0.27 - vertalign_Koef_Sub * CurTextPr.FontSize * g_dKoef_pt_to_mm;
        break;
    case vertalign_SuperScript:
        StrikeoutY += -CurTextPr.FontSize * vertalign_Koef_Size * g_dKoef_pt_to_mm * 0.27 - vertalign_Koef_Super * CurTextPr.FontSize * g_dKoef_pt_to_mm;
        break;
    }
    var UnderlineY = Y + UndOff - this.YOffset;
    var LineW = (CurTextPr.FontSize / 18) * g_dKoef_pt_to_mm;
    var BgColor = PDSL.BgColor;
    if (undefined !== CurTextPr.Shd && shd_Nil !== 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 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 === CurTextPr.Color.Auto && !CurTextPr.Unifill) {
            CurColor = new CDocumentColor(AutoColor.r, AutoColor.g, AutoColor.b);
        } else {
            if (CurTextPr.Unifill) {
                CurTextPr.Unifill.check(Theme, ColorMap);
                RGBA = CurTextPr.Unifill.getRGBAColor();
                CurColor = new CDocumentColor(RGBA.R, RGBA.G, RGBA.B);
            } else {
                CurColor = new CDocumentColor(CurTextPr.Color.r, CurTextPr.Color.g, CurTextPr.Color.b);
            }
        }
    }
    var SpellingMarksArray = {};
    var SpellingMarksCount = this.SpellingMarks.length;
    for (var SPos = 0; SPos < SpellingMarksCount; SPos++) {
        var Mark = this.SpellingMarks[SPos];
        if (false === Mark.Element.Checked) {
            if (true === Mark.Start) {
                var MarkPos = Mark.Element.StartPos.Get(Mark.Depth);
                if (undefined === SpellingMarksArray[MarkPos]) {
                    SpellingMarksArray[MarkPos] = 1;
                } else {
                    SpellingMarksArray[MarkPos] += 1;
                }
            } else {
                var MarkPos = Mark.Element.EndPos.Get(Mark.Depth);
                if (undefined === SpellingMarksArray[MarkPos]) {
                    SpellingMarksArray[MarkPos] = 2;
                } else {
                    SpellingMarksArray[MarkPos] += 2;
                }
            }
        }
    }
    for (var Pos = StartPos; Pos < EndPos; Pos++) {
        var Item = this.Content[Pos];
        var ItemType = Item.Type;
        var ItemWidthVisible = Item.Get_WidthVisible();
        if (1 === SpellingMarksArray[Pos] || 3 === SpellingMarksArray[Pos]) {
            PDSL.SpellingCounter++;
        }
        switch (ItemType) {
        case para_End:
            case para_NewLine:
            X += ItemWidthVisible;
            break;
        case para_PageNum:
            case para_Drawing:
            case para_Tab:
            case para_Text:
            case para_Sym:
            if (para_Drawing != ItemType || drawing_Anchor != Item.DrawingType) {
                if (true === CurTextPr.DStrikeout) {
                    aDStrikeout.Add(StrikeoutY, StrikeoutY, X, X + ItemWidthVisible, LineW, CurColor.r, CurColor.g, CurColor.b);
                } else {
                    if (true === CurTextPr.Strikeout) {
                        aStrikeout.Add(StrikeoutY, StrikeoutY, X, X + ItemWidthVisible, LineW, CurColor.r, CurColor.g, CurColor.b);
                    }
                }
                if (true === CurTextPr.Underline) {
                    aUnderline.Add(UnderlineY, UnderlineY, X, X + ItemWidthVisible, LineW, CurColor.r, CurColor.g, CurColor.b);
                }
                if (PDSL.SpellingCounter > 0) {
                    aSpelling.Add(UnderlineY, UnderlineY, X, X + ItemWidthVisible, LineW, 0, 0, 0);
                }
                X += ItemWidthVisible;
            }
            break;
        case para_Space:
            if (PDSL.Spaces > 0) {
                if (true === CurTextPr.DStrikeout) {
                    aDStrikeout.Add(StrikeoutY, StrikeoutY, X, X + ItemWidthVisible, LineW, CurColor.r, CurColor.g, CurColor.b);
                } else {
                    if (true === CurTextPr.Strikeout) {
                        aStrikeout.Add(StrikeoutY, StrikeoutY, X, X + ItemWidthVisible, LineW, CurColor.r, CurColor.g, CurColor.b);
                    }
                }
                if (true === CurTextPr.Underline) {
                    aUnderline.Add(UnderlineY, UnderlineY, X, X + ItemWidthVisible, LineW, CurColor.r, CurColor.g, CurColor.b);
                }
                PDSL.Spaces--;
            }
            X += ItemWidthVisible;
            break;
        case para_Math_Text:
            case para_Math_Ampersand:
            if (true === CurTextPr.DStrikeout) {
                aDStrikeout.Add(StrikeoutY, StrikeoutY, X, X + ItemWidthVisible, LineW, CurColor.r, CurColor.g, CurColor.b);
            } else {
                if (true === CurTextPr.Strikeout) {
                    aStrikeout.Add(StrikeoutY, StrikeoutY, X, X + ItemWidthVisible, LineW, CurColor.r, CurColor.g, CurColor.b);
                }
            }
            X += ItemWidthVisible;
            break;
        case para_Math_Placeholder:
            var ctrPrp = this.Parent.GetCtrPrp();
            if (true === ctrPrp.DStrikeout) {
                aDStrikeout.Add(StrikeoutY, StrikeoutY, X, X + ItemWidthVisible, LineW, CurColor.r, CurColor.g, CurColor.b);
            } else {
                if (true === ctrPrp.Strikeout) {
                    aStrikeout.Add(StrikeoutY, StrikeoutY, X, X + ItemWidthVisible, LineW, CurColor.r, CurColor.g, CurColor.b);
                }
            }
            X += ItemWidthVisible;
            break;
        }
        if (2 === SpellingMarksArray[Pos + 1] || 3 === SpellingMarksArray[Pos + 1]) {
            PDSL.SpellingCounter--;
        }
    }
    PDSL.X = X;
};
ParaRun.prototype.Is_CursorPlaceable = function () {
    return true;
};
ParaRun.prototype.Cursor_Is_Start = function () {
    if (this.State.ContentPos <= 0) {
        return true;
    }
    return false;
};
ParaRun.prototype.Cursor_Is_NeededCorrectPos = function () {
    if (true === this.Is_Empty(false)) {
        return true;
    }
    var NewRangeStart = false;
    var RangeEnd = false;
    var Pos = this.State.ContentPos;
    var LinesLen = this.protected_GetLinesCount();
    for (var CurLine = 0; CurLine < LinesLen; CurLine++) {
        var RangesLen = this.protected_GetRangesCount(CurLine);
        for (var CurRange = 0; CurRange < RangesLen; CurRange++) {
            var StartPos = this.protected_GetRangeStartPos(CurLine, CurRange);
            var EndPos = this.protected_GetRangeEndPos(CurLine, CurRange);
            if (0 !== CurLine || 0 !== CurRange) {
                if (Pos === StartPos) {
                    NewRangeStart = true;
                }
            }
            if (Pos === EndPos) {
                RangeEnd = true;
            }
        }
        if (true === NewRangeStart) {
            break;
        }
    }
    if (true !== NewRangeStart && true !== RangeEnd && true === this.Cursor_Is_Start()) {
        return true;
    }
    return false;
};
ParaRun.prototype.Cursor_Is_End = function () {
    if (this.State.ContentPos >= this.Content.length) {
        return true;
    }
    return false;
};
ParaRun.prototype.Cursor_MoveToStartPos = function () {
    this.State.ContentPos = 0;
};
ParaRun.prototype.Cursor_MoveToEndPos = function (SelectFromEnd) {
    if (true === SelectFromEnd) {
        var Selection = this.State.Selection;
        Selection.Use = true;
        Selection.StartPos = this.Content.length;
        Selection.EndPos = this.Content.length;
    } else {
        var CurPos = this.Content.length;
        while (CurPos > 0) {
            if (para_End === this.Content[CurPos - 1].Type) {
                CurPos--;
            } else {
                break;
            }
        }
        this.State.ContentPos = CurPos;
    }
};
ParaRun.prototype.Get_ParaContentPosByXY = function (SearchPos, Depth, _CurLine, _CurRange, StepEnd) {
    var Result = false;
    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);
    var CurPos = StartPos;
    var bNotUpdate = SearchPos.InText && this.Type === para_Math_Run;
    for (; CurPos < EndPos; CurPos++) {
        var Item = this.Content[CurPos];
        var ItemType = Item.Type;
        var TempDx = 0;
        if (para_Drawing != ItemType || true === Item.Is_Inline()) {
            TempDx = Item.Get_WidthVisible();
        }
        var Diff = SearchPos.X - SearchPos.CurX;
        if ((Math.abs(Diff) < SearchPos.DiffX + 0.001 && (SearchPos.CenterMode || SearchPos.X > SearchPos.CurX)) && !bNotUpdate) {
            SearchPos.DiffX = Math.abs(Diff);
            SearchPos.Pos.Update(CurPos, Depth);
            Result = true;
            if (Diff >= -0.001 && Diff <= TempDx + 0.001) {
                SearchPos.InTextPos.Update(CurPos, Depth);
                SearchPos.InText = true;
            }
        }
        SearchPos.CurX += TempDx;
        Diff = SearchPos.X - SearchPos.CurX;
        if ((Math.abs(Diff) < SearchPos.DiffX + 0.001 && (SearchPos.CenterMode || SearchPos.X > SearchPos.CurX)) && !bNotUpdate) {
            if (para_End === ItemType) {
                SearchPos.End = true;
                if (true === StepEnd) {
                    SearchPos.Pos.Update(this.Content.length, Depth);
                    Result = true;
                }
            } else {
                if (CurPos === EndPos - 1 && para_NewLine != ItemType) {
                    SearchPos.Pos.Update(EndPos, Depth);
                    Result = true;
                }
            }
        }
    }
    if (SearchPos.DiffX > 1000000 - 1) {
        SearchPos.Pos.Update(StartPos, Depth);
        Result = true;
    }
    if (this.Type == para_Math_Run) {
        var Diff = SearchPos.X - SearchPos.CurX;
        if ((Math.abs(Diff) < SearchPos.DiffX + 0.001 && (SearchPos.CenterMode || SearchPos.X > SearchPos.CurX)) && !bNotUpdate) {
            SearchPos.DiffX = Math.abs(Diff);
            SearchPos.Pos.Update(CurPos, Depth);
            Result = true;
        }
    }
    return Result;
};
ParaRun.prototype.Get_ParaContentPos = function (bSelection, bStart, ContentPos) {
    var Pos = (true !== bSelection ? this.State.ContentPos : (false !== bStart ? this.State.Selection.StartPos : this.State.Selection.EndPos));
    ContentPos.Add(Pos);
};
ParaRun.prototype.Set_ParaContentPos = function (ContentPos, Depth) {
    var Pos = ContentPos.Get(Depth);
    var Count = this.Content.length;
    if (Pos > Count) {
        Pos = Count;
    }
    for (var TempPos = 0; TempPos < Pos; TempPos++) {
        if (para_End === this.Content[TempPos].Type) {
            Pos = TempPos;
            break;
        }
    }
    if (Pos < 0) {
        Pos = 0;
    }
    this.State.ContentPos = Pos;
};
ParaRun.prototype.Get_PosByElement = function (Class, ContentPos, Depth, UseRange, Range, Line) {
    if (this === Class) {
        return true;
    }
    return false;
};
ParaRun.prototype.Get_ElementByPos = function (ContentPos, Depth) {
    return this;
};
ParaRun.prototype.Get_PosByDrawing = function (Id, ContentPos, Depth) {
    var Count = this.Content.length;
    for (var CurPos = 0; CurPos < Count; CurPos++) {
        var Item = this.Content[CurPos];
        if (para_Drawing === Item.Type && Id === Item.Get_Id()) {
            ContentPos.Update(CurPos, Depth);
            return true;
        }
    }
    return false;
};
ParaRun.prototype.Get_RunElementByPos = function (ContentPos, Depth) {
    if (undefined !== ContentPos) {
        var CurPos = ContentPos.Get(Depth);
        var ContentLen = this.Content.length;
        if (CurPos >= this.Content.length || CurPos < 0) {
            return null;
        }
        return this.Content[CurPos];
    } else {
        if (this.Content.length > 0) {
            return this.Content[0];
        } else {
            return null;
        }
    }
};
ParaRun.prototype.Get_LastRunInRange = function (_CurLine, _CurRange) {
    var CurLine = _CurLine - this.StartLine;
    var CurRange = (0 === CurLine ? _CurRange - this.StartRange : _CurRange);
    return this;
};
ParaRun.prototype.Get_LeftPos = function (SearchPos, ContentPos, Depth, UseContentPos) {
    var CurPos = (true === UseContentPos ? ContentPos.Get(Depth) : this.Content.length);
    while (true) {
        CurPos--;
        var Item = this.Content[CurPos];
        if (CurPos < 0 || para_Drawing !== Item.Type || false !== Item.Is_Inline()) {
            break;
        }
    }
    if (CurPos >= 0) {
        SearchPos.Found = true;
        SearchPos.Pos.Update(CurPos, Depth);
    }
};
ParaRun.prototype.Get_RightPos = function (SearchPos, ContentPos, Depth, UseContentPos, StepEnd) {
    var CurPos = (true === UseContentPos ? ContentPos.Get(Depth) : 0);
    var Count = this.Content.length;
    while (true) {
        CurPos++;
        if (Count === CurPos) {
            if (CurPos === 0) {
                return;
            }
            var PrevItem = this.Content[CurPos - 1];
            var PrevItemType = PrevItem.Type;
            if ((true !== StepEnd && para_End === PrevItemType) || (para_Drawing === PrevItemType && false === PrevItem.Is_Inline())) {
                return;
            }
            break;
        }
        if (CurPos > Count) {
            break;
        }
        var Item = this.Content[CurPos];
        var ItemType = Item.Type;
        if ((para_Drawing !== ItemType && (false !== StepEnd || para_End !== this.Content[CurPos - 1].Type)) || (para_Drawing === ItemType && false !== Item.Is_Inline())) {
            break;
        }
    }
    if (CurPos <= Count) {
        SearchPos.Found = true;
        SearchPos.Pos.Update(CurPos, Depth);
    }
};
ParaRun.prototype.Get_WordStartPos = function (SearchPos, ContentPos, Depth, UseContentPos) {
    var CurPos = (true === UseContentPos ? ContentPos.Get(Depth) - 1 : this.Content.length - 1);
    if (CurPos < 0) {
        return;
    }
    SearchPos.Shift = true;
    var NeedUpdate = false;
    if (0 === SearchPos.Stage) {
        while (true) {
            var Item = this.Content[CurPos];
            var Type = Item.Type;
            var bSpace = false;
            if (para_Space === Type || para_Tab === Type || (para_Text === Type && true === Item.Is_NBSP()) || (para_Drawing === Type && true !== Item.Is_Inline())) {
                bSpace = true;
            }
            if (true === bSpace) {
                CurPos--;
                if (CurPos < 0) {
                    return;
                }
            } else {
                if (para_Text !== this.Content[CurPos].Type && para_Math_Text !== this.Content[CurPos].Type) {
                    SearchPos.Pos.Update(CurPos, Depth);
                    SearchPos.Found = true;
                    SearchPos.UpdatePos = true;
                    return;
                }
                SearchPos.Pos.Update(CurPos, Depth);
                SearchPos.Stage = 1;
                SearchPos.Punctuation = this.Content[CurPos].Is_Punctuation();
                NeedUpdate = true;
                break;
            }
        }
    } else {
        CurPos = (true === UseContentPos ? ContentPos.Get(Depth) : this.Content.length);
    }
    while (CurPos > 0) {
        CurPos--;
        var Item = this.Content[CurPos];
        var TempType = Item.Type;
        if ((para_Text !== TempType && para_Math_Text !== TempType) || true === Item.Is_NBSP() || (true === SearchPos.Punctuation && true !== Item.Is_Punctuation()) || (false === SearchPos.Punctuation && false !== Item.Is_Punctuation())) {
            SearchPos.Found = true;
            break;
        } else {
            SearchPos.Pos.Update(CurPos, Depth);
            NeedUpdate = true;
        }
    }
    SearchPos.UpdatePos = NeedUpdate;
};
ParaRun.prototype.Get_WordEndPos = function (SearchPos, ContentPos, Depth, UseContentPos, StepEnd) {
    var CurPos = (true === UseContentPos ? ContentPos.Get(Depth) : 0);
    var ContentLen = this.Content.length;
    if (CurPos >= ContentLen) {
        return;
    }
    var NeedUpdate = false;
    if (0 === SearchPos.Stage) {
        while (true) {
            var Item = this.Content[CurPos];
            var Type = Item.Type;
            var bText = false;
            if ((para_Text === Type || para_Math_Text === Type) && true != Item.Is_NBSP() && (true === SearchPos.First || (SearchPos.Punctuation === Item.Is_Punctuation()))) {
                bText = true;
            }
            if (true === bText) {
                if (true === SearchPos.First) {
                    SearchPos.First = false;
                    SearchPos.Punctuation = Item.Is_Punctuation();
                }
                CurPos++;
                SearchPos.Shift = true;
                if (CurPos >= ContentLen) {
                    return;
                }
            } else {
                SearchPos.Stage = 1;
                if (true === SearchPos.First) {
                    if (para_End === Type) {
                        if (true === StepEnd) {
                            SearchPos.Pos.Update(CurPos + 1, Depth);
                            SearchPos.Found = true;
                            SearchPos.UpdatePos = true;
                        }
                        return;
                    }
                    CurPos++;
                    SearchPos.Shift = true;
                }
                break;
            }
        }
    }
    if (CurPos >= ContentLen) {
        return;
    }
    if (! (para_Space === this.Content[CurPos].Type || (para_Text === this.Content[CurPos].Type && true === this.Content[CurPos].Is_NBSP()))) {
        SearchPos.Pos.Update(CurPos, Depth);
        SearchPos.Found = true;
        SearchPos.UpdatePos = true;
    } else {
        while (CurPos < ContentLen - 1) {
            CurPos++;
            var Item = this.Content[CurPos];
            var TempType = Item.Type;
            if ((true !== StepEnd && para_End === TempType) || !(para_Space === TempType || (para_Text === TempType && true === Item.Is_NBSP()))) {
                SearchPos.Found = true;
                break;
            }
        }
        SearchPos.Pos.Update(CurPos, Depth);
        SearchPos.UpdatePos = true;
    }
};
ParaRun.prototype.Get_EndRangePos = function (_CurLine, _CurRange, SearchPos, Depth) {
    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);
    var LastPos = -1;
    for (var CurPos = StartPos; CurPos < EndPos; CurPos++) {
        var Item = this.Content[CurPos];
        var ItemType = Item.Type;
        if (! ((para_Drawing === ItemType && true !== Item.Is_Inline()) || para_End === ItemType || (para_NewLine === ItemType && break_Line === Item.BreakType))) {
            LastPos = CurPos + 1;
        }
    }
    if (-1 !== LastPos) {
        SearchPos.Pos.Update(LastPos, Depth);
        return true;
    } else {
        return false;
    }
};
ParaRun.prototype.Get_StartRangePos = function (_CurLine, _CurRange, SearchPos, Depth) {
    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);
    var FirstPos = -1;
    for (var CurPos = EndPos - 1; CurPos >= StartPos; CurPos--) {
        var Item = this.Content[CurPos];
        if (! (para_Drawing === Item.Type && true !== Item.Is_Inline())) {
            FirstPos = CurPos;
        }
    }
    if (-1 !== FirstPos) {
        SearchPos.Pos.Update(FirstPos, Depth);
        return true;
    } else {
        if (this.Type == para_Math_Run && this.Parent.Is_FirstComposition()) {
            SearchPos.Pos.Update(0, Depth);
            return true;
        } else {
            return false;
        }
    }
};
ParaRun.prototype.Get_StartRangePos2 = function (_CurLine, _CurRange, ContentPos, Depth) {
    var CurLine = _CurLine - this.StartLine;
    var CurRange = (0 === CurLine ? _CurRange - this.StartRange : _CurRange);
    var Pos = this.protected_GetRangeStartPos(CurLine, CurRange);
    ContentPos.Update(Pos, Depth);
};
ParaRun.prototype.Get_StartPos = function (ContentPos, Depth) {
    ContentPos.Update(0, Depth);
};
ParaRun.prototype.Get_EndPos = function (BehindEnd, ContentPos, Depth) {
    var ContentLen = this.Content.length;
    if (true === BehindEnd) {
        ContentPos.Update(ContentLen, Depth);
    } else {
        for (var CurPos = 0; CurPos < ContentLen; CurPos++) {
            if (para_End === this.Content[CurPos].Type) {
                ContentPos.Update(CurPos, Depth);
                return;
            }
        }
        ContentPos.Update(ContentLen, Depth);
    }
};
ParaRun.prototype.Set_SelectionContentPos = function (StartContentPos, EndContentPos, Depth, StartFlag, EndFlag) {
    var StartPos = 0;
    switch (StartFlag) {
    case 1:
        StartPos = 0;
        break;
    case -1:
        StartPos = this.Content.length;
        break;
    case 0:
        StartPos = StartContentPos.Get(Depth);
        break;
    }
    var EndPos = 0;
    switch (EndFlag) {
    case 1:
        EndPos = 0;
        break;
    case -1:
        EndPos = this.Content.length;
        break;
    case 0:
        EndPos = EndContentPos.Get(Depth);
        break;
    }
    var Selection = this.State.Selection;
    Selection.StartPos = StartPos;
    Selection.EndPos = EndPos;
    Selection.Use = true;
};
ParaRun.prototype.Set_SelectionAtEndPos = function () {
    this.Set_SelectionContentPos(null, null, 0, -1, -1);
};
ParaRun.prototype.Set_SelectionAtStartPos = function () {
    this.Set_SelectionContentPos(null, null, 0, 1, 1);
};
ParaRun.prototype.Selection_IsUse = function () {
    return this.State.Selection.Use;
};
ParaRun.prototype.Is_SelectedAll = function (Props) {
    var Selection = this.State.Selection;
    if (false === Selection.Use && true !== this.Is_Empty(Props)) {
        return false;
    }
    var SkipAnchor = Props.SkipAnchor;
    var SkipEnd = Props.SkipEnd;
    var StartPos = Selection.StartPos;
    var EndPos = Selection.EndPos;
    if (EndPos < StartPos) {
        StartPos = Selection.EndPos;
        EndPos = Selection.StartPos;
    }
    for (var Pos = 0; Pos < StartPos; Pos++) {
        var Item = this.Content[Pos];
        var ItemType = Item.Type;
        if (! ((true === SkipAnchor && (para_Drawing === ItemType && true !== Item.Is_Inline())) || (true === SkipEnd && para_End === ItemType))) {
            return false;
        }
    }
    var Count = this.Content.length;
    for (var Pos = EndPos; Pos < Count; Pos++) {
        var Item = this.Content[Pos];
        var ItemType = Item.Type;
        if (! ((true === SkipAnchor && (para_Drawing === ItemType && true !== Item.Is_Inline())) || (true === SkipEnd && para_End === ItemType))) {
            return false;
        }
    }
    return true;
};
ParaRun.prototype.Selection_CorrectLeftPos = function (Direction) {
    if (false === this.Selection.Use || true === this.Is_Empty({
        SkipAnchor: true
    })) {
        return true;
    }
    var Selection = this.State.Selection;
    var StartPos = Math.min(Selection.StartPos, Selection.EndPos);
    var EndPos = Math.max(Selection.StartPos, Selection.EndPos);
    for (var Pos = 0; Pos < StartPos; Pos++) {
        var Item = this.Content[Pos];
        if (para_Drawing !== Item.Type || true === Item.Is_Inline()) {
            return false;
        }
    }
    for (var Pos = StartPos; Pos < EndPos; Pos++) {
        var Item = this.Content[Pos];
        if (para_Drawing === Item.Type && true !== Item.Is_Inline()) {
            if (1 === Direction) {
                Selection.StartPos = Pos + 1;
            } else {
                Selection.EndPos = Pos + 1;
            }
        } else {
            return false;
        }
    }
    return true;
};
ParaRun.prototype.Selection_Stop = function () {};
ParaRun.prototype.Selection_Remove = function () {
    var Selection = this.State.Selection;
    Selection.Use = false;
    Selection.StartPos = 0;
    Selection.EndPos = 0;
};
ParaRun.prototype.Select_All = function (Direction) {
    var Selection = this.State.Selection;
    Selection.Use = true;
    if (-1 === Direction) {
        Selection.StartPos = this.Content.length;
        Selection.EndPos = 0;
    } else {
        Selection.StartPos = 0;
        Selection.EndPos = this.Content.length;
    }
};
ParaRun.prototype.Selection_DrawRange = function (_CurLine, _CurRange, SelectionDraw, PointsInfo) {
    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);
    var Selection = this.State.Selection;
    var SelectionUse = Selection.Use;
    var SelectionStartPos = Selection.StartPos;
    var SelectionEndPos = Selection.EndPos;
    if (SelectionStartPos > SelectionEndPos) {
        SelectionStartPos = Selection.EndPos;
        SelectionEndPos = Selection.StartPos;
    }
    var FindStart = SelectionDraw.FindStart;
    for (var CurPos = StartPos; CurPos < EndPos; CurPos++) {
        var Item = this.Content[CurPos];
        var ItemType = Item.Type;
        var DrawSelection = false;
        if (true === FindStart) {
            if (true === Selection.Use && CurPos >= SelectionStartPos && CurPos < SelectionEndPos) {
                FindStart = false;
                DrawSelection = true;
            } else {
                if (para_Drawing !== ItemType || true === Item.Is_Inline()) {
                    SelectionDraw.StartX += Item.Get_WidthVisible();
                }
            }
        } else {
            if (true === Selection.Use && CurPos >= SelectionStartPos && CurPos < SelectionEndPos) {
                DrawSelection = true;
            }
        }
        if (true === DrawSelection) {
            if (para_Drawing === ItemType && true !== Item.Is_Inline()) {
                if (true === SelectionDraw.Draw) {
                    Item.Draw_Selection();
                }
            } else {
                SelectionDraw.W += Item.Get_WidthVisible();
            }
        }
    }
    SelectionDraw.FindStart = FindStart;
};
ParaRun.prototype.Selection_IsEmpty = function (CheckEnd) {
    var Selection = this.State.Selection;
    if (true !== Selection.Use) {
        return true;
    }
    if (this.Type == para_Math_Run && this.IsPlaceholder()) {
        return true;
    }
    var StartPos = Selection.StartPos;
    var EndPos = Selection.EndPos;
    if (StartPos > EndPos) {
        StartPos = Selection.EndPos;
        EndPos = Selection.StartPos;
    }
    if (true === CheckEnd) {
        return (EndPos > StartPos ? false : true);
    } else {
        if (this.Type == para_Math_Run && this.Is_Empty()) {
            return false;
        } else {
            for (var CurPos = StartPos; CurPos < EndPos; CurPos++) {
                var ItemType = this.Content[CurPos].Type;
                if (para_End !== ItemType) {
                    return false;
                }
            }
        }
    }
    return true;
};
ParaRun.prototype.Selection_CheckParaEnd = function () {
    var Selection = this.State.Selection;
    if (true !== Selection.Use) {
        return false;
    }
    var StartPos = Selection.StartPos;
    var EndPos = Selection.EndPos;
    if (StartPos > EndPos) {
        StartPos = Selection.EndPos;
        EndPos = Selection.StartPos;
    }
    for (var CurPos = StartPos; CurPos < EndPos; CurPos++) {
        var Item = this.Content[CurPos];
        if (para_End === Item.Type) {
            return true;
        }
    }
    return false;
};
ParaRun.prototype.Selection_CheckParaContentPos = function (ContentPos, Depth, bStart, bEnd) {
    var CurPos = ContentPos.Get(Depth);
    if (this.Selection.StartPos <= this.Selection.EndPos && this.Selection.StartPos <= CurPos && CurPos <= this.Selection.EndPos) {
        if ((true !== bEnd) || (true === bEnd && CurPos !== this.Selection.EndPos)) {
            return true;
        }
    } else {
        if (this.Selection.StartPos > this.Selection.EndPos && this.Selection.EndPos <= CurPos && CurPos <= this.Selection.StartPos) {
            if ((true !== bEnd) || (true === bEnd && CurPos !== this.Selection.StartPos)) {
                return true;
            }
        }
    }
    return false;
};
ParaRun.prototype.Clear_TextFormatting = function (DefHyper) {
    this.Set_Bold(undefined);
    this.Set_Italic(undefined);
    this.Set_Strikeout(undefined);
    this.Set_Underline(undefined);
    this.Set_FontSize(undefined);
    this.Set_Color(undefined);
    this.Set_Unifill(undefined);
    this.Set_VertAlign(undefined);
    this.Set_Spacing(undefined);
    this.Set_DStrikeout(undefined);
    this.Set_Caps(undefined);
    this.Set_SmallCaps(undefined);
    this.Set_Position(undefined);
    this.Set_RFonts2(undefined);
    this.Set_RStyle(undefined);
    this.Set_Shd(undefined);
    this.Recalc_CompiledPr(true);
};
ParaRun.prototype.Get_TextPr = function () {
    return this.Pr.Copy();
};
ParaRun.prototype.Get_CompiledTextPr = function (Copy) {
    if (true === this.State.Selection.Use && true === this.Selection_CheckParaEnd()) {
        var ThisTextPr = this.Get_CompiledPr(true);
        var Para = this.Paragraph;
        var EndTextPr = Para.Get_CompiledPr2(false).TextPr.Copy();
        EndTextPr.Merge(Para.TextPr.Value);
        ThisTextPr = ThisTextPr.Compare(EndTextPr);
        return ThisTextPr;
    } else {
        return this.Get_CompiledPr(Copy);
    }
};
ParaRun.prototype.Recalc_CompiledPr = function (RecalcMeasure) {
    this.RecalcInfo.TextPr = true;
    if (true === RecalcMeasure) {
        this.RecalcInfo.Measure = true;
    }
    this.private_UpdateMathResize();
    this.private_RecalcCtrPrp();
};
ParaRun.prototype.Recalc_RunsCompiledPr = function () {
    this.Recalc_CompiledPr(true);
};
ParaRun.prototype.Get_CompiledPr = function (bCopy) {
    if (true === this.RecalcInfo.TextPr) {
        this.RecalcInfo.TextPr = false;
        this.CompiledPr = this.Internal_Compile_Pr();
    }
    if (false === bCopy) {
        return this.CompiledPr;
    } else {
        return this.CompiledPr.Copy();
    }
};
ParaRun.prototype.Internal_Compile_Pr = function () {
    if (undefined === this.Paragraph || null === this.Paragraph) {
        var TextPr = new CTextPr();
        TextPr.Init_Default();
        this.RecalcInfo.TextPr = true;
        return TextPr;
    }
    var TextPr = this.Paragraph.Get_CompiledPr2(false).TextPr.Copy();
    if (undefined != this.Pr.RStyle) {
        var Styles = this.Paragraph.Parent.Get_Styles();
        var StyleTextPr = Styles.Get_Pr(this.Pr.RStyle, styletype_Character).TextPr;
        TextPr.Merge(StyleTextPr);
    }
    if (this.Type == para_Math_Run) {
        if (undefined === this.Parent || null === this.Parent) {
            var TextPr = new CTextPr();
            TextPr.Init_Default();
            this.RecalcInfo.TextPr = true;
            return TextPr;
        }
        if (!this.IsNormalText()) {
            var Styles = this.Paragraph.Parent.Get_Styles();
            var StyleDefaultTextPr = Styles.Default.TextPr.Copy();
            var DefaultTextPr = new CTextPr();
            DefaultTextPr.RFonts.Set_All("Cambria Math", -1);
            Styles.Default.TextPr = DefaultTextPr;
            var StyleId = this.Paragraph.Style_Get();
            var Pr = Styles.Get_Pr(StyleId, styletype_Paragraph, null, null);
            TextPr.RFonts.Set_FromObject(Pr.TextPr.RFonts);
            Styles.Default.TextPr = StyleDefaultTextPr;
        }
        if (this.IsPlaceholder()) {
            TextPr.Merge(this.Parent.GetCtrPrp());
            TextPr.Merge(this.Pr);
        } else {
            TextPr.Merge(this.Pr);
            if (!this.IsNormalText()) {
                var MPrp = this.MathPrp.GetTxtPrp();
                TextPr.Merge(MPrp);
            }
        }
    } else {
        TextPr.Merge(this.Pr);
        if (this.Pr.Color && !this.Pr.Unifill) {
            TextPr.Unifill = undefined;
        }
    }
    TextPr.FontFamily.Name = TextPr.RFonts.Ascii.Name;
    TextPr.FontFamily.Index = TextPr.RFonts.Ascii.Index;
    return TextPr;
};
ParaRun.prototype.Set_Pr = function (TextPr) {
    var OldValue = this.Pr;
    this.Pr = TextPr;
    History.Add(this, {
        Type: historyitem_ParaRun_TextPr,
        New: TextPr,
        Old: OldValue
    });
    this.Recalc_CompiledPr(true);
    this.protected_UpdateSpellChecking();
};
ParaRun.prototype.Apply_TextPr = function (TextPr, IncFontSize, ApplyToAll) {
    if (true === ApplyToAll) {
        if (undefined === IncFontSize) {
            this.Apply_Pr(TextPr);
        } else {
            var _TextPr = new CTextPr();
            var CurTextPr = this.Get_CompiledPr(false);
            this.Set_FontSize(FontSize_IncreaseDecreaseValue(IncFontSize, CurTextPr.FontSize));
        }
        var bEnd = false;
        var Count = this.Content.length;
        for (var Pos = 0; Pos < Count; Pos++) {
            if (para_End === this.Content[Pos].Type) {
                bEnd = true;
                break;
            }
        }
        if (true === bEnd) {
            if (undefined === IncFontSize) {
                this.Paragraph.TextPr.Apply_TextPr(TextPr);
            } else {
                var Para = this.Paragraph;
                var EndTextPr = Para.Get_CompiledPr2(false).TextPr.Copy();
                EndTextPr.Merge(Para.TextPr.Value);
                Para.TextPr.Set_FontSize(FontSize_IncreaseDecreaseValue(IncFontSize, EndTextPr.FontSize));
            }
        }
    } else {
        var Result = [];
        var LRun = this,
        CRun = null,
        RRun = null;
        if (true === this.State.Selection.Use) {
            var StartPos = this.State.Selection.StartPos;
            var EndPos = this.State.Selection.EndPos;
            var Direction = 1;
            if (StartPos > EndPos) {
                var Temp = StartPos;
                StartPos = EndPos;
                EndPos = Temp;
                Direction = -1;
            }
            if (EndPos < this.Content.length) {
                RRun = LRun.Split_Run(EndPos);
            }
            if (StartPos > 0) {
                CRun = LRun.Split_Run(StartPos);
            } else {
                CRun = LRun;
                LRun = null;
            }
            if (null !== LRun) {
                LRun.Selection.Use = true;
                LRun.Selection.StartPos = LRun.Content.length;
                LRun.Selection.EndPos = LRun.Content.length;
            }
            CRun.Select_All(Direction);
            if (undefined === IncFontSize) {
                CRun.Apply_Pr(TextPr);
            } else {
                var _TextPr = new CTextPr();
                var CurTextPr = this.Get_CompiledPr(false);
                CRun.Set_FontSize(FontSize_IncreaseDecreaseValue(IncFontSize, CurTextPr.FontSize));
            }
            if (null !== RRun) {
                RRun.Selection.Use = true;
                RRun.Selection.StartPos = 0;
                RRun.Selection.EndPos = 0;
            }
            if (true === this.Selection_CheckParaEnd()) {
                if (undefined === IncFontSize) {
                    this.Paragraph.TextPr.Apply_TextPr(TextPr);
                } else {
                    var Para = this.Paragraph;
                    var EndTextPr = Para.Get_CompiledPr2(false).TextPr.Copy();
                    EndTextPr.Merge(Para.TextPr.Value);
                    Para.TextPr.Set_FontSize(FontSize_IncreaseDecreaseValue(IncFontSize, EndTextPr.FontSize));
                }
            }
        } else {
            var CurPos = this.State.ContentPos;
            if (CurPos < this.Content.length) {
                RRun = LRun.Split_Run(CurPos);
            }
            if (CurPos > 0) {
                CRun = LRun.Split_Run(CurPos);
            } else {
                CRun = LRun;
                LRun = null;
            }
            if (null !== LRun) {
                LRun.Selection_Remove();
            }
            CRun.Selection_Remove();
            CRun.Cursor_MoveToStartPos();
            if (undefined === IncFontSize) {
                CRun.Apply_Pr(TextPr);
            } else {
                var _TextPr = new CTextPr();
                var CurTextPr = this.Get_CompiledPr(false);
                CRun.Set_FontSize(FontSize_IncreaseDecreaseValue(IncFontSize, CurTextPr.FontSize));
            }
            if (null !== RRun) {
                RRun.Selection_Remove();
            }
        }
        Result.push(LRun);
        Result.push(CRun);
        Result.push(RRun);
        return Result;
    }
};
ParaRun.prototype.Split_Run = function (Pos) {
    var bMathRun = this.Type == para_Math_Run;
    var NewRun = new ParaRun(this.Paragraph, bMathRun);
    NewRun.Set_Pr(this.Pr.Copy());
    if (bMathRun) {
        NewRun.Set_MathPr(this.MathPrp.Copy());
    }
    var OldCrPos = this.State.ContentPos;
    var OldSSPos = this.State.Selection.StartPos;
    var OldSEPos = this.State.Selection.EndPos;
    NewRun.Concat_ToContent(this.Content.slice(Pos));
    this.Remove_FromContent(Pos, this.Content.length - Pos, true);
    if (OldCrPos >= Pos) {
        NewRun.State.ContentPos = OldCrPos - Pos;
        this.State.ContentPos = this.Content.length;
    } else {
        NewRun.State.ContentPos = 0;
    }
    if (OldSSPos >= Pos) {
        NewRun.State.Selection.StartPos = OldSSPos - Pos;
        this.State.Selection.StartPos = this.Content.length;
    } else {
        NewRun.State.Selection.StartPos = 0;
    }
    if (OldSEPos >= Pos) {
        NewRun.State.Selection.EndPos = OldSEPos - Pos;
        this.State.Selection.EndPos = this.Content.length;
    } else {
        NewRun.State.Selection.EndPos = 0;
    }
    var SpellingMarksCount = this.SpellingMarks.length;
    for (var Index = 0; Index < SpellingMarksCount; Index++) {
        var Mark = this.SpellingMarks[Index];
        var MarkPos = (true === Mark.Start ? Mark.Element.StartPos.Get(Mark.Depth) : Mark.Element.EndPos.Get(Mark.Depth));
        if (MarkPos >= Pos) {
            var MarkElement = Mark.Element;
            if (true === Mark.Start) {
                MarkElement.StartPos.Data[Mark.Depth] -= Pos;
            } else {
                MarkElement.EndPos.Data[Mark.Depth] -= Pos;
            }
            NewRun.SpellingMarks.push(Mark);
            this.SpellingMarks.splice(Index, 1);
            SpellingMarksCount--;
            Index--;
        }
    }
    return NewRun;
};
ParaRun.prototype.Clear_TextPr = function () {
    var NewTextPr = new CTextPr();
    NewTextPr.Lang = this.Pr.Lang.Copy();
    this.Set_Pr(NewTextPr);
};
ParaRun.prototype.Apply_Pr = function (TextPr) {
    if (this.Type == para_Math_Run && !this.IsNormalText()) {
        if (null === TextPr.Bold && null === TextPr.Italic) {
            this.Math_Apply_Style(undefined);
        } else {
            if (undefined != TextPr.Bold) {
                if (TextPr.Bold == true) {
                    if (this.MathPrp.sty == STY_ITALIC || this.MathPrp.sty == undefined) {
                        this.Math_Apply_Style(STY_BI);
                    } else {
                        if (this.MathPrp.sty == STY_PLAIN) {
                            this.Math_Apply_Style(STY_BOLD);
                        }
                    }
                } else {
                    if (TextPr.Bold == false || TextPr.Bold == null) {
                        if (this.MathPrp.sty == STY_BI || this.MathPrp.sty == undefined) {
                            this.Math_Apply_Style(STY_ITALIC);
                        } else {
                            if (this.MathPrp.sty == STY_BOLD) {
                                this.Math_Apply_Style(STY_PLAIN);
                            }
                        }
                    }
                }
            }
            if (undefined != TextPr.Italic) {
                if (TextPr.Italic == true) {
                    if (this.MathPrp.sty == STY_BOLD) {
                        this.Math_Apply_Style(STY_BI);
                    } else {
                        if (this.MathPrp.sty == STY_PLAIN || this.MathPrp.sty == undefined) {
                            this.Math_Apply_Style(STY_ITALIC);
                        }
                    }
                } else {
                    if (TextPr.Italic == false || TextPr.Italic == null) {
                        if (this.MathPrp.sty == STY_BI) {
                            this.Math_Apply_Style(STY_BOLD);
                        } else {
                            if (this.MathPrp.sty == STY_ITALIC || this.MathPrp.sty == undefined) {
                                this.Math_Apply_Style(STY_PLAIN);
                            }
                        }
                    }
                }
            }
        }
    } else {
        if (undefined != TextPr.Bold) {
            this.Set_Bold(null === TextPr.Bold ? undefined : TextPr.Bold);
        }
        if (undefined != TextPr.Italic) {
            this.Set_Italic(null === TextPr.Italic ? undefined : TextPr.Italic);
        }
    }
    if (undefined != TextPr.Strikeout) {
        this.Set_Strikeout(null === TextPr.Strikeout ? undefined : TextPr.Strikeout);
    }
    if (undefined !== TextPr.Underline) {
        this.Set_Underline(null === TextPr.Underline ? undefined : TextPr.Underline);
    }
    if (undefined != TextPr.FontSize) {
        this.Set_FontSize(null === TextPr.FontSize ? undefined : TextPr.FontSize);
    }
    if (undefined !== TextPr.Color && undefined === TextPr.Unifill) {
        this.Set_Color(null === TextPr.Color ? undefined : TextPr.Color);
        this.Set_Unifill(undefined);
    }
    if (undefined !== TextPr.Unifill) {
        this.Set_Unifill(null === TextPr.Unifill ? undefined : TextPr.Unifill);
        this.Set_Color(undefined);
    }
    if (undefined != TextPr.VertAlign) {
        this.Set_VertAlign(null === TextPr.VertAlign ? undefined : TextPr.VertAlign);
    }
    if (undefined != TextPr.HighLight) {
        this.Set_HighLight(null === TextPr.HighLight ? undefined : TextPr.HighLight);
    }
    if (undefined !== TextPr.RStyle) {
        this.Set_RStyle(null === TextPr.RStyle ? undefined : TextPr.RStyle);
    }
    if (undefined != TextPr.Spacing) {
        this.Set_Spacing(null === TextPr.Spacing ? undefined : TextPr.Spacing);
    }
    if (undefined != TextPr.DStrikeout) {
        this.Set_DStrikeout(null === TextPr.DStrikeout ? undefined : TextPr.DStrikeout);
    }
    if (undefined != TextPr.Caps) {
        this.Set_Caps(null === TextPr.Caps ? undefined : TextPr.Caps);
    }
    if (undefined != TextPr.SmallCaps) {
        this.Set_SmallCaps(null === TextPr.SmallCaps ? undefined : TextPr.SmallCaps);
    }
    if (undefined != TextPr.Position) {
        this.Set_Position(null === TextPr.Position ? undefined : TextPr.Position);
    }
    if (undefined != TextPr.RFonts) {
        if (this.Type == para_Math_Run && !this.IsNormalText()) {
            if (TextPr.RFonts.Ascii !== undefined || TextPr.RFonts.HAnsi !== undefined) {
                var RFonts = new CRFonts();
                RFonts.Set_All("Cambria Math", -1);
                this.Set_RFonts2(RFonts);
            }
        } else {
            this.Set_RFonts2(TextPr.RFonts);
        }
    }
    if (undefined != TextPr.Lang) {
        this.Set_Lang2(TextPr.Lang);
    }
    if (undefined !== TextPr.Shd) {
        this.Set_Shd(TextPr.Shd);
    }
};
ParaRun.prototype.Set_Bold = function (Value) {
    if (Value !== this.Pr.Bold) {
        var OldValue = this.Pr.Bold;
        this.Pr.Bold = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_Bold,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(true);
    }
};
ParaRun.prototype.Get_Bold = function () {
    return this.Get_CompiledPr(false).Bold;
};
ParaRun.prototype.Set_Italic = function (Value) {
    if (Value !== this.Pr.Italic) {
        var OldValue = this.Pr.Italic;
        this.Pr.Italic = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_Italic,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(true);
    }
};
ParaRun.prototype.Get_Italic = function () {
    return this.Get_CompiledPr(false).Italic;
};
ParaRun.prototype.Set_Strikeout = function (Value) {
    if (Value !== this.Pr.Strikeout) {
        var OldValue = this.Pr.Strikeout;
        this.Pr.Strikeout = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_Strikeout,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(false);
    }
};
ParaRun.prototype.Get_Strikeout = function () {
    return this.Get_CompiledPr(false).Strikeout;
};
ParaRun.prototype.Set_Underline = function (Value) {
    if (Value !== this.Pr.Underline) {
        var OldValue = this.Pr.Underline;
        this.Pr.Underline = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_Underline,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(false);
    }
};
ParaRun.prototype.Get_Underline = function () {
    return this.Get_CompiledPr(false).Underline;
};
ParaRun.prototype.Set_FontSize = function (Value) {
    if (Value !== this.Pr.FontSize) {
        var OldValue = this.Pr.FontSize;
        this.Pr.FontSize = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_FontSize,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(true);
    }
};
ParaRun.prototype.Get_FontSize = function () {
    return this.Get_CompiledPr(false).FontSize;
};
ParaRun.prototype.Set_Color = function (Value) {
    if ((undefined === Value && undefined !== this.Pr.Color) || (Value instanceof CDocumentColor && (undefined === this.Pr.Color || false === Value.Compare(this.Pr.Color)))) {
        var OldValue = this.Pr.Color;
        this.Pr.Color = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_Color,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(false);
    }
};
ParaRun.prototype.Set_Unifill = function (Value) {
    if ((undefined === Value && undefined !== this.Pr.Unifill) || (Value instanceof CUniFill && (undefined === this.Pr.Unifill || false === CompareUnifillBool(this.Pr.Unifill, Value)))) {
        var OldValue = this.Pr.Unifill;
        this.Pr.Unifill = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_Unifill,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(false);
    }
};
ParaRun.prototype.Get_Color = function () {
    return this.Get_CompiledPr(false).Color;
};
ParaRun.prototype.Set_VertAlign = function (Value) {
    if (Value !== this.Pr.VertAlign) {
        var OldValue = this.Pr.VertAlign;
        this.Pr.VertAlign = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_VertAlign,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(true);
    }
};
ParaRun.prototype.Get_VertAlign = function () {
    return this.Get_CompiledPr(false).VertAlign;
};
ParaRun.prototype.Set_HighLight = function (Value) {
    var OldValue = this.Pr.HighLight;
    if ((undefined === Value && undefined !== OldValue) || (highlight_None === Value && highlight_None !== OldValue) || (Value instanceof CDocumentColor && (undefined === OldValue || highlight_None === OldValue || false === Value.Compare(OldValue)))) {
        this.Pr.HighLight = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_HighLight,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(false);
    }
};
ParaRun.prototype.Get_HighLight = function () {
    return this.Get_CompiledPr(false).HighLight;
};
ParaRun.prototype.Set_RStyle = function (Value) {
    if (Value !== this.Pr.RStyle) {
        var OldValue = this.Pr.RStyle;
        this.Pr.RStyle = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_RStyle,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(true);
    }
};
ParaRun.prototype.Set_Spacing = function (Value) {
    if (Value !== this.Pr.Spacing) {
        var OldValue = this.Pr.Spacing;
        this.Pr.Spacing = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_Spacing,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(true);
    }
};
ParaRun.prototype.Get_Spacing = function () {
    return this.Get_CompiledPr(false).Spacing;
};
ParaRun.prototype.Set_DStrikeout = function (Value) {
    if (Value !== this.Pr.Value) {
        var OldValue = this.Pr.DStrikeout;
        this.Pr.DStrikeout = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_DStrikeout,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(false);
    }
};
ParaRun.prototype.Get_DStrikeout = function () {
    return this.Get_CompiledPr(false).DStrikeout;
};
ParaRun.prototype.Set_Caps = function (Value) {
    if (Value !== this.Pr.Caps) {
        var OldValue = this.Pr.Caps;
        this.Pr.Caps = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_Caps,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(true);
    }
};
ParaRun.prototype.Get_Caps = function () {
    return this.Get_CompiledPr(false).Caps;
};
ParaRun.prototype.Set_SmallCaps = function (Value) {
    if (Value !== this.Pr.SmallCaps) {
        var OldValue = this.Pr.SmallCaps;
        this.Pr.SmallCaps = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_SmallCaps,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(true);
    }
};
ParaRun.prototype.Get_SmallCaps = function () {
    return this.Get_CompiledPr(false).SmallCaps;
};
ParaRun.prototype.Set_Position = function (Value) {
    if (Value !== this.Pr.Position) {
        var OldValue = this.Pr.Position;
        this.Pr.Position = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_Position,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(false);
        this.YOffset = this.Get_Position();
    }
};
ParaRun.prototype.Get_Position = function () {
    return this.Get_CompiledPr(false).Position;
};
ParaRun.prototype.Set_RFonts = function (Value) {
    var OldValue = this.Pr.RFonts;
    this.Pr.RFonts = Value;
    History.Add(this, {
        Type: historyitem_ParaRun_RFonts,
        New: Value,
        Old: OldValue
    });
    this.Recalc_CompiledPr(true);
};
ParaRun.prototype.Get_RFonts = function () {
    return this.Get_CompiledPr(false).RFonts;
};
ParaRun.prototype.Set_RFonts2 = function (RFonts) {
    if (undefined != RFonts) {
        if (undefined != RFonts.Ascii) {
            this.Set_RFonts_Ascii(RFonts.Ascii);
        }
        if (undefined != RFonts.HAnsi) {
            this.Set_RFonts_HAnsi(RFonts.HAnsi);
        }
        if (undefined != RFonts.CS) {
            this.Set_RFonts_CS(RFonts.CS);
        }
        if (undefined != RFonts.EastAsia) {
            this.Set_RFonts_EastAsia(RFonts.EastAsia);
        }
        if (undefined != RFonts.Hint) {
            this.Set_RFonts_Hint(RFonts.Hint);
        }
    } else {
        this.Set_RFonts_Ascii(undefined);
        this.Set_RFonts_HAnsi(undefined);
        this.Set_RFonts_CS(undefined);
        this.Set_RFonts_EastAsia(undefined);
        this.Set_RFonts_Hint(undefined);
    }
};
ParaRun.prototype.Set_RFont_ForMathRun = function () {
    this.Set_RFonts_Ascii({
        Name: "Cambria Math",
        Index: -1
    });
    this.Set_RFonts_CS({
        Name: "Cambria Math",
        Index: -1
    });
    this.Set_RFonts_EastAsia({
        Name: "Cambria Math",
        Index: -1
    });
    this.Set_RFonts_HAnsi({
        Name: "Cambria Math",
        Index: -1
    });
};
ParaRun.prototype.Set_RFonts_Ascii = function (Value) {
    if (Value !== this.Pr.RFonts.Ascii) {
        var OldValue = this.Pr.RFonts.Ascii;
        this.Pr.RFonts.Ascii = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_RFonts_Ascii,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(true);
    }
};
ParaRun.prototype.Set_RFonts_HAnsi = function (Value) {
    if (Value !== this.Pr.RFonts.HAnsi) {
        var OldValue = this.Pr.RFonts.HAnsi;
        this.Pr.RFonts.HAnsi = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_RFonts_HAnsi,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(true);
    }
};
ParaRun.prototype.Set_RFonts_CS = function (Value) {
    if (Value !== this.Pr.RFonts.CS) {
        var OldValue = this.Pr.RFonts.CS;
        this.Pr.RFonts.CS = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_RFonts_CS,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(true);
    }
};
ParaRun.prototype.Set_RFonts_EastAsia = function (Value) {
    if (Value !== this.Pr.RFonts.EastAsia) {
        var OldValue = this.Pr.RFonts.EastAsia;
        this.Pr.RFonts.EastAsia = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_RFonts_EastAsia,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(true);
    }
};
ParaRun.prototype.Set_RFonts_Hint = function (Value) {
    if (Value !== this.Pr.RFonts.Hint) {
        var OldValue = this.Pr.RFonts.Hint;
        this.Pr.RFonts.Hint = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_RFonts_Hint,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(true);
    }
};
ParaRun.prototype.Set_Lang = function (Value) {
    var OldValue = this.Pr.Lang;
    this.Pr.Lang = new CLang();
    if (undefined != Value) {
        this.Pr.Lang.Set_FromObject(Value);
    }
    History.Add(this, {
        Type: historyitem_ParaRun_Lang,
        New: this.Pr.Lang,
        Old: OldValue
    });
    this.Recalc_CompiledPr(false);
};
ParaRun.prototype.Set_Lang2 = function (Lang) {
    if (undefined != Lang) {
        if (undefined != Lang.Bidi) {
            this.Set_Lang_Bidi(Lang.Bidi);
        }
        if (undefined != Lang.EastAsia) {
            this.Set_Lang_EastAsia(Lang.EastAsia);
        }
        if (undefined != Lang.Val) {
            this.Set_Lang_Val(Lang.Val);
        }
        this.protected_UpdateSpellChecking();
    }
};
ParaRun.prototype.Set_Lang_Bidi = function (Value) {
    if (Value !== this.Pr.Lang.Bidi) {
        var OldValue = this.Pr.Lang.Bidi;
        this.Pr.Lang.Bidi = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_Lang_Bidi,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(false);
    }
};
ParaRun.prototype.Set_Lang_EastAsia = function (Value) {
    if (Value !== this.Pr.Lang.EastAsia) {
        var OldValue = this.Pr.Lang.EastAsia;
        this.Pr.Lang.EastAsia = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_Lang_EastAsia,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(false);
    }
};
ParaRun.prototype.Set_Lang_Val = function (Value) {
    if (Value !== this.Pr.Lang.Val) {
        var OldValue = this.Pr.Lang.Val;
        this.Pr.Lang.Val = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_Lang_Val,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(false);
    }
};
ParaRun.prototype.Set_Shd = function (Shd) {
    if ((undefined === this.Pr.Shd && undefined === Shd) || (undefined !== this.Pr.Shd && undefined !== Shd && true === this.Pr.Shd.Compare(Shd))) {
        return;
    }
    var OldShd = this.Pr.Shd;
    if (undefined !== Shd) {
        this.Pr.Shd = new CDocumentShd();
        this.Pr.Shd.Set_FromObject(Shd);
    } else {
        this.Pr.Shd = undefined;
    }
    History.Add(this, {
        Type: historyitem_ParaRun_Shd,
        New: this.Pr.Shd,
        Old: OldShd
    });
    this.Recalc_CompiledPr(false);
};
ParaRun.prototype.Undo = function (Data) {
    var Type = Data.Type;
    switch (Type) {
    case historyitem_ParaRun_AddItem:
        this.Content.splice(Data.Pos, Data.EndPos - Data.Pos + 1);
        this.RecalcInfo.Measure = true;
        this.protected_UpdateSpellChecking();
        this.private_UpdateMathResize();
        break;
    case historyitem_ParaRun_RemoveItem:
        var Pos = Data.Pos;
        var Array_start = this.Content.slice(0, Pos);
        var Array_end = this.Content.slice(Pos);
        this.Content = Array_start.concat(Data.Items, Array_end);
        this.RecalcInfo.Measure = true;
        this.protected_UpdateSpellChecking();
        this.private_UpdateMathResize();
        break;
    case historyitem_ParaRun_TextPr:
        if (undefined != Data.Old) {
            this.Pr = Data.Old;
        } else {
            this.Pr = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_Bold:
        if (undefined != Data.Old) {
            this.Pr.Bold = Data.Old;
        } else {
            this.Pr.Bold = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_Italic:
        if (undefined != Data.Old) {
            this.Pr.Italic = Data.Old;
        } else {
            this.Pr.Italic = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_Strikeout:
        if (undefined != Data.Old) {
            this.Pr.Strikeout = Data.Old;
        } else {
            this.Pr.Strikeout = undefined;
        }
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_Underline:
        if (undefined != Data.Old) {
            this.Pr.Underline = Data.Old;
        } else {
            this.Pr.Underline = undefined;
        }
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_FontSize:
        if (undefined != Data.Old) {
            this.Pr.FontSize = Data.Old;
        } else {
            this.Pr.FontSize = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_Color:
        if (undefined != Data.Old) {
            this.Pr.Color = Data.Old;
        } else {
            this.Pr.Color = undefined;
        }
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_Unifill:
        if (undefined != Data.Old) {
            this.Pr.Unifill = Data.Old;
        } else {
            this.Pr.Unifill = undefined;
        }
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_VertAlign:
        if (undefined != Data.Old) {
            this.Pr.VertAlign = Data.Old;
        } else {
            this.Pr.VertAlign = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_HighLight:
        if (undefined != Data.Old) {
            this.Pr.HighLight = Data.Old;
        } else {
            this.Pr.HighLight = undefined;
        }
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_RStyle:
        if (undefined != Data.Old) {
            this.Pr.RStyle = Data.Old;
        } else {
            this.Pr.RStyle = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_Spacing:
        if (undefined != Data.Old) {
            this.Pr.Spacing = Data.Old;
        } else {
            this.Pr.Spacing = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_DStrikeout:
        if (undefined != Data.Old) {
            this.Pr.DStrikeout = Data.Old;
        } else {
            this.Pr.DStrikeout = undefined;
        }
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_Caps:
        if (undefined != Data.Old) {
            this.Pr.Caps = Data.Old;
        } else {
            this.Pr.Caps = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_SmallCaps:
        if (undefined != Data.Old) {
            this.Pr.SmallCaps = Data.Old;
        } else {
            this.Pr.SmallCaps = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_Position:
        if (undefined != Data.Old) {
            this.Pr.Position = Data.Old;
        } else {
            this.Pr.Position = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_RFonts:
        if (undefined != Data.Old) {
            this.Pr.RFonts = Data.Old;
        } else {
            this.Pr.RFonts = new CRFonts();
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_RFonts_Ascii:
        if (undefined != Data.Old) {
            this.Pr.RFonts.Ascii = Data.Old;
        } else {
            this.Pr.RFonts.Ascii = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_RFonts_HAnsi:
        if (undefined != Data.Old) {
            this.Pr.RFonts.HAnsi = Data.Old;
        } else {
            this.Pr.RFonts.HAnsi = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_RFonts_CS:
        if (undefined != Data.Old) {
            this.Pr.RFonts.CS = Data.Old;
        } else {
            this.Pr.RFonts.CS = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_RFonts_EastAsia:
        if (undefined != Data.Old) {
            this.Pr.RFonts.EastAsia = Data.Old;
        } else {
            this.Pr.RFonts.EastAsia = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_RFonts_Hint:
        if (undefined != Data.Old) {
            this.Pr.RFonts.Hint = Data.Old;
        } else {
            this.Pr.RFonts.Hint = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_Lang:
        if (undefined != Data.Old) {
            this.Pr.Lang = Data.Old;
        } else {
            this.Pr.Lang = new CLang();
        }
        this.Recalc_CompiledPr(false);
        this.protected_UpdateSpellChecking();
        break;
    case historyitem_ParaRun_Lang_Bidi:
        if (undefined != Data.Old) {
            this.Pr.Lang.Bidi = Data.Old;
        } else {
            this.Pr.Lang.Bidi = undefined;
        }
        this.Recalc_CompiledPr(false);
        this.protected_UpdateSpellChecking();
        break;
    case historyitem_ParaRun_Lang_EastAsia:
        if (undefined != Data.Old) {
            this.Pr.Lang.EastAsia = Data.Old;
        } else {
            this.Pr.Lang.EastAsia = undefined;
        }
        this.Recalc_CompiledPr(false);
        this.protected_UpdateSpellChecking();
        break;
    case historyitem_ParaRun_Lang_Val:
        if (undefined != Data.Old) {
            this.Pr.Lang.Val = Data.Old;
        } else {
            this.Pr.Lang.Val = undefined;
        }
        this.Recalc_CompiledPr(false);
        this.protected_UpdateSpellChecking();
        break;
    case historyitem_ParaRun_Shd:
        this.Pr.Shd = Data.Old;
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_MathStyle:
        this.MathPrp.sty = Data.Old;
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_MathPrp:
        this.MathPrp = Data.Old;
        this.Recalc_CompiledPr(true);
        break;
    }
};
ParaRun.prototype.Redo = function (Data) {
    var Type = Data.Type;
    switch (Type) {
    case historyitem_ParaRun_AddItem:
        var Pos = Data.Pos;
        var Array_start = this.Content.slice(0, Pos);
        var Array_end = this.Content.slice(Pos);
        this.Content = Array_start.concat(Data.Items, Array_end);
        this.RecalcInfo.Measure = true;
        this.protected_UpdateSpellChecking();
        this.private_UpdateMathResize();
        break;
    case historyitem_ParaRun_RemoveItem:
        this.Content.splice(Data.Pos, Data.EndPos - Data.Pos + 1);
        this.RecalcInfo.Measure = true;
        this.protected_UpdateSpellChecking();
        this.private_UpdateMathResize();
        break;
    case historyitem_ParaRun_TextPr:
        if (undefined != Data.New) {
            this.Pr = Data.New;
        } else {
            this.Pr = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_Bold:
        if (undefined != Data.New) {
            this.Pr.Bold = Data.New;
        } else {
            this.Pr.Bold = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_Italic:
        if (undefined != Data.New) {
            this.Pr.Italic = Data.New;
        } else {
            this.Pr.Italic = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_Strikeout:
        if (undefined != Data.New) {
            this.Pr.Strikeout = Data.New;
        } else {
            this.Pr.Strikeout = undefined;
        }
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_Underline:
        if (undefined != Data.New) {
            this.Pr.Underline = Data.New;
        } else {
            this.Pr.Underline = undefined;
        }
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_FontSize:
        if (undefined != Data.New) {
            this.Pr.FontSize = Data.New;
        } else {
            this.Pr.FontSize = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_Color:
        if (undefined != Data.New) {
            this.Pr.Color = Data.New;
        } else {
            this.Pr.Color = undefined;
        }
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_Unifill:
        if (undefined != Data.New) {
            this.Pr.Unifill = Data.New;
        } else {
            this.Pr.Unifill = undefined;
        }
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_VertAlign:
        if (undefined != Data.New) {
            this.Pr.VertAlign = Data.New;
        } else {
            this.Pr.VertAlign = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_HighLight:
        if (undefined != Data.New) {
            this.Pr.HighLight = Data.New;
        } else {
            this.Pr.HighLight = undefined;
        }
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_RStyle:
        if (undefined != Data.New) {
            this.Pr.RStyle = Data.New;
        } else {
            this.Pr.RStyle = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_Spacing:
        if (undefined != Data.New) {
            this.Pr.Spacing = Data.New;
        } else {
            this.Pr.Spacing = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_DStrikeout:
        if (undefined != Data.New) {
            this.Pr.DStrikeout = Data.New;
        } else {
            this.Pr.DStrikeout = undefined;
        }
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_Caps:
        if (undefined != Data.New) {
            this.Pr.Caps = Data.New;
        } else {
            this.Pr.Caps = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_SmallCaps:
        if (undefined != Data.New) {
            this.Pr.SmallCaps = Data.New;
        } else {
            this.Pr.SmallCaps = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_Position:
        if (undefined != Data.New) {
            this.Pr.Position = Data.New;
        } else {
            this.Pr.Position = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_RFonts:
        if (undefined != Data.New) {
            this.Pr.RFonts = Data.New;
        } else {
            this.Pr.RFonts = new CRFonts();
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_RFonts_Ascii:
        if (undefined != Data.New) {
            this.Pr.RFonts.Ascii = Data.New;
        } else {
            this.Pr.RFonts.Ascii = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_RFonts_HAnsi:
        if (undefined != Data.New) {
            this.Pr.RFonts.HAnsi = Data.New;
        } else {
            this.Pr.RFonts.HAnsi = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_RFonts_CS:
        if (undefined != Data.New) {
            this.Pr.RFonts.CS = Data.New;
        } else {
            this.Pr.RFonts.CS = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_RFonts_EastAsia:
        if (undefined != Data.New) {
            this.Pr.RFonts.EastAsia = Data.New;
        } else {
            this.Pr.RFonts.EastAsia = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_RFonts_Hint:
        if (undefined != Data.New) {
            this.Pr.RFonts.Hint = Data.New;
        } else {
            this.Pr.RFonts.Hint = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_Lang:
        if (undefined != Data.New) {
            this.Pr.Lang = Data.New;
        } else {
            this.Pr.Lang = new CLang();
        }
        this.Recalc_CompiledPr(false);
        this.protected_UpdateSpellChecking();
        break;
    case historyitem_ParaRun_Lang_Bidi:
        if (undefined != Data.New) {
            this.Pr.Lang.Bidi = Data.New;
        } else {
            this.Pr.Lang.Bidi = undefined;
        }
        this.Recalc_CompiledPr(false);
        this.protected_UpdateSpellChecking();
        break;
    case historyitem_ParaRun_Lang_EastAsia:
        if (undefined != Data.New) {
            this.Pr.Lang.EastAsia = Data.New;
        } else {
            this.Pr.Lang.EastAsia = undefined;
        }
        this.Recalc_CompiledPr(false);
        this.protected_UpdateSpellChecking();
        break;
    case historyitem_ParaRun_Lang_Val:
        if (undefined != Data.New) {
            this.Pr.Lang.Val = Data.New;
        } else {
            this.Pr.Lang.Val = undefined;
        }
        this.Recalc_CompiledPr(false);
        this.protected_UpdateSpellChecking();
        break;
    case historyitem_ParaRun_Shd:
        this.Pr.Shd = Data.New;
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_MathStyle:
        this.MathPrp.sty = Data.New;
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_MathPrp:
        this.MathPrp = Data.New;
        this.Recalc_CompiledPr(true);
        break;
    }
};
ParaRun.prototype.Check_HistoryUninon = function (Data1, Data2) {
    var Type1 = Data1.Type;
    var Type2 = Data2.Type;
    if (historyitem_ParaRun_AddItem === Type1 && historyitem_ParaRun_AddItem === Type2) {
        if (1 === Data1.Items.length && 1 === Data2.Items.length && Data1.Pos === Data2.Pos - 1 && para_Text === Data1.Items[0].Type && para_Text === Data2.Items[0].Type) {
            return true;
        }
    }
    return false;
};
ParaRun.prototype.Save_Changes = function (Data, Writer) {
    Writer.WriteLong(historyitem_type_ParaRun);
    var Type = Data.Type;
    Writer.WriteLong(Type);
    switch (Type) {
    case historyitem_ParaRun_AddItem:
        var bArray = Data.UseArray;
        var Count = Data.Items.length;
        if (false === Data.Color) {
            Writer.WriteBool(false);
        } else {
            Writer.WriteBool(true);
        }
        Writer.WriteLong(Count);
        for (var Index = 0; Index < Count; Index++) {
            if (true === bArray) {
                Writer.WriteLong(Data.PosArray[Index]);
            } else {
                Writer.WriteLong(Data.Pos + Index);
            }
            Data.Items[Index].Write_ToBinary(Writer);
        }
        break;
    case historyitem_ParaRun_RemoveItem:
        var bArray = Data.UseArray;
        var Count = Data.Items.length;
        var StartPos = Writer.GetCurPosition();
        Writer.Skip(4);
        var RealCount = Count;
        for (var Index = 0; Index < Count; Index++) {
            if (true === bArray) {
                if (false === Data.PosArray[Index]) {
                    RealCount--;
                } else {
                    Writer.WriteLong(Data.PosArray[Index]);
                }
            } else {
                Writer.WriteLong(Data.Pos);
            }
        }
        var EndPos = Writer.GetCurPosition();
        Writer.Seek(StartPos);
        Writer.WriteLong(RealCount);
        Writer.Seek(EndPos);
        break;
    case historyitem_ParaRun_TextPr:
        this.Pr.Write_ToBinary(Writer);
        break;
    case historyitem_ParaRun_Bold:
        case historyitem_ParaRun_Italic:
        case historyitem_ParaRun_Strikeout:
        case historyitem_ParaRun_Underline:
        if (undefined != Data.New) {
            Writer.WriteBool(false);
            Writer.WriteBool(Data.New);
        } else {
            Writer.WriteBool(true);
        }
        break;
    case historyitem_ParaRun_FontSize:
        if (undefined != Data.New) {
            Writer.WriteBool(false);
            Writer.WriteDouble(Data.New);
        } else {
            Writer.WriteBool(true);
        }
        break;
    case historyitem_ParaRun_Color:
        if (undefined != Data.New) {
            Writer.WriteBool(false);
            Data.New.Write_ToBinary(Writer);
        } else {
            Writer.WriteBool(true);
        }
        break;
    case historyitem_ParaRun_Unifill:
        if (undefined != Data.New) {
            Writer.WriteBool(false);
            Data.New.Write_ToBinary(Writer);
        } else {
            Writer.WriteBool(true);
        }
        break;
    case historyitem_ParaRun_VertAlign:
        if (undefined != Data.New) {
            Writer.WriteBool(false);
            Writer.WriteLong(Data.New);
        } else {
            Writer.WriteBool(true);
        }
        break;
    case historyitem_ParaRun_HighLight:
        if (undefined != Data.New) {
            Writer.WriteBool(false);
            if (highlight_None != Data.New) {
                Writer.WriteBool(false);
                Data.New.Write_ToBinary(Writer);
            } else {
                Writer.WriteBool(true);
            }
        } else {
            Writer.WriteBool(true);
        }
        break;
    case historyitem_ParaRun_RStyle:
        if (undefined != Data.New) {
            Writer.WriteBool(false);
            Writer.WriteString2(Data.New);
        } else {
            Writer.WriteBool(true);
        }
        break;
    case historyitem_ParaRun_Spacing:
        case historyitem_ParaRun_Position:
        if (undefined != Data.New) {
            Writer.WriteBool(false);
            Writer.WriteDouble(Data.New);
        } else {
            Writer.WriteBool(true);
        }
        break;
    case historyitem_ParaRun_DStrikeout:
        case historyitem_ParaRun_Caps:
        case historyitem_ParaRun_SmallCaps:
        if (undefined != Data.New) {
            Writer.WriteBool(false);
            Writer.WriteBool(Data.New);
        } else {
            Writer.WriteBool(true);
        }
        break;
    case historyitem_ParaRun_RFonts:
        if (undefined != Data.New) {
            Writer.WriteBool(false);
            Data.New.Write_ToBinary(Writer);
        } else {
            Writer.WriteBool(true);
        }
        break;
    case historyitem_ParaRun_RFonts_Ascii:
        case historyitem_ParaRun_RFonts_HAnsi:
        case historyitem_ParaRun_RFonts_CS:
        case historyitem_ParaRun_RFonts_EastAsia:
        if (undefined != Data.New) {
            Writer.WriteBool(false);
            Writer.WriteString2(Data.New.Name);
        } else {
            Writer.WriteBool(true);
        }
        break;
    case historyitem_ParaRun_RFonts_Hint:
        if (undefined != Data.New) {
            Writer.WriteBool(false);
            Writer.WriteLong(Data.New);
        } else {
            Writer.WriteBool(true);
        }
        break;
    case historyitem_ParaRun_Lang:
        if (undefined != Data.New) {
            Writer.WriteBool(false);
            Data.New.Write_ToBinary(Writer);
        } else {
            Writer.WriteBool(true);
        }
        break;
    case historyitem_ParaRun_Lang_Bidi:
        case historyitem_ParaRun_Lang_EastAsia:
        case historyitem_ParaRun_Lang_Val:
        if (undefined != Data.New) {
            Writer.WriteBool(false);
            Writer.WriteLong(Data.New);
        } else {
            Writer.WriteBool(true);
        }
        break;
    case historyitem_ParaRun_Shd:
        if (undefined !== Data.New) {
            Writer.WriteBool(false);
            Data.New.Write_ToBinary(Writer);
        } else {
            Writer.WriteBool(true);
        }
        break;
    case historyitem_ParaRun_MathStyle:
        if (undefined != Data.New) {
            Writer.WriteBool(false);
            Writer.WriteLong(Data.New);
        } else {
            Writer.WriteBool(true);
        }
        break;
    case historyitem_ParaRun_MathPrp:
        var StartPos = Writer.GetCurPosition();
        Writer.Skip(4);
        var Flags = 0;
        if (undefined != this.MathPrp.aln) {
            Writer.WriteBool(this.MathPrp.aln);
            Flags |= 1;
        }
        if (undefined != this.MathPrp.brk) {
            Writer.WriteBool(this.MathPrp.brk);
            Flags |= 2;
        }
        if (undefined != this.MathPrp.lit) {
            Writer.WriteBool(this.MathPrp.lit);
            Flags |= 4;
        }
        if (undefined != this.MathPrp.nor) {
            Writer.WriteBool(this.MathPrp.nor);
            Flags |= 8;
        }
        if (undefined != this.MathPrp.scr) {
            Writer.WriteLong(this.MathPrp.scr);
            Flags |= 16;
        }
        if (undefined != this.MathPrp.sty) {
            Writer.WriteLong(this.MathPrp.sty);
            Flags |= 32;
        }
        var EndPos = Writer.GetCurPosition();
        Writer.Seek(StartPos);
        Writer.WriteLong(Flags);
        Writer.Seek(EndPos);
        break;
    }
    return Writer;
};
ParaRun.prototype.Load_Changes = function (Reader, Reader2, Color) {
    var ClassType = Reader.GetLong();
    if (historyitem_type_ParaRun != ClassType) {
        return;
    }
    var Type = Reader.GetLong();
    switch (Type) {
    case historyitem_ParaRun_AddItem:
        var bColorChanges = Reader.GetBool();
        var Count = Reader.GetLong();
        for (var Index = 0; Index < Count; Index++) {
            var Pos = this.m_oContentChanges.Check(contentchanges_Add, Reader.GetLong());
            var Element = ParagraphContent_Read_FromBinary(Reader);
            if (null != Element) {
                if (true === bColorChanges && null !== Color) {
                    this.CollaborativeMarks.Update_OnAdd(Pos);
                    this.CollaborativeMarks.Add(Pos, Pos + 1, Color);
                    CollaborativeEditing.Add_ChangedClass(this);
                }
                this.Content.splice(Pos, 0, Element);
            }
        }
        this.RecalcInfo.Measure = true;
        this.protected_UpdateSpellChecking();
        this.private_UpdateMathResize();
        break;
    case historyitem_ParaRun_RemoveItem:
        var Count = Reader.GetLong();
        for (var Index = 0; Index < Count; Index++) {
            var ChangesPos = this.m_oContentChanges.Check(contentchanges_Remove, Reader.GetLong());
            if (false === ChangesPos) {
                continue;
            }
            this.CollaborativeMarks.Update_OnRemove(ChangesPos, 1);
            this.Content.splice(ChangesPos, 1);
        }
        this.RecalcInfo.Measure = true;
        this.protected_UpdateSpellChecking();
        this.private_UpdateMathResize();
        break;
    case historyitem_ParaRun_TextPr:
        this.Pr = new CTextPr();
        this.Pr.Read_FromBinary(Reader);
        break;
    case historyitem_ParaRun_Bold:
        if (true === Reader.GetBool()) {
            this.Pr.Bold = undefined;
        } else {
            this.Pr.Bold = Reader.GetBool();
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_Italic:
        if (true === Reader.GetBool()) {
            this.Pr.Italic = undefined;
        } else {
            this.Pr.Italic = Reader.GetBool();
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_Strikeout:
        if (true === Reader.GetBool()) {
            this.Pr.Strikeout = undefined;
        } else {
            this.Pr.Strikeout = Reader.GetBool();
        }
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_Underline:
        if (true != Reader.GetBool()) {
            this.Pr.Underline = Reader.GetBool();
        } else {
            this.Pr.Underline = undefined;
        }
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_FontSize:
        if (true != Reader.GetBool()) {
            this.Pr.FontSize = Reader.GetDouble();
        } else {
            this.Pr.FontSize = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_Color:
        if (true != Reader.GetBool()) {
            this.Pr.Color = new CDocumentColor(0, 0, 0, false);
            this.Pr.Color.Read_FromBinary(Reader);
        } else {
            this.Pr.Color = undefined;
        }
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_Unifill:
        if (true != Reader.GetBool()) {
            var unifill = new CUniFill();
            unifill.Read_FromBinary(Reader);
            this.Pr.Unifill = unifill;
        } else {
            this.Pr.Unifill = undefined;
        }
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_VertAlign:
        if (true != Reader.GetBool()) {
            this.Pr.VertAlign = Reader.GetLong();
        } else {
            this.Pr.VertAlign = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_HighLight:
        if (true != Reader.GetBool()) {
            if (true != Reader.GetBool()) {
                this.Pr.HighLight = new CDocumentColor(0, 0, 0);
                this.Pr.HighLight.Read_FromBinary(Reader);
            } else {
                this.Pr.HighLight = highlight_None;
            }
        } else {
            this.Pr.HighLight = undefined;
        }
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_RStyle:
        if (true != Reader.GetBool()) {
            this.Pr.RStyle = Reader.GetString2();
        } else {
            this.Pr.RStyle = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_Spacing:
        if (true != Reader.GetBool()) {
            this.Pr.Spacing = Reader.GetDouble();
        } else {
            this.Pr.Spacing = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_DStrikeout:
        if (true != Reader.GetBool()) {
            this.Pr.DStrikeout = Reader.GetBool();
        } else {
            this.Pr.DStrikeout = undefined;
        }
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_Caps:
        if (true != Reader.GetBool()) {
            this.Pr.Caps = Reader.GetBool();
        } else {
            this.Pr.Caps = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_SmallCaps:
        if (true != Reader.GetBool()) {
            this.Pr.SmallCaps = Reader.GetBool();
        } else {
            this.Pr.SmallCaps = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_Position:
        if (true != Reader.GetBool()) {
            this.Pr.Position = Reader.GetDouble();
        } else {
            this.Pr.Position = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_RFonts:
        if (false === Reader.GetBool()) {
            this.Pr.RFonts = new CRFonts();
            this.Pr.RFonts.Read_FromBinary(Reader);
        } else {
            this.Pr.RFonts = new CRFonts();
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_RFonts_Ascii:
        if (false === Reader.GetBool()) {
            this.Pr.RFonts.Ascii = {
                Name: Reader.GetString2(),
                Index: -1
            };
        } else {
            this.Pr.RFonts.Ascii = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_RFonts_HAnsi:
        if (false === Reader.GetBool()) {
            this.Pr.RFonts.HAnsi = {
                Name: Reader.GetString2(),
                Index: -1
            };
        } else {
            this.Pr.RFonts.HAnsi = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_RFonts_CS:
        if (false === Reader.GetBool()) {
            this.Pr.RFonts.CS = {
                Name: Reader.GetString2(),
                Index: -1
            };
        } else {
            this.Pr.RFonts.CS = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_RFonts_EastAsia:
        if (false === Reader.GetBool()) {
            this.Pr.RFonts.EastAsia = {
                Name: Reader.GetString2(),
                Index: -1
            };
        } else {
            this.Pr.RFonts.EastAsia = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_RFonts_Hint:
        if (false === Reader.GetBool()) {
            this.Pr.RFonts.Hint = Reader.GetLong();
        } else {
            this.Pr.RFonts.Hint = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_Lang:
        if (false === Reader.GetBool()) {
            this.Pr.Lang = new CLang();
            this.Pr.Lang.Read_FromBinary(Reader);
        } else {
            this.Pr.Lang = new CLang();
        }
        this.Recalc_CompiledPr(true);
        this.protected_UpdateSpellChecking();
        break;
    case historyitem_ParaRun_Lang_Bidi:
        if (false === Reader.GetBool()) {
            this.Pr.Lang.Bidi = Reader.GetLong();
        } else {
            this.Pr.Lang.Bidi = undefined;
        }
        this.Recalc_CompiledPr(true);
        this.protected_UpdateSpellChecking();
        break;
    case historyitem_ParaRun_Lang_EastAsia:
        if (false === Reader.GetBool()) {
            this.Pr.Lang.EastAsia = Reader.GetLong();
        } else {
            this.Pr.Lang.EastAsia = undefined;
        }
        this.Recalc_CompiledPr(true);
        this.protected_UpdateSpellChecking();
        break;
    case historyitem_ParaRun_Lang_Val:
        if (false === Reader.GetBool()) {
            this.Pr.Lang.Val = Reader.GetLong();
        } else {
            this.Pr.Lang.Val = undefined;
        }
        this.Recalc_CompiledPr(true);
        this.protected_UpdateSpellChecking();
        break;
    case historyitem_ParaRun_Shd:
        if (false === Reader.GetBool()) {
            this.Pr.Shd = new CDocumentShd();
            this.Pr.Shd.Read_FromBinary(Reader);
        } else {
            this.Pr.Shd = undefined;
        }
        this.Recalc_CompiledPr(false);
        break;
    case historyitem_ParaRun_MathStyle:
        if (false === Reader.GetBool()) {
            this.MathPrp.sty = Reader.GetLong();
        } else {
            this.MathPrp.sty = undefined;
        }
        this.Recalc_CompiledPr(true);
        break;
    case historyitem_ParaRun_MathPrp:
        var Flags = Reader.GetLong();
        if (Flags & 1) {
            this.MathPrp.aln = Reader.GetBool();
        }
        if (Flags & 2) {
            this.MathPrp.brk = Reader.GetBool();
        }
        if (Flags & 4) {
            this.MathPrp.lit = Reader.GetBool();
        }
        if (Flags & 8) {
            this.MathPrp.nor = Reader.GetBool();
        }
        if (Flags & 16) {
            this.MathPrp.scr = Reader.GetLong();
        }
        if (Flags & 32) {
            this.MathPrp.sty = Reader.GetLong();
        }
        this.Recalc_CompiledPr(true);
        break;
    }
};
ParaRun.prototype.Write_ToBinary2 = function (Writer) {
    Writer.WriteLong(historyitem_type_ParaRun);
    Writer.WriteLong(this.Type);
    var ParagraphToWrite, PrToWrite, ContentToWrite;
    if (this.StartState) {
        ParagraphToWrite = this.StartState.Paragraph;
        PrToWrite = this.StartState.Pr;
        ContentToWrite = this.StartState.Content;
    } else {
        ParagraphToWrite = this.Paragraph;
        PrToWrite = this.Pr;
        ContentToWrite = this.Content;
    }
    Writer.WriteString2(this.Id);
    Writer.WriteString2(null !== ParagraphToWrite && undefined !== ParagraphToWrite ? ParagraphToWrite.Get_Id() : "");
    PrToWrite.Write_ToBinary(Writer);
    var Count = ContentToWrite.length;
    Writer.WriteLong(Count);
    for (var Index = 0; Index < Count; Index++) {
        var Item = ContentToWrite[Index];
        Item.Write_ToBinary(Writer);
    }
};
ParaRun.prototype.Read_FromBinary2 = function (Reader) {
    this.Type = Reader.GetLong();
    this.Id = Reader.GetString2();
    this.Paragraph = g_oTableId.Get_ById(Reader.GetString2());
    this.Pr = new CTextPr();
    this.Pr.Read_FromBinary(Reader);
    if (para_Math_Run == this.Type) {
        this.MathPrp = new CMPrp();
        this.size = new CMathSize();
    }
    if (undefined !== editor && true === editor.isDocumentEditor) {
        var Count = Reader.GetLong();
        this.Content = [];
        for (var Index = 0; Index < Count; Index++) {
            var Element = ParagraphContent_Read_FromBinary(Reader);
            if (null !== Element) {
                this.Content.push(Element);
            }
        }
    }
};
ParaRun.prototype.Clear_CollaborativeMarks = function () {
    this.CollaborativeMarks.Clear();
};
ParaRun.prototype.private_UpdateMathResize = function () {
    if (para_Math_Run === this.Type && undefined !== this.Parent && null !== this.Parent && null !== this.Parent.ParaMath) {
        this.Parent.ParaMath.SetNeedResize();
    }
};
ParaRun.prototype.private_RecalcCtrPrp = function () {
    if (para_Math_Run === this.Type && undefined !== this.Parent && null !== this.Parent && null !== this.Parent.ParaMath) {
        this.Parent.ParaMath.SetRecalcCtrPrp(this);
    }
};
function CParaRunSelection() {
    this.Use = false;
    this.StartPos = 0;
    this.EndPos = 0;
}
function CParaRunState() {
    this.Selection = new CParaRunSelection();
    this.ContentPos = 0;
}
function CParaRunRecalcInfo() {
    this.TextPr = true;
    this.Measure = true;
    this.Recalc = true;
    this.RunLen = 0;
    this.NumberingItem = null;
    this.NumberingUse = false;
    this.NumberingAdd = true;
}
CParaRunRecalcInfo.prototype = {
    Reset: function () {
        this.TextPr = true;
        this.Measure = true;
        this.Recalc = true;
        this.RunLen = 0;
    }
};
function CParaRunRange(StartPos, EndPos) {
    this.StartPos = StartPos;
    this.EndPos = EndPos;
}
function CParaRunLine() {
    this.Ranges = [];
    this.Ranges[0] = new CParaRunRange(0, 0);
    this.RangesLength = 0;
}
CParaRunLine.prototype = {
    Add_Range: function (RangeIndex, StartPos, EndPos) {
        if (0 !== RangeIndex) {
            this.Ranges[RangeIndex] = new CParaRunRange(StartPos, EndPos);
            this.RangesLength = RangeIndex + 1;
        } else {
            this.Ranges[0].StartPos = StartPos;
            this.Ranges[0].EndPos = EndPos;
            this.RangesLength = 1;
        }
        if (this.Ranges.length > this.RangesLength) {
            this.Ranges.legth = this.RangesLength;
        }
    },
    Copy: function () {
        var NewLine = new CParaRunLine();
        NewLine.RangesLength = this.RangesLength;
        for (var CurRange = 0; CurRange < this.RangesLength; CurRange++) {
            var Range = this.Ranges[CurRange];
            NewLine.Ranges[CurRange] = new CParaRunRange(Range.StartPos, Range.EndPos);
        }
        return NewLine;
    },
    Compare: function (OtherLine, CurRange) {
        if (this.RangesLength <= CurRange || OtherLine.RangesLength <= CurRange) {
            return false;
        }
        var OtherRange = OtherLine.Ranges[CurRange];
        var ThisRange = this.Ranges[CurRange];
        if (OtherRange.StartPos !== ThisRange.StartPos || OtherRange.EndPos !== ThisRange.EndPos) {
            return false;
        }
        return true;
    }
};
var pararun_CollaborativeMark_Start = 0;
var pararun_CollaborativeMark_End = 1;
function CParaRunCollaborativeMark(Pos, Type) {
    this.Pos = Pos;
    this.Type = Type;
}
function FontSize_IncreaseDecreaseValue(bIncrease, Value) {
    var Sizes = [8, 9, 10, 11, 12, 14, 16, 18, 20, 22, 24, 26, 28, 36, 48, 72];
    var NewValue = Value;
    if (true === bIncrease) {
        if (Value < Sizes[0]) {
            if (Value >= Sizes[0] - 1) {
                NewValue = Sizes[0];
            } else {
                NewValue = Math.floor(Value + 1);
            }
        } else {
            if (Value >= Sizes[Sizes.length - 1]) {
                NewValue = Math.min(300, Math.floor(Value / 10 + 1) * 10);
            } else {
                for (var Index = 0; Index < Sizes.length; Index++) {
                    if (Value < Sizes[Index]) {
                        NewValue = Sizes[Index];
                        break;
                    }
                }
            }
        }
    } else {
        if (Value <= Sizes[0]) {
            NewValue = Math.max(Math.floor(Value - 1), 1);
        } else {
            if (Value > Sizes[Sizes.length - 1]) {
                if (Value <= Math.floor(Sizes[Sizes.length - 1] / 10 + 1) * 10) {
                    NewValue = Sizes[Sizes.length - 1];
                } else {
                    NewValue = Math.floor(Math.ceil(Value / 10) - 1) * 10;
                }
            } else {
                for (var Index = Sizes.length - 1; Index >= 0; Index--) {
                    if (Value > Sizes[Index]) {
                        NewValue = Sizes[Index];
                        break;
                    }
                }
            }
        }
    }
    return NewValue;
}
function CRunCollaborativeMarks() {
    this.Ranges = [];
    this.DrawingObj = {};
}
CRunCollaborativeMarks.prototype = {
    Add: function (PosS, PosE, Color) {
        var Count = this.Ranges.length;
        for (var Index = 0; Index < Count; Index++) {
            var Range = this.Ranges[Index];
            if (PosS > Range.PosE) {
                continue;
            } else {
                if (PosS >= Range.PosS && PosS <= Range.PosE && PosE >= Range.PosS && PosE <= Range.PosE) {
                    if (true !== Color.Compare(Range.Color)) {
                        var _PosE = Range.PosE;
                        Range.PosE = PosS;
                        this.Ranges.splice(Index + 1, 0, new CRunCollaborativeRange(PosS, PosE, Color));
                        this.Ranges.splice(Index + 2, 0, new CRunCollaborativeRange(PosE, _PosE, Range.Color));
                    }
                    return;
                } else {
                    if (PosE < Range.PosS) {
                        this.Ranges.splice(Index, 0, new CRunCollaborativeRange(PosS, PosE, Color));
                        return;
                    } else {
                        if (PosS < Range.PosS && PosE > Range.PosE) {
                            Range.PosS = PosS;
                            Range.PosE = PosE;
                            Range.Color = Color;
                            return;
                        } else {
                            if (PosS < Range.PosS) {
                                if (true === Color.Compare(Range.Color)) {
                                    Range.PosS = PosS;
                                } else {
                                    Range.PosS = PosE;
                                    this.Ranges.splice(Index, 0, new CRunCollaborativeRange(PosS, PosE, Color));
                                }
                                return;
                            } else {
                                if (true === Color.Compare(Range.Color)) {
                                    Range.PosE = PosE;
                                } else {
                                    Range.PosE = PosS;
                                    this.Ranges.splice(Index + 1, 0, new CRunCollaborativeRange(PosS, PosE, Color));
                                }
                                return;
                            }
                        }
                    }
                }
            }
        }
        this.Ranges.push(new CRunCollaborativeRange(PosS, PosE, Color));
    },
    Update_OnAdd: function (Pos) {
        var Count = this.Ranges.length;
        for (var Index = 0; Index < Count; Index++) {
            var Range = this.Ranges[Index];
            if (Pos <= Range.PosS) {
                Range.PosS++;
                Range.PosE++;
            } else {
                if (Pos > Range.PosS && Pos < Range.PosE) {
                    var NewRange = new CRunCollaborativeRange(Pos + 1, Range.PosE + 1, Range.Color.Copy());
                    this.Ranges.splice(Index + 1, 0, NewRange);
                    Range.PosE = Pos;
                    Count++;
                    Index++;
                }
            }
        }
    },
    Update_OnRemove: function (Pos, Count) {
        var Len = this.Ranges.length;
        for (var Index = 0; Index < Len; Index++) {
            var Range = this.Ranges[Index];
            var PosE = Pos + Count;
            if (Pos < Range.PosS) {
                if (PosE <= Range.PosS) {
                    Range.PosS -= Count;
                    Range.PosE -= Count;
                } else {
                    if (PosE >= Range.PosE) {
                        this.Ranges.splice(Index, 1);
                        Len--;
                        Index--;
                        continue;
                    } else {
                        Range.PosS = Pos;
                        Range.PosE -= Count;
                    }
                }
            } else {
                if (Pos >= Range.PosS && Pos < Range.PosE) {
                    if (PosE >= Range.PosE) {
                        Range.PosE = Pos;
                    } else {
                        Range.PosE -= Count;
                    }
                } else {
                    continue;
                }
            }
        }
    },
    Clear: function () {
        this.Ranges = [];
    },
    Init_Drawing: function () {
        this.DrawingObj = {};
        var Count = this.Ranges.length;
        for (var CurPos = 0; CurPos < Count; CurPos++) {
            var Range = this.Ranges[CurPos];
            for (var Pos = Range.PosS; Pos < Range.PosE; Pos++) {
                this.DrawingObj[Pos] = Range.Color;
            }
        }
    },
    Check: function (Pos) {
        if (undefined !== this.DrawingObj[Pos]) {
            return this.DrawingObj[Pos];
        }
        return null;
    }
};
function CRunCollaborativeRange(PosS, PosE, Color) {
    this.PosS = PosS;
    this.PosE = PosE;
    this.Color = Color;
}
ParaRun.prototype.Math_SetPosition = function (pos) {
    var w = 0;
    for (var i = 0; i < this.Content.length; i++) {
        var NewPos = new CMathPosition();
        NewPos.x = pos.x + w;
        NewPos.y = pos.y - this.size.ascent;
        this.Content[i].setPosition(NewPos);
        w += this.Content[i].size.width;
    }
};
ParaRun.prototype.Math_Draw = function (x, y, pGraphics) {
    var X = x;
    var Y = y + this.size.ascent;
    var oWPrp = this.Get_CompiledPr(false);
    var Font = {
        Bold: oWPrp.Bold,
        Italic: oWPrp.Italic,
        FontFamily: {
            Name: oWPrp.FontFamily.Name,
            Index: oWPrp.FontFamily.Index
        },
        FontSize: MathApplyArgSize(oWPrp.FontSize, this.Parent.Compiled_ArgSz.value)
    };
    if (this.IsMathematicalText()) {
        Font.Italic = false;
        Font.Bold = false;
    }
    pGraphics.SetFont(Font);
    pGraphics.b_color1(0, 0, 0, 255);
    for (var i = 0; i < this.Content.length; i++) {
        this.Content[i].draw(X, Y, pGraphics);
    }
};
ParaRun.prototype.Math_Recalculate = function (oMeasure, RPI, WidthPoints) {
    var RangeStartPos = 0;
    var RangeEndPos = this.Content.length;
    this.protected_AddRange(0, 0);
    this.protected_FillRange(0, 0, RangeStartPos, RangeEndPos);
    if (RPI.NeedResize) {
        var oWPrp = this.Get_CompiledPr(false);
        var Theme = this.Paragraph.Get_Theme();
        var ArgSize = this.Parent.Compiled_ArgSz.value,
        bNormalText = this.IsNormalText();
        g_oTextMeasurer.SetTextPr(oWPrp, Theme);
        var InfoMathText = new CMathInfoTextPr_2(oWPrp, ArgSize, bNormalText);
        this.bEqqArray = RPI.bEqqArray;
        this.size.SetZero();
        var widthCurr = 0,
        ascent = 0,
        descent = 0;
        var Lng = this.Content.length;
        for (var i = 0; i < Lng; i++) {
            this.Content[i].Resize(oMeasure, RPI, InfoMathText);
            var oSize = this.Content[i].size;
            widthCurr = oSize.width;
            this.size.width += widthCurr;
            var oDescent = oSize.height - oSize.ascent;
            ascent = ascent > oSize.ascent ? ascent : oSize.ascent;
            descent = descent < oDescent ? oDescent : descent;
            if (RPI.bEqqArray) {
                if (this.Content[i].Type !== para_Math_Ampersand) {
                    WidthPoints.UpdatePoint(widthCurr);
                } else {
                    WidthPoints.AddNewAlignRange();
                }
            }
        }
        this.size.ascent = ascent;
        this.size.height = ascent + descent;
        this.TextHeight = g_oTextMeasurer.GetHeight();
        this.TextDescent = Math.abs(g_oTextMeasurer.GetDescender());
        this.TextAscent = this.TextHeight - this.TextDescent;
        this.TextAscent2 = g_oTextMeasurer.GetAscender();
    }
    if (RPI.PRS.LineTextAscent < this.TextAscent) {
        RPI.PRS.LineTextAscent = this.TextAscent;
    }
    if (RPI.PRS.LineTextAscent2 < this.TextAscent2) {
        RPI.PRS.LineTextAscent2 = this.TextAscent2;
    }
    if (RPI.PRS.LineTextDescent < this.TextDescent) {
        RPI.PRS.LineTextDescent = this.TextDescent;
    }
};
ParaRun.prototype.Math_Apply_Style = function (Value) {
    if (Value !== this.MathPrp.sty) {
        var OldValue = this.MathPrp.sty;
        this.MathPrp.sty = Value;
        History.Add(this, {
            Type: historyitem_ParaRun_MathStyle,
            New: Value,
            Old: OldValue
        });
        this.Recalc_CompiledPr(true);
    }
};
ParaRun.prototype.IsNormalText = function () {
    var comp_MPrp = this.MathPrp.GetCompiled_ScrStyles();
    return comp_MPrp.nor === true;
};
ParaRun.prototype.IsMathematicalText = function () {
    var MathText = !this.IsNormalText();
    var bMFont = this.Get_CompiledPr(false).FontFamily.Name == "Cambria Math";
    return MathText && bMFont;
};
ParaRun.prototype.getPropsForWrite = function () {
    var wRPrp = this.Pr.Copy(),
    mathRPrp = this.MathPrp.getPropsForWrite();
    return {
        wRPrp: wRPrp,
        mathRPrp: mathRPrp
    };
};
ParaRun.prototype.Math_PreRecalc = function (Parent, ParaMath, ArgSize, RPI, GapsInfo) {
    this.Parent = Parent;
    this.Paragraph = ParaMath.Paragraph;
    var FontSize = this.Get_CompiledPr(false).FontSize;
    for (var Pos = 0; Pos < this.Content.length; Pos++) {
        if (!this.Content[Pos].IsAlignPoint()) {
            GapsInfo.setGaps(this.Content[Pos], FontSize);
        }
        this.Content[Pos].PreRecalc(this);
    }
};
ParaRun.prototype.IsPlaceholder = function () {
    return this.Content.length == 1 && this.Content[0].IsPlaceholder();
};
ParaRun.prototype.fillPlaceholders = function () {
    var placeholder = new CMathText(false);
    placeholder.fillPlaceholders();
    this.Add_ToContent(0, placeholder, false);
};
ParaRun.prototype.Math_Correct_Content = function () {
    for (var i = 0; i < this.Content.length; i++) {
        if (this.Content[i].Type == para_Math_Placeholder) {
            this.Remove_FromContent(i, 1, true);
        }
    }
};
ParaRun.prototype.Set_MathPr = function (MPrp) {
    var OldValue = this.MathPrp;
    this.MathPrp = MPrp;
    History.Add(this, {
        Type: historyitem_ParaRun_MathPrp,
        New: MPrp,
        Old: OldValue
    });
    this.Recalc_CompiledPr(true);
};
ParaRun.prototype.Set_MathTextPr2 = function (TextPr, MathPr) {
    this.Set_Pr(TextPr.Copy());
    this.Set_MathPr(MathPr.Copy());
};
ParaRun.prototype.IsAccent = function () {
    return this.Parent.IsAccent();
};
ParaRun.prototype.GetCompiled_ScrStyles = function () {
    return this.MathPrp.GetCompiled_ScrStyles();
};
ParaRun.prototype.IsEqqArray = function () {
    return this.Parent.IsEqqArray();
};
ParaRun.prototype.Math_GetInfoLetter = function (Info) {
    if (this.Content.length == 1) {
        var Compiled_MPrp = this.MathPrp.GetCompiled_ScrStyles();
        Info.sty = Compiled_MPrp.sty;
        Info.scr = Compiled_MPrp.scr;
        this.Content[0].getInfoLetter(Info);
    } else {
        Info.Result = false;
    }
};
ParaRun.prototype.GetMathTextPrForMenu = function () {
    var TextPr = new CTextPr();
    if (this.IsPlaceholder()) {
        TextPr.Merge(this.Parent.GetCtrPrp());
    }
    TextPr.Merge(this.Pr);
    var MathTextPr = this.MathPrp.Copy();
    var BI = MathTextPr.GetBoldItalic();
    TextPr.Italic = BI.Italic;
    TextPr.Bold = BI.Bold;
    return TextPr;
};
ParaRun.prototype.ApplyPoints = function (PointsInfo) {
    if (this.bEqqArray) {
        this.size.width = 0;
        for (var Pos = 0; Pos < this.Content.length; Pos++) {
            if (this.Content[Pos].Type == para_Math_Ampersand) {
                PointsInfo.NextAlignRange();
                this.Content[Pos].size.width = PointsInfo.GetAlign();
            }
            this.size.width += this.Content[Pos].size.width;
        }
    }
};
ParaRun.prototype.Get_TextForAutoCorrect = function (AutoCorrectEngine, RunPos) {
    var ActionElement = AutoCorrectEngine.Get_ActionElement();
    var nCount = this.Content.length;
    for (var nPos = 0; nPos < nCount; nPos++) {
        var Item = this.Content[nPos];
        if (para_Math_Text === Item.Type) {
            AutoCorrectEngine.Add_Text(String.fromCharCode(Item.value), this, nPos, RunPos);
        }
        if (Item === ActionElement) {
            AutoCorrectEngine.Stop_CollectText();
            break;
        }
    }
    if (null === AutoCorrectEngine.TextPr) {
        AutoCorrectEngine.TextPr = this.Pr.Copy();
    }
    if (null == AutoCorrectEngine.MathPr) {
        AutoCorrectEngine.MathPr = this.MathPrp.Copy();
    }
};
ParaRun.prototype.IsShade = function () {
    var oShd = this.Get_CompiledPr(false).Shd;
    return ! (oShd === undefined || shd_Nil === oShd.Value);
};
ParaRun.prototype.Get_RangesByPos = function (Pos) {
    var Ranges = [];
    var LinesCount = this.protected_GetLinesCount();
    for (var LineIndex = 0; LineIndex < LinesCount; LineIndex++) {
        var RangesCount = this.protected_GetRangesCount(LineIndex);
        for (var RangeIndex = 0; RangeIndex < RangesCount; RangeIndex++) {
            var StartPos = this.protected_GetRangeStartPos(LineIndex, RangeIndex);
            var EndPos = this.protected_GetRangeEndPos(LineIndex, RangeIndex);
            if (StartPos <= Pos && Pos <= EndPos) {
                Ranges.push({
                    Range: (LineIndex === 0 ? RangeIndex + this.StartRange : RangeIndex),
                    Line: LineIndex + this.StartLine
                });
            }
        }
    }
    return Ranges;
};
function CParaRunStartState(Run) {
    this.Paragraph = Run.Paragraph;
    this.Pr = Run.Pr.Copy();
    this.Content = [];
    for (var i = 0; i < Run.Content.length; ++i) {
        this.Content.push(Run.Content[i]);
    }
}