Finally I get the code to you

[vital at videotron.ca]

I would suggest another way of managing the handle.
Instead of using the index in the list, we could use the pointer of the
instance of the wrapper class (TWidgetObject) which is any way the instance
that we will need to find by is index. We then get direct access to the
instance without the need to retrieve it from the list.  This is not a great
deal but that would prevent the mess when some object will be deleted from
the list resulting in a shifted index. So the index will be out of sync.

Those that make sence.


By the way Cliff, Do you relay on my to finish this work now or you have to
complete it somehow before I get involve?


Vital Tremblay
vital at videotron.ca


At 21:37 00-05-01 -0700, you wrote:
>From the standpoint of the LCL here is what really occurs.
>
>When a program is started the application object gets created and and the
>initialize routing is called on the interface object. Here is where we tell
>the engine to create a engine instance. From then on the lcl will pass a
>message to the IntSendMessage routine telling the widget engine to do
>various things depending on what was passed. For instance the routine may
>get a message to create a form in that case lcl_win32_create_widget gets
>called and it internally creates a form. It will pass back a integer value
>"we'll call it the hwnd" which is the index of the component in the list.
>Inside of the interface object we set the LCL TComponent handle with that
>returned value because that is what we are going to use to access the
>instance. Now in the library you will need to do something like
>lcl_win32_reparent_widget(hwndparent, hwndchild: integer) and that will
>inturn set the parent of the child to the parent. Then you add something
>like lcl_win32_set_bounds(hwndwidget: integer;x,y,top,left: integer)  so
>internal you just grab that widget from the list and set the properties.
>Then you need to add a event hook I think I coded the stub into it but did
>not finish it. Something like lcl_win32_hook_mouse_move(hwndwidget: integer;
>fproc: pointer) You then assign a handler internal which will call this fpc
>method pointer. I know this sounds like a lot of stuff but it is pretty
>simple to implement.
>
>Cliff