basiccomboboxui.java

JAVA的一些源码 JAVA2 STANDARD EDITION DEVELOPMENT KIT 5.0

                        }
                    } else {
                        comboBox.setPopupVisible(true);
                    }
                }
            }
            else if (key == DOWN_2) {
		// Special case in which pressing the arrow keys will not 
                // make the popup appear - except for editable combo boxes
                // and combo boxes inside a table.
                if (comboBox.isShowing() ) {
                    if ( (comboBox.isEditable() ||
                            (ui != null && ui.isTableCellEditor()))
                         && !comboBox.isPopupVisible() ) {
                        comboBox.setPopupVisible(true);
                    } else {
                        if (ui != null) {
                            ui.selectNextPossibleValue();
                        }
                    }
                }
            }
            else if (key == TOGGLE || key == TOGGLE_2) {
                if (ui != null && (key == TOGGLE || !comboBox.isEditable())) {
                    if ( ui.isTableCellEditor() ) {
                        // Forces the selection of the list item if the
                        // combo box is in a JTable.
                        comboBox.setSelectedIndex(ui.popup.getList().
                                                  getSelectedIndex());
                    } 
                    else {
                        comboBox.setPopupVisible(!comboBox.isPopupVisible());
                    }
                }
            }
            else if (key == UP) {
		if (ui != null) {
                    if (ui.isPopupVisible(comboBox)) {
                        ui.selectPreviousPossibleValue();
                    }
                    else if (DefaultLookup.getBoolean(comboBox, ui,
                                    "ComboBox.showPopupOnNavigation", false)) {
                        ui.setPopupVisible(comboBox, true);
                    }
                }
            }
	    else if (key == UP_2) {
                 // Special case in which pressing the arrow keys will not 
                 // make the popup appear - except for editable combo boxes.
                 if (comboBox.isShowing() && ui != null) {
                     if ( comboBox.isEditable() && !comboBox.isPopupVisible()) {
			 comboBox.setPopupVisible(true);
                     } else {
			 ui.selectPreviousPossibleValue();
                     }
                 }
             }

            else if (key == ENTER) {
                if ( ui != null && ui.isTableCellEditor() ) {
                    // Forces the selection of the list item if the
                    // combo box is in a JTable.
                    comboBox.setSelectedIndex(ui.popup.getList().
                                              getSelectedIndex());
                } 
                else {
                    if (comboBox.isPopupVisible()) {
                        comboBox.setPopupVisible(false);
                    } else {
                        // Call the default button binding.
                        // This is a pretty messy way of passing an event through
                        // to the root pane.
                        JRootPane root = SwingUtilities.getRootPane(comboBox);
                        if (root != null) {
                            InputMap im = root.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
                            ActionMap am = root.getActionMap();
                            if (im != null && am != null) {
                                Object obj = im.get(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER,0));
                                if (obj != null) {
                                    Action action = am.get(obj);
                                    if (action != null) {
                                        action.actionPerformed(new ActionEvent(
                                         root, e.getID(), e.getActionCommand(),
                                         e.getWhen(), e.getModifiers()));
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        private int getNextIndex(JComboBox comboBox, String key) {
            if (key == PAGE_UP) {
                int listHeight = comboBox.getMaximumRowCount();
                int index = comboBox.getSelectedIndex() - listHeight;
                return (index < 0 ? 0: index);
            }
            else if (key == PAGE_DOWN) {
                int listHeight = comboBox.getMaximumRowCount();
                int index = comboBox.getSelectedIndex() + listHeight;
                int max = comboBox.getItemCount();
                return (index < max ? index: max-1);
            }
            else if (key == HOME) {
                return 0;
            }
            else if (key == END) {
                return comboBox.getItemCount() - 1;
            }
            return comboBox.getSelectedIndex();
	}

	public boolean isEnabled(Object c) {
            if (getName() == HIDE) {
                return (c != null && ((JComboBox)c).isPopupVisible());
            }
            return true;
	}
    }
    //
    // end Keyboard Action Management
    //===============================


    //
    // Shared Handler, implements all listeners
    //
    private class Handler implements ActionListener, FocusListener,
                                     KeyListener, LayoutManager,
                                     ListDataListener, PropertyChangeListener {
        //
        // PropertyChangeListener
        //
        public void propertyChange(PropertyChangeEvent e) {
            String propertyName = e.getPropertyName();
	    JComboBox comboBox = (JComboBox)e.getSource();

            if ( propertyName == "model" ) {
                ComboBoxModel newModel = (ComboBoxModel)e.getNewValue();
                ComboBoxModel oldModel = (ComboBoxModel)e.getOldValue();

                if ( oldModel != null && listDataListener != null ) {
                    oldModel.removeListDataListener( listDataListener );
                }

                if ( newModel != null && listDataListener != null ) {
                    newModel.addListDataListener( listDataListener );
                }

                if ( editor != null ) {
                    comboBox.configureEditor( comboBox.getEditor(), comboBox.getSelectedItem() ); 
                }
                isMinimumSizeDirty = true;
                isDisplaySizeDirty = true;
                comboBox.revalidate();
		comboBox.repaint();
            }
            else if ( propertyName == "editor" && comboBox.isEditable() ) {
                addEditor();
                comboBox.revalidate();
            }
            else if ( propertyName == "editable" ) {
                if ( comboBox.isEditable() ) {
                    comboBox.setRequestFocusEnabled( false );
                    addEditor();
                } else {
                    comboBox.setRequestFocusEnabled( true );
                    removeEditor();
                }

                updateToolTipTextForChildren();

                comboBox.revalidate();
            }
            else if ( propertyName == "enabled" ) {
                boolean enabled = comboBox.isEnabled();
                if ( editor != null )
                    editor.setEnabled(enabled);
                if ( arrowButton != null )
                    arrowButton.setEnabled(enabled);
                comboBox.repaint();
            }
            else if ( propertyName == "maximumRowCount" ) {
                if ( isPopupVisible( comboBox ) ) {
                    setPopupVisible(comboBox, false);
                    setPopupVisible(comboBox, true);
                }
            }
            else if ( propertyName == "font" ) {
                listBox.setFont( comboBox.getFont() );
                if ( editor != null ) {
                    editor.setFont( comboBox.getFont() );
                }
                isMinimumSizeDirty = true;
                comboBox.validate();
            }
            else if ( propertyName == JComponent.TOOL_TIP_TEXT_KEY ) {
                updateToolTipTextForChildren();
	    }
            else if ( propertyName == BasicComboBoxUI.IS_TABLE_CELL_EDITOR ) {
                Boolean inTable = (Boolean)e.getNewValue();
		isTableCellEditor = inTable.equals(Boolean.TRUE) ? true : false;
            } 
	    else if (propertyName == "prototypeDisplayValue") {
                isMinimumSizeDirty = true;
                isDisplaySizeDirty = true;
                comboBox.revalidate();
            } 
	    else if (propertyName == "renderer") {
                isMinimumSizeDirty = true;
                isDisplaySizeDirty = true;
                comboBox.revalidate();
            }
        }


        //
        // KeyListener
        //

        // This listener checks to see if the key event isn't a navigation
        // key.  If it finds a key event that wasn't a navigation key it
        // dispatches it to JComboBox.selectWithKeyChar() so that it can do
        // type-ahead.
        public void keyPressed( KeyEvent e ) {
 	    if ( isNavigationKey(e.getKeyCode(), e.getModifiers()) ) {
 		lastTime = 0L;
 	    } else if ( comboBox.isEnabled() && comboBox.getModel().getSize()!=0 &&
			isTypeAheadKey( e ) ) {
		time = e.getWhen();		
                if ( comboBox.selectWithKeyChar(e.getKeyChar()) ) {
                    e.consume();
                }
            }
        } 

        public void keyTyped(KeyEvent e) {
        }

        public void keyReleased(KeyEvent e) {
        }

        private boolean isTypeAheadKey( KeyEvent e ) {
            return !e.isAltDown() && !e.isControlDown() && !e.isMetaDown();
        }

        //
        // FocusListener
        //
        // NOTE: The class is added to both the Editor and ComboBox.
        // The combo box listener hides the popup when the focus is lost.
        // It also repaints when focus is gained or lost.

        public void focusGained( FocusEvent e ) {
            if (e.getSource() == comboBox.getEditor().getEditorComponent()) {
                return;
            }
            hasFocus = true;
            comboBox.repaint();
	    
	    if (comboBox.isEditable() && editor != null) {
		editor.requestFocus();
	    }
        }

        public void focusLost( FocusEvent e ) {
            if (e.getSource() == comboBox.getEditor().getEditorComponent()) {
                ComboBoxEditor editor = comboBox.getEditor();
                Object item = editor.getItem();

                if (!e.isTemporary() && item != null && 
                    !item.equals( comboBox.getSelectedItem())) {
                    comboBox.actionPerformed
                        (new ActionEvent(editor, 0, "",
                                      EventQueue.getMostRecentEventTime(), 0));
                }
            }

            hasFocus = false;
            if (!e.isTemporary()) {
                setPopupVisible(comboBox, false);
            }
            comboBox.repaint();
        }

        //
        // ListDataListener
        //

        // This listener watches for changes in the ComboBoxModel
        public void contentsChanged( ListDataEvent e ) {
	    if ( !(e.getIndex0() == -1 && e.getIndex1() == -1) ) {
		isMinimumSizeDirty = true;
		comboBox.revalidate();
	    }

	    // set the editor with the selected item since this
	    // is the event handler for a selected item change.
	    if (comboBox.isEditable() && editor != null) {
		comboBox.configureEditor( comboBox.getEditor(), 
					  comboBox.getSelectedItem() ); 
	    }

	    comboBox.repaint();
	}

        public void intervalAdded( ListDataEvent e ) {
	    isDisplaySizeDirty = true;
	    contentsChanged( e );
        }

        public void intervalRemoved( ListDataEvent e ) {
	    isDisplaySizeDirty = true;
            contentsChanged( e );
        }

        //
        // LayoutManager
        //

        // This layout manager handles the 'standard' layout of combo boxes.
        // It puts the arrow button to the right and the editor to the left.
        // If there is no editor it still keeps the arrow button to the right.
        public void addLayoutComponent(String name, Component comp) {}

        public void removeLayoutComponent(Component comp) {}

        public Dimension preferredLayoutSize(Container parent) {
            return parent.getPreferredSize();
        }

        public Dimension minimumLayoutSize(Container parent) {
            return parent.getMinimumSize();
        }

        public void layoutContainer(Container parent) {
            JComboBox cb = (JComboBox)parent;
            int width = cb.getWidth();
            int height = cb.getHeight();
            
            Insets insets = getInsets();
            int buttonSize = height - (insets.top + insets.bottom);
            Rectangle cvb;

            if ( arrowButton != null ) {
	        if(BasicGraphicsUtils.isLeftToRight(cb)) {
		    arrowButton.setBounds( width - (insets.right + buttonSize),
					   insets.top,
					   buttonSize, buttonSize);
		}
		else {
		    arrowButton.setBounds( insets.left, insets.top,
					   buttonSize, buttonSize);
		}
            }
            if ( editor != null ) {
                cvb = rectangleForCurrentValue();
                editor.setBounds(cvb);
            }
        }


        //
        // ActionListener
        //
	// Fix for 4515752: Forward the Enter pressed on the
	// editable combo box to the default button if the item has
	// not changed.

	// Note: This could depend on event ordering. The first ActionEvent
	// from the editor may be handled by the JComboBox in which case, the
	// enterPressed action will always be invoked.
	public void actionPerformed(ActionEvent evt) {
	    Object item = comboBox.getEditor().getItem();

	    if (item != null && item.equals(comboBox.getSelectedItem())) {
		ActionMap am = comboBox.getActionMap();
		if (am != null) {
		    Action action = am.get("enterPressed");
		    if (action != null) {
			action.actionPerformed(new ActionEvent(comboBox, evt.getID(), 
							       evt.getActionCommand(),
							       evt.getModifiers()));
		    }
		}
	    }
	}
    }

    class DefaultKeySelectionManager implements JComboBox.KeySelectionManager, UIResource {
 	private String prefix = "";
 	private String typedString = "";

        public int selectionForKey(char aKey,ComboBoxModel aModel) {
	    if (lastTime == 0L) {
		prefix = "";
		typedString = "";
	    }
 	    boolean startingFromSelection = true;

 	    int startIndex = comboBox.getSelectedIndex();
 	    if (time - lastTime < timeFactor) {
 		typedString += aKey;
 		if((prefix.length() == 1) && (aKey == prefix.charAt(0))) {
 		    // Subsequent same key presses move the keyboard focus to the next
 		    // object that starts with the same letter.
 		    startIndex++;
 		} else {
 		    prefix = typedString;
 		}
 	    } else {
 		startIndex++;
 		typedString = "" + aKey;
 		prefix = typedString;
 	    }
 	    lastTime = time;
 
 	    if (startIndex < 0 || startIndex >= aModel.getSize()) {
 		startingFromSelection = false;
 		startIndex = 0;
 	    }
 	    int index = listBox.getNextMatch(prefix, startIndex,
 					     Position.Bias.Forward);
 	    if (index < 0 && startingFromSelection) { // wrap
 		index = listBox.getNextMatch(prefix, 0,
 					     Position.Bias.Forward);
 	    }
	    return index;
	}
    }

}