xpra icon
Bug tracker and wiki

Ticket #2701: add-remove-semicolons2.patch

File add-remove-semicolons2.patch, 42.8 KB (added by brief, 3 months ago)
  • Client.js

     
    8282        this.PING_FREQUENCY = 5000;
    8383        this.INFO_FREQUENCY = 1000;
    8484        this.uuid = Utilities.getHexUUID();
    85 }
     85};
    8686
    8787XpraClient.prototype.init_state = function(container) {
    8888        // state
     
    153153        this.ping_timeout_timer = null;
    154154        this.ping_grace_timer = null;
    155155        this.ping_timer = null;
    156         this.last_ping_server_time = 0
    157         this.last_ping_local_time = 0
     156        this.last_ping_server_time = 0;
     157        this.last_ping_local_time = 0;
    158158        this.last_ping_echoed_time = 0;
    159159        this.server_ping_latency = 0;
    160160        this.client_ping_latency = 0;
     
    210210        else if (Utilities.isEventSupported("DOMMouseScroll")) {
    211211                div.addEventListener('DOMMouseScroll',  on_mousescroll, false); // for Firefox
    212212        }
    213 }
     213};
    214214
    215215XpraClient.prototype.send = function() {
    216216        if (this.protocol) {
    217217                this.protocol.send.apply(this.protocol, arguments);
    218218        }
    219 }
     219};
    220220
    221221XpraClient.prototype.send_log = function(level, args) {
    222222        if(this.remote_logging && this.server_remote_logging && this.connected) {
     
    233233                        }
    234234                }
    235235        }
    236 }
     236};
    237237XpraClient.prototype.exc = function() {
    238238        //first argument is the exception:
    239239        var exception = arguments[0];
     
    251251                        //we tried our best
    252252                }
    253253        }
    254 }
     254};
    255255XpraClient.prototype.error = function() {
    256256        //logging.ERROR = 40
    257257        this.send_log(40, arguments);
    258258        this.cerror.apply(this, arguments);
    259 }
     259};
    260260XpraClient.prototype.cerror = function() {
    261261        Utilities.cerror.apply(Utilities, arguments);
    262 }
     262};
    263263XpraClient.prototype.warn = function() {
    264264        //logging.WARN = 30
    265265        this.send_log(30, arguments);
    266266        this.cwarn.apply(this, arguments);
    267 }
     267};
    268268XpraClient.prototype.cwarn = function() {
    269269        Utilities.cwarn.apply(Utilities, arguments);
    270 }
     270};
    271271XpraClient.prototype.log = function() {
    272272        //logging.INFO = 20
    273273        this.send_log(20, arguments);
    274274        this.clog.apply(this, arguments);
    275 }
     275};
    276276XpraClient.prototype.clog = function() {
    277277        Utilities.clog.apply(Utilities, arguments);
    278 }
     278};
    279279XpraClient.prototype.debug = function() {
    280280        var category = arguments[0];
    281281        var args = Array.from(arguments);
     
    287287                }
    288288                this.cdebug.apply(this, arguments);
    289289        }
    290 }
     290};
    291291XpraClient.prototype.cdebug = function() {
    292292        Utilities.cdebug.apply(Utilities, arguments);
    293 }
     293};
    294294
    295295
    296296XpraClient.prototype.init = function(ignore_blacklist) {
     
    298298        this.init_audio(ignore_blacklist);
    299299        this.init_packet_handlers();
    300300        this.init_keyboard();
    301 }
     301};
    302302
    303303
    304304XpraClient.prototype.init_packet_handlers = function() {
     
    342342                'setting-change': this._process_setting_change,
    343343                'pointer-position': this._process_pointer_position,
    344344        };
    345 }
     345};
    346346
    347347XpraClient.prototype.on_connection_progress = function(state, details, progress) {
    348348        //can be overriden
    349349        this.clog(state, details);
    350 }
     350};
    351351
    352352XpraClient.prototype.callback_close = function(reason) {
    353353        if (reason === undefined) {
     
    354354                reason = "unknown reason";
    355355        }
    356356        this.clog("connection closed: "+reason);
    357 }
     357};
    358358
    359359XpraClient.prototype.connect = function() {
    360360        var details = this.host + ":" + this.port + this.path;
     
    391391                        default:
    392392                                me.clog("client got unknown message from worker");
    393393                                me._do_connect(false);
    394                         };
     394                        }
    395395                }, false);
    396396                // ask the worker to check for websocket support, when we receive a reply
    397397                // through the eventlistener above, _do_connect() will finish the job
     
    398398                worker.postMessage({'cmd': 'check'});
    399399        } else {
    400400                // no webworker support
    401                 this.clog("no webworker support at all.")
     401                this.clog("no webworker support at all.");
    402402                me._do_connect(false);
    403403        }
    404 }
     404};
    405405
    406406XpraClient.prototype._do_connect = function(with_worker) {
    407407        if(with_worker && !(XPRA_CLIENT_FORCE_NO_WORKER)) {
     
    410410                this.protocol = new XpraProtocol();
    411411        }
    412412        this.open_protocol();
    413 }
     413};
    414414
    415415XpraClient.prototype.open_protocol = function() {
    416416        // set protocol to deliver packets to our packet router
     
    426426        this.uri = uri;
    427427        this.on_connection_progress("Opening WebSocket connection", uri, 60);
    428428        this.protocol.open(uri);
    429 }
     429};
    430430
    431431XpraClient.prototype.close = function() {
    432432        this.clog("client closed");
     
    434434        this.clear_timers();
    435435        this.close_audio();
    436436        this.close_protocol();
    437 }
     437};
    438438
    439439XpraClient.prototype.request_refresh = function(wid) {
    440440        this.send([
     
    445445                },
    446446                {},     //no client_properties
    447447                ])
    448 }
     448};
    449449
    450450XpraClient.prototype.redraw_windows = function() {
    451451        for (var i in this.id_to_window) {
     
    452452                var iwin = this.id_to_window[i];
    453453                this.request_redraw(iwin);
    454454        }
    455 }
     455};
    456456
    457457XpraClient.prototype.close_windows = function() {
    458458        for (var i in this.id_to_window) {
     
    460460                window.removeWindowListItem(i);
    461461                iwin.destroy();
    462462        }
    463 }
     463};
    464464
    465465XpraClient.prototype.close_protocol = function() {
    466466        this.connected = false;
     
    468468                this.protocol.close();
    469469                this.protocol = null;
    470470        }
    471 }
     471};
    472472
    473473XpraClient.prototype.clear_timers = function() {
    474474        this.stop_info_timer();
     
    488488                clearTimeout(this.ping_grace_timer);
    489489                this.ping_grace_timer = null;
    490490        }
    491 }
     491};
    492492
    493493XpraClient.prototype.enable_encoding = function(encoding) {
    494494        // add an encoding to our hello.encodings list
    495495        this.clog("enable", encoding);
    496496        this.enabled_encodings.push(encoding);
    497 }
     497};
    498498
    499499XpraClient.prototype.disable_encoding = function(encoding) {
    500500        // remove an encoding from our hello.encodings.core list
     
    504504        if(index > -1) {
    505505                this.supported_encodings.splice(index, 1);
    506506        }
    507 }
     507};
    508508
    509509XpraClient.prototype._route_packet = function(packet, ctx) {
    510510        // ctx refers to `this` because we came through a callback
     
    519519        } else {
    520520                fn(packet, ctx);
    521521        }
    522 }
     522};
    523523
    524524XpraClient.prototype._screen_resized = function(event, ctx) {
    525525        // send the desktop_size packet so server knows we changed size
     
    536536                var iwin = ctx.id_to_window[i];
    537537                iwin.screen_resized();
    538538        }
    539 }
     539};
    540540
    541541/**
    542542 * Keyboard
     
    565565                        e.preventDefault();
    566566                }
    567567        });
    568 }
     568};
    569569
    570570
    571571XpraClient.prototype._keyb_get_modifiers = function(event) {
     
    577577        //convert generic modifiers "meta" and "alt" into their x11 name:
    578578        var modifiers = get_event_modifiers(event);
    579579        return this.translate_modifiers(modifiers);
    580 }
     580};
    581581
    582582XpraClient.prototype.translate_modifiers = function(modifiers) {
    583583        /**
     
    632632        }
    633633        //this.clog("altgr_state=", this.altgr_state, ", altgr_modifier=", this.altgr_modifier, ", modifiers=", new_modifiers);
    634634        return new_modifiers;
    635 }
     635};
    636636
    637637
    638638XpraClient.prototype._check_browser_language = function(key_layout) {
     
    678678                //check again after 100ms minimum
    679679                this.browser_language_change_embargo_time = now + 100;
    680680        }
    681 }
     681};
    682682
    683683
    684684XpraClient.prototype._keyb_process = function(pressed, event) {
     
    742742
    743743        var DOM_KEY_LOCATION_RIGHT = 2;
    744744        if (keyname.match("_L$") && event.location==DOM_KEY_LOCATION_RIGHT)
    745                 keyname = keyname.replace("_L", "_R")
     745                keyname = keyname.replace("_L", "_R");
    746746
    747747        //AltGr: keep track of pressed state
    748748        if (str=="AltGraph" || (keyname=="Alt_R" && Utilities.isWindows())) {
     
    852852                allow_default = true;
    853853        }
    854854        return allow_default;
    855 }
     855};
    856856
    857857
    858858XpraClient.prototype._keyb_onkeydown = function(event, ctx) {
     
    867867        if (this.keyboard_layout)
    868868                return this.keyboard_layout;
    869869        return Utilities.getKeyboardLayout();
    870 }
     870};
    871871
    872872XpraClient.prototype._get_keycodes = function() {
    873873        //keycodes.append((nn(keyval), nn(name), nn(keycode), nn(group), nn(level)))
     
    879879        }
    880880        //show("keycodes="+keycodes.toSource());
    881881        return keycodes;
    882 }
     882};
    883883
    884884XpraClient.prototype._get_desktop_size = function() {
    885885        return [this.desktop_width, this.desktop_height];
    886 }
     886};
    887887
    888888XpraClient.prototype._get_DPI = function() {
    889889        "use strict";
     
    898898                return (screen.systemXDPI + screen.systemYDPI) / 2;
    899899        //default:
    900900        return 96;
    901 }
     901};
    902902
    903903XpraClient.prototype._get_screen_sizes = function() {
    904904        var dpi = this._get_DPI();
     
    913913                        ];
    914914        //just a single screen:
    915915        return [screen];
    916 }
     916};
    917917
    918918XpraClient.prototype._get_encodings = function() {
    919919        if(this.enabled_encodings.length == 0) {
     
    924924                this.clog("return just enabled encodings: ", this.enabled_encodings);
    925925                return this.enabled_encodings;
    926926        }
    927 }
     927};
    928928
    929929XpraClient.prototype._update_capabilities = function(appendobj) {
    930930        for (var attr in appendobj) {
    931931                this.capabilities[attr] = appendobj[attr];
    932932        }
    933 }
     933};
    934934
    935935/**
    936936 * Ping
     
    950950                        iwin.set_spinner(this.server_ok);
    951951                }
    952952        }
    953 }
     953};
    954954
    955955XpraClient.prototype._check_echo_timeout = function(ping_time) {
    956956        if (this.reconnect_in_progress) {
     
    967967                        this.callback_close("server ping timeout, waited "+ this.PING_TIMEOUT +"ms without a response");
    968968                }
    969969        }
    970 }
     970};
    971971
    972972
    973973XpraClient.prototype._emit_event = function(event_type) {
     
    974974        var event = document.createEvent("Event");
    975975        event.initEvent(event_type, true, true);
    976976        document.dispatchEvent(event);
    977 }
     977};
    978978XpraClient.prototype.emit_connection_lost = function(event_type) {
    979979        this._emit_event("connection-lost");
    980 }
     980};
    981981XpraClient.prototype.emit_connection_established = function(event_type) {
    982982        this._emit_event("connection-established");
    983 }
     983};
    984984
    985985
    986986/**
     
    10221022        }
    10231023        // send the packet
    10241024        this.send(["hello", this.capabilities]);
    1025 }
     1025};
    10261026
    10271027XpraClient.prototype._make_hello_base = function() {
    10281028        this.capabilities = {};
     
    11231123        if(this.start_new_session) {
    11241124                this._update_capabilities({"start-new-session" : this.start_new_session});
    11251125        }
    1126 }
     1126};
    11271127
    11281128XpraClient.prototype._make_hello = function() {
    11291129        var selections = null;
     
    12301230                "printing"                                      : this.printing,
    12311231                "file-size-limit"                       : 10,
    12321232        });
    1233 }
     1233};
    12341234
    12351235
    12361236XpraClient.prototype.on_first_ui_event = function() {
    12371237        //this hook can be overriden
    1238 }
     1238};
    12391239
    12401240XpraClient.prototype._new_ui_event = function() {
    12411241        if (this.ui_events==0) {
     
    12421242                this.on_first_ui_event();
    12431243        }
    12441244        this.ui_events++;
    1245 }
     1245};
    12461246
    12471247/**
    12481248 * Mouse handlers
     
    12921292
    12931293XpraClient.prototype.on_mousescroll = function(e) {
    12941294        this.do_window_mouse_scroll(e, null);
    1295 }
     1295};
    12961296
    12971297
    12981298XpraClient.prototype._window_mouse_move = function(ctx, e, window) {
    12991299        ctx.do_window_mouse_move(e, window);
    1300 }
     1300};
    13011301XpraClient.prototype.do_window_mouse_move = function(e, window) {
    13021302        if (this.server_readonly || this.mouse_grabbed || !this.connected) {
    13031303                return;
     
    13121312                wid = window.wid;
    13131313        }
    13141314        this.send(["pointer-position", wid, [x, y], modifiers, buttons]);
    1315 }
     1315};
    13161316
    13171317XpraClient.prototype._window_mouse_down = function(ctx, e, window) {
    13181318        ctx.mousedown_event = e;
    13191319        ctx.do_window_mouse_click(e, window, true);
    1320 }
     1320};
    13211321
    13221322XpraClient.prototype._window_mouse_up = function(ctx, e, window) {
    13231323        //this.mousedown_event = null;
    13241324        ctx.do_window_mouse_click(e, window, false);
    1325 }
     1325};
    13261326
    13271327XpraClient.prototype.do_window_mouse_click = function(e, window, pressed) {
    13281328        if (this.server_readonly || this.mouse_grabbed || !this.connected) {
     
    13581358                this.clipboard_delayed_event_time = Utilities.monotonicTime()+CLIPBOARD_EVENT_DELAY;
    13591359                me.send(["button-action", wid, button, pressed, [x, y], modifiers, buttons]);
    13601360        }, send_delay);
    1361 }
     1361};
    13621362
    13631363XpraClient.prototype._window_mouse_scroll = function(ctx, e, window) {
    13641364        ctx.do_window_mouse_scroll(e, window);
    1365 }
     1365};
    13661366
    13671367XpraClient.prototype.do_window_mouse_scroll = function(e, window) {
    13681368        if (this.server_readonly || this.mouse_grabbed || !this.connected) {
     
    14371437        //store left overs:
    14381438        this.wheel_delta_x = (this.wheel_delta_x>=0) ? wx : -wx;
    14391439        this.wheel_delta_y = (this.wheel_delta_y>=0) ? wy : -wy;
    1440 }
     1440};
    14411441
    14421442
    14431443XpraClient.prototype._poll_clipboard = function(e) {
     
    14671467        if (!clipboardData) {
    14681468                clipboardData = window.clipboardData;
    14691469                if (!clipboardData) {
    1470                         this.debug("clipboard", "polling: no data available")
     1470                        this.debug("clipboard", "polling: no data available");
    14711471                        return false;
    14721472                }
    14731473        }
     
    14841484        this.send_clipboard_token(clipboard_buffer);
    14851485        this.clipboard_delayed_event_time = Utilities.monotonicTime()+CLIPBOARD_EVENT_DELAY;
    14861486        return true;
    1487 }
     1487};
    14881488
    14891489
    14901490/**
     
    15271527                iwin.update_zindex();
    15281528        }
    15291529        //client._set_favicon(wid);
    1530 }
     1530};
    15311531
    15321532/*
    15331533 * packet processing functions start here
     
    15351535
    15361536XpraClient.prototype.on_open = function() {
    15371537        //this hook can be overriden
    1538 }
     1538};
    15391539
    15401540XpraClient.prototype._process_open = function(packet, ctx) {
    15411541        // call the send_hello function
     
    15471547        }, ctx.HELLO_TIMEOUT);
    15481548        ctx._send_hello();
    15491549        ctx.on_open();
    1550 }
     1550};
    15511551
    15521552XpraClient.prototype._process_error = function(packet, ctx) {
    15531553        ctx.cerror("websocket error: ", packet[1], "reason: ", ctx.disconnect_reason);
     
    15621562                // call the client's close callback
    15631563                ctx.callback_close(ctx.disconnect_reason);
    15641564        }
    1565 }
     1565};
    15661566
    15671567
    15681568XpraClient.prototype.do_reconnect = function() {
     
    15871587                        me.reconnect_in_progress = false;
    15881588                }
    15891589        }, this.reconnect_delay);
    1590 }
     1590};
    15911591
    15921592XpraClient.prototype._process_close = function(packet, ctx) {
    15931593        ctx.clog("websocket closed: ", packet[1], "reason: ", ctx.disconnect_reason, ", reconnect: ", ctx.reconnect, ", reconnect attempt: ", ctx.reconnect_attempt);
     
    16051605        else {
    16061606                ctx.close();
    16071607        }
    1608 }
     1608};
    16091609
    16101610XpraClient.prototype.close = function() {
    16111611        this.emit_connection_lost();
     
    16151615        this.close_protocol();
    16161616        // call the client's close callback
    16171617        this.callback_close(this.disconnect_reason);
    1618 }
     1618};
    16191619
    16201620XpraClient.prototype._process_disconnect = function(packet, ctx) {
    16211621        // save the disconnect reason
     
    16281628        ctx.close();
    16291629        // call the client's close callback
    16301630        ctx.callback_close(reason);
    1631 }
     1631};
    16321632
    16331633XpraClient.prototype._process_startup_complete = function(packet, ctx) {
    16341634        ctx.log("startup complete");
    16351635        ctx.emit_connection_established();
    1636 }
     1636};
    16371637
    16381638XpraClient.prototype._connection_change = function(e) {
    16391639        var ci = Utilities.getConnectionInfo();
     
    16411641        if (ci && this.server_connection_data) {
    16421642                this.send(["connection-data", ci]);
    16431643        }
    1644 }
     1644};
    16451645
    16461646
    16471647XpraClient.prototype._process_hello = function(packet, ctx) {
     
    16741674                ctx.protocol.set_cipher_out(ctx.cipher_out_caps, ctx.encryption_key);
    16751675        }
    16761676        // find the modifier to use for Num_Lock
    1677         var modifier_keycodes = hello['modifier_keycodes']
     1677        const modifier_keycodes = hello['modifier_keycodes'];
    16781678        if (modifier_keycodes) {
    16791679                for (var modifier in modifier_keycodes) {
    16801680                        if (modifier_keycodes.hasOwnProperty(modifier)) {
     
    17941794        }
    17951795        ctx.server_resize_exact = hello["resize_exact"] || false;
    17961796        ctx.server_screen_sizes = hello["screen-sizes"] || [];
    1797         ctx.clog("server screen sizes:", ctx.server_screen_sizes)
     1797        ctx.clog("server screen sizes:", ctx.server_screen_sizes);
    17981798
    17991799        ctx.server_precise_wheel = hello["wheel.precise"] || false;
    18001800
     
    18161816        if (navigator.connection) {
    18171817                navigator.connection.onchange = function() {
    18181818                        ctx._connection_change();
    1819                 }
     1819                };
    18201820                ctx._connection_change();
    18211821        }
    18221822
     
    18301830        ctx.on_connection_progress("Session started", "", 100);
    18311831        ctx.on_connect();
    18321832        ctx.connected = true;
    1833 }
     1833};
    18341834
    18351835XpraClient.prototype._process_encodings = function(packet, ctx) {
    18361836        var caps = packet[1];
    18371837        ctx.log("update encodings:", caps);
    1838 }
     1838};
    18391839
    18401840
    18411841XpraClient.prototype.process_xdg_menu = function() {
     
    19101910                li.appendChild(ul);
    19111911                startmenu.appendChild(li);
    19121912        }
    1913 }
     1913};
    19141914
    19151915
    19161916XpraClient.prototype._process_setting_change = function(packet, ctx) {
     
    19221922                        ctx.process_xdg_menu();
    19231923                }
    19241924        }
    1925 }
     1925};
    19261926
    19271927XpraClient.prototype.xdg_image = function(icon_data, icon_type) {
    19281928        var img = new Image();
     
    19411941        img.height = 24;
    19421942        img.width = 24;
    19431943        return img
    1944 }
     1944};
    19451945
    19461946
    19471947
    19481948XpraClient.prototype.on_connect = function() {
    19491949        //this hook can be overriden
    1950 }
     1950};
    19511951
    19521952XpraClient.prototype._process_challenge = function(packet, ctx) {
    19531953        ctx.clog("process challenge");
     
    20012001        else {
    20022002                this.callback_close("server requested an unsupported digest " + digest);
    20032003        }
    2004 }
     2004};
    20052005
    20062006XpraClient.prototype._gendigest = function(digest, password, salt) {
    20072007        if (digest.startsWith("hmac")) {
     
    20202020        } else {
    20212021                return null;
    20222022        }
    2023 }
     2023};
    20242024
    20252025
    20262026XpraClient.prototype._send_ping = function() {
     
    20392039        this.ping_grace_timer = setTimeout(function () {
    20402040                me._check_server_echo(now_ms);
    20412041        }, wait);
    2042 }
     2042};
    20432043
    20442044XpraClient.prototype._process_ping = function(packet, ctx) {
    20452045        var echotime = packet[1];
     
    20552055        ctx.last_ping_local_time = new Date().getTime();
    20562056        var l1=0, l2=0, l3=0;
    20572057        ctx.send(["ping_echo", echotime, l1, l2, l3, 0, sid]);
    2058 }
     2058};
    20592059
    20602060XpraClient.prototype._process_ping_echo = function(packet, ctx) {
    20612061        ctx.last_ping_echoed_time = packet[1];
     
    20672067        ctx.server_load = [l1/1000.0, l2/1000.0, l3/1000.0];
    20682068        // make sure server goes OK immediately instead of waiting for next timeout
    20692069        ctx._check_server_echo(0);
    2070 }
     2070};
    20712071
    20722072
    20732073/**
     
    20832083                        return true;
    20842084                }, this.INFO_FREQUENCY);
    20852085        }
    2086 }
     2086};
    20872087XpraClient.prototype.send_info_request = function() {
    20882088        if (!this.info_request_pending) {
    20892089                this.send(["info-request", [this.uuid], [], []]);
    20902090                this.info_request_pending = true;
    20912091        }
    2092 }
     2092};
    20932093XpraClient.prototype._process_info_response = function(packet, ctx) {
    20942094        ctx.info_request_pending = false;
    20952095        ctx.server_last_info = packet[1];
     
    20982098        event.initEvent('info-response', true, true);
    20992099        event.data = ctx.server_last_info;
    21002100        document.dispatchEvent(event);
    2101 }
     2101};
    21022102XpraClient.prototype.stop_info_timer = function() {
    21032103        if (this.info_timer) {
    21042104                clearTimeout(this.info_timer);
     
    21052105                this.info_timer = null;
    21062106                this.info_request_pending = false;
    21072107        }
    2108 }
     2108};
    21092109
    21102110
    21112111/**
     
    21532153                );
    21542154        ctx.id_to_window[wid] = win;
    21552155        ctx.send_tray_configure(wid);
    2156 }
     2156};
    21572157XpraClient.prototype.send_tray_configure = function(wid) {
    21582158        var div = jQuery("#" + String(wid));
    21592159        var x = Math.round(div.offset().left);
     
    21622162                h = float_menu_item_size;
    21632163        this.clog("tray", wid, "position:", x, y);
    21642164        this.send(["configure-window", Number(wid), x, y, w, h, {}]);
    2165 }
     2165};
    21662166XpraClient.prototype._tray_geometry_changed = function(win) {
    21672167        ctx.debug("tray", "tray geometry changed (ignored)");
    2168 }
     2168};
    21692169XpraClient.prototype._tray_set_focus = function(win) {
    21702170        ctx.debug("tray", "tray set focus (ignored)");
    2171 }
     2171};
    21722172XpraClient.prototype._tray_closed = function(win) {
    21732173        ctx.debug("tray", "tray closed (ignored)");
    2174 }
     2174};
    21752175
    21762176XpraClient.prototype.reconfigure_all_trays = function() {
    21772177        var float_menu = document.getElementById("float_menu");
     
    21882188        if($('#float_menu').width() > 0){
    21892189                float_menu.style.width = float_menu_width;
    21902190        }
    2191 }
     2191};
    21922192
    21932193/**
    21942194 * Windows
     
    22292229                this.send(["map-window", wid, geom.x, geom.y, geom.w, geom.h, this._get_client_properties(win)]);
    22302230                this._window_set_focus(win);
    22312231        }
    2232 }
     2232};
    22332233
    22342234XpraClient.prototype._new_window_common = function(packet, override_redirect) {
    22352235        var wid = packet[1],
     
    22442244                this.error("window dimensions are wrong:", w, h);
    22452245                w, h = 1, 1;
    22462246        }
    2247         var client_properties = {}
     2247        let client_properties = {};
    22482248        if (packet.length>=8)
    22492249                client_properties = packet[7];
    22502250        if (x==0 && y==0 && !metadata["set-initial-position"]) {
     
    22642264                        y = 96;
    22652265                }
    22662266        }
    2267         this._new_window(wid, x, y, w, h, metadata, override_redirect, client_properties)
     2267        this._new_window(wid, x, y, w, h, metadata, override_redirect, client_properties);
    22682268        this._new_ui_event();
    2269 }
     2269};
    22702270
    22712271XpraClient.prototype._window_closed = function(win) {
    22722272        win.client.send(["close-window", win.wid]);
    2273 }
     2273};
    22742274
    22752275XpraClient.prototype._get_client_properties = function(win) {
    22762276        var cp = win.client_properties;
    22772277        cp["encodings.rgb_formats"] = this.RGB_FORMATS;
    22782278        return cp;
    2279 }
     2279};
    22802280
    22812281XpraClient.prototype._window_geometry_changed = function(win) {
    22822282        // window callbacks are called from the XpraWindow function context
     
    22842284        var geom = win.get_internal_geometry();
    22852285        var wid = win.wid;
    22862286        win.client.send(["configure-window", wid, geom.x, geom.y, geom.w, geom.h, win.client._get_client_properties(win)]);
    2287 }
     2287};
    22882288
    22892289XpraClient.prototype._process_new_window = function(packet, ctx) {
    22902290        ctx._new_window_common(packet, false);
    2291 }
     2291};
    22922292
    22932293XpraClient.prototype._process_new_override_redirect = function(packet, ctx) {
    22942294        ctx._new_window_common(packet, true);
    2295 }
     2295};
    22962296
    22972297XpraClient.prototype._process_window_metadata = function(packet, ctx) {
    22982298        var wid = packet[1],
     
    23012301        if (win!=null) {
    23022302                win.update_metadata(metadata);
    23032303        }
    2304 }
     2304};
    23052305
    23062306XpraClient.prototype._process_initiate_moveresize = function(packet, ctx) {
    23072307        var wid = packet[1],
     
    23142314                        source_indication = packet[6];
    23152315                win.initiate_moveresize(ctx.mousedown_event, x_root, y_root, direction, button, source_indication)
    23162316        }
    2317 }
     2317};
    23182318
    23192319XpraClient.prototype._process_pointer_position = function(packet, ctx) {
    23202320        var wid = packet[1],
     
    23572357        style.left = x+"px";
    23582358        style.top = y+"px";
    23592359        style.display = "inline";
    2360 }
     2360};
    23612361
    23622362XpraClient.prototype.on_last_window = function() {
    23632363        //this hook can be overriden
    2364 }
     2364};
    23652365
    23662366XpraClient.prototype._process_lost_window = function(packet, ctx) {
    23672367        var wid = packet[1];
     
    23852385        if (Object.keys(ctx.id_to_window).length==0) {
    23862386                ctx.on_last_window();
    23872387        }
    2388 }
     2388};
    23892389
    23902390XpraClient.prototype._process_raise_window = function(packet, ctx) {
    23912391        var wid = packet[1];
     
    23932393        if (win!=null) {
    23942394                ctx._window_set_focus(win);
    23952395        }
    2396 }
     2396};
    23972397
    23982398XpraClient.prototype._process_window_resized = function(packet, ctx) {
    23992399        var wid = packet[1];
     
    24032403        if (win!=null) {
    24042404                win.resize(width, height);
    24052405        }
    2406 }
     2406};
    24072407
    24082408XpraClient.prototype._process_window_move_resize = function(packet, ctx) {
    24092409        var wid = packet[1];
     
    24152415        if (win!=null) {
    24162416                win.move_resize(x, y, width, height);
    24172417        }
    2418 }
     2418};
    24192419
    24202420XpraClient.prototype._process_configure_override_redirect = function(packet, ctx) {
    24212421        var wid = packet[1];
     
    24272427        if (win!=null) {
    24282428                win.move_resize(x, y, width, height);
    24292429        }
    2430 }
     2430};
    24312431
    24322432XpraClient.prototype._process_desktop_size = function(packet, ctx) {
    24332433        //root_w, root_h, max_w, max_h = packet[1:5]
    24342434        //we don't use this yet,
    24352435        //we could use this to clamp the windows to a certain area
    2436 }
     2436};
    24372437
    24382438XpraClient.prototype._process_bell = function(packet, ctx) {
    24392439        var percent = packet[3];
     
    24542454                snd.play();
    24552455        }
    24562456        return;
    2457 }
     2457};
    24582458
    24592459/**
    24602460 * Notifications
     
    25312531                                });
    25322532        }
    25332533        ctx._new_ui_event();
    2534 }
     2534};
    25352535
    25362536XpraClient.prototype._process_notify_close = function(packet, ctx) {
    25372537        nid = packet[1];
     
    25382538        if(window.closeNotification) {
    25392539                window.closeNotification(nid);
    25402540        }
    2541 }
     2541};
    25422542
    25432543
    25442544/**
     
    25502550                window.reset_cursor();
    25512551        }
    25522552        return;
    2553 }
     2553};
    25542554
    25552555XpraClient.prototype._process_cursor = function(packet, ctx) {
    25562556        if (packet.length==2) {
     
    25762576                var window = ctx.id_to_window[wid];
    25772577                window.set_cursor(encoding, w, h, xhot, yhot, img_data);
    25782578        }
    2579 }
     2579};
    25802580
    25812581XpraClient.prototype._process_window_icon = function(packet, ctx) {
    25822582        var wid = packet[1];
     
    25932593                        jQuery("#favicon").attr("href", src);
    25942594                }
    25952595        }
    2596 }
     2596};
    25972597
    25982598/**
    25992599 * Window Painting
     
    26092609        } else {
    26102610                ctx._process_draw_queue(packet, ctx);
    26112611        }
    2612 }
     2612};
    26132613
    26142614XpraClient.prototype._process_eos = function(packet, ctx) {
    26152615        ctx._process_draw(packet, ctx);
    2616 }
     2616};
    26172617
    26182618
    26192619XpraClient.prototype.request_redraw = function(win) {
     
    26472647                // requestAnimationFrame is not available, draw immediately
    26482648                win.draw();
    26492649        }
    2650 }
     2650};
    26512651
    26522652XpraClient.prototype._process_draw_queue = function(packet, ctx){
    26532653        if(!packet && ctx.queue_draw_packets){
     
    27212721                win.may_paint_now();
    27222722                ctx.request_redraw(win);
    27232723        }
    2724 }
     2724};
    27252725
    27262726
    27272727/**
     
    27942794                this.log("using "+this.audio_framework+" audio codec: "+this.audio_codec);
    27952795        }
    27962796        this.log("audio codecs: ", Object.keys(this.audio_codecs));
    2797 }
     2797};
    27982798
    27992799XpraClient.prototype._sound_start_receiving = function() {
    28002800        if (!this.audio_framework || !this.audio_codec) {
     
    28282828        catch(e) {
    28292829                this.exc(e, "error starting audio player");
    28302830        }
    2831 }
     2831};
    28322832
    28332833
    28342834XpraClient.prototype._send_sound_start = function() {
    28352835        this.log("audio: requesting "+this.audio_codec+" stream from the server");
    28362836        this.send(["sound-control", "start", this.audio_codec]);
    2837 }
     2837};
    28382838
    28392839
    28402840XpraClient.prototype._sound_start_httpstream = function() {
     
    28602860        this.audio.appendChild(source);
    28612861        this.log("starting http stream from", url);
    28622862        document.body.appendChild(this.audio);
    2863 }
     2863};
    28642864
    28652865XpraClient.prototype._sound_start_aurora = function() {
    28662866        this.audio_aurora_ctx = AV.Player.fromXpraSource();
    28672867        this._send_sound_start();
    2868 }
     2868};
    28692869
    28702870XpraClient.prototype._sound_start_mediasource = function() {
    28712871        var me = this;
     
    29022902
    29032903        //attach the MediaSource to the <audio> element:
    29042904        this.audio.src = window.URL.createObjectURL(this.media_source);
    2905         this.audio_buffers = []
     2905        this.audio_buffers = [];
    29062906        this.audio_buffers_count = 0;
    29072907        this.audio_source_ready = false;
    29082908        this.clog("audio waiting for source open event on", this.media_source);
     
    29392939                me.audio_source_ready = true;
    29402940                me._send_sound_start();
    29412941        });
    2942 }
     2942};
    29432943
    29442944XpraClient.prototype.close_audio = function() {
    29452945        if (this.protocol) {
     
    29552955                this._close_audio_aurora();
    29562956        }
    29572957        this.on_audio_state_change("stopped", "closed");
    2958 }
     2958};
    29592959
    29602960XpraClient.prototype._close_audio_httpstream = function() {
    29612961        this._remove_audio_element();
    2962 }
     2962};
    29632963
    29642964XpraClient.prototype._close_audio_aurora = function() {
    29652965        if(this.audio_aurora_ctx) {
     
    29732973                }
    29742974                this.audio_aurora_ctx = null;
    29752975        }
    2976 }
     2976};
    29772977
    29782978XpraClient.prototype._close_audio_mediasource = function() {
    29792979        this.log("close_audio_mediasource: audio_source_buffer="+this.audio_source_buffer+", media_source="+this.media_source+", audio="+this.audio);
     
    29962996                }
    29972997                this._remove_audio_element();
    29982998        }
    2999 }
     2999};
    30003000
    30013001XpraClient.prototype._remove_audio_element = function() {
    30023002        if (this.audio!=null) {
     
    30103010                }
    30113011                this.audio = null;
    30123012        }
    3013 }
     3013};
    30143014
    30153015XpraClient.prototype._process_sound_data = function(packet, ctx) {
    30163016        if (packet[1]!=ctx.audio_codec) {
     
    30433043                ctx.exc(e, "sound data error");
    30443044                ctx.close_audio();
    30453045        }
    3046 }
     3046};
    30473047
    30483048XpraClient.prototype.on_audio_state_change = function(newstate, details) {
    30493049        this.debug("on_audio_state_change:", newstate, details);
    30503050        this.audio_state = newstate;
    30513051        //can be overriden
    3052 }
     3052};
    30533053
    30543054XpraClient.prototype.add_sound_data = function(codec, buf, metadata) {
    30553055        var MIN_START_BUFFERS = 4;
     
    31093109                }
    31103110                this.audio_buffers = [];
    31113111        }
    3112 }
     3112};
    31133113
    31143114XpraClient.prototype._audio_start_stream = function() {
    31153115        this.debug("audio", "audio start of "+this.audio_framework+" "+this.audio_codec+" stream");
     
    31353135                me.log("invalid start-of-stream data for unknown framework:", this.audio_framework);
    31363136        }
    31373137        this.on_audio_state_change("waiting", ""+this.audio_framework+" playing "+this.audio_codec+" stream");
    3138 }
     3138};
    31393139
    31403140XpraClient.prototype._audio_ready = function() {
    31413141        if (this.audio_framework=="mediasource") {
     
    31503150        else {
    31513151                return (this.audio_aurora_ctx!=null);
    31523152        }
    3153 }
     3153};
    31543154
    31553155XpraClient.prototype.push_audio_buffer = function(buf) {
    31563156        if (this.audio_framework=="mediasource") {
     
    31863186                                                        //"events=", this.audio_aurora_ctx.asset.source.events);
    31873187        }
    31883188        this.on_audio_state_change("playing", "");
    3189 }
     3189};
    31903190
    31913191
    31923192/**
     
    31943194 */
    31953195XpraClient.prototype.get_clipboard_buffer = function() {
    31963196        return this.clipboard_buffer;
    3197 }
     3197};
    31983198XpraClient.prototype.get_clipboard_datatype = function() {
    31993199        return this.clipboard_datatype;
    3200 }
     3200};
    32013201
    32023202XpraClient.prototype.send_clipboard_token = function(data) {
    32033203        if (!this.clipboard_enabled) {
     
    32193219                        claim, greedy, synchronous];
    32203220        }
    32213221        this.send(packet);
    3222 }
     3222};
    32233223
    32243224XpraClient.prototype._process_clipboard_token = function(packet, ctx) {
    32253225        if (!ctx.clipboard_enabled) {
     
    32713271                                if (navigator.clipboard && navigator.clipboard.writeText) {
    32723272                                        if (is_text) {
    32733273                                                navigator.clipboard.writeText(wire_data).then(function() {
    3274                                                         ctx.debug("clipboard", "writeText succeeded")
     3274                                                        ctx.debug("clipboard", "writeText succeeded");
    32753275                                                        ctx.clipboard_pending = false;
    32763276                                                }, function() {
    32773277                                                        ctx.debug("clipboard", "writeText failed")
     
    32963296                        });
    32973297                }
    32983298        }
    3299 }
     3299};
    33003300
    33013301XpraClient.prototype._process_set_clipboard_enabled = function(packet, ctx) {
    33023302        if (!ctx.clipboard_enabled) {
     
    33043304        }
    33053305        ctx.clipboard_enabled = packet[1];
    33063306        ctx.log("server set clipboard state to "+packet[1]+" reason was: "+packet[2]);
    3307 }
     3307};
    33083308
    33093309XpraClient.prototype._process_clipboard_request = function(packet, ctx) {
    33103310        // we shouldn't be handling clipboard requests
     
    33953395        }
    33963396        var clipboard_buffer = ctx.get_clipboard_buffer() || "";
    33973397        ctx.send_clipboard_string(request_id, selection, clipboard_buffer, "UTF8_STRING");
    3398 }
     3398};
    33993399
    34003400XpraClient.prototype.resend_clipboard_server_buffer = function(request_id, selection) {
    34013401        var server_buffer = this.clipboard_server_buffers["CLIPBOARD"];
     
    34103410        var wire_encoding = server_buffer[3];
    34113411        var wire_data = server_buffer[4];
    34123412        this.send_clipboard_contents(request_id, selection, dtype, dformat, wire_encoding, wire_data);
    3413 }
     3413};
    34143414
    34153415XpraClient.prototype.send_clipboard_string = function(request_id, selection, clipboard_buffer, datatype) {
    34163416        var packet;
     
    34213421        }
    34223422        this.debug("clipboard", "send_clipboard_string: packet=", packet);
    34233423        this.send(packet);
    3424 }
     3424};
    34253425
    34263426XpraClient.prototype.send_clipboard_contents = function(request_id, selection, datatype, dformat, encoding, clipboard_buffer) {
    34273427        var packet;
     
    34313431                packet = ["clipboard-contents", request_id, selection, datatype, dformat || 8, encoding || "bytes", clipboard_buffer];
    34323432        }
    34333433        this.send(packet);
    3434 }
     3434};
    34353435
    34363436/**
    34373437 * File transfers and printing
     
    34543454        else {
    34553455                ctx.save_file(basefilename, data, mimetype);
    34563456        }
    3457 }
     3457};
    34583458
    34593459XpraClient.prototype.save_file = function(filename, data, mimetype) {
    34603460        if (!this.file_transfer || !this.remote_file_transfer) {
     
    34663466        }
    34673467        this.log("saving "+data.length+" bytes of "+mimetype+" data to filename "+filename);
    34683468        Utilities.saveFile(filename, data, {type : mimetype});
    3469 }
     3469};
    34703470
    34713471XpraClient.prototype.print_document = function(filename, data, mimetype) {
    34723472        if (!this.printing || !this.remote_printing) {
     
    34873487                this.warn("popup blocked, saving to file instead");
    34883488                Utilities.saveFile(filename, data, {type : mimetype});
    34893489        }
    3490 }
     3490};
    34913491
    34923492XpraClient.prototype.send_file = function(filename, mimetype, size, buffer) {
    34933493        if (!this.file_transfer || !this.remote_file_transfer) {
     
    34963496        }
    34973497        var packet = ["send-file", filename, mimetype, false, this.remote_open_files, size, buffer, {}];
    34983498        this.send(packet);
    3499 }
     3499};
    35003500
    35013501XpraClient.prototype.start_command = function(name, command, ignore) {
    35023502        var packet = ["start-command", name, command, ignore];
    35033503        this.send(packet);
    3504 }
     3504};
    35053505
    35063506XpraClient.prototype._process_open_url = function(packet, ctx) {
    35073507        var url = packet[1];
     
    35213521                var timeout = 10;
    35223522                window.doNotification("", 0, summary, body, timeout, null, null, null, null, null);
    35233523        }
    3524 }
     3524};
  • Keycodes.js

     
    16461646        "Armenian"      : "am",
    16471647        "Georgian"      : "ge",
    16481648        "braille"       : "brai",
    1649 }
     1649};
    16501650
    16511651
    16521652/**
     
    17381738        CHARCODE_TO_NAME[111+i] = "F"+i;
    17391739}
    17401740//overrides: only for 'de' layout?
    1741 CHARCODE_TO_NAME[192] = "dead_circumflex"
    1742 CHARCODE_TO_NAME[219] = "backtick"
    1743 CHARCODE_TO_NAME[221] = "dead_acute"
    1744 CHARCODE_TO_NAME[220] = "dead_circumflex"
     1741CHARCODE_TO_NAME[192] = "dead_circumflex";
     1742CHARCODE_TO_NAME[219] = "backtick";
     1743CHARCODE_TO_NAME[221] = "dead_acute";
     1744CHARCODE_TO_NAME[220] = "dead_circumflex";
    17451745
    17461746
    17471747/**
  • Menu.js

     
    4848                        ul.classList.remove("-hide");
    4949                        ul.parentElement.classList.remove("-active");
    5050                        return;
    51                 };
     51                }
    5252
    5353        if(ul.classList.contains("-visible")){
    5454                        return;
  • Notifications.js

     
    9090                        }
    9191                });
    9292                return notification_button;
    93         }
     93        };
    9494
    9595        window.cancelNotificationTimer = function(nid) {
    9696                var timer = window.notification_timers[nid];
     
    9898                        window.clearInterval(timer);
    9999                        delete window.notification_timers[nid];
    100100                }
    101         }
     101        };
    102102        window.cancelNotificationTimers = function() {
    103103                for (var nid in window.notification_timers) {
    104104                        window.cancelNotificationTimer(nid);
    105105                }
    106         }
     106        };
    107107
    108108        window.closeNotification = function(nid) {
    109109                window.cancelNotificationTimer(nid);
    110110                var nID = 'notification' + nid;
    111111                $('.notifications').find('#'+nID).find('.dismiss').trigger('click');
    112         }
     112        };
    113113
    114114        window.clearNotifications = function(){
    115115                window.cancelNotificationTimers();
  • Protocol.js

     
    5353                default:
    5454                        console.error("got unknown command from worker");
    5555                        console.error(e.data);
    56                 };
     56                }
    5757        }, false);
    58 }
     58};
    5959
    6060XpraProtocolWorkerHost.prototype.close = function() {
    6161        this.worker.postMessage({'c': 'c'});
    62 }
     62};
    6363
    6464XpraProtocolWorkerHost.prototype.terminate = function() {
    6565        this.worker.postMessage({'c': 't'});
    66 }
     66};
    6767
    6868XpraProtocolWorkerHost.prototype.send = function(packet) {
    6969        this.worker.postMessage({'c': 's', 'p': packet});
    70 }
     70};
    7171
    7272XpraProtocolWorkerHost.prototype.set_packet_handler = function(callback, ctx) {
    7373        this.packet_handler = callback;
    7474        this.packet_ctx = ctx;
    75 }
     75};
    7676
    7777XpraProtocolWorkerHost.prototype.set_cipher_in = function(caps, key) {
    7878        this.worker.postMessage({'c': 'z', 'p': caps, 'k': key});
    79 }
     79};
    8080
    8181XpraProtocolWorkerHost.prototype.set_cipher_out = function(caps, key) {
    8282        this.worker.postMessage({'c': 'x', 'p': caps, 'k': key});
    83 }
     83};
    8484
    8585
    8686
     
    139139                                me.process_receive_queue();
    140140                        }, this.process_interval);
    141141        };
    142 }
     142};
    143143
    144144XpraProtocol.prototype.close = function() {
    145145        if (this.websocket) {
     
    150150                this.websocket.close();
    151151                this.websocket = null;
    152152        }
    153 }
     153};
    154154
    155155XpraProtocol.prototype.protocol_error = function(msg) {
    156156        console.error("protocol error:", msg);
     
    163163        this.rQ = [];
    164164        //and just tell the client to close (it may still try to re-connect):
    165165        this.packet_handler(['close', msg]);
    166 }
     166};
    167167
    168168XpraProtocol.prototype.process_receive_queue = function() {
    169169        while (this.websocket && this.do_process_receive_queue()) {
    170170        }
    171 }
     171};
    172172
    173173XpraProtocol.prototype.do_process_receive_queue = function() {
    174174        var i = 0, j = 0;
     
    371371                }
    372372        }
    373373        return this.rQ.length>0;
    374 }
     374};
    375375
    376376XpraProtocol.prototype.process_send_queue = function() {
    377377        while(this.sQ.length !== 0 && this.websocket) {
     
    397397                        var padding_size = this.cipher_out_block_size - (payload_size % this.cipher_out_block_size);
    398398                        for (var i = padding_size - 1; i >= 0; i--) {
    399399                                bdata += String.fromCharCode(padding_size);
    400                         };
     400                        }
    401401                        this.cipher_out.update(forge.util.createBuffer(bdata));
    402402                        bdata = this.cipher_out.output.getBytes();
    403403                }
     
    426426                        this.websocket.send((new Uint8Array(header)).buffer);
    427427                }
    428428        }
    429 }
     429};
    430430
    431431XpraProtocol.prototype.process_message_queue = function() {
    432432        while(this.mQ.length !== 0){
     
    439439                var raw_draw_buffer = (packet[0] === 'draw') && (packet[6] !== 'scroll');
    440440                postMessage({'c': 'p', 'p': packet}, raw_draw_buffer ? [packet[7].buffer] : []);
    441441        }
    442 }
     442};
    443443
    444444XpraProtocol.prototype.send = function(packet) {
    445445        this.sQ[this.sQ.length] = packet;
     
    447447        setTimeout(function() {
    448448                me.process_send_queue();
    449449                }, this.process_interval);
    450 }
     450};
    451451
    452452XpraProtocol.prototype.set_packet_handler = function(callback, ctx) {
    453453        this.packet_handler = callback;
    454454        this.packet_ctx = ctx;
    455 }
     455};
    456456
    457457XpraProtocol.prototype.set_cipher_in = function(caps, key) {
    458458        this.cipher_in_block_size = 32;
     
    461461        // start the cipher
    462462        this.cipher_in = forge.cipher.createDecipher('AES-CBC', secret);
    463463        this.cipher_in.start({iv: caps['cipher.iv']});
    464 }
     464};
    465465
    466466XpraProtocol.prototype.set_cipher_out = function(caps, key) {
    467467        this.cipher_out_block_size = 32;
     
    470470        // start the cipher
    471471        this.cipher_out = forge.cipher.createCipher('AES-CBC', secret);
    472472        this.cipher_out.start({iv: caps['cipher.iv']});
    473 }
     473};
    474474
    475475
    476476/*
     
    520520                        break;
    521521                default:
    522522                        postMessage({'c': 'l', 't': 'got unknown command from host'});
    523                 };
     523                }
    524524        }, false);
    525525        // tell host we are ready
    526526        postMessage({'c': 'r'});
  • Utilities.js

     
    485485                    section = match[1];
    486486                }else if(line.length == 0 && section){
    487487                    section = null;
    488                 };
     488                }
    489489            });
    490490            return value;
    491491        },
  • Window.js

     
    271271        this.updateCSSGeometry();
    272272        // now read all metadata
    273273        this.update_metadata(metadata);
    274 };
     274}
    275275
    276276XpraWindow.prototype._init_2d_canvas = function() {
    277277        this.offscreen_canvas = document.createElement("canvas");
     
    278278        this.updateCanvasGeometry();
    279279        this.offscreen_canvas_ctx = this.offscreen_canvas.getContext('2d');
    280280        this.offscreen_canvas_ctx.imageSmoothingEnabled = false;
    281 }
     281};
    282282
    283283XpraWindow.prototype.swap_buffers = function() {
    284284        //the up to date canvas is what we'll draw on screen:
     
    286286        this.draw_canvas = this.offscreen_canvas;
    287287        this._init_2d_canvas();
    288288        this.offscreen_canvas_ctx.drawImage(this.draw_canvas, 0, 0);
    289 }
     289};
    290290
    291291XpraWindow.prototype.set_spinner = function(state) {
    292292        if(state) {
     
    294294        } else {
    295295                this.spinnerdiv.css("display", "table");
    296296        }
    297 }
     297};
    298298
    299299XpraWindow.prototype.ensure_visible = function() {
    300300        if (this.client.server_is_desktop || this.client.server_is_shadow) {
     
    329329                return false;
    330330        }
    331331        return true;
    332 }
     332};
    333333
    334334XpraWindow.prototype.updateCanvasGeometry = function() {
    335335        // set size of both canvas if needed
     
    345345        if(this.offscreen_canvas.height != this.h) {
    346346                this.offscreen_canvas.height = this.h;
    347347        }
    348 }
     348};
    349349
    350350XpraWindow.prototype.updateCSSGeometry = function() {
    351351        // set size of canvas
     
    366366        jQuery(this.div).css('left', this.outerX);
    367367        jQuery(this.div).css('top', this.outerY);
    368368        this.debug("geometry", "updateCSSGeometry() left=", this.outerX, ", top=", this.outerY, ", width=", this.outerW, ", height=", this.outerH);
    369 }
     369};
    370370
    371371XpraWindow.prototype.updateFocus = function() {
    372372        if(this.focused) {
     
    377377                // set not in focus style
    378378                jQuery(this.div).removeClass("windowinfocus");
    379379        }
    380 }
     380};
    381381
    382382/**
    383383 * Mouse: delegate to client, telling it which window triggered the event.
     
    404404        this.mouse_scroll_cb(this.client, e, this);
    405405        //e.preventDefault();
    406406        return false;
    407 }
     407};
    408408
    409409/**
    410410 * toString allows us to identify windows by their unique window id.
     
    444444                z += 2500;
    445445        }
    446446        jQuery(this.div).css('z-index', z);
    447 }
     447};
    448448
    449449
    450450/**
     
    591591                jQuery(this.div).resizable("option", "maxHeight", maxh);
    592592        }
    593593        //TODO: aspectRatio, grid
    594 }
     594};
    595595
    596596
    597597/**
     
    618618                        "w"     : this.w,
    619619                        "h" : this.h};
    620620        this.debug("geometry", "save_geometry() saved-geometry=", this.saved_geometry);
    621 }
     621};
    622622/**
    623623 * Restores the saved geometry (if it exists).
    624624 */
     
    723723                jQuery(this.div).removeClass("window");
    724724                jQuery(this.div).addClass("undecorated");
    725725        }
    726 }
     726};
    727727
    728728/**
    729729 * Either:
     
    797797        this.ensure_visible();
    798798        // tell remote we have moved window
    799799        this.geometry_cb(this);
    800 }
     800};
    801801
    802802/**
    803803 * The "screen" has been resized, we may need to resize our window to match
     
    843843        if (this.x<0 || this.y<0) {
    844844                this.warn("window does not fit in canvas, offsets: ", x, y);
    845845        }
    846 }
     846};
    847847
    848848
    849849XpraWindow.prototype.match_screen_size = function() {
     
    953953                        resize_widget.trigger({ type: "mousedown", which: 1, pageX: pageX, pageY: pageY });
    954954                }
    955955        }
    956 }
     956};
    957957
    958958
    959959/**
     
    10231023        this._close_jsmpeg();
    10241024        this._close_broadway();
    10251025        this._close_video();
    1026 }
     1026};
    10271027
    10281028
    10291029/**
     
    10761076
    10771077XpraWindow.prototype._close_broadway = function() {
    10781078        this.broadway_decoder = null;
    1079 }
     1079};
    10801080
    10811081
    10821082XpraWindow.prototype._close_video = function() {
     
    10981098                this.video.remove();
    10991099                this.video = null;
    11001100        }
    1101 }
     1101};
    11021102
    11031103XpraWindow.prototype._push_video_buffers = function() {
    11041104        this.debug("draw", "_push_video_buffers()");
     
    11491149        this.video.addEventListener('error', function() { me.error("video error"); });
    11501150        this.video.src = window.URL.createObjectURL(this.media_source);
    11511151        //this.video.src = "https://html5-demos.appspot.com/static/test.webm"
    1152         this.video_buffers = []
     1152        this.video_buffers = [];
    11531153        this.video_buffers_count = 0;
    11541154        this.video_source_ready = false;
    11551155
     
    11971197                var height = this.video.getAttribute("height");
    11981198        this.offscreen_canvas_ctx.drawImage(this.video, 0, 0, width, height);
    11991199        }
    1200 }
     1200};
    12011201
    12021202
    12031203/**
     
    12101210        var item = Array.prototype.slice.call(arguments);
    12111211        this.paint_queue.push(item);
    12121212        this.may_paint_now();
    1213 }
     1213};
    12141214
    12151215/**
    12161216 * Pick items from the paint_queue
     
    12251225                this.do_paint.apply(this, item);
    12261226                now = Utilities.monotonicTime();
    12271227        }
    1228 }
     1228};
    12291229
    12301230var DEFAULT_BOX_COLORS = {
    12311231        "png"     : "yellow",
     
    12561256                //}
    12571257        }
    12581258        return this.jsmpeg_renderer;
    1259 }
     1259};
    12601260
    12611261XpraWindow.prototype._close_jsmpeg = function _close_jsmpeg() {
    12621262        if (this.jsmpeg_renderer!=null) {
     
    12641264        }
    12651265        //decoder doesn't need cleanup?
    12661266        this.jsmpeg_decoder = null;
    1267 }
     1267};
    12681268
    12691269XpraWindow.prototype.do_paint = function paint(x, y, width, height, coding, img_data, packet_sequence, rowstride, options, decode_callback) {
    12701270        this.debug("draw", "do_paint(", img_data.length, " bytes of ", ("zlib" in options?"zlib ":""), coding, " data ", width, "x", height, " at ", x, ",", y, ") focused=", this.focused);
     
    13561356                        j.onerror = function () {
    13571357                                paint_error("failed to load into image tag:", coding);
    13581358                                me.may_paint_now();
    1359                         }
     1359                        };
    13601360                        j.src = "data:image/"+coding+";base64," + Utilities.ArrayBufferToBase64(img_data);
    13611361                }
    13621362                else if (coding=="mpeg1") {
     
    13751375                                        var canvas = jsmpeg_renderer.canvas;
    13761376                                        me.offscreen_canvas_ctx.drawImage(canvas, x, y, width, height);
    13771377                                        paint_box("olive", x, y, width, height);
    1378                                 }
     1378                                };
    13791379                                renderer.resize = function resize(newWidth, newHeight) {
    13801380                                        var jsmpeg_renderer = me.get_jsmpeg_renderer();
    13811381                                        jsmpeg_renderer.resize(newWidth, newHeight);
    1382                                 }
     1382                                };
    13831383                                this.jsmpeg_decoder.connect(renderer);
    13841384                        }
    13851385                        var pts = frame;