← Back to branch summary

~mortenoh/+junk/dhis2-detailed-import-export

« back to all changes in this revision

Viewing changes to gis/dhis-gis-geostat/mfbase/openlayers/tests/Handler.html

  • Committer: larshelge at gmail
  • Date: 2009-03-03 16:46:36 UTC
  • Revision ID: larshelge@gmail.com-20090303164636-2sjlrquo7ib1gf7r
Initial check-in

Show diffs side-by-side

added added

removed removed

Lines of Context:
gis/dhis-gis-geostat/mfbase/openlayers/tests/Handler.html
 
1
<html>
 
2
<head>
 
3
  <script src="../lib/OpenLayers.js"></script>
 
4
  <script type="text/javascript">
 
5
    function test_Handler_constructor(t) {
 
6
        t.plan(4);
 
7
        var map = new OpenLayers.Map('map');
 
8
        var control = new OpenLayers.Control();
 
9
        map.addControl(control);
 
10
    
 
11
        var callbacks = {foo: "bar"};
 
12
        var options = {bar: "foo"};
 
13
        var handler = new OpenLayers.Handler(control, callbacks, options);
 
14
        t.ok(handler instanceof OpenLayers.Handler,
 
15
             "new OpenLayers.Handler returns object");
 
16
        t.eq(handler.map.id, map.id,
 
17
             "constructing a handler with a map sets the map on the handler");
 
18
        t.eq(handler.callbacks.foo, callbacks.foo,
 
19
             "constructor correctly sets callbacks");
 
20
        t.eq(handler.bar, options.bar,
 
21
             "constructor correctly extends handler with options");
 
22
    }
 
23
    
 
24
    function test_Handler_activate(t) {
 
25
        t.plan(52);
 
26
        var map = new OpenLayers.Map('map');
 
27
        var control = new OpenLayers.Control();
 
28
        map.addControl(control);
 
29
    
 
30
        var events = ["mouseover", "mouseout", "mousedown",
 
31
                      "mouseup", "mousemove", "click",
 
32
                      "dblclick", "resize", "focus", "blur"];
 
33
 
 
34
        var handler = new OpenLayers.Handler(control);
 
35
        handler.active = true;
 
36
        var activated = handler.activate();
 
37
        t.ok(!activated,
 
38
             "activate returns false if the handler is already active");
 
39
 
 
40
        handler.active = false;
 
41
        map.events.registerPriority = function(type, obj, func) {
 
42
            var r = func();
 
43
            if(typeof r == "string") {
 
44
                // this is one of the mock handler methods
 
45
                t.ok(OpenLayers.Util.indexOf(events, type) > -1,
 
46
                     "activate calls registerPriority with browser event: " + type);
 
47
                t.eq(typeof func, "function",
 
48
                     "activate calls registerPriority with a function");
 
49
                t.eq(r, type,
 
50
                     "activate calls registerPriority with the correct method");
 
51
                t.eq(obj["CLASS_NAME"], "OpenLayers.Handler",
 
52
                     "activate calls registerPriority with the handler");
 
53
            } else {
 
54
                // this is the call with handler.setEvent as the func
 
55
                t.ok(r, "activate calls registerPriority with handler.setEvent");
 
56
            }
 
57
        }
 
58
        
 
59
        // set browser event like properties on the handler
 
60
        for(var i=0; i<events.length; ++i) {
 
61
            setMethod(events[i]);
 
62
        }
 
63
        function setMethod(key) {
 
64
            handler[key] = function() {return key};
 
65
        }
 
66
        activated = handler.activate();
 
67
        t.ok(activated,
 
68
             "activated returns true if the handler is not already active");
 
69
        
 
70
    }
 
71
    
 
72
    function test_Handler_deactivate(t) {
 
73
        t.plan(52);
 
74
        var map = new OpenLayers.Map('map', { controls: []});
 
75
        // No controls so that we don't get more thingies than we expect
 
76
        // when we actually clean up after ourselves: r5891 caused this
 
77
        // because we actually destroy things now on the navigation control. 
 
78
        var control = new OpenLayers.Control();
 
79
        map.addControl(control);
 
80
    
 
81
        var events = ["mouseover", "mouseout", "mousedown",
 
82
                      "mouseup", "mousemove", "click",
 
83
                      "dblclick", "resize", "focus", "blur"];
 
84
 
 
85
        var handler = new OpenLayers.Handler(control);
 
86
        handler.active = false;
 
87
        var deactivated = handler.deactivate();
 
88
        t.ok(!deactivated,
 
89
             "deactivate returns false if the handler is already deactive");
 
90
 
 
91
        handler.activate();
 
92
        map.events.unregister = function(type, obj, func) {
 
93
            var r = func();
 
94
            if(typeof r == "string") {
 
95
                // this is one of the mock handler methods
 
96
                t.ok(OpenLayers.Util.indexOf(events, type) > -1,
 
97
                     "deactivate calls unregister with browser event: " + type);
 
98
                t.eq(typeof func, "function",
 
99
                     "activate calls unregister with a function");
 
100
                t.eq(func(), type,
 
101
                     "activate calls unregister with the correct method");
 
102
                t.eq(obj["CLASS_NAME"], "OpenLayers.Handler",
 
103
                     "activate calls unregister with the handler");
 
104
            } else {
 
105
                // this is the call with handler.setEvent as the func
 
106
                t.ok(r, "activate calls registerPriority with handler.setEvent");
 
107
            }
 
108
        }
 
109
        
 
110
        // set browser event like properties on the handler
 
111
        for(var i=0; i<events.length; ++i) {
 
112
            // add in a closure for key
 
113
            (function(key) {
 
114
                handler[key] = function() {return key};
 
115
            })(events[i]);
 
116
        }
 
117
        deactivated = handler.deactivate();
 
118
        t.ok(deactivated,
 
119
             "deactivated returns true if the handler is already active");
 
120
        map.events.unregister = OpenLayers.Events.prototype.unregister;
 
121
        map.destroy();
 
122
        
 
123
    }
 
124
    
 
125
    function test_Handler_setEvent(t) {
 
126
        t.plan(4);
 
127
        var map = new OpenLayers.Map('map');
 
128
        var control = new OpenLayers.Control();
 
129
        map.addControl(control);
 
130
        var handler = new OpenLayers.Handler(control);
 
131
        handler.click = function(evt) {
 
132
        }
 
133
        handler.activate();
 
134
        var testEvent = {
 
135
            xy: new OpenLayers.Pixel(Math.random(), Math.random()),
 
136
            altKey: (Math.random() > 0.5),
 
137
            shiftKey: (Math.random() > 0.5),
 
138
            ctrlKey: (Math.random() > 0.5)
 
139
        }
 
140
        map.events.triggerEvent("click", testEvent);
 
141
        t.ok(handler.evt.xy.x == testEvent.xy.x &&
 
142
             handler.evt.xy.y == testEvent.xy.y,
 
143
             "handler.evt has proper xy object");
 
144
        t.eq(handler.evt.altKey, testEvent.altKey,
 
145
             "handler.evt.altKey correct");
 
146
        t.eq(handler.evt.shiftKey, testEvent.shiftKey,
 
147
             "handler.evt.shiftKey correct");
 
148
        t.eq(handler.evt.ctrlKey, testEvent.ctrlKey,
 
149
             "handler.evt.ctrlKey correct");
 
150
    }
 
151
    
 
152
    function test_Handler_destroy(t) {
 
153
        t.plan(5);
 
154
        var map = new OpenLayers.Map('map');
 
155
        var control = new OpenLayers.Control();
 
156
        map.addControl(control);
 
157
        var handler = new OpenLayers.Handler(control);
 
158
        var deactivated = false;
 
159
        handler.deactivate = function() {
 
160
            deactivated = true;
 
161
        };
 
162
        t.ok(handler.control,
 
163
             "handler has a control prior to destroy");
 
164
        t.ok(handler.map,
 
165
             "handler has a map prior to destroy");
 
166
        handler.destroy();
 
167
        t.eq(handler.control, null,
 
168
             "hanlder.control is null after destroy");
 
169
        t.eq(handler.map, null,
 
170
             "handler.map is null after destroy");
 
171
        t.ok(deactivated,
 
172
             "handler.deactivate is called by destroy");
 
173
    }
 
174
    
 
175
    function test_Handler_checkModifiers(t) {
 
176
        t.plan(26);
 
177
        var handler = new OpenLayers.Handler({});
 
178
        handler.keyMask = null;
 
179
        var proceed = handler.checkModifiers({});
 
180
        t.ok(proceed,
 
181
             "checkModifiers returns true if no keyMask on the handler");
 
182
        
 
183
        
 
184
        /**
 
185
         * Test checkModifiers for single keyMask values.  The method should
 
186
         *     return true if the corresponding key is associated with the
 
187
         *     event.  For example, if evt.shiftKey is true and handler.keyMask
 
188
         *     is OpenLayers.Handler.MOD_SHIFT, checkModifiers should return
 
189
         *     true.
 
190
         */
 
191
        var constants = {
 
192
            MOD_NONE: null,
 
193
            MOD_SHIFT: "shiftKey",
 
194
            MOD_CTRL: "ctrlKey",
 
195
            MOD_ALT: "altKey"
 
196
        }
 
197
        var proceed, evt, value, c, k;
 
198
        for(c in constants) {
 
199
            handler.keyMask = OpenLayers.Handler[c];
 
200
            // for this key mask, test all single key possibilities
 
201
            for(k in constants) {
 
202
                value = constants[k];
 
203
                evt = {};
 
204
                if(value) {
 
205
                    // mimic a key down on an event
 
206
                    evt[value] = true;
 
207
                }
 
208
                proceed = handler.checkModifiers(evt);
 
209
                // if k == c, proceed should be true - false otherwise
 
210
                t.eq(k == c, proceed,
 
211
                     "returns " + proceed + " if keyMask is " + c +
 
212
                     " and " + ((value) ? value : "no key") + " is down");
 
213
            }
 
214
        }
 
215
 
 
216
        /**
 
217
         * Test checkModifiers for double keyMask values.  The method should
 
218
         *     return true if the corresponding key combo is associated with the
 
219
         *     event.  For example, if evt.shiftKey is true and handler.keyMask
 
220
         *     is OpenLayers.Handler.MOD_SHIFT, checkModifiers should return
 
221
         *     true.
 
222
         */
 
223
        var constants = ["MOD_SHIFT", "MOD_CTRL", "MOD_ALT"];
 
224
        var keys = ["shiftKey", "ctrlKey", "altKey"];
 
225
        var proceed, evt, c1, c2, k1, k2;
 
226
        for(var i=0; i<constants.length-1; ++i) {
 
227
            c1 = constants[i];
 
228
            for(var j=i+1; j<constants.length; ++j) {
 
229
                c2 = constants[j];
 
230
                handler.keyMask = OpenLayers.Handler[c1] |
 
231
                                  OpenLayers.Handler[c2];
 
232
                // for this key mask, test all double key possibilities
 
233
                for(var x=0; x<keys.length-1; ++x) {
 
234
                    k1 = keys[x];
 
235
                    for(var y=x+1; y<keys.length; ++y) {
 
236
                        k2 = keys[y];
 
237
                        evt = {};
 
238
                        evt[k1] = true;
 
239
                        evt[k2] = true;
 
240
                        proceed = handler.checkModifiers(evt);
 
241
                        // if the combo matches, proceed should be true
 
242
                        // at this point we know that i != j and x != y
 
243
                        t.eq(((i == x) || (i == y)) &&
 
244
                             ((j == x) || (j == y)),
 
245
                             proceed,
 
246
                             "returns " + proceed + " if " + c1 + " | " + c2 +
 
247
                             " and " + k1 + " + " + k2 + " is down");
 
248
                    }
 
249
                }
 
250
            }
 
251
        }
 
252
            
 
253
    }
 
254
 
 
255
 
 
256
  </script>
 
257
</head>
 
258
<body>
 
259
    <div id="map" style="width: 1024px; height: 512px;"/>
 
260
</body>
 
261
</html>