connectionstreepanel.java

eq跨平台查询工具源码 eq跨平台查询工具源码

     * @return the preferences key
     */
    public String getMenuItemKey() {
        return MENU_ITEM_KEY;
    }

    /** The tree's popup menu function */
    private class PopMenu extends JPopupMenu {
        
        private JMenuItem addNewConnection;
        private JMenuItem connect;
        private JMenuItem disconnect;
        private JMenuItem reload;
        private JMenuItem duplicate;
        private JMenuItem delete;
        private JMenuItem recycleConnection;

        private JMenu exportData;
        private JMenu importData;
        
        protected TreePath popupPath;
        protected DatabaseConnection hover;
        
        public PopMenu() {            
            ActionListener listener = new PopupMenuActionListener();

            addNewConnection = createMenuItem("New Connection", "addNewConnection", listener);
            add(addNewConnection);
            
            addSeparator();
            
            reload = createMenuItem("Reload", "reload", listener);
            add(reload);
            recycleConnection = createMenuItem("Recycle this connection", "recycle", listener);
            add(recycleConnection);

            addSeparator();
            
            connect = createMenuItem("Connect", "connect", listener);
            add(connect);
            disconnect = createMenuItem("Disconnect", "disconnect", listener);
            add(disconnect);
            
            addSeparator();
            
            duplicate = createMenuItem("Duplicate", "duplicate", listener);
            add(duplicate);
            delete = createMenuItem("Delete", "delete", listener);
            add(delete);
            
            addSeparator();
            
            exportData = new JMenu("Export Data");
            exportData.add(createMenuItem("Export to XML File", "exportXml", listener));
            exportData.add(createMenuItem("Export to Delimited File", "exportDelimited", listener));
            exportData.add(createMenuItem("Export to Excel Spreadsheet", "exportExcel", listener));
            add(exportData);

            importData = new JMenu("Import Data");
            importData.add(
                    createMenuItem("Import from XML File", "importXml", listener));
            importData.add(
                    createMenuItem("Import from Delimited File", "importDelimited", listener));
            add(importData);
            
            addSeparator();
            add(createMenuItem("Connection Properties", "properties", listener));
        }

        private JMenuItem createMenuItem(String text, 
                                         String actionCommand, 
                                         ActionListener listener) {
            JMenuItem menuItem = new JMenuItem(text);
            menuItem.setActionCommand(actionCommand);
            menuItem.addActionListener(listener);
            return menuItem;
        }
        
        public void setToConnect(boolean canConnect) {
            connect.setEnabled(canConnect);
            disconnect.setEnabled(!canConnect);
            delete.setEnabled(canConnect);

            String label = null;
            // check whether reload is available
            if (popupPath != null) {
                Object object = popupPath.getLastPathComponent();
                if (object instanceof BrowserTreeNode) {
                    BrowserTreeNode node = (BrowserTreeNode)object;
                    if (node.getUserObject() instanceof ConnectionObject) {
                        reload.setEnabled(false);
                        exportData.setEnabled(false);
                        importData.setEnabled(false);
                        recycleConnection.setEnabled(!canConnect);
                    } else {
                        label = node.toString();
                        reload.setEnabled(true);
                        recycleConnection.setEnabled(false);

                        boolean importExport = 
                                (node.getDatabaseUserObject().getType() == 
                                    BrowserConstants.TABLE_NODE && !node.isTypeParent());
                        exportData.setEnabled(importExport);
                        importData.setEnabled(importExport);
                    }
                }
            }

            // re-label the menu items
            if (hover != null) {
                String name = hover.getName();
                connect.setText("Connect Data Source " + name);
                disconnect.setText("Disconnect Data Source " + name);
                delete.setText("Remove Data Source " + name);
                duplicate.setText("Create Duplicate of Data Source " + name);
                
                if (label != null) {
                    reload.setText("Reload " + label);
                } else {
                    reload.setText("Reload");
                }
                
            }
            
        }

    }

    // declared public un-intentionally here for the reflective 
    // action extension and its use to work correctly.
    // may need to revise !!??
    public class PopupMenuActionListener extends ReflectiveAction {

        public PopupMenuActionListener() {}

        public void actionPerformed(ActionEvent e) {
            try {
                super.actionPerformed(e);
            }
            finally {
                reloadView = false;
                popupMenu.hover = null;
                popupMenu.popupPath = null;
            }
        }
        
        public void addNewConnection(ActionEvent e) {
            newConnection();
        }
        
        public void delete(ActionEvent e) {
            if (popupMenu.popupPath != null) {
                BrowserTreeNode node = 
                        (BrowserTreeNode)popupMenu.popupPath.getLastPathComponent();
                deleteConnection(node);
            }
        }
        
        public void recycle(ActionEvent e) {
            ConnectionObject dbObject = getSelectedMetaObject();
            controller.recycleConnection(dbObject.getDatabaseConnection());
        }
        
        public void reload(ActionEvent e) {
            if (popupMenu.popupPath != null) {
                reloadPath(popupMenu.popupPath);
            }
        }
        
        public void disconnect(ActionEvent e) {
            // check if the selected node belongs to the
            // connection about to closed
            boolean selectHover = (getSelectedDatabaseConnection() == popupMenu.hover);
            controller.connect(popupMenu.hover, false);
            
            //System.err.println("selectHover: " + selectHover);
            
            if (selectHover) {
                try {
                    reloadView = true;
                    setSelectedConnection(popupMenu.hover);
                    // select the properties panel for the
                    // just closed connection
                    /*
                    controller.valueChanged(
                            getSelectedMetaObject(),
                            (BrowserTreeNode)popupPath.getLastPathComponent(),
                            false);
                     */
                }
                finally {
                    reloadView = false;
                }
            }
        }
        
        public void duplicate(ActionEvent e) {
            if (popupMenu.hover != null) {
                String name = buildConnectionName(
                                popupMenu.hover.getName() + " (Copy") + ")";

                DatabaseConnection dc = new DatabaseConnection(name);
                dc.setPasswordStored(popupMenu.hover.isPasswordStored());
                dc.setPasswordEncrypted(popupMenu.hover.isPasswordEncrypted());
                dc.setDriverId(popupMenu.hover.getDriverId());
                dc.setDatabaseType(popupMenu.hover.getDatabaseType());
                dc.setHost(popupMenu.hover.getHost());
                dc.setPort(popupMenu.hover.getPort());
                dc.setSourceName(popupMenu.hover.getSourceName());
                dc.setTransactionIsolation(popupMenu.hover.getTransactionIsolation());
                dc.setURL(popupMenu.hover.getURL());
                dc.setUserName(popupMenu.hover.getUserName());

                if (popupMenu.hover.getJdbcProperties() != null) {
                    dc.setJdbcProperties(
                            (Properties)popupMenu.hover.getJdbcProperties().clone());
                }

                if (dc.isPasswordEncrypted()) {
                    dc.setEncryptedPassword(popupMenu.hover.getPassword());
                } else {
                    dc.setPassword(popupMenu.hover.getPassword());
                }

                newConnection(dc);
            }

        }
        
        public void exportExcel(ActionEvent e) {
            importExportDialog(ImportExportProcess.EXCEL);
        }

        public void importXml(ActionEvent e) {
            importExportDialog(ImportExportProcess.IMPORT_XML);
        }

        public void exportXml(ActionEvent e) {
            importExportDialog(ImportExportProcess.EXPORT_XML);
        }

        public void importDelimited(ActionEvent e) {
            importExportDialog(ImportExportProcess.IMPORT_DELIMITED);
        }
        
        public void exportDelimited(ActionEvent e) {
            importExportDialog(ImportExportProcess.EXPORT_DELIMITED);
        }
        
        public void properties(ActionEvent e) {
            reloadView = true;
            setSelectedConnection(popupMenu.hover);
        }
        
        public void connect(ActionEvent e) {
            controller.connect(popupMenu.hover, false);
        }
        
        private void importExportDialog(int transferType) {
            BaseDialog dialog = null;
            JPanel panel = null;

            DatabaseConnection dc = getSelectedDatabaseConnection();
            String schemaName = getSelectedDatabaseObject().getSchemaName();
            String tableName = getSelectedDatabaseObject().getName();

            try {
                GUIUtilities.showWaitCursor();
                switch (transferType) {
                    case ImportExportProcess.EXPORT_DELIMITED:
                        dialog = new BaseDialog("Export Data", false, false);
                        panel = new ImportExportDelimitedPanel(
                                        dialog, ImportExportProcess.EXPORT, 
                                        dc, schemaName, tableName);
                        break;

                    case ImportExportProcess.IMPORT_DELIMITED:
                        dialog = new BaseDialog("Import Data", false, false);
                        panel = new ImportExportDelimitedPanel(
                                        dialog, ImportExportProcess.IMPORT, 
                                        dc, schemaName, tableName);
                        break;

                    case ImportExportProcess.EXPORT_XML:
                        dialog = new BaseDialog("Export XML", false, false);
                        panel = new ImportExportXMLPanel(
                                        dialog, ImportExportProcess.EXPORT, 
                                        dc, schemaName, tableName);
                        break;

                    case ImportExportProcess.IMPORT_XML:
                        dialog = new BaseDialog("Import XML", false, false);
                        panel = new ImportExportXMLPanel(
                                        dialog, ImportExportProcess.IMPORT, 
                                        dc, schemaName, tableName);
                        break;

                    case ImportExportProcess.EXCEL:
                        dialog = new BaseDialog("Export Excel Spreadsheet", false, false);
                        panel = new ImportExportExcelPanel(
                                        dialog, ImportExportProcess.EXPORT, 
                                        dc, schemaName, tableName);
                        break;

                }

                dialog.addDisplayComponent(panel);
                dialog.display();            
            }
            finally {
                GUIUtilities.showNormalCursor();
            }
        }

    }
    
    private boolean reselecting;
    
    private class MouseHandler extends MouseAdapter {
        
        public MouseHandler() {}
        
        public void mouseClicked(MouseEvent e) {
            if (e.getClickCount() < 2) {
                reselecting = false;
                return;
            }
            TreePath path = tree.getPathForLocation(e.getX(), e.getY());
            if (path != null && path == tree.getSelectionPath()) {
                reselecting = true;
                valueChanged(new TreeSelectionEvent(
                        tree, path, true, oldSelectionPath, path));
            }
        }
        
        public void mousePressed(MouseEvent e) {
            maybeShowPopup(e);
        }

        public void mouseReleased(MouseEvent e) {
            maybeShowPopup(e);
        }

        private void maybeShowPopup(MouseEvent e) {
            if (e.isPopupTrigger()) {
                
                if (popupMenu == null) {
                    popupMenu = new PopMenu();
                }

                Point point = new Point(e.getX(), e.getY());
                popupMenu.popupPath = tree.getPathForLocation(point.x, point.y);
                // get the connection at this point
                popupMenu.hover = getConnectionAt(point);
                if (popupMenu.hover != null) {
                    try {
                        // enable/disable items
                        popupMenu.setToConnect(!popupMenu.hover.isConnected());
                        tree.removeTreeSelectionListener(ConnectionsTreePanel.this);
                        tree.setSelectionPath(popupMenu.popupPath);
                    }
                    finally {
                        tree.addTreeSelectionListener(ConnectionsTreePanel.this);
                    }
                    popupMenu.show(e.getComponent(), point.x, point.y);
                }
            }
        }

    }
    
}