[lazarus]

[Michael A. Hess]

Shane Miller wrote:
> 
> I'm not real familiar with XLib so let me ask this.  Is the XLib the
> method that was used to write KDE and other GUI's?  Or is it simply
> another component library?

Xlib is the X11 system. It is what was used to write the GDK. Then GTK
was written using the GDK. Then Gnome is written using the GTK. The same
kind of process goes for KDE. Qt's primatives (I don't know their name)
are written to the Xlib. The Qt widgets are written to use the Qt
primiatives. KDE is written using the Qt widgets.

What we are talking about is writting our own GTK or Qt or what we would
call the FCL. Our FCL would talk to the Xlib directly. To skip some of
this headache we could use GDK instead of going all the way down to
Xlib.
 
> Can we then create a unit that has a CREATECOMPONENT and SENDMESSAGE
> and such that will interface with X11 library?

We would be able to do ANYTHING we wish. All of the messaging component
interaction would be written by us in the FCL. We would not be calling
or using any other libs other than the standard X11 libs which you have
to use even with GTK. The GDK might be easier to use as the low level
graphics primatives since it already takes care of many of the headaches
involved with accessing the X11 libs.

Think about it this way. If you look in the Delphi VCL most of the
direct Windows API calls are only found within the Draw methods of any
component. That is what we are talking about. All the rest of the
component would be written entirely with FPC in Pascal. Only the Draw
method would need to be written to address how the widget in question
looks and is...well drawn. We could call Xlib directly or as I said
overcome alot of Xlib headaches by using GDK. This is the "Graphics
Drawing Kit" that is the basis of GTK. The other advantage to using the
GDK is that it is already ported to Win32. If GTK has been ported to
Win32, well then GDK has been as well. We would write our components
once using GDK and any platform that has GTK/GDK would be able to use
the FPC and the FCL. We still get the portability of the graphics
primatives but aren't tied to the widget set of GTK.

The GDK has all your basics:

Draw Pixel
Draw Lines
Draw Rectangles
Draw Polygons

All of these than have the standard outlined or filled what color, etc.
etc.

I think this way of doing the FCL gives us the most flexibility within
FPC. We will not be tied to a limited widget set established by some
other third party API.
-- 
==== Programming my first best destiny! ====

Michael A. Hess      Miracle Concepts, Inc.
mhess at miraclec.com   http://www.miraclec.com