As an aside on the topic of JavaFX I've recently been working with
JavaFX sequences and creating sequences of functions so I can callback
parts of my UI when changes occur in the data model:
//My list of closures
var callbacksOnAccountListChange:function(:String[])[];
//adding a closure to the list
public function addAccountListChangeListener
(callbackFunction:function(:String[]))
{
insert callbackFunction into callbacksOnAccountListChange;
}
// And executing the closures when the data (A list of user accounts)
changes:
public var accounts:TwitterAccountConfiguration[] on replace {
for (callbackFunction in callbacksOnAccountListChange)
{ callbackFunction( for (account in accounts)
account.username) }
}
Basically this is updating the list of accounts in a listView when the
list accounts.
I probably could have just used binding, but I figured I'd play around
with this way of doing things....
On Sep 17, 6:54 am, Joshua Marinacci <[email protected]> wrote:
> I haven't listened to the podcast yet, so I'm not sure what they were
> referring to. I'm just demonstrating the JavaFX Script syntax.
>
> What makes the syntax great (and an improvement over the Swing way) is
> a couple of things:
>
> closures, slightly cleaner than inner classes in Java
> button.onMousePressed = myFunction
>
> object literal syntax: much cleaner and more compact than anonymous
> inner classes, and fits the way most people actually think about guis
> (as an in order tree)
>
> the swing way is
>
> button = new JButton();
> button.addActionListener( new ActionListener() {
> public void actionPerformed(ActionEvent e) {
> //do stuff
> }
>
> });
>
> the javafx way can do more with less code
> VBox { content: [
> Button { action: action1 }
> Button { action: function() {
> // do stuff
> } }
> Button { action: action 3 }
> ]
>
> }
>
> We considered the += for event handlers but decided against it because
> it made the language more confusing, had some weird corner cases, and
> for most uses there were simpler ways of doing what you want.
>
> We say JavaFX encourages component driven development because the
> language and the apis were designed for it. It encourages composition
> over inheritance, and encourages mixes vs deep inheritance
> hierarchies. With binding we have properties (we call them attributes)
> and the ability to make something private, read only, write only on
> init, and fully writeable. This means you can cleanly expose just the
> parts of your component you want and restrict access to the rest.
>
> After coding Swing for nearly 12 years it's quite a nice change. A
> very clean way to code.
>
> - Josh
>
> On Sep 16, 2009, at 1:06 PM, Reinier Zwitserloot wrote:
>
>
>
>
>
> > If that's all, I'm thoroughly confused.
>
> > button.onclick = mymethod
>
> > is some sort of revelation compared to:
>
> > button.addClickListener(#mymethod);
>
> > (yes, closures are nice things, and if that's what this is all about,
> > that's fine, but the word wasn't mentioned once in the entire podcast,
> > hence my confusion).
>
> > Using += as a list append operator is not universally considered a
> > good idea, and for good reason. Operators are great when the operation
> > is usually done as part of a massive chain - 5 + 2 * 10 is much more
> > readable than 5.add(2.multiply(10)). add doesn't qualify.
>
> > So, 'components' just means: "Closures + modules"? In that case, I'm
> > all for it.
>
> > On Sep 16, 5:48 pm, phil swenson <[email protected]> wrote:
> >> Haven't done delphi in 10 years, but it was something like this
> >> (delphi people, i know this isn't correct, but it conveys the
> >> concept):
>
> >> button.onclick = mymethod
>
> >> I believe that in later versions they did something like:
>
> >> button.onclick += mymethod
>
> >> that way you could have multiple listeners.
>
> >> I remember when I switched from delphi to java I was surprised at how
> >> many features Delphi had that Java didn't. 10 years later and that
> >> is
> >> still the case (properties and events for example).
>
> >> On Sep 16, 5:37 am, Reinier Zwitserloot <[email protected]> wrote:
>
> >>> So, after listening to #278 (What do you want from JavaFX?), I'm
> >>> curious: How exactly do you 'just register' a listener and forget
> >>> about it? In what way is this different from the java experience. If
> >>> anyone could put some examples of either C# or delphi source here,
> >>> that'd be great.
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups "The
Java Posse" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to
[email protected]
For more options, visit this group at
http://groups.google.com/group/javaposse?hl=en
-~----------~----~----~----~------~----~------~--~---
