Menu
▾
▴
Home
Overview
The „wicket components“ project is a component library for the apache wicket web-framework. Referring to classic component libraries for desktop applications ( like Microsoft Foundation Classes, QT Library or wxWindows) the wicket components provide graphical user interface components for wicket web-applications.
Based upon this library it'll be easy to create complex user interfaces for data processing applications and it is a perfect start to migrate old desktop applications to modern web-applications. This will make a system administrator happy, because it is more complicated to update a desktop application on many client computer systems, rather than having a web-application on one server system, that can easily be updated.
But one disadvantage of web-applications is, that every application has its own look and feel and the user have to get used to that. This was not the case when every application had the look and feel of the operating system.
The wicket components have different styles that are base upon the look and feel of the operating systems. And based upon the users browser informations a fitting style will be automatically chosen.
So an application using the wicket components will look like a desktop application whatever operating system the user is currently using.
Separation of design, graphical user interface components and application
Complex web-application are developed by different people. But in many cases there's not an exact separation of tasks. Every developer has to have knowledge of java, markup languages and sometimes even designing, because it is very complicated to separate the processes of „STRUTS“ like applications, when there are no design templates for every applications dialog.
Desktop application were always build upon a complex graphical library and a developer was able to create an application dialog without a design template. The look and feel was provided by the library and the application developer didn't have to think about button designs or the functionality of a list view. The wicket components library is such a graphical basement for web-applications.
The wicket components library uses styles that can be edited by a designer. All changes are automatically used by the components. Another developer can build company specific graphical components that can be used in different applications.
And the application developer can use this base to create a complex java web-application without using HTML, Javascript or Photoshop.
Intelligent components
The base of the wicket components are „intelligent“ components. These components are „intelligent“, because their current visualisation doesn't have to be set from outside, they figure out their current style by their self by using a central application logic. This will also separate the application's logic code from the interface code.
Components are devided into simple and complex components.
Simple components
Simple components (like text fields, buttons etc.) have four base states:
enabled
disabled
labeled
invisible
Each component will figure out the current state by asking a central intelligence container.
As an example, just think about a simple text value. Depending on user rights the value can be edited or not. Depending on a checkbox state the value is currently editable or not.
Is the value editable it should be visualized as a text field. Is it currently not editable but the user can change that, it should be visualized as a deactivated text field. Is there no way for the user to edit the value, it should be visualized as a label.
The “intelligent” text field can display itself in all that states. The developer can add one component and it will change its visualization in the best way.
Complex components
Complex components are base upon many simple components. They have their own states on the one hand and they provide the current states for all their sub components.
Examples are the list- and tree components. A list component is a component on its own build upon buttons, text fields and labels.
Automatic scaling
Browser windows can be sized any time. A dialog should use this feature to give as much information to the user, as possible. The wicket components library can size components automatically. A complex javascript routine calculates the size of every component in realtime based upon a grid model that is very easy to understand.
Validation
All components provide a build in visualization for wicket validation messages. So there's no need to even think about how to visualize error, warning or information messages. Complex components and panel are able to sum up all messages of their sub components. This looks good on the one hand but it also sets a common look and feel for validation messages.
Library state
The library is currently „feature complete“. The base functionality is implemented, but not well tested. Every help to bring this idea forward is highly appreciated.
The wiki uses Markdown syntax.
