david
960b25140d
git-svn-id: https://192.168.0.254/svn/Componentes.Terceros.DevExpressVCL@55 05c56307-c608-d34a-929d-697000501d7a
764 lines
24 KiB
ObjectPascal
764 lines
24 KiB
ObjectPascal
{********************************************************************}
|
|
{ }
|
|
{ Developer Express Visual Component Library }
|
|
{ ExpressScheduler }
|
|
{ }
|
|
{ Copyright (c) 2003-2009 Developer Express Inc. }
|
|
{ ALL RIGHTS RESERVED }
|
|
{ }
|
|
{ The entire contents of this file is protected by U.S. and }
|
|
{ International Copyright Laws. Unauthorized reproduction, }
|
|
{ reverse-engineering, and distribution of all or any portion of }
|
|
{ the code contained in this file is strictly prohibited and may }
|
|
{ result in severe civil and criminal penalties and will be }
|
|
{ prosecuted to the maximum extent possible under the law. }
|
|
{ }
|
|
{ RESTRICTIONS }
|
|
{ }
|
|
{ THIS SOURCE CODE AND ALL RESULTING INTERMEDIATE FILES }
|
|
{ (DCU, OBJ, DLL, ETC.) ARE CONFIDENTIAL AND PROPRIETARY TRADE }
|
|
{ SECRETS OF DEVELOPER EXPRESS INC. THE REGISTERED DEVELOPER IS }
|
|
{ LICENSED TO DISTRIBUTE THE EXPRESSSCHEDULER AND ALL ACCOMPANYING }
|
|
{ VCL CONTROLS AS PART OF AN EXECUTABLE PROGRAM ONLY. }
|
|
{ }
|
|
{ THE SOURCE CODE CONTAINED WITHIN THIS FILE AND ALL RELATED }
|
|
{ FILES OR ANY PORTION OF ITS CONTENTS SHALL AT NO TIME BE }
|
|
{ COPIED, TRANSFERRED, SOLD, DISTRIBUTED, OR OTHERWISE MADE }
|
|
{ AVAILABLE TO OTHER INDIVIDUALS WITHOUT EXPRESS WRITTEN CONSENT }
|
|
{ AND PERMISSION FROM DEVELOPER EXPRESS INC. }
|
|
{ }
|
|
{ CONSULT THE END USER LICENSE AGREEMENT FOR INFORMATION ON }
|
|
{ ADDITIONAL RESTRICTIONS. }
|
|
{ }
|
|
{********************************************************************}
|
|
|
|
unit cxSchedulerEventEditor;
|
|
|
|
{$I cxVer.inc}
|
|
|
|
interface
|
|
|
|
uses
|
|
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
|
|
StdCtrls, ExtCtrls, cxTextEdit, cxMemo, cxImageComboBox, cxCalendar,
|
|
cxTimeEdit, cxLookAndFeelPainters, cxDropDownEdit, cxCheckBox,
|
|
cxSpinEdit, cxMaskEdit, cxControls, cxContainer, cxEdit, cxButtons,
|
|
cxSchedulerStorage, cxLookAndFeels, cxSchedulerCustomControls;
|
|
|
|
type
|
|
|
|
{ TcxSchedulerCustomEditorForm }
|
|
|
|
TcxSchedulerCustomEditorForm = class(TForm)
|
|
private
|
|
FEvent: TcxSchedulerControlEvent;
|
|
FIsInternalActivate: Boolean;
|
|
FReadOnly: Boolean;
|
|
function GetStorage: TcxCustomSchedulerStorage;
|
|
protected
|
|
FModified: Boolean;
|
|
procedure ApplyChanges; virtual;
|
|
function GetFormColor: TColor; virtual;
|
|
procedure InitializeControls; virtual;
|
|
procedure LoadEventValuesIntoControls; virtual;
|
|
procedure SetReadOnly(AValue: Boolean); virtual;
|
|
procedure UpdateEventValuesFromControls; virtual;
|
|
|
|
property Storage: TcxCustomSchedulerStorage read GetStorage;
|
|
public
|
|
constructor CreateEx(AEvent: TcxSchedulerControlEvent); virtual;
|
|
function ShowModal: Integer; override;
|
|
|
|
property Event: TcxSchedulerControlEvent read FEvent;
|
|
property IsInternalActivate: Boolean read FIsInternalActivate write FIsInternalActivate;
|
|
property Modified: Boolean read FModified;
|
|
property ReadOnly: Boolean read FReadOnly write SetReadOnly;
|
|
end;
|
|
|
|
{ TcxSchedulerCustomEventEditor }
|
|
|
|
TcxSchedulerCustomEventEditor = class(TcxSchedulerCustomEditorForm)
|
|
private
|
|
FAllowDelete: Boolean;
|
|
FAllowRecurrence: Boolean;
|
|
FBiasTime: TDateTime;
|
|
FDeleteSeries: Boolean;
|
|
FDeleteExceptions: Boolean;
|
|
FForceSeries: Boolean;
|
|
FHasStorageEvent: Boolean;
|
|
FRecurrenceActivate: Boolean;
|
|
FOnDeleteFunc: TcxOnDeleteEventFunc;
|
|
protected
|
|
procedure DeleteEvent; virtual;
|
|
procedure PostEvent; virtual;
|
|
procedure SaveChanges; virtual;
|
|
procedure SetAllowDelete(AValue: Boolean); virtual;
|
|
procedure SetAllowRecurrence(AValue: Boolean); virtual;
|
|
|
|
property DeleteExceptions: Boolean read FDeleteExceptions write FDeleteExceptions;
|
|
property DeleteSeries: Boolean read FDeleteSeries write FDeleteSeries;
|
|
property HasStorageEvent: Boolean read FHasStorageEvent;
|
|
property Storage;
|
|
public
|
|
constructor CreateEx(AEvent: TcxSchedulerControlEvent); override;
|
|
|
|
property AllowDelete: Boolean read FAllowDelete write SetAllowDelete;
|
|
property AllowRecurrence: Boolean read FAllowRecurrence write SetAllowRecurrence;
|
|
property BiasTime: TDateTime read FBiasTime write FBiasTime;
|
|
property Event;
|
|
property ForceSeries: Boolean read FForceSeries write FForceSeries;
|
|
property Modified: Boolean read FModified;
|
|
property RecurrenceActivate: Boolean read FRecurrenceActivate write FRecurrenceActivate;
|
|
property ReadOnly;
|
|
property OnDeleteFunc: TcxOnDeleteEventFunc read FOnDeleteFunc write FOnDeleteFunc;
|
|
end;
|
|
|
|
{ TcxSchedulerEventEditorForm }
|
|
|
|
TcxSchedulerEventEditorForm = class(TcxSchedulerCustomEventEditor)
|
|
pnlCaption: TPanel;
|
|
lbLocation: TLabel;
|
|
lbSubject: TLabel;
|
|
teLocation: TcxTextEdit;
|
|
teSubject: TcxTextEdit;
|
|
icbLabel: TcxImageComboBox;
|
|
lbLabel: TLabel;
|
|
pnlMessage: TPanel;
|
|
meMessage: TcxMemo;
|
|
pnlReminder: TPanel;
|
|
cbReminder: TcxCheckBox;
|
|
cbAdvanceTime: TcxComboBox;
|
|
lbShowTimeAs: TLabel;
|
|
icbShowTimeAs: TcxImageComboBox;
|
|
pnlTime: TPanel;
|
|
lbStartTime: TLabel;
|
|
deStart: TcxDateEdit;
|
|
teStart: TcxTimeEdit;
|
|
lbEndTime: TLabel;
|
|
deEnd: TcxDateEdit;
|
|
teEnd: TcxTimeEdit;
|
|
cbAllDayEvent: TcxCheckBox;
|
|
btnOk: TcxButton;
|
|
btnDelete: TcxButton;
|
|
btnRecurrence: TcxButton;
|
|
pnlResource: TPanel;
|
|
Bevel5: TBevel;
|
|
cbResources: TcxComboBox;
|
|
lbResource: TLabel;
|
|
Bevel1: TBevel;
|
|
btnCancel: TcxButton;
|
|
pnlThreeButtons: TPanel;
|
|
pnlRecurrence: TPanel;
|
|
procedure OnChanged(Sender: TObject);
|
|
procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean);
|
|
procedure FormKeyDown(Sender: TObject; var Key: Word;
|
|
Shift: TShiftState);
|
|
procedure FormActivate(Sender: TObject);
|
|
procedure btnRecurrenceClick(Sender: TObject);
|
|
procedure cbAllDayEventPropertiesChange(Sender: TObject);
|
|
procedure StartDateChanged(Sender: TObject);
|
|
procedure btnDeleteClick(Sender: TObject);
|
|
private
|
|
FNeedCheckLossOfExceptions: Boolean;
|
|
function GetEventName: string;
|
|
protected
|
|
FDuration: TDateTime;
|
|
procedure ApplyChanges; override;
|
|
procedure CheckVisible;
|
|
procedure ClearModifiedFlag; virtual;
|
|
function GetFormColor: TColor; override;
|
|
function GetReminderTime: Integer;
|
|
procedure InitializeControls; override;
|
|
procedure InitLabel;
|
|
procedure InitReminderPanel;
|
|
procedure InitResources;
|
|
procedure LoadEventValuesIntoControls; override;
|
|
function IsValid: Boolean; virtual;
|
|
procedure SetActiveControl; virtual;
|
|
procedure SetAllowDelete(AValue: Boolean); override;
|
|
procedure SetAllowRecurrence(AValue: Boolean); override;
|
|
procedure SetCaptions; virtual;
|
|
procedure SetReadOnly(AValue: Boolean); override;
|
|
procedure UpdateEventValuesFromControls; override;
|
|
public
|
|
constructor CreateEx(AEvent: TcxSchedulerControlEvent); override;
|
|
function ShowModal: Integer; override;
|
|
|
|
property AllowDelete;
|
|
property AllowRecurrence;
|
|
property BiasTime;
|
|
property Event;
|
|
property EventName: string read GetEventName;
|
|
property ForceSeries;
|
|
property Modified;
|
|
property RecurrenceActivate;
|
|
property ReadOnly;
|
|
property OnDeleteFunc;
|
|
end;
|
|
|
|
TcxSchedulerEventEditor = TcxSchedulerEventEditorForm; //workaround for Delphi 2005
|
|
|
|
TcxSchedulerEventEditorClass = class of TcxSchedulerCustomEventEditor;
|
|
|
|
implementation
|
|
|
|
uses
|
|
cxClasses, cxSchedulerStrs, cxSchedulerUtils, cxSchedulerDialogs,
|
|
{$IFDEF DELPHI6}Variants, DateUtils, {$ENDIF} cxDateUtils, cxVariants,
|
|
cxSchedulerRecurrenceSelectionDialog;
|
|
|
|
{$R *.dfm}
|
|
|
|
{ TcxSchedulerCustomEditorForm }
|
|
|
|
constructor TcxSchedulerCustomEditorForm.CreateEx(
|
|
AEvent: TcxSchedulerControlEvent);
|
|
begin
|
|
inherited Create(nil);
|
|
FEvent := AEvent;
|
|
InitializeControls;
|
|
LoadEventValuesIntoControls;
|
|
FModified := False;
|
|
end;
|
|
|
|
procedure TcxSchedulerCustomEditorForm.ApplyChanges;
|
|
begin
|
|
end;
|
|
|
|
function TcxSchedulerCustomEditorForm.GetFormColor: TColor;
|
|
begin
|
|
Result := clBtnFace;
|
|
end;
|
|
|
|
function TcxSchedulerCustomEditorForm.GetStorage: TcxCustomSchedulerStorage;
|
|
begin
|
|
Result := Event.Storage;
|
|
end;
|
|
|
|
procedure TcxSchedulerCustomEditorForm.InitializeControls;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxSchedulerCustomEditorForm.LoadEventValuesIntoControls;
|
|
begin
|
|
end;
|
|
|
|
procedure TcxSchedulerCustomEditorForm.SetReadOnly(AValue: Boolean);
|
|
begin
|
|
FReadOnly := AValue;
|
|
end;
|
|
|
|
function TcxSchedulerCustomEditorForm.ShowModal: Integer;
|
|
begin
|
|
if UseSchedulerColorInDialogs then
|
|
Color := GetFormColor;
|
|
cxDialogsMetricsStore.InitDialog(Self);
|
|
Result := inherited ShowModal;
|
|
cxDialogsMetricsStore.StoreMetrics(Self);
|
|
ApplyChanges;
|
|
end;
|
|
|
|
procedure TcxSchedulerCustomEditorForm.UpdateEventValuesFromControls;
|
|
begin
|
|
end;
|
|
|
|
{ TcxSchedulerCustomEventEditor }
|
|
|
|
constructor TcxSchedulerCustomEventEditor.CreateEx(
|
|
AEvent: TcxSchedulerControlEvent);
|
|
begin
|
|
inherited CreateEx(AEvent);
|
|
FHasStorageEvent := not ((AEvent.Source = nil) or (AEvent.EventType = etOccurrence));
|
|
end;
|
|
|
|
procedure TcxSchedulerCustomEventEditor.DeleteEvent;
|
|
begin
|
|
if FDeleteSeries then
|
|
Event.Pattern.Delete
|
|
else
|
|
Event.Delete;
|
|
end;
|
|
|
|
procedure TcxSchedulerCustomEventEditor.PostEvent;
|
|
|
|
function GetStorageEvent: TcxSchedulerEvent;
|
|
begin
|
|
if not FHasStorageEvent then
|
|
Result := Storage.CreateEvent
|
|
else
|
|
Result := Event.Source;
|
|
Result.Assign(Event);
|
|
end;
|
|
|
|
procedure CheckDeleteException;
|
|
begin
|
|
if FDeleteExceptions and (Event.Pattern <> nil) then
|
|
Event.Pattern.DeleteExceptions;
|
|
end;
|
|
|
|
begin
|
|
CheckDeleteException;
|
|
if not FModified and (Event.Source <> nil) then
|
|
begin
|
|
Event.Start := Event.Start - BiasTime;
|
|
Event.Finish := Event.Finish - BiasTime;
|
|
Exit;
|
|
end;
|
|
if Event.IsRecurring then
|
|
begin
|
|
if ForceSeries then
|
|
begin
|
|
if Event.Pattern <> nil then
|
|
begin
|
|
Event.Pattern.Assign(Event);
|
|
Event.Pattern.EventType := etPattern;
|
|
end
|
|
else
|
|
GetStorageEvent.EventType := etPattern;
|
|
end
|
|
else
|
|
with GetStorageEvent do
|
|
begin
|
|
BeginEditing;
|
|
EventType := etCustom;
|
|
ParentID := Event.Pattern.ID;
|
|
EndEditing;
|
|
end;
|
|
end
|
|
else
|
|
if Event.Pattern <> nil then
|
|
begin
|
|
Event.Pattern.Assign(Event);
|
|
Event.Pattern.EventType := Event.EventType;
|
|
end
|
|
else
|
|
with GetStorageEvent do
|
|
EventType := etNone;
|
|
end;
|
|
|
|
procedure TcxSchedulerCustomEventEditor.SaveChanges;
|
|
var
|
|
AStorage: TcxCustomSchedulerStorage;
|
|
begin
|
|
// if not Modified and (Event.Source <> nil) then Exit;
|
|
AStorage := Storage;
|
|
AStorage.BeginUpdate;
|
|
try
|
|
UpdateEventValuesFromControls;
|
|
PostEvent;
|
|
finally
|
|
AStorage.EndUpdate;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxSchedulerCustomEventEditor.SetAllowDelete(
|
|
AValue: Boolean);
|
|
begin
|
|
FAllowDelete := AValue;
|
|
end;
|
|
|
|
procedure TcxSchedulerCustomEventEditor.SetAllowRecurrence(
|
|
AValue: Boolean);
|
|
begin
|
|
FAllowRecurrence := AValue;
|
|
end;
|
|
|
|
{ TcxSchedulerEventEditor }
|
|
|
|
constructor TcxSchedulerEventEditorForm.CreateEx(AEvent: TcxSchedulerControlEvent);
|
|
begin
|
|
inherited CreateEx(AEvent);
|
|
FNeedCheckLossOfExceptions := (AEvent.Pattern <> nil) and AEvent.Pattern.HasExceptions;
|
|
FDuration := AEvent.Duration;
|
|
ClearModifiedFlag;
|
|
end;
|
|
|
|
function TcxSchedulerEventEditorForm.ShowModal: Integer;
|
|
begin
|
|
CheckVisible;
|
|
SetActiveControl;
|
|
Result := inherited ShowModal;
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.SetActiveControl;
|
|
begin
|
|
if (Event.Source = nil) and teSubject.CanFocus then
|
|
ActiveControl := teSubject
|
|
else
|
|
if meMessage.CanFocus then
|
|
ActiveControl := meMessage
|
|
else
|
|
if deStart.CanFocus then
|
|
ActiveControl := deStart;
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.SetAllowDelete(AValue: Boolean);
|
|
begin
|
|
inherited;
|
|
btnDelete.Enabled := AValue;
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.SetAllowRecurrence(AValue: Boolean);
|
|
begin
|
|
inherited;
|
|
pnlRecurrence.Visible := AValue;
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.ApplyChanges;
|
|
begin
|
|
case ModalResult of
|
|
mrAbort:
|
|
DeleteEvent;
|
|
mrOk:
|
|
SaveChanges;
|
|
mrCancel:
|
|
begin
|
|
Event.Cancel;
|
|
FModified := False;
|
|
Storage.FullRefresh;
|
|
end;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.CheckVisible;
|
|
begin
|
|
pnlTime.Visible := (Event.EventType = etNone) or
|
|
((Event.EventType in [etOccurrence, etCustom]) and not ForceSeries);
|
|
teStart.Time := TimeOf(Event.Start);
|
|
teEnd.Time := TimeOf(Event.Finish);
|
|
teStart.Visible := not cbAllDayEvent.Checked;
|
|
teEnd.Visible := not cbAllDayEvent.Checked;
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.ClearModifiedFlag;
|
|
|
|
procedure CheckComponent(AComponent: TComponent);
|
|
begin
|
|
if AComponent is TcxCustomEdit then
|
|
TcxCustomEdit(AComponent).EditModified := False;
|
|
end;
|
|
|
|
var
|
|
I: Integer;
|
|
begin
|
|
for I := 0 to ComponentCount - 1 do
|
|
CheckComponent(Components[I]);
|
|
FModified := False;
|
|
end;
|
|
|
|
function TcxSchedulerEventEditorForm.GetFormColor: TColor;
|
|
begin
|
|
Result := teLocation.Style.LookAndFeel.Painter.DefaultSchedulerControlColor;
|
|
end;
|
|
|
|
function TcxSchedulerEventEditorForm.GetReminderTime: Integer;
|
|
begin
|
|
Result := Integer(cbAdvanceTime.Properties.Items.Objects[cbAdvanceTime.ItemIndex]);
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.InitializeControls;
|
|
begin
|
|
InitReminderPanel;
|
|
InitLabel;
|
|
SetCaptions;
|
|
cbReminder.Visible := False; //
|
|
cbAdvanceTime.Visible := False;
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.InitReminderPanel;
|
|
var
|
|
I: Integer;
|
|
AItem: TcxImageComboboxItem;
|
|
const
|
|
ATimeTypes: array[0..3] of Pointer =
|
|
(@scxFree, @scxTentative, @scxBusy, @scxOutOfOffice);
|
|
begin
|
|
TcxSchedulerDateTimeHelper.FillAdvanceStrings(cbAdvanceTime.Properties.Items);
|
|
cbAdvanceTime.ItemIndex := 0; //todo:
|
|
for I := 0 to 3 do
|
|
begin
|
|
AItem := TcxImageComboboxItem(icbShowTimeAs.Properties.Items.Add);
|
|
AItem.Description := cxGetResourceString(ATimeTypes[I]);
|
|
AItem.ImageIndex := I;
|
|
AItem.Value := I;
|
|
end;
|
|
icbShowTimeAs.ItemIndex := Integer(Event.State);
|
|
icbShowTimeAs.Properties.Images := TimeLinePatterns;
|
|
icbShowTimeAs.Enabled := Storage.IsStateAvailable;
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.InitResources;
|
|
var
|
|
I, AResourceIndex: Integer;
|
|
begin
|
|
pnlResource.Visible := (Storage.ResourceCount > 0) and
|
|
(csDesigning in Storage.ComponentState);
|
|
if pnlResource.Visible then
|
|
begin
|
|
AResourceIndex := -1;
|
|
with cbResources.Properties.Items do
|
|
begin
|
|
BeginUpdate;
|
|
Clear;
|
|
for I := 0 to Storage.ResourceCount - 1 do
|
|
begin
|
|
Add(Storage.ResourceNames[I]);
|
|
if VarCompare(Event.ResourceID, Storage.ResourceIDs[I]) = 0 then
|
|
AResourceIndex := I;
|
|
end;
|
|
EndUpdate;
|
|
end;
|
|
cbResources.ItemIndex := AResourceIndex;
|
|
end;
|
|
end;
|
|
|
|
function TcxSchedulerEventEditorForm.IsValid: Boolean;
|
|
begin
|
|
Result := not ((deStart.Date + teStart.Time) >
|
|
(deEnd.Date + teEnd.Time));
|
|
if not Result then
|
|
begin
|
|
MessageDlg(cxGetResourceString(@scxWrongTimeBounds), mtWarning, [mbOk], 0);
|
|
ActiveControl := deEnd;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.LoadEventValuesIntoControls;
|
|
begin
|
|
teSubject.Text := Event.Caption;
|
|
teSubject.Enabled := Storage.IsCaptionAvailable;
|
|
teLocation.Text := Event.Location;
|
|
teLocation.Enabled := Storage.IsLocationAvailable;
|
|
meMessage.Text := Event.Message;
|
|
meMessage.Enabled := Storage.IsMessageAvailable;
|
|
deStart.Date := DateOf(Event.Start);
|
|
teStart.Time := TimeOf(Event.Start);
|
|
deEnd.Date := DateOf(Event.Finish) - Ord(Event.AllDayEvent);
|
|
teEnd.Time := TimeOf(Event.Finish);
|
|
cbAllDayEvent.Checked := Event.AllDayEvent;
|
|
//cbReminder.Checked := Event.Reminder; //for the next version
|
|
InitResources;
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.InitLabel;
|
|
|
|
function GetIndex: Integer;
|
|
var
|
|
I: Integer;
|
|
begin
|
|
Result := -1;
|
|
for I := LOW(EventLabelColors) to HIGH(EventLabelColors) do
|
|
if Event.LabelColor = EventLabelColors[I] then
|
|
begin
|
|
Result := I;
|
|
break;
|
|
end;
|
|
end;
|
|
|
|
var
|
|
I: Integer;
|
|
AItem: TcxImageComboboxItem;
|
|
begin
|
|
for I := LOW(EventLabelColors) to HIGH(EventLabelColors) do
|
|
begin
|
|
AItem := TcxImageComboboxItem(icbLabel.Properties.Items.Add);
|
|
AItem.Description := cxGetResourceString(sEventLabelCaptions[I]);
|
|
AItem.ImageIndex := I + 11;
|
|
AItem.Value := EventLabelColors[I];
|
|
end;
|
|
icbLabel.ItemIndex := GetIndex;
|
|
icbLabel.Properties.Images := MenuImages;
|
|
icbLabel.Enabled := Storage.IsLabelColorAvailable;
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.SetCaptions;
|
|
begin
|
|
Caption := cxGetResourceString(@scxEvent) + ' - ' + EventName;
|
|
// events
|
|
lbResource.Caption := cxGetResourceString(@scxResource);
|
|
lbSubject.Caption := cxGetResourceString(@scxSubject);
|
|
lbLocation.Caption := cxGetResourceString(@scxLocation);
|
|
lbLabel.Caption := cxGetResourceString(@scxLabel);
|
|
lbShowTimeAs.Caption := cxGetResourceString(@scxShowTimeAs);
|
|
lbStartTime.Caption := cxGetResourceString(@scxStartTime);
|
|
lbEndTime.Caption := cxGetResourceString(@scxEndTime);
|
|
cbAllDayEvent.Caption := cxGetResourceString(@scxAllDayEvent);
|
|
// buttons
|
|
btnOk.Caption := cxGetResourceString(@scxOk);
|
|
btnCancel.Caption := cxGetResourceString(@scxCancel);
|
|
btnDelete.Caption := cxGetResourceString(@scxDelete);
|
|
btnRecurrence.Caption := cxGetResourceString(@scxRecurrence);
|
|
btnRecurrence.Enabled := Storage.IsRecurrenceAvailable;
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.UpdateEventValuesFromControls;
|
|
begin
|
|
if teSubject.EditModified then
|
|
Event.Caption := teSubject.Text;
|
|
if teLocation.EditModified then
|
|
Event.Location := teLocation.Text;
|
|
if meMessage.EditModified then
|
|
Event.Message := meMessage.Text;
|
|
//Event.Reminder := cbReminder.Checked;
|
|
//Event.ReminderTime := GetReminderTime;
|
|
if (Event.EventType = etNone) or not ForceSeries then
|
|
begin
|
|
Event.Start := deStart.Date + teStart.Time + BiasTime;
|
|
Event.Finish := deEnd.Date + teEnd.Time + Ord(cbAllDayEvent.Checked) + BiasTime;
|
|
if cbAllDayEvent.EditModified then
|
|
Event.AllDayEvent := cbAllDayEvent.Checked;
|
|
end;
|
|
if icbShowTimeAs.EditModified then
|
|
Event.State := icbShowTimeAs.ItemIndex;
|
|
if icbLabel.EditModified and (icbLabel.ItemIndex <> -1) then
|
|
Event.LabelColor := EventLabelColors[icbLabel.ItemIndex];
|
|
if pnlResource.Visible and (cbResources.ItemIndex <> -1) then
|
|
Event.ResourceID := Storage.ResourceIDs[cbResources.ItemIndex];
|
|
end;
|
|
|
|
function TcxSchedulerEventEditorForm.GetEventName: string;
|
|
begin
|
|
Result := cxGetResourceString(@scxUntitled);
|
|
if Event.Caption <> '' then
|
|
Result := Event.Caption;
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.OnChanged(Sender: TObject);
|
|
begin
|
|
FModified := True;
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.FormCloseQuery(Sender: TObject;
|
|
var CanClose: Boolean);
|
|
var
|
|
AMsgRes: Integer;
|
|
begin
|
|
CanClose := (ModalResult = mrOk) or not Modified;
|
|
if not CanClose then
|
|
begin
|
|
if ModalResult = mrAbort then
|
|
CanClose := MessageDlg(cxGetResourceString(@scxDeleteConfirmation),
|
|
mtWarning, [mbYes, mbNo], 0) = mrYes
|
|
else
|
|
if ModalResult = mrCancel then
|
|
begin
|
|
AMsgRes := MessageDlg(cxGetResourceString(@scxExitConfirmation),
|
|
mtWarning, [mbYes, mbNo, mbCancel], 0);
|
|
CanClose := AMsgRes in [mrYes, mrNo];
|
|
if AMsgRes = mrYes then
|
|
begin
|
|
if (Event.Pattern <> nil) and (Event.EventType = etNone) then
|
|
Event.Pattern.DeleteExceptions;
|
|
ModalResult := mrOk;
|
|
end;
|
|
end;
|
|
if not CanClose then
|
|
ModalResult := mrNone;
|
|
end;
|
|
if ModalResult = mrOk then
|
|
CanClose := IsValid;
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.FormKeyDown(Sender: TObject;
|
|
var Key: Word; Shift: TShiftState);
|
|
begin
|
|
if (Key = VK_ESCAPE) and not IsInternalPopupWindowShowed(ActiveControl) then
|
|
begin
|
|
ModalResult := mrCancel;
|
|
Key := 0;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.FormActivate(Sender: TObject);
|
|
begin
|
|
OnActivate := nil;
|
|
if RecurrenceActivate then
|
|
btnRecurrenceClick(nil);
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.btnRecurrenceClick(Sender: TObject);
|
|
var
|
|
AModified: Boolean;
|
|
begin
|
|
AModified := False;
|
|
if (Event.EventType = etNone) then
|
|
begin
|
|
Event.AllDayEvent := cbAllDayEvent.Checked;
|
|
Event.Start := deStart.Date + teStart.Time;
|
|
Event.Finish := deEnd.Date + teEnd.Time + Ord(cbAllDayEvent.Checked);
|
|
end;
|
|
if cxShowRecurrenceEditor(Event, icbShowTimeAs.Style.LookAndFeel, AModified,
|
|
ReadOnly, FNeedCheckLossOfExceptions, True) then
|
|
begin
|
|
DeleteExceptions := True;
|
|
FNeedCheckLossOfExceptions := False;
|
|
FForceSeries := True;
|
|
end
|
|
else
|
|
DeleteExceptions := DeleteExceptions or ((Event.Pattern <> nil) and (Event.EventType = etNone));
|
|
FModified := not ReadOnly and (FModified or AModified);
|
|
CheckVisible;
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.cbAllDayEventPropertiesChange(
|
|
Sender: TObject);
|
|
const
|
|
States: array[Boolean] of Byte = (tlsBusy, tlsFree);
|
|
var
|
|
ACanCorrect: Boolean;
|
|
begin
|
|
ACanCorrect := icbShowTimeAs.ItemIndex = States[Event.AllDayEvent];
|
|
Event.AllDayEvent := cbAllDayEvent.Checked;
|
|
if ACanCorrect then
|
|
icbShowTimeAs.ItemIndex := States[Event.AllDayEvent];
|
|
FModified := True;
|
|
CheckVisible;
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.StartDateChanged(Sender: TObject);
|
|
begin
|
|
OnChanged(nil);
|
|
deEnd.Date := deStart.Date + DateOf(FDuration) - Ord(cbAllDayEvent.Checked);
|
|
FDuration := (DateOf(deEnd.Date) + TimeOf(teEnd.Time)) -
|
|
(DateOf(deStart.Date) + TimeOf(teStart.Time)) + Ord(cbAllDayEvent.Checked);
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.SetReadOnly(AValue: Boolean);
|
|
begin
|
|
if FReadOnly <> AValue then
|
|
begin
|
|
pnlCaption.Enabled := not AValue;
|
|
pnlReminder.Enabled := not AValue;
|
|
pnlTime.Enabled := not AValue;
|
|
pnlResource.Enabled := not AValue;
|
|
meMessage.Properties.ReadOnly := AValue;
|
|
btnCancel.Enabled := not AValue;
|
|
btnDelete.Enabled := not AValue and btnDelete.Enabled;
|
|
FReadOnly := AValue;
|
|
end;
|
|
end;
|
|
|
|
procedure TcxSchedulerEventEditorForm.btnDeleteClick(Sender: TObject);
|
|
var
|
|
AOccurrence: Boolean;
|
|
begin
|
|
if not Assigned(FOnDeleteFunc) or FOnDeleteFunc(Event) then
|
|
begin
|
|
if (Event.Pattern <> nil) and Event.IsRecurring then
|
|
if not ForceSeries then
|
|
begin
|
|
if not cxShowRecurrenceSelectionDialog(Event, rsmDeleting, btnOk.LookAndFeel,
|
|
AOccurrence) then Exit;
|
|
DeleteSeries := not AOccurrence;
|
|
end
|
|
else
|
|
DeleteSeries := True;
|
|
ModalResult := mrAbort;
|
|
end;
|
|
end;
|
|
|
|
initialization
|
|
RegisterClass(TBevel);
|
|
|
|
end.
|