We've been busy working on building a Native Browser API for the Content View in 2.8.

This allows advanced users with JavaScript development skills to effectively build a custom view in Javascript which runs in your system browser, embedded inside the Omniscope Content View, with the page source editable in the Content View as usual.

This is very much work in progress, and subject to change following feedback before we release 2.8 in public beta. Please experiment and post below, but don't build any live reports that depend upon the new behaviour.

But can't I already use Javascript in the Content View?

The Content View already supports Javascript pre-processing. In your page source, you have special <# #> tags indicating the start and end of script fragments. Omniscope then, behind the scenes, executes the Javascript in a browser-less environment to produce the final page text.

This is directly equivalent to the way a PHP/JSP/ASP/etc. web server might "execute" a server-side page to produce the HTML document that is sent to the client. We chose to use Javascript on the "server" side, but note that there is no HTML DOM or browser Window object, for example; this is pure "headless" Javascript.

In this case, the "server" is the Omniscope Content View back-end, in-memory on your desktop, and the "client" is the page renderer, either Java within Omniscope, or a separate native browser process embedded in the Omniscope window.

New source editing enhancements

When editing in "source mode" in the Content View, we now have full syntax highlighting of your page source. This makes scripting and HTML coding much, much easier.

Note that if you're using script pre-processing, advanced formulae, or the native browser, you will only be allowed to use source mode, rather than "design mode" for editing your page.

New menu items in the view's Tools menu:

• "Use native browser"
  
  This affects how the HTML page content is rendered, after it has been evaluated (e.g. applying any formula insertion or script pre-processing).
  
  This is deselected by default, matching 2.7 behaviour, meaning the page is displayed using Omniscope's built-in rich text display (via Java, based on HTML 3.2, without any support for in-page Javascript).
  
  When selected, the page is displayed by embedding the system web browser (typically IE on Windows), allowing "client-side" scripts to be executed in the browser's Javascript engine, with full access to the HTML DOM, etc. This allows you to build Javascript interactivity and do other native browser behaviours such as embed media.
  
  
• "View in external browser"
  
  Click this to open the same page in an external browser. This allows you to debug your page in a full separate browser; we recommend Google Chrome for its developer tools out-of-the-box. The embedded browser, if IE, has very limited support for debugging.
  
  Note that Javascript native dialogs (alert/confirm/prompt) are disabled in the embedded browser, because it can often lead to a complete freeze of the application. You should use alternative Javascript frameworks instead.
  
  
• "Refresh on change"
  
  By default, the page content is rebuild and the browser refreshed when cell edits or filtering occur. Untick this option to disable. You will need to code in a different means of triggering updates to any data you may have loaded via API / AJAX calls.
  
  Even if ticked, viewing in an external browser will never refresh automatically on change; you will need to manually reload the external browser.
  
  

AJAX requests

You can choose to use this native browser option to add some animations or general pizzazz to your Content Views, or more extensively by using the API to request and process data.

We currently provide two APIs. At a low level, an HTTP service is provided should you wish to roll your own AJAX calls and perhaps use different or incompatible JS libraries to those used by the high-level API.

The high-level API is enabled by inserting a pre-processing snippet into your page source in the HTML HEAD tag, and provides Javascript objects and methods to 'call' the enclosing Omniscope Content View.

Low-level API

The page itself is served up by "page.html" within an auto-generated unique URL, which changes each time the view is opened. Use "View in external browser" to see the URL. But you should not need to know this, since the other HTTP services are available in a relative URL to this page. For example, from within "page.html", you can use AJAX and hit the "meta.json" URL (without any further URL qualifiers).

All requests return HTTP status code 200 if successful.

• page.html
  
  Returns the page content as text/html after applying pre-processing and evaluating formulas.
  
  No request parameters.
  
  
• eval.json
  
  Evaluates a JS expression on the back-end, with access to formula functions.
  
  Accepts a POST request with text/plain upload body (NOT regular key/value form data), containing a Javascript expression to evaluate against the Content View's dataset as per "script pre-processing". This can be used to query arbitrary formula functions such as subset_max("fieldname"), for example.
  
  Returns JSON { "result": value } where value is the result of the expression; can be a complex object or array.
  
  
• meta.json
  
  Retrieves metadata about the view's data.
  
  No request parameters.
  
  Returns JSON { "fieldCount" : 13, "recordCount": 1052, "fieldNames": ["field1","field2",...], "fieldTypes": ["text","text","date","integer","decimal",...] }
  
  
• cells.json
  
  Retrieves one or more cell values.
  
  Accepts a POST request with the following form key/value pairs:
  "fields": a JSON array of field names; if omitted, all fields are retrieved
  "firstRow": The first row to retrieve, 0-indexed, must be in-bounds; if omitted, zero is used
  "numberOfRows": The number of rows to retrieve; if omitted, all remaining rows are retrieved; automatically capped by the last row in the dataset
  
  Returns JSON { "result": [ [cell00, cell10, cell20], [cell01, cell11, cell21], [cell20, cell21, cell22] ] }
  (where the 2-dimensional array's dimensions reflect the filtered data results, doesn't contain a row for field names, and is indexed [column][row]).
  
  
• edit.json
  
  Writes back one or more cell edits to the data table.
  
  Accepts a POST request with the same key-value pairs as "cells.json", plus:
  "data": a JSON two-dimensional array, in the same format as returned by "cells.json" under the "result" property.
  
  Returns the empty JSON {} to indicate success.
  
  This will only work in licensed editions where editing cell data is permissioned - i.e. not in the free Viewer. It will propagate a change to all views, and you will immediately see the result. You will need to untick "Refresh on change" if you want to avoid the same Content View (which originated the call) from reloading your page.