home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Internet 2000 May / MICD_2000_05.iso / CBuilder5 / INSTALL / DATA1.CAB / Program_Built_Files / Include / Vcl / controls.hpp < prev    next >
C/C++ Source or Header  |  2000-02-01  |  75KB  |  1,823 lines
  1. // Borland C++ Builder
  2. // Copyright (c) 1995, 1999 by Borland International
  3. // All rights reserved
  4.  
  5. // (DO NOT EDIT: machine generated header) 'Controls.pas' rev: 5.00
  6.  
  7. #ifndef ControlsHPP
  8. #define ControlsHPP
  9.  
  10. #pragma delphiheader begin
  11. #pragma option push -w-
  12. #pragma option push -Vx
  13. #include <ActnList.hpp>    // Pascal unit
  14. #include <ImgList.hpp>    // Pascal unit
  15. #include <Imm.hpp>    // Pascal unit
  16. #include <Menus.hpp>    // Pascal unit
  17. #include <Graphics.hpp>    // Pascal unit
  18. #include <SysUtils.hpp>    // Pascal unit
  19. #include <Classes.hpp>    // Pascal unit
  20. #include <MultiMon.hpp>    // Pascal unit
  21. #include <Windows.hpp>    // Pascal unit
  22. #include <Messages.hpp>    // Pascal unit
  23. #include <SysInit.hpp>    // Pascal unit
  24. #include <System.hpp>    // Pascal unit
  25.  
  26. //-- user supplied -----------------------------------------------------------
  27. namespace Controls
  28. {
  29. #pragma option -b-
  30.   enum TCursor {crMin=-32768, crMax=32767};
  31. #pragma option -b.
  32. }
  33. namespace Controls
  34. {
  35.     typedef System::TDateTime TDate;
  36.     typedef System::TDateTime TTime;
  37. }
  38.  
  39. namespace Controls
  40. {
  41. //-- type declarations -------------------------------------------------------
  42. typedef TMetaClass*TWinControlClass;
  43.  
  44. typedef Messages::TWMNoParams  TCMActivate;
  45.  
  46. typedef Messages::TWMNoParams  TCMDeactivate;
  47.  
  48. typedef Messages::TWMNoParams  TCMGotFocus;
  49.  
  50. typedef Messages::TWMNoParams  TCMLostFocus;
  51.  
  52. typedef Messages::TWMKey  TCMDialogKey;
  53.  
  54. typedef Messages::TWMKey  TCMDialogChar;
  55.  
  56. typedef Messages::TWMNCHitTest  TCMHitTest;
  57.  
  58. typedef Messages::TWMNoParams  TCMEnter;
  59.  
  60. typedef Messages::TWMNoParams  TCMExit;
  61.  
  62. typedef Messages::TWMMouse  TCMDesignHitTest;
  63.  
  64. typedef Messages::TWMKey  TCMWantSpecialKey;
  65.  
  66. struct TCMMouseWheel
  67. {
  68.     unsigned Msg;
  69.     Classes::TShiftState ShiftState;
  70.     Byte Unused;
  71.     short WheelDelta;
  72.     union
  73.     {
  74.         struct 
  75.         {
  76.             Windows::TSmallPoint Pos;
  77.             int Result;
  78.             
  79.         };
  80.         struct 
  81.         {
  82.             short XPos;
  83.             short YPos;
  84.             
  85.         };
  86.         
  87.     };
  88. } ;
  89.  
  90. class DELPHICLASS TControl;
  91. class DELPHICLASS TWinControl;
  92. typedef void __fastcall (__closure *TWndMethod)(Messages::TMessage &Message);
  93.  
  94. #pragma option push -b-
  95. enum Controls__8 { csAcceptsControls, csCaptureMouse, csDesignInteractive, csClickEvents, csFramed, 
  96.     csSetCaption, csOpaque, csDoubleClicks, csFixedWidth, csFixedHeight, csNoDesignVisible, csReplicatable, 
  97.     csNoStdEvents, csDisplayDragImage, csReflector, csActionClient, csMenuEvents };
  98. #pragma option pop
  99.  
  100. typedef Set<Controls__8, csAcceptsControls, csMenuEvents>  TControlStyle;
  101.  
  102. #pragma option push -b-
  103. enum Controls__7 { csLButtonDown, csClicked, csPalette, csReadingState, csAlignmentNeeded, csFocusing, 
  104.     csCreating, csPaintCopy, csCustomPaint, csDestroyingHandle, csDocking };
  105. #pragma option pop
  106.  
  107. typedef Set<Controls__7, csLButtonDown, csDocking>  TControlState;
  108.  
  109. #pragma option push -b-
  110. enum TAlign { alNone, alTop, alBottom, alLeft, alRight, alClient };
  111. #pragma option pop
  112.  
  113. #pragma option push -b-
  114. enum TDragMode { dmManual, dmAutomatic };
  115. #pragma option pop
  116.  
  117. #pragma option push -b-
  118. enum TAnchorKind { akLeft, akTop, akRight, akBottom };
  119. #pragma option pop
  120.  
  121. typedef Set<TAnchorKind, akLeft, akBottom>  TAnchors;
  122.  
  123. class DELPHICLASS TControlActionLink;
  124. class PASCALIMPLEMENTATION TControlActionLink : public Actnlist::TActionLink 
  125. {
  126.     typedef Actnlist::TActionLink inherited;
  127.     
  128. protected:
  129.     TControl* FClient;
  130.     virtual void __fastcall AssignClient(System::TObject* AClient);
  131.     virtual bool __fastcall IsCaptionLinked(void);
  132.     virtual bool __fastcall IsEnabledLinked(void);
  133.     virtual bool __fastcall IsHintLinked(void);
  134.     virtual bool __fastcall IsVisibleLinked(void);
  135.     virtual bool __fastcall IsOnExecuteLinked(void);
  136.     virtual bool __fastcall DoShowHint(AnsiString &HintStr);
  137.     virtual void __fastcall SetCaption(const AnsiString Value);
  138.     virtual void __fastcall SetEnabled(bool Value);
  139.     virtual void __fastcall SetHint(const AnsiString Value);
  140.     virtual void __fastcall SetVisible(bool Value);
  141.     virtual void __fastcall SetOnExecute(Classes::TNotifyEvent Value);
  142. public:
  143.     #pragma option push -w-inl
  144.     /* TBasicActionLink.Create */ inline __fastcall virtual TControlActionLink(System::TObject* AClient
  145.         ) : Actnlist::TActionLink(AClient) { }
  146.     #pragma option pop
  147.     #pragma option push -w-inl
  148.     /* TBasicActionLink.Destroy */ inline __fastcall virtual ~TControlActionLink(void) { }
  149.     #pragma option pop
  150.     
  151. };
  152.  
  153.  
  154. class DELPHICLASS TSizeConstraints;
  155. typedef int TConstraintSize;
  156.  
  157. class PASCALIMPLEMENTATION TSizeConstraints : public Classes::TPersistent 
  158. {
  159.     typedef Classes::TPersistent inherited;
  160.     
  161. private:
  162.     TControl* FControl;
  163.     TConstraintSize FMaxHeight;
  164.     TConstraintSize FMaxWidth;
  165.     TConstraintSize FMinHeight;
  166.     TConstraintSize FMinWidth;
  167.     Classes::TNotifyEvent FOnChange;
  168.     void __fastcall SetConstraints(int Index, TConstraintSize Value);
  169.     
  170. protected:
  171.     DYNAMIC void __fastcall Change(void);
  172.     virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
  173.     __property TControl* Control = {read=FControl};
  174.     
  175. public:
  176.     __fastcall virtual TSizeConstraints(TControl* Control);
  177.     __property Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
  178.     
  179. __published:
  180.     __property TConstraintSize MaxHeight = {read=FMaxHeight, write=SetConstraints, index=0, default=0};
  181.         
  182.     __property TConstraintSize MaxWidth = {read=FMaxWidth, write=SetConstraints, index=1, default=0};
  183.     __property TConstraintSize MinHeight = {read=FMinHeight, write=SetConstraints, index=2, default=0};
  184.         
  185.     __property TConstraintSize MinWidth = {read=FMinWidth, write=SetConstraints, index=3, default=0};
  186. public:
  187.         
  188.     #pragma option push -w-inl
  189.     /* TPersistent.Destroy */ inline __fastcall virtual ~TSizeConstraints(void) { }
  190.     #pragma option pop
  191.     
  192. };
  193.  
  194.  
  195. #pragma option push -b-
  196. enum Controls__9 { sfLeft, sfTop, sfWidth, sfHeight, sfFont };
  197. #pragma option pop
  198.  
  199. typedef Set<Controls__9, sfLeft, sfFont>  TScalingFlags;
  200.  
  201. #pragma option push -b-
  202. enum TDragKind { dkDrag, dkDock };
  203. #pragma option pop
  204.  
  205. #pragma option push -b-
  206. enum TDockOrientation { doNoOrient, doHorizontal, doVertical };
  207. #pragma option pop
  208.  
  209. typedef void __fastcall (__closure *TCanResizeEvent)(System::TObject* Sender, int &NewWidth, int &NewHeight
  210.     , bool &Resize);
  211.  
  212. typedef void __fastcall (__closure *TConstrainedResizeEvent)(System::TObject* Sender, int &MinWidth, 
  213.     int &MinHeight, int &MaxWidth, int &MaxHeight);
  214.  
  215. #pragma option push -b-
  216. enum TMouseButton { mbLeft, mbRight, mbMiddle };
  217. #pragma option pop
  218.  
  219. typedef void __fastcall (__closure *TMouseEvent)(System::TObject* Sender, TMouseButton Button, Classes::TShiftState 
  220.     Shift, int X, int Y);
  221.  
  222. typedef void __fastcall (__closure *TMouseMoveEvent)(System::TObject* Sender, Classes::TShiftState Shift
  223.     , int X, int Y);
  224.  
  225. typedef void __fastcall (__closure *TDragDropEvent)(System::TObject* Sender, System::TObject* Source
  226.     , int X, int Y);
  227.  
  228. #pragma option push -b-
  229. enum TDragState { dsDragEnter, dsDragLeave, dsDragMove };
  230. #pragma option pop
  231.  
  232. typedef void __fastcall (__closure *TDragOverEvent)(System::TObject* Sender, System::TObject* Source
  233.     , int X, int Y, TDragState State, bool &Accept);
  234.  
  235. class DELPHICLASS TDragDockObject;
  236. typedef void __fastcall (__closure *TStartDockEvent)(System::TObject* Sender, TDragDockObject* &DragObject
  237.     );
  238.  
  239. typedef void __fastcall (__closure *TEndDragEvent)(System::TObject* Sender, System::TObject* Target, 
  240.     int X, int Y);
  241.  
  242. class DELPHICLASS TDragObject;
  243. typedef void __fastcall (__closure *TStartDragEvent)(System::TObject* Sender, TDragObject* &DragObject
  244.     );
  245.  
  246. typedef void __fastcall (__closure *TContextPopupEvent)(System::TObject* Sender, const Windows::TPoint 
  247.     &MousePos, bool &Handled);
  248.  
  249. struct TCMDrag;
  250. typedef AnsiString TCaption;
  251.  
  252. struct TCMFloat;
  253. typedef TMetaClass*TControlActionLinkClass;
  254.  
  255. class DELPHICLASS TDragImageList;
  256. class PASCALIMPLEMENTATION TControl : public Classes::TComponent 
  257. {
  258.     typedef Classes::TComponent inherited;
  259.     
  260. private:
  261.     TWinControl* FParent;
  262.     TWndMethod FWindowProc;
  263.     int FLeft;
  264.     int FTop;
  265.     int FWidth;
  266.     int FHeight;
  267.     TControlStyle FControlStyle;
  268.     TControlState FControlState;
  269.     bool FDesktopFont;
  270.     bool FVisible;
  271.     bool FEnabled;
  272.     bool FParentFont;
  273.     bool FParentColor;
  274.     TAlign FAlign;
  275.     bool FAutoSize;
  276.     TDragMode FDragMode;
  277.     bool FIsControl;
  278.     Classes::TBiDiMode FBiDiMode;
  279.     bool FParentBiDiMode;
  280.     TAnchors FAnchors;
  281.     bool FAnchorMove;
  282.     char *FText;
  283.     Graphics::TFont* FFont;
  284.     TControlActionLink* FActionLink;
  285.     Graphics::TColor FColor;
  286.     TSizeConstraints* FConstraints;
  287.     TCursor FCursor;
  288.     TCursor FDragCursor;
  289.     Menus::TPopupMenu* FPopupMenu;
  290.     AnsiString FHint;
  291.     int FFontHeight;
  292.     Windows::TPoint FAnchorRules;
  293.     Windows::TPoint FOriginalParentSize;
  294.     TScalingFlags FScalingFlags;
  295.     bool FShowHint;
  296.     bool FParentShowHint;
  297.     TDragKind FDragKind;
  298.     TDockOrientation FDockOrientation;
  299.     TWinControl* FHostDockSite;
  300.     int FUndockWidth;
  301.     int FUndockHeight;
  302.     int FLRDockWidth;
  303.     int FTBDockHeight;
  304.     TMetaClass*FFloatingDockSiteClass;
  305.     TCanResizeEvent FOnCanResize;
  306.     TConstrainedResizeEvent FOnConstrainedResize;
  307.     TMouseEvent FOnMouseDown;
  308.     TMouseMoveEvent FOnMouseMove;
  309.     TMouseEvent FOnMouseUp;
  310.     TDragDropEvent FOnDragDrop;
  311.     TDragOverEvent FOnDragOver;
  312.     Classes::TNotifyEvent FOnResize;
  313.     TStartDockEvent FOnStartDock;
  314.     TEndDragEvent FOnEndDock;
  315.     TStartDragEvent FOnStartDrag;
  316.     TEndDragEvent FOnEndDrag;
  317.     Classes::TNotifyEvent FOnClick;
  318.     Classes::TNotifyEvent FOnDblClick;
  319.     TContextPopupEvent FOnContextPopup;
  320.     void __fastcall CalcDockSizes(void);
  321.     bool __fastcall CheckNewSize(int &NewWidth, int &NewHeight);
  322.     TWinControl* __fastcall CreateFloatingDockSite(const Windows::TRect &Bounds);
  323.     void __fastcall DoActionChange(System::TObject* Sender);
  324.     bool __fastcall DoCanAutoSize(int &NewWidth, int &NewHeight);
  325.     bool __fastcall DoCanResize(int &NewWidth, int &NewHeight);
  326.     void __fastcall DoConstraintsChange(System::TObject* Sender);
  327.     void __fastcall DoConstrainedResize(int &NewWidth, int &NewHeight);
  328.     void __fastcall DoDragMsg(TCMDrag &DragMsg);
  329.     void __fastcall DoMouseDown(Messages::TWMMouse &Message, TMouseButton Button, Classes::TShiftState 
  330.         Shift);
  331.     void __fastcall DoMouseUp(Messages::TWMMouse &Message, TMouseButton Button);
  332.     void __fastcall FontChanged(System::TObject* Sender);
  333.     Classes::TBasicAction* __fastcall GetAction(void);
  334.     Windows::TRect __fastcall GetBoundsRect();
  335.     int __fastcall GetClientHeight(void);
  336.     int __fastcall GetClientWidth(void);
  337.     int __fastcall GetLRDockWidth(void);
  338.     bool __fastcall GetMouseCapture(void);
  339.     AnsiString __fastcall GetText();
  340.     int __fastcall GetTBDockHeight(void);
  341.     int __fastcall GetUndockWidth(void);
  342.     int __fastcall GetUndockHeight(void);
  343.     void __fastcall InvalidateControl(bool IsVisible, bool IsOpaque);
  344.     bool __fastcall IsAnchorsStored(void);
  345.     bool __fastcall IsBiDiModeStored(void);
  346.     bool __fastcall IsCaptionStored(void);
  347.     bool __fastcall IsColorStored(void);
  348.     bool __fastcall IsEnabledStored(void);
  349.     bool __fastcall IsFontStored(void);
  350.     bool __fastcall IsHintStored(void);
  351.     bool __fastcall IsOnClickStored(void);
  352.     bool __fastcall IsShowHintStored(void);
  353.     bool __fastcall IsVisibleStored(void);
  354.     void __fastcall ReadIsControl(Classes::TReader* Reader);
  355.     void __fastcall SetAnchors(TAnchors Value);
  356.     void __fastcall SetAction(Classes::TBasicAction* Value);
  357.     void __fastcall SetAlign(TAlign Value);
  358.     void __fastcall SetAutoSize(bool Value);
  359.     void __fastcall SetBoundsRect(const Windows::TRect &Rect);
  360.     void __fastcall SetClientHeight(int Value);
  361.     void __fastcall SetClientSize(const Windows::TPoint &Value);
  362.     void __fastcall SetClientWidth(int Value);
  363.     void __fastcall SetColor(Graphics::TColor Value);
  364.     void __fastcall SetCursor(TCursor Value);
  365.     void __fastcall SetDesktopFont(bool Value);
  366.     void __fastcall SetFont(Graphics::TFont* Value);
  367.     void __fastcall SetHeight(int Value);
  368.     void __fastcall SetHostDockSite(TWinControl* Value);
  369.     void __fastcall SetLeft(int Value);
  370.     void __fastcall SetMouseCapture(bool Value);
  371.     void __fastcall SetParentColor(bool Value);
  372.     void __fastcall SetParentFont(bool Value);
  373.     void __fastcall SetShowHint(bool Value);
  374.     void __fastcall SetParentShowHint(bool Value);
  375.     void __fastcall SetPopupMenu(Menus::TPopupMenu* Value);
  376.     void __fastcall SetText(const AnsiString Value);
  377.     void __fastcall SetTop(int Value);
  378.     void __fastcall SetVisible(bool Value);
  379.     void __fastcall SetWidth(int Value);
  380.     void __fastcall SetZOrderPosition(int Position);
  381.     void __fastcall UpdateAnchorRules(void);
  382.     void __fastcall WriteIsControl(Classes::TWriter* Writer);
  383.     MESSAGE void __fastcall WMLButtonDown(Messages::TWMMouse &Message);
  384.     MESSAGE void __fastcall WMNCLButtonDown(Messages::TWMNCHitMessage &Message);
  385.     MESSAGE void __fastcall WMRButtonDown(Messages::TWMMouse &Message);
  386.     MESSAGE void __fastcall WMMButtonDown(Messages::TWMMouse &Message);
  387.     MESSAGE void __fastcall WMLButtonDblClk(Messages::TWMMouse &Message);
  388.     MESSAGE void __fastcall WMRButtonDblClk(Messages::TWMMouse &Message);
  389.     MESSAGE void __fastcall WMMButtonDblClk(Messages::TWMMouse &Message);
  390.     MESSAGE void __fastcall WMMouseMove(Messages::TWMMouse &Message);
  391.     MESSAGE void __fastcall WMLButtonUp(Messages::TWMMouse &Message);
  392.     MESSAGE void __fastcall WMRButtonUp(Messages::TWMMouse &Message);
  393.     MESSAGE void __fastcall WMMButtonUp(Messages::TWMMouse &Message);
  394.     MESSAGE void __fastcall WMCancelMode(Messages::TWMNoParams &Message);
  395.     MESSAGE void __fastcall WMWindowPosChanged(Messages::TWMWindowPosMsg &Message);
  396.     MESSAGE void __fastcall CMVisibleChanged(Messages::TMessage &Message);
  397.     MESSAGE void __fastcall CMEnabledChanged(Messages::TMessage &Message);
  398.     MESSAGE void __fastcall CMFontChanged(Messages::TMessage &Message);
  399.     MESSAGE void __fastcall CMColorChanged(Messages::TMessage &Message);
  400.     MESSAGE void __fastcall CMParentFontChanged(Messages::TMessage &Message);
  401.     MESSAGE void __fastcall CMSysFontChanged(Messages::TMessage &Message);
  402.     MESSAGE void __fastcall CMParentColorChanged(Messages::TMessage &Message);
  403.     MESSAGE void __fastcall CMParentShowHintChanged(Messages::TMessage &Message);
  404.     MESSAGE void __fastcall CMHintShow(Messages::TMessage &Message);
  405.     MESSAGE void __fastcall CMHitTest(Messages::TWMNCHitTest &Message);
  406.     MESSAGE void __fastcall CMMouseEnter(Messages::TMessage &Message);
  407.     MESSAGE void __fastcall CMMouseLeave(Messages::TMessage &Message);
  408.     MESSAGE void __fastcall CMDesignHitTest(Messages::TWMMouse &Message);
  409.     MESSAGE void __fastcall CMFloat(TCMFloat &Message);
  410.     MESSAGE void __fastcall CMBiDiModeChanged(Messages::TMessage &Message);
  411.     MESSAGE void __fastcall CMParentBiDiModeChanged(Messages::TMessage &Message);
  412.     MESSAGE void __fastcall WMContextMenu(Messages::TWMContextMenu &Message);
  413.     
  414. protected:
  415.     DYNAMIC void __fastcall ActionChange(System::TObject* Sender, bool CheckDefaults);
  416.     DYNAMIC void __fastcall AdjustSize(void);
  417.     virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
  418.     DYNAMIC void __fastcall BeginAutoDrag(void);
  419.     virtual bool __fastcall CanResize(int &NewWidth, int &NewHeight);
  420.     virtual bool __fastcall CanAutoSize(int &NewWidth, int &NewHeight);
  421.     void __fastcall Changed(void);
  422.     DYNAMIC void __fastcall ChangeScale(int M, int D);
  423.     DYNAMIC void __fastcall Click(void);
  424.     virtual void __fastcall ConstrainedResize(int &MinWidth, int &MinHeight, int &MaxWidth, int &MaxHeight
  425.         );
  426.     DYNAMIC void __fastcall DblClick(void);
  427.     DYNAMIC void __fastcall DefaultDockImage(TDragDockObject* DragDockObject, bool Erase);
  428.     virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
  429.     DYNAMIC void __fastcall DockTrackNoTarget(TDragDockObject* Source, int X, int Y);
  430.     DYNAMIC void __fastcall DoContextPopup(const Windows::TPoint &MousePos, bool &Handled);
  431.     DYNAMIC void __fastcall DoEndDock(System::TObject* Target, int X, int Y);
  432.     DYNAMIC void __fastcall DoDock(TWinControl* NewDockSite, Windows::TRect &ARect);
  433.     DYNAMIC void __fastcall DoStartDock(TDragObject* &DragObject);
  434.     DYNAMIC void __fastcall DragCanceled(void);
  435.     DYNAMIC void __fastcall DragOver(System::TObject* Source, int X, int Y, TDragState State, bool &Accept
  436.         );
  437.     DYNAMIC void __fastcall DoEndDrag(System::TObject* Target, int X, int Y);
  438.     DYNAMIC void __fastcall DoStartDrag(TDragObject* &DragObject);
  439.     DYNAMIC void __fastcall DrawDragDockImage(TDragDockObject* DragDockObject);
  440.     DYNAMIC void __fastcall EraseDragDockImage(TDragDockObject* DragDockObject);
  441.     DYNAMIC TMetaClass* __fastcall GetActionLinkClass(void);
  442.     virtual Windows::TPoint __fastcall GetClientOrigin();
  443.     virtual Windows::TRect __fastcall GetClientRect();
  444.     virtual HDC __fastcall GetDeviceContext(HWND &WindowHandle);
  445.     DYNAMIC TAlign __fastcall GetDockEdge(const Windows::TPoint &MousePos);
  446.     virtual TDragImageList* __fastcall GetDragImages(void);
  447.     virtual bool __fastcall GetEnabled(void);
  448.     virtual bool __fastcall GetFloating(void);
  449.     virtual TMetaClass* __fastcall GetFloatingDockSiteClass(void);
  450.     DYNAMIC HPALETTE __fastcall GetPalette(void);
  451.     DYNAMIC Menus::TPopupMenu* __fastcall GetPopupMenu(void);
  452.     virtual void __fastcall Loaded(void);
  453.     DYNAMIC void __fastcall MouseDown(TMouseButton Button, Classes::TShiftState Shift, int X, int Y);
  454.     DYNAMIC void __fastcall MouseMove(Classes::TShiftState Shift, int X, int Y);
  455.     DYNAMIC void __fastcall MouseUp(TMouseButton Button, Classes::TShiftState Shift, int X, int Y);
  456.     virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation
  457.         );
  458.     DYNAMIC void __fastcall PositionDockRect(TDragDockObject* DragDockObject);
  459.     DYNAMIC bool __fastcall PaletteChanged(bool Foreground);
  460.     virtual void __fastcall ReadState(Classes::TReader* Reader);
  461.     DYNAMIC void __fastcall RequestAlign(void);
  462.     DYNAMIC void __fastcall Resize(void);
  463.     void __fastcall SendCancelMode(TControl* Sender);
  464.     void __fastcall SendDockNotification(unsigned Msg, int WParam, int LParam);
  465.     virtual void __fastcall SetDragMode(TDragMode Value);
  466.     virtual void __fastcall SetEnabled(bool Value);
  467.     virtual void __fastcall SetName(const AnsiString Value);
  468.     virtual void __fastcall SetParent(TWinControl* AParent);
  469.     DYNAMIC void __fastcall SetParentComponent(Classes::TComponent* Value);
  470.     virtual void __fastcall SetParentBiDiMode(bool Value);
  471.     virtual void __fastcall SetBiDiMode(Classes::TBiDiMode Value);
  472.     DYNAMIC void __fastcall SetZOrder(bool TopMost);
  473.     void __fastcall UpdateBoundsRect(const Windows::TRect &R);
  474.     DYNAMIC void __fastcall VisibleChanging(void);
  475.     virtual void __fastcall WndProc(Messages::TMessage &Message);
  476.     __property TControlActionLink* ActionLink = {read=FActionLink, write=FActionLink};
  477.     __property bool AutoSize = {read=FAutoSize, write=SetAutoSize, default=0};
  478.     __property AnsiString Caption = {read=GetText, write=SetText, stored=IsCaptionStored};
  479.     __property Graphics::TColor Color = {read=FColor, write=SetColor, stored=IsColorStored, default=-2147483643
  480.         };
  481.     __property bool DesktopFont = {read=FDesktopFont, write=SetDesktopFont, default=0};
  482.     __property TDragKind DragKind = {read=FDragKind, write=FDragKind, default=0};
  483.     __property TCursor DragCursor = {read=FDragCursor, write=FDragCursor, default=-12};
  484.     __property TDragMode DragMode = {read=FDragMode, write=SetDragMode, default=0};
  485.     __property Graphics::TFont* Font = {read=FFont, write=SetFont, stored=IsFontStored};
  486.     __property bool IsControl = {read=FIsControl, write=FIsControl, nodefault};
  487.     __property bool MouseCapture = {read=GetMouseCapture, write=SetMouseCapture, nodefault};
  488.     __property bool ParentBiDiMode = {read=FParentBiDiMode, write=SetParentBiDiMode, default=1};
  489.     __property bool ParentColor = {read=FParentColor, write=SetParentColor, default=1};
  490.     __property bool ParentFont = {read=FParentFont, write=SetParentFont, default=1};
  491.     __property bool ParentShowHint = {read=FParentShowHint, write=SetParentShowHint, default=1};
  492.     __property Menus::TPopupMenu* PopupMenu = {read=FPopupMenu, write=SetPopupMenu};
  493.     __property TScalingFlags ScalingFlags = {read=FScalingFlags, write=FScalingFlags, nodefault};
  494.     __property AnsiString Text = {read=GetText, write=SetText};
  495.     __property char * WindowText = {read=FText, write=FText};
  496.     __property TCanResizeEvent OnCanResize = {read=FOnCanResize, write=FOnCanResize};
  497.     __property Classes::TNotifyEvent OnClick = {read=FOnClick, write=FOnClick, stored=IsOnClickStored};
  498.         
  499.     __property TConstrainedResizeEvent OnConstrainedResize = {read=FOnConstrainedResize, write=FOnConstrainedResize
  500.         };
  501.     __property TContextPopupEvent OnContextPopup = {read=FOnContextPopup, write=FOnContextPopup};
  502.     __property Classes::TNotifyEvent OnDblClick = {read=FOnDblClick, write=FOnDblClick};
  503.     __property TDragDropEvent OnDragDrop = {read=FOnDragDrop, write=FOnDragDrop};
  504.     __property TDragOverEvent OnDragOver = {read=FOnDragOver, write=FOnDragOver};
  505.     __property TEndDragEvent OnEndDock = {read=FOnEndDock, write=FOnEndDock};
  506.     __property TEndDragEvent OnEndDrag = {read=FOnEndDrag, write=FOnEndDrag};
  507.     __property TMouseEvent OnMouseDown = {read=FOnMouseDown, write=FOnMouseDown};
  508.     __property TMouseMoveEvent OnMouseMove = {read=FOnMouseMove, write=FOnMouseMove};
  509.     __property TMouseEvent OnMouseUp = {read=FOnMouseUp, write=FOnMouseUp};
  510.     __property Classes::TNotifyEvent OnResize = {read=FOnResize, write=FOnResize};
  511.     __property TStartDockEvent OnStartDock = {read=FOnStartDock, write=FOnStartDock};
  512.     __property TStartDragEvent OnStartDrag = {read=FOnStartDrag, write=FOnStartDrag};
  513.     
  514. public:
  515.     __fastcall virtual TControl(Classes::TComponent* AOwner);
  516.     __fastcall virtual ~TControl(void);
  517.     void __fastcall BeginDrag(bool Immediate, int Threshold);
  518.     void __fastcall BringToFront(void);
  519.     Windows::TPoint __fastcall ClientToScreen(const Windows::TPoint &Point);
  520.     DYNAMIC void __fastcall Dock(TWinControl* NewDockSite, const Windows::TRect &ARect);
  521.     virtual void __fastcall DefaultHandler(void *Message);
  522.     bool __fastcall Dragging(void);
  523.     DYNAMIC void __fastcall DragDrop(System::TObject* Source, int X, int Y);
  524.     int __fastcall DrawTextBiDiModeFlags(int Flags);
  525.     int __fastcall DrawTextBiDiModeFlagsReadingOnly(void);
  526.     __property bool Enabled = {read=GetEnabled, write=SetEnabled, stored=IsEnabledStored, default=1};
  527.     void __fastcall EndDrag(bool Drop);
  528.     DYNAMIC Classes::TAlignment __fastcall GetControlsAlignment(void);
  529.     DYNAMIC Classes::TComponent* __fastcall GetParentComponent(void);
  530.     int __fastcall GetTextBuf(char * Buffer, int BufSize);
  531.     int __fastcall GetTextLen(void);
  532.     DYNAMIC bool __fastcall HasParent(void);
  533.     void __fastcall Hide(void);
  534.     virtual void __fastcall InitiateAction(void);
  535.     virtual void __fastcall Invalidate(void);
  536.     bool __fastcall IsRightToLeft(void);
  537.     bool __fastcall ManualDock(TWinControl* NewDockSite, TControl* DropControl, TAlign ControlSide);
  538.     bool __fastcall ManualFloat(const Windows::TRect &ScreenPos);
  539.     int __fastcall Perform(unsigned Msg, int WParam, int LParam);
  540.     void __fastcall Refresh(void);
  541.     virtual void __fastcall Repaint(void);
  542.     bool __fastcall ReplaceDockedControl(TControl* Control, TWinControl* NewDockSite, TControl* DropControl
  543.         , TAlign ControlSide);
  544.     Windows::TPoint __fastcall ScreenToClient(const Windows::TPoint &Point);
  545.     void __fastcall SendToBack(void);
  546.     virtual void __fastcall SetBounds(int ALeft, int ATop, int AWidth, int AHeight);
  547.     void __fastcall SetTextBuf(char * Buffer);
  548.     void __fastcall Show(void);
  549.     virtual void __fastcall Update(void);
  550.     DYNAMIC bool __fastcall UseRightToLeftAlignment(void);
  551.     bool __fastcall UseRightToLeftReading(void);
  552.     bool __fastcall UseRightToLeftScrollBar(void);
  553.     __property Classes::TBasicAction* Action = {read=GetAction, write=SetAction};
  554.     __property TAlign Align = {read=FAlign, write=SetAlign, default=0};
  555.     __property TAnchors Anchors = {read=FAnchors, write=SetAnchors, stored=IsAnchorsStored, default=3};
  556.         
  557.     __property Classes::TBiDiMode BiDiMode = {read=FBiDiMode, write=SetBiDiMode, stored=IsBiDiModeStored
  558.         , nodefault};
  559.     __property Windows::TRect BoundsRect = {read=GetBoundsRect, write=SetBoundsRect};
  560.     __property int ClientHeight = {read=GetClientHeight, write=SetClientHeight, stored=false, nodefault
  561.         };
  562.     __property Windows::TPoint ClientOrigin = {read=GetClientOrigin};
  563.     __property Windows::TRect ClientRect = {read=GetClientRect};
  564.     __property int ClientWidth = {read=GetClientWidth, write=SetClientWidth, stored=false, nodefault};
  565.     __property TSizeConstraints* Constraints = {read=FConstraints, write=FConstraints};
  566.     __property TControlState ControlState = {read=FControlState, write=FControlState, nodefault};
  567.     __property TControlStyle ControlStyle = {read=FControlStyle, write=FControlStyle, nodefault};
  568.     __property TDockOrientation DockOrientation = {read=FDockOrientation, write=FDockOrientation, nodefault
  569.         };
  570.     __property bool Floating = {read=GetFloating, nodefault};
  571.     __property TMetaClass* FloatingDockSiteClass = {read=GetFloatingDockSiteClass, write=FFloatingDockSiteClass
  572.         };
  573.     __property TWinControl* HostDockSite = {read=FHostDockSite, write=SetHostDockSite};
  574.     __property int LRDockWidth = {read=GetLRDockWidth, write=FLRDockWidth, nodefault};
  575.     __property TWinControl* Parent = {read=FParent, write=SetParent};
  576.     __property bool ShowHint = {read=FShowHint, write=SetShowHint, stored=IsShowHintStored, nodefault};
  577.         
  578.     __property int TBDockHeight = {read=GetTBDockHeight, write=FTBDockHeight, nodefault};
  579.     __property int UndockHeight = {read=GetUndockHeight, write=FUndockHeight, nodefault};
  580.     __property int UndockWidth = {read=GetUndockWidth, write=FUndockWidth, nodefault};
  581.     __property bool Visible = {read=FVisible, write=SetVisible, stored=IsVisibleStored, default=1};
  582.     __property TWndMethod WindowProc = {read=FWindowProc, write=FWindowProc};
  583.     
  584. __published:
  585.     __property int Left = {read=FLeft, write=SetLeft, nodefault};
  586.     __property int Top = {read=FTop, write=SetTop, nodefault};
  587.     __property int Width = {read=FWidth, write=SetWidth, nodefault};
  588.     __property int Height = {read=FHeight, write=SetHeight, nodefault};
  589.     __property TCursor Cursor = {read=FCursor, write=SetCursor, default=0};
  590.     __property AnsiString Hint = {read=FHint, write=FHint, stored=IsHintStored};
  591. };
  592.  
  593.  
  594. #pragma option push -b-
  595. enum TBevelEdge { beLeft, beTop, beRight, beBottom };
  596. #pragma option pop
  597.  
  598. typedef Set<TBevelEdge, beLeft, beBottom>  TBevelEdges;
  599.  
  600. #pragma option push -b-
  601. enum TBevelCut { bvNone, bvLowered, bvRaised, bvSpace };
  602. #pragma option pop
  603.  
  604. #pragma option push -b-
  605. enum TBevelKind { bkNone, bkTile, bkSoft, bkFlat };
  606. #pragma option pop
  607.  
  608. typedef int TBevelWidth;
  609.  
  610. typedef int TBorderWidth;
  611.  
  612. __interface IDockManager;
  613. typedef System::DelphiInterface<IDockManager> _di_IDockManager;
  614. __interface INTERFACE_UUID("{8619FD79-C281-11D1-AA60-00C04FA370E8}") IDockManager  : public IUnknown 
  615.     
  616. {
  617.     
  618. public:
  619.     virtual void __fastcall BeginUpdate(void) = 0 ;
  620.     virtual void __fastcall EndUpdate(void) = 0 ;
  621.     virtual void __fastcall GetControlBounds(TControl* Control, /* out */ Windows::TRect &CtlBounds) = 0 
  622.         ;
  623.     virtual void __fastcall InsertControl(TControl* Control, TAlign InsertAt, TControl* DropCtl) = 0 ;
  624.     virtual void __fastcall LoadFromStream(Classes::TStream* Stream) = 0 ;
  625.     virtual void __fastcall PaintSite(HDC DC) = 0 ;
  626.     virtual void __fastcall PositionDockRect(TControl* Client, TControl* DropCtl, TAlign DropAlign, Windows::TRect 
  627.         &DockRect) = 0 ;
  628.     virtual void __fastcall RemoveControl(TControl* Control) = 0 ;
  629.     virtual void __fastcall ResetBounds(bool Force) = 0 ;
  630.     virtual void __fastcall SaveToStream(Classes::TStream* Stream) = 0 ;
  631.     virtual void __fastcall SetReplacingControl(TControl* Control) = 0 ;
  632. };
  633.  
  634. #pragma option push -b-
  635. enum TImeMode { imDisable, imClose, imOpen, imDontCare, imSAlpha, imAlpha, imHira, imSKata, imKata, 
  636.     imChinese, imSHanguel, imHanguel };
  637. #pragma option pop
  638.  
  639. typedef AnsiString TImeName;
  640.  
  641. typedef void __fastcall (__closure *TDockDropEvent)(System::TObject* Sender, TDragDockObject* Source
  642.     , int X, int Y);
  643.  
  644. typedef void __fastcall (__closure *TDockOverEvent)(System::TObject* Sender, TDragDockObject* Source
  645.     , int X, int Y, TDragState State, bool &Accept);
  646.  
  647. typedef void __fastcall (__closure *TGetSiteInfoEvent)(System::TObject* Sender, TControl* DockClient
  648.     , Windows::TRect &InfluenceRect, const Windows::TPoint &MousePos, bool &CanDock);
  649.  
  650. typedef void __fastcall (__closure *TKeyEvent)(System::TObject* Sender, Word &Key, Classes::TShiftState 
  651.     Shift);
  652.  
  653. typedef void __fastcall (__closure *TKeyPressEvent)(System::TObject* Sender, char &Key);
  654.  
  655. typedef void __fastcall (__closure *TMouseWheelEvent)(System::TObject* Sender, Classes::TShiftState 
  656.     Shift, int WheelDelta, const Windows::TPoint &MousePos, bool &Handled);
  657.  
  658. typedef void __fastcall (__closure *TMouseWheelUpDownEvent)(System::TObject* Sender, Classes::TShiftState 
  659.     Shift, const Windows::TPoint &MousePos, bool &Handled);
  660.  
  661. typedef void __fastcall (__closure *TUnDockEvent)(System::TObject* Sender, TControl* Client, TWinControl* 
  662.     NewTarget, bool &Allow);
  663.  
  664. typedef short TTabOrder;
  665.  
  666. struct TCMFocusChanged;
  667. struct TCMDockClient;
  668. struct TCMUnDockClient;
  669. struct TCreateParams;
  670. class PASCALIMPLEMENTATION TWinControl : public TControl 
  671. {
  672.     typedef TControl inherited;
  673.     
  674. private:
  675.     Word FAlignLevel;
  676.     TBevelEdges FBevelEdges;
  677.     TBevelCut FBevelInner;
  678.     TBevelCut FBevelOuter;
  679.     TBevelKind FBevelKind;
  680.     TBevelWidth FBevelWidth;
  681.     TBorderWidth FBorderWidth;
  682.     Graphics::TBrush* FBrush;
  683.     Classes::TList* FControls;
  684.     bool FCtl3D;
  685.     void *FDefWndProc;
  686.     Classes::TList* FDockClients;
  687.     bool FDockSite;
  688.     _di_IDockManager FDockManager;
  689.     HWND FHandle;
  690.     Classes::THelpContext FHelpContext;
  691.     TImeMode FImeMode;
  692.     AnsiString FImeName;
  693.     void *FObjectInstance;
  694.     bool FParentCtl3D;
  695.     HWND FParentWindow;
  696.     bool FShowing;
  697.     Classes::TList* FTabList;
  698.     int FTabOrder;
  699.     bool FTabStop;
  700.     int FWheelAccumulator;
  701.     bool FUseDockManager;
  702.     Classes::TList* FWinControls;
  703.     TDockDropEvent FOnDockDrop;
  704.     TDockOverEvent FOnDockOver;
  705.     Classes::TNotifyEvent FOnEnter;
  706.     Classes::TNotifyEvent FOnExit;
  707.     TGetSiteInfoEvent FOnGetSiteInfo;
  708.     TKeyEvent FOnKeyDown;
  709.     TKeyPressEvent FOnKeyPress;
  710.     TKeyEvent FOnKeyUp;
  711.     TMouseWheelEvent FOnMouseWheel;
  712.     TMouseWheelUpDownEvent FOnMouseWheelDown;
  713.     TMouseWheelUpDownEvent FOnMouseWheelUp;
  714.     TUnDockEvent FOnUnDock;
  715.     void __fastcall AlignControl(TControl* AControl);
  716.     void __fastcall CalcConstraints(int &MinWidth, int &MinHeight, int &MaxWidth, int &MaxHeight);
  717.     TControl* __fastcall GetControl(int Index);
  718.     int __fastcall GetControlCount(void);
  719.     int __fastcall GetDockClientCount(void);
  720.     TControl* __fastcall GetDockClients(int Index);
  721.     HWND __fastcall GetHandle(void);
  722.     TTabOrder __fastcall GetTabOrder(void);
  723.     int __fastcall GetVisibleDockClientCount(void);
  724.     HIDESBASE void __fastcall Insert(TControl* AControl);
  725.     void __fastcall InvalidateFrame(void);
  726.     bool __fastcall IsCtl3DStored(void);
  727.     bool __fastcall IsHelpContextStored(void);
  728.     HWND __fastcall PrecedingWindow(TWinControl* Control);
  729.     HIDESBASE void __fastcall Remove(TControl* AControl);
  730.     void __fastcall RemoveFocus(bool Removing);
  731.     void __fastcall SetBevelCut(int Index, const TBevelCut Value);
  732.     void __fastcall SetBevelEdges(const TBevelEdges Value);
  733.     void __fastcall SetBevelKind(const TBevelKind Value);
  734.     void __fastcall SetBevelWidth(const TBevelWidth Value);
  735.     void __fastcall SetBorderWidth(TBorderWidth Value);
  736.     void __fastcall SetCtl3D(bool Value);
  737.     void __fastcall SetDockSite(bool Value);
  738.     void __fastcall SetParentCtl3D(bool Value);
  739.     void __fastcall SetParentWindow(HWND Value);
  740.     void __fastcall SetTabOrder(TTabOrder Value);
  741.     void __fastcall SetTabStop(bool Value);
  742.     void __fastcall SetUseDockManager(bool Value);
  743.     HIDESBASE void __fastcall SetZOrderPosition(int Position);
  744.     void __fastcall UpdateTabOrder(TTabOrder Value);
  745.     void __fastcall UpdateBounds(void);
  746.     void __fastcall UpdateShowing(void);
  747.     bool __fastcall IsMenuKey(Messages::TWMKey &Message);
  748.     MESSAGE void __fastcall WMPaint(Messages::TWMPaint &Message);
  749.     MESSAGE void __fastcall WMCommand(Messages::TWMCommand &Message);
  750.     MESSAGE void __fastcall WMNotify(Messages::TWMNotify &Message);
  751.     MESSAGE void __fastcall WMSysColorChange(Messages::TWMNoParams &Message);
  752.     MESSAGE void __fastcall WMHScroll(Messages::TWMScroll &Message);
  753.     MESSAGE void __fastcall WMVScroll(Messages::TWMScroll &Message);
  754.     MESSAGE void __fastcall WMCompareItem(Messages::TWMCompareItem &Message);
  755.     MESSAGE void __fastcall WMDeleteItem(Messages::TWMDeleteItem &Message);
  756.     MESSAGE void __fastcall WMDrawItem(Messages::TWMDrawItem &Message);
  757.     MESSAGE void __fastcall WMMeasureItem(Messages::TWMMeasureItem &Message);
  758.     MESSAGE void __fastcall WMEraseBkgnd(Messages::TWMEraseBkgnd &Message);
  759.     HIDESBASE MESSAGE void __fastcall WMWindowPosChanged(Messages::TWMWindowPosMsg &Message);
  760.     MESSAGE void __fastcall WMWindowPosChanging(Messages::TWMWindowPosMsg &Message);
  761.     MESSAGE void __fastcall WMSize(Messages::TWMSize &Message);
  762.     MESSAGE void __fastcall WMMove(Messages::TWMMove &Message);
  763.     MESSAGE void __fastcall WMSetCursor(Messages::TWMSetCursor &Message);
  764.     MESSAGE void __fastcall WMKeyDown(Messages::TWMKey &Message);
  765.     MESSAGE void __fastcall WMSysKeyDown(Messages::TWMKey &Message);
  766.     MESSAGE void __fastcall WMKeyUp(Messages::TWMKey &Message);
  767.     MESSAGE void __fastcall WMSysKeyUp(Messages::TWMKey &Message);
  768.     MESSAGE void __fastcall WMChar(Messages::TWMKey &Message);
  769.     MESSAGE void __fastcall WMSysCommand(Messages::TWMSysCommand &Message);
  770.     MESSAGE void __fastcall WMCharToItem(Messages::TWMCharToItem &Message);
  771.     MESSAGE void __fastcall WMParentNotify(Messages::TWMParentNotify &Message);
  772.     MESSAGE void __fastcall WMVKeyToItem(Messages::TWMCharToItem &Message);
  773.     MESSAGE void __fastcall WMDestroy(Messages::TWMNoParams &Message);
  774.     MESSAGE void __fastcall WMNCCalcSize(Messages::TWMNCCalcSize &Message);
  775.     MESSAGE void __fastcall WMNCDestroy(Messages::TWMNoParams &Message);
  776.     MESSAGE void __fastcall WMNCHitTest(Messages::TWMNCHitTest &Message);
  777.     MESSAGE void __fastcall WMNCPaint(Messages::TMessage &Message);
  778.     MESSAGE void __fastcall WMQueryNewPalette(Messages::TMessage &Message);
  779.     MESSAGE void __fastcall WMPaletteChanged(Messages::TMessage &Message);
  780.     MESSAGE void __fastcall WMWinIniChange(Messages::TMessage &Message);
  781.     MESSAGE void __fastcall WMFontChange(Messages::TMessage &Message);
  782.     MESSAGE void __fastcall WMTimeChange(Messages::TMessage &Message);
  783.     MESSAGE void __fastcall WMSetFocus(Messages::TWMSetFocus &Message);
  784.     MESSAGE void __fastcall WMKillFocus(Messages::TWMSetFocus &Message);
  785.     MESSAGE void __fastcall WMIMEStartComp(Messages::TMessage &Message);
  786.     MESSAGE void __fastcall WMIMEEndComp(Messages::TMessage &Message);
  787.     MESSAGE void __fastcall WMMouseWheel(Messages::TWMMouseWheel &Message);
  788.     HIDESBASE MESSAGE void __fastcall WMContextMenu(Messages::TWMContextMenu &Message);
  789.     MESSAGE void __fastcall CMChanged(Messages::TMessage &Message);
  790.     MESSAGE void __fastcall CMChildKey(Messages::TMessage &Message);
  791.     MESSAGE void __fastcall CMDialogKey(Messages::TWMKey &Message);
  792.     MESSAGE void __fastcall CMDialogChar(Messages::TWMKey &Message);
  793.     MESSAGE void __fastcall CMFocusChanged(TCMFocusChanged &Message);
  794.     HIDESBASE MESSAGE void __fastcall CMVisibleChanged(Messages::TMessage &Message);
  795.     HIDESBASE MESSAGE void __fastcall CMEnabledChanged(Messages::TMessage &Message);
  796.     HIDESBASE MESSAGE void __fastcall CMColorChanged(Messages::TMessage &Message);
  797.     HIDESBASE MESSAGE void __fastcall CMFontChanged(Messages::TMessage &Message);
  798.     MESSAGE void __fastcall CMBorderChanged(Messages::TMessage &Message);
  799.     MESSAGE void __fastcall CMCursorChanged(Messages::TMessage &Message);
  800.     MESSAGE void __fastcall CMCtl3DChanged(Messages::TMessage &Message);
  801.     MESSAGE void __fastcall CMParentCtl3DChanged(Messages::TMessage &Message);
  802.     MESSAGE void __fastcall CMShowingChanged(Messages::TMessage &Message);
  803.     MESSAGE void __fastcall CMShowHintChanged(Messages::TMessage &Message);
  804.     MESSAGE void __fastcall CMEnter(Messages::TWMNoParams &Message);
  805.     MESSAGE void __fastcall CMExit(Messages::TWMNoParams &Message);
  806.     HIDESBASE MESSAGE void __fastcall CMDesignHitTest(Messages::TWMMouse &Message);
  807.     MESSAGE void __fastcall CMSysColorChange(Messages::TMessage &Message);
  808.     HIDESBASE MESSAGE void __fastcall CMSysFontChanged(Messages::TMessage &Message);
  809.     MESSAGE void __fastcall CMWinIniChange(Messages::TWMWinIniChange &Message);
  810.     MESSAGE void __fastcall CMFontChange(Messages::TMessage &Message);
  811.     MESSAGE void __fastcall CMTimeChange(Messages::TMessage &Message);
  812.     MESSAGE void __fastcall CMDrag(TCMDrag &Message);
  813.     MESSAGE void __fastcall CNKeyDown(Messages::TWMKey &Message);
  814.     MESSAGE void __fastcall CNKeyUp(Messages::TWMKey &Message);
  815.     MESSAGE void __fastcall CNChar(Messages::TWMKey &Message);
  816.     MESSAGE void __fastcall CNSysKeyDown(Messages::TWMKey &Message);
  817.     MESSAGE void __fastcall CNSysChar(Messages::TWMKey &Message);
  818.     MESSAGE void __fastcall CMControlListChange(Messages::TMessage &Message);
  819.     MESSAGE void __fastcall CMRecreateWnd(Messages::TMessage &Message);
  820.     MESSAGE void __fastcall CMInvalidate(Messages::TMessage &Message);
  821.     MESSAGE void __fastcall CMDockClient(TCMDockClient &Message);
  822.     MESSAGE void __fastcall CMUnDockClient(TCMUnDockClient &Message);
  823.     HIDESBASE MESSAGE void __fastcall CMFloat(TCMFloat &Message);
  824.     HIDESBASE MESSAGE void __fastcall CMBiDiModeChanged(Messages::TMessage &Message);
  825.     MESSAGE void __fastcall CMMouseWheel(TCMMouseWheel &Message);
  826.     
  827. protected:
  828.     bool FDoubleBuffered;
  829.     bool FInImeComposition;
  830.     DYNAMIC void __fastcall ActionChange(System::TObject* Sender, bool CheckDefaults);
  831.     void __fastcall AddBiDiModeExStyle(unsigned &ExStyle);
  832.     virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
  833.     virtual void __fastcall AdjustClientRect(Windows::TRect &Rect);
  834.     DYNAMIC void __fastcall AdjustSize(void);
  835.     virtual void __fastcall AlignControls(TControl* AControl, Windows::TRect &Rect);
  836.     virtual bool __fastcall CanAutoSize(int &NewWidth, int &NewHeight);
  837.     virtual bool __fastcall CanResize(int &NewWidth, int &NewHeight);
  838.     DYNAMIC void __fastcall ChangeScale(int M, int D);
  839.     virtual void __fastcall ConstrainedResize(int &MinWidth, int &MinHeight, int &MaxWidth, int &MaxHeight
  840.         );
  841.     DYNAMIC _di_IDockManager __fastcall CreateDockManager();
  842.     virtual void __fastcall CreateHandle(void);
  843.     virtual void __fastcall CreateParams(TCreateParams &Params);
  844.     void __fastcall CreateSubClass(TCreateParams &Params, char * ControlClassName);
  845.     virtual void __fastcall CreateWindowHandle(const TCreateParams &Params);
  846.     virtual void __fastcall CreateWnd(void);
  847.     void __fastcall DestroyHandle(void);
  848.     virtual void __fastcall DestroyWindowHandle(void);
  849.     virtual void __fastcall DestroyWnd(void);
  850.     DYNAMIC void __fastcall DoAddDockClient(TControl* Client, const Windows::TRect &ARect);
  851.     DYNAMIC void __fastcall DockOver(TDragDockObject* Source, int X, int Y, TDragState State, bool &Accept
  852.         );
  853.     DYNAMIC void __fastcall DoDockOver(TDragDockObject* Source, int X, int Y, TDragState State, bool &Accept
  854.         );
  855.     DYNAMIC void __fastcall DoEnter(void);
  856.     DYNAMIC void __fastcall DoExit(void);
  857.     DYNAMIC void __fastcall DoFlipChildren(void);
  858.     bool __fastcall DoKeyDown(Messages::TWMKey &Message);
  859.     bool __fastcall DoKeyPress(Messages::TWMKey &Message);
  860.     bool __fastcall DoKeyUp(Messages::TWMKey &Message);
  861.     DYNAMIC bool __fastcall DoMouseWheel(Classes::TShiftState Shift, int WheelDelta, const Windows::TPoint 
  862.         &MousePos);
  863.     DYNAMIC bool __fastcall DoMouseWheelDown(Classes::TShiftState Shift, const Windows::TPoint &MousePos
  864.         );
  865.     DYNAMIC bool __fastcall DoMouseWheelUp(Classes::TShiftState Shift, const Windows::TPoint &MousePos)
  866.         ;
  867.     DYNAMIC void __fastcall DoRemoveDockClient(TControl* Client);
  868.     DYNAMIC bool __fastcall DoUnDock(TWinControl* NewTarget, TControl* Client);
  869.     TWinControl* __fastcall FindNextControl(TWinControl* CurControl, bool GoForward, bool CheckTabStop, 
  870.         bool CheckParent);
  871.     void __fastcall FixupTabList(void);
  872.     DYNAMIC TMetaClass* __fastcall GetActionLinkClass(void);
  873.     DYNAMIC void __fastcall GetChildren(Classes::TGetChildProc Proc, Classes::TComponent* Root);
  874.     virtual Windows::TPoint __fastcall GetClientOrigin();
  875.     virtual Windows::TRect __fastcall GetClientRect();
  876.     virtual Windows::TRect __fastcall GetControlExtents();
  877.     virtual HDC __fastcall GetDeviceContext(HWND &WindowHandle);
  878.     HWND __fastcall GetParentHandle(void);
  879.     DYNAMIC void __fastcall GetSiteInfo(TControl* Client, Windows::TRect &InfluenceRect, const Windows::TPoint 
  880.         &MousePos, bool &CanDock);
  881.     HWND __fastcall GetTopParentHandle(void);
  882.     bool __fastcall IsControlMouseMsg(Messages::TWMMouse &Message);
  883.     DYNAMIC void __fastcall KeyDown(Word &Key, Classes::TShiftState Shift);
  884.     DYNAMIC void __fastcall KeyUp(Word &Key, Classes::TShiftState Shift);
  885.     DYNAMIC void __fastcall KeyPress(char &Key);
  886.     void __fastcall MainWndProc(Messages::TMessage &Message);
  887.     void __fastcall NotifyControls(Word Msg);
  888.     void __fastcall PaintControls(HDC DC, TControl* First);
  889.     void __fastcall PaintHandler(Messages::TWMPaint &Message);
  890.     virtual void __fastcall PaintWindow(HDC DC);
  891.     DYNAMIC bool __fastcall PaletteChanged(bool Foreground);
  892.     virtual void __fastcall ReadState(Classes::TReader* Reader);
  893.     void __fastcall RecreateWnd(void);
  894.     DYNAMIC void __fastcall ReloadDockedControl(const AnsiString AControlName, TControl* &AControl);
  895.     void __fastcall ResetIme(void);
  896.     bool __fastcall ResetImeComposition(unsigned Action);
  897.     void __fastcall ScaleControls(int M, int D);
  898.     void __fastcall SelectFirst(void);
  899.     void __fastcall SelectNext(TWinControl* CurControl, bool GoForward, bool CheckTabStop);
  900.     DYNAMIC void __fastcall SetChildOrder(Classes::TComponent* Child, int Order);
  901.     void __fastcall SetIme(void);
  902.     bool __fastcall SetImeCompositionWindow(Graphics::TFont* Font, int XPos, int YPos);
  903.     DYNAMIC void __fastcall SetZOrder(bool TopMost);
  904.     virtual void __fastcall ShowControl(TControl* AControl);
  905.     virtual void __fastcall WndProc(Messages::TMessage &Message);
  906.     __property TBevelEdges BevelEdges = {read=FBevelEdges, write=SetBevelEdges, default=15};
  907.     __property TBevelCut BevelInner = {read=FBevelInner, write=SetBevelCut, index=0, default=2};
  908.     __property TBevelCut BevelOuter = {read=FBevelOuter, write=SetBevelCut, index=1, default=1};
  909.     __property TBevelKind BevelKind = {read=FBevelKind, write=SetBevelKind, default=0};
  910.     __property TBevelWidth BevelWidth = {read=FBevelWidth, write=SetBevelWidth, default=1};
  911.     __property TBorderWidth BorderWidth = {read=FBorderWidth, write=SetBorderWidth, default=0};
  912.     __property bool Ctl3D = {read=FCtl3D, write=SetCtl3D, stored=IsCtl3DStored, nodefault};
  913.     __property void * DefWndProc = {read=FDefWndProc, write=FDefWndProc};
  914.     __property bool DockSite = {read=FDockSite, write=SetDockSite, default=0};
  915.     __property _di_IDockManager DockManager = {read=FDockManager, write=FDockManager};
  916.     __property TImeMode ImeMode = {read=FImeMode, write=FImeMode, default=3};
  917.     __property AnsiString ImeName = {read=FImeName, write=FImeName};
  918.     __property bool ParentCtl3D = {read=FParentCtl3D, write=SetParentCtl3D, default=1};
  919.     __property bool UseDockManager = {read=FUseDockManager, write=SetUseDockManager, default=0};
  920.     __property int WheelAccumulator = {read=FWheelAccumulator, write=FWheelAccumulator, nodefault};
  921.     __property HWND WindowHandle = {read=FHandle, write=FHandle, nodefault};
  922.     __property TDockDropEvent OnDockDrop = {read=FOnDockDrop, write=FOnDockDrop};
  923.     __property TDockOverEvent OnDockOver = {read=FOnDockOver, write=FOnDockOver};
  924.     __property Classes::TNotifyEvent OnEnter = {read=FOnEnter, write=FOnEnter};
  925.     __property Classes::TNotifyEvent OnExit = {read=FOnExit, write=FOnExit};
  926.     __property TGetSiteInfoEvent OnGetSiteInfo = {read=FOnGetSiteInfo, write=FOnGetSiteInfo};
  927.     __property TKeyEvent OnKeyDown = {read=FOnKeyDown, write=FOnKeyDown};
  928.     __property TKeyPressEvent OnKeyPress = {read=FOnKeyPress, write=FOnKeyPress};
  929.     __property TKeyEvent OnKeyUp = {read=FOnKeyUp, write=FOnKeyUp};
  930.     __property TMouseWheelEvent OnMouseWheel = {read=FOnMouseWheel, write=FOnMouseWheel};
  931.     __property TMouseWheelUpDownEvent OnMouseWheelDown = {read=FOnMouseWheelDown, write=FOnMouseWheelDown
  932.         };
  933.     __property TMouseWheelUpDownEvent OnMouseWheelUp = {read=FOnMouseWheelUp, write=FOnMouseWheelUp};
  934.     __property TUnDockEvent OnUnDock = {read=FOnUnDock, write=FOnUnDock};
  935.     
  936. public:
  937.     __fastcall virtual TWinControl(Classes::TComponent* AOwner);
  938.     __fastcall TWinControl(HWND ParentWindow);
  939.     /*         class method */ static TWinControl* __fastcall CreateParentedControl(TMetaClass* vmt, HWND 
  940.         ParentWindow);
  941.     __fastcall virtual ~TWinControl(void);
  942.     void __fastcall Broadcast(void *Message);
  943.     DYNAMIC bool __fastcall CanFocus(void);
  944.     bool __fastcall ContainsControl(TControl* Control);
  945.     TControl* __fastcall ControlAtPos(const Windows::TPoint &Pos, bool AllowDisabled, bool AllowWinControls
  946.         );
  947.     virtual void __fastcall DefaultHandler(void *Message);
  948.     void __fastcall DisableAlign(void);
  949.     __property int DockClientCount = {read=GetDockClientCount, nodefault};
  950.     __property TControl* DockClients[int Index] = {read=GetDockClients};
  951.     DYNAMIC void __fastcall DockDrop(TDragDockObject* Source, int X, int Y);
  952.     __property bool DoubleBuffered = {read=FDoubleBuffered, write=FDoubleBuffered, nodefault};
  953.     void __fastcall EnableAlign(void);
  954.     TControl* __fastcall FindChildControl(const AnsiString ControlName);
  955.     DYNAMIC void __fastcall FlipChildren(bool AllLevels);
  956.     DYNAMIC bool __fastcall Focused(void);
  957.     DYNAMIC void __fastcall GetTabOrderList(Classes::TList* List);
  958.     bool __fastcall HandleAllocated(void);
  959.     void __fastcall HandleNeeded(void);
  960.     void __fastcall InsertControl(TControl* AControl);
  961.     virtual void __fastcall Invalidate(void);
  962.     DYNAMIC void __fastcall MouseWheelHandler(Messages::TMessage &Message);
  963.     void __fastcall PaintTo(HDC DC, int X, int Y);
  964.     void __fastcall RemoveControl(TControl* AControl);
  965.     void __fastcall Realign(void);
  966.     virtual void __fastcall Repaint(void);
  967.     void __fastcall ScaleBy(int M, int D);
  968.     void __fastcall ScrollBy(int DeltaX, int DeltaY);
  969.     virtual void __fastcall SetBounds(int ALeft, int ATop, int AWidth, int AHeight);
  970.     virtual void __fastcall SetFocus(void);
  971.     virtual void __fastcall Update(void);
  972.     void __fastcall UpdateControlState(void);
  973.     __property int VisibleDockClientCount = {read=GetVisibleDockClientCount, nodefault};
  974.     __property Graphics::TBrush* Brush = {read=FBrush};
  975.     __property TControl* Controls[int Index] = {read=GetControl};
  976.     __property int ControlCount = {read=GetControlCount, nodefault};
  977.     __property HWND Handle = {read=GetHandle, nodefault};
  978.     __property HWND ParentWindow = {read=FParentWindow, write=SetParentWindow, nodefault};
  979.     __property bool Showing = {read=FShowing, nodefault};
  980.     __property TTabOrder TabOrder = {read=GetTabOrder, write=SetTabOrder, default=-1};
  981.     __property bool TabStop = {read=FTabStop, write=SetTabStop, default=0};
  982.     
  983. __published:
  984.     __property Classes::THelpContext HelpContext = {read=FHelpContext, write=FHelpContext, stored=IsHelpContextStored
  985.         , default=0};
  986. };
  987.  
  988.  
  989.  
  990. struct TCMCancelMode
  991. {
  992.     unsigned Msg;
  993.     int Unused;
  994.     TControl* Sender;
  995.     int Result;
  996. } ;
  997.  
  998. struct TCMFocusChanged
  999. {
  1000.     unsigned Msg;
  1001.     int Unused;
  1002.     TWinControl* Sender;
  1003.     int Result;
  1004. } ;
  1005.  
  1006. struct TCMControlListChange
  1007. {
  1008.     unsigned Msg;
  1009.     TControl* Control;
  1010.     BOOL Inserting;
  1011.     int Result;
  1012. } ;
  1013.  
  1014. struct TCMChildKey
  1015. {
  1016.     unsigned Msg;
  1017.     Word CharCode;
  1018.     Word Unused;
  1019.     TWinControl* Sender;
  1020.     int Result;
  1021. } ;
  1022.  
  1023. struct TCMControlChange
  1024. {
  1025.     unsigned Msg;
  1026.     TControl* Control;
  1027.     BOOL Inserting;
  1028.     int Result;
  1029. } ;
  1030.  
  1031. struct TCMChanged
  1032. {
  1033.     unsigned Msg;
  1034.     int Unused;
  1035.     TControl* Child;
  1036.     int Result;
  1037. } ;
  1038.  
  1039. #pragma option push -b-
  1040. enum TDragMessage { dmDragEnter, dmDragLeave, dmDragMove, dmDragDrop, dmDragCancel, dmFindTarget };
  1041. #pragma option pop
  1042.  
  1043. struct TDragRec;
  1044. typedef TDragRec *PDragRec;
  1045.  
  1046. struct TDragRec
  1047. {
  1048.     Windows::TPoint Pos;
  1049.     TDragObject* Source;
  1050.     void *Target;
  1051.     bool Docking;
  1052. } ;
  1053.  
  1054. #pragma pack(push, 1)
  1055. struct TCMDrag
  1056. {
  1057.     unsigned Msg;
  1058.     TDragMessage DragMessage;
  1059.     Byte Reserved1;
  1060.     Word Reserved2;
  1061.     TDragRec *DragRec;
  1062.     int Result;
  1063. } ;
  1064. #pragma pack(pop)
  1065.  
  1066. #pragma pack(push, 1)
  1067. struct TCMDockClient
  1068. {
  1069.     unsigned Msg;
  1070.     TDragDockObject* DockSource;
  1071.     Windows::TSmallPoint MousePos;
  1072.     int Result;
  1073. } ;
  1074. #pragma pack(pop)
  1075.  
  1076. #pragma pack(push, 1)
  1077. struct TCMUnDockClient
  1078. {
  1079.     unsigned Msg;
  1080.     TControl* NewTarget;
  1081.     TControl* Client;
  1082.     int Result;
  1083. } ;
  1084. #pragma pack(pop)
  1085.  
  1086. #pragma pack(push, 1)
  1087. struct TCMFloat
  1088. {
  1089.     unsigned Msg;
  1090.     int Reserved;
  1091.     TDragDockObject* DockSource;
  1092.     int Result;
  1093. } ;
  1094. #pragma pack(pop)
  1095.  
  1096. struct TDockNotifyRec;
  1097. typedef TDockNotifyRec *PDockNotifyRec;
  1098.  
  1099. struct TDockNotifyRec
  1100. {
  1101.     unsigned ClientMsg;
  1102.     int MsgWParam;
  1103.     int MsgLParam;
  1104. } ;
  1105.  
  1106. #pragma pack(push, 1)
  1107. struct TCMDockNotification
  1108. {
  1109.     unsigned Msg;
  1110.     TControl* Client;
  1111.     TDockNotifyRec *NotifyRec;
  1112.     int Result;
  1113. } ;
  1114. #pragma pack(pop)
  1115.  
  1116. typedef Set<TAlign, alNone, alClient>  TAlignSet;
  1117.  
  1118. class PASCALIMPLEMENTATION TDragObject : public System::TObject 
  1119. {
  1120.     typedef System::TObject inherited;
  1121.     
  1122. private:
  1123.     void *FDragTarget;
  1124.     HWND FDragHandle;
  1125.     Windows::TPoint FDragPos;
  1126.     Windows::TPoint FDragTargetPos;
  1127.     double FMouseDeltaX;
  1128.     double FMouseDeltaY;
  1129.     bool FCancelling;
  1130.     HWND __fastcall Capture(void);
  1131.     void __fastcall MouseMsg(Messages::TMessage &Msg);
  1132.     void __fastcall ReleaseCapture(HWND Handle);
  1133.     
  1134. protected:
  1135.     virtual void __fastcall Finished(System::TObject* Target, int X, int Y, bool Accepted);
  1136.     virtual TCursor __fastcall GetDragCursor(bool Accepted, int X, int Y);
  1137.     virtual TDragImageList* __fastcall GetDragImages(void);
  1138.     
  1139. public:
  1140.     virtual void __fastcall Assign(TDragObject* Source);
  1141.     virtual AnsiString __fastcall GetName();
  1142.     virtual void __fastcall HideDragImage(void);
  1143.     virtual unsigned __fastcall Instance(void);
  1144.     virtual void __fastcall ShowDragImage(void);
  1145.     __property bool Cancelling = {read=FCancelling, write=FCancelling, nodefault};
  1146.     __property HWND DragHandle = {read=FDragHandle, write=FDragHandle, nodefault};
  1147.     __property Windows::TPoint DragPos = {read=FDragPos, write=FDragPos};
  1148.     __property Windows::TPoint DragTargetPos = {read=FDragTargetPos, write=FDragTargetPos};
  1149.     __property void * DragTarget = {read=FDragTarget, write=FDragTarget};
  1150.     __property double MouseDeltaX = {read=FMouseDeltaX};
  1151.     __property double MouseDeltaY = {read=FMouseDeltaX};
  1152. public:
  1153.     #pragma option push -w-inl
  1154.     /* TObject.Create */ inline __fastcall TDragObject(void) : System::TObject() { }
  1155.     #pragma option pop
  1156.     #pragma option push -w-inl
  1157.     /* TObject.Destroy */ inline __fastcall virtual ~TDragObject(void) { }
  1158.     #pragma option pop
  1159.     
  1160. };
  1161.  
  1162.  
  1163. class DELPHICLASS TBaseDragControlObject;
  1164. class PASCALIMPLEMENTATION TBaseDragControlObject : public TDragObject 
  1165. {
  1166.     typedef TDragObject inherited;
  1167.     
  1168. private:
  1169.     TControl* FControl;
  1170.     
  1171. protected:
  1172.     virtual void __fastcall EndDrag(System::TObject* Target, int X, int Y);
  1173.     virtual void __fastcall Finished(System::TObject* Target, int X, int Y, bool Accepted);
  1174.     
  1175. public:
  1176.     __fastcall virtual TBaseDragControlObject(TControl* AControl);
  1177.     virtual void __fastcall Assign(TDragObject* Source);
  1178.     __property TControl* Control = {read=FControl, write=FControl};
  1179. public:
  1180.     #pragma option push -w-inl
  1181.     /* TObject.Destroy */ inline __fastcall virtual ~TBaseDragControlObject(void) { }
  1182.     #pragma option pop
  1183.     
  1184. };
  1185.  
  1186.  
  1187. class DELPHICLASS TDragControlObject;
  1188. class PASCALIMPLEMENTATION TDragControlObject : public TBaseDragControlObject 
  1189. {
  1190.     typedef TBaseDragControlObject inherited;
  1191.     
  1192. protected:
  1193.     virtual TCursor __fastcall GetDragCursor(bool Accepted, int X, int Y);
  1194.     virtual TDragImageList* __fastcall GetDragImages(void);
  1195.     
  1196. public:
  1197.     virtual void __fastcall HideDragImage(void);
  1198.     virtual void __fastcall ShowDragImage(void);
  1199. public:
  1200.     #pragma option push -w-inl
  1201.     /* TBaseDragControlObject.Create */ inline __fastcall virtual TDragControlObject(TControl* AControl
  1202.         ) : TBaseDragControlObject(AControl) { }
  1203.     #pragma option pop
  1204.     
  1205. public:
  1206.     #pragma option push -w-inl
  1207.     /* TObject.Destroy */ inline __fastcall virtual ~TDragControlObject(void) { }
  1208.     #pragma option pop
  1209.     
  1210. };
  1211.  
  1212.  
  1213. class PASCALIMPLEMENTATION TDragDockObject : public TBaseDragControlObject 
  1214. {
  1215.     typedef TBaseDragControlObject inherited;
  1216.     
  1217. private:
  1218.     Graphics::TBrush* FBrush;
  1219.     Windows::TRect FDockRect;
  1220.     TAlign FDropAlign;
  1221.     TControl* FDropOnControl;
  1222.     Windows::TRect FEraseDockRect;
  1223.     bool FFloating;
  1224.     void __fastcall SetBrush(Graphics::TBrush* Value);
  1225.     
  1226. protected:
  1227.     virtual void __fastcall AdjustDockRect(const Windows::TRect &ARect);
  1228.     virtual void __fastcall DrawDragDockImage(void);
  1229.     virtual void __fastcall EndDrag(System::TObject* Target, int X, int Y);
  1230.     virtual void __fastcall EraseDragDockImage(void);
  1231.     virtual TCursor __fastcall GetDragCursor(bool Accepted, int X, int Y);
  1232.     virtual int __fastcall GetFrameWidth(void);
  1233.     
  1234. public:
  1235.     __fastcall virtual TDragDockObject(TControl* AControl);
  1236.     __fastcall virtual ~TDragDockObject(void);
  1237.     virtual void __fastcall Assign(TDragObject* Source);
  1238.     __property Graphics::TBrush* Brush = {read=FBrush, write=SetBrush};
  1239.     __property Windows::TRect DockRect = {read=FDockRect, write=FDockRect};
  1240.     __property TAlign DropAlign = {read=FDropAlign, nodefault};
  1241.     __property TControl* DropOnControl = {read=FDropOnControl};
  1242.     __property bool Floating = {read=FFloating, write=FFloating, nodefault};
  1243.     __property int FrameWidth = {read=GetFrameWidth, nodefault};
  1244. };
  1245.  
  1246.  
  1247. class DELPHICLASS TControlCanvas;
  1248. class PASCALIMPLEMENTATION TControlCanvas : public Graphics::TCanvas 
  1249. {
  1250.     typedef Graphics::TCanvas inherited;
  1251.     
  1252. private:
  1253.     TControl* FControl;
  1254.     HDC FDeviceContext;
  1255.     HWND FWindowHandle;
  1256.     void __fastcall SetControl(TControl* AControl);
  1257.     
  1258. protected:
  1259.     virtual void __fastcall CreateHandle(void);
  1260.     
  1261. public:
  1262.     __fastcall virtual ~TControlCanvas(void);
  1263.     void __fastcall FreeHandle(void);
  1264.     void __fastcall UpdateTextFlags(void);
  1265.     __property TControl* Control = {read=FControl, write=SetControl};
  1266. public:
  1267.     #pragma option push -w-inl
  1268.     /* TCanvas.Create */ inline __fastcall TControlCanvas(void) : Graphics::TCanvas() { }
  1269.     #pragma option pop
  1270.     
  1271. };
  1272.  
  1273.  
  1274. typedef TMetaClass*TControlClass;
  1275.  
  1276. struct TCreateParams
  1277. {
  1278.     char *Caption;
  1279.     unsigned Style;
  1280.     unsigned ExStyle;
  1281.     int X;
  1282.     int Y;
  1283.     int Width;
  1284.     int Height;
  1285.     HWND WndParent;
  1286.     void *Param;
  1287.     tagWNDCLASSA WindowClass;
  1288.     char WinClassName[64];
  1289. } ;
  1290.  
  1291. class DELPHICLASS TWinControlActionLink;
  1292. class PASCALIMPLEMENTATION TWinControlActionLink : public TControlActionLink 
  1293. {
  1294.     typedef TControlActionLink inherited;
  1295.     
  1296. protected:
  1297.     TWinControl* FClient;
  1298.     virtual void __fastcall AssignClient(System::TObject* AClient);
  1299.     virtual bool __fastcall IsHelpContextLinked(void);
  1300.     virtual void __fastcall SetHelpContext(Classes::THelpContext Value);
  1301. public:
  1302.     #pragma option push -w-inl
  1303.     /* TBasicActionLink.Create */ inline __fastcall virtual TWinControlActionLink(System::TObject* AClient
  1304.         ) : TControlActionLink(AClient) { }
  1305.     #pragma option pop
  1306.     #pragma option push -w-inl
  1307.     /* TBasicActionLink.Destroy */ inline __fastcall virtual ~TWinControlActionLink(void) { }
  1308.     #pragma option pop
  1309.     
  1310. };
  1311.  
  1312.  
  1313. typedef TMetaClass*TWinControlActionLinkClass;
  1314.  
  1315. class DELPHICLASS TGraphicControl;
  1316. class PASCALIMPLEMENTATION TGraphicControl : public TControl 
  1317. {
  1318.     typedef TControl inherited;
  1319.     
  1320. private:
  1321.     Graphics::TCanvas* FCanvas;
  1322.     MESSAGE void __fastcall WMPaint(Messages::TWMPaint &Message);
  1323.     
  1324. protected:
  1325.     virtual void __fastcall Paint(void);
  1326.     __property Graphics::TCanvas* Canvas = {read=FCanvas};
  1327.     
  1328. public:
  1329.     __fastcall virtual TGraphicControl(Classes::TComponent* AOwner);
  1330.     __fastcall virtual ~TGraphicControl(void);
  1331. };
  1332.  
  1333.  
  1334. class DELPHICLASS TCustomControl;
  1335. class PASCALIMPLEMENTATION TCustomControl : public TWinControl 
  1336. {
  1337.     typedef TWinControl inherited;
  1338.     
  1339. private:
  1340.     Graphics::TCanvas* FCanvas;
  1341.     HIDESBASE MESSAGE void __fastcall WMPaint(Messages::TWMPaint &Message);
  1342.     
  1343. protected:
  1344.     virtual void __fastcall Paint(void);
  1345.     virtual void __fastcall PaintWindow(HDC DC);
  1346.     __property Graphics::TCanvas* Canvas = {read=FCanvas};
  1347.     
  1348. public:
  1349.     __fastcall virtual TCustomControl(Classes::TComponent* AOwner);
  1350.     __fastcall virtual ~TCustomControl(void);
  1351. public:
  1352.     #pragma option push -w-inl
  1353.     /* TWinControl.CreateParented */ inline __fastcall TCustomControl(HWND ParentWindow) : TWinControl(
  1354.         ParentWindow) { }
  1355.     #pragma option pop
  1356.     
  1357. };
  1358.  
  1359.  
  1360. class DELPHICLASS THintWindow;
  1361. class PASCALIMPLEMENTATION THintWindow : public TCustomControl 
  1362. {
  1363.     typedef TCustomControl inherited;
  1364.     
  1365. private:
  1366.     bool FActivating;
  1367.     HIDESBASE MESSAGE void __fastcall WMNCHitTest(Messages::TWMNCHitTest &Message);
  1368.     HIDESBASE MESSAGE void __fastcall WMNCPaint(Messages::TMessage &Message);
  1369.     MESSAGE void __fastcall CMTextChanged(Messages::TMessage &Message);
  1370.     
  1371. protected:
  1372.     virtual void __fastcall CreateParams(TCreateParams &Params);
  1373.     virtual void __fastcall Paint(void);
  1374.     
  1375. public:
  1376.     __fastcall virtual THintWindow(Classes::TComponent* AOwner);
  1377.     virtual void __fastcall ActivateHint(const Windows::TRect &Rect, const AnsiString AHint);
  1378.     virtual void __fastcall ActivateHintData(const Windows::TRect &Rect, const AnsiString AHint, void * 
  1379.         AData);
  1380.     virtual Windows::TRect __fastcall CalcHintRect(int MaxWidth, const AnsiString AHint, void * AData);
  1381.         
  1382.     virtual bool __fastcall IsHintMsg(tagMSG &Msg);
  1383.     void __fastcall ReleaseHandle(void);
  1384.     __property BiDiMode ;
  1385.     __property Caption ;
  1386.     __property Color ;
  1387.     __property Canvas ;
  1388.     __property Font ;
  1389. public:
  1390.     #pragma option push -w-inl
  1391.     /* TCustomControl.Destroy */ inline __fastcall virtual ~THintWindow(void) { }
  1392.     #pragma option pop
  1393.     
  1394. public:
  1395.     #pragma option push -w-inl
  1396.     /* TWinControl.CreateParented */ inline __fastcall THintWindow(HWND ParentWindow) : TCustomControl(
  1397.         ParentWindow) { }
  1398.     #pragma option pop
  1399.     
  1400. };
  1401.  
  1402.  
  1403. typedef TMetaClass*THintWindowClass;
  1404.  
  1405. class PASCALIMPLEMENTATION TDragImageList : public Imglist::TCustomImageList 
  1406. {
  1407.     typedef Imglist::TCustomImageList inherited;
  1408.     
  1409. private:
  1410.     TCursor FDragCursor;
  1411.     bool FDragging;
  1412.     HWND FDragHandle;
  1413.     Windows::TPoint FDragHotspot;
  1414.     int FDragIndex;
  1415.     void __fastcall CombineDragCursor(void);
  1416.     void __fastcall SetDragCursor(TCursor Value);
  1417.     
  1418. protected:
  1419.     virtual void __fastcall Initialize(void);
  1420.     
  1421. public:
  1422.     bool __fastcall BeginDrag(HWND Window, int X, int Y);
  1423.     bool __fastcall DragLock(HWND Window, int XPos, int YPos);
  1424.     bool __fastcall DragMove(int X, int Y);
  1425.     void __fastcall DragUnlock(void);
  1426.     bool __fastcall EndDrag(void);
  1427.     virtual Windows::TPoint __fastcall GetHotSpot();
  1428.     void __fastcall HideDragImage(void);
  1429.     bool __fastcall SetDragImage(int Index, int HotSpotX, int HotSpotY);
  1430.     void __fastcall ShowDragImage(void);
  1431.     __property TCursor DragCursor = {read=FDragCursor, write=SetDragCursor, nodefault};
  1432.     __property bool Dragging = {read=FDragging, nodefault};
  1433. public:
  1434.     #pragma option push -w-inl
  1435.     /* TCustomImageList.Create */ inline __fastcall virtual TDragImageList(Classes::TComponent* AOwner)
  1436.          : Imglist::TCustomImageList(AOwner) { }
  1437.     #pragma option pop
  1438.     #pragma option push -w-inl
  1439.     /* TCustomImageList.CreateSize */ inline __fastcall TDragImageList(int AWidth, int AHeight) : Imglist::TCustomImageList(
  1440.         AWidth, AHeight) { }
  1441.     #pragma option pop
  1442.     #pragma option push -w-inl
  1443.     /* TCustomImageList.Destroy */ inline __fastcall virtual ~TDragImageList(void) { }
  1444.     #pragma option pop
  1445.     
  1446. };
  1447.  
  1448.  
  1449. class DELPHICLASS TImageList;
  1450. class PASCALIMPLEMENTATION TImageList : public TDragImageList 
  1451. {
  1452.     typedef TDragImageList inherited;
  1453.     
  1454. __published:
  1455.     __property BlendColor ;
  1456.     __property BkColor ;
  1457.     __property AllocBy ;
  1458.     __property DrawingStyle ;
  1459.     __property Height ;
  1460.     __property ImageType ;
  1461.     __property Masked ;
  1462.     __property OnChange ;
  1463.     __property ShareImages ;
  1464.     __property Width ;
  1465. public:
  1466.     #pragma option push -w-inl
  1467.     /* TCustomImageList.Create */ inline __fastcall virtual TImageList(Classes::TComponent* AOwner) : TDragImageList(
  1468.         AOwner) { }
  1469.     #pragma option pop
  1470.     #pragma option push -w-inl
  1471.     /* TCustomImageList.CreateSize */ inline __fastcall TImageList(int AWidth, int AHeight) : TDragImageList(
  1472.         AWidth, AHeight) { }
  1473.     #pragma option pop
  1474.     #pragma option push -w-inl
  1475.     /* TCustomImageList.Destroy */ inline __fastcall virtual ~TImageList(void) { }
  1476.     #pragma option pop
  1477.     
  1478. };
  1479.  
  1480.  
  1481. class DELPHICLASS TDockZone;
  1482. class DELPHICLASS TDockTree;
  1483. typedef void __fastcall (__closure *TForEachZoneProc)(TDockZone* Zone);
  1484.  
  1485. class PASCALIMPLEMENTATION TDockTree : public System::TInterfacedObject 
  1486. {
  1487.     typedef System::TInterfacedObject inherited;
  1488.     
  1489. private:
  1490.     int FBorderWidth;
  1491.     Graphics::TBrush* FBrush;
  1492.     TWinControl* FDockSite;
  1493.     int FGrabberSize;
  1494.     bool FGrabbersOnTop;
  1495.     Windows::TRect FOldRect;
  1496.     TWndMethod FOldWndProc;
  1497.     TDockZone* FReplacementZone;
  1498.     double FScaleBy;
  1499.     TDockOrientation FShiftScaleOrient;
  1500.     int FShiftBy;
  1501.     Windows::TPoint FSizePos;
  1502.     HDC FSizingDC;
  1503.     HWND FSizingWnd;
  1504.     TDockZone* FSizingZone;
  1505.     TDockZone* FTopZone;
  1506.     int FTopXYLimit;
  1507.     int FUpdateCount;
  1508.     int FVersion;
  1509.     void __fastcall ControlVisibilityChanged(TControl* Control, bool Visible);
  1510.     void __fastcall DrawSizeSplitter(void);
  1511.     TDockZone* __fastcall FindControlZone(TControl* Control);
  1512.     void __fastcall ForEachAt(TDockZone* Zone, TForEachZoneProc Proc);
  1513.     int __fastcall GetNextLimit(TDockZone* AZone);
  1514.     void __fastcall InsertNewParent(TDockZone* NewZone, TDockZone* SiblingZone, TDockOrientation ParentOrientation
  1515.         , bool InsertLast);
  1516.     void __fastcall InsertSibling(TDockZone* NewZone, TDockZone* SiblingZone, bool InsertLast);
  1517.     TDockZone* __fastcall InternalHitTest(const Windows::TPoint &MousePos, /* out */ int &HTFlag);
  1518.     void __fastcall PruneZone(TDockZone* Zone);
  1519.     void __fastcall RemoveZone(TDockZone* Zone);
  1520.     void __fastcall ScaleZone(TDockZone* Zone);
  1521.     void __fastcall SetNewBounds(TDockZone* Zone);
  1522.     void __fastcall ShiftZone(TDockZone* Zone);
  1523.     void __fastcall SplitterMouseDown(TDockZone* OnZone, const Windows::TPoint &MousePos);
  1524.     void __fastcall SplitterMouseUp(void);
  1525.     void __fastcall UpdateZone(TDockZone* Zone);
  1526.     void __fastcall WindowProc(Messages::TMessage &Message);
  1527.     
  1528. protected:
  1529.     virtual void __fastcall AdjustDockRect(TControl* Control, Windows::TRect &ARect);
  1530.     void __fastcall BeginUpdate(void);
  1531.     void __fastcall EndUpdate(void);
  1532.     void __fastcall GetControlBounds(TControl* Control, /* out */ Windows::TRect &CtlBounds);
  1533.     virtual TControl* __fastcall HitTest(const Windows::TPoint &MousePos, /* out */ int &HTFlag);
  1534.     virtual void __fastcall InsertControl(TControl* Control, TAlign InsertAt, TControl* DropCtl);
  1535.     virtual void __fastcall LoadFromStream(Classes::TStream* Stream);
  1536.     virtual void __fastcall PaintDockFrame(Graphics::TCanvas* Canvas, TControl* Control, const Windows::TRect 
  1537.         &ARect);
  1538.     virtual void __fastcall PositionDockRect(TControl* Client, TControl* DropCtl, TAlign DropAlign, Windows::TRect 
  1539.         &DockRect);
  1540.     virtual void __fastcall RemoveControl(TControl* Control);
  1541.     virtual void __fastcall SaveToStream(Classes::TStream* Stream);
  1542.     void __fastcall SetReplacingControl(TControl* Control);
  1543.     virtual void __fastcall ResetBounds(bool Force);
  1544.     void __fastcall UpdateAll(void);
  1545.     __property TWinControl* DockSite = {read=FDockSite, write=FDockSite};
  1546.     
  1547. public:
  1548.     __fastcall virtual TDockTree(TWinControl* DockSite);
  1549.     __fastcall virtual ~TDockTree(void);
  1550.     virtual void __fastcall PaintSite(HDC DC);
  1551. private:
  1552.     void *__IDockManager;    /* Controls::IDockManager */
  1553.     
  1554. public:
  1555.     operator IDockManager*(void) { return (IDockManager*)&__IDockManager; }
  1556.     
  1557. };
  1558.  
  1559.  
  1560. class PASCALIMPLEMENTATION TDockZone : public System::TObject 
  1561. {
  1562.     typedef System::TObject inherited;
  1563.     
  1564. private:
  1565.     TControl* FChildControl;
  1566.     TDockZone* FChildZones;
  1567.     TDockZone* FNextSibling;
  1568.     TDockOrientation FOrientation;
  1569.     TDockZone* FParentZone;
  1570.     TDockZone* FPrevSibling;
  1571.     TDockTree* FTree;
  1572.     int FZoneLimit;
  1573.     int __fastcall GetChildCount(void);
  1574.     int __fastcall GetLimitBegin(void);
  1575.     int __fastcall GetLimitSize(void);
  1576.     int __fastcall GetTopLeft(int Orient);
  1577.     int __fastcall GetHeightWidth(int Orient);
  1578.     AnsiString __fastcall GetControlName();
  1579.     bool __fastcall SetControlName(const AnsiString Value);
  1580.     
  1581. public:
  1582.     __fastcall TDockZone(TDockTree* Tree);
  1583.     void __fastcall ResetChildren(void);
  1584.     void __fastcall Update(void);
  1585.     __property int ChildCount = {read=GetChildCount, nodefault};
  1586.     __property int Height = {read=GetHeightWidth, index=1, nodefault};
  1587.     __property int Left = {read=GetTopLeft, index=2, nodefault};
  1588.     __property int LimitBegin = {read=GetLimitBegin, nodefault};
  1589.     __property int LimitSize = {read=GetLimitSize, nodefault};
  1590.     __property int Top = {read=GetTopLeft, index=1, nodefault};
  1591.     __property int Width = {read=GetHeightWidth, index=2, nodefault};
  1592. public:
  1593.     #pragma option push -w-inl
  1594.     /* TObject.Destroy */ inline __fastcall virtual ~TDockZone(void) { }
  1595.     #pragma option pop
  1596.     
  1597. };
  1598.  
  1599.  
  1600. typedef TMetaClass*TDockTreeClass;
  1601.  
  1602. class DELPHICLASS TMouse;
  1603. class PASCALIMPLEMENTATION TMouse : public System::TObject 
  1604. {
  1605.     typedef System::TObject inherited;
  1606.     
  1607. private:
  1608.     bool FDragImmediate;
  1609.     int FDragThreshold;
  1610.     bool FMousePresent;
  1611.     bool FNativeWheelSupport;
  1612.     int FScrollLines;
  1613.     unsigned FScrollLinesMessage;
  1614.     HWND FWheelHwnd;
  1615.     unsigned FWheelMessage;
  1616.     bool FWheelPresent;
  1617.     unsigned FWheelSupportMessage;
  1618.     void __fastcall GetMouseData(void);
  1619.     void __fastcall GetNativeData(void);
  1620.     void __fastcall GetRegisteredData(void);
  1621.     Windows::TPoint __fastcall GetCursorPos();
  1622.     void __fastcall SetCursorPos(const Windows::TPoint &Value);
  1623.     HWND __fastcall GetCapture(void);
  1624.     void __fastcall SetCapture(const HWND Value);
  1625.     
  1626. public:
  1627.     __fastcall TMouse(void);
  1628.     __fastcall virtual ~TMouse(void);
  1629.     void __fastcall SettingChanged(int Setting);
  1630.     __property HWND Capture = {read=GetCapture, write=SetCapture, nodefault};
  1631.     __property Windows::TPoint CursorPos = {read=GetCursorPos, write=SetCursorPos};
  1632.     __property bool DragImmediate = {read=FDragImmediate, write=FDragImmediate, default=1};
  1633.     __property int DragThreshold = {read=FDragThreshold, write=FDragThreshold, default=5};
  1634.     __property bool MousePresent = {read=FMousePresent, nodefault};
  1635.     __property unsigned RegWheelMessage = {read=FWheelMessage, nodefault};
  1636.     __property bool WheelPresent = {read=FWheelPresent, nodefault};
  1637.     __property int WheelScrollLines = {read=FScrollLines, nodefault};
  1638. };
  1639.  
  1640.  
  1641. //-- var, const, procedure ---------------------------------------------------
  1642. static const Word CM_BASE = 0xb000;
  1643. static const Word CM_ACTIVATE = 0xb000;
  1644. static const Word CM_DEACTIVATE = 0xb001;
  1645. static const Word CM_GOTFOCUS = 0xb002;
  1646. static const Word CM_LOSTFOCUS = 0xb003;
  1647. static const Word CM_CANCELMODE = 0xb004;
  1648. static const Word CM_DIALOGKEY = 0xb005;
  1649. static const Word CM_DIALOGCHAR = 0xb006;
  1650. static const Word CM_FOCUSCHANGED = 0xb007;
  1651. static const Word CM_PARENTFONTCHANGED = 0xb008;
  1652. static const Word CM_PARENTCOLORCHANGED = 0xb009;
  1653. static const Word CM_HITTEST = 0xb00a;
  1654. static const Word CM_VISIBLECHANGED = 0xb00b;
  1655. static const Word CM_ENABLEDCHANGED = 0xb00c;
  1656. static const Word CM_COLORCHANGED = 0xb00d;
  1657. static const Word CM_FONTCHANGED = 0xb00e;
  1658. static const Word CM_CURSORCHANGED = 0xb00f;
  1659. static const Word CM_CTL3DCHANGED = 0xb010;
  1660. static const Word CM_PARENTCTL3DCHANGED = 0xb011;
  1661. static const Word CM_TEXTCHANGED = 0xb012;
  1662. static const Word CM_MOUSEENTER = 0xb013;
  1663. static const Word CM_MOUSELEAVE = 0xb014;
  1664. static const Word CM_MENUCHANGED = 0xb015;
  1665. static const Word CM_APPKEYDOWN = 0xb016;
  1666. static const Word CM_APPSYSCOMMAND = 0xb017;
  1667. static const Word CM_BUTTONPRESSED = 0xb018;
  1668. static const Word CM_SHOWINGCHANGED = 0xb019;
  1669. static const Word CM_ENTER = 0xb01a;
  1670. static const Word CM_EXIT = 0xb01b;
  1671. static const Word CM_DESIGNHITTEST = 0xb01c;
  1672. static const Word CM_ICONCHANGED = 0xb01d;
  1673. static const Word CM_WANTSPECIALKEY = 0xb01e;
  1674. static const Word CM_INVOKEHELP = 0xb01f;
  1675. static const Word CM_WINDOWHOOK = 0xb020;
  1676. static const Word CM_RELEASE = 0xb021;
  1677. static const Word CM_SHOWHINTCHANGED = 0xb022;
  1678. static const Word CM_PARENTSHOWHINTCHANGED = 0xb023;
  1679. static const Word CM_SYSCOLORCHANGE = 0xb024;
  1680. static const Word CM_WININICHANGE = 0xb025;
  1681. static const Word CM_FONTCHANGE = 0xb026;
  1682. static const Word CM_TIMECHANGE = 0xb027;
  1683. static const Word CM_TABSTOPCHANGED = 0xb028;
  1684. static const Word CM_UIACTIVATE = 0xb029;
  1685. static const Word CM_UIDEACTIVATE = 0xb02a;
  1686. static const Word CM_DOCWINDOWACTIVATE = 0xb02b;
  1687. static const Word CM_CONTROLLISTCHANGE = 0xb02c;
  1688. static const Word CM_GETDATALINK = 0xb02d;
  1689. static const Word CM_CHILDKEY = 0xb02e;
  1690. static const Word CM_DRAG = 0xb02f;
  1691. static const Word CM_HINTSHOW = 0xb030;
  1692. static const Word CM_DIALOGHANDLE = 0xb031;
  1693. static const Word CM_ISTOOLCONTROL = 0xb032;
  1694. static const Word CM_RECREATEWND = 0xb033;
  1695. static const Word CM_INVALIDATE = 0xb034;
  1696. static const Word CM_SYSFONTCHANGED = 0xb035;
  1697. static const Word CM_CONTROLCHANGE = 0xb036;
  1698. static const Word CM_CHANGED = 0xb037;
  1699. static const Word CM_DOCKCLIENT = 0xb038;
  1700. static const Word CM_UNDOCKCLIENT = 0xb039;
  1701. static const Word CM_FLOAT = 0xb03a;
  1702. static const Word CM_BORDERCHANGED = 0xb03b;
  1703. static const Word CM_BIDIMODECHANGED = 0xb03c;
  1704. static const Word CM_PARENTBIDIMODECHANGED = 0xb03d;
  1705. static const Word CM_ALLCHILDRENFLIPPED = 0xb03e;
  1706. static const Word CM_ACTIONUPDATE = 0xb03f;
  1707. static const Word CM_ACTIONEXECUTE = 0xb040;
  1708. static const Word CM_HINTSHOWPAUSE = 0xb041;
  1709. static const Word CM_DOCKNOTIFICATION = 0xb042;
  1710. static const Word CM_MOUSEWHEEL = 0xb043;
  1711. static const Word CN_BASE = 0xbc00;
  1712. static const Word CN_CHARTOITEM = 0xbc2f;
  1713. static const Word CN_COMMAND = 0xbd11;
  1714. static const Word CN_COMPAREITEM = 0xbc39;
  1715. static const Word CN_CTLCOLORBTN = 0xbd35;
  1716. static const Word CN_CTLCOLORDLG = 0xbd36;
  1717. static const Word CN_CTLCOLOREDIT = 0xbd33;
  1718. static const Word CN_CTLCOLORLISTBOX = 0xbd34;
  1719. static const Word CN_CTLCOLORMSGBOX = 0xbd32;
  1720. static const Word CN_CTLCOLORSCROLLBAR = 0xbd37;
  1721. static const Word CN_CTLCOLORSTATIC = 0xbd38;
  1722. static const Word CN_DELETEITEM = 0xbc2d;
  1723. static const Word CN_DRAWITEM = 0xbc2b;
  1724. static const Word CN_HSCROLL = 0xbd14;
  1725. static const Word CN_MEASUREITEM = 0xbc2c;
  1726. static const Word CN_PARENTNOTIFY = 0xbe10;
  1727. static const Word CN_VKEYTOITEM = 0xbc2e;
  1728. static const Word CN_VSCROLL = 0xbd15;
  1729. static const Word CN_KEYDOWN = 0xbd00;
  1730. static const Word CN_KEYUP = 0xbd01;
  1731. static const Word CN_CHAR = 0xbd02;
  1732. static const Word CN_SYSKEYDOWN = 0xbd04;
  1733. static const Word CN_SYSCHAR = 0xbd06;
  1734. static const Word CN_NOTIFY = 0xbc4e;
  1735. static const Shortint mrNone = 0x0;
  1736. static const Shortint mrOk = 0x1;
  1737. static const Shortint mrCancel = 0x2;
  1738. static const Shortint mrAbort = 0x3;
  1739. static const Shortint mrRetry = 0x4;
  1740. static const Shortint mrIgnore = 0x5;
  1741. static const Shortint mrYes = 0x6;
  1742. static const Shortint mrNo = 0x7;
  1743. static const Shortint mrAll = 0x8;
  1744. static const Shortint mrNoToAll = 0x9;
  1745. static const Shortint mrYesToAll = 0xa;
  1746. static const TCursor crDefault = 0x0;
  1747. static const TCursor crNone = 0xffffffff;
  1748. static const TCursor crArrow = 0xfffffffe;
  1749. static const TCursor crCross = 0xfffffffd;
  1750. static const TCursor crIBeam = 0xfffffffc;
  1751. static const TCursor crSize = 0xffffffea;
  1752. static const TCursor crSizeNESW = 0xfffffffa;
  1753. static const TCursor crSizeNS = 0xfffffff9;
  1754. static const TCursor crSizeNWSE = 0xfffffff8;
  1755. static const TCursor crSizeWE = 0xfffffff7;
  1756. static const TCursor crUpArrow = 0xfffffff6;
  1757. static const TCursor crHourGlass = 0xfffffff5;
  1758. static const TCursor crDrag = 0xfffffff4;
  1759. static const TCursor crNoDrop = 0xfffffff3;
  1760. static const TCursor crHSplit = 0xfffffff2;
  1761. static const TCursor crVSplit = 0xfffffff1;
  1762. static const TCursor crMultiDrag = 0xfffffff0;
  1763. static const TCursor crSQLWait = 0xffffffef;
  1764. static const TCursor crNo = 0xffffffee;
  1765. static const TCursor crAppStart = 0xffffffed;
  1766. static const TCursor crHelp = 0xffffffec;
  1767. static const TCursor crHandPoint = 0xffffffeb;
  1768. static const TCursor crSizeAll = 0xffffffea;
  1769. extern PACKAGE TMouse* Mouse;
  1770. extern PACKAGE TWinControl* CreationControl;
  1771. extern PACKAGE TMetaClass*DefaultDockTreeClass;
  1772. static const Word CTL3D_ALL = 0xffff;
  1773. extern const TWinControl* NullDockSite;
  1774. extern PACKAGE TAnchors AnchorAlign[6];
  1775. extern PACKAGE bool NewStyleControls;
  1776. extern PACKAGE void __fastcall ChangeBiDiModeAlignment(Classes::TAlignment &Alignment);
  1777. extern PACKAGE int __stdcall InitWndProc(HWND HWindow, int Message, int WParam, int LParam);
  1778. extern PACKAGE TWinControl* __fastcall FindControl(HWND Handle);
  1779. extern PACKAGE int __fastcall SendAppMessage(unsigned Msg, int WParam, int LParam);
  1780. extern PACKAGE AnsiString __fastcall CursorToString(TCursor Cursor);
  1781. extern PACKAGE TCursor __fastcall StringToCursor(const AnsiString S);
  1782. extern PACKAGE void __fastcall GetCursorValues(Classes::TGetStrProc Proc);
  1783. extern PACKAGE bool __fastcall CursorToIdent(int Cursor, AnsiString &Ident);
  1784. extern PACKAGE bool __fastcall IdentToCursor(const AnsiString Ident, int &Cursor);
  1785. extern PACKAGE AnsiString __fastcall GetShortHint(const AnsiString Hint);
  1786. extern PACKAGE AnsiString __fastcall GetLongHint(const AnsiString Hint);
  1787. extern PACKAGE TControl* __fastcall GetCaptureControl(void);
  1788. extern PACKAGE void __fastcall SetCaptureControl(TControl* Control);
  1789. extern PACKAGE bool __fastcall IsDragObject(System::TObject* Sender);
  1790. extern PACKAGE void __fastcall CancelDrag(void);
  1791. extern PACKAGE TWinControl* __fastcall FindVCLWindow(const Windows::TPoint &Pos);
  1792. extern PACKAGE TControl* __fastcall FindDragTarget(const Windows::TPoint &Pos, bool AllowDisabled);
  1793. extern PACKAGE void __fastcall MoveWindowOrg(HDC DC, int DX, int DY);
  1794. extern PACKAGE bool __fastcall Win32NLSEnableIME(HWND hWnd, bool Enable);
  1795. extern PACKAGE void __fastcall SetImeMode(HWND hWnd, TImeMode Mode);
  1796. extern PACKAGE void __fastcall SetImeName(AnsiString Name);
  1797. extern PACKAGE int __fastcall Imm32GetContext(HWND hWnd);
  1798. extern PACKAGE bool __fastcall Imm32ReleaseContext(HWND hWnd, int hImc);
  1799. extern PACKAGE bool __fastcall Imm32GetConversionStatus(int hImc, unsigned &Conversion, unsigned &Sentence
  1800.     );
  1801. extern PACKAGE bool __fastcall Imm32SetConversionStatus(int hImc, unsigned Conversion, unsigned Sentence
  1802.     );
  1803. extern PACKAGE bool __fastcall Imm32SetOpenStatus(int hImc, bool fOpen);
  1804. extern PACKAGE bool __fastcall Imm32SetCompositionWindow(int hImc, Imm::PCompositionForm lpCompForm)
  1805.     ;
  1806. extern PACKAGE bool __fastcall Imm32SetCompositionFont(int hImc, Windows::PLogFontA lpLogfont);
  1807. extern PACKAGE int __fastcall Imm32GetCompositionString(int hImc, unsigned dWord1, void * lpBuf, unsigned 
  1808.     dwBufLen);
  1809. extern PACKAGE bool __fastcall Imm32IsIME(HKL hKl);
  1810. extern PACKAGE bool __fastcall Imm32NotifyIME(int hImc, unsigned dwAction, unsigned dwIndex, unsigned 
  1811.     dwValue);
  1812.  
  1813. }    /* namespace Controls */
  1814. #if !defined(NO_IMPLICIT_NAMESPACE_USE)
  1815. using namespace Controls;
  1816. #endif
  1817. #pragma option pop    // -w-
  1818. #pragma option pop    // -Vx
  1819.  
  1820. #pragma delphiheader end.
  1821. //-- end unit ----------------------------------------------------------------
  1822. #endif    // Controls
  1823.