abdbctrls.pas

著名的虚拟仪表控件,包含全部源码, 可以在,delphi2007 下安装运行

constructor TAbDBThermometer.Create(AOwner: TComponent);
begin
  inherited;
  FDataLink := TAbFieldDataLink.Create;
  FDataLink.Control := self;
  FDataLink.OnDataRead := DataRead;
  FDataLink.ValueSingle := Value;
  DataReadOnly := true;
end;

destructor TAbDBThermometer.Destroy;
begin
  FDataLink.Free;
  FDataLink := nil;
  inherited;
end;

function TAbDBThermometer.GetDataReadOnly: Boolean;
begin
  result := FDataLink.ReadOnly;
end;

procedure TAbDBThermometer.SetDataReadOnly(Value: Boolean);
begin
  FDataLink.ReadOnly := Value;
end;

procedure TAbDBThermometer.CMGetDataLink(var Message: TMessage);
begin
  Message.result := Integer(FDataLink);
end;

procedure TAbDBThermometer.DataRead(Sender: TObject);
begin
  Value := FDataLink.ValueSingle;
end;

function TAbDBThermometer.GetDataField: string;
begin
  result := FDataLink.FieldName;
end;

function TAbDBThermometer.GetDataSource: TDataSource;
begin
  result := FDataLink.DataSource;
end;

procedure TAbDBThermometer.SetDataField(const Value: string);
begin
  FDataLink.FieldName := Value;
end;

procedure TAbDBThermometer.SetDataSource(const Value: TDataSource);
begin
  if not (FDataLink.DataSourceFixed and (csLoading in Componentstate)) then
    FDataLink.DataSource := Value;
  if Value <> nil then Value.FreeNotification(self);
end;

procedure TAbDBThermometer.ValueChange;
begin
  inherited;
  if Assigned(FDataLink) then FDataLink.DbWriteSingle(Value);
end;

procedure TAbDBThermometer.Notification(AComponent: TComponent;
  Operation: TOperation);
begin
  inherited Notification(AComponent, Operation);
  if (Operation = opRemove) and (FDataLink <> nil) and
    (AComponent = DataSource) then DataSource := nil;
end;
//========================== TAbDBThermometer ==================================

//========================== TAbDBTank =====================================

constructor TAbDBTank.Create(AOwner: TComponent);
begin
  inherited;
  FDataLink := TAbFieldDataLink.Create;
  FDataLink.Control := self;
  FDataLink.OnDataRead := DataRead;
  FDataLink.ValueSingle := Value;
  DataReadOnly := true;
end;

destructor TAbDBTank.Destroy;
begin
  FDataLink.Free;
  FDataLink := nil;
  inherited;
end;

function TAbDBTank.GetDataReadOnly: Boolean;
begin
  result := FDataLink.ReadOnly;
end;

procedure TAbDBTank.SetDataReadOnly(Value: Boolean);
begin
  FDataLink.ReadOnly := Value;
end;

procedure TAbDBTank.CMGetDataLink(var Message: TMessage);
begin
  Message.result := Integer(FDataLink);
end;

procedure TAbDBTank.DataRead(Sender: TObject);
begin
  Value := FDataLink.ValueSingle;
end;

function TAbDBTank.GetDataField: string;
begin
  result := FDataLink.FieldName;
end;

function TAbDBTank.GetDataSource: TDataSource;
begin
  result := FDataLink.DataSource;
end;

procedure TAbDBTank.SetDataField(const Value: string);
begin
  FDataLink.FieldName := Value;
end;

procedure TAbDBTank.SetDataSource(const Value: TDataSource);
begin
  if not (FDataLink.DataSourceFixed and (csLoading in Componentstate)) then
    FDataLink.DataSource := Value;
  if Value <> nil then Value.FreeNotification(self);
end;

procedure TAbDBTank.ValueChange;
begin
  inherited;
  if Assigned(FDataLink) then FDataLink.DbWriteSingle(Value);
end;

procedure TAbDBTank.Notification(AComponent: TComponent;
  Operation: TOperation);
begin
  inherited Notification(AComponent, Operation);
  if (Operation = opRemove) and (FDataLink <> nil) and
    (AComponent = DataSource) then DataSource := nil;
end;
//========================== TAbDBTank =========================================


// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
//                          LED, Switches
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

//============================== TAbDBLED ======================================

constructor TAbDBLED.Create(AOwner: TComponent);
begin
  inherited;
  FDataLink := TAbFieldDataLink.Create;
  FDataLink.Control := self;
  FDataLink.OnDataRead := DataRead;
end;

destructor TAbDBLED.Destroy;
begin
  FDataLink.Free;
  FDataLink := nil;
  inherited;
end;

function TAbDBLED.GetDataReadOnly: Boolean;
begin
  result := FDataLink.ReadOnly;
end;

procedure TAbDBLED.SetDataReadOnly(Value: Boolean);
begin
  FDataLink.ReadOnly := Value;
end;

procedure TAbDBLED.CMGetDataLink(var Message: TMessage);
begin
  Message.result := Integer(FDataLink);
end;

procedure TAbDBLED.DataRead(Sender: TObject);
begin
  case FDataLink.DType of
    dtBoolean: Checked := FDataLink.ValueBool;
    dtInteger, dtSingle: StatusInt := FDataLink.ValueInt;
  end;
end;

function TAbDBLED.GetDataField: string;
begin
  result := FDataLink.FieldName;
end;

function TAbDBLED.GetDataSource: TDataSource;
begin
  result := FDataLink.DataSource;
end;

procedure TAbDBLED.SetDataField(const Value: string);
begin
  FDataLink.FieldName := Value;
end;

procedure TAbDBLED.SetDataSource(const Value: TDataSource);
begin
  if not (FDataLink.DataSourceFixed and (csLoading in Componentstate)) then
    FDataLink.DataSource := Value;
  if Value <> nil then Value.FreeNotification(self);
end;

procedure TAbDBLED.StatusIntChanged;
begin
  inherited;
  if DataReadOnly then Exit;
  if not Assigned(FDataLink) then Exit;

  case FDataLink.DType of
    dtBoolean: FDataLink.DbWriteBoolean(Checked);
    dtInteger, dtSingle: FDataLink.DbWriteInteger(StatusInt);
  end;
end;

procedure TAbDBLED.Notification(AComponent: TComponent;
  Operation: TOperation);
begin
  inherited Notification(AComponent, Operation);
  if (Operation = opRemove) and (FDataLink <> nil) and
    (AComponent = DataSource) then DataSource := nil;
end;
//========================== TAbDBLED ==========================================

//============================== TAbDBColBitBtn ================================

constructor TAbDBColBitBtn.Create(AOwner: TComponent);
begin
  inherited;
  FDataLink := TAbFieldDataLink.Create;
  FDataLink.Control := self;
  FDataLink.OnDataRead := DataRead;
end;

destructor TAbDBColBitBtn.Destroy;
begin
  FDataLink.Free;
  FDataLink := nil;
  inherited;
end;

function TAbDBColBitBtn.GetDataReadOnly: Boolean;
begin
  result := FDataLink.ReadOnly;
end;

procedure TAbDBColBitBtn.SetDataReadOnly(Value: Boolean);
begin
  FDataLink.ReadOnly := Value;
end;

procedure TAbDBColBitBtn.CMGetDataLink(var Message: TMessage);
begin
  Message.result := Integer(FDataLink);
end;

procedure TAbDBColBitBtn.DataRead(Sender: TObject);
begin
  case FDataLink.DType of
    dtBoolean: Checked := FDataLink.ValueBool;
    dtInteger, dtSingle: StatusInt := FDataLink.ValueInt;
  end;
end;

function TAbDBColBitBtn.GetDataField: string;
begin
  result := FDataLink.FieldName;
end;

function TAbDBColBitBtn.GetDataSource: TDataSource;
begin
  result := FDataLink.DataSource;
end;

procedure TAbDBColBitBtn.SetDataField(const Value: string);
begin
  FDataLink.FieldName := Value;
end;

procedure TAbDBColBitBtn.SetDataSource(const Value: TDataSource);
begin
  if not (FDataLink.DataSourceFixed and (csLoading in Componentstate)) then
    FDataLink.DataSource := Value;
  if Value <> nil then Value.FreeNotification(self);
end;

procedure TAbDBColBitBtn.StatusIntChanged;
begin
  inherited;
  if DataReadOnly then Exit;
  if not Assigned(FDataLink) then Exit;

  case FDataLink.DType of
    dtBoolean: FDataLink.DbWriteBoolean(Checked);
    dtInteger, dtSingle: FDataLink.DbWriteInteger(StatusInt);
  end;
end;

procedure TAbDBColBitBtn.Notification(AComponent: TComponent;
  Operation: TOperation);
begin
  inherited Notification(AComponent, Operation);
  if (Operation = opRemove) and (FDataLink <> nil) and
    (AComponent = DataSource) then DataSource := nil;
end;
//========================== TAbDBColBitBtn ====================================

//============================== TAbDBRockerSwitch =============================

constructor TAbDBRockerSwitch.Create(AOwner: TComponent);
begin
  inherited;
  FDataLink := TAbFieldDataLink.Create;
  FDataLink.Control := self;
  FDataLink.OnDataRead := DataRead;
end;

destructor TAbDBRockerSwitch.Destroy;
begin
  FDataLink.Free;
  FDataLink := nil;
  inherited;
end;

function TAbDBRockerSwitch.GetDataReadOnly: Boolean;
begin
  result := FDataLink.ReadOnly;
end;

procedure TAbDBRockerSwitch.SetDataReadOnly(Value: Boolean);
begin
  FDataLink.ReadOnly := Value;
end;

procedure TAbDBRockerSwitch.CMGetDataLink(var Message: TMessage);
begin
  Message.result := Integer(FDataLink);
end;

procedure TAbDBRockerSwitch.DataRead(Sender: TObject);
begin
  case FDataLink.DType of
    dtBoolean: Checked := FDataLink.ValueBool;
    dtInteger, dtSingle: StatusInt := FDataLink.ValueInt;
  end;
end;

function TAbDBRockerSwitch.GetDataField: string;
begin
  result := FDataLink.FieldName;
end;

function TAbDBRockerSwitch.GetDataSource: TDataSource;
begin
  result := FDataLink.DataSource;
end;

procedure TAbDBRockerSwitch.SetDataField(const Value: string);
begin
  FDataLink.FieldName := Value;
end;

procedure TAbDBRockerSwitch.SetDataSource(const Value: TDataSource);
begin
  if not (FDataLink.DataSourceFixed and (csLoading in Componentstate)) then
    FDataLink.DataSource := Value;
  if Value <> nil then Value.FreeNotification(self);
end;

procedure TAbDBRockerSwitch.StatusIntChanged;
begin
  inherited;
  if DataReadOnly then Exit;
  if not Assigned(FDataLink) then Exit;

  case FDataLink.DType of
    dtBoolean: FDataLink.DbWriteBoolean(Checked);
    dtInteger, dtSingle: FDataLink.DbWriteInteger(StatusInt);
  end;
end;

procedure TAbDBRockerSwitch.Notification(AComponent: TComponent;
  Operation: TOperation);
begin
  inherited Notification(AComponent, Operation);
  if (Operation = opRemove) and (FDataLink <> nil) and
    (AComponent = DataSource) then DataSource := nil;
end;
//========================== TAbDBRockerSwitch =================================

//============================== TAbDBToggleSwitch =============================

constructor TAbDBToggleSwitch.Create(AOwner: TComponent);
begin
  inherited;
  FDataLink := TAbFieldDataLink.Create;
  FDataLink.Control := self;
  FDataLink.OnDataRead := DataRead;
end;

destructor TAbDBToggleSwitch.Destroy;
begin
  FDataLink.Free;
  FDataLink := nil;
  inherited;
end;

function TAbDBToggleSwitch.GetDataReadOnly: Boolean;
begin
  result := FDataLink.ReadOnly;
end;

procedure TAbDBToggleSwitch.SetDataReadOnly(Value: Boolean);
begin
  FDataLink.ReadOnly := Value;
end;

procedure TAbDBToggleSwitch.CMGetDataLink(var Message: TMessage);
begin
  Message.result := Integer(FDataLink);
end;

procedure TAbDBToggleSwitch.DataRead(Sender: TObject);
begin
  case FDataLink.DType of
    dtBoolean: Checked := FDataLink.ValueBool;
    dtInteger, dtSingle: StatusInt := FDataLink.ValueInt;
  end;
end;

function TAbDBToggleSwitch.GetDataField: string;
begin
  result := FDataLink.FieldName;
end;

function TAbDBToggleSwitch.GetDataSource: TDataSource;
begin
  result := FDataLink.DataSource;
end;

procedure TAbDBToggleSwitch.SetDataField(const Value: string);
begin
  FDataLink.FieldName := Value;
end;

procedure TAbDBToggleSwitch.SetDataSource(const Value: TDataSource);
begin
  if not (FDataLink.DataSourceFixed and (csLoading in Componentstate)) then
    FDataLink.DataSource := Value;
  if Value <> nil then Value.FreeNotification(self);
end;

procedure TAbDBToggleSwitch.StatusIntChanged;
begin
  inherited;
  if DataReadOnly then Exit;
  if not Assigned(FDataLink) then Exit;

  case FDataLink.DType of
    dtBoolean: FDataLink.DbWriteBoolean(Checked);
    dtInteger, dtSingle: FDataLink.DbWriteInteger(StatusInt);
  end;
end;

procedure TAbDBToggleSwitch.Notification(AComponent: TComponent;
  Operation: TOperation);
begin
  inherited Notification(AComponent, Operation);
  if (Operation = opRemove) and (FDataLink <> nil) and
    (AComponent = DataSource) then DataSource := nil;
end;
//========================== TAbDBToggleSwitch =================================




end.