jvinterpreter_db.pas

East make Tray Icon in delphi

{ constructor Create(Owner: TIndexDefs; Name: string; Fields: string; Options: TIndexOptions) }

procedure TIndexDef_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TIndexDef.Create(V2O(Args.Values[0]) as TIndexDefs, string(Args.Values[1]), string(Args.Values[2]),
    TIndexOptions(Byte(V2S(Args.Values[3])))));
end;

{ property Read Expression: string }

procedure TIndexDef_Read_Expression(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TIndexDef(Args.Obj).Expression;
end;

{ property Read Fields: string }

procedure TIndexDef_Read_Fields(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TIndexDef(Args.Obj).Fields;
end;

{ property Read Name: string }

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

{ property Read Options: TIndexOptions }

procedure TIndexDef_Read_Options(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := S2V(Byte(TIndexDef(Args.Obj).Options));
end;

{ property Read Source: string }

procedure TIndexDef_Read_Source(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TIndexDef(Args.Obj).Source;
end;

{ property Write Source(Value: string) }

procedure TIndexDef_Write_Source(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TIndexDef(Args.Obj).Source := Value;
end;

{ TIndexDefs }

{ constructor Create(DataSet: TDataSet) }

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

{ procedure Add(const Name, Fields: string; Options: TIndexOptions); }

procedure TIndexDefs_Add(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TIndexDefs(Args.Obj).Add(Args.Values[0], Args.Values[1], TIndexOptions(Byte(V2S(Args.Values[2]))));
end;

{ procedure Assign(IndexDefs: TIndexDefs); }

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

{ procedure Clear; }

procedure TIndexDefs_Clear(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TIndexDefs(Args.Obj).Clear;
end;

{ function FindIndexForFields(const Fields: string): TIndexDef; }

procedure TIndexDefs_FindIndexForFields(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TIndexDefs(Args.Obj).FindIndexForFields(Args.Values[0]));
end;

{ function GetIndexForFields(const Fields: string; CaseInsensitive: Boolean): TIndexDef; }

procedure TIndexDefs_GetIndexForFields(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TIndexDefs(Args.Obj).GetIndexForFields(Args.Values[0], Args.Values[1]));
end;

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

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

{ procedure Update; }

procedure TIndexDefs_Update(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TIndexDefs(Args.Obj).Update;
end;

{ property Read Count: Integer }

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

{ property Read Items[Integer]: TIndexDef }

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

{ property Read Updated: Boolean }

procedure TIndexDefs_Read_Updated(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TIndexDefs(Args.Obj).Updated;
end;

{ property Write Updated(Value: Boolean) }

procedure TIndexDefs_Write_Updated(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TIndexDefs(Args.Obj).Updated := Value;
end;

{ TDataLink }

{ constructor Create }

procedure TDataLink_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TDataLink.Create);
end;

{ function Edit: Boolean; }

procedure TDataLink_Edit(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataLink(Args.Obj).Edit;
end;

{ procedure UpdateRecord; }

procedure TDataLink_UpdateRecord(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataLink(Args.Obj).UpdateRecord;
end;

{ property Read Active: Boolean }

procedure TDataLink_Read_Active(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataLink(Args.Obj).Active;
end;

{ property Read ActiveRecord: Integer }

procedure TDataLink_Read_ActiveRecord(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataLink(Args.Obj).ActiveRecord;
end;

{ property Write ActiveRecord(Value: Integer) }

procedure TDataLink_Write_ActiveRecord(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataLink(Args.Obj).ActiveRecord := Value;
end;

{ property Read BufferCount: Integer }

procedure TDataLink_Read_BufferCount(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataLink(Args.Obj).BufferCount;
end;

{ property Write BufferCount(Value: Integer) }

procedure TDataLink_Write_BufferCount(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataLink(Args.Obj).BufferCount := Value;
end;

{ property Read DataSet: TDataSet }

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

{ property Read DataSource: TDataSource }

procedure TDataLink_Read_DataSource(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TDataLink(Args.Obj).DataSource);
end;

{ property Write DataSource(Value: TDataSource) }

procedure TDataLink_Write_DataSource(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataLink(Args.Obj).DataSource := V2O(Value) as TDataSource;
end;

{ property Read DataSourceFixed: Boolean }

procedure TDataLink_Read_DataSourceFixed(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataLink(Args.Obj).DataSourceFixed;
end;

{ property Write DataSourceFixed(Value: Boolean) }

procedure TDataLink_Write_DataSourceFixed(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataLink(Args.Obj).DataSourceFixed := Value;
end;

{ property Read Editing: Boolean }

procedure TDataLink_Read_Editing(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataLink(Args.Obj).Editing;
end;

{ property Read ReadOnly: Boolean }

procedure TDataLink_Read_ReadOnly(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataLink(Args.Obj).ReadOnly;
end;

{ property Write ReadOnly(Value: Boolean) }

procedure TDataLink_Write_ReadOnly(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataLink(Args.Obj).ReadOnly := Value;
end;

{ property Read RecordCount: Integer }

procedure TDataLink_Read_RecordCount(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataLink(Args.Obj).RecordCount;
end;

{ TDataSource }

{ constructor Create(AOwner: TComponent) }

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

{ procedure Edit; }

procedure TDataSource_Edit(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSource(Args.Obj).Edit;
end;

{ function IsLinkedTo(DataSet: TDataSet): Boolean; }

procedure TDataSource_IsLinkedTo(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSource(Args.Obj).IsLinkedTo(V2O(Args.Values[0]) as TDataSet);
end;

{ property Read State: TDataSetState }

procedure TDataSource_Read_State(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSource(Args.Obj).State;
end;

{ property Read AutoEdit: Boolean }

procedure TDataSource_Read_AutoEdit(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSource(Args.Obj).AutoEdit;
end;

{ property Write AutoEdit(Value: Boolean) }

procedure TDataSource_Write_AutoEdit(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSource(Args.Obj).AutoEdit := Value;
end;

{ property Read DataSet: TDataSet }

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

{ property Write DataSet(Value: TDataSet) }

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

{ property Read Enabled: Boolean }

procedure TDataSource_Read_Enabled(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSource(Args.Obj).Enabled;
end;

{ property Write Enabled(Value: Boolean) }

procedure TDataSource_Write_Enabled(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSource(Args.Obj).Enabled := Value;
end;

{ TCheckConstraint }

{ procedure Assign(Source: TPersistent); }

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

{ function GetDisplayName: string; }

procedure TCheckConstraint_GetDisplayName(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TCheckConstraint(Args.Obj).GetDisplayName;
end;

{ property Read CustomConstraint: string }

procedure TCheckConstraint_Read_CustomConstraint(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TCheckConstraint(Args.Obj).CustomConstraint;
end;

{ property Write CustomConstraint(Value: string) }

procedure TCheckConstraint_Write_CustomConstraint(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TCheckConstraint(Args.Obj).CustomConstraint := Value;
end;

{ property Read ErrorMessage: string }

procedure TCheckConstraint_Read_ErrorMessage(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TCheckConstraint(Args.Obj).ErrorMessage;
end;

{ property Write ErrorMessage(Value: string) }

procedure TCheckConstraint_Write_ErrorMessage(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TCheckConstraint(Args.Obj).ErrorMessage := Value;
end;

{ property Read FromDictionary: Boolean }

procedure TCheckConstraint_Read_FromDictionary(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TCheckConstraint(Args.Obj).FromDictionary;
end;

{ property Write FromDictionary(Value: Boolean) }

procedure TCheckConstraint_Write_FromDictionary(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TCheckConstraint(Args.Obj).FromDictionary := Value;
end;

{ property Read ImportedConstraint: string }

procedure TCheckConstraint_Read_ImportedConstraint(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TCheckConstraint(Args.Obj).ImportedConstraint;
end;

{ property Write ImportedConstraint(Value: string) }

procedure TCheckConstraint_Write_ImportedConstraint(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TCheckConstraint(Args.Obj).ImportedConstraint := Value;
end;

{ TCheckConstraints }

{ constructor Create(Owner: TPersistent) }

procedure TCheckConstraints_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TCheckConstraints.Create(V2O(Args.Values[0]) as TPersistent));
end;

{ function Add: TCheckConstraint; }

procedure TCheckConstraints_Add(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TCheckConstraints(Args.Obj).Add);
end;

{ property Read Items[Integer]: TCheckConstraint }

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

{ property Write Items[Integer]: TCheckConstraint }

procedure TCheckConstraints_Write_Items(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TCheckConstraints(Args.Obj).Items[Args.Values[0]] := V2O(Value) as TCheckConstraint;
end;

{ TDataSet }

{ function ActiveBuffer: PChar; }

procedure TDataSet_ActiveBuffer(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := string(PString(TDataSet(Args.Obj).ActiveBuffer));
end;

{ procedure Append; }

procedure TDataSet_Append(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).Append;
end;

{ procedure AppendRecord(const Values: array of const); }

procedure TDataSet_AppendRecord(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Args.OpenArray(0);
  TDataSet(Args.Obj).AppendRecord(Slice(Args.OA^, Args.OAS));
end;

{ function BookmarkValid(Bookmark: TBookmark): Boolean; }

procedure TDataSet_BookmarkValid(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).BookmarkValid(V2P(Args.Values[0]));
end;

{ procedure Cancel; }

procedure TDataSet_Cancel(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).Cancel;
end;

{ procedure CheckBrowseMode; }

procedure TDataSet_CheckBrowseMode(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).CheckBrowseMode;
end;

{ procedure ClearFields; }

procedure TDataSet_ClearFields(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).ClearFields;
end;

{ procedure Close; }

procedure TDataSet_Close(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).Close;