← 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-12 16:19:19 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:204
browser.js: Now correctly writes file size.

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
{
 
49
    if (text == null) text = "";
41
50
    var elem = document.createElement(tagname);
42
 
    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);
43
61
    return elem;
44
62
}
45
63
 
46
64
/** Creates a DOM element with hyperlinked text inside it.
47
65
 * \param tagname String. Name of the element's tag (eg. "p").
48
66
 * \param text String. Text to be placed inside the element.
 
67
 * \param title String, optional. Sets a tooltip for the link.
49
68
 * \param href String. URL the text will link to. This is a raw string,
50
69
 *  it will automatically be URL-encoded.
51
70
 * \param onclick Optional string. Will be set as the "onclick" attribute
52
71
 *  of the "a" element.
53
72
 * \return DOM Element object.
54
73
 */
55
 
function dom_make_link_elem(tagname, text, href, onclick)
 
74
function dom_make_link_elem(tagname, text, title, href, onclick)
56
75
{
 
76
    if (text == null) text = "";
 
77
    if (href == null) href = "";
57
78
    var elem = document.createElement(tagname);
58
79
    var link = document.createElement("a");
59
80
    link.setAttribute("href", encodeURI(href));
 
81
    if (title != null)
 
82
        link.setAttribute("title", title);
60
83
    if (onclick != null)
61
84
        link.setAttribute("onclick", onclick);
62
85
    link.appendChild(document.createTextNode(text));
64
87
    return elem;
65
88
}
66
89
 
67
 
/** Converts a list of directories into a path name, with a slash at the end.
68
 
 * \param pathlist List of strings.
 
90
/** Creates a DOM img element. All parameters are optional except src.
 
91
 * If alt (compulsory in HTML) is omitted, will be set to "".
 
92
 */
 
93
function dom_make_img(src, width, height, title, alt)
 
94
{
 
95
    var img = document.createElement("img");
 
96
    img.setAttribute("src", src);
 
97
    if (width != null)
 
98
        img.setAttribute("width", width);
 
99
    if (height != null)
 
100
        img.setAttribute("height", height);
 
101
    if (title != null)
 
102
        img.setAttribute("title", title);
 
103
    if (alt == null) alt = "";
 
104
    img.setAttribute("alt", alt);
 
105
    return img;
 
106
}
 
107
 
 
108
/** Given a number of bytes, returns a string representing the file size in a
 
109
 * human-readable format.
 
110
 * eg. nice_filesize(6) -> "6 bytes"
 
111
 *     nice_filesize(81275) -> "79.4 kB"
 
112
 *     nice_filesize(13498346) -> "12.9 MB"
 
113
 * \param bytes Number of bytes. Must be an integer.
69
114
 * \return String.
70
115
 */
71
 
function pathlist_to_path(pathlist)
 
116
function nice_filesize(bytes)
72
117
{
73
 
    ret = "";
74
 
    for (var i=0; i<pathlist.length; i++)
75
 
    {
76
 
        ret += pathlist[i] + "/";
77
 
    }
78
 
    return ret;
 
118
    if (bytes == null) return "";
 
119
    var size;
 
120
    if (bytes < 1024)
 
121
        return bytes.toString() + " B";
 
122
    size = bytes / 1024;
 
123
    if (size < 1024)
 
124
        return size.toFixed(1) + " kB";
 
125
    size = size / 1024;
 
126
    if (size < 1024)
 
127
        return size.toFixed(1) + " MB";
 
128
    size = size / 1024;
 
129
    return size.toFixed(1) + " GB";
79
130
}
80
131
 
81
132
/** Given a URL, returns an object containing a number of attributes
97
148
 * whose names appear multiple times.
98
149
 * args is never null, though it may be empty.
99
150
 *
100
 
 * The args strings are decoded from URL encoding form. Other strings are left
101
 
 * in raw URL form.
 
151
 * All strings are decoded/unescaped. Reserved characters
 
152
 * (; , / ? : @ & = + * $) are not decoded except in args.
102
153
 *
103
154
 * \param url String. A URL. To read from the current browser window, use
104
155
 *  window.location.href.
111
162
    var serverpart;
112
163
    var args;
113
164
 
 
165
    url = decodeURI(url);
 
166
 
114
167
    /* Split scheme from rest */
115
168
    index = url.indexOf("://");
116
169
    if (index < 0)
131
184
    else
132
185
    {
133
186
        serverpart = url.substr(0, index);
134
 
        url = url.substr(index+1);
 
187
        url = url.substr(index);
135
188
    }
136
189
 
137
190
    /* Split server name from port */
182
235
            /* Ignore malformed args */
183
236
            if (index >= 0)
184
237
            {
185
 
                arg_key = decodeURI(arg_str.substr(0, index));
186
 
                arg_val = decodeURI(arg_str.substr(index+1));
 
238
                arg_key = decodeURIComponent(arg_str.substr(0, index));
 
239
                arg_val = decodeURIComponent(arg_str.substr(index+1));
187
240
                if (arg_key in args)
188
241
                {
189
242
                    /* Collision - make an array */
202
255
    return obj;
203
256
}
204
257
 
 
258
/** Builds a query_string from an args object. Encodes the arguments.
 
259
 * \param args Args object as described in parse_url.
 
260
 * \return Query string portion of a URL.
 
261
 */
 
262
function make_query_string(args)
 
263
{
 
264
    var query_string = "";
 
265
    var arg_val;
 
266
    for (var arg_key in args)
 
267
    {
 
268
        arg_val = args[arg_key];
 
269
        if (arg_val instanceof Array)
 
270
            for (var i=0; i<arg_val.length; i++)
 
271
                query_string += "&" + encodeURIComponent(arg_key) + "=" +
 
272
                    encodeURIComponent(arg_val[i]);
 
273
        else
 
274
            query_string += "&" + encodeURIComponent(arg_key) + "=" +
 
275
                encodeURIComponent(arg_val);
 
276
    }
 
277
    if (query_string == "")
 
278
        query_string = null;
 
279
    else
 
280
        /* Drop the first "&" */
 
281
        query_string = query_string.substr(1);
 
282
 
 
283
    return query_string;
 
284
}
 
285
 
205
286
/** Given an object exactly of the form described for the output of parseurl,
206
 
 * returns a URL string built from those parameters.
 
287
 * returns a URL string built from those parameters. The URL is properly
 
288
 * encoded.
207
289
 * parseurl and buildurl are strict inverses of each other.
208
290
 * Note that either query_string or args may be supplied. If both are
209
291
 * supplied, query_string is preferred (because it keeps the argument order).
212
294
 * \param obj Object as returned by parseurl.
213
295
 * \return String, a URL.
214
296
 */
215
 
function buildurl(obj)
 
297
function build_url(obj)
216
298
{
217
299
    var url = "";
218
300
    var query_string = null;
219
301
 
220
 
    if (!("scheme" in obj) || obj.scheme != null)
 
302
    if (("scheme" in obj) && obj.scheme != null)
221
303
        url = obj.scheme.toString() + "://";
222
 
    if (!("server_name" in obj) || obj.server_name != null)
 
304
    if (("server_name" in obj) && obj.server_name != null)
223
305
        url += obj.server_name.toString();
224
 
    if (!("server_port" in obj) || obj.server_port != null)
 
306
    if (("server_port" in obj) && obj.server_port != null)
225
307
        url += ":" + obj.server_port.toString();
226
 
    if (!("path" in obj) || obj.path != null)
 
308
    if (("path" in obj) && obj.path != null)
227
309
    {
228
310
        var path = obj.path.toString();
229
 
        if (path.length > 0 && path[0] != "/")
 
311
        if (url.length > 0 && path.length > 0 && path[0] != "/")
230
312
            path = "/" + path;
231
313
        url += path;
232
314
    }
233
 
    if (!("query_string" in obj) || obj.query_string != null)
 
315
    if (("query_string" in obj) && obj.query_string != null)
234
316
        query_string = obj.query_string.toString();
235
 
    else if (!("args" in obj) || obj.args != null)
236
 
    {
237
 
        query_string = "";
238
 
        var arg_val;
239
 
        for (var arg_key in obj.args)
240
 
        {
241
 
            arg_val = obj.args[arg_key];
242
 
            if (arg_val instanceof Array)
243
 
                for (var i=0; i<arg_val.length; i++)
244
 
                    query_string += "&" + encodeURI(arg_key) + "=" +
245
 
                        encodeURI(arg_val[i]);
246
 
            else
247
 
                query_string += "&" + encodeURI(arg_key) + "=" +
248
 
                    encodeURI(arg_val);
249
 
   
250
 
        }
251
 
        if (query_string == "")
252
 
            query_string = null;
253
 
        else
254
 
            /* Drop the first "&" */
255
 
            query_string = query_string.substr(1);
256
 
    }
 
317
    else if (("args" in obj) && obj.args != null)
 
318
        query_string = make_query_string(obj.args);
257
319
 
258
320
    if (query_string != null)
259
321
        url += "?" + query_string;
260
322
 
261
 
    return url;
 
323
    return encodeURI(url);
262
324
}
263
325
 
264
326
/** Given an argument map, as output in the args parameter of the return of
300
362
    else
301
363
        return [r];
302
364
}
 
365
 
 
366
/** Joins one or more paths together. Accepts 1 or more arguments.
 
367
 */
 
368
function path_join(path1 /*, path2, ... */)
 
369
{
 
370
    var arg;
 
371
    var path = "";
 
372
    for (var i=0; i<arguments.length; i++)
 
373
    {
 
374
        arg = arguments[i];
 
375
        if (arg.length == 0) continue;
 
376
        if (arg[0] == '/')
 
377
            path = arg;
 
378
        else
 
379
        {
 
380
            if (path.length > 0 && path[path.length-1] != '/')
 
381
                path += '/';
 
382
            path += arg;
 
383
        }
 
384
    }
 
385
    return path;
 
386
}
 
387
 
 
388
 
 
389
/** Builds a multipart_formdata string from an args object. Similar to
 
390
 * make_query_string, but it returns data of type "multipart/form-data"
 
391
 * instead of "application/x-www-form-urlencoded". This is good for
 
392
 * encoding large strings such as text objects from the editor.
 
393
 * Should be written with a Content-Type of
 
394
 * "multipart/form-data, boundary=<boundary>".
 
395
 * All fields are sent with a Content-Type of text/plain.
 
396
 * \param args Args object as described in parse_url.
 
397
 * \param boundary Random "magic" string which DOES NOT appear in any of
 
398
 *  the argument values. This should match the "boundary=" value written to
 
399
 *  the Content-Type header.
 
400
 * \return String in multipart/form-data format.
 
401
 */
 
402
function make_multipart_formdata(args, boundary)
 
403
{
 
404
    var data = "";
 
405
    var arg_val;
 
406
    /* Mutates data */
 
407
    var extend_data = function(arg_key, arg_val)
 
408
    {
 
409
        /* FIXME: Encoding not supported here (should not matter if we
 
410
         * only use ASCII names */
 
411
        data += "--" + boundary + "\n"
 
412
            + "Content-Disposition: form-data; name=\"" + arg_key
 
413
            + "\"\n\n"
 
414
            + arg_val + "\n";
 
415
    }
 
416
 
 
417
    for (var arg_key in args)
 
418
    {
 
419
        arg_val = args[arg_key];
 
420
        if (arg_val instanceof Array)
 
421
            for (var i=0; i<arg_val.length; i++)
 
422
            {
 
423
                extend_data(arg_key, arg_val[i]);
 
424
            }
 
425
        else
 
426
            extend_data(arg_key, arg_val);
 
427
    }
 
428
    /* End boundary */
 
429
    data += "--" + boundary + "--\n";
 
430
 
 
431
    return data;
 
432
}
 
433
 
 
434
/** Converts a list of directories into a path name, with a slash at the end.
 
435
 * \param pathlist List of strings.
 
436
 * \return String.
 
437
 */
 
438
function pathlist_to_path(pathlist)
 
439
{
 
440
    ret = path_join.apply(null, pathlist);
 
441
    if (ret[ret.length-1] != '/')
 
442
        ret += '/';
 
443
    return ret;
 
444
}
 
445
 
 
446
/** Given a path relative to the IVLE root, gives a path relative to
 
447
 * the site root.
 
448
 */
 
449
function make_path(path)
 
450
{
 
451
    return path_join(root_dir, path);
 
452
}
 
453
 
 
454
/** Makes an XMLHttpRequest call to the server. Waits (synchronously) for a
 
455
 * response, and returns an XMLHttpRequest object containing the completed
 
456
 * response.
 
457
 *
 
458
 * \param app IVLE app to call (such as "fileservice").
 
459
 * \param path URL path to make the request to, within the application.
 
460
 * \param args Argument object, as described in parse_url and friends.
 
461
 * \param method String; "GET" or "POST"
 
462
 * \param content_type String, optional. Only applies if method is "POST".
 
463
 *      May be "application/x-www-form-urlencoded" or "multipart/form-data".
 
464
 *      Defaults to "application/x-www-form-urlencoded".
 
465
 * \return An XMLHttpRequest object containing the completed response.
 
466
 */
 
467
function ajax_call(app, path, args, method, content_type)
 
468
{
 
469
    if (content_type != "multipart/form-data")
 
470
        content_type = "application/x-www-form-urlencoded";
 
471
    path = make_path(path_join(app, path));
 
472
    var url;
 
473
    /* A random string, for multipart/form-data
 
474
     * (This is not checked against anywhere else, it is solely defined and
 
475
     * used within this function) */
 
476
    var boundary = "48234n334nu7n4n2ynonjn234t683jyh80j";
 
477
    var xhr = new XMLHttpRequest();
 
478
    if (method == "GET")
 
479
    {
 
480
        /* GET sends the args in the URL */
 
481
        url = build_url({"path": path, "args": args});
 
482
        /* open's 3rd argument = false -> SYNCHRONOUS (wait for response)
 
483
         * (No need for a callback function) */
 
484
        xhr.open(method, url, false);
 
485
        xhr.send(null);
 
486
    }
 
487
    else
 
488
    {
 
489
        /* POST sends the args in application/x-www-form-urlencoded */
 
490
        url = encodeURI(path);
 
491
        xhr.open(method, url, false);
 
492
        var message;
 
493
        if (content_type == "multipart/form-data")
 
494
        {
 
495
            xhr.setRequestHeader("Content-Type",
 
496
                "multipart/form-data, boundary=" + boundary);
 
497
            message = make_multipart_formdata(args, boundary);
 
498
        }
 
499
        else
 
500
        {
 
501
            xhr.setRequestHeader("Content-Type", content_type);
 
502
            message = make_query_string(args);
 
503
        }
 
504
        xhr.send(message);
 
505
    }
 
506
    return xhr;
 
507
}
 
508