gef/derived/gefeventIE.m3


Copyright (C) 1994, Digital Equipment Corp.
********************************************************************
      *  NOTE: This file is generated automatically from the event 
      *        definition file gefevent.evt.
 
********************************************************************
<* PRAGMA LL *>

MODULE gefeventIE;

<* NOWARN *> IMPORT RefList;
<* NOWARN *> IMPORT SLispClass;
<*NOWARN*> IMPORT gefeventAlgClass, gefeventViewClass;
<*NOWARN*> IMPORT Algorithm, AlgorithmClass, Thread, View, Zeus, ZeusClass;

<* FATAL Zeus.Error, Zeus.Locked *>
If you get either of these errors, contact a Zeus implementor.

TYPE
  InitArgs = BRANDED REF RECORD
     files: RefList.T
  END;

  EventArgs = BRANDED REF RECORD
     name: TEXT; args: RefList.T
  END;

  UpdateArgs = BRANDED REF RECORD
     name: TEXT; args: RefList.T
  END;

  FeedbackArgs = BRANDED REF RECORD
     name: TEXT; args: RefList.T
  END;

  PauseArgs = BRANDED REF RECORD

  END;
Zeus calls the following to invoke vbt v's event handler:

<*NOWARN*> PROCEDURE OEDispatcher(v: ZeusClass.T; evt: REFANY) RAISES {Thread.Alerted} =
  <* LL <= VBT.mu *>
  (* LL = {} if event style is output, LL = VBT.mu if event style is update. *)
  BEGIN
    TYPECASE v OF
    | gefeventViewClass.T (view) => <*NOWARN*>
      TYPECASE evt OF
      | InitArgs(varInitArgs) => <*NOWARN*>
          view.oeInit (
              varInitArgs.files
              )
      | EventArgs(varEventArgs) => <*NOWARN*>
          view.oeEvent (
              varEventArgs.name
                ,
              varEventArgs.args
              )
      | PauseArgs(varPauseArgs) => <*NOWARN*>
          view.oePause (
              )
      | UpdateArgs(varUpdateArgs) => <*NOWARN*>
          view.ueUpdate (
              varUpdateArgs.name
                ,
              varUpdateArgs.args
              )
      ELSE <* ASSERT FALSE *>
      END;
    ELSE (* this view isn't a gefeventViewClass, so just ignore *)
    END
  END OEDispatcher;

<*NOWARN*> PROCEDURE FEDispatcher(v: ZeusClass.T; evt: REFANY) =
  <* LL = VBT.mu *>
  BEGIN
    TYPECASE v OF
    | gefeventAlgClass.T (alg) => <*NOWARN*>
      TYPECASE evt OF
      | FeedbackArgs(varFeedbackArgs) => <*NOWARN*>
          alg.feFeedback (
              varFeedbackArgs.name
                ,
              varFeedbackArgs.args
              )
      ELSE <* ASSERT FALSE *>
      END;
    ELSE (* this alg isn't a gefeventAlgClass, so just ignore *)
    END
  END FEDispatcher;

PROCEDURE Init (
      initiator: Algorithm.T;
       files: RefList.T
    ) RAISES {Thread.Alerted} =
  <* LL = {} *>
  VAR zumeArgRec := NEW(InitArgs
               , files := files
      );
      alg := NARROW(initiator, gefeventAlgClass.T);
  BEGIN
    LOCK alg.evtMu DO
      INC(alg.eventDataRec.ctOfInit);
      alg.stopAtEvent := alg.eventDataRec.stopAtInit;
      alg.waitAtEvent := alg.eventDataRec.waitAtInit;
      Zeus.Dispatch(initiator, Zeus.EventStyle.Output, 1,
                    "Init", OEDispatcher, zumeArgRec);
    END;
  END Init;

PROCEDURE Event (
      initiator: Algorithm.T;
       name: TEXT; args: RefList.T
    ) RAISES {Thread.Alerted} =
  <* LL = {} *>
  VAR zumeArgRec := NEW(EventArgs
               , name := name
               , args := args
      );
      alg := NARROW(initiator, gefeventAlgClass.T);
  BEGIN
    LOCK alg.evtMu DO
      INC(alg.eventDataRec.ctOfEvent);
      alg.stopAtEvent := alg.eventDataRec.stopAtEvent;
      alg.waitAtEvent := alg.eventDataRec.waitAtEvent;
      Zeus.Dispatch(initiator, Zeus.EventStyle.Output, 1,
                    "Event", OEDispatcher, zumeArgRec);
    END;
  END Event;

PROCEDURE Pause (
      initiator: Algorithm.T;

    ) RAISES {Thread.Alerted} =
  <* LL = {} *>
  VAR zumeArgRec := NEW(PauseArgs
      );
      alg := NARROW(initiator, gefeventAlgClass.T);
  BEGIN
    LOCK alg.evtMu DO
      INC(alg.eventDataRec.ctOfPause);
      alg.stopAtEvent := alg.eventDataRec.stopAtPause;
      alg.waitAtEvent := alg.eventDataRec.waitAtPause;
      Zeus.Dispatch(initiator, Zeus.EventStyle.Output, 1,
                    "Pause", OEDispatcher, zumeArgRec);
    END;
  END Pause;

PROCEDURE Update (
      initiator: Algorithm.T;
       name: TEXT; args: RefList.T
    ) RAISES {Thread.Alerted} =
  <* LL = VBT.mu *>
  VAR zumeArgRec := NEW(UpdateArgs
               , name := name
               , args := args
      );
  BEGIN
    Zeus.Dispatch(initiator, Zeus.EventStyle.Update, 1,
                  "Update", OEDispatcher, zumeArgRec);
  END Update;

PROCEDURE Feedback (
      initiator: View.T;
       name: TEXT; args: RefList.T
    ) RAISES {Thread.Alerted} =
  <* LL = VBT.mu *>
  VAR zumeArgRec := NEW(FeedbackArgs
               , name := name
               , args := args
      );
  BEGIN
    Zeus.Dispatch(initiator, Zeus.EventStyle.Notify, 1,
                  "Feedback", FEDispatcher, zumeArgRec);
  END Feedback;

BEGIN
END gefeventIE.