browsertableeditingpanel.java

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

        gbc.insets.top = 0;
        gbc.insets.right = 5;
        gbc.fill = GridBagConstraints.NONE;
        gbc.anchor = GridBagConstraints.EAST;
        base.add(applyButton, gbc);
        gbc.gridx = 4;
        gbc.weightx = 0;
        gbc.insets.left = 0;
        base.add(cancelButton, gbc);
        
        hasSQL = false;
        
        // set up and add the focus listener for the tables
        FocusListener tableFocusListener = new FocusListener() {
            public void focusGained(FocusEvent e) {
                focusTable = (JTable)e.getSource(); }
            public void focusLost(FocusEvent e) {}
        };
        columnDataTable.addTableFocusListener(tableFocusListener);
        conPanel.addTableFocusListener(tableFocusListener);

        sbTemp = new StringBuffer(100);        
        cache = new HashMap();

        setContentPanel(base);
        setHeaderIcon(GUIUtilities.loadIcon("DatabaseTable24.gif"));
        setHeaderText("Database Table");
        
        // register for keyword changes
        EventMediator.registerListener(EventMediator.KEYWORD_EVENT, this);
    }
    
    /**
     * Invoked when a SQL text pane gains the keyboard focus.
     */
    public void focusGained(FocusEvent e) {
        Object source = e.getSource();
        // check which editor we are in
        if (createSqlText.getEditorTextComponent() == source) {
            lastFocusEditor = createSqlText;
        }
        else if (alterSqlText.getEditorTextComponent() == source) {
            lastFocusEditor = alterSqlText;
        }
    }

    /**
     * Invoked when a SQL text pane loses the keyboard focus.
     * Does nothing here.
     */
    public void focusLost(FocusEvent e) {}

    /**
     * Notification of a new keyword added to the list.
     */
    public void keywordsAdded(KeywordEvent e) {
        alterSqlText.setSQLKeywords(true);
        createSqlText.setSQLKeywords(true);
    }

    /**
     * Notification of a keyword removed from the list.
     */
    public void keywordsRemoved(KeywordEvent e) {
        alterSqlText.setSQLKeywords(true);
        createSqlText.setSQLKeywords(true);
    }

    /**
     * Performs the apply/cancel changes.
     *
     * @param e - the event
     */
    public void actionPerformed(ActionEvent e) {
        // if there is nothing to apply or cancel - bail
        if (!hasSQLText()) {
            return;
        }
        
        Object source = e.getSource();
        if (source == applyButton) {
            controller.applyTableChange(false);
        }
        else if (source == cancelButton) {
            selectionChanged(metaObject, true);
            resetSQLText();
        }
    }
    
    public String getLayoutName() {
        return NAME;
    }
    
    public void refresh() {
        cache.clear();
    }
    
    public Printable getPrintable() {
        
        int tabIndex = tabPane.getSelectedIndex();
        
        switch (tabIndex) {
            
            case 0:
                return new TablePrinter(columnDataTable.getTable(),
                                        "Table: " + metaObject.getName());
                
            case 1:
                return new TablePrinter(conPanel.getTable(),
                                        "Constraints for table: " + metaObject.getName(), false);
                
            case 2:
                return new TablePrinter(columnIndexTable,
                                        "Indexes for table: " + metaObject.getName());
                
            case 3:
                return new TablePrinter(tablePrivilegePanel.getTable(),
                                        "Access rights for table: " + metaObject.getName());
                
            case 4:
                return referencesPanel.getPrintable();
                
            case 5:
                return new TablePrinter(tableDataPanel.getTable(),
                                        "Table Data: " + metaObject.getName());

            case 7:
                return new TablePrinter(metaDataTable,
                                        "Table Meta Data: " + metaObject.getName());

            default:
                return null;
                
        }
        
    }
    
    public void cleanup() {
        referencesPanel.cleanup();
        EventMediator.deregisterListener(EventMediator.KEYWORD_EVENT, this);
    }
    
    /**
     * Handles a change tab selection.
     */
    public void stateChanged(ChangeEvent e) {
        int index = tabPane.getSelectedIndex();
        if (index != 5 && tableDataPanel.isExecuting()) {
            tableDataPanel.cancelStatement();
            return;
        }
        
        switch (index) {
            case 2:
                loadIndexes();
                break;
            case 3:
                loadPrivileges();
                break;
            case 4:
                loadReferences();
                break;
            case 5:
                tableDataPanel.getTableData(
                        controller.getDatabaseConnection(), metaObject);
                break;
            case 7:
                loadTableMetaData();
                break;
        }
        
    }
    
    /*
    private boolean executing;
    
    private void loadTableData() {
        SwingWorker worker = new SwingWorker() {
            public Object construct() {
                try {
                    executing = true;
                    showWaitCursor();
                    return setTableResultsPanel(dc, metaObject);
                }
                catch (Exception e) {
                    GUIUtilities.displayExceptionErrorDialog(
                                        "An error occured retrieving the table data.\n" + 
                                        e.getMessage(), e);
                    return "done";
                }
            }
            public void finished() {
                executing = false;
                querySender.releaseResources();
                showNormalCursor();
            }
        };        
        worker.start();
    }
    */

    /**
     * Returns whether the specified object exists in this
     * object cache.
     *
     * @return true | false
     */
    public boolean containsObject(DatabaseObject metaObject) {
        return cache.containsKey(metaObject);
    }
    
    /** 
     * Indicates that the references tab has been previously displayed
     * for the current selection. Aims to keep any changes made to the 
     * references ERD (moving tables around) stays as was previosuly set.
     */
    private boolean referencesLoaded;
    
    /**
     * Loads database table references.
     */
    private void loadReferences() {
        
        if (referencesLoaded) {
            return;
        }

        Vector tableNames = null;
        Vector tableMeta = null;
        CacheObject cacheObject = (CacheObject)cache.get(metaObject);
        
        if (!cacheObject.isReferenceDataLoaded()) {
            
            String catalogName = metaObject.getCatalogName();
            String schemaName = metaObject.getSchemaName();
            String tableName = metaObject.getName();
            
            String[] importedTables = controller.getImportedKeyTables(catalogName,
                                                                      schemaName,
                                                                      tableName);
            
            String[] exportedTables = controller.getExportedKeyTables(catalogName,
                                                                      schemaName,
                                                                      tableName);
            
            int size = importedTables.length + exportedTables.length + 1;
            
            tableNames = new Vector(size);
            tableNames.add(tableName);
            
            DatabaseTable dt = cacheObject.getDatabaseTable();
            ColumnData[] columnData = dt.getColumns();
            tableMeta = new Vector(size);
            tableMeta.add(columnData);
            
            for (int i = 0; i < importedTables.length; i++) {
                tableNames.add(importedTables[i]);
                tableMeta.add(controller.getColumnData(catalogName,
                                                       schemaName,
                                                       importedTables[i]));
            }
            
            for (int i = 0; i < exportedTables.length; i++) {
                tableNames.add(exportedTables[i]);
                tableMeta.add(controller.getColumnData(catalogName,
                                                       schemaName,
                                                       exportedTables[i]));
            }
            
            ReferencesCacheObject reference = new ReferencesCacheObject(tableNames, 
                                                                        tableMeta);
            cacheObject.setReferencesObject(reference);
            
        }        
        else {
            ReferencesCacheObject reference = cacheObject.getReferencesObject();
            tableNames = reference.getTableNames();
            tableMeta = reference.getColumnData();
        }

        referencesPanel.setTables(tableNames, tableMeta);
        referencesLoaded = true;
    }
    
    /**
     * Loads database table indexes.
     */
    private void loadTableMetaData() {
        CacheObject cacheObject = (CacheObject)cache.get(metaObject);
        if (cacheObject == null) {
            return;
        }

        try {
            metaDataModel.createTable(
                    controller.getTableMetaData(metaObject.getCatalogName(),
                                                metaObject.getSchemaName(),
                                                metaObject.getName()));
        }
        finally {
            controller.closeConnection();
        }
    }

    
    /**
     * Loads database table indexes.
     */
    private void loadIndexes() {
        CacheObject cacheObject = (CacheObject)cache.get(metaObject);
        if (cacheObject == null) {
            return;
        }
        
        ColumnIndex[] indexes = null;
        DatabaseTable dt = cacheObject.getDatabaseTable();
        if (!dt.hasIndexes()) {
            Vector _indexes = controller.getTableIndexes(metaObject.getCatalogName(),
                                                         metaObject.getSchemaName(),
                                                         metaObject.getName());
            
            indexes = (ColumnIndex[])_indexes.toArray(new ColumnIndex[_indexes.size()]);
            dt.setIndexes(indexes);
        }
        else {
            indexes = dt.getIndexes();
        }
        
        citm.setIndexData(indexes);
        setIndexTableColumnProperties(columnIndexTable);
    }