From f28a735d19538321a17a6428c7ce0b822134de38 Mon Sep 17 00:00:00 2001 From: lazarus Date: Mon, 27 Nov 2000 18:52:38 +0000 Subject: [PATCH] Added the Object Inspector code. Added more form editor code. Shane git-svn-id: trunk@46 - --- .gitattributes | 4 + designer/abstractformeditor.pp | 3 +- designer/object_inspector.pp | 1025 ++++++++++++++++ designer/prop_edits.pp | 2085 ++++++++++++++++++++++++++++++++ designer/test_obj_inspector.pp | 13 + designer/test_unit.pp | 424 +++++++ ide/customformeditor.pp | 112 +- ide/idecomp.pp | 5 + ide/main.pp | 145 ++- lcl/controls.pp | 15 +- lcl/forms.pp | 11 + 11 files changed, 3772 insertions(+), 70 deletions(-) create mode 100644 designer/object_inspector.pp create mode 100644 designer/prop_edits.pp create mode 100644 designer/test_obj_inspector.pp create mode 100644 designer/test_unit.pp diff --git a/.gitattributes b/.gitattributes index af24ee8d42..af0cb95689 100644 --- a/.gitattributes +++ b/.gitattributes @@ -78,6 +78,10 @@ designer/designer.pp svneol=native#text/pascal designer/designerform.pp svneol=native#text/pascal designer/designerwidget.pp svneol=native#text/pascal designer/filesystem.pp svneol=native#text/pascal +designer/object_inspector.pp svneol=native#text/pascal +designer/prop_edits.pp svneol=native#text/pascal +designer/test_obj_inspector.pp svneol=native#text/pascal +designer/test_unit.pp svneol=native#text/pascal designer/widgetstack.pp svneol=native#text/pascal examples/bitbtnform.pp svneol=native#text/pascal examples/bitbutton.pp svneol=native#text/pascal diff --git a/designer/abstractformeditor.pp b/designer/abstractformeditor.pp index 1c1ca8c66b..8bf2429bcb 100644 --- a/designer/abstractformeditor.pp +++ b/designer/abstractformeditor.pp @@ -84,7 +84,8 @@ or use TPropertyType Function GetSelCount : Integer; virtual; abstract; Function GetSelComponent(Index : Integer) : TIComponentInterface; virtual; abstract; - Function CreateComponent(CI : TIComponentInterface; TypeName : String; +// Function CreateComponent(CI : TIComponentInterface; TypeName : String; + Function CreateComponent(CI : TIComponentInterface; TypeClass : TComponentClass; X,Y,W,H : Integer): TIComponentInterface; virtual; abstract; end; diff --git a/designer/object_inspector.pp b/designer/object_inspector.pp new file mode 100644 index 0000000000..1e1e925360 --- /dev/null +++ b/designer/object_inspector.pp @@ -0,0 +1,1025 @@ +unit object_inspector; +{ + Author: Mattias Gaertner + + Abstract: + + + ToDo: + - the abstract + - connect to TFormEditor + - TCustomComboBox has a bug: it can not store objects + - MouseDown is always fired two times -> workaround + - clipping (almost everywhere) + - scrolling with TrackBar + - ScrollBar instead of TrackBar + - TCustomComboBox don't know custom draw yet + - improve TextHeight function + - combobox can't sort (exception) + - TEdit.OnChange and TEdit.OnExit don't work + - TEdit has no ReadOnly and Maxlength + - Events + - backgroundcolor=clNone + + - a lot more ... +} + +{$MODE OBJFPC} + +interface + +uses + Forms, SysUtils, Buttons, Classes, Graphics, StdCtrls, LCLLinux, Controls, + ComCtrls, ExtCtrls, Prop_Edits, TypInfo; + +type + TOIPropertyGrid = class; + + TOIPropertyGridRow = class + private + FTop:integer; + FHeight:integer; + FLvl:integer; + FName:string; + FExpanded: boolean; + FTree:TOIPropertyGrid; + FChildCount:integer; + FPriorBrother, + FFirstChild, + FLastChild, + FNextBrother, + FParent:TOIPropertyGridRow; + FEditor: TPropertyEditor; + procedure GetLvl; + public + Index:integer; + property Editor:TPropertyEditor read FEditor; + property Top:integer read FTop write FTop; + property Height:integer read FHeight write FHeight; + function Bottom:integer; + property Lvl:integer read FLvl; + property Name:string read FName; + property Expanded:boolean read FExpanded; + property Tree:TOIPropertyGrid read FTree; + property Parent:TOIPropertyGridRow read FParent; + property ChildCount:integer read FChildCount; + property FirstChild:TOIPropertyGridRow read FFirstChild; + property LastChild:TOIPropertyGridRow read FFirstChild; + property NextBrother:TOIPropertyGridRow read FNextBrother; + property PriorBrother:TOIPropertyGridRow read FPriorBrother; + constructor Create(PropertyTree:TOIPropertyGrid; PropEditor:TPropertyEditor; + ParentNode:TOIPropertyGridRow); + destructor Destroy; override; + end; + + //---------------------------------------------------------------------------- + TOIPropertyGrid = class(TCustomControl) + private + FComponentList: TComponentSelectionList; + FFilter: TTypeKinds; + FItemIndex:integer; + FRows:TList; + FExpandingRow:TOIPropertyGridRow; + FTopY:integer; + FDefaultItemHeight:integer; + FSplitterX:integer; + FIndent:integer; + FBackgroundColor:TColor; + FNameFont,FValueFont:TFont; + FCurrentEdit:TWinControl; // nil or ValueEdit or ValueComboBox + FCurrentButton:TWinControl; // nil or ValueButton + FDragging:boolean; + FOldMouseDownY:integer; // XXX workaround + + function GetRow(Index:integer):TOIPropertyGridRow; + function GetRowCount:integer; + procedure ClearRows; + procedure SetItemIndex(NewIndex:integer); + + procedure SetItemsTops; + procedure AlignEditComponents; + procedure EndDragSplitter; + procedure SetSplitterX(const NewValue:integer); + + function GetTreeIconX(Index:integer):integer; + function RowRect(ARow:integer):TRect; + procedure PaintRow(ARow:integer); + + procedure SetSelections(const NewSelections:TComponentSelectionList); + + procedure AddPropertyEditor(PropEditor: TPropertyEditor); + procedure AddStringToComboBox(const s:string); + procedure ExpandRow(Index:integer); + procedure ShrinkRow(Index:integer); + procedure AddSubEditor(PropEditor:TPropertyEditor); + + procedure SetRowValue; + procedure ValueEditKeyDown(Sender: TObject; var Key: Word; Shift: TShiftState); + procedure ValueEditExit(Sender: TObject); + procedure ValueEditChange(Sender: TObject); + procedure ValueComboBoxExit(Sender: TObject); + procedure ValueComboBoxChange(Sender: TObject); + procedure TrackBarChange(Sender:TObject); + public + ValueEdit:TEdit; + ValueComboBox:TComboBox; + ValueButton:TButton; + TrackBar:TTrackBar; + + property Selections:TComponentSelectionList read FComponentList write SetSelections; + procedure BuildPropertyList; + + property RowCount:integer read GetRowCount; + property Rows[Index:integer]:TOIPropertyGridRow read GetRow; + + property TopY:integer read FTopY write FTopY; + function GridHeight:integer; + property DefaultItemHeight:integer read FDefaultItemHeight write FDefaultItemHeight; + property SplitterX:integer read FSplitterX write SetSplitterX; + property Indent:integer read FIndent write FIndent; + property BackgroundColor:TColor read FBackgroundColor write FBackgroundColor; + property NameFont:TFont read FNameFont write FNameFont; + property ValueFont:TFont read FValueFont write FValueFont; + property ItemIndex:integer read FItemIndex write SetItemIndex; + + procedure MouseDown(Button:TMouseButton; Shift:TShiftState; X,Y:integer); override; + procedure MouseMove(Shift:TShiftState; X,Y:integer); override; + procedure MouseUp(Button:TMouseButton; Shift:TShiftState; X,Y:integer); override; + function MouseToIndex(y:integer;MustExist:boolean):integer; + + procedure SetBounds(aLeft,aTop,aWidth,aHeight:integer); override; + procedure Paint; override; + procedure Clear; + constructor Create(AOwner:TComponent); override; + destructor Destroy; override; + end; + + //============================================================================ + TObjectInspector = class (TCustomForm) + private + FComponentList: TComponentSelectionList; + FRootComponent:TComponent; + function ComponentToString(c:TComponent):string; + procedure SetRootComponent(Value:TComponent); + procedure SetSelections(const NewSelections:TComponentSelectionList); + procedure AvailComboBoxChange(Sender:TObject); + public + AvailCompsComboBox : TComboBox; + NoteBook:TNoteBook; + PropertyGrid:TOIPropertyGrid; + procedure SetBounds(aLeft,aTop,aWidth,aHeight:integer); override; + property Selections:TComponentSelectionList read FComponentList write SetSelections; + procedure RefreshSelections; + procedure FillComponentComboBox; + property RootComponent:TComponent read FRootComponent write SetRootComponent; + procedure DoInnerResize; + procedure Paint; override; + constructor Create(AOwner: TComponent); override; + end; + +//****************************************************************************** + +implementation + +{ TOIPropertyGrid } + +constructor TOIPropertyGrid.Create(AOwner:TComponent); +begin + inherited Create(AOwner); + SetBounds(1,1,200,300); + Visible:=false; + ControlStyle:=ControlStyle+[csAcceptsControls]; + + FComponentList:=TComponentSelectionList.Create; + FFilter:=[tkUnknown, tkInteger, tkChar, tkEnumeration, + tkFloat, tkSet, tkMethod, tkSString, tkLString, tkAString, + tkWString, tkVariant{, tkArray, tkRecord, tkInterface}, + tkClass, tkObject, tkWChar, tkBool, tkInt64, tkQWord]; + FItemIndex:=-1; + FRows:=TList.Create; + FExpandingRow:=nil; + FDragging:=false; + + // visible values + FTopY:=0; + FSplitterX:=100; + FIndent:=9; + FBackgroundColor:=clBtnFace; + FNameFont:=TFont.Create; + FNameFont.Color:=clWindowText; + FValueFont:=TFont.Create; + FValueFont.Color:=clActiveCaption; + BorderWidth:=1; + + // create sub components + FCurrentEdit:=nil; + FCurrentButton:=nil; + + TrackBar:=TTrackBar.Create(AOwner); + with TrackBar do begin + Name:='TrackBar'; + Orientation:=trVertical; + Align:=alRight; + OnChange:=@TrackBarChange; + Visible:=true; + Enabled:=true; + Parent:=Self; + end; + + ValueEdit:=TEdit.Create(Self); + with ValueEdit do begin + Name:='ValueEdit'; + Parent:=Self; + OnKeyDown:=@ValueEditKeyDown; + OnExit:=@ValueEditExit; + OnChange:=@ValueEditChange; + Visible:=false; + Enabled:=false; + end; + + ValueComboBox:=TComboBox.Create(Self); + with ValueComboBox do begin + Name:='ValueComboBox'; + OnExit:=@ValueComboBoxExit; + OnChange:=@ValueComboBoxChange; + Visible:=false; + Enabled:=false; + Parent:=Self; + end; + + ValueButton:=TButton.Create(Self); + with ValueButton do begin + Name:='ValueButton'; + Visible:=false; + Enabled:=false; + Parent:=Self; + end; + + FDefaultItemHeight:=ValueComboBox.Height-3; + + BuildPropertyList; +end; + +destructor TOIPropertyGrid.Destroy; +var a:integer; +begin + for a:=0 to FRows.Count-1 do Rows[a].Free; + FRows.Free; + FComponentList.Free; + FValueFont.Free; + FNameFont.Free; + inherited Destroy; +end; + +procedure TOIPropertyGrid.SetSelections( + const NewSelections:TComponentSelectionList); +var a:integer; +begin + ItemIndex:=-1; + for a:=0 to FRows.Count-1 do + Rows[a].Free; + FRows.Clear; + FComponentList.Assign(NewSelections); + BuildPropertyList; +end; + +procedure TOIPropertyGrid.SetRowValue; +var CurrRow:TOIPropertyGridRow; + NewValue:string; +begin + if (FCurrentEdit<>nil) + and (FItemIndex>=0) and (FItemIndexCurrRow.Editor.GetVisualValue then begin + try + CurrRow.Editor.SetValue(NewValue); + except + end; + end; + end; +end; + +procedure TOIPropertyGrid.ValueEditKeyDown(Sender: TObject; var Key: Word; + Shift: TShiftState); +begin + if Key=VK_Return then + SetRowValue; +end; + +procedure TOIPropertyGrid.ValueEditExit(Sender: TObject); +begin + SetRowValue; +end; + +procedure TOIPropertyGrid.ValueEditChange(Sender: TObject); +var CurrRow:TOIPropertyGridRow; +begin + if (FCurrentEdit<>nil) and (FItemIndex>=0) and (FItemIndexFTopY then begin + FTopY:=TrackBar.Position; + Invalidate; + end; +end; + +procedure TOIPropertyGrid.SetItemIndex(NewIndex:integer); +var NewRow:TOIPropertyGridRow; + NewValue:string; +begin + // XXX + SetRowValue; + if (FItemIndex<>NewIndex) then begin + FItemIndex:=NewIndex; + if FCurrentEdit<>nil then begin + FCurrentEdit.Visible:=false; + FCurrentEdit.Enabled:=false; + FCurrentEdit:=nil; + end; + if FCurrentButton<>nil then begin + FCurrentButton.Visible:=false; + FCurrentButton.Enabled:=false; + FCurrentButton:=nil; + end; + if (NewIndex>=0) and (NewIndexnil then begin + FCurrentEdit.Enabled:=true; + if (FDragging=false) and (FCurrentEdit.Showing) then + FCurrentEdit.SetFocus; + end; + end; + end; +end; + +function TOIPropertyGrid.GetRowCount:integer; +begin + Result:=FRows.Count; +end; + +procedure TOIPropertyGrid.BuildPropertyList; +var a:integer; +begin + ItemIndex:=-1; + for a:=0 to FRows.Count-1 do Rows[a].Free; + FRows.Clear; + GetComponentProperties(FComponentList,FFilter,@AddPropertyEditor); + SetItemsTops; + Invalidate; +end; + +procedure TOIPropertyGrid.AddPropertyEditor(PropEditor: TPropertyEditor); +var NewRow:TOIPropertyGridRow; +begin + NewRow:=TOIPropertyGridRow.Create(Self,PropEditor,nil); + FRows.Add(NewRow); + if FRows.Count>1 then begin + NewRow.FPriorBrother:=Rows[FRows.Count-2]; + NewRow.FPriorBrother.FNextBrother:=NewRow; + end; +end; + +procedure TOIPropertyGrid.AddStringToComboBox(const s:string); +var NewIndex:integer; +begin + NewIndex:=ValueComboBox.Items.Add(s); + if ValueComboBox.Text=s then + ValueComboBox.ItemIndex:=NewIndex; +end; + +procedure TOIPropertyGrid.ExpandRow(Index:integer); +begin + FExpandingRow:=Rows[Index]; + if (FExpandingRow.Expanded) + or (not (paSubProperties in FExpandingRow.Editor.GetAttributes)) + then begin + FExpandingRow:=nil; + exit; + end; + FExpandingRow.Editor.GetProperties(@AddSubEditor); + SetItemsTops; + FExpandingRow.FExpanded:=true; + FExpandingRow:=nil; + Invalidate; +end; + +procedure TOIPropertyGrid.ShrinkRow(Index:integer); +var CurrRow:TOIPropertyGridRow; + StartIndex,EndIndex,a:integer; +begin + CurrRow:=Rows[Index]; + if (not CurrRow.Expanded) then exit; + if CurrRow.NextBrother=nil then StartIndex:=FRows.Count-1 + else StartIndex:=CurrRow.NextBrother.Index-1; + EndIndex:=CurrRow.Index+1; + for a:=StartIndex downto EndIndex do begin + Rows[a].Free; + FRows.Delete(a); + end; + SetItemsTops; + CurrRow.FExpanded:=false; + Parent.Invalidate; + Invalidate; +end; + +procedure TOIPropertyGrid.AddSubEditor(PropEditor:TPropertyEditor); +var NewRow:TOIPropertyGridRow; + NewIndex:integer; +begin + NewRow:=TOIPropertyGridRow.Create(Self,PropEditor,FExpandingRow); + NewIndex:=FExpandingRow.Index+1+FExpandingRow.ChildCount; + FRows.Insert(NewIndex,NewRow); + if FExpandingRow.FFirstChild=nil then + FExpandingRow.FFirstChild:=NewRow; + NewRow.FPriorBrother:=FExpandingRow.FLastChild; + FExpandingRow.FLastChild:=NewRow; + if NewRow.FPriorBrother<>nil then NewRow.FPriorBrother.FNextBrother:=NewRow; + inc(FExpandingRow.FChildCount); +end; + +function TOIPropertyGrid.MouseToIndex(y:integer;MustExist:boolean):integer; +var l,r,m:integer; +begin + l:=0; + r:=FRows.Count-1; + inc(y,FTopY); + while (l<=r) do begin + m:=(l+r) shr 1; + if Rows[m].Top>y then begin + r:=m-1; + end else if Rows[m].Bottom<=y then begin + l:=m+1; + end else begin + Result:=m; exit; + end; + end; + if (MustExist=false) and (FRows.Count>0) then begin + if y<0 then Result:=0 + else Result:=FRows.Count-1; + end else Result:=-1; +end; + +procedure TOIPropertyGrid.MouseDown(Button:TMouseButton; Shift:TShiftState; + X,Y:integer); +var IconX,Index:integer; + PointedRow:TOIpropertyGridRow; +begin + // XXX + // the MouseDown event is fired two times + // this is a workaround + if FOldMouseDownY=Y then begin + FOldMouseDownY:=-1; + exit; + end else FOldMouseDownY:=Y; + + if Button=mbLeft then begin + if Cursor=crHSplit then begin + FDragging:=true; + end else begin + Index:=MouseToIndex(Y,false); + ItemIndex:=Index; + if (Index>=0) and (Index=IconX) and (X<=IconX+FIndent) then begin + PointedRow:=Rows[Index]; + if paSubProperties in PointedRow.Editor.GetAttributes then begin + if PointedRow.Expanded then + ShrinkRow(Index) + else + ExpandRow(Index); + end; + end; + end; + end; + end; +end; + +procedure TOIPropertyGrid.MouseMove(Shift:TShiftState; X,Y:integer); +var SplitDistance:integer; +begin + SplitDistance:=X-SplitterX; + if FDragging then begin + if ssLeft in Shift then begin + SplitterX:=SplitterX+SplitDistance; + end else begin + EndDragSplitter; + end; + end else begin + if (abs(SplitDistance)<=2) then begin + Cursor:=crHSplit; + end else begin + Cursor:=crDefault; + end; + end; +end; + +procedure TOIPropertyGrid.MouseUp(Button:TMouseButton; Shift:TShiftState; +X,Y:integer); +begin + if FDragging then EndDragSplitter; +end; + +procedure TOIPropertyGrid.EndDragSplitter; +begin + if FDragging then begin + Cursor:=crDefault; + FDragging:=false; + if FCurrentEdit<>nil then FCurrentEdit.SetFocus; + end; +end; + +procedure TOIPropertyGrid.SetSplitterX(const NewValue:integer); +begin + if FSplitterX<>NewValue then begin + FSplitterX:=NewValue; + AlignEditComponents; + Invalidate; + end; +end; + +procedure TOIPropertyGrid.SetBounds(aLeft,aTop,aWidth,aHeight:integer); +var scrollmax:integer; +begin + inherited SetBounds(aLeft,aTop,aWidth,aHeight); + if Visible then begin + AlignEditComponents; + scrollmax:=GridHeight-Height; + if scrollmax<0 then scrollmax:=0; + TrackBar.Max:=scrollmax; + end; +end; + +function TOIPropertyGrid.GetTreeIconX(Index:integer):integer; +begin + Result:=Rows[Index].Lvl*Indent+2; +end; + +function TOIPropertyGrid.GridHeight:integer; +begin + if FRows.Count>0 then + Result:=Rows[FRows.Count-1].Bottom + else + Result:=0; +end; + +procedure TOIPropertyGrid.AlignEditComponents; +var RRect,EditCompRect,EditBtnRect:TRect; + + function CompareRectangles(r1,r2:TRect):boolean; + begin + Result:=(r1.Left=r2.Left) and (r1.Top=r2.Top) and (r1.Right=r2.Right) + and (r1.Bottom=r2.Bottom); + end; + +// AlignEditComponents +begin + if ItemIndex>=0 then begin + RRect:=RowRect(ItemIndex); + EditCompRect:=RRect; + EditCompRect.Top:=EditCompRect.Top-1; + EditCompRect.Left:=RRect.Left+SplitterX; + if FCurrentButton<>nil then begin + // edit dialog button + with EditBtnRect do begin + Top:=RRect.Top; + Left:=RRect.Right-20; + Bottom:=RRect.Bottom; + Right:=RRect.Right; + EditCompRect.Right:=Left; + end; + if not CompareRectangles(FCurrentButton.BoundsRect,EditBtnRect) then begin + FCurrentButton.BoundsRect:=EditBtnRect; + //FCurrentButton.Invalidate; + end; + end; + if FCurrentEdit<>nil then begin + // edit component + EditCompRect.Left:=EditCompRect.Left-1; + // XXX + // + EditCompRect.Bottom:=EditCompRect.Top+FCurrentEdit.Height; + if not CompareRectangles(FCurrentEdit.BoundsRect,EditCompRect) then begin + FCurrentEdit.BoundsRect:=EditCompRect; + FCurrentEdit.Invalidate; + end; + end; + end; +end; + +procedure TOIPropertyGrid.PaintRow(ARow:integer); +var ARowRect,NameRect,NameIconRect,NameTextRect,ValueRect:TRect; + IconX,IconY:integer; + CurrRow:TOIPropertyGridRow; + DrawState:TPropEditDrawState; + OldFont:TFont; + + procedure DrawTreeIcon(x,y:integer;Plus:boolean); + begin + with Canvas do begin + Brush.Color:=clWhite; + Pen.Color:=clBlack; + Rectangle(x,y,x+8,y+8); + MoveTo(x+2,y+4); + LineTo(x+7,y+4); + if Plus then begin + MoveTo(x+4,y+2); + LineTo(x+4,y+7); + end; + end; + end; + +// PaintRow +begin + CurrRow:=Rows[ARow]; + ARowRect:=RowRect(ARow); + NameRect:=ARowRect; + ValueRect:=ARowRect; + NameRect.Right:=SplitterX; + ValueRect.Left:=SplitterX; + IconX:=GetTreeIconX(ARow); + IconY:=((NameRect.Bottom-NameRect.Top-9) div 2)+NameRect.Top; + NameIconRect:=NameRect; + NameIconRect.Right:=IconX+Indent; + NameTextRect:=NameRect; + NameTextRect.Left:=NameIconRect.Right; + DrawState:=[]; + if ARow=FItemIndex then Include(DrawState,pedsSelected); + with Canvas do begin + // draw name background + if FBackgroundColor<>clNone then begin + Brush.Color:=FBackgroundColor; + FillRect(NameIconRect); + FillRect(NameTextRect); + end; + // draw icon + if paSubProperties in CurrRow.Editor.GetAttributes then begin + DrawTreeIcon(IconX,IconY,not CurrRow.Expanded); + end; + // draw name + OldFont:=Font; + Font:=FNameFont; + CurrRow.Editor.PropDrawName(Canvas,NameTextRect,DrawState); + Font:=OldFont; + // draw frame + Pen.Color:=cl3DDkShadow; + MoveTo(NameRect.Left,NameRect.Bottom-1); + LineTo(NameRect.Right-1,NameRect.Bottom-1); + LineTo(NameRect.Right-1,NameRect.Top-1); + if ARow=FItemIndex then begin + MoveTo(NameRect.Left,NameRect.Bottom-1); + LineTo(NameRect.Left,NameRect.Top); + LineTo(NameRect.Right-1,NameRect.Top); + end; + // draw value background + if FBackgroundColor<>clNone then begin + Brush.Color:=FBackgroundColor; + FillRect(ValueRect); + end; + // draw value + if ARow<>ItemIndex then begin + OldFont:=Font; + Font:=FValueFont; + CurrRow.Editor.PropDrawValue(Canvas,ValueRect,DrawState); + Font:=OldFont; + end; + // draw frame + Pen.Color:=cl3DDkShadow; + MoveTo(ValueRect.Left,ValueRect.Bottom-1); + LineTo(ValueRect.Right,ValueRect.Bottom-1); + Pen.Color:=cl3DLight; + MoveTo(ValueRect.Left,ValueRect.Bottom-1); + LineTo(ValueRect.Left,ValueRect.Top); + end; +end; + +procedure TOIPropertyGrid.Paint; +var a:integer; + SpaceRect:TRect; +begin + inherited Paint; + with Canvas do begin + // draw properties + for a:=0 to FRows.Count-1 do begin + PaintRow(a); + end; + // draw unused space below rows + SpaceRect:=Rect(BorderWidth,BorderWidth,TrackBar.Left-1,Height-BorderWidth); + Brush.Color:=FBackgroundColor; + if FRows.Count>0 then + SpaceRect.Top:=Rows[FRows.Count-1].Bottom-FTopY+BorderWidth; + FillRect(SpaceRect); + // draw border + Pen.Color:=cl3DDkShadow; + for a:=0 to BorderWidth-1 do begin + MoveTo(a,Self.Height-1-a); + LineTo(a,a); + LineTo(Self.Width-1-a,a); + end; + Pen.Color:=cl3DLight; + for a:=0 to BorderWidth-1 do begin + MoveTo(Self.Width-1-a,a); + LineTo(Self.Width-1-a,Self.Height-1-a); + LineTo(a,Self.Height-1-a); + end; + end; +end; + +function TOIPropertyGrid.RowRect(ARow:integer):TRect; +begin + Result.Left:=BorderWidth; + Result.Top:=Rows[ARow].Top-TopY+BorderWidth; + Result.Right:=TrackBar.Left-1; + Result.Bottom:=Rows[ARow].Bottom-TopY+BorderWidth; +end; + +procedure TOIPropertyGrid.SetItemsTops; +// compute row tops from row heights +// set indices of all rows +var a:integer; +begin + for a:=0 to FRows.Count-1 do + Rows[a].Index:=a; + if FRows.Count>0 then + Rows[0].Top:=0; + for a:=1 to FRows.Count-1 do + Rows[a].FTop:=Rows[a-1].Bottom; + if FRows.Count>0 then + TrackBar.Max:=Rows[FRows.Count-1].Bottom-Height + else + TrackBar.Max:=0; +end; + +procedure TOIPropertyGrid.ClearRows; +var a:integer; +begin + for a:=0 to FRows.Count-1 do begin + Rows[a].Free; + end; + FRows.Clear; +end; + +procedure TOIPropertyGrid.Clear; +begin + ClearRows; +end; + +function TOIPropertyGrid.GetRow(Index:integer):TOIPropertyGridRow; +begin + Result:=TOIPropertyGridRow(FRows[Index]); +end; + +//------------------------------------------------------------------------------ + +{ TOIPropertyGridRow } + +constructor TOIPropertyGridRow.Create(PropertyTree:TOIPropertyGrid; +PropEditor:TPropertyEditor; ParentNode:TOIPropertyGridRow); +begin + inherited Create; + // tree pointer + FTree:=PropertyTree; + FParent:=ParentNode; + FNextBrother:=nil; + FPriorBrother:=nil; + FExpanded:=false; + // child nodes + FChildCount:=0; + FFirstChild:=nil; + FLastChild:=nil; + // director + FEditor:=PropEditor; + GetLvl; + FName:=FEditor.GetName; + FTop:=0; + FHeight:=FTree.DefaultItemHeight; + Index:=-1; +end; + +destructor TOIPropertyGridRow.Destroy; +begin + if FPriorBrother<>nil then FPriorBrother.FNextBrother:=FNextBrother; + if FNextBrother<>nil then FNextBrother.FPriorBrother:=FPriorBrother; + if FParent<>nil then begin + if FParent.FFirstChild=Self then FParent.FFirstChild:=FNextBrother; + if FParent.FLastChild=Self then FParent.FLastChild:=FPriorBrother; + dec(FParent.FChildCount); + end; + if FEditor<>nil then FEditor.Free; + inherited Destroy; +end; + +procedure TOIPropertyGridRow.GetLvl; +var n:TOIPropertyGridRow; +begin + FLvl:=0; + n:=FParent; + while n<>nil do begin + inc(FLvl); + n:=n.FParent; + end; +end; + +function TOIPropertyGridRow.Bottom:integer; +begin + Result:=FTop+FHeight; +end; + +//============================================================================== + +{ TObjectInspector } + +constructor TObjectInspector.Create(AOwner: TComponent); +begin + inherited Create(AOwner); + Caption := 'Object Inspector'; + FRootComponent:=nil; + FComponentList:=TComponentSelectionList.Create; + + // combobox at top (filled with available components) + AvailCompsComboBox := TComboBox.Create (Self); + with AvailCompsComboBox do begin + Name:='AvailCompsComboBox'; + Parent:=self; + Style:=csDropDown; + OnChange:=@AvailComboBoxChange; + //Sorted:=true; + Show; + end; + + // NoteBook + NoteBook:=TNoteBook.Create(Self); + with NoteBook do begin + Name:='NoteBook'; + Parent:=Self; + Pages.Strings[0]:='Properties'; + Pages.Add('Events'); + Show; + end; + + // property grid + PropertyGrid:=TOIPropertyGrid.Create(Self); + with PropertyGrid do begin + Name:='PropertyGrid'; + Parent:=NoteBook.Page[0]; + TrackBar.Parent:=Parent; + ValueEdit.Parent:=Parent; + ValueComboBox.Parent:=Parent; + ValueButton.Parent:=Parent; + Selections:=Self.FComponentList; + Align:=alClient; + Show; + end; +end; + +procedure TObjectInspector.DoInnerResize; +var MaxX,MaxY,NewTop:integer; +begin + if Visible=false then exit; + MaxX:=ClientWidth; + MaxY:=ClientHeight-20; + + // combobox at top (filled with available components) + AvailCompsComboBox.SetBounds(0,0,MaxX-4,20); + + // notebook + NewTop:=AvailCompsComboBox.Top+AvailCompsComboBox.Height+2; + NoteBook.SetBounds(0,NewTop,MaxX-4,MaxY-NewTop); +end; + +procedure TObjectinspector.Paint; +begin + with Canvas do begin + end; +end; + +procedure TObjectinspector.SetRootComponent(Value:TComponent); +begin + if FRootComponent<>Value then begin + FRootComponent:=Value; + FillComponentComboBox; + // select root component + FComponentList.Clear; + if FRootComponent<>nil then FComponentList.Add(FRootComponent); + RefreshSelections; + end; +end; + +function TObjectinspector.ComponentToString(c:TComponent):string; +begin + Result:=c.GetNamePath+': '+c.ClassName; +end; + +procedure TObjectinspector.FillComponentComboBox; +var a:integer; +begin + AvailCompsComboBox.Items.Clear; + if FRootComponent<>nil then begin + AvailCompsComboBox.Items.AddObject( + ComponentToString(FRootComponent),FRootComponent); + AvailCompsComboBox.Text:=ComponentToString(FRootComponent); + for a:=0 to FRootComponent.ComponentCount-1 do begin + AvailCompsComboBox.Items.AddObject( + ComponentToString(FRootComponent.Components[a]), + FRootComponent.Components[a]); + end; + end; +end; + +procedure TObjectinspector.SetSelections( + const NewSelections:TComponentSelectionList); +var a:integer; +begin + FComponentList.Clear; + FComponentList.Capacity:=NewSelections.Count; + for a:=0 to NewSelections.Count-1 do + FComponentList.Add(NewSelections[a]); + RefreshSelections; +end; + +procedure TObjectinspector.RefreshSelections; +begin + if FComponentList.Count=1 then begin + AvailCompsComboBox.Text:=ComponentToString(FComponentList[0]); + end else begin + AvailCompsComboBox.Text:=''; + end; + PropertyGrid.Selections:=FComponentList; +end; + +procedure TObjectinspector.SetBounds(aLeft,aTop,aWidth,aHeight:integer); +begin + inherited SetBounds(aLeft,aTop,aWidth,aHeight); + DoInnerResize; +end; + +procedure TObjectinspector.AvailComboBoxChange(Sender:TObject); +var NewComponent:TComponent; + a:integer; +begin + if FRootComponent=nil then exit; + if AvailCompsComboBox.Text=ComponentToString(FRootComponent) then begin + FComponentList.Clear; + FComponentList.Add(FRootComponent); + RefreshSelections; + end else begin + for a:=0 to FRootComponent.ComponentCount-1 do begin + NewComponent:=FRootComponent.Components[a]; + if AvailCompsComboBox.Text=ComponentToString(NewComponent) then begin + FComponentList.Clear; + FComponentList.Add(NewComponent); + RefreshSelections; + break; + end; + end; + end; +end; + +end. + diff --git a/designer/prop_edits.pp b/designer/prop_edits.pp new file mode 100644 index 0000000000..158407bc4a --- /dev/null +++ b/designer/prop_edits.pp @@ -0,0 +1,2085 @@ +unit prop_edits; +{ + Author: Mattias Gaertner + + ToDo: + -TypInfo.GetPropList is unable to work with nil. incombatibility to delphi + -digits for floattypes -> I hope, I have guessed right + -TIntegerSet missing -> taking my own + -Save ColorDialog settings + -ColorToString missing -> taking my own + -StringToColor missing -> taking my own + -System.TypeInfo(Type) missing -> ? + -StrToInt64 has a bug. It prints infinitly "something happened" + -> taking my own + + -many more... see XXX +} + +{$mode objfpc} + +interface + +uses Classes, TypInfo, SysUtils, Forms, Controls, Graphics, StdCtrls, Buttons; + +const + MaxIdentLength: Byte = 63; + // XXX ToDo + // this variable should be fetched from consts(x).inc + // like in fcl/inc/classes.inc + srUnknown = 'unknown'; + +type + // XXX + // The IntegerSet (a set of size of an integer) + // don't if this is always valid + TIntegerSet = set of 0..SizeOf(Integer) * 8 - 1; + + TGetStringProc = procedure(const s:string) of object; + + TComponentSelectionList = class + private + FComponents:TList; + function GetItems(Index: integer): TComponent; + procedure SetItems(Index: integer; const Value: TComponent); + function GetCount: integer; + function GetCapacity:integer; + procedure SetCapacity(const NewCapacity:integer); + public + procedure Clear; + property Count:integer read GetCount; + property Capacity:integer read GetCapacity write SetCapacity; + function Add(c:TComponent):integer; + procedure Assign(SourceSelectionList:TComponentSelectionList); + property Items[Index:integer]:TComponent read GetItems write SetItems; default; + constructor Create; + destructor Destroy; override; + end; + +{ TPropertyEditor + Edits a property of a component, or list of components, selected into the + Object Inspector. The property editor is created based on the type of the + property being edited as determined by the types registered by + RegisterPropertyEditor. The Object Inspector uses a TPropertyEditor + for all modification to a property. GetName and GetValue are called to display + the name and value of the property. SetValue is called whenever the user + requests to change the value. Edit is called when the user double-clicks the + property in the Object Inspector. GetValues is called when the drop-down + list of a property is displayed. GetProperties is called when the property + is expanded to show sub-properties. AllEqual is called to decide whether or + not to display the value of the property when more than one component is + selected. + + The following are methods that can be overridden to change the behavior of + the property editor: + + Activate + Called whenever the property becomes selected in the object inspector. + This is potentially useful to allow certain property attributes to + to only be determined whenever the property is selected in the object + inspector. Only paSubProperties and paMultiSelect,returned from + GetAttributes,need to be accurate before this method is called. + Deactivate + Called whenevr the property becomes unselected in the object inspector. + AllEqual + Called whenever there is more than one component selected. If this + method returns true,GetValue is called,otherwise blank is displayed + in the Object Inspector. This is called only when GetAttributes + returns paMultiSelect. + AutoFill + Called to determine whether the values returned by GetValues can be + selected incrementally in the Object Inspector. This is called only when + GetAttributes returns paValueList. + Edit + Called when the '...' button is pressed or the property is double-clicked. + This can,for example,bring up a dialog to allow the editing the + component in some more meaningful fashion than by text (e.g. the Font + property). + GetAttributes + Returns the information for use in the Object Inspector to be able to + show the appropriate tools. GetAttributes returns a set of type + TPropertyAttributes: + paValueList: The property editor can return an enumerated list of + values for the property. If GetValues calls Proc + with values then this attribute should be set. This + will cause the drop-down button to appear to the right + of the property in the Object Inspector. + paSortList: Object Inspector to sort the list returned by + GetValues. + paSubProperties:The property editor has sub-properties that will be + displayed indented and below the current property in + standard outline format. If GetProperties will + generate property objects then this attribute should + be set. + paDialog: Indicates that the Edit method will bring up a + dialog. This will cause the '...' button to be + displayed to the right of the property in the Object + Inspector. + paMultiSelect: Allows the property to be displayed when more than + one component is selected. Some properties are not + appropriate for multi-selection (e.g. the Name + property). + paAutoUpdate: Causes the SetValue method to be called on each + change made to the editor instead of after the change + has been approved (e.g. the Caption property). + paReadOnly: Value is not allowed to change. + paRevertable: Allows the property to be reverted to the original + value. Things that shouldn't be reverted are nested + properties (e.g. Fonts) and elements of a composite + property such as set element values. + paFullWidthName:Tells the object inspector that the value does not + need to be rendered and as such the name should be + rendered the full width of the inspector. + GetComponent + Returns the Index'th component being edited by this property editor. This + is used to retrieve the components. A property editor can only refer to + multiple components when paMultiSelect is returned from GetAttributes. + GetEditLimit + Returns the number of character the user is allowed to enter for the + value. The inplace editor of the object inspector will be have its + text limited set to the return value. By default this limit is 255. + GetName + Returns the name of the property. By default the value is retrieved + from the type information with all underbars replaced by spaces. This + should only be overridden if the name of the property is not the name + that should appear in the Object Inspector. + GetProperties + Should be overridden to call PropertyProc for every sub-property (or + nested property) of the property begin edited and passing a new + TPropertyEdtior for each sub-property. By default,PropertyProc is not + called and no sub-properties are assumed. TClassPropertyEditor will pass a + new property editor for each published property in a class. + TSetPropertyEditor passes a new editor for each element in the set. + GetPropType + Returns the type information pointer for the property(s) being edited. + GetValue + Returns the string value of the property. By default this returns + '(unknown)'. This should be overridden to return the appropriate value. + GetValues + Called when paValueList is returned in GetAttributes. Should call Proc + for every value that is acceptable for this property. TEnumPropertyEditor + will pass every element in the enumeration. + Initialize + Called after the property editor has been created but before it is used. + Many times property editors are created and because they are not a common + property across the entire selection they are thrown away. Initialize is + called after it is determined the property editor is going to be used by + the object inspector and not just thrown away. + SetValue(Value) + Called to set the value of the property. The property editor should be + able to translate the string and call one of the SetXxxValue methods. If + the string is not in the correct format or not an allowed value,the + property editor should generate an exception describing the problem. Set + value can ignore all changes and allow all editing of the property be + accomplished through the Edit method (e.g. the Picture property). + ListMeasureWidth(Value,Canvas,AWidth) + This is called during the width calculation phase of the drop down list + preparation. + ListMeasureHeight(Value,Canvas,AHeight) + This is called during the item/value height calculation phase of the drop + down list's render. This is very similar to TListBox's OnMeasureItem, + just slightly different parameters. + ListDrawValue(Value,Canvas,Rect,Selected) + This is called during the item/value render phase of the drop down list's + render. This is very similar to TListBox's OnDrawItem, just slightly + different parameters. + PropMeasureHeight(Value,Canvas,AHeight) + This is called during the item/property height calculation phase of the + object inspectors rows render. This is very similar to TListBox's + OnMeasureItem, just slightly different parameters. + PropDrawName(Canvas,Rect,Selected) + Called during the render of the name column of the property list. Its + functionality is very similar to TListBox's OnDrawItem,but once again + it has slightly different parameters. + PropDrawValue(Canvas,Rect,Selected) + Called during the render of the value column of the property list. Its + functionality is similar to PropDrawName. If multiple items are selected + and their values don't match this procedure will be passed an empty + value. + + Properties and methods useful in creating a new TPropertyEditor classes: + + Name property + Returns the name of the property returned by GetName + PrivateEditory property + It is either the .EXE or the "working editory" as specified in + the registry under the key: + "HKEY_CURRENT_USER\Software\Borland\Delphi\*\Globals\PrivateDir" + If the property editor needs auxiliary or state files (templates, + examples, etc) they should be stored in this editory. + Value property + The current value,as a string,of the property as returned by GetValue. + Modified + Called to indicate the value of the property has been modified. Called + automatically by the SetXxxValue methods. If you call a TProperty + SetXxxValue method directly,you *must* call Modified as well. + GetXxxValue + Gets the value of the first property in the Properties property. Calls + the appropriate TProperty GetXxxValue method to retrieve the value. + SetXxxValue + Sets the value of all the properties in the Properties property. Calls + the approprate TProperty SetXxxxValue methods to set the value. + GetVisualValue + This function will return the displayable value of the property. If + only one item is selected or all the multi-selected items have the same + property value then this function will return the actual property value. + Otherwise this function will return an empty string.} + + TPropertyAttribute=(paValueList,paSubProperties,paDialog,paMultiSelect, + paAutoUpdate,paSortList,paReadOnly,paRevertable,paFullWidthName); + TPropertyAttributes=set of TPropertyAttribute; + + TPropertyEditor=class; + + TInstProp=record + Instance:TPersistent; + PropInfo:PPropInfo; + end; + + PInstPropList=^TInstPropList; + TInstPropList=array[0..1023] of TInstProp; + + TGetPropEditProc=procedure(Prop:TPropertyEditor) of object; + + TPropEditDrawStateType = (pedsSelected, pedsFocused, pedsInEdit, + pedsInComboList); + TPropEditDrawState = set of TPropEditDrawStateType; + + TPropertyEditor=class + private + // XXX + //FDesigner:IFormDesigner; + FComponents:TComponentSelectionList; + FPropList:PInstPropList; + FPropCount:Integer; + function GetPrivateDirectory:string; + procedure SetPropEntry(Index:Integer; AInstance:TPersistent; + APropInfo:PPropInfo); + protected + // XXX these functions could be transfered to the TComponentInterface + function GetPropInfo:PPropInfo; + function GetFloatValue:Extended; + function GetFloatValueAt(Index:Integer):Extended; + function GetInt64Value:Int64; + function GetInt64ValueAt(Index:Integer):Int64; + function GetMethodValue:TMethod; + function GetMethodValueAt(Index:Integer):TMethod; + function GetOrdValue:Longint; + function GetOrdValueAt(Index:Integer):Longint; + function GetStrValue:string; + function GetStrValueAt(Index:Integer):string; + function GetVarValue:Variant; + function GetVarValueAt(Index:Integer):Variant; + procedure SetFloatValue(NewValue:Extended); + procedure SetMethodValue(const NewValue:TMethod); + procedure SetInt64Value(NewValue:Int64); + procedure SetOrdValue(NewValue:Longint); + procedure SetStrValue(const NewValue:string); + procedure SetVarValue(const NewValue:Variant); + procedure Modified; + public + constructor Create({const ADesigner:IFormDesigner;} + ComponentList:TComponentSelectionList; APropCount:Integer); virtual; + destructor Destroy; override; + procedure Activate; virtual; + procedure Deactivate; virtual; + function AllEqual:Boolean; virtual; + function AutoFill:Boolean; virtual; + procedure Edit; virtual; + function GetAttributes:TPropertyAttributes; virtual; + function GetComponent(Index:Integer):TPersistent; + function GetEditLimit:Integer; virtual; + function GetName:string; virtual; + procedure GetProperties(Proc:TGetPropEditProc); virtual; + function GetPropType:PTypeInfo; + function GetValue:string; virtual; + function GetVisualValue:string; + procedure GetValues(Proc:TGetStringProc); virtual; + procedure Initialize; virtual; + procedure Revert; + procedure SetValue(const NewValue:string); virtual; + function ValueAvailable:Boolean; + procedure ListMeasureWidth(const NewValue:string; Index:integer; + ACanvas:TCanvas; var AWidth:Integer); dynamic; + procedure ListMeasureHeight(const NewValue:string; Index:integer; + ACanvas:TCanvas; var AHeight:Integer); dynamic; + procedure ListDrawValue(const NewValue:string; Index:integer; + ACanvas:TCanvas; const ARect:TRect; State: TPropEditDrawState); dynamic; + procedure PropMeasureHeight(const NewValue:string; ACanvas:TCanvas; + var AHeight:Integer); dynamic; + procedure PropDrawName(ACanvas:TCanvas; const ARect:TRect; + State:TPropEditDrawState); dynamic; + procedure PropDrawValue(ACanvas:TCanvas; const ARect:TRect; + State:TPropEditDrawState); dynamic; + //property Designer:IFormDesigner read FDesigner; + property PrivateDirectory:string read GetPrivateDirectory; + property PropCount:Integer read FPropCount; + property Value2:string read GetValue write SetValue; + end; + + TPropertyEditorClass=class of TPropertyEditor; + +{ TOrdinalPropertyEditor + The base class of all ordinal property editors. It establishes that ordinal + properties are all equal if the GetOrdValue all return the same value. } + + TOrdinalPropertyEditor = class(TPropertyEditor) + function AllEqual: Boolean; override; + function GetEditLimit: Integer; override; + end; + +{ TIntegerPropertyEditor + Default editor for all Longint properties and all subtypes of the Longint + type (i.e. Integer, Word, 1..10, etc.). Restricts the value entered into + the property to the range of the sub-type. } + + TIntegerPropertyEditor = class(TOrdinalPropertyEditor) + public + function GetValue: string; override; + procedure SetValue(const NewValue: string); override; + end; + +{ TCharPropertyEditor + Default editor for all Char properties and sub-types of Char (i.e. Char, + 'A'..'Z', etc.). } + + TCharPropertyEditor = class(TOrdinalPropertyEditor) + public + function GetValue: string; override; + procedure SetValue(const Value: string); override; + end; + +{ TEnumPropertyEditor + The default property editor for all enumerated properties (e.g. TShape = + (sCircle, sTriangle, sSquare), etc.). } + + TEnumPropertyEditor = class(TOrdinalPropertyEditor) + public + function GetAttributes: TPropertyAttributes; override; + function GetValue: string; override; + procedure GetValues(Proc: TGetStringProc); override; + procedure SetValue(const Value: string); override; + end; + +{ TBoolPropertyEditor + Default property editor for all boolean properties } + + TBoolPropertyEditor = class(TEnumPropertyEditor) + function GetValue: string; override; + procedure GetValues(Proc: TGetStringProc); override; + procedure SetValue(const Value: string); override; + end; + +{ TInt64PropertyEditor + Default editor for all Int64 properties and all subtypes of Int64. } + + TInt64PropertyEditor = class(TPropertyEditor) + public + function AllEqual: Boolean; override; + function GetEditLimit: Integer; override; + function GetValue: string; override; + procedure SetValue(const Value: string); override; + end; + +{ TFloatPropertyEditor + The default property editor for all floating point types (e.g. Float, + Single, Double, etc.) } + + TFloatPropertyEditor = class(TPropertyEditor) + public + function AllEqual: Boolean; override; + function GetValue: string; override; + procedure SetValue(const Value: string); override; + end; + +{ TStringPropertyEditor + The default property editor for all strings and sub types (e.g. string, + string[20], etc.). } + + TStringPropertyEditor = class(TPropertyEditor) + public + function AllEqual: Boolean; override; + function GetEditLimit: Integer; override; + function GetValue: string; override; + procedure SetValue(const Value: string); override; + end; + +{ TNestedPropertyEditor + A property editor that uses the parent's Designer, PropList and PropCount. + The constructor and destructor do not call inherited, but all derived classes + should. This is useful for properties like the TSetElementPropertyEditor. } + + TNestedPropertyEditor = class(TPropertyEditor) + public + constructor Create(Parent: TPropertyEditor); + destructor Destroy; override; + end; + +{ TSetElementPropertyEditor + A property editor that edits an individual set element. GetName is + changed to display the set element name instead of the property name and + Get/SetValue is changed to reflect the individual element state. This + editor is created by the TSetPropertyEditor editor. } + + TSetElementPropertyEditor = class(TNestedPropertyEditor) + private + FElement: Integer; + public + constructor Create(Parent: TPropertyEditor; AElement: Integer); + function AllEqual: Boolean; override; + function GetAttributes: TPropertyAttributes; override; + function GetName: string; override; + function GetValue: string; override; + procedure GetValues(Proc: TGetStringProc); override; + procedure SetValue(const Value: string); override; + end; + +{ TSetPropertyEditor + Default property editor for all set properties. This editor does not edit + the set directly but will display sub-properties for each element of the + set. GetValue displays the value of the set in standard set syntax. } + + TSetPropertyEditor = class(TOrdinalPropertyEditor) + public + function GetAttributes: TPropertyAttributes; override; + procedure GetProperties(Proc: TGetPropEditProc); override; + function GetValue: string; override; + end; + +{ TClassPropertyEditor + Default property editor for all objects. Does not allow modifying the + property but does display the class name of the object and will allow the + editing of the object's properties as sub-properties of the property. } + + TClassPropertyEditor = class(TPropertyEditor) + public + function GetAttributes: TPropertyAttributes; override; + procedure GetProperties(Proc: TGetPropEditProc); override; + function GetValue: string; override; + end; + +{ TComponentPropertyEditor + The default editor for TComponents. It does not allow editing of the + properties of the component. It allow the user to set the value of this + property to point to a component in the same form that is type compatible + with the property being edited (e.g. the ActiveControl property). } + + TComponentPropertyEditor = class(TPropertyEditor) + public + procedure Edit; override; + function GetAttributes: TPropertyAttributes; override; + function GetEditLimit: Integer; override; + function GetValue: string; override; + procedure GetValues(Proc: TGetStringProc); override; + procedure SetValue(const Value: string); override; + end; + +{ TComponentNamePropertyEditor + Property editor for the Name property. It restricts the name property + from being displayed when more than one component is selected. } + + TComponentNamePropertyEditor = class(TStringPropertyEditor) + public + function GetAttributes: TPropertyAttributes; override; + function GetEditLimit: Integer; override; + end; + +{ TColorPropertyEditor + PropertyEditor editor for the TColor type. Displays the color as a clXXX value + if one exists, otherwise displays the value as hex. Also allows the + clXXX value to be picked from a list. } + + TColorPropertyEditor = class(TIntegerPropertyEditor) + public + procedure Edit; override; + function GetAttributes: TPropertyAttributes; override; + function GetValue: string; override; + procedure GetValues(Proc: TGetStringProc); override; + procedure SetValue(const Value: string); override; + + procedure ListMeasureWidth(const NewValue:string; Index:integer; + ACanvas:TCanvas; var AWidth:Integer); override; + procedure ListDrawValue(const NewValue:string; Index:integer; + ACanvas:TCanvas; const ARect:TRect; State: TPropEditDrawState); override; + procedure PropDrawValue(ACanvas:TCanvas; const ARect:TRect; + State:TPropEditDrawState); override; + end; + + +//============================================================================== + +{ RegisterPropertyEditor + Registers a new property editor for the given type. When a component is + selected the Object Inspector will create a property editor for each + of the component's properties. The property editor is created based on + the type of the property. If,for example,the property type is an + Integer,the property editor for Integer will be created (by default + that would be TIntegerPropertyEditor). Most properties do not need specialized + property editors. For example, if the property is an ordinal type the + default property editor will restrict the range to the ordinal subtype + range (e.g. a property of type TMyRange=1..10 will only allow values + between 1 and 10 to be entered into the property). Enumerated types will + display a drop-down list of all the enumerated values (e.g. TShapes = + (sCircle,sSquare,sTriangle) will be edited by a drop-down list containing + only sCircle,sSquare and sTriangle). A property editor need only be + created if default property editor or none of the existing property editors + are sufficient to edit the property. This is typically because the + property is an object. The properties are looked up newest to oldest. + This allows and existing property editor replaced by a custom property + editor. + + PropertyEditorType + The type information pointer returned by the TypeInfo built-in function + (e.g. TypeInfo(TMyRange) or TypeInfo(TShapes)). + + ComponentClass + Type of the component to which to restrict this type editor. This + parameter can be left nil which will mean this type editor applies to all + properties of PropertyEditorType. + + PropertyEditorName + The name of the property to which to restrict this type editor. This + parameter is ignored if ComponentClass is nil. This parameter can be + an empty string ('') which will mean that this editor applies to all + properties of PropertyEditorType in ComponentClass. + + editorClass + The class of the editor to be created whenever a property of the type + passed in PropertyEditorTypeInfo is displayed in the Object Inspector. + The class will be created by calling EditorClass.Create. } + +procedure RegisterPropertyEditor(PropertyType:PTypeInfo; + ComponentClass:TClass; const PropertyName:string; + EditorClass:TPropertyEditorClass); + +type + TPropertyEditorMapperFunc=function(Obj:TPersistent; + PropInfo:PPropInfo):TPropertyEditorClass; + +procedure RegisterPropertyEditorMapper(Mapper:TPropertyEditorMapperFunc); + +procedure GetComponentProperties(Components:TComponentSelectionList; + Filter:TTypeKinds; Proc:TGetPropEditProc); + +//procedure RegisterComponentEditor(ComponentClass:TComponentClass; +// ComponentEditor:TComponentEditorClass); + +//function GetComponentEditor(Component:TComponent; +// Designer:IFormDesigner):TComponentEditor; + + +//============================================================================== + +{ TMessageDialog + The TMessageDialog form is a simple dialog like Delphis ShowMessage +} + +type + TMessageDialog = class(TForm) + public + OkButton:TButton; + TextLabel:TLabel; + procedure OkButtonClick(Sender:TObject); + constructor Create(AOwner: TComponent); override; + end; + +procedure ShowMessageDialog(const s:string); + +//============================================================================== + +implementation + +uses Dialogs, Math; + +//============================================================================== + +procedure ShowMessageDialog(const s:string); +var MessageDialog:TMessageDialog; +begin + MessageDialog:=TMessageDialog.Create(Application); + MessageDialog.TextLabel.Caption:=s; + try + MessageDialog.ShowModal; + finally + MessageDialog.Free; + end; +end; + +constructor TMessageDialog.Create(AOwner: TComponent); +begin + inherited Create(AOwner); + //Position:=poFormCenter; + Width:=400; + Height:=100; + // OkButton + OkButton:=TButton.Create(Self); + with OkButton do begin + Name:='OkButton'; + Parent:=Self; + Caption:='OK'; + SetBounds(150,70,100,20); + OnClick:=@OkButtonClick; + Show; + end; + // TextLabel + TextLabel:=TLabel.Create(Self); + with TextLabel do begin + Name:='TextLabel'; + Parent:=Self; + WordWrap:=true; + SetBounds(10,10,380,20); + Show; + end; +end; + +procedure TMessageDialog.OkButtonClick(Sender:TObject); +begin + ModalResult:=1; +end; + +//============================================================================== + +const +{ TypeKinds see typinfo.pp + TTypeKind = (tkUnknown,tkInteger,tkChar,tkEnumeration, + tkFloat,tkSet,tkMethod,tkSString,tkLString,tkAString, + tkWString,tkVariant,tkArray,tkRecord,tkInterface, + tkClass,tkObject,tkWChar,tkBool,tkInt64,tkQWord); +} + + PropClassMap:array[TypInfo.TTypeKind] of TPropertyEditorClass=( + nil, // tkUnknown + TIntegerPropertyEditor,// tkInteger + TCharpropertyEditor, // tkChar + TEnumPropertyEditor, // tkEnumeration + TFloatPropertyEditor, // tkFloat + TSetPropertyEditor, // tkSet + nil, // tkMethod + TStringPropertyEditor, // tkSString + TStringPropertyEditor, // tkLString + TStringPropertyEditor, // tkAString + TStringPropertyEditor, // tkWString + TPropertyEditor, // tkVariant + nil, // tkArray + nil, // tkRecord + nil, // tkInterface + TClassPropertyEditor, // tkClass + nil, // tkObject + TPropertyEditor, // tkWChar + TBoolPropertyEditor, // tkBool + TInt64PropertyEditor, // tkInt64 + nil // tkQWord + ); + +// XXX ToDo: These variables/functions have bugs. Thus I provide my own ------ + +function StrToInt64(const s:string):int64; +var p:integer; + negated:boolean; +begin + p:=1; + while (p<=length(s)) and (s[p]=' ') do inc(p); + if (p<=length(s)) and (s[p]='-') then begin + negated:=true; + inc(p); + while (p<=length(s)) and (s[p]=' ') do inc(p); + end else begin + negated:=false; + end; + Result:=0; + while (p<=length(s)) and (s[p]>='0') and (s[p]<='9') do begin + Result:=Result*10+ord(s[p])-ord('0'); + inc(p); + end; + if negated then Result:=-Result; +end; + +// XXX ToDo: These variables/functions should be moved to graphics.pp ------ + +{ Color mapping routines } + +const + Colors: array[0..41] of TIdentMapEntry = ( + (Value: clBlack; Name: 'clBlack'), + (Value: clMaroon; Name: 'clMaroon'), + (Value: clGreen; Name: 'clGreen'), + (Value: clOlive; Name: 'clOlive'), + (Value: clNavy; Name: 'clNavy'), + (Value: clPurple; Name: 'clPurple'), + (Value: clTeal; Name: 'clTeal'), + (Value: clGray; Name: 'clGray'), + (Value: clSilver; Name: 'clSilver'), + (Value: clRed; Name: 'clRed'), + (Value: clLime; Name: 'clLime'), + (Value: clYellow; Name: 'clYellow'), + (Value: clBlue; Name: 'clBlue'), + (Value: clFuchsia; Name: 'clFuchsia'), + (Value: clAqua; Name: 'clAqua'), + (Value: clWhite; Name: 'clWhite'), + (Value: clScrollBar; Name: 'clScrollBar'), + (Value: clBackground; Name: 'clBackground'), + (Value: clActiveCaption; Name: 'clActiveCaption'), + (Value: clInactiveCaption; Name: 'clInactiveCaption'), + (Value: clMenu; Name: 'clMenu'), + (Value: clWindow; Name: 'clWindow'), + (Value: clWindowFrame; Name: 'clWindowFrame'), + (Value: clMenuText; Name: 'clMenuText'), + (Value: clWindowText; Name: 'clWindowText'), + (Value: clCaptionText; Name: 'clCaptionText'), + (Value: clActiveBorder; Name: 'clActiveBorder'), + (Value: clInactiveBorder; Name: 'clInactiveBorder'), + (Value: clAppWorkSpace; Name: 'clAppWorkSpace'), + (Value: clHighlight; Name: 'clHighlight'), + (Value: clHighlightText; Name: 'clHighlightText'), + (Value: clBtnFace; Name: 'clBtnFace'), + (Value: clBtnShadow; Name: 'clBtnShadow'), + (Value: clGrayText; Name: 'clGrayText'), + (Value: clBtnText; Name: 'clBtnText'), + (Value: clInactiveCaptionText; Name: 'clInactiveCaptionText'), + (Value: clBtnHighlight; Name: 'clBtnHighlight'), + (Value: cl3DDkShadow; Name: 'cl3DDkShadow'), + (Value: cl3DLight; Name: 'cl3DLight'), + (Value: clInfoText; Name: 'clInfoText'), + (Value: clInfoBk; Name: 'clInfoBk'), + (Value: clNone; Name: 'clNone')); + +function ColorToIdent(Color: Longint; var Ident: AnsiString): Boolean; +begin + Result := IntToIdent(Color, Ident, Colors); +end; + +function IdentToColor(const Ident: string; var Color: Longint): Boolean; +begin + Result := IdentToInt(Ident, Color, Colors); +end; + +{function ColorToRGB(Color: TColor): Longint; +begin + if Color < 0 then + Result := GetSysColor(Color and $000000FF) else + Result := Color; +end;} + +function ColorToString(Color: TColor): AnsiString; +begin + if not ColorToIdent(Color, Result) then + Result:='$'+HexStr(Color,8); +end; + +function StringToColor(const S: string): TColor; +begin + if not IdentToColor(S, Longint(Result)) then + Result := TColor(StrToInt(S)); +end; + +procedure GetColorValues(Proc: TGetStringProc); +var + I: Integer; +begin + for I := Low(Colors) to High(Colors) do Proc(Colors[I].Name); +end; + +// ----------------------------------------------------------- + +var + PropertyEditorMapperList:TList; + PropertyClassList:TList; + +type + PPropertyClassRec=^TPropertyClassRec; + TPropertyClassRec=record + // XXX + //Group:Integer; + PropertyType:PTypeInfo; + PropertyName:string; + ComponentClass:TClass; + EditorClass:TPropertyEditorClass; + end; + + PPropertyEditorMapperRec=^TPropertyEditorMapperRec; + TPropertyEditorMapperRec=record + // XXX + //Group:Integer; + Mapper:TPropertyEditorMapperFunc; + end; + +{ TPropInfoList } + +type + TPropInfoList=class + private + FList:PPropList; + FCount:Integer; + FSize:Integer; + function Get(Index:Integer):PPropInfo; + public + constructor Create(Instance:TPersistent; Filter:TTypeKinds); + destructor Destroy; override; + function Contains(P:PPropInfo):Boolean; + procedure Delete(Index:Integer); + procedure Intersect(List:TPropInfoList); + property Count:Integer read FCount; + property Items[Index:Integer]:PPropInfo read Get; default; + end; + +constructor TPropInfoList.Create(Instance:TPersistent; Filter:TTypeKinds); +var AllSize:integer; + TypeInfo : PTypeInfo; +begin + TypeInfo:=Instance.ClassInfo; + + // get filtered count + // XXX, Delphi can do this easier. Must talk to typinfo developer... + AllSize:=GetTypeData(TypeInfo)^.Propcount * SizeOf(Pointer); + GetMem(FList,AllSize); + FCount:=GetPropList(TypeInfo,Filter,FList); + FreeMem(FList,AllSize); + + // get PropInfoList + FSize:=FCount * SizeOf(Pointer); + GetMem(FList,FSize); + GetPropList(TypeInfo,Filter,FList); +end; + +destructor TPropInfoList.Destroy; +begin + if FList<>nil then FreeMem(FList,FSize); +end; + +function TPropInfoList.Contains(P:PPropInfo):Boolean; +var + I:Integer; +begin + for I:=0 to FCount-1 do begin + with FList^[I]^ do begin + if (PropType^.Kind=P^.PropType^.Kind) + and (CompareText(Name,P^.Name)=0) then begin + Result:=True; + Exit; + end; + end; + end; + Result:=False; +end; + +procedure TPropInfoList.Delete(Index:Integer); +begin + Dec(FCount); + if Index < FCount then + Move(FList^[Index+1],FList^[Index], + (FCount-Index) * SizeOf(Pointer)); +end; + +function TPropInfoList.Get(Index:Integer):PPropInfo; +begin + Result:=FList^[Index]; +end; + +procedure TPropInfoList.Intersect(List:TPropInfoList); +var + I:Integer; +begin + for I:=FCount-1 downto 0 do + if not List.Contains(FList^[I]) then Delete(I); +end; + +{ GetComponentProperties } + +procedure RegisterPropertyEditor(PropertyType:PTypeInfo; +ComponentClass:TClass; const PropertyName:string; +EditorClass:TPropertyEditorClass); +var + P:PPropertyClassRec; +begin + if PropertyClassList=nil then + PropertyClassList:=TList.Create; + New(P); + // XXX + //P^.Group:=CurrentGroup; + P^.PropertyType:=PropertyType; + P^.ComponentClass:=ComponentClass; + P^.PropertyName:=''; + if Assigned(ComponentClass) then P^.PropertyName:=PropertyName; + P^.EditorClass:=EditorClass; + PropertyClassList.Insert(0,P); +end; + +procedure RegisterPropertyEditorMapper(Mapper:TPropertyEditorMapperFunc); +var + P:PPropertyEditorMapperRec; +begin + if PropertyEditorMapperList=nil then + PropertyEditorMapperList:=TList.Create; + New(P); + // XXX + //P^.Group:=CurrentGroup; + P^.Mapper:=Mapper; + PropertyEditorMapperList.Insert(0,P); +end; + +function GetEditorClass(PropInfo:PPropInfo; + Obj:TPersistent):TPropertyEditorClass; +var + PropType:PTypeInfo; + P,C:PPropertyClassRec; + I:Integer; +begin + if PropertyEditorMapperList<>nil then begin + for I:=0 to PropertyEditorMapperList.Count-1 do begin + with PPropertyEditorMapperRec(PropertyEditorMapperList[I])^ do begin + Result:=Mapper(Obj,PropInfo); + if Result<>nil then Exit; + end; + end; + end; + PropType:=PropInfo^.PropType; + I:=0; + C:=nil; + while I < PropertyClassList.Count do begin + P:=PropertyClassList[I]; + + if ((P^.PropertyType=PropType) or + ((P^.PropertyType^.Kind=PropType^.Kind) and + (P^.PropertyType^.Name=PropType^.Name) + ) + ) or + ( (PropType^.Kind=tkClass) and + (P^.PropertyType^.Kind=tkClass) and + GetTypeData(PropType)^.ClassType.InheritsFrom(GetTypeData(P^.PropertyType)^.ClassType) + ) then + if ((P^.ComponentClass=nil) or (Obj.InheritsFrom(P^.ComponentClass))) and + ((P^.PropertyName='') or (CompareText(PropInfo^.Name,P^.PropertyName)=0)) then + if (C=nil) or // see if P is better match than C + ((C^.ComponentClass=nil) and (P^.ComponentClass<>nil)) or + ((C^.PropertyName='') and (P^.PropertyName<>'')) + or // P's proptype match is exact,but C's isn't + ((C^.PropertyType<>PropType) and (P^.PropertyType=PropType)) + or // P's proptype is more specific than C's proptype + ((P^.PropertyType<>C^.PropertyType) and + (P^.PropertyType^.Kind=tkClass) and + (C^.PropertyType^.Kind=tkClass) and + GetTypeData(P^.PropertyType)^.ClassType.InheritsFrom( + GetTypeData(C^.PropertyType)^.ClassType)) + or // P's component class is more specific than C's component class + ((P^.ComponentClass<>nil) and (C^.ComponentClass<>nil) and + (P^.ComponentClass<>C^.ComponentClass) and + (P^.ComponentClass.InheritsFrom(C^.ComponentClass))) then + C:=P; + Inc(I); + end; + if C<>nil then + Result:=C^.EditorClass else + Result:=PropClassMap[PropType^.Kind]; +end; + +procedure GetComponentProperties(Components:TComponentSelectionList; + Filter:TTypeKinds; Proc:TGetPropEditProc); +var + I,J,CompCount:Integer; + CompType:TClass; + Candidates:TPropInfoList; + PropLists:TList; + Editor:TPropertyEditor; + DirClass:TPropertyEditorClass; + PropInfo:PPropInfo; + AddEditor:Boolean; + Obj:TPersistent; +begin + if (Components=nil) or (Components.Count=0) then Exit; + CompCount:=Components.Count; + Obj:=Components[0]; + CompType:=Components[0].ClassType; + Candidates:=TPropInfoList.Create(Components[0],Filter); + try + for I:=Candidates.Count-1 downto 0 do begin + PropInfo:=Candidates[I]; + DirClass:=GetEditorClass(PropInfo,Obj); + if DirClass=nil then + Candidates.Delete(I) + else begin + Editor:=DirClass.Create(Components,1); + try + Editor.SetPropEntry(0,Components[0],PropInfo); + Editor.Initialize; + with PropInfo^ do + if (GetProc=nil) + or ((PropType^.Kind<>tkClass) and (SetProc=nil)) + or ((CompCount > 1) and not (paMultiSelect in Editor.GetAttributes)) + or (not Editor.ValueAvailable) then + Candidates.Delete(I); + finally + Editor.Free; + end; + end; + end; + PropLists:=TList.Create; + try + PropLists.Capacity:=CompCount; + for I:=0 to CompCount-1 do + PropLists.Add(TPropInfoList.Create(Components[I],Filter)); + for I:=0 to CompCount-1 do + Candidates.Intersect(TPropInfoList(PropLists[I])); + for I:=0 to CompCount-1 do + TPropInfoList(PropLists[I]).Intersect(Candidates); + for I:=0 to Candidates.Count-1 do begin + DirClass:=GetEditorClass(Candidates[I],Obj); + if DirClass=nil then continue; + Editor:=DirClass.Create(Components,CompCount); + try + AddEditor:=true; + for j:=0 to CompCount-1 do begin + if (Components[j].ClassType<>CompType) and + (GetEditorClass(TPropInfoList(PropLists[j])[I],Components[j]) + <>Editor.ClassType) then + begin + AddEditor:=false; + break; + end; + Editor.SetPropEntry(J,Components[J], + TPropInfoList(PropLists[J])[I]); + end; + except + Editor.Free; + raise; + end; + if AddEditor then + begin + Editor.Initialize; + if Editor.ValueAvailable then + Proc(Editor) else + Editor.Free; + end + else Editor.Free; + end; + finally + for I:=0 to PropLists.Count-1 do TPropInfoList(PropLists[I]).Free; + PropLists.Free; + end; + finally + Candidates.Free; + end; +end; + +{ TPropertyEditor } + +constructor TPropertyEditor.Create({const ADesigner:IFormDesigner;} + ComponentList:TComponentSelectionList; APropCount:Integer); +begin + // XXX + //FDesigner:=ADesigner; + FComponents:=ComponentList; + GetMem(FPropList,APropCount * SizeOf(TInstProp)); + FPropCount:=APropCount; +end; + +destructor TPropertyEditor.Destroy; +begin + if FPropList<>nil then + FreeMem(FPropList,FPropCount * SizeOf(TInstProp)); +end; + +procedure TPropertyEditor.Activate; +begin + // +end; + +procedure TPropertyEditor.Deactivate; +begin + // +end; + +function TPropertyEditor.AllEqual:Boolean; +begin + Result:=FPropCount=1; +end; + +procedure TPropertyEditor.Edit; +type + TGetStrFunc=function(const Value:string):Integer of object; +var + I:Integer; + Values:TStringList; + AddValue:TGetStrFunc; +begin + if not AutoFill then Exit; + Values:=TStringList.Create; + Values.Sorted:=paSortList in GetAttributes; + try + AddValue:=@Values.Add; + GetValues(TGetStringProc(AddValue)); + if Values.Count > 0 then begin + I:=Values.IndexOf(Value2)+1; + if I=Values.Count then I:=0; + Value2:=Values[I]; + end; + finally + Values.Free; + end; +end; + +function TPropertyEditor.AutoFill:Boolean; +begin + Result:=True; +end; + +function TPropertyEditor.GetAttributes:TPropertyAttributes; +begin + Result:=[paMultiSelect,paRevertable]; +end; + +function TPropertyEditor.GetComponent(Index:Integer):TPersistent; +begin + Result:=FPropList^[Index].Instance; +end; + +function TPropertyEditor.GetFloatValue:Extended; +begin + Result:=GetFloatValueAt(0); +end; + +function TPropertyEditor.GetFloatValueAt(Index:Integer):Extended; +begin + with FPropList^[Index] do Result:=GetFloatProp(Instance,PropInfo); +end; + +function TPropertyEditor.GetMethodValue:TMethod; +begin + Result:=GetMethodValueAt(0); +end; + +function TPropertyEditor.GetMethodValueAt(Index:Integer):TMethod; +begin + with FPropList^[Index] do Result:=GetMethodProp(Instance,PropInfo); +end; + +function TPropertyEditor.GetEditLimit:Integer; +begin + Result:=255; +end; + +function TPropertyEditor.GetName:string; +begin + Result:=FPropList^[0].PropInfo^.Name; +end; + +function TPropertyEditor.GetOrdValue:Longint; +begin + Result:=GetOrdValueAt(0); +end; + +function TPropertyEditor.GetOrdValueAt(Index:Integer):Longint; +begin + with FPropList^[Index] do Result:=GetOrdProp(Instance,PropInfo); +end; + +function TPropertyEditor.GetPrivateDirectory:string; +begin + Result:=''; + // XXX + //if Designer<>nil then + // Result:=Designer.GetPrivateDirectory; +end; + +procedure TPropertyEditor.GetProperties(Proc:TGetPropEditProc); +begin + // +end; + +function TPropertyEditor.GetPropInfo:PPropInfo; +begin + Result:=FPropList^[0].PropInfo; +end; + +function TPropertyEditor.GetPropType:PTypeInfo; +begin + Result:=FPropList^[0].PropInfo^.PropType; +end; + +function TPropertyEditor.GetStrValue:string; +begin + Result:=GetStrValueAt(0); +end; + +function TPropertyEditor.GetStrValueAt(Index:Integer):string; +begin + with FPropList^[Index] do Result:=GetStrProp(Instance,PropInfo); +end; + +function TPropertyEditor.GetVarValue:Variant; +begin + Result:=GetVarValueAt(0); +end; + +function TPropertyEditor.GetVarValueAt(Index:Integer):Variant; +begin + with FPropList^[Index] do Result:=GetVariantProp(Instance,PropInfo); +end; + +function TPropertyEditor.GetValue:string; +begin + Result:=srUnknown; +end; + +function TPropertyEditor.GetVisualValue:string; +begin + if AllEqual then + Result:=GetValue + else + Result:=''; +end; + +procedure TPropertyEditor.GetValues(Proc:TGetStringProc); +begin +end; + +procedure TPropertyEditor.Initialize; +begin + // +end; + +procedure TPropertyEditor.Modified; +begin + // XXX + //if Designer<>nil then + // Designer.Modified; +end; + +procedure TPropertyEditor.SetFloatValue(NewValue:Extended); +var + I:Integer; +begin + for I:=0 to FPropCount-1 do + with FPropList^[I] do SetFloatProp(Instance,PropInfo,NewValue); + Modified; +end; + +procedure TPropertyEditor.SetMethodValue(const NewValue:TMethod); +var + I:Integer; +begin + for I:=0 to FPropCount-1 do + with FPropList^[I] do SetMethodProp(Instance,PropInfo,NewValue); + Modified; +end; + +procedure TPropertyEditor.SetOrdValue(NewValue:Longint); +var + I:Integer; +begin + for I:=0 to FPropCount-1 do + with FPropList^[I] do SetOrdProp(Instance,PropInfo,NewValue); + Modified; +end; + +procedure TPropertyEditor.SetPropEntry(Index:Integer; + AInstance:TPersistent; APropInfo:PPropInfo); +begin + with FPropList^[Index] do + begin + Instance:=AInstance; + PropInfo:=APropInfo; + end; +end; + +procedure TPropertyEditor.SetStrValue(const NewValue:string); +var + I:Integer; +begin + for I:=0 to FPropCount-1 do + with FPropList^[I] do SetStrProp(Instance,PropInfo,NewValue); + Modified; +end; + +procedure TPropertyEditor.SetVarValue(const NewValue:Variant); +var + I:Integer; +begin + for I:=0 to FPropCount-1 do + with FPropList^[I] do SetVariantProp(Instance,PropInfo,NewValue); + Modified; +end; + +procedure TPropertyEditor.Revert; +//var I:Integer; +begin + //if Designer<>nil then + // for I:=0 to FPropCount-1 do + // with FPropList^[I] do Designer.Revert(Instance,PropInfo); +end; + +procedure TPropertyEditor.SetValue(const NewValue:string); +begin +end; + +function TPropertyEditor.ValueAvailable:Boolean; +var + I:Integer; +begin + Result:=True; + for I:=0 to FPropCount-1 do + begin + if (FPropList^[I].Instance is TComponent) and + (csCheckPropAvail in TComponent(FPropList^[I].Instance).ComponentStyle) then + begin + try + GetValue; + AllEqual; + except + Result:=False; + end; + Exit; + end; + end; +end; + +function TPropertyEditor.GetInt64Value:Int64; +begin + Result:=GetInt64ValueAt(0); +end; + +function TPropertyEditor.GetInt64ValueAt(Index:Integer):Int64; +begin + with FPropList^[Index] do Result:=GetInt64Prop(Instance,PropInfo); +end; + +procedure TPropertyEditor.SetInt64Value(NewValue:Int64); +var + I:Integer; +begin + for I:=0 to FPropCount-1 do + with FPropList^[I] do SetInt64Prop(Instance,PropInfo,NewValue); + Modified; +end; + +{ these three procedures implement the default render behavior of the + object/property inspector's drop down list editor. You don't need to + override the two measure procedures if the default width or height don't + need to be changed. } +procedure TPropertyEditor.ListMeasureHeight(const NewValue:string; +Index:integer; ACanvas:TCanvas; var AHeight:Integer); +begin + // +end; + +procedure TPropertyEditor.ListMeasureWidth(const NewValue:string; Index:integer; + ACanvas:TCanvas; var AWidth:Integer); +begin + // +end; + +procedure TPropertyEditor.ListDrawValue(const NewValue:string; Index:integer; + ACanvas:TCanvas; const ARect:TRect; State: TPropEditDrawState); +var TextY:integer; +begin + TextY:=((ARect.Bottom-ARect.Top-abs(ACanvas.Font.Height)) div 2)+ARect.Top-1; + if ACanvas.Brush.Color<>clNone then + ACanvas.FillRect(ARect); + // XXX Todo: clipping + ACanvas.TextOut(ARect.Left+1,TextY,NewValue); +end; + +{ these three procedures implement the default render behavior of the + object/property inspector. You don't need to override the measure procedure + if the default width or height don't need to be changed. } +procedure TPropertyEditor.PropMeasureHeight(const NewValue:string; + ACanvas:TCanvas; var AHeight:Integer); +begin + // +end; + +procedure TPropertyEditor.PropDrawName(ACanvas:TCanvas; const ARect:TRect; + State:TPropEditDrawState); +var TextY:integer; +begin + TextY:=((ARect.Bottom-ARect.Top-abs(ACanvas.Font.Height)) div 2)+ARect.Top-5; + // XXX Todo: clipping + ACanvas.TextOut(ARect.Left+2,TextY,GetName); +end; + +procedure TPropertyEditor.PropDrawValue(ACanvas:TCanvas; const ARect:TRect; + State:TPropEditDrawState); +var TextY:integer; +begin + TextY:=((ARect.Bottom-ARect.Top-abs(ACanvas.Font.Height)) div 2)+ARect.Top-5; + // XXX Todo: clipping + ACanvas.TextOut(ARect.Left+2,TextY,GetVisualValue) +end; + +{ TOrdinalPropertyEditor } + +function TOrdinalPropertyEditor.AllEqual: Boolean; +var + I: Integer; + V: Longint; +begin + Result := False; + if PropCount > 1 then + begin + V := GetOrdValue; + for I := 1 to PropCount - 1 do + if GetOrdValueAt(I) <> V then Exit; + end; + Result := True; +end; + +function TOrdinalPropertyEditor.GetEditLimit: Integer; +begin + Result := 63; +end; + + +{ TIntegerPropertyEditor } + +function TIntegerPropertyEditor.GetValue: string; +begin + with GetTypeData(GetPropType)^ do + if OrdType = otULong then // unsigned + Result := IntToStr(Cardinal(GetOrdValue)) + else + Result := IntToStr(GetOrdValue); +end; + +procedure TIntegerPropertyEditor.SetValue(const NewValue: String); + + procedure Error(const Args: array of const); + begin + // XXX + {raise EPropertyError.CreateResFmt(@SOutOfRange, Args);} + end; + +var + L: Int64; +begin + L := StrToInt64(NewValue); + with GetTypeData(GetPropType)^ do + if OrdType = otULong then + begin // unsigned compare and reporting needed + if (L < Cardinal(MinValue)) or (L > Cardinal(MaxValue)) then begin + // bump up to Int64 to get past the %d in the format string + Error([Int64(Cardinal(MinValue)), Int64(Cardinal(MaxValue))]); + exit; + end + end + else if (L < MinValue) or (L > MaxValue) then begin + Error([MinValue, MaxValue]); + exit; + end; + SetOrdValue(L); +end; + +{ TCharPropertyEditor } + +function TCharPropertyEditor.GetValue: string; +var + Ch: Char; +begin + Ch := Chr(GetOrdValue); + if Ch in [#33..#127] then + Result := Ch + else + Result:='#'+IntToStr(Ord(Ch)); +end; + +procedure TCharPropertyEditor.SetValue(const Value: string); +var + L: Longint; +begin + if Length(Value) = 0 then L := 0 else + if Length(Value) = 1 then L := Ord(Value[1]) else + if Value[1] = '#' then L := StrToInt(Copy(Value, 2, Maxint)) else begin + {raise EPropertyError.CreateRes(@SInvalidPropertyValue)}; + exit; + end; + with GetTypeData(GetPropType)^ do + if (L < MinValue) or (L > MaxValue) then begin + {raise EPropertyError.CreateResFmt(@SOutOfRange, [MinValue, MaxValue])}; + exit; + end; + SetOrdValue(L); +end; + +{ TEnumPropertyEditor } + +function TEnumPropertyEditor.GetAttributes: TPropertyAttributes; +begin + Result := [paMultiSelect, paValueList, paSortList, paRevertable]; +end; + +function TEnumPropertyEditor.GetValue: string; +var + L: Longint; +begin + L := GetOrdValue; + with GetTypeData(GetPropType)^ do + if (L < MinValue) or (L > MaxValue) then L := MaxValue; + Result := GetEnumName(GetPropType, L); +end; + +procedure TEnumPropertyEditor.GetValues(Proc: TGetStringProc); +var + I: Integer; + EnumType: PTypeInfo; +begin + EnumType := GetPropType; + with GetTypeData(EnumType)^ do + for I := MinValue to MaxValue do Proc(GetEnumName(EnumType, I)); +end; + +procedure TEnumPropertyEditor.SetValue(const Value: string); +var + I: Integer; +begin + I := GetEnumValue(GetPropType, Value); + if I < 0 then begin + {raise EPropertyError.CreateRes(@SInvalidPropertyValue)}; + exit; + end; + SetOrdValue(I); +end; + +{ TBoolPropertyEditor } + +function TBoolPropertyEditor.GetValue: string; +begin + if GetOrdValue = 0 then + Result := 'False' + else + Result := 'True'; +end; + +procedure TBoolPropertyEditor.GetValues(Proc: TGetStringProc); +begin + Proc('False'); + Proc('True'); +end; + +procedure TBoolPropertyEditor.SetValue(const Value: string); +var + I: Integer; +begin + if CompareText(Value, 'False') = 0 then + I := 0 + else if CompareText(Value, 'True') = 0 then + I := -1 + else + I := StrToInt(Value); + SetOrdValue(I); +end; + +{ TInt64PropertyEditor } + +function TInt64PropertyEditor.AllEqual: Boolean; +var + I: Integer; + V: Int64; +begin + Result := False; + if PropCount > 1 then + begin + V := GetInt64Value; + for I := 1 to PropCount - 1 do + if GetInt64ValueAt(I) <> V then Exit; + end; + Result := True; +end; + +function TInt64PropertyEditor.GetEditLimit: Integer; +begin + Result := 63; +end; + +function TInt64PropertyEditor.GetValue: string; +begin + Result := IntToStr(GetInt64Value); +end; + +procedure TInt64PropertyEditor.SetValue(const Value: string); +begin + SetInt64Value(StrToInt64(Value)); +end; + + +{ TFloatPropertyEditor } + +function TFloatPropertyEditor.AllEqual: Boolean; +var + I: Integer; + V: Extended; +begin + Result := False; + if PropCount > 1 then + begin + V := GetFloatValue; + for I := 1 to PropCount - 1 do + if GetFloatValueAt(I) <> V then Exit; + end; + Result := True; +end; + +function TFloatPropertyEditor.GetValue: string; +const + Precisions: array[TFloatType] of Integer = (7, 15, 19, 19, 19, 15, 31); +begin + Result := FloatToStrF(GetFloatValue, ffGeneral, + Precisions[GetTypeData(GetPropType)^.FloatType], 0); +end; + +procedure TFloatPropertyEditor.SetValue(const Value: string); +begin + SetFloatValue(StrToFloat(Value)); +end; + +{ TStringPropertyEditor } + +function TStringPropertyEditor.AllEqual: Boolean; +var + I: Integer; + V: string; +begin + Result := False; + if PropCount > 1 then + begin + V := GetStrValue; + for I := 1 to PropCount - 1 do + if GetStrValueAt(I) <> V then Exit; + end; + Result := True; +end; + +function TStringPropertyEditor.GetEditLimit: Integer; +begin + if GetPropType^.Kind = tkString then + Result := GetTypeData(GetPropType)^.MaxLength else + Result := 255; +end; + +function TStringPropertyEditor.GetValue: string; +begin + Result := GetStrValue; +end; + +procedure TStringPropertyEditor.SetValue(const Value: string); +begin + SetStrValue(Value); +end; + +{ TNestedPropertyEditor } + +constructor TNestedPropertyEditor.Create(Parent: TPropertyEditor); +begin + // XXX + //FDesigner := Parent.Designer; + FComponents:=Parent.FComponents; + FPropList:=Parent.FPropList; + FPropCount:=Parent.PropCount; +end; + +destructor TNestedPropertyEditor.Destroy; +begin +end; + +{ TSetElementPropertyEditor } + +constructor TSetElementPropertyEditor.Create(Parent: TPropertyEditor; + AElement: Integer); +begin + inherited Create(Parent); + FElement := AElement; +end; + +function TSetElementPropertyEditor.AllEqual: Boolean; +var + I: Integer; + S: TIntegerSet; + V: Boolean; +begin + Result := False; + if PropCount > 1 then begin + Integer(S) := GetOrdValue; + V := FElement in S; + for I := 1 to PropCount - 1 do begin + Integer(S) := GetOrdValueAt(I); + if (FElement in S) <> V then Exit; + end; + end; + Result := True; +end; + +function TSetElementPropertyEditor.GetAttributes: TPropertyAttributes; +begin + Result := [paMultiSelect, paValueList, paSortList]; +end; + +function TSetElementPropertyEditor.GetName: string; +begin + Result := GetEnumName(GetTypeData(GetPropType)^.CompType, FElement); +end; + +function TSetElementPropertyEditor.GetValue: string; +var + S: TIntegerSet; +begin + Integer(S) := GetOrdValue; + Result := BooleanIdents[FElement in S]; +end; + +procedure TSetElementPropertyEditor.GetValues(Proc: TGetStringProc); +begin + Proc(BooleanIdents[False]); + Proc(BooleanIdents[True]); +end; + +procedure TSetElementPropertyEditor.SetValue(const Value: string); +var + S: TIntegerSet; +begin + Integer(S) := GetOrdValue; + if CompareText(Value, 'True') = 0 then + Include(S, FElement) else + Exclude(S, FElement); + SetOrdValue(Integer(S)); +end; + +{ TSetPropertyEditor } + +function TSetPropertyEditor.GetAttributes: TPropertyAttributes; +begin + Result := [paMultiSelect, paSubProperties, paReadOnly, paRevertable]; +end; + +procedure TSetPropertyEditor.GetProperties(Proc: TGetPropEditProc); +var + I: Integer; +begin + with GetTypeData(GetTypeData(GetPropType)^.CompType)^ do + for I := MinValue to MaxValue do + Proc(TSetElementPropertyEditor.Create(Self, I)); +end; + +function TSetPropertyEditor.GetValue: string; +var + S: TIntegerSet; + TypeInfo: PTypeInfo; + I: Integer; +begin + Integer(S) := GetOrdValue; + TypeInfo := GetTypeData(GetPropType)^.CompType; + Result := '['; + for I := 0 to SizeOf(Integer) * 8 - 1 do + if I in S then + begin + if Length(Result) <> 1 then Result := Result + ','; + Result := Result + GetEnumName(TypeInfo, I); + end; + Result := Result + ']'; +end; + +{ TClassPropertyEditor } + +function TClassPropertyEditor.GetAttributes: TPropertyAttributes; +begin + Result := [paMultiSelect, paSubProperties, paReadOnly]; +end; + +procedure TClassPropertyEditor.GetProperties(Proc: TGetPropEditProc); +var + I: Integer; + SubComponent: TComponent; + Components: TComponentSelectionList; +begin + Components := TComponentSelectionList.Create; + try + for I := 0 to PropCount - 1 do begin + SubComponent:=TComponent(GetOrdValueAt(I)); + if SubComponent<>nil then + Components.Add(SubComponent); + end; + GetComponentProperties(Components, tkProperties, Proc); + finally + Components.Free; + end; +end; + +function TClassPropertyEditor.GetValue: string; +begin + Result:='('+GetPropType^.Name+')'; +end; + +{ TComponentPropertyEditor } + +procedure TComponentPropertyEditor.Edit; +begin + {if (GetKeyState(VK_CONTROL) < 0) and + (GetKeyState(VK_LBUTTON) < 0) and + (GetOrdValue <> 0) then begin + Designer.SelectComponent(TPersistent(GetOrdValue)) + end else} + inherited Edit; +end; + +function TComponentPropertyEditor.GetAttributes: TPropertyAttributes; +begin + Result := [paMultiSelect, paValueList, paSortList, paRevertable]; +end; + +function TComponentPropertyEditor.GetEditLimit: Integer; +begin + Result := 127; +end; + +function TComponentPropertyEditor.GetValue: string; +begin + Result := '' {Designer.GetComponentName(TComponent(GetOrdValue))}; +end; + +procedure TComponentPropertyEditor.GetValues(Proc: TGetStringProc); +begin + {Designer.GetComponentNames(GetTypeData(GetPropType), Proc);} +end; + +procedure TComponentPropertyEditor.SetValue(const Value: string); +{var Component: TComponent;} +begin + {if Value = '' then Component := nil else + begin + Component := Designer.GetComponent(Value); + if not (Component is GetTypeData(GetPropType)^.ClassType) then + raise EPropertyError.CreateRes(@SInvalidPropertyValue); + end; + SetOrdValue(Longint(Component));} +end; + +{ TComponentNamePropertyEditor } + +function TComponentNamePropertyEditor.GetAttributes: TPropertyAttributes; +begin + Result := []; +end; + +function TComponentNamePropertyEditor.GetEditLimit: Integer; +begin + Result := MaxIdentLength; +end; + +{ TColorPropertyEditor } + +procedure TColorPropertyEditor.Edit; +var + ColorDialog: TColorDialog; + {IniFile: TRegIniFile; + + procedure GetCustomColors; + begin + if BaseRegistryKey = '' then Exit; + IniFile := TRegIniFile.Create(BaseRegistryKey); + try + IniFile.ReadSectionValues(SCustomColors, ColorDialog.CustomColors); + except + // Ignore errors reading values + end; + end; + + procedure SaveCustomColors; + var + I, P: Integer; + S: string; + begin + if IniFile <> nil then + with ColorDialog do + for I := 0 to CustomColors.Count - 1 do + begin + S := CustomColors.Strings[I]; + P := Pos('=', S); + if P <> 0 then + begin + S := Copy(S, 1, P - 1); + IniFile.WriteString(SCustomColors, S, + CustomColors.Values[S]); + end; + end; + end; + } +begin + {IniFile := nil;} + ColorDialog := TColorDialog.Create(Application); + try + {GetCustomColors;} + ColorDialog.Color := GetOrdValue; + if ColorDialog.Execute then SetOrdValue(ColorDialog.Color); + {SaveCustomColors;} + finally + {IniFile.Free;} + ColorDialog.Free; + end; +end; + +function TColorPropertyEditor.GetAttributes: TPropertyAttributes; +begin + Result := [paMultiSelect, paDialog, paValueList, paRevertable]; +end; + +function TColorPropertyEditor.GetValue: string; +begin + Result := ColorToString(TColor(GetOrdValue)); +end; + +procedure TColorPropertyEditor.GetValues(Proc: TGetStringProc); +begin + GetColorValues(Proc); +end; + +procedure TColorPropertyEditor.PropDrawValue(ACanvas:TCanvas; const ARect:TRect; + State:TPropEditDrawState); +begin + if GetVisualValue <> '' then + ListDrawValue(GetVisualValue, -1, ACanvas, ARect, [pedsInComboList]) + else + inherited PropDrawValue(ACanvas, ARect, State); +end; + +procedure TColorPropertyEditor.ListDrawValue(const NewValue:string; +Index:integer; ACanvas:TCanvas; const ARect:TRect; State: TPropEditDrawState); + + function ColorToBorderColor(AColor: TColor): TColor; + type + TColorQuad = record + Red, + Green, + Blue, + Alpha: Byte; + end; + begin + if (TColorQuad(AColor).Red > 192) or + (TColorQuad(AColor).Green > 192) or + (TColorQuad(AColor).Blue > 192) then + Result := clBlack + else if pedsSelected in State then + Result := clWhite + else + Result := AColor; + end; +var + vRight: Integer; + vOldPenColor, vOldBrushColor: TColor; +begin + vRight := (ARect.Bottom - ARect.Top) {* 2} + ARect.Left; + with ACanvas do + try + // save off things + vOldPenColor := Pen.Color; + vOldBrushColor := Brush.Color; + + // frame things + Pen.Color := Brush.Color; + Rectangle(ARect.Left, ARect.Top, vRight, ARect.Bottom); + + // set things up and do the work + Brush.Color := StringToColor(NewValue); + Pen.Color := ColorToBorderColor(ColorToRGB(Brush.Color)); + Rectangle(ARect.Left + 1, ARect.Top + 1, vRight - 1, ARect.Bottom - 1); + + // restore the things we twiddled with + Brush.Color := vOldBrushColor; + Pen.Color := vOldPenColor; + finally + inherited ListDrawValue(NewValue, Index, ACanvas, + Rect(vRight, ARect.Top, ARect.Right, ARect.Bottom), + State); + end; +end; + +procedure TColorPropertyEditor.ListMeasureWidth(const NewValue:string; + Index:integer; ACanvas:TCanvas; var AWidth:Integer); +begin + AWidth := AWidth + ACanvas.TextHeight('M') {* 2}; +end; + +procedure TColorPropertyEditor.SetValue(const Value: string); +var + NewValue: Longint; +begin + if IdentToColor(Value, NewValue) then + SetOrdValue(NewValue) + else + inherited SetValue(Value); +end; + +//============================================================================== + +{ TComponentSelectionList } + +function TComponentSelectionList.Add(c: TComponent): integer; +begin + Result:=FComponents.Add(c); +end; + +procedure TComponentSelectionList.Clear; +begin + FComponents.Clear; +end; + +constructor TComponentSelectionList.Create; +begin + inherited Create; + FComponents:=TList.Create; +end; + +destructor TComponentSelectionList.Destroy; +begin + FComponents.Free; + inherited Destroy; +end; + +function TComponentSelectionList.GetCount: integer; +begin + Result:=FComponents.Count; +end; + +function TComponentSelectionList.GetItems(Index: integer): TComponent; +begin + Result:=TComponent(FComponents[Index]); +end; + +procedure TComponentSelectionList.SetItems(Index: integer; + const Value: TComponent); +begin + FComponents[Index]:=Value; +end; + +function TComponentSelectionList.GetCapacity:integer; +begin + Result:=FComponents.Capacity; +end; + +procedure TComponentSelectionList.SetCapacity(const NewCapacity:integer); +begin + FComponents.Capacity:=NewCapacity; +end; + +procedure TComponentSelectionList.Assign( + SourceSelectionList:TComponentSelectionList); +var a:integer; +begin + Clear; + if (SourceSelectionList<>nil) and (SourceSelectionList.Count>0) then begin + FComponents.Capacity:=SourceSelectionList.Count; + for a:=0 to SourceSelectionList.Count-1 do + Add(SourceSelectionList[a]); + end; +end; + + +//****************************************************************************** + +initialization + PropertyClassList:=TList.Create; + PropertyEditorMapperList:=TList.Create; + // register the standard property editors + // the System.TypeInfo(Type) is missing + //RegisterPropertyEditor(TypeInfo(TColor),nil,'',TColorPropertyEditor); + +finalization + PropertyEditorMapperList.Free; PropertyEditorMapperList:=nil; + PropertyClassList.Free; PropertyClassList:=nil; + +end. diff --git a/designer/test_obj_inspector.pp b/designer/test_obj_inspector.pp new file mode 100644 index 0000000000..94f084b7a2 --- /dev/null +++ b/designer/test_obj_inspector.pp @@ -0,0 +1,13 @@ +program test_obj_inspector; + +{$MODE OBJFPC} + +uses + classes, forms, sysutils, test_unit, object_inspector; + +begin + Application.Initialize; { calls InitProcedure which starts up GTK } + Application.CreateForm(TForm1, Form1); + Application.Run; +end. + diff --git a/designer/test_unit.pp b/designer/test_unit.pp new file mode 100644 index 0000000000..5e7af7d5c7 --- /dev/null +++ b/designer/test_unit.pp @@ -0,0 +1,424 @@ +{ + +} +{$H+} +unit test_unit; + +{$mode objfpc} + +interface + +uses + classes, stdctrls,forms,buttons,menus,comctrls,sysutils, extctrls, + object_inspector, prop_edits, graphics; + +type + TMyEnum = (MyEnum1,MyEnum2,MyEnum3); + TMySet = set of TMyEnum; + + TForm1 = class(TFORM) + public + Label1 : TLabel; + Label2 : TLabel; + Label3 : TLabel; + EditToComboButton: TButton; + AddItemButton: TButton; + ComboToEditButton: TButton; + SwitchEnabledButton: TButton; + DumpButton: TButton; + IndexButton: TButton; + OIResizeButton: TButton; + OIRefreshButton: TButton; + Edit1 : TEdit; + mnuMain: TMainMenu; + itmFileQuit: TMenuItem; + itmFile: TMenuItem; + ComboBox1 : TComboBox; + ComboBox2 : TComboBox; + Memo1 : TMemo; + constructor Create(AOwner: TComponent); override; + procedure LoadMainMenu; + procedure FormKill(Sender : TObject); + procedure FormShow(Sender : TObject); + procedure mnuQuitClicked(Sender : TObject); + protected + procedure EditToComboButtonCLick(Sender : TObject); + procedure AddItemButtonCLick(Sender : TObject); + procedure ComboToEditButtonCLick(Sender : TObject); + procedure SwitchEnabledButtonCLick(Sender : TObject); + procedure DumpButtonCLick(Sender : TObject); + procedure IndexButtonCLick(Sender : TObject); + procedure OIResizeButtonCLick(Sender : TObject); + procedure OIRefreshButtonCLick(Sender : TObject); + procedure ComboOnChange (Sender:TObject); + procedure ComboOnClick (Sender:TObject); + public + FMyInteger:integer; + FMyCardinal:Cardinal; + FMyEnum:TMyEnum; + FMySet:TMySet; + FMyFont:TFont; + FMyString:string; + FMyBool:boolean; + published + property MyInteger:integer read FMyInteger write FMyInteger; + property MyCardinal:cardinal read FMyCardinal write FMyCardinal; + property MyEnum:TMyEnum read FMyEnum write FMyEnum; + property MySet:TMySet read FMySet write FMySet; + property MyFont:TFont read FMyFont write FMyFont; + property MyString:string read FMyString write FMyString; + property MyBool:Boolean read FMyBool write FMyBool; + end; + +var + Form1 : TForm1; + OI: TObjectInspector; + +implementation + + +constructor TForm1.Create(AOwner: TComponent); +begin + inherited Create(AOwner); + FMySet:=[MyEnum1]; + FMyEnum:=MyEnum2; + FMyFont:=TFont.Create; + + Name:='Form1'; + Caption := 'Test Form'; + OI:=nil; + OnShow:=@FormShow; + LoadMainMenu; + Left:=250; + Top:=50; + if OI=nil then begin + OI:=TObjectInspector.Create(Application); + OI.Name:='OI'; + OI.SetBounds(7,50,220,700); + OI.Show; + OI.RootComponent:=Self; + end; +end; + +procedure TForm1.FormShow(Sender: TObject); +begin +end; + +procedure TForm1.OIResizeButtonClick(Sender : TObject); +begin + OI.DoInnerResize; +end; + +procedure TForm1.OIRefreshButtonClick(Sender : TObject); +begin + OI.RefreshSelections; +end; + +procedure TForm1.EditToComboButtonClick(Sender : TObject); +Begin + if assigned (ComboBox1) and assigned (edit1) then + ComboBox1.Text := edit1.text; +End; + +procedure TForm1.AddItemButtonClick(Sender : TObject); +Begin + if assigned (ComboBox1) + then Combobox1.Items.Add ('item ' + IntToStr (comboBox1.Items.Count)); + if assigned (ComboBox2) + then Combobox2.Items.Add ('item ' + IntToStr (comboBox2.Items.Count)); +End; + +procedure TForm1.ComboToEditButtonClick(Sender : TObject); +Begin + if assigned (ComboBox1) and assigned (edit1) + then edit1.Text := ComboBox1.Text; +End; + +procedure TForm1.SwitchEnabledButtonClick(Sender : TObject); +Begin + if assigned (ComboBox1) + then ComboBox1.Enabled := not ComboBox1.Enabled; +End; + +procedure TForm1.DumpButtonClick(Sender : TObject); +var + i : integer; +Begin + if assigned (ComboBox1) then + begin + i := 0; + while i < ComboBox1.Items.Count do + begin + if assigned (Memo1) + then Memo1.Lines.Add (ComboBox1.Items[i]); + inc (i); + end; + end; +End; + +procedure TForm1.IndexButtonClick(Sender : TObject); +var + s : shortstring; +Begin + if assigned (ComboBox1) then + begin + s := Format ('%x', [ComboBox1.ItemIndex]); + if assigned (Memo1) + then Memo1.Lines.Add (s); + end; +End; + +procedure TForm1.ComboOnChange (Sender:TObject); +var + s : shortstring; +begin + if sender is TEdit + then s := 'TEdit' + else if sender is TComboBox + then s := 'TComboBox' + else + s := 'UNKNOWN'; + if assigned (Memo1) + then Memo1.Lines.Add (s + 'ONChange'); +end; + +procedure TForm1.ComboOnClick (Sender:TObject); +begin + if assigned (Memo1) + then Memo1.Lines.Add ('ONClick'); +end; +{------------------------------------------------------------------------------} + +procedure TForm1.FormKill(Sender : TObject); +Begin + FMyFont.Free; + Application.terminate; +End; + +{------------------------------------------------------------------------------} +procedure TForm1.LoadMainMenu; + +begin + OnDestroy := @FormKill; + + { set the height and width } + Height := 400; + Width := 700; + + OIResizeButton:=TButton.Create(Self); + with OIResizeButton do begin + Name:='OIResizeButton'; + Parent:=Self; + SetBounds(200,10,100,40); + Caption:='Resize OI'; + OnClick:=@OIResizeButtonClick; + Show; + end; + + OIRefreshButton:=TButton.Create(Self); + with OIRefreshButton do begin + Name:='OIRefreshButton'; + Parent:=Self; + SetBounds(200,60,100,40); + Caption:='Refresh OI'; + OnClick:=@OIRefreshButtonClick; + Show; + end; + + { Create 2 buttons inside the groupbox } + EditToComboButton := TButton.Create(Self); + EditToComboButton.Name:='EditToComboButton'; + EditToComboButton.Parent := Self; + EditToComboButton.Left := 50; + EditToComboButton.Top := 80; + EditToComboButton.Width := 120; + EditToComboButton.Height := 30; + EditToComboButton.Show; + EditToComboButton.Caption := 'Edit->Combo'; + EditToComboButton.OnClick := @EditToComboButtonClick; + + AddItemButton := TButton.Create(Self); + AddItemButton.Name:='AddItemButton'; + AddItemButton.Parent := Self; + AddItemButton.Left := 50; + AddItemButton.Top := 40; + AddItemButton.Width := 120; + AddItemButton.Height := 30; + AddItemButton.Show; + AddItemButton.Caption := 'Add item'; + AddItemButton.OnClick := @AddItemButtonClick; + + { Create 2 more buttons outside the groupbox } + ComboToEditButton := TButton.Create(Self); + ComboToEditButton.Name:='ComboToEditButton'; + ComboToEditButton.Parent := Self; + ComboToEditButton.Left := 50; + ComboToEditButton.Top := 120; + ComboToEditButton.Width := 120; + ComboToEditButton.Height := 30; + ComboToEditButton.Show; + ComboToEditButton.Caption := 'Combo->Edit'; + ComboToEditButton.OnClick := @ComboToEditButtonClick; + + + SwitchEnabledButton := TButton.Create(Self); + SwitchEnabledButton.Name:='SwitchEnabledButton'; + SwitchEnabledButton.Parent := Self; + SwitchEnabledButton.Left := 50; + SwitchEnabledButton.Top := 160; + SwitchEnabledButton.Width := 120; + SwitchEnabledButton.Height := 30; + SwitchEnabledButton.Show; + SwitchEnabledButton.Caption := 'Enabled On/Off'; + SwitchEnabledButton.OnClick := @SwitchEnabledButtonClick; + + DumpButton := TButton.Create(Self); + DumpButton.Name:='DumpButton'; + DumpButton.Parent := Self; + DumpButton.Left := 50; + DumpButton.Top := 200; + DumpButton.Width := 120; + DumpButton.Height := 30; + DumpButton.Show; + DumpButton.Caption := 'Dump'; + DumpButton.OnClick := @DumpButtonClick; + + IndexButton := TButton.Create(Self); + IndexButton.Name:='IndexButton'; + IndexButton.Parent := Self; + IndexButton.Left := 50; + IndexButton.Top := 240; + IndexButton.Width := 120; + IndexButton.Height := 30; + IndexButton.Show; + IndexButton.Caption := 'Index ?'; + IndexButton.OnClick := @IndexButtonClick; + + + { Create a label for the edit field } + label1 := TLabel.Create(Self); + Label1.Name:='Label1'; + label1.Parent := self; + label1.top := 50; + label1.left := 320; + label1.Height := 20; + label1.Width := 130; + label1.Show; + label1.Caption := 'TEdit :'; + + + Edit1 := TEdit.Create (self); + with Edit1 do begin + Name := 'Edit1'; + Parent := self; + Left := 500; + Top := 50; + Width := 70; + Height := 20; + OnChange := @ComboOnChange; + OnClick := @ComboOnClick; + Show; + end; + + { Create a label for the 1st combobox } + label2 := TLabel.Create(Self); + Label2.Name:='Label2'; + label2.Parent := self; + label2.top := 100; + label2.left := 320; + label2.Height := 20; + label2.Width := 130; + label2.Enabled:= true; + label2.Show; + label2.Caption := 'Combo (unsorted)'; + label2.Enabled:= true; + + + { Create the menu now } + { WARNING: If you do it after creation of the combo, the menu will not + appear. Reason is unknown by now!!!!!!} + mnuMain := TMainMenu.Create(Self); + mnuMain.Name:='mnuMain'; + Menu := mnuMain; + itmFile := TMenuItem.Create(Self); + itmFile.Name:='itmFile'; + itmFile.Caption := '&File'; + mnuMain.Items.Add(itmFile); + itmFileQuit := TMenuItem.Create(Self); + itmFileQuit.Name:='itmFileQuit'; + itmFileQuit.Caption := '&Quit'; + itmFileQuit.OnClick := @mnuQuitClicked; + itmFile.Add(itmFileQuit); + + ComboBox1 := TComboBox.Create (self); + with ComboBox1 do + begin + Name:='ComboBox1'; + Parent := self; + Left := 500; + Top := 100; + Width := 170; + Height := 20; + Style := csDropDown; + Items.Add ('wohhh!'); + Items.Add ('22222!'); + ItemIndex := 1; + Items.Add ('33333!'); + Items.Add ('abcde!'); + OnChange := @ComboOnChange; + OnClick := @ComboOnClick; + Show; + end; + + + { Create a label for the 2nd combobox } + label3 := TLabel.Create(Self); + Label3.Name:='Label3'; + label3.Parent := self; + label3.top := 150; + label3.left := 320; + label3.Height := 20; + label3.Width := 130; + label3.Show; + label3.Caption := 'Combo (sorted)'; + + + ComboBox2 := TComboBox.Create (self); + with ComboBox2 do begin + Name:='ComboBox2'; + Parent := self; + Left := 500; + Top := 150; + Width := 170; + Height := 20; + Items.Add ('wohhh!'); + Items.Add ('22222!'); + ItemIndex := 1; + Items.Add ('33333!'); + Items.Add ('abcde!'); + Sorted := true; + Show; + end; + + Memo1 := TMemo.Create(Self); + with Memo1 do begin + Memo1.Name:='Memo1'; + Parent := Self; + Scrollbars := ssBoth; + Left := 200; + Top := 200; + Width := 335; + Height := 155; + Show; + end; +end; + +{------------------------------------------------------------------------------} +procedure TForm1.mnuQuitClicked(Sender : TObject); +begin + Application.Terminate; +end; +{------------------------------------------------------------------------------} + + +end. diff --git a/ide/customformeditor.pp b/ide/customformeditor.pp index 836e524489..5a880cf0b0 100644 --- a/ide/customformeditor.pp +++ b/ide/customformeditor.pp @@ -25,12 +25,13 @@ unit CustomFormEditor; interface uses - classes, abstractformeditor, controls,Typinfo; + classes, abstractformeditor, controls,prop_edits,Typinfo,Object_Inspector; Const OrdinalTypes = [tkInteger,tkChar,tkENumeration,tkbool]; type + { TComponentInterface is derived from TIComponentInterface. It gives access to each control that's dropped onto the form @@ -77,24 +78,22 @@ TGetProc = Function : Variant of Object; Function Select : Boolean; override; Function Focus : Boolean; override; Function Delete : Boolean; override; + property Control : TComponent read FCOntrol; end; { TCustomFormEditor - One is created whenever a "NEw Form" is created. The Form is contained in the MainControl - property. FComponentClass tells whether this container is a TFORM or a TDataModule, or - something else new. + } TControlClass = class of TControl; TCustomFormEditor = class(TAbstractFormEditor) private - FModified : Boolean; - FComponentInterfaceList : TList; //used to track and find controls - FMainControl : TComponent; //this needs to be recorded here so when a control - //is created via the CreateComponent we can use this - //to set the owner property. + FModified : Boolean; + FComponentInterfaceList : TList; //used to track and find controls + FSelectedComponents : TComponentSelectionList; + FObj_Inspector : TObjectInspector; protected public @@ -102,16 +101,25 @@ TCustomFormEditor constructor Create; destructor Destroy; override; + Function AddSelected(Value : TComponent) : Integer; Function Filename : String; override; Function FormModified : Boolean; override; Function FindComponent(const Name : String) : TIComponentInterface; override; - Function CreateComponent(CI : TIComponentInterface; TypeName : String; +// Function CreateComponent(CI : TIComponentInterface; TypeName : String; + Function CreateComponent(CI : TIComponentInterface; TypeClass : TComponentClass; X,Y,W,H : Integer): TIComponentInterface; override; - property MainControl : TComponent read FMainControl write FMainControl; + Procedure ClearSelected; + property SelectedComponents : TComponentSelectionList read FSelectedComponents write FSelectedComponents; + property Obj_Inspector : TObjectInspector read FObj_Inspector write FObj_Inspector; + end; implementation +uses + SysUtils; + + {TComponentInterface} @@ -428,14 +436,25 @@ end; constructor TCustomFormEditor.Create; begin +inherited Create; FComponentInterfaceList := TList.Create; -inherited; +FSelectedComponents := TComponentSelectionList.Create; end; destructor TCustomFormEditor.Destroy; begin -FComponentInterfaceList.Destroy; inherited; +FComponentInterfaceList.Destroy; +FSelectedComponents.Destroy; +end; + +Function TCustomFormEditor.AddSelected(Value : TComponent) : Integer; +Begin +Result := -1; +FSelectedComponents.Add(Value); +Result := FSelectedComponents.Count; +//call the OI to update it's selected. +Obj_Inspector.Selections := FSelectedComponents; end; @@ -462,28 +481,68 @@ Begin end; end; -Function TCustomFormEditor.CreateComponent(CI : TIComponentInterface; TypeName : String; +//Function TCustomFormEditor.CreateComponent(CI : TIComponentInterface; TypeName : String; +Function TCustomFormEditor.CreateComponent(CI : TIComponentInterface; TypeClass : TComponentClass; X,Y,W,H : Integer): TIComponentInterface; Var Temp : TComponentInterface; +TempInterface : TComponentInterface; +TempClass : TPersistentClass; Begin Temp := TComponentInterface.Create; -Temp.FControl := TControlClass(TypeName).Create(MainControl); +Writeln('2'); +//TempClass := GetClass(Typename); +Writeln('3'); + +if SelectedComponents.Count = 0 then +Temp.FControl := TypeClass.Create(nil) +else +Begin +Writeln('Selected Components > 0'); +if (SelectedComponents.Items[0] is TWinControl) and (csAcceptsControls in TWinControl(SelectedComponents.Items[0]).ControlStyle) then + Begin + Writeln('The Control is a TWinControl and it accepts controls'); + Writeln('SelectedComponents.Count = '+Inttostr(SelectedComponents.Count)); + Temp.FControl := TypeClass.Create(TComponent(SelectedComponents.Items[0])); + end + else + Begin + Writeln('The Control is not a TWinControl or it does not accept controls'); + Temp.FControl := TypeClass.Create(SelectedComponents.Items[0].Owner); + end; +end; + + +Writeln('4'); + if Assigned(CI) then Begin - if (TComponentInterface(CI).FControl is TWinControl) then + if (TComponentInterface(CI).FControl is TWinControl) and + (csAcceptsControls in TWinControl(TComponentInterface(CI).FControl).COntrolStyle)then begin - if (csAcceptsControls in TWinControl(TComponentInterface(CI).FControl).COntrolStyle) then - Begin //set CI the parent of the new one. - TWinControl(Temp.FControl).Parent := TWinControl(TComponentInterface(CI).FControl); - end; - end; + TWinControl(Temp.FControl).Parent := TWinControl(TComponentInterface(CI).FControl); + end + else + TWinControl(Temp.FControl).Parent := TWinControl(TComponentInterface(CI).FControl).Parent; - End; + End + else + Begin //CI is not assigned so check the selected control + if SelectedComponents.Count > 0 then + Begin + TempInterface := TComponentInterface(FindComponent(SelectedComponents.Items[0].Name)); + if (TempInterface.FControl is TWinControl) and + (csAcceptsControls in TWinControl(TempInterface.FControl).ControlStyle)then + TWinControl(Temp.FControl).Parent := TWinControl(TempInterface.FControl) + else + TWinControl(Temp.FControl).Parent := TWinControl(TempInterface.FControl).Parent; + end + end; +Writeln('5'); if (Temp.FControl is TControl) then Begin -if (X <> -1) and (Y <> -1) and (W <> -1) and (h <> -1) then +if (X <> -1) and (Y <> -1) and (W <> -1) and (H <> -1) then TControl(Temp.FControl).SetBounds(X,Y,W,H) else Begin @@ -502,9 +561,16 @@ else end; + +FComponentInterfaceList.Add(Temp); + Result := Temp; end; +Procedure TCUstomFormEditor.ClearSelected; +Begin +FSelectedComponents.Clear; +end; end. diff --git a/ide/idecomp.pp b/ide/idecomp.pp index 91983397c4..740be537bd 100644 --- a/ide/idecomp.pp +++ b/ide/idecomp.pp @@ -40,6 +40,7 @@ type private FImage : String; FClassName : String; //hold the main types classname + FClassType : TClass; procedure SetImage(Value : String); protected Function LoadImageintoPixmap : TPixmap; @@ -51,6 +52,8 @@ type Function Speedbutton(AOwner : TComponent; nParent: TWinControl): TSpeedButton; Virtual; property image : string read FImage write SetImage; property ClassName : String read FClassName write FClassName; + property ClassType : TClass read FClassType write FClassType; + end; {------------------------------------------- @@ -276,6 +279,7 @@ begin inherited create; FImage := 'images/mouse.xpm'; ClassName := 'TMOUSE'; //not really the classname for a mouse +//ClassType := TComponent; end; function TIDEMouse.CreateMethod(AOwner : TComponent): TControl; @@ -324,6 +328,7 @@ begin inherited create; FImage := 'images/menu.xpm'; FClassName := 'TMenu'; +FClassType := TMenu; end; function TIDEMenu.CreateMethod(AOwner : TComponent): TControl; diff --git a/ide/main.pp b/ide/main.pp index 9b700de88e..d76e11e888 100644 --- a/ide/main.pp +++ b/ide/main.pp @@ -31,7 +31,7 @@ uses classes,LclLinux,compiler, stdctrls,forms,buttons,menus,comctrls, Spin, project,sysutils, global, compileroptions,Controls,graphics,extctrls, Dialogs,dlgMEssage, - designerform,process,idecomp,Find_dlg; + designerform,process,idecomp,Find_dlg,FormEditor,CustomFormEditor,Object_Inspector; const STANDARDBTNCOUNT = 50; @@ -138,6 +138,9 @@ type procedure mnuSearchFindClicked(Sender : TObject); procedure mnuSearchFindAgainClicked(Sender : TObject); + procedure ClickonForm(Sender : TObject); + procedure ClickonControl(Sender : TObject); + procedure ControlClick(Sender : TObject); procedure MessageViewDblClick(Sender : TObject); procedure DesignFormMouseUp(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); @@ -185,6 +188,8 @@ const var Form1 : TForm1; +FormEditor1 : TFormEditor; +ObjectInspector1 : TObjectInspector; Taginc : Integer; implementation uses @@ -615,6 +620,14 @@ begin Compiler1 := TCompiler.Create; Compiler1.OutputString := @Messagedlg.Add; + ObjectInspector1 := TObjectInspector.Create(Self); + ObjectInspector1.left := 0; + ObjectInspector1.Top := Top+Height; + ObjectInspector1.Height := 400; + + ObjectInspector1.Show; + FormEditor1 := TFormEditor.Create; + FormEditor1.Obj_Inspector := ObjectInspector1; end; @@ -1497,6 +1510,79 @@ begin end; +{------------------------------------------------------------------------------} +{------------------------------------------------------------------------------} +{ + Used when we a control is clicked. This is used + to update the Object Inspector. +} +{------------------------------------------------------------------------------} +{------------------------------------------------------------------------------} +{------------------------------------------------------------------------------} +Procedure TForm1.ClickOnControl(Sender : TObject); +var + CInterface : TComponentInterface; +Begin +//We clicked on the form. Let's see what the active selection is in the IDE control +//bar. If it's the pointer, then we set the FormEditor1.SelectedComponents to Sender, +//otherwise we drop a control and call the CreateComponent function. +if BPressed = 1 then + Begin //mouse button pressed. + FormEditor1.ClearSelected; + Writeln('Clicked on the control!!!!! Control name is '+TControl(sender).name); + FormEditor1.AddSelected(TComponent(Sender)); + end + else + Begin //add a new control + CInterface := TComponentInterface(FormEditor1.CreateComponent(nil, + TComponentClass(TIdeComponent(ideComplist.items[bpressed-1]).ClassType),-1,-1,-1,-1)); + TControl(CInterface.Control).Visible := True; + + //set the ONCLICK event so we know when the control is selected; + TControl(CInterface.Control).OnClick := @ClickOnControl; + + + end; +//TIdeComponent(ideComplist.items[bpressed-1]). +end; + +{------------------------------------------------------------------------------} +{------------------------------------------------------------------------------} +{ + Used when we click on a form that was created. + This can be used to detect when + a control is dropped onto a form +} +{------------------------------------------------------------------------------} +{------------------------------------------------------------------------------} +{------------------------------------------------------------------------------} +Procedure TForm1.ClickOnForm(Sender : TObject); +var + CInterface : TComponentInterface; +Begin +//We clicked on the form. Let's see what the active selection is in the IDE control +//bar. If it's the pointer, then we set the FormEditor1.SelectedComponents to Sender, +//otherwise we drop a control and call the CreateComponent function. +if BPressed = 1 then + Begin //mouse button pressed. + FormEditor1.ClearSelected; + Writeln('Clicked on the form!!!!! Froms name is '+TFOrm(sender).name); + FormEditor1.AddSelected(TComponent(Sender)); + end + else + Begin //add a new control + CInterface := TComponentInterface(FormEditor1.CreateComponent(nil, + TComponentClass(TIdeComponent(ideComplist.items[bpressed-1]).ClassType),-1,-1,-1,-1)); + TControl(CInterface.Control).Visible := True; + + //set the ONCLICK event so we know when the control is selected; + TControl(CInterface.Control).OnClick := @ClickOnControl; + + + end; +//TIdeComponent(ideComplist.items[bpressed-1]). +end; + {------------------------------------------------------------------------------} procedure TForm1.mnuNewFormClicked(Sender : TObject); var @@ -1505,48 +1591,20 @@ var TempName : String; TempFormName : String; Found : Boolean; + TempForm : TForm; + CInterface : TComponentInterface; begin - //Create new unit, then display it. - TempName:= ''; - SList:= CreateUnit(TempName); - //get a name for the new form - SList.Form := CreateNewForm; - SList.Formname := SList.Form.Name; - TempFormName := SList.FormName; - SList.Filename := ''; - SList.Flags := pfForm; - with SList.Source do begin - //Add the default lines - Add('unit '+TempName+';'); - Add(''); - Add('{$mode objfpc}'); - Add(''); - Add('interface'); - Add(''); - Add('uses'); - Add('Classes,Messages, SysUtils, Graphics, Controls, Forms, Dialogs;'); - Add(''); - Add('type'); - Add(' T'+TempFormName+' = class(TForm)'); - Add(' private'); - Add(' { Private declarations }'); - Add(' public'); - Add(' { Public declarations }'); - Add(' end;'); - Add(''); - Add('var'); - Add(' '+TempFormName+': T'+TempFormName+';'); - Add(''); - Add('implementation'); - Add(''); - Add('end.'); - end; + TempForm := TForm.Create(Self); + TempForm.Parent := Self; + if not Assigned(FormEditor1) then + FormEditor1 := TFormEditor.Create; + FormEditor1.SelectedComponents.Clear; + CInterface := TComponentInterface(FormEditor1.CreateComponent(nil,TForm,50,50,300,400)); + TForm(CInterface.Control).Show; + TForm(CInterface.Control).Name := 'Form1'; +//set the ONCLICK event so we know when a control is dropped onto the form. + TFOrm(CInterface.Control).OnClick := @ClickOnForm; - ideEditor1.AddPage(SList.Name,SList.Source); - SList.Page := ideEditor1.Notebook1.Pageindex; //keep track of what page it is on - Project1.AddUnit(SList); - UpdateViewDialogs; - ideEditor1.Show; end; function TForm1.CreateNewForm : TDesignerForm; @@ -2319,6 +2377,11 @@ end. { ============================================================================= $Log$ + Revision 1.6 2000/11/27 18:52:37 lazarus + Added the Object Inspector code. + Added more form editor code. + Shane + Revision 1.5 2000/08/10 13:22:51 lazarus Additions for the FIND dialog Shane diff --git a/lcl/controls.pp b/lcl/controls.pp index 54d8e8844f..69625ab0d1 100644 --- a/lcl/controls.pp +++ b/lcl/controls.pp @@ -523,6 +523,7 @@ TCMDialogKey = TLMKEY; property Align : TAlign read FAlign write SetAlign; property BoundsRect : TRect read GetBoundsRect write SetBoundsRect; property Caption: TCaption read GetText write SetText stored IsCaptionStored; + property Cursor: TCursor read FCursor write SetCursor default crDefault; property Color : TColor read FCOlor write SetColor; {should change the WRITE to do something eventually} property ControlState: TControlState read FControlState write FControlState; property ClientOrigin: TPoint read GetClientOrigin; @@ -531,23 +532,22 @@ TCMDialogKey = TLMKEY; property ControlStyle : TControlStyle read FControlStyle write FControlStyle; property Enabled: Boolean read GetEnabled write SetEnabled default True; property Font : TFont read FFont write FFont; - property Height: Integer read FHeight write SetHeight; property HostDockSite : TWincontrol read FHostDockSite write FHostDockSite; - property Left: Integer read FLeft write SetLeft; property ClientHeight : Integer read FHeight write SetHeight; property ClientWidth : Integer read FWIdth write SetWidth; property Parent : TWinControl read FParent write SetParent; property ShowHint : Boolean read FShowHint write SetShowHint; - property Top: Integer read FTop write SetTop; property Visible: Boolean read FVisible write SetVisible; - property Width: Integer read FWidth write SetWidth; {events} property OnResize: TNotifyEvent read FOnResize write FOnResize; property OnClick: TNotifyEvent read FOnClick write FOnClick; // property Owner: TComponent read FOwner write FOwner; property WindowProc: TWndMethod read FWindowProc write FWindowProc; published - property Cursor: TCursor read FCursor write SetCursor default crDefault; + property Left: Integer read FLeft write SetLeft; + property Top: Integer read FTop write SetTop; + property Height: Integer read FHeight write SetHeight; + property Width: Integer read FWidth write SetWidth; property Hint: String read FHint write SetHint; end; @@ -1123,6 +1123,11 @@ end. { ============================================================================= $Log$ + Revision 1.3 2000/11/27 18:52:37 lazarus + Added the Object Inspector code. + Added more form editor code. + Shane + Revision 1.2 2000/07/30 21:48:32 lazarus MWE: = Moved ObjectToGTKObject to GTKProc unit diff --git a/lcl/forms.pp b/lcl/forms.pp index 8f34a137f2..d6e4cf0876 100644 --- a/lcl/forms.pp +++ b/lcl/forms.pp @@ -163,8 +163,19 @@ type property ClientHandle: HWND read FClientHandle; published property ActiveCOntrol; + property Align; + property AutoSize; + property Caption; + property Color; + property ClientHeight; + property ClientWidth; + property Enabled; property FormStyle; property Position; + property Visible; +// property WindowState; + property OnCreate; + property OnDestroy; end; TFormClass = class of TForm;