jvqschedevtstore.pas

East make Tray Icon in delphi

      case Schedule.RecurringType of
        srkDaily:
          begin
            BeginStruct(seskScheduleDaily);
            if not UsesIdentifiers or (Schedule as IJclDailySchedule).EveryWeekDay then
              StoreScheduleDailyWeekdays;
            if not UsesIdentifiers or not (Schedule as IJclDailySchedule).EveryWeekDay then
              StoreScheduleDailyInterval;
            EndStruct; {seskScheduleDaily}
          end;
        srkWeekly:
          begin
            BeginStruct(seskScheduleWeekly);
            StoreScheduleWeeklyDays;
            StoreScheduleWeeklyInterval;
            EndStruct; {seskScheduleWeekly}
          end;
        srkMonthly:
          begin
            BeginStruct(seskScheduleMonthly);
            BeginStruct(seskScheduleMonthlyIndex);
            StoreScheduleMonthlyIndexType;
            if (Schedule as IJclMonthlySchedule).IndexKind <> sikNone then
              StoreScheduleMonthlyIndex;
            EndStruct; {seskScheduleMonthlyIndex}
            if (Schedule as IJclMonthlySchedule).IndexKind = sikNone then
              StoreScheduleMonthlyDay;
            StoreScheduleMonthlyInterval;
            EndStruct; {seskScheduleMonthly}
          end;
        srkYearly:
          begin
            BeginStruct(seskScheduleYearly);
            BeginStruct(seskScheduleYearlyIndex);
            StoreScheduleYearlyIndexType;
            if (Schedule as IJclYearlySchedule).IndexKind <> sikNone then
              StoreScheduleYearlyIndex;
            EndStruct; {seskScheduleYearlyIndex}
            if (Schedule as IJclYearlySchedule).IndexKind = sikNone then
              StoreScheduleYearlyDay;
            StoreScheduleYearlyMonth;
            StoreScheduleYearlyInterval;
            EndStruct; {seskScheduleYearly}
          end;
      end;
    end;
    EndStruct; {seskScheduleRecurInfo}
    EndStruct; {seskSchedule}
  end;
end;

procedure TJvSchedEvtStore.LoadEventSettings(const Event: TJvEventCollectionItem);
begin
  raise EJVCLException.CreateRes(@RsENotImplemented_);
end;

procedure TJvSchedEvtStore.SaveEventSettings(const Event: TJvEventCollectionItem);
begin
  raise EJVCLException.CreateRes(@RsENotImplemented_);
end;

//=== TBinStore ==============================================================

const
  BinStreamID = 'JVSE';
  BinStreamVer = Word($0001);

type
  TBinStore = class(TJvSchedEvtStore)
  private
    FStream: TStream;
    FOwnsStream: Boolean;
    FStreamVersion: Word; // Only used for reading
  protected
    // Retrieving items: Schedule
    procedure CheckSignature; override;
    procedure CheckVersion; 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;
  public
    constructor Create(const AStream: TStream; const AOwnsStream: Boolean = True);
    destructor Destroy; override;
  end;

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

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

procedure TBinStore.CheckSignature;
var
  S: string;
begin
  SetLength(S, Length(BinStreamID));
  FStream.ReadBuffer(S[1], Length(BinStreamID));
  if S <> BinStreamID then
    raise EJVCLException.CreateRes(@RsENotASchedule);
end;

procedure TBinStore.CheckVersion;
begin
  FStream.ReadBuffer(FStreamVersion, SizeOf(FStreamVersion));
  if FStreamVersion > BinStreamVer then
    raise EJVCLException.CreateResFmt(@RsEUnknownScheduleVersions, [IntToHex(FStreamVersion, 4)]);
end;

procedure TBinStore.RestoreScheduleStart;
var
  I: TTimeStamp;
begin
  FStream.ReadBuffer(I, SizeOf(I));
  Event.Schedule.StartDate := I;
end;

procedure TBinStore.RestoreScheduleRecurType;
var
  I: TScheduleRecurringKind;
begin
  FStream.ReadBuffer(I, SizeOf(I));
  Event.Schedule.RecurringType := I;
end;

procedure TBinStore.RestoreScheduleEndType;
var
  I: TScheduleEndKind;
begin
  FStream.ReadBuffer(I, SizeOf(I));
  Event.Schedule.EndType := I;
end;

procedure TBinStore.RestoreScheduleEndCount;
var
  I: Cardinal;
begin
  FStream.ReadBuffer(I, SizeOf(I));
  Event.Schedule.EndCount := I;
end;

procedure TBinStore.RestoreScheduleEndDate;
var
  I: TTimeStamp;
begin
  FStream.ReadBuffer(I, SizeOf(I));
  Event.Schedule.EndDate := I;
end;

procedure TBinStore.RestoreFreqStart;
var
  I: Cardinal;
begin
  FStream.ReadBuffer(I, SizeOf(I));
  (Event.Schedule as IJclScheduleDayFrequency).StartTime := I;
end;

procedure TBinStore.RestoreFreqEnd;
var
  I: Cardinal;
begin
  FStream.ReadBuffer(I, SizeOf(I));
  (Event.Schedule as IJclScheduleDayFrequency).EndTime := I;
end;

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

procedure TBinStore.RestoreScheduleDailyWeekdays;
var
  I: Boolean;
begin
  FStream.ReadBuffer(I, SizeOf(I));
  (Event.Schedule as IJclDailySchedule).EveryWeekDay := I;
end;

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

procedure TBinStore.RestoreScheduleWeeklyDays;
var
  I: TScheduleWeekDays;
begin
  FStream.ReadBuffer(I, SizeOf(I));
  (Event.Schedule as IJclWeeklySchedule).DaysOfWeek := I;
end;

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

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

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

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

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

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

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

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

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

procedure TBinStore.RestoreScheduleYearlyInterval;
var
  I: Cardinal;
begin
  FStream.ReadBuffer(I, SizeOf(I));
  (Event.Schedule as IJclYearlySchedule).Interval := I;
end;

procedure TBinStore.StoreSignature;
var
  S: string;
begin
  S := BinStreamID;
  FStream.WriteBuffer(S[1], Length(S));
end;

procedure TBinStore.StoreVersion;
var
  W: Word;
begin
  W := BinStreamVer;
  FStream.writeBuffer(W, SizeOf(W));
end;

procedure TBinStore.StoreScheduleStart;
var
  Stamp: TTimeStamp;
begin
  Stamp := Event.Schedule.StartDate;
  FStream.WriteBuffer(Stamp, SizeOf(Stamp));
end;

procedure TBinStore.StoreScheduleRecurType;
var
  RT: TScheduleRecurringKind;
begin
  RT := Event.Schedule.RecurringType;
  FStream.WriteBuffer(RT, SizeOf(RT));
end;

procedure TBinStore.StoreScheduleEndType;
var
  ET: TScheduleEndKind;
begin
  ET := Event.Schedule.EndType;
  FStream.WriteBuffer(ET, SizeOf(ET));
end;

procedure TBinStore.StoreScheduleEndCount;
var
  I: Cardinal;
begin
  I := Event.Schedule.EndCount;
  FStream.WriteBuffer(I, SizeOf(I));
end;

procedure TBinStore.StoreScheduleEndDate;
var
  Stamp: TTimeStamp;
begin
  Stamp := Event.Schedule.EndDate;
  FStream.WriteBuffer(Stamp, SizeOf(Stamp));
end;

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

procedure TBinStore.StoreFreqEnd;
var