← 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-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/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
 
/** 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
482
/** Given a path, gets the "basename" (the last path segment).
530
483
 */
531
484
function path_basename(path)
544
497
    return str.substr(str.length - substring.length) == substring;
545
498
}
546
499
 
 
500
/** Equivalent to Python's repr.
 
501
 * Gets the JavaScript string representation.
 
502
 * Actually just calls JSON.stringify.
 
503
 */
 
504
function repr(str)
 
505
{
 
506
    return JSON.stringify(str);
 
507
}
 
508
 
547
509
/** Removes all occurences of a value from an array.
548
510
 */
549
511
Array.prototype.removeall = function(val)
559
521
    arr.splice(j, i-j);
560
522
}
561
523
 
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.
 
524
/** Makes an XMLHttpRequest call to the server. Waits (synchronously) for a
 
525
 * response, and returns an XMLHttpRequest object containing the completed
 
526
 * response.
623
527
 *
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
528
 * \param app IVLE app to call (such as "fileservice").
629
529
 * \param path URL path to make the request to, within the application.
630
530
 * \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.
 
531
 * \param method String; "GET" or "POST"
 
532
 * \param content_type String, optional. Only applies if method is "POST".
 
533
 *      May be "application/x-www-form-urlencoded" or "multipart/form-data".
633
534
 *      Defaults to "application/x-www-form-urlencoded".
 
535
 * \return An XMLHttpRequest object containing the completed response.
634
536
 */
635
 
function ajax_call(callback, app, path, args, method, content_type)
 
537
function ajax_call(app, path, args, method, content_type)
636
538
{
637
 
    if (!content_type)
 
539
    if (content_type != "multipart/form-data")
638
540
        content_type = "application/x-www-form-urlencoded";
639
541
    path = app_path(app, path);
640
542
    var url;
641
543
    /* A random string, for multipart/form-data
642
544
     * (This is not checked against anywhere else, it is solely defined and
643
545
     * 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
 
    }
 
546
    var boundary = "48234n334nu7n4n2ynonjn234t683jyh80j";
 
547
    var xhr = new XMLHttpRequest();
657
548
    if (method == "GET")
658
549
    {
659
550
        /* GET sends the args in the URL */
660
551
        url = build_url({"path": path, "args": args});
661
 
        /* open's 3rd argument = true -> asynchronous */
662
 
        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);
663
555
        xhr.send(null);
664
556
    }
665
557
    else
666
558
    {
667
 
        /* POST & PUT & PATCH sends the args in the request body */
668
 
        url = urlencode_path(path);
669
 
        xhr.open(method, url, asyncronous);
 
559
        /* POST sends the args in application/x-www-form-urlencoded */
 
560
        url = encodeURI(path);
 
561
        xhr.open(method, url, false);
670
562
        var message;
671
563
        if (content_type == "multipart/form-data")
672
564
        {
673
565
            xhr.setRequestHeader("Content-Type",
674
 
                "multipart/form-data; boundary=" + boundary);
 
566
                "multipart/form-data, boundary=" + boundary);
675
567
            message = make_multipart_formdata(args, boundary);
676
568
        }
677
 
        else if (content_type == "application/x-www-form-urlencoded")
 
569
        else
678
570
        {
679
571
            xhr.setRequestHeader("Content-Type", content_type);
680
572
            message = make_query_string(args);
681
573
        }
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
574
        xhr.send(message);
693
575
    }
694
 
    /* Only return the XHR for syncronous requests */
695
 
    if (!asyncronous)
696
 
    { 
697
 
        return xhr;
698
 
    }
 
576
    return xhr;
699
577
}
700
578
 
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
 
}