-- TJaMGraphicsViewer.mesa
-- Last change by Bill Paxton,  October 5, 1982 3:19 pm
-- Last change by McGregor,  June 15, 1982 10:05 am
-- Last Edited by: Stone, January 31, 1984 3:45:22 pm PST

DIRECTORY
  Graphics,
  GraphicsOps, 
  CGVector, 
  GL USING [ Start],
  Rope USING [Concat],
  InputFocus USING [CaptureButtons, ReleaseButtons],
  Real USING [RoundI],
  Spline USING [New],
  TIPUser USING [InstantiateNewTIPTable, TIPScreenCoords],
  Cursors USING [SetCursor],
  WindowManager USING [RestoreCursor],
  Menus USING [Menu, MenuProc, CreateEntry, CreateMenu, InsertMenuEntry],
  ViewerClasses USING [Viewer, ViewerClass, ViewerClassRec, NotifyProc],
  ViewerOps USING [DestroyViewer, RegisterViewerClass, CreateViewer],
  JaM USING [SetAbort, Register, PushReal, PopBool, Execute, ExecuteRope],
  TJaMGraphics,
  TJaMGraphicsInfo,
  TJaMGraphicsContexts,
  MessageWindow USING [Blink, Append];
  
TJaMGraphicsViewer: CEDAR MONITOR
  LOCKS info USING info:TJaMGraphicsInfo.Info
  IMPORTS Graphics, Real, TJaMGraphicsInfo, Rope,
	MessageWindow, InputFocus, TIPUser, Cursors, Menus, ViewerOps, WindowManager,
	Spline, JaM, GraphicsOps, TJaMGraphics, GL, TJaMGraphicsContexts
  EXPORTS TJaMGraphics, TJaMGraphicsInfo, TJaMGraphicsContexts =
  BEGIN OPEN TJaMGraphicsInfo, J: JaM, G: Graphics, E: GraphicsOps,
  Vector: CGVector, TJaMGraphics, TDC: TJaMGraphicsContexts;
  
jamGraphicsClass: ViewerClasses.ViewerClass _ NEW[ViewerClasses.ViewerClassRec _ [
	paint: TJaMGraphicsInfo.Paint,
	notify: InputNotify,
	destroy: AboutToDestroy,
	tipTable: TIPUser.InstantiateNewTIPTable["JaMGraphics.TIP"]
	]];

JReloadTIP: PROC [frame: State] = { ReloadTIP[] };

ReloadTIP: PUBLIC PROC = {
	jamGraphicsClass.tipTable _ TIPUser.InstantiateNewTIPTable["JaMGraphics.TIP"] };

InitGL: PROC RETURNS[Graphics.Context] = {RETURN[GL.Start[NIL]]};  
Create: PUBLIC PROC [
  frame: State, typescript: ViewerClasses.Viewer, iconic: BOOLEAN _ FALSE]
  RETURNS [viewer: ViewerClasses.Viewer] = {
  info: Info;
  menu: Menus.Menu;
  bmw,bmh: CARDINAL;
  { -- extra block to make info defined in scope of UNWIND
  ENABLE UNWIND => -- something went wrong while creating the viewer
  	IF viewer#NIL THEN DestroyViewer[viewer] ELSE IF info#NIL THEN ForgetInfo[frame];
  IF (info _ GetInfo[frame]) # NIL THEN RETURN;
  info _ CreateInfo[frame];
  info.path _ G.NewPath[];
  [bmw,bmh] _ GetBitmapSize[];
  info.bitmap _ E.NewBitmap[bmw,bmh];
  info.spline _ Spline.New[];
  info.font _ E.DefaultFont[];
  info.text _ NIL;
  menu _ Menus.CreateMenu[];
  Menus.InsertMenuEntry[menu, Menus.CreateEntry["Reset", Reset]];
  Menus.InsertMenuEntry[menu, Menus.CreateEntry["Mouse", CaptureFocusButton]];
  Menus.InsertMenuEntry[menu, Menus.CreateEntry["Interrupt", InterruptButton]];
  viewer _ ViewerOps.CreateViewer[flavor: $JaMGraphics, info: [data: info,
  	name: Rope.Concat[typescript.name,"Graphics "], menu: menu, iconic: iconic, scrollable: FALSE]];
  info.viewer _ viewer;
  info.typescript _ typescript;
  info.vdc _ NIL; info.vinitdc _ NIL; info.venabled _ TRUE;
  TDC.AddContext[frame: frame, init: InitGL,name: $GList, enabled: FALSE, initOnErase: TRUE];
  info.gl _ NIL; info.drawGL _ FALSE;
  Init[frame];
  TJaMGraphicsInfo.RegisterGraphics[frame];
  TJaMGraphicsInfo.RegisterColor[frame];
  TJaMGraphicsInfo.RegisterImage[frame];
  }};

Reset: Menus.MenuProc = TRUSTED {
  viewer: ViewerClasses.Viewer _ NARROW[parent];
  frame: State _ NARROW[viewer.data,Info].frame;
  InitDC[frame]; JErase[frame] };

CaptureFocusButton: Menus.MenuProc = TRUSTED {
  viewer: ViewerClasses.Viewer _ NARROW[parent];
  info: Info _ NARROW[viewer.data];
  frame: State _ info.frame;
  JCaptureButtons[frame] };

InterruptButton: Menus.MenuProc = TRUSTED {
  viewer: ViewerClasses.Viewer _ NARROW[parent];
  info: Info _ NARROW[viewer.data];
  frame: State _ info.frame;
  J.SetAbort[frame,TRUE];
  SetPlace[info,0,0];
  SetBug[info,0,0] };

JDestroyViewer: PROCEDURE [frame: State] = { -- returns true if already have a viewer for this frame
  info: Info _ GetInfo[frame];
  IF info = NIL THEN RETURN;
  DestroyViewer[info.viewer];
  };

DestroyViewer: PROC [viewer: ViewerClasses.Viewer] = {
  AboutToDestroy[viewer];
  ViewerOps.DestroyViewer[viewer];
  };

AboutToDestroy: SAFE PROC [self: ViewerClasses.Viewer] = TRUSTED {
  info: Info _ NARROW[self.data];
  ForgetInfo[info.frame];
  };

JCaptureButtons: PROCEDURE [frame: State] = {
  info: Info _ GetInfo[frame];
  InputFocus.CaptureButtons[info.viewer.class.notify, info.viewer.tipTable, info.viewer];
  info.capturedButtons _ TRUE;
  Cursors.SetCursor[textPointer] };

JReleaseButtons: PROCEDURE [frame: State] = {
  info: Info _ GetInfo[frame];
  InputFocus.ReleaseButtons[];
  WindowManager.RestoreCursor;
  info.capturedButtons _ FALSE };

InitDC: PROCEDURE [frame: State] = {
  info: Info _ GetInfo[frame];
  IF info.venabled THEN info.vdc _ G.CopyContext[info.vinitdc];
  FOR l: TDC.DCList _ info.dcList, l.next UNTIL l=NIL DO
		IF l.enabled THEN l.dc _ l.init[]; 
		ENDLOOP;
  info.gl _ NIL;
  };

JErase: PROCEDURE [frame: State] = {
	info: Info _ GetInfo[frame];
	paint: TDC.GProc ={
		mark: G.Mark _ G.Save[dc];
		G.SetColor[dc, G.white];
		G.DrawBox[dc,G.GetBounds[dc]];
		G.Restore[dc,mark];
		};
	Painter[paint,frame];
	FOR l: TDC.DCList _ info.dcList, l.next UNTIL l=NIL DO
	  	IF l.initOnErase AND l.enabled THEN l.dc _ l.init[]; 
	  	ENDLOOP;
	info.gl _ NIL;
	};

EnableViewer: PUBLIC PROC [frame: State] = {
	info: Info _ GetInfo[frame];
	info.venabled _ TRUE;
	};
	
DisableViewer: PUBLIC PROC [frame: State] = {
	info: Info _ GetInfo[frame];
	info.venabled _ FALSE;
	};
	
KeepGL: PUBLIC PROC [frame: State] = {
	info: Info _ GetInfo[frame];
	b: BOOLEAN _ J.PopBool[frame];
	FOR l: TDC.DCList _ info.dcList, l.next UNTIL l=NIL DO
		IF l.name=$GList THEN l.enabled _ b; 
		ENDLOOP;
	IF b=FALSE THEN {info.drawGL _ FALSE; info.gl _ NIL};
	};
	
DoRefresh: PUBLIC PROC [frame: State] = {
	info: Info _ GetInfo[frame];
	b: BOOLEAN _ J.PopBool[frame];
	IF b=TRUE THEN {FOR l: TDC.DCList _ info.dcList, l.next UNTIL l=NIL DO
		IF l.name=$GList THEN l.enabled _ b; 	--must have an active GList to use it for refresh
		ENDLOOP;
		}
	ELSE info.gl _ NIL;	--destroy old list
	info.drawGL _ b;
	};
	
ViewerMouse: PUBLIC PROCEDURE[frame: State, click: BOOLEAN] RETURNS[x,y: INTEGER] = {
  rx, ry: REAL;
  [rx, ry] _ RealViewerMouse[frame, click];
  x _ Real.RoundI[x]; y _ Real.RoundI[y] };

RealViewerMouse: PUBLIC PROCEDURE[frame: State, click: BOOLEAN] RETURNS[x,y: REAL] = {
  info: Info _ GetInfo[frame];
  IF info=NIL THEN RETURN [0,0];
  IF click THEN [x,y] _ GetBug[info] ELSE [x,y] _ GetPlace[info];
  };

GetBug: ENTRY PROC [info: Info] RETURNS[x,y: REAL] = { OPEN info;
  ENABLE UNWIND => NULL;
  bugflag _ FALSE;
  UNTIL viewer.destroyed OR bugflag DO WAIT bugged ENDLOOP;
  IF viewer.destroyed THEN x _ y _ 0
  ELSE { x _ bugX; y _ bugY; bugflag _ FALSE };
  };

SetBug: PUBLIC ENTRY PROC [info: Info, x,y: REAL] = { OPEN info;
  ENABLE UNWIND => NULL;
  bugflag _ TRUE; bugX _ x; bugY _ y;
  NOTIFY bugged };

GetPlace: ENTRY PROC [info: Info] RETURNS[x,y: REAL] = { OPEN info;
  ENABLE UNWIND => NULL;
  mouseflag _ FALSE;
  UNTIL viewer.destroyed OR mouseflag DO WAIT mouse ENDLOOP;
  IF viewer.destroyed THEN x _ y _ 0
  ELSE { x _ mouseX; y _ mouseY; mouseflag _ FALSE };
  };

SetPlace: PUBLIC ENTRY PROC [info: Info, x,y: REAL] = { OPEN info;
  ENABLE UNWIND => NULL;
  mouseflag _ TRUE; mouseX _ x; mouseY _ y; NOTIFY mouse;
  };

DoAtom: PROC [state: State, atom: ATOM] = {
JaM.Execute[state, atom];
};

DoButton: PROC [state: State, button: ATOM, x,y: REAL] = {
JaM.PushReal[state, x];
JaM.PushReal[state, y];
SELECT button FROM
$RedDown, $CtrlRedDown,
$ShiftRedDown, $CtrlShiftRedDown =>  JaM.ExecuteRope[state,".reddown"];
$YellowDown, $CtrlYellowDown,
$ShiftYellowDown, $CtrlShiftYellowDown => JaM.ExecuteRope[state,".yellowdown"];
$BlueDown, $CtrlBlueDown,
$ShiftBlueDown, $CtrlShiftBlueDown => JaM.ExecuteRope[state,".bluedown"];
$Track, $CtrlTrack,
$ShiftTrack, $CtrlShiftTrack => JaM.ExecuteRope[state,".track"];
$RedUp, $CtrlRedUp,
$ShiftRedUp, $CtrlShiftRedUp => JaM.ExecuteRope[state,".redup"];
$YellowUp, $CtrlYellowUp,
$ShiftYellowUp, $CtrlShiftYellowUp => JaM.ExecuteRope[state,".yellowup"];
$BlueUp, $CtrlBlueUp,
$ShiftBlueUp, $CtrlShiftBlueUp => JaM.ExecuteRope[state,".blueup"];
ENDCASE  => ERROR;	
};


--[self: ViewerClasses.Viewer, input: LIST OF REF ANY]
InputNotify: PUBLIC ViewerClasses.NotifyProc = {
  Do: PROC [button: ATOM] = {
    DoButton[NARROW[self.data,Info].frame,button,x,y] };
  ReleaseButtons: PROC = {
	info: Info _ NARROW[self.data];
	IF ~info.capturedButtons THEN RETURN;
	InputFocus.ReleaseButtons[];
    info.capturedButtons _ FALSE };
  AdjustCoords: PROC = {
	info: Info _ NARROW[self.data];
	IF ~info.capturedButtons THEN -- get screen coordinates
		[x, y] _ Graphics.UserToWorld[info.vinitdc, mx, my]
	ELSE { x _ mx; y _ my };  -- already in screen coordinates
	[x, y] _ Graphics.WorldToUser[info.vdc, x, y]; -- convert using current dc
	};
  mx, my: INTEGER;
  x, y: REAL;
  Place: PROC = { SetPlace[NARROW[self.data,Info],x,y] };
  FOR l: LIST OF REF ANY _ input, l.rest UNTIL l = NIL DO
    WITH l.first SELECT FROM
      z: ATOM => SELECT z FROM
		$RedDown, $CtrlRedDown, $ShiftRedDown, $CtrlShiftRedDown => {
			SetBug[NARROW[self.data,Info],x,y]; Place[]; Do[z] };
		$YellowDown, $CtrlYellowDown, $ShiftYellowDown, $CtrlShiftYellowDown,
			$BlueDown, $CtrlBlueDown, $ShiftBlueDown, $CtrlShiftBlueDown,
			$Track, $CtrlTrack, $ShiftTrack, $CtrlShiftTrack => Do[z];
		$RedUp, $CtrlRedUp, $ShiftRedUp, $CtrlShiftRedUp,
			$YellowUp, $CtrlYellowUp, $ShiftYellowUp, $CtrlShiftYellowUp,
			$BlueUp, $CtrlBlueUp, $ShiftBlueUp, $CtrlShiftBlueUp => { Do[z]; ReleaseButtons[] };	
		$Place => Place[];
		ENDCASE  => DoAtom[NARROW[self.data,Info].frame,z];
      z: TIPUser.TIPScreenCoords => { [mx, ----, my] _ z^; AdjustCoords[] };
      ENDCASE => {
      	MessageWindow.Blink[];
      	MessageWindow.Append["unknown TIP Atom (JaMImager)", TRUE];
      	};
    ENDLOOP;
  };

Init: PROC[frame: State] = {
  J.Register[frame,".erase",JErase];
  J.Register[frame,".initdc",InitDC];
  J.Register[frame,".destroyviewer",JDestroyViewer];
  J.Register[frame,".capturebuttons",JCaptureButtons];
  J.Register[frame,".releasebuttons",JReleaseButtons];
  J.Register[frame,".reloadTIP",JReloadTIP];
  J.Register[frame,".enableviewer",EnableViewer];
  J.Register[frame,".disableviewer",DisableViewer];
  J.Register[frame,".keepgl",KeepGL];
  J.Register[frame,".dorefresh",DoRefresh];
};

ViewerOps.RegisterViewerClass[$JaMGraphics, jamGraphicsClass];


END...
  

jgeneric proc for TIP atoms.  Normal TIP table never comes here
all the *Down, *Up and *Track atoms
ส9–
"Mesa" style˜Iprocš”ฯcก
œ
œ
ฯk	œ,žœ
žœžœžœ*žœžœžœ6žœžœžœMžœ@žœ;žœŒ
žœ)ž
œžœžœžœก
žœžœ:žœ
žœž
œž
œž
œ1žœIžœต
ฯn
œžœ$Ÿ	œžœ
žœXŸœžœ
žœžœ
žœžœŸœžœ
žœ=žœžœžœQžœ7œžœ
žœ2œžœžœ
žœžœ
žœžœ
žœžœžœ
žœ
žœ,ž
œ;ž
œAž
œวžœIžœžœžœžœ<žœžœžœžœฎ
žœ$žœžœbžœ$žœžœkžœ$žœžœ.ž
œžœ0Ÿœž	œ8œ!žœžœ
žœ
žœ&Ÿ
œžœgŸœžœ
žœ žœžœ-Ÿœž	œฆ
žœ'Ÿœž	œŠ
žœŸœž	œ5žœžœž
œžœžœžœžœ
žœžœžœžœžœŸœž	œ:žœž
œž
œ
ž
œž
œž
œž
œž
œ0žœžœžœžœ
žœžœžœžœžœ
žœŸœžœ
žœCžœŸ
œžœ
žœCžœะbnœžœ
žœ6žœž
œžœžœžœžœ
žœžœžœžœžœžœ
žœžœžœ	Ÿ	œžœ
žœ6žœž
œžœžœ
žœ
žœžœžœžœ
žœžœžœ2œžœžœžœœŸœžœ
ž	œžœžœžœžœ[Ÿœžœ
ž	œžœžœžœ'žœžœ
žœ
žœ
žœžœžœŸœžœ
žœžœžœžœ	žœ
žœžœžœžœžœ	žœ
žœžœžœžœ
žœ!žœ
Ÿœžœ
žœ
žœžœžœ	žœ
žœžœžœžœŸœžœ
žœžœžœžœ	žœ
žœžœžœžœžœžœ
žœžœžœžœ
žœ'žœ
Ÿœžœ
žœ
žœžœžœ	žœ
žœžœžœžœ
˜ผ:JšŸœžœžœ˜+š
œ>™>Jš
œ˜J˜J˜—JšŸœžœžœžœ˜:š
œ#™#J˜J˜šžœž˜š
œ˜Jš
œG˜G—š
œ˜Jš
œO˜O—š
œ˜Jš
œI˜I—š
œ˜Jš
œ@˜@—š
œ˜Jš
œ@˜@—š
œ˜Jš
œI˜I—š
œ˜Jš
œC˜C—Jšžœžœ˜—J˜—J˜Kš{œ
ะci7œ
žœ Ÿœžœ
žœžœ(Ÿœžœžœžœžœ
žœ;žœŸœžœžœžœžœ
œ7žœ!œ0œžœ
žœŸœžœžœžœžœ
žœ
žœ
žœžœžœ
žœžœ	žœ
žœ
žœžœžœKžœีžœžœFœ$žœ`žœžœŸœžœž
œ$ž
œ%ž
œ4ž
œ6ž
œ6ž
œ,ž
œ1ž
œ3ž
œ%ž
œnžœ˜แ—…—)š0=