********************************************************************

      *  NOTE: This file is generated automatically from the event
      *        definition file Wheeler.evt.
      ********************************************************************


<* PRAGMA LL *>

MODULE WheelerViewClass;

<*NOWARN*> IMPORT TextConv, ZeusClass, WheelerAlgClass, ViewClass;
<*NOWARN*> IMPORT MiscFmt;

REVEAL
  T = Public BRANDED OBJECT
      OVERRIDES
        <* LL.sup = VBT.mu *>
        isCompat := IsCompat;
        <* LL.sup < VBT.mu *>
        oeStartPermute := StartPermute;
        oeNextRotation := NextRotation;
        oeRotationsSorted := RotationsSorted;
        oePermuteDone := PermuteDone;
        oeStartEncode := StartEncode;
        oeEncodeNextChar := EncodeNextChar;
        oeEncodeDistinctCount := EncodeDistinctCount;
        oeEncodeFoundCode := EncodeFoundCode;
        oeEncodeDone := EncodeDone;
        oeInitDecode := InitDecode;
        oeStartDecode := StartDecode;
        oeDecodeNextCode := DecodeNextCode;
        oeDecodeDistinctCount := DecodeDistinctCount;
        oeDecodeFoundChar := DecodeFoundChar;
        oeDecodeDone := DecodeDone;
        oeStartReconstruct := StartReconstruct;
        oeFirstChars := FirstChars;
        oeConsiderChar := ConsiderChar;
        oeEqualChars := EqualChars;
        oeFinishCharRun := FinishCharRun;
        oeStartResult := StartResult;
        oeResultNextChar := ResultNextChar;
        oeEndResult := EndResult;
        oeReveal := Reveal;
        <* LL.sup = VBT.mu *>
      END;

PROCEDURE IsCompat(<*UNUSED*> v: T; alg: ZeusClass.T): BOOLEAN =
  <* LL.sup = VBT.mu *>
  BEGIN
    RETURN ISTYPE(alg, WheelerAlgClass.T)
  END IsCompat;

PROCEDURE StartPermute (view: T
    ; <*UNUSED*> string: TEXT
    ; <*UNUSED*> alphabet: TEXT
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END StartPermute;
PROCEDURE NextRotation (view: T
    ; <*UNUSED*> i: INTEGER
    ; <*UNUSED*> string: TEXT
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END NextRotation;
PROCEDURE RotationsSorted (view: T
    ; <*UNUSED*> rotations: MiscFmt.RefTextArray
    ; <*UNUSED*> rowIndex: INTEGER
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END RotationsSorted;
PROCEDURE PermuteDone (view: T
    ; <*UNUSED*> lastchars: TEXT
    ; <*UNUSED*> rowIndex: INTEGER
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END PermuteDone;
PROCEDURE StartEncode (view: T
    ; <*UNUSED*> alphabet: TEXT
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END StartEncode;
PROCEDURE EncodeNextChar (view: T
    ; <*UNUSED*> i: INTEGER
    ; <*UNUSED*> c: CHAR
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END EncodeNextChar;
PROCEDURE EncodeDistinctCount (view: T
    ; <*UNUSED*> i: INTEGER
    ; <*UNUSED*> k: INTEGER
    ; <*UNUSED*> n: INTEGER
    ; <*UNUSED*> c: CHAR
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END EncodeDistinctCount;
PROCEDURE EncodeFoundCode (view: T
    ; <*UNUSED*> i: INTEGER
    ; <*UNUSED*> k: INTEGER
    ; <*UNUSED*> code: INTEGER
    ; <*UNUSED*> c: CHAR
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END EncodeFoundCode;
PROCEDURE EncodeDone (view: T
    ; <*UNUSED*> alphabet: TEXT
    ; <*UNUSED*> codes: MiscFmt.RefIntArray
    ; <*UNUSED*> rowIndex: INTEGER
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END EncodeDone;
PROCEDURE InitDecode (view: T
    ; <*UNUSED*> alphabet: TEXT
    ; <*UNUSED*> codes: MiscFmt.RefIntArray
    ; <*UNUSED*> rowIndex: INTEGER
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END InitDecode;
PROCEDURE StartDecode (view: T
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END StartDecode;
PROCEDURE DecodeNextCode (view: T
    ; <*UNUSED*> i: INTEGER
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END DecodeNextCode;
PROCEDURE DecodeDistinctCount (view: T
    ; <*UNUSED*> i: INTEGER
    ; <*UNUSED*> k: INTEGER
    ; <*UNUSED*> n: INTEGER
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END DecodeDistinctCount;
PROCEDURE DecodeFoundChar (view: T
    ; <*UNUSED*> i: INTEGER
    ; <*UNUSED*> k: INTEGER
    ; <*UNUSED*> c: CHAR
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END DecodeFoundChar;
PROCEDURE DecodeDone (view: T
    ; <*UNUSED*> lastchars: TEXT
    ; <*UNUSED*> rowIndex: INTEGER
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END DecodeDone;
PROCEDURE StartReconstruct (view: T
    ; <*UNUSED*> lastchars: TEXT
    ; <*UNUSED*> rowIndex: INTEGER
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END StartReconstruct;
PROCEDURE FirstChars (view: T
    ; <*UNUSED*> t: TEXT
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END FirstChars;
PROCEDURE ConsiderChar (view: T
    ; <*UNUSED*> i: INTEGER
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END ConsiderChar;
PROCEDURE EqualChars (view: T
    ; <*UNUSED*> i: INTEGER
    ; <*UNUSED*> j: INTEGER
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END EqualChars;
PROCEDURE FinishCharRun (view: T
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END FinishCharRun;
PROCEDURE StartResult (view: T
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END StartResult;
PROCEDURE ResultNextChar (view: T
    ; <*UNUSED*> pos: INTEGER
    ; <*UNUSED*> k: INTEGER
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END ResultNextChar;
PROCEDURE EndResult (view: T
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END EndResult;
PROCEDURE Reveal (view: T
    ; <*UNUSED*> i: INTEGER
) =
  <* LL.sup < VBT.mu *>
  BEGIN
    view.evtHandled := FALSE;
  END Reveal;

BEGIN
END WheelerViewClass.