designintf.pas

漏洞扫描系列中HB Network Scanner 测试用练习代码

  IDesignerThreadAffinity = interface
    ['{7ED7BF2D-E449-11D3-A84A-00C05FB1767A}']
    function GetThreadAffinity: TThreadAffinity;
  end;
{$ENDIF}

{$IFDEF MSWINDOWS}
  { Drag drop interface }
  TDragTarget = class
  private
    FDesigner: IDesigner;
  public
    constructor Create(const ADesigner: IDesigner); virtual;
    function DragOver(Target, Source: TObject; X, Y: Integer;
      State: TDragState): Boolean; virtual; abstract;
    procedure DragDrop(Target, Source: TObject; X, Y: Integer); virtual; abstract;
    property Designer: IDesigner read FDesigner;
  end;

  TDragTargetClass = class of TDragTarget;

  TRegisterDragTargetProc = procedure(const SourceName: string;
    TargetClass: TDragTargetClass);

var
  RegisterDragTargetProc: TRegisterDragTargetProc;

procedure RegisterDragTarget(const SourceName: string; TargetClass: TDragTargetClass);

type
  TRegisterDesignDragObject = procedure (DragObjectClass: TDragObjectClass);

var
  RegisterDesignDragObjectProc: TRegisterDesignDragObject;

procedure RegisterDesignDragObject(DragObjectClass: TDragObjectClass);
{$ENDIF}

implementation

procedure RegisterPropertyMapper(Mapper: TPropertyMapperFunc);
begin
  if Assigned(RegisterPropertyMapperProc) then
    RegisterPropertyMapperProc(Mapper);
end;

procedure RegisterPropertyInCategory(const CategoryName, PropertyName: string);
  overload;
begin
  if Assigned(RegisterPropertyInCategoryProc) then
    RegisterPropertyInCategoryProc(CategoryName, nil, nil, PropertyName);
end;

procedure RegisterPropertyInCategory(const CategoryName: string;
  ComponentClass: TClass; const PropertyName: string); overload;
begin
  if Assigned(RegisterPropertyInCategoryProc) then
    RegisterPropertyInCategoryProc(CategoryName, ComponentClass, nil,
      PropertyName);
end;

procedure RegisterPropertyInCategory(const CategoryName: string;
  PropertyType: PTypeInfo; const PropertyName: string); overload;
begin
  if Assigned(RegisterPropertyInCategoryProc) then
    RegisterPropertyInCategoryProc(CategoryName, nil, PropertyType,
      PropertyName);
end;

procedure RegisterPropertyInCategory(const CategoryName: string;
  PropertyType: PTypeInfo); overload;
begin
  if Assigned(RegisterPropertyInCategoryProc) then
    RegisterPropertyInCategoryProc(CategoryName, nil, PropertyType, '');
end;

procedure RegisterPropertiesInCategory(const CategoryName: string;
  const Filters: array of const); overload;
var
  I: Integer;
begin
  if Assigned(RegisterPropertyInCategoryProc) then
    for I := Low(Filters) to High(Filters) do
      with Filters[I] do
        case vType of
          vtPointer:
            RegisterPropertyInCategoryProc(CategoryName, nil,
              PTypeInfo(vPointer), '');
          vtClass:
            RegisterPropertyInCategoryProc(CategoryName, vClass, nil, '');
          vtAnsiString:
            RegisterPropertyInCategoryProc(CategoryName, nil, nil,
              string(vAnsiString));
        else
          raise Exception.CreateResFmt(@sInvalidFilter, [I, vType]);
        end;
end;

procedure RegisterPropertiesInCategory(const CategoryName: string;
  ComponentClass: TClass; const Filters: array of string); overload;
var
  I: Integer;
begin
  if Assigned(RegisterPropertyInCategoryProc) then
    for I := Low(Filters) to High(Filters) do
      RegisterPropertyInCategoryProc(CategoryName, ComponentClass, nil,
        Filters[I]);
end;

procedure RegisterPropertiesInCategory(const CategoryName: string;
  PropertyType: PTypeInfo; const Filters: array of string); overload;
var
  I: Integer;
begin
  if Assigned(RegisterPropertyInCategoryProc) then
    for I := Low(Filters) to High(Filters) do
      RegisterPropertyInCategoryProc(CategoryName, nil, PropertyType,
        Filters[I]);
end;

{ Design notification registration }

procedure RegisterDesignNotification(const DesignNotification: IDesignNotification);
begin
  if Assigned(RegisterDesignNotificationProc) then
    RegisterDesignNotificationProc(DesignNotification);
end;

procedure UnregisterDesignNotification(const DesignNotification: IDesignNotification);
begin
  if Assigned(UnregisterDesignNotificationProc) then
    UnregisterDesignNotificationProc(DesignNotification);
end;

{ TBasePropertyEditor }

constructor TBasePropertyEditor.Create(const ADesigner: IDesigner;
  APropCount: Integer);
begin
  inherited Create;
end;

{ TBaseComponentEditor }

constructor TBaseComponentEditor.Create(AComponent: TComponent;
  ADesigner: IDesigner);
begin
  inherited Create;
end;

procedure RegisterComponentEditor(ComponentClass: TComponentClass;
  ComponentEditor: TComponentEditorClass);
begin
  if Assigned(RegisterComponentEditorProc) then
    RegisterComponentEditorProc(ComponentClass, ComponentEditor);
end;

{ TDesignerSelections }

function TDesignerSelections.Add(const Item: TPersistent): Integer;
begin
  Result := FList.Add(Item);
end;

constructor TDesignerSelections.Copy(const Selections: IDesignerSelections);
var
  I: Integer;
begin
  Create;
  for I := 0 to Selections.Count - 1 do
    Add(Selections[I]);
end;

constructor TDesignerSelections.Create;
begin
  inherited;
  FList := TList.Create;
end;

destructor TDesignerSelections.Destroy;
begin
  FList.Free;
  inherited;
end;

function TDesignerSelections.Equals(const List: IDesignerSelections): Boolean;
var
  I: Integer;
begin
  Result := False;
  if List.Count <> Count then Exit;
  for I := 0 to Count - 1 do
    if Items[I] <> List[I] then Exit;
  Result := True;
end;

function TDesignerSelections.Get(Index: Integer): TPersistent;
begin
  Result := TPersistent(FList[Index]);
end;

function TDesignerSelections.GetCount: Integer;
begin
  Result := FList.Count;
end;

function CreateSelectionList: IDesignerSelections;
begin
  Result := TDesignerSelections.Create;
end;

procedure RegisterPropertyEditor(PropertyType: PTypeInfo;
  ComponentClass: TClass; const PropertyName: string;
  EditorClass: TPropertyEditorClass);
begin
  if Assigned(RegisterPropertyEditorProc) then
    RegisterPropertyEditorProc(PropertyType, ComponentClass, PropertyName,
      EditorClass);
end;

procedure SetPropertyEditorGroup(EditorClass: TPropertyEditorClass;
  GroupClass: TPersistentClass);
begin
  if Assigned(SetPropertyEditorGroupProc) then
    SetPropertyEditorGroupProc(EditorClass, GroupClass);
end;

procedure UnlistPublishedProperty(ComponentClass: TClass; const PropertyName: string);
var
  LPropInfo: PPropInfo;
begin
  LPropInfo := GetPropInfo(ComponentClass, PropertyName);
  if LPropInfo <> nil then
    RegisterPropertyEditor(LPropInfo^.PropType^, ComponentClass, PropertyName, nil);
end;

{ TBaseSelectionEditor }

constructor TBaseSelectionEditor.Create(const ADesigner: IDesigner);
begin
  inherited Create;
end;

procedure RegisterSelectionEditor(AClass: TClass; AEditor: TSelectionEditorClass);
begin
  if Assigned(RegisterSelectionEditorProc) then
    RegisterSelectionEditorProc(AClass, AEditor);
end;

{ TBaseCustomModule }

constructor TBaseCustomModule.Create(ARoot: TComponent; const Designer: IDesigner);
begin
  inherited Create;
end;

class function TBaseCustomModule.DesignClass: TComponentClass;
begin
  Result := nil;
end;

procedure RegisterCustomModule(ComponentBaseClass: TComponentClass;
  CustomModuleClass: TCustomModuleClass);
begin
  if Assigned(RegisterCustomModuleProc) then
    RegisterCustomModuleProc(CurrentGroup, ComponentBaseClass,
      CustomModuleClass);
end;

{$IFDEF MSWINDOWS}
{ TDragTarget }

constructor TDragTarget.Create(const ADesigner: IDesigner);
begin
  inherited Create;
  FDesigner := ADesigner;
end;

procedure RegisterDragTarget(const SourceName: string; TargetClass: TDragTargetClass);
begin
  if Assigned(RegisterDragTargetProc) then
    RegisterDragTargetProc(SourceName, TargetClass);
end;

procedure RegisterDesignDragObject(DragObjectClass: TDragObjectClass);
begin
  if Assigned(RegisterDesignDragObjectProc) then
    RegisterDesignDragObjectProc(DragObjectClass);
end;

{$ENDIF}
end.