To do...

Take a deep breath and look the BIG list below:

  • Urgent: Write unit tests;
  • Urgent: Source code refactoring;
  • Urgent: Documentation improvement. It includes the JavaDoc;
  • Urgent: Improve log messages and do other things to make easier to find errors;
  • Support classes to internationalize and localize applications;
  • Support the SwingX component suite, without force the developer to add the SwingX jars when these components are not in use by the application;
  • Create object 'scopes' (eg: session scope). These scopes must define listeners to allow the developers to execute some code when an object is added/removed from the scope, when a scope is created, and so forth. The possible scopes are 'Application', 'Session', and 'Jobs';
  • Create @Save annotation that can be used to persist the View's state in a file (the file format must be defined yet). So, when the View is activated for the first time, the framework will try to restore its previous state;
  • Add validation capabilities. To make it easier, we must use a mature validation framework and integrate it with Surf. I guess the Hibernate Annotations, since this is an annotation-driven validation framework. Look for alternates;
  • Make the data synchronization as transparent as possible (no more updateView() and updateModel() calls!). When the user modifies the Model and/or the View, these modifications will be stored in some kind of cache (it can be used to provide some kind of 'undo' and 'redo' thing). The sync between the Model and the View must be triggered in well-defined points during the user interaction (when a Command is activated, for example). Also, we must create some kind of 'Sync strategies'... these strategies will determine WHEN to synchronize the View and the Model. Besides, these strategies must be easy to configure by the developer;
  • Create the @BindSelection annotation. This annotation can be used to provide a 'Selection binding' functionality, instead of the default 'Value binding' (that already works in the current version);
  • Modify the @Bind annotation to allow the user to bind any information of the widget adapter with the Model (background/foreground color, enable, visible, size etc). Or create a new annotation @BindProperty(String value). Example: @BindProperty("enabled"), @BindProperty("visible");
  • Add support to more IoC frameworks, like Nano Container;
  • Add integration to Quartz out of the box, to make easier to implement Commands as Quartz' Jobs. These Commands must be reached through a special scope: Jobs Scope (see the object scopes above);
  • Add support to more Swing components, like JTree, JPanel and JTabbedPane;
  • Make easier to work with components like JTable, JTree, JList and this sort of components;
  • Modify the @Widget annotation, adding the 'model' attribute. It's main function is to set the Widget's model (TableModel -> JTable, ListModel -> JList, and so forth);
  • Improve the @Formatter annotation, to make possible to use it in addiction to @Bind and @Widget annotations (already work with @Bind). One thing to be done: when the @Formatter annotation is used in a JFormattedTextField component, the framework will automatically add the formatter into the widget, avoiding to have both annotation and code to configure the widget. Obviously, this will be done in other components like JFormattedTextField;
  • Add support to more Swing events;
  • Add support to 'plugabble event types'. So, the user can define custom event types for custom components;
  • Create the @Background annotation, to determine whether a Command must be executed 'in background' or not. In the current version, all commands execute in background. It is necessary to avoid the SwingWorker whenever it doesn't fit and, in turn, optimize the framework performance a little;
  • Create the annotation @Converter to allow the developers to configure a converter manually. If this annotation cannot be found in a given component, Surf framework will try to figure out what converter must be used;
  • Improve the listener methods, implementing a Tapestry-like listener support:
      // This already works
      public void doSomething(Map test) {
        Integer i = test.get("number");
        String s = test.get("string");
    
        // ...
      }
    
      // This should work (in future releases)
      public void doSomething(Integer number, String string) {
    
        //...
      }
  • Create the @Synchronize annotation, which will be used to install listeners to two or more widgets in order to synchronize state among them:
    public class MyFrame extends JFrame {
    
       private JToggleButton a;
       private JCheckBoxMenuItem b;
       private JCheckBox c;
    
       public JToggleButton getA() {
         return a;
       }
    
       @Synchronize(widget="a", properties={"value", "enabled"})
       public JCheckBoxMenuItem getB() {
         return b;
       }
    
       @Synchronize(widget="b",
       properties="value")
       public JCheckBox getC() {
         return c;
       }
    
       // ...
    }

    In this code, the @Synchronize annotation get two parameters: 'widget' and 'properties'. The 'widget' parameter is used to select the other widget and the 'properties' parameter gets an array of "adapter property names" that should be synchronized. It must work either when those properties are changed on widget A or B, doesn't matter.

    This is a very BIG list, and it grows every day... As you can see, there's a lot of work to be done.