Yajbir Singh
3742 lines
124 KiB
JavaScript
3742 lines
124 KiB
JavaScript
/*
|
|
* (c) Copyright Ascensio System SIA 2010-2024
|
|
*
|
|
* This program is a free software product. You can redistribute it and/or
|
|
* modify it under the terms of the GNU Affero General Public License (AGPL)
|
|
* version 3 as published by the Free Software Foundation. In accordance with
|
|
* Section 7(a) of the GNU AGPL its Section 15 shall be amended to the effect
|
|
* that Ascensio System SIA expressly excludes the warranty of non-infringement
|
|
* of any third-party rights.
|
|
*
|
|
* This program is distributed WITHOUT ANY WARRANTY; without even the implied
|
|
* warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For
|
|
* details, see the GNU AGPL at: http://www.gnu.org/licenses/agpl-3.0.html
|
|
*
|
|
* You can contact Ascensio System SIA at 20A-6 Ernesta Birznieka-Upish
|
|
* street, Riga, Latvia, EU, LV-1050.
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions
|
|
* of the Program must display Appropriate Legal Notices, as required under
|
|
* Section 5 of the GNU AGPL version 3.
|
|
*
|
|
* Pursuant to Section 7(b) of the License you must retain the original Product
|
|
* logo when distributing the program. Pursuant to Section 7(e) we decline to
|
|
* grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
* All the Product's GUI elements, including illustrations and icon sets, as
|
|
* well as technical writing content are licensed under the terms of the
|
|
* Creative Commons Attribution-ShareAlike 4.0 International. See the License
|
|
* terms at http://creativecommons.org/licenses/by-sa/4.0/legalcode
|
|
*
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
// Import
|
|
var c_oAscDocumentUnits = Asc.c_oAscDocumentUnits;
|
|
var global_mouseEvent = AscCommon.global_mouseEvent;
|
|
var g_dKoef_pix_to_mm = AscCommon.g_dKoef_pix_to_mm;
|
|
var g_dKoef_mm_to_pix = AscCommon.g_dKoef_mm_to_pix;
|
|
|
|
function CTab(pos, type, leader)
|
|
{
|
|
this.pos = pos;
|
|
this.type = type;
|
|
this.leader = leader;
|
|
}
|
|
|
|
var g_array_objects_length = 1;
|
|
|
|
var RULER_OBJECT_TYPE_PARAGRAPH = 1;
|
|
var RULER_OBJECT_TYPE_HEADER = 2;
|
|
var RULER_OBJECT_TYPE_FOOTER = 4;
|
|
var RULER_OBJECT_TYPE_TABLE = 8;
|
|
var RULER_OBJECT_TYPE_COLUMNS = 16;
|
|
|
|
function CHorRulerRepaintChecker()
|
|
{
|
|
// zoom/section check
|
|
this.Width = 0;
|
|
this.Height = 0;
|
|
|
|
// ruler type check
|
|
this.Type = 0;
|
|
|
|
// margin check
|
|
this.MarginLeft = 0;
|
|
this.MarginRight = 0;
|
|
|
|
// table column check
|
|
this.tableCols = [];
|
|
this.marginsLeft = [];
|
|
this.marginsRight = [];
|
|
|
|
this.columns = null; // CColumnsMarkup
|
|
|
|
// blit to main params
|
|
this.BlitAttack = false;
|
|
this.BlitLeft = 0;
|
|
this.BlitIndentLeft = 0;
|
|
this.BlitIndentLeftFirst = 0;
|
|
this.BlitIndentRight = 0;
|
|
this.BlitDefaultTab = 0;
|
|
this.BlitTabs = null;
|
|
this.BlitRtl = false;
|
|
|
|
this.BlitMarginLeftInd = 0;
|
|
this.BlitMarginRightInd = 0;
|
|
}
|
|
|
|
function CVerRulerRepaintChecker()
|
|
{
|
|
// zoom/section check
|
|
this.Width = 0;
|
|
this.Height = 0;
|
|
|
|
// ruler type check
|
|
this.Type = 0;
|
|
|
|
// margin check
|
|
this.MarginTop = 0;
|
|
this.MarginBottom = 0;
|
|
|
|
// header/footer check
|
|
this.HeaderTop = 0;
|
|
this.HeaderBottom = 0;
|
|
|
|
// table column check
|
|
this.rowsY = [];
|
|
this.rowsH = [];
|
|
|
|
// blit params
|
|
this.BlitAttack = false;
|
|
this.BlitTop = 0;
|
|
}
|
|
|
|
function RulerCorrectPosition(_ruler, val, margin)
|
|
{
|
|
if (AscCommon.global_keyboardEvent.AltKey)
|
|
return val;
|
|
|
|
var mm_1_4 = 10 / 4;
|
|
|
|
if (_ruler.Units == c_oAscDocumentUnits.Inch)
|
|
mm_1_4 = 25.4 / 16;
|
|
else if (_ruler.Units == c_oAscDocumentUnits.Point)
|
|
mm_1_4 = 25.4 / 12;
|
|
|
|
var mm_1_8 = mm_1_4 / 2;
|
|
|
|
if (undefined === margin)
|
|
return (((val + mm_1_8) / mm_1_4) >> 0) * mm_1_4;
|
|
|
|
if (val >= margin)
|
|
return margin + (((val - margin + mm_1_8) / mm_1_4) >> 0) * mm_1_4;
|
|
|
|
return margin + (((val - margin - mm_1_8) / mm_1_4) >> 0) * mm_1_4;
|
|
}
|
|
|
|
function RulerCheckSimpleChanges()
|
|
{
|
|
this.X = -1;
|
|
this.Y = -1;
|
|
this.IsSimple = true;
|
|
|
|
this.IsDown = false;
|
|
}
|
|
RulerCheckSimpleChanges.prototype =
|
|
{
|
|
Clear : function()
|
|
{
|
|
this.X = -1;
|
|
this.Y = -1;
|
|
this.IsSimple = true;
|
|
this.IsDown = false;
|
|
},
|
|
|
|
Reinit : function()
|
|
{
|
|
this.X = global_mouseEvent.X;
|
|
this.Y = global_mouseEvent.Y;
|
|
this.IsSimple = true;
|
|
this.IsDown = true;
|
|
},
|
|
|
|
CheckMove : function()
|
|
{
|
|
if (!this.IsDown)
|
|
return;
|
|
if (!this.IsSimple)
|
|
return;
|
|
|
|
if (Math.abs(global_mouseEvent.X - this.X) > 0 || Math.abs(global_mouseEvent.Y - this.Y) > 0)
|
|
this.IsSimple = false;
|
|
}
|
|
};
|
|
|
|
(function(){
|
|
AscWord.RULER_DRAG_TYPE = {
|
|
none : 0,
|
|
leftMargin : 1,
|
|
rightMargin : 2,
|
|
leftFirstInd : 3,
|
|
leftInd : 4,
|
|
firstInd : 5,
|
|
rightInd : 6,
|
|
tab : 7,
|
|
table : 8,
|
|
columnSize : 9,
|
|
columnPos : 10
|
|
};
|
|
})();
|
|
|
|
function CHorRuler()
|
|
{
|
|
this.m_oPage = null; // текущая страница. Нужна для размеров и маргинов в режиме RULER_OBJECT_TYPE_PARAGRAPH
|
|
|
|
this.m_nTop = 0; // начало прямогулольника линейки
|
|
this.m_nBottom = 0; // конец прямоугольника линейки
|
|
|
|
// реализация tab'ов
|
|
this.m_dDefaultTab = 12.5;
|
|
this.m_arrTabs = [];
|
|
this.m_lCurrentTab = -1;
|
|
this.m_dCurrentTabNewPosition = -1;
|
|
this.m_dMaxTab = 0;
|
|
this.IsDrawingCurTab = true; // это подсказка для пользователя - будет ли оставлен таб после отпускания мышки, или будет выкинут
|
|
|
|
this.m_dMarginLeft = 20;
|
|
this.m_dMarginRight = 190;
|
|
|
|
this.m_dIndentLeft = 10;
|
|
this.m_dIndentRight = 20;
|
|
this.m_dIndentLeftFirst = 20;
|
|
this.m_bRtl = false;
|
|
|
|
this.m_oCanvas = null;
|
|
|
|
this.m_dZoom = 1;
|
|
|
|
this.DragType = AscWord.RULER_DRAG_TYPE.none;
|
|
this.DragTypeMouseDown = AscWord.RULER_DRAG_TYPE.none;
|
|
|
|
this.m_dIndentLeft_old = -10000;
|
|
this.m_dIndentLeftFirst_old = -10000;
|
|
this.m_dIndentRight_old = -10000;
|
|
|
|
// отдельные настройки для текущего объекта линейки
|
|
this.CurrentObjectType = RULER_OBJECT_TYPE_PARAGRAPH;
|
|
this.m_oTableMarkup = null;
|
|
this.m_oColumnMarkup = null;
|
|
this.DragTablePos = -1;
|
|
|
|
this.TableMarginLeft = 0;
|
|
this.TableMarginLeftTrackStart = 0;
|
|
this.TableMarginRight = 0;
|
|
|
|
this.m_oWordControl = null;
|
|
|
|
this.RepaintChecker = new CHorRulerRepaintChecker();
|
|
this.m_bIsMouseDown = false;
|
|
|
|
// presentations addons
|
|
this.IsCanMoveMargins = true;
|
|
this.IsCanMoveAnyMarkers = true;
|
|
this.IsDrawAnyMarkers = true;
|
|
|
|
this.SimpleChanges = new RulerCheckSimpleChanges();
|
|
|
|
this.Units = c_oAscDocumentUnits.Millimeter;
|
|
|
|
this.DrawTablePict = function() {
|
|
var ctx = g_memory.ctx;
|
|
var dPR = AscCommon.AscBrowser.retinaPixelRatio;
|
|
var isNeedRedraw = (dPR - Math.floor(dPR)) >= 0.5 ? true : false;
|
|
var roundDPR = isNeedRedraw ? Math.floor(dPR) : Math.round(dPR);
|
|
|
|
var canvasWidth = (isNeedRedraw && dPR >= 1 ) ? Math.round(7 * (Math.floor(dPR) + 0.5)) : 7 * (isNeedRedraw ? dPR : ( dPR >= 1 ? Math.round(dPR) : dPR)),
|
|
canvasHeight = (isNeedRedraw && dPR >= 1) ? Math.round(8 * (Math.floor(dPR) + 0.5)) : 8 * (isNeedRedraw ? dPR : ( dPR >= 1 ? Math.round(dPR) : dPR));
|
|
|
|
if (null != this.tableSprite)
|
|
{
|
|
if (ctx.canvas.width == canvasWidth)
|
|
return;
|
|
}
|
|
|
|
ctx.canvas.width = canvasWidth;
|
|
ctx.canvas.height = canvasHeight;
|
|
|
|
|
|
ctx.beginPath();
|
|
ctx.fillStyle = '#ffffff';
|
|
ctx.strokeStyle = '#ffffff';
|
|
ctx.stroke();
|
|
ctx.rect(0,0,ctx.canvas.width, ctx.canvas.height)
|
|
ctx.fill();
|
|
|
|
ctx.beginPath();
|
|
ctx.strokeStyle = '#646464';
|
|
ctx.lineWidth = roundDPR;
|
|
|
|
var step = isNeedRedraw ? Math.round(dPR): ctx.lineWidth;
|
|
for (var i = 0; i < 7 * ctx.canvas.width; i += step + ctx.lineWidth) {
|
|
ctx.moveTo(0, 0.5 * ctx.lineWidth + step + i);
|
|
ctx.lineTo(ctx.canvas.width, 0.5 * ctx.lineWidth + step + i);
|
|
ctx.stroke();
|
|
}
|
|
for (var i = 0; i < 8 * ctx.canvas.height; i += step + ctx.lineWidth) {
|
|
ctx.moveTo(0.5 * ctx.lineWidth + step + i, 0);
|
|
ctx.lineTo(0.5 * ctx.lineWidth + step + i, ctx.canvas.height);
|
|
ctx.stroke();
|
|
}
|
|
|
|
return ctx.canvas;
|
|
}
|
|
|
|
this.tableSprite = null;
|
|
|
|
this.CheckCanvas = function()
|
|
{
|
|
this.m_dZoom = this.m_oWordControl.m_nZoomValue / 100;
|
|
var dPR = AscCommon.AscBrowser.retinaPixelRatio;
|
|
|
|
var tablePict = this.DrawTablePict();
|
|
if (tablePict)
|
|
this.tableSprite = tablePict;
|
|
|
|
var dKoef_mm_to_pix = g_dKoef_mm_to_pix * this.m_dZoom;
|
|
dKoef_mm_to_pix *= dPR;
|
|
|
|
var widthNew = dKoef_mm_to_pix * this.m_oPage.width_mm;
|
|
|
|
var _width = 10 * Math.round(dPR) + widthNew;
|
|
if (dPR > 1)
|
|
_width += Math.round(dPR);
|
|
|
|
var _height = 8 * g_dKoef_mm_to_pix * dPR;
|
|
|
|
var intW = _width >> 0;
|
|
var intH = _height >> 0;
|
|
if (null == this.m_oCanvas)
|
|
{
|
|
this.m_oCanvas = document.createElement('canvas');
|
|
this.m_oCanvas.width = intW;
|
|
this.m_oCanvas.height = intH;
|
|
}
|
|
else
|
|
{
|
|
var oldW = this.m_oCanvas.width;
|
|
var oldH = this.m_oCanvas.height;
|
|
|
|
if ((oldW != intW) || (oldH != intH))
|
|
{
|
|
delete this.m_oCanvas;
|
|
this.m_oCanvas = document.createElement('canvas');
|
|
this.m_oCanvas.width = intW;
|
|
this.m_oCanvas.height = intH;
|
|
}
|
|
}
|
|
return widthNew;
|
|
}
|
|
|
|
this.CreateBackground = function(cachedPage, isattack)
|
|
{
|
|
if (window["NATIVE_EDITOR_ENJINE"])
|
|
return;
|
|
|
|
if (null == cachedPage || undefined == cachedPage)
|
|
return;
|
|
|
|
this.m_oPage = cachedPage;
|
|
var width = this.CheckCanvas();
|
|
|
|
if (0 == this.DragType)
|
|
{
|
|
this.m_dMarginLeft = cachedPage.margin_left;
|
|
this.m_dMarginRight = cachedPage.margin_right;
|
|
}
|
|
|
|
// check old state
|
|
var checker = this.RepaintChecker;
|
|
var markup = this.m_oTableMarkup;
|
|
if (this.CurrentObjectType == RULER_OBJECT_TYPE_COLUMNS)
|
|
markup = this.m_oColumnMarkup;
|
|
|
|
if (isattack !== true && this.CurrentObjectType == checker.Type && width == checker.Width)
|
|
{
|
|
if (this.CurrentObjectType == RULER_OBJECT_TYPE_PARAGRAPH)
|
|
{
|
|
if (this.m_dMarginLeft == checker.MarginLeft && this.m_dMarginRight == checker.MarginRight)
|
|
return;
|
|
}
|
|
else if (this.CurrentObjectType == RULER_OBJECT_TYPE_TABLE)
|
|
{
|
|
var oldcount = checker.tableCols.length;
|
|
var newcount = 1 + markup.Cols.length;
|
|
|
|
if (oldcount == newcount)
|
|
{
|
|
var arr1 = checker.tableCols;
|
|
var arr2 = markup.Cols;
|
|
|
|
if (arr1[0] == markup.X)
|
|
{
|
|
var _break = false;
|
|
for (var i = 1; i < newcount; i++)
|
|
{
|
|
if (arr1[i] != arr2[i - 1])
|
|
{
|
|
_break = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!_break)
|
|
{
|
|
--newcount;
|
|
var _margs = markup.Margins;
|
|
|
|
for (var i = 0; i < newcount; i++)
|
|
{
|
|
if (_margs[i].Left != checker.marginsLeft[i] || _margs[i].Right != checker.marginsRight[i])
|
|
{
|
|
_break = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!_break)
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if (this.CurrentObjectType == RULER_OBJECT_TYPE_COLUMNS)
|
|
{
|
|
if (this.m_oColumnMarkup.X == checker.columns.X)
|
|
{
|
|
if (markup.EqualWidth == checker.columns.EqualWidth)
|
|
{
|
|
if (markup.EqualWidth)
|
|
{
|
|
if (markup.Num == checker.columns.Num && markup.Space == checker.columns.Space && markup.R == checker.columns.R)
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
var _arr1 = markup.Cols;
|
|
var _arr2 = checker.columns.Cols;
|
|
if (_arr1 && _arr2 && _arr1.length == _arr2.length)
|
|
{
|
|
var _len = _arr1.length;
|
|
var _index = 0;
|
|
for (_index = 0; _index < _len; _index++)
|
|
{
|
|
if (_arr1[_index].W != _arr2[_index].W || _arr1[_index].Space != _arr2[_index].Space)
|
|
break;
|
|
}
|
|
|
|
if (_index == _len)
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//console.log("horizontal");
|
|
|
|
checker.Width = width;
|
|
checker.Type = this.CurrentObjectType;
|
|
checker.BlitAttack = true;
|
|
|
|
var dPR = AscCommon.AscBrowser.retinaPixelRatio;
|
|
var dKoef_mm_to_pix = g_dKoef_mm_to_pix * this.m_dZoom * dPR;
|
|
|
|
// не править !!!
|
|
this.m_nTop = Math.round(6 * dPR);//(1.8 * g_dKoef_mm_to_pix) >> 0;
|
|
this.m_nBottom = Math.round(19 * dPR);//(5.2 * g_dKoef_mm_to_pix) >> 0;
|
|
|
|
var context = this.m_oCanvas.getContext('2d');
|
|
context.setTransform(1, 0, 0, 1, 5 * Math.round( dPR), 0);
|
|
|
|
|
|
context.fillStyle = GlobalSkin.BackgroundColor;
|
|
context.fillRect(0, 0, this.m_oCanvas.width, this.m_oCanvas.height);
|
|
|
|
// промежуток между маргинами
|
|
var left_margin = 0;
|
|
var right_margin = 0;
|
|
|
|
let isRtl = false;
|
|
if (this.CurrentObjectType == RULER_OBJECT_TYPE_PARAGRAPH)
|
|
{
|
|
left_margin = (this.m_dMarginLeft * dKoef_mm_to_pix) >> 0;
|
|
right_margin = (this.m_dMarginRight * dKoef_mm_to_pix) >> 0;
|
|
|
|
checker.MarginLeft = this.m_dMarginLeft;
|
|
checker.MarginRight = this.m_dMarginRight;
|
|
isRtl = this.m_bRtl;
|
|
}
|
|
else if (this.CurrentObjectType == RULER_OBJECT_TYPE_TABLE && null != markup)
|
|
{
|
|
var _cols = checker.tableCols;
|
|
if (0 != _cols.length)
|
|
_cols.splice(0, _cols.length);
|
|
|
|
_cols[0] = markup.X;
|
|
var _ml = checker.marginsLeft;
|
|
if (0 != _ml.length)
|
|
_ml.splice(0, _ml.length);
|
|
|
|
var _mr = checker.marginsRight;
|
|
if (0 != _mr.length)
|
|
_mr.splice(0, _mr.length);
|
|
|
|
var _count_ = markup.Cols.length;
|
|
|
|
for (var i = 0; i < _count_; i++)
|
|
{
|
|
_cols[i + 1] = markup.Cols[i];
|
|
_ml[i] = markup.Margins[i].Left;
|
|
_mr[i] = markup.Margins[i].Right;
|
|
}
|
|
|
|
if (0 != _count_)
|
|
{
|
|
var _start = 0;
|
|
for (var i = 0; i < _count_; i++)
|
|
{
|
|
_start += markup.Cols[i];
|
|
}
|
|
|
|
left_margin = ((markup.X + markup.Margins[0].Left) * dKoef_mm_to_pix) >> 0;
|
|
right_margin = ((markup.X + _start - markup.Margins[markup.Margins.length - 1].Right) * dKoef_mm_to_pix) >> 0;
|
|
}
|
|
}
|
|
else if (this.CurrentObjectType == RULER_OBJECT_TYPE_COLUMNS && null != markup)
|
|
{
|
|
left_margin = (markup.X * dKoef_mm_to_pix) >> 0;
|
|
right_margin = (markup.R * dKoef_mm_to_pix) >> 0;
|
|
|
|
checker.MarginLeft = this.m_dMarginLeft;
|
|
checker.MarginRight = this.m_dMarginRight;
|
|
|
|
checker.columns = this.m_oColumnMarkup.CreateDuplicate();
|
|
}
|
|
var indent = 0.5 * Math.round(dPR);
|
|
context.fillStyle = GlobalSkin.RulerLight;
|
|
context.fillRect(left_margin + indent, this.m_nTop + indent, right_margin - left_margin, this.m_nBottom - this.m_nTop);
|
|
|
|
var intW = width >> 0;
|
|
|
|
if (true)
|
|
{
|
|
context.beginPath();
|
|
context.fillStyle = GlobalSkin.RulerDark;
|
|
|
|
context.fillRect(indent, this.m_nTop + indent, left_margin, this.m_nBottom - this.m_nTop);
|
|
context.fillRect(right_margin + indent, this.m_nTop + indent, Math.max(intW - right_margin, 1), this.m_nBottom - this.m_nTop);
|
|
context.beginPath();
|
|
}
|
|
|
|
// рамка
|
|
//context.shadowBlur = 0;
|
|
//context.shadowColor = "#81878F";
|
|
|
|
context.beginPath();
|
|
context.lineWidth = Math.round(dPR);
|
|
context.strokeStyle = GlobalSkin.RulerTextColor;
|
|
context.fillStyle = GlobalSkin.RulerTextColor;
|
|
|
|
let mm_1_4 = 10 * dKoef_mm_to_pix / 4;
|
|
let inch_1_8 = 25.4 * dKoef_mm_to_pix / 8;
|
|
let point_1_12 = 25.4 * dKoef_mm_to_pix / 12;
|
|
|
|
var middleVert = (this.m_nTop + this.m_nBottom) / 2;
|
|
var part1 = 1.5 * Math.round(dPR);
|
|
var part2 = 2.5 * Math.round(dPR);
|
|
|
|
context.font = Math.round(7 * dPR) + "pt Arial";
|
|
|
|
let _bottom = this.m_nBottom;
|
|
function drawLayoutMM(x, step, count)
|
|
{
|
|
let isDraw1_4 = Math.abs(step) > 7;
|
|
let index = 0;
|
|
let num = 0;
|
|
for (let i = 1; i <= count; ++i)
|
|
{
|
|
let lXPos = ((x + i * step) >> 0) + indent;
|
|
index++;
|
|
|
|
if (index === 4)
|
|
index = 0;
|
|
|
|
if (0 === index)
|
|
{
|
|
num++;
|
|
// number
|
|
let strNum = "" + num;
|
|
let lWidthText = context.measureText(strNum).width;
|
|
lXPos -= (lWidthText / 2.0);
|
|
context.fillText(strNum, lXPos, _bottom - Math.round(3 * dPR));
|
|
}
|
|
else if (1 === index && isDraw1_4)
|
|
{
|
|
// 1/4
|
|
context.beginPath();
|
|
context.moveTo(lXPos, middleVert - part1);
|
|
context.lineTo(lXPos, middleVert + part1);
|
|
context.stroke();
|
|
}
|
|
else if (2 === index)
|
|
{
|
|
// 1/2
|
|
context.beginPath();
|
|
context.moveTo(lXPos, middleVert - part2);
|
|
context.lineTo(lXPos, middleVert + part2);
|
|
context.stroke();
|
|
}
|
|
else if (isDraw1_4)
|
|
{
|
|
// 1/4
|
|
context.beginPath();
|
|
context.moveTo(lXPos, middleVert - part1);
|
|
context.lineTo(lXPos, middleVert + part1);
|
|
context.stroke();
|
|
}
|
|
}
|
|
}
|
|
function drawLayoutInch(x, step, count)
|
|
{
|
|
let isDraw1_8 = Math.abs(step) > 8;
|
|
let index = 0;
|
|
let num = 0;
|
|
for (let i = 1; i <= count; ++i)
|
|
{
|
|
let lXPos = ((x + i * step) >> 0) + indent;
|
|
index++;
|
|
|
|
if (index === 8)
|
|
index = 0;
|
|
|
|
if (0 === index)
|
|
{
|
|
num++;
|
|
// number
|
|
let strNum = "" + num;
|
|
let lWidthText = context.measureText(strNum).width;
|
|
lXPos -= (lWidthText / 2.0);
|
|
context.fillText(strNum, lXPos, _bottom - Math.round(3 * dPR));
|
|
}
|
|
else if (4 === index)
|
|
{
|
|
// 1/2
|
|
context.beginPath();
|
|
context.moveTo(lXPos, middleVert - part2);
|
|
context.lineTo(lXPos, middleVert + part2);
|
|
context.stroke();
|
|
}
|
|
else if (isDraw1_8)
|
|
{
|
|
// 1/8
|
|
context.beginPath();
|
|
context.moveTo(lXPos, middleVert - part1);
|
|
context.lineTo(lXPos, middleVert + part1);
|
|
context.stroke();
|
|
}
|
|
}
|
|
}
|
|
function drawLayoutPt(x, step, count)
|
|
{
|
|
let isDraw1_12 = Math.abs(step) > 5;
|
|
let index = 0;
|
|
let num = 0;
|
|
for (let i = 1; i <= count; ++i)
|
|
{
|
|
let lXPos = ((x + i * step) >> 0) + indent;
|
|
index++;
|
|
|
|
if (index === 12)
|
|
index = 0;
|
|
|
|
if (0 === index || 6 === index)
|
|
{
|
|
num++;
|
|
// number
|
|
let strNum = "" + (num * 36);
|
|
let lWidthText = context.measureText(strNum).width;
|
|
lXPos -= (lWidthText / 2.0);
|
|
context.fillText(strNum, lXPos, _bottom - Math.round(3 * dPR));
|
|
}
|
|
else if (isDraw1_12)
|
|
{
|
|
// 1/12
|
|
context.beginPath();
|
|
context.moveTo(lXPos, middleVert - part1);
|
|
context.lineTo(lXPos, middleVert + part1);
|
|
context.stroke();
|
|
}
|
|
}
|
|
}
|
|
|
|
let step = point_1_12;
|
|
let drawFunc = null;
|
|
|
|
if (this.Units === c_oAscDocumentUnits.Millimeter)
|
|
{
|
|
step = mm_1_4;
|
|
drawFunc = drawLayoutMM;
|
|
}
|
|
else if (this.Units === c_oAscDocumentUnits.Inch)
|
|
{
|
|
step = inch_1_8;
|
|
drawFunc = drawLayoutInch;
|
|
}
|
|
else if (this.Units === c_oAscDocumentUnits.Point)
|
|
{
|
|
step = point_1_12;
|
|
drawFunc = drawLayoutPt;
|
|
}
|
|
|
|
if (drawFunc)
|
|
{
|
|
let zeroX = isRtl ? right_margin : left_margin;
|
|
let rCount = isRtl ? ((width - right_margin) / step) >> 0 : (((width - left_margin) / step) >> 0) - 1;
|
|
let lCount = isRtl ? ((right_margin / step) >> 0) - 1 : left_margin / step >> 0;
|
|
|
|
drawFunc(zeroX, step, rCount);
|
|
drawFunc(zeroX, -step, lCount);
|
|
}
|
|
|
|
if (null != markup && this.CurrentObjectType == RULER_OBJECT_TYPE_TABLE)
|
|
{
|
|
var _count = markup.Cols.length;
|
|
if (0 != _count)
|
|
{
|
|
context.fillStyle = GlobalSkin.RulerDark;
|
|
context.strokeStyle = GlobalSkin.RulerOutline;
|
|
|
|
var _offset = markup.X;
|
|
for (var i = 0; i <= _count; i++)
|
|
{
|
|
var __xID = 0;
|
|
__xID = (-2.5 * dPR + _offset * dKoef_mm_to_pix) >> 0;
|
|
|
|
var __yID = this.m_nBottom - Math.round(10 * dPR);
|
|
|
|
if (0 == i)
|
|
{
|
|
context.drawImage(this.tableSprite, __xID, __yID);
|
|
_offset += markup.Cols[i];
|
|
continue;
|
|
}
|
|
if (i == _count)
|
|
{
|
|
context.drawImage(this.tableSprite, __xID, __yID);
|
|
break;
|
|
}
|
|
|
|
var __x = (((_offset - markup.Margins[i-1].Right) * dKoef_mm_to_pix) >> 0) + indent;
|
|
var __r = (((_offset + markup.Margins[i].Left) * dKoef_mm_to_pix) >> 0) + indent;
|
|
|
|
context.fillRect(__x, this.m_nTop + indent, __r - __x, this.m_nBottom - this.m_nTop);
|
|
context.strokeRect(__x, this.m_nTop + indent, __r - __x, this.m_nBottom - this.m_nTop);
|
|
context.drawImage(this.tableSprite, __xID, __yID);
|
|
|
|
_offset += markup.Cols[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (null != markup && this.CurrentObjectType == RULER_OBJECT_TYPE_COLUMNS)
|
|
{
|
|
var _array = markup.EqualWidth ? [] : markup.Cols;
|
|
if (markup.EqualWidth)
|
|
{
|
|
var _w = ((markup.R - markup.X) - markup.Space * (markup.Num - 1)) / markup.Num;
|
|
|
|
for (var i = 0; i < markup.Num; i++)
|
|
{
|
|
var _cur = new CColumnsMarkupColumn();
|
|
_cur.W = _w;
|
|
_cur.Space = markup.Space;
|
|
_array.push(_cur);
|
|
}
|
|
}
|
|
|
|
var _count = _array.length;
|
|
if (0 != _count)
|
|
{
|
|
context.fillStyle = GlobalSkin.RulerDark;
|
|
context.strokeStyle = GlobalSkin.RulerOutline;
|
|
|
|
var _offsetX = markup.X;
|
|
for (var i = 0; i < _count; i++)
|
|
{
|
|
var __xTmp = _offsetX + _array[i].W;
|
|
var __rTmp = __xTmp + _array[i].Space;
|
|
|
|
var _offset = (__xTmp + __rTmp) / 2;
|
|
|
|
if (i == (_count - 1))
|
|
continue;
|
|
|
|
var __xID = 0;
|
|
__xID = ((2.5 + _offset * dKoef_mm_to_pix)) * dPR >> 0;
|
|
|
|
var __yID = this.m_nBottom - Math.round(10 * dPR);
|
|
|
|
var __x = ((__xTmp * dKoef_mm_to_pix) >> 0) + indent;
|
|
var __r = ((__rTmp * dKoef_mm_to_pix) >> 0) + indent;
|
|
|
|
context.fillRect(__x, this.m_nTop + indent, __r - __x, this.m_nBottom - this.m_nTop);
|
|
context.strokeRect(__x, this.m_nTop + indent, __r - __x, this.m_nBottom - this.m_nTop);
|
|
|
|
if (!markup.EqualWidth)
|
|
context.drawImage(this.tableSprite, __xID, __yID);
|
|
|
|
if ((__r - __x) > 10)
|
|
{
|
|
context.fillStyle = GlobalSkin.RulerLight;
|
|
context.strokeStyle = GlobalSkin.RulerMarkersOutlineColor;
|
|
|
|
var roundV1 = Math.round(3 * dPR);
|
|
var roundV2 = Math.round(6 * dPR);
|
|
context.fillRect(__x + roundV1, this.m_nTop + indent + roundV1, roundV1, this.m_nBottom - this.m_nTop - roundV2);
|
|
context.fillRect(__r - roundV2, this.m_nTop + indent + roundV1, roundV1, this.m_nBottom - this.m_nTop - roundV2);
|
|
context.strokeRect(__x + roundV1, this.m_nTop + indent + roundV1, roundV1, this.m_nBottom - this.m_nTop - roundV2);
|
|
context.strokeRect(__r - roundV2, this.m_nTop + indent + roundV1, roundV1, this.m_nBottom - this.m_nTop - roundV2);
|
|
context.fillStyle = GlobalSkin.RulerDark;
|
|
context.strokeStyle = GlobalSkin.RulerOutline;
|
|
}
|
|
|
|
_offsetX += (_array[i].W + _array[i].Space);
|
|
}
|
|
}
|
|
}
|
|
|
|
context.beginPath();
|
|
context.strokeStyle = GlobalSkin.RulerOutline;
|
|
context.strokeRect(indent, this.m_nTop + indent, Math.max(intW - 1, 1), this.m_nBottom - this.m_nTop);
|
|
context.beginPath();
|
|
context.moveTo(left_margin + indent, this.m_nTop + indent);
|
|
context.lineTo(left_margin + indent, this.m_nBottom - indent);
|
|
|
|
context.moveTo(right_margin + indent, this.m_nTop + indent);
|
|
context.lineTo(right_margin + indent, this.m_nBottom - indent);
|
|
|
|
context.stroke();
|
|
}
|
|
|
|
this.CorrectTabs = function()
|
|
{
|
|
this.m_dMaxTab = 0;
|
|
var _old_c = this.m_arrTabs.length;
|
|
if (0 == _old_c)
|
|
return;
|
|
|
|
var _old = this.m_arrTabs;
|
|
var _new = [];
|
|
|
|
for (var i = 0; i < _old_c; i++)
|
|
{
|
|
for (var j = i + 1; j < _old_c; j++)
|
|
{
|
|
if (_old[j].pos < _old[i].pos)
|
|
{
|
|
var temp = _old[i];
|
|
_old[i] = _old[j];
|
|
_old[j] = temp;
|
|
}
|
|
}
|
|
}
|
|
|
|
var _new_len = 0;
|
|
_new[_new_len++] = _old[0];
|
|
for (var i = 1; i < _old_c; i++)
|
|
{
|
|
if (_new[_new_len - 1].pos != _old[i].pos)
|
|
_new[_new_len++] = _old[i];
|
|
}
|
|
this.m_arrTabs = null;
|
|
this.m_arrTabs = _new;
|
|
|
|
this.m_dMaxTab = this.m_arrTabs[_new_len - 1].pos;
|
|
}
|
|
|
|
this.CalculateMargins = function()
|
|
{
|
|
if (this.CurrentObjectType == RULER_OBJECT_TYPE_TABLE)
|
|
{
|
|
this.TableMarginLeft = 0;
|
|
this.TableMarginRight = 0;
|
|
|
|
var markup = this.m_oTableMarkup;
|
|
var margin_left = markup.X;
|
|
|
|
var _col = markup.CurCol;
|
|
for (var i = 0; i < _col; i++)
|
|
margin_left += markup.Cols[i];
|
|
|
|
this.TableMarginLeft = margin_left + markup.Margins[_col].Left;
|
|
this.TableMarginRight = margin_left + markup.Cols[_col] - markup.Margins[_col].Right;
|
|
}
|
|
else if (this.CurrentObjectType == RULER_OBJECT_TYPE_COLUMNS)
|
|
{
|
|
this.TableMarginLeft = 0;
|
|
this.TableMarginRight = 0;
|
|
|
|
var markup = this.m_oColumnMarkup;
|
|
|
|
if (markup.EqualWidth)
|
|
{
|
|
var _w = ((markup.R - markup.X) - markup.Space * (markup.Num - 1)) / markup.Num;
|
|
|
|
this.TableMarginLeft = markup.X + (_w + markup.Space) * markup.CurCol;
|
|
this.TableMarginRight = this.TableMarginLeft + _w;
|
|
}
|
|
else
|
|
{
|
|
var margin_left = markup.X;
|
|
var _col = markup.CurCol;
|
|
for (var i = 0; i < _col; i++)
|
|
margin_left += (markup.Cols[i].W + markup.Cols[i].Space);
|
|
|
|
this.TableMarginLeft = margin_left;
|
|
this.TableMarginRight = margin_left + markup.Cols[_col].W;
|
|
|
|
var _x = markup.X;
|
|
|
|
var _len = markup.Cols.length;
|
|
for (var i = 0; i < _len; i++)
|
|
{
|
|
_x += markup.Cols[i].W;
|
|
|
|
if (i != (_len - 1))
|
|
_x += markup.Cols[i].Space;
|
|
}
|
|
|
|
markup.R = _x;
|
|
}
|
|
}
|
|
}
|
|
|
|
this.OnMouseMove = function(left, top, e)
|
|
{
|
|
var word_control = this.m_oWordControl;
|
|
|
|
AscCommon.check_MouseMoveEvent(e);
|
|
|
|
this.SimpleChanges.CheckMove();
|
|
|
|
// теперь определяем позицию относительно самой линейки. Все в миллиметрах
|
|
var hor_ruler = word_control.m_oTopRuler_horRuler;
|
|
var dKoefPxToMM = 100 * g_dKoef_pix_to_mm / word_control.m_nZoomValue;
|
|
|
|
var _x = global_mouseEvent.X - left - word_control.X - word_control.GetMainContentBounds().L * g_dKoef_mm_to_pix;
|
|
if (!word_control.m_oApi.isRtlInterface)
|
|
_x -= 5 * g_dKoef_mm_to_pix;
|
|
|
|
_x *= dKoefPxToMM;
|
|
var _y = (global_mouseEvent.Y - word_control.Y) * g_dKoef_pix_to_mm;
|
|
|
|
var dKoef_mm_to_pix = g_dKoef_mm_to_pix * this.m_dZoom;
|
|
var mm_1_4 = 10 / 4;
|
|
var mm_1_8 = mm_1_4 / 2;
|
|
|
|
var _margin_left = this.m_dMarginLeft;
|
|
var _margin_right = this.m_dMarginRight;
|
|
if (this.CurrentObjectType == RULER_OBJECT_TYPE_TABLE || this.CurrentObjectType == RULER_OBJECT_TYPE_COLUMNS)
|
|
{
|
|
_margin_left = this.TableMarginLeft;
|
|
_margin_right = this.TableMarginRight;
|
|
}
|
|
|
|
var _presentations = false;
|
|
if (word_control.EditorType === "presentations")
|
|
_presentations = true;
|
|
|
|
switch (this.DragType)
|
|
{
|
|
case AscWord.RULER_DRAG_TYPE.none:
|
|
{
|
|
var position = this.CheckMouseType(_x, _y);
|
|
if ((1 == position) || (2 == position) || (8 == position) || (9 == position) || (10 == position))
|
|
word_control.m_oDrawingDocument.SetCursorType("w-resize");
|
|
else
|
|
word_control.m_oDrawingDocument.SetCursorType("default");
|
|
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.leftMargin:
|
|
{
|
|
var newVal = RulerCorrectPosition(this, _x, _margin_left);
|
|
|
|
if (newVal < 0)
|
|
newVal = 0;
|
|
|
|
var max = this.m_dMarginRight - 20;
|
|
if (0 < this.m_dIndentRight)
|
|
max = (this.m_dMarginRight - this.m_dIndentRight - 20);
|
|
if (newVal > max)
|
|
newVal = max;
|
|
|
|
var _max_ind = Math.max(this.m_dIndentLeft, this.m_dIndentLeftFirst);
|
|
if ((newVal + _max_ind) > max)
|
|
newVal = max - _max_ind;
|
|
|
|
this.m_dMarginLeft = newVal;
|
|
word_control.UpdateHorRulerBack();
|
|
|
|
var pos = left + this.m_dMarginLeft * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
|
|
word_control.m_oDrawingDocument.SetCursorType("w-resize");
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.rightMargin:
|
|
{
|
|
var newVal = RulerCorrectPosition(this, _x, _margin_left);
|
|
|
|
var min = this.m_dMarginLeft;
|
|
if ((this.m_dMarginLeft + this.m_dIndentLeft) > min)
|
|
min = this.m_dMarginLeft + this.m_dIndentLeft;
|
|
if ((this.m_dMarginLeft + this.m_dIndentLeftFirst) > min)
|
|
min = this.m_dMarginLeft + this.m_dIndentLeftFirst;
|
|
|
|
min += 20;
|
|
if (newVal < min)
|
|
newVal = min;
|
|
if (newVal > this.m_oPage.width_mm)
|
|
newVal = this.m_oPage.width_mm;
|
|
|
|
if ((newVal - this.m_dIndentRight) < min)
|
|
newVal = min + this.m_dIndentRight;
|
|
|
|
this.m_dMarginRight = newVal;
|
|
word_control.UpdateHorRulerBack();
|
|
|
|
var pos = left + this.m_dMarginRight * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
|
|
word_control.m_oDrawingDocument.SetCursorType("w-resize");
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.leftFirstInd:
|
|
{
|
|
let newVal = RulerCorrectPosition(this, _x, this.m_bRtl ? _margin_right : _margin_left);
|
|
|
|
if (this.m_bRtl)
|
|
{
|
|
let max = this.m_oPage.width_mm;
|
|
if (_presentations)
|
|
max = _margin_right;
|
|
else if (this.m_dIndentLeftFirst < this.m_dIndentLeft)
|
|
max = this.m_oPage.width_mm - (this.m_dIndentLeft - this.m_dIndentLeftFirst);
|
|
|
|
if (newVal > max)
|
|
newVal = max;
|
|
|
|
let min = _margin_left;
|
|
if (this.m_dIndentRight > 0)
|
|
min = _margin_left + this.m_dIndentRight;
|
|
|
|
if (this.m_dIndentLeftFirst > this.m_dIndentLeft)
|
|
min += this.m_dIndentLeftFirst - this.m_dIndentLeft;
|
|
|
|
if (newVal < min + 20)
|
|
newVal = Math.min(min + 20, _margin_right - this.m_dIndentLeft_old);
|
|
|
|
let newIndent = _margin_right - newVal;
|
|
this.m_dIndentLeftFirst = (this.m_dIndentLeftFirst - this.m_dIndentLeft) + newIndent;
|
|
this.m_dIndentLeft = newIndent;
|
|
}
|
|
else
|
|
{
|
|
let min = 0;
|
|
|
|
if (_presentations)
|
|
min = _margin_left;
|
|
else if (this.m_dIndentLeftFirst < this.m_dIndentLeft)
|
|
min = this.m_dIndentLeft - this.m_dIndentLeftFirst;
|
|
|
|
if (newVal < min)
|
|
newVal = min;
|
|
|
|
let max = _margin_right;
|
|
if (0 < this.m_dIndentRight)
|
|
max = _margin_right - this.m_dIndentRight;
|
|
|
|
if (this.m_dIndentLeftFirst > this.m_dIndentLeft)
|
|
max = max + (this.m_dIndentLeft - this.m_dIndentLeftFirst);
|
|
|
|
if (newVal > (max - 20))
|
|
newVal = Math.max(max - 20, (this.m_dIndentLeft_old + _margin_left));
|
|
|
|
let newIndent = newVal - _margin_left;
|
|
this.m_dIndentLeftFirst = (this.m_dIndentLeftFirst - this.m_dIndentLeft) + newIndent;
|
|
this.m_dIndentLeft = newIndent;
|
|
}
|
|
let pos = left + newVal * dKoef_mm_to_pix;
|
|
word_control.UpdateHorRulerBack();
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.leftInd:
|
|
{
|
|
let newVal = RulerCorrectPosition(this, _x, this.m_bRtl ? _margin_right : _margin_left);
|
|
if (newVal < 0)
|
|
newVal = 0;
|
|
|
|
if (this.m_bRtl)
|
|
{
|
|
if (newVal > (this.m_oPage.width_mm))
|
|
newVal = this.m_oPage.width_mm;
|
|
|
|
let min = Math.max(_margin_left, _margin_left + this.m_dIndentRight) + 20;
|
|
if (_presentations)
|
|
{
|
|
if (newVal > _margin_right)
|
|
newVal = _margin_right;
|
|
}
|
|
|
|
if (newVal < min)
|
|
newVal = Math.min(min, _margin_right - this.m_dIndentLeft_old);
|
|
|
|
this.m_dIndentLeft = _margin_right - newVal;
|
|
}
|
|
else
|
|
{
|
|
let max = _margin_right - 20;
|
|
if (0 < this.m_dIndentRight)
|
|
max -= this.m_dIndentRight;
|
|
|
|
if (_presentations)
|
|
{
|
|
if (newVal < _margin_left)
|
|
newVal = _margin_left;
|
|
}
|
|
|
|
if (newVal > max)
|
|
newVal = Math.max(max, _margin_left + this.m_dIndentLeft_old);
|
|
|
|
this.m_dIndentLeft = newVal - _margin_left;
|
|
}
|
|
let pos = left + newVal * dKoef_mm_to_pix;
|
|
word_control.UpdateHorRulerBack();
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.firstInd:
|
|
{
|
|
let newVal = RulerCorrectPosition(this, _x, this.m_bRtl ? _margin_right : _margin_left);
|
|
|
|
if (newVal < 0)
|
|
newVal = 0;
|
|
|
|
if (this.m_bRtl)
|
|
{
|
|
if (newVal > (this.m_oPage.width_mm))
|
|
newVal = this.m_oPage.width_mm;
|
|
|
|
let min = 20 + Math.max(_margin_left, _margin_left + this.m_dIndentRight);
|
|
if (_presentations)
|
|
{
|
|
if (newVal > _margin_right)
|
|
newVal = _margin_right;
|
|
}
|
|
|
|
if (newVal < min)
|
|
newVal = Math.min(min, _margin_right - this.m_dIndentLeftFirst_old);
|
|
|
|
this.m_dIndentLeftFirst = _margin_right - newVal;
|
|
}
|
|
else
|
|
{
|
|
let max = _margin_right - 20;
|
|
if (0 < this.m_dIndentRight)
|
|
max -= this.m_dIndentRight;
|
|
|
|
if (_presentations)
|
|
{
|
|
if (newVal < _margin_left)
|
|
newVal = _margin_left;
|
|
}
|
|
|
|
if (newVal > max)
|
|
newVal = Math.max(max, _margin_left + this.m_dIndentLeftFirst_old);
|
|
|
|
this.m_dIndentLeftFirst = newVal - _margin_left;
|
|
}
|
|
let pos = left + newVal * dKoef_mm_to_pix;
|
|
word_control.UpdateHorRulerBack();
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.rightInd:
|
|
{
|
|
let newVal = RulerCorrectPosition(this, _x, this.m_bRtl ? _margin_right : _margin_left);
|
|
|
|
if (newVal > (this.m_oPage.width_mm))
|
|
newVal = this.m_oPage.width_mm;
|
|
if (newVal < 0)
|
|
newVal = 0;
|
|
|
|
if (this.m_bRtl)
|
|
{
|
|
let max = -20 + Math.min(_margin_right, _margin_right - this.m_dIndentLeft, _margin_right - this.m_dIndentLeftFirst);
|
|
if (newVal > max)
|
|
newVal = Math.max(max, _margin_left + this.m_dIndentRight_old);
|
|
|
|
if (_presentations && newVal < _margin_left)
|
|
newVal = _margin_left;
|
|
|
|
this.m_dIndentRight = newVal - _margin_left;
|
|
}
|
|
else
|
|
{
|
|
let min = _margin_left;
|
|
if ((_margin_left + this.m_dIndentLeft) > min)
|
|
min = _margin_left + this.m_dIndentLeft;
|
|
if ((_margin_left + this.m_dIndentLeftFirst) > min)
|
|
min = _margin_left + this.m_dIndentLeftFirst;
|
|
|
|
min += 20;
|
|
|
|
if (newVal < min)
|
|
newVal = Math.min(min, _margin_right - this.m_dIndentRight_old);
|
|
|
|
if (_presentations)
|
|
{
|
|
if (newVal > _margin_right)
|
|
newVal = _margin_right;
|
|
}
|
|
this.m_dIndentRight = _margin_right - newVal;
|
|
}
|
|
let pos = left + newVal * dKoef_mm_to_pix;
|
|
word_control.UpdateHorRulerBack();
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.tab:
|
|
{
|
|
let newVal = RulerCorrectPosition(this, _x, this.m_bRtl ? _margin_right : _margin_left);
|
|
|
|
this.m_dCurrentTabNewPosition = this.m_bRtl ? _margin_right - newVal : newVal - _margin_left;
|
|
if (_y <= 3 || _y > 5.6)
|
|
{
|
|
this.IsDrawingCurTab = false;
|
|
word_control.OnUpdateOverlay();
|
|
}
|
|
else
|
|
{
|
|
this.IsDrawingCurTab = true;
|
|
let offset = this.m_bRtl ? _margin_right - this.m_dCurrentTabNewPosition : _margin_left + this.m_dCurrentTabNewPosition;
|
|
let pos = left + offset * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
}
|
|
word_control.UpdateHorRulerBack();
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.table:
|
|
{
|
|
var newVal = RulerCorrectPosition(this, _x, this.TableMarginLeftTrackStart);
|
|
|
|
// сначала определим граничные условия
|
|
var _min = 0;
|
|
var _max = this.m_oPage.width_mm;
|
|
|
|
var markup = this.m_oTableMarkup;
|
|
var _left = 0;
|
|
|
|
if (this.DragTablePos > 0)
|
|
{
|
|
var start = markup.X;
|
|
for (var i = 1; i < this.DragTablePos; i++)
|
|
start += markup.Cols[i - 1];
|
|
_left = start;
|
|
|
|
start += markup.Margins[this.DragTablePos - 1].Left;
|
|
start += markup.Margins[this.DragTablePos - 1].Right;
|
|
|
|
_min = start;
|
|
}
|
|
|
|
if (newVal < _min)
|
|
newVal = _min;
|
|
if (newVal > _max)
|
|
newVal = _max;
|
|
|
|
if (0 == this.DragTablePos)
|
|
{
|
|
markup.X = newVal;
|
|
}
|
|
else
|
|
{
|
|
markup.Cols[this.DragTablePos - 1] = newVal - _left;
|
|
}
|
|
|
|
this.CalculateMargins();
|
|
word_control.UpdateHorRulerBack();
|
|
|
|
var pos = left + newVal * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.columnSize:
|
|
{
|
|
var newVal = RulerCorrectPosition(this, _x, this.TableMarginLeftTrackStart);
|
|
|
|
// сначала определим граничные условия
|
|
var markup = this.m_oColumnMarkup;
|
|
|
|
if (markup.EqualWidth)
|
|
{
|
|
if (0 == this.DragTablePos)
|
|
{
|
|
var _min = 0;
|
|
var _max = markup.R - markup.Num * 10 - (markup.Num - 1) * markup.Space;
|
|
|
|
if (newVal < _min)
|
|
newVal = _min;
|
|
if (newVal > _max)
|
|
newVal = _max;
|
|
|
|
markup.X = newVal;
|
|
}
|
|
else if ((2 * markup.Num - 1) == this.DragTablePos)
|
|
{
|
|
var _min = markup.X + markup.Num * 10 + (markup.Num - 1) * markup.Space;
|
|
var _max = this.m_oPage.width_mm;
|
|
|
|
if (newVal < _min)
|
|
newVal = _min;
|
|
if (newVal > _max)
|
|
newVal = _max;
|
|
|
|
markup.R = newVal;
|
|
}
|
|
else
|
|
{
|
|
var bIsLeftSpace = ((this.DragTablePos & 1) == 1);
|
|
var _spaceMax = (markup.R - markup.X - 10 * markup.Num) / (markup.Num - 1);
|
|
|
|
var _col = ((this.DragTablePos + 1) >> 1);
|
|
var _center = _col * (markup.R - markup.X + markup.Space) / markup.Num - markup.Space / 2;
|
|
|
|
newVal -= markup.X;
|
|
|
|
if (bIsLeftSpace)
|
|
{
|
|
var _min = _center - _spaceMax / 2;
|
|
var _max = _center;
|
|
|
|
if (newVal < _min)
|
|
newVal = _min;
|
|
if (newVal > _max)
|
|
newVal = _max;
|
|
|
|
markup.Space = Math.abs((newVal - _center) * 2);
|
|
}
|
|
else
|
|
{
|
|
var _min = _center;
|
|
var _max = _center + _spaceMax / 2;
|
|
|
|
if (newVal < _min)
|
|
newVal = _min;
|
|
if (newVal > _max)
|
|
newVal = _max;
|
|
|
|
markup.Space = Math.abs((newVal - _center) * 2);
|
|
}
|
|
|
|
newVal += markup.X;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var bIsLeftSpace = ((this.DragTablePos & 1) == 1);
|
|
var nSpaceNumber = ((this.DragTablePos + 1) >> 1);
|
|
var _min = 0;
|
|
var _max = this.m_oPage.width_mm;
|
|
|
|
if (0 == nSpaceNumber)
|
|
{
|
|
_max = markup.X + markup.Cols[0].W - 10;
|
|
|
|
if (newVal < _min)
|
|
newVal = _min;
|
|
if (newVal > _max)
|
|
newVal = _max;
|
|
|
|
var _delta = markup.X - newVal;
|
|
markup.X -= _delta;
|
|
markup.Cols[0].W += _delta;
|
|
}
|
|
else
|
|
{
|
|
var _offsetX = markup.X;
|
|
for (var i = 0; i < nSpaceNumber; i++)
|
|
{
|
|
_min = _offsetX;
|
|
|
|
_offsetX += markup.Cols[i].W;
|
|
if (!bIsLeftSpace || i != (nSpaceNumber - 1))
|
|
{
|
|
_min = _offsetX;
|
|
_offsetX += markup.Cols[i].Space;
|
|
}
|
|
}
|
|
|
|
if (bIsLeftSpace)
|
|
{
|
|
if (nSpaceNumber != markup.Num)
|
|
_max = _min + markup.Cols[nSpaceNumber - 1].W + markup.Cols[nSpaceNumber - 1].Space;
|
|
|
|
var _natMin = _min + 10;
|
|
|
|
if (newVal < _natMin)
|
|
newVal = _natMin;
|
|
if (newVal > _max)
|
|
newVal = _max;
|
|
|
|
markup.Cols[nSpaceNumber - 1].W = newVal - _min;
|
|
markup.Cols[nSpaceNumber - 1].Space = _max - newVal;
|
|
|
|
if (nSpaceNumber == markup.Num)
|
|
{
|
|
markup.R = newVal;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_max = _min + markup.Cols[nSpaceNumber - 1].Space + markup.Cols[nSpaceNumber].W;
|
|
var _natMax = _max - 10;
|
|
|
|
if (newVal < _min)
|
|
newVal = _min;
|
|
if (newVal > _natMax)
|
|
newVal = _natMax;
|
|
|
|
markup.Cols[nSpaceNumber - 1].Space = newVal - _min;
|
|
markup.Cols[nSpaceNumber].W = _max - newVal;
|
|
}
|
|
}
|
|
}
|
|
|
|
this.CalculateMargins();
|
|
word_control.UpdateHorRulerBack();
|
|
|
|
var pos = left + newVal * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.columnPos:
|
|
{
|
|
var newVal = RulerCorrectPosition(this, _x, this.TableMarginLeftTrackStart);
|
|
|
|
// сначала определим граничные условия
|
|
var markup = this.m_oColumnMarkup;
|
|
|
|
var _min = markup.X;
|
|
for (var i = 0; i < this.DragTablePos; i++)
|
|
{
|
|
_min += (markup.Cols[i].W + markup.Cols[i].Space);
|
|
}
|
|
|
|
var _max = _min + markup.Cols[this.DragTablePos].W + markup.Cols[this.DragTablePos].Space;
|
|
_max += markup.Cols[this.DragTablePos + 1].W;
|
|
|
|
var _space = markup.Cols[this.DragTablePos].Space;
|
|
|
|
var _natMin = _min + _space / 2 + 10;
|
|
var _natMax = _max - _space / 2 - 10;
|
|
|
|
if (newVal < _natMin)
|
|
newVal = _natMin;
|
|
if (newVal > _natMax)
|
|
newVal = _natMax;
|
|
|
|
var _delta = newVal - (_min + markup.Cols[this.DragTablePos].W + markup.Cols[this.DragTablePos].Space / 2);
|
|
markup.Cols[this.DragTablePos].W += _delta;
|
|
markup.Cols[this.DragTablePos + 1].W -= _delta;
|
|
|
|
this.CalculateMargins();
|
|
word_control.UpdateHorRulerBack();
|
|
|
|
var pos = left + newVal * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
this.CheckMouseType = function(x, y, isMouseDown, isNegative)
|
|
{
|
|
// проверяем где находимся
|
|
|
|
var _top = 1.8;
|
|
var _bottom = 5.2;
|
|
|
|
var _margin_left = this.m_dMarginLeft;
|
|
var _margin_right = this.m_dMarginRight;
|
|
if (this.CurrentObjectType == RULER_OBJECT_TYPE_TABLE || this.CurrentObjectType == RULER_OBJECT_TYPE_COLUMNS)
|
|
{
|
|
_margin_left = this.TableMarginLeft;
|
|
_margin_right = this.TableMarginRight;
|
|
}
|
|
|
|
var posL = _margin_left;
|
|
if ((_margin_left + this.m_dIndentLeft) > posL)
|
|
posL = _margin_left + this.m_dIndentLeft;
|
|
if ((_margin_left + this.m_dIndentLeftFirst) > posL)
|
|
posL = _margin_left + this.m_dIndentLeftFirst;
|
|
|
|
var posR = _margin_right;
|
|
if (this.m_dIndentRight > 0)
|
|
posR = _margin_right - this.m_dIndentRight;
|
|
|
|
if (this.IsCanMoveAnyMarkers && posL < posR)
|
|
{
|
|
// tabs
|
|
if (y >= 3 && y <= _bottom)
|
|
{
|
|
for (let i = 0, tabCount = this.m_arrTabs.length; i < tabCount; ++i)
|
|
{
|
|
var _pos = this.m_bRtl ? _margin_right - this.m_arrTabs[i].pos : _margin_left + this.m_arrTabs[i].pos;
|
|
if ((x >= (_pos - 1)) && (x <= (_pos + 1)))
|
|
{
|
|
if (true === isMouseDown)
|
|
this.m_lCurrentTab = i;
|
|
return AscWord.RULER_DRAG_TYPE.tab;
|
|
}
|
|
}
|
|
}
|
|
|
|
// left indent
|
|
var dCenterX = this.m_bRtl ? _margin_right - this.m_dIndentLeft : _margin_left + this.m_dIndentLeft;
|
|
|
|
var var1 = dCenterX - 1;
|
|
var var2 = 1.4;
|
|
var var3 = 1.5;
|
|
var var4 = dCenterX + 1;
|
|
|
|
if ((x >= var1) && (x <= var4))
|
|
{
|
|
if ((y >= _bottom) && (y < (_bottom + var2)))
|
|
return AscWord.RULER_DRAG_TYPE.leftFirstInd;
|
|
else if ((y > (_bottom - var3)) && (y < _bottom))
|
|
return AscWord.RULER_DRAG_TYPE.leftInd;
|
|
}
|
|
|
|
// right indent
|
|
dCenterX = this.m_bRtl ? _margin_left + this.m_dIndentRight : _margin_right - this.m_dIndentRight;
|
|
|
|
var1 = dCenterX - 1;
|
|
var4 = dCenterX + 1;
|
|
|
|
if ((x >= var1) && (x <= var4))
|
|
{
|
|
if ((y > (_bottom - var3)) && (y < _bottom))
|
|
return AscWord.RULER_DRAG_TYPE.rightInd;
|
|
}
|
|
|
|
// first line indent
|
|
dCenterX = this.m_bRtl ? _margin_right - this.m_dIndentLeftFirst : _margin_left + this.m_dIndentLeftFirst;
|
|
|
|
var1 = dCenterX - 1;
|
|
var4 = dCenterX + 1;
|
|
|
|
if ((x >= var1) && (x <= var4))
|
|
{
|
|
if ((y > (_top - 1)) && (y < (_top + 1.68)))
|
|
{
|
|
if (0 == this.m_dIndentLeftFirst && 0 == this.m_dIndentLeft && this.CurrentObjectType == RULER_OBJECT_TYPE_PARAGRAPH && this.IsCanMoveMargins)
|
|
{
|
|
if (y > (_top + 1))
|
|
return this.m_bRtl ? AscWord.RULER_DRAG_TYPE.rightMargin : AscWord.RULER_DRAG_TYPE.leftMargin;
|
|
}
|
|
return AscWord.RULER_DRAG_TYPE.firstInd;
|
|
}
|
|
}
|
|
}
|
|
|
|
var isColumnsInside = false;
|
|
var isColumnsInside2 = false;
|
|
var isTableInside = false;
|
|
|
|
if (this.CurrentObjectType == RULER_OBJECT_TYPE_PARAGRAPH && this.IsCanMoveMargins)
|
|
{
|
|
if (y >= _top && y <= _bottom)
|
|
{
|
|
// внутри линейки
|
|
if (Math.abs(x - this.m_dMarginLeft) < 1)
|
|
{
|
|
return AscWord.RULER_DRAG_TYPE.leftMargin;
|
|
}
|
|
else if (Math.abs(x - this.m_dMarginRight) < 1)
|
|
{
|
|
return AscWord.RULER_DRAG_TYPE.rightMargin;
|
|
}
|
|
|
|
if (isNegative)
|
|
{
|
|
if (x < this.m_dMarginLeft)
|
|
return -AscWord.RULER_DRAG_TYPE.leftMargin;
|
|
if (x > this.m_dMarginRight)
|
|
return -AscWord.RULER_DRAG_TYPE.rightMargin;
|
|
}
|
|
}
|
|
}
|
|
else if (this.CurrentObjectType == RULER_OBJECT_TYPE_TABLE)
|
|
{
|
|
var nTI_x = 0;
|
|
var nTI_r = 0;
|
|
if (y >= _top && y <= _bottom)
|
|
{
|
|
var markup = this.m_oTableMarkup;
|
|
var pos = markup.X;
|
|
var _count = markup.Cols.length;
|
|
for (var i = 0; i <= _count; i++)
|
|
{
|
|
if (Math.abs(x - pos) < 1)
|
|
{
|
|
this.DragTablePos = i;
|
|
return AscWord.RULER_DRAG_TYPE.table;
|
|
}
|
|
if (i == _count)
|
|
{
|
|
nTI_r = pos;
|
|
break;
|
|
}
|
|
if (i == 0)
|
|
{
|
|
nTI_x = pos;
|
|
}
|
|
|
|
pos += markup.Cols[i];
|
|
}
|
|
}
|
|
|
|
if (x > nTI_x && x < nTI_r)
|
|
isTableInside = true;
|
|
}
|
|
else if (this.CurrentObjectType == RULER_OBJECT_TYPE_COLUMNS)
|
|
{
|
|
if (y >= _top && y <= _bottom)
|
|
{
|
|
var markup = this.m_oColumnMarkup;
|
|
|
|
var nCI_x = markup.X;
|
|
var nCI_r = nCI_x;
|
|
|
|
if (markup.EqualWidth)
|
|
{
|
|
var _w = ((markup.R - markup.X) - markup.Space * (markup.Num - 1)) / markup.Num;
|
|
var _x = markup.X;
|
|
|
|
var _index = 0;
|
|
for (var i = 0; i < markup.Num; i++)
|
|
{
|
|
if (0 == i)
|
|
{
|
|
if (Math.abs(x - _x) < 1)
|
|
{
|
|
this.DragTablePos = _index;
|
|
return AscWord.RULER_DRAG_TYPE.columnSize;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (x < _x + 1 && x > _x - 2)
|
|
{
|
|
this.DragTablePos = _index;
|
|
return AscWord.RULER_DRAG_TYPE.columnSize;
|
|
}
|
|
}
|
|
|
|
++_index;
|
|
_x += _w;
|
|
nCI_r = _x;
|
|
|
|
if (i == markup.Num - 1)
|
|
{
|
|
if (Math.abs(x - _x) < 1)
|
|
{
|
|
this.DragTablePos = _index;
|
|
return AscWord.RULER_DRAG_TYPE.columnSize;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (x < _x + 2 && x > _x - 1)
|
|
{
|
|
this.DragTablePos = _index;
|
|
return AscWord.RULER_DRAG_TYPE.columnSize;
|
|
}
|
|
|
|
if (x > _x && x < (_x + markup.Space))
|
|
isColumnsInside = true;
|
|
}
|
|
|
|
++_index;
|
|
_x += markup.Space;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var _x = markup.X;
|
|
|
|
var _index = 0;
|
|
for (var i = 0; i < markup.Cols.length; i++)
|
|
{
|
|
if (0 == i)
|
|
{
|
|
if (Math.abs(x - _x) < 1)
|
|
{
|
|
this.DragTablePos = _index;
|
|
return AscWord.RULER_DRAG_TYPE.columnSize;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (x < _x + 1 && x > _x - 2)
|
|
{
|
|
this.DragTablePos = _index;
|
|
return AscWord.RULER_DRAG_TYPE.columnSize;
|
|
}
|
|
}
|
|
|
|
++_index;
|
|
_x += markup.Cols[i].W;
|
|
nCI_r = _x;
|
|
|
|
if (i == markup.Num - 1)
|
|
{
|
|
if (Math.abs(x - _x) < 1)
|
|
{
|
|
this.DragTablePos = _index;
|
|
return AscWord.RULER_DRAG_TYPE.columnSize;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (x < _x + 2 && x > _x - 1)
|
|
{
|
|
this.DragTablePos = _index;
|
|
return AscWord.RULER_DRAG_TYPE.columnSize;
|
|
}
|
|
}
|
|
|
|
if (i != markup.Cols.length - 1)
|
|
{
|
|
if (Math.abs(x - (_x + markup.Cols[i].Space / 2)) < 1)
|
|
{
|
|
this.DragTablePos = i;
|
|
return AscWord.RULER_DRAG_TYPE.columnPos;
|
|
}
|
|
|
|
if (x > _x && x < (_x + markup.Cols[i].Space))
|
|
isColumnsInside = true;
|
|
}
|
|
|
|
++_index;
|
|
_x += markup.Cols[i].Space;
|
|
}
|
|
}
|
|
|
|
if (x > nCI_x && x < nCI_r)
|
|
isColumnsInside2 = true;
|
|
}
|
|
}
|
|
|
|
if (isNegative)
|
|
{
|
|
if (isColumnsInside)
|
|
return -AscWord.RULER_DRAG_TYPE.columnSize;
|
|
|
|
// если вникуда - то ВСЕГДА margins
|
|
return -AscWord.RULER_DRAG_TYPE.leftMargin;
|
|
|
|
if (isColumnsInside2)
|
|
return 0;
|
|
if ((y >= _top && y <= _bottom) && !isTableInside)
|
|
{
|
|
if (x < _margin_left)
|
|
return -AscWord.RULER_DRAG_TYPE.leftMargin;
|
|
if (x > _margin_right)
|
|
return -AscWord.RULER_DRAG_TYPE.rightMargin;
|
|
}
|
|
}
|
|
|
|
return AscWord.RULER_DRAG_TYPE.none;
|
|
}
|
|
|
|
this.OnMouseDown = function(left, top, e)
|
|
{
|
|
var word_control = this.m_oWordControl;
|
|
|
|
if (true === word_control.m_oApi.isStartAddShape)
|
|
{
|
|
word_control.m_oApi.sync_EndAddShape();
|
|
word_control.m_oApi.sync_StartAddShapeCallback(false);
|
|
}
|
|
if (true === word_control.m_oApi.isInkDrawerOn())
|
|
{
|
|
word_control.m_oApi.stopInkDrawer();
|
|
}
|
|
|
|
AscCommon.check_MouseDownEvent(e, true);
|
|
global_mouseEvent.LockMouse();
|
|
|
|
this.SimpleChanges.Reinit();
|
|
|
|
var dKoefPxToMM = 100 * g_dKoef_pix_to_mm / word_control.m_nZoomValue;
|
|
var dKoef_mm_to_pix = g_dKoef_mm_to_pix * this.m_dZoom;
|
|
|
|
var _x = global_mouseEvent.X - left - word_control.X - word_control.GetMainContentBounds().L * g_dKoef_mm_to_pix;
|
|
if (!word_control.m_oApi.isRtlInterface)
|
|
_x -= 5 * g_dKoef_mm_to_pix;
|
|
|
|
_x *= dKoefPxToMM;
|
|
var _y = (global_mouseEvent.Y - word_control.Y) * g_dKoef_pix_to_mm;
|
|
|
|
this.DragType = this.CheckMouseType(_x, _y, true, true);
|
|
if (this.DragType < 0)
|
|
{
|
|
this.DragTypeMouseDown = -this.DragType;
|
|
this.DragType = AscWord.RULER_DRAG_TYPE.none;
|
|
}
|
|
else
|
|
{
|
|
this.DragTypeMouseDown = this.DragType;
|
|
}
|
|
|
|
if (global_mouseEvent.ClickCount > 1)
|
|
{
|
|
var eventType = "";
|
|
switch (this.DragTypeMouseDown)
|
|
{
|
|
case AscWord.RULER_DRAG_TYPE.leftMargin:
|
|
case AscWord.RULER_DRAG_TYPE.rightMargin:
|
|
{
|
|
eventType = "margins";
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.leftFirstInd:
|
|
case AscWord.RULER_DRAG_TYPE.leftInd:
|
|
case AscWord.RULER_DRAG_TYPE.firstInd:
|
|
case AscWord.RULER_DRAG_TYPE.rightInd:
|
|
{
|
|
eventType = "indents";
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.tab:
|
|
{
|
|
eventType = "tabs";
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.table:
|
|
{
|
|
eventType = "tables";
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.columnSize:
|
|
case AscWord.RULER_DRAG_TYPE.columnPos:
|
|
{
|
|
eventType = "columns";
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (eventType != "")
|
|
{
|
|
word_control.m_oApi.sendEvent("asc_onRulerDblClick", eventType);
|
|
this.DragType = AscWord.RULER_DRAG_TYPE.none;
|
|
this.OnMouseUp(left, top, e);
|
|
return;
|
|
}
|
|
}
|
|
|
|
var _margin_left = this.m_dMarginLeft;
|
|
var _margin_right = this.m_dMarginRight;
|
|
if (this.CurrentObjectType == RULER_OBJECT_TYPE_TABLE || this.CurrentObjectType == RULER_OBJECT_TYPE_COLUMNS)
|
|
{
|
|
_margin_left = this.TableMarginLeft;
|
|
_margin_right = this.TableMarginRight;
|
|
}
|
|
|
|
this.m_bIsMouseDown = true;
|
|
|
|
switch (this.DragType)
|
|
{
|
|
case AscWord.RULER_DRAG_TYPE.leftMargin:
|
|
{
|
|
var pos = left + _margin_left * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.rightMargin:
|
|
{
|
|
var pos = left + _margin_right * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.leftFirstInd:
|
|
{
|
|
let offset = this.m_bRtl ? (_margin_right - this.m_dIndentLeft) : (_margin_left + this.m_dIndentLeft);
|
|
let pos = left + offset * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
|
|
this.m_dIndentLeft_old = this.m_dIndentLeft;
|
|
this.m_dIndentLeftFirst_old = this.m_dIndentLeftFirst;
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.leftInd:
|
|
{
|
|
let offset = this.m_bRtl ? (_margin_right - this.m_dIndentLeft) : (_margin_left + this.m_dIndentLeft);
|
|
let pos = left + offset * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
|
|
this.m_dIndentLeft_old = this.m_dIndentLeft;
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.firstInd:
|
|
{
|
|
let offset = this.m_bRtl ? (_margin_right - this.m_dIndentLeftFirst) : (_margin_left + this.m_dIndentLeftFirst);
|
|
let pos = left + offset * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
|
|
this.m_dIndentLeftFirst_old = this.m_dIndentLeftFirst;
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.rightInd:
|
|
{
|
|
let offset = this.m_bRtl ? (_margin_left + this.m_dIndentRight) : (_margin_right - this.m_dIndentRight);
|
|
let pos = left + offset * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
|
|
this.m_dIndentRight_old = this.m_dIndentRight;
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.tab:
|
|
{
|
|
let offset = this.m_bRtl ? (_margin_right - this.m_arrTabs[this.m_lCurrentTab].pos) : (_margin_left + this.m_arrTabs[this.m_lCurrentTab].pos);
|
|
let pos = left + offset * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
this.m_dCurrentTabNewPosition = this.m_arrTabs[this.m_lCurrentTab].pos;
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.table:
|
|
{
|
|
var markup = this.m_oTableMarkup;
|
|
var pos = markup.X;
|
|
var _count = markup.Cols.length;
|
|
for (var i = 0; i < this.DragTablePos; i++)
|
|
{
|
|
pos += markup.Cols[i];
|
|
}
|
|
pos = left + pos * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
|
|
this.TableMarginLeftTrackStart = this.TableMarginLeft;
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.columnSize:
|
|
{
|
|
var markup = this.m_oColumnMarkup;
|
|
var pos = 0;
|
|
if (markup.EqualWidth)
|
|
{
|
|
var _w = ((markup.R - markup.X) - markup.Space * (markup.Num - 1)) / markup.Num;
|
|
var _x = markup.X + (this.DragTablePos >> 1) * (_w + markup.Space);
|
|
if (this.DragTablePos & 1 == 1)
|
|
_x += _w;
|
|
|
|
pos = _x;
|
|
}
|
|
else
|
|
{
|
|
var _x = markup.X;
|
|
|
|
var _index = 0;
|
|
for (var i = 0; i < markup.Cols.length && _index < this.DragTablePos; i++)
|
|
{
|
|
if (_index == this.DragTablePos)
|
|
break;
|
|
|
|
++_index;
|
|
_x += markup.Cols[i].W;
|
|
|
|
if (_index == this.DragTablePos)
|
|
break;
|
|
|
|
++_index;
|
|
_x += markup.Cols[i].Space;
|
|
}
|
|
|
|
pos = _x;
|
|
}
|
|
|
|
pos = left + pos * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
|
|
this.TableMarginLeftTrackStart = markup.X;
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.columnPos:
|
|
{
|
|
var markup = this.m_oColumnMarkup;
|
|
var pos = markup.X;
|
|
|
|
var _index = 0;
|
|
for (var i = 0; i < markup.Cols.length && i < this.DragTablePos; i++)
|
|
{
|
|
if (_index == this.DragTablePos)
|
|
break;
|
|
|
|
pos += markup.Cols[i].W;
|
|
pos += markup.Cols[i].Space;
|
|
}
|
|
|
|
if (this.DragTablePos < markup.Cols.length)
|
|
{
|
|
pos += markup.Cols[this.DragTablePos].W;
|
|
pos += markup.Cols[this.DragTablePos].Space / 2;
|
|
}
|
|
|
|
pos = left + pos * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
this.TableMarginLeftTrackStart = markup.X;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (AscWord.RULER_DRAG_TYPE.none === this.DragType)
|
|
{
|
|
let posT = 3;
|
|
let posB = 5.2;
|
|
let posL = this.m_bRtl ? _margin_left + this.m_dIndentRight : _margin_left + this.m_dIndentLeft;
|
|
let posR = this.m_bRtl ? _margin_right - this.m_dIndentRight : _margin_right - this.m_dIndentLeft;
|
|
if (posT <= _y && _y <= posB && posL <= _x && _x <= posR)
|
|
{
|
|
let newVal = RulerCorrectPosition(this, _x, this.m_bRtl ? _margin_right : _margin_left);
|
|
let tabPos = this.m_bRtl ? _margin_right - newVal : newVal - _margin_left;
|
|
let tabType = word_control.m_nTabsType;
|
|
if (this.m_bRtl)
|
|
{
|
|
if (tab_Left === tabType)
|
|
tabType = tab_Right;
|
|
else if (tab_Right === tabType)
|
|
tabType = tab_Left;
|
|
}
|
|
this.m_arrTabs[this.m_arrTabs.length] = new CTab(tabPos, tabType);
|
|
word_control.UpdateHorRuler();
|
|
|
|
this.m_lCurrentTab = this.m_arrTabs.length - 1;
|
|
|
|
this.DragType = AscWord.RULER_DRAG_TYPE.tab;
|
|
this.m_dCurrentTabNewPosition = tabPos;
|
|
|
|
let pos = left + newVal * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.VertLine(pos);
|
|
}
|
|
}
|
|
|
|
word_control.m_oDrawingDocument.LockCursorTypeCur();
|
|
}
|
|
this.OnMouseUp = function(left, top, e)
|
|
{
|
|
var word_control = this.m_oWordControl;
|
|
this.m_oWordControl.OnUpdateOverlay();
|
|
var lockedElement = AscCommon.check_MouseUpEvent(e);
|
|
|
|
this.m_dIndentLeft_old = -10000;
|
|
this.m_dIndentLeftFirst_old = -10000;
|
|
this.m_dIndentRight_old = -10000;
|
|
|
|
if (AscWord.RULER_DRAG_TYPE.tab !== this.DragType)
|
|
{
|
|
word_control.UpdateHorRuler();
|
|
//word_control.m_oOverlayApi.UnShow();
|
|
}
|
|
|
|
var _margin_left = this.m_dMarginLeft;
|
|
var _margin_right = this.m_dMarginRight;
|
|
if (this.CurrentObjectType == RULER_OBJECT_TYPE_TABLE || this.CurrentObjectType == RULER_OBJECT_TYPE_COLUMNS)
|
|
{
|
|
_margin_left = this.TableMarginLeft;
|
|
_margin_right = this.TableMarginRight;
|
|
}
|
|
|
|
switch (this.DragType)
|
|
{
|
|
case AscWord.RULER_DRAG_TYPE.leftMargin:
|
|
case AscWord.RULER_DRAG_TYPE.rightMargin:
|
|
{
|
|
if (!this.SimpleChanges.IsSimple)
|
|
this.SetMarginProperties();
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.leftFirstInd:
|
|
case AscWord.RULER_DRAG_TYPE.leftInd:
|
|
case AscWord.RULER_DRAG_TYPE.firstInd:
|
|
case AscWord.RULER_DRAG_TYPE.rightInd:
|
|
{
|
|
if (!this.SimpleChanges.IsSimple)
|
|
this.SetPrProperties();
|
|
else
|
|
word_control.OnUpdateOverlay();
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.tab:
|
|
{
|
|
// смотрим, сохраняем ли таб
|
|
var _y = (global_mouseEvent.Y - word_control.Y) * g_dKoef_pix_to_mm;
|
|
if (_y <= 3 || _y > 5.6 || this.m_dCurrentTabNewPosition < this.m_dIndentLeft || this.m_dCurrentTabNewPosition > _margin_right - _margin_left - this.m_dIndentRight)
|
|
{
|
|
if (-1 !== this.m_lCurrentTab)
|
|
this.m_arrTabs.splice(this.m_lCurrentTab, 1);
|
|
}
|
|
else
|
|
{
|
|
if (this.m_lCurrentTab < this.m_arrTabs.length)
|
|
this.m_arrTabs[this.m_lCurrentTab].pos = this.m_dCurrentTabNewPosition;
|
|
}
|
|
|
|
this.m_lCurrentTab = -1;
|
|
this.CorrectTabs();
|
|
this.m_oWordControl.UpdateHorRuler();
|
|
this.SetTabsProperties();
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.table:
|
|
{
|
|
if (!this.SimpleChanges.IsSimple)
|
|
this.SetTableProperties();
|
|
this.DragTablePos = -1;
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.columnSize:
|
|
case AscWord.RULER_DRAG_TYPE.columnPos:
|
|
{
|
|
if (!this.SimpleChanges.IsSimple)
|
|
this.SetColumnsProperties();
|
|
this.DragTablePos = -1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (AscWord.RULER_DRAG_TYPE.tab === this.DragType)
|
|
{
|
|
word_control.UpdateHorRuler();
|
|
//word_control.m_oOverlayApi.UnShow();
|
|
}
|
|
|
|
this.IsDrawingCurTab = true;
|
|
this.DragType = 0;
|
|
this.m_bIsMouseDown = false;
|
|
|
|
this.m_oWordControl.m_oDrawingDocument.UnlockCursorType();
|
|
this.SimpleChanges.Clear();
|
|
}
|
|
|
|
this.OnMouseUpExternal = function()
|
|
{
|
|
var word_control = this.m_oWordControl;
|
|
this.m_oWordControl.OnUpdateOverlay();
|
|
|
|
this.m_dIndentLeft_old = -10000;
|
|
this.m_dIndentLeftFirst_old = -10000;
|
|
this.m_dIndentRight_old = -10000;
|
|
|
|
if (AscWord.RULER_DRAG_TYPE.tab !== this.DragType)
|
|
{
|
|
word_control.UpdateHorRuler();
|
|
//word_control.m_oOverlayApi.UnShow();
|
|
}
|
|
|
|
var _margin_left = this.m_dMarginLeft;
|
|
var _margin_right = this.m_dMarginRight;
|
|
if (this.CurrentObjectType == RULER_OBJECT_TYPE_TABLE || this.CurrentObjectType == RULER_OBJECT_TYPE_COLUMNS)
|
|
{
|
|
_margin_left = this.TableMarginLeft;
|
|
_margin_right = this.TableMarginRight;
|
|
}
|
|
|
|
switch (this.DragType)
|
|
{
|
|
case AscWord.RULER_DRAG_TYPE.leftMargin:
|
|
case AscWord.RULER_DRAG_TYPE.rightMargin:
|
|
{
|
|
if (!this.SimpleChanges.IsSimple)
|
|
this.SetMarginProperties();
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.leftFirstInd:
|
|
case AscWord.RULER_DRAG_TYPE.leftInd:
|
|
case AscWord.RULER_DRAG_TYPE.firstInd:
|
|
case AscWord.RULER_DRAG_TYPE.rightInd:
|
|
{
|
|
if (!this.SimpleChanges.IsSimple)
|
|
this.SetPrProperties();
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.tab:
|
|
{
|
|
// смотрим, сохраняем ли таб
|
|
var _y = (global_mouseEvent.Y - word_control.Y) * g_dKoef_pix_to_mm;
|
|
if (_y <= 3 || _y > 5.6 || this.m_dCurrentTabNewPosition < this.m_dIndentLeft || this.m_dCurrentTabNewPosition > _margin_right - _margin_left - this.m_dIndentRight)
|
|
{
|
|
if (-1 !== this.m_lCurrentTab)
|
|
this.m_arrTabs.splice(this.m_lCurrentTab, 1);
|
|
}
|
|
else
|
|
{
|
|
if (this.m_lCurrentTab < this.m_arrTabs.length)
|
|
this.m_arrTabs[this.m_lCurrentTab].pos = this.m_dCurrentTabNewPosition;
|
|
}
|
|
this.m_lCurrentTab = -1;
|
|
this.CorrectTabs();
|
|
this.m_oWordControl.UpdateHorRuler();
|
|
this.SetTabsProperties();
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.table:
|
|
{
|
|
if (!this.SimpleChanges.IsSimple)
|
|
this.SetTableProperties();
|
|
this.DragTablePos = -1;
|
|
break;
|
|
}
|
|
case AscWord.RULER_DRAG_TYPE.columnSize:
|
|
case AscWord.RULER_DRAG_TYPE.columnPos:
|
|
{
|
|
if (!this.SimpleChanges.IsSimple)
|
|
this.SetColumnsProperties();
|
|
this.DragTablePos = -1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (AscWord.RULER_DRAG_TYPE.tab === this.DragType)
|
|
{
|
|
word_control.UpdateHorRuler();
|
|
//word_control.m_oOverlayApi.UnShow();
|
|
}
|
|
|
|
this.IsDrawingCurTab = true;
|
|
this.DragType = 0;
|
|
this.m_bIsMouseDown = false;
|
|
|
|
this.m_oWordControl.m_oDrawingDocument.UnlockCursorType();
|
|
this.SimpleChanges.Clear();
|
|
}
|
|
|
|
this.SetTabsProperties = function()
|
|
{
|
|
// потом заменить на объекты CTab (когда Илюха реализует не только левые табы)
|
|
var _arr = new CParaTabs();
|
|
var _c = this.m_arrTabs.length;
|
|
for (var i = 0; i < _c; i++)
|
|
{
|
|
if (this.m_arrTabs[i].type == tab_Left || this.m_arrTabs[i].type == tab_Right || this.m_arrTabs[i].type == tab_Center)
|
|
_arr.Add(new CParaTab(this.m_arrTabs[i].type, this.m_arrTabs[i].pos, this.m_arrTabs[i].leader));
|
|
}
|
|
|
|
if (false === this.m_oWordControl.m_oLogicDocument.Document_Is_SelectionLocked(AscCommon.changestype_Paragraph_Properties))
|
|
{
|
|
this.m_oWordControl.m_oLogicDocument.StartAction(AscDFH.historydescription_Document_SetParagraphTabs);
|
|
this.m_oWordControl.m_oLogicDocument.SetParagraphTabs(_arr);
|
|
this.m_oWordControl.m_oLogicDocument.FinalizeAction();
|
|
}
|
|
this.m_oWordControl.m_oLogicDocument.UpdateSelection();
|
|
this.m_oWordControl.m_oLogicDocument.UpdateInterface();
|
|
}
|
|
|
|
this.SetPrProperties = function(isTemporary)
|
|
{
|
|
let left = this.m_dIndentLeft;
|
|
let right = this.m_dIndentRight;
|
|
let firstLine = this.m_dIndentLeftFirst - this.m_dIndentLeft;
|
|
|
|
let logicDocument = this.m_oWordControl.m_oLogicDocument;
|
|
if (logicDocument.IsSelectionLocked(AscCommon.changestype_Paragraph_Properties))
|
|
{
|
|
logicDocument.UpdateSelection();
|
|
logicDocument.UpdateInterface();
|
|
return;
|
|
}
|
|
|
|
isTemporary = isTemporary && logicDocument.IsDocumentEditor();
|
|
|
|
if (isTemporary)
|
|
logicDocument.TurnOff_InterfaceEvents();
|
|
|
|
logicDocument.StartAction(AscDFH.historydescription_Document_SetParagraphIndentFromRulers);
|
|
logicDocument.SetParagraphIndent({
|
|
Left : left,
|
|
Right : right,
|
|
FirstLine : firstLine
|
|
});
|
|
logicDocument.UpdateInterface();
|
|
logicDocument.Recalculate();
|
|
logicDocument.FinalizeAction();
|
|
|
|
if (isTemporary)
|
|
{
|
|
AscCommon.History.SetLastPointTemporary();
|
|
logicDocument.TurnOn_InterfaceEvents();
|
|
}
|
|
}
|
|
this.SetMarginProperties = function()
|
|
{
|
|
if ( false === this.m_oWordControl.m_oLogicDocument.Document_Is_SelectionLocked(AscCommon.changestype_Document_SectPr) )
|
|
{
|
|
this.m_oWordControl.m_oLogicDocument.StartAction(AscDFH.historydescription_Document_SetDocumentMargin_Hor);
|
|
this.m_oWordControl.m_oLogicDocument.SetDocumentMargin( { Left : this.m_dMarginLeft, Right : this.m_dMarginRight }, true);
|
|
this.m_oWordControl.m_oLogicDocument.FinalizeAction();
|
|
}
|
|
this.m_oWordControl.m_oLogicDocument.UpdateSelection();
|
|
this.m_oWordControl.m_oLogicDocument.UpdateInterface();
|
|
}
|
|
|
|
this.SetTableProperties = function()
|
|
{
|
|
if ( false === this.m_oWordControl.m_oLogicDocument.Document_Is_SelectionLocked(AscCommon.changestype_Table_Properties) )
|
|
{
|
|
this.m_oWordControl.m_oLogicDocument.StartAction(AscDFH.historydescription_Document_SetTableMarkup_Hor);
|
|
|
|
this.m_oTableMarkup.CorrectTo();
|
|
this.m_oTableMarkup.Table.Update_TableMarkupFromRuler(this.m_oTableMarkup, true, this.DragTablePos);
|
|
if (this.m_oTableMarkup)
|
|
this.m_oTableMarkup.CorrectFrom();
|
|
|
|
this.m_oWordControl.m_oLogicDocument.UpdateRulers();
|
|
this.m_oWordControl.m_oLogicDocument.FinalizeAction();
|
|
}
|
|
this.m_oWordControl.m_oLogicDocument.UpdateSelection();
|
|
this.m_oWordControl.m_oLogicDocument.UpdateInterface();
|
|
}
|
|
|
|
this.SetColumnsProperties = function()
|
|
{
|
|
this.m_oWordControl.m_oLogicDocument.Update_ColumnsMarkupFromRuler(this.m_oColumnMarkup);
|
|
}
|
|
|
|
this.BlitToMain = function(left, top, htmlElement)
|
|
{
|
|
var dPR = AscCommon.AscBrowser.retinaPixelRatio;
|
|
left = Math.round(dPR * left);
|
|
var _margin_left = this.m_dMarginLeft;
|
|
var _margin_right = this.m_dMarginRight;
|
|
if (this.CurrentObjectType == RULER_OBJECT_TYPE_TABLE || this.CurrentObjectType == RULER_OBJECT_TYPE_COLUMNS)
|
|
{
|
|
_margin_left = this.TableMarginLeft;
|
|
_margin_right = this.TableMarginRight;
|
|
}
|
|
|
|
var checker = this.RepaintChecker;
|
|
if (!checker.BlitAttack && left == checker.BlitLeft && !this.m_bIsMouseDown)
|
|
{
|
|
if (checker.BlitIndentLeft == this.m_dIndentLeft
|
|
&& checker.BlitIndentLeftFirst == this.m_dIndentLeftFirst
|
|
&& checker.BlitIndentRight == this.m_dIndentRight
|
|
&& checker.BlitRtl === this.m_bRtl
|
|
&& checker.BlitDefaultTab == this.m_dDefaultTab
|
|
&& _margin_left == checker.BlitMarginLeftInd
|
|
&& _margin_right == checker.BlitMarginRightInd)
|
|
{
|
|
// осталось проверить только табы кастомные
|
|
var _count1 = 0;
|
|
if (null != checker.BlitTabs)
|
|
_count1 = checker.BlitTabs.length;
|
|
|
|
var _count2 = this.m_arrTabs.length;
|
|
if (_count1 == _count2)
|
|
{
|
|
var bIsBreak = false;
|
|
for (var ii = 0; ii < _count1; ii++)
|
|
{
|
|
if ((checker.BlitTabs[ii].type != this.m_arrTabs[ii].type) || (checker.BlitTabs[ii].pos != this.m_arrTabs[ii].pos))
|
|
{
|
|
bIsBreak = true;
|
|
break;
|
|
}
|
|
}
|
|
if (false === bIsBreak)
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
checker.BlitAttack = false;
|
|
htmlElement.width = htmlElement.width;
|
|
var context = htmlElement.getContext('2d');
|
|
context.setTransform(1, 0, 0, 1, 0, 0);
|
|
|
|
if (null != this.m_oCanvas)
|
|
{
|
|
checker.BlitLeft = left;
|
|
checker.BlitRtl = this.m_bRtl;
|
|
checker.BlitIndentLeft = this.m_dIndentLeft;
|
|
checker.BlitIndentLeftFirst = this.m_dIndentLeftFirst;
|
|
checker.BlitIndentRight = this.m_dIndentRight;
|
|
checker.BlitDefaultTab = this.m_dDefaultTab;
|
|
checker.BlitTabs = null;
|
|
if (0 != this.m_arrTabs.length)
|
|
{
|
|
checker.BlitTabs = [];
|
|
var _len = this.m_arrTabs.length;
|
|
for (var ii = 0; ii < _len; ii++)
|
|
{
|
|
checker.BlitTabs[ii] = { type: this.m_arrTabs[ii].type, pos: this.m_arrTabs[ii].pos };
|
|
}
|
|
}
|
|
var roundDPR = Math.round(dPR);
|
|
var indent = 0.5 * roundDPR;
|
|
//context.drawImage(this.m_oCanvas, left - 5, 0, this.m_oCanvas.width, this.m_oCanvas.height,
|
|
// 0, 0, this.m_oCanvas.width, this.m_oCanvas.height);
|
|
|
|
context.drawImage(this.m_oCanvas, 5 * roundDPR, 0, this.m_oCanvas.width - 10 * roundDPR, this.m_oCanvas.height,
|
|
left, 0, this.m_oCanvas.width - 10 * roundDPR, this.m_oCanvas.height);
|
|
|
|
if (!this.IsDrawAnyMarkers)
|
|
return;
|
|
var dKoef_mm_to_pix = g_dKoef_mm_to_pix * this.m_dZoom * dPR;
|
|
var dCenterX = 0;
|
|
var var2 = 0;
|
|
var var3 = 0;
|
|
|
|
// не менять!!!
|
|
var2 = 5 * dPR;//(1.4 * g_dKoef_mm_to_pix) >> 0;
|
|
var3 = 3 * dPR;//(1 * g_dKoef_mm_to_pix) >> 0;
|
|
|
|
checker.BlitMarginLeftInd = _margin_left;
|
|
checker.BlitMarginRightInd = _margin_right;
|
|
|
|
var _1mm_to_pix = g_dKoef_mm_to_pix * dPR;
|
|
let top = this.m_nTop;
|
|
let bottom = this.m_nBottom;
|
|
let isRtl = this.m_bRtl;
|
|
|
|
function blitLeftInd(ind, isRtl)
|
|
{
|
|
let offset = isRtl ? (_margin_right - ind) : (_margin_left + ind);
|
|
let dCenterX = left + offset * dKoef_mm_to_pix;
|
|
|
|
let var1 = parseInt(dCenterX - _1mm_to_pix) - indent + Math.round(dPR) - 1;
|
|
let var4 = parseInt(dCenterX + _1mm_to_pix) + indent + Math.round(dPR) - 1;
|
|
|
|
if (0 !== ((var1 - var4 + Math.round(dPR)) & 1))
|
|
var4 += 1;
|
|
|
|
context.beginPath();
|
|
context.lineWidth = Math.round(dPR);
|
|
context.moveTo(var1, bottom + indent);
|
|
context.lineTo(var4, bottom + indent);
|
|
context.lineTo(var4, bottom + indent + Math.round(var2));
|
|
context.lineTo(var1, bottom + indent + Math.round(var2));
|
|
context.lineTo(var1, bottom + indent);
|
|
context.lineTo(var1, bottom + indent - Math.round(var3));
|
|
context.lineTo((var1 + var4) / 2, bottom - Math.round(var2 * 1.2));
|
|
context.lineTo(var4, bottom + indent - Math.round(var3));
|
|
context.lineTo(var4, bottom + indent);
|
|
|
|
context.fill();
|
|
context.stroke();
|
|
}
|
|
|
|
function blitFirstInd(ind, isRtl)
|
|
{
|
|
let offset = isRtl ? (_margin_right - ind) : (_margin_left + ind);
|
|
dCenterX = left + offset * dKoef_mm_to_pix;
|
|
|
|
let var1 = parseInt(dCenterX - _1mm_to_pix) - indent + Math.round(dPR) - 1;
|
|
let var4 = parseInt(dCenterX + _1mm_to_pix) + indent + Math.round(dPR) - 1;
|
|
|
|
if (0 !== ((var1 - var4 + Math.round(dPR)) & 1))
|
|
var4 += 1;
|
|
|
|
// first line indent
|
|
context.beginPath();
|
|
context.lineWidth = Math.round(dPR);
|
|
context.moveTo(var1, top + indent);
|
|
context.lineTo(var1, top + indent - Math.round(var3));
|
|
context.lineTo(var4, top + indent - Math.round(var3));
|
|
context.lineTo(var4, top + indent);
|
|
context.lineTo((var1 + var4) / 2, top + Math.round(var2 * 1.2));
|
|
context.closePath();
|
|
|
|
context.fill();
|
|
context.stroke();
|
|
}
|
|
|
|
function blitRightInd(ind, isRtl)
|
|
{
|
|
let offset = isRtl ? (_margin_left + ind) : (_margin_right - ind);
|
|
dCenterX = left + offset * dKoef_mm_to_pix;
|
|
|
|
let var1 = parseInt(dCenterX - _1mm_to_pix) - indent + Math.round(dPR) - 1;
|
|
let var4 = parseInt(dCenterX + _1mm_to_pix) + indent + Math.round(dPR) - 1;
|
|
|
|
if (0 !== ((var1 - var4 + Math.round(dPR)) & 1))
|
|
var4 += 1;
|
|
|
|
context.beginPath();
|
|
context.lineWidth = Math.round(dPR);
|
|
context.moveTo(var1, bottom + indent);
|
|
context.lineTo(var4, bottom + indent);
|
|
context.lineTo(var4, bottom + indent - Math.round(var3));
|
|
context.lineTo((var1 + var4) / 2, bottom - Math.round(var2 * 1.2));
|
|
context.lineTo(var1, bottom + indent - Math.round(var3));
|
|
context.closePath();
|
|
|
|
context.fill();
|
|
context.stroke();
|
|
}
|
|
|
|
function blitLeftTab(x, y)
|
|
{
|
|
context.beginPath();
|
|
context.moveTo(x, y);
|
|
context.lineTo(x, y + Math.round(5 * dPR));
|
|
context.lineTo(x + Math.round(5 * dPR), y + Math.round(5 * dPR));
|
|
context.stroke();
|
|
}
|
|
|
|
function blitRightTab(x, y)
|
|
{
|
|
context.beginPath();
|
|
context.moveTo(x, y);
|
|
context.lineTo(x, y + Math.round(5 * dPR));
|
|
context.lineTo(x - Math.round(5 * dPR), y + Math.round(5 * dPR));
|
|
context.stroke();
|
|
}
|
|
|
|
function blitCenterTab(x, y)
|
|
{
|
|
context.beginPath();
|
|
context.moveTo(x, y);
|
|
context.lineTo(x, y + Math.round(5 * dPR));
|
|
context.moveTo(x - Math.round(5 * dPR), y + Math.round(5 * dPR));
|
|
context.lineTo(x + Math.round(5 * dPR), y + Math.round(5 * dPR));
|
|
context.stroke();
|
|
}
|
|
|
|
function blitTab(tabPos, tabType)
|
|
{
|
|
let x = parseInt((isRtl ? (_margin_right - tabPos) : (_margin_left + tabPos)) * dKoef_mm_to_pix) + left;
|
|
let y = bottom - 5 * dPR;
|
|
|
|
let lineW = context.lineWidth;
|
|
context.lineWidth = 2 * roundDPR;
|
|
|
|
if (tab_Left === tabType)
|
|
{
|
|
if (isRtl)
|
|
blitRightTab(x, y);
|
|
else
|
|
blitLeftTab(x, y);
|
|
}
|
|
else if (tab_Right === tabType)
|
|
{
|
|
if (isRtl)
|
|
blitLeftTab(x, y);
|
|
else
|
|
blitRightTab(x, y);
|
|
}
|
|
else if (tab_Center === tab_Center)
|
|
{
|
|
blitCenterTab(x, y);
|
|
}
|
|
|
|
context.lineWidth = lineW;
|
|
}
|
|
|
|
// old position --------------------------------------
|
|
context.strokeStyle = GlobalSkin.RulerMarkersOutlineColorOld;
|
|
context.fillStyle = GlobalSkin.RulerMarkersFillColorOld;
|
|
if (-10000 !== this.m_dIndentLeft_old && this.m_dIndentLeft_old !== this.m_dIndentLeft)
|
|
blitLeftInd(this.m_dIndentLeft_old, this.m_bRtl);
|
|
|
|
if (-10000 !== this.m_dIndentLeftFirst_old && this.m_dIndentLeftFirst_old !== this.m_dIndentLeftFirst)
|
|
blitFirstInd(this.m_dIndentLeftFirst_old, this.m_bRtl);
|
|
|
|
if (-10000 !== this.m_dIndentRight_old && this.m_dIndentRight_old !== this.m_dIndentRight)
|
|
blitRightInd(this.m_dIndentRight_old, this.m_bRtl);
|
|
|
|
context.strokeStyle = GlobalSkin.RulerTabsColorOld;
|
|
if (-1 !== this.m_lCurrentTab && this.m_lCurrentTab < this.m_arrTabs.length)
|
|
{
|
|
var _tab = this.m_arrTabs[this.m_lCurrentTab];
|
|
blitTab(_tab.pos, _tab.type);
|
|
}
|
|
|
|
// ---------------------------------------------------
|
|
|
|
// рисуем инденты, только если они корректны
|
|
var posL = _margin_left;
|
|
if ((_margin_left + this.m_dIndentLeft) > posL)
|
|
posL = _margin_left + this.m_dIndentLeft;
|
|
if ((_margin_left + this.m_dIndentLeftFirst) > posL)
|
|
posL = _margin_left + this.m_dIndentLeftFirst;
|
|
|
|
var posR = _margin_right;
|
|
if (this.m_dIndentRight > 0)
|
|
posR = _margin_right - this.m_dIndentRight;
|
|
|
|
if (posL < posR)
|
|
{
|
|
context.strokeStyle = GlobalSkin.RulerMarkersOutlineColor;
|
|
context.fillStyle = GlobalSkin.RulerMarkersFillColor;
|
|
|
|
blitLeftInd(this.m_dIndentLeft, this.m_bRtl);
|
|
blitRightInd(this.m_dIndentRight, this.m_bRtl)
|
|
blitFirstInd(this.m_dIndentLeftFirst, this.m_bRtl);
|
|
}
|
|
|
|
// теперь рисуем табы ----------------------------------------
|
|
// default
|
|
var position_default_tab = this.m_dDefaultTab;
|
|
let _positon_y = this.m_nBottom + Math.round(1.5 * dPR);
|
|
|
|
var _min_default_value = Math.max(0, this.m_dMaxTab);
|
|
if (this.m_dDefaultTab > 0.01)
|
|
{
|
|
if (this.m_bRtl)
|
|
{
|
|
while (_margin_right - position_default_tab > this.m_dMarginLeft)
|
|
{
|
|
if (position_default_tab < _min_default_value)
|
|
{
|
|
position_default_tab += this.m_dDefaultTab;
|
|
continue;
|
|
}
|
|
|
|
let _x = parseInt((_margin_right - position_default_tab) * dKoef_mm_to_pix) + left + indent;
|
|
context.beginPath();
|
|
context.moveTo(_x, _positon_y);
|
|
context.lineTo(_x, _positon_y + Math.round(3 * dPR));
|
|
context.stroke();
|
|
|
|
position_default_tab += this.m_dDefaultTab;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
while (_margin_left + position_default_tab < this.m_dMarginRight)
|
|
{
|
|
if (position_default_tab < _min_default_value)
|
|
{
|
|
position_default_tab += this.m_dDefaultTab;
|
|
continue;
|
|
}
|
|
|
|
let _x = parseInt((_margin_left + position_default_tab) * dKoef_mm_to_pix) + left + indent;
|
|
context.beginPath();
|
|
context.moveTo(_x, _positon_y);
|
|
context.lineTo(_x, _positon_y + Math.round(3 * dPR));
|
|
context.stroke();
|
|
|
|
position_default_tab += this.m_dDefaultTab;
|
|
}
|
|
}
|
|
}
|
|
|
|
// custom tabs
|
|
context.strokeStyle = GlobalSkin.RulerTabsColor;
|
|
for (let i = 0, tabCount = this.m_arrTabs.length; i < tabCount; ++i)
|
|
{
|
|
let tab = this.m_arrTabs[i];
|
|
let tabPos = tab.pos;
|
|
|
|
if (i === this.m_lCurrentTab)
|
|
{
|
|
if (!this.IsDrawingCurTab)
|
|
continue;
|
|
// рисуем вместо него - позицию нового
|
|
tabPos = this.m_dCurrentTabNewPosition;
|
|
}
|
|
else if (tab.pos < this.m_dIndentLeft)
|
|
{
|
|
continue;
|
|
}
|
|
blitTab(tabPos, tab.type);
|
|
}
|
|
// -----------------------------------------------------------
|
|
}
|
|
}
|
|
|
|
this.UpdateParaInd = function(paraInd, isRtl)
|
|
{
|
|
if (!paraInd)
|
|
return 0;
|
|
|
|
let left = undefined !== paraInd.Left ? paraInd.Left : 0;
|
|
let right = undefined !== paraInd.Right ? paraInd.Right : 0;
|
|
let firstLine = undefined !== paraInd.FirstLine ? left + paraInd.FirstLine : 0;
|
|
|
|
let update = 0;
|
|
|
|
if (Math.abs(this.m_dIndentLeft - left) > AscWord.EPSILON)
|
|
{
|
|
this.m_dIndentLeft = left;
|
|
update |= 1;
|
|
}
|
|
|
|
if (Math.abs(this.m_dIndentLeftFirst - firstLine) > AscWord.EPSILON)
|
|
{
|
|
this.m_dIndentLeftFirst = firstLine;
|
|
update |= 1;
|
|
}
|
|
|
|
if (Math.abs(this.m_dIndentRight - right) > AscWord.EPSILON)
|
|
{
|
|
this.m_dIndentRight = right;
|
|
update |= 1;
|
|
}
|
|
|
|
if (this.m_bRtl !== isRtl)
|
|
{
|
|
this.m_bRtl = isRtl;
|
|
update |= 1;
|
|
update |= 2;
|
|
}
|
|
|
|
return update;
|
|
};
|
|
}
|
|
|
|
function CVerRuler()
|
|
{
|
|
this.m_oPage = null;
|
|
|
|
this.m_nLeft = 0; // значения в пикселах - смещение до самой линейки
|
|
this.m_nRight = 0; // значения в пикселах - смещение до самой линейки
|
|
// (т.е. ширина линейки в пикселах = (this.m_nRight - this.m_nLeft))
|
|
|
|
this.m_dMarginTop = 20;
|
|
this.m_dMarginBottom = 250;
|
|
|
|
this.m_oCanvas = null;
|
|
|
|
this.m_dZoom = 1;
|
|
|
|
this.DragType = 0; // 0 - none
|
|
// 1 - top margin, 2 - bottom margin
|
|
// 3 - header_top, 4 - header_bottom
|
|
// 5 - table rows
|
|
|
|
// отдельные настройки для текущего объекта линейки
|
|
this.CurrentObjectType = RULER_OBJECT_TYPE_PARAGRAPH;
|
|
this.m_oTableMarkup = null;
|
|
this.header_top = 0;
|
|
this.header_bottom = 0;
|
|
|
|
this.DragTablePos = -1;
|
|
|
|
this.RepaintChecker = new CVerRulerRepaintChecker();
|
|
|
|
// presentations addons
|
|
this.IsCanMoveMargins = true;
|
|
|
|
this.m_oWordControl = null;
|
|
|
|
this.SimpleChanges = new RulerCheckSimpleChanges();
|
|
|
|
this.Units = c_oAscDocumentUnits.Millimeter;
|
|
|
|
this.CheckCanvas = function()
|
|
{
|
|
this.m_dZoom = this.m_oWordControl.m_nZoomValue / 100;
|
|
var dPR = AscCommon.AscBrowser.retinaPixelRatio;
|
|
var dKoef_mm_to_pix = g_dKoef_mm_to_pix * this.m_dZoom * dPR;
|
|
|
|
var heightNew = dKoef_mm_to_pix * this.m_oPage.height_mm;
|
|
|
|
var _height = Math.round(10 * dPR) + heightNew;
|
|
if (dPR > 1)
|
|
_height += Math.round(dPR);
|
|
|
|
var _width = 5 * g_dKoef_mm_to_pix * dPR;
|
|
|
|
var intW = _width >> 0;
|
|
var intH = _height >> 0;
|
|
if (null == this.m_oCanvas)
|
|
{
|
|
this.m_oCanvas = document.createElement('canvas');
|
|
this.m_oCanvas.width = intW;
|
|
this.m_oCanvas.height = intH;
|
|
}
|
|
else
|
|
{
|
|
var oldW = this.m_oCanvas.width;
|
|
var oldH = this.m_oCanvas.height;
|
|
|
|
if ((oldW != intW) || (oldH != intH))
|
|
{
|
|
delete this.m_oCanvas;
|
|
this.m_oCanvas = document.createElement('canvas');
|
|
this.m_oCanvas.width = intW;
|
|
this.m_oCanvas.height = intH;
|
|
}
|
|
}
|
|
return heightNew;
|
|
}
|
|
|
|
this.CreateBackground = function(cachedPage, isattack)
|
|
{
|
|
if (window["NATIVE_EDITOR_ENJINE"])
|
|
return;
|
|
|
|
if (null == cachedPage || undefined == cachedPage)
|
|
return;
|
|
|
|
this.m_oPage = cachedPage;
|
|
var height = this.CheckCanvas();
|
|
|
|
if (0 == this.DragType)
|
|
{
|
|
this.m_dMarginTop = cachedPage.margin_top;
|
|
this.m_dMarginBottom = cachedPage.margin_bottom;
|
|
}
|
|
|
|
// check old state
|
|
var checker = this.RepaintChecker;
|
|
var markup = this.m_oTableMarkup;
|
|
|
|
if (isattack !== true && this.CurrentObjectType == checker.Type && height == checker.Height)
|
|
{
|
|
if (this.CurrentObjectType == RULER_OBJECT_TYPE_PARAGRAPH)
|
|
{
|
|
if (this.m_dMarginTop == checker.MarginTop && this.m_dMarginBottom == checker.MarginBottom)
|
|
return;
|
|
}
|
|
else if (this.CurrentObjectType == RULER_OBJECT_TYPE_HEADER || this.CurrentObjectType == RULER_OBJECT_TYPE_FOOTER)
|
|
{
|
|
if (this.header_top == checker.HeaderTop && this.header_bottom == checker.HeaderBottom)
|
|
return;
|
|
}
|
|
else if (this.CurrentObjectType == RULER_OBJECT_TYPE_TABLE)
|
|
{
|
|
var oldcount = checker.rowsY.length;
|
|
var newcount = markup.Rows.length;
|
|
|
|
if (oldcount == newcount)
|
|
{
|
|
var arr1 = checker.rowsY;
|
|
var arr2 = checker.rowsH;
|
|
|
|
var rows = markup.Rows;
|
|
|
|
var _break = false;
|
|
for (var i = 0; i < oldcount; i++)
|
|
{
|
|
if ((arr1[i] != rows[i].Y) || (arr2[i] != rows[i].H))
|
|
{
|
|
_break = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!_break)
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
//console.log("vertical");
|
|
|
|
checker.Height = height;
|
|
checker.Type = this.CurrentObjectType;
|
|
checker.BlitAttack = true;
|
|
|
|
var dPR = AscCommon.AscBrowser.retinaPixelRatio;
|
|
var dKoef_mm_to_pix = g_dKoef_mm_to_pix * this.m_dZoom * dPR;
|
|
|
|
// не править !!!
|
|
this.m_nLeft = Math.round(3 * dPR);//(0.8 * g_dKoef_mm_to_pix) >> 0;
|
|
this.m_nRight = Math.round(15 * dPR);//(4.2 * g_dKoef_mm_to_pix) >> 0;
|
|
|
|
var context = this.m_oCanvas.getContext('2d');
|
|
context.setTransform(1, 0, 0, 1, 0, Math.round(5 * dPR));
|
|
|
|
context.fillStyle = GlobalSkin.BackgroundColor;
|
|
context.fillRect(0, 0, this.m_oCanvas.width, this.m_oCanvas.height);
|
|
|
|
var top_margin = 0;
|
|
var bottom_margin = 0;
|
|
|
|
if (RULER_OBJECT_TYPE_PARAGRAPH == this.CurrentObjectType)
|
|
{
|
|
top_margin = (this.m_dMarginTop * dKoef_mm_to_pix) >> 0;
|
|
bottom_margin = (this.m_dMarginBottom * dKoef_mm_to_pix) >> 0;
|
|
|
|
checker.MarginTop = this.m_dMarginTop;
|
|
checker.MarginBottom = this.m_dMarginBottom;
|
|
}
|
|
else if (RULER_OBJECT_TYPE_HEADER == this.CurrentObjectType || RULER_OBJECT_TYPE_FOOTER == this.CurrentObjectType)
|
|
{
|
|
top_margin = (this.header_top * dKoef_mm_to_pix) >> 0;
|
|
bottom_margin = (this.header_bottom * dKoef_mm_to_pix) >> 0;
|
|
|
|
checker.HeaderTop = this.header_top;
|
|
checker.HeaderBottom = this.header_bottom;
|
|
}
|
|
else if (RULER_OBJECT_TYPE_TABLE == this.CurrentObjectType)
|
|
{
|
|
var _arr1 = checker.rowsY;
|
|
var _arr2 = checker.rowsH;
|
|
|
|
if (0 != _arr1.length)
|
|
_arr1.splice(0, _arr1.length);
|
|
|
|
if (0 != _arr2.length)
|
|
_arr2.splice(0, _arr2.length);
|
|
|
|
var _count = this.m_oTableMarkup.Rows.length;
|
|
|
|
for (var i = 0; i < _count; i++)
|
|
{
|
|
_arr1[i] = markup.Rows[i].Y;
|
|
_arr2[i] = markup.Rows[i].H;
|
|
}
|
|
|
|
if (_count != 0)
|
|
{
|
|
top_margin = (markup.Rows[0].Y * dKoef_mm_to_pix) >> 0;
|
|
bottom_margin = ((markup.Rows[_count - 1].Y + markup.Rows[_count - 1].H) * dKoef_mm_to_pix) >> 0;
|
|
}
|
|
}
|
|
|
|
var indent = 0.5 * Math.round(dPR);
|
|
|
|
if (bottom_margin > top_margin)
|
|
{
|
|
context.fillStyle = GlobalSkin.RulerLight;
|
|
context.fillRect(this.m_nLeft + indent, top_margin + indent, this.m_nRight - this.m_nLeft, bottom_margin - top_margin);
|
|
}
|
|
|
|
var intH = height >> 0;
|
|
|
|
if (true)
|
|
{
|
|
context.beginPath();
|
|
context.fillStyle = GlobalSkin.RulerDark;
|
|
|
|
context.fillRect(this.m_nLeft + indent, indent, this.m_nRight - this.m_nLeft, top_margin);
|
|
context.fillRect(this.m_nLeft + indent, bottom_margin + indent, this.m_nRight - this.m_nLeft, Math.max(intH - bottom_margin, 1));
|
|
context.beginPath();
|
|
}
|
|
|
|
context.beginPath();
|
|
context.lineWidth = Math.round(dPR);
|
|
context.strokeStyle = GlobalSkin.RulerTextColor;
|
|
context.fillStyle = GlobalSkin.RulerTextColor;
|
|
|
|
var mm_1_4 = 10 * dKoef_mm_to_pix / 4;
|
|
var isDraw1_4 = (mm_1_4 > 7) ? true : false;
|
|
var inch_1_8 = 25.4 * dKoef_mm_to_pix / 8;
|
|
|
|
var middleHor = (this.m_nLeft + this.m_nRight) / 2;
|
|
var part1 = dPR;
|
|
var part2 = 2.5 * dPR;
|
|
|
|
var l_part1 = Math.floor(middleHor - part1);
|
|
var r_part1 = Math.ceil(middleHor + part1);
|
|
var l_part2 = Math.floor(middleHor - part2);
|
|
var r_part2 = Math.ceil(middleHor + part2);
|
|
|
|
context.font = Math.round(7 * dPR) + "pt Arial";
|
|
|
|
if (this.Units == c_oAscDocumentUnits.Millimeter)
|
|
{
|
|
var lCount1 = ((height - top_margin) / mm_1_4) >> 0;
|
|
var lCount2 = (top_margin / mm_1_4) >> 0;
|
|
|
|
var index = 0;
|
|
var num = 0;
|
|
for (var i = 1; i < lCount1; i++)
|
|
{
|
|
var lYPos = ((top_margin + i * mm_1_4) >> 0) + indent;
|
|
index++;
|
|
|
|
if (index == 4)
|
|
index = 0;
|
|
|
|
if (0 == index)
|
|
{
|
|
num++;
|
|
// number
|
|
|
|
var strNum = "" + num;
|
|
var lWidthText = context.measureText(strNum).width;
|
|
|
|
context.translate(middleHor, lYPos);
|
|
context.rotate(-Math.PI / 2);
|
|
context.fillText(strNum, -lWidthText / 2.0, Math.round(4 * dPR));
|
|
context.setTransform(1, 0, 0, 1, 0, Math.round(5 * dPR));
|
|
}
|
|
else if (1 == index && isDraw1_4)
|
|
{
|
|
// 1/4
|
|
context.beginPath();
|
|
context.moveTo(l_part1, lYPos);
|
|
context.lineTo(r_part1, lYPos);
|
|
context.stroke();
|
|
}
|
|
else if (2 == index)
|
|
{
|
|
// 1/2
|
|
context.beginPath();
|
|
context.moveTo(l_part2, lYPos);
|
|
context.lineTo(r_part2, lYPos);
|
|
context.stroke();
|
|
}
|
|
else if (isDraw1_4)
|
|
{
|
|
// 1/4
|
|
context.beginPath();
|
|
context.moveTo(l_part1, lYPos);
|
|
context.lineTo(r_part1, lYPos);
|
|
context.stroke();
|
|
}
|
|
}
|
|
|
|
index = 0;
|
|
num = 0;
|
|
for (var i = 1; i <= lCount2; i++)
|
|
{
|
|
var lYPos = ((top_margin - i * mm_1_4) >> 0) + indent;
|
|
index++;
|
|
|
|
if (index == 4)
|
|
index = 0;
|
|
|
|
if (0 == index)
|
|
{
|
|
num++;
|
|
// number
|
|
var strNum = "" + num;
|
|
var lWidthText = context.measureText(strNum).width;
|
|
|
|
context.translate(middleHor, lYPos);
|
|
context.rotate(-Math.PI / 2);
|
|
context.fillText(strNum, -lWidthText / 2.0, Math.round(4 * dPR));
|
|
context.setTransform(1, 0, 0, 1, 0, Math.round(5 * dPR));
|
|
}
|
|
else if (1 == index && isDraw1_4)
|
|
{
|
|
// 1/4
|
|
context.beginPath();
|
|
context.moveTo(l_part1, lYPos);
|
|
context.lineTo(r_part1, lYPos);
|
|
context.stroke();
|
|
}
|
|
else if (2 == index)
|
|
{
|
|
// 1/2
|
|
context.beginPath();
|
|
context.moveTo(l_part2, lYPos);
|
|
context.lineTo(r_part2, lYPos);
|
|
context.stroke();
|
|
}
|
|
else if (isDraw1_4)
|
|
{
|
|
// 1/4
|
|
context.beginPath();
|
|
context.moveTo(l_part1, lYPos);
|
|
context.lineTo(r_part1, lYPos);
|
|
context.stroke();
|
|
}
|
|
}
|
|
}
|
|
else if (this.Units == c_oAscDocumentUnits.Inch)
|
|
{
|
|
var lCount1 = ((height - top_margin) / inch_1_8) >> 0;
|
|
var lCount2 = (top_margin / inch_1_8) >> 0;
|
|
|
|
var index = 0;
|
|
var num = 0;
|
|
for (var i = 1; i < lCount1; i++)
|
|
{
|
|
var lYPos = ((top_margin + i * inch_1_8) >> 0) + indent;
|
|
index++;
|
|
|
|
if (index == 8)
|
|
index = 0;
|
|
|
|
if (0 == index)
|
|
{
|
|
num++;
|
|
// number
|
|
|
|
var strNum = "" + num;
|
|
var lWidthText = context.measureText(strNum).width;
|
|
|
|
context.translate(middleHor, lYPos);
|
|
context.rotate(-Math.PI / 2);
|
|
context.fillText(strNum, -lWidthText / 2.0, Math.round(4 * dPR));
|
|
context.setTransform(1, 0, 0, 1, 0, Math.round(5 * dPR));
|
|
}
|
|
else if (4 == index)
|
|
{
|
|
// 1/2
|
|
context.beginPath();
|
|
context.moveTo(l_part2, lYPos);
|
|
context.lineTo(r_part2, lYPos);
|
|
context.stroke();
|
|
}
|
|
else if (inch_1_8 > 8)
|
|
{
|
|
// 1/8
|
|
context.beginPath();
|
|
context.moveTo(l_part1, lYPos);
|
|
context.lineTo(r_part1, lYPos);
|
|
context.stroke();
|
|
}
|
|
}
|
|
|
|
index = 0;
|
|
num = 0;
|
|
for (var i = 1; i <= lCount2; i++)
|
|
{
|
|
var lYPos = ((top_margin - i * inch_1_8) >> 0) + indent;
|
|
index++;
|
|
|
|
if (index == 8)
|
|
index = 0;
|
|
|
|
if (0 == index)
|
|
{
|
|
num++;
|
|
// number
|
|
var strNum = "" + num;
|
|
var lWidthText = context.measureText(strNum).width;
|
|
|
|
context.translate(middleHor, lYPos);
|
|
context.rotate(-Math.PI / 2);
|
|
context.fillText(strNum, -lWidthText / 2.0, Math.round(4 * dPR));
|
|
context.setTransform(1, 0, 0, 1, 0, Math.round(5 * dPR));
|
|
|
|
}
|
|
else if (4 == index)
|
|
{
|
|
// 1/2
|
|
context.beginPath();
|
|
context.moveTo(middleHor - part2, lYPos);
|
|
context.lineTo(middleHor + part2, lYPos);
|
|
context.stroke();
|
|
}
|
|
else if (inch_1_8 > 8)
|
|
{
|
|
// 1/8
|
|
context.beginPath();
|
|
context.moveTo(middleHor - part1, lYPos);
|
|
context.lineTo(middleHor + part1, lYPos);
|
|
context.stroke();
|
|
}
|
|
}
|
|
}
|
|
else if (this.Units == c_oAscDocumentUnits.Point)
|
|
{
|
|
var point_1_12 = 25.4 * dKoef_mm_to_pix / 12;
|
|
|
|
var lCount1 = ((height - top_margin) / point_1_12) >> 0;
|
|
var lCount2 = (top_margin / point_1_12) >> 0;
|
|
|
|
var index = 0;
|
|
var num = 0;
|
|
for (var i = 1; i < lCount1; i++)
|
|
{
|
|
var lYPos = ((top_margin + i * point_1_12) >> 0) + indent;
|
|
index++;
|
|
|
|
if (index == 12)
|
|
index = 0;
|
|
|
|
if (0 == index || 6 == index)
|
|
{
|
|
num++;
|
|
// number
|
|
|
|
var strNum = "" + (num * 36);
|
|
var lWidthText = context.measureText(strNum).width;
|
|
|
|
context.translate(middleHor, lYPos);
|
|
context.rotate(-Math.PI / 2);
|
|
context.fillText(strNum, -lWidthText / 2.0, Math.round(4 * dPR));
|
|
context.setTransform(1, 0, 0, 1, 0, Math.round(5 * dPR));
|
|
}
|
|
else if (point_1_12 > 5)
|
|
{
|
|
// 1/8
|
|
context.beginPath();
|
|
context.moveTo(l_part1, lYPos);
|
|
context.lineTo(r_part1, lYPos);
|
|
context.stroke();
|
|
}
|
|
}
|
|
|
|
index = 0;
|
|
num = 0;
|
|
for (var i = 1; i <= lCount2; i++)
|
|
{
|
|
var lYPos = ((top_margin - i * point_1_12) >> 0) + indent;
|
|
index++;
|
|
|
|
if (index == 12)
|
|
index = 0;
|
|
|
|
if (0 == index || 6 == index)
|
|
{
|
|
num++;
|
|
// number
|
|
var strNum = "" + (num * 36);
|
|
var lWidthText = context.measureText(strNum).width;
|
|
|
|
context.translate(middleHor, lYPos);
|
|
context.rotate(-Math.PI / 2);
|
|
context.fillText(strNum, -lWidthText / 2.0, Math.round(4 * dPR));
|
|
context.setTransform(1, 0, 0, 1, 0, Math.round(5 * dPR));
|
|
}
|
|
else if (point_1_12 > 5)
|
|
{
|
|
// 1/8
|
|
context.beginPath();
|
|
context.moveTo(l_part1, lYPos);
|
|
context.lineTo(r_part1, lYPos);
|
|
context.stroke();
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((this.CurrentObjectType == RULER_OBJECT_TYPE_TABLE) && (null != markup))
|
|
{
|
|
var dPR = AscCommon.AscBrowser.retinaPixelRatio;
|
|
var dKoef_mm_to_pix = g_dKoef_mm_to_pix * this.m_dZoom * dPR;
|
|
|
|
// не будет нулевых таблиц.
|
|
var _count = markup.Rows.length;
|
|
|
|
if (0 == _count)
|
|
return;
|
|
|
|
var start_dark = (((markup.Rows[0].Y + markup.Rows[0].H) * dKoef_mm_to_pix) >> 0) + indent;
|
|
var end_dark = 0;
|
|
|
|
context.fillStyle = GlobalSkin.RulerDark;
|
|
context.strokeStyle = GlobalSkin.RulerOutline;
|
|
|
|
var _x = this.m_nLeft + indent;
|
|
var _w = this.m_nRight - this.m_nLeft;
|
|
for (var i = 1; i < _count; i++)
|
|
{
|
|
end_dark = ((markup.Rows[i].Y * dKoef_mm_to_pix) >> 0) + indent;
|
|
context.fillRect(_x, start_dark, _w, Math.max(end_dark - start_dark, Math.round(7 * dPR)));
|
|
context.strokeRect(_x, start_dark, _w, Math.max(end_dark - start_dark, Math.round(7 * dPR)));
|
|
|
|
start_dark = (((markup.Rows[i].Y + markup.Rows[i].H) * dKoef_mm_to_pix) >> 0) + indent;
|
|
}
|
|
}
|
|
|
|
// рамка
|
|
context.beginPath();
|
|
context.strokeStyle = GlobalSkin.RulerOutline;
|
|
context.strokeRect(this.m_nLeft + indent, indent, this.m_nRight - this.m_nLeft, Math.max(intH - 1, 1));
|
|
context.beginPath();
|
|
context.moveTo(this.m_nLeft + indent, top_margin + indent);
|
|
context.lineTo(this.m_nRight - indent, top_margin + indent);
|
|
|
|
context.moveTo(this.m_nLeft + indent, bottom_margin + indent);
|
|
context.lineTo(this.m_nRight - indent, bottom_margin + indent);
|
|
context.stroke();
|
|
}
|
|
|
|
this.OnMouseMove = function(left, top, e)
|
|
{
|
|
var word_control = this.m_oWordControl;
|
|
AscCommon.check_MouseMoveEvent(e);
|
|
|
|
this.SimpleChanges.CheckMove();
|
|
var ver_ruler = word_control.m_oLeftRuler_vertRuler;
|
|
var dKoefPxToMM = 100 * g_dKoef_pix_to_mm / word_control.m_nZoomValue;
|
|
|
|
// теперь определяем позицию относительно самой линейки. Все в миллиметрах
|
|
var _y = global_mouseEvent.Y - 7 * g_dKoef_mm_to_pix - top - word_control.Y;
|
|
_y *= dKoefPxToMM;
|
|
var _x = left * g_dKoef_pix_to_mm;
|
|
|
|
var dKoef_mm_to_pix = g_dKoef_mm_to_pix * this.m_dZoom;
|
|
var mm_1_4 = 10 / 4;
|
|
var mm_1_8 = mm_1_4 / 2;
|
|
|
|
switch (this.DragType)
|
|
{
|
|
case 0:
|
|
{
|
|
if (this.CurrentObjectType == RULER_OBJECT_TYPE_PARAGRAPH)
|
|
{
|
|
if (this.IsCanMoveMargins && ((Math.abs(_y - this.m_dMarginTop) < 1) || (Math.abs(_y - this.m_dMarginBottom) < 1)))
|
|
word_control.m_oDrawingDocument.SetCursorType("s-resize");
|
|
else
|
|
word_control.m_oDrawingDocument.SetCursorType("default");
|
|
}
|
|
else if (this.CurrentObjectType == RULER_OBJECT_TYPE_HEADER)
|
|
{
|
|
if ((Math.abs(_y - this.header_top) < 1) || (Math.abs(_y - this.header_bottom) < 1))
|
|
word_control.m_oDrawingDocument.SetCursorType("s-resize");
|
|
else
|
|
word_control.m_oDrawingDocument.SetCursorType("default");
|
|
}
|
|
else if (this.CurrentObjectType == RULER_OBJECT_TYPE_FOOTER)
|
|
{
|
|
if (Math.abs(_y - this.header_top) < 1)
|
|
word_control.m_oDrawingDocument.SetCursorType("s-resize");
|
|
else
|
|
word_control.m_oDrawingDocument.SetCursorType("default");
|
|
}
|
|
else if (this.CurrentObjectType == RULER_OBJECT_TYPE_TABLE)
|
|
{
|
|
var type = this.CheckMouseType(2, _y);
|
|
if (type == 5)
|
|
word_control.m_oDrawingDocument.SetCursorType("s-resize");
|
|
else
|
|
word_control.m_oDrawingDocument.SetCursorType("default");
|
|
}
|
|
|
|
break;
|
|
}
|
|
case 1:
|
|
{
|
|
var newVal = RulerCorrectPosition(this, _y, this.m_dMarginTop);
|
|
|
|
if (newVal > (this.m_dMarginBottom - 30))
|
|
newVal = this.m_dMarginBottom - 30;
|
|
if (newVal < 0)
|
|
newVal = 0;
|
|
|
|
this.m_dMarginTop = newVal;
|
|
word_control.UpdateVerRulerBack();
|
|
|
|
var pos = top + this.m_dMarginTop * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.HorLine(pos);
|
|
|
|
word_control.m_oDrawingDocument.SetCursorType("s-resize");
|
|
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
var newVal = RulerCorrectPosition(this, _y, this.m_dMarginTop);
|
|
|
|
if (newVal < (this.m_dMarginTop + 30))
|
|
newVal = this.m_dMarginTop + 30;
|
|
if (newVal > this.m_oPage.height_mm)
|
|
newVal = this.m_oPage.height_mm;
|
|
|
|
this.m_dMarginBottom = newVal;
|
|
word_control.UpdateVerRulerBack();
|
|
|
|
var pos = top + this.m_dMarginBottom * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.HorLine(pos);
|
|
|
|
word_control.m_oDrawingDocument.SetCursorType("s-resize");
|
|
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
var newVal = RulerCorrectPosition(this, _y, this.m_dMarginTop);
|
|
|
|
if (newVal > this.header_bottom)
|
|
newVal = this.header_bottom;
|
|
if (newVal < 0)
|
|
newVal = 0;
|
|
|
|
this.header_top = newVal;
|
|
word_control.UpdateVerRulerBack();
|
|
|
|
var pos = top + this.header_top * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.HorLine(pos);
|
|
|
|
word_control.m_oDrawingDocument.SetCursorType("s-resize");
|
|
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
var newVal = RulerCorrectPosition(this, _y, this.m_dMarginTop);
|
|
|
|
if (newVal < 0)
|
|
newVal = 0;
|
|
if (newVal > this.m_oPage.height_mm)
|
|
newVal = this.m_oPage.height_mm;
|
|
|
|
this.header_bottom = newVal;
|
|
word_control.UpdateVerRulerBack();
|
|
|
|
var pos = top + this.header_bottom * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.HorLine(pos);
|
|
|
|
word_control.m_oDrawingDocument.SetCursorType("s-resize");
|
|
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
// сначала нужно определить минимум и максимум сдвига
|
|
var _min = 0;
|
|
var _max = this.m_oPage.height_mm;
|
|
|
|
if (0 < this.DragTablePos)
|
|
{
|
|
_min = this.m_oTableMarkup.Rows[this.DragTablePos - 1].Y;
|
|
}
|
|
if (this.DragTablePos < this.m_oTableMarkup.Rows.length)
|
|
{
|
|
_max = this.m_oTableMarkup.Rows[this.DragTablePos].Y + this.m_oTableMarkup.Rows[this.DragTablePos].H;
|
|
}
|
|
|
|
var newVal = RulerCorrectPosition(this, _y, this.m_dMarginTop);
|
|
|
|
if (newVal < _min)
|
|
newVal = _min;
|
|
if (newVal > _max)
|
|
newVal = _max;
|
|
|
|
if (0 == this.DragTablePos)
|
|
{
|
|
var _bottom = this.m_oTableMarkup.Rows[0].Y + this.m_oTableMarkup.Rows[0].H;
|
|
this.m_oTableMarkup.Rows[0].Y = newVal;
|
|
this.m_oTableMarkup.Rows[0].H = _bottom - newVal;
|
|
}
|
|
else
|
|
{
|
|
var oldH = this.m_oTableMarkup.Rows[this.DragTablePos - 1].H;
|
|
this.m_oTableMarkup.Rows[this.DragTablePos - 1].H = newVal - this.m_oTableMarkup.Rows[this.DragTablePos - 1].Y;
|
|
|
|
var delta = this.m_oTableMarkup.Rows[this.DragTablePos - 1].H - oldH;
|
|
for (var i = this.DragTablePos; i < this.m_oTableMarkup.Rows.length; i++)
|
|
{
|
|
this.m_oTableMarkup.Rows[i].Y += delta;
|
|
}
|
|
}
|
|
|
|
word_control.UpdateVerRulerBack();
|
|
|
|
var pos = top + newVal * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.HorLine(pos);
|
|
|
|
word_control.m_oDrawingDocument.SetCursorType("s-resize");
|
|
}
|
|
}
|
|
}
|
|
|
|
this.CheckMouseType = function(x, y)
|
|
{
|
|
// проверяем где находимся
|
|
|
|
if (this.IsCanMoveMargins === false)
|
|
return 0;
|
|
|
|
if (x >= 0.8 && x <= 4.2)
|
|
{
|
|
// внутри линейки
|
|
if (this.CurrentObjectType == RULER_OBJECT_TYPE_PARAGRAPH)
|
|
{
|
|
if (Math.abs(y - this.m_dMarginTop) < 1)
|
|
{
|
|
return 1;
|
|
}
|
|
else if (Math.abs(y - this.m_dMarginBottom) < 1)
|
|
{
|
|
return 2;
|
|
}
|
|
}
|
|
else if (this.CurrentObjectType == RULER_OBJECT_TYPE_HEADER)
|
|
{
|
|
if (Math.abs(y - this.header_top) < 1)
|
|
{
|
|
return 3;
|
|
}
|
|
else if (Math.abs(y - this.header_bottom) < 1)
|
|
{
|
|
return 4;
|
|
}
|
|
}
|
|
else if (this.CurrentObjectType == RULER_OBJECT_TYPE_FOOTER)
|
|
{
|
|
if (Math.abs(y - this.header_top) < 1)
|
|
{
|
|
return 3;
|
|
}
|
|
}
|
|
else if (this.CurrentObjectType == RULER_OBJECT_TYPE_TABLE && null != this.m_oTableMarkup)
|
|
{
|
|
// не будет нулевых таблиц.
|
|
var markup = this.m_oTableMarkup;
|
|
var _count = markup.Rows.length;
|
|
|
|
if (0 == _count)
|
|
return 0;
|
|
|
|
var _start = markup.Rows[0].Y;
|
|
var _end = _start - 2;
|
|
|
|
for (var i = 0; i <= _count; i++)
|
|
{
|
|
if (i == _count)
|
|
{
|
|
_end = markup.Rows[i - 1].Y + markup.Rows[i - 1].H;
|
|
_start = _end + 2;
|
|
}
|
|
else if (i != 0)
|
|
{
|
|
_end = markup.Rows[i - 1].Y + markup.Rows[i - 1].H;
|
|
_start = markup.Rows[i].Y;
|
|
}
|
|
|
|
if ((_end - 1) < y && y < (_start + 1))
|
|
{
|
|
this.DragTablePos = i;
|
|
return 5;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
this.OnMouseDown = function(left, top, e)
|
|
{
|
|
var word_control = this.m_oWordControl;
|
|
|
|
if (true === word_control.m_oApi.isStartAddShape)
|
|
{
|
|
word_control.m_oApi.sync_EndAddShape();
|
|
word_control.m_oApi.sync_StartAddShapeCallback(false);
|
|
}
|
|
if (true === word_control.m_oApi.isInkDrawerOn())
|
|
{
|
|
word_control.m_oApi.stopInkDrawer();
|
|
}
|
|
|
|
AscCommon.check_MouseDownEvent(e, true);
|
|
|
|
this.SimpleChanges.Reinit();
|
|
global_mouseEvent.LockMouse();
|
|
|
|
var dKoefPxToMM = 100 * g_dKoef_pix_to_mm / word_control.m_nZoomValue;
|
|
var dKoef_mm_to_pix = g_dKoef_mm_to_pix * this.m_dZoom;
|
|
|
|
var _y = global_mouseEvent.Y - 7 * g_dKoef_mm_to_pix - top - word_control.Y;
|
|
_y *= dKoefPxToMM;
|
|
var _x = (global_mouseEvent.X - word_control.X) * g_dKoef_pix_to_mm - word_control.GetMainContentBounds().L - word_control.GetVertRulerLeft();
|
|
|
|
this.DragType = this.CheckMouseType(_x, _y);
|
|
this.DragTypeMouseDown = this.DragType;
|
|
|
|
if (global_mouseEvent.ClickCount > 1)
|
|
{
|
|
var eventType = "";
|
|
switch (this.DragTypeMouseDown)
|
|
{
|
|
case 5:
|
|
eventType = "tables";
|
|
break;
|
|
default:
|
|
eventType = "margins";
|
|
break;
|
|
}
|
|
|
|
if (eventType != "")
|
|
{
|
|
word_control.m_oApi.sendEvent("asc_onRulerDblClick", eventType);
|
|
this.DragType = 0;
|
|
this.OnMouseUp(left, top, e);
|
|
return;
|
|
}
|
|
}
|
|
|
|
switch (this.DragType)
|
|
{
|
|
case 1:
|
|
{
|
|
var pos = top + this.m_dMarginTop * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.HorLine(pos);
|
|
break;
|
|
}
|
|
case 2:
|
|
{
|
|
var pos = top + this.m_dMarginBottom * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.HorLine(pos);
|
|
break;
|
|
}
|
|
case 3:
|
|
{
|
|
var pos = top + this.header_top * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.HorLine(pos);
|
|
break;
|
|
}
|
|
case 4:
|
|
{
|
|
var pos = top + this.header_bottom * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.HorLine(pos);
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
var pos = 0;
|
|
if (0 == this.DragTablePos)
|
|
{
|
|
pos = top + this.m_oTableMarkup.Rows[0].Y * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.HorLine(pos);
|
|
}
|
|
else
|
|
{
|
|
pos = top + (this.m_oTableMarkup.Rows[this.DragTablePos - 1].Y + this.m_oTableMarkup.Rows[this.DragTablePos - 1].H) * dKoef_mm_to_pix;
|
|
word_control.m_oOverlayApi.HorLine(pos);
|
|
}
|
|
}
|
|
}
|
|
|
|
word_control.m_oDrawingDocument.LockCursorTypeCur();
|
|
}
|
|
|
|
this.OnMouseUp = function(left, top, e)
|
|
{
|
|
var lockedElement = AscCommon.check_MouseUpEvent(e);
|
|
|
|
//this.m_oWordControl.m_oOverlayApi.UnShow();
|
|
this.m_oWordControl.OnUpdateOverlay();
|
|
|
|
switch (this.DragType)
|
|
{
|
|
case 1:
|
|
case 2:
|
|
{
|
|
if (!this.SimpleChanges.IsSimple)
|
|
this.SetMarginProperties();
|
|
break;
|
|
}
|
|
case 3:
|
|
case 4:
|
|
{
|
|
if (!this.SimpleChanges.IsSimple)
|
|
this.SetHeaderProperties();
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
if (!this.SimpleChanges.IsSimple)
|
|
this.SetTableProperties();
|
|
this.DragTablePos = -1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
this.DragType = 0;
|
|
this.m_oWordControl.m_oDrawingDocument.UnlockCursorType();
|
|
|
|
this.SimpleChanges.Clear();
|
|
}
|
|
|
|
this.OnMouseUpExternal = function()
|
|
{
|
|
//this.m_oWordControl.m_oOverlayApi.UnShow();
|
|
this.m_oWordControl.OnUpdateOverlay();
|
|
|
|
switch (this.DragType)
|
|
{
|
|
case 1:
|
|
case 2:
|
|
{
|
|
if (!this.SimpleChanges.IsSimple)
|
|
this.SetMarginProperties();
|
|
break;
|
|
}
|
|
case 3:
|
|
case 4:
|
|
{
|
|
if (!this.SimpleChanges.IsSimple)
|
|
this.SetHeaderProperties();
|
|
break;
|
|
}
|
|
case 5:
|
|
{
|
|
if (!this.SimpleChanges.IsSimple)
|
|
this.SetTableProperties();
|
|
this.DragTablePos = -1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
this.DragType = 0;
|
|
this.m_oWordControl.m_oDrawingDocument.UnlockCursorType();
|
|
|
|
this.SimpleChanges.Clear();
|
|
}
|
|
|
|
this.BlitToMain = function(left, top, htmlElement)
|
|
{
|
|
if (!this.RepaintChecker.BlitAttack && top == this.RepaintChecker.BlitTop)
|
|
return;
|
|
var dPR = AscCommon.AscBrowser.retinaPixelRatio;
|
|
top = Math.round(top * dPR);
|
|
this.RepaintChecker.BlitTop = top;
|
|
this.RepaintChecker.BlitAttack = false;
|
|
|
|
htmlElement.width = htmlElement.width;
|
|
var context = htmlElement.getContext('2d');
|
|
|
|
if (null != this.m_oCanvas)
|
|
{
|
|
context.drawImage(this.m_oCanvas, 0, Math.round(5 * dPR), this.m_oCanvas.width, this.m_oCanvas.height - Math.round(10 * dPR),
|
|
0, top, this.m_oCanvas.width, this.m_oCanvas.height - Math.round(10 * dPR));
|
|
}
|
|
}
|
|
|
|
// выставление параметров логическому документу
|
|
this.SetMarginProperties = function()
|
|
{
|
|
if ( false === this.m_oWordControl.m_oLogicDocument.Document_Is_SelectionLocked(AscCommon.changestype_Document_SectPr) )
|
|
{
|
|
this.m_oWordControl.m_oLogicDocument.StartAction(AscDFH.historydescription_Document_SetDocumentMargin_Ver);
|
|
this.m_oWordControl.m_oLogicDocument.SetDocumentMargin( { Top : this.m_dMarginTop, Bottom : this.m_dMarginBottom }, true);
|
|
this.m_oWordControl.m_oLogicDocument.FinalizeAction();
|
|
}
|
|
}
|
|
this.SetHeaderProperties = function()
|
|
{
|
|
if ( false === this.m_oWordControl.m_oLogicDocument.Document_Is_SelectionLocked(AscCommon.changestype_HdrFtr) )
|
|
{
|
|
// TODO: в данной функции при определенных параметрах может меняться верхнее поле. Поэтому, надо
|
|
// вставить проверку на залоченность с типом changestype_Document_SectPr
|
|
|
|
this.m_oWordControl.m_oLogicDocument.StartAction(AscDFH.historydescription_Document_SetHdrFtrBounds);
|
|
this.m_oWordControl.m_oLogicDocument.Document_SetHdrFtrBounds(this.header_top, this.header_bottom);
|
|
this.m_oWordControl.m_oLogicDocument.FinalizeAction();
|
|
}
|
|
}
|
|
this.SetTableProperties = function()
|
|
{
|
|
if ( false === this.m_oWordControl.m_oLogicDocument.Document_Is_SelectionLocked(AscCommon.changestype_Table_Properties) )
|
|
{
|
|
this.m_oWordControl.m_oLogicDocument.StartAction(AscDFH.historydescription_Document_SetTableMarkup_Ver);
|
|
|
|
this.m_oTableMarkup.CorrectTo();
|
|
this.m_oTableMarkup.Table.Update_TableMarkupFromRuler(this.m_oTableMarkup, false, this.DragTablePos);
|
|
if (this.m_oTableMarkup)
|
|
this.m_oTableMarkup.CorrectFrom();
|
|
|
|
this.m_oWordControl.m_oLogicDocument.FinalizeAction();
|
|
}
|
|
}
|
|
}
|