IdeIntf: Improve identification of designer forms. r49352,r49367,r49371,r49510 from free-sparta branch by Maciej Izak.

git-svn-id: trunk@49528 -

components/ideintf/formeditingintf.pas

@@ -24,6 +24,11 @@ const
   ComponentPaletteImageHeight = 24;
   ComponentPaletteBtnWidth  = ComponentPaletteImageWidth + 3;
   ComponentPaletteBtnHeight = ComponentPaletteImageHeight + 3;
+  DesignerBaseClassId_TForm = 0;
+  DesignerBaseClassId_TDataModule = 1;
+  DesignerBaseClassId_TFrame = 2;
+  NonControlProxyDesignerFormId = 0;
+  FrameProxyDesignerFormId = 1;
 
 type
   TDMCompAtPosFlag = (
@@ -32,6 +37,93 @@ type
     );
   TDMCompAtPosFlags = set of TDMCompAtPosFlag;
 
+  TDesignerMediator = class;
+
+  INonFormDesigner = interface
+  ['{244DEC6B-80FB-4B28-85EF-FE613D1E2DD3}']
+    procedure Create;
+
+    function GetLookupRoot: TComponent;
+    procedure SetLookupRoot(const AValue: TComponent);
+    property LookupRoot: TComponent read GetLookupRoot write SetLookupRoot;
+
+    procedure SetBounds(ALeft, ATop, AWidth, AHeight: integer);
+    procedure Notification(AComponent: TComponent; AOperation: TOperation);
+    procedure Paint;
+
+    procedure DoSaveBounds;
+    procedure DoLoadBounds;
+  end;
+
+  IFrameDesigner = interface(INonFormDesigner)
+  ['{2B9442B0-6359-450A-88A1-BB6744F84918}']
+  end;
+
+  INonControlDesigner = interface(INonFormDesigner)
+  ['{5943A33C-F812-4052-BFE8-77AEA73199A9}']
+    function GetMediator: TDesignerMediator;
+    procedure SetMediator(AValue: TDesignerMediator);
+    property Mediator: TDesignerMediator read GetMediator write SetMediator;
+  end;
+
+  { TNonFormProxyDesignerForm }
+
+  TNonFormProxyDesignerForm = class(TForm, INonFormDesigner)
+  private
+    FNonFormDesigner: INonFormDesigner;
+    FLookupRoot: TComponent;
+  protected
+    procedure Notification(AComponent: TComponent; AOperation: TOperation); override;
+
+    procedure SetLookupRoot(AValue: TComponent); virtual;
+    function GetPublishedBounds(AIndex: Integer): Integer; virtual;
+    procedure SetPublishedBounds(AIndex: Integer; AValue: Integer); virtual;
+  public
+    constructor Create(AOwner: TComponent; ANonFormDesigner: INonFormDesigner); virtual; reintroduce;
+    procedure Paint; override;
+
+    procedure SetBounds(ALeft, ATop, AWidth, AHeight: integer); override;
+    procedure SetDesignerFormBounds(ALeft, ATop, AWidth, AHeight: integer);
+    procedure SetPublishedBounds(ALeft, ATop, AWidth, AHeight: integer);
+    procedure SetLookupRootBounds(ALeft, ATop, AWidth, AHeight: integer); virtual;
+
+    function DockedDesigner: boolean; virtual;
+
+    property NonFormDesigner: INonFormDesigner read FNonFormDesigner  implements INonFormDesigner;
+    property LookupRoot: TComponent read FLookupRoot write SetLookupRoot;
+  published
+    property Left: Integer index 0 read GetPublishedBounds write SetPublishedBounds;
+    property Top: Integer index 1 read GetPublishedBounds write SetPublishedBounds;
+    property Width: Integer index 2 read GetPublishedBounds write SetPublishedBounds;
+    property Height: Integer index 3 read GetPublishedBounds write SetPublishedBounds;
+    property ClientWidth: Integer index 2 read GetPublishedBounds write SetPublishedBounds;
+    property ClientHeight: Integer index 3 read GetPublishedBounds write SetPublishedBounds;
+  end;
+
+  { TFrameProxyDesignerForm }
+
+  TFrameProxyDesignerForm = class(TNonFormProxyDesignerForm, IFrameDesigner)
+  private
+    function GetFrameDesigner: IFrameDesigner;
+  public
+    property FrameDesigner: IFrameDesigner read GetFrameDesigner implements IFrameDesigner;
+  end;
+
+  { TNonControlProxyDesignerForm }
+
+  TNonControlProxyDesignerForm = class(TNonFormProxyDesignerForm, INonControlDesigner)
+  private
+    FMediator: TDesignerMediator;
+    function GetNonControlDesigner: INonControlDesigner;
+  protected
+    procedure SetMediator(AValue: TDesignerMediator); virtual;
+  public
+    property NonControlDesigner: INonControlDesigner read GetNonControlDesigner implements INonControlDesigner;
+    property Mediator: TDesignerMediator read FMediator write SetMediator;
+  end;
+
+  TNonFormProxyDesignerFormClass = class of TNonFormProxyDesignerForm;
+
   { TDesignerMediator
     To edit designer forms which do not use the LCL, register a TDesignerMediator,
     which will emulate the painting, handle the mouse and editing bounds. }
@@ -89,11 +181,18 @@ type
   { TAbstractFormEditor }
   
   TAbstractFormEditor = class
+  private
+    FNonFormProxyDesignerFormClass: array[0..1] of TNonFormProxyDesignerFormClass;
   protected
     function GetDesignerBaseClasses(Index: integer): TComponentClass; virtual; abstract;
+    function GetStandardDesignerBaseClasses(Index: integer): TComponentClass; virtual; abstract;
+    procedure SetStandardDesignerBaseClasses(Index: integer; AValue: TComponentClass); virtual; abstract;
     function GetDesigner(Index: integer): TIDesigner; virtual; abstract;
     function GetDesignerMediators(Index: integer): TDesignerMediatorClass; virtual; abstract;
+    function GetNonFormProxyDesignerForm(Index: Integer): TNonFormProxyDesignerFormClass; virtual;
+    procedure SetNonFormProxyDesignerForm(Index: Integer; AValue: TNonFormProxyDesignerFormClass); virtual;
   public
+    constructor Create;
     // persistent
     procedure RegisterDefineProperty(const APersistentClassName,
                                      Identifier: string); virtual; abstract;
@@ -138,13 +237,18 @@ type
     function DescendFromDesignerBaseClass(AClass: TComponentClass): integer; virtual; abstract;
     function FindDesignerBaseClassByName(const AClassName: shortstring; WithDefaults: boolean): TComponentClass; virtual; abstract;
 
+    property StandardDesignerBaseClasses[Index: integer]: TComponentClass read GetStandardDesignerBaseClasses
+                                                                         write SetStandardDesignerBaseClasses;
+    function StandardDesignerBaseClassesCount: Integer; virtual; abstract;
     // designers
     function DesignerCount: integer; virtual; abstract;
     property Designer[Index: integer]: TIDesigner read GetDesigner;
     function GetCurrentDesigner: TIDesigner; virtual; abstract;
     function GetDesignerForm(APersistent: TPersistent): TCustomForm; virtual; abstract;
-    function GetDesignerByComponent(AComponent: TComponent
+    function GetDesignerByComponent(AComponent: TComponent): TIDesigner; virtual; abstract;
-                                    ): TIDesigner; virtual; abstract;
+    function NonFormProxyDesignerFormCount: integer; virtual;
+    property NonFormProxyDesignerForm[Index: integer]: TNonFormProxyDesignerFormClass read GetNonFormProxyDesignerForm
+                                                                                     write SetNonFormProxyDesignerForm;
 
     // mediators for non LCL forms
     procedure RegisterDesignerMediator(MediatorClass: TDesignerMediatorClass); virtual; abstract; // auto calls RegisterDesignerBaseClass
@@ -188,6 +292,8 @@ procedure SetDesignInfoLeft(AComponent: TComponent; const aLeft: SmallInt); inli
 procedure SetDesignInfoTop(AComponent: TComponent; const aTop: SmallInt); inline;
 function LeftTopToDesignInfo(const ALeft, ATop: SmallInt): LongInt; inline;
 procedure DesignInfoToLeftTop(ADesignInfo: LongInt; out ALeft, ATop: SmallInt); inline;
+function IsFormDesign(AForm: TCustomForm): boolean;
+function LookupRoot(AForm: TCustomForm): TComponent;
 
 implementation
 
@@ -280,6 +386,151 @@ begin
   ATop := LazLongRec(ADesignInfo).Hi;
 end;
 
+function IsFormDesign(AForm: TCustomForm): boolean;
+begin
+  if AForm = nil then
+    Exit(False);
+  Result := (csDesignInstance in AForm.ComponentState)
+     or ((csDesigning in AForm.ComponentState) and (AForm.Designer <> nil))
+     or (AForm is TNonFormProxyDesignerForm);
+end;
+
+function LookupRoot(AForm: TCustomForm): TComponent;
+begin
+  if AForm is TNonFormProxyDesignerForm then
+    Result := TNonFormProxyDesignerForm(AForm).LookupRoot
+  else if csDesignInstance in AForm.ComponentState then
+    Result := AForm
+  else
+    Result := nil;
+end;
+
+{ TAbstractFormEditor }
+
+function TAbstractFormEditor.GetNonFormProxyDesignerForm(Index: Integer
+  ): TNonFormProxyDesignerFormClass;
+begin
+  Result := FNonFormProxyDesignerFormClass[Index];
+end;
+
+procedure TAbstractFormEditor.SetNonFormProxyDesignerForm(Index: Integer;
+  AValue: TNonFormProxyDesignerFormClass);
+begin
+  FNonFormProxyDesignerFormClass[Index] := AValue;
+end;
+
+constructor TAbstractFormEditor.Create;
+begin
+  FNonFormProxyDesignerFormClass[NonControlProxyDesignerFormId] := TNonControlProxyDesignerForm;
+  FNonFormProxyDesignerFormClass[FrameProxyDesignerFormId] := TFrameProxyDesignerForm;
+end;
+
+function TAbstractFormEditor.NonFormProxyDesignerFormCount: integer;
+begin
+  Result := Length(FNonFormProxyDesignerFormClass);
+end;
+
+{ TNonControlProxyDesignerForm }
+
+function TNonControlProxyDesignerForm.GetNonControlDesigner: INonControlDesigner;
+begin
+  Result := FNonFormDesigner as INonControlDesigner;
+end;
+
+procedure TNonControlProxyDesignerForm.SetMediator(AValue: TDesignerMediator);
+begin
+  FMediator := AValue;
+end;
+
+{ TFrameProxyDesignerForm }
+
+function TFrameProxyDesignerForm.GetFrameDesigner: IFrameDesigner;
+begin
+  Result := FNonFormDesigner as IFrameDesigner;
+end;
+
+{ TNonFormProxyDesignerForm }
+
+procedure TNonFormProxyDesignerForm.Notification(AComponent: TComponent;
+  AOperation: TOperation);
+begin
+  inherited Notification(AComponent, AOperation);
+  if Assigned(FNonFormDesigner) then
+    FNonFormDesigner.Notification(AComponent, AOperation);
+end;
+
+procedure TNonFormProxyDesignerForm.SetLookupRoot(AValue: TComponent);
+begin
+  FLookupRoot := AValue;
+end;
+
+function TNonFormProxyDesignerForm.GetPublishedBounds(AIndex: Integer): Integer;
+begin
+  case AIndex of
+    0: Result := inherited Left;
+    1: Result := inherited Top;
+    2: Result := inherited Width;
+    3: Result := inherited Height;
+  end;
+end;
+
+procedure TNonFormProxyDesignerForm.SetPublishedBounds(AIndex: Integer;
+  AValue: Integer);
+begin
+  case AIndex of
+    0: inherited Left := AValue;
+    1: inherited Top := AValue;
+    2: inherited Width := AValue;
+    3: inherited Height := AValue;
+  end;
+end;
+
+constructor TNonFormProxyDesignerForm.Create(AOwner: TComponent;
+  ANonFormDesigner: INonFormDesigner);
+begin
+  inherited CreateNew(AOwner, 1);
+
+  FNonFormDesigner := ANonFormDesigner;
+  FNonFormDesigner.Create;
+end;
+
+procedure TNonFormProxyDesignerForm.Paint;
+begin
+  inherited Paint;
+  FNonFormDesigner.Paint;
+end;
+
+procedure TNonFormProxyDesignerForm.SetBounds(ALeft, ATop, AWidth, AHeight: integer);
+begin
+  inherited SetBounds(aLeft, aTop, aWidth, aHeight);
+  if Assigned(FNonFormDesigner) then
+    FNonFormDesigner.SetBounds(ALeft, ATop, AWidth, AHeight);
+end;
+
+procedure TNonFormProxyDesignerForm.SetDesignerFormBounds(ALeft, ATop, AWidth, AHeight: integer);
+begin
+  inherited SetBounds(aLeft, aTop, aWidth, aHeight);
+end;
+
+procedure TNonFormProxyDesignerForm.SetPublishedBounds(ALeft, ATop, AWidth, AHeight: integer);
+begin
+  SetPublishedBounds(0, ALeft);
+  SetPublishedBounds(1, ATop);
+  SetPublishedBounds(2, AWidth);
+  SetPublishedBounds(3, AHeight);
+end;
+
+procedure TNonFormProxyDesignerForm.SetLookupRootBounds(ALeft, ATop, AWidth, AHeight: integer);
+begin
+  if LookupRoot is TControl then
+    TControl(LookupRoot).SetBounds(ALeft, ATop, AWidth, AHeight);
+end;
+
+function TNonFormProxyDesignerForm.DockedDesigner: boolean;
+begin
+  Result := False;
+end;
+
 { TDesignerMediator }
 
 procedure TDesignerMediator.SetRoot(const AValue: TComponent);

components/ideintf/unitresources.pas

@@ -69,6 +69,9 @@ function GetUnitResourcefileFormats: TUnitResourcefileFormatArr;
 
 implementation
 
+uses
+  FormEditingIntf;
+
 var
   GUnitResourcefileFormats: TUnitResourcefileFormatArr;
 
@@ -146,11 +149,11 @@ class function TCustomLFMUnitResourceFileFormat.FindComponentClass(
   aClassName: string): TComponentClass;
 begin
   if CompareText(aClassName,'TForm')=0 then
-    Result:=TForm
+    Result:=FormEditingHook.StandardDesignerBaseClasses[DesignerBaseClassId_TForm]
   else if CompareText(aClassName,'TFrame')=0 then
-    Result:=TFrame
+    Result:=FormEditingHook.StandardDesignerBaseClasses[DesignerBaseClassId_TFrame]
   else if CompareText(aClassName,'TDataModule')=0 then
-    Result:=TDataModule
+    Result:=FormEditingHook.StandardDesignerBaseClasses[DesignerBaseClassId_TDataModule]
   else
     Result:=nil;
 end;
@@ -167,8 +170,7 @@ begin
   Result:=TForm;
 end;
 
-class function TUnitResourcefileFormat.FindComponentClass(aClassName: string
+class function TUnitResourcefileFormat.FindComponentClass(aClassName: string): TComponentClass;
-  ): TComponentClass;
 begin
   Result:=nil;
 end;

designer/controlselection.pp

@@ -1160,8 +1160,8 @@ begin
   InvalidateGrabbers;
   OldCustomForm:=FForm;
   FForm:=NewCustomForm;
-  if FForm is TNonControlDesignerForm then
+  if FForm is FormEditingHook.NonFormProxyDesignerForm[NonControlProxyDesignerFormId] then
-    FMediator:=TNonControlDesignerForm(FForm).Mediator
+    FMediator:=(FForm as INonControlDesigner).Mediator
   else
     FMediator:=nil;
   FLookupRoot:=GetSelectionOwner;
@@ -1177,8 +1177,7 @@ begin
   Result:=FGrabbers[AGrabIndex];
 end;
 
-procedure TControlSelection.SetGrabbers(AGrabIndex:TGrabIndex;
+procedure TControlSelection.SetGrabbers(AGrabIndex:TGrabIndex; const AGrabber: TGrabber);
-  const AGrabber: TGrabber);
 begin
   FGrabbers[AGrabIndex]:=AGrabber;
 end;

designer/customnonformdesigner.pas

@@ -31,27 +31,32 @@ interface
 
 uses
   Classes, SysUtils, LCLProc, Graphics, GraphType, Forms, Controls,
-  IDEProcs;
+  IDEProcs, FormEditingIntf;
   
 type
 
   { TCustomNonFormDesignerForm }
 
-  TCustomNonFormDesignerForm = class(TForm)
+  TCustomNonFormDesignerForm = class(TInterfacedObject, INonFormDesigner)
   private
-    FLookupRoot: TComponent;
+    FNonFormProxyDesignerForm: TNonFormProxyDesignerForm;
     FOnLoadBounds: TNotifyEvent;
     FOnSaveBounds: TNotifyEvent;
   protected
+    function GetLookupRoot: TComponent; virtual;
     procedure SetLookupRoot(const AValue: TComponent); virtual;
-    procedure Notification(AComponent: TComponent; Operation: TOperation);
+    procedure Notification(AComponent: TComponent; Operation: TOperation); virtual;
-         override;
   public
-    constructor Create(AOwner: TComponent); override;
+    procedure Create; virtual; overload;
+    constructor Create(ANonFormProxyDesignerForm: TNonFormProxyDesignerForm); virtual; overload;
+    destructor Destroy; override;
     procedure DoLoadBounds; virtual;
     procedure DoSaveBounds; virtual;
+    procedure SetBounds(ALeft, ATop, AWidth, AHeight: integer); virtual;
+    procedure Paint; virtual;
   public
-    property LookupRoot: TComponent read FLookupRoot write SetLookupRoot;
+    property LookupRoot: TComponent read GetLookupRoot write SetLookupRoot;
+    property NonFormProxyDesignerForm: TNonFormProxyDesignerForm read FNonFormProxyDesignerForm;
     property OnLoadBounds: TNotifyEvent read FOnLoadBounds write FOnLoadBounds;
     property OnSaveBounds: TNotifyEvent read FOnSaveBounds write FOnSaveBounds;
   end;
@@ -65,42 +70,42 @@ implementation
 
 function CompareNonFormDesignerForms(Data1, Data2: Pointer): integer;
 var
-  Form1: TCustomNonFormDesignerForm;
+  Form1: INonFormDesigner;
-  Form2: TCustomNonFormDesignerForm;
+  Form2: INonFormDesigner;
 begin
-  Form1 := TCustomNonFormDesignerForm(Data1);
+  Form1 := TNonFormProxyDesignerForm(Data1) as INonFormDesigner;
-  Form2 := TCustomNonFormDesignerForm(Data2);
+  Form2 := TNonFormProxyDesignerForm(Data2) as INonFormDesigner;
   Result := PtrInt(Form1.LookupRoot) - PtrInt(Form2.LookupRoot);
 end;
 
 function CompareLookupRootAndNonFormDesignerForm(Key, Data: Pointer): integer;
 var
   LookupRoot: TComponent;
-  Form: TCustomNonFormDesignerForm;
+  Form: INonFormDesigner;
 begin
   LookupRoot := TComponent(Key);
-  Form := TCustomNonFormDesignerForm(Data);
+  Form := TNonFormProxyDesignerForm(Data) as INonFormDesigner;
   Result := PtrInt(LookupRoot) - PtrInt(Form.LookupRoot);
 end;
 
 { TCustomNonFormDesignerForm }
 
-constructor TCustomNonFormDesignerForm.Create(AOwner: TComponent);
+function TCustomNonFormDesignerForm.GetLookupRoot: TComponent;
 begin
-  inherited CreateNew(AOwner, 1);
+  Result := FNonFormProxyDesignerForm.LookupRoot;
 end;
 
 procedure TCustomNonFormDesignerForm.SetLookupRoot(const AValue: TComponent);
 begin
-  if FLookupRoot = AValue then 
+  if FNonFormProxyDesignerForm.LookupRoot = AValue then
     Exit;
-  if FLookupRoot<>nil then
+  if FNonFormProxyDesignerForm.LookupRoot<>nil then
-    FLookupRoot.RemoveFreeNotification(Self);
+    FNonFormProxyDesignerForm.LookupRoot.RemoveFreeNotification(FNonFormProxyDesignerForm);
   DoSaveBounds;
-  FLookupRoot := AValue;
+  FNonFormProxyDesignerForm.LookupRoot := AValue;
-  if FLookupRoot <> nil then begin
+  if FNonFormProxyDesignerForm.LookupRoot <> nil then begin
-    FLookupRoot.FreeNotification(Self);
+    FNonFormProxyDesignerForm.LookupRoot.FreeNotification(FNonFormProxyDesignerForm);
-    Caption := FLookupRoot.Name;
+    FNonFormProxyDesignerForm.Caption := FNonFormProxyDesignerForm.LookupRoot.Name;
   end;
   DoLoadBounds;
 end;
@@ -108,12 +113,27 @@ end;
 procedure TCustomNonFormDesignerForm.Notification(AComponent: TComponent;
   Operation: TOperation);
 begin
-  inherited Notification(AComponent, Operation);
   if Operation=opRemove then begin
-    if AComponent=FLookupRoot then FLookupRoot:=nil;
+    if AComponent=FNonFormProxyDesignerForm.LookupRoot then FNonFormProxyDesignerForm.LookupRoot:=nil;
   end;
 end;
 
+constructor TCustomNonFormDesignerForm.Create(
+  ANonFormProxyDesignerForm: TNonFormProxyDesignerForm);
+begin
+  FNonFormProxyDesignerForm := ANonFormProxyDesignerForm;
+end;
+
+destructor TCustomNonFormDesignerForm.Destroy;
+begin
+  inherited Destroy;
+end;
+
+procedure TCustomNonFormDesignerForm.Create;
+begin
+  inherited Create;
+end;
+
 procedure TCustomNonFormDesignerForm.DoLoadBounds;
 begin
   if Assigned(OnLoadBounds) then
@@ -126,5 +146,15 @@ begin
     OnSaveBounds(Self);
 end;
 
+procedure TCustomNonFormDesignerForm.SetBounds(ALeft, ATop, AWidth,
+  AHeight: integer);
+begin
+end;
+
+procedure TCustomNonFormDesignerForm.Paint;
+begin
+
+end;
+
 end.
 

designer/designer.pp

@@ -617,17 +617,19 @@ end;
 constructor TDesigner.Create(TheDesignerForm: TCustomForm;
   AControlSelection: TControlSelection);
 var
+  LNonControlDesigner: INonControlDesigner;
   i: integer;
 begin
   inherited Create;
   //debugln(['TDesigner.Create Self=',dbgs(Pointer(Self)),' TheDesignerForm=',DbgSName(TheDesignerForm)]);
   FForm := TheDesignerForm;
-  if FForm is TNonControlDesignerForm then begin
+  if FForm is BaseFormEditor1.NonFormProxyDesignerForm[NonControlProxyDesignerFormId] then begin
-    FLookupRoot := TNonControlDesignerForm(FForm).LookupRoot;
+    LNonControlDesigner := FForm as INonControlDesigner;
-    Mediator:=TNonControlDesignerForm(FForm).Mediator;
+    FLookupRoot := LNonControlDesigner.LookupRoot;
+    Mediator := LNonControlDesigner.Mediator;
   end
-  else if FForm is TFrameDesignerForm then
+  else if FForm is BaseFormEditor1.NonFormProxyDesignerForm[FrameProxyDesignerFormId] then
-    FLookupRoot := TFrameDesignerForm(FForm).LookupRoot
+    FLookupRoot := (FForm as IFrameDesigner).LookupRoot
   else
     FLookupRoot := FForm;
 

designer/framedesigner.pas

@@ -37,7 +37,7 @@ type
 
   { TFrameDesignerForm }
 
-  TFrameDesignerForm = class(TCustomNonFormDesignerForm)
+  TFrameDesignerForm = class(TCustomNonFormDesignerForm, INonFormDesigner, IFrameDesigner)
   protected
     FChangingBounds: Boolean;
     FResizing: Boolean;
@@ -45,7 +45,8 @@ type
     procedure OnControlChangeBounds(Sender: TObject);
     procedure OnControlResize(Sender: TObject);
   public
-    constructor Create(AOwner: TComponent); override;
+    procedure Create; override;
+    constructor Create(ANonFormProxyDesignerForm: TNonFormProxyDesignerForm); override;
     destructor Destroy; override;
     procedure DoLoadBounds; override;
     procedure DoSaveBounds; override;
@@ -57,14 +58,6 @@ implementation
 
 { TFrameDesignerForm }
 
-constructor TFrameDesignerForm.Create(AOwner: TComponent);
-begin
-  Position := poDesigned; 
-  inherited Create(AOwner);
-  // workaround problem with out assumption that Width = ClientWidth, Height = ClientHeight
-  AutoScroll := False; 
-end;
-
 destructor TFrameDesignerForm.Destroy;
 begin
   if LookupRoot is TControl then
@@ -82,7 +75,7 @@ begin
   if (AValue is TControl) then
   begin
     AControl := TControl(AValue);
-    AControl.Parent := Self;
+    AControl.Parent := NonFormProxyDesignerForm;
     AControl.AddHandlerOnChangeBounds(@OnControlChangeBounds, True);
     AControl.AddHandlerOnResize(@OnControlResize, True);
   end;
@@ -102,7 +95,7 @@ begin
     for a := Low(TAnchorKind) to High(TAnchorKind) do
       AControl.AnchorSide[a].Control := nil;
     // reset left, top but save width and height
-    AControl.SetBounds(0, 0, AControl.Width, AControl.Height);
+    NonFormProxyDesignerForm.SetLookupRootBounds(0, 0, AControl.Width, AControl.Height);
   finally
     FChangingBounds := False;
   end;
@@ -117,22 +110,48 @@ begin
   FResizing := True;
   try
     // update form bounds
-    SetBounds(Left, Top, AControl.Width, AControl.Height);
+    with NonFormProxyDesignerForm do
+    SetPublishedBounds(Left, Top, AControl.Width, AControl.Height);
   finally
     FResizing := False;
   end;
 end;
 
+procedure TFrameDesignerForm.Create;
+begin
+  inherited Create;
+  // workaround problem with out assumption that Width = ClientWidth, Height = ClientHeight
+  NonFormProxyDesignerForm.AutoScroll := False;
+end;
+
+constructor TFrameDesignerForm.Create(
+  ANonFormProxyDesignerForm: TNonFormProxyDesignerForm);
+begin
+  inherited Create(ANonFormProxyDesignerForm);
+  NonFormProxyDesignerForm.Position := poDesigned;
+end;
+
 procedure TFrameDesignerForm.DoLoadBounds;
 
   procedure SetNewBounds(NewLeft, NewTop, NewWidth, NewHeight: integer);
+  begin
+    with NonFormProxyDesignerForm do
     begin
       if NewWidth <= 0 then NewWidth := Width;
       if NewHeight <= 0 then NewHeight := Height;
 
+      if DockedDesigner then
+      begin
+        NewLeft:=Max(0,NewLeft);
+        NewTop:=Max(0,NewTop);
+      end
+      else
+      begin
         NewWidth := Max(20, Min(NewWidth, Screen.Width - 50));
         NewHeight := Max(20, Min(NewHeight, Screen.Height - 50));
-    SetBounds(NewLeft, NewTop, Max(20, NewWidth), Max(NewHeight, 20));
+      end;
+      SetPublishedBounds(NewLeft, NewTop, NewWidth, NewHeight);
+    end;
   end;
 
 var
@@ -159,11 +178,12 @@ end;
 procedure TFrameDesignerForm.DoSaveBounds;
 begin
   if LookupRoot is TControl then
+  with NonFormProxyDesignerForm do
   begin
     // store designer position
     LookupRoot.DesignInfo := LeftTopToDesignInfo(Left, Top);
     // always fill the whole designer form
-    TControl(LookupRoot).SetBounds(0, 0, Width, Height);
+    SetLookupRootBounds(0, 0, Width, Height);
     //DebugLn(['TFrameDesignerForm.DoSaveBounds ',Left,',',Top,' ',LazLongRec(LookupRoot.DesignInfo).Lo,',',LazLongRec(LookupRoot.DesignInfo).hi]);
   end
   else
@@ -176,8 +196,9 @@ procedure TFrameDesignerForm.SetBounds(aLeft, aTop, aWidth, aHeight: integer);
 begin
   // auto apply width and height
   inherited SetBounds(aLeft, aTop, aWidth, aHeight);
-  if (LookupRoot is TControl) then
+
-    TControl(LookupRoot).SetBounds(0, 0, Width, Height);
+  with NonFormProxyDesignerForm do
+    SetLookupRootBounds(0, 0, Width, Height);
 end;
 
 end.

designer/noncontroldesigner.pas

@@ -38,25 +38,25 @@ type
 
   { TNonControlDesignerForm }
 
-  TNonControlDesignerForm = class(TCustomNonFormDesignerForm)
+  TNonControlDesignerForm = class(TCustomNonFormDesignerForm, INonFormDesigner, INonControlDesigner)
   private
     FFrameWidth: integer;
-    FMediator: TDesignerMediator;
+    function GetMediator: TDesignerMediator;
-    procedure SetMediator(const AValue: TDesignerMediator);
+    procedure SetMediator(AValue: TDesignerMediator);
   protected
     procedure SetFrameWidth(const AValue: integer); virtual;
-    procedure DoSetBounds(ALeft, ATop, AWidth, AHeight: integer); override;
     procedure Notification(AComponent: TComponent; Operation: TOperation);
           override;
   public
-    constructor Create(TheOwner: TComponent); override;
+    procedure Create; override; overload;
     destructor Destroy; override;
     procedure Paint; override;
+    procedure SetBounds(aLeft, aTop, aWidth, aHeight: integer); override;
     procedure DoLoadBounds; override;
     procedure DoSaveBounds; override;
   public
     property FrameWidth: integer read FFrameWidth write SetFrameWidth;
-    property Mediator: TDesignerMediator read FMediator write SetMediator;
+    property Mediator: TDesignerMediator read GetMediator write SetMediator;
   end;
   
   
@@ -65,19 +65,27 @@ implementation
 
 { TNonControlDesignerForm }
 
-procedure TNonControlDesignerForm.SetMediator(const AValue: TDesignerMediator);
+function TNonControlDesignerForm.GetMediator: TDesignerMediator;
 begin
-  if FMediator=AValue then exit;
+  Result := TNonControlProxyDesignerForm(NonFormProxyDesignerForm).Mediator;
-  if FMediator<>nil then begin
+end;
-    FMediator.LCLForm:=nil;
+
-    FMediator.RemoveFreeNotification(Self);
+procedure TNonControlDesignerForm.SetMediator(AValue: TDesignerMediator);
+begin
+  with TNonControlProxyDesignerForm(NonFormProxyDesignerForm) do
+  begin
+    if Mediator=AValue then exit;
+    if Mediator<>nil then begin
+      Mediator.LCLForm:=nil;
+      Mediator.RemoveFreeNotification(NonFormProxyDesignerForm);
     end;
-  FMediator:=AValue;
+    Mediator:=AValue;
-  if FMediator<>nil then begin
+    if Mediator<>nil then begin
-    FMediator.LCLForm:=Self;
+      Mediator.LCLForm:=NonFormProxyDesignerForm;
-    FMediator.FreeNotification(Self);
+      Mediator.FreeNotification(NonFormProxyDesignerForm);
       DoLoadBounds;
     end;
+  end;
 end;
 
 procedure TNonControlDesignerForm.SetFrameWidth(const AValue: integer);
@@ -85,15 +93,15 @@ begin
   if FFrameWidth = AValue then 
     Exit;
   FFrameWidth := AValue;
-  Invalidate;
+  NonFormProxyDesignerForm.Invalidate;
 end;
 
-procedure TNonControlDesignerForm.DoSetBounds(ALeft, ATop, AWidth,
+procedure TNonControlDesignerForm.SetBounds(aLeft, aTop, aWidth,
-  AHeight: integer);
+  aHeight: integer);
 begin
-  inherited DoSetBounds(ALeft, ATop, AWidth, AHeight);
+  inherited SetBounds(ALeft, ATop, AWidth, AHeight);
   if Mediator<>nil then
-    Mediator.SetFormBounds(LookupRoot,BoundsRect,ClientRect);
+    Mediator.SetFormBounds(LookupRoot,NonFormProxyDesignerForm.BoundsRect,NonFormProxyDesignerForm.ClientRect);
 end;
 
 procedure TNonControlDesignerForm.Notification(AComponent: TComponent;
@@ -101,21 +109,22 @@ procedure TNonControlDesignerForm.Notification(AComponent: TComponent;
 begin
   inherited Notification(AComponent, Operation);
   if Operation=opRemove then begin
-    if FMediator=AComponent then FMediator:=nil;
+    if Mediator=AComponent then Mediator:=nil;
   end;
 end;
 
-constructor TNonControlDesignerForm.Create(TheOwner: TComponent);
+procedure TNonControlDesignerForm.Create;
 begin
-  inherited Create(TheOwner);
+  inherited;
   FFrameWidth := 1;
-  ControlStyle := ControlStyle - [csAcceptsControls];
+  NonFormProxyDesignerForm.ControlStyle := NonFormProxyDesignerForm.ControlStyle - [csAcceptsControls];
 end;
 
 destructor TNonControlDesignerForm.Destroy;
 begin
   try
-    FreeAndNil(FMediator);
+    Mediator.Free;
+    Mediator := nil;
   except
     on E: Exception do begin
       debugln(['TNonControlDesignerForm.Destroy freeing mediator failed: ',E.Message]);
@@ -129,15 +138,16 @@ var
   ARect: TRect;
 begin
   inherited Paint;
+  with NonFormProxyDesignerForm do
   with Canvas do begin
     if LookupRoot is TDataModule then
     begin
       Brush.Color:=clWhite;
       ARect:=Rect(FrameWidth,FrameWidth,
-          Self.ClientWidth-FrameWidth,
+          ClientWidth-FrameWidth,
-          Self.ClientHeight-FrameWidth);
+          ClientHeight-FrameWidth);
       FillRect(ARect);
-      ARect:=Rect(0,0,Self.ClientWidth+1,Self.ClientHeight+1);
+      ARect:=Rect(0,0,ClientWidth+1,ClientHeight+1);
       Pen.Color:=clBlack;
       Frame3d(ARect, FrameWidth, bvLowered);
     end;
@@ -149,17 +159,28 @@ end;
 procedure TNonControlDesignerForm.DoLoadBounds;
 
   procedure SetNewBounds(NewLeft, NewTop, NewWidth, NewHeight: integer);
+  begin
+    with NonFormProxyDesignerForm do
     begin
       if NewWidth<=0 then NewWidth:=Width;
       if NewHeight<=0 then NewHeight:=Height;
 
+      if DockedDesigner then
+      begin
+        NewLeft:=Max(0,NewLeft);
+        NewTop:=Max(0,NewTop);
+        SetPublishedBounds(NewLeft,NewTop,Max(0,NewWidth),Max(NewHeight,0));
+      end
+      else
+      begin
         NewWidth:=Max(20,Min(NewWidth,Screen.Width-50));
         NewHeight:=Max(20,Min(NewHeight,Screen.Height-50));
         NewLeft:=Max(0,Min(NewLeft,Screen.Width-NewWidth-50));
         NewTop:=Max(0,Min(NewTop,Screen.Height-NewHeight-50));
-
+        SetPublishedBounds(NewLeft,NewTop,Max(20,NewWidth),Max(NewHeight,20));
+      end;
       //debugln('TNonControlDesignerForm.DoLoadBounds (TDataModule) ',dbgsName(LookupRoot),' ',dbgs(NewLeft),',',dbgs(NewTop),',',dbgs(NewWidth),',',dbgs(NewHeight));
-    SetBounds(NewLeft,NewTop,Max(20,NewWidth),Max(NewHeight,20));
+    end;
   end;
 
 var
@@ -180,7 +201,7 @@ begin
     NewHeight := CurDataModule.DesignSize.Y;
     
     SetNewBounds(NewLeft, NewTop, NewWidth, NewHeight);
-  end else begin
+  end else with NonFormProxyDesignerForm do begin
     if Mediator<>nil then begin
       Mediator.GetFormBounds(LookupRoot,NewBounds,NewClientRect);
       NewLeft:=NewBounds.Left;
@@ -203,17 +224,23 @@ begin
 end;
 
 procedure TNonControlDesignerForm.DoSaveBounds;
+var
+  LBoundsRect: TRect;
+  LClientRect: TRect;
 begin
   if LookupRoot is TDataModule then begin
-    with TDataModule(LookupRoot) do begin
+    with NonFormProxyDesignerForm, TDataModule(LookupRoot) do begin
       DesignOffset:=Point(Left,Top);
       DesignSize:=Point(Width,Height);
       //debugln('TNonControlDesignerForm.DoSaveBounds (TDataModule) ',dbgsName(LookupRoot),' ',dbgs(DesignOffset.X),',',dbgs(DesignOffset.Y));
     end;
-  end else if LookupRoot<>nil then begin
+  end else if LookupRoot<>nil then with NonFormProxyDesignerForm do begin
     //debugln(['TNonControlDesignerForm.DoSaveBounds ',dbgsName(LookupRoot),' ',dbgs(Left),',',dbgs(Top),' ',DbgSName(Mediator)]);
     if Mediator<>nil then begin
-      Mediator.SetFormBounds(LookupRoot,BoundsRect,ClientRect);
+      LBoundsRect := Rect(Left, Top, Left + Width, Top + Height);
+      LClientRect := Rect(0, 0, Width, Height);
+
+      Mediator.SetFormBounds(LookupRoot, LBoundsRect, LClientRect);
     end else begin
       SetComponentLeftTopOrDesignInfo(LookupRoot,Left,Top);
     end;

ide/customformeditor.pp

@@ -102,6 +102,8 @@ type
                                var ComponentClass: TComponentClass);
 
     function GetDesignerBaseClasses(Index: integer): TComponentClass; override;
+    function GetStandardDesignerBaseClasses(Index: integer): TComponentClass; override;
+    procedure SetStandardDesignerBaseClasses(Index: integer; AValue: TComponentClass); override;
     procedure OnDesignerMenuItemClick(Sender: TObject); virtual;
     function FindNonFormFormNode(LookupRoot: TComponent): TAvgLvlTreeNode;
 
@@ -134,38 +136,28 @@ type
     function IsJITComponent(AComponent: TComponent): boolean;
     function GetJITListOfType(AncestorType: TComponentClass): TJITComponentList;
     function FindJITList(AComponent: TComponent): TJITComponentList;
-    function FindJITListByClassName(const AComponentClassName: string
+    function FindJITListByClassName(const AComponentClassName: string): TJITComponentList;
-                                    ): TJITComponentList;
+    function FindJITListByClass(AComponentClass: TComponentClass): TJITComponentList;
-    function FindJITListByClass(AComponentClass: TComponentClass
-                                ): TJITComponentList;
     function GetDesignerForm(APersistent: TPersistent): TCustomForm; override;
 
-    function FindNonFormForm(LookupRoot: TComponent): TCustomNonFormDesignerForm;
+    function FindNonFormForm(LookupRoot: TComponent): TNonFormProxyDesignerForm;
+    function CreateNonFormForm(LookupRoot: TComponent): TNonFormProxyDesignerForm;
 
-    function CreateNonFormForm(LookupRoot: TComponent): TCustomNonFormDesignerForm;
+    procedure RenameJITComponent(AComponent: TComponent; const NewClassName: shortstring);
-
+    procedure RenameJITComponentUnitname(AComponent: TComponent; const NewUnitName: shortstring);
-    procedure RenameJITComponent(AComponent: TComponent;
-                                 const NewClassName: shortstring);
-    procedure RenameJITComponentUnitname(AComponent: TComponent;
-                                         const NewUnitName: shortstring);
     procedure UpdateDesignerFormName(AComponent: TComponent);
     procedure UpdateComponentName(AComponent: TComponent);
-    function CreateNewJITMethod(ALookupRoot: TComponent;
+    function CreateNewJITMethod(ALookupRoot: TComponent; const AMethodName: shortstring): TMethod;
-                                const AMethodName: shortstring): TMethod;
+    procedure RenameJITMethod(AComponent: TComponent; const OldMethodName, NewMethodName: shortstring);
-    procedure RenameJITMethod(AComponent: TComponent;
-                           const OldMethodName, NewMethodName: shortstring);
     procedure SaveHiddenDesignerFormProperties(AComponent: TComponent);
-    function FindJITComponentByClassName(const AComponentClassName: string
+    function FindJITComponentByClassName(const AComponentClassName: string): TComponent;
-                                         ): TComponent;
+    function FindJITComponentByClass(AComponentClass: TComponentClass): TComponent;
-    function FindJITComponentByClass(AComponentClass: TComponentClass
-                                     ): TComponent;
     procedure WriteMethodPropertyEvent(Writer: TWriter; {%H-}Instance: TPersistent;
       PropInfo: PPropInfo; const MethodValue, DefMethodValue: TMethod;
       var Handled: boolean);
     function SaveUnitComponentToBinStream(AnUnitInfo: TUnitInfo;
       var BinCompStream: TExtMemoryStream): TModalResult;
-    function OnGetDanglingMethodName(const AMethod: TMethod;
+    function OnGetDanglingMethodName(const AMethod: TMethod; aRootComponent: TObject): string;
-                                     aRootComponent: TObject): string;
 
     // ancestors
     function GetAncestorLookupRoot(AComponent: TComponent): TComponent; override;
@@ -177,6 +169,7 @@ type
     function DescendFromDesignerBaseClass(AClass: TComponentClass): integer; override;
     function FindDesignerBaseClassByName(const AClassName: shortstring; WithDefaults: boolean): TComponentClass; override;
 
+    function StandardDesignerBaseClassesCount: Integer; override;
     // designers
     function DesignerCount: integer; override;
     function GetDesigner(Index: integer): TIDesigner; override;
@@ -302,8 +295,8 @@ type
   end;
   
 
-const
+var
-  StandardDesignerBaseClasses: array[1..3] of TComponentClass = 
+  StandardDesignerBaseClasses: array[0..2] of TComponentClass =
   (
     Forms.TForm,
     TDataModule,
@@ -461,7 +454,7 @@ begin
   FSelection := TPersistentSelectionList.Create;
   FDesignerBaseClasses:=TFPList.Create;
   FDesignerMediatorClasses:=TFPList.Create;
-  for l:=Low(StandardDesignerBaseClasses) to High(StandardDesignerBaseClasses) do
+  for l:=0 to StandardDesignerBaseClassesCount - 1 do
     FDesignerBaseClasses.Add(StandardDesignerBaseClasses[l]);
 
   JITFormList := TJITForms.Create(nil);
@@ -567,7 +560,7 @@ Begin
     end else if JITNonFormList.IsJITNonForm(AComponent) then begin
       // free/unbind a non form component and its designer form
       aForm:=GetDesignerForm(AComponent);
-      if (AForm<>nil) and (not (AForm is TCustomNonFormDesignerForm)) then
+      if (AForm<>nil) and (not (AForm is TNonFormProxyDesignerForm)) then
         RaiseException(Format(
           lisCFETCustomFormEditorDeleteComponentWhereIsTheTCustomN, [AComponent.
           ClassName]));
@@ -575,7 +568,7 @@ Begin
       if (AForm <> nil) then
       begin
         FNonFormForms.Remove(AForm);
-        TCustomNonFormDesignerForm(AForm).LookupRoot := nil;
+        (AForm as INonFormDesigner).LookupRoot := nil;
         Application.ReleaseComponent(AForm);
       end;
 
@@ -812,20 +805,21 @@ begin
     exit;
 end;
 
-function TCustomFormEditor.FindNonFormForm(LookupRoot: TComponent): TCustomNonFormDesignerForm;
+function TCustomFormEditor.FindNonFormForm(LookupRoot: TComponent): TNonFormProxyDesignerForm;
 var
   AVLNode: TAvgLvlTreeNode;
 begin
   AVLNode := FindNonFormFormNode(LookupRoot);
   if AVLNode <> nil then
-    Result := TCustomNonFormDesignerForm(AVLNode.Data)
+    Result := TNonFormProxyDesignerForm(AVLNode.Data)
   else
     Result := nil;
 end;
 
-function TCustomFormEditor.CreateNonFormForm(LookupRoot: TComponent): TCustomNonFormDesignerForm;
+function TCustomFormEditor.CreateNonFormForm(LookupRoot: TComponent): TNonFormProxyDesignerForm;
 var
   MediatorClass: TDesignerMediatorClass;
+  LNonFormProxyDesignerClass: TNonFormProxyDesignerFormClass;
 begin
   Result := Nil;
   if FindNonFormFormNode(LookupRoot) <> nil then
@@ -833,18 +827,26 @@ begin
   if LookupRoot is TComponent then
   begin
     if LookupRoot is TCustomFrame then
-      Result := TFrameDesignerForm.Create(nil)
+    begin
+      LNonFormProxyDesignerClass := BaseFormEditor1.NonFormProxyDesignerForm[FrameProxyDesignerFormId];
+      Result := TNonFormProxyDesignerForm(LNonFormProxyDesignerClass.NewInstance);
+      Result.Create(nil, TFrameDesignerForm.Create(Result));
+    end
     else
-      Result := TNonControlDesignerForm.Create(nil);
+    begin
+      LNonFormProxyDesignerClass := BaseFormEditor1.NonFormProxyDesignerForm[NonControlProxyDesignerFormId];
+      Result := TNonFormProxyDesignerForm(LNonFormProxyDesignerClass.NewInstance);
+      Result.Create(nil, TNonControlDesignerForm.Create(Result));
+    end;
     Result.Name:='_Designer_'+LookupRoot.Name;
-    Result.LookupRoot := LookupRoot;
+    (Result as INonFormDesigner).LookupRoot := LookupRoot;
     FNonFormForms.Add(Result);
 
-    if Result is TNonControlDesignerForm then begin
+    if Result is BaseFormEditor1.NonFormProxyDesignerForm[NonControlProxyDesignerFormId] then begin
       // create the mediator
       MediatorClass:=GetDesignerMediatorClass(TComponentClass(LookupRoot.ClassType));
       if MediatorClass<>nil then
-        TNonControlDesignerForm(Result).Mediator:=MediatorClass.CreateMediator(nil,LookupRoot);
+        (Result as INonControlDesigner).Mediator:=MediatorClass.CreateMediator(nil,LookupRoot);
     end;
   end else
     RaiseException(Format(lisCFETCustomFormEditorCreateNonFormFormUnknownType, [
@@ -875,7 +877,7 @@ end;
 
 procedure TCustomFormEditor.UpdateDesignerFormName(AComponent: TComponent);
 var
-  ANonFormForm: TCustomNonFormDesignerForm;
+  ANonFormForm: TNonFormProxyDesignerForm;
 begin
   ANonFormForm := FindNonFormForm(AComponent);
   //DebugLn(['TCustomFormEditor.UpdateDesignerFormName ',ANonFormForm<>nil, ' ',AComponent.Name]);
@@ -922,11 +924,11 @@ end;
 
 procedure TCustomFormEditor.SaveHiddenDesignerFormProperties(AComponent: TComponent);
 var
-  NonFormForm: TCustomNonFormDesignerForm;
+  NonFormForm: TNonFormProxyDesignerForm;
 begin
   NonFormForm := FindNonFormForm(AComponent);
   if NonFormForm <> nil then
-    NonFormForm.DoSaveBounds;
+    (NonFormForm as INonFormDesigner).DoSaveBounds;
 end;
 
 function TCustomFormEditor.FindJITComponentByClassName(
@@ -1616,8 +1618,7 @@ begin
   {$ENDIF}
 end;
 
-function TCustomFormEditor.GetAncestorInstance(AComponent: TComponent
+function TCustomFormEditor.GetAncestorInstance(AComponent: TComponent): TComponent;
-  ): TComponent;
 { Returns the next ancestor instance.
   For example:
     TFrame3 = class(TFrame2), TFrame2 = class(TFrame1)
@@ -1650,8 +1651,7 @@ begin
   {$ENDIF}
 end;
 
-function TCustomFormEditor.RegisterDesignerBaseClass(AClass: TComponentClass
+function TCustomFormEditor.RegisterDesignerBaseClass(AClass: TComponentClass): integer;
-  ): integer;
 begin
   if AClass=nil then
     RaiseGDBException('TCustomFormEditor.RegisterDesignerBaseClass');
@@ -1669,21 +1669,18 @@ procedure TCustomFormEditor.UnregisterDesignerBaseClass(AClass: TComponentClass)
 var
   l: Integer;
 begin
-  for l:=Low(StandardDesignerBaseClasses) to High(StandardDesignerBaseClasses)
+  for l := 0 to StandardDesignerBaseClassesCount-1 do
-  do
     if StandardDesignerBaseClasses[l]=AClass then
       RaiseGDBException('TCustomFormEditor.UnregisterDesignerBaseClass');
   FDesignerBaseClasses.Remove(AClass);
 end;
 
-function TCustomFormEditor.IndexOfDesignerBaseClass(AClass: TComponentClass
+function TCustomFormEditor.IndexOfDesignerBaseClass(AClass: TComponentClass): integer;
-  ): integer;
 begin
   Result:=FDesignerBaseClasses.IndexOf(AClass);
 end;
 
-function TCustomFormEditor.DescendFromDesignerBaseClass(AClass: TComponentClass
+function TCustomFormEditor.DescendFromDesignerBaseClass(AClass: TComponentClass): integer;
-  ): integer;
 begin
   Result:=FDesignerBaseClasses.Count-1;
   while (Result>=0)
@@ -1695,24 +1692,43 @@ function TCustomFormEditor.FindDesignerBaseClassByName(
   const AClassName: shortstring; WithDefaults: boolean): TComponentClass;
 var
   i: Integer;
-begin
+
-  if WithDefaults then begin
+  function SearchInParent(AParent: TComponentClass): TComponentClass;
-    for i:=Low(StandardDesignerBaseClasses) to high(StandardDesignerBaseClasses)
-    do begin
-      if CompareText(AClassName,StandardDesignerBaseClasses[i].ClassName)=0 then
   begin
-        Result:=StandardDesignerBaseClasses[i];
+    Result := nil;
-        exit;
+    while AParent <> nil do
+    begin
+      if CompareText(AClassName, AParent.ClassName)=0 then
+        Exit(AParent);
+      AParent:=TComponentClass(AParent.ClassParent);
+      if AParent = TComponent then
+        Exit;
     end;
   end;
+
+begin
+  if WithDefaults then
+  begin
+    for i := 0 to StandardDesignerBaseClassesCount - 1 do
+    begin
+      Result := SearchInParent(StandardDesignerBaseClasses[i]);
+      if Result <> nil then
+        Exit(StandardDesignerBaseClasses[i]);
     end;
-  for i:=FDesignerBaseClasses.Count-1 downto 0 do begin
+  end;
+  for i:=FDesignerBaseClasses.Count-1 downto 0 do
+  begin
     Result:=DesignerBaseClasses[i];
     if CompareText(Result.ClassName,AClassName)=0 then exit;
   end;
   Result:=nil;
 end;
 
+function TCustomFormEditor.StandardDesignerBaseClassesCount: Integer;
+begin
+  Result := Succ(High(CustomFormEditor.StandardDesignerBaseClasses) - Low(CustomFormEditor.StandardDesignerBaseClasses));
+end;
+
 procedure TCustomFormEditor.FindDefineProperty(
   const APersistentClassName, AncestorClassName, Identifier: string;
   var IsDefined: boolean);
@@ -2185,6 +2201,16 @@ begin
   Result:=TComponentClass(FDesignerBaseClasses[Index]);
 end;
 
+function TCustomFormEditor.GetStandardDesignerBaseClasses(Index: integer): TComponentClass;
+begin
+  Result := CustomFormEditor.StandardDesignerBaseClasses[Index];
+end;
+
+procedure TCustomFormEditor.SetStandardDesignerBaseClasses(Index: integer; AValue: TComponentClass);
+begin
+  CustomFormEditor.StandardDesignerBaseClasses[Index] := AValue;
+end;
+
 procedure TCustomFormEditor.FrameCompGetCreationClass(Sender: TObject;
   var NewComponentClass: TComponentClass);
 begin
@@ -2226,8 +2252,7 @@ begin
                     TListSortCompare(@ComparePersClassNameAndDefPropCacheItem));
 end;
 
-function TCustomFormEditor.CreateUniqueComponentName(AComponent: TComponent
+function TCustomFormEditor.CreateUniqueComponentName(AComponent: TComponent): string;
-  ): string;
 begin
   Result:='';
   if (AComponent=nil) then exit;
@@ -2258,8 +2283,7 @@ begin
   end;
 end;
 
-function TCustomFormEditor.TranslateKeyToDesignerCommand(Key: word;
+function TCustomFormEditor.TranslateKeyToDesignerCommand(Key: word; Shift: TShiftState): word;
-  Shift: TShiftState): word;
 begin
   //debugln(['TCustomFormEditor.TranslateKeyToDesignerCommand ',DbgSName(TDesignerIDECommandForm),' ',Key,' ',dbgs(Shift)]);
   Result:=EditorOpts.KeyMap.TranslateKey(Key,Shift,TDesignerIDECommandForm);
@@ -2318,7 +2342,7 @@ var
   i: Integer;
   CurComponent: TComponent;
   P: TPoint;
-  AForm: TCustomNonFormDesignerForm;
+  AForm: TNonFormProxyDesignerForm;
   MinX: Integer;
   MinY: Integer;
   MaxX: Integer;
@@ -2415,8 +2439,7 @@ begin
     CustomForm.Designer.Modified;
 end;
 
-procedure TCustomFormEditor.SetObj_Inspector(
+procedure TCustomFormEditor.SetObj_Inspector(AnObjectInspector: TObjectInspectorDlg);
-  AnObjectInspector: TObjectInspectorDlg);
 begin
   if AnObjectInspector=FObj_Inspector then exit;
   if FObj_Inspector<>nil then begin
@@ -2442,8 +2465,9 @@ begin
   DesignerForm := GetDesignerForm(APersistent);
 
   // ask TMediator
-  if DesignerForm is TNonControlDesignerForm then begin
+  if DesignerForm is BaseFormEditor1.NonFormProxyDesignerForm[NonControlProxyDesignerFormId] then
-    Mediator:=TNonControlDesignerForm(DesignerForm).Mediator;
+  begin
+    Mediator:=(DesignerForm as INonControlDesigner).Mediator;
     if Mediator<>nil then
       Mediator.GetObjInspNodeImageIndex(APersistent, AImageIndex);
   end;

ide/sourcefilemanager.pas

@@ -45,7 +45,8 @@ uses
   DiskDiffsDialog, InputHistory, CheckLFMDlg, LCLMemManager, CodeToolManager,
   CodeToolsStructs, ConvCodeTool, CodeCache, CodeTree, FindDeclarationTool,
   BasicCodeTools, SynEdit, UnitResources, IDEExternToolIntf, ObjectInspector,
-  PublishModule, etMessagesWnd;
+  PublishModule, etMessagesWnd,
+  FormEditingIntf;
 
 type
 
@@ -1611,6 +1612,8 @@ var
   IsPartOfProject: Boolean;
   RequiredPackages: String;
   Src: String;
+  i: Integer;
+  LFindDesignerBaseClassByName: Boolean = True;
 begin
   //debugln('TLazSourceFileManager.NewFile A NewFilename=',NewFilename);
   // empty NewFilename is ok, it will be auto generated
@@ -1776,6 +1779,18 @@ begin
 
     // create component
     AncestorType:=NewFileDescriptor.ResourceClass;
+    if AncestorType <> nil then
+    begin
+      // loop for Inherited Items
+      for i:=0 to BaseFormEditor1.StandardDesignerBaseClassesCount - 1 do
+        if AncestorType.InheritsFrom(BaseFormEditor1.StandardDesignerBaseClasses[i]) then
+        begin
+          LFindDesignerBaseClassByName := False;
+          Break;
+        end;
+      if LFindDesignerBaseClassByName then
+        AncestorType:=FormEditor1.FindDesignerBaseClassByName(AncestorType.ClassName, True);
+    end;
     //DebugLn(['TLazSourceFileManager.NewFile AncestorType=',dbgsName(AncestorType),' ComponentName',NewUnitInfo.ComponentName]);
     if AncestorType<>nil then begin
       ResType:=MainBuildBoss.GetResourceType(NewUnitInfo);
@@ -5952,7 +5967,7 @@ begin
     end;
   end else begin
     // default is TForm
-    AComponentClass:=TForm;
+    AComponentClass:=BaseFormEditor1.StandardDesignerBaseClasses[DesignerBaseClassId_TForm];
   end;
   Result:=true;
 end;
@@ -6017,7 +6032,7 @@ begin
 
   // use TForm as default ancestor
   if AncestorClass=nil then
-    AncestorClass:=TForm;
+    AncestorClass:=BaseFormEditor1.StandardDesignerBaseClasses[DesignerBaseClassId_TForm];
   //DebugLn('TLazSourceFileManager.LoadAncestorDependencyHidden Filename="',AnUnitInfo.Filename,'" AncestorClassName=',AncestorClassName,' AncestorClass=',dbgsName(AncestorClass));
   Result:=mrOk;
 end;