cxgrid.pas

来自「胜天进销存源码,国产优秀的进销存」· PAS 代码 · 共 2,183 行 · 第 1/5 页

{********************************************************************}
{                                                                    }
{       Developer Express Visual Component Library                   }
{       ExpressQuantumGrid                                           }
{                                                                    }
{       Copyright (c) 1998-2008 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 EXPRESSQUANTUMGRID 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 cxGrid;

{$I cxVer.inc}

interface

uses
{$IFDEF DELPHI6}
  Types,
{$ENDIF}
  Windows, Messages,
  Classes, Controls, Graphics, ImgList, Forms, StdCtrls,
  cxClasses, cxGraphics, cxLookAndFeels, cxLookAndFeelPainters, cxControls, cxPC,
  cxNavigator, cxCustomData,
  cxGridCommon, cxGridLevel, cxGridDetailsSite, cxGridCustomView;

const
(*
  CM_DEFERUPDATES = WM_USER + 333;
*)

  cxGridLevelTabsDefaultCaptionAlignment = taCenter;
  cxGridLevelTabsDefaultImageBorder = 0;
  cxGridRootLevelDefaultDetailFrameWidth = 0;
  cxGridDefaultDragOpeningWaitTime = 800;//500;

type
  TcxGridViewInfo = class;
  TcxCustomGrid = class;

  { changes }

  TcxGridLayoutChange = class(TcxCustomGridViewChange)
  public
    procedure Execute; override;
    function IsCompatibleWith(AChange: TcxCustomGridChange): Boolean; override;
  end;

  TcxGridSizeChange = class(TcxCustomGridViewChange)
  private
    FKeepMaster: Boolean;
    FUpdateGridViewOnly: Boolean;
  public
    constructor Create(AGridView: TcxCustomGridView;
      AUpdateGridViewOnly: Boolean = False; AKeepMaster: Boolean = False); reintroduce; virtual;
    procedure Execute; override;
    function IsCompatibleWith(AChange: TcxCustomGridChange): Boolean; override;
    function IsEqual(AChange: TcxCustomGridChange): Boolean; override;
    property KeepMaster: Boolean read FKeepMaster;
    property UpdateGridViewOnly: Boolean read FUpdateGridViewOnly
      write FUpdateGridViewOnly;
  end;

  TcxGridViewChange = class(TcxCustomGridViewChange)
  private
    FUpdateBounds: TRect;
    FUpdateRegion: TcxRegion;
  public
    constructor Create(AGridView: TcxCustomGridView;
      const AUpdateBounds: TRect); reintroduce; overload; virtual;
    constructor Create(AGridView: TcxCustomGridView;
      const AUpdateRegion: TcxRegion); reintroduce; overload; virtual;
    constructor Create(AGridView: TcxCustomGridView); reintroduce; overload;
    destructor Destroy; override;
    procedure Execute; override;
    function IsCompatibleWith(AChange: TcxCustomGridChange): Boolean; override;
    function IsEqual(AChange: TcxCustomGridChange): Boolean; override;
    property UpdateBounds: TRect read FUpdateBounds;
    property UpdateRegion: TcxRegion read FUpdateRegion;
  end;

  { notification }

  TcxGridNotificationKind = (gnkFocusedViewChanged, gnkFocusedRecordChanged,
    gnkRecordCountChanged, gnkContextMenu, gnkCustomization, gnkKeyDown);
  TcxGridNotificationKinds = set of TcxGridNotificationKind;

  TcxCustomGridNotification = class
  protected
    function NotificationKinds: TcxGridNotificationKinds; virtual; abstract;
    procedure Notify(AKind: TcxGridNotificationKind; AData: TObject;
      var AHandled: Boolean); virtual; abstract;
  end;

  { structure navigator }

  TcxCustomGridStructureNavigatorClass = class of TcxCustomGridStructureNavigator;

  TcxCustomGridStructureNavigator = class(TcxControl)
  private
    FGrid: TcxCustomGrid;
  protected
    procedure Changed; virtual;
    procedure FontChanged; override;
    function MayFocus: Boolean; override;

    function CalculateBoundsRect: TRect; virtual; abstract;
  public
    constructor Create(AGrid: TcxCustomGrid); reintroduce; virtual;
    procedure BeforeGridLoading; virtual;
    function IsObjectSelected(AObject: TPersistent): Boolean; virtual; abstract;
    procedure SelectionChanged(ASelection: TList); virtual; abstract;
    procedure SelectObject(AObject: TPersistent; AClearSelection: Boolean); virtual; abstract;
    procedure SelectObjects(AObjects: TList); virtual; abstract;
    procedure UnselectObject(AObject: TPersistent); virtual; abstract;
    property Grid: TcxCustomGrid read FGrid;
  end;

  { handlers }

  TcxCustomGridHandler = class
  private
    FControl: TcxCustomGrid;
    function GetActiveController: TcxCustomGridController;
    function GetActiveGridView: TcxCustomGridView;
    function GetLookAndFeelPainter: TcxCustomLookAndFeelPainterClass;
    function GetViewInfo: TcxGridViewInfo;
  protected
    property ActiveController: TcxCustomGridController read GetActiveController;
    property ActiveGridView: TcxCustomGridView read GetActiveGridView;
    property LookAndFeelPainter: TcxCustomLookAndFeelPainterClass read GetLookAndFeelPainter;
    property ViewInfo: TcxGridViewInfo read GetViewInfo;
  public
    constructor Create(AControl: TcxCustomGrid); virtual;
    property Control: TcxCustomGrid read FControl;
  end;

  TcxGridDesignControllerClass = class of TcxGridDesignController;

  TcxGridDesignController = class(TcxCustomGridDesignController)
  private
    FControl: TcxCustomGrid;
  protected
    function GetControl: TcxControl; override;
  public
    constructor Create(AControl: TcxCustomGrid); virtual;
  end;

  TcxGridDragOpenInfoTab = class(TcxCustomGridDragOpenInfo)
  public
    Level: TcxGridLevel;
    constructor Create(ALevel: TcxGridLevel); virtual;
    function Equals(AInfo: TcxCustomGridDragOpenInfo): Boolean; override;
    procedure Run; override;
  end;

  TcxGridControllerClass = class of TcxGridController;

  TcxGridController = class(TcxCustomGridHandler)
  private
    FDesignController: TcxGridDesignController;
    FDragOpenInfo: TcxCustomGridDragOpenInfo;
    FDragOpenTimer: TcxTimer;
    function GetDesignController: TcxGridDesignController;
    procedure DragOpenTimerHandler(Sender: TObject);
  protected
    function GetDesignControllerClass: TcxGridDesignControllerClass; virtual;
  public
    destructor Destroy; override;

    procedure DoCancelMode; virtual;
    procedure FocusChanged; virtual;

    function GetCursor(X, Y: Integer): TCursor; virtual;
    procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); dynamic;
    procedure MouseMove(Shift: TShiftState; X, Y: Integer); dynamic;
    procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); dynamic;

    procedure DragOver(Source: TObject; X, Y: Integer; State: TDragState;
      var Accept: Boolean); virtual;
    procedure EndDrag(Target: TObject; X, Y: Integer); virtual;
    procedure StartDrag(var DragObject: TDragObject); virtual;

    function GetDragOpenInfo(AHitTest: TcxCustomGridHitTest): TcxCustomGridDragOpenInfo; virtual;
    function IsDragOpenHitTest(AHitTest: TcxCustomGridHitTest;
      out ADragOpenInfo: TcxCustomGridDragOpenInfo): Boolean;
    procedure StartDragOpen(ADragOpenInfo: TcxCustomGridDragOpenInfo);
    procedure StopDragOpen;
    property DragOpenInfo: TcxCustomGridDragOpenInfo read FDragOpenInfo;

    property DesignController: TcxGridDesignController read GetDesignController;
  end;

  TcxGridPainterClass = class of TcxGridPainter;

  TcxGridPainter = class(TcxCustomGridHandler)
  private
    function GetCanvas: TcxCanvas;
  protected
    procedure DrawDetailsSite; virtual;
    //procedure DrawEmptyArea; virtual;
  public
    procedure Invalidate(AInvalidateDetails: Boolean); overload; virtual;
    procedure Invalidate(const R: TRect); overload; virtual;
    procedure Paint; virtual;
    property Canvas: TcxCanvas read GetCanvas;
  end;

  TcxGridTopDetailsSiteViewInfoClass = class of TcxGridTopDetailsSiteViewInfo;

  TcxGridTopDetailsSiteViewInfo = class(TcxCustomGridDetailsSiteViewInfo)
  private
    function GetControl: TcxCustomGrid;
  protected
    function CalculateHeight: Integer; override;
    function CalculateWidth: Integer; override;
    function GetActiveGridView: TcxCustomGridView; override;
    function GetActiveLevel: TcxGridLevel; override;
    function GetCanvas: TcxCanvas; override;
    function GetContainer: TcxControl; override;
    function GetDesignController: TcxCustomGridDesignController; override;
    function GetMasterRecord: TObject; override;
    function GetMaxHeight: Integer; override;
    function GetMaxWidth: Integer; override;
    procedure InitTabHitTest(AHitTest: TcxGridDetailsSiteTabHitTest); override;
    property Control: TcxCustomGrid read GetControl;
  public
    procedure ChangeActiveTab(ALevel: TcxGridLevel; AFocusView: Boolean = False); override;
    function DetailHasData(ALevel: TcxGridLevel): Boolean; override;
    function SupportsTabAccelerators: Boolean; override;
    procedure VisibilityChanged(AVisible: Boolean); override;
  end;

  TcxGridViewInfoClass = class of TcxGridViewInfo;

  TcxGridViewInfo = class(TcxCustomGridHandler)
  private
    FDetailsSiteViewInfo: TcxGridTopDetailsSiteViewInfo;
    FDetailsSiteViewInfoCachedInfo: TcxCustomGridDetailsSiteViewInfoCachedInfo;
    function GetBounds: TRect;
    function GetClientBounds: TRect;
    function GetEmptyAreaColor: TColor;
  protected
    procedure CreateViewInfos; virtual;
    procedure DestroyViewInfos; virtual;
    function GetDetailsSiteViewInfoClass: TcxGridTopDetailsSiteViewInfoClass; virtual;
    procedure RecreateViewInfos;
  public
    constructor Create(AControl: TcxCustomGrid); override;
    destructor Destroy; override;
    procedure Calculate; virtual;
    function GetHitTest(X, Y: Integer): TcxCustomGridHitTest; virtual;
    property Bounds: TRect read GetBounds;
    property ClientBounds: TRect read GetClientBounds;
    property DetailsSiteViewInfo: TcxGridTopDetailsSiteViewInfo read FDetailsSiteViewInfo;
    property EmptyAreaColor: TColor read GetEmptyAreaColor;
  end;

  { controls }

  TcxGridLevelTabsClass = class of TcxGridLevelTabs;

  TcxGridLevelTabs = class(TPersistent)
  private
    FCaptionAlignment: TAlignment;
    FFreeNotificator: TcxFreeNotificator;
    FImageBorder: Integer;
    FImages: TCustomImageList;
    FImagesChangeLink: TChangeLink;
    FOwner: TcxCustomGrid;
    FSlants: TcxTabSlants;
    FStyle: TcxPCStyleID;
    procedure SetCaptionAlignment(Value: TAlignment);
    procedure SetImageBorder(Value: Integer);
    procedure SetImages(Value: TCustomImageList);
    procedure SetSlants(Value: TcxTabSlants);
    procedure SetStyle(Value: TcxPCStyleID);
    procedure FreeNotification(Sender: TComponent);
    procedure ImagesChanged(Sender: TObject);
    procedure SlantsChanged(Sender: TObject);
  protected
    procedure Changed;
  public
    constructor Create(AOwner: TcxCustomGrid); virtual;
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
    property Owner: TcxCustomGrid read FOwner;
  published
    property CaptionAlignment: TAlignment read FCaptionAlignment write SetCaptionAlignment default cxGridLevelTabsDefaultCaptionAlignment;
    property ImageBorder: Integer read FImageBorder write SetImageBorder default cxGridLevelTabsDefaultImageBorder;
    property Images: TCustomImageList read FImages write SetImages;
    property Slants: TcxTabSlants read FSlants write SetSlants;
    property Style: TcxPCStyleID read FStyle write SetStyle default cxPCDefaultStyle;
  end;

  TcxGridRootLevelOptions = class(TcxGridLevelOptions)
  public
    constructor Create(ALevel: TcxGridLevel); override;
  published
    property DetailFrameWidth default cxGridRootLevelDefaultDetailFrameWidth;
  end;

  TcxGridRootLevel = class(TcxGridLevel)
  protected
    function GetOptionsClass: TcxGridLevelOptionsClass; override;
  end;

  TcxGridActiveTabChangedEvent = procedure(Sender: TcxCustomGrid; ALevel: TcxGridLevel) of object;
  TcxGridFocusedViewChangedEvent = procedure(Sender: TcxCustomGrid;
    APrevFocusedView, AFocusedView: TcxCustomGridView) of object;
  TcxGridLayoutChangedEvent = procedure(Sender: TcxCustomGrid; AGridView: TcxCustomGridView) of object;

  TcxCustomGrid = class(TcxControl, IcxNavigator, IdxSkinSupport)
  private
    FActiveLevel: TcxGridLevel;
    FChanges: TList;
    FChangesStack: TList;
    FController: TcxGridController;
    FCreatingStructureNavigator: Boolean;
    FDragOpening: Boolean;
    FDragOpeningWaitTime: Integer;
    FFocusedView: TcxCustomGridView;
    FIsPopupControl: Boolean;
    FLastFocused: Boolean;
    FLevels: TcxGridLevel;
    FLevelTabs: TcxGridLevelTabs;
    FNavigatorNotifier: TcxNavigatorControlNotifier;
    FNotifications: TList;
    FPainter: TcxGridPainter;
    FProcessingChangesStack: Boolean;
    FStructureNavigator: TcxCustomGridStructureNavigator;
    FTabStop: Boolean;
    FTag: TObject;
    FUpdateLockCount: Integer;
    FViewInfo: TcxGridViewInfo;
    FViews: TList;
    FOnActiveTabChanged: TcxGridActiveTabChangedEvent;
    FOnFocusedViewChanged: TcxGridFocusedViewChangedEvent;
    FOnLayoutChanged: TcxGridLayoutChangedEvent;
    FSubClassEvents: TNotifyEvent;

    function GetActiveView: TcxCustomGridView;
    function GetFocusedViewNavigator: IcxNavigator;
    function GetView(Index: Integer): TcxCustomGridView;
    function GetViewCount: Integer;
    function GetRootLevelOptions: TcxGridLevelOptions;
    function GetRootLevelStyles: TcxGridLevelStyles;
    function GetStructureNavigator: TcxCustomGridStructureNavigator;
    function GetUpdateLocked: Boolean;
    procedure SetActiveLevel(Value: TcxGridLevel);
    procedure SetDragOpeningWaitTime(Value: Integer);
    procedure SetFocusedView(Value: TcxCustomGridView);
    procedure SetLevels(Value: TcxGridLevel);
    procedure SetLevelTabs(Value: TcxGridLevelTabs);
    procedure SetRootLevelOptions(Value: TcxGridLevelOptions);
    procedure SetRootLevelStyles(Value: TcxGridLevelStyles);
    procedure SetTabStop(Value: Boolean);

    procedure AddView(AView: TcxCustomGridView);
    procedure RemoveView(AView: TcxCustomGridView);
    procedure DestroyViews;

    procedure DestroyChanges(AChanges: TList);
    procedure DestroyViewChanges(AView: TcxCustomGridView);

    procedure CreateStructureNavigator;

    //procedure CMDeferUpdates(var Message: TMessage); message CM_DEFERUPDATES;
    procedure CMDialogChar(var Message: TCMDialogChar); message CM_DIALOGCHAR;
  protected
    // IcxNavigator
    function IcxNavigator.IsActive = NavigatorIsActive;
    function IcxNavigator.IsBof = NavigatorIsBof;
    function IcxNavigator.IsEof = NavigatorIsEof;
    function IcxNavigator.CanAppend = NavigatorCanAppend;
    function IcxNavigator.CanEdit = NavigatorCanEdit;
    function IcxNavigator.CanDelete = NavigatorCanDelete;
    function IcxNavigator.CanInsert = NavigatorCanInsert;
    procedure IcxNavigator.ClearBookmark = NavigatorClearBookmark;
    function IcxNavigator.IsEditing = NavigatorIsEditing;
    function IcxNavigator.IsBookmarkAvailable = NavigatorIsBookmarkAvailable;
    procedure IcxNavigator.DoAction = NavigatorDoAction;
    function IcxNavigator.GetNotifier = NavigatorGetNotifier;
    function IcxNavigator.IsActionSupported = NavigatorIsActionSupported;
    function NavigatorIsActive: Boolean;
    function NavigatorIsBof: Boolean;
    function NavigatorIsEof: Boolean;
    function NavigatorCanAppend: Boolean;
    function NavigatorCanEdit: Boolean;
    function NavigatorCanDelete: Boolean;
    function NavigatorCanInsert: Boolean;
    function NavigatorIsEditing: Boolean;
    procedure NavigatorClearBookmark;
    function NavigatorIsBookmarkAvailable: Boolean;
    procedure NavigatorDoAction(AButtonIndex: Integer);
    function NavigatorGetNotifier: TcxNavigatorControlNotifier;
    function NavigatorIsActionSupported(AButtonIndex: Integer): Boolean;

    procedure AddChildComponent(AComponent: TcxControlChildComponent); override;
    procedure RemoveChildComponent(AComponent: TcxControlChildComponent); override;

    procedure BoundsChanged; override;
    procedure DoCancelMode; override;
    procedure DoContextPopup(MousePos: TPoint; var Handled: Boolean); override;
    procedure FocusChanged; override;
    procedure GetChildren(Proc: TGetChildProc; Root: TComponent); override;
    function GetCursor(X, Y: Integer): TCursor; override;
    function GetDesignHitTest(X, Y: Integer; Shift: TShiftState): Boolean; override;
    function GetIsFocused: Boolean; override;
    procedure Loaded; override;
    function MayFocus: Boolean; override;
    procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
    procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;