Re: Custom model in gtkada?

[Stephen Leake <Stephe.Leake@nasa.gov>]

"Jeffrey R. Carter" <spam.not.jrcarter@acm.not.spam.org> writes:

> Stephen Leake wrote:
>> I think Gtk is the best model, although the C underpinnings make
>> things difficult sometimes. In particular, it is difficult to detect
>> some errors at compile time, that the fully Ada systems can detect. At
>> root, the C pointers are not strongly typed.
>
> I think neither callbacks nor dispatching are good models. Callbacks
> are a way to get around C's lack of concurrency, since GUIs are
> inherently concurrent. 

I disagree. I only click on one thing at a time.

I suppose lots of displays can be updated with new data
"simultaneously". But underneath, there is only one display device, so
it is not concurrent.

> Let the window manager control your code so you only have 1 thread
> of control. The result violates locality,

I'm not sure what you mean by "locality" here.

> tends to result in lots of state variables global to the callbacks,

Not in a well designed GUI framework; the window object is a parameter
to the callback; no globals.

> is unintuitive, 

Since when was anything in a computer "intuitive"? At root,
"intuition" means "innate skill, evovled in humans". Computers haven't
been around long enough for humans to co-evolve with them. 

You simply mean "unfamiliar". That is a function of time spent learning.

> and is difficult to understand.

Well, lots of people disagree.

> Dispatching is simply an attempt to model callbacks with something
> other than pointers. It has the same problems as callbacks. You can do
> something similar with generics, but it's still no improvement.

Yes, they all have similar features.

> If you were designing a windowing system from scratch for a concurrent
> language such as Ada, you'd probably have a concurrent queue of events
> for each window, with a way to control what events are reported.
> That's far more straightforward and easy to understand. 

You are saying "each window should have its own thread of control".
That's way overkill.

It's like saying "each object should have its own thread of control",
in an object oriented design, without analyzing the true concurrency.

In GWindows and GtkAda, each _thread_ has its own event queue. You can
put windows in as many threads as you need. That gives you explicit
control over the concurrency behavior. If you like, you can have one
thread per window. That will be cumbersome for most applications. It
would be possible to design a GUI system that makes that style easier.

> JEWL is an example of this, though very basic.

I have not looked at JEWL.

-- 
-- Stephe