<> <> <> <<>> DIRECTORY Atom USING [MakeAtom, GetProp, PutProp, RemProp], CommandTool USING[DoCommand], Convert USING[CardFromRope], BasicTime USING[nullGMT, Unpack], Booting USING[CheckpointProc, RegisterProcs, RollbackProc], FS USING [Error, StreamOpen], Icons USING [IconFlavor], IconRegistry USING [GetIcon], IO USING[GetCedarTokenRope, TokenKind, BreakProc, Close, EndOf, EndOfStream, Error, Flush, GetChar, PeekChar, GetBlock, GetIndex, GetLength, GetTokenRope, int, PutBlock, PutF, PutRope, RIS, rope, SetIndex, SetLength, SkipWhitespace, STREAM, time, GetLineRope], List USING [Sort, CompareProc], Menus USING [SetLine, GetNumberOfLines, MenuEntry], MessageWindow USING [Append, Blink], Process USING[Pause, SecondsToTicks, Detach], RememberDefs, RememberDefsPrivate, Rope USING[ROPE, Cat, Concat, Fetch, Equal, Substr], Tempus USING [Adjust, defaultTime, Error, MakeRope, Packed, PackedSeconds, Seconds, PackedToSeconds, SecondsToPacked, Parse, Precision, Unintelligible], TiogaExtraOps USING [GetFile], TiogaOps USING [Ref, FirstChild, Jump, GetRope, SaveSpanForPaste, LastLocWithin, SelectDocument, Paste, Next, LockSel, UnlockSel, SaveSelB, RestoreSelB, ViewerDoc], UserProfile USING [Boolean, Number, Token, ProfileChangedProc, CallWhenProfileChanges], ViewerClasses USING[Viewer], ViewerEvents USING[RegisterEventProc, ViewerEvent, EventProc], ViewerIO USING [CreateViewerStreams], ViewerSpecs USING [openBottomY], ViewerTools USING[MakeNewTextViewer, SetContents], ViewerOps USING[AddProp, FetchProp, PaintViewer, BlinkIcon, DestroyViewer, FindViewer, RestoreViewer], WalnutDisplayerOps USING [StuffMsgContents] ; RememberImpl: CEDAR MONITOR IMPORTS Atom, BasicTime, Booting, CommandTool, Convert, FS, IconRegistry, IO, List, Menus, MessageWindow, Process, RememberDefsPrivate, Rope, Tempus, TiogaExtraOps, TiogaOps, UserProfile, ViewerEvents, ViewerIO, ViewerOps, ViewerSpecs, ViewerTools, WalnutDisplayerOps EXPORTS RememberDefs, RememberDefsPrivate = BEGIN OPEN RememberDefs, RememberDefsPrivate; <> Error: PUBLIC ERROR [ec: ErrorCode, msg: Rope.ROPE _ NIL] = CODE; <> eventList: PUBLIC LIST OF Event _ NIL; itIsNow: PUBLIC Tempus.Packed _ Tempus.defaultTime; -- defaultTime used in Register, EnterEventTime. Is a variable so that can be reset for debugging. walnutUser: PUBLIC BOOL _ FALSE; peanutUser: PUBLIC BOOL _ FALSE; <> Construct: ENTRY PROC = { ENABLE UNWIND => NULL; fileStream: IO.STREAM; BEGIN -- establish scope for exits IF eventList # NIL THEN FOR el: LIST OF Event _ eventList, el.rest UNTIL el = NIL DO event: Event = el.first; IF event.viewer # NIL AND NOT event.viewer.destroyed THEN ViewerOps.DestroyViewer[event.viewer]; ENDLOOP; eventList _ NIL; fileStream _ FS.StreamOpen["RememberEvents.txt", $read ! ANY => CONTINUE]; IF fileStream = NIL THEN GOTO noReminderFile; DO parameters: ParameterList _ NIL; timeRope, text, repeat, duration, lead, until, iconLabel, icon, message: ROPE _ NIL; [] _ IO.SkipWhitespace[fileStream]; timeRope _ ReadTimeRope[fileStream]; IF timeRope = NIL THEN EXIT; parameters _ LIST[NEW[Parameter _ [startTime, timeRope]]]; DO r: ROPE; class: ParameterClass; [class, r] _ ReadParameter[fileStream ! Error => GOTO formatError]; parameters _ CONS[NEW[Parameter _ [class, r]], parameters]; IF class = text THEN EXIT; ENDLOOP; [] _ Register[ parameters: parameters ! Error => IF ec = formatError THEN GOTO formatError ELSE IF ec = timeRopeFormatError THEN GOTO timeRopeFormatError ]; ENDLOOP; fileStream.Close[]; EXITS formatError => { out: IO.STREAM _ ViewerIO.CreateViewerStreams["Remember Error Log"].out; eventList _ NIL; out.PutF["Format error in RememberEvents.txt, at or near position: %d\n", IO.int[fileStream.GetIndex[]]]; }; timeRopeFormatError => { out: IO.STREAM _ ViewerIO.CreateViewerStreams["Remember Error Log"].out; eventList _ NIL; out.PutF["DateAndTime.Unintelligible in RememberEvents.txt, at or near position: %d\n", IO.int[fileStream.GetIndex[]]]; out.PutRope["\n"]; }; noReminderFile => { eventList _ NIL; MessageWindow.Append["Could not find RememberEvents.txt: no events logged.", TRUE]; MessageWindow.Blink[]; }; END; }; ReadParameters: PUBLIC PROC [stream: IO.STREAM] RETURNS[parameters: ParameterList] = { UNTIL IO.EndOf[stream] DO r: ROPE; class: ParameterClass; [class, r] _ ReadParameter[stream]; parameters _ CONS[NEW[Parameter _ [class, r]], parameters]; [] _ IO.SkipWhitespace[stream]; ENDLOOP; }; ReadParameter: PROC[stream: IO.STREAM] RETURNS[parameterClass: ParameterClass _ text, value: ROPE _ NIL] = { ENABLE { IO.EndOfStream => GOTO formatError; IO.Error => GOTO formatError; }; key: ROPE; kind: IO.TokenKind; [kind, value, ] _ IO.GetCedarTokenRope[stream]; SELECT kind FROM tokenROPE => RETURN[text, value]; tokenID => key _ value; tokenSINGLE => { -- e.g. , ; etc. left over on line. [parameterClass, value] _ ReadParameter[stream]; RETURN; }; ENDCASE => IO.Error[SyntaxError, stream]; [] _ IO.SkipWhitespace[stream]; IF IO.PeekChar[stream] = ': THEN [] _ IO.GetChar[stream]; SELECT TRUE FROM Rope.Equal[s1: key, s2: "REPEAT", case: FALSE] => parameterClass _ repeat; Rope.Equal[s1: key, s2: "DURATION", case: FALSE] => parameterClass _ duration; Rope.Equal[s1: key, s2: "GETSERIOUSAFTER", case: FALSE], Rope.Equal[s1: key, s2: "NAGTIME", case: FALSE] => parameterClass _ getSeriousAfter; Rope.Equal[s1: key, s2: "UNTIL", case: FALSE] => parameterClass _ until; Rope.Equal[s1: key, s2: "LEADTIME", case: FALSE] => parameterClass _ leadTime; Rope.Equal[s1: key, s2: "TIME", case: FALSE] => parameterClass _ startTime; Rope.Equal[s1: key, s2: "TEXT", case: FALSE] => parameterClass _ text; Rope.Equal[s1: key, s2: "ICONFLAVOR", case: FALSE] => parameterClass _ iconFlavor; Rope.Equal[s1: key, s2: "ICONLABEL", case: FALSE] => parameterClass _ iconLabel; Rope.Equal[s1: key, s2: "ICONLABELTYPE", case: FALSE] => parameterClass _ iconLabelType; Rope.Equal[s1: key, s2: "MESSAGE", case: FALSE] => parameterClass _ message; ENDCASE => Error [formatError, key]; [kind, value, ] _ IO.GetCedarTokenRope[stream]; -- value will be the next object. If surrounded in "'s, the "'s will be removed. RETURN; EXITS formatError => Error[formatError]; }; <> RegisterEvent: PUBLIC ENTRY PROC [parameters: ParameterList, scanThis: Rope.ROPE _ NIL, out: IO.STREAM] = TRUSTED { ENABLE UNWIND => NULL; event: Event _ Register[parameters, scanThis]; IF out # NIL THEN { out.PutF["Reminder will be posted at %g", IO.rope[Tempus.MakeRope[time: Tempus.SecondsToPacked[[event.timeToStartNotification - event.leadTime]], includeDayOfWeek: TRUE]]]; IF event.durationTime > 0 THEN out.PutF[", for %d minutes", IO.int[event.durationTime/60]]; IF event.repeat # NIL THEN out.PutF[", repeated %g", IO.rope[event.repeat]]; IF event.getSeriousAfter # 0 THEN out.PutF[", start nagging after %d minutes", IO.int[event.getSeriousAfter/60]]; }; Process.Detach[FORK Save[]]; }; Register: INTERNAL PROC [parameters: ParameterList, scanThis: Rope.ROPE _ NIL] RETURNS[event: Event] = { ENABLE Tempus.Unintelligible => Error[timeRopeFormatError, Rope.Cat[ SELECT ec FROM invalid => "Invalid: ", overConstrained => "Over Constrained: ", tooVague => "Too Vague: ", nothingSpecified => "Not a time: ", notImplemented => "Not Implemented: ", ENDCASE => ERROR, Rope.Substr[base: rope, len: vicinity], "<>", Rope.Substr[base: rope, start: vicinity] ]]; startAt, text, lead, until, duration, getSerious, repeat, iconFlavor, iconLabel: Rope.ROPE; timeToStartNotification, nextNotification: PackedSeconds _ [0]; durationTime, leadTime, getSeriousTime: Seconds _ 0; precision: Tempus.Precision; Lookup: PROC [class: ParameterClass] RETURNS[value: Rope.ROPE _ NIL] = INLINE { FOR l: ParameterList _ parameters, l.rest UNTIL l = NIL DO IF l.first.class = class THEN RETURN[l.first.value]; ENDLOOP; }; LookupKeyWord: PROC [word: Rope.ROPE] RETURNS[ParameterList] = INLINE { FOR l: KeyWordList _ keyWordList, l.rest UNTIL l = NIL DO IF Rope.Equal[l.first.key, word, FALSE] THEN RETURN[l.first.defaults]; ENDLOOP; RETURN[NIL]; }; text _ Lookup[text]; startAt _ Lookup[startTime]; -- i.e. specified in parameters iconFlavor _ Lookup[iconFlavor]; iconLabel _ Lookup[iconLabel]; IF scanThis # NIL THEN { h: IO.STREAM = IO.RIS[scanThis]; token: ROPE; tokens: LIST OF ROPE; UNTIL h.EndOf[] DO breakProc: IO.BreakProc = { RETURN[SELECT char FROM ', , '. , ';, ': => sepr, ' , '\n, '\t, '\l => sepr, -- white space ENDCASE => other ]; }; defaults: ParameterList; iconLabelType: Rope.ROPE; token _ h.GetTokenRope[breakProc].token; tokens _ CONS[token, tokens]; IF (defaults _ LookupKeyWord[token]) # NIL THEN { -- add defaults to end of parameters, i.e. if parameters are specified by / .., they take precedence over those specified via keywords. FOR l: ParameterList _ parameters, l.rest UNTIL l = NIL DO defaults _ CONS[l.first, defaults]; ENDLOOP; parameters _ defaults; <> IF iconLabel = NIL AND (iconLabel _ Lookup[iconLabel]) = NIL AND (iconLabelType _ Lookup[iconLabelType]) # NIL THEN -- this check must be done here because iconLabelTypes may require knowing exactly where in the rope the corresponding key word appeared. SELECT TRUE FROM Rope.Equal[iconLabelType, "this", FALSE] => iconLabel _ token; Rope.Equal[iconLabelType, "next", FALSE] => { iconLabel _ h.GetTokenRope[breakProc].token; IF Rope.Fetch[iconLabel, 0] IN ['A..'Z] THEN { pos: INT = h.GetIndex[]; r: ROPE; WHILE Rope.Fetch[r _ h.GetTokenRope[breakProc].token, 0] IN ['A..'Z] DO iconLabel _ Rope.Cat[iconLabel, " ", r]; ENDLOOP; h.SetIndex[pos]; }; }; Rope.Equal[iconLabelType, "prev", FALSE] => IF tokens.rest # NIL THEN { iconLabel _ tokens.rest.first; IF Rope.Fetch[iconLabel, 0] IN ['A..'Z] THEN { FOR l: LIST OF ROPE _ tokens.rest.rest, l.rest UNTIL l = NIL DO IF NOT (Rope.Fetch[l.first, 0] IN ['A..'Z]) THEN EXIT; iconLabel _ Rope.Cat[l.first, " ", iconLabel]; ENDLOOP; }; }; ENDCASE => Error[formatError]; }; ENDLOOP; -- end of loop processing scan this IF startAt = NIL AND timeToStartNotification = 0 THEN { -- look for a time in scanThis t: Packed _ BasicTime.nullGMT; start, len: INT; startAt _ Lookup[startTime]; [t, precision, start, len] _ Tempus.Parse[rope: scanThis, baseTime: itIsNow ! Tempus.Unintelligible => IF ec # overConstrained THEN CONTINUE]; -- time may still be specified via keywords. Used to just check for nothingSpecified, but invalid can be raised in case that the word 'week' or 'day' appears in the text. IF t # BasicTime.nullGMT THEN { IF startAt # NIL THEN -- time specified both in text and keyword, e.g. keyword says Wednesday 1:15PM, user says Today, or the actual date. [t, precision] _ Tempus.Parse[rope: Rope.Cat[startAt, " ", Rope.Substr[base: scanThis, start: start, len: len]], baseTime: itIsNow ! Tempus.Unintelligible => CONTINUE]; timeToStartNotification _ Tempus.PackedToSeconds[t]; }; }; IF text = NIL THEN text _ scanThis; }; -- end of IF scanThis # NIL IF timeToStartNotification = 0 AND startAt # NIL THEN { -- startAt specified either in parameters, or via keyword. t: Packed; [t, precision] _ Tempus.Parse[startAt, itIsNow]; timeToStartNotification _ Tempus.PackedToSeconds[t]; }; IF timeToStartNotification = 0 THEN Error[timeNotSpecified]; IF (repeat _ Lookup[repeat]) # NIL THEN nextNotification _ ComputeRepetitionInterval[repeat, timeToStartNotification]; -- call ComputeRepetitionInterval here just so any errors will get noticed at registration time, rather than in event minder IF (duration _ Lookup[duration]) # NIL THEN { IF NOT Rope.Equal[duration, "NIL"] THEN -- so user can override defaultDuration by saying Duration: NIL durationTime _ Convert.CardFromRope[duration]*60 } ELSE IF defaultDuration # -1 AND precision > days THEN durationTime _ defaultDuration * 60; -- if user says Thursday, then don't default duration, but if he says a time do so IF (lead _ Lookup[leadTime]) # NIL THEN { leadTime _ Convert.CardFromRope[lead]*60; <> } ELSE IF precision <= days THEN NULL -- similarly if user says "See somebody Thursday", don't use leadtime. ELSE IF defaultLeadTime > 0 THEN leadTime _ (defaultLeadTime * 60); IF (until _ Lookup[until]) # NIL THEN durationTime _ Tempus.PackedToSeconds[Tempus.Parse[until, Tempus.SecondsToPacked[timeToStartNotification]].time] - timeToStartNotification; -- e.g. user can say until Tuesday, meaning Tuesday after event IF (getSerious _ Lookup[getSeriousAfter]) # NIL THEN getSeriousTime _ Convert.CardFromRope[getSerious]*60; event _ NEW[EventRecord _ [ timeToStartNotification: timeToStartNotification, text: text, repeat: repeat, nextNotification: nextNotification, durationTime: durationTime, leadTime: leadTime, getSeriousAfter: getSeriousTime, message: Lookup[message], iconLabel: iconLabel, iconFlavor: Lookup[iconFlavor] ]]; FOR l: LIST OF Event _ eventList, l.rest UNTIL l = NIL DO e: Event = l.first; IF Rope.Equal[e.message, event.message, FALSE] AND Rope.Equal[e.text, event.text, FALSE] THEN { -- i.e. if an event already exists which differs only in start time, duration, icon label, etc. then this event is considered to replace the original e^ _ event^; EXIT; }; REPEAT FINISHED => eventList _ CONS[event, eventList]; ENDLOOP; }; AddEvent: PUBLIC ENTRY PROC [event: Event] = { -- for use by buttons eventList _ CONS[event, eventList]; }; <> eventMinderDisabled: BOOL _ FALSE; EventMinder: PROC = { DO EnterEventMinder[itIsNow]; Process.Pause[Process.SecondsToTicks[3]]; ENDLOOP; }; EnterEventMinder: PUBLIC ENTRY PROC [itIsNow: Packed] = { ENABLE UNWIND => NULL; now: PackedSeconds _ Tempus.PackedToSeconds[itIsNow]; IF eventMinderDisabled THEN RETURN; FOR el: LIST OF Event _ eventList, el.rest UNTIL el = NIL DO -- for each event. event: Event = el.first; startTime: PackedSeconds _ [event.timeToStartNotification - event.leadTime]; <> <> <> <<};>> IF now > startTime AND event.repeat # NIL THEN { -- repeating event. compute most recent startTime, otherwise, if duration specified, may think this event has lapsed and there may be a later time which would satisfy. t1: PackedSeconds _ event.timeToStartNotification; DO ENABLE { Tempus.Error, Tempus.Unintelligible => GOTO Bogus; }; t1 _ IF event.nextNotification # 0 THEN event.nextNotification ELSE ComputeRepetitionInterval[event.repeat, t1]; < nextNotification. Note that the latest time of notification before now may or may not cause the event to be posted, depending on whether or not there is a duration, and whether it has lapsed. >> IF t1 > now THEN {event.nextNotification _ t1; EXIT}; event.newStartTime _ TRUE; event.nextNotification _ [0]; event.timeToStartNotification _ startTime _ t1; REPEAT Bogus => LOOP; ENDLOOP; }; IF now > startTime THEN { <> event.justPretending _ (itIsNow # Tempus.defaultTime); IF event.newStartTime AND (event.durationTime = 0 OR now < startTime + event.durationTime) THEN { viewer: Viewer _ event.viewer; text: ROPE _ Rope.Cat[Tempus.MakeRope[], ".\n", event.text]; event.newStartTime _ FALSE; event.blink _ TRUE; IF viewer = NIL OR viewer.destroyed THEN { viewer _ ViewerTools.MakeNewTextViewer[ info: [ name: event.text, data: text, icon: IconRegistry.GetIcon[IF el.first.iconFlavor # NIL THEN el.first.iconFlavor ELSE "Remember.defaultIcon", IconRegistry.GetIcon["Remember.defaultIcon", document]]], -- uses el.first.iconFlavor if it can be found, otherwise Remember.defaultIcon otherwise document. The reason for the NIL check instead of just looking up NIL and letting it fail is that somebody actually managed to register an icon for NIL. paint: FALSE]; Menus.SetLine[menu: viewer.menu, line: Menus.GetNumberOfLines[viewer.menu], entryList: reminderButtons]; }; IF event.message # NIL THEN { IF walnutUser THEN { IF NOT WalnutDisplayerOps.StuffMsgContents[viewer, event.message] THEN ViewerTools.SetContents[viewer: viewer, contents: Rope.Cat[text, "\n(Could not find message: \"", event.message, "\")\n"], paint: FALSE] } ELSE IF peanutUser THEN { stream: IO.STREAM = IO.RIS[event.message]; fileName: ROPE = IO.GetTokenRope[stream].token; message: ROPE; fileAtom: ATOM = Atom.MakeAtom[fileName]; mailViewer: ViewerClasses.Viewer; mailDoc: TiogaOps.Ref; [] _ IO.GetChar[stream]; -- the extra space message _ IO.GetTokenRope[stream, EveryThing].token; TRUSTED {mailDoc _ LOOPHOLE[Atom.GetProp[atom: fileAtom, prop: $Root]]}; IF mailDoc # NIL THEN NULL ELSE IF (mailViewer _ ViewerOps.FindViewer[fileName]) # NIL THEN { mailDoc _ TiogaOps.ViewerDoc[mailViewer]; Atom.RemProp[atom: fileAtom, prop: $Root]; -- if a reminder is posted from a mail file which does not have a viewer, thereby caching the reminder, and then user opens a viewer, invalidate the cache because user might edit the viewer. In other words, cache is used only during those periods where no viewer is around, and hence it is known that user is not editing the mail file } ELSE Atom.PutProp[atom: fileAtom, prop: $Root, val: mailDoc _ TiogaExtraOps.GetFile[fileName ! FS.Error => CONTINUE]]; IF mailDoc = NIL THEN ViewerTools.SetContents[viewer: viewer, contents: Rope.Cat[text, "\n(Could not find mail file: ", fileName, ") ", message], paint: FALSE] ELSE { node: TiogaOps.Ref _ TiogaOps.FirstChild[mailDoc]; DO IF Rope.Equal[TiogaOps.GetRope[node], message] THEN { ENABLE UNWIND => TiogaOps.UnlockSel[]; TiogaOps.LockSel[]; TiogaOps.SaveSelB[]; TiogaOps.SaveSpanForPaste[startLoc: [node, 0], endLoc: TiogaOps.LastLocWithin[node]]; TiogaOps.SelectDocument[viewer: viewer, pendingDelete: TRUE]; TiogaOps.Paste[]; <> TiogaOps.Jump[viewer: viewer, loc: [TiogaOps.ViewerDoc[viewer], 0]]; viewer.newVersion _ FALSE; viewer.icon _ IconRegistry.GetIcon["Remember.defaultIcon", document]; TiogaOps.RestoreSelB[]; TiogaOps.UnlockSel[]; EXIT; } ELSE IF (node _ TiogaOps.Next[node]) = NIL THEN { text _ Rope.Cat[text, "\n(Could not find message: \"", message, "\"\n"]; text _ Rope.Cat[text, "in mail file: ", fileName, ")\n"]; ViewerTools.SetContents[viewer: viewer, contents: text, paint: FALSE]; EXIT; }; ENDLOOP; }; } ELSE ViewerTools.SetContents[viewer: viewer, contents: Rope.Cat[text, "\n(Walnut/Peanut not loaded, could not include message: ", event.message, ")\n"], paint: FALSE] ; }; IF event.iconLabel # NIL THEN ViewerOps.AddProp[viewer, $IconLabel, event.iconLabel]; ViewerOps.AddProp[viewer, $Remember, el.first]; -- for menus event.viewer _ viewer; ViewerOps.PaintViewer[viewer, all]; IF logEvents THEN { eventLogStream.PutF["(Following Reminder posted at %t.)\n", IO.time[itIsNow]]; SaveEvent[event, eventLogStream]; eventLogStream.Flush[]; }; }; IF event.durationTime # 0 -- 0 means forever AND now > startTime + event.durationTime THEN { IF event.justPretending THEN NULL ELSE IF event.repeat # NIL THEN TRUSTED { IF event.nextNotification = 0 THEN ERROR; event.timeToStartNotification _ event.nextNotification; event.newStartTime _ TRUE; Process.Detach[FORK Save[]]; } ELSE IF NOT event.destroyed THEN TRUSTED { event.destroyed _ TRUE; Process.Detach[FORK Save[]]; }; IF event.viewer # NIL AND NOT event.viewer.destroyed THEN -- destroy an existing viewer if a duration is specified and it has lapsed ViewerOps.DestroyViewer[event.viewer]; }; <<>> IF event.getSeriousAfter # 0 AND now > startTime + event.getSeriousAfter AND NOT event.destroyed AND NOT event.newStartTime THEN TRUSTED { IF event.viewer # NIL AND NOT event.viewer.destroyed AND event.viewer.iconic THEN -- waste the sucker [] _ CommandTool.DoCommand[commandLine: Rope.Cat["_ SpecialCache.NameIt[\"", event.viewer.name,"\"]"], parent: NIL]; MessageWindow.Append[Rope.Concat["Important! ", event.text], TRUE]; MessageWindow.Blink[]; }; <> IF event.viewer # NIL AND NOT event.viewer.destroyed AND event.viewer.iconic AND event.blink THEN { IF event.viewer.wy >= ViewerSpecs.openBottomY THEN { -- icon is not visible MessageWindow.Append[Rope.Concat["Reminder: ", event.text], TRUE]; MessageWindow.Blink[]; } ELSE ViewerOps.BlinkIcon[event.viewer]; }; }; ENDLOOP; }; EveryThing: IO.BreakProc = {RETURN[other]}; <> Save: PUBLIC ENTRY PROC = { OPEN IO; ENABLE UNWIND => NULL; stream: IO.STREAM = FS.StreamOpen[fileName: "RememberEvents.txt", accessOptions: write]; viewer: ViewerClasses.Viewer; now: PackedSeconds = Tempus.PackedToSeconds[]; newEventList: LIST OF Event _ NIL; compare: List.CompareProc = { e1, e2: Event; e1 _ NARROW[ref1]; e2 _ NARROW[ref2]; RETURN[IF e1.timeToStartNotification < e2.timeToStartNotification THEN less ELSE greater]; }; SaveOld["RememberEvents.txt", stream]; IO.SetLength[stream, 0]; FOR l: LIST OF Event _ eventList, l.rest UNTIL l = NIL DO event: Event _ l.first; <> IF event.repeat # NIL THEN NULL -- if this is a repeated event, can't purge it ELSE IF event.justPretending THEN NULL -- this event posted as a result of a justpretend ELSE IF event.destroyed -- reminder was posted and user has destroyed the viewer. the check for destroyed, rather than viewer.destroyed, is because save may be called as a result of the destroy operation, i.e. from WasAReminderDestroyed, in which case the viewer.destroyed has not yet been set to TRUE. OR (event.durationTime # 0 AND event.timeToStartNotification + event.durationTime < now) -- this is an old event and no longer interesting THEN { IF logEvents THEN { eventLogStream.PutF["(Following Event deleted at %t.)\n", IO.time[]]; SaveEvent[event, eventLogStream]; eventLogStream.Flush[]; }; LOOP; }; newEventList _ CONS[event, newEventList]; ENDLOOP; TRUSTED {eventList _ LOOPHOLE[List.Sort[list: LOOPHOLE[newEventList], compareProc: compare]]}; FOR l: LIST OF Event _ eventList, l.rest UNTIL l = NIL DO SaveEvent[l.first, stream]; ENDLOOP; stream.Close[]; IF (viewer _ ViewerOps.FindViewer["RememberEvents.txt"]) # NIL THEN ViewerOps.RestoreViewer[viewer]; }; SaveEvent: PROC [event: Event, stream: IO.STREAM] = { OPEN IO; timeToStartNotification: PackedSeconds _ event.timeToStartNotification; <> stream.PutF["%g\n", rope[Tempus.MakeRope[time: Tempus.SecondsToPacked[timeToStartNotification], includeDayOfWeek: TRUE]]]; IF event.repeat # NIL THEN stream.PutF["Repeat: %g\n", rope[event.repeat]]; IF event.durationTime # 0 THEN stream.PutF["Duration: %d\n", int[event.durationTime/60]]; IF event.leadTime # 0 THEN stream.PutF["LeadTime: %d\n", int[event.leadTime/60]]; IF event.getSeriousAfter # 0 THEN stream.PutF["NagTime: %d\n", int[event.getSeriousAfter/60]]; IF event.iconFlavor # NIL THEN stream.PutF["IconFlavor: \"%g\"\n", rope[event.iconFlavor]]; IF event.iconLabel # NIL THEN stream.PutF["IconLabel: \"%q\"\n", rope[event.iconLabel]]; IF event.message # NIL THEN stream.PutF["Message: \"%q\"\n", rope[event.message]]; stream.PutF["\"%q\"\n\n", rope[event.text]]; }; SaveOld: PROC [name: Rope.ROPE, stream: IO.STREAM] = { len: INT = IO.GetLength[stream]; dollarName: Rope.ROPE = Rope.Concat[name, "$"]; dollarStream: IO.STREAM = FS.StreamOpen[fileName: dollarName, accessOptions: create, createByteCount: len ! ANY => GOTO Out]; bufferSize: INT = 512; buffer: REF TEXT = NEW[TEXT[bufferSize]]; bytes: INT; IO.SetIndex[stream, 0]; WHILE (bytes _ stream.GetBlock[buffer]) > 0 DO dollarStream.PutBlock[buffer]; ENDLOOP; dollarStream.Close[]; EXITS Out => NULL; }; <> logEvents: BOOLEAN _ FALSE; eventLogStream: IO.STREAM _ NIL; defaultDuration: INT _ -1; defaultLeadTime: INT _ 0; KeyWordList: TYPE = LIST OF REF KeyWord; KeyWord: TYPE = RECORD [key: ROPE, defaults: ParameterList]; keyWordList: KeyWordList _ NIL; Options: UserProfile.ProfileChangedProc = { keyWords: Rope.ROPE; IF (logEvents _ UserProfile.Boolean["Remember.CreateLog", FALSE]) THEN { eventLogStream _ FS.StreamOpen[fileName: "Remember.log", accessOptions: append]; }; defaultLeadTime _ UserProfile.Number["Remember.LeadTime", 0]; defaultDuration _ UserProfile.Number["Remember.Duration", -1]; keyWords _ UserProfile.Token["Remember.KeyWords"]; keyWordList _ NIL; IF keyWords # NIL THEN { stream: IO.STREAM = IO.RIS[keyWords]; scratchStream: IO.STREAM; UNTIL IO.EndOf[stream] DO key, line: Rope.ROPE; line _ IO.GetLineRope[stream]; scratchStream _ IO.RIS[line, scratchStream]; key _ IO.GetTokenRope[scratchStream].token; IF key # NIL THEN keyWordList _ CONS[NEW[KeyWord _ [key, ReadParameters[scratchStream]]], keyWordList]; ENDLOOP; }; }; RegisterKeyWord: PUBLIC PROC [keyWord: ROPE, parameters: ParameterList] = { keyWordList _ CONS[NEW[KeyWord _ [keyWord, parameters]], keyWordList]; }; <> ComputeRepetitionInterval: PROCEDURE [r: Rope.ROPE, time: Tempus.PackedSeconds] RETURNS[Tempus.PackedSeconds] = { ENABLE Tempus.Error => ERROR Tempus.Unintelligible[rope: r, vicinity: -1, ec: ec]; t: Tempus.Packed = Tempus.SecondsToPacked[time]; RETURN[Tempus.PackedToSeconds[ IF Rope.Equal[r, "HOURLY", FALSE] THEN Tempus.Adjust[baseTime: t, hours: 1, precisionOfResult: minutes].time ELSE IF Rope.Equal[r, "DAILY", FALSE] THEN Tempus.Adjust[baseTime: t, days: 1, precisionOfResult: minutes].time ELSE IF Rope.Equal[r, "WEEKDAYS", FALSE] THEN Tempus.Adjust[baseTime: t, days: IF BasicTime.Unpack[t].weekday = Friday THEN 3 ELSE 1, precisionOfResult: minutes].time ELSE IF Rope.Equal[r, "WEEKLY", FALSE] THEN Tempus.Adjust[baseTime: t, days: 7, precisionOfResult: minutes].time ELSE IF Rope.Equal[r, "MONTHLY", FALSE] THEN Tempus.Adjust[baseTime: t, months: 1, precisionOfResult: minutes].time ELSE IF Rope.Equal[r, "YEARLY", FALSE] THEN Tempus.Adjust[baseTime: t, years: 1, precisionOfResult: minutes].time ELSE Tempus.Parse[baseTime: t, rope: r].time]]; }; ReadTimeRope: PROC [stream: IO.STREAM] RETURNS[ROPE] = { RETURN[IO.GetLineRope[stream]]; }; WasAReminderDestroyed: ViewerEvents.EventProc -- [viewer: ViewerClasses.Viewer, event: ViewerEvent] -- = TRUSTED { prop: REF ANY _ ViewerOps.FetchProp[viewer, $Remember]; IF prop # NIL THEN { event: Event = NARROW[prop]; IF event.destroyed THEN RETURN ELSE IF event.justPretending THEN { event.justPretending _ FALSE; event.newStartTime _ TRUE; event.viewer _ NIL; RETURN; } ELSE IF event.newStartTime THEN RETURN; -- e.g. reset via snooze alarm event.destroyed _ TRUE; IF event.repeat # NIL THEN { IF event.nextNotification = 0 THEN ERROR; event.timeToStartNotification _ event.nextNotification; }; Process.Detach[FORK Save[]]; -- rewrite reminder.txt }; }; CheckSavedFile: ViewerEvents.EventProc = { IF Rope.Equal[s1: viewer.name, s2: "RememberEvents.txt", case: FALSE] THEN [] _ Construct[]; }; CheckpointProc: Booting.CheckpointProc = { DisableEventMinder: ENTRY PROC = {eventMinderDisabled _ TRUE}; IF eventLogStream # NIL THEN { IO.Close[eventLogStream]; eventLogStream _ NIL; }; DisableEventMinder[]; }; RollbackProc: Booting.RollbackProc = { EnableEventMinder: ENTRY PROC = {eventMinderDisabled _ FALSE}; IF logEvents THEN eventLogStream _ FS.StreamOpen[fileName: "Remember.log", accessOptions: append]; [] _ Construct[]; EnableEventMinder[]; }; <> UserProfile.CallWhenProfileChanges[Options]; [] _ ViewerEvents.RegisterEventProc[proc: WasAReminderDestroyed, filter: $Text, event: destroy]; [] _ ViewerEvents.RegisterEventProc[CheckSavedFile, save, $Text, FALSE]; [] _ Construct[]; TRUSTED {Booting.RegisterProcs[c: CheckpointProc, r: RollbackProc]}; TRUSTED {Process.Detach[FORK EventMinder[]]}; END.