| /* |
| * Copyright (c) 2002, 2008, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| package com.sun.java.swing.plaf.gtk; |
| |
| import java.awt.*; |
| import java.awt.event.*; |
| import java.awt.image.*; |
| import javax.swing.*; |
| import javax.swing.colorchooser.*; |
| import javax.swing.event.*; |
| import javax.swing.plaf.*; |
| |
| /** |
| * A color chooser panel mimicking that of GTK's: a color wheel showing |
| * hue and a triangle that varies saturation and brightness. |
| * |
| * @author Scott Violet |
| */ |
| class GTKColorChooserPanel extends AbstractColorChooserPanel implements |
| ChangeListener { |
| private static final float PI_3 = (float)(Math.PI / 3); |
| |
| private ColorTriangle triangle; |
| private JLabel lastLabel; |
| private JLabel label; |
| |
| private JSpinner hueSpinner; |
| private JSpinner saturationSpinner; |
| private JSpinner valueSpinner; |
| |
| private JSpinner redSpinner; |
| private JSpinner greenSpinner; |
| private JSpinner blueSpinner; |
| |
| private JTextField colorNameTF; |
| |
| private boolean settingColor; |
| |
| // The colors are mirrored to avoid creep in adjusting an individual |
| // value. |
| private float hue; |
| private float saturation; |
| private float brightness; |
| |
| |
| |
| /** |
| * Convenience method to transfer focus to the next child of component. |
| */ |
| // PENDING: remove this when a variant of this is added to awt. |
| static void compositeRequestFocus(Component component, boolean direction) { |
| if (component instanceof Container) { |
| Container container = (Container)component; |
| if (container.isFocusCycleRoot()) { |
| FocusTraversalPolicy policy = container. |
| getFocusTraversalPolicy(); |
| Component comp = policy.getDefaultComponent(container); |
| if (comp!=null) { |
| comp.requestFocus(); |
| return; |
| } |
| } |
| Container rootAncestor = container.getFocusCycleRootAncestor(); |
| if (rootAncestor!=null) { |
| FocusTraversalPolicy policy = rootAncestor. |
| getFocusTraversalPolicy(); |
| Component comp; |
| |
| if (direction) { |
| comp = policy.getComponentAfter(rootAncestor, container); |
| } |
| else { |
| comp = policy.getComponentBefore(rootAncestor, container); |
| } |
| if (comp != null) { |
| comp.requestFocus(); |
| return; |
| } |
| } |
| } |
| component.requestFocus(); |
| } |
| |
| |
| /** |
| * Returns a user presentable description of this GTKColorChooserPane. |
| */ |
| public String getDisplayName() { |
| return (String)UIManager.get("GTKColorChooserPanel.nameText"); |
| } |
| |
| /** |
| * Returns the mnemonic to use with <code>getDisplayName</code>. |
| */ |
| public int getMnemonic() { |
| String m = (String)UIManager.get("GTKColorChooserPanel.mnemonic"); |
| |
| if (m != null) { |
| try { |
| int value = Integer.parseInt(m); |
| |
| return value; |
| } catch (NumberFormatException nfe) {} |
| } |
| return -1; |
| } |
| |
| /** |
| * Character to underline that represents the mnemonic. |
| */ |
| public int getDisplayedMnemonicIndex() { |
| String m = (String)UIManager.get( |
| "GTKColorChooserPanel.displayedMnemonicIndex"); |
| |
| if (m != null) { |
| try { |
| int value = Integer.parseInt(m); |
| |
| return value; |
| } catch (NumberFormatException nfe) {} |
| } |
| return -1; |
| } |
| |
| public Icon getSmallDisplayIcon() { |
| return null; |
| } |
| |
| public Icon getLargeDisplayIcon() { |
| return null; |
| } |
| |
| public void uninstallChooserPanel(JColorChooser enclosingChooser) { |
| super.uninstallChooserPanel(enclosingChooser); |
| removeAll(); |
| } |
| |
| /** |
| * Builds and configures the widgets for the GTKColorChooserPanel. |
| */ |
| protected void buildChooser() { |
| triangle = new ColorTriangle(); |
| triangle.setName("GTKColorChooserPanel.triangle"); |
| |
| // PENDING: when we straighten out user setting opacity, this should |
| // be changed. |
| label = new OpaqueLabel(); |
| label.setName("GTKColorChooserPanel.colorWell"); |
| label.setOpaque(true); |
| label.setMinimumSize(new Dimension(67, 32)); |
| label.setPreferredSize(new Dimension(67, 32)); |
| label.setMaximumSize(new Dimension(67, 32)); |
| |
| // PENDING: when we straighten out user setting opacity, this should |
| // be changed. |
| lastLabel = new OpaqueLabel(); |
| lastLabel.setName("GTKColorChooserPanel.lastColorWell"); |
| lastLabel.setOpaque(true); |
| lastLabel.setMinimumSize(new Dimension(67, 32)); |
| lastLabel.setPreferredSize(new Dimension(67, 32)); |
| lastLabel.setMaximumSize(new Dimension(67, 32)); |
| |
| hueSpinner = new JSpinner(new SpinnerNumberModel(0, 0, 360, 1)); |
| configureSpinner(hueSpinner, "GTKColorChooserPanel.hueSpinner"); |
| saturationSpinner = new JSpinner(new SpinnerNumberModel(0, 0, 255, 1)); |
| configureSpinner(saturationSpinner, |
| "GTKColorChooserPanel.saturationSpinner"); |
| valueSpinner = new JSpinner(new SpinnerNumberModel(0, 0, 255, 1)); |
| configureSpinner(valueSpinner, "GTKColorChooserPanel.valueSpinner"); |
| redSpinner = new JSpinner(new SpinnerNumberModel(0, 0, 255, 1)); |
| configureSpinner(redSpinner, "GTKColorChooserPanel.redSpinner"); |
| greenSpinner = new JSpinner(new SpinnerNumberModel(0, 0, 255, 1)); |
| configureSpinner(greenSpinner, "GTKColorChooserPanel.greenSpinner"); |
| blueSpinner = new JSpinner(new SpinnerNumberModel(0, 0, 255, 1)); |
| configureSpinner(blueSpinner, "GTKColorChooserPanel.blueSpinner"); |
| |
| colorNameTF = new JTextField(8); |
| |
| setLayout(new GridBagLayout()); |
| |
| add(this, "GTKColorChooserPanel.hue", hueSpinner, -1, -1); |
| add(this, "GTKColorChooserPanel.red", redSpinner, -1, -1); |
| add(this, "GTKColorChooserPanel.saturation", saturationSpinner, -1,-1); |
| add(this, "GTKColorChooserPanel.green", greenSpinner, -1, -1); |
| add(this, "GTKColorChooserPanel.value", valueSpinner, -1, -1); |
| add(this, "GTKColorChooserPanel.blue", blueSpinner, -1, -1); |
| |
| add(new JSeparator(SwingConstants.HORIZONTAL), new |
| GridBagConstraints(1, 3, 4, 1, 1, 0, |
| GridBagConstraints.LINE_START, GridBagConstraints.HORIZONTAL, |
| new Insets(14, 0, 0, 0), 0, 0)); |
| |
| add(this, "GTKColorChooserPanel.colorName", colorNameTF, 0, 4); |
| |
| add(triangle, new GridBagConstraints(0, 0, 1, 5, 0, 0, |
| GridBagConstraints.LINE_START, GridBagConstraints.NONE, |
| new Insets(14, 20, 2, 9), 0, 0)); |
| |
| Box hBox = Box.createHorizontalBox(); |
| hBox.add(lastLabel); |
| hBox.add(label); |
| add(hBox, new GridBagConstraints(0, 5, 1, 1, 0, 0, |
| GridBagConstraints.CENTER, GridBagConstraints.NONE, |
| new Insets(0, 0, 0, 0), 0, 0)); |
| |
| add(new JSeparator(SwingConstants.HORIZONTAL), new |
| GridBagConstraints(0, 6, 5, 1, 1, 0, |
| GridBagConstraints.LINE_START, GridBagConstraints.HORIZONTAL, |
| new Insets(12, 0, 0, 0), 0, 0)); |
| } |
| |
| /** |
| * Configures the spinner. |
| */ |
| private void configureSpinner(JSpinner spinner, String name) { |
| spinner.addChangeListener(this); |
| spinner.setName(name); |
| JComponent editor = spinner.getEditor(); |
| if (editor instanceof JSpinner.DefaultEditor) { |
| JFormattedTextField ftf = ((JSpinner.DefaultEditor)editor). |
| getTextField(); |
| |
| ftf.setFocusLostBehavior(JFormattedTextField.COMMIT_OR_REVERT); |
| } |
| } |
| |
| /** |
| * Adds the widget creating a JLabel with the specified name. |
| */ |
| private void add(Container parent, String key, JComponent widget, |
| int x, int y) { |
| JLabel label = new JLabel(UIManager.getString(key + "Text", |
| getLocale())); |
| String mnemonic = (String)UIManager.get(key + "Mnemonic", getLocale()); |
| |
| if (mnemonic != null) { |
| try { |
| label.setDisplayedMnemonic(Integer.parseInt(mnemonic)); |
| } catch (NumberFormatException nfe) { |
| } |
| String mnemonicIndex = (String)UIManager.get(key + "MnemonicIndex", |
| getLocale()); |
| |
| if (mnemonicIndex != null) { |
| try { |
| label.setDisplayedMnemonicIndex(Integer.parseInt( |
| mnemonicIndex)); |
| } catch (NumberFormatException nfe) { |
| } |
| } |
| } |
| label.setLabelFor(widget); |
| if (x < 0) { |
| x = parent.getComponentCount() % 4; |
| } |
| if (y < 0) { |
| y = parent.getComponentCount() / 4; |
| } |
| GridBagConstraints con = new GridBagConstraints(x + 1, y, 1, 1, 0, 0, |
| GridBagConstraints.FIRST_LINE_END, GridBagConstraints.NONE, |
| new Insets(4, 0, 0, 4), 0, 0); |
| if (y == 0) { |
| con.insets.top = 14; |
| } |
| parent.add(label, con); |
| con.gridx++; |
| parent.add(widget, con); |
| } |
| |
| /** |
| * Refreshes the display from the model. |
| */ |
| public void updateChooser() { |
| if (!settingColor) { |
| lastLabel.setBackground(getColorFromModel()); |
| setColor(getColorFromModel(), true, true, false); |
| } |
| } |
| |
| /** |
| * Resets the red component of the selected color. |
| */ |
| private void setRed(int red) { |
| setRGB(red << 16 | getColor().getGreen() << 8 | getColor().getBlue()); |
| } |
| |
| /** |
| * Resets the green component of the selected color. |
| */ |
| private void setGreen(int green) { |
| setRGB(getColor().getRed() << 16 | green << 8 | getColor().getBlue()); |
| } |
| |
| /** |
| * Resets the blue component of the selected color. |
| */ |
| private void setBlue(int blue) { |
| setRGB(getColor().getRed() << 16 | getColor().getGreen() << 8 | blue); |
| } |
| |
| /** |
| * Sets the hue of the selected color and updates the display if |
| * necessary. |
| */ |
| private void setHue(float hue, boolean update) { |
| setHSB(hue, saturation, brightness); |
| if (update) { |
| settingColor = true; |
| hueSpinner.setValue(Integer.valueOf((int)(hue * 360))); |
| settingColor = false; |
| } |
| } |
| |
| /** |
| * Returns the current amount of hue. |
| */ |
| private float getHue() { |
| return hue; |
| } |
| |
| /** |
| * Resets the saturation. |
| */ |
| private void setSaturation(float saturation) { |
| setHSB(hue, saturation, brightness); |
| } |
| |
| /** |
| * Returns the saturation. |
| */ |
| private float getSaturation() { |
| return saturation; |
| } |
| |
| /** |
| * Sets the brightness. |
| */ |
| private void setBrightness(float brightness) { |
| setHSB(hue, saturation, brightness); |
| } |
| |
| /** |
| * Returns the brightness. |
| */ |
| private float getBrightness() { |
| return brightness; |
| } |
| |
| /** |
| * Sets the saturation and brightness and updates the display if |
| * necessary. |
| */ |
| private void setSaturationAndBrightness(float s, float b, boolean update) { |
| setHSB(hue, s, b); |
| if (update) { |
| settingColor = true; |
| saturationSpinner.setValue(Integer.valueOf((int)(s * 255))); |
| valueSpinner.setValue(Integer.valueOf((int)(b * 255))); |
| settingColor = false; |
| } |
| } |
| |
| /** |
| * Resets the rgb values. |
| */ |
| private void setRGB(int rgb) { |
| Color color = new Color(rgb); |
| |
| setColor(color, false, true, true); |
| |
| settingColor = true; |
| hueSpinner.setValue(Integer.valueOf((int)(hue * 360))); |
| saturationSpinner.setValue(Integer.valueOf((int)(saturation * 255))); |
| valueSpinner.setValue(Integer.valueOf((int)(brightness * 255))); |
| settingColor = false; |
| } |
| |
| /** |
| * Resets the hsb values. |
| */ |
| private void setHSB(float h, float s, float b) { |
| Color color = Color.getHSBColor(h, s, b); |
| |
| this.hue = h; |
| this.saturation = s; |
| this.brightness = b; |
| setColor(color, false, false, true); |
| |
| settingColor = true; |
| redSpinner.setValue(Integer.valueOf(color.getRed())); |
| greenSpinner.setValue(Integer.valueOf(color.getGreen())); |
| blueSpinner.setValue(Integer.valueOf(color.getBlue())); |
| settingColor = false; |
| } |
| |
| |
| /** |
| * Rests the color. |
| * |
| * @param color new Color |
| * @param updateSpinners whether or not to update the spinners. |
| * @param updateHSB if true, the hsb fields are updated based on the |
| * new color |
| * @param updateModel if true, the model is set. |
| */ |
| private void setColor(Color color, boolean updateSpinners, |
| boolean updateHSB, boolean updateModel) { |
| if (color == null) { |
| color = Color.BLACK; |
| } |
| |
| settingColor = true; |
| |
| if (updateHSB) { |
| float[] hsb = Color.RGBtoHSB(color.getRed(), color.getGreen(), |
| color.getBlue(), null); |
| hue = hsb[0]; |
| saturation = hsb[1]; |
| brightness = hsb[2]; |
| } |
| |
| if (updateModel) { |
| ColorSelectionModel model = getColorSelectionModel(); |
| if (model != null) { |
| model.setSelectedColor(color); |
| } |
| } |
| |
| triangle.setColor(hue, saturation, brightness); |
| label.setBackground(color); |
| // Force Integer to pad the string with 0's by adding 0x1000000 and |
| // then removing the first character. |
| String hexString = Integer.toHexString( |
| (color.getRGB() & 0xFFFFFF) | 0x1000000); |
| colorNameTF.setText("#" + hexString.substring(1)); |
| |
| if (updateSpinners) { |
| redSpinner.setValue(Integer.valueOf(color.getRed())); |
| greenSpinner.setValue(Integer.valueOf(color.getGreen())); |
| blueSpinner.setValue(Integer.valueOf(color.getBlue())); |
| |
| hueSpinner.setValue(Integer.valueOf((int)(hue * 360))); |
| saturationSpinner.setValue(Integer.valueOf((int)(saturation * 255))); |
| valueSpinner.setValue(Integer.valueOf((int)(brightness * 255))); |
| } |
| settingColor = false; |
| } |
| |
| public Color getColor() { |
| return label.getBackground(); |
| } |
| |
| /** |
| * ChangeListener method, updates the necessary display widgets. |
| */ |
| public void stateChanged(ChangeEvent e) { |
| if (settingColor) { |
| return; |
| } |
| Color color = getColor(); |
| |
| if (e.getSource() == hueSpinner) { |
| setHue(((Number)hueSpinner.getValue()).floatValue() / 360, false); |
| } |
| else if (e.getSource() == saturationSpinner) { |
| setSaturation(((Number)saturationSpinner.getValue()). |
| floatValue() / 255); |
| } |
| else if (e.getSource() == valueSpinner) { |
| setBrightness(((Number)valueSpinner.getValue()). |
| floatValue() / 255); |
| } |
| else if (e.getSource() == redSpinner) { |
| setRed(((Number)redSpinner.getValue()).intValue()); |
| } |
| else if (e.getSource() == greenSpinner) { |
| setGreen(((Number)greenSpinner.getValue()).intValue()); |
| } |
| else if (e.getSource() == blueSpinner) { |
| setBlue(((Number)blueSpinner.getValue()).intValue()); |
| } |
| } |
| |
| |
| |
| /** |
| * Flag indicating the angle, or hue, has changed and the triangle |
| * needs to be recreated. |
| */ |
| private static final int FLAGS_CHANGED_ANGLE = 1 << 0; |
| /** |
| * Indicates the wheel is being dragged. |
| */ |
| private static final int FLAGS_DRAGGING = 1 << 1; |
| /** |
| * Indicates the triangle is being dragged. |
| */ |
| private static final int FLAGS_DRAGGING_TRIANGLE = 1 << 2; |
| /** |
| * Indicates a color is being set and we should ignore setColor |
| */ |
| private static final int FLAGS_SETTING_COLOR = 1 << 3; |
| /** |
| * Indicates the wheel has focus. |
| */ |
| private static final int FLAGS_FOCUSED_WHEEL = 1 << 4; |
| /** |
| * Indicates the triangle has focus. |
| */ |
| private static final int FLAGS_FOCUSED_TRIANGLE = 1 << 5; |
| |
| |
| /** |
| * Class responsible for rendering a color wheel and color triangle. |
| */ |
| private class ColorTriangle extends JPanel { |
| /** |
| * Cached image of the wheel. |
| */ |
| private Image wheelImage; |
| |
| /** |
| * Cached image of the triangle. |
| */ |
| private Image triangleImage; |
| |
| /** |
| * Angle triangle is rotated by. |
| */ |
| private double angle; |
| |
| /** |
| * Boolean bitmask. |
| */ |
| private int flags; |
| |
| /** |
| * X location of selected color indicator. |
| */ |
| private int circleX; |
| /** |
| * Y location of selected color indicator. |
| */ |
| private int circleY; |
| |
| |
| public ColorTriangle() { |
| enableEvents(AWTEvent.FOCUS_EVENT_MASK); |
| enableEvents(AWTEvent.MOUSE_EVENT_MASK); |
| enableEvents(AWTEvent.MOUSE_MOTION_EVENT_MASK); |
| |
| setMinimumSize(new Dimension(getWheelRadius() * 2 + 2, |
| getWheelRadius() * 2 + 2)); |
| setPreferredSize(new Dimension(getWheelRadius() * 2 + 2, |
| getWheelRadius() * 2 + 2)); |
| |
| // We want to handle tab ourself. |
| setFocusTraversalKeysEnabled(false); |
| |
| // PENDING: this should come from the style. |
| getInputMap().put(KeyStroke.getKeyStroke("UP"), "up"); |
| getInputMap().put(KeyStroke.getKeyStroke("DOWN"), "down"); |
| getInputMap().put(KeyStroke.getKeyStroke("LEFT"), "left"); |
| getInputMap().put(KeyStroke.getKeyStroke("RIGHT"), "right"); |
| |
| getInputMap().put(KeyStroke.getKeyStroke("KP_UP"), "up"); |
| getInputMap().put(KeyStroke.getKeyStroke("KP_DOWN"), "down"); |
| getInputMap().put(KeyStroke.getKeyStroke("KP_LEFT"), "left"); |
| getInputMap().put(KeyStroke.getKeyStroke("KP_RIGHT"), "right"); |
| |
| getInputMap().put(KeyStroke.getKeyStroke("TAB"), "focusNext"); |
| getInputMap().put(KeyStroke.getKeyStroke("shift TAB"),"focusLast"); |
| |
| ActionMap map = (ActionMap)UIManager.get( |
| "GTKColorChooserPanel.actionMap"); |
| |
| if (map == null) { |
| map = new ActionMapUIResource(); |
| map.put("left", new ColorAction("left", 2)); |
| map.put("right", new ColorAction("right", 3)); |
| map.put("up", new ColorAction("up", 0)); |
| map.put("down", new ColorAction("down", 1)); |
| map.put("focusNext", new ColorAction("focusNext", 4)); |
| map.put("focusLast", new ColorAction("focusLast", 5)); |
| UIManager.getLookAndFeelDefaults().put( |
| "GTKColorChooserPanel.actionMap", map); |
| } |
| SwingUtilities.replaceUIActionMap(this, map); |
| } |
| |
| /** |
| * Returns the GTKColorChooserPanel. |
| */ |
| GTKColorChooserPanel getGTKColorChooserPanel() { |
| return GTKColorChooserPanel.this; |
| } |
| |
| /** |
| * Gives focus to the wheel. |
| */ |
| void focusWheel() { |
| setFocusType(1); |
| } |
| |
| /** |
| * Gives focus to the triangle. |
| */ |
| void focusTriangle() { |
| setFocusType(2); |
| } |
| |
| /** |
| * Returns true if the wheel currently has focus. |
| */ |
| boolean isWheelFocused() { |
| return isSet(FLAGS_FOCUSED_WHEEL); |
| } |
| |
| /** |
| * Resets the selected color. |
| */ |
| public void setColor(float h, float s, float b) { |
| if (isSet(FLAGS_SETTING_COLOR)) { |
| return; |
| } |
| |
| setAngleFromHue(h); |
| setSaturationAndBrightness(s, b); |
| } |
| |
| /** |
| * Returns the selected color. |
| */ |
| public Color getColor() { |
| return GTKColorChooserPanel.this.getColor(); |
| } |
| |
| /** |
| * Returns the x location of the selected color indicator. |
| */ |
| int getColorX() { |
| return circleX + getIndicatorSize() / 2 - getWheelXOrigin(); |
| } |
| |
| /** |
| * Returns the y location of the selected color indicator. |
| */ |
| int getColorY() { |
| return circleY + getIndicatorSize() / 2 - getWheelYOrigin(); |
| } |
| |
| protected void processEvent(AWTEvent e) { |
| if (e.getID() == MouseEvent.MOUSE_PRESSED || |
| ((isSet(FLAGS_DRAGGING) ||isSet(FLAGS_DRAGGING_TRIANGLE)) && |
| e.getID() == MouseEvent.MOUSE_DRAGGED)) { |
| // Assign focus to either the wheel or triangle and attempt |
| // to drag either the wheel or triangle. |
| int size = getWheelRadius(); |
| int x = ((MouseEvent)e).getX() - size; |
| int y = ((MouseEvent)e).getY() - size; |
| |
| if (!hasFocus()) { |
| requestFocus(); |
| } |
| if (!isSet(FLAGS_DRAGGING_TRIANGLE) && |
| adjustHue(x, y, e.getID() == MouseEvent.MOUSE_PRESSED)) { |
| setFlag(FLAGS_DRAGGING, true); |
| setFocusType(1); |
| } |
| else if (adjustSB(x, y, e.getID() == |
| MouseEvent.MOUSE_PRESSED)) { |
| setFlag(FLAGS_DRAGGING_TRIANGLE, true); |
| setFocusType(2); |
| } |
| else { |
| setFocusType(2); |
| } |
| } |
| else if (e.getID() == MouseEvent.MOUSE_RELEASED) { |
| // Stopped dragging |
| setFlag(FLAGS_DRAGGING_TRIANGLE, false); |
| setFlag(FLAGS_DRAGGING, false); |
| } |
| else if (e.getID() == FocusEvent.FOCUS_LOST) { |
| // Reset the flags to indicate no one has focus |
| setFocusType(0); |
| } |
| else if (e.getID() == FocusEvent.FOCUS_GAINED) { |
| // Gained focus, reassign focus to the wheel if no one |
| // currently has focus. |
| if (!isSet(FLAGS_FOCUSED_TRIANGLE) && |
| !isSet(FLAGS_FOCUSED_WHEEL)) { |
| setFlag(FLAGS_FOCUSED_WHEEL, true); |
| setFocusType(1); |
| } |
| repaint(); |
| } |
| super.processEvent(e); |
| } |
| |
| public void paintComponent(Graphics g) { |
| super.paintComponent(g); |
| |
| // Draw the wheel and triangle |
| int size = getWheelRadius(); |
| int width = getWheelWidth(); |
| Image image = getImage(size); |
| g.drawImage(image, getWheelXOrigin() - size, |
| getWheelYOrigin() - size, null); |
| |
| // Draw the focus indicator for the wheel |
| if (hasFocus() && isSet(FLAGS_FOCUSED_WHEEL)) { |
| g.setColor(Color.BLACK); |
| g.drawOval(getWheelXOrigin() - size, getWheelYOrigin() - size, |
| 2 * size, 2 * size); |
| g.drawOval(getWheelXOrigin() - size + width, getWheelYOrigin()- |
| size + width, 2 * (size - width), 2 * |
| (size - width)); |
| } |
| |
| // Draw a line on the wheel indicating the selected hue. |
| if (Math.toDegrees(Math.PI * 2 - angle) <= 20 || |
| Math.toDegrees(Math.PI * 2 - angle) >= 201) { |
| g.setColor(Color.WHITE); |
| } |
| else { |
| g.setColor(Color.BLACK); |
| } |
| int lineX0 = (int)(Math.cos(angle) * size); |
| int lineY0 = (int)(Math.sin(angle) * size); |
| int lineX1 = (int)(Math.cos(angle) * (size - width)); |
| int lineY1 = (int)(Math.sin(angle) * (size - width)); |
| g.drawLine(lineX0 + size, lineY0 + size, lineX1 + size, |
| lineY1 + size); |
| |
| // Draw the focus indicator on the triangle |
| if (hasFocus() && isSet(FLAGS_FOCUSED_TRIANGLE)) { |
| Graphics g2 = g.create(); |
| int innerR = getTriangleCircumscribedRadius(); |
| int a = (int)(3 * innerR / Math.sqrt(3)); |
| g2.translate(getWheelXOrigin(), getWheelYOrigin()); |
| ((Graphics2D)g2).rotate(angle + Math.PI / 2); |
| g2.setColor(Color.BLACK); |
| g2.drawLine(0, -innerR, a / 2, innerR / 2); |
| g2.drawLine(a / 2, innerR / 2, -a / 2, innerR / 2); |
| g2.drawLine(-a / 2, innerR / 2, 0, -innerR); |
| g2.dispose(); |
| } |
| |
| // Draw the selected color indicator. |
| g.setColor(Color.BLACK); |
| g.drawOval(circleX, circleY, getIndicatorSize() - 1, |
| getIndicatorSize() - 1); |
| g.setColor(Color.WHITE); |
| g.drawOval(circleX + 1, circleY + 1, getIndicatorSize() - 3, |
| getIndicatorSize() - 3); |
| } |
| |
| /** |
| * Returns an image representing the triangle and wheel. |
| */ |
| private Image getImage(int size) { |
| if (!isSet(FLAGS_CHANGED_ANGLE) && wheelImage != null && |
| wheelImage.getWidth(null) == size * 2) { |
| return wheelImage; |
| } |
| if (wheelImage == null || wheelImage.getWidth(null) != size) { |
| wheelImage = getWheelImage(size); |
| } |
| int innerR = getTriangleCircumscribedRadius(); |
| int triangleSize = (int)(innerR * 3.0 / 2.0); |
| int a = (int)(2 * triangleSize / Math.sqrt(3)); |
| if (triangleImage == null || triangleImage.getWidth(null) != a) { |
| triangleImage = new BufferedImage(a, a, |
| BufferedImage.TYPE_INT_ARGB); |
| } |
| Graphics g = triangleImage.getGraphics(); |
| g.setColor(new Color(0, 0, 0, 0)); |
| g.fillRect(0, 0, a, a); |
| g.translate(a / 2, 0); |
| paintTriangle(g, triangleSize, getColor()); |
| g.translate(-a / 2, 0); |
| g.dispose(); |
| |
| g = wheelImage.getGraphics(); |
| g.setColor(new Color(0, 0, 0, 0)); |
| g.fillOval(getWheelWidth(), getWheelWidth(), |
| 2 * (size - getWheelWidth()), |
| 2 * (size - getWheelWidth())); |
| |
| double rotate = Math.toRadians(-30.0) + angle; |
| g.translate(size, size); |
| ((Graphics2D)g).rotate(rotate); |
| g.drawImage(triangleImage, -a / 2, |
| getWheelWidth() - size, null); |
| ((Graphics2D)g).rotate(-rotate); |
| g.translate(a / 2, size - getWheelWidth()); |
| |
| setFlag(FLAGS_CHANGED_ANGLE, false); |
| |
| return wheelImage; |
| } |
| |
| private void paintTriangle(Graphics g, int size, Color color) { |
| float[] colors = Color.RGBtoHSB(color.getRed(), |
| color.getGreen(), |
| color.getBlue(), null); |
| float hue = colors[0]; |
| double dSize = (double)size; |
| for (int y = 0; y < size; y++) { |
| int maxX = (int)(y * Math.tan(Math.toRadians(30.0))); |
| float factor = maxX * 2; |
| if (maxX > 0) { |
| float value = (float)(y / dSize); |
| for (int x = -maxX; x <= maxX; x++) { |
| float saturation = (float)x / factor + .5f; |
| g.setColor(Color.getHSBColor(hue, saturation, value)); |
| g.fillRect(x, y, 1, 1); |
| } |
| } |
| else { |
| g.setColor(color); |
| g.fillRect(0, y, 1, 1); |
| } |
| } |
| } |
| |
| /** |
| * Returns a color wheel image for the specified size. |
| * |
| * @param size Integer giving size of color wheel. |
| * @return Color wheel image |
| */ |
| private Image getWheelImage(int size) { |
| int minSize = size - getWheelWidth(); |
| int doubleSize = size * 2; |
| BufferedImage image = new BufferedImage(doubleSize, doubleSize, |
| BufferedImage.TYPE_INT_ARGB); |
| |
| for (int y = -size; y < size; y++) { |
| int ySquared = y * y; |
| for (int x = -size; x < size; x++) { |
| double rad = Math.sqrt(ySquared + x * x); |
| |
| if (rad < size && rad > minSize) { |
| int rgb = colorWheelLocationToRGB(x, y, rad) | |
| 0xFF000000; |
| image.setRGB(x + size, y + size, rgb); |
| } |
| } |
| } |
| wheelImage = image; |
| return wheelImage; |
| } |
| |
| /** |
| * Adjusts the saturation and brightness. <code>x</code> and |
| * <code>y</code> give the location to adjust to and are relative |
| * to the origin of the wheel/triangle. |
| * |
| * @param x X coordinate on the triangle to adjust to |
| * @param y Y coordinate on the triangle to adjust to |
| * @param checkLoc if true the location is checked to make sure |
| * it is contained in the triangle, if false the location is |
| * constrained to fit in the triangle. |
| * @return true if the location is valid |
| */ |
| boolean adjustSB(int x, int y, boolean checkLoc) { |
| int innerR = getWheelRadius() - getWheelWidth(); |
| boolean resetXY = false; |
| // Invert the axis. |
| y = -y; |
| if (checkLoc && (x < -innerR || x > innerR || y < -innerR || |
| y > innerR)) { |
| return false; |
| } |
| // Rotate to origin and and verify x is valid. |
| int triangleSize = innerR * 3 / 2; |
| double x1 = Math.cos(angle) * x - Math.sin(angle) * y; |
| double y1 = Math.sin(angle) * x + Math.cos(angle) * y; |
| if (x1 < -(innerR / 2)) { |
| if (checkLoc) { |
| return false; |
| } |
| x1 = -innerR / 2; |
| resetXY = true; |
| } |
| else if ((int)x1 > innerR) { |
| if (checkLoc) { |
| return false; |
| } |
| x1 = innerR; |
| resetXY = true; |
| } |
| // Verify y location is valid. |
| int maxY = (int)((triangleSize - x1 - innerR / 2.0) * |
| Math.tan(Math.toRadians(30.0))); |
| if (y1 <= -maxY) { |
| if (checkLoc) { |
| return false; |
| } |
| y1 = -maxY; |
| resetXY = true; |
| } |
| else if (y1 > maxY) { |
| if (checkLoc) { |
| return false; |
| } |
| y1 = maxY; |
| resetXY = true; |
| } |
| // Rotate again to determine value and scale |
| double x2 = Math.cos(Math.toRadians(-30.0)) * x1 - |
| Math.sin(Math.toRadians(-30.0)) * y1; |
| double y2 = Math.sin(Math.toRadians(-30.0)) * x1 + |
| Math.cos(Math.toRadians(-30.0)) * y1; |
| float value = Math.min(1.0f, (float)((innerR - y2) / |
| (double)triangleSize)); |
| float maxX = (float)(Math.tan(Math.toRadians(30)) * (innerR - y2)); |
| float saturation = Math.min(1.0f, (float)(x2 / maxX / 2 + .5)); |
| |
| setFlag(FLAGS_SETTING_COLOR, true); |
| if (resetXY) { |
| setSaturationAndBrightness(saturation, value); |
| } |
| else { |
| setSaturationAndBrightness(saturation, value, x + |
| getWheelXOrigin(),getWheelYOrigin() - y); |
| } |
| GTKColorChooserPanel.this.setSaturationAndBrightness(saturation, |
| value, true); |
| setFlag(FLAGS_SETTING_COLOR, false); |
| return true; |
| } |
| |
| /** |
| * Sets the saturation and brightness. |
| */ |
| private void setSaturationAndBrightness(float s, float b) { |
| int innerR = getTriangleCircumscribedRadius(); |
| int triangleSize = innerR * 3 / 2; |
| double x = b * triangleSize; |
| double maxY = x * Math.tan(Math.toRadians(30.0)); |
| double y = 2 * maxY * s - maxY; |
| x = x - innerR; |
| double x1 = Math.cos(Math.toRadians(-60.0) - angle) * |
| x - Math.sin(Math.toRadians(-60.0) - angle) * y; |
| double y1 = Math.sin(Math.toRadians(-60.0) - angle) * x + |
| Math.cos(Math.toRadians(-60.0) - angle) * y; |
| int newCircleX = (int)x1 + getWheelXOrigin(); |
| int newCircleY = getWheelYOrigin() - (int)y1; |
| |
| setSaturationAndBrightness(s, b, newCircleX, newCircleY); |
| } |
| |
| |
| /** |
| * Sets the saturation and brightness. |
| */ |
| private void setSaturationAndBrightness(float s, float b, |
| int newCircleX, int newCircleY) { |
| newCircleX -= getIndicatorSize() / 2; |
| newCircleY -= getIndicatorSize() / 2; |
| |
| int minX = Math.min(newCircleX, circleX); |
| int minY = Math.min(newCircleY, circleY); |
| |
| repaint(minX, minY, Math.max(circleX, newCircleX) - minX + |
| getIndicatorSize() + 1, Math.max(circleY, newCircleY) - |
| minY + getIndicatorSize() + 1); |
| circleX = newCircleX; |
| circleY = newCircleY; |
| } |
| |
| /** |
| * Adjusts the hue based on the passed in location. |
| * |
| * @param x X location to adjust to, relative to the origin of the |
| * wheel |
| * @param y Y location to adjust to, relative to the origin of the |
| * wheel |
| * @param check if true the location is checked to make sure |
| * it is contained in the wheel, if false the location is |
| * constrained to fit in the wheel |
| * @return true if the location is valid. |
| */ |
| private boolean adjustHue(int x, int y, boolean check) { |
| double rad = Math.sqrt(x * x + y * y); |
| int size = getWheelRadius(); |
| |
| if (!check || (rad >= size - getWheelWidth() && rad < size)) { |
| // Map the location to an angle and reset hue |
| double angle; |
| if (x == 0) { |
| if (y > 0) { |
| angle = Math.PI / 2.0; |
| } |
| else { |
| angle = Math.PI + Math.PI / 2.0; |
| } |
| } |
| else { |
| angle = Math.atan((double)y / (double)x); |
| if (x < 0) { |
| angle += Math.PI; |
| } |
| else if (angle < 0) { |
| angle += 2 * Math.PI; |
| } |
| } |
| setFlag(FLAGS_SETTING_COLOR, true); |
| setHue((float)(1.0 - angle / Math.PI / 2), true); |
| setFlag(FLAGS_SETTING_COLOR, false); |
| setHueAngle(angle); |
| setSaturationAndBrightness(getSaturation(), getBrightness()); |
| return true; |
| } |
| return false; |
| } |
| |
| /** |
| * Rotates the triangle to accomodate the passed in hue. |
| */ |
| private void setAngleFromHue(float hue) { |
| setHueAngle((1.0 - hue) * Math.PI * 2); |
| } |
| |
| /** |
| * Sets the angle representing the hue. |
| */ |
| private void setHueAngle(double angle) { |
| double oldAngle = this.angle; |
| |
| this.angle = angle; |
| if (angle != oldAngle) { |
| setFlag(FLAGS_CHANGED_ANGLE, true); |
| repaint(); |
| } |
| } |
| |
| /** |
| * Returns the size of the color indicator. |
| */ |
| private int getIndicatorSize() { |
| return 8; |
| } |
| |
| /** |
| * Returns the circumscribed radius of the triangle. |
| */ |
| private int getTriangleCircumscribedRadius() { |
| return 72; |
| } |
| |
| /** |
| * Returns the x origin of the wheel and triangle. |
| */ |
| private int getWheelXOrigin() { |
| return 85; |
| } |
| |
| /** |
| * Returns y origin of the wheel and triangle. |
| */ |
| private int getWheelYOrigin() { |
| return 85; |
| } |
| |
| /** |
| * Returns the width of the wheel. |
| */ |
| private int getWheelWidth() { |
| return 13; |
| } |
| |
| /** |
| * Sets the focus to one of: 0 no one, 1 the wheel or 2 the triangle. |
| */ |
| private void setFocusType(int type) { |
| if (type == 0) { |
| setFlag(FLAGS_FOCUSED_WHEEL, false); |
| setFlag(FLAGS_FOCUSED_TRIANGLE, false); |
| repaint(); |
| } |
| else { |
| int toSet = FLAGS_FOCUSED_WHEEL; |
| int toUnset = FLAGS_FOCUSED_TRIANGLE; |
| |
| if (type == 2) { |
| toSet = FLAGS_FOCUSED_TRIANGLE; |
| toUnset = FLAGS_FOCUSED_WHEEL; |
| } |
| if (!isSet(toSet)) { |
| setFlag(toSet, true); |
| repaint(); |
| setFlag(toUnset, false); |
| } |
| } |
| } |
| |
| /** |
| * Returns the radius of the wheel. |
| */ |
| private int getWheelRadius() { |
| // As far as I can tell, GTK doesn't allow stretching this |
| // widget |
| return 85; |
| } |
| |
| /** |
| * Updates the flags bitmask. |
| */ |
| private void setFlag(int flag, boolean value) { |
| if (value) { |
| flags |= flag; |
| } |
| else { |
| flags &= ~flag; |
| } |
| } |
| |
| /** |
| * Returns true if a particular flag has been set. |
| */ |
| private boolean isSet(int flag) { |
| return ((flags & flag) == flag); |
| } |
| |
| /** |
| * Returns the RGB color to use for the specified location. The |
| * passed in point must be on the color wheel and be relative to the |
| * origin of the color wheel. |
| * |
| * @param x X location to get color for |
| * @param y Y location to get color for |
| * @param rad Radius from center of color wheel |
| * @return integer with red, green and blue components |
| */ |
| private int colorWheelLocationToRGB(int x, int y, double rad) { |
| double angle = Math.acos((double)x / rad); |
| int rgb; |
| |
| if (angle < PI_3) { |
| if (y < 0) { |
| // FFFF00 - FF0000 |
| rgb = 0xFF0000 | Math.min(255, |
| (int)(255 * angle / PI_3)) << 8; |
| } |
| else { |
| // FF0000 - FF00FF |
| rgb = 0xFF0000 | Math.min(255, |
| (int)(255 * angle / PI_3)); |
| } |
| } |
| else if (angle < 2 * PI_3) { |
| angle -= PI_3; |
| if (y < 0) { |
| // 00FF00 - FFFF00 |
| rgb = 0x00FF00 | Math.max(0, 255 - |
| (int)(255 * angle / PI_3)) << 16; |
| } |
| else { |
| // FF00FF - 0000FF |
| rgb = 0x0000FF | Math.max(0, 255 - |
| (int)(255 * angle / PI_3)) << 16; |
| } |
| } |
| else { |
| angle -= 2 * PI_3; |
| if (y < 0) { |
| // 00FFFF - 00FF00 |
| rgb = 0x00FF00 | Math.min(255, |
| (int)(255 * angle / PI_3)); |
| } |
| else { |
| // 0000FF - 00FFFF |
| rgb = 0x0000FF | Math.min(255, |
| (int)(255 * angle / PI_3)) << 8; |
| } |
| } |
| return rgb; |
| } |
| |
| /** |
| * Increments the hue. |
| */ |
| void incrementHue(boolean positive) { |
| float hue = triangle.getGTKColorChooserPanel().getHue(); |
| |
| if (positive) { |
| hue += 1.0f / 360.0f; |
| } |
| else { |
| hue -= 1.0f / 360.0f; |
| } |
| if (hue > 1) { |
| hue -= 1; |
| } |
| else if (hue < 0) { |
| hue += 1; |
| } |
| getGTKColorChooserPanel().setHue(hue, true); |
| } |
| } |
| |
| |
| /** |
| * Action class used for colors. |
| */ |
| private static class ColorAction extends AbstractAction { |
| private int type; |
| |
| ColorAction(String name, int type) { |
| super(name); |
| this.type = type; |
| } |
| |
| public void actionPerformed(ActionEvent e) { |
| ColorTriangle triangle = (ColorTriangle)e.getSource(); |
| |
| if (triangle.isWheelFocused()) { |
| float hue = triangle.getGTKColorChooserPanel().getHue(); |
| |
| switch (type) { |
| case 0: |
| case 2: |
| triangle.incrementHue(true); |
| break; |
| case 1: |
| case 3: |
| triangle.incrementHue(false); |
| break; |
| case 4: |
| triangle.focusTriangle(); |
| break; |
| case 5: |
| compositeRequestFocus(triangle, false); |
| break; |
| } |
| } |
| else { |
| int xDelta = 0; |
| int yDelta = 0; |
| |
| switch (type) { |
| case 0: |
| // up |
| yDelta--; |
| break; |
| case 1: |
| // down |
| yDelta++; |
| break; |
| case 2: |
| // left |
| xDelta--; |
| break; |
| case 3: |
| // right |
| xDelta++; |
| break; |
| case 4: |
| compositeRequestFocus(triangle, true); |
| return; |
| case 5: |
| triangle.focusWheel(); |
| return; |
| } |
| triangle.adjustSB(triangle.getColorX() + xDelta, |
| triangle.getColorY() + yDelta, true); |
| } |
| } |
| } |
| |
| |
| private class OpaqueLabel extends JLabel { |
| public boolean isOpaque() { |
| return true; |
| } |
| } |
| } |
