← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to www/media/console/console.js

  • Committer: mattgiuca
  • Date: 2008-01-31 01:44:30 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:345
Global CSS change: ivlebody no longer has 1em of padding (it has none).
This is because most apps were disabling it (and it had to change anyway for
other reasons -- see below).

Hence, all apps which WERE disabling the padding have had that removed, and
just work by default. (console, browser, tutorial)
All apps which WEREN'T disabling the padding (very few) now have to manually
include an extra div. This has been done on all such apps, and has been
heavily documented (both in the CSS file and doc/app_howto). (help, dummy,
debuginfo).

media/common/ivle.css: 
    The real change here (which isn't yet being used) is that ivlebody is now
    positioned absolutely and takes up all the space on the canvas. This is
    to be used for full-page layouts in console and browser.

Show diffs side-by-side

added added

removed removed

Lines of Context:
www/media/console/console.js
20
20
 * Date: 30/1/2008
21
21
 */
22
22
 
23
 
var server_key;
 
23
digest_constant = "hello";
 
24
 
 
25
var server_host;
 
26
var server_port;
 
27
var server_magic;
24
28
 
25
29
/* Begin religious debate (tabs vs spaces) here: */
26
30
/* (This string will be inserted in the console when the user presses the Tab
34
38
windowpane_mode = false;
35
39
server_started = false;
36
40
 
37
 
interrupted = false;
38
 
 
39
41
/* Starts the console server, if it isn't already.
40
42
 * This can be called any number of times - it only starts the one server.
41
 
 * Note that this is asynchronous. It will return after signalling to start
42
 
 * the server, but there is no guarantee that it has been started yet.
43
43
 * This is a separate step from console_init, as the server is only to be
44
44
 * started once the first command is entered.
45
45
 * Does not return a value. Writes to global variables
46
 
 * server_host, and server_port.
47
 
 *
48
 
 * \param callback Function which will be called after the server has been
49
 
 * started. No parameters are passed. May be null.
 
46
 * server_host, server_port, server_magic.
50
47
 */
51
 
function start_server(callback)
 
48
function start_server()
52
49
{
53
 
    if (server_started)
54
 
    {
55
 
        callback();
56
 
        return;
57
 
    }
58
 
    var callback1 = function(xhr)
59
 
        {
60
 
            var json_text = xhr.responseText;
61
 
            server_key = JSON.parse(json_text).key;
62
 
            server_started = true;
63
 
            if (callback != null)
64
 
                callback();
65
 
        }
66
 
 
67
 
    //var current_path;
68
 
    if((typeof(current_path) != 'undefined') && current_file)
69
 
    {
70
 
        // We have a current_path - give a suggestion to the server
71
 
        var path;
72
 
        if (current_file.isdir)
73
 
        {
74
 
            // Browser
75
 
            path = path_join("/home", current_path);
76
 
        }
77
 
        else
78
 
        {
79
 
            // Editor - need to chop off filename
80
 
            var tmp_path = current_path.split('/');
81
 
            tmp_path.pop();
82
 
            path = path_join("/home", tmp_path.join('/'));
83
 
        }
84
 
        ajax_call(callback1, "consoleservice", "start", {"startdir": path}, "POST");
85
 
    }
86
 
    else
87
 
    {
88
 
        // No current_path - let the server decide
89
 
        ajax_call(callback1, "consoleservice", "start", {}, "POST");
90
 
    }
 
50
    if (server_started) return;
 
51
    var xhr = ajax_call("consoleservice", "start", {}, "POST");
 
52
    var json_text = xhr.responseText;
 
53
    var server_info = JSON.parse(json_text);
 
54
    server_host = server_info.host;
 
55
    server_port = server_info.port;
 
56
    server_magic = server_info.magic;
 
57
    server_started = true;
91
58
}
92
59
 
93
60
/** Initialises the console. All apps which import console are required to
101
68
{
102
69
    /* Set up the console as a floating pane */
103
70
    console_body = document.getElementById("console_body");
104
 
    /* If there is no console body, don't worry.
105
 
     * (This lets us import console.js even on pages without a console box */
106
 
    if (console_body == null) return;
107
71
    console_filler = document.getElementById("console_filler");
108
72
    if (windowpane)
109
73
    {
110
74
        windowpane_mode = true;
111
75
        console_minimize();
112
76
    }
 
77
    /* TEMP: Start the server now.
 
78
     * Ultimately we want the server to start only when a line is typed, but
 
79
     * it currently does it asynchronously and doesn't start in time for the
 
80
     * first line. */
 
81
    start_server();
113
82
}
114
83
 
115
84
/** Hide the main console panel, so the console minimizes to just an input box
130
99
    console_filler.setAttribute("class", "windowpane maximal");
131
100
}
132
101
 
133
 
/* current_text is the string currently on the command line.
134
 
 * If non-empty, it will be stored at the bottom of the history.
 
102
/* Below here imported from trunk/console/console.js
 
103
 * (Tom Conway)
135
104
 */
136
 
function historyUp(current_text)
 
105
 
 
106
var magic = 'xyzzy';
 
107
 
 
108
function historyUp()
137
109
{
138
 
    /* Remember the changes made to this item */
139
 
    this.edited[this.cursor] = current_text;
140
 
    if (this.cursor > 0)
 
110
    if (this.cursor >= 0)
141
111
    {
142
112
        this.cursor--;
143
113
    }
144
 
    this.earliestCursor = this.cursor;
145
114
}
146
115
 
147
 
function historyDown(current_text)
 
116
function historyDown()
148
117
{
149
 
    /* Remember the changes made to this item */
150
 
    this.edited[this.cursor] = current_text;
151
 
    if (this.cursor < this.items.length - 1)
 
118
    if (this.cursor < this.items.length)
152
119
    {
153
120
        this.cursor++;
154
121
    }
156
123
 
157
124
function historyCurr()
158
125
{
159
 
    return this.edited[this.cursor];
 
126
    if (this.cursor < 0 || this.cursor >= this.items.length)
 
127
    {
 
128
        return "";
 
129
    }
 
130
    return this.items[this.cursor];
160
131
}
161
132
 
162
 
function historySubmit(text)
 
133
function historyAdd(text)
163
134
{
164
 
    /* Copy the selected item's "edited" version over the permanent version of
165
 
     * the last item. */
166
 
    this.items[this.items.length-1] = text;
167
 
    /* Add a new blank item */
168
 
    this.items[this.items.length] = "";
169
 
    this.cursor = this.items.length-1;
170
 
    /* Blow away all the edited versions, replacing them with the existing
171
 
     * items set.
172
 
     * Not the whole history - just start from the earliest edited one.
173
 
     * (This avoids slowdown over extended usage time).
174
 
     */
175
 
    for (var i=this.earliestCursor; i<=this.cursor; i++)
176
 
        this.edited[i] = this.items[i];
177
 
    this.earliestCursor = this.cursor;
 
135
    this.items[this.items.length] = text;
 
136
    this.cursor = this.items.length;
178
137
}
179
138
 
180
139
function historyShow()
181
140
{
182
141
    var res = "";
 
142
    if (this.cursor == -1)
 
143
    {
 
144
        res += "[]";
 
145
    }
183
146
    for (var i = 0; i < this.items.length; i++)
184
147
    {
185
148
        if (i == this.cursor)
200
163
    return res;
201
164
}
202
165
 
203
 
/* How history works
204
 
 * This is a fairly complex mechanism due to complications when editing
205
 
 * history items. We store two arrays. "items" is the permanent history of
206
 
 * each item. "edited" is a "volatile" version of items - the edits made to
207
 
 * the history between now and last time you hit "enter".
208
 
 * This is because the user can go back and edit any of the previous items,
209
 
 * and the edits are remembered until they hit enter.
210
 
 *
211
 
 * When hitting enter, the "edited" version of the currently selected item
212
 
 * replaces the "item" version of the last item in the list.
213
 
 * Then a new blank item is created, for the new line of input.
214
 
 * Lastly, all the "edited" versions are replaced with their stable versions.
215
 
 *
216
 
 * Cursor never points to an invalid location.
217
 
 */
218
166
function History()
219
167
{
220
 
    this.items = new Array("");
221
 
    this.edited = new Array("");
222
 
    this.cursor = 0;
223
 
    this.earliestCursor = 0;
 
168
    this.items = new Array();
 
169
    this.cursor = -1;
224
170
    this.up = historyUp;
225
171
    this.down = historyDown;
226
172
    this.curr = historyCurr;
227
 
    this.submit = historySubmit;
 
173
    this.add = historyAdd;
228
174
    this.show = historyShow;
229
175
}
230
176
 
231
177
var hist = new History();
232
178
 
233
 
function set_interrupt()
234
 
{
235
 
    interrupted = true;
236
 
}
237
 
 
238
 
function clear_output()
239
 
{
240
 
    var output = document.getElementById("console_output");
241
 
    while (output.firstChild)
242
 
    {
243
 
        output.removeChild(output.firstChild);
244
 
    }
245
 
}
246
 
 
247
179
/** Send a line of text to the Python server, wait for its return, and react
248
180
 * to its response by writing to the output box.
249
181
 * Also maximize the console window if not already.
250
182
 */
251
 
function console_enter_line(inputbox, which)
252
 
{
253
 
    interrupted = false;
254
 
 
255
 
    if (typeof(inputbox) == "string")
256
 
    {
257
 
        var inputline = inputbox;
258
 
        inputbox = null;
259
 
        var graytimer = null;
260
 
    }
261
 
    else
262
 
    {
263
 
        GLOBAL_inputbox = inputbox;     /* For timer */
264
 
        var inputline = inputbox.value + "\n";
265
 
        var graytimer = setTimeout("GLOBAL_inputbox.setAttribute(\"class\", "
266
 
            + "\"disabled\");", 100);
267
 
    }
268
 
    var output = document.getElementById("console_output");
269
 
    {
270
 
        // Print ">>>" span
271
 
        var span = document.createElement("span");
272
 
        span.setAttribute("class", "inputPrompt");
273
 
        span.appendChild(document.createTextNode(
274
 
              document.getElementById("console_prompt").firstChild.textContent)
275
 
                        );
276
 
        output.appendChild(span);
277
 
        // Print input line itself in a span
278
 
        var span = document.createElement("span");
279
 
        span.setAttribute("class", "inputMsg");
280
 
        span.appendChild(document.createTextNode(inputline));
281
 
        output.appendChild(span);
282
 
    }
283
 
    var args = {"key": server_key, "text":inputline};
284
 
    var callback = function(xhr)
285
 
        {
286
 
            console_response(inputbox, graytimer, inputline, xhr.responseText);
287
 
        }
288
 
    /* Disable the text box */
289
 
    if (inputbox != null)
290
 
        inputbox.setAttribute("disabled", "disabled");
291
 
    ajax_call(callback, "consoleservice", which, args, "POST");
292
 
}
293
 
 
294
 
function console_response(inputbox, graytimer, inputline, responseText)
295
 
{
296
 
    try
297
 
    {
298
 
        var res = JSON.parse(responseText);
299
 
    }
300
 
    catch (e)
301
 
    {
302
 
        alert("An internal error occurred in the python console.");
303
 
        return;
304
 
    }
305
 
    var output = document.getElementById("console_output");
 
183
function console_enter_line(inputline)
 
184
{
 
185
    /* Start the server if it hasn't already been started */
 
186
    start_server();
 
187
    var digest = hex_md5(inputline + magic);
 
188
    var args = {"host": server_host, "port": server_port,
 
189
                    "digest":digest, "text":inputline};
 
190
    var xmlhttp = ajax_call("consoleservice", "chat", args, "POST");
 
191
 
 
192
    var res = JSON.parse(xmlhttp.responseText);
 
193
    var output = document.getElementById("console_output");
 
194
    {
 
195
        var pre = document.createElement("pre");
 
196
        pre.setAttribute("class", "inputMsg");
 
197
        pre.appendChild(document.createTextNode(inputline + "\n"));
 
198
        output.appendChild(pre);
 
199
    }
306
200
    if (res.hasOwnProperty('okay'))
307
201
    {
308
202
        // Success!
309
 
        if (res.okay)
 
203
        // print out the output (res.okay[0])
 
204
        var pre = document.createElement("pre");
 
205
        pre.setAttribute("class", "outputMsg");
 
206
        pre.appendChild(document.createTextNode(res.okay[0]));
 
207
        output.appendChild(pre);
 
208
        // print out the return value (res.okay[1])
 
209
        if (res.okay[1])
310
210
        {
311
 
            output.appendChild(document.createTextNode(res.okay + "\n"));
312
 
            output.appendChild(span);
 
211
            var pre = document.createElement("pre");
 
212
            pre.setAttribute("class", "outputMsg");
 
213
            pre.appendChild(document.createTextNode(res.okay[1] + "\n"));
 
214
            output.appendChild(pre);
313
215
        }
314
216
        // set the prompt to >>>
315
 
        set_prompt(">>>");
 
217
        var prompt = document.getElementById("console_prompt");
 
218
        prompt.replaceChild(document.createTextNode(">>> "), prompt.firstChild);
316
219
    }
317
220
    else if (res.hasOwnProperty('exc'))
318
221
    {
319
222
        // Failure!
 
223
        // print out any output that came before the error
 
224
        if (res.exc[0].length > 0)
 
225
        {
 
226
            var pre = document.createElement("pre");
 
227
            pre.setAttribute("class", "outputMsg");
 
228
            pre.appendChild(document.createTextNode(res.exc[0]));
 
229
            output.appendChild(pre);
 
230
        }
 
231
 
320
232
        // print out the error message (res.exc)
321
 
        print_error(res.exc);
322
 
        
323
 
        // set the prompt to >>>
324
 
        set_prompt(">>>");
325
 
    }
326
 
    else if (res.hasOwnProperty('restart') && res.hasOwnProperty('key'))
327
 
    {
328
 
        // Server has indicated that the console should be restarted
329
 
        
330
 
        // Get the new key (host, port, magic)
331
 
        server_key = res.key;
332
 
 
333
 
        // Print a reason to explain why we'd do such a horrible thing
334
 
        // (console timeout, server error etc.)
335
 
        print_error("Console Restart: " + res.restart);
336
 
        
337
 
        // set the prompt to >>>
338
 
        set_prompt(">>>");
 
233
        var pre = document.createElement("pre");
 
234
        pre.setAttribute("class", "errorMsg");
 
235
        pre.appendChild(document.createTextNode(res.exc[1]));
 
236
        output.appendChild(pre);
339
237
    }
340
238
    else if (res.hasOwnProperty('more'))
341
239
    {
342
240
        // Need more input, so set the prompt to ...
343
 
        set_prompt("...");
344
 
    }
345
 
    else if (res.hasOwnProperty('output'))
346
 
    {
347
 
        if (res.output.length > 0)
348
 
        {
349
 
            output.appendChild(document.createTextNode(res.output));
350
 
        }
351
 
        var callback = function(xhr)
352
 
            {
353
 
                console_response(inputbox, graytimer,
354
 
                                 null, xhr.responseText);
355
 
            }
356
 
        if (interrupted)
357
 
        {
358
 
            var kind = "interrupt";
359
 
        }
360
 
        else
361
 
        {
362
 
            var kind = "chat";
363
 
        }
364
 
        var args = {"key": server_key, "text":''};
365
 
        ajax_call(callback, "consoleservice", kind, args, "POST");
366
 
 
367
 
        // Open up the console so we can see the output
368
 
        // FIXME: do we need to maximize here?
369
 
        console_maximize();
370
 
 
371
 
        /* Auto-scrolling */
372
 
        divScroll.activeScroll();
373
 
 
374
 
        // Return early, so we don't re-enable the input box.
375
 
        return;
376
 
    }
377
 
    else
378
 
    {
 
241
        var prompt = document.getElementById("console_prompt");
 
242
        prompt.replaceChild(document.createTextNode("... "), prompt.firstChild);
 
243
    }
 
244
    else {
379
245
        // assert res.hasOwnProperty('input')
380
 
        set_prompt("...");
381
 
    }
382
 
 
383
 
    if (inputbox != null)
384
 
    {
385
 
        /* Re-enable the text box */
386
 
        clearTimeout(graytimer);
387
 
        inputbox.removeAttribute("disabled");
388
 
        inputbox.removeAttribute("class");
389
 
        interrupted = false;
390
 
    }
391
 
 
 
246
        var prompt = document.getElementById("console_prompt");
 
247
        prompt.replaceChild(document.createTextNode("+++ "), prompt.firstChild);
 
248
    }
392
249
    /* Open up the console so we can see the output */
393
250
    console_maximize();
394
 
    /* Auto-scrolling */
395
 
    divScroll.activeScroll();
396
 
 
397
 
    // Focus the input box by default
398
 
    document.getElementById("console_output").focus();
399
 
    document.getElementById("console_inputText").focus();
400
251
}
401
252
 
402
253
function catch_input(key)
434
285
         */
435
286
        break;
436
287
    case 13:                /* Enter key */
437
 
        var callback = function()
438
 
        {
439
 
            /* Send the line of text to the server */
440
 
            console_enter_line(inp, "chat");
441
 
            hist.submit(inp.value);
442
 
            inp.value = hist.curr();
443
 
        }
444
 
        /* Start the server if it hasn't already been started */
445
 
        start_server(callback);
 
288
        /* Send the line of text to the server */
 
289
        console_enter_line(inp.value);
 
290
        hist.add(inp.value);
 
291
        inp.value = hist.curr();
446
292
        break;
447
293
    case 38:                /* Up arrow */
448
 
        hist.up(inp.value);
 
294
        hist.up();
449
295
        inp.value = hist.curr();
450
296
        break;
451
297
    case 40:                /* Down arrow */
452
 
        hist.down(inp.value);
 
298
        hist.down();
453
299
        inp.value = hist.curr();
454
300
        break;
455
301
    }
456
302
}
457
 
 
458
 
/** Resets the console by signalling the old console to expire and starting a 
459
 
 * new one.
460
 
 */
461
 
function console_reset()
462
 
{
463
 
    // FIXME: We show some feedback here - either disable input or at very 
464
 
    // least the reset button.
465
 
 
466
 
    // Restart the console
467
 
    if(!server_started)
468
 
    {
469
 
        start_server(null);
470
 
    }
471
 
    else
472
 
    {
473
 
        xhr = ajax_call(null, "consoleservice", "restart", {"key": server_key}, "POST");
474
 
        console_response(null, null, null, xhr.responseText);
475
 
    }
476
 
}
477
 
 
478
 
/** Prints an error line in the console **/
479
 
function print_error(error)
480
 
{ 
481
 
    var output = document.getElementById("console_output");
482
 
  
483
 
    // Create text block
484
 
    var span = document.createElement("span");
485
 
    span.setAttribute("class", "errorMsg");
486
 
    span.appendChild(document.createTextNode(error + "\n"));
487
 
    output.appendChild(span);
488
 
 
489
 
    // Autoscroll
490
 
    divScroll.activeScroll();
491
 
}
492
 
 
493
 
/** Sets the prompt text **/
494
 
function set_prompt(prompt_text)
495
 
{
496
 
    var prompt = document.getElementById("console_prompt");
497
 
    prompt.replaceChild(document.createTextNode(prompt_text + " "), prompt.firstChild);
498
 
}
499
 
 
500
 
/**** Following Code modified from ******************************************/
501
 
/**** http://radio.javaranch.com/pascarello/2006/08/17/1155837038219.html ***/
502
 
/****************************************************************************/
503
 
var chatscroll = new Object();
504
 
 
505
 
chatscroll.Pane = function(scrollContainerId)
506
 
{
507
 
    this.scrollContainerId = scrollContainerId;
508
 
}
509
 
 
510
 
chatscroll.Pane.prototype.activeScroll = function()
511
 
{
512
 
    var scrollDiv = document.getElementById(this.scrollContainerId);
513
 
    var currentHeight = 0;
514
 
        
515
 
    if (scrollDiv.scrollHeight > 0)
516
 
        currentHeight = scrollDiv.scrollHeight;
517
 
    else if (scrollDiv.offsetHeight > 0)
518
 
        currentHeight = scrollDiv.offsetHeight;
519
 
 
520
 
    scrollDiv.scrollTop = currentHeight;
521
 
 
522
 
    scrollDiv = null;
523
 
}
524
 
 
525
 
var divScroll = new chatscroll.Pane('console_output');