vxe-gantt 4.0.23 → 4.0.25

package/es/gantt/src/gantt-body.js

@@ -1,6 +1,8 @@
 import { h, inject, ref, onMounted, onUnmounted } from 'vue';
 import { defineVxeComponent } from '../../ui/src/comp';
 import { getCellRestHeight } from './util';
+import { getClass } from '../../ui/src/utils';
+import XEUtils from 'xe-utils';
 import GanttViewChartComponent from './gantt-chart';
 const sourceType = 'gantt';
 const viewType = 'body';
@@ -30,9 +32,10 @@ export default defineVxeComponent({
             const { headerGroups } = reactData;
             const { todayDateMaps } = internalData;
             const taskViewOpts = computeTaskViewOpts.value;
-            const { showNowLine } = taskViewOpts;
+            const { showNowLine, viewStyle } = taskViewOpts;
             const { scaleItem } = headerGroups[headerGroups.length - 1] || {};
-            const { field } = column;
+            const { field, dateObj } = column;
+            const { cellClassName, cellStyle } = viewStyle || {};
             const todayValue = showNowLine && scaleItem ? todayDateMaps[scaleItem.type] : null;
             const rowRest = fullAllDataRowIdData[rowid] || {};
             const resizeHeight = resizeHeightFlag ? rowRest.resizeHeight : 0;
@@ -71,16 +74,24 @@ export default defineVxeComponent({
                     onDblclick: (evnt) => $xeTable.handleRowResizeDblclickEvent(evnt, cellParams)
                 }));
             }
-            const ctParams = { source: sourceType, type: viewType, row, column, $rowIndex, rowIndex, _rowIndex };
+            const ctParams = { source: sourceType, type: viewType, dateObj, row, column, $rowIndex, rowIndex, _rowIndex };
             return h('td', {
                 key: $columnIndex,
-                class: ['vxe-gantt-view--body-column', {
+                class: [
+                    'vxe-gantt-view--body-column',
+                    {
                         'is--now': showNowLine && todayValue === field,
                         'col--rs-height': isRsHeight
-                    }],
-                style: {
-                    height: `${cellHeight}px`
-                },
+                    },
+                    getClass(cellClassName, ctParams)
+                ],
+                style: cellStyle
+                    ? Object.assign({}, XEUtils.isFunction(cellStyle) ? cellStyle(ctParams) : cellStyle, {
+                        height: `${cellHeight}px`
+                    })
+                    : {
+                        height: `${cellHeight}px`
+                    },
                 onClick(evnt) {
                     $xeGantt.handleTaskCellClickEvent(evnt, { row, column });
                 },
@@ -106,6 +117,9 @@ export default defineVxeComponent({
             const treeOpts = computeTreeOpts.value;
             const { transform } = treeOpts;
             const childrenField = treeOpts.children || treeOpts.childrenField;
+            const taskViewOpts = computeTaskViewOpts.value;
+            const { viewStyle } = taskViewOpts;
+            const { rowClassName, rowStyle } = viewStyle || {};
             const { tableColumn, scrollYLoad } = reactData;
             const trVNs = [];
             tableData.forEach((row, $rowIndex) => {
@@ -138,13 +152,18 @@ export default defineVxeComponent({
                     trOns.onDragend = $xeTable.handleRowDragDragendEvent;
                     trOns.onDragover = $xeTable.handleRowDragDragoverEvent;
                 }
-                trVNs.push(h('tr', Object.assign({ key: treeConfig ? rowid : $rowIndex, class: ['vxe-gantt-view--body-row', {
+                const rowParams = { source: sourceType, type: viewType, row, rowIndex, $rowIndex, _rowIndex };
+                trVNs.push(h('tr', Object.assign({ key: treeConfig ? rowid : $rowIndex, class: [
+                        'vxe-gantt-view--body-row',
+                        {
                             'row--stripe': stripe && (_rowIndex + 1) % 2 === 0,
                             'is--new': isNewRow,
                             'row--radio': radioOpts.highlight && $xeTable.eqRow(selectRadioRow, row),
                             'row--checked': checkboxOpts.highlight && $xeTable.isCheckedByCheckboxRow(row),
                             'row--pending': !!pendingRowFlag && !!pendingRowMaps[rowid]
-                        }], rowid }, trOns), tableColumn.map((column, $columnIndex) => renderColumn($xeTable, row, rowid, rowIndex, $rowIndex, _rowIndex, column, $columnIndex))));
+                        },
+                        getClass(rowClassName, rowParams)
+                    ], rowid, style: rowStyle ? XEUtils.isFunction(rowStyle) ? rowStyle(rowParams) : rowStyle : undefined }, trOns), tableColumn.map((column, $columnIndex) => renderColumn($xeTable, row, rowid, rowIndex, $rowIndex, _rowIndex, column, $columnIndex))));
                 let isExpandTree = false;
                 let rowChildren = [];
                 if (treeConfig && !scrollYLoad && !transform) {

package/es/gantt/src/gantt-view.js

@@ -8,6 +8,7 @@ import GanttViewHeaderComponent from './gantt-header';
 import GanttViewBodyComponent from './gantt-body';
 import GanttViewFooterComponent from './gantt-footer';
 const { globalEvents } = VxeUI;
+const sourceType = 'gantt';
 function createInternalData() {
     return {
         xeTable: null,
@@ -781,8 +782,7 @@ export default defineVxeComponent({
                 reactData.lazScrollLoading = false;
             }, 200);
         };
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const handleScrollEvent = (evnt, isRollY, isRollX, scrollTop, scrollLeft) => {
+        const handleScrollData = (isRollY, isRollX, scrollTop, scrollLeft) => {
             if (isRollX) {
                 internalData.lastScrollLeft = scrollLeft;
             }
@@ -792,6 +792,91 @@ export default defineVxeComponent({
             reactData.lastScrollTime = Date.now();
             checkLastSyncScroll(isRollX, isRollY);
         };
+        const handleScrollEvent = (evnt, isRollY, isRollX, scrollTop, scrollLeft) => {
+            const $xeTable = internalData.xeTable;
+            const { lastScrollLeft, lastScrollTop } = internalData;
+            const xHandleEl = refScrollXHandleElem.value;
+            const yHandleEl = refScrollYHandleElem.value;
+            if (!xHandleEl || !yHandleEl) {
+                return;
+            }
+            if (!$xeTable) {
+                return;
+            }
+            const { computeScrollXThreshold, computeScrollYThreshold } = $xeTable.getComputeMaps();
+            const bodyHeight = yHandleEl.clientHeight;
+            const bodyWidth = xHandleEl.clientWidth;
+            const scrollHeight = yHandleEl.scrollHeight;
+            const scrollWidth = xHandleEl.scrollWidth;
+            let isTop = false;
+            let isBottom = false;
+            let isLeft = false;
+            let isRight = false;
+            let direction = '';
+            let isTopBoundary = false;
+            let isBottomBoundary = false;
+            let isLeftBoundary = false;
+            let isRightBoundary = false;
+            if (isRollX) {
+                const xThreshold = computeScrollXThreshold.value;
+                isLeft = scrollLeft <= 0;
+                if (!isLeft) {
+                    isRight = scrollLeft + bodyWidth >= scrollWidth - 1;
+                }
+                if (scrollLeft > lastScrollLeft) {
+                    direction = 'right';
+                    if (scrollLeft + bodyWidth >= scrollWidth - xThreshold) {
+                        isRightBoundary = true;
+                    }
+                }
+                else {
+                    direction = 'left';
+                    if (scrollLeft <= xThreshold) {
+                        isLeftBoundary = true;
+                    }
+                }
+            }
+            if (isRollY) {
+                const yThreshold = computeScrollYThreshold.value;
+                isTop = scrollTop <= 0;
+                if (!isTop) {
+                    isBottom = scrollTop + bodyHeight >= scrollHeight - 1;
+                }
+                if (scrollTop > lastScrollTop) {
+                    direction = 'bottom';
+                    if (scrollTop + bodyHeight >= scrollHeight - yThreshold) {
+                        isBottomBoundary = true;
+                    }
+                }
+                else {
+                    direction = 'top';
+                    if (scrollTop <= yThreshold) {
+                        isTopBoundary = true;
+                    }
+                }
+            }
+            handleScrollData(isRollY, isRollX, scrollTop, scrollLeft);
+            const evntParams = {
+                source: sourceType,
+                scrollTop,
+                scrollLeft,
+                bodyHeight,
+                bodyWidth,
+                scrollHeight,
+                scrollWidth,
+                isX: isRollX,
+                isY: isRollY,
+                isTop,
+                isBottom,
+                isLeft,
+                isRight,
+                direction
+            };
+            if (isBottomBoundary || isTopBoundary || isRightBoundary || isLeftBoundary) {
+                $xeGantt.dispatchEvent('scroll-boundary', evntParams, evnt);
+            }
+            $xeGantt.dispatchEvent('scroll', evntParams, evnt);
+        };
         const ganttViewMethods = {
             refreshData() {
                 handleUpdateData();
@@ -911,7 +996,12 @@ export default defineVxeComponent({
                         triggerScrollXEvent();
                     }
                 }
-                handleScrollEvent(evnt, isRollY, isRollX, wrapperEl.scrollTop, scrollLeft);
+                if (isRollY) {
+                    handleScrollData(isRollY, isRollX, wrapperEl.scrollTop, scrollLeft);
+                }
+                if (isRollX) {
+                    handleScrollEvent(evnt, isRollY, isRollX, wrapperEl.scrollTop, scrollLeft);
+                }
             },
             // triggerFooterScrollEvent (evnt) {
             //   const { inVirtualScroll, inHeaderScroll, inBodyScroll } = internalData
@@ -965,7 +1055,7 @@ export default defineVxeComponent({
                     internalData.inVirtualScroll = true;
                     setScrollTop(bodyScrollElem, currTopNum);
                     syncTableScrollTop(currTopNum);
-                    handleScrollEvent(evnt, isRollY, isRollX, currTopNum, wrapperEl.scrollLeft);
+                    handleScrollData(isRollY, isRollX, currTopNum, wrapperEl.scrollLeft);
                 }
             },
             handleUpdateSXSpace() {

package/es/gantt/src/gantt.js

@@ -17,6 +17,7 @@ const tableComponentMethodKeys = ['clearAll', 'syncData', 'updateData', 'loadDat
 const defaultLayouts = [['Form'], ['Toolbar', 'Top', 'Gantt', 'Bottom', 'Pager']];
 function createInternalData() {
     return {
+        uFoot: false,
         resizeTableWidth: 0
     };
 }
@@ -60,6 +61,7 @@ export default defineVxeComponent({
             filterData: [],
             formData: {},
             sortData: [],
+            footerData: [],
             tZindex: 0,
             tablePage: {
                 total: 0,
@@ -217,14 +219,17 @@ export default defineVxeComponent({
         });
         const computeTableExtendProps = computed(() => {
             const rest = {};
+            const ganttProps = props;
             tableComponentPropKeys.forEach((key) => {
-                rest[key] = props[key];
+                if (ganttProps[key] !== undefined) {
+                    rest[key] = ganttProps[key];
+                }
             });
             return rest;
         });
         const computeTableProps = computed(() => {
-            const { seqConfig, pagerConfig, editConfig, proxyConfig } = props;
-            const { isZMax, tablePage } = reactData;
+            const { showFooter, seqConfig, pagerConfig, editConfig, proxyConfig } = props;
+            const { isZMax, tablePage, footerData } = reactData;
             const taskViewOpts = computeTaskViewOpts.value;
             const { tableStyle } = taskViewOpts;
             const tableExtendProps = computeTableExtendProps.value;
@@ -243,8 +248,16 @@ export default defineVxeComponent({
                     tProps.border = border;
                 }
             }
+            if (showFooter && !tProps.footerData) {
+                // 如果未设置自己的标位数据，则使用代理的
+                tProps.footerData = footerData;
+            }
+            else if (proxyOpts.footer && footerData.length) {
+                // 如果代理标为数据，且未请求到数据，则用自己的
+                tProps.footerData = footerData;
+            }
             if (isZMax) {
-                if (tableExtendProps.maxHeight) {
+                if (tProps.maxHeight) {
                     tProps.maxHeight = '100%';
                 }
                 else {
@@ -558,9 +571,12 @@ export default defineVxeComponent({
                 reactData.filterData = params.filterList;
                 if (proxyConfig && 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();
                 }
             }
         };
@@ -579,9 +595,12 @@ export default defineVxeComponent({
                 return;
             }
             if (proxyConfig && 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);
         };
@@ -594,9 +613,12 @@ export default defineVxeComponent({
                 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);
         };
@@ -754,13 +776,17 @@ export default defineVxeComponent({
                     if (field) {
                         let itemValue = null;
                         if (itemRender) {
-                            const { defaultValue } = itemRender;
+                            const { startField, endField, defaultValue } = itemRender;
                             if (XEUtils.isFunction(defaultValue)) {
                                 itemValue = defaultValue({ item });
                             }
                             else if (!XEUtils.isUndefined(defaultValue)) {
                                 itemValue = defaultValue;
                             }
+                            if (startField && endField) {
+                                XEUtils.set(fData, startField, null);
+                                XEUtils.set(fData, endField, null);
+                            }
                         }
                         fData[field] = itemValue;
                     }
@@ -781,13 +807,26 @@ export default defineVxeComponent({
                 if (!proxyInited) {
                     reactData.proxyInited = true;
                     if (proxyOpts.autoLoad !== false) {
-                        nextTick().then(() => $xeGantt.commitProxy('initial')).then((rest) => {
+                        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);
@@ -808,15 +847,15 @@ export default defineVxeComponent({
              * @param {String/Object} code 字符串或对象
              */
             commitProxy(proxyTarget, ...args) {
-                const { proxyConfig, toolbarConfig, pagerConfig, editRules, validConfig } = props;
+                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, afterQuery, beforeDelete, afterDelete, beforeSave, afterSave, ajax = {} } = proxyOpts;
-                const resConfigs = proxyOpts.response || proxyOpts.props || {};
+                const { beforeQuery, afterQuery, beforeQueryFooter, afterQueryFooter, beforeDelete, afterDelete, beforeSave, afterSave, ajax = {} } = proxyOpts;
+                const resConfigs = (proxyOpts.response || proxyOpts.props || {});
                 const $xeTable = refTable.value;
                 if (!$xeTable) {
                     return nextTick();
@@ -866,15 +905,16 @@ export default defineVxeComponent({
                     case 'initial':
                     case 'reload':
                     case 'query': {
-                        const ajaxMethods = ajax.query;
-                        const querySuccessMethods = ajax.querySuccess;
-                        const queryErrorMethods = ajax.queryError;
-                        if (ajaxMethods) {
+                        const qMethods = ajax.query;
+                        const qsMethods = ajax.querySuccess;
+                        const qeMethods = ajax.queryError;
+                        if (qMethods) {
                             const isInited = code === 'initial';
                             const isReload = code === 'reload';
                             if (!isInited && reactData.tableLoading) {
                                 return nextTick();
                             }
+                            let operPromise = null;
                             let sortList = [];
                             let filterList = [];
                             let pageParams = {};
@@ -929,7 +969,7 @@ export default defineVxeComponent({
                             else {
                                 if ($xeTable) {
                                     if (isReload) {
-                                        $xeTable.clearAll();
+                                        operPromise = $xeTable.clearAll();
                                     }
                                     else {
                                         sortList = $xeTable.getSortColumns();
@@ -950,22 +990,25 @@ export default defineVxeComponent({
                                 sorts: sortList,
                                 filters: filterList,
                                 form: formData,
-                                options: ajaxMethods
+                                options: qMethods
                             };
                             reactData.sortData = sortList;
                             reactData.filterData = filterList;
                             reactData.tableLoading = true;
-                            return Promise.resolve((beforeQuery || ajaxMethods)(commitParams, ...args))
-                                .then(rest => {
+                            return Promise.all([
+                                Promise.resolve((beforeQuery || qMethods)(commitParams, ...args)),
+                                operPromise
+                            ]).then(([rest]) => {
                                 let tableData = [];
                                 reactData.tableLoading = false;
                                 if (rest) {
+                                    const reParams = { data: rest, $table: $xeTable, $grid: null, $gantt: $xeGantt };
                                     if (pagerConfig && isEnableConf(pagerOpts)) {
                                         const totalProp = resConfigs.total;
-                                        const total = (XEUtils.isFunction(totalProp) ? totalProp({ data: rest, $table: $xeTable, $grid: null, $gantt: $xeGantt }) : XEUtils.get(rest, totalProp || 'page.total')) || 0;
+                                        const total = (XEUtils.isFunction(totalProp) ? totalProp(reParams) : XEUtils.get(rest, totalProp || 'page.total')) || 0;
                                         tablePage.total = XEUtils.toNumber(total);
                                         const resultProp = resConfigs.result;
-                                        tableData = (XEUtils.isFunction(resultProp) ? resultProp({ data: rest, $table: $xeTable, $grid: null, $gantt: $xeGantt }) : XEUtils.get(rest, resultProp || 'result')) || [];
+                                        tableData = (XEUtils.isFunction(resultProp) ? resultProp(reParams) : XEUtils.get(rest, resultProp || 'result')) || [];
                                         // 检验当前页码，不能超出当前最大页数
                                         const pageCount = Math.max(Math.ceil(total / tablePage.pageSize), 1);
                                         if (tablePage.currentPage > pageCount) {
@@ -974,7 +1017,19 @@ export default defineVxeComponent({
                                     }
                                     else {
                                         const listProp = resConfigs.list;
-                                        tableData = (listProp ? (XEUtils.isFunction(listProp) ? listProp({ data: rest, $table: $xeTable, $grid: null, $gantt: $xeGantt }) : XEUtils.get(rest, listProp)) : rest) || [];
+                                        if (XEUtils.isArray(rest)) {
+                                            tableData = rest;
+                                        }
+                                        else if (listProp) {
+                                            tableData = (XEUtils.isFunction(listProp) ? listProp(reParams) : XEUtils.get(rest, listProp)) || [];
+                                        }
+                                    }
+                                    if (showFooter) {
+                                        const fdProp = resConfigs.footerData;
+                                        const footerList = fdProp ? (XEUtils.isFunction(fdProp) ? fdProp(reParams) : XEUtils.get(rest, fdProp)) : [];
+                                        if (XEUtils.isArray(footerList)) {
+                                            reactData.footerData = footerList;
+                                        }
                                     }
                                 }
                                 if ($xeTable) {
@@ -982,6 +1037,7 @@ export default defineVxeComponent({
                                 }
                                 else {
                                     nextTick(() => {
+                                        const $xeTable = refTable.value;
                                         if ($xeTable) {
                                             $xeTable.loadData(tableData);
                                         }
@@ -990,28 +1046,68 @@ export default defineVxeComponent({
                                 if (afterQuery) {
                                     afterQuery(commitParams, ...args);
                                 }
-                                if (querySuccessMethods) {
-                                    querySuccessMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                                if (qsMethods) {
+                                    qsMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
                                 }
                                 return { status: true };
                             }).catch((rest) => {
                                 reactData.tableLoading = false;
-                                if (queryErrorMethods) {
-                                    queryErrorMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                                if (qeMethods) {
+                                    qeMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
                                 }
                                 return { status: false };
                             });
                         }
                         else {
-                            errLog('vxe.error.notFunc', ['proxy-config.ajax.query']);
+                            errLog('vxe.error.notFunc', ['[gantt] proxy-config.ajax.query']);
+                        }
+                        break;
+                    }
+                    case 'queryFooter': {
+                        const qfMethods = ajax.queryFooter;
+                        const qfSuccessMethods = ajax.queryFooterSuccess;
+                        const qfErrorMethods = ajax.queryFooterError;
+                        if (qfMethods) {
+                            let filterList = [];
+                            if ($xeTable) {
+                                filterList = $xeTable.getCheckedFilters();
+                            }
+                            const commitParams = {
+                                $table: $xeTable,
+                                $grid: null,
+                                $gantt: $xeGantt,
+                                code,
+                                button,
+                                filters: filterList,
+                                form: formData,
+                                options: qfMethods
+                            };
+                            return Promise.resolve((beforeQueryFooter || qfMethods)(commitParams, ...args)).then(rest => {
+                                reactData.footerData = XEUtils.isArray(rest) ? rest : [];
+                                if (afterQueryFooter) {
+                                    afterQueryFooter(commitParams, ...args);
+                                }
+                                if (qfSuccessMethods) {
+                                    qfSuccessMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                                }
+                                return { status: true };
+                            }).catch((rest) => {
+                                if (qfErrorMethods) {
+                                    qfErrorMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
+                                }
+                                return { status: false };
+                            });
+                        }
+                        else {
+                            errLog('vxe.error.notFunc', ['[gantt] proxy-config.ajax.queryFooter']);
                         }
                         break;
                     }
                     case 'delete': {
-                        const ajaxMethods = ajax.delete;
+                        const dMethods = ajax.delete;
                         const deleteSuccessMethods = ajax.deleteSuccess;
                         const deleteErrorMethods = ajax.deleteError;
-                        if (ajaxMethods) {
+                        if (dMethods) {
                             const selectRecords = $xeGantt.getCheckboxRecords();
                             const removeRecords = selectRecords.filter(row => !$xeTable.isInsertByRow(row));
                             const body = { removeRecords };
@@ -1023,7 +1119,7 @@ export default defineVxeComponent({
                                 button,
                                 body,
                                 form: formData,
-                                options: ajaxMethods
+                                options: dMethods
                             };
                             if (selectRecords.length) {
                                 return handleDeleteRow(code, 'vxe.grid.deleteSelectRecord', () => {
@@ -1031,7 +1127,7 @@ export default defineVxeComponent({
                                         return $xeTable.remove(selectRecords);
                                     }
                                     reactData.tableLoading = true;
-                                    return Promise.resolve((beforeDelete || ajaxMethods)(commitParams, ...args))
+                                    return Promise.resolve((beforeDelete || dMethods)(commitParams, ...args))
                                         .then(rest => {
                                         reactData.tableLoading = false;
                                         $xeTable.setPendingRow(removeRecords, false);
@@ -1044,7 +1140,10 @@ export default defineVxeComponent({
                                             afterDelete(commitParams, ...args);
                                         }
                                         else {
+                                            internalData.uFoot = true;
                                             $xeGantt.commitProxy('query');
+                                            internalData.uFoot = false;
+                                            updateQueryFooter();
                                         }
                                         if (deleteSuccessMethods) {
                                             deleteSuccessMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
@@ -1074,7 +1173,7 @@ export default defineVxeComponent({
                             }
                         }
                         else {
-                            errLog('vxe.error.notFunc', ['proxy-config.ajax.delete']);
+                            errLog('vxe.error.notFunc', ['[gantt] proxy-config.ajax.delete']);
                         }
                         break;
                     }
@@ -1128,7 +1227,10 @@ export default defineVxeComponent({
                                             afterSave(commitParams, ...args);
                                         }
                                         else {
+                                            internalData.uFoot = true;
                                             $xeGantt.commitProxy('query');
+                                            internalData.uFoot = false;
+                                            updateQueryFooter();
                                         }
                                         if (saveSuccessMethods) {
                                             saveSuccessMethods(Object.assign(Object.assign({}, commitParams), { response: rest }));
@@ -1158,7 +1260,7 @@ export default defineVxeComponent({
                             });
                         }
                         else {
-                            errLog('vxe.error.notFunc', ['proxy-config.ajax.save']);
+                            errLog('vxe.error.notFunc', ['[gantt] proxy-config.ajax.save']);
                         }
                         break;
                     }
@@ -1170,7 +1272,7 @@ export default defineVxeComponent({
                                 tCommandMethod({ code, button, $table: $xeTable, $grid: null, $gantt: $xeGantt }, ...args);
                             }
                             else {
-                                errLog('vxe.error.notCommands', [code]);
+                                errLog('vxe.error.notCommands', [`[grid] ${code}`]);
                             }
                         }
                     }
@@ -1369,6 +1471,7 @@ export default defineVxeComponent({
              * 获取需要排除的高度
              */
             getExcludeHeight() {
+                const { height } = props;
                 const { isZMax } = reactData;
                 const el = refElem.value;
                 if (el) {
@@ -1378,7 +1481,10 @@ export default defineVxeComponent({
                     const bottomWrapper = refBottomWrapper.value;
                     const pagerWrapper = refPagerWrapper.value;
                     const parentEl = el.parentElement;
-                    const parentPaddingSize = isZMax ? 0 : (parentEl ? getPaddingTopBottomSize(parentEl) : 0);
+                    let parentPaddingSize = 0;
+                    if (parentEl && (height === '100%' || height === 'auto')) {
+                        parentPaddingSize = isZMax ? 0 : getPaddingTopBottomSize(parentEl);
+                    }
                     return parentPaddingSize + getPaddingTopBottomSize(el) + getOffsetHeight(formWrapper) + getOffsetHeight(toolbarWrapper) + getOffsetHeight(topWrapper) + getOffsetHeight(bottomWrapper) + getOffsetHeight(pagerWrapper);
                 }
                 return 0;
@@ -1393,11 +1499,23 @@ export default defineVxeComponent({
             },
             triggerToolbarCommitEvent(params, evnt) {
                 const { code } = params;
-                return $xeGantt.commitProxy(params, evnt).then((rest) => {
-                    if (code && 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);
+                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 nextTick();
             },
             triggerToolbarBtnEvent(button, evnt) {
                 $xeGantt.triggerToolbarCommitEvent(button, evnt);

package/es/ui/index.js

@@ -1,7 +1,7 @@
 import { VxeUI } from '@vxe-ui/core';
 import { errLog } from './src/log';
 const { setConfig, setIcon, checkVersion } = VxeUI;
-VxeUI.ganttVersion = "4.0.23";
+VxeUI.ganttVersion = "4.0.25";
 setConfig({
     gantt: {
         // size: null,