World: r3wp

table [2 2  5 5
	button "X"  button "O"
	button "O"  button "X"
]

Kaj, I love what you are doing. Just curious if you looked at QT, 
it seems to be avail on more platforms - phone wise- which is a major 
plus...
Is it more difficult to impliment?

Thanks. As it happens, I looked into binding Qt last week

I never liked either GTK or Qt. The reason I'm binding one anyway 
is that we want native platform user interfaces for Red. Linux and 
BSD don't have a native interface, but if you have to appoint one, 
you have to appoint two: GTK and Qt

The reason I chose GTK is that it's written in C, which makes it 
natural to bind to Red/System. Almost all other open source GUI toolkits, 
including Qt, are written in C++, which is much more problematic 
to bind

Basically, to bind a C++ library, you have to write two bindings: 
one from C++ to C, and then one from C to your target language. This 
is because only C++ knows what C++ objects mean, and C++ claims that 
its object classes are a program's interface

So you can write a binding from Red/System to a C library purely 
in Red/System, while a C++ binding would also require writing an 
extra bridge in C++. Even after this initial hurdle, apart from the 
maintenance, a remaining problem would be that the C++ bridge needs 
a traditional development environment, so the wonderful abitlity 
of Red to crosscompile to anything would be negated for a large part. 
Basically the same problem that REBOL 3 extensions have

Intrepid readers will note that one of the libraries I bind, 0MQ, 
is written in C++. However, the 0MQ designers wisely decided to define 
the interface in C, so that all languages can bind to it

For generic libraries, binding tools exist, such as SWIG and SIP. 
Unfortunately, they don't solve the problem but only assist a little, 
and the result is very bloated

Since a few years, Qt and KDE use a new tool: Smoke. It's more automated, 
so it looks like it can generate a C interface without writing C++ 
yourself. However, the cross-compilation problem still exists. Because 
the tool is so generic, the bindings it generates are also quite 
bloated and probably otherwise inefficient. In any case, it's just 
the first step for a Red binding, because I put abstraction layers 
over my bindings that are much more REBOL like

Another consideration for me is that GTK is more fragmented, but 
that also makes it more modular than Qt. From the viewpoint of Syllable, 
it makes it harder to integrate completely, but easier to integrate 
just some selected pieces, which is what I am after

While it's true that Qt is more portable than GTK, I'm not sure it's 
significant. The only phone platform I know that uses it is Meego, 
but Nokia has sidetracked that. Samsung's own phone platform in Bada, 
for example, uses GTK. There's also recent DirectFB support in GTK, 
while the Qt port to DirectFB is obsolete

So I chose GTK to support as the "native" GUI for Linux and BSD. 
It can also run on several other platforms until we have native support 
for those

I'm not planning to fragment the effort by doing a Qt binding as 
well, but I did evaluate it, and the decision could change if I would 
be funded for it

Interesting stuff...thanks

Thank you for the good explanations Kaj.

TL;DR: the creators of C++ and C++ compilers decided that the world 
was not complicated enough, so they worked hard to make it more complicated.

:-) Fortunately, you can build an entire economy on it, because every 
solution creates a new problem...

Added a logic! element to the dialect for GTK windows to support 
their ability to be non-resizable

Any chance of doing a youtube video on a demo?

That would be a nice opportunity for someone to contribute :-)

No offence, but I have so many bindings to do, that I have decided 
to focus on that, instead of things such as writing documentation

Right now, one of the parts of the videos of the last SylCon shows 
me demoing the Red/System GTK widgets as they were then, I think. 
It must be one of the last videos

I don't think Bas has published them yet:

http://www.youtube.com/playlist?list=PL904CC146DCD27762

Most of the Red demo is in part 9:

http://www.youtube.com/watch?v=LnYa5_-1n7E&list=PL904CC146DCD27762&index=3

It discusses 0MQ and shows SDL and GTK, but it's a primitive Hello 
World example when the GTK binding was only a week old, and callbacks 
in Red weren't fixed yet

Nice presentation! :)

BTW, do you plan to make a small documentation on the GTK+ binding 
API and/or a dedicated web page?

Thanks. I'm limiting the documentation to the examples for now. I 
have to choose between writing documentation or more bindings, and 
I need the bindings

Part 8 has a discussion of the PeterPaint SDL example on Syllable 
Desktop, but the video is very bad during the demo:

http://www.youtube.com/watch?v=LriNVROAseI&list=PL904CC146DCD27762&index=4

Implemented TEXT and AREA styles, based on the GTK text view widget

If someone following Red progress would have time to write a small 
doc on the GTK+ binding API, I think that would really help.

I can't implement things such as GTK sliders and progress bars, because 
they use floats

That's a pity, because Jaromil requested slider and file selector 
widgets from me. When he has those, he can start using Red for a 
GUI for his Tomb security tool

Implemented INFO style, as a non-editable GTK line entry widget

I understand the frustration...If it could be added in 2-3 days, 
I would add it now, but a complete support would require much more 
time. I will try next week to make a more accurate evaluation of 
all the additions and changes required in Red/System compiler for 
supporting float numbers.

Cool

Implemented SECRET style, for hiding entering passwords and such

Both single and double precision floats will be necessary to interface 
with other subsystems

And that can't be done by linking to a math library?

How would you communicate values?

Implemented activate action for FIELD and SECRET styles, so that 
they can respond to pressing the enter key

According to Twitter message, Doc got simple program compiling and 
running on Linux ARM. Nice and congrats :-)

URL ?

https://twitter.com/#!/red_lang/status/127738543027138560

Is there any significance to the code compiled?

It's the minimum program