← 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: mattgiuca
  • Date: 2008-02-05 01:41:15 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:409
Moved www/conf and www/common to a new directory lib. This separates the "web"
part of IVLE from what is becoming less web oriented (at least from Apache's
standpoint).
Modified setup.py to install this lib directory correctly and write conf in
the right place. Also adds the lib directory to ivle.pth.

Show diffs side-by-side

added added

removed removed

Lines of Context:
www/media/common/util.js
25
25
/* Expects the following variables to have been declared by JavaScript in
26
26
 * the HTML generated by the server:
27
27
 * - root_dir
28
 
 * - public_host
29
28
 * - username
30
29
 */
31
30
 
279
278
            query_string += "&" + encodeURIComponent(arg_key) + "=" +
280
279
                encodeURIComponent(arg_val);
281
280
    }
282
 
    if (query_string != "")
 
281
    if (query_string == "")
 
282
        query_string = null;
 
283
    else
283
284
        /* Drop the first "&" */
284
285
        query_string = query_string.substr(1);
285
286
 
311
312
    if (("path" in obj) && obj.path != null)
312
313
    {
313
314
        var path = urlencode_path(obj.path.toString());
314
 
        if (url.length > 0 && path.length > 0 && path.charAt(0) != "/")
 
315
        if (url.length > 0 && path.length > 0 && path[0] != "/")
315
316
            path = "/" + path;
316
317
        url += path;
317
318
    }
320
321
    else if (("args" in obj) && obj.args != null)
321
322
        query_string = make_query_string(obj.args);
322
323
 
323
 
    if (query_string != "" && query_string != null)
 
324
    if (query_string != null)
324
325
        url += "?" + query_string;
325
326
 
326
327
    return url;
342
343
    return path;
343
344
}
344
345
 
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
 
    }
377
 
}
378
 
 
379
346
/** Given an argument map, as output in the args parameter of the return of
380
347
 * parseurl, gets the first occurence of an argument in the URL string.
381
348
 * If the argument was not found, returns null.
426
393
    {
427
394
        arg = arguments[i];
428
395
        if (arg.length == 0) continue;
429
 
        if (arg.charAt(0) == '/')
 
396
        if (arg[0] == '/')
430
397
            path = arg;
431
398
        else
432
399
        {
433
 
            if (path.length > 0 && path.charAt(path.length-1) != '/')
 
400
            if (path.length > 0 && path[path.length-1] != '/')
434
401
                path += '/';
435
402
            path += arg;
436
403
        }
491
458
function pathlist_to_path(pathlist)
492
459
{
493
460
    ret = path_join.apply(null, pathlist);
494
 
    if (ret.charAt(ret.length-1) != '/')
 
461
    if (ret[ret.length-1] != '/')
495
462
        ret += '/';
496
463
    return ret;
497
464
}
512
479
    return make_path(path_join.apply(null, arguments));
513
480
}
514
481
 
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
482
/** Given a path, gets the "basename" (the last path segment).
524
483
 */
525
484
function path_basename(path)
562
521
    arr.splice(j, i-j);
563
522
}
564
523
 
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 XMLHttpRequest call to the server.
624
 
 * Sends the XMLHttpRequest object containing the completed response to a
625
 
 * specified callback function.
 
524
/** Makes an XMLHttpRequest call to the server. Waits (synchronously) for a
 
525
 * response, and returns an XMLHttpRequest object containing the completed
 
526
 * response.
626
527
 *
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. If callback is null this is a syncronous request 
630
 
 *      otherwise this is an asynchronous request.
631
528
 * \param app IVLE app to call (such as "fileservice").
632
529
 * \param path URL path to make the request to, within the application.
633
530
 * \param args Argument object, as described in parse_url and friends.
635
532
 * \param content_type String, optional. Only applies if method is "POST".
636
533
 *      May be "application/x-www-form-urlencoded" or "multipart/form-data".
637
534
 *      Defaults to "application/x-www-form-urlencoded".
 
535
 * \return An XMLHttpRequest object containing the completed response.
638
536
 */
639
 
function ajax_call(callback, app, path, args, method, content_type)
 
537
function ajax_call(app, path, args, method, content_type)
640
538
{
641
539
    if (content_type != "multipart/form-data")
642
540
        content_type = "application/x-www-form-urlencoded";
645
543
    /* A random string, for multipart/form-data
646
544
     * (This is not checked against anywhere else, it is solely defined and
647
545
     * used within this function) */
648
 
    var boundary = random_string(20);
649
 
    var xhr = new_xmlhttprequest();
650
 
    var asyncronous = callback != null;
651
 
    if (asyncronous)
652
 
    {
653
 
        xhr.onreadystatechange = function()
654
 
            {
655
 
                if (xhr.readyState == 4)
656
 
                {
657
 
                    callback(xhr);
658
 
                }
659
 
            }
660
 
    }
 
546
    var boundary = "48234n334nu7n4n2ynonjn234t683jyh80j";
 
547
    var xhr = new XMLHttpRequest();
661
548
    if (method == "GET")
662
549
    {
663
550
        /* GET sends the args in the URL */
664
551
        url = build_url({"path": path, "args": args});
665
 
        /* open's 3rd argument = true -> asynchronous */
666
 
        xhr.open(method, url, asyncronous);
 
552
        /* open's 3rd argument = false -> SYNCHRONOUS (wait for response)
 
553
         * (No need for a callback function) */
 
554
        xhr.open(method, url, false);
667
555
        xhr.send(null);
668
556
    }
669
557
    else
670
558
    {
671
559
        /* POST sends the args in application/x-www-form-urlencoded */
672
560
        url = encodeURI(path);
673
 
        xhr.open(method, url, asyncronous);
 
561
        xhr.open(method, url, false);
674
562
        var message;
675
563
        if (content_type == "multipart/form-data")
676
564
        {
677
565
            xhr.setRequestHeader("Content-Type",
678
 
                "multipart/form-data; boundary=" + boundary);
 
566
                "multipart/form-data, boundary=" + boundary);
679
567
            message = make_multipart_formdata(args, boundary);
680
568
        }
681
569
        else
685
573
        }
686
574
        xhr.send(message);
687
575
    }
688
 
    /* Only return the XHR for syncronous requests */
689
 
    if (!asyncronous)
690
 
    { 
691
 
        return xhr;
692
 
    }
 
576
    return xhr;
693
577
}
694
578
 
695
 
/** Attempts to JSON decodes a response object
696
 
 * If a non-200 response or the JSON decode fails then returns null
697
 
 */
698
 
function decode_response(response)
699
 
{
700
 
    if (response.status == 200)
701
 
    {
702
 
        try
703
 
        {
704
 
            var responseText = response.responseText;
705
 
            return JSON.parse(responseText);
706
 
        }
707
 
        catch (e)
708
 
        {
709
 
            // Pass
710
 
        }
711
 
     }
712
 
    
713
 
     return null;
714
 
}