rm_jvinterpreter_classes.pas

来自「胜天进销存源码,国产优秀的进销存」· PAS 代码 · 共 1,210 行 · 第 1/4 页

{-----------------------------------------------------------------------------
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_Classes.PAS, released on 2002-07-04.
The Initial Developers of the Original Code are: Andrei Prygounkov <[e-mail]>
Copyright (c) 1999, 2002 Andrei Prygounkov
All Rights Reserved.
Contributor(s):
Last Modified: 2002-07-04
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:
-----------------------------------------------------------------------------}
{$I rm_JVCL.INC}
unit rm_JvInterpreter_Classes;
interface
uses
  rm_JvInterpreter;
procedure RegisterJvInterpreterAdapter(JvInterpreterAdapter: TJvInterpreterAdapter);
implementation
uses
{$IFDEF LINUX}
  Classes, Variants;
{$ELSE}
  Classes;
{$ENDIF LINUX}
{ TList }
{ constructor }

procedure TList_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TList.Create);
end;
{ function Add(Item: Pointer): Integer; }

procedure TList_Add(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TList(Args.Obj).Add(V2P(Args.Values[0]));
end;
{ procedure Clear; }

procedure TList_Clear(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TList(Args.Obj).Clear;
end;
{ procedure Delete(Index: Integer); }

procedure TList_Delete(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TList(Args.Obj).Delete(Args.Values[0]);
end;
{ procedure Exchange(Index1, Index2: Integer); }

procedure TList_Exchange(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TList(Args.Obj).Exchange(Args.Values[0], Args.Values[1]);
end;
{ function Expand: TList; }

procedure TList_Expand(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TList(Args.Obj).Expand);
end;
{ function First: Pointer; }

procedure TList_First(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := P2V(TList(Args.Obj).First);
end;
{ function IndexOf(Item: Pointer): Integer; }

procedure TList_IndexOf(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TList(Args.Obj).IndexOf(V2P(Args.Values[0]));
end;
{ procedure Insert(Index: Integer; Item: Pointer); }

procedure TList_Insert(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TList(Args.Obj).Insert(Args.Values[0], V2P(Args.Values[1]));
end;
{ function Last: Pointer; }

procedure TList_Last(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := P2V(TList(Args.Obj).Last);
end;
{ procedure Move(CurIndex, NewIndex: Integer); }

procedure TList_Move(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TList(Args.Obj).Move(Args.Values[0], Args.Values[1]);
end;
{ function Remove(Item: Pointer): Integer; }

procedure TList_Remove(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TList(Args.Obj).Remove(V2P(Args.Values[0]));
end;
{ procedure Pack; }

procedure TList_Pack(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TList(Args.Obj).Pack;
end;
{ procedure Sort(Compare: TListSortCompare); }

procedure TList_Sort(var Value: Variant; Args: TJvInterpreterArgs);
begin
//  TList(Args.Obj).Sort(Args.Values[0]);
  NotImplemented('TList.Sort');
end;
{ property Read Capacity: Integer }

procedure TList_Read_Capacity(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TList(Args.Obj).Capacity;
end;
{ property Write Capacity(Value: Integer) }

procedure TList_Write_Capacity(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TList(Args.Obj).Capacity := Value;
end;
{ property Read Count: Integer }

procedure TList_Read_Count(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TList(Args.Obj).Count;
end;
{ property Write Count(Value: Integer) }

procedure TList_Write_Count(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TList(Args.Obj).Count := Value;
end;
{ property Read Items[Integer]: Pointer }

procedure TList_Read_Items(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := P2V(TList(Args.Obj).Items[Args.Values[0]]);
end;
{ property Write Items[Integer]: Pointer }

procedure TList_Write_Items(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TList(Args.Obj).Items[Args.Values[0]] := V2P(Value);
end;
{ property Read List: PPointerList }

procedure TList_Read_List(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := P2V(TList(Args.Obj).List);
end;
{ TPersistent }
{ procedure Assign(Source: TPersistent); }

procedure TPersistent_Assign(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TPersistent(Args.Obj).Assign(V2O(Args.Values[0]) as TPersistent);
end;
{ function GetNamePath: string; }
{$IFDEF COMPILER3_UP}

procedure TPersistent_GetNamePath(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TPersistent(Args.Obj).GetNamePath;
end;
{$ENDIF COMPILER3_UP}
{ TCollectionItem }
{ constructor Create(Collection: TCollection) }

procedure TCollectionItem_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TCollectionItem.Create(V2O(Args.Values[0]) as TCollection));
end;
{ property Read Collection: TCollection }

procedure TCollectionItem_Read_Collection(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TCollectionItem(Args.Obj).Collection);
end;
{ property Write Collection(Value: TCollection) }

procedure TCollectionItem_Write_Collection(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TCollectionItem(Args.Obj).Collection := V2O(Value) as TCollection;
end;
{ property Read ID: Integer }
{$IFDEF COMPILER3_UP}

procedure TCollectionItem_Read_ID(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TCollectionItem(Args.Obj).ID;
end;
{$ENDIF COMPILER3_UP}
{ property Read Index: Integer }

procedure TCollectionItem_Read_Index(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TCollectionItem(Args.Obj).Index;
end;
{ property Write Index(Value: Integer) }

procedure TCollectionItem_Write_Index(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TCollectionItem(Args.Obj).Index := Value;
end;
{$IFDEF COMPILER3_UP}
{ property Read DisplayName: string }

procedure TCollectionItem_Read_DisplayName(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TCollectionItem(Args.Obj).DisplayName;
end;
{ property Write DisplayName(Value: string) }

procedure TCollectionItem_Write_DisplayName(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TCollectionItem(Args.Obj).DisplayName := Value;
end;
{$ENDIF COMPILER3_UP}
{ TCollection }
{ constructor Create(ItemClass: TCollectionItemClass) }

procedure TCollection_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TCollection.Create(TCollectionItemClass(V2O(Args.Values[0]))));
end;
{ function Add: TCollectionItem; }

procedure TCollection_Add(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TCollection(Args.Obj).Add);
end;
{ procedure Assign(Source: TPersistent); }

procedure TCollection_Assign(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCollection(Args.Obj).Assign(V2O(Args.Values[0]) as TPersistent);
end;
{ procedure BeginUpdate; }

procedure TCollection_BeginUpdate(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCollection(Args.Obj).BeginUpdate;
end;
{ procedure Clear; }

procedure TCollection_Clear(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCollection(Args.Obj).Clear;
end;
{ procedure EndUpdate; }

procedure TCollection_EndUpdate(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCollection(Args.Obj).EndUpdate;
end;
{ function FindItemID(ID: Integer): TCollectionItem; }
{$IFDEF COMPILER3_UP}

procedure TCollection_FindItemID(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TCollection(Args.Obj).FindItemID(Args.Values[0]));
end;
{$ENDIF COMPILER3_UP}
{ property Read Count: Integer }

procedure TCollection_Read_Count(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TCollection(Args.Obj).Count;
end;
{ property Read ItemClass: TCollectionItemClass }
{$IFDEF COMPILER3_UP}

procedure TCollection_Read_ItemClass(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TObject(TCollection(Args.Obj).ItemClass));
end;
{$ENDIF COMPILER3_UP}
{ property Read Items[Integer]: TCollectionItem }

procedure TCollection_Read_Items(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TCollection(Args.Obj).Items[Args.Values[0]]);
end;
{ property Write Items[Integer]: TCollectionItem }

procedure TCollection_Write_Items(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TCollection(Args.Obj).Items[Args.Values[0]] := V2O(Value) as TCollectionItem;
end;
{ TStrings }
{ function Add(const S: string): Integer; }

procedure TStrings_Add(var Value: Variant; Args: TJvInterpreterArgs);