design/designer-base/src/main/java/com/fr/design/mainframe/DesignerFrameFileDealerPane.java

package com.fr.design.mainframe;

import com.fr.base.BaseUtils;
import com.fr.base.extension.FileExtension;
import com.fr.base.vcs.DesignerMode;
import com.fr.chartx.TwoTuple;
import com.fr.design.DesignModelAdapter;
import com.fr.design.DesignerEnvManager;
import com.fr.design.ExtraDesignClassManager;
import com.fr.design.actions.UpdateAction;
import com.fr.design.actions.file.DelFileAction;
import com.fr.design.actions.file.LocateAction;
import com.fr.design.actions.file.RenameAction;
import com.fr.design.constants.UIConstants;
import com.fr.design.data.DesignTableDataManager;
import com.fr.design.data.datapane.TableDataTreePane;
import com.fr.design.data.datapane.management.search.TableDataTreeSearchManager;
import com.fr.design.data.tabledata.ResponseDataSourceChange;
import com.fr.design.dialog.BasicDialog;
import com.fr.design.dialog.FineJOptionPane;
import com.fr.design.file.FileOperations;
import com.fr.design.file.FileToolbarStateChangeListener;
import com.fr.design.file.HistoryTemplateListCache;
import com.fr.design.file.HistoryTemplateListPane;
import com.fr.design.file.MultiTemplateTabPane;
import com.fr.design.file.TemplateTreePane;
import com.fr.design.gui.ibutton.UIButton;
import com.fr.design.gui.ilable.UILabel;
import com.fr.design.gui.imenu.UIMenuHighLight;
import com.fr.design.gui.itextfield.UITextField;
import com.fr.design.gui.itoolbar.UIToolbar;
import com.fr.design.i18n.Toolkit;
import com.fr.design.layout.FRGUIPaneFactory;
import com.fr.design.layout.TableLayout;
import com.fr.design.layout.TableLayoutHelper;
import com.fr.design.mainframe.manager.search.TemplateTreeSearchManager;
import com.fr.design.mainframe.manager.search.searcher.control.pane.TemplateTreeSearchToolbarPane;
import com.fr.design.mainframe.vcs.RecycleAction;
import com.fr.design.mainframe.vcs.common.VcsHelper;
import com.fr.design.mainframe.vcs.ui.FileVersionsPanel;
import com.fr.design.mainframe.vcs.ui.VcsNewPane;
import com.fr.design.menu.KeySetUtils;
import com.fr.design.menu.ShortCut;
import com.fr.design.menu.ToolBarDef;
import com.fr.design.roleAuthority.RolesAlreadyEditedPane;
import com.fr.design.ui.util.UIUtil;
import com.fr.design.utils.DesignUtils;
import com.fr.design.utils.gui.GUICoreUtils;
import com.fr.design.worker.save.CallbackSaveWorker;
import com.fr.event.Event;
import com.fr.file.filetree.FileNode;
import com.fr.general.ComparatorUtils;
import com.fr.general.GeneralContext;
import com.fr.general.IOUtils;
import com.fr.log.FineLoggerFactory;
import com.fr.plugin.context.PluginContext;
import com.fr.plugin.injectable.PluginModule;
import com.fr.plugin.manage.PluginFilter;
import com.fr.plugin.observer.PluginEvent;
import com.fr.plugin.observer.PluginEventListener;
import com.fr.report.lock.LockInfoOperator;
import com.fr.stable.CoreConstants;
import com.fr.stable.StableUtils;
import com.fr.stable.StringUtils;
import com.fr.stable.project.ProjectConstants;
import com.fr.third.org.apache.commons.io.FilenameUtils;
import com.fr.workspace.WorkContext;

import javax.swing.BorderFactory;
import javax.swing.JDialog;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.SwingConstants;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import java.awt.BorderLayout;
import java.awt.CardLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;

import static javax.swing.JOptionPane.WARNING_MESSAGE;

public class DesignerFrameFileDealerPane extends JPanel implements FileToolbarStateChangeListener, ResponseDataSourceChange {

    public static final com.fr.event.Event<TwoTuple<String, String>> TEMPLATE_RENAME = new Event<TwoTuple<String, String>>() {
    };

    private static final String FILE = "file";
    public static final String FILE_NAME_LIMIT = "^[^/\\\\:<>\\*\\|\"\\?]+$";
    private static volatile DesignerFrameFileDealerPane THIS;

    static {
        GeneralContext.listenPluginRunningChanged(new PluginEventListener() {

            @Override
            public void on(PluginEvent event) {
                DesignUtils.refreshDesignerFrame();
            }
        }, new PluginFilter() {

            @Override
            public boolean accept(PluginContext context) {
                return context.contain(PluginModule.ExtraDesign, ShortCut.TEMPLATE_TREE);
            }
        });
        GeneralContext.listenPluginRunningChanged(new PluginEventListener() {
            @Override
            public void on(PluginEvent event) {
                UIUtil.invokeLaterIfNeeded(new Runnable() {
                    @Override
                    public void run() {
                        DesignerFrameFileDealerPane.getInstance().refresh();
                        DesignerFrameFileDealerPane.getInstance().stateChange();
                    }
                });
            }
        }, new PluginFilter() {
            @Override
            public boolean accept(PluginContext context) {
                return context.contain(PluginModule.ExtraDesign, App.MARK_STRING);
            }
        });
    }

    private List<FileToolbarStateChangeListener> otherToolbarStateChangeListeners = new ArrayList<>();

    private FileOperations selectedOperation;

    private UIToolbar toolBar;

    private UIToolbar rightToolBar;

    private NewFolderAction newFolderAction = new NewFolderAction();

    private RefreshTreeAction refreshTreeAction = new RefreshTreeAction();

    private ShowInExplorerAction showInExplorerAction = new ShowInExplorerAction();

    private RenameAction renameAction = new RenameAction();

    private DelFileAction delFileAction = new DelFileAction();

    private VcsAction vcsAction = new VcsAction();

    private RecycleAction recycleAction = new RecycleAction();

    //搜索
    private SwitchAction switchAction = new SwitchAction();
    private TemplateTreeSearchToolbarPane searchToolbarPane;

    //定位、收起
    private LocateAction locateAction = new LocateAction();
    private CollapseAllAction collapseAllAction = new CollapseAllAction();

    private DesignerFrameFileDealerPane() {

        setLayout(new BorderLayout());
        toolBar = ToolBarDef.createJToolBar();
        toolBar.setBorder(BorderFactory.createMatteBorder(0, 0, 1, 0, UIConstants.TOOLBAR_BORDER_COLOR));
        toolBar.setBorderPainted(true);
        JPanel tooBarPane = FRGUIPaneFactory.createBorderLayout_S_Pane();
        JPanel parent = new JPanel(new BorderLayout());
        parent.add(createUpToolBarPane(), BorderLayout.CENTER);
        parent.setBorder(BorderFactory.createEmptyBorder(3, 0, 4, 0));
        tooBarPane.add(parent, BorderLayout.CENTER);
        tooBarPane.add(new UIMenuHighLight(), BorderLayout.SOUTH);

        searchToolbarPane = new TemplateTreeSearchToolbarPane(toolBar);
        searchToolbarPane.add(createUpToolBarPane(), BorderLayout.EAST);
        searchToolbarPane.setPreferredSize(new Dimension(this.getWidth(), 23));
        add(searchToolbarPane, BorderLayout.NORTH);
        CardLayout card;
        JPanel cardPane = new JPanel(card = new CardLayout());
        cardPane.add(TemplateTreePane.getInstance(), FILE);

        selectedOperation = TemplateTreePane.getInstance();
        card.show(cardPane, FILE);

        TemplateTreePane.getInstance().setToolbarStateChangeListener(this);
        add(cardPane, BorderLayout.CENTER);
        stateChange();
    }

    public static DesignerFrameFileDealerPane getInstance() {

        if (THIS == null) {
            synchronized (DesignerFrameFileDealerPane.class) {
                if (THIS == null) {
                    THIS = new DesignerFrameFileDealerPane();
                }
            }
        }
        return THIS;
    }

    /**
     * 刷新
     */
    public void refresh() {
        selectedOperation.refresh();
    }

    /**
     * 刷新根目录并退出搜索模式
     */
    public void refreshAndOutOfSearch() {
        if (TemplateTreeSearchManager.getInstance().isInSearchMode()) {
            TemplateTreeSearchManager.getInstance().outOfSearchMode();
        }
        refresh();
    }

    private JPanel createUpToolBarPane() {
        JPanel panel = new JPanel(new BorderLayout());
        if (WorkContext.getCurrent().isRoot()) {
            rightToolBar = new UIToolbar(FlowLayout.RIGHT);
            rightToolBar.setBorder(BorderFactory.createMatteBorder(0, 0, 1, 0, UIConstants.TOOLBAR_BORDER_COLOR));
            rightToolBar.setBorderPainted(true);
            UILabel tipLabel = new UILabel(Toolkit.i18nText("Fine_Design_Template_Lock_Status"));
            tipLabel.setForeground(Color.GRAY);
            rightToolBar.add(tipLabel);
            UIButton button = new UIButton(IOUtils.readIcon("/com/fr/design/images/toolbarbtn/lock.png"));
            button.setRolloverIcon(IOUtils.readIcon("/com/fr/design/images/toolbarbtn/unlock.png"));
            button.setBorderPainted(false);
            button.setContentAreaFilled(false);
            button.set4ToolbarButton();
            button.setToolTipText(Toolkit.i18nText("Fine_Design_Template_Unlock_Tip"));
            button.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                   int option =  FineJOptionPane.showOptionDialog(DesignerContext.getDesignerFrame(),
                                                     Toolkit.i18nText("Fine_Design_Template_UnLock_Tip"),
                                                                  Toolkit.i18nText("Fine-Design_Basic_Alert"),
                                                                  JOptionPane.YES_NO_OPTION,
                                                                  JOptionPane.WARNING_MESSAGE,
                                                                  IOUtils.readIcon("/com/fr/design/images/warnings/warning32.png"),
                                                                  new Object[] {Toolkit.i18nText("Fine_Design_Template_UnLock_I_Known"), Toolkit.i18nText("Fine-Design_Basic_Button_Cancel")}, null);
                   if (option == JOptionPane.YES_OPTION) {
                       String path = StableUtils.pathJoin(ProjectConstants.REPORTLETS_NAME, TemplateTreePane.getInstance().getTemplateFileTree().getSelectedTemplatePath());
                       boolean success = WorkContext.getCurrent().get(LockInfoOperator.class).unLockTpl(path);
                       if (success) {
                           FileNode fileNode = TemplateTreePane.getInstance().getFileNode();
                           refreshRightToolBarBy(fileNode);
                       } else {
                           FineJOptionPane.showMessageDialog(DesignerContext.getDesignerFrame(),
                                                             Toolkit.i18nText("Fine-Design_Template_Unlock_Failed"),
                                                             Toolkit.i18nText("Fine-Design_Basic_Alert"),
                                                             JOptionPane.WARNING_MESSAGE);
                           FineLoggerFactory.getLogger().error("Unlock {} failed", path);
                       }
                       TemplateTreePane.getInstance().refresh();
                   }
                }
            });
            rightToolBar.add(button);
            refreshRightToolBarBy(TemplateTreePane.getInstance().getFileNode());
            panel.add(rightToolBar, BorderLayout.EAST);
        }
        return panel;
    }

    public final void setCurrentEditingTemplate(JTemplate<?, ?> jt) {

        DesignModelAdapter.setCurrentModelAdapter(jt.getModel());
        fireDSChanged();
        if (TableDataTreeSearchManager.getInstance().isInSearchMode()) {
            TableDataTreeSearchManager.getInstance().outOfSearchMode();
        }
        TableDataTreePane.getInstance(DesignModelAdapter.getCurrentModelAdapter());
        HistoryTemplateListPane.getInstance().setCurrentEditingTemplate(jt);
        //处理自动新建的模板
        MultiTemplateTabPane.getInstance().doWithtemTemplate();
        if (DesignerMode.isAuthorityEditing()) {
            RolesAlreadyEditedPane.getInstance().refreshDockingView();
        }

        jt.setComposite();
        jt.refreshToolArea();
        jt.fireJTemplateOpened();
        jt.requestFocus();
        jt.revert();

        // 打开为空占位模板时不输出
        if (!jt.isOpening()) {
            FineLoggerFactory.getLogger().info(
                    "\"" + jt.getEditingFILE().getName() + "\""
                            + Toolkit.i18nText("Fine-Design_Basic_LOG_Has_Been_Openned") + "!");
        }
    }

    /**
     * 刷新菜单
     */
    public void refreshDockingView() {
        ToolBarDef toolbarDef = new ToolBarDef();
        toolbarDef.addShortCut(newFolderAction, refreshTreeAction);
        if (WorkContext.getCurrent().isLocal()) {
            toolbarDef.addShortCut(showInExplorerAction);
        }
        toolbarDef.addShortCut(renameAction, delFileAction);
        Set<ShortCut> extraShortCuts = ExtraDesignClassManager.getInstance().getExtraShortCuts();
        for (ShortCut shortCut : extraShortCuts) {
            toolbarDef.addShortCut(shortCut);
        }
        addVcsAction(toolbarDef);
        toolbarDef.addShortCut(locateAction, collapseAllAction, switchAction);
        toolbarDef.updateToolBar(toolBar);
        resetActionStatus();
        refresh();
    }


    /**
     * 添加VcsAction
     *
     * @param toolbarDef
     */
    private void addVcsAction(ToolBarDef toolbarDef) {
        if (VcsHelper.getInstance().needInit()) {
            vcsAction = new VcsAction();

            if (!isLegacyOnCluster()) {
                vcsAction.setName(Toolkit.i18nText("Fine-Design_Vcs_Title"));
            } else {
                vcsAction.setName(Toolkit.i18nText("Fine-Design_Vcs_NotSupportRemote"));
            }
            toolbarDef.addShortCut(vcsAction);
            //11.0.19及其之后加入回收站逻辑
            if (VcsHelper.getInstance().checkV2FunctionSupport()) {
                recycleAction = new RecycleAction();
                toolbarDef.addShortCut(recycleAction);
            }
        }
    }


    private void resetActionStatus() {

        newFolderAction.setEnabled(false);
        refreshTreeAction.setEnabled(true);
        showInExplorerAction.setEnabled(false);
        renameAction.setEnabled(false);
        delFileAction.setEnabled(false);
        vcsAction.setEnabled(false);
        this.repaint();
    }

    /**
     * 响应数据集改变
     */
    @Override
    public void fireDSChanged() {

        fireDSChanged(new HashMap<String, String>());
    }

    /**
     * 响应数据集改变
     *
     * @param map 改变名字的数据集
     */
    @Override
    public void fireDSChanged(Map<String, String> map) {

        DesignTableDataManager.fireDSChanged(map);
    }


    public void addToolbarStateChangeListener(FileToolbarStateChangeListener listener) {
        this.otherToolbarStateChangeListeners.add(listener);
    }

    public void removeToolbarStateChangeListener(FileToolbarStateChangeListener listener) {
        this.otherToolbarStateChangeListeners.remove(listener);
    }

    private void otherStateChange() {
        for (FileToolbarStateChangeListener listener : otherToolbarStateChangeListeners) {
            listener.stateChange();
        }
    }

    private boolean isCurrentEditing(String path) {
        JTemplate<?, ?> jt = HistoryTemplateListCache.getInstance().getCurrentEditingTemplate();
        if (JTemplate.isValid(jt)) {
            String editing = jt.getEditingFILE().getPath();
            return ComparatorUtils.equals(editing, path);
        }
        return false;
    }

    /**
     * 按钮状态改变
     */
    @Override
    public void stateChange() {

        int selectedPathNum = TemplateTreePane.getInstance().countSelectedPath();

        // 新建文件夹，重命名操作，在explorer中打开三个操作在选中单个文件夹或者文件时可用，其他情况不可用
        boolean singleSelected = selectedPathNum == 1;
        // 打开和保存中 需要禁用相关操作
        boolean enable = isEnable();
        newFolderAction.setEnabled(singleSelected);
        renameAction.setEnabled(singleSelected && enable);
        showInExplorerAction.setEnabled(singleSelected);
        // 删除操作在至少选中一个时可用
        boolean selected = selectedPathNum > 0;
        delFileAction.setEnabled(selected && enable);
        // 刷新操作始终可用
        refreshTreeAction.setEnabled(true);
        //触发vcsAction变化
        vcsAction.fireVcsActionChange(enable);

        // 其他状态
        otherStateChange();
    }

    public FileOperations getSelectedOperation() {
        return selectedOperation;
    }

    /**
     * 新建文件夹
     */
    private class NewFolderAction extends UpdateAction {

        public NewFolderAction() {

            this.setName(KeySetUtils.NEW_FOLDER.getMenuKeySetName());
            this.setSmallIcon("/com/fr/design/standard/newfolder/new_folder");
        }

        @Override
        public void actionPerformed(ActionEvent evt) {

            if (!selectedOperation.access()) {
                FineJOptionPane.showMessageDialog(DesignerContext.getDesignerFrame(),
                        Toolkit.i18nText("Fine-Design_Basic_Template_Permission_Denied"),
                        Toolkit.i18nText("Fine-Design_Basic_Alert"),
                        WARNING_MESSAGE);
                return;
            }

            new MkdirDialog();
            stateChange();
        }

    }

    private class SwitchAction extends UpdateAction {

        public SwitchAction() {
            this.setName(Toolkit.i18nText("Fine-Design_Basic_Search"));
            this.setMnemonic('S');
            this.setSmallIcon("/com/fr/design/standard/search", false);
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            // 交换层级
            searchToolbarPane.switchPane(TemplateTreeSearchToolbarPane.SEARCH_PANE);
            refreshRightToolBarByContentPaneType();
            TemplateTreePane.getInstance().refreshDockingView();
            TemplateTreeSearchManager.getInstance().switchToSearch(TemplateTreePane.getInstance().getTemplateFileTree());
        }
    }

    public class CollapseAllAction extends UpdateAction {

        public CollapseAllAction() {
            this.setName(Toolkit.i18nText("Fine-Design_Basic_Collapse_All"));
            this.setSmallIcon("/com/fr/design/standard/collapse_all", false);
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            TemplateTreePane.getInstance().refreshDockingView();
            refreshDockingView();
        }
    }

    /**
     * 版本管理
     */
    private class VcsAction extends UpdateAction {

        public VcsAction() {
            this.setSmallIcon("/com/fr/design/standard/vcslist/vcs_list");
        }

        @Override
        public void actionPerformed(ActionEvent e) {
            String path = DesignerFrameFileDealerPane.getInstance().getSelectedOperation().getFilePath();
            path = StableUtils.pathJoin(ProjectConstants.REPORTLETS_NAME, path);
            boolean currentEditing = isCurrentEditing(path);
            if (VcsHelper.getInstance().isLegacyMode()) {
                // 如果模板已经打开了，关掉，避免出现2个同名tab（1个是模板，1个是版本）
                closeOpenedTemplate(path, currentEditing);
                FileVersionsPanel fileVersionTablePanel = FileVersionsPanel.getInstance();
                fileVersionTablePanel.showFileVersionsPane();
                stateChange();
            } else {
                checkTemplateSavedAndShowVcsNewPane(path, currentEditing);
            }


        }

        private void showVcsNewPane(String path) {
            VcsNewPane panel = new VcsNewPane(path);
            panel.showDialog();
        }

        /**
         * 版本管理可用状态的监控
         */
        private void fireVcsActionChange(boolean enable) {
            if (!DesignerEnvManager.getEnvManager().getVcsConfigManager().isVcsEnable()
                    || VcsHelper.getInstance().isUnSelectedTemplate()
                    || isLegacyOnCluster()) {
                setEnabled(false);
                return;
            }


            if (WorkContext.getCurrent() != null) {
                boolean pathSupportVcsAction = selectedOperation.getFilePath() != null && pathSupportVcsAction(selectedOperation.getFilePath());
                if (!WorkContext.getCurrent().isLocal()) {
                    //当前环境为远程环境时
                    FileNode node = TemplateTreePane.getInstance().getTemplateFileTree().getSelectedFileNode();
                    if (pathSupportVcsAction) {
                        if (node.getLock() != null && !ComparatorUtils.equals(node.getUserID(), node.getLock())) {
                            setEnabled(false);
                        } else {
                            setEnabled(enable);
                        }
                    } else {
                        setEnabled(false);
                    }
                } else {
                    //当前环境为本地环境时
                    setEnabled(pathSupportVcsAction && enable);
                }
            }
        }

        private boolean pathSupportVcsAction(String path) {
            if (FileExtension.CPT.matchExtension(path) || FileExtension.FRM.matchExtension(path) || FileExtension.VIS.matchExtension(path)) {
                return true;
            }
            return false;
        }

        private void closeOpenedTemplate(String path, boolean isCurrentEditing) {
            for (JTemplate jTemplate : HistoryTemplateListCache.getInstance().getHistoryList()) {
                if (ComparatorUtils.equals(jTemplate.getEditingFILE().getPath(), path)) {
                    if (isCurrentEditing) {
                        MultiTemplateTabPane.getInstance().setIsCloseCurrent(true);
                    }
                    MultiTemplateTabPane.getInstance().closeFormat(jTemplate);
                    MultiTemplateTabPane.getInstance().closeSpecifiedTemplate(jTemplate);
                    return;
                }
            }
        }

        /**
         * 如果指定模板已经打开：
         * <p>1.如果该模板已保存，则正常打开新版本管理弹窗
         * <p>2.如果该模板未保存，触发保存逻辑
         *   <li>a.如果用户选择保存，则保存并不关闭模板，弹出新版本管理弹窗
         *   <li>b.如果用户选择不保存，则关闭当前模板，弹出新版本管理弹窗
         *   <li>c.如果用户选择取消, 则啥操作都不做
         *
         * @param path
         * @param isCurrentEditing
         */
        private void checkTemplateSavedAndShowVcsNewPane(String path, boolean isCurrentEditing) {
            for (JTemplate jTemplate : HistoryTemplateListCache.getInstance().getHistoryList()) {
                if (ComparatorUtils.equals(jTemplate.getEditingFILE().getPath(), path)) {
                    if (!jTemplate.isALLSaved()) {
                        MultiTemplateTabPane.getInstance().setIsCloseCurrent(isCurrentEditing);
                        MultiTemplateTabPane.getInstance().closeFormat(jTemplate);
                        confirmCloseAndShowVcsNewPane(jTemplate, path);
                        return;
                    }
                }
            }
            showVcsNewPane(path);
        }

        private void confirmCloseAndShowVcsNewPane(JTemplate<?, ?> specifiedTemplate, String path) {
            if (specifiedTemplate == null) {
                return;
            }
            if (!specifiedTemplate.isALLSaved() && !DesignerMode.isVcsMode()) {
                specifiedTemplate.stopEditing();
                int returnVal = FineJOptionPane.showConfirmDialog(DesignerContext.getDesignerFrame(), Toolkit.i18nText("Fine-Design_Basic_Utils_Would_You_Like_To_Save") + " \"" + specifiedTemplate.getEditingFILE() + "\" ?",
                        Toolkit.i18nText("Fine-Design_Basic_Confirm"), JOptionPane.YES_NO_CANCEL_OPTION, JOptionPane.QUESTION_MESSAGE);
                if (returnVal == JOptionPane.YES_OPTION) {
                    CallbackSaveWorker worker = specifiedTemplate.save();
                    worker.addSuccessCallback(() -> {
                        FineLoggerFactory.getLogger().info(Toolkit.i18nText("Fine-Design_Basic_Template_Already_Saved", specifiedTemplate.getEditingFILE().getName()));
                        showVcsNewPane(path);
                    });
                    worker.start(specifiedTemplate.getRuntimeId());
                } else if (returnVal == JOptionPane.NO_OPTION) {
                    closeTpl(specifiedTemplate);
                    showVcsNewPane(path);
                }
            } else {
                showVcsNewPane(path);
            }
        }

        private void closeTpl(JTemplate<?, ?> specifiedTemplate) {
            HistoryTemplateListCache.getInstance().closeSelectedReport(specifiedTemplate);
            MultiTemplateTabPane.getInstance().closeAndFreeLock(specifiedTemplate);
            MultiTemplateTabPane.getInstance().activePrevTemplateAfterClose();
        }

    }

    /**
     * 在系统资源管理器中打开
     */
    private class ShowInExplorerAction extends UpdateAction {

        public ShowInExplorerAction() {

            this.setName(com.fr.design.i18n.Toolkit.i18nText("Fine-Design_Basic_Show_In_Containing_Folder"));
            this.setSmallIcon("/com/fr/design/standard/viewfolder/view_folder");
        }

        @Override
        public void actionPerformed(ActionEvent evt) {
            selectedOperation.showInExplorer();
        }
    }

    /*
     * 刷新ReportletsTree
     */
    private class RefreshTreeAction extends UpdateAction {

        public RefreshTreeAction() {

            this.setName(Toolkit.i18nText("Fine-Design_Basic_Refresh"));
            this.setSmallIcon("/com/fr/design/standard/refresh", false);
        }

        @Override
        public void actionPerformed(ActionEvent evt) {
            selectedOperation.refresh();
            stateChange();
        }
    }

    /**
     * 搜索状态下不显示rightToolBar
     */
    public void refreshRightToolBarByContentPaneType() {
        if (rightToolBar != null) {
            if (StringUtils.equals(TemplateTreeSearchToolbarPane.contentPaneType, TemplateTreeSearchToolbarPane.SEARCH_PANE)) {
                rightToolBar.setVisible(false);
            }
        }
    }

    public void refreshRightToolBarBy(FileNode fileNode) {
        refreshRightToolBarByNode(fileNode);
        refreshRightToolBarByContentPaneType();
    }

    /**
     * 根据当前选中节点判断是否锁定状态
     *
     * @param fileNode 选中文件节点
     */
    public void refreshRightToolBarByNode(FileNode fileNode) {
        if (rightToolBar != null) {
            boolean locked = fileNode != null
                    && StringUtils.isNotEmpty(fileNode.getLock())
                    && !ComparatorUtils.equals(fileNode.getLock(), fileNode.getUserID());
            boolean visible = locked
                    && WorkContext.getCurrent().isRoot()
                    && WorkContext.getCurrent().get(LockInfoOperator.class).isUnLockable()
                    && !WorkContext.getCurrent().get(LockInfoOperator.class).isTplUnLocked(fileNode.getEnvPath());
            rightToolBar.setVisible(visible);
        }
    }


    /**
     * 新建文件夹对话框
     * 支持快捷键Enter，ESC
     */
    private class MkdirDialog extends JDialog {

        private UITextField nameField;

        private UILabel warnLabel;

        private UIButton confirmButton;


        private MkdirDialog() {

            this.setLayout(new BorderLayout());
            this.setModal(true);

            // 输入框前提示
            UILabel newNameLabel = new UILabel(Toolkit.i18nText(
                    "Fine-Design_Basic_Enter_New_Folder_Name")
            );
            newNameLabel.setHorizontalAlignment(SwingConstants.RIGHT);
            newNameLabel.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 10));

            // 文件名输入框
            nameField = new UITextField();
            nameField.getDocument().addDocumentListener(new DocumentListener() {

                @Override
                public void changedUpdate(DocumentEvent e) {
                    validInput();
                }

                @Override
                public void insertUpdate(DocumentEvent e) {
                    validInput();
                }

                @Override
                public void removeUpdate(DocumentEvent e) {
                    validInput();
                }
            });
            nameField.selectAll();
            nameField.setPreferredSize(new Dimension(180, 20));

            JPanel topPanel = new JPanel(new FlowLayout(FlowLayout.LEFT, 0, 5));
            topPanel.setBorder(BorderFactory.createEmptyBorder(15, 15, 0, 15));
            topPanel.add(newNameLabel);
            topPanel.add(nameField);

            // 增加enter以及esc快捷键的支持
            nameField.addKeyListener(new KeyAdapter() {
                @Override
                public void keyPressed(KeyEvent e) {
                    if (e.getKeyCode() == KeyEvent.VK_ESCAPE) {
                        dispose();
                    } else if (e.getKeyCode() == KeyEvent.VK_ENTER) {
                        if (confirmButton.isEnabled()) {
                            confirmClose();
                        }
                    }
                }
            });
            // 重名提示
            warnLabel = new UILabel();
            warnLabel.setPreferredSize(new Dimension(300, 50));
            warnLabel.setHorizontalAlignment(SwingConstants.LEFT);
            warnLabel.setVerticalAlignment(SwingConstants.TOP);
            warnLabel.setForeground(Color.RED);
            warnLabel.setVisible(false);

            JPanel midPanel = new JPanel(new BorderLayout());
            midPanel.setBorder(BorderFactory.createEmptyBorder(0, 15, 0, 15));
            midPanel.add(warnLabel, BorderLayout.WEST);

            // 确认按钮
            confirmButton = new UIButton(Toolkit.i18nText("Fine-Design_Basic_Confirm"));
            confirmButton.setPreferredSize(new Dimension(60, 25));
            confirmButton.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    confirmClose();
                }
            });
            confirmButton.setEnabled(false);

            // 取消按钮
            UIButton cancelButton = new UIButton(Toolkit.i18nText("Fine-Design_Basic_Cancel"));
            cancelButton.setPreferredSize(new Dimension(60, 25));

            cancelButton.addActionListener(new ActionListener() {

                @Override
                public void actionPerformed(ActionEvent e) {
                    dispose();
                }
            });

            JPanel bottomPanel = new JPanel(new FlowLayout(FlowLayout.RIGHT, 10, 0));
            bottomPanel.setBorder(BorderFactory.createEmptyBorder(10, 15, 10, 10));
            bottomPanel.add(confirmButton);
            bottomPanel.add(cancelButton);

            this.add(
                    TableLayoutHelper.createTableLayoutPane(
                            new Component[][]{
                                    new Component[]{topPanel},
                                    new Component[]{midPanel},
                                    new Component[]{bottomPanel}
                            },
                            new double[]{TableLayout.FILL, TableLayout.PREFERRED, TableLayout.PREFERRED},
                            new double[]{TableLayout.FILL}
                    ),
                    BorderLayout.CENTER);


            this.setSize(380, 200);
            this.setTitle(Toolkit.i18nText("Fine-Design_Basic_Mkdir"));
            this.setResizable(false);
            this.setAlwaysOnTop(true);
            this.setIconImage(BaseUtils.readImage("/com/fr/base/images/oem/logo.png"));
            this.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
            GUICoreUtils.setWindowCenter(DesignerContext.getDesignerFrame(), this);
            this.setVisible(true);
        }

        private void confirmClose() {
            String userInput = nameField.getText().trim();


            if (StringUtils.isEmpty(userInput)) {
                return;
            }

            //新建文件夹
            FileNode selectedFileNode = selectedOperation.getFileNode();
            String parentPath = selectedFileNode.getParent();
            if (selectedFileNode.isDirectory()) {
                //目录的话，父目录就是所选目录
                parentPath = FilenameUtils.standard(parentPath + CoreConstants.SEPARATOR + selectedFileNode.getName());
            }
            String targetPath = FilenameUtils.standard(parentPath + CoreConstants.SEPARATOR + userInput);
            boolean success = selectedOperation.mkdir(targetPath);
            selectedOperation.refresh();
            this.dispose();
            LocateAction.gotoEditingTemplateLeaf(targetPath);
            if (!success) {
                FineJOptionPane.showConfirmDialog(DesignerContext.getDesignerFrame(),
                        Toolkit.i18nText("Fine-Design_Basic_Make_Failure"),
                        Toolkit.i18nText("Fine-Design_Basic_Error"),
                        JOptionPane.DEFAULT_OPTION,
                        JOptionPane.ERROR_MESSAGE);
            }
        }


        private void validInput() {
            String userInput = nameField.getText().trim();


            if (StringUtils.isEmpty(userInput)) {
                confirmButton.setEnabled(false);
                return;
            }

            String errorMsg = doCheck(userInput, StringUtils.EMPTY);
            if (StringUtils.isNotEmpty(errorMsg)) {
                nameField.selectAll();
                // 如果检测出错，则灰掉确认按钮并提示
                warnLabel.setText(errorMsg);
                warnLabel.setVisible(true);
                confirmButton.setEnabled(false);
            } else {
                warnLabel.setVisible(false);
                confirmButton.setEnabled(true);
            }
        }
    }

    private boolean isLegacyOnCluster() {
        // 老模式且为集群，用于代替之前的只判断集群逻辑
        return WorkContext.getCurrent().isCluster() && VcsHelper.getInstance().isLegacyMode();
    }

    private String doCheck (String userInput, String suffix) {
        String errorMsg = StringUtils.EMPTY;
        if (selectedOperation.duplicated(userInput, suffix, true)) {
            errorMsg = Toolkit.i18nText("Fine-Design_Basic_Folder_Name_Duplicate", userInput);
        }
        if (!Pattern.compile(FILE_NAME_LIMIT).matcher(userInput).matches()) {
            errorMsg = Toolkit.i18nText("Fine-Design_Basic_Template_Name_Illegal");
        }
        return errorMsg;
    }

    private boolean isEnable() {
        List<JTemplate<?, ?>> templates = HistoryTemplateListCache.getInstance().getHistoryList();
        for (JTemplate<?, ?> template : templates) {
            if (template.isSaving() || template.isOpening()) {
                FileNode node = TemplateTreePane.getInstance().getFileNode();
                if (node != null && ComparatorUtils.equals(template.getEditingFILE().getPath(), node.getEnvPath())) {
                    return false;
                }
            }
        }
        return true;
    }


}