jvinterpreter_db.pas

East make Tray Icon in delphi

{-----------------------------------------------------------------------------
The contents of this file are subject to the Mozilla Public License
Version 1.1 (the "License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.mozilla.org/MPL/MPL-1.1.html

Software distributed under the License is distributed on an "AS IS" basis,
WITHOUT WARRANTY OF ANY KIND, either expressed or implied. See the License for
the specific language governing rights and limitations under the License.

The Original Code is: JvInterpreter_Db.PAS, released on 2002-07-04.

The Initial Developers of the Original Code are: Andrei Prygounkov <a dott prygounkov att gmx dott de>
Copyright (c) 1999, 2002 Andrei Prygounkov
All Rights Reserved.

Contributor(s):

You may retrieve the latest version of this file at the Project JEDI's JVCL home page,
located at http://jvcl.sourceforge.net

Description : adapter unit - converts JvInterpreter calls to delphi calls

Known Issues:
-----------------------------------------------------------------------------}
// $Id: JvInterpreter_Db.pas,v 1.11 2005/02/17 10:20:39 marquardt Exp $

unit JvInterpreter_Db;

{$I jvcl.inc}

interface

uses
  {$IFDEF UNITVERSIONING}
  JclUnitVersioning,
  {$ENDIF UNITVERSIONING}
  JvInterpreter;

procedure RegisterJvInterpreterAdapter(JvInterpreterAdapter: TJvInterpreterAdapter);

{$IFDEF UNITVERSIONING}
const
  UnitVersioning: TUnitVersionInfo = (
    RCSfile: '$RCSfile: JvInterpreter_Db.pas,v $';
    Revision: '$Revision: 1.11 $';
    Date: '$Date: 2005/02/17 10:20:39 $';
    LogPath: 'JVCL\run'
  );
{$ENDIF UNITVERSIONING}

implementation

uses
  Classes, Db;

{ EDatabaseError }

{ TFieldDef }

{ constructor Create(Owner: TFieldDefs; Name: string; DataType: TFieldType; Size: Word; Required: Boolean; FieldNo: Integer) }

procedure TFieldDef_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TFieldDef.Create(V2O(Args.Values[0]) as TFieldDefs, string(Args.Values[1]), Args.Values[2],
    Args.Values[3], Args.Values[4], Args.Values[5]));
end;

{ function CreateField(Owner: TComponent): TField; }

procedure TFieldDef_CreateField(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TFieldDef(Args.Obj).CreateField(V2O(Args.Values[0]) as TComponent));
end;

{ property Read InternalCalcField: Boolean }

procedure TFieldDef_Read_InternalCalcField(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TFieldDef(Args.Obj).InternalCalcField;
end;

{ property Write InternalCalcField(Value: Boolean) }

procedure TFieldDef_Write_InternalCalcField(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TFieldDef(Args.Obj).InternalCalcField := Value;
end;

{ property Read DataType: TFieldType }

procedure TFieldDef_Read_DataType(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TFieldDef(Args.Obj).DataType;
end;

{ property Read FieldClass: TFieldClass }

procedure TFieldDef_Read_FieldClass(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := C2V(TFieldDef(Args.Obj).FieldClass);
end;

{ property Read FieldNo: Integer }

procedure TFieldDef_Read_FieldNo(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TFieldDef(Args.Obj).FieldNo;
end;

{ property Read Name: string }

procedure TFieldDef_Read_Name(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TFieldDef(Args.Obj).Name;
end;

{ property Read Precision: Integer }

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

{ property Write Precision(Value: Integer) }

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

{ property Read Required: Boolean }

procedure TFieldDef_Read_Required(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TFieldDef(Args.Obj).Required;
end;

{ property Read Size: Word }

procedure TFieldDef_Read_Size(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TFieldDef(Args.Obj).Size;
end;

{ TFieldDefs }

{ constructor Create(DataSet: TDataSet) }

procedure TFieldDefs_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TFieldDefs.Create(V2O(Args.Values[0]) as TDataSet));
end;

{ procedure Add(const Name: string; DataType: TFieldType; Size: Word; Required: Boolean); }

procedure TFieldDefs_Add(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TFieldDefs(Args.Obj).Add(Args.Values[0], Args.Values[1], Args.Values[2], Args.Values[3]);
end;

{ procedure Assign(FieldDefs: TFieldDefs); }

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

{ procedure Clear; }

procedure TFieldDefs_Clear(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TFieldDefs(Args.Obj).Clear;
end;

{ function Find(const Name: string): TFieldDef; }

procedure TFieldDefs_Find(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TFieldDefs(Args.Obj).Find(Args.Values[0]));
end;

{ function IndexOf(const Name: string): Integer; }

procedure TFieldDefs_IndexOf(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TFieldDefs(Args.Obj).IndexOf(Args.Values[0]);
end;

{ procedure Update; }

procedure TFieldDefs_Update(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TFieldDefs(Args.Obj).Update;
end;

{ property Read Count: Integer }

procedure TFieldDefs_Read_Count(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TFieldDefs(Args.Obj).Count;
end;

{ property Read Items[Integer]: TFieldDef }

procedure TFieldDefs_Read_Items(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TFieldDefs(Args.Obj).Items[Args.Values[0]]);
end;

{ TField }

{ constructor Create(AOwner: TComponent) }

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

{ procedure Assign(Source: TPersistent); }

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

(*
{ procedure AssignValue(const Value: TVarRec); }
procedure TField_AssignValue(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TField(Args.Obj).AssignValue(Args.Values[0]);
end;
*)

{ procedure Clear; }

procedure TField_Clear(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TField(Args.Obj).Clear;
end;

{ procedure FocusControl; }

procedure TField_FocusControl(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TField(Args.Obj).FocusControl;
end;

{ function GetData(Buffer: Pointer): Boolean; }

procedure TField_GetData(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TField(Args.Obj).GetData(V2P(Args.Values[0]));
end;

{ function IsBlob: Boolean; }

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

{ function IsValidChar(InputChar: Char): Boolean; }

procedure TField_IsValidChar(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TField(Args.Obj).IsValidChar(string(Args.Values[0])[1]);
end;

{ procedure RefreshLookupList; }

procedure TField_RefreshLookupList(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TField(Args.Obj).RefreshLookupList;
end;

{ procedure SetData(Buffer: Pointer); }

procedure TField_SetData(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TField(Args.Obj).SetData(V2P(Args.Values[0]));
end;

{ procedure SetFieldType(Value: TFieldType); }

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

{ procedure Validate(Buffer: Pointer); }

procedure TField_Validate(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TField(Args.Obj).Validate(V2P(Args.Values[0]));
end;

{ property Read AsBoolean: Boolean }

procedure TField_Read_AsBoolean(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TField(Args.Obj).AsBoolean;
end;

{ property Write AsBoolean(Value: Boolean) }

procedure TField_Write_AsBoolean(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TField(Args.Obj).AsBoolean := Value;
end;

{ property Read AsCurrency: Currency }

procedure TField_Read_AsCurrency(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TField(Args.Obj).AsCurrency;
end;

{ property Write AsCurrency(Value: Currency) }

procedure TField_Write_AsCurrency(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TField(Args.Obj).AsCurrency := Value;
end;

{ property Read AsDateTime: TDateTime }

procedure TField_Read_AsDateTime(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TField(Args.Obj).AsDateTime;
end;

{ property Write AsDateTime(Value: TDateTime) }

procedure TField_Write_AsDateTime(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TField(Args.Obj).AsDateTime := Value;
end;

{ property Read AsFloat: Double }

procedure TField_Read_AsFloat(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TField(Args.Obj).AsFloat;
end;

{ property Write AsFloat(Value: Double) }

procedure TField_Write_AsFloat(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TField(Args.Obj).AsFloat := Value;
end;

{ property Read AsInteger: Longint }

procedure TField_Read_AsInteger(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TField(Args.Obj).AsInteger;
end;

{ property Write AsInteger(Value: Longint) }

procedure TField_Write_AsInteger(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TField(Args.Obj).AsInteger := Value;
end;

{ property Read AsString: string }

procedure TField_Read_AsString(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TField(Args.Obj).AsString;
end;

{ property Write AsString(Value: string) }

procedure TField_Write_AsString(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TField(Args.Obj).AsString := Value;
end;

{ property Read AsVariant: Variant }

procedure TField_Read_AsVariant(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TField(Args.Obj).AsVariant;
end;

{ property Write AsVariant(Value: Variant) }

procedure TField_Write_AsVariant(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TField(Args.Obj).AsVariant := Value;
end;

{ property Read AttributeSet: string }

procedure TField_Read_AttributeSet(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TField(Args.Obj).AttributeSet;
end;

{ property Write AttributeSet(Value: string) }

procedure TField_Write_AttributeSet(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TField(Args.Obj).AttributeSet := Value;
end;

{ property Read Calculated: Boolean }

procedure TField_Read_Calculated(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TField(Args.Obj).Calculated;
end;

{ property Write Calculated(Value: Boolean) }

procedure TField_Write_Calculated(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TField(Args.Obj).Calculated := Value;
end;

{ property Read CanModify: Boolean }

procedure TField_Read_CanModify(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TField(Args.Obj).CanModify;
end;

{ property Read CurValue: Variant }

procedure TField_Read_CurValue(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TField(Args.Obj).CurValue;
end;

{ property Read DataSet: TDataSet }

procedure TField_Read_DataSet(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TField(Args.Obj).DataSet);
end;

{ property Write DataSet(Value: TDataSet) }

procedure TField_Write_DataSet(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TField(Args.Obj).DataSet := V2O(Value) as TDataSet;
end;

{ property Read DataSize: Word }

procedure TField_Read_DataSize(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TField(Args.Obj).DataSize;
end;

{ property Read DataType: TFieldType }

procedure TField_Read_DataType(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TField(Args.Obj).DataType;
end;

{ property Read DisplayName: string }

procedure TField_Read_DisplayName(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TField(Args.Obj).DisplayName;
end;

{ property Read DisplayText: string }

procedure TField_Read_DisplayText(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TField(Args.Obj).DisplayText;
end;

{ property Read EditMask: string }

procedure TField_Read_EditMask(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TField(Args.Obj).EditMask;
end;

{ property Write EditMask(Value: string) }