|
1
25 package org.ofbiz.pos.adaptor;
26
27 import java.awt.Component  ;
28 import java.awt.Container ;
29 import java.awt.event.KeyEvent ;
30 import java.awt.event.KeyListener ;
31 import java.util.Iterator ;
32 import java.util.LinkedList ;
33 import java.util.List ;
34 import java.util.Map ;
35
36 import org.ofbiz.base.util.Debug;
37
38 import org.apache.commons.collections.map.LinkedMap;
39
40
41
48 public class KeyboardAdaptor {
49
50 public static final String module = KeyboardAdaptor.class.getName();
51
52 public static final int EVENT_RELEASED = 2;
53 public static final int EVENT_PRESSED = 1;
54 public static final int EVENT_TYPED = 3;
55
56 public static final int KEYBOARD_DATA = 100;
57 public static final int SCANNER_DATA = 101;
58 public static final int MSR_DATA = 102;
59 public static final int ALL_DATA = 999;
60
61 protected static List loadedComponents = new LinkedList ();
62 protected static Map receivers = new LinkedMap();
63 protected static KeyboardAdaptor adaptor = null;
64 protected static boolean running = true;
65
66 protected KeyboardListener listener = null;
67
68 public static KeyboardAdaptor getInstance(KeyboardReceiver receiver, int dataType) {
69 if (adaptor == null) {
70 synchronized(KeyboardAdaptor.class) {
71 if (adaptor == null) {
72 adaptor = new KeyboardAdaptor();
73 }
74 }
75 }
76
77 if (receiver != null && dataType > -1) {
78 receivers.put(receiver, new Integer (dataType));
79 }
80 return adaptor;
81 }
82
83 public static KeyboardAdaptor getInstance() {
84 return getInstance(null, -1);
85 }
86
87 public static void attachComponents(Component [] coms, boolean recurse) {
88 if (adaptor == null) {
90 KeyboardAdaptor.getInstance();
91 }
92
93 if (adaptor != null && coms != null) {
95 adaptor.addComponents(coms, recurse);
96 }
97 }
98
99 public static void attachComponents(Component [] coms) {
100 KeyboardAdaptor.attachComponents(coms, true);
101 }
102
103 public static void attachComponents(Container parent, boolean recurse) {
104 KeyboardAdaptor.attachComponents(new Component [] { parent }, recurse);
105 }
106
107 public static void attachComponents(Container parent) {
108 KeyboardAdaptor.attachComponents(parent, true);
109 }
110
111 public static void stop() {
112 running = false;
113 }
114
115 private KeyboardAdaptor() {
116 this.listener = new KeyboardListener();
117 this.listener.setDaemon(false);
118 this.listener.setName(listener.toString());
119 this.listener.start();
120 KeyboardAdaptor.adaptor = this;
121 }
122
123 private void addComponents(Component [] coms, boolean recurse) {
124 listener.reader.configureComponents(coms, recurse);
125 }
126
127 private class KeyboardListener extends Thread {
128
129 private static final long MAX_WAIT = 100;
130 private List keyCodeData = new LinkedList ();
131 private List keyCharData = new LinkedList ();
132 private long lastKey = -1;
133 private KeyReader reader = null;
134
135 public KeyboardListener() {
136 this.reader = new KeyReader(this);
137 }
138
139 private int checkDataType(char[] chars) {
140 if (chars.length == 0) {
141 return KEYBOARD_DATA;
143 } else if (((int) chars[0]) == 2 && ((int) chars[chars.length - 1]) == 10) {
144 return SCANNER_DATA;
146 } else if (((int) chars[0]) == 37 && ((int) chars[chars.length - 1]) == 10) {
147 return MSR_DATA;
149 } else {
150 return KEYBOARD_DATA;
152 }
153 }
154
155 protected synchronized void receiveCode(int keycode) {
156 keyCodeData.add(new Integer (keycode));
157 }
158
159 protected synchronized void receiveChar(char keychar) {
160 keyCharData.add(new Character (keychar));
161 }
162
163 protected synchronized void sendData() {
164 if (KeyboardAdaptor.receivers.size() > 0) {
165 if (keyCharData.size() > 0 || keyCodeData.size() > 0) {
166 char[] chars = new char[keyCharData.size()];
167 int[] codes = new int[keyCodeData.size()];
168
169 for (int i = 0; i < codes.length; i++) {
170 Integer itg = (Integer ) keyCodeData.get(i);
171 codes[i] = itg.intValue();
172 }
173
174 for (int i = 0; i < chars.length; i++) {
175 Character ch = (Character ) keyCharData.get(i);
176 chars[i] = ch.charValue();
177 }
178
179 Iterator ri = KeyboardAdaptor.receivers.keySet().iterator();
180 while (ri.hasNext()) {
181 KeyboardReceiver receiver = (KeyboardReceiver) ri.next();
182 int receiverType = ((Integer ) receivers.get(receiver)).intValue();
183 int thisDataType = this.checkDataType(chars);
184 if (receiverType == ALL_DATA || receiverType == thisDataType) {
185 receiver.receiveData(codes, chars);
186 }
187 }
188
189 keyCharData = new LinkedList ();
190 keyCodeData = new LinkedList ();
191 lastKey = -1;
192 }
193 } else {
194 Debug.logWarning("No receivers configured for key input", module);
195 }
196 }
197
198 protected synchronized void sendEvent(int eventType, KeyEvent event) {
199 lastKey = System.currentTimeMillis();
200 if (KeyboardAdaptor.receivers.size() > 0) {
201 Iterator ri = KeyboardAdaptor.receivers.keySet().iterator();
202 while (ri.hasNext()) {
203 KeyboardReceiver receiver = (KeyboardReceiver) ri.next();
204 if (receiver instanceof KeyListener ) {
205 switch (eventType) {
206 case 1:
207 ((KeyListener ) receiver).keyPressed(event);
208 break;
209 case 2:
210 ((KeyListener ) receiver).keyTyped(event);
211 break;
212 case 3:
213 ((KeyListener ) receiver).keyReleased(event);
214 break;
215 default:
216 break;
217 }
218 }
219 }
220 }
221 }
222
223 public void run() {
224 while (running) {
225 long now = System.currentTimeMillis();
226 if ((lastKey > -1) && (now - lastKey) >= MAX_WAIT) {
227 this.sendData();
228 }
229
230 if (!running) {
231 break;
232 } else {
233 try {
234 Thread.sleep(MAX_WAIT);
235 } catch (InterruptedException e) {
236 }
237 }
238 }
239 }
240 }
241
242 class KeyReader implements KeyListener {
243
244 private KeyboardListener k;
245
246 public KeyReader(KeyboardListener k) {
247 this.k = k;
248 }
249
250 private void configureComponents(Component [] coms, boolean recurse) {
251 for (int i = 0; i < coms.length; i++) {
252 if (!loadedComponents.contains(coms[i])) {
253 coms[i].addKeyListener(this);
254 Debug.logInfo("Added [" + coms[i].getName() + "] to KeyboardAdaptor", module);
255 }
256 if (recurse && coms[i] instanceof Container ) {
257 Component [] nextComs = ((Container ) coms[i]).getComponents();
258 configureComponents(nextComs, true);
259 }
260 }
261 }
262
263 public void keyTyped(KeyEvent e) {
264 k.receiveChar(e.getKeyChar());
265 k.sendEvent(EVENT_TYPED, e);
266 }
267
268 public void keyPressed(KeyEvent e) {
269 k.receiveCode(e.getKeyCode());
270 k.sendEvent(EVENT_PRESSED, e);
271 }
272
273 public void keyReleased(KeyEvent e) {
274 k.sendEvent(EVENT_RELEASED, e);
275 }
276 }
277 }
278 |
Popular Tags |
Java API By Example, From Geeks To Geeks.