vxe-gantt
Version:
A vue based gantt component
3,146 lines • 112 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _vue = require("vue");
var _comp = require("../../ui/src/comp");
var _xeUtils = _interopRequireDefault(require("xe-utils"));
var _utils = require("../../ui/src/utils");
var _dom = require("../../ui/src/dom");
var _vn = require("../../ui/src/vn");
var _core = require("@vxe-ui/core");
var _emits = require("./emits");
var _util = require("./util");
var _tableEmits = require("./table-emits");
var _log = require("../../ui/src/log");
var _ganttView = _interopRequireDefault(require("./gantt-view"));
var _vxeTable = require("vxe-table");
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
const {
warnLog,
errLog
} = (0, _log.createComponentLog)('gantt');
const {
getConfig,
getIcon,
getI18n,
commands,
hooks,
useFns,
createEvent,
globalEvents,
GLOBAL_EVENT_KEYS,
renderEmptyElement
} = _core.VxeUI;
const tableProps = _vxeTable.VxeTable.props;
const tableComponentPropKeys = Object.keys(tableProps);
const tableComponentMethodKeys = ['clearAll', 'syncData', 'updateData', 'loadData', 'reloadData', 'reloadRow', 'loadColumn', 'reloadColumn', 'getRowNode', 'getColumnNode', 'getRowIndex', 'getVTRowIndex', 'getVMRowIndex', 'getColumnIndex', 'getVTColumnIndex', 'getVMColumnIndex', 'setRow', 'createData', 'createRow', 'revertData', 'clearData', 'isRemoveByRow', 'isInsertByRow', 'isUpdateByRow', 'getColumns', 'getColumnById', 'getColumnByField', 'getTableColumn', 'getFullColumns', 'getData', 'getCheckboxRecords', 'getParentRow', 'getTreeRowChildren', 'getTreeRowLevel', 'getTreeParentRow', 'getRowSeq', 'getRowById', 'getRowid', 'getTableData', 'getFullData', 'setColumnFixed', 'clearColumnFixed', 'setColumnWidth', 'getColumnWidth', 'recalcRowHeight', 'setRowHeightConf', 'getRowHeightConf', 'setRowHeight', 'getRowHeight', 'hideColumn', 'showColumn', 'resetColumn', 'refreshColumn', 'refreshScroll', 'recalculate', 'closeTooltip', 'isAllCheckboxChecked', 'isAllCheckboxIndeterminate', 'getCheckboxIndeterminateRecords', 'setCheckboxRow', 'setCheckboxRowKey', 'isCheckedByCheckboxRow', 'isCheckedByCheckboxRowKey', 'isIndeterminateByCheckboxRow', 'isIndeterminateByCheckboxRowKey', 'toggleCheckboxRow', 'setAllCheckboxRow', 'getRadioReserveRecord', 'clearRadioReserve', 'getCheckboxReserveRecords', 'clearCheckboxReserve', 'toggleAllCheckboxRow', 'clearCheckboxRow', 'setCurrentRow', 'isCheckedByRadioRow', 'isCheckedByRadioRowKey', 'setRadioRow', 'setRadioRowKey', 'clearCurrentRow', 'clearRadioRow', 'getCurrentRecord', 'getRadioRecord', 'getCurrentColumn', 'setCurrentColumn', 'clearCurrentColumn', 'setPendingRow', 'togglePendingRow', 'hasPendingByRow', 'isPendingByRow', 'getPendingRecords', 'clearPendingRow', 'setFilterByEvent', 'sort', 'setSort', 'setSortByEvent', 'clearSort', 'clearSortByEvent', 'isSort', 'getSortColumns', 'closeFilter', 'isFilter', 'clearFilterByEvent', 'isActiveFilterByColumn', 'isRowExpandLoaded', 'clearRowExpandLoaded', 'reloadRowExpand', 'reloadRowExpand', 'toggleRowExpand', 'setAllRowExpand', 'setRowExpand', 'isExpandByRow', 'isRowExpandByRow', 'clearRowExpand', 'clearRowExpandReserve', 'getRowExpandRecords', 'getTreeExpandRecords', 'isTreeExpandLoaded', 'clearTreeExpandLoaded', 'reloadTreeExpand', 'reloadTreeChilds', 'toggleTreeExpand', 'setAllTreeExpand', 'setTreeExpand', 'isTreeExpandByRow', 'clearTreeExpand', 'clearTreeExpandReserve', 'getScroll', 'scrollTo', 'scrollToStartRow', 'scrollToEndRow', 'scrollToRow', 'scrollToStartColumn', 'scrollToEndColumn', 'scrollToColumn', 'clearScroll', 'updateFooter', 'updateStatus', 'setMergeCells', 'removeInsertRow', 'removeMergeCells', 'getMergeCells', 'clearMergeCells', 'setMergeFooterItems', 'removeMergeFooterItems', 'getMergeFooterItems', 'clearMergeFooterItems', 'getCustomStoreData', 'setRowGroupExpand', 'setRowGroupExpandByField', 'setAllRowGroupExpand', 'clearRowGroupExpand', 'isRowGroupExpandByRow', 'isRowGroupRecord', 'isAggregateRecord', 'isAggregateExpandByRow', 'getAggregateContentByRow', 'getAggregateRowChildren', 'setRowGroups', 'clearRowGroups', 'openTooltip', 'moveColumnTo', 'moveRowTo', 'getCellLabel', 'undo', 'redo', 'getCellElement', 'focus', 'blur', 'connect'];
const defaultLayouts = [['Form'], ['Toolbar', 'Top', 'Gantt', 'Bottom', 'Pager']];
function createInternalData() {
return {
linkFromConfMaps: {},
linkToConfMaps: {},
linkUniqueMaps: {},
uFoot: false,
resizeTableWidth: 0,
// barTipTimeout: null,
// dragBarRow: null,
// dragLineRow: null,
dragLinkToStore: {
rowid: null,
type: 0
},
// 关键路径
criticalRowList: [],
criticalRowMaps: new Map(),
criticalLinkKeyMaps: new Map()
};
}
function createReactData() {
var _a;
return {
tableLoading: false,
proxyInited: false,
// 是否存在纵向滚动条
overflowY: false,
// 是否存在横向滚动条
overflowX: false,
// 纵向滚动条的宽度
scrollbarWidth: 0,
// 横向滚动条的高度
scrollbarHeight: 0,
isZMax: false,
tableLinks: [],
tableData: [],
filterData: [],
formData: {},
sortData: [],
footerData: [],
tZindex: 0,
tablePage: {
total: 0,
pageSize: ((_a = getConfig().pager) === null || _a === void 0 ? void 0 : _a.pageSize) || 10,
currentPage: 1
},
showLeftView: true,
showRightView: true,
taskScaleList: [],
barTipStore: {
row: null,
content: '',
visible: false,
params: null
},
dragLinkFromStore: {
rowid: null,
type: 0
},
activeBarRowid: null,
activeLink: null,
isActiveCeLe: false,
linkList: [],
upLinkFlag: 0,
showSplitAnimat: false,
nowTime: 0,
currLeftSpacing: 0,
currRightSpacing: 0,
// 关键路径
criticalLinks: [],
criticalRowIds: [],
criticalPathFlag: 0
};
}
const viewTypeLevelMaps = {
year: 19,
quarter: 17,
month: 15,
week: 13,
day: 11,
date: 9,
hour: 7,
minute: 5,
second: 3
};
function getViewTypeLevel(type) {
return viewTypeLevelMaps[type || 'date'] || viewTypeLevelMaps.date;
}
var _default = exports.default = (0, _comp.defineVxeComponent)({
name: 'VxeGantt',
mixins: [],
props: Object.assign(Object.assign({}, tableProps), {
columns: Array,
pagerConfig: Object,
proxyConfig: Object,
toolbarConfig: Object,
formConfig: Object,
zoomConfig: Object,
links: Array,
layouts: Array,
taskConfig: Object,
taskViewScaleConfig: Object,
taskNowLineConfig: Object,
taskViewConfig: Object,
taskLinkConfig: Object,
taskBarConfig: Object,
taskBarMilestoneConfig: Object,
taskCriticalPathConfig: Object,
taskBarSubviewConfig: Object,
taskBarTooltipConfig: Object,
taskSplitConfig: Object,
taskBarResizeConfig: Object,
taskBarResizeTooltipConfig: Object,
taskBarMoveConfig: Object,
taskBarMoveTooltipConfig: Object,
size: {
type: String,
default: () => getConfig().gantt.size || getConfig().size
}
}),
emits: _emits.ganttEmits,
setup(props, context) {
const {
slots,
emit
} = context;
const xID = _xeUtils.default.uniqueId();
// 使用已安装的组件，如果未安装则不渲染
const VxeUIFormComponent = _core.VxeUI.getComponent('VxeForm');
const VxeUIPagerComponent = _core.VxeUI.getComponent('VxePager');
const VxeTableComponent = _core.VxeUI.getComponent('VxeTable');
const VxeToolbarComponent = _core.VxeUI.getComponent('VxeToolbar');
const VxeUITooltipComponent = _core.VxeUI.getComponent('VxeTooltip');
const {
computeSize
} = useFns.useSize(props);
const reactData = (0, _vue.reactive)(createReactData());
const internalData = createInternalData();
const refElem = (0, _vue.ref)();
const refTable = (0, _vue.ref)();
const refForm = (0, _vue.ref)();
const refToolbar = (0, _vue.ref)();
const refPager = (0, _vue.ref)();
const refGanttContainerElem = (0, _vue.ref)();
const refClassifyWrapperElem = (0, _vue.ref)();
const refGanttView = (0, _vue.ref)();
const refPopupContainerElem = (0, _vue.ref)();
const refFormWrapper = (0, _vue.ref)();
const refToolbarWrapper = (0, _vue.ref)();
const refTopWrapper = (0, _vue.ref)();
const refBottomWrapper = (0, _vue.ref)();
const refPagerWrapper = (0, _vue.ref)();
const refTableWrapper = (0, _vue.ref)();
const refGanttWrapper = (0, _vue.ref)();
const refTooltip = (0, _vue.ref)();
const refResizableSplitTip = (0, _vue.ref)();
const extendTableMethods = methodKeys => {
const funcs = {};
methodKeys.forEach(name => {
funcs[name] = (...args) => {
const $xeTable = refTable.value;
if ($xeTable && $xeTable[name]) {
return $xeTable[name](...args);
}
};
});
return funcs;
};
const ganttExtendTableMethods = extendTableMethods(tableComponentMethodKeys);
tableComponentMethodKeys.forEach(name => {
ganttExtendTableMethods[name] = (...args) => {
const $xeTable = refTable.value;
if ($xeTable && $xeTable[name]) {
return $xeTable && $xeTable[name](...args);
}
};
});
const computeProxyOpts = (0, _vue.computed)(() => {
return _xeUtils.default.merge({}, _xeUtils.default.clone(getConfig().gantt.proxyConfig, true), props.proxyConfig);
});
const computeIsRespMsg = (0, _vue.computed)(() => {
const proxyOpts = computeProxyOpts.value;
return !!(_xeUtils.default.isBoolean(proxyOpts.message) ? proxyOpts.message : proxyOpts.showResponseMsg);
});
const computeIsActiveMsg = (0, _vue.computed)(() => {
const proxyOpts = computeProxyOpts.value;
return _xeUtils.default.isBoolean(proxyOpts.showActionMsg) ? proxyOpts.showActionMsg : !!proxyOpts.showActiveMsg;
});
const computePagerOpts = (0, _vue.computed)(() => {
return Object.assign({}, getConfig().gantt.pagerConfig, props.pagerConfig);
});
const computeFormOpts = (0, _vue.computed)(() => {
return Object.assign({}, getConfig().gantt.formConfig, props.formConfig);
});
const computeToolbarOpts = (0, _vue.computed)(() => {
return Object.assign({}, getConfig().gantt.toolbarConfig, props.toolbarConfig);
});
const computeZoomOpts = (0, _vue.computed)(() => {
return Object.assign({}, getConfig().gantt.zoomConfig, props.zoomConfig);
});
const computeTaskOpts = (0, _vue.computed)(() => {
return Object.assign({}, getConfig().gantt.taskConfig, props.taskConfig);
});
const computeTaskViewScaleOpts = (0, _vue.computed)(() => {
return _xeUtils.default.merge({}, getConfig().gantt.taskViewScaleConfig, props.taskViewScaleConfig);
});
const computeTaskNowLineOpts = (0, _vue.computed)(() => {
return Object.assign({}, getConfig().gantt.taskNowLineConfig, props.taskNowLineConfig);
});
const computeTaskViewOpts = (0, _vue.computed)(() => {
return Object.assign({}, getConfig().gantt.taskViewConfig, props.taskViewConfig);
});
const computeTaskBarOpts = (0, _vue.computed)(() => {
return Object.assign({}, getConfig().gantt.taskBarConfig, props.taskBarConfig);
});
const computeTaskBarMoveOpts = (0, _vue.computed)(() => {
return Object.assign({}, getConfig().gantt.taskBarMoveConfig, props.taskBarMoveConfig);
});
const computeTaskBarMoveTooltipOpts = (0, _vue.computed)(() => {
return Object.assign({}, getConfig().gantt.taskBarMoveTooltipConfig, props.taskBarMoveTooltipConfig);
});
const computeTaskBarResizeOpts = (0, _vue.computed)(() => {
return Object.assign({}, getConfig().gantt.taskBarResizeConfig, props.taskBarResizeConfig);
});
const computeTaskBarResizeTooltipOpts = (0, _vue.computed)(() => {
return Object.assign({}, getConfig().gantt.taskBarResizeTooltipConfig, props.taskBarResizeTooltipConfig);
});
const computeTaskSplitOpts = (0, _vue.computed)(() => {
return Object.assign({}, getConfig().gantt.taskSplitConfig, props.taskSplitConfig);
});
const computeTaskBarMilestoneOpts = (0, _vue.computed)(() => {
return Object.assign({}, getConfig().gantt.taskBarMilestoneConfig, props.taskBarMilestoneConfig);
});
const computeTaskCriticalPathOpts = (0, _vue.computed)(() => {
return Object.assign({}, getConfig().gantt.taskCriticalPathConfig, props.taskCriticalPathConfig);
});
const computeTaskBarSubviewOpts = (0, _vue.computed)(() => {
return Object.assign({}, getConfig().gantt.taskBarSubviewConfig, props.taskBarSubviewConfig);
});
const computeTaskBarTooltipOpts = (0, _vue.computed)(() => {
return Object.assign({}, getConfig().gantt.taskBarTooltipConfig, props.taskBarTooltipConfig);
});
const computeTaskLinkOpts = (0, _vue.computed)(() => {
return Object.assign({}, getConfig().gantt.taskLinkConfig, props.taskLinkConfig);
});
const computeDateFormat = (0, _vue.computed)(() => {
const taskOpts = computeTaskOpts.value;
const {
dateFormat
} = taskOpts;
return dateFormat || '';
});
const computeScaleUnit = (0, _vue.computed)(() => {
const minScale = computeMinScale.value;
return minScale ? minScale.type : 'date';
});
const computeMinScale = (0, _vue.computed)(() => {
const {
taskScaleList
} = reactData;
return _xeUtils.default.last(taskScaleList);
});
const computeScaleStep = (0, _vue.computed)(() => {
const minScale = computeMinScale.value;
const {
step
} = minScale;
return _xeUtils.default.toNumber(step || 1) || 1;
});
const computeWeekScale = (0, _vue.computed)(() => {
const {
taskScaleList
} = reactData;
return taskScaleList.find(item => item.type === 'week');
});
const computeTaskViewScales = (0, _vue.computed)(() => {
const taskViewOpts = computeTaskViewOpts.value;
const {
scales
} = taskViewOpts;
return scales;
});
const computeTaskLinkStyle = (0, _vue.computed)(() => {
const {
lineType,
lineWidth,
lineStatus,
lineColor
} = computeTaskLinkOpts.value;
return `${lineType || ''}_${lineWidth || ''}_${lineStatus || ''}_${lineColor || ''}`;
});
const computeTitleField = (0, _vue.computed)(() => {
const taskOpts = computeTaskOpts.value;
return taskOpts.titleField || 'title';
});
const computeStartField = (0, _vue.computed)(() => {
const taskOpts = computeTaskOpts.value;
return taskOpts.startField || 'start';
});
const computeEndField = (0, _vue.computed)(() => {
const taskOpts = computeTaskOpts.value;
return taskOpts.endField || 'end';
});
const computeTypeField = (0, _vue.computed)(() => {
const taskOpts = computeTaskOpts.value;
return taskOpts.typeField || 'type';
});
const computeProgressField = (0, _vue.computed)(() => {
const taskOpts = computeTaskOpts.value;
return taskOpts.progressField || 'progress';
});
const computeScrollbarOpts = (0, _vue.computed)(() => {
return Object.assign({}, getConfig().gantt.scrollbarConfig, props.scrollbarConfig);
});
const computeScrollbarXToTop = (0, _vue.computed)(() => {
const scrollbarOpts = computeScrollbarOpts.value;
return !!(scrollbarOpts.x && scrollbarOpts.x.position === 'top');
});
const computeScrollbarYToLeft = (0, _vue.computed)(() => {
const scrollbarOpts = computeScrollbarOpts.value;
return !!(scrollbarOpts.y && scrollbarOpts.y.position === 'left');
});
const computeCriticalPathVisible = (0, _vue.computed)(() => {
const taskBarOpts = computeTaskBarOpts.value;
return taskBarOpts.showCriticalPath;
});
const computeWrapperStyle = (0, _vue.computed)(() => {
const {
height,
maxHeight,
taskBarSubviewConfig
} = props;
const {
isZMax,
tZindex,
overflowY,
scrollbarWidth
} = reactData;
const taskViewOpts = computeTaskViewOpts.value;
const {
viewStyle,
tableStyle
} = taskViewOpts;
const taskBarOpts = computeTaskBarOpts.value;
const {
barStyle
} = taskBarOpts;
const taskCriticalPathOpts = computeTaskCriticalPathOpts.value;
const {
lineColor: cpLineColor
} = taskCriticalPathOpts;
const taskBarSubviewOpts = computeTaskBarSubviewOpts.value;
const taskNowLineOpts = computeTaskNowLineOpts.value;
const {
fontColor: nlfColor,
bgColor: nlbgColor,
width: nlWidth
} = taskNowLineOpts;
const stys = {
'--vxe-ui-gantt-scrollbar-width': (overflowY && scrollbarWidth ? scrollbarWidth : 0) + 'px'
};
if (cpLineColor) {
stys['--vxe-ui-gantt-view-bar-critical-path-line-color'] = cpLineColor;
}
if (isZMax) {
stys.zIndex = tZindex;
} else {
if (height) {
stys.height = height === 'auto' || height === '100%' ? '100%' : (0, _dom.toCssUnit)(height);
}
if (maxHeight) {
stys.maxHeight = maxHeight === 'auto' || maxHeight === '100%' ? '100%' : (0, _dom.toCssUnit)(maxHeight);
}
}
if (barStyle && !_xeUtils.default.isFunction(barStyle)) {
const {
bgColor,
completedBgColor,
overviewBgColor
} = barStyle;
if (bgColor) {
stys['--vxe-ui-gantt-view-task-bar-background-color'] = bgColor;
}
if (completedBgColor) {
stys['--vxe-ui-gantt-view-task-bar-completed-background-color'] = completedBgColor;
}
if (overviewBgColor && (0, _utils.hasEnableConf)(taskBarSubviewConfig, taskBarSubviewOpts)) {
stys['--vxe-ui-gantt-view-task-bar-overview-background-color'] = overviewBgColor;
}
}
if (nlfColor) {
stys['--vxe-ui-gantt-view-task-now-line-color'] = nlfColor;
}
if (nlbgColor) {
stys['--vxe-ui-gantt-view-task-now-line-background-color'] = nlbgColor;
}
if (nlWidth) {
stys['--vxe-ui-gantt-view-task-now-line-width'] = (0, _dom.toCssUnit)(nlWidth);
}
if (viewStyle) {
const {
cellWidth
} = viewStyle;
if (cellWidth) {
stys['--vxe-ui-gantt-view-default-cell-width'] = (0, _dom.toCssUnit)(cellWidth);
}
}
if (tableStyle) {
const {
width: defTbWidth
} = tableStyle;
if (defTbWidth) {
stys['--vxe-ui-gantt-view-table-default-width'] = (0, _dom.toCssUnit)(defTbWidth);
}
}
return stys;
});
const computeTableExtendProps = (0, _vue.computed)(() => {
const rest = {};
const ganttProps = props;
tableComponentPropKeys.forEach(key => {
if (ganttProps[key] !== undefined) {
rest[key] = ganttProps[key];
}
});
return rest;
});
const computeTableProps = (0, _vue.computed)(() => {
const {
showFooter,
seqConfig,
pagerConfig,
editConfig,
proxyConfig
} = props;
const {
isZMax,
tablePage,
footerData
} = reactData;
const taskViewOpts = computeTaskViewOpts.value;
const {
tableStyle
} = taskViewOpts;
const tableExtendProps = computeTableExtendProps.value;
const proxyOpts = computeProxyOpts.value;
const pagerOpts = computePagerOpts.value;
const isLoading = computeIsLoading.value;
const tProps = Object.assign({}, tableExtendProps, {
// 不支持修改的属性
showOverflow: true,
showHeaderOverflow: true,
showFooterOverflow: true
});
if (tableStyle) {
const {
border
} = tableStyle;
if (!_xeUtils.default.eqNull(border)) {
tProps.border = border;
}
}
if (showFooter && !tProps.footerData) {
// 如果未设置自己的标位数据，则使用代理的
tProps.footerData = footerData;
} else if (proxyOpts.footer && footerData.length) {
// 如果代理标为数据，且未请求到数据，则用自己的
tProps.footerData = footerData;
}
if (isZMax) {
if (tProps.maxHeight) {
tProps.maxHeight = '100%';
} else {
tProps.height = '100%';
}
}
if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts)) {
tProps.loading = isLoading;
if (pagerConfig && proxyOpts.seq && (0, _utils.isEnableConf)(pagerOpts)) {
tProps.seqConfig = Object.assign({}, seqConfig, {
startIndex: (tablePage.currentPage - 1) * tablePage.pageSize
});
}
}
if (editConfig) {
tProps.editConfig = Object.assign({}, editConfig);
}
return tProps;
});
const computeCurrLayoutConf = (0, _vue.computed)(() => {
const {
layouts
} = props;
let confs = [];
if (layouts && layouts.length) {
confs = layouts;
} else {
confs = getConfig().gantt.layouts || defaultLayouts;
}
let headKeys = [];
let bodyKeys = [];
let footKeys = [];
if (confs.length) {
if (_xeUtils.default.isArray(confs[0])) {
headKeys = confs[0];
bodyKeys = confs[1] || [];
footKeys = confs[2] || [];
} else {
bodyKeys = confs;
}
}
return {
headKeys,
bodyKeys,
footKeys
};
});
const computeCustomCurrentPageFlag = (0, _vue.computed)(() => {
const pagerOpts = computePagerOpts.value;
return pagerOpts.currentPage;
});
const computeCustomPageSizeFlag = (0, _vue.computed)(() => {
const pagerOpts = computePagerOpts.value;
return pagerOpts.pageSize;
});
const computeCustomTotalFlag = (0, _vue.computed)(() => {
const pagerOpts = computePagerOpts.value;
return pagerOpts.total;
});
const computePageCount = (0, _vue.computed)(() => {
const {
tablePage
} = reactData;
return Math.max(Math.ceil(tablePage.total / tablePage.pageSize), 1);
});
const computeIsLoading = (0, _vue.computed)(() => {
const {
loading,
proxyConfig
} = props;
const {
tableLoading
} = reactData;
const proxyOpts = computeProxyOpts.value;
const {
showLoading
} = proxyOpts;
return loading || tableLoading && showLoading && proxyConfig && (0, _utils.isEnableConf)(proxyOpts);
});
const computeTableBorder = (0, _vue.computed)(() => {
let {
border
} = props;
const taskViewOpts = computeTaskViewOpts.value;
const {
viewStyle
} = taskViewOpts;
if (viewStyle) {
if (!_xeUtils.default.eqNull(viewStyle.border)) {
border = viewStyle.border;
}
}
if (border === true) {
return 'full';
}
if (border) {
return border;
}
return 'default';
});
const refMaps = {
refElem,
refTable,
refForm,
refToolbar,
refPager,
refGanttView,
refGanttContainerElem,
refClassifyWrapperElem,
refPopupContainerElem
};
const computeMaps = {
computeProxyOpts,
computePagerOpts,
computeFormOpts,
computeToolbarOpts,
computeZoomOpts,
computeTaskOpts,
computeTaskViewScaleOpts,
computeTaskNowLineOpts,
computeTaskViewOpts,
computeTaskBarOpts,
computeTaskBarMoveOpts,
computeTaskBarMoveTooltipOpts,
computeTaskBarResizeOpts,
computeTaskBarResizeTooltipOpts,
computeTaskSplitOpts,
computeTaskBarMilestoneOpts,
computeTaskCriticalPathOpts,
computeTaskBarSubviewOpts,
computeTaskBarTooltipOpts,
computeTaskLinkOpts,
computeTaskViewScales,
computeScaleUnit,
computeDateFormat,
computeMinScale,
computeScaleStep,
computeWeekScale,
computeTitleField,
computeStartField,
computeEndField,
computeTypeField,
computeProgressField,
computeScrollbarOpts,
computeScrollbarXToTop,
computeScrollbarYToLeft
};
computeMaps.computeTaskScaleConfs = computeTaskViewScales;
const $xeGantt = {
xID,
props: props,
context,
reactData,
internalData,
getRefMaps: () => refMaps,
getComputeMaps: () => computeMaps
};
const handleTaskScaleConfig = () => {
const taskScaleConfs = computeTaskViewScales.value;
const taskViewScaleOpts = computeTaskViewScaleOpts.value;
const scaleConfs = [];
const keyMaps = {};
const scaleList = taskScaleConfs && taskScaleConfs.length ? taskScaleConfs : ['month', 'date'];
scaleList.forEach(conf => {
const sConf = !conf || _xeUtils.default.isString(conf) ? {
type: conf
} : conf;
const type = sConf.type;
const level = getViewTypeLevel(type);
if (!type || !viewTypeLevelMaps[type]) {
errLog('vxe.error.errProp', [`type=${type}`, _xeUtils.default.keys(viewTypeLevelMaps).join(',')]);
return;
}
if (keyMaps[type]) {
errLog('vxe.error.repeatProp', ['type', type]);
return;
}
const scaleObj = Object.assign({}, type ? taskViewScaleOpts[type] || {} : {}, sConf, {
level
});
keyMaps[type] = true;
scaleConfs.push(scaleObj);
});
reactData.taskScaleList = _xeUtils.default.orderBy(scaleConfs, {
field: 'level',
order: 'desc'
});
};
const initToolbar = () => {
const toolbarOpts = computeToolbarOpts.value;
if (props.toolbarConfig && (0, _utils.isEnableConf)(toolbarOpts)) {
(0, _vue.nextTick)(() => {
const $xeTable = refTable.value;
const $xeToolbar = refToolbar.value;
if ($xeTable && $xeToolbar) {
$xeTable.connectToolbar($xeToolbar);
}
});
}
};
const initGanttView = () => {
const $xeTable = refTable.value;
const $ganttView = refGanttView.value;
if ($xeTable && $ganttView) {
$xeTable.handleConnectGanttView($ganttView);
}
};
const getFormData = () => {
const {
proxyConfig
} = props;
const {
formData
} = reactData;
const proxyOpts = computeProxyOpts.value;
const formOpts = computeFormOpts.value;
return proxyConfig && (0, _utils.isEnableConf)(proxyOpts) && proxyOpts.form ? formData : formOpts.data;
};
const initPages = propKey => {
const {
tablePage
} = reactData;
const {
pagerConfig
} = props;
const pagerOpts = computePagerOpts.value;
if (pagerConfig && (0, _utils.isEnableConf)(pagerOpts)) {
if (propKey) {
if (pagerOpts[propKey]) {
tablePage[propKey] = _xeUtils.default.toNumber(pagerOpts[propKey]);
}
} else {
const {
currentPage,
pageSize,
total
} = pagerOpts;
if (currentPage) {
tablePage.currentPage = currentPage;
}
if (pageSize) {
tablePage.pageSize = pageSize;
}
if (total) {
tablePage.total = total;
}
}
}
};
const triggerPendingEvent = code => {
const isActiveMsg = computeIsActiveMsg.value;
const $xeTable = refTable.value;
const selectRecords = $xeTable ? $xeTable.getCheckboxRecords() : [];
if (selectRecords.length) {
if ($xeTable) {
$xeTable.togglePendingRow(selectRecords);
}
$xeGantt.clearCheckboxRow();
} else {
if (isActiveMsg) {
if (_core.VxeUI.modal) {
_core.VxeUI.modal.message({
id: code,
content: getI18n('vxe.grid.selectOneRecord'),
status: 'warning'
});
}
}
}
};
const getRespMsg = (rest, defaultMsg) => {
const proxyOpts = computeProxyOpts.value;
const resConfigs = proxyOpts.response || proxyOpts.props || {};
const messageProp = resConfigs.message;
const $xeTable = refTable.value;
let msg;
if (rest && messageProp) {
msg = _xeUtils.default.isFunction(messageProp) ? messageProp({
data: rest,
$table: $xeTable,
$grid: null,
$gantt: $xeGantt
}) : _xeUtils.default.get(rest, messageProp);
}
return msg || getI18n(defaultMsg);
};
const handleDeleteRow = (code, alertKey, callback) => {
const isActiveMsg = computeIsActiveMsg.value;
const selectRecords = $xeGantt.getCheckboxRecords();
if (isActiveMsg) {
if (selectRecords.length) {
if (_core.VxeUI.modal) {
return _core.VxeUI.modal.confirm({
id: `cfm_${code}`,
content: getI18n(alertKey),
escClosable: true
}).then(type => {
if (type === 'confirm') {
return callback();
}
});
}
} else {
if (_core.VxeUI.modal) {
_core.VxeUI.modal.message({
id: `msg_${code}`,
content: getI18n('vxe.grid.selectOneRecord'),
status: 'warning'
});
}
}
} else {
if (selectRecords.length) {
callback();
}
}
return Promise.resolve();
};
const pageChangeEvent = params => {
const {
proxyConfig
} = props;
const {
tablePage
} = reactData;
const {
$event,
currentPage,
pageSize
} = params;
const proxyOpts = computeProxyOpts.value;
tablePage.currentPage = currentPage;
tablePage.pageSize = pageSize;
$xeGantt.dispatchEvent('page-change', params, $event);
if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts)) {
$xeGantt.commitProxy('query').then(rest => {
$xeGantt.dispatchEvent('proxy-query', rest, $event);
});
}
};
const handleSortEvent = params => {
const $xeTable = refTable.value;
const {
proxyConfig
} = props;
if (!$xeTable) {
return;
}
const {
computeSortOpts
} = $xeTable.getComputeMaps();
const proxyOpts = computeProxyOpts.value;
const sortOpts = computeSortOpts.value;
// 如果是服务端排序
if (sortOpts.remote) {
reactData.sortData = params.sortList;
if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts)) {
reactData.tablePage.currentPage = 1;
$xeGantt.commitProxy('query').then(rest => {
$xeGantt.dispatchEvent('proxy-query', rest, params.$event);
});
}
}
};
const sortChangeEvent = params => {
handleSortEvent(params);
$xeGantt.dispatchEvent('sort-change', params, params.$event);
};
const clearAllSortEvent = params => {
handleSortEvent(params);
$xeGantt.dispatchEvent('clear-all-sort', params, params.$event);
};
const handleFilterEvent = params => {
const $xeTable = refTable.value;
const {
proxyConfig
} = props;
if (!$xeTable) {
return;
}
const {
computeFilterOpts
} = $xeTable.getComputeMaps();
const proxyOpts = computeProxyOpts.value;
const filterOpts = computeFilterOpts.value;
// 如果是服务端过滤
if (filterOpts.remote) {
reactData.filterData = params.filterList;
if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts)) {
reactData.tablePage.currentPage = 1;
internalData.uFoot = true;
$xeGantt.commitProxy('query').then(rest => {
$xeGantt.dispatchEvent('proxy-query', rest, params.$event);
});
internalData.uFoot = false;
updateQueryFooter();
}
}
};
const filterChangeEvent = params => {
handleFilterEvent(params);
$xeGantt.dispatchEvent('filter-change', params, params.$event);
};
const clearAllFilterEvent = params => {
handleFilterEvent(params);
$xeGantt.dispatchEvent('clear-all-filter', params, params.$event);
};
const submitFormEvent = params => {
const {
proxyConfig
} = props;
const proxyOpts = computeProxyOpts.value;
if (reactData.tableLoading) {
return;
}
if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts)) {
internalData.uFoot = true;
$xeGantt.commitProxy('reload').then(rest => {
$xeGantt.dispatchEvent('proxy-query', Object.assign(Object.assign({}, rest), {
isReload: true
}), params.$event);
});
internalData.uFoot = false;
updateQueryFooter();
}
$xeGantt.dispatchEvent('form-submit', params, params.$event);
};
const resetFormEvent = params => {
const $xeTable = refTable.value;
const {
proxyConfig
} = props;
const {
$event
} = params;
const proxyOpts = computeProxyOpts.value;
if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts)) {
if ($xeTable) {
$xeTable.clearScroll();
}
internalData.uFoot = true;
$xeGantt.commitProxy('reload').then(rest => {
$xeGantt.dispatchEvent('proxy-query', Object.assign(Object.assign({}, rest), {
isReload: true
}), $event);
});
internalData.uFoot = false;
updateQueryFooter();
}
$xeGantt.dispatchEvent('form-reset', params, $event);
};
const submitInvalidEvent = params => {
$xeGantt.dispatchEvent('form-submit-invalid', params, params.$event);
};
const collapseEvent = params => {
const {
$event
} = params;
$xeGantt.dispatchEvent('form-toggle-collapse', params, $event);
$xeGantt.dispatchEvent('form-collapse', params, $event);
};
const handleZoom = isMax => {
const {
isZMax
} = reactData;
if (isMax ? !isZMax : isZMax) {
reactData.isZMax = !isZMax;
if (reactData.tZindex < (0, _utils.getLastZIndex)()) {
reactData.tZindex = (0, _utils.nextZIndex)();
}
}
return (0, _vue.nextTick)().then(() => $xeGantt.recalculate(true)).then(() => {
setTimeout(() => $xeGantt.recalculate(true), 15);
return reactData.isZMax;
});
};
const getFuncSlot = (optSlots, slotKey) => {
const funcSlot = optSlots[slotKey];
if (funcSlot) {
if (_xeUtils.default.isString(funcSlot)) {
if (slots[funcSlot]) {
return slots[funcSlot];
} else {
errLog('vxe.error.notSlot', [funcSlot]);
}
} else {
return funcSlot;
}
}
return null;
};
const getConfigSlot = slotConfigs => {
const slotConf = {};
_xeUtils.default.objectMap(slotConfigs, (slotFunc, slotKey) => {
if (slotFunc) {
if (_xeUtils.default.isString(slotFunc)) {
if (slots[slotFunc]) {
slotConf[slotKey] = slots[slotFunc];
} else {
errLog('vxe.error.notSlot', [slotFunc]);
}
} else {
slotConf[slotKey] = slotFunc;
}
}
});
return slotConf;
};
const dragSplitEvent = evnt => {
const el = refElem.value;
if (!el) {
return;
}
const ganttContainerEl = refGanttContainerElem.value;
if (!ganttContainerEl) {
return;
}
const tableWrapperEl = refTableWrapper.value;
if (!tableWrapperEl) {
return;
}
const rsSplitLineEl = refResizableSplitTip.value;
if (!rsSplitLineEl) {
return;
}
const taskViewOpts = computeTaskViewOpts.value;
const containerRect = ganttContainerEl.getBoundingClientRect();
const rsSplitTipEl = rsSplitLineEl.children[0];
const disX = evnt.clientX;
const ganttWidth = ganttContainerEl.clientWidth;
const tableWidth = tableWrapperEl.clientWidth;
const tableMinWidth = taskViewOpts.tableStyle && _xeUtils.default.toNumber(taskViewOpts.tableStyle.minWidth) || 80;
let targetTableWidth = tableWidth;
let offsetLeft = -1;
(0, _dom.addClass)(el, 'is--split-drag');
const handleReStyle = evnt => {
const rsNumLeftEl = rsSplitTipEl.children[0];
const rsNumRightEl = rsSplitTipEl.children[1];
let tipHeight = 0;
if (rsNumLeftEl) {
if (offsetLeft < 0) {
rsNumLeftEl.style.display = 'none';
} else {
rsNumLeftEl.textContent = `${targetTableWidth}px`;
rsNumLeftEl.style.display = 'block';
tipHeight = rsNumLeftEl.offsetHeight;
}
}
if (rsNumRightEl) {
if (offsetLeft < 0) {
rsNumRightEl.textContent = `${Math.floor(containerRect.width - targetTableWidth)}px`;
rsNumRightEl.style.display = 'block';
tipHeight = rsNumRightEl.offsetHeight;
} else {
rsNumRightEl.style.display = 'none';
}
}
const tipTop = evnt.clientY - containerRect.top - tipHeight / 2;
rsSplitLineEl.style.left = `${targetTableWidth}px`;
rsSplitTipEl.style.top = `${Math.min(containerRect.height - tipHeight - 1, Math.max(1, tipTop))}px`;
};
document.onmousemove = evnt => {
evnt.preventDefault();
offsetLeft = evnt.clientX - disX;
targetTableWidth = Math.min(ganttWidth - 80, Math.max(tableMinWidth, tableWidth + offsetLeft));
handleReStyle(evnt);
};
document.onmouseup = () => {
document.onmousemove = null;
document.onmouseup = null;
rsSplitLineEl.style.display = '';
tableWrapperEl.style.width = `${targetTableWidth}px`;
(0, _dom.removeClass)(el, 'is--split-drag');
const $xeTable = refTable.value;
if ($xeTable) {
$xeTable.recalculate(true);
}
};
rsSplitLineEl.style.display = 'block';
handleReStyle(evnt);
};
const handleSplitAnimat = () => {
const taskSplitOpts = computeTaskSplitOpts.value;
const {
animation
} = taskSplitOpts;
if (animation) {
const {
_taTime
} = internalData;
if (_taTime) {
clearTimeout(_taTime);
}
reactData.showSplitAnimat = true;
internalData._taTime = setTimeout(() => {
reactData.showSplitAnimat = false;
internalData._taTime = null;
}, 350);
}
};
const handleSplitLeftViewEvent = () => {
handleSplitAnimat();
reactData.showLeftView = !reactData.showLeftView;
};
const handleSplitRightViewEvent = () => {
handleSplitAnimat();
reactData.showRightView = !reactData.showRightView;
};
const tableCompEvents = {};
_tableEmits.tableEmits.forEach(name => {
const type = _xeUtils.default.camelCase(`on-${name}`);
tableCompEvents[type] = (...args) => emit(name, ...args);
});
const getDefaultFormData = () => {
const formOpts = computeFormOpts.value;
if (formOpts.items) {
const fData = {};
formOpts.items.forEach(item => {
const {
field,
itemRender
} = item;
if (field) {
let itemValue = null;
if (itemRender) {
const {
startField,
endField,
defaultValue
} = itemRender;
if (_xeUtils.default.isFunction(defaultValue)) {
itemValue = defaultValue({
item
});
} else if (!_xeUtils.default.isUndefined(defaultValue)) {
itemValue = defaultValue;
}
if (startField && endField) {
_xeUtils.default.set(fData, startField, null);
_xeUtils.default.set(fData, endField, null);
}
}
fData[field] = itemValue;
}
});
return fData;
}
return {};
};
const initProxy = () => {
const {
proxyConfig,
formConfig
} = props;
const {
proxyInited
} = reactData;
const proxyOpts = computeProxyOpts.value;
const formOpts = computeFormOpts.value;
if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts)) {
if (formConfig && (0, _utils.isEnableConf)(formOpts) && proxyOpts.form && formOpts.items) {
reactData.formData = getDefaultFormData();
}
if (!proxyInited) {
reactData.proxyInited = true;
if (proxyOpts.autoLoad !== false) {
(0, _vue.nextTick)().then(() => {
internalData.uFoot = true;
const rest = $xeGantt.commitProxy('initial');
internalData.uFoot = false;
updateQueryFooter();
return rest;
}).then(rest => {
dispatchEvent('proxy-query', Object.assign(Object.assign({}, rest), {
isInited: true
}), new Event('initial'));
});
}
}
}
};
const updateQueryFooter = () => {
const proxyOpts = computeProxyOpts.value;
const {
ajax
} = proxyOpts;
if (ajax && ajax.queryFooter) {
return $xeGantt.commitProxy('queryFooter');
}
};
const handleGlobalKeydownEvent = evnt => {
const zoomOpts = computeZoomOpts.value;
const isEsc = globalEvents.hasKey(evnt, GLOBAL_EVENT_KEYS.ESCAPE);
if (isEsc && reactData.isZMax && zoomOpts.escRestore !== false) {
$xeGantt.triggerZoomEvent(evnt);
}
};
const dispatchEvent = (type, params, evnt) => {
emit(type, createEvent(evnt, {
$grid: null,
$gantt: $xeGantt
}, params));
};
const handleTargetEnterEvent = isClear => {
const $tooltip = refTooltip.value;
clearTimeout(internalData.barTipTimeout);
if (isClear) {
$xeGantt.closeTaskBarTooltip();
} else {
if ($tooltip && $tooltip.setActived) {
$tooltip.setActived(true);
}
}
};
const ganttMethods = {
dispatchEvent,
getEl() {
return refElem.value;
},
/**
* 提交指令，支持 code 或 button
* @param {String/Object} code 字符串或对象
*/
commitProxy(proxyTarget, ...args) {
const {
showFooter,
proxyConfig,
toolbarConfig,
pagerConfig,
editRules,
validConfig
} = props;
const {
tablePage
} = reactData;
const isActiveMsg = computeIsActiveMsg.value;
const isRespMsg = computeIsRespMsg.value;
const proxyOpts = computeProxyOpts.value;
const pagerOpts = computePagerOpts.value;
const toolbarOpts = computeToolbarOpts.value;
const {
beforeQuery: oldBeforeQuery,
afterQuery: oldAfterQuery,
beforeQueryFooter: oldBeforeQueryFooter,
afterQueryFooter: oldAfterQueryFooter,
beforeDelete: oldBeforeDelete,
afterDelete: oldAfterDelete,
beforeSave: oldBeforeSave,
afterSave: oldAfterSave,
ajax = {}
} = proxyOpts;
const resConfigs = proxyOpts.response || proxyOpts.props || {};
const $xeTable = refTable.value;
if (!$xeTable) {
return (0, _vue.nextTick)();
}
let formData = getFormData();
let button = null;
let code = null;
if (_xeUtils.default.isString(proxyTarget)) {
const {
buttons
} = toolbarOpts;
const matchObj = toolbarConfig && (0, _utils.isEnableConf)(toolbarOpts) && buttons ? _xeUtils.default.findTree(buttons, item => item.code === proxyTarget, {
children: 'dropdowns'
}) : null;
button = matchObj ? matchObj.item : null;
code = proxyTarget;
} else {
button = proxyTarget;
code = button.code;
}
const btnParams = button ? button.params : null;
switch (code) {
case 'insert':
return $xeTable.insert({});
case 'insert_edit':
return $xeTable.insert({}).then(({
row
}) => $xeTable.setEditRow(row, true));
// 已废弃
case 'insert_actived':
return $xeTable.insert({}).then(({
row
}) => $xeTable.setEditRow(row, true));
// 已废弃
case 'mark_cancel':
triggerPendingEvent(code);
break;
case 'remove':
return handleDeleteRow(code, 'vxe.grid.removeSelectRecord', () => $xeTable.removeCheckboxRow());
case 'import':
$xeTable.importData(btnParams);
break;
case 'open_import':
$xeTable.openImport(btnParams);
break;
case 'export':
$xeTable.exportData(btnParams);
break;
case 'open_export':
$xeTable.openExport(btnParams);
break;
case 'reset_custom':
return $xeTable.resetCustom(true);
case 'initial':
case 'reload':
case 'query':
{
const bqMethod = ajax.beforeQuery;
const qMethod = ajax.query;
const aqMethod = ajax.afterQuery;
const qsMethod = ajax.querySuccess;
const qeMethod = ajax.queryError;
if (qMethod) {
const isInited = code === 'initial';
const isReload = code === 'reload';
if (!isInited && reactData.tableLoading) {
return (0, _vue.nextTick)();
}
let operPromise = null;
let sortList = [];
let filterList = [];
let pageParams = {};
if (pagerConfig) {
if (isInited || isReload) {
// 重置分页
tablePage.currentPage = 1;
}
if ((0, _utils.isEnableConf)(pagerOpts)) {
pageParams = Object.assign({}, tablePage);
}
}
if (isInited) {
// 重置代理表单数据
if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts) && proxyOpts.form) {
formData = getDefaultFormData();
reactData.formData = formData;
}
if ($xeTable) {
const tableInternalData = $xeTable.internalData;
const {
tableFullColumn,
fullColumnFieldData
} = tableInternalData;
const {
computeSortOpts
} = $xeTable.getComputeMaps();
const sortOpts = computeSortOpts.value;
let defaultSort = sortOpts.defaultSort;
tableFullColumn.forEach(column => {
column.order = null;
});
// 如果使用默认排序
if (defaultSort) {
if (!_xeUtils.default.isArray(defaultSort)) {
defaultSort = [defaultSort];
}
sortList = defaultSort.map(item => {
const {
field,
order
} = item;
const colRest = fullColumnFieldData[field];
if (colRest) {
const column = colRest.column;
if (column) {
column.order = order;
}
}
return {
field,
property: field,
order
};
});
}
filterList = $xeTable.getCheckedFilters();
}
} else {
if ($xeTable) {
if (isReload) {
operPromise = $xeTable.clearAll();
} else {
sortList = $xeTable.getSortColumns();
filterList = $xeTable.getCheckedFilters();
}
}
}
const commitParams = {
$table: $xeTable,
$grid: null,
$gantt: $xeGantt,
code,
button,
isInited,
isReload,
page: pageParams,
sort: sortList.length ? sortList[0] : {},
sorts: sortList,
filters: filterList,
form: formData,
options: qMethod
};
const handleQuery = () => {
reactData.sortData = sortList;
reactData.filterData = filterList;
reactData.tableLoading = true;
return Promise.all([Promise.resolve((oldBeforeQuery || qMethod)(commitParams, ...args)), operPromise]).then(([rest]) => {
reactData.tableLoading = false;
if (aqMethod) {
aqMethod(Object.assign(Object.assign({}, commitParams), {
response: rest,
status: 'success'
}), ...args);
} else {
let tableData = [];
if (rest) {
const reParams = {
data: rest,
$table: $xeTable,
$grid: null,
$gantt: $xeGantt
};
if (pagerConfig && (0, _utils.isEnableConf)(pagerOpts)) {
const totalProp = resConfigs.total;
const total = (_xeUtils.default.isFunction(totalProp) ? totalProp(reParams) : _xeUtils.default.get(rest, totalProp || 'page.total')) || 0;
tablePage.total = _xeUtils.default.toNumber(total);
const resultProp = resConfigs.result;
tableData = (_xeUtils.default.isFunction(resultProp) ? resultProp(reParams) : _xeUtils.default.get(rest, resultProp || 'result')) || [];
// 检验当前页码，不能超出当前最大页数
const pageCount = Math.max(Math.ceil(total / tablePage.pageSize), 1);
if (tablePage.currentPage > pageCount) {
tablePage.currentPage = pageCount;
}
} else {
const listProp = resConfigs.list;
if (_xeUtils.default.isArray(rest)) {
tableData = rest;
} else if (listProp) {
tableData = (_xeUtils.default.isFunction(listProp) ? listProp(reParams) : _xeUtils.default.get(rest, listProp)) || [];
}
}
if (showFooter) {
const fdProp = resConfigs.footerData;
const footerList = fdProp ? _xeUtils.default.isFunction(fdProp) ? fdProp(reParams) : _xeUtils.default.get(rest, fdProp) : [];
if (_xeUtils.default.isArray(footerList)) {
reactData.footerData = footerList;
}
}
}
if ($xeTable) {
$xeTable.loadData(tableData);
} else {
(0, _vue.nextTick)(() => {
const $xeTable = refTable.value;
if ($xeTable) {
$xeTable.loadData(tableData);
}
});
}
if (oldAfterQuery) {
oldAfterQuery(Object.assign(Object.assign({}, commitParams), {
response: rest
}), ...args);
}
}
if (qsMethod) {
qsMethod(Object.assign(Object.assign({}, commitParams), {
response: rest
}));
}
return {
status: true
};
}).catch(rest => {
reactData.tableLoading = false;
if (aqMethod) {
aqMethod(Object.assign(Object.assign({}, commitParams), {
response: rest,
status: 'error'
}), ...args);
}
if (qeMethod) {
qeMethod(Object.assign(Object.assign({}, commitParams), {
response: rest
}));
}
return {
status: false
};
});
};
if (bqMethod) {
return Promise.resolve(bqMethod(commitParams, ...args)).then(status => {
if (status !== false) {
return handleQuery();
}
});
}
return handleQuery();
} else {
errLog('vxe.error.notFunc', ['proxy-config.ajax.query']);
}
break;
}
case 'queryFooter':
{
const bqfMethod = ajax.beforeQueryFooter;
const qfMethod = ajax.queryFooter;
const aqfMethod = ajax.afterQueryFooter;
const qfSuccessMethod = ajax.queryFooterSuccess;
const qfErrorMethod = ajax.queryFooterError;
if (qfMethod) {
let filterList = [];
if ($xeTable) {
filterList = $xeTable.getCheckedFilters();
}
let pageParams = {};
if (pagerConfig) {
if ((0, _utils.isEnableConf)(pagerOpts)) {
pageParams = Object.assign({}, tablePage);
}
}
const commitParams = {
$table: $xeTable,
$grid: null,
$gantt: $xeGantt,
code,
button,
page: pageParams,
filters: filterList,
form: formData,
options: qfMethod
};
const handleQueryFooter = () => {
return Promise.resolve((oldBeforeQueryFooter || qfMethod)(commitParams, ...args)).then(rest => {
if (aqfMethod) {
aqfMethod(Object.assign(Object.assign({}, commitParams), {
response: rest,
status: 'success'
}), ...args);
} else {
reactData.footerData = _xeUtils.default.isArray(rest) ? rest : [];
if (oldAfterQueryFooter) {
oldAfterQueryFooter(Object.assign(Object.assign({}, commitParams), {
response: rest
}), ...args);
}
}
if (qfSuccessMethod) {
qfSuccessMethod(Object.assign(Object.assign({}, commitParams), {
response: rest
}));
}
return {
status: true
};
}).catch(rest => {
if (aqfMethod) {
aqfMethod(Object.assign(Object.assign({}, commitParams), {
response: rest,
status: 'error'
}), ...args);
}
if (qfErrorMethod) {
qfErrorMethod(Object.assign(Object.assign({}, commitParams), {
response: rest
}));
}
return {
status: false
};
});
};
if (bqfMethod) {
return Promise.resolve(bqfMethod(commitParams, ...args)).then(status => {
if (status !== false) {
return handleQueryFooter();
}
});
}
return handleQueryFooter();
} else {
errLog('vxe.error.notFunc', ['proxy-config.ajax.queryFooter']);
}
break;
}
case 'delete':
{
const bdMethod = ajax.beforeDelete;
const dMethod = ajax.delete;
const adMethod = ajax.afterDelete;
const deleteSuccessMethods = ajax.deleteSuccess;
const deleteErrorMethods = ajax.deleteError;
if (dMethod) {
const selectRecords = $xeGantt.getCheckboxRecords();
const removeRecords = selectRecords.filter(row => !$xeTable.isInsertByRow(row));
const body = {
removeRecords
};
const commitParams = {
$table: $xeTable,
$grid: null,
$gantt: $xeGantt,
code,
button,
body,
form: formData,
options: dMethod
};
if (selectRecords.length) {
return handleDeleteRow(code, 'vxe.grid.deleteSelectRecord', () => {
if (!removeRecords.length) {
return $xeTable.remove(selectRecords);
}
const handleDelete = () => {
reactData.tableLoading = true;
return Promise.resolve((oldBeforeDelete || dMethod)(commitParams, ...args)).then(rest => {
reactData.tableLoading = false;
if (adMethod) {
adMethod(Object.assign(Object.assign({}, commitParams), {
response: rest,
status: 'success'
}), ...args);
} else {
$xeTable.setPendingRow(removeRecords, false);
if (isRespMsg) {
if (_core.VxeUI.modal) {
_core.VxeUI.modal.message({
content: getRespMsg(rest, 'vxe.grid.delSuccess'),
status: 'success'
});
}
}
if (oldAfterDelete) {
oldAfterDelete(Object.assign(Object.assign({}, commitParams), {
response: rest
}), ...args);
} else {
internalData.uFoot = true;
$xeGantt.commitProxy('query');
internalData.uFoot = false;
updateQueryFooter();
}
}
if (deleteSuccessMethods) {
deleteSuccessMethods(Object.assign(Object.assign({}, commitParams), {
response: rest
}));
}
return {
status: true
};
}).catch(rest => {
reactData.tableLoading = false;
if (adMethod) {
adMethod(Object.assign(Object.assign({}, commitParams), {
response: rest,
status: 'error'
}), ...args);
} else {
if (isRespMsg) {
if (_core.VxeUI.modal) {
_core.VxeUI.modal.message({
id: code,
content: getRespMsg(rest, 'vxe.grid.operError'),
status: 'error'
});
}
}
}
if (deleteErrorMethods) {
deleteErrorMethods(Object.assign(Object.assign({}, commitParams), {
response: rest
}));
}
return {
status: false
};
});
};
if (bdMethod) {
return Promise.resolve(bdMethod(commitParams, ...args)).then(status => {
if (status !== false) {
return handleDelete();
}
});
}
return handleDelete();
});
} else {
if (isActiveMsg) {
if (_core.VxeUI.modal) {
_core.VxeUI.modal.message({
id: code,
content: getI18n('vxe.grid.selectOneRecord'),
status: 'warning'
});
}
}
}
} else {
errLog('vxe.error.notFunc', ['proxy-config.ajax.delete']);
}
break;
}
case 'save':
{
const bSaveMethod = ajax.beforeSave;
const sMethod = ajax.save;
const aSaveMethod = ajax.afterSave;
const sSuccessMethod = ajax.saveSuccess;
const sErrorMethod = ajax.saveError;
if (sMethod) {
const body = $xeTable.getRecordset();
const {
insertRecords,
removeRecords,
updateRecords,
pendingRecords
} = body;
const commitParams = {
$table: $xeTable,
$grid: null,
$gantt: $xeGantt,
code,
button,
body,
form: formData,
options: sMethod
};
// 排除掉新增且标记为删除的数据
if (insertRecords.length) {
body.pendingRecords = pendingRecords.filter(row => $xeTable.findRowIndexOf(insertRecords, row) === -1);
}
// 排除已标记为删除的数据
if (pendingRecords.length) {
body.insertRecords = insertRecords.filter(row => $xeTable.findRowIndexOf(pendingRecords, row) === -1);
}
let restPromise = Promise.resolve();
if (editRules) {
// 只校验新增和修改的数据
restPromise = $xeTable[validConfig && validConfig.msgMode === 'full' ? 'fullValidate' : 'validate'](body.insertRecords.concat(updateRecords));
}
return restPromise.then(errMap => {
if (errMap) {
// 如果校验不通过
return;
}
if (body.insertRecords.length || removeRecords.length || updateRecords.length || body.pendingRecords.length) {
const handleSave = () => {
reactData.tableLoading = true;
return Promise.resolve((oldBeforeSave || sMethod)(commitParams, ...args)).then(rest => {
reactData.tableLoading = false;
if (aSaveMethod) {
aSaveMethod(Object.assign(Object.assign({}, commitParams), {
response: rest,
status: 'success'
}), ...args);
} else {
$xeTable.clearPendingRow();
if (isRespMsg) {
if (_core.VxeUI.modal) {
_core.VxeUI.modal.message({
content: getRespMsg(rest, 'vxe.grid.saveSuccess'),
status: 'success'
});
}
}
if (oldAfterSave) {
oldAfterSave(Object.assign(Object.assign({}, commitParams), {
response: rest
}), ...args);
} else {
internalData.uFoot = true;
$xeGantt.commitProxy('query');
internalData.uFoot = false;
updateQueryFooter();
}
}
if (sSuccessMethod) {
sSuccessMethod(Object.assign(Object.assign({}, commitParams), {
response: rest
}));
}
return {
status: true
};
}).catch(rest => {
reactData.tableLoading = false;
if (aSaveMethod) {
aSaveMethod(Object.assign(Object.assign({}, commitParams), {
response: rest,
status: 'error'
}), ...args);
} else {
if (isRespMsg) {
if (_core.VxeUI.modal) {
_core.VxeUI.modal.message({
id: code,
content: getRespMsg(rest, 'vxe.grid.operError'),
status: 'error'
});
}
}
}
if (sErrorMethod) {
sErrorMethod(Object.assign(Object.assign({}, commitParams), {
response: rest
}));
}
return {
status: false
};
});
};
if (bSaveMethod) {
return Promise.resolve(bSaveMethod(commitParams, ...args)).then(status => {
if (status !== false) {
return handleSave();
}
});
}
return handleSave();
} else {
if (isActiveMsg) {
if (_core.VxeUI.modal) {
_core.VxeUI.modal.message({
id: code,
content: getI18n('vxe.grid.dataUnchanged'),
status: 'info'
});
}
}
}
});
} else {
errLog('vxe.error.notFunc', ['proxy-config.ajax.save']);
}
break;
}
default:
{
const gCommandOpts = commands.get(code);
if (gCommandOpts) {
const tCommandMethod = gCommandOpts.tableCommandMethod || gCommandOpts.commandMethod;
if (tCommandMethod) {
tCommandMethod({
code,
button,
$table: $xeTable,
$grid: null,
$gantt: $xeGantt
}, ...args);
} else {
errLog('vxe.error.notCommands', [code]);
}
}
}
}
return (0, _vue.nextTick)();
},
getParams() {
return props.params;
},
zoom() {
if (reactData.isZMax) {
return $xeGantt.revert();
}
return $xeGantt.maximize();
},
isMaximized() {
return reactData.isZMax;
},
maximize() {
return handleZoom(true);
},
revert() {
return handleZoom();
},
getFormData,
/**
* 已废弃，被 getFormFlatItems 替换
* @deprecated
*/
getFormItems(itemIndex) {
const formOpts = computeFormOpts.value;
const {
formConfig
} = props;
const {
items
} = formOpts;
const itemList = [];
_xeUtils.default.eachTree(formConfig && (0, _utils.isEnableConf)(formOpts) && items ? items : [], item => {
itemList.push(item);
}, {
children: 'children'
});
// errLog('vxe.error.delFunc', ['getFormItems', 'getFormFlatItems'])
return _xeUtils.default.isUndefined(itemIndex) ? itemList : itemList[itemIndex];
},
getFormFlatItems() {
const $form = refForm.value;
if ($form) {
return $form.getFlatItems();
}
return [];
},
getFormNestedItems() {
const $form = refForm.value;
if ($form) {
return $form.getNestedItems();
}
return [];
},
getFormItemByField(field) {
const $form = refForm.value;
if ($form) {
return $form.getItemByField(field);
}
return null;
},
resetForm() {
const $form = refForm.value;
if ($form) {
return $form.reset();
}
return (0, _vue.nextTick)();
},
validateForm() {
const $form = refForm.value;
if ($form) {
return $form.validate();
}
return (0, _vue.nextTick)();
},
validateFormField(field) {
const $form = refForm.value;
if ($form) {
return $form.validateField(field);
}
return (0, _vue.nextTick)();
},
clearFormValidate(field) {
const $form = refForm.value;
if ($form) {
return $form.clearValidate(field);
}
return (0, _vue.nextTick)();
},
homePage() {
const {
tablePage
} = reactData;
tablePage.currentPage = 1;
return (0, _vue.nextTick)();
},
homePageByEvent(evnt) {
const $pager = refPager.value;
if ($pager) {
$pager.homePageByEvent(evnt);
}
},
endPage() {
const {
tablePage
} = reactData;
const pageCount = computePageCount.value;
tablePage.currentPage = pageCount;
return (0, _vue.nextTick)();
},
endPageByEvent(evnt) {
const $pager = refPager.value;
if ($pager) {
$pager.endPageByEvent(evnt);
}
},
getCurrentPage() {
const {
tablePage
} = reactData;
return tablePage.currentPage;
},
setCurrentPage(currentPage) {
const {
tablePage
} = reactData;
const pageCount = computePageCount.value;
tablePage.currentPage = Math.min(pageCount, Math.max(1, _xeUtils.default.toNumber(currentPage)));
return (0, _vue.nextTick)();
},
setCurrentPageByEvent(evnt, currentPage) {
const $pager = refPager.value;
if ($pager) {
$pager.setCurrentPageByEvent(evnt, currentPage);
}
},
getPageSize() {
const {
tablePage
} = reactData;
return tablePage.pageSize;
},
setPageSize(pageSize) {
const {
tablePage
} = reactData;
tablePage.pageSize = Math.max(1, _xeUtils.default.toNumber(pageSize));
return (0, _vue.nextTick)();
},
setPageSizeByEvent(evnt, pageSize) {
const $pager = refPager.value;
if ($pager) {
$pager.setPageSizeByEvent(evnt, pageSize);
}
},
getProxyInfo() {
const $xeTable = refTable.value;
if (props.proxyConfig) {
const {
sortData
} = reactData;
return {
data: $xeTable ? $xeTable.getFullData() : [],
filter: reactData.filterData,
form: getFormData(),
sort: sortData.length ? sortData[0] : {},
sorts: sortData,
pager: reactData.tablePage,
pendingRecords: $xeTable ? $xeTable.getPendingRecords() : []
};
}
return null;
},
getCustomPagerData() {
const {
pagerConfig
} = props;
const {
tablePage
} = reactData;
const pagerOpts = computePagerOpts.value;
if (pagerConfig && (0, _utils.isEnableConf)(pagerOpts)) {
return {
pSize: tablePage.pageSize
};
}
return {};
},
// setProxyInfo (options) {
// if (props.proxyConfig && options) {
// const { pager, form } = options
// const proxyOpts = computeProxyOpts.value
// if (pager) {
// if (pager.currentPage) {
// reactData.tablePage.currentPage = Number(pager.currentPage)
// }
// if (pager.pageSize) {
// reactData.tablePage.pageSize = Number(pager.pageSize)
// }
// }
// if (proxyOpts.form && form) {
// Object.assign(reactData.formData, form)
// }
// }
// return nextTick()
// },
refreshTaskView() {
const $ganttView = refGanttView.value;
if ($ganttView) {
return $ganttView.refreshData();
}
return (0, _vue.nextTick)();
},
hasTableViewVisible() {
return reactData.showLeftView;
},
showTableView() {
reactData.showLeftView = true;
return (0, _vue.nextTick)();
},
hideTableView() {
reactData.showLeftView = false;
// 至少显示一个
if (!reactData.showRightView) {
reactData.showRightView = true;
}
return (0, _vue.nextTick)();
},
hasTaskViewVisible() {
return reactData.showRightView;
},
showTaskView() {
reactData.showRightView = true;
return (0, _vue.nextTick)();
},
hideTaskView() {
reactData.showRightView = false;
// 至少显示一个
if (!reactData.showLeftView) {
reactData.showLeftView = true;
}
return (0, _vue.nextTick)();
},
/**
* 关闭 bar tooltip
*/
closeTaskBarTooltip() {
const {
barTipStore
} = reactData;
const $tooltip = refTooltip.value;
if (barTipStore.visible) {
Object.assign(barTipStore, {
row: null,
content: null,
visible: false,
params: {}
});
if ($tooltip && $tooltip.close) {
$tooltip.close();
}
}
return (0, _vue.nextTick)();
},
scrollToDateView(colDate) {
const $ganttView = refGanttView.value;
if ($ganttView) {
const ganttViewReactData = $ganttView.reactData;
const ganttViewInternalData = $ganttView.internalData;
const {
viewCellWidth
} = ganttViewReactData;
const {
visibleColumn,
elemStore
} = ganttViewInternalData;
const currDate = _xeUtils.default.toStringDate(colDate);
const currTime = currDate.getTime();
const colIndex = _xeUtils.default.findIndexOf(visibleColumn, column => currTime === column.dateObj.date.getTime());
const bodyScrollElem = (0, _util.getRefElem)(elemStore['main-body-scroll']);
if (colIndex > -1 && bodyScrollElem) {
bodyScrollElem.scrollLeft = _xeUtils.default.floor(colIndex * viewCellWidth);
}
}
return (0, _vue.nextTick)();
},
scrollToTaskView(rowOrRowid) {
const $xeTable = refTable.value;
if ($xeTable) {
const rowid = _xeUtils.default.isString(rowOrRowid) || _xeUtils.default.isNumber(rowOrRowid) ? rowOrRowid : $xeTable.getRowid(rowOrRowid);
return $xeTable.scrollToRow(rowOrRowid).then(() => {
const $ganttView = refGanttView.value;
if ($ganttView) {
const ganttViewReactData = $ganttView.reactData;
const ganttViewInternalData = $ganttView.internalData;
const {
viewCellWidth
} = ganttViewReactData;
const {
chartMaps,
elemStore
} = ganttViewInternalData;
const chartRest = rowid ? chartMaps[rowid] : null;
if (chartRest) {
const bodyScrollElem = (0, _util.getRefElem)(elemStore['main-body-scroll']);
if (bodyScrollElem) {
bodyScrollElem.scrollLeft = _xeUtils.default.floor(chartRest.oLeftSize * viewCellWidth);
}
}
}
});
}
return (0, _vue.nextTick)();
},
getCriticalPath() {
const {
criticalRowIds,
criticalLinks
} = reactData;
const {
criticalRowMaps
} = internalData;
return {
rowIds: criticalRowIds.slice(0),
rows: Array.from(criticalRowMaps.values()),
links: criticalLinks.slice(0)
};
}
};
const ganttPrivateMethods = {
extendTableMethods,
callSlot(slotFunc, params) {
if (slotFunc) {
if (_xeUtils.default.isString(slotFunc)) {
slotFunc = slots[slotFunc] || null;
}
if (_xeUtils.default.isFunction(slotFunc)) {
return (0, _vn.getSlotVNs)(slotFunc(params));
}
}
return [];
},
/**
* 获取需要排除的高度
*/
getExcludeHeight() {
const {
height
} = props;
const {
isZMax
} = reactData;
const el = refElem.value;
if (el) {
const formWrapper = refFormWrapper.value;
const toolbarWrapper = refToolbarWrapper.value;
const topWrapper = refTopWrapper.value;
const bottomWrapper = refBottomWrapper.value;
const pagerWrapper = refPagerWrapper.value;
const parentEl = el.parentElement;
let parentPaddingSize = 0;
if (parentEl && (height === '100%' || height === 'auto')) {
parentPaddingSize = isZMax ? 0 : (0, _dom.getPaddingTopBottomSize)(parentEl);
}
return parentPaddingSize + (0, _dom.getPaddingTopBottomSize)(el) + (0, _dom.getOffsetHeight)(formWrapper) + (0, _dom.getOffsetHeight)(toolbarWrapper) + (0, _dom.getOffsetHeight)(topWrapper) + (0, _dom.getOffsetHeight)(bottomWrapper) + (0, _dom.getOffsetHeight)(pagerWrapper);
}
return 0;
},
getParentElem() {
const el = refElem.value;
if (!el) {
return null;
}
let parentEl = el.parentElement;
// 如果是虚拟滚动条
if (parentEl && (0, _dom.hasClass)(parentEl, 'vxe-scrollbar--view-inner')) {
parentEl = parentEl.parentElement;
}
return parentEl;
},
getParentHeight() {
const el = refElem.value;
if (el) {
const parentEl = $xeGantt.getParentElem();
return (reactData.isZMax ? (0, _dom.getDomNode)().visibleHeight : parentEl ? _xeUtils.default.toNumber(getComputedStyle(parentEl).height) : 0) - ganttPrivateMethods.getExcludeHeight();
}
return 0;
},
triggerToolbarCommitEvent(params, evnt) {
const {
code
} = params;
if (code) {
const isUf = ['reload', 'delete', 'save'].includes(code);
if (isUf) {
internalData.uFoot = true;
}
const rest = $xeGantt.commitProxy(params, evnt).then(rest => {
if (rest && rest.status && ['query', 'reload', 'delete', 'save'].includes(code)) {
$xeGantt.dispatchEvent(code === 'delete' || code === 'save' ? `proxy-${code}` : 'proxy-query', Object.assign(Object.assign({}, rest), {
isReload: code === 'reload'
}), evnt);
}
});
internalData.uFoot = false;
if (isUf) {
updateQueryFooter();
}
return rest;
}
return (0, _vue.nextTick)();
},
triggerToolbarBtnEvent(button, evnt) {
$xeGantt.triggerToolbarCommitEvent(button, evnt);
$xeGantt.dispatchEvent('toolbar-button-click', {
code: button.code,
button
}, evnt);
},
triggerToolbarTolEvent(tool, evnt) {
$xeGantt.triggerToolbarCommitEvent(tool, evnt);
$xeGantt.dispatchEvent('toolbar-tool-click', {
code: tool.code,
tool
}, evnt);
},
triggerZoomEvent(evnt) {
$xeGantt.zoom();
$xeGantt.dispatchEvent('zoom', {
type: reactData.isZMax ? 'max' : 'revert'
}, evnt);
},
handleTaskCellClickEvent(evnt, params) {
const $xeTable = refTable.value;
if ($xeTable) {
const tableProps = $xeTable.props;
const {
highlightCurrentRow
} = tableProps;
const tableReactData = $xeTable.reactData;
const {
radioColumn,
checkboxColumn
} = tableReactData;
const {
computeRadioOpts,
computeCheckboxOpts,
computeRowOpts
} = $xeTable.getComputeMaps();
const radioOpts = computeRadioOpts.value;
const checkboxOpts = computeCheckboxOpts.value;
const rowOpts = computeRowOpts.value;
const {
row
} = params;
// 如果是当前行
if (rowOpts.isCurrent || highlightCurrentRow) {
$xeTable.triggerCurrentRowEvent(evnt, Object.assign({
$table: $xeTable,
rowIndex: $xeTable.getRowIndex(row),
$rowIndex: $xeTable.getVMRowIndex(row)
}, params));
}
// 如果是单选框
if (radioColumn && radioOpts.trigger === 'row') {
$xeTable.triggerRadioRowEvent(evnt, params);
}
// 如果是复选框
if (checkboxColumn && checkboxOpts.trigger === 'row') {
$xeTable.handleToggleCheckRowEvent(evnt, params);
}
}
reactData.isActiveCeLe = false;
reactData.activeBarRowid = null;
reactData.activeLink = null;
$xeGantt.dispatchEvent('task-cell-click', params, evnt);
},
handleTaskCellDblclickEvent(evnt, params) {
$xeGantt.dispatchEvent('task-cell-dblclick', params, evnt);
},
handleTaskBarClickEvent(evnt, params) {
const $xeTable = refTable.value;
const taskBarOpts = computeTaskBarOpts.value;
const {
linkCreatable
} = taskBarOpts;
const {
row
} = params;
reactData.isActiveCeLe = !!linkCreatable;
reactData.activeBarRowid = $xeTable ? $xeTable.getRowid(row) : row;
reactData.activeLink = null;
$xeGantt.dispatchEvent('task-bar-click', params, evnt);
},
handleTaskBarDblclickEvent(evnt, params) {
$xeGantt.dispatchEvent('task-bar-dblclick', params, evnt);
},
triggerTaskBarTooltipEvent(evnt, params) {
const {
barTipStore,
activeLink
} = reactData;
const {
dragBarRow,
dragLineRow
} = internalData;
if (dragBarRow || dragLineRow) {
return;
}
if (activeLink) {
return;
}
const taskBarTooltipOpts = computeTaskBarTooltipOpts.value;
const titleField = computeTitleField.value;
const {
contentMethod
} = taskBarTooltipOpts;
const {
row
} = params;
let content = (0, _utils.formatText)(_xeUtils.default.get(row, titleField));
if (contentMethod) {
const customContnet = contentMethod(params);
if (!_xeUtils.default.eqNull(customContnet)) {
content = `${customContnet}`;
}
}
handleTargetEnterEvent(barTipStore.row !== row);
const tipContent = (0, _utils.formatText)(content);
Object.assign(barTipStore, {
row,
visible: true,
content: tipContent,
params
});
(0, _vue.nextTick)(() => {
const $tooltip = refTooltip.value;
if ($tooltip) {
if ($tooltip.openByEvent) {
$tooltip.openByEvent(evnt, evnt.currentTarget, tipContent);
} else if ($tooltip.open) {
$tooltip.open(evnt.currentTarget, tipContent);
}
}
});
},
handleTaskBarTooltipLeaveEvent() {
const taskBarTooltipOpts = computeTaskBarTooltipOpts.value;
let $tooltip = refTooltip.value;
if ($tooltip && $tooltip.setActived) {
$tooltip.setActived(false);
}
if (taskBarTooltipOpts.enterable) {
internalData.barTipTimeout = setTimeout(() => {
$tooltip = refTooltip.value;
if ($tooltip && $tooltip.isActived && !$tooltip.isActived()) {
$xeGantt.closeTaskBarTooltip();
}
}, taskBarTooltipOpts.leaveDelay);
} else {
$xeGantt.closeTaskBarTooltip();
}
},
handleTaskHeaderContextmenuEvent(evnt, params) {
const $xeTable = refTable.value;
if ($xeTable) {
const tableProps = $xeTable.props;
const {
menuConfig
} = tableProps;
if ((0, _utils.isEnableConf)(menuConfig)) {
evnt.stopPropagation();
$xeTable.handleOpenMenuEvent(evnt, 'header', params);
$xeTable.dispatchEvent('header-cell-menu', params, evnt);
}
}
},
handleTaskBodyContextmenuEvent(evnt, params) {
const $xeTable = refTable.value;
if ($xeTable) {
const tableProps = $xeTable.props;
const {
menuConfig
} = tableProps;
if ((0, _utils.isEnableConf)(menuConfig)) {
evnt.stopPropagation();
$xeTable.handleOpenMenuEvent(evnt, 'body', params);
$xeTable.dispatchEvent('cell-menu', params, evnt);
}
}
},
handleTaskFooterContextmenuEvent(evnt, params) {
const $xeTable = refTable.value;
if ($xeTable) {
const tableProps = $xeTable.props;
const {
menuConfig
} = tableProps;
if ((0, _utils.isEnableConf)(menuConfig)) {
evnt.stopPropagation();
$xeTable.handleOpenMenuEvent(evnt, 'footer', params);
$xeTable.dispatchEvent('footer-cell-menu', params, evnt);
}
}
},
handleTaskBarContextmenuEvent(evnt, params) {
const $xeTable = refTable.value;
if ($xeTable) {
const tableProps = $xeTable.props;
const {
menuConfig
} = tableProps;
if ((0, _utils.isEnableConf)(menuConfig)) {
evnt.stopPropagation();
$xeTable.handleOpenMenuEvent(evnt, 'body', params);
$xeTable.dispatchEvent('cell-menu', params, evnt);
}
}
}
};
Object.assign($xeGantt, ganttExtendTableMethods, ganttMethods, ganttPrivateMethods, {
loadColumn(columns) {
const $xeTable = refTable.value;
// 检查插槽
_xeUtils.default.eachTree(columns, column => {
const {
type
} = column;
if (column.slots) {
_xeUtils.default.each(column.slots, func => {
if (!_xeUtils.default.isFunction(func)) {
if (!slots[func]) {
errLog('vxe.error.notSlot', [func]);
}
}
});
}
if (type === 'expand') {
errLog('vxe.error.errProp', ['type=expand', 'type=seq,radio,checkbox,html']);
}
});
reactData.currLeftSpacing = 0;
reactData.currRightSpacing = 0;
if ($xeTable) {
return $xeTable.loadColumn(columns);
}
return (0, _vue.nextTick)();
},
reloadColumn(columns) {
$xeGantt.clearAll();
return $xeGantt.loadColumn(columns);
}
});
/**
* 渲染表单
*/
const renderForm = () => {
const {
formConfig,
proxyConfig
} = props;
const {
formData
} = reactData;
const proxyOpts = computeProxyOpts.value;
const formOpts = computeFormOpts.value;
if (formConfig && (0, _utils.isEnableConf)(formOpts) || slots.form) {
let slotVNs = [];
if (slots.form) {
slotVNs = slots.form({
$grid: null,
$gantt: $xeGantt
});
} else {
if (formOpts.items) {
const formSlots = {};
if (!formOpts.inited) {
formOpts.inited = true;
const beforeItem = proxyOpts.beforeItem;
if (proxyOpts && beforeItem) {
formOpts.items.forEach(item => {
beforeItem({
$grid: null,
$gantt: $xeGantt,
item
});
});
}
}
// 处理插槽
formOpts.items.forEach(item => {
_xeUtils.default.each(item.slots, func => {
if (func && !_xeUtils.default.isFunction(func)) {
if (slots[func]) {
formSlots[func] = slots[func];
}
}
});
});
if (VxeUIFormComponent) {
slotVNs.push((0, _vue.h)(VxeUIFormComponent, Object.assign(Object.assign({
ref: refForm
}, Object.assign({}, formOpts, {
data: proxyConfig && (0, _utils.isEnableConf)(proxyOpts) && proxyOpts.form ? formData : formOpts.data
})), {
onSubmit: submitFormEvent,
onReset: resetFormEvent,
onSubmitInvalid: submitInvalidEvent,
onCollapse: collapseEvent
}), formSlots));
}
}
}
return (0, _vue.h)('div', {
ref: refFormWrapper,
key: 'form',
class: 'vxe-gantt--form-wrapper'
}, slotVNs);
}
return renderEmptyElement($xeGantt);
};
/**
* 渲染工具栏
*/
const renderToolbar = () => {
const {
toolbarConfig
} = props;
const toolbarOpts = computeToolbarOpts.value;
const toolbarSlot = slots.toolbar;
if (toolbarConfig && (0, _utils.isEnableConf)(toolbarOpts) || toolbarSlot) {
let slotVNs = [];
if (slots.toolbar) {
slotVNs = slots.toolbar({
$grid: null,
$gantt: $xeGantt
});
} else {
const toolbarOptSlots = toolbarOpts.slots;
const toolbarSlots = {};
if (toolbarOptSlots) {
const buttonsSlot = getFuncSlot(toolbarOptSlots, 'buttons');
const buttonPrefixSlot = getFuncSlot(toolbarOptSlots, 'buttonPrefix');
const buttonSuffixSlot = getFuncSlot(toolbarOptSlots, 'buttonSuffix');
const toolsSlot = getFuncSlot(toolbarOptSlots, 'tools');
const toolPrefixSlot = getFuncSlot(toolbarOptSlots, 'toolPrefix');
const toolSuffixSlot = getFuncSlot(toolbarOptSlots, 'toolSuffix');
if (buttonsSlot) {
toolbarSlots.buttons = buttonsSlot;
}
if (buttonPrefixSlot) {
toolbarSlots.buttonPrefix = buttonPrefixSlot;
}
if (buttonSuffixSlot) {
toolbarSlots.buttonSuffix = buttonSuffixSlot;
}
if (toolsSlot) {
toolbarSlots.tools = toolsSlot;
}
if (toolPrefixSlot) {
toolbarSlots.toolPrefix = toolPrefixSlot;
}
if (toolSuffixSlot) {
toolbarSlots.toolSuffix = toolSuffixSlot;
}
}
slotVNs.push((0, _vue.h)(VxeToolbarComponent, Object.assign(Object.assign({
ref: refToolbar
}, toolbarOpts), {
slots: undefined
}), toolbarSlots));
}
return (0, _vue.h)('div', {
ref: refToolbarWrapper,
key: 'toolbar',
class: 'vxe-gantt--toolbar-wrapper'
}, slotVNs);
}
return renderEmptyElement($xeGantt);
};
/**
* 渲染表格顶部区域
*/
const renderTop = () => {
const topSlot = slots.top;
if (topSlot) {
return (0, _vue.h)('div', {
ref: refTopWrapper,
key: 'top',
class: 'vxe-gantt--top-wrapper'
}, topSlot({
$grid: null,
$gantt: $xeGantt
}));
}
return renderEmptyElement($xeGantt);
};
const renderTableLeft = () => {
const leftSlot = slots.left;
if (leftSlot) {
return (0, _vue.h)('div', {
class: 'vxe-gantt--left-wrapper'
}, leftSlot({
$grid: null,
$gantt: $xeGantt
}));
}
return renderEmptyElement($xeGantt);
};
const renderTableRight = () => {
const rightSlot = slots.right;
if (rightSlot) {
return (0, _vue.h)('div', {
class: 'vxe-gantt--right-wrapper'
}, rightSlot({
$grid: null,
$gantt: $xeGantt
}));
}
return renderEmptyElement($xeGantt);
};
/**
* 渲染表格
*/
const renderTable = () => {
const {
proxyConfig
} = props;
const tableProps = computeTableProps.value;
const proxyOpts = computeProxyOpts.value;
const tableOns = Object.assign({}, tableCompEvents);
const emptySlot = slots.empty;
const loadingSlot = slots.loading;
const rowDragIconSlot = slots.rowDragIcon || slots['row-drag-icon'];
const columnDragIconSlot = slots.columnDragIcon || slots['column-drag-icon'];
const headerTooltipSlot = slots.headerTooltip || slots['header-tooltip'];
const tooltipSlot = slots.tooltip;
const footerTooltipSlot = slots.footerTooltip || slots['footer-tooltip'];
if (proxyConfig && (0, _utils.isEnableConf)(proxyOpts)) {
if (proxyOpts.sort) {
tableOns.onSortChange = sortChangeEvent;
tableOns.onClearAllSort = clearAllSortEvent;
}
if (proxyOpts.filter) {
tableOns.onFilterChange = filterChangeEvent;
tableOns.onClearAllFilter = clearAllFilterEvent;
}
}
const slotObj = {};
if (emptySlot) {
slotObj.empty = emptySlot;
}
if (loadingSlot) {
slotObj.loading = loadingSlot;
}
if (rowDragIconSlot) {
slotObj.rowDragIcon = rowDragIconSlot;
}
if (columnDragIconSlot) {
slotObj.columnDragIcon = columnDragIconSlot;
}
if (headerTooltipSlot) {
slotObj.headerTooltip = headerTooltipSlot;
}
if (tooltipSlot) {
slotObj.tooltip = tooltipSlot;
}
if (footerTooltipSlot) {
slotObj.footerTooltip = footerTooltipSlot;
}
return (0, _vue.h)('div', {
ref: refTableWrapper,
class: 'vxe-gantt--table-wrapper'
}, [(0, _vue.h)(VxeTableComponent, Object.assign(Object.assign({
ref: refTable
}, tableProps), tableOns), slotObj)]);
};
/**
* 渲染表格底部区域
*/
const renderBottom = () => {
if (slots.bottom) {
return (0, _vue.h)('div', {
ref: refBottomWrapper,
key: 'bottom',
class: 'vxe-gantt--bottom-wrapper'
}, slots.bottom({
$grid: null,
$gantt: $xeGantt
}));
}
return renderEmptyElement($xeGantt);
};
/**
* 渲染分页
*/
const renderPager = () => {
const {
proxyConfig,
pagerConfig
} = props;
const proxyOpts = computeProxyOpts.value;
const pagerOpts = computePagerOpts.value;
const pagerSlot = slots.pager;
if (pagerConfig && (0, _utils.isEnableConf)(pagerOpts) || slots.pager) {
return (0, _vue.h)('div', {
ref: refPagerWrapper,
key: 'pager',
class: 'vxe-gantt--pager-wrapper'
}, pagerSlot ? pagerSlot({
$grid: null,
$gantt: $xeGantt
}) : [VxeUIPagerComponent ? (0, _vue.h)(VxeUIPagerComponent, Object.assign(Object.assign(Object.assign({
ref: refPager
}, pagerOpts), proxyConfig && (0, _utils.isEnableConf)(proxyOpts) ? reactData.tablePage : {}), {
onPageChange: pageChangeEvent
}), getConfigSlot(pagerOpts.slots)) : renderEmptyElement($xeGantt)]);
}
return renderEmptyElement($xeGantt);
};
/**
* 渲染任务视图
*/
const renderTaskView = () => {
return (0, _vue.h)('div', {
ref: refGanttWrapper,
class: 'vxe-gantt--view-wrapper'
}, [(0, _vue.h)(_ganttView.default, {
ref: refGanttView
})]);
};
const renderSplitBar = () => {
const {
showLeftView,
showRightView
} = reactData;
const taskSplitOpts = computeTaskSplitOpts.value;
const {
enabled,
resize,
showCollapseTableButton,
showCollapseTaskButton
} = taskSplitOpts;
if (!enabled) {
return renderEmptyElement($xeGantt);
}
const isResize = resize && showLeftView && showRightView;
const ons = {};
if (isResize) {
ons.onMousedown = dragSplitEvent;
}
return (0, _vue.h)('div', {
class: ['vxe-gantt--view-split-bar', {
'is--resize': isResize
}]
}, [(0, _vue.h)('div', Object.assign({
class: 'vxe-gantt--view-split-bar-handle'
}, ons)), showCollapseTableButton || showCollapseTaskButton ? (0, _vue.h)('div', {
class: 'vxe-gantt--view-split-bar-btn-wrapper'
}, [showCollapseTableButton && showRightView ? (0, _vue.h)('div', {
class: ['vxe-gantt--view-split-bar-action-btn', showLeftView ? 'is--prev' : 'is--next'],
onClick: handleSplitLeftViewEvent
}, [(0, _vue.h)('i', {
class: showLeftView ? getIcon().GANTT_VIEW_LEFT_OPEN : getIcon().GANTT_VIEW_LEFT_CLOSE
})]) : renderEmptyElement($xeGantt), showCollapseTaskButton && showLeftView ? (0, _vue.h)('div', {
class: ['vxe-gantt--view-split-bar-action-btn', showRightView ? 'is--next' : 'is--prev'],
onClick: handleSplitRightViewEvent
}, [(0, _vue.h)('i', {
class: showRightView ? getIcon().GANTT_VIEW_RIGHT_OPEN : getIcon().GANTT_VIEW_RIGHT_CLOSE
})]) : renderEmptyElement($xeGantt)]) : renderEmptyElement($xeGantt)]);
};
const renderChildLayout = layoutKeys => {
const {
showLeftView,
showRightView
} = reactData;
const taskSplitOpts = computeTaskSplitOpts.value;
const scrollbarXToTop = computeScrollbarXToTop.value;
const scrollbarYToLeft = computeScrollbarYToLeft.value;
const {
autoHideCollapseButton
} = taskSplitOpts;
const childVNs = [];
layoutKeys.forEach(key => {
switch (key) {
case 'Form':
childVNs.push(renderForm());
break;
case 'Toolbar':
childVNs.push(renderToolbar());
break;
case 'Top':
childVNs.push(renderTop());
break;
case 'Gantt':
childVNs.push((0, _vue.h)('div', {
ref: refGanttContainerElem,
key: 'tv',
class: ['vxe-gantt--gantt-container', `sx-pos--${scrollbarXToTop ? 'top' : 'bottom'}`, `sy-pos--${scrollbarYToLeft ? 'left' : 'right'}`, {
'show--left': showLeftView,
'hide--left': !showLeftView,
'show--right': showRightView,
'hide--right': !showRightView,
'is--ah-split-btn': autoHideCollapseButton
}]
}, [renderTableLeft(), renderTable(), renderSplitBar(), renderTaskView(), renderTableRight(), (0, _vue.h)('div', {
ref: refClassifyWrapperElem
}), (0, _vue.h)('div', {
ref: refResizableSplitTip,
class: 'vxe-gantt--resizable-split-tip'
}, [(0, _vue.h)('div', {
class: 'vxe-gantt--resizable-split-tip-number'
}, [(0, _vue.h)('div', {
class: 'vxe-gantt--resizable-split-number-left'
}), (0, _vue.h)('div', {
class: 'vxe-gantt--resizable-split-number-right'
})])]), (0, _vue.h)('div', {
class: 'vxe-gantt--border-line'
})]));
break;
case 'Bottom':
childVNs.push(renderBottom());
break;
case 'Pager':
childVNs.push(renderPager());
break;
default:
errLog('vxe.error.notProp', [`layouts -> ${key}`]);
break;
}
});
return childVNs;
};
const renderLayout = () => {
const {
barTipStore
} = reactData;
const currLayoutConf = computeCurrLayoutConf.value;
const {
headKeys,
bodyKeys,
footKeys
} = currLayoutConf;
const taskBarTooltipOpts = computeTaskBarTooltipOpts.value;
const asideLeftSlot = slots.asideLeft || slots['aside-left'];
const asideRightSlot = slots.asideRight || slots['aside-right'];
const taskBarTooltipSlot = slots.taskBarTooltip || slots['task-bar-tooltip'];
return [(0, _vue.h)('div', {
class: 'vxe-gantt--layout-header-wrapper'
}, renderChildLayout(headKeys)), (0, _vue.h)('div', {
class: 'vxe-gantt--layout-body-wrapper'
}, [asideLeftSlot ? (0, _vue.h)('div', {
class: 'vxe-gantt--layout-aside-left-wrapper'
}, asideLeftSlot({})) : renderEmptyElement($xeGantt), (0, _vue.h)('div', {
class: 'vxe-gantt--layout-body-content-wrapper'
}, renderChildLayout(bodyKeys)), asideRightSlot ? (0, _vue.h)('div', {
class: 'vxe-gantt--layout-aside-right-wrapper'
}, asideRightSlot({})) : renderEmptyElement($xeGantt)]), (0, _vue.h)('div', {
class: 'vxe-gantt--layout-footer-wrapper'
}, renderChildLayout(footKeys)), (0, _vue.h)('div', {
ref: refPopupContainerElem
}), (0, _vue.h)('div', {}, [
/**
* 任务条提示
*/
(0, _vue.h)(VxeUITooltipComponent, {
key: 'gtp',
ref: refTooltip,
theme: taskBarTooltipOpts.theme,
enterable: taskBarTooltipOpts.enterable,
enterDelay: taskBarTooltipOpts.enterDelay,
leaveDelay: taskBarTooltipOpts.leaveDelay,
useHtml: _xeUtils.default.isBoolean(taskBarTooltipOpts.useHtml) ? taskBarTooltipOpts.useHtml : taskBarTooltipOpts.useHTML,
width: taskBarTooltipOpts.width,
height: taskBarTooltipOpts.height,
minWidth: taskBarTooltipOpts.minWidth,
minHeight: taskBarTooltipOpts.minHeight,
maxWidth: taskBarTooltipOpts.maxWidth,
maxHeight: taskBarTooltipOpts.maxHeight,
isArrow: false
}, taskBarTooltipSlot ? {
content: () => {
const {
row,
content: tooltipContent
} = barTipStore;
if (row) {
return (0, _vue.h)('div', {}, taskBarTooltipSlot(Object.assign({
tooltipContent,
$gantt: $xeGantt
}, barTipStore.params)));
}
return renderEmptyElement($xeGantt);
}
} : {})])];
};
const renderVN = () => {
const {
showLeftView,
showRightView,
overflowY,
overflowX,
showSplitAnimat
} = reactData;
const vSize = computeSize.value;
const wrapperStyle = computeWrapperStyle.value;
const isLoading = computeIsLoading.value;
const taskSplitOpts = computeTaskSplitOpts.value;
const tableBorder = computeTableBorder.value;
const scrollbarXToTop = computeScrollbarXToTop.value;
const scrollbarYToLeft = computeScrollbarYToLeft.value;
return (0, _vue.h)('div', {
ref: refElem,
class: ['vxe-gantt', `border--${tableBorder}`, `sx-pos--${scrollbarXToTop ? 'top' : 'bottom'}`, `sy-pos--${scrollbarYToLeft ? 'left' : 'right'}`, {
[`size--${vSize}`]: vSize,
'is--round': props.round,
'show--animat': taskSplitOpts.animation,
'is--maximize': reactData.isZMax,
'is--loading': isLoading,
'is--animat': showSplitAnimat,
'show--left': showLeftView,
'hide--left': !showLeftView,
'show--right': showRightView,
'hide--right': !showRightView,
'is--scroll-y': overflowY,
'is--scroll-x': overflowX
}],
style: wrapperStyle
}, renderLayout());
};
const columnFlag = (0, _vue.ref)(0);
(0, _vue.watch)(() => props.columns ? props.columns.length : -1, () => {
columnFlag.value++;
});
(0, _vue.watch)(() => props.columns, () => {
columnFlag.value++;
});
(0, _vue.watch)(columnFlag, () => {
(0, _vue.nextTick)(() => $xeGantt.loadColumn(props.columns || []));
});
(0, _vue.watch)(() => props.toolbarConfig, () => {
initToolbar();
});
(0, _vue.watch)(computeCustomCurrentPageFlag, () => {
initPages('currentPage');
});
(0, _vue.watch)(computeCustomPageSizeFlag, () => {
initPages('pageSize');
});
(0, _vue.watch)(computeCustomTotalFlag, () => {
initPages('total');
});
(0, _vue.watch)(() => props.proxyConfig, () => {
initProxy();
});
const reViewFlag = (0, _vue.ref)(0);
(0, _vue.watch)(computeTaskViewScales, () => {
handleTaskScaleConfig();
reViewFlag.value++;
});
(0, _vue.watch)(computeCriticalPathVisible, () => {
reViewFlag.value++;
});
(0, _vue.watch)(reViewFlag, () => {
$xeGantt.refreshTaskView();
});
(0, _vue.watch)(computeTaskLinkStyle, () => {
if ($xeGantt.handleUpTaskLinkData) {
$xeGantt.handleUpTaskLinkData();
}
});
hooks.forEach(options => {
const {
setupGantt
} = options;
if (setupGantt) {
const hookRest = setupGantt($xeGantt);
if (hookRest && _xeUtils.default.isObject(hookRest)) {
Object.assign($xeGantt, hookRest);
}
}
});
if ($xeGantt.handleTaskLoadLinks) {
if (props.links) {
$xeGantt.handleTaskLoadLinks(props.links);
}
}
handleTaskScaleConfig();
initPages();
(0, _vue.onMounted)(() => {
const taskBarSubviewOpts = computeTaskBarSubviewOpts.value;
const {
barStyle
} = taskBarSubviewOpts;
if (barStyle) {
if (barStyle.top) {
warnLog('vxe.error.delProp', ['task-bar-subview-config.barStyle.top', 'task-bar-subview-config.barStyle.style.top']);
}
if (barStyle.backgroundColor) {
warnLog('vxe.error.delProp', ['task-bar-subview-config.barStyle.backgroundColor', 'task-bar-subview-config.barStyle.style.backgroundColor']);
}
}
if (!$xeGantt.handleUpTaskLinkData) {
if (props.links) {
warnLog('vxe.error.notProp', ['links']);
}
if (props.taskLinkConfig) {
warnLog('vxe.error.notProp', ['task-link-config']);
}
}
(0, _vue.nextTick)(() => {
const {
columns
} = props;
const proxyOpts = computeProxyOpts.value;
if (props.formConfig) {
if (!VxeUIFormComponent) {
errLog('vxe.error.reqComp', ['vxe-form']);
}
}
if (props.pagerConfig) {
if (!VxeUIPagerComponent) {
errLog('vxe.error.reqComp', ['vxe-pager']);
}
}
if (props.treeConfig && props.links) {
const $xeTable = refTable.value;
if ($xeTable) {
const {
computeTreeOpts
} = $xeTable.getComputeMaps();
const treeOpts = computeTreeOpts.value;
if (!treeOpts.transform) {
errLog('vxe.error.notSupportProp', ['links', 'tree-config.transform=false', 'tree-config.transform=true']);
}
}
}
// const { data, columns, proxyConfig } = props
// const formOpts = computeFormOpts.value
// if (isEnableConf(proxyConfig) && (data || (proxyOpts.form && formOpts.data))) {
// errLog('vxe.error.errConflicts', ['grid.data', 'grid.proxy-config'])
// }
if (proxyOpts.props) {
warnLog('vxe.error.delProp', ['proxy-config.props', 'proxy-config.response']);
}
if (props.expandConfig) {
warnLog('vxe.error.notProp', ['expand-config']);
}
if (columns && columns.length) {
$xeGantt.loadColumn(columns);
}
initToolbar();
initProxy();
});
initGanttView();
globalEvents.on($xeGantt, 'keydown', handleGlobalKeydownEvent);
});
(0, _vue.onBeforeUnmount)(() => {
_xeUtils.default.assign(reactData, createReactData());
_xeUtils.default.assign(internalData, createInternalData());
});
(0, _vue.onUnmounted)(() => {
globalEvents.off($xeGantt, 'keydown');
});
$xeGantt.renderVN = renderVN;
(0, _vue.provide)('$xeGrid', null);
(0, _vue.provide)('$xeGantt', $xeGantt);
return $xeGantt;
},
render() {
return this.renderVN();
}
});