DIRECTORY
Imager, ImagerTransformation, IO, List, 
Pipal, PipalInt, PipalMutate, PipalOps, PipalOverlayMutant, PipalPaint, PipalReal, 
Real, RefTab, TerminalIO;

PipalOverlayMutantImpl: CEDAR PROGRAM
IMPORTS Imager, ImagerTransformation, IO, List, Pipal, PipalMutate, PipalInt, PipalOps, PipalPaint, PipalReal, Real, RefTab, TerminalIO
EXPORTS PipalOverlayMutant =
BEGIN OPEN PipalOverlayMutant;
overlayMutantClass: PUBLIC Pipal.Class _ Pipal.RegisterClass["OverlayMutant", CODE [OverlayMutantRec]];

Do: PROC [old: OverlayMutant, message: Pipal.ROPE, overlay: Pipal.Overlay, selected: Pipal.Objects] RETURNS [new: OverlayMutant] = {
new _ NEW [OverlayMutantRec _ [
overlay: overlay, 
selected: selected,
undoRedo: PipalOps.Do[old.undoRedo, message, old] 
]];
};

ReplaceOverlayMutant: PipalOps.ReplaceProc = {
om: OverlayMutant _ NARROW [parent];
selected: Pipal.Objects _ NIL;
FOR objects: Pipal.Objects _ om.selected, objects.rest UNTIL objects=NIL DO
selected _ CONS [map[objects.first], selected];
ENDLOOP;
newParent _ Do[om, "Replace", NARROW [map[om.overlay]], selected];
};

EnumerateOverlayMutant: PipalOps.EnumerateProc = {
om: OverlayMutant = NARROW [object];
IF each[om.overlay] THEN RETURN [TRUE];
FOR objects: Pipal.Objects _ om.selected, objects.rest UNTIL objects=NIL DO
IF each[objects.first] THEN RETURN [TRUE];
ENDLOOP; 
};

OverlayMutantSize: PipalReal.SizeProc = {
om: OverlayMutant = NARROW [object];
size _ PipalReal.ObjectSize[om.overlay];
};

PaintOverlayMutant: PipalPaint.PaintProc = {
transformation: PipalReal.Transformation _ PipalReal.CreateTransformation[]; -- changed the day PaintProcs have a transformation
om: OverlayMutant = NARROW [object];
PipalPaint.Paint[om.overlay, context];
FOR objects: Pipal.Objects _ om.selected, objects.rest UNTIL objects=NIL DO
PipalPaint.PaintOutline[context, PipalReal.BBox[objects.first, transformation]];
ENDLOOP; 
PipalReal.DestroyTransformation[transformation];
};
Create: PUBLIC PROC [overlay: Pipal.Overlay] RETURNS [om: OverlayMutant] = {
om _ NEW [OverlayMutantRec _ [overlay: overlay]];
};

OverlayFromSelection: PROC [om: OverlayMutant] RETURNS [changedArea: PipalPaint.Area, newOm: OverlayMutant] ~ {
newOv: Pipal.Object;
children, selected, changed: Pipal.Objects _ NIL;
new: Pipal.Objects _ NIL;
translation: PipalInt.Vector;
[children, selected, changed] _ SplitThem[om];
translation _ ChildrenBBox[selected].base;
new _ TransformObjects[[PipalInt.Neg[translation]], selected];
newOv _ PipalInt.TransformObject[[translation], Pipal.CreateOverlay[new]];
changed _ CONS [PipalPaint.ChildArea[newOv, bboxChild], changed];
children _ CONS [newOv, children];
newOm _ Do[om, IO.PutFR["overlay "], Pipal.CreateOverlay[children], LIST [newOv]];
changedArea _ Pipal.CreateOverlay[changed];
};

InsertInt: PUBLIC PROC [om: OverlayMutant, child: Pipal.Object, position: PipalInt.Position, selectNew: BOOL _ TRUE] RETURNS [new: OverlayMutant] = {
new _ Insert[om, IO.int[position.x], IO.int[position.y], PipalInt.TransformObject[[translation: position], child], selectNew];
};

InsertReal: PUBLIC PROC [om: OverlayMutant, child: Pipal.Object, position: PipalReal.Position, selectNew: BOOL _ TRUE] RETURNS [new: OverlayMutant] = {
transformation: PipalReal.Transformation _ ImagerTransformation.Translate[position];
new _ Insert[om, IO.real[position.x], IO.real[position.y], PipalReal.TransformObject[transformation, child], selectNew];
};

Insert: PROC [om: OverlayMutant, x, y: IO.Value, child: Pipal.Object, selectNew: BOOL] RETURNS [new: OverlayMutant] = {
children: Pipal.Objects _ Pipal.ExpandOverlay[om.overlay];
children _ CONS [child, children];
new _ Do[om, IO.PutFR["insert of %g at [%g, %g]", IO.rope[Pipal.DescribeToRope[child, 0, 1]], x, y], Pipal.CreateOverlay[children], IF selectNew THEN LIST [child] ELSE om.selected];
};

Delete: PUBLIC PROC [om: OverlayMutant] RETURNS [changedArea: PipalPaint.Area, new: OverlayMutant] = {
children: Pipal.Objects _ NIL;
changed: Pipal.Objects _ NIL;
[children, , changed] _ SplitThem[om];
new _ Do[om, IO.PutFR["delete "], Pipal.CreateOverlay[children], NIL];
changedArea _ Pipal.CreateOverlay[changed];
};

CopyInt: PROC [om: OverlayMutant, vector: PipalInt.Vector, selectNew: BOOL _ TRUE] RETURNS [changedArea: PipalPaint.Area, new: OverlayMutant] = {
changed: Pipal.Objects _ NIL;
children: Pipal.Objects _ Pipal.ExpandOverlay[om.overlay];
selected: Pipal.Objects _ NIL;
transformation: PipalInt.Transformation = [translation: vector];
FOR i: NAT IN [0 .. om.overlay.size) DO
child: Pipal.Object _ om.overlay[i];
IF Pipal.Member[om.selected, child] THEN {
new: Pipal.Object _ PipalInt.TransformObject[transformation, child];
children _ CONS [new, children];
selected _ CONS [new, selected];
changed _ CONS [PipalPaint.ChildArea[child, bboxChild], changed];
changed _ CONS [PipalPaint.ChildArea[new, bboxChild], changed];
};
ENDLOOP;
new _ Do[om, IO.PutFR["copy translated by [%g, %g]", IO.int[vector.x], IO.int[vector.y]], Pipal.CreateOverlay[children], IF selectNew THEN selected ELSE om.selected];
changedArea _ Pipal.CreateOverlay[changed];
};

MoveInt: PROC [om: OverlayMutant, transformation: PipalInt.Transformation] RETURNS [changedArea: PipalPaint.Area, new: OverlayMutant] ~ {
changed: Pipal.Objects _ NIL;
children: Pipal.Objects _ NIL;
selected: Pipal.Objects _ NIL;
FOR i: NAT IN [0 .. om.overlay.size) DO
child: Pipal.Object _ om.overlay[i];
IF Pipal.Member[om.selected, child] THEN {
new: Pipal.Object _ PipalInt.TransformObject[transformation, child];
children _ CONS [new, children];
selected _ CONS [new, selected];
changed _ CONS [PipalPaint.ChildArea[child, bboxChild], changed];
changed _ CONS [PipalPaint.ChildArea[new, bboxChild], changed];
} ELSE children _ CONS [child, children];
ENDLOOP;
new _ Do[om, IO.PutFR["move by %g", IO.rope[PipalInt.TransformationToRope[transformation]]], Pipal.CreateOverlay[children], selected];
changedArea _ Pipal.CreateOverlay[changed];
};

MoveReal: PROC [om: OverlayMutant, transformation: PipalReal.Transformation] RETURNS [changedArea: PipalPaint.Area, new: OverlayMutant] ~ {
changed: Pipal.Objects _ NIL;
children: Pipal.Objects _ NIL;
selected: Pipal.Objects _ NIL;
FOR i: NAT IN [0 .. om.overlay.size) DO
child: Pipal.Object _ om.overlay[i];
IF Pipal.Member[om.selected, child] THEN {
new: Pipal.Object _ PipalReal.TransformObject[transformation, child];
children _ CONS [new, children];
selected _ CONS [new, selected];
changed _ CONS [PipalPaint.ChildArea[child, bboxChild], changed];
changed _ CONS [PipalPaint.ChildArea[new, bboxChild], changed];
} ELSE children _ CONS [child, children];
ENDLOOP;
new _ Do[om, IO.PutFR["move by %g", IO.rope[PipalReal.TransformationToRope[transformation]]], Pipal.CreateOverlay[children], selected];
changedArea _ Pipal.CreateOverlay[changed];
};

Select: PUBLIC PROC [om: OverlayMutant, exclusive: BOOL _ TRUE, remove: BOOL _ FALSE, style: ATOM, pos1: PipalReal.Position, pos2: PipalReal.Position] RETURNS [changedArea: PipalPaint.Area, new: OverlayMutant] = {
AddOrRemove: PROC [child: Pipal.Object] = {
(IF remove THEN Remove ELSE Add)[child];
};
Remove: PROC [child: Pipal.Object] = {
selected _ Pipal.Delete[selected, child];
changed _ CONS [PipalPaint.ChildArea[child, edgesChild], changed];
};
Add: PROC [child: Pipal.Object] = {
selected _ Pipal.Add[selected, child];
changed _ CONS [PipalPaint.ChildArea[child, edgesChild], changed];
};
changed: Pipal.Objects _ NIL;
selected: Pipal.Objects _ om.selected;
rect: PipalReal.Rectangle _ PipalReal.BoundingRectangle[pos1, pos2];
transformation: PipalReal.Transformation _ PipalReal.CreateTransformation[];
IF exclusive THEN WHILE selected#NIL DO Remove[selected.first] ENDLOOP;
SELECT style FROM
$Point => FOR i: NAT IN [0 .. om.overlay.size) DO
IF ~PipalReal.IsInsidePoint[PipalReal.BBox[om.overlay[i], transformation], rect.base] THEN LOOP;
AddOrRemove[om.overlay[i]];
TerminalIO.PutF["Selected: %g.\n", IO.rope[Pipal.DescribeToRope[om.overlay[i], 0, 1]]];
EXIT;
ENDLOOP;
$Area => {
count: INT _ 0;
FOR i: NAT IN [0 .. om.overlay.size) DO
IF ~PipalReal.IsInsideRectangle[rect, PipalReal.BBox[om.overlay[i], transformation]] THEN LOOP;
AddOrRemove[om.overlay[i]];
count _ count+1;
ENDLOOP;
TerminalIO.PutF["%g objects (de)selected in area.\n", IO.int[count]];
};
$Touch => {
count: INT _ 0;
FOR i: NAT IN [0 .. om.overlay.size) DO
IF ~PipalReal.DoRectanglesIntersect[PipalReal.BBox[om.overlay[i], transformation], rect] THEN LOOP;
AddOrRemove[om.overlay[i]];
count _ count+1;
ENDLOOP;
TerminalIO.PutF["%g objects touch-(de)selected.\n", IO.int[count]];
};
$Close => ERROR;
ENDCASE => ERROR;
PipalReal.DestroyTransformation[transformation];
new _ Do[om, "Select", om.overlay, selected];
changedArea _ Pipal.CreateOverlay[changed];
};

TransformInt: PROC [om: OverlayMutant, transformation: PipalInt.Transformation] RETURNS [changedArea: PipalPaint.Area, new: OverlayMutant] = {
children, selected, changed: Pipal.Objects _ NIL;
translation, fudgeFactor: PipalInt.Vector;
[children, selected, changed] _ SplitThem[om];
translation _ ChildrenBBox[selected].base;
selected _ TransformObjects[[PipalInt.Neg[translation]], selected];
selected _ TransformObjects[transformation, selected];
fudgeFactor _ ChildrenBBox[selected].base;
selected _ TransformObjects[[PipalInt.Neg[fudgeFactor]], selected];
selected _ TransformObjects[[translation], selected];
children _ List.Append[children, selected];
changed _ List.Append[changed, ChildrenAreaAnnotation[selected]];
new _ Do[om, IO.PutFR["transform by %g", IO.rope[PipalInt.TransformationToRope[transformation]]], Pipal.CreateOverlay[children], selected];
changedArea _ Pipal.CreateOverlay[changed];
};

SplitThem: PROC [om: OverlayMutant] RETURNS [unselected, selected, changed: Pipal.Objects _ NIL] ~ {
FOR i: NAT IN [0 .. om.overlay.size) DO
child: Pipal.Object _ om.overlay[i];
IF ~Pipal.Member[om.selected, child] THEN unselected _ CONS [child, unselected]
ELSE {
selected _ CONS [child, selected];
changed _ CONS [PipalPaint.ChildArea[child, bboxChild], changed];
};
ENDLOOP;
};

SingleSelection: PROC [om: OverlayMutant] RETURNS [selected: Pipal.Object _ NIL] = {
SELECT TRUE FROM
om.selected=NIL => ERROR Pipal.Error[$noSelection];
om.selected.rest#NIL => ERROR Pipal.Error[$multipleSelections];
ENDCASE => selected _ om.selected.first;
};
TransformObjects: PROC [transformation: PipalInt.Transformation, children: Pipal.Objects] RETURNS [new: Pipal.Objects _ NIL] = {
FOR list: Pipal.Objects _ children, list.rest WHILE list#NIL DO
new _ CONS [PipalInt.TransformObject[transformation, list.first], new];
ENDLOOP;
};
ChildrenBBox: PROC [children: Pipal.Objects] RETURNS [bbox: PipalInt.Rectangle _ PipalInt.emptyRectangle] = {
FOR list: Pipal.Objects _ children, list.rest WHILE list#NIL DO
bbox _ PipalInt.BoundingBox[bbox, PipalInt.BBox[list.first, []]];
ENDLOOP;
};
ChildrenAreaAnnotation: PROC [children: Pipal.Objects] RETURNS [changed: Pipal.Objects _ NIL] = {
FOR list: Pipal.Objects _ children, list.rest WHILE list#NIL DO
changed _ CONS [PipalPaint.ChildArea[list.first, bboxChild], changed];
ENDLOOP;
};
MutateOverlay: PipalMutate.MutationProc = {
overlay: Pipal.Overlay _ NARROW [object];
mutant _ Create[overlay];
};
CopyIntCommand: PipalMutate.CommandProc = {
om: OverlayMutant = NARROW [mutant];
start: PipalReal.Position _ NARROW [arguments.first, REF PipalReal.Position]^;
end: PipalReal.Position _ NARROW [arguments.rest.first, REF PipalReal.Position]^;
realDelta: PipalReal.Vector = PipalReal.Sub[end, start];
delta: PipalInt.Vector = [Real.Round[realDelta.x], Real.Round[realDelta.y]];
resultType _ changedArea;
[result, new] _ CopyInt[om, [delta.x, delta.y]];
};

MoveIntCommand: PipalMutate.CommandProc = {
om: OverlayMutant = NARROW [mutant];
start: PipalReal.Position _ NARROW [arguments.first, REF PipalReal.Position]^;
end: PipalReal.Position _ NARROW [arguments.rest.first, REF PipalReal.Position]^;
realDelta: PipalReal.Vector = PipalReal.Sub[end, start];
delta: PipalInt.Vector = [Real.Round[realDelta.x], Real.Round[realDelta.y]];
resultType _ changedArea;
[result, new] _ MoveInt[om, [delta]];
};

MoveRealCommand: PipalMutate.CommandProc = {
om: OverlayMutant = NARROW [mutant];
start: PipalReal.Position _ NARROW [arguments.first, REF PipalReal.Position]^;
end: PipalReal.Position _ NARROW [arguments.rest.first, REF PipalReal.Position]^;
delta: PipalReal.Vector = PipalReal.Sub[end, start];
resultType _ changedArea;
[result, new] _ MoveReal[om, ImagerTransformation.Translate[delta]];
};

SelectCommand: PipalMutate.CommandProc = {
om: OverlayMutant = NARROW [mutant];
exclusive, remove: BOOL;
style: ATOM;
pos1, pos2: PipalReal.Position;
SELECT arguments.first FROM
$Add => exclusive _ FALSE;
$Exclusive => exclusive _ TRUE;
ENDCASE => ERROR;
arguments _ arguments.rest;
SELECT arguments.first FROM
$Select => remove _ FALSE;
$Deselect => remove _ TRUE;
ENDCASE => ERROR;
arguments _ arguments.rest;
SELECT arguments.first FROM
$Point, $Area, $Touch, $Close => style _ NARROW [arguments.first];
ENDCASE => ERROR;
arguments _ arguments.rest;
pos1 _ NARROW [arguments.first, REF PipalReal.Position]^;
arguments _ arguments.rest;
pos2 _ IF arguments#NIL THEN NARROW [arguments.first, REF PipalReal.Size]^ ELSE pos1;
IF style=$Area AND pos1=pos2 THEN style _ $Point;
resultType _ changedArea;
[result, new] _ Select[om, exclusive, remove, style, pos1, pos2];
};

SelectedOutlinesCommand: PipalMutate.CommandProc = {
om: OverlayMutant = NARROW [mutant];
changed: Pipal.Objects _ NIL;
changed _ ChildrenAreaAnnotation[om.selected];
resultType _ selectionArea;
new _ mutant;
result _ Pipal.CreateOverlay[changed];
};

DeleteSelectCommand: PipalMutate.CommandProc ~ {
om: OverlayMutant = NARROW [mutant];
resultType _ changedArea;
[result, new] _ Delete[om];
};

MakeOverlayCommand: PipalMutate.CommandProc ~ {
om: OverlayMutant = NARROW [mutant];
resultType _ changedArea;
[result, new] _ OverlayFromSelection[om];
};

TransformSelectCommand: PipalMutate.CommandProc ~ {
om: OverlayMutant = NARROW [mutant];
transformation: PipalInt.Transformation _ SELECT arguments.first FROM
$Rot90 => [ , rotate90],
$Rot270 => [ , rotate270],
$FlipX => [ , mirrorX],
$FlipY => [ , rotate180X],
ENDCASE => ERROR;
resultType _ changedArea;
[result, new] _ TransformInt[om, transformation];
};

DoUndoRedo: PROC [old: OverlayMutant, message: Pipal.ROPE, op: PipalOps.UndoRedoOp] RETURNS [new: OverlayMutant] = {
newUndoRedo: PipalOps.UndoRedo;
newState: REF;
newOM: OverlayMutant;
[newUndoRedo, newState] _ op[old.undoRedo, old];
newOM _ NARROW [newState];
new _ NEW [OverlayMutantRec _ [
overlay: newOM.overlay, 
selected: newOM.selected,
undoRedo: newUndoRedo 
]];
};

ResetCommand: PipalMutate.CommandProc ~ {
om: OverlayMutant = NARROW [mutant];
new _ DoUndoRedo[om, "Reset", PipalOps.Reset];
};

UndoCommand: PipalMutate.CommandProc ~ {
om: OverlayMutant = NARROW [mutant];
IF om.undoRedo.undo=NIL 
THEN {TerminalIO.PutF["*** Cant Undo!\n"]; RETURN [changedArea, Pipal.void, om]};
new _ DoUndoRedo[om, "Undo", PipalOps.Undo];
};

RedoCommand: PipalMutate.CommandProc ~ {
om: OverlayMutant = NARROW [mutant];
IF om.undoRedo.redo=NIL 
THEN {TerminalIO.PutF["*** Cant Redo!\n"]; RETURN [changedArea, Pipal.void, om]};
new _ DoUndoRedo[om, "Redo", PipalOps.Redo];
};

FlushCommand: PipalMutate.CommandProc ~ {
om: OverlayMutant = NARROW [mutant];
new _ NEW [OverlayMutantRec _ [
overlay: om.overlay, 
selected: om.selected,
undoRedo: []
]];
RETURN [changedArea, Pipal.void, new];
};
PopData: TYPE = REF PopDataRec;
PopDataRec: TYPE = RECORD [om: OverlayMutant, editable: Pipal.Object, selected: Pipal.Object, path: PipalOps.Path, newMutant: Pipal.Object];

OverlayPopWatchDog: PipalOps.WatchDog = {
pd: PopData _ NARROW [registrationData];
newMutant: Pipal.Object _ NARROW [arg1];
new: Pipal.Object _ NARROW [arg2];
table: PipalOps.ReplaceTable _ RefTab.Create[];
IF newMutant#pd.newMutant THEN RETURN; -- irrelevant pop!
IF TerminalIO.Confirm["Global Replace"] 
THEN {[] _ RefTab.Store[table, pd.editable, new]; PipalOps.BroadcastReplace[table]}
ELSE {
om: OverlayMutant = pd.om;
newSelected: Pipal.Object;
table _ PipalOps.ReplaceInPath[pd.selected, pd.path, pd.editable, new];
newSelected _ RefTab.Fetch[table, pd.selected].val;
table _ RefTab.Create[];
[] _ RefTab.Store[table, pd.selected, newSelected];
PipalOps.TransitiveReplace[om.overlay, table];
};
};

RegisterPopWatchDog: PROC [pdr: PopDataRec] = {
PipalOps.RegisterWatchDog[PipalMutate.popEvent, OverlayPopWatchDog, NEW [PopDataRec _ pdr]];
};

Push: PUBLIC PROC [om: OverlayMutant] RETURNS [mutants: Pipal.Objects _ NIL, new: OverlayMutant] = {
count: NAT _ 0;
FOR selected: Pipal.Objects _ om.selected, selected.rest UNTIL selected=NIL DO
EachEditableChild: PipalMutate.EachChildProc = {
newMutant: Pipal.Object _ PipalMutate.Mutation[child];
mutants _ CONS [newMutant, mutants];
count _ count + 1;
RegisterPopWatchDog[[om, child, root, path, newMutant]];
};
root: Pipal.Object = selected.first;
[] _ PipalMutate.EnumerateMutantChildren[root, EachEditableChild];
ENDLOOP;
new _ Do[om, IO.PutFR["Pushing in %g objects", IO.int[count]], om.overlay, om.selected];
};
PipalMutate.RegisterCommand[overlayMutantClass, $Select, SelectCommand];
PipalMutate.RegisterCommand[overlayMutantClass, $SelectedOutlines, SelectedOutlinesCommand];

PipalMutate.RegisterCommand[overlayMutantClass, $MoveInt, MoveIntCommand];
PipalMutate.RegisterCommand[overlayMutantClass, $MoveReal, MoveRealCommand];
PipalMutate.RegisterCommand[overlayMutantClass, $CopyInt, CopyIntCommand];
PipalMutate.RegisterCommand[overlayMutantClass, $DeleteSelect, DeleteSelectCommand];
PipalMutate.RegisterCommand[overlayMutantClass, $MakeOverlay, MakeOverlayCommand];
PipalMutate.RegisterCommand[overlayMutantClass, $TransformSelect, TransformSelectCommand];

PipalMutate.RegisterCommand[overlayMutantClass, $Reset, ResetCommand];
PipalMutate.RegisterCommand[overlayMutantClass, $Undo, UndoCommand];
PipalMutate.RegisterCommand[overlayMutantClass, $Redo, RedoCommand];
PipalMutate.RegisterCommand[overlayMutantClass, $Flush, FlushCommand];

Pipal.PutClassMethod[overlayMutantClass, PipalOps.replaceMethod, NEW [PipalOps.ReplaceProc _ ReplaceOverlayMutant]];
Pipal.PutClassMethod[overlayMutantClass, PipalOps.enumerateMethod, NEW [PipalOps.EnumerateProc _ EnumerateOverlayMutant]];
Pipal.PutClassMethod[overlayMutantClass, PipalReal.sizeMethod, NEW [PipalReal.SizeProc _ OverlayMutantSize]];
Pipal.PutClassMethod[overlayMutantClass, PipalPaint.paintMethod, NEW [PipalPaint.PaintProc _ PaintOverlayMutant]];

Pipal.PutClassMethod[Pipal.overlayClass, PipalMutate.mutationMethod, NEW [PipalMutate.MutationProc _ MutateOverlay]];

END.
ΦPipalOverlayMutantImpl.mesa
Copyright Σ 1988 by Xerox Corporation.  All rights reserved.
Barth, January 28, 1988 6:21:44 pm PST
Bertrand Serlet May 11, 1988 11:55:58 pm PDT
Louis Monier February 2, 1988 3:37:24 pm PST

Class
draw a box around the abut box of each item
Basic Operations
Object Manipulation
FlattenSelected: PROC [mutant: OverlayMutant] RETURNS [changedArea: PipalPaint.Area] ~ {
-- for every selected object
check if there is an enumerate proc
enumerate the guts of selection and replace by children, properly transformed
};

Copy
Move
Selection
Transformations
Utilities





Commands
first argument tells if we should get rid of existing selection
second argument tells if we select/deselect
third argument tells the style
fourth argument is pos1
fifth argument may be pos2
FlattenCommand: PipalMutate.CommandProc ~ {
resultType _ changedArea;
[result, new] _ FlattenSelected[mutant];
};
Undo/Redo Commands
Push
PipalMutate.Do[om, IO.PutFR["Pop new: %g replaced by %g", IO.rope[Pipal.DescribeToRope[pd.editable, 0, 1]], IO.rope[Pipal.DescribeToRope[new, 0, 1]]], RefTab.Fetch[table, om.overlay].val, CreateOverlayMutant[]];
Initialization
PipalMutate.RegisterCommand[overlayMutantClass, $Flatten, FlattenCommand];
ΚΨ–

"cedar" style˜
codeš
œ™Kš
œ<™<Kšœ#Οk™&Kš
œ,™,Kšœ)™,K™—š
	˜	Kšœœ˜(Kš
œS˜SKš
œ˜—K˜•StartOfExpansion[]šΟnœœ
˜%Kšœœ_˜‡
Kšœ˜Kšœ
œ˜—
head™šœœ4œ˜gK˜—šžœœ%œ3œ˜„
šœœ˜Kš
œ˜Kš
œ˜Kš
œ2˜2K˜—K˜K˜—šžœ˜.Kšœœ
˜$Kšœœ
˜šœ4œ	œ
˜KKšœœ ˜/Kšœ
˜—Kšœœ˜BK˜K˜—šžœ˜2Kšœœ
˜$Kšœœ
œœ˜'šœ4œ	œ
˜KKšœœ
œœ˜*Kšœ˜	—K˜K˜—šžœ˜)Kšœœ
˜$Kš
œ(˜(K˜K˜—šžœ˜,KšœMΟc3˜€
Kšœœ
˜$Kš
œ&˜&šœ4œ	œ
˜KK™+Kš
œP˜PKšœ˜	—Kš
œ0˜0K˜——™šžœœ
œœ˜LKšœœ)˜1K˜K˜——™šžœœœ9˜oKš
œ˜Kšœ-œ
˜1Kšœœ
˜Kš
œ˜Kš
œ.˜.Kš
œ*˜*Kš
œ>˜>Kš
œJ˜JKšœ
œ3˜AKšœœ˜"Kšœœ3œ
˜RKš
œ+˜+K˜K˜—šžœœœ#™Xš
Ÿ™K™#K™M—K™K™—šž	œœ
œRœœœ˜•
KšœœœW˜~K˜K˜—šž
œœ
œSœœœ˜—
Kš
œT˜TKšœœœP˜xK˜K˜—š
žœœœ(œœ˜wKš
œ:˜:Kšœœ˜"Kš
œ
œ#œPœœ
œ	œ˜΅
K˜K˜—šžœœ
œœ7˜fKšœœ
˜Kšœœ
˜Kš
œ&˜&Kšœ
œ2œ˜FKš
œ+˜+K˜K˜——™š
žœœ9œœœ7˜‘
Kšœœ
˜Kš
œ:˜:Kšœœ
˜Kš
œ@˜@šœœ
œ˜'Kš
œ$˜$šœ"œ˜*Kš
œD˜DKšœœ˜ Kšœœ˜ Kšœ
œ3˜AKšœ
œ1˜?Kš
œ˜—Kšœ
˜—Kš
œ
œ&œœ0œœ
œ˜¦
Kš
œ+˜+K˜K˜——™šžœœ>œ7˜‰
Kšœœ
˜Kšœœ
˜Kšœœ
˜šœœ
œ˜'Kš
œ$˜$šœ"œ˜*Kš
œD˜DKšœœ˜ Kšœœ˜ Kšœ
œ3˜AKšœ
œ1˜?Kšœœœ˜)—Kšœ
˜—Kšœ
œœ`˜†
Kš
œ+˜+K˜K˜—šžœœ?œ7˜‹
Kšœœ
˜Kšœœ
˜Kšœœ
˜šœœ
œ˜'Kš
œ$˜$šœ"œ˜*Kš
œE˜EKšœœ˜ Kšœœ˜ Kšœ
œ3˜AKšœ
œ1˜?Kšœœœ˜)—Kšœ
˜—Kšœ
œœa˜‡
Kš
œ+˜+K˜K˜——™	šžœœ
œ œœ
œœ	œ6œ7˜Υ
šžœœ˜+Kšœ
œœœ
˜(K˜—šžœœ˜&Kš
œ)˜)Kšœ
œ4˜BK˜—šžœœ˜#Kš
œ&˜&Kšœ
œ4˜BK˜—Kšœœ
˜Kš
œ&˜&Kš
œD˜DKš
œL˜LJšœœ
œ
œ
œœ
˜Gšœ˜šœ
œœ
œ˜1KšœTœ
œ
˜`Kš
œ˜Kšœ#œ2˜WKšœ
˜Kšœ
˜—š
œ
˜
Jšœœ˜šœœ
œ˜'KšœSœ
œ
˜_Kš
œ˜Kš
œ˜Kšœ
˜—Kšœ6œ
˜EK˜—š
œ˜Jšœœ˜šœœ
œ˜'KšœWœ
œ
˜cKš
œ˜Kš
œ˜Kšœ
˜—Kšœ4œ
˜CK˜—Kšœ
œ
˜Kšœœ
˜—Kš
œ0˜0Kš
œ-˜-Kš
œ+˜+K˜K˜——™šžœœ>œ7˜Ž
Kšœ-œ
˜1Kš
œ*˜*Kš
œ.˜.Kš
œ*˜*Kš
œC˜CKš
œ6˜6Kš
œ*˜*Kš
œC˜CKš
œ5˜5Kš
œ+˜+Kš
œA˜AKšœ
œœ`˜‹
Kš
œ+˜+K˜K˜——™	šž	œœœ1œ˜dšœœ
œ˜'Kš
œ$˜$Kšœ#œœ˜Ošœ˜Kšœœ˜"Kšœ
œ3˜AK˜—Kšœ
˜—K˜K˜—šžœœœœ˜Tšœ
œ
˜Kšœœœ˜3Kšœœœ"˜?Kšœ!˜(—K˜K™—šžœœDœœ˜€
šœ+œœ
˜?Kšœœ=˜GKšœ
˜—K˜K™—šžœœœ9˜mšœ+œœ
˜?Kš
œA˜AKšœ
˜—K˜K™—šžœœœœ˜ašœ+œœ
˜?Kšœ
œ8˜FKšœ
˜—K˜K™—šž
œ˜+Kšœœ
˜)Kš
œ˜K˜K™——™šžœ˜+Kšœœ
˜$Kšœœœ˜NKšœœœ˜QKš
œ8˜8Kš
œL˜LKš
œ˜Kš
œ0˜0K˜K˜—šžœ˜+Kšœœ
˜$Kšœœœ˜NKšœœœ˜QKš
œ8˜8Kš
œL˜LKš
œ˜Kš
œ%˜%K˜K˜—šžœ˜,Kšœœ
˜$Kšœœœ˜NKšœœœ˜QKš
œ4˜4Kš
œ˜Kš
œD˜DKš
œ˜K˜—šž
œ˜*Kšœœ
˜$Kšœœ
˜Kšœœ
˜K˜Kš
œ?™?šœ˜Jšœœ
˜Jšœœ
˜Jšœœ
˜—Jš
œ˜Kš
œ+™+šœ˜Jšœœ
˜Jšœœ
˜Jšœœ
˜—Jš
œ˜Kš
œ™šœ˜Jšœ)œ˜BJšœœ
˜—Jš
œ˜Kš
œ™Jšœœœ˜9Jš
œ˜Kš
œ™Jš
œœœ
œ
œœœ˜UKšœ
œœ˜1Kš
œ˜Kš
œA˜AK˜K˜—šžœ˜4Kšœœ
˜$Kšœœ
˜Kš
œ.˜.Kš
œ˜Kš
œ
˜
Kš
œ&˜&K˜K˜—šžœ˜0Kšœœ
˜$Kš
œ˜Kš
œ˜K˜K˜—šžœ˜/Kšœœ
˜$Kš
œ˜Kš
œ)˜)K˜K˜—šžœ˜3Kšœœ
˜$šœ*œ˜EKš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœœ
˜—Kš
œ˜Kš
œ1˜1K˜K˜—šžœ™+Kš
œ™Kš
œ(™(K™——™šž
œœ%œœ˜tKš
œ˜Kšœ
œ
˜Kš
œ˜Kš
œ0˜0Kšœœ˜šœœ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜—K˜K˜—šžœ˜)Kšœœ
˜$Kš
œ.˜.K˜K˜—šžœ˜(Kšœœ
˜$šœœ
˜Kšœ'œ ˜Q—Kš
œ,˜,K˜K˜—šžœ˜(Kšœœ
˜$šœœ
˜Kšœ'œ ˜Q—Kš
œ,˜,K˜K˜—šžœ˜)Kšœœ
˜$šœœ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜—Kšœ ˜&K˜——™Kšœ	œœ˜šœœœs˜Œ
K˜—šžœ˜)Kšœœ˜(Kšœœ˜(Kšœœ˜"Kš
œ/˜/Kšœœ
œŸ˜9šœ&˜(KšœO˜SKšœ˜Kš
œ˜Kš
œ˜Kš
œG˜GKš
œ3˜3Kš
œ˜Kš
œ3˜3Kš
œ.˜.Kš	ΟbΠbk %‘ 0‘ =œ
 ™Σ
K˜—K˜K˜—šžœœ˜/KšœDœ˜\K˜K˜—š
žœœ
œœœ˜dKšœœ˜šœ6œ
œ
˜Nšžœ˜0Jš
œ6˜6Kšœ
œ˜$Kš
œ˜Kš
œ8˜8K˜—Kš
œ$˜$Kš
œB˜BKšœ
˜—Kšœ
œ œ'˜XK˜——™Kš
œH˜HKš
œ\˜\K˜Kš
œJ˜JKš
œL˜LKš
œJ˜JKš
œT˜TKš
œR˜RKš
œZ˜ZKš
œJ™JK˜Kš
œF˜FKš
œD˜DKš
œD˜DKš
œF˜FK˜KšœAœ0˜tKšœCœ4˜zKšœ?œ+˜mKšœAœ.˜rK˜KšœEœ-˜uK˜—Kšœ
˜—…—H¬_Z