Delphi - Overriding Properties of Windows Implemented Components

Window'ed components (controls partially implemented by the MS Windows operating system - edit controls, radio buttons, and the like) have two types of properties

Those implemented by your code
Those stored in your code, but implemented by MS Windows

I already have a page covering properties that you have full control over.

Background

I was creating my own edit control based on the existing TEdit control. I wanted to change the background color to provide a visual indication of the component's ReadOnly state (property).

The following is the relevant code.

  TCustomEdit = class(TWinControl)
  private
    FReadOnly: Boolean;
    procedure SetReadOnly(Value: Boolean);
  protected
    property ReadOnly: Boolean read FReadOnly write SetReadOnly default False;
  end;

  TEdit = class(TCustomEdit)
  published
    property ReadOnly;
  end;

Normally, I would simply override the property setter (SetReadOnly) and add whatever new functionality I want ... not this time. Unfortunately, SetReadOnly is private.

First Attempts (Did not work)

In my opinion, all property setters should be protected and virtual. Unfortunately, that would make for larger and slower programs. On the other hand, if that was done, then the change (enhancement) I wanted to make would have been trivial.

The first thing I tried was to simply replace the existing property with a new definition.

    property ReadOnly: Boolean read FReadOnly write SetReadOnly default False;

procedure TMyCustomEdit.SetReadOnly(const Value: Boolean);
begin
  FReadOnly := Value;         // sets the local value

  if FReadOnly then color := FColorWhenReadOnly
               else color := FColorWhenReadWrite;
end;

Unfortunately, this code does not actually change the Read/Write property of the edit control. Since TEdit is actually a wrapper for a windows edit control, your code must tell windows what the properties are. In StdCtrls.pas, the associated code is

procedure TCustomEdit.SetReadOnly(Value: Boolean);
begin
  if FReadOnly <> Value then
  begin
    FReadOnly := Value;
    if HandleAllocated then
      SendMessage(Handle, EM_SETREADONLY, Ord(Value), 0);  // key line - actually changes the component behavior
  end;
end;

The key line is the SendMessage statement .. without that, the function of the component does not change.

Simple Solution

Unfortunately, there is no way to directly access the setter method (since it is private). Instead, I was able to access the parent property using the following.

    property ReadOnly: Boolean read FReadOnly write SetReadOnly default False;

procedure TMyCustomEdit.SetReadOnly(const Value: Boolean);
var
  tempEdit : TEdit;
begin
  tempEdit := self as TEdit;  // cast to parent class
  tempEdit.ReadOnly := Value; // this calls the parent class setter method

  FReadOnly := Value;         // sets the local value, displayed in Object Inspector

  if FReadOnly then color := FColorWhenReadOnly
               else color := FColorWhenReadWrite;
end;

My first attempt to accomplish this failed. I have no idea why (since I can not reproduce the problem). Perhaps it was my error, perhaps not. The help suggests that overriding a property completely hides the original definition. At any rate, it works now.

Window'ed Components

As I said, my first attempt at the simple solution (above) failed. Next I tried copying the code from TCustomEdit.SetReadOnly to my property .. and it also failed.

    property ReadOnly: Boolean read FReadOnly write SetReadOnly default False;

procedure TMyCustomEdit.SetReadOnly(Value: Boolean);
begin
  if FReadOnly <> Value then
  begin
    FReadOnly := Value;
    if HandleAllocated then
      SendMessage(Handle, EM_SETREADONLY, Ord(Value), 0);
  end;

  if FReadOnly then color := FColorWhenReadOnly
               else color := FColorWhenReadWrite;
end;

That's right, this code works perfectly in the original component and totally failed in my code. Well, not "totally". I placed a checkbox and an edit component on a form to test the code and everything worked ok. Then I started the program with the ReadOnly property set true .. and was able to edit its contents.

When I set a breakpoint and single stepped the code, it worked .. when I ran it without breakpoints, it failed. The reason was far from obvious.

(To debug this type of problem, you must enable Debug DUCs under Project / Options... / Compiler.)

I eventually determined that when properties are set as the program starts, none of the windows implemented objects exist. As a result, HandleAllocated returns false because FHandle equals zero. However, when setting breakpoints and single stepping the program, I let the mouse hover over the Handle variable .. and THIS caused the program to go ahead and create the edit window.

To be clear, when I

Set a breakpoint
Let the mouse hover over the Handle variable
And clicked run

the program ran as expected. But, if I simply ran the program without breakpoints, the program failed.

(I love intermittent software .. don't you?)

This is because window'ed components (such as TEdit) are not created until AFTER TForm.FormCreate is called. As a result, the code that actually creates the components must read the available properties and send them to windows. In the case of ReadOnly, I had overridden the original definition and used my own FReadOnly variable. When the component was finally created, the following code used the original variable.

  TCustomEdit = class(TWinControl)
  protected
    procedure CreateParams(var Params: TCreateParams); override;
  end;

procedure TCustomEdit.CreateParams(var Params: TCreateParams);
const
  Passwords: array[Boolean] of DWORD = (0, ES_PASSWORD);
  ReadOnlys: array[Boolean] of DWORD = (0, ES_READONLY);
  CharCases: array[TEditCharCase] of DWORD = (0, ES_UPPERCASE, ES_LOWERCASE);
  HideSelections: array[Boolean] of DWORD = (ES_NOHIDESEL, 0);
  OEMConverts: array[Boolean] of DWORD = (0, ES_OEMCONVERT);
begin
  inherited CreateParams(Params);
  CreateSubClass(Params, 'EDIT');
  with Params do
  begin
    Style := Style or (ES_AUTOHSCROLL or ES_AUTOVSCROLL) or
      BorderStyles[FBorderStyle] or Passwords[FPasswordChar <> #0] or
      ReadOnlys[FReadOnly] or CharCases[FCharCase] or
      HideSelections[FHideSelection] or OEMConverts[FOEMConvert];
    if NewStyleControls and Ctl3D and (FBorderStyle = bsSingle) then
    begin
      Style := Style and not WS_BORDER;
      ExStyle := ExStyle or WS_EX_CLIENTEDGE;
    end;
  end;
end;

My solution was to simply override CreateParams and set (or clear) the appropriate bit, as required.

procedure TMyCustomEdit.CreateParams(var Params: TCreateParams);
begin
  inherited CreateParams(Params);
  with Params do begin
    if FReadOnly
      then Style := Style or      ES_READONLY
      else Style := Style and not ES_READONLY;
  end;
end;

Other Techniques

I know that this works. (See above)

var
  tempEdit : TEdit;
begin
  tempEdit := self as TEdit;  // cast to parent class
  tempEdit.ReadOnly := Value; // this calls the parent class setter method

This failed. (Need to verify it again.)

  (TEdit)self.ReadOnly := Value; // this calls the parent class setter method

I need to test this. (Should work)

  (self as TEdit).ReadOnly := Value; // this calls the parent class setter method

From C:\Program Files\Borland\Delphi5\Source\Vcl\mask.pas

function TCustomMaskEdit.GetEditText: string;
begin
  Result := inherited Text;  // simply access the property - never thought of this
end;

procedure TCustomMaskEdit.SetText(const Value: string);
begin
  if not IsMasked then
    inherited Text := Value  // simply access the property - never thought of this
  else
 .....

Final Code

This is the final code I used. It is similar to what is above .. except .. it only replaces the setter method and not the private variable.

  TMyCustomEdit = class(TEdit)
  private
    FColorWhenReadOnly : TColor; // the *color* property is the currently displayed color
    FColorWhenReadWrite: TColor; // these allow the color to indicate the readonly state

    procedure SetReadOnly(const Value: Boolean);
  public
    constructor Create(AOwner: TComponent); override;
  published
    property ColorWhenReadOnly : TColor read FColorWhenReadOnly  write SetColorWhenReadOnly  default clBtnFace;
    property ColorWhenReadWrite: TColor read FColorWhenReadWrite write SetColorWhenReadWrite default clWindow;

    property ReadOnly write SetReadOnly;
  end;

constructor TMyCustomEdit.Create(AOwner: TComponent);
begin
  inherited;

  FColorWhenReadOnly  := clBtnFace;
  FColorWhenReadWrite := clWindow ;
end;

procedure TMyCustomEdit.SetReadOnly(const Value: Boolean);
var
  tempEdit : TEdit;
begin
  tempEdit := self as TEdit;  // cast to parent class
  tempEdit.ReadOnly := Value; // this calls the parent class setter method

  if Value then color := FColorWhenReadOnly
           else color := FColorWhenReadWrite;
end;

(Note: This is just a fragment of the complete component .. just the part related to the ReadOnly property.)

Comment

I am sure that this information is written down somewhere in the help files, but I have been doing Delphi development for many years and was not aware of how, or when, the window'ed components were created.

I hope you find these notes useful.

Advice

Always test your code in every way you can imagine - there is always something you have missed. Oh .. and write down the steps so that you can repeat them (and improve them).

Author: Robert Clemenzi - clemenzi@cpcug.org