design/designer-base/src/main/java/com/fr/design/file/TemplateTabManager.java

package com.fr.design.file;

import com.finebi.cbb.utils.CompareUtils;
import com.fr.design.file.impl.DefaultTemplateTabOperate;
import com.fr.design.file.impl.EmptyTemplateTabOperator;
import com.fr.design.mainframe.DesignerContext;
import com.fr.design.mainframe.JTemplate;
import com.fr.file.FILE;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author kerry
 * @since 11.0
 * created on 2023-04-14
 **/
public class TemplateTabManager {
    private static class HOLDER {
        private static final TemplateTabManager SINGLETON = new TemplateTabManager();
    }

    /**
     * 返回TemplateTabManager单例对象
     * @return
     */
    public static TemplateTabManager getInstance() {
        return HOLDER.SINGLETON;
    }

    private TemplateTabManager() {
        list.add(DefaultTemplateTabOperate.getInstance());
    }

    private List<TemplateTabOperateProvider> list = new ArrayList<>();

    /**
     * 支持注册新的Operator
     * @param templateTabOperateProvider
     */
    public void register(TemplateTabOperateProvider templateTabOperateProvider) {
        this.list.add(templateTabOperateProvider);
    }

    /**
     * 移除operator
     * @param templateTabOperateProvider
     */
    public void remove(TemplateTabOperateProvider templateTabOperateProvider) {
        this.list.remove(templateTabOperateProvider);
    }

    private boolean closeCurrent = false;
    //自动新建的模板B若没有进行任何编辑，切换到其他

    // 模板时，模板B会自动关闭
    private JTemplate<?, ?> temTemplate = null;


    public boolean isCloseCurrent() {
        return closeCurrent;
    }

    public void setCloseCurrent(boolean closeCurrent) {
        this.closeCurrent = closeCurrent;
    }

    public void setTemTemplate(JTemplate<?, ?> temTemplate) {
        this.temTemplate = temTemplate;
    }

    /**
     * 刷新tab栏
     */
    public void refresh() {
        getCurrentOperator().refresh();
    }

    /**
     * 从模板树删除文件
     */
    public void deleteOpenedTemplate(JTemplate<?, ?> template) {
        TemplateTabOperateProvider provider = getOperatorByTemplate(template);
        provider.deleteOpenedTemplate(template);
        this.refresh();
    }

    public JTemplate getSelectedFile() {
        return getCurrentOperator().getSelectedFile();
    }

    /**
     * 关闭掉当前文件列表中指定的文件
     *
     * @param file 指定的文件
     */
    public void closeFileTemplate(FILE file) {
        for (TemplateTabOperateProvider provider : list) {
            provider.closeFileTemplate(file);
        }
    }

    /**
     * 关闭指定模板
     *
     * @param specifiedTemplate
     */
    public void closeSpecifiedTemplate(JTemplate<?, ?> specifiedTemplate) {
        getCurrentOperator().closeSpecifiedTemplate(specifiedTemplate);
    }


    /**
     * 刷新打开模板
     *
     * @param tempalteLsit
     */
    public void refreshOpenedTemplate(List<JTemplate<?, ?>> tempalteLsit) {
        for (TemplateTabOperateProvider provider : list) {
            provider.refreshOpenedTemplate(tempalteLsit);
        }
    }


    /**
     * 处理自动新建的模板 在切换时的处理
     */
    public void doWithtemTemplate() {
        //temtemplate保存的一定是手动新建的没有编辑或是编辑了没有保存的模板
        //没有保存，说明有编辑；已经保存在磁盘里的文件，说明有过处理，并且已经保存，此时切换都不将其自动关闭
        if (temTemplate == null || temTemplate == HistoryTemplateListCache.getInstance().getCurrentEditingTemplate()) {
            return;
        }

        if (!temTemplate.isSaved() || !temTemplate.getEditingFILE().isMemFile()) {
            temTemplate = null;
        }

        //自动新建的模板B若没有进行任何编辑(新建模板没有进行任何编辑时saved都是true):还没有存盘
        if (temTemplate != null && temTemplate.getEditingFILE().isMemFile() && temTemplate.isSaved()) {
            HistoryTemplateListCache.getInstance().closeSelectedReport(temTemplate);
            temTemplate = null;
            resetSelectIndex(HistoryTemplateListCache.getInstance().getCurrentEditingTemplate());
        }
    }


    /**
     * 重置选中index
     * @param jTemplate
     */
    public void resetSelectIndex(JTemplate jTemplate) {
        getCurrentOperator().resetSelectIndex(jTemplate);
    }


    /**
     * 激活新模板
     */
    public void activeNewTemplate() {
        //先看其他模式中是否有已打开的模板，有的话切换过去
        for (TemplateTabOperateProvider templateTabOperateProvider : list) {
            if (templateTabOperateProvider.getOpenedJTemplates().size() != 0) {
                templateTabOperateProvider.getSelectedFile().activeNewJTemplate();
                refresh();
                return;

            }
        }
        //都没有的话，新建并激活模板
        DesignerContext.getDesignerFrame().addAndActivateJTemplate();
        //此时刚自动新建的模板在HistoryTemplateListCache的editingTemplate
        TemplateTabManager.getInstance().setTemTemplate(HistoryTemplateListCache.getInstance().getCurrentEditingTemplate());
        refresh();
    }

    /**
     * 后台关闭当前编辑模板
     */
    public void closeCurrentTpl() {
        JTemplate jTemplate = HistoryTemplateListCache.getInstance().getCurrentEditingTemplate();
        this.setCloseCurrent(true);
        this.closeFormat(jTemplate);
        this.closeSpecifiedTemplate(jTemplate);
    }


    /**
     * 关闭指定索引值模板
     *
     * @param index
     */
    public void closeByIndex(int index) {
        getCurrentOperator().closeByIndex(index);
    }

    /**
     * 关闭指定索引值模板
     *
     * @param jTemplate
     */
    public void closeByJTemplate(JTemplate jTemplate) {
        TemplateTabOperateProvider operator = getOperatorByOperatorType(jTemplate.getTemplateTabOperatorType());
        operator.closeByIndex(operator.getJTemplateIndex(jTemplate));
    }

    /**
     * 切换到指定tab栏的指定索引值模板
     *
     * @param jTemplate
     */
    public void switchByJTemplate(JTemplate jTemplate) {
        TemplateTabOperateProvider operator = getOperatorByOperatorType(jTemplate.getTemplateTabOperatorType());
        operator.switchTpl(operator.getJTemplateIndex(jTemplate));
    }

    /**
     * 获取所有打开的模板map
     *
     * @return
     */
    public Map<String, List<JTemplate<?, ?>>> getAllOpenedTemplateMap() {
        Map<String, List<JTemplate<?, ?>>> resultMap = new HashMap<>();
        for (TemplateTabOperateProvider provider : list) {
            resultMap.put(provider.getOperatorType(), provider.getOpenedJTemplates());
        }
        return resultMap;
    }

    /**
     * 关闭其他
     */
    public void closeOthers() {
        TemplateTabOperateProvider currentOperator = getCurrentOperator();
        currentOperator.closeAction(CloseOption.Others,
                currentOperator.getJTemplateIndex(HistoryTemplateListCache.getInstance().getCurrentEditingTemplate()));
    }

    public String getTemplateShowName(JTemplate temTemplate){
        return getCurrentOperator().getTemplateShowName(temTemplate);
    }


    /**
     * 关闭模板
     *
     * @param closedTemplate 模板
     */
    public void closeFormat(JTemplate closedTemplate) {
        //表单不需要处理
        if (!closedTemplate.isJWorkBook()) {
            return;
        }

        if (DesignerContext.getFormatState() == DesignerContext.FORMAT_STATE_NULL) {
            return;
        }

        //是被参照的模板被关闭，则重置格式刷
        closedTemplate.doConditionCancelFormat();
    }


    public TemplateTabOperateProvider getCurrentOperator() {
        return getOperatorByTemplate(HistoryTemplateListCache.getInstance().getCurrentEditingTemplate());
    }

    private TemplateTabOperateProvider getOperatorByTemplate(JTemplate jTemplate) {
        return getOperatorByOperatorType(jTemplate.getTemplateTabOperatorType());
    }

    private TemplateTabOperateProvider getOperatorByOperatorType(String type) {
        for (TemplateTabOperateProvider provider : list) {
            if (CompareUtils.isEqual(provider.getOperatorType(), type)) {
                return provider;
            }
        }
        return EmptyTemplateTabOperator.getInstance();
    }

}