← 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-02-19 08:26:11 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:509
common.db: Rewrote user_authenticate to return 3 values (True, false, None)
    Now returns False if the password did not match, None if the password
    field is NULL (None implying a soft failure, with the possibility of
    validating against LDAP or something else).

auth.authenticate: Rewrote this module with a new plugin interface
    (as discussed with Tom Conway). Allows successive modules to try to
    authenticate the user.
    Changed the authenticate function interface: Now raises an AuthError
    when auth fails, instead of returning None.

dispatch.login: Handle new auth interface (exception catch).
    Auth is now able to provide an error message, in the exception.
    The exception message is displayed as an error to the user.

Show diffs side-by-side

added added

removed removed

Lines of Context:
www/media/console/console.js
34
34
windowpane_mode = false;
35
35
server_started = false;
36
36
 
37
 
interrupted = false;
38
 
 
39
 
 
40
 
function get_console_start_directory()
41
 
{
42
 
    if((typeof(current_path) != 'undefined') && current_file)
43
 
    {
44
 
        // We have a current_path - give a suggestion to the server
45
 
        var path;
46
 
        if (current_file.isdir)
47
 
        {
48
 
            // Browser
49
 
            return path_join("/home", current_path);
50
 
        }
51
 
        else
52
 
        {
53
 
            // Editor - need to chop off filename
54
 
            var tmp_path = current_path.split('/');
55
 
            tmp_path.pop();
56
 
            return path_join("/home", tmp_path.join('/'));
57
 
        }
58
 
    }
59
 
    else
60
 
    {
61
 
        // No current_path - let the server decide
62
 
        return '';
63
 
    }
64
 
}
65
 
 
66
37
/* Starts the console server, if it isn't already.
67
38
 * This can be called any number of times - it only starts the one server.
68
 
 * Note that this is asynchronous. It will return after signalling to start
69
 
 * the server, but there is no guarantee that it has been started yet.
70
39
 * This is a separate step from console_init, as the server is only to be
71
40
 * started once the first command is entered.
72
41
 * Does not return a value. Writes to global variables
73
42
 * server_host, and server_port.
74
 
 *
75
 
 * \param callback Function which will be called after the server has been
76
 
 * started. No parameters are passed. May be null.
77
43
 */
78
 
function start_server(callback)
 
44
function start_server()
79
45
{
80
 
    if (server_started)
81
 
    {
82
 
        callback();
83
 
        return;
84
 
    }
85
 
    var callback1 = function(xhr)
86
 
        {
87
 
            var json_text = xhr.responseText;
88
 
            try
89
 
            {
90
 
                server_key = JSON.parse(json_text).key;
91
 
                server_started = true;
92
 
                if (callback != null)
93
 
                    callback();
94
 
            }
95
 
            catch (e)
96
 
            {
97
 
                alert("An error occured when starting the IVLE console. " +
98
 
                    "Please refresh the page and try again.\n" +
99
 
                    "Details have been logged for further examination.")
100
 
            }
101
 
        }
102
 
 
103
 
    ajax_call(
104
 
        callback1, "console", "service",
105
 
        {"ivle.op": "start", "cwd": get_console_start_directory()}, 
106
 
        "POST");
 
46
    if (server_started) return;
 
47
    var xhr = ajax_call("consoleservice", "start", {}, "POST");
 
48
    var json_text = xhr.responseText;
 
49
    server_key = JSON.parse(json_text);
 
50
    server_started = true;
107
51
}
108
52
 
109
53
/** Initialises the console. All apps which import console are required to
126
70
        windowpane_mode = true;
127
71
        console_minimize();
128
72
    }
 
73
    /* TEMP: Start the server now.
 
74
     * Ultimately we want the server to start only when a line is typed, but
 
75
     * it currently does it asynchronously and doesn't start in time for the
 
76
     * first line. */
 
77
    start_server();
129
78
}
130
79
 
131
80
/** Hide the main console panel, so the console minimizes to just an input box
144
93
    if (!windowpane_mode) return;
145
94
    console_body.setAttribute("class", "windowpane maximal");
146
95
    console_filler.setAttribute("class", "windowpane maximal");
 
96
    /* Focus the input box by default */
 
97
    document.getElementById("console_inputText").focus()
147
98
}
148
99
 
149
100
/* current_text is the string currently on the command line.
246
197
 
247
198
var hist = new History();
248
199
 
249
 
function set_interrupt()
250
 
{
251
 
    interrupted = true;
252
 
}
253
 
 
254
 
function clear_output()
255
 
{
256
 
    var output = document.getElementById("console_output");
257
 
    while (output.firstChild)
258
 
    {
259
 
        output.removeChild(output.firstChild);
260
 
    }
261
 
}
262
 
 
263
200
/** Send a line of text to the Python server, wait for its return, and react
264
201
 * to its response by writing to the output box.
265
202
 * Also maximize the console window if not already.
266
203
 */
267
 
function console_enter_line(inputbox, which)
268
 
{
269
 
    interrupted = false;
270
 
 
271
 
    if (typeof(inputbox) == "string")
272
 
    {
273
 
        var inputline = inputbox + "\n";
274
 
        inputbox = null;
275
 
    }
276
 
    else
277
 
    {
278
 
        /* Disable the text box */
279
 
        inputbox.setAttribute("disabled", "disabled");
280
 
 
281
 
        var inputline = inputbox.value + "\n";
282
 
    }
283
 
    var output = document.getElementById("console_output");
284
 
    {
285
 
        // Print ">>>" span
286
 
        var span = document.createElement("span");
287
 
        span.setAttribute("class", "inputPrompt");
288
 
        span.appendChild(document.createTextNode(
289
 
              document.getElementById("console_prompt").firstChild.nodeValue)
290
 
                        );
291
 
        output.appendChild(span);
292
 
        // Print input line itself in a span
293
 
        var span = document.createElement("span");
294
 
        span.setAttribute("class", "inputMsg");
295
 
        span.appendChild(document.createTextNode(inputline));
296
 
        output.appendChild(span);
297
 
    }
298
 
    var args = {
299
 
        "ivle.op": "chat", "kind": which, "key": server_key,
300
 
        "text": inputline, "cwd": get_console_start_directory()
301
 
        };
302
 
    var callback = function(xhr)
303
 
        {
304
 
            console_response(inputbox, inputline, xhr.responseText);
305
 
        }
306
 
    ajax_call(callback, "console", "service", args, "POST");
307
 
}
308
 
 
309
 
function console_response(inputbox, inputline, responseText)
310
 
{
311
 
    try
312
 
    {
313
 
        var res = JSON.parse(responseText);
314
 
    }
315
 
    catch (e)
316
 
    {
317
 
        alert("An internal error occurred in the python console.");
318
 
        return;
319
 
    }
320
 
    var output = document.getElementById("console_output");
 
204
function console_enter_line(inputline, which)
 
205
{
 
206
    /* Start the server if it hasn't already been started */
 
207
    start_server();
 
208
    var args = {"key": server_key, "text":inputline};
 
209
    var xmlhttp = ajax_call("consoleservice", which, args, "POST");
 
210
 
 
211
    var res = JSON.parse(xmlhttp.responseText);
 
212
    var output = document.getElementById("console_output");
 
213
    {
 
214
        var pre = document.createElement("pre");
 
215
        pre.setAttribute("class", "inputMsg");
 
216
        pre.appendChild(document.createTextNode(inputline + "\n"));
 
217
        output.appendChild(pre);
 
218
    }
321
219
    if (res.hasOwnProperty('okay'))
322
220
    {
323
221
        // Success!
324
 
        if (res.okay)
 
222
        // print out the output (res.okay[0])
 
223
        var pre = document.createElement("pre");
 
224
        pre.setAttribute("class", "outputMsg");
 
225
        pre.appendChild(document.createTextNode(res.okay[0]));
 
226
        output.appendChild(pre);
 
227
        // print out the return value (res.okay[1])
 
228
        if (res.okay[1])
325
229
        {
326
 
            output.appendChild(document.createTextNode(res.okay + "\n"));
327
 
            output.appendChild(span);
 
230
            var pre = document.createElement("pre");
 
231
            pre.setAttribute("class", "outputMsg");
 
232
            pre.appendChild(document.createTextNode(res.okay[1] + "\n"));
 
233
            output.appendChild(pre);
328
234
        }
329
235
        // set the prompt to >>>
330
 
        set_prompt(">>>");
 
236
        var prompt = document.getElementById("console_prompt");
 
237
        prompt.replaceChild(document.createTextNode(">>> "), prompt.firstChild);
331
238
    }
332
239
    else if (res.hasOwnProperty('exc'))
333
240
    {
334
241
        // Failure!
 
242
        // print out any output that came before the error
 
243
        if (res.exc[0].length > 0)
 
244
        {
 
245
            var pre = document.createElement("pre");
 
246
            pre.setAttribute("class", "outputMsg");
 
247
            pre.appendChild(document.createTextNode(res.exc[0]));
 
248
            output.appendChild(pre);
 
249
        }
 
250
 
335
251
        // print out the error message (res.exc)
336
 
        print_error(res.exc);
337
 
        
338
 
        // set the prompt to >>>
339
 
        set_prompt(">>>");
340
 
    }
341
 
    else if (res.hasOwnProperty('restart') && res.hasOwnProperty('key'))
342
 
    {
343
 
        // Server has indicated that the console should be restarted
344
 
        
345
 
        // Get the new key (host, port, magic)
346
 
        server_key = res.key;
347
 
 
348
 
        // Print a reason to explain why we'd do such a horrible thing
349
 
        // (console timeout, server error etc.)
350
 
        print_error("Console Restart: " + res.restart);
351
 
        
352
 
        // set the prompt to >>>
353
 
        set_prompt(">>>");
 
252
        var pre = document.createElement("pre");
 
253
        pre.setAttribute("class", "errorMsg");
 
254
        pre.appendChild(document.createTextNode(res.exc[1]));
 
255
        output.appendChild(pre);
354
256
    }
355
257
    else if (res.hasOwnProperty('more'))
356
258
    {
357
259
        // Need more input, so set the prompt to ...
358
 
        set_prompt("...");
359
 
    }
360
 
    else if (res.hasOwnProperty('output'))
361
 
    {
362
 
        if (res.output.length > 0)
363
 
        {
364
 
            output.appendChild(document.createTextNode(res.output));
365
 
        }
366
 
        var callback = function(xhr)
367
 
            {
368
 
                console_response(inputbox, null, xhr.responseText);
369
 
            }
370
 
        if (interrupted)
371
 
        {
372
 
            var kind = "interrupt";
373
 
        }
374
 
        else
375
 
        {
376
 
            var kind = "chat";
377
 
        }
378
 
        var args = {
379
 
            "ivle.op": "chat", "kind": kind, "key": server_key,
380
 
            "text": '', "cwd": get_console_start_directory()
381
 
            };
382
 
        ajax_call(callback, "console", "service", args, "POST");
383
 
 
384
 
        // Open up the console so we can see the output
385
 
        // FIXME: do we need to maximize here?
386
 
        console_maximize();
387
 
 
388
 
        /* Auto-scrolling */
389
 
        divScroll.activeScroll();
390
 
 
391
 
        // Return early, so we don't re-enable the input box.
392
 
        return;
393
 
    }
394
 
    else
395
 
    {
 
260
        var prompt = document.getElementById("console_prompt");
 
261
        prompt.replaceChild(document.createTextNode("... "), prompt.firstChild);
 
262
    }
 
263
    else {
396
264
        // assert res.hasOwnProperty('input')
397
 
        set_prompt("...");
398
 
    }
399
 
 
400
 
    if (inputbox != null)
401
 
    {
402
 
        /* Re-enable the text box */
403
 
        inputbox.removeAttribute("disabled");
404
 
        interrupted = false;
405
 
    }
406
 
 
 
265
        var prompt = document.getElementById("console_prompt");
 
266
        prompt.replaceChild(document.createTextNode("+++ "), prompt.firstChild);
 
267
    }
407
268
    /* Open up the console so we can see the output */
408
269
    console_maximize();
409
 
    /* Auto-scrolling */
410
 
    divScroll.activeScroll();
411
 
 
412
 
    // Focus the input box by default
413
 
    document.getElementById("console_output").focus();
414
 
    document.getElementById("console_inputText").focus();
415
270
}
416
271
 
417
272
function catch_input(key)
449
304
         */
450
305
        break;
451
306
    case 13:                /* Enter key */
452
 
        var callback = function()
453
 
        {
454
 
            /* Send the line of text to the server */
455
 
            console_enter_line(inp, "chat");
456
 
            hist.submit(inp.value);
457
 
            inp.value = hist.curr();
458
 
        }
459
 
 
460
 
        /* Disable the text box. This will be redone by
461
 
         * console_enter_line, but we do it here too in case start_server
462
 
         * takes a while.
463
 
         */
464
 
        inp.setAttribute("disabled", "disabled");
465
 
        /* Start the server if it hasn't already been started */
466
 
        start_server(callback);
 
307
        /* Send the line of text to the server */
 
308
        console_enter_line(inp.value, "chat");
 
309
        hist.submit(inp.value);
 
310
        inp.value = hist.curr();
467
311
        break;
468
312
    case 38:                /* Up arrow */
469
313
        hist.up(inp.value);
470
314
        inp.value = hist.curr();
471
 
        /* Inhibit further responses to this event, or WebKit moves the
472
 
         * cursor to the start. */
473
 
        return false;
474
315
        break;
475
316
    case 40:                /* Down arrow */
476
317
        hist.down(inp.value);
477
318
        inp.value = hist.curr();
478
 
        return false;
479
319
        break;
480
320
    }
481
321
}
482
 
 
483
 
/** Resets the console by signalling the old console to expire and starting a 
484
 
 * new one.
485
 
 */
486
 
function console_reset()
487
 
{
488
 
    // FIXME: We show some feedback here - either disable input or at very 
489
 
    // least the reset button.
490
 
 
491
 
    // Restart the console
492
 
    if(!server_started)
493
 
    {
494
 
        start_server(null);
495
 
    }
496
 
    else
497
 
    {
498
 
        xhr = ajax_call(null, "console", "service", {"ivle.op": "chat", "kind": "terminate", "key": server_key, "cwd": get_console_start_directory()}, "POST");
499
 
        console_response(null, null, xhr.responseText);
500
 
    }
501
 
}
502
 
 
503
 
/** Prints an error line in the console **/
504
 
function print_error(error)
505
 
{ 
506
 
    var output = document.getElementById("console_output");
507
 
  
508
 
    // Create text block
509
 
    var span = document.createElement("span");
510
 
    span.setAttribute("class", "errorMsg");
511
 
    span.appendChild(document.createTextNode(error + "\n"));
512
 
    output.appendChild(span);
513
 
 
514
 
    // Autoscroll
515
 
    divScroll.activeScroll();
516
 
}
517
 
 
518
 
/** Sets the prompt text **/
519
 
function set_prompt(prompt_text)
520
 
{
521
 
    var prompt = document.getElementById("console_prompt");
522
 
    prompt.replaceChild(document.createTextNode(prompt_text + " "), prompt.firstChild);
523
 
}
524
 
 
525
 
/**** Following Code modified from ******************************************/
526
 
/**** http://radio.javaranch.com/pascarello/2006/08/17/1155837038219.html ***/
527
 
/****************************************************************************/
528
 
var chatscroll = new Object();
529
 
 
530
 
chatscroll.Pane = function(scrollContainerId)
531
 
{
532
 
    this.scrollContainerId = scrollContainerId;
533
 
}
534
 
 
535
 
chatscroll.Pane.prototype.activeScroll = function()
536
 
{
537
 
    var scrollDiv = document.getElementById(this.scrollContainerId);
538
 
    var currentHeight = 0;
539
 
        
540
 
    if (scrollDiv.scrollHeight > 0)
541
 
        currentHeight = scrollDiv.scrollHeight;
542
 
    else if (scrollDiv.offsetHeight > 0)
543
 
        currentHeight = scrollDiv.offsetHeight;
544
 
 
545
 
    scrollDiv.scrollTop = currentHeight;
546
 
 
547
 
    scrollDiv = null;
548
 
}
549
 
 
550
 
var divScroll = new chatscroll.Pane('console_output');