学步园

Delphi 版本：Delphi XE2

TControl = class(TComponent) 
private
  { 属性：Parent 读 } 
  FParent: TWinControl;
  { 属性：WindowProc 读写 }
  FWindowProc: TWndMethod;
  { 属性：Left 读 }
  FLeft:Integer; 
  { 属性：Top 读 }
  FTop:Integer; 
  { 属性：Width 读 }
  FWidth:Integer; 
  { 属性：Height 读 }
  FHeight:Integer; 
  { 属性：ControlState 读写 }
  FControlStyle: TControlStyle;
  { 属性：ControlState 读写 }
  FControlState: TControlState;
  { 属性：DesktopFont 读 }
  FDesktopFont:Boolean; 
  { 属性：Visible 读 }
  FVisible:Boolean; 
  { 用于 Enabled 属性：用来存放控件的 Enabled 值 }
  FEnabled:Boolean; 
  { 属性：ParentFont 读 }
  FParentFont:Boolean; 
  { 属性：ParentColor 读 }
  FParentColor:Boolean; 
  { 属性：Align 读 }
  FAlign: TAlign;
  { 属性：AutoSize 读 }
  FAutoSize:Boolean; 
  { 用于 DragMode 属性：用来存放控件的 DragMode 值 }
  FDragMode: TDragMode;
  { 属性：IsControl 读写 }
  FIsControl:Boolean; 
  { 属性：BiDiMode 读 }
  FBiDiMode: TBiDiMode;
  { 属性：ParentBiDiMode 读 }
  FParentBiDiMode:Boolean; 
  { 属性：Anchors 读 }
  FAnchors: TAnchors;
  { 属性：Font 读 }
  FFont: TFont;
  { 属性：ActionLink 读写 }
  FActionLink: TControlActionLink;
  { 属性：Color 读 }
  FColor: TColor;
  { 属性：Constraints 读 }
  FConstraints: TSizeConstraints;
  { 属性：Margins 读 }
  FMargins: TMargins;
  { 属性：Cursor 读 }
  FCursor: TCursor;
  { 属性：DragCursor 读写 }
  FDragCursor: TCursor;
  { 属性：PopupMenu 读 }
  FPopupMenu: TPopupMenu;
  { 属性：Hint 读写 }
  FHint:string; 
  { 用于 ScalingFlags 属性：在 FontChanged 过程中根据 FFontHeight 改变 ScalingFlags 的值 }
  FFontHeight:Integer; 
  { 属性：ScalingFlags 读写 }
  FScalingFlags: TScalingFlags;
  { 属性：ShowHint 读 }
  FShowHint:Boolean; 
  { 属性：ParentShowHint 读 }
  FParentShowHint:Boolean; 
  { 属性：DragKind 读写 }
  FDragKind: TDragKind;
  { 属性：DockOrientation 读写 }
  FDockOrientation: TDockOrientation;
  { 属性：HostDockSite 读 }
  FHostDockSite: TWinControl;
  { 属性：WheelAccumulator 读写 }
  FWheelAccumulator:Integer; 
  { 属性：UndockWidth 写 }
  FUndockWidth:Integer; 
  { 属性：UndockHeight 写 }
  FUndockHeight:Integer; 
  { 属性：LRDockWidth 写 }
  FLRDockWidth:Integer; 
  { 属性：TBDockHeight 写 }
  FTBDockHeight:Integer; 
  { 属性：FloatingDockSiteClass 写 }
  FFloatingDockSiteClass: TWinControlClass;
  { 属性：TouchManager 读 }
  FTouchManager: TTouchManager;
  { 属性：OnCanResize 读写 }
  FOnCanResize: TCanResizeEvent;
  { 属性：OnConstrainedResize 读写 }
  FOnConstrainedResize: TConstrainedResizeEvent;
  { 属性：OnMouseDown 读写 }
  FOnMouseDown: TMouseEvent;
  { 属性：OnMouseMove 读写 }
  FOnMouseMove: TMouseMoveEvent;
  { 属性：OnMouseUp 读写 }
  FOnMouseUp: TMouseEvent;
  { 属性：OnDragDrop 读写 }
  FOnDragDrop: TDragDropEvent;
  { 属性：OnDragOver 读写 }
  FOnDragOver: TDragOverEvent;
  { 属性：OnResize 读写 }
  FOnResize: TNotifyEvent;
  { 属性：OnStartDock 读写 }
  FOnStartDock: TStartDockEvent;
  { 属性：OnEndDock 读写 }
  FOnEndDock: TEndDragEvent;
  { 属性：OnStartDrag 读写 }
  FOnStartDrag: TStartDragEvent;
  { 属性：OnEndDrag 读写 }
  FOnEndDrag: TEndDragEvent;
  { 属性：OnClick 读写 }
  FOnClick: TNotifyEvent;
  { 属性：OnDblClick 读写 }
  FOnDblClick: TNotifyEvent;
  { 属性：OnContextPopup 读写 }
  FOnContextPopup: TContextPopupEvent;
  { 属性：OnMouseActivate 读写 }
  FOnMouseActivate: TMouseActivateEvent;
  { 属性：OnMouseLeave 读写 }
  FOnMouseLeave: TNotifyEvent;
  { 属性：OnMouseEnter 读写 }
  FOnMouseEnter: TNotifyEvent;
  { 属性：OnMouseWheel 读写 }
  FOnMouseWheel: TMouseWheelEvent;
  { 属性：OnMouseWheelDown 读写 }
  FOnMouseWheelDown: TMouseWheelUpDownEvent;
  { 属性：OnMouseWheelUp 读写 }
  FOnMouseWheelUp: TMouseWheelUpDownEvent;
  { 属性：OnGesture 读写 }
  FOnGesture: TGestureEvent;
  { 属性：HelpType 读写 }
  FHelpType: THelpType;
  { 属性：HelpKeyword 读 }
  FHelpKeyword:string; 
  { 属性： HelpContext 读 }
  FHelpContext: THelpContext;
  { 用于 CustomHint 属性：用来存放控件的 CustomHint 值 }
  FCustomHint: TCustomHint;
  { 属性：ParentCustomHint 读 }
  FParentCustomHint:Boolean; 
  { 属性：WindowText 读写 }
  FText:PChar; 
  { 属性：CustomHint 读 }
  functionGetCustomHint: TCustomHint; 
  {  }
  procedureCalcDockSizes; 
  {  }
  functionCheckNewSize(varNewWidth, NewHeight: Integer):Boolean; 
  {  }
  functionCreateFloatingDockSite(Bounds: TRect): TWinControl; 
  {  }
  procedureDoActionChange(Sender: TObject); 
  {  }
  functionDoCanAutoSize(varNewWidth, NewHeight: Integer):Boolean; 
  {  }
  functionDoCanResize(varNewWidth, NewHeight: Integer):Boolean; 
  {  }
  procedureDoConstraintsChange(Sender: TObject); 
  {  }
  procedureDoConstrainedResize(varNewWidth, NewHeight: Integer);
  {  }
  procedureDoDragMsg(varDragMsg: TCMDrag); 
  {  }
  procedureDoMouseActivate(varMessage: TCMMouseActivate); 
  {  }
  procedureDoMouseDown(varMessage: TWMMouse; Button: TMouseButton; Shift: TShiftState);
  {  }
  procedureDoMouseUp(varMessage: TWMMouse; Button: TMouseButton); 
  {  }
  procedureDoMarginChange(Sender: TObject); 
  {  }
  procedureFontChanged(Sender: TObject); 
  { 属性：AlignWithMargins 读 }
  functionGetAlignWithMargins: Boolean; inline;
  { 属性：BoundsRect 读 }
  functionGetBoundsRect: TRect; 
  { 属性：ClientHeight 读 }
  functionGetClientHeight: Integer;
  { 属性：ClientWidth 读 }
  functionGetClientWidth: Integer;
  { 属性：LRDockWidth 读 }
  functionGetLRDockWidth: Integer;
  { 属性：MouseCapture 读 }
  functionGetMouseCapture: Boolean;
  { 属性：TBDockHeight 读 }
  functionGetTBDockHeight: Integer;
  { 属性：UndockWidth 读 }
  functionGetUndockWidth: Integer;
  { 属性：UndockHeight 读 }
  functionGetUndockHeight: Integer;
  {  }
  procedureInvalidateControl(IsVisible, IsOpaque: Boolean);
  {  }
  functionIsAnchorsStored: Boolean;
  {  }
  functionIsBiDiModeStored: Boolean;
  {  }
  functionIsCaptionStored: Boolean;
  {  }
  functionIsColorStored: Boolean;
  {  }
  functionIsEnabledStored: Boolean;
  {  }
  functionIsFontStored: Boolean;
  {  }
  functionIsHintStored: Boolean;
  {  }
  functionIsHelpContextStored: Boolean;
  {  }
  functionIsOnClickStored: Boolean;
  {  }
  functionIsShowHintStored: Boolean;
  {  }
  functionIsVisibleStored: Boolean;
  {  }
  procedureReadIsControl(Reader: TReader); 
  {  }
  procedureReadExplicitLeft(Reader: TReader); 
  {  }
  procedureReadExplicitTop(Reader: TReader); 
  {  }
  procedureReadExplicitWidth(Reader: TReader); 
  {  }
  procedureReadExplicitHeight(Reader: TReader); 
  { 属性：AlignWithMargins 写 }
  procedureSetAlignWithMargins(Value: Boolean);
  { 属性：Anchors 写 }
  procedureSetAnchors(Value: TAnchors); 
  { 属性：Action 写 }
  procedureSetAction(Value: TBasicAction); 
  { 属性：Align 写 }
  procedureSetAlign(Value: TAlign); 
  { 属性：BoundsRect 写 }
  procedureSetBoundsRect(constRect: TRect); 
  { 属性：ClientHeight 写 }
  procedureSetClientHeight(Value: Integer);
  {  }
  procedureSetClientSize(Value: TPoint); 
  { 属性：ClientWidth 写 }
  procedureSetClientWidth(Value: Integer);
  { 属性：Color 写 }
  procedureSetColor(Value: TColor); 
  { 属性：Cursor 写 }
  procedureSetCursor(Value: TCursor); 
  { 属性：DesktopFont 写 }
  procedureSetDesktopFont(Value: Boolean);
  { 属性：Font 写 }
  procedureSetFont(Value: TFont); 
  { 属性：Height 写 }
  procedureSetHeight(Value: Integer);
  { 属性：HelpContext 写 }
  procedureSetHelpContext(constValue: THelpContext); 
  { 属性：HelpKeyword 写 }
  procedureSetHelpKeyword(constValue: string);
  { 属性：HostDockSite 写 }
  procedureSetHostDockSite(Value: TWinControl); 
  { 属性：Left 写 }
  procedureSetLeft(Value: Integer);
  { 属性：MouseCapture 写 }
  procedureSetMouseCapture(Value: Boolean);
  { 属性：ParentColor 写 }
  procedureSetParentColor(Value: Boolean);
  { 属性：ParentFont 写 }
  procedureSetParentFont(Value: Boolean);
  { 属性：ShowHint 写 }
  procedureSetShowHint(Value: Boolean);
  { 属性：ParentShowHint 写 }
  procedureSetParentShowHint(Value: Boolean);
  { 属性：ParentCustomHint 写 }
  procedureSetParentCustomHint(Value: Boolean);
  { 属性：SetPopupMenu 写 }
  procedureSetPopupMenu(Value: TPopupMenu); 
  { 属性：Top 写 }
  procedureSetTop(Value: Integer);
  { 属性：Visible 写 }
  procedureSetVisible(Value: Boolean);
  { 属性：Width 写 }
  procedureSetWidth(Value: Integer);
  {  }
  procedureSetZOrderPosition(Position: Integer);
  {  }
  procedureUpdateAnchorRules; 
  {  }
  procedureWriteIsControl(Writer: TWriter); 
  {  }
  procedureWriteExplicitLeft(Writer: TWriter); 
  {  }
  procedureWriteExplicitTop(Writer: TWriter); 
  {  }
  procedureWriteExplicitWidth(Writer: TWriter); 
  {  }
  procedureWriteExplicitHeight(Writer: TWriter); 
  {  }
  procedureWMLButtonDown(varMessage: TWMLButtonDown); message WM_LBUTTONDOWN; 
  {  }
  procedureWMNCLButtonDown(varMessage: TWMNCLButtonDown); message WM_NCLBUTTONDOWN; 
  {  }
  procedureWMRButtonDown(varMessage: TWMRButtonDown); message WM_RBUTTONDOWN; 
  {  }
  procedureWMMButtonDown(varMessage: TWMMButtonDown); message WM_MBUTTONDOWN; 
  {  }
  procedureWMLButtonDblClk(varMessage: TWMLButtonDblClk); message WM_LBUTTONDBLCLK; 
  {  }
  procedureWMRButtonDblClk(varMessage: TWMRButtonDblClk); message WM_RBUTTONDBLCLK; 
  {  }
  procedureWMMButtonDblClk(varMessage: TWMMButtonDblClk); message WM_MBUTTONDBLCLK; 
  {  }
  procedureWMMouseMove(varMessage: TWMMouseMove); message WM_MOUSEMOVE; 
  {  }
  procedureWMLButtonUp(varMessage: TWMLButtonUp); message WM_LBUTTONUP; 
  {  }
  procedureWMRButtonUp(varMessage: TWMRButtonUp); message WM_RBUTTONUP; 
  {  }
  procedureWMMButtonUp(varMessage: TWMMButtonUp); message WM_MBUTTONUP; 
  {  }
  procedureWMMouseWheel(varMessage: TWMMouseWheel); message WM_MOUSEWHEEL; 
  {  }
  procedureWMCancelMode(varMessage: TWMCancelMode); message WM_CANCELMODE; 
  {  }
  procedureWMWindowPosChanged(varMessage: TWMWindowPosChanged); message WM_WINDOWPOSCHANGED;
  {  }
  procedureCMVisibleChanged(varMessage: TMessage); message CM_VISIBLECHANGED; 
  {  }
  procedureCMEnabledChanged(varMessage: TMessage); message CM_ENABLEDCHANGED; 
  {  }
  procedureCMFontChanged(varMessage: TMessage); message CM_FONTCHANGED; 
  {  }
  procedureCMColorChanged(varMessage: TMessage); message CM_COLORCHANGED; 
  {  }
  procedureCMMouseActivate(varMessage: TCMMouseActivate); message CM_MOUSEACTIVATE; 
  {  }
  procedureCMParentFontChanged(varMessage: TCMParentFontChanged); message CM_PARENTFONTCHANGED;
  {  }
  procedureCMSysFontChanged(varMessage: TMessage); message CM_SYSFONTCHANGED; 
  {  }
  procedureCMParentColorChanged(varMessage: TMessage); message CM_PARENTCOLORCHANGED; 
  {  }
  procedureCMParentShowHintChanged(varMessage: TMessage); message CM_PARENTSHOWHINTCHANGED; 
  {  }
  procedureCMHintShow(varMessage: TCMHintShow); message CM_HINTSHOW; 
  {  }
  procedureCMHitTest(varMessage: TCMHitTest); message CM_HITTEST; 
  {  }
  procedureCMMouseEnter(varMessage: TMessage); message CM_MOUSEENTER; 
  {  }
  procedureCMMouseLeave(varMessage: TMessage); message CM_MOUSELEAVE; 
  {  }
  procedureCMDesignHitTest(varMessage: TCMDesignHitTest); message CM_DESIGNHITTEST; 
  {  }
  procedureCMBiDiModeChanged(varMessage: TMessage); message CM_BIDIMODECHANGED; 
  {  }
  procedureCMParentBiDiModeChanged(varMessage: TMessage); message CM_PARENTBIDIMODECHANGED; 
  {  }
  procedureCMMouseWheel(varMessage: TCMMouseWheel); message CM_MOUSEWHEEL; 
  {  }
  procedureCMGesture(varMessage: TCMGesture); message CM_GESTURE; 
  {  }
  procedureWMContextMenu(varMessage: TWMContextMenu); message WM_CONTEXTMENU; 
  {  }
  procedureCMParentTabletOptionsChanged(varMessage: TMessage); message CM_PARENTTABLETOPTIONSCHANGED;
  { 属性：Constraints 写 }
  procedureSetConstraints(constValue: TSizeConstraints); 
  { 属性：Margins 写 }
  procedureSetMargins(constValue: TMargins); 
  { 属性：TouchManager 写 }
  procedureSetTouchManager(constValue: TTouchManager); 
  { 属性：Text 和 Caption 读 }
  functionGetText: TCaption; 
  { 属性：Text 和 Caption 写 }
  procedureSetText(constValue: TCaption); 
  {  }
  procedureCMFloat(varMessage: TCMFloat); message CM_FLOAT; 
protected
  {  }
  FAnchorMove:Boolean; 
  {  }
  FAnchorRules: TPoint;
  {  }
  FAnchorOrigin: TPoint;
  {  }
  FOriginalParentSize: TPoint;
  { 属性：ExplicitLeft 只读 }
  FExplicitLeft:Integer; 
  { 属性：ExplicitTop 只读 }
  FExplicitTop:Integer; 
  { 属性：ExplicitWidth 只读 }
  FExplicitWidth:Integer; 
  { 属性：ExplicitHeight 只读 }
  FExplicitHeight:Integer; 
  {  }
  FReserved: TReservedControlData;{ 内部使用，用户不要调用 }
  {  }
  procedureActionChange(Sender: TObject; CheckDefaults: Boolean); dynamic;
  {  }
  procedureAdjustSize; dynamic; 
  {  }
  procedureAssignTo(Dest: TPersistent); override; 
  {  }
  procedureBeginAutoDrag; dynamic; 
  {  }
  functionCanResize(varNewWidth, NewHeight: Integer):Boolean; virtual;
  {  }
  functionCanAutoSize(varNewWidth, NewHeight: Integer):Boolean; virtual;
  {  }
  procedureChanged; 
  {  }
  procedureChangeScale(M, D: Integer); dynamic;
  {  }
  procedureClick; dynamic; 
  {  }
  procedureConstrainedResize(varMinWidth, MinHeight, MaxWidth, MaxHeight: Integer); virtual;
  {  }
  functionCalcCursorPos: TPoint; 
  {  }
  procedureCreateTouchManager; virtual; 
  {  }
  procedureDblClick; dynamic; 
  {  }
  procedureDefaultDockImage(DragDockObject: TDragDockObject; Erase:Boolean); dynamic;
  {  }
  procedureDefineProperties(Filer: TFiler); override; 
  {  }
  procedureDockTrackNoTarget(Source: TDragDockObject; X, Y: Integer); dynamic;
  {  }
  procedureDoContextPopup(MousePos: TPoint; varHandled: Boolean); dynamic;
  {  }
  procedureDoEndDock(Target: TObject; X, Y: Integer); dynamic;
  {  }
  procedureDoDock(NewDockSite: TWinControl; varARect: TRect); dynamic; 
  {  }
  procedureDoStartDock(varDragObject: TDragObject); dynamic; 
  {  }
  functionDoMouseWheel(Shift: TShiftState; WheelDelta: Integer; MousePos: TPoint):Boolean; dynamic;
  {  }
  functionDoMouseWheelDown(Shift: TShiftState; MousePos: TPoint):Boolean; dynamic;
  {  }
  functionDoMouseWheelUp(Shift: TShiftState; MousePos: TPoint): Boolean; dynamic; 
  {  }
  procedureDragCanceled; dynamic; 
  {  }
  procedureDragOver(Source: TObject; X, Y: Integer; State: TDragState;var Accept:Boolean); dynamic;
  {  }
  procedureDoEndDrag(Target: TObject; X, Y: Integer); dynamic;
  {  }
  procedureDoStartDrag(varDragObject: TDragObject); dynamic; 
  {  }
  procedureDoGesture(constEventInfo: TGestureEventInfo; varHandled: Boolean); virtual;
  {  }
  procedureDoGetGestureOptions(varGestures: TInteractiveGestures; varOptions: TInteractiveGestureOptions); virtual; 
  {  }
  procedureDrawDragDockImage(DragDockObject: TDragDockObject); dynamic;
  {  }
  procedureEraseDragDockImage(DragDockObject: TDragDockObject); dynamic;
  { 属性：Action 读 }
  functionGetAction: TBasicAction; virtual; 
  {  }
  functionGetActionLinkClass: TControlActionLinkClass; dynamic; 
  { 属性：ClientOrigin 只读 }
  functionGetClientOrigin: TPoint; virtual; 
  { 属性：ClientRect 只读 }
  functionGetClientRect: TRect; virtual; 
  {  }
  functionGetDeviceContext(varWindowHandle: HWND): HDC; overload; virtual; 
  {  }
  functionGetDockEdge(MousePos: TPoint): TAlign; dynamic; 
  { 属性：Enabled 读 }
  functionGetEnabled: Boolean; virtual;
  { 属性：Floating 只读 }
  functionGetFloating: Boolean; virtual;
  { 属性：FloatingDockSiteClass 读 }
  functionGetFloatingDockSiteClass: TWinControlClass; virtual; 
  {  }
  functionGetPalette: HPALETTE; dynamic; 
  {  }
  functionGetPopupMenu: TPopupMenu; dynamic; 
  { 属性：DragMode 读 }
  functionGetDragMode: TDragMode; 
  {  }
  functionIsTouchPropertyStored(AProperty: TTouchProperty): Boolean; dynamic; 
  {  }
  procedureLoaded; override; 
  {  }
  functionMouseActivate(Button: TMouseButton; Shift: TShiftState; X, Y:Integer; HitTest:Integer): TMouseActivate; dynamic;
  {  }
  procedureMouseDown(Button: TMouseButton; Shift: TShiftState; X, Y:Integer); dynamic;
  {  }
  procedureMouseMove(Shift: TShiftState; X, Y: Integer); dynamic;
  {  }
  procedureMouseUp(Button: TMouseButton; Shift: TShiftState; X, Y:Integer); dynamic;
  {  }
  procedureNotification(AComponent: TComponent; Operation: TOperation); override;
  {  }
  procedurePositionDockRect(DragDockObject: TDragDockObject); dynamic;
  {  }
  functionPaletteChanged(Foreground: Boolean):Boolean; dynamic;
  {  }
  procedureReadState(Reader: TReader); override; 
  {  }
  procedureRequestAlign; virtual; 
  {  }
  procedureResize; dynamic; 
  {  }
  procedureScaleConstraints(M, D: Integer);
  {  }
  procedureScaleMargins(M, D: Integer);
  {  }
  procedureSendCancelMode(Sender: TControl); 
  {  }
  procedureSendDockNotification(Msg: Cardinal; WParam, LParam: THandle);
  { 属性：AutoSize 写 }
  procedureSetAutoSize(Value: Boolean); virtual;
  { 属性：DragMode 写 }
  procedureSetDragMode(Value: TDragMode); virtual; 
  { 属性：Enabled 写 }
  procedureSetEnabled(Value: Boolean); virtual;
  {  }
  procedureSetName(constValue: TComponentName); override; 
  { 属性：Parent 写 }
  procedureSetParent(AParent: TWinControl); virtual; 
  { 属性：ParentBiDiMode 写 }
  procedureSetParentBiDiMode(Value: Boolean); virtual;
  { 属性：BiDiMode 写 }
  procedureSetBiDiMode(Value: TBiDiMode); virtual; 
  {  }
  procedureSetZOrder(TopMost: Boolean); dynamic;
  { 属性：CustomHint 写 }
  procedureSetCustomHint(Value: TCustomHint); 
  {  }
  procedureUpdateExplicitBounds; 
  {  }
  procedureUpdateBoundsRect(constR: TRect); 
  {  }
  procedureVisibleChanging; dynamic; 
  {  }
  procedureWndProc(varMessage: TMessage); virtual; 
  {  }
  functionDesignWndProc(varMessage: TMessage): Boolean; dynamic;
  {  }
  functionGetDragImages: TDragImageList; virtual; 
  { 属性：包含与控件相关的 ActionLink 对象，ActionLink 对象用来处理控件与 Action 之间的关联 }
  propertyActionLink: TControlActionLink read FActionLink write FActionLink;
  { 属性：指定控件是否自动调整其大小以适应其包含的内容 }
  propertyAutoSize: Booleanread FAutoSize writeSetAutoSize default False;
  { 属性：指定一个与控件相关的字符串，通常根据不同的控件类型，分别使用 Caption 和 Text 来显示控件的字符串 }
  propertyCaption: TCaption read GetText writeSetText stored IsCaptionStored; 
  { 属性：指定控件是否使用 Windows 的图标字体作为自身的字体属性，通过 Screen.IconFont 可以获取 Windows 的图标字体（Windows 的图标字体就是 Windows 中各个图标下面的文字的字体） }
  propertyDesktopFont: Booleanread FDesktopFont writeSetDesktopFont default False;
  { 属性：指定拖拽控件时，是执行正常拖放，还是执行停靠操作 }
  propertyDragKind: TDragKind read FDragKind writeFDragKind default dkDrag; 
  { 属性：指定当控件被拖拽时的鼠标指针形状 }
  propertyDragCursor: TCursor read FDragCursor writeFDragCursor default crDrag; 
  { 属性：指定控件如何启用拖拽操作（dmAutomatic：当用户拖动控件时自动开始拖放操作；dmAutomatic：控件不能拖，直到应用程序调用 BeginDrag 的方法 }
  propertyDragMode: TDragMode read GetDragMode writeSetDragMode default dmManual; 
  { 属性：IsControl 可以使窗体变成一个特殊的控件，而不是一个窗体，这将影响窗体的保存方式 }
  propertyIsControl: Booleanread FIsControl writeFIsControl; 
  { 属性：指定控件是否已经“捕获”鼠标事件，当用户拖动控件中的项目时，控件将捕获鼠标 }
  propertyMouseCapture: Booleanread GetMouseCapture writeSetMouseCapture; 
  { 属性：指定控件是否使用其 Parent 控件的 BiDiMode 属性 }
  propertyParentBiDiMode: Booleanread FParentBiDiMode writeSetParentBiDiMode default True;
  { 属性：指定控件是否使用其 Parent 控件的 Color 属性 }
  propertyParentColor: Booleanread FParentColor writeSetParentColor default True;
  { 属性：指定控件是否使用其 Parent 控件的 Font 属性 }
  propertyParentFont: Booleanread FParentFont writeSetParentFont default True;
  { 属性：指定控件是否使用其 Parent 控件的 ShowHint 属性 }
  propertyParentShowHint: Booleanread FParentShowHint writeSetParentShowHint default True;
  { 属性：指定与控件相关的弹出式菜单 }
  propertyPopupMenu: TPopupMenu read FPopupMenu writeSetPopupMenu; 
  { 属性：指定控件的哪些属性被缩放，Delphi 内部使用，用户无需调用 }
  propertyScalingFlags: TScalingFlags read FScalingFlags write FScalingFlags;
  { 属性：指定一个与控件相关的字符串，通常根据不同的控件类型，分别使用 Caption 和 Text 来显示控件的字符串 }
  propertyText: TCaption read GetText writeSetText; 
  { 属性：指定鼠标一次滚动的进展 }
  propertyWheelAccumulator: Integerread FWheelAccumulator writeFWheelAccumulator; 
  { 属性：指定控件的背景色 }
  propertyColor: TColor read FColor writeSetColor stored IsColorStored default clWindow; 
  { 属性：指定控件的字体 }
  propertyFont: TFont read FFont writeSetFont stored IsFontStored; 
  { 属性：等同于 Text，为了给不同控件提供不同的用途 }
  propertyWindowText: PCharread FText writeFText; 
  { 事件：当试图改变控件尺寸时触发。如果在 OnCanResize 中未禁止调整尺寸，则其后紧接着 OnConstrainedResize 事件 }
  propertyOnCanResize: TCanResizeEvent read FOnCanResize write FOnCanResize;
  { 属性：当用户单击控件时触发。如果控件拥有一个 Action，而且该 Action 有一个 OnExecute 方法，则这个 OnExecute 方法将与控件的单击事件相关联，除非控件明确制定一个 OnClick 事件。下列事件也被认为是 OnClick 事件：当用户通过键盘的方向键来选择类似于表格、列表框、组合框中的项目时；当一个按钮或复选框具有焦点时，用户按下空格键；当窗体有默认按钮（Default）时，按下回车键；当窗体有取消按钮（Cancel）时，按下 Esc 键；当用户按下按钮或复选框的快捷键（例如 Alt + B）时；当单选钮的 Checked 属性为 True 时；当复选框的 Checked 属性发生变化时；当调用菜单项的 Click 方法时；当用户单击一个窗体的空白区域或单击窗体中被禁用的控件时，将触发窗体的 OnClick 事件 }
  propertyOnClick: TNotifyEvent read FOnClick writeFOnClick stored IsOnClickStored; 
  { 属性：OnCanResize 之后紧跟着 OnConstrainedResize，用来限制控件的可调整尺寸范围 }
  propertyOnConstrainedResize: TConstrainedResizeEvent read FOnConstrainedResizewrite FOnConstrainedResize;
  { 属性：当用户通过点击鼠标右键或其它方式（比如键盘的 Shift + F10 或 Application 键）打开弹出式菜单时触发（无论控件有没有指定弹出式菜单）。注意：Parent 控件比 Child 控件先接收到 OnContextPopup 事件，此外，默认的窗口过程会让许多 Child 控件比 Parent 控件先接收到 OnContextPopup 事件。因此，当处理完一个 OnContextPopup 消息后，如果不将消息中的 Handled 参数设置为 True，则该消息会继续向后传递 }
  propertyOnContextPopup: TContextPopupEvent read FOnContextPopupwrite FOnContextPopup;
  { 属性：当用户双击控件时触发 }
  propertyOnDblClick: TNotifyEvent read FOnDblClick writeFOnDblClick; 
  { 属性：当用户在一个控件上放下正被拖动的对象时，触发该控件的 OnDragDrop 事件 }
  propertyOnDragDrop: TDragDropEvent read FOnDragDrop writeFOnDragDrop; 
  { 属性：当用户拖动对象经过一个控件时，触发该控件的 OnDragOver 事件。注意 OnDragOver 的 Accept 参数默认为 True，表示控件接收拖放操作，如果控件没有指定 OnDragOver 事件，则该控件不接收拖放操作 }
  propertyOnDragOver: TDragOverEvent read FOnDragOver writeFOnDragOver; 
  { 属性：当控件被停靠或取消停靠时触发 }
  propertyOnEndDock: TEndDragEvent read FOnEndDock writeFOnEndDock; 
  { 属性：当控件被放下或取消拖放时触发 }
  propertyOnEndDrag: TEndDragEvent read FOnEndDrag writeFOnEndDrag; 
  { 属性：当一个控件所在的窗体为非激活状态，而通过鼠标点击该控件来激活窗体时触发该控件的 OnMouseActivate 事件。该控件在处理完 OnMouseActivate 事件后，如果不修改该事件的 MouseActivate 参数，仍然保留其默认值 maDefault，则该消息会继续向 Parent 传递。某些控件在收到按钮的单击事件后会自动激活窗体，而不理会 MouseActivate 的 maNoActive 值 }
  propertyOnMouseActivate: TMouseActivateEvent read FOnMouseActivatewrite FOnMouseActivate;
  { 属性：当用户在控件上按下鼠标按键时触发 }
  propertyOnMouseDown: TMouseEvent read FOnMouseDown writeFOnMouseDown; 
  { 属性：当用户将鼠标移入当前控件的范围时触发一次 }
  propertyOnMouseEnter: TNotifyEvent read FOnMouseEnter writeFOnMouseEnter; 
  { 属性：当用户将鼠标移出当前控件的范围时触发一次 }
  propertyOnMouseLeave: TNotifyEvent read FOnMouseLeave writeFOnMouseLeave; 
  { 属性：当用户在控件上移动鼠标时触发 }
  propertyOnMouseMove: TMouseMoveEvent read FOnMouseMove write FOnMouseMove;
  { 属性：当用户在控件上松开鼠标按键时触发 }
  propertyOnMouseUp: TMouseEvent read FOnMouseUp writeFOnMouseUp; 
  { 属性：当用户在控件上滚动鼠标滚轮时触发 }
  propertyOnMouseWheel: TMouseWheelEvent read FOnMouseWheel write FOnMouseWheel;
  { 属性：当用户在控件上向下滚动鼠标滚轮时触发 }
  propertyOnMouseWheelDown: TMouseWheelUpDownEvent read FOnMouseWheelDownwrite FOnMouseWheelDown;
  { 属性：当用户在控件上向上滚动鼠标滚轮时触发 }
  propertyOnMouseWheelUp: TMouseWheelUpDownEvent read FOnMouseWheelUpwrite FOnMouseWheelUp;
  { 属性：控件尺寸被改变时触发 }
  propertyOnResize: TNotifyEvent read FOnResize writeFOnResize; 
  { 属性：当控件的 DragKind 属性值为 dkDock 而且开始拖动控件时触发 }
  propertyOnStartDock: TStartDockEvent read FOnStartDock write FOnStartDock;
  { 属性：当控件的 DragKind 属性值为 dkDrag 而且开始拖动控件时触发 }
  propertyOnStartDrag: TStartDragEvent read FOnStartDrag write FOnStartDrag;
public
  {  }
  constructorCreate(AOwner: TComponent); override; 
  {  }
  destructorDestroy; override; 
  {  }
  procedureBeginDrag(Immediate: Boolean; Threshold:Integer = -1);
  {  }
  procedureBringToFront; 
  {  }
  functionClientToScreen(constPoint: TPoint): TPoint; 
  {  }
  functionClientToParent(constPoint: TPoint; AParent: TWinControl = nil): TPoint;
  {  }
  procedureDock(NewDockSite: TWinControl; ARect: TRect); dynamic;
  {  }
  functionDragging: Boolean;
  {  }
  procedureDragDrop(Source: TObject; X, Y: Integer); dynamic;
  {  }
  functionDrawTextBiDiModeFlags(Flags: Longint):Longint; 
  {  }
  functionDrawTextBiDiModeFlagsReadingOnly: Longint;
  { 属性：指定控件是否响应鼠标、键盘和计时器事件，部分控件被禁用后，外观将变暗 }
  propertyEnabled: Booleanread GetEnabled writeSetEnabled stored IsEnabledStored default True;
  {  }
  procedureEndDrag(Drop: Boolean);
  {  }
  functionGetControlsAlignment: TAlignment; dynamic; 
  {  }
  functionGetParentComponent: TComponent; override; 
  {  }
  functionHasParent: Boolean; override;
  {  }
  procedureHide; 
  {  }
  procedureInitiateAction; virtual; 
  {  }
  procedureInvalidate; virtual; 
  {  }
  procedureMouseWheelHandler(varMessage: TMessage); dynamic; 
  {  }
  functionIsRightToLeft: Boolean;
  {  }
  functionManualDock(NewDockSite: TWinControl; DropControl: TControl =nil; ControlSide: TAlign = alNone):Boolean; 
  {  }
  functionManualFloat(ScreenPos: TRect): Boolean;
  {  }
  functionPerform(Msg: Cardinal; WParam: WPARAM; LParam: LPARAM): LRESULT; overload;
  {  }
  procedureRefresh; 
  {  }
  procedureRepaint; virtual; 
  {  }
  functionReplaceDockedControl(Control: TControl; NewDockSite: TWinControl; DropControl: TControl; ControlSide: TAlign):Boolean; 
  {  }
  functionScreenToClient(constPoint: TPoint): TPoint; 
  {  }
  functionParentToClient(constPoint: TPoint; AParent: TWinControl = nil): TPoint;
  {  }
  procedureSendToBack; 
  {  }
  procedureSetBounds(ALeft, ATop, AWidth, AHeight: Integer); virtual;
  {  }
  procedureSetDesignVisible(Value: Boolean); dynamic;
  {  }
  procedureSetParentComponent(Value: TComponent); override; 
  {  }
  procedureShow; 
  {  }
  procedureUpdate; virtual; 
  {  }
  functionUseRightToLeftAlignment: Boolean; dynamic;
  {  }
  functionUseRightToLeftReading: Boolean;
  {  }
  functionUseRightToLeftScrollBar: Boolean;
  {  }
  procedureDefaultHandler(varMessage); override; 
  {  }
  functionGetTextBuf(Buffer: PChar; BufSize:Integer): Integer; 
  {  }
  functionGetTextLen: Integer;
  {  }
  functionPerform(Msg: Cardinal; WParam: WPARAM; LParam:PChar): LRESULT; overload;
  {  }
  functionPerform(Msg: Cardinal; WParam: WPARAM;var LParam: TRect): LRESULT; overload;
  {  }
  procedureSetTextBuf(Buffer: PChar);
  { 属性：指定与控件相关连的动作 }
  propertyAction: TBasicAction read GetAction writeSetAction; 
  { 属性：指定控件在其 Parent 中的对齐方式 }
  propertyAlign: TAlign read FAlign writeSetAlign default alNone; 
  { 属性：指定控件如何固定在其 Parent 中，确保无论 Parent 如何改变尺寸，当前控件的上下左右与其 Parent 的相对位置都不会发生变化 }
  propertyAnchors: TAnchors read FAnchors writeSetAnchors stored IsAnchorsStored default [akLeft, akTop];
  { 属性：指定控件的双向模式，BiDiMode 允许当控件运行在一个本地环境中时，自动调整它的外观和行为，使控件从右向左读取，而不是从左向右读取 }
  propertyBiDiMode: TBiDiMode read FBiDiMode writeSetBiDiMode stored IsBiDiModeStored; 
  { 属性：获取以 Parent 的坐标系统表示的当前控件的范围坐标（当前控件的上下左右在 Parent 坐标系统的什么地方） }
  propertyBoundsRect: TRect read GetBoundsRect writeSetBoundsRect; 
  { 属性：控件的客户群高度，相当于 ClientRect.Bottom }
  propertyClientHeight: Integerread GetClientHeight writeSetClientHeight stored False;
  { 属性：指定控件客户区左上角的屏幕坐标（以像素为单位），继承自 TControl 和 TWInControl 的控件的“屏幕坐标”是指该控件相对于其 Parent 左上角的坐标，如果该控件没有 Parent，则读取 ClientOrigin 属性会引发一个 EInvalidOperation 异常 }
  propertyClientOrigin: TPoint read GetClientOrigin; 
  { 属性：控件的客户区范围（对于窗体而言，客户区是指去掉标题栏和边框以后的区域），对于有滚动条的控件，客户区并不是整个滚动范围，而只是当前可见的滚动区域 }
  propertyClientRect: TRect read GetClientRect; 
  { 属性：控件的客户群宽度，相当于 ClientRect.Right }
  propertyClientWidth: Integerread GetClientWidth writeSetClientWidth stored False;
  { 属性：指定控件的限制尺寸，控件只能在限制范围内改变尺寸 }
  propertyConstraints: TSizeConstraints read FConstraints write SetConstraints;
  { 属性：指定控件在运行时的当前状态 }
  { TControlState = set of (csLButtonDown, csClicked, csPalette,
    csReadingState, csAlignmentNeeded, csFocusing, csCreating,
    csPaintCopy, csCustomPaint, csDestroyingHandle, csDocking,
    csDesignerHide, csPanning, csRecreating, csAligning, csGlassPaint,
    csPrintClient); } 
  propertyControlState: TControlState read FControlState write FControlState;
  { 属性：指定控件的样式特征。ControlStyle 描述一个控件的永久状态，ControlStyle 不能在运行时被修改，但可以在构造函数中被修改。而 ControlState 属性则用来记录控件的临时状态。 }
  { TControlStyle = set of (
    csAcceptsControls,         // 在设计时，控件可以成为放在它上面的控件的Parent控件
    csActionClient,            // 控件被连接到一个 Action 对象，当为控件的Action属性赋值时，这个设置被自动启用，当控件的Action属性被清空时，这个设置被自动禁用
    csAlignWithMargins,        // 控件使用 Margins 属性进行控制
    csCaptureMouse,            // 控件在被单击时捕获鼠标事件
    csClickEvents,             // 控件可以接收和响应鼠标单击消息，某些控件不继承这个属性，比如TButton
    csDesignInteractive,       // 在设计时，将控件的鼠标右击映射为鼠标左击来操纵控件
    csDisplayDragImage,        //
    csDoubleClicks,            // 控件可以接收和响应鼠标双击消息，另外，将双击消息映射到（两个）单击消息
    csFixedHeight,             // 控件的高度值不发生改变或缩放
    csFixedWidth,              // 控件的宽度值不发生改变或缩放
    csFramed,                  // 控件拥有 3D 框架
    csGestures,                //
    csMenuEvents,              // 控件响应系统菜单命令
    csNeedsBorderPaint,        // 这个选项只有当控件启用 Windows XP 样式时才适用，这个选项会使 ThemeServices 使用当前主题绘制控件边框
    csNoDesignVisible,         // 控件在设计时不可见
    csNoStdEvents,             // 标准事件（例如鼠标、键盘和单击事件）将被忽略，这个标志允许应用程序在不需要响应这些消息时更快的运行
    csOpaque,                  // 控件完全填充它的客户区范围
    csOverrideStylePaint,      //
    csPaintBlackOpaqueOnGlass, //
    csPannable,                // 如果想要控件支持鼠标平移，则使用这个标志
    csParentBackground,        // 这个选项只有当控件启用 Windows XP 样式时才适用，这个选项会使当前控件使用其 Parent 的背景主题
    csReflector,               // 控件响应窗口对话框消息，焦点消息或尺寸改变消息
    csReplicatable,            // 控件可以通过 PaintTo 方法将自身的样子拷贝到任意画布中
    csSetCaption               // 如果没有明确给控件的 Caption属性赋值，则控件的Caption属性的值将和Name 属性相同
    ); }
  propertyControlStyle: TControlStyle read FControlStyle write FControlStyle;
  { 属性：指定控件如何与其它控件一起停靠在相同的 Parent 中，对接区可以设置为从左到右或从上到下 }
  propertyDockOrientation: TDockOrientation read FDockOrientationwrite FDockOrientation;
  { 属性：获取控件的精确水平位置，由 Delphi 内部使用，用户只需要使用 Left 属性即可 }
  propertyExplicitLeft: Integerread FExplicitLeft; 
  { 属性：获取控件的精确垂直位置，由 Delphi 内部使用，用户只需要使用 Top 属性即可 }
  propertyExplicitTop: Integerread FExplicitTop; 
  { 属性：获取控件的精确宽度，由 Delphi 内部使用，用户只需要使用 Width 属性即可 }
  propertyExplicitWidth: Integerread FExplicitWidth; 
  { 属性：获取控件的精确高度，由 Delphi 内部使用，用户只需要使用 Height 属性即可 }
  propertyExplicitHeight: Integerread FExplicitHeight; 
  { 属性：获取控件的浮动状态 }
  propertyFloating: Booleanread GetFloating; 
  { 属性：指定用来承载浮动控件的临时控件的类型 }
  propertyFloatingDockSiteClass: TWinControlClass read GetFloatingDockSiteClasswrite FFloatingDockSiteClass;
  { 属性：指定控件所停靠的控件（停靠在哪个控件旁边），应用程序应该使用 ManualDock 方法，而不是设置 HostDockSite 属性 }
  propertyHostDockSite: TWinControl read FHostDockSite writeSetHostDockSite; 
  { 属性：指定控件水平停靠时的宽度 }
  propertyLRDockWidth: Integerread GetLRDockWidth writeFLRDockWidth; 
  { 属性：确定当鼠标指针移动到控件上时，是否显示提示信息 }
  propertyShowHint: Booleanread FShowHint writeSetShowHint stored IsShowHintStored; 
  { 属性：指定控件垂直停靠时的高度 }
  propertyTBDockHeight: Integerread GetTBDockHeight writeFTBDockHeight; 
  { 属性：指定与控件相关的 TouchManager 组件（手势控件） }
  propertyTouch: TTouchManager read FTouchManager writeSetTouchManager; 
  { 属性：指定控件在浮动时的高度，改变一个空间的 UndockHeight 值，只有在控件下一次浮动时才会体现出来 }
  propertyUndockHeight: Integerread GetUndockHeight writeFUndockHeight; 
  { 属性：指定控件在浮动时的宽度，改变一个空间的 UndockWidth 值，只有在控件下一次浮动时才会体现出来 }
  propertyUndockWidth: Integerread GetUndockWidth writeFUndockWidth; 
  { 属性：指定组件在运行时是否可见，也可以使用 Show 或 Hide 方法来显示或隐藏控件，对于 TTabSheet 的后裔，Visible 无法在运行时控制其可见与否，更多信息请参见 TabVisible 属性 }
  propertyVisible: Booleanread FVisible writeSetVisible stored IsVisibleStored default True;
  { 属性：指向控件消息处理过程 }
  propertyWindowProc: TWndMethod read FWindowProc writeFWindowProc; 
  { 属性：指定用来包含该控件的 Parent 控件（只有 TWinControl 及其子类的控件才能作为 Parent 使用） }
  propertyParent: TWinControl read FParent writeSetParent; 
  { 属性：当执行一个与此控件相关的手势时，触发该事件，参见 TTouchManager 类 }
  propertyOnGesture: TGestureEvent read FOnGesture writeFOnGesture; 
published
  { 属性：指定控件是否受 Margins 属性的制约 }
  propertyAlignWithMargins: Booleanread GetAlignWithMargins writeSetAlignWithMargins default False;
  { 属性：指定控件的左边相对其 Parent 或 包含该控件的控件 的左边的位置（以像素为单位）。对于窗体而言，Left 则相对于屏幕 }
  propertyLeft: Integerread FLeft writeSetLeft; 
  { 属性：指定控件的顶部相对其 Parent 或 包含该控件的控件 的顶部的位置（以像素为单位）。对于窗体而言，Top 则相对于屏幕 }
  propertyTop: Integerread FTop writeSetTop; 
  { 属性：指定控件的宽度（以像素为单位）。注：TTabSheet 控件在运行时改变这个属性值不会有任何效果 }
  propertyWidth: Integerread FWidth writeSetWidth; 
  { 属性：指定控件的高度（以像素为单位） }
  propertyHeight: Integerread FHeight writeSetHeight; 
  { 属性：指定当鼠标指针移动到控件区域时所显示的指针形状，它的的值是全局变量 Screen 中保存的光标列表的索引，应用程序也可以添加自定义光标到这个列表中 }
  propertyCursor: TCursor read FCursor writeSetCursor default crDefault; 
  { 属性：当鼠标指针移动到控件上时，要显示的提示信息字符串 }
  propertyHint: stringread FHint writeFHint stored IsHintStored; 
  { 属性：HelpType 用于指定控件的帮助主题使用哪种上下文敏感方式 }
  propertyHelpType: THelpType read FHelpType writeFHelpType default htContext; 
  { 属性：HelpKeyword 包含用于识别控件的帮助主题的关键字字符串，要使用基于关键字字符串的帮助功能，必须设置 HelpTyp 为 htKeyword }
  propertyHelpKeyword: Stringread FHelpKeyword writeSetHelpKeyword stored IsHelpContextStored; 
  { 属性：HelpContext 包含用于识别控件的帮助主题的上下文 ID，要使用基于上下文 ID 的帮助功能，必须设置 HelpTyp 为 htContext }
  propertyHelpContext: THelpContext read FHelpContext writeSetHelpContext stored IsHelpContextStored default 0; 
  { 属性：设置控件的外边距，只有当 AlignWithMargins 为 True，而且 Align 不为 alNone 时，外边距才有效 }
  propertyMargins: TMargins read FMargins writeSetMargins; 
  { 属性：控件的自定义提示信息 }
  propertyCustomHint: TCustomHint read GetCustomHint writeSetCustomHint; 
  { 属性：是否使用 Parent 的 CustomHint 信息，如果修改 CustomHint 的值，则 ParentCustomHint 自动变为 False }
  propertyParentCustomHint: Booleanread FParentCustomHint writeSetParentCustomHint default True;
end;

此时我们必须明白一些概念，Parent 和 Child 的关系是包含和被包含的关系，Owner 和 Sub 的关系是拥有与被拥有的关系。

TControl 中声明的 Parent 属性类似于 TComponent 中声明的 Owner 属性，因为 Parent 控件释放控件的过程就像 Owner 组件释放组件的过程。然而，Parent 控件通常是在视觉上包含其它控件的窗口控件，而且当窗体被保存时，还要负责将控件写入到流中。Owner 组件是通过构造函数的参数传入的组件，而且，如果指定了 Owner，那么当窗体被保存时，Owner
将保存所有对象（包括控件和它的 Parent 控件）。

Parent 负责 3 件事情：

1、Parent 负责将它的 Child 控件限制在自己的显示范围内，归自己管理。

2、Parent 在销毁时，负责销毁它的所有 Child 控件。

3、Parent 负责将它的 Child 控件写入到流中以便保存。

Owner 负责 2 件事情：

1、Owner 在销毁时负责释放它的所有子组件。

2、Owner 负责装载和保存它所拥有的控件的 Published 属性。

默认情况下，一个窗体将作为该窗体上所有组件的 Owner，同时 Application 又是窗体的 Owner。在窗体上放置组件时（包括放在 Panel 中的组件），窗体将默认成为该组件的 Owner。

警告：在设计期，如果一个组件的 Owner 不是一个窗体或一个数据模块，那么该组件不会跟随其 Owner 一起被保存和装载。除非通过 SetSubComponent 方法指定该组件为一个子组件。