← Back to branch summary

~ubuntu-branches/ubuntu/karmic/firebug/karmic

« back to all changes in this revision

Viewing changes to content/firebug/tracePanel.js

  • Committer: Bazaar Package Importer
  • Author(s): Fabrice Coutadeur
  • Date: 2009-01-08 06:23:15 UTC
  • mfrom: (1.1.2 upstream) (0.1.3 sid)
  • Revision ID: james.westby@ubuntu.com-20090108062315-8axszgu22g9a2uyn
Tags: 1.2.1-1ubuntu1
https://launchpad.net/bugs/314962
https://launchpad.net/bugs/272959
* Merge with Debian unstable (LP: #314962)
* debian/control: 
  - Changed references of Iceweasel to Firefox
  - Changed dependency on iceweasel to firefox | abrowser 
    (also close LP: #272959)
  - Changed binary name to firebug
* debian/rules: Changed tag name from makebuilddir/iceweasel-firebug to
  makebuilddir/firebug::
* Created debian/links, debian/docs and debian/install from debian ones

Show diffs side-by-side

added added

removed removed

Lines of Context:
content/firebug/tracePanel.js
1
 
/* See license.txt for terms of usage */
2
 
 
3
 
// UI control of debug Logging for Firebug internals
4
 
 
5
 
FBL.ns(function() { with (FBL) {
6
 
 
7
 
//***********************************************************************************
8
 
// Module
9
 
const Cc = Components.classes;
10
 
const Ci = Components.interfaces;
11
 
const PrefService = Cc["@mozilla.org/preferences-service;1"];
12
 
const nsIPrefBranch2 = Ci.nsIPrefBranch2;
13
 
const prefs = PrefService.getService(nsIPrefBranch2);
14
 
const nsIPrefService = Ci.nsIPrefService;
15
 
const prefService = PrefService.getService(nsIPrefService);
16
 
const prefDomain = "extensions.firebug";
17
 
 
18
 
this.namespaceName = "TracePanel";
19
 
 
20
 
Firebug.TraceModule = extend(Firebug.Console,
21
 
{
22
 
    // These will appear as options in FBTrace panel, with the DBG_ removed.
23
 
        // Also add extension.firebug.BP etc to defaults/preferences/chromebug.js if you want persistence.
24
 
    DBG_BP: false,                      // debugger.js and firebug-services.js; lots of output
25
 
    DBG_CSS: false,             // CSS panel or css stuff
26
 
    DBG_CACHE: false,                   // sourceCache
27
 
    DBG_CONSOLE: false,         // console
28
 
    DBG_DISPATCH: false,                // lib.dispatch
29
 
    DBG_DOM: false,             // includes domplate
30
 
    DBG_DBG2FIREBUG: false,     // put trace output to Firebug console
31
 
    DBG_ERRORS: false,                  // error.js
32
 
    DBG_EVENTS: false,                  // debugger.js for event handlers, need more
33
 
    DBG_EVAL: false,                    // debugger.js and firebug-service.js
34
 
    DBG_FUNCTION_NAMES: false,  // heuristics for anon functions
35
 
    DBG_INSPECT: false,                 // inspector.js
36
 
    DBG_INITIALIZE: false,              // registry (modules panels); initialize FB
37
 
    DBG_HTML: false,            // HTML panel
38
 
    DBG_LINETABLE: false,       // lib.js creating line tables.
39
 
    DBG_NET: false,             // net.js
40
 
    DBG_OPTIONS: false,
41
 
    DBG_PANELS: false, // panel selection.
42
 
    DBG_SHOW_SYSTEM: false,    // isSystemURL return false always.
43
 
    DBG_SOURCEFILES: false,     // debugger and sourceCache
44
 
    DBG_STACK: false,           // call stack, mostly debugger.js
45
 
    DBG_TOPLEVEL: false,                // firebug-service
46
 
    DBG_UI_LOOP: false,                 // debugger.js
47
 
    DBG_WINDOWS: false,         // tabWatcher, dispatch events; very useful for understand modules/panels
48
 
    DBG_FBS_CREATION: false, // firebug-service script creation
49
 
    DBG_FBS_SRCUNITS: false, // firebug-service compilation units
50
 
    DBG_FBS_STEP: false,     // firebug-service stepping
51
 
    DBG_FBS_FUNCTION: false,     // firebug-service new Function
52
 
    DBG_FBS_BP: false, // firebug-service breakpoints
53
 
    DBG_FBS_ERRORS: false, // firebug-service error handling
54
 
    DBG_FBS_FINDDEBUGGER: false, // firebug-service routing calls to debug windows
55
 
    DBG_FBS_FF_START: false, // firebug-service trace from start of firefox
56
 
    DBG_FBS_FLUSH: false, // firebug-service flush to see crash point
57
 
    DBG_FBS_JSDCONTEXT: false, // firebug-service dump contexts
58
 
 
59
 
    debug: this.DBG_OPTIONS,
60
 
 
61
 
    injectOptions: function()
62
 
    {
63
 
        if (this.debug) FBTrace.sysout("TraceModule.injectOptions\n");
64
 
        for (p in this)
65
 
        {
66
 
            var m = reDBG.exec(p);
67
 
            if (m)
68
 
                FBTrace[p] = this[p];
69
 
        }
70
 
    },
71
 
 
72
 
    initialize: function(prefDomain, prefNames)
73
 
    {
74
 
        if (this.debug) FBTrace.sysout("TraceModule.initialize prefDomain="+prefDomain+"\n");
75
 
 
76
 
        for (var p in this)
77
 
        {
78
 
            var f = reDBG_FBS.exec(p);
79
 
            if (f)
80
 
            {
81
 
                FBTrace[p] = Firebug.getPref("extensions.firebug-service", p);
82
 
                if (this.debug)
83
 
                    FBTrace.sysout("TraceModule.initialize extensions.firebug-service."+p+"="+FBTrace[p]+"\n");
84
 
            }
85
 
            else
86
 
            {
87
 
                var m = p.indexOf("DBG_");
88
 
                if (m != -1)
89
 
                    FBTrace[p] = Firebug.getPref(prefDomain, p); // set to 'true' to turn on all traces;
90
 
                if (this.debug && m)
91
 
                    FBTrace.sysout("TraceModule.initialize "+prefDomain+"."+p+"="+FBTrace[p]+"\n");
92
 
            }
93
 
        }
94
 
        prefs.setBoolPref("browser.dom.window.dump.enabled", true);
95
 
        prefs.addObserver("extensions", this, false);
96
 
    },
97
 
 
98
 
    observe: function(subject, topic, data)
99
 
    {
100
 
        var m = reDBG.exec(data);
101
 
        if (m)
102
 
        {
103
 
            var prefDomain = "extensions."+m[1];
104
 
            this.resetOption(prefDomain, m[2]);
105
 
        }
106
 
        else
107
 
            FBTrace.sysout("TraceFirebug.panel observe data: "+data+"\n");
108
 
    },
109
 
 
110
 
    updateOption: function(name, value)
111
 
    {
112
 
        this.debug = FBTrace.DBG_OPTIONS;
113
 
        if (this.debug)
114
 
            FBTrace.sysout("TraceFirebug.panel updateOption this.debug="+this.debug+" name:"+name+" value:"+value+"\n");
115
 
    },
116
 
 
117
 
    resetOption: function(prefDomain, optionName)
118
 
    {
119
 
        if (!FBTrace)  // we get called in a weird scope
120
 
            return;
121
 
        try
122
 
        {
123
 
            FBTrace[optionName] = Firebug.getPref(prefDomain, optionName);
124
 
            if (this.debug)
125
 
                FBTrace.sysout("tracePanel.resetOption set FBTrace."+optionName+" to "+FBTrace[optionName]+" using prefDomain:"+prefDomain+"\n");
126
 
        }
127
 
        catch (exc)
128
 
        {
129
 
            FBTrace.sysout("tracePanel.resetOption "+optionName+" is not an option; not set in defaults/prefs.js?\n");
130
 
        }
131
 
    },
132
 
 
133
 
    watchWindow: function(context, win)
134
 
    {
135
 
        // Don't call the predecessor
136
 
        // Firebug.Console module injects loadFirebugConsole method into the current-page.
137
 
        // It shouldn't be done twice.
138
 
    },
139
 
 
140
 
    initContext: function(context)
141
 
    {
142
 
        if (this.debug)
143
 
            FBTrace.sysout("TraceModule.initContext try sysout\n");
144
 
        this.context = context;
145
 
    },
146
 
 
147
 
    getPanel: function(context, noCreate)
148
 
    {
149
 
        return context ? context.getPanel("TraceFirebug", noCreate) : this.context.getPanel("TraceFirebug", noCreate);
150
 
    },
151
 
 
152
 
    showPanel: function(browser, panel)
153
 
    {
154
 
        if (!panel || panel.name != "TraceFirebug")
155
 
            return;
156
 
 
157
 
        if (this.debug) FBTrace.sysout("TraceModule showPanel module:\n");
158
 
    },
159
 
 
160
 
    logInfoOnce: function(obj, context, rep)
161
 
    {
162
 
        if (!FBTrace.avoidRecursion)
163
 
        {
164
 
            var noThrottle = true;
165
 
            FBTrace.avoidRecursion = true;
166
 
            dump(obj);
167
 
            Firebug.TraceModule.log(obj, context, "info", rep, noThrottle);
168
 
        }
169
 
        else
170
 
        {
171
 
            dump("avoided recursion \n");
172
 
        }
173
 
        FBTrace.avoidRecursion = false;
174
 
    },
175
 
 
176
 
    logRow: function(appender, objects, context, className, rep, sourceLink, noThrottle, noRow)
177
 
    {
178
 
        if (!context)
179
 
            context = FirebugContext;
180
 
        var panel = this.getPanel(context);
181
 
        return panel.append(appender, objects, className, rep, sourceLink, noRow);
182
 
    },
183
 
 
184
 
 
185
 
});
186
 
// ************************************************************************************************
187
 
 
188
 
Firebug.TracePanel = function() {};
189
 
const reDBG = /extensions\.([^\.]*)\.(DBG_.*)/;
190
 
const reDBG_FBS = /DBG_FBS_(.*)/;
191
 
Firebug.TracePanel.prototype = extend(Firebug.ConsolePanel.prototype,
192
 
{
193
 
    name: "TraceFirebug",
194
 
    title: "FBTrace",
195
 
    searchable: false,
196
 
    editable: false,
197
 
    debug: Firebug.TraceModule.DBG_OPTIONS,
198
 
 
199
 
    initializeNode: function(myPanelNode)
200
 
    {
201
 
        if (this.debug) FBTrace.sysout("TracePanel initializeNode\n");
202
 
        var options = this.getOptionsMenuItems();
203
 
 
204
 
        var numbers_of_columns = 6;
205
 
        var number_of_rows = Math.round((options.length / numbers_of_columns));
206
 
 
207
 
        for (var i = 0; i < options.length; i++)
208
 
        {
209
 
            var depth = i % number_of_rows;
210
 
            if (depth == 0)
211
 
            {
212
 
                var optionsColumn = this.document.createElement("div");
213
 
                setClass(optionsColumn, "FBTraceColumn");
214
 
                myPanelNode.appendChild(optionsColumn);
215
 
            }
216
 
 
217
 
            var button = this.document.createElement("button");
218
 
            setClass(button, "FBTraceOption");
219
 
            button.innerHTML = options[i].label;
220
 
            setItemIntoElement(button, options[i]);
221
 
            optionsColumn.appendChild(button);
222
 
            button.addEventListener("click", options[i].command, false);
223
 
        }
224
 
        prefs.addObserver("extensions", { observe: bind(this.observePrefs, this)}, false);
225
 
    },
226
 
 
227
 
    observePrefs: function(subject, topic, data)
228
 
    {
229
 
        var m = reDBG.exec(data);
230
 
        if (m)
231
 
        {
232
 
            this.updateButtons();
233
 
        }
234
 
    },
235
 
 
236
 
    show: function(state)
237
 
    {
238
 
        if (this.debug) FBTrace.sysout("TraceFirebug.panel show context="+this.context+"\n");
239
 
        var consoleButtons = this.context.browser.chrome.$("fbConsoleButtons");
240
 
        collapse(consoleButtons, false);
241
 
 
242
 
        this.updateButtons(state);
243
 
        // TODO update options based on state to make tracing per-page
244
 
    },
245
 
 
246
 
    updateButtons: function()
247
 
    {
248
 
        var buttons = this.panelNode.getElementsByTagName("button");
249
 
        for (var i = 0; i < buttons.length; i++)
250
 
        {
251
 
            var label = buttons[i].getAttribute("label");
252
 
            var prop = "DBG_"+label;
253
 
            if (FBTrace.hasOwnProperty(prop))
254
 
            {
255
 
                var optionOn = FBTrace[prop];
256
 
                //FBTrace.sysout("tracePanel.show label: "+label+" optionOn: "+optionOn+"\n");
257
 
                buttons[i].setAttribute("checked", optionOn);
258
 
            }
259
 
        }
260
 
    },
261
 
 
262
 
    hide: function()
263
 
    {
264
 
        if (this.debug) FBTrace.dumpStack("TraceFirebug.panel hide\n");
265
 
        if (this.context && this.context.browser)
266
 
        {
267
 
            var consoleButtons = this.context.browser.chrome.$("fbConsoleButtons");
268
 
            collapse(consoleButtons, true);
269
 
        }
270
 
    },
271
 
 
272
 
    watchWindow: function(win)
273
 
    {
274
 
        if (this.debug) FBTrace.sysout("TraceFirebug.panel watchWindow\n");
275
 
    },
276
 
 
277
 
    unwatchWindow: function(win)
278
 
    {
279
 
        if (this.debug) FBTrace.sysout("TraceFirebug.panel unwatchWindow\n");
280
 
        var errorWin = fbs.lastErrorWindow;
281
 
        if (errorWin)
282
 
            FBTrace.sysout("tracePanel had to clear lastErrorWindow <*><*><*><*>\n");
283
 
    },
284
 
 
285
 
 
286
 
    updateSelection: function(object)
287
 
    {
288
 
        if (this.debug) FBTrace.sysout("TraceFirebug.panel updateSelection\n");
289
 
    },
290
 
 
291
 
    getObjectPath: function(object)
292
 
    {
293
 
        if (this.debug) FBTrace.sysout("TraceFirebug.panel getObjectPath\n");
294
 
        return TabWatcher.contexts;
295
 
    },
296
 
 
297
 
    getDefaultSelection: function()
298
 
    {
299
 
        if (this.debug) FBTrace.sysout("TraceFirebug.panel getDefaultSelection\n");
300
 
    },
301
 
 
302
 
    getOptionsMenuItems: function()
303
 
    {
304
 
        if (this.debug) FBTrace.sysout("TraceFirebug.panel getOptionsMenuItems for this.context="+this.context+"\n");
305
 
        var items = [];
306
 
        var self = this;
307
 
 
308
 
        for (p in FBTrace)
309
 
        {
310
 
            var m = p.indexOf("DBG_");
311
 
            if (m != -1)
312
 
            {
313
 
                var label = p.substr(4);
314
 
                items.push({
315
 
                    label: label,
316
 
                    nol10n: true,
317
 
                    type: "checkbox",
318
 
                    checked: FBTrace[p],
319
 
                    command: this.setOption
320
 
                });
321
 
            }
322
 
        }
323
 
        return items;
324
 
    },
325
 
 
326
 
    setOption: function(event)
327
 
    {
328
 
        var menuitem = event.target;
329
 
        var label = menuitem.getAttribute("label");
330
 
        var category = 'DBG_'+label;
331
 
        FBTrace[category] = !FBTrace[category];
332
 
        menuitem.checked = FBTrace[category];
333
 
 
334
 
        if (category.indexOf("_FBS_") == -1)
335
 
        {
336
 
            var prefDomain = Firebug.prefDomain;
337
 
            Firebug.setPref(Firebug.prefDomain, category, FBTrace[category] );
338
 
            prefService.savePrefFile(null);
339
 
        }
340
 
        else
341
 
        {
342
 
            var prefDomain = "extensions.firebug-service";
343
 
            prefs.setBoolPref(prefDomain+"."+category, FBTrace[category]);
344
 
            prefService.savePrefFile(null);
345
 
        }
346
 
 
347
 
        if (FBTrace.DBG_OPTIONS)
348
 
                FBTrace.sysout("tracePanel.setOption: "+prefDomain+"."+category+ " = " + FBTrace[category] + "\n");
349
 
 
350
 
    },
351
 
 
352
 
    getContextMenuItems: function(object, target)
353
 
    {
354
 
        if (this.debug) FBTrace.sysout("TraceFirebug.panel getContextMenuItems\n");
355
 
    },
356
 
 
357
 
    getEditor: function(target, value)
358
 
    {
359
 
        if (this.debug) FBTrace.sysout("TraceFirebug.panel getEditor\n");
360
 
    }
361
 
 
362
 
});
363
 
 
364
 
Firebug.TraceModule.injectOptions();
365
 
Firebug.registerModule(Firebug.TraceModule);
366
 
Firebug.registerPanel(Firebug.TracePanel);
367
 
 
368
 
}});