rmd_reportexplorer.pas

这是一个功能强大

{*****************************************}
{                                         }
{   Report Machine v2.0 - Data storage    }
{            Report Explorer              }
{                                         }
{*****************************************}

unit RMD_ReportExplorer;

interface

{$I RM.INC}

uses
  Windows, Classes, SysUtils, Forms, Controls, Graphics, Menus, Dialogs, ComCtrls,
  DB, RM_Class
{$IFDEF COMPILER6_UP}, Variants{$ENDIF};

const
  rmitAllFolders = 0;
  rmitReport = 1;
  rmitFolder = 255;
  rmitRecycleBin = -2;

type
  TRMRenameFolderEvent = procedure(Sender: TObject; aFolderId: Integer; const aNewName: string) of object;
  TRMReportExplorer = class;

  { TRMFolderFieldNames }
  TRMFolderFieldNames = class(TPersistent)
  private
    FName: string;
    FFolderId: string;
    FParentId: string;
  public
    constructor Create;
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
  published
    property FolderId: string read FFolderId write FFolderId;
    property Name: string read FName write FName;
    property ParentId: string read FParentId write FParentId;
  end;

  { TRMItemFieldNames }
  TRMItemFieldNames = class(TPersistent)
  private
    FDeleted: string;
    FFolderId: string;
    FItemId: string;
    FModified: string;
    FName: string;
    FSize: string;
    FTemplate: string;
    FItemType: string;
  public
    constructor Create;
    destructor Destroy; override;
    procedure Assign(Source: TPersistent); override;
  published
    property Deleted: string read FDeleted write FDeleted;
    property FolderId: string read FFolderId write FFolderId;
    property ItemId: string read FItemId write FItemId;
    property Modified: string read FModified write FModified;
    property Name: string read FName write FName;
    property Size: string read FSize write FSize;
    property Template: string read FTemplate write FTemplate;
    property ItemType: string read FItemType write FItemType;
  end;

  { TRMFolderInfo }
  TRMFolderInfo = class
  private
    FName: string;
    FFolderId: Integer;
    FParentId: Integer;
  public
    property Name: string read FName write FName;
    property FolderId: Integer read FFolderId write FFolderId;
    property ParentId: Integer read FParentId write FParentId;
  end;

  { TRMItemInfo }
  TRMItemInfo = class
  private
    FDeleted: TDateTime;
    FFolderId: Integer;
    FItemId: Integer;
    FModified: TDateTime;
    FName: string;
    FSize: Integer;
    FItemType: Integer;
  public
    property Deleted: TDateTime read FDeleted write FDeleted;
    property FolderId: Integer read FFolderId write FFolderId;
    property ItemId: Integer read FItemId write FItemId;
    property Modified: TDateTime read FModified write FModified;
    property Name: string read FName write FName;
    property Size: Integer read FSize write FSize;
    property ItemType: Integer read FItemType write FItemType;
  end;

  PRMListItemData = ^TRMListItemData;
  TRMListItemData = packed record
    ItemId: Integer;
    ItemType: Smallint;
  end;

  { TRMItemListView }
  TRMItemListView = class(TListView)
  private
    FAllFolders: Boolean;
    FFolderId: Integer;
    FOnDoubleClick: TNotifyEvent;
    FOnFolderChange: TNotifyEvent;
    FOnRenameFolder: TRMRenameFolderEvent;
    FOnSelectionChange: TNotifyEvent;
    FReportExplorer: TRMReportExplorer;
    FSelectionCount: Integer;
    FSelectionSize: Integer;
    FSortMode: Integer;

    procedure DoOnFolderChange;
    procedure DoOnRenameFolder(aFolderId: Integer; const aNewName: string);
    procedure DoOnSelectionChange;
    function GetItemId: Integer;
    function GetItemName: string;
    function GetItemType: Integer;
    procedure GetItemsForFolder;
    procedure GetSelectedItems(aList: TStrings);
    procedure SetFolderId(aFolderId: Integer);
    procedure SetItemName(aName: string);
    procedure SetReportExplorer(aExplorer: TRMReportExplorer);
    procedure SetSortMode(aSortMode: Integer);
    procedure SetSortModeDescription;

    procedure ChangeEvent(Sender: TObject; Item: TListItem; Change: TItemChange);
    procedure CompareEvent(Sender: TObject; Item1, Item2: TListItem; Data: Integer; var Compare: Integer);
    procedure ColumnClickEvent(Sender: TObject; Column: TListColumn);
    procedure DblClickEvent(Sender: TObject);
    procedure DragDropEvent(Sender, Source: TObject; X, Y: Integer);
    procedure DragOverEvent(Sender, Source: TObject; X, Y: Integer; State: TDragState; var Accept: Boolean);
    procedure EditedEvent(Sender: TObject; Item: TListItem; var S: string);
    procedure EditingEvent(Sender: TObject; Item: TListItem; var AllowEdit: Boolean);
  protected
    procedure SetParent(aParent: TWinControl); override;
  public
    constructor Create(aOwner: TComponent); override;
    destructor Destroy; override;
    procedure DeleteSelection;
    procedure EmptyRecycleBin;
    procedure MoveSelectionToFolder(aFolderId: Integer);
    procedure RenameItem;
    procedure ClearData;

    property AllFolders: Boolean read FAllFolders;
    property FolderId: Integer read FFolderId write SetFolderId;
    property ItemName: string read GetItemName write SetItemName;
    property ItemId: Integer read GetItemId;
    property ItemType: Integer read GetItemType;
    property ReportExplorer: TRMReportExplorer read FReportExplorer write SetReportExplorer;
    property SelectionCount: Integer read FSelectionCount;
    property SelectionSize: Integer read FSelectionSize;
    property SortMode: Integer read FSortMode write SetSortMode;

    property OnDoubleClick: TNotifyEvent read FOnDoubleClick write FOnDoubleClick;
    property OnFolderChange: TNotifyEvent read FOnFolderChange write FOnFolderChange;
    property OnRenameFolder: TRMRenameFolderEvent read FOnRenameFolder write FOnRenameFolder;
    property OnSelectionChange: TNotifyEvent read FOnSelectionChange write FOnSelectionChange;
  end;

  { TRMReportItem }
  TRMReportItem = class(TCollectionItem)
  private
    FReport: TRMReport;
  protected
  public
    constructor Create(Collection: TCollection); override;
    procedure Assign(Source: TPersistent); override;
  published
    property Report: TRMReport read FReport write FReport;
  end;

  TRMReportItemClass = class of TRMReportItem;

  { TRMReportItems }
  TRMReportItems = class(TCollection)
  private
    FReportExplorer: TRMReportExplorer;
    function GetItem(Index: Integer): TRMReportItem;
    procedure SetItem(Index: Integer; Value: TRMReportItem);
  protected
    function GetOwner: TPersistent; override;
  public
    constructor Create(aReportExplorer: TRMReportExplorer; aReportItemClass: TRMReportItemClass);
    function Add: TRMReportItem;
    property Items[Index: Integer]: TRMReportItem read GetItem write SetItem; default;
  end;

  { TRMReportExplorer }
  TRMReportExplorer = class(TComponent)
  private
    FForm: TForm;
    FCurrentFolderId: Integer;
    FCurrentItemName: string;
    FCurrentItemType: Integer;
    FRecyclingItems: Boolean;
    FYesToAll: Boolean;
    FFolderFieldNames: TRMFolderFieldNames;
    FFolderDataSet: TDataSet;
    FItemFieldNames: TRMItemFieldNames;
    FItemDataSet: TDataSet;
    FRootKey: string;
    FInsertRecordFlag: Boolean;
    FRefreshFlag: Boolean;
    FReports: TRMReportItems;
    FCurrentReport: TRMReport;

    procedure SetReports(Value: TRMReportItems);
    procedure SetFolderFieldNames(aFolderFieldNames: TRMFolderFieldNames);
    procedure SetItemFieldNames(aItemFieldNames: TRMItemFieldNames);
    procedure DeleteItemsInFolder(aFolderId: Integer);
    function LocateItemRecord(const aId: Integer): Boolean;
    function IsReport(const aId: Integer): Boolean;
    function MoveFolderToFolder(aFolderId, aNewParentId: Integer): Boolean;
    function MoveItemToFolder(aItemId, aNewFolderId: Integer): Boolean;
    function GetNewReportName(aFolderId: Integer): string;
    function ValidFolderName(aParentId: Integer; aFolderName: string): Boolean;
    function GetCurrentReportIndex(aReportType: Byte): Integer;

    procedure OnSaveReportEvent(Report: TRMReport; var ReportName: string; SaveAs: Boolean; var Saved: Boolean);
  protected
  public
    constructor Create(aOwner: TComponent); override;
    destructor Destroy; override;
    procedure Notification(aComponent: TComponent; Operation: TOperation); override;
    procedure Execute;
    procedure New(aFolderId: Integer);
    procedure Open(const aItemId, aFolderId, aItemType: Integer; aReportName: string);
    procedure Print(const aItemId, aFolderId, aItemType: Integer; const aReportName: string);
    procedure PrintPreview(const aItemId, aFolderId, aItemType: Integer; const aReportName: string);

    function GetParentId(aFolderId: Integer): Integer;
    procedure GetFolders(aList: TStrings);
    procedure GetItems(aFolderId: Integer; aList: TStrings);
    function GetNewFolderName(aParentId: Integer): string;
    function ChangeFolder(aItemId, aNewFolderId: Integer): Boolean;
    function ChangeParentFolder(aFolderId, aNewParentId: Integer): Boolean;
    procedure AddFolder(aParentId: Integer; aFolderName: string; var aFolderId: Integer);
    procedure RenameFolder(aFolderId: Integer; const aNewName: string);
    procedure Rename(aItemId: Integer; aNewName: string);
    procedure Delete(aItemId: Integer);
    function DeleteFolder(aFolderId: Integer): Boolean;
    procedure GetChildFolders(aFolderId: Integer; aList: TStrings);
    function GetFolderName(aFolderId: Integer): string;

    property CurrentItemName: string read FCurrentItemName write FCurrentItemName;
    property CurrentFolderId: Integer read FCurrentFolderId write FCurrentFolderId;
  published
    property FolderFieldNames: TRMFolderFieldNames read FFolderFieldNames write SetFolderFieldNames;
    property FolderDataSet: TDataSet read FFolderDataSet write FFolderDataSet;
    property ItemFieldNames: TRMItemFieldNames read FItemFieldNames write SetItemFieldNames;
    property ItemDataSet: TDataSet read FItemDataSet write FItemDataSet;
    property RootKey: string read FRootKey write FRootKey;
    property Reports: TRMReportItems read FReports write SetReports;
  end;

implementation

uses
  RM_Designer, RMD_ExpFrm, RM_Utils, RM_Const, RMD_DlgSelectReportType;

function RMGetTypeDesc(aItemType: Integer): string;
begin
  case aItemType of
    rmitReport: Result := RMLoadStr(rmRes + 3157); //'Report';
    rmitFolder: Result := RMLoadStr(rmRes + 3158); //'Folder';
  end;
end;

{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
{TRMFolderFieldNames}

constructor TRMFolderFieldNames.Create;
begin
  inherited Create;
  FFolderId := 'FolderId';
  FName := 'Name';
  FParentId := 'ParentId';
end;

destructor TRMFolderFieldNames.Destroy;
begin
  inherited Destroy;
end;

procedure TRMFolderFieldNames.Assign(Source: TPersistent);
var
  lSource: TRMFolderFieldNames;
begin
  if not (Source is TRMFolderFieldNames) then
    Exit;
  lSource := TRMFolderFieldNames(Source);
  FFolderId := lSource.FolderId;
  FName := lSource.Name;
  FParentId := lSource.ParentId;
end;

{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
{TRMItemFieldNames}

constructor TRMItemFieldNames.Create;
begin
  inherited Create;
  FDeleted := 'Deleted';
  FFolderId := 'FolderId';
  FItemId := 'ItemId';
  FItemType := 'ItemType';
  FModified := 'Modified';
  FName := 'Name';
  FSize := 'Size';
  FTemplate := 'Template';
end;

destructor TRMItemFieldNames.Destroy;
begin
  inherited Destroy;
end;

procedure TRMItemFieldNames.Assign(Source: TPersistent);
var
  lSource: TRMItemFieldNames;
begin
  if not (Source is TRMItemFieldNames) then
    Exit;
  lSource := TRMItemFieldNames(Source);
  FDeleted := lSource.Deleted;
  FFolderId := lSource.FolderId;
  FItemId := lSource.ItemId;
  FItemType := lSource.ItemType;
  FModified := lSource.Modified;
  FName := lSource.Name;
  FSize := lSource.Size;
  FTemplate := lSource.Template;
end;

{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
{TRMItemListView}

constructor TRMItemListView.Create(aOwner: TComponent);
begin
  inherited Create(aOwner);

  FAllFolders := False;
  FFolderId := 0;
//  FItemTypeFilter := rmitAllFolders;
  FOnDoubleClick := nil;
  FOnFolderChange := nil;
  FOnRenameFolder := nil;
  FOnSelectionChange := nil;
  FReportExplorer := nil;
  FSelectionCount := 0;
  FSelectionSize := 0;
  FSortMode := 1;

  OnChange := ChangeEvent;
  OnColumnClick := ColumnClickEvent;
  OnCompare := CompareEvent;
  OnDblClick := DblClickEvent;
  OnDragDrop := DragDropEvent;
  OnDragOver := DragOverEvent;
  OnEdited := EditedEvent;
  OnEditing := EditingEvent;

  DragCursor := crDefault;
  DragMode := dmAutomatic;
  SortType := stText;
end;

destructor TRMItemListView.Destroy;
begin
  ClearData;
  inherited Destroy;
end;

procedure TRMItemListView.ClearData;
var
  i: Integer;
begin
  for i := 0 to Items.Count - 1 do
  begin
    if Items[i].Data <> nil then
    begin
      Dispose(Items[i].Data);
      Items[i].Data := nil;
    end;
  end;
  Items.Clear;
end;