jvtfmanager.pas

East make Tray Icon in delphi

{-----------------------------------------------------------------------------
The contents of this file are subject to the Mozilla Public License
Version 1.1 (the "License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.mozilla.org/MPL/MPL-1.1.html

Software distributed under the License is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either expressed or implied. See the License for
the specific language governing rights and limitations under the License.

The Original Code is: JvTFManager.PAS, released on 2003-08-01.

The Initial Developer of the Original Code is Unlimited Intelligence Limited.
Portions created by Unlimited Intelligence Limited are Copyright (C) 1999-2002 Unlimited Intelligence Limited.
All Rights Reserved.

Contributor(s):
Mike Kolter (original code)

You may retrieve the latest version of this file at the Project JEDI's JVCL home page,
located at http://jvcl.sourceforge.net

Known Issues:
-----------------------------------------------------------------------------}
// $Id: JvTFManager.pas,v 1.44 2005/02/17 10:20:56 marquardt Exp $

unit JvTFManager;

{$I jvcl.inc}

interface

uses
  {$IFDEF USEJVCL}
  {$IFDEF UNITVERSIONING}
  JclUnitVersioning,
  {$ENDIF UNITVERSIONING}
  {$ENDIF USEJVCL}
  Classes, SysUtils, Windows, Controls, Messages,
  Graphics, ImgList, ExtCtrls, Printers,
  {$IFDEF USEJVCL}
  JvComponent, JvTypes,
  {$ENDIF USEJVCL}
  JvTFUtils;

const
  CN_REQUESTREFRESH = $BD01;

type
  {$IFNDEF USEJVCL}
  THintString = string;
  {$ENDIF !USEJVCL}
  // Redeclaration of this type.  It is used in JvTFMonths.TJvTFDrawDWTitleEvent.
  // If not redeclared here, Delphi complains of 'unknown type' because it
  // will not automatically bring in 'JvTFUtils' into the uses clause when
  // a TJvTFDrawDWTitleEvent prototype is created.
  TTFDayOfWeek = JvTFUtils.TTFDayOfWeek;
  EJvTFScheduleManagerError = class(Exception);

  TJvTFTimeRange = record
    StartTime: TTime;
    EndTime: TTime;
  end;

  TJvTFServNotifyCode = (sncDestroyAppt,
    sncDestroySchedule,
    sncLoadAppt,
    sncSchedLoadAppt,
    sncSchedUnloadAppt,
    sncPostAppt,
    sncDeleteAppt,
    sncRequestSchedule,
    sncReleaseSchedule,
    sncConnectComponent,
    sncDisconnectComponent,
    sncConnectControl,
    sncDisconnectControl,
    sncConnectAppt,
    sncDisconnectAppt,
    sncRefresh);

  TJvTFScheduleManager = class;
  TJvTFSched = class;
  TJvTFAppt = class;
  TJvTFComponent = class;
  TJvTFControl = class;
  TJvTFPrinter = class;
  TJvTFHint = class;
  //  TJvTFNavigator = class;

  TJvTFSchedClass = class of TJvTFSched;
  TJvTFApptClass = class of TJvTFAppt;
  TJvTFHintClass = class of TJvTFHint;

  TCNRequestRefresh = record
    Msg: Cardinal;
    Schedule: TJvTFSched;
    Unused: Longint;
    Result: Longint;
  end;

  TJvTFDateList = class
  private
    FOnChange: TNotifyEvent;
  protected
    FList: TStringList;
    function GetDate(Index: Integer): TDate;
    procedure Change; virtual;
  public
    constructor Create;
    destructor Destroy; override;
    function Add(ADate: TDate): Integer;
    procedure Delete(Index: Integer);
    procedure Clear;
    function Count: Integer;
    function IndexOf(ADate: TDate): Integer;
    property Dates[Index: Integer]: TDate read GetDate; default;
    property OnChange: TNotifyEvent read FOnChange write FOnChange;
  end;

  TJvTFNavEvent = procedure(Sender: TObject; aControl: TJvTFControl;
    SchedNames: TStringList; Dates: TJvTFDateList) of object;
  TJvTFControlEvent = procedure(Sender: TObject; aControl: TJvTFControl) of object;
  TJvTFSchedEvent = procedure(Sender: TObject; Schedule: TJvTFSched) of object;
  TJvTFApptEvent = procedure(Sender: TObject; Appt: TJvTFAppt) of object;
  TJvTFVarApptEvent = procedure(Sender: TObject; var Appt: TJvTFAppt) of object;
  TJvTFFlushEvent = procedure(Sender, FlushObj: TObject; var FlushIt: Boolean) of object;

  // implicit post fix
  TJvTFPostApptQueryEvent = procedure(Sender: TObject; Appt: TJvTFAppt;
    var CanPost: Boolean) of object;

  TJvTFCustomImageMap = class(TPersistent)
  private
    FMap: TStringList;
    function GetImage(MapIndex: Integer): Integer;
    procedure SetImage(MapIndex: Integer; Value: Integer);
    function GetImageName(MapIndex: Integer): string;
  protected
    FAppt: TJvTFAppt;
    procedure Change;
  public
    constructor Create(anAppt: TJvTFAppt);
    destructor Destroy; override;
    property Images[MapIndex: Integer]: Integer read GetImage write SetImage; default;
    property ImageNames[MapIndex: Integer]: string read GetImageName;
    function Count: Integer;
    procedure Add(const ImageName: string; ImageIndex: Integer);
    procedure Delete(MapIndex: Integer);
    procedure Move(SrcMapIndex, DestMapIndex: Integer);
    function FindMapIndex(const ImageName: string): Integer;
    function FindImageIndex(const ImageName: string): Integer;
    procedure Clear;
    procedure Assign(Source: TPersistent); override;
  end;

  TJvTFStatePic = (spAlarmEnabled, spAlarmDisabled, spShared, spRecurring,
    spModified);

  TJvTFStateImageMap = class(TPersistent)
  private
    FPics: array[Low(TJvTFStatePic)..High(TJvTFStatePic)] of Integer;

    procedure SetImage(StatePicID: TJvTFStatePic; Value: Integer);
    function GetImage(StatePicID: TJvTFStatePic): Integer;
    function GetAlarmDisabled: Integer;
    function GetAlarmEnabled: Integer;
    function GetModified: Integer;
    function GetRecurring: Integer;
    function GetShared: Integer;
    procedure SetAlarmDisabled(const Value: Integer);
    procedure SetAlarmEnabled(const Value: Integer);
    procedure SetModified(const Value: Integer);
    procedure SetRecurring(const Value: Integer);
    procedure SetShared(const Value: Integer);
  protected
    FScheduleManager: TJvTFScheduleManager;
    FUpdating: Boolean;
    procedure Change;
  public
    constructor Create(Serv: TJvTFScheduleManager);
    procedure BeginUpdate;
    procedure EndUpdate;
    procedure Clear;
    procedure Assign(Source: TPersistent); override;
    property Pics[Index: TJvTFStatePic]: Integer read GetImage write SetImage;
  published
    property AlarmEnabled: Integer {index spAlarmEnabled}
    read GetAlarmEnabled write SetAlarmEnabled;
    property AlarmDisabled: Integer {index spAlarmDisabled}
    read GetAlarmDisabled write SetAlarmDisabled;
    property Shared: Integer {index spShared}
    read GetShared write SetShared;
    property Recurring: Integer {index spRecurring}
    read GetRecurring write SetRecurring;
    //read GetImage write SetImage;
    property Modified: Integer {index spModified}
    read GetModified write SetModified;
  end;

  TDynTimeRangeArray = array of TJvTFTimeRange;

  TDynApptArray = array of TJvTFAppt;

  TDynSchedArray = array of TJvTFSched;

  TJvTFAppt = class(TPersistent)
  private
    FStartDate: TDate;
    FEndDate: TDate;
    FStartTime: TTime;
    FEndTime: TTime;
    FDescription: string;
    FAlarmEnabled: Boolean;
    FAlarmAdvance: Integer;
    FImageMap: TJvTFCustomImageMap;
    FData: Integer;
    FPersistent: Boolean;
    FColor: TColor;
    FBarColor: TColor;
    FRefreshed: Boolean;

    function GetDescription: string;
    procedure SetDescription(Value: string);
    procedure SetAlarmEnabled(Value: Boolean);
    procedure SetAlarmAdvance(Value: Integer);
    procedure SetColor(Value: TColor);
    procedure SetBarColor(Value: TColor);
    function GetStartDateTime: TDateTime;
    function GetEndDateTime: TDateTime;
    function GetStartDate: TDate;
    function GetEndDate: TDate;
    function GetStartTime: TTime;
    function GetEndTime: TTime;
    procedure SetRefreshed(Value: Boolean);
  protected
    FID: string;
    FModified: Boolean;
    FScheduleManager: TJvTFScheduleManager;
    FConnections: TStringList;
    FSchedules: TStringList;
    FDeleting: Boolean;
    // implicit post fix
    FUpdating: Boolean;

    procedure Notify(Sender: TObject; Code: TJvTFServNotifyCode);
    procedure NotifyManager(Serv: TJvTFScheduleManager; Sender: TObject;
      Code: TJvTFServNotifyCode);
    procedure NotifySchedule(Sched: TJvTFSched; Sender: TObject;
      Code: TJvTFServNotifyCode);

    function GetConnection(Index: Integer): TJvTFSched;
    function GetSchedule(Index: Integer): string;
    procedure CheckConnections;

    procedure Connect(Schedule: TJvTFSched);
    procedure Disconnect(Schedule: TJvTFSched);
    procedure Change;
    procedure InternalClearSchedules;
    procedure DeleteApptNotification;
    // implicit post fix
    procedure PostApptNotification;
    procedure RefreshNotification;
  public
    constructor Create(Serv: TJvTFScheduleManager; const ApptID: string); virtual;
    destructor Destroy; override;

    procedure Assign(Source: TPersistent); override;
    procedure SetStartEnd(NewStartDate: TDate; NewStartTime: TTime;
      NewEndDate: TDate; NewEndTime: TTime);

    procedure SetModified;
    function Modified: Boolean; dynamic;
    property ScheduleManager: TJvTFScheduleManager read FScheduleManager;

    function ConnectionCount: Integer;
    property Connections[Index: Integer]: TJvTFSched read GetConnection;

    function ScheduleCount: Integer;
    property Schedules[Index: Integer]: string read GetSchedule;
    procedure AddSchedule(const SchedName: string);
    procedure RemoveSchedule(const SchedName: string);
    procedure AssignSchedules(List: TStrings);
    procedure ClearSchedules;
    function IndexOfSchedule(const SchedName: string): Integer;
    function Shared: Boolean;

    procedure Post;
    procedure Refresh;
    procedure Delete;

    // implicit post fix
    procedure BeginUpdate;
    procedure EndUpdate;
    property Updating: Boolean read FUpdating;

    property ImageMap: TJvTFCustomImageMap read FImageMap write FImageMap;
    procedure RefreshControls;
    property Refreshed: Boolean read FRefreshed write SetRefreshed;
  published
    property ID: string read FID;
    property StartDate: TDate read GetStartDate;
    property EndDate: TDate read GetEndDate;
    property StartTime: TTime read GetStartTime;
    property EndTime: TTime read GetEndTime;
    property StartDateTime: TDateTime read GetStartDateTime;
    property EndDateTime: TDateTime read GetEndDateTime;
    property Description: string read GetDescription write SetDescription;
    property AlarmEnabled: Boolean read FAlarmEnabled write SetAlarmEnabled;
    property AlarmAdvance: Integer read FAlarmAdvance write SetAlarmAdvance;
    property Data: Integer read FData write FData;
    property Persistent: Boolean read FPersistent write FPersistent;
    property Color: TColor read FColor write SetColor default clDefault;
    property BarColor: TColor read FBarColor write SetBarColor default clDefault;
  end;

  TJvTFSched = class(TObject)
  private
    FAppts: TStringList;
    FConControls: TStringList;
    FConComponents: TStringList;
    FDestroying: Boolean;
    FData: Integer;
    FPersistent: Boolean;
    FSchedDisplayName: string;
    procedure SetSchedDisplayName(const Value: string);

    function GetAppt(Index: Integer): TJvTFAppt;
  protected
    FSchedName: string;
    FSchedDate: TDate;
    FScheduleManager: TJvTFScheduleManager;
    FCached: Boolean;
    FCachedTime: DWORD;
    procedure Notify(Sender: TObject; Code: TJvTFServNotifyCode);
    procedure NotifyManager(Serv: TJvTFScheduleManager; Sender: TObject;
      Code: TJvTFServNotifyCode);
    procedure NotifyAppt(Appt: TJvTFAppt; Sender: TObject;
      Code: TJvTFServNotifyCode);
    function GetConControl(Index: Integer): TJvTFControl;
    function GetConComponent(Index: Integer): TJvTFComponent;
    procedure ConnectAppt(Appt: TJvTFAppt);
    procedure DisconnectAppt(Appt: TJvTFAppt);
    procedure ConnectionsOnChange(Sender: TObject);
    procedure CheckConnections;
    function GetFreeUsedTime(FreeTime: Boolean): TDynTimeRangeArray; dynamic;
  public
    constructor Create(Serv: TJvTFScheduleManager; const AName: string; ADate: TDate); virtual;
    destructor Destroy; override;

    function ApptCount: Integer;
    function ApptByID(const ID: string): TJvTFAppt;
    property Appts[Index: Integer]: TJvTFAppt read GetAppt;

    function ConControlCount: Integer;
    property ConControls[Index: Integer]: TJvTFControl read GetConControl;

    function ConComponentCount: Integer;
    property ConComponents[Index: Integer]: TJvTFComponent read GetConComponent;

    procedure AddAppt(Appt: TJvTFAppt);
    procedure RemoveAppt(Appt: TJvTFAppt);

    //procedure RefreshAppts;
    procedure Refresh;
    procedure PostAppts;

    // Conflict and free time methods
    function GetFreeTime: TDynTimeRangeArray; dynamic;
    function GetUsedTime: TDynTimeRangeArray; dynamic;
    function TimeIsFree(TimeRange: TJvTFTimeRange): Boolean; overload; dynamic;
    function TimeIsFree(RangeStart, RangeEnd: TTime): Boolean; overload; dynamic;
    // The ApptHasConflicts(anAppt : TJvTFAppt) method declared here checks
    //  ONLY THIS SCHEDULE!!
    function ApptHasConflicts(anAppt: TJvTFAppt): Boolean; dynamic;
    function EnumConflicts(TimeRange: TJvTFTimeRange): TDynApptArray;
      overload; dynamic;
    function EnumConflicts(RangeStart, RangeEnd: TTime): TDynApptArray;
      overload; dynamic;
    // The following EnumConflicts(anAppt : TJvTFAppt) checks
    //  ONLY THIS SCHEDULE!!
    function EnumConflicts(anAppt: TJvTFAppt): TDynApptArray;
      overload; dynamic;

    property Cached: Boolean read FCached;
    property CachedTime: DWORD read FCachedTime;
    property Destroying: Boolean read FDestroying;

    function GetFirstAppt: TJvTFAppt;
    function GetLastAppt: TJvTFAppt;
  published
    property SchedDisplayName: string read FSchedDisplayName
      write SetSchedDisplayName;
    property SchedName: string read FSchedName;
    property SchedDate: TDate read FSchedDate;
    property ScheduleManager: TJvTFScheduleManager read FScheduleManager;
    property Data: Integer read FData write FData;
    property Persistent: Boolean read FPersistent write FPersistent;
  end;