### Navigation

- index
- modules |
- next |
- previous |
- Gate One Documentation »
- Developer Documentation »

# gateone.js

Gate One's JavaScript (source) is made up of several modules (aka plugins), each pertaining to a specific type of activity. These modules are laid out like so:

- GateOne.Base
- GateOne
- GateOne.Utils
- GateOne.Net
- GateOne.Input
- GateOne.Visual
- GateOne.Terminal
- GateOne.User

The properties and functions of each respective module are outlined below.

## GateOne.Base

`GateOne.``Base`

Note

Why is GateOne.Base before GateOne? Two reasons: 1) Because that's how it is laid out in the code. 2) The module-loading functions are all inside GateOne.Base.

The Base module is mostly copied from MochiKit and consists of the following:

> `GateOne.Base.``module`(parent, name, version, deps)

>   Creates a new name module in a parent namespace. This function will create a new empty module object with NAME, VERSION, toString and __repr__ properties. It will also verify that all the strings in deps are defined in parent, or an error will be thrown.

>   Arguments:

>   - parent (object) -- The parent module or namespace (object).
>   - name -- A string representing the new module name.
>   - version -- The version string for this module (e.g. "1.0").
>   - deps -- An array of module dependencies, as strings.

> The following example would create a new object named, "Net", attach it to the `GateOne` object, at version "0.9", with `GateOne.Base` and `GateOne.Utils` as dependencies:

> >     > GateOne.Base.module(GateOne, 'Net', '1.0', ['Base', 'Utils']);
> >     > GateOne.Net.__repr__();
> >     "[GateOne.Net 1.0]"
> >     > GateOne.Net.NAME;
> >     "GateOne.Net"

> `GateOne.Base.``update`(self, obj[, obj2, ...])

>   Mutate self by replacing its key:value pairs with those from other object(s). Key:value pairs from later objects will overwrite those from earlier objects.

>   If self is null, a new Object instance will be created and returned.

>   Warning

>   This mutates and returns self.

>   Arguments:

>   - self (object) -- The object you wish to mutate with obj.
>   - obj -- Any given JavaScript object (e.g. {}).

>   Returns: | self

> The following example would mutate GateOne.Net with a new function, "someFunc()".

> >     > GateOne.Base.update(GateOne.Net, {someFunc: function(i) { return "someFunc() was just executed with " + i + "."; }});
> >     > GateOne.Net.someFunc('1234');
> >     "someFunc() was just executed with 1234."

> Note

> In this example, if GateOne.Net.someFunc() already existed, it would be overridden.

> `GateOne.Base.update()` can be used to combine multiple sets of objects into one single object with latter objects taking precedence. Essentially, it's a way to emulate Python-style class mixins with JavaScript objects.

## GateOne

`GateOne`

GateOne is the base object for all of GateOne's client-side JavaScript. Besides the aforementioned modules (`Utils`, `Net`, `Input`, `Visual`, `Terminal`, and `User`), it contains the following properties, objects, and methods:

### Properties

- `GateOne.initialized`
- `GateOne.prefs`
- `GateOne.prefs.url`
- `GateOne.prefs.fillContainer`
- `GateOne.prefs.style`
- `GateOne.prefs.goDiv`
- `GateOne.prefs.scrollback`
- `GateOne.prefs.rows`
- `GateOne.prefs.cols`
- `GateOne.prefs.prefix`
- `GateOne.prefs.theme`
- `GateOne.prefs.colors`
- `GateOne.prefs.fontSize`
- `GateOne.prefs.autoConnectURL`
- `GateOne.prefs.embedded`
- `GateOne.prefs.skipChecks`
- `GateOne.prefs.showTitle`
- `GateOne.prefs.showToolbar`
- `GateOne.prefs.audibleBell`
- `GateOne.prefs.bellSound`
- `GateOne.prefs.bellSoundType`
- `GateOne.prefs.disableTermTransitions`

- `GateOne.prefs.colAdjust`
- `GateOne.prefs.rowAdjust`
- `GateOne.prefs.webWorker`
- `GateOne.prefs.auth`
- `GateOne.noSavePrefs`
- `GateOne.savePrefsCallbacks`
- `GateOne.terminals`
- `GateOne.terminals[num].backspace`
- `GateOne.terminals[num].columns`
- `GateOne.terminals[num].created`
- `GateOne.terminals[num].mode`
- `GateOne.terminals[num].playbackFrames`
- `GateOne.terminals[num].prevScreen`
- `GateOne.terminals[num].rows`
- `GateOne.terminals[num].screen`
- `GateOne.terminals[num].scrollback`
- `GateOne.terminals[num].scrollbackVisible`
- `GateOne.terminals[num].sshConnectString`
- `GateOne.Icons`
- `GateOne.loadedModules`
- `GateOne.ws`

Note

These are ordered by importance/usefulness.

#### prefs

`GateOne.``initialized`

  Type : | Boolean

  This gets set to `true` after `GateOne.initialize()` has completed all of its tasks.

`GateOne.``prefs`

  Type : | Object

  This is where all of Gate One's client-side preferences are kept. If the client changes them they will be saved in `localStorage['prefs']`. Also, these settings can be passed to `GateOne.init()` as an object in the first argument like so:

  >     GateOne.init({fillContainer: false, style: {'width': '50em', 'height': '32em'}, theme: 'white'});

  Each individual setting is outlined below:

  `GateOne.prefs.``url`

    Type : | String

        GateOne.prefs.url = window.location.href;

    URL of the Gate One server. Gate One will open a WebSocket to this URL, converting 'http://' and 'https://' to 'ws://' and 'wss://'.

  `GateOne.prefs.``fillContainer`

    Type : | Boolean

        GateOne.prefs.fillContainer = true;

    If set to true, `GateOne.prefs.goDiv` (e.g. `#gateone`) will fill itself out to the full size of its parent element.

  `GateOne.prefs.``style`

    Type : | Object

        GateOne.prefs.style = {};

    An object that will be used to apply styles to `GateOne.prefs.goDiv` element (`#gateone` by default). Example:

        GateOne.prefs.style = {'padding': '1em', 'margin': '0.5em'};

    Note

    `width` and `height` will be ignored if `GateOne.prefs.fillContainer` is true.

  `GateOne.prefs.``goDiv`

    Type : | String

        GateOne.prefs.goDiv = '#gateone';

    The element to place Gate One inside of. It can be any block element (or element set with `display: block` or `display: inline-block`) on the page embedding Gate One.

    Note

    To keep things simple it is recommended that a `<div>` be used (hence the name).

  `GateOne.prefs.``scrollback`

    Type : | Integer

        GateOne.prefs.scrollback = 500;

    The default number of lines of scrollback that clients will be instructed to use. The higher the number the longer it will take for the browser to re-enable the scrollback buffer after the 3.5-second screen update timeout is reached. 500 lines should only take a few milliseconds even on a slow computer (very high resolutions notwithstanding).

    Note

    Clients will still be able to change this value in the preferences panel even if you pass it to `GateOne.init()`.

  `GateOne.prefs.``rows`

    Type : | Integer

        GateOne.prefs.rows = null;

    This will force the number of rows in the terminal. If null, Gate One will automatically figure out how many will fit within `GateOne.prefs.goDiv`.

  `GateOne.prefs.``cols`

    Type : | Integer

        GateOne.prefs.cols = null;

    This will force the number of columns in the terminal. If null, Gate One will automatically figure out how many will fit within `GateOne.prefs.goDiv`.

  `GateOne.prefs.``prefix`

    Type : | String

        GateOne.prefs.prefix = 'go_';

    Instructs Gate One to prefix the 'id' of all elements it creates with this string (except `GateOne.prefs.goDiv` itself). You usually won't want to change this unless you're embedding Gate One into a page where a name conflict exists (e.g. you already have an element named `#go_notice`). The Gate One server will be made aware of this setting when the client connects so it can apply it to all generated templates where necessary.

  `GateOne.prefs.``theme`

    Type : | String

        GateOne.prefs.theme = 'black';

    This sets the default CSS theme. Clients will still be able to change it in the preferences if they wish.

  `GateOne.prefs.``colors`

    Type : | String

        GateOne.prefs.colors = 'default'; // 'gnome-terminal' is another text color scheme that comes with Gate One.

    This sets the CSS text color scheme. These are the colors that text renditions will use (i.e. when the terminal text is bold, red, etc).

  `GateOne.prefs.``fontSize`

    Type : | String

        GateOne.prefs.fontSize = '100%'; // Alternatives: '1em', '12pt', '15px', etc.

    This sets the base font size for everything in `GateOne.prefs.goDiv` (e.g. #gateone).

    Tip

    If you're embedding Gate One into something else this can be really useful for matching up Gate One's font size with the rest of your app.

  `GateOne.prefs.``autoConnectURL`

    Type : | String

        GateOne.prefs.autoConnectURL = null;

    If the SSH plugin is installed, this setting can be used to ensure that whenever a client connects it will automatically connect to the given SSH URL. Here's an example where Gate One would auto-connect as a guest user to localhost (hypothetical terminal program demo):

        GateOne.prefs.autoConnectURL = 'ssh://guest:guest@localhost:22';

    Warning

    If you provide a password in the ssh:// URL clients will be able to see it.

  `GateOne.prefs.``embedded`

    Type : | Boolean

        GateOne.prefs.embedded = false;

    This option tells Gate One (at the client) to run in embedded mode. In embedded mode there will be no toolbar, no side information panel, and new terminals will not be opened automatically. In essence, it just connects to the Gate One server, downloads additional JavaScript/CSS (plugins/themes), and calls each plugin's init() and postInit() functions (which may also behave differently in embedded mode). The point is to provide developers with the flexibility to control every aspect of Gate One's look and feel.

    In GateOne's 'tests' directory there is a walkthrough/tutorial of embedded mode called "hello_embedded". To run it simply execute ./hello_embedded.py and connect to https://localhost/ in your browser.

    Note

    Why is the hello_embedded tutorial separate from this documentation? It needs to be run on a different address/port than the Gate One server itself in order to properly demonstrate how Gate One would be embedded "in the wild." Also note that the documentation you're reading is meant to be viewable offline (e.g. file:///path/to/the/docs in your browser) but web browsers don't allow WebSocket connections from documents loaded via file:// URLs.

  `GateOne.prefs.``skipChecks`

    Type : | Boolean

        GateOne.prefs.skipChecks = false;

    If this is set to `true` Gate One will skip performing browser capabilities checks/alerts when `GateOne.init()` is called.

  `GateOne.prefs.``showTitle`

    Type : | Boolean

        GateOne.prefs.showTitle = true;

    If this is set to `false` Gate One will not show the terminal title in the sidebar.

  `GateOne.prefs.``showToolbar`

    Type : | Boolean

        GateOne.prefs.showToolbar = true;

    If this is set to `false` Gate One will not show the toolbar (no icons on the right).

  `GateOne.prefs.``audibleBell`

    Type : | Boolean

        GateOne.prefs.audibleBell = true;

    If this is set to `false` Gate One will not play a sound when a bell is encountered in any given terminal.

    Note

    A visual bell indiciator will still be displayed even if this is set to `false`.

  `GateOne.prefs.``bellSound`

    Type : | String

        GateOne.prefs.bellSound = "data:audio/ogg;base64,T2dnUwACAAAAAAAAA...";

    Stores the user's chosen (or the default) bell sound as a data URI.

    Note

    This is much more efficient than having to download this file from the server every time Gate One is loaded!

  `GateOne.prefs.``bellSoundType`

    Type : | String

        GateOne.prefs.bellSound = "audio/ogg";

    Stores the mimetype associated with `GateOne.prefs.bellSound`.

  `GateOne.prefs.``disableTermTransitions`

    Type : | Boolean

        GateOne.prefs.disableTermTransitions = false;

    With this enabled Gate One won't use fancy CSS3 transitions when switching between open terminals. Such switching will be instantaneous (i.e. not smooth/pretty).

  `GateOne.prefs.``colAdjust`

    Type : | Integer

        GateOne.prefs.colAdjust = 0;

    When the terminal size is calculated the number of columns will be decreased by this amount (e.g. to make room for an extra toolbar).

  `GateOne.prefs.``rowAdjust`

    Type : | Integer

        GateOne.prefs.rowAdjust = 0;

    When the terminal size is calculated the number of rows will be decreased by this amount (e.g. to make room for the playback controls).

  `GateOne.prefs.``webWorker`

    Type : | String

        GateOne.prefs.webWorker = "https://gateone.company.com/static/go_process.js";

    This is the fallback path to Gate One's Web Worker. You should only ever have to change this when embedding Gate One into another application and your Gate One server is listening on a different port than your app's web server. Otherwise Gate One will just use the Web Worker located at `GateOne.prefs.url`/static/go_process.js.

  `GateOne.prefs.``auth`

    Type : | Object

        GateOne.prefs.auth = { // This is just an example--not a default
            'api_key': 'MjkwYzc3MDI2MjhhNGZkNDg1MjJkODgyYjBmN2MyMTM4M',
            'upn': 'joe@company.com',
            'timestamp': 1323391717238,
            'signature': <encrypted gibberish>,
            'signature_method': 'HMAC-SHA1',
            'api_version': '1.0'
        };

    This is used to pre-authenticate users when Gate One is embedded into another application. It works like this: You enroll your app by creating an API key and secret via "./gateone.py --new_api_key". Then you use those generated values to sign the combined values of upn, timestamp, and api_key via HMAC-SHA1 using the secret that was created when you generated your API key. When Gate One sees these values it will verify them against the API keys/secrets it knows about and if everything lines up it will inherently trust the 'upn' (aka username) it has been given via this mechanism.

    This process allows parent applications (embedding Gate One) to authenticate a user just once instead of having users authenticate once for their own app and then once again for Gate One.

    Note

    If your app doesn't authenticate users you can still embed Gate One using the default (anonymous) authentication method. In these instances there's no need to pass an 'auth' parameter to `GateOne.init()`.

    More information about API-based authentication can be found in the "Embedding Gate One" documentation.

`GateOne.``noSavePrefs`

  Type : | Object

  Properties in this object that match the names of objects in `GateOne.prefs` will get ignored when they are saved to localStorage.

  Note

  Plugin Authors: If you want to have your own property in `GateOne.prefs` but it isn't a per-user setting, add your property here (e.g. `GateOne.prefs['myPref'] = 'foo'; GateOne.noSavePrefs['myPref'] = null;`).

  Here's what this object contains by default:

      GateOne.noSavePrefs = {
          url: null, // These are all things that shouldn't be modified by the user.
          webWorker: null,
          fillContainer: null,
          style: null,
          goDiv: null,
          prefix: null,
          autoConnectURL: null,
          embedded: null,
          auth: null,
          showTitle: null,
          showToolbar: null,
          rowAdjust: null,
          colAdjust: null
      }

`GateOne.``savePrefsCallbacks`

  Type : | Array

  Functions placed in this array will be called immediately after `GateOne.Utils.savePrefs()` is called. This gives plugins the ability to save their own preferences (in their own way) when the user clicks the "Save" button in the preferences panel.

`GateOne.``terminals`

  Type : | Object

  Terminal-specific settings and information are stored within this object like so:

  >     GateOne.terminals[1] = {
  >         X11Title = "Gate One",
  >         backspace: String.fromCharCode(127),
  >         columns: 165,
  >         created: Date(),
  >         mode: "default",
  >         node: <pre>,
  >         pasteNode: <textarea>,
  >         playbackFrames: Array(),
  >         prevScreen: Array(),
  >         rows: 45,
  >         screen: Array(),
  >         screenNode: <span>,
  >         scrollback: Array(),
  >         scrollbackNode: <span>,
  >         scrollbackTimer: 2311,
  >         scrollbackVisible: true,
  >         scrollbackWriteTimer: 2649
  >         sshConnectString: "user@localhost:22"
  >     };

  Each terminal in Gate One has its own object--referenced by terminal number--attached to `terminals` that gets created when a new terminal is opened (in `GateOne.Terminal.newTerminal()`). Theses values and what they mean are outlined below:

  `GateOne.terminals[num].``X11Title`

    Type : | String

        GateOne.terminals[num].X11Title = "New Terminal";

    When the server detects an X11 title escape sequence it sends it to the client and that value gets stored in this variable. This is separated from the terminal node's `title` attribute so that the user can restore the X11 title after they have overridden it.

  `GateOne.terminals[num].``backspace`

    Type : | String

        GateOne.terminals[num].backspace = String.fromCharCode(127);

    The backspace key used by this terminal. One of ^? (String.fromCharCode(127)) or ^H (String.fromCharCode(8)).

    Note

    Not configurable yet. Should be soon.

  `GateOne.terminals[num].``columns`

    Type : | Integer

        GateOne.terminals[num].columns = GateOne.prefs.cols;

    The number of columns this terminal is configured to use. Unless the user changed it, it will match whatever is in `GateOne.prefs.cols`.

  `GateOne.terminals[num].``created`

    Type : | Date()

        GateOne.terminals[num].created = new Date();

    The date and time a terminal was originally created.

  `GateOne.terminals[num].``mode`

    Type : | String

        GateOne.terminals[num].mode = "default";

    The current keyboard input mode of the terminal. One of "default" or "appmode" representing whether or not the terminal is in standard or "application cursor keys" mode (which changes what certain keystrokes send to the Gate One server).

  `GateOne.terminals[num].``node`

    Type : | DOM Node

        GateOne.terminals[num].node = <pre node object>

    Used as a quick reference to the terminal's <pre> node so we don't have to call `GateOne.Utils.getNode()` every time we need it.

  `GateOne.terminals[num].``pasteNode`

    Type : | DOM Node

        GateOne.terminals[num].node = <textarea node object>

    Used as a quick reference to the terminal's pastearea node (which hovers above all terminals so you can paste in a natural fashion).

  `GateOne.terminals[num].``playbackFrames`

    Type : | Array

        GateOne.terminals[num].playbackFrames = Array();

    This is where Gate One stores the frames of your session so they can be played back on-the-fly.

    Note

    playbackFrames only gets used if the playback plugin is available.

  `GateOne.terminals[num].``prevScreen`

    Type : | Array

        GateOne.terminals[num].prevScreen = Array(); // Whatever was last in GateOne.terminals[num].screen

    This stores the previous screen array from the last time the terminal was updated. Gate One's terminal update protocol only sends lines that changed since the last screen was sent. This variable allows us to create an updated screen from just the line that changed.

  `GateOne.terminals[num].``rows`

    Type : | Integer

        GateOne.terminals[num].rows = GateOne.prefs.rows;

    The number of rows this terminal is configured to use. Unless the user changed it, it will match whatever is in `GateOne.prefs.rows`.

  `GateOne.terminals[num].``screen`

    Type : | Array

        GateOne.terminals[num].screen = Array();

    This stores the current terminal's screen as an array of lines.

  `GateOne.terminals[num].``screenNode`

    Type : | DOM Node

        GateOne.terminals[num].node = <span node object>

    Used as a quick reference to the terminal's screen node (which is a span).

  `GateOne.terminals[num].``scrollback`

    Type : | Array

        GateOne.terminals[num].scrollback = Array();

    Stores the given terminal's scrollback buffer (so we can remove/replace it at-will).

  `GateOne.terminals[num].``scrollbackNode`

    Type : | DOM Node

        GateOne.terminals[num].scrollbackNode = <span node object>

    Used as a quick reference to the terminal's scrollback node (which is a span).

  `GateOne.terminals[num].``scrollbackVisible`

    Type : | Boolean

        GateOne.terminals[num].scrollbackVisible = true;

    Kept up to date on the current status of whether or not the scrollback buffer is visible in the terminal (so we don't end up replacing it or removing it when we don't have to).

  `GateOne.terminals[num].``scrollbackWriteTimer`

    Type : | String

        GateOne.terminals[num].scrollbackWriteTimer = <timeout object>;

    Whenever the scrollback buffer is updated a timer is set to write that scrollback to localStorage. If an update comes in before that timer finishes the existing timer will be cancelled and replaced. The idea is to prevent queueing up timers for scrollback that will just end up getting overwritten. The `scrollbackWriteTimer` attribute holds the reference to this timer.

  `GateOne.terminals[num].``sshConnectString`

    Type : | String

        GateOne.terminals[num].sshConnectString = "ssh://user@somehost:22"; // Will actually be whatever the user connected to

    If the SSH plugin is enabled, this variable contains the connection string used by the SSH client to connect to the server.

    Note

    This is a good example of a plugin using `GateOne.terminals` to great effect.

`GateOne.``Icons`

  Type : | Array

  This is where Gate One stores all of its (inline) SVG icons. If your plugin has its own icons they can be kept in here. Here's a (severely shortened) example from the Bookmarks plugin:

      GateOne.Icons['bookmark'] = '<svg xmlns:rdf="blah blah">svg stuff here</svg>';

  For reference, using an existing icon is as easy as:

      someElement.appendChild(GateOne.Icons['close']);

  Note

  All of Gate One's icons use a linearGradient that has stop points--stop1, stop2, stop3, and stop4--defined in CSS. This allows the SVG icons to change color with the CSS theme. If you're writing your own plugin with it's own icon(s) it would be best to use the same stop points.

`GateOne.``loadedModules`

  Type : | Array

  All modules (aka plugins) loaded via `GateOne.Base.module()` are kept here as a quick reference. For example:

      > GateOne.loadedModules;
      [
          "GateOne.Base",
          "GateOne.Utils",
          "GateOne.Net",
          "GateOne.Input",
          "GateOne.Visual",
          "GateOne.Terminal",
          "GateOne.User",
          "GateOne.Bookmarks",
          "GateOne.Help",
          "GateOne.Logging",
          "GateOne.Mobile",
          "GateOne.Playback",
          "GateOne.SSH"
      ]

`GateOne.``ws`

  Type : | WebSocket

  Holds Gate One's open WebSocket object. It can be used to send messages to WebSocket 'actions' (aka hooks) on the server like so:

      GateOne.ws.send(JSON.stringify({'my_plugin_function': {'someparam': true, 'whatever': [1,2,3]}}));

### Functions

- `GateOne.init()`
- `GateOne.initialize()`

`GateOne` contains two functions: `init()` and `initialize()`. These functions are responsible for setting up Gate One's interface, authenticating the user (if necessary), connecting to the server, (re)loading user preferences, and calling the init() function of each module/plugin:

> `GateOne.``init`(prefs)

>   Sets up preferences, loads the CSS theme/colors, loads JavaScript plugins, and calls `GateOne.Net.connect()` (which calls `initialize()` after the successfully connecting). Additionally, it will check if the user is authenticated and will force a re-auth if the credentials stored in the encrypted cookie don't check out.

>   Arguments:

>   - prefs (object) -- An object containing the settings that will be used by Gate One. See `GateOne.prefs` under Properties for details on what can be set.

>   Example:

>       GateOne.init({url: 'https://console12.serialconcentrators.mycompany.com/', theme: 'black'});

> `GateOne.``initialize`()

>   Sets up Gate One's graphical elements and starts Gate One capturing keyboard input.

## GateOne.Utils

`GateOne.``Utils`

This module consists of a collection of utility functions used throughout Gate One. Think of it like a mini JavaScript library of useful tools.

### Functions

- `GateOne.Utils.init`
- `GateOne.Utils.createBlob`
- `GateOne.Utils.createElement`
- `GateOne.Utils.deleteCookie`
- `GateOne.Utils.endsWith`
- `GateOne.Utils.enumerateThemes` ###
- `GateOne.Utils.getEmDimensions`
- `GateOne.Utils.getNode`
- `GateOne.Utils.getNodes`
- `GateOne.Utils.getOffset`
- `GateOne.Utils.getRowsAndColumns`
- `GateOne.Utils.getSelText`
- `GateOne.Utils.getToken`
- `GateOne.Utils.hasElementClass`
- `GateOne.Utils.hideElement`
- `GateOne.Utils.hideElements` ###
- `GateOne.Utils.init` ###
- `GateOne.Utils.isArray`
- `GateOne.Utils.isElement`
- `GateOne.Utils.isEven`
- `GateOne.Utils.isHTMLCollection`
- `GateOne.Utils.isNodeList`
- `GateOne.Utils.isPageHidden` ###
- `GateOne.Utils.isPrime`
- `GateOne.Utils.isVisible` ###
- `GateOne.Utils.itemgetter`
- `GateOne.Utils.items`
- `GateOne.Utils.loadCSS`

- `GateOne.Utils.loadPluginCSS`
- `GateOne.Utils.loadPrefs`
- `GateOne.Utils.loadScript`
- `GateOne.Utils.loadStyle` ###
- `GateOne.Utils.loadThemeCSS`
- `GateOne.Utils.ltrim` ###
- `GateOne.Utils.noop`
- `GateOne.Utils.partial`
- `GateOne.Utils.postInit` ###
- `GateOne.Utils.randomPrime`
- `GateOne.Utils.randomString`
- `GateOne.Utils.removeElement`
- `GateOne.Utils.replaceURLWithHTMLLinks`
- `GateOne.Utils.rtrim` ###
- `GateOne.Utils.runPostInit` ###
- `GateOne.Utils.saveAs`
- `GateOne.Utils.saveAsAction`
- `GateOne.Utils.savePrefs`
- `GateOne.Utils.scrollLines`
- `GateOne.Utils.scrollToBottom`
- `GateOne.Utils.setActiveStyleSheet`
- `GateOne.Utils.showElement`
- `GateOne.Utils.showElements` ###
- `GateOne.Utils.startsWith`
- `GateOne.Utils.stripHTML`
- `GateOne.Utils.toArray`
- `GateOne.Utils.xhrGet`

`GateOne.Utils.``init`()

  Like all plugin init() functions this gets called from `GateOne.Utils.runPostInit()` which itself is called at the end of `GateOne.initialize()`. It simply attaches a few actions like, 'save_file' to their respective functions in `GateOne.Net.actions`. Literally:

      GateOne.Net.addAction('save_file', GateOne.Utils.saveAsAction);
      GateOne.Net.addAction('load_style', GateOne.Utils.loadStyle);
      GateOne.Net.addAction('themes_list', GateOne.Utils.enumerateThemes);

`GateOne.Utils.``createBlob`(array, mimetype)

  Returns a Blob() object using the given array and mimetype. If mimetype is omitted it will default to 'text/plain'. Optionally, array may be given as a string in which case it will be automatically wrapped in an array.

  Arguments:

  - array (array) -- A string or array containing the data that the Blob will contain.
  - mimetype (string) -- A string representing the mimetype of the data (e.g. 'application/javascript').

  Returns: | A Blob()

  Examples:

      blob = GateOne.Utils.createBlob('some data here', 'text/plain);

`GateOne.Utils.``createElement`(tagname, properties)

  A simplified version of MochiKit's createDOM function, it creates a tagname (e.g. "div") element using the given properties.

  Arguments:

  - tagname (string) -- The type of element to create ("a", "table", "div", etc)
  - properties (object) -- An object containing the properties which will be pre-attached to the created element.

  Returns: | A node suitable for adding to the DOM.

  Examples:

      myDiv = GateOne.Utils.createElement('div', {'id': 'foo', 'style': {'opacity': 0.5, 'color': 'black'}});
      myAnchor = GateOne.Utils.createElement('a', {'id': 'liftoff', 'href': 'http://liftoffsoftware.com/'});
      myParagraph = GateOne.Utils.createElement('p', {'id': 'some_paragraph'});

  Note

  `createElement` will automatically apply `GateOne.prefs.prefix` to the 'id' of the created elements (if an 'id' was given).

`GateOne.Utils.``deleteCookie`(name, path, domain)

  Deletes the given cookie (name) from path for the given domain.

  Arguments:

  - name (string) -- The name of the cookie to delete.
  - path (string) -- The path of the cookie to delete (typically '/' but could be '/some/path/on/the/webserver' =).
  - path -- The domain where this cookie is from (an empty string means "the current domain in window.location.href").

  Examples:

      GateOne.Utils.deleteCookie('gateone_user', '/', ''); // Deletes the 'gateone_user' cookie

`GateOne.Utils.``endsWith`(substr, str)

  Returns true if str ends with substr.

  Arguments:

  - substr (string) -- The string that you want to see if str ends with.
  - str (string) -- The string you're checking substr against.

  Returns: | true/false

  Examples:

      > GateOne.Utils.endsWith('.txt', 'somefile.txt');
      true
      > GateOne.Utils.endsWith('.txt', 'somefile.svg');
      false

`GateOne.Utils.``enumerateThemes`(messageObj)

  Attached to the 'themes_list' action, updates the preferences panel with the list of themes stored on the server.

`GateOne.Utils.``getEmDimensions`(elem)

  Returns the height and width of 1em inside the given elem (e.g. '#term1_pre'). The returned object will be in the form of:

      {'w': <width in px>, 'h': <height in px>}

  Arguments:

  - elem -- A querySelector string like `#some_element_id` or a DOM node.

  Returns: | An object containing the width and height as obj.w and obj.h.

  Example:

      > GateOne.Utils.getEmDimensions('#gateone');
      {'w': 8, 'h': 15}

`GateOne.Utils.``getNode`(nodeOrSelector)

  Returns a DOM node if given a querySelector-style string or an existing DOM node (will return the node as-is).

  Note

  The benefit of this over just `document.querySelector()` is that if it is given a node it will return the node as-is (so functions can accept both without having to worry about such things). See `removeElement()` below for a good example.

  Arguments:

  - nodeOrSelector --

    A querySelector string like `#some_element_id` or a DOM node.

  Returns: | A DOM node or `null` if not found.

  Example:

      goDivNode = GateOne.Utils.getNode('#gateone');

      > GateOne.Utils.getEmDimensions('#gateone');
      {'w': 8, 'h': 15}

`GateOne.Utils.``getNodes`(nodeListOrSelector)

  Given a CSS querySelectorAll string (e.g. '.some_class') or NodeList (in case we're not sure), lookup the node using `document.querySelectorAll()` and return the result (which will be a NodeList).

  Note

  The benefit of this over just `document.querySelectorAll()` is that if it is given a nodeList it will just return the nodeList as-is (so functions can accept both without having to worry about such things).

  Arguments:

  - nodeListOrSelector --

    A querySelectorAll string like `.some_class` or a NodeList.

  Returns: | A NodeList or `[]` (an empty Array) if not found.

  Example:

      panels = GateOne.Utils.getNodes('#gateone .panel');

`GateOne.Utils.``getRowsAndColumns`(elem)

  Calculates and returns the number of text rows and colunmns that will fit in the given element (elem) as an object like so:

      {'cols': 165, 'rows': 45}

  Arguments:

  - elem --

    A querySelector string like `#some_element_id` or a DOM node.

  Returns: | An object with obj.cols and obj.rows representing the maximum number of columns and rows of text that will fit inside elem.

  Warning

  elem must be a basic block element such as DIV, SPAN, P, PRE, etc. Elements that require sub-elements such as TABLE (requires TRs and TDs) probably won't work.

  Note

  This function only works properly with monospaced fonts but it does work with high-resolution displays (so users with properly-configured high-DPI displays will be happy =). Other similar functions I've found on the web had hard-coded pixel widths for known fonts at certain point sizes. These break on any display with a resolution higher than 96dpi.

  Example:

      > GateOne.Utils.getRowsAndColumns('#gateone');
      {'cols': 165, 'rows': 45}

`GateOne.Utils.``getOffset`(elem)

  Returns: | An object representing `elem.offsetTop` and `elem.offsetLeft`.

  Example:

      > GateOne.Utils.getOffset(someNode);
      {"top":130, "left":50}

`GateOne.Utils.``getSelText`()

  Returns: | The text that is currently highlighted in the browser.

  Example:

      > GateOne.Utils.getSelText();
      "localhost" // Assuming the user had highlighted the word, "localhost"

`GateOne.Utils.``getToken`()

  This function is a work in progress... Doesn't do anything right now, but will (likely) eventually return time-based token (based on a random seed provided by the Gate One server) for use in an anti-session-hijacking mechanism.

`GateOne.Utils.``hasElementClass`(element, className)

  Almost a direct copy of MochiKit.DOM.hasElementClass... Returns true if className is found on element. element is looked up with `getNode()` so querySelector-style identifiers or DOM nodes are acceptable.

  Arguments:

  - element --

    A querySelector string like `#some_element_id` or a DOM node.

  - className -- The name of the class you're checking is applied to element.

  Returns: | true/false

  Example:

      > GateOne.Utils.hasElementClass('#go_panel_info', 'panel');
      true
      > GateOne.Utils.hasElementClass('#go_panel_info', 'foo');
      false

`GateOne.Utils.``hideElement`(elem)

  Hides the given element by setting `elem.style.display = 'none'`.

  Arguments:

  - elem --

    A querySelector string like `#some_element_id` or a DOM node.

  Example:

      > GateOne.Utils.hideElement('#go_icon_newterm');

`GateOne.Utils.``hideElements`(elems)

  Hides the given elements by setting `elem.style.display = 'none'` on all of them.

  Arguments:

  - elems --

    A querySelectorAll string like `.some_element_class`, a NodeList, or an array.

  Example:

      > GateOne.Utils.hideElements('.pastearea');

`GateOne.Utils.``isArray`(obj)

  Returns true if obj is an Array.

  Arguments:

  - obj (object) -- A JavaScript object.

  Returns: | true/false

  Example:

      > GateOne.Utils.isArray(GateOne.terminals['1'].screen);
      true

`GateOne.Utils.``isElement`(obj)

  Returns true if obj is an HTMLElement.

  Arguments:

  - obj (object) -- A JavaScript object.

  Returns: | true/false

  Example:

      > GateOne.Utils.isElement(GateOne.Utils.getNode('#gateone'));
      true

`GateOne.Utils.``isEven`(someNumber)

  Returns true if someNumber is even.

  Arguments:

  - someNumber (number) -- A JavaScript object.

  Returns: | true/false

  Example:

      > GateOne.Utils.isEven(2);
      true
      > GateOne.Utils.isEven(3);
      false

`GateOne.Utils.``isHTMLCollection`(obj)

  Returns true if obj is an HTMLCollection. HTMLCollection objects come from DOM level 1 and are what is returned by some browsers when you execute functions like document.getElementsByTagName. This function lets us know if the Array-like object we've got is an actual HTMLCollection (as opposed to a NodeList or just an Array).

  Arguments:

  - obj (object) -- A JavaScript object.

  Returns: | true/false

  Example:

      > GateOne.Utils.isHTMLCollection(document.getElementsByTagName('pre'));
      true // Will vary from browser to browser.  Don't you just love JavaScript programming?  Sigh.

`GateOne.Utils.``isNodeList`(obj)

  Returns true if obj is a NodeList. NodeList objects come from DOM level 3 and are what is returned by some browsers when you execute functions like document.getElementsByTagName. This function lets us know if the Array-like object we've got is an actual NodeList (as opposed to an HTMLCollection or just an Array).

  Arguments:

  - obj (object) -- A JavaScript object.

  Returns: | true/false

  Example:

      > GateOne.Utils.isHTMLCollection(document.getElementsByTagName('pre'));
      true // Just like isHTMLCollection this will vary

`GateOne.Utils.``isPageHidden`()

  Returns true if the page (browser tab) is hidden (e.g. inactive). Returns false otherwise.

  Example:

      > GateOne.Utils.isPageHidden();
      false

`GateOne.Utils.``isPrime`(n)

  Returns true if n is a prime number.

  Arguments:

  - n (number) -- The number we're checking to see if it is prime or not.

  Returns: | true/false

  Example:

      > GateOne.Utils.isPrime(13);
      true
      > GateOne.Utils.isPrime(14);
      false

`GateOne.Utils.``isVisible`(elem)

  Returns true if node is visible (checks parent nodes recursively too). node may be a DOM node or a selector string.

  Example:

      > GateOne.Utils.isVisible('#'+GateOne.prefs.prefix+'pastearea1');
      true

  Note

  Relies on checking elem.style.opacity and elem.style.display. Does not check transforms.

`GateOne.Utils.``itemgetter`(name)

  Copied from MochiKit.Base.itemgetter. Returns a `function(obj)` that returns `obj[name]`.

  Arguments:

  - name (value) -- The value that will be used as the key when the returned function is called to retrieve an item.

  Returns: | A function.

  To better understand what this function does it is probably best to simply provide the code:

      itemgetter: function (name) {
          return function (arg) {
              return arg[name];
          }
      }

  Here's an example of how to use it:

      > var object1 = {};
      > var object2 = {};
      > object1.someNumber = 12;
      > object2.someNumber = 37;
      > var numberGetter = GateOne.Utils.itemgetter("someNumber");
      > numberGetter(object1);
      12
      > numberGetter(object2);
      37

  Note

  Yes, it can be confusing. Especially when thinking up use cases but it actually is incredibly useful when the need arises!

`GateOne.Utils.``items`(obj)

  Copied from MochiKit.Base.items. Returns an Array of [propertyName, propertyValue] pairs for the given obj.

  Arguments:

  - obj (object) -- Any given JavaScript object.

  Returns: | Array

  Example:

      > GateOne.Utils.items(GateOne.terminals).forEach(function(item) { console.log(item) });
      ["1", Object]
      ["2", Object]

  Note

  Can be very useful for debugging.

`GateOne.Utils.``loadCSS`(url, id)

  Loads and applies the CSS at url. When the `<link>` element is created it will use id like so:

      {'id': GateOne.prefs.prefix + id}

  Arguments:

  - url (string) -- The URL path to the style sheet.
  - id (string) -- The 'id' that will be applied to the `<link>` element when it is created.

  Note

  If an existing `<link>` element already exists with the same id it will be overridden.

  Example:

      GateOne.Utils.loadCSS("static/themes/black.css", "black_theme");

`GateOne.Utils.``loadPrefs`()

  Populates `GateOne.prefs` with values from `localStorage[GateOne.prefs.prefix+'prefs']`.

`GateOne.Utils.``loadScript`(URL, callback)

  Loads the JavaScript (.js) file at URL and appends it to document.body. If callback is given, it will be called after the script has been loaded.

  Arguments:

  - URL (string) -- The URL of a JavaScript file.
  - callback (function) -- A function to call after the script has been loaded.

  Example:

      var myfunc = function() { console.log("finished loading whatever.js"); };
      GateOne.Utils.loadScript("/static/someplugin/whatever.js", myfunc);

`GateOne.Utils.``loadStyle`(message)

  Loads the stylesheet sent by the server via the 'load_style' WebSocket action.

`GateOne.Utils.``loadThemeCSS`(themeObj)

  Loads the GateOne CSS theme(s) for the given themeObj which should be in the form of:

      {'theme': 'black'}
      // or:
      {'colors': 'gnome-terminal'}
      // ...or an object containing both:
      {'theme': 'black', 'colors': 'gnome-terminal'}

  If themeObj is not provided, will load the defaults.

`GateOne.Utils.``ltrim`(string)

  Returns string minus left-hand whitespace

`GateOne.Utils.``noop`(a)

  AKA "No Operation". Returns whatever is given to it (if anything at all). In other words, this function doesn't do anything and that's exactly what it is supposed to do!

  Arguments:

  - a -- Anything you want.

  Returns: | a

  Example:

      var functionList = {'1': GateOne.Utils.noop, '2': GateOne.Utils.noop};

  Note

  This function is most useful as a placeholder for when you plan to update something in-place later. In the event that something never gets replaced, you can be assured that nothing bad will happen if it gets called (no exceptions).

`GateOne.Utils.``partial`(fn, arguments)

  Returns: | A partially-applied function.

  Similar to MochiKit.Base.partial. Returns partially applied function.

  Arguments:

  - fn (function) -- The function to ultimately be executed.
  - arguments (arguments) -- Whatever arguments you want to be pre-applied to fn.

  Example:

      > addNumbers = function (a, b) {
          return a + b;
      }
      > addOne = GateOne.Utils.partial(addNumbers, 1);
      > addOne(3);
      4

  Note

  This function can also be useful to simply save yourself a lot of typing. If you're planning on calling a function with the same parameters a number of times it is a good idea to use partial() to create a new function with all the parameters pre-applied. Can make code easier to read too.

`GateOne.Utils.``postInit`()

  Called by `GateOne.runPostInit()`, iterates over the list of plugins in `GateOne.loadedModules` calling the `init()` function of each (if present). When that's done it does the same thing with each respective plugin's `postInit()` function.

`GateOne.Utils.``randomPrime`()

  Returns: | A random prime number <= 9 digits.

  Example:

      > GateOne.Utils.randomPrime();
      618690239

`GateOne.Utils.``randomString`(length, chars)

  Returns: | A random string of the given length using the given chars.

  If chars is omitted the returned string will consist of lower-case ASCII alphanumerics.

  Arguments:

  - length (int) -- The length of the random string to be returned.
  - chars (string) -- Optional; a string containing the characters to use when generating the random string.

  Example:

      > GateOne.Utils.randomString(8);
      "oa2f9txf"
      > GateOne.Utils.randomString(8, '123abc');
      "1b3ac12b"

`GateOne.Utils.``removeElement`(elem)

  Removes the given elem from the DOM.

  Arguments:

  - elem --

    A querySelector string like `#some_element_id` or a DOM node.

  Example:

      GateOne.Utils.removeElement('#go_infocontainer');

`GateOne.Utils.``replaceURLWithHTMLLinks`(text)

  Returns: | text with URLs transformed into links.

  Turns textual URLs like 'http://whatever.com/' into links.

  Arguments:

  - text (string) -- Any text with or without links in it (no URLs == no changes)

  Example:

      > GateOne.Utils.replaceURLWithHTMLLinks('Downloading http://foo.bar.com/some/file.zip');
      "Downloading <a href='http://foo.bar.com/some/file.zip'>http://foo.bar.com/some/file.zip</a>"

`GateOne.Utils.``rtrim`(string)

  Returns string minus right-hand whitespace

`GateOne.Utils.``runPostInit`()

  Calls all module/plugin `init()` functions followed by all `postInit()` functions after the page is loaded and the WebSocket has been connected. Specifically it is called right near the end of `GateOne.initialize()` just before keyboard input is enabled.

`GateOne.Utils.``saveAs`(blob, filename)

  Saves the given blob (which must be a proper Blob object with data inside of it) as filename (as a file) in the browser. Just as if you clicked on a link to download it.

  Note

  This is amazingly handy for downloading files over the WebSocket.

`GateOne.Utils.``saveAsAction`(message)

  Note

  This function is attached to the 'save_file' WebSocket action (in `GateOne.Net.actions`) via `GateOne.Utils.init()`.

  Saves to disk the file contained in message. message should contain the following:

  > - message['result'] - Either 'Success' or a descriptive error message.
  > - message['filename'] - The name we'll give to the file when we save it.
  > - message['data'] - The content of the file we're saving.
  > - message['mimetype'] - Optional: The mimetype we'll be instructing the browser to associate with the file (so it will handle it appropriately). Will default to 'text/plain' if not given.

`GateOne.Utils.``savePrefs`()

  Saves what's set in `GateOne.prefs` to `localStorage['GateOne.prefs.prefix+prefs']` as JSON; skipping anything that's set in `GateOne.noSavePrefs`.

`GateOne.Utils.``scrollLines`(elem, lines)

  Scrolls the given element (elem) by the number given in lines. It will automatically determine the line height using `getEmDimensions()`. lines can be a positive or negative integer (to scroll down or up, respectively).

  Arguments:

  - elem --

    A querySelector string like `#some_element_id` or a DOM node.

  - lines (number) -- The number of lines to scroll elem by. Can be positive or negative.

  Example:

      GateOne.Utils.scrollLines('#go_term1_pre', -3);

  Note

  There must be a scrollbar visible (and `overflow-y = "auto"` or equivalent) for this to work.

`GateOne.Utils.``scrollToBottom`(elem)

  Scrolls the given element (elem) to the very bottom (all the way down).

  Arguments:

  - elem --

    A querySelector string like `#some_element_id` or a DOM node.

  Example:

      GateOne.Utils.scrollLines('#term1_pre');

`GateOne.Utils.``setActiveStyleSheet`(title)

  Sets the stylesheet matching title to be active.

  Thanks to Paul Sowden at A List Apart for this function. See: http://www.alistapart.com/articles/alternate/ for a great article on how to control active/alternate stylesheets in JavaScript.

  Arguments:

  - title (string) -- The title of the stylesheet to set active.

  Example:

      GateOne.Utils.setActiveStyleSheet("myplugin_stylesheet");

`GateOne.Utils.``showElement`(elem)

  Shows the given element (if previously hidden via `hideElement()`) by setting `elem.style.display = 'block'`.

  Arguments:

  - elem --

    A querySelector string like `#some_element_id` or a DOM node.

  Example:

      > GateOne.Utils.showElement('#go_icon_newterm');

`GateOne.Utils.``showElements`(elems)

  Shows the given elements (if previously hidden via `hideElement()` or `hideElements()`) by setting `elem.style.display = 'block'`.

  Arguments:

  - elems --

    A querySelectorAll string like `.some_element_class`, a NodeList, or an array.

  Example:

      > GateOne.Utils.showElements('.pastearea');

`GateOne.Utils.``startsWith`(substr, str)

  Returns true if str starts with substr.

  Arguments:

  - substr (string) -- The string that you want to see if str starts with.
  - str (string) -- The string you're checking substr against.

  Returns: | true/false

  Examples:

      > GateOne.Utils.startsWith('some', 'somefile.txt');
      true
      > GateOne.Utils.startsWith('foo', 'somefile.txt');
      false

`GateOne.Utils.``stripHTML`(html)

  Returns the contents of html minus the HTML.

  Arguments:

  - html (string) -- The string that you wish to strip HTML from.

  Returns: | The string with all HTML formatting removed.

  Examples:

      > GateOne.Utils.stripHTML('<span>This <b>is</b> a test</span>');
      "This is a test"

`GateOne.Utils.``toArray`(obj)

  Returns an actual Array() given an Array-like obj such as an HTMLCollection or a NodeList.

  Arguments:

  - obj (object) -- An Array-like object.

  Returns: | Array

  Example:

      > var terms = document.getElementsByClassName(GateOne.prefs.prefix+'terminal');
      > GateOne.Utils.toArray(terms).forEach(function(termObj) {
          GateOne.Terminal.closeTerminal(termObj.id.split('term')[1]);
      });

`GateOne.Utils.``xhrGet`(url[, callback])

  Performs a GET on the given url and if given, calls callback with the responseText as the only argument.

  Arguments:

  - url (string) -- The URL to GET.
  - callback (function) -- A function to call like so: `callback(responseText)`

  Example:

      > var mycallback = function(responseText) { console.log("It worked: " + responseText) };
      > GateOne.Utils.xhrGet('https://demo.example.com/static/about.html', mycallback);
      It worked: <!DOCTYPE html>
      <html>
      <head>
      ...

## GateOne.Net

`GateOne.``Net`

Just about all of Gate One's communications with the server are handled inside this module. It contains all the functions and properties to deal with setting up the WebSocket and issuing/receiving commands over it. The most important facet of `GateOne.Net` is `GateOne.Net.actions` which holds the mapping of what function maps to which command. More info on `GateOne.Net.actions` is below.

### Properties

`GateOne.Net.``actions`

  Type : | Object

This is where all of Gate One's WebSocket protocol actions are assigned to functions. Here's how they are defined by default:

> Action | Function
> --- | ---
> bell | `GateOne.Visual.bellAction()`
> gateone_user | `GateOne.User.storeSession()`
> load_bell | `GateOne.User.loadBell()`
> load_css | `GateOne.Visual.CSSPluginAction()`
> load_style | `GateOne.Utils.loadStyle()`
> load_webworker | `GateOne.Terminal.loadWebWorkerAction()`
> log | `GateOne.Net.log()`
> notice | `GateOne.Visual.serverMessageAction()`
> ping | `GateOne.Net.ping()`
> pong | `GateOne.Net.pong()`
> reauthenticate | `GateOne.Net.reauthenticate()`
> save_file | `GateOne.Utils.saveAsAction()`
> set_mode | `GateOne.Terminal.setModeAction()`
> set_title | `GateOne.Visual.setTitleAction()`
> set_username | `GateOne.User.setUsername()`
> term_ended | `GateOne.Terminal.closeTerminal()`
> term_exists | `GateOne.Terminal.reconnectTerminalAction()`
> terminals | `GateOne.Terminal.reattachTerminalsAction()`
> termupdate | `GateOne.Terminal.updateTerminalAction()`
> timeout | `GateOne.Terminal.timeoutAction()`

Note

Most of the above is added via `addAction()` inside of each respective module's `init()` function.

For example, if we execute `GateOne.Net.ping()`, this will send a message over the WebSocket like so:

    GateOne.ws.send(JSON.stringify({'ping': timestamp}));

The GateOne server will receive this message and respond with a `pong` message that looks like this (Note: Python code below):

    message = {'pong': timestamp} # The very same timestamp we just sent via GateOne.Net.ping()
    self.write_message(json_encode(message))

When GateOne.Net receives a message from the server over the WebSocket it will evaluate the object it receives as `{action: message}` and call the matching action in `GateOne.Net.actions`. In this case, our action "pong" matches `GateOne.Net.actions['pong']` so it will be called like so:

    GateOne.Net.actions['pong'](message);

Plugin authors can add their own arbitrary actions using `GateOne.Net.addAction()`. Here's an example taken from the SSH plugin:

    GateOne.Net.addAction('sshjs_connect', GateOne.SSH.handleConnect);
    GateOne.Net.addAction('sshjs_reconnect', GateOne.SSH.handleReconnect);

If no action can be found for a message it will be passed to `GateOne.Visual.displayMessage()` and displayed to the user like so:

    GateOne.Visual.displayMessage('Message From Server: ' + <message>);

### Functions

- `GateOne.Net.addAction`
- `GateOne.Net.connect`
- `GateOne.Net.connectionError`
- `GateOne.Net.fullRefresh`
- `GateOne.Net.killTerminal`
- `GateOne.Net.log`
- `GateOne.Net.onMessage`
- `GateOne.Net.onOpen`
- `GateOne.Net.ping`

- `GateOne.Net.pong`
- `GateOne.Net.reauthenticate`
- `GateOne.Net.refresh`
- `GateOne.Net.sendChars`
- `GateOne.Net.sendDimensions`
- `GateOne.Net.sendString`
- `GateOne.Net.setTerminal`
- `GateOne.Net.sslError`

`GateOne.Net.``addAction`(name, func)

  Arguments:

  - name (string) -- The name of the action we're going to attach func to.
  - func (function) --

    The function to be called when an action arrives over the WebSocket matching name.

  Adds an action to the `GateOne.Net.actions` object.

  Example:

      GateOne.Net.addAction('sshjs_connect', GateOne.SSH.handleConnect);

`GateOne.Net.``connect`()

  Opens a connection to the WebSocket defined in `GateOne.prefs.url` and stores it as `GateOne.ws`. Once connected `GateOne.initialize()` will be called.

  If an error is encountered while trying to connect to the WebSocket, `connectionError()` will be called to notify the user as such. After five seconds, if a connection has yet to be connected successfully it will be assumed that the user needs to accept the Gate One server's SSL certificate. This will invoke call to `sslError()` which will redirect the user to the `accept_certificate.html` page on the Gate One server. Once that page has loaded successfully (after the user has clicked through the interstitial page) the user will be redirected back to the page they were viewing that contained Gate One.

  Note

  This function gets called by `GateOne.init()` and there's really no reason why it should be called directly by anything else.

`GateOne.Net.``connectionError`()

  Called when there's an error communicating over the WebSocket... Displays a message to the user indicating there's a problem, logs the error (using `logError()`), and sets a five-second timeout to attempt reconnecting.

  This function is attached to the WebSocket's `onclose` event and shouldn't be called directly.

`GateOne.Net.``fullRefresh`()

  Sends a message to the Gate One server asking it to send a full screen refresh (i.e. send us the whole thing as opposed to just the difference from the last screen).

`GateOne.Net.``killTerminal`(term)

  Arguments:

  - term (number) -- The termimal number that should be killed on the server side of things.

  Normally called when the user closes a terminal, it sends a message to the server telling it to end the process associated with term. Normally this function would not be called directly. To close a terminal cleanly, plugins should use `GateOne.Terminal.closeTerminal(term)` (which calls this function).

`GateOne.Net.``log`(msg)

  Arguments:

  - msg (string) -- The message received from the Gate One server.

  This function can be used in debugging `actions`; it logs whatever message is received from the Gate One server: `GateOne.Logging.logInfo(msg)` (which would equate to console.log under most circumstances).

  When developing a new action, you can test out or debug your server-side messages by attaching the respective action to `GateOne.Net.log()` like so:

      GateOne.Net.addAction('my_action', GateOne.Net.log);

  Then you can view the exact messages received by the client in the JavaScript console in your browser.

  Tip

  Setting `GateOne.Logging.level = 'DEBUG'` in your JS console will also log all incoming messages from the server (though it can be a bit noisy).

`GateOne.Net.``onMessage`(event)

  Arguments:

  - event (event) --

    A WebSocket event object as passed by the 'message' event.

  This gets attached to `GateOne.ws.onmessage` inside of `connect()`. It takes care of decoding (JSON) messages sent from the server and calling any matching `actions`. If no matching action can be found inside `event.data` it will fall back to passing the message directly to `GateOne.Visual.displayMessage()`.

`GateOne.Net.``onOpen`()

  This gets attached to `GateOne.ws.onopen` inside of `connect()`. It clears any error message that might be displayed to the user and asks the server to send us the (currently-selected) theme CSS, all plugin CSS, the bell sound (if not already stored in `GateOne.prefs.bellSound`), and the go_process.js Web Worker (`go.ws.send(JSON.stringify({'get_webworker': null}));`). Lastly, it sends an authentication message and calls `ping()` after a short timeout (to let things settle down lest they interfere with the ping time calculation).

`GateOne.Net.``ping`()

  Sends a ping to the server with a client-generated timestamp attached. The expectation is that the server will return a 'pong' respose with the timestamp as-is so we can measure the round-trip time.

      > GateOne.Net.ping();
      2011-10-09 21:13:08 INFO PONG: Gate One server round-trip latency: 2ms

  Note

  That response was actually logged by `pong()` below.

`GateOne.Net.``pong`(timestamp)

  Arguments:

  - timestamp (string) -- Expected to be the output of `new Date().toISOString()` (as generated by `ping()`).

  Simply logs timestamp using `GateOne.Logging.logInfo()` and includes a measurement of the round-trip time in milliseconds.

`GateOne.Net.``reauthenticate`()

  Called when the Gate One server wants us to re-authenticate our session (e.g. our cookie expired). Deletes the 'gateone_user' cookie and reloads the current page with the following code:

      GateOne.Utils.deleteCookie('gateone_user', '/', '');
      window.location.reload();

  This will force the client to re-authenticate with the Gate One server.

  Note

  This function will likely change in the future as a reload shoud not be necessary to force a re-auth.

`GateOne.Net.``refresh`()

  Sends a message to the Gate One server telling it to perform a screen refresh with just the difference from the last refresh.

`GateOne.Net.``sendChars`()

  Sends the current character queue to the Gate One server and empties it out. Typically it would be used like this:

      GateOne.Input.queue("echo 'This text will be sent to the server'\n");
      GateOne.Net.sendChars(); // Send it off and empty the queue

`GateOne.Net.``sendDimensions`([term])

  Arguments:

  - term (number) -- Not currently used but in the future this will allow setting the dimensions of individual terminals.

  Sends the current dimensions of term to the Gate One server. Typically used when the user resizes their browser window.

      GateOne.Net.sendDimensions();

`GateOne.Net.``sendString`(chars[, term])

  Arguments:

  - chars (string) -- The characters to be sent to the terminal.
  - term (number) -- Optional - The terminal to send the characters to.

  Sends chars to term. If term is omitted the currently-selected terminal will be used.

      GateOne.Input.sendString("echo 'This text will be sent to terminal 1'\n", 1);

`GateOne.Net.``setTerminal`(term)

  Arguments:

  - term (number) -- The terminal we wish to become active.

  Tells the Gate One server which is our active terminal and sets `localStorage['selectedTerminal'] = *term*`.

      GateOne.Net.setTerminal(1);

`GateOne.Net.``sslError`(callback)

  Called when we fail to connect due to an SSL error (user must accept the SSL certificate). It opens a dialog where the user can accept the Gate One server's SSL certificate (via an iframe).

  Arguments:

  - callback (function) -- Will be called after the user clicks "OK" to the dialog.

## GateOne.Input

`GateOne.``Input`

This module handles mouse and keyboard input for Gate One. It consists of a few tables of information that tell Gate One how to act upon a given keystroke as well as functions that make working with keyboard and mouse events a bit easier.

### Properties

Note

Properties that have to do with temporary, internal states (e.g. `GateOne.Input.metaHeld`) were purposefully left out of this documentation since there's really no reason to ever reference them.

`GateOne.Input.``charBuffer`

  This is an Array that temporarily stores characters before sending them to the Gate One server. The `charBuffer` gets sent to the server and emptied when `GateOne.Net.sendChars()` is called.

  Typically, characters wind up in the buffer by way of `GateOne.Input.queue()`.

`GateOne.Input.``keyTable`

  This is an object that houses all of Gate One's special key mappings. Here's an example from the default keyTable:

      'KEY_2': {'default': "2", 'shift': "@", 'ctrl': String.fromCharCode(0)}

  This entry tells Gate One how to respond when the '2' key is pressed; by default, when the shift key is held, or when the Ctrl key is held. If no entry existed for the '2' key, Gate One would simply use the standard keyboard defaults (for the key itself and when shift is held).

  Note

  This property is used by both `GateOne.Input.emulateKey()` and `GateOne.Input.emulateKeyCombo()`.

  Warning

  Entries in `GateOne.Input.shortcuts` will supersede anything in `GateOne.Input.keyTable`. So if you use `GateOne.Input.registerShortcut()` to bind the '2' key to some JavaScript action, that action will need to ALSO send the proper character or the user will wind up dazed and confused as to why their '2' key doesn't work.

`GateOne.Input.``shortcuts`

  Keyboard shortcuts that get added using `GateOne.Input.registerShortcut()` are stored here like so:

      > GateOne.Input.shortcuts;
      {'KEY_N': [
          {
              'modifiers': {'ctrl': true, 'alt': true, 'meta': false, 'shift': false},
              'action': 'GateOne.Terminal.newTerminal()'
          }
      ]}

  Note

  A single key can have multiple entries depending on which modifier is held.

### Functions

- `GateOne.Input.bufferEscSeq`
- `GateOne.Input.capture`
- `GateOne.Input.disableCapture`
- `GateOne.Input.emulateKey`
- `GateOne.Input.emulateKeyCombo`
- `GateOne.Input.emulateKeyFallback`
- `GateOne.Input.key`

- `GateOne.Input.modifiers`
- `GateOne.Input.mouse`
- `GateOne.Input.onKeyDown`
- `GateOne.Input.onKeyUp`
- `GateOne.Input.queue`
- `GateOne.Input.registerShortcut`

`GateOne.Input.``bufferEscSeq`(chars)

  Arguments:

  - chars (string) -- A string that will have the ESC character prepended to it.

  Prepends an ESC character to chars and adds it to the `charBuffer`

      // This would send the same as the up arrow key:
      GateOne.Input.bufferEscSeq("[A") // Would end up as ^[[A

`GateOne.Input.``capture`()

  Sets the browser's focus to `GateOne.prefs.goDiv` and enables the capture of keyboard and mouse events. It also a very important part of Gate One's ability to support copy & paste without requiring the use of browser plugins.

`GateOne.Input.``disableCapture`()

  Disables the capture of keyboard and mouse events by setting all of the relevant events tied to `GateOne.prefs.goDiv` to null like so:

      GateOne.prefs.goDiv.onpaste = null;
      GateOne.prefs.goDiv.tabIndex = null;
      GateOne.prefs.goDiv.onkeydown = null;
      GateOne.prefs.goDiv.onkeyup = null;
      GateOne.prefs.goDiv.onmousedown = null;
      GateOne.prefs.goDiv.onmouseup = null;

  Typically you would call this function if a user needed to fill out a form or use a non-terminal portion of the web page. `GateOne.prefs.capture()` can be called to turn it all back on.

`GateOne.Input.``emulateKey`(e, skipF11check)

  Typically called by `GateOne.Input.onKeyDown()`, converts a keyboard event (e) into a string (using `GateOne.Input.keyTable`) and appends it to the `charBuffer` using `GateOne.Input.queue()`. This function also has logic that allows the user to double-tap the F11 key to send the browser's native keystroke (enable/disable fullscreen). This is to prevent the user from getting stuck in fullscreen mode (since we call `e.preventDefault()` for nearly all events).

  Arguments:

  - e (event) -- The JavaScript event that the function is handling (coming from `GateOne.prefs.goDiv.onkeydown`).
  - skipF11check (boolean) -- Used internally by the function as part of the logic surrounding the F11 (fullscreen) key.

`GateOne.Input.``emulateKeyCombo`(e)

  Arguments:

  - e (event) -- The JavaScript event that the function is handling (coming from `GateOne.prefs.goDiv.onkeydown`).

  Typically called by `GateOne.prefs.onKeyDown()`, converts a keyboard event (e) into a string. The difference between this function and `emulateKey()` is that this funcion handles key combinations that include non-shift modifiers (Ctrl, Alt, and Meta).

`GateOne.Input.``emulateKeyFallback`(e)

  Arguments:

  - e (event) -- The JavaScript event that the function is handling (coming from `GateOne.prefs.goDiv.onkeypress`).

  This gets attached to the goDiv.onkeypress event... It Queues the (character) result of a keypress event if an unknown modifier key is held. Without this, 3rd and 5th level keystroke events (i.e. the stuff you get when you hold down various combinations of AltGr+<key>) would not work.

`GateOne.Input.``key`(e)

  Arguments:

  - e (event) -- A JavaScript key event.

  Given an event (e), returns a very straightforward (e.g. easy to read/understand) object representing any keystrokes contained within it. The object will look like this:

      {
          type: <event type>, // Just preserves it.
          code: <the key code>, // e.g. 27
          string: 'KEY_<key string>' // e.g. KEY_N or KEY_F11
      }

  This makes keystroke-handling code a lot easier to read and more consistent across browsers and platforms. For example, here's a hypothetical function that gets passed a keystroke event:

      var keystrokeHandler(e) {
          var key = GateOne.Input.key(e);
          console.log('key.code: ' + key.code + ', key.string: ' + key.string);
      }

  The key.string comes from `GateOne.Input.specialKeys`, `GateOne.Input.specialMacKeys`, and the key event itself (onkeydown events provide an upper-case string for most keys).

`GateOne.Input.``modifiers`(e)

  Arguments:

  - e (event) -- A JavaScript key event.

  Like `GateOne.Input.key()`, this function returns a well-formed object for a fairly standard JavaScript event. This object looks like so:

      {
          shift: false,
          alt: false,
          ctrl: false,
          meta: false
      }

  Since some browsers (i.e. Chrome) don't register the 'meta' key (aka "the Windows key") as a proper modifier, `modifiers()` will emulate it by examining the `GateOne.Input.metaHeld` property. The state of the meta key is tracked via `GateOne.Input.metaHeld` by way of the `GateOne.Input.onKeyDown()` and `GateOne.Input.onKeyUp()` functions.

`GateOne.Input.``mouse`(e)

  Arguments:

  - e (event) -- A JavaScript mouse event.

  Just like `GateOne.Input.key()` and `GateOne.Input.modifiers()`, this function returns a well-formed object for a fairly standard JavaScript event:

      {
          type:   <event type>, // Just preserves it
          left:   <true/false>,
          right:  <true/false>,
          middle: <true/false>,
      }

  Very convient for figuring out which mouse button was pressed on any given mouse event.

`GateOne.Input.``onKeyDown`(e)

  Arguments:

  - e (event) -- A JavaScript key event.

  This function gets attached to `GateOne.prefs.goDiv.onkeydown` by way of `GateOne.Input.capture()`. It keeps track of the state of the meta key (see `modifiers()` above), executes any matching keyboard shortcuts defined in `GateOne.Input.shortcuts`, and calls `GateOne.Input.emulateKey()` or `GateOne.Input.emulateKeyCombo()` depending on which (if any) modifiers were held during the keystroke event.

`GateOne.Input.``onKeyUp`(e)

  Arguments:

  - e (event) -- A JavaScript key event.

  This function gets attached to `GateOne.prefs.goDiv.onkeyup` by way of `GateOne.Input.capture()`. It is used in conjunction with `GateOne.Input.modifiers()` and `GateOne.Input.onKeyDown()` to emulate the meta key modifier using KEY_WINDOWS_LEFT and KEY_WINDOWS_RIGHT since "meta" doesn't work as an actual modifier on some browsers/platforms.

`GateOne.Input.``queue`(text)

  Arguments:

  - text (string) -- The text to be added to the `charBuffer`.

  Adds text to `GateOne.Input.charBuffer`.

`GateOne.Input.``registerShortcut`(keyString, shortcutObj, action)

  Arguments:

  - keyString (string) -- The KEY_<key> that will invoke this shortcut.
  - shortcutObj (object) -- A JavaScript object containing two properties: 'modifiers' and 'action'. See above for their format.
  - action -- A string to be eval()'d or a function to be executed when the provided key combination is pressed.

  Registers the given shortcutObj for the given keyString by adding a new object to `GateOne.Input.shortcuts`. Here's an example:

      GateOne.Input.registerShortcut('KEY_ARROW_LEFT', {
          'modifiers': {
              'ctrl': false,
              'alt': false,
              'meta': false,
              'shift': true
          },
          'action': 'GateOne.Visual.slideLeft()'
      });

  Note

  The 'action' may be a string that gets invoked via eval(). This allows plugin authors to register shortcuts that call objects and functions that may not have been available at the time they were registered.

## GateOne.Visual

`GateOne.``Visual`

This module contains all of Gate One's visual effect functions. It is just like `GateOne.Utils` but specific to visual effects and DOM manipulations.

### Properties

`GateOne.Visual.``goDimensions`

  Stores the dimensions of the `GateOne.prefs.goDiv` element in the form of `{w: '800', h: '600'}` where 'w' and 'h' represent the width and height in pixels. It is used by several functions in order to calculate how far to slide terminals, how many rows and columns will fit, etc.

### Functions

- `GateOne.Visual.addSquare`
- `GateOne.Visual.alert`
- `GateOne.Visual.applyStyle`
- `GateOne.Visual.applyTransform`
- `GateOne.Visual.bellAction`
- `GateOne.Visual.createGrid`
- `GateOne.Visual.CSSPluginAction`
- `GateOne.Visual.dialog`
- `GateOne.Visual.disableScrollback`
- `GateOne.Visual.displayMessage`
- `GateOne.Visual.displayTermInfo`
- `GateOne.Visual.enableScrollback`
- `GateOne.Visual.getTransform`
- `GateOne.Visual.init`

- `GateOne.Visual.playBell`
- `GateOne.Visual.serverMessageAction`
- `GateOne.Visual.setTitleAction`
- `GateOne.Visual.slideDown`
- `GateOne.Visual.slideLeft`
- `GateOne.Visual.slideRight`
- `GateOne.Visual.slideToTerm`
- `GateOne.Visual.slideUp`
- `GateOne.Visual.toggleGridView`
- `GateOne.Visual.toggleOverlay`
- `GateOne.Visual.togglePanel`
- `GateOne.Visual.toggleScrollback`
- `GateOne.Visual.updateDimensions`
- `GateOne.Visual.widget`

Tip

In most of Gate One's JavaScript, term refers to the terminal number (e.g. 1).

`GateOne.Visual.``addSquare`(squareName)

  Arguments:

  - squareName (string) -- The name of the "square" to be added to the grid.

  Called by `createGrid()`; creates a terminal div and appends it to `GateOne.Visual.squares` (which is just a temporary holding space). Probably not useful for anything else.

  Note

  In fact, this function would only ever get called if you were debugging the grid... You'd call `createGrid()` with, say, an Array containing a dozen pre-determined terminal names as the second argument. This would save you the trouble of opening a dozen terminals by hand.

`GateOne.Visual.``alert`(title, message, callback)

  Arguments:

  - title (string) -- Title of the dialog that will be displayed.
  - message (string) -- Main content of the alert dialog.
  - callback (string) -- A function that will be called after the user clicks "OK".

  Displays a dialog using the given title containing the given message along with an OK button. When the OK button is clicked, callback will be called.

      GateOne.Visual.alert('Test Alert', 'This is an alert box.');

  Note

  This function is meant to be a less-intrusive form of JavaScript's alert().

`GateOne.Visual.``applyStyle`(elem, style)

  Arguments:

  - elem --

    A querySelector string like `#some_element_id` or a DOM node.

  - style -- A JavaScript object holding the style that will be applied to elem.

  A convenience function that allows us to apply multiple style changes in one go. For example:

      GateOne.Visual.applyStyle('#somediv', {'opacity': 0.5, 'color': 'black'});

`GateOne.Visual.``applyTransform`(obj, transform)

  Arguments:

  - obj --

    A querySelector string like `#some_element_id`, a DOM node, an Array of DOM nodes, an HTMLCollection, or a NodeList.

  - transform -- A CSS3 transform function such as `scale()` or `translate()`.

  This function is Gate One's bread and butter: It applies the given CSS3 transform to obj. obj can be one of the following:

  > - A querySelector-like string (e.g. "#some_element_id").
  > - A DOM node.
  > - An Array or an Array-like object containing DOM nodes such as HTMLCollection or NodeList (it will apply the transform to all of them).

  The transform should be just the actual transform function (e.g. `scale(0.5)`). `applyTransform()` will take care of applying the transform according to how each browser implements it. For example:

      GateOne.Visual.applyTransform('#somediv', 'translateX(500%)');

  ...would result in `#somediv` getting styles applied to it like this:

      #somediv {
          -webkit-transform: translateX(500%); /* Chrome/Safari/Webkit-based stuff */
          -moz-transform: translateX(500%);    /* Mozilla/Firefox/Gecko-based stuff */
          -o-transform: translateX(500%);      /* Opera */
          -ms-transform: translateX(500%);     /* IE9+ */
          -khtml-transform: translateX(500%);  /* Konqueror */
          transform: translateX(500%);         /* Some day this will be all that is necessary */
      }

`GateOne.Visual.``bellAction`(bellObj)

  Arguments:

  - bellObj (object) -- A JavaScript object containing one attribute: {'term': <num>}.

  Plays a bell sound and pops up a message indiciating which terminal the bell came from (visual bell is always enabled). If `GateOne.prefs.bellSound == false` only thwe visual indicator will be displayed.

  Note

  This takes a JavaScript object (bellObj) as an argument because it is meant to be registered as an action in `GateOne.Net.actions` as it is the Gate One server that tells us when a bell has been encountered.

  The format of bellObj is as simple as can be: `{'term': 1}`. The bell sound will be whatever `<source>` is attached to an `<audio>` tag with ID `#bell`. By default, Gate One's index.html template includes a such an `<audio>` tag with a data:URI as the `<source>` that gets created from '<gateone dir>/static/bell.ogg'.

      GateOne.Visual.bellAction({'term': 1}); // This is how it is called

  Note

  Why is the visual bell always enabled? Without a visual indicator, if you had more than one terminal open it would be impossible to tell which terminal the bell came from.

`GateOne.Visual.``createGrid`(id[, terminalNames])

  Arguments:

  - id -- The name that will be given to the resulting grid. e.g. <div id="id"></div>
  - style -- An array of DOM IDs (e.g. ["term1", "term2"]).

  Creates a container for housing terminals and optionally, pre-creates them using terminalNames (useful in debugging). The container will be laid out in a 2x2 grid.

      GateOne.Visual.createGrid("#"+GateOne.prefs.prefix+"termwrapper");

  Note

  Work is being done to replace the usage of the grid with more abiguous functions in order to make it possible for plugins to override the default behavior to, say, have a 4x4 grid. Or use some other terminal-switching mechanism/layout altogether (cube, anyone? =). Will probably be available in Gate One v1.5 since it is merely time consuming to replace a zillion function calls with a wrapper.

`GateOne.Visual.``CSSPluginAction`(message)

  Arguments:

  - message (object) -- The name that will be given to the resulting grid. e.g. <div id="id"></div>

  Note

  This function gets attached to the 'load_css' action in `GateOne.Net.actions`.

  Loads the CSS for a given plugin by adding a <link> tag to the <head>.

`GateOne.Visual.``dialog`(title, content[, options])

  Arguments:

  - title (string) -- The title of the dialog.
  - content (string) -- The content of the dialog.
  - options (object) -- Doesn't do anything yet.

  Returns: | A function that will close the dialog.

  Creates a dialog with the given title and content. Returns a function that will close the dialog when called. Example:

      var closeDialog = GateOne.Visual.dialog("Test Dialog", "Dialog content goes here.");

`GateOne.Visual.``disableScrollback`([term])

  Arguments:

  - term (number) -- The terminal number to disable scrollback.

  Replaces the contents of term with just the visible screen (i.e. no scrollback buffer). This makes terminal manipulations considerably faster since the browser doesn't have to reflow as much text. If no term is given, replace the contents of all terminals with just their visible screens.

  While this function itself causes a reflow, it is still a good idea to call it just before performing a manipulation of the DOM since the presence of scrollbars really slows down certain CSS3 transformations. Just don't forget to cancel `GateOne.terminals[term]['scrollbackTimer']` or any effects underway might get very choppy right in the middle of execution.

      GateOne.Visual.disableScrollback(1);

  Note

  A convenience function for enabling/disabling the scrollback buffer is available: `GateOne.Visual.toggleScrollback()` (detailed below).

`GateOne.Visual.``displayMessage`(message[, timeout[, removeTimeout[, id]]])

  Arguments:

  - message (string) -- The message to display.
  - timeout (integer) -- Milliseconds; How long to display the message before starting the removeTimeout timer. Default: 1000.
  - removeTimeout (integer) -- Milliseconds; How long to delay before calling `GateOne.Utils.removeElement()` on the message DIV. Default: 5000.
  - id (string) -- The ID to assign the message DIV. Default: "notice".

  Displays message to the user via a transient pop-up DIV that will appear inside `GateOne.prefs.goDiv`. How long the message lasts can be controlled via timeout and removeTimeout (which default to 1000 and 5000, respectively).

  If id is given, it will be prefixed with `GateOne.prefs.prefix` and used as the DIV ID for the pop-up. i.e. `GateOne.prefs.prefix+id`. The default is `GateOne.prefs.prefix+"notice"`.

      GateOne.Visual.displayMessage('This is a test.');

  Note

  The default is to display the message in the lower-right corner of `GateOne.prefs.goDiv` but this can be controlled via CSS.

`GateOne.Visual.``displayTermInfo`(term)

  Arguments:

  - term (number) -- The terminal number to display info for.

  Displays the terminal number and terminal title of the given term via a transient pop-up DIV that starts fading away after one second.

      GateOne.Visual.displayTermInfo(1);

  Note

  Like `displayMessage()`, the location and effect of the pop-up can be controlled via CSS. The DIV ID will be `GateOne.prefs.prefix+'infocontainer'`.

`GateOne.Visual.``enableScrollback`([term])

  Arguments:

  - term (number) -- The terminal number to enable scrollback.

  Replaces the contents of term with the visible scren + scrollback buffer. Use this to restore scrollback after calling `disableScrollback()`. If no term is given, re-enable the scrollback buffer in all terminals.

      GateOne.Visual.enableScrollback(1);

  Note

  A convenience function for enabling/disabling the scrollback buffer is available: `GateOne.Visual.toggleScrollback()` (detailed below).

`GateOne.Visual.``getTransform`(elem)

  Arguments:

  - elem (number) --

    A querySelector string ID or a DOM node.

  Returns the transform string applied to the style of the given elem

      > GateOne.Visual.getTransform('#go_term1_pre');
      "translateY(-3px)"

`GateOne.Visual.``init`()

  Called by `GateOne.init()`, performs the following:

  > - Adds an icon to the panel for toggling the grid.

  > - Adds `GateOne.Visual.bellAction()` as the 'bell' action in `GateOne.Net.actions`.

  > - Adds `GateOne.Visual.setTitleAction()` as the 'set_title' action in `GateOne.Net.actions`.

  > - Registers the following keyboard shortcuts:

  >   > Function | Shortcut
  >   > --- | ---
  >   > GateOne.Visual.toggleGridView() | `Control-Alt-G`
  >   > GateOne.Visual.slideLeft() | `Shift-LeftArrow`
  >   > GateOne.Visual.slideRight() | `Shift-RightArrow`
  >   > GateOne.Visual.slideUp() | `Shift-UpArrow`
  >   > GateOne.Visual.slideDown() | `Shift-DownArrow`

`GateOne.Visual.``playBell`()

  Plays the bell sound attached to the `<audio>` tag with ID `#bell` without any visual notification.

      GateOne.Visual.playBell();

`GateOne.Visual.``serverMessageAction`(message)

  Arguments:

  - message (string) -- A message from the Gate One server.

  Note

  This function gets attached to the 'notice' action in `GateOne.Net.actions`.

  Displays an incoming message from the Gate One server. As simple as can be. This is the entire function:

      serverMessageAction: function(message) {
          // Displays a *message* sent from the server
          GateOne.Visual.displayMessage(message);
      },

  Why not just attach `displayMessage()` to the 'notice' action? Two reasons:

  > 1. So plugins can override this method.
  > 2. We might want to apply extra formatting or perform additional functions in the future.

`GateOne.Visual.``setTitleAction`(titleObj)

  Arguments:

  - titleObj (object) -- A JavaScript object as decoded from the message from the server.

  Note

  This function gets attached to the 'set_title' action in `GateOne.Net.actions`.

  Given that titleObj is a JavaScript object such as, `{'term': 1, 'title': "user@host:~"}`, sets the title of the terminal provided by titleObj['term'] to titleObj['title'].

      GateOne.Visual.setTitleAction({'term': 1, 'title': "user@host:~"});

`GateOne.Visual.``slideDown`()

  Grid specific: Slides the view downward one terminal by pushing all the others up.

      GateOne.Visual.slideDown();

`GateOne.Visual.``slideLeft`()

  Grid specific: Slides the view left one terminal by pushing all the others to the right.

      GateOne.Visual.slideLeft();

`GateOne.Visual.``slideRight`()

  Grid specific: Slides the view right one terminal by pushing all the others to the left.

      GateOne.Visual.slideRight();

`GateOne.Visual.``slideToTerm`(term, changeSelected)

  Arguments:

  - term (number) -- The terminal number to slide to.
  - changeSelected (boolean) -- If true, set the current terminal to term.

  Grid specific: Slides the view to term. If changeSelected is true, this will also set the current terminal to the one we're sliding to.

      GateOne.Visual.slideToTerm(1, true);

  Note

  Generally speaking, you'll want changeSelected to always be true.

`GateOne.Visual.``slideUp`()

  Grid specific: Slides the view upward one terminal by pushing all the others down.

      GateOne.Visual.slideUp();

`GateOne.Visual.``toggleGridView`([goBack])

  Arguments:

  - goBack (boolean) -- If false, will not switch to the previously-selected terminal when un-toggling the grid view (i.e. sliding to a specific terminal will be taken care of via other means).

  Brings up the terminal grid view (by scaling all the terminals to 50%) or returns to a single, full-size terminal. If goBack is true (the default), go back to the previously-selected terminal when un-toggling the grid view. This argument is primarily meant for use internally within the function when assigning onclick events to each downsized terminal.

      GateOne.Visual.toggleGridView();

`GateOne.Visual.``toggleOverlay`()

  Toggles the overlay that visually indicates whether or not Gate One is ready for input. Normally this function gets called automatically by `GateOne.Input.capture()` and `GateOne.Input.disableCapture()` which are attached to `mousedown` and `blur` events, respectively.

`GateOne.Visual.``togglePanel`([panel])

  Arguments:

  - panel (string) --

    A querySelector string ID or the DOM node of the panel we're toggling.

  Toggles the given panel in or out of view. panel is expected to be the ID of an element with the `GateOne.prefs.prefix+"panel"` class. If panel is null or false, all open panels will be toggled out of view.

      GateOne.Visual.togglePanel('#'+GateOne.prefs.prefix+'panel_bookmarks');

`GateOne.Visual.``toggleScrollback`()

  Toggles the scrollback buffer for all terminals by calling `GateOne.Visual.disableScrollback()` or `GateOne.Visual.enableScrollback()` depending on the state of the toggle.

      GateOne.Visual.toggleScrollback();

`GateOne.Visual.``updateDimensions`()

  Sets `GateOne.Visual.goDimensions` to the current width/height of `GateOne.prefs.goDiv`. Typically called when the browser window is resized.

      GateOne.Visual.updateDimensions();

`GateOne.Visual.``widget`(title, content[, options])

  Arguments:

  - title (string) -- A title that will appear above the widget when the mouse hovers over it for longer than a second.
  - content -- An HTML string or DOM node that will be the content of the widget.
  - options (object) -- A JavaScript object containing a number of optional parameters.

  Creates an on-screen widget with the given title and content that hovers above Gate One's terminals or a specific terminal (depending on options). Returns a function that will remove the widget when called. Options:

  `options.``onopen`

    A function that will be called with the parent widget node as an argument when the widget is opened.

  `options.``onclose`

    A function that will be called with the parent widget node as an argument when the widget is closed.

  `options.``onconfig`

    If a function is assigned to this parameter a gear icon will be visible in the title bar of the widget that when clicked will call this function.

  `options.``term`

    If provided the widget will be attached to this specific terminal (as opposed to floating above all terminals).

  By default widgets are transparent and have no border:

      GateOne.Visual.widget("Example Widget", "This is the content of the widget.");

  However, if the user holds their mouse over the widget a title will be drawn and they will be able to move it around:

  When an `onconfig` function is set a configuration icon (gear) will appear to the left of the widget title that when clicked calls that function:

      GateOne.Visual.widget("Configurable Widget", "This widget can be configured.", {'onconfig': configFunc});

## GateOne.Terminal

`GateOne.``Terminal`

GateOne.Terminal contains terminal-specific properties and functions. Really, there's not much more to it than that :)

### Properties

`GateOne.Terminal.``closeTermCallbacks`

  Type : | Array

  If a plugin wants to perform an action whenever a terminal is closed it can register a callback here like so:

      GateOne.Terminal.closeTermCallbacks.push(GateOne.MyPlugin.termClosed);

  All callbacks in `closeTermCallbacks` will be called whenever a terminal is closed with the terminal number as the only argument.

`GateOne.Terminal.``modes`

  Type : | Object

  An object containing a collection of functions that will be called whenever a matching terminal (expanded) mode is encountered. For example, terminal mode '1' (which maps to escape sequences '[?1h' and '[?1l') controls "application cursor keys" mode. In this mode, the cursor keys are meant to send different escape sequences than they normally do.

  Functions inside `GateOne.Terminal.modes` are called with a boolean as their only argument; `true` meaning 'set this mode' and `false` meaning 'reset this mode'. These translate back to `terminal.Terminal` which calls whatever is assigned to `Terminal.callbacks[CALLBACK_MODE]` with the mode number and a boolean as the only two arguments.

  `Terminal.callbacks[CALLBACK_MODE]` is assigned inside of gateone.py to `TerminalWebSocket.mode_handler` which sends a message to the Gate One client containing a JSON-encoded object like so:

      {'set_mode': {
          'mode': setting, # Would be '1' for application cursor keys mode
          'boolean': True, # Set this mode
          'term': term     # On this terminal
      }}

  This maps directly to the 'set_mode' action in `GateOne.Net.actions` which calls `GateOne.Terminal.modes`.

`GateOne.Terminal.``newTermCallbacks`

  Type : | Array

  If a plugin wants to perform an action whenever a terminal is opened it can register a callback here like so:

      GateOne.Terminal.newTermCallbacks.push(GateOne.MyPlugin.termOpened);

  All callbacks in `newTermCallbacks` will be called whenever a new terminal is opened with the terminal number as the only argument.

`GateOne.Terminal.``scrollbackWidth`

  Type : | Integer

  The first time `GateOne.Terminal.termUpdateFromWorker()` is executed it calculates the width of the scrollbar inside of the terminal it is updating (in order to make sure the toolbar doesn't overlap). The result of this calculation is stored in this attribute.

`GateOne.Terminal.``termUpdatesWorker`

  Type : | Web Worker

  This is a Web Worker (go_process.js) that is used by `GateOne.Terminal.updateTerminalAction()` to process the text received from the Gate One server. This allows things like linkifying text to take place asynchronously so it doesn't lock or slow down your browser while the CPU does its work.

`GateOne.Terminal.``updateTermCallbacks`

  Type : | Arrray

  If a plugin wants to perform an action whenever a terminal screen is updated it can register a callback here like so:

      GateOne.Terminal.updateTermCallbacks.push(GateOne.MyPlugin.termUpdated);

  All callbacks in `updateTermCallbacks` will be called whenever a new terminal is opened with the terminal number as the only argument.

### Functions

- `GateOne.Terminal.applyScreen`
- `GateOne.Terminal.closeTerminal`
- `GateOne.Terminal.init`
- `GateOne.Terminal.loadWebWorkerAction`
- `GateOne.Terminal.newTerminal`
- `GateOne.Terminal.notifyActivity`
- `GateOne.Terminal.notifyInactivity`
- `GateOne.Terminal.paste`
- `GateOne.Terminal.reattachTerminalsAction`

- `GateOne.Terminal.reconnectTerminalAction`
- `GateOne.Terminal.registerTextTransform`
- `GateOne.Terminal.resetTerminalAction`
- `GateOne.Terminal.setModeAction`
- `GateOne.Terminal.switchTerminal`
- `GateOne.Terminal.termUpdateFromWorker`
- `GateOne.Terminal.timeoutAction`
- `GateOne.Terminal.updateTerminalAction`
- `GateOne.Terminal.writeScrollback`

`GateOne.Terminal.``applyScreen`(screen[, term])

  Arguments:

  - screen (array) -- An array of HTML-formatted strings representing the lines of a terminal screen.
  - term (number) -- The terminal that have the screen applied.

  Uses screen (an array of HTML-formatted lines) to update term. If term is not provided, the currently-selected terminal will be updated.

      // Pretend screenArray is an array of lines we want to place in terminal 1:
      GateOne.Terminal.applyScreen(screenArray, 1);

`GateOne.Terminal.``closeTerminal`(term)

  Arguments:

  - term (number) -- The terminal that will be closed.

  Closes the given term and tells the Gate One server to end the process associated with it.

      GateOne.Terminal.closeTerm(2);

`GateOne.Terminal.``init`()

  Creates the terminal information panel, initializes the terminal updates Web Worker (which is contained in go_process.js), and registers the following keyboard shortcuts and WebSocket actions:

  Keyboard Shortcuts

  Function | Shortcut | Enabled in Embedded Mode?
  --- | --- | ---
  GateOne.Terminal.newTerminal() | `Control-Alt-N` | No
  GateOne.Terminal.closeTerminal(localStorage["selectedTerminal"]) | `Control-Alt-W` | No
  GateOne.Terminal.paste() | `Shift-INS` | Yes

  WebSocket Actions

  Action | Function
  --- | ---
  load_webworker | `GateOne.Terminal.loadWebWorkerAction()`
  set_mode | `GateOne.Terminal.setModeAction()`
  term_ended | `GateOne.Terminal.closeTerminal()`
  terminals | `GateOne.Terminal.reattachTerminalsAction()`
  termupdate | `GateOne.Terminal.updateTerminalAction()`
  term_exists | `GateOne.Terminal.reconnectTerminalAction()`
  timeout | `GateOne.Terminal.timeoutAction()`

`GateOne.Terminal.``loadWebWorkerAction`(source)

  Arguments:

  - source (string) --

    The source code of the Web Worker (go_process.js).

  This function gets attached to the 'load_webworker' action in `GateOne.Net.actions` and gets called by the server in response to a 'get_webworker' request. The 'get_webworker' request is sent by `GateOne.Net.onOpen()` after the WebSocket is opened. It loads our Web Worker (go_process.js) given it's source.

  Note

  This is a clever way to work around the origin limiations of Web Workers. Something that is necessary when Gate One is embedded into another application and being served up from a completely different domain.

`GateOne.Terminal.``newTerminal`([term][, type][, where])

  Arguments:

  - term (number) -- Optional: When the new terminal is created, it will be assigned this number.
  - type (number) -- Optional: Not currently used. In the future it will be used to tell the server which kind of terminal to create.
  - where (number) --

    Optional: A querySelector string like `#some_element_id` or a DOM node where the new terminal will be created.

  Creates a new terminal and gets it updating itself by way of the Gate One server. Also, if `GateOne.prefs.autoConnectURL` is set `GateOne.Net.onOpen()` will send that value to the server 500ms after the terminal is opened.

  If where is provided the new terminal elements will be placed inside that container... Which doesn't have to be inside `GateOne.prefs.goDiv` but it's a good idea since that will ensure everything lines up and has the correct formatting.

      GateOne.Terminal.newTerminal();

`GateOne.Terminal.``notifyActivity`(term)

  Arguments:

  - term (number) -- The terminal that activity was detected in.

  Notifies the user when there's activity in term by displaying a message and playing the bell.

      GateOne.Terminal.notifyActivity(1);

  Note

  You wouldn't normally call this function directly. It is meant to be called from `GateOne.Terminal.updateTerminal()` when the right conditions are met.

`GateOne.Terminal.``notifyInactivity`(term)

  Arguments:

  - term (number) -- The terminal that inactivity was detected in.

  Notifies the user when the inactivity timeout in term has been reached by displaying a message and playing the bell.

      GateOne.Terminal.notifyInactivity(1);

  Note

  You wouldn't normally call this function directly. It is meant to be called from `GateOne.Terminal.updateTerminal()` when the right conditions are met.

`GateOne.Terminal.``paste`(e)

  Arguments:

  - e (event) -- A JavaScript event as received from a 'paste' event or the shift-INS keyboard shortcut.

  This gets attached to Shift-Insert (KEY_INSERT) as a shortcut and the 'paste' event attached to `GateOne.prefs.goDiv` in order to support pasting text into a terminal via those mechanisms. It shifts focus to the pastearea just before the actual paste event takes place in order for the input to be captured. Also, if the browser allows it will perform a `commandExec('paste')` into the pastearea as part of the process (with logic to prevent double pastes).

`GateOne.Terminal.``reattachTerminalsAction`(terminals)

  Arguments:

  - terminals (array) -- An Array of terminal numbers we're reattaching.

  This function gets attached to the 'terminals' action in `GateOne.Net.actions` and gets called after we authenticate with the Gate One server (the server is what tells us to call this function). The terminals argument is expected to be an Array of terminal numbers that are currently running on the Gate One server.

  If no terminals currently exist (we received an empty Array), `GateOne.Terminal.newTerminal()` will be called to create a new one (if embedded mode is not enabled).

`GateOne.Terminal.``reconnectTerminalAction`(term)

  Arguments:

  - term (number) -- The terminal number that already exists on the server.

  This function gets attached to the 'term_exists' action in `GateOne.Net.actions` and gets called when the server reports that the terminal number supplied via 'new_terminal' already exists. It doesn't actually do anything right now but there might be use case for handling this condition in the future.

`GateOne.Terminal.``registerTextTransform`(name, pattern, newString)

  Arguments:

  - name (string) -- The name of this pattern (so we can reference it later).
  - pattern (regex) -- A regular expression that will be used to process incoming terminal screen updates.
  - newString (string) -- An HTML string with regular expression placement indicators (e.g. $1) that will replace what was matched in pattern.

  Adds a new or replaces an existing text transformation to `GateOne.Terminal.textTransforms` using pattern and newString with the given name. Example:

      // If your company's ticket system uses the following format: IM123456789 the code
      // below will turn it into a clickable link in the user's terminal!
      var pattern = /(\bIM\d{9,10}\b)/g,
          newString = "<a href='https://support.company.com/tracker?ticket=$1' target='new'>$1</a>";
      GateOne.Terminal.registerTextTransform("ticketIDs", pattern, newString);
      // If you typed "Ticket: IM123456789" into a terminal it would be transformed thusly:
      //      "Ticket number: <a href='https://support.company.com/tracker?ticket=IM123456789' target='new'>IM123456789</a>"

  What is a text transformation? Why should I care?

  Text transformations allow one to arbitrarily replace any string in the incoming terminal screen with one of your choosing. In the example code above it turns ticket numbers like IM0123456789 into clickable links but you can also match things like credit card numbers, man page commands, etc and do what you want with them.

  Tip

  A single .js file in `gateone/plugins/yourplugin/static/` is all it takes to use your own text transformations on a Gate One server!

  Note

  To keep things smooth and prevent blocking the interactivity of the browser all text transformations are processed within Gate One's Web Worker (go_process.js). In fact, this is exactly how Gate One transforms URLs into clickable links.

`GateOne.Terminal.``resetTerminalAction`(term)

  Arguments:

  - term (number) -- The terminal number you wish to reset.

  Clears the screen and the scrollback buffer (in memory and in localStorage) of the given term.

`GateOne.Terminal.``setModeAction`(modeObj)

  Arguments:

  - modeObj (object) -- An object in the form of `{'mode': setting, 'boolean': True, 'term': term}`

  This function gets attached to the 'set_mode' action in `GateOne.Net.actions` and gets called when the server encounters either a "set expanded mode" or "reset expanded mode" escape sequence. Essentially, it uses the values provided by modeObj to call `GateOne.Net.actions[modeObj['mode']](modeObj['term'], modeObj['boolean'])`.

  See also

  `GateOne.Terminal.modes`.

`GateOne.Terminal.``switchTerminal`(term)

  Arguments:

  - term (number) -- The number of the terminal you wish to switch to.

  Calls `GateOne.Net.setTerminal()` then calls whatever function is assigned to `GateOne.Terminal.termSelectCallback` (default is `GateOne.Visual.slideToTerm()`) with the given term as the only argument.

  Tip

  If you want to write your own animation/function for switching terminals you can make it happen by assigning your function to `GateOne.Terminal.termSelectCallback`.

`GateOne.Terminal.``termUpdateFromWorker`(e)

  Arguments:

  - e (object) --

    A JavaScript event incoming from the go_process.js Web Worker.

  When the go_process.js Web Worker has completed processing the incoming terminal screen it pushes the resulting data back to the main page via this function which performs the following:

  > - Sets the terminal title if it changed.
  > - Creates the screen and scrollback buffer nodes if they don't already exist.
  > - Applies the incoming screen and scrollback buffer updates (using `GateOne.Terminal.applyScreen()`).
  > - Automatically increases or decreases the size of the screen node if it has changed since the last update.
  > - Only Once: Adjusts the position of the toolbar so that it lines up properly next to the the scrollbar.
  > - Schedules writing the scrollback buffer to localStorage making sure that there's only ever one such write going on at once.
  > - Generates log messages sent from the Web Worker (only used when debugging).
  > - Notifies the user of activity/inactivity in terminals and keeps track of those timers.
  > - Calls `GateOne.Terminal.updateTermCallbacks` when all of the aformentioned activities are complete.

`GateOne.Terminal.``timeoutAction`()

  This function gets attached to the 'timeout' action in `GateOne.Net.actions` and gets called when the user's session has timed out on the Gate One server. It writes a message to the screen indicating a timeout has occurred and closes the WebSocket.

`GateOne.Terminal.``updateTerminalAction`(termUpdateObj)

  Arguments:

  - termUpdateObj (object) -- An object that contains the terminal number ('term'), the 'scrollback' buffer, the terminal 'screen', and a boolean idicating whether or not the rate limiter has been engaged ('ratelimiter').

  Takes the updated screen information from termUpdateObj and posts it to the go_process.js Web Worker for processing.

  This function gets attached to the 'termupdate' action in `GateOne.Net.actions` and gets called when a terminal has been modified on the server. The termObj that the this function will receive from the Gate One server will look like this:

      {
          'term': term,
          'scrollback': scrollback,
          'screen' : screen,
          'ratelimiter': false
      }

  `options.``term`

    The number of the terminal that is being updated.

  `options.``scrollback`

    An Array of lines of scrollback that the server has preserved for us (in the event that the screen scrolled text faster than we could send it to the client).

  `options.``screen`

    An Array of HTML-formatted lines representing the updated terminal.

  `options.``ratelimiter`

    A boolean value representing whether or not the rate limiter has been engaged (if the program running on this terminal is updating the screen too fast).

`GateOne.Terminal.``writeScrollback`(term, scrollback)

  Arguments:

  - term (number) -- The number of the terminal we're saving the scrollback buffer.
  - scrollback (array) -- The number of the terminal you wish to switch to.

  Saves the scrollback buffer in localStorage for retrieval later if the user reloads the page.

  Note

  Normally this function would only get called by `termUpdateFromWorker()`

## GateOne.User

`GateOne.``User`

GateOne.User is for things like logging out, synchronizing preferences with the server (not implemented yet), and it is also meant to provide hooks for plugins to tie into so that actions can be taken when user-specific events occur. It also provides the UI elements necessary for the user to change their bell sound.

### Properties

`GateOne.User.``userLoginCallbacks`

  If a plugin wants to perform an action immediately after the user is authenticated a callback may be appended to this array like so:

      GateOne.User.userLoginCallbacks.push(GateOne.MyPlugin.userAuthenticated);

  This is very useful if you want to ensure that a function does not get executed until after `username` has been set.

  All callbacks in `userLoginCallbacks` will be called with the authenticated user's username as the only argument like so:

      myCallback(username);

`GateOne.User.``username`

  Stores the authenticated user's username. If Gate One is configured with anonymous authenticationn ( `auth = none` in server.conf) the username will be set to 'ANONYMOUS'.

### Functions

- `GateOne.User.init`
- `GateOne.User.setUsername`
- `GateOne.User.logout`

- `GateOne.User.loadBell`
- `GateOne.User.uploadBellDialog`
- `GateOne.User.storeSession`

`GateOne.User.``init`()

  Like all plugin init() functions this gets called from `GateOne.Utils.postInit()` which itself is called at the end of `GateOne.initialize()`. It adds the username to the preferences panel as well as a link that allows the user to logout. It also attaches the 'set_username', 'load_bell', and 'gateone_user' actions to `GateOne.Net.actions`.

`GateOne.User.``setUsername`()

  This is what gets attached to the 'set_username' WebSocket action in `GateOne.Net.actions` and gets called immediately after the user is successfully authenticated.

`GateOne.User.``logout`(redirectURL)

  This function will log the user out by deleting all Gate One cookies and forcing them to re-authenticate. By default this is what is attached to the 'logout' link in the preferences panel.

  redirectURL if provided, will be used to automatically redirect the user to the given URL after they are logged out (as opposed to just reloading the main Gate One page).

`GateOne.User.``loadBell`()

  This gets attached to the 'load_bell' WebSocket action in `GateOne.Net.actions` and gets called by the server whenever it is asked to perform the 'get_bell' action. The server-side 'get_bell' action is normally called by `GateOne.Net.onOpen()` if a bell sound doesn't already exist in `GateOne.Prefs.bellSound`. This will download the default bell sound from the server and store it in `GateOne.Prefs.bellSound`.

`GateOne.User.``uploadBellDialog`()

  Displays a dialog/form where the user can set a replacement bell sound or reset it to the default (which is whatever is at '<gateone>/static/bell.ogg' on the server).

  Note

  When the user sets a custom bell sound it doesn't involve the server at all (no network traffic). It is set locally using the HTML5 File API; the FileReader() function, specifically.

`GateOne.User.``storeSession`()

  This gets attached to the 'gateone_user' WebSocket action in `GateOne.Net.actions`. It stores the incoming (encrypted) 'gateone_user' session data in localStorage in a nearly identical fashion to how it gets stored in the 'gateone_user' cookie.

  Note

  The reason for storing data in localStorage instead of in the cookie is so that applications embedding Gate One can remain authenticated to the user without having to deal with the cross-origin limitations of cookies.

### Navigation

- index
- modules |
- next |
- previous |
- Gate One Documentation »
- Developer Documentation »