MVC in Pentaho XUL applications can be achieved by architecting your application using the pattern we will detail here. As a refresher, the purpose of the MVC pattern is separation of concerns in UI applications. The idea is to keep a clear separation between the data we would like to display and how that data is being displayed. In Pentaho XUL framework (PXF) the view layer is represented at least partially in a xul dom object (typically coming from a xul file). I say "partially" because you could consider view logic to be part of the view and view logic is not included in the XUL DOM.
The diagram below shows how Pentaho XUL MVC would operate in an example UI widget project Foo. Starting from the left we see that the XUL file foo.xul is represented in your application as a XulDom. The XulDom is what we consider to be the View of our MVC implementation PXF by way of the XulDom is responsible for instantiating and laying out UI components, however, as we mentioned earlier view logic is not handled by the XulDom. The responsiblity for handling view logic rests on the Controller. View logic is comprised of component state changes and events. These two classes of view logic are handled differently in the Controller. As depicted in the diagram, user interface events are handled directly in the controller, whereas state changes are mapped by the controller to a model.
Events vs State Changes - the story
A major motivation of introducing MVC in XUL applications is to remove all XUL dependencies from the backing model. In a rudimentary MVC implementation, the housekeeping work of wiring up XUL components to the backing model would be handled in the controller. Fortunately, we were able to take one more step in minimizing XUL dependencies by implementing XUL Binding. What this means is now it is possible for your controller to have zero XUL dependencies. I say possible because this is not always the case. There are some limitations to XUL Binding. XUL Binding is simply the synchronization of two Java Bean properties and since user interface events such as a button click are not represented as a bean property, they cannot be bound. So here is the important distinction, UI _events_ must be handled in their own handler methods within your controller while component _state changes_ will be bound to your model in the onLoad method of your controller. So back to my statement that it is possible for your controller to have zero XUL dependencies.. this is true if your view doesn't require any event handling, but if it does, your controller will have to handle the event explicitly. As such your controller will typically have references to XulContainer subclasses (the events will typically launch dialogs and windows). Even so, your controller should still have zero references to XulComponent subclasses as any changes to a XulCompoent you might with to make have to do with properties of the component and should be handled via a binding.
Data Binding and Component-state Events
It is the responsibility of your Controller implementation to setup bindings between your XUL components and your model (a POJO/Java Bean). What do we mean by "binding"? Binding is a way to associate bean properties so that when one changes, the other is kept in sync. Binding can be unidirectional or bidirectional, but we won't get into that here. For more information on this see XUL Bindings. For the purpose of this document we will assume that a binding is always bidirectional meaning when either side of the binding changes, the other will reflect the change. This is useful in UI applications because we can tie, say, a text box's value to a model bean String property. Consider the following XUL file snippet that defines a text box component by id "nameTextBox". Notice that there are no attribute specifying event handler calls; these are not needed when using data binding.
Here is a snippet of the corresponding controller onLoad method. Notice how you create a binding between the model's name property and the nameTextBox XUL component value property.
Behind the scenes this bind method is retrieving a XulComponent by id "nameTextBox" and linking the name property of the model to the value property of the XulComponent instance. Now let's say in addition to binding the name property to a text box we want to wire the enabled state of an OK button to a boolean bean property on the model. We would just add another bind call that ties the two properties together, notice the "!" expression which does an in-flight negation of boolean value. (Many XUL components have a disabled attribute--which is sometimes hard to wrap your head around; typically we like to think in the positive.)
How do I know which properties to bind?
A helpful point to realize is that binding is not magic, it is simply a synchronizing of 2 java bean properties. Bean A is your XulComponent subclass and Bean B is your model. If you want to know what component properties you can bind simply lookup your xul component, say XulTextbox, and take a look at its bean properties. You can configure a binding to any property of your xul component object.
Event Handling and non-Component-state Events
In the diagram you will see that the XulDom fires "events" to the FooController. As we mentioned before, these events are not state changes of a XulComponent, rather these are launching and routing operations such as displaying a dialog. Events are declared in xul source file as tag attributes, e.g.:
When PXF parses this tag, it will register an onclick property on the button component such that when the button is clicked PXF will try to find a registered event handler by the name of "fooController" and call it's displaySearchDialog method. You register an event handler on a XulDomContainer object like so (you will likely do this during your application's initialization):
Foo Example Source
- represented as a Java Bean (with property change support)
- "models" view state as bean properties
- contains view logic such as enablement and visibility
- applies form validation
- contains *no* references to Xul of any kind
- represented in the XUL dom (via XUL source file)
- contains syntax for creation of UI components
- layout of UI components
- represented as a Java class that implements XulEventHandler
- binds UI state to the model
- performs UI evnt handling (not related to component state) such as launching of dialogs (XulDialog and XulWindow)
- should *never* reference XulComponent or subclasses