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