001: /*
002: *
003: *
004: * Copyright 1990-2007 Sun Microsystems, Inc. All Rights Reserved.
005: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
006: *
007: * This program is free software; you can redistribute it and/or
008: * modify it under the terms of the GNU General Public License version
009: * 2 only, as published by the Free Software Foundation.
010: *
011: * This program is distributed in the hope that it will be useful, but
012: * WITHOUT ANY WARRANTY; without even the implied warranty of
013: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
014: * General Public License version 2 for more details (a copy is
015: * included at /legal/license.txt).
016: *
017: * You should have received a copy of the GNU General Public License
018: * version 2 along with this work; if not, write to the Free Software
019: * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
020: * 02110-1301 USA
021: *
022: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
023: * Clara, CA 95054 or visit www.sun.com if you need additional
024: * information or have any questions.
025: */
026:
027: package com.sun.midp.util;
028:
029: import javax.microedition.lcdui.Canvas;
030: import javax.microedition.lcdui.Display;
031: import javax.microedition.lcdui.Graphics;
032:
033: /**
034: * A simple test canvas. Adds the ability to wait for the Canvas to become
035: * visible for the first time.
036: */
037:
038: public class LcduiTestCanvas extends Canvas {
039: static final long TIMEOUT = 1000L;
040: boolean painted = false;
041: boolean shown = false;
042: boolean everShown = false;
043:
044: /**
045: * Subclassers should override this to do actual painting.
046: */
047: public void paint1(Graphics g) {
048: }
049:
050: /**
051: * Subclassers should override this to do showNotify() processing.
052: */
053: public void showNotify1() {
054: }
055:
056: /**
057: * Subclassers should override this to do hideNotify() processing.
058: */
059: public void hideNotify1() {
060: }
061:
062: /**
063: * Notifies when painted for the first time. This is made final so that
064: * subclassers can't accidentally break this if they override and forget
065: * to call super(). Subclassers should override paint1() to do actual
066: * painting.
067: */
068: public final void paint(Graphics g) {
069: synchronized (this ) {
070: if (!painted) {
071: painted = true;
072: notifyAll();
073: }
074: }
075: paint1(g);
076: }
077:
078: /**
079: * Tracks the shown state. If this is the first time the Canvas is being
080: * shown, sets everShown and does a monitor notify. This is made final so
081: * that subclassers can't accidentally break the protocol if they override
082: * and forget to call super(). Subclassers may override showNotify1() if
083: * they wish to do show processing.
084: */
085: public final void showNotify() {
086: synchronized (this ) {
087: shown = true;
088: if (!everShown) {
089: everShown = true;
090: notifyAll();
091: }
092: }
093: showNotify1();
094: }
095:
096: /**
097: * Tracks the shown state. This is made final so that subclassers can't
098: * accidentally break the protocol if they override and forget to call
099: * super(). Subclassers may override hideNotify1() if they wish to do hide
100: * processing.
101: */
102: public final void hideNotify() {
103: synchronized (this ) {
104: shown = false;
105: }
106: hideNotify1();
107: }
108:
109: /**
110: * Waits until this canvas is painted for the first time. Proper operation
111: * relies on the caller to have arranged for this canvas to be shown, for
112: * example, with setCurrent(). Returns immediately if the canvas has been
113: * painted already, even if it's been hidden and shown again. Returns true
114: * if the canvas has been painted at least once. Returns false if the wait
115: * was interrupted or if it timed out. This method must not be called on
116: * the event thread. If it is, it will block paint processing and will
117: * eventually timeout.
118: */
119: public boolean awaitPaint() {
120: long deadline = System.currentTimeMillis() + TIMEOUT;
121:
122: synchronized (this ) {
123: try {
124: while (!painted
125: && System.currentTimeMillis() < deadline) {
126: wait(TIMEOUT);
127: }
128: } catch (InterruptedException ie) {
129: return false;
130: }
131: return painted;
132: }
133: }
134:
135: /**
136: * Waits until this canvas is shown for the first time. Proper operation
137: * relies on the caller to have arranged for this canvas to be shown, for
138: * example, with setCurrent(). Returns immediately if the canvas has been
139: * shown already, even if it has subsequently been hidden. Returns true if
140: * the canvas has ever been shown. Returns false if the wait was
141: * interrupted or if it timed out. This method must not be called on the
142: * event thread. If it is, it will block show processing and will
143: * eventually timeout.
144: */
145: public boolean awaitShow() {
146: long deadline = System.currentTimeMillis() + TIMEOUT;
147:
148: synchronized (this ) {
149: try {
150: while (!everShown
151: && System.currentTimeMillis() < deadline) {
152: wait(TIMEOUT);
153: }
154: } catch (InterruptedException ie) {
155: return false;
156: }
157: return everShown;
158: }
159: }
160:
161: /**
162: * Returns a boolean indicating whether showNotify has been called on this
163: * canvas more recently than hideNotify. This differs from the
164: * Displayable.isShown() method, which checks the internal state of the
165: * Displayable object.
166: */
167: public synchronized boolean showCalled() {
168: return shown;
169: }
170:
171: /**
172: * Returns a boolean indicating whether showNotify() has ever been called
173: * at any time since the canvas was created.
174: */
175: public synchronized boolean wasShown() {
176: return everShown;
177: }
178:
179: }
|