https://www.landscape.ac.uk/WebResource.axd?d=Rp19xwWexf5mz5egpJ4I…&t=639039891111179092&build=171154

1
2if ((typeof(window.CCN) == 'undefined') || (!window.CCN))
3{
4    window.CCN = {};
5    window.CCN.RegisterObject = function(obj){
6        if (typeof(this._Objects) == 'undefined')
7        {
8            this._Objects = [];
9        }
10        this._Objects.Add(obj);
11    }
12    window.CCN.RegisterElement = function(el){
13        if (typeof(this._Elements) == 'undefined')
14        {
15            this._Elements = [];
16        }
17        this._Elements.Add(el);
18    }
19    window.CCN.RegisterExtension = function(el, funcName){
20        if (typeof(el._extensions) == 'undefined')
21        {
22            el._extensions = [];
23        }
24        el._extensions.Add(funcName);
25    }
26    window.CCN.OnDispose = function(){
27        window.CCN.Dispose();
28    }
29    window.CCN.Dispose = function() {
30        if (typeof(this._Objects) != 'undefined')
31        {
32            if (this._Objects)
33            {
34                for (var i=0; i<this._Objects.length; i++)
35                {
36                    this._Objects[i].Dispose();
37                    this._Objects[i] = null;
38                }
39                this._Objects.Clear();                
40            }
41        }
42        if (typeof(this._Elements) != 'undefined')
43        {
44            if (this._Elements)
45            {
46                for (var i=0; i<this._Elements.length; i++)
47                {
48                    var el = this._Elements[i];
49                    if (el._extensions)
50                    {
51                        for (var k=0; k<el._extensions.length; k++)
52                        {
53                            var funcName = el._extensions[k];
54                            el[funcName] = null;
55                            el._extensions[k] = null;                
56                        }
57                        el._extensions = null;
58                    }
59                    this._Elements[i] = null;
60                }  
61                this._Elements.Clear();              
62            }
63        }  
64        // remove unload handler 
65        if (window.removeEventListener) 
66        {
67            window.removeEventListener('unload', window.CCN.OnDispose, false);            
68        }
69        else if (window.detachEvent) 
70        {
71            window.detachEvent('onunload', window.CCN.OnDispose);            
72        }         
73    }
74    if (window.addEventListener) 
75    {
76        window.addEventListener('unload', window.CCN.OnDispose, false);			
77	} 
78	else if (window.attachEvent) 
79	{
80	    window.attachEvent('onunload', window.CCN.OnDispose);
81	} 
82}
83
84function Base()
85{
86    window.CCN.RegisterObject(this);
87    this._Disposed = false;
88    this._HandledElements = [];
89    this._HTMLElements = [];
90}
91
92Base.prototype.Dispose = function(){
93    if (this._Disposed) { return; }
94    this._Disposed = true;
95    for (var i=0; i<this._HandledElements.length; i++)    
96    {
97        var el = this._HandledElements[i];
98        if (el._events)
99        {
100            for (var k=0; k<el._events.length; k++)
101            {
102                var ev = el._events[k];
103                this.RemoveHandler(el, ev.eventName);
104                el._events[k] = null;                
105            }
106            el._events = null;
107        }        
108        this._HandledElements[i] = null;
109    }
110    for (var i=0; i<this._HTMLElements.length; i++)    
111    {
112        var propertyName = this._HTMLElements[i];
113        if (typeof(this[propertyName]) != 'undefined')
114        {
115            delete this[propertyName];
116        }        
117    }
118}
119
120Base.prototype.RegisterHTMLElement = function(propertyName) {
121    this._HTMLElements.Add(propertyName);
122}
123
124Base.prototype.CreateDelegate = function(instance, method) 
125{
126    return function() {         
127        return method.apply(instance, arguments); 
128    }
129}
130
131Base.prototype.CreateCallback = function(func){
132    var args = [];  
133    args[0] = func;
134    args[1] = this;
135    args.LoadArgs(arguments, 1);     
136    return this.CreateCallbackWithContext.apply(this, args);      
137}
138
139Base.prototype.CreateCallbackWithContext = function(func, context){    
140    var newArgs = [];
141    newArgs.LoadArgs(arguments, 2);
142    
143    return function() {
144        var originalContext = this;        
145        var args = [];
146        args[0] = originalContext;
147        args.AddRange(newArgs);
148        args.LoadArgs(arguments);       

149        func.apply(context, args);        
150    }
151}
152
153Base.prototype.AddHandler = function(element, eventName, func){
154    var args = [];    
155    args[0] = element;
156    args[1] = eventName;
157    args[2] = func;
158    args[3] = this;
159    args.LoadArgs(arguments, 3);
160    return this.AddHandlerWithContext.apply(this, args);    
161}
162
163Base.prototype.AddHandlerWithContext = function(element, eventName, func, context){
164    this._HandledElements.Add(element);
165    
166    var useCapture = false;
167    if (typeof(this.UseCapture) != 'undefined')
168    {
169        if (this.UseCapture) { useCapture = true; }
170    }
171    
172    var result = false;
173    if (!element._events)
174    {
175        element._events = [];
176    }
177    var delegate = this.CreateDelegate(context, func);
178    var handler;
179    var args = [];    
180    args[0] = null;
181    args[1] = element;
182    args.LoadArgs(arguments, 4);
183    if (element.addEventListener)
184    {
185        handler = function(e) { args[0] = e; return delegate.apply(element, args); };
186        element.addEventListener(eventName, handler, useCapture);
187        result = true;
188    }
189    else
190    {
191        if (element.attachEvent)
192        {
193            handler = function(e) { 
194                if (!e) 
195                { 
196                    try { e = window.event; }
197                    catch (ex) { }                    
198                }  
199                args[0] = e;              
200                return delegate.apply(element, args);
201            };   
202            element.attachEvent('on' + eventName,  handler); 
203        }
204    }
205    element._events[element._events.length] = {eventName: eventName, delegate: delegate, handler: handler};  
206    return delegate;
207}
208
209Base.prototype.RemoveHandler = function(element, eventName, delegate)
210{    
211    var handler = null;
212    if ((typeof(element._events) !== 'object') || (element._events == null)) 
213    {
214        return false;
215    }
216    var result = false;
217    var cache = [];
218    for (var i=0; i<element._events.length; i++)
219    {
220        if (element._events[i].eventName == eventName)
221        {
222            cache[cache.length] = element._events[i];
223            cache[cache.length-1].Index = i;
224        }
225    } 
226    if (!(cache instanceof Array)) 
227    {
228        return false;
229    }
230    if (delegate)
231    {
232        var index = null;
233        for (var i=0; i<cache.length; i++) 
234        {
235            if (cache[i].delegate === delegate) 
236            {
237                handler = cache[i].handler;
238                index = cache[i].Index;
239                break;
240            }
241        }
242        if (typeof(handler) !== 'function') { return false; }
243        if (element.removeEventListener) 
244        {
245            element.removeEventListener(eventName, handler, false);
246            result = true;
247        }
248        else 
249        {
250            if (element.detachEvent) 
251            {
252                element.detachEvent('on' + eventName, handler);
253                result = true;
254            }
255        }    
256        element._events.splice(index, 1);
257    }
258    else
259    {
260        var i=0;
261        var length = cache.length;
262        while (i<length) 
263        {
264            if (cache[i].eventName == eventName)
265            {
266                handler = cache[i].handler;
267                if (typeof(handler) == 'function') 
268                { 
269                    if (element.removeEventListener) 
270                    {
271                        element.removeEventListener(eventName, handler, false);
272                        result = true;
273                    }
274                    else 
275                    {
276                        if (element.detachEvent) 
277                        {
278                            element.detachEvent('on' + eventName, handler);
279                            result = true;
280                        }
281                    }    
282                }
283                element._events.splice(cache[i].Index, 1); 
284                length -= 1;
285            }
286            else { i += 1; }
287        }        
288    }
289    return result;
290}
291
292Base.prototype.KillEvent = function(eventObject) {
293    if (eventObject)
294    {
295        if (eventObject.stopPropagation) eventObject.stopPropagation();
296        if (eventObject.preventDefault) eventObject.preventDefault();
297        eventObject.cancelBubble = true;
298    }
299    
300    if (window.event)
301    {        
302        window.event.returnValue = false;
303        window.event.cancelBubble = true;
304    }
305    var isFirefox3 = false;
306    var isMozilla = window.netscape && !window.opera;    
307    if (isMozilla)
308    {
309        if (window.showModalDialog) { isFirefox3 = true; }
310    }
311    
312    if (!isFirefox3)
313    {
314        if(eventObject.preventCapture) eventObject.preventCapture();
315        if(eventObject.preventBubble) eventObject.preventBubble();
316    }
317    return false;
318}
319
320Base.prototype.getElementById = function(id, propertyName){
321    if (propertyName) { this.RegisterHTMLElement(propertyName); }
322    return ContensisElement(document.getElementById(id));
323}
324
325Base.prototype.getElementsByTagName = function(tagName, element, propertyName){
326    if (propertyName) { this.RegisterHTMLElement(propertyName); }
327    var elements = document.getElementsByTagName(tagName);
328    if (element)
329    {
330        if (element.getElementsByTagName)
331        {
332            elements = element.getElementsByTagName(tagName);
333        }
334    }
335    var result = [];
336    this.Each(elements, function(el, index){
337        result[result.length] = ContensisElement(el);
338    });

339    return result;
340}
341
342Base.prototype.CreateElement = function(tagName, propertyName){
343    if (propertyName) { this.RegisterHTMLElement(propertyName); }
344    return ContensisElement(document.createElement(tagName));
345}
346
347Base.prototype.Each = function(obj, func){
348    if (!obj) { return; }
349    if (typeof(obj.length) != 'undefined')
350    {
351        for (var i=0; i<obj.length; i++)
352        {            
353            var result = func.call(this, obj[i], i);
354            if (result) { break; }            
355        }
356    }
357    else 
358    {
359        for (var prop in obj)
360        {
361            var result = func.call(this, obj[prop], prop);
362            if (result) { break; }            
363        }
364    }    
365}