DIRECTORY
Imager USING [ClassRep, ClipRectangle, ClipRectangleI, Color, ColorOperator, ConcatT, Context, DoSave, DoSaveAll, DrawSampledColor, Error, GetProp, MaskBitmap, MaskPixel, MaskRectangleI, Move, Object, PathProc, PutProp, ROPE, SetColor, SetGray, SetXY, Trans],
ImagerBackdoor USING [AccessBuffer, AccessBufferRectangle, CoordSys, GetBounds, GetTransformation, Visibility],
ImagerBox USING [Box, BoxFromRectangle, IntersectBox, Rectangle],
ImagerFont USING [MapText, XChar, XStringProc],
ImagerPixel USING [MakePixelMap, PixelMap, PixelMapRep],
ImagerPixelArray USING [FromPixelMap, PixelArray],
ImagerPrivate USING [Class, ClassRep],
ImagerSample USING [Copy, GetBox, SampleMap, Transfer],
ImagerStroke USING [Dashes],
ImagerSys USING [CheckForAbort],
ImagerTransformation USING [ApplyPreTranslate, ApplySFToXY, Destroy, ScanMode, Transform, Transformation, TransformVec, Translate],
Prop USING [Get, Put, Rem, PropList],
SF USING [Box, SizeF, SizeS, Vec],
Vector2 USING [VEC];
~
BEGIN
Class: TYPE ~ ImagerPrivate.Class;
ClassRep: PUBLIC TYPE ~ ImagerPrivate.ClassRep; -- export to Imager.ClassRep
Context: TYPE ~ Imager.Context;
Transformation: TYPE ~ ImagerTransformation.Transformation;
PixelArray: TYPE ~ ImagerPixelArray.PixelArray;
CoordSys: TYPE ~ ImagerBackdoor.CoordSys;
Visibility: TYPE ~ ImagerBackdoor.Visibility;
ColorOperator: TYPE ~ Imager.ColorOperator;
PixelMap: TYPE ~ ImagerPixel.PixelMap;
PathProc: TYPE ~ Imager.PathProc;
noViewOps: Imager.ROPE ~ "View operations not implemented for this context";
DefaultShowAndFixedXRel:
PUBLIC
PROC [context: Context, string: ImagerFont.XStringProc, x:
REAL] ~ {
class: Class ~ context.class;
first: BOOL ¬ TRUE;
eachChar:
PROC [char: ImagerFont.XChar] ~ {
thisChar: ImagerFont.XStringProc ~ { charAction[char] };
IF first THEN first ¬ FALSE ELSE class.SetXYRel[context, [x, 0]];
class.Show[context: context, string: thisChar, xrel: FALSE];
};
string[eachChar];
};
DefaultShowText:
PUBLIC
PROC [context: Context, text:
REF
READONLY
TEXT,
start: NAT ¬ 0, len: NAT ¬ NAT.LAST, xrel: BOOL ¬ FALSE] ~ {
class: Class ~ context.class;
string: ImagerFont.XStringProc ~ { ImagerFont.MapText[text, start, len, charAction] };
ImagerSys.CheckForAbort[];
class.Show[context, string, xrel];
};
DefaultMaskRectangleI:
PUBLIC
PROC [context: Context, x, y, w, h:
INTEGER] ~ {
class: Class ~ context.class;
class.MaskRectangle[context, [x: x, y: y, w: w, h: h]];
};
DefaultMaskVector:
PUBLIC
PROC [context: Context, p1, p2: Vector2.
VEC] ~ {
class: Class ~ context.class;
vectorPath: Imager.PathProc ~ { moveTo[p1]; lineTo[p2] };
class.MaskStroke[context: context, path: vectorPath, closed: FALSE];
};
DefaultMaskDashedStroke:
PUBLIC
PROC [context: Context, path: Imager.PathProc, patternLen:
NAT, pattern:
PROC [
NAT]
RETURNS [
REAL], offset, length:
REAL] ~ {
class: Class ~ context.class;
dashedPath: Imager.PathProc ~ { ImagerStroke.Dashes[path: path, patternLen: patternLen, pattern: pattern, offset: offset, length: length, moveTo: moveTo, lineTo: lineTo, conicTo: conicTo, curveTo: curveTo] };
class.MaskStroke[context: context, path: dashedPath, closed: FALSE];
};
DefaultMaskBitmap:
PUBLIC
PROC [context: Context, bitmap: ImagerSample.SampleMap, referencePoint:
SF.Vec,
scanMode: ImagerTransformation.ScanMode, position: Vector2.VEC] ~ {
box: SF.Box ~ ImagerSample.GetBox[bitmap];
pa: PixelArray ~ ImagerPixelArray.FromPixelMap[pixelMap: ImagerPixel.MakePixelMap[bitmap], box: box, scanMode: [slow: right, fast: up], immutable: FALSE];
ImagerTransformation.ApplyPreTranslate[pa.m, position];
ImagerTransformation.ApplySFToXY[pa.m, scanMode, 0, 0];
ImagerTransformation.ApplyPreTranslate[pa.m, [box.min.s-referencePoint.s, box.min.f-referencePoint.f]];
Imager.MaskPixel[context, pa];
};
DefaultDrawBitmap:
PUBLIC
PROC [context: Context, bitmap: ImagerSample.SampleMap, referencePoint:
SF.Vec,
scanMode: ImagerTransformation.ScanMode, position: Vector2.VEC] ~ {
proc:
PROC ~ {
box: SF.Box ~ ImagerSample.GetBox[bitmap];
m: Transformation ¬ ImagerTransformation.Translate[position];
ImagerTransformation.ApplySFToXY[m, scanMode, 0, 0];
ImagerTransformation.ApplyPreTranslate[m, [-referencePoint.s, -referencePoint.f]];
Imager.ConcatT[context, m];
Imager.SetGray[context, 0];
Imager.MaskRectangleI[context: context, x: box.min.s, y: box.min.f, w: SF.SizeS[box], h: SF.SizeF[box]];
Imager.SetGray[context, 1];
Imager.MaskBitmap[context: context, bitmap: bitmap, referencePoint: [0, 0], scanMode: [slow: right, fast: up], position: [0, 0]];
};
Imager.DoSave[context, proc];
};
DefaultDrawPixels:
PUBLIC
PROC [context: Context, pixelMap: ImagerPixel.PixelMap, colorOperator: Imager.ColorOperator, referencePoint:
SF.Vec, scanMode: ImagerTransformation.ScanMode, position: Vector2.
VEC] ~ {
pa: PixelArray ~ ImagerPixelArray.FromPixelMap[pixelMap: pixelMap, box: pixelMap.box, scanMode: [slow: right, fast: up], immutable: FALSE];
ImagerTransformation.ApplySFToXY[pa.m, scanMode, 0, 0];
ImagerTransformation.ApplyPreTranslate[pa.m, [pixelMap.box.min.s-referencePoint.s, pixelMap.box.min.f-referencePoint.f]];
Imager.DrawSampledColor[context: context, pa: pa, colorOperator: colorOperator, m: NIL, position: position];
};
DefaultViewReset:
PUBLIC
PROC [context: Context] ~ {
Imager.Error[[$unimplemented, noViewOps]];
};
DefaultViewTranslateI:
PUBLIC
PROC [context: Context, x, y:
INTEGER] ~ {
Imager.Error[[$unimplemented, noViewOps]];
};
DefaultViewClip:
PUBLIC
PROC [context: Context, path: Imager.PathProc, oddWrap:
BOOL, exclude:
BOOL] ~ {
Imager.Error[[$unimplemented, noViewOps]];
};
DefaultViewClipRectangleI:
PUBLIC
PROC [context: Context, x, y, w, h:
INTEGER, exclude:
BOOL] ~ {
Imager.Error[[$unimplemented, noViewOps]];
};
DefaultGetTransformation:
PUBLIC
PROC [context: Context, from, to: CoordSys]
RETURNS [Transformation] ~ {
Imager.Error[[$unimplemented, noViewOps]];
};
DefaultTransform:
PUBLIC
PROC [context: Context, v: Vector2.
VEC, from, to: CoordSys, vec:
BOOL]
RETURNS [Vector2.
VEC] ~ {
M: Transformation ~ ImagerBackdoor.GetTransformation[context: context, from: from, to: to];
vM: Vector2.VEC ~ (IF vec THEN ImagerTransformation.TransformVec ELSE ImagerTransformation.Transform)[M, v];
ImagerTransformation.Destroy[M];
RETURN [vM];
};
DefaultMoveViewRectangle:
PUBLIC
PROC [context: Context, width, height, fromX, fromY, toX, toY:
INTEGER] ~ {
Imager.Error[[$unimplemented, noViewOps]];
};
DefaultTestViewRectangle: PUBLIC PROC [context: Context, x, y, w, h: INTEGER] RETURNS [Visibility] ~ { RETURN [part] };
DefaultGetBounds:
PUBLIC
PROC [context: Context]
RETURNS [ImagerBox.Rectangle] ~ {
Imager.Error[[$unimplemented, "GetBounds not implemented for this context"]];
};
DefaultDoIfVisible:
PUBLIC
PROC [context: Context, r: ImagerBox.Rectangle, action:
PROC] ~ {
class: Class ~ context.class;
br: ImagerBox.Rectangle ¬ r;
IF class.GetBounds # DefaultGetBounds
THEN {
br ¬ class.GetBounds[context ! Imager.Error => CONTINUE];
};
{ bb: ImagerBox.Box ~ ImagerBox.BoxFromRectangle[br];
cb: ImagerBox.Box ~ ImagerBox.BoxFromRectangle[r];
ib: ImagerBox.Box ~ ImagerBox.IntersectBox[bb, cb];
IF ib.xmin < ib.xmax AND ib.ymin < ib.ymax THEN action[];
};
};
DefaultDoWithBuffer:
PUBLIC
PROC [context: Context, action:
PROC, x, y, w, h:
INTEGER, backgroundColor: Imager.Color ¬
NIL] ~ {
paintBack:
PROC ~ {
Imager.SetColor[context, backgroundColor];
Imager.MaskRectangleI[context, x, y, w, h];
};
clippedAction:
PROC ~ {
Imager.ClipRectangleI[context, x, y, w, h];
IF backgroundColor # NIL THEN Imager.DoSave[context, paintBack];
action[];
};
Imager.DoSave[context, clippedAction];
};
DefaultDrawObject:
PUBLIC
PROC [context: Context, object: Imager.Object, position: Vector2.
VEC, interactive:
BOOL] ~ {
proc:
PROC ~ {
Imager.SetXY[context, position];
IF interactive THEN Imager.Trans[context] ELSE Imager.Move[context];
Imager.ClipRectangle[context, object.clip];
object.draw[object, context]
};
Imager.DoSaveAll[context, proc];
};
DefaultGetBufferColorOperator:
PUBLIC
PROC [context: Context]
RETURNS [ColorOperator] ~ {
RETURN [
NIL] };
DefaultAccessBuffer:
PUBLIC
PROC [context: Context, action:
PROC [pixelMap: PixelMap], path: PathProc, oddWrap:
BOOL] ~ {
Imager.Error[[$unimplemented, "Buffer access not implemented for this context"]];
};
DefaultSaveBuffer:
PUBLIC
PROC [context: Context, id:
ATOM, path: PathProc, oddWrap:
BOOL] ~ {
pixelMaps: LIST OF PixelMap ¬ NIL;
action:
PROC [pixelMap: PixelMap] ~ {
copy: PixelMap ~ NEW[ImagerPixel.PixelMapRep[pixelMap.samplesPerPixel]];
copy.box ¬ pixelMap.box;
FOR i:
NAT
IN [0..pixelMap.samplesPerPixel)
DO
copy[i] ¬ ImagerSample.Copy[pixelMap[i]];
ENDLOOP;
pixelMaps ¬ CONS[copy, pixelMaps];
};
savedBuffers: Prop.PropList ¬ NARROW[Imager.GetProp[context, $SavedBuffers]];
ImagerBackdoor.AccessBuffer[context: context, action: action, path: path, oddWrap: oddWrap];
savedBuffers ¬ Prop.Put[savedBuffers, id, pixelMaps];
Imager.PutProp[context, $SavedBuffers, savedBuffers];
};
DefaultRestoreBuffer:
PUBLIC
PROC [context: Context, id:
ATOM] ~ {
savedBuffers: Prop.PropList ~ NARROW[Imager.GetProp[context, $SavedBuffers]];
pixelMaps: LIST OF PixelMap ¬ NARROW[Prop.Get[savedBuffers, id]];
action:
PROC [pixelMap: PixelMap] ~ {
FOR each:
LIST
OF PixelMap ¬ pixelMaps, each.rest
UNTIL each =
NIL
DO
src: PixelMap ~ each.first;
FOR i:
NAT
IN [0..src.samplesPerPixel)
DO
ImagerSample.Transfer[dst: pixelMap[i], src: src[i]];
ENDLOOP;
ENDLOOP;
};
ImagerBackdoor.AccessBufferRectangle[context: context, action: action, rectangle: ImagerBackdoor.GetBounds[context]];
};
DefaultDiscardBuffer:
PUBLIC
PROC [context: Context, id:
ATOM] ~ {
savedBuffers: Prop.PropList ¬ NARROW[Imager.GetProp[context, $SavedBuffers]];
savedBuffers ¬ Prop.Rem[savedBuffers, id];
Imager.PutProp[context, $SavedBuffers, savedBuffers];
Rely of garbage collection to reclaim storage.
};
END.