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

« back to all changes in this revision

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

  • Committer: mattgiuca
  • Date: 2008-01-12 12:57:30 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:197
dispatch.html, ivle.css: Main IVLE header is now an h1/h2 pair, styled to the
    left with absolute positioning (one over the top of the other).

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
 
32
25
/** Removes all children of a given DOM element
33
26
 * \param elem A DOM Element. Will be modified.
34
27
 */
41
34
/** Creates a DOM element with simple text inside it.
42
35
 * \param tagname String. Name of the element's tag (eg. "p").
43
36
 * \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).
46
37
 * \return DOM Element object.
47
38
 */
48
 
function dom_make_text_elem(tagname, text, title)
 
39
function dom_make_text_elem(tagname, text)
49
40
{
50
41
    if (text == null) text = "";
51
42
    var elem = document.createElement(tagname);
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);
 
43
    elem.appendChild(document.createTextNode(text));
62
44
    return elem;
63
45
}
64
46
 
65
47
/** Creates a DOM element with hyperlinked text inside it.
66
48
 * \param tagname String. Name of the element's tag (eg. "p").
67
49
 * \param text String. Text to be placed inside the element.
68
 
 * \param title String, optional. Sets a tooltip for the link.
69
50
 * \param href String. URL the text will link to. This is a raw string,
70
51
 *  it will automatically be URL-encoded.
71
52
 * \param onclick Optional string. Will be set as the "onclick" attribute
72
53
 *  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.
76
54
 * \return DOM Element object.
77
55
 */
78
 
function dom_make_link_elem(tagname, text, title, href, onclick, dontencode)
 
56
function dom_make_link_elem(tagname, text, href, onclick)
79
57
{
80
58
    if (text == null) text = "";
81
59
    if (href == null) href = "";
82
60
    var elem = document.createElement(tagname);
83
61
    var link = document.createElement("a");
84
 
    if (dontencode != true)
85
 
        href = urlencode_path(href);
86
 
    link.setAttribute("href", href);
87
 
    if (title != null)
88
 
        link.setAttribute("title", title);
 
62
    link.setAttribute("href", encodeURI(href));
89
63
    if (onclick != null)
90
64
        link.setAttribute("onclick", onclick);
91
65
    link.appendChild(document.createTextNode(text));
99
73
function dom_make_img(src, width, height, title, alt)
100
74
{
101
75
    var img = document.createElement("img");
102
 
    img.setAttribute("src", urlencode_path(src));
 
76
    img.setAttribute("src", src);
103
77
    if (width != null)
104
78
        img.setAttribute("width", width);
105
79
    if (height != null)
155
129
 * args is never null, though it may be empty.
156
130
 *
157
131
 * All strings are decoded/unescaped. Reserved characters
158
 
 * (; , / ? : @ & = + * $) are not decoded except in args and path.
 
132
 * (; , / ? : @ & = + * $) are not decoded except in args.
159
133
 *
160
134
 * \param url String. A URL. To read from the current browser window, use
161
135
 *  window.location.href.
168
142
    var serverpart;
169
143
    var args;
170
144
 
 
145
    url = decodeURI(url);
 
146
 
171
147
    /* Split scheme from rest */
172
148
    index = url.indexOf("://");
173
149
    if (index < 0)
224
200
            obj.query_string = url.substr(index+1);
225
201
        }
226
202
    }
227
 
    obj.path = decodeURIComponent(obj.path);
228
203
 
229
204
    /* Split query string into arguments */
230
205
    args = {};
279
254
            query_string += "&" + encodeURIComponent(arg_key) + "=" +
280
255
                encodeURIComponent(arg_val);
281
256
    }
282
 
    if (query_string != "")
 
257
    if (query_string == "")
 
258
        query_string = null;
 
259
    else
283
260
        /* Drop the first "&" */
284
261
        query_string = query_string.substr(1);
285
262
 
310
287
        url += ":" + obj.server_port.toString();
311
288
    if (("path" in obj) && obj.path != null)
312
289
    {
313
 
        var path = urlencode_path(obj.path.toString());
314
 
        if (url.length > 0 && path.length > 0 && path.charAt(0) != "/")
 
290
        var path = obj.path.toString();
 
291
        if (url.length > 0 && path.length > 0 && path[0] != "/")
315
292
            path = "/" + path;
316
293
        url += path;
317
294
    }
318
295
    if (("query_string" in obj) && obj.query_string != null)
319
 
        query_string = encodeURI(obj.query_string.toString());
 
296
        query_string = obj.query_string.toString();
320
297
    else if (("args" in obj) && obj.args != null)
321
298
        query_string = make_query_string(obj.args);
322
299
 
323
 
    if (query_string != "" && query_string != null)
 
300
    if (query_string != null)
324
301
        url += "?" + query_string;
325
302
 
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
 
    }
 
303
    return encodeURI(url);
377
304
}
378
305
 
379
306
/** Given an argument map, as output in the args parameter of the return of
421
348
function path_join(path1 /*, path2, ... */)
422
349
{
423
350
    var arg;
424
 
    var path = "";
425
 
    for (var i=0; i<arguments.length; i++)
 
351
    path = path1;
 
352
    for (var i=1; i<arguments.length; i++)
426
353
    {
427
354
        arg = arguments[i];
428
355
        if (arg.length == 0) continue;
429
 
        if (arg.charAt(0) == '/')
 
356
        if (arg[0] == '/')
430
357
            path = arg;
431
358
        else
432
359
        {
433
 
            if (path.length > 0 && path.charAt(path.length-1) != '/')
 
360
            if (path[path.length-1] != '/')
434
361
                path += '/';
435
362
            path += arg;
436
363
        }
461
388
    {
462
389
        /* FIXME: Encoding not supported here (should not matter if we
463
390
         * only use ASCII names */
464
 
        data += "--" + boundary + "\r\n"
 
391
        data += "--" + boundary + "\n"
465
392
            + "Content-Disposition: form-data; name=\"" + arg_key
466
 
            + "\"\r\n\r\n"
467
 
            + arg_val + "\r\n";
 
393
            + "\"\n\n"
 
394
            + arg_val + "\n";
468
395
    }
469
396
 
470
397
    for (var arg_key in args)
479
406
            extend_data(arg_key, arg_val);
480
407
    }
481
408
    /* End boundary */
482
 
    data += "--" + boundary + "--\r\n";
 
409
    data += "--" + boundary + "--\n";
483
410
 
484
411
    return data;
485
412
}
491
418
function pathlist_to_path(pathlist)
492
419
{
493
420
    ret = path_join.apply(null, pathlist);
494
 
    if (ret.charAt(ret.length-1) != '/')
 
421
    if (ret[ret.length-1] != '/')
495
422
        ret += '/';
496
423
    return ret;
497
424
}
504
431
    return path_join(root_dir, path);
505
432
}
506
433
 
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
 
/** Same as app_path but creates a properly-escaped site-relative URL.
516
 
 */
517
 
function app_url(app /*,...*/)
518
 
{
519
 
    return urlencode_path(app_path.apply(null, arguments));
520
 
}
521
 
 
522
 
/** Generates an absolute URL to a public application
523
 
 */
524
 
function public_app_url(app /*,...*/)
525
 
{
526
 
    return "http://" + public_host + app_url.apply(null, arguments);
527
 
}
528
 
 
529
 
/** Given a path, gets the "basename" (the last path segment).
530
 
 */
531
 
function path_basename(path)
532
 
{
533
 
    segments = path.split("/");
534
 
    if (segments[segments.length-1].length == 0)
535
 
        return segments[segments.length-2];
536
 
    else
537
 
        return segments[segments.length-1];
538
 
}
539
 
 
540
 
/** Given a string str, determines whether it ends with substr */
541
 
function endswith(str, substring)
542
 
{
543
 
    if (str.length < substring.length) return false;
544
 
    return str.substr(str.length - substring.length) == substring;
545
 
}
546
 
 
547
 
/** Removes all occurences of a value from an array.
548
 
 */
549
 
Array.prototype.removeall = function(val)
550
 
{
551
 
    var i, j;
552
 
    var arr = this;
553
 
    j = 0;
554
 
    for (i=0; i<arr.length; i++)
555
 
    {
556
 
        arr[j] = arr[i];
557
 
        if (arr[i] != val) j++;
558
 
    }
559
 
    arr.splice(j, i-j);
560
 
}
561
 
 
562
 
/** Shallow-clones an object */
563
 
function shallow_clone_object(obj)
564
 
{
565
 
    o = {};
566
 
    for (k in obj)
567
 
        o[k] = obj[k];
568
 
    return o;
569
 
}
570
 
 
571
 
/** Returns a new XMLHttpRequest object, in a somewhat browser-agnostic
572
 
 * fashion.
573
 
 */
574
 
function new_xmlhttprequest()
575
 
{
576
 
    try
577
 
    {
578
 
        /* Real Browsers */
579
 
        return new XMLHttpRequest();
580
 
    }
581
 
    catch (e)
582
 
    {
583
 
        /* Internet Explorer */
584
 
        try
585
 
        {
586
 
            return new ActiveXObject("Msxml2.XMLHTTP");
587
 
        }
588
 
        catch (e)
589
 
        {
590
 
            try
591
 
            {
592
 
                return new ActiveXObject("Microsoft.XMLHTTP");
593
 
            }
594
 
            catch (e)
595
 
            {
596
 
                throw("Your browser does not support AJAX. "
597
 
                    + "IVLE requires a modern browser.");
598
 
            }
599
 
        }
600
 
    }
601
 
}
602
 
 
603
 
/** Creates a random string of length length,
604
 
 * consisting of alphanumeric characters.
605
 
 */
606
 
var rand_chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZ"
607
 
               + "abcdefghiklmnopqrstuvwxyz";
608
 
function random_string(length)
609
 
{
610
 
    var str = Array(length);
611
 
    var v;
612
 
    for (var i=0; i<length; i++)
613
 
    {
614
 
        v = Math.floor(Math.random() * rand_chars.length);
615
 
        str[i] = rand_chars.charAt(v);
616
 
    }
617
 
    return str.join('');
618
 
}
619
 
 
620
 
/** Makes an XMLHttpRequest call to the server.
621
 
 * Sends the XMLHttpRequest object containing the completed response to a
622
 
 * specified callback function.
 
434
/** Makes an XMLHttpRequest call to the server. Waits (synchronously) for a
 
435
 * response, and returns an XMLHttpRequest object containing the completed
 
436
 * response.
623
437
 *
624
 
 * \param callback A callback function. Will be called when the response is
625
 
 *      complete. Passed 1 parameter, an XMLHttpRequest object containing the
626
 
 *      completed response. If callback is null this is a syncronous request 
627
 
 *      otherwise this is an asynchronous request.
628
438
 * \param app IVLE app to call (such as "fileservice").
629
439
 * \param path URL path to make the request to, within the application.
630
440
 * \param args Argument object, as described in parse_url and friends.
631
 
 * \param method String; "GET", "POST", "PUT", or "PATCH"
632
 
 * \param content_type String, optional.
 
441
 * \param method String; "GET" or "POST"
 
442
 * \param content_type String, optional. Only applies if method is "POST".
 
443
 *      May be "application/x-www-form-urlencoded" or "multipart/form-data".
633
444
 *      Defaults to "application/x-www-form-urlencoded".
 
445
 * \return An XMLHttpRequest object containing the completed response.
634
446
 */
635
 
function ajax_call(callback, app, path, args, method, content_type)
 
447
function ajax_call(app, path, args, method, content_type)
636
448
{
637
 
    if (!content_type)
 
449
    if (content_type != "multipart/form-data")
638
450
        content_type = "application/x-www-form-urlencoded";
639
 
    path = app_path(app, path);
 
451
    path = make_path(path_join(app, path));
640
452
    var url;
641
453
    /* A random string, for multipart/form-data
642
454
     * (This is not checked against anywhere else, it is solely defined and
643
455
     * used within this function) */
644
 
    var boundary = random_string(20);
645
 
    var xhr = new_xmlhttprequest();
646
 
    var asyncronous = callback != null;
647
 
    if (asyncronous)
648
 
    {
649
 
        xhr.onreadystatechange = function()
650
 
            {
651
 
                if (xhr.readyState == 4)
652
 
                {
653
 
                    callback(xhr);
654
 
                }
655
 
            }
656
 
    }
 
456
    var boundary = "48234n334nu7n4n2ynonjn234t683jyh80j";
 
457
    var xhr = new XMLHttpRequest();
657
458
    if (method == "GET")
658
459
    {
659
460
        /* GET sends the args in the URL */
660
461
        url = build_url({"path": path, "args": args});
661
 
        /* open's 3rd argument = true -> asynchronous */
662
 
        xhr.open(method, url, asyncronous);
 
462
        /* open's 3rd argument = false -> SYNCHRONOUS (wait for response)
 
463
         * (No need for a callback function) */
 
464
        xhr.open(method, url, false);
663
465
        xhr.send(null);
664
466
    }
665
467
    else
666
468
    {
667
 
        /* POST & PUT & PATCH sends the args in the request body */
668
 
        url = urlencode_path(path);
669
 
        xhr.open(method, url, asyncronous);
 
469
        /* POST sends the args in application/x-www-form-urlencoded */
 
470
        url = encodeURI(path);
 
471
        xhr.open(method, url, false);
670
472
        var message;
671
473
        if (content_type == "multipart/form-data")
672
474
        {
673
475
            xhr.setRequestHeader("Content-Type",
674
 
                "multipart/form-data; boundary=" + boundary);
 
476
                "multipart/form-data, boundary=" + boundary);
675
477
            message = make_multipart_formdata(args, boundary);
676
478
        }
677
 
        else if (content_type == "application/x-www-form-urlencoded")
 
479
        else
678
480
        {
679
481
            xhr.setRequestHeader("Content-Type", content_type);
680
482
            message = make_query_string(args);
681
483
        }
682
 
        else if (content_type == "application/json")
683
 
        {
684
 
            xhr.setRequestHeader("Content-Type", content_type);
685
 
            message = JSON.stringify(args);
686
 
        }
687
 
        else
688
 
        {
689
 
            xhr.setRequestHeader("Content-Type", content_type);
690
 
            message = args;
691
 
        }
692
484
        xhr.send(message);
693
485
    }
694
 
    /* Only return the XHR for syncronous requests */
695
 
    if (!asyncronous)
696
 
    { 
697
 
        return xhr;
698
 
    }
 
486
    return xhr;
699
487
}
700
488
 
701
 
/** Attempts to JSON decodes a response object
702
 
 * If a non-200 response or the JSON decode fails then returns null
703
 
 */
704
 
function decode_response(response)
705
 
{
706
 
    if (response.status == 200)
707
 
    {
708
 
        try
709
 
        {
710
 
            var responseText = response.responseText;
711
 
            return JSON.parse(responseText);
712
 
        }
713
 
        catch (e)
714
 
        {
715
 
            // Pass
716
 
        }
717
 
     }
718
 
    
719
 
     return null;
720
 
}