← Back to branch summary

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

« back to all changes in this revision

Viewing changes to www/media/common/util.js

  • Committer: wagrant
  • Date: 2008-07-14 02:33:23 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:856
editor.js: Prompt before allowing users to navigate away from a
           modified file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
www/media/common/util.js
22
22
 * Defines some generic JavaScript utility functions.
23
23
 */
24
24
 
 
25
/* Expects the following variables to have been declared by JavaScript in
 
26
 * the HTML generated by the server:
 
27
 * - root_dir
 
28
 * - public_host
 
29
 * - username
 
30
 */
 
31
 
25
32
/** Removes all children of a given DOM element
26
33
 * \param elem A DOM Element. Will be modified.
27
34
 */
34
41
/** Creates a DOM element with simple text inside it.
35
42
 * \param tagname String. Name of the element's tag (eg. "p").
36
43
 * \param text String. Text to be placed inside the element.
 
44
 * \param title String, optional. Tooltip for the text.
 
45
 *  (Note, title creates a span element around the text).
37
46
 * \return DOM Element object.
38
47
 */
39
 
function dom_make_text_elem(tagname, text)
 
48
function dom_make_text_elem(tagname, text, title)
40
49
{
41
50
    if (text == null) text = "";
42
51
    var elem = document.createElement(tagname);
43
 
    elem.appendChild(document.createTextNode(text));
 
52
    var textnode;
 
53
    if (title == null)
 
54
        textnode = document.createTextNode(text);
 
55
    else
 
56
    {
 
57
        textnode = document.createElement("span");
 
58
        textnode.setAttribute("title", title);
 
59
        textnode.appendChild(document.createTextNode(text));
 
60
    }
 
61
    elem.appendChild(textnode);
44
62
    return elem;
45
63
}
46
64
 
47
65
/** Creates a DOM element with hyperlinked text inside it.
48
66
 * \param tagname String. Name of the element's tag (eg. "p").
49
67
 * \param text String. Text to be placed inside the element.
 
68
 * \param title String, optional. Sets a tooltip for the link.
50
69
 * \param href String. URL the text will link to. This is a raw string,
51
70
 *  it will automatically be URL-encoded.
52
71
 * \param onclick Optional string. Will be set as the "onclick" attribute
53
72
 *  of the "a" element.
 
73
 * \param dontencode Optional boolean. If true, will not encode the href.
 
74
 *  if including query strings, you must set this to true and use build_url
 
75
 *  to escape the URI correctly.
54
76
 * \return DOM Element object.
55
77
 */
56
 
function dom_make_link_elem(tagname, text, href, onclick)
 
78
function dom_make_link_elem(tagname, text, title, href, onclick, dontencode)
57
79
{
58
80
    if (text == null) text = "";
59
81
    if (href == null) href = "";
60
82
    var elem = document.createElement(tagname);
61
83
    var link = document.createElement("a");
62
 
    link.setAttribute("href", encodeURI(href));
 
84
    if (dontencode != true)
 
85
        href = urlencode_path(href);
 
86
    link.setAttribute("href", href);
 
87
    if (title != null)
 
88
        link.setAttribute("title", title);
63
89
    if (onclick != null)
64
90
        link.setAttribute("onclick", onclick);
65
91
    link.appendChild(document.createTextNode(text));
73
99
function dom_make_img(src, width, height, title, alt)
74
100
{
75
101
    var img = document.createElement("img");
76
 
    img.setAttribute("src", src);
 
102
    img.setAttribute("src", urlencode_path(src));
77
103
    if (width != null)
78
104
        img.setAttribute("width", width);
79
105
    if (height != null)
129
155
 * args is never null, though it may be empty.
130
156
 *
131
157
 * All strings are decoded/unescaped. Reserved characters
132
 
 * (; , / ? : @ & = + * $) are not decoded except in args.
 
158
 * (; , / ? : @ & = + * $) are not decoded except in args and path.
133
159
 *
134
160
 * \param url String. A URL. To read from the current browser window, use
135
161
 *  window.location.href.
142
168
    var serverpart;
143
169
    var args;
144
170
 
145
 
    url = decodeURI(url);
146
 
 
147
171
    /* Split scheme from rest */
148
172
    index = url.indexOf("://");
149
173
    if (index < 0)
200
224
            obj.query_string = url.substr(index+1);
201
225
        }
202
226
    }
 
227
    obj.path = decodeURIComponent(obj.path);
203
228
 
204
229
    /* Split query string into arguments */
205
230
    args = {};
254
279
            query_string += "&" + encodeURIComponent(arg_key) + "=" +
255
280
                encodeURIComponent(arg_val);
256
281
    }
257
 
    if (query_string == "")
258
 
        query_string = null;
259
 
    else
 
282
    if (query_string != "")
260
283
        /* Drop the first "&" */
261
284
        query_string = query_string.substr(1);
262
285
 
287
310
        url += ":" + obj.server_port.toString();
288
311
    if (("path" in obj) && obj.path != null)
289
312
    {
290
 
        var path = obj.path.toString();
291
 
        if (url.length > 0 && path.length > 0 && path[0] != "/")
 
313
        var path = urlencode_path(obj.path.toString());
 
314
        if (url.length > 0 && path.length > 0 && path.charAt(0) != "/")
292
315
            path = "/" + path;
293
316
        url += path;
294
317
    }
295
318
    if (("query_string" in obj) && obj.query_string != null)
296
 
        query_string = obj.query_string.toString();
 
319
        query_string = encodeURI(obj.query_string.toString());
297
320
    else if (("args" in obj) && obj.args != null)
298
321
        query_string = make_query_string(obj.args);
299
322
 
300
 
    if (query_string != null)
 
323
    if (query_string != "" && query_string != null)
301
324
        url += "?" + query_string;
302
325
 
303
 
    return encodeURI(url);
 
326
    return url;
 
327
}
 
328
 
 
329
/** URL-encodes a path. This is a special case of URL encoding as all
 
330
 * characters *except* the slash must be encoded.
 
331
 */
 
332
function urlencode_path(path)
 
333
{
 
334
    /* Split up the path, URLEncode each segment with encodeURIComponent,
 
335
     * and rejoin.
 
336
     */
 
337
    var split = path.split('/');
 
338
    for (var i=0; i<split.length; i++)
 
339
        split[i] = encodeURIComponent(split[i]);
 
340
    path = path_join.apply(null, split);
 
341
    if (split[0] == "" && split.length > 1) path = "/" + path;
 
342
    return path;
 
343
}
 
344
 
 
345
/** Writes a JSONable object to the cookie under a particular key
 
346
 * (JSON encoded and URL encoded).
 
347
 */
 
348
function write_cookie(key, value)
 
349
{
 
350
    var sendstr = encodeURIComponent(key) + "="
 
351
        + encodeURIComponent(JSON.stringify(value))
 
352
        + "; path=" + urlencode_path(root_dir);
 
353
    /* This actually just assigns to the key, not replacing the whole cookie
 
354
     * as it appears to. */
 
355
    document.cookie = sendstr;
 
356
}
 
357
/** Reads a cookie which has a JSONable object encoded as its value.
 
358
 * Returns the object, parsed from JSON.
 
359
 */
 
360
function read_cookie(key)
 
361
{
 
362
    var cookies = document.cookie.split(";");
 
363
    var checkstart = encodeURIComponent(key) + "=";
 
364
    var checklen = checkstart.length;
 
365
    for (var i=0; i<cookies.length; i++)
 
366
    {
 
367
        var cookie = cookies[i];
 
368
        while (cookie[0] == ' ')
 
369
            cookie = cookie.substr(1);
 
370
        if (cookie.substr(0, checklen) == checkstart)
 
371
        {
 
372
            var valstr = cookie.substr(checklen);
 
373
            valstr = decodeURIComponent(valstr);
 
374
            return JSON.parse(valstr);
 
375
        }
 
376
    }
304
377
}
305
378
 
306
379
/** Given an argument map, as output in the args parameter of the return of
348
421
function path_join(path1 /*, path2, ... */)
349
422
{
350
423
    var arg;
351
 
    path = path1;
352
 
    for (var i=1; i<arguments.length; i++)
 
424
    var path = "";
 
425
    for (var i=0; i<arguments.length; i++)
353
426
    {
354
427
        arg = arguments[i];
355
428
        if (arg.length == 0) continue;
356
 
        if (arg[0] == '/')
 
429
        if (arg.charAt(0) == '/')
357
430
            path = arg;
358
431
        else
359
432
        {
360
 
            if (path[path.length-1] != '/')
 
433
            if (path.length > 0 && path.charAt(path.length-1) != '/')
361
434
                path += '/';
362
435
            path += arg;
363
436
        }
388
461
    {
389
462
        /* FIXME: Encoding not supported here (should not matter if we
390
463
         * only use ASCII names */
391
 
        data += "--" + boundary + "\n"
 
464
        data += "--" + boundary + "\r\n"
392
465
            + "Content-Disposition: form-data; name=\"" + arg_key
393
 
            + "\"\n\n"
394
 
            + arg_val + "\n";
 
466
            + "\"\r\n\r\n"
 
467
            + arg_val + "\r\n";
395
468
    }
396
469
 
397
470
    for (var arg_key in args)
406
479
            extend_data(arg_key, arg_val);
407
480
    }
408
481
    /* End boundary */
409
 
    data += "--" + boundary + "--\n";
 
482
    data += "--" + boundary + "--\r\n";
410
483
 
411
484
    return data;
412
485
}
418
491
function pathlist_to_path(pathlist)
419
492
{
420
493
    ret = path_join.apply(null, pathlist);
421
 
    if (ret[ret.length-1] != '/')
 
494
    if (ret.charAt(ret.length-1) != '/')
422
495
        ret += '/';
423
496
    return ret;
424
497
}
431
504
    return path_join(root_dir, path);
432
505
}
433
506
 
434
 
/** Makes an XMLHttpRequest call to the server. Waits (synchronously) for a
435
 
 * response, and returns an XMLHttpRequest object containing the completed
436
 
 * response.
 
507
/** Shorthand for make_path(path_join(app, ...))
 
508
 * Creates an absolute path for a given path within a given app.
 
509
 */
 
510
function app_path(app /*,...*/)
 
511
{
 
512
    return make_path(path_join.apply(null, arguments));
 
513
}
 
514
 
 
515
/** Generates an absolute URL to a public application
 
516
 */
 
517
function public_app_path(app /*,...*/)
 
518
{
 
519
    return location.protocol + "//" + public_host
 
520
        + make_path(path_join.apply(null, arguments));
 
521
}
 
522
 
 
523
/** Given a path, gets the "basename" (the last path segment).
 
524
 */
 
525
function path_basename(path)
 
526
{
 
527
    segments = path.split("/");
 
528
    if (segments[segments.length-1].length == 0)
 
529
        return segments[segments.length-2];
 
530
    else
 
531
        return segments[segments.length-1];
 
532
}
 
533
 
 
534
/** Given a string str, determines whether it ends with substr */
 
535
function endswith(str, substring)
 
536
{
 
537
    if (str.length < substring.length) return false;
 
538
    return str.substr(str.length - substring.length) == substring;
 
539
}
 
540
 
 
541
/** Equivalent to Python's repr.
 
542
 * Gets the JavaScript string representation.
 
543
 * Actually just calls JSON.stringify.
 
544
 */
 
545
function repr(str)
 
546
{
 
547
    return JSON.stringify(str);
 
548
}
 
549
 
 
550
/** Removes all occurences of a value from an array.
 
551
 */
 
552
Array.prototype.removeall = function(val)
 
553
{
 
554
    var i, j;
 
555
    var arr = this;
 
556
    j = 0;
 
557
    for (i=0; i<arr.length; i++)
 
558
    {
 
559
        arr[j] = arr[i];
 
560
        if (arr[i] != val) j++;
 
561
    }
 
562
    arr.splice(j, i-j);
 
563
}
 
564
 
 
565
/** Shallow-clones an object */
 
566
function shallow_clone_object(obj)
 
567
{
 
568
    o = {};
 
569
    for (k in obj)
 
570
        o[k] = obj[k];
 
571
    return o;
 
572
}
 
573
 
 
574
/** Returns a new XMLHttpRequest object, in a somewhat browser-agnostic
 
575
 * fashion.
 
576
 */
 
577
function new_xmlhttprequest()
 
578
{
 
579
    try
 
580
    {
 
581
        /* Real Browsers */
 
582
        return new XMLHttpRequest();
 
583
    }
 
584
    catch (e)
 
585
    {
 
586
        /* Internet Explorer */
 
587
        try
 
588
        {
 
589
            return new ActiveXObject("Msxml2.XMLHTTP");
 
590
        }
 
591
        catch (e)
 
592
        {
 
593
            try
 
594
            {
 
595
                return new ActiveXObject("Microsoft.XMLHTTP");
 
596
            }
 
597
            catch (e)
 
598
            {
 
599
                throw("Your browser does not support AJAX. "
 
600
                    + "IVLE requires a modern browser.");
 
601
            }
 
602
        }
 
603
    }
 
604
}
 
605
 
 
606
/** Creates a random string of length length,
 
607
 * consisting of alphanumeric characters.
 
608
 */
 
609
var rand_chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZ"
 
610
               + "abcdefghiklmnopqrstuvwxyz";
 
611
function random_string(length)
 
612
{
 
613
    var str = Array(length);
 
614
    var v;
 
615
    for (var i=0; i<length; i++)
 
616
    {
 
617
        v = Math.floor(Math.random() * rand_chars.length);
 
618
        str[i] = rand_chars.charAt(v);
 
619
    }
 
620
    return str.join('');
 
621
}
 
622
 
 
623
/** Makes an asynchronous XMLHttpRequest call to the server.
 
624
 * Sends the XMLHttpRequest object containing the completed response to a
 
625
 * specified callback function.
437
626
 *
 
627
 * \param callback A callback function. Will be called when the response is
 
628
 *      complete. Passed 1 parameter, an XMLHttpRequest object containing the
 
629
 *      completed response.
438
630
 * \param app IVLE app to call (such as "fileservice").
439
631
 * \param path URL path to make the request to, within the application.
440
632
 * \param args Argument object, as described in parse_url and friends.
442
634
 * \param content_type String, optional. Only applies if method is "POST".
443
635
 *      May be "application/x-www-form-urlencoded" or "multipart/form-data".
444
636
 *      Defaults to "application/x-www-form-urlencoded".
445
 
 * \return An XMLHttpRequest object containing the completed response.
446
637
 */
447
 
function ajax_call(app, path, args, method, content_type)
 
638
function ajax_call(callback, app, path, args, method, content_type)
448
639
{
449
640
    if (content_type != "multipart/form-data")
450
641
        content_type = "application/x-www-form-urlencoded";
451
 
    path = make_path(path_join(app, path));
 
642
    path = app_path(app, path);
452
643
    var url;
453
644
    /* A random string, for multipart/form-data
454
645
     * (This is not checked against anywhere else, it is solely defined and
455
646
     * used within this function) */
456
 
    var boundary = "48234n334nu7n4n2ynonjn234t683jyh80j";
457
 
    var xhr = new XMLHttpRequest();
 
647
    var boundary = random_string(20);
 
648
    var xhr = new_xmlhttprequest();
 
649
    xhr.onreadystatechange = function()
 
650
        {
 
651
            if (xhr.readyState == 4)
 
652
            {
 
653
                callback(xhr);
 
654
            }
 
655
        }
458
656
    if (method == "GET")
459
657
    {
460
658
        /* GET sends the args in the URL */
461
659
        url = build_url({"path": path, "args": args});
462
 
        /* open's 3rd argument = false -> SYNCHRONOUS (wait for response)
463
 
         * (No need for a callback function) */
464
 
        xhr.open(method, url, false);
 
660
        /* open's 3rd argument = true -> asynchronous */
 
661
        xhr.open(method, url, true);
465
662
        xhr.send(null);
466
663
    }
467
664
    else
468
665
    {
469
666
        /* POST sends the args in application/x-www-form-urlencoded */
470
667
        url = encodeURI(path);
471
 
        xhr.open(method, url, false);
 
668
        xhr.open(method, url, true);
472
669
        var message;
473
670
        if (content_type == "multipart/form-data")
474
671
        {
475
672
            xhr.setRequestHeader("Content-Type",
476
 
                "multipart/form-data, boundary=" + boundary);
 
673
                "multipart/form-data; boundary=" + boundary);
477
674
            message = make_multipart_formdata(args, boundary);
478
675
        }
479
676
        else
483
680
        }
484
681
        xhr.send(message);
485
682
    }
486
 
    return xhr;
487
683
}
488
684