ViewerPaintImpl.mesa; written by S. McGregor
Edited by McGregor on August 8, 1983 4:00 pm
Edited by Maxwell, June 3, 1983 8:23 am
Last Edited by: Pausch, August 26, 1983 3:39 pm
DIRECTORY
Carets USING [ResumeCarets, SuspendCarets],
IconManager USING [selectedIcon],
Icons USING [DrawIcon],
Imager USING [black, ClipIntRectangle, ClipView, Context, DoSave, MaskIntRectangle, MaskCharacters, Create, IntScaleT, Reset, SetColor, SetIntCP, SetView, IntTranslateT, white],
MenusPrivate USING [DrawMenu, ViewerMenus],
Process USING [Detach, GetCurrent, MsecToTicks, Pause, Ticks],
Rope USING [ROPE],
VFonts USING [defaultFont, RopeWidth],
ViewerOps,
ViewerClasses,
ViewerLocks USING [CallUnderReadLock, CallUnderWriteLock, ColumnWedged, Wedged],
ViewerSpecs,
ViewersStallNotifier,
ViewerTools USING [GetSelectedViewer];
ViewerPaintImpl: CEDAR MONITOR
IMPORTS Carets, Imager, IconManager, Icons, MenusPrivate, Process, VFonts, ViewerLocks, ViewerTools, ViewerOps, ViewerSpecs
EXPORTS ViewerOps, ViewersStallNotifier
SHARES ViewerClasses, ViewerLocks =
BEGIN OPEN Imager, ViewerClasses, ViewerOps, ViewerSpecs;
InvisiblePaint: PUBLIC SIGNAL = CODE;
PaintDocumentHeader: PROC [viewer: Viewer, context: Context, clear: BOOL, hint: PaintHint, whatChanged: REF ANY] =
BEGIN OPEN viewer;
wbs: INTEGER = IF viewer.border THEN windowBorderSize ELSE 0;
ClipIntRectangle[context, [wx, wy, ww, wh]];
IF hint#menu THEN BEGIN
IF viewer.class.caption#NIL THEN BEGIN-- client-painted caption
CallClient: PROC = BEGIN
ClipIntRectangle[context, [wx+wbs, wy+wh-captionHeight-wbs, ww-(2*wbs),
wh-wbs]];
viewer.class.caption[viewer, context];
END;
DoSave[context, CallClient];
END
ELSE BEGIN
headerW: INTEGER ← VFonts.RopeWidth[name];
IF viewer.saveInProgress THEN headerW ← headerW + sipW
ELSE IF viewer.newFile THEN headerW ← headerW + newFW
ELSE IF viewer.newVersion THEN headerW ← headerW + newVW;
IF viewer.link#NIL THEN headerW ← headerW + linkW;
headerW ← MIN[headerW, ww];
MaskIntRectangle[context, [wx, wy+wh-captionHeight, ww, captionHeight]];
SetColor[context, white];
SetIntCP[context, [wx+((ww-headerW)/2), wy+wh-captionHeight+4]];
MaskCharacters[context, VFonts.defaultFont, name];
IF viewer.saveInProgress THEN MaskCharacters[context, VFonts.defaultFont, sipT]
ELSE IF viewer.newFile THEN MaskCharacters[context, VFonts.defaultFont, newFT]
ELSE IF viewer.newVersion THEN MaskCharacters[context, VFonts.defaultFont, newVT];
IF viewer.link#NIL THEN MaskCharacters[context, VFonts.defaultFont, linkT];
END;
END;
IF menus#NIL AND hint#caption THEN BEGIN
height: INTEGERNARROW[menus, MenusPrivate.ViewerMenus].h;
IF whatChanged=NIL THEN BEGIN
IF ~clear THEN BEGIN
SetColor[context, white];
MaskIntRectangle[context, [wx+wbs, wy+wh-captionHeight-height, ww-(2*wbs), height]];
END;
SetColor[context, black];
MaskIntRectangle[context, [wx, wy+wh-captionHeight-height-windowBorderSize,ww, menuBarHeight]];
END;
MenusPrivate.DrawMenu[viewer, NARROW[viewer.menus, MenusPrivate.ViewerMenus], context, whatChanged];
END;
END;
PaintIcon: PROC [viewer: Viewer, hint: PaintHint, whatChanged: REF ANYNIL] = BEGIN
context: Context;
label: Rope.ROPE;
IF viewer.parent#NIL THEN RETURN;
context ← AcquireContext[viewer, FALSE]; -- all icons on b&w display
IF flavor is private then client wants to draw the icon
IF viewer.icon=private THEN viewer.class.paint[viewer, context, whatChanged, hint=all]
ELSE IF hint=all OR hint=caption THEN BEGIN
DrawIcon: PROC = {Icons.DrawIcon[flavor: viewer.icon, context: context, label: label]};
IF viewer.icon=document AND (viewer.newVersion OR viewer.newFile) THEN
viewer.icon ← dirtyDocument
ELSE IF viewer.icon=dirtyDocument AND NOT (viewer.newVersion OR viewer.newFile) THEN
viewer.icon ← document;
label ← NARROW[ViewerOps.FetchProp[viewer, $IconLabel]];
IF label = NIL THEN label ← viewer.name;
DoSave[context, DrawIcon];
IF IconManager.selectedIcon=viewer THEN BEGIN
SetColor[context, $XOR];
MaskIntRectangle[context, [0, 0, iconWidth, iconHeight]];
END;
END;
ReleaseContext[context];
END;
SetIconLabel: PUBLIC PROC [viewer: Viewer, label: Rope.ROPE] = BEGIN
ViewerOps.AddProp[viewer, $IconLabel, label];
END;
RecursivelyPaintViewers: PROC [viewer: Viewer, hint: PaintHint, clearClient: BOOL,
clear: BOOL, rect: PaintRectangle, whatChanged: REF ANY] = BEGIN OPEN viewer;
vx, vy: INTEGER;
context: Context ← NIL;
bitmapY: INTEGER ← 0;
FOR v: Viewer ← viewer, v.parent UNTIL v=NIL DO-- visibility test
IF v.parent#NIL THEN BEGIN
IF (v.wy+v.wh < 0) OR (v.wy > v.parent.ch) THEN RETURN;
IF (v.ww+v.ww < 0) OR (v.wx > v.parent.cw) THEN RETURN;
END
ENDLOOP;
IF hint#client THEN BEGIN
ENABLE UNWIND => IF context#NIL THEN ReleaseContext[context];
PaintHeader: PROC = {PaintDocumentHeader[viewer, context, clear, hint, whatChanged]};
context ← AcquireContext[parent, viewer.column=color];
IF ~viewer.visible OR viewer.destroyed THEN SIGNAL InvisiblePaint;
IF clearClient AND ~clear AND hint=all THEN BEGIN
SetColor[context, white];
MaskIntRectangle[context, [wx, wy, ww, wh]];
SetColor[context, black];
clear ← TRUE;
END;
IF border AND hint=all THEN BEGIN
wbs: INTEGER ~ windowBorderSize;
MaskIntRectangle[context, [wx, wy, ww, wbs]];
MaskIntRectangle[context, [wx, wy, wbs, wh]];
MaskIntRectangle[context, [wx+ww-wbs, wy, wbs, wh]];
MaskIntRectangle[context, [wx, wy+wh-wbs, ww, wbs]];
END;
IF parent=NIL AND viewer.column#static THEN DoSave[context, PaintHeader];
ReleaseContext[context];
END;
IF hint=all OR hint=client THEN BEGIN
ENABLE UNWIND => IF context#NIL THEN ReleaseContext[context];
PaintClient: PROC = {class.paint[viewer, context, whatChanged, clear]};
context ← NIL; context ← AcquireContext[viewer, viewer.column=color];
IF ~viewer.visible OR viewer.destroyed THEN SIGNAL InvisiblePaint;
IF rect#NIL AND class.bltContents = none THEN clearClient ← TRUE;
IF clearClient AND ~clear THEN BEGIN
SetColor[context, white];
MaskIntRectangle[context, [0, 0, cw, ch]];
SetColor[context, black];
IF rect # NIL THEN whatChanged ← NIL;
rect ← NIL;
clear ← TRUE;
END;
IF class.paint#NIL THEN BEGIN
IF clientContext THEN PaintClient[] ELSE DoSave[context, PaintClient];
END;
ReleaseContext[context];
END;
do we need to paint any of the children?
IF rect # NIL AND viewer.parent = NIL THEN {
IF viewer.cx >= rect.x AND (viewer.cx + viewer.cw <= rect.x + rect.w) AND
viewer.cy >= rect.y AND (viewer.cy + viewer.ch <= rect.y + rect.h) THEN RETURN};
recursively paint children
IF hint=all OR clear THEN
these guys should be painted in reverse order for correct overlaps
FOR v: Viewer ← viewer.child, v.sibling UNTIL v=NIL DO
IF rect # NIL THEN { -- don't paint if it is completely within the blt
map to the coodinate system that rect uses
IF viewer.class.coordSys = top
THEN [vx, vy] ← ViewerOps.UserToScreenCoords[viewer, v.wx, v.wy+v.wh]
ELSE [vx, vy] ← ViewerOps.UserToScreenCoords[viewer, v.wx, v.wy];
IF vx >= rect.x AND (vx + v.ww <= rect.x + rect.w) AND
vy >= rect.y AND (vy + v.wh <= rect.y + rect.h) THEN LOOP};
RecursivelyPaintViewers[v, all, FALSE, clear, rect, whatChanged];
ENDLOOP;
END;
PaintViewer: PUBLIC PROC [viewer: Viewer, hint: PaintHint ← client, clearClient: BOOLTRUE,
whatChanged: REF ANYNIL] = BEGIN
LocalPaintViewer: PROC = {
ENABLE ABORTED => {Carets.ResumeCarets[]; CONTINUE};
rect: PaintRectangle;
IF ~viewer.visible OR viewer.destroyed THEN RETURN;
IF viewer.iconic THEN {PaintIcon[viewer, hint, whatChanged]; RETURN};
Carets.SuspendCarets[];
IF ISTYPE[whatChanged, PaintRectangle] THEN rect ← NARROW[whatChanged];
RecursivelyPaintViewers[viewer, hint, clearClient AND ~(hint=menu OR hint=caption),
FALSE, rect, whatChanged ! InvisiblePaint => CONTINUE];
Carets.ResumeCarets[]};
ViewerLocks.CallUnderReadLock[LocalPaintViewer, viewer ! ViewerLocks.Wedged => CONTINUE];
END;
PaintVector: TYPE = REF PaintVectorRec;
PaintVectorRec: TYPE = RECORD [
next: PaintVector ← NIL,
viewer: Viewer ← NIL,
inUse: BOOLFALSE,
resetOnRelease: BOOLFALSE,
color: BOOLFALSE,
process: UNSAFE PROCESSNIL,
context: Context ← NIL,
previous: PaintVector ← NIL];
nVectors: CARDINAL = 5;
usedVectors: CARDINAL ← 0;
PaintVectorAvailable: CONDITION;
paintingLock: CARDINAL ← 0;
vectorRoot: PaintVector ← NIL;
Init: ENTRY PROC = BEGIN
new: PaintVector;
FOR n: CARDINAL IN [0..nVectors) DO
new ← NEW[PaintVectorRec];
new.context ← Create[$LFDisplay];
new.next ← vectorRoot;
IF vectorRoot#NIL THEN vectorRoot.previous ← new;
vectorRoot ← new;
ENDLOOP;
newFW ← VFonts.RopeWidth[newFT];
newVW ← VFonts.RopeWidth[newVT];
linkW ← VFonts.RopeWidth[linkT];
sipW ← VFonts.RopeWidth[sipT];
END;
colorInit: BOOLFALSE;
InitialiseColorPainting: PUBLIC PROC = BEGIN
colorInit ← TRUE;
ViewerOps.GreyScreen[0, 0, 9999, 9999, TRUE, FALSE];
END;
ZapVector: INTERNAL PROC [p: PaintVector] = BEGIN
oldContext: Context ← p.context;
p.context ← Create[$LFDisplay];
p.viewer ← NIL;
p.inUse ← FALSE;
p.process ← NIL;
IF ~p.color THEN usedVectors ← usedVectors - 1;
SetView[oldContext, [0,0,0,0]]; -- smash old
BROADCAST PaintVectorAvailable;
END;
UnWedgePainter: PUBLIC ENTRY PROC [process: PROCESS, kind: ATOM] = BEGIN
ENABLE UNWIND => NULL;
FOR p: PaintVector ← vectorRoot, p.next UNTIL p=NIL DO
IF p.inUse AND p.process=process THEN ZapVector[p];
ENDLOOP;
END;
UnWedge: ENTRY PROC [process: PROCESS, kind: ATOM] = BEGIN
call from debugger
FOR p: PaintVector ← vectorRoot, p.next UNTIL p=NIL DO
IF p.inUse THEN ZapVector[p];
ENDLOOP;
usedVectors ← 0; -- make sure
paintingLock ← 0; -- make sure
BROADCAST PaintVectorAvailable;
END;
DisablePainting: PUBLIC ENTRY PROC [wait: BOOLTRUE] = BEGIN
ENABLE UNWIND => NULL;
InternalDisablePainting[wait];
END;
InternalDisablePainting: INTERNAL PROC [wait: BOOLTRUE] = INLINE BEGIN
IF wait THEN
WHILE usedVectors#0 DO WAIT PaintVectorAvailable;
ENDLOOP;
paintingLock ← paintingLock+1;
END;
EnablePainting: PUBLIC ENTRY PROC = BEGIN
ENABLE UNWIND => NULL;
InternalEnablePainting[];
END;
InternalEnablePainting: INTERNAL PROC = INLINE BEGIN
IF paintingLock#0 THEN paintingLock ← paintingLock-1;
broadcast since all are likely to be free
IF paintingLock=0 THEN BROADCAST PaintVectorAvailable;
END;
DisablePaintingUnWedged: INTERNAL PROC [wait: BOOLTRUE] = INLINE BEGIN
AllWedged: INTERNAL PROC RETURNS[BOOL] = INLINE BEGIN
FOR p: PaintVector ← vectorRoot, p.next UNTIL p=NIL DO
IF ~p.inUse THEN LOOP;
IF p.viewer = NIL THEN RETURN[FALSE]; -- context = screen
IF ~ViewerLocks.ColumnWedged[ViewerColumn[p.viewer]].wedged THEN RETURN[FALSE];
ENDLOOP;
RETURN[TRUE];
END;
IF wait THEN
WHILE usedVectors#0 DO
IF AllWedged[] THEN EXIT ELSE WAIT PaintVectorAvailable;
ENDLOOP;
paintingLock ← paintingLock+1;
END;
WaitForPaintingToFinish: PUBLIC ENTRY PROC = BEGIN
assumes interesting paints already in progress
WHILE usedVectors#0 DO WAIT PaintVectorAvailable ENDLOOP;
END;
ResetPaintCache: PUBLIC ENTRY PROC [viewer: Viewer ← NIL, wait: BOOLTRUE] = BEGIN
ENABLE UNWIND => NULL;
DisablePaintingUnWedged[wait];
FOR p: PaintVector ← vectorRoot, p.next UNTIL p=NIL DO
IF p.inUse THEN BEGIN
IF p.viewer = NIL OR ~ViewerLocks.ColumnWedged[ViewerColumn[p.viewer]].wedged
THEN IF wait THEN RETURN WITH ERROR fatalViewersError;
p.resetOnRelease ← TRUE;
END
ELSE IF p.viewer#NIL THEN BEGIN
Reset[p.context];
p.viewer ← NIL;
END;
ENDLOOP;
InternalEnablePainting[];
END;
fatalViewersError: ERROR = CODE;
ReleaseContext: PUBLIC ENTRY PROC [free: Context] = BEGIN
ENABLE UNWIND => NULL;
CleanUp: INTERNAL PROC [p: PaintVector] = BEGIN
p.inUse ← FALSE;
IF usedVectors=0 THEN RETURN WITH ERROR fatalViewersError
ELSE usedVectors ← usedVectors-1;
IF p.resetOnRelease THEN BEGIN
Reset[p.context];
p.viewer ← NIL;
p.resetOnRelease ← FALSE;
END;
p.process ← NIL;
BROADCAST PaintVectorAvailable;
END;
IF free=NIL THEN RETURN WITH ERROR fatalViewersError;
FOR p: PaintVector ← vectorRoot, p.next UNTIL p=NIL DO
IF free=p.context THEN {CleanUp[p]; EXIT};
ENDLOOP;
END;
AcquireContext: PUBLIC ENTRY PROC [viewer: Viewer, color: BOOLFALSE]
RETURNS [allocated: Context] = BEGIN
ENABLE UNWIND => NULL;
bestFit: PaintVector;
nil: BOOLFALSE;
MakeFirst: INTERNAL PROC [pv: PaintVector] = INLINE BEGIN-- LRU caching scheme
IF pv=vectorRoot THEN RETURN;
pv.previous.next ← pv.next;
IF pv.next#NIL THEN pv.next.previous ← pv.previous;
pv.next ← vectorRoot;
vectorRoot.previous ← pv;
vectorRoot ← pv;
END;
IF color THEN BEGIN
IF ~colorInit THEN ERROR fatalViewersError;
END;
UNTIL usedVectors<nVectors AND paintingLock=0 DO WAIT PaintVectorAvailable; ENDLOOP;
IF viewer#NIL AND (~viewer.visible OR viewer.destroyed) THEN
SIGNAL InvisiblePaint; -- someone got changed while waiting in the loop above
IF viewer#NIL AND viewer.clientContext THEN BEGIN-- private client context
allocated ← NARROW[ViewerOps.FetchProp[viewer, $ViewerClientContext]];
SetContext[viewer, allocated];
RETURN;
END;
FOR p: PaintVector ← vectorRoot, p.next UNTIL p=NIL DO
IF p.inUse THEN LOOP;
IF viewer=p.viewer THEN {bestFit ← p; EXIT}
ELSE IF p.viewer=NIL THEN {bestFit ← p; nil ← TRUE}
ELSE IF ~nil THEN bestFit ← p;
ENDLOOP;
usedVectors ← usedVectors+1;
MakeFirst[bestFit];
bestFit.inUse ← TRUE;
TRUSTED {bestFit.process ← Process.GetCurrent[]};
IF viewer#bestFit.viewer THEN SetContext[viewer, bestFit.context];
bestFit.viewer ← viewer;
SetColor[bestFit.context, black]; -- since we don't save the color
RETURN[bestFit.context];
END;
SetContext: INTERNAL PROC [viewer: Viewer, context: Context] = BEGIN
x, y: INTEGER ← 0;
invert: BOOLFALSE;
RecursivelyPushParent: INTERNAL PROC [v: Viewer] = BEGIN
IF v.parent#NIL THEN RecursivelyPushParent[v.parent];
PushContext[v]
END;
PushContext: INTERNAL PROC [v: Viewer] = BEGIN OPEN v;
invertCoords: BOOL = IF v.parent=NIL THEN v.class.coordSys=top
ELSE v.class.coordSys#v.parent.class.coordSys;
x ← x + cx;
IF invert THEN y ← y + parent.ch - cy - ch
ELSE y ← y + cy;
ClipView[context, [x, y, cw, ch], FALSE];
IF invertCoords THEN invert ← ~invert;
END;
Reset[context];
IF viewer=NIL THEN RETURN
ELSE IF viewer.iconic THEN BEGIN OPEN viewer;
IF wy+wh > openBottomY THEN BEGIN
ClipIcon[context];
ClipView[context, [wx, wy, ww, wh], FALSE];
IntTranslateT[context, wx, wy]; --xlate since ClipView does no x,y translation
END
ELSE SetView[context, [wx, wy, ww, wh]];
END
ELSE IF viewer.parent=NIL THEN BEGIN OPEN viewer;
SetView[context, [cx, cy, cw, ch]];
IF class.coordSys=top THEN BEGIN
IntTranslateT[context, 0, ch];
IntScaleT[context, 1, -1];
END;
END
ELSE BEGIN
RecursivelyPushParent[viewer];
IF invert THEN BEGIN
IntTranslateT[context, x, y+viewer.ch];
IntScaleT[context, 1, -1];
END
ELSE IntTranslateT[context, x, y];
END;
END;
InvertForMenus: PUBLIC PROC [viewer: Viewer, x: INTEGER, y: INTEGER, w: INTEGER, h: INTEGER] = BEGIN
context: Context ← AcquireContext[viewer.parent, viewer.column=color];
ActuallyDoDrawing: PROC = {
ClipIntRectangle[context, [viewer.wx, viewer.wy, viewer.ww, viewer.wh] ];
SetColor[context, $XOR];
MaskIntRectangle[context, [x, y, w, h]];
};
DoSave[context, ActuallyDoDrawing];
ReleaseContext[context];
END;
ClipIcon: PROC [context: Context] = BEGIN
clips for overlapping top level windows given valid Context and Viewer
ClipOpenViewer: ViewerOps.EnumProc = BEGIN
IF ~v.iconic AND (v.column=right OR v.column=left) THEN
ClipView[context, [v.wx, v.wy, v.ww, v.wh], TRUE];
END;
ViewerOps.EnumerateViewers[ClipOpenViewer];
END;
BlinkIcon: PUBLIC PROC [viewer: Viewer, count, interval: NAT] = BEGIN
IF interval >= 1000 THEN interval ← interval/1000;
IF viewer.offDeskTop THEN ViewerOps.ChangeColumn[viewer, left];
IF count = 1 THEN BlinkProcess[viewer, count, interval]
ELSE TRUSTED {Process.Detach[FORK BlinkProcess[viewer, count, interval]]};
END;
BlinkProcess: PROC [viewer: Viewer, count, n: NAT] = BEGIN
howOften: Process.Ticks = Process.MsecToTicks[500];
Blink: PROC = BEGIN OPEN viewer;
context: Context;
IF NOT visible OR destroyed THEN RETURN;
context ← AcquireContext[viewer, IF iconic THEN FALSE ELSE column=color];
SetColor[context, $XOR];
MaskIntRectangle[context, [0, 0, viewer.ww, viewer.wh]];
Process.Pause[Process.MsecToTicks[400]];
MaskIntRectangle[context, [0, 0, viewer.ww, viewer.wh]];
ReleaseContext[context];
Process.Pause[Process.MsecToTicks[350]]; -- so can be called back-to-back
END;
DO
ViewerLocks.CallUnderWriteLock[Blink, viewer];
IF count = 1 THEN RETURN;
IF count > 0 THEN count ← count - 1;
FOR i: NAT IN [0..2*n) DO -- blink every n seconds, but wake up every half second.
Process.Pause[howOften];
IF viewer.destroyed OR ~viewer.iconic
OR viewer = ViewerTools.GetSelectedViewer[] THEN RETURN;
ENDLOOP;
ENDLOOP;
END;
newVT: Rope.ROPE = " [New Version]";
newVW: INTEGER;
newFT: Rope.ROPE = " [New File]";
newFW: INTEGER;
linkT: Rope.ROPE = " [Split]";
linkW: INTEGER;
sipT: Rope.ROPE = " [Saving...]";
sipW: INTEGER;
Init[];
ViewerOps.GreyScreen[0, 0, 9999, 9999, FALSE, FALSE];
END.