Mercurial > projects > dwt-addons

comparison dwtx/jface/bindings/keys/SWTKeyLookup.d @ 16:e0f0aaf75edd

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
PopupDialog, bindings and actions
author Frank Benoit <benoit@tionex.de>
date Tue, 01 Apr 2008 08:00:31 +0200
parents
children da5ad8eedf5d
comparison
equal deleted inserted replaced
15:db8940420ed8 16:e0f0aaf75edd
1 /*******************************************************************************
2 * Copyright (c) 2005, 2006 IBM Corporation and others.
3 * All rights reserved. This program and the accompanying materials
4 * are made available under the terms of the Eclipse Public License v1.0
5 * which accompanies this distribution, and is available at
6 * http://www.eclipse.org/legal/epl-v10.html
7 *
8 * Contributors:
9 * IBM Corporation - initial API and implementation
10 * Port to the D programming language:
11 * Frank Benoit <benoit@tionex.de>
12 *******************************************************************************/
13 module dwtx.jface.bindings.keys.SWTKeyLookup;
14
15 import dwtx.jface.bindings.keys.IKeyLookup;
16
17 import tango.util.collection.HashMap;
18 import tango.util.collection.model.Map;
19
20 import dwt.DWT;
21 import dwtx.jface.util.Util;
22
23 import dwt.dwthelper.utils;
24 import dwt.dwthelper.Integer;
25
26 /**
27 * <p>
28 * A look-up table for the formal grammar for keys, and the integer values they
29 * represent. This look-up table is hard-coded to use DWT representations. By
30 * replacing this class (and
31 * {@link dwtx.jface.bindings.keys.SWTKeySupport}), you can remove the
32 * dependency on DWT.
33 * </p>
34 *
35 * @since 3.1
36 * @see dwtx.jface.bindings.keys.KeyLookupFactory
37 */
38 public final class SWTKeyLookup : IKeyLookup {
39
40 /**
41 * The look-up table for modifier keys. This is a map of formal name (<code>String</code>)
42 * to integer value (<code>Integer</code>).
43 */
44 private const Map!(String,Integer) modifierKeyTable;
45
46 /**
47 * The look-up table for formal names. This is a map of integer value (<code>Integer</code>)
48 * to formal name (<code>String</code>).
49 */
50 private const Map!(Integer,String) nameTable;
51
52 /**
53 * The look-up table for natural keys. This is a map of formal name (<code>String</code>)
54 * to integer value (<code>Integer</code>).
55 */
56 private const Map!(String,Integer) naturalKeyTable;
57
58 /**
59 * Constructs a new look-up class. This should only be done by the look-up
60 * factory.
61 *
62 * @see KeyLookupFactory
63 */
64 this() {
65 modifierKeyTable = new HashMap!(String,Integer);
66 nameTable = new HashMap!(Integer,String);
67 naturalKeyTable = new HashMap!(String,Integer);
68 Integer alt = new Integer(DWT.ALT);
69 Integer command = new Integer(DWT.COMMAND);
70 Integer ctrl = new Integer(DWT.CTRL);
71 Integer shift = new Integer(DWT.SHIFT);
72 modifierKeyTable.add(ALT_NAME, alt);
73 nameTable.add(alt, ALT_NAME);
74 modifierKeyTable.add(COMMAND_NAME, command);
75 nameTable.add(command, COMMAND_NAME);
76 modifierKeyTable.add(CTRL_NAME, ctrl);
77 nameTable.add(ctrl, CTRL_NAME);
78 modifierKeyTable.add(SHIFT_NAME, shift);
79 nameTable.add(shift, SHIFT_NAME);
80 modifierKeyTable.add(M1_NAME,
81 "carbon".equals(DWT.getPlatform()) ? command : ctrl); //$NON-NLS-1$
82 modifierKeyTable.add(M2_NAME, shift);
83 modifierKeyTable.add(M3_NAME, alt);
84 modifierKeyTable.add(M4_NAME, "carbon".equals(DWT.getPlatform()) ? ctrl //$NON-NLS-1$
85 : command);
86
87 Integer arrowDown = new Integer(DWT.ARROW_DOWN);
88 naturalKeyTable.add(ARROW_DOWN_NAME, arrowDown);
89 nameTable.add(arrowDown, ARROW_DOWN_NAME);
90 Integer arrowLeft = new Integer(DWT.ARROW_LEFT);
91 naturalKeyTable.add(ARROW_LEFT_NAME, arrowLeft);
92 nameTable.add(arrowLeft, ARROW_LEFT_NAME);
93 Integer arrowRight = new Integer(DWT.ARROW_RIGHT);
94 naturalKeyTable.add(ARROW_RIGHT_NAME, arrowRight);
95 nameTable.add(arrowRight, ARROW_RIGHT_NAME);
96 Integer arrowUp = new Integer(DWT.ARROW_UP);
97 naturalKeyTable.add(ARROW_UP_NAME, arrowUp);
98 nameTable.add(arrowUp, ARROW_UP_NAME);
99 Integer breakKey = new Integer(DWT.BREAK);
100 naturalKeyTable.add(BREAK_NAME, breakKey);
101 nameTable.add(breakKey, BREAK_NAME);
102 Integer bs = new Integer(DWT.BS);
103 naturalKeyTable.add(BS_NAME, bs);
104 nameTable.add(bs, BS_NAME);
105 naturalKeyTable.add(BACKSPACE_NAME, bs);
106 Integer capsLock = new Integer(DWT.CAPS_LOCK);
107 naturalKeyTable.add(CAPS_LOCK_NAME, capsLock);
108 nameTable.add(capsLock, CAPS_LOCK_NAME);
109 Integer cr = new Integer(DWT.CR);
110 naturalKeyTable.add(CR_NAME, cr);
111 nameTable.add(cr, CR_NAME);
112 naturalKeyTable.add(ENTER_NAME, cr);
113 naturalKeyTable.add(RETURN_NAME, cr);
114 Integer del = new Integer(DWT.DEL);
115 naturalKeyTable.add(DEL_NAME, del);
116 nameTable.add(del, DEL_NAME);
117 naturalKeyTable.add(DELETE_NAME, del);
118 Integer end = new Integer(DWT.END);
119 naturalKeyTable.add(END_NAME, end);
120 nameTable.add(end, END_NAME);
121 Integer esc = new Integer(DWT.ESC);
122 naturalKeyTable.add(ESC_NAME, esc);
123 nameTable.add(esc, ESC_NAME);
124 naturalKeyTable.add(ESCAPE_NAME, esc);
125 Integer f1 = new Integer(DWT.F1);
126 naturalKeyTable.add(F1_NAME, f1);
127 nameTable.add(f1, F1_NAME);
128 Integer f2 = new Integer(DWT.F2);
129 naturalKeyTable.add(F2_NAME, new Integer(DWT.F2));
130 nameTable.add(f2, F2_NAME);
131 Integer f3 = new Integer(DWT.F3);
132 naturalKeyTable.add(F3_NAME, new Integer(DWT.F3));
133 nameTable.add(f3, F3_NAME);
134 Integer f4 = new Integer(DWT.F4);
135 naturalKeyTable.add(F4_NAME, new Integer(DWT.F4));
136 nameTable.add(f4, F4_NAME);
137 Integer f5 = new Integer(DWT.F5);
138 naturalKeyTable.add(F5_NAME, new Integer(DWT.F5));
139 nameTable.add(f5, F5_NAME);
140 Integer f6 = new Integer(DWT.F6);
141 naturalKeyTable.add(F6_NAME, new Integer(DWT.F6));
142 nameTable.add(f6, F6_NAME);
143 Integer f7 = new Integer(DWT.F7);
144 naturalKeyTable.add(F7_NAME, new Integer(DWT.F7));
145 nameTable.add(f7, F7_NAME);
146 Integer f8 = new Integer(DWT.F8);
147 naturalKeyTable.add(F8_NAME, new Integer(DWT.F8));
148 nameTable.add(f8, F8_NAME);
149 Integer f9 = new Integer(DWT.F9);
150 naturalKeyTable.add(F9_NAME, new Integer(DWT.F9));
151 nameTable.add(f9, F9_NAME);
152 Integer f10 = new Integer(DWT.F10);
153 naturalKeyTable.add(F10_NAME, new Integer(DWT.F10));
154 nameTable.add(f10, F10_NAME);
155 Integer f11 = new Integer(DWT.F11);
156 naturalKeyTable.add(F11_NAME, new Integer(DWT.F11));
157 nameTable.add(f11, F11_NAME);
158 Integer f12 = new Integer(DWT.F12);
159 naturalKeyTable.add(F12_NAME, new Integer(DWT.F12));
160 nameTable.add(f12, F12_NAME);
161 Integer f13 = new Integer(DWT.F13);
162 naturalKeyTable.add(F13_NAME, new Integer(DWT.F13));
163 nameTable.add(f13, F13_NAME);
164 Integer f14 = new Integer(DWT.F14);
165 naturalKeyTable.add(F14_NAME, new Integer(DWT.F14));
166 nameTable.add(f14, F14_NAME);
167 Integer f15 = new Integer(DWT.F15);
168 naturalKeyTable.add(F15_NAME, new Integer(DWT.F15));
169 nameTable.add(f15, F15_NAME);
170 Integer ff = new Integer(12); // ASCII 0x0C
171 naturalKeyTable.add(FF_NAME, ff);
172 nameTable.add(ff, FF_NAME);
173 Integer home = new Integer(DWT.HOME);
174 naturalKeyTable.add(HOME_NAME, home);
175 nameTable.add(home, HOME_NAME);
176 Integer insert = new Integer(DWT.INSERT);
177 naturalKeyTable.add(INSERT_NAME, insert);
178 nameTable.add(insert, INSERT_NAME);
179 Integer lf = new Integer(DWT.LF);
180 naturalKeyTable.add(LF_NAME, lf);
181 nameTable.add(lf, LF_NAME);
182 Integer nul = new Integer(DWT.NULL);
183 naturalKeyTable.add(NUL_NAME, nul);
184 nameTable.add(nul, NUL_NAME);
185 Integer numLock = new Integer(DWT.NUM_LOCK);
186 naturalKeyTable.add(NUM_LOCK_NAME, numLock);
187 nameTable.add(numLock, NUM_LOCK_NAME);
188 Integer keypad0 = new Integer(DWT.KEYPAD_0);
189 naturalKeyTable.add(NUMPAD_0_NAME, keypad0);
190 nameTable.add(keypad0, NUMPAD_0_NAME);
191 Integer keypad1 = new Integer(DWT.KEYPAD_1);
192 naturalKeyTable.add(NUMPAD_1_NAME, keypad1);
193 nameTable.add(keypad1, NUMPAD_1_NAME);
194 Integer keypad2 = new Integer(DWT.KEYPAD_2);
195 naturalKeyTable.add(NUMPAD_2_NAME, keypad2);
196 nameTable.add(keypad2, NUMPAD_2_NAME);
197 Integer keypad3 = new Integer(DWT.KEYPAD_3);
198 naturalKeyTable.add(NUMPAD_3_NAME, keypad3);
199 nameTable.add(keypad3, NUMPAD_3_NAME);
200 Integer keypad4 = new Integer(DWT.KEYPAD_4);
201 naturalKeyTable.add(NUMPAD_4_NAME, keypad4);
202 nameTable.add(keypad4, NUMPAD_4_NAME);
203 Integer keypad5 = new Integer(DWT.KEYPAD_5);
204 naturalKeyTable.add(NUMPAD_5_NAME, keypad5);
205 nameTable.add(keypad5, NUMPAD_5_NAME);
206 Integer keypad6 = new Integer(DWT.KEYPAD_6);
207 naturalKeyTable.add(NUMPAD_6_NAME, keypad6);
208 nameTable.add(keypad6, NUMPAD_6_NAME);
209 Integer keypad7 = new Integer(DWT.KEYPAD_7);
210 naturalKeyTable.add(NUMPAD_7_NAME, keypad7);
211 nameTable.add(keypad7, NUMPAD_7_NAME);
212 Integer keypad8 = new Integer(DWT.KEYPAD_8);
213 naturalKeyTable.add(NUMPAD_8_NAME, keypad8);
214 nameTable.add(keypad8, NUMPAD_8_NAME);
215 Integer keypad9 = new Integer(DWT.KEYPAD_9);
216 naturalKeyTable.add(NUMPAD_9_NAME, keypad9);
217 nameTable.add(keypad9, NUMPAD_9_NAME);
218 Integer keypadAdd = new Integer(DWT.KEYPAD_ADD);
219 naturalKeyTable.add(NUMPAD_ADD_NAME, keypadAdd);
220 nameTable.add(keypadAdd, NUMPAD_ADD_NAME);
221 Integer keypadDecimal = new Integer(DWT.KEYPAD_DECIMAL);
222 naturalKeyTable.add(NUMPAD_DECIMAL_NAME, keypadDecimal);
223 nameTable.add(keypadDecimal, NUMPAD_DECIMAL_NAME);
224 Integer keypadDivide = new Integer(DWT.KEYPAD_DIVIDE);
225 naturalKeyTable.add(NUMPAD_DIVIDE_NAME, keypadDivide);
226 nameTable.add(keypadDivide, NUMPAD_DIVIDE_NAME);
227 Integer keypadCr = new Integer(DWT.KEYPAD_CR);
228 naturalKeyTable.add(NUMPAD_ENTER_NAME, keypadCr);
229 nameTable.add(keypadCr, NUMPAD_ENTER_NAME);
230 Integer keypadEqual = new Integer(DWT.KEYPAD_EQUAL);
231 naturalKeyTable.add(NUMPAD_EQUAL_NAME, keypadEqual);
232 nameTable.add(keypadEqual, NUMPAD_EQUAL_NAME);
233 Integer keypadMultiply = new Integer(DWT.KEYPAD_MULTIPLY);
234 naturalKeyTable.add(NUMPAD_MULTIPLY_NAME, keypadMultiply);
235 nameTable.add(keypadMultiply, NUMPAD_MULTIPLY_NAME);
236 Integer keypadSubtract = new Integer(DWT.KEYPAD_SUBTRACT);
237 naturalKeyTable.add(NUMPAD_SUBTRACT_NAME, keypadSubtract);
238 nameTable.add(keypadSubtract, NUMPAD_SUBTRACT_NAME);
239 Integer pageDown = new Integer(DWT.PAGE_DOWN);
240 naturalKeyTable.add(PAGE_DOWN_NAME, pageDown);
241 nameTable.add(pageDown, PAGE_DOWN_NAME);
242 Integer pageUp = new Integer(DWT.PAGE_UP);
243 naturalKeyTable.add(PAGE_UP_NAME, pageUp);
244 nameTable.add(pageUp, PAGE_UP_NAME);
245 Integer pause = new Integer(DWT.PAUSE);
246 naturalKeyTable.add(PAUSE_NAME, pause);
247 nameTable.add(pause, PAUSE_NAME);
248 Integer printScreen = new Integer(DWT.PRINT_SCREEN);
249 naturalKeyTable.add(PRINT_SCREEN_NAME, printScreen);
250 nameTable.add(printScreen, PRINT_SCREEN_NAME);
251 Integer scrollLock = new Integer(DWT.SCROLL_LOCK);
252 naturalKeyTable.add(SCROLL_LOCK_NAME, scrollLock);
253 nameTable.add(scrollLock, SCROLL_LOCK_NAME);
254 Integer space = new Integer(' ');
255 naturalKeyTable.add(SPACE_NAME, space);
256 nameTable.add(space, SPACE_NAME);
257 Integer tab = new Integer(DWT.TAB);
258 naturalKeyTable.add(TAB_NAME, tab);
259 nameTable.add(tab, TAB_NAME);
260 Integer vt = new Integer(11); // ASCII 0x0B
261 naturalKeyTable.add(VT_NAME, vt);
262 nameTable.add(vt, VT_NAME);
263 }
264
265 /*
266 * (non-Javadoc)
267 *
268 * @see dwtx.jface.bindings.keys.IKeyLookup#formalKeyLookup(java.lang.String)
269 *
270 */
271 public final int formalKeyLookup(String name) {
272 Object value = naturalKeyTable.get(name);
273 if (cast(Integer)value ) {
274 return (cast(Integer) value).intValue();
275 }
276
277 if (name.length > 0) {
278 throw new IllegalArgumentException("Unrecognized formal key name: " //$NON-NLS-1$
279 ~ name);
280 }
281
282 return name.charAt(0);
283 }
284
285 /*
286 * (non-Javadoc)
287 *
288 * @see dwtx.jface.bindings.keys.IKeyLookup#formalKeyLookupInteger(java.lang.String)
289 *
290 */
291 public final Integer formalKeyLookupInteger(String name) {
292 Object value = naturalKeyTable.get(name);
293 if (cast(Integer)value ) {
294 return cast(Integer) value;
295 }
296
297 return new Integer(name.charAt(0));
298 }
299
300 /*
301 * (non-Javadoc)
302 *
303 * @see dwtx.jface.bindings.keys.IKeyLookup#formalModifierLookup(java.lang.String)
304 *
305 */
306 public final int formalModifierLookup(String name) {
307 Object value = modifierKeyTable.get(name);
308 if (cast(Integer)value ) {
309 return (cast(Integer) value).intValue();
310 }
311
312 return 0;
313 }
314
315 /*
316 * (non-Javadoc)
317 *
318 * @see dwtx.jface.bindings.keys.IKeyLookup#formalNameLookup(int)
319 *
320 */
321 public final String formalNameLookup(int key) {
322 Integer keyObject = new Integer(key);
323 if (nameTable.containsKey(keyObject) ) {
324 return nameTable.get(keyObject);
325 }
326
327 return dcharToString( cast(dchar) key );
328 }
329
330 /*
331 * (non-Javadoc)
332 *
333 * @see dwtx.jface.bindings.keys.IKeyLookup#getAlt()
334 *
335 */
336 public final int getAlt() {
337 return DWT.ALT;
338 }
339
340 /*
341 * (non-Javadoc)
342 *
343 * @see dwtx.jface.bindings.keys.IKeyLookup#getCommand()
344 *
345 */
346 public final int getCommand() {
347 return DWT.COMMAND;
348 }
349
350 /*
351 * (non-Javadoc)
352 *
353 * @see dwtx.jface.bindings.keys.IKeyLookup#getCtrl()
354 *
355 */
356 public final int getCtrl() {
357 return DWT.CTRL;
358 }
359
360 /*
361 * (non-Javadoc)
362 *
363 * @see dwtx.jface.bindings.keys.IKeyLookup#getShift()
364 *
365 */
366 public final int getShift() {
367 return DWT.SHIFT;
368 }
369
370 /*
371 * (non-Javadoc)
372 *
373 * @see dwtx.jface.bindings.keys.IKeyLookup#isModifierKey(int)
374 *
375 */
376 public final bool isModifierKey(int key) {
377 return ((key & DWT.MODIFIER_MASK) !is 0);
378 }
379 }