← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to www/media/browser/browser.js

  • Committer: mattgiuca
  • Date: 2008-01-12 15:35:53 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:201
Added "test" directory.
Added make_date_test.py, a short script I wrote to test the date format
algorithm committed in the previous revision.

Show diffs side-by-side

added added

removed removed

Lines of Context:
www/media/browser/browser.js
22
22
 
23
23
/* Url names for apps */
24
24
this_app = "files";
25
 
edit_app = "edit";
26
25
service_app = "fileservice";
27
 
serve_app = "serve";
28
 
download_app = "download";
29
26
 
30
27
/* Mapping MIME types onto handlers.
31
28
 * "text" : When navigating to a text file, the text editor is opened.
43
40
    "application/x-javascript" : "text",
44
41
    "application/javascript" : "text",
45
42
    "application/json" : "text",
46
 
    "application/xml" : "text"
 
43
    "application/xml" : "text",
47
44
};
48
45
 
49
46
/* Mapping MIME types to icons, just the file's basename */
50
47
type_icons = {
51
48
    "text/directory": "dir.png",
52
 
    "text/x-python": "py.png"
 
49
    "text/x-python": "py.png",
53
50
};
54
51
 
55
52
default_type_icon = "txt.png";
56
53
 
57
54
/* Relative to IVLE root */
58
 
type_icons_path = "+media/ivle.webapp.core/images/mime";
59
 
type_icons_path_large = "+media/ivle.webapp.core/images/mime/large";
 
55
type_icons_path = "media/images/mime";
 
56
type_icons_path_large = "media/images/mime/large";
60
57
 
61
58
/* Mapping SVN status to icons, just the file's basename */
62
59
svn_icons = {
63
60
    "unversioned": "unversioned.png",
64
61
    "normal": "normal.png",
65
 
    "added": "added.png",
66
 
    "missing": "missing.png",
67
 
    "deleted": "deleted.png",
68
62
    "modified": "modified.png",
69
 
    "conflicted": "conflicted.png",
70
 
    "revision": "revision.png"
71
 
};
72
 
 
73
 
/* Mapping SVN status to "nice" strings */
74
 
svn_nice = {
75
 
    "unversioned": "Temporary file",
76
 
    "normal": "Permanent file",
77
 
    "added": "Temporary file (scheduled to be added)",
78
 
    "missing": "Permanent file (missing)",
79
 
    "deleted": "Permanent file (scheduled for deletion)",
80
 
    "replaced": "Permanent file (replaced)",
81
 
    "modified": "Permanent file (modified)",
82
 
    "merged": "Permanent file (merged)",
83
 
    "conflicted": "Permanent file (conflicted)",
84
 
    "revision": "Past Permanent file (revision)"
85
 
};
86
 
 
87
 
default_svn_icon = null;
88
 
default_svn_nice = "Unknown status";
89
 
 
90
 
svn_icons_path = "+media/ivle.webapp.core/images/svn";
91
 
 
92
 
published_icon = "+media/ivle.webapp.core/images/interface/published.png";
 
63
};
 
64
 
 
65
default_svn_icon = "normal.png";
 
66
 
 
67
svn_icons_path = "media/images/svn";
93
68
 
94
69
/* List of MIME types considered "executable" by the system.
95
70
 * Executable files offer a "run" link, implying that the "serve"
96
71
 * application can interpret them.
97
72
 */
98
73
types_exec = [
99
 
    "text/x-python"
 
74
    "text/x-python",
100
75
];
101
76
 
102
 
 
103
 
/* Global variables */
104
 
 
105
 
/** The listing object returned by the server as JSON */
106
 
file_listing = null;
107
 
current_file = null;
108
 
current_revision = null;
109
 
current_path = "";
110
 
 
111
 
/** Filenames of all files selected
112
 
 * (Only used by dir listings, but still needs to be [] for files, so that
113
 
 * update_actions knows that nothing is selected).
114
 
 */
115
 
selected_files = [];
116
 
 
117
 
upload_callback_count = 0;      /* See upload_callback */
118
 
 
119
77
/** Calls the server using Ajax, performing an action on the server side.
120
78
 * Receives the response from the server and performs a refresh of the page
121
79
 * contents, updating it to display the returned data (such as a directory
134
92
 *      May be "application/x-www-form-urlencoded" or "multipart/form-data".
135
93
 *      Defaults to "application/x-www-form-urlencoded".
136
94
 *      "multipart/form-data" is recommended for large uploads.
137
 
 * \param callback, optional.
138
 
 *      A callback function for after the action has been handled.
139
95
 */
140
 
function do_action(action, path, args, content_type, callback)
 
96
function do_action(action, path, args, content_type)
141
97
{
142
98
    args.action = action;
143
 
    /* Callback action, when the server returns */
144
 
    var callback_inner = function(response)
145
 
        {
146
 
            /* Check for action errors reported by the server, and report them
147
 
             * to the user */
148
 
            var error = response.getResponseHeader("X-IVLE-Action-Error");
149
 
            if (error != null && error != "")
150
 
                /* Note: This header (in particular) comes URI-encoded, to
151
 
                 * allow multi-line error messages. Decode */
152
 
                alert("Error: " + decodeURIComponent(error.toString()) + ".");
153
 
            /* Now read the response and set up the page accordingly */
154
 
            if (callback != null)
155
 
                callback(path, response);
156
 
        }
157
99
    /* Call the server and perform the action. This mutates the server. */
158
 
    ajax_call(callback_inner, service_app, path, args, "POST", content_type);
 
100
    response = ajax_call(service_app, path, args, "POST", content_type);
 
101
    /* Check for action errors reported by the server, and report them to the
 
102
     * user */
 
103
    error = response.getResponseHeader("X-IVLE-Action-Error");
 
104
    if (error != null)
 
105
        alert("Error: " + error.toString() + ".");
 
106
    /* Now read the response and set up the page accordingly */
 
107
    handle_response(path, response);
159
108
}
160
109
 
161
110
/** Calls the server using Ajax, requesting a directory listing. This should
168
117
 */
169
118
function navigate(path)
170
119
{
171
 
    callback = function(response)
172
 
        {
173
 
            /* Read the response and set up the page accordingly */
174
 
            handle_response(path, response, false, url.args);
175
 
        }
176
 
    /* Get any query strings */
177
 
    url = parse_url(window.location.href);
178
 
    
179
 
    /* Call the server and request the listing. */
180
 
    ajax_call(callback, service_app, path, url.args, "GET");
181
 
}
182
 
 
183
 
/* Refreshes the current view.
184
 
 * Calls navigate on the current path.
185
 
 */
186
 
function refresh()
187
 
{
188
 
    if (maybe_save('All changes since the last save will be lost!'))
189
 
        navigate(current_path);
190
 
}
191
 
 
192
 
/** Determines the "handler type" from a MIME type.
193
 
 * The handler type is a string, either "text", "image", "audio" or "binary".
194
 
 */
195
 
function get_handler_type(content_type)
196
 
{
197
 
    if (!content_type)
198
 
        return null;
199
 
    if (content_type in type_handlers)
200
 
        return type_handlers[content_type];
201
 
    else
202
 
    {   /* Based on the first part of the MIME type */
203
 
        var handler_type = content_type.split('/')[0];
204
 
        if (handler_type != "text" && handler_type != "image" &&
205
 
            handler_type != "audio")
206
 
            handler_type = "binary";
207
 
        return handler_type;
208
 
    }
 
120
    /* Call the server and request the listing. This mutates the server. */
 
121
    response = ajax_call(service_app, path, null, "GET");
 
122
    /* Now read the response and set up the page accordingly */
 
123
    handle_response(path, response);
209
124
}
210
125
 
211
126
/** Given an HTTP response object, cleans up and rebuilds the contents of the
218
133
 * things) be used to update the URL in the location bar.
219
134
 * \param response XMLHttpRequest object returned by the server. Should
220
135
 * contain all the response data.
221
 
 * \param is_action Boolean. True if this is the response to an action, false
222
 
 * if this is the response to a simple listing. This is used in handling the
223
 
 * error.
224
 
 * \param url_args Arguments dict, for the arguments passed to the URL
225
 
 * in the browser's address bar (will be forwarded along).
226
136
 */
227
 
function handle_response(path, response, is_action, url_args)
 
137
function handle_response(path, response)
228
138
{
229
139
    /* TODO: Set location bar to "path" */
230
 
    current_path = path;
231
140
 
232
141
    /* Clear away the existing page contents */
233
142
    clearpage();
 
143
    /* Display the path at the top, for navigation */
 
144
    presentpath(path);
234
145
 
235
146
    /* Check the status, and if not 200, read the error and handle this as an
236
147
     * error. */
243
154
        return;
244
155
    }
245
156
 
246
 
    var subjects = null;
247
 
    var top_level_dir = path==username;
248
 
    if (top_level_dir)
249
 
    {
250
 
        var req = ajax_call(null, "userservice", "get_enrolments", null, "GET")
251
 
        subjects = decode_response(req);
252
 
    }
253
 
 
254
 
 
255
 
    /* This will always return a listing, whether it is a dir or a file.
256
 
     */
257
 
    var listing = response.responseText;
258
 
    /* The listing SHOULD be valid JSON text. Parse it into an object. */
259
 
    try
260
 
    {
261
 
        listing = JSON.parse(listing);
262
 
        file_listing = listing.listing;     /* Global */
263
 
    }
264
 
    catch (e)
265
 
    {
266
 
        if (is_action)
267
 
        {
268
 
            var err = document.createElement("div");
269
 
            var p = dom_make_text_elem("p", "Error: "
270
 
                    + "There was an unexpected server error processing "
271
 
                    + "the selected command.");
272
 
            err.appendChild(p);
273
 
            p = dom_make_text_elem("p", "If the problem persists, please "
274
 
                    + "contact the system administrator.")
275
 
            err.appendChild(p);
276
 
            p = document.createElement("p");
277
 
            var refresh = document.createElement("input");
278
 
            refresh.setAttribute("type", "button");
279
 
            refresh.setAttribute("value", "Back to file view");
280
 
            refresh.setAttribute("onclick", "refresh()");
281
 
            p.appendChild(refresh);
282
 
            err.appendChild(p);
283
 
            handle_error(err);
284
 
        }
285
 
        else
286
 
        {
287
 
            var err = document.createElement("div");
288
 
            var p = dom_make_text_elem("p", "Error: "
289
 
                    + "There was an unexpected server error retrieving "
290
 
                    + "the requested file or directory.");
291
 
            err.appendChild(p);
292
 
            p = dom_make_text_elem("p", "If the problem persists, please "
293
 
                    + "contact the system administrator.")
294
 
            err.appendChild(p);
295
 
            handle_error(err);
296
 
        }
297
 
        return;
298
 
    }
299
 
    /* Get "." out, it's special */
300
 
    current_file = file_listing["."];     /* Global */
301
 
    delete file_listing["."];
302
 
 
303
 
    if ('revision' in listing)
304
 
    {
305
 
        current_revision = listing.revision;
306
 
    }
307
 
 
308
157
    /* Check if this is a directory listing or file contents */
309
 
    var isdir = response.getResponseHeader("X-IVLE-Return") == "Dir";
310
 
    if (isdir)
 
158
    if (response.getResponseHeader("X-IVLE-Return") == "Dir")
311
159
    {
312
 
        setup_for_listing();
313
 
        home_listing(listing, subjects, path);
 
160
        var listing = response.responseText;
 
161
        /* The listing SHOULD be valid JSON text. Parse it into an object. */
 
162
        try
 
163
        {
 
164
            listing = JSON.parse(listing);
 
165
        }
 
166
        catch (e)
 
167
        {
 
168
            handle_error("The server returned an invalid directory listing");
 
169
            return;
 
170
        }
 
171
        handle_dir_listing(path, listing);
314
172
    }
315
173
    else
316
174
    {
317
 
        /* Need to make a 2nd ajax call, this time get the actual file
318
 
         * contents */
319
 
        callback = function(response)
320
 
            {
321
 
                /* Read the response and set up the page accordingly */
322
 
                handle_contents_response(path, response);
323
 
            }
324
 
        /* Call the server and request the listing. */
325
 
        if (url_args)
326
 
            args = shallow_clone_object(url_args);
 
175
        /* Treat this as an ordinary file. Get the file type. */
 
176
        var content_type = response.getResponseHeader("Content-Type");
 
177
        var handler_type;
 
178
        if (content_type in type_handlers)
 
179
            handler_type = type_handlers[content_type];
327
180
        else
328
 
            args = {};
329
 
        /* This time, get the contents of the file, not its metadata */
330
 
        args['return'] = "contents";
331
 
        ajax_call(callback, service_app, path, args, "GET");
332
 
    }
333
 
    update_actions(isdir);
334
 
}
335
 
 
336
 
function handle_contents_response(path, response)
337
 
{
338
 
    /* Treat this as an ordinary file. Get the file type. */
339
 
    var content_type = response.getResponseHeader("Content-Type");
340
 
    var handler_type = get_handler_type(content_type);
341
 
    would_be_handler_type = handler_type;
342
 
    /* handler_type should now be set to either
343
 
     * "text", "image", "audio" or "binary". */
344
 
    switch (handler_type)
345
 
    {
346
 
    case "text":
347
 
        handle_text(path, response.responseText,
348
 
            would_be_handler_type);
349
 
        break;
350
 
    case "image":
351
 
        /* TODO: Custom image handler */
352
 
        handle_binary(path, response.responseText);
353
 
        break;
354
 
    case "audio":
355
 
        /* TODO: Custom audio handler */
356
 
        handle_binary(path, response.responseText);
357
 
        break;
358
 
    case "binary":
359
 
        handle_binary(path);
360
 
        break;
361
 
    }
362
 
}
363
 
 
364
 
/* Called when a form upload comes back (from an iframe).
365
 
 * Refreshes the page.
366
 
 */
367
 
function upload_callback()
368
 
{
369
 
    /* This has a pretty nasty hack, which happens to work.
370
 
     * upload_callback is set as the "onload" callback for the iframe which
371
 
     * receives the response from the server for uploading a file.
372
 
     * This means it gets called twice. Once when initialising the iframe, and
373
 
     * a second time when the actual response comes back.
374
 
     * All we want to do is call navigate to refresh the page. But we CAN'T do
375
 
     * that on the first load or it will just go into an infinite cycle of
376
 
     * refreshing. We need to refresh the page ONLY on the second refresh.
377
 
     * upload_callback_count is reset to 0 just before the iframe is created.
378
 
     */
379
 
    upload_callback_count++;
380
 
    if (upload_callback_count >= 2)
381
 
    {
382
 
        myFrame = frames['upload_iframe'].document;
383
 
        /* Browsers will turn the raw returned JSON into an HTML document. We
384
 
         * need to get the <pre> from inside the <body>, and look at its text.
385
 
         */
386
 
        data = myFrame.firstChild.getElementsByTagName(
387
 
            'body')[0].firstChild.firstChild.nodeValue;
388
 
        data = JSON.parse(data);
389
 
        if ('Error' in data)
390
 
            alert("Error: " + decodeURIComponent(data['Error']));
391
 
        document.getElementsByName('data')[0].value = '';
392
 
        refresh();
 
181
        {   /* Based on the first part of the MIME type */
 
182
            handler_type = content_type.split('/')[0];
 
183
            if (handler_type != "text" && handler_type != "image" &&
 
184
                handler_type != "audio")
 
185
                handler_type = "binary";
 
186
        }
 
187
        /* handler_type should now be set to either
 
188
         * "text", "image", "audio" or "binary". */
 
189
        switch (handler_type)
 
190
        {
 
191
        case "text":
 
192
            handle_text(path, response.responseText);
 
193
            break;
 
194
        case "image":
 
195
            /* TODO: Custom image handler */
 
196
            handle_binary(path, response.responseText);
 
197
            break;
 
198
        case "audio":
 
199
            /* TODO: Custom audio handler */
 
200
            handle_binary(path, response.responseText);
 
201
            break;
 
202
        case "binary":
 
203
            handle_binary(path);
 
204
            break;
 
205
        }
393
206
    }
394
207
}
395
208
 
399
212
 */
400
213
function clearpage()
401
214
{
402
 
    dom_removechildren(document.getElementById("filesbody"));
403
 
}
404
 
 
405
 
/* Checks if a file needs to be saved. If it does, the user will be asked
406
 
 * if they want to continue anyway. The caller must specify a warning
407
 
 * sentence which indicates the consequences of continuing.
408
 
 * Returns true if we should continue, and false if we should not.
409
 
 */
410
 
function maybe_save(warning)
411
 
{
412
 
    if (warning == null) warning = '';
413
 
    if (current_file.isdir) return true;
414
 
    if (document.getElementById("save_button").disabled) return true;
415
 
    return confirm("This file has unsaved changes. " + warning +
416
 
                   "\nAre you sure you wish to continue?");
417
 
}
418
 
 
419
 
/** Deletes all "dynamic" content on the page necessary to navigate from
420
 
 * one directory listing to another (does not clear as much as clearpage
421
 
 * does).
422
 
 * This is the equivalent of calling clearpage() then
423
 
 * setup_for_dir_listing(), assuming the page is already on a dir listing.
424
 
 */
425
 
function clearpage_dir()
426
 
{
 
215
    /* Note: For now clear just enough to repopulate with a dir listing.
 
216
     * Later, will have to clear more to make way for other handlers.
 
217
     * Possibly have a "full clear" for all handlers, and special
 
218
     * less-violent clearers for each handler if the same handler is going to
 
219
     * be used that was used last time. */
427
220
    dom_removechildren(document.getElementById("path"));
428
221
    dom_removechildren(document.getElementById("files"));
429
222
    dom_removechildren(document.getElementById("sidepanel"));
432
225
/*** HANDLERS for different types of responses (such as dir listing, file,
433
226
 * etc). */
434
227
 
435
 
/* handle_error.
436
 
 * message may either be a string, or a DOM node, which will be placed inside
437
 
 * a div.
438
 
 */
439
228
function handle_error(message)
440
229
{
441
 
    var files = document.getElementById("filesbody");
442
 
    var txt_elem;
443
 
    if (typeof(message) == "string")
444
 
    {
445
 
        txt_elem = dom_make_text_elem("div", "Error: "
446
 
                   + message.toString() + ".")
447
 
    }
448
 
    else
449
 
    {
450
 
        /* Assume message is a DOM node */
451
 
        txt_elem = document.createElement("div");
452
 
        txt_elem.appendChild(message);
453
 
    }
454
 
    txt_elem.setAttribute("class", "padding error");
455
 
    files.appendChild(txt_elem);
 
230
    /* TODO: Find a better place to put this message. */
 
231
    var files = document.getElementById("files");
 
232
    var tr = document.createElement("tr");
 
233
    var td = document.createElement("td");
 
234
    tr.appendChild(td);
 
235
    var td = document.createElement("td");
 
236
    tr.appendChild(td);
 
237
    var td = document.createElement("td");
 
238
    tr.appendChild(td);
 
239
    var txt_elem = dom_make_text_elem("td", "Error: "
 
240
        + message.toString() + ".")
 
241
    txt_elem.setAttribute("class", "error");
 
242
    tr.appendChild(txt_elem);
 
243
    var td = document.createElement("td");
 
244
    tr.appendChild(td);
 
245
    var td = document.createElement("td");
 
246
    tr.appendChild(td);
 
247
    files.appendChild(tr);
456
248
}
457
249
 
458
 
/** Given a path, filename and optional revision, returns a URL to open that
459
 
 *  revision of that file.
 
250
/** Presents a path list (address bar inside the page) for clicking.
460
251
 */
461
 
function build_revision_url(path, filename, revision)
 
252
function presentpath(path)
462
253
{
463
 
    bits = {'path': app_path(this_app, path, filename)};
464
 
    if (current_revision)
 
254
    var dom_path = document.getElementById("path");
 
255
    var href_path = make_path(this_app);
 
256
    var nav_path = "";
 
257
 
 
258
    /* Create all of the paths */
 
259
    for each (dir in path.split("/"))
465
260
    {
466
 
        bits['query_string'] = 'r=' + revision;
 
261
        if (dir == "") continue;
 
262
        /* Make an 'a' element */
 
263
        href_path = path_join(href_path, dir);
 
264
        nav_path = path_join(nav_path, dir);
 
265
        var link = dom_make_link_elem("a", dir, "Navigate to " + nav_path,
 
266
                href_path, "navigate(" + href_path + ")");
 
267
        dom_path.appendChild(link);
 
268
        dom_path.appendChild(document.createTextNode("/"));
467
269
    }
468
 
    return build_url(bits);
469
270
}
470
271
 
471
272
/** Given a mime type, returns the path to the icon.
490
291
/** Given an svnstatus, returns the path to the icon.
491
292
 * \param type String, svn status.
492
293
 * \return Path to the icon. Has applied make_path, so it is relative to site
493
 
 * root. May return null to indicate no SVN icon.
 
294
 * root.
494
295
 */
495
296
function svnstatus_to_icon(svnstatus)
496
297
{
499
300
        filename = svn_icons[svnstatus];
500
301
    else
501
302
        filename = default_svn_icon;
502
 
    if (filename == null) return null;
503
303
    return make_path(path_join(svn_icons_path, filename));
504
304
}
505
305
 
506
 
/** Given an svnstatus, returns the "nice" string.
507
 
 */
508
 
function svnstatus_to_string(svnstatus)
509
 
{
510
 
    if (svnstatus in svn_nice)
511
 
        return svn_nice[svnstatus];
512
 
    else
513
 
        return default_svn_nice;
 
306
/** Presents the directory listing.
 
307
 */
 
308
function handle_dir_listing(path, listing)
 
309
{
 
310
    var row_toggle = 1;
 
311
    /* Nav through the top-level of the JSON to the actual listing object. */
 
312
    var listing = listing.listing;
 
313
 
 
314
    /* Get "." out, it's special */
 
315
    var thisdir = listing["."];
 
316
    delete listing["."];
 
317
    /* Is this dir under svn? */
 
318
    var under_subversion = "svnstatus" in thisdir;
 
319
 
 
320
    var files = document.getElementById("files");
 
321
    var file;
 
322
    var row;
 
323
    var td;
 
324
    var checkbox;
 
325
 
 
326
    /* Create all of the files */
 
327
    for (var filename in listing)
 
328
    {
 
329
        file = listing[filename];
 
330
        /* Make a 'tr' element */
 
331
        row = document.createElement("tr");
 
332
        /* Column 1: Selection checkbox */
 
333
        row.setAttribute("class", "row" + row_toggle.toString())
 
334
        row_toggle = row_toggle == 1 ? 2 : 1;
 
335
        td = document.createElement("td");
 
336
        checkbox = document.createElement("input");
 
337
        checkbox.setAttribute("type", "checkbox");
 
338
        checkbox.setAttribute("title", "Select this file");
 
339
        td.appendChild(checkbox);
 
340
        row.appendChild(td);
 
341
        if (file.isdir)
 
342
        {
 
343
            /* Column 2: Filetype and subversion icons. */
 
344
            td = document.createElement("td");
 
345
            td.setAttribute("class", "thincol");
 
346
            td.appendChild(dom_make_img(mime_type_to_icon("text/directory"),
 
347
                22, 22, file.type));
 
348
            row.appendChild(td);
 
349
            td = document.createElement("td");
 
350
            td.setAttribute("class", "thincol");
 
351
            if (under_subversion)
 
352
                td.appendChild(dom_make_img(svnstatus_to_icon(file.svnstatus),
 
353
                    22, 22, file.svnstatus));
 
354
            row.appendChild(td);
 
355
            /* Column 3: Filename */
 
356
            row.appendChild(dom_make_link_elem("td", filename,
 
357
                "Navigate to " + path_join(path, filename),
 
358
                make_path(path_join(this_app, path, filename)),
 
359
                "navigate(" + path_join(path, filename) + ")"));
 
360
        }
 
361
        else
 
362
        {
 
363
            /* Column 2: Filetype and subversion icons. */
 
364
            td = document.createElement("td");
 
365
            td.setAttribute("class", "thincol");
 
366
            td.appendChild(dom_make_img(mime_type_to_icon(file.type),
 
367
                22, 22, file.type));
 
368
            row.appendChild(td);
 
369
            td = document.createElement("td");
 
370
            td.setAttribute("class", "thincol");
 
371
            if (under_subversion)
 
372
                td.appendChild(dom_make_img(svnstatus_to_icon(file.svnstatus),
 
373
                    22, 22, file.svnstatus));
 
374
            row.appendChild(td);
 
375
            /* Column 3: Filename */
 
376
            row.appendChild(dom_make_text_elem("td", filename));
 
377
        }
 
378
        /* Column 4: Size */
 
379
        row.appendChild(dom_make_text_elem("td", nice_filesize(file.size)));
 
380
        /* Column 4: Date */
 
381
        row.appendChild(dom_make_text_elem("td", file.mtime_short,
 
382
            file.mtime_nice));
 
383
        files.appendChild(row);
 
384
    }
 
385
 
 
386
}
 
387
 
 
388
/** Presents the text editor.
 
389
 */
 
390
function handle_text(path, text)
 
391
{
 
392
    /* TODO */
 
393
    alert(text);
514
394
}
515
395
 
516
396
/** Displays a download link to the binary file.
517
397
 */
518
398
function handle_binary(path)
519
399
{
520
 
    var files = document.getElementById("filesbody");
521
 
    var div = document.createElement("div");
522
 
    files.appendChild(div);
523
 
    div.setAttribute("class", "padding");
524
 
    var download_link = app_path(download_app, path);
525
 
    var par1 = dom_make_text_elem("p",
526
 
        "The file " + path + " is a binary file. To download this file, " +
527
 
        "click the following link:");
528
 
    var par2 = dom_make_link_elem("p",
529
 
        "Download " + path, "Download " + path, download_link);
530
 
    div.appendChild(par1);
531
 
    div.appendChild(par2);
532
 
}
533
 
 
534
 
/* Enable or disable actions1 moreactions actions. Takes either a single
535
 
 * name, or an array of them.*/
536
 
function set_action_state(names, which, allow_on_revision)
537
 
{
538
 
    if (!(names instanceof Array)) names = Array(names);
539
 
 
540
 
    for (var i=0; i < names.length; i++)
541
 
    {
542
 
        element = document.getElementById('act_' + names[i]);
543
 
        if (which &&
544
 
            !(current_file.svnstatus == 'revision' && !allow_on_revision))
545
 
        {
546
 
            /* Enabling */
547
 
            element.setAttribute("class", "choice");
548
 
            element.removeAttribute("disabled");
549
 
        }
550
 
        else
551
 
        {
552
 
            /* Disabling */
553
 
            element.setAttribute("class", "disabled");
554
 
            element.setAttribute("disabled", "disabled");
555
 
        }
556
 
    }
557
 
}
558
 
 
559
 
/* Updates the list of available actions based on files selected */
560
 
function update_actions()
561
 
{
562
 
    var file;
563
 
    var numsel = selected_files.length;
564
 
    var svn_selection = false;
565
 
    
566
 
    if (numsel > 0)
567
 
    {
568
 
        svn_selection = true;
569
 
        for (var i = 0; i < selected_files.length; i++){
570
 
            if (file_listing[selected_files[i]]["svnstatus"] == "unversioned")
571
 
            {
572
 
                svn_selection = false;        
573
 
            }
574
 
        }
575
 
    }
576
 
    
577
 
    if (numsel <= 1)
578
 
    {
579
 
        if (numsel == 0)
580
 
        {
581
 
            /* Display information about the current directory instead */
582
 
            filename = path_basename(current_path);
583
 
            file = current_file;
584
 
        }
585
 
        else if (numsel == 1)
586
 
        {
587
 
            filename = selected_files[0];
588
 
            file = file_listing[filename];
589
 
        }
590
 
 
591
 
        /* Update each action node in the topbar.
592
 
         * This includes enabling/disabling actions as appropriate, and
593
 
         * setting href/onclick attributes. */
594
 
    }
595
 
 
596
 
    /* Open */
597
 
    /* Available if exactly one file is selected */
598
 
    var open = document.getElementById("act_open");
599
 
    if (numsel == 1)
600
 
    {
601
 
        open.setAttribute("class", "choice");
602
 
        if (file.isdir)
603
 
            open.setAttribute("title",
604
 
                "Navigate to this directory in the file browser");
605
 
        else
606
 
            open.setAttribute("title",
607
 
                "Edit or view this file");
608
 
        open.setAttribute("href", build_revision_url(current_path, filename,
609
 
                                                     current_revision));
610
 
    }
611
 
    else
612
 
    {
613
 
        open.setAttribute("class", "disabled");
614
 
        open.removeAttribute("title");
615
 
        open.removeAttribute("href");
616
 
    }
617
 
 
618
 
    /* Serve */
619
 
    /* Available if zero or one files are selected,
620
 
     * and only if this is a file, not a directory */
621
 
    var serve = document.getElementById("act_serve");
622
 
    if (numsel <= 1 && !file.isdir && current_file.svnstatus != 'revision')
623
 
    {
624
 
        serve.setAttribute("class", "choice");
625
 
        serve.setAttribute("onclick",
626
 
              "return maybe_save('The last saved version will be served.')");
627
 
        if (numsel == 0)
628
 
            serve.setAttribute("href",
629
 
                app_path(serve_app, current_path));
630
 
        else
631
 
            serve.setAttribute("href",
632
 
                app_path(serve_app, current_path, filename));
633
 
    }
634
 
    else
635
 
    {
636
 
        serve.setAttribute("class", "disabled");
637
 
        serve.removeAttribute("href");
638
 
        serve.removeAttribute("onclick");
639
 
    }
640
 
 
641
 
    /* Run */
642
 
    /* Available if exactly one file is selected,
643
 
     * and it is a Python file.
644
 
     */
645
 
    var run = document.getElementById("act_run");
646
 
     
647
 
    if (numsel <= 1 && !file.isdir && file.type == "text/x-python" 
648
 
            && current_file.svnstatus != 'revision')
649
 
    {
650
 
        if (numsel == 0)
651
 
        {
652
 
            // In the edit window
653
 
            var localpath = path_join('/home', current_path);
654
 
        }
655
 
        else
656
 
        {
657
 
            // In the browser window
658
 
            var localpath = path_join('/home', current_path, filename);
659
 
        }
660
 
        run.setAttribute("class", "choice");
661
 
        run.setAttribute("onclick", "runfile('" + localpath + "')");
662
 
    }
663
 
    else
664
 
    {
665
 
        run.setAttribute("class", "disabled");
666
 
        run.removeAttribute("onclick");
667
 
    }
668
 
 
669
 
    /* Download */
670
 
    /* Always available for current files.
671
 
     * If 0 files selected, download the current file or directory as a ZIP.
672
 
     * If 1 directory selected, download it as a ZIP.
673
 
     * If 1 non-directory selected, download it.
674
 
     * If >1 files selected, download them all as a ZIP.
675
 
     */
676
 
    var download = document.getElementById("act_download");
677
 
    if (current_file.svnstatus == 'revision')
678
 
    {
679
 
        download.setAttribute("class", "disabled");
680
 
        download.removeAttribute("onclick");
681
 
    }
682
 
    else if (numsel <= 1)
683
 
    {
684
 
        download.setAttribute("class", "choice")
685
 
        if (numsel == 0)
686
 
        {
687
 
            download.setAttribute("href",
688
 
                app_path(download_app, current_path));
689
 
            if (file.isdir)
690
 
                download.setAttribute("title",
691
 
                    "Download the current directory as a ZIP file");
692
 
            else
693
 
                download.setAttribute("title",
694
 
                    "Download the current file");
695
 
        }
696
 
        else
697
 
        {
698
 
            download.setAttribute("href",
699
 
                app_path(download_app, current_path, filename));
700
 
            if (file.isdir)
701
 
                download.setAttribute("title",
702
 
                    "Download the selected directory as a ZIP file");
703
 
            else
704
 
                download.setAttribute("title",
705
 
                    "Download the selected file");
706
 
        }
707
 
    }
708
 
    else
709
 
    {
710
 
        /* Make a query string with all the files to download */
711
 
        var dlpath = urlencode_path(app_path(download_app, current_path)) + "?";
712
 
        for (var i=0; i<numsel; i++)
713
 
            dlpath += "path=" + encodeURIComponent(selected_files[i]) + "&";
714
 
        dlpath = dlpath.substr(0, dlpath.length-1);
715
 
        download.setAttribute("class", "choice")
716
 
        download.setAttribute("href", dlpath);
717
 
        download.setAttribute("title",
718
 
            "Download the selected files as a ZIP file");
719
 
    }
720
 
 
721
 
    /* Refresh - No changes required */
722
 
 
723
 
    /* Publish and Submit */
724
 
    /* If this directory is under subversion and selected/unselected file is a
725
 
     * directory. */
726
 
    var publish = document.getElementById("act_publish");
727
 
    var submit = document.getElementById("act_submit");
728
 
    var pubcond = numsel <= 1 && file.isdir;
729
 
    if (pubcond)
730
 
    {
731
 
        /* If this dir is already published, call it "Unpublish" */
732
 
        if (file.published)
733
 
        {
734
 
            publish.setAttribute("value", "unpublish");
735
 
            publish.setAttribute("title" ,"Make it so this directory "
736
 
                + "can not be seen by anyone on the web");
737
 
            publish.firstChild.nodeValue = "Unpublish";
738
 
        } else {
739
 
            publish.setAttribute("value", "publish");
740
 
            publish.setAttribute("title","Make it so this directory "
741
 
                + "can be seen by anyone on the web");
742
 
            publish.firstChild.nodeValue = "Publish";
743
 
        }
744
 
    }
745
 
    set_action_state(["publish", "submit"], pubcond);
746
 
 
747
 
    /* Share */
748
 
    /* If exactly 1 non-directory file is selected, and its parent
749
 
     * directory is published.
750
 
     */
751
 
    set_action_state("share", numsel == 1 && !file.isdir &&
752
 
                     current_file.published);
753
 
 
754
 
    /* Rename */
755
 
    /* If exactly 1 file is selected */
756
 
    set_action_state("rename", numsel == 1);
757
 
 
758
 
    /* Delete, cut, copy */
759
 
    /* If >= 1 file is selected */
760
 
    set_action_state(["delete", "cut", "copy"], numsel >= 1);
761
 
 
762
 
    /* Paste, new file, new directory, upload */
763
 
    /* Disable if the current file is not a directory */
764
 
    set_action_state(["paste", "newfile", "mkdir", "upload"], current_file.isdir);
765
 
 
766
 
    /* Subversion actions */
767
 
    /* These are only useful if we are in a versioned directory and have some
768
 
     * files selected. */
769
 
    set_action_state(["svnadd"], numsel >= 1 && current_file.svnstatus);
770
 
    /* And these are only usefull is ALL the selected files are versioned */
771
 
    set_action_state(["svnremove", "svnrevert", "svncommit", "svncopy", 
772
 
            "svncut"], numsel >= 1 && current_file.svnstatus && svn_selection);
773
 
    
774
 
    /* Diff, log and update only support one path at the moment, so we must
775
 
     * have 0 or 1 versioned files selected. If 0, the directory must be
776
 
     * versioned. */
777
 
    single_versioned_path = (
778
 
         (
779
 
          (numsel == 1 && (svnst = file_listing[selected_files[0]].svnstatus)) ||
780
 
          (numsel == 0 && (svnst = current_file.svnstatus))
781
 
         ) && svnst != "unversioned");
782
 
    set_action_state(["svndiff", "svnupdate"], single_versioned_path);
783
 
 
784
 
    /* We can resolve if we have a file selected and it is conflicted. */
785
 
    set_action_state("svnresolved", single_versioned_path && numsel == 1 && svnst == "conflicted");
786
 
 
787
 
    /* Log should be available for revisions as well. */
788
 
    set_action_state("svnlog", single_versioned_path, true);
789
 
 
790
 
    /* Cleanup should be available for revisions as well. */
791
 
    set_action_state("svncleanup", single_versioned_path, true);
792
 
 
793
 
    single_ivle_versioned_path = (
794
 
         (
795
 
          (numsel == 1 && (stat = file_listing[selected_files[0]])) ||
796
 
          (numsel == 0 && (stat = current_file))
797
 
         ) && stat.svnstatus != "unversioned"
798
 
           && stat.svnurl
799
 
           && stat.svnurl.substr(0, svn_base.length) == svn_base);
800
 
    set_action_state(["submit"], single_ivle_versioned_path);
801
 
 
802
 
    /* There is currently nothing on the More Actions menu of use
803
 
     * when the current file is not a directory. Hence, just remove
804
 
     * it entirely.
805
 
     * (This makes some of the above decisions somewhat redundant).
806
 
     * We also take this opportunity to show the appropriate actions2
807
 
     * bar for this path. It should either be a save or upload widget.
808
 
     */
809
 
    if (current_file.isdir)
810
 
    {
811
 
        var actions2_directory = document.getElementById("actions2_directory");
812
 
        actions2_directory.setAttribute("style", "display: inline;");
813
 
        var moreactions = document.getElementById("moreactions_area");
814
 
        moreactions.setAttribute("style", "display: inline;");
815
 
    }
816
 
    else
817
 
    {
818
 
        var actions2_file = document.getElementById("actions2_file");
819
 
        actions2_file.setAttribute("style", "display: inline;");
820
 
    }
821
 
 
822
 
    return;
823
 
}
824
 
 
825
 
/** Event handler for when an item of the "More actions..." dropdown box is
826
 
 * selected. Performs the selected action. */
827
 
function handle_moreactions()
828
 
{
829
 
    var moreactions = document.getElementById("moreactions");
830
 
    if (moreactions.value == "top")
831
 
        return;
832
 
    var selectedaction = moreactions.value;
833
 
    /* Reset to "More actions..." */
834
 
    moreactions.selectedIndex = 0;
835
 
 
836
 
    /* If 0 files selected, filename is the name of the current dir.
837
 
     * If 1 file selected, filename is that file.
838
 
     */
839
 
    if (selected_files.length == 0)
840
 
        filename = path_basename(current_path);
841
 
    else if (selected_files.length == 1)
842
 
        filename = selected_files[0];
843
 
    else
844
 
        filename = null;
845
 
 
846
 
    /* Now handle the selected action */
847
 
    switch(selectedaction)
848
 
    {
849
 
    case "publish":
850
 
        action_publish(selected_files);
851
 
        break;
852
 
    case "unpublish":
853
 
        action_unpublish(selected_files);
854
 
        break;
855
 
    case "share":
856
 
        window.open(public_app_path("~" + current_path, filename), 'share')
857
 
        break;
858
 
    case "submit":
859
 
        if (selected_files.length == 1)
860
 
            stat = file_listing[selected_files[0]];
861
 
        else
862
 
            stat = current_file;
863
 
        path = stat.svnurl.substr(svn_base.length);
864
 
 
865
 
        /* The working copy might not have an up-to-date version of the
866
 
         * directory. While submitting like this could yield unexpected
867
 
         * results, we should really submit the latest revision to minimise
868
 
         * terrible mistakes - so we run off and ask fileservice for the
869
 
         * latest revision.*/
870
 
        $.post(app_path(service_app, current_path),
871
 
            {"action": "svnrepostat", "path": path},
872
 
            function(result)
873
 
            {
874
 
                window.location = path_join(app_path('+submit'), path) + '?revision=' + result.svnrevision;
875
 
            },
876
 
            "json");
877
 
 
878
 
        break;
879
 
    case "rename":
880
 
        action_rename(filename);
881
 
        break;
882
 
    case "delete":
883
 
        action_delete(selected_files);
884
 
        break;
885
 
    case "copy":
886
 
        action_copy(selected_files);
887
 
        break;
888
 
    case "cut":
889
 
        action_cut(selected_files);
890
 
        break;
891
 
    case "paste":
892
 
        action_paste();
893
 
        break;
894
 
    case "newfile":
895
 
        action_newfile();
896
 
        break;
897
 
    case "mkdir":
898
 
        action_mkdir();
899
 
        break;
900
 
    case "upload":
901
 
        show_uploadpanel(true);
902
 
        break;
903
 
    case "svnadd":
904
 
        action_add(selected_files);
905
 
        break;
906
 
    case "svnremove":
907
 
        action_remove(selected_files);
908
 
        break;
909
 
    case "svnrevert":
910
 
        action_revert(selected_files);
911
 
        break;
912
 
    case "svndiff":
913
 
        window.location = path_join(app_path('diff'), current_path, selected_files[0] || '');
914
 
        break;
915
 
    case "svnupdate":
916
 
        action_update(selected_files);
917
 
        break;
918
 
    case "svnresolved":
919
 
        action_resolved(selected_files);
920
 
        break;
921
 
    case "svncommit":
922
 
        action_commit(selected_files);
923
 
        break;
924
 
    case "svnlog":
925
 
        window.location = path_join(app_path('svnlog'), current_path, selected_files[0] || '');
926
 
        break;
927
 
    case "svncopy":
928
 
        action_svncopy(selected_files);
929
 
        break;
930
 
    case "svncut":
931
 
        action_svncut(selected_files);
932
 
        break;
933
 
    case "svncleanup":
934
 
        action_svncleanup(".");
935
 
        break;
936
 
    }
937
 
}
938
 
 
939
 
/** User clicks "Run" button.
940
 
 * Do an Ajax call and print the test output.
941
 
 */
942
 
function runfile(localpath)
943
 
{
944
 
    if (!maybe_save('The last saved version will be run.')) return false;
945
 
 
946
 
    /* Dump the entire file to the console */
947
 
    var callback = function()
948
 
    {
949
 
        console_enter_line("execfile('" + localpath + "')", "block");
950
 
    }
951
 
    start_server(callback)
952
 
    return;
 
400
    /* TODO */
 
401
    alert(path);
953
402
}
954
403
 
955
404
/** Called when the page loads initially.
956
405
 */
957
 
function browser_init()
 
406
window.onload = function()
958
407
{
959
408
    /* Navigate (internally) to the path in the URL bar.
960
409
     * This causes the page to be populated with whatever is at that address,
961
410
     * whether it be a directory or a file.
962
411
     */
963
 
    var path = get_path();
964
 
    navigate(path);
965
 
}
966
 
 
967
 
/** Gets the current path of the window */
968
 
function get_path() {
969
412
    var path = parse_url(window.location.href).path;
970
413
    /* Strip out root_dir + "/files" from the front of the path */
971
 
    var strip = make_path(this_app);
972
 
    if (path.substr(0, strip.length) == strip)
973
 
        path = path.substr(strip.length+1);
974
 
    else
975
 
    {
976
 
        /* See if this is an edit path */
977
 
        strip = make_path(edit_app);
978
 
        if (path.substr(0, strip.length) == strip)
979
 
        {
980
 
            path = path.substr(strip.length+1);
981
 
        }
982
 
    }
 
414
    strip_chars = make_path(this_app).length + 1;
 
415
    path = path.substr(strip_chars);
983
416
 
984
417
    if (path.length == 0)
985
418
    {
988
421
        path = username;
989
422
    }
990
423
 
991
 
    return path;
 
424
    navigate(path);
992
425
}