cxvieweditor.pas

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

{********************************************************************}
{                                                                    }
{       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 cxViewEditor;

{$I cxVer.inc}

interface

uses
{$IFDEF DELPHI6}
    DesignIntf, DesignMenus,
{$ELSE}
  DsgnIntf,
{$ENDIF}
{$IFDEF DELPHI6}
  Variants,
{$ENDIF}
{$IFNDEF NONDB}
  DB,
{$ENDIF}
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Menus,
  Dialogs, ExtCtrls, cxLibraryReg,
  cxClasses, cxStorage, cxDesignWindows, cxCustomData, cxGridCommon, cxGridCustomView;

const
  cxGridViewMenuSeparatorCaption = '-';

type
  { TcxViewEditor }

  TcxViewEditor = class(TForm)
    PViewEditor: TPanel;
    procedure FormKeyPress(Sender: TObject; var Key: Char);
  private
    FView: TcxCustomGridView;
    function GetDataController: TcxCustomDataController;
    function GetOwnerForm: TComponent;
  protected
    procedure BeginUpdate;
    function CanAddComponent: Boolean;
    function CanDeleteComponent(AComponent: TComponent): Boolean;
    procedure EndUpdate;
    procedure GetSelectionList(AList: TList);
    procedure SelectComponent(AComponent: TPersistent);
    function UniqueName(AComponent: TComponent;
      const ATruncateClassName: string = ScxGridPrefixName): string; virtual;
    procedure UpdateDesigner; virtual;
    procedure UpdateEditor; virtual;
    procedure UpdateSelection; virtual;
    property DataController: TcxCustomDataController read GetDataController;
  public
    FormEditor: TcxDesignFormEditor;
    class function GetViewByObject(APersistent: TPersistent): TcxCustomGridView; virtual;
    procedure SetView(Value: TcxCustomGridView; ARefreshNeeded: Boolean);
    property OwnerForm: TComponent read GetOwnerForm;
    property View: TcxCustomGridView read FView;
  end;

  TcxViewEditorClass = class of TcxViewEditor;

  { TcxCustomGridViewStorage }

  TcxCustomGridViewStorage = class(TcxInterfacedPersistent, IcxStoredObject)
  private
    FView: TcxCustomGridView;
  protected
    // IcxStoredObject
    function GetObjectName: string;
    function GetProperties(AProperties: TStrings): Boolean;
    procedure GetPropertyValue(const AName: string; var AValue: Variant);
    procedure SetPropertyValue(const AName: string; const AValue: Variant);
    property View: TcxCustomGridView read FView;
  public
    constructor Create(AView: TcxCustomGridView); reintroduce; virtual;
    class function GetViewClass: TcxCustomGridViewClass; virtual;
  end;

  TcxCustomGridViewStorageClass = class of TcxCustomGridViewStorage;

  { View Menu Provider }

  TcxGridViewMenuItem = class;

  TcxGridViewMenuItemActionEvent = procedure(Sender: TcxGridViewMenuItem) of object;

  TcxGridViewMenuItems = class
  private
    FItems: TList;
    function GetCount: Integer;
    function GetItem(Index: Integer): TcxGridViewMenuItem;
  protected
    procedure ClearItems;
  public
    constructor Create;
    destructor Destroy; override;
    function AddItem(const ACaption: string; AOnClick: TcxGridViewMenuItemActionEvent = nil;
      AEnabled: Boolean = True; AChecked: Boolean = False; AData: TObject = nil): TcxGridViewMenuItem;
    function AddSeparator: TcxGridViewMenuItem;
    procedure Delete(AIndex: Integer);
    procedure Prepare(AMenuItem: TMenuItem); overload; virtual;
  {$IFDEF DELPHI6}
    procedure Prepare(const AMenuItem: TDesignMenuItem); overload; virtual;
  {$ENDIF}
    procedure RemoveExcessSeparators;
    property Count: Integer read GetCount;
    property Items[Index: Integer]: TcxGridViewMenuItem read GetItem; default;
  end;

  TcxGridViewMenuItem = class(TcxGridViewMenuItems)
  private
    procedure MenuItemClick(Sender: TObject);
  protected
    OnAction: TcxGridViewMenuItemActionEvent;
  public
    Caption: string;
    Checked: Boolean;
    Data: TObject;
    Enabled: Boolean;
    constructor Create(const ACaption: string; AEnabled: Boolean;
      AChecked: Boolean; AData: TObject; AOnAction: TcxGridViewMenuItemActionEvent);
    procedure DoAction;
    function IsSeparator: Boolean;
    procedure Prepare(AMenuItem: TMenuItem); overload; override;
  {$IFDEF DELPHI6}
    procedure Prepare(const AMenuItem: TDesignMenuItem); overload; override;
  {$ENDIF}
  end;

  TcxCustomGridViewMenuProviderClass = class of TcxCustomGridViewMenuProvider;

  TcxCustomGridViewMenuProvider = class
  private
    FDesigner: IDesigner;
    FDesignHelper: TcxDesignHelper;
    FGridView: TcxCustomGridView;
    FItems: TcxGridViewMenuItems;
  {$IFNDEF NONDB}
    FDataSourceNames: TStringList;
    procedure GetDataSourceName(const S: string);
    function GetDBGridView: TcxCustomGridView;
    function GetViewDataSource: TDataSource;
    procedure SetViewDataSource(Value: TDataSource);
  {$ENDIF}
  protected
    procedure DesignerModified;
    procedure ObjectCreated(AObject: TPersistent);
    procedure SelectObject(AObject: TPersistent);

    procedure InitAdditionalItems; virtual;
    procedure InitCopySettingsFromViewItem; virtual;
  {$IFNDEF NONDB}
    procedure InitDataBindingItems; virtual;
  {$ENDIF}
    procedure InitItems; virtual;
    procedure InitLayoutItems; virtual;
    procedure InitStructureItems; virtual;

    procedure CopySettings(Sender: TcxGridViewMenuItem);
    procedure DeleteView(Sender: TcxGridViewMenuItem);
    procedure EditLayoutAndData(Sender: TcxGridViewMenuItem);
    procedure SetAsDefault(Sender: TcxGridViewMenuItem);
  {$IFNDEF NONDB}
    function GetDataSourceNames: TStringList;
    procedure LinkToDataSource(Sender: TcxGridViewMenuItem);
  {$ENDIF}

  {$IFNDEF NONDB}
    property ViewDataSource: TDataSource read GetViewDataSource write SetViewDataSource;
    property DBGridView: TcxCustomGridView read GetDBGridView;
  {$ENDIF}
    property Designer: IDesigner read FDesigner;
    property DesignHelper: TcxDesignHelper read FDesignHelper;
  public
    constructor Create(AGridView: TcxCustomGridView); virtual;
    destructor Destroy; override;
    property GridView: TcxCustomGridView read FGridView;
    property Items: TcxGridViewMenuItems read FItems;
  end;

  { TcxGridViewList }

  TcxGridViewList = class
  private
    FDesigner: IDesigner;
    FViewNames: TStringList;
    function GetView(Index: Integer): TcxCustomGridView;
    procedure AddViewName(const S: string);
  protected
    procedure GetViewNames; virtual;
  public
    constructor Create(ADesigner: IDesigner);
    destructor Destroy; override;
    function GetViewIndex(AView: TcxCustomGridView): Integer;
    property Designer: IDesigner read FDesigner;
    property ViewNames: TStringList read FViewNames;
    property Views[Index: Integer]: TcxCustomGridView read GetView;
  end;

function GetViewEditorClass(AViewClass: TcxCustomGridViewClass): TcxViewEditorClass;
procedure RegisterViewEditorClass(AViewClass: TcxCustomGridViewClass; AViewEditorClass: TcxViewEditorClass);
procedure UnregisterViewEditorClass(AViewClass: TcxCustomGridViewClass; AViewEditorClass: TcxViewEditorClass);
function GetLinkedView(APersistent: TPersistent): TcxCustomGridView;
function IsViewLinkedToComponent(AView: TcxCustomGridView; AComponent: TComponent): Boolean;

function GetViewTemplateRegKey: string;
procedure RegisterDefaultViewStorage(AStorageClass: TcxCustomGridViewStorageClass);
procedure UnregisterDefaultViewStorage(AStorageClass: TcxCustomGridViewStorageClass);
function GetDefaultViewStorageByViewClass(AGridView: TcxCustomGridView): TcxCustomGridViewStorage;

procedure RestoreViewFromTemplate(const ARegPath: string; AView: TcxCustomGridView);
procedure SaveViewToTemplate(const ARegPath: string; AView: TcxCustomGridView);

function CreateViewMenuProvider(AView: TcxCustomGridView): TcxCustomGridViewMenuProvider;
function GetViewMenuProviderClass(AView: TcxCustomGridView): TcxCustomGridViewMenuProviderClass;
procedure RegisterViewMenuProviderClass(AViewClass: TcxCustomGridViewClass;
  AViewMenuProviderClass: TcxCustomGridViewMenuProviderClass);
procedure UnregisterViewMenuProviderClass(AViewClass: TcxCustomGridViewClass;
  AViewMenuProviderClass: TcxCustomGridViewMenuProviderClass);

function GetViewItemUniqueName(AView: TcxCustomGridView; AItem: TComponent;
  const AItemName: string): string;

implementation

{$R *.dfm}

uses
{$IFNDEF NONDB}
  TypInfo, cxDBData,
{$ENDIF}
  cxGrid, cxGridLevel, cxGridViewLayoutEditor;

type
  TcxDesignWindowAccess = class(TcxDesignWindow);

var
  ViewEditorClassList: TcxRegisteredClassList;
  DefaultViewStorages: TList;
  ViewMenuProviderClassList: TcxRegisteredClassList;

function GetViewEditorClass(AViewClass: TcxCustomGridViewClass): TcxViewEditorClass;
begin
  Result := TcxViewEditorClass(ViewEditorClassList.FindClass(AViewClass));
end;

procedure RegisterViewEditorClass(AViewClass: TcxCustomGridViewClass; AViewEditorClass: TcxViewEditorClass);
begin
  ViewEditorClassList.Register(AViewClass, AViewEditorClass);
end;

procedure UnregisterViewEditorClass(AViewClass: TcxCustomGridViewClass; AViewEditorClass: TcxViewEditorClass);
begin
  ViewEditorClassList.Unregister(AViewClass, AViewEditorClass);
end;

function GetLinkedView(APersistent: TPersistent): TcxCustomGridView;
var
  I: Integer;
  AViewEditorClass: TcxViewEditorClass;
begin
  Result := nil;
  for I := 0 to ViewEditorClassList.Count - 1 do
  begin
    AViewEditorClass := TcxViewEditorClass(ViewEditorClassList[I].RegisteredClass);
    Result := AViewEditorClass.GetViewByObject(APersistent);
    if Result <> nil then
      Break;
  end;
end;

function IsViewLinkedToComponent(AView: TcxCustomGridView; AComponent: TComponent): Boolean;

  function CheckLevels(ALevel: TcxGridLevel): Boolean;
  var
    I: Integer;
  begin
    Result := False;
    for I := 0 to ALevel.Count - 1 do
      if (ALevel[I].GridView = AView) or CheckLevels(ALevel[I]) then
      begin
        Result := True;
        Break;
      end; 
  end;

begin
  Result := AView.GetParentComponent = AComponent;
  if not Result and (AComponent is TcxCustomGrid) then // check Levels (from Repository)
    Result := CheckLevels(TcxCustomGrid(AComponent).Levels);
end;

function GetViewTemplateRegKey: string;
begin
  Result := TcxDesignWindow.GetBaseRegKey + '\TcxGridViewTemplate';
end;

procedure RegisterDefaultViewStorage(AStorageClass: TcxCustomGridViewStorageClass);
begin
  if DefaultViewStorages = nil then
    DefaultViewStorages := TList.Create;
  if DefaultViewStorages.IndexOf((AStorageClass)) < 0 then
    DefaultViewStorages.Add((AStorageClass));
end;

procedure UnregisterDefaultViewStorage(AStorageClass: TcxCustomGridViewStorageClass);
begin
  if DefaultViewStorages <> nil then
    DefaultViewStorages.Remove((AStorageClass));
end;

function GetDefaultViewStorageByViewClass(AGridView: TcxCustomGridView): TcxCustomGridViewStorage;
var
  I: Integer;
  ACurrent, AStorageClass: TcxCustomGridViewStorageClass;
begin
  Result := nil;
  AStorageClass := nil;
  if (DefaultViewStorages <> nil) and (AGridView <> nil) then
  begin
    for I := 0 to DefaultViewStorages.Count - 1 do
    begin
      ACurrent := TcxCustomGridViewStorageClass(DefaultViewStorages[I]);

      if AGridView.InheritsFrom(ACurrent.GetViewClass) then
        if (AStorageClass = nil) or
          not AStorageClass.GetViewClass.InheritsFrom(ACurrent.GetViewClass) then
          AStorageClass := ACurrent;

      if (AStorageClass <> nil) and
        (AStorageClass.GetViewClass = AGridView.ClassType) then
        Break;
    end;
  end;
  if AStorageClass <> nil then
    Result := AStorageClass.Create(AGridView);
end;

procedure RestoreViewFromTemplate(const ARegPath: string; AView: TcxCustomGridView);
var
  AStorage: TcxStorage;
  AViewStorage: TcxCustomGridViewStorage;
begin
  AViewStorage := GetDefaultViewStorageByViewClass(AView);
  if AViewStorage = nil then Exit;
  try
    AStorage := TcxStorage.Create(ARegPath{ + '\' + AViewStorage.GetObjectName});
    try
      AStorage.Modes := AStorage.Modes + [smSavePublishedClassProperties];
      AStorage.RestoreFromRegistry(AViewStorage);
    finally
      AStorage.Free;
    end;
  finally
    AViewStorage.Free;
  end;
end;

procedure SaveViewToTemplate(const ARegPath: string; AView: TcxCustomGridView);
var
  AStorage: TcxStorage;
  AViewStorage: TcxCustomGridViewStorage;
begin
  AViewStorage := GetDefaultViewStorageByViewClass(AView);
  if AViewStorage = nil then Exit;
  try
    AStorage := TcxStorage.Create(ARegPath{ + '\' + AViewStorage.GetObjectName});
    try
      AStorage.Modes := AStorage.Modes + [smSavePublishedClassProperties];
      AStorage.Recreate := False;
      AStorage.StoreToRegistry(AViewStorage);
    finally
      AStorage.Free;
    end;
  finally
    AViewStorage.Free;
  end;
end;

function CreateViewMenuProvider(AView: TcxCustomGridView): TcxCustomGridViewMenuProvider;
var
  AClass: TcxCustomGridViewMenuProviderClass;
begin
  AClass := GetViewMenuProviderClass(AView);
  if AClass = nil then
    Result := nil
  else
    Result := AClass.Create(AView);
end;

function GetViewMenuProviderClass(AView: TcxCustomGridView): TcxCustomGridViewMenuProviderClass;
begin
  Result := TcxCustomGridViewMenuProviderClass(ViewMenuProviderClassList.FindClass(AView.ClassType));
end;

procedure RegisterViewMenuProviderClass(AViewClass: TcxCustomGridViewClass;
  AViewMenuProviderClass: TcxCustomGridViewMenuProviderClass);
begin
  ViewMenuProviderClassList.Register(AViewClass, AViewMenuProviderClass);
end;

procedure UnregisterViewMenuProviderClass(AViewClass: TcxCustomGridViewClass;
  AViewMenuProviderClass: TcxCustomGridViewMenuProviderClass);
begin
  ViewMenuProviderClassList.Unregister(AViewClass, AViewMenuProviderClass);
end;

function GetViewItemUniqueName(AView: TcxCustomGridView; AItem: TComponent;
  const AItemName: string): string;
begin
  Result := CreateUniqueName(AView.Owner{!!!}, AView, AItem,
    Copy(AItem.ClassName, 1, Pos(AItemName, AItem.ClassName) - 1), '');
end;

{ TcxCustomGridViewStorage }

constructor TcxCustomGridViewStorage.Create(AView: TcxCustomGridView);
begin
  inherited Create(AView);
  FView := AView;
end;

class function TcxCustomGridViewStorage.GetViewClass: TcxCustomGridViewClass;
begin
  Result := nil;
end;

function TcxCustomGridViewStorage.GetObjectName: string;
begin
  Result := GetViewClass.ClassName;
end;

function TcxCustomGridViewStorage.GetProperties(AProperties: TStrings): Boolean;
begin
  Result := False;
end;

procedure TcxCustomGridViewStorage.GetPropertyValue(const AName: string; var AValue: Variant);
begin
end;

procedure TcxCustomGridViewStorage.SetPropertyValue(const AName: string; const AValue: Variant);
begin
end;

{ TcxViewEditor }

class function TcxViewEditor.GetViewByObject(APersistent: TPersistent): TcxCustomGridView;
begin
  Result := nil;
end;