rm_cmpreg.pas

进销存·完整的·有数据库的·非常完整·只得参考

unit RM_CmpReg;

interface

{$I RM.inc}

uses
  SysUtils, Windows, Messages, Classes, Graphics, Forms, RM_Class;

type
 { TRMAddInObjectInfo }
  TRMAddInObjectInfo = class
  private
    FClassRef: TRMClass;
    FEditorFormClass: TFormClass;
    FButtonBmpRes: string;
    FButtonHint: string;
    FIsControl: Boolean;
  public
    constructor Create(AClassRef: TClass; AEditorFormClass: TFormClass;
      const AButtonBmpRes: string; const AButtonHint: string; AIsControl: Boolean);
    property ClassRef: TRMClass read FClassRef write FClassRef;
    property EditorFormClass: TFormClass read FEditorFormClass write FEditorFormClass;
    property ButtonBmpRes: string read FButtonBmpRes write FButtonBmpRes;
    property ButtonHint: string read FButtonHint write FButtonHint;
    property IsControl: Boolean read FIsControl write FIsControl;
  end;

  { TRMExportFilterInfo }
  TRMExportFilterInfo = class
  private
    FFilter: TRMExportFilter;
    FFilterDesc: string;
    FFilterExt: string;
  public
    constructor Create(AClassRef: TRMExportFilter; const AFilterDesc: string; const AFilterExt: string);
    property Filter: TRMExportFilter read FFilter write FFilter;
    property FilterDesc: string read FFilterDesc write FFilterDesc;
    property FilterExt: string read FFilterExt write FFilterExt;
  end;

  { TRMToolsInfo }
  TRMToolsInfo = class
  private
    FCaption: string;
    FButtonBmpRes: string;
    FOnClick: TNotifyEvent;
  public
    constructor Create(const ACaption: string; const AButtonBmpRes: string; AOnClick: TNotifyEvent);
    property Caption: string read FCaption write FCaption;
    property ButtonBmpRes: string read FButtonBmpRes write FButtonBmpRes;
    property OnClick: TNotifyEvent read FOnClick write FOnClick;
  end;

procedure RMRegisterObjectByRes(ClassRef: TClass; const ButtonBmpRes: string;
  const ButtonHint: string; EditorFormClass: TFormClass);
procedure RMRegisterControl(ClassRef: TClass; const ButtonBmpRes, ButtonHint: string);
procedure RMRegisterExportFilter(Filter: TRMExportFilter; const FilterDesc, FilterExt: string);
procedure RMUnRegisterExportFilter(Filter: TRMExportFilter);
procedure RMRegisterTool(const MenuCaption: string; const ButtonBmpRes: string; OnClick: TNotifyEvent);
procedure RMUnRegisterTool(const MenuCaption: string);
procedure RMRegisterFunctionLibrary(ClassRef: TClass);
procedure RMUnRegisterFunctionLibrary(ClassRef: TClass);

function RMAddIns(index: Integer): TRMAddInObjectInfo;
function RMAddInsCount: Integer;
function RMFilters(index: Integer): TRMExportFilterInfo;
function RMFiltersCount: Integer;
function RMTools(index: Integer): TRMToolsInfo;
function RMToolsCount: Integer;
function RMAddInFunctions(Index: Integer): TRMFunctionLibrary;
function RMAddInFunctionCount: Integer;

implementation

uses RM_Const;

var
  FRMAddInObjectList: TStringList;
  FRMExportFilterList: TStringList;
  FRMToolsList: TStringList;
  FRMFunctionList: TList;

function RMAddInObjectList: TStringList;
begin
  if FRMAddInObjectList = nil then
    FRMAddInObjectList := TStringList.Create;
  Result := FRMAddInObjectList;
end;

function RMExportFilterList: TStringList;
begin
  if FRMExportFilterList = nil then
    FRMExportFilterList := TStringList.Create;
  Result := FRMExportFilterList;
end;

function RMToolsList: TStringList;
begin
  if FRMToolsList = nil then
    FRMToolsList := TStringList.Create;
  Result := FRMToolsList;
end;

function RMAddIns(index: Integer): TRMAddInObjectInfo;
begin
  Result := TRMAddInObjectInfo(FRMAddInObjectList.Objects[index]);
end;

function RMAddInsCount: Integer;
begin
  if FRMAddInObjectList = nil then
    Result := -1
  else
    Result := FRMAddinObjectList.Count;
end;

function RMFilters(index: Integer): TRMExportFilterInfo;
begin
  Result := TRMExportFilterInfo(FRMExportFilterList.Objects[index]);
end;

function RMFiltersCount: Integer;
begin
  if FRMExportFilterList = nil then
    Result := -1
  else
    Result := FRMExportFilterList.Count;
end;

function RMTools(index: Integer): TRMToolsInfo;
begin
  Result := TRMToolsInfo(FRMToolsList.Objects[index]);
end;

function RMToolsCount: Integer;
begin
  if FRMToolsList = nil then
    Result := -1
  else
    Result := FRMToolsList.Count;
end;

function RMFunctionList: TList;
begin
	if FRMFunctionList = nil then
  	FRMFunctionList := TList.Create;
	Result := FRMFunctionList;
end;

function RMAddInFunctionCount: Integer;
begin
	if FRMFunctionList <> nil then
  	Result := FRMFunctionList.Count
  else
  	Result := 0;
end;

function RMAddInFunctions(Index: Integer): TRMFunctionLibrary;
begin
	if (Index >= 0) and (Index < RMFunctionList.Count) then
  	Result := TRMFunctionLibrary(FRMFunctionList[Index])
  else
  	Result := nil;
end;


{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
{TRMAddInObjectInfo}

constructor TRMAddInObjectInfo.Create(AClassRef: TClass;
  AEditorFormClass: TFormClass;  const AButtonBmpRes: string;
  const AButtonHint: string;  AIsControl: Boolean);
begin
  inherited Create;
  FClassRef := TRMClass(AClassRef);
  FEditorFormClass := AEditorFormClass;
  FButtonBmpRes := AButtonBmpRes;
  FButtonHint := AButtonHint;
  FIsControl := AIsControl;
end;

{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
{TRMExportFilterInfo}

constructor TRMExportFilterInfo.Create(AClassRef: TRMExportFilter;
  const AFilterDesc: string;  const AFilterExt: string);
begin
  inherited Create;
  FFilter := AClassRef;
  FFilterDesc := AFilterDesc;
  FFilterExt := AFilterExt;
end;

{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
{TRMToolsInfo}

constructor TRMToolsInfo.Create(const ACaption: string;
  const AButtonBmpRes: string;  AOnClick: TNotifyEvent);
begin
  inherited Create;
  FCaption := ACaption;
  FButtonBmpRes := AButtonBmpRes;
  FOnClick := AOnClick;
end;

{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
{登记注册一个Add-in Object}

procedure RMRegisterObjectByRes(ClassRef: TClass; const ButtonBmpRes: string;
  const ButtonHint: string; EditorFormClass: TFormClass);
var
  tmp: TRMAddinObjectInfo;
begin
  tmp := TRMAddinObjectInfo.Create(ClassRef, EditorFormClass, ButtonBmpRes, ButtonHint, FALSE);
  RMAddinObjectList.AddObject('', tmp);
end;

procedure RMRegisterControl(ClassRef: TClass; const ButtonBmpRes, ButtonHint: string);
var
  tmp: TRMAddinObjectInfo;
begin
  tmp := TRMAddinObjectInfo.Create(ClassRef, nil, ButtonBmpRes, ButtonHint, TRUE);
  RMAddinObjectList.AddObject('', tmp);
end;

{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
{登记注册一个Export}

procedure RMRegisterExportFilter(Filter: TRMExportFilter; const FilterDesc, FilterExt: string);
var
  i: Integer;
  tmp: TRMExportFilterInfo;
begin
  for i := 0 to RMFiltersCount - 1 do
  begin
    if RMFilters(i).Filter.ClassName = Filter.ClassName then Exit;
  end;
  tmp := TRMExportFilterInfo.Create(Filter, FilterDesc, FilterExt);
  RMExportFilterList.AddObject('', tmp);
end;

procedure RMUnRegisterExportFilter(Filter: TRMExportFilter);
var
  i: Integer;
begin
  for i := 0 to RMFiltersCount - 1 do
  begin
    if RMFilters(i).Filter.ClassName = Filter.ClassName then
    begin
      TRMExportFilterInfo(RMExportFilterList.Objects[i]).Free;
      RMExportFilterList.Delete(i);
      Break;
    end;
  end;
end;

{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
{登记注册一个Design Tools}

procedure RMRegisterTool(const MenuCaption: string; const ButtonBmpRes: string; OnClick: TNotifyEvent);
var
  tmp: TRMToolsInfo;
begin
  tmp := TRMToolsInfo.Create(MenuCaption, ButtonBmpRes, OnClick);
  RMToolsList.AddObject('', tmp);
end;

procedure RMUnRegisterTool(const MenuCaption: string);
var
  i: Integer;
begin
  for i := 0 to RMToolsList.Count - 1 do
  begin
    if TRMToolsInfo(RMToolsList.Objects[i]).Caption = MenuCaption then
    begin
      TRMToolsInfo(RMToolsList.Objects[i]).Free;
      RMToolsList.Delete(i);
      Break;
    end;
  end;
end;

{------------------------------------------------------------------------------}
{------------------------------------------------------------------------------}
procedure RMRegisterFunctionLibrary(ClassRef: TClass);
var
  i: Integer;
  tmp: TRMFunctionLibrary;
begin
	for i := 0 to RMFunctionList.Count - 1 do
  begin
    if TRMFunctionLibrary(RMFunctionList[i]).ClassName = ClassRef.ClassName then
    	Exit;
  end;
  tmp := TRMFunctionLibrary(ClassRef.NewInstance);
  tmp.Create;
  RMFunctionList.Add(tmp);
end;

procedure RMUnRegisterFunctionLibrary(ClassRef: TClass);
var
  i: Integer;
begin
  for i := 0 to RMFunctionList.Count - 1 do
  begin
    if TRMFunctionLibrary(RMFunctionList[i]).ClassName = ClassRef.ClassName then
    begin
      TRMFunctionLibrary(RMFunctionList[i]).Free;
      RMFunctionList.Delete(i);
      Break;
    end;
  end;
end;

procedure FreeAddInObjectList;
var
  i: Integer;
begin
  if FRMAddInObjectList = nil then Exit;
  for i := 0 to FRMAddInObjectList.Count - 1 do
    FRMAddInObjectList.Objects[i].Free;

  FRMAddInObjectList.Free;  FRMAddInObjectList := nil;
end;

procedure FreeExportFilterList;
var
  i: Integer;
begin
  if FRMExportFilterList = nil then Exit;
  for i := 0 to FRMExportFilterList.Count - 1 do
    FRMExportFilterList.Objects[i].Free;

  FRMExportFilterList.Free;  FRMExportFilterList := nil;
end;

procedure FreeToolsList;
var
  i: Integer;
begin
  if FRMToolsList = nil then Exit;
  for i := 0 to FRMToolsList.Count - 1 do
    FRMToolsList.Objects[i].Free;

  FRMToolsList.Free;  FRMToolsList := nil;
end;

procedure FreeFunctionList;
var
  i: Integer;
begin
  if FRMFunctionList = nil then Exit;
  for i := 0 to FRMFunctionList.Count - 1 do
    TRMFunctionLibrary(FRMFunctionList[i]).Free;

  FRMFunctionList.Free;  FRMFunctionList := nil;
end;

initialization

finalization
  FreeAddInObjectList;
  FreeExportFilterList;
  FreeToolsList;
  FreeFunctionList;

end.