rm_jvinterpreter_forms.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_Forms.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_Forms.pas 10078 2005-10-28 08:37:23Z marquardt $

unit rm_JvInterpreter_Forms;

{$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: 10078 $';
    Date: '$Date: 2005-10-28 01:37:23 -0700 (Fri, 28 Oct 2005) $';
    LogPath: 'JVCL\run'
  );
{$ENDIF UNITVERSIONING}

implementation

uses
  Classes,
  {$IFDEF VCL}
  SysUtils, Graphics, Controls, Menus, Forms;
  {$ENDIF VCL}
  {$IFDEF VisualCLX}
  SysUtils, Variants, Qt, QGraphics, QControls, QMenus, QImgList, QForms,
  rm_JvInterpreter_Types;
  {$ENDIF VisualCLX}

{ TControlScrollBar }

{ procedure Assign(Source: TPersistent); }

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

{ property Read Kind: TScrollBarKind }

procedure TControlScrollBar_Read_Kind(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TControlScrollBar(Args.Obj).Kind;
end;

{ property Read ScrollPos: Integer }

procedure TControlScrollBar_Read_ScrollPos(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TControlScrollBar(Args.Obj).ScrollPos;
end;

{ property Read Margin: Word }

procedure TControlScrollBar_Read_Margin(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TControlScrollBar(Args.Obj).Margin;
end;

{ property Write Margin(Value: Word) }

procedure TControlScrollBar_Write_Margin(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TControlScrollBar(Args.Obj).Margin := Value;
end;

{ property Read Increment: TScrollBarInc }

procedure TControlScrollBar_Read_Increment(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TControlScrollBar(Args.Obj).Increment;
end;

{ property Write Increment(Value: TScrollBarInc) }

procedure TControlScrollBar_Write_Increment(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TControlScrollBar(Args.Obj).Increment := Value;
end;

{ property Read Range: Integer }

procedure TControlScrollBar_Read_Range(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TControlScrollBar(Args.Obj).Range;
end;

{ property Write Range(Value: Integer) }

procedure TControlScrollBar_Write_Range(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TControlScrollBar(Args.Obj).Range := Value;
end;

{ property Read Position: Integer }

procedure TControlScrollBar_Read_Position(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TControlScrollBar(Args.Obj).Position;
end;

{ property Write Position(Value: Integer) }

procedure TControlScrollBar_Write_Position(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TControlScrollBar(Args.Obj).Position := Value;
end;

{ property Read Tracking: Boolean }

procedure TControlScrollBar_Read_Tracking(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TControlScrollBar(Args.Obj).Tracking;
end;

{ property Write Tracking(Value: Boolean) }

procedure TControlScrollBar_Write_Tracking(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TControlScrollBar(Args.Obj).Tracking := Value;
end;

{ property Read Visible: Boolean }

procedure TControlScrollBar_Read_Visible(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TControlScrollBar(Args.Obj).Visible;
end;

{ property Write Visible(Value: Boolean) }

procedure TControlScrollBar_Write_Visible(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TControlScrollBar(Args.Obj).Visible := Value;
end;

{ TScrollingWinControl }

{ constructor Create(AOwner: TComponent) }

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

{ procedure DisableAutoRange; }

procedure TScrollingWinControl_DisableAutoRange(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TScrollingWinControl(Args.Obj).DisableAutoRange;
end;

{ procedure EnableAutoRange; }

procedure TScrollingWinControl_EnableAutoRange(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TScrollingWinControl(Args.Obj).EnableAutoRange;
end;

{ procedure ScrollInView(AControl: TControl); }

procedure TScrollingWinControl_ScrollInView(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TScrollingWinControl(Args.Obj).ScrollInView(V2O(Args.Values[0]) as TControl);
end;

{ property Read HorzScrollBar: TControlScrollBar }

procedure TScrollingWinControl_Read_HorzScrollBar(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TScrollingWinControl(Args.Obj).HorzScrollBar);
end;

{ property Write HorzScrollBar(Value: TControlScrollBar) }

procedure TScrollingWinControl_Write_HorzScrollBar(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TScrollingWinControl(Args.Obj).HorzScrollBar := V2O(Value) as TControlScrollBar;
end;

{ property Read VertScrollBar: TControlScrollBar }

procedure TScrollingWinControl_Read_VertScrollBar(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TScrollingWinControl(Args.Obj).VertScrollBar);
end;

{ property Write VertScrollBar(Value: TControlScrollBar) }

procedure TScrollingWinControl_Write_VertScrollBar(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TScrollingWinControl(Args.Obj).VertScrollBar := V2O(Value) as TControlScrollBar;
end;

{ TScrollBox }

{ constructor Create(AOwner: TComponent) }

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

{ property Read BorderStyle: TBorderStyle }

procedure TScrollBox_Read_BorderStyle(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TScrollBox(Args.Obj).BorderStyle;
end;

{ property Write BorderStyle(Value: TBorderStyle) }

procedure TScrollBox_Write_BorderStyle(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TScrollBox(Args.Obj).BorderStyle := Value;
end;

{ function CloseQuery: Boolean; }

procedure TCustomForm_CloseQuery(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TCustomForm(Args.Obj).CloseQuery;
end;

{ procedure Close; }

procedure TCustomForm_Close(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCustomForm(Args.Obj).Close;
end;

{ procedure DefocusControl(Control: TWinControl; Removing: Boolean); }

procedure TCustomForm_DefocusControl(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCustomForm(Args.Obj).DefocusControl(V2O(Args.Values[0]) as TWinControl, Args.Values[1]);
end;

{ procedure FocusControl(Control: TWinControl); }

procedure TCustomForm_FocusControl(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCustomForm(Args.Obj).FocusControl(V2O(Args.Values[0]) as TWinControl);
end;

{ function GetFormImage: TBitmap; }

{$IFDEF VCL}
procedure TCustomForm_GetFormImage(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TCustomForm(Args.Obj).GetFormImage);
end;
{$ENDIF VCL}

{ procedure Hide; }

procedure TCustomForm_Hide(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCustomForm(Args.Obj).Hide;
end;

{ procedure Print; }

{$IFDEF VCL}
procedure TCustomForm_Print(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCustomForm(Args.Obj).Print;
end;
{$ENDIF VCL}

{ procedure Release; }

procedure TCustomForm_Release(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCustomForm(Args.Obj).Release;
end;

{ procedure SendCancelMode(Sender: TControl); }

{$IFDEF VCL}
procedure TCustomForm_SendCancelMode(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCustomForm(Args.Obj).SendCancelMode(V2O(Args.Values[0]) as TControl);
end;
{$ENDIF VCL}

{ procedure SetFocus; }

procedure TCustomForm_SetFocus(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCustomForm(Args.Obj).SetFocus;
end;

{ function SetFocusedControl(Control: TWinControl): Boolean; }

procedure TCustomForm_SetFocusedControl(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TCustomForm(Args.Obj).SetFocusedControl(V2O(Args.Values[0]) as TWinControl);
end;

{ procedure Show; }

procedure TCustomForm_Show(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCustomForm(Args.Obj).Show;
end;

{ function ShowModal: Integer; }

procedure TCustomForm_ShowModal(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TCustomForm(Args.Obj).ShowModal;
end;

{ property Read Active: Boolean }

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

{ property Read ActiveControl: TWinControl }

procedure TCustomForm_Read_ActiveControl(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TCustomForm(Args.Obj).ActiveControl);
end;

{ property Write ActiveControl(Value: TWinControl) }

procedure TCustomForm_Write_ActiveControl(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TCustomForm(Args.Obj).ActiveControl := V2O(Value) as TWinControl;
end;

{$IFDEF VCL}

{ property Read ActiveOleControl: TWinControl }

procedure TCustomForm_Read_ActiveOleControl(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TCustomForm(Args.Obj).ActiveOleControl);
end;

{ property Write ActiveOleControl(Value: TWinControl) }

procedure TCustomForm_Write_ActiveOleControl(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TCustomForm(Args.Obj).ActiveOleControl := V2O(Value) as TWinControl;
end;

{$ENDIF VCL}

{ property Read Canvas: TCanvas }

procedure TCustomForm_Read_Canvas(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TCustomForm(Args.Obj).Canvas);
end;