home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / BC_502 / MFCEXINC.PAK / CONTROLS.HPP next >
Encoding:
C/C++ Source or Header  |  1997-05-06  |  47.9 KB  |  1,143 lines
  1. //----------------------------------------------------------------------------
  2. // Controls.hpp - bcbdcc32 generated hdr (DO NOT EDIT) rev: 0
  3. // From: Controls.pas
  4. //----------------------------------------------------------------------------
  5. #ifndef ControlsHPP
  6. #define ControlsHPP
  7. //----------------------------------------------------------------------------
  8. #include <Imm.hpp>
  9. #include <CommCtrl.hpp>
  10. #include <Menus.hpp>
  11. #include <Graphics.hpp>
  12. #include <SysUtils.hpp>
  13. #include <Classes.hpp>
  14. #include <Windows.hpp>
  15. #include <Messages.hpp>
  16. #include <System.hpp>
  17. #include <ctl3d.h>
  18.  
  19. #pragma warn -par
  20. #pragma warn -hid 
  21. #pragma warn -inl
  22.  
  23. namespace Controls
  24. {
  25. //-- type declarations -------------------------------------------------------
  26. enum TCursor {crMin=-0x7FFF-1, crMax=0x7FFF};
  27.  
  28. typedef Messages::TWMNoParams  TCMActivate;
  29.  
  30. typedef Messages::TWMNoParams  TCMDeactivate;
  31.  
  32. typedef Messages::TWMNoParams  TCMGotFocus;
  33.  
  34. typedef Messages::TWMNoParams  TCMLostFocus;
  35.  
  36. typedef Messages::TWMKey  TCMDialogKey;
  37.  
  38. typedef Messages::TWMKey  TCMDialogChar;
  39.  
  40. typedef Messages::TWMNCHitTest  TCMHitTest;
  41.  
  42. typedef Messages::TWMNoParams  TCMEnter;
  43.  
  44. typedef Messages::TWMNoParams  TCMExit;
  45.  
  46. typedef Messages::TWMMouse  TCMDesignHitTest;
  47.  
  48. typedef Messages::TWMKey  TCMWantSpecialKey;
  49.  
  50. class __declspec(delphiclass) TControl;
  51. class __declspec(delphiclass) TWinControl;
  52. typedef void __fastcall (__closure *TWndMethod)(Messages::TMessage &Message);
  53.  
  54. enum Controls_7 { csAcceptsControls, csCaptureMouse, csDesignInteractive, csClickEvents, csFramed, csSetCaption, 
  55.     csOpaque, csDoubleClicks, csFixedWidth, csFixedHeight, csNoDesignVisible, csReplicatable, csNoStdEvents, 
  56.     csDisplayDragImage };
  57.  
  58. typedef Set<Controls_7, csAcceptsControls, csDisplayDragImage>  TControlStyle;
  59.  
  60. enum Controls_6 { csLButtonDown, csClicked, csPalette, csReadingState, csAlignmentNeeded, csFocusing, 
  61.     csCreating, csPaintCopy };
  62.  
  63. typedef Set<Controls_6, csLButtonDown, csPaintCopy>  TControlState;
  64.  
  65. enum TAlign { alNone, alTop, alBottom, alLeft, alRight, alClient };
  66.  
  67. enum TDragMode { dmManual, dmAutomatic };
  68.  
  69. enum Controls_8 { sfLeft, sfTop, sfWidth, sfHeight, sfFont };
  70.  
  71. typedef Set<Controls_8, sfLeft, sfFont>  TScalingFlags;
  72.  
  73. enum TMouseButton { mbLeft, mbRight, mbMiddle };
  74.  
  75. typedef void __fastcall (__closure *TMouseEvent)(System::TObject* Sender, TMouseButton Button, Classes::TShiftState 
  76.     Shift, int X, int Y);
  77.  
  78. typedef void __fastcall (__closure *TMouseMoveEvent)(System::TObject* Sender, Classes::TShiftState Shift
  79.     , int X, int Y);
  80.  
  81. typedef void __fastcall (__closure *TDragDropEvent)(System::TObject* Sender, System::TObject* Source
  82.     , int X, int Y);
  83.  
  84. enum TDragState { dsDragEnter, dsDragLeave, dsDragMove };
  85.  
  86. typedef void __fastcall (__closure *TDragOverEvent)(System::TObject* Sender, System::TObject* Source
  87.     , int X, int Y, TDragState State, bool &Accept);
  88.  
  89. class __declspec(delphiclass) TDragObject;
  90. typedef void __fastcall (__closure *TStartDragEvent)(System::TObject* Sender, TDragObject* &DragObject
  91.     );
  92.  
  93. typedef void __fastcall (__closure *TEndDragEvent)(System::TObject* Sender, System::TObject* Target, 
  94.     int X, int Y);
  95.  
  96. struct TCMDrag;
  97. typedef System::AnsiString TCaption;
  98.  
  99. class __declspec(delphiclass) TCustomImageList;
  100. class __declspec(pascalimplementation) TControl : public Classes::TComponent
  101. {
  102.     typedef Classes::TComponent inherited;
  103.     
  104. private:
  105.     TWinControl* FParent;
  106.     TWndMethod FWindowProc;
  107.     int FLeft;
  108.     int FTop;
  109.     int FWidth;
  110.     int FHeight;
  111.     TControlStyle FControlStyle;
  112.     TControlState FControlState;
  113.     bool FVisible;
  114.     bool FEnabled;
  115.     bool FParentFont;
  116.     bool FParentColor;
  117.     TAlign FAlign;
  118.     TDragMode FDragMode;
  119.     bool FIsControl;
  120.     char *FText;
  121.     Graphics::TFont* FFont;
  122.     Graphics::TColor FColor;
  123.     TCursor FCursor;
  124.     TCursor FDragCursor;
  125.     Menus::TPopupMenu* FPopupMenu;
  126.     System::AnsiString FHint;
  127.     int FFontHeight;
  128.     TScalingFlags FScalingFlags;
  129.     bool FShowHint;
  130.     bool FParentShowHint;
  131.     TMouseEvent FOnMouseDown;
  132.     TMouseMoveEvent FOnMouseMove;
  133.     TMouseEvent FOnMouseUp;
  134.     TDragDropEvent FOnDragDrop;
  135.     TDragOverEvent FOnDragOver;
  136.     TStartDragEvent FOnStartDrag;
  137.     TEndDragEvent FOnEndDrag;
  138.     Classes::TNotifyEvent FOnClick;
  139.     Classes::TNotifyEvent FOnDblClick;
  140.     void __fastcall CheckMenuPopup(const Windows::TSmallPoint Pos);
  141.     void __fastcall DoDragMsg(TCMDrag &DragMsg);
  142.     void __fastcall DoMouseDown(Messages::TWMMouse &Message, TMouseButton Button, Classes::TShiftState 
  143.         Shift);
  144.     void __fastcall DoMouseUp(Messages::TWMMouse &Message, TMouseButton Button);
  145.     void __fastcall FontChanged(System::TObject* Sender);
  146.     Windows::TRect __fastcall GetBoundsRect(void);
  147.     int __fastcall GetClientHeight(void);
  148.     int __fastcall GetClientWidth(void);
  149.     bool __fastcall GetMouseCapture(void);
  150.     System::AnsiString __fastcall GetText(void);
  151.     void __fastcall InvalidateControl(bool IsVisible, bool IsOpaque);
  152.     bool __fastcall IsColorStored(void);
  153.     bool __fastcall IsFontStored(void);
  154.     bool __fastcall IsShowHintStored(void);
  155.     void __fastcall ReadIsControl(Classes::TReader* Reader);
  156.     void __fastcall RequestAlign(void);
  157.     void __fastcall SetAlign(TAlign Value);
  158.     void __fastcall SetBoundsRect(const Windows::TRect &Rect);
  159.     void __fastcall SetClientHeight(int Value);
  160.     void __fastcall SetClientSize(const POINT &Value);
  161.     void __fastcall SetClientWidth(int Value);
  162.     void __fastcall SetColor(Graphics::TColor Value);
  163.     void __fastcall SetCursor(TCursor Value);
  164.     void __fastcall SetEnabled(bool Value);
  165.     void __fastcall SetFont(Graphics::TFont* Value);
  166.     void __fastcall SetHeight(int Value);
  167.     void __fastcall SetLeft(int Value);
  168.     void __fastcall SetMouseCapture(bool Value);
  169.     void __fastcall SetParentColor(bool Value);
  170.     void __fastcall SetParentFont(bool Value);
  171.     void __fastcall SetShowHint(bool Value);
  172.     void __fastcall SetParentShowHint(bool Value);
  173.     void __fastcall SetPopupMenu(Menus::TPopupMenu* Value);
  174.     void __fastcall SetText(const System::AnsiString Value);
  175.     void __fastcall SetTop(int Value);
  176.     void __fastcall SetVisible(bool Value);
  177.     void __fastcall SetWidth(int Value);
  178.     void __fastcall SetZOrderPosition(int Position);
  179.     void __fastcall WriteIsControl(Classes::TWriter* Writer);
  180.     MESSAGE void __fastcall WMLButtonDown(Messages::TWMMouse &Message);
  181.     MESSAGE void __fastcall WMNCLButtonDown(Messages::TWMNCHitMessage &Message);
  182.     MESSAGE void __fastcall WMRButtonDown(Messages::TWMMouse &Message);
  183.     MESSAGE void __fastcall WMMButtonDown(Messages::TWMMouse &Message);
  184.     MESSAGE void __fastcall WMLButtonDblClk(Messages::TWMMouse &Message);
  185.     MESSAGE void __fastcall WMRButtonDblClk(Messages::TWMMouse &Message);
  186.     MESSAGE void __fastcall WMMButtonDblClk(Messages::TWMMouse &Message);
  187.     MESSAGE void __fastcall WMMouseMove(Messages::TWMMouse &Message);
  188.     MESSAGE void __fastcall WMLButtonUp(Messages::TWMMouse &Message);
  189.     MESSAGE void __fastcall WMRButtonUp(Messages::TWMMouse &Message);
  190.     MESSAGE void __fastcall WMMButtonUp(Messages::TWMMouse &Message);
  191.     MESSAGE void __fastcall WMCancelMode(Messages::TWMNoParams &Message);
  192.     MESSAGE void __fastcall CMVisibleChanged(Messages::TMessage &Message);
  193.     MESSAGE void __fastcall CMEnabledChanged(Messages::TMessage &Message);
  194.     MESSAGE void __fastcall CMFontChanged(Messages::TMessage &Message);
  195.     MESSAGE void __fastcall CMColorChanged(Messages::TMessage &Message);
  196.     MESSAGE void __fastcall CMParentFontChanged(Messages::TMessage &Message);
  197.     MESSAGE void __fastcall CMParentColorChanged(Messages::TMessage &Message);
  198.     MESSAGE void __fastcall CMParentShowHintChanged(Messages::TMessage &Message);
  199.     MESSAGE void __fastcall CMHitTest(Messages::TWMNCHitTest &Message);
  200.     MESSAGE void __fastcall CMMouseEnter(Messages::TMessage &Message);
  201.     MESSAGE void __fastcall CMMouseLeave(Messages::TMessage &Message);
  202.     MESSAGE void __fastcall CMDesignHitTest(Messages::TWMMouse &Message);
  203.     
  204. protected:
  205.     virtual void __fastcall ChangeScale(int M, int D);
  206.     virtual void __fastcall Click(void);
  207.     virtual void __fastcall DblClick(void);
  208.     virtual void __fastcall DefaultHandler(void *Message);
  209.     virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
  210.     virtual void __fastcall DragCanceled(void);
  211.     virtual void __fastcall DragOver(System::TObject* Source, int X, int Y, TDragState State, bool &Accept
  212.         );
  213.     virtual void __fastcall DoEndDrag(System::TObject* Target, int X, int Y);
  214.     virtual void __fastcall DoStartDrag(TDragObject* &DragObject);
  215.     virtual POINT __fastcall GetClientOrigin(void);
  216.     virtual Windows::TRect __fastcall GetClientRect(void);
  217.     virtual HDC __fastcall GetDeviceContext(HWND &WindowHandle);
  218.     virtual TCustomImageList* __fastcall GetDragImages(void);
  219.     virtual HPALETTE __fastcall GetPalette(void);
  220.     virtual Classes::TComponent* __fastcall GetParentComponent(void);
  221.     virtual Menus::TPopupMenu* __fastcall GetPopupMenu(void);
  222.     virtual bool __fastcall HasParent(void);
  223.     virtual void __fastcall MouseDown(TMouseButton Button, Classes::TShiftState Shift, int X, int Y);
  224.     virtual void __fastcall MouseMove(Classes::TShiftState Shift, int X, int Y);
  225.     virtual void __fastcall MouseUp(TMouseButton Button, Classes::TShiftState Shift, int X, int Y);
  226.     virtual void __fastcall Notification(Classes::TComponent* AComponent, Classes::TOperation Operation
  227.         );
  228.     virtual bool __fastcall PaletteChanged(bool Foreground);
  229.     virtual void __fastcall ReadState(Classes::TReader* Reader);
  230.     void __fastcall SendCancelMode(TControl* Sender);
  231.     virtual void __fastcall SetDragMode(TDragMode Value);
  232.     virtual void __fastcall SetParent(TWinControl* AParent);
  233.     virtual void __fastcall SetParentComponent(Classes::TComponent* Value);
  234.     virtual void __fastcall SetName(const System::AnsiString Value);
  235.     virtual void __fastcall SetZOrder(bool TopMost);
  236.     void __fastcall UpdateBoundsRect(const Windows::TRect &R);
  237.     virtual void __fastcall VisibleChanging(void);
  238.     virtual void __fastcall WndProc(Messages::TMessage &Message);
  239.     __property System::AnsiString Caption = {read=GetText, write=SetText, nodefault};
  240.     __property Graphics::TColor Color = {read=FColor, write=SetColor, stored=IsColorStored, default=-2147483643
  241.         };
  242.     __property TCursor DragCursor = {read=FDragCursor, write=FDragCursor, default=-12};
  243.     __property TDragMode DragMode = {read=FDragMode, write=SetDragMode, default=0};
  244.     __property Graphics::TFont* Font = {read=FFont, write=SetFont, stored=IsFontStored, nodefault};
  245.     __property bool IsControl = {read=FIsControl, write=FIsControl, nodefault};
  246.     __property bool MouseCapture = {read=GetMouseCapture, write=SetMouseCapture, nodefault};
  247.     __property bool ParentColor = {read=FParentColor, write=SetParentColor, default=1};
  248.     __property bool ParentFont = {read=FParentFont, write=SetParentFont, default=1};
  249.     __property bool ParentShowHint = {read=FParentShowHint, write=SetParentShowHint, default=1};
  250.     __property Menus::TPopupMenu* PopupMenu = {read=FPopupMenu, write=SetPopupMenu, nodefault};
  251.     __property TScalingFlags ScalingFlags = {read=FScalingFlags, write=FScalingFlags, nodefault};
  252.     __property System::AnsiString Text = {read=GetText, write=SetText, nodefault};
  253.     __property char * WindowText = {read=FText, write=FText, nodefault};
  254.     __property Classes::TNotifyEvent OnClick = {read=FOnClick, write=FOnClick};
  255.     __property Classes::TNotifyEvent OnDblClick = {read=FOnDblClick, write=FOnDblClick};
  256.     __property TDragDropEvent OnDragDrop = {read=FOnDragDrop, write=FOnDragDrop};
  257.     __property TDragOverEvent OnDragOver = {read=FOnDragOver, write=FOnDragOver};
  258.     __property TEndDragEvent OnEndDrag = {read=FOnEndDrag, write=FOnEndDrag};
  259.     __property TMouseEvent OnMouseDown = {read=FOnMouseDown, write=FOnMouseDown};
  260.     __property TMouseMoveEvent OnMouseMove = {read=FOnMouseMove, write=FOnMouseMove};
  261.     __property TMouseEvent OnMouseUp = {read=FOnMouseUp, write=FOnMouseUp};
  262.     __property TStartDragEvent OnStartDrag = {read=FOnStartDrag, write=FOnStartDrag};
  263.     
  264. public:
  265.     __fastcall virtual TControl(Classes::TComponent* AOwner);
  266.     __fastcall virtual ~TControl(void);
  267.     void __fastcall BeginDrag(bool Immediate);
  268.     void __fastcall BringToFront(void);
  269.     POINT __fastcall ClientToScreen(const POINT &Point);
  270.     bool __fastcall Dragging(void);
  271.     virtual void __fastcall DragDrop(System::TObject* Source, int X, int Y);
  272.     void __fastcall EndDrag(bool Drop);
  273.     int __fastcall GetTextBuf(char * Buffer, int BufSize);
  274.     int __fastcall GetTextLen(void);
  275.     void __fastcall Hide(void);
  276.     virtual void __fastcall Invalidate(void);
  277.     long __fastcall Perform(Cardinal Msg, long WParam, long LParam);
  278.     void __fastcall Refresh(void);
  279.     virtual void __fastcall Repaint(void);
  280.     POINT __fastcall ScreenToClient(const POINT &Point);
  281.     void __fastcall SendToBack(void);
  282.     virtual void __fastcall SetBounds(int ALeft, int ATop, int AWidth, int AHeight);
  283.     void __fastcall SetTextBuf(char * Buffer);
  284.     void __fastcall Show(void);
  285.     virtual void __fastcall Update(void);
  286.     __property TAlign Align = {read=FAlign, write=SetAlign, default=0};
  287.     __property Windows::TRect BoundsRect = {read=GetBoundsRect, write=SetBoundsRect};
  288.     __property int ClientHeight = {read=GetClientHeight, write=SetClientHeight, stored=false, nodefault
  289.         };
  290.     __property POINT ClientOrigin = {read=GetClientOrigin};
  291.     __property Windows::TRect ClientRect = {read=GetClientRect};
  292.     __property int ClientWidth = {read=GetClientWidth, write=SetClientWidth, stored=false, nodefault};
  293.     __property TControlState ControlState = {read=FControlState, write=FControlState, nodefault};
  294.     __property TControlStyle ControlStyle = {read=FControlStyle, write=FControlStyle, nodefault};
  295.     __property TWinControl* Parent = {read=FParent, write=SetParent, nodefault};
  296.     __property bool ShowHint = {read=FShowHint, write=SetShowHint, stored=IsShowHintStored, nodefault};
  297.         
  298.     __property bool Visible = {read=FVisible, write=SetVisible, default=1};
  299.     __property bool Enabled = {read=FEnabled, write=SetEnabled, default=1};
  300.     __property TWndMethod WindowProc = {read=FWindowProc, write=FWindowProc};
  301.     
  302. __published:
  303.     __property int Left = {read=FLeft, write=SetLeft, nodefault};
  304.     __property int Top = {read=FTop, write=SetTop, nodefault};
  305.     __property int Width = {read=FWidth, write=SetWidth, nodefault};
  306.     __property int Height = {read=FHeight, write=SetHeight, nodefault};
  307.     __property TCursor Cursor = {read=FCursor, write=SetCursor, default=0};
  308.     __property System::AnsiString Hint = {read=FHint, write=FHint, nodefault};
  309. };
  310.  
  311. enum TImeMode { imDisable, imClose, imOpen, imDontCare, imSAlpha, imAlpha, imHira, imSKata, imKata, 
  312.     imChinese, imSHanguel, imHanguel };
  313.  
  314. typedef System::AnsiString TImeName;
  315.  
  316. typedef void __fastcall (__closure *TKeyEvent)(System::TObject* Sender, Word &Key, Classes::TShiftState 
  317.     Shift);
  318.  
  319. typedef void __fastcall (__closure *TKeyPressEvent)(System::TObject* Sender, char &Key);
  320.  
  321. typedef short TTabOrder;
  322.  
  323. struct TCMFocusChanged;
  324. struct TCreateParams;
  325. class __declspec(pascalimplementation) TWinControl : public TControl
  326. {
  327.     typedef TControl inherited;
  328.     
  329. private:
  330.     void *FObjectInstance;
  331.     void *FDefWndProc;
  332.     Classes::TList* FControls;
  333.     Classes::TList* FWinControls;
  334.     Classes::TList* FTabList;
  335.     Graphics::TBrush* FBrush;
  336.     HWND FHandle;
  337.     HWND FParentWindow;
  338.     bool FTabStop;
  339.     bool FCtl3D;
  340.     bool FParentCtl3D;
  341.     bool FShowing;
  342.     int FTabOrder;
  343.     Word FAlignLevel;
  344.     Classes::THelpContext FHelpContext;
  345.     TImeMode FImeMode;
  346.     System::AnsiString FImeName;
  347.     TKeyEvent FOnKeyDown;
  348.     TKeyPressEvent FOnKeyPress;
  349.     TKeyEvent FOnKeyUp;
  350.     Classes::TNotifyEvent FOnEnter;
  351.     Classes::TNotifyEvent FOnExit;
  352.     void __fastcall AlignControl(TControl* AControl);
  353.     TControl* __fastcall GetControl(int Index);
  354.     int __fastcall GetControlCount(void);
  355.     HWND __fastcall GetHandle(void);
  356.     TTabOrder __fastcall GetTabOrder(void);
  357.     HIDESBASE void __fastcall Insert(TControl* AControl);
  358.     void __fastcall InvalidateFrame(void);
  359.     bool __fastcall IsCtl3DStored(void);
  360.     HWND __fastcall PrecedingWindow(TWinControl* Control);
  361.     HIDESBASE void __fastcall Remove(TControl* AControl);
  362.     void __fastcall RemoveFocus(bool Removing);
  363.     void __fastcall SetCtl3D(bool Value);
  364.     void __fastcall SetParentCtl3D(bool Value);
  365.     void __fastcall SetParentWindow(HWND Value);
  366.     void __fastcall SetTabOrder(TTabOrder Value);
  367.     void __fastcall SetTabStop(bool Value);
  368.     HIDESBASE void __fastcall SetZOrderPosition(int Position);
  369.     void __fastcall UpdateTabOrder(TTabOrder Value);
  370.     void __fastcall UpdateBounds(void);
  371.     void __fastcall UpdateShowing(void);
  372.     bool __fastcall IsMenuKey(Messages::TWMKey &Message);
  373.     MESSAGE void __fastcall WMPaint(Messages::TWMPaint &Message);
  374.     MESSAGE void __fastcall WMCommand(Messages::TWMCommand &Message);
  375.     MESSAGE void __fastcall WMNotify(Messages::TWMNotify &Message);
  376.     MESSAGE void __fastcall WMSysColorChange(Messages::TWMNoParams &Message);
  377.     MESSAGE void __fastcall WMHScroll(Messages::TWMScroll &Message);
  378.     MESSAGE void __fastcall WMVScroll(Messages::TWMScroll &Message);
  379.     MESSAGE void __fastcall WMCompareItem(Messages::TWMCompareItem &Message);
  380.     MESSAGE void __fastcall WMDeleteItem(Messages::TWMDeleteItem &Message);
  381.     MESSAGE void __fastcall WMDrawItem(Messages::TWMDrawItem &Message);
  382.     MESSAGE void __fastcall WMMeasureItem(Messages::TWMMeasureItem &Message);
  383.     MESSAGE void __fastcall WMEraseBkgnd(Messages::TWMEraseBkgnd &Message);
  384.     MESSAGE void __fastcall WMWindowPosChanged(Messages::TWMWindowPosMsg &Message);
  385.     MESSAGE void __fastcall WMSize(Messages::TWMSize &Message);
  386.     MESSAGE void __fastcall WMMove(Messages::TWMMove &Message);
  387.     MESSAGE void __fastcall WMSetCursor(Messages::TWMSetCursor &Message);
  388.     MESSAGE void __fastcall WMKeyDown(Messages::TWMKey &Message);
  389.     MESSAGE void __fastcall WMSysKeyDown(Messages::TWMKey &Message);
  390.     MESSAGE void __fastcall WMKeyUp(Messages::TWMKey &Message);
  391.     MESSAGE void __fastcall WMSysKeyUp(Messages::TWMKey &Message);
  392.     MESSAGE void __fastcall WMChar(Messages::TWMKey &Message);
  393.     MESSAGE void __fastcall WMSysCommand(Messages::TWMSysCommand &Message);
  394.     MESSAGE void __fastcall WMCharToItem(Messages::TWMCharToItem &Message);
  395.     MESSAGE void __fastcall WMParentNotify(Messages::TWMParentNotify &Message);
  396.     MESSAGE void __fastcall WMVKeyToItem(Messages::TWMCharToItem &Message);
  397.     MESSAGE void __fastcall WMDestroy(Messages::TWMNoParams &Message);
  398.     MESSAGE void __fastcall WMNCDestroy(Messages::TWMNoParams &Message);
  399.     MESSAGE void __fastcall WMNCHitTest(Messages::TWMNCHitTest &Message);
  400.     MESSAGE void __fastcall WMQueryNewPalette(Messages::TMessage &Message);
  401.     MESSAGE void __fastcall WMPaletteChanged(Messages::TMessage &Message);
  402.     MESSAGE void __fastcall WMWinIniChange(Messages::TMessage &Message);
  403.     MESSAGE void __fastcall WMFontChange(Messages::TMessage &Message);
  404.     MESSAGE void __fastcall WMTimeChange(Messages::TMessage &Message);
  405.     MESSAGE void __fastcall WMSetFocus(Messages::TWMSetFocus &Message);
  406.     MESSAGE void __fastcall WMKillFocus(Messages::TWMSetFocus &Message);
  407.     MESSAGE void __fastcall WMIMEStartComp(Messages::TMessage &Message);
  408.     MESSAGE void __fastcall WMIMEEndComp(Messages::TMessage &Message);
  409.     MESSAGE void __fastcall CMChildKey(Messages::TMessage &Message);
  410.     MESSAGE void __fastcall CMDialogKey(Messages::TWMKey &Message);
  411.     MESSAGE void __fastcall CMDialogChar(Messages::TWMKey &Message);
  412.     MESSAGE void __fastcall CMFocusChanged(TCMFocusChanged &Message);
  413.     HIDESBASE MESSAGE void __fastcall CMVisibleChanged(Messages::TMessage &Message);
  414.     HIDESBASE MESSAGE void __fastcall CMEnabledChanged(Messages::TMessage &Message);
  415.     HIDESBASE MESSAGE void __fastcall CMColorChanged(Messages::TMessage &Message);
  416.     HIDESBASE MESSAGE void __fastcall CMFontChanged(Messages::TMessage &Message);
  417.     MESSAGE void __fastcall CMCursorChanged(Messages::TMessage &Message);
  418.     MESSAGE void __fastcall CMCtl3DChanged(Messages::TMessage &Message);
  419.     MESSAGE void __fastcall CMParentCtl3DChanged(Messages::TMessage &Message);
  420.     MESSAGE void __fastcall CMShowingChanged(Messages::TMessage &Message);
  421.     MESSAGE void __fastcall CMShowHintChanged(Messages::TMessage &Message);
  422.     MESSAGE void __fastcall CMEnter(Messages::TWMNoParams &Message);
  423.     MESSAGE void __fastcall CMExit(Messages::TWMNoParams &Message);
  424.     HIDESBASE MESSAGE void __fastcall CMDesignHitTest(Messages::TWMMouse &Message);
  425.     MESSAGE void __fastcall CMSysColorChange(Messages::TMessage &Message);
  426.     MESSAGE void __fastcall CMWinIniChange(Messages::TWMWinIniChange &Message);
  427.     MESSAGE void __fastcall CMFontChange(Messages::TMessage &Message);
  428.     MESSAGE void __fastcall CMTimeChange(Messages::TMessage &Message);
  429.     MESSAGE void __fastcall CMDrag(TCMDrag &Message);
  430.     MESSAGE void __fastcall CNKeyDown(Messages::TWMKey &Message);
  431.     MESSAGE void __fastcall CNKeyUp(Messages::TWMKey &Message);
  432.     MESSAGE void __fastcall CNChar(Messages::TWMKey &Message);
  433.     MESSAGE void __fastcall CNSysKeyDown(Messages::TWMKey &Message);
  434.     MESSAGE void __fastcall CNSysChar(Messages::TWMKey &Message);
  435.     MESSAGE void __fastcall CMControlListChange(Messages::TMessage &Message);
  436.     MESSAGE void __fastcall CMRecreateWnd(Messages::TMessage &Message);
  437.     MESSAGE void __fastcall CMInvalidate(Messages::TMessage &Message);
  438.     
  439. protected:
  440.     bool FInImeComposition;
  441.     virtual void __fastcall AlignControls(TControl* AControl, Windows::TRect &Rect);
  442.     virtual void __fastcall ChangeScale(int M, int D);
  443.     virtual void __fastcall CreateHandle(void);
  444.     virtual void __fastcall CreateParams(TCreateParams &Params);
  445.     void __fastcall CreateSubClass(TCreateParams &Params, char * ControlClassName);
  446.     virtual void __fastcall CreateWindowHandle(const TCreateParams &Params);
  447.     virtual void __fastcall CreateWnd(void);
  448.     virtual void __fastcall DefaultHandler(void *Message);
  449.     void __fastcall DestroyHandle(void);
  450.     virtual void __fastcall DestroyWindowHandle(void);
  451.     virtual void __fastcall DestroyWnd(void);
  452.     virtual void __fastcall DoEnter(void);
  453.     virtual void __fastcall DoExit(void);
  454.     bool __fastcall DoKeyDown(Messages::TWMKey &Message);
  455.     bool __fastcall DoKeyPress(Messages::TWMKey &Message);
  456.     bool __fastcall DoKeyUp(Messages::TWMKey &Message);
  457.     TWinControl* __fastcall FindNextControl(TWinControl* CurControl, bool GoForward, bool CheckTabStop, 
  458.         bool CheckParent);
  459.     void __fastcall FixupTabList(void);
  460.     virtual void __fastcall GetChildren(Classes::TGetChildProc Proc);
  461.     virtual POINT __fastcall GetClientOrigin(void);
  462.     virtual Windows::TRect __fastcall GetClientRect(void);
  463.     virtual HDC __fastcall GetDeviceContext(HWND &WindowHandle);
  464.     bool __fastcall IsControlMouseMsg(Messages::TWMMouse &Message);
  465.     virtual void __fastcall KeyDown(Word &Key, Classes::TShiftState Shift);
  466.     virtual void __fastcall KeyUp(Word &Key, Classes::TShiftState Shift);
  467.     virtual void __fastcall KeyPress(char &Key);
  468.     void __fastcall MainWndProc(Messages::TMessage &Message);
  469.     void __fastcall NotifyControls(Word Msg);
  470.     void __fastcall PaintControls(HDC DC, TControl* First);
  471.     void __fastcall PaintHandler(Messages::TWMPaint &Message);
  472.     virtual void __fastcall PaintWindow(HDC DC);
  473.     virtual bool __fastcall PaletteChanged(bool Foreground);
  474.     virtual void __fastcall ReadState(Classes::TReader* Reader);
  475.     void __fastcall RecreateWnd(void);
  476.     void __fastcall ResetIme(void);
  477.     bool __fastcall ResetImeComposition(int Action);
  478.     void __fastcall ScaleControls(int M, int D);
  479.     void __fastcall SelectFirst(void);
  480.     void __fastcall SelectNext(TWinControl* CurControl, bool GoForward, bool CheckTabStop);
  481.     virtual void __fastcall SetChildOrder(Classes::TComponent* Child, int Order);
  482.     void __fastcall SetIme(void);
  483.     bool __fastcall SetImeCompositionWindow(HWND hWnd, Graphics::TFont* Font, int XPos, int YPos);
  484.     virtual void __fastcall SetZOrder(bool TopMost);
  485.     virtual void __fastcall ShowControl(TControl* AControl);
  486.     virtual void __fastcall WndProc(Messages::TMessage &Message);
  487.     __property bool Ctl3D = {read=FCtl3D, write=SetCtl3D, stored=IsCtl3DStored, nodefault};
  488.     __property void * DefWndProc = {read=FDefWndProc, write=FDefWndProc, nodefault};
  489.     __property TImeMode ImeMode = {read=FImeMode, write=FImeMode, default=3};
  490.     __property System::AnsiString ImeName = {read=FImeName, write=FImeName, nodefault};
  491.     __property bool ParentCtl3D = {read=FParentCtl3D, write=SetParentCtl3D, default=1};
  492.     __property HWND WindowHandle = {read=FHandle, write=FHandle, nodefault};
  493.     __property Classes::TNotifyEvent OnEnter = {read=FOnEnter, write=FOnEnter};
  494.     __property Classes::TNotifyEvent OnExit = {read=FOnExit, write=FOnExit};
  495.     __property TKeyEvent OnKeyDown = {read=FOnKeyDown, write=FOnKeyDown};
  496.     __property TKeyPressEvent OnKeyPress = {read=FOnKeyPress, write=FOnKeyPress};
  497.     __property TKeyEvent OnKeyUp = {read=FOnKeyUp, write=FOnKeyUp};
  498.     
  499. public:
  500.     __fastcall virtual TWinControl(Classes::TComponent* AOwner);
  501.     __fastcall TWinControl(HWND ParentWindow);
  502.     __fastcall virtual ~TWinControl(void);
  503.     void __fastcall Broadcast(void *Message);
  504.     bool __fastcall CanFocus(void);
  505.     bool __fastcall ContainsControl(TControl* Control);
  506.     TControl* __fastcall ControlAtPos(const POINT &Pos, bool AllowDisabled);
  507.     void __fastcall DisableAlign(void);
  508.     void __fastcall EnableAlign(void);
  509.     bool __fastcall Focused(void);
  510.     virtual void __fastcall GetTabOrderList(Classes::TList* List);
  511.     bool __fastcall HandleAllocated(void);
  512.     void __fastcall HandleNeeded(void);
  513.     void __fastcall InsertControl(TControl* AControl);
  514.     virtual void __fastcall Invalidate(void);
  515.     void __fastcall PaintTo(HDC DC, int X, int Y);
  516.     void __fastcall RemoveControl(TControl* AControl);
  517.     void __fastcall Realign(void);
  518.     virtual void __fastcall Repaint(void);
  519.     void __fastcall ScaleBy(int M, int D);
  520.     void __fastcall ScrollBy(int DeltaX, int DeltaY);
  521.     virtual void __fastcall SetBounds(int ALeft, int ATop, int AWidth, int AHeight);
  522.     virtual void __fastcall SetFocus(void);
  523.     virtual void __fastcall Update(void);
  524.     void __fastcall UpdateControlState(void);
  525.     __property Graphics::TBrush* Brush = {read=FBrush, nodefault};
  526.     __property TControl* Controls[int Index] = {read=GetControl};
  527.     __property int ControlCount = {read=GetControlCount, nodefault};
  528.     __property HWND Handle = {read=GetHandle, nodefault};
  529.     __property HWND ParentWindow = {read=FParentWindow, write=SetParentWindow, nodefault};
  530.     __property bool Showing = {read=FShowing, nodefault};
  531.     __property TTabOrder TabOrder = {read=GetTabOrder, write=SetTabOrder, default=-1};
  532.     __property bool TabStop = {read=FTabStop, write=SetTabStop, default=0};
  533.     
  534. __published:
  535.     __property Classes::THelpContext HelpContext = {read=FHelpContext, write=FHelpContext, default=0};
  536. };
  537.  
  538. struct TCMCancelMode
  539. {
  540.     Cardinal Msg;
  541.     int Unused;
  542.     TControl* Sender;
  543.     long Result;
  544. } ;
  545.  
  546. struct TCMFocusChanged
  547. {
  548.     Cardinal Msg;
  549.     int Unused;
  550.     TWinControl* Sender;
  551.     long Result;
  552. } ;
  553.  
  554. struct TCMControlListChange
  555. {
  556.     Cardinal Msg;
  557.     TControl* Control;
  558.     DWord Inserting;
  559.     long Result;
  560. } ;
  561.  
  562. struct TCMChildKey
  563. {
  564.     Cardinal Msg;
  565.     Word CharCode;
  566.     Word Unused;
  567.     TWinControl* Sender;
  568.     long Result;
  569. } ;
  570.  
  571. enum TDragMessage { dmDragEnter, dmDragLeave, dmDragMove, dmDragDrop, dmDragCancel, dmFindTarget };
  572.  
  573. struct TDragRec;
  574. typedef TDragRec *PDragRec;
  575.  
  576. struct TDragRec
  577. {
  578.     POINT Pos;
  579.     TDragObject* Source;
  580.     void *Target;
  581. } ;
  582.  
  583. #pragma pack(push, 1)
  584. struct TCMDrag
  585. {
  586.     Cardinal Msg;
  587.     TDragMessage DragMessage;
  588.     Byte Reserved1;
  589.     Word Reserved2;
  590.     TDragRec *DragRec;
  591.     long Result;
  592. } ;
  593. #pragma pack(pop)
  594.  
  595. class __declspec(delphiclass) EOutOfResources;
  596. class __declspec(pascalimplementation) EOutOfResources : public Sysutils::EOutOfMemory
  597. {
  598.     typedef Sysutils::EOutOfMemory inherited;
  599.     
  600. public:
  601.     /* EOutOfMemory.Destroy */ __fastcall virtual ~EOutOfResources(void) { }
  602.     
  603. public:
  604.     /* Exception.Create */ __fastcall EOutOfResources(const System::AnsiString Msg) : Sysutils::EOutOfMemory(
  605.         Msg) { }
  606.     /* Exception.CreateFmt */ __fastcall EOutOfResources(const System::AnsiString Msg, const System::TVarRec 
  607.         * Args, const int Args_Size) : Sysutils::EOutOfMemory(Msg, Args, Args_Size) { }
  608.     /* Exception.CreateRes */ __fastcall EOutOfResources(int Ident) : Sysutils::EOutOfMemory(Ident) { }
  609.         
  610.     /* Exception.CreateResFmt */ __fastcall EOutOfResources(int Ident, const System::TVarRec * Args, const 
  611.         int Args_Size) : Sysutils::EOutOfMemory(Ident, Args, Args_Size) { }
  612.     /* Exception.CreateHelp */ __fastcall EOutOfResources(const System::AnsiString Msg, int AHelpContext
  613.         ) : Sysutils::EOutOfMemory(Msg, AHelpContext) { }
  614.     /* Exception.CreateFmtHelp */ __fastcall EOutOfResources(const System::AnsiString Msg, const System::TVarRec 
  615.         * Args, const int Args_Size, int AHelpContext) : Sysutils::EOutOfMemory(Msg, Args, Args_Size, AHelpContext
  616.         ) { }
  617.     /* Exception.CreateResHelp */ __fastcall EOutOfResources(int Ident, int AHelpContext) : Sysutils::EOutOfMemory(
  618.         Ident, AHelpContext) { }
  619.     /* Exception.CreateResFmtHelp */ __fastcall EOutOfResources(int Ident, const System::TVarRec * Args
  620.         , const int Args_Size, int AHelpContext) : Sysutils::EOutOfMemory(Ident, Args, Args_Size, AHelpContext
  621.         ) { }
  622.     
  623. };
  624.  
  625. class __declspec(delphiclass) EInvalidOperation;
  626. class __declspec(pascalimplementation) EInvalidOperation : public Sysutils::Exception
  627. {
  628.     typedef Sysutils::Exception inherited;
  629.     
  630. public:
  631.     /* Exception.Create */ __fastcall EInvalidOperation(const System::AnsiString Msg) : Sysutils::Exception(
  632.         Msg) { }
  633.     /* Exception.CreateFmt */ __fastcall EInvalidOperation(const System::AnsiString Msg, const System::TVarRec 
  634.         * Args, const int Args_Size) : Sysutils::Exception(Msg, Args, Args_Size) { }
  635.     /* Exception.CreateRes */ __fastcall EInvalidOperation(int Ident) : Sysutils::Exception(Ident) { }
  636.     /* Exception.CreateResFmt */ __fastcall EInvalidOperation(int Ident, const System::TVarRec * Args, 
  637.         const int Args_Size) : Sysutils::Exception(Ident, Args, Args_Size) { }
  638.     /* Exception.CreateHelp */ __fastcall EInvalidOperation(const System::AnsiString Msg, int AHelpContext
  639.         ) : Sysutils::Exception(Msg, AHelpContext) { }
  640.     /* Exception.CreateFmtHelp */ __fastcall EInvalidOperation(const System::AnsiString Msg, const System::TVarRec 
  641.         * Args, const int Args_Size, int AHelpContext) : Sysutils::Exception(Msg, Args, Args_Size, AHelpContext
  642.         ) { }
  643.     /* Exception.CreateResHelp */ __fastcall EInvalidOperation(int Ident, int AHelpContext) : Sysutils::
  644.         Exception(Ident, AHelpContext) { }
  645.     /* Exception.CreateResFmtHelp */ __fastcall EInvalidOperation(int Ident, const System::TVarRec * Args
  646.         , const int Args_Size, int AHelpContext) : Sysutils::Exception(Ident, Args, Args_Size, AHelpContext
  647.         ) { }
  648.     
  649. public:
  650.     /* TObject.Destroy */ __fastcall virtual ~EInvalidOperation(void) { }
  651.     
  652. };
  653.  
  654. class __declspec(pascalimplementation) TDragObject : public System::TObject
  655. {
  656.     typedef System::TObject inherited;
  657.     
  658. private:
  659.     void __fastcall MouseMsg(Messages::TMessage &Msg);
  660.     HWND __fastcall Capture(void);
  661.     void __fastcall ReleaseCapture(HWND Handle);
  662.     
  663. protected:
  664.     virtual TCustomImageList* __fastcall GetDragImages(void);
  665.     virtual TCursor __fastcall GetDragCursor(bool Accepted, int X, int Y);
  666.     virtual void __fastcall Finished(System::TObject* Target, int X, int Y, bool Accepted);
  667.     
  668. public:
  669.     virtual int __fastcall Instance(void);
  670.     virtual System::AnsiString __fastcall GetName(void);
  671.     virtual void __fastcall HideDragImage(void);
  672.     virtual void __fastcall ShowDragImage(void);
  673. public:
  674.     /* TObject.Create */ __fastcall TDragObject(void) : System::TObject() { }
  675.     /* TObject.Destroy */ __fastcall virtual ~TDragObject(void) { }
  676.     
  677. };
  678.  
  679. class __declspec(delphiclass) TDragControlObject;
  680. class __declspec(pascalimplementation) TDragControlObject : public TDragObject
  681. {
  682.     typedef TDragObject inherited;
  683.     
  684. private:
  685.     TControl* FControl;
  686.     
  687. public:
  688.     virtual TCustomImageList* __fastcall GetDragImages(void);
  689.     virtual TCursor __fastcall GetDragCursor(bool Accepted, int X, int Y);
  690.     virtual void __fastcall Finished(System::TObject* Target, int X, int Y, bool Accepted);
  691.     
  692. protected:
  693.     __fastcall TDragControlObject(TControl* AControl);
  694.     __property TControl* Control = {read=FControl, nodefault};
  695.     virtual void __fastcall HideDragImage(void);
  696.     virtual void __fastcall ShowDragImage(void);
  697. public:
  698.     /* TObject.Destroy */ __fastcall virtual ~TDragControlObject(void) { }
  699.     
  700. };
  701.  
  702. class __declspec(delphiclass) TControlCanvas;
  703. class __declspec(pascalimplementation) TControlCanvas : public Graphics::TCanvas
  704. {
  705.     typedef Graphics::TCanvas inherited;
  706.     
  707. private:
  708.     TControl* FControl;
  709.     HDC FDeviceContext;
  710.     HWND FWindowHandle;
  711.     void __fastcall SetControl(TControl* AControl);
  712.     
  713. protected:
  714.     virtual void __fastcall CreateHandle(void);
  715.     
  716. public:
  717.     __fastcall virtual ~TControlCanvas(void);
  718.     void __fastcall FreeHandle(void);
  719.     __property TControl* Control = {read=FControl, write=SetControl, nodefault};
  720. public:
  721.     /* TCanvas.Create */ __fastcall TControlCanvas(void) : Graphics::TCanvas() { }
  722.     
  723. };
  724.  
  725. typedef System::TMetaClass*TControlClass;
  726.  
  727. struct TCreateParams
  728. {
  729.     char *Caption;
  730.     long Style;
  731.     long ExStyle;
  732.     int X;
  733.     int Y;
  734.     int Width;
  735.     int Height;
  736.     HWND WndParent;
  737.     void *Param;
  738.     WNDCLASSA WindowClass;
  739.     char WinClassName[64];
  740. } ;
  741.  
  742. class __declspec(delphiclass) TGraphicControl;
  743. class __declspec(pascalimplementation) TGraphicControl : public TControl
  744. {
  745.     typedef TControl inherited;
  746.     
  747. private:
  748.     Graphics::TCanvas* FCanvas;
  749.     MESSAGE void __fastcall WMPaint(Messages::TWMPaint &Message);
  750.     
  751. protected:
  752.     virtual void __fastcall Paint(void);
  753.     __property Graphics::TCanvas* Canvas = {read=FCanvas, nodefault};
  754.     
  755. public:
  756.     __fastcall virtual TGraphicControl(Classes::TComponent* AOwner);
  757.     __fastcall virtual ~TGraphicControl(void);
  758. };
  759.  
  760. class __declspec(delphiclass) TCustomControl;
  761. class __declspec(pascalimplementation) TCustomControl : public TWinControl
  762. {
  763.     typedef TWinControl inherited;
  764.     
  765. private:
  766.     Graphics::TCanvas* FCanvas;
  767.     HIDESBASE MESSAGE void __fastcall WMPaint(Messages::TWMPaint &Message);
  768.     
  769. protected:
  770.     virtual void __fastcall Paint(void);
  771.     virtual void __fastcall PaintWindow(HDC DC);
  772.     __property Graphics::TCanvas* Canvas = {read=FCanvas, nodefault};
  773.     
  774. public:
  775.     __fastcall virtual TCustomControl(Classes::TComponent* AOwner);
  776.     __fastcall virtual ~TCustomControl(void);
  777. public:
  778.     /* TWinControl.CreateParented */ __fastcall TCustomControl(HWND ParentWindow) : Controls::TWinControl(
  779.         ParentWindow) { }
  780.     
  781. };
  782.  
  783. class __declspec(delphiclass) THintWindow;
  784. class __declspec(pascalimplementation) THintWindow : public TCustomControl
  785. {
  786.     typedef TCustomControl inherited;
  787.     
  788. private:
  789.     MESSAGE void __fastcall CMTextChanged(Messages::TMessage &Message);
  790.     
  791. protected:
  792.     virtual void __fastcall CreateParams(TCreateParams &Params);
  793.     virtual void __fastcall Paint(void);
  794.     
  795. public:
  796.     __fastcall virtual THintWindow(Classes::TComponent* AOwner);
  797.     virtual void __fastcall ActivateHint(const Windows::TRect &Rect, const System::AnsiString AHint);
  798.     virtual bool __fastcall IsHintMsg(MSG &Msg);
  799.     void __fastcall ReleaseHandle(void);
  800.     __property Caption ;
  801.     __property Color ;
  802.     __property Canvas ;
  803. public:
  804.     /* TCustomControl.Destroy */ __fastcall virtual ~THintWindow(void) { }
  805.     
  806. public:
  807.     /* TWinControl.CreateParented */ __fastcall THintWindow(HWND ParentWindow) : Controls::TCustomControl(
  808.         ParentWindow) { }
  809.     
  810. };
  811.  
  812. typedef System::TMetaClass*THintWindowClass;
  813.  
  814. class __declspec(delphiclass) TChangeLink;
  815. class __declspec(pascalimplementation) TChangeLink : public System::TObject
  816. {
  817.     typedef System::TObject inherited;
  818.     
  819. private:
  820.     TCustomImageList* FSender;
  821.     Classes::TNotifyEvent FOnChange;
  822.     
  823. public:
  824.     __fastcall virtual ~TChangeLink(void);
  825.     virtual void __fastcall Change(void);
  826.     __property Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
  827.     __property TCustomImageList* Sender = {read=FSender, write=FSender, nodefault};
  828. public:
  829.     /* TObject.Create */ __fastcall TChangeLink(void) : System::TObject() { }
  830.     
  831. };
  832.  
  833. enum TDrawingStyle { dsFocus, dsSelected, dsNormal, dsTransparent };
  834.  
  835. enum TImageType { itImage, itMask };
  836.  
  837. enum TResType { rtBitmap, rtCursor, rtIcon };
  838.  
  839. typedef Shortint TOverlay;
  840.  
  841. enum TLoadResource { lrDefaultColor, lrDefaultSize, lrFromFile, lrMap3DColors, lrTransparent, lrMonoChrome 
  842.     };
  843.  
  844. typedef Set<TLoadResource, lrDefaultColor, lrMonoChrome>  TLoadResources;
  845.  
  846. class __declspec(pascalimplementation) TCustomImageList : public Classes::TComponent
  847. {
  848.     typedef Classes::TComponent inherited;
  849.     
  850. private:
  851.     int FHeight;
  852.     int FWidth;
  853.     int FAllocBy;
  854.     int FHandle;
  855.     TDrawingStyle FDrawingStyle;
  856.     bool FMasked;
  857.     bool FShareImages;
  858.     TImageType FImageType;
  859.     Graphics::TColor FBkColor;
  860.     Graphics::TColor FBlendColor;
  861.     Classes::TList* FClients;
  862.     HWND FDragHandle;
  863.     bool FDragging;
  864.     TCursor FDragCursor;
  865.     Graphics::TBitmap* FBitmap;
  866.     Classes::TNotifyEvent FOnChange;
  867.     virtual void __fastcall AssignTo(Classes::TPersistent* Dest);
  868.     void __fastcall InitBitmap(void);
  869.     void __fastcall CheckImage(Graphics::TGraphic* Image);
  870.     void __fastcall CombineDragCursor(void);
  871.     void __fastcall CopyImages(int Value);
  872.     void __fastcall CreateImageList(void);
  873.     void __fastcall FreeHandle(void);
  874.     int __fastcall GetCount(void);
  875.     Graphics::TColor __fastcall GetBkColor(void);
  876.     int __fastcall GetHandle(void);
  877.     HBITMAP __fastcall GetImageHandle(Graphics::TBitmap* Image);
  878.     void __fastcall InsertImage(int Index, Graphics::TBitmap* Image, Graphics::TBitmap* Mask, Graphics::TColor 
  879.         MaskColor);
  880.     void __fastcall ReadData(Classes::TStream* Stream);
  881.     void __fastcall SetBkColor(Graphics::TColor Value);
  882.     void __fastcall SetDragCursor(TCursor Value);
  883.     void __fastcall SetHandle(int Value);
  884.     void __fastcall SetHeight(int Value);
  885.     void __fastcall SetNewDimensions(int Value);
  886.     void __fastcall SetWidth(int Value);
  887.     void __fastcall WriteData(Classes::TStream* Stream);
  888.     
  889. protected:
  890.     virtual void __fastcall Change(void);
  891.     virtual void __fastcall DefineProperties(Classes::TFiler* Filer);
  892.     void __fastcall GetImages(int Index, Graphics::TBitmap* Image, Graphics::TBitmap* Mask);
  893.     void __fastcall HandleNeeded(void);
  894.     void __fastcall Initialize(void);
  895.     __property Graphics::TColor BlendColor = {read=FBlendColor, write=FBlendColor, default=536870911};
  896.     __property Graphics::TColor BkColor = {read=GetBkColor, write=SetBkColor, default=536870911};
  897.     __property int AllocBy = {read=FAllocBy, write=FAllocBy, default=4};
  898.     __property TDrawingStyle DrawingStyle = {read=FDrawingStyle, write=FDrawingStyle, default=2};
  899.     __property int Height = {read=FHeight, write=SetHeight, default=16};
  900.     __property TImageType ImageType = {read=FImageType, write=FImageType, default=0};
  901.     __property bool Masked = {read=FMasked, write=FMasked, default=1};
  902.     __property Classes::TNotifyEvent OnChange = {read=FOnChange, write=FOnChange};
  903.     __property bool ShareImages = {read=FShareImages, write=FShareImages, default=0};
  904.     __property int Width = {read=FWidth, write=SetWidth, default=16};
  905.     
  906. public:
  907.     __fastcall virtual TCustomImageList(Classes::TComponent* AOwner);
  908.     __fastcall TCustomImageList(int AWidth, int AHeight);
  909.     __fastcall virtual ~TCustomImageList(void);
  910.     virtual void __fastcall Assign(Classes::TPersistent* Source);
  911.     int __fastcall Add(Graphics::TBitmap* Image, Graphics::TBitmap* Mask);
  912.     int __fastcall AddIcon(Graphics::TIcon* Image);
  913.     void __fastcall AddImages(TCustomImageList* Value);
  914.     int __fastcall AddMasked(Graphics::TBitmap* Image, Graphics::TColor MaskColor);
  915.     bool __fastcall BeginDrag(HWND Window, int X, int Y);
  916.     void __fastcall Clear(void);
  917.     void __fastcall Delete(int Index);
  918.     bool __fastcall DragLock(HWND Window, int XPos, int YPos);
  919.     bool __fastcall DragMove(int X, int Y);
  920.     void __fastcall DragUnlock(void);
  921.     void __fastcall Draw(Graphics::TCanvas* Canvas, int X, int Y, int Index);
  922.     void __fastcall DrawOverlay(Graphics::TCanvas* Canvas, int X, int Y, int ImageIndex, TOverlay Overlay
  923.         );
  924.     bool __fastcall EndDrag(void);
  925.     bool __fastcall FileLoad(TResType ResType,  System::AnsiString Name, Graphics::TColor MaskColor);
  926.     void __fastcall GetBitmap(int Index, Graphics::TBitmap* Image);
  927.     POINT __fastcall GetHotSpot(void);
  928.     void __fastcall GetIcon(int Index, Graphics::TIcon* Image);
  929.     HBITMAP __fastcall GetImageBitmap(void);
  930.     HBITMAP __fastcall GetMaskBitmap(void);
  931.     bool __fastcall GetResource(TResType ResType,  System::AnsiString Name, int Width, TLoadResources LoadFlags
  932.         , Graphics::TColor MaskColor);
  933.     bool __fastcall HandleAllocated(void);
  934.     void __fastcall HideDragImage(void);
  935.     HIDESBASE void __fastcall Insert(int Index, Graphics::TBitmap* Image, Graphics::TBitmap* Mask);
  936.     void __fastcall InsertIcon(int Index, Graphics::TIcon* Image);
  937.     void __fastcall InsertMasked(int Index, Graphics::TBitmap* Image, Graphics::TColor MaskColor);
  938.     void __fastcall Move(int CurIndex, int NewIndex);
  939.     bool __fastcall Overlay(int ImageIndex, TOverlay Overlay);
  940.     void __fastcall RegisterChanges(TChangeLink* Value);
  941.     bool __fastcall ResourceLoad(TResType ResType,  System::AnsiString Name, Graphics::TColor MaskColor
  942.         );
  943.     void __fastcall Replace(int Index, Graphics::TBitmap* Image, Graphics::TBitmap* Mask);
  944.     void __fastcall ReplaceIcon(int Index, Graphics::TIcon* Image);
  945.     void __fastcall ReplaceMasked(int Index, Graphics::TBitmap* NewImage, Graphics::TColor MaskColor);
  946.     bool __fastcall SetDragImage(int Index, int HotSpotX, int HotSpotY);
  947.     void __fastcall ShowDragImage(void);
  948.     void __fastcall UnRegisterChanges(TChangeLink* Value);
  949.     __property int Count = {read=GetCount, nodefault};
  950.     __property TCursor DragCursor = {read=FDragCursor, write=SetDragCursor, nodefault};
  951.     __property bool Dragging = {read=FDragging, nodefault};
  952.     __property int Handle = {read=GetHandle, write=SetHandle, nodefault};
  953. };
  954.  
  955. class __declspec(delphiclass) TImageList;
  956. class __declspec(pascalimplementation) TImageList : public TCustomImageList
  957. {
  958.     typedef TCustomImageList inherited;
  959.     
  960. __published:
  961.     __property BlendColor ;
  962.     __property BkColor ;
  963.     __property AllocBy ;
  964.     __property DrawingStyle ;
  965.     __property Height ;
  966.     __property ImageType ;
  967.     __property Masked ;
  968.     __property OnChange ;
  969.     __property ShareImages ;
  970.     __property Width ;
  971. public:
  972.     /* TCustomImageList.Create */ __fastcall virtual TImageList(Classes::TComponent* AOwner) : Controls::
  973.         TCustomImageList(AOwner) { }
  974.     /* TCustomImageList.CreateSize */ __fastcall TImageList(int AWidth, int AHeight) : Controls::TCustomImageList(
  975.         AWidth, AHeight) { }
  976.     /* TCustomImageList.Destroy */ __fastcall virtual ~TImageList(void) { }
  977.     
  978. };
  979.  
  980. //-- var, const, procedure ---------------------------------------------------
  981. #define CM_BASE (int)(45056)
  982. #define CM_ACTIVATE (int)(45056)
  983. #define CM_DEACTIVATE (int)(45057)
  984. #define CM_GOTFOCUS (int)(45058)
  985. #define CM_LOSTFOCUS (int)(45059)
  986. #define CM_CANCELMODE (int)(45060)
  987. #define CM_DIALOGKEY (int)(45061)
  988. #define CM_DIALOGCHAR (int)(45062)
  989. #define CM_FOCUSCHANGED (int)(45063)
  990. #define CM_PARENTFONTCHANGED (int)(45064)
  991. #define CM_PARENTCOLORCHANGED (int)(45065)
  992. #define CM_HITTEST (int)(45066)
  993. #define CM_VISIBLECHANGED (int)(45067)
  994. #define CM_ENABLEDCHANGED (int)(45068)
  995. #define CM_COLORCHANGED (int)(45069)
  996. #define CM_FONTCHANGED (int)(45070)
  997. #define CM_CURSORCHANGED (int)(45071)
  998. #define CM_CTL3DCHANGED (int)(45072)
  999. #define CM_PARENTCTL3DCHANGED (int)(45073)
  1000. #define CM_TEXTCHANGED (int)(45074)
  1001. #define CM_MOUSEENTER (int)(45075)
  1002. #define CM_MOUSELEAVE (int)(45076)
  1003. #define CM_MENUCHANGED (int)(45077)
  1004. #define CM_APPKEYDOWN (int)(45078)
  1005. #define CM_APPSYSCOMMAND (int)(45079)
  1006. #define CM_BUTTONPRESSED (int)(45080)
  1007. #define CM_SHOWINGCHANGED (int)(45081)
  1008. #define CM_ENTER (int)(45082)
  1009. #ifndef CM_EXIT
  1010. #define CM_EXIT (int)(45083)
  1011. #endif
  1012. #define CM_DESIGNHITTEST (int)(45084)
  1013. #define CM_ICONCHANGED (int)(45085)
  1014. #define CM_WANTSPECIALKEY (int)(45086)
  1015. #define CM_INVOKEHELP (int)(45087)
  1016. #define CM_WINDOWHOOK (int)(45088)
  1017. #define CM_RELEASE (int)(45089)
  1018. #define CM_SHOWHINTCHANGED (int)(45090)
  1019. #define CM_PARENTSHOWHINTCHANGED (int)(45091)
  1020. #define CM_SYSCOLORCHANGE (int)(45092)
  1021. #define CM_WININICHANGE (int)(45093)
  1022. #define CM_FONTCHANGE (int)(45094)
  1023. #define CM_TIMECHANGE (int)(45095)
  1024. #define CM_TABSTOPCHANGED (int)(45096)
  1025. #define CM_UIACTIVATE (int)(45097)
  1026. #define CM_UIDEACTIVATE (int)(45098)
  1027. #define CM_DOCWINDOWACTIVATE (int)(45099)
  1028. #define CM_CONTROLLISTCHANGE (int)(45100)
  1029. #define CM_GETDATALINK (int)(45101)
  1030. #define CM_CHILDKEY (int)(45102)
  1031. #define CM_DRAG (int)(45103)
  1032. #define CM_HINTSHOW (int)(45104)
  1033. #define CM_DIALOGHANDLE (int)(45105)
  1034. #define CM_ISTOOLCONTROL (int)(45106)
  1035. #define CM_RECREATEWND (int)(45107)
  1036. #define CM_INVALIDATE (int)(45108)
  1037. #define CN_BASE (int)(48128)
  1038. #define CN_CHARTOITEM (int)(48175)
  1039.  
  1040. #ifndef CN_COMMAND
  1041. #define CN_COMMAND (int)(48401)
  1042. #endif
  1043.  
  1044. #define CN_COMPAREITEM (int)(48185)
  1045. #define CN_CTLCOLORBTN (int)(48437)
  1046. #define CN_CTLCOLORDLG (int)(48438)
  1047. #define CN_CTLCOLOREDIT (int)(48435)
  1048. #define CN_CTLCOLORLISTBOX (int)(48436)
  1049. #define CN_CTLCOLORMSGBOX (int)(48434)
  1050. #define CN_CTLCOLORSCROLLBAR (int)(48439)
  1051. #define CN_CTLCOLORSTATIC (int)(48440)
  1052. #define CN_DELETEITEM (int)(48173)
  1053. #define CN_DRAWITEM (int)(48171)
  1054. #define CN_HSCROLL (int)(48404)
  1055. #define CN_MEASUREITEM (int)(48172)
  1056. #define CN_PARENTNOTIFY (int)(48656)
  1057. #define CN_VKEYTOITEM (int)(48174)
  1058. #define CN_VSCROLL (int)(48405)
  1059. #define CN_KEYDOWN (int)(48384)
  1060. #define CN_KEYUP (int)(48385)
  1061. #define CN_CHAR (int)(48386)
  1062. #define CN_SYSKEYDOWN (int)(48388)
  1063. #define CN_SYSCHAR (int)(48390)
  1064. #define CN_NOTIFY (int)(48206)
  1065. #define mrNone (Byte)(0)
  1066. #define mrOk (Byte)(1)
  1067. #define mrCancel (Byte)(2)
  1068. #define mrAbort (Byte)(3)
  1069. #define mrRetry (Byte)(4)
  1070. #define mrIgnore (Byte)(5)
  1071. #define mrYes (Byte)(6)
  1072. #define mrNo (Byte)(7)
  1073. #define mrAll (Byte)(8)
  1074. #define crDefault (TCursor)(0)
  1075. #define crNone (TCursor)(-1)
  1076. #define crArrow (TCursor)(-2)
  1077. #define crCross (TCursor)(-3)
  1078. #define crIBeam (TCursor)(-4)
  1079. #define crSize (TCursor)(-5)
  1080. #define crSizeNESW (TCursor)(-6)
  1081. #define crSizeNS (TCursor)(-7)
  1082. #define crSizeNWSE (TCursor)(-8)
  1083. #define crSizeWE (TCursor)(-9)
  1084. #define crUpArrow (TCursor)(-10)
  1085. #define crHourGlass (TCursor)(-11)
  1086. #define crDrag (TCursor)(-12)
  1087. #define crNoDrop (TCursor)(-13)
  1088. #define crHSplit (TCursor)(-14)
  1089. #define crVSplit (TCursor)(-15)
  1090. #define crMultiDrag (TCursor)(-16)
  1091. #define crSQLWait (TCursor)(-17)
  1092. #define crNo (TCursor)(-18)
  1093. #define crAppStart (TCursor)(-19)
  1094. #define crHelp (TCursor)(-20)
  1095. extern TWinControl* CreationControl;
  1096. extern bool NewStyleControls;
  1097. extern long __stdcall InitWndProc(HWND HWindow, long Message, long WParam, long LParam);
  1098. extern TWinControl* __fastcall FindControl(HWND Handle);
  1099. extern long __fastcall SendAppMessage(Cardinal Msg, long WParam, long LParam);
  1100. extern System::AnsiString __fastcall CursorToString(TCursor Cursor);
  1101. extern TCursor __fastcall StringToCursor(const System::AnsiString S);
  1102. extern void __fastcall GetCursorValues(Classes::TGetStrProc Proc);
  1103. extern bool __fastcall CursorToIdent(long Cursor,  System::AnsiString &Ident);
  1104. extern bool __fastcall IdentToCursor(const System::AnsiString Ident, long &Cursor);
  1105. extern System::AnsiString __fastcall GetShortHint(const System::AnsiString Hint);
  1106. extern System::AnsiString __fastcall GetLongHint(const System::AnsiString Hint);
  1107. extern TControl* __fastcall GetCaptureControl(void);
  1108. extern void __fastcall SetCaptureControl(TControl* Control);
  1109. extern bool __fastcall IsDragObject(System::TObject* Sender);
  1110. extern void __fastcall CancelDrag(void);
  1111. extern TWinControl* __fastcall FindVCLWindow(const POINT &Pos);
  1112. extern TControl* __fastcall FindDragTarget(const POINT &Pos, bool AllowDisabled);
  1113. extern void __fastcall MoveWindowOrg(HDC DC, int DX, int DY);
  1114. extern bool __fastcall Win32NLSEnableIME(HWND Handle, bool Enable);
  1115. extern void __fastcall SetImeMode(HWND Handle, TImeMode Mode);
  1116. extern int __fastcall Imm32GetContext(HWND hWnd);
  1117. extern bool __fastcall Imm32ReleaseContext(HWND hWnd, int hImc);
  1118. extern bool __fastcall Imm32GetConversionStatus(int hImc, int &Conversion, int &Sentence);
  1119. extern bool __fastcall Imm32SetConversionStatus(int hImc, int Conversion, int Sentence);
  1120. extern bool __fastcall Imm32SetOpenStatus(int hImc, bool fOpen);
  1121. extern bool __fastcall Imm32SetCompositionWindow(int hImc, Imm::PCompositionForm lpCompForm);
  1122. extern bool __fastcall Imm32SetCompositionFont(int hImc, Windows::PLogFontA lpLogfont);
  1123. extern long __fastcall Imm32GetCompositionString(int hImc, int dWord1, void * lpBuf, int dwBufLen);
  1124. extern bool __fastcall Imm32IsIME(HKL hKl);
  1125. extern bool __fastcall Imm32NotifyIME(int hImc, int dwAction, int dwIndex, int dwValue);
  1126. //-- template instantiations -------------------------------------------------
  1127. template class TLoadResources ;
  1128. template class TScalingFlags ;
  1129. template class TControlState ;
  1130. template class TControlStyle ;
  1131.  
  1132. }    /* namespace Controls */
  1133.  
  1134. #pragma warn .par
  1135. #pragma warn .hid 
  1136. #pragma warn .inl
  1137.  
  1138. #if !defined(NO_IMPLICIT_NAMESPACE_USE)
  1139. using namespace Controls;
  1140. #endif
  1141. //-- end unit ----------------------------------------------------------------
  1142. #endif    // Controls
  1143.