-- a queue of pending painting requests, consisting of boxes whose interior has to be repainted by the server process.

-- a queue of pending click actions to be performed by the server process as soon as the scene becomes available.

DoRemoveObject: TreeAction =
BEGIN
[oldParent, oldNext] ← RemoveAndRepaintObject[obj];
END;

DoInsertObject: TreeAction =
BEGIN
InsertAndRepaintObject[obj, newParent, newNext]
END;

DoMoveObject: DoubleTreeAction =
BEGIN
-- remove object from current tree
[oldParent, oldNext] ← RemoveAndRepaintObject[obj];
-- insert it in new place
InsertAndRepaintObject[obj, newParent, newNext]
END;

BEGIN
-- apply action to obj.
changed: BOOL ← Action[obj, context];
IF changed AND sc # NIL THEN
BEGIN
UnS.ScheduleRepaint[sc, obj.box]; -- repaint old box
boxChanged ← UnS.RecomputeLineWidthsAndBoxes[obj];
IF boxChanged THEN
{UnS.ScheduleRepaint[sc, box]} -- repaint new box too
END
END;

BEGIN
-- apply action to obj. Assumes its lineWidth is OK.
objChanged: BOOL;
someChildBoxChanged: BOOL ← FALSE;
IF someAncestorChanged AND sc # NIL THEN
{UnS.RecomputeLineWidth[obj]}; -- propagate ancestor's changes
objChanged ← Action[obj, context];
IF objChanged AND sc # NIL THEN
BEGIN
UnS.RecomputeLineWidth[obj]; -- Action may have changed $LineWidth
END;
IF ISTYPE [obj, Group] THEN
BEGIN
group: Group ← NARROW[obj];
child: object ← group.child;
IF child # NIL THEN
BEGIN
DO
child ← child.next;
someChildBoxChanged ←
someChildBoxChanged OR ModifyAllObjects
[child, someAncestorChanged OR objChanged];
IF child = group.last THEN EXIT
ENDLOOP
END
END;
IF (someAncestorChanged OR objChanged OR someChildBoxChanged)
AND sc # NIL THEN
BEGIN
IF repaint AND objChanged THEN
{UnS.ScheduleRepaint[sc, obj.box]}; -- repaint old box
boxChanged ← UnS.RecomputeBox[group]
IF repaint AND objChanged AND NOT someAncestorChanged
AND boxChanged THEN
{UnS.ScheduleRepaint[sc, obj.box]} -- repaint new box
END
END;

BEGIN
objChanged: BOOL;
WITH obj SELECT FROM
group: Group =>
BEGIN
child: object ← group.child;
someChildBoxChanged: BOOL ← FALSE;
IF child # NIL THEN
BEGIN
DO
child ← child.next;
someChildBoxChanged ←
someChildBoxChanged OR ModifyAllThings [child];
IF child = group.last THEN EXIT
ENDLOOP
END;
IF someChildBoxChanged AND sc # NIL THEN
{boxChanged ← UnS.RecomputeBox[group]};
END;
thing: THING =>
BEGIN
objChanged: BOOL ← Action[thing, context];
IF objChanged AND sc # NIL THEN
BEGIN
UnS.RecomputeLineWidth[thing]; -- Action may change $LineWidth
IF repaint THEN
UnS.ScheduleRepaint [sc, thing.box];
boxChanged ← UnS.RecomputeBox[thing];
IF repaint AND boxChanged THEN
UnS.ScheduleRepaint [sc, thing.box]
END
END;
nil: NIL => {};
ENDCASE => ERROR SceneError["Invalid object"]
END;

DoModifyObjects: TreeAction =
BEGIN
ModifyAndRepaintObjects [node: node, Action: Action, option: option,
context: context, repaint: repaint];
END;

DoModifyThing: TreeAction =
BEGIN
sc: Scene = UnS.GetScene[node];
rootBoxChanged: BOOL;
rootObj: Object = -- root of subtree to modify
IF node IS Scene THEN
NARROW[NARROW[node, Scene].data], SceneData].tree
ELSE IF node IS Object THEN NARROW[node, Object]
ELSE NIL;

RecursiveModifyAllThings: PROC [obj: Object]
RETURNS [boxChanged: BOOL ← FALSE] =

rootBoxChanged ← RecursiveModifyAllThings[rootObj];
IF rootBoxChanged AND sc # NIL AND rootObj.parent IS Group THEN
UnS.RecomputeAncestorBoxes[NARROW[rootObj.parent]]
END;

DoEnumerateAllThing: TreeAction =
BEGIN
rootObj: Object = -- root of subtree to enumerate
IF node IS Scene THEN
NARROW[NARROW[node, Scene].data], SceneData].tree
ELSE IF node IS Object THEN NARROW[node, Object]
ELSE NIL;

RecursiveEnumerateAllThings: PROC [obj: Object] =

RecursiveEnumerateAll[rootObj]
END;

-- This procedure is called with the viewer locked for read (I hope). Any process that modifies an attached object tree must first lock its viewer for write, and must update its bounding boxes before releasing the lock. Therefore, inside this procedure the bounding box of the object tree and the viewer's context are stable. We can search the mouse action table and convert the mouse coordinates from the the viewer's to the client's coordinate system.

-- However, we cannot call the mouse action; to do so properly we should acquire access to it, and this may get us into a deadlock. All we can do is to enqueue the action and the transformed coordinates for the server process to call later on.

BEGIN
me: REF MouseActionEntry ← NIL;
event: MouseEvent ← [button: , shift: FALSE, ctrl: FALSE, kind: down];
sData: SceneData = NARROW[self.data];
coords: TIPTables.TIPScreenCoords ←
NARROW[input.rest.first, TIPTables.TIPScreenCoords];
clientContext: Gr.context ← UnS.ComputeClientContext[sc, self.context];
xc, yc: REAL; -- mouse coordinates in client's coordinate system
IF NOT sData.alive THEN RETURN;
SELECT input.first FROM
$LeftDown => {event.button ← red};
$CenterDown => {event.button ← yellow};
$RightDown => {event.button ← blue};
$LeftMove => {event.button ← red; event.kind ← move};
$CenterMove => {event.button ← yellow; event.kind ← move};
$RightMove => {event.button ← blue; event.kind ← move};
ENDCASE => RETURN;
input ← input.rest.rest;
IF input # NIL AND input.first = $Shift THEN
{event.shift ← TRUE; input ← input.rest};
IF input # NIL AND input.first = $Ctrl THEN
{event.ctrl ← TRUE; input ← input.rest};

-- map x, y to client coordinates and locate MouseActionEntry for this event
-- since we have the viewer's lock for read, we know no one is
-- changing the object tree of the scene.
BEGIN
maList: LIST OF REF MouseActionEntry ← sData.mouseActions;
UNTIL maList = NIL OR maList.first.event = event DO
maList ← maList.rest
ENDLOOP;
IF maList # NIL THEN
me ← maList.first
END;
clientContext ← Grgr: NAT = vData.grid;
IF gr # 0 THEN
{coords.mouseX ← (coords.mouseX + gr/2)/gr*gr;
coords.mouseY ← (coords.mouseY + gr/2)/gr*gr};
pt ← Cart.UnScalePoint [[x: coords.mouseX, y: coords.mouseY], vData.scale];
Release [self, c]
END;
-- CAUTION - there is a chance that some other process will sneak in here, perhaps
-- removing this mouse action from the list. It is possible to check for that case, but let's
-- think about that if and when the problem occurs...
IF me # NIL THEN
{c ← GetRights[self, me.needs];
me.Proc [self, me.eventData, pt.x, pt.y, event ! UNWIND => {Release [self, c]} ];
Release [self, c]}
END

-- Locates the scene sc to which the object belongs. If the scene is not being written, acquires read access to it, and returns success=TRUE. If the scene is in use, returns success=FALSE and sets sc to NIL.

If the object is in a detached tree, returns success=TRUE with sc = NIL.

BEGIN
p: Object ← obj;
WHILE p.parent IS Object DO p ← p.parent ENDLOOP;
IF p.parent = NIL THEN RETURN[TRUE]
ELSE IF p.parent IS Scene THEN
BEGIN
IF p.next NEQ NIL THEN ERROR InvalidTreeStructure
sc ← NARROW [p.parent];
IF p
IF sc.writer = NIL OR sc.writer=myself THEN
{-- wops! no writers; grab it!
sc.readers ← sc.readers+1; RETURN [TRUE]}
ELSE
{-- sorry, scene is in use...
sc ← NIL; RETURN [FALSE]}
END
ELSE ERROR InvalidTreeStructure
END;

-- sc must be non-NIL

BEGIN
sc.readers ← sc.readers - 1;
IF sc.readers = 0 THEN BROADCAST TreesAvailable
END;

-- Locates the scene sc to which the object belongs. If the scene is not being read or written, acquires write access to it, and returns success=TRUE. If the scene is in use, returns success=FALSE and sets sc to NIL.

-- If the object is in a detached tree, returns success=TRUE with sc = NIL.

-- NOTE: deadlocks if a process with read access tries to get write access too. Could prevent the deadlock by attaching to the current process a stack of scenes to which it holds access.

BEGIN
p: Object ← obj;
WHILE p.parent IS Object DO p ← p.parent ENDLOOP;
IF p.parent = NIL THEN RETURN[TRUE]
ELSE IF p.parent IS Scene THEN
BEGIN
IF p.next NEQ NIL THEN ERROR InvalidTreeStructure
sc ← NARROW [p.parent];
IF (sc.writer = NIL OR (wasHolding ← sc.writer=myself))
AND sc.readers=0 THEN
{-- wops! no readers or writers; grab it!
sc.writer ← myself; RETURN [TRUE]}
ELSE
{-- sorry, scene is in use...
sc ← NIL; RETURN [FALSE]}
END
ELSE ERROR InvalidTreeStructure
END;

-- sc must be non-NIL

BEGIN
sc.writer ← NIL;
BROADCAST TreesAvailable
END;

vData: ViewerData ← NARROW[self.data];

c: Change;

PaintSingleObject: PROC [obj: Object] = TRUSTED INLINE

RePaintEverything: PROC = TRUSTED

IF NOT vData.alive THEN RETURN;

c ← GetReadRights [self];

BEGIN OPEN vData;
ENABLE UNWIND => {Release[self, c]};
cBox: Graphics.Box = Graphics.GetBounds[context];
vData.scale ← Cart.BoxToBoxScale
[vData.box, [[cBox.xmin, cBox.ymin], [cBox.xmax, cBox.ymax]]];
IF whatChanged = NIL OR whatChanged = $All THEN
{-- repaint everything - assume the background is clear
RePaintEverything []}
ELSE
{-- repaint the given thing
obj: Object = NARROW [whatChanged];
PaintSingleObject[obj]};
-- relinquish acquired access rights
Release[self, c]
END;