Source code: com/voytechs/html/event/HtmlDispatcher.java
1 /*
2 * File: HtmlDispatcher.java
3 * Auth: Mark Bednarczyk
4 * Date: DATE
5 * Id: $Id: HtmlDispatcher.java,v 1.1.1.1 2002/01/23 23:52:46 voytechs Exp $
6 ********************************************
7 * $Log: HtmlDispatcher.java,v $
8 * Revision 1.1.1.1 2002/01/23 23:52:46 voytechs
9 * Initial public release, BETA 1.0 - voytechs
10 *
11 */
12 package com.voytechs.html.event;
13
14 import com.voytechs.html.util.LogFacility;
15 import com.voytechs.html.event.*;
16
17 import java.lang.*;
18 import java.util.*;
19
20 /**
21 *
22 */
23 public class HtmlDispatcher
24 extends Dispatcher {
25 /* Internal attributes */
26
27 public static final int EVENT_SUBMIT_MASK = 0x0001;
28 public static final int EVENT_PASSWORD_MASK = 0x0002;
29 public static final int EVENT_TEXTAREA_MASK = 0x0004;
30 public static final int EVENT_TEXTFIELD_MASK = 0x0008;
31 public static final int EVENT_LIST_MASK = 0x0010;
32 public static final int EVENT_CHECKED_MASK = 0x0020;
33 public static final int EVENT_RADIO_MASK = 0x0040;
34 public static final int EVENT_HIDDEN_MASK = 0x0080;
35 public static final int EVENT_LINK_MASK = 0x0100;
36 public static final int EVENT_DEFAULT_MASK = 0x8000;
37
38 private Hashtable eventTypeStrings = new Hashtable();
39 private Hashtable eventTypeIDs = new Hashtable();
40
41 /**
42 *
43 * @param
44 * @exception
45 */
46 public HtmlDispatcher() {
47 super();
48 init();
49 }
50
51 /**
52 * Initialize the various HTML related event types that we
53 * support. <BR>
54 * <UL>
55 * <LI> Submit button press
56 * <LI> Reset button press
57 * <LI> Text area
58 * <LI> Text field
59 * <LI> List box
60 * <LI> Check boxes
61 * <LI> Radio boxes
62 * <LI> Hidden input field (way of passing hidden info)
63 * <LI> Link - Hypertext link
64 * <LI> Default parameters which are none of the above
65 */
66 private void init() {
67
68 registerEventType(EVENT_SUBMIT_MASK, 's');
69 registerEventType(EVENT_PASSWORD_MASK, 'p');
70 registerEventType(EVENT_TEXTAREA_MASK, 'x');
71 registerEventType(EVENT_TEXTFIELD_MASK, 'f');
72 registerEventType(EVENT_LIST_MASK, 'l');
73 registerEventType(EVENT_CHECKED_MASK, 'c');
74 registerEventType(EVENT_RADIO_MASK, 'r');
75 registerEventType(EVENT_HIDDEN_MASK, 'h');
76 registerEventType(EVENT_LINK_MASK, 'a');
77 registerEventType(EVENT_DEFAULT_MASK, 'd');
78 }
79
80 /**
81 * Register/create a new event type so it can be known and encoded.
82 * @param eventType Event type ID
83 * @param eventAbr Character abreviation used in the encoding of the String ID for HTML elements
84 * to represent the type of event type. ie s = submit, p = password, ...
85 */
86 protected void registerEventType(int eventType, char eventAbr) {
87 super.registerEventType(eventType);
88
89 eventTypeStrings.put(new Integer(eventType), new Character(eventAbr));
90 eventTypeIDs.put(new Character(eventAbr), new Integer(eventType));
91 }
92
93 /**
94 * Scan source object in form of Properties.
95 * @param source Is immediately cast to Properties object for retrieval of
96 * paramaters which are interpreted and appropriately dispatched when present.
97 */
98 public void scanEvent(Object source)
99 throws EventException {
100
101 LogFacility.log.println("HtmlDispatcher::scanEvent() - ENTERING");
102
103 Hashtable ht = (Hashtable)source;
104
105 HtmlEvent event = null;
106 Enumeration names = ht.keys();
107 while(names.hasMoreElements()) {
108 String name = (String)names.nextElement();
109 LogFacility.log.println("HtmlDispatcher::scanEvent processing param=" +name);
110
111 if( (event = decodeParam(name, (String [])ht.get(name))) != null)
112 super.handleEvent(event);
113 }
114 LogFacility.log.println("HtmlDispatcher::scanEvent() hashtable=" + ht);
115
116 LogFacility.log.println("HtmlDispatcher::scanEvent() - EXITING");
117 }
118
119 /**
120 * Dispatches event to a proper listener.
121 */
122 protected void dispatchEvent(ListenerIf listener, Event event, Object data)
123 throws EventException {
124 LogFacility.log.println("HtmlDispatcher::dispatchEvent dispatching event=" +event);
125
126 switch(event.getType()) {
127 case EVENT_PASSWORD_MASK:
128 case EVENT_TEXTAREA_MASK:
129 case EVENT_TEXTFIELD_MASK:
130 case EVENT_LIST_MASK:
131 case EVENT_RADIO_MASK:
132 case EVENT_HIDDEN_MASK:
133 TextListenerIf tl = (TextListenerIf)listener;
134 tl.processEvent((HtmlTextEvent)event, data);
135 break;
136
137 case EVENT_SUBMIT_MASK:
138 ButtonListenerIf bl = (ButtonListenerIf)listener;
139 bl.processEvent((HtmlButtonEvent)event, data);
140 break;
141
142 case EVENT_LINK_MASK:
143 LinkListenerIf ll = (LinkListenerIf)listener;
144 ll.processEvent((HtmlLinkEvent)event, data);
145 break;
146
147 case EVENT_CHECKED_MASK:
148
149
150 case EVENT_DEFAULT_MASK:
151 default:
152 throw new EventException("Unrecognized event; type=" + event.getType() + ", id=" + event.getId());
153
154 }
155 }
156
157 /**
158 * decode an encoded parameter from Properties object. In essence
159 * a <INPUT TYPE=SUBMIT NAME='param'> where param is a specially encoded, uniq
160 * string which encodes information as to the type of the object. These are mapped
161 * a uniq integer ID which the dispatcher uses to hash entries for.
162 * <BR>
163 * Encoding is as follows: [type]_[id]<BR>
164 * where type is a one letter string representing the type of element on the form and
165 * id is uniq integer ID associated with that instance of the form element.
166 */
167 protected HtmlEvent decodeParam(String param, String [] value) throws EventException {
168
169 LogFacility.log.println("HtmlDispatcher::decodeParam(" + param + ")");
170
171 StringBuffer sb = new StringBuffer(param);
172
173 if( sb.charAt(1) != '_')
174 return(null);
175
176 Character c = new Character(sb.charAt(0));
177 Integer i = (Integer)eventTypeIDs.get(c);
178 if(i == null) {
179 throw new EventException("EventType not registered; eventType=" + c + " eventTypeId=" + i);
180 }
181 int type = ((Integer)eventTypeIDs.get(c)).intValue();
182
183 if(isEventEnabled(type) == false)
184 return(null);
185
186 String idString = param.substring(2);
187 int id = Integer.parseInt(idString);
188 String v = null;
189 if(value.length >= 1)
190 v = value[0];
191
192 HtmlEvent event = null;
193 switch(type) {
194 case EVENT_PASSWORD_MASK:
195 case EVENT_TEXTAREA_MASK:
196 case EVENT_TEXTFIELD_MASK:
197 case EVENT_LIST_MASK:
198 case EVENT_RADIO_MASK:
199 case EVENT_HIDDEN_MASK:
200 event = new HtmlTextEvent(type, id, v);
201 break;
202
203 case EVENT_CHECKED_MASK:
204 event = new HtmlCheckedEvent(type, id, v);
205 break;
206
207 case EVENT_SUBMIT_MASK:
208 event = new HtmlButtonEvent(type, id, v);
209 break;
210
211 case EVENT_LINK_MASK:
212 event = new HtmlLinkEvent(type, id, v);
213 break;
214
215 case EVENT_DEFAULT_MASK:
216 event = new HtmlDefaultEvent(type, id, v);
217 break;
218
219 }
220
221 LogFacility.log.println("HtmlDispatcher::decodeParam(" + param + ")=" + event.toString());
222
223 return(event);
224 }
225
226 /**
227 * decode an encoded parameter from Properties object. In essence
228 * a <INPUT TYPE=SUBMIT NAME='param'> where param is a specially encoded, uniq
229 * string which encodes information as to the type of the object. These are mapped
230 * a uniq integer ID which the dispatcher uses to hash entries for.
231 * <BR>
232 * Encoding is as follows: [type]_[id]<BR>
233 * where type is a one letter string representing the type of element on the form and
234 * id is uniq integer ID associated with that instance of the form element.
235 */
236 protected String encodeParam(int eventType, int id) throws EventException {
237
238 Character eventAbr = null;
239
240 if( (eventAbr = (Character)eventTypeStrings.get(new Integer(eventType))) == null) {
241 throw new EventException("Unregistered eventType; eventType=" + eventType);
242 }
243
244 String s = "";
245 s += eventAbr;
246 s += "_";
247 s += id;
248
249 return(s);
250 }
251
252 /**
253 * Generate a uniq name based on event type and id.
254 */
255 public String generateUniqName(int eventType, int id) throws EventException {
256 return(encodeParam(eventType, id));
257 }
258
259 /**
260 * Test function for HtmlDispatcher
261 * @param args command line arguments
262 */
263 public static void main(String [] args) {
264
265 try {
266 HtmlDispatcher hd = new HtmlDispatcher();
267 String encoded = hd.encodeParam(HtmlDispatcher.EVENT_HIDDEN_MASK, 0x112);
268
269 System.out.println(encoded);
270 System.out.println(hd.decodeParam(encoded, new String []{}));
271 }
272 catch(EventException ee) {
273 System.err.println(ee);
274 System.exit(1);
275 }
276 }
277
278 } /* END OF: HtmlDispatcher */