Mercurial > projects > dwt-linux

comparison dwt/widgets/EventTable.d @ 54:8f049b136add

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
first example working
author Frank Benoit <benoit@tionex.de>
date Fri, 11 Jan 2008 14:31:37 +0100
parents 10acbb123580
children 8cec8f536af3
comparison
equal deleted inserted replaced
53:3da31bec7de0 54:8f049b136add
10 *******************************************************************************/ 10 *******************************************************************************/
11 module dwt.widgets.EventTable; 11 module dwt.widgets.EventTable;
12 12
13 import dwt.widgets.Listener; 13 import dwt.widgets.Listener;
14 import dwt.widgets.Event; 14 import dwt.widgets.Event;
15 import dwt.widgets.Listener;
16 import dwt.widgets.TypedListener;
17 import dwt.internal.SWTEventListener;
18 import dwt.dwthelper.System;
19 import dwt.SWT;
15 import dwt.internal.SWTEventListener; 20 import dwt.internal.SWTEventListener;
16 21
22 /+
17 class EventTable{ 23 class EventTable{
18 public void hook (int eventType, Listener listener) {} 24 public void hook (int eventType, Listener listener) {
19 public void sendEvent (Event event) ; 25 }
20 public bool hooks (int eventType) ; 26 public void sendEvent (Event event) {}
21 public void unhook (int eventType, Listener listener) ; 27 public bool hooks (int eventType) { return false; }
22 public void unhook (int eventType, SWTEventListener listener) ; 28 public void unhook (int eventType, Listener listener) {}
23 public int size () ; 29 public void unhook (int eventType, SWTEventListener listener) {}
30 public int size () { return 0;}
24 } 31 }
32 +/
25 33
26 /+++
27 import dwt.*;
28 import dwt.internal.SWTEventListener;
29 34
30 /** 35 /**
31 * Instances of this class implement a simple 36 * Instances of this class implement a simple
32 * look up mechanism that maps an event type 37 * look up mechanism that maps an event type
33 * to a listener. Multiple listeners for the 38 * to a listener. Multiple listeners for the
38 int [] types; 43 int [] types;
39 Listener [] listeners; 44 Listener [] listeners;
40 int level; 45 int level;
41 46
42 public void hook (int eventType, Listener listener) { 47 public void hook (int eventType, Listener listener) {
43 if (types == null) types = new int [4]; 48 if (types is null) types = new int [4];
44 if (listeners == null) listeners = new Listener [4]; 49 if (listeners is null) listeners = new Listener [4];
45 int length = types.length, index = length - 1; 50 int length = types.length, index = length - 1;
46 while (index >= 0) { 51 while (index >= 0) {
47 if (types [index] != 0) break; 52 if (types [index] !is 0) break;
48 --index; 53 --index;
49 } 54 }
50 index++; 55 index++;
51 if (index == length) { 56 if (index is length) {
52 int [] newTypes = new int [length + 4]; 57 int [] newTypes = new int [length + 4];
53 System.arraycopy (types, 0, newTypes, 0, length); 58 System.arraycopy (types, 0, newTypes, 0, length);
54 types = newTypes; 59 types = newTypes;
55 Listener [] newListeners = new Listener [length + 4]; 60 Listener [] newListeners = new Listener [length + 4];
56 System.arraycopy (listeners, 0, newListeners, 0, length); 61 SimpleType!(Listener).arraycopy (listeners, 0, newListeners, 0, length);
57 listeners = newListeners; 62 listeners = newListeners;
58 } 63 }
59 types [index] = eventType; 64 types [index] = eventType;
60 listeners [index] = listener; 65 listeners [index] = listener;
61 } 66 }
62 67
63 public boolean hooks (int eventType) { 68 public bool hooks (int eventType) {
64 if (types == null) return false; 69 if (types is null) return false;
65 for (int i=0; i<types.length; i++) { 70 for (int i=0; i<types.length; i++) {
66 if (types [i] == eventType) return true; 71 if (types [i] is eventType) return true;
67 } 72 }
68 return false; 73 return false;
69 } 74 }
70 75
71 public void sendEvent (Event event) { 76 public void sendEvent (Event event) {
72 if (types == null) return; 77 if (types is null) return;
73 level += level >= 0 ? 1 : -1; 78 level += level >= 0 ? 1 : -1;
74 try { 79 try {
75 for (int i=0; i<types.length; i++) { 80 for (int i=0; i<types.length; i++) {
76 if (event.type == SWT.None) return; 81 if (event.type is SWT.None) return;
77 if (types [i] == event.type) { 82 if (types [i] is event.type) {
78 Listener listener = listeners [i]; 83 Listener listener = listeners [i];
79 if (listener != null) listener.handleEvent (event); 84 if (listener !is null) listener.handleEvent (event);
80 } 85 }
81 } 86 }
82 } finally { 87 } finally {
83 boolean compact = level < 0; 88 bool compact = level < 0;
84 level -= level >= 0 ? 1 : -1; 89 level -= level >= 0 ? 1 : -1;
85 if (compact && level == 0) { 90 if (compact && level is 0) {
86 int index = 0; 91 int index = 0;
87 for (int i=0; i<types.length; i++) { 92 for (int i=0; i<types.length; i++) {
88 if (types [i] != 0) { 93 if (types [i] !is 0) {
89 types [index] = types [i]; 94 types [index] = types [i];
90 listeners [index] = listeners [i]; 95 listeners [index] = listeners [i];
91 index++; 96 index++;
92 } 97 }
93 } 98 }
98 } 103 }
99 } 104 }
100 } 105 }
101 106
102 public int size () { 107 public int size () {
103 if (types == null) return 0; 108 if (types is null) return 0;
104 int count = 0; 109 int count = 0;
105 for (int i=0; i<types.length; i++) { 110 for (int i=0; i<types.length; i++) {
106 if (types [i] != 0) count++; 111 if (types [i] !is 0) count++;
107 } 112 }
108 return count; 113 return count;
109 } 114 }
110 115
111 void remove (int index) { 116 void remove (int index) {
112 if (level == 0) { 117 if (level is 0) {
113 int end = types.length - 1; 118 int end = types.length - 1;
114 System.arraycopy (types, index + 1, types, index, end - index); 119 System.arraycopy (types, index + 1, types, index, end - index);
115 System.arraycopy (listeners, index + 1, listeners, index, end - index); 120 SimpleType!(Listener).arraycopy (listeners, index + 1, listeners, index, end - index);
116 index = end; 121 index = end;
117 } else { 122 } else {
118 if (level > 0) level = -level; 123 if (level > 0) level = -level;
119 } 124 }
120 types [index] = 0; 125 types [index] = 0;
121 listeners [index] = null; 126 listeners [index] = null;
122 } 127 }
123 128
124 public void unhook (int eventType, Listener listener) { 129 public void unhook (int eventType, Listener listener) {
125 if (types == null) return; 130 if (types is null) return;
126 for (int i=0; i<types.length; i++) { 131 for (int i=0; i<types.length; i++) {
127 if (types [i] == eventType && listeners [i] == listener) { 132 if (types [i] is eventType && listeners [i] is listener) {
128 remove (i); 133 remove (i);
129 return; 134 return;
130 } 135 }
131 } 136 }
132 } 137 }
133 138
134 public void unhook (int eventType, SWTEventListener listener) { 139 public void unhook (int eventType, SWTEventListener listener) {
135 if (types == null) return; 140 if (types is null) return;
136 for (int i=0; i<types.length; i++) { 141 for (int i=0; i<types.length; i++) {
137 if (types [i] == eventType) { 142 if (types [i] is eventType) {
138 if (listeners [i] instanceof TypedListener) { 143 if ( auto typedListener = cast(TypedListener) listeners [i] ) {
139 TypedListener typedListener = (TypedListener) listeners [i]; 144 if (typedListener.getEventListener () is listener) {
140 if (typedListener.getEventListener () == listener) {
141 remove (i); 145 remove (i);
142 return; 146 return;
143 } 147 }
144 } 148 }
145 } 149 }
146 } 150 }
147 } 151 }
148 152
149 } 153 }
150 +++/