               OVERWRITE - handle overwrite mode in IO-controls
               ================================================

Hi, out there in the wilderness. Recently I was asked, how to implement 
OVERWRITE-aware controls.
So I tried to answer that question, and while thinking over and over that 
problem I came to the conclusion, that it would be VERY NICE to have a little
smart unit (NOT component!) handling all sorts of IO-controls to be aware of
the insert/overwrite state on the keyboard.

This is, what UZIOHAND.DCU does. It enables ALL (at least I hope I didn't
forget one/some) sorts of controls to be aware of the isert/overwrite toggle
status.

UZIOHAND is FREEWARE, therefore using is at YOUR OWN RISK !!

Source is available on request, but we will request some sort of written
agreement, that you will _not_ use the source or the knowlegdement you got
form the source to implement a similar unit or functionality for commercial
use.


                       WHAT's NEW in Version 1.1:
                       ==========================

hrumpfffhh, I packed the wrong code first time (so sorry), so V.1.0 didn't
support TComboBoxes and TMemos (raising an "invalid caset" exception), which
1.1 now will.
In addition, I changed layout of the demo-form and added one more function
to be glabbly available:

     KBDIsInsert    will return TRUE/FALSE according to
                    current insert/overwrite state of KBD

KBDIsInsert is used to reflect a INS/OVR panel on the bottom of the demo
form.



                       OVERVIEW and USAGE of OVRWRITE.ZIP
                       ==================================

SAMPLE.DPR:    a little sample of, how to use OVRWRITE handling in UZIOHAND.
               Sample.DPR requires a valid alias DBDEMOS and CUSTOMERS.DB
               available in that alias (as it is after standard-installation
               of DELPHI).

UZIOHAND.DCU   should be installed into a directory included in your search-
               path (standard would be the LIB-subdirectory of DELPHI);

   NOTE:       UZIOHAND is _NOT_ a component but a simple pure module, so it
               is _NOT_ to be added into your COMPLIB.DCL.

   USAGE:      once UZIOHAND.DCU-file into a subdirectory inlcuded in your
               search-paths, UZIOHAND is very simple to use:

      USES:    each FORM, which makes use of the IOHandleOverwriting function
               MUST contain UZIOHAND in it's uses clause

      CONTROL: if you only want a SINGLE CONTROL, to have IOHandleOverwriting
               active, just code in the following line into the OnKeyDown-Event
               of that control:

                  IOHandleOverwriting(<TheControl>, Key);

               where <Key> is the Key-parameter of the OnKeyDown routine.

      GLOBAL:  if you prefer to have ALL CONTROLS of a form handled by
               IOHandleOverwriting, just implement folling routine (the samples
               call this procedure <GobalKeyDownHandler>) as follows:


               	type
	                 TFormXX = class(TForm);
	                 {... your and DELPHI'S stuff goes here }
  	                 procedure GlobalKeyDownHandler(Sender: TObject; var Key: Word;
                                                   Shift: TShiftState);
	                 {... your and DELPHI'S stuff goes here }
               	end;


               then code out the <GlobalKeyDownEvent> as follows:
            

	               procedure TFormXX.GlobalKeyDownHandler(Sender: TObject; var Key: Word;
	                                                      Shift: TShiftState);
               	begin
	                  IOHandleOverwriting(ActiveControl, Key);
	               end;


	            Every control now can _direclty_ make use of <GlobalKeyDown-
	            Handler>, and it will show up in your object inspector's
	            window, when you open the conbolist beside the OnKeyDown event.

	            Now EACH control, which should be "overwrite-mode aware" either
	            would call <GlobalKeyDownHandler> directly or make a call to
	            this function from within it's own OnKeyDown routine.

	            Since IOHandleOverwriting will NOT change anything other than 
	            the selection in the active control, it's up to you, where 
	            exactly to post the call to IOHandleOverwriting in your
	            OnKeyDown-event routine.

may the gods of the olymp smile on you ...

bye UZ/2       CIS: 100271,313
