-- file:  ChollaBBoard.mesa
-- edited by Barth, August 11, 1981  4:34 PM
-- edited by Brotz, March 3, 1983  5:12 PM
-- edited by Crowther, January 13, 1982  10:36 AM

DIRECTORY
  Ascii,
  ccD: FROM "ChollaCmdDefs",
  dsD: FROM "DisplayDefs",
  exD: FROM "ExceptionDefs",
  inD: FROM "InteractorDefs",
  intCommon,
  lmD: FROM "LaurelMenuDefs",
  MessageParse,
  opD: FROM "OperationsDefs",
  prD: FROM "ProtectionDefs",
  Storage,
  String,
  tsD: FROM "TOCSelectionDefs",
  vmD: FROM "VirtualMgrDefs";

ChollaBBoard: PROGRAM
  IMPORTS ccD, dsD, exD, inD, intC: intCommon, lmD, MessageParse, Storage, String, tsD,
    vmD
  EXPORTS ccD =
BEGIN


bbTopHp, bbMiddleHp, bbLowerHp: inD.HousePtr;

-- the following variables save state from the time of a modify to the time of a deliver
bbAction: ccD.Action _ none;
savedUniqueId: STRING _ [24];
savedThisId: STRING _ [24];
savedIndex: vmD.TOCIndex _ 0;


InstallBB: PUBLIC PROCEDURE =
BEGIN
tnp: inD.TOCTextNbrPtr = intC.tocTextNbr;
oldToc: vmD.TOCHandle;
bbtoc: vmD.TOCHandle;
key: CARDINAL;
inD.StopBlinkingCaret[];
intC.userBracketsHouse.nextHouse _ bbTopHp;
bbTopHp.nextHouse.text.length _ 0;
lmD.ChangeEditorMenu[singleLine];
inD.ChangeCommandMenu
  [cnp: intC.mailCommandNbr, region: intC.mailCommandRegion, linesToKeep: 2];
intC.tocCommandNbr.houses _ bbMiddleHp;
inD.ChangeCommandMenu
  [cnp: intC.tocCommandNbr, region: intC.TOCCommandRegion, linesToKeep: 0];
intC.cmCommandNbr.houses _ bbLowerHp;
inD.ChangeCommandMenu
  [cnp: intC.cmCommandNbr, region: intC.CMCommandRegion, linesToKeep: 0];
[bbtoc, key] _ ccD.GetTOCForFile["ChollaBulletinBoard"L, bb];
vmD.UnlockTOC[bbtoc, key];
oldToc _ tnp.toc;
key _ vmD.WaitForLock[oldToc];
tnp.toc _ bbtoc;
tnp.haveToc _ TRUE;
vmD.UnlockTOC[oldToc, key];
key _ vmD.WaitForLock[bbtoc];
dsD.ClearRectangle[inD.leftMargin, inD.rightMargin, tnp.topY, tnp.bottomY];
inD.TOCTextPainter[tnp, key];
vmD.UnlockTOC[bbtoc, key];
IF inD.CaretIsBlinking[] THEN inD.SetCaretBlinking[intC.target.point, intC.target.mnp];
END;  -- of InstallBB --


BBLaurel: inD.CommandProcedure = {ccD.RestoreLaurel[]};


BBSpecs: inD.CommandProcedure =
BEGIN
IF ~ccD.IsAuthorized[onlooker, hp] THEN RETURN;
ccD.InstallSpecs[];
END; -- of BBSpecs --


BBDisplay: inD.CommandProcedure =
BEGIN
IF ~ccD.IsAuthorized[onlooker, hp] THEN RETURN;
inD.DisplayMessageCommand[hp, TRUE];
END; -- of BBDisplay --


BBDeliver: inD.CommandProcedure =
BEGIN
cm: vmD.ComposedMessagePtr = vmD.ComposedMessage[intC.cmTextNbr.message];
toc: vmD.TOCHandle;
key: CARDINAL;
index: vmD.TOCIndex;
ok: BOOLEAN;
IF ~ccD.IsAuthorized[technician, hp] THEN RETURN;
IF bbAction = none THEN
 {exD.DisplayExceptionString["Nothing to Deliver!"L]; RETURN};
[toc, key] _ ccD.GetTOCForFile["ChollaBulletinBoard"L, bb];
[index, ok] _ GetSingleSelectedEntry[toc, key, bbAction = insert];
IF bbAction = insert THEN index _ index + 1;
SELECT TRUE FROM
  (bbAction = replace AND index # savedIndex) =>
    exD.DisplayExceptionString["Invalid Selection"L];
  ok =>
    BEGIN
    fieldList: MessageParse.FieldList _ MessageParse.MakeFieldList[cm];
    IF bbAction = replace THEN
      BEGIN
      MessageParse.ReplaceOrAppendField[cm, @fieldList, "UniqueId"L, savedUniqueId];
      MessageParse.ReplaceOrAppendField[cm, @fieldList, "ThisId"L, savedThisId];
      END;
    IF ~ccD.SendChollaMail[bbAction, bb, toc, key, index, cm, @fieldList] THEN
      exD.DisplayExceptionString["Faulty update message!"L];
    MessageParse.FreeFieldList[fieldList];
    END;
  ENDCASE;
vmD.UnlockTOC[toc, key];
bbAction _ none;
END;  -- of BBDeliver --


BBDelete: inD.CommandProcedure =
BEGIN
cm: vmD.ComposedMessagePtr _ vmD.AllocateComposedMessageObject[];
toc: vmD.TOCHandle;
key: CARDINAL;
index: vmD.TOCIndex;
run: STRING _ [ccD.maxRunNameLength];
ok: BOOLEAN;
IF ~ccD.IsAuthorized[maven, hp] THEN RETURN;
ccD.StartMultiTOCOperation[];
[toc, key] _ ccD.GetTOCForFile["ChollaBulletinBoard"L, bb];
[index, ok] _ GetSingleSelectedEntry[toc, key];
IF ok THEN
  BEGIN
  IF confirmed OR inD.Confirm[1] THEN
    BEGIN  -- he wants to delete.
    fieldList: MessageParse.FieldList;
    ccD.LoadComposedMessage[toc, key, index, cm];
    fieldList _ MessageParse.MakeFieldList[cm];
    IF ObtainRunName[cm, fieldList, run] THEN
      BEGIN
      exD.DisplayExceptionString
        ["Are you sure that you wish to delete all traces of this run?"L];
      IF inD.Confirm[2] THEN
        IF ~ccD.SendChollaMail[delete, bb, toc, key, index, cm, @fieldList] THEN
          exD.DisplayExceptionString["Cannot perform run deletion!"L];
      END
    ELSE IF ~ccD.SendChollaMail[delete, bb, toc, key, index, cm, @fieldList] THEN
      exD.DisplayExceptionString["Cannot delete entry!"L];
    MessageParse.FreeFieldList[fieldList];
    END;
  END;
vmD.UnlockTOC[toc, key];
ccD.FinishMultiTOCOperation[];
vmD.FreeVirtualMessageObject[cm];
bbAction _ none;
END;  -- of BBDelete --


BBNewForm: inD.CommandProcedure=
BEGIN
mnp: inD.MessageTextNbrPtr = intC.cmTextNbr;
cm: vmD.ComposedMessagePtr _ vmD.ComposedMessage[mnp.message];
IF ~ccD.IsAuthorized[technician, hp] THEN RETURN;
bbAction _ insert;
vmD.InitComposedMessage[cm, "Subject: 
Topic


Message

"L];
ccD.ResetTheEditor[];
END;  -- of BBNewForm --


BBModify: inD.CommandProcedure=
BEGIN
mnp: inD.MessageTextNbrPtr = intC.cmTextNbr;
cm: vmD.ComposedMessagePtr = vmD.ComposedMessage[mnp.message];
bbSelection: vmD.TOCIndex;
toc: vmD.TOCHandle;
key: CARDINAL;
ok: BOOLEAN;
IF ~ccD.IsAuthorized[technician, hp] THEN RETURN;
IF ~confirmed AND intC.composedMessageEdited
  AND vmD.GetMessageSize[cm] # 0
  AND ~inD.AskUserToConfirm[exD.willReplaceMessage]
  THEN RETURN;
[toc, key] _ ccD.GetTOCForFile["ChollaBulletinBoard"L, bb];
[bbSelection, ok] _ GetSingleSelectedEntry[toc, key];
IF ok THEN BEGIN
  dm: vmD.DisplayMessagePtr _ vmD.AllocateDisplayMessageObject[];
  fieldList: MessageParse.FieldList;
  runName: STRING _ [20];
  vmD.LoadDisplayMessage[toc, key, bbSelection, dm];
  fieldList _ MessageParse.MakeFieldList[dm];
  IF ObtainRunName[dm, fieldList, runName] THEN
    exD.DisplayExceptionString["Can't modify a run-in-progress entry!"L]
  ELSE BEGIN
    MessageParse.GetWholeField[dm, fieldList, "UniqueID"L, savedUniqueId];
    MessageParse.GetWholeField[dm, fieldList, "ThisID"L, savedThisId];
    ccD.WriteMessageIntoComposeWindow[dm, @fieldList];
    MessageParse.DeleteField[cm, @fieldList, "Date"L];
    MessageParse.DeleteField[cm, @fieldList, "From"L];
    ccD.ResetTheEditor[];
    bbAction _ replace;
    savedIndex _ bbSelection;
    END;
  vmD.FlushDisplayMessage[dm, key];
  vmD.FreeVirtualMessageObject[dm];
  MessageParse.FreeFieldList[fieldList];
  END;
vmD.UnlockTOC[toc, key];
END;  -- of BBModify --


BBStepList: inD.CommandProcedure =
BEGIN
selectedEntry: vmD.TOCIndex;
toc: vmD.TOCHandle;
key: CARDINAL;
IF ~ccD.IsAuthorized[onlooker, hp] THEN RETURN;
[toc, key] _ ccD.GetTOCForFile["ChollaBulletinBoard"L, bb];
selectedEntry _ tsD.FirstSelectedEntry[toc, key];
IF selectedEntry # 0 AND selectedEntry = tsD.LastSelectedEntry[toc, key] THEN
  BEGIN
  dm: vmD.DisplayMessagePtr _ vmD.AllocateDisplayMessageObject[];
  runName: STRING _ [ccD.maxRunNameLength];
  fieldList: MessageParse.FieldList;
  vmD.LoadDisplayMessage[toc, key, selectedEntry, dm];
  fieldList _ MessageParse.MakeFieldList[dm];
  IF ObtainRunName[dm, fieldList, runName] THEN
    {hp.nextHouse.text.length _ 0; String.AppendString[hp.nextHouse.text, runName]};
  MessageParse.FreeFieldList[fieldList];
  vmD.FlushDisplayMessage[dm, key];
  vmD.FreeVirtualMessageObject[dm];
  END;
vmD.UnlockTOC[toc, key];
hp.nextHouse.houseRefresher[hp.nextHouse];
SELECT TRUE FROM
  ~(confirmed OR inD.ConfirmBrackets[hp: hp.nextHouse, fileExtension: "StepList.chml."L]) =>
    inD.IndicateCommandFinished[hp];
  hp.nextHouse.text.length = 0 =>
    {exD.DisplayExceptionString["Must name a run."L]; inD.IndicateCommandFinished[hp]};
  hp.nextHouse.text.length > 20 =>
    BEGIN
    exD.DisplayExceptionString["Run name is too long!"L];
    inD.IndicateCommandFinished[hp];
    END;
  ENDCASE =>
    BEGIN
    ccD.CleanupDisplayMessage[];
    [toc, key] _ ccD.GetTOCForFile["ChollaBulletinBoard"L, bb];
    tsD.ResetTOCSelection[toc, key];
    vmD.UnlockTOC[toc, key];
    IF ~ccD.InstallStepList[hp.nextHouse.text] THEN inD.IndicateCommandFinished[hp];
    END;
IF inD.CaretIsBlinking[] THEN inD.SetCaretBlinking[intC.target.point, intC.target.mnp];
END;  -- of BBStepList --


BBTalk: inD.CommandProcedure =
BEGIN
worked: BOOLEAN _ FALSE;
IF ~ccD.IsAuthorized[technician, hp] THEN RETURN;
IF confirmed OR inD.ConfirmBrackets[hp: hp.nextHouse, fileExtension: "Talk.bcd."L] THEN
  BEGIN
  lmD.ChangeEditorMenu[singleLine];
  worked _ ccD.MachineTalker[hp.nextHouse.text];
  END;
inD.IndicateCommandFinished[hp];
END;  -- of BBTalk --


BBFilter: inD.CommandProcedure =
BEGIN
exD.DisplayExceptionString["Not yet implemented."L];
END;  -- of BBFilter --


ObtainRunName: PUBLIC PROCEDURE
    [vm: vmD.VirtualMessagePtr, fieldList: MessageParse.FieldList, runName: STRING]
  RETURNS [isRun: BOOLEAN] =
BEGIN
string: STRING _ [10];
MessageParse.GetStringFromField[vm, fieldList, "BBEntryType"L, string];
-- no field returns zero length string.
IF (isRun _ String.EquivalentString[string, "Run"L]) THEN
  MessageParse.GetStringFromField[vm, fieldList, "Subject"L, runName];
END;  -- of ObtainRunName --


GetSingleSelectedEntry:
  PROCEDURE [toc: vmD.TOCHandle, key: CARDINAL, zeroOk: BOOLEAN _ FALSE]
  RETURNS [entry: vmD.TOCIndex, ok: BOOLEAN] =
BEGIN
ok _ FALSE;
SELECT (entry _ tsD.FirstSelectedEntry[toc, key]) FROM
  0 => IF ~(ok _ zeroOk) THEN exD.DisplayExceptionString["An entry must be selected"L];
  tsD.LastSelectedEntry[toc, key] => ok _ TRUE;
  ENDCASE => exD.DisplayExceptionString["Only a single entry may be selected"L];
END;  -- of GetSingleSelectedEntry --


-- Startup code for BBoard --


Init: PROCEDURE =
BEGIN
bbTopMenu: ARRAY [0 .. 3) OF lmD.HouseDescriptor _
  [[text: "Step list"L, type: brackets, bracketsText: ""L, command: BBStepList,
    indicDone: FALSE],
  [text: "Specs"L, command: BBSpecs, indicDone: FALSE],
  [text: "Laurel"L, rightFlush: TRUE, command: BBLaurel, indicDone: FALSE]];
  -- [text: "Filter"L, type: brackets, bracketsText: ""L, command: BBFilter]];
bbMiddleMenu: ARRAY [0 .. 2) OF lmD.HouseDescriptor _
  [[text: "Display"L, command: BBDisplay],
  [text: "Delete"L, command: BBDelete]];
bbLowerMenu: ARRAY [0 .. 5) OF lmD.HouseDescriptor _
  [[text: "New entry"L, command: BBNewForm],
  [text: "Modify"L, command: BBModify],
  [text: "Get"L, command: inD.GetCommand],
  [text: "Talk"L, type: brackets, bracketsText: ""L, command: BBTalk, indicDone: FALSE],
  [text: "Post"L, endOfLine: TRUE, rightFlush: TRUE, command: BBDeliver]];
specsHp, laurelHp: inD.HousePtr;

bbTopHp _ lmD.CreateCommandHouses
  [DESCRIPTOR[bbTopMenu], Storage.Node, Storage.String, 2,
  intC.newMailCommandHouse.leftX];
specsHp _ lmD.MapHouseTextToHousePtr[bbTopHp, "Specs"L];
laurelHp _ lmD.MapHouseTextToHousePtr[specsHp, "Laurel"L];
specsHp.leftX _ specsHp.leftX + (laurelHp.leftX - specsHp.rightX - 25);
specsHp.rightX _ specsHp.rightX + (laurelHp.leftX - specsHp.rightX - 25);
bbMiddleHp _ lmD.CreateCommandHouses
  [DESCRIPTOR[bbMiddleMenu], Storage.Node, Storage.String];
bbLowerHp _ lmD.CreateCommandHouses
  [DESCRIPTOR[bbLowerMenu], Storage.Node, Storage.String];
END;  -- of Init --


Init[];


END.  -- of ChollaBBoard --(635)\f1 5120v32V