So Gooey: Can You See The Button?

Note however, there will still be a kernel of REBOL that is not open source. This factor lets us keep the language 100% compatible between different computers and operating systems.

Sure, sure. Wake me when REBOL’s actually Open Source and I can run it on e.g. Linux/PPC (or natively on anything 64-bit, for that matter…).

That said, a Ruby GUI abstraction in the style of REBOL/View would be pretty cool.

tap tap tap Hmm, did this thing just eat my last comment?

Back in 2005 there was a RubyCentral project of that exact nature. See the second item by Andrey Melnik. (Vanished.)

Oh, what am I thinking! Here’s one for Hackety Hack:

Web.popup {
  buttons("Press me") { say("OK") }
}

Although some things are changing. Like how Web.popup is becoming Window.

Guh. XAML.

Actually, one of the things I’m working on is a little declarative GUI toolkit for Ruby. My current project allows scenario developers to generate custom GUIs, but the scenario developer’s code runs in a separate process from the UI. So they need to be able to declare UI elements and style them and provide them with behavior without letting them go straight to the (potentially insecure) GUI metal. The problem is that it’s more of a ‘user interaction/input’ system than a traditional GUI system—it’s more focused on presenting data and getting responses than on designing widgets.

Seems both Melnik’s 2005 projects are worth notion. Also seems, none of them had been ended. Somebody knows, what’ve happened with my compatriot?

Back to topic. I’m working on Ruby wrapper for this library (much more lightweight than Mozilla layouting), and it has it’s own Markaby-like builder (and it would have it’s own Camping-like desktop framework).

It would do something likewise:

App.run {
button(“Press me”).on_click{puts “You bet!”}
}


The Amiga was—err, still is, very nice indeed. And REBOL is really nice too. If only it were really free…

I think one key thing is to make the common case simple. The rule with buttons is that, with few exceptions, they have some text and some code that runs when you click the button. Auf Ruby that pretty much means:

button("Some text") { some_code }
There’s always option hashes for the stuff you need more seldom.

Hmm, looks like SuperRedCloth(?) isn’t quite up to snuff with closing <pre><code> yet.

Well, it seems the Ajax preview matches the real entry completely now. That’s good.

What’s the new recipe for code samples, though?

> I think one key thing is to make the common case simple.

If it was complain for my example (and “on_click” part of it), I can say–it’s Markaby thing. Thus, “just block” is reserved for DOM creation. Something like:

button{img :src=>"1.gif"; span “and title”}.on_click{puts “see?”}


(btw, “code” without “pre” works :)

I wasn’t picking on your example in particular (more stuff like the TCL example in the original post), although I’ll admit that Markaby is not my favorite thing for templating in general.

(“code” without “pre” means you don’t get indentation)

Anyway, enough complaining from me! It’s true that .on_click {} is the best approach when you’ve got multiple sorts of event handlers to deal with.

> although I’ll admit that Markaby is not my favorite thing for templating in general

Than, what’s your favourite? Just today the topic was discussed in Russian RoR list, where there was an opinions after erb, lilu, Haml, Markaby, and Zope’s TAL.

(yeah, I’ve noticed)

I’m somewhat partial to lilu actually, though I’m not really happy with any of them. The big thing is a lack of simple semantics. I’m actually trying to develop my own templating system at the moment.

it’s a completely off-topic yet, but can’t you share in short, what your templating system would look like? i’m very interested in simple semantics!

(_why, don’t ban me, pleeeease)

I’m a fan of Haml ;).

MenTaLguY, I’m also curious as to what you’ve got up your sleeve.

I’d love to see a nice, declarative GUI framework in Ruby. Preferably one that can have native WMs as a backend, while preserving snazzy Ruby syntax.

…and which sample takes the cake for finding the action to be executed when the button is pressed?

At the moment, what I’m playing with is essentially a substantially less magic version of Markaby. All that stuff with fragments? Gone. (There are alternatives.) The underlying abstraction also deals in byte streams, so it’s theoretically useful for generating more than just XML/HTML.

But I’ll post more about it when I feel I’ve got something genuinely useful. I’d like to find a more declarative approach to do atop this the templating-via-substitution thing that lilu does, among other things.

What about good old XHTML + JavaScript?

<input type=“button” onclick=“‘Hello World!’)” />

Unfortunately blog software seems completely incapable of allowing me to post such beautiful and elegant code. :)

… now it would be interesting to see a comparison for interactive 3d objects with video ..

I agree that XAML can be verbose, but to be fair it’s the only example that will run (except for maybe REBOL). You omit the necessary boilerplate code to get the javaFX or Tcl/tk code off the ground.

That said, I agree that xaml can be verbose. However, I’d argue that it’s xml syntax has strengths when it comes to creating design tools around it. I’m sure hand-coders will villify me, but the truth is that GUI design is best accomplished, well… with a GUI.