LogicNode = Object.subClass({
|
|
init: function(config) {
|
this.level = config.level || 0;
|
this.type = config.type;
|
this.expression = config.expression;
|
this.condition = config.condition;
|
this.valuation = config.valuation;
|
this.parent = config.parent;
|
this.children = [];
|
},
|
|
toString: function(content) {
|
var result = "";
|
|
if (!this.condition) {
|
this.expression = this.valuation.expression = this.valuation.editor.val();
|
}
|
else {
|
this.condition.expression = this.condition.editor.val();
|
this.valuation.expression = this.valuation.editor.val();
|
|
this.expression = this.condition.expression + "?" + this.valuation.expression;
|
}
|
|
result = result + this.expression;
|
var flag = this.level == 0 ? ";" : ",";
|
|
var max = this.children.length;
|
for (var i = 0; i < max; i++) {
|
var child = this.children[i];
|
result = result + flag + child.toString();
|
}
|
},
|
|
show: function() {
|
if (!this.condition) {
|
this.valuation.editor.val(this.valuation.expression);
|
}
|
else {
|
this.condition.editor.val(this.condition.expression);
|
this.valuation.editor.val(this.valuation.expression);
|
}
|
},
|
|
clear: function() {
|
if (this.condition && this.condition.el) {
|
this.condition.el.remove();
|
}
|
if (this.valuation && this.valuation.el) {
|
this.valuation.el.remove();
|
}
|
if (this.el) {
|
this.el.remove();
|
}
|
}
|
});
|
|
LogicTree = Object.subClass({
|
|
init: function(config) {
|
this.type;
|
this.condition = null;
|
this.valuation = null;
|
this.eidtor = null;
|
this.children = [];
|
},
|
|
parse: function(content, flag) {
|
this.clear();
|
|
//1. if empty add default line
|
if (!content) {
|
this.parseMathValue(this, content, 0);
|
return;
|
}
|
|
flag = flag || ";";
|
|
//2. math
|
if (content.indexOf(";") < 0) {
|
this.parseMathValue(this, content, 0);
|
return;
|
}
|
|
//3. logic
|
var sequences = content.split(";");
|
var max = sequences.length;
|
|
for (var i = 0; i < max; i++) {
|
sequence = sequences[i];
|
var node = this.parseIFValue(this, sequence, 0);
|
}
|
},
|
|
parseMathValue: function(parent, value, level) {
|
var node = new LogicNode({
|
parent: parent,
|
level: level,
|
type: "Math",
|
valuation: {
|
expression: value,
|
el: null
|
}
|
});
|
|
parent.children.push(node);
|
return node;
|
},
|
|
parseIFValue: function(parent, content, level) {
|
var pos = content.indexOf("?");
|
|
//1. else if
|
if (pos < 0) {
|
var node = new LogicNode({
|
parent: parent,
|
level: level,
|
type: "ELSE",
|
expression: content,
|
valuation: {
|
expression: content,
|
el: null
|
}
|
});
|
|
parent.children.push(node);
|
return;
|
}
|
|
//2. if condition
|
var node = new LogicNode({
|
parent: parent,
|
level: level,
|
type: "IF",
|
condition: {
|
expression: content.substring(0, pos),
|
el: null
|
}
|
});
|
node.expression = content;
|
parent.children.push(node);
|
|
//3. if valuation
|
var pos_subflag = content.indexOf(",");
|
if (pos_subflag < 0) {
|
var math = content.substring(pos + 1);
|
|
node.valuation = {
|
expression: math,
|
el: null
|
}
|
return;
|
}
|
|
//4. children
|
this.parse(node, ",", 1);
|
},
|
|
gotoEmptyMathLogic: function() {
|
if ("Math" == this.type) {
|
return;
|
}
|
|
this.clear();
|
this.parseMathValue(this, null, 0);
|
},
|
|
gotoEmptyIFLogic: function() {
|
if ("IF" == this.type) {
|
return;
|
}
|
|
this.clear();
|
|
//1. if
|
var node = new LogicNode({
|
parent: this,
|
level: 0,
|
type: "IF",
|
expression: null,
|
condition: {
|
expression: null,
|
el: null
|
},
|
valuation: {
|
expression: null,
|
el: null
|
}
|
});
|
this.children.push(node);
|
|
//2. else
|
node = new LogicNode({
|
parent: this,
|
level: 0,
|
type: "ELSE",
|
expression: null,
|
valuation: {
|
expression: null,
|
el: null
|
}
|
});
|
this.children.push(node);
|
},
|
|
getString: function() {
|
var result = "";
|
|
var max = this.children.length;
|
for (var i = 0; i < max; i++) {
|
var child = this.children[i];
|
result = result + child.toString();
|
}
|
|
return result;
|
},
|
|
show: function() {
|
var max = this.children.length;
|
for (var i = 0; i < max; i++) {
|
var child = this.children[i];
|
child.show();
|
}
|
},
|
|
clear: function() {
|
var max = this.children.length;
|
for (var i = 0; i < max; i++) {
|
var child = this.children[i];
|
child.clear();
|
}
|
|
this.children = [];
|
}
|
});
|
|
FormulaDesigner = Control.subClass({
|
|
items: true,
|
|
init: function(config) {
|
config.css = util.combine(config.css, {
|
container: null
|
});
|
|
this.columnSetting = this.createSetting();
|
|
this.logicTree = new LogicTree({});
|
this.mathLine = {};
|
this.selected = null;
|
this.Code = {
|
BackSpace: 8,
|
Delete: 46,
|
Enter: 13,
|
TrigerBegin: 219,
|
TrigerEnd: 221
|
};
|
this.tipList = {
|
|
};
|
|
Control.call(this, config);
|
},
|
|
getContainerTemplate: function() {
|
return $(Formula_Template.container.join(""));
|
},
|
|
createContent: function() {
|
this.logicTree.el = this.container;
|
|
//1. body
|
this.logicTree.el.body = $("#formula_body", this.container);
|
|
//2. header
|
this.header = $("#formula_header", this.container);
|
var me = this;
|
|
//2.1 header - name
|
var codeEditor = this.header.codeEditor = $("#editor_code", this.header);
|
codeEditor.change(function() { me.onChangeVariantCode.call(me) });
|
|
var nameEditor = this.header.nameEditor = $("#editor_name", this.header);
|
nameEditor.change(function() { me.onChangeVariantName.call(me) });
|
|
nameEditor.focus(function () {
|
nameEditor.preValue = nameEditor.val();
|
})
|
//2.2 header - align
|
var alignEditor = this.header.alignEditor = $("#editor_align", this.header);
|
alignEditor.change(function() { me.onChangeLayoutSetting() });
|
|
//2.3 header - formatter
|
var formatterEditor = this.header.formatterEditor = $("#editor_formatter", this.header);
|
formatterEditor.change(function() { me.onChangeLayoutSetting() });
|
|
//2.4 header - width
|
var widthEditor = this.header.widthEditor = $("#width_editor", this.header);
|
widthEditor.change(function() { me.onChangeLayoutSetting() });
|
var typeEditor = this.header.typeEditor = $("#width_editor", this.header);
|
typeEditor.change(function() { me.onChangeLayoutSetting() });
|
},
|
|
createLines: function() {
|
var lines = this.logicTree.children;
|
var max = lines.length;
|
|
for (var i = 0; i < max; i++) {
|
this.createOneLine(lines[i]);
|
}
|
},
|
|
createOneLine: function(logic) {
|
if ("Math" == logic.type) {
|
this.createMathLine(logic);
|
}
|
else if ("IF" == logic.type) {
|
this.createIFLine(logic);
|
}
|
else if ("ELSE" == logic.type) {
|
this.createElseLine(logic);
|
}
|
},
|
|
createMathLine: function(logic) {
|
//1. element
|
var el = logic.valuation.el = $(Formula_Template.mathLine.join(""));
|
var editor = logic.valuation.editor = $("#mathEditor", el);
|
// editor.prop({ disabled: true });
|
|
//2.
|
this.linkDropdown(editor);
|
|
//3. change event
|
var me = this;
|
editor.change(function() {
|
me.onExpressionChange.call(me);
|
});
|
|
//3. append to parent
|
logic.parent.el.body.append(el);
|
return result;
|
},
|
|
createIFLogic: function(parentLogic) {
|
//1. clear math line
|
if (this.mathLine.el) {
|
this.mathLine.el.remove();
|
this.mathLine = {};
|
}
|
|
//2. login tree
|
this.createIFLine(parentLogic);
|
this.createElseLine(parentLogic);
|
},
|
|
createIFLine: function(logic) {
|
this.createLogicLine(logic, "IF");
|
},
|
|
createElseIFLine: function(logic, priorLogic) {
|
this.createLogicLine(logic, "ELSE-IF", priorLogic);
|
},
|
|
createElseLine: function(logic) {
|
this.createLogicLine(logic, "ELSE");
|
},
|
|
createLogicLine: function(logic, type, priorLogic) {
|
//1. create element
|
var el; var existsButtons;
|
|
if ("IF" == type || "ELSE-IF" == type) {
|
el = $(Formula_Template.logicIF.join(""));
|
logic.condition = {};
|
logic.valuation = {};
|
logic.condition.editor = $("#conditionEditor", el);
|
logic.valuation.editor = $("#valuationEditor", el);
|
existsButtons = true;
|
}
|
else {
|
el = logic.valuation.el = $(Formula_Template.logicELSE.join(""));
|
logic.valuation.editor = $("#valuationEditor", el);
|
existsButtons = false;
|
}
|
|
logic.el = el;
|
el.body = $("#logic_body", el);
|
|
//2. change event
|
var me = this;
|
|
if (logic.condition && logic.condition.editor) {
|
var editor = logic.condition.editor;
|
|
this.linkDropdown(editor);
|
|
editor.change(function() {
|
me.onExpressionChange.call(me);
|
});
|
}
|
|
if (logic.valuation && logic.valuation.editor) {
|
var editor = logic.valuation.editor;
|
|
this.linkDropdown(editor);
|
|
editor.change(function() {
|
me.onExpressionChange.call(me);
|
});
|
}
|
|
//3. caption
|
var caption = $("#conditionCaption", el);
|
caption.html(this.getLogicLabel(type));
|
|
//4. event
|
if (existsButtons) {
|
var me = this;
|
el.bntAddOne = $("#btn_addOne", el);
|
el.bntAddOne.click(function() {
|
me.createElseIFLine(parentLogic, result);
|
});
|
|
el.bntAddChild = $("#btn_addChild", el);
|
el.bntAddChild.click(function() {
|
me.createIFLogic(result);
|
});
|
|
el.bntDeleteOne = $("#btn_deleteOne", el);
|
el.bntDeleteOne.click(function() {
|
me.deleteLogic(result);
|
});
|
}
|
|
//5. append to parent
|
var parentLogic = logic.parent;
|
|
if (priorLogic) {
|
result.el.insertBefore(priorLogic.el);
|
}
|
else {
|
var parentEl = parentLogic.el.body;
|
parentEl.append(el);
|
}
|
|
//6. animate
|
return result;
|
},
|
|
deleteLogic: function(logic) {
|
var parent = logic.parent;
|
var logicList = parent.children;
|
|
//1. 只有if和else
|
if (logicList.length <= 2) {
|
this.initLogicBody(parent);
|
}
|
else {
|
//1. delete from parent
|
var index = logicList.indexOf(logic);
|
logicList.splice(index, 1);
|
|
//2. delete el
|
logic.el.remove();
|
}
|
},
|
|
initLogicBody: function(logic) {
|
//1. empty parent children
|
logic.children = [];
|
|
//2. empty body
|
logic.el.body.empty();
|
|
//3. append valuation
|
var valuation = $(Formula_Template.valuation.join(""));
|
logic.el.body.append(valuation);
|
},
|
|
removeLogicValuation: function(logic) {
|
if (!logic.el.valuation) {
|
return;
|
}
|
|
logic.el.valuation.remove();
|
logic.el.valuation = null;
|
},
|
|
getExpressionString: function() {
|
if (logicLine) {
|
var result = logicLine.expression.getString();
|
return result;
|
}
|
if (this.activeEditor) {
|
return this.activeEditor.val();
|
}
|
|
var result = "";
|
var logicTree = this.logicTree;
|
var max = logicTree.children.length;
|
|
for (var i = 0; i < max; i++) {
|
var logicLine = logicTree.children[i];
|
result = result + logicLine.expression.getString();
|
}
|
|
return result;
|
},
|
|
gotoMathLogic: function() {
|
this.logicTree.gotoEmptyMathLogic();
|
this.createLines();
|
},
|
|
gotoIFLogic: function() {
|
this.logicTree.gotoEmptyIFLogic();
|
this.createLines();
|
},
|
|
getLogicLabel: function(type) {
|
if ("IF" == type) {
|
return "如果：";
|
}
|
else if ("ELSE-IF" == type) {
|
return "如果：";
|
}
|
else if ("ELSE" == type) {
|
return "否则：";
|
}
|
},
|
|
clear: function() {
|
//1. math
|
if (this.mathLine.el) {
|
this.mathLine.el.remove();
|
}
|
this.mathLine = {};
|
|
//2.
|
var children = this.logicTree.children;
|
var max = children.length;
|
|
for (var i = 0; i < max; i++) {
|
var logic = children[i];
|
logic.el.remove();
|
}
|
|
this.logicTree.children = [];
|
},
|
|
createSetting: function() {
|
var me = this;
|
|
var result = new ColumnSetting({
|
owner: "formula",
|
getActiveColumn: function() {
|
return me.selected;
|
},
|
onSetCode: function(column, code) {
|
me.header.codeEditor.val(code);
|
},
|
onSetName: function(column, name) {
|
me.header.nameEditor.val(name);
|
},
|
onSetExpression: function(column, expression) {
|
me.logicTree.parse(expression);
|
me.createLines();
|
me.logicTree.show();
|
},
|
onSetFormatter: function(column, formatter) {
|
var filter = "[value='" + formatter + "']";
|
var option = $(filter, me.header.formatterEditor);
|
if (option) {
|
option.attr("selected", "selected");
|
}
|
},
|
onSetAlign: function(column, align) {
|
var filter = "[value='" + align + "']";
|
var option = $(filter, me.header.alignEditor);
|
if (option) {
|
option.attr("selected", "selected");
|
}
|
},
|
onSetWidth: function(column, width) {
|
var filter = "[value='" + width + "']";
|
var option = $(filter, me.header.widthEditor);
|
if (option) {
|
option.attr("selected", "selected");
|
}
|
},
|
onBeginSetting: function() {
|
me.loading = true;
|
|
if (this.expressionChanged) {
|
me.onSaveExpression();
|
}
|
this.expressionChanged = false;
|
|
},
|
onEndSetting: function() {
|
me.loading = false;
|
}
|
});
|
|
return result;
|
},
|
|
setColumnSetting: function(sender, column, option) {
|
this.selected = column;
|
this.columnSetting.set(sender, column, option);
|
},
|
|
onChangeVariantCode: function() {
|
if (this.loading) {
|
return;
|
}
|
|
if (this.config.settingListener) {
|
var value = this.header.codeEditor.val();
|
|
this.config.settingListener.setColumnSetting(this, null, {
|
code: value
|
});
|
}
|
},
|
|
onChangeVariantName: function() {
|
if (this.loading) {
|
return;
|
}
|
let editor = this.activeEditor;
|
if (this.config.settingListener) {
|
var value = this.header.nameEditor.val();
|
let afterTip = {
|
name: value,
|
text:"[" + value + "]"
|
};
|
if( this.header.nameEditor.preValue) {
|
let preTip = {
|
name: this.header.nameEditor.preValue,
|
text:"[" + this.header.nameEditor.preValue + "]"
|
};
|
this.updateTip(preTip, afterTip);
|
}else {
|
this.addOneTip(afterTip);
|
}
|
|
|
|
this.config.settingListener.setColumnSetting(this, null, {
|
name: value
|
});
|
}
|
},
|
|
onExpressionChange: function() {
|
this.columnSetting.expressionChanged = true;
|
},
|
|
onSaveExpression: function() {
|
if (this.loading) {
|
return;
|
}
|
|
if (this.config.settingListener) {
|
var value = this.getExpressionString();
|
// value = value.replace("+", "~");
|
this.config.settingListener.setColumnSetting(this, null, {
|
expression: value
|
});
|
}
|
},
|
onChangeLayoutSetting: function() {
|
if (this.loading) {
|
return;
|
}
|
|
if (this.config.settingListener) {
|
var setting = {
|
align: this.header.alignEditor.val(),
|
formatter: this.header.formatterEditor.val(),
|
width: this.header.widthEditor.val(),
|
data_type: this.header.typeEditor.val(),
|
|
};
|
|
this.config.settingListener.setColumnSetting(this, null, setting);
|
}
|
},
|
|
setTipList: function(tipList) {
|
this.tipList = tipList;
|
|
if (this.dropdown) {
|
this.dropdown.dirty = true;
|
}
|
},
|
|
addOneTip: function(tip) {
|
if (!tip || !tip.name) {
|
return;
|
}
|
this.tipList[tip.name] = tip;
|
},
|
updateTip: function(preTip, afterTip) {
|
if (!afterTip || !afterTip.name) {
|
return;
|
}
|
|
this.tipList[preTip.name] = afterTip;
|
},
|
deleteOneTip: function(tip) {
|
if (!tip || !tip.name) {
|
return;
|
}
|
|
delete this.tipList[tip.name];
|
},
|
|
linkDropdown: function(editor) {
|
var me = this;
|
me.activeEditor = editor;
|
editor.on("keydown", function(e) {
|
me.onEditorKeyDown.call(me, editor, e);
|
});
|
|
editor.on("keyup", function(e) {
|
me.onEditorKeyUp.call(me, editor, e);
|
});
|
},
|
|
getCurrentPos: function(editor) {
|
editor.focus();
|
var currentPos = editor.get(0).selectionStart;
|
return currentPos;
|
},
|
|
setCurrentPos: function(editor, currentPosition) {
|
editor.focus();
|
var currentPos = editor.get(0).selectionStart;
|
if (currentPos != undefined && currentPos >= currentPosition) {
|
editor.get(0).selectionStart = (currentPosition);
|
editor.get(0).selectionEnd = (currentPosition);
|
}
|
|
},
|
|
onEditorKeyDown: function(editor, e) {
|
var config = this.config, Code = this.Code;
|
var event = e || window.event;
|
|
var keyCode = event.keyCode;
|
if (keyCode == Code.BackSpace) {
|
this.editMode = "DeleteFront";
|
}
|
else if (keyCode == Code.Delete) {
|
this.editMode = "DeleteBack";
|
}
|
else if (keyCode == Code.TrigerBegin) {
|
this.editMode = "ShowDropDown";
|
}
|
else if (keyCode == Code.Return) {
|
this.editMode = "ReShowDropDown";
|
}
|
else {
|
this.editMode = "Edit";
|
}
|
},
|
|
onEditorKeyUp: function(editor, e) {
|
this.activeEditor = editor;
|
var editMode = this.editMode;
|
|
if (editMode == "DeleteFront") {
|
this.deleteFront(editor);
|
e.preventDefault();
|
}
|
else if (editMode == "DeleteBack") {
|
this.deleteBack(editor);
|
e.preventDefault();
|
}
|
else if (editMode == "ShowDropDown") {
|
this.showDropdown(editor);
|
}
|
else if (editMode == "ReShowDropDown") {
|
this.reshowDropdown(editor);
|
}
|
},
|
|
deleteFront: function(editor) {
|
var value = editor.val();
|
var pos = this.getCurrentPos(editor);
|
|
if (pos <= 0) {
|
return;
|
}
|
|
var location = this.getVariantLocation(value, pos, "toFront");
|
var from = location ? location.from : pos;
|
var to = location ? location.to : pos;
|
|
value = value.substring(0, from) + value.substring(to + 1);
|
editor.val(value);
|
},
|
|
deleteBack: function() {
|
var value = editor.val();
|
var pos = this.getCurrentPos(editor);
|
|
if (pos >= value.length) {
|
return;
|
}
|
|
var header = val.substring(pos, pos + 1);
|
|
var location;
|
if (header == this.Code.TrigerBegin) {
|
location = this.getVariantLocation(value, pos, "toBack");
|
}
|
|
var from = location ? location.from : pos;
|
var to = location ? location.to : pos;
|
|
value = value.substring(0, from) + value.substring(to + 1);
|
editor.val(value);
|
},
|
|
reshowDropdown: function(editor) {
|
var value = editor.val();
|
var pos = this.getCurrentPos(editor);
|
|
if (pos <= 0) {
|
return;
|
}
|
|
var header = val.substring(pos, pos + 1);
|
if (header == this.Code.TrigerBegin) {
|
this.showDropdown(editor, pos);
|
}
|
},
|
|
showDropdown: function(editor, pos) {
|
if (pos == undefined) {
|
pos = this.getCurrentPos(editor);
|
}
|
|
if (!this.dropdown || this.dropdown.dirty) {
|
this.createDropDown(editor);
|
}
|
|
this.setDropDownPosition(editor, this.dropdown.el);
|
this.dropdown.el.show();
|
},
|
|
hideDropdown: function() {
|
this.dropdown.el.hide();
|
},
|
|
createDropDown: function(editor) {
|
if (this.dropdown) {
|
this.dropdown.el.empty();
|
}
|
else {
|
this.dropdown = {
|
el: $(Formula_Template.dropdown)
|
};
|
}
|
|
var tipList = this.tipList, dropdownEl = this.dropdown.el;
|
|
if (tipList) {
|
var me = this;
|
|
for (var prop in tipList) {
|
var item = tipList[prop];
|
var el = $(Formula_Template.dropdownItem);
|
el.html(item.name);
|
|
el.prop("data-code", prop);
|
el.click(function() {
|
var code = $(this).prop("data-code");
|
var item = me.tipList[code];
|
me.onSelectDropdown(item);
|
});
|
|
dropdownEl.append(el);
|
}
|
}
|
|
$("body").append(this.dropdown.el);
|
this.dropdown.dirty = false;
|
return this.dropdown;
|
},
|
insertMathOperator: function (item, idx) {
|
var editor = this.activeEditor;
|
if(!editor || !item) {
|
return;
|
}
|
item = " "+ item +" "
|
let currentPos = this.getCurrentPos(editor);
|
var value = editor.val();
|
// check same type tag
|
let result = value.substring(0, currentPos) + item + value.substring(currentPos);
|
editor.val(result);
|
let nextPosition = currentPos + item.length;
|
if(idx) {
|
nextPosition = currentPos + item.length - idx - 1;
|
}
|
this.setCurrentPos(editor, nextPosition);
|
},
|
|
onSelectDropdown: function(item) {
|
var editor = this.activeEditor;
|
|
var pos = this.getCurrentPos(editor);
|
var value = editor.val();
|
var result = value.substring(0, pos - 1) + item.text + value.substring(pos + 1);
|
editor.val(result);
|
|
this.hideDropdown();
|
},
|
|
getVariantLocation: function(value, pos, direction) {
|
var result = {
|
from: pos,
|
to: pos
|
}
|
|
if ("toBack" == direction) {
|
var max = value.length;
|
|
for (var i = pos + 1; i < max; i++) {
|
var char = value.charCodeAt(i);
|
if ("[" == char) {
|
return result;
|
}
|
else if ("]" == char) {
|
result.from = pos;
|
result.to = i;
|
return result;
|
}
|
}
|
}
|
else if ("toFront" == direction) {
|
for (var i = pos - 1; i >= 0; i--) {
|
var char = value[i];
|
if ("]" == char) {
|
return result;
|
}
|
else if ("[" == char) {
|
result.from = i;
|
result.to = pos;
|
return result;
|
}
|
}
|
}
|
|
return result;
|
},
|
|
setDropDownPosition: function(editor, dropdown) {
|
dropdown.css({
|
bottom: "50px",
|
left: "300px"
|
});
|
}
|
|
});
|
|
|
//*************************************
|
Formula_Template = {};
|
|
Formula_Template.container = [
|
'<div class="formula">',
|
'<div id="formula_header" class="formula-header">',
|
'<span>列名：</span>',
|
'<input id="editor_code" type="text" class="formula-header-code" value="" autocomplete="off"/>',
|
'<span> </span>',
|
'<span>显示名称：</span>',
|
'<input id="editor_name" type="text" class="formula-header-name" value="" autocomplete="off"/>',
|
'<span> </span>',
|
'<span>显示格式：</span>',
|
'<select id="editor_formatter">',
|
'<option value="text">文本</option>',
|
'<option value="percent">百分比</option>',
|
'<option value="money">金额</option>',
|
'<option value="decimal">数值</option>',
|
'<option value="bool">是/否</option>',
|
'</select>',
|
'<span> </span>',
|
'<span>对齐方式：</span>',
|
'<select id="editor_align">',
|
'<option value="left">左对齐</option>',
|
'<option value="center">居中对齐</option>',
|
'<option value="right">右对齐</option>',
|
'</select>',
|
'<span> </span>',
|
'<span>列宽度：</span>',
|
'<select id="width_editor">',
|
'<option value="0.6">0.6</option>',
|
'<option value="0.8">0.8</option>',
|
'<option value="1">1</option>',
|
'<option value="1.5">1.5</option>',
|
'<option value="2.5">2.5</option>',
|
'</select>',
|
'<span> </span>',
|
'<span>列类型：</span>',
|
'<select id="type_editor">',
|
'<option value="">常规</option>',
|
'<option value="customer">记账对象</option>',
|
'<option value="value">记账金额</option>',
|
'</select>',
|
'</div>',
|
'<div class="formula-body">',
|
'<div id="formula_body" class="formula-body-inner">',
|
'</div>',
|
'</div>',
|
'</div>'
|
];
|
|
Formula_Template.mathLine = [
|
'<div id="math_body" class="math-body">',
|
'<span id="mathCaption" class="math-caption">=</span>',
|
'<input id="mathEditor" class="math-input" type="text" autocomplete="off" placeholder="请编辑公式"/>',
|
'</div>'
|
];
|
|
Formula_Template.logicIF = [
|
'<div class="logic">',
|
'<div class="logic-condition">',
|
'<div class="indicator-line"></div>',
|
'<div class="indicator-if"></div>',
|
'<span id="conditionCaption" class="condition-caption"></span>',
|
'<input id="conditionEditor" class="logic-input-condition" type="text" autocomplete="off"/>',
|
'<div class="logic-btn-group">',
|
'<div id="btn_addOne" class="logic-btn">+ 同级</div>',
|
'<div id="btn_addChild" class="logic-btn">+ 下级</div>',
|
'<div id="btn_deleteOne" class="logic-btn">- 删除</div>',
|
'</div>',
|
'</div>',
|
'<div id="logic_body" class="logic-body">',
|
'<div class="indicator-line"></div>',
|
'<div id="valuation_body" class="valuation-body">',
|
'<input id="valuationEditor" class="logic-input-valuation" type="text" autocomplete="off"/>',
|
'</div>',
|
'</div>',
|
'</div>'
|
];
|
|
Formula_Template.logicELSE = [
|
'<div class="logic">',
|
'<div id="logic_body" class="logic-condition">',
|
'<div class="indicator-else"></div>',
|
'<span id="conditionCaption" class="condition-caption"></span>',
|
'<input id="valuationEditor" class="logic-input-valuation" type="text" autocomplete="off"/>',
|
'</div>',
|
'</div>'
|
];
|
|
Formula_Template.valuation = [
|
'<div class="indicator-line"></div>',
|
'<div id="valuation_body" class="valuation-body">',
|
'<input id="valuationEditor" type="text" autocomplete="off"/>',
|
'</div>',
|
];
|
|
Formula_Template.dropdown = "<ul class='tips' style='display:none;'></ul>";
|
|
Formula_Template.dropdownItem = "<li class='tips-item'></li>";
|
