ming-demo3/lib/components/grid/CellModel.js

mdf metaui web

"use strict";

var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));

var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));

var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));

var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));

var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _react = _interopRequireDefault(require("react"));

var _baseui = require("@mdf/baseui");

var _fixedDataTable = require("fixed-data-table-2");

var _input = _interopRequireDefault(require("../basic/input"));

var _InputMultiLang = _interopRequireDefault(require("../basic/InputMultiLang"));

var _hotkeyinput = _interopRequireDefault(require("../basic/hotkeyinput"));

var _inputnumber = _interopRequireDefault(require("../basic/inputnumber"));

var _datepicker = _interopRequireDefault(require("../basic/datepicker"));

var _timepicker = _interopRequireDefault(require("../basic/timepicker"));

var _select = _interopRequireDefault(require("../basic/select"));

var _refer = _interopRequireDefault(require("../basic/refer"));

var _switch = _interopRequireDefault(require("../basic/switch"));

var _labelswitch = _interopRequireDefault(require("../basic/labelswitch"));

var _button = _interopRequireDefault(require("../basic/button"));

var _checkbox = _interopRequireDefault(require("../basic/checkbox"));

var _tag = _interopRequireDefault(require("../basic/tag"));

var _col = _interopRequireDefault(require("../basic/col"));

var _row = _interopRequireDefault(require("../basic/row"));

var _switchlabel = _interopRequireDefault(require("../basic/switchlabel"));

var _treerefer = _interopRequireDefault(require("../basic/treerefer"));

var _functypes = _interopRequireDefault(require("../basic/functypes"));

var _listrefer = _interopRequireDefault(require("../basic/listrefer"));

var _CompositeModel = _interopRequireDefault(require("./CompositeModel"));

var _checkradio = _interopRequireDefault(require("../basic/checkradio"));

var _cascader = _interopRequireDefault(require("../basic/cascader"));

var format = _interopRequireWildcard(require("@mdf/cube/lib/helpers/formatDate"));

var _util = require("@mdf/cube/lib/helpers/util");

var _UncertainControl = _interopRequireDefault(require("./UncertainControl"));

var _SvgIcon = _interopRequireDefault(require("@mdf/metaui-web/lib/components/common/SvgIcon"));

var _extend = require("@mdf/cube/lib/extend");

var themeType = process.env.__THEMETYPE__;
var ReferComp = _refer["default"];

var CellModel = function (_React$Component) {
  (0, _inherits2["default"])(CellModel, _React$Component);

  function CellModel(props) {
    var _this;

    (0, _classCallCheck2["default"])(this, CellModel);
    _this = (0, _possibleConstructorReturn2["default"])(this, (0, _getPrototypeOf2["default"])(CellModel).call(this, props));
    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "getKeyByIndex", function (index, data) {
      var columnKey = null;

      for (var key in data) {
        if (index == data[key]) {
          columnKey = key;
          break;
        }
      }

      return columnKey;
    });
    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "getCount", function (data, index) {
      var keyIndex = index - 1,
          count = 1;

      for (var i = 0; i < 1000000; i++) {
        if (data[keyIndex] === 1) {
          count = count + 1;
          keyIndex = keyIndex - 1;
        } else {
          break;
        }
      }

      return count;
    });
    (0, _defineProperty2["default"])((0, _assertThisInitialized2["default"])(_this), "onCrChange", function (value, index, columnKey) {
      _this.props.model.setFocusedRowIndex(index);

      _this.props.model.setCellValue(index, columnKey, value, true);
    });
    _this.state = {};
    return _this;
  }

  (0, _createClass2["default"])(CellModel, [{
    key: "componentDidMount",
    value: function componentDidMount() {
      if (process.env.__CLIENT__ == true) {
        try {
          ReferComp = _extend.extendComp.basic.Refer ? _extend.extendComp.basic.Refer : _refer["default"];
        } catch (e) {}
      }
    }
  }, {
    key: "componentWillReceiveProps",
    value: function componentWillReceiveProps(nextProps) {}
  }, {
    key: "setCellBlur",
    value: function setCellBlur(index, columnKey) {
      var data = {
        rowIndex: index,
        cellName: columnKey
      };
      this.props.setCellBlur(data);
    }
  }, {
    key: "onCellClick",
    value: function onCellClick(e, index, columnKey) {
      if (!this.props.Column.bCanModify) return;
      if (!this.props.cellState[index][columnKey].disabled && !this.props.cellState[index][columnKey].readOnly) this.props.onCellClick(e, index, columnKey);
    }
  }, {
    key: "setCell",
    value: function setCell() {
      var self = this;
      var property = this.props.RowProperty;
      var col = this.props.Column;
      var controlType = col.cControlType;
      var index = property.rowIndex;
      var cellState = {
        disabled: false,
        visible: false,
        readOnly: false,
        style: {}
      };
      var isColErro = this.props.isColErro;

      if (this.props.cellState[index] && this.props.cellState[index][property.columnKey]) {
        cellState.disabled = this.props.cellState[index][property.columnKey].disabled;
        cellState.visible = this.props.cellState[index][property.columnKey].visible;
        cellState.readOnly = this.props.cellState[index][property.columnKey].readOnly;
        cellState.style = cb.utils.extend(true, {}, this.props.cellState[index][property.columnKey].style);
        cellState.className = this.props.cellState[index][property.columnKey].className;
      }

      cellState.style.height = property.height;
      if (controlType && controlType.trim().toLocaleLowerCase() != 'avatar') cellState.style.padding = '12px 10px';
      cellState.style.lineHeight = '14px';

      if (isColErro) {
        cellState.style.height = cellState.style.height - 2;
        cellState.style.boxSizing = 'border-box';
        cellState.style.borderRadius = '5px';
        cellState.style.border = '1px solid #ff7733';
      }

      var data = this.props.dataList;

      if (data[index]) {
        if (col.cControlType == 'Action') {
          var actionList = this.props.action.controls;
          var rowHeight = this.props.rowHeight || 40;
          var aStyle = rowHeight - 40 == 0 ? {} : {
            'padding-top': (rowHeight - 40) / 2
          };
          var actionControl = [];

          if (actionList && actionList.length > 0) {
            var className = '';

            if (this.props.operationPos == 'right') {
              className = 'fix-operation';
              actionControl = this.buildRightActionControls(actionList);
            } else {
              actionControl = this.buildActionControls(actionList, true);
            }

            if (actionControl.length == 0) aStyle = {};
            return _react["default"].createElement("div", {
              style: {
                "width": property.width,
                "height": property.height,
                "borderBottom": "1px solid #dbe0e5"
              }
            }, _react["default"].createElement("div", {
              style: aStyle,
              className: "acticonCell ".concat(className)
            }, _react["default"].createElement(_row["default"], null, actionControl)));
          } else {
            return _react["default"].createElement("div", {
              className: "acticonCell"
            }, _react["default"].createElement(_row["default"], null));
          }
        } else {
          var _Cell = this.RemodelingCell(property, col, cellState);

          return _Cell;
        }
      }
    }
  }, {
    key: "buildRightActionControls",
    value: function buildRightActionControls(actionList) {
      var _this3 = this;

      if (!actionList) return;
      var data = this.props.dataList,
          index = this.props.RowProperty.rowIndex,
          actionState = this.props.actionState,
          actionControl = [];

      var _id = data[index] ? data[index]._id : 0;

      var basicAction = [],
          moreAction = [],
          showcount = 0;
      actionList.forEach(function (ac) {
        if (actionState[_id] && actionState[_id][ac.cItemName] && actionState[_id][ac.cItemName].visible) {
          showcount > 2 ? moreAction.push(ac) : basicAction.push(ac);
          showcount++;
        }
      });
      basicAction.map(function (action) {
        var _this2 = this;

        var icon = action.iStyle === 1 ? null : action.icon;
        var text = action.iStyle === 2 ? null : action.cShowCaption;
        var cItemName = action.cItemName;
        var viewModel = this.props.model.getParent();

        while (viewModel.getParent()) {
          viewModel = viewModel.getParent();
        }

        var caption = viewModel.getParams().caption;
        var temp_action = themeType == 'ncc' && (cItemName == 'btnDelete' || cItemName == 'btnDeleteRow') ? _react["default"].createElement(_baseui.Popconfirm, {
          overlayClassName: 'switch-popconform ncc-popconfirm',
          trigger: "click",
          placement: "top",
          title: "\u786E\u5B9A\u8981\u5220\u9664\u5417?",
          okText: "\u786E\u5B9A(Y)",
          cancelText: "\u53D6\u6D88(N)",
          btnReverse: true,
          onConfirm: function onConfirm(e) {
            return _this2.props.ActionClick(e, action);
          }
        }, _react["default"].createElement("span", {
          key: action.cItemName
        }, _react["default"].createElement("a", {
          className: "table-list-btn"
        }, text))) : _react["default"].createElement("span", {
          key: action.cItemName
        }, _react["default"].createElement("a", {
          className: "table-list-btn",
          onClick: function onClick(e) {
            return _this2.props.ActionClick(e, action);
          }
        }, text));
        actionControl.push(temp_action);
      }, this);

      if (moreAction.length) {
        var menuItems = moreAction.map(function (maction) {
          var icon = maction.iStyle === 1 ? null : maction.icon;
          var text = maction.iStyle === 2 ? null : maction.cShowCaption;
          return _react["default"].createElement(_baseui.Menu.Item, {
            className: "more-option"
          }, _react["default"].createElement("a", {
            className: "table-list-btn",
            onClick: function onClick(e) {
              return _this3.props.ActionClick(e, maction);
            },
            onMouseLeave: function onMouseLeave(event) {
              return _this3.props.onRowMouseLeave(event, index);
            },
            onMouseEnter: function onMouseEnter(event) {
              return _this3.props.onRowMouseEnter(event, index);
            }
          }, icon, text));
        });

        var menu = _react["default"].createElement(_baseui.Menu, null, menuItems);

        var moreControll = _react["default"].createElement(_baseui.Dropdown, {
          overlay: menu,
          trigger: "click",
          onClick: function onClick(e) {
            e.stopPropagation();
          }
        }, _react["default"].createElement("span", null, _react["default"].createElement("a", {
          className: "table-list-btn"
        }, "\u66F4\u591A")));

        actionControl.push(moreControll);
      }

      return actionControl;
    }
  }, {
    key: "buildActionControls",
    value: function buildActionControls(actionList, judge) {
      if (!actionList) return;
      var data = this.props.dataList,
          index = this.props.RowProperty.rowIndex,
          actionState = this.props.actionState,
          actionControl = [];

      var _id = data[this.props.showActionIndex] ? data[this.props.showActionIndex]._id : 0;

      actionList.map(function (action) {
        var _this4 = this;

        var icon = action.iStyle === 1 ? null : action.icon;
        var text = action.iStyle === 2 ? null : action.cShowCaption;
        var iconCom = !judge && icon ? _react["default"].createElement(_SvgIcon["default"], {
          className: 'icon-' + icon,
          type: icon
        }) : null;

        if (!judge || this.props.showActionIndex == index && actionState[_id] && actionState[_id][action.cItemName].visible) {
          if (action.cControlType != 'popbutton') {
            var extraProps = {};
            if (!action.popoverKey) extraProps.onClick = function (e) {
              return _this4.props.ActionClick(e, action);
            };

            var temp_action = _react["default"].createElement("span", {
              key: action.cItemName
            }, _react["default"].createElement("a", (0, _extends2["default"])({
              className: "table-list-btn"
            }, extraProps), iconCom, text));

            if (action.popoverKey) {
              var ComName = _extend.extendComp.popover[action.popoverKey];

              if (ComName) {
                temp_action = _react["default"].createElement(ComName, {
                  model: action.model,
                  data: data[this.props.showActionIndex]
                }, temp_action);
              }
            }

            actionControl.push(temp_action);
          } else {
            var currentRow = this.dataList[this.props.showActionIndex];
            if (!currentRow) return;
          }
        }
      }, this);
      return actionControl;
    }
  }, {
    key: "RemodelingCell",
    value: function RemodelingCell(rowIndex, col, cellState) {
      var _this5 = this;

      var cControlType = col.cControlType,
          formatter = col.formatter,
          bCanModify = col.bCanModify,
          bJointQuery = col.bJointQuery;
      var index = rowIndex.rowIndex;
      var columnKey = rowIndex.columnKey;
      var data = this.props.dataList;
      var CellStatus = this.state.CellStatus;
      var readOnly = this.props.readOnly;
      var className = "textCol";
      var cellClass = "retail-table-cell";
      cControlType = cControlType ? cControlType : 'Input';

      if (this.props.CellStatus[index]) {
        CellStatus = this.props.CellStatus[index][columnKey];
      }

      if (cControlType.trim().toLocaleLowerCase() == 'labelswitch') {
        CellStatus = false;
      }

      if (this.props.rowStatus[index] && this.props.rowStatus[index].disabled || !bCanModify || cellState.disabled) className = 'public_fixedDataTableCell_disabled textCol';

      if (cControlType === 'refer' || cControlType.trim().toLocaleLowerCase() === 'refer') {
        cellState.style.textAlign = 'left';
      }

      cellState.style.width = rowIndex.width;
      if (cellState.className && cellState.className != '') className = className + ' ' + cellState.className;
      if (col.className && col.className != '') className = className + ' ' + col.className;

      if (formatter && !CellStatus) {
        var cellObj = formatter(rowIndex, data[index]);

        if (cellObj) {
          if (cellObj.formatterKey) {
            var ComName = _extend.extendComp.formatter[cellObj.formatterKey];
            if (!ComName) return null;
            return _react["default"].createElement(_fixedDataTable.Cell, {
              width: rowIndex.width,
              height: rowIndex.height,
              className: cellClass
            }, _react["default"].createElement("div", {
              style: cellState.style,
              className: "textCol"
            }, _react["default"].createElement(ComName, (0, _extends2["default"])({
              model: this.props.model
            }, cellObj.props))));
          }

          var cellHtml = '',
              cellText = '';
          var cellProps = {};

          if (cellObj.html) {
            cellHtml += cellObj.html;
            cellText += cellObj.text || cellObj.html;
            Object.assign(cellProps, cellObj.props);
          }

          var cellCom = _react["default"].createElement("span", (0, _extends2["default"])({
            title: cellText,
            dangerouslySetInnerHTML: {
              __html: cellHtml
            }
          }, cellProps));

          cellState.style.padding = '0px 0px';
          if (this.props.readOnly) className = "textCol";
          return _react["default"].createElement(_fixedDataTable.Cell, {
            width: rowIndex.width,
            height: rowIndex.height,
            className: cellClass
          }, _react["default"].createElement("div", {
            style: cellState.style,
            className: className
          }, cellObj && cellObj.override ? null : _react["default"].createElement("span", {
            title: data[index][columnKey]
          }, data[index][columnKey]), cellCom));
        }
      }

      if (columnKey === 'GridRowNo') {
        return _react["default"].createElement(_fixedDataTable.Cell, {
          width: rowIndex.width,
          height: rowIndex.height
        }, _react["default"].createElement("div", {
          className: "rowNo",
          style: {
            "width": rowIndex.width,
            "height": rowIndex.height
          }
        }, index + 1));
      }

      var needMerge = false;

      if (this.props.mergeCells) {
        if (this.props.mergeColContrast[columnKey] && col.bMergeCol) needMerge = true;
        if (col.bMergeCol && columnKey === 'CheckBox') needMerge = true;
      }

      if (needMerge) {
        var _this$props = this.props,
            ColIndexs = _this$props.ColIndexs,
            mergeMode = _this$props.mergeMode,
            mergeSourceName = _this$props.mergeSourceName;
        var mergeColContrast = this.props.mergeColContrast;
        var dataLen = data.length;
        var nowColIndex = ColIndexs[columnKey];
        var hasMoreRow = dataLen > index + 1;
        var preRow = data[index - 1];
        var nowRow = data[index];
        var nextRow = data[index + 1];
        mergeColContrast[columnKey][index] = 0;

        if (mergeMode == 2 && !cb.utils.isEmpty(mergeSourceName)) {
          if (index == 0) {
            if (hasMoreRow) {
              if (nowRow[columnKey] == nextRow[columnKey] && nowRow[mergeSourceName] == nextRow[mergeSourceName]) {
                mergeColContrast[columnKey][index] = 1;
                this.props.setMergeColContrast(mergeColContrast);
                return _react["default"].createElement(_fixedDataTable.Cell, null);
              }
            }
          } else {
            if (mergeColContrast[columnKey][index - 1]) {
              if (nowRow[columnKey] == preRow[columnKey] && nowRow[mergeSourceName] == preRow[mergeSourceName]) {
                if (hasMoreRow && nowRow[columnKey] == nextRow[columnKey] && nowRow[mergeSourceName] == nextRow[mergeSourceName]) {
                  mergeColContrast[columnKey][index] = 1;
                  this.props.setMergeColContrast(mergeColContrast);
                  return _react["default"].createElement(_fixedDataTable.Cell, null);
                } else {
                  var count = this.getCount(mergeColContrast[columnKey], index);
                  cellState.style.marginTop = "-" + count * this.props.rowHeight / 2;
                  cellState.style.position = "absolute";
                  cellState.style.height = (this.props.rowHeight + count * this.props.rowHeight) / 2;
                  mergeColContrast[columnKey][index] = 2;
                }
              } else {
                if (hasMoreRow && nowRow[columnKey] == nextRow[columnKey] && nowRow[mergeSourceName] == nextRow[mergeSourceName]) {
                  mergeColContrast[columnKey][index] = 1;
                  this.props.setMergeColContrast(mergeColContrast);
                  return _react["default"].createElement(_fixedDataTable.Cell, null);
                }
              }
            } else {
              if (hasMoreRow && nowRow[columnKey] == nextRow[columnKey] && nowRow[mergeSourceName] == nextRow[mergeSourceName]) {
                mergeColContrast[columnKey][index] = 1;
                this.props.setMergeColContrast(mergeColContrast);
                return _react["default"].createElement(_fixedDataTable.Cell, null);
              }
            }
          }
        } else {
          if (index == 0) {
            if (hasMoreRow) {
              if (nowColIndex == 0) {
                if (nowRow[columnKey] == nextRow[columnKey]) {
                  mergeColContrast[columnKey][index] = 1;
                  this.props.setMergeColContrast(mergeColContrast);
                  return _react["default"].createElement(_fixedDataTable.Cell, null);
                }
              } else {
                var preColumnKey = this.getKeyByIndex(nowColIndex - 1, ColIndexs);

                if (mergeColContrast[preColumnKey][index] == 1 && nowRow[columnKey] == nextRow[columnKey] && nowRow[preColumnKey] == nextRow[preColumnKey]) {
                  mergeColContrast[columnKey][index] = 1;
                  this.props.setMergeColContrast(mergeColContrast);
                  return _react["default"].createElement(_fixedDataTable.Cell, null);
                }
              }
            }
          } else {
            if (nowColIndex == 0) {
              if (mergeColContrast[columnKey][index - 1] == 1) {
                if (nowRow[columnKey] == preRow[columnKey]) {
                  if (dataLen > index + 1 && nowRow[columnKey] == nextRow[columnKey]) {
                    mergeColContrast[columnKey][index] = 1;
                    this.props.setMergeColContrast(mergeColContrast);
                    return _react["default"].createElement(_fixedDataTable.Cell, null);
                  } else {
                    var _count = this.getCount(mergeColContrast[columnKey], index);

                    cellState.style.marginTop = "-" + _count * this.props.rowHeight / 2;
                    cellState.style.position = "absolute";
                    cellState.style.height = (this.props.rowHeight + _count * this.props.rowHeight) / 2;
                    mergeColContrast[columnKey][index] = 2;
                  }
                }
              } else {
                if (dataLen > index + 1 && nowRow[columnKey] == nextRow[columnKey]) {
                  mergeColContrast[columnKey][index] = 1;
                  return _react["default"].createElement(_fixedDataTable.Cell, null);
                }
              }
            } else {
              var _preColumnKey = this.getKeyByIndex(nowColIndex - 1, ColIndexs);

              var preColMerge = mergeColContrast[_preColumnKey][index];

              if (preColMerge == 1) {
                if (mergeColContrast[columnKey][index - 1]) {
                  if (nowRow[columnKey] == preRow[columnKey]) {
                    if (nowRow[columnKey] == nextRow[columnKey]) {
                      mergeColContrast[columnKey][index] = 1;
                      this.props.setMergeColContrast(mergeColContrast);
                      return _react["default"].createElement(_fixedDataTable.Cell, null);
                    } else {
                      var _count2 = this.getCount(mergeColContrast[columnKey], index);

                      cellState.style.marginTop = "-" + _count2 * this.props.rowHeight / 2;
                      cellState.style.position = "absolute";
                      cellState.style.height = (this.props.rowHeight + _count2 * this.props.rowHeight) / 2;
                      mergeColContrast[columnKey][index] = 2;
                    }
                  }
                } else {
                  if (nowRow[columnKey] == nextRow[columnKey]) {
                    mergeColContrast[columnKey][index] = 1;
                    this.props.setMergeColContrast(mergeColContrast);
                    return _react["default"].createElement(_fixedDataTable.Cell, null);
                  }
                }
              } else if (preColMerge == 2) {
                if (mergeColContrast[columnKey][index - 1]) {
                  if (nowRow[columnKey] == preRow[columnKey]) {
                    var _count3 = this.getCount(mergeColContrast[columnKey], index);

                    cellState.style.marginTop = "-" + _count3 * this.props.rowHeight / 2;
                    cellState.style.position = "absolute";
                    cellState.style.height = (this.props.rowHeight + _count3 * this.props.rowHeight) / 2;
                    mergeColContrast[columnKey][index] = 2;
                  }
                }
              }
            }
          }
        }

        this.props.setMergeColContrast(mergeColContrast);
      }

      if (columnKey === 'CheckBox') {
        delete cellState.style.position;
        return _react["default"].createElement(_fixedDataTable.Cell, {
          className: "yxy_cell_checkbox first-checkbox",
          width: rowIndex.width,
          height: rowIndex.height
        }, _react["default"].createElement("div", {
          style: cellState.style
        }, this.RemodelingEditControl(cControlType, index, columnKey, col)));
      }

      if ((cControlType == 'scheckbox' || cControlType == 'labelswitch' || cControlType == 'tag') && cControlType.trim().toLocaleLowerCase()) {
        cellState.style.textAlign = 'center';
        if (cControlType == 'labelswitch') cellState.style.pointerEvents = 'initial';

        if (this.props.selectIndex == index && cControlType !== 'labelswitch' && cControlType !== 'scheckbox') {
          return _react["default"].createElement(_fixedDataTable.Cell, {
            width: rowIndex.width,
            height: rowIndex.height
          }, _react["default"].createElement("div", {
            style: cellState.style,
            className: className
          }, this.RemodelingEditControl(cControlType, index, columnKey, col)));
        } else {
          return _react["default"].createElement(_fixedDataTable.Cell, {
            width: rowIndex.width,
            height: rowIndex.height
          }, _react["default"].createElement("div", {
            style: cellState.style,
            className: className
          }, this.RemodelingFormatControl(cControlType, data[index][columnKey], bJointQuery, index, columnKey, col)));
        }
      }

      if (cControlType == 'CheckRadio' && !CellStatus && !readOnly) {
        cellState.style.padding = '4px 10px';
      }

      if (readOnly) {
        var title = data[index][columnKey];

        if (!cb.utils.isEmpty(title) && (0, _typeof2["default"])(title) === 'object') {
          title = title.text;
        }

        var cName = "textCol";
        if (cellState.className && cellState.className != '') cName = cName + '  ' + cellState.className;
        if (col.className && col.className != '') cName = cName + '  ' + col.className;
        return _react["default"].createElement(_fixedDataTable.Cell, {
          width: rowIndex.width,
          height: rowIndex.height,
          className: "retail-table-cell"
        }, _react["default"].createElement("div", {
          title: title,
          className: cName,
          style: cellState.style
        }, this.RemodelingFormatControl(cControlType, data[index][columnKey], bJointQuery, index, columnKey, col)));
      }

      if (!cellState) {
        className = className + 'formatCol';
      }

      return CellStatus ? _react["default"].createElement(_fixedDataTable.Cell, {
        width: rowIndex.width,
        height: rowIndex.height,
        className: cellClass
      }, _react["default"].createElement("div", {
        className: "editCol",
        style: cellState.style
      }, this.RemodelingEditControl(cControlType, index, columnKey, col))) : _react["default"].createElement(_fixedDataTable.Cell, {
        width: rowIndex.width,
        height: rowIndex.height,
        className: cellClass
      }, _react["default"].createElement("div", {
        style: cellState.style,
        className: className,
        onClick: function onClick(e) {
          return _this5.onCellClick(e, index, columnKey);
        }
      }, this.RemodelingFormatControl(cControlType, data[index][columnKey], bJointQuery, index, columnKey, col)));
    }
  }, {
    key: "RemodelingEditControl",
    value: function RemodelingEditControl(controlType, index, columnKey, col) {
      var _this6 = this;

      var model = this.props.model.getEditRowModel().get(columnKey);
      var disabled = false;
      var NumPoint = 1;

      if (col.iNumPoint && col.iNumPoint > 1) {
        NumPoint = 0.1;
        NumPoint = Math.pow(NumPoint, col.iNumPoint).toFixed(col.iNumPoint);
      }

      if (this.props.rowStatus[index]) disabled = this.props.rowStatus[index].disabled;

      switch (controlType && controlType.trim().toLocaleLowerCase()) {
        case 'input':
          return _react["default"].createElement(_input["default"], {
            focus: true,
            model: model
          });

        case 'hotkeyinput':
          return _react["default"].createElement(_hotkeyinput["default"], {
            focus: true,
            model: model
          });

        case 'inputnumber':
        case 'money':
        case 'price':
          if (controlType === 'money') NumPoint = cb.rest.AppContext.option.amountofdecimal;else if (controlType === 'price') NumPoint = cb.rest.AppContext.option.monovalentdecimal;
          var iNumPoint = col.iNumPoint;
          var _format = {};

          if (col.cFormatData) {
            try {
              _format = JSON.parse(col.cFormatData);
            } catch (e) {}
          }

          var relatedName = _format.related;

          if (relatedName && !relatedName.startsWith('parentdata.')) {
            var relatedValue = (0, _util.getRoundValue)(this.props.dataList[index][relatedName], 0);
            iNumPoint = relatedValue > 0 ? relatedValue : 0;
          }

          model._set_data('iNumPoint', iNumPoint, true);

          return _react["default"].createElement(_inputnumber["default"], {
            className: 'edit-input-number',
            focus: true,
            model: model,
            iNumPoint: iNumPoint,
            cFormatData: col.cFormatData,
            cStyle: col.cStyle
          });

        case 'datepicker':
          return _react["default"].createElement(_datepicker["default"], {
            model: model,
            className: 'edit-input-number',
            cFormatData: col.cFormatData
          });

        case 'timepicker':
          return _react["default"].createElement(_timepicker["default"], {
            model: model,
            className: "edit-input-number"
          });

        case 'select':
          return _react["default"].createElement(_select["default"], {
            focus: true,
            model: model,
            className: 'edit-input-number'
          });

        case 'refer':
          return _react["default"].createElement(ReferComp, {
            focus: true,
            model: model,
            inTable: true,
            title: col.cShowCaption,
            relatedControl: this.buildActionControls(col.relatedActions)
          });

        case 'specialcom':
          return _react["default"].createElement(_functypes["default"], {
            focus: true,
            model: model,
            value: this.getSpecalValue1(index),
            relatedControl: this.buildActionControls(col.relatedActions),
            title: this.props.Column.cShowCaption
          });

        case 'switch':
          return _react["default"].createElement(_switch["default"], {
            focus: true,
            model: model,
            className: 'edit-input-number',
            style: {
              width: '50%'
            },
            readOnly: false,
            checkedChildren: "\u662F",
            unCheckedChildren: "\u5426"
          });

        case 'checkradio':
          return _react["default"].createElement(_checkradio["default"], {
            focus: true,
            model: model,
            className: 'edit-input-number',
            style: {
              width: '50%'
            },
            readOnly: false
          });

        case 'selectcheckbox':
          if (this.props.GridProps.isRadio) return _react["default"].createElement(_baseui.Radio, {
            checked: this.props.dataList[index]._selected,
            onChange: function onChange(e) {
              return _this6.SelectChange(e, index);
            }
          });else return _react["default"].createElement(_checkbox["default"], {
            value: this.props.dataList[index]._selected,
            onChange: function onChange(e, i) {
              return _this6.SelectChange(e, index);
            }
          });

        case 'labelswitch':
          return _react["default"].createElement(_labelswitch["default"], {
            focus: true,
            model: model,
            style: {
              width: '50%'
            },
            readOnly: false,
            checkedChildren: "\u542F",
            unCheckedChildren: "\u505C",
            cStyle: col.cStyle
          });

        case 'scheckbox':
          return _react["default"].createElement(_checkbox["default"], {
            model: model,
            disabled: disabled
          });

        case 'tag':
          return disabled ? _react["default"].createElement(_tag["default"], {
            model: model,
            disabled: true,
            color: '',
            closable: false,
            cRefType: this.props.Column.cRefType,
            refReturn: this.props.Column.refReturn,
            cRefRetId: this.props.Column.cRefRetId
          }) : _react["default"].createElement(_tag["default"], {
            model: model,
            disabled: false,
            color: 'blue',
            closable: true,
            cRefType: this.props.Column.cRefType,
            refReturn: this.props.Column.refReturn,
            cRefRetId: this.props.Column.cRefRetId
          });

        case 'treerefer':
          return _react["default"].createElement(_treerefer["default"], {
            model: model
          });

        case 'listrefer':
          return _react["default"].createElement(_listrefer["default"], {
            model: model
          });

        case 'cascader':
          return _react["default"].createElement(_cascader["default"], {
            model: model
          });

        case 'composite':
          var compositeControl = this.props.compositeControl[index][columnKey];
          var rowModel = this.props.model.getEditRowModel();
          return _react["default"].createElement(_CompositeModel["default"], {
            compositeControl: compositeControl,
            visible: false,
            width: col.iColWidth,
            height: this.props.rowHeight,
            cellState: this.props.cellState[index][columnKey],
            rowModel: rowModel,
            setCellBlur: function setCellBlur() {
              return _this6.setCellBlur(index, columnKey);
            }
          });

        case 'uncertain':
          return _react["default"].createElement(_UncertainControl["default"], (0, _extends2["default"])({
            model: model,
            cellConfig: this.props.dataList[index].cellConfig || null
          }, this.props));

        case 'inputmultilang':
          return _react["default"].createElement(_InputMultiLang["default"], (0, _extends2["default"])({
            focus: true,
            model: model
          }, col));
      }
    }
  }, {
    key: "switchChange",
    value: function switchChange(value, index, columnKey) {
      this.props.dataList[index][columnKey] = value;
      this.props.model.setFocusedRowIndex(index);
      this.props.model.setCellValue(index, columnKey, this.props.dataList[index][columnKey], true);
    }
  }, {
    key: "CheckBoxOnChange",
    value: function CheckBoxOnChange(value, index, columnKey) {
      this.props.dataList[index][columnKey] = value;
      this.props.model.setFocusedRowIndex(index);
      this.props.model.setCellValue(index, columnKey, value, true);
    }
  }, {
    key: "referClikc",
    value: function referClikc(index, columnKey) {
      this.props.model.setFocusedRowIndex(index);
      var model = this.props.model.getEditRowModel().get(columnKey);
      model.browse();
    }
  }, {
    key: "TagOnClose",
    value: function TagOnClose(key, index, columnKey) {
      this.props.model.setFocusedRowIndex(index);
      var model = this.props.model.getEditRowModel().get(columnKey);
      model.deleteItem(key);
    }
  }, {
    key: "RemodelingFormatControl",
    value: function RemodelingFormatControl(controlType, text, bJointQuery, index, columnKey, col) {
      var _this7 = this;

      var disabled = false;
      if (this.props.rowStatus[index]) disabled = this.props.rowStatus[index].disabled;

      switch (controlType && controlType.trim().toLocaleLowerCase()) {
        case 'refer':
        case 'treerefer':
        case 'listrefer':
          {
            var formatText = text != null && (0, _typeof2["default"])(text) === 'object' ? text.name : text;
            return bJointQuery ? _react["default"].createElement("a", {
              onClick: function onClick(e) {
                return _this7.handleJointQuery(e, index, columnKey);
              }
            }, formatText) : formatText;
          }

        case 'radio':
        case 'checkboxenum':
        case 'select':
          {
            if (cb.utils.isEmpty(text)) return text;
            var _formatText = null;
            if ((0, _typeof2["default"])(text) !== 'object') _formatText = text;else if (text.nameType === 'icontext') _formatText = _react["default"].createElement("span", null, _react["default"].createElement(_baseui.Icon, {
              type: text.icon
            }), text.text);else if (text.nameType === 'icon') _formatText = _react["default"].createElement(_baseui.Icon, {
              type: text.icon
            });else _formatText = text.text;
            return bJointQuery ? _react["default"].createElement("a", {
              onClick: function onClick(e) {
                return _this7.handleJointQuery(e, index, columnKey);
              }
            }, _formatText) : _formatText;
            return (0, _typeof2["default"])(text) === 'object' ? text.text : text;
          }

        case 'switch':
          return _react["default"].createElement(_switch["default"], {
            className: 'edit-input-number',
            checked: Boolean(text),
            readOnly: true,
            checkedChildren: "\u662F",
            unCheckedChildren: "\u5426"
          });

        case 'checkradio':
          return _react["default"].createElement(_checkradio["default"], {
            focus: true,
            className: 'edit-input-number',
            checked: Boolean(text),
            style: {
              width: '50%'
            },
            onChange: function onChange(checked) {
              return _this7.onCrChange(checked, index, columnKey);
            },
            readOnly: this.props.readOnly
          });

        case 'vouchermoney':
          var money = this.buildMoney(text);
          return money;

        case 'labelswitch':
          var viewModel = this.props.model.getParent();
          return _react["default"].createElement(_labelswitch["default"], {
            disabled: !col.bCanModify,
            viewModel: viewModel,
            checkedChildren: '√',
            unCheckedChildren: 'X',
            value: text,
            onChange: function onChange(checked) {
              return _this7.switchChange(checked, index, columnKey);
            },
            cStyle: col.cStyle,
            index: index
          });

        case 'switchlabel':
          return _react["default"].createElement(_switchlabel["default"], {
            value: text
          });

        case 'scheckbox':
          return _react["default"].createElement(_checkbox["default"], {
            disabled: !col.bCanModify,
            value: text,
            onChange: function onChange(value) {
              return _this7.CheckBoxOnChange(value, index, columnKey);
            }
          });

        case 'tag':
          return _react["default"].createElement(_tag["default"], {
            disabled: disabled,
            cRefType: this.props.Column.cRefType,
            refReturn: this.props.Column.refReturn,
            cRefRetId: this.props.Column.cRefRetId,
            closable: !disabled,
            tagData: text,
            color: 'blue',
            onClose: function onClose(key) {
              return _this7.TagOnClose(key, index, columnKey);
            },
            referClikc: function referClikc() {
              return _this7.referClikc(index, columnKey);
            }
          });

        case 'composite':
          var CompositeJson = JSON.parse(this.props.CompositeLayout[index][columnKey]);
          var compositeData = this.analysisComposite(CompositeJson, index);
          return compositeData;

        case 'inputnumber':
        case 'money':
        case 'price':
          if (cb.utils.isEmpty(text)) return '';
          if (isNaN(text)) return text;
          var cFormatData = this.props.Column.cFormatData;

          try {
            if (!cFormatData || cFormatData == '') {
              cFormatData = {};
            } else {
              cFormatData = JSON.parse(cFormatData);
            }
          } catch (e) {
            cb.utils.alert('数量/金额/单价，预制错误！', 'error');
          }

          var iNumPoint = this.props.Column.iNumPoint;
          var relatedName = cFormatData.related;

          if (relatedName && !relatedName.startsWith('parentdata.')) {
            var relatedValue = (0, _util.getRoundValue)(this.props.dataList[index][relatedName], 0);
            iNumPoint = relatedValue > 0 ? relatedValue : 0;
          }

          var decimal = cFormatData.decimal ? (0, _util.getPredicateValue)(cFormatData.decimal) : null;

          if (controlType === 'money') {
            if (decimal) iNumPoint = decimal;else iNumPoint = cb.rest.AppContext.option.amountofdecimal;
          } else if (controlType === 'price') {
            if (decimal) iNumPoint = decimal;else iNumPoint = cb.rest.AppContext.option.monovalentdecimal;
          } else {
            if (decimal) iNumPoint = decimal;else if (cb.utils.isEmpty(iNumPoint)) iNumPoint = null;
          }

          if (!isNaN(iNumPoint) && iNumPoint != null) {
            text = parseFloat(text);
            text = (0, _util.getRoundValue)(text, iNumPoint);
          }

          var formatterForSplitter = function formatterForSplitter(value) {
            var _value = value + '';

            var _valueArr = _value.split('.');

            if (_valueArr.length == 1) {
              return "".concat(format.before || '').concat(_value.replace(/\B(?=(\d{3})+(?!\d))/g, ',')).concat(format.after || '');
            } else {
              _valueArr[0] = _valueArr[0].replace(/\B(?=(\d{3})+(?!\d))/g, ',');
              return "".concat(format.before || '').concat(_valueArr.join('.')).concat(format.after || '');
            }
          };

          if (cFormatData.splitter) text = formatterForSplitter(text);
          if (cFormatData.before) text = cFormatData.before + text;
          if (cFormatData.after) text = text + cFormatData.after;
          return text;

        case 'datepicker':
          if (text) {
            var fmt = 'YYYY-MM-dd';

            if (this.props.Column.cFormatData && this.props.Column.cFormatData != '') {
              fmt = this.props.Column.cFormatData;
            }

            if (cb.utils.isIE()) {
              text = text.replace(/\-/g, "/");
              fmt = fmt.replace(/\-/g, "/");
            }

            text = format.dateFormat(new Date(text), fmt);
          }

          return text;

        case 'avatar':
          var displaymode = 'default';
          var cStyle = this.props.Column.cStyle;

          if (cStyle) {
            try {
              displaymode = JSON.parse(cStyle).displaymode || displaymode;
            } catch (e) {}
          }

          var className = "cell-avatar-".concat(displaymode);

          if (!text || text == '') {
            return _react["default"].createElement("div", {
              className: "no-avatar-man ".concat(className)
            });
          } else {
            var style = {};
            style.height = this.props.rowHeight;
            style.width = this.props.rowHeight;
            return _react["default"].createElement("img", {
              className: className,
              src: text + '?imageView2/1/w/80/h/80',
              style: style
            });
          }

        case 'uncertain':
          text = this.getUncertainFormatValue(text, index, columnKey);
          return text;

        case 'specialcom':
          text = this.getSpecalValue(index);
          return text;

        case 'inputmultilang':
          if (cb.utils.isEmpty(text)) {
            return '';
          }

          return text;
      }

      if (text === '') return '';
      if (text && (0, _typeof2["default"])(text) === 'object') text = '';
      return bJointQuery ? _react["default"].createElement("a", {
        onClick: function onClick(e) {
          return _this7.handleJointQuery(e, index, columnKey);
        }
      }, text) : text;
    }
  }, {
    key: "getSpecalValue1",
    value: function getSpecalValue1(index) {
      var column = this.props.Column;
      var cStyle = column.cStyle;

      try {
        cStyle = JSON.parse(cStyle);
      } catch (e) {
        cb.utils.alert('specialcom  cstyle预制错误！');
        return;
      }

      var _cStyle = cStyle,
          Separator = _cStyle.Separator,
          dataSource = _cStyle.dataSource,
          columns = _cStyle.columns;
      var row = this.props.dataList[index];
      var data = row[dataSource];
      var cols = columns.split(',');
      var controls = [];
      if (!Separator) Separator = '';
      data && data.map(function (row) {
        var temp = [];
        var colLen = cols ? cols.length : 0;
        cols && cols.map(function (col, index) {
          if (index == colLen - 1) {
            temp.push(row[col]);
          } else {
            temp.push(row[col]);
            temp.push(Separator);
          }
        });
        controls.push(temp);
      });
      return controls;
    }
  }, {
    key: "getSpecalValue",
    value: function getSpecalValue(index) {
      var column = this.props.Column;
      var cStyle = column.cStyle;

      try {
        cStyle = JSON.parse(cStyle);
      } catch (e) {
        cb.utils.alert('specialcom  cstyle预制错误！');
        return;
      }

      var _cStyle2 = cStyle,
          Separator = _cStyle2.Separator,
          dataSource = _cStyle2.dataSource,
          columns = _cStyle2.columns;
      var row = this.props.dataList[index];
      var data = row[dataSource];
      var cols = columns.split(',');
      var controls = [];
      if (!Separator) Separator = '';
      data && data.map(function (row) {
        var temp = [];
        var colLen = cols ? cols.length : 0;
        cols && cols.map(function (col, index) {
          if (index == colLen - 1) {
            temp.push(_react["default"].createElement("div", {
              className: "special_col"
            }, row[col]));
          } else {
            temp.push(_react["default"].createElement("div", {
              className: "special_col"
            }, row[col]));
            temp.push(_react["default"].createElement("div", {
              className: "special_separator"
            }, Separator));
          }
        });
        controls.push(_react["default"].createElement("div", {
          className: "special-row"
        }, temp));
      });
      return _react["default"].createElement("div", {
        className: "special-rows func-share"
      }, controls);
    }
  }, {
    key: "getUncertainFormatValue",
    value: function getUncertainFormatValue(text, index, columnKey) {
      if (this.props.dataList[index][columnKey] == null || this.props.dataList[index][columnKey] == "") return "";
      var cellConfig = this.props.dataList[index].cellConfig || null;
      if (!cellConfig) return text;
      var controlType = cellConfig.cControlType;

      switch (controlType && controlType.trim().toLocaleLowerCase()) {
        case 'refer':
        case 'treerefer':
        case 'listrefer':
          return text;

        case 'select':
        case 'radio':
        case 'checkboxenum':
          var cEnumString = cellConfig.cEnumString;

          try {
            if (!cEnumString || cEnumString == '') {
              cEnumString = {};
            } else {
              cEnumString = JSON.parse(cEnumString);
            }
          } catch (e) {
            cb.utils.alert('cEnumString，预制错误！', 'error');
          }

          if ((0, _typeof2["default"])(text) === 'object') {
            var temp = '';
            text.map(function (t) {
              temp = temp == '' ? cEnumString[t] : temp + ',' + cEnumString[t];
            });
            text = temp;
          } else {
            if (text && text.split(',') && text.split(',').length > 1) {
              var tem_text = text.split(',');
              text = '';