Unitraverse Desktop Productivity
Application
Documentation
Section 14
Products
Contact us
About us
Section 14
Unitraverse Desktop Productivity Application - Version 1.4

Platform design mini-manifesto

How can tech be made more simple, easy and less of a drain on budgets and manpower? Answering this question is not hard if all you are doing is looking back on what has been done in the past and continuing on in the same trajectory, but what about new possibilites for the future? Are there unconventional ways we can push forward, accelerating things toward greater reduction of code authoring effort and fewer maintainence burdens? Taking what has worked in the past and using it more effectively is an important part of the answer. Consolidation of tasks that are common to a set of applications can be continued, and we should continue to place shared services into a framework or platform... but isn't there something more that can be done?

Whereas it may not be groundbreaking tech to place commonly shared processing into a single shared stack, much of the effort and toil required for CRUD (create, replace, update, delete) and saving to permanent storage should be done this way... it may, on the other hand, prove to be a game changing concept to have a wider range of web apps utilize a common codebase with a shared set of primitives, by limiting their internal data representation and having their gui interface conform to a single set of underlying patterns so that more can be done with a smaller codebase and less code maintenence and rewrite effort.

By reducing the number of design paradigms and streamlining a design process that conforms to unifying goals and economically satisfying objectives, a truly wonderful thing can happen: end users can get back to the business of developing and perfecting business logic, and focusing on domain relevant info and data rather than spinning their wheels on the endless parade of me-too technologies that don't necessarily gravitate toward streamlined endeavors or interoperability. A single set of GUI patterns is important, because consistent navigational cues can accelerate many processes in and around an unlimited number of applets and activities. Presumably, a single platform install process alleviates a lot of pain and frustration as well.

More specifically, what is also needed are platforms allowing users to generate scaffolding and an index-like lattice for the internet that conforms to this streamlined paradigm, with the help of software developers who will benefit from and use such common platforms to make applets available for end-user consumption.

This concept of end user navigation being enhanced, is not just a peripheral consideration for Unitraverse. It's the number one thing! Even if we nail it by having more apps benefiting from a powerful and flexible shared codebase, we will end up with more, possibly much more of the same thing that we currently have on the internet. More toll roads with annoying billboards, walls and gates that eat away valuable time for learners and students. But making it easier and faster and more enjoyable for users to find information, and having the process be part of the learning experience,... well, this can redeem the web, and accelerate extraordinary changes in society...for the better.

Content aside, forthcoming guidelines will light a path for applet developers to mimic some of the navigational cues and behaviors of the basic list applet. For example, the 'Enter' button should take people somewhere, or launch a building out process that converts a simple percept into an object that can be referenced and explored. The up and down arrow buttons should cycle through tabs that enable a set of menu items, sometimes familiar and conventional, sometimes special to the applet.

The goal is to realize a dream of effortless navigation, unimpinged activity and access, a uniform visual fabric and most importantly a content lattice, that will prove to be the favorite way to surf for learners and researchers of the world.

Unitraverse Client App APIs

Note: this section builds on concepts and ideas in previous sections. If something seems unclear or missing, it may be helpful to go back to the preceding documents.

To access the platform methods and variables you use the 'core' object. There are a couple different ways to get the 'core' object. When you are initializing your application and drawing HTML, the object is passed in as a function parameter. The first parameter in both the applet-provided initialization and HTML drawing methods is the 'core' object that exposes the API methods and data.

The other way to get the core object is by using a globally defined 'SharedGlobal' variable. This is the method you need to use when your code is running inside an event handler or other function that doesn't have access to the 'core' parameter mentioned above. Here is how you get the globally accessible object:

var core = SharedGlobal.core;

Variables (alphabetically)

core.defTitleBarHt

a global integer value that indicates the height of the window's title bar.

USE: used by applets that wish to mimic the title bar.

DETAILS: Title bars are drawn by the platform and, at this time the value is set to 34 pixels by default. It is currently modifiable directly and new values should persist until the user reloads the web application inside the browser, or some other applet modifies it.

core.device

a string that indicates the device platform that we are running on.

DETAILS: Values are 'mac' | 'win' | 'android' | 'ipod' | 'iphone'. These are obtained by examining the navigator.useragent inside the clients browser environment.

core.groupMap

an associative array whose keys are a resource id, and values are a string of comma separated group monikers.

USE: shows membership of some resources in 1 or more tagged resource groups

core.groupMode

a boolean value that indicates whether group mode is currently on or off

core.mainRect

a JavaScript object that provides the screen aspect and position of the main content area of the web client application

DETAILS: The object defines a rectangle with integer fields: width, height, top, bottom, left and right.

core.openItems

an array with indices that are resource item ids with element values that are booleans to indicate whether some resource is currently open

core.pathSeparator

the operating system ASCII symbol used as a delimiter in a file system path.

DETAILS: The path separator was obtained through the python or PHP agent paired with this client.

core.scopeItem

a JavaScript object that is the current node location (a.k.a. 'page') being viewed inside a window pane.

core.scopeItemIndex

the temporary id for the scope item being viewed inside a window pane.

core.tracker

a JavaScript object that provides iteration methods for traversing a vault's tree structure, accesssor functions for location-specific state, and generation of id strings that encode helpful location values.

DETAILS: See the tracker api section for more details.

core.vaultId

a string whose value is the globally unique identifier for the currently loaded vault.

Functions (alphabetically)

core.addToDynamicMenuitemList()

adds a menuitem for applets that are installing custom menuitems into the DOM under 'menu'.

DETAILS: This does not set up the action or HTML, but merely takes a list of DOM ids so that the platform can remove these when the applet no longer is the scope item. To see how applets can setup listeners for their menuitems, see the SampleCustomizer.js or Snippetizer.js applets.

PARAMETERS:

id_list
an array of DOM ids belonging to dynamic menuitems added by the applet

RETURN VALUE:

undefined

core.addVaultItem()

adds a newly created context node object to the current vault.

PARAMETERS:

parent_id
a number that is the parent id.

label
a string that is the label of the new vault item.

vault_item
a JavaScript object that is a vault item.

child_index
a number that is the child insertion location under the parent.

RETURN VALUE:

undefined

core.assembleCustomPopupFromJSON()

takes a JavaScript object whose attributes are a description for generating a customized arrangment of HTML form inputs. The HTML is added to the DOM, as content for the custom dialog popup.

DETAILS: The custom popup is not displayed until applet code invokes the attemptDisplayDialogBox() function, passing it the 'custom-popup-pane' string.

How to specify controls:
Each control that you need in the popup will have it's own JavaScript object with the following attributes:

  • field.value
    a boolean, string or integer value that determines the default content or state of the control. Which type to use will depend on the kind of control.
  • field.type
    a string that must be one of the following: 'normal_text' | 'bold_text' | 'radio' | 'checkbox' | 'edit'
  • field.key
    a unique value that your applet callback function can use to access the response value for a specific control.
  • field.text
    a string that is the message to be displayed for static text.
  • field.options
    a list of strings that are used as options in a listbox.
  • field.label
    an optional string that appears next to the form component to prompt users for the information that is sought.

How to obtain responses:
A callback that recieves user responses must expect a parameter value that is a map of the results from the user. The keys to the map are those same keys supplied by the assembleCustomPopupFromJSON function. See the code sample below for more clarity on recieving user responses.

PARAMETERS:

custom_dialog_info
a JavaScript object that is a vault item.

accept_values_fn
a callback function that accepts the modified values.

CODE SAMPLE:


  function getFavoriteColorChoice(){
var customDlgInfo = {"fields":[
{type:"edit", label: "my favorite color:", box_class: "medium", value: "", key: "clr"} ]}; SharedGlobal.core.assembleCustomPopupFromJSON(customDlgInfo,acceptUserResponses); SharedGlobal.core.attemptDisplayDialogBox('custom-popup-pane'); } function acceptUserResponses(resultMap){ var colorChoice = resultMap['clr']; doSomethingWithFavColor(colorChoice); }

RETURN VALUE:

undefined

core.attemptDisplayDialogBox()

causes a dialog popup to appear if no other popups are currently being displayed.

DETAILS: See assembleCustomPopupFromJSON for more info.

PARAMETERS:

dialog_box_id
string values that identify an available popup. The possible values are:

  • custom-popup-pane
  • search_settings_pane

RETURN VALUE:

undefined

core.copyFileToNativeLocation()

[not implemented]

PARAMETERS:

[tbd]

RETURN VALUE:

undefined

core.createNewVaultItem()

creates a new vault item with default values. The new item must be added to the vault in some location before it will be visible to users.

DETAILS: Calling this function sets a flag that will cause temporary scaffolding ids to be regenerated.

RETURN VALUE:

a Javascript object that is the new vault item.

core.createTemporaryResourceVaultItem()

creates a resource item that can can be added to a vault tree and will take on the look and feel of resources items provided by the 'add' -> 'file', 'add' -> 'url', or 'add' -> 'doc' menu commands.

PARAMETERS:

type
a string that indicates the type of resource. Expected values are 'doc' | 'url' | 'file'.

title
a string that indicates the title if the resource type is 'doc'.

filename
a string that indicates the filename of the file associated with the resource.

extension
a string that indicates the file extension of the file associated with the resource. Expected formate is '.*'.

RETURN VALUE:

a JavaScript object that is the resource item.

core.doArbitraryLocationCopyItems()

calls copyItems after setting things up to use a vault location other than the current scope item for some window.

PARAMETERS:

event
a JavaScript object that is a browser-supplied keydown, mouse click, or similar event.

parent_id
a number that indicates the temporary item id for the current vault.

child_index
a number that is the child array postion for vault item to copy.

RETURN VALUE:

undefined

core.getActivePaneIndex()

provides the window pane index for the currently active window.

RETURN VALUE:

a number that is the active pane index

core.getApplicationInstanceId()

provides a unique application instance id

DETAILS: Using the accessor function allows the platform to keep track of currently used and next available app instance ids for applets. An applet might be used for any number of vault items that have been configured to run it. With this comes the possibility of more than a single instance of some particular applet using the code, associated storage and DOM objects at the same time. When it is important to differentiate between applet instances, for example, to remember applet state that users will expect to be unique to some particular applet instance, an app instance id can be used. For more insight about this, check out the sample applets listed here.

RETURN VALUE:

a number that is an app instance id

core.getCurrentTabIdsRgn()

will obtain the current tab ids rgn.

DETAILS: Tab ids regions are contiguous sections of the tab cycle that correspond to GUI regions on the screen. It simplifies having behavior that is taylored to the location of the current selection within the tab cycle. They are used to route control and to expedite software responses to events that dictate what is an is not appropriate behavior.

The possible regions are 'out of bounds', 'navpath', 'container', 'child', and 'resource'.

RETURN VALUE:

a string that is one of the aforementioned regions.

core.getDrawingInstanceToken()

obtains a unique string token that differentiates numerous redundant applet drawing instances from one another so that DOM collisions and other cached memory collisions can be avoided.

DETAILS: Applets will often need to create HTML containing id attributes that will eventually become part of the DOM. When code must later tweak the position or modify data associated with these ids, id collions will prevent all but the last instance of that DOM object from being updated. This situation arises from the fact that having multiple windows as well as support for sym links can cause many instances of the same vault item to be displayed at the same time.

RETURN VALUE:

a string that is the drawing instance token

core.getDrawingPaneIndex()

provides the index of the window pane that is currently being drawn.

RETURN VALUE:

a number that is the index of the currently drawn window.

core.getGloballySafeDOMToken()

obtains a unique string token that can be trusted as a unique identifier among other globally safe identifiers generated since the application was first loaded.

RETURN VALUE:

a number that is the globally unique token.

core.getInternalClipboardData()

obtains the current data object that was saved to the internal web application clipboard.

DETAILS: Note that the internal clipboard is not the operating system's clipboard.

RETURN VALUE:

a JavaScript object having no specific format or restrictions, that was saved previously.

core.getItemFromBankIndex()

obtains a vault item from the specified index (a.k.a. 'vault item id').

PARAMETERS:

index
a number greater than -1 that is the vault item id.

RETURN VALUE:

a JavaScript object that is the requested vault item.

core.getKeycdFromEvt()

converts a useful key code from the browser supplied keydown event.

RETURN VALUE:

a string that is the useful intuitive key code

core.getParentAndChildIndex()

obtains a wrapper object that contains the parent object and the child index that corresponds to the first encountered instance of the input object among children of its parent.

RETURN VALUE:

a JavaScript object that has the following fields:

parent
a JavaScript object that is the parent of the input object.

childIndex
a number that is the child index of the input object.

core.getPositionedTracker()

obtains a tracker object that is set to a specific node within the vault tree relative to the current scope item.

DETAILS: No input parameters are needed by this function because the relative position is computed from the current tab id selection. See the tracker api section for more information about trackers.

RETURN VALUE:

a JavaScript object that is a tracker set to begin iteration and tracking at a specified descendant position.

core.getRelativePositionTracker()

obtains a tracker set to a vault position supplied by the caller.

DETAILS: See the tracker api section for more information about trackers.

PARAMETERS:

prx
a JavaScript object that is a 'path route extension'. A path route extension is an array of child indices that describe a route from the scope item of a specified window pane, to some descendant location within the scope item branch. One example might be the prx '[2,4,9]', which describes the 10th child of the 5th child of the 3rd child of the scope item node.

child_index
a number that is the child index of the selected child label that belongs to the deepest vault item implied by this position.

pane_index
a number that is the index of the specified window pane.

RETURN VALUE:

a JavaScript object that is a tracker set to begin iteration and tracking at a specified descendant position.

core.getSelectionInfo()

obtains a JavaScript object whose fields hold the values that define the current selection state.

DETAILS: Selection state involves more than just a simple single selected item, it entails a selected child under a selected parent and the tab id grouping called a 'zone' (a.k.a. a 'region').

RETURN VALUE:

a JavaScript object indicating the current selection with the following fields:

scopeIndex
a number that is the item id for the current scope.

rgn
a string that indicates the current contiguous range (a.k.a. 'zone') in which the selected tab id is found, for a given window. Values can be 'out-of-bounds' | 'navpath' | 'container' | 'child' | 'resource'.

zoneIndex
a number that is the nth index for some zone or region. For example, if the 'rgn' is 'child' then the zone index is a child index. If the region is 'resource', then the zoneIndex is valid for accessing resources.

scopeItem
a JavaScript object that is the current scope item for some window.

accessScopeIndex
a number that is the parent id of a selected item in either a multi-level view or a single level view.

accessZoneIndex
a number that is the child index of a selected item in either a multi-level view or a zone index in a single level view.

core.getTabIdsPos()

obtains the current position in the tab cycle array.

DETAILS: Hanging on to a tab id is never a good idea, because users can move about in the same scope very quickly and a function to get the current position in the tab cycle is needed instead of a static tab position.

RETURN VALUE:

a number that is the zero-based index associated with the current tab id array position.

core.getTemporaryVaultUniqueId()

obtains a unique temporary id for any use or purpose specific to the current vault.

DETAILS: No other temporary id assigned will collide with ids obtained via this function unless they are kept permantently, which is a misuse of this id. The temporary id will be valid until the next load of the web application. Rather than force the vault's resource or link id counters up, only to leave unused ids down the road, a separate counter for temporary ids is used to provide the ids.

RETURN VALUE:

a unique number that is the temporary id.

core.getVaultSharedStorage()

obtains a storage object intended for all instances of some applet or applet grouping.

DETAILS: The vault shared storage is a permanent location in the current vault that can store information that is useful for all users of the vault. It would not be the ideal place to keep user-specific information, but thus far no facility is yet in place for that kind of storage. The shared storage object is just a non-descript JavaScript object that can have custom fields added to it, in order to accomodate and store any data required by the applet.

RETURN VALUE:

a JavaScript object that is the shared storage for the given key.

core.getVaultSnapshot()

obtains a stringified version of the vault after first collapsing it.

DETAILS: A collapsed vault has none of the cycles or duplicate branches that happen because of sym links. In other words, none of the guest vault items are installed, only the link stubs that are present when the vault is saved to disk. Other associated data, such as external links relavent to this vault, or user info referencing it, is not captured by this function.

RETURN VALUE:

a string that is a copy of the collapsed vault.

core.getWindowPaneFromIndex()

obtains a window pane from the window pane index.

PARAMETERS:

pane_id
a number that is the index of the desired window pane.

RETURN VALUE:

a JavaScript object that is the window pane.

core.generateHTMLFromScopeId()

obtains HTML from vault locations chosen by applet code.

DETAILS: When an applet draws a page, it may want to bring in HTML from some other node that is knows will contribute something beling to it's own page. This enables nested drawing with some limitations on things such as the tab cycle or injection of menuitems.

RETURN VALUE:

a string that is the generated HTML

core.hideCurrentDialogBox()

hides any currently displayed dialog box.

RETURN VALUE:

undefined

core.insertPercept()

inserts a string into the context node's list of labels, (a.k.a. list of 'percepts').

DETAILS: A context node is one location on a tree consisting of an item and it's children. The children are sometimes child objects, but often they are null. Regardless of whether there are child objects or not, a parallel list of labels will allow a context item to draw it's own contents in terms of how the child items might be percieved from the outside. Quite often, a percept is the same or similar to the title of the child object if one exists.

RETURN VALUE:

undefined

core.installGuest()

adds a link stub to the specified parent at the specified child location, and sets up its guest item for future swaps.

DETAILS: The importance of installGuest() is that it enables applets such as Snippetizer.js to read in documents and data from external sources and place them into the vault without having the storage size of the vault grow.

When platform code requests a swap, the system either replaces the link stub with the vault item, (both provided as argments to this function), or it replaces the vault item with the stub, depending on whether the tree is being expanded or collapsed.

The sym link mechanism uses this swapping system, but also, applets can make use of it by submitting a guest and stub pair which may or may not be a symbolic link. All such guests are temporary and when applets need to add something to the vault but do not wish to install it permanently, they can make use of this method.

PARAMETERS:

parent
a JavaScript object that is the parent location for the guest and its stub.

child_index
a number that is the child index at which the guest and alternately its stub, are placed.

stub
a JavaScript object that is the stub.

guest
a JavaScript object that is the guest item.

RETURN VALUE:

undefined

core.isThereUnsavedData()

indicates whether or not there are changes to the vault that haven't yet been saved to disk.

RETURN VALUE:

a boolean value that is true if there are unsaved changes to the vault, false otherwise.

core.navigateToContainerContext()

changes the current scope to it's parent if the current scope item has a parent

RETURN VALUE:

undefined

core.openItemFromId()

changes the current scope to a specified location.

PARAMETERS:

id
a number that is the temporary id of the vault item to open, making it the current location, (a.k.a. making it the 'scope item').

RETURN VALUE:

undefined

core.pointIsInRect()

indicates if a given point is inside a given rectangle.

DETAILS: The input point and rectangle are assumed to have the same coordinate systems.

PARAMETERS:

x_coordinate
the x coordinate in pixels

y_coordinate
the y coordinate in pixels

rectangle
a JavaScript object with integer fields: width, height, top, bottom, left and right.

RETURN VALUE:

true if the point exists inside the rectangle, otherwise false.

core.promptToSave()

alert the user that changes have been made to the vault and that they are currently unsaved.

RETURN VALUE:

undefined

core.removeVaultItem()

removes a specified item from the vault at a specified location.

PARAMETERS:

parent
a JavaScript object that is the parent.

item_id
a number that is the vault item id of the object to be removed.

child_index
a number that is the zero-based index location where the target object resides under the parent item.

RETURN VALUE:

a boolean value that indicates the operation's success or failure.

core.replaceVaultItemAtLocation()

replaces a specified vault item at a specified location, no questions asked.

DETAILS: The specified child location must already contain either an object or null value. If there is a pre-existing object, no deletion or finalization will take place and no sunset notifications will be sent.

PARAMETERS:

parent_id
a number that is vault item id.

child_index
a number that is the child index for an existing vault item or null value.

vault_item
a JavaScript object that is the vault item that will occupy the specified position, replacing the existing item.

RETURN VALUE:

undefined

core.requestDirectoryContents()

sends a request to the Python or PHP agent paired with this web application for files and subdirectories contained in a specified OS file system location.

PARAMETERS:

path
a string that is the complete or relative path to a file directory.

callback
a function that will recieve the directory content info.

RETURN VALUE:

undefined

core.requestFileContents()

sends a request to the Python or PHP agent paired with this web application for the contents of a specific OS file system file.

PARAMETERS:

file_fqfn
a string that is the fully qualified filename (including the OS directory path) for the file.

callback
a function that will receive the contents of the file.

RETURN VALUE:

undefined

core.requestRedraw()

starts an immediate redraw for the entire vault.

DETAILS: Any applet can request a redraw at any time. This redraw does not reload any applets or run their initialization functions.

RETURN VALUE:

undefined

core.setAutoManagedNonSerializableField()

adds an object and attribute to the auto-manage list and initializes the specified attribute and object with the given initial value.

DETAILS: Protecting our permanently stored vault from accumulating large amounts of temporary runtime data will have a direct impact on end-user experience. However, using 'scope items' to stash some state information is a seemingly necessary thing to do, so one of the solutions is to create a field that is automatically removed before serialization. This function provides just such a field.

Note: it is not necessary that the supplied object be a context node. Any object that becomes attached to the vault but should not be permanently saved to disk can be auto-managed, with a few exceptions that should seem obvious... such as auto-managing some object that is critical for the serialization routine to function.

PARAMETERS:

object
a JavaScript object.

attribute_name
a string that is the name of the field that is removed during save operations and restored immediately after.

initial_value
any valid JavaScript primative, object or value.

RETURN VALUE:

undefined

core.setOnAcceptSimpleEditFunc()

puts in place a callback function that will receive the results of the simple edit popup if the user accepts the new value.

CODE SAMPLE:

function askForDateOfBirth(){
var core = SharedGlobal.core;
core.setSimpleEditMessage("date of birth:");
core.setOnAcceptSimpleEditFunc(acceptUserBirthday);
core.attemptDisplayDialogBox('simple-edit-pane');
var element = document.getElementById('se-dialog-single-item');
element.value = defaultDOB;
}


function acceptUserBirthday(){
return document.getElementById('se-dialog-single-item').value;
}

RETURN VALUE:

undefined

core.setSimpleEditMessage()

loads the specified message to the DOM object that will prompt users for a edit box response.

RETURN VALUE:

undefined

core.setTitleBarBgColor()

sets the background color used for platform-generated title bars for a particular window pane.

DETAILS: The use of this function is not as straight forward as we all might like it to be! The HTML for platform-drawn title bars is rendered *before* the content code is drawn. That means if you wait for your applet to draw itself and decide to use this function in your HTML rendering code, the icon will not appear.

PARAMETERS:

window_id
a number that is the id for a window.

color
a string that is the CSS-legal color.

RETURN VALUE:

undefined

core.setTitleBarColor()

sets color used for platform-generated title bars for a particular window pane.

DETAILS: See the 'DETAILS' section for 'setTitleBarBgColor()'.

PARAMETERS:

window_id
a number that is the id for a window.

color
a string that is the CSS-legal color.

RETURN VALUE:

undefined

core.setTitleBarIcon()

sets the icon used for platform-generated title bars for a particular window pane.

DETAILS: See the 'DETAILS' section for 'setTitleBarBgColor()'.

All of this to say, each of the above title bar functions need to be invoked during applet initialization, or when a user event is going to cause or bring about customization for a title bar.

PARAMETERS:

window
a JavaScript object that is the target window.

icon_resource
a string that is the OS path (in the future, a URL) at which resides a bitmap file.

RETURN VALUE:

undefined

core.setTitleBarTitle()

sets the title of a title bar for a particular window pane, overriding the normal behavior of using the scope item's title.

DETAILS: See the 'DETAILS' section for 'setTitleBarBgColor()'.

PARAMETERS:

window
a JavaScript object that is the target window.

title
a string that is the title.

RETURN VALUE:

undefined

core.setupResponsiveMenuitem()

adds a menuitem at the specified menu location and with the specified handler and shortcut

DETAILS: the platform provides a shared menu, with a degree of uniform structure, for the benefit of the user. The 'responsive' nature of the created menuitem means that it turns off and on (becomes active and deactivates) when the appropriate things are selected in the active window, provided that any applet-supplied 'allow' function also returns true.

PARAMETERS:

window_id
a number that is the index for the window that sends the menuitem contribution two the composite menu.

group_name
a string that is the name of the top-level branches of the main menu. There are four supported group names that appear in the following order in the main menu:

  • 'gleaner' - currently seafoam green menuitems that have to do with users that are purely consumers of vault data rather than authors
  • 'author' - currently lavender menuitems that provide actions related to editing and authoring of vault content.
  • 'applet' - currently yellow menuitems that provide actions related to the current applet.
  • 'platform' - currently pink menuitems that are odd & ends or related to the platform or environment.

command_sequence
a string that describes the menuitem location. The provided command sequence is used to generate components that start with a root menuitem and extends to the final, operative menuitem, using auto-generated submenus that are populated using multiple calls to this method.

tab_cycle_region_code
a string that signifies the selection locations in a window pane that allows the target menuitem to be active. Values can be 'out-of-bounds' | 'navpath' | 'container' | 'child' | 'resource'.

allow_function
a function that adds an extra requirement for enabling menuitem activation. Regardless of how restrictive or inclusive the set of tab cycle regions being specified for activation might be, this function increases the restrictiveness, returning true if the menuitem can be active and false if it should not be.

label_id
a number that is the id for the text element of the menuitem that can be used by applets to manipulate or decorate.

shortcut_key
a string that is the shortcut key, (implemented by other code).

menu_action
a function that is the handler for click events on this menuitem.

DETAILS: It can be safely assumed that when handlers are invoked, the current window is the active window. Handlers are associated with a window and deactivated when their window is not the active window.

RETURN VALUE:

a JavaScript object that is the command info. This info is used internally, and not likely to be used by applets.

core.updateCore()

updates the core platform variables to which applets are given access.

DETAILS: The vault and platform interface variables are copies of internal values that frequently change. Moving to a new location, toggling groupMode and some other things can require that these static values are refreshed.

The following are variables that get refreshsed:

  • scopeItem
  • scopeItemIndex
  • pathIds
  • tracker
  • childIds
  • groupMode

RETURN VALUE:

undefined

core.writeToInternalClipboard()

copies the specified data to the internal clipboard.

DETAILS: The internal clipboard is not the OS clipboard, and it does not persist beyond the life cycle of the current web application.

RETURN VALUE:

undefined

email: support@unitraverse.com

Our company was founded in July 2017 by Bradley Pliam.

The headquarters is currently in Austin, Texas.

Ideas that have been in gestation since the early 2000s have now finally been given 'wings'.

The mission of the company is to deliver happiness in the form of value and great user experience via high quality software, being honest about what is being delivered, and up-front about any current limitations. The world of software has some great things, along with some insidiously bad aspects. We intend to be a positive influence.

Meet our current staff...

Brad Pliam - Dev lead

Unitraverse