queryeditorresultspanel.java

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

            queryEditor.setLeftStatusText(SPACE + rowCount + ROW_RETURNED);
        }
        else {
            queryEditor.setLeftStatusText(ZERO_ROWS);
        }
    }
    
    private int getResultSetRowCount(ResultSetTableModel model, boolean showRowNumber) {
        int rowCount = model.getRowCount();
        if (rowCount == 0) {
            if (showRowNumber) {
                setOutputMessage(QueryEditorConstants.PLAIN_MESSAGE, NO_ROWS);
                resetEditorRowCount(rowCount);
                queryEditor.setMetaDataButtonEnabled(false);
            }
        }
        return rowCount;
    }
    
    public void setResultText(int result, int type) {
        if (getTabCount() == 0) {
            addTextOutputTab();
        }
        setSelectedIndex(0);

        String row = " row ";
        if (result > 1 || result == 0) {
            row = " rows ";
        }
        
        String rText = null;
        switch (type) {
            case QuerySender.INSERT:
                rText = row + "created.";
                break;
            case QuerySender.UPDATE:
                rText = row + "updated.";
                break;
            case QuerySender.DELETE:
                rText = row + "deleted.";
                break;
            case QuerySender.DROP_TABLE:
                rText = "Table dropped.";
                break;
            case QuerySender.CREATE_TABLE:
                rText = "Table created.";
                break;
            case QuerySender.ALTER_TABLE:
                rText = "Table altered.";
                break;
            case QuerySender.CREATE_SEQUENCE:
                rText = "Sequence created.";
                break;
            case QuerySender.CREATE_PROCEDURE:
                rText = "Procedure created.";
                break;
            case QuerySender.CREATE_FUNCTION:
                rText = "Function created.";
                break;
            case QuerySender.GRANT:
                rText = "Grant succeeded.";
                break;
            case QuerySender.CREATE_SYNONYM:
                rText = "Synonym created.";
                break;
            case QuerySender.COMMIT:
                rText = "Commit complete.";
                break;
            case QuerySender.ROLLBACK:
                rText = "Rollback complete.";
                break;
            case QuerySender.UNKNOWN:
            case QuerySender.EXECUTE:
                if (result > -1) {
                    rText = result + row + "affected.\nStatement executed successfully.";
                }
                else {
                    rText = "Statement executed successfully.";
                }
                break;
        }

        StringBuffer sb = new StringBuffer(50);

        if ((result > -1 && type >= QuerySender.ALL_UPDATES) 
                && type != QuerySender.UNKNOWN) {
            sb.append(result);
        }

        sb.append(rText);
        setOutputMessage(QueryEditorConstants.PLAIN_MESSAGE, sb.toString());
        queryEditor.setLeftStatusText(SUCCESS);
    }
    
    public void setResultBackground(Color colour) {
        outputTextPane.setBackground(colour);
        
        Component[] tabs = getComponents();
        for (int i = 0; i < tabs.length; i++) {
            Component c = tabs[i];
            if (c instanceof ResultSetPanel) {
                ResultSetPanel panel = (ResultSetPanel)c;
                panel.setResultBackground(colour);
            }
        }
    }

    public void destroyTable() {
        Component[] tabs = getComponents();
        for (int i = 0; i < tabs.length; i++) {
            Component c = tabs[i];
            if (c instanceof ResultSetPanel) {
                ResultSetPanel panel = (ResultSetPanel)c;
                panel.destroyTable();
            }
        }
    }
    
    private ResultSetPanel getSelectedResultSetPanel() {
        int selectedIndex = getSelectedIndex();
        if (selectedIndex <= 0) {
            return null;
        }

        Component c = getComponentAt(selectedIndex);
        if (c instanceof ResultSetPanel) {
            return (ResultSetPanel)c;
        }
        return null;
    }
    
    /**
     * Returns whether a result set panel is selected and that
     * that panel has a result set row count > 0.
     *
     * @return true | false
     */
    public boolean isResultSetSelected() {
        ResultSetPanel panel = getSelectedResultSetPanel();
        if (panel != null) {
            return panel.getRowCount() > 0;
        }
        return false;
    }
    
    public JTable getResultsTable() {
        ResultSetPanel panel = getSelectedResultSetPanel();
        if (panel != null) {
            return panel.getResultsTable();
        }
        return null;
    }
    
    public ResultSetTableModel getResultSetTableModel() {
        ResultSetPanel panel = getSelectedResultSetPanel();
        if (panel != null) {
            return panel.getResultSetTableModel();
        }
        return null;
    }

    public void setWarningMessage(String s) {
        appendOutput(QueryEditorConstants.WARNING_MESSAGE, s);
    }

    public void setPlainMessage(String s) {
        appendOutput(QueryEditorConstants.PLAIN_MESSAGE, s);
    }

    public void setActionMessage(String s) {
        appendOutput(QueryEditorConstants.ACTION_MESSAGE, s);
    }
    
    public void setErrorMessage(String s) {
        if (getTabCount() == 0) {
            addTextOutputTab();
        }

        setSelectedIndex(0);
        if (!MiscUtils.isNull(s)) {
            appendOutput(QueryEditorConstants.ERROR_MESSAGE, s);
        }
        if (queryEditor != null) {
            queryEditor.setExportButtonEnabled(false);
            queryEditor.setMetaDataButtonEnabled(false);
        }
    }

    public void setOutputMessage(int type, String text) {
        if (getTabCount() == 0) {
            addTextOutputTab();
        }

        setSelectedIndex(0);
        if (!MiscUtils.isNull(text)) {            
            appendOutput(type, text);
        }
        if (queryEditor != null) {
            queryEditor.setExportButtonEnabled(false);
            queryEditor.setMetaDataButtonEnabled(false);
        }
    }
    
    protected void appendOutput(int type, String text) {
        outputTextPane.append(type, text);
        outputTextPane.setCaretPosition(outputTextPane.getDocument().getLength());
        //outputTextViewport.validate();
    }
    
    public void clearOutputPane() {
        outputTextPane.setText(EMPTY);
        outputTextPane.setCaretPosition(0);
    }

    /**
     * Indicates the current execute has completed to
     * clear the temp panel availability cache.
     */
    public void finished() {
        if (resultSetPanelsAvail != null) {
            resultSetPanelsAvail.clear();
        }
    }

    /**
     * Sets to display the result set meta data for the
     * currently selected result set tab.
     */
    public void displayResultSetMetaData() {
        ResultSetPanel panel = getSelectedResultSetPanel();
        if (panel.hasResultSetMetaData()) {
            int index = getSelectedIndex();
            ResultSetMetaDataPanel metaDataPanel = 
                    panel.getResultSetMetaDataPanel();
            
            // check if the meta data is already displayed
            // at the index next to the result panel
            if (index != getTabCount() - 1) {
                Component c = getComponentAt(index + 1);
                if (c == metaDataPanel) {
                    setSelectedIndex(index + 1);
                    return;
                }
            }

            // otherwise add it
            insertTab(ResultSetMetaDataPanel.TITLE,
                      GUIUtilities.loadIcon("RSMetaData16.gif", true),
                      metaDataPanel,
                      getToolTipTextAt(index),
                      index + 1);
            setSelectedIndex(index + 1);
        }
    }

    /**
     * Indicates whether the current execute is a 
     * single statement - usually an execute at cursor.
     *
     * @return true | false
     */
    public boolean isExecutingSingle() {
        return executingSingle;
    }

    /**
     * Sets that the current execute may be a single.
     * 
     * @param true | false
     */
    public void setExecutingSingle(boolean executingSingle) {
        this.executingSingle = executingSingle;
        if (!executingSingle) {
            if (resultSetPanelsAvail == null) {
                resultSetPanelsAvail = new ArrayList<ResultSetPanel>();
            } else {
                resultSetPanelsAvail.clear();
            }
            
            // temp cache the result panels for use in the current query(ies)
            if (resultSetPanels == null || resultSetPanels.isEmpty()) {
                return;
            }
            
            for (int i = 0, k = resultSetPanels.size(); i < k; i++) {
                resultSetPanelsAvail.add(resultSetPanels.get(i));
            }

            // reset the tab pane
            removeAll();

            // clear the current panels
            resultSetPanels.clear();
        }
        
        // make sure the output tab is there
        if (getTabCount() == 0) {
            addTextOutputTab();
        }
        
    }
    
    /**
     * Moves the caret to the beginning of the specified query.
     *
     * @param query - the query to move the cursor to
     */
    public void caretToQuery(String query) {
        queryEditor.caretToQuery(query);
    }
    
    /** the query display popup */
    private static QueryTextPopup queryPopup;
    
    /** last popup rollover index */
    private int lastRolloverIndex = -1;
    
    /**
     * Returns the result set's query at the specified index.
     *
     * @param index - the result set index
     * @return the query string
     */
    public String getQueryTextAt(int index) {
        return getToolTipTextAt(index);
    }
    
    /**
     * Reacts to a tab rollover.
     *
     * @param the associated event
     */
    public void tabRollOver(TabRolloverEvent e) {
        int index = e.getIndex();
        
        // check if we're over the output panel (index 0)
        if (index == 0 && hasOutputPane()) {
            lastRolloverIndex = index;
            if (queryPopup != null && queryPopup.isVisible()) {
                queryPopup.dispose();
            }
            return;
        }
        
        if (queryPopup != null && 
                queryPopup.isVisible() && lastRolloverIndex == index) {
            return;
        }

        if (index != -1) {
            String query = getToolTipTextAt(index);
            if (!MiscUtils.isNull(query)) {
                if (queryPopup == null) {
                    queryPopup = new QueryTextPopup(this);
                }
                lastRolloverIndex = index;
                queryPopup.setQueryText(e.getX(), e.getY(), query, index);
            }
        }
    }
    
    /**
     * Reacts to a tab rollover finishing.
     *
     * @param the associated event
     */
    public void tabRollOverFinished(TabRolloverEvent e) {
        int index = e.getIndex();
        if (index == -1) {
            lastRolloverIndex = index;
            if (queryPopup != null) {
                queryPopup.dispose();
            }
        }
    }
    
}