Matisse or Jigloo ?

Question

We have a dilema; developing desktop application using matisse or jigloo..

Matisse has this XML form files which we are affraid of maintaining later, we don't even know should MyEclipse further support Matisse, even Netbeans - do you think they will give up os support of Matisse?

Moreless Jigloo and Matisse have similar behaviour, although Jigloo obeys more designers wish, Matisse have this strange alignment behaviour from time to time.

Jigloo generates Java code which can be edited and which in turn can cause visual editor not being able to draw form. Thats propbably the reason why matisse wants to have definition of elements in more stable XML form from which it generates java code.

Matisse would not help much if there is an error in instantiating GUI element, so puttin custom elements can be also nightmare.

When typing code in jigloo, visual editor likes to erase picture so you have to wait for picture to show up after editing code. In Matisse you can have errors in class and still editing GUI.

Please help us by voting, what do you prefer more and why.

Answer 1

I prefer Netbeans Matise. Even if it is impossible to edit generated code, it's much more easier to design complex screens with Mattise(because of FreeForm layout).

Answer 2

I wouldn't go with either. The best thing I've found so far is Instantiations Swing Designer. It is not free, but not expensive either. It supports all major Swing layouts and DOES NOT create any additional artifacts except pure Java code.

Here is the link, if your are interested.

Answer 3

I haven't tried Jigloo, but I would throw a fourth one in the mix.

JFormDesigner is the best Swing UI designer that I have ever used. Like Matisse, it does create XML form files, but that is the only negative about this tool.

It supports all standard layout managers, plus some popular ones (such as JGoodies FormLayout). It has plugins for IntelliJ and eclipse and can also run as a standalone tool.

Here is the link

hth

Koen

Answer 4

I would prefer Matisse since Netbeans is backed by Sun Microsystems and the possibility of the project being scrapped in the near futures seems blissfully low.

Also, I do not know the size of your project but I have developed some small ones and I personally use matisse to see how the layout would look and then go ahead and code everything using the Miglayout library. It increases the amount of coding a lot but gives good control and flexibility. And there is a possibility this library might be included in Java 7, consequently embedded into Matisse.

Answer 5

I have personally had a handful of occasions where the XML file backing a Matisse form somehow became out of sync with the code and had to resort to a backup to get it working again. This was enough to scare me away. I have no experience with Jigloo, though.

My current projects use TableLayout, extensively. It is easy to understand and (of all the layout managers I've tried) maintain. I have not found any other solution in GUI design for Java that I feel more comfortable with than coding the GUIs by hand. Moving forward, it seems like the best "future-proof" way of coding my GUIs.

I agree with Chintan on using Matisse or similar to mock up your design and then convert the layout to another layout (like TableLayout). Personally, I like using pencil and paper to do most of it. Not exactly high-tech, but it gets the job done.

Answer 6

Please don't use either! As with this answer, it's my strong opinion (after writing Swing GUIs for 10 years), that using GUI builders is, in all but the most edge-cases, a bad idea. HAND CODE YOUR GUI!

• Whether you choose Matisse or Igloo, it is not a standard, will fall out of favour and a better tool will come along. At that point, you will have legacy code that is nigh on impossible to maintain. This has already happened severeal times in the history of Java GUI builders

• You should avoid forcing your developers to use one IDE and it is a huge overhead to expect devs to switch to a particular IDE when looking at the GUI code. They'll be frustrated as they can't remember key bindings, project setup is out-of-date, they havbe the wrong version installed etc. People will make quick-fixes without the builder. At this point your code is unmaintainable in both your IDE of choice, and in the GUI builder istelf! The whole thing is a mess.

• Designing a GUI is not, in my experience, a particularly onerous task and probably accounts for no more than 5-10% of the total development time of an application. Even if initially using Matisse or Igloo provides you with a 50% time advantage over hand-coding the GUI, this is insignifcant in the grand scheme of things. It is certainly not worth the hidden costs and impending maintenance disasters that lie ahead

• GridBagLayout is not hard. It just isn't! It's really simple, in fact. It will take you a few minutes to learn and after that you'll never look back. Your GUI's will look like how you want them to look and your code will be more maintainable as a result. Use GridbagLayout!

I have spent a good deal of time warning people about this before and been proven correct.

Answer 7

What you can expect when you mess a file generated by a tool? Mess, isn't it? This is a very very important always forgotten by developers.

Take Matisse as an example. It generates a XML file for you and a .java file for you. Why on Earth developers start changing these classes? Later they complain that everything is messed and they point out to Matisse as the guilt of it, because Matisse doesn't do A or doesn't do B. The only thing Matisse is guilty is not being able to fix the mess promoted by developers. This is problem in the domain of Artificial Inteligence and I personally do not expect any solution soon.

There's a more or less simple solution for it: OOP.

I explain: one of the most important concepts of OOP is 'responsibility', which means that a certain class has a limited and well defined responsibility in a broader and more complex problem domain. So, Matisse generated the UI for you, which basically consists on UI elements, event handlers, etc.

Then you say: well... I need to add some logic to it otherwise the UI is innoperative. True. This is another responsibility, which cannot *never* be implemented in the same class generated by Matisse. Because either people is lazy or do not understand what 'responsibility' means in OOP, people implement whateber they need, add lots of variables and promote all sort of madness in a class which is definitely not responsible for business logic.

By a very simple thing like inheritance you can separate business logic in a extended class. The base class is the one produced by Matisse. The extended one is your class implemented by hand which contain implementation of event handlers, initialization of UI elements, etc.

Many developers are tempted to edit by hand the .java file produced by Matisse. The golden rule is: never, never edit the .java file by hand. Matisse provides you means of defining whatever you need and call whatever you need. Never editing resources (both .xml and .java) produced by Matisse, you guarantee that it (Matisse) will be able to load it again in case you need to change the GUI in future. Probably you will find yourself tempted to edit the .java or even the .xml file directly. Please resist this temptation and educate yourself; you will thank yourself in future.

So... you can use whatever tool you wish or whatever provides the sexiest UI elements. All tools will fail if you fail to separate UI from business logic. All tools will succeed if you succeed in your main task as programmer which is: produce decent code.