← 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: stevenbird
  • Date: 2008-02-01 03:51:56 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:368
First version of a DTD for XML problem files

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
 * - username
 
29
 */
 
30
 
25
31
/** Removes all children of a given DOM element
26
32
 * \param elem A DOM Element. Will be modified.
27
33
 */
34
40
/** Creates a DOM element with simple text inside it.
35
41
 * \param tagname String. Name of the element's tag (eg. "p").
36
42
 * \param text String. Text to be placed inside the element.
 
43
 * \param title String, optional. Tooltip for the text.
 
44
 *  (Note, title creates a span element around the text).
37
45
 * \return DOM Element object.
38
46
 */
39
 
function dom_make_text_elem(tagname, text)
 
47
function dom_make_text_elem(tagname, text, title)
40
48
{
41
49
    if (text == null) text = "";
42
50
    var elem = document.createElement(tagname);
43
 
    elem.appendChild(document.createTextNode(text));
 
51
    var textnode;
 
52
    if (title == null)
 
53
        textnode = document.createTextNode(text);
 
54
    else
 
55
    {
 
56
        textnode = document.createElement("span");
 
57
        textnode.setAttribute("title", title);
 
58
        textnode.appendChild(document.createTextNode(text));
 
59
    }
 
60
    elem.appendChild(textnode);
44
61
    return elem;
45
62
}
46
63
 
47
64
/** Creates a DOM element with hyperlinked text inside it.
48
65
 * \param tagname String. Name of the element's tag (eg. "p").
49
66
 * \param text String. Text to be placed inside the element.
 
67
 * \param title String, optional. Sets a tooltip for the link.
50
68
 * \param href String. URL the text will link to. This is a raw string,
51
69
 *  it will automatically be URL-encoded.
52
70
 * \param onclick Optional string. Will be set as the "onclick" attribute
53
71
 *  of the "a" element.
 
72
 * \param dontencode Optional boolean. If true, will not encode the href.
 
73
 *  if including query strings, you must set this to true and use build_url
 
74
 *  to escape the URI correctly.
54
75
 * \return DOM Element object.
55
76
 */
56
 
function dom_make_link_elem(tagname, text, href, onclick)
 
77
function dom_make_link_elem(tagname, text, title, href, onclick, dontencode)
57
78
{
58
79
    if (text == null) text = "";
59
80
    if (href == null) href = "";
60
81
    var elem = document.createElement(tagname);
61
82
    var link = document.createElement("a");
62
 
    link.setAttribute("href", encodeURI(href));
 
83
    if (dontencode != true)
 
84
        href = urlencode_path(href);
 
85
    link.setAttribute("href", href);
 
86
    if (title != null)
 
87
        link.setAttribute("title", title);
63
88
    if (onclick != null)
64
89
        link.setAttribute("onclick", onclick);
65
90
    link.appendChild(document.createTextNode(text));
67
92
    return elem;
68
93
}
69
94
 
 
95
/** Creates a DOM img element. All parameters are optional except src.
 
96
 * If alt (compulsory in HTML) is omitted, will be set to "".
 
97
 */
 
98
function dom_make_img(src, width, height, title, alt)
 
99
{
 
100
    var img = document.createElement("img");
 
101
    img.setAttribute("src", urlencode_path(src));
 
102
    if (width != null)
 
103
        img.setAttribute("width", width);
 
104
    if (height != null)
 
105
        img.setAttribute("height", height);
 
106
    if (title != null)
 
107
        img.setAttribute("title", title);
 
108
    if (alt == null) alt = "";
 
109
    img.setAttribute("alt", alt);
 
110
    return img;
 
111
}
 
112
 
70
113
/** Given a number of bytes, returns a string representing the file size in a
71
114
 * human-readable format.
72
115
 * eg. nice_filesize(6) -> "6 bytes"
111
154
 * args is never null, though it may be empty.
112
155
 *
113
156
 * All strings are decoded/unescaped. Reserved characters
114
 
 * (; , / ? : @ & = + * $) are not decoded except in args.
 
157
 * (; , / ? : @ & = + * $) are not decoded except in args and path.
115
158
 *
116
159
 * \param url String. A URL. To read from the current browser window, use
117
160
 *  window.location.href.
124
167
    var serverpart;
125
168
    var args;
126
169
 
127
 
    url = decodeURI(url);
128
 
 
129
170
    /* Split scheme from rest */
130
171
    index = url.indexOf("://");
131
172
    if (index < 0)
182
223
            obj.query_string = url.substr(index+1);
183
224
        }
184
225
    }
 
226
    obj.path = decodeURIComponent(obj.path);
185
227
 
186
228
    /* Split query string into arguments */
187
229
    args = {};
269
311
        url += ":" + obj.server_port.toString();
270
312
    if (("path" in obj) && obj.path != null)
271
313
    {
272
 
        var path = obj.path.toString();
 
314
        var path = urlencode_path(obj.path.toString());
273
315
        if (url.length > 0 && path.length > 0 && path[0] != "/")
274
316
            path = "/" + path;
275
317
        url += path;
276
318
    }
277
319
    if (("query_string" in obj) && obj.query_string != null)
278
 
        query_string = obj.query_string.toString();
 
320
        query_string = encodeURI(obj.query_string.toString());
279
321
    else if (("args" in obj) && obj.args != null)
280
322
        query_string = make_query_string(obj.args);
281
323
 
282
324
    if (query_string != null)
283
325
        url += "?" + query_string;
284
326
 
285
 
    return encodeURI(url);
 
327
    return url;
 
328
}
 
329
 
 
330
/** URL-encodes a path. This is a special case of URL encoding as all
 
331
 * characters *except* the slash must be encoded.
 
332
 */
 
333
function urlencode_path(path)
 
334
{
 
335
    /* Split up the path, URLEncode each segment with encodeURIComponent,
 
336
     * and rejoin.
 
337
     */
 
338
    var split = path.split('/');
 
339
    for (var i=0; i<split.length; i++)
 
340
        split[i] = encodeURIComponent(split[i]);
 
341
    path = path_join.apply(null, split);
 
342
    if (split[0] == "" && split.length > 1) path = "/" + path;
 
343
    return path;
286
344
}
287
345
 
288
346
/** Given an argument map, as output in the args parameter of the return of
330
388
function path_join(path1 /*, path2, ... */)
331
389
{
332
390
    var arg;
333
 
    path = path1;
334
 
    for (var i=1; i<arguments.length; i++)
 
391
    var path = "";
 
392
    for (var i=0; i<arguments.length; i++)
335
393
    {
336
394
        arg = arguments[i];
337
395
        if (arg.length == 0) continue;
339
397
            path = arg;
340
398
        else
341
399
        {
342
 
            if (path[path.length-1] != '/')
 
400
            if (path.length > 0 && path[path.length-1] != '/')
343
401
                path += '/';
344
402
            path += arg;
345
403
        }
370
428
    {
371
429
        /* FIXME: Encoding not supported here (should not matter if we
372
430
         * only use ASCII names */
373
 
        data += "--" + boundary + "\n"
 
431
        data += "--" + boundary + "\r\n"
374
432
            + "Content-Disposition: form-data; name=\"" + arg_key
375
 
            + "\"\n\n"
376
 
            + arg_val + "\n";
 
433
            + "\"\r\n\r\n"
 
434
            + arg_val + "\r\n";
377
435
    }
378
436
 
379
437
    for (var arg_key in args)
388
446
            extend_data(arg_key, arg_val);
389
447
    }
390
448
    /* End boundary */
391
 
    data += "--" + boundary + "--\n";
 
449
    data += "--" + boundary + "--\r\n";
392
450
 
393
451
    return data;
394
452
}
413
471
    return path_join(root_dir, path);
414
472
}
415
473
 
 
474
/** Shorthand for make_path(path_join(app, ...))
 
475
 * Creates an absolute path for a given path within a given app.
 
476
 */
 
477
function app_path(app /*,...*/)
 
478
{
 
479
    return make_path(path_join.apply(null, arguments));
 
480
}
 
481
 
 
482
/** Given a path, gets the "basename" (the last path segment).
 
483
 */
 
484
function path_basename(path)
 
485
{
 
486
    segments = path.split("/");
 
487
    if (segments[segments.length-1].length == 0)
 
488
        return segments[segments.length-2];
 
489
    else
 
490
        return segments[segments.length-1];
 
491
}
 
492
 
 
493
/** Given a string str, determines whether it ends with substr */
 
494
function endswith(str, substring)
 
495
{
 
496
    if (str.length < substring.length) return false;
 
497
    return str.substr(str.length - substring.length) == substring;
 
498
}
 
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
 
 
509
/** Removes all occurences of a value from an array.
 
510
 */
 
511
Array.prototype.removeall = function(val)
 
512
{
 
513
    var i, j;
 
514
    var arr = this;
 
515
    j = 0;
 
516
    for (i=0; i<arr.length; i++)
 
517
    {
 
518
        arr[j] = arr[i];
 
519
        if (arr[i] != val) j++;
 
520
    }
 
521
    arr.splice(j, i-j);
 
522
}
 
523
 
416
524
/** Makes an XMLHttpRequest call to the server. Waits (synchronously) for a
417
525
 * response, and returns an XMLHttpRequest object containing the completed
418
526
 * response.
430
538
{
431
539
    if (content_type != "multipart/form-data")
432
540
        content_type = "application/x-www-form-urlencoded";
433
 
    path = make_path(path_join(app, path));
 
541
    path = app_path(app, path);
434
542
    var url;
435
543
    /* A random string, for multipart/form-data
436
544
     * (This is not checked against anywhere else, it is solely defined and