rm_jvinterpreter_graphics.pas

这是一个功能强大

  Value := O2V(TPicture(Args.Obj).Bitmap);
end;

{ property Write Bitmap(Value: TBitmap) }

procedure TPicture_Write_Bitmap(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TPicture(Args.Obj).Bitmap := V2O(Value) as TBitmap;
end;

{ property Read Graphic: TGraphic }

procedure TPicture_Read_Graphic(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TPicture(Args.Obj).Graphic);
end;

{ property Write Graphic(Value: TGraphic) }

procedure TPicture_Write_Graphic(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TPicture(Args.Obj).Graphic := V2O(Value) as TGraphic;
end;

{$IFDEF VCL}

{ property Read PictureAdapter: IChangeNotifier }

procedure TPicture_Read_PictureAdapter(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TPicture(Args.Obj).PictureAdapter;
end;

{ property Write PictureAdapter(Value: IChangeNotifier) }

procedure TPicture_Write_PictureAdapter(const Value: Variant; Args: TJvInterpreterArgs);
begin
//  TPicture(Args.Obj).PictureAdapter := Value;
  NotImplemented('TPicture.PictureAdapter');
end;

{$ENDIF VCL}


{ property Read Height: Integer }

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

{ property Read Icon: TIcon }

procedure TPicture_Read_Icon(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TPicture(Args.Obj).Icon);
end;

{ property Write Icon(Value: TIcon) }

procedure TPicture_Write_Icon(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TPicture(Args.Obj).Icon := V2O(Value) as TIcon;
end;

{$IFDEF VCL}

{ property Read Metafile: TMetafile }

procedure TPicture_Read_Metafile(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TPicture(Args.Obj).Metafile);
end;

{ property Write Metafile(Value: TMetafile) }

procedure TPicture_Write_Metafile(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TPicture(Args.Obj).Metafile := V2O(Value) as TMetafile;
end;

{$ENDIF VCL}

{ property Read Width: Integer }

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

{$IFDEF VCL}

{ TMetafile }

{ constructor Create }

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

{ procedure Clear; }

procedure TMetafile_Clear(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TMetafile(Args.Obj).Clear;
end;

{ procedure LoadFromStream(Stream: TStream); }

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

{ procedure SaveToFile(const Filename: String); }

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

{ procedure SaveToStream(Stream: TStream); }

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

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

procedure TMetafile_LoadFromClipboardFormat(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TMetafile(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 TMetafile_SaveToClipboardFormat(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TMetafile(Args.Obj).SaveToClipboardFormat(Word(TVarData(Args.Values[0]).VSmallInt),
    THandle(TVarData(Args.Values[1]).VInteger), HPALETTE(TVarData(Args.Values[2]).VInteger));
end;

{ procedure Assign(Source: TPersistent); }

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

{ function ReleaseHandle: HENHMETAFILE; }

procedure TMetafile_ReleaseHandle(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := Integer(TMetafile(Args.Obj).ReleaseHandle);
end;


{ property Read CreatedBy: String }

procedure TMetafile_Read_CreatedBy(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMetafile(Args.Obj).CreatedBy;
end;

{ property Read Description: String }

procedure TMetafile_Read_Description(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMetafile(Args.Obj).Description;
end;

{ property Read Enhanced: Boolean }

procedure TMetafile_Read_Enhanced(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMetafile(Args.Obj).Enhanced;
end;

{ property Write Enhanced(Value: Boolean) }

procedure TMetafile_Write_Enhanced(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TMetafile(Args.Obj).Enhanced := Value;
end;

{ property Read Handle: HENHMETAFILE }

procedure TMetafile_Read_Handle(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := Integer(TMetafile(Args.Obj).Handle);
end;

{ property Write Handle(Value: HENHMETAFILE) }

procedure TMetafile_Write_Handle(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TMetafile(Args.Obj).Handle := Value;
end;

{ property Read MMWidth: Integer }

procedure TMetafile_Read_MMWidth(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMetafile(Args.Obj).MMWidth;
end;

{ property Write MMWidth(Value: Integer) }

procedure TMetafile_Write_MMWidth(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TMetafile(Args.Obj).MMWidth := Value;
end;

{ property Read MMHeight: Integer }

procedure TMetafile_Read_MMHeight(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMetafile(Args.Obj).MMHeight;
end;

{ property Write MMHeight(Value: Integer) }

procedure TMetafile_Write_MMHeight(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TMetafile(Args.Obj).MMHeight := Value;
end;

{ property Read Inch: Word }

procedure TMetafile_Read_Inch(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TMetafile(Args.Obj).Inch;
end;

{ property Write Inch(Value: Word) }

procedure TMetafile_Write_Inch(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TMetafile(Args.Obj).Inch := Value;
end;

{$ENDIF VCL}

{ TBitmap }

{ constructor Create }

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

{ procedure Assign(Source: TPersistent); }

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

{ procedure Dormant; }

procedure TBitmap_Dormant(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TBitmap(Args.Obj).Dormant;
end;

{ procedure FreeImage; }

procedure TBitmap_FreeImage(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TBitmap(Args.Obj).FreeImage;
end;

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

{$IFDEF VCL}
procedure TBitmap_LoadFromClipboardFormat(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TBitmap(Args.Obj).LoadFromClipboardFormat(Args.Values[0], Args.Values[1], Args.Values[2]);
end;
{$ENDIF VCL}

{ procedure LoadFromStream(Stream: TStream); }

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

{ procedure LoadFromResourceName(Instance: THandle; const ResName: String); }

procedure TBitmap_LoadFromResourceName(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TBitmap(Args.Obj).Assign(nil); // fixes GDI resource leak
  TBitmap(Args.Obj).LoadFromResourceName(Args.Values[0], Args.Values[1]);
end;

{ procedure LoadFromResourceID(Instance: THandle; ResID: Integer); }

procedure TBitmap_LoadFromResourceID(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TBitmap(Args.Obj).Assign(nil); // fixes GDI resource leak
  TBitmap(Args.Obj).LoadFromResourceID(Args.Values[0], Args.Values[1]);
end;

{ procedure Mask(TransparentColor: TColor); }

procedure TBitmap_Mask(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TBitmap(Args.Obj).Mask(Args.Values[0]);
end;


{$IFDEF VCL}

{ function ReleaseHandle: HBITMAP; }

procedure TBitmap_ReleaseHandle(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := Integer(TBitmap(Args.Obj).ReleaseHandle);
end;

{ function ReleaseMaskHandle: HBITMAP; }

procedure TBitmap_ReleaseMaskHandle(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := Integer(TBitmap(Args.Obj).ReleaseMaskHandle);
end;


{ function ReleasePalette: HPALETTE; }

procedure TBitmap_ReleasePalette(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := Integer(TBitmap(Args.Obj).ReleasePalette);
end;

{ procedure SaveToClipboardFormat(var Format: Word; var Data: THandle; var APalette: HPALETTE); }

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

{$ENDIF VCL}

{ procedure SaveToStream(Stream: TStream); }

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

{ property Read Canvas: TCanvas }

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

{ property Read Handle: HBITMAP }

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

{ property Write Handle(Value: HBITMAP) }

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

{$IFDEF VCL}

{ property Read HandleType: TBitmapHandleType }

procedure TBitmap_Read_HandleType(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBitmap(Args.Obj).HandleType;
end;

{ property Write HandleType(Value: TBitmapHandleType) }

procedure TBitmap_Write_HandleType(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBitmap(Args.Obj).HandleType := Value;
end;



{ property Read IgnorePalette: Boolean }

procedure TBitmap_Read_IgnorePalette(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBitmap(Args.Obj).IgnorePalette;
end;

{ property Write IgnorePalette(Value: Boolean) }

procedure TBitmap_Write_IgnorePalette(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBitmap(Args.Obj).IgnorePalette := Value;
end;

{ property Read MaskHandle: HBITMAP }


procedure TBitmap_Read_MaskHandle(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := Integer(TBitmap(Args.Obj).MaskHandle);
end;


{$ENDIF VCL}

{ property Read Monochrome: Boolean }

procedure TBitmap_Read_Monochrome(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBitmap(Args.Obj).Monochrome;
end;

{ property Write Monochrome(Value: Boolean) }

procedure TBitmap_Write_Monochrome(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBitmap(Args.Obj).Monochrome := Value;
end;



{ property Read PixelFormat: TPixelFormat }

procedure TBitmap_Read_PixelFormat(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBitmap(Args.Obj).PixelFormat;
end;

{ property Write PixelFormat(Value: TPixelFormat) }

procedure TBitmap_Write_PixelFormat(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBitmap(Args.Obj).PixelFormat := Value;
end;

{ property Read ScanLine[Integer]: Pointer }