rm_jvinterpreter_graphics.pas

这是一个功能强大

{$IFDEF VCL}

{ procedure FloodFill(X, Y: Integer; Color: TColor; FillStyle: TFillStyle); }

procedure TCanvas_FloodFill(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCanvas(Args.Obj).FloodFill(Args.Values[0], Args.Values[1], Args.Values[2], Args.Values[3]);
end;

{ procedure FrameRect(const Rect: TRect); }

procedure TCanvas_FrameRect(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCanvas(Args.Obj).FrameRect(Var2Rect(Args.Values[0]));
end;

{$ENDIF VCL}

{ procedure LineTo(X, Y: Integer); }

procedure TCanvas_LineTo(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCanvas(Args.Obj).LineTo(Args.Values[0], Args.Values[1]);
end;

{ procedure Lock; }

procedure TCanvas_Lock(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCanvas(Args.Obj).Lock;
end;


{ procedure MoveTo(X, Y: Integer); }

procedure TCanvas_MoveTo(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCanvas(Args.Obj).MoveTo(Args.Values[0], Args.Values[1]);
end;

{ procedure Pie(X1, Y1, X2, Y2, X3, Y3, X4, Y4: Integer); }

procedure TCanvas_Pie(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCanvas(Args.Obj).Pie(Args.Values[0], Args.Values[1], Args.Values[2], Args.Values[3], Args.Values[4], Args.Values[5],
    Args.Values[6], Args.Values[7]);
end;

{ procedure Polygon(const Points: array of TPoint); }

procedure TCanvas_Polygon(var Value: Variant; Args: TJvInterpreterArgs);
begin
//  TCanvas(Args.Obj).Polygon(Args.Values[0]);
  NotImplemented('TCanvas.Polygon');
end;

{ procedure Polyline(const Points: array of TPoint); }

procedure TCanvas_Polyline(var Value: Variant; Args: TJvInterpreterArgs);
begin
//  TCanvas(Args.Obj).Polyline(Args.Values[0]);
  NotImplemented('TCanvas.Polyline');
end;

{ procedure Rectangle(X1, Y1, X2, Y2: Integer); }

procedure TCanvas_Rectangle(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCanvas(Args.Obj).Rectangle(Args.Values[0], Args.Values[1], Args.Values[2], Args.Values[3]);
end;

{ procedure Refresh; }

procedure TCanvas_Refresh(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCanvas(Args.Obj).Refresh;
end;

{ procedure RoundRect(X1, Y1, X2, Y2, X3, Y3: Integer); }

procedure TCanvas_RoundRect(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCanvas(Args.Obj).RoundRect(Args.Values[0], Args.Values[1], Args.Values[2], Args.Values[3], Args.Values[4],
    Args.Values[5]);
end;

{ procedure StretchDraw(const Rect: TRect; Graphic: TGraphic); }

procedure TCanvas_StretchDraw(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCanvas(Args.Obj).StretchDraw(Var2Rect(Args.Values[0]), V2O(Args.Values[1]) as TGraphic);
end;

{ function TextExtent(const Text: string): TSize; }

procedure TCanvas_TextExtent(var Value: Variant; Args: TJvInterpreterArgs);
begin
//  Value := TCanvas(Args.Obj).TextExtent(Args.Values[0]);
  NotImplemented('TCanvas.TextExtent');
end;

{ function TextHeight(const Text: string): Integer; }

procedure TCanvas_TextHeight(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TCanvas(Args.Obj).TextHeight(Args.Values[0]);
end;

{ procedure TextOut(X, Y: Integer; const Text: string); }

procedure TCanvas_TextOut(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCanvas(Args.Obj).TextOut(Args.Values[0], Args.Values[1], Args.Values[2]);
end;

{ procedure TextRect(Rect: TRect; X, Y: Integer; const Text: string); }

procedure TCanvas_TextRect(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCanvas(Args.Obj).TextRect(Var2Rect(Args.Values[0]), Args.Values[1], Args.Values[2], Args.Values[3]);
end;

{ function TextWidth(const Text: string): Integer; }

procedure TCanvas_TextWidth(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TCanvas(Args.Obj).TextWidth(Args.Values[0]);
end;


{ function TryLock: Boolean; }

procedure TCanvas_TryLock(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TCanvas(Args.Obj).TryLock;
end;

{ procedure Unlock; }

procedure TCanvas_Unlock(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TCanvas(Args.Obj).Unlock;
end;



{ property Read ClipRect: TRect }

procedure TCanvas_Read_ClipRect(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := Rect2Var(TCanvas(Args.Obj).ClipRect);
end;

{ property Read Handle: HDC }

procedure TCanvas_Read_Handle(var Value: Variant; Args: TJvInterpreterArgs);
begin
  {$IFDEF VCL}
  Value := Integer(TCanvas(Args.Obj).Handle);
  {$ENDIF VCL}
  {$IFDEF VisualCLX}
  Value := P2V(TCanvas(Args.Obj).Handle);
  {$ENDIF VisualCLX}
end;

{ property Write Handle(Value: HDC) }

procedure TCanvas_Write_Handle(const Value: Variant; Args: TJvInterpreterArgs);
begin
  {$IFDEF VCL}
  TCanvas(Args.Obj).Handle := Value;
  {$ENDIF VCL}
  {$IFDEF VisualCLX}
  TCanvas(Args.Obj).Handle := V2P(Value);
  {$ENDIF VisualCLX}
end;

{ property Read LockCount: Integer }

procedure TCanvas_Read_LockCount(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TCanvas(Args.Obj).LockCount;
end;


{ property Read PenPos: TPoint }

procedure TCanvas_Read_PenPos(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := Point2Var(TCanvas(Args.Obj).PenPos);
end;

{ property Write PenPos(Value: TPoint) }

procedure TCanvas_Write_PenPos(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TCanvas(Args.Obj).PenPos := Var2Point(Value);
end;

{ property Read Brush: TBrush }

procedure TCanvas_Read_Brush(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TCanvas(Args.Obj).Brush);
end;

{ property Write Brush(Value: TBrush) }

procedure TCanvas_Write_Brush(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TCanvas(Args.Obj).Brush := V2O(Value) as TBrush;
end;

{ property Read CopyMode: TCopyMode }

procedure TCanvas_Read_CopyMode(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TCanvas(Args.Obj).CopyMode;
end;

{ property Write CopyMode(Value: TCopyMode) }

procedure TCanvas_Write_CopyMode(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TCanvas(Args.Obj).CopyMode := Value;
end;

{ property Read Font: TFont }

procedure TCanvas_Read_Font(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TCanvas(Args.Obj).Font);
end;

{ property Write Font(Value: TFont) }

procedure TCanvas_Write_Font(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TCanvas(Args.Obj).Font := V2O(Value) as TFont;
end;

{ property Read Pen: TPen }

procedure TCanvas_Read_Pen(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TCanvas(Args.Obj).Pen);
end;

{ property Write Pen(Value: TPen) }

procedure TCanvas_Write_Pen(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TCanvas(Args.Obj).Pen := V2O(Value) as TPen;
end;

{ TGraphic }

{ procedure LoadFromFile(const Filename: string); }

procedure TGraphic_LoadFromFile(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TGraphic(Args.Obj).LoadFromFile(Args.Values[0]);
end;

{ procedure SaveToFile(const Filename: string); }

procedure TGraphic_SaveToFile(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TGraphic(Args.Obj).SaveToFile(Args.Values[0]);
end;

{ procedure LoadFromStream(Stream: TStream); }

procedure TGraphic_LoadFromStream(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TGraphic(Args.Obj).LoadFromStream(V2O(Args.Values[0]) as TStream);
end;

{ procedure SaveToStream(Stream: TStream); }

procedure TGraphic_SaveToStream(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TGraphic(Args.Obj).SaveToStream(V2O(Args.Values[0]) as TStream);
end;

{$IFDEF VCL}

{ procedure LoadFromClipboardFormat(AFormat: Word; AData: THandle; APalette: HPALETTE); }

procedure TGraphic_LoadFromClipboardFormat(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TGraphic(Args.Obj).LoadFromClipboardFormat(Args.Values[0], Args.Values[1], Args.Values[2]);
end;

{ procedure SaveToClipboardFormat(var AFormat: Word; var AData: THandle; var APalette: HPALETTE); }

procedure TGraphic_SaveToClipboardFormat(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TGraphic(Args.Obj).SaveToClipboardFormat(Word(TVarData(Args.Values[0]).VSmallInt),
    THandle(TVarData(Args.Values[1]).VInteger), HPALETTE(TVarData(Args.Values[2]).VInteger));
end;

{$ENDIF VCL}

{ property Read Empty: Boolean }

procedure TGraphic_Read_Empty(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TGraphic(Args.Obj).Empty;
end;

{ property Read Height: Integer }

procedure TGraphic_Read_Height(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TGraphic(Args.Obj).Height;
end;

{ property Write Height(Value: Integer) }

procedure TGraphic_Write_Height(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TGraphic(Args.Obj).Height := Value;
end;

{ property Read Modified: Boolean }

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

{ property Write Modified(Value: Boolean) }

procedure TGraphic_Write_Modified(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TGraphic(Args.Obj).Modified := Value;
end;

{$IFDEF VCL}

{ property Read Palette: HPALETTE }

procedure TGraphic_Read_Palette(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := Integer(TGraphic(Args.Obj).Palette);
end;

{ property Write Palette(Value: HPALETTE) }

procedure TGraphic_Write_Palette(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TGraphic(Args.Obj).Palette := Value;
end;

{ property Read PaletteModified: Boolean }

procedure TGraphic_Read_PaletteModified(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TGraphic(Args.Obj).PaletteModified;
end;

{ property Write PaletteModified(Value: Boolean) }

procedure TGraphic_Write_PaletteModified(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TGraphic(Args.Obj).PaletteModified := Value;
end;

{$ENDIF VCL}

{ property Read Transparent: Boolean }

procedure TGraphic_Read_Transparent(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TGraphic(Args.Obj).Transparent;
end;

{ property Write Transparent(Value: Boolean) }

procedure TGraphic_Write_Transparent(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TGraphic(Args.Obj).Transparent := Value;
end;



{ property Read Width: Integer }

procedure TGraphic_Read_Width(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TGraphic(Args.Obj).Width;
end;

{ property Write Width(Value: Integer) }

procedure TGraphic_Write_Width(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TGraphic(Args.Obj).Width := Value;
end;

{ TPicture }

{ constructor Create }

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

{ procedure LoadFromFile(const Filename: string); }

procedure TPicture_LoadFromFile(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TPicture(Args.Obj).LoadFromFile(Args.Values[0]);
end;

{ procedure SaveToFile(const Filename: string); }

procedure TPicture_SaveToFile(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TPicture(Args.Obj).SaveToFile(Args.Values[0]);
end;

{$IFDEF VCL}

{ procedure LoadFromClipboardFormat(AFormat: Word; AData: THandle; APalette: HPALETTE); }

procedure TPicture_LoadFromClipboardFormat(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TPicture(Args.Obj).LoadFromClipboardFormat(Args.Values[0], Args.Values[1], Args.Values[2]);
end;

{ procedure SaveToClipboardFormat(var AFormat: Word; var AData: THandle; var APalette: HPALETTE); }

procedure TPicture_SaveToClipboardFormat(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TPicture(Args.Obj).SaveToClipboardFormat(Word(TVarData(Args.Values[0]).VSmallInt),
    THandle(TVarData(Args.Values[1]).VInteger), HPALETTE(TVarData(Args.Values[2]).VInteger));
end;

{ function SupportsClipboardFormat(AFormat: Word): Boolean; }

procedure TPicture_SupportsClipboardFormat(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TPicture(Args.Obj).SupportsClipboardFormat(Args.Values[0]);
end;

{$ENDIF VCL}

{ procedure Assign(Source: TPersistent); }

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

{ property Read Bitmap: TBitmap }

procedure TPicture_Read_Bitmap(var Value: Variant; Args: TJvInterpreterArgs);
begin