feat(delete cell): delete cell

delete cell

src/controllers/controlHistory.js

@@ -13,6 +13,7 @@ import {
     jfrefreshrange, 
     jfrefreshgrid_rhcw, 
     jfrefreshgrid_adRC,
+    jfrefreshgrid_deleteCell,
     jfrefreshgrid_pastcut,
     luckysheetrefreshgrid 
 } from '../global/refresh';
@@ -139,6 +140,9 @@ const controlHistory = {
 
             jfrefreshgrid_adRC(ctr.data, ctr.config, "addRC", ctrlValue, ctr.calc, ctr.filterObj, ctr.cf, ctr.af, ctr.freezen);
         }
+        else if (ctr.type == "deleteCell") { //删除单元格撤销操作
+            jfrefreshgrid_deleteCell(ctr.data, ctr.config, ctr.ctrl, ctr.calc, ctr.filterObj, ctr.cf);
+        }
         else if (ctr.type == "showHidRows") { // 隐藏、显示行 撤销操作
             //config
             Store.config = ctr.config;
@@ -381,6 +385,9 @@ const controlHistory = {
         else if (ctr.type == "delRC") { //删除行列重做操作
             jfrefreshgrid_adRC(ctr.curData, ctr.curConfig, "delRC", ctr.ctrlValue, ctr.curCalc, ctr.curFilterObj, ctr.curCf, ctr.curAf, ctr.curFreezen);
         }
+        else if (ctr.type == "deleteCell") { //删除单元格重做操作
+            jfrefreshgrid_deleteCell(ctr.curData, ctr.curConfig, ctr.ctrl, ctr.curCalc, ctr.curFilterObj, ctr.curCf);
+        }
         else if (ctr.type == "showHidRows") { // 隐藏、显示行 重做操作
             //config
             Store.config = ctr.curconfig;

src/controllers/filter.js

@@ -745,6 +745,10 @@ function initialFilterHandler(){
     
                 //单元格颜色
                 let bg = menuButton.checkstatus(Store.flowdata, r, cindex , "bg");
+
+                if(bg == null){
+                    bg = "#ffffff";
+                }
     
                 let checksAF = alternateformat.checksAF(r, cindex, af_compute);
                 if(checksAF != null){//若单元格有交替颜色

src/controllers/rowColumnOperation.js

@@ -21,7 +21,7 @@ import {
 import { isRealNull, isRealNum, hasPartMC, isEditMode } from '../global/validate';
 import { countfunc } from '../global/count';
 import formula from '../global/formula';
-import { luckysheetextendtable, luckysheetdeletetable } from '../global/extend';
+import { luckysheetextendtable, luckysheetdeletetable, luckysheetDeleteCell } from '../global/extend';
 import { 
     jfrefreshgrid, 
     jfrefreshgridall, 
@@ -1367,6 +1367,54 @@ export function rowColumnOperationInitial(){
         jfrefreshgrid_rhcw(Store.flowdata.length, Store.flowdata[0].length);
     })
 
+    //删除单元格（左移、上移）
+    $("#luckysheet-delCellsMoveLeft").click(function (event) {
+        $("#luckysheet-rightclick-menu").hide();
+        luckysheetContainerFocus();
+
+        const locale_drag = locale().drag;
+
+        if(Store.luckysheet_select_save.length > 1){
+            if(isEditMode()){
+                alert(locale_drag.noMulti);
+            }
+            else{
+                tooltip.info(locale_drag.noMulti, ""); 
+            }
+            return;
+        }
+
+        let str = Store.luckysheet_select_save[0].row[0],
+            edr = Store.luckysheet_select_save[0].row[1],
+            stc = Store.luckysheet_select_save[0].column[0],
+            edc = Store.luckysheet_select_save[0].column[1];
+
+        luckysheetDeleteCell('moveLeft', str, edr, stc, edc);
+    });
+    $("#luckysheet-delCellsMoveUp").click(function (event) {
+        $("#luckysheet-rightclick-menu").hide();
+        luckysheetContainerFocus();
+
+        const locale_drag = locale().drag;
+
+        if(Store.luckysheet_select_save.length > 1){
+            if(isEditMode()){
+                alert(locale_drag.noMulti);
+            }
+            else{
+                tooltip.info(locale_drag.noMulti, ""); 
+            }
+            return;
+        }
+
+        let str = Store.luckysheet_select_save[0].row[0],
+            edr = Store.luckysheet_select_save[0].row[1],
+            stc = Store.luckysheet_select_save[0].column[0],
+            edc = Store.luckysheet_select_save[0].column[1];
+
+        luckysheetDeleteCell('moveUp', str, edr, stc, edc);
+    });
+
     //清除单元格内容
     $("#luckysheet-delete-text").click(function(){
         $("#luckysheet-rightclick-menu").hide();

src/global/extend.js

@@ -1,8 +1,9 @@
 import editor from './editor';
 import formula from './formula';
-import { jfrefreshgrid_adRC, jfrefreshgrid_rhcw } from './refresh';
+import { jfrefreshgrid_adRC, jfrefreshgrid_deleteCell, jfrefreshgrid_rhcw } from './refresh';
 import { datagridgrowth } from './getdata';
 import { setcellvalue } from './setdata';
+import conditionformat from '../controllers/conditionformat';
 import luckysheetFreezen from '../controllers/freezen';
 import { selectHightlightShow } from '../controllers/select';
 import { luckysheet_searcharray } from '../controllers/sheetSearch';
@@ -808,6 +809,7 @@ function luckysheetextendData(rowlen, newData) {
     jfrefreshgrid_rhcw(Store.flowdata.length, Store.flowdata[0].length);
 }
 
+//删除行列
 function luckysheetdeletetable(type, st, ed) {
     let d = editor.deepCopyFlowData(Store.flowdata);
     let file = Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)];
@@ -1481,8 +1483,482 @@ function luckysheetdeletetable(type, st, ed) {
     );
 }
 
+//删除单元格
+function luckysheetDeleteCell(type, str, edr, stc, edc) {
+    let d = editor.deepCopyFlowData(Store.flowdata);
+    let file = Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)];
+
+    let rlen = edr - str + 1;
+    let clen = edc - stc + 1;
+    let cfg = $.extend(true, {}, Store.config);
+
+    //合并单元格配置变动
+    if(cfg["merge"] == null){
+        cfg["merge"] = {};
+    }
+
+    let merge_new = {};
+    for(let m in cfg["merge"]){
+        let mc = cfg["merge"][m];
+
+        let r = mc.r,
+            c = mc.c,
+            rs = mc.rs,
+            cs = mc.cs;
+
+        if(type == "moveLeft"){
+            if(str > r + rs - 1 || edr < r || stc > c + cs - 1){
+                merge_new[r + "_" + c] = { "r": r, "c": c, "rs": rs, "cs": cs };
+            }
+            else if(str <= r && edr >= r + rs - 1 && edc < c){
+                merge_new[r + "_" + (c - clen)] = { "r": r, "c": c - clen, "rs": rs, "cs": cs };
+            }
+        }
+        else if(type == "moveUp"){
+            if(stc > c + cs - 1 || edc < c || str > r + rs - 1){
+                merge_new[r + "_" + c] = { "r": r, "c": c, "rs": rs, "cs": cs };
+            }
+            else if(stc <= c && edc >= c + cs - 1 && edr < r){
+                merge_new[(r - rlen) + "_" + c] = { "r": r - rlen, "c": c, "rs": rs, "cs": cs };
+            }
+        }
+    }
+    cfg["merge"] = merge_new;
+
+    //公式配置变动
+    let calcChain = file.calcChain;
+    let newCalcChain = [];
+    if(calcChain != null && calcChain.length > 0){
+        for(let i = 0; i < calcChain.length; i++){
+            let calc = $.extend(true, {}, calcChain[i]);
+            let calc_r = calc.r, calc_c = calc.c, calc_i = calc.index, calc_funcStr = calc.func[2];
+
+            if((calc_r < str || calc_r > edr) && (calc_c < stc || calc_c > edc)){
+                let functionStr;
+
+                if(type == 'moveLeft'){
+                    functionStr = "=" + formula.functionStrChange(calc_funcStr, "del", "col", null, stc, clen);
+                
+                    if(calc_c > edc){
+                        calc.c = calc_c - clen;
+                    }
+                }
+                else if(type == 'moveUp'){
+                    functionStr = "=" + formula.functionStrChange(calc_funcStr, "del", "row", null, str, rlen);
+                
+                    if(calc_r > edr){
+                        calc.r = calc_r - rlen;
+                    }
+                }
+
+                if(d[calc_r][calc_c].f == calc_funcStr){
+                    d[calc_r][calc_c].f = functionStr;
+                }
+
+                calc.func[2] = functionStr;
+
+                newCalcChain.push(calc);
+            }
+        }
+    }
+
+    //筛选配置变动
+    let filter_select = file.filter_select;
+    let filter = file.filter;
+    let newFilterObj = null;
+    if(filter_select != null && JSON.stringify(filter_select) != "{}"){
+        newFilterObj = { "filter_select": null, "filter": null };
+
+        let f_r1 = filter_select.row[0], f_r2 = filter_select.row[1];
+        let f_c1 = filter_select.column[0], f_c2 = filter_select.column[1];
+        
+        if(type == 'moveUp'){
+            if(f_c1 >= stc && f_c2 <= edc){
+                if(f_r1 > edr){
+                    newFilterObj.filter_select = {
+                        "row": [f_r1 - rlen, f_r2 - rlen],
+                        "column": [f_c1, f_c2]
+                    }
+                }
+                else if(f_r2 < str){
+                    newFilterObj.filter_select = {
+                        "row": [f_r1, f_r2],
+                        "column": [f_c1, f_c2]
+                    }
+                }
+                else if(f_r1 < str){
+                    if(f_r2 > edr){
+                        newFilterObj.filter_select = {
+                            "row": [f_r1, f_r2 - rlen],
+                            "column": [f_c1, f_c2]
+                        }
+                    }
+                    else{
+                        newFilterObj.filter_select = {
+                            "row": [f_r1, str - 1],
+                            "column": [f_c1, f_c2]
+                        }
+                    }
+                }
+
+                if(newFilterObj.filter_select != null && filter != null){
+                    for(let k in filter){
+                        let f_rowhidden = filter[k].rowhidden;
+                        let f_rowhidden_new = {};
+        
+                        for(let n in f_rowhidden){
+                            if(n < str){
+                                f_rowhidden_new[n] = 0;
+                            }
+                            else if(n > edr){
+                                f_rowhidden_new[n - slen] = 0;
+                            }
+                        }
+
+                        if(newFilterObj.filter == null){
+                            newFilterObj.filter = {};
+                        }
+                        newFilterObj.filter[k] = $.extend(true, {}, filter[k]);
+        
+                        if(JSON.stringify(f_rowhidden_new) != "{}"){
+                            newFilterObj.filter[k].rowhidden = f_rowhidden_new;
+                        }
+        
+                        newFilterObj.filter[k].str = newFilterObj.filter_select.row[0];
+                        newFilterObj.filter[k].edr = newFilterObj.filter_select.row[1];
+                    }
+                }
+            }
+            else if(f_r1 >= str && f_r2 <= edr){
+                if(f_c1 > edc){
+                    newFilterObj.filter_select = {
+                        "row": [f_r1, f_r2],
+                        "column": [f_c1, f_c2]
+                    }
+                }
+                else if(f_c1 >= stc){
+                    if(f_c2 > edc){
+                        newFilterObj.filter_select = {
+                            "row": [f_r1, f_r2],
+                            "column": [stc, f_c2 - clen]
+                        }
+                    }
+                }
+                else{
+                    if(f_c2 < stc){
+                        newFilterObj.filter_select = {
+                            "row": [f_r1, f_r2],
+                            "column": [f_c1, f_c2]
+                        }
+                    }
+                    else if(f_c2 <= edc){
+                        newFilterObj.filter_select = {
+                            "row": [f_r1, f_r2],
+                            "column": [f_c1, stc - 1]
+                        }
+                    }
+                    else{
+                        newFilterObj.filter_select = {
+                            "row": [f_r1, f_r2],
+                            "column": [f_c1, f_c2 - clen]
+                        }
+                    }
+                }
+
+                if(newFilterObj.filter_select != null && filter != null){
+                    for(let k in filter){
+                        let f_stc = newFilterObj.filter_select.column[0];
+                        let f_edc = newFilterObj.filter_select.column[1];
+                        let f_cindex = filter[k].cindex;
+
+                        if(f_cindex < stc || f_cindex > edc){
+                            if(newFilterObj.filter == null){
+                                newFilterObj.filter = {};
+                            }
+
+                            if(f_cindex > edc){
+                                f_cindex -= clen;
+                            }
+
+                            let k2 = f_cindex - f_stc;
+
+                            newFilterObj.filter[k2] = $.extend(true, {}, filter[k]);
+                            newFilterObj.filter[k2].cindex = f_cindex;
+                            newFilterObj.filter[k2].stc = f_stc;
+                            newFilterObj.filter[k2].edc = f_edc;
+                        }
+                    }
+                }
+            }
+            else{
+                newFilterObj.filter_select = {
+                    "row": [f_r1, f_r2],
+                    "column": [f_c1, f_c2]
+                }
+
+                if(filter != null){
+                    newFilterObj.filter = filter;
+                }
+            }
+        }
+        else if(type == 'moveLeft'){
+            if(f_r1 >= str && f_r2 <= edr){
+                if(f_c1 > edc){
+                    newFilterObj.filter_select = {
+                        "row": [f_r1, f_r2],
+                        "column": [f_c1 - clen, f_c2 - clen]
+                    }
+                }
+                else if(f_c2 < stc){
+                    newFilterObj.filter_select = {
+                        "row": [f_r1, f_r2],
+                        "column": [f_c1, f_c2]
+                    }
+                }
+                else if(f_c1 < stc){
+                    if(f_c2 > edc){
+                        newFilterObj.filter_select = {
+                            "row": [f_r1, f_r2],
+                            "column": [f_c1, f_c2 - clen]
+                        }
+                    }
+                    else{
+                        newFilterObj.filter_select = {
+                            "row": [f_r1, f_r2],
+                            "column": [f_c1, stc - 1]
+                        }
+                    }
+                }
+
+                if(newFilterObj.filter_select != null && filter != null){
+                    for(let k in filter){
+                        let f_stc = newFilterObj.filter_select.column[0];
+                        let f_edc = newFilterObj.filter_select.column[1];
+                        let f_cindex = filter[k].cindex;
+
+                        if(f_cindex < stc || f_cindex > edc){
+                            if(newFilterObj.filter == null){
+                                newFilterObj.filter = {};
+                            }
+
+                            if(f_cindex > edc){
+                                f_cindex -= clen;
+                            }
+
+                            let k2 = f_cindex - f_stc;
+
+                            newFilterObj.filter[k2] = $.extend(true, {}, filter[k]);
+                            newFilterObj.filter[k2].cindex = f_cindex;
+                            newFilterObj.filter[k2].stc = f_stc;
+                            newFilterObj.filter[k2].edc = f_edc;
+                        }
+                    }
+                }
+            }
+            else if(f_c1 >= stc && f_c2 <= edc){
+                if(f_r1 < str || f_r1 > edr){
+                    newFilterObj.filter_select = {
+                        "row": [f_r1, f_r2],
+                        "column": [f_c1, f_c2]
+                    }
+
+                    if(filter != null){
+                        newFilterObj.filter = filter;
+                    }
+                }
+            }
+            else{
+                newFilterObj.filter_select = {
+                    "row": [f_r1, f_r2],
+                    "column": [f_c1, f_c2]
+                }
+
+                if(filter != null){
+                    newFilterObj.filter = filter;
+                }
+            }
+        }
+    }
+
+    if(newFilterObj != null && newFilterObj.filter != null){
+        cfg["rowhidden"] = {};
+
+        for(let k in newFilterObj.filter){
+            let f_rowhidden = newFilterObj.filter[k].rowhidden;
+
+            for(let n in f_rowhidden){
+                cfg["rowhidden"][n] = 0;
+            }
+        }
+    }
+    else{
+        delete cfg["rowhidden"];
+    }
+
+    //条件格式配置变动
+    let CFarr = file.luckysheet_conditionformat_save;
+    let newCFarr = [];
+    if(CFarr != null && CFarr.length > 0){
+        for(let i = 0; i < CFarr.length; i++){
+            let cf_range = CFarr[i].cellrange;
+            let cf_new_range = [];
+
+            for(let j = 0; j < cf_range.length; j++){
+                let CFr1 = cf_range[j].row[0],
+                    CFr2 = cf_range[j].row[1],
+                    CFc1 = cf_range[j].column[0],
+                    CFc2 = cf_range[j].column[1];
+
+                if(!(str > CFr2 || edr < CFr1) || !(stc > CFc2 || edc < CFc1)){
+                    let range = conditionformat.CFSplitRange(
+                        cf_range[j], 
+                        { "row": [str, edr], "column": [stc, edc] }, 
+                        { "row": [str, edr], "column": [stc, edc] }, 
+                        "restPart"
+                    );
+
+                    cf_new_range.concat(range);
+                }
+                else{
+                    cf_new_range.push(cf_range[j]);
+                }
+            }
+
+            if(cf_new_range.length > 0){
+                let cf = $.extend(true, {}, CFarr[i]);
+                cf.cellrange = cf_new_range;
+
+                newCFarr.push(cf);
+            }
+        }
+    }
+
+    //边框配置变动
+    if(cfg["borderInfo"] && cfg["borderInfo"].length > 0){
+        let borderInfo = []; 
+
+        for(let i = 0; i < cfg["borderInfo"].length; i++){
+            let rangeType = cfg["borderInfo"][i].rangeType;
+
+            if(rangeType == "range"){
+                let borderRange = cfg["borderInfo"][i].range;
+
+                let emptyRange = [];
+
+                for(let j = 0; j < borderRange.length; j++){
+                    let bd_r1 = borderRange[j].row[0],
+                        bd_r2 = borderRange[j].row[1],
+                        bd_c1 = borderRange[j].column[0],
+                        bd_c2 = borderRange[j].column[1];
+
+                    if(!(str > bd_r2 || edr < bd_r1) || !(stc > bd_c2 || edc < bd_c1)){
+                        let range = conditionformat.CFSplitRange(
+                            borderRange[j], 
+                            { "row": [str, edr], "column": [stc, edc] }, 
+                            { "row": [str, edr], "column": [stc, edc] }, 
+                            "restPart"
+                        );
+    
+                        emptyRange.concat(range);
+                    }
+                    else{
+                        emptyRange.push(borderRange[j]);
+                    }
+                }
+
+                if(emptyRange.length > 0){
+                    let bd_obj = {
+                        "rangeType": "range",
+                        "borderType": cfg["borderInfo"][i].borderType,
+                        "style": cfg["borderInfo"][i].style,
+                        "color": cfg["borderInfo"][i].color,
+                        "range": emptyRange
+                    }
+
+                    borderInfo.push(bd_obj);
+                }
+            }
+            else if(rangeType == "cell"){
+                let row_index = cfg["borderInfo"][i].value.row_index;
+                let col_index = cfg["borderInfo"][i].value.col_index;
+
+                if(row_index < str || col_index < stc){
+                    borderInfo.push(cfg["borderInfo"][i]);
+                }
+                else if(row_index > edr || col_index > edc){
+                    if(row_index > edr){
+                        row_index -= rlen;
+                        cfg["borderInfo"][i].value.row_index = row_index;
+                    }
+
+                    if(col_index > edc){
+                        col_index -= clen;
+                        cfg["borderInfo"][i].value.col_index = col_index;
+                    }
+
+                    borderInfo.push(cfg["borderInfo"][i]);
+                }
+            }
+        }
+
+        cfg["borderInfo"] = borderInfo;
+    }
+    
+    //空白列模板
+    let addcol = [];
+    for (let c = stc; c <= edc; c++) {
+        addcol.push(null);
+    }
+
+    if(type == 'moveUp'){//上移
+        let data = [];
+
+        for(let r = str; r <= d.length - 1; r++){
+            let row = [];
+
+            for(let c = stc; c <= edc; c++){
+                row.push(d[r][c]);
+            }
+
+            data.push(row);
+        }
+
+        data.splice(0, rlen);
+
+        //空白行模板
+        let addrow = [];
+        for (let r = str; r <= edr; r++) {
+            addrow.push(addcol);
+        }
+
+        data = data.concat(addrow);
+
+        for(let r = str; r <= d.length - 1; r++){
+            for(let c = stc; c <= edc; c++){
+                d[r][c] = data[r - str][c - stc];
+            }
+        }
+    }
+    else if(type == 'moveLeft'){//左移
+        for(let r = str; r <= edr; r++){
+            d[r].splice(stc, clen);
+            d[r] = d[r].concat(addcol);
+        }
+    }
+
+    jfrefreshgrid_deleteCell(
+        d,
+        cfg,
+        { type: type, 'str': str, 'edr': edr, 'stc': stc, 'edc': edc },
+        newCalcChain,
+        newFilterObj,
+        newCFarr
+    );
+}
+
 export {
     luckysheetextendtable,
     luckysheetextendData,
     luckysheetdeletetable,
+    luckysheetDeleteCell,
 }

src/global/refresh.js

@@ -519,6 +519,162 @@ function jfrefreshgrid_adRC(data, cfg, ctrlType, ctrlValue, calc, filterObj, cf,
     jfrefreshgrid_rhcw(Store.flowdata.length, Store.flowdata[0].length);
 }
 
+//删除单元格 刷新表格
+function jfrefreshgrid_deleteCell(data, cfg, ctrl, calc, filterObj, cf){
+    let file = Store.luckysheetfile[getSheetIndex(Store.currentSheetIndex)];
+
+    //merge改变对应的单元格值改变
+    let mcData = [];
+    if(JSON.stringify(cfg["merge"]) == "{}"){
+        for(let r = 0; r < data.length; r++){
+            for(let c = 0; c < data[0].length; c++){
+                let cell = data[r][c];
+    
+                if(cell != null && cell.mc != null){
+                    delete cell.mc;
+                    mcData.push({ "r": r, "c": c });
+                }
+            }
+        }
+    }
+    else{
+        for(let m in cfg["merge"]){
+            let mc = cfg["merge"][m];
+    
+            for(let r = mc.r; r <= mc.r + mc.rs - 1; r++){
+                for(let c = mc.c; c <= mc.c + mc.cs - 1; c++){
+                    if(data[r][c] == null){
+                        data[r][c] = {};
+                    }
+    
+                    if(r == mc.r && c == mc.c){
+                        data[r][c].mc = mc;
+                    }
+                    else{
+                        data[r][c].mc = { "r": mc.r, "c": mc.c };
+                    }
+    
+                    mcData.push({ "r": r, "c": c });                       
+                }
+            }
+        }
+    }
+
+    //公式链中公式范围改变对应单元格值的改变
+    let funcData = [];
+    if(calc.length > 0){
+        formula.execFunctionGroupData = data;
+
+        for(let i = 0; i < calc.length; i++){
+            let clc = calc[i];
+            let clc_r = clc.r, clc_c = clc.c, clc_i = clc.index, clc_funcStr = clc.func[2];
+            let clc_result = formula.execfunction(clc_funcStr, clc_r, clc_c, null, true);
+            clc.func = clc_result;
+
+            if(data[clc_r][clc_c].f == clc_funcStr){
+                setcellvalue(clc_r, clc_c, data, clc_result[1]);
+                funcData.push({ "r": clc_r, "c": clc_c });
+            }
+        }
+    }
+
+    if(Store.clearjfundo){
+        Store.jfundo = [];
+
+        Store.jfredo.push({
+            "type": "deleteCell",
+            "sheetIndex": Store.currentSheetIndex,
+            "ctrl": ctrl,
+            "data": Store.flowdata,
+            "curData": data,
+            "config": $.extend(true, {}, Store.config),
+            "curConfig": cfg,
+            "mcData": mcData,
+            "calc": $.extend(true, [], file.calcChain),
+            "curCalc": calc,
+            "funcData": funcData,
+            "filterObj": { "filter_select": $.extend(true, {}, file.filter_select), "filter": $.extend(true, {}, file.filter) },
+            "curFilterObj": filterObj,
+            "cf": $.extend(true, [], file.luckysheet_conditionformat_save),
+            "curCf": cf,
+        });
+    }
+
+    //Store.flowdata
+    Store.flowdata = data;
+    editor.webWorkerFlowDataCache(Store.flowdata);//worker存数据
+    file.data = data;
+
+    //共享编辑模式
+    if(server.allowUpdate){
+        let type = ctrl.type,
+            str = ctrl.str,
+            edr = ctrl.edr,
+            stc = ctrl.stc,
+            edc = ctrl.edc;
+
+        let range;
+        if(type == 'moveUp'){
+            range = {
+                "row": [str, data.length - 1],
+                "column": [stc, edc]
+            }
+        }
+        else if(type == 'moveLeft'){
+            range = {
+                "row": [str, edr],
+                "column": [stc, data[0].length - 1]
+            };
+        }
+
+        server.historyParam(Store.flowdata, Store.currentSheetIndex, range);
+    }
+
+    //config
+    Store.config = cfg;
+    file.config = Store.config;
+    server.saveParam("all", Store.currentSheetIndex, cfg, { "k": "config" });
+
+    //mcData
+    for(let i = 0; i < mcData.length; i++){
+        let mcData_r = mcData[i].r,
+            mcData_c = mcData[i].c;
+
+        server.saveParam("v", Store.currentSheetIndex, Store.flowdata[mcData_r][mcData_c], { "r": mcData_r, "c": mcData_c });
+    }
+
+    //calc函数链
+    file.calcChain = calc;
+    server.saveParam("all", Store.currentSheetIndex, calc, { "k": "calcChain" });
+    for(let i = 0; i < funcData.length; i++){
+        let funcData_r = funcData[i].r,
+            funcData_c = funcData[i].c;
+
+        server.saveParam("v", Store.currentSheetIndex, Store.flowdata[funcData_r][funcData_c], { "r": funcData_r, "c": funcData_c });
+    }
+
+    //筛选配置
+    if(filterObj != null){
+        file.filter_select = filterObj.filter_select;
+        file.filter = filterObj.filter;
+    }
+    else{
+        file.filter_select = null;
+        file.filter = null;
+    }
+    createFilterOptions(file.filter_select, file.filter);
+    server.saveParam("all", Store.currentSheetIndex, file.filter_select, { "k": "filter_select" });
+    server.saveParam("all", Store.currentSheetIndex, file.filter, { "k": "filter" });
+
+    //条件格式配置
+    file.luckysheet_conditionformat_save = cf;
+    server.saveParam("all", Store.currentSheetIndex, file.luckysheet_conditionformat_save, { "k": "luckysheet_conditionformat_save" });
+
+    setTimeout(function () {
+        luckysheetrefreshgrid();
+    }, 1);
+}
+
 //复制剪切 刷新表格
 function jfrefreshgrid_pastcut(source, target, RowlChange){
     //单元格数据更新联动
@@ -1002,6 +1158,7 @@ export {
     jfrefreshgridall,
     jfrefreshrange,
     jfrefreshgrid_adRC,
+    jfrefreshgrid_deleteCell,
     jfrefreshgrid_pastcut,
     jfrefreshgrid_rhcw,
     luckysheetrefreshgrid,

src/locale/en.js

@@ -492,6 +492,7 @@ export default {
         paste: 'Paste',
         insert: 'Insert',
         delete: 'Delete',
+        deleteCell: 'Delete cell',
         deleteSelected: 'Delete selected ',
         hide: 'Hide',
         hideSelected: 'Hide selected ',
@@ -501,6 +502,8 @@ export default {
         right: 'Right',
         top: 'Top',
         bottom: 'Bottom',
+        moveLeft: 'Move left',
+        moveUp: 'Move up',
         add: 'Add',
         row: 'Row',
         column: 'Column',

src/locale/zh.js

@@ -509,6 +509,7 @@ export default {
         paste: '粘贴',
         insert: '插入',
         delete: '删除',
+        deleteCell: '删除单元格',
         deleteSelected: '删除选中',
         hide: '隐藏',
         hideSelected: '隐藏选中',
@@ -518,6 +519,8 @@ export default {
         right: '右',
         top: '上',
         bottom: '下',
+        moveLeft: '左移',
+        moveUp: '上移',
         add: '增加',
         row: '行',
         column: '列',