← 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: drtomc
  • Date: 2008-02-04 23:18:34 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:405
Version 0 of the file manipulation tools to allow us to get the permissions right.

Show diffs side-by-side

added added

removed removed

Lines of Context:
www/media/browser/browser.js
43
43
    "application/x-javascript" : "text",
44
44
    "application/javascript" : "text",
45
45
    "application/json" : "text",
46
 
    "application/xml" : "text"
 
46
    "application/xml" : "text",
47
47
};
48
48
 
49
49
/* Mapping MIME types to icons, just the file's basename */
50
50
type_icons = {
51
51
    "text/directory": "dir.png",
52
 
    "text/x-python": "py.png"
 
52
    "text/x-python": "py.png",
53
53
};
54
54
 
55
55
default_type_icon = "txt.png";
66
66
    "missing": "missing.png",
67
67
    "deleted": "deleted.png",
68
68
    "modified": "modified.png",
69
 
    "conflicted": "conflicted.png",
70
 
    "revision": "revision.png"
71
69
};
72
70
 
73
71
/* Mapping SVN status to "nice" strings */
81
79
    "modified": "Permanent file (modified)",
82
80
    "merged": "Permanent file (merged)",
83
81
    "conflicted": "Permanent file (conflicted)",
84
 
    "revision": "Past Permanent file (revision)"
85
82
};
86
83
 
87
84
default_svn_icon = null;
96
93
 * application can interpret them.
97
94
 */
98
95
types_exec = [
99
 
    "text/x-python"
 
96
    "text/x-python",
100
97
];
101
98
 
102
99
 
103
100
/* Global variables */
104
101
 
105
 
/** The listing object returned by the server as JSON */
106
 
file_listing = null;
107
 
current_file = null;
108
 
current_revision = null;
109
102
current_path = "";
110
103
 
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
104
/** Calls the server using Ajax, performing an action on the server side.
120
105
 * Receives the response from the server and performs a refresh of the page
121
106
 * contents, updating it to display the returned data (such as a directory
138
123
function do_action(action, path, args, content_type, ignore_response)
139
124
{
140
125
    args.action = action;
141
 
    /* Callback action, when the server returns */
142
 
    var callback = function(response)
143
 
        {
144
 
            /* Check for action errors reported by the server, and report them
145
 
             * to the user */
146
 
            var error = response.getResponseHeader("X-IVLE-Action-Error");
147
 
            if (error != null)
148
 
                /* Note: This header (in particular) comes URI-encoded, to
149
 
                 * allow multi-line error messages. Decode */
150
 
                alert("Error: " + decodeURIComponent(error.toString()) + ".");
151
 
            /* Now read the response and set up the page accordingly */
152
 
            if (ignore_response != true)
153
 
                handle_response(path, response, true);
154
 
        }
155
126
    /* Call the server and perform the action. This mutates the server. */
156
 
    ajax_call(callback, service_app, path, args, "POST", content_type);
 
127
    response = ajax_call(service_app, path, args, "POST", content_type);
 
128
    /* Check for action errors reported by the server, and report them to the
 
129
     * user */
 
130
    error = response.getResponseHeader("X-IVLE-Action-Error");
 
131
    if (error != null)
 
132
        alert("Error: " + error.toString() + ".");
 
133
    /* Now read the response and set up the page accordingly */
 
134
    if (ignore_response != true)
 
135
        handle_response(path, response);
157
136
}
158
137
 
159
138
/** Calls the server using Ajax, requesting a directory listing. This should
163
142
 * Called "navigate", can also be used for a simple refresh.
164
143
 * Always makes a GET request.
165
144
 * No return value.
166
 
 */
167
 
function navigate(path)
168
 
{
169
 
    callback = function(response)
170
 
        {
171
 
            /* Read the response and set up the page accordingly */
172
 
            handle_response(path, response, false, url.args);
173
 
        }
174
 
    /* Get any query strings */
175
 
    url = parse_url(window.location.href);
176
 
    
177
 
    /* Call the server and request the listing. */
178
 
    ajax_call(callback, service_app, path, url.args, "GET");
179
 
}
180
 
 
181
 
/* Refreshes the current view.
182
 
 * Calls navigate on the current path.
183
 
 */
184
 
function refresh()
185
 
{
186
 
    if (maybe_save('All changes since the last save will be lost!'))
187
 
        navigate(current_path);
 
145
 * \param editmode Optional boolean. If true, then the user navigated here
 
146
 * with an "edit" URL so we should favour using the editor.
 
147
 */
 
148
function navigate(path, editmode)
 
149
{
 
150
    /* Call the server and request the listing. This mutates the server. */
 
151
    response = ajax_call(service_app, path, null, "GET");
 
152
    /* Now read the response and set up the page accordingly */
 
153
    handle_response(path, response, editmode);
188
154
}
189
155
 
190
156
/** Determines the "handler type" from a MIME type.
216
182
 * things) be used to update the URL in the location bar.
217
183
 * \param response XMLHttpRequest object returned by the server. Should
218
184
 * contain all the response data.
219
 
 * \param is_action Boolean. True if this is the response to an action, false
220
 
 * if this is the response to a simple listing. This is used in handling the
221
 
 * error.
222
 
 * \param url_args Arguments dict, for the arguments passed to the URL
223
 
 * in the browser's address bar (will be forwarded along).
 
185
 * \param editmode Optional boolean. If true, then the user navigated here
 
186
 * with an "edit" URL so we should favour using the editor.
224
187
 */
225
 
function handle_response(path, response, is_action, url_args)
 
188
function handle_response(path, response, editmode)
226
189
{
227
190
    /* TODO: Set location bar to "path" */
228
191
    current_path = path;
229
192
 
230
193
    /* Clear away the existing page contents */
231
194
    clearpage();
 
195
    /* Display the path at the top, for navigation */
 
196
    presentpath(path);
232
197
 
233
198
    /* Check the status, and if not 200, read the error and handle this as an
234
199
     * error. */
241
206
        return;
242
207
    }
243
208
 
244
 
    var subjects = null;
245
 
    var top_level_dir = path==username;
246
 
    if (top_level_dir)
247
 
    {
248
 
        var req = ajax_call(null, "userservice", "get_enrolments", null, "GET")
249
 
        subjects = decode_response(req);
250
 
    }
251
 
 
252
 
 
253
 
    /* This will always return a listing, whether it is a dir or a file.
254
 
     */
255
 
    var listing = response.responseText;
256
 
    /* The listing SHOULD be valid JSON text. Parse it into an object. */
257
 
    try
258
 
    {
259
 
        listing = JSON.parse(listing);
260
 
        file_listing = listing.listing;     /* Global */
261
 
    }
262
 
    catch (e)
263
 
    {
264
 
        if (is_action)
265
 
        {
266
 
            var err = document.createElement("div");
267
 
            var p = dom_make_text_elem("p", "Error: "
268
 
                    + "There was an unexpected server error processing "
269
 
                    + "the selected command.");
270
 
            err.appendChild(p);
271
 
            p = dom_make_text_elem("p", "If the problem persists, please "
272
 
                    + "contact the system administrator.")
273
 
            err.appendChild(p);
274
 
            p = document.createElement("p");
275
 
            var refresh = document.createElement("input");
276
 
            refresh.setAttribute("type", "button");
277
 
            refresh.setAttribute("value", "Back to file view");
278
 
            refresh.setAttribute("onclick", "refresh()");
279
 
            p.appendChild(refresh);
280
 
            err.appendChild(p);
281
 
            handle_error(err);
282
 
        }
283
 
        else
284
 
        {
285
 
            var err = document.createElement("div");
286
 
            var p = dom_make_text_elem("p", "Error: "
287
 
                    + "There was an unexpected server error retrieving "
288
 
                    + "the requested file or directory.");
289
 
            err.appendChild(p);
290
 
            p = dom_make_text_elem("p", "If the problem persists, please "
291
 
                    + "contact the system administrator.")
292
 
            err.appendChild(p);
293
 
            handle_error(err);
294
 
        }
295
 
        return;
296
 
    }
297
 
    /* Get "." out, it's special */
298
 
    current_file = file_listing["."];     /* Global */
299
 
    delete file_listing["."];
300
 
 
301
 
    if ('revision' in listing)
302
 
    {
303
 
        current_revision = listing.revision;
304
 
    }
305
 
 
306
209
    /* Check if this is a directory listing or file contents */
307
210
    var isdir = response.getResponseHeader("X-IVLE-Return") == "Dir";
308
 
    if (isdir)
 
211
    if (!editmode && isdir)
309
212
    {
310
 
        setup_for_listing();
311
 
        home_listing(listing, subjects, path);
 
213
        var listing = response.responseText;
 
214
        /* The listing SHOULD be valid JSON text. Parse it into an object. */
 
215
        try
 
216
        {
 
217
            listing = JSON.parse(listing);
 
218
        }
 
219
        catch (e)
 
220
        {
 
221
            handle_error("The server returned an invalid directory listing");
 
222
            return;
 
223
        }
 
224
        handle_dir_listing(path, listing);
312
225
    }
313
226
    else
314
227
    {
315
 
        /* Need to make a 2nd ajax call, this time get the actual file
316
 
         * contents */
317
 
        callback = function(response)
318
 
            {
319
 
                /* Read the response and set up the page accordingly */
320
 
                handle_contents_response(path, response);
321
 
            }
322
 
        /* Call the server and request the listing. */
323
 
        if (url_args)
324
 
            args = shallow_clone_object(url_args);
325
 
        else
326
 
            args = {};
327
 
        /* This time, get the contents of the file, not its metadata */
328
 
        args['return'] = "contents";
329
 
        ajax_call(callback, service_app, path, args, "GET");
330
 
    }
331
 
    update_actions(isdir);
332
 
}
333
 
 
334
 
function handle_contents_response(path, response)
335
 
{
336
 
    /* Treat this as an ordinary file. Get the file type. */
337
 
    var content_type = response.getResponseHeader("Content-Type");
338
 
    var handler_type = get_handler_type(content_type);
339
 
    would_be_handler_type = handler_type;
340
 
    /* handler_type should now be set to either
341
 
     * "text", "image", "audio" or "binary". */
342
 
    switch (handler_type)
343
 
    {
344
 
    case "text":
345
 
        handle_text(path, response.responseText,
346
 
            would_be_handler_type);
347
 
        break;
348
 
    case "image":
349
 
        /* TODO: Custom image handler */
350
 
        handle_binary(path, response.responseText);
351
 
        break;
352
 
    case "audio":
353
 
        /* TODO: Custom audio handler */
354
 
        handle_binary(path, response.responseText);
355
 
        break;
356
 
    case "binary":
357
 
        handle_binary(path);
358
 
        break;
359
 
    }
360
 
}
361
 
 
362
 
/* Called when a form upload comes back (from an iframe).
363
 
 * Refreshes the page.
364
 
 */
365
 
function upload_callback()
366
 
{
367
 
    /* This has a pretty nasty hack, which happens to work.
368
 
     * upload_callback is set as the "onload" callback for the iframe which
369
 
     * receives the response from the server for uploading a file.
370
 
     * This means it gets called twice. Once when initialising the iframe, and
371
 
     * a second time when the actual response comes back.
372
 
     * All we want to do is call navigate to refresh the page. But we CAN'T do
373
 
     * that on the first load or it will just go into an infinite cycle of
374
 
     * refreshing. We need to refresh the page ONLY on the second refresh.
375
 
     * upload_callback_count is reset to 0 just before the iframe is created.
376
 
     */
377
 
    upload_callback_count++;
378
 
    if (upload_callback_count >= 2)
379
 
    {
380
 
        document.getElementsByName('data')[0].value = '';
381
 
        refresh();
 
228
        /* Treat this as an ordinary file. Get the file type. */
 
229
        var content_type = response.getResponseHeader("Content-Type");
 
230
        var handler_type = get_handler_type(content_type);
 
231
        /* If we're in "edit mode", always treat this file as text */
 
232
        would_be_handler_type = handler_type;
 
233
        if (editmode) handler_type = "text";
 
234
        /* handler_type should now be set to either
 
235
         * "text", "image", "audio" or "binary". */
 
236
        switch (handler_type)
 
237
        {
 
238
        case "text":
 
239
            if (isdir)
 
240
            {
 
241
                handle_text(path_join(path, "untitled"), "",
 
242
                    would_be_handler_type);
 
243
            }
 
244
            else
 
245
            {
 
246
                handle_text(path, response.responseText,
 
247
                    would_be_handler_type);
 
248
            }
 
249
            break;
 
250
        case "image":
 
251
            /* TODO: Custom image handler */
 
252
            handle_binary(path, response.responseText);
 
253
            break;
 
254
        case "audio":
 
255
            /* TODO: Custom audio handler */
 
256
            handle_binary(path, response.responseText);
 
257
            break;
 
258
        case "binary":
 
259
            handle_binary(path);
 
260
            break;
 
261
        }
382
262
    }
383
263
}
384
264
 
388
268
 */
389
269
function clearpage()
390
270
{
 
271
    dom_removechildren(document.getElementById("path"));
391
272
    dom_removechildren(document.getElementById("filesbody"));
392
273
}
393
274
 
394
 
/* Checks if a file needs to be saved. If it does, the user will be asked
395
 
 * if they want to continue anyway. The caller must specify a warning
396
 
 * sentence which indicates the consequences of continuing.
397
 
 * Returns true if we should continue, and false if we should not.
398
 
 */
399
 
function maybe_save(warning)
400
 
{
401
 
    if (warning == null) warning = '';
402
 
    if (current_file.isdir) return true;
403
 
    if (document.getElementById("save_button").disabled) return true;
404
 
    return confirm("This file has unsaved changes. " + warning +
405
 
                   "\nAre you sure you wish to continue?");
406
 
}
407
 
 
408
275
/** Deletes all "dynamic" content on the page necessary to navigate from
409
276
 * one directory listing to another (does not clear as much as clearpage
410
277
 * does).
418
285
    dom_removechildren(document.getElementById("sidepanel"));
419
286
}
420
287
 
 
288
/** Sets the mode to either "file browser" or "text editor" mode.
 
289
 * This modifies the window icon, and selected tab.
 
290
 * \param editmode If True, editor mode. Else, file browser mode.
 
291
 */
 
292
function setmode(editmode)
 
293
{
 
294
    /* Find the DOM elements for the file browser and editor tabs */
 
295
    var tabs = document.getElementById("apptabs");
 
296
    var tab_files = null;
 
297
    var tab_edit = null;
 
298
    var a;
 
299
    var href;
 
300
    for (var i=0; i<tabs.childNodes.length; i++)
 
301
    {
 
302
        /* Find the href of the link within */
 
303
        if (!tabs.childNodes[i].getElementsByTagName) continue;
 
304
        a = tabs.childNodes[i].getElementsByTagName("a");
 
305
        if (a.length == 0) continue;
 
306
        href = a[0].getAttribute("href");
 
307
        if (href == null) continue;
 
308
        if (endswith(href, this_app))
 
309
            tab_files = tabs.childNodes[i];
 
310
        else if (endswith(href, edit_app))
 
311
            tab_edit = tabs.childNodes[i];
 
312
    }
 
313
 
 
314
    if (editmode)
 
315
    {
 
316
        tab_files.removeAttribute("class");
 
317
        tab_edit.setAttribute("class", "thisapp");
 
318
    }
 
319
    else
 
320
    {
 
321
        tab_edit.removeAttribute("class");
 
322
        tab_files.setAttribute("class", "thisapp");
 
323
    }
 
324
}
 
325
 
421
326
/*** HANDLERS for different types of responses (such as dir listing, file,
422
327
 * etc). */
423
328
 
424
 
/* handle_error.
425
 
 * message may either be a string, or a DOM node, which will be placed inside
426
 
 * a div.
427
 
 */
428
329
function handle_error(message)
429
330
{
 
331
    setmode(false);
430
332
    var files = document.getElementById("filesbody");
431
 
    var txt_elem;
432
 
    if (typeof(message) == "string")
433
 
    {
434
 
        txt_elem = dom_make_text_elem("div", "Error: "
435
 
                   + message.toString() + ".")
436
 
    }
437
 
    else
438
 
    {
439
 
        /* Assume message is a DOM node */
440
 
        txt_elem = document.createElement("div");
441
 
        txt_elem.appendChild(message);
442
 
    }
 
333
    var txt_elem = dom_make_text_elem("div", "Error: "
 
334
        + message.toString() + ".")
443
335
    txt_elem.setAttribute("class", "padding error");
444
336
    files.appendChild(txt_elem);
445
337
}
446
338
 
447
 
/** Given a path, filename and optional revision, returns a URL to open that
448
 
 *  revision of that file.
 
339
/** Presents a path list (address bar inside the page) for clicking.
449
340
 */
450
 
function build_revision_url(path, filename, revision)
 
341
function presentpath(path)
451
342
{
452
 
    bits = {'path': app_path(this_app, path, filename)};
453
 
    if (current_revision)
 
343
    var dom_path = document.getElementById("path");
 
344
    var href_path = make_path(this_app);
 
345
    var nav_path = "";
 
346
    var dir;
 
347
 
 
348
    /* Also set the document title */
 
349
    document.title = path_basename(path) + " - IVLE";
 
350
    /* Create all of the paths */
 
351
    var pathlist = path.split("/");
 
352
    for (var i=0; i<pathlist.length; i++)
454
353
    {
455
 
        bits['query_string'] = 'r=' + revision;
 
354
        dir = pathlist[i];
 
355
        if (dir == "") continue;
 
356
        /* Make an 'a' element */
 
357
        href_path = path_join(href_path, dir);
 
358
        nav_path = path_join(nav_path, dir);
 
359
        var link = dom_make_link_elem("a", dir, "Navigate to " + nav_path,
 
360
                href_path/*, "navigate(" + repr(href_path) + ")"*/);
 
361
        dom_path.appendChild(link);
 
362
        dom_path.appendChild(document.createTextNode("/"));
456
363
    }
457
 
    return build_url(bits);
 
364
    dom_path.removeChild(dom_path.lastChild);
458
365
}
459
366
 
460
367
/** Given a mime type, returns the path to the icon.
506
413
 */
507
414
function handle_binary(path)
508
415
{
 
416
    setmode(false);
509
417
    var files = document.getElementById("filesbody");
510
418
    var div = document.createElement("div");
511
419
    files.appendChild(div);
520
428
    div.appendChild(par2);
521
429
}
522
430
 
523
 
/* Enable or disable actions1 moreactions actions. Takes either a single
524
 
 * name, or an array of them.*/
525
 
function set_action_state(names, which, allow_on_revision)
526
 
{
527
 
    if (!(names instanceof Array)) names = Array(names);
528
 
 
529
 
    for (var i=0; i < names.length; i++)
530
 
    {
531
 
        element = document.getElementById('act_' + names[i]);
532
 
        if (which &&
533
 
            !(current_file.svnstatus == 'revision' && !allow_on_revision))
534
 
        {
535
 
            /* Enabling */
536
 
            element.setAttribute("class", "choice");
537
 
            element.removeAttribute("disabled");
538
 
        }
539
 
        else
540
 
        {
541
 
            /* Disabling */
542
 
            element.setAttribute("class", "disabled");
543
 
            element.setAttribute("disabled", "disabled");
544
 
        }
545
 
    }
546
 
}
547
 
 
548
 
function update_actions()
549
 
{
550
 
    var file;
551
 
    var numsel = selected_files.length;
552
 
    if (numsel <= 1)
553
 
    {
554
 
        if (numsel == 0)
555
 
        {
556
 
            /* Display information about the current directory instead */
557
 
            filename = path_basename(current_path);
558
 
            file = current_file;
559
 
        }
560
 
        else if (numsel == 1)
561
 
        {
562
 
            filename = selected_files[0];
563
 
            file = file_listing[filename];
564
 
        }
565
 
 
566
 
        /* Update each action node in the topbar.
567
 
         * This includes enabling/disabling actions as appropriate, and
568
 
         * setting href/onclick attributes. */
569
 
    }
570
 
 
571
 
    /* Open */
572
 
    /* Available if exactly one file is selected */
573
 
    var open = document.getElementById("act_open");
574
 
    if (numsel == 1)
575
 
    {
576
 
        open.setAttribute("class", "choice");
577
 
        if (file.isdir)
578
 
            open.setAttribute("title",
579
 
                "Navigate to this directory in the file browser");
580
 
        else
581
 
            open.setAttribute("title",
582
 
                "Edit or view this file");
583
 
        open.setAttribute("href", build_revision_url(current_path, filename,
584
 
                                                     current_revision));
585
 
    }
586
 
    else
587
 
    {
588
 
        open.setAttribute("class", "disabled");
589
 
        open.removeAttribute("title");
590
 
        open.removeAttribute("href");
591
 
    }
592
 
 
593
 
    /* Serve */
594
 
    /* Available if zero or one files are selected,
595
 
     * and only if this is a file, not a directory */
596
 
    var serve = document.getElementById("act_serve");
597
 
    if (numsel <= 1 && !file.isdir && current_file.svnstatus != 'revision')
598
 
    {
599
 
        serve.setAttribute("class", "choice");
600
 
        serve.setAttribute("onclick",
601
 
              "return maybe_save('The last saved version will be served.')");
602
 
        if (numsel == 0)
603
 
            serve.setAttribute("href",
604
 
                app_path(serve_app, current_path));
605
 
        else
606
 
            serve.setAttribute("href",
607
 
                app_path(serve_app, current_path, filename));
608
 
    }
609
 
    else
610
 
    {
611
 
        serve.setAttribute("class", "disabled");
612
 
        serve.removeAttribute("href");
613
 
        serve.removeAttribute("onclick");
614
 
    }
615
 
 
616
 
    /* Run */
617
 
    /* Available if exactly one file is selected,
618
 
     * and it is a Python file.
619
 
     */
620
 
    var run = document.getElementById("act_run");
621
 
     
622
 
    if (!file.isdir && file.type == "text/x-python" && numsel <= 1
623
 
        && current_file.svnstatus != 'revision')
624
 
    {
625
 
        if (numsel == 0)
626
 
        {
627
 
            // In the edit window
628
 
            var localpath = path_join('/home', current_path);
629
 
        }
630
 
        else
631
 
        {
632
 
            // In the browser window
633
 
            var localpath = path_join('/home', current_path, filename);
634
 
        }
635
 
        run.setAttribute("class", "choice");
636
 
        run.setAttribute("onclick", "runfile('" + localpath + "')");
637
 
    }
638
 
    else
639
 
    {
640
 
        run.setAttribute("class", "disabled");
641
 
        run.removeAttribute("onclick");
642
 
    }
643
 
 
644
 
    /* Download */
645
 
    /* Always available for current files.
646
 
     * If 0 files selected, download the current file or directory as a ZIP.
647
 
     * If 1 directory selected, download it as a ZIP.
648
 
     * If 1 non-directory selected, download it.
649
 
     * If >1 files selected, download them all as a ZIP.
650
 
     */
651
 
    var download = document.getElementById("act_download");
652
 
    if (current_file.svnstatus == 'revision')
653
 
    {
654
 
        download.setAttribute("class", "disabled");
655
 
        download.removeAttribute("onclick");
656
 
    }
657
 
    else if (numsel <= 1)
658
 
    {
659
 
        download.setAttribute("class", "choice")
660
 
        if (numsel == 0)
661
 
        {
662
 
            download.setAttribute("href",
663
 
                app_path(download_app, current_path));
664
 
            if (file.isdir)
665
 
                download.setAttribute("title",
666
 
                    "Download the current directory as a ZIP file");
667
 
            else
668
 
                download.setAttribute("title",
669
 
                    "Download the current file");
670
 
        }
671
 
        else
672
 
        {
673
 
            download.setAttribute("href",
674
 
                app_path(download_app, current_path, filename));
675
 
            if (file.isdir)
676
 
                download.setAttribute("title",
677
 
                    "Download the selected directory as a ZIP file");
678
 
            else
679
 
                download.setAttribute("title",
680
 
                    "Download the selected file");
681
 
        }
682
 
    }
683
 
    else
684
 
    {
685
 
        /* Make a query string with all the files to download */
686
 
        var dlpath = urlencode_path(app_path(download_app, current_path)) + "?";
687
 
        for (var i=0; i<numsel; i++)
688
 
            dlpath += "path=" + encodeURIComponent(selected_files[i]) + "&";
689
 
        dlpath = dlpath.substr(0, dlpath.length-1);
690
 
        download.setAttribute("class", "choice")
691
 
        download.setAttribute("href", dlpath);
692
 
        download.setAttribute("title",
693
 
            "Download the selected files as a ZIP file");
694
 
    }
695
 
 
696
 
    /* Refresh - No changes required */
697
 
 
698
 
    /* Publish and Submit */
699
 
    /* If this directory is under subversion and selected/unselected file is a
700
 
     * directory. */
701
 
    var publish = document.getElementById("act_publish");
702
 
    var submit = document.getElementById("act_submit");
703
 
    var pubcond = numsel <= 1 && file.isdir;
704
 
    if (pubcond)
705
 
    {
706
 
        /* TODO: Work out of file is svn'd */
707
 
        /* If this dir is already published, call it "Unpublish" */
708
 
        if (file.published)
709
 
        {
710
 
            publish.setAttribute("value", "unpublish");
711
 
            publish.setAttribute("title" ,"Make it so this directory "
712
 
                + "can not be seen by anyone on the web");
713
 
            publish.textContent = "Unpublish";
714
 
        } else {
715
 
            publish.setAttribute("value", "publish");
716
 
            publish.setAttribute("title","Make it so this directory "
717
 
                + "can be seen by anyone on the web");
718
 
            publish.textContent = "Publish";
719
 
        }
720
 
    }
721
 
    set_action_state(["publish", "submit"], pubcond);
722
 
 
723
 
    /* Share */
724
 
    /* If exactly 1 non-directory file is selected, and its parent
725
 
     * directory is published.
726
 
     */
727
 
    set_action_state("share", numsel == 1 && !file.isdir &&
728
 
                     current_file.published);
729
 
 
730
 
    /* Rename */
731
 
    /* If exactly 1 file is selected */
732
 
    set_action_state("rename", numsel == 1);
733
 
 
734
 
    /* Delete, cut, copy */
735
 
    /* If >= 1 file is selected */
736
 
    set_action_state(["delete", "cut", "copy"], numsel >= 1);
737
 
 
738
 
    /* Paste, new file, new directory, upload */
739
 
    /* Disable if the current file is not a directory */
740
 
    set_action_state(["paste", "newfile", "mkdir", "upload"], current_file.isdir);
741
 
 
742
 
    /* Subversion actions */
743
 
    /* These are only useful if we are in a versioned directory and have some
744
 
     * files selected. */
745
 
    set_action_state(["svnadd", "svnremove", "svnrevert", "svncommit"], numsel >= 1 && current_file.svnstatus);
746
 
 
747
 
    /* Diff, log and update only support one path at the moment, so we must
748
 
     * have 0 or 1 versioned files selected. If 0, the directory must be
749
 
     * versioned. */
750
 
    single_versioned_path = (
751
 
         (
752
 
          (numsel == 1 && (svnst = file_listing[selected_files[0]].svnstatus)) ||
753
 
          (numsel == 0 && (svnst = current_file.svnstatus))
754
 
         ) && svnst != "unversioned");
755
 
    set_action_state(["svndiff", "svnupdate"], single_versioned_path);
756
 
 
757
 
    /* We can resolve if we have a file selected and it is conflicted. */
758
 
    set_action_state("svnresolved", single_versioned_path && numsel == 1 && svnst == "conflicted");
759
 
 
760
 
    /* Log should be available for revisions as well. */
761
 
    set_action_state("svnlog", single_versioned_path, true);
762
 
 
763
 
    /* There is currently nothing on the More Actions menu of use
764
 
     * when the current file is not a directory. Hence, just remove
765
 
     * it entirely.
766
 
     * (This makes some of the above decisions somewhat redundant).
767
 
     * We also take this opportunity to show the appropriate actions2
768
 
     * bar for this path. It should either be a save or upload widget.
769
 
     */
770
 
    if (current_file.isdir)
771
 
    {
772
 
        var actions2_directory = document.getElementById("actions2_directory");
773
 
        actions2_directory.setAttribute("style", "display: inline;");
774
 
        var moreactions = document.getElementById("moreactions_area");
775
 
        moreactions.setAttribute("style", "display: inline;");
776
 
    }
777
 
    else
778
 
    {
779
 
        var actions2_file = document.getElementById("actions2_file");
780
 
        actions2_file.setAttribute("style", "display: inline;");
781
 
    }
782
 
 
783
 
    return;
784
 
}
785
 
 
786
 
/** Event handler for when an item of the "More actions..." dropdown box is
787
 
 * selected. Performs the selected action. */
788
 
function handle_moreactions()
789
 
{
790
 
    var moreactions = document.getElementById("moreactions");
791
 
    if (moreactions.value == "top")
792
 
        return;
793
 
    var selectedaction = moreactions.value;
794
 
    /* Reset to "More actions..." */
795
 
    moreactions.selectedIndex = 0;
796
 
 
797
 
    /* If 0 files selected, filename is the name of the current dir.
798
 
     * If 1 file selected, filename is that file.
799
 
     */
800
 
    if (selected_files.length == 0)
801
 
        filename = path_basename(current_path);
802
 
    else if (selected_files.length == 1)
803
 
        filename = selected_files[0];
804
 
    else
805
 
        filename = null;
806
 
 
807
 
    /* Now handle the selected action */
808
 
    switch(selectedaction)
809
 
    {
810
 
    case "publish":
811
 
        action_publish(selected_files);
812
 
        break;
813
 
    case "unpublish":
814
 
        action_unpublish(selected_files);
815
 
        break;
816
 
    case "share":
817
 
        //alert("Not yet implemented: Sharing files");
818
 
        window.open(public_app_path(serve_app, current_path, filename), 'share')
819
 
        break;
820
 
    case "submit":
821
 
        // TODO
822
 
        alert("Not yet implemented: Submit");
823
 
        break;
824
 
    case "rename":
825
 
        action_rename(filename);
826
 
        break;
827
 
    case "delete":
828
 
        action_delete(selected_files);
829
 
        break;
830
 
    case "copy":
831
 
        action_copy(selected_files);
832
 
        break;
833
 
    case "cut":
834
 
        action_cut(selected_files);
835
 
        break;
836
 
    case "paste":
837
 
        action_paste();
838
 
        break;
839
 
    case "newfile":
840
 
        action_newfile();
841
 
        break;
842
 
    case "mkdir":
843
 
        action_mkdir();
844
 
        break;
845
 
    case "upload":
846
 
        show_uploadpanel(true);
847
 
        break;
848
 
    case "svnadd":
849
 
        action_add(selected_files);
850
 
        break;
851
 
    case "svnremove":
852
 
        action_remove(selected_files);
853
 
        break;
854
 
    case "svnrevert":
855
 
        action_revert(selected_files);
856
 
        break;
857
 
    case "svndiff":
858
 
        window.location = path_join(app_path('diff'), current_path, selected_files[0] || '');
859
 
        break;
860
 
    case "svnupdate":
861
 
        action_update(selected_files);
862
 
        break;
863
 
    case "svnresolved":
864
 
        action_resolved(selected_files);
865
 
        break;
866
 
    case "svncommit":
867
 
        action_commit(selected_files);
868
 
        break;
869
 
    case "svnlog":
870
 
        window.location = path_join(app_path('svnlog'), current_path, selected_files[0] || '');
871
 
        break;
872
 
    }
873
 
}
874
 
 
875
 
/** User clicks "Run" button.
876
 
 * Do an Ajax call and print the test output.
877
 
 */
878
 
function runfile(localpath)
879
 
{
880
 
    if (!maybe_save('The last saved version will be run.')) return false;
881
 
 
882
 
    /* Dump the entire file to the console */
883
 
    var callback = function()
884
 
    {
885
 
        console_enter_line("execfile('" + localpath + "')", "block");
886
 
    }
887
 
    start_server(callback)
888
 
    return;
889
 
}
890
 
 
891
431
/** Called when the page loads initially.
892
432
 */
893
 
function browser_init()
 
433
window.onload = function()
894
434
{
895
435
    /* Navigate (internally) to the path in the URL bar.
896
436
     * This causes the page to be populated with whatever is at that address,
899
439
    var path = parse_url(window.location.href).path;
900
440
    /* Strip out root_dir + "/files" from the front of the path */
901
441
    var strip = make_path(this_app);
 
442
    var editmode = false;
902
443
    if (path.substr(0, strip.length) == strip)
903
444
        path = path.substr(strip.length+1);
904
445
    else
908
449
        if (path.substr(0, strip.length) == strip)
909
450
        {
910
451
            path = path.substr(strip.length+1);
 
452
            editmode = true;
911
453
        }
912
454
    }
913
455
 
918
460
        path = username;
919
461
    }
920
462
 
921
 
    navigate(path);
 
463
    navigate(path, editmode);
922
464
}