home *** CD-ROM | disk | FTP | other *** search
/ PC World Plus! (NZ) 2001 June / HDC50.iso / Runimage / Delphi50 / Doc / CONTROLS.INT < prev    next >
Text File  |  1999-08-11  |  43KB  |  1,132 lines
  1.  
  2. {*******************************************************}
  3. {                                                       }
  4. {       Borland Delphi Visual Component Library         }
  5. {                                                       }
  6. {       Copyright (c) 1995,99 Inprise Corporation       }
  7. {                                                       }
  8. {*******************************************************}
  9.  
  10. unit Controls;
  11.  
  12. {$P+,S-,W-,R-,T-,H+,X+}
  13. {$C PRELOAD}
  14.  
  15. interface
  16.  
  17. {$R CONTROLS}
  18.  
  19. { CommCtrl.hpp is not required in Controls.hpp }
  20. (*$NOINCLUDE CommCtrl *)
  21. uses Messages, Windows, MultiMon, Classes, Sysutils, Graphics, Menus, CommCtrl, Imm,
  22.   ImgList, ActnList;
  23.  
  24. { VCL control message IDs }
  25.  
  26. const
  27.   CM_BASE                   = $B000;
  28.   CM_ACTIVATE               = CM_BASE + 0;
  29.   CM_DEACTIVATE             = CM_BASE + 1;
  30.   CM_GOTFOCUS               = CM_BASE + 2;
  31.   CM_LOSTFOCUS              = CM_BASE + 3;
  32.   CM_CANCELMODE             = CM_BASE + 4;
  33.   CM_DIALOGKEY              = CM_BASE + 5;
  34.   CM_DIALOGCHAR             = CM_BASE + 6;
  35.   CM_FOCUSCHANGED           = CM_BASE + 7;
  36.   CM_PARENTFONTCHANGED      = CM_BASE + 8;
  37.   CM_PARENTCOLORCHANGED     = CM_BASE + 9;
  38.   CM_HITTEST                = CM_BASE + 10;
  39.   CM_VISIBLECHANGED         = CM_BASE + 11;
  40.   CM_ENABLEDCHANGED         = CM_BASE + 12;
  41.   CM_COLORCHANGED           = CM_BASE + 13;
  42.   CM_FONTCHANGED            = CM_BASE + 14;
  43.   CM_CURSORCHANGED          = CM_BASE + 15;
  44.   CM_CTL3DCHANGED           = CM_BASE + 16;
  45.   CM_PARENTCTL3DCHANGED     = CM_BASE + 17;
  46.   CM_TEXTCHANGED            = CM_BASE + 18;
  47.   CM_MOUSEENTER             = CM_BASE + 19;
  48.   CM_MOUSELEAVE             = CM_BASE + 20;
  49.   CM_MENUCHANGED            = CM_BASE + 21;
  50.   CM_APPKEYDOWN             = CM_BASE + 22;
  51.   CM_APPSYSCOMMAND          = CM_BASE + 23;
  52.   CM_BUTTONPRESSED          = CM_BASE + 24;
  53.   CM_SHOWINGCHANGED         = CM_BASE + 25;
  54.   CM_ENTER                  = CM_BASE + 26;
  55.   CM_EXIT                   = CM_BASE + 27;
  56.   CM_DESIGNHITTEST          = CM_BASE + 28;
  57.   CM_ICONCHANGED            = CM_BASE + 29;
  58.   CM_WANTSPECIALKEY         = CM_BASE + 30;
  59.   CM_INVOKEHELP             = CM_BASE + 31;
  60.   CM_WINDOWHOOK             = CM_BASE + 32;
  61.   CM_RELEASE                = CM_BASE + 33;
  62.   CM_SHOWHINTCHANGED        = CM_BASE + 34;
  63.   CM_PARENTSHOWHINTCHANGED  = CM_BASE + 35;
  64.   CM_SYSCOLORCHANGE         = CM_BASE + 36;
  65.   CM_WININICHANGE           = CM_BASE + 37;
  66.   CM_FONTCHANGE             = CM_BASE + 38;
  67.   CM_TIMECHANGE             = CM_BASE + 39;
  68.   CM_TABSTOPCHANGED         = CM_BASE + 40;
  69.   CM_UIACTIVATE             = CM_BASE + 41;
  70.   CM_UIDEACTIVATE           = CM_BASE + 42;
  71.   CM_DOCWINDOWACTIVATE      = CM_BASE + 43;
  72.   CM_CONTROLLISTCHANGE      = CM_BASE + 44;
  73.   CM_GETDATALINK            = CM_BASE + 45;
  74.   CM_CHILDKEY               = CM_BASE + 46;
  75.   CM_DRAG                   = CM_BASE + 47;
  76.   CM_HINTSHOW               = CM_BASE + 48;
  77.   CM_DIALOGHANDLE           = CM_BASE + 49;
  78.   CM_ISTOOLCONTROL          = CM_BASE + 50;
  79.   CM_RECREATEWND            = CM_BASE + 51;
  80.   CM_INVALIDATE             = CM_BASE + 52;
  81.   CM_SYSFONTCHANGED         = CM_BASE + 53;
  82.   CM_CONTROLCHANGE          = CM_BASE + 54;
  83.   CM_CHANGED                = CM_BASE + 55;
  84.   CM_DOCKCLIENT             = CM_BASE + 56;
  85.   CM_UNDOCKCLIENT           = CM_BASE + 57;
  86.   CM_FLOAT                  = CM_BASE + 58;
  87.   CM_BORDERCHANGED          = CM_BASE + 59;
  88.   CM_BIDIMODECHANGED        = CM_BASE + 60;
  89.   CM_PARENTBIDIMODECHANGED  = CM_BASE + 61;
  90.   CM_ALLCHILDRENFLIPPED     = CM_BASE + 62;
  91.   CM_ACTIONUPDATE           = CM_BASE + 63;
  92.   CM_ACTIONEXECUTE          = CM_BASE + 64;
  93.   CM_HINTSHOWPAUSE          = CM_BASE + 65;
  94.   CM_DOCKNOTIFICATION       = CM_BASE + 66;
  95.   CM_MOUSEWHEEL             = CM_BASE + 67;
  96.  
  97. { VCL control notification IDs }
  98.  
  99. const
  100.   CN_BASE              = $BC00;
  101.   CN_CHARTOITEM        = CN_BASE + WM_CHARTOITEM;
  102.   CN_COMMAND           = CN_BASE + WM_COMMAND;
  103.   CN_COMPAREITEM       = CN_BASE + WM_COMPAREITEM;
  104.   CN_CTLCOLORBTN       = CN_BASE + WM_CTLCOLORBTN;
  105.   CN_CTLCOLORDLG       = CN_BASE + WM_CTLCOLORDLG;
  106.   CN_CTLCOLOREDIT      = CN_BASE + WM_CTLCOLOREDIT;
  107.   CN_CTLCOLORLISTBOX   = CN_BASE + WM_CTLCOLORLISTBOX;
  108.   CN_CTLCOLORMSGBOX    = CN_BASE + WM_CTLCOLORMSGBOX;
  109.   CN_CTLCOLORSCROLLBAR = CN_BASE + WM_CTLCOLORSCROLLBAR;
  110.   CN_CTLCOLORSTATIC    = CN_BASE + WM_CTLCOLORSTATIC;
  111.   CN_DELETEITEM        = CN_BASE + WM_DELETEITEM;
  112.   CN_DRAWITEM          = CN_BASE + WM_DRAWITEM;
  113.   CN_HSCROLL           = CN_BASE + WM_HSCROLL;
  114.   CN_MEASUREITEM       = CN_BASE + WM_MEASUREITEM;
  115.   CN_PARENTNOTIFY      = CN_BASE + WM_PARENTNOTIFY;
  116.   CN_VKEYTOITEM        = CN_BASE + WM_VKEYTOITEM;
  117.   CN_VSCROLL           = CN_BASE + WM_VSCROLL;
  118.   CN_KEYDOWN           = CN_BASE + WM_KEYDOWN;
  119.   CN_KEYUP             = CN_BASE + WM_KEYUP;
  120.   CN_CHAR              = CN_BASE + WM_CHAR;
  121.   CN_SYSKEYDOWN        = CN_BASE + WM_SYSKEYDOWN;
  122.   CN_SYSCHAR           = CN_BASE + WM_SYSCHAR;
  123.   CN_NOTIFY            = CN_BASE + WM_NOTIFY;
  124.  
  125. { TModalResult values }
  126.  
  127. const
  128.   mrNone     = 0;
  129.   mrOk       = idOk;
  130.   mrCancel   = idCancel;
  131.   mrAbort    = idAbort;
  132.   mrRetry    = idRetry;
  133.   mrIgnore   = idIgnore;
  134.   mrYes      = idYes;
  135.   mrNo       = idNo;
  136.   mrAll      = mrNo + 1;
  137.   mrNoToAll  = mrAll + 1;
  138.   mrYesToAll = mrNoToAll + 1;
  139.  
  140. { Cursor identifiers }
  141.  
  142. type
  143.   TCursor = -32768..32767;
  144.   {$NODEFINE TCursor}
  145.  
  146.   (*$HPPEMIT 'namespace Controls'}*)
  147.   (*$HPPEMIT '{'}*)
  148.   (*$HPPEMIT '#pragma option -b-'*)
  149.   (*$HPPEMIT '  enum TCursor {crMin=-32768, crMax=32767};'}*)
  150.   (*$HPPEMIT '#pragma option -b.'*)
  151.   (*$HPPEMIT '}'*)
  152.  
  153. const
  154.   crDefault     = TCursor(0);
  155.   crNone        = TCursor(-1);
  156.   crArrow       = TCursor(-2);
  157.   crCross       = TCursor(-3);
  158.   crIBeam       = TCursor(-4);
  159.   crSize        = TCursor(-22);
  160.   crSizeNESW    = TCursor(-6);
  161.   crSizeNS      = TCursor(-7);
  162.   crSizeNWSE    = TCursor(-8);
  163.   crSizeWE      = TCursor(-9);
  164.   crUpArrow     = TCursor(-10);
  165.   crHourGlass   = TCursor(-11);
  166.   crDrag        = TCursor(-12);
  167.   crNoDrop      = TCursor(-13);
  168.   crHSplit      = TCursor(-14);
  169.   crVSplit      = TCursor(-15);
  170.   crMultiDrag   = TCursor(-16);
  171.   crSQLWait     = TCursor(-17);
  172.   crNo          = TCursor(-18);
  173.   crAppStart    = TCursor(-19);
  174.   crHelp        = TCursor(-20);
  175.   crHandPoint   = TCursor(-21);
  176.   crSizeAll     = TCursor(-22);
  177.  
  178. type
  179.  
  180. { Forward declarations }
  181.  
  182.   TDragObject = class;
  183.   TControl = class;
  184.   TWinControl = class;
  185.   TDragImageList = class;
  186.  
  187.   TWinControlClass = class of TWinControl;
  188.  
  189. { VCL control message records }
  190.  
  191.   TCMActivate = TWMNoParams;
  192.   TCMDeactivate = TWMNoParams;
  193.   TCMGotFocus = TWMNoParams;
  194.   TCMLostFocus = TWMNoParams;
  195.   TCMDialogKey = TWMKey;
  196.   TCMDialogChar = TWMKey;
  197.   TCMHitTest = TWMNCHitTest;
  198.   TCMEnter = TWMNoParams;
  199.   TCMExit = TWMNoParams;
  200.   TCMDesignHitTest = TWMMouse;
  201.   TCMWantSpecialKey = TWMKey;
  202.  
  203.   TCMMouseWheel = record
  204.     Msg: Cardinal;
  205.     ShiftState: TShiftState;
  206.     Unused: Byte;
  207.     WheelDelta: SmallInt;
  208.     case Integer of
  209.       0: (
  210.         XPos: Smallint;
  211.         YPos: Smallint);
  212.       1: (
  213.         Pos: TSmallPoint;
  214.         Result: Longint);
  215.   end;
  216.  
  217.   TCMCancelMode = record
  218.     Msg: Cardinal;
  219.     Unused: Integer;
  220.     Sender: TControl;
  221.     Result: Longint;
  222.   end;
  223.  
  224.   TCMFocusChanged = record
  225.     Msg: Cardinal;
  226.     Unused: Integer;
  227.     Sender: TWinControl;
  228.     Result: Longint;
  229.   end;
  230.  
  231.   TCMControlListChange = record
  232.     Msg: Cardinal;
  233.     Control: TControl;
  234.     Inserting: LongBool;
  235.     Result: Longint;
  236.   end;
  237.  
  238.   TCMChildKey = record
  239.     Msg: Cardinal;
  240.     CharCode: Word;
  241.     Unused: Word;
  242.     Sender: TWinControl;
  243.     Result: Longint;
  244.   end;
  245.  
  246.   TCMControlChange = record
  247.     Msg: Cardinal;
  248.     Control: TControl;
  249.     Inserting: LongBool;
  250.     Result: Longint;
  251.   end;
  252.  
  253.   TCMChanged = record
  254.     Msg: Cardinal;
  255.     Unused: Longint;
  256.     Child: TControl;
  257.     Result: Longint;
  258.   end;
  259.  
  260.   TDragMessage = (dmDragEnter, dmDragLeave, dmDragMove, dmDragDrop, dmDragCancel,
  261.     dmFindTarget);
  262.  
  263.   PDragRec = ^TDragRec;
  264.   TDragRec = record
  265.     Pos: TPoint;
  266.     Source: TDragObject;
  267.     Target: Pointer;
  268.     Docking: Boolean;
  269.   end;
  270.  
  271.   TCMDrag = packed record
  272.     Msg: Cardinal;
  273.     DragMessage: TDragMessage;
  274.     Reserved1: Byte;
  275.     Reserved2: Word;
  276.     DragRec: PDragRec;
  277.     Result: Longint;
  278.   end;
  279.  
  280.   TDragDockObject = class;
  281.  
  282.   TCMDockClient = packed record
  283.     Msg: Cardinal;
  284.     DockSource: TDragDockObject;
  285.     MousePos: TSmallPoint;
  286.     Result: Integer;
  287.   end;
  288.  
  289.   TCMUnDockClient = packed record
  290.     Msg: Cardinal;
  291.     NewTarget: TControl;
  292.     Client: TControl;
  293.     Result: Integer;
  294.   end;
  295.  
  296.   TCMFloat = packed record
  297.     Msg: Cardinal;
  298.     Reserved: Integer;
  299.     DockSource: TDragDockObject;
  300.     Result: Integer;
  301.   end;
  302.  
  303.   PDockNotifyRec = ^TDockNotifyRec;
  304.   TDockNotifyRec = record
  305.     ClientMsg: Cardinal;
  306.     MsgWParam: Integer;
  307.     MsgLParam: Integer;
  308.   end;
  309.  
  310.   TCMDockNotification = packed record
  311.     Msg: Cardinal;
  312.     Client: TControl;
  313.     NotifyRec: PDockNotifyRec;
  314.     Result: Integer;
  315.   end;
  316.  
  317.   TAlign = (alNone, alTop, alBottom, alLeft, alRight, alClient);
  318.  
  319.   TAlignSet = set of TAlign;
  320.  
  321. { Dragging objects }
  322.  
  323.   TDragObject = class(TObject)
  324.   protected
  325.     procedure Finished(Target: TObject; X, Y: Integer; Accepted: Boolean); virtual;
  326.     function GetDragCursor(Accepted: Boolean; X, Y: Integer): TCursor; virtual;
  327.     function GetDragImages: TDragImageList; virtual;
  328.   public
  329.     procedure Assign(Source: TDragObject); virtual;
  330.     function GetName: string; virtual;
  331.     procedure HideDragImage; virtual;
  332.     function Instance: THandle; virtual;
  333.     procedure ShowDragImage; virtual;
  334.     property Cancelling: Boolean;
  335.     property DragHandle: HWND;
  336.     property DragPos: TPoint;
  337.     property DragTargetPos: TPoint;
  338.     property DragTarget: Pointer;
  339.     property MouseDeltaX: Double;
  340.     property MouseDeltaY: Double;
  341.   end;
  342.  
  343.   TBaseDragControlObject = class(TDragObject)
  344.   protected
  345.     procedure EndDrag(Target: TObject; X, Y: Integer); virtual;
  346.     procedure Finished(Target: TObject; X, Y: Integer; Accepted: Boolean); override;
  347.   public
  348.     constructor Create(AControl: TControl); virtual;
  349.     procedure Assign(Source: TDragObject); override;
  350.     property Control: TControl;
  351.   end;
  352.  
  353.   TDragControlObject = class(TBaseDragControlObject)
  354.   protected
  355.     function GetDragCursor(Accepted: Boolean; X, Y: Integer): TCursor; override;
  356.     function GetDragImages: TDragImageList; override;
  357.   public
  358.     procedure HideDragImage; override;
  359.     procedure ShowDragImage; override;
  360.   end;
  361.  
  362.   TDragDockObject = class(TBaseDragControlObject)
  363.   protected
  364.     procedure AdjustDockRect(ARect: TRect); virtual;
  365.     procedure DrawDragDockImage; virtual;
  366.     procedure EndDrag(Target: TObject; X, Y: Integer); override;
  367.     procedure EraseDragDockImage; virtual;
  368.     function GetDragCursor(Accepted: Boolean; X, Y: Integer): TCursor; override;
  369.     function GetFrameWidth: Integer; virtual;
  370.   public
  371.     constructor Create(AControl: TControl); override;
  372.     destructor Destroy; override;
  373.     procedure Assign(Source: TDragObject); override;
  374.     property Brush: TBrush;
  375.     property DockRect: TRect;
  376.     property DropAlign: TAlign;
  377.     property DropOnControl: TControl;
  378.     property Floating: Boolean;
  379.     property FrameWidth: Integer;
  380.   end;
  381.  
  382. { Controls }
  383.  
  384.   TControlCanvas = class(TCanvas)
  385.   protected
  386.     procedure CreateHandle; override;
  387.   public
  388.     destructor Destroy; override;
  389.     procedure FreeHandle;
  390.     procedure UpdateTextFlags;
  391.     property Control: TControl;
  392.   end;
  393.  
  394. { TControlActionLink }
  395.  
  396.   TControlActionLink = class(TActionLink)
  397.   protected
  398.     FClient: TControl;
  399.     procedure AssignClient(AClient: TObject); override;
  400.     function IsCaptionLinked: Boolean; override;
  401.     function IsEnabledLinked: Boolean; override;
  402.     function IsHintLinked: Boolean; override;
  403.     function IsVisibleLinked: Boolean; override;
  404.     function IsOnExecuteLinked: Boolean; override;
  405.     function DoShowHint(var HintStr: string): Boolean; virtual;
  406.     procedure SetCaption(const Value: string); override;
  407.     procedure SetEnabled(Value: Boolean); override;
  408.     procedure SetHint(const Value: string); override;
  409.     procedure SetVisible(Value: Boolean); override;
  410.     procedure SetOnExecute(Value: TNotifyEvent); override;
  411.   end;
  412.  
  413.   TControlActionLinkClass = class of TControlActionLink;
  414.  
  415. { TControl }
  416.  
  417.   TControlState = set of (csLButtonDown, csClicked, csPalette,
  418.     csReadingState, csAlignmentNeeded, csFocusing, csCreating,
  419.     csPaintCopy, csCustomPaint, csDestroyingHandle, csDocking);
  420.  
  421.   TControlStyle = set of (csAcceptsControls, csCaptureMouse,
  422.     csDesignInteractive, csClickEvents, csFramed, csSetCaption, csOpaque,
  423.     csDoubleClicks, csFixedWidth, csFixedHeight, csNoDesignVisible,
  424.     csReplicatable, csNoStdEvents, csDisplayDragImage, csReflector,
  425.     csActionClient, csMenuEvents);
  426.  
  427.   TMouseButton = (mbLeft, mbRight, mbMiddle);
  428.  
  429.   TDragMode = (dmManual, dmAutomatic);
  430.  
  431.   TDragState = (dsDragEnter, dsDragLeave, dsDragMove);
  432.  
  433.   TDragKind = (dkDrag, dkDock);
  434.  
  435.   TTabOrder = -1..32767;
  436.  
  437.   TCaption = type string;
  438.  
  439.   TDate = type TDateTime;
  440.  
  441.   TTime = type TDateTime;
  442.   {$EXTERNALSYM TDate}
  443.   {$EXTERNALSYM TTime}
  444.   (*$HPPEMIT 'namespace Controls'*)
  445.   (*$HPPEMIT '{'*)
  446.   (*$HPPEMIT '    typedef System::TDateTime TDate;'*)
  447.   (*$HPPEMIT '    typedef System::TDateTime TTime;'*)
  448.   (*$HPPEMIT '}'*)
  449.  
  450.  
  451.   TScalingFlags = set of (sfLeft, sfTop, sfWidth, sfHeight, sfFont);
  452.  
  453.   TAnchorKind = (akLeft, akTop, akRight, akBottom);
  454.   TAnchors = set of TAnchorKind;
  455.  
  456.   TConstraintSize = 0..MaxInt;
  457.  
  458.   TSizeConstraints = class(TPersistent)
  459.   protected
  460.     procedure Change; dynamic;
  461.     procedure AssignTo(Dest: TPersistent); override;
  462.     property Control: TControl;
  463.   public
  464.     constructor Create(Control: TControl); virtual;
  465.     property OnChange: TNotifyEvent;
  466.   published
  467.     property MaxHeight: TConstraintSize index 0 default 0;
  468.     property MaxWidth: TConstraintSize index 1 default 0;
  469.     property MinHeight: TConstraintSize index 2 default 0;
  470.     property MinWidth: TConstraintSize index 3 default 0;
  471.   end;
  472.  
  473.   TMouseEvent = procedure(Sender: TObject; Button: TMouseButton;
  474.     Shift: TShiftState; X, Y: Integer) of object;
  475.   TMouseMoveEvent = procedure(Sender: TObject; Shift: TShiftState;
  476.     X, Y: Integer) of object;
  477.   TKeyEvent = procedure(Sender: TObject; var Key: Word;
  478.     Shift: TShiftState) of object;
  479.   TKeyPressEvent = procedure(Sender: TObject; var Key: Char) of object;
  480.   TDragOverEvent = procedure(Sender, Source: TObject; X, Y: Integer;
  481.     State: TDragState; var Accept: Boolean) of object;
  482.   TDragDropEvent = procedure(Sender, Source: TObject;
  483.     X, Y: Integer) of object;
  484.   TStartDragEvent = procedure(Sender: TObject;
  485.     var DragObject: TDragObject) of object;
  486.   TEndDragEvent = procedure(Sender, Target: TObject;
  487.     X, Y: Integer) of object;
  488.   TDockDropEvent = procedure(Sender: TObject; Source: TDragDockObject;
  489.     X, Y: Integer) of object;
  490.   TDockOverEvent = procedure(Sender: TObject; Source: TDragDockObject;
  491.     X, Y: Integer; State: TDragState; var Accept: Boolean) of object;
  492.   TUnDockEvent = procedure(Sender: TObject; Client: TControl;
  493.     NewTarget: TWinControl; var Allow: Boolean) of object;
  494.   TStartDockEvent = procedure(Sender: TObject;
  495.     var DragObject: TDragDockObject) of object;
  496.   TGetSiteInfoEvent = procedure(Sender: TObject; DockClient: TControl;
  497.     var InfluenceRect: TRect; MousePos: TPoint; var CanDock: Boolean) of object;
  498.   TCanResizeEvent = procedure(Sender: TObject; var NewWidth, NewHeight: Integer;
  499.     var Resize: Boolean) of object;
  500.   TConstrainedResizeEvent = procedure(Sender: TObject; var MinWidth, MinHeight,
  501.     MaxWidth, MaxHeight: Integer) of object;
  502.   TMouseWheelEvent = procedure(Sender: TObject; Shift: TShiftState;
  503.     WheelDelta: Integer; MousePos: TPoint; var Handled: Boolean) of object;
  504.   TMouseWheelUpDownEvent = procedure(Sender: TObject; Shift: TShiftState;
  505.     MousePos: TPoint; var Handled: Boolean) of object;
  506.   TContextPopupEvent = procedure(Sender: TObject; MousePos: TPoint; var Handled: Boolean) of object;
  507.  
  508.   TWndMethod = procedure(var Message: TMessage) of object;
  509.  
  510.   // TDockOrientation indicates how a zone's child zones are arranged.
  511.   // doNoOrient means a zone contains a TControl and not child zones.
  512.   // doHorizontal means a zone's children are stacked top-to-bottom.
  513.   // doVertical means a zone's children are arranged left-to-right.
  514.   TDockOrientation = (doNoOrient, doHorizontal, doVertical);
  515.  
  516.   TControl = class(TComponent)
  517.   protected
  518.     procedure ActionChange(Sender: TObject; CheckDefaults: Boolean); dynamic;
  519.     procedure AdjustSize; dynamic;
  520.     procedure AssignTo(Dest: TPersistent); override;
  521.     procedure BeginAutoDrag; dynamic;
  522.     function CanResize(var NewWidth, NewHeight: Integer): Boolean; virtual;
  523.     function CanAutoSize(var NewWidth, NewHeight: Integer): Boolean; virtual;
  524.     procedure Changed;
  525.     procedure ChangeScale(M, D: Integer); dynamic;
  526.     procedure Click; dynamic;
  527.     procedure ConstrainedResize(var MinWidth, MinHeight, MaxWidth, MaxHeight: Integer); virtual;
  528.     procedure DblClick; dynamic;
  529.     procedure DefaultDockImage(DragDockObject: TDragDockObject; Erase: Boolean); dynamic;
  530.     procedure DefineProperties(Filer: TFiler); override;
  531.     procedure DockTrackNoTarget(Source: TDragDockObject; X, Y: Integer); dynamic;
  532.     procedure DoContextPopup(MousePos: TPoint; var Handled: Boolean); dynamic;
  533.     procedure DoEndDock(Target: TObject; X, Y: Integer); dynamic;
  534.     procedure DoDock(NewDockSite: TWinControl; var ARect: TRect); dynamic;
  535.     procedure DoStartDock(var DragObject: TDragObject); dynamic;
  536.     procedure DragCanceled; dynamic;
  537.     procedure DragOver(Source: TObject; X, Y: Integer; State: TDragState;
  538.       var Accept: Boolean); dynamic;
  539.     procedure DoEndDrag(Target: TObject; X, Y: Integer); dynamic;
  540.     procedure DoStartDrag(var DragObject: TDragObject); dynamic;
  541.     procedure DrawDragDockImage(DragDockObject: TDragDockObject); dynamic;
  542.     procedure EraseDragDockImage(DragDockObject: TDragDockObject); dynamic;
  543.     function GetActionLinkClass: TControlActionLinkClass; dynamic;
  544.     function GetClientOrigin: TPoint; virtual;
  545.     function GetClientRect: TRect; virtual;
  546.     function GetDeviceContext(var WindowHandle: HWnd): HDC; virtual;
  547.     function GetDockEdge(MousePos: TPoint): TAlign; dynamic;
  548.     function GetDragImages: TDragImageList; virtual;
  549.     function GetEnabled: Boolean; virtual;
  550.     function GetFloating: Boolean; virtual;
  551.     function GetFloatingDockSiteClass: TWinControlClass; virtual;
  552.     function GetPalette: HPALETTE; dynamic;
  553.     function GetPopupMenu: TPopupMenu; dynamic;
  554.     procedure Loaded; override;
  555.     procedure MouseDown(Button: TMouseButton; Shift: TShiftState;
  556.       X, Y: Integer); dynamic;
  557.     procedure MouseMove(Shift: TShiftState; X, Y: Integer); dynamic;
  558.     procedure MouseUp(Button: TMouseButton; Shift: TShiftState;
  559.       X, Y: Integer); dynamic;
  560.     procedure Notification(AComponent: TComponent;
  561.       Operation: TOperation); override;
  562.     procedure PositionDockRect(DragDockObject: TDragDockObject); dynamic;
  563.     function PaletteChanged(Foreground: Boolean): Boolean; dynamic;
  564.     procedure ReadState(Reader: TReader); override;
  565.     procedure RequestAlign; dynamic;
  566.     procedure Resize; dynamic;
  567.     procedure SendCancelMode(Sender: TControl);
  568.     procedure SendDockNotification(Msg: Cardinal; WParam, LParam: Integer);
  569.     procedure SetDragMode(Value: TDragMode); virtual;
  570.     procedure SetEnabled(Value: Boolean); virtual;
  571.     procedure SetName(const Value: TComponentName); override;
  572.     procedure SetParent(AParent: TWinControl); virtual;
  573.     procedure SetParentComponent(Value: TComponent); override;
  574.     procedure SetParentBiDiMode(Value: Boolean); virtual;
  575.     procedure SetBiDiMode(Value: TBiDiMode); virtual;
  576.     procedure SetZOrder(TopMost: Boolean); dynamic;
  577.     procedure UpdateBoundsRect(const R: TRect);
  578.     procedure VisibleChanging; dynamic;
  579.     procedure WndProc(var Message: TMessage); virtual;
  580.     property ActionLink: TControlActionLink;
  581.     property AutoSize: Boolean default False;
  582.     property Caption: TCaption;
  583.     property Color: TColor default clWindow;
  584.     property DesktopFont: Boolean default False;
  585.     property DragKind: TDragKind default dkDrag;
  586.     property DragCursor: TCursor default crDrag;
  587.     property DragMode: TDragMode default dmManual;
  588.     property Font: TFont;
  589.     property IsControl: Boolean;
  590.     property MouseCapture: Boolean;
  591.     property ParentBiDiMode: Boolean default True;
  592.     property ParentColor: Boolean default True;
  593.     property ParentFont: Boolean default True;
  594.     property ParentShowHint: Boolean default True;
  595.     property PopupMenu: TPopupMenu;
  596.     property ScalingFlags: TScalingFlags;
  597.     property Text: TCaption;
  598.     property WindowText: PChar;
  599.     property OnCanResize: TCanResizeEvent;
  600.     property OnClick: TNotifyEvent;
  601.     property OnConstrainedResize: TConstrainedResizeEvent;
  602.     property OnContextPopup: TContextPopupEvent;
  603.     property OnDblClick: TNotifyEvent;
  604.     property OnDragDrop: TDragDropEvent;
  605.     property OnDragOver: TDragOverEvent;
  606.     property OnEndDock: TEndDragEvent;
  607.     property OnEndDrag: TEndDragEvent;
  608.     property OnMouseDown: TMouseEvent;
  609.     property OnMouseMove: TMouseMoveEvent;
  610.     property OnMouseUp: TMouseEvent;
  611.     property OnResize: TNotifyEvent;
  612.     property OnStartDock: TStartDockEvent;
  613.     property OnStartDrag: TStartDragEvent;
  614.   public
  615.     constructor Create(AOwner: TComponent); override;
  616.     destructor Destroy; override;
  617.     procedure BeginDrag(Immediate: Boolean; Threshold: Integer = -1);
  618.     procedure BringToFront;
  619.     function ClientToScreen(const Point: TPoint): TPoint;
  620.     procedure Dock(NewDockSite: TWinControl; ARect: TRect); dynamic;
  621.     procedure DefaultHandler(var Message); override;
  622.     function Dragging: Boolean;
  623.     procedure DragDrop(Source: TObject; X, Y: Integer); dynamic;
  624.     function DrawTextBiDiModeFlags(Flags: Longint): Longint;
  625.     function DrawTextBiDiModeFlagsReadingOnly: Longint;
  626.     property Enabled: Boolean default True;
  627.     procedure EndDrag(Drop: Boolean);
  628.     function GetControlsAlignment: TAlignment; dynamic;
  629.     function GetParentComponent: TComponent; override;
  630.     function GetTextBuf(Buffer: PChar; BufSize: Integer): Integer;
  631.     function GetTextLen: Integer;
  632.     function HasParent: Boolean; override;
  633.     procedure Hide;
  634.     procedure InitiateAction; virtual;
  635.     procedure Invalidate; virtual;
  636.     function IsRightToLeft: Boolean;
  637.     function ManualDock(NewDockSite: TWinControl; DropControl: TControl = nil;
  638.       ControlSide: TAlign = alNone): Boolean;
  639.     function ManualFloat(ScreenPos: TRect): Boolean;
  640.     function Perform(Msg: Cardinal; WParam, LParam: Longint): Longint;
  641.     procedure Refresh;
  642.     procedure Repaint; virtual;
  643.     function ReplaceDockedControl(Control: TControl; NewDockSite: TWinControl;
  644.       DropControl: TControl; ControlSide: TAlign): Boolean;
  645.     function ScreenToClient(const Point: TPoint): TPoint;
  646.     procedure SendToBack;
  647.     procedure SetBounds(ALeft, ATop, AWidth, AHeight: Integer); virtual;
  648.     procedure SetTextBuf(Buffer: PChar);
  649.     procedure Show;
  650.     procedure Update; virtual;
  651.     function UseRightToLeftAlignment: Boolean; dynamic;
  652.     function UseRightToLeftReading: Boolean;
  653.     function UseRightToLeftScrollBar: Boolean;
  654.     property Action: TBasicAction;
  655.     property Align: TAlign default alNone;
  656.     property Anchors: TAnchors default [akLeft, akTop];
  657.     property BiDiMode: TBiDiMode;
  658.     property BoundsRect: TRect;
  659.     property ClientHeight: Integer;
  660.     property ClientOrigin: TPoint;
  661.     property ClientRect: TRect;
  662.     property ClientWidth: Integer;
  663.     property Constraints: TSizeConstraints;
  664.     property ControlState: TControlState;
  665.     property ControlStyle: TControlStyle;
  666.     property DockOrientation: TDockOrientation;
  667.     property Floating: Boolean;
  668.     property FloatingDockSiteClass: TWinControlClass;
  669.     property HostDockSite: TWinControl;
  670.     property LRDockWidth: Integer;
  671.     property Parent: TWinControl;
  672.     property ShowHint: Boolean;
  673.     property TBDockHeight: Integer;
  674.     property UndockHeight: Integer;
  675.     property UndockWidth: Integer;
  676.     property Visible: Boolean default True;
  677.     property WindowProc: TWndMethod;
  678.   published
  679.     property Left: Integer;
  680.     property Top: Integer;
  681.     property Width: Integer;
  682.     property Height: Integer;
  683.     property Cursor: TCursor default crDefault;
  684.     property Hint: string;
  685.   end;
  686.  
  687.   TControlClass = class of TControl;
  688.  
  689.   TCreateParams = record
  690.     Caption: PChar;
  691.     Style: DWORD;
  692.     ExStyle: DWORD;
  693.     X, Y: Integer;
  694.     Width, Height: Integer;
  695.     WndParent: HWnd;
  696.     Param: Pointer;
  697.     WindowClass: TWndClass;
  698.     WinClassName: array[0..63] of Char;
  699.   end;
  700.  
  701. { TWinControlActionLink }
  702.  
  703.   TWinControlActionLink = class(TControlActionLink)
  704.   protected
  705.     FClient: TWinControl;
  706.     procedure AssignClient(AClient: TObject); override;
  707.     function IsHelpContextLinked: Boolean; override;
  708.     procedure SetHelpContext(Value: THelpContext); override;
  709.   end;
  710.  
  711.   TWinControlActionLinkClass = class of TWinControlActionLink;
  712.  
  713. { TWinControl }
  714.  
  715.   TImeMode = (imDisable, imClose, imOpen, imDontCare,
  716.               imSAlpha, imAlpha, imHira, imSKata, imKata,
  717.               imChinese, imSHanguel, imHanguel);
  718.   TImeName = type string;
  719.  
  720.   TBorderWidth = 0..MaxInt;
  721.  
  722.   TBevelCut = (bvNone, bvLowered, bvRaised, bvSpace);
  723.   TBevelEdge = (beLeft, beTop, beRight, beBottom);
  724.   TBevelEdges = set of TBevelEdge;
  725.   TBevelKind = (bkNone, bkTile, bkSoft, bkFlat);
  726.   TBevelWidth = 1..MaxInt;
  727.  
  728.   // IDockManager defines an interface for managing a dock site's docked
  729.   // controls. The default VCL implementation of IDockManager is TDockTree.
  730.   IDockManager = interface
  731.     ['{8619FD79-C281-11D1-AA60-00C04FA370E8}']
  732.     procedure BeginUpdate;
  733.     procedure EndUpdate;
  734.     procedure GetControlBounds(Control: TControl; out CtlBounds: TRect);
  735.     procedure InsertControl(Control: TControl; InsertAt: TAlign;
  736.       DropCtl: TControl);
  737.     procedure LoadFromStream(Stream: TStream);
  738.     procedure PaintSite(DC: HDC);
  739.     procedure PositionDockRect(Client, DropCtl: TControl; DropAlign: TAlign;
  740.       var DockRect: TRect);
  741.     procedure RemoveControl(Control: TControl);
  742.     procedure ResetBounds(Force: Boolean);
  743.     procedure SaveToStream(Stream: TStream);
  744.     procedure SetReplacingControl(Control: TControl);
  745.   end;
  746.  
  747.   TWinControl = class(TControl)
  748.   protected
  749.     FDoubleBuffered: Boolean;
  750.     FInImeComposition: Boolean;
  751.     procedure ActionChange(Sender: TObject; CheckDefaults: Boolean); override;
  752.     procedure AddBiDiModeExStyle(var ExStyle: DWORD);
  753.     procedure AssignTo(Dest: TPersistent); override;
  754.     procedure AdjustClientRect(var Rect: TRect); virtual;
  755.     procedure AdjustSize; override;
  756.     procedure AlignControls(AControl: TControl; var Rect: TRect); virtual;
  757.     function CanAutoSize(var NewWidth, NewHeight: Integer): Boolean; override;
  758.     function CanResize(var NewWidth, NewHeight: Integer): Boolean; override;
  759.     procedure ChangeScale(M, D: Integer); override;
  760.     procedure ConstrainedResize(var MinWidth, MinHeight, MaxWidth,
  761.       MaxHeight: Integer); override;
  762.     function CreateDockManager: IDockManager; dynamic;
  763.     procedure CreateHandle; virtual;
  764.     procedure CreateParams(var Params: TCreateParams); virtual;
  765.     procedure CreateSubClass(var Params: TCreateParams;
  766.       ControlClassName: PChar);
  767.     procedure CreateWindowHandle(const Params: TCreateParams); virtual;
  768.     procedure CreateWnd; virtual;
  769.     procedure DestroyHandle;
  770.     procedure DestroyWindowHandle; virtual;
  771.     procedure DestroyWnd; virtual;
  772.     procedure DoAddDockClient(Client: TControl; const ARect: TRect); dynamic;
  773.     procedure DockOver(Source: TDragDockObject; X, Y: Integer; State: TDragState;
  774.       var Accept: Boolean); dynamic;
  775.     procedure DoDockOver(Source: TDragDockObject; X, Y: Integer; State: TDragState;
  776.       var Accept: Boolean); dynamic;
  777.     procedure DoEnter; dynamic;
  778.     procedure DoExit; dynamic;
  779.     procedure DoFlipChildren; dynamic;
  780.     function DoKeyDown(var Message: TWMKey): Boolean;
  781.     function DoKeyPress(var Message: TWMKey): Boolean;
  782.     function DoKeyUp(var Message: TWMKey): Boolean;
  783.     function DoMouseWheel(Shift: TShiftState; WheelDelta: Integer;
  784.       MousePos: TPoint): Boolean; dynamic;
  785.     function DoMouseWheelDown(Shift: TShiftState; MousePos: TPoint): Boolean; dynamic;
  786.     function DoMouseWheelUp(Shift: TShiftState; MousePos: TPoint): Boolean; dynamic;
  787.     procedure DoRemoveDockClient(Client: TControl); dynamic;
  788.     function DoUnDock(NewTarget: TWinControl; Client: TControl): Boolean; dynamic;
  789.     function FindNextControl(CurControl: TWinControl;
  790.       GoForward, CheckTabStop, CheckParent: Boolean): TWinControl;
  791.     procedure FixupTabList;
  792.     function GetActionLinkClass: TControlActionLinkClass; override;
  793.     procedure GetChildren(Proc: TGetChildProc; Root: TComponent); override;
  794.     function GetClientOrigin: TPoint; override;
  795.     function GetClientRect: TRect; override;
  796.     function GetControlExtents: TRect; virtual;
  797.     function GetDeviceContext(var WindowHandle: HWnd): HDC; override;
  798.     function GetParentHandle: HWnd;
  799.     procedure GetSiteInfo(Client: TControl; var InfluenceRect: TRect;
  800.       MousePos: TPoint; var CanDock: Boolean); dynamic;
  801.     function GetTopParentHandle: HWnd;
  802.     function IsControlMouseMsg(var Message: TWMMouse): Boolean;
  803.     procedure KeyDown(var Key: Word; Shift: TShiftState); dynamic;
  804.     procedure KeyUp(var Key: Word; Shift: TShiftState); dynamic;
  805.     procedure KeyPress(var Key: Char); dynamic;
  806.     procedure MainWndProc(var Message: TMessage);
  807.     procedure NotifyControls(Msg: Word);
  808.     procedure PaintControls(DC: HDC; First: TControl);
  809.     procedure PaintHandler(var Message: TWMPaint);
  810.     procedure PaintWindow(DC: HDC); virtual;
  811.     function PaletteChanged(Foreground: Boolean): Boolean; override;
  812.     procedure ReadState(Reader: TReader); override;
  813.     procedure RecreateWnd;
  814.     procedure ReloadDockedControl(const AControlName: string;
  815.       var AControl: TControl); dynamic;
  816.     procedure ResetIme;
  817.     function ResetImeComposition(Action: DWORD): Boolean;
  818.     procedure ScaleControls(M, D: Integer);
  819.     procedure SelectFirst;
  820.     procedure SelectNext(CurControl: TWinControl;
  821.       GoForward, CheckTabStop: Boolean);
  822.     procedure SetChildOrder(Child: TComponent; Order: Integer); override;
  823.     procedure SetIme;
  824.     function SetImeCompositionWindow(Font: TFont; XPos, YPos: Integer): Boolean;
  825.     procedure SetZOrder(TopMost: Boolean); override;
  826.     procedure ShowControl(AControl: TControl); virtual;
  827.     procedure WndProc(var Message: TMessage); override;
  828.     property BevelEdges: TBevelEdges default [beLeft, beTop, beRight, beBottom];
  829.     property BevelInner: TBevelCut index 0 default bvRaised;
  830.     property BevelOuter: TBevelCut index 1 default bvLowered;
  831.     property BevelKind: TBevelKind default bkNone;
  832.     property BevelWidth: TBevelWidth default 1;
  833.     property BorderWidth: TBorderWidth default 0;
  834.     property Ctl3D: Boolean;
  835.     property DefWndProc: Pointer;
  836.     property DockSite: Boolean default False;
  837.     property DockManager: IDockManager;
  838.     property ImeMode: TImeMode default imDontCare;
  839.     property ImeName: TImeName;
  840.     property ParentCtl3D: Boolean default True;
  841.     property UseDockManager: Boolean default False;
  842.     property WheelAccumulator: Integer;
  843.     property WindowHandle: HWnd;
  844.     property OnDockDrop: TDockDropEvent;
  845.     property OnDockOver: TDockOverEvent;
  846.     property OnEnter: TNotifyEvent;
  847.     property OnExit: TNotifyEvent;
  848.     property OnGetSiteInfo: TGetSiteInfoEvent;
  849.     property OnKeyDown: TKeyEvent;
  850.     property OnKeyPress: TKeyPressEvent;
  851.     property OnKeyUp: TKeyEvent;
  852.     property OnMouseWheel: TMouseWheelEvent;
  853.     property OnMouseWheelDown: TMouseWheelUpDownEvent;
  854.     property OnMouseWheelUp: TMouseWheelUpDownEvent;
  855.     property OnUnDock: TUnDockEvent;
  856.   public
  857.     constructor Create(AOwner: TComponent); override;
  858.     constructor CreateParented(ParentWindow: HWnd);
  859.     class function CreateParentedControl(ParentWindow: HWnd): TWinControl;
  860.     destructor Destroy; override;
  861.     procedure Broadcast(var Message);
  862.     function CanFocus: Boolean; dynamic;
  863.     function ContainsControl(Control: TControl): Boolean;
  864.     function ControlAtPos(const Pos: TPoint; AllowDisabled: Boolean;
  865.       AllowWinControls: Boolean = False): TControl;
  866.     procedure DefaultHandler(var Message); override;
  867.     procedure DisableAlign;
  868.     property DockClientCount: Integer;
  869.     property DockClients[Index: Integer]: TControl;
  870.     procedure DockDrop(Source: TDragDockObject; X, Y: Integer); dynamic;
  871.     property DoubleBuffered: Boolean;
  872.     procedure EnableAlign;
  873.     function FindChildControl(const ControlName: string): TControl;
  874.     procedure FlipChildren(AllLevels: Boolean); dynamic;
  875.     function Focused: Boolean; dynamic;
  876.     procedure GetTabOrderList(List: TList); dynamic;
  877.     function HandleAllocated: Boolean;
  878.     procedure HandleNeeded;
  879.     procedure InsertControl(AControl: TControl);
  880.     procedure Invalidate; override;
  881.     procedure MouseWheelHandler(var Message: TMessage); dynamic;
  882.     procedure PaintTo(DC: HDC; X, Y: Integer);
  883.     procedure RemoveControl(AControl: TControl);
  884.     procedure Realign;
  885.     procedure Repaint; override;
  886.     procedure ScaleBy(M, D: Integer);
  887.     procedure ScrollBy(DeltaX, DeltaY: Integer);
  888.     procedure SetBounds(ALeft, ATop, AWidth, AHeight: Integer); override;
  889.     procedure SetFocus; virtual;
  890.     procedure Update; override;
  891.     procedure UpdateControlState;
  892.     property VisibleDockClientCount: Integer;
  893.     property Brush: TBrush;
  894.     property Controls[Index: Integer]: TControl;
  895.     property ControlCount: Integer;
  896.     property Handle: HWnd;
  897.     property ParentWindow: HWnd;
  898.     property Showing: Boolean;
  899.     property TabOrder: TTabOrder default -1;
  900.     property TabStop: Boolean default False;
  901.   published
  902.     property HelpContext: THelpContext default 0;
  903.   end;
  904.  
  905.   TGraphicControl = class(TControl)
  906.   protected
  907.     procedure Paint; virtual;
  908.     property Canvas: TCanvas;
  909.   public
  910.     constructor Create(AOwner: TComponent); override;
  911.     destructor Destroy; override;
  912.   end;
  913.  
  914.   TCustomControl = class(TWinControl)
  915.   protected
  916.     procedure Paint; virtual;
  917.     procedure PaintWindow(DC: HDC); override;
  918.     property Canvas: TCanvas;
  919.   public
  920.     constructor Create(AOwner: TComponent); override;
  921.     destructor Destroy; override;
  922.   end;
  923.  
  924.   THintWindow = class(TCustomControl)
  925.   protected
  926.     procedure CreateParams(var Params: TCreateParams); override;
  927.     procedure Paint; override;
  928.   public
  929.     constructor Create(AOwner: TComponent); override;
  930.     procedure ActivateHint(Rect: TRect; const AHint: string); virtual;
  931.     procedure ActivateHintData(Rect: TRect; const AHint: string; AData: Pointer); virtual;
  932.     function CalcHintRect(MaxWidth: Integer; const AHint: string;
  933.       AData: Pointer): TRect; virtual;
  934.     function IsHintMsg(var Msg: TMsg): Boolean; virtual;
  935.     procedure ReleaseHandle;
  936.     property BiDiMode;
  937.     property Caption;
  938.     property Color;
  939.     property Canvas;
  940.     property Font;
  941.   end;
  942.  
  943.   THintWindowClass = class of THintWindow;
  944.  
  945. { TDragImageList }
  946.  
  947.   TDragImageList = class(TCustomImageList)
  948.   protected
  949.     procedure Initialize; override;
  950.   public
  951.     function BeginDrag(Window: HWND; X, Y: Integer): Boolean;
  952.     function DragLock(Window: HWND; XPos, YPos: Integer): Boolean;
  953.     function DragMove(X, Y: Integer): Boolean;
  954.     procedure DragUnlock;
  955.     function EndDrag: Boolean;
  956.     function GetHotSpot: TPoint; override;
  957.     procedure HideDragImage;
  958.     function SetDragImage(Index, HotSpotX, HotSpotY: Integer): Boolean;
  959.     procedure ShowDragImage;
  960.     property DragCursor: TCursor;
  961.     property Dragging: Boolean;
  962.   end;
  963.  
  964. { TImageList }
  965.  
  966.   TImageList = class(TDragImageList)
  967.   published
  968.     property BlendColor;
  969.     property BkColor;
  970.     property AllocBy;
  971.     property DrawingStyle;
  972.     property Height;
  973.     property ImageType;
  974.     property Masked;
  975.     property OnChange;
  976.     property ShareImages;
  977.     property Width;
  978.   end;
  979.  
  980. { TDockZone }
  981.  
  982.   TDockTree = class;
  983.  
  984.   // TDockZone encapsulates a region into which other zones are contained.
  985.   // A TDockZone can be a parent to other zones (when FChildZones <> nil) or
  986.   // can contain only a control (when FChildControl <> nil).  A TDockZone also
  987.   // stores pointers to previous and next siblings and its parent.  Parents
  988.   // store a pointer to only the first child in a doubly-linked list of child
  989.   // zones, though each child maintains a pointer to its parent.  Thus, the
  990.   // data structure of relating TDockZones works out to a kind of a
  991.   // doubly-linked list tree.  The FZoneLimit field of TDockZone represents
  992.   // the coordinate of either the left or bottom of the zone, depending on
  993.   // whether its parent zone's orientation is doVertical or doHorizontal.
  994.   TDockZone = class
  995.   public
  996.     constructor Create(Tree: TDockTree);
  997.     procedure ResetChildren;
  998.     procedure Update;
  999.     property ChildCount: Integer;
  1000.     property Height: Integer index Ord(doHorizontal);
  1001.     property Left: Integer index Ord(doVertical);
  1002.     property LimitBegin: Integer;
  1003.     property LimitSize: Integer;
  1004.     property Top: Integer index Ord(doHorizontal);
  1005.     property Width: Integer index Ord(doVertical);
  1006.   end;
  1007.  
  1008. { TDockTree }
  1009.  
  1010.   TForEachZoneProc = procedure(Zone: TDockZone) of object;
  1011.  
  1012.   TDockTreeClass = class of TDockTree;
  1013.  
  1014.   // TDockTree serves as a manager for a tree of TDockZones.  It is responsible
  1015.   // for inserting and removing controls (and thus zones) from the tree and
  1016.   // associated housekeeping, such as orientation, zone limits, parent zone
  1017.   // creation, and painting of controls into zone bounds.
  1018.   TDockTree = class(TInterfacedObject, IDockManager)
  1019.   protected
  1020.     procedure AdjustDockRect(Control: TControl; var ARect: TRect); virtual;
  1021.     procedure BeginUpdate;
  1022.     procedure EndUpdate;
  1023.     procedure GetControlBounds(Control: TControl; out CtlBounds: TRect);
  1024.     function HitTest(const MousePos: TPoint; out HTFlag: Integer): TControl; virtual;
  1025.     procedure InsertControl(Control: TControl; InsertAt: TAlign;
  1026.       DropCtl: TControl); virtual;
  1027.     procedure LoadFromStream(Stream: TStream); virtual;
  1028.     procedure PaintDockFrame(Canvas: TCanvas; Control: TControl;
  1029.       const ARect: TRect); virtual;
  1030.     procedure PositionDockRect(Client, DropCtl: TControl; DropAlign: TAlign;
  1031.       var DockRect: TRect); virtual;
  1032.     procedure RemoveControl(Control: TControl); virtual;
  1033.     procedure SaveToStream(Stream: TStream); virtual;
  1034.     procedure SetReplacingControl(Control: TControl);
  1035.     procedure ResetBounds(Force: Boolean); virtual;
  1036.     procedure UpdateAll;
  1037.     property DockSite: TWinControl;
  1038.   public
  1039.     constructor Create(DockSite: TWinControl); virtual;
  1040.     destructor Destroy; override;
  1041.     procedure PaintSite(DC: HDC); virtual;
  1042.   end;
  1043.  
  1044. { Mouse support }
  1045.  
  1046.   TMouse = class
  1047.   public
  1048.     constructor Create;
  1049.     destructor Destroy; override;
  1050.     procedure SettingChanged(Setting: Integer);
  1051.     property Capture: HWND;
  1052.     property CursorPos: TPoint;
  1053.     property DragImmediate: Boolean default True;
  1054.     property DragThreshold: Integer default 5;
  1055.     property MousePresent: Boolean;
  1056.     property RegWheelMessage: UINT;
  1057.     property WheelPresent: Boolean;
  1058.     property WheelScrollLines: Integer;
  1059.   end;
  1060.  
  1061. var
  1062.   Mouse: TMouse;
  1063.  
  1064. { Drag stuff }
  1065.  
  1066. function IsDragObject(Sender: TObject): Boolean;
  1067. function FindControl(Handle: HWnd): TWinControl;
  1068. function FindVCLWindow(const Pos: TPoint): TWinControl;
  1069. function FindDragTarget(const Pos: TPoint; AllowDisabled: Boolean): TControl;
  1070. function GetCaptureControl: TControl;
  1071. procedure SetCaptureControl(Control: TControl);
  1072. procedure CancelDrag;
  1073.  
  1074. { Misc }
  1075.  
  1076. function CursorToString(Cursor: TCursor): string;
  1077. function StringToCursor(const S: string): TCursor;
  1078. procedure GetCursorValues(Proc: TGetStrProc);
  1079. function CursorToIdent(Cursor: Longint; var Ident: string): Boolean;
  1080. function IdentToCursor(const Ident: string; var Cursor: Longint): Boolean;
  1081.  
  1082. function GetShortHint(const Hint: string): string;
  1083. function GetLongHint(const Hint: string): string;
  1084.  
  1085. var
  1086.   CreationControl: TWinControl = nil;
  1087.   DefaultDockTreeClass: TDockTreeClass = TDockTree;
  1088.   
  1089. function InitWndProc(HWindow: HWnd; Message, WParam: Longint;
  1090.   LParam: Longint): Longint; stdcall;
  1091.  
  1092. const
  1093.   CTL3D_ALL = $FFFF;
  1094.   NullDockSite = TWinControl($FFFFFFFF);
  1095.   AnchorAlign: array[TAlign] of TAnchors = (
  1096.     { alNone }
  1097.     [akLeft, akTop],
  1098.     { alTop }
  1099.     [akLeft, akTop, akRight],
  1100.     { alBottom }
  1101.     [akLeft, akRight, akBottom],
  1102.     { alLeft }
  1103.     [akLeft, akTop, akBottom],
  1104.     { alRight }
  1105.     [akRight, akTop, akBottom],
  1106.     { alClient }
  1107.     [akLeft, akTop, akRight, akBottom]);
  1108.  
  1109. var
  1110.   NewStyleControls: Boolean;
  1111.  
  1112. procedure ChangeBiDiModeAlignment(var Alignment: TAlignment);
  1113.  
  1114. function SendAppMessage(Msg: Cardinal; WParam, LParam: Longint): Longint;
  1115. procedure MoveWindowOrg(DC: HDC; DX, DY: Integer);
  1116.  
  1117. procedure SetImeMode(hWnd: HWND; Mode: TImeMode);
  1118. procedure SetImeName(Name: TImeName);
  1119. function Win32NLSEnableIME(hWnd: HWND; Enable: Boolean): Boolean;
  1120. function Imm32GetContext(hWnd: HWND): HIMC;
  1121. function Imm32ReleaseContext(hWnd: HWND; hImc: HIMC): Boolean;
  1122. function Imm32GetConversionStatus(hImc: HIMC; var Conversion, Sentence: DWORD): Boolean;
  1123. function Imm32SetConversionStatus(hImc: HIMC; Conversion, Sentence: DWORD): Boolean;
  1124. function Imm32SetOpenStatus(hImc: HIMC; fOpen: Boolean): Boolean;
  1125. function Imm32SetCompositionWindow(hImc: HIMC; lpCompForm: PCOMPOSITIONFORM): Boolean;
  1126. function Imm32SetCompositionFont(hImc: HIMC; lpLogfont: PLOGFONTA): Boolean;
  1127. function Imm32GetCompositionString(hImc: HIMC; dWord1: DWORD; lpBuf: pointer; dwBufLen: DWORD): Longint;
  1128. function Imm32IsIME(hKl: HKL): Boolean;
  1129. function Imm32NotifyIME(hImc: HIMC; dwAction, dwIndex, dwValue: DWORD): Boolean;
  1130.  
  1131. implementation
  1132.