Class TBGRADefaultBitmap

Description

Hierarchy

Fields

Methods

Properties

Unit

BGRADefaultBitmap

Declaration

type TBGRADefaultBitmap = class(TBGRACustomBitmap)

Description

Base implementation for all TBGRABitmap classes.

It implements most function to the exception from implementations specific to the widgetset.

Hierarchy

Overview

Fields

	`FAlphaCorrectionNeeded: boolean;`
	`FBitmap: TBitmap;`
	`FBitmapModified: boolean;`
	`FCanvas2D: TBGRACanvas2D;`
	`FCanvasBGRA: TBGRACanvas;`
	`FCanvasDrawModeFP: TDrawMode;`
	`FCanvasFP: TFPImageCanvas;`
	`FCanvasOpacity: byte;`
	`FCanvasPixelProcFP: procedure(x, y: int32or64; const col: TBGRAPixel) of object;`
	`FDataModified: boolean;`
	`FFontHeight: integer;`
	`FFontRenderer: TBGRACustomFontRenderer;`

Methods

	`constructor Create(AFilename: string); overload; override;`
	`constructor Create(AFPImage: TFPCustomImage; ACopyProperties: Boolean=False); overload; override;`
	`constructor Create(ABitmap: TBitmap); overload; override;`
	`constructor Create(AStream: TStream); overload; override;`
	`constructor Create(AFilename: string; AIsUtf8: boolean; AOptions: TBGRALoadingOptions); overload; override;`
	`constructor Create(AFilename: string; AIsUtf8: boolean); overload; override;`
	`constructor Create(ABitmap: TBitmap; AUseTransparentColor: boolean); overload; override;`
	`destructor Destroy; override;`
	`function ComputeArc65536(x,y,rx,ry: single; start65536,end65536: word; quality: single = 1): ArrayOfTPointF; override;`
	`function ComputeArcRad(x,y,rx,ry: single; startRad,endRad: single; quality: single = 1): ArrayOfTPointF; override;`
	`function ComputeBezierCurve(const ACurve: TQuadraticBezierCurve): ArrayOfTPointF; overload; override;`
	`function ComputeBezierCurve(const ACurve: TCubicBezierCurve): ArrayOfTPointF; overload; override;`
	`function ComputeBezierSpline(const ASpline: array of TQuadraticBezierCurve): ArrayOfTPointF; overload; override;`
	`function ComputeBezierSpline(const ASpline: array of TCubicBezierCurve): ArrayOfTPointF; overload; override;`
	`function ComputeClosedSpline(const APoints: array of TPointF; AStyle: TSplineStyle): ArrayOfTPointF; override;`
	`function ComputeEllipseBorder(x,y,rx,ry,w: single; quality: single = 1): ArrayOfTPointF; overload; override;`
	`function ComputeEllipseBorder(AOrigin, AXAxis, AYAxis: TPointF; w: single; quality: single = 1): ArrayOfTPointF; override; overload;`
	`function ComputeEllipseContour(x,y,rx,ry: single; quality: single = 1): ArrayOfTPointF; overload; override;`
	`function ComputeEllipseContour(AOrigin, AXAxis, AYAxis: TPointF; quality: single = 1): ArrayOfTPointF; overload; override;`
	`function ComputeOpenedSpline(const APoints: array of TPointF; AStyle: TSplineStyle): ArrayOfTPointF; override;`
	`function ComputePie65536(x,y,rx,ry: single; start65536,end65536: word; quality: single = 1): ArrayOfTPointF; override;`
	`function ComputePieRad(x,y,rx,ry: single; startRad,endRad: single; quality: single = 1): ArrayOfTPointF; override;`
	`function ComputeRoundRect(x1,y1,x2,y2,rx,ry: single; quality: single = 1): ArrayOfTPointF; overload; override;`
	`function ComputeRoundRect(x1,y1,x2,y2,rx,ry: single; options: TRoundRectangleOptions; quality: single = 1): ArrayOfTPointF; overload; override;`
	`function ComputeWidePolygon(const points: array of TPointF; w: single): ArrayOfTPointF; overload; override;`
	`function ComputeWidePolyline(const points: array of TPointF; w: single; ClosedCap: boolean): ArrayOfTPointF; overload; override;`
	`function ComputeWidePolyline(const points: array of TPointF; w: single): ArrayOfTPointF; overload; override;`
	`function FilterAffine(AMatrix: TAffineMatrix; correctBlur: boolean = false; ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
	`function FilterContour(AGammaCorrection: boolean = false; ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
	`function FilterCylinder(ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
	`function FilterEmboss(angle: single; ABounds: TRect; AStrength: integer= 64; AOptions: TEmbossOptions = []; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
	`function FilterEmboss(angle: single; AStrength: integer= 64; AOptions: TEmbossOptions = []; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
	`function FilterEmbossHighlight(FillSelection: boolean; BorderColor: TBGRAPixel; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
	`function FilterEmbossHighlight(FillSelection: boolean; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
	`function FilterEmbossHighlight(FillSelection: boolean; BorderColor: TBGRAPixel; var Offset: TPoint; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
	`function FilterGrayscale(ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
	`function FilterGrayscale(ABounds: TRect; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
	`function FilterMedian(Option: TMedianOption; ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
	`function FilterNormalize(ABounds: TRect; eachChannel: boolean = True; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
	`function FilterNormalize(eachChannel: boolean = True; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
	`function FilterPixelate(pixelSize: integer; useResample: boolean; filter: TResampleFilter = rfLinear; ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
	`function FilterPlane(ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
	`function FilterRotate(origin: TPointF; angle: single; correctBlur: boolean = false; ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
	`function FilterSharpen(Amount: single = 1; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
	`function FilterSharpen(ABounds: TRect; Amount: single = 1; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
	`function FilterSmartZoom3(Option: TMedianOption; ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
	`function FilterSmooth(ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
	`function FilterSphere(ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
	`function FilterTwirl(ABounds: TRect; ACenter: TPoint; ARadius: Single; ATurn: Single=1; AExponent: Single=3; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
	`function FilterTwirl(ACenter: TPoint; ARadius: Single; ATurn: Single=1; AExponent: Single=3; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
	`function GetGrayscaleMaskFromAlpha: TGrayscaleMask;`
	`function GetImageAffineBounds(AMatrix: TAffineMatrix; ASourceBounds: TRect; AClipOutput: boolean = true; APixelCenteredCoords: boolean = true): TRect; overload; override;`
	`function GetMaskFromAlpha: TBGRADefaultBitmap; override;`
	`function GetPixel(x, y: single; AResampleFilter: TResampleFilter = rfLinear; smoothBorder: boolean = true): TBGRAPixel; overload; override;`
	`function GetPixel256(x, y, fracX256,fracY256: int32or64; AResampleFilter: TResampleFilter = rfLinear; smoothBorder: boolean = true): TBGRAPixel; override;`
	`function GetPixelCycle(x, y: single; AResampleFilter: TResampleFilter; repeatX: boolean; repeatY: boolean): TBGRAPixel; overload; override;`
	`function GetPixelCycle(x, y: single; AResampleFilter: TResampleFilter = rfLinear): TBGRAPixel; overload; override;`
	`function GetPixelCycle256(x, y, fracX256,fracY256: int32or64; AResampleFilter: TResampleFilter; repeatX: boolean; repeatY: boolean): TBGRAPixel; overload; override;`
	`function GetPixelCycle256(x, y, fracX256,fracY256: int32or64; AResampleFilter: TResampleFilter = rfLinear): TBGRAPixel; overload; override;`
	`function GetPtrBitmap(Top,Bottom: Integer): TBGRACustomBitmap; override;`
	`class function IsAffineRoughlyTranslation(AMatrix: TAffineMatrix; ASourceBounds: TRect): boolean; override;`
	`function IsScanPutPixelsDefined: boolean; override;`
	`function MakeBitmapCopy(BackgroundColor: TColor; AMasked: boolean = False): TBitmap; override;`
	`function NewBitmap(AWidth, AHeight: integer): TBGRADefaultBitmap; overload; override;`
	`function NewBitmap: TBGRADefaultBitmap; overload; override;`
	`function NewBitmap(AWidth, AHeight: integer; AColor: Pointer): TBGRADefaultBitmap; overload; override;`
	`function NewBitmap(AWidth, AHeight: integer; const Color: TBGRAPixel): TBGRADefaultBitmap; overload; override;`
	`function NewBitmap(Filename: string; AIsUtf8: boolean; AOptions: TBGRALoadingOptions): TBGRADefaultBitmap; overload; override;`
	`function NewBitmap(AFPImage: TFPCustomImage): TBGRADefaultBitmap; overload; override;`
	`function NewBitmap(Filename: string): TBGRADefaultBitmap; overload; override;`
	`function NewBitmap(Filename: string; AIsUtf8: boolean): TBGRADefaultBitmap; overload; override;`
	`function Resample(newWidth, newHeight: integer; mode: TResampleMode = rmFineResample; ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
	`function ScanAt(X,Y: Single): TBGRAPixel; override;`
	`function ScanAtInteger(X,Y: integer): TBGRAPixel; override;`
	`function ScanNextPixel: TBGRAPixel; override;`
	`function TextAffineBox(const sUTF8: string): TAffineBox; override;`
	`function TextFitInfo(const sUTF8: string; AMaxWidth: integer): integer; override;`
	`function TextSize(const sUTF8: string): TSize; override;`
	`function TextSize(const sUTF8: string; AMaxWidth: integer; ARightToLeft: boolean): TSize; override;`
	`function TextSize(const sUTF8: string; AMaxWidth: integer): TSize; override;`
	`function TextSizeMultiline(const sUTF8: string; AMaxWidth: single = EmptySingle; AParagraphSpacing: single = 0): TSize; override;`
	`function CheckEmpty: boolean; override;`
	`function CreateDefaultFontRenderer: TBGRACustomFontRenderer; virtual; abstract;`
	`function CreatePtrBitmap(AWidth,AHeight: integer; AData: PBGRAPixel): TBGRAPtrBitmap; virtual;`
	`function FineResample(NewWidth, NewHeight: integer): TBGRACustomBitmap;`
	`function GetArrowEndOffset: single; override;`
	`function GetArrowEndRepeat: integer; override;`
	`function GetArrowEndSize: TPointF; override;`
	`function GetArrowStartOffset: single; override;`
	`function GetArrowStartRepeat: integer; override;`
	`function GetArrowStartSize: TPointF; override;`
	`function GetAverageColor: TColor; override;`
	`function GetAveragePixel: TBGRAPixel; override;`
	`function GetBitmap: TBitmap; override;`
	`function GetCanvas: TCanvas; override;`
	`function GetCanvasAlphaCorrection: boolean; override;`
	`function GetCanvasDrawModeFP: TDrawMode; override;`
	`function GetCanvasFP: TFPImageCanvas; override;`
	`function GetCanvasOpacity: byte; override;`
	`function GetCustomPenStyle: TBGRAPenStyle; override;`
	`function GetFontAnchorRotatedOffset(ACustomOrientation: integer): TPointF; overload;`
	`function GetFontAnchorRotatedOffset: TPointF; overload;`
	`function GetFontFullHeight: integer; override;`
	`function GetFontHeight: integer; override;`
	`function GetFontPixelMetric: TFontPixelMetric; override;`
	`function GetFontRenderer: TBGRACustomFontRenderer; override;`
	`function GetFontVerticalAnchorOffset: single; override;`
	`function GetHasSemiTransparentPixels: boolean; override;`
	`function GetHasTransparentPixels: boolean; override;`
	`function GetInternalColor(x, y: integer): TFPColor; override;`
	`function GetInternalPixel(x, y: integer): integer; override;`
	`function GetPenJoinStyle: TPenJoinStyle; override;`
	`function GetPenMiterLimit: single; override;`
	`function GetPenStyle: TPenStyle; override;`
	`function InternalGetPixel256(ix,iy: int32or64; iFactX,iFactY: int32or64; smoothBorder: boolean): TBGRAPixel;`
	`function InternalGetPixelCycle256(ix,iy: int32or64; iFactX,iFactY: int32or64): TBGRAPixel;`
	`function InternalNew: TBGRADefaultBitmap; override;`
	`function LoadFromRawImage(ARawImage: TRawImage; DefaultOpacity: byte; AlwaysReplaceAlpha: boolean = False; RaiseErrorOnInvalidPixelFormat: boolean = True): boolean; virtual; abstract;`
	`function SimpleStretch(NewWidth, NewHeight: integer): TBGRACustomBitmap;`
	`class procedure AlphaBrush(out ABrush: TUniversalBrush; AAlpha: Word); override;`
	`procedure AlphaFill(alpha: byte; start, Count: integer); overload; override;`
	`procedure AlphaHorizLine(x, y, x2: int32or64; alpha: byte); override;`
	`procedure AlphaPixel(x, y: int32or64; alpha: byte); override;`
	`procedure AlphaToGrayscale; override;`
	`procedure AlphaVertLine(x, y, y2: int32or64; alpha: byte); override;`
	`procedure ArrowEndAsClassic(AFlipped: boolean = false; ACut: boolean = false; ARelativePenWidth: single = 1); override;`
	`procedure ArrowEndAsNone; override;`
	`procedure ArrowEndAsTail; override;`
	`procedure ArrowEndAsTriangle(ABackOffset: single = 0; ARounded: boolean = false; AHollow: boolean = false; AHollowPenWidth: single = 0.5); override;`
	`procedure ArrowStartAsClassic(AFlipped: boolean = false; ACut: boolean = false; ARelativePenWidth: single = 1); override;`
	`procedure ArrowStartAsNone; override;`
	`procedure ArrowStartAsTail; override;`
	`procedure ArrowStartAsTriangle(ABackOffset: single = 0; ARounded: boolean = false; AHollow: boolean = false; AHollowPenWidth: single = 0.5); override;`
	`procedure Assign(Source: TPersistent); overload; override;`
	`procedure Assign(Source: TPersistent; ACopyProperties: Boolean); overload; override;`
	`procedure Assign(Source: TBitmap; AUseTransparentColor: boolean); overload;`
	`procedure AssignWithFixedTransparent(Source: TBitmap); overload;`
	`procedure BlendImage(x, y: integer; ASource: TBGRACustomBitmap; AOperation: TBlendOperation); overload; override;`
	`procedure BlendImage(ADest: TRect; ASource: IBGRAScanner; AOffsetX, AOffsetY: integer; AOperation: TBlendOperation); overload; override;`
	`procedure BlendImageOver(ADest: TRect; ASource: IBGRAScanner; AOffsetX, AOffsetY: integer; AOperation: TBlendOperation; AOpacity: byte = 255; ALinearBlend: boolean = false); overload; override;`
	`procedure BlendImageOver(x, y: integer; ASource: TBGRACustomBitmap; AOperation: TBlendOperation; AOpacity: byte = 255; ALinearBlend: boolean = false); overload; override;`
	`procedure BlendRect(ADest: TRect; AColor: TBGRAPixel; AOperation: TBlendOperation; AExcludeChannels: TChannels); overload; override;`
	`procedure BlendRectOver(ADest: TRect; AColor: TBGRAPixel; AOperation: TBlendOperation; AOpacity: byte; ALinearBlend: boolean; AExcludeChannels: TChannels); overload; override;`
	`procedure ClearTransparentPixels; override;`
	`procedure ConvertFromLinearRGB; override;`
	`procedure ConvertToLinearRGB; override;`
	`procedure CrossFade(ARect: TRect; Source1, Source2: IBGRAScanner; AFadePosition: byte; mode: TDrawMode = dmDrawWithTransparency); overload; override;`
	`procedure CrossFade(ARect: TRect; Source1, Source2: IBGRAScanner; AFadeMask: IBGRAScanner; mode: TDrawMode = dmDrawWithTransparency); overload; override;`
	`procedure Deserialize(AStream: TStream); override;`
	`procedure Draw(ACanvas: TCanvas; x, y: integer; Opaque: boolean = True); overload; override;`
	`procedure Draw(ACanvas: TCanvas; Rect: TRect; Opaque: boolean = True); overload; override;`
	`procedure DrawHorizLine(x, y, x2: int32or64; ec: TExpandedPixel); override; overload;`
	`procedure DrawHorizLineDiff(x, y, x2: int32or64; c, compare: TBGRAPixel; maxDiff: byte); override;`
	`procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeTexture: IBGRAScanner; AWidth: single; AFillColor: TBGRAPixel); overload; override;`
	`procedure DrawPath(APath: IBGRAPath; AStrokeColor: TBGRAPixel; AWidth: single; AFillTexture: IBGRAScanner); overload; override;`
	`procedure DrawPath(APath: IBGRAPath; AStrokeTexture: IBGRAScanner; AWidth: single; AFillColor: TBGRAPixel); overload; override;`
	`procedure DrawPath(APath: IBGRAPath; AStrokeColor: TBGRAPixel; AWidth: single; AFillColor: TBGRAPixel); overload; override;`
	`procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeColor: TBGRAPixel; AWidth: single; AFillColor: TBGRAPixel); overload; override;`
	`procedure DrawPath(APath: IBGRAPath; AStrokeTexture: IBGRAScanner; AWidth: single; AFillTexture: IBGRAScanner); overload; override;`
	`procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeTexture: IBGRAScanner; AWidth: single; AFillTexture: IBGRAScanner); overload; override;`
	`procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeColor: TBGRAPixel; AWidth: single; AFillTexture: IBGRAScanner); overload; override;`
	`procedure DrawPixel(x, y: int32or64; const c: TBGRAPixel); overload; override;`
	`procedure DrawPixels(c: TBGRAPixel; start, Count: integer); override;`
	`procedure DrawPolygonAntialias(const points: array of TPointF; c: TBGRAPixel; w: single; fillcolor: TBGRAPixel); overload; override;`
	`procedure DrawPolyLineAntialias(const points: array of TPointF; c: TBGRAPixel; w: single; fillcolor: TBGRAPixel); overload; override;`
	`procedure DrawVertLine(x, y, y2: int32or64; c: TBGRAPixel); override;`
	`procedure EllipseAntialias(x, y, rx, ry: single; c: TBGRAPixel; w: single; back: TBGRAPixel); overload; override;`
	`procedure EllipseAntialias(AOrigin, AXAxis, AYAxis: TPointF; c: TBGRAPixel; w: single; back: TBGRAPixel); overload; override;`
	`class procedure EraseBrush(out ABrush: TUniversalBrush; AAlpha: Word); override;`
	`procedure EraseMask(x,y: integer; AMask: TBGRACustomBitmap; alpha: byte=255); override;`
	`procedure ErasePixel(x, y: int32or64; alpha: byte); override;`
	`procedure FastBlendHorizLine(x, y, x2: int32or64; c: TBGRAPixel); override;`
	`procedure FastBlendPixel(x, y: int32or64; const c: TBGRAPixel); override;`
	`procedure FastBlendVertLine(x, y, y2: int32or64; c: TBGRAPixel); override;`
	`procedure Fill(c: TBGRAPixel; start, Count: integer); overload; override;`
	`procedure FillClearTypeMask(x,y: integer; xThird: integer; AMask: TBGRACustomBitmap; texture: IBGRAScanner; ARGBOrder: boolean = true); override;`
	`procedure FillClearTypeMask(x,y: integer; xThird: integer; AMask: TBGRACustomBitmap; color: TBGRAPixel; ARGBOrder: boolean = true); override;`
	`procedure FillEllipseLinearColorAntialias(AOrigin, AXAxis, AYAxis: TPointF; outercolor, innercolor: TBGRAPixel); overload; override;`
	`procedure FillEllipseLinearColorAntialias(x, y, rx, ry: single; outercolor, innercolor: TBGRAPixel); overload; override;`
	`procedure FillMask(x,y: integer; AMask: TCustomUniversalBitmap; ATexture: IBGRAScanner; ADrawMode: TDrawMode; AOpacity: byte); overload; override;`
	`procedure FillMask(x,y: integer; AMask: TCustomUniversalBitmap; const AColor: TBGRAPixel; ADrawMode: TDrawMode); overload; override;`
	`procedure FillPolyLinearColor(const points: array of TPointF; AColors: array of TBGRAPixel); override;`
	`procedure FillPolyLinearMapping(const points: array of TPointF; texture: IBGRAScanner; texCoords: array of TPointF; TextureInterpolation: Boolean); override;`
	`procedure FillPolyLinearMappingLightness(const points: array of TPointF; texture: IBGRAScanner; texCoords: array of TPointF; lightnesses: array of word; TextureInterpolation: Boolean); override;`
	`procedure FillPolyPerspectiveMapping(const points: array of TPointF; const pointsZ: array of single; texture: IBGRAScanner; texCoords: array of TPointF; TextureInterpolation: Boolean; zbuffer: psingle = nil); override;`
	`procedure FillPolyPerspectiveMappingLightness(const points: array of TPointF; const pointsZ: array of single; texture: IBGRAScanner; texCoords: array of TPointF; lightnesses: array of word; TextureInterpolation: Boolean; zbuffer: psingle = nil); override;`
	`procedure FillQuadAffineMapping(Orig,HAxis,VAxis: TPointF; AImage: TBGRACustomBitmap; APixelCenteredCoordinates: boolean = true; ADrawMode: TDrawMode = dmDrawWithTransparency; AOpacity: byte = 255); override;`
	`procedure FillQuadAffineMappingAntialias(Orig,HAxis,VAxis: TPointF; AImage: TBGRACustomBitmap; APixelCenteredCoordinates: boolean = true; AOpacity: byte = 255); override;`
	`procedure FillQuadLinearColor(pt1,pt2,pt3,pt4: TPointF; c1,c2,c3,c4: TBGRAPixel); override;`
	`procedure FillQuadLinearColorAntialias(pt1,pt2,pt3,pt4: TPointF; c1,c2,c3,c4: TBGRAPixel); override;`
	`procedure FillQuadLinearMapping(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; TextureInterpolation: Boolean= True; ACulling: TFaceCulling = fcNone; ACropToPolygon: boolean = true); override;`
	`procedure FillQuadLinearMappingAntialias(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; ACulling: TFaceCulling = fcNone); override;`
	`procedure FillQuadLinearMappingLightness(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; light1,light2,light3,light4: word; TextureInterpolation: Boolean= True); override;`
	`procedure FillQuadPerspectiveMapping(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; ACleanBorders: TRect; ADrawMode: TDrawMode = dmDrawWithTransparency); override;`
	`procedure FillQuadPerspectiveMapping(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; ADrawMode: TDrawMode = dmDrawWithTransparency); override;`
	`procedure FillQuadPerspectiveMappingAntialias(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF); override;`
	`procedure FillQuadPerspectiveMappingAntialias(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; ACleanBorders: TRect); override;`
	`procedure FillRect(x, y, x2, y2: integer; texture: IBGRAScanner; mode: TDrawMode; AScanOffset: TPoint; ditheringAlgorithm: TDitheringAlgorithm); overload; override;`
	`procedure FillTriangleLinearColor(pt1,pt2,pt3: TPointF; c1,c2,c3: TBGRAPixel); override;`
	`procedure FillTriangleLinearColorAntialias(pt1,pt2,pt3: TPointF; c1,c2,c3: TBGRAPixel); override;`
	`procedure FillTriangleLinearMapping(pt1,pt2,pt3: TPointF; texture: IBGRAScanner; tex1, tex2, tex3: TPointF; TextureInterpolation: Boolean= True); override;`
	`procedure FillTriangleLinearMappingAntialias(pt1,pt2,pt3: TPointF; texture: IBGRAScanner; tex1, tex2, tex3: TPointF); override;`
	`procedure FillTriangleLinearMappingLightness(pt1,pt2,pt3: TPointF; texture: IBGRAScanner; tex1, tex2, tex3: TPointF; light1,light2,light3: word; TextureInterpolation: Boolean= True); override;`
	`procedure GradientFill(x, y, x2, y2: integer; gradient: TBGRACustomGradient; gtype: TGradientType; o1, o2: TPointF; mode: TDrawMode; Sinus: Boolean=False; ditherAlgo: TDitheringAlgorithm = daNearestNeighbor); override;`
	`procedure GradientFill(x, y, x2, y2: integer; c1, c2: TBGRAPixel; gtype: TGradientType; o1, o2: TPointF; mode: TDrawMode; gammaColorCorrection: boolean = True; Sinus: Boolean=False; ditherAlgo: TDitheringAlgorithm = daNearestNeighbor); override;`
	`procedure GrayscaleToAlpha; override;`
	`procedure HorizLineDiff(x, y, x2: int32or64; const ABrush: TUniversalBrush; ACompare: TBGRAPixel; AMaxDiffW: word); override;`
	`procedure InplaceGrayscale(ABounds: TRect; AGammaCorrection: boolean = true); overload; override;`
	`procedure InplaceGrayscale(AGammaCorrection: boolean = true); overload; override;`
	`procedure InplaceNormalize(ABounds: TRect; AEachChannel: boolean = True); overload; override;`
	`procedure InplaceNormalize(AEachChannel: boolean = True); overload; override;`
	`procedure InvalidateBitmap; override;`
	`procedure LinearNegative; override;`
	`procedure LinearNegativeRect(ABounds: TRect); override;`
	`procedure LoadFromBitmapIfNeeded; override;`
	`class procedure MaskBrush(out ABrush: TUniversalBrush; AScanner: IBGRAScanner; AOffsetX: integer = 0; AOffsetY: integer = 0); override;`
	`procedure Negative; override;`
	`procedure NegativeRect(ABounds: TRect); override;`
	`procedure NotifyBitmapChange; inline;`
	`procedure ParallelFloodFill(X, Y: integer; Dest: TCustomUniversalBitmap; Color: TBGRAPixel; mode: TFloodfillMode; Tolerance: byte = 0; DestOfsX: integer = 0; DestOfsY: integer = 0); overload; override;`
	`procedure ParallelFloodFill(X, Y: integer; Dest: TCustomUniversalBitmap; const Brush: TUniversalBrush; Progressive: boolean; ToleranceW: Word = $00ff; DestOfsX: integer = 0; DestOfsY: integer = 0); overload; override;`
	`procedure PutImage(X, Y: integer; ASource: TCustomUniversalBitmap; AMode: TDrawMode; AOpacity: byte); overload; override;`
	`procedure PutImageAffine(AMatrix: TAffineMatrix; Source: TBGRACustomBitmap; AOutputBounds: TRect; AResampleFilter: TResampleFilter; AMode: TDrawMode; AOpacity: Byte=255; APixelCenteredCoords: boolean = true); overload; override;`
	`procedure RectangleAntialias(x, y, x2, y2: single; c: TBGRAPixel; w: single; back: TBGRAPixel); overload; override;`
	`procedure ReplaceColor(ABounds: TRect; before, after: TColor); overload; override;`
	`procedure ReplaceColor(before, after: TColor); overload; override;`
	`procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; pencolor: TBGRAPixel; w: single; fillcolor: TBGRAPixel; options: TRoundRectangleOptions = []); overload; override;`
	`procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; penTexture: IBGRAScanner; w: single; fillTexture: IBGRAScanner; options: TRoundRectangleOptions = []); overload; override;`
	`procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; c: TBGRAPixel; w: single; options: TRoundRectangleOptions = []); overload; override;`
	`procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; texture: IBGRAScanner; w: single; options: TRoundRectangleOptions = []); overload; override;`
	`class procedure ScannerBrush(out ABrush: TUniversalBrush; AScanner: IBGRAScanner; ADrawMode: TDrawMode = dmDrawWithTransparency; AOffsetX: integer = 0; AOffsetY: integer = 0); override;`
	`procedure ScanPutPixels(pdest: PBGRAPixel; count: integer; mode: TDrawMode); override;`
	`procedure Serialize(AStream: TStream); override;`
	`procedure SetPixel(x, y: int32or64; c: TColor); overload; override;`
	`procedure SetSize(AWidth, AHeight: integer); override;`
	`class procedure SolidBrush(out ABrush: TUniversalBrush; const AColor: TBGRAPixel; ADrawMode: TDrawMode = dmDrawWithTransparency); override;`
	`procedure SolidBrushIndirect(out ABrush: TUniversalBrush; AColor: Pointer; ADrawMode: TDrawMode = dmDrawWithTransparency); override;`
	`procedure StretchPutImage(ARect: TRect; Source: TBGRACustomBitmap; mode: TDrawMode; AOpacity: byte = 255); override;`
	`procedure SwapRedBlue; override;`
	`procedure SwapRedBlue(ARect: TRect); override;`
	`procedure TextMultiline(ALeft,ATop,AWidth: single; const sUTF8: string; ATexture: IBGRAScanner; AAlign: TBidiTextAlignment = btaNatural; AVertAlign: TTextLayout = tlTop; AParagraphSpacing: single = 0); overload; override;`
	`procedure TextMultiline(ALeft,ATop,AWidth: single; const sUTF8: string; c: TBGRAPixel; AAlign: TBidiTextAlignment = btaNatural; AVertAlign: TTextLayout = tlTop; AParagraphSpacing: single = 0); overload; override;`
	`procedure TextOut(x, y: single; const sUTF8: string; ATexture: IBGRAScanner; AAlign: TAlignment; ALetterSpacing: single); overload; override;`
	`procedure TextOut(x, y: single; const sUTF8: string; c: TBGRAPixel; align: TAlignment; ARightToLeft: boolean); overload; override;`
	`procedure TextOut(x, y: single; const sUTF8: string; texture: IBGRAScanner; align: TAlignment; ARightToLeft: boolean); overload; override;`
	`procedure TextOut(x, y: single; const sUTF8: string; AColor: TBGRAPixel; AAlign: TAlignment; ALetterSpacing: single); overload; override;`
	`procedure TextOutAngle(x, y: single; orientationTenthDegCCW: integer; const sUTF8: string; texture: IBGRAScanner; align: TAlignment; ARightToLeft: boolean); overload; override;`
	`procedure TextOutAngle(x, y: single; orientationTenthDegCCW: integer; const sUTF8: string; c: TBGRAPixel; align: TAlignment; ARightToLeft: boolean); overload; override;`
	`procedure TextOutCurved(ACursor: TBGRACustomPathCursor; const sUTF8: string; ATexture: IBGRAScanner; AAlign: TAlignment; ALetterSpacing: single); overload; override;`
	`procedure TextOutCurved(ACursor: TBGRACustomPathCursor; const sUTF8: string; AColor: TBGRAPixel; AAlign: TAlignment; ALetterSpacing: single); overload; override;`
	`procedure TextRect(ARect: TRect; x, y: integer; const sUTF8: string; style: TTextStyle; c: TBGRAPixel); overload; override;`
	`procedure TextRect(ARect: TRect; x, y: integer; const sUTF8: string; style: TTextStyle; texture: IBGRAScanner); overload; override;`
	`procedure XorHorizLine(x, y, x2: int32or64; c: TBGRAPixel); override;`
	`procedure XorPixel(x, y: int32or64; const c: TBGRAPixel); override;`
	`procedure XorVertLine(x, y, y2: int32or64; c: TBGRAPixel); override;`
	`procedure DiscardBitmapChange; inline;`
	`procedure DoAlphaCorrection;`
	`procedure DoLoadFromBitmap; virtual;`
	`procedure FreeBitmap; virtual;`
	`procedure Init; override;`
	`procedure InternalArc(cx,cy,rx,ry: single; StartAngleRad,EndAngleRad: Single; ABorderColor: TBGRAPixel; w: single; AFillColor: TBGRAPixel; AOptions: TArcOptions; ADrawChord: boolean = false; ATexture: IBGRAScanner = nil); override;`
	`procedure InternalCrossFade(ARect: TRect; Source1, Source2: IBGRAScanner; AFadePos: byte; AFadeMask: IBGRAScanner; mode: TDrawMode = dmDrawWithTransparency);`
	`procedure InternalTextOutCurved(ACursor: TBGRACustomPathCursor; sUTF8: string; AColor: TBGRAPixel; ATexture: IBGRAScanner; AAlign: TAlignment; ALetterSpacing: single);`
	`procedure InternalTextOutLetterSpacing(x,y: single; sUTF8: string; AColor: TBGRAPixel; ATexture: IBGRAScanner; AAlign: TAlignment; ALetterSpacing: single);`
	`procedure InternalTextOutOffset(x, y: single; const sUTF8: string; AColor: TBGRAPixel; ATexture: IBGRAScanner; AOffsets: array of TPointF); override;`
	`procedure RebuildBitmap; virtual; abstract;`
	`procedure SetArrowEndOffset(AValue: single); override;`
	`procedure SetArrowEndRepeat(AValue: integer); override;`
	`procedure SetArrowEndSize(AValue: TPointF); override;`
	`procedure SetArrowStartOffset(AValue: single); override;`
	`procedure SetArrowStartRepeat(AValue: integer); override;`
	`procedure SetArrowStartSize(AValue: TPointF); override;`
	`procedure SetCanvasAlphaCorrection(const AValue: boolean); override;`
	`procedure SetCanvasDrawModeFP(const AValue: TDrawMode); override;`
	`procedure SetCanvasOpacity(AValue: byte); override;`
	`procedure SetCustomPenStyle(const AValue: TBGRAPenStyle); override;`
	`procedure SetFontFullHeight(AHeight: integer); override;`
	`procedure SetFontHeight(AHeight: integer); override;`
	`procedure SetFontRenderer(AValue: TBGRACustomFontRenderer); override;`
	`procedure SetInternalColor(x, y: integer; const Value: TFPColor); override;`
	`procedure SetInternalPixel(x, y: integer; Value: integer); override;`
	`procedure SetPenJoinStyle(const AValue: TPenJoinStyle); override;`
	`procedure SetPenMiterLimit(const AValue: single); override;`
	`procedure SetPenStyle(const AValue: TPenStyle); override;`

Properties

	`property Canvas2D: TBGRACanvas2D read GetCanvas2D;`
	`property CanvasBGRA: TBGRACanvas read GetCanvasBGRA;`

Description

Fields

	`FAlphaCorrectionNeeded: boolean;`
opacity used with standard canvas functions

	`FBitmap: TBitmap;`
if data image has changed so TBitmap should be updated GUI bitmap object

	`FBitmapModified: boolean;`
This item has no description.

	`FCanvas2D: TBGRACanvas2D;`
This item has no description.

	`FCanvasBGRA: TBGRACanvas;`
canvas-like with antialiasing and texturing

	`FCanvasDrawModeFP: TDrawMode;`
This item has no description.

	`FCanvasFP: TFPImageCanvas;`
the alpha channel is not correct because standard functions do not take it into account FreePascal drawing routines

	`FCanvasOpacity: byte;`
if TBitmap has changed so pixel data should be updated

	`FCanvasPixelProcFP: procedure(x, y: int32or64; const col: TBGRAPixel) of object;`
This item has no description.

	`FDataModified: boolean;`
Pixel data

	`FFontHeight: integer;`
drawing options

	`FFontRenderer: TBGRACustomFontRenderer;`
This item has no description.

Methods

	`constructor Create(AFilename: string); overload; override;`
Creates an image by loading its content from the file ''AFilename''. The encoding of the string is the default one for the operating system. It is recommended to use the next constructor and UTF8 encoding

	`constructor Create(AFPImage: TFPCustomImage; ACopyProperties: Boolean=False); overload; override;`
Creates an image by copying the content of a ''TFPCustomImage''

	`constructor Create(ABitmap: TBitmap); overload; override;`
Creates an image by copying the content of a ''TBitmap'', apply transparent color if specified and bitmap is masked

	`constructor Create(AStream: TStream); overload; override;`
Creates an image by loading its content from the stream ''AStream''

	`constructor Create(AFilename: string; AIsUtf8: boolean; AOptions: TBGRALoadingOptions); overload; override;`
This item has no description.

	`constructor Create(AFilename: string; AIsUtf8: boolean); overload; override;`
Creates an image by loading its content from the file ''AFilename''. The boolean ''AIsUtf8Filename'' specifies if UTF8 encoding is assumed for the filename

	`constructor Create(ABitmap: TBitmap; AUseTransparentColor: boolean); overload; override;`
Creates an image by copying the content of a ''TBitmap'', enforce/disable use of transparent color

	`destructor Destroy; override;`
Free the object and all its resources

	`function ComputeArc65536(x,y,rx,ry: single; start65536,end65536: word; quality: single = 1): ArrayOfTPointF; override;`
This item has no description.

	`function ComputeArcRad(x,y,rx,ry: single; startRad,endRad: single; quality: single = 1): ArrayOfTPointF; override;`
This item has no description.

	`function ComputeBezierCurve(const ACurve: TQuadraticBezierCurve): ArrayOfTPointF; overload; override;`
This item has no description.

	`function ComputeBezierCurve(const ACurve: TCubicBezierCurve): ArrayOfTPointF; overload; override;`
This item has no description.

	`function ComputeBezierSpline(const ASpline: array of TQuadraticBezierCurve): ArrayOfTPointF; overload; override;`
This item has no description.

	`function ComputeBezierSpline(const ASpline: array of TCubicBezierCurve): ArrayOfTPointF; overload; override;`
This item has no description.

	`function ComputeClosedSpline(const APoints: array of TPointF; AStyle: TSplineStyle): ArrayOfTPointF; override;`
Spline

	`function ComputeEllipseBorder(x,y,rx,ry,w: single; quality: single = 1): ArrayOfTPointF; overload; override;`
This item has no description.

	`function ComputeEllipseBorder(AOrigin, AXAxis, AYAxis: TPointF; w: single; quality: single = 1): ArrayOfTPointF; override; overload;`
This item has no description.

	`function ComputeEllipseContour(x,y,rx,ry: single; quality: single = 1): ArrayOfTPointF; overload; override;`
This item has no description.

	`function ComputeEllipseContour(AOrigin, AXAxis, AYAxis: TPointF; quality: single = 1): ArrayOfTPointF; overload; override;`
This item has no description.

function ComputeOpenedSpline(const APoints: array of TPointF; AStyle: TSplineStyle): ArrayOfTPointF; override;

This item has no description. Showing description inherited from TBGRACustomBitmap.ComputeOpenedSpline.

Compute an opened spline passing by the given points.

Example of drawing a spline on a form:

computeopenedspline

procedure TForm1.FormPaint(Sender: TObject);
var
  image: TBGRABitmap;
  pts: array of TPointF;
  storedSpline: array of TPointF;
  c: TBGRAPixel;
begin
    image := TBGRABitmap.Create(ClientWidth, ClientHeight, clBtnFace);
    c := clWindowText;

    //rectangular polyline
    setlength(pts,4);
    pts[0] := PointF(50,50);
    pts[1] := PointF(150,50);
    pts[2] := PointF(150,150);
    pts[3] := PointF(50,150);
    image.DrawPolylineAntialias(pts,BGRA(255,0,0,150),1);

    //compute spline points and draw as a polyline
    storedSpline := image.ComputeOpenedSpline(pts,ssVertexToSide);
    image.DrawPolylineAntialias(storedSpline,c,1);

    image.Draw(Canvas,0,0,True);
    image.free;
end;

	`function ComputePie65536(x,y,rx,ry: single; start65536,end65536: word; quality: single = 1): ArrayOfTPointF; override;`
This item has no description.

	`function ComputePieRad(x,y,rx,ry: single; startRad,endRad: single; quality: single = 1): ArrayOfTPointF; override;`
This item has no description.

	`function ComputeRoundRect(x1,y1,x2,y2,rx,ry: single; quality: single = 1): ArrayOfTPointF; overload; override;`
This item has no description.

	`function ComputeRoundRect(x1,y1,x2,y2,rx,ry: single; options: TRoundRectangleOptions; quality: single = 1): ArrayOfTPointF; overload; override;`
This item has no description.

	`function ComputeWidePolygon(const points: array of TPointF; w: single): ArrayOfTPointF; overload; override;`
This item has no description.

	`function ComputeWidePolyline(const points: array of TPointF; w: single; ClosedCap: boolean): ArrayOfTPointF; overload; override;`
This item has no description.

function ComputeWidePolyline(const points: array of TPointF; w: single): ArrayOfTPointF; overload; override;

This item has no description. Showing description inherited from TBGRACustomBitmap.ComputeWidePolyline.

can be accessed via Pen property

	`function FilterAffine(AMatrix: TAffineMatrix; correctBlur: boolean = false; ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
This item has no description.

	`function FilterContour(AGammaCorrection: boolean = false; ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
This item has no description.

	`function FilterCylinder(ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
This item has no description.

	`function FilterEmboss(angle: single; ABounds: TRect; AStrength: integer= 64; AOptions: TEmbossOptions = []; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
This item has no description.

	`function FilterEmboss(angle: single; AStrength: integer= 64; AOptions: TEmbossOptions = []; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
This item has no description.

	`function FilterEmbossHighlight(FillSelection: boolean; BorderColor: TBGRAPixel; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
This item has no description.

	`function FilterEmbossHighlight(FillSelection: boolean; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
This item has no description.

	`function FilterEmbossHighlight(FillSelection: boolean; BorderColor: TBGRAPixel; var Offset: TPoint; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
This item has no description.

	`function FilterGrayscale(ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
This item has no description.

	`function FilterGrayscale(ABounds: TRect; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
This item has no description.

	`function FilterMedian(Option: TMedianOption; ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
This item has no description.

	`function FilterNormalize(ABounds: TRect; eachChannel: boolean = True; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
This item has no description.

	`function FilterNormalize(eachChannel: boolean = True; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
This item has no description.

	`function FilterPixelate(pixelSize: integer; useResample: boolean; filter: TResampleFilter = rfLinear; ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
This item has no description.

	`function FilterPlane(ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
This item has no description.

	`function FilterRotate(origin: TPointF; angle: single; correctBlur: boolean = false; ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
This item has no description.

	`function FilterSharpen(Amount: single = 1; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
This item has no description.

	`function FilterSharpen(ABounds: TRect; Amount: single = 1; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
This item has no description.

	`function FilterSmartZoom3(Option: TMedianOption; ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
Filters

	`function FilterSmooth(ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
This item has no description.

	`function FilterSphere(ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
This item has no description.

	`function FilterTwirl(ABounds: TRect; ACenter: TPoint; ARadius: Single; ATurn: Single=1; AExponent: Single=3; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
This item has no description.

	`function FilterTwirl(ACenter: TPoint; ARadius: Single; ATurn: Single=1; AExponent: Single=3; ACopyProperties: Boolean=False): TBGRADefaultBitmap; overload; override;`
This item has no description.

	`function GetGrayscaleMaskFromAlpha: TGrayscaleMask;`
This item has no description.

	`function GetImageAffineBounds(AMatrix: TAffineMatrix; ASourceBounds: TRect; AClipOutput: boolean = true; APixelCenteredCoords: boolean = true): TRect; overload; override;`
This item has no description.

	`function GetMaskFromAlpha: TBGRADefaultBitmap; override;`
This item has no description.

function GetPixel(x, y: single; AResampleFilter: TResampleFilter = rfLinear; smoothBorder: boolean = true): TBGRAPixel; overload; override;

Computes the value of the pixel at a floating point coordiante by interpolating the values of the pixels around it.

There is a one pixel wide margin around the pixel where the pixels are still considered inside. If ''smoothBorder'' is set to true, pixel fade to transparent.
If it is more out of the bounds, the result is ''BGRAPixelTransparent''.
''AResampleFilter'' specifies how pixels must be interpolated. Accepted values are ''rfBox'', ''rfLinear'', ''rfHalfCosine'' and ''rfCosine''

	`function GetPixel256(x, y, fracX256,fracY256: int32or64; AResampleFilter: TResampleFilter = rfLinear; smoothBorder: boolean = true): TBGRAPixel; override;`
Similar to previous ''GetPixel'' function, but the fractional part of the coordinate is supplied with a number from 0 to 255. The actual coordinate is (''x'' + ''fracX256''/256, ''y'' + ''fracY256''/256)

function GetPixelCycle(x, y: single; AResampleFilter: TResampleFilter; repeatX: boolean; repeatY: boolean): TBGRAPixel; overload; override;

Computes the value of the pixel at a floating point coordiante by interpolating the values of the pixels around it. ''repeatX'' and ''repeatY'' specifies if the image is to be repeated or not.

''AResampleFilter'' specifies how pixels must be interpolated. Accepted values are ''rfBox'', ''rfLinear'', ''rfHalfCosine'' and ''rfCosine''

function GetPixelCycle(x, y: single; AResampleFilter: TResampleFilter = rfLinear): TBGRAPixel; overload; override;

Computes the value of the pixel at a floating point coordiante by interpolating the values of the pixels around it. If the pixel is out of bounds, the image is repeated.

''AResampleFilter'' specifies how pixels must be interpolated. Accepted values are ''rfBox'', ''rfLinear'', ''rfHalfCosine'' and ''rfCosine''

	`function GetPixelCycle256(x, y, fracX256,fracY256: int32or64; AResampleFilter: TResampleFilter; repeatX: boolean; repeatY: boolean): TBGRAPixel; overload; override;`
Similar to previous ''GetPixel'' function, but the fractional part of the coordinate is supplied with a number from 0 to 255. The actual coordinate is (''x'' + ''fracX256''/256, ''y'' + ''fracY256''/256)

	`function GetPixelCycle256(x, y, fracX256,fracY256: int32or64; AResampleFilter: TResampleFilter = rfLinear): TBGRAPixel; overload; override;`
Similar to previous ''GetPixel'' function, but the fractional part of the coordinate is supplied with a number from 0 to 255. The actual coordinate is (''x'' + ''fracX256''/256, ''y'' + ''fracY256''/256)

	`function GetPtrBitmap(Top,Bottom: Integer): TBGRACustomBitmap; override;`
This item has no description.

	`class function IsAffineRoughlyTranslation(AMatrix: TAffineMatrix; ASourceBounds: TRect): boolean; override;`
This item has no description.

function IsScanPutPixelsDefined: boolean; override;

This item has no description. Showing descriptions inherited from ancestors.

From IBGRAScanner.IsScanPutPixelsDefined:: Returns True if the function ScanPutPixels is available. Otherwise you need to call ScanNextPixel and combine pixels for example with SetPixel
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 MakeBitmapCopy(BackgroundColor: TColor; AMasked: boolean = False): TBitmap; override;`
This item has no description.

	`function NewBitmap(AWidth, AHeight: integer): TBGRADefaultBitmap; overload; override;`
Can only be called from an existing instance of ''TBGRABitmap''. Creates a new instance with dimensions ''AWidth'' and ''AHeight'', containing transparent pixels.

	`function NewBitmap: TBGRADefaultBitmap; overload; override;`
Can only be called from an existing instance of ''TBGRABitmap''. Creates a new instance with dimensions 0 x 0.

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

	`function NewBitmap(AWidth, AHeight: integer; const Color: TBGRAPixel): TBGRADefaultBitmap; overload; override;`
Can only be called from an existing instance of ''TBGRABitmap''. Creates a new instance with dimensions ''AWidth'' and ''AHeight'', and fills it with Color

	`function NewBitmap(Filename: string; AIsUtf8: boolean; AOptions: TBGRALoadingOptions): TBGRADefaultBitmap; overload; override;`
This item has no description.

	`function NewBitmap(AFPImage: TFPCustomImage): TBGRADefaultBitmap; overload; override;`
Can only be called from an existing instance of ''TBGRABitmap''. Creates an image by copying the content of a ''TFPCustomImage''

	`function NewBitmap(Filename: string): TBGRADefaultBitmap; overload; override;`
Can only be called from an existing instance of ''TBGRABitmap''. Creates a new instance with by loading its content from the file ''Filename''. The encoding of the string is the default one for the operating system

	`function NewBitmap(Filename: string; AIsUtf8: boolean): TBGRADefaultBitmap; overload; override;`
Can only be called from an existing instance of ''TBGRABitmap''. Creates a new instance with by loading its content from the file ''Filename''

	`function Resample(newWidth, newHeight: integer; mode: TResampleMode = rmFineResample; ACopyProperties: Boolean=False): TBGRADefaultBitmap; override;`
This item has no description.

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

This item has no description. Showing descriptions inherited from ancestors.

From IBGRAScanner.ScanAt:: Scan at any location using floating point coordinates
From IBGRAScanner.ScanAt:: Scan at any location using floating point coordinates

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

This item has no description. Showing descriptions inherited from ancestors.

From IBGRAScanner.ScanAtInteger:: Scan at any location using integer coordinates
From IBGRAScanner.ScanAtInteger:: Scan at any location using integer coordinates

function ScanNextPixel: TBGRAPixel; override;

This item has no description. Showing descriptions inherited from ancestors.

From IBGRAScanner.ScanNextPixel:: Scan the pixel at the current location and increments X
From IBGRAScanner.ScanNextPixel:: Scan the pixel at the current location and increments X

	`function TextAffineBox(const sUTF8: string): TAffineBox; override;`
Returns the affine box of the string provided using the current font. Orientation is taken into account. End of lines are stripped from the string.

	`function TextFitInfo(const sUTF8: string; AMaxWidth: integer): integer; override;`
This item has no description.

	`function TextSize(const sUTF8: string): TSize; override;`
Returns the total size of the string provided using the current font. Orientation is not taken into account, so that the width is along the text. End of lines are stripped from the string.

	`function TextSize(const sUTF8: string; AMaxWidth: integer; ARightToLeft: boolean): TSize; override;`
This item has no description.

	`function TextSize(const sUTF8: string; AMaxWidth: integer): TSize; override;`
Returns the total size of a paragraph i.e. with word break

function TextSizeMultiline(const sUTF8: string; AMaxWidth: single = EmptySingle; AParagraphSpacing: single = 0): TSize; override;

This item has no description. Showing description inherited from TBGRACustomBitmap.TextSizeMultiline.

Returns the total size of the string provided using the current font and taking into account line breaks.

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

	`function CreateDefaultFontRenderer: TBGRACustomFontRenderer; virtual; abstract;`
This item has no description.

	`function CreatePtrBitmap(AWidth,AHeight: integer; AData: PBGRAPixel): TBGRAPtrBitmap; virtual;`
This item has no description.

	`function FineResample(NewWidth, NewHeight: integer): TBGRACustomBitmap;`
Image functions

	`function GetArrowEndOffset: single; override;`
This item has no description.

	`function GetArrowEndRepeat: integer; override;`
This item has no description.

	`function GetArrowEndSize: TPointF; override;`
This item has no description.

	`function GetArrowStartOffset: single; override;`
This item has no description.

	`function GetArrowStartRepeat: integer; override;`
This item has no description.

	`function GetArrowStartSize: TPointF; override;`
This item has no description.

	`function GetAverageColor: TColor; override;`
This item has no description.

	`function GetAveragePixel: TBGRAPixel; override;`
This item has no description.

	`function GetBitmap: TBitmap; override;`
GUI bitmap object

	`function GetCanvas: TCanvas; override;`
This item has no description.

	`function GetCanvasAlphaCorrection: boolean; override;`
This item has no description.

	`function GetCanvasDrawModeFP: TDrawMode; override;`
This item has no description.

	`function GetCanvasFP: TFPImageCanvas; override;`
FreePascal drawing routines

	`function GetCanvasOpacity: byte; override;`
This item has no description.

	`function GetCustomPenStyle: TBGRAPenStyle; override;`
This item has no description.

	`function GetFontAnchorRotatedOffset(ACustomOrientation: integer): TPointF; overload;`
This item has no description.

	`function GetFontAnchorRotatedOffset: TPointF; overload;`
This item has no description.

	`function GetFontFullHeight: integer; override;`
This item has no description.

	`function GetFontHeight: integer; override;`
font accessors

	`function GetFontPixelMetric: TFontPixelMetric; override;`
This item has no description.

	`function GetFontRenderer: TBGRACustomFontRenderer; override;`
This item has no description.

	`function GetFontVerticalAnchorOffset: single; override;`
This item has no description.

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

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

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

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

	`function GetPenJoinStyle: TPenJoinStyle; override;`
pen style accesors

	`function GetPenMiterLimit: single; override;`
This item has no description.

	`function GetPenStyle: TPenStyle; override;`
This item has no description.

	`function InternalGetPixel256(ix,iy: int32or64; iFactX,iFactY: int32or64; smoothBorder: boolean): TBGRAPixel;`
This item has no description.

	`function InternalGetPixelCycle256(ix,iy: int32or64; iFactX,iFactY: int32or64): TBGRAPixel;`
This item has no description.

	`function InternalNew: TBGRADefaultBitmap; override;`
This item has no description.

	`function LoadFromRawImage(ARawImage: TRawImage; DefaultOpacity: byte; AlwaysReplaceAlpha: boolean = False; RaiseErrorOnInvalidPixelFormat: boolean = True): boolean; virtual; abstract;`
Pixel data

	`function SimpleStretch(NewWidth, NewHeight: integer): TBGRACustomBitmap;`
This item has no description.

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

	`procedure AlphaFill(alpha: byte; start, Count: integer); overload; override;`
This item has no description.

	`procedure AlphaHorizLine(x, y, x2: int32or64; alpha: byte); override;`
Replaces the alpha value of the pixels at line ''y'' and at columns ''x'' to ''x2'' included

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

	`procedure AlphaToGrayscale; override;`
This item has no description.

	`procedure AlphaVertLine(x, y, y2: int32or64; alpha: byte); override;`
Replace alpha values in a vertical line at column ''x'' and at row ''y'' to ''y2''

	`procedure ArrowEndAsClassic(AFlipped: boolean = false; ACut: boolean = false; ARelativePenWidth: single = 1); override;`
This item has no description.

	`procedure ArrowEndAsNone; override;`
This item has no description.

	`procedure ArrowEndAsTail; override;`
This item has no description.

	`procedure ArrowEndAsTriangle(ABackOffset: single = 0; ARounded: boolean = false; AHollow: boolean = false; AHollowPenWidth: single = 0.5); override;`
This item has no description.

	`procedure ArrowStartAsClassic(AFlipped: boolean = false; ACut: boolean = false; ARelativePenWidth: single = 1); override;`
This item has no description.

	`procedure ArrowStartAsNone; override;`
This item has no description.

	`procedure ArrowStartAsTail; override;`
This item has no description.

	`procedure ArrowStartAsTriangle(ABackOffset: single = 0; ARounded: boolean = false; AHollow: boolean = false; AHollowPenWidth: single = 0.5); override;`
This item has no description.

	`procedure Assign(Source: TPersistent); overload; override;`
Assign the content of the specified ''Source''. It can be a ''TBGRACustomBitmap'' or a ''TFPCustomImage''

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

	`procedure Assign(Source: TBitmap; AUseTransparentColor: boolean); overload;`
This item has no description.

	`procedure AssignWithFixedTransparent(Source: TBitmap); overload;`
This item has no description.

	`procedure BlendImage(x, y: integer; ASource: TBGRACustomBitmap; AOperation: TBlendOperation); overload; override;`
This item has no description.

	`procedure BlendImage(ADest: TRect; ASource: IBGRAScanner; AOffsetX, AOffsetY: integer; AOperation: TBlendOperation); overload; override;`
This item has no description.

	`procedure BlendImageOver(ADest: TRect; ASource: IBGRAScanner; AOffsetX, AOffsetY: integer; AOperation: TBlendOperation; AOpacity: byte = 255; ALinearBlend: boolean = false); overload; override;`
This item has no description.

	`procedure BlendImageOver(x, y: integer; ASource: TBGRACustomBitmap; AOperation: TBlendOperation; AOpacity: byte = 255; ALinearBlend: boolean = false); overload; override;`
This item has no description.

	`procedure BlendRect(ADest: TRect; AColor: TBGRAPixel; AOperation: TBlendOperation; AExcludeChannels: TChannels); overload; override;`
This item has no description.

	`procedure BlendRectOver(ADest: TRect; AColor: TBGRAPixel; AOperation: TBlendOperation; AOpacity: byte; ALinearBlend: boolean; AExcludeChannels: TChannels); overload; override;`
This item has no description.

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

	`procedure ConvertFromLinearRGB; override;`
This item has no description.

	`procedure ConvertToLinearRGB; override;`
This item has no description.

	`procedure CrossFade(ARect: TRect; Source1, Source2: IBGRAScanner; AFadePosition: byte; mode: TDrawMode = dmDrawWithTransparency); overload; override;`
BGRA bitmap functions

	`procedure CrossFade(ARect: TRect; Source1, Source2: IBGRAScanner; AFadeMask: IBGRAScanner; mode: TDrawMode = dmDrawWithTransparency); overload; override;`
This item has no description.

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

	`procedure Draw(ACanvas: TCanvas; x, y: integer; Opaque: boolean = True); overload; override;`
Canvas drawing functions

	`procedure Draw(ACanvas: TCanvas; Rect: TRect; Opaque: boolean = True); overload; override;`
This item has no description.

	`procedure DrawHorizLine(x, y, x2: int32or64; ec: TExpandedPixel); override; overload;`
Draws an horizontal line with gamma correction at line ''y'' and at columns ''x'' to ''x2'' included, using specified color

	`procedure DrawHorizLineDiff(x, y, x2: int32or64; c, compare: TBGRAPixel; maxDiff: byte); override;`
Draws an horizontal line with gamma correction at line ''y'' and at columns ''x'' to ''x2'' included, using specified color, and with a transparency that increases with the color difference with ''compare''. If the difference is greater than ''maxDiff'', pixels are not changed

	`procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeTexture: IBGRAScanner; AWidth: single; AFillColor: TBGRAPixel); overload; override;`
This item has no description.

	`procedure DrawPath(APath: IBGRAPath; AStrokeColor: TBGRAPixel; AWidth: single; AFillTexture: IBGRAScanner); overload; override;`
This item has no description.

	`procedure DrawPath(APath: IBGRAPath; AStrokeTexture: IBGRAScanner; AWidth: single; AFillColor: TBGRAPixel); overload; override;`
This item has no description.

	`procedure DrawPath(APath: IBGRAPath; AStrokeColor: TBGRAPixel; AWidth: single; AFillColor: TBGRAPixel); overload; override;`
Draws and fills a path

	`procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeColor: TBGRAPixel; AWidth: single; AFillColor: TBGRAPixel); overload; override;`
Draws and fills a path with a matrix transform

	`procedure DrawPath(APath: IBGRAPath; AStrokeTexture: IBGRAScanner; AWidth: single; AFillTexture: IBGRAScanner); overload; override;`
This item has no description.

	`procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeTexture: IBGRAScanner; AWidth: single; AFillTexture: IBGRAScanner); overload; override;`
This item has no description.

	`procedure DrawPath(APath: IBGRAPath; AMatrix: TAffineMatrix; AStrokeColor: TBGRAPixel; AWidth: single; AFillTexture: IBGRAScanner); overload; override;`
This item has no description.

	`procedure DrawPixel(x, y: int32or64; const c: TBGRAPixel); overload; override;`
Draws a pixel with gamma correction at (''x'',''y''). Pixel is supplied in sRGB colorspace

	`procedure DrawPixels(c: TBGRAPixel; start, Count: integer); override;`
This item has no description.

	`procedure DrawPolygonAntialias(const points: array of TPointF; c: TBGRAPixel; w: single; fillcolor: TBGRAPixel); overload; override;`
Draws a filled polygon using current pen style/cap/join in one go. The stroke is stricly over the fill even if partially transparent. The polygon is always closed. You don't need to set the last point to be the same as the first point.

	`procedure DrawPolyLineAntialias(const points: array of TPointF; c: TBGRAPixel; w: single; fillcolor: TBGRAPixel); overload; override;`
Draws and fill a polyline using current pen style/cap/join in one go. The stroke is stricly over the fill even if partially transparent. ''fillcolor'' specifies a color to fill the polygon formed by the points

	`procedure DrawVertLine(x, y, y2: int32or64; c: TBGRAPixel); override;`
Draws a vertical line with gamma correction at column ''x'' and at row ''y'' to ''y2''

	`procedure EllipseAntialias(x, y, rx, ry: single; c: TBGRAPixel; w: single; back: TBGRAPixel); overload; override;`
Draws and fills an ellipse

	`procedure EllipseAntialias(AOrigin, AXAxis, AYAxis: TPointF; c: TBGRAPixel; w: single; back: TBGRAPixel); overload; override;`
This item has no description.

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

	`procedure EraseMask(x,y: integer; AMask: TBGRACustomBitmap; alpha: byte=255); override;`
This item has no description.

	`procedure ErasePixel(x, y: int32or64; alpha: byte); override;`
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 ''BGRAPixelTransparent''

	`procedure FastBlendHorizLine(x, y, x2: int32or64; c: TBGRAPixel); override;`
Draws an horizontal line without gamma correction at line ''y'' and at columns ''x'' to ''x2'' included, using specified color

	`procedure FastBlendPixel(x, y: int32or64; const c: TBGRAPixel); override;`
Draws a pixel without gamma correction at (''x'',''y''). Pixel is supplied in sRGB colorspace

	`procedure FastBlendVertLine(x, y, y2: int32or64; c: TBGRAPixel); override;`
Draws a vertical line without gamma correction at column ''x'' and at row ''y'' to ''y2''

	`procedure Fill(c: TBGRAPixel; start, Count: integer); overload; override;`
Filling

	`procedure FillClearTypeMask(x,y: integer; xThird: integer; AMask: TBGRACustomBitmap; texture: IBGRAScanner; ARGBOrder: boolean = true); override;`
This item has no description.

	`procedure FillClearTypeMask(x,y: integer; xThird: integer; AMask: TBGRACustomBitmap; color: TBGRAPixel; ARGBOrder: boolean = true); override;`
This item has no description.

	`procedure FillEllipseLinearColorAntialias(AOrigin, AXAxis, AYAxis: TPointF; outercolor, innercolor: TBGRAPixel); overload; override;`
This item has no description.

	`procedure FillEllipseLinearColorAntialias(x, y, rx, ry: single; outercolor, innercolor: TBGRAPixel); overload; override;`
Fills an ellipse with a gradient of color. ''outercolor'' specifies the end color of the gradient on the border of the ellipse and ''innercolor'' the end color of the gradient at the center of the ellipse

	`procedure FillMask(x,y: integer; AMask: TCustomUniversalBitmap; ATexture: IBGRAScanner; ADrawMode: TDrawMode; AOpacity: byte); overload; override;`
This item has no description.

	`procedure FillMask(x,y: integer; AMask: TCustomUniversalBitmap; const AColor: TBGRAPixel; ADrawMode: TDrawMode); overload; override;`
This item has no description.

	`procedure FillPolyLinearColor(const points: array of TPointF; AColors: array of TBGRAPixel); override;`
This item has no description.

procedure FillPolyLinearMapping(const points: array of TPointF; texture: IBGRAScanner; texCoords: array of TPointF; TextureInterpolation: Boolean); override;

This item has no description. Showing description inherited from TBGRACustomBitmap.FillPolyLinearMapping.

Fills a polygon with a texture that is linearly mapped.

Example filling a trapeze with a texture:

fillpolylinearmapping

procedure TForm1.PaintImage;
var image: TBGRABitmap;
    tex: TBGRABitmap;
begin
  image := TBGRABitmap.Create(ClientWidth,ClientHeight, BGRABlack );

  tex:= TBGRABitmap.Create('image.png');
  image.FillPolyLinearMapping( [PointF(110,10), PointF(250,10), PointF(350,160), PointF(10,160)], tex,
             [PointF(0,0), PointF(tex.width-1,0), PointF(tex.Width-1,tex.Height-1), PointF(0,tex.Height-1)], true);
  tex.Free;

  image.Draw(Canvas,0,0,True);
  image.free;
end;

	`procedure FillPolyLinearMappingLightness(const points: array of TPointF; texture: IBGRAScanner; texCoords: array of TPointF; lightnesses: array of word; TextureInterpolation: Boolean); override;`
This item has no description.

procedure FillPolyPerspectiveMapping(const points: array of TPointF; const pointsZ: array of single; texture: IBGRAScanner; texCoords: array of TPointF; TextureInterpolation: Boolean; zbuffer: psingle = nil); override;

This item has no description. Showing description inherited from TBGRACustomBitmap.FillPolyPerspectiveMapping.

Fills a polygon with a texture that is mapped with perspective.

Example filling a trapeze with a texture:

fillpolyperspectivemapping

procedure TForm1.PaintImage;
var image: TBGRABitmap;
    tex: TBGRABitmap;
begin
  image := TBGRABitmap.Create(ClientWidth,ClientHeight, BGRABlack );

  tex:= TBGRABitmap.Create('image.png');
  image.FillPolyPerspectiveMapping( [PointF(110,10), PointF(250,10), PointF(350,160), PointF(10,160)],
                                    [75,             75,             50,              50],
       tex, [PointF(0,0), PointF(tex.width-1,0), PointF(tex.Width-1,tex.Height-1), PointF(0,tex.Height-1)], true);
  tex.Free;

  image.Draw(Canvas,0,0,True);
  image.free;
end;

	`procedure FillPolyPerspectiveMappingLightness(const points: array of TPointF; const pointsZ: array of single; texture: IBGRAScanner; texCoords: array of TPointF; lightnesses: array of word; TextureInterpolation: Boolean; zbuffer: psingle = nil); override;`
This item has no description.

	`procedure FillQuadAffineMapping(Orig,HAxis,VAxis: TPointF; AImage: TBGRACustomBitmap; APixelCenteredCoordinates: boolean = true; ADrawMode: TDrawMode = dmDrawWithTransparency; AOpacity: byte = 255); override;`
This item has no description.

	`procedure FillQuadAffineMappingAntialias(Orig,HAxis,VAxis: TPointF; AImage: TBGRACustomBitmap; APixelCenteredCoordinates: boolean = true; AOpacity: byte = 255); override;`
This item has no description.

	`procedure FillQuadLinearColor(pt1,pt2,pt3,pt4: TPointF; c1,c2,c3,c4: TBGRAPixel); override;`
This item has no description.

	`procedure FillQuadLinearColorAntialias(pt1,pt2,pt3,pt4: TPointF; c1,c2,c3,c4: TBGRAPixel); override;`
This item has no description.

	`procedure FillQuadLinearMapping(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; TextureInterpolation: Boolean= True; ACulling: TFaceCulling = fcNone; ACropToPolygon: boolean = true); override;`
This item has no description.

	`procedure FillQuadLinearMappingAntialias(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; ACulling: TFaceCulling = fcNone); override;`
This item has no description.

procedure FillQuadLinearMappingLightness(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; light1,light2,light3,light4: word; TextureInterpolation: Boolean= True); override;

This item has no description. Showing description inherited from TBGRACustomBitmap.FillQuadLinearMappingLightness.

Fills a quadrilateral with linear mapping and lightness

	`procedure FillQuadPerspectiveMapping(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; ACleanBorders: TRect; ADrawMode: TDrawMode = dmDrawWithTransparency); override;`
This item has no description.

	`procedure FillQuadPerspectiveMapping(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; ADrawMode: TDrawMode = dmDrawWithTransparency); override;`
This item has no description.

	`procedure FillQuadPerspectiveMappingAntialias(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF); override;`
This item has no description.

	`procedure FillQuadPerspectiveMappingAntialias(pt1,pt2,pt3,pt4: TPointF; texture: IBGRAScanner; tex1, tex2, tex3, tex4: TPointF; ACleanBorders: TRect); override;`
This item has no description.

	`procedure FillRect(x, y, x2, y2: integer; texture: IBGRAScanner; mode: TDrawMode; AScanOffset: TPoint; ditheringAlgorithm: TDitheringAlgorithm); overload; override;`
Fills completely a rectangle, without any border, with the specified ''texture'' and with the specified ''mode''

	`procedure FillTriangleLinearColor(pt1,pt2,pt3: TPointF; c1,c2,c3: TBGRAPixel); override;`
==== Gradient polygons ====

	`procedure FillTriangleLinearColorAntialias(pt1,pt2,pt3: TPointF; c1,c2,c3: TBGRAPixel); override;`
This item has no description.

	`procedure FillTriangleLinearMapping(pt1,pt2,pt3: TPointF; texture: IBGRAScanner; tex1, tex2, tex3: TPointF; TextureInterpolation: Boolean= True); override;`
This item has no description.

	`procedure FillTriangleLinearMappingAntialias(pt1,pt2,pt3: TPointF; texture: IBGRAScanner; tex1, tex2, tex3: TPointF); override;`
This item has no description.

procedure FillTriangleLinearMappingLightness(pt1,pt2,pt3: TPointF; texture: IBGRAScanner; tex1, tex2, tex3: TPointF; light1,light2,light3: word; TextureInterpolation: Boolean= True); override;

This item has no description. Showing description inherited from TBGRACustomBitmap.FillTriangleLinearMappingLightness.

Fills a triangle with linear mapping of a texture and lightness

	`procedure GradientFill(x, y, x2, y2: integer; gradient: TBGRACustomGradient; gtype: TGradientType; o1, o2: TPointF; mode: TDrawMode; Sinus: Boolean=False; ditherAlgo: TDitheringAlgorithm = daNearestNeighbor); override;`
This item has no description.

	`procedure GradientFill(x, y, x2, y2: integer; c1, c2: TBGRAPixel; gtype: TGradientType; o1, o2: TPointF; mode: TDrawMode; gammaColorCorrection: boolean = True; Sinus: Boolean=False; ditherAlgo: TDitheringAlgorithm = daNearestNeighbor); override;`
This item has no description.

	`procedure GrayscaleToAlpha; override;`
This item has no description.

	`procedure HorizLineDiff(x, y, x2: int32or64; const ABrush: TUniversalBrush; ACompare: TBGRAPixel; AMaxDiffW: word); override;`
This item has no description.

	`procedure InplaceGrayscale(ABounds: TRect; AGammaCorrection: boolean = true); overload; override;`
This item has no description.

	`procedure InplaceGrayscale(AGammaCorrection: boolean = true); overload; override;`
This item has no description.

	`procedure InplaceNormalize(ABounds: TRect; AEachChannel: boolean = True); overload; override;`
This item has no description.

	`procedure InplaceNormalize(AEachChannel: boolean = True); overload; override;`
This item has no description.

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

	`procedure LinearNegative; override;`
This item has no description.

	`procedure LinearNegativeRect(ABounds: TRect); override;`
This item has no description.

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

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

procedure Negative; override;

This item has no description. Showing description inherited from TBGRACustomBitmap.Negative.

inplace filters

	`procedure NegativeRect(ABounds: TRect); override;`
This item has no description.

	`procedure NotifyBitmapChange; inline;`
call to ensure that bitmap data is up to date

	`procedure ParallelFloodFill(X, Y: integer; Dest: TCustomUniversalBitmap; Color: TBGRAPixel; mode: TFloodfillMode; Tolerance: byte = 0; DestOfsX: integer = 0; DestOfsY: integer = 0); overload; override;`
This item has no description.

	`procedure ParallelFloodFill(X, Y: integer; Dest: TCustomUniversalBitmap; const Brush: TUniversalBrush; Progressive: boolean; ToleranceW: Word = $00ff; DestOfsX: integer = 0; DestOfsY: integer = 0); overload; override;`
This item has no description.

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

	`procedure PutImageAffine(AMatrix: TAffineMatrix; Source: TBGRACustomBitmap; AOutputBounds: TRect; AResampleFilter: TResampleFilter; AMode: TDrawMode; AOpacity: Byte=255; APixelCenteredCoords: boolean = true); overload; override;`
This item has no description.

	`procedure RectangleAntialias(x, y, x2, y2: single; c: TBGRAPixel; w: single; back: TBGRAPixel); overload; override;`
Draws a rectangle with antialiasing and fills it with color ''back''. Note that the pixel (x2,y2) is included contrary to integer coordinates

	`procedure ReplaceColor(ABounds: TRect; before, after: TColor); overload; override;`
This item has no description.

	`procedure ReplaceColor(before, after: TColor); overload; override;`
This item has no description.

	`procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; pencolor: TBGRAPixel; w: single; fillcolor: TBGRAPixel; options: TRoundRectangleOptions = []); overload; override;`
Draws and fills a round rectangle

	`procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; penTexture: IBGRAScanner; w: single; fillTexture: IBGRAScanner; options: TRoundRectangleOptions = []); overload; override;`
Draws and fills a round rectangle with textures

	`procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; c: TBGRAPixel; w: single; options: TRoundRectangleOptions = []); overload; override;`
Draws a rounded rectangle border with antialiasing. The corners have an elliptical radius of ''rx'' and ''ry''. ''options'' specifies how to draw the corners. See [[BGRABitmap Geometry types\|geometry types]]

	`procedure RoundRectAntialias(x,y,x2,y2,rx,ry: single; texture: IBGRAScanner; w: single; options: TRoundRectangleOptions = []); overload; override;`
Draws a rounded rectangle border with the specified texture. The corners have an elliptical radius of ''rx'' and ''ry''. ''options'' specifies how to draw the corners. See [[BGRABitmap Geometry types\|geometry types]]

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

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

This item has no description. Showing descriptions inherited from ancestors.

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
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 Serialize(AStream: TStream); override;`
Stores the image in the stream without compression nor header

	`procedure SetPixel(x, y: int32or64; c: TColor); overload; override;`
Sets the pixel by replacing the content at (''x'',''y'') with the specified color. Alpha value is set to 255 (opaque)

	`procedure SetSize(AWidth, AHeight: integer); override;`
For more properties, see parent class [[TBGRACustomBitmap and IBGRAScanner#TBGRACustomBitmap\|TBGRACustomBitmap]]

	`class procedure SolidBrush(out ABrush: TUniversalBrush; const AColor: TBGRAPixel; ADrawMode: TDrawMode = dmDrawWithTransparency); override;`
This item has no description.

	`procedure SolidBrushIndirect(out ABrush: TUniversalBrush; AColor: Pointer; ADrawMode: TDrawMode = dmDrawWithTransparency); override;`
universal brushes

	`procedure StretchPutImage(ARect: TRect; Source: TBGRACustomBitmap; mode: TDrawMode; AOpacity: byte = 255); override;`
This item has no description.

	`procedure SwapRedBlue; override;`
This item has no description.

	`procedure SwapRedBlue(ARect: TRect); override;`
This item has no description.

procedure TextMultiline(ALeft,ATop,AWidth: single; const sUTF8: string; ATexture: IBGRAScanner; AAlign: TBidiTextAlignment = btaNatural; AVertAlign: TTextLayout = tlTop; AParagraphSpacing: single = 0); overload; override;

This item has no description. Showing description inherited from TBGRACustomBitmap.TextMultiline.

Draw text with line breaks, filling it with a texture

procedure TextMultiline(ALeft,ATop,AWidth: single; const sUTF8: string; c: TBGRAPixel; AAlign: TBidiTextAlignment = btaNatural; AVertAlign: TTextLayout = tlTop; AParagraphSpacing: single = 0); overload; override;

This item has no description. Showing description inherited from TBGRACustomBitmap.TextMultiline.

Draw text with line breaks, filling it with a solid color

	`procedure TextOut(x, y: single; const sUTF8: string; ATexture: IBGRAScanner; AAlign: TAlignment; ALetterSpacing: single); overload; override;`
This item has no description.

	`procedure TextOut(x, y: single; const sUTF8: string; c: TBGRAPixel; align: TAlignment; ARightToLeft: boolean); overload; override;`
Draws the UTF8 encoded string, with color c. If align is taLeftJustify, (x,y) is the top-left corner. If align is taCenter, (x,y) is at the top and middle of the text. If align is taRightJustify, (x,y) is the top-right corner. The value of FontOrientation is taken into account, so that the text may be rotated.

	`procedure TextOut(x, y: single; const sUTF8: string; texture: IBGRAScanner; align: TAlignment; ARightToLeft: boolean); overload; override;`
Same as above functions, except that the text is filled using texture. The value of FontOrientation is taken into account, so that the text may be rotated.

	`procedure TextOut(x, y: single; const sUTF8: string; AColor: TBGRAPixel; AAlign: TAlignment; ALetterSpacing: single); overload; override;`
This item has no description.

	`procedure TextOutAngle(x, y: single; orientationTenthDegCCW: integer; const sUTF8: string; texture: IBGRAScanner; align: TAlignment; ARightToLeft: boolean); overload; override;`
This item has no description.

	`procedure TextOutAngle(x, y: single; orientationTenthDegCCW: integer; const sUTF8: string; c: TBGRAPixel; align: TAlignment; ARightToLeft: boolean); overload; override;`
Same as above, except that the orientation is specified, overriding the value of the property FontOrientation.

	`procedure TextOutCurved(ACursor: TBGRACustomPathCursor; const sUTF8: string; ATexture: IBGRAScanner; AAlign: TAlignment; ALetterSpacing: single); overload; override;`
This item has no description.

	`procedure TextOutCurved(ACursor: TBGRACustomPathCursor; const sUTF8: string; AColor: TBGRAPixel; AAlign: TAlignment; ALetterSpacing: single); overload; override;`
This item has no description.

	`procedure TextRect(ARect: TRect; x, y: integer; const sUTF8: string; style: TTextStyle; c: TBGRAPixel); overload; override;`
Draw the UTF8 encoded string at the coordinate (x,y), clipped inside the rectangle ARect. Additional style information is provided by the style parameter. The color c or texture is used to fill the text. No rotation is applied.

	`procedure TextRect(ARect: TRect; x, y: integer; const sUTF8: string; style: TTextStyle; texture: IBGRAScanner); overload; override;`
This item has no description.

	`procedure XorHorizLine(x, y, x2: int32or64; c: TBGRAPixel); override;`
Applies xor to the pixels at line ''y'' and at columns ''x'' to ''x2'' included, using specified color. This includes the alpha channel, so if you want to preserve the opacity, provide a color ''c'' with alpha channel equal to zero

	`procedure XorPixel(x, y: int32or64; const c: TBGRAPixel); override;`
Applies a logical '''xor''' to the content of the pixel with the specified value. This includes the alpha channel, so if you want to preserve the opacity, provide a color ''c'' with alpha channel equal to zero

	`procedure XorVertLine(x, y, y2: int32or64; c: TBGRAPixel); override;`
Xors a vertical line at column ''x'' and at row ''y'' to ''y2''

	`procedure DiscardBitmapChange; inline;`
This item has no description.

	`procedure DoAlphaCorrection;`
This item has no description.

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

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

procedure Init; override;

This item has no description. Showing description inherited from TCustomUniversalBitmap.Init.

ReadWriteConfig: TBGRAReadWriteConfig;

	`procedure InternalArc(cx,cy,rx,ry: single; StartAngleRad,EndAngleRad: Single; ABorderColor: TBGRAPixel; w: single; AFillColor: TBGRAPixel; AOptions: TArcOptions; ADrawChord: boolean = false; ATexture: IBGRAScanner = nil); override;`
This item has no description.

	`procedure InternalCrossFade(ARect: TRect; Source1, Source2: IBGRAScanner; AFadePos: byte; AFadeMask: IBGRAScanner; mode: TDrawMode = dmDrawWithTransparency);`
This item has no description.

	`procedure InternalTextOutCurved(ACursor: TBGRACustomPathCursor; sUTF8: string; AColor: TBGRAPixel; ATexture: IBGRAScanner; AAlign: TAlignment; ALetterSpacing: single);`
This item has no description.

	`procedure InternalTextOutLetterSpacing(x,y: single; sUTF8: string; AColor: TBGRAPixel; ATexture: IBGRAScanner; AAlign: TAlignment; ALetterSpacing: single);`
This item has no description.

	`procedure InternalTextOutOffset(x, y: single; const sUTF8: string; AColor: TBGRAPixel; ATexture: IBGRAScanner; AOffsets: array of TPointF); override;`
This item has no description.

	`procedure RebuildBitmap; virtual; abstract;`
This item has no description.

	`procedure SetArrowEndOffset(AValue: single); override;`
This item has no description.

	`procedure SetArrowEndRepeat(AValue: integer); override;`
This item has no description.

	`procedure SetArrowEndSize(AValue: TPointF); override;`
This item has no description.

	`procedure SetArrowStartOffset(AValue: single); override;`
This item has no description.

	`procedure SetArrowStartRepeat(AValue: integer); override;`
This item has no description.

	`procedure SetArrowStartSize(AValue: TPointF); override;`
This item has no description.

	`procedure SetCanvasAlphaCorrection(const AValue: boolean); override;`
This item has no description.

	`procedure SetCanvasDrawModeFP(const AValue: TDrawMode); override;`
This item has no description.

	`procedure SetCanvasOpacity(AValue: byte); override;`
This item has no description.

	`procedure SetCustomPenStyle(const AValue: TBGRAPenStyle); override;`
This item has no description.

	`procedure SetFontFullHeight(AHeight: integer); override;`
This item has no description.

	`procedure SetFontHeight(AHeight: integer); override;`
This item has no description.

	`procedure SetFontRenderer(AValue: TBGRACustomFontRenderer); override;`
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 SetPenJoinStyle(const AValue: TPenJoinStyle); override;`
This item has no description.

	`procedure SetPenMiterLimit(const AValue: single); override;`
This item has no description.

	`procedure SetPenStyle(const AValue: TPenStyle); override;`
This item has no description.

Properties

	`property Canvas2D: TBGRACanvas2D read GetCanvas2D;`
Provides a canvas with 2d transformation and similar to HTML5.

	`property CanvasBGRA: TBGRACanvas read GetCanvasBGRA;`
Provides a canvas with opacity and antialiasing

Getting started

Class TBGRADefaultBitmap

Unit

Declaration

Description

Hierarchy

Overview

Fields

Methods

Properties

Description

Fields

Methods

Properties