Class TCustomUniversalBitmap

Description

Hierarchy

Fields

Methods

Properties

Unit

BGRABitmapTypes

Declaration

type TCustomUniversalBitmap = class(TFPCustomImage, IBGRAScanner)

Description

Base class for the universal bitmap (of any colorspace)

Hierarchy

TFPCustomImage
TCustomUniversalBitmap

Overview

Fields

	`Caption: string;`
	`FAntialiasingDrawMode: TDrawMode;`
	`FClipRect: TRect;`
	`FColorspace: TColorspaceAny;`
	`FConvertFromBGRA: TBridgedConversion;`
	`FConvertFromExpanded: TBridgedConversion;`
	`FConvertFromFPColor: TBridgedConversion;`
	`FConvertToBGRA: TBridgedConversion;`
	`FConvertToExpanded: TBridgedConversion;`
	`FConvertToFPColor: TBridgedConversion;`
	`FDataByte: PByte;`
	`FHeight: integer;`
	`FillMode: TFillMode;`
	`FLineOrder: TRawImageLineOrder;`
	`FNbPixels: integer;`
	`FPenStroker: TBGRACustomPenStroker;`
	`FPixelSize: integer;`
	`FRefCount: integer;`
	`FReferenceWhite: PXYZReferenceWhite;`
	`FResolutionUnit: TResolutionUnit;`
	`FResolutionX: Single;`
	`FResolutionY: Single;`
	`FRowSize: PtrInt;`
	`FScanCurX: integer;`
	`FScanCurY: integer;`
	`FScanHeight: integer;`
	`FScanPtr: PByte;`
	`FScanWidth: integer;`
	`FWidth: integer;`
	`ScanOffset: TPoint;`

Methods

	`constructor Create; overload;`
	`constructor Create(AWidth, AHeight: integer); overload; override;`
	`constructor Create(AColorspace: TColorspaceAny; ALineOrder: TRawImageLineOrder); overload;`
	`constructor Create(AColorspace: TColorspaceAny; AWidth, AHeight: integer; ALineOrder: TRawImageLineOrder); overload;`
	`destructor Destroy; override;`
	`function CheckClippedRectBounds(var x,y,x2,y2: integer): boolean;`
	`function Duplicate(ACopyProperties: boolean=false): TCustomUniversalBitmap; virtual;`
	`function FilterBlurMotion(const ABounds: TRect; distance: single; angle: single; oriented: boolean; ACopyProperties: Boolean=False): TCustomUniversalBitmap; overload; virtual;`
	`function FilterBlurMotion(distance: single; angle: single; oriented: boolean; ACopyProperties: Boolean=False): TCustomUniversalBitmap; overload; virtual;`
	`function FilterBlurRadial(radius: single; blurType: TRadialBlurType; ACopyProperties: Boolean=False): TCustomUniversalBitmap; overload; virtual;`
	`function FilterBlurRadial(const ABounds: TRect; radius: single; blurType: TRadialBlurType; ACopyProperties: Boolean=False): TCustomUniversalBitmap; overload; virtual;`
	`function FilterBlurRadial(const ABounds: TRect; radiusX, radiusY: single; blurType: TRadialBlurType; ACopyProperties: Boolean=False): TCustomUniversalBitmap; overload; virtual;`
	`function FilterBlurRadial(radiusX, radiusY: single; blurType: TRadialBlurType; ACopyProperties: Boolean=False): TCustomUniversalBitmap; overload; virtual;`
	`function FilterCustomBlur(const ABounds: TRect; mask: TCustomUniversalBitmap; ACopyProperties: Boolean=False): TCustomUniversalBitmap; overload; virtual;`
	`function FilterCustomBlur(mask: TCustomUniversalBitmap; ACopyProperties: Boolean=False): TCustomUniversalBitmap; overload; virtual;`
	`function GetImageBounds: TRect; overload; virtual;`
	`function GetImageBounds(Channels: TChannels; ANothingValue: Byte = 0): TRect; overload;`
	`function GetImageBounds(Channel: TChannel; ANothingValue: Byte = 0): TRect; overload;`
	`function GetImageBoundsWithin(const ARect: TRect; Channels: TChannels; ANothingValue: Byte = 0): TRect; overload; virtual;`
	`function GetImageBoundsWithin(const ARect: TRect; Channel: TChannel = cAlpha; ANothingValue: Byte = 0): TRect; overload; virtual;`
	`function GetPart(const ARect: TRect; ACopyProperties: Boolean=False): TCustomUniversalBitmap; virtual;`
	`function GetPixelAddress(x,y: integer): PByte; virtual;`
	`function GetScanCustomColorspace: TColorspaceAny; virtual;`
	`function GetUnique: TCustomUniversalBitmap; virtual;`
	`function IntersectClip(const ARect: TRect): TRect;`
	`function IsScanPutPixelsDefined: boolean; virtual;`
	`function NewBitmap: TCustomUniversalBitmap; overload; virtual;`
	`function NewBitmap(AWidth, AHeight: integer): TCustomUniversalBitmap; overload; virtual;`
	`function NewBitmap(AWidth, AHeight: integer; AColor: Pointer): TCustomUniversalBitmap; overload; virtual;`
	`function NewReference: TCustomUniversalBitmap; virtual;`
	`function PtInClipRect(x, y: int32or64): boolean; inline;`
	`function RotateCCW(ACopyProperties: Boolean=False): TCustomUniversalBitmap; virtual;`
	`function RotateCW(ACopyProperties: Boolean=False): TCustomUniversalBitmap; virtual;`
	`function RotateUD(ACopyProperties: Boolean=False): TCustomUniversalBitmap; virtual;`
	`function ScanAt(X,Y: Single): TBGRAPixel; virtual;`
	`function ScanAtExpanded(X, Y: Single): TExpandedPixel; virtual;`
	`function ScanAtInteger(X,Y: integer): TBGRAPixel; virtual;`
	`function ScanAtIntegerExpanded(X, Y: integer): TExpandedPixel; virtual;`
	`function ScanAtIntegerMask(X,Y: integer): TByteMask; virtual;`
	`function ScanAtMask(X,Y: Single): TByteMask; virtual;`
	`function ScanNextExpandedPixel: TExpandedPixel; virtual;`
	`function ScanNextPixel: TBGRAPixel; virtual;`
	`function CheckEmpty: boolean; virtual;`
	`function CheckHorizLineBounds(var x:int32or64; y: int32or64; var x2: int32or64): boolean; inline;`
	`function CheckIsZero: boolean; virtual;`
	`function CheckVertLineBounds(x: int32or64; var y, y2: int32or64): boolean; inline;`
	`class function DefaultColorspace: TColorspaceAny; virtual;`
	`function GetArrow: TBGRACustomArrow; virtual;`
	`function GetClipRect: TRect; virtual;`
	`function GetDataBytePtr: PByte; virtual;`
	`function GetHasSemiTransparentPixels: boolean; virtual;`
	`function GetHasTransparentPixels: boolean; virtual;`
	`function GetHeight: integer; virtual;`
	`function GetInternalColor(x, y: integer): TFPColor; override;`
	`function GetInternalPen: TBGRACustomPenStroker; virtual;`
	`function GetInternalPixel(x, y: integer): integer; override;`
	`function GetLinearAntialiasing: boolean; virtual;`
	`function GetLineCap: TPenEndCap; virtual;`
	`function GetLineOrder: TRawImageLineOrder; virtual;`
	`function GetNbPixels: integer; virtual;`
	`function GetPenStroker: TBGRACustomPenStroker; virtual;`
	`function GetRefCount: integer; virtual;`
	`function GetResolutionHeight: Single; virtual;`
	`function GetResolutionWidth: Single; virtual;`
	`function GetScanlineAt(X, Y: integer): PBGRAPixel; virtual;`
	`function GetScanLineByte(y: integer): PByte; virtual;`
	`function GetTextureGL: IUnknown; virtual;`
	`function GetWidth: integer; virtual;`
	`function InternalDuplicate(ACopyProperties: boolean=false): TCustomUniversalBitmap; virtual;`
	`function InternalNew: TCustomUniversalBitmap; virtual;`
	`function ProvidesScanline(ARect: TRect): boolean; virtual;`
	`function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;`
	`function _AddRef: Integer; stdcall;`
	`function _Release: Integer; stdcall;`
	`class procedure AlphaBrush(out ABrush: TUniversalBrush; AAlpha: Word); virtual;`
	`procedure AlphaFill(alpha: byte); virtual;`
	`procedure AlphaFillEllipseInRect(ARect: TRect; alpha: byte); virtual;`
	`procedure AlphaFillPathAliased(APath: IBGRAPath; alpha: byte; APixelCenteredCoordinates: boolean = true); overload;`
	`procedure AlphaFillPathAliased(APath: IBGRAPath; const AMatrix: TAffineMatrix; alpha: byte; APixelCenteredCoordinates: boolean = true); overload;`
	`procedure AlphaFillPoly(const APoints: array of TPointF; alpha: byte; APixelCenteredCoordinates: boolean = true); virtual;`
	`procedure AlphaFillRect(const ARect: TRect; alpha: byte); virtual;`
	`procedure AlphaFillRect(ALeft, ATop, ARight, ABottom: integer; alpha: byte); virtual;`
	`procedure AlphaFillRoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; alpha: byte); virtual;`
	`procedure AlphaFillShape(AShape: TBGRACustomFillInfo; alpha: byte); virtual;`
	`procedure AlphaHorizLine(x,y,x2: int32or64; alpha: byte); virtual;`
	`procedure AlphaLine(x1, y1, x2, y2: integer; alpha: byte; DrawLastPixel: boolean); virtual;`
	`procedure AlphaLineAntialias(x1, y1, x2, y2: integer; alpha: byte; DrawLastPixel: boolean); virtual;`
	`procedure AlphaPixel(x, y: int32or64; alpha: byte); virtual;`
	`procedure AlphaPixelF(x, y: single; alpha: byte); virtual;`
	`procedure AlphaPolygonOutline(const points: array of TPoint; alpha: byte);`
	`procedure AlphaPolygonOutlineAntialias(const points: array of TPoint; alpha: byte);`
	`procedure AlphaPolyLine(const points: array of TPoint; alpha: byte; ADrawLastPixel: boolean);`
	`procedure AlphaPolyLineAntialias(const points: array of TPoint; alpha: byte; ADrawLastPixel: boolean);`
	`procedure AlphaVertLine(x, y, y2: int32or64; alpha: byte); virtual;`
	`procedure ApplyGlobalOpacity(ARect: TRect; alpha: byte); overload; virtual;`
	`procedure ApplyGlobalOpacity(alpha: byte); overload; virtual;`
	`procedure ApplyMask(mask: TCustomUniversalBitmap; ARect: TRect; AMaskRectTopLeft: TPoint; AAlpha: Word = 65535); overload; virtual;`
	`procedure ApplyMask(mask: TCustomUniversalBitmap; AAlpha: Word = 65535); overload;`
	`procedure ApplyMask(mask: TCustomUniversalBitmap; ARect: TRect; AAlpha: Word = 65535); overload;`
	`procedure Assign(Source: TPersistent; ACopyProperties: Boolean); virtual; overload;`
	`procedure Assign(Source: TPersistent); override;`
	`procedure ClearTransparentPixels; virtual;`
	`procedure CopyPropertiesTo(ABitmap: TCustomUniversalBitmap); virtual;`
	`procedure Deserialize(AStream: TStream); virtual;`
	`procedure DrawCheckers(ARect: TRect; const ABrushEven,ABrushOdd: TUniversalBrush; AGridWidth: integer = 8; AGridHeight: integer = 8); overload; virtual;`
	`procedure DrawLine(x1, y1, x2, y2: integer; const ABrush: TUniversalBrush; ADrawLastPixel: boolean; AAlpha: Word = 65535); overload; virtual;`
	`procedure DrawLine(x1, y1, x2, y2: integer; ATexture: IBGRAScanner; AMode: TDrawMode; ADrawLastPixel: boolean; AAlpha: Word = 65535); overload; virtual;`
	`procedure DrawLineAntialias(x1, y1, x2, y2: integer; const ABrush1, ABrush2: TUniversalBrush; ADashLen: integer; ADrawLastPixel: boolean; AAlpha: Word = 65535); overload; virtual;`
	`procedure DrawLineAntialias(x1, y1, x2, y2: integer; ATexture: IBGRAScanner; AMode: TDrawMode; ADrawLastPixel: boolean; AAlpha: Word = 65535); overload; virtual;`
	`procedure DrawLineAntialias(x1, y1, x2, y2: integer; const ABrush: TUniversalBrush; ADrawLastPixel: boolean; AAlpha: Word = 65535); overload; virtual;`
	`procedure DrawLineAntialias(x1, y1, x2, y2: integer; const ABrush1, ABrush2: TUniversalBrush; ADashLen: integer; var ADashPos: integer; ADrawLastPixel: boolean; AAlpha: Word = 65535); overload; virtual;`
	`procedure DrawLineAntialias(x1, y1, x2, y2: single; ATexture: IBGRAScanner; APenWidth: single); overload; virtual;`
	`procedure DrawLineAntialias(x1, y1, x2, y2: single; const ABrush: TUniversalBrush; APenWidth: single); overload; virtual;`
	`procedure DrawLineAntialias(x1, y1, x2, y2: single; ATexture: IBGRAScanner; APenWidth: single; AClosedCap: boolean); overload; virtual;`
	`procedure DrawLineAntialias(x1, y1, x2, y2: single; const ABrush: TUniversalBrush; APenWidth: single; AClosedCap: boolean); overload; virtual;`
	`procedure DrawPath(APath: IBGRAPath; const AMatrix: TAffineMatrix; const ABrush: TUniversalBrush; AWidth: single; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure DrawPath(APath: IBGRAPath; ATexture: IBGRAScanner; AWidth: single; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure DrawPath(APath: IBGRAPath; const ABrush: TUniversalBrush; AWidth: single; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure DrawPath(APath: IBGRAPath; const AMatrix: TAffineMatrix; ATexture: IBGRAScanner; AWidth: single; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure DrawPathAliased(APath: IBGRAPath; const ABrush: TUniversalBrush; APixelCenteredCoordinates: boolean = true; AAlpha: Word = 65535); overload;`
	`procedure DrawPathAliased(APath: IBGRAPath; const AMatrix: TAffineMatrix; const ABrush: TUniversalBrush; APixelCenteredCoordinates: boolean = true; AAlpha: Word = 65535); overload;`
	`procedure DrawPixel(x,y: Int32or64; const ABrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
	`procedure DrawPixel(x,y: Int32or64; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
	`procedure DrawPixelF(x,y: single; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
	`procedure DrawPixelF(x,y: single; const ABrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
	`procedure DrawPolygon(const points: array of TPoint; const ABrush: TUniversalBrush; AAlpha: Word = 65535);`
	`procedure DrawPolygonAntialias(const APoints: array of TPointF; const ABrush: TUniversalBrush; APenWidth: single); overload; virtual;`
	`procedure DrawPolygonAntialias(const points: array of TPoint; const ABrush: TUniversalBrush; AAlpha: Word = 65535); overload;`
	`procedure DrawPolygonAntialias(const points: array of TPoint; const ABrush1, ABrush2: TUniversalBrush; ADashLen: integer; AAlpha: Word = 65535); overload;`
	`procedure DrawPolygonAntialias(const APoints: array of TPointF; ATexture: IBGRAScanner; APenWidth: single); overload; virtual;`
	`procedure DrawPolyLine(const points: array of TPoint; const ABrush: TUniversalBrush; ADrawLastPixel: boolean; AAlpha: Word = 65535);`
	`procedure DrawPolyLineAntialias(const APoints: array of TPointF; const ABrush: TUniversalBrush; APenWidth: single); overload; virtual;`
	`procedure DrawPolyLineAntialias(const APoints: array of TPointF; ATexture: IBGRAScanner; APenWidth: single); overload; virtual;`
	`procedure DrawPolyLineAntialias(const points: array of TPoint; const ABrush: TUniversalBrush; ADrawLastPixel: boolean; AAlpha: Word = 65535); overload;`
	`procedure DrawPolyLineAntialias(const points: array of TPoint; const ABrush1, ABrush2: TUniversalBrush; ADashLen: integer; ADrawLastPixel: boolean; AAlpha: Word = 65535); overload;`
	`procedure DrawPolyLineAntialias(const APoints: array of TPointF; ATexture: IBGRAScanner; APenWidth: single; AClosedCap: boolean); overload; virtual;`
	`procedure DrawPolyLineAntialias(const APoints: array of TPointF; const ABrush: TUniversalBrush; APenWidth: single; AClosedCap: boolean); overload; virtual;`
	`procedure DrawPolyLineAntialiasAutocycle(const APoints: array of TPointF; const ABrush: TUniversalBrush; APenWidth: single); overload; virtual;`
	`procedure DrawPolyLineAntialiasAutocycle(const APoints: array of TPointF; ATexture: IBGRAScanner; APenWidth: single); overload; virtual;`
	`procedure Ellipse(x, y, rx, ry: single; ATexture: IBGRAScanner; AWidth: single; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
	`procedure Ellipse(x, y, rx, ry: single; const ABrush: TUniversalBrush; AWidth: single; AAlpha: Word = 65535); overload; virtual;`
	`procedure Ellipse(const AOrigin, AXAxis, AYAxis: TPointF; ATexture: IBGRAScanner; AWidth: single; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
	`procedure Ellipse(const AOrigin, AXAxis, AYAxis: TPointF; const ABrush: TUniversalBrush; AWidth: single; AAlpha: Word = 65535); overload; virtual;`
	`procedure EllipseAntialias(x, y, rx, ry: single; ATexture: IBGRAScanner; AWidth: single); overload; virtual;`
	`procedure EllipseAntialias(x, y, rx, ry: single; const ABrush: TUniversalBrush; AWidth: single); overload; virtual;`
	`procedure EllipseAntialias(const AOrigin, AXAxis, AYAxis: TPointF; ATexture: IBGRAScanner; AWidth: single); overload; virtual;`
	`procedure EllipseAntialias(const AOrigin, AXAxis, AYAxis: TPointF; const ABrush: TUniversalBrush; AWidth: single); overload; virtual;`
	`procedure EllipseInRect(ARect: TRect; const ABorderBrush, AFillBrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
	`procedure EllipseInRect(ARect: TRect; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
	`procedure EllipseInRect(ARect: TRect; const ABorderBrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
	`class procedure EraseBrush(out ABrush: TUniversalBrush; AAlpha: Word); virtual;`
	`procedure EraseEllipseAntialias(x, y, rx, ry: single; AAlpha: Byte); overload; virtual;`
	`procedure EraseEllipseAntialias(const AOrigin, AXAxis, AYAxis: TPointF; AAlpha: Byte); overload; virtual;`
	`procedure EraseEllipseInRect(ARect: TRect; alpha: byte); virtual;`
	`procedure EraseHorizLine(x,y,x2: int32or64; alpha: byte); virtual;`
	`procedure EraseLine(x1, y1, x2, y2: integer; alpha: byte; DrawLastPixel: boolean); virtual;`
	`procedure EraseLineAntialias(x1, y1, x2, y2: integer; alpha: byte; DrawLastPixel: boolean); virtual;`
	`procedure EraseLineAntialias(x1, y1, x2, y2: single; AAlpha: Byte; APenWidth: single; AClosedCap: boolean); overload; virtual;`
	`procedure EraseLineAntialias(x1, y1, x2, y2: single; AAlpha: Byte; APenWidth: single); overload; virtual;`
	`procedure ErasePath(APath: IBGRAPath; const AMatrix: TAffineMatrix; AAlpha: byte; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure ErasePath(APath: IBGRAPath; AAlpha: Byte; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure ErasePathAliased(APath: IBGRAPath; const AMatrix: TAffineMatrix; alpha: byte; APixelCenteredCoordinates: boolean = true); overload;`
	`procedure ErasePathAliased(APath: IBGRAPath; alpha: byte; APixelCenteredCoordinates: boolean = true); overload;`
	`procedure ErasePixel(x, y: int32or64; alpha: byte); virtual;`
	`procedure ErasePixelF(x, y: single; alpha: byte); virtual;`
	`procedure ErasePoly(const APoints: array of TPointF; alpha: byte; APixelCenteredCoordinates: boolean = true); virtual;`
	`procedure ErasePolyAntialias(const APoints: array of TPointF; AAlpha: Byte; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure ErasePolygonOutline(const points: array of TPoint; alpha: byte);`
	`procedure ErasePolygonOutlineAntialias(const APoints: array of TPointF; AAlpha: byte; APenWidth: single); overload; virtual;`
	`procedure ErasePolygonOutlineAntialias(const points: array of TPoint; alpha: byte);`
	`procedure ErasePolyLine(const points: array of TPoint; alpha: byte; ADrawLastPixel: boolean);`
	`procedure ErasePolyLineAntialias(const APoints: array of TPointF; AAlpha: byte; APenWidth: single; AClosedCap: boolean); overload; virtual;`
	`procedure ErasePolyLineAntialias(const points: array of TPoint; alpha: byte; ADrawLastPixel: boolean);`
	`procedure ErasePolyLineAntialias(const APoints: array of TPointF; AAlpha: byte; APenWidth: single); overload; virtual;`
	`procedure ErasePolyLineAntialiasAutocycle(const APoints: array of TPointF; AAlpha: byte; APenWidth: single); overload; virtual;`
	`procedure EraseRect(const ARect: TRect; alpha: byte); virtual;`
	`procedure EraseRect(ALeft, ATop, ARight, ABottom: integer; alpha: byte); virtual;`
	`procedure EraseRectAntialias(const ARectF: TRectF; AAlpha: Byte; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure EraseRectAntialias(x, y, x2, y2: single; AAlpha: Byte; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure EraseRoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; alpha: byte); virtual;`
	`procedure EraseRoundRectAntialias(x, y, x2, y2, rx, ry: single; AAlpha: Byte; AOptions: TRoundRectangleOptions = []; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure EraseShape(AShape: TBGRACustomFillInfo; alpha: byte); virtual;`
	`procedure EraseShapeAntialias(AShape: TBGRACustomFillInfo; AAlpha: Byte); overload; virtual;`
	`procedure EraseVertLine(x, y, y2: int32or64; alpha: byte); virtual;`
	`procedure Fill(ATexture: IBGRAScanner; AMode: TDrawMode); overload; virtual;`
	`procedure Fill(const ABrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
	`procedure Fill(ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word); overload; virtual;`
	`procedure FillEllipseAntialias(const AOrigin, AXAxis, AYAxis: TPointF; ATexture: IBGRAScanner); overload; virtual;`
	`procedure FillEllipseAntialias(const AOrigin, AXAxis, AYAxis: TPointF; const ABrush: TUniversalBrush); overload; virtual;`
	`procedure FillEllipseAntialias(x, y, rx, ry: single; ATexture: IBGRAScanner); overload; virtual;`
	`procedure FillEllipseAntialias(x, y, rx, ry: single; const ABrush: TUniversalBrush); overload; virtual;`
	`procedure FillEllipseInRect(ARect: TRect; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
	`procedure FillEllipseInRect(ARect: TRect; const AFillBrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
	`procedure FillMask(x,y: integer; AMask: TCustomUniversalBitmap; ATexture: IBGRAScanner; AMode: TDrawMode); overload; virtual;`
	`procedure FillMask(x,y: integer; AMask: TCustomUniversalBitmap; ATexture: IBGRAScanner; AMode: TDrawMode; AScanOffset: TPoint); overload; virtual;`
	`procedure FillMask(x,y: integer; AMask: TCustomUniversalBitmap; ATexture: IBGRAScanner); overload; virtual;`
	`procedure FillMask(x,y: integer; AMask: TCustomUniversalBitmap; const ABrush: TUniversalBrush); overload; virtual;`
	`procedure FillPath(APath: IBGRAPath; const ABrush: TUniversalBrush; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure FillPath(APath: IBGRAPath; ATexture: IBGRAScanner; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure FillPath(APath: IBGRAPath; const AMatrix: TAffineMatrix; ATexture: IBGRAScanner; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure FillPath(APath: IBGRAPath; const AMatrix: TAffineMatrix; const ABrush: TUniversalBrush; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure FillPathAliased(APath: IBGRAPath; ATexture: IBGRAScanner; AMode: TDrawMode; APixelCenteredCoordinates: boolean = true; AAlpha: Word = 65535); overload;`
	`procedure FillPathAliased(APath: IBGRAPath; const AMatrix: TAffineMatrix; ATexture: IBGRAScanner; AMode: TDrawMode; APixelCenteredCoordinates: boolean = true; AAlpha: Word = 65535); overload;`
	`procedure FillPathAliased(APath: IBGRAPath; const ABrush: TUniversalBrush; APixelCenteredCoordinates: boolean = true; AAlpha: Word = 65535); overload;`
	`procedure FillPathAliased(APath: IBGRAPath; const AMatrix: TAffineMatrix; const ABrush: TUniversalBrush; APixelCenteredCoordinates: boolean = true; AAlpha: Word = 65535); overload;`
	`procedure FillPoly(const APoints: array of TPointF; ATexture: IBGRAScanner; AMode: TDrawMode; APixelCenteredCoordinates: boolean = true; AAlpha: Word = 65535); overload; virtual;`
	`procedure FillPoly(const APoints: array of TPointF; const ABrush: TUniversalBrush; APixelCenteredCoordinates: boolean = true; AAlpha: Word = 65535); overload; virtual;`
	`procedure FillPolyAntialias(const APoints: array of TPointF; const ABrush: TUniversalBrush; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure FillPolyAntialias(const APoints: array of TPointF; ATexture: IBGRAScanner; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure FillRect(ALeft, ATop, ARight, ABottom: integer; const ABrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
	`procedure FillRect(const ARect: TRect; const ABrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
	`procedure FillRect(ALeft, ATop, ARight, ABottom: integer; ATexture: IBGRAScanner; AMode: TDrawMode; AScanOffset: TPoint; AAlpha: Word = 65535); overload; virtual;`
	`procedure FillRect(const ARect: TRect; ATexture: IBGRAScanner; AMode: TDrawMode; AScanOffset: TPoint; AAlpha: Word = 65535); overload; virtual;`
	`procedure FillRect(ALeft, ATop, ARight, ABottom: integer; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
	`procedure FillRect(const ARect: TRect; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
	`procedure FillRectAntialias(x, y, x2, y2: single; ATexture: IBGRAScanner; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure FillRectAntialias(x, y, x2, y2: single; const ABrush: TUniversalBrush; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure FillRectAntialias(const ARectF: TRectF; ATexture: IBGRAScanner; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure FillRectAntialias(const ARectF: TRectF; const ABrush: TUniversalBrush; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure FillRoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
	`procedure FillRoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; const AFillBrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
	`procedure FillRoundRectAntialias(x, y, x2, y2, rx, ry: single; ATexture: IBGRAScanner; AOptions: TRoundRectangleOptions = []; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure FillRoundRectAntialias(x, y, x2, y2, rx, ry: single; const ABrush: TUniversalBrush; AOptions: TRoundRectangleOptions = []; APixelCenteredCoordinates: boolean = true); overload; virtual;`
	`procedure FillShape(AShape: TBGRACustomFillInfo; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); virtual;`
	`procedure FillShape(AShape: TBGRACustomFillInfo; const ABrush: TUniversalBrush; AAlpha: Word = 65535); virtual;`
	`procedure FillShapeAntialias(AShape: TBGRACustomFillInfo; const ABrush: TUniversalBrush); overload; virtual;`
	`procedure FillShapeAntialias(AShape: TBGRACustomFillInfo; ATexture: IBGRAScanner); overload; virtual;`
	`procedure FillTransparent; virtual;`
	`procedure FreeReference;`
	`procedure GetPixelCycleIndirect(x,y: int32or64; AColor: pointer); virtual;`
	`procedure GetPixelIndirect(x,y: int32or64; AColor: pointer); virtual;`
	`procedure HorizLine(x, y, x2: int32or64; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
	`procedure HorizLine(x, y, x2: int32or64; const ABrush: TUniversalBrush; AAlpha: Word = 65535); virtual;`
	`procedure HorizontalFlip; overload; virtual;`
	`procedure HorizontalFlip(ARect: TRect); overload; virtual;`
	`procedure InvalidateBitmap; virtual;`
	`procedure LoadFromBitmapIfNeeded; virtual;`
	`procedure LoadFromFile(const AFilename:String; AHandler:TFPCustomImageReader); overload; virtual;`
	`procedure LoadFromFile(const AFilename:String; AHandler:TFPCustomImageReader; AOptions: TBGRALoadingOptions); overload; virtual;`
	`procedure LoadFromFile(const AFilename: string; AOptions: TBGRALoadingOptions); overload; virtual;`
	`procedure LoadFromFile(const AFilename: string); overload; virtual;`
	`procedure LoadFromFileUTF8(const AFilenameUTF8: string; AOptions: TBGRALoadingOptions = []); overload; virtual;`
	`procedure LoadFromFileUTF8(const AFilenameUTF8: string; AHandler: TFPCustomImageReader; AOptions: TBGRALoadingOptions = []); overload; virtual;`
	`procedure LoadFromResource(AFilename: string; AHandler: TFPCustomImageReader); overload; virtual;`
	`procedure LoadFromResource(AFilename: string; AHandler: TFPCustomImageReader; AOptions: TBGRALoadingOptions); overload; virtual;`
	`procedure LoadFromResource(AFilename: string); overload; virtual;`
	`procedure LoadFromResource(AFilename: string; AOptions: TBGRALoadingOptions); overload; virtual;`
	`procedure LoadFromStream(AStream: TStream; AHandler: TFPCustomImageReader); overload; virtual;`
	`procedure LoadFromStream(AStream: TStream; AOptions: TBGRALoadingOptions); overload; virtual;`
	`procedure LoadFromStream(AStream: TStream); overload; virtual;`
	`procedure LoadFromStream(AStream: TStream; AHandler: TFPCustomImageReader; AOptions: TBGRALoadingOptions); overload; virtual;`
	`class procedure MaskBrush(out ABrush: TUniversalBrush; AScanner: IBGRAScanner; AOffsetX: integer = 0; AOffsetY: integer = 0); virtual;`
	`procedure NoClip; virtual;`
	`procedure PutImage(X, Y: integer; ASource: TCustomUniversalBitmap; AMode: TDrawMode; AOpacity: byte = 255); virtual;`
	`procedure Rectangle(x, y, x2, y2: integer; const ABorderBrush, AFillBrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
	`procedure Rectangle(const ARect: TRect; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
	`procedure Rectangle(const ARect: TRect; const ABrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
	`procedure Rectangle(x, y, x2, y2: integer; const ABrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
	`procedure Rectangle(x, y, x2, y2: integer; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
	`procedure Rectangle(const ARect: TRect; const ABorderBrush, AFillBrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
	`procedure RectangleAntialias(x, y, x2, y2: single; ATexture: IBGRAScanner; AWidth: single); overload; virtual;`
	`procedure RectangleAntialias(x, y, x2, y2: single; const ABrush: TUniversalBrush; AWidth: single); overload; virtual;`
	`procedure RotateUDInplace; overload; virtual;`
	`procedure RotateUDInplace(ARect: TRect); overload; virtual;`
	`procedure RoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; const ABorderBrush, AFillBrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
	`procedure RoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; const ABorderBrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
	`procedure RoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
	`procedure SaveToFile(const AFilename: string; AHandler:TFPCustomImageWriter); overload; virtual;`
	`procedure SaveToFile(const AFilename: string); overload; virtual;`
	`procedure SaveToFileUTF8(const AFilenameUTF8: string); overload; virtual;`
	`procedure SaveToFileUTF8(const AFilenameUTF8: string; AHandler:TFPCustomImageWriter); overload; virtual;`
	`procedure SaveToStreamAs(AStream: TStream; AFormat: TBGRAImageFormat); virtual;`
	`procedure SaveToStreamAsPng(AStream: TStream); virtual;`
	`procedure ScanMoveTo(X,Y: Integer); virtual;`
	`class procedure ScannerBrush(out ABrush: TUniversalBrush; AScanner: IBGRAScanner; ADrawMode: TDrawMode = dmDrawWithTransparency; AOffsetX: integer = 0; AOffsetY: integer = 0); virtual;`
	`procedure ScanNextCustomChunk(var ACount: integer; out APixels: Pointer); virtual;`
	`procedure ScanNextMaskChunk(var ACount: integer; out AMask: PByteMask; out AStride: integer); virtual;`
	`procedure ScanPutPixels(pdest: PBGRAPixel; count: integer; mode: TDrawMode); virtual;`
	`procedure ScanSkipPixels(ACount: integer); virtual;`
	`procedure Serialize(AStream: TStream); virtual;`
	`class procedure SerializeEmpty(AStream: TStream); static;`
	`procedure SetPixelIndirect(x,y: int32or64; AColor: pointer); virtual;`
	`procedure SetSize(AWidth, AHeight: integer); override;`
	`procedure SolidBrushBGRA(out ABrush: TUniversalBrush; AColor: TBGRAPixel; ADrawMode: TDrawMode = dmDrawWithTransparency); overload; virtual;`
	`procedure SolidBrushBGRA(out ABrush: TUniversalBrush; ARed,AGreen,ABlue,AAlpha: Byte; ADrawMode: TDrawMode = dmDrawWithTransparency); overload; virtual;`
	`procedure SolidBrushExpanded(out ABrush: TUniversalBrush; AColor: TExpandedPixel; ADrawMode: TDrawMode = dmDrawWithTransparency); overload; virtual;`
	`procedure SolidBrushExpanded(out ABrush: TUniversalBrush; ARed,AGreen,ABlue,AAlpha: Word; ADrawMode: TDrawMode = dmDrawWithTransparency); overload; virtual;`
	`procedure SolidBrushIndirect(out ABrush: TUniversalBrush; AColor: Pointer; ADrawMode: TDrawMode = dmDrawWithTransparency); virtual;`
	`procedure VerticalFlip(ARect: TRect); overload; virtual;`
	`procedure VerticalFlip; overload; virtual;`
	`procedure VertLine(x, y, y2: int32or64; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
	`procedure VertLine(x, y, y2: int32or64; const ABrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
	`procedure AssignTransparentPixel(out ADest); virtual;`
	`procedure FreeData; virtual;`
	`procedure Init; virtual;`
	`procedure InternalCopyPixels(ASource,ADest: PByte; ASourceStride,ADestStride: PtrInt; ACount: integer); virtual;`
	`procedure InternalSetPixels(ASource,ADest: PByte; ADestStride: PtrInt; ACount: integer); virtual;`
	`procedure InternalSwapPixels(ABuf1,ABuf2: PByte; AStride1,AStride2: PtrInt; ACount: integer); virtual;`
	`procedure RaiseInvalidBrushColorspace; virtual;`
	`procedure RaiseMissingUniDrawer; virtual;`
	`procedure ReallocData; virtual;`
	`procedure SetAntialiasingDrawMode(AValue: TDrawMode); virtual;`
	`procedure SetClipRect(const AValue: TRect); virtual;`
	`procedure SetInternalColor(x, y: integer; const Value: TFPColor); override;`
	`procedure SetInternalPixel(x, y: integer; Value: integer); override;`
	`procedure SetLinearAntialiasing(AValue: boolean); virtual;`
	`procedure SetLineCap(AValue: TPenEndCap); virtual;`
	`procedure SetLineOrder(AValue: TRawImageLineOrder); virtual;`
	`procedure SetResolutionUnit(AResolutionUnit: TResolutionUnit);`

Properties

	`property AntialiasingDrawMode: TDrawMode read FAntialiasingDrawMode write SetAntialiasingDrawMode;`
	`property Arrow: TBGRACustomArrow read GetArrow;`
	`property ClipRect: TRect read GetClipRect write SetClipRect;`
	`property Colorspace: TColorspaceAny read FColorspace;`
	`property DataByte: PByte Read GetDataBytePtr;`
	`property Empty: boolean Read CheckEmpty;`
	`property HasSemiTransparentPixels: boolean Read GetHasSemiTransparentPixels;`
	`property HasTransparentPixels: boolean Read GetHasTransparentPixels;`
	`property Height: integer Read GetHeight;`
	`property IsZero: boolean Read CheckIsZero;`
	`property LinearAntialiasing: boolean read GetLinearAntialiasing write SetLinearAntialiasing;`
	`property LineCap: TPenEndCap read GetLineCap write SetLineCap;`
	`property LineOrder: TRawImageLineOrder Read GetLineOrder write SetLineOrder;`
	`property NbPixels: integer Read GetNbPixels;`
	`property Pen: TBGRACustomPenStroker read GetPenStroker;`
	`property RefCount: integer Read GetRefCount;`
	`property ReferenceWhite: PXYZReferenceWhite read FReferenceWhite write FReferenceWhite;`
	`property ResolutionHeight: Single read GetResolutionHeight;`
	`property ResolutionUnit: TResolutionUnit read FResolutionUnit write SetResolutionUnit;`
	`property ResolutionWidth: Single read GetResolutionWidth;`
	`property ResolutionX: Single read FResolutionX write FResolutionX;`
	`property ResolutionY: Single read FResolutionY write FResolutionY;`
	`property RowSize: PtrInt read FRowSize;`
	`property ScanLineByte[y: integer]: PByte Read GetScanLineByte;`
	`property Width: integer Read GetWidth;`

Description

Fields

	`Caption: string;`
User defined `caption`. It does not appear on the image

	`FAntialiasingDrawMode: TDrawMode;`
Specifies if linear antialiasing must be used when drawing antialiased shapes

	`FClipRect: TRect;`
current scan coordinates

	`FColorspace: TColorspaceAny;`
This item has no description.

	`FConvertFromBGRA: TBridgedConversion;`
This item has no description.

	`FConvertFromExpanded: TBridgedConversion;`
This item has no description.

	`FConvertFromFPColor: TBridgedConversion;`
This item has no description.

	`FConvertToBGRA: TBridgedConversion;`
This item has no description.

	`FConvertToExpanded: TBridgedConversion;`
This item has no description.

	`FConvertToFPColor: TBridgedConversion;`
This item has no description.

	`FDataByte: PByte;`
This item has no description.

	`FHeight: integer;`
This item has no description.

	`FillMode: TFillMode;`
Method to use when filling polygons (winding or alternate). See [[BGRABitmap Types imported from Graphics\|BGRAGraphics]]

	`FLineOrder: TRawImageLineOrder;`
This item has no description.

	`FNbPixels: integer;`
This item has no description.

	`FPenStroker: TBGRACustomPenStroker;`
This item has no description.

	`FPixelSize: integer;`
This item has no description.

	`FRefCount: integer;`
This item has no description.

	`FReferenceWhite: PXYZReferenceWhite;`
This item has no description.

	`FResolutionUnit: TResolutionUnit;`
Resolution

	`FResolutionX: Single;`
This item has no description.

	`FResolutionY: Single;`
This item has no description.

	`FRowSize: PtrInt;`
This item has no description.

	`FScanCurX: integer;`
current scan address

	`FScanCurY: integer;`
current scan address

	`FScanHeight: integer;`
Scan

	`FScanPtr: PByte;`
possibility to reduce the zone being scanned

	`FScanWidth: integer;`
Scan

	`FWidth: integer;`
This item has no description.

	`ScanOffset: TPoint;`
Offset to apply when the image is scanned

Methods

	`constructor Create; overload;`
Creates an image of width and height equal to zero. In this case, ''DataByte'' = '''nil'''

	`constructor Create(AWidth, AHeight: integer); overload; override;`
Creates a new bitmap, initialize properties and bitmap data

	`constructor Create(AColorspace: TColorspaceAny; ALineOrder: TRawImageLineOrder); overload;`
This item has no description.

	`constructor Create(AColorspace: TColorspaceAny; AWidth, AHeight: integer; ALineOrder: TRawImageLineOrder); overload;`
This item has no description.

	`destructor Destroy; override;`
This item has no description.

	`function CheckClippedRectBounds(var x,y,x2,y2: integer): boolean;`
Check if the bounds are within the clipping rectangle and adjust the coordinates to fit (similar to IntersectRect but may flip the coordinates)

	`function Duplicate(ACopyProperties: boolean=false): TCustomUniversalBitmap; virtual;`
This item has no description.

	`function FilterBlurMotion(const ABounds: TRect; distance: single; angle: single; oriented: boolean; ACopyProperties: Boolean=False): TCustomUniversalBitmap; overload; virtual;`
This item has no description.

	`function FilterBlurMotion(distance: single; angle: single; oriented: boolean; ACopyProperties: Boolean=False): TCustomUniversalBitmap; overload; virtual;`
This item has no description.

	`function FilterBlurRadial(radius: single; blurType: TRadialBlurType; ACopyProperties: Boolean=False): TCustomUniversalBitmap; overload; virtual;`
filters

	`function FilterBlurRadial(const ABounds: TRect; radius: single; blurType: TRadialBlurType; ACopyProperties: Boolean=False): TCustomUniversalBitmap; overload; virtual;`
This item has no description.

	`function FilterBlurRadial(const ABounds: TRect; radiusX, radiusY: single; blurType: TRadialBlurType; ACopyProperties: Boolean=False): TCustomUniversalBitmap; overload; virtual;`
This item has no description.

	`function FilterBlurRadial(radiusX, radiusY: single; blurType: TRadialBlurType; ACopyProperties: Boolean=False): TCustomUniversalBitmap; overload; virtual;`
This item has no description.

	`function FilterCustomBlur(const ABounds: TRect; mask: TCustomUniversalBitmap; ACopyProperties: Boolean=False): TCustomUniversalBitmap; overload; virtual;`
This item has no description.

	`function FilterCustomBlur(mask: TCustomUniversalBitmap; ACopyProperties: Boolean=False): TCustomUniversalBitmap; overload; virtual;`
This item has no description.

	`function GetImageBounds: TRect; overload; virtual;`
This item has no description.

	`function GetImageBounds(Channels: TChannels; ANothingValue: Byte = 0): TRect; overload;`
This item has no description.

	`function GetImageBounds(Channel: TChannel; ANothingValue: Byte = 0): TRect; overload;`
This item has no description.

	`function GetImageBoundsWithin(const ARect: TRect; Channels: TChannels; ANothingValue: Byte = 0): TRect; overload; virtual;`
This item has no description.

	`function GetImageBoundsWithin(const ARect: TRect; Channel: TChannel = cAlpha; ANothingValue: Byte = 0): TRect; overload; virtual;`
This item has no description.

	`function GetPart(const ARect: TRect; ACopyProperties: Boolean=False): TCustomUniversalBitmap; virtual;`
Get a part of the image with repetition in both directions. It means that if the bounds are within the image, the result is just that part of the image, but if the bounds are bigger than the image, the image is tiled.

	`function GetPixelAddress(x,y: integer): PByte; virtual;`
Returns the address of a pixel. /!\ Does not check if the coordinates are valid.

	`function GetScanCustomColorspace: TColorspaceAny; virtual;`
This item has no description.

	`function GetUnique: TCustomUniversalBitmap; virtual;`
Returns an object with a reference count equal to 1. Duplicate this bitmap if necessary

	`function IntersectClip(const ARect: TRect): TRect;`
Reduce the clipping region further by intersection and returns the previous clipping rectangle

function IsScanPutPixelsDefined: boolean; virtual;

This item has no description. Showing description inherited from IBGRAScanner.IsScanPutPixelsDefined.

Returns True if the function ScanPutPixels is available. Otherwise you need to call ScanNextPixel and combine pixels for example with SetPixel

	`function NewBitmap: TCustomUniversalBitmap; overload; virtual;`
This item has no description.

	`function NewBitmap(AWidth, AHeight: integer): TCustomUniversalBitmap; overload; virtual;`
This item has no description.

	`function NewBitmap(AWidth, AHeight: integer; AColor: Pointer): TCustomUniversalBitmap; overload; virtual;`
This item has no description.

	`function NewReference: TCustomUniversalBitmap; virtual;`
Adds a reference (this reference count is not the same as the reference count of an interface, it changes only by explicit calls)

	`function PtInClipRect(x, y: int32or64): boolean; inline;`
Checks if the specified point is in the clipping rectangle ''ClipRect''

	`function RotateCCW(ACopyProperties: Boolean=False): TCustomUniversalBitmap; virtual;`
Return a new bitmap rotated in a counter clock wise direction.

	`function RotateCW(ACopyProperties: Boolean=False): TCustomUniversalBitmap; virtual;`
Return a new bitmap rotated in a clock wise direction.

	`function RotateUD(ACopyProperties: Boolean=False): TCustomUniversalBitmap; virtual;`
Return a new bitmap rotated 180° (upside down).

function ScanAt(X,Y: Single): TBGRAPixel; virtual;

This item has no description. Showing description inherited from IBGRAScanner.ScanAt.

Scan at any location using floating point coordinates

	`function ScanAtExpanded(X, Y: Single): TExpandedPixel; virtual;`
This item has no description.

function ScanAtInteger(X,Y: integer): TBGRAPixel; virtual;

This item has no description. Showing description inherited from IBGRAScanner.ScanAtInteger.

Scan at any location using integer coordinates

	`function ScanAtIntegerExpanded(X, Y: integer): TExpandedPixel; virtual;`
This item has no description.

	`function ScanAtIntegerMask(X,Y: integer): TByteMask; virtual;`
This item has no description.

	`function ScanAtMask(X,Y: Single): TByteMask; virtual;`
This item has no description.

	`function ScanNextExpandedPixel: TExpandedPixel; virtual;`
This item has no description.

function ScanNextPixel: TBGRAPixel; virtual;

This item has no description. Showing description inherited from IBGRAScanner.ScanNextPixel.

Scan the pixel at the current location and increments X

	`function CheckEmpty: boolean; virtual;`
This item has no description.

	`function CheckHorizLineBounds(var x:int32or64; y: int32or64; var x2: int32or64): boolean; inline;`
This item has no description.

	`function CheckIsZero: boolean; virtual;`
This item has no description.

	`function CheckVertLineBounds(x: int32or64; var y, y2: int32or64): boolean; inline;`
This item has no description.

	`class function DefaultColorspace: TColorspaceAny; virtual;`
This item has no description.

	`function GetArrow: TBGRACustomArrow; virtual;`
==== Pen style ====

	`function GetClipRect: TRect; virtual;`
This item has no description.

	`function GetDataBytePtr: PByte; virtual;`
This item has no description.

	`function GetHasSemiTransparentPixels: boolean; virtual;`
This item has no description.

	`function GetHasTransparentPixels: boolean; virtual;`
This item has no description.

	`function GetHeight: integer; virtual;`
This item has no description.

	`function GetInternalColor(x, y: integer): TFPColor; override;`
This item has no description.

	`function GetInternalPen: TBGRACustomPenStroker; virtual;`
This item has no description.

	`function GetInternalPixel(x, y: integer): integer; override;`
This item has no description.

	`function GetLinearAntialiasing: boolean; virtual;`
This item has no description.

	`function GetLineCap: TPenEndCap; virtual;`
This item has no description.

	`function GetLineOrder: TRawImageLineOrder; virtual;`
This item has no description.

	`function GetNbPixels: integer; virtual;`
This item has no description.

	`function GetPenStroker: TBGRACustomPenStroker; virtual;`
This item has no description.

	`function GetRefCount: integer; virtual;`
This item has no description.

	`function GetResolutionHeight: Single; virtual;`
This item has no description.

	`function GetResolutionWidth: Single; virtual;`
This item has no description.

	`function GetScanlineAt(X, Y: integer): PBGRAPixel; virtual;`
This item has no description.

	`function GetScanLineByte(y: integer): PByte; virtual;`
This item has no description.

function GetTextureGL: IUnknown; virtual;

This item has no description. Showing description inherited from IBGRAScanner.GetTextureGL.

Returns the corresponding OpenGL texture. The value is nil if no texture is associated. **

	`function GetWidth: integer; virtual;`
This item has no description.

	`function InternalDuplicate(ACopyProperties: boolean=false): TCustomUniversalBitmap; virtual;`
This item has no description.

	`function InternalNew: TCustomUniversalBitmap; virtual;`
This item has no description.

	`function ProvidesScanline(ARect: TRect): boolean; virtual;`
==== 'IBGRAScanner'' interface ====

	`function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;`
interface

	`function _AddRef: Integer; stdcall;`
This item has no description.

	`function _Release: Integer; stdcall;`
This item has no description.

	`class procedure AlphaBrush(out ABrush: TUniversalBrush; AAlpha: Word); virtual;`
This item has no description.

	`procedure AlphaFill(alpha: byte); virtual;`
This item has no description.

	`procedure AlphaFillEllipseInRect(ARect: TRect; alpha: byte); virtual;`
This item has no description.

	`procedure AlphaFillPathAliased(APath: IBGRAPath; alpha: byte; APixelCenteredCoordinates: boolean = true); overload;`
This item has no description.

	`procedure AlphaFillPathAliased(APath: IBGRAPath; const AMatrix: TAffineMatrix; alpha: byte; APixelCenteredCoordinates: boolean = true); overload;`
This item has no description.

	`procedure AlphaFillPoly(const APoints: array of TPointF; alpha: byte; APixelCenteredCoordinates: boolean = true); virtual;`
This item has no description.

	`procedure AlphaFillRect(const ARect: TRect; alpha: byte); virtual;`
This item has no description.

	`procedure AlphaFillRect(ALeft, ATop, ARight, ABottom: integer; alpha: byte); virtual;`
This item has no description.

	`procedure AlphaFillRoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; alpha: byte); virtual;`
This item has no description.

	`procedure AlphaFillShape(AShape: TBGRACustomFillInfo; alpha: byte); virtual;`
This item has no description.

	`procedure AlphaHorizLine(x,y,x2: int32or64; alpha: byte); virtual;`
This item has no description.

	`procedure AlphaLine(x1, y1, x2, y2: integer; alpha: byte; DrawLastPixel: boolean); virtual;`
This item has no description.

	`procedure AlphaLineAntialias(x1, y1, x2, y2: integer; alpha: byte; DrawLastPixel: boolean); virtual;`
This item has no description.

	`procedure AlphaPixel(x, y: int32or64; alpha: byte); virtual;`
Sets the alpha value at (''x'',''y''). If ''alpha'' = 0, the pixel is replaced by the transparent pixel

	`procedure AlphaPixelF(x, y: single; alpha: byte); virtual;`
This item has no description.

	`procedure AlphaPolygonOutline(const points: array of TPoint; alpha: byte);`
This item has no description.

	`procedure AlphaPolygonOutlineAntialias(const points: array of TPoint; alpha: byte);`
This item has no description.

	`procedure AlphaPolyLine(const points: array of TPoint; alpha: byte; ADrawLastPixel: boolean);`
This item has no description.

	`procedure AlphaPolyLineAntialias(const points: array of TPoint; alpha: byte; ADrawLastPixel: boolean);`
This item has no description.

	`procedure AlphaVertLine(x, y, y2: int32or64; alpha: byte); virtual;`
This item has no description.

	`procedure ApplyGlobalOpacity(ARect: TRect; alpha: byte); overload; virtual;`
This item has no description.

	`procedure ApplyGlobalOpacity(alpha: byte); overload; virtual;`
This item has no description.

	`procedure ApplyMask(mask: TCustomUniversalBitmap; ARect: TRect; AMaskRectTopLeft: TPoint; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure ApplyMask(mask: TCustomUniversalBitmap; AAlpha: Word = 65535); overload;`
Masking

	`procedure ApplyMask(mask: TCustomUniversalBitmap; ARect: TRect; AAlpha: Word = 65535); overload;`
This item has no description.

	`procedure Assign(Source: TPersistent; ACopyProperties: Boolean); virtual; overload;`
This item has no description.

	`procedure Assign(Source: TPersistent); override;`
This item has no description.

	`procedure ClearTransparentPixels; virtual;`
Clear all channels of transparent pixels

	`procedure CopyPropertiesTo(ABitmap: TCustomUniversalBitmap); virtual;`
This item has no description.

	`procedure Deserialize(AStream: TStream); virtual;`
Reads the image in a stream that was previously serialized

	`procedure DrawCheckers(ARect: TRect; const ABrushEven,ABrushOdd: TUniversalBrush; AGridWidth: integer = 8; AGridHeight: integer = 8); overload; virtual;`
This item has no description.

	`procedure DrawLine(x1, y1, x2, y2: integer; const ABrush: TUniversalBrush; ADrawLastPixel: boolean; AAlpha: Word = 65535); overload; virtual;`
Draws an aliased line from (x1,y1) to (x2,y2) using Bresenham's algorithm. ''DrawLastPixel'' specifies if (x2,y2) must be drawn.

	`procedure DrawLine(x1, y1, x2, y2: integer; ATexture: IBGRAScanner; AMode: TDrawMode; ADrawLastPixel: boolean; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure DrawLineAntialias(x1, y1, x2, y2: integer; const ABrush1, ABrush2: TUniversalBrush; ADashLen: integer; ADrawLastPixel: boolean; AAlpha: Word = 65535); overload; virtual;`
Draws an antialiased line with two brushes as dashes of length ''ADashLen''. ''ADashPos'' can be used to specify the start dash position and to retrieve the dash position at the end of the line, in order to draw a polyline with consistent dashes

	`procedure DrawLineAntialias(x1, y1, x2, y2: integer; ATexture: IBGRAScanner; AMode: TDrawMode; ADrawLastPixel: boolean; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure DrawLineAntialias(x1, y1, x2, y2: integer; const ABrush: TUniversalBrush; ADrawLastPixel: boolean; AAlpha: Word = 65535); overload; virtual;`
Draws an antialiased line from (x1,y1) to (x2,y2) using an improved version of Bresenham's algorithm ''DrawLastPixel'' specifies if (x2,y2) must be drawn

	`procedure DrawLineAntialias(x1, y1, x2, y2: integer; const ABrush1, ABrush2: TUniversalBrush; ADashLen: integer; var ADashPos: integer; ADrawLastPixel: boolean; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure DrawLineAntialias(x1, y1, x2, y2: single; ATexture: IBGRAScanner; APenWidth: single); overload; virtual;`
Draws a line from (x1,y1) to (x2,y2) using current pen style/cap/join. ''texture'' specifies the source color to use when filling the line

	`procedure DrawLineAntialias(x1, y1, x2, y2: single; const ABrush: TUniversalBrush; APenWidth: single); overload; virtual;`
Draws a line from (x1,y1) to (x2,y2) using current pen style/cap/join

	`procedure DrawLineAntialias(x1, y1, x2, y2: single; ATexture: IBGRAScanner; APenWidth: single; AClosedCap: boolean); overload; virtual;`
Same as above with ''texture'' specifying the source color to use when filling the line

	`procedure DrawLineAntialias(x1, y1, x2, y2: single; const ABrush: TUniversalBrush; APenWidth: single; AClosedCap: boolean); overload; virtual;`
Draws a line from (x1,y1) to (x2,y2) using current pen style/cap/join. ''Closed'' specifies if the end of the line is roundly closed. If it is not closed, a space is left so that the next line can fit

	`procedure DrawPath(APath: IBGRAPath; const AMatrix: TAffineMatrix; const ABrush: TUniversalBrush; AWidth: single; APixelCenteredCoordinates: boolean = true); overload; virtual;`
This item has no description.

	`procedure DrawPath(APath: IBGRAPath; ATexture: IBGRAScanner; AWidth: single; APixelCenteredCoordinates: boolean = true); overload; virtual;`
This item has no description.

	`procedure DrawPath(APath: IBGRAPath; const ABrush: TUniversalBrush; AWidth: single; APixelCenteredCoordinates: boolean = true); overload; virtual;`
This item has no description.

	`procedure DrawPath(APath: IBGRAPath; const AMatrix: TAffineMatrix; ATexture: IBGRAScanner; AWidth: single; APixelCenteredCoordinates: boolean = true); overload; virtual;`
This item has no description.

	`procedure DrawPathAliased(APath: IBGRAPath; const ABrush: TUniversalBrush; APixelCenteredCoordinates: boolean = true; AAlpha: Word = 65535); overload;`
This item has no description.

	`procedure DrawPathAliased(APath: IBGRAPath; const AMatrix: TAffineMatrix; const ABrush: TUniversalBrush; APixelCenteredCoordinates: boolean = true; AAlpha: Word = 65535); overload;`
This item has no description.

	`procedure DrawPixel(x,y: Int32or64; const ABrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure DrawPixel(x,y: Int32or64; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure DrawPixelF(x,y: single; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure DrawPixelF(x,y: single; const ABrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure DrawPolygon(const points: array of TPoint; const ABrush: TUniversalBrush; AAlpha: Word = 65535);`
This item has no description.

	`procedure DrawPolygonAntialias(const APoints: array of TPointF; const ABrush: TUniversalBrush; APenWidth: single); overload; virtual;`
Draws a polygon using current pen style/cap/join. The polygon is always closed. You don't need to set the last point to be the same as the first point

	`procedure DrawPolygonAntialias(const points: array of TPoint; const ABrush: TUniversalBrush; AAlpha: Word = 65535); overload;`
This item has no description.

	`procedure DrawPolygonAntialias(const points: array of TPoint; const ABrush1, ABrush2: TUniversalBrush; ADashLen: integer; AAlpha: Word = 65535); overload;`
This item has no description.

	`procedure DrawPolygonAntialias(const APoints: array of TPointF; ATexture: IBGRAScanner; APenWidth: single); overload; virtual;`
This item has no description.

	`procedure DrawPolyLine(const points: array of TPoint; const ABrush: TUniversalBrush; ADrawLastPixel: boolean; AAlpha: Word = 65535);`
This item has no description.

	`procedure DrawPolyLineAntialias(const APoints: array of TPointF; const ABrush: TUniversalBrush; APenWidth: single); overload; virtual;`
Draws a polyline using current pen style/cap/join

	`procedure DrawPolyLineAntialias(const APoints: array of TPointF; ATexture: IBGRAScanner; APenWidth: single); overload; virtual;`
Draws a polyline using current pen style/cap/join. ''texture'' specifies the source color to use when filling the line

	`procedure DrawPolyLineAntialias(const points: array of TPoint; const ABrush: TUniversalBrush; ADrawLastPixel: boolean; AAlpha: Word = 65535); overload;`
This item has no description.

	`procedure DrawPolyLineAntialias(const points: array of TPoint; const ABrush1, ABrush2: TUniversalBrush; ADashLen: integer; ADrawLastPixel: boolean; AAlpha: Word = 65535); overload;`
This item has no description.

	`procedure DrawPolyLineAntialias(const APoints: array of TPointF; ATexture: IBGRAScanner; APenWidth: single; AClosedCap: boolean); overload; virtual;`
This item has no description.

	`procedure DrawPolyLineAntialias(const APoints: array of TPointF; const ABrush: TUniversalBrush; APenWidth: single; AClosedCap: boolean); overload; virtual;`
Draws a polyline using current pen style/cap/join. ''Closed'' specifies if the end of the line is roundly closed. If it is not closed, a space is left so that the next line can fit

	`procedure DrawPolyLineAntialiasAutocycle(const APoints: array of TPointF; const ABrush: TUniversalBrush; APenWidth: single); overload; virtual;`
Draws a polyline using current pen style/cap/join. The last point considered as a join with the first point if it has the same coordinate

	`procedure DrawPolyLineAntialiasAutocycle(const APoints: array of TPointF; ATexture: IBGRAScanner; APenWidth: single); overload; virtual;`
Draws a polygon using current pen style/cap/join. Use a texture to fill the line. The polygon is always closed. You don't need to set the last point to be the same as the first point

	`procedure Ellipse(x, y, rx, ry: single; ATexture: IBGRAScanner; AWidth: single; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure Ellipse(x, y, rx, ry: single; const ABrush: TUniversalBrush; AWidth: single; AAlpha: Word = 65535); overload; virtual;`
Draws an ellipse without antialising. ''rx'' is the horizontal radius and ''ry'' the vertical radius

	`procedure Ellipse(const AOrigin, AXAxis, AYAxis: TPointF; ATexture: IBGRAScanner; AWidth: single; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure Ellipse(const AOrigin, AXAxis, AYAxis: TPointF; const ABrush: TUniversalBrush; AWidth: single; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure EllipseAntialias(x, y, rx, ry: single; ATexture: IBGRAScanner; AWidth: single); overload; virtual;`
This item has no description.

	`procedure EllipseAntialias(x, y, rx, ry: single; const ABrush: TUniversalBrush; AWidth: single); overload; virtual;`
Draws an ellipse with antialising. ''rx'' is the horizontal radius and ''ry'' the vertical radius

	`procedure EllipseAntialias(const AOrigin, AXAxis, AYAxis: TPointF; ATexture: IBGRAScanner; AWidth: single); overload; virtual;`
This item has no description.

	`procedure EllipseAntialias(const AOrigin, AXAxis, AYAxis: TPointF; const ABrush: TUniversalBrush; AWidth: single); overload; virtual;`
This item has no description.

	`procedure EllipseInRect(ARect: TRect; const ABorderBrush, AFillBrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure EllipseInRect(ARect: TRect; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure EllipseInRect(ARect: TRect; const ABorderBrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`class procedure EraseBrush(out ABrush: TUniversalBrush; AAlpha: Word); virtual;`
This item has no description.

	`procedure EraseEllipseAntialias(x, y, rx, ry: single; AAlpha: Byte); overload; virtual;`
Erases the content of an ellipse which axes are parallel to X and Y axes

	`procedure EraseEllipseAntialias(const AOrigin, AXAxis, AYAxis: TPointF; AAlpha: Byte); overload; virtual;`
Erases the content of an ellipse with any axes

	`procedure EraseEllipseInRect(ARect: TRect; alpha: byte); virtual;`
This item has no description.

	`procedure EraseHorizLine(x,y,x2: int32or64; alpha: byte); virtual;`
This item has no description.

	`procedure EraseLine(x1, y1, x2, y2: integer; alpha: byte; DrawLastPixel: boolean); virtual;`
Erases the line from (x1,y1) to (x2,y2) using Bresenham's algorithm. ''alpha'' specifies how much to decrease. If ''alpha'' = 0, nothing is changed and if ''alpha'' = 255, all pixels become transparent. ''DrawListPixel'' specifies if (x2,y2) must be changed

	`procedure EraseLineAntialias(x1, y1, x2, y2: integer; alpha: byte; DrawLastPixel: boolean); virtual;`
Erases the line from (x1,y1) to (x2,y2) width antialiasing. ''alpha'' specifies how much to decrease. If ''alpha'' = 0, nothing is changed and if ''alpha'' = 255, all pixels become transparent. ''DrawListPixel'' specifies if (x2,y2) must be changed

	`procedure EraseLineAntialias(x1, y1, x2, y2: single; AAlpha: Byte; APenWidth: single; AClosedCap: boolean); overload; virtual;`
Erases a line from (x1,y1) to (x2,y2) using current pen style/cap/join. ''Closed'' specifies if the end of the line is roundly closed. If it is not closed, a space is left so that the next line can fit

	`procedure EraseLineAntialias(x1, y1, x2, y2: single; AAlpha: Byte; APenWidth: single); overload; virtual;`
Erases a line from (x1,y1) to (x2,y2) using current pen style/cap/join

	`procedure ErasePath(APath: IBGRAPath; const AMatrix: TAffineMatrix; AAlpha: byte; APixelCenteredCoordinates: boolean = true); overload; virtual;`
This item has no description.

	`procedure ErasePath(APath: IBGRAPath; AAlpha: Byte; APixelCenteredCoordinates: boolean = true); overload; virtual;`
This item has no description.

	`procedure ErasePathAliased(APath: IBGRAPath; const AMatrix: TAffineMatrix; alpha: byte; APixelCenteredCoordinates: boolean = true); overload;`
This item has no description.

	`procedure ErasePathAliased(APath: IBGRAPath; alpha: byte; APixelCenteredCoordinates: boolean = true); overload;`
This item has no description.

	`procedure ErasePixel(x, y: int32or64; alpha: byte); virtual;`
Erase the content of the pixel by reducing the value of the alpha channel. ''alpha'' specifies how much to decrease. If the resulting alpha reaches zero, the content is replaced by the transparent pixel

	`procedure ErasePixelF(x, y: single; alpha: byte); virtual;`
This item has no description.

	`procedure ErasePoly(const APoints: array of TPointF; alpha: byte; APixelCenteredCoordinates: boolean = true); virtual;`
This item has no description.

	`procedure ErasePolyAntialias(const APoints: array of TPointF; AAlpha: Byte; APixelCenteredCoordinates: boolean = true); overload; virtual;`
This item has no description.

	`procedure ErasePolygonOutline(const points: array of TPoint; alpha: byte);`
This item has no description.

	`procedure ErasePolygonOutlineAntialias(const APoints: array of TPointF; AAlpha: byte; APenWidth: single); overload; virtual;`
This item has no description.

	`procedure ErasePolygonOutlineAntialias(const points: array of TPoint; alpha: byte);`
This item has no description.

	`procedure ErasePolyLine(const points: array of TPoint; alpha: byte; ADrawLastPixel: boolean);`
This item has no description.

	`procedure ErasePolyLineAntialias(const APoints: array of TPointF; AAlpha: byte; APenWidth: single; AClosedCap: boolean); overload; virtual;`
This item has no description.

	`procedure ErasePolyLineAntialias(const points: array of TPoint; alpha: byte; ADrawLastPixel: boolean);`
This item has no description.

	`procedure ErasePolyLineAntialias(const APoints: array of TPointF; AAlpha: byte; APenWidth: single); overload; virtual;`
Erases a polyline using current pen style/cap/join

	`procedure ErasePolyLineAntialiasAutocycle(const APoints: array of TPointF; AAlpha: byte; APenWidth: single); overload; virtual;`
This item has no description.

	`procedure EraseRect(const ARect: TRect; alpha: byte); virtual;`
This item has no description.

	`procedure EraseRect(ALeft, ATop, ARight, ABottom: integer; alpha: byte); virtual;`
This item has no description.

	`procedure EraseRectAntialias(const ARectF: TRectF; AAlpha: Byte; APixelCenteredCoordinates: boolean = true); overload; virtual;`
This item has no description.

	`procedure EraseRectAntialias(x, y, x2, y2: single; AAlpha: Byte; APixelCenteredCoordinates: boolean = true); overload; virtual;`
This item has no description.

	`procedure EraseRoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; alpha: byte); virtual;`
This item has no description.

	`procedure EraseRoundRectAntialias(x, y, x2, y2, rx, ry: single; AAlpha: Byte; AOptions: TRoundRectangleOptions = []; APixelCenteredCoordinates: boolean = true); overload; virtual;`
This item has no description.

	`procedure EraseShape(AShape: TBGRACustomFillInfo; alpha: byte); virtual;`
This item has no description.

	`procedure EraseShapeAntialias(AShape: TBGRACustomFillInfo; AAlpha: Byte); overload; virtual;`
This item has no description.

	`procedure EraseVertLine(x, y, y2: int32or64; alpha: byte); virtual;`
This item has no description.

	`procedure Fill(ATexture: IBGRAScanner; AMode: TDrawMode); overload; virtual;`
This item has no description.

	`procedure Fill(const ABrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
Fill the whole image regardless of clipping rect

	`procedure Fill(ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word); overload; virtual;`
This item has no description.

	`procedure FillEllipseAntialias(const AOrigin, AXAxis, AYAxis: TPointF; ATexture: IBGRAScanner); overload; virtual;`
This item has no description.

	`procedure FillEllipseAntialias(const AOrigin, AXAxis, AYAxis: TPointF; const ABrush: TUniversalBrush); overload; virtual;`
Fills an ellipse with any axes

	`procedure FillEllipseAntialias(x, y, rx, ry: single; ATexture: IBGRAScanner); overload; virtual;`
This item has no description.

	`procedure FillEllipseAntialias(x, y, rx, ry: single; const ABrush: TUniversalBrush); overload; virtual;`
Fills an ellipse which axes are parallel to X and Y axes

	`procedure FillEllipseInRect(ARect: TRect; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure FillEllipseInRect(ARect: TRect; const AFillBrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure FillMask(x,y: integer; AMask: TCustomUniversalBitmap; ATexture: IBGRAScanner; AMode: TDrawMode); overload; virtual;`
This item has no description.

	`procedure FillMask(x,y: integer; AMask: TCustomUniversalBitmap; ATexture: IBGRAScanner; AMode: TDrawMode; AScanOffset: TPoint); overload; virtual;`
This item has no description.

	`procedure FillMask(x,y: integer; AMask: TCustomUniversalBitmap; ATexture: IBGRAScanner); overload; virtual;`
This item has no description.

	`procedure FillMask(x,y: integer; AMask: TCustomUniversalBitmap; const ABrush: TUniversalBrush); overload; virtual;`
This item has no description.

	`procedure FillPath(APath: IBGRAPath; const ABrush: TUniversalBrush; APixelCenteredCoordinates: boolean = true); overload; virtual;`
This item has no description.

	`procedure FillPath(APath: IBGRAPath; ATexture: IBGRAScanner; APixelCenteredCoordinates: boolean = true); overload; virtual;`
This item has no description.

	`procedure FillPath(APath: IBGRAPath; const AMatrix: TAffineMatrix; ATexture: IBGRAScanner; APixelCenteredCoordinates: boolean = true); overload; virtual;`
This item has no description.

	`procedure FillPath(APath: IBGRAPath; const AMatrix: TAffineMatrix; const ABrush: TUniversalBrush; APixelCenteredCoordinates: boolean = true); overload; virtual;`
This item has no description.

	`procedure FillPathAliased(APath: IBGRAPath; ATexture: IBGRAScanner; AMode: TDrawMode; APixelCenteredCoordinates: boolean = true; AAlpha: Word = 65535); overload;`
This item has no description.

	`procedure FillPathAliased(APath: IBGRAPath; const AMatrix: TAffineMatrix; ATexture: IBGRAScanner; AMode: TDrawMode; APixelCenteredCoordinates: boolean = true; AAlpha: Word = 65535); overload;`
This item has no description.

	`procedure FillPathAliased(APath: IBGRAPath; const ABrush: TUniversalBrush; APixelCenteredCoordinates: boolean = true; AAlpha: Word = 65535); overload;`
This item has no description.

	`procedure FillPathAliased(APath: IBGRAPath; const AMatrix: TAffineMatrix; const ABrush: TUniversalBrush; APixelCenteredCoordinates: boolean = true; AAlpha: Word = 65535); overload;`
This item has no description.

	`procedure FillPoly(const APoints: array of TPointF; ATexture: IBGRAScanner; AMode: TDrawMode; APixelCenteredCoordinates: boolean = true; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure FillPoly(const APoints: array of TPointF; const ABrush: TUniversalBrush; APixelCenteredCoordinates: boolean = true; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure FillPolyAntialias(const APoints: array of TPointF; const ABrush: TUniversalBrush; APixelCenteredCoordinates: boolean = true); overload; virtual;`
This item has no description.

procedure FillPolyAntialias(const APoints: array of TPointF; ATexture: IBGRAScanner; APixelCenteredCoordinates: boolean = true); overload; virtual;

Fills a polygon with a texture and with antialiased borders.

Texture will be repeated if smaller than output area.

fillpolyantialias_texture

procedure TForm1.FormPaint(Sender: TObject);
var image: TBGRABitmap;
    tex: TBGRABitmap;
begin
  //black background
  image := TBGRABitmap.Create(ClientWidth,ClientHeight, BGRABlack );

  tex:= TBGRABitmap.Create('image.png'); //load a bitmap
  image.FillPolyAntialias( [PointF(110,10), PointF(250,10), PointF(350,160), PointF(10,160)], tex);
  tex.Free;

  image.Draw(Canvas,0,0,True); //draw on the screen
  image.free;
end;

	`procedure FillRect(ALeft, ATop, ARight, ABottom: integer; const ABrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
Fills completely a rectangle, without any border

	`procedure FillRect(const ARect: TRect; const ABrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure FillRect(ALeft, ATop, ARight, ABottom: integer; ATexture: IBGRAScanner; AMode: TDrawMode; AScanOffset: TPoint; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure FillRect(const ARect: TRect; ATexture: IBGRAScanner; AMode: TDrawMode; AScanOffset: TPoint; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure FillRect(ALeft, ATop, ARight, ABottom: integer; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure FillRect(const ARect: TRect; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure FillRectAntialias(x, y, x2, y2: single; ATexture: IBGRAScanner; APixelCenteredCoordinates: boolean = true); overload; virtual;`
This item has no description.

	`procedure FillRectAntialias(x, y, x2, y2: single; const ABrush: TUniversalBrush; APixelCenteredCoordinates: boolean = true); overload; virtual;`
Fills a rectangle with antialiasing. Note that the pixel (x2,y2) is included contrary to integer coordinates. For example (-0.5,-0.5,0.5,0.5) with pixel-centered coords fills one pixel

	`procedure FillRectAntialias(const ARectF: TRectF; ATexture: IBGRAScanner; APixelCenteredCoordinates: boolean = true); overload; virtual;`
This item has no description.

	`procedure FillRectAntialias(const ARectF: TRectF; const ABrush: TUniversalBrush; APixelCenteredCoordinates: boolean = true); overload; virtual;`
This item has no description.

	`procedure FillRoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure FillRoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; const AFillBrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure FillRoundRectAntialias(x, y, x2, y2, rx, ry: single; ATexture: IBGRAScanner; AOptions: TRoundRectangleOptions = []; APixelCenteredCoordinates: boolean = true); overload; virtual;`
This item has no description.

	`procedure FillRoundRectAntialias(x, y, x2, y2, rx, ry: single; const ABrush: TUniversalBrush; AOptions: TRoundRectangleOptions = []; APixelCenteredCoordinates: boolean = true); overload; virtual;`
This item has no description.

	`procedure FillShape(AShape: TBGRACustomFillInfo; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); virtual;`
This item has no description.

	`procedure FillShape(AShape: TBGRACustomFillInfo; const ABrush: TUniversalBrush; AAlpha: Word = 65535); virtual;`
This item has no description.

	`procedure FillShapeAntialias(AShape: TBGRACustomFillInfo; const ABrush: TUniversalBrush); overload; virtual;`
==== Antialias fill ====

	`procedure FillShapeAntialias(AShape: TBGRACustomFillInfo; ATexture: IBGRAScanner); overload; virtual;`
This item has no description.

	`procedure FillTransparent; virtual;`
This item has no description.

	`procedure FreeReference;`
Free a reference. When the resulting reference count gets to zero, the image is freed. The initial reference count is equal to 1

	`procedure GetPixelCycleIndirect(x,y: int32or64; AColor: pointer); virtual;`
This item has no description.

	`procedure GetPixelIndirect(x,y: int32or64; AColor: pointer); virtual;`
This item has no description.

	`procedure HorizLine(x, y, x2: int32or64; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
Draws an horizontal line at line ''y'' and at columns ''x'' to ''x2'' included, using specified scanner and the specified ''AMode''

	`procedure HorizLine(x, y, x2: int32or64; const ABrush: TUniversalBrush; AAlpha: Word = 65535); virtual;`
This item has no description.

	`procedure HorizontalFlip; overload; virtual;`
This item has no description.

	`procedure HorizontalFlip(ARect: TRect); overload; virtual;`
This item has no description.

	`procedure InvalidateBitmap; virtual;`
This item has no description.

	`procedure LoadFromBitmapIfNeeded; virtual;`
call if you modify with Scanline

	`procedure LoadFromFile(const AFilename:String; AHandler:TFPCustomImageReader); overload; virtual;`
Load image from a file with the specified image reader. ''filename'' is an ANSI string

	`procedure LoadFromFile(const AFilename:String; AHandler:TFPCustomImageReader; AOptions: TBGRALoadingOptions); overload; virtual;`
This item has no description.

	`procedure LoadFromFile(const AFilename: string; AOptions: TBGRALoadingOptions); overload; virtual;`
This item has no description.

	`procedure LoadFromFile(const AFilename: string); overload; virtual;`
Load image from a file. ''filename'' is an ANSI string

	`procedure LoadFromFileUTF8(const AFilenameUTF8: string; AOptions: TBGRALoadingOptions = []); overload; virtual;`
Load image from a file. ''filename'' is an UTF8 string

	`procedure LoadFromFileUTF8(const AFilenameUTF8: string; AHandler: TFPCustomImageReader; AOptions: TBGRALoadingOptions = []); overload; virtual;`
Load image from a file with the specified image reader. ''filename'' is an UTF8 string

	`procedure LoadFromResource(AFilename: string; AHandler: TFPCustomImageReader); overload; virtual;`
Load image from an embedded Lazarus resource. The specified image reader is used

	`procedure LoadFromResource(AFilename: string; AHandler: TFPCustomImageReader; AOptions: TBGRALoadingOptions); overload; virtual;`
This item has no description.

	`procedure LoadFromResource(AFilename: string); overload; virtual;`
Load image from an embedded Lazarus resource. Format is detected automatically

	`procedure LoadFromResource(AFilename: string; AOptions: TBGRALoadingOptions); overload; virtual;`
This item has no description.

	`procedure LoadFromStream(AStream: TStream; AHandler: TFPCustomImageReader); overload; virtual;`
Load image from a stream. The specified image reader is used

	`procedure LoadFromStream(AStream: TStream; AOptions: TBGRALoadingOptions); overload; virtual;`
This item has no description.

	`procedure LoadFromStream(AStream: TStream); overload; virtual;`
Load image from a stream. Format is detected automatically

	`procedure LoadFromStream(AStream: TStream; AHandler: TFPCustomImageReader; AOptions: TBGRALoadingOptions); overload; virtual;`
This item has no description.

	`class procedure MaskBrush(out ABrush: TUniversalBrush; AScanner: IBGRAScanner; AOffsetX: integer = 0; AOffsetY: integer = 0); virtual;`
This item has no description.

	`procedure NoClip; virtual;`
Stop clipping (clipping rectangle becomes the whole image)

	`procedure PutImage(X, Y: integer; ASource: TCustomUniversalBitmap; AMode: TDrawMode; AOpacity: byte = 255); virtual;`
This item has no description.

	`procedure Rectangle(x, y, x2, y2: integer; const ABorderBrush, AFillBrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
Draw a filled rectangle with a border

	`procedure Rectangle(const ARect: TRect; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure Rectangle(const ARect: TRect; const ABrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure Rectangle(x, y, x2, y2: integer; const ABrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
Draw the border of a rectangle

	`procedure Rectangle(x, y, x2, y2: integer; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure Rectangle(const ARect: TRect; const ABorderBrush, AFillBrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure RectangleAntialias(x, y, x2, y2: single; ATexture: IBGRAScanner; AWidth: single); overload; virtual;`
This item has no description.

	`procedure RectangleAntialias(x, y, x2, y2: single; const ABrush: TUniversalBrush; AWidth: single); overload; virtual;`
This item has no description.

	`procedure RotateUDInplace; overload; virtual;`
This item has no description.

	`procedure RotateUDInplace(ARect: TRect); overload; virtual;`
This item has no description.

	`procedure RoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; const ABorderBrush, AFillBrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure RoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; const ABorderBrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure RoundRect(X1, Y1, X2, Y2: integer; DX, DY: integer; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure SaveToFile(const AFilename: string; AHandler:TFPCustomImageWriter); overload; virtual;`
Save image to a file with the specified image writer. ''filename'' is an ANSI string

	`procedure SaveToFile(const AFilename: string); overload; virtual;`
Save image to a file. The format is guessed from the file extension. ''filename'' is an ANSI string

	`procedure SaveToFileUTF8(const AFilenameUTF8: string); overload; virtual;`
Save image to a file. The format is guessed from the file extension. ''filename'' is an ANSI string

	`procedure SaveToFileUTF8(const AFilenameUTF8: string; AHandler:TFPCustomImageWriter); overload; virtual;`
Save image to a file with the specified image writer. ''filename'' is an UTF8 string

	`procedure SaveToStreamAs(AStream: TStream; AFormat: TBGRAImageFormat); virtual;`
Save image to a stream in the specified image format

	`procedure SaveToStreamAsPng(AStream: TStream); virtual;`
Save image to a stream in PNG format

procedure ScanMoveTo(X,Y: Integer); virtual;

This item has no description. Showing description inherited from IBGRAScanner.ScanMoveTo.

Move to the position (X, Y) for the next call to ScanNextPixel

	`class procedure ScannerBrush(out ABrush: TUniversalBrush; AScanner: IBGRAScanner; ADrawMode: TDrawMode = dmDrawWithTransparency; AOffsetX: integer = 0; AOffsetY: integer = 0); virtual;`
This item has no description.

	`procedure ScanNextCustomChunk(var ACount: integer; out APixels: Pointer); virtual;`
This item has no description.

	`procedure ScanNextMaskChunk(var ACount: integer; out AMask: PByteMask; out AStride: integer); virtual;`
This item has no description.

procedure ScanPutPixels(pdest: PBGRAPixel; count: integer; mode: TDrawMode); virtual;

This item has no description. Showing description inherited from IBGRAScanner.ScanPutPixels.

Copy a row of pixels from X to X + count - 1 to a specified destination pdest. mode indicates how to combine with existing data

	`procedure ScanSkipPixels(ACount: integer); virtual;`
This item has no description.

	`procedure Serialize(AStream: TStream); virtual;`
Stores the image in the stream without compression nor header

	`class procedure SerializeEmpty(AStream: TStream); static;`
Stores an empty image (of size zero)

	`procedure SetPixelIndirect(x,y: int32or64; AColor: pointer); virtual;`
This item has no description.

	`procedure SetSize(AWidth, AHeight: integer); override;`
Sets the dimension of an existing bitmap /!\ Data can be random

	`procedure SolidBrushBGRA(out ABrush: TUniversalBrush; AColor: TBGRAPixel; ADrawMode: TDrawMode = dmDrawWithTransparency); overload; virtual;`
This item has no description.

	`procedure SolidBrushBGRA(out ABrush: TUniversalBrush; ARed,AGreen,ABlue,AAlpha: Byte; ADrawMode: TDrawMode = dmDrawWithTransparency); overload; virtual;`
This item has no description.

	`procedure SolidBrushExpanded(out ABrush: TUniversalBrush; AColor: TExpandedPixel; ADrawMode: TDrawMode = dmDrawWithTransparency); overload; virtual;`
This item has no description.

	`procedure SolidBrushExpanded(out ABrush: TUniversalBrush; ARed,AGreen,ABlue,AAlpha: Word; ADrawMode: TDrawMode = dmDrawWithTransparency); overload; virtual;`
This item has no description.

	`procedure SolidBrushIndirect(out ABrush: TUniversalBrush; AColor: Pointer; ADrawMode: TDrawMode = dmDrawWithTransparency); virtual;`
This item has no description.

	`procedure VerticalFlip(ARect: TRect); overload; virtual;`
This item has no description.

	`procedure VerticalFlip; overload; virtual;`
This item has no description.

	`procedure VertLine(x, y, y2: int32or64; ATexture: IBGRAScanner; AMode: TDrawMode; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure VertLine(x, y, y2: int32or64; const ABrush: TUniversalBrush; AAlpha: Word = 65535); overload; virtual;`
This item has no description.

	`procedure AssignTransparentPixel(out ADest); virtual;`
This item has no description.

	`procedure FreeData; virtual;`
This item has no description.

	`procedure Init; virtual;`
ReadWriteConfig: TBGRAReadWriteConfig;

	`procedure InternalCopyPixels(ASource,ADest: PByte; ASourceStride,ADestStride: PtrInt; ACount: integer); virtual;`
This item has no description.

	`procedure InternalSetPixels(ASource,ADest: PByte; ADestStride: PtrInt; ACount: integer); virtual;`
This item has no description.

	`procedure InternalSwapPixels(ABuf1,ABuf2: PByte; AStride1,AStride2: PtrInt; ACount: integer); virtual;`
This item has no description.

	`procedure RaiseInvalidBrushColorspace; virtual;`
This item has no description.

	`procedure RaiseMissingUniDrawer; virtual;`
This item has no description.

	`procedure ReallocData; virtual;`
This item has no description.

	`procedure SetAntialiasingDrawMode(AValue: TDrawMode); virtual;`
This item has no description.

	`procedure SetClipRect(const AValue: TRect); virtual;`
This item has no description.

	`procedure SetInternalColor(x, y: integer; const Value: TFPColor); override;`
TFPCustomImage

	`procedure SetInternalPixel(x, y: integer; Value: integer); override;`
This item has no description.

	`procedure SetLinearAntialiasing(AValue: boolean); virtual;`
This item has no description.

	`procedure SetLineCap(AValue: TPenEndCap); virtual;`
This item has no description.

	`procedure SetLineOrder(AValue: TRawImageLineOrder); virtual;`
This item has no description.

	`procedure SetResolutionUnit(AResolutionUnit: TResolutionUnit);`
This item has no description.

Properties

	`property AntialiasingDrawMode: TDrawMode read FAntialiasingDrawMode write SetAntialiasingDrawMode;`
This item has no description.

	`property Arrow: TBGRACustomArrow read GetArrow;`
Properties of `arrow` ends

	`property ClipRect: TRect read GetClipRect write SetClipRect;`
Clipping rectangle for all drawing functions

	`property Colorspace: TColorspaceAny read FColorspace;`
This item has no description.

	`property DataByte: PByte Read GetDataBytePtr;`
Provides a pointer to the first pixel in memory. Depending on the ''LineOrder'' property, this can be the top-left pixel or the bottom-left pixel. There is no padding between scanlines. See [[BGRABitmap tutorial 4]]

	`property Empty: boolean Read CheckEmpty;`
Returns True if the bitmap only contains transparent pixels or has a size of zero

	`property HasSemiTransparentPixels: boolean Read GetHasSemiTransparentPixels;`
Returns True if there are semitransparent pixels and so if the image would be stored with an alpha channel of at least 8 bit

	`property HasTransparentPixels: boolean Read GetHasTransparentPixels;`
Returns True if there are transparent and so if the image would be stored at least with an alpha channel of 1 bit

	`property Height: integer Read GetHeight;`
`Height` of the image in pixels

	`property IsZero: boolean Read CheckIsZero;`
Returns True if the bitmap is filled with zero values or has a size of zero

	`property LinearAntialiasing: boolean read GetLinearAntialiasing write SetLinearAntialiasing;`
This item has no description.

	`property LineCap: TPenEndCap read GetLineCap write SetLineCap;`
How to draw the ends of a line (applies to arrow as well)

	`property LineOrder: TRawImageLineOrder Read GetLineOrder write SetLineOrder;`
Indicates the order in which lines are stored in memory. If it is equal to ''riloTopToBottom'', the first line is the top line. If it is equal to ''riloBottomToTop'', the first line is the bottom line. See [[BGRABitmap Miscellaneous types\|miscellaneous types]]

	`property NbPixels: integer Read GetNbPixels;`
Total number of pixels. It is always true that ''`NbPixels`'' = ''Width'' * ''Height''

	`property Pen: TBGRACustomPenStroker read GetPenStroker;`
You can use this class set `pen` style and generate strokes polygonal representations

	`property RefCount: integer Read GetRefCount;`
Number of references to this image. It is increased by the function ''NewReference'' and decreased by the function ''FreeReference''

	`property ReferenceWhite: PXYZReferenceWhite read FReferenceWhite write FReferenceWhite;`
Current reference white used for color conversion

	`property ResolutionHeight: Single read GetResolutionHeight;`
This item has no description.

	`property ResolutionUnit: TResolutionUnit read FResolutionUnit write SetResolutionUnit;`
Resolution

	`property ResolutionWidth: Single read GetResolutionWidth;`
This item has no description.

	`property ResolutionX: Single read FResolutionX write FResolutionX;`
This item has no description.

	`property ResolutionY: Single read FResolutionY write FResolutionY;`
This item has no description.

	`property RowSize: PtrInt read FRowSize;`
Size in bytes of a row of pixels

	`property ScanLineByte[y: integer]: PByte Read GetScanLineByte;`
Returns the address of the left-most pixel of any line. The parameter y ranges from 0 to Height-1

	`property Width: integer Read GetWidth;`
`Width` of the image in pixels

Getting started

Class TCustomUniversalBitmap

Unit

Declaration

Description

Hierarchy

Overview

Fields

Methods

Properties

Description

Fields

Methods

Properties