← 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-16 22:11:01 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:235
listing.js: Added sorting functions and a bit of infrastructure to facilitate
this. (A little buggy at the moment).

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
 
70
69
 *  it will automatically be URL-encoded.
71
70
 * \param onclick Optional string. Will be set as the "onclick" attribute
72
71
 *  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
72
 * \return DOM Element object.
77
73
 */
78
 
function dom_make_link_elem(tagname, text, title, href, onclick, dontencode)
 
74
function dom_make_link_elem(tagname, text, title, href, onclick)
79
75
{
80
76
    if (text == null) text = "";
81
77
    if (href == null) href = "";
82
78
    var elem = document.createElement(tagname);
83
79
    var link = document.createElement("a");
84
 
    if (dontencode != true)
85
 
        href = urlencode_path(href);
86
 
    link.setAttribute("href", href);
 
80
    link.setAttribute("href", urlencode_path(href));
87
81
    if (title != null)
88
82
        link.setAttribute("title", title);
89
83
    if (onclick != null)
279
273
            query_string += "&" + encodeURIComponent(arg_key) + "=" +
280
274
                encodeURIComponent(arg_val);
281
275
    }
282
 
    if (query_string != "")
 
276
    if (query_string == "")
 
277
        query_string = null;
 
278
    else
283
279
        /* Drop the first "&" */
284
280
        query_string = query_string.substr(1);
285
281
 
311
307
    if (("path" in obj) && obj.path != null)
312
308
    {
313
309
        var path = urlencode_path(obj.path.toString());
314
 
        if (url.length > 0 && path.length > 0 && path.charAt(0) != "/")
 
310
        if (url.length > 0 && path.length > 0 && path[0] != "/")
315
311
            path = "/" + path;
316
312
        url += path;
317
313
    }
320
316
    else if (("args" in obj) && obj.args != null)
321
317
        query_string = make_query_string(obj.args);
322
318
 
323
 
    if (query_string != "" && query_string != null)
 
319
    if (query_string != null)
324
320
        url += "?" + query_string;
325
321
 
326
322
    return url;
342
338
    return path;
343
339
}
344
340
 
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
341
/** Given an argument map, as output in the args parameter of the return of
380
342
 * parseurl, gets the first occurence of an argument in the URL string.
381
343
 * If the argument was not found, returns null.
426
388
    {
427
389
        arg = arguments[i];
428
390
        if (arg.length == 0) continue;
429
 
        if (arg.charAt(0) == '/')
 
391
        if (arg[0] == '/')
430
392
            path = arg;
431
393
        else
432
394
        {
433
 
            if (path.length > 0 && path.charAt(path.length-1) != '/')
 
395
            if (path.length > 0 && path[path.length-1] != '/')
434
396
                path += '/';
435
397
            path += arg;
436
398
        }
461
423
    {
462
424
        /* FIXME: Encoding not supported here (should not matter if we
463
425
         * only use ASCII names */
464
 
        data += "--" + boundary + "\r\n"
 
426
        data += "--" + boundary + "\n"
465
427
            + "Content-Disposition: form-data; name=\"" + arg_key
466
 
            + "\"\r\n\r\n"
467
 
            + arg_val + "\r\n";
 
428
            + "\"\n\n"
 
429
            + arg_val + "\n";
468
430
    }
469
431
 
470
432
    for (var arg_key in args)
479
441
            extend_data(arg_key, arg_val);
480
442
    }
481
443
    /* End boundary */
482
 
    data += "--" + boundary + "--\r\n";
 
444
    data += "--" + boundary + "--\n";
483
445
 
484
446
    return data;
485
447
}
491
453
function pathlist_to_path(pathlist)
492
454
{
493
455
    ret = path_join.apply(null, pathlist);
494
 
    if (ret.charAt(ret.length-1) != '/')
 
456
    if (ret[ret.length-1] != '/')
495
457
        ret += '/';
496
458
    return ret;
497
459
}
512
474
    return make_path(path_join.apply(null, arguments));
513
475
}
514
476
 
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
477
/** Given a path, gets the "basename" (the last path segment).
524
478
 */
525
479
function path_basename(path)
538
492
    return str.substr(str.length - substring.length) == substring;
539
493
}
540
494
 
541
 
/** Removes all occurences of a value from an array.
542
 
 */
543
 
Array.prototype.removeall = function(val)
544
 
{
545
 
    var i, j;
546
 
    var arr = this;
547
 
    j = 0;
548
 
    for (i=0; i<arr.length; i++)
549
 
    {
550
 
        arr[j] = arr[i];
551
 
        if (arr[i] != val) j++;
552
 
    }
553
 
    arr.splice(j, i-j);
554
 
}
555
 
 
556
 
/** Shallow-clones an object */
557
 
function shallow_clone_object(obj)
558
 
{
559
 
    o = {};
560
 
    for (k in obj)
561
 
        o[k] = obj[k];
562
 
    return o;
563
 
}
564
 
 
565
 
/** Returns a new XMLHttpRequest object, in a somewhat browser-agnostic
566
 
 * fashion.
567
 
 */
568
 
function new_xmlhttprequest()
569
 
{
570
 
    try
571
 
    {
572
 
        /* Real Browsers */
573
 
        return new XMLHttpRequest();
574
 
    }
575
 
    catch (e)
576
 
    {
577
 
        /* Internet Explorer */
578
 
        try
579
 
        {
580
 
            return new ActiveXObject("Msxml2.XMLHTTP");
581
 
        }
582
 
        catch (e)
583
 
        {
584
 
            try
585
 
            {
586
 
                return new ActiveXObject("Microsoft.XMLHTTP");
587
 
            }
588
 
            catch (e)
589
 
            {
590
 
                throw("Your browser does not support AJAX. "
591
 
                    + "IVLE requires a modern browser.");
592
 
            }
593
 
        }
594
 
    }
595
 
}
596
 
 
597
 
/** Creates a random string of length length,
598
 
 * consisting of alphanumeric characters.
599
 
 */
600
 
var rand_chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZ"
601
 
               + "abcdefghiklmnopqrstuvwxyz";
602
 
function random_string(length)
603
 
{
604
 
    var str = Array(length);
605
 
    var v;
606
 
    for (var i=0; i<length; i++)
607
 
    {
608
 
        v = Math.floor(Math.random() * rand_chars.length);
609
 
        str[i] = rand_chars.charAt(v);
610
 
    }
611
 
    return str.join('');
612
 
}
613
 
 
614
 
/** Makes an XMLHttpRequest call to the server.
615
 
 * Sends the XMLHttpRequest object containing the completed response to a
616
 
 * specified callback function.
 
495
/** Equivalent to Python's repr.
 
496
 * Gets the JavaScript string representation.
 
497
 * Actually just calls JSON.stringify.
 
498
 */
 
499
function repr(str)
 
500
{
 
501
    return JSON.stringify(str);
 
502
}
 
503
 
 
504
/** Makes an XMLHttpRequest call to the server. Waits (synchronously) for a
 
505
 * response, and returns an XMLHttpRequest object containing the completed
 
506
 * response.
617
507
 *
618
 
 * \param callback A callback function. Will be called when the response is
619
 
 *      complete. Passed 1 parameter, an XMLHttpRequest object containing the
620
 
 *      completed response. If callback is null this is a syncronous request 
621
 
 *      otherwise this is an asynchronous request.
622
508
 * \param app IVLE app to call (such as "fileservice").
623
509
 * \param path URL path to make the request to, within the application.
624
510
 * \param args Argument object, as described in parse_url and friends.
625
 
 * \param method String; "GET", "POST", "PUT", or "PATCH"
626
 
 * \param content_type String, optional.
 
511
 * \param method String; "GET" or "POST"
 
512
 * \param content_type String, optional. Only applies if method is "POST".
 
513
 *      May be "application/x-www-form-urlencoded" or "multipart/form-data".
627
514
 *      Defaults to "application/x-www-form-urlencoded".
 
515
 * \return An XMLHttpRequest object containing the completed response.
628
516
 */
629
 
function ajax_call(callback, app, path, args, method, content_type)
 
517
function ajax_call(app, path, args, method, content_type)
630
518
{
631
 
    if (!content_type)
 
519
    if (content_type != "multipart/form-data")
632
520
        content_type = "application/x-www-form-urlencoded";
633
521
    path = app_path(app, path);
634
522
    var url;
635
523
    /* A random string, for multipart/form-data
636
524
     * (This is not checked against anywhere else, it is solely defined and
637
525
     * used within this function) */
638
 
    var boundary = random_string(20);
639
 
    var xhr = new_xmlhttprequest();
640
 
    var asyncronous = callback != null;
641
 
    if (asyncronous)
642
 
    {
643
 
        xhr.onreadystatechange = function()
644
 
            {
645
 
                if (xhr.readyState == 4)
646
 
                {
647
 
                    callback(xhr);
648
 
                }
649
 
            }
650
 
    }
 
526
    var boundary = "48234n334nu7n4n2ynonjn234t683jyh80j";
 
527
    var xhr = new XMLHttpRequest();
651
528
    if (method == "GET")
652
529
    {
653
530
        /* GET sends the args in the URL */
654
531
        url = build_url({"path": path, "args": args});
655
 
        /* open's 3rd argument = true -> asynchronous */
656
 
        xhr.open(method, url, asyncronous);
 
532
        /* open's 3rd argument = false -> SYNCHRONOUS (wait for response)
 
533
         * (No need for a callback function) */
 
534
        xhr.open(method, url, false);
657
535
        xhr.send(null);
658
536
    }
659
537
    else
660
538
    {
661
 
        /* POST & PUT & PATCH sends the args in the request body */
 
539
        /* POST sends the args in application/x-www-form-urlencoded */
662
540
        url = encodeURI(path);
663
 
        xhr.open(method, url, asyncronous);
 
541
        xhr.open(method, url, false);
664
542
        var message;
665
543
        if (content_type == "multipart/form-data")
666
544
        {
667
545
            xhr.setRequestHeader("Content-Type",
668
 
                "multipart/form-data; boundary=" + boundary);
 
546
                "multipart/form-data, boundary=" + boundary);
669
547
            message = make_multipart_formdata(args, boundary);
670
548
        }
671
 
        else if (content_type == "application/x-www-form-urlencoded")
 
549
        else
672
550
        {
673
551
            xhr.setRequestHeader("Content-Type", content_type);
674
552
            message = make_query_string(args);
675
553
        }
676
 
        else if (content_type == "application/json")
677
 
        {
678
 
            xhr.setRequestHeader("Content-Type", content_type);
679
 
            message = JSON.stringify(args);
680
 
        }
681
 
        else
682
 
        {
683
 
            xhr.setRequestHeader("Content-Type", content_type);
684
 
            message = args;
685
 
        }
686
554
        xhr.send(message);
687
555
    }
688
 
    /* Only return the XHR for syncronous requests */
689
 
    if (!asyncronous)
690
 
    { 
691
 
        return xhr;
692
 
    }
 
556
    return xhr;
693
557
}
694
558
 
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
 
}