rm_jvinterpreter_classes.pas

这是一个功能强大

{-----------------------------------------------------------------------------
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: rm_JvInterpreter_Classes.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 rm_JvInterpreter calls to delphi calls

Known Issues:
-----------------------------------------------------------------------------}
// $Id: rm_JvInterpreter_Classes.pas 9258 2005-02-17 10:21:22Z marquardt $

unit rm_JvInterpreter_Classes;

{$I rm_jvcl.inc}

interface

uses
  {$IFDEF UNITVERSIONING}
  rm_JclUnitVersioning,
  {$ENDIF UNITVERSIONING}
  rm_JvInterpreter;

procedure RegisterJvInterpreterAdapter(JvInterpreterAdapter: TJvInterpreterAdapter);

{$IFDEF UNITVERSIONING}
const
  UnitVersioning: TUnitVersionInfo = (
    RCSfile: '$RCSfile$';
    Revision: '$Revision: 9258 $';
    Date: '$Date: 2005-02-17 02:21:22 -0800 (Thu, 17 Feb 2005) $';
    LogPath: 'JVCL\run'
  );
{$ENDIF UNITVERSIONING}

implementation

uses
  {$IFDEF HAS_UNIT_VARIANTS}
  Variants,
  {$ENDIF HAS_UNIT_VARIANTS}
  Classes;

{ 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; }

procedure TPersistent_GetNamePath(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TPersistent(Args.Obj).GetNamePath;
end;

{ 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 }

procedure TCollectionItem_Read_ID(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TCollectionItem(Args.Obj).ID;
end;

{ 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;

{ 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;

{ 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; }

procedure TCollection_FindItemID(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TCollection(Args.Obj).FindItemID(Args.Values[0]));
end;

{ property Read Count: Integer }

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