← Back to branch summary

~zubairassad89/sahana-eden/vms_gsoc

« back to all changes in this revision

Viewing changes to static/mfbase/openlayers/lib/Firebug/firebug.js

  • Committer: Fran Boon
  • Date: 2008-12-09 22:35:23 UTC
  • Revision ID: flavour@partyvibe.com-20081209223523-fcs5k95jjk0uqo0z
Initial import of work done so far

Show diffs side-by-side

added added

removed removed

Lines of Context:
static/mfbase/openlayers/lib/Firebug/firebug.js
 
1
 
 
2
if (!window.console || !console.firebug) { (function()
 
3
{
 
4
    window.console = 
 
5
    {
 
6
        log: function()
 
7
        {
 
8
            logFormatted(arguments, "");
 
9
        },
 
10
        
 
11
        debug: function()
 
12
        {
 
13
            logFormatted(arguments, "debug");
 
14
        },
 
15
        
 
16
        info: function()
 
17
        {
 
18
            logFormatted(arguments, "info");
 
19
        },
 
20
        
 
21
        warn: function()
 
22
        {
 
23
            logFormatted(arguments, "warning");
 
24
        },
 
25
        
 
26
        error: function()
 
27
        {
 
28
            logFormatted(arguments, "error");
 
29
        },
 
30
        
 
31
        assert: function(truth, message)
 
32
        {
 
33
            if (!truth)
 
34
            {
 
35
                var args = [];
 
36
                for (var i = 1; i < arguments.length; ++i)
 
37
                    args.push(arguments[i]);
 
38
                
 
39
                logFormatted(args.length ? args : ["Assertion Failure"], "error");
 
40
                throw message ? message : "Assertion Failure";
 
41
            }
 
42
        },
 
43
        
 
44
        dir: function(object)
 
45
        {
 
46
            var html = [];
 
47
                        
 
48
            var pairs = [];
 
49
            for (var name in object)
 
50
            {
 
51
                try
 
52
                {
 
53
                    pairs.push([name, object[name]]);
 
54
                }
 
55
                catch (exc)
 
56
                {
 
57
                }
 
58
            }
 
59
            
 
60
            pairs.sort(function(a, b) { return a[0] < b[0] ? -1 : 1; });
 
61
            
 
62
            html.push('<table>');
 
63
            for (var i = 0; i < pairs.length; ++i)
 
64
            {
 
65
                var name = pairs[i][0], value = pairs[i][1];
 
66
                
 
67
                html.push('<tr>', 
 
68
                '<td class="propertyNameCell"><span class="propertyName">',
 
69
                    escapeHTML(name), '</span></td>', '<td><span class="propertyValue">');
 
70
                appendObject(value, html);
 
71
                html.push('</span></td></tr>');
 
72
            }
 
73
            html.push('</table>');
 
74
            
 
75
            logRow(html, "dir");
 
76
        },
 
77
        
 
78
        dirxml: function(node)
 
79
        {
 
80
            var html = [];
 
81
            
 
82
            appendNode(node, html);
 
83
            logRow(html, "dirxml");
 
84
        },
 
85
        
 
86
        group: function()
 
87
        {
 
88
            logRow(arguments, "group", pushGroup);
 
89
        },
 
90
        
 
91
        groupEnd: function()
 
92
        {
 
93
            logRow(arguments, "", popGroup);
 
94
        },
 
95
        
 
96
        time: function(name)
 
97
        {
 
98
            timeMap[name] = (new Date()).getTime();
 
99
        },
 
100
        
 
101
        timeEnd: function(name)
 
102
        {
 
103
            if (name in timeMap)
 
104
            {
 
105
                var delta = (new Date()).getTime() - timeMap[name];
 
106
                logFormatted([name+ ":", delta+"ms"]);
 
107
                delete timeMap[name];
 
108
            }
 
109
        },
 
110
        
 
111
        count: function()
 
112
        {
 
113
            this.warn(["count() not supported."]);
 
114
        },
 
115
        
 
116
        trace: function()
 
117
        {
 
118
            this.warn(["trace() not supported."]);
 
119
        },
 
120
        
 
121
        profile: function()
 
122
        {
 
123
            this.warn(["profile() not supported."]);
 
124
        },
 
125
        
 
126
        profileEnd: function()
 
127
        {
 
128
        },
 
129
        
 
130
        clear: function()
 
131
        {
 
132
            consoleBody.innerHTML = "";
 
133
        },
 
134
 
 
135
        open: function()
 
136
        {
 
137
            toggleConsole(true);
 
138
        },
 
139
        
 
140
        close: function()
 
141
        {
 
142
            if (frameVisible)
 
143
                toggleConsole();
 
144
        }
 
145
    };
 
146
 
 
147
    // ********************************************************************************************
 
148
       
 
149
    var consoleFrame = null;
 
150
    var consoleBody = null;
 
151
    var commandLine = null;
 
152
    
 
153
    var frameVisible = false;
 
154
    var messageQueue = [];
 
155
    var groupStack = [];
 
156
    var timeMap = {};
 
157
    
 
158
    var clPrefix = ">>> ";
 
159
    
 
160
    var isFirefox = navigator.userAgent.indexOf("Firefox") != -1;
 
161
    var isIE = navigator.userAgent.indexOf("MSIE") != -1;
 
162
    var isOpera = navigator.userAgent.indexOf("Opera") != -1;
 
163
    var isSafari = navigator.userAgent.indexOf("AppleWebKit") != -1;
 
164
 
 
165
    // ********************************************************************************************
 
166
 
 
167
    function toggleConsole(forceOpen)
 
168
    {
 
169
        frameVisible = forceOpen || !frameVisible;
 
170
        if (consoleFrame)
 
171
            consoleFrame.style.visibility = frameVisible ? "visible" : "hidden";
 
172
        else
 
173
            waitForBody();
 
174
    }
 
175
 
 
176
    function focusCommandLine()
 
177
    {
 
178
        toggleConsole(true);
 
179
        if (commandLine)
 
180
            commandLine.focus();
 
181
    }
 
182
 
 
183
    function waitForBody()
 
184
    {
 
185
        if (document.body)
 
186
            createFrame();
 
187
        else
 
188
            setTimeout(waitForBody, 200);
 
189
    }    
 
190
 
 
191
    function createFrame()
 
192
    {
 
193
        if (consoleFrame)
 
194
            return;
 
195
        
 
196
        window.onFirebugReady = function(doc)
 
197
        {
 
198
            window.onFirebugReady = null;
 
199
 
 
200
            var toolbar = doc.getElementById("toolbar");
 
201
            toolbar.onmousedown = onSplitterMouseDown;
 
202
 
 
203
            commandLine = doc.getElementById("commandLine");
 
204
            addEvent(commandLine, "keydown", onCommandLineKeyDown);
 
205
 
 
206
            addEvent(doc, isIE || isSafari ? "keydown" : "keypress", onKeyDown);
 
207
            
 
208
            consoleBody = doc.getElementById("log");
 
209
            layout();
 
210
            flush();
 
211
        }
 
212
 
 
213
        var baseURL = getFirebugURL();
 
214
 
 
215
        consoleFrame = document.createElement("iframe");
 
216
        consoleFrame.setAttribute("src", baseURL+"/firebug.html");
 
217
        consoleFrame.setAttribute("frameBorder", "0");
 
218
        consoleFrame.style.visibility = (frameVisible ? "visible" : "hidden");    
 
219
        consoleFrame.style.zIndex = "2147483583";
 
220
        consoleFrame.style.position = document.all ? "absolute" : "fixed";
 
221
        consoleFrame.style.width = "100%";
 
222
        consoleFrame.style.left = "0";
 
223
        consoleFrame.style.bottom = "0";
 
224
        consoleFrame.style.height = "200px";
 
225
        document.body.appendChild(consoleFrame);
 
226
    }
 
227
    
 
228
    function getFirebugURL()
 
229
    {
 
230
        var scripts = document.getElementsByTagName("script");
 
231
        for (var i = 0; i < scripts.length; ++i)
 
232
        {
 
233
            if (scripts[i].src.indexOf("firebug.js") != -1)
 
234
            {
 
235
                var lastSlash = scripts[i].src.lastIndexOf("/");
 
236
                return scripts[i].src.substr(0, lastSlash);
 
237
            }
 
238
        }
 
239
    }
 
240
    
 
241
    function evalCommandLine()
 
242
    {
 
243
        var text = commandLine.value;
 
244
        commandLine.value = "";
 
245
 
 
246
        logRow([clPrefix, text], "command");
 
247
        
 
248
        var value;
 
249
        try
 
250
        {
 
251
            value = eval(text);
 
252
        }
 
253
        catch (exc)
 
254
        {
 
255
        }
 
256
 
 
257
        console.log(value);
 
258
    }
 
259
    
 
260
    function layout()
 
261
    {
 
262
        var toolbar = consoleBody.ownerDocument.getElementById("toolbar");
 
263
        var height = consoleFrame.offsetHeight - (toolbar.offsetHeight + commandLine.offsetHeight);
 
264
        height = Math.max(height, 0);
 
265
        consoleBody.style.top = toolbar.offsetHeight + "px";
 
266
        consoleBody.style.height = height + "px";
 
267
        
 
268
        commandLine.style.top = (consoleFrame.offsetHeight - commandLine.offsetHeight) + "px";
 
269
    }
 
270
    
 
271
    function logRow(message, className, handler)
 
272
    {
 
273
        if (consoleBody)
 
274
            writeMessage(message, className, handler);
 
275
        else
 
276
        {
 
277
            messageQueue.push([message, className, handler]);
 
278
            waitForBody();
 
279
        }
 
280
    }
 
281
    
 
282
    function flush()
 
283
    {
 
284
        var queue = messageQueue;
 
285
        messageQueue = [];
 
286
        
 
287
        for (var i = 0; i < queue.length; ++i)
 
288
            writeMessage(queue[i][0], queue[i][1], queue[i][2]);
 
289
    }
 
290
 
 
291
    function writeMessage(message, className, handler)
 
292
    {
 
293
        var isScrolledToBottom =
 
294
            consoleBody.scrollTop + consoleBody.offsetHeight >= consoleBody.scrollHeight;
 
295
 
 
296
        if (!handler)
 
297
            handler = writeRow;
 
298
        
 
299
        handler(message, className);
 
300
        
 
301
        if (isScrolledToBottom)
 
302
            consoleBody.scrollTop = consoleBody.scrollHeight - consoleBody.offsetHeight;
 
303
    }
 
304
    
 
305
    function appendRow(row)
 
306
    {
 
307
        var container = groupStack.length ? groupStack[groupStack.length-1] : consoleBody;
 
308
        container.appendChild(row);
 
309
    }
 
310
 
 
311
    function writeRow(message, className)
 
312
    {
 
313
        var row = consoleBody.ownerDocument.createElement("div");
 
314
        row.className = "logRow" + (className ? " logRow-"+className : "");
 
315
        row.innerHTML = message.join("");
 
316
        appendRow(row);
 
317
    }
 
318
 
 
319
    function pushGroup(message, className)
 
320
    {
 
321
        logFormatted(message, className);
 
322
 
 
323
        var groupRow = consoleBody.ownerDocument.createElement("div");
 
324
        groupRow.className = "logGroup";
 
325
        var groupRowBox = consoleBody.ownerDocument.createElement("div");
 
326
        groupRowBox.className = "logGroupBox";
 
327
        groupRow.appendChild(groupRowBox);
 
328
        appendRow(groupRowBox);
 
329
        groupStack.push(groupRowBox);
 
330
    }
 
331
 
 
332
    function popGroup()
 
333
    {
 
334
        groupStack.pop();
 
335
    }
 
336
    
 
337
    // ********************************************************************************************
 
338
 
 
339
    function logFormatted(objects, className)
 
340
    {
 
341
        var html = [];
 
342
 
 
343
        var format = objects[0];
 
344
        var objIndex = 0;
 
345
 
 
346
        if (typeof(format) != "string")
 
347
        {
 
348
            format = "";
 
349
            objIndex = -1;
 
350
        }
 
351
 
 
352
        var parts = parseFormat(format);
 
353
        for (var i = 0; i < parts.length; ++i)
 
354
        {
 
355
            var part = parts[i];
 
356
            if (part && typeof(part) == "object")
 
357
            {
 
358
                var object = objects[++objIndex];
 
359
                part.appender(object, html);
 
360
            }
 
361
            else
 
362
                appendText(part, html);
 
363
        }
 
364
 
 
365
        for (var i = objIndex+1; i < objects.length; ++i)
 
366
        {
 
367
            appendText(" ", html);
 
368
            
 
369
            var object = objects[i];
 
370
            if (typeof(object) == "string")
 
371
                appendText(object, html);
 
372
            else
 
373
                appendObject(object, html);
 
374
        }
 
375
        
 
376
        logRow(html, className);
 
377
    }
 
378
 
 
379
    function parseFormat(format)
 
380
    {
 
381
        var parts = [];
 
382
 
 
383
        var reg = /((^%|[^\\]%)(\d+)?(\.)([a-zA-Z]))|((^%|[^\\]%)([a-zA-Z]))/;    
 
384
        var appenderMap = {s: appendText, d: appendInteger, i: appendInteger, f: appendFloat};
 
385
 
 
386
        for (var m = reg.exec(format); m; m = reg.exec(format))
 
387
        {
 
388
            var type = m[8] ? m[8] : m[5];
 
389
            var appender = type in appenderMap ? appenderMap[type] : appendObject;
 
390
            var precision = m[3] ? parseInt(m[3]) : (m[4] == "." ? -1 : 0);
 
391
 
 
392
            parts.push(format.substr(0, m[0][0] == "%" ? m.index : m.index+1));
 
393
            parts.push({appender: appender, precision: precision});
 
394
 
 
395
            format = format.substr(m.index+m[0].length);
 
396
        }
 
397
 
 
398
        parts.push(format);
 
399
 
 
400
        return parts;
 
401
    }
 
402
 
 
403
    function escapeHTML(value)
 
404
    {
 
405
        function replaceChars(ch)
 
406
        {
 
407
            switch (ch)
 
408
            {
 
409
                case "<":
 
410
                    return "&lt;";
 
411
                case ">":
 
412
                    return "&gt;";
 
413
                case "&":
 
414
                    return "&amp;";
 
415
                case "'":
 
416
                    return "&#39;";
 
417
                case '"':
 
418
                    return "&quot;";
 
419
            }
 
420
            return "?";
 
421
        };
 
422
        return String(value).replace(/[<>&"']/g, replaceChars);
 
423
    }
 
424
 
 
425
    function objectToString(object)
 
426
    {
 
427
        try
 
428
        {
 
429
            return object+"";
 
430
        }
 
431
        catch (exc)
 
432
        {
 
433
            return null;
 
434
        }
 
435
    }
 
436
 
 
437
    // ********************************************************************************************
 
438
 
 
439
    function appendText(object, html)
 
440
    {
 
441
        html.push(escapeHTML(objectToString(object)));
 
442
    }
 
443
 
 
444
    function appendNull(object, html)
 
445
    {
 
446
        html.push('<span class="objectBox-null">', escapeHTML(objectToString(object)), '</span>');
 
447
    }
 
448
 
 
449
    function appendString(object, html)
 
450
    {
 
451
        html.push('<span class="objectBox-string">&quot;', escapeHTML(objectToString(object)),
 
452
            '&quot;</span>');
 
453
    }
 
454
 
 
455
    function appendInteger(object, html)
 
456
    {
 
457
        html.push('<span class="objectBox-number">', escapeHTML(objectToString(object)), '</span>');
 
458
    }
 
459
 
 
460
    function appendFloat(object, html)
 
461
    {
 
462
        html.push('<span class="objectBox-number">', escapeHTML(objectToString(object)), '</span>');
 
463
    }
 
464
 
 
465
    function appendFunction(object, html)
 
466
    {
 
467
        var reName = /function ?(.*?)\(/;
 
468
        var m = reName.exec(objectToString(object));
 
469
        var name = m ? m[1] : "function";
 
470
        html.push('<span class="objectBox-function">', escapeHTML(name), '()</span>');
 
471
    }
 
472
    
 
473
    function appendObject(object, html)
 
474
    {
 
475
        try
 
476
        {
 
477
            if (object == undefined)
 
478
                appendNull("undefined", html);
 
479
            else if (object == null)
 
480
                appendNull("null", html);
 
481
            else if (typeof object == "string")
 
482
                appendString(object, html);
 
483
            else if (typeof object == "number")
 
484
                appendInteger(object, html);
 
485
            else if (typeof object == "function")
 
486
                appendFunction(object, html);
 
487
            else if (object.nodeType == 1)
 
488
                appendSelector(object, html);
 
489
            else if (typeof object == "object")
 
490
                appendObjectFormatted(object, html);
 
491
            else
 
492
                appendText(object, html);
 
493
        }
 
494
        catch (exc)
 
495
        {
 
496
        }
 
497
    }
 
498
        
 
499
    function appendObjectFormatted(object, html)
 
500
    {
 
501
        var text = objectToString(object);
 
502
        var reObject = /\[object (.*?)\]/;
 
503
 
 
504
        var m = reObject.exec(text);
 
505
        html.push('<span class="objectBox-object">', m ? m[1] : text, '</span>')
 
506
    }
 
507
    
 
508
    function appendSelector(object, html)
 
509
    {
 
510
        html.push('<span class="objectBox-selector">');
 
511
 
 
512
        html.push('<span class="selectorTag">', escapeHTML(object.nodeName.toLowerCase()), '</span>');
 
513
        if (object.id)
 
514
            html.push('<span class="selectorId">#', escapeHTML(object.id), '</span>');
 
515
        if (object.className)
 
516
            html.push('<span class="selectorClass">.', escapeHTML(object.className), '</span>');
 
517
 
 
518
        html.push('</span>');
 
519
    }
 
520
 
 
521
    function appendNode(node, html)
 
522
    {
 
523
        if (node.nodeType == 1)
 
524
        {
 
525
            html.push(
 
526
                '<div class="objectBox-element">',
 
527
                    '&lt;<span class="nodeTag">', node.nodeName.toLowerCase(), '</span>');
 
528
 
 
529
            for (var i = 0; i < node.attributes.length; ++i)
 
530
            {
 
531
                var attr = node.attributes[i];
 
532
                if (!attr.specified)
 
533
                    continue;
 
534
                
 
535
                html.push('&nbsp;<span class="nodeName">', attr.nodeName.toLowerCase(),
 
536
                    '</span>=&quot;<span class="nodeValue">', escapeHTML(attr.nodeValue),
 
537
                    '</span>&quot;')
 
538
            }
 
539
 
 
540
            if (node.firstChild)
 
541
            {
 
542
                html.push('&gt;</div><div class="nodeChildren">');
 
543
 
 
544
                for (var child = node.firstChild; child; child = child.nextSibling)
 
545
                    appendNode(child, html);
 
546
                    
 
547
                html.push('</div><div class="objectBox-element">&lt;/<span class="nodeTag">', 
 
548
                    node.nodeName.toLowerCase(), '&gt;</span></div>');
 
549
            }
 
550
            else
 
551
                html.push('/&gt;</div>');
 
552
        }
 
553
        else if (node.nodeType == 3)
 
554
        {
 
555
            html.push('<div class="nodeText">', escapeHTML(node.nodeValue),
 
556
                '</div>');
 
557
        }
 
558
    }
 
559
 
 
560
    // ********************************************************************************************
 
561
    
 
562
    function addEvent(object, name, handler)
 
563
    {
 
564
        if (document.all)
 
565
            object.attachEvent("on"+name, handler);
 
566
        else
 
567
            object.addEventListener(name, handler, false);
 
568
    }
 
569
    
 
570
    function removeEvent(object, name, handler)
 
571
    {
 
572
        if (document.all)
 
573
            object.detachEvent("on"+name, handler);
 
574
        else
 
575
            object.removeEventListener(name, handler, false);
 
576
    }
 
577
    
 
578
    function cancelEvent(event)
 
579
    {
 
580
        if (document.all)
 
581
            event.cancelBubble = true;
 
582
        else
 
583
            event.stopPropagation();        
 
584
    }
 
585
 
 
586
    function onError(msg, href, lineNo)
 
587
    {
 
588
        var html = [];
 
589
        
 
590
        var lastSlash = href.lastIndexOf("/");
 
591
        var fileName = lastSlash == -1 ? href : href.substr(lastSlash+1);
 
592
        
 
593
        html.push(
 
594
            '<span class="errorMessage">', msg, '</span>', 
 
595
            '<div class="objectBox-sourceLink">', fileName, ' (line ', lineNo, ')</div>'
 
596
        );
 
597
        
 
598
        logRow(html, "error");
 
599
    };
 
600
 
 
601
    function onKeyDown(event)
 
602
    {
 
603
        if (event.keyCode == 123)
 
604
            toggleConsole();
 
605
        else if ((event.keyCode == 108 || event.keyCode == 76) && event.shiftKey
 
606
                 && (event.metaKey || event.ctrlKey))
 
607
            focusCommandLine();
 
608
        else
 
609
            return;
 
610
        
 
611
        cancelEvent(event);
 
612
    }
 
613
 
 
614
    function onSplitterMouseDown(event)
 
615
    {
 
616
        if (isSafari || isOpera)
 
617
            return;
 
618
        
 
619
        addEvent(document, "mousemove", onSplitterMouseMove);
 
620
        addEvent(document, "mouseup", onSplitterMouseUp);
 
621
 
 
622
        for (var i = 0; i < frames.length; ++i)
 
623
        {
 
624
            addEvent(frames[i].document, "mousemove", onSplitterMouseMove);
 
625
            addEvent(frames[i].document, "mouseup", onSplitterMouseUp);
 
626
        }
 
627
    }
 
628
    
 
629
    function onSplitterMouseMove(event)
 
630
    {
 
631
        var win = document.all
 
632
            ? event.srcElement.ownerDocument.parentWindow
 
633
            : event.target.ownerDocument.defaultView;
 
634
 
 
635
        var clientY = event.clientY;
 
636
        if (win != win.parent)
 
637
            clientY += win.frameElement ? win.frameElement.offsetTop : 0;
 
638
        
 
639
        var height = consoleFrame.offsetTop + consoleFrame.clientHeight;
 
640
        var toolbar = consoleBody.ownerDocument.getElementById("toolbar");
 
641
        var y = Math.max(height - clientY,
 
642
                         toolbar.offsetHeight + commandLine.offsetHeight);
 
643
        
 
644
        consoleFrame.style.height = y + "px";
 
645
        layout();
 
646
    }
 
647
    
 
648
    function onSplitterMouseUp(event)
 
649
    {
 
650
        removeEvent(document, "mousemove", onSplitterMouseMove);
 
651
        removeEvent(document, "mouseup", onSplitterMouseUp);
 
652
 
 
653
        for (var i = 0; i < frames.length; ++i)
 
654
        {
 
655
            removeEvent(frames[i].document, "mousemove", onSplitterMouseMove);
 
656
            removeEvent(frames[i].document, "mouseup", onSplitterMouseUp);
 
657
        }
 
658
    }
 
659
    
 
660
    function onCommandLineKeyDown(event)
 
661
    {
 
662
        if (event.keyCode == 13)
 
663
            evalCommandLine();
 
664
        else if (event.keyCode == 27)
 
665
            commandLine.value = "";
 
666
    }
 
667
    
 
668
    window.onerror = onError;
 
669
    addEvent(document, isIE || isSafari ? "keydown" : "keypress", onKeyDown);
 
670
    
 
671
    if (document.documentElement.getAttribute("debug") == "true")
 
672
        toggleConsole(true);
 
673
})();
 
674
}