1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * ident "%Z%%M% %I% %E% SMI"
24 *
25 * Copyright (c) 1999-2000 by Sun Microsystems, Inc.
26 * All rights reserved.
27 */
28
29 import java.awt.*;
30 import java.awt.event.*;
31
32 /**
33 * Creates a panel with two buttons (+ and - side by side on it). The
34 * panel registers a DCListener with it that gets notified whenever
35 * these butons are clicked. <bold>The buttons may also be kept continously
36 * pressed for faster increments/decrements.</bold>
37 * <para>
38 * On a single click of the button, the listener is notified to
39 * increment/decrement itself by a small amount. When the button is kept
40 * pressed the following notifications are sent out for larger
41 * increments/decrements. (It is up to the listener to decide the
42 * increment/decrement corresponding to large/small.) Moreover, these
43 * notifications will be sent out much faster if the button is kept
44 * pressed.
45 */
46
47 // The panel waits for a period of BIG_SLEEP_TIME before the faster
48 // increments are sent out. They, in turn, are sent out after
49 // intervals of SMALL_SLEEP_TIME. Therfore, an instance of this class
50 // is associated with 2 timers - a longer one that starts off and then
51 // schedules the shorter one. The shorter one keeps scheduling itself
52 // every time it wakes up.
53
54 public class DCPanel extends Panel {
55
56 private Button plusButton;
57 private Button minusButton;
58
59 private DCListener listener = null;
60
61 private Timer bigTimer;
62 private Timer smallTimer;
63
64 private static int BIG_SLEEP_TIME = 1000;
65 private static int SMALL_SLEEP_TIME = 100;
66
67 private boolean incrementFlag;
68
69 public DCPanel() {
70
71 setLayout(new GridLayout(1, 2));
72
73 bigTimer = new BigTimer();
74 smallTimer = new SmallTimer();
75
76 bigTimer.start();
77 smallTimer.start();
78
79 plusButton = new DCButton("+");
80 minusButton = new DCButton("-");
81
82 add(plusButton);
83 add(minusButton);
84
85 }
86
87 /**
88 * Ensures that this component is not brought into focus by
89 * tabbing. This prevents the tab focus from moving in here instead
90 * of going to a text field.
91 * @return false always.
92 */
93 public boolean isFocusable() {
94 return false;
95 }
96
97 /**
98 * Sets the listener for this tab.
99 * @param listener the DCListener that needs to be notified when the
100 * buttons on this panel are pressed.
101 * @return the old listener
102 */
103 public DCListener setListener(DCListener listener) {
104 DCListener oldListener = this.listener;
105 this.listener = listener;
106 return oldListener;
107 }
108
109 /**
110 * Removes the listener when it no longer need to be notified.
111 * @return the old listener
112 */
113 public DCListener removeListener() {
114 return setListener(null);
115 }
116
117 /**
118 * Kicks the times into action. Is called when a button is pressed.
119 */
120 private void startAction() {
121 bigTimer.request();
122 }
123
124 /**
125 * Stops the timers. Is called when a button is released.
126 */
127 private void stopAction() {
128 smallTimer.cancel();
129 bigTimer.cancel();
130 }
131
132 /**
133 * Notifies the listener about whether to increment or decrement and
134 * by how much.
135 * @param bigFlag true if the listener needs to increment/decrement
136 * by a large amount, false otherwise.
137 */
138 private void informListener(boolean bigFlag) {
139 // System.out.println("DCPanel.informListener: " + bigFlag);
140
141 if (listener != null) {
142
143 if (bigFlag) {
144 // request a big change
145 if (incrementFlag)
146 listener.bigIncrement();
147 else
148 listener.bigDecrement();
149 } else {
150 // request a small change
151 if (incrementFlag)
152 listener.increment();
153 else
154 listener.decrement();
155 }
156
157 }
158
159 } // informListener
160
161
162 // ***********************************************
163 // I N N E R C L A S S E S F O L L O W
164 // ***********************************************
165
166 /**
167 * A timer class since java does not have one.
168 */
169 private abstract class Timer extends Thread {
170 private boolean running = false;
171
172 /**
173 * Sleeps till the timer's services are requested using wait() and
174 * notify(). Then it does its task and goes back to sleep. And
175 * loops forever like this.
176 */
177 public void run() {
178 while (true) {
179 try {
180 synchronized (this) {
181 running = false;
182 // Wait till the timer is required
183 wait();
184 running = true;
185 }
186 doTask();
187 } catch (InterruptedException e) {}
188 } // while loop
189 } // run method
190
191 protected void doTask() {} // bug in java workshop
192
193 /**
194 * Wakes up the timer.
195 */
196 public synchronized void request() {
197 notify();
198 }
199
200 /**
201 * Cancels the timer if it is running.
202 */
203 public void cancel() {
204 if (running) {
205 interrupt();
206 }
207 }
208
209 }// class Timer
210
211 /**
212 * The first stage of timer - is a longer timer. Wait to see if the
213 * user really wants to amek the increments/decrements go by fast.
214 */
215 private class BigTimer extends Timer {
216
217 /**
218 * Sleep for the long amount of time. Then inform the listener
219 * to have a bigIncrement/bigDecrement. After that, your job is
220 * done, schedule the smaller (faster) timer from this point on.
221 */
222 protected void doTask() {
223 try {
224 sleep(BIG_SLEEP_TIME);
225 informListener(true);
226 smallTimer.request();
227 } catch (InterruptedException e) {
228 informListener(false);
229 }
230 }
231
232 } // class BigTimer
233
234
235 /**
236 * The second stage of timers. This timer keeps rescheduling itself
237 * everytime it wakes up. In between this, it sends a notification
238 * to the listener to do a big Increment/Decrement.
239 */
240 private class SmallTimer extends Timer {
241
242 protected void doTask() {
243 try {
244 // loop forever and keep rescheduling yourself
245 while (true) {
246 sleep(SMALL_SLEEP_TIME);
247 informListener(true);
248 }
249 } catch (InterruptedException e) {}
250 } // doTask method
251
252 } // class SmallTimer
253
254 /**
255 * A mouse listener to detect when a button has been
256 * pressed/released. One instance of this is bound to the plus
257 * button and the other instance to the minus button.
258 */
259 private class DCMouseListener extends MouseAdapter {
260 private boolean plusOrMinus;
261
262 /**
263 * Constructor for DCMouseListener.
264 * @param plusOrMinus true if this is a listener for the plus
265 * button, false if it is for the minus button.
266 */
267 public DCMouseListener(boolean plusOrMinus) {
268 this.plusOrMinus = plusOrMinus;
269 }
270
271 /**
272 * Kicks in when the mouse is pressed.
273 */
274 public void mousePressed(MouseEvent e) {
275 incrementFlag = plusOrMinus;
276 DCPanel.this.startAction();
277 }
278
279 /**
280 * Kicks in when the mouse is released.
281 */
282 public void mouseReleased(MouseEvent e) {
283 incrementFlag = plusOrMinus;
284 DCPanel.this.stopAction();
285 }
286 }
287
288 /**
289 * The button used by this DCPanel.
290 */
291 private class DCButton extends Button {
292 public DCButton(String text) {
293 super(text);
294 if (text.equals("+"))
295 addMouseListener(new DCMouseListener(true));
296 else
297 addMouseListener(new DCMouseListener(false));
298 }
299
300 /**
301 * Make the button non-focus traversable so that it cannot be
302 * tabbed in to.
303 */
304 public boolean isFocusable() {
305 return false;
306 }
307
308 } // DCButton
309
310
311 /**
312 * Test method for DCPanel class to see appearance.
313 */
314 public static void main(String args[]) {
315 Frame f = new Frame("Testing DCPanel");
316 f.add(new DCPanel());
317 f.setBounds(new Rectangle(100, 100, 100, 100));
318 f.setVisible(true);
319 }
320
321 }