| /* |
| * Copyright (c) 2001, 2014, 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. |
| * |
| * 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 test.java.awt.event.helpers.lwcomponents; |
| |
| import java.io.*; |
| import java.awt.*; |
| import java.awt.event.*; |
| |
| /** |
| * This is experimental - The idea is to subclass all the LW components |
| * from LWComponent to provide for some common capabilities. The main |
| * capability to be provided is the status rectangles as done for LWButton. |
| * In particular the Focus and MouseOver rectangles are generically |
| * useful, while other rectangles might be useful to other components.<p> |
| * |
| * To implement that, here is the idea ... borrowed from Win32 ... Each |
| * of the LW components has both a client and non-client region. We |
| * call paintNC to paint the non-client region (Focus and MouseOver |
| * rectangles), and the subclass might be permitted to implement paintNC |
| * but for now they aren't.<p> |
| * |
| * Then the paint{Enabled,Disabled} methods are called as appropriate. |
| * Note that paintDisabled is implemented in LWComponent to call paintEnabled |
| * then stipple over the top of it.<p> |
| * |
| * So it is paintEnabled that the component should implement. This method |
| * needs to know the dimensions of the client area (getClientRegion?) and |
| * the Graphics needs to have it's clip region set appropriately.<p> |
| * |
| * <b>KVETCHING</b>: <i>Kvetch</i> is a Yiddish word which means, basically, |
| * to complain very precisely. The LWComponent family tracks various pieces |
| * of information over time that are used to check closely for correct behavior |
| * in some circumstances. The method <i>kvetch</i> is where this code lives |
| * and is intended to check a broad range of conditions.<p> |
| * |
| * To turn off specific kvetch's, one simply specifies a System property |
| * as in this table:<p> |
| * |
| * <table border="1"> |
| * <tr><th>Property name</th><th>Value</th><th>Discussion</th></tr> |
| * <tr> |
| * <th>javasoft.awtsqe.lw.IGNORE_FOCUS_KVETCH</th> |
| * <th>true or false</th> |
| * <td>Specify whether the <i>hasFocus</i> kvetch is checked.</td> |
| * </tr> |
| * </table><p> |
| * |
| * <b>XXX To implement</b> - specifying colors. NCBackground, |
| * FocusRectColor, MouseOverColor are the threee colors. paintNC |
| * fills the NC region with NCBackground, and then pains the two |
| * colors as appropriate. There needs to be methods to get/specify |
| * these colors.<p> |
| * |
| * <b>XXX To implement</b> - Specifying the component name and toString(). |
| * The subclass should only give the base class name, and a method |
| * in LWComponent should construct a name from that. For toString() |
| * there needs to be a small amount of infrastructure built.<p> |
| */ |
| |
| public abstract class LWComponent extends Component { |
| |
| protected static Color ncBackgroundColor; |
| protected static Color focusColor; |
| protected static Color focusWrongColor; |
| protected static Color mouseOverColor; |
| |
| static { |
| ncBackgroundColor = Color.white; |
| focusColor = Color.black; |
| focusWrongColor = Color.magenta; |
| mouseOverColor = Color.blue; |
| } |
| |
| /** |
| * Flag indicating whether our records indicate that the component |
| * should have focus. |
| */ |
| protected boolean _shouldHaveFocus = false; |
| protected boolean _shouldBeShowing = false; |
| |
| protected boolean mouseB1Pressed = false; |
| protected boolean mouseB2Pressed = false; |
| protected boolean mouseB3Pressed = false; |
| protected boolean mouseInside = false; |
| |
| protected static boolean tracingOn = false; |
| protected static PrintStream traceOutput = null; |
| |
| // Uncommenting these lines turns on tracing for the package. |
| // static { |
| // tracingOn = true; |
| // traceOutput = System.err; |
| // } |
| |
| public LWComponent() { |
| enableEvents(AWTEvent.MOUSE_EVENT_MASK |
| /*| AWTEvent.MOUSE_MOTION_EVENT_MASK*/ |
| | AWTEvent.FOCUS_EVENT_MASK |
| | AWTEvent.COMPONENT_EVENT_MASK); |
| } |
| |
| /** |
| * Print out an error message. |
| * @param msg the message |
| */ |
| public static void errorMsg(String msg) { |
| System.err.println("ERROR: " + msg); |
| } |
| |
| /** |
| * Print out a tracing message |
| * @param msg the message |
| */ |
| public static void traceMsg(String msg) { |
| if (LWComponent.tracingOn) { |
| LWComponent.traceOutput.println(msg); |
| } |
| } |
| |
| ///////////////////////////////////////////// |
| /////// FLAGS FOR IGNORING KVETCH's ///////// |
| ///////////////////////////////////////////// |
| |
| static boolean bIgnFocus = false; |
| |
| static { |
| // Initialize the kvetch ignoring flags here. |
| String ignFocus = System.getProperty("javasoft.awtsqe.lw.IGNORE_FOCUS_KVETCH", |
| "false"); |
| bIgnFocus = ignFocus.trim().toLowerCase().equals("true"); |
| } |
| |
| /** |
| * Check the <i>shoulds</i> and return a string indicating which |
| * do not match the components actual state. |
| * |
| * @return the string indicating which do not match the components actual state |
| */ |
| public String kvetch() { |
| String ret = this.toString(); |
| boolean errors = false; |
| |
| if (!bIgnFocus) { |
| if (hasFocus()) { |
| if (!shouldHaveFocus()) { |
| ret += "\nERROR: hasFocus indicates we have Focus, when we shouldn't."; |
| errors = true; |
| } |
| } else { |
| if (shouldHaveFocus()) { |
| ret += "\nERROR: (see bug#4233658) hasFocus does not indicate we have Focus, when we should."; |
| errors = true; |
| } |
| } |
| } |
| |
| if (errors) { |
| return ret; |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Check the <i>shoulds</i> and return a string indicating which |
| * do not match the components actual state. Prints the output |
| * to the given PrintStream. |
| * @param out The PrintStream to print to. |
| */ |
| public void kvetch(PrintStream out) { |
| if (out != null) { |
| String s = kvetch(); |
| if (s != null) { |
| LWComponent.errorMsg(s); |
| } |
| } |
| } |
| |
| /** |
| * Turn on tracing for the LWComponent family. |
| * @param out the output stream |
| */ |
| public static void startTracing(PrintStream out) { |
| tracingOn = true; |
| traceOutput = out; |
| } |
| |
| /** |
| * Turn off tracing for the LWComponent family. |
| */ |
| public static void stopTracing() { tracingOn = false; traceOutput = null; } |
| |
| /** |
| * Indicate whether it is believed the component should have focus. |
| * @return {@code true} if the component should have focus |
| */ |
| public boolean shouldHaveFocus() { return _shouldHaveFocus; } |
| |
| /** |
| * Indicate whether it is believed the component should be showing. |
| * @return {@code true} if the component should be showing |
| */ |
| public boolean shouldBeShowing() { return _shouldBeShowing; } |
| |
| @Override |
| protected void processFocusEvent(FocusEvent e) { |
| super.processFocusEvent(e); |
| LWComponent.traceMsg("processFocusEvent " + e.toString()); |
| switch (e.getID()) { |
| case FocusEvent.FOCUS_GAINED: |
| _shouldHaveFocus = true; |
| repaint(); |
| break; |
| case FocusEvent.FOCUS_LOST: |
| _shouldHaveFocus = false; |
| repaint(); |
| break; |
| } |
| } |
| |
| @Override |
| protected void processComponentEvent(ComponentEvent e) { |
| super.processComponentEvent(e); |
| LWComponent.traceMsg("processComponentEvent " + e.toString()); |
| switch (e.getID()) { |
| case ComponentEvent.COMPONENT_MOVED: break; |
| case ComponentEvent.COMPONENT_RESIZED: break; |
| case ComponentEvent.COMPONENT_SHOWN: _shouldBeShowing = true; break; |
| case ComponentEvent.COMPONENT_HIDDEN: _shouldBeShowing = false; break; |
| } |
| } |
| |
| @Override |
| protected void processMouseEvent(MouseEvent e) { |
| int mod = e.getModifiers(); |
| super.processMouseEvent(e); |
| LWComponent.traceMsg("processMouseEvent " + e.toString()); |
| switch (e.getID()) { |
| case MouseEvent.MOUSE_PRESSED: |
| if ((mod & MouseEvent.BUTTON1_MASK) != 0) { |
| if (mouseB1Pressed) { |
| errorMsg("ERROR: MOUSE_PRESSED for B1 when already pressed, on " |
| + this.toString()); |
| } |
| mouseB1Pressed = true; |
| break; |
| } |
| if ((mod & MouseEvent.BUTTON2_MASK) != 0) { |
| if (mouseB2Pressed) { |
| errorMsg("ERROR: MOUSE_PRESSED for B2 when already pressed, on " |
| + this.toString()); |
| } |
| mouseB2Pressed = true; |
| break; |
| } |
| if ((mod & MouseEvent.BUTTON3_MASK) != 0) { |
| if (mouseB3Pressed) { |
| errorMsg("ERROR: MOUSE_PRESSED for B3 when already pressed, on " |
| + this.toString()); |
| } |
| mouseB3Pressed = true; |
| break; |
| } |
| repaint(); |
| break; |
| case MouseEvent.MOUSE_RELEASED: |
| if ((mod & MouseEvent.BUTTON1_MASK) != 0) { |
| if (!mouseB1Pressed) { |
| errorMsg("ERROR: MOUSE_RELEASED for B1 when not pressed, on " |
| + this.toString()); |
| } |
| mouseB1Pressed = false; |
| break; |
| } |
| if ((mod & MouseEvent.BUTTON2_MASK) != 0) { |
| if (!mouseB2Pressed) { |
| errorMsg("ERROR: MOUSE_RELEASED for B2 when not pressed, on " |
| + this.toString()); |
| } |
| mouseB2Pressed = false; |
| break; |
| } |
| if ((mod & MouseEvent.BUTTON3_MASK) != 0) { |
| if (!mouseB3Pressed) { |
| errorMsg("ERROR: MOUSE_RELEASED for B3 when not pressed, on " |
| + this.toString()); |
| } |
| mouseB3Pressed = false; |
| break; |
| } |
| repaint(); |
| break; |
| case MouseEvent.MOUSE_CLICKED: |
| break; |
| case MouseEvent.MOUSE_ENTERED: |
| if (mouseInside) { |
| errorMsg("ERROR: MOUSE_ENTERED when mouse already inside component, on " |
| + this.toString()); |
| } |
| mouseInside = true; |
| repaint(); |
| break; |
| case MouseEvent.MOUSE_EXITED: |
| if (!mouseInside) { |
| errorMsg("ERROR: MOUSE_EXITED when mouse not inside component, on " |
| + this.toString()); |
| } |
| mouseInside = false; |
| repaint(); |
| break; |
| case MouseEvent.MOUSE_MOVED: |
| break; |
| case MouseEvent.MOUSE_DRAGGED: |
| break; |
| } |
| } |
| |
| public Point getClientLocation() { |
| return new Point(5, 5); |
| } |
| |
| public Dimension getClientSize() { |
| Dimension dim = getSize(); |
| dim.width -= 10; |
| dim.height -= 10; |
| return dim; |
| } |
| |
| public Rectangle getClientBounds() { |
| Dimension dim = getClientSize(); |
| return new Rectangle(5, 5, dim.width, dim.height); |
| } |
| |
| public int getClientX() { return 5; } |
| public int getClientY() { return 5; } |
| |
| /** |
| * Set the color used for painting the non-client area of the component. |
| * The default for this is Color.white. |
| * |
| * @param c The new color to use. |
| */ |
| public void setNonClientColor(Color c) { |
| LWComponent.ncBackgroundColor = c; |
| } |
| |
| /** |
| * Handle painting for the component. |
| */ |
| @Override |
| public void paint(Graphics g) { |
| Dimension dim = getSize(); |
| |
| kvetch(System.err); |
| |
| Color saveColor = g.getColor(); |
| super.paint(g); |
| |
| // ------------------- Paint the background ----------------- |
| |
| // In jdk 1.2 (pre-release) there was a bug using clearRect |
| // to paint the background of a lightweight. |
| //g.clearRect(0, 0, dim.width, dim.height); |
| g.setColor(getBackground()); |
| g.fillRect(0, 0, dim.width, dim.height); |
| |
| // ------------------- Paint the non-client area ------------ |
| |
| g.setColor(ncBackgroundColor); |
| // x y width height |
| g.fillRect(0, 0, dim.width, 5); |
| g.fillRect(0, 5, 5, dim.height - 10); |
| g.fillRect(dim.width - 5, 5, 5, dim.height - 10); |
| g.fillRect(0, dim.height - 5, dim.width, 5); |
| |
| if (shouldHaveFocus() || hasFocus()) { |
| g.setColor(shouldHaveFocus() && hasFocus() |
| ? focusColor |
| : focusWrongColor); |
| g.drawRect(1, 1, dim.width - 3, dim.height - 3); |
| } |
| |
| if (mouseInside) { |
| g.setColor(mouseOverColor); |
| g.drawRect(3, 3, dim.width - 7, dim.height - 7); |
| } |
| |
| // ------------------- Paint disabledness, if true ----------- |
| |
| if (!isEnabled()) { |
| g.setColor(getBackground()); |
| Dimension size = getSize(); |
| int borderThickness = 0; |
| int startX = borderThickness; |
| int startY = borderThickness; |
| int endX = startX + size.width - 2 * borderThickness - 2; |
| int endY = startY + size.height - 2 * borderThickness - 2; |
| int x, y; |
| for (y = startY; y <= endY; y += 1) { |
| for (x = startX + (y % 2); x <= endX; x += 2) { |
| g.fillRect(x, y, 1, 1); |
| } // x |
| } // y |
| } |
| |
| g.setColor(saveColor); |
| } |
| |
| /** |
| * Restricts the Graphics to be within the "client area" of the |
| * component. Recall that the LWComponent series of components has |
| * a "non-client area" of 5 pixels wide in which it draws two |
| * status rectangles showing mouse-over and has-focus status. <p> |
| * |
| * Child classes of LWComponent are to call {@code restrictGraphicsToClientArea} |
| * at the beginning of their {@code paint} method, and then call |
| * {@code unrestrictGraphicsFromClientArea} afterwards.<p> |
| * |
| * In order to make those paint methods as convenient as possible, these |
| * two methods make it appear as if the Graphics available to the |
| * component is slightly smaller than it really is, by the amount |
| * used in the non-client area (5 pixel wide border).<p> |
| * |
| * @param g The Graphics to restrict. |
| */ |
| public void restrictGraphicsToClientArea(Graphics g) { |
| Dimension dim = getSize(); |
| g.translate(5, 5); |
| g.setClip(0, 0, dim.width - 10, dim.height - 10); |
| } |
| |
| /** |
| * Undo the restriction done in restrictGraphicsToClientArea. |
| * |
| * @param g The Graphics to unrestrict. |
| */ |
| public void unrestrictGraphicsFromClientArea(Graphics g) { |
| g.translate(-5, -5); |
| Dimension dim = getSize(); |
| g.setClip(0, 0, dim.width, dim.height); |
| } |
| |
| } |
