OOP2

JSugar

======

JSugar is a tiny framework, in an attempt to hide away the tons of

useless cruft that you get from working with Java's Swing.

Features

--------

Purely speaking, JSugar does not add anything new compared to when you're using

Swing. It does however, offer some considerable advantages over using Swing

directly:

* Easy creation of windows, that offer a series of convenient methods like

  createButton(), allowing for easy creation of small GUI programs.

* Built-in support for action triggering; Just say which method should be

  triggered where, and you're done.

* Easy learning curve, compared to manually handling Swing. Create a new Window,

  slap some components on it, add the methods it needs to call on trigger, and

  done.

* Relies mainly on primitive types, like integer arrays, and classes that are

  available in every recent OpenJDK version, like Strings.

* Completely [free/libre software](https://www.gnu.org/philosophy/free-sw.html).

* Very lightweight. It's just a bunch of source files that you can directly link

  to. Putting it in a seperate jar will cause more harm than good.

* Only RuntimeExceptions will be thrown, avoiding *exception infection* that

  you'll get from using self-defined exceptions in Java.

* Documentation available through JavaDoc. I do my very best to provide clear

  documentation, so you know how to use this without having to figure it out

  yourself.

* Components you add are returned to the caller, so if you do need some more

  advanced stuff, you can add it yourself.

Limitations

-----------

The convenience causes some limitations, but they're fairly minor, and if you're

using JSugar, it's very unlikely you'd be bothered by them anyway, but here they

are:

* You can't add your own panels to the window, but you'll most likely just want

  to add some components to the window itself.

* The panels default to double buffering (which you should do anyway) and the

  flow layout.

* The window is automatically updated whenever a new component is added. When

  using Swing 'natively', you could postpone updating, but why did you add a

  component then in the first place?

* *Trigger methods* can only have 1 parameter, or none at all. That 1 parameter

  must be of type java.awt.event.ActionEvent. This should be enough for >80% of

  use cases, and if you really need more flexibility, you can add your own

  action handlers manually.

* Pressing the X in the title bar of the window closes it. >95% of use cases do

  this anyway.

* Some silly stuff like adding icons to buttons, checkboxes, ... is not

  possible. You'll have to do that yourself. Yet for most use cases,you might

  just do the sane thing and add text.

* Certain components don't offer the ability to attach a trigger action to them.

  We're talking about components like labels. But then again, these kind of

  components shouldn't get much triggers anyway.

* Some components have deliberately been left out, because they don't offer many

  information/interaction for the user. An example for this, is the

  JProgressBar. Although in some rare cases it's a very useful thing, but it's

  mainly eye candy, and you may just show the data in a JLabel anyway.

  However, if I feel like doing so, and the rest of the library is stable, I may

  add such components.