600 lines
27 KiB
JavaScript
600 lines
27 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
|
|
*
|
|
*/
|
|
/**
|
|
* CustomColumnsDialog.js
|
|
*
|
|
* Created on 6/23/17
|
|
*
|
|
*/
|
|
|
|
define([], function () { 'use strict';
|
|
|
|
DE.Views.CustomColumnsDialog = Common.UI.Window.extend(_.extend({
|
|
options: {
|
|
width: 300,
|
|
header: true,
|
|
style: 'min-width: 216px;',
|
|
cls: 'modal-dlg',
|
|
id: 'window-custom-columns',
|
|
buttons: ['ok', 'cancel']
|
|
},
|
|
|
|
initialize : function(options) {
|
|
_.extend(this.options, {
|
|
title: this.textTitle
|
|
}, options || {});
|
|
|
|
this.template = [
|
|
'<div class="box">',
|
|
'<div class="input-row" style="margin-bottom: 10px;">',
|
|
'<label class="input-label">' + this.textColumns + '</label><div id="custom-columns-spin-num" class="float-right"></div>',
|
|
'</div>',
|
|
'<div id="custom-columns-list" style="width:100%; height: 122px;"></div>',
|
|
'<div class="input-row" style="margin: 10px 0;">',
|
|
'<div id="custom-columns-equal-width"></div>',
|
|
'</div>',
|
|
'<div class="input-row">',
|
|
'<div id="custom-columns-separator"></div>',
|
|
'</div>',
|
|
'</div>',
|
|
].join('');
|
|
|
|
this.options.tpl = _.template(this.template)(this.options);
|
|
|
|
this.totalWidth = 558.7;
|
|
this.minWidthCol = 10; //Minimum column width in mm
|
|
this.defaultSpacing = 12.5; //Default spacing for 2 columns in mm
|
|
this._noApply = false;
|
|
|
|
Common.UI.Window.prototype.initialize.call(this, this.options);
|
|
},
|
|
|
|
render: function() {
|
|
Common.UI.Window.prototype.render.call(this);
|
|
|
|
var me = this;
|
|
this.spnColumns = new Common.UI.MetricSpinner({
|
|
el: $('#custom-columns-spin-num'),
|
|
step: 1,
|
|
allowDecimal: false,
|
|
width: 45,
|
|
defaultUnit : "",
|
|
value: 1,
|
|
maxValue: 30,
|
|
minValue: 1,
|
|
maskExp: /[0-9]/
|
|
});
|
|
this.spnColumns.on('change', function(field, newValue, oldValue, eOpts){
|
|
var num = parseInt(newValue),
|
|
storeLength = me.columnsList.store.length,
|
|
isIncrease = (num > storeLength),
|
|
isEqualWidth = me.chEqualWidth.getValue() == 'checked',
|
|
arrColumnObj = [];
|
|
|
|
if(storeLength == 0 || num == storeLength) return;
|
|
|
|
if(isEqualWidth){
|
|
var spacing = (storeLength == 1) ? me.defaultSpacing : me.columnsList.store.at(0).get('spacing'),
|
|
columnWidth = (me.totalWidth - spacing * (num - 1)) / num;
|
|
|
|
if(columnWidth < me.minWidthCol) {
|
|
columnWidth = me.minWidthCol;
|
|
spacing = (me.totalWidth - columnWidth * num) / (num - 1);
|
|
}
|
|
for(var i = 0; i < num; i++) {
|
|
arrColumnObj.push({
|
|
width: columnWidth,
|
|
spacing: spacing,
|
|
});
|
|
}
|
|
}
|
|
else {
|
|
var allSpacing = 0,
|
|
koef = (me.columnsList.store.at(storeLength - 1).get('width') + (storeLength > 1 ? me.columnsList.store.at(storeLength - 2).get('spacing') : 0)) / me.totalWidth,
|
|
widthKoefArr = [1];
|
|
|
|
for(var i = 0, previosSpacing = me.defaultSpacing; i < num; i++){
|
|
var columnSpacing = 0;
|
|
|
|
//Calculation spacing
|
|
//y = curSpacing / (koef*x + 1 - curNum*koef) y <-- spacing when 'x' columns
|
|
// x <-- num columns
|
|
// curSpacing <-- current spacing for column
|
|
// curNum <-- cur columns
|
|
// koef <-- (lastWidth + lastSpacing) / totalWidth
|
|
if(i < num -1) {
|
|
if(i < storeLength - 1){
|
|
var curSpacing = (storeLength > 1) ? me.columnsList.store.at(i).get('spacing') : me.defaultSpacing;
|
|
columnSpacing = curSpacing / (koef*num + 1 - storeLength*koef);
|
|
}
|
|
else {
|
|
columnSpacing = previosSpacing;
|
|
}
|
|
|
|
previosSpacing = columnSpacing;
|
|
}
|
|
|
|
if(i < storeLength)
|
|
widthKoefArr[i] = me.columnsList.store.at(i).get('width') / me.columnsList.store.at(0).get('width');
|
|
else
|
|
widthKoefArr[i] = widthKoefArr[storeLength - 1];
|
|
|
|
arrColumnObj.push({spacing: columnSpacing});
|
|
allSpacing += columnSpacing;
|
|
}
|
|
|
|
var totalWidthWithoutSpacing = me.totalWidth - allSpacing,
|
|
widthFirstColumn = totalWidthWithoutSpacing / widthKoefArr.reduce(function(a, b) { return a + b; });
|
|
|
|
for(var i = 0; i < num; i++) {
|
|
arrColumnObj[i].width = widthFirstColumn * widthKoefArr[i];
|
|
}
|
|
}
|
|
me.updateColumnsList(arrColumnObj);
|
|
me.setMaxValueSpinsForColumns();
|
|
if(!isIncrease && !isEqualWidth)
|
|
me.setMaxColumns();
|
|
|
|
me.chEqualWidth.setDisabled(num<2);
|
|
me.chSeparator.setDisabled(num<2);
|
|
});
|
|
|
|
this.columnsList = new Common.UI.ListView({
|
|
el: $('#custom-columns-list', this.$window),
|
|
store: new Common.UI.DataViewStore(),
|
|
showLast: false,
|
|
handleSelect: false,
|
|
tabindex: 0,
|
|
template: _.template(['<div class="listview inner" style=""></div>'].join('')),
|
|
headers: [
|
|
{name: '#', width:26},
|
|
{name: this.textWidth, width:115},
|
|
{name: this.textTitleSpacing, width:113},
|
|
],
|
|
itemTemplate: _.template([
|
|
'<div id="custom-columns-list-item-<%= index %>" class="list-item" style="display:flex; align-items:center; width=100%;">',
|
|
'<label class="level-caption padding-right-5" style="flex-shrink:0; width:20px;"><%= index + 1 %></label>',
|
|
'<div style="display:inline-block;flex-grow: 1;">',
|
|
'<div style="padding: 0 5px;display: inline-block;vertical-align: top;"><div id="custom-columns-list-item-spin-width-<%= index %>" class="input-group-nr" style=""></div></div>',
|
|
'<div style="padding: 0 5px;display: inline-block;vertical-align: top;"><div id="custom-columns-list-item-spin-spacing-<%= index %>" class="input-group-nr"></div></div>',
|
|
'</div>',
|
|
'</div>'
|
|
].join(''))
|
|
});
|
|
|
|
this.columnsList.on('item:add', _.bind(this.addControls, this));
|
|
|
|
this.chEqualWidth = new Common.UI.CheckBox({
|
|
el: $('#custom-columns-equal-width'),
|
|
labelText: this.textEqualWidth
|
|
}).on('change', function(item, newValue, oldValue) {
|
|
me.lockSpinsForEqualColumns(newValue == 'checked');
|
|
if(newValue == 'checked') {
|
|
me.setEqualWidthColumns();
|
|
}
|
|
if(me.columnsList.store.length > 0){
|
|
me.setMaxColumns();
|
|
me.setMaxValueSpinsForColumns();
|
|
}
|
|
});
|
|
|
|
this.chSeparator = new Common.UI.CheckBox({
|
|
el: $('#custom-columns-separator'),
|
|
labelText: this.textSeparator
|
|
});
|
|
|
|
this.getChild().find('.dlg-btn').on('click', _.bind(this.onBtnClick, this));
|
|
},
|
|
|
|
getFocusedComponents: function() {
|
|
return [this.spnColumns, this.chEqualWidth, this.chSeparator].concat(this.getFooterButtons());
|
|
},
|
|
|
|
getDefaultFocusableComponent: function () {
|
|
return this.spnColumns;
|
|
},
|
|
|
|
_handleInput: function(state) {
|
|
if (this.options.handler) {
|
|
this.options.handler.call(this, this, state);
|
|
}
|
|
|
|
this.close();
|
|
},
|
|
|
|
onBtnClick: function(event) {
|
|
this._handleInput(event.currentTarget.attributes['result'].value);
|
|
},
|
|
|
|
onPrimary: function() {
|
|
this._handleInput('ok');
|
|
return false;
|
|
},
|
|
|
|
setSettings: function (props) {
|
|
if (props) {
|
|
var equal = props.get_EqualWidth(),
|
|
num = (equal) ? props.get_Num() : props.get_ColsCount(),
|
|
total = props.get_TotalWidth(),
|
|
arrColumnObj = [];
|
|
|
|
this.totalWidth = total;
|
|
this.spnColumns.setValue(num, true);
|
|
|
|
var calcWidthForEqual = (equal && num > 1) ? this.calcWidthForEqualColumns(num, props.get_Space()) : total;
|
|
|
|
for(var i = 0; i < num; i++) {
|
|
if(!equal && num > 1) {
|
|
var currentCol = props.get_Col(i);
|
|
arrColumnObj.push({
|
|
width: currentCol.get_W(),
|
|
spacing: currentCol.get_Space(),
|
|
});
|
|
|
|
if(currentCol.get_W() < this.minWidthCol)
|
|
this.minWidthCol = currentCol.get_W();
|
|
}
|
|
else {
|
|
arrColumnObj.push({
|
|
width: calcWidthForEqual,
|
|
spacing: props.get_Space(),
|
|
});
|
|
}
|
|
}
|
|
|
|
this.chEqualWidth.setValue(equal, true);
|
|
this.chEqualWidth.setDisabled(num<2);
|
|
this.chSeparator.setValue(props.get_Sep());
|
|
this.chSeparator.setDisabled(num<2);
|
|
|
|
this.updateColumnsList(arrColumnObj);
|
|
|
|
this.setMaxColumns();
|
|
this.setMaxValueSpinsForColumns();
|
|
}
|
|
},
|
|
|
|
getSettings: function() {
|
|
var props = new Asc.CDocumentColumnsProps();
|
|
|
|
props.put_Num(this.spnColumns.getNumberValue());
|
|
props.put_Space(this.columnsList.store.at(0).get('spacing'));
|
|
props.put_EqualWidth(this.chEqualWidth.getValue()=='checked');
|
|
props.put_Sep(this.chSeparator.getValue()=='checked');
|
|
|
|
if(this.chEqualWidth.getValue() != 'checked') {
|
|
this.columnsList.store.each(function(col, index) {
|
|
props.put_ColByValue(index, col.get('width'), col.get('spacing'));
|
|
});
|
|
}
|
|
return props;
|
|
},
|
|
|
|
updateColumnsList: function(arrColumnObj) {
|
|
var me = this,
|
|
arrItems = arrColumnObj.map(function(item, itemIndex) {
|
|
return {
|
|
index: itemIndex,
|
|
allowSelected: false,
|
|
width: item.width,
|
|
spacing: (itemIndex != arrColumnObj.length - 1 ? item.spacing : 0),
|
|
widthSpin: null,
|
|
spacingSpin: null,
|
|
};
|
|
});
|
|
|
|
this.columnsList.store.reset(arrItems);
|
|
},
|
|
|
|
setMaxColumns: function() {
|
|
var maxPossibleColumns = Math.floor(this.totalWidth / this.minWidthCol);
|
|
|
|
if(this.chEqualWidth.getValue() == 'checked') {
|
|
this.spnColumns.setMaxValue(maxPossibleColumns);
|
|
}
|
|
else {
|
|
var me = this,
|
|
curNumColumns = me.columnsList.store.length,
|
|
koef = null,
|
|
widthKoefArr = [];
|
|
|
|
if(curNumColumns > 1) {
|
|
for(var i = 0; i < curNumColumns; i++){
|
|
widthKoefArr[i] = me.columnsList.store.at(i).get('width') / me.columnsList.store.at(0).get('width');
|
|
}
|
|
koef = (me.columnsList.store.at(curNumColumns - 1).get('width') + me.columnsList.store.at(curNumColumns - 2).get('spacing')) / me.totalWidth;
|
|
}
|
|
else {
|
|
curNumColumns = 2;
|
|
widthKoefArr = [1, 1];
|
|
koef = (me.totalWidth - me.defaultSpacing) / (2 * me.totalWidth);
|
|
}
|
|
|
|
var minWidthKoef = _.min(widthKoefArr);
|
|
widthKoefArr = widthKoefArr.map(function(item) { return item / minWidthKoef; });
|
|
|
|
//Calculation max columns
|
|
//Quadratic equation
|
|
//n <-- number current columns
|
|
//MAX <-- max columns
|
|
//w(i) <-- width 'i' column when the minimum column width is 'this.minWidthColumn'
|
|
//s(i) <-- current spacing 'i' column
|
|
//(koef*w(n)) * MAX^2 + ((1-n*koef)*w(n) - koef*this.totalWidth + summ(w(1), w(2), ..., w(n-1))*koef + (1-n)*koef*w(n) + s(n-1)) + (this.totalWidth*(1-n*koef) + summ(w(1), w(2), ..., w(n-1))*(1-n*koef) + w(n)*(1-n)*(1-n*koef) + summ(s(1), s(2), ..., w(n-2)) + s(n-1)*(1-n)) = 0
|
|
var lastWidth = widthKoefArr.pop() * me.minWidthCol,
|
|
summWidthWithoutLast = widthKoefArr.reduce(function(a, b) { return a + b ; }) * me.minWidthCol,
|
|
lastSpacing = (me.columnsList.store.length > 1) ? me.columnsList.store.at(curNumColumns-2).get('spacing') : me.defaultSpacing,
|
|
summSpacingWithoutLast = 0;
|
|
|
|
me.columnsList.store.each(function(item, index) {
|
|
if(index < me.columnsList.store.length - 2)
|
|
summSpacingWithoutLast += item.get('spacing');
|
|
});
|
|
|
|
var a = koef*lastWidth,
|
|
b = (1-curNumColumns*koef)*lastWidth - koef*this.totalWidth + koef*summWidthWithoutLast + (1-curNumColumns)*koef*lastWidth + lastSpacing,
|
|
c = -this.totalWidth*(1-curNumColumns*koef) + summWidthWithoutLast*(1-curNumColumns*koef) + lastWidth*(1-curNumColumns)*(1-curNumColumns*koef) + summSpacingWithoutLast + lastSpacing*(1-curNumColumns),
|
|
maxColumn = (Math.sqrt(b*b - 4*a*c) - b) / (2*a);
|
|
|
|
this.spnColumns.setMaxValue(Math.floor(maxColumn+0.01));
|
|
}
|
|
},
|
|
|
|
lockSpinsForEqualColumns: function(bool) {
|
|
var num = this.columnsList.store.length;
|
|
this.columnsList.store.each(function(col, index) {
|
|
col.get('widthSpin').setDisabled(bool);
|
|
col.get('spacingSpin').setDisabled(index != 0 && bool || index == num-1);
|
|
});
|
|
},
|
|
|
|
calcWidthForEqualColumns: function(num, spacing) {
|
|
return (this.totalWidth - (num - 1) * spacing ) / num;
|
|
},
|
|
|
|
setEqualWidthColumns: function () {
|
|
if(this.columnsList.store.length == 0) return;
|
|
|
|
var me = this,
|
|
num = this.spnColumns.getNumberValue(),
|
|
spacing = this.columnsList.store.at(0).get('spacing'),
|
|
width = this.calcWidthForEqualColumns(num, spacing);
|
|
|
|
if(width < this.minWidthCol) {
|
|
width = this.minWidthCol + 0.0001;
|
|
spacing = (num > 1) ? (this.totalWidth - (num * width)) / (num - 1) : 0;
|
|
}
|
|
|
|
this.columnsList.store.each(function(col, index) {
|
|
me.setWidthColumnValue(col, width);
|
|
if(index != num - 1) {
|
|
me.setSpacingColumnValue(col, spacing);
|
|
}
|
|
});
|
|
},
|
|
|
|
setWidthColumnValue: function(item, value) {
|
|
var widthSpin = item.get('widthSpin'),
|
|
valueInUserMetric = Common.Utils.Metric.fnRecalcFromMM(value);
|
|
|
|
item.set('width', value, {silent: true});
|
|
if(widthSpin.getMaxValue() < valueInUserMetric) {
|
|
widthSpin.setMaxValue(this.decimalRouding(valueInUserMetric))
|
|
}
|
|
widthSpin.setValue(valueInUserMetric, true);
|
|
},
|
|
|
|
setSpacingColumnValue: function(item, value) {
|
|
item.set('spacing', value, {silent: true});
|
|
item.get('spacingSpin').setValue(Common.Utils.Metric.fnRecalcFromMM(value), true);
|
|
},
|
|
|
|
setMaxValueSpinsForColumns: function() {
|
|
if(this.chEqualWidth.getValue() == 'checked') {
|
|
var item = this.columnsList.store.at(0),
|
|
num = this.columnsList.store.length,
|
|
width = this.minWidthCol,
|
|
maxSpacing = (num > 1) ? Common.Utils.Metric.fnRecalcFromMM((this.totalWidth - (num * width)) / (num - 1)) : 0;
|
|
|
|
item.get('widthSpin').setMaxValue(1000000);
|
|
item.get('spacingSpin').setMaxValue(num > 1 ? this.decimalRouding(maxSpacing) : 0);
|
|
}
|
|
else {
|
|
var me = this,
|
|
num = this.columnsList.store.length,
|
|
maxWidth = Common.Utils.Metric.fnRecalcFromMM(this.totalWidth - this.minWidthCol * (num - 1)),
|
|
maxSpacing = Common.Utils.Metric.fnRecalcFromMM(this.totalWidth - this.minWidthCol * num);
|
|
|
|
this.columnsList.store.each(function(item) {
|
|
item.get('widthSpin').setMaxValue(me.decimalRouding(maxWidth));
|
|
item.get('spacingSpin').setMaxValue(me.decimalRouding(maxSpacing));
|
|
});
|
|
}
|
|
},
|
|
|
|
decimalRouding: function (a, precision) {
|
|
var x = Math.pow(10, (precision ? precision : 2));
|
|
return Math.round(a * x) / x;
|
|
},
|
|
|
|
//type = width/spacing
|
|
setNewValueSpinsForColumns: function(changedItemIndex, difference, type) {
|
|
var me = this,
|
|
newWidthArr = [],
|
|
newSpacingArr = [],
|
|
diffFirstItemInArr = 0;
|
|
|
|
newWidthArr = fillArrNewValues('width', changedItemIndex + 1, me.columnsList.store.length);
|
|
if(type == 'width') {
|
|
if(difference != 0) {
|
|
newSpacingArr = fillArrNewValues('spacing', 0, me.columnsList.store.length - 1);
|
|
}
|
|
if(difference != 0) {
|
|
var newWidthArrBeforeCur = fillArrNewValues('width', 0, changedItemIndex);
|
|
newWidthArrBeforeCur.forEach(function(val, index){
|
|
newWidthArr[index] = val;
|
|
});
|
|
}
|
|
}
|
|
else {
|
|
if(difference != 0) {
|
|
var newWidthArrBeforeCur = fillArrNewValues('width', 0, changedItemIndex+1);
|
|
newWidthArrBeforeCur.forEach(function(val, index){
|
|
newWidthArr[index] = val;
|
|
});
|
|
}
|
|
if(difference != 0) {
|
|
newSpacingArr = fillArrNewValues('spacing', 0, me.columnsList.store.length - 1, changedItemIndex);
|
|
}
|
|
}
|
|
|
|
newWidthArr.forEach(function(val, index) {
|
|
me.setWidthColumnValue(me.columnsList.store.at(index), val);
|
|
});
|
|
|
|
newSpacingArr.forEach(function(val, index) {
|
|
me.setSpacingColumnValue(me.columnsList.store.at(index), val);
|
|
});
|
|
|
|
//type = width/spacing
|
|
function fillArrNewValues(type, indexStart, indexEnd, excludedIndex){
|
|
var koefArr = getKoefs(type, indexStart, indexEnd, difference < 0, excludedIndex),
|
|
minValue = (type == 'width') ? me.minWidthCol : 0,
|
|
resultArr = [];
|
|
|
|
while(koefArr.length > 0 && koefArr.reduce(function(a, b){ return a + (b ? 1 : 0) }) > 0 && difference != 0) {
|
|
diffFirstItemInArr = difference / koefArr.reduce(function(a, b) { return a + b; });
|
|
for(var i = indexStart; i < indexEnd; i++) {
|
|
if(!koefArr[i] || (excludedIndex !== undefined && excludedIndex == i)) continue;
|
|
|
|
var term = diffFirstItemInArr * koefArr[i],
|
|
oldWidth = (resultArr[i] !== undefined ? resultArr[i] : me.columnsList.store.at(i).get(type)),
|
|
newWidth = oldWidth - term;
|
|
|
|
if(newWidth < minValue) {
|
|
term = oldWidth - minValue;
|
|
newWidth = minValue;
|
|
koefArr[i] = 0;
|
|
}
|
|
resultArr[i] = newWidth;
|
|
difference -= term;
|
|
}
|
|
difference = me.decimalRouding(difference, 6);
|
|
}
|
|
return resultArr;
|
|
}
|
|
|
|
//type = width/spacing
|
|
function getKoefs(type, indexStart, indexEnd, positive, excludedIndex) {
|
|
if(positive == undefined) positive = false;
|
|
|
|
var resultArr = [];
|
|
for(var i = indexStart, firstIndexNotMinimumVal; i < indexEnd; i++) {
|
|
if((excludedIndex !== undefined && excludedIndex == i)) continue;
|
|
|
|
var curColumnVal = me.columnsList.store.at(i).get(type);
|
|
if((type == 'width' && (positive || curColumnVal > me.minWidthCol)) || (type == 'spacing' && curColumnVal > 0)) {
|
|
if(firstIndexNotMinimumVal === undefined)
|
|
firstIndexNotMinimumVal = i;
|
|
|
|
resultArr[i] = curColumnVal / me.columnsList.store.at(firstIndexNotMinimumVal).get(type);
|
|
}
|
|
}
|
|
if(positive && resultArr.length == 0){
|
|
for(var i = indexStart, firstIndexNotMinimumVal; i < indexEnd; i++) {
|
|
resultArr[i] = 1;
|
|
}
|
|
}
|
|
return resultArr;
|
|
}
|
|
},
|
|
|
|
addControls: function(listView, itemView, item) {
|
|
if (!item) return;
|
|
|
|
var me = this,
|
|
index = item.get('index'),
|
|
isLastItem = index === me.columnsList.store.length - 1,
|
|
isEqualWidth = me.chEqualWidth.getValue() == 'checked',
|
|
metricName = Common.Utils.Metric.getCurrentMetricName();
|
|
|
|
var spinWidth = new Common.UI.MetricSpinner({
|
|
el: $('#custom-columns-list-item-spin-width-' + index),
|
|
step: Common.Utils.Metric.getCurrentMetric() == Common.Utils.Metric.c_MetricUnits.pt ? 1 : 0.1,
|
|
width: 105,
|
|
tabindex: 1,
|
|
defaultUnit : metricName,
|
|
value: me.decimalRouding(Common.Utils.Metric.fnRecalcFromMM(item.get('width'))) + ' ' + metricName,
|
|
maxValue: 120,
|
|
minValue: me.decimalRouding(Common.Utils.Metric.fnRecalcFromMM(me.minWidthCol)),
|
|
disabled: isEqualWidth || (index == 0 && isLastItem),
|
|
}).on('change', function(field, newValue, oldValue, eOpts) {
|
|
var difference = Common.Utils.Metric.fnRecalcToMM(parseFloat(newValue) - Common.Utils.Metric.fnRecalcFromMM(item.get('width')).toFixed(2));
|
|
item.set('width', item.get('width') + difference, {silent: true});
|
|
|
|
me.setNewValueSpinsForColumns(index, difference, 'width');
|
|
me.setMaxColumns();
|
|
});
|
|
|
|
var spinSpacing = new Common.UI.MetricSpinner({
|
|
el: $('#custom-columns-list-item-spin-spacing-' + index),
|
|
step: Common.Utils.Metric.getCurrentMetric() == Common.Utils.Metric.c_MetricUnits.pt ? 1 : 0.1,
|
|
width: 105,
|
|
tabindex: 1,
|
|
defaultUnit : metricName,
|
|
value: !isLastItem ? this.decimalRouding(Common.Utils.Metric.fnRecalcFromMM(item.get('spacing'))) + ' ' + metricName : '',
|
|
maxValue: 120,
|
|
minValue: 0,
|
|
disabled: (isEqualWidth && index != 0) || isLastItem,
|
|
}).on('change', function(field, newValue, oldValue, eOpts) {
|
|
var difference = Common.Utils.Metric.fnRecalcToMM(parseFloat(newValue) - Common.Utils.Metric.fnRecalcFromMM(item.get('spacing')).toFixed(2));
|
|
item.set('spacing', item.get('spacing') + difference, {silent: true});
|
|
|
|
if(me.chEqualWidth.getValue() == 'checked')
|
|
me.setEqualWidthColumns();
|
|
else
|
|
me.setNewValueSpinsForColumns(index, difference, 'spacing');
|
|
|
|
me.setMaxColumns();
|
|
});
|
|
|
|
item.set('widthSpin', spinWidth, {silent: true});
|
|
item.set('spacingSpin', spinSpacing, {silent: true});
|
|
},
|
|
|
|
textTitle: 'Columns',
|
|
textColumns: 'Number of columns',
|
|
textWidth: 'Width',
|
|
textTitleSpacing: 'Spacing',
|
|
textEqualWidth: 'Equal column width',
|
|
textSeparator: 'Column divider'
|
|
}, DE.Views.CustomColumnsDialog || {}))
|
|
}); |