`/usr/local/bin`.
-Overview
+Concepts
========
-Core concepts
--------------
+Code structure
+--------------
+
+The code of the widget set is in four main layers, described here from
+the bottom up:
+
+1. The core code, which manages the set of widget teams, default
+options, authentication onto the Service Proxy, and the creation of
+widgets from HTML elements.
+This code is in `mkws-core.js`
+
+2. The team code, which manages teams of widgets. This is responsible
+for the collections of widgets that make up teams, event queues, and
+handling search-and-retrieval events
+This code is in `mkws-team.js`
+
+3. The generic widget code, which handles the creation of widget
+objects, parsing configuration attributes from their HTML elements,
+and firing off automatic searches.
+
+4. The code for individual widgets, which is specific to those
+widgets. It often involves subscribing to events and responding to
+them by setting the HTML of the widget element, but need not do
+so. The code for many of the most important widgets is in
+`mkws-widget-main.js`, but certain other widgets are defined in other
+files beginning with the prefix `mkws-widget-`.
+
+In addition to this code, there are several source files containing
+support code:
+
+* `mkws-filter.js` contains support routine implementing the
+filter-set data structure, which contains information about which
+filters (e.g. by target, or by facet) are in force.
+
+* `mkws-handlebars.js` contains Handlebars helpers which can be used
+by the HTML templates.
+
+* `mkws-popup.js` defines a special widget for creating popup
+ windows. These may, but need not, contain other MKWS widgets,
+ forming a popup searching application.
+
+The final component of the source code is the set of Handlebars
+templates, in the `templates` directory, which are used to emit the
+HTML of the various widgets' contents. These are compiled into the
+file `mkws-templates.js`.
+
+
+
+Defining new types of widget
+----------------------------
Development with MKWS consists primarily of defining new types of
-widgets. These can interact with the core functionality is several
-defined ways.
+widgets. This is done using exactly the same API as the the widgets
+that come as part of the set: they have no privileged access.
You create a new widget type by calling the `mkws.registerWidgetType`
function, passing in the widget name and a function. The name is used
to recognise HTML elements as being widgets of this type -- for
-example, if you register a `Foo` widget, elements like
-`<div class="mkwsFoo">` will be widgets of this type.
+example, if you register a `foo` widget, elements like
+`<div class="mkws-foo">` will become widgets of this type.
-The function promotes a bare widget object (passed as `this`) into a
+The function promotes a bare widget object (which is created by the
+core widget code and passed in as `this`) into a
widget of the appropriate type. MKWS doesn't use classes or explicit
prototypes: it just makes objects that have the necessary
behaviours. There are _no_ behaviours that Widgets are obliged to
provide: you can make a doesn't-do-anything-at-all widget if you like:
- mkws.registerWidgetType('Sluggard', function() {});
+ mkws.registerWidgetType('sluggard', function() {});
More commonly, widgets will subscribe to one or more events, so that
they're notified when something interesting happens. For example, the
-`Log` widget asks to be notified when a `log` event happens, and
+`log` widget asks to be notified when a `log` event happens, and
appends the logged message to its node, as follows:
- mkws.registerWidgetType('Log', function() {
+ mkws.registerWidgetType('log', function() {
var that = this;
this.team.queue("log").subscribe(function(teamName, timestamp, message) {
* You can add functionality to a widget by subscribing it to an
event's queue using `this.team.queue("EVENT").subscribe`. The
argument is a function which is called whenever the event is
- published. The arguments to the function are different for different
- events.
+ published. The arguments to the event-callback function are
+ different for different events.
* As with so much JavaScript programming, the value of the special
- variable `this` is lost inside the `subscribez` callback function,
+ variable `this` is lost inside the `subscribe` callback function,
so it must be saved if it's to be used inside that callback
(typically as a local variable named `that`).