| 方法 |
描述 |
| public: |
|
| TControl |
__fastcall virtual TControl(System::Classes::TComponent* AOwner);
构造函数 |
| ~TControl |
__fastcall virtual ~TControl(void);
析构函数 |
| ScaleForPPI |
virtual void __fastcall ScaleForPPI(int NewPPI);
按照 NewPPI 分辨率重新调整控件。
参数：NewPPI 分辨率，每英寸像素个数 |
| BeginDrag |
void __fastcall BeginDrag(bool Immediate, int Threshold = 0xffffffff);
拖拽控件。只有当 DragMode 属性为 dmManual 的时候需要调用这个方法，如果 DragMode 属性为 dmAutomatic，这个方法会被自动调用。请参考 BeginDrag 方法。
参数：Immediate: true: 鼠标变为 DragCursor 属性的形状，并且立即开始拖拽；false: 等待用户移动鼠标，如果用户移动鼠标的距离达到 Threshold 的时候，鼠标才会变为 DragCursor 属性的形状，并且开始拖拽。如果 Threshold 属性为负数，使用全局 Mouse 对象的 DragThreshold 属性。 |
| BringToFront |
void __fastcall BringToFront(void);
控件提到最前，可以挡住其他控件，不被其他控件挡住。相关方法：SendToBack。
从 TGraphicControl 继承的控件始终被从 TWinControl 继承的控件挡住；
BringToFront 可以调整 TGraphicControl 之间的遮挡关系，或者 TWinControl 之间的遮挡关系。 |
| ClientToScreen |
TPoint __fastcall ClientToScreen(const TPoint &Point);
客户区坐标转为屏幕坐标，相关方法：ScreenToClient。
参数：Point 客户区坐标，这个函数不会修改参数 Point 的值，转换之后的坐标是函数的返回值；
返回值：屏幕坐标。 |
| ClientToParent |
TPoint __fastcall ClientToParent(const TPoint &Point, TWinControl* AParent = NULL);
客户区坐标转为 Parent 坐标，相关方法：ParentToClient。
参数：Point 客户区坐标，这个函数不会修改参数 Point 的值，转换之后的坐标是函数的返回值；
AParent 必须是这个控件的容器，是第几层无所谓，即可以是 Parent 的 Parent，如果 AParent 值为 NULL，使用这个控件的直接容器；
返回值：Parent 坐标。 |
| Dock |
DYNAMIC void __fastcall Dock(TWinControl* NewDockSite, const TRect &ARect);
控件内部使用的函数，如果需要使用程序停靠控件，需要调用 ManualDock 方法。 |
| Dragging |
bool __fastcall Dragging(void);
返回控件是否正在被拖拽。 |
| DragDrop |
DYNAMIC void __fastcall DragDrop(System::TObject* Source, int X, int Y);
是 OnDragDrop 事件的默认处理，继承 TControl 的子类需要重载 DragDrop 方法实现 OnDragDrop 事件之前的处理工作，参数 X 和 Y 是控件放在这个坐标了 (鼠标位置) |
| DrawTextBiDiModeFlags |
int __fastcall DrawTextBiDiModeFlags(int Flags);
获取 Canvas 的 TextFlags 属性值，也可以提供给 DrawText 函数使用。
参数：Flags 为当前的 TextFlags，
返回值：根据 BiDiMode 属性调整之后的 TextFlags，可能会添加或去掉 DT_RIGHT 和 DT_RTLREADING |
| DrawTextBiDiModeFlagsReadingOnly |
int __fastcall DrawTextBiDiModeFlagsReadingOnly(void);
根据 BiDiMode 属性，获取是否需要在参数里面添加 DT_RTLREADING 来调用 Windows API 函数 DrawText。返回值：DT_RTLREADING 或 0 |
| EndDrag |
void __fastcall EndDrag(bool Drop);
结束 BeginDrag 开始的拖拽，请参考 BeginDrag 方法。
如果 Drop 参数为 true，会执行拖放或停靠动作，如果 Drop 参数为 false，取消拖拽操作 |
| GetControlsAlignment |
DYNAMIC System::Classes::TAlignment __fastcall GetControlsAlignment(void);
获取控件里面文字的对齐方式，如果控件没有 Alignment 属性，函数返回值为 taLeftJustify。
这个函数返回的值是没有根据 BiDiMode 修改的对齐方式。如果需要知道是否需要根据 BiDiMode 属性修改对齐方式，需要调用 UseRightToLeftAlignment 方法 |
| GetParentComponent |
DYNAMIC System::Classes::TComponent* __fastcall GetParentComponent(void);
重载 TComponent 的 GetParentComponent 方法。
返回容器组件，即 Parent 属性。如果这个组件没有放在容器里面，返回值为 NULL。
用 HasParent 方法可以获取这个组件是否在容器组件里面。
例如，把 Button 放在了 Form 上的 Panel 里面了，那么 Button 的 Parent 是 Panel，Panel 的 Parent 是 Form，而 Form 的 Parent 是 NULL。 |
| HasParent |
DYNAMIC bool __fastcall HasParent(void);
重载 TComponent 的 HasParent 方法。
获取这个组件是否放在了容器里面。如果放在了容器里面，返回 true。
可以用 GetParentComponent 获取容器组件，请参考 GetParentComponent 方法。 |
| Hide |
void __fastcall Hide(void);
隐藏控件，Visible 属性变为 false。请参考 Visible 属性和 Show 方法。 |
| InitiateAction |
virtual void __fastcall InitiateAction(void);
调用 ActionLink 的 Update 方法，如果控件关联了 ActionLink 属性。
当应用程序变为空闲，会调用每个 Form 的 InitiateAction，然后是可见的菜单项和控件的 InitiateAction 方法：
1. 包含这个 Action 的 ActionList 收到 OnUpdate 事件；
2. 如果 ActionList 没有处理 OnUpdate 事件，Application 对象会收到 OnActionUpdate 事件；
3. 如果 OnActionUpdate 事件也没有处理，这个 Action 会收到 OnUpdate 事件；
4. 如果没有更新 Action，当前活动控件的 UpdateAction 方法会被调用；
5. 如果 Action 仍然没有更新，当前活动 Form 的 UpdateAction 方法会被调用。 |
| Invalidate |
virtual void __fastcall Invalidate(void);
控件需要刷新显示，整个控件的内容即将重绘。连续多次调用 Invalidate 只会产生一次刷新事件。 |
| MouseWheelHandler |
DYNAMIC void __fastcall MouseWheelHandler(Winapi::Messages::TMessage &Message);
处理鼠标滚轮消息。WndProc 方法调用 MouseWheelHandler 处理鼠标滚轮消息，
如果控件嵌入窗口里面，会调用窗口的 MouseWheelHandler 方法；
如果控件不在窗口里面，会调用控件的 Perform 方法，产生 OnMouseWheel 事件，如果有需要，随后还会产生 OnMouseWheelUp 或 OnMouseWheelDown 事件 |
| IsRightToLeft |
bool __fastcall IsRightToLeft(void);
控件是否需要左右翻转，中东地区从右到左书写文字的地区，控件也要左右翻转才符合书写习惯。
BiDiMode 属性会反映书写方向。 |
| ManualDock |
bool __fastcall ManualDock(TWinControl* NewDockSite, TControl* DropControl = NULL, TAlign ControlSide = alNone);
把控件停靠在 NewDockSite 控件里面。
请参考 DragKind、DragMode、Floating、HostDockSite 属性和 ManualFloat 方法。
参数：NewDockSite 控件要停靠在这个控件里面；DropControl 是在 NewDockSite 里面的控件，控件停靠要放在这里，例如把控件停靠在 PageControl 里面，DropControl 是 TabSheet，通常这个参数为 NULL；ControlSide 为要停靠在 NewDockSite 里面的哪个边上，可以通过 DockSite 控件的 GetDockEdge 方法获取应该停靠在哪里，可以不指定停靠边缘，即参数的默认值 alNone。 |
| ManualFloat |
bool __fastcall ManualFloat(const System::Types::TRect &ScreenPos);
控件从停靠位置漂浮出来。
请参考 DragKind、DragMode、Floating、HostDockSite 属性和 ManualDock 方法。
参数 ScreenPos：漂浮出来的小窗口位置。 |
| Perform |
NativeInt __fastcall Perform(unsigned Msg, NativeUInt WParam, NativeInt LParam);
NativeInt __fastcall Perform(unsigned Msg, NativeUInt WParam, System::WideChar * LParam);
NativeInt __fastcall Perform(unsigned Msg, NativeUInt WParam, System::Types::TRect &LParam);
响应和处理收到的 Windows 消息，调用 Perform 可以越过 Windows 消息处理，直接让控件处理通过参数提供给 Perform 方法的消息。Perform 把参数 Msg、WParam 和 LParam 的值赋值到 TMessage 结构里面，Result 成员清零，然后调用 WindowProc 来处理消息。 |
| Refresh |
void __fastcall Refresh(void);
立即刷新显示，通过调用 Repaint 方法实现。调用 Refresh 和 Repaint 是一样的效果。 |
| Repaint |
virtual void __fastcall Repaint(void);
立即刷新显示，如果 ControlStyle 属性包含 csOpaque，控件刷新它自己，否则会先调用 Invalidate 方法，然后再调用 Update 方法，让控件露出部分的下面的控件也能够刷新。 |
| ReplaceDockedControl |
bool __fastcall ReplaceDockedControl(TControl* Control, TWinControl* NewDockSite, TControl* DropControl, TAlign ControlSide);
把控件停靠在其他控件停靠的位置，替换那个控件，那个控件移动到另外的 DockSite。
参数：Control 是要替换到这个控件的位置，这个控件要移动到新的 NewDockSite 里面，DropControl 为 NewDockSite 里面的，停靠之后要放在这个控件里面，ControlSide 为停靠的边缘。请参考 ManualDock 方法。 |
| ScreenToClient |
System::Types::TPoint __fastcall ScreenToClient(const System::Types::TPoint &Point);
屏幕坐标转换为客户区坐标，相关方法：ClientToScreen。
参数：Point 屏幕坐标，这个函数不会修改参数 Point 的值，转换之后的坐标是函数的返回值；
返回值：客户区坐标。 |
| ParentToClient |
System::Types::TPoint __fastcall ParentToClient(const System::Types::TPoint &Point, TWinControl* AParent = NULL);
Parent 坐标转为客户区坐标，相关方法：ClientToParent。
参数：Point 为 Parent 坐标，这个函数不会修改参数 Point 的值，转换之后的坐标是函数的返回值；
AParent 必须是这个控件的容器，是第几层无所谓，即可以是 Parent 的 Parent，如果 AParent 值为 NULL，使用这个控件的直接容器；
返回值：客户区坐标。 |
| SendToBack |
void __fastcall SendToBack(void);
控件放到最后，被其他控件挡住，不遮挡其他控件。相关方法：BringToFront。
从 TGraphicControl 继承的控件始终被从 TWinControl 继承的控件挡住；
BringToFront 可以调整 TGraphicControl 之间的遮挡关系，或者 TWinControl 之间的遮挡关系。 |
| SetBounds |
virtual void __fastcall SetBounds(int ALeft, int ATop, int AWidth, int AHeight);
同时修改 Left、Top、Width 和 Height 属性，只需要一次刷新显示。
AutoSize 和 Constraints 属性会限制或影响调整之后的大小，并且会产生 OnResize 事件，
而 UpdateBoundsRect 方法不受这些限制，也不产生事件。 |
| SetDesignVisible |
DYNAMIC void __fastcall SetDesignVisible(bool Value);
内部调用的方法，控件在设计期间隐藏或显示，Value: true 显示，false: 隐藏。
执行可以让 ControlState 属性包含或去掉 csDesignerHide 状态。
请参考 ControlState 和 ComponentState 属性，和在设计期间显示和隐藏不可视控件 |
| SetParentComponent |
DYNAMIC void __fastcall SetParentComponent(System::Classes::TComponent* Value);
设置控件的 Parent，内部调用的函数，不要直接调用。
只有 Value 是从 TWinControl 继承的控件或窗口的时候 SetParentComponent 才会调用 SetParent 方法。
如果要修改或设置 Parent 属性，可以直接给 Parent 属性赋值。 |
| Show |
void __fastcall Show(void);
显示控件，Visible 属性变为 true。请参考 Visible 属性和 Hide 方法。 |
| Update |
virtual void __fastcall Update(void);
立即执行等待的刷新，不等待 Windows 的刷新消息。也就是说，调用 Update 方法只是重新绘制控件，不通过 Invalidate 让显示区域失效的方法。调用 Update 可能会有额外的耗时，但是会让用户立即看到刷新的结果。 |
| UseRightToLeftAlignment |
DYNAMIC bool __fastcall UseRightToLeftAlignment(void);
控件是否需要从右到左的对齐，实现 BiDiMode 属性会调用这个方法，会影响显示和鼠标事件，当 BiDiMode 属性是 bdRightToLeft 的时候函数返回 true。 |
| UseRightToLeftReading |
bool __fastcall UseRightToLeftReading(void);
控件采用从右到左的书写和阅读，实现 BiDiMode 属性会调用这个方法，控件的文字从右到左阅读，当 BiDiMode 属性不是 bdLeftToRight 的时候函数返回 true。 |
| UseRightToLeftScrollBar |
bool __fastcall UseRightToLeftScrollBar(void);
控件的垂直滚条在左边，实现 BiDiMode 属性会调用这个方法，当 BiDiMode 属性是 bdRightToLeft 或 bdRightToLeftNoAlign 的时候函数返回 true。 |
| DefaultHandler |
virtual void __fastcall DefaultHandler(void *Message);
重载 TObject 的 DefaultHandler 方法。
默认的消息处理。如果 Dispatch 处理消息的过程，没有找到处理的方法，会调用 DefaultHandler 进行默认的消息处理。 |
| GetTextBuf |
int __fastcall GetTextBuf(System::WideChar * Buffer, int BufSize);
读取 Text 属性到 Buffer 里面，Buffer 的容量为 BufSize，包括结束符。
返回值为实际复制的字符个数，是 Text 的长度或 BufSize-1。
读取控件的文字需要使用 Text 属性，这个方法只是为了兼容保留下来的。 |
| GetTextLen |
int __fastcall GetTextLen(void);
返回 Text 属性的长度，请参考 GetTextBuf 方法。
读取控件的文字需要使用 Text 属性，这个方法只是为了兼容保留下来的。 |
| SetTextBuf |
void __fastcall SetTextBuf(System::WideChar * Buffer);
设置 Text 属性为 Buffer。
修改控件的文字需要使用 Text 属性，这个方法只是为了兼容保留下来的。 |
| TComponent:: |
从 TComponent 继承过来的 |
| TComponent |
__fastcall virtual TComponent(TComponent* AOwner);
构造函数。
AOwner 为这个组件的拥有者，请参考 Owner 属性。 |
| ~TComponent |
__fastcall virtual ~TComponent(void);
析构函数 |
| BeforeDestruction |
virtual void __fastcall BeforeDestruction(void);
重载了 TObject 的 BeforeDestruction。
在执行析构函数之前会自动调用 BeforeDestruction，不要直接调用这个函数。
在调用 BeforeDestruction 的时候，还没做任何销毁动作呢。
只有当构造函数完整执行完成的情况下，析构之前才会调用 BeforeDestruction，如果在构造函数里面抛出了异常，会调用析构函数，但是不会调用 BeforeDestruction。
重载这个函数可以处理析构函数调用之前需要运行的代码，
TComponent 组件在 BeforeDestruction 里面检查 Destroying 方法是否被调用了，如果没被调用过，就调用它。 |
| BeginInvoke |
System::Types::_di_IAsyncResult __fastcall BeginInvoke(const System::Sysutils::_di_TProc AProc, System::TObject* const AContext = (System::TObject*)(0x0))/* overload */;
System::Types::_di_IAsyncResult __fastcall BeginInvoke(const TAsyncProcedureEvent AProc, System::TObject* const AContext = (System::TObject*)(0x0))/* overload */;
template<typename TResult> System::Types::_di_IAsyncResult __fastcall BeginInvoke(const System::DelphiInterface<System::Sysutils::TFunc__1<TResult> > AFunc, System::TObject* const AContext = (System::TObject*)(0x0))/* overload */;
System::Types::_di_IAsyncResult __fastcall BeginInvoke(const _di_TAsyncConstArrayProc AProc, const System::TVarRec *Params, const int Params_High, System::TObject* const AContext = (System::TObject*)(0x0))/* overload */;
template<typename TResult> System::Types::_di_IAsyncResult __fastcall BeginInvoke(const System::DelphiInterface<TAsyncConstArrayFunc__1<TResult> > AFunc, const System::TVarRec *Params, const int Params_High, System::TObject* const AContext = (System::TObject*)(0x0))/* overload */;
System::Types::_di_IAsyncResult __fastcall BeginInvoke(const TAsyncConstArrayProcedureEvent AProc, const System::TVarRec *Params, const int Params_High, System::TObject* const AContext = (System::TObject*)(0x0))/* overload */;
System::Types::_di_IAsyncResult __fastcall BeginInvoke(const TAsyncConstArrayFunctionEvent AFunc, const System::TVarRec *Params, const int Params_High, System::TObject* const AContext = (System::TObject*)(0x0))/* overload */;
System::Types::_di_IAsyncResult __fastcall BeginInvoke(const TAsyncFunctionEvent AFunc, System::TObject* const AContext = (System::TObject*)(0x0))/* overload */;
异步调用 AProc 或 AFunc。AContext 提供执行的内容，在主线程里面执行。如果是从 TControl 继承的，执行在最近创建的窗口句柄所在的线程。
返回值：IAsyncResult 类型的异步执行的结果。 |
| EndInvoke |
void __fastcall EndInvoke(const System::Types::_di_IAsyncResult ASyncResult)/* overload */;
template<typename TResult> TResult __fastcall EndInvoke(const System::Types::_di_IAsyncResult AsyncResult)/* overload */;
等待异步执行的结果，返回 BeginInvoke 的执行结果。EndInvoke 会抛出在异步执行当中发生的异常。 |
| EndFunctionInvoke |
System::TObject* __fastcall EndFunctionInvoke(const System::Types::_di_IAsyncResult AsyncResult);
等待异步执行的结果，返回 BeginInvoke 的执行结果，返回结果类型为 TObject *。EndInvoke 会抛出在异步执行当中发生的异常。 |
| DestroyComponents |
void __fastcall DestroyComponents(void);
销毁所有容纳的子组件。
不需要直接调用这个方法，当组件被销毁的时候，会自动调用 DestroyComponents 来销毁所有的子组件。 |
| Destroying |
void __fastcall Destroying(void);
指示这个组件，和这个组件容纳的所有子组件，都将被销毁。
Destroying 方法会在 ComponentState 属性里面添加 csDestroying 状态标志。
不需要直接调用这个方法，当组件被销毁的时候，会自动调用 Destroying 方法。 |
| ExecuteAction |
DYNAMIC bool __fastcall ExecuteAction(TBasicAction* Action);
执行一个 Action。Action 可以是一个 TBasicAction 或者从 TBasicAction 继承的类。
ExecuteAction 方法检查 Action 是否和这个组件兼容并且执行这个 Action。
如果执行了 Action，函数返回 true，如果没执行，返回 false。
子类可以重载 ExecuteAction 提供对 Action 的不同的执行方法。 |
| FindComponent |
TComponent* __fastcall FindComponent(const System::UnicodeString AName);
通过名称 AName 查找子组件，不区分大小写。 |
| FreeNotification |
void __fastcall FreeNotification(TComponent* AComponent);
把这个组件将要被销毁的信息通知给 AComponent。
当这个组件和 AComponent 在不同的 Form 里面或者 Owner 不同的情况，AComponent 把这个组件当作属性的时候，这个组件被销毁的时候需要通知给 AComponent。 |
| RemoveFreeNotification |
void __fastcall RemoveFreeNotification(TComponent* AComponent);
把 FreeNotification 的通知信息去掉。
大多数情况应用程序不需要调用这个方法，组件检测到通知循环，比如当两个组件互相通知对方销毁信息的时候，需要去掉不必要的通知信息。 |
| FreeOnRelease |
void __fastcall FreeOnRelease(void);
使用 COM 接口的组件，当调用 Release 方法的时候，会调用这个方法。
FreeOnRelease 是组件内部调用的方法，不要直接调用。 |
| GetEnumerator |
TComponentEnumerator* __fastcall GetEnumerator(void);
返回一个枚举对象，枚举某个容器里面所有组件的枚举对象。
如果处理所有的子组件，在一个循环里面，调用 TComponentEnumerator 里面的 GetCurrent 方法获取组件，调用 MoveNext 来循环每个组件。 |
| GetNamePath |
DYNAMIC System::UnicodeString __fastcall GetNamePath(void);
重载了 TPersistent 的 GetNamePath 方法。
返回在 Object Inspector 属性面板里面的名称。对于控件，返回控件的名称，对于 TCollectionItem 对象，返回宿主控件的名称、属性名和 [索引号]。
TComponent 组件重载这个方法用来返回组件的名称，组件内部使用，不要直接调用这个方法。 |
| InsertComponent |
void __fastcall InsertComponent(TComponent* const AComponent);
把 AComponent 作为这个组件的子组件，加入 Components 属性里面。
AComponent 的 Name 属性可以为空，如果不为空，必须不能和 Components 里面其他组件同名。
这个组件被销毁的时候，AComponent 也会被销毁。
在使用画面编辑器的设计期间，这个工作是自动处理的。 |
| RemoveComponent |
void __fastcall RemoveComponent(TComponent* const AComponent);
把 AComponent 从子组件 Components 里面移除。
在使用画面编辑器的设计期间，这个工作是自动处理的。 |
| SetSubComponent |
void __fastcall SetSubComponent(bool IsSubComponent);
设置这个组件为 SubComponent，如果参数 IsSubComponent 为 true，会在 ComponentStyle 属性里面添加 csSubComponent 样式，否则会去掉这个样式。 |
| SafeCallException |
virtual HRESULT __fastcall SafeCallException(System::TObject* ExceptObject, void * ExceptAddr);
重载了 TObject 的 SafeCallException。
TComponent 调用这个方法，当它支持 COM 接口的时候，处理接口的异常。如果不支持 COM 接口，会调用 TObject 的这个方法，即返回 E_UNEXPECTED。 |
| UpdateAction |
virtual bool __fastcall UpdateAction(TBasicAction* Action);
更新 Action 的状态。Action 可以是 TBasicAction 或从 TBasicAction 继承的子类对象。
返回 true，如果更新了 Action 的状态，返回 false 如果没有更新。
子类可以重载这个方法了提供不同的处理方法。 |
| IsImplementorOf |
bool __fastcall IsImplementorOf(const System::_di_IInterface I);
这个方法与 QueryInterface 类似，不同的是，这个方法支持 NULL 接口请求，不返回接口指针。
流处理系统利用这个方法来存取接口类型的属性值。 |
| ReferenceInterface |
bool __fastcall ReferenceInterface(const System::_di_IInterface I, TOperation Operation);
建立或移除内部链接来通知这个组件，当指定的接口被销毁的时候。当组件的属性是接口的时候使用。
I 是 __published: 属性的接口指针，Operation 的值可以为：opInsert: 建立，opRemove: 移除。
返回值：true 为执行成功，false 为执行失败。 |
operator
_di_IInterfaceComponentReference() |
operator _di_IInterfaceComponentReference()
{
_di_IInterfaceComponentReference intf;
this->GetInterface(intf);
return intf;
}
类型转换操作符，把当前组件转为 _di_IInterfaceComponentReference 类型时使用。 |
operator
_di_IInterface() |
operator System::_di_IInterface()
{
System::_di_IInterface intf;
this->GetInterface(intf);
return intf;
}
类型转换操作符，把当前组件转为 _di_IInterface 类型时使用。 |
| TPersistent:: |
从 TPersistent 继承过来的 |
| Assign |
virtual void __fastcall Assign(TPersistent *Source);
把 Source 对象的所有的属性和数据赋值到当前对象，包括类型和格式转换再赋值。
【例：jpg, gif, png, bmp 之间的格式转换】 |
| TObject:: |
从 TObject 继承过来的 |
| Free |
void __fastcall Free(void);
C++ 程序需要用 delete 来销毁对象，不要调用 Free 方法。
Delphi 程序可以通过调用 Free 方法来调用析构函数释放分配的内存，空指针和未初始化的对象调用 Free 不会出错。 |
| DisposeOf |
void __fastcall DisposeOf(void);
PC 版本，相当于 Free；移动版本，会强制销毁对象无论 RefCount 的值是多少，并且置 Disposed 属性为 true. |
| InitInstance |
__classmethod __unsafe TObject* __fastcall InitInstance(void * Instance);
初始化成员，给他们清零。这是 NewInstance 内部调用的函数，不要直接调用 InitInstance。
重载 NewInstance 的时候，在 NewInstance 的最后一句要调用 InitInstance。
不要重载 InitInstance，因为它不是 virtual 函数。 |
| NewInstance |
__classmethod virtual __unsafe TObject* __fastcall NewInstance();
NewInstance 给实例分配内存，并且返回新的实例的地址，通过调用 InstanceSize 获取需要的内存的字节数。
构造函数会自动调用 NewInstance，不要直接调用 NewInstance。
如果重载了 NewInstance 分配内存，就必须重载 FreeInstance 释放内存。 |
| InstanceSize |
__classmethod int __fastcall InstanceSize();
返回给实例数据分配内存需要多少字节数。
不要重载 InstanceSize 因为它不是 virtual 函数。
只有在重载的 NewInstance 函数里面需要调用 InstanceSize。 |
| FreeInstance |
virtual void __fastcall FreeInstance(void);
释放 NewInstance 分配的内存。
析构函数会自动调用 FreeInstance，不要直接调用 FreeInstance。
如果重载了 NewInstance 就必须重载 FreeInstance 与之对应。
和 NewInstance 一样，FreeInstance 也是通过 InstanceSize 获取释放内存的字节数。 |
| CleanupInstance |
void __fastcall CleanupInstance(void);
清除长字符串、Variants、接口变量等，把长字符串置为 Empty，Variant 置为 Unassigned 状态。
不要直接调用 CleanupInstance，会在销毁实例的时候自动调用。 |
| ClassType |
TClass __fastcall ClassType(void);
返回类的类型信息【例1：获取控件对象的类及这个类的祖先】
C++ 程序可以使用 dynamic_cast 或 InheritsFrom 来代替 ClassType 方法。 |
| ClassName |
__classmethod UnicodeString __fastcall ClassName();
获取类名。如果父类指针指向的是子类，通过父类指针获取类名，得到的是子类的类名。 |
| ClassNameIs |
__classmethod bool __fastcall ClassNameIs(const UnicodeString Name);
判断类名是否为 Name。如果父类指针指向的是子类，通过父类指针判断类名，用的是子类的类名进行判断。 |
| QualifiedClassName |
__classmethod UnicodeString __fastcall QualifiedClassName();
返回包含命名空间的类名，例如 TButton 类型返回的是 "Vcl.StdCtrls.TButton"
UnitName 和 ClassName 合在一起就是 QualifiedClassName |
| UnitName |
__classmethod UnicodeString __fastcall UnitName();
返回类所在的命名空间，例如 TButton 类型返回的是 "Vcl.StdCtrls"
UnitName 和 ClassName 合在一起就是 QualifiedClassName |
| UnitScope |
__classmethod UnicodeString __fastcall UnitScope();
和 UnitName 返回的结果相同。 |
| ClassParent |
__classmethod TClass __fastcall ClassParent();
返回父类的类型信息【例1：获取控件对象的类及这个类的祖先】
C++ 程序可以使用 dynamic_cast 或 InheritsFrom 来代替 ClassParent 方法。 |
| ClassInfo |
__classmethod void * __fastcall ClassInfo();
返回运行时类型信息表 (RTTI table)。
不是所有的类都提供 RTTI 信息表，如果没有提供，返回值为 NULL。
从 TPersistent 继承的类会提供 RTTI 信息表。 |
| InheritsFrom |
__classmethod bool __fastcall InheritsFrom(TClass AClass);
当前对象的类是否从 AClass 继承过来的。AClass 是父类、父类的父类，…… 一直到祖先，返回为真。 |
| MethodAddress |
__classmethod void * __fastcall MethodAddress(const ShortString &Name)/* overload */;
__classmethod void * __fastcall MethodAddress(const UnicodeString Name)/* overload */;
通过名称返方法的地址。 |
| MethodName |
__classmethod UnicodeString __fastcall MethodName(void *Address);
通过方法的地址返回名称。 |
| FieldAddress |
void * __fastcall FieldAddress(const ShortString &Name)/* overload */;
void * __fastcall FieldAddress(const UnicodeString Name)/* overload */;
返回 __published: 成员的地址。 |
| GetInterface |
bool __fastcall GetInterface(const GUID &IID, /* out */ void *Obj);
template <typename T>
bool __fastcall GetInterface(DelphiInterface<T>& smartIntf)
{
return GetInterface(__uuidof(T), reinterpret_cast<void*>(static_cast<T**>(&smartIntf)));
}
Delphi 的 IID 允许用接口名称，编译器会自动采用类型的 GUID。
C++ 可以用模板版本的 GetInterface，相当于 dynamic_cast，GetInterface 在转为不支持的类型的时候不会抛出异常，只是得到的指针为 NULL，请参考 TInterfacedPersistent 的 operator
_di_IInterface()。
参数 Obj 虽然是 void * 类型的，但是实质上是 void ** 类型的，必须把 void ** 强制转为 void * 作为 Obj 参数。 |
| GetInterfaceEntry |
__classmethod PInterfaceEntry __fastcall GetInterfaceEntry(const GUID &IID);
获取接口项目 |
| GetInterfaceTable |
__classmethod PInterfaceTable __fastcall GetInterfaceTable();
获取接口表 |
| Equals |
virtual bool __fastcall Equals(TObject *Obj);
比较当前对象和 Obj 对象是否相同。从 TObject 继承的子类需要重载 Equals 来提供比较相同的方法。 |
| GetHashCode |
virtual int __fastcall GetHashCode(void);
返回一个整数的 hash 值，默认的，返回的整数值为对象的地址。
测试程序：int a = Sender->GetHashCode();
int b = (int)Sender; 发现 a 和 b 的值相等。 |
| ToString |
virtual UnicodeString __fastcall ToString(void);
转为字符串。默认的，ToString 返回类名，和 ClassName 的返回值相同。
如果需要其他的转字符串方式，需要用重载 ToString 来提供转为字符串的方法。 |
| AfterConstruction |
virtual void __fastcall AfterConstruction(void);
在构造函数结束的时候会自动调用 AfterConstruction，不要直接调用这个函数。
重载这个函数可以处理在构造函数结束时需要运行的代码，
例如 TCustomForm 利用重载的 AfterConstruction 来产生 OnCreate 事件。 |
| Dispatch |
virtual void __fastcall Dispatch(void *Message);
如果从 TObject 类继承的类处理了消息，Dispatch 为处理消息的函数。
如果没有处理的消息，会调用父类的消息处理，如果仍然没有处理，调用 DefaultHandler。 |
| protected: |
|
| GetDesignDpi |
virtual int __fastcall GetDesignDpi(void);
控件内部使用的方法，返回控件所在 Form 或 Form 本身的 PixelsPerInch 属性 |
| GetParentCurrentDpi |
virtual int __fastcall GetParentCurrentDpi(void);
控件内部使用的方法，返回最底层 Parent 的 FCurrentPPI 属性，即 Parent 的 Parent 的 Parent …… (这样找到的可能是 Form) 的 FCurrentPPI 属性，请参考 ScaleForPPI 方法。 |
| AsyncSchedule |
virtual void __fastcall AsyncSchedule(TBaseAsyncResult* const AsyncResult);
重载 TComponent 的 AsyncSchedule 方法。
把异步执行 ASyncResult 添加到主线程的队列里面。 |
| ActionChange |
DYNAMIC void __fastcall ActionChange(System::TObject* Sender, bool CheckDefaults);
控件关联的 Action 有变化的时候，关联到不同的 Action，或者关联的 Action 的属性有变化，会触发和执行 ActionLink 的 OnChange 事件，在这个事件里面会调用控件的 ActionChange 方法。
ActionChange 方法会根据 Action 的属性更新控件的属性，例如 Caption、Enabled、Hint、Visisble 属性和 OnClick 事件等。
参数 Sender 指向有变化的 Action 对象；
CheckDefaults 为 false 表示所有属性都需要更新，true 表示只更新属性值等于默认值的属性 |
| AdjustSize |
DYNAMIC void __fastcall AdjustSize(void);
控件内部调用的方法，不要直接调用。当 AutoSize 为 true 的时候，会自动调用 AdjustSize 方法调整控件的大小，调整大小是通过调用 SetBounds 方法实现的。 |
| AssignTo |
virtual void __fastcall AssignTo(System::Classes::TPersistent* Dest);
重载 TPersistent 的 AssignTo 方法。
把当前对象的所有属性和数据都赋值到 Dest 对象。
从 TPersistent 继承的子类必须重载 AssignTo 来实现这个方法。 |
| BeginAutoDrag |
DYNAMIC void __fastcall BeginAutoDrag(void);
控件内部调用的方法。当 DragMode 属性为 dmAutomatic 的时候，会自动调用这个方法。
BeginAutoDrag 会调用 BeginDrag 方法，使用全局的 Mouse 对象的 DragImmediate 和 DragThreshold 属性作为参数。在应用程序里面不要直接调用这个方法，手动拖拽请使用 BeginDrag 方法。 |
| CanResize |
virtual bool __fastcall CanResize(int &NewWidth, int &NewHeight);
当控件的大小发生变化是，会自动调用 CanResize 方法，参数 NewWidth 和 NewHeight 是尝试把控件改为这个宽度和高度，如果这个宽度和高度合理，函数返回 true，允许修改控件大小；如果宽度和高度不合理，可以在这个函数里面修改参数 NewWidth 和 NewHeight 到一个合理的值，然后返回 true 允许修改控件的大小，也可以直接返回 false 不允许修改控件的大小。
CanResize 会产生 OnCanResize 事件，在 OnCanResize 事件里面也可以修改这个宽度和高度值，或者拒绝改变控件的大小。 |
| CanAutoSize |
virtual bool __fastcall CanAutoSize(int &NewWidth, int &NewHeight);
当 AutoSize 属性为 true 的时候会自动调用这个方法。当尝试改变大小之前会产生 OnCanResize 和 OnConstrainedResize 事件，在改变大小完成的时候会产生 OnResize 事件。
参数 NewWidth 和 NewHeight 是尝试把控件改为这个宽度和高度，如果这个宽度和高度合理，函数返回 true，允许修改控件大小；如果宽度和高度不合理，可以在这个函数里面修改参数 NewWidth 和 NewHeight 到一个合理的值，然后返回 true 允许修改控件的大小，也可以直接返回 false 不允许修改控件的大小。 |
| Changed |
void __fastcall Changed(void);
给控件发送一个 CM_CHANGED 消息。如果控件的属性值变化了，会自动调用 Changed 方法，如果这是有窗口句柄的控件，会把消息发给 Parent 以进行必要的调整。请参考 Parent 属性。 |
| ChangeScale |
DYNAMIC void __fastcall ChangeScale(int M, int D);
DYNAMIC void __fastcall ChangeScale(int M, int D, bool isDpiChange);
当控件需要改变大小的时候会自动调用这个方法。
这和 Left 和 Top 属性不变，调整 Width 和 Height 属性的效果一样，按照一定的比例放大或缩小控件，新的宽度或高度 = 原先的宽度或高度 * M / D，如果 M = 3，D = 4，那么就是把控件变为原来的 3/4 那么大，即 75% 大小。 |
| Click |
DYNAMIC void __fastcall Click(void);
当使用鼠标左键点击控件的时候，会自动调用 Click 方法。如果用程序调用控件的 Click 方法，就相当于模拟点击鼠标。调用 Click 方法会产生 OnClick 事件，如果 OnClick 事件关联到了程序里面的事件处理函数；如果没有关联事件处理函数，控件关联了 Action 控件，会产生关联的 Action 控件的 OnExecute 事件。 |
| ConstrainedResize |
virtual void __fastcall ConstrainedResize(int &MinWidth, int &MinHeight, int &MaxWidth, int &MaxHeight);
如果 Constraints 属性包含不等于 0 的值，当控件改变大小的时候会调用这个方法，这个方法会产生 OnConstrainedResize 事件。 |
| CalcCursorPos |
System::Types::TPoint __fastcall CalcCursorPos(void);
获取鼠标的位置，相对于客户区坐标，
如果鼠标位置不在客户区范围之内，会出现负值或大于客户区宽度和高度的坐标值。 |
| CreateTouchManager |
virtual void __fastcall CreateTouchManager(void);
创建 TouchManager，默认的是 TTouchManager 类型，请参考 Touch 属性。
如果要创建不同类型的 TouchManager，可以通过重载 CreateTouchManager 方法来实现。 |
| DblClick |
DYNAMIC void __fastcall DblClick(void);
双击鼠标会自动调用这个方法，鼠标左键双击 Windows 消息 WM_LBUTTONDBLCLK 使用这个方法处理。
DblClick 会触发和执行 OnDblClick 事件。 |
| DefaultDockImage |
DYNAMIC void __fastcall DefaultDockImage(TDragDockObject* DragDockObject, bool Erase);
绘制和擦除拖拽和停靠 (Dock) 使用的图像，通过调用 DrawDragDockImage 和 EraseDragDockImage 方法实现。 |
| DefineProperties |
virtual void __fastcall DefineProperties(System::Classes::TFiler* Filer);
重载了 TComponent 的 DefineProperties 方法。
提供把非 __published: 属性 (IsControl 属性) 存入流中或从流中读出，是 protected: 方法。
如果子类需要这个功能，需要重载这个函数，在重载的 DefineProperties 需要调用父类的 DefineProperties，Filter 的 DefineProperty 和 DefineBinaryProperty。 |
| DockTrackNoTarget |
DYNAMIC void __fastcall DockTrackNoTarget(TDragDockObject* Source, int X, int Y);
处理拖拽控件到无效的目标上的方法，当拖拽和停靠时会自动调用这个方法。
参数 Source 影响鼠标的坐标，即 X 和 Y。 |
| DoContextPopup |
DYNAMIC void __fastcall DoContextPopup(const TPoint &MousePos, bool &Handled);
当控件的弹出菜单弹出的时候，会自动调用这个方法，这个方法会触发和执行 OnContextPopup 事件。
子类可以重载这个方法来处理 OnContextPopup 事件需要处理的内容。
如果用鼠标右键点击弹出这个菜单，参数 MousePos 是鼠标点击的位置的坐标，如果是通过按键盘按键弹出的菜单，MousePos 的坐标为 (-1, -1)。如果在这个函数里面处理了这个事件，不希望调用默认的处理，Handled 参数需要返回 true，如果返回 false，这个函数结束时会调用默认的处理。 |
| DoEndDock |
DYNAMIC void __fastcall DoEndDock(System::TObject* Target, int X, int Y);
当控件结束停靠的时候，会自动调用这个方法，这个方法会触发和执行 OnEndDock 事件。
子类可以重载这个方法来处理 OnEndDock 事件需要处理的内容。 |
| DoDock |
DYNAMIC void __fastcall DoDock(TWinControl* NewDockSite, System::Types::TRect &ARect);
处理拖放事件，在拖放的过程中会自动调用这个方法。
参数 NewDockSite 是这个控件的新的停靠控件 (DockSite)，如果没有有效的控件，可能等于 NULL 或 NullDockSite，ARect 是这个控件将要停靠的位置。 |
| DoStartDock |
DYNAMIC void __fastcall DoStartDock(TDragObject* &DragObject);
当控件开始停靠的时候，会自动调用这个方法，这个方法会触发和执行 OnStartDockevent 事件。
子类可以重载这个方法来处理 OnStartDockevent 事件需要处理的内容。 |
| DoMouseWheel |
DYNAMIC bool __fastcall DoMouseWheel(System::Classes::TShiftState Shift, int WheelDelta, const System::Types::TPoint &MousePos);
处理鼠标滚轮，当拨动鼠标滚轮的时候，会自动调用这个方法，这个方法会触发和执行 OnMouseWheel 事件。如果 OnMouseWheel 事件处理了滚轮事件，DoMouseWheel 会返回 true，否则会调用 DoMouseWheelDown 或 DoMouseWheelUp 方法，根据滚轮拨动的方向，而这两个方法会触发和执行 OnMouseWheelUp 或 OnMouseWheelDown 事件。在第一次调用 DoMouseWheelDown 或 DoMouseWheelUp 方法之前，会把 WheelDelta 值加入 WheelAccumulator 属性，调用完成，会把 WheelAccumulator 属性向零值方向调整 (绝对值减少) 一个内定的数值，如果减少之后的数值的绝对值仍然超过内定的递减值，会再次调用 DoMouseWheelDown 或 DoMouseWheelUp 和调整 WheelAccumulator 属性，一直到 WheelAccumulator 减少到绝对值小于那个内定值。DoMouseWheel 返回最后一次调用 DoMouseWheelDown 或 DoMouseWheelUp 方法的返回值。 |
| DoMouseWheelDown |
DYNAMIC bool __fastcall DoMouseWheelDown(System::Classes::TShiftState Shift, const System::Types::TPoint &MousePos);
鼠标滚轮向下拨动，会触发和执行 OnMouseWheelDown 事件，请参考 DoMouseWheel 方法。 |
| DoMouseWheelUp |
DYNAMIC bool __fastcall DoMouseWheelUp(System::Classes::TShiftState Shift, const System::Types::TPoint &MousePos);
鼠标滚轮向上拨动，会触发和执行 OnMouseWheelUp 事件，请参考 DoMouseWheel 方法。 |
| DragCanceled |
DYNAMIC void __fastcall DragCanceled(void);
当拖拽动作取消的时候，会自动调用这个方法。TControl 的 DragCanceled 方法没有做任何事情，如果子类想在取消拖拽的时候做一些处理，可以重载这个方法。 |
| DragOver |
DYNAMIC void __fastcall DragOver(System::TObject* Source, int X, int Y, System::Uitypes::TDragState State, bool &Accept);
在拖拽的时候会自动调用这个方法，Source 是被拖拽的控件，State 是拖拽的状态，X 和 Y 是拖拽时鼠标的位置，如果可以接受把 Source 放在这里，需要把 Accept 参数设为 true，如果不接受把 Source 放在这里，需要把 Accept 参数设为 false。 |
| DoEndDrag |
DYNAMIC void __fastcall DoEndDrag(System::TObject* Target, int X, int Y);
当拖拽结束的时候会自动调用这个方法，这个方法会触发和执行 OnEndDrag 事件。
如果子类需要在 OnEndDrag 事件里面做一些处理，可以重载这个方法。 |
| DoStartDrag |
DYNAMIC void __fastcall DoStartDrag(TDragObject* &DragObject);
当拖拽开始的时候会自动调用这个方法，这个方法会触发和执行 OnStartDrag 事件。
如果子类需要在 OnStartDrag 事件里面做一些处理，可以重载这个方法。 |
| DoGesture |
virtual void __fastcall DoGesture(const TGestureEventInfo &EventInfo, bool &Handled);
处理未处理的手势事件。只有 OnGesture 事件没有关联到事件处理函数，或者 OnGesture 事件没有处理事件内容的时候，才会调用这个方法。
子类可以通过重载这个方法来处理未处理的手势消息。TControl 的 DoGesture 方法没有处理任何事情 |
| DoGetGestureOptions |
virtual void __fastcall DoGetGestureOptions(TInteractiveGestures &Gestures, TInteractiveGestureOptions &Options);
控件内部调用的方法，获取手势处理选项 |
| DrawDragDockImage |
DYNAMIC void __fastcall DrawDragDockImage(TDragDockObject* DragDockObject);
绘制停靠图像，这个方法会自动被调用，用来画拖拽时的控件 (通常会画一个拖拽时的方块)，请参考 DefaultDockImage 方法 |
| EraseDragDockImage |
DYNAMIC void __fastcall EraseDragDockImage(TDragDockObject* DragDockObject);
擦除停靠图像，这个方法会自动被调用，用来擦除拖拽时的控件 (通常会画一个拖拽时的方块)，请参考 DefaultDockImage 方法 |
| GetAction |
virtual System::Classes::TBasicAction* __fastcall GetAction(void);
获取 Action 属性值，请参考 Action 属性 |
| GetActionLinkClass |
DYNAMIC TControlActionLinkClass __fastcall GetActionLinkClass(void);
获取 ActionLink 属性值，请参考 ActionLink 属性。 |
| GetClientOrigin |
virtual System::Types::TPoint __fastcall GetClientOrigin(void);
获取 ClientOrigin 属性的值，请参考 ClientOrigin 属性。 |
| GetClientRect |
virtual System::Types::TRect __fastcall GetClientRect(void);
获取 ClientRect 属性的值，请参考 ClientRect 属性。 |
| GetDeviceContext |
virtual HDC __fastcall GetDeviceContext(HWND &WindowHandle);
获取窗口句柄和 HDC (device context)，如果这个控件不是从 TWinControl 继承的控件，会调用 Parent 的 GetDeviceContext 方法。 |
| GetDockEdge |
DYNAMIC TAlign __fastcall GetDockEdge(const System::Types::TPoint &MousePos);
如果有其他控件拖拽到这个控件，获取那个控件应该停靠在哪个边缘，在拖拽的过程中，会自动调用这个方法。请参考 ManualDock 方法。 |
| GetEnabled |
virtual bool __fastcall GetEnabled(void);
获取 Enabled 属性的值，请参考 Enabled 属性。 |
| GetFloating |
virtual bool __fastcall GetFloating(void);
获取 Floating 属性的值，请参考 Floating 属性。 |
| GetFloatingDockSiteClass |
virtual TWinControlClass __fastcall GetFloatingDockSiteClass(void);
获取 FloatingDockSiteClass 属性的值，请参考 FloatingDockSiteClass 属性。 |
| GetPalette |
DYNAMIC HPALETTE __fastcall GetPalette(void);
获取调色板句柄。TControl 的这个方法返回 NULL，表示这个控件不使用调色板。
子类如果需要使用调色板，可以重载这个方法。只有在 256 色显示模式才需要使用调色板。 |
| GetPopupMenu |
DYNAMIC Vcl::Menus::TPopupMenu* __fastcall GetPopupMenu(void);
返回关联到这个控件的弹出菜单，请参考 PopupMenu 属性。 |
| GetDragMode |
System::Uitypes::TDragMode __fastcall GetDragMode(void);
返回 DragMode 属性值，请参考 DragMode 属性。 |
| IsTouchPropertyStored |
DYNAMIC bool __fastcall IsTouchPropertyStored(TTouchProperty AProperty);
返回控件是否关联到 touch manager，这是控件内部使用的函数，不要直接调用，请参考 Touch 属性 |
| Loaded |
virtual void __fastcall Loaded(void);
重载 TComponent 的 Loaded 方法。TControl 在这个方法里面初始化关联的 Action。
子类如果需要处理 Action 属性的变化，可以通过重载 ActionChange 方法。
当 Form 读取到内存的时候，调用 Loaded 方法初始化这个组件。
不要直接调用这个方法，当流处理系统从流里面读取这个组件的时候，会自动调用。
Loaded 会清除 ComponentState 属性里面的 csLoading 状态标志。
Loaded 会被调用多次，如果是被继承的 Form，所以不要在这里做分配内存的操作，除非有办法阻止多次被调用的时候多次分配内存。 |
| MouseActivate |
DYNAMIC System::Uitypes::TMouseActivate __fastcall MouseActivate(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y, int HitTest);
鼠标点击激活窗口，这个方法触发 OnMouseActivate 事件。
参数：Button 点击了鼠标的按钮；Shift：当点击鼠标按钮的时候，组合键的状态；X 和 Y：点击鼠标时的鼠标位置；HitTest：鼠标点击的位置，从 WM_NCHITTEST 消息获取的值。
返回值：如何处理鼠标点击 (激活窗口)，请参考 TMouseActivate 类型。 |
| MouseDown |
DYNAMIC void __fastcall MouseDown(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y);
触发并且执行 OnMouseDown 事件。控件使用这个方法响应 Windows 消息：WM_LBUTTONDOWN, WM_MBUTTONDOWN, WM_RBUTTONDOWN。子类可以通过重载这个方法来处理需要在 OnMouseDown 事件里面处理的内容。 |
| MouseMove |
DYNAMIC void __fastcall MouseMove(System::Classes::TShiftState Shift, int X, int Y);
触发并且执行 OnMouseMove 事件。控件使用这个方法来响应 Windows 消息：WM_MOUSEMOVE。
子类可以通过重载这个方法来处理需要在 OnMouseMove 事件里面处理的内容。 |
| MouseUp |
DYNAMIC void __fastcall MouseUp(System::Uitypes::TMouseButton Button, System::Classes::TShiftState Shift, int X, int Y);
触发并且执行 OnMouseUp 事件。控件使用这个方法响应 Windows 消息：WM_LBUTTONUP, WM_MBUTTONUP, WM_RBUTTONUP。子类可以通过重载这个方法来处理需要在 OnMouseUp 事件里面处理的内容。 |
| Notification |
virtual void __fastcall Notification(System::Classes::TComponent* AComponent, System::Classes::TOperation Operation);
重载 TComponent 的 Notification 方法。
AComponent 发过来的创建或移除消息，会自动调用这个方法。
Operation 的值可能为：opInsert: 建立，或者 opRemove: 移除。
Notification 可以让 TControl 更新内部状态，如果关联的组件被移除：
• 关联的弹出菜单被销毁 (请参考 PopupMenu 属性)；
• 控件停靠的控件 (DockSite) 被销毁 (请参考 HostDockSite 属性)；
• 关联到自定义方式显示 Hint 属性的提示框控件被销毁 (请参考 CustomHint 属性)；
• 关联的 GestureManager 被销毁 (请参考 Touch 属性)。 |
| PositionDockRect |
DYNAMIC void __fastcall PositionDockRect(TDragDockObject* DragDockObject);
使用 UndockWidth、UndockHeight、LRDockWidth, 和 TBDockHeight 属性重新调整 TDragDockObject 停靠的位置和大小。 |
| PaletteChanged |
DYNAMIC bool __fastcall PaletteChanged(bool Foreground);
响应系统调色板变化，控件需要调整自身的调色板。只有 256 色显示模式需要处理调色板。
如果 Foreground 为 true: 这个 Form 被激活在最前端，控件使用新调色板；false: 这个 Form 不在最前端，没有被激活，控件需要调整自身的背景调色板以和他们的逻辑调色板搭配 |
| ReadState |
virtual void __fastcall ReadState(System::Classes::TReader* Reader);
重载 TComponent 的 ReadState 方法。
读取组件的状态，是组件内部调用的方法，不需要直接调用。
TControl 的 ReadState 方法，在调用父类 (即 TComponent) 的 ReadState 之前，就读出 Parent 属性，最后，ReadState 方法需要根据 ParentFont, ParentColor 和 ParentShowHint 属性同步 Font、Color 和 ShowHint 属性为 Parent 的相应的属性值 |
| RequestAlign |
virtual void __fastcall RequestAlign(void);
当控件的位置或大小发生变化的时候，调用这个方法请求 Parent 根据 Align 属性重新调整 Parent 里面的控件的大小。这是控件内部调用的方法，不要在应用程序里面直接调用。 |
| Resize |
DYNAMIC void __fastcall Resize(void);
当控件的大小发生变化的时候，会自动调用这个方法，这个方法触发并且执行 OnResize 事件。 |
| ScaleConstraints |
void __fastcall ScaleConstraints(int M, int D);
把 Constraints 属性里面的属性值按照比例缩放，新值 = 旧值 * M / D |
| ScaleMargins |
void __fastcall ScaleMargins(int M, int D);
把 Margins 属性里面的属性值按照比例缩放，新值 = 旧值 * M / D |
| DefaultScalingFlags |
virtual TScalingFlags __fastcall DefaultScalingFlags(void);
获取 ScalingFlags 的默认值，包含 { sfLeft, sfTop, sfWidth, sfHeight, sfFont } 这五个属性 |
| SendCancelMode |
void __fastcall SendCancelMode(TControl* Sender);
控件取消模态 (modal state，当前只有这一个控件响应用户输入的状态)，例如组合框 (ComboBox) 已经拉开下拉表的状态。 |
| SendDockNotification |
void __fastcall SendDockNotification(unsigned Msg, NativeUInt WParam, NativeUInt LParam);
给 HostDockSite 发送消息，请参考 HostDockSite 属性。
当控件的 Text 和 Visible 属性变化时，会自动调用这个方法。 |
| SetAutoSize |
virtual void __fastcall SetAutoSize(bool Value);
修改 AutoSize 属性值为 Value |
| SetDragMode |
virtual void __fastcall SetDragMode(System::Uitypes::TDragMode Value);
修改 DragMode 属性值为 Value |
| SetEnabled |
virtual void __fastcall SetEnabled(bool Value);
修改 Enabled 属性值为 Value |
| SetName |
virtual void __fastcall SetName(const System::Classes::TComponentName Value);
重载 TComponent 的 SetName 方法，在改名的时候修改 Text 或 Caption 属性。
给属性 Name 赋值调用这个方法来修改组件名，SetName 调用 ChangeName 方法来实现改名。
ChangeName 不是 virtual 函数，不要重载 ChangeName，可以用重载 SetName 方法来替代。 |
| SetParent |
virtual void __fastcall SetParent(TWinControl* AParent);
修改 Parent 属性值为 AParent。这个方法会调用原来 Parent 的 RemoveControl 方法和新 Parent 的 InsertControl 方法，在销毁这个控件的时候，会调用 SetParent(NULL);。 |
| SetParentBiDiMode |
virtual void __fastcall SetParentBiDiMode(bool Value);
修改 ParentBiDiMode 属性值为 Value。 |
| SetBiDiMode |
virtual void __fastcall SetBiDiMode(System::Classes::TBiDiMode Value);
修改 BiDiMode 属性值为 Value。 |
| SetZOrder |
DYNAMIC void __fastcall SetZOrder(bool TopMost);
改变这个控件和与这个控件在同一个容器里面的其他控件之间的前后 (遮挡) 关系。
TopMost 参数为 true: 提到最前，可以挡住其他控件，不被其他控件挡住；false: 放在最后，被其他控件挡住，不遮挡其他控件。函数结束时会刷新显示。
遮挡关系请参考 BringToFront 和 SendToBack 方法，刷新显示请参考 Invalidate 方法。 |
| SetCustomHint |
void __fastcall SetCustomHint(TCustomHint* Value);
修改 CustomHint 属性值为 Value。 |
| UpdateExplicitBounds |
void __fastcall UpdateExplicitBounds(void);
把 ExplicitBounds (ExplicitLeft、ExplicitTop、ExplicitWidth、ExplicitHeight 属性) 值设为 Bounds (Left、Top、Width、Height 属性) 值，ControlState 属性包含 csAligning 和 ComponentState 包含 csReading 的时候函数执行也会成功。 |
| UpdateBoundsRect |
void __fastcall UpdateBoundsRect(const System::Types::TRect &R);
控件内部调用的方法，修改 Left、Top、Width 和 Height 属性，不产生任何事件 (例如 OnResize) |
| VisibleChanging |
DYNAMIC void __fastcall VisibleChanging(void);
Visible 属性变化时，在变化之前自动调用这个方法，TControl 的这个方法没有做任何事情，子类可以重载这个方法实现 Visible 变化之前的处理，例如抛出异常可以阻止 Visible 属性的改变 |
| WndProc |
virtual void __fastcall WndProc(Winapi::Messages::TMessage &Message);
处理 Windows 消息。子类可以重载这个方法捕获和处理 Windows 消息，子类的 WndProc 必须调用父类的 WndProc 来处理子类没有处理的消息。WndProc 实现 ControlStyle 和 DragMode 属性的鼠标处理，并且更新 ControlState 属性。WndProc 没有处理的消息会调用 Dispatch 方法处理。 |
| UpdateStyleElements |
virtual void __fastcall UpdateStyleElements(void);
当 StyleElements 属性变化时，自动调用这个方法。 |
| DesignWndProc |
DYNAMIC bool __fastcall DesignWndProc(Winapi::Messages::TMessage &Message);
处理参数 Message 的消息，并且返回这个消息相关的布尔值。ControlStyle 属性包含 csDesignInteractive，并且鼠标右键按下或抬起、鼠标移动或右键双击，会返回 true |
| GetDragImages |
virtual TDragImageList* __fastcall GetDragImages(void);
鼠标拖拽是显示的图像，TControl 的这个方法返回 NULL，子类需要通过重载这个方法提供拖拽图像。
请参考 DefaultDockImage、 DrawDragDockImage 和 EraseDragDockImage 方法。 |
| TComponent:: |
从 TComponent 继承过来的 |
| ChangeName |
void __fastcall ChangeName(const TComponentName NewName);
给组件改名为 NewName。通过给 Name 属性赋值来调用这个方法。
ChangeName 不是 virtual 函数，不要重载这个函数，可以用重载 SetName 方法来替代。 |
| GetChildren |
DYNAMIC void __fastcall GetChildren(TGetChildProc Proc, TComponent* Root);
枚举所有的子组件。这个方法是 TComponent 内部使用的，不要直接调用。
Proc 为回调函数，用来接收枚举出来的组件，Root 为需要枚举子组件的组件。 |
| GetChildOwner |
DYNAMIC TComponent* __fastcall GetChildOwner(void);
当从流里面读取的时候，返回一个子组件的 Owner；如果没有 Owner 返回 NULL。
这是 TComponent 内部调用的方法，不需要直接调用。 |
| GetChildParent |
DYNAMIC TComponent* __fastcall GetChildParent(void);
当从流里面读取的时候，返回一个子组件的 Parent (容器组件)，如果没有 Parent 则返回 Owner。 |
| GetOwner |
DYNAMIC TPersistent* __fastcall GetOwner(void);
重载了 TPersistent 的 GetOwner。
返回对象的拥有者，是 protected: 方法。GetNamePath 方法会调用 GetOwner。
TPersistent 的 GetOwner 只是简单的返回 NULL。
例如，TOwnedCollection 的 GetOwner 返回这个 collection 的 owner；TCollectionItem 的 GetOwner 返回这个项目添加在哪个 collection object 里面了，组件 (TComponent) 的 GetOwner 返回组件的 Owner 属性。 |
| GetDeltaStreams |
DYNAMIC void __fastcall GetDeltaStreams(TGetStreamProc Proc);
TComponent 内部调用的方法，帮助里面没有相关的说明。 |
| PaletteCreated |
DYNAMIC void __fastcall PaletteCreated(void);
组件在组件面板里面创建的时候，会自动调用这个方法。
TComponent 里面，PaletteCreated 并没有实现任何功能，子类可以重载这个方法来实现需要的操作。 |
| CanObserve |
virtual bool __fastcall CanObserve(const int ID);
帮助里面没有相关说明。
和这个组件的 Observers 属性，和 LiveBindings 相关。 |
| ObserverAdded |
virtual void __fastcall ObserverAdded(const int ID, const _di_IObserver Observer);
帮助里面没有相关说明。
和这个组件的 Observers 属性，和 LiveBindings 相关。 |
| GetObservers |
virtual TObservers* __fastcall GetObservers(void);
Observers 属性利用这个方法返回属性值。 |
| SetAncestor |
void __fastcall SetAncestor(bool Value);
清除或设置 ComponentState 属性里面的 csAncestor 状态。
这是 TComponent 内部调用的方法，不需要直接调用。 |
| SetDesigning |
void __fastcall SetDesigning(bool Value, bool SetChildren = true);
清除或设置 ComponentState 属性里面的 csDesigning 状态。
这是 TComponent 内部调用的方法，不需要直接调用。 |
| SetInline |
void __fastcall SetInline(bool Value);
清除或设置 ComponentState 属性里面的 csInline 状态。
这是 TComponent 内部调用的方法，不需要直接调用。 |
| SetDesignInstance |
void __fastcall SetDesignInstance(bool Value);
清除或设置 ComponentState 属性里面的 csDesignInstance 状态。
这是 TComponent 内部调用的方法，不需要直接调用。 |
| SetChildOrder |
DYNAMIC void __fastcall SetChildOrder(TComponent* Child, int Order);
调整子组件的顺序，这是内部调用的方法，不要直接调用。 |
| SetParentComponent |
DYNAMIC void __fastcall SetParentComponent(TComponent* Value);
设置组件的 Parent (容器组件)，这是组件内部使用的方法，不要直接调用。
可以重载这个方法来实现在设置 Parent 的时候执行一段代码。 |
| Updating |
DYNAMIC void __fastcall Updating(void);
设置 ComponentState 属性里面的 csUpdating 状态。
这是 TComponent 内部调用的方法，不需要直接调用。 |
| Updated |
DYNAMIC void __fastcall Updated(void);
清除 ComponentState 属性里面的 csUpdating 状态。
这是 TComponent 内部调用的方法，不需要直接调用。 |
| UpdateRegistry |
__classmethod virtual void __fastcall UpdateRegistry(bool Register, const System::UnicodeString ClassID, const System::UnicodeString ProgID);
如果组件实现了 COM 接口，UpdateRegistry 会在注册表里面添加类型库信息。
这是组件内部调用的方法，不要直接调用。 |
| ValidateRename |
virtual void __fastcall ValidateRename(TComponent* AComponent, const System::UnicodeString CurName, const System::UnicodeString NewName);
在给组件改名的时候会调用这个函数，检查名称是否有效。 |
| ValidateContainer |
DYNAMIC void __fastcall ValidateContainer(TComponent* AComponent);
检查组件是否可以放入容器。
当把组件放入容器的时候，会调用这个方法，这个方法会调用 ValidateInsert 方法来检查，如果不可以放入容器，会抛出异常。 |
| ValidateInsert |
DYNAMIC void __fastcall ValidateInsert(TComponent* AComponent);
把组件放入容器的时候，会调用这个方法来检查是否可以放入容器，如果不可以，会抛出异常。 |
| WriteState |
virtual void __fastcall WriteState(TWriter* Writer);
写入组件的状态，由流处理系统自动调用，不需要直接调用。 |
| RemoveFreeNotifications |
void __fastcall RemoveFreeNotifications(void);
通知所有的 Owner 这个组件要被销毁了。当组件被销毁的时候，会自动调用这个方法。 |
| QueryInterface |
virtual HRESULT __stdcall QueryInterface(const GUID &IID, /* out */ void *Obj);
返回当前组件所支持的 COM 接口的引用到 Obj，函数返回值为 S_OK；
如果不支持，Obj 返回 NULL，函数返回值为 S_FALSE, E_NOINTERFACE, E_UNEXPECTED, 或 E_NOTIMPL 等。 |
| _AddRef |
int __stdcall _AddRef(void);
如果组件封装的是 COM 接口，会调用 COM 接口的 _AddRef 增加引用计数，返回值为当前的引用计数值；如果封装的不是 COM 接口，直接返回 -1。 |
| _Release |
int __stdcall _Release(void);
如果组件封装的是 COM 接口，会调用 COM 接口的 _Release 减少引用计数，返回值为当前的引用计数值，如果计数值等于 0，会销毁对象，释放占用的资源。如果封装的不是 COM 接口，直接返回 -1。 |
| GetTypeInfoCount |
HRESULT __stdcall GetTypeInfoCount(/* out */ int &Count);
如果封装的是 IDispatch 会实现 IDispatch 的 GetTypeInfoCount 返回类型信息的个数，如果支持类型信息，返回 1，否则返回 0。 |
| GetTypeInfo |
HRESULT __stdcall GetTypeInfo(int Index, int LocaleID, /* out */ void *TypeInfo);
如果封装的是 IDispatch 会实现 IDispatch 的 GetTypeInfo 返回类型信息。 |
| GetIDsOfNames |
HRESULT __stdcall GetIDsOfNames(const GUID &IID, void * Names, int NameCount, int LocaleID, void * DispIDs);
把 COM 接口的方法的名字和参数映射成一组 DISPID
如果封装的是 IDispatch 会实现 IDispatch 的 GetIDsOfNames |
| Invoke |
HRESULT __stdcall Invoke(int DispID, const GUID &IID, int LocaleID, System::Word Flags, void *Params, void * VarResult, void * ExcepInfo, void * ArgErr);
如果这个组件封装了 COM 对象，Invoke 提供访问 COM 对象的属性和调用 COM 对象的方法。
如果组件封装的是 IDispatch 接口，Invoke 会调用 IDispatch 的 Invoke 方法，并且把参数传递给 IDispatch 的 Invoke 方法。 |
