Re: Properties

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On Thu, 2 Dec 2010 21:53:13 -0800 (PST), Shark8 wrote:

> On Dec 1, 8:59�am, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
> wrote:
>>The main problem is the interface of such a library. There are
>>multiple parallel hierarchies need to be handled: a hierarchy
>>of widget types, a hierarchy of widget containers, a hierarchy
>>of event handlers (events are filtered, propagated, swallowed,
>>re-generated).
>>
> Why not have an INTERFACE hierarchy in addition to the GUI_Object
> hierarchy?

Hmm, isn't it same? To me interface = abstract type.

> Additionally, it could help with keeping the GUI_Object hierarchy
> smaller as there are many GUI items which are themselves composed of
> other GUI items. A scroll-bar, for example, has two distinct
> interfaces: the Button[s] and the slider-bar.

Ada should have had proper multiple inheritance 15 years ago.
 
> By "widget containers" do you mean something like
> Ada.Containers.Vectors initialized to the classwide-type of the root
> of the GUI_Object hierarchy, OR do you mean some component which
> contains other components (like a panel, perhaps)? {I'm inclined to
> believe you meant the latter.}

Yes, the latter, but the former is also required, you frequently need lists
of widgets (of referential semantics). This raises another question. Ada
does not support abstract access types. You want a reference to the widget
be a fat pointer transparent to all widget operations with automatic
collection of widget objects. This almost works in Ada, but it is extremely
boring to do. The scheme is as follows:

1. You declare a separate interface type for each widget
2. You implement the interface by the widget object
3. You implement the interface by the handle to the widget (a controlled
type).

It is nightmare to do, I know it. I did so in one project (not for the
widgets), and I don't want this adventure anymore.

The bottom line, interfaces must be removed from Ada. Instead of that an
interface must be made inheritable from any concrete type. This is the same
idea as with abstract record, array etc types. Any type has interface,
which is inheritable without the implementation:

   type Widget_Handle is private Widget; -- Like the widget, but isn't
private
   type Widget_Handle is new Ada.Limited_Controlled with record
       Ptr : access Widget;
   end record;

For access types there must be delegation support, which should eliminate
need in wrappers. There are other issues as well, like that "access Widget"
is purposely not "access Widget'Class."

> Finally, I've been quite impressed with Delphi's Visual Component
> Library (VCL).

That's interesting, because we are using the VCL quite heavily. One of our
customers explicitly ordered that. Now, my impression is opposite to yours:
it is safer, *quicker*, cleaner, an far more maintainable to develop GUI in
*raw* Windows API than in VCL. As a bonus, you can get rid of that awful
Borland C++, use VC++ or gcc instead.

> Microsoft's MFC and Java's JFC seem to have been
> 'inspired' [or copied] from the VCL, but neither presents itself as
> uniform & usable/mature [if you will] as the VCL.

We dropped MFC long ago and never returned to it. We didn't use JFC, so I
cannot say anything about it.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de