jvinterpreter_db.pas

East make Tray Icon in delphi

end;

{ function ControlsDisabled: Boolean; }

procedure TDataSet_ControlsDisabled(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).ControlsDisabled;
end;

{ function CompareBookmarks(Bookmark1, Bookmark2: TBookmark): Integer; }

procedure TDataSet_CompareBookmarks(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).CompareBookmarks(V2P(Args.Values[0]), V2P(Args.Values[1]));
end;

{ function CreateBlobStream(Field: TField; Mode: TBlobStreamMode): TStream; }

procedure TDataSet_CreateBlobStream(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TDataSet(Args.Obj).CreateBlobStream(V2O(Args.Values[0]) as TField, Args.Values[1]));
end;

{ procedure CursorPosChanged; }

procedure TDataSet_CursorPosChanged(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).CursorPosChanged;
end;

{ procedure Delete; }

procedure TDataSet_Delete(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).Delete;
end;

{ procedure DisableControls; }

procedure TDataSet_DisableControls(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).DisableControls;
end;

{ procedure Edit; }

procedure TDataSet_Edit(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).Edit;
end;

{ procedure EnableControls; }

procedure TDataSet_EnableControls(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).EnableControls;
end;

{ function FieldByName(const FieldName: string): TField; }

procedure TDataSet_FieldByName(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TDataSet(Args.Obj).FieldByName(Args.Values[0]));
end;

{ function FindField(const FieldName: string): TField; }

procedure TDataSet_FindField(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TDataSet(Args.Obj).FindField(Args.Values[0]));
end;

{ function FindFirst: Boolean; }

procedure TDataSet_FindFirst(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).FindFirst;
end;

{ function FindLast: Boolean; }

procedure TDataSet_FindLast(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).FindLast;
end;

{ function FindNext: Boolean; }

procedure TDataSet_FindNext(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).FindNext;
end;

{ function FindPrior: Boolean; }

procedure TDataSet_FindPrior(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).FindPrior;
end;

{ procedure First; }

procedure TDataSet_First(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).First;
end;

{ procedure FreeBookmark(Bookmark: TBookmark); }

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

{ function GetBookmark: TBookmark; }

procedure TDataSet_GetBookmark(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := P2V(TDataSet(Args.Obj).GetBookmark);
end;

{ function GetCurrentRecord(Buffer: PChar): Boolean; }

procedure TDataSet_GetCurrentRecord(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).GetCurrentRecord(PChar(string(Args.Values[0])));
end;

{ procedure GetFieldList(List: TList; const FieldNames: string); }

procedure TDataSet_GetFieldList(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).GetFieldList(V2O(Args.Values[0]) as TList, Args.Values[1]);
end;

{ procedure GetFieldNames(List: TStrings); }

procedure TDataSet_GetFieldNames(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).GetFieldNames(V2O(Args.Values[0]) as TStrings);
end;

{ procedure GotoBookmark(Bookmark: TBookmark); }

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

{ procedure Insert; }

procedure TDataSet_Insert(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).Insert;
end;

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

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

{ function IsEmpty: Boolean; }

procedure TDataSet_IsEmpty(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).IsEmpty;
end;

{ function IsLinkedTo(DataSource: TDataSource): Boolean; }

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

{ function IsSequenced: Boolean; }

procedure TDataSet_IsSequenced(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).IsSequenced;
end;

{ procedure Last; }

procedure TDataSet_Last(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).Last;
end;

{ function Locate(const KeyFields: string; const KeyValues: Variant; Options: TLocateOptions): Boolean; }

procedure TDataSet_Locate(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).Locate(Args.Values[0], Args.Values[1], TLocateOptions(Byte(V2S(Args.Values[2]))));
end;

{ function Lookup(const KeyFields: string; const KeyValues: Variant; const ResultFields: string): Variant; }

procedure TDataSet_Lookup(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).Lookup(Args.Values[0], Args.Values[1], Args.Values[2]);
end;

{ function MoveBy(Distance: Integer): Integer; }

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

{ procedure Next; }

procedure TDataSet_Next(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).Next;
end;

{ procedure Open; }

procedure TDataSet_Open(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).Open;
end;

{ procedure Post; }

procedure TDataSet_Post(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).Post;
end;

{ procedure Prior; }

procedure TDataSet_Prior(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).Prior;
end;

{ procedure Refresh; }

procedure TDataSet_Refresh(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).Refresh;
end;

{ procedure Resync(Mode: TResyncMode); }

procedure TDataSet_Resync(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).Resync(TResyncMode(Byte(V2S(Args.Values[0]))));
end;

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

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

{ procedure Translate(Src, Dest: PChar; ToOem: Boolean); }

procedure TDataSet_Translate(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).Translate(PChar(string(Args.Values[0])), PChar(string(Args.Values[1])), Args.Values[2]);
end;

{ procedure UpdateCursorPos; }

procedure TDataSet_UpdateCursorPos(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).UpdateCursorPos;
end;

{ procedure UpdateRecord; }

procedure TDataSet_UpdateRecord(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).UpdateRecord;
end;

{ property Read BOF: Boolean }

procedure TDataSet_Read_BOF(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).BOF;
end;

{ property Read Bookmark: TBookmarkStr }

procedure TDataSet_Read_Bookmark(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).Bookmark;
end;

{ property Write Bookmark(Value: TBookmarkStr) }

procedure TDataSet_Write_Bookmark(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).Bookmark := Value;
end;

{ property Read CanModify: Boolean }

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

{ property Read DataSource: TDataSource }

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

{ property Read DefaultFields: Boolean }

procedure TDataSet_Read_DefaultFields(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).DefaultFields;
end;

{ property Read Designer: TDataSetDesigner }

procedure TDataSet_Read_Designer(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TDataSet(Args.Obj).Designer);
end;

{ property Read EOF: Boolean }

procedure TDataSet_Read_EOF(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).EOF;
end;

{ property Read FieldCount: Integer }

procedure TDataSet_Read_FieldCount(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).FieldCount;
end;

{ property Read FieldDefs: TFieldDefs }

procedure TDataSet_Read_FieldDefs(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TDataSet(Args.Obj).FieldDefs);
end;

{ property Write FieldDefs(Value: TFieldDefs) }

procedure TDataSet_Write_FieldDefs(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).FieldDefs := V2O(Value) as TFieldDefs;
end;

{ property Read Fields[Integer]: TField }

procedure TDataSet_Read_Fields(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TDataSet(Args.Obj).Fields[Args.Values[0]]);
end;

{ property Read FieldValues[string]: Variant }

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

{ property Write FieldValues[string]: Variant }

procedure TDataSet_Write_FieldValues(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).FieldValues[Args.Values[0]] := Value;
end;

{ property Read Found: Boolean }

procedure TDataSet_Read_Found(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).Found;
end;

{ property Read Modified: Boolean }

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

{ property Read RecordCount: Integer }

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

{ property Read RecNo: Integer }

procedure TDataSet_Read_RecNo(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).RecNo;
end;

{ property Write RecNo(Value: Integer) }

procedure TDataSet_Write_RecNo(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).RecNo := Value;
end;

{ property Read RecordSize: Word }

procedure TDataSet_Read_RecordSize(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).RecordSize;
end;

{ property Read State: TDataSetState }

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

{ property Read Filter: string }

procedure TDataSet_Read_Filter(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).Filter;
end;

{ property Write Filter(Value: string) }

procedure TDataSet_Write_Filter(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).Filter := Value;
end;

{ property Read Filtered: Boolean }

procedure TDataSet_Read_Filtered(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDataSet(Args.Obj).Filtered;
end;

{ property Write Filtered(Value: Boolean) }

procedure TDataSet_Write_Filtered(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).Filtered := Value;
end;

{ property Read FilterOptions: TFilterOptions }

procedure TDataSet_Read_FilterOptions(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := S2V(Byte(TDataSet(Args.Obj).FilterOptions));
end;

{ property Write FilterOptions(Value: TFilterOptions) }

procedure TDataSet_Write_FilterOptions(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Args.Obj).FilterOptions := TFilterOptions(Byte(V2S(Value)));
end;

{ property Read Active: Boolean }

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

{ property Write Active(Value: Boolean) }

procedure TDataSet_Write_Active(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TDataSet(Ar