PLTWEB.git - Gitblit

package com.vci.client.portal.UI.v3;
 
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.FlowLayout;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
import javax.swing.ButtonGroup;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.event.TreeSelectionListener;
import javax.swing.tree.TreePath;
 
import com.vci.client.framework.rightConfig.modelConfig.ModuleTreeCellRenderer;
import com.vci.client.omd.btm.ui.BtmClient;
import com.vci.client.omd.linktype.LinkTypeStart;
import com.vci.client.ui.swing.VCISwingUtil;
import com.vci.client.ui.swing.components.VCIJButton;
import com.vci.client.ui.swing.components.VCIJDialog;
import com.vci.client.ui.swing.components.VCIJLabel;
import com.vci.client.ui.swing.components.VCIJPanel;
import com.vci.client.ui.swing.components.VCIJRadioButton;
import com.vci.client.ui.swing.components.VCIJTextField;
import com.vci.client.ui.tree.VCIBaseTree;
import com.vci.client.ui.tree.VCIBaseTreeModel;
import com.vci.client.ui.tree.VCIBaseTreeNode;
import com.vci.corba.common.VCIError;
import com.vci.corba.omd.btm.BtmItem;
import com.vci.corba.omd.ltm.LinkType;
import com.vci.mw.ClientContextVariable;
 
/**
 * 业务类型&链接类型树Panel
 * 
 * <p>Title: </p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2016</p>
 * <p>Company: VCI</p>
 * @author xiongchao
 * @time 2017-2-15
 * @version 1.0
 */
public class BtmLinkTypeTreePanel extends VCIJPanel {
 
    /**
     * 
     */
    private static final long serialVersionUID = 3357669516630770059L;
    private boolean showBtmLinkTypeRadioButton = false;
    private boolean onlyLinkType = false;
    public BtmLinkTypeTreePanel(){
        
    }
    
    public void buildUI(){
        init();
    }
    private void init(){
        initUI();
    }
    private void initUI(){
        setLayout(new BorderLayout());
        add(getNorthPanel(), BorderLayout.NORTH);
        add(new JScrollPane(getCenterTreePanel()), BorderLayout.CENTER);
    }
    private VCIJLabel lblSearch = new VCIJLabel("查找:");
    private VCIJTextField txtSearch = new VCIJTextField("", false);
    private VCIJButton btnSearch = VCISwingUtil.createVCIJButton("search", "", "", "search.gif", new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            search_exec();
        }
    });
    private VCIJButton btnRefresh = VCISwingUtil.createVCIJButton("refresh", "", "", "pagination_refresh.png", new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            refresh_exec();
        }
    });
    private VCIJRadioButton rbtnBtmType = new VCIJRadioButton("业务类型", true);
    private VCIJRadioButton rbtnLinkType = new VCIJRadioButton("链接类型", false);
    private VCIJPanel getNorthPanel(){
        VCIJPanel pal = new VCIJPanel();
        pal.setLayout(new GridBagLayout());
        pal.add(lblSearch, getGBC(0, 0, 1, 1, 0.0, 0.0, GridBagConstraints.NORTHWEST, GridBagConstraints.NONE, 1));
        pal.add(txtSearch, getGBC(1, 0, 2, 1, 1.0, 0.0, GridBagConstraints.NORTHWEST, GridBagConstraints.BOTH, 1));
        pal.add(btnSearch, getGBC(3, 0, 1, 1, 0.0, 0.0, GridBagConstraints.NORTHWEST, GridBagConstraints.NONE, 1));
        pal.add(btnRefresh, getGBC(4, 0, 1, 1, 0.0, 0.0, GridBagConstraints.NORTHWEST, GridBagConstraints.NONE, 1));
        rbtnBtmType.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                rbtn_change(rbtnBtmType.getText());
            }
        });
        rbtnLinkType.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                rbtn_change(rbtnLinkType.getText());                
            }
        });
        if(isShowBtmLinkTypeRadioButton() && !isOnlyLinkType()){
            ButtonGroup rbtnGroup = new ButtonGroup();
            rbtnGroup.add(rbtnBtmType);
            rbtnGroup.add(rbtnLinkType);
            pal.add(rbtnBtmType, getGBC(1, 1, 1, 1, 0.0, 0.0, GridBagConstraints.NORTHWEST, GridBagConstraints.NONE, 1));
            pal.add(rbtnLinkType, getGBC(2, 1, 1, 1, 1.0, 0.0, GridBagConstraints.NORTHWEST, GridBagConstraints.BOTH, 1));
        }
        return pal;
    }
    
    private VCIBaseTreeNode rootNode = null;
    private VCIBaseTreeModel treeModel = null;
    private VCIBaseTree tree = null;
    private VCIBaseTree getCenterTreePanel(){
        VCIBaseTree res = null;
        rootNode = new VCIBaseTreeNode("", "root");
        treeModel = new VCIBaseTreeModel(rootNode);
        updateRootNodeInfo();
        reloadTreeData();
        tree = new VCIBaseTree(treeModel, new ModuleTreeCellRenderer(){
            private static final long serialVersionUID = 6253740682089786968L;
            @Override
            public Component getTreeCellRendererComponent(JTree tree, Object value, boolean sel, boolean expanded, boolean leaf, int row, boolean hasFocus){
                Component compt = super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus);
                VCIBaseTreeNode node = null;
                if(value instanceof VCIBaseTreeNode){
                    node = (VCIBaseTreeNode)value;
                }
                if(node != null){
                    if(node.isRoot()){
                        setIcon(VCISwingUtil.createImageIcon("house.png"));
                    }
                    if(node.getObj() instanceof BtmItem){
                        setIcon(VCISwingUtil.createImageIcon("folder.png"));
                    } else if(node.getObj() instanceof LinkType){
                        setIcon(VCISwingUtil.createImageIcon("folder_link.png"));
                    }
                }
                return compt;
            }
        });
        res = tree;
        return res; 
    }
    private String getRootNodeShowLabel(){
        String res = rbtnBtmType.getText();
        if(isShowBtmLinkTypeRadioButton()){
            if(rbtnLinkType.isSelected()){
                res = rbtnLinkType.getText();
            }
        }
        if(isOnlyLinkType()){
            res = rbtnLinkType.getText();
            rbtnLinkType.setSelected(isOnlyLinkType());
            rbtnBtmType.setSelected(!isOnlyLinkType());
        }
        return res;
    }
    private void search_exec(){
        searchedTreeNodeList.clear();
        String text = txtSearch.getText().trim();
        if("".equals(text)) return;
        searchInTree(rootNode, searchedTreeNodeList, text);
        
        if(searchedTreeNodeList.size() < 0){
            return;
        }
        if(searchedTreeNodeList.size() == 1){
            VCIBaseTreeNode treeNode = searchedTreeNodeList.get(0);
            selectedTreeNodeToTree(treeNode);
            return;
        }
        showSearchResultDialg(searchedTreeNodeList);
    }
    
    private void selectedTreeNodeToTree(VCIBaseTreeNode treeNode){
        tree.clearSelection();
        TreePath navToTreePath = new TreePath(treeNode.getPath()); 
        tree.setSelectionPath(navToTreePath);
        tree.scrollPathToVisible(navToTreePath);
        tree.updateUI();
        tree.validate();
    }
    
    private int index = -1;
    private List<VCIBaseTreeNode> searchedTreeNodeList = new ArrayList<VCIBaseTreeNode>();
    private VCIJDialog dialog = new VCIJDialog(ClientContextVariable.getFrame(), true);
    private VCIJButton btnPrev = VCISwingUtil.createVCIJButton("prev", "上一个", "上一个", "pagination_previous.png", new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            index = index - 1;
            prevOrNext(index);
        }
    });
    private VCIJButton btnNext = VCISwingUtil.createVCIJButton("next", "下一个", "下一个", "pagination_next.png", new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            index = index + 1;
            prevOrNext(index);
        }
    });
    private VCIJButton btnClose = VCISwingUtil.createVCIJButton("close", "关闭", "关闭", "close.png", new ActionListener() {
        @Override
        public void actionPerformed(ActionEvent e) {
            dialog.setVisible(false);
            dialog.dispose();
        }
    });
    private VCIJLabel lblSearchInfo = new VCIJLabel("", null, VCIJLabel.LEADING);
    private void showSearchResultDialg(List<VCIBaseTreeNode> list){
        index = -1;
        btnPrev.setEnabled(false);
        btnNext.setEnabled(true);
        
        VCIJPanel pal = new VCIJPanel(new FlowLayout(FlowLayout.LEADING));
        lblSearchInfo.setText("" +
                "<html>" +
                "<p>共查找到 " + String.valueOf(searchedTreeNodeList.size()) + " 个结果</p>" +
                "<p>&nbsp;&nbsp;</p>" +
                "<p>&nbsp;&nbsp;</p>" +
                "</html>" +
                "");
        pal.add(lblSearchInfo);
        
        dialog.setTitle("查找结果");
        dialog.setSize(300, 125);
        dialog.setLocationRelativeTo(ClientContextVariable.getFrame());
        VCIJPanel palBtn = new VCIJPanel(new FlowLayout());
        
        palBtn.add(btnPrev);
        palBtn.add(btnNext);
        palBtn.add(btnClose);
        VCIJPanel palContent = new VCIJPanel(new BorderLayout());
        palContent.add(pal, BorderLayout.CENTER);
        palContent.add(palBtn, BorderLayout.SOUTH);
        dialog.setContentPane(palContent);
        dialog.setVisible(true);
    }
    
    private void prevOrNext(int index){
        VCIBaseTreeNode treeNode = searchedTreeNodeList.get(index);
        selectedTreeNodeToTree(treeNode);
        
        btnPrev.setEnabled(index > 0);
        btnNext.setEnabled(index < searchedTreeNodeList.size() - 1);
 
        lblSearchInfo.setText("" +
                "<html>" +
                "<p>共查找到 " + String.valueOf(searchedTreeNodeList.size()) + " 个结果，当前显示</p>" +
                "<p>第 " + String.valueOf(index + 1) + " 个 : " + treeNode.getUserObject() + "</p>" +
                "<p>&nbsp;&nbsp;</p>" +
                "</html>" +
                "");
        lblSearchInfo.updateUI();
        updateUI();
    }
    
    
    private void searchInTree(VCIBaseTreeNode parentTreeNode, List<VCIBaseTreeNode> list, String text){
        int childCount = parentTreeNode.getChildCount();
        for (int i = 0; i < childCount; i++) {
            VCIBaseTreeNode treeNode = (VCIBaseTreeNode) parentTreeNode.getChildAt(i);
            Object obj = treeNode.getObj();
            if(isOnlyLinkType() || 
                    (isShowBtmLinkTypeRadioButton() && rbtnLinkType.isSelected())){
                if(obj instanceof LinkType){
                    LinkType lt = (LinkType)obj;
                    if(lt.name.contains(text) || lt.tag.contains(text)){
                        list.add(treeNode);
                    }
                }
            } else if(rbtnBtmType.isSelected()){
                if(obj instanceof BtmItem){
                    BtmItem bi = (BtmItem)obj;
                    if(bi.name.contains(text) || bi.label.contains(text)){
                        list.add(treeNode);
                    }
                }
            }
            searchInTree(treeNode, list, text);
        }
    }
    
    private void refresh_exec(){
        btmItemMap.clear();
        linkTypeMap.clear();
        reloadTreeData();
    }
    private String lastRbtnText = rbtnBtmType.getText();
    private void rbtn_change(String text){
        if(text.equals(lastRbtnText)){
            return;
        }
        lastRbtnText = text;
        reloadTreeData();
        updateRootNodeInfo();
        updateUI();
    }
    private void updateRootNodeInfo(){
        rootNode.setUserObject(getRootNodeShowLabel());
    }
    private void reloadTreeData(){
        loadTreeData(rootNode, treeModel);
    }
    private Map<String, BtmItem[]> btmItemMap = new HashMap<String, BtmItem[]>();
    private Map<String, LinkType[]> linkTypeMap = new HashMap<String, LinkType[]>();
    private void loadTreeData(VCIBaseTreeNode parentTreeNode, VCIBaseTreeModel treeModel) {
        try{
            parentTreeNode.removeAllChildren();
            if(rbtnBtmType.isSelected()){
                BtmItem[] bis = new BtmItem[0];
                String name = "";
                if(!btmItemMap.containsKey(name)){
                    bis = BtmClient.getService().getAllBtmItem(name);
                    btmItemMap.put(name, bis);
                } else {
                    bis = btmItemMap.get(name);
                }
                addBtmItemToTreeNode(bis, parentTreeNode);
            } else {
                LinkType[] lts = new LinkType[0];
                String name = "all";
                if(!linkTypeMap.containsKey("")){
                    lts = LinkTypeStart.getService().getLinkTypes();
                    linkTypeMap.put(name, lts);
                }else {
                    lts = linkTypeMap.put(name, lts);
                }
                addLinkTypeToTreeNode(lts, parentTreeNode);
            }
            treeModel.reload();
        }catch(Exception e){
            e.printStackTrace();
        }
    }
    private void addBtmItemToTreeNode(BtmItem[] btmItems, VCIBaseTreeNode parentTreeNode) throws VCIError{
        Arrays.sort(btmItems, btmItemComparator);
        for (BtmItem btmItem : btmItems) {
            String nodeName = btmItem.name + " " + btmItem.label;
            VCIBaseTreeNode treeNode = new VCIBaseTreeNode(nodeName, btmItem);
            treeNode.setExpand(true);
            treeNode.setLeaf(true);
            treeModel.insertNodeInto(treeNode, parentTreeNode, treeModel.getChildCount(parentTreeNode));
            BtmItem[] childBtmItems = new BtmItem[0];
            String name = btmItem.name;
            if(!btmItemMap.containsKey(name)){
                childBtmItems = BtmClient.getService().getChildrenBtms(name);
                btmItemMap.put(name, childBtmItems);
            } else {
                childBtmItems = btmItemMap.get(name);
            }
            addBtmItemToTreeNode(childBtmItems, treeNode);
        }
    }
    private void addLinkTypeToTreeNode(LinkType[] linkTypes, VCIBaseTreeNode parentTreeNode){
        Arrays.sort(linkTypes, linkTypeComparator);
        for (LinkType linkType : linkTypes) {
            String nodeName = linkType.name + " " + linkType.tag;
            VCIBaseTreeNode treeNode = new VCIBaseTreeNode(nodeName, linkType);
            treeNode.setLeaf(true);
            treeNode.setExpand(true);
            treeModel.insertNodeInto(treeNode, parentTreeNode, treeModel.getChildCount(parentTreeNode));
        }
    }
    private Comparator<BtmItem> btmItemComparator = new Comparator<BtmItem>(){
        @Override
        public int compare(BtmItem o1, BtmItem o2) {
            return o1.name.compareTo(o2.name);
        }
    };
    private Comparator<LinkType> linkTypeComparator = new Comparator<LinkType>(){
        @Override
        public int compare(LinkType o1, LinkType o2) {
            return o1.name.compareTo(o2.name);
        }
    };
    private GridBagConstraints getGBC(int gridx, int gridy, int gridwidth, int gridheight, double weightx, double weighty, int anchor, int fill, int padxy) {
        return new GridBagConstraints(gridx, gridy, gridwidth, gridheight, weightx, weighty, anchor, fill, new Insets(padxy, padxy, padxy, padxy), padxy, padxy);
    }
 
    public boolean isShowBtmLinkTypeRadioButton() {
        return showBtmLinkTypeRadioButton;
    }
 
    public boolean isOnlyLinkType() {
        return onlyLinkType;
    }
    /**
     * 设置是否显示 业务类型 链接类型 单选按钮
     * <p>显示后 可以切换显示 业务类型 或 链接类型</p>
     * <p>默认值为false，此时按只显示 业务类型进行处理 </p>
     * @param showBtmLinkTypeRadioButton
     */
    public void setShowBtmLinkTypeRadioButton(boolean showBtmLinkTypeRadioButton) {
        this.showBtmLinkTypeRadioButton = showBtmLinkTypeRadioButton;
    }
    /**
     * 设置是否只显示链接类型（只显示链接类型时，没有 业务类型 链接类型 切换的单选按钮）
     * @param onlyLinkType
     */
    public void setOnlyLinkType(boolean onlyLinkType) {
        this.onlyLinkType = onlyLinkType;
    }
    /**
     * 添加树节点选择后的事件处理
     * @param tsl 树节点选择后的事件处理程序  TreeSelectionListener
     */
    public void addTreeSelectionListener(TreeSelectionListener tsl) {
        tree.addTreeSelectionListener(tsl);
    }
    /**
     * 返回当前选择的业务类型列表
     * @return 当前选择的业务类型列表 List<BtmItem>
     */
    public List<BtmItem> getSelectedBtmItems(){
        List<BtmItem> list = new ArrayList<BtmItem>();
        if(isShowBtmLinkTypeRadioButton() && rbtnBtmType.isSelected()){
            TreePath[] treePaths = tree.getSelectionPaths();
            for (TreePath treePath : treePaths) {
                Object pathObj = treePath.getLastPathComponent();
                if(pathObj != null && pathObj instanceof VCIBaseTreeNode){
                    VCIBaseTreeNode treeNode = (VCIBaseTreeNode)pathObj;
                    Object obj = treeNode.getObj();
                    if(obj instanceof BtmItem){
                        list.add(((BtmItem)obj));
                    }
                }
            }
        }
        return list;
    }
    /**
     * 返回当前选择的链接类型列表
     * @return 当前选择的链接类型列表  List<LinkType>
     */
    public List<LinkType> getSelectedLinkTypes(){
        List<LinkType> list = new ArrayList<LinkType>();
        if(!isOnlyLinkType() && rbtnLinkType.isSelected()){
            TreePath[] treePaths = tree.getSelectionPaths();
            for (TreePath treePath : treePaths) {
                Object pathObj = treePath.getLastPathComponent();
                if(pathObj != null && pathObj instanceof VCIBaseTreeNode){
                    VCIBaseTreeNode treeNode = (VCIBaseTreeNode)pathObj;
                    Object obj = treeNode.getObj();
                    if(obj instanceof LinkType){
                        list.add(((LinkType)obj));
                    }
                }
            }
        }
        return list;
    }
}