Widget Pages

An HTTP-Oriented MVC Pattern

by Guilherme Gusm?o da Silva

Foreword

* HTTP request and response cycle nature impacts the MVC pattern.
* Here we try to describe this impact.
* Based on that description we propose an HTTP-oriented MVC pattern called Widget Pages.
* The new MVC pattern makes extensive use of XMLC and Barracuda technologies.

The MVC Pattern

* MVC separates a GUI in its data (model), its appearance (view) and its algorithm (controller).

The HTTP Protocol

* HTTP separates a Web page in its markup representation and the corresponding Web browser GUI.

MVC versus HTTP (I)

* HTTP distinguishes between a markup view and a GUI view. MVC does not.
* For the HTTP server, there is only a markup view, not a GUI view. For MVC, there is only a GUI view.
* In the HTTP response, the markup view should also represent pure data.

MVC versus HTTP (II)

* A view as a GUI always represents either a valid, or a fake, or even an empty model processed by a controller. So it is also a whole MVC pattern.
* A view as markup can also be a whole MVC pattern - a model processed by a controller.
* However, it can exist before any controller processes any model. So it can be a pure view (for instance: <SELECT></SELECT>).

MVC versus HTTP (III)

* HTTP splits MVC into both a server MVC (sMVC) and a client MVC (cMVC).
* sMVC is the model of cMVC, which is also a view based on an interpretation of sMVC by a client-side controller.
* So sMVC is the view model of cMVC, and cMVC is the controller view of sMVC.

The Data Concept

* The data within the HTTP response view is the sMVC model.
* So the sMVC model is data.

A Controller as Data

* The sMVC data can also be the cMVC view model (for instance: a checked radio button within a table cell).
* To add a view model to an sMVC pure view, the HTTP server has to give a controller another controller as data.
* So the data concept is not restricted to pure data.

The Prototype Concept

* The HTTP response view should incorporate data.
* A pure, empty view to which an sMVC controller adds data is a prototype.

An XMLC Prototype

* XMLC generates Java classes from HTML, XML, XHTML, and WML etc.
* In these classes, each XML tag identified by an ID attribute within the original document is a DOM node accessible by a getter method.
* Such a DOM node is a prototype.

The Widget Concept

* A widget is an algorithm capable of adding data to a prototype.
* So an sMVC controller is a widget.

A Barracuda's Widget

* Barracuda has components capable of adding data to prototypes.
* For a Barracuda's component, data can be another Barracuda's component.
* So each Barracuda's component is a widget.

The Page Concept

* A widget needs access to a prototype in order to add it data.
* This access can be a Java interface getter method allowing the widget to vary its prototype providers.
* Such a Java interface is a page.

Multiple Page Inheritance

* In Java, multiple inheritances are allowed within interfaces.
* Through multiple inheritances within pages, it is possible to vary the prototypes in a Web page without changing or creating any widget.

Widget Pages Core

* The Widget Pages core defines five Java classes.
* These classes include three interfaces, an abstract class and a final class.
* In addition to depending on other Widget Pages core classes, a Widget Pages core class depends only on the Object class.
* Now follows a description of each Widget Pages core class.

Page

* The Widget Pages core defines a mandatory parent class for all pages, the Page interface.
* However, there is no Page method that gets a prototype used by all possible widgets.
* Therefore, the Page interface has no methods.

Widget

* The Widget Pages core defines a mandatory interface for all widgets, the Widget interface.
* The Widget interface has five methods.
* Now follows a description of each method of the Widget interface.

Widget.getData

* The Widget.getData() method returns a data object:
* public Object getData();
* A data object can be any object, including a Widget interface implementer.
* So the Widget.getData() method returns an Object.

Widget.getPrototype

* The Widget.getPrototype() method returns an actual prototype implementation:
* public Object getPrototype();
* A prototype can be any object, such as an org.w3c.dom.Element, or an org.w3c.dom.html.HTMLSelectElement.
* So the Widget.getPrototype() method returns an Object.

Widget.getWidget

* The Widget.getWidget() method returns an actual widget implementation:
* public Object getWidget();
* A widget can be any object, such as a Barracuda's component.
* So the Widget.getWidget() method returns an Object.

Widget.getWidget'

* The Widget.getWidget(Object) method returns a Widget interface implementer:
* public Widget getWidget(Object);
* The returned widget is a clone of the invoked one whose Widget.getData() method returns the same Object received by the original widget as a parameter.
* The returned widget is data for the invoker ones.

Widget.getPage

* The Widget.getPage() method returns a Page interface implementer:
* public Page getPage();
* The returned page is a child of the Page interface used by the widget to get its prototype.

PageWidget

* The Widget Pages core defines a mandatory parent class for all widgets, the PageWidget abstract class.
* It has two constructors, one of which receives a Page interface implementer and an Object as data.
* The PageWidget abstract class provides final implementations of three Widget methods:
* Widget.getData()
* Widget.getWidget(Object)
* Widget.getPage()

WidgetDataHandler

* The other constructor of the PageWidget abstract class receives a Page interface implementer, an Object as data and a WidgetDataHandler interface implementer.
* The WidgetDataHandler interface has only one method, called within the Widget.getData() method for changing a widget data as necessary:
* public Object getData(Object);

DefaultDataHandler

* The Widget Pages core defines a default implementation of the WidgetDataHandler interface, the DefaultDataHandler final class.
* Its WidgetDataHandler.getData(Object) method returns the same Object received as a parameter.
* This is the class used within the Widget.getData() method when the PageWidget class two-parameter constructor is used.

Pattern Scope

* In addition to multiple page inheritance, the Widget Pages core applies to the full sMVC because of three methods:
* WidgetDataHandler.getData(Object)
* Widget.getPrototype()
* Widget.getWidget(Object)
* Now follows a by-method showing of it.

WidgetDataHandler.getData

* This method allows giving a widget other widgets as data.
* So a widget (an sMVC controller) can add any view model to any prototype.

Widget.getPrototype

* This method allows using the same widgets for adding data to any prototypes.
* So the same widgets can be used within any other widgets to add data to whatever their prototypes are.

Widget.getWidget'

* This method allows adding data to widgets contained in other widgets by means of the containing ones.
* So the same widgets can be used within any other widgets whatever their data is.

Reason For The Name

* The proposed MVC pattern is called Widget Pages for multiple page inheritance directs it toward widget sets that are also pages, widget pages for short.

Main Benefits

* Rigorous isolation between the view and the controller (XMLC).
* Truly generic controllers (Barracuda).
* API independent of both widget and prototype implementations (Barracuda and XMLC).
* Compile-time checking of the widget/prototype contract (XML ID tags).
* Optimized access to prototypes (XMLC-generated DOM node getters).

References

* XMLC (http://xmlc.enhydra.org).
* Barracuda (http://barracuda.enhydra.org).
* XML Journal article "Enhydra Design Patterns for ASPs" by Nick Xidis (http://www.sys-con.com/xml/article.cfm?id=340).

Do you mean HTML or *ML rather than HTTP. HTTP is a protocol.

Do you mean HTML or *ML rather than HTTP. HTTP is a protocol.