OOP

• Declare a class inherited from the class you want to access:
  type
  TExposedWinControl = class (TWinControl);
• Type-cast the object:
  if Sender is TWinControl then
  TExposedWinControl(Sender).Caption := 'New Caption';

Using TList
The TList class is used to hold (pointers to) objects inherited from TObject. The number of those objects can be defined at runtime. In our example, we declare in step 1 a class for the items you want to add to the list. Our items consist of a string and an integer property:

{ type for items that will be added to a TList instance }
type
  TMyListItem = class (TObject)
    s: string;
    i: integer;
  end;

procedure TForm1.Button1Click(Sender: TObject);
var List: TList;
    j: integer;
begin
  { create the List }
  List := TList.Create;
  for j := 1 to SpinEdit1.Value do begin
    { add new items to the list without using an item instance, see note 1 below }
    List.Add (TMyListItem.Create);
    with TMyListItem (List.Items [j - 1]) do begin
      { use type-casting to set values for previously added item
        (normally, you should use methods for setting values) }
      s := 's' + IntToStr (j);
      i := j;
    end;
  end;
  { fill listbox with items }
  ListBox1.Items.Clear;
  for j := 0 to List.Count - 1 do
    ListBox1.Items.Add (TMyListItem (List.Items [j]).s + ', i = ' +
      IntToStr (TMyListItem (List.Items [j]).i));
  { free each item, see note 2 below }
  for j := 0 to List.Count - 1 do
    { use type-casting to free each item }
    TMyListItem (List.Items [j]).Free;
  { free the list }
  List.Free;
end;

1. No variables are declared to hold TMyListItem instances, because the number of items is known only at runtime.
2. Because TList is not aware of the items' class type, the Free method of TList can't remove the objects from memory. We have to free each item properly using the appropriate type-casting before we free the list itself.

VCL

{***********************************************************************
 Listbox with horizontal scrollbar
 MaxWidth < 0 : adapt automatically to largest item
 MaxWidth >= 0: use value of MaxWidth for width of scrollable area
 ***********************************************************************}
procedure HorScrollBar (ListBox: TListBox; MaxWidth: integer);
var i, w: integer;
begin
  if MaxWidth >= 0 then
    SendMessage(ListBox.Handle, LB_SETHORIZONTALEXTENT, MaxWidth, 0)
  else begin
    { get largest item }
    for i := 0 to ListBox.Items.Count - 1 do with ListBox do begin
      w := Canvas.TextWidth (Items [i]);
      if w > MaxWidth then
        MaxWidth := w;
     end;
    SendMessage(ListBox.Handle, LB_SETHORIZONTALEXTENT,
      MaxWidth + GetSystemMetrics (SM_CXFRAME), 0);
  end;
end;

Center a form on screen at runtime

procedure CenterForm (AForm: TForm);
var ALeft, ATop: integer;
begin
  ALeft := (Screen.Width - AForm.Width) div 2;
  ATop  := (Screen.Height - AForm.Height) div 2;
  { prevents form being twice repainted! }
  AForm.SetBounds (ALeft, ATop, AForm.Width, AForm.Height);
end;

Center a form over active form at runtime

procedure CenterFormOverActive (AForm: TForm);
var ALeft, ATop: integer;
begin
  ALeft := Screen.ActiveForm.Left +
   (Screen.ActiveForm.Width div 2) - (AForm.Width div 2);
  ATop := Screen.ActiveForm.Top +
   (Screen.ActiveForm.Height div 2) - (AForm.Height div 2);
  { prevent form from being outside screen }
  if ALeft < 0 then
    ALeft := Screen.ActiveForm.Left;
  if ATop < 0 then
    ATop := Screen.ActiveForm.Top;
  if (ALeft + AForm.Width > Screen.Width) or
    (ATop + AForm.Height > Screen.Height)
  then
    CenterForm (AForm)
  else
    { prevents form being twice repainted! }
    AForm.SetBounds (ALeft, ATop, AForm.Width, AForm.Height);
end;

Prevent labels from being cut
When switching between small fonts and large fonts, the AutoSize property of TLabel components does not work properly. As work-around, call the following procedure within the form's OnCreate event:

procedure LabelsAutoSizeCorrect (Form: TForm);
var i: integer;
    Component: TComponent;
begin
  for i := 0 to Form.ComponentCount - 1 do begin
    Component := Form.Components [i];
    if (Component is TLabel) and TLabel (Component).AutoSize then begin
      TLabel (Component).AutoSize := false;
      TLabel (Component).AutoSize := true;
    end;
  end;
end;

Determine if mouse cursor is over a component at runtime

{***********************************************************************
 is mouse cursor over Control?
 ***********************************************************************}
function IsMouseOver (Control: TControl): boolean;
var p: TPoint;
begin
  { get absolute coordinates }
  if GetCursorPos (p) then begin
    { convert to relative coordinates of component }
    p := Control.ScreenToClient (p);
    { coordinates within Control? }
    Result := (p.x >= 0) and (p.x <= Control.Width) and
      (p.y >= 0) and (p.y <= Control.Height);
  end
  else
    { this should never happen, but who knows... }
    Result := false;
end;

Win32 API

The following example lists the captions of all visible windows in a listbox:

{ list of all windows' handles }
var WindowList: TList;

{**********************************************************************
 callback function for EnumChildWindows called for each window
 **********************************************************************}
function GetWindow (Handle: HWND; LParam: longint): bool; stdcall;
begin
  Result := true;
  { add each handle to the list }
  WindowList.Add (Pointer(Handle));
end;

{**********************************************************************
 look for all visible windows
 **********************************************************************}
procedure TForm1.Button1Click(Sender: TObject);
var i: integer;
    Hnd: HWND;
    Buffer: array [0..255] of char;

begin

  try
    { initialize list }
    WindowList := TList.Create;
    { get all windows }
    EnumWindows (@GetWindow, 0);

    ListBox1.Items.Clear;

    for i := 0 to WindowList.Count - 1 do begin
      { handle of current list item }
      Hnd := HWND (WindowList [i]);
      if IsWindowVisible (Hnd) then begin
        GetWindowText (Hnd, Buffer, SizeOf (Buffer) - 1);
        if Buffer [0] <> #0 then
          { caption is not empty }
          ListBox1.Items.Add (StrPas (Buffer));
      end;
    end; { for i }

  finally
    WindowList.Free;
  end;

end;

Disabling screen saver temporarily
If you want to turn off the screen saver while your program is running, you don't have to disable the Windows screen saver at all. Just define the following method to handle the appropriate Windows message:

procedure TForm1.AppMessage (var Msg: TMsg; var Handled: boolean);
begin
  if (Msg.Message = WM_SYSCOMMAND) and (Msg.wParam = SC_SCREENSAVE) then
    Handled := true;
end;

Application.OnMessage := AppMessage;

Closing another application
To close e.g. Notepad, you simply send the message WM_CLOSE to the application's main window:

procedure TForm1.Button1Click(Sender: TObject);
var Hnd: THandle;
begin
  Hnd := FindWindow (PChar ('Notepad'), nil);
  if Hnd > 0 then
    SendMessage (Hnd, WM_CLOSE, 0, 0);
end;

Database

The online help says: Traditionally SQL cursors are unidirectional. They can travel only forward through a dataset. The BDE, however, permits bidirectional travel by caching records. If an application does not need bidirectional access to records in a result set, set UniDirectional to True. When UniDirectional is True, an application requires less memory and performance is improved.