home *** CD-ROM | disk | FTP | other *** search
/ Chip: Shareware for Win 95 / Chip-Shareware-Win95.bin / ostatni / delphi / delphi2 / datetime.exe / 32BIT / DATETIME.PAS < prev    next >
Pascal/Delphi Source File  |  1996-10-14  |  34KB  |  1,308 lines
  1. unit Datetime;
  2.  
  3. {************************************************************}
  4. {*  TDateTime and TDBDateTime components (32 bit version)   *}
  5. {*  Completed: 14 October 1996                              *}
  6. {*  Developed By: John Stathakis                            *}
  7. {*  E-Mail: Jlstath@mail.icon.co.za                         *}
  8. {*  read the readme.txt file for more info                  *}
  9. {************************************************************}
  10.  
  11. interface
  12.  
  13. uses
  14.   SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls,
  15.   Forms, Dialogs, StdCtrls, Buttons, spin, ExtCtrls, Calendar, db, dbTables,
  16.   StdComps;
  17.  
  18. type
  19.   TIncrementScale = (Year, Month, Week, Day, Hour, Minute, Second);
  20.   TButtonOption = (btnCalendar, btnClock, btnIncrement);
  21.   TButtonOptions = Set of TButtonOption;
  22.  
  23.   TFormSetIncrement = class(TForm)
  24.     BtnClose: TBitBtn;
  25.     SEIncrementBy: TSpinEdit;
  26.     CBIncrementScale: TComboBox;
  27.     Label1: TLabel;
  28.     Label2: TLabel;
  29.     procedure BtnCloseClick(Sender: TObject);
  30.   private
  31.     { Private declarations }
  32.   public
  33.     procedure SetIncrementScale(IncScale: TIncrementScale);
  34.     procedure SetIncrementBy(incBy: Integer);
  35.     function GetIncrementScale: TIncrementScale;
  36.     function GetIncrementBy: Integer;
  37.   end;
  38.  
  39.   TFormClock = class(TForm)
  40.     Panel3: TPanel;
  41.     BtnSelect: TBitBtn;
  42.     BtnCancel: TBitBtn;
  43.     Panel2: TPanel;
  44.     Label1: TLabel;
  45.     Label2: TLabel;
  46.     Label3: TLabel;
  47.     Label4: TLabel;
  48.     SEHour: TSpinEdit;
  49.     SEDmin: TSpinEdit;
  50.     SEDsec: TSpinEdit;
  51.     EditAmPm: TEdit;
  52.     SBAmPm: TSpinButton;
  53.     PBClock: TPaintBox;
  54.     SEMin: TSpinEdit;
  55.     SESec: TSpinEdit;
  56.     procedure FormCreate(Sender: TObject);
  57.     procedure FormDestroy(Sender: TObject);
  58.     procedure FormPaint(Sender: TObject);
  59.     procedure SBAmPmDownClick(Sender: TObject);
  60.     procedure SEDsecChange(Sender: TObject);
  61.     procedure SEHourChange(Sender: TObject);
  62.     procedure SEDminChange(Sender: TObject);
  63.     procedure BtnCancelClick(Sender: TObject);
  64.     procedure BtnSelectClick(Sender: TObject);
  65.     procedure SEMinChange(Sender: TObject);
  66.     procedure SESecChange(Sender: TObject);
  67.   private
  68.     FPen: TPen;
  69.     CentrePt : TPoint;
  70.     {Clock Centre}
  71.     Radius : integer;
  72.     {Clock Radius}
  73.     RectWidth : integer;
  74.     {Width of Clock rectangles}
  75.     ClockTime, SelectedTime: TDateTime;
  76.     {Internal Clock time and selected clock time}
  77.     function MinuteAngle(Min: word): real;
  78.     {Minute Hand angle}
  79.     function HourAngle(Hour, Min: word): real;
  80.     {Hour Hand angle}
  81.     procedure CalculateAngles;
  82.     procedure DrawMinBlocks;
  83.     procedure DrawClockFace;
  84.     {Draw clock face on window}
  85.     procedure DrawHand(Angle, Scale : real; AWidth : integer);
  86.     {Draw a clock hand}
  87.     procedure DrawHands;
  88.     {Draw clock Hands}
  89.     procedure SetTime;
  90.     {The following procedures rectify overflow on the
  91.      spin edits}
  92.     procedure FixHour;
  93.     procedure FixDmin;
  94.     procedure FixMin;
  95.     procedure FixDsec;
  96.     procedure FixSec;
  97.   public
  98.     function GetClkTime: TDateTime;
  99.     {Get clock time}
  100.     procedure SetClkTime(H, M, S: Word);
  101.     {Set Clock Time}
  102.     procedure SetClkDateTime(ClkTime: TDateTime);
  103.     {Set Clock Time from TDateTime}
  104.   end;
  105.  
  106.  
  107.   TFormCalendar = class(TForm)
  108.     Panel2: TPanel;
  109.     Label1: TLabel;
  110.     Label2: TLabel;
  111.     CBMonth: TComboBox;
  112.     Panel1: TPanel;
  113.     Calendar1: TCalendar;
  114.     Panel3: TPanel;
  115.     BtnSelect: TBitBtn;
  116.     SEYear: TSpinEdit;
  117.     BtnCancel: TBitBtn;
  118.     procedure SEYearChange(Sender: TObject);
  119.     procedure CBMonthChange(Sender: TObject);
  120.     procedure Calendar1DblClick(Sender: TObject);
  121.     procedure FormKeyDown(Sender: TObject; var Key: Word;
  122.       Shift: TShiftState);
  123.     procedure BtnSelectClick(Sender: TObject);
  124.     procedure UpdateDate(Y, M, D: Word);
  125.     procedure BtnCancelClick(Sender: TObject);
  126.   private
  127.     SelectedDateTime: TDateTime;
  128.     procedure SelectDate;
  129.   public
  130.     procedure SetDate(Y, M, D: Word);
  131.     procedure SetDateTime(DT: TDateTime);
  132.     function GetDateTime:TDateTime;
  133.   end;
  134.  
  135.  
  136.   TDateTimeDlg = class(TEdit)
  137.   private
  138.     FAbout: TAbout;
  139.     {Dummy for about property editor}
  140.     {
  141.     Buttons}
  142.     FButtons: TButtonOptions;
  143.  
  144.     FUpButton: TComponentButton;
  145.     FDownButton: TComponentButton;
  146.     FCalendarButton: TComponentButton;
  147.     FClockButton: TComponentButton;
  148.     FFocusedButton: TComponentButton;
  149.  
  150.     FEnableEditor: Boolean;
  151.     FIncrementScale: TIncrementScale;
  152.     FIncrementBy: Integer;
  153.     FIncrementBtns: Boolean;
  154.  
  155.     procedure KeyDown(var Key: Word; Shift: TShiftState); override;
  156.     procedure BtnMouseDown (Sender: TObject; Button: TMouseButton;
  157.                  Shift: TShiftState; X, Y: Integer);
  158.  
  159.     procedure SetFocusBtn (Btn: TComponentButton);
  160.     {
  161.     Setting & getting properties}
  162.     procedure SetUpGlyph(Value: TBitmap);
  163.     procedure SetDownGlyph(Value: TBitmap);
  164.     procedure SetCalendarGlyph(Value: TBitmap);
  165.     procedure SetClockGlyph(Value: TBitmap);
  166.     function GetUpGlyph: TBitmap;
  167.     function GetDownGlyph: TBitmap;
  168.     function GetCalendarGlyph: TBitmap;
  169.     function GetClockGlyph: TBitmap;
  170.     procedure SetNumUpGlyphs(Value: TNumGlyphs);
  171.     procedure SetNumDownGlyphs(Value: TNumGlyphs);
  172.     procedure SetNumCalendarGlyphs(Value: TNumGlyphs);
  173.     procedure SetNumClockGlyphs(Value: TNumGlyphs);
  174.     function GetNumUpGlyphs: TNumGlyphs;
  175.     function GetNumDownGlyphs: TNumGlyphs;
  176.     function GetNumCalendarGlyphs: TNumGlyphs;
  177.     function GetNumClockGlyphs: TNumGlyphs;
  178.     procedure SetButtons(Value: TButtonOptions);
  179.     function GetButtons: TButtonOptions;
  180.     procedure SetEnableEditor(Value: Boolean);
  181.     procedure SetIncrementBtns(Value: Boolean);
  182.     procedure SetIncrementBy(Value: Integer);
  183.     {
  184.     For sizing and redrawing}
  185.     procedure DrawButtons;
  186.     function GetMinHeight: Integer;
  187.     procedure SetEditRect;
  188.     procedure WMSize(var Message: TWMSize); message WM_SIZE;
  189.     procedure CMEnter(var Message: TCMGotFocus); message CM_ENTER;
  190.     {
  191.     Cutting and Pasting}
  192.     procedure WMPaste(var Message: TWMPaste);   message WM_PASTE;
  193.     procedure WMCut(var Message: TWMCut);   message WM_CUT;
  194.     {
  195.     increment}
  196.     procedure IncDateTime(Down: Boolean);
  197.   protected
  198.     procedure CreateParams(var Params: TCreateParams); override;
  199.     procedure CreateWnd; override;
  200.     procedure UpClick (Sender: TObject); virtual;
  201.     procedure DownClick (Sender: TObject); virtual;
  202.     procedure CalendarClick (Sender: TObject); virtual;
  203.     procedure ClockClick (Sender: TObject); virtual;
  204.     procedure IncOnMouseDown(Sender: TObject; Button: TMouseButton;
  205.                  Shift: TShiftState; X, Y: Integer); virtual;
  206.   public
  207.     constructor Create(AOwner: TComponent); override;
  208.     destructor Destroy; override;
  209.   published
  210.     property About: TAbout read FAbout;
  211.     property BtnUpGlyph: TBitmap read GetUpGlyph write SetUpGlyph;
  212.     property BtnDownGlyph: TBitmap read GetDownGlyph write SetDownGlyph;
  213.     property BtnCalendarGlyph: TBitmap read GetCalendarGlyph write SetCalendarGlyph;
  214.     property BtnClockGlyph: TBitmap read GetClockGlyph write SetClockGlyph;
  215.     property NumUpGlyphs: TNumGlyphs read GetNumUpGlyphs write SetNumUpGlyphs;
  216.     property NumDownGlyphs: TNumGlyphs read GetNumDownGlyphs write SetNumDownGlyphs;
  217.     property NumCalendarGlyphs: TNumGlyphs read GetNumCalendarGlyphs write SetNumCalendarGlyphs;
  218.     property NumClockGlyphs: TNumGlyphs read GetNumClockGlyphs write SetNumClockGlyphs;
  219.     property Buttons: TButtonOptions read GetButtons write SetButtons default [btnCalendar];
  220.     property EnableEditor: Boolean read FEnableEditor write SetEnableEditor;
  221.     property IncrementScale: TIncrementScale read FIncrementScale write FIncrementScale;
  222.     property IncrementBy: Integer read FIncrementBy write SetIncrementBy;
  223.   end;
  224.  
  225.   TDBDateTimeDlg = class(TDateTimeDlg)
  226.   private
  227.     FDataLink: TFieldDataLink;
  228.     Procedure DataChange(sender:Tobject);
  229.     function getDataField: String;
  230.     Function GetDataSource : TDataSource;
  231.     Procedure SetDataField(const value:String);
  232.     Procedure SetDataSource(value : TDataSource);
  233.     Procedure UpdateData(Sender:Tobject);
  234.   protected
  235.     Procedure KeyDown(Var Key:Word;Shift:TShiftState); override;
  236.     procedure Change; override;
  237.     procedure Notification(AComponent: TComponent;
  238.       Operation: TOperation); override;
  239.     procedure CMExit(var Message: TCMExit); message CM_EXIT;
  240.   public
  241.     constructor Create(AOwner: TComponent); override;
  242.     destructor Destroy; override;
  243.     procedure UpClick (Sender: TObject); override;
  244.     procedure DownClick (Sender: TObject); override;
  245.     procedure CalendarClick (Sender: TObject); override;
  246.     procedure ClockClick (Sender: TObject); override;
  247.   published
  248.     Property DataField : string read GetDataField write SetDataField;
  249.     property DataSource: TDataSource read GetDataSource write SetDataSource;
  250.   end;
  251.  
  252.  
  253. procedure Register;
  254.  
  255. implementation
  256. {$R DateTime}
  257. {$R Clockdlg.dfm}
  258. {$R Calendlg.dfm}
  259. {$R SetInc.DFM}
  260.  
  261. {32 bit variables}
  262. const
  263. BtnOffset = 3;   {Offset on buttons to compensate for 32 bit environment}
  264.  
  265. procedure Register;
  266. begin
  267.   RegisterComponents('John', [TDateTimeDlg]);
  268.   RegisterComponents('John', [TDBDateTimeDlg]);
  269. end;
  270.  
  271. {TFormSetIncrement Implementation}
  272. procedure TFormSetIncrement.BtnCloseClick(Sender: TObject);
  273. begin
  274.   Close;
  275. end;
  276.  
  277. procedure TFormSetIncrement.SetIncrementScale(IncScale: TIncrementScale);
  278. begin
  279.   Case IncScale of
  280.   Year: CBIncrementScale.ItemIndex := 0;
  281.   Month: CBIncrementScale.ItemIndex := 1;
  282.   Week: CBIncrementScale.ItemIndex := 2;
  283.   Day: CBIncrementScale.ItemIndex := 3;
  284.   Hour: CBIncrementScale.ItemIndex := 4;
  285.   Minute: CBIncrementScale.ItemIndex := 5;
  286.   Second: CBIncrementScale.ItemIndex := 6;
  287.   end;
  288. end;
  289.  
  290. procedure TFormSetIncrement.SetIncrementBy(incBy: Integer);
  291. begin
  292.   SEIncrementBy.Value := IncBy;
  293. end;
  294.  
  295. function TFormSetIncrement.GetIncrementBy;
  296. begin
  297.   Result := SEIncrementBy.Value;
  298. end;
  299.  
  300. function TFormSetIncrement.GetIncrementScale: TIncrementScale;
  301. begin
  302.   Case CBIncrementScale.ItemIndex of
  303.   0: Result := Year;
  304.   1: Result := Month;
  305.   2: Result := Week;
  306.   3: Result := Day;
  307.   4: Result := Hour;
  308.   5: Result := Minute;
  309.   6: Result := Second;
  310.   end;
  311. end;
  312.  
  313. {TFormClock Implementation}
  314. procedure TFormClock.FormCreate(Sender: TObject);
  315. begin
  316.   {Create Pen}
  317.   FPen := TPen.Create;
  318.   SelectedTime := 0;
  319. end;
  320.  
  321. procedure TFormClock.FormDestroy(Sender: TObject);
  322. begin
  323.   FPen.Free;
  324. end;
  325.  
  326. function TFormClock.GetClkTime: TDateTime;
  327. {Get clock time}
  328. begin
  329.   If trunc(SelectedTime) = 0
  330.   then Result := SelectedTime + Date
  331.   else Result := SelectedTime;
  332. end;
  333.  
  334. procedure TFormClock.SetClkTime(H, M, S: Word);
  335. var
  336.   MS: Word;
  337. begin
  338.   If (H > 11) or (H < 0)
  339.   then begin
  340.     MessageDlg('Invalid Hour', mtError, [mbOK], 0);
  341.     exit;
  342.   end;
  343.   If (M > 59) or (M < 0)
  344.   then begin
  345.     MessageDlg('Invalid Minute', mtError, [mbOK], 0);
  346.     exit;
  347.   end;
  348.   If (S > 59) or (S < 0)
  349.   then begin
  350.     MessageDlg('Invalid Second', mtError, [mbOK], 0);
  351.     exit;
  352.   end;
  353.  
  354.   {Set Spin Edit Values}
  355.   SEHour.Value := H;
  356.   SEDmin.Value := M div 10;
  357.   SEMin.Value := M mod 10;
  358.   SEDsec.Value := S div 10;
  359.   SESec.Value := S mod 10;
  360.  
  361.   ClockTime := EncodeTime(H, M, S, MS);
  362.   SelectedTime := ClockTime;
  363.   invalidate;
  364. end;
  365.  
  366. procedure TFormClock.SetClkDateTime(ClkTime: TDateTime);
  367. var
  368.   H, M, S, MS: Word;
  369. begin
  370.   ClockTime := ClkTime;
  371.   SelectedTime := ClkTime;
  372.   DecodeTime(ClkTime, H, M, S, ms);
  373.  
  374.   {Convert from 24 mode to 12 hr mode}
  375.   If H > 12
  376.   then begin
  377.     EditAmPm.Text := 'pm';
  378.     H := H - 12;
  379.   end;
  380.  
  381.   {Set Spin Edit Values}
  382.   SEHour.Value := H;
  383.   SEDmin.Value := M div 10;
  384.   SEMin.Value := M mod 10;
  385.   SEDsec.Value := S div 10;
  386.   SESec.Value := S mod 10;
  387.  
  388.   invalidate;
  389. end;
  390.  
  391. function TFormClock.MinuteAngle( Min : word) : real;
  392. begin
  393.   MinuteAngle := Min*Pi/30;
  394. end;
  395.  
  396. function TFormClock.HourAngle( Hour, Min : word) : real;
  397. begin
  398.  HourAngle := (Hour MOD 12)*Pi/6 + MinuteAngle(Min)/12;
  399. end;
  400.  
  401. procedure TFormClock.DrawHand(Angle, Scale : real; AWidth : integer);
  402. var ScreenPos: real;
  403. begin
  404.   with PBClock.Canvas do
  405.   begin
  406.     Pen.Width := AWidth;
  407.     MoveTo(CentrePt.X, CentrePt.Y);
  408.     ScreenPos := Scale*Radius;
  409.     LineTo(trunc(ScreenPos*sin(Angle))+CentrePt.X,
  410.            trunc(-ScreenPos*cos(Angle))+CentrePt.Y);
  411.   end;
  412. end;
  413.  
  414. procedure TFormClock.DrawHands;
  415. var
  416.   H, M, S, ms : word;
  417.   ARect: TRect;
  418. begin
  419.   FPen.Color := ClHighlight;
  420.   with PBClock.Canvas do
  421.   begin
  422.     Pen := FPen;
  423.     Brush.Color := ClBtnFace;
  424.   end;
  425.  
  426.   DecodeTime(ClockTime, H, M, S, ms);
  427.   DrawHand(MinuteAngle(S), 1, 1);
  428.   DrawHand(MinuteAngle(M), 0.95, 3);
  429.   DrawHand(HourAngle(H, M), 0.60, 6);
  430.   PBClock.Canvas.Pen.Color := clHighlightText;
  431.   DrawHand(MinuteAngle(M), 0.95, 1);
  432.   DrawHand(HourAngle(H, M), 0.60, 1);
  433.  
  434.   ARect.Left := CentrePt.X-5;
  435.   ARect.Right := CentrePt.X+5;
  436.   ARect.Top := CentrePt.Y-5;
  437.   ARect.Bottom := CentrePt.Y+5;
  438.  
  439.   Frame3D(PBClock.Canvas, ARect, clHighlight, clBtnShadow, 6);
  440. end;
  441.  
  442. procedure TFormClock.CalculateAngles;
  443. begin
  444.   { Calc Center of clock face}
  445.   CentrePt := Point( PBClock.Width DIV 2, PBClock.Height DIV 2 );
  446.   { Calc Radius of clock}
  447.   with CentrePt do
  448.     if X <= Y then Radius := X
  449.     else           Radius := Y;
  450.  
  451.   RectWidth := Radius DIV 8;
  452.   if RectWidth < 6 then RectWidth := 6;
  453.  
  454.   dec( Radius, RectWidth + 2);
  455. end;
  456.  
  457. procedure TFormClock.DrawMinBlocks;
  458. var
  459.   OfsX, OfsY : integer;
  460.   MinCounter : word;
  461.   CurPt : TPoint;
  462.   TmpRect : TRect;
  463.   RadOff, Ang : real;
  464. begin
  465.   OfsX := RectWidth DIV 2; OfsY := OfsX;
  466.   for MinCounter := 0 to 11 do
  467.   begin
  468.     RadOff := Radius + OfsX;
  469.     Ang := MinuteAngle(MinCounter*5);
  470.     CurPt := Point(
  471.         trunc(RadOff*sin(Ang))+CentrePt.X, trunc(-RadOff*cos(Ang))+CentrePt.Y);
  472.     Case MinCounter*5 of
  473.     0,30:TmpRect := Rect(CurPt.X-4, CurPt.Y-10, CurPt.X+4, CurPt.Y+10);
  474.     15,45:TmpRect := Rect(CurPt.X-10, CurPt.Y-4, CurPt.X+10, CurPt.Y+4);
  475.     else
  476.       TmpRect := Rect(CurPt.X-2, CurPt.Y-2, CurPt.X+2, CurPt.Y+2);
  477.     end;
  478.     Frame3D(PBClock.Canvas, TmpRect, clHighlight, clBtnShadow, 6);
  479.   end;
  480. end;
  481.  
  482. procedure TFormClock.DrawClockFace;
  483. {Draw minute points on Panel}
  484. begin
  485.   with PBClock.Canvas do
  486.   begin
  487.     Brush.Style := bsSolid;
  488.     Brush.Color := ClBtnFace;
  489.     FillRect( ClipRect);
  490.   end;
  491.   DrawMinBlocks;
  492. end;
  493.  
  494. procedure TFormClock.FormPaint(Sender: TObject);
  495. begin
  496.   CalculateAngles;
  497.   DrawClockFace;
  498.   DrawHands;
  499. end;
  500.  
  501. procedure TFormClock.SetTime;
  502. var
  503.   Hr24: Word;
  504. begin
  505.   {Ensure date part is not lost}
  506.   If (EditAmPm.Text = 'pm')
  507.   then Hr24 := SEHour.Value + 12
  508.   else Hr24 := SEHour.Value;
  509.   ClockTime := EncodeTime(Hr24, (10*SEDmin.Value)+(SEMin.Value),
  510.         (10*SEDsec.Value)+(SESec.Value), 0) + Trunc(ClockTime);
  511.   Invalidate;
  512. end;
  513.  
  514. procedure TFormClock.FixHour;
  515. {Rectifies overflow on hour counter}
  516. begin
  517.   If SEHour.Value = 12
  518.   then begin
  519.     SEHour.Value := 0;
  520.     If EditAmPm.text = 'am'
  521.     then EditAmPm.text := 'pm'
  522.     else EditAmPm.text := 'am';
  523.   end;
  524. end;
  525.  
  526. procedure TFormClock.FixDmin;
  527. {Rectifies overflow on ten minute counter}
  528. begin
  529.   If SEDmin.Value = 6
  530.   then begin
  531.     SEDmin.Value := 0;
  532.     SEHour.Value := SEHour.Value + 1;
  533.     FixHour;
  534.   end;
  535. end;
  536.  
  537. procedure TFormClock.FixMin;
  538. {Rectifies overflow on minute counter}
  539. begin
  540.   If SEMin.Value = 10
  541.   then begin
  542.     SEMin.Value := 0;
  543.     SEDmin.Value := SEDmin.Value + 1;
  544.     FixDmin;
  545.   end;
  546. end;
  547.  
  548. procedure TFormClock.FixDsec;
  549. {Rectifies overflow on 10 second counter}
  550. begin
  551.   If SEDsec.Value = 6
  552.   then begin
  553.     SEDsec.Value := 0;
  554.     SEMin.Value := SEMin.Value + 1;
  555.     FixMin;
  556.   end;
  557. end;
  558.  
  559. procedure TFormClock.FixSec;
  560. {Rectifies overflow on second counter}
  561. begin
  562.   If SESec.Value = 10
  563.   then begin
  564.     SESec.Value := 0;
  565.     SEDsec.Value := SEDsec.Value + 1;
  566.     FixDsec;
  567.   end;
  568. end;
  569.  
  570. procedure TFormClock.SEHourChange(Sender: TObject);
  571. begin
  572.   FixHour;
  573.   SetTime;
  574. end;
  575.  
  576. procedure TFormClock.SEDminChange(Sender: TObject);
  577. begin
  578.   FixDmin;
  579.   SetTime;
  580. end;
  581.  
  582. procedure TFormClock.SEMinChange(Sender: TObject);
  583. begin
  584.   FixMin;
  585.   SetTime;
  586. end;
  587.  
  588. procedure TFormClock.SEDsecChange(Sender: TObject);
  589. begin
  590.   FixDsec;
  591.   SetTime;
  592. end;
  593.  
  594. procedure TFormClock.SESecChange(Sender: TObject);
  595. begin
  596.   FixSec;
  597.   SetTime;
  598. end;
  599.  
  600.  
  601. procedure TFormClock.SBAmPmDownClick(Sender: TObject);
  602. begin
  603.   If EditAmPm.text = 'am'
  604.     then EditAmPm.text := 'pm'
  605.     else EditAmPm.text := 'am';
  606.   SetTime;
  607. end;
  608.  
  609. procedure TFormClock.BtnCancelClick(Sender: TObject);
  610. begin
  611.   Close;
  612. end;
  613.  
  614. procedure TFormClock.BtnSelectClick(Sender: TObject);
  615. begin
  616.   SelectedTime := ClockTime;
  617.   Close;
  618. end;
  619.  
  620.  
  621. {TFormCalendar Implementation}
  622.  
  623. procedure TFormCalendar.UpdateDate(Y, M, D: Word);
  624. begin
  625.   try
  626.     SEYear.Value := Y;
  627.     CBMonth.ItemIndex := M - 1;
  628.     Calendar1.Year := Y;
  629.     Calendar1.Month := M;
  630.     Calendar1.Day := D;
  631.   except
  632.     MessageDlg('Invalid Date', mtError, [mbOK], 0);
  633.   end;
  634. end;
  635.  
  636. procedure TFormCalendar.SetDate(Y, M, D: Word);
  637. begin
  638.   UpdateDate(Y, M, D);
  639.   {Set Initial Date}
  640.   SelectedDateTime := EncodeDate(Y, M, D);
  641. end;
  642.  
  643. procedure TFormCalendar.SetDateTime(DT: TDateTime);
  644. var
  645.   Year, Month, Day: Word;
  646. begin
  647.   {Set Initial Date}
  648.   SelectedDateTime := DT;
  649.   If DT > 0
  650.   then DecodeDate(DT, Year, Month, Day)
  651.   else DecodeDate(Date, Year, Month, Day);
  652.   UpdateDate(Year, Month, Day)
  653. end;
  654.  
  655. function TFormCalendar.GetDateTime: TDateTime;
  656. begin
  657.   Result := SelectedDateTime;
  658. end;
  659.  
  660. procedure TFormCalendar.SEYearChange(Sender: TObject);
  661. begin
  662.   UpdateDate(SEYear.Value, Calendar1.Month, Calendar1.Day);
  663. end;
  664.  
  665. procedure TFormCalendar.CBMonthChange(Sender: TObject);
  666. begin
  667.   UpdateDate(Calendar1.Year, CBMonth.ItemIndex + 1, Calendar1.Day);
  668. end;
  669.  
  670. procedure TFormCalendar.SelectDate;
  671. begin
  672.   {If date/time already set, then change only the date part}
  673.   SelectedDateTime := EncodeDate(Calendar1.Year, Calendar1.Month,
  674.                              Calendar1.Day) + Frac(SelectedDateTime);
  675. end;
  676.  
  677. procedure TFormCalendar.Calendar1DblClick(Sender: TObject);
  678. begin
  679.   SelectDate;
  680.   Close;
  681. end;
  682.  
  683. procedure TFormCalendar.FormKeyDown(Sender: TObject; var Key: Word;
  684.   Shift: TShiftState);
  685. begin
  686.   if (Key = VK_RETURN)
  687.   then begin
  688.     SelectDate;
  689.     Close;
  690.   end;
  691. end;
  692.  
  693. procedure TFormCalendar.BtnSelectClick(Sender: TObject);
  694. begin
  695.   SelectDate;
  696.   Close;
  697. end;
  698.  
  699. procedure TFormCalendar.BtnCancelClick(Sender: TObject);
  700. begin
  701.   Close;
  702. end;
  703.  
  704.  
  705. {TDateTimeDlg Implementation}
  706.  
  707. constructor TDateTimeDlg.Create(AOwner: TComponent);
  708. begin
  709.   inherited Create(AOwner);
  710.  
  711.   Buttons := [btnCalendar];
  712.  
  713.   FUpButton := TComponentButton.Create (Self, 'Increase Date/Time');
  714.   FUpButton.OnClick := UpClick;
  715.   FUpButton.OnMouseDown := IncOnMouseDown;
  716.   FUpButton.Width := Height div 2;
  717.   FUpButton.Height := (Height-BtnOffset) div 2;
  718.   FUpButton.Parent := Self;
  719.   FUpButton.Glyph.Handle := LoadBitmap(HInstance, 'ARROWUP');
  720.   FUpButton.NumGlyphs := 1;
  721.   FUpButton.Invalidate;
  722.  
  723.   FDownButton := TComponentButton.Create (Self, 'Decrease Date/Time');
  724.   FDownButton.OnClick := DownClick;
  725.   FDownButton.OnMouseDown := IncOnMouseDown;
  726.   FDownButton.Width := Height div 2;
  727.   FDownButton.Height := (Height-BtnOffset) div 2;
  728.   FDownButton.Parent := Self;
  729.   FDownButton.Glyph.Handle := LoadBitmap(HInstance, 'ARROWDOWN');
  730.   FDownButton.NumGlyphs := 1;
  731.   FDownButton.Invalidate;
  732.  
  733.   FCalendarButton := TComponentButton.Create (Self, 'Select Date');
  734.   FCalendarButton.OnClick := CalendarClick;
  735.   FCalendarButton.Left := Width - 15;
  736.   FCalendarButton.Top := 0;
  737.   FCalendarButton.Width := 15;
  738.   FCalendarButton.Height := Height - BtnOffset;
  739.   FCalendarButton.Parent := Self;
  740.   FCalendarButton.Glyph.Handle := LoadBitmap(HInstance, 'CALENDAR');
  741.   FCalendarButton.NumGlyphs := 1;
  742.   FCalendarButton.Invalidate;
  743.  
  744.   FClockButton := TComponentButton.Create (Self, 'Select Time');
  745.   FClockButton.OnClick := ClockClick;
  746.   FClockButton.Width := 15;
  747.   FClockButton.Height := Height - BtnOffset;
  748.   FClockButton.Parent := Self;
  749.   FClockButton.Glyph.Handle := LoadBitmap(HInstance, 'CLOCK');
  750.   FClockButton.NumGlyphs := 1;
  751.   FClockButton.Invalidate;
  752.  
  753.  
  754.   FFocusedButton := FCalendarButton;
  755.  
  756.   EnableEditor := False;
  757.   IncrementScale := Day;
  758.   IncrementBy := 1;
  759. end;
  760.  
  761. destructor TDateTimeDlg.Destroy;
  762. begin
  763.   FUpButton.Free;
  764.   FDownButton.Free;
  765.   FCalendarButton.Free;
  766.   FClockButton.Free;
  767.   inherited Destroy;
  768. end;
  769.  
  770. procedure TDateTimeDlg.CreateParams(var Params: TCreateParams);
  771. begin
  772.   inherited CreateParams(Params);
  773.   Params.Style := Params.Style or ES_MULTILINE or WS_CLIPCHILDREN;
  774. end;
  775.  
  776. procedure TDateTimeDlg.SetEditRect;
  777. var
  778.   Loc: TRect;
  779.   TotBtnWidth: Integer;
  780. begin
  781.   SendMessage(Handle, EM_GETRECT, 0, LongInt(@Loc));
  782.   Loc.Bottom := ClientHeight + 1;  {+1 is workaround for windows paint bug}
  783.  
  784.   {Set Buttons for Calendar and timer buttons}
  785.   TotBtnWidth := Integer(btnCalendar in FButtons)*FCalendarButton.Width +
  786.        Integer(btnClock in FButtons)*FClockButton.Width +
  787.        Integer(btnIncrement in FButtons)*FUpButton.Width + BtnOffset;
  788.  
  789.   Loc.Right := ClientWidth - TotBtnWidth - 2;
  790.   Loc.Top := 0;
  791.   Loc.Left := 0;
  792.   SendMessage(Handle, EM_SETRECTNP, 0, LongInt(@Loc));
  793.   SendMessage(Handle, EM_GETRECT, 0, LongInt(@Loc));  {debug}
  794. end;
  795.  
  796. procedure TDateTimeDlg.CreateWnd;
  797. var
  798.   Loc: TRect;
  799. begin
  800.   inherited CreateWnd;
  801.   SetEditRect;
  802. end;
  803.  
  804. function TDateTimeDlg.GetMinHeight: Integer;
  805. var
  806.   DC: HDC;
  807.   SaveFont: HFont;
  808.   I: Integer;
  809.   SysMetrics, Metrics: TTextMetric;
  810. begin
  811.   DC := GetDC(0);
  812.   GetTextMetrics(DC, SysMetrics);
  813.   SaveFont := SelectObject(DC, Font.Handle);
  814.   GetTextMetrics(DC, Metrics);
  815.   SelectObject(DC, SaveFont);
  816.   ReleaseDC(0, DC);
  817.   I := SysMetrics.tmHeight;
  818.   if I > Metrics.tmHeight then I := Metrics.tmHeight;
  819.   Result := Metrics.tmHeight + I div 4 + GetSystemMetrics(SM_CYBORDER) * 4 + 2;
  820. end;
  821.  
  822.  
  823. procedure TDateTimeDlg.DrawButtons;
  824. var
  825.   IncHeight, NumBtns, ClockHeight, CalendarHeight: Integer;
  826. begin
  827.   {Set Buttons for Calendar and timer buttons}
  828.   NumBtns := 0;
  829.   ClockHeight := 0;
  830.   CalendarHeight := 0;
  831.   IncHeight := 0;
  832.  
  833.   If (btnCalendar in FButtons)
  834.   then begin
  835.     NumBtns := 1;
  836.     ClockHeight := 0;
  837.     CalendarHeight := Height - BtnOffset;
  838.   end;
  839.   If (btnClock in FButtons)
  840.   then begin
  841.     NumBtns := 1;
  842.     ClockHeight := Height - BtnOffset;
  843.     CalendarHeight := 0;
  844.   end;
  845.   If (btnCalendar in FButtons) and (btnClock in FButtons)
  846.   then begin
  847.     NumBtns := 2;
  848.     ClockHeight := Height - BtnOffset;
  849.     CalendarHeight := Height - BtnOffset;
  850.   end;
  851.   If (btnIncrement in FButtons)
  852.   then IncHeight := (Height-BtnOffset) div 2 
  853.   else IncHeight := 0;
  854.  
  855.   if FUpButton <> nil then
  856.     FUpButton.SetBounds (Width-IncHeight-(NumBtns*Height)-BtnOffset, 0,
  857.                          IncHeight, IncHeight);
  858.   if FDownButton <> nil then
  859.     FDownButton.SetBounds (Width-IncHeight-(NumBtns*Height)-BtnOffset,
  860.                            IncHeight, IncHeight, IncHeight);
  861.   if FCalendarButton <> nil then
  862.     FCalendarButton.SetBounds (Width-(NumBtns*Height)-BtnOffset, 0,
  863.                                Height, CalendarHeight);
  864.   if FClockButton <> nil then
  865.     FClockButton.SetBounds (Width - Height-BtnOffset, 0, Height, ClockHeight);
  866. end;
  867.  
  868. procedure TDateTimeDlg.WMSize(var Message: TWMSize);
  869. var
  870.   MinHeight: Integer;
  871. begin
  872.   inherited;
  873.   MinHeight := GetMinHeight;
  874.     { text edit bug: if size to less than minheight, then edit ctrl does
  875.       not display the text }
  876.   if Height < MinHeight
  877.   then Height := MinHeight
  878.   else begin
  879.     DrawButtons;
  880.     SetEditRect;
  881.   end;
  882. end;
  883.  
  884. procedure TDateTimeDlg.IncDateTime(Down: Boolean);
  885. var
  886.   IncAmount: Double;
  887.   ADate, BDate: TDateTime;
  888.   Y,M,D: Word;
  889.   Mnth, AnInc: Integer;
  890. begin
  891.   If Length(Text) > 0
  892.   then begin
  893.     {Get initial Values}
  894.     If btnClock in FButtons
  895.     then begin
  896.       If btnCalendar in FButtons
  897.       then ADate := StrToDateTime(Text)
  898.       else ADate := StrToTime(Text);
  899.     end
  900.     else ADate := StrToDate(Text);
  901.  
  902.     If Down
  903.     then AnInc := -FIncrementBy
  904.     else AnInc := FIncrementBy;
  905.  
  906.     Case FIncrementScale of
  907.     Year:
  908.       begin
  909.         DecodeDate(ADate, Y, M, D);
  910.         Y := Y + AnInc;
  911.         BDate := EncodeDate(Y, M, D) + Frac(ADate);
  912.         IncAmount := BDate - ADate;
  913.       end;
  914.     Month:
  915.       begin
  916.         DecodeDate(ADate, Y, M, D);
  917.         Mnth := M + AnInc;
  918.         If Mnth > 0
  919.         then begin
  920.           Y := Y + (Mnth-1) div 12;
  921.           If Mnth > 12 then Mnth := Mnth MOD 12;
  922.           If Mnth = 0 then Mnth := 12;
  923.         end
  924.         else begin
  925.           Y := Y - ((ABS(Mnth)+12) div 12);
  926.           Mnth := 12 - (ABS(Mnth) MOD 12);
  927.         end;
  928.         M := Mnth;
  929.         BDate := EncodeDate(Y, M, D) + Frac(ADate);
  930.         IncAmount := BDate - ADate;
  931.       end;
  932.     Week: IncAmount := 7*AnInc;
  933.     Day: IncAmount := 1*AnInc;
  934.     Hour: IncAmount := AnInc/24;
  935.     Minute: IncAmount := AnInc/(24*60);
  936.     Second: IncAmount := AnInc/(24*60*60);
  937.     end;
  938.  
  939.     If not (btnCalendar in FButtons)
  940.     then begin
  941.       {Cannot update date if only time is showing}
  942.       If ABS(IncAmount) < 1
  943.       then
  944.         if StrToTime(Text)+IncAmount < 0
  945.         then Text := TimeToStr(1+StrToTime(Text)+IncAmount)
  946.         else Text := TimeToStr(StrToTime(Text)+IncAmount);
  947.     end
  948.     else Text := DateTimeToStr(StrToDateTime(Text)+IncAmount);
  949.   end
  950.   else MessageDlg('Select a date or time first', mtInformation, [mbOK], 0);
  951. end;
  952.  
  953. procedure TDateTimeDlg.UpClick(Sender: TObject);
  954. begin
  955.   IncDateTime(False);
  956. end;
  957.  
  958. procedure TDateTimeDlg.IncOnMouseDown(Sender: TObject; Button: TMouseButton;
  959.                       Shift: TShiftState; X, Y: Integer);
  960. var
  961.   FormSetIncrement: TFormSetIncrement;
  962. begin
  963.   FormSetIncrement := TFormSetIncrement.Create(Self);
  964.   With FormSetIncrement do
  965.   begin
  966.     SetIncrementScale(FIncrementScale);
  967.     SetIncrementBy(FIncrementBy);
  968.     if Button = mbRight then ShowModal;
  969.     FIncrementBy := GetIncrementBy;
  970.     FincrementScale := GetIncrementScale;
  971.     Free;
  972.   end;
  973. end;
  974.  
  975. procedure TDateTimeDlg.DownClick(Sender: TObject);
  976. begin
  977.   IncDateTime(True);
  978. end;
  979.  
  980. procedure TDateTimeDlg.ClockClick(Sender: TObject);
  981. var
  982.   ADate: TDateTime;
  983.   FormClock: TFormClock;
  984. begin
  985.   FormClock := TFormClock.Create(Self);
  986.   If Length(Text) > 1
  987.   then
  988.     try
  989.       If not (btnCalendar in FButtons)
  990.       then ADate := StrToTime(Text)
  991.       else ADate := StrToDateTime(Text);
  992.     except
  993.       ADate := 0;
  994.       MessageDlg(Text+' is not a valid time', mtError, [mbOK], 0);
  995.     end
  996.   else ADate := 0;
  997.   FormClock.SetClkDateTime(ADate);
  998.   FormClock.ShowModal;
  999.   ADate := FormClock.GetClkTime;
  1000.   If ADate > 0
  1001.   then begin
  1002.     if btnCalendar in FButtons
  1003.     then Text := DateTimeToStr(ADate)
  1004.     else Text := TimeToStr(ADate);
  1005.   end;
  1006.   FormClock.Free;
  1007. end;
  1008.  
  1009. procedure TDateTimeDlg.CalendarClick(Sender: TObject);
  1010. var
  1011.   ADate: TDateTime;
  1012.   Y, M, D: Word;
  1013.   FormCalendar: TFormCalendar;
  1014. begin
  1015.   FormCalendar := TFormCalendar.Create(Self);
  1016.   If Length(Text) > 1 then
  1017.   Try
  1018.     ADate := StrToDateTime(Text);
  1019.     FormCalendar.SetDateTime(ADate);
  1020.   except
  1021.     MessageDlg(Text+' is not a valid date', mtError, [mbOK], 0);
  1022.     FormCalendar.SetDateTime(0);
  1023.   end
  1024.   else FormCalendar.SetDateTime(0);
  1025.   FormCalendar.ShowModal;
  1026.  
  1027.   ADate := FormCalendar.GetDateTime;
  1028.   If ADate > 0
  1029.   then begin
  1030.     if not (btnClock in FButtons)
  1031.     then Text := DateToStr(ADate)
  1032.     else Text := DateTimeToStr(ADate);
  1033.   end;
  1034.   FormCalendar.Free;
  1035. end;
  1036.  
  1037. procedure TDateTimeDlg.SetUpGlyph(Value: TBitmap);
  1038. begin
  1039.   FUpButton.Glyph := Value;
  1040. end;
  1041.  
  1042. procedure TDateTimeDlg.SetDownGlyph(Value: TBitmap);
  1043. begin
  1044.   FDownButton.Glyph := Value;
  1045. end;
  1046.  
  1047. procedure TDateTimeDlg.SetCalendarGlyph(Value: TBitmap);
  1048. begin
  1049.   FCalendarButton.Glyph := Value;
  1050. end;
  1051.  
  1052. procedure TDateTimeDlg.SetClockGlyph(Value: TBitmap);
  1053. begin
  1054.   FClockButton.Glyph := Value;
  1055. end;
  1056.  
  1057. function TDateTimeDlg.GetUpGlyph: TBitmap;
  1058. begin
  1059.   result := FUpButton.Glyph;
  1060. end;
  1061.  
  1062. function TDateTimeDlg.GetDownGlyph: TBitmap;
  1063. begin
  1064.   result := FDownButton.Glyph;
  1065. end;
  1066.  
  1067. function TDateTimeDlg.GetCalendarGlyph: TBitmap;
  1068. begin
  1069.   result := FCalendarButton.Glyph;
  1070. end;
  1071.  
  1072. function TDateTimeDlg.GetClockGlyph: TBitmap;
  1073. begin
  1074.   result := FClockButton.Glyph;
  1075. end;
  1076.  
  1077. procedure TDateTimeDlg.SetNumUpGlyphs(Value: TNumGlyphs);
  1078. begin
  1079.   FUpButton.NumGlyphs := Value;
  1080. end;
  1081.  
  1082. procedure TDateTimeDlg.SetNumDownGlyphs(Value: TNumGlyphs);
  1083. begin
  1084.   FDownButton.NumGlyphs := Value;
  1085. end;
  1086.  
  1087. procedure TDateTimeDlg.SetNumCalendarGlyphs(Value: TNumGlyphs);
  1088. begin
  1089.   FCalendarButton.NumGlyphs := Value;
  1090. end;
  1091.  
  1092. procedure TDateTimeDlg.SetNumClockGlyphs(Value: TNumGlyphs);
  1093. begin
  1094.   FClockButton.NumGlyphs := Value;
  1095. end;
  1096.  
  1097. function TDateTimeDlg.GetNumUpGlyphs: TNumGlyphs;
  1098. begin
  1099.   result := FUpButton.NumGlyphs;
  1100. end;
  1101.  
  1102. function TDateTimeDlg.GetNumDownGlyphs: TNumGlyphs;
  1103. begin
  1104.   result := FDownButton.NumGlyphs;
  1105. end;
  1106.  
  1107. function TDateTimeDlg.GetNumCalendarGlyphs: TNumGlyphs;
  1108. begin
  1109.   result := FCalendarButton.NumGlyphs;
  1110. end;
  1111.  
  1112. function TDateTimeDlg.GetNumClockGlyphs: TNumGlyphs;
  1113. begin
  1114.   result := FClockButton.NumGlyphs;
  1115. end;
  1116.  
  1117. procedure TDateTimeDlg.SetButtons(Value: TButtonOptions);
  1118. begin
  1119.   FButtons := Value;
  1120.   DrawButtons;
  1121. end;
  1122.  
  1123. function TDateTimeDlg.GetButtons: TButtonOptions;
  1124. begin
  1125.   result := FButtons;
  1126. end;
  1127.  
  1128. procedure TDateTimeDlg.SetIncrementBy(Value: Integer);
  1129. begin
  1130.   If (Value > -1) and (Value < 32767)
  1131.   then FIncrementBy := Value
  1132.   else MessageDlg('"Increment By" must be between 0 and 32767', mtWarning,
  1133.                      [mbOK], 0);
  1134. end;
  1135.  
  1136. procedure TDateTimeDlg.SetEnableEditor(Value: Boolean);
  1137. begin
  1138.   FEnableEditor := Value;
  1139.   ReadOnly := not Value;
  1140. end;
  1141.  
  1142. procedure TDateTimeDlg.SetIncrementBtns(Value: Boolean);
  1143. begin
  1144.   FIncrementBtns := Value;
  1145.   DrawButtons;
  1146. end;
  1147.  
  1148. procedure TDateTimeDlg.KeyDown(var Key: Word; Shift: TShiftState);
  1149. begin
  1150.   case Key of
  1151.   VK_UP: If (btnIncrement in FButtons)
  1152.     then begin
  1153.       SetFocusBtn (FUpButton);
  1154.       IncDateTime(False);
  1155.     end;
  1156.   VK_DOWN: If (btnIncrement in FButtons)
  1157.     then begin
  1158.       SetFocusBtn (FDownButton);
  1159.       IncDateTime(False);
  1160.     end;
  1161.   end;
  1162. end;
  1163.  
  1164. procedure TDateTimeDlg.BtnMouseDown (Sender: TObject; Button: TMouseButton;
  1165.   Shift: TShiftState; X, Y: Integer);
  1166. begin
  1167.   if Button = mbLeft
  1168.   then SetFocusBtn (TComponentButton(Sender));
  1169. end;
  1170.  
  1171. procedure TDateTimeDlg.SetFocusBtn (Btn: TComponentButton);
  1172. begin
  1173.   if TabStop and CanFocus and  (Btn <> FFocusedButton) then
  1174.   begin
  1175.     FFocusedButton.TimeBtnState := FFocusedButton.TimeBtnState - [tbFocusRect];
  1176.     FFocusedButton := Btn;
  1177.     if (GetFocus = Handle) then
  1178.     begin
  1179.        FFocusedButton.TimeBtnState := FFocusedButton.TimeBtnState + [tbFocusRect];
  1180.        Invalidate;
  1181.     end;
  1182.   end;
  1183. end;
  1184.  
  1185. procedure TDateTimeDlg.WMPaste(var Message: TWMPaste);
  1186. begin
  1187.   if not FEnableEditor then Exit;
  1188.   inherited;
  1189. end;
  1190.  
  1191. procedure TDateTimeDlg.WMCut(var Message: TWMPaste);
  1192. begin
  1193.   if not FEnableEditor then Exit;
  1194.   inherited;
  1195. end;
  1196.  
  1197. procedure TDateTimeDlg.CMEnter(var Message: TCMGotFocus);
  1198. begin
  1199.   if AutoSelect and not (csLButtonDown in ControlState) then
  1200.     SelectAll;
  1201.   inherited;
  1202. end;
  1203.  
  1204. {TDBDateTimeDlg Implementation}
  1205.  
  1206. constructor TDBDateTimeDlg.Create(AOwner: TComponent);
  1207. begin
  1208.   inherited Create(AOwner);
  1209.   FdataLink:= TfieldDataLink.Create;
  1210.   FDataLink.Control := Self;
  1211.   Fdatalink.OnDataChange := DataChange;
  1212.   FdataLink.OnUpdateData := UpdateData;
  1213. end;
  1214.  
  1215. destructor TDBDateTimeDlg.Destroy;
  1216. begin
  1217.   FDataLink.OnDataChange := nil;
  1218.   Fdatalink.Free;
  1219.   inherited Destroy;
  1220. end;
  1221.  
  1222. procedure TDBDateTimeDlg.Notification(AComponent: TComponent;
  1223.   Operation: TOperation);
  1224. begin
  1225.   inherited Notification(AComponent, Operation);
  1226.   if (Operation = opRemove) and (FDataLink <> nil) and
  1227.     (AComponent = DataSource) then DataSource := nil;
  1228. end;
  1229.  
  1230. Procedure TDBDateTimeDlg.DataChange(sender: TObject);
  1231. begin
  1232.   If FdataLink.Field <> nil
  1233.   then Text := Fdatalink.Field.AsString
  1234.   else Text := '';
  1235. end;
  1236.  
  1237. Function TDBDateTimeDlg.GetDataField : String;
  1238. begin
  1239.   result := FdataLink.FieldName;
  1240. end;
  1241.  
  1242. Function TDBDateTimeDlg.GetDataSource : TDataSource;
  1243. begin
  1244.   Result := FdataLink.DataSource;
  1245. end;
  1246.  
  1247. Procedure TDBDateTimeDlg.SetDataField(const value : string);
  1248. begin
  1249.   FdataLink.FieldName:=Value;
  1250. end;
  1251.  
  1252. procedure TDBDateTimeDlg.SetDataSource(value : TDataSource);
  1253. begin
  1254.   FdataLink.DataSource:=Value;
  1255. end;
  1256.  
  1257. Procedure TDBDateTimeDlg.UpdateData(Sender: TObject);
  1258. begin
  1259.   if FDataLink.edit
  1260.   then FdataLink.Field.AsString := Text
  1261.   else Text := Fdatalink.Field.AsString;
  1262. end;
  1263.  
  1264. Procedure TDBDateTimeDlg.Change;
  1265. begin
  1266.   FdataLink.Modified;
  1267.   Inherited Change;
  1268. end;
  1269.  
  1270. procedure TDBDateTimeDlg.UpClick (Sender: TObject);
  1271. begin
  1272.   FDataLink.Edit;
  1273.   inherited UpClick(Sender);
  1274. end;
  1275.  
  1276. procedure TDBDateTimeDlg.DownClick (Sender: TObject);
  1277. begin
  1278.   FDataLink.Edit;
  1279.   inherited DownClick(Sender);
  1280. end;
  1281.  
  1282. procedure TDBDateTimeDlg.ClockClick (Sender: TObject);
  1283. begin
  1284.   FDataLink.Edit;
  1285.   inherited ClockClick(Sender);
  1286. end;
  1287.  
  1288. procedure TDBDateTimeDlg.CalendarClick (Sender: TObject);
  1289. begin
  1290.   FDataLink.Edit;
  1291.   inherited CalendarClick(Sender);
  1292. end;
  1293.  
  1294. Procedure TDBDateTimeDlg.KeyDown(Var Key:Word;Shift:TShiftState);
  1295. begin
  1296.   FDataLink.Edit;
  1297.   inherited KeyDown(Key, Shift);
  1298. end;
  1299.  
  1300. procedure TDBDateTimeDlg.CMExit(var Message: TCMExit);
  1301. begin
  1302.   UpdateData(Self);
  1303.   inherited;
  1304. end;
  1305.  
  1306. end.
  1307.  
  1308.