jvqschedevtstore.pas

East make Tray Icon in delphi

  I: Cardinal;
begin
  I := (Event.Schedule as IJclScheduleDayFrequency).EndTime;
  FStream.WriteBuffer(I, SizeOf(I));
end;

procedure TBinStore.StoreFreqInterval;
var
  I: Cardinal;
begin
  I := (Event.Schedule as IJclScheduleDayFrequency).Interval;
  FStream.WriteBuffer(I, SizeOf(I));
end;

procedure TBinStore.StoreScheduleDailyWeekdays;
var
  EWD: Boolean;
begin
  EWD := (Event.Schedule as IJclDailySchedule).EveryWeekDay;
  FStream.WriteBuffer(EWD, SizeOf(EWD));
end;

procedure TBinStore.StoreScheduleDailyInterval;
var
  I: Cardinal;
begin
  I := (Event.Schedule as IJclDailySchedule).Interval;
  FStream.WriteBuffer(I, SizeOf(I));
end;

procedure TBinStore.StoreScheduleWeeklyDays;
var
  WD: TScheduleWeekDays;
begin
  WD := (Event.Schedule as IJclWeeklySchedule).DaysOfWeek;
  FStream.WriteBuffer(WD, SizeOf(WD));
end;

procedure TBinStore.StoreScheduleWeeklyInterval;
var
  I: Cardinal;
begin
  I := (Event.Schedule as IJclWeeklySchedule).Interval;
  FStream.WriteBuffer(I, SizeOf(I));
end;

procedure TBinStore.StoreScheduleMonthlyDay;
var
  I: Cardinal;
begin
  I := (Event.Schedule as IJclMonthlySchedule).Day;
  FStream.WriteBuffer(I, SizeOf(I));
end;

procedure TBinStore.StoreScheduleMonthlyIndexType;
var
  I: TScheduleIndexKind;
begin
  I := (Event.Schedule as IJclMonthlySchedule).IndexKind;
  FStream.WriteBuffer(I, SizeOf(I));
end;

procedure TBinStore.StoreScheduleMonthlyIndex;
var
  I: Integer;
begin
  I := (Event.Schedule as IJclMonthlySchedule).IndexValue;
  FStream.WriteBuffer(I, SizeOf(I));
end;

procedure TBinStore.StoreScheduleMonthlyInterval;
var
  I: Cardinal;
begin
  I := (Event.Schedule as IJclMonthlySchedule).Interval;
  FStream.WriteBuffer(I, SizeOf(I));
end;

procedure TBinStore.StoreScheduleYearlyDay;
var
  I: Cardinal;
begin
  I := (Event.Schedule as IJclYearlySchedule).Day;
  FStream.WriteBuffer(I, SizeOf(I));
end;

procedure TBinStore.StoreScheduleYearlyMonth;
var
  I: Cardinal;
begin
  I := (Event.Schedule as IJclYearlySchedule).Month;
  FStream.WriteBuffer(I, SizeOf(I));
end;

procedure TBinStore.StoreScheduleYearlyIndexType;
var
  I: TScheduleIndexKind;
begin
  I := (Event.Schedule as IJclYearlySchedule).IndexKind;
  FStream.WriteBuffer(I, SizeOf(I));
end;

procedure TBinStore.StoreScheduleYearlyIndex;
var
  I: Integer;
begin
  I := (Event.Schedule as IJclYearlySchedule).IndexValue;
  FStream.WriteBuffer(I, SizeOf(I));
end;

procedure TBinStore.StoreScheduleYearlyInterval;
var
  I: Integer;
begin
  I := (Event.Schedule as IJclYearlySchedule).Interval;
  FStream.WriteBuffer(I, SizeOf(I));
end;

//=== TTxtStore ==============================================================

const
  TxtIdentifiers: array [TSchedEvtItemKind] of PChar =
    ('', {seikUnknown}
     'Start', {seikScheduleStart}
     'Recur type', {seikScheduleRecurType}
     'End type', {seikScheduleEndType}
     'End count', {seikScheduleEndCount}
     'End', {seikScheduleEndDate}
     'Frequency start', {seikFreqStart}
     'Frequency end', {seikFreqEnd}
     'Frequency interval', {seikFreqInterval}
     'Daily every weekday', {seikScheduleDailyWeekdays}
     'Daily interval', {seikScheduleDailyInterval}
     'Weekly days', {seikScheduleWeeklyDays}
     'Weekly interval', {seikScheduleWeeklyInterval}
     'Monthly day', {seikScheduleMonthlyDay}
     'Monthly index type', {seikScheduleMonthlyIndexType}
     'Monthly index', {seikScheduleMonthlyIndex}
     'Monthly interval', {seikScheduleMonthlyInterval}
     'Yearly day', {seikScheduleYearlyDay}
     'Yearly month', {seikScheduleYearlyMonth}
     'Yearly index type', {seikScheduleYearlyIndexType}
     'Yearly index', {seikScheduleYearlyIndex}
     'Yearly interval'); {seikScheduleYearlyInterval}

  sTXTID_SchedGeneric = '# Schedule: Generic';
  sTXTID_SchedRecur = '# Schedule: Recurring info';
  sTXTID_SchedEnd = '# Schedule: End info';
  sTXTID_SchedFreq = '# Schedule: Day frequency';
  sTXTID_SchedDaily = '# Schedule: Daily info';
  sTXTID_SchedWeekly = '# Schedule: Weekly info';
  sTXTID_SchedMonthly = '# Schedule: Monthly info';
  sTXTID_SchedYearly = '# Schedule: Yearly info';

type
  TTxtStore = class(TJvSchedEvtStore)
  private
    FStream: TStream;
    FOwnsStream: Boolean;
  protected
    // Retrieving items: Schedule
    procedure CheckSignature; override;
    procedure CheckVersion; override;
    function NextItemKind: TSchedEvtItemKind; override;
    procedure RestoreScheduleStart; override;
    procedure RestoreScheduleRecurType; override;
    procedure RestoreScheduleEndType; override;
    procedure RestoreScheduleEndCount; override;
    procedure RestoreScheduleEndDate; override;
    procedure RestoreFreqStart; override;
    procedure RestoreFreqEnd; override;
    procedure RestoreFreqInterval; override;
    procedure RestoreScheduleDailyWeekdays; override;
    procedure RestoreScheduleDailyInterval; override;
    procedure RestoreScheduleWeeklyDays; override;
    procedure RestoreScheduleWeeklyInterval; override;
    procedure RestoreScheduleMonthlyDay; override;
    procedure RestoreScheduleMonthlyIndexType; override;
    procedure RestoreScheduleMonthlyIndex; override;
    procedure RestoreScheduleMonthlyInterval; override;
    procedure RestoreScheduleYearlyDay; override;
    procedure RestoreScheduleYearlyMonth; override;
    procedure RestoreScheduleYearlyIndexType; override;
    procedure RestoreScheduleYearlyIndex; override;
    procedure RestoreScheduleYearlyInterval; override;
    // Storing items: signature (only for unstructured storages) and versioning
    procedure StoreSignature; override;
    procedure StoreVersion; override;
    // Storing items: Schedule
    procedure StoreScheduleStart; override;
    procedure StoreScheduleRecurType; override;
    procedure StoreScheduleEndType; override;
    procedure StoreScheduleEndCount; override;
    procedure StoreScheduleEndDate; override;
    procedure StoreFreqStart; override;
    procedure StoreFreqEnd; override;
    procedure StoreFreqInterval; override;
    procedure StoreScheduleDailyWeekdays; override;
    procedure StoreScheduleDailyInterval; override;
    procedure StoreScheduleWeeklyDays; override;
    procedure StoreScheduleWeeklyInterval; override;
    procedure StoreScheduleMonthlyDay; override;
    procedure StoreScheduleMonthlyIndexType; override;
    procedure StoreScheduleMonthlyIndex; override;
    procedure StoreScheduleMonthlyInterval; override;
    procedure StoreScheduleYearlyDay; override;
    procedure StoreScheduleYearlyMonth; override;
    procedure StoreScheduleYearlyIndexType; override;
    procedure StoreScheduleYearlyIndex; override;
    procedure StoreScheduleYearlyInterval; override;
    procedure BeginStruct(const StructType: TSchedEvtStructKind); override;
    procedure EndStruct; override;
    procedure CheckBeginStruct(const StructType: TSchedEvtStructKind); override;
    procedure CheckEndStruct; override;
    function ReadLn: string;
    function ReadNextLine: string;
    function ReadItem(out AName: string): string;
    procedure WriteLn(const S: string);
    function ReadEnum(const AName: string;  TypeInfo: PTypeInfo): Integer;
    function ReadInt(const AName: string): Int64;
    procedure ReadSet(const AName: string; out Value;  TypeInfo: PTypeInfo);
    function ReadStamp(const AName: string): TTimeStamp;
    function ReadStampDate(const AName: string): Integer;
    function ReadStampTime(const AName: string): Integer;
    procedure WriteEnum(const AName: string; const Ordinal: Integer;  TypeInfo: PTypeInfo);
    procedure WriteInt(const AName: string; const Value: Int64);
    procedure WriteSet(const AName: string; const Value;  TypeInfo: PTypeInfo);
    procedure WriteStamp(const AName: string; const Stamp: TTimeStamp);
    procedure WriteStampDate(const AName: string; const Date: Integer);
    procedure WriteStampTime(const AName: string; const Time: Integer);
  public
    function GetAttributes: TSchedEvtStoreAttributes; override;
    constructor Create(const AStream: TStream; const AOwnsStream: Boolean = True);
    destructor Destroy; override;
  end;

constructor TTxtStore.Create(const AStream: TStream; const AOwnsStream: Boolean);
begin
  inherited Create;
  FStream := AStream;
  FOwnsStream := AOwnsStream;
end;

destructor TTxtStore.Destroy;
begin
  if FOwnsStream then
    FreeAndNil(FStream);
  inherited Destroy;
end;

procedure TTxtStore.CheckSignature;
begin
end;

procedure TTxtStore.CheckVersion;
begin
end;

function TTxtStore.NextItemKind: TSchedEvtItemKind;
var
  SPos: Integer;
  ItemName: string;
  I: Integer;
begin
  SPos := FStream.Position;
  try
    ReadItem(ItemName);
    I := Pos('.', ItemName);
    if I > 0 then
      ItemName := Copy(ItemName, 1, I - 1);
    Result := High(TSchedEvtItemKind);
    while (Result > Low(TSchedEvtItemKind)) and
      not AnsiSameText(ItemName, TxtIdentifiers[Result]) do
      Dec(Result);
  finally
    FStream.Position := SPos;
  end;
end;

procedure TTxtStore.RestoreScheduleStart;
begin
  Event.Schedule.StartDate := ReadStamp(TxtIdentifiers[seikScheduleStart]);
end;

procedure TTxtStore.RestoreScheduleRecurType;
begin
  Event.Schedule.RecurringType := TScheduleRecurringKind(ReadEnum(
    TxtIdentifiers[seikScheduleRecurType], TypeInfo(TScheduleRecurringKind)));
end;

procedure TTxtStore.RestoreScheduleEndType;
begin
  Event.Schedule.EndType := TScheduleEndKind(ReadEnum(
    TxtIdentifiers[seikScheduleEndType], TypeInfo(TScheduleEndKind)));
end;

procedure TTxtStore.RestoreScheduleEndCount;
begin
  Event.Schedule.EndCount := ReadInt(TxtIdentifiers[seikScheduleEndCount]);
end;

procedure TTxtStore.RestoreScheduleEndDate;
begin
  Event.Schedule.EndDate := ReadStamp(TxtIdentifiers[seikScheduleEndDate]);
end;

procedure TTxtStore.RestoreFreqStart;
begin
  (Event.Schedule as IJclScheduleDayFrequency).StartTime := ReadStampTime(TxtIdentifiers[seikFreqStart]);
end;

procedure TTxtStore.RestoreFreqEnd;
begin
  (Event.Schedule as IJclScheduleDayFrequency).EndTime := ReadStampTime(TxtIdentifiers[seikFreqEnd]);
end;

procedure TTxtStore.RestoreFreqInterval;
begin
  (Event.Schedule as IJclScheduleDayFrequency).Interval := ReadStampTime(TxtIdentifiers[seikFreqInterval]);
end;

procedure TTxtStore.RestoreScheduleDailyWeekdays;
begin
  (Event.Schedule as IJclDailySchedule).EveryWeekDay := Boolean(ReadEnum(TxtIdentifiers[seikScheduleDailyWeekdays],
    TypeInfo(Boolean)));
end;

procedure TTxtStore.RestoreScheduleDailyInterval;
begin
  (Event.Schedule as IJclDailySchedule).Interval := ReadInt(TxtIdentifiers[seikScheduleDailyInterval]);
end;

procedure TTxtStore.RestoreScheduleWeeklyDays;
var
  I: TScheduleWeekDays;
begin
  ReadSet(TxtIdentifiers[seikScheduleWeeklyDays], I, TypeInfo(TScheduleWeekDays));
  (Event.Schedule as IJclWeeklySchedule).DaysOfWeek := I;
end;

procedure TTxtStore.RestoreScheduleWeeklyInterval;
begin
  (Event.Schedule as IJclWeeklySchedule).Interval := ReadInt(TxtIdentifiers[seikScheduleWeeklyInterval]);
end;

procedure TTxtStore.RestoreScheduleMonthlyDay;
begin
  (Event.Schedule as IJclMonthlySchedule).Day := ReadInt(TxtIdentifiers[seikScheduleMonthlyDay]);
end;

procedure TTxtStore.RestoreScheduleMonthlyIndexType;
begin
  (Event.Schedule as IJclMonthlySchedule).IndexKind :=
    TScheduleIndexKind(ReadEnum(TxtIdentifiers[seikScheduleMonthlyIndexType], TypeInfo(TScheduleIndexKind)));
end;

procedure TTxtStore.RestoreScheduleMonthlyIndex;
begin
  (Event.Schedule as IJclMonthlySchedule).IndexValue := ReadInt(TxtIdentifiers[seikScheduleMonthlyIndex]);
end;

procedure TTxtStore.RestoreScheduleMonthlyInterval;
begin
  (Event.Schedule as IJclMonthlySchedule).Interval := ReadInt(TxtIdentifiers[seikScheduleMonthlyInterval]);
end;

procedure TTxtStore.RestoreScheduleYearlyDay;
begin
  (Event.Schedule as IJclYearlySchedule).Day := ReadInt(TxtIdentifiers[seikScheduleYearlyDay]);
end;

procedure TTxtStore.RestoreScheduleYearlyMonth;
begin
  (Event.Schedule as IJclYearlySchedule).Month := ReadInt(TxtIdentifiers[seikScheduleYearlyMonth]);
end;

procedure TTxtStore.RestoreScheduleYearlyIndexType;
begin
  (Event.Schedule as IJclYearlySchedule).IndexKind :=
    TScheduleIndexKind(ReadEnum(TxtIdentifiers[seikScheduleYearlyIndexType], TypeInfo(TScheduleIndexKind)));
end;

procedure TTxtStore.RestoreScheduleYearlyIndex;
begin
  (Event.Schedule as IJclYearlySchedule).IndexValue := ReadInt(TxtIdentifiers[seikScheduleYearlyIndex]);
end;

procedure TTxtStore.RestoreScheduleYearlyInterval;
begin
  (Event.Schedule as IJclYearlySchedule).Interval := ReadInt(TxtIdentifiers[seikScheduleYearlyInterval]);
end;

procedure TTxtStore.StoreSignature;