jvinterpreter_db.pas

East make Tray Icon in delphi

procedure TIntegerField_Read_Value(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TIntegerField(Args.Obj).Value;
end;

{ property Write Value(Value: Longint) }

procedure TIntegerField_Write_Value(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TIntegerField(Args.Obj).Value := Value;
end;

{ property Read MaxValue: Longint }

procedure TIntegerField_Read_MaxValue(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TIntegerField(Args.Obj).MaxValue;
end;

{ property Write MaxValue(Value: Longint) }

procedure TIntegerField_Write_MaxValue(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TIntegerField(Args.Obj).MaxValue := Value;
end;

{ property Read MinValue: Longint }

procedure TIntegerField_Read_MinValue(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TIntegerField(Args.Obj).MinValue;
end;

{ property Write MinValue(Value: Longint) }

procedure TIntegerField_Write_MinValue(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TIntegerField(Args.Obj).MinValue := Value;
end;

{ TSmallintField }

{ constructor Create(AOwner: TComponent) }

procedure TSmallintField_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TSmallintField.Create(V2O(Args.Values[0]) as TComponent));
end;

{ TWordField }

{ constructor Create(AOwner: TComponent) }

procedure TWordField_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TWordField.Create(V2O(Args.Values[0]) as TComponent));
end;

{ TAutoIncField }

{ constructor Create(AOwner: TComponent) }

procedure TAutoIncField_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TAutoIncField.Create(V2O(Args.Values[0]) as TComponent));
end;

{ TFloatField }

{ constructor Create(AOwner: TComponent) }

procedure TFloatField_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TFloatField.Create(V2O(Args.Values[0]) as TComponent));
end;

{ property Read Value: Double }

procedure TFloatField_Read_Value(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TFloatField(Args.Obj).Value;
end;

{ property Write Value(Value: Double) }

procedure TFloatField_Write_Value(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TFloatField(Args.Obj).Value := Value;
end;

{ property Read Currency: Boolean }

procedure TFloatField_Read_Currency(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TFloatField(Args.Obj).Currency;
end;

{ property Write Currency(Value: Boolean) }

procedure TFloatField_Write_Currency(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TFloatField(Args.Obj).Currency := Value;
end;

{ property Read MaxValue: Double }

procedure TFloatField_Read_MaxValue(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TFloatField(Args.Obj).MaxValue;
end;

{ property Write MaxValue(Value: Double) }

procedure TFloatField_Write_MaxValue(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TFloatField(Args.Obj).MaxValue := Value;
end;

{ property Read MinValue: Double }

procedure TFloatField_Read_MinValue(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TFloatField(Args.Obj).MinValue;
end;

{ property Write MinValue(Value: Double) }

procedure TFloatField_Write_MinValue(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TFloatField(Args.Obj).MinValue := Value;
end;

{ property Read Precision: Integer }

procedure TFloatField_Read_Precision(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TFloatField(Args.Obj).Precision;
end;

{ property Write Precision(Value: Integer) }

procedure TFloatField_Write_Precision(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TFloatField(Args.Obj).Precision := Value;
end;

{ TCurrencyField }

{ constructor Create(AOwner: TComponent) }

procedure TCurrencyField_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TCurrencyField.Create(V2O(Args.Values[0]) as TComponent));
end;

{ TBooleanField }

{ constructor Create(AOwner: TComponent) }

procedure TBooleanField_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TBooleanField.Create(V2O(Args.Values[0]) as TComponent));
end;

{ property Read Value: Boolean }

procedure TBooleanField_Read_Value(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBooleanField(Args.Obj).Value;
end;

{ property Write Value(Value: Boolean) }

procedure TBooleanField_Write_Value(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBooleanField(Args.Obj).Value := Value;
end;

{ property Read DisplayValues: string }

procedure TBooleanField_Read_DisplayValues(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBooleanField(Args.Obj).DisplayValues;
end;

{ property Write DisplayValues(Value: string) }

procedure TBooleanField_Write_DisplayValues(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBooleanField(Args.Obj).DisplayValues := Value;
end;

{ TDateTimeField }

{ constructor Create(AOwner: TComponent) }

procedure TDateTimeField_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TDateTimeField.Create(V2O(Args.Values[0]) as TComponent));
end;

{ property Read Value: TDateTime }

procedure TDateTimeField_Read_Value(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDateTimeField(Args.Obj).Value;
end;

{ property Write Value(Value: TDateTime) }

procedure TDateTimeField_Write_Value(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TDateTimeField(Args.Obj).Value := Value;
end;

{ property Read DisplayFormat: string }

procedure TDateTimeField_Read_DisplayFormat(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDateTimeField(Args.Obj).DisplayFormat;
end;

{ property Write DisplayFormat(Value: string) }

procedure TDateTimeField_Write_DisplayFormat(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TDateTimeField(Args.Obj).DisplayFormat := Value;
end;

{ TDateField }

{ constructor Create(AOwner: TComponent) }

procedure TDateField_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TDateField.Create(V2O(Args.Values[0]) as TComponent));
end;

{ TTimeField }

{ constructor Create(AOwner: TComponent) }

procedure TTimeField_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTimeField.Create(V2O(Args.Values[0]) as TComponent));
end;

{ TBinaryField }

{ constructor Create(AOwner: TComponent) }

procedure TBinaryField_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TBinaryField.Create(V2O(Args.Values[0]) as TComponent));
end;

{ TBytesField }

{ constructor Create(AOwner: TComponent) }

procedure TBytesField_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TBytesField.Create(V2O(Args.Values[0]) as TComponent));
end;

{ TVarBytesField }

{ constructor Create(AOwner: TComponent) }

procedure TVarBytesField_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TVarBytesField.Create(V2O(Args.Values[0]) as TComponent));
end;

{ TBCDField }

{ constructor Create(AOwner: TComponent) }

procedure TBCDField_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TBCDField.Create(V2O(Args.Values[0]) as TComponent));
end;

{ property Read Value: Currency }

procedure TBCDField_Read_Value(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBCDField(Args.Obj).Value;
end;

{ property Write Value(Value: Currency) }

procedure TBCDField_Write_Value(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBCDField(Args.Obj).Value := Value;
end;

{ property Read Currency: Boolean }

procedure TBCDField_Read_Currency(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBCDField(Args.Obj).Currency;
end;

{ property Write Currency(Value: Boolean) }

procedure TBCDField_Write_Currency(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBCDField(Args.Obj).Currency := Value;
end;

{ property Read MaxValue: Currency }

procedure TBCDField_Read_MaxValue(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBCDField(Args.Obj).MaxValue;
end;

{ property Write MaxValue(Value: Currency) }

procedure TBCDField_Write_MaxValue(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBCDField(Args.Obj).MaxValue := Value;
end;

{ property Read MinValue: Currency }

procedure TBCDField_Read_MinValue(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBCDField(Args.Obj).MinValue;
end;

{ property Write MinValue(Value: Currency) }

procedure TBCDField_Write_MinValue(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBCDField(Args.Obj).MinValue := Value;
end;

{ TBlobField }

{ constructor Create(AOwner: TComponent) }

procedure TBlobField_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TBlobField.Create(V2O(Args.Values[0]) as TComponent));
end;

{ procedure Assign(Source: TPersistent); }

procedure TBlobField_Assign(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TBlobField(Args.Obj).Assign(V2O(Args.Values[0]) as TPersistent);
end;

{ procedure Clear; }

procedure TBlobField_Clear(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TBlobField(Args.Obj).Clear;
end;

{ function IsBlob: Boolean; }

procedure TBlobField_IsBlob(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBlobField(Args.Obj).IsBlob;
end;

{ procedure LoadFromFile(const FileName: string); }

procedure TBlobField_LoadFromFile(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TBlobField(Args.Obj).LoadFromFile(Args.Values[0]);
end;

{ procedure LoadFromStream(Stream: TStream); }

procedure TBlobField_LoadFromStream(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TBlobField(Args.Obj).LoadFromStream(V2O(Args.Values[0]) as TStream);
end;

{ procedure SaveToFile(const FileName: string); }

procedure TBlobField_SaveToFile(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TBlobField(Args.Obj).SaveToFile(Args.Values[0]);
end;

{ procedure SaveToStream(Stream: TStream); }

procedure TBlobField_SaveToStream(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TBlobField(Args.Obj).SaveToStream(V2O(Args.Values[0]) as TStream);
end;

{ procedure SetFieldType(Value: TFieldType); }

procedure TBlobField_SetFieldType(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TBlobField(Args.Obj).SetFieldType(Args.Values[0]);
end;

{ property Read BlobSize: Integer }

procedure TBlobField_Read_BlobSize(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBlobField(Args.Obj).BlobSize;
end;

{ property Read Modified: Boolean }

procedure TBlobField_Read_Modified(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBlobField(Args.Obj).Modified;
end;

{ property Write Modified(Value: Boolean) }

procedure TBlobField_Write_Modified(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBlobField(Args.Obj).Modified := Value;
end;

{ property Read Value: string }

procedure TBlobField_Read_Value(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBlobField(Args.Obj).Value;
end;

{ property Write Value(Value: string) }

procedure TBlobField_Write_Value(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBlobField(Args.Obj).Value := Value;
end;

{ property Read Transliterate: Boolean }

procedure TBlobField_Read_Transliterate(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBlobField(Args.Obj).Transliterate;
end;

{ property Write Transliterate(Value: Boolean) }

procedure TBlobField_Write_Transliterate(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBlobField(Args.Obj).Transliterate := Value;
end;

{ property Read BlobType: TBlobType }

procedure TBlobField_Read_BlobType(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBlobField(Args.Obj).BlobType;
end;

{ property Write BlobType(Value: TBlobType) }

procedure TBlobField_Write_BlobType(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBlobField(Args.Obj).BlobType := Value;
end;

{ TMemoField }

{ constructor Create(AOwner: TComponent) }

procedure TMemoField_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TMemoField.Create(V2O(Args.Values[0]) as TComponent));
end;

{ TGraphicField }

{ constructor Create(AOwner: TComponent) }

procedure TGraphicField_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TGraphicField.Create(V2O(Args.Values[0]) as TComponent));
end;

{ TIndexDef }